Package org.tp23.jasper.compiler

This package contains code that compiles the JSP pages.


Interface Summary
ClassDeclarationPhase When a generator implements ClassDeclarationPhase, its generate method will only be invoked while generating the servlet's class body and not during the service method phase.
DestroyMethodPhase If a generator needs to output things into the destroy() method of the generated servlet, it should implement DestroyMethodPhase
FileDeclarationPhase If a generator wants to output stuff at "file scope" in the generated servlet class, it should implement this interface.
Generator Interface that all generators implement.
InitMethodPhase If you want code generated into init() method, then implement this interface.
JavaCompiler If you want to plugin your own Java compiler, you probably want to write a class that implements this interface.
Mangler You can control attributes like classname, packagename etc by plugging in your own mangler.
ParseEventListener Interface for the JSP code generation backend.
ServiceMethodPhase If your generator needs to generate code into the jspService() method (which is very likely), it should implement this class.
StaticInitializerPhase Generators the need to generate code that end up being statically initialized need to implement this class.

Class Summary
BaseJspListener An abstract base class to make things easy during development.
BeanEndGenerator Deal with .
BeanGenerator Generate code for useBean.
BeanRepository Holds instances of {session, application, page}-scoped beans
CharDataGenerator CharDataGenerator generates the character data present in the JSP file.
ClassName Parse a .class file to figure out the name of the class from which it was generated.
CommandLineCompiler Overrides some methods so that we get the desired effects.
Compiler If you want to customize JSP compilation aspects, this class is something you should take a look at.
DeclarationGenerator Generator to deal with JSP declarations.
DumbParseEventListener Throwaway class that can be used for debugging during development etc.
EscapeUnicodeWriter Used to escape unicode characters with \ u's.
ExpressionGenerator Generator to deal with JSP expressions: <%= ...
ForwardGenerator Generator for
GetPropertyGenerator Generator for
IncludeGenerator Generator for
JakartaCommentGenerator Generates original "Jakarta"-style comments
JikesJavaCompiler A Plug-in class for specifying a 'jikes' compile.
JspCompiler JspCompiler is an implementation of Compiler with a funky code mangling and code generation scheme! The reason that it is both a sub-class of compiler and an implementation of mangler is because the isOutDated method that is overridden and the name mangulation both depend on the actual existance of other class and java files.
JspParseEventListener JSP code generator "backend".
JspReader JspReader is an input buffer for the JSP parser.
JspUtil This class has all the utility method(s).
MappedCharDataGenerator CharDataGenerator generates the character data present in the JSP file.
Mark Mark represents a point in the JSP input.
Parser The class that parses the JSP input and calls the right methods on the code generator backend.
PluginGenerator Generator for
ScriptletGenerator Generator for <% ....
ServletWriter This is what is used to generate servlets.
SetPropertyGenerator Generator for
StoredCharDataGenerator StoredCharDataGenerator generates HTML and other data present in JSP files to be stored/serialized into a .dat file.
SunJavaCompiler The default compiler.
TagBeginGenerator Custom tag support.
TagCache A simple cache to hold results of one-time evaluation for a custom tag.
TagEndGenerator Custom tag support.
TagLibraries A container for all tag libraries that have been imported using the taglib directive.
TagLibraryInfoImpl Implementation of the TagLibraryInfo class from the JSP spec.

Exception Summary
CompileException Class for parser exceptions.
ParseException Class for parser exceptions.

Package org.tp23.jasper.compiler Description

This package contains code that compiles the JSP pages. It has not had many modifications from the tomcat code but there are some. Notible differences are as follows

  • the package imports for the compiled JSPs
  • the base class of the JSP
  • the method signiture of the service method
  • the interfaces that the standard objects available to a JSP confirm to e.g. out, config