Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You under the Apache License, Version 2.0
    * (the "License"); you may not use this file except in compliance with
    * the License.  You may obtain a copy of the License at
    * 
    *      http://www.apache.org/licenses/LICENSE-2.0
   * 
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package org.apache.jasper.compiler;
  
  import static org.jboss.web.JasperMessages.MESSAGES;
  
  import java.util.Vector;
  
  
This class has all the utility method(s). Ideally should move all the bean containers here.

Author(s):
Mandar Raje.
Rajiv Mordani.
Danno Ferrin
Pierre Delisle
Shawn Bayern
Mark Roth
  
  public class JspUtil {
  
      private static final String WEB_INF_TAGS = "/WEB-INF/tags/";
      private static final String META_INF_TAGS = "/META-INF/tags/";
  
      // Delimiters for request-time expressions (JSP and XML syntax)
      private static final String OPEN_EXPR  = "<%=";
      private static final String CLOSE_EXPR = "%>";
      private static final String OPEN_EXPR_XML  = "%=";
      private static final String CLOSE_EXPR_XML = "%";
  
      //private static ExpressionEvaluatorImpl expressionEvaluator
      //= new ExpressionEvaluatorImpl();
      
      //tc6
      //private final static ExpressionEvaluator expressionEvaluator =
      //    new ExpressionEvaluatorImpl(ExpressionFactory.newInstance());
  
      private static final String javaKeywords[] = {
          "abstract""assert""boolean""break""byte""case",
          "catch""char""class""const""continue",
          "default""do""double""else""enum""extends",
          "final""finally""float""for""goto",
          "if""implements""import""instanceof""int",
          "interface""long""native""new""package",
          "private""protected""public""return""short",
          "static""strictfp""super""switch""synchronized",
          "this""throw""throws""transient""try""void",
          "volatile""while" };
  
      public static final int CHUNKSIZE = 1024;
          
      public static char[] removeQuotes(char []chars) {
          CharArrayWriter caw = new CharArrayWriter();
          for (int i = 0; i < chars.lengthi++) {
              if (chars[i] == '%' && chars[i+1] == '\\' &&
                  chars[i+2] == '>') {
                  caw.write('%');
                  caw.write('>');
                  i = i + 2;
              } else {
                  caw.write(chars[i]);
              }
          }
          return caw.toCharArray();
      }
  
      public static char[] escapeQuotes (char []chars) {
          // Prescan to convert %\> to %>
          String s = new String(chars);
          while (true) {
              int n = s.indexOf("%\\>");
             if (n < 0)
                 break;
             StringBuilder sb = new StringBuilder(s.substring(0, n));
             sb.append("%>");
             sb.append(s.substring(n + 3));
             s = sb.toString();
         }
         chars = s.toCharArray();
         return (chars);
 
 
         // Escape all backslashes not inside a Java string literal
         /*
         CharArrayWriter caw = new CharArrayWriter();
         boolean inJavaString = false;
         for (int i = 0; i < chars.length; i++) {
             if (chars[i] == '"') inJavaString = !inJavaString;
             // escape out the escape character
             if (!inJavaString && (chars[i] == '\\')) caw.write('\\');
             caw.write(chars[i]);
         }
         return caw.toCharArray();
         */
     }

    
Checks if the token is a runtime expression. In standard JSP syntax, a runtime expression starts with '<%' and ends with '%>'. When the JSP document is in XML syntax, a runtime expression starts with '%=' and ends with '%'.

Parameters:
token The token to be checked return whether the token is a runtime expression or not.
 
     public static boolean isExpression(String tokenboolean isXml) {
     String openExpr;
     String closeExpr;
     if (isXml) {
         openExpr = ;
         closeExpr = ;
     } else {
         openExpr = ;
         closeExpr = ;
     }
     if (token.startsWith(openExpr) && token.endsWith(closeExpr)) {
         return true;
     } else {
         return false;
     }
     }

    

Returns:
the "expression" part of a runtime expression, taking the delimiters out.
 
     public static String getExpr (String expressionboolean isXml) {
     String returnString;
     String openExpr;
     String closeExpr;
     if (isXml) {
         openExpr = ;
         closeExpr = ;
     } else {
         openExpr = ;
         closeExpr = ;
     }
     int length = expression.length();
     if (expression.startsWith(openExpr) && 
                 expression.endsWith(closeExpr)) {
         returnString = expression.substring(
                                openExpr.length(), length - closeExpr.length());
     } else {
         returnString = "";
     }
     return returnString;
     }

    
Takes a potential expression and converts it into XML form
 
     public static String getExprInXml(String expression) {
         String returnString;
         int length = expression.length();
 
         if (expression.startsWith(
                 && expression.endsWith()) {
             returnString = expression.substring (1, length - 1);
         } else {
             returnString = expression;
         }
 
         return escapeXml(returnString);
     }

    
Checks to see if the given scope is valid.

Parameters:
scope The scope to be checked
n The Node containing the 'scope' attribute whose value is to be checked
err error dispatcher
Throws:
org.apache.jasper.JasperException if scope is not null and different from "page", "request", "session", and "application"
 
     public static void checkScope(String scopeNode nErrorDispatcher err)
             throws JasperException {
     if (scope != null && !scope.equals("page") && !scope.equals("request")
         && !scope.equals("session") && !scope.equals("application")) {
         err.jspError(n.getStart(), .invalidScope(scope));
     }
     }

    
Checks if all mandatory attributes are present and if all attributes present have valid names. Checks attributes specified as XML-style attributes as well as attributes specified using the jsp:attribute standard action.
 
     public static void checkAttributes(String typeOfTag,
                        Node n,
                        ValidAttribute[] validAttributes,
                        ErrorDispatcher err)
                 throws JasperException {
         Attributes attrs = n.getAttributes();
         Mark start = n.getStart();
     boolean valid = true;
 
         // AttributesImpl.removeAttribute is broken, so we do this...
         int tempLength = (attrs == null) ? 0 : attrs.getLength();
     Vector temp = new Vector(tempLength, 1);
         for (int i = 0; i < tempLengthi++) {
             String qName = attrs.getQName(i);
             if ((!qName.equals("xmlns")) && (!qName.startsWith("xmlns:")))
                 temp.addElement(qName);
         }
 
         // Add names of attributes specified using jsp:attribute
         Node.Nodes tagBody = n.getBody();
         iftagBody != null ) {
             int numSubElements = tagBody.size();
             forint i = 0; i < numSubElementsi++ ) {
                 Node node = tagBody.getNodei );
                 ifnode instanceof Node.NamedAttribute ) {
                     String attrName = node.getAttributeValue"name" );
                     temp.addElementattrName );
             // Check if this value appear in the attribute of the node
             if (n.getAttributeValue(attrName) != null) {
             err.jspError(n.getStart(), .duplicateAttribute(attrName));
             }
                 }
                 else {
                     // Nothing can come before jsp:attribute, and only
                     // jsp:body can come after it.
                     break;
                 }
             }
         }
 
     /*
      * First check to see if all the mandatory attributes are present.
      * If so only then proceed to see if the other attributes are valid
      * for the particular tag.
      */
     String missingAttribute = null;
 
     for (int i = 0; i < validAttributes.lengthi++) {
         int attrPos;    
         if (validAttributes[i].) {
                 attrPos = temp.indexOf(validAttributes[i].);
         if (attrPos != -1) {
             temp.remove(attrPos);
             valid = true;
         } else {
             valid = false;
             missingAttribute = validAttributes[i].;
             break;
         }
         }
     }
 
     // If mandatory attribute is missing then the exception is thrown
     if (!valid)
         err.jspError(start.missingMandatoryAttribute(typeOfTagmissingAttribute));
 
     // Check to see if there are any more attributes for the specified tag.
         int attrLeftLength = temp.size();
     if (attrLeftLength == 0)
         return;
 
     // Now check to see if the rest of the attributes are valid too.
     String attribute = null;
 
     for (int j = 0; j < attrLeftLengthj++) {
         valid = false;
         attribute = (Stringtemp.elementAt(j);
         for (int i = 0; i < validAttributes.lengthi++) {
         if (attribute.equals(validAttributes[i].)) {
             valid = true;
             break;
         }
         }
         if (!valid)
         err.jspError(start.invalidAttribute(typeOfTagattribute));
     }
     // XXX *could* move EL-syntax validation here... (sb)
     }
     
     public static String escapeQueryString(String unescString) {
     if ( unescString == null )
         return null;
     
     String escString    = "";
     String shellSpChars = "\\\"";
     
     for(int index=0; index<unescString.length(); index++) {
         char nextChar = unescString.charAt(index);
         
         ifshellSpChars.indexOf(nextChar) != -1 )
         escString += "\\";
         
         escString += nextChar;
     }
     return escString;
     }
 
    
Escape the 5 entities defined by XML.
 
     public static String escapeXml(String s) {
         if (s == nullreturn null;
         StringBuilder sb = new StringBuilder();
         for(int i=0; i<s.length(); i++) {
             char c = s.charAt(i);
             if (c == '<') {
                 sb.append("&lt;");
             } else if (c == '>') {
                 sb.append("&gt;");
             } else if (c == '\'') {
                 sb.append("&apos;");
             } else if (c == '&') {
                 sb.append("&amp;");
             } else if (c == '"') {
                 sb.append("&quot;");
             } else {
                 sb.append(c);
             }
         }
         return sb.toString();
     }

    
Replaces any occurrences of the character replace with the string with.
 
     public static String replace(String namechar replaceString with) {
     StringBuilder buf = new StringBuilder();
     int begin = 0;
     int end;
     int last = name.length();
 
     while (true) {
         end = name.indexOf(replacebegin);
         if (end < 0) {
         end = last;
         }
         buf.append(name.substring(beginend));
         if (end == last) {
         break;
         }
         buf.append(with);
         begin = end + 1;
     }
     
     return buf.toString();
     }
 
     public static class ValidAttribute {
     String name;
     boolean mandatory;
     boolean rtexprvalue;    // not used now
 
     public ValidAttribute (String nameboolean mandatory,
             boolean rtexprvalue )
         {
         this. = name;
         this. = mandatory;
             this. = rtexprvalue;
         }
 
        public ValidAttribute (String nameboolean mandatory) {
             thisnamemandatoryfalse );
     }
 
     public ValidAttribute (String name) {
         this (namefalse);
     }
     }
    
    
Convert a String value to 'boolean'. Besides the standard conversions done by Boolean.valueOf(s).booleanValue(), the value "yes" (ignore case) is also converted to 'true'. If 's' is null, then 'false' is returned.

Parameters:
s the string to be converted
Returns:
the boolean value associated with the string s
 
     public static boolean booleanValue(String s) {
     boolean b = false;
     if (s != null) {
         if (s.equalsIgnoreCase("yes")) {
         b = true;
         } else {
         b = Boolean.valueOf(s).booleanValue();
         }
     }
     return b;
     }

    
Returns the Class object associated with the class or interface with the given string name.

The Class object is determined by passing the given string name to the Class.forName() method, unless the given string name represents a primitive type, in which case it is converted to a Class object by appending ".class" to it (e.g., "int.class").

 
     public static Class toClass(String typeClassLoader loader)
         throws ClassNotFoundException {
 
     Class c = null;
     int i0 = type.indexOf('[');
     int dims = 0;
     if (i0 > 0) {
         // This is an array.  Count the dimensions
         for (int i = 0; i < type.length(); i++) {
         if (type.charAt(i) == '[')
             dims++;
         }
         type = type.substring(0, i0);
     }
 
     if ("boolean".equals(type))
         c = boolean.class;
     else if ("char".equals(type))
         c = char.class;
     else if ("byte".equals(type))
         c =  byte.class;
     else if ("short".equals(type))
         c = short.class;
     else if ("int".equals(type))
         c = int.class;
     else if ("long".equals(type))
         c = long.class;
     else if ("float".equals(type))
         c = float.class;
     else if ("double".equals(type))
         c = double.class;
     else if ("void".equals(type))
         c = void.class;
     else if (type.indexOf('[') < 0)
         c = loader.loadClass(type);
 
     if (dims == 0)
         return c;
 
     if (dims == 1)
         return java.lang.reflect.Array.newInstance(c, 1).getClass();
 
     // Array of more than i dimension
     return java.lang.reflect.Array.newInstance(cnew int[dims]).getClass();
     }
    
    
Produces a String representing a call to the EL interpreter.

Parameters:
expression a String containing zero or more "${}" expressions
expectedType the expected type of the interpreted result
fnmapvar Variable pointing to a function map.
XmlEscape True if the result should do XML escaping
Returns:
a String representing a call to the EL interpreter.
 
     public static String interpreterCall(boolean isTagFile,
                      String expression,
                                          Class expectedType,
                                          String fnmapvar,
                                          boolean XmlEscape ) 
     {
         /*
          * Determine which context object to use.
          */
     String jspCtxt = null;
     if (isTagFile)
         jspCtxt = "this.getJspContext()";
     else
         jspCtxt = "_jspx_page_context";
 
     /*
          * Determine whether to use the expected type's textual name
      * or, if it's a primitive, the name of its correspondent boxed
      * type.
          */
     String targetType = getCanonicalName(expectedType);
     String primitiveConverterMethod = null;
     if (expectedType.isPrimitive()) {
         if (expectedType.equals(.)) {
         targetType = Boolean.class.getName();
         primitiveConverterMethod = "booleanValue";
         } else if (expectedType.equals(.)) {
         targetType = Byte.class.getName();
         primitiveConverterMethod = "byteValue";
         } else if (expectedType.equals(.)) {
         targetType = Character.class.getName();
         primitiveConverterMethod = "charValue";
         } else if (expectedType.equals(.)) {
         targetType = Short.class.getName();
         primitiveConverterMethod = "shortValue";
         } else if (expectedType.equals(.)) {
         targetType = Integer.class.getName();
         primitiveConverterMethod = "intValue";
         } else if (expectedType.equals(.)) {
         targetType = Long.class.getName();
         primitiveConverterMethod = "longValue";
         } else if (expectedType.equals(.)) {
         targetType = Float.class.getName();
         primitiveConverterMethod = "floatValue";
         } else if (expectedType.equals(.)) { 
         targetType = Double.class.getName();
         primitiveConverterMethod = "doubleValue";
         }
     }
  
     if (primitiveConverterMethod != null) {
         XmlEscape = false;
     }
 
     /*
          * Build up the base call to the interpreter.
          */
         // XXX - We use a proprietary call to the interpreter for now
         // as the current standard machinery is inefficient and requires
         // lots of wrappers and adapters.  This should all clear up once
         // the EL interpreter moves out of JSTL and into its own project.
         // In the future, this should be replaced by code that calls
         // ExpressionEvaluator.parseExpression() and then cache the resulting
         // expression objects.  The interpreterCall would simply select
         // one of the pre-cached expressions and evaluate it.
         // Note that PageContextImpl implements VariableResolver and
         // the generated Servlet/SimpleTag implements FunctionMapper, so
         // that machinery is already in place (mroth).
     targetType = toJavaSourceType(targetType);
     StringBuilder call = new StringBuilder(
              "(" + targetType + ") "
                + "org.apache.jasper.runtime.PageContextImpl.proprietaryEvaluate"
                + "(" + Generator.quote(expression) + ", "
                +       targetType + ".class, "
            +       "(PageContext)" + jspCtxt 
                +       ", " + fnmapvar
            + ", " + XmlEscape
                + ")");
  
     /*
          * Add the primitive converter method if we need to.
          */
     if (primitiveConverterMethod != null) {
         call.insert(0, "(");
         call.append(")." + primitiveConverterMethod + "()");
     }
  
     return call.toString();
     }

    
Validates the syntax of all ${} expressions within the given string.

Deprecated:
now delegated to the org.apache.el Package
Parameters:
where the approximate location of the expressions in the JSP page
expressions a string containing zero or more "${}" expressions
err an error dispatcher to use
 
     public static void validateExpressions(Mark where,
                                            String expressions,
                                            Class expectedType,
                                            FunctionMapper functionMapper,
                                            ErrorDispatcher err)
             throws JasperException {
 
 //        try {
 //            
 //            JspUtil.expressionEvaluator.parseExpression( expressions, 
 //                expectedType, functionMapper );
 //        }
 //        catch( ELParseException e ) {
 //            err.jspError(where, "jsp.error.invalid.expression", expressions,
 //                e.toString() );
 //        }
 //        catch( ELException e ) {
 //            err.jspError(where, "jsp.error.invalid.expression", expressions,
 //                e.toString() );
 //        }
     }
 
     public static String coerceToPrimitiveBoolean(String s,
                           boolean isNamedAttribute) {
     if (isNamedAttribute) {
         return "org.apache.jasper.runtime.JspRuntimeLibrary.coerceToBoolean(" + s + ")";
     } else {
         if (s == null || s.length() == 0)
         return "false";
         else
         return Boolean.valueOf(s).toString();
     }
     }
 
     public static String coerceToBoolean(String sboolean isNamedAttribute) {
     if (isNamedAttribute) {
         return "(Boolean) org.apache.jasper.runtime.JspRuntimeLibrary.coerce(" + s + ", Boolean.class)";
     } else {
         if (s == null || s.length() == 0) {
         return "new Boolean(false)";
         } else {
         // Detect format error at translation time
         return "new Boolean(" + Boolean.valueOf(s).toString() + ")";
         }
     }
     }
 
     public static String coerceToPrimitiveByte(String s,
                            boolean isNamedAttribute) {
     if (isNamedAttribute) {
         return "org.apache.jasper.runtime.JspRuntimeLibrary.coerceToByte(" + s + ")";
     } else {
         if (s == null || s.length() == 0)
         return "(byte) 0";
         else
         return "((byte)" + Byte.valueOf(s).toString() + ")";
     }
     }
 
     public static String coerceToByte(String sboolean isNamedAttribute) {
     if (isNamedAttribute) {
         return "(Byte) org.apache.jasper.runtime.JspRuntimeLibrary.coerce(" + s + ", Byte.class)";
     } else {
         if (s == null || s.length() == 0) {
         return "new Byte((byte) 0)";
         } else {
         // Detect format error at translation time
         return "new Byte((byte)" + Byte.valueOf(s).toString() + ")";
         }
     }
     }
 
     public static String coerceToChar(String sboolean isNamedAttribute) {
     if (isNamedAttribute) {
         return "org.apache.jasper.runtime.JspRuntimeLibrary.coerceToChar(" + s + ")";
     } else {
         if (s == null || s.length() == 0) {
         return "(char) 0";
         } else {
         char ch = s.charAt(0);
         // this trick avoids escaping issues
         return "((char) " + (intch + ")";
         }
     }
     }
 
     public static String coerceToCharacter(String sboolean isNamedAttribute) {
     if (isNamedAttribute) {
         return "(Character) org.apache.jasper.runtime.JspRuntimeLibrary.coerce(" + s + ", Character.class)";
     } else {
         if (s == null || s.length() == 0) {
         return "new Character((char) 0)";
         } else {
         char ch = s.charAt(0);
         // this trick avoids escaping issues
         return "new Character((char) " + (intch + ")";
         }
     }
     }
 
     public static String coerceToPrimitiveDouble(String s,
                          boolean isNamedAttribute) {
     if (isNamedAttribute) {
         return "org.apache.jasper.runtime.JspRuntimeLibrary.coerceToDouble(" + s + ")";
     } else {
         if (s == null || s.length() == 0)
         return "(double) 0";
         else
         return Double.valueOf(s).toString();
     }
     }
 
     public static String coerceToDouble(String sboolean isNamedAttribute) {
     if (isNamedAttribute) {
         return "(Double) org.apache.jasper.runtime.JspRuntimeLibrary.coerce(" + s + ", Double.class)";
     } else {
         if (s == null || s.length() == 0) {
         return "new Double(0)";
         } else {
         // Detect format error at translation time
         return "new Double(" + Double.valueOf(s).toString() + ")";
         }
     }
     }
 
     public static String coerceToPrimitiveFloat(String s,
                         boolean isNamedAttribute) {
     if (isNamedAttribute) {
         return "org.apache.jasper.runtime.JspRuntimeLibrary.coerceToFloat(" + s + ")";
     } else {
         if (s == null || s.length() == 0)
         return "(float) 0";
         else
         return Float.valueOf(s).toString() + "f";
     }
     }
 
     public static String coerceToFloat(String sboolean isNamedAttribute) {
     if (isNamedAttribute) {
         return "(Float) org.apache.jasper.runtime.JspRuntimeLibrary.coerce(" + s + ", Float.class)";
     } else {
         if (s == null || s.length() == 0) {
         return "new Float(0)";
         } else {
         // Detect format error at translation time
         return "new Float(" + Float.valueOf(s).toString() + "f)";
         }
     }
     }
 
     public static String coerceToInt(String sboolean isNamedAttribute) {
     if (isNamedAttribute) {
         return "org.apache.jasper.runtime.JspRuntimeLibrary.coerceToInt(" + s + ")";
     } else {
         if (s == null || s.length() == 0)
         return "0";
         else
         return Integer.valueOf(s).toString();
     }
     }
 
     public static String coerceToInteger(String sboolean isNamedAttribute) {
     if (isNamedAttribute) {
         return "(Integer) org.apache.jasper.runtime.JspRuntimeLibrary.coerce(" + s + ", Integer.class)";
     } else {
         if (s == null || s.length() == 0) {
         return "new Integer(0)";
         } else {
         // Detect format error at translation time
         return "new Integer(" + Integer.valueOf(s).toString() + ")";
         }
     }
     }
 
     public static String coerceToPrimitiveShort(String s,
                         boolean isNamedAttribute) {
     if (isNamedAttribute) {
         return "org.apache.jasper.runtime.JspRuntimeLibrary.coerceToShort(" + s + ")";
     } else {
         if (s == null || s.length() == 0)
         return "(short) 0";
         else
         return "((short) " + Short.valueOf(s).toString() + ")";
     }
     }
     
     public static String coerceToShort(String sboolean isNamedAttribute) {
     if (isNamedAttribute) {
         return "(Short) org.apache.jasper.runtime.JspRuntimeLibrary.coerce(" + s + ", Short.class)";
     } else {
         if (s == null || s.length() == 0) {
         return "new Short((short) 0)";
         } else {
         // Detect format error at translation time
         return "new Short(\"" + Short.valueOf(s).toString() + "\")";
         }
     }
     }
     
     public static String coerceToPrimitiveLong(String s,
                            boolean isNamedAttribute) {
     if (isNamedAttribute) {
         return "org.apache.jasper.runtime.JspRuntimeLibrary.coerceToLong(" + s + ")";
     } else {
         if (s == null || s.length() == 0)
         return "(long) 0";
         else
         return Long.valueOf(s).toString() + "l";
     }
     }
 
     public static String coerceToLong(String sboolean isNamedAttribute) {
     if (isNamedAttribute) {
         return "(Long) org.apache.jasper.runtime.JspRuntimeLibrary.coerce(" + s + ", Long.class)";
     } else {
         if (s == null || s.length() == 0) {
         return "new Long(0)";
         } else {
         // Detect format error at translation time
         return "new Long(" + Long.valueOf(s).toString() + "l)";
         }
     }
     }
 
     public static InputStream getInputStream(String fnameJarFile jarFile,
                          JspCompilationContext ctxt,
                          ErrorDispatcher err)
         throws JasperExceptionIOException {
 
         InputStream in = null;
 
     if (jarFile != null) {
         String jarEntryName = fname.substring(1, fname.length());
         ZipEntry jarEntry = jarFile.getEntry(jarEntryName);
         if (jarEntry == null) {
         err.jspError(.fileNotFound(fname));
         }
         in = jarFile.getInputStream(jarEntry);
     } else {
         in = ctxt.getResourceAsStream(fname);
     }
 
     if (in == null) {
         err.jspError(.fileNotFound(fname));
     }
 
     return in;
     }

    
Gets the fully-qualified class name of the tag handler corresponding to the given tag file path.

Deprecated:
Use See https://issues.apache.org/bugzilla/show_bug.cgi?id=46471
Parameters:
path Tag file path
err Error dispatcher
Returns:
Fully-qualified class name of the tag handler corresponding to the given tag file path
 
     public static String getTagHandlerClassName(String pathErrorDispatcher err)
             throws JasperException {
         return getTagHandlerClassName(pathnullerr);
     }
    
    
Gets the fully-qualified class name of the tag handler corresponding to the given tag file path.

Parameters:
path Tag file path
err Error dispatcher
Returns:
Fully-qualified class name of the tag handler corresponding to the given tag file path
 
     public static String getTagHandlerClassName(String pathString urn,
             ErrorDispatcher errthrows JasperException {
 
         String className = null;
         int begin = 0;
         int index;
         
         index = path.lastIndexOf(".tag");
         if (index == -1) {
             err.jspError(.invalidTagFileName(path));
         }
 
         //It's tempting to remove the ".tag" suffix here, but we can't.
         //If we remove it, the fully-qualified class name of this tag
         //could conflict with the package name of other tags.
         //For instance, the tag file
         //    /WEB-INF/tags/foo.tag
         //would have fully-qualified class name
         //    org.apache.jsp.tag.web.foo
         //which would conflict with the package name of the tag file
         //    /WEB-INF/tags/foo/bar.tag
 
         index = path.indexOf();
         if (index != -1) {
             className = "org.apache.jsp.tag.web.";
             begin = index + .length();
         } else {
         index = path.indexOf();
         if (index != -1) {
         className = getClassNameBase(urn);
         begin = index + .length();
         } else {
         err.jspError(.invalidTagFileDirectory(path));
         }
     }
 
         className += makeJavaPackage(path.substring(begin));
   
        return className;
     }
 
     private static String getClassNameBase(String urn) {
         StringBuilder base = new StringBuilder("org.apache.jsp.tag.meta.");
         if (urn != null) {
             base.append(makeJavaPackage(urn));
             base.append('.');
         }
         return base.toString();
     }

    
Converts the given path to a Java package or fully-qualified class name

Parameters:
path Path to convert
Returns:
Java package corresponding to the given path
 
     public static final String makeJavaPackage(String path) {
         String classNameComponents[] = split(path,"/");
         StringBuilder legalClassNames = new StringBuilder();
         for (int i = 0; i < classNameComponents.lengthi++) {
             legalClassNames.append(makeJavaIdentifier(classNameComponents[i]));
             if (i < classNameComponents.length - 1) {
                 legalClassNames.append('.');
             }
         }
         return legalClassNames.toString();
     }

    
Splits a string into it's components.

Parameters:
path String to split
pat Pattern to split at
Returns:
the components of the path
 
     private static final String [] split(String pathString pat) {
         Vector comps = new Vector();
         int pos = path.indexOf(pat);
         int start = 0;
         whilepos >= 0 ) {
             if(pos > start ) {
                 String comp = path.substring(start,pos);
                 comps.add(comp);
             }
             start = pos + pat.length();
             pos = path.indexOf(pat,start);
         }
         ifstart < path.length()) {
             comps.add(path.substring(start));
         }
         String [] result = new String[comps.size()];
         for(int i=0; i < comps.size(); i++) {
             result[i] = (String)comps.elementAt(i);
         }
         return result;
     }
            
    
Converts the given identifier to a legal Java identifier

Parameters:
identifier Identifier to convert
Returns:
Legal Java identifier corresponding to the given identifier
 
     public static final String makeJavaIdentifier(String identifier) {
         StringBuilder modifiedIdentifier = 
             new StringBuilder(identifier.length());
         if (!Character.isJavaIdentifierStart(identifier.charAt(0))) {
             modifiedIdentifier.append('_');
         }
         for (int i = 0; i < identifier.length(); i++) {
             char ch = identifier.charAt(i);
             if (Character.isJavaIdentifierPart(ch) && ch != '_') {
                 modifiedIdentifier.append(ch);
             } else if (ch == '.') {
                 modifiedIdentifier.append('_');
             } else {
                 modifiedIdentifier.append(mangleChar(ch));
             }
         }
         if (isJavaKeyword(modifiedIdentifier.toString())) {
             modifiedIdentifier.append('_');
         }
         return modifiedIdentifier.toString();
     }
    
    
Mangle the specified character to create a legal Java class name.
 
     public static final String mangleChar(char ch) {
         char[] result = new char[5];
         result[0] = '_';
         result[1] = Character.forDigit((ch >> 12) & 0xf, 16);
         result[2] = Character.forDigit((ch >> 8) & 0xf, 16);
         result[3] = Character.forDigit((ch >> 4) & 0xf, 16);
         result[4] = Character.forDigit(ch & 0xf, 16);
        return new String(result);
    }

    
Test whether the argument is a Java keyword
    public static boolean isJavaKeyword(String key) {
        int i = 0;
        int j = .;
        while (i < j) {
            int k = (i+j)/2;
            int result = [k].compareTo(key);
            if (result == 0) {
                return true;
            }
            if (result < 0) {
                i = k+1;
            } else {
                j = k;
            }
        }
        return false;
    }

    
Converts the given Xml name to a legal Java identifier. This is slightly more efficient than makeJavaIdentifier in that we only need to worry about '.', '-', and ':' in the string. We also assume that the resultant string is further concatenated with some prefix string so that we don't have to worry about it being a Java key word.

Parameters:
name Identifier to convert
Returns:
Legal Java identifier corresponding to the given identifier
    public static final String makeXmlJavaIdentifier(String name) {
        if (name.indexOf('-') >= 0)
            name = replace(name'-'"$1");
        if (name.indexOf('.') >= 0)
            name = replace(name'.'"$2");
        if (name.indexOf(':') >= 0)
            name = replace(name':'"$3");
        return name;
    }
    static InputStreamReader getReader(String fnameString encoding,
            JarFile jarFile,
            JspCompilationContext ctxt,
            ErrorDispatcher err)
    throws JasperExceptionIOException {
        return getReader(fnameencodingjarFilectxterr, 0);
    }
    static InputStreamReader getReader(String fnameString encoding,
            JarFile jarFile,
            JspCompilationContext ctxt,
            ErrorDispatcher errint skip)
    throws JasperExceptionIOException {
        InputStreamReader reader = null;
        InputStream in = getInputStream(fnamejarFilectxterr);
        for (int i = 0; i < skipi++) {
            in.read();
        }
        try {
            reader = new InputStreamReader(inencoding);
        } catch (UnsupportedEncodingException ex) {
            err.jspError(.unsupportedEncoding(encoding));
        }
        return reader;
    }
    
    
Handles taking input from TLDs 'java.lang.Object' -> 'java.lang.Object.class' 'int' -> 'int.class' 'void' -> 'Void.TYPE' 'int[]' -> 'int[].class'

Parameters:
type
Returns:
    public static String toJavaSourceTypeFromTld(String type) {
        if (type == null || "void".equals(type)) {
            return "Void.TYPE";
        }
        return type + ".class";
    }

    
Class.getName() return arrays in the form "[[[<et>", where et, the element type can be one of ZBCDFIJS or L<classname>; It is converted into forms that can be understood by javac.
    public static String toJavaSourceType(String type) {
    if (type.charAt(0) != '[') {
        return type;
    }
    int dims = 1;
    String t = null;
    for (int i = 1; i < type.length(); i++) {
        if (type.charAt(i) == '[') {
        dims++;
        } else {
        switch (type.charAt(i)) {
        case 'Z't = "boolean"break;
        case 'B't = "byte"break;
        case 'C't = "char"break;
        case 'D't = "double"break;
        case 'F't = "float"break;
        case 'I't = "int"break;
        case 'J't = "long"break;
        case 'S't = "short"break;
        case 'L't = type.substring(i+1, type.indexOf(';')); break;
        }
        break;
        }
    }
    StringBuilder resultType = new StringBuilder(t);
    for (; dims > 0; dims--) {
        resultType.append("[]");
    }
    return resultType.toString();
    }

    
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 legal Java Identifier character.

Parameters:
c A instance of java.lang.Class
Returns:
The canonical name of c.
    public static String getCanonicalName(Class c) {
        String binaryName = c.getName();
        c = c.getDeclaringClass();
        if (c == null) {
            return binaryName;
        }
        StringBuilder buf = new StringBuilder(binaryName);
        do {
            buf.setCharAt(c.getName().length(), '.');
            c = c.getDeclaringClass();
        } while ( c != null);
        return buf.toString();
    }