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.runtime;
  
  import static org.jboss.web.JasperMessages.MESSAGES;
  
  
  
Bunch of util methods that are used by code generated for useBean, getProperty and setProperty. The __begin, __end stuff is there so that the JSP engine can actually parse this file and inline them if people don't want runtime dependencies on this class. However, I'm not sure if that works so well right now. It got forgotten at some point. -akv

Author(s):
Mandar Raje
Shawn Bayern
  
  public class JspRuntimeLibrary {
      
      private static final String SERVLET_EXCEPTION
  	= "javax.servlet.error.exception";
      private static final String JSP_EXCEPTION
  	= "javax.servlet.jsp.jspException";
  
      protected static class PrivilegedIntrospectHelper
  	implements PrivilegedExceptionAction {
  
  	private Object bean;
  	private String prop;
  	private String value;
  	private ServletRequest request;
  	private String param;
  	private boolean ignoreMethodNF;
  
          PrivilegedIntrospectHelper(Object beanString prop,
                                     String valueServletRequest request,
                                     String paramboolean ignoreMethodNF)
          {
  	    this. = bean;
  	    this. = prop;
  	    this. = value;
              this. = request;
  	    this. = param;
  	    this. = ignoreMethodNF;
          }
           
          public Object run() throws JasperException {
                  ,,,,,);
              return null;
          }
      }

    
Returns the value of the javax.servlet.error.exception request attribute value, if present, otherwise the value of the javax.servlet.jsp.jspException request attribute value. This method is called at the beginning of the generated servlet code for a JSP error page, when the "exception" implicit scripting language variable is initialized.
 
     public static Throwable getThrowable(ServletRequest request) {
 	if (error == null) {
 	    error = (Throwablerequest.getAttribute();
 	    if (error != null) {
 		/*
 		 * The only place that sets JSP_EXCEPTION is
 		 * PageContextImpl.handlePageException(). It really should set
 		 * SERVLET_EXCEPTION, but that would interfere with the 
 		 * ErrorReportValve. Therefore, if JSP_EXCEPTION is set, we
 		 * need to set SERVLET_EXCEPTION.
 		 */
 		request.setAttribute(error);
 	    }
 	}
 
 	return error;
     }
 
     public static boolean coerceToBoolean(String s) {
 	if (s == null || s.length() == 0)
 	    return false;
 	else
 	    return Boolean.valueOf(s).booleanValue();
     }
 
     public static byte coerceToByte(String s) {
 	if (s == null || s.length() == 0)
 	    return (byte) 0;
 	else
 	    return Byte.valueOf(s).byteValue();
     }
 
     public static char coerceToChar(String s) {
 	if (s == null || s.length() == 0) {
 	    return (char) 0;
 	} else {
 	    // this trick avoids escaping issues
 	    return (char)(ints.charAt(0);
 	}
     }
 
     public static double coerceToDouble(String s) {
 	if (s == null || s.length() == 0)
 	    return (double) 0;
 	else
 	    return Double.valueOf(s).doubleValue();
     }
 
     public static float coerceToFloat(String s) {
 	if (s == null || s.length() == 0)
 	    return (float) 0;
 	else
 	    return Float.valueOf(s).floatValue();
     }
 
     public static int coerceToInt(String s) {
 	if (s == null || s.length() == 0)
 	    return 0;
 	else
 	    return Integer.valueOf(s).intValue();
     }
 
     public static short coerceToShort(String s) {
 	if (s == null || s.length() == 0)
 	    return (short) 0;
 	else
 	    return Short.valueOf(s).shortValue();
     }
 
     public static long coerceToLong(String s) {
 	if (s == null || s.length() == 0)
 	    return (long) 0;
 	else
 	    return Long.valueOf(s).longValue();
     }
 
     public static Object coerce(String sClass target) {
 
 	boolean isNullOrEmpty = (s == null || s.length() == 0);
 
 	if (target == Boolean.class) {
 	    if (isNullOrEmpty) {
 		s = "false";
 	    }
 	    return new Boolean(s);
 	} else if (target == Byte.class) {
 	    if (isNullOrEmpty)
 		return new Byte((byte) 0);
 	    else
 		return new Byte(s);
 	} else if (target == Character.class) {
 	    if (isNullOrEmpty)
 		return new Character((char) 0);
 	    else 
 		return new Character(s.charAt(0));
 	} else if (target == Double.class) {
 	    if (isNullOrEmpty)
 		return new Double(0);
 	    else
 		return new Double(s);
 	} else if (target == Float.class) {
 	    if (isNullOrEmpty)
 		return new Float(0);
 	    else
 		return new Float(s);
 	} else if (target == Integer.class) {
 	    if (isNullOrEmpty)
 		return new Integer(0);
 	    else
 		return new Integer(s);
 	} else if (target == Short.class) {
 	    if (isNullOrEmpty)
 		return new Short((short) 0);
 	    else
 		return new Short(s);
 	} else if (target == Long.class) {
 	    if (isNullOrEmpty)
 		return new Long(0);
 	    else
 		return new Long(s);
 	} else {
 	    return null;
 	}
     }
 
    // __begin convertMethod
     public static Object convert(String propertyNameString sClass t,
 				 Class propertyEditorClass
        throws JasperException 
     {
         try {
             if (s == null) {
                 if (t.equals(Boolean.class) || t.equals(.))
                     s = "false";
                 else
                     return null;
             }
 	    if (propertyEditorClass != null) {
 				    tpropertyNamespropertyEditorClass);
 	    } else if ( t.equals(Boolean.class) || t.equals(.) ) {
                 if (s.equalsIgnoreCase("on") || s.equalsIgnoreCase("true"))
                     s = "true";
                 else
                     s = "false";
                 return new Boolean(s);
             } else if ( t.equals(Byte.class) || t.equals(.) ) {
                 return new Byte(s);
             } else if (t.equals(Character.class) || t.equals(.)) {
                 return s.length() > 0 ? new Character(s.charAt(0)) : null;
             } else if ( t.equals(Short.class) || t.equals(.) ) {
                 return new Short(s);
             } else if ( t.equals(Integer.class) || t.equals(.) ) {
                 return new Integer(s);
             } else if ( t.equals(Float.class) || t.equals(.) ) {
                 return new Float(s);
             } else if ( t.equals(Long.class) || t.equals(.) ) {
                 return new Long(s);
             } else if ( t.equals(Double.class) || t.equals(.) ) {
                 return new Double(s);
             } else if ( t.equals(String.class) ) {
                 return s;
             } else if ( t.equals(java.io.File.class) ) {
                 return new java.io.File(s);
             } else if (t.getName().equals("java.lang.Object")) {
                 return new Object[] {s};
 	    } else {
                                             tpropertyNames);
             }
         } catch (Exception ex) {
             throw new JasperException(ex);
         }
     }
     // __end convertMethod
 
     // __begin introspectMethod
     public static void introspect(Object beanServletRequest request)
                                   throws JasperException
     {
 	Enumeration e = request.getParameterNames();
 	while ( e.hasMoreElements() ) {
 	    String name  = (Stringe.nextElement();
 	    String value = request.getParameter(name);
 	    introspecthelper(beannamevaluerequestnametrue);
 	}
     }
     // __end introspectMethod
     
     // __begin introspecthelperMethod
     public static void introspecthelper(Object beanString prop,
                                         String valueServletRequest request,
                                         String paramboolean ignoreMethodNF)
                                         throws JasperException
     {
         if. ) {
             try {
                 PrivilegedIntrospectHelper dp =
 			bean,prop,value,request,param,ignoreMethodNF);
                 AccessController.doPrivileged(dp);
             } catchPrivilegedActionException pe) {
                 Exception e = pe.getException();
                 throw (JasperException)e;
             }
         } else {
             internalIntrospecthelper(
 		bean,prop,value,request,param,ignoreMethodNF);
         }
     }
 
     private static void internalIntrospecthelper(Object beanString prop,
 					String valueServletRequest request,
 					String paramboolean ignoreMethodNF
     {
         Method method = null;
         Class type = null;
         Class propertyEditorClass = null;
 	try {
 	    java.beans.BeanInfo info
 		= java.beans.Introspector.getBeanInfo(bean.getClass());
 	    if ( info != null ) {
 		    = info.getPropertyDescriptors();
 		for (int i = 0 ; i < pd.length ; i++) {
 		    if ( pd[i].getName().equals(prop) ) {
 			method = pd[i].getWriteMethod();
 			type   = pd[i].getPropertyType();
 			propertyEditorClass = pd[i].getPropertyEditorClass();
 			break;
 		    }
 		}
 	    }
 	    if ( method != null ) {
 		if (type.isArray()) {
                     if (request == null) {
                     }
 		    Class t = type.getComponentType();
 		    String[] values = request.getParameterValues(param);
 		    //XXX Please check.
 		    if(values == nullreturn;
 		    if(t.equals(String.class)) {
 			method.invoke(beannew Object[] { values });
 		    } else {
 			Object tmpval = null;
 			createTypedArray (propbeanmethodvaluest,
 					  propertyEditorClass); 
 		    }
 		} else {
 		    if(value == null || (param != null && value.equals(""))) return;
 		    Object oval = convert(propvaluetypepropertyEditorClass);
 		    if ( oval != null )
 			method.invoke(beannew Object[] { oval });
 		}
 	    }
 	} catch (Exception ex) {
 	    throw new JasperException(ex);
 	}
         if (!ignoreMethodNF && (method == null)) {
             if (type == null) {
                 throw new JasperException(.cannotFindBeanProperty(propbean.getClass().getName()));
             } else {
                 throw new JasperException(.cannotSetBeanProperty(proptype.getName(), bean.getClass().getName()));
             }
         }
     }
     // __end introspecthelperMethod
     
     //-------------------------------------------------------------------
     // functions to convert builtin Java data types to string.
     //-------------------------------------------------------------------
     // __begin toStringMethod
     public static String toString(Object o) {
         return String.valueOf(o);
     }
 
     public static String toString(byte b) {
         return new Byte(b).toString();
     }
 
     public static String toString(boolean b) {
         return new Boolean(b).toString();
     }
 
     public static String toString(short s) {
         return new Short(s).toString();
     }
 
     public static String toString(int i) {
         return new Integer(i).toString();
     }
 
     public static String toString(float f) {
         return new Float(f).toString();
     }
 
     public static String toString(long l) {
         return new Long(l).toString();
     }
 
     public static String toString(double d) {
         return new Double(d).toString();
     }
 
     public static String toString(char c) {
         return new Character(c).toString();
     }
     // __end toStringMethod
 

    
Create a typed array. This is a special case where params are passed through the request and the property is indexed.
 
     public static void createTypedArray(String propertyName,
 					Object bean,
 					Method method,
 					String[] values,
 					Class t,
 					Class propertyEditorClass)
 	        throws JasperException {
 
 	try {
 	    if (propertyEditorClass != null) {
 		Object[] tmpval = new Integer[values.length];
 		for (int i=0; i<values.lengthi++) {
 		    tmpval[i] = getValueFromBeanInfoPropertyEditor(
                             tpropertyNamevalues[i], propertyEditorClass);
 		}
 		method.invoke (beannew Object[] {tmpval});
 	    } else if (t.equals(Integer.class)) {
 		Integer []tmpval = new Integer[values.length];
 		for (int i = 0 ; i < values.lengthi++)
 		    tmpval[i] =  new Integer (values[i]);
 		method.invoke (beannew Object[] {tmpval});
 	    } else if (t.equals(Byte.class)) {
 		Byte[] tmpval = new Byte[values.length];
 		for (int i = 0 ; i < values.lengthi++)
 		    tmpval[i] = new Byte (values[i]);
 		method.invoke (beannew Object[] {tmpval});
 	    } else if (t.equals(Boolean.class)) {
 		Boolean[] tmpval = new Boolean[values.length];
 		for (int i = 0 ; i < values.lengthi++)
 		    tmpval[i] = new Boolean (values[i]);
 		method.invoke (beannew Object[] {tmpval});
 	    } else if (t.equals(Short.class)) {
 		Short[] tmpval = new Short[values.length];
 		for (int i = 0 ; i < values.lengthi++)
 		    tmpval[i] = new Short (values[i]);
 		method.invoke (beannew Object[] {tmpval});
 	    } else if (t.equals(Long.class)) {
 		Long[] tmpval = new Long[values.length];
 		for (int i = 0 ; i < values.lengthi++)
 		    tmpval[i] = new Long (values[i]);
 		method.invoke (beannew Object[] {tmpval});
 	    } else if (t.equals(Double.class)) {
 		Double[] tmpval = new Double[values.length];
 		for (int i = 0 ; i < values.lengthi++)
 		    tmpval[i] = new Double (values[i]);
 		method.invoke (beannew Object[] {tmpval});
 	    } else if (t.equals(Float.class)) {
 		Float[] tmpval = new Float[values.length];
 		for (int i = 0 ; i < values.lengthi++)
 		    tmpval[i] = new Float (values[i]);
 		method.invoke (beannew Object[] {tmpval});
 	    } else if (t.equals(Character.class)) {
 		Character[] tmpval = new Character[values.length];
 		for (int i = 0 ; i < values.lengthi++)
 		    tmpval[i] = new Character(values[i].charAt(0));
 		method.invoke (beannew Object[] {tmpval});
 	    } else if (t.equals(int.class)) {
 		int []tmpval = new int[values.length];
 		for (int i = 0 ; i < values.lengthi++)
 		    tmpval[i] = Integer.parseInt (values[i]);
 		method.invoke (beannew Object[] {tmpval});
 	    } else if (t.equals(byte.class)) {
 		byte[] tmpval = new byte[values.length];
 		for (int i = 0 ; i < values.lengthi++)
 		    tmpval[i] = Byte.parseByte (values[i]);
 		method.invoke (beannew Object[] {tmpval});
 	    } else if (t.equals(boolean.class)) {
 		boolean[] tmpval = new boolean[values.length];
 		for (int i = 0 ; i < values.lengthi++)
 		    tmpval[i] = (Boolean.valueOf(values[i])).booleanValue();
 		method.invoke (beannew Object[] {tmpval});
 	    } else if (t.equals(short.class)) {
 		short[] tmpval = new short[values.length];
 		for (int i = 0 ; i < values.lengthi++)
 		    tmpval[i] = Short.parseShort (values[i]);
 		method.invoke (beannew Object[] {tmpval});
 	    } else if (t.equals(long.class)) {
 		long[] tmpval = new long[values.length];
 		for (int i = 0 ; i < values.lengthi++)
 		    tmpval[i] = Long.parseLong (values[i]);
 		method.invoke (beannew Object[] {tmpval});
 	    } else if (t.equals(double.class)) {
 		double[] tmpval = new double[values.length];
 		for (int i = 0 ; i < values.lengthi++)
 		    tmpval[i] = Double.valueOf(values[i]).doubleValue();
 		method.invoke (beannew Object[] {tmpval});
 	    } else if (t.equals(float.class)) {
 		float[] tmpval = new float[values.length];
 		for (int i = 0 ; i < values.lengthi++)
 		    tmpval[i] = Float.valueOf(values[i]).floatValue();
 		method.invoke (beannew Object[] {tmpval});
 	    } else if (t.equals(char.class)) {
 		char[] tmpval = new char[values.length];
 		for (int i = 0 ; i < values.lengthi++)
 		    tmpval[i] = values[i].charAt(0);
 		method.invoke (beannew Object[] {tmpval});
 	    } else {
 		Object[] tmpval = new Integer[values.length];
 		for (int i=0; i<values.lengthi++) {
 		    tmpval[i] =  
                                             tpropertyNamevalues[i]);
 		}
 		method.invoke (beannew Object[] {tmpval});
 	    }
 	} catch (Exception ex) {
             throw new JasperException ("error in invoking method"ex);
 	}
     }

    
Escape special shell characters.

Parameters:
unescString The string to shell-escape
Returns:
The escaped shell string.
 
 
     public static String escapeQueryString(String unescString) {
     if ( unescString == null )
         return null;
    
     String escString    = "";
     String shellSpChars = "&;`'\"|*?~<>^()[]{}$\\\n";
    
     for(int index=0; index<unescString.length(); index++) {
         char nextChar = unescString.charAt(index);
 
         ifshellSpChars.indexOf(nextChar) != -1 )
         escString += "\\";
 
         escString += nextChar;
     }
     return escString;
     }

    
Decode an URL formatted string.

Parameters:
encoded The string to decode.
Returns:
The decoded string.
 
 
     public static String decode(String encoded) {
         // speedily leave if we're not needed
     if (encoded == nullreturn null;
         if (encoded.indexOf('%') == -1 && encoded.indexOf('+') == -1)
         return encoded;
 
     //allocate the buffer - use byte[] to avoid calls to new.
         byte holdbuffer[] = new byte[encoded.length()];
 
         char holdchar;
         int bufcount = 0;
 
         for (int count = 0; count < encoded.length(); count++) {
         char cur = encoded.charAt(count);
             if (cur == '%') {
             holdbuffer[bufcount++] =
           (byte)Integer.parseInt(encoded.substring(count+1,count+3),16);
                 if (count + 2 >= encoded.length())
                     count = encoded.length();
                 else
                     count += 2;
             } else if (cur == '+') {
         holdbuffer[bufcount++] = (byte' ';
         } else {
             holdbuffer[bufcount++] = (bytecur;
             }
         }
 	// REVISIT -- remedy for Deprecated warning.
     //return new String(holdbuffer,0,0,bufcount);
     return new String(holdbuffer,0,bufcount);
     }
 
     // __begin lookupReadMethodMethod
     public static Object handleGetProperty(Object oString prop)
     throws JasperException {
         if (o == null) {
 	    throw new JasperException(.nullBean());
         }
 	Object value = null;
         try {
             Method method = getReadMethod(o.getClass(), prop);
 	    value = method.invoke(o, (Object[]) null);
         } catch (Exception ex) {
 	    throw new JasperException (ex);
         }
         return value;
     }
     // __end lookupReadMethodMethod
 
     // handles <jsp:setProperty> with EL expression for 'value' attribute
Use proprietaryEvaluate public static void handleSetPropertyExpression(Object bean, String prop, String expression, PageContext pageContext, VariableResolver variableResolver, FunctionMapper functionMapper ) throws JasperException { try { Method method = getWriteMethod(bean.getClass(), prop); method.invoke(bean, new Object[] { pageContext.getExpressionEvaluator().evaluate( expression, method.getParameterTypes()[0], variableResolver, functionMapper, null ) }); } catch (Exception ex) { throw new JasperException(ex); } }
 
     public static void handleSetPropertyExpression(Object bean,
         String propString expressionPageContext pageContext,
 	ProtectedFunctionMapper functionMapper )
         throws JasperException
     {
         try {
             Method method = getWriteMethod(bean.getClass(), prop);
             method.invoke(beannew Object[] {
                 PageContextImpl.proprietaryEvaluate(
                     expression,
                     method.getParameterTypes()[0],
 		    pageContext,
                     functionMapper,
                     false )
             });
         } catch (Exception ex) {
             throw new JasperException(ex);
         }
     }
 
     public static void handleSetProperty(Object beanString prop,
 					 Object value)
     {
 	try {
             Method method = getWriteMethod(bean.getClass(), prop);
 	    method.invoke(beannew Object[] { value });
 	} catch (Exception ex) {
 	    throw new JasperException(ex);
 	}
     }
     
     public static void handleSetProperty(Object beanString prop,
 					 int value)
     {
 	try {
             Method method = getWriteMethod(bean.getClass(), prop);
 	    method.invoke(beannew Object[] { new Integer(value) });
 	} catch (Exception ex) {
 	    throw new JasperException(ex);
 	}	
     }
     
     public static void handleSetProperty(Object beanString prop,
 					 short value)
     {
 	try {
             Method method = getWriteMethod(bean.getClass(), prop);
 	    method.invoke(beannew Object[] { new Short(value) });
 	} catch (Exception ex) {
 	    throw new JasperException(ex);
 	}	
     }
     
     public static void handleSetProperty(Object beanString prop,
 					 long value)
     {
 	try {
             Method method = getWriteMethod(bean.getClass(), prop);
 	    method.invoke(beannew Object[] { new Long(value) });
 	} catch (Exception ex) {
 	    throw new JasperException(ex);
 	}	
     } 
     
     public static void handleSetProperty(Object beanString prop,
 					 double value)
     {
 	try {
             Method method = getWriteMethod(bean.getClass(), prop);
 	    method.invoke(beannew Object[] { new Double(value) });
 	} catch (Exception ex) {
 	    throw new JasperException(ex);
 	}	
     }
     
     public static void handleSetProperty(Object beanString prop,
 					 float value)
     {
 	try {
             Method method = getWriteMethod(bean.getClass(), prop);
 	    method.invoke(beannew Object[] { new Float(value) });
 	} catch (Exception ex) {
 	    throw new JasperException(ex);
 	}	
     }
     
     public static void handleSetProperty(Object beanString prop,
 					 char value)
     {
 	try {
             Method method = getWriteMethod(bean.getClass(), prop);
 	    method.invoke(beannew Object[] { new Character(value) });
 	} catch (Exception ex) {
 	    throw new JasperException(ex);
 	}	
     }
 
     public static void handleSetProperty(Object beanString prop,
 					 byte value)
     {
 	try {
             Method method = getWriteMethod(bean.getClass(), prop);
 	    method.invoke(beannew Object[] { new Byte(value) });
 	} catch (Exception ex) {
 	    throw new JasperException(ex);
 	}	
     }
     
     public static void handleSetProperty(Object beanString prop,
 					 boolean value)
     {
 	try {
             Method method = getWriteMethod(bean.getClass(), prop);
 	    method.invoke(beannew Object[] { new Boolean(value) });
 	} catch (Exception ex) {
 	    throw new JasperException(ex);
 	}	
     }
     
     public static Method getWriteMethod(Class beanClassString prop)
     throws JasperException {
 	Method method = null;	
         Class type = null;
 	try {
 	    java.beans.BeanInfo info
                 = java.beans.Introspector.getBeanInfo(beanClass);
 	    if ( info != null ) {
 		    = info.getPropertyDescriptors();
 		for (int i = 0 ; i < pd.length ; i++) {
 		    if ( pd[i].getName().equals(prop) ) {
 			method = pd[i].getWriteMethod();
 			type   = pd[i].getPropertyType();
 			break;
 		    }
 		}
             } else {        
                 // just in case introspection silently fails.
                 throw new JasperException(.cannotFindBeanInfo(beanClass.getName()));
             }
         } catch (Exception ex) {
             throw new JasperException (ex);
         }
         if (method == null) {
             if (type == null) {
                 throw new JasperException(.cannotFindBeanProperty(propbeanClass.getName()));
             } else {
                 throw new JasperException(.cannotSetBeanProperty(proptype.getName(), beanClass.getName()));
             }
         }
         return method;
     }
 
     public static Method getReadMethod(Class beanClassString prop)
 	    throws JasperException {
 
         Method method = null;        
         Class type = null;
         try {
             java.beans.BeanInfo info
                 = java.beans.Introspector.getBeanInfo(beanClass);
             if ( info != null ) {
                 java.beans.PropertyDescriptor pd[]
                     = info.getPropertyDescriptors();
                 for (int i = 0 ; i < pd.length ; i++) {
                     if ( pd[i].getName().equals(prop) ) {
                         method = pd[i].getReadMethod();
                         type   = pd[i].getPropertyType();
                         break;
                     }
                 }
             } else {        
                 // just in case introspection silently fails.
 	    }
 	} catch (Exception ex) {
 	    throw new JasperException (ex);
 	}
         if (method == null) {
             if (type == null) {
                 throw new JasperException(.cannotFindBeanProperty(propbeanClass.getName()));
             } else {
                 throw new JasperException(.cannotGetBeanProperty(propbeanClass.getName()));
             }
         }
 
 	return method;
     }
 
     //*********************************************************************
     // PropertyEditor Support
 
     public static Object getValueFromBeanInfoPropertyEditor(
 		           Class attrClassString attrNameString attrValue,
 			   Class propertyEditorClass
 	throws JasperException 
     {
 	try {
 	    PropertyEditor pe = (PropertyEditor)propertyEditorClass.newInstance();
 	    pe.setAsText(attrValue);
 	    return pe.getValue();
 	} catch (Exception ex) {
 	            (attrValueattrClass.getName(), attrNameex.getMessage()));
 	}
     }
 
     public static Object getValueFromPropertyEditorManager(
 	             Class attrClassString attrNameString attrValue
 	throws JasperException 
     {
 	try {
 	    PropertyEditor propEditor = 
 		PropertyEditorManager.findEditor(attrClass);
 	    if (propEditor != null) {
 		propEditor.setAsText(attrValue);
 		return propEditor.getValue();
 	    } else {
 	    }
 	} catch (IllegalArgumentException ex) {
                 (attrValueattrClass.getName(), attrNameex.getMessage()));
 	}
     }
 
 
     // ************************************************************************
     // General Purpose Runtime Methods
     // ************************************************************************
 

    
Convert a possibly relative resource path into a context-relative resource path that starts with a '/'.

Parameters:
request The servlet request we are processing
relativePath The possibly relative resource path
 
     public static String getContextRelativePath(ServletRequest request,
                                                 String relativePath) {
 
         if (relativePath.startsWith("/"))
             return (relativePath);
         if (!(request instanceof HttpServletRequest))
             return (relativePath);
         HttpServletRequest hrequest = (HttpServletRequestrequest;
         String uri = (String)
             request.getAttribute("javax.servlet.include.servlet_path");
         if (uri != null) {
             String pathInfo = (String)
                 request.getAttribute("javax.servlet.include.path_info");
             if (pathInfo == null) {
                 if (uri.lastIndexOf('/') >= 0) 
                     uri = uri.substring(0, uri.lastIndexOf('/'));
             }
         }
         else {
             uri = hrequest.getServletPath();
             if (uri.lastIndexOf('/') >= 0) 
                 uri = uri.substring(0, uri.lastIndexOf('/'));
         }
         return uri + '/' + relativePath;
 
     }


    
Perform a RequestDispatcher.include() operation, with optional flushing of the response beforehand.

Parameters:
request The servlet request we are processing
response The servlet response we are processing
relativePath The relative path of the resource to be included
out The Writer to whom we are currently writing
flush Should we flush before the include is processed?
Throws:
java.io.IOException if thrown by the included servlet
javax.servlet.ServletException if thrown by the included servlet
 
     public static void include(ServletRequest request,
                                ServletResponse response,
                                String relativePath,
                                JspWriter out,
                                boolean flush)
         throws IOExceptionServletException {
 
         if (flush && !(out instanceof BodyContent))
             out.flush();
 
         // FIXME - It is tempting to use request.getRequestDispatcher() to
         // resolve a relative path directly, but Catalina currently does not
         // take into account whether the caller is inside a RequestDispatcher
         // include or not.  Whether Catalina *should* take that into account
         // is a spec issue currently under review.  In the mean time,
         // replicate Jasper's previous behavior
 
         String resourcePath = getContextRelativePath(requestrelativePath);
         RequestDispatcher rd = request.getRequestDispatcher(resourcePath);
 
         rd.include(request,
                    new ServletResponseWrapperInclude(responseout));
 
     }

    
URL encodes a string, based on the supplied character encoding. This performs the same function as java.next.URLEncode.encode in J2SDK1.4, and should be removed if the only platform supported is 1.4 or higher.

Parameters:
s The String to be URL encoded.
enc The character encoding
Returns:
The URL encoded String
 
     public static String URLEncode(String sString enc) {
 
 	if (s == null) {
 	    return "null";
 	}
 
 	if (enc == null) {
 	    enc = "ISO-8859-1";	// The default request encoding 
 	}
 
 	StringBuilder out = new StringBuilder(s.length());
 	OutputStreamWriter writer = null;
 	try {
 	    writer = new OutputStreamWriter(bufenc);
 	    // Use the default encoding?
 	    writer = new OutputStreamWriter(buf);
 	}
 	
 	for (int i = 0; i < s.length(); i++) {
 	    int c = s.charAt(i);
 	    if (c == ' ') {
 		out.append('+');
 	    } else if (isSafeChar(c)) {
 		out.append((char)c);
 	    } else {
 		// convert to external encoding before hex conversion
 		try {
 		    writer.write(c);
 		    writer.flush();
 		} catch(IOException e) {
 		    buf.reset();
 		    continue;
 		}
 		byte[] ba = buf.toByteArray();
 		for (int j = 0; j < ba.lengthj++) {
 		    out.append('%');
 		    // Converting each byte in the buffer
 		    out.append(Character.forDigit((ba[j]>>4) & 0xf, 16));
 		    out.append(Character.forDigit(ba[j] & 0xf, 16));
 		}
 		buf.reset();
 	    }
 	}
 	return out.toString();
    }
    private static boolean isSafeChar(int c) {
	if (c >= 'a' && c <= 'z') {
	    return true;
	if (c >= 'A' && c <= 'Z') {
	    return true;
	if (c >= '0' && c <= '9') {
	    return true;
	if (c == '-' || c == '_' || c == '.' || c == '!' ||
	    c == '~' || c == '*' || c == '\'' || c == '(' || c == ')') {
	    return true;
	return false;
    }