| Methods Summary |
|---|
| protected static final java.lang.String | canonicalURI(java.lang.String s)
if (s == null) return null;
StringBuffer result = new StringBuffer();
final int len = s.length();
int pos = 0;
while (pos < len) {
char c = s.charAt(pos);
if ( isPathSeparator(c) ) {
/*
* multiple path separators.
* 'foo///bar' -> 'foo/bar'
*/
while (pos+1 < len && isPathSeparator(s.charAt(pos+1))) {
++pos;
}
if (pos+1 < len && s.charAt(pos+1) == '.") {
/*
* a single dot at the end of the path - we are done.
*/
if (pos+2 >= len) break;
switch (s.charAt(pos+2)) {
/*
* self directory in path
* foo/./bar -> foo/bar
*/
case '/":
case '\\":
pos += 2;
continue;
/*
* two dots in a path: go back one hierarchy.
* foo/bar/../baz -> foo/baz
*/
case '.":
// only if we have exactly _two_ dots.
if (pos+3 < len && isPathSeparator(s.charAt(pos+3))) {
pos += 3;
int separatorPos = result.length()-1;
while (separatorPos >= 0 &&
! isPathSeparator(result
.charAt(separatorPos))) {
--separatorPos;
}
if (separatorPos >= 0)
result.setLength(separatorPos);
continue;
}
}
}
}
result.append(c);
++pos;
}
return result.toString();
|
| public void | checkOutputDir()
if (outputDir != null) {
if (!(new File(outputDir)).exists()) {
makeOutputDir();
}
} else {
createOutputDir();
}
|
| public void | compile()
createCompiler();
if (isPackagedTagFile || jspCompiler.isOutDated()) {
try {
jspCompiler.removeGeneratedFiles();
jspLoader = null;
jspCompiler.compile();
jsw.setReload(true);
jsw.setCompilationException(null);
} catch (JasperException ex) {
// Cache compilation exception
jsw.setCompilationException(ex);
throw ex;
} catch (Exception ex) {
JasperException je = new JasperException(
Localizer.getMessage("jsp.error.unable.compile"),
ex);
// Cache compilation exception
jsw.setCompilationException(je);
throw je;
}
}
|
| protected org.apache.jasper.compiler.Compiler | createCompiler(java.lang.String className)
Compiler compiler = null;
try {
compiler = (Compiler) Class.forName(className).newInstance();
} catch (InstantiationException e) {
log.warn(Localizer.getMessage("jsp.error.compiler"), e);
} catch (IllegalAccessException e) {
log.warn(Localizer.getMessage("jsp.error.compiler"), e);
} catch (NoClassDefFoundError e) {
if (log.isDebugEnabled()) {
log.debug(Localizer.getMessage("jsp.error.compiler"), e);
}
} catch (ClassNotFoundException e) {
if (log.isDebugEnabled()) {
log.debug(Localizer.getMessage("jsp.error.compiler"), e);
}
}
return compiler;
|
| public org.apache.jasper.compiler.Compiler | createCompiler()Create a "Compiler" object based on some init param data. This
is not done yet. Right now we're just hardcoding the actual
compilers that are created.
if (jspCompiler != null ) {
return jspCompiler;
}
jspCompiler = null;
if (options.getCompilerClassName() != null) {
jspCompiler = createCompiler(options.getCompilerClassName());
} else {
if (options.getCompiler() == null) {
jspCompiler = createCompiler("org.apache.jasper.compiler.JDTCompiler");
if (jspCompiler == null) {
jspCompiler = createCompiler("org.apache.jasper.compiler.AntCompiler");
}
} else {
jspCompiler = createCompiler("org.apache.jasper.compiler.AntCompiler");
if (jspCompiler == null) {
jspCompiler = createCompiler("org.apache.jasper.compiler.JDTCompiler");
}
}
}
if (jspCompiler == null) {
throw new IllegalStateException(Localizer.getMessage("jsp.error.compiler"));
}
jspCompiler.init(this, jsw);
return jspCompiler;
|
| protected void | createOutputDir()
String path = null;
if (isTagFile()) {
String tagName = tagInfo.getTagClassName();
path = tagName.replace('.", '/");
path = path.substring(0, path.lastIndexOf('/"));
} else {
path = getServletPackageName().replace('.", '/");
}
// Append servlet or tag handler path to scratch dir
try {
baseUrl = options.getScratchDir().toURL();
String outUrlString = baseUrl.toString() + '/" + path;
URL outUrl = new URL(outUrlString);
outputDir = outUrl.getFile() + File.separator;
if (!makeOutputDir()) {
throw new IllegalStateException(Localizer.getMessage("jsp.error.outputfolder"));
}
} catch (MalformedURLException e) {
throw new IllegalStateException(Localizer.getMessage("jsp.error.outputfolder"), e);
}
|
| public java.lang.String | getClassFileName()
if (classFileName == null) {
classFileName = getOutputDir() + getServletClassName() + ".class";
}
return classFileName;
|
| public java.lang.ClassLoader | getClassLoader()What class loader to use for loading classes while compiling
this JSP?
if( loader != null )
return loader;
return rctxt.getParentClassLoader();
|
| public java.lang.String | getClassPath()The classpath that is passed off to the Java compiler.
if( classPath != null )
return classPath;
return rctxt.getClassPath();
|
| public org.apache.jasper.compiler.Compiler | getCompiler()
return jspCompiler;
|
| public java.lang.String | getContentType()Get the content type of this JSP.
Content type includes content type and encoding.
return contentType;
|
| protected java.lang.String | getDerivedPackageName()
if (derivedPackageName == null) {
int iSep = jspUri.lastIndexOf('/");
derivedPackageName = (iSep > 0) ?
JspUtil.makeJavaPackage(jspUri.substring(1,iSep)) : "";
}
return derivedPackageName;
|
| public java.lang.String | getJavaPath()Path of the Java file relative to the work directory.
if (javaPath != null) {
return javaPath;
}
if (isTagFile()) {
String tagName = tagInfo.getTagClassName();
javaPath = tagName.replace('.", '/") + ".java";
} else {
javaPath = getServletPackageName().replace('.", '/") + '/" +
getServletClassName() + ".java";
}
return javaPath;
|
| public java.lang.String | getJspFile()Path of the JSP URI. Note that this is not a file name. This is
the context rooted URI of the JSP file.
return jspUri;
|
| public java.lang.ClassLoader | getJspLoader()
if( jspLoader == null ) {
jspLoader = new JasperLoader
(new URL[] {baseUrl},
getClassLoader(),
rctxt.getPermissionCollection(),
rctxt.getCodeSource());
}
return jspLoader;
|
| public Options | getOptions()Get hold of the Options object for this context.
return options;
|
| public java.lang.String | getOutputDir()The output directory to generate code into. The output directory
is make up of the scratch directory, which is provide in Options,
plus the directory derived from the package name.
if (outputDir == null) {
createOutputDir();
}
return outputDir;
|
| public java.lang.String | getRealPath(java.lang.String path)Gets the actual path of a URI relative to the context of
the compilation.
if (context != null) {
return context.getRealPath(path);
}
return path;
|
| public java.net.URL | getResource(java.lang.String res)
return context.getResource(canonicalURI(res));
|
| public java.io.InputStream | getResourceAsStream(java.lang.String res)Gets a resource as a stream, relative to the meanings of this
context's implementation.
return context.getResourceAsStream(canonicalURI(res));
|
| public java.util.Set | getResourcePaths(java.lang.String path)
return context.getResourcePaths(canonicalURI(path));
|
| public org.apache.jasper.compiler.JspRuntimeContext | getRuntimeContext()
return rctxt;
|
| public java.lang.String | getServletClassName()Just the class name (does not include package name) of the
generated class.
if (className != null) {
return className;
}
if (isTagFile) {
className = tagInfo.getTagClassName();
int lastIndex = className.lastIndexOf('.");
if (lastIndex != -1) {
className = className.substring(lastIndex + 1);
}
} else {
int iSep = jspUri.lastIndexOf('/") + 1;
className = JspUtil.makeJavaIdentifier(jspUri.substring(iSep));
}
return className;
|
| public javax.servlet.ServletContext | getServletContext()
return context;
|
| public java.lang.String | getServletJavaFileName()Full path name of the Java file into which the servlet is being
generated.
if (servletJavaFileName == null) {
servletJavaFileName = getOutputDir() + getServletClassName() + ".java";
}
return servletJavaFileName;
|
| public java.lang.String | getServletPackageName()Package name for the generated class is make up of the base package
name, which is user settable, and the derived package name. The
derived package name directly mirrors the file heirachy of the JSP page.
if (isTagFile()) {
String className = tagInfo.getTagClassName();
int lastIndex = className.lastIndexOf('.");
String pkgName = "";
if (lastIndex != -1) {
pkgName = className.substring(0, lastIndex);
}
return pkgName;
} else {
String dPackageName = getDerivedPackageName();
if (dPackageName.length() == 0) {
return basePackageName;
}
return basePackageName + '." + getDerivedPackageName();
}
|
| public java.net.URL | getTagFileJarUrl(java.lang.String tagFile)Returns the tag-file-name-to-JAR-file map of this compilation unit,
which maps tag file names to the JAR files in which the tag files are
packaged.
The map is populated when parsing the tag-file elements of the TLDs
of any imported taglibs.
return this.tagFileJarUrls.get(tagFile);
|
| public java.net.URL | getTagFileJarUrl()Returns the JAR file in which the tag file for which this
JspCompilationContext was created is packaged, or null if this
JspCompilationContext does not correspond to a tag file, or if the
corresponding tag file is not packaged in a JAR.
return this.tagFileJarUrl;
|
| public javax.servlet.jsp.tagext.TagInfo | getTagInfo()
return tagInfo;
|
| public java.lang.String[] | getTldLocation(java.lang.String uri)Gets the 'location' of the TLD associated with the given taglib 'uri'.
String[] location =
getOptions().getTldLocationsCache().getLocation(uri);
return location;
|
| public org.apache.jasper.compiler.ServletWriter | getWriter()Where is the servlet being generated?
return writer;
|
| public void | incrementRemoved()
if (removed == 0 && rctxt != null) {
rctxt.removeWrapper(jspUri);
}
removed++;
|
| public boolean | isErrorPage()Are we processing something that has been declared as an
errorpage?
return isErrPage;
|
| protected static final boolean | isPathSeparator(char c)
return (c == '/" || c == '\\");
|
| public boolean | isPrototypeMode()True if we are compiling a tag file in prototype mode.
ie we only generate codes with class for the tag handler with empty
method bodies.
return protoTypeMode;
|
| public boolean | isRemoved()
if (removed > 1 ) {
return true;
}
return false;
|
| public boolean | isTagFile()
return isTagFile;
|
| public boolean | keepGenerated()Are we keeping generated code around?
return getOptions().getKeepGenerated();
|
| public java.lang.Class | load()
try {
getJspLoader();
String name;
if (isTagFile()) {
name = tagInfo.getTagClassName();
} else {
name = getServletPackageName() + "." + getServletClassName();
}
servletClass = jspLoader.loadClass(name);
} catch (ClassNotFoundException cex) {
throw new JasperException(Localizer.getMessage("jsp.error.unable.load"),
cex);
} catch (Exception ex) {
throw new JasperException(Localizer.getMessage("jsp.error.unable.compile"),
ex);
}
removed = 0;
return servletClass;
|
| protected boolean | makeOutputDir()
synchronized(outputDirLock) {
File outDirFile = new File(outputDir);
return (outDirFile.exists() || outDirFile.mkdirs());
}
|
| public java.lang.String | resolveRelativeUri(java.lang.String uri)Get the full value of a URI relative to this compilations context
uses current file as the base.
// sometimes we get uri's massaged from File(String), so check for
// a root directory deperator char
if (uri.startsWith("/") || uri.startsWith(File.separator)) {
return uri;
} else {
return baseURI + uri;
}
|
| public void | setClassLoader(java.net.URLClassLoader loader)
this.loader = loader;
|
| public void | setClassPath(java.lang.String classPath)The classpath that is passed off to the Java compiler.
this.classPath = classPath;
|
| public void | setContentType(java.lang.String contentType)
this.contentType = contentType;
|
| public void | setErrorPage(boolean isErrPage)
this.isErrPage = isErrPage;
|
| public void | setPrototypeMode(boolean pm)
protoTypeMode = pm;
|
| public void | setServletClassName(java.lang.String className)
this.className = className;
|
| public void | setServletPackageName(java.lang.String servletPackageName)The package name into which the servlet class is generated.
this.basePackageName = servletPackageName;
|
| public void | setTagFileJarUrl(java.lang.String tagFile, java.net.URL tagFileURL)
this.tagFileJarUrls.put(tagFile, tagFileURL);
|
| public void | setTagInfo(javax.servlet.jsp.tagext.TagInfo tagi)
tagInfo = tagi;
|
| public void | setWriter(org.apache.jasper.compiler.ServletWriter writer)
this.writer = writer;
|
