tomcat-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From cos...@apache.org
Subject cvs commit: jakarta-tomcat/src/facade22/org/apache/tomcat/facade JspInterceptor.java RequestDispatcherImpl.java
Date Sun, 28 Jan 2001 19:45:52 GMT
costin      01/01/28 11:45:52

  Modified:    src/facade22/org/apache/tomcat/facade JspInterceptor.java
                        RequestDispatcherImpl.java
  Log:
  JspInterceptor:
  - Added the missing jasper options.
  - More comments in the code
  - Better support for JspServlet
  - cleaner code
  
  ( there is now a log message for each jsp compilation - I can
  remove it later, I want to make sure the compilation/recompilation
  happens when needed - i.e. no recompilation after tomcat restart,
  detect if source changes, etc )
  
  Revision  Changes    Path
  1.9       +285 -663  jakarta-tomcat/src/facade22/org/apache/tomcat/facade/JspInterceptor.java
  
  Index: JspInterceptor.java
  ===================================================================
  RCS file: /home/cvs/jakarta-tomcat/src/facade22/org/apache/tomcat/facade/JspInterceptor.java,v
  retrieving revision 1.8
  retrieving revision 1.9
  diff -u -r1.8 -r1.9
  --- JspInterceptor.java	2001/01/26 06:45:32	1.8
  +++ JspInterceptor.java	2001/01/28 19:45:52	1.9
  @@ -77,70 +77,207 @@
   import org.apache.tomcat.facade.*;
   
   /**
  - * Plug in the JSP engine (a.k.a Jasper)! 
  + * Plug in the JSP engine (a.k.a Jasper)!
  + * Tomcat uses a "built-in" mapping for jsps ( *.jsp -> jsp ). "jsp"
  + * can be either a real servlet (JspServlet) that compiles the jsp
  + * and include the resource, or we can "intercept" and do the
  + * compilation and mapping in requestMap stage.
    *
  + * JspInterceptor will be invoked once per jsp, and will add an exact
  + * mapping - all further invocation are identical with servlet invocations
  + * with direct maps, with no extra overhead.
  + *
  + * Future - better abstraction for jsp->java converter ( jasper ), better
  + * abstraction for java->class, plugin other jsp implementations,
  + * better scalability.
  + *
    * @author Anil K. Vijendran
    * @author Harish Prabandham
    * @author Costin Manolache
    */
   public class JspInterceptor extends BaseInterceptor {
  -    TomcatOptions options=new TomcatOptions();
  -    boolean useJspServlet=true;
  -    
       static final String JIKES="org.apache.jasper.compiler.JikesJavaCompiler";
  +    static final String JSP_SERVLET="org.apache.jasper.servlet.JspServlet";
  +    
  +    Properties args=new Properties(); // args for jasper
  +    boolean useJspServlet=false; 
  +    String jspServletCN=JSP_SERVLET;
  +    
  +    // -------------------- Jasper options --------------------
  +    // Options that affect jasper functionality. Will be set on
  +    // JspServlet ( if useJspServlet="true" ) or TomcatOptions.
  +    // IMPORTANT: periodically test for new jasper options
  +    
  +    /**
  +     * Are we keeping generated code around?
  +     */
  +    public void setKeepGenerated( String s ) {
  +	args.put( "keepgenerated", s );
  +    }
  +
  +    /**
  +     * Are we supporting large files?
  +     */
  +    public void setLargeFile( String s ) {
  +	args.put( "largefile", s );
  +    }
  +
  +    /**
  +     * Are we supporting HTML mapped servlets?
  +     */
  +    public void setMappedFile( String s ) {
  +	args.put( "mappedfile", s );
  +    }
   
  -    // -------------------- Configurable properties --------------------
  +    /**
  +     * Should errors be sent to client or thrown into stderr?
  +     */
  +    public void setSendErrToClient( String s ) {
  +	args.put( "sendErrToClient", s );
  +    }
  +
  +    /**
  +     * Class ID for use in the plugin tag when the browser is IE. 
  +     */
  +    public void setIEClassId( String s ) {
  +	args.put( "ieClassId", s );
  +    }
  +
  +    /**
  +     * What classpath should I use while compiling the servlets
  +     * generated from JSP files?
  +     */
  +    public void setClassPath( String s ) {
  +	args.put( "classpath", s );
  +    }
  +
  +    /**
  +     * What is my scratch dir?
  +     */
  +    public void setScratchdir( String s ) {
  +	args.put( "scratchdir", s );
  +    }
  +
  +    /**
  +     * Path of the compiler to use for compiling JSP pages.
  +     */
  +    public void setJspCompilerPath( String s ) {
  +	args.put( "jspCompilerPath", s );
  +    }
  +
  +    /**
  +     * What compiler plugin should I use to compile the servlets
  +     * generated from JSP files?
  +     * @deprecated Use setJavaCompiler instead
  +     */
  +    public void setJspCompilerPlugin( String s ) {
  +	args.put( "jspCompilerPlugin", s );
  +    }
  +
  +    /** Include debug information in generated classes
  +     */
  +    public void setClassDebugInfo( String s ) {
  +	args.put("classDebugInfo", s );
  +    }
  +    
  +    public void setProperty( String n, String v ) {
  +	args.put( n, v );
  +    }
  +    // -------------------- JspInterceptor properties --------------------
   
       /** Use the old JspServlet to execute Jsps, instead of the
   	new code. Note that init() never worked (AFAIK) and it'll
   	be slower - but given the stability of JspServlet it may
  -	be a safe option
  +	be a safe option. This will significantly slow down jsps.
  +	Default is false.
       */
       public void setUseJspServlet( boolean b ) {
   	useJspServlet=b;
       }
  -    
  +
  +    /** Specify the implementation class of the jsp servlet.
  +     */
  +    public void setJspServlet( String  s ) {
  +	jspServletCN=s;
  +    }
  +
  +    /**
  +     * What compiler should I use to compile the servlets
  +     * generated from JSP files? Default is "javac" ( you can use
  +     * "jikes" as a shortcut ).
  +     */
       public void setJavaCompiler( String type ) {
  -	// shortcut
   	if( "jikes".equals( type ) )
   	    type=JIKES;
  -	
  -	try {
  -	    options.jspCompilerPlugin=Class.forName(type);
  -	} catch(Exception ex ) {
  -	    ex.printStackTrace();
  -	}
  +
  +	args.put( "jspCompilerPlugin", type );
       }
   
       // -------------------- Hooks --------------------
   
       /**
        * Jasper-specific initializations, add work dir to classpath,
  -     *  make sure we have a dependManager.
        */
       public void addContext(ContextManager cm, Context ctx)
   	throws TomcatException 
       {
  -	// Make sure JspFactory is set ( ? )
   	JspFactory.setDefaultFactory(new JspFactoryImpl());
   
  -	try {
  -	    // Note: URLClassLoader in JDK1.2.2 doesn't work with file URLs
  -	    // that contain '\' characters.  Insure only '/' is used.
  -	    if( ! useJspServlet ) {
  +	// jspServlet uses it's own loader. We need to add workdir
  +	// to the context classpath to use URLLoader and normal
  +	// operation
  +	// XXX alternative: use WEB-INF/classes for generated files 
  +	if( ! useJspServlet ) {
  +	    try {
  +		// Note: URLClassLoader in JDK1.2.2 doesn't work with file URLs
  +		// that contain '\' characters.  Insure only '/' is used.
   		// jspServlet uses it's own mechanism
   		URL url=new URL( "file", null,
   		 ctx.getWorkDir().getAbsolutePath().replace('\\','/') + "/");
   		ctx.addClassPath( url );
   		if( debug > 9 ) log( "Added to classpath: " + url );
  -	    } 
  -	} catch( MalformedURLException ex ) {
  +	    } catch( MalformedURLException ex ) {
  +	    }
   	}
  +    }
   
  -	DependManager dm=ctx.getDependManager();
  -	if( dm==null ) {
  -	    dm=new DependManager();
  -	    ctx.setDependManager( dm );
  +    /** Do the needed initialization if jspServlet is used.
  +     *  It must be called after Web.xml is read ( WebXmlReader ).
  +     */
  +    public void contextInit(Context ctx)
  +	throws TomcatException
  +    {
  +	if( useJspServlet ) {
  +	    // prepare jsp servlet. 
  +	    Handler jasper=ctx.getServletByName( "jsp" );
  +	    if ( debug>10) log( "Got jasper servlet " + jasper );
  +
  +	    ServletHandler jspServlet=(ServletHandler)jasper;
  +	    if( jspServlet.getServletClassName() == null ) {
  +		log( "Jsp already defined in web.xml " +
  +		     jspServlet.getServletClassName() );
  +		return;
  +	    }
  +	    if( debug>-1)
  +		log( "jspServlet=" +  jspServlet.getServletClassName());
  +	    Enumeration enum=args.keys();
  +	    while( enum.hasMoreElements() ) {
  +		String s=(String)enum.nextElement();
  +		String v=(String)args.get(s);
  +		if( debug>0 ) log( "Setting " + s + "=" + v );
  +		jspServlet.getServletInfo().addInitParam(s, v );
  +	    }
  +	    
  +	    if( debug > 0 ) {
  +		//enable jasperServlet logging
  +		log( "Seetting debug on jsp servlet");
  +		org.apache.jasper.Constants.jasperLog=
  +		    org.apache.tomcat.util.log.Logger.getDefaultLogger();
  +		org.apache.jasper.Constants.jasperLog.
  +		    setVerbosityLevel("debug");
  +	    }
  +
  +	    jspServlet.setServletClassName(jspServletCN);
   	}
       }
   
  @@ -188,6 +325,13 @@
   	to set them on JspInterceptor.
       */
       public int requestMap( Request req ) {
  +	if( useJspServlet ) {
  +	    // no further processing - jspServlet will take care
  +	    // of the processing as before ( all processing
  +	    // will happen in the handle() pipeline.
  +	    return 0;
  +	}
  +
   	Handler wrapper=req.getHandler();
   
   	if( wrapper==null )
  @@ -199,44 +343,23 @@
   	    return 0;
   	}
   
  -	if( useJspServlet ) {
  -	    // this code can be optimized - but it's tiny compared
  -	    // with what happens in jsp servlet ( compiling a java
  -	    // program or the jspServlet overhead )
  -	    ServletHandler jspServlet=(ServletHandler)wrapper;
  -	    if( ! "jsp".equals( jspServlet.getServletClassName())  )
  -		return 0; // it's all set, the JspServlet will do the job.
  -
  -	    if( debug > 0 ) {
  -		log( "Using jsp servlet !");
  -		//enable jasperServlet logging
  -		org.apache.jasper.Constants.jasperLog=
  -		    org.apache.tomcat.util.log.Logger.getDefaultLogger();
  -		org.apache.jasper.Constants.jasperLog.
  -		    setVerbosityLevel("debug");
  -	    }
  -
  -	    // it's the first time a jsp is invoked, the jspServlet
  -	    // is not setup
  -	    jspServlet.
  -		setServletClassName("org.apache.jasper.servlet.JspServlet");
  -	    Context ctx=req.getContext();
  -	    ctx.setAttribute( "org.apache.tomcat.classloader",
  -			      ctx.getClassLoader());
  -	    // XXX set the options
  -	    // 	 jspServlet.getServletInfo().addInitParam("jspCompilerPlugin",
  -	    // 	  "org.apache.jasper.compiler.JikesJavaCompiler");
  -	    return 0;
  -	    // nothing else happens during request map
  -	    // XXX this can be done at context add time
  -	}
  -	
   	ServletHandler handler=null;
   	String jspFile=null;
  +
  +	// There are 2 cases: extension mapped and exact map with
  +	// a <servlet> with file-name declaration
  +
  +	// note that this code is called only the first time
  +	// the jsp page is called - all other calls will treat the jsp
  +	// as a regular servlet, nothing is special except the initial
  +	// processing.
   
  -	// if it's an extension mapped file, construct and map a handler
  +	// XXX deal with jsp_compile
  +	
   	if( "jsp".equals( wrapper.getName())) {
  +	    // if it's an extension mapped file, construct and map a handler
   	    jspFile=req.servletPath().toString();
  +	    
   	    // extension mapped jsp - define a new handler,
   	    // add the exact mapping to avoid future overhead
   	    handler= mapJspPage( req.getContext(), jspFile );
  @@ -248,15 +371,20 @@
   	    if( jspFile==null )
   		return 0; // not a jsp
   	}
  -	
  +
  +	// Each .jsp file is compiled to a servlet, and will
  +	// have a dependency to check if it's expired
   	Dependency dep= handler.getServletInfo().getDependency();
   	if( dep!=null && ! dep.isExpired() ) {
   	    // if the jspfile is older than the class - we're ok
  +	    // this happens if the .jsp file was compiled in a previous
  +	    // run of tomcat.
   	    return 0;
   	}
   
  -	JasperLiaison liasion=new JasperLiaison(getLog(), debug, options);
  -	liasion.processJspFile(req, jspFile, handler);
  +	// we need to compile... ( or find previous .class )
  +	JasperLiaison liasion=new JasperLiaison(getLog(), debug);
  +	liasion.processJspFile(req, jspFile, handler, args);
   	return 0;
       }
   
  @@ -270,7 +398,7 @@
        *  <servlet-mapping><servlet-name>tomcat.jsp.[uri]</>
        *                   <url-pattern>[uri]</></>
        */
  -    ServletHandler mapJspPage( Context ctx, String uri)
  +    private ServletHandler mapJspPage( Context ctx, String uri)
       {
   	String servletName= SERVLET_NAME_PREFIX + uri;
   
  @@ -315,12 +443,10 @@
   final class JasperLiaison {
       Log log;
       final int debug;
  -    Options options;
       
  -    JasperLiaison( Log log, int debug, Options options ) {
  +    JasperLiaison( Log log, int debug ) {
   	this.log=log;
   	this.debug=debug;
  -	this.options=options;
       }
       
       /** Generate mangled names, check for previous versions,
  @@ -329,7 +455,7 @@
        *  changes ). 
        */
       int processJspFile(Request req, String jspFile,
  -				ServletHandler handler)
  +		       ServletHandler handler, Properties args)
       {
   	// ---------- Expensive part - compile and load
   	
  @@ -351,8 +477,8 @@
   	    
   	    // Mangle the names - expensive operation, but nothing
   	    // compared with a compilation :-)
  -	    JspMangler mangler=
  -		new JspMangler(ctx.getWorkDir().getAbsolutePath(),
  +	    JasperMangler mangler=
  +		new JasperMangler(ctx.getWorkDir().getAbsolutePath(),
   			       ctx.getAbsolutePath(),
   			       jspFile );
   
  @@ -368,8 +494,9 @@
   		    return 0;
   	    }
   
  -	    if( debug > 3) 
  -		log.log( "Jsp source changed, recompiling: " + jspFile );
  +	    //	    if( debug > 3) 
  +	    log.log( "Compiling: " + jspFile + " to " +
  +		     mangler.getServletClassName());
   	    
   	    //XXX old servlet -  destroy(); 
   	    
  @@ -391,9 +518,30 @@
   		log.log( "Update class Name " + mangler.getServletClassName());
   	    handler.setServletClassName( mangler.getServletClassName() );
   
  -	    compile( handler, req, mangler );
  -	    
   	    
  +	    try {
  +		Options options=new JasperOptionsImpl(args); 
  +		JspCompilationContext ctxt=createCompilationContext(req,
  +								    options,
  +								    mangler);
  +		JavaCompiler javaC=createJavaCompiler( options );
  +
  +		jsp2java( mangler, ctxt );
  +		javac( javaC, ctxt, mangler );
  +	    
  +		if(debug>0)log.log( "Generated " +
  +				    mangler.getClassFileName() );
  +	    } catch( Exception ex ) {
  +		if( ctx!=null )
  +		    ctx.log("compile error: req="+req, ex);
  +		else
  +		    log.log("compile error: req="+req, ex);
  +		handler.setErrorException(ex);
  +		handler.setState(Handler.STATE_DISABLED);
  +		// until the jsp cahnges, when it'll be enabled again
  +		return 0;
  +	    }
  +
   	    dep.setExpired( false );
   	    
   	}
  @@ -403,47 +551,31 @@
   
       /** Convert the .jsp file to a java file, then compile it to class
        */
  -    void compile(Handler wrapper, Request req, JspMangler mangler ) {
  +    void jsp2java(JasperMangler mangler,  JspCompilationContext ctxt)
  +	throws Exception
  +    {
   	if( debug > 0 ) log.log( "Generating " + mangler.getJavaFileName());
  -	try {
  -	    // make sure we have the directories
  -	    String javaFileName=mangler.getJavaFileName();
  -	    
  -	    File javaFile=new File(javaFileName);
  -	    
  -	    // make sure the directory is created
  -	    new File( javaFile.getParent()).mkdirs();
  -
  -	    JspEngineContext1 ctxt = new JspEngineContext1(log,req, mangler);
  -	    ctxt.setOptions( options );
  -	    
  -	    Compiler compiler=new Compiler(ctxt);
  -	    compiler.setMangler( mangler );
  -	    // we will compile ourself
  -	    compiler.setJavaCompiler( null );
  -	    
  -	    
  -	    synchronized ( mangler ) {
  -		compiler.compile();
  -	    }
  -	    if( debug > 0 ) {
  -		File f = new File( mangler.getJavaFileName());
  -		log.log( "Created file : " + f +  " " + f.lastModified());
  -		
  -	    }
  -	    javac( createJavaCompiler( options ), ctxt, mangler );
  +	// make sure we have the directories
  +	String javaFileName=mangler.getJavaFileName();
  +	
  +	File javaFile=new File(javaFileName);
  +	
  +	// make sure the directory is created
  +	new File( javaFile.getParent()).mkdirs();
  +	
  +	Compiler compiler=new Compiler(ctxt);
  +	compiler.setMangler( mangler );
  +	// we will compile ourself
  +	compiler.setJavaCompiler( null );
  +	
  +	
  +	synchronized ( mangler ) {
  +	    compiler.compile();
  +	}
  +	if( debug > 0 ) {
  +	    File f = new File( mangler.getJavaFileName());
  +	    log.log( "Created file : " + f +  " " + f.lastModified());
   	    
  -	    if(debug>0)log.log( "Generated " + mangler.getClassFileName() );
  -	} catch( Exception ex ) {
  -	    Context ctx=req.getContext();
  -	    if( ctx!=null )
  -		ctx.log("compile error: req="+req, ex);
  -	    else
  -		log.log("compile error: req="+req, ex);
  -	    wrapper.setErrorException(ex);
  -	    wrapper.setState(Handler.STATE_DISABLED);
  -	    // until the jsp cahnges, when it'll be enabled again
  -
   	}
       }
       
  @@ -455,7 +587,7 @@
   	keep it part of jasper
       */
       void javac(JavaCompiler javac, JspCompilationContext ctxt,
  -		      Mangler mangler)
  +	       Mangler mangler)
   	throws JasperException
       {
   
  @@ -470,7 +602,7 @@
           javac.setMsgOutput(out);
   
   	String javaFileName = mangler.getJavaFileName();
  -	if( debug>0) log.log( "Compiling java file " + javaFileName);
  +	if( debug>0 ) log.log( "Compiling java file " + javaFileName);
   	/**
            * Execute the compiler
            */
  @@ -489,7 +621,7 @@
   	if( debug > 0 ) log.log("Compiled ok");
       }
   
  -    /** tool for customizing javac
  +    /** tool for customizing javac.
        */
       public JavaCompiler createJavaCompiler(Options options)
   	throws JasperException
  @@ -518,9 +650,38 @@
   
   	return javac;
       }
  +
  +    private String computeClassPath(Context ctx) {
  +	URL classP[]=ctx.getClassPath();
  +	String separator = System.getProperty("path.separator", ":");
  +        String cpath = "";
  +        for(int i=0; i< classP.length; i++ ) {
  +            URL cp = classP[i];
  +            File f = new File( cp.getFile());
  +            if (cpath.length()>0) cpath += separator;
  +            cpath += f;
  +        }
  +	return cpath;
  +    }
   
  -    private Dependency setDependency( Context ctx, JspMangler mangler,
  -				ServletHandler handler )
  +    private JspCompilationContext createCompilationContext( Request req,
  +							    Options opt,
  +							    Mangler mangler)
  +    {
  +	JasperEngineContext ctxt = new JasperEngineContext();
  +	ctxt.setServletClassName( mangler.getClassName());
  +	ctxt.setJspFile( req.servletPath().toString());
  +	ctxt.setClassPath( computeClassPath( req.getContext()) );
  +	ctxt.setServletContext( req.getContext().getFacade());
  +	ctxt.setOptions( opt );
  +	ctxt.setClassLoader( req.getContext().getClassLoader());
  +	ctxt.setOutputDir(req.getContext().getWorkDir().getAbsolutePath());
  +	return ctxt;
  +    }
  +    
  +    // Add an "expire check" to the generated servlet.
  +    private Dependency setDependency( Context ctx, JasperMangler mangler,
  +				      ServletHandler handler )
       {
   	ServletInfo info=handler.getServletInfo();
   	// create a lastModified checker.
  @@ -529,9 +690,9 @@
   	dep.setOrigin( new File(mangler.getJspFilePath()) );
   	dep.setTarget( handler );
   	dep.setLocal( true );
  +	File f=new File( mangler.getClassFileName() );
   	if( mangler.getVersion() > 0 ) {
   	    // it has a previous version
  -	    File f=new File( mangler.getClassFileName() );
   	    dep.setLastModified(f.lastModified());
   	    // update the "expired" variable
   	    dep.checkExpiry();
  @@ -539,6 +700,12 @@
   	    dep.setLastModified( -1 );
   	    dep.setExpired( true );
   	}
  +	if( debug>0 )
  +	    log.log( "file = " + mangler.getClassFileName() + " " +
  +		     f.lastModified() );
  +	if( debug>0 )
  +	    log.log("origin = " + dep.getOrigin() + " " +
  +		    dep.getOrigin().lastModified());
   	ctx.getDependManager().addDependency( dep );
   	info.setDependency( dep );
   	return dep;
  @@ -546,548 +713,3 @@
   	
   
   }
  -
  -// -------------------- Jasper support - options --------------------
  -
  -class TomcatOptions implements Options {
  -    public boolean keepGenerated = true;
  -    public boolean largeFile = false;
  -    public boolean mappedFile = false;
  -    public boolean sendErrorToClient = false;
  -    public boolean classDebugInfo = false;
  -    public String ieClassId = "clsid:8AD9C840-044E-11D1-B3E9-00805F499D93";
  -    public Class jspCompilerPlugin = null;
  -    public String jspCompilerPath = null;
  -    public int debug=0;
  -    
  -    public File scratchDir;
  -    private Object protectionDomain;
  -    public String classpath = null;
  -
  -    public boolean getKeepGenerated() {
  -        return keepGenerated;
  -    }
  -
  -    public String getJavaEncoding() {
  -	return "UTF8";
  -    }
  -
  -    public boolean getLargeFile() {
  -        return largeFile;
  -    }
  -
  -    public boolean getMappedFile() {
  -        return mappedFile;
  -    }
  -    
  -    public boolean getSendErrorToClient() {
  -        return sendErrorToClient;
  -    }
  - 
  -    public boolean getClassDebugInfo() {
  -        return classDebugInfo;
  -    }
  -
  -    public String getIeClassId() {
  -        return ieClassId;
  -    }
  -
  -    public void setScratchDir( File f ) {
  -	scratchDir=f;
  -    }
  -    
  -    public File getScratchDir() {
  -	if( debug>0 ) log("Options: getScratchDir " + scratchDir);
  -        return scratchDir;
  -    }
  -
  -    public final Object getProtectionDomain() {
  -	if( debug>0 ) log("Options: GetPD" );
  -	return protectionDomain;
  -    }
  -
  -    public String getClassPath() {
  -	if( debug>0 ) log("Options: GetCP " + classpath  );
  -        return classpath;
  -    }
  -
  -    public Class getJspCompilerPlugin() {
  -        return jspCompilerPlugin;
  -    }
  -
  -    public String getJspCompilerPath() {
  -        return jspCompilerPath;
  -    }
  -
  -    void log(String s) {
  -	System.err.println(s);
  -    }
  -    
  -}
  -
  -// -------------------- Jasper support - JspCompilationContext -------------
  -
  -class JspEngineContext1 implements JspCompilationContext {
  -    JspReader reader;
  -    ServletWriter writer;
  -    ServletContext context;
  -    JspLoader loader;
  -    String classpath; // for compiling JSPs.
  -    boolean isErrPage;
  -    String jspFile;
  -    String servletClassName;
  -    String servletPackageName;
  -    String servletJavaFileName;
  -    String contentType;
  -    Options options;
  -    public int debug=0;
  -    
  -    Request req;
  -    Mangler m;
  -    Log log;
  -    
  -    public JspEngineContext1(Log log, Request req, Mangler m)
  -    {
  -	this.log=log;
  -	this.req=req;
  -	this.m=m;
  -    }
  -
  -    public HttpServletRequest getRequest() {
  -	if( debug>0 ) log.log("getRequest " + req );
  -        return (HttpServletRequest)req.getFacade();
  -    }
  -    
  -
  -    /**
  -     * Get the http response we are using now...
  -     */
  -    public HttpServletResponse getResponse() {
  -	if( debug>0 ) log.log("getResponse " );
  -        return (HttpServletResponse)req.getResponse().getFacade();
  -    }
  -
  -    /**
  -     * The classpath that is passed off to the Java compiler. 
  -     */
  -    public String getClassPath() {
  -	Context ctx=req.getContext();
  -	URL classP[]=ctx.getClassPath();
  -	String separator = System.getProperty("path.separator", ":");
  -        String cpath = "";
  -	
  -        for(int i=0; i< classP.length; i++ ) {
  -            URL cp = classP[i];
  -            File f = new File( cp.getFile());
  -            if (cpath.length()>0) cpath += separator;
  -            cpath += f;
  -        }
  -
  -	if( debug>0 ) log.log("getClassPath " + cpath);
  -	return cpath;
  -    }
  -    
  -    /**
  -     * Get the input reader for the JSP text. 
  -     */
  -    public JspReader getReader() {
  -	if( debug>0 ) log.log("getReader " + reader );
  -        return reader;
  -    }
  -    
  -    /**
  -     * Where is the servlet being generated?
  -     */
  -    public ServletWriter getWriter() {
  -	if( debug>0 ) log.log("getWriter " + writer );
  -        return writer;
  -    }
  -    
  -    /**
  -     * Get the ServletContext for the JSP we're processing now. 
  -     */
  -    public ServletContext getServletContext() {
  -	if( debug>0 ) log.log("getCtx " +
  -			   req.getContext().getFacade());
  -        return (ServletContext)req.getContext().getFacade();
  -    }
  -    
  -    /**
  -     * What class loader to use for loading classes while compiling
  -     * this JSP? I don't think this is used right now -- akv. 
  -     */
  -    public ClassLoader getClassLoader() {
  -	if( debug>0 ) log.log("getLoader " + loader );
  -        return req.getContext().getClassLoader();
  -    }
  -
  -    public void addJar( String jar ) throws IOException {
  -	if( debug>0 ) log.log("Add jar " + jar);
  -	//loader.addJar( jar );
  -    }
  -
  -    /**
  -     * Are we processing something that has been declared as an
  -     * errorpage? 
  -     */
  -    public boolean isErrorPage() {
  -	if( debug>0 ) log.log("isErrorPage " + isErrPage );
  -        return isErrPage;
  -    }
  -    
  -    /**
  -     * What is the scratch directory we are generating code into?
  -     * FIXME: In some places this is called scratchDir and in some
  -     * other places it is called outputDir.
  -     */
  -    public String getOutputDir() {
  -	if( debug>0 ) log.log("getOutputDir " +
  -			   req.getContext().getWorkDir().getAbsolutePath());
  -        return req.getContext().getWorkDir().getAbsolutePath();
  -    }
  -    
  -    /**
  -     * Path of the JSP URI. Note that this is not a file name. This is
  -     * the context rooted URI of the JSP file. 
  -     */
  -    public String getJspFile() {
  -	String sP=req.servletPath().toString();
  -	Context ctx=req.getContext();
  -	if( debug>0 ) log.log("getJspFile " +
  -			   sP);//   ctx.getRealPath( sP ) );
  -	//        return ctx.getRealPath( sP );
  -	return sP;
  -    }
  -    
  -    /**
  -     * Just the class name (does not include package name) of the
  -     * generated class. 
  -     */
  -    public String getServletClassName() {
  -	if( debug>0 ) log.log("getServletClassName " +
  -			   m.getClassName());
  -        return m.getClassName();
  -    }
  -    
  -    /**
  -     * The package name into which the servlet class is generated. 
  -     */
  -    public String getServletPackageName() {
  -	if( debug>0 ) log.log("getServletPackageName " +
  -			   servletPackageName );
  -        return servletPackageName;
  -    }
  -
  -    /**
  -     * Utility method to get the full class name from the package and
  -     * class name. 
  -     */
  -    public final String getFullClassName() {
  -	if( debug>0 ) log.log("getServletPackageName " +
  -			   servletPackageName + "." + servletClassName);
  -        if (servletPackageName == null)
  -            return servletClassName;
  -        return servletPackageName + "." + servletClassName;
  -    }
  -
  -    /**
  -     * Full path name of the Java file into which the servlet is being
  -     * generated. 
  -     */
  -    public String getServletJavaFileName() {
  -	if( debug>0 ) log.log("getServletPackageName " +
  -			   servletPackageName + "." + servletClassName);
  -        return servletJavaFileName;
  -    }
  -
  -    /**
  -     * Are we keeping generated code around?
  -     */
  -    public boolean keepGenerated() {
  -        return options.getKeepGenerated();
  -    }
  -
  -    /**
  -     * What's the content type of this JSP? Content type includes
  -     * content type and encoding. 
  -     */
  -    public String getContentType() {
  -        return contentType;
  -    }
  -
  -    /**
  -     * Get hold of the Options object for this context. 
  -     */
  -    public Options getOptions() {
  -        return options;
  -    }
  -
  -    public void setOptions(Options options) {
  -	this.options=options;
  -    }
  -    
  -    public void setContentType(String contentType) {
  -        this.contentType = contentType;
  -    }
  -
  -    public void setReader(JspReader reader) {
  -        this.reader = reader;
  -    }
  -    
  -    public void setWriter(ServletWriter writer) {
  -        this.writer = writer;
  -    }
  -    
  -    public void setServletClassName(String servletClassName) {
  -        this.servletClassName = servletClassName;
  -    }
  -    
  -    public void setServletPackageName(String servletPackageName) {
  -        this.servletPackageName = servletPackageName;
  -    }
  -    
  -    public void setServletJavaFileName(String servletJavaFileName) {
  -        this.servletJavaFileName = servletJavaFileName;
  -    }
  -    
  -    public void setErrorPage(boolean isErrPage) {
  -        this.isErrPage = isErrPage;
  -    }
  -
  -    public Compiler createCompiler() throws JasperException {
  -	if( debug>0 ) log.log("createCompiler ");
  -	return null;
  -    }
  -    
  -    public String resolveRelativeUri(String uri)
  -    {
  -	if( debug>0 ) log.log("resolveRelativeUri " +
  -				 uri);
  -	return null;
  -    };    
  -
  -    public java.io.InputStream getResourceAsStream(String res)
  -    {
  -	if( debug>0 ) log.log("getResourceAsStream " + res);
  -        ServletContext sctx=(ServletContext)req.getContext().getFacade();
  -	return sctx.getResourceAsStream(res);
  -    };
  -
  -    /** 
  -     * Gets the actual path of a URI relative to the context of
  -     * the compilation.
  -     */
  -    public String getRealPath(String path)
  -    {
  -	if( debug>0 ) log.log("GetRP " + path);
  -	Context ctx=req.getContext();
  -	return FileUtil.safePath( ctx.getAbsolutePath(),
  -				  path);
  -    };
  -}
  -
  -// -------------------- Jasper support - mangler --------------------
  -
  -final class JspMangler implements Mangler{
  -
  -    public JspMangler(String workDir, String docBase, String jspFile)
  -    {
  -	this.jspFile=jspFile;
  -	this.workDir=workDir;
  -	this.docBase=docBase;
  -	init();
  -    }
  -
  -    /** Versioned class name ( without package ).
  -     */
  -    public String getClassName() {
  -	return JavaGeneratorTool.getVersionedName( baseClassN, version );
  -    }
  -    
  -    /**
  -     *   Full path to the generated java file ( including version )
  -     */
  -    public String getJavaFileName() {
  -	return javaFileName;
  -    }
  -
  -    /** The package name ( "." separated ) of the generated
  -     *  java file
  -     */
  -    public String getPackageName() {
  -	if( pkgDir!=null ) {
  -	    return pkgDir.replace('/', '.');
  -	} else {
  -	    return null;
  -	}
  -    }
  -
  -    // -------------------- JspInterceptor fields --------------------
  -    
  -    /** Returns the jsp file, as declared by <jsp-file> in server.xml
  -     *  or the context-relative path that was extension mapped to jsp
  -     */
  -    public String getJspFile() {
  -	return jspFile;
  -    }
  -
  -    /** Returns the directory where the class is located, using
  -     *  the normal class loader rules.
  -     */
  -    public String getClassDir() {
  -	return classDir;
  -    }
  -    
  -    /** The class name ( package + class + versioning ) of the
  -     *  compilation result
  -     */
  -    public String getServletClassName() {
  -	if( pkgDir!=null ) {
  -	    return getPackageName()  + "." + getClassName();
  -	} else {
  -	    return getClassName();
  -	}
  -    }
  -
  -    public int getVersion() {
  -	return version;
  -    }
  -
  -    /** Full path to the compiled class file ( including version )
  -     */
  -    public String getClassFileName() {
  -	return classFileName;
  -    }
  -    // In Jasper = not used - it's specific to the class scheme
  -    // used by JspServlet
  -    // Full path to the class file - without version.
  -    
  -
  -    public String getBaseClassName() {
  -	return baseClassN;
  -    }
  -
  -    public String getPackageDir() {
  -	return pkgDir;
  -    }
  -    
  -    public String getJspFilePath() {
  -	return FileUtil.safePath( docBase, jspFile);
  -    }
  -
  -    private String fixInvalidChars(String className) {
  -	// Fix for invalid characters. From CommandLineCompiler
  -	StringBuffer modifiedClassName = new StringBuffer();
  -	for (int i = 0; i < className.length(); i++) {
  -	    char c=className.charAt(i);
  -	    if (Character.isLetterOrDigit(c) == true ||
  -		c=='_' ||
  -		c=='/' )
  -		modifiedClassName.append(className.substring(i,i+1));
  -	    else
  -		modifiedClassName.append(mangleChar(className.charAt(i)));
  -	}
  -	return modifiedClassName.toString();
  -    }
  -
  -    private static final String mangleChar(char ch) {
  -        if(ch == File.separatorChar) {
  -	    ch = '/';
  -	}
  -	String s = Integer.toHexString(ch);
  -	int nzeros = 5 - s.length();
  -	char[] result = new char[6];
  -	result[0] = '_';
  -	for (int i = 1; i <= nzeros; i++)
  -	    result[i] = '0';
  -	for (int i = nzeros+1, j = 0; i < 6; i++, j++)
  -	    result[i] = s.charAt(j);
  -	return new String(result);
  -    }
  -
  -
  -    
  -    /** compute basic names - pkgDir and baseClassN
  -     */
  -    private void init() {
  -	int lastComp=jspFile.lastIndexOf(  "/" );
  -
  -	if( lastComp > 0 ) {
  -	    // has package 
  -	    // ignore the first "/" of jspFile
  -	    pkgDir=jspFile.substring( 1, lastComp );
  -	}
  -	
  -	// remove "special" words, replace "."
  -	if( pkgDir!=null ) {
  -	    pkgDir=JavaGeneratorTool.manglePackage(pkgDir);
  -	    pkgDir=pkgDir.replace('.', '_');
  -	    pkgDir=fixInvalidChars( pkgDir );
  -	    classDir=workDir + "/" + pkgDir;
  -	} else {
  -	    classDir=workDir;
  -	}
  -	
  -	int extIdx=jspFile.lastIndexOf( "." );
  -
  -	if( extIdx<0 ) {
  -	    // no "." 
  -	    if( lastComp > 0 )
  -		baseClassN=jspFile.substring( lastComp+1 );
  -	    else
  -		baseClassN=jspFile.substring( 1 );
  -	} else {
  -	    if( lastComp > 0 )
  -		baseClassN=jspFile.substring( lastComp+1, extIdx );
  -	    else
  -		baseClassN=jspFile.substring( 1, extIdx );
  -	}
  -
  -	baseClassN=fixInvalidChars( baseClassN );
  -	
  -	//	System.out.println("XXXMangler: " + jspFile + " " +
  -	// pkgDir + " " + baseClassN);
  -
  -	// extract version from the .class dir, using the base name
  -	version=JavaGeneratorTool.readVersion(classDir,
  -					      baseClassN);
  -	if( version==-1 ) {
  -	    version=0;
  -	} 
  -	updateVersionPaths();
  -    }
  -
  -    private void updateVersionPaths() {
  -	// version dependent stuff
  -	String baseName=classDir + "/" + JavaGeneratorTool.
  -	    getVersionedName( baseClassN, version);
  -	
  -	javaFileName= baseName + ".java";
  -
  -	classFileName=baseName +  ".class";
  -    }
  -    
  -    /** Move to a new class name, if a changes has been detected.
  -     */
  -    void nextVersion() {
  -	version++;
  -	JavaGeneratorTool.writeVersion( getClassDir(), baseClassN, version);
  -	updateVersionPaths();
  -    }
  -
  -    // context-relative jsp path 
  -    // extracted from the <jsp-file> or the result of a *.jsp mapping
  -    private String jspFile; 
  -    // version of the compiled java file
  -    private int version;
  -    private String workDir;
  -    private String docBase;
  -    // the "/" separted version
  -    private String pkgDir;
  -    // class name without package and version
  -    private String baseClassN;
  -    private String classDir;
  -    private String javaFileName;
  -    private String classFileName;
  -}
  -
  
  
  
  1.14      +1 -1      jakarta-tomcat/src/facade22/org/apache/tomcat/facade/RequestDispatcherImpl.java
  
  Index: RequestDispatcherImpl.java
  ===================================================================
  RCS file: /home/cvs/jakarta-tomcat/src/facade22/org/apache/tomcat/facade/RequestDispatcherImpl.java,v
  retrieving revision 1.13
  retrieving revision 1.14
  diff -u -r1.13 -r1.14
  --- RequestDispatcherImpl.java	2001/01/26 02:59:55	1.13
  +++ RequestDispatcherImpl.java	2001/01/28 19:45:52	1.14
  @@ -285,7 +285,7 @@
   	    includeNamed( request, response );
   	    return;
   	}
  -	
  +
   	// Implement the spec that "no changes in response, only write"
   	// can also be done by setting the response to 0.9 mode
   	//	IncludedResponse iResponse = new IncludedResponse(realResponse);
  
  
  

Mime
View raw message