Arrays.asList(PRIVATE_CACHED_DTD_RESOURCE_PATHS));
/**
- * Default URLs to download the pluging for Netscape and IE.
+ * Default URLs to download the plugin for Netscape and IE.
*/
public static final String NS_PLUGIN_URL =
"http://java.sun.com/products/plugin/";
private int checkInterval = 0;
/**
- * Is the generation of SMAP info for JSR45 debuggin suppressed?
+ * Is the generation of SMAP info for JSR45 debugging suppressed?
*/
private boolean isSmapSuppressed = false;
}
/**
- * Background JSP compile thread check intervall
+ * Background JSP compile thread check interval
*/
public int getCheckInterval() {
return checkInterval;
}
/**
- * Is the generation of SMAP info for JSR45 debuggin suppressed?
+ * Is the generation of SMAP info for JSR45 debugging suppressed?
*/
public boolean isSmapSuppressed() {
return isSmapSuppressed;
/**
* Base class for all exceptions generated by the JSP engine. Makes it
- * convienient to catch just this at the top-level.
+ * convenient to catch just this at the top-level.
*
* @author Anil K. Vijendran
*/
}
/**
- * Is the generation of SMAP info for JSR45 debuggin suppressed?
+ * Is the generation of SMAP info for JSR45 debugging suppressed?
*/
public boolean isSmapSuppressed() {
return smapSuppressed;
}
/**
- * Obtain JSP configuration informantion specified in web.xml.
+ * Obtain JSP configuration information specified in web.xml.
*/
public JspConfig getJspConfig() {
return jspConfig;
f = new File(fParent);
}
- // If there is no acceptible candidate, uriRoot will
+ // If there is no acceptable candidate, uriRoot will
// remain null to indicate to the CompilerContext to
// use the current working/user dir.
}
if (baseURI == null) {
baseURI = "/";
} else if (baseURI.charAt(0) != '/') {
- // strip the basde slash since it will be combined with the
+ // strip the base slash since it will be combined with the
// uriBase to generate a file
baseURI = "/" + baseURI;
}
*/
public String resolveRelativeUri(String uri) {
// sometimes we get uri's massaged from File(String), so check for
- // a root directory deperator char
+ // a root directory separator char
if (uri.startsWith("/") || uri.startsWith(File.separator)) {
return uri;
} else {
/**
* 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.
+ * derived package name directly mirrors the file hierarchy of the JSP page.
*/
public String getServletPackageName() {
if (isTagFile()) {
* 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
+ * A tag library is 'exposed' either explicitly in
+ * web.xml or implicitly via the uri tag in the TLD
* of a taglib deployed in a jar file (WEB-INF/lib).
*
* @return the instance of the TldLocationsCache
public boolean getFork();
/**
- * Obtain JSP configuration informantion specified in web.xml.
+ * Obtain JSP configuration information specified in web.xml.
*/
public JspConfig getJspConfig();
import org.apache.jasper.JasperException;
/**
- * Collect info about the page and nodes, and make them availabe through
+ * Collect info about the page and nodes, and make them available through
* the PageInfo object.
*
* @author Kin-man Chung
/**
* Determine if a compilation is necessary by checking the time stamp of the
* JSP page with that of the corresponding .class or .java file. If the page
- * has dependencies, the check is also extended to its dependeants, and so
- * on. This method can by overidden by a subclasses of Compiler.
+ * has dependencies, the check is also extended to its dependents, and so
+ * on. This method can by overridden by a subclasses of Compiler.
*
* @param checkClass
* If true, check against .class file, if false, check against
/**
* This class generates functions mappers for the EL expressions in the page.
- * Instead of a global mapper, a mapper is used for ecah call to EL
+ * Instead of a global mapper, a mapper is used for each call to EL
* evaluator, thus avoiding the prefix overlapping and redefinition
* issues.
*
}
/**
- * Generation of static initializers in preamble. For example, dependant
+ * Generation of static initializers in preamble. For example, dependent
* list, el function map, prefix map. (shared by servlet and tag handler
* preamble generation)
*/
// Create bean
/*
- * Check if bean is alredy there
+ * Check if bean is already there
*/
out.printin("if (");
out.print(name);
out.printil(" throws Throwable {");
out.pushIndent();
- // Initilaize local variables used in this method.
+ // Initialize local variables used in this method.
if (!isTagFile) {
out
.printil("PageContext pageContext = _jspx_page_context;");
StringBuilder sb = new StringBuilder("out.write(\"");
int initLength = sb.length();
int count = JspUtil.CHUNKSIZE;
- int srcLine = 0; // relative to starting srouce line
+ int srcLine = 0; // relative to starting source line
for (int i = 0; i < text.length(); i++) {
char ch = text.charAt(i);
--count;
/*
* Creates a tag variable name by concatenating the given prefix and
- * shortName and endcoded to make the resultant string a valid Java
+ * shortName and encoded to make the resultant string a valid Java
* Identifier.
*/
private String createTagVarName(String fullName, String prefix,
/**
* Provide a mechanism for Jasper to obtain a reference to the JarScanner
- * impementation.
+ * implementation.
*/
public class JarScannerFactory {
}
/**
- * Obtain the {@link JarScanner} associated with the specificed {@link
+ * Obtain the {@link JarScanner} associated with the specified {@link
* ServletContext}. It is obtained via a context parameter.
*/
public static JarScanner getJarScanner(ServletContext ctxt) {
extension = file.substring(file.indexOf('.')+1);
}
- // The url patterns are reconstructed as the follwoing:
+ // The url patterns are reconstructed as the following:
// path != null, extension == null: / or /foo/bar.ext
// path == null, extension != null: *.ext
// path != null, extension == "*": /foo/*
// Nesting level of Tag dependent bodies
private int tagDependentNesting = 0;
- // Flag set to delay incrmenting tagDependentNesting until jsp:body
+ // Flag set to delay incrementing tagDependentNesting until jsp:body
// is first encountered
private boolean tagDependentPending = false;
/**
* Unregister the source file.
* This method is used to implement file inclusion. Each included file
- * gets a uniq identifier (which is the index in the array of source
+ * gets a unique identifier (which is the index in the array of source
* files).
*
* @return The index of the now registered file.
return true;
}
// Note that although the current file is undefined here, "current"
- // is not set to null just for convience, for it maybe used to
+ // is not set to null just for convenience, for it maybe used to
// set the current (undefined) position.
return false;
}
* &060;%@include file="..."%&062; directive is used.
*
* A background thread periodically checks the files a JSP page
- * is dependent upon. If a dpendent file changes the JSP page
+ * is dependent upon. If a dependent file changes the JSP page
* which included it is recompiled.
*
* Only used if a web application context is a directory.
/**
* Get the SecurityManager Policy CodeSource for this web
- * applicaiton context.
+ * application context.
*
* @return CodeSource for JSP
*/
}
/**
- * Process a "destory" event for this web application context.
+ * Process a "destroy" event for this web application context.
*/
public void destroy() {
Iterator<JspServletWrapper> servlets = jsps.values().iterator();
/**
* Compute the canonical name from a Class instance. Note that a simple
- * replacment of '$' with '.' of a binary name would not work, as '$' is a
+ * replacement of '$' with '.' of a binary name would not work, as '$' is a
* legal Java Identifier character.
*
* @param c
import org.xml.sax.Attributes;
/**
- * An internal data representation of a JSP page or a JSP docuement (XML). Also
- * included here is a visitor class for tranversing nodes.
+ * An internal data representation of a JSP page or a JSP document (XML). Also
+ * included here is a visitor class for traversing nodes.
*
* @author Kin-man Chung
* @author Jan Luehe
/*
* Indicates whether an encoding has been explicitly specified in the
- * page's bom.
+ * page's dom.
*/
private boolean isBomPresent;
childInfo = new ChildInfo();
name = this.getAttributeValue("name");
if (name != null) {
- // Mandatary attribute "name" will be checked in Validator
+ // Mandatory attribute "name" will be checked in Validator
localName = name;
int index = name.indexOf(':');
if (index != -1) {
* Add a source to Java line mapping
*
* @param srcLine
- * The postion of the source line, relative to the line at
+ * The position of the source line, relative to the line at
* the start of this node. The corresponding java line is
* assumed to be consecutive, i.e. one more than the last.
*/
}
/***************************************************************************
- * Auxillary classes used in Node
+ * Auxiliary classes used in Node
*/
/**
}
/**
- * Perform miscellean checks after the nodes are visited.
+ * Perform miscellaneous checks after the nodes are visited.
*/
void postCheck() throws JasperException {
// Check that var.name-from-attributes has valid values.
* @param path
* the path for the tagfile
* @param tagFileJarUrl
- * the url for the Jar containign the tag file
+ * the url for the Jar containing the tag file
* @param tagLibInfo
* the TagLibraryInfo object associated with this TagInfo
* @return a TagInfo object assembled from the directives in the tag file.
try {
if (tripCount > 0) {
// When tripCount is greater than zero, a circular
- // dependency exists. The circularily dependant tag
+ // dependency exists. The circularly dependent tag
// file is compiled in prototype mode, to avoid infinite
// recursion.
wrapper.decTripCount();
}
- // Add the dependants for this tag file to its parent's
- // dependant list. The only reliable dependency information
+ // Add the dependents for this tag file to its parent's
+ // Dependent list. The only reliable dependency information
// can only be obtained from the tag instance.
try {
Object tagIns = tagClazz.newInstance();
/**
* Implements a phase of the translation that compiles (if necessary) the
* tag files used in a JSP files. The directives in the tag files are
- * assumed to have been proccessed and encapsulated as TagFileInfo in the
+ * assumed to have been processed and encapsulated as TagFileInfo in the
* CustomTag nodes.
*/
public void loadTagFiles(Compiler compiler, Node.Nodes page)
* the TLD, in case the tag file is specified relative to it @param jarFile
* The JAR file, in case the tag file is packaged in a JAR
*
- * @return TagInfo correspoding to tag file directives
+ * @return TagInfo corresponding to tag file directives
*/
private TagFileInfo createTagFileInfo(TreeNode elem, URL jarFileUrl)
throws JasperException {
}
/*
- * The following directis are ignored in text concatenation
+ * The following directives are ignored in text concatenation
*/
@Override
private ServletContext ctxt;
//*********************************************************************
- // Constructor and Initilizations
+ // Constructor and Initializations
/*
* Initializes the set of JARs that are known not to contain any TLDs
/**
* Performs validation on the page elements. Attributes are checked for
* mandatory presence, entry value validity, and consistency. As a side effect,
- * some page global value (such as those from page direcitves) are stored, for
+ * some page global value (such as those from page directives) are stored, for
* later use.
*
* @author Kin-man Chung
}
/*
- * The bodyconet of a SimpleTag cannot be JSP.
+ * The bodycontent of a SimpleTag cannot be JSP.
*/
if (n.implementsSimpleTag()
&& tagInfo.getBodyContent().equalsIgnoreCase(
}
}
if (tldAttrs[j].isDeferredValue()) {
- // The String litteral must be castable to what is declared as type
+ // The String literal must be castable to what is declared as type
// for the attribute
expectedType = tldAttrs[j].getExpectedTypeName();
}
/**
- * This interface allows the plugin author to make inqueries about the
+ * This interface allows the plugin author to make inquiries about the
* properties of the current tag, and to use Jasper resources to generate
* direct Java codes in place of tag handler invocations.
*/
/**
* Generate a declaration in the of the generated class. This can be
- * used to declare an innter class, a method, or a class variable.
+ * used to declare an inner class, a method, or a class variable.
* @param id An unique ID identifying the declaration. It is not
* part of the declaration, and is used to ensure that the
* declaration will only appear once. If this method is
String getConstantAttribute(String attribute);
/**
- * Generate codesto evaluate value of a attribute in the custom tag
+ * Generate codes to evaluate value of a attribute in the custom tag
* The codes is a Java expression.
* NOTE: Currently cannot handle attributes that are fragments.
* @param attribute The specified attribute
* Abandon optimization for this tag handler, and instruct
* Jasper to generate the tag handler calls, as usual.
* Should be invoked if errors are detected, or when the tag body
- * is deemed too compilicated for optimization.
+ * is deemed too complicated for optimization.
*/
void dontUseTagPlugin();
/**
* Clears the current contents of the buffer. Unlike clear(), this
- * mehtod will not throw an IOException if the buffer has already been
+ * method will not throw an IOException if the buffer has already been
* flushed. It merely clears the current content of the buffer and
* returns.
*
}
/**
- * Synchronize variables before fragment invokation
+ * Synchronize variables before fragment invocation
*/
public void syncBeforeInvoke() {
copyTagToPageScope(VariableInfo.NESTED);
* a servlet the opportunity to call
* <code>request.setCharacterEncoding()</code> first.</p>
*
- * @param request The servlet requset we are processing
+ * @param request The servlet request we are processing
*
* @exception ServletException if an invalid parameter value for the
* <code>jsp_precompile</code> parameter name is specified
/**
* Compile and load a prototype for the Tag file. This is needed
- * when compiling tag files with circular dependencies. A prototpe
+ * when compiling tag files with circular dependencies. A prototype
* (skeleton) with no dependencies on other other tag files is
* generated and compiled.
*/
ctxt.generateAttribute("charEncoding");
ctxt.generateJavaSource(";");
- //assign appropriate value tp the charset
+ //assign appropriate value to the charset
ctxt.generateJavaSource("if(null != " + charEncodingName + " " +
"&& !" + charEncodingName + ".equals(\"\")){");
ctxt.generateJavaSource(" " + charSetName + " = "
* Adapter class that wraps an <code>Enumeration</code> around a Java2
* collection classes object <code>Iterator</code> so that existing APIs
* returning Enumerations can easily run on top of the new collections.
- * Constructors are provided to easliy create such wrappers.
+ * Constructors are provided to easily create such wrappers.
*
* @author Craig R. McClanahan
* @version $Revision$ $Date$
// NOTE: Having an offset value other than zero means that there was
// an error in the last character read. In this case, we have
// skipped the read so we don't consume any bytes past the
- // error. By signalling the error on the next block read we
+ // error. By signaling the error on the next block read we
// allow the method to return the most valid characters that
// it can on the previous block read. -Ac
else {
* This class allows rewinding an inputStream by allowing a mark
* to be set, and the stream reset to that position. <strong>The
* class assumes that it needs to read one character per
- * invocation when it's read() method is inovked, but uses the
+ * invocation when it's read() method is invoked, but uses the
* underlying InputStream's read(char[], offset length) method--it
* won't buffer data read this way!</strong>
*
* Read configuration for the specified classloader.
*
* @param classLoader
- * @throws IOException Errot
+ * @throws IOException Error
*/
protected void readConfiguration(ClassLoader classLoader)
throws IOException {
/**
* Provides same information as default log format but on a single line to make
- * it easier to grep the logs. The only excpetion is stacktraces which are
- * always preceeded by whitespace to make it simple to skip them.
+ * it easier to grep the logs. The only exception is stacktraces which are
+ * always preceded by whitespace to make it simple to skip them.
*/
/*
* Date processing based on AccessLogValve.
}
try {
Formatter fmt=(Formatter)Class.forName(SIMPLE_FMT).newInstance();
- // it is also possible that the user modifed jre/lib/logging.properties -
+ // it is also possible that the user modified jre/lib/logging.properties -
// but that's really stupid in most cases
Logger root=Logger.getLogger("");
Handler handlers[]=root.getHandlers();
}
// from commons logging. This would be my number one reason why java.util.logging
- // is bad - design by comitee can be really bad ! The impact on performance of
+ // is bad - design by committee can be really bad ! The impact on performance of
// using java.util.logging - and the ugliness if you need to wrap it - is far
// worse than the unfriendly and uncommon default format for logs.
* </ol>
* The mapping of these log levels to the concepts used by the underlying
* logging system is implementation dependent.
- * The implemention should ensure, though, that this ordering behaves
+ * The implementation should ensure, though, that this ordering behaves
* as expected.</p>
*
* <p>Performance is often a logging concern.
* that corresponds to their logger of choice. This completely avoids any discovery
* problem, while still allowing the user to switch.
*
- * Note that this implementation is not just a wrapper arround JDK logging ( like
+ * Note that this implementation is not just a wrapper around JDK logging ( like
* the original commons-logging impl ). It adds 2 features - a simpler configuration
* ( which is in fact a subset of log4j.properties ) and a formatter that is
* less ugly.
* <strong>Usage:</strong> Set this property when Java is invoked
* and <code>LogFactory</code> will attempt to load a new instance
* of the given implementation class.
- * For example, running the following ant scriplet:
+ * For example, running the following ant scriptlet:
* <code><pre>
* <java classname="${test.runner}" fork="yes" failonerror="${test.failonerror}">
* ...
* <p>
* The returned string is of form "classname@hashcode", ie is the same as
* the return value of the Object.toString() method, but works even when
- * the specified object's class has overidden the toString method.
+ * the specified object's class has overridden the toString method.
*
* @param o may be null.
* @return a string of form classname@hashcode, or "null" if param o is null.
projects / tomcat7.0 / commitdiff