## org.apache.jasper
Class JspC

    java.lang.Object
      org.apache.jasper.JspC

All Implemented Interfaces:
  Options

    public class JspC

extends Object
implements Options

Shell for the jspc compiler. Handles all options associated with the command line and creates compilation contexts which it then compiles according to the specified options. This version can process files from a _single_ webapp at once, i.e. a single docbase can be specified. It can be used as an Ant task using:

       <taskdef classname="org.apache.jasper.JspC" name="jasper2" >
          <classpath>
              <pathelement location="${java.home}/../lib/tools.jar"/>
              <fileset dir="${ENV.CATALINA_HOME}/server/lib">
                  <include name="*.jar"/>
              </fileset>
              <fileset dir="${ENV.CATALINA_HOME}/common/lib">
                  <include name="*.jar"/>
              </fileset>
              <path refid="myjars"/>
           </classpath>
      </taskdef>

      <jasper2 verbose="0"
               package="my.package"
               uriroot="${webapps.dir}/${webapp.name}"
               webXmlFragment="${build.dir}/generated_web.xml"
               outputDir="${webapp.dir}/${webapp.name}/WEB-INF/src/my/package" />

Author:
  Danno Ferrin, Pierre Delisle, Costin Manolache

Field Summary
`static String` `DEFAULT_IE_CLASS_ID`

Constructor Summary
`JspC()`

Method Summary
`void` `execute()`
`void` `generateWebMapping(String file, JspCompilationContext clctxt)`
`boolean` `genStringAsByteArray()` Are text strings to be generated as byte arrays, if the page is unbuffered?
`boolean` `genStringAsCharArray()` Indicates whether text strings are to be generated as char arrays.
`int` `getCheckInterval()` Background compilation check intervals in seconds
`boolean` `getClassDebugInfo()` Should we include debug information in compiled class?
`String` `getClassPath()` What classpath should I use while compiling the servlets generated from JSP files?
`String` `getCompiler()` Compiler to use.
`String` `getCompilerSourceVM()` Compiler source VM, e.g.
`String` `getCompilerTargetVM()` The compiler target VM, e.g.
`boolean` `getDevelopment()` Is Jasper being used in development mode?
`int` `getDieLevel()`
`boolean` `getErrorOnUseBeanInvalidClassAttribute()` Returns true if Jasper issues a compilation error instead of a runtime Instantiation error if the class attribute specified in useBean action is invalid.
`boolean` `getFailOnError()`
`boolean` `getFork()` boolean flag to tell Ant whether to fork JSP page compilations.
`String` `getIeClassId()` Gets the class-id value that is sent to Internet Explorer when using tags.
`int` `getInitialCapacity()` Gets initial capacity of HashMap which maps JSPs to their corresponding servlets.
`String` `getJavaEncoding()` Returns the encoding to use for java files.
`List<JasperException>` `getJSPCompilationErrors()` Gets the list of JSP compilation errors caught during the most recent invocation of this instance's `execute` method when failOnError has been set to FALSE.
`String` `getJspCompilerPath()`
`Class` `getJspCompilerPlugin()`
`JspConfig` `getJspConfig()` Obtain JSP configuration informantion specified in web.xml.
`boolean` `getKeepGenerated()` Are we keeping generated code around?
`boolean` `getMappedFile()` Are we supporting HTML mapped servlets?
`int` `getModificationTestInterval()` Modification test interval.
`Object` `getProtectionDomain()`
`boolean` `getSaveBytecode()` If class files are generated as byte arrays, should they be saved to disk at the end of compilations?
`File` `getScratchDir()` What is my scratch dir?
`boolean` `getSendErrorToClient()` Should errors be sent to client or thrown into stderr?
`String` `getSystemClassPath()` Gets the system class path.
`TagPluginManager` `getTagPluginManager()` Obtain a Tag Plugin Manager
`int` `getTagPoolSize()`
`TldLocationsCache` `getTldLocationsCache()` The cache for the location of the TLD's for the various tag libraries 'exposed' by the web application.
`boolean` `getTrimSpaces()` Should white spaces between directives or actions be trimmed?
`boolean` `getUsePrecompiled()` Returns the value of the usePrecompiled (or use-precompiled) init param.
`boolean` `isDefaultBufferNone()` If the buffer attribute for the page directive is not specified, is the default "none"?
`boolean` `isPoolingEnabled()` Returns true if tag handler pooling is enabled, false otherwise.
`boolean` `isSmapDumped()` Should SMAP info for JSR45 debugging be dumped to a file?
`boolean` `isSmapSuppressed()` Is the generation of SMAP info for JSR45 debugging suppressed?
`boolean` `isValidationEnabled()`
`boolean` `isXpoweredBy()` Is generation of X-Powered-By response header enabled/disabled?
`static void` `main(String[] arg)`
`protected void` `mergeIntoWebXml()` Include the generated web.xml inside the webapp's web.xml.
`void` `scanFiles(File base)` Locate all jsp files in the webapp.
`void` `setAddWebXmlMappings(boolean b)`
`void` `setArgs(String[] arg)`
`void` `setClassDebugInfo(boolean b)`
`void` `setClassName(String p)` Class name of the generated file ( without package ).
`void` `setClassPath(String s)`
`void` `setCompile(boolean b)`
`void` `setCompiler(String c)`
`void` `setCompilerSourceVM(String vm)`
`void` `setCompilerTargetVM(String vm)`
`void` `setDefaultBufferNone()`
`static void` `setDtdResourcePrefix(String prefix)` Sets the path prefix for .dtd resources
`void` `setErrorOnUseBeanInvalidClassAttribute(boolean b)`
`void` `setFailOnError(boolean b)` Set the option that throws an exception in case of a compilation error.
`void` `setGenStringAsByteArray(boolean genStringAsCharArray)`
`void` `setGenStringAsCharArray(boolean genStringAsCharArray)` Determines whether text strings are to be generated as char arrays, which improves performance in some cases.
`void` `setIeClassId(String ieClassId)` Sets the class-id value to be sent to Internet Explorer when using tags.
`void` `setIgnoreJspFragmentErrors(boolean ignore)`
`void` `setIsValidationEnabled(boolean b)`
`void` `setJavaEncoding(String encodingName)` Sets the encoding to use for java files.
`void` `setJspFiles(String jspFiles)`
`void` `setListErrors(boolean b)`
`void` `setOutputDir(String s)`
`void` `setPackage(String p)`
`void` `setPoolingEnabled(boolean poolingEnabled)`
`static void` `setSchemaResourcePrefix(String prefix)` Sets the path prefix for .xsd resources
`void` `setSmapDumped(boolean smapDumped)` Set smapSuppressed flag.
`void` `setSmapSuppressed(boolean smapSuppressed)` Set smapSuppressed flag.
`void` `setSystemClassPath(String s)` Sets the system class path.
`void` `setTrimSpaces(boolean ts)`
`void` `setUriroot(String s)` Base dir for the webapp.
`void` `setValidateXml(boolean b)`
`void` `setVerbose(int level)`
`void` `setWebXml(String s)` File where we generate a complete web.xml with the class definitions.
`void` `setWebXmlFragment(String s)` File where we generate a web.xml fragment with the class definitions.
`void` `setXpoweredBy(boolean xpoweredBy)`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### DEFAULT_IE_CLASS_ID

    public static final String DEFAULT_IE_CLASS_ID

See Also:
  Constant Field Values

Constructor Detail

### JspC

    public JspC()

Method Detail

### main

    public static void main(String[] arg)

### setArgs

    public void setArgs(String[] arg)
                 throws JasperException

  Throws:
    `JasperException`

### getDieLevel

    public int getDieLevel()

### getKeepGenerated

    public boolean getKeepGenerated()

  Description copied from interface: `Options`
  Are we keeping generated code around?

  Specified by:
    `getKeepGenerated` in interface `Options`

### getSaveBytecode

    public boolean getSaveBytecode()

  Description copied from interface: `Options`
  If class files are generated as byte arrays, should they be saved to disk at the end of compilations?

  Specified by:
    `getSaveBytecode` in interface `Options`

### getTrimSpaces

    public boolean getTrimSpaces()

  Description copied from interface: `Options`
  Should white spaces between directives or actions be trimmed?

  Specified by:
    `getTrimSpaces` in interface `Options`

### setTrimSpaces

    public void setTrimSpaces(boolean ts)

### isPoolingEnabled

    public boolean isPoolingEnabled()

  Description copied from interface: `Options`
  Returns true if tag handler pooling is enabled, false otherwise.

  Specified by:
    `isPoolingEnabled` in interface `Options`

### setPoolingEnabled

    public void setPoolingEnabled(boolean poolingEnabled)

### isXpoweredBy

    public boolean isXpoweredBy()

  Description copied from interface: `Options`
  Is generation of X-Powered-By response header enabled/disabled?

  Specified by:
    `isXpoweredBy` in interface `Options`

### setXpoweredBy

    public void setXpoweredBy(boolean xpoweredBy)

### getErrorOnUseBeanInvalidClassAttribute

    public boolean getErrorOnUseBeanInvalidClassAttribute()

  Description copied from interface: `Options`
  Returns true if Jasper issues a compilation error instead of a runtime Instantiation error if the class attribute specified in useBean action is invalid.

  Specified by:
    `getErrorOnUseBeanInvalidClassAttribute` in interface `Options`

### setErrorOnUseBeanInvalidClassAttribute

    public void setErrorOnUseBeanInvalidClassAttribute(boolean b)

### getTagPoolSize

    public int getTagPoolSize()

### getInitialCapacity

    public int getInitialCapacity()

  Gets initial capacity of HashMap which maps JSPs to their corresponding servlets.

  Specified by:
    `getInitialCapacity` in interface `Options`

### getMappedFile

    public boolean getMappedFile()

  Are we supporting HTML mapped servlets?

  Specified by:
    `getMappedFile` in interface `Options`

### getProtectionDomain

    public Object getProtectionDomain()

### getSendErrorToClient

    public boolean getSendErrorToClient()

  Description copied from interface: `Options`
  Should errors be sent to client or thrown into stderr?

  Specified by:
    `getSendErrorToClient` in interface `Options`

### setClassDebugInfo

    public void setClassDebugInfo(boolean b)

### getClassDebugInfo

    public boolean getClassDebugInfo()

  Description copied from interface: `Options`
  Should we include debug information in compiled class?

  Specified by:
    `getClassDebugInfo` in interface `Options`

### getCheckInterval

    public int getCheckInterval()

  Background compilation check intervals in seconds

  Specified by:
    `getCheckInterval` in interface `Options`

### getModificationTestInterval

    public int getModificationTestInterval()

  Modification test interval.

  Specified by:
    `getModificationTestInterval` in interface `Options`

### getDevelopment

    public boolean getDevelopment()

  Is Jasper being used in development mode?

  Specified by:
    `getDevelopment` in interface `Options`

### getUsePrecompiled

    public boolean getUsePrecompiled()

  Description copied from interface: `Options`
  Returns the value of the usePrecompiled (or use-precompiled) init param.

  Specified by:
    `getUsePrecompiled` in interface `Options`

### isSmapSuppressed

    public boolean isSmapSuppressed()

  Is the generation of SMAP info for JSR45 debugging suppressed?

  Specified by:
    `isSmapSuppressed` in interface `Options`

### setSmapSuppressed

    public void setSmapSuppressed(boolean smapSuppressed)

  Set smapSuppressed flag.

### isSmapDumped

    public boolean isSmapDumped()

  Should SMAP info for JSR45 debugging be dumped to a file?

  Specified by:
    `isSmapDumped` in interface `Options`

### setSmapDumped

    public void setSmapDumped(boolean smapDumped)

  Set smapSuppressed flag.

### setGenStringAsCharArray

    public void setGenStringAsCharArray(boolean genStringAsCharArray)

  Determines whether text strings are to be generated as char arrays, which improves performance in some cases.

  Parameters:
    `genStringAsCharArray` - true if text strings are to be generated as char arrays, false otherwise

### genStringAsCharArray

    public boolean genStringAsCharArray()

  Indicates whether text strings are to be generated as char arrays.

  Specified by:
    `genStringAsCharArray` in interface `Options`
  Returns:
    true if text strings are to be generated as char arrays, false otherwise

### setGenStringAsByteArray

    public void setGenStringAsByteArray(boolean genStringAsCharArray)

### genStringAsByteArray

    public boolean genStringAsByteArray()

  Description copied from interface: `Options`
  Are text strings to be generated as byte arrays, if the page is unbuffered?

  Specified by:
    `genStringAsByteArray` in interface `Options`

### isDefaultBufferNone

    public boolean isDefaultBufferNone()

  Description copied from interface: `Options`
  If the buffer attribute for the page directive is not specified, is the default "none"?

  Specified by:
    `isDefaultBufferNone` in interface `Options`

### setDefaultBufferNone

    public void setDefaultBufferNone()

### setIeClassId

    public void setIeClassId(String ieClassId)

  Sets the class-id value to be sent to Internet Explorer when using tags.

  Parameters:
    `ieClassId` - Class-id value

### getIeClassId

    public String getIeClassId()

  Gets the class-id value that is sent to Internet Explorer when using tags.

  Specified by:
    `getIeClassId` in interface `Options`
  Returns:
    Class-id value

### getScratchDir

    public File getScratchDir()

  Description copied from interface: `Options`
  What is my scratch dir?

  Specified by:
    `getScratchDir` in interface `Options`

### getJspCompilerPlugin

    public Class getJspCompilerPlugin()

### getJspCompilerPath

    public String getJspCompilerPath()

### getCompiler

    public String getCompiler()

  Compiler to use.

  Specified by:
    `getCompiler` in interface `Options`

### setCompiler

    public void setCompiler(String c)

### getCompilerTargetVM

    public String getCompilerTargetVM()

  Description copied from interface: `Options`
  The compiler target VM, e.g. 1.1, 1.2, 1.3, 1.4, or 1.5.

  Specified by:
    `getCompilerTargetVM` in interface `Options`
  See Also:
    `Options.getCompilerTargetVM()`

### setCompilerTargetVM

    public void setCompilerTargetVM(String vm)

### getCompilerSourceVM

    public String getCompilerSourceVM()

  Description copied from interface: `Options`
  Compiler source VM, e.g. 1.3, 1.4, or 1.5.

  Specified by:
    `getCompilerSourceVM` in interface `Options`
  See Also:
    `Options#getCompilerSourceVM.`

### setCompilerSourceVM

    public void setCompilerSourceVM(String vm)

  See Also:
    `Options#getCompilerSourceVM.`

### getTldLocationsCache

    public TldLocationsCache getTldLocationsCache()

  Description copied from interface: `Options`
  The cache for the location of the TLD's for the various tag libraries 'exposed' by the web application. A tag library is 'exposed' either explicitely in web.xml or implicitely via the uri tag in the TLD of a taglib deployed in a jar file (WEB-INF/lib).

  Specified by:
    `getTldLocationsCache` in interface `Options`
  Returns:
    the instance of the TldLocationsCache for the web-application.

### getJavaEncoding

    public String getJavaEncoding()

  Returns the encoding to use for java files. The default is UTF-8.

  Specified by:
    `getJavaEncoding` in interface `Options`
  Returns:
    String The encoding

### setJavaEncoding

    public void setJavaEncoding(String encodingName)

  Sets the encoding to use for java files.

  Parameters:
    `encodingName` - The name, e.g. "UTF-8"

### getFork

    public boolean getFork()

  Description copied from interface: `Options`
  boolean flag to tell Ant whether to fork JSP page compilations.

  Specified by:
    `getFork` in interface `Options`

### getClassPath

    public String getClassPath()

  Description copied from interface: `Options`
  What classpath should I use while compiling the servlets generated from JSP files?

  Specified by:
    `getClassPath` in interface `Options`

### setClassPath

    public void setClassPath(String s)

### getSystemClassPath

    public String getSystemClassPath()

  Gets the system class path.

  Specified by:
    `getSystemClassPath` in interface `Options`
  Returns:
    The system class path

### setSystemClassPath

    public void setSystemClassPath(String s)

  Sets the system class path.

  Parameters:
    `s` - The system class path to use

### setUriroot

    public void setUriroot(String s)

  Base dir for the webapp. Used to generate class names and resolve includes

### setSchemaResourcePrefix

    public static void setSchemaResourcePrefix(String prefix)

  Sets the path prefix for .xsd resources

### setDtdResourcePrefix

    public static void setDtdResourcePrefix(String prefix)

  Sets the path prefix for .dtd resources

### setJspFiles

    public void setJspFiles(String jspFiles)

### setCompile

    public void setCompile(boolean b)

### setVerbose

    public void setVerbose(int level)

### setValidateXml

    public void setValidateXml(boolean b)

### setIsValidationEnabled

    public void setIsValidationEnabled(boolean b)

### isValidationEnabled

    public boolean isValidationEnabled()

  Specified by:
    `isValidationEnabled` in interface `Options`

### setListErrors

    public void setListErrors(boolean b)

### setOutputDir

    public void setOutputDir(String s)

### setPackage

    public void setPackage(String p)

### setClassName

    public void setClassName(String p)

  Class name of the generated file ( without package ). Can only be used if a single file is converted. XXX Do we need this feature ?

### setWebXmlFragment

    public void setWebXmlFragment(String s)

  File where we generate a web.xml fragment with the class definitions.

### setWebXml

    public void setWebXml(String s)

  File where we generate a complete web.xml with the class definitions.

### setAddWebXmlMappings

    public void setAddWebXmlMappings(boolean b)

### setFailOnError

    public void setFailOnError(boolean b)

  Set the option that throws an exception in case of a compilation error.

### getFailOnError

    public boolean getFailOnError()

### setIgnoreJspFragmentErrors

    public void setIgnoreJspFragmentErrors(boolean ignore)

### getJspConfig

    public JspConfig getJspConfig()

  Obtain JSP configuration informantion specified in web.xml.

  Specified by:
    `getJspConfig` in interface `Options`

### getTagPluginManager

    public TagPluginManager getTagPluginManager()

  Description copied from interface: `Options`
  Obtain a Tag Plugin Manager

  Specified by:
    `getTagPluginManager` in interface `Options`

### generateWebMapping

    public void generateWebMapping(String file,
                                   JspCompilationContext clctxt)
                            throws IOException

  Throws:
    `IOException`

### getJSPCompilationErrors

    public List<JasperException> getJSPCompilationErrors()

  Gets the list of JSP compilation errors caught during the most recent invocation of this instance's `execute` method when failOnError has been set to FALSE. Each error error in the list is represented by an instance of org.apache.jasper.JasperException.

  Returns:
    List of JSP compilation errors caught during most recent invocation of this instance's `execute` method, or an empty list if no errors were encountered or this instance's failOnError property was set to TRUE

### mergeIntoWebXml

    protected void mergeIntoWebXml()
                            throws IOException

  Include the generated web.xml inside the webapp's web.xml.

  Throws:
    `IOException`

### scanFiles

    public void scanFiles(File base)
                   throws JasperException

  Locate all jsp files in the webapp. Used if no explicit jsps are specified.

  Throws:
    `JasperException`

### execute

    public void execute()
                 throws JasperException

  Throws:
    `JasperException`

Copyright © 2008 Mort Bay Consulting. All Rights Reserved.