protected  void addExtension(String extension) 
{
        if(extension != null) {
            if(extensions == null) {
                extensions = new Vector();
            }
            extensions.add(extension);
        }
}

Adds the given file extension to the list of extensions handled as JSP files.

 protected  void completeWebXml() 
{
        if (mapout != null) {
            try {
                servletout.writeTo(mapout);
                mappingout.writeTo(mapout);
                if (webxmlLevel  >= ALL_WEBXML) {
                    mapout.write(Localizer.getMessage("jspc.webxml.footer"));
                } else if ((webxmlLevel  >= INC_WEBXML) && !addWebXmlMappings) {
                    mapout.write(Localizer.getMessage("jspc.webinc.footer"));
                }
                mapout.close();
            } catch (IOException ioe) {
                // noting to do if it fails since we are done with it
            }
        }
}

 public  void execute() throws JasperException 
{
        if(log.isDebugEnabled()) {
            log.debug("execute() starting for " + pages.size() + " pages.");
        }
        try {
            if (uriRoot == null) {
                if( pages.size() == 0 ) {
                    throw new JasperException(
                        Localizer.getMessage("jsp.error.jspc.missingTarget"));
                }
                String firstJsp = (String) pages.get( 0 );
                File firstJspF = new File( firstJsp );
                if (!firstJspF.exists()) {
                    throw new JasperException(
                        Localizer.getMessage("jspc.error.fileDoesNotExist",
                                             firstJsp));
                }
                locateUriRoot( firstJspF );
            }
            if (uriRoot == null) {
                throw new JasperException(
                    Localizer.getMessage("jsp.error.jspc.no_uriroot"));
            }
            if( context==null ) {
                initServletContext();
            }
            // No explicit pages, we'll process all .jsp in the webapp
            if (pages.size() == 0) {
                scanFiles( new File( uriRoot ));
            }
            File uriRootF = new File(uriRoot);
            if (!uriRootF.exists() || !uriRootF.isDirectory()) {
                throw new JasperException(
                    Localizer.getMessage("jsp.error.jspc.uriroot_not_dir"));
            }
            initWebXml();
            Iterator iter = pages.iterator();
            while (iter.hasNext()) {
                String nextjsp = iter.next().toString();
                File fjsp = new File(nextjsp);
                if (!fjsp.isAbsolute()) {
                    fjsp = new File(uriRootF, nextjsp);
                }
                if (!fjsp.exists()) {
                    if (log.isWarnEnabled()) {
                        log.warn
                            (Localizer.getMessage
                             ("jspc.error.fileDoesNotExist", fjsp.toString()));
                    }
                    continue;
                }
                String s = fjsp.getAbsolutePath();
                if (s.startsWith(uriRoot)) {
                    nextjsp = s.substring(uriRoot.length());
                }
                if (nextjsp.startsWith("." + File.separatorChar)) {
                    nextjsp = nextjsp.substring(2);
                }
                processFile(nextjsp);
            }
            completeWebXml();
            if (addWebXmlMappings) {
                mergeIntoWebXml();
            }
        } catch (IOException ioe) {
            throw new JasperException(ioe);
        } catch (JasperException je) {
            Throwable rootCause = je;
            while (rootCause instanceof JasperException
                    && ((JasperException) rootCause).getRootCause() != null) {
                rootCause = ((JasperException) rootCause).getRootCause();
            }
            if (rootCause != je) {
                rootCause.printStackTrace();
            }
            throw je;
        } finally {
            if (loader != null) {
                LogFactory.release(loader);
            }
        }
}

Executes the compilation.

 public boolean genStringAsCharArray() 
{
        return genStringAsCharArray;
}

Indicates whether text strings are to be generated as char arrays.

 public  void generateWebMapping(String file,
    JspCompilationContext clctxt) throws IOException 
{
        if (log.isDebugEnabled()) {
            log.debug("Generating web mapping for file " + file
                      + " using compilation context " + clctxt);
        }
        String className = clctxt.getServletClassName();
        String packageName = clctxt.getServletPackageName();
        String thisServletName;
        if  ("".equals(packageName)) {
            thisServletName = className;
        } else {
            thisServletName = packageName + '." + className;
        }
        if (servletout != null) {
            servletout.write("\n    < servlet >\n        < servlet-name >");
            servletout.write(thisServletName);
            servletout.write("< /servlet-name >\n        < servlet-class >");
            servletout.write(thisServletName);
            servletout.write("< /servlet-class >\n    < /servlet >\n");
        }
        if (mappingout != null) {
            mappingout.write("\n    < servlet-mapping >\n        < servlet-name >");
            mappingout.write(thisServletName);
            mappingout.write("< /servlet-name >\n        < url-pattern >");
            mappingout.write(file.replace('\\", '/"));
            mappingout.write("< /url-pattern >\n    < /servlet-mapping >\n");
        }
}

 public Map getCache() 
{
        return cache;
}

 public int getCheckInterval() 
{
        return 0;
}

Background compilation check intervals in seconds

 public boolean getClassDebugInfo() 
{
        // compile with debug info
        return classDebugInfo;
}

 public String getClassPath() 
{
        if( classPath != null )
            return classPath;
        return System.getProperty("java.class.path");
}

 public String getCompiler() 
{
        return compiler;
}

Compiler to use.

 public String getCompilerClassName() 
{
        return null;
}

Compiler class name to use.

 public String getCompilerSourceVM() 
{
         return compilerSourceVM;
}

 public String getCompilerTargetVM() 
{
        return compilerTargetVM;
}

 public boolean getDevelopment() 
{
        return false;
}

Is Jasper being used in development mode?

 public boolean getDisplaySourceFragment() 
{
        return true;
}

 public boolean getErrorOnUseBeanInvalidClassAttribute() 
{
        return errorOnUseBeanInvalidClassAttribute;
}

 public List getExtensions() 
{
        return extensions;
}

Returns the list of file extensions that are treated as JSP files.

 public boolean getFailOnError() 
{
        return failOnError;
}

 public boolean getFork() 
{
        return false;
}

 public String getIeClassId() 
{
        return ieClassId;
}

Gets the class-id value that is sent to Internet Explorer when using tags.

 public String getJavaEncoding() 
{
        return javaEncoding;
}

Returns the encoding to use for java files. The default is UTF-8.

 public String getJspCompilerPath() 
{
       // we don't compile, so this is meanlingless
        return null;
}

 public Class getJspCompilerPlugin() 
{
       // we don't compile, so this is meanlingless
        return null;
}

 public JspConfig getJspConfig() 
{
        return jspConfig;
}

Obtain JSP configuration informantion specified in web.xml.

 public boolean getKeepGenerated() 
{
        // isn't this why we are running jspc?
        return true;
}

 public boolean getMappedFile() 
{
        return mappedFile;
}

Are we supporting HTML mapped servlets?

 public int getModificationTestInterval() 
{
        return 0;
}

Modification test interval.

 public Project getProject() 
{
        return project;
}

Returns the project: may be null if not running inside an Ant project.

 public Object getProtectionDomain() 
{
        return null;
}

 public File getScratchDir() 
{
        return scratchDir;
}

 public boolean getSendErrorToClient() 
{
        return true;
}

 public TagPluginManager getTagPluginManager() 
{
        return tagPluginManager;
}

 public int getTagPoolSize() 
{
        return Constants.MAX_POOL_SIZE;
}

 public TldLocationsCache getTldLocationsCache() 
{
        return tldLocationsCache;
}

 public boolean getTrimSpaces() 
{
        return trimSpaces;
}

 protected  void initClassLoader(JspCompilationContext clctxt) throws IOException 
{
        classPath = getClassPath();
        ClassLoader jspcLoader = getClass().getClassLoader();
        if (jspcLoader instanceof AntClassLoader) {
            classPath += File.pathSeparator
                + ((AntClassLoader) jspcLoader).getClasspath();
        }
        // Turn the classPath into URLs
        ArrayList< URL > urls = new ArrayList< URL >();
        StringTokenizer tokenizer = new StringTokenizer(classPath,
                                                        File.pathSeparator);
        while (tokenizer.hasMoreTokens()) {
            String path = tokenizer.nextToken();
            try {
                File libFile = new File(path);
                urls.add(libFile.toURL());
            } catch (IOException ioe) {
                // Failing a toCanonicalPath on a file that
                // exists() should be a JVM regression test,
                // therefore we have permission to freak uot
                throw new RuntimeException(ioe.toString());
            }
        }
        File webappBase = new File(uriRoot);
        if (webappBase.exists()) {
            File classes = new File(webappBase, "/WEB-INF/classes");
            try {
                if (classes.exists()) {
                    classPath = classPath + File.pathSeparator
                        + classes.getCanonicalPath();
                    urls.add(classes.getCanonicalFile().toURL());
                }
            } catch (IOException ioe) {
                // failing a toCanonicalPath on a file that
                // exists() should be a JVM regression test,
                // therefore we have permission to freak out
                throw new RuntimeException(ioe.toString());
            }
            File lib = new File(webappBase, "/WEB-INF/lib");
            if (lib.exists() && lib.isDirectory()) {
                String[] libs = lib.list();
                for (int i = 0; i <  libs.length; i++) {
                    if( libs[i].length() < 5 ) continue;
                    String ext=libs[i].substring( libs[i].length() - 4 );
                    if (! ".jar".equalsIgnoreCase(ext)) {
                        if (".tld".equalsIgnoreCase(ext)) {
                            log.warn("TLD files should not be placed in "
                                     + "/WEB-INF/lib");
                        }
                        continue;
                    }
                    try {
                        File libFile = new File(lib, libs[i]);
                        classPath = classPath + File.pathSeparator
                            + libFile.getAbsolutePath();
                        urls.add(libFile.getAbsoluteFile().toURL());
                    } catch (IOException ioe) {
                        // failing a toCanonicalPath on a file that
                        // exists() should be a JVM regression test,
                        // therefore we have permission to freak out
                        throw new RuntimeException(ioe.toString());
                    }
                }
            }
        }
        // What is this ??
        urls.add(new File(clctxt.getRealPath("/")).getCanonicalFile().toURL());
        URL urlsA[]=new URL[urls.size()];
        urls.toArray(urlsA);
        loader = new URLClassLoader(urlsA, this.getClass().getClassLoader());
}

Initializes the classloader as/if needed for the given compilation context.

 protected  void initServletContext() 
{
        try {
            context =new JspCServletContext
                (new PrintWriter(System.out),
                 new URL("file:" + uriRoot.replace('\\",'/") + '/"));
            tldLocationsCache = new TldLocationsCache(context, true);
        } catch (MalformedURLException me) {
            System.out.println("**" + me);
        }
        rctxt = new JspRuntimeContext(context, this);
        jspConfig = new JspConfig(context);
        tagPluginManager = new TagPluginManager(context);
}

 protected  void initWebXml() 
{
        try {
            if (webxmlLevel  >= INC_WEBXML) {
                File fmapings = new File(webxmlFile);
                mapout = new FileWriter(fmapings);
                servletout = new CharArrayWriter();
                mappingout = new CharArrayWriter();
            } else {
                mapout = null;
                servletout = null;
                mappingout = null;
            }
            if (webxmlLevel  >= ALL_WEBXML) {
                mapout.write(Localizer.getMessage("jspc.webxml.header"));
                mapout.flush();
            } else if ((webxmlLevel >= INC_WEBXML) && !addWebXmlMappings) {
                mapout.write(Localizer.getMessage("jspc.webinc.header"));
                mapout.flush();
            }
        } catch (IOException ioe) {
            mapout = null;
            servletout = null;
            mappingout = null;
        }
}

 public boolean isCaching() 
{
        return caching;
}

 public boolean isPoolingEnabled() 
{
        return poolingEnabled;
}

 public boolean isSmapDumped() 
{
        return smapDumped;
}

Should SMAP info for JSR45 debugging be dumped to a file?

 public boolean isSmapSuppressed() 
{
        return smapSuppressed;
}

Is the generation of SMAP info for JSR45 debuggin suppressed?

 public boolean isXpoweredBy() 
{
        return xpoweredBy;
}

 protected  void locateUriRoot(File f) 
{
        String tUriBase = uriBase;
        if (tUriBase == null) {
            tUriBase = "/";
        }
        try {
            if (f.exists()) {
                f = new File(f.getAbsolutePath());
                while (f != null) {
                    File g = new File(f, "WEB-INF");
                    if (g.exists() && g.isDirectory()) {
                        uriRoot = f.getCanonicalPath();
                        uriBase = tUriBase;
                        if (log.isInfoEnabled()) {
                            log.info(Localizer.getMessage(
                                        "jspc.implicit.uriRoot",
                                        uriRoot));
                        }
                        break;
                    }
                    if (f.exists() && f.isDirectory()) {
                        tUriBase = "/" + f.getName() + "/" + tUriBase;
                    }
                    String fParent = f.getParent();
                    if (fParent == null) {
                        break;
                    } else {
                        f = new File(fParent);
                    }
                    // If there is no acceptible candidate, uriRoot will
                    // remain null to indicate to the CompilerContext to
                    // use the current working/user dir.
                }
                if (uriRoot != null) {
                    File froot = new File(uriRoot);
                    uriRoot = froot.getCanonicalPath();
                }
            }
        } catch (IOException ioe) {
            // since this is an optional default and a null value
            // for uriRoot has a non-error meaning, we can just
            // pass straight through
        }
}

Find the WEB-INF dir by looking up in the directory tree. This is used if no explicit docbase is set, but only files. XXX Maybe we should require the docbase.

 public static  void main(String[] arg) 
{
         
        if (arg.length == 0) {
            System.out.println(Localizer.getMessage("jspc.usage"));
        } else {
            try {
                JspC jspc = new JspC();
                jspc.setArgs(arg);
                if (jspc.helpNeeded) {
                    System.out.println(Localizer.getMessage("jspc.usage"));
                } else {
                    jspc.execute();
                }
            } catch (JasperException je) {
                System.err.println(je);
                if (die != NO_DIE_LEVEL) {
                    System.exit(die);
                }
            }
        }
}

 protected  void mergeIntoWebXml() throws IOException 
{
        File webappBase = new File(uriRoot);
        File webXml = new File(webappBase, "WEB-INF/web.xml");
        File webXml2 = new File(webappBase, "WEB-INF/web2.xml");
        String insertStartMarker =
            Localizer.getMessage("jspc.webinc.insertStart");
        String insertEndMarker =
            Localizer.getMessage("jspc.webinc.insertEnd");
        BufferedReader reader = new BufferedReader(new FileReader(webXml));
        BufferedReader fragmentReader =
            new BufferedReader(new FileReader(webxmlFile));
        PrintWriter writer = new PrintWriter(new FileWriter(webXml2));
        // Insert the < servlet > and < servlet-mapping > declarations
        int pos = -1;
        String line = null;
        while (true) {
            line = reader.readLine();
            if (line == null) {
                break;
            }
            // Skip anything previously generated by JSPC
            if (line.indexOf(insertStartMarker)  >= 0) {
                while (true) {
                    line = reader.readLine();
                    if (line == null) {
                        return;
                    }
                    if (line.indexOf(insertEndMarker)  >= 0) {
                        line = reader.readLine();
                        line = reader.readLine();
                        if (line == null) {
                            return;
                        }
                        break;
                    }
                }
            }
            for (int i = 0; i <  insertBefore.length; i++) {
                pos = line.indexOf(insertBefore[i]);
                if (pos  >= 0)
                    break;
            }
            if (pos  >= 0) {
                writer.print(line.substring(0, pos));
                break;
            } else {
                writer.println(line);
            }
        }
        writer.println(insertStartMarker);
        while (true) {
            String line2 = fragmentReader.readLine();
            if (line2 == null) {
                writer.println();
                break;
            }
            writer.println(line2);
        }
        writer.println(insertEndMarker);
        writer.println();
        for (int i = 0; i <  pos; i++) {
            writer.print(" ");
        }
        writer.println(line.substring(pos));
        while (true) {
            line = reader.readLine();
            if (line == null) {
                break;
            }
            writer.println(line);
        }
        writer.close();
        reader.close();
        fragmentReader.close();
        FileInputStream fis = new FileInputStream(webXml2);
        FileOutputStream fos = new FileOutputStream(webXml);
        byte buf[] = new byte[512];
        while (true) {
            int n = fis.read(buf);
            if (n <  0) {
                break;
            }
            fos.write(buf, 0, n);
        }
        fis.close();
        fos.close();
        webXml2.delete();
        (new File(webxmlFile)).delete();
}

Include the generated web.xml inside the webapp's web.xml.

 protected String nextArg() 
{
        if ((argPos  >= args.length)
            || (fullstop = SWITCH_FULL_STOP.equals(args[argPos]))) {
            return null;
        } else {
            return args[argPos++];
        }
}

 protected String nextFile() 
{
        if (fullstop) argPos++;
        if (argPos  >= args.length) {
            return null;
        } else {
            return args[argPos++];
        }
}

 protected  void processFile(String file) throws JasperException 
{
        if (log.isDebugEnabled()) {
            log.debug("Processing file: " + file);
        }
        ClassLoader originalClassLoader = null;
        try {
            // set up a scratch/output dir if none is provided
            if (scratchDir == null) {
                String temp = System.getProperty("java.io.tmpdir");
                if (temp == null) {
                    temp = "";
                }
                scratchDir = new File(new File(temp).getAbsolutePath());
            }
            String jspUri=file.replace('\\",'/");
            JspCompilationContext clctxt = new JspCompilationContext
                ( jspUri, false,  this, context, null, rctxt );
            /* Override the defaults */
            if ((targetClassName != null) && (targetClassName.length()  > 0)) {
                clctxt.setServletClassName(targetClassName);
                targetClassName = null;
            }
            if (targetPackage != null) {
                clctxt.setServletPackageName(targetPackage);
            }
            originalClassLoader = Thread.currentThread().getContextClassLoader();
            if( loader==null ) {
                initClassLoader( clctxt );
            }
            Thread.currentThread().setContextClassLoader(loader);
            clctxt.setClassLoader(loader);
            clctxt.setClassPath(classPath);
            Compiler clc = clctxt.createCompiler();
            // If compile is set, generate both .java and .class, if
            // .jsp file is newer than .class file;
            // Otherwise only generate .java, if .jsp file is newer than
            // the .java file
            if( clc.isOutDated(compile) ) {
                if (log.isDebugEnabled()) {
                    log.debug(jspUri + " is out dated, compiling...");
                }
                clc.compile(compile, true);
            }
            // Generate mapping
            generateWebMapping( file, clctxt );
            if ( showSuccess ) {
                log.info( "Built File: " + file );
            }
        } catch (JasperException je) {
            Throwable rootCause = je;
            while (rootCause instanceof JasperException
                    && ((JasperException) rootCause).getRootCause() != null) {
                rootCause = ((JasperException) rootCause).getRootCause();
            }
            if (rootCause != je) {
                log.error(Localizer.getMessage("jspc.error.generalException",
                                               file),
                          rootCause);
            }
            // Bugzilla 35114.
            if(getFailOnError()) {
                throw je;
            } else {
                log.error(je.getMessage());
            }
        } catch (Exception e) {
            if ((e instanceof FileNotFoundException) && log.isWarnEnabled()) {
                log.warn(Localizer.getMessage("jspc.error.fileDoesNotExist",
                                              e.getMessage()));
            }
            throw new JasperException(e);
        } finally {
            if(originalClassLoader != null) {
                Thread.currentThread().setContextClassLoader(originalClassLoader);
            }
        }
}

 protected File resolveFile(String s) 
{
         if(getProject() == null) {
             // Note FileUtils.getFileUtils replaces FileUtils.newFileUtils in Ant 1.6.3
             return FileUtils.newFileUtils().resolveFile(null, s);
         } else {
             return FileUtils.newFileUtils().resolveFile(getProject().getBaseDir(), s);
         }
}

Resolves the relative or absolute pathname correctly in both Ant and command-line situations. If Ant launched us, we should use the basedir of the current project to resolve relative paths. See Bugzilla 35571.

 public  void scanFiles(File base) throws JasperException 
{
        Stack< String > dirs = new Stack< String >();
        dirs.push(base.toString());
        // Make sure default extensions are always included
        if ((getExtensions() == null) || (getExtensions().size() <  2)) {
            addExtension("jsp");
            addExtension("jspx");
        }
        while (!dirs.isEmpty()) {
            String s = dirs.pop();
            File f = new File(s);
            if (f.exists() && f.isDirectory()) {
                String[] files = f.list();
                String ext;
                for (int i = 0; (files != null) && i <  files.length; i++) {
                    File f2 = new File(s, files[i]);
                    if (f2.isDirectory()) {
                        dirs.push(f2.getPath());
                    } else {
                        String path = f2.getPath();
                        String uri = path.substring(uriRoot.length());
                        ext = files[i].substring(files[i].lastIndexOf('.") +1);
                        if (getExtensions().contains(ext) ||
                            jspConfig.isJspPage(uri)) {
                            pages.add(path);
                        }
                    }
                }
            }
        }
}

Locate all jsp files in the webapp. Used if no explicit jsps are specified.

 public  void setAddWebXmlMappings(boolean b) 
{
        addWebXmlMappings = b;
}

 public  void setArgs(String[] arg) throws JasperException 
{
        args = arg;
        String tok;
        dieLevel = NO_DIE_LEVEL;
        die = dieLevel;
        while ((tok = nextArg()) != null) {
            if (tok.equals(SWITCH_VERBOSE)) {
                verbose = true;
                showSuccess = true;
                listErrors = true;
            } else if (tok.equals(SWITCH_OUTPUT_DIR)) {
                tok = nextArg();
                setOutputDir( tok );
            } else if (tok.equals(SWITCH_PACKAGE_NAME)) {
                targetPackage = nextArg();
            } else if (tok.equals(SWITCH_COMPILE)) {
                compile=true;
            } else if (tok.equals(SWITCH_CLASS_NAME)) {
                targetClassName = nextArg();
            } else if (tok.equals(SWITCH_URI_BASE)) {
                uriBase=nextArg();
            } else if (tok.equals(SWITCH_URI_ROOT)) {
                setUriroot( nextArg());
            } else if (tok.equals(SWITCH_FILE_WEBAPP)) {
                setUriroot( nextArg());
            } else if ( tok.equals( SHOW_SUCCESS ) ) {
                showSuccess = true;
            } else if ( tok.equals( LIST_ERRORS ) ) {
                listErrors = true;
            } else if (tok.equals(SWITCH_WEBAPP_INC)) {
                webxmlFile = nextArg();
                if (webxmlFile != null) {
                    webxmlLevel = INC_WEBXML;
                }
            } else if (tok.equals(SWITCH_WEBAPP_XML)) {
                webxmlFile = nextArg();
                if (webxmlFile != null) {
                    webxmlLevel = ALL_WEBXML;
                }
            } else if (tok.equals(SWITCH_MAPPED)) {
                mappedFile = true;
            } else if (tok.equals(SWITCH_XPOWERED_BY)) {
                xpoweredBy = true;
            } else if (tok.equals(SWITCH_TRIM_SPACES)) {
                setTrimSpaces(true);
            } else if (tok.equals(SWITCH_CACHE)) {
                tok = nextArg();
                if ("false".equals(tok)) {
                    caching = false;
                } else {
                    caching = true;
                }            
            } else if (tok.equals(SWITCH_CLASSPATH)) {
                setClassPath(nextArg());
            } else if (tok.startsWith(SWITCH_DIE)) {
                try {
                    dieLevel = Integer.parseInt(
                        tok.substring(SWITCH_DIE.length()));
                } catch (NumberFormatException nfe) {
                    dieLevel = DEFAULT_DIE_LEVEL;
                }
                die = dieLevel;
            } else if (tok.equals(SWITCH_HELP)) {
                helpNeeded = true;
            } else if (tok.equals(SWITCH_POOLING)) {
                tok = nextArg();
                if ("false".equals(tok)) {
                    poolingEnabled = false;
                } else {
                    poolingEnabled = true;
                }
            } else if (tok.equals(SWITCH_ENCODING)) {
                setJavaEncoding(nextArg());
            } else if (tok.equals(SWITCH_SOURCE)) {
                setCompilerSourceVM(nextArg());
            } else if (tok.equals(SWITCH_TARGET)) {
                setCompilerTargetVM(nextArg());
            } else if (tok.equals(SWITCH_SMAP)) {
                smapSuppressed = false;
            } else if (tok.equals(SWITCH_DUMP_SMAP)) {
                smapDumped = true;
            } else {
                if (tok.startsWith("-")) {
                    throw new JasperException("Unrecognized option: " + tok +
                        ".  Use -help for help.");
                }
                if (!fullstop) {
                    argPos--;
                }
                // Start treating the rest as JSP Pages
                break;
            }
        }
        // Add all extra arguments to the list of files
        while( true ) {
            String file = nextFile();
            if( file==null ) {
                break;
            }
            pages.add( file );
        }
}

 public  void setCaching(boolean caching) 
{
        this.caching = caching;
}

 public  void setClassDebugInfo(boolean b) 
{
        classDebugInfo=b;
}

 public  void setClassName(String p) 
{
        targetClassName=p;
}

Class name of the generated file ( without package ). Can only be used if a single file is converted. XXX Do we need this feature ?

 public  void setClassPath(String s) 
{
        classPath=s;
}

 public  void setCompile(boolean b) 
{
        compile = b;
}

Sets the compile flag.

 public  void setCompiler(String c) 
{
        compiler=c;
}

 public  void setCompilerSourceVM(String vm) 
{
        compilerSourceVM = vm;
}

 public  void setCompilerTargetVM(String vm) 
{
        compilerTargetVM = vm;
}

 public  void setErrorOnUseBeanInvalidClassAttribute(boolean b) 
{
        errorOnUseBeanInvalidClassAttribute = b;
}

 public  void setFailOnError(boolean b) 
{
        failOnError = b;
}

Set the option that throws an exception in case of a compilation error.

 public  void setGenStringAsCharArray(boolean genStringAsCharArray) 
{
        this.genStringAsCharArray = genStringAsCharArray;
}

Determines whether text strings are to be generated as char arrays, which improves performance in some cases.

 public  void setIeClassId(String ieClassId) 
{
        this.ieClassId = ieClassId;
}

Sets the class-id value to be sent to Internet Explorer when using tags.

 public  void setJavaEncoding(String encodingName) 
{
        javaEncoding = encodingName;
}

Sets the encoding to use for java files.

 public  void setJspFiles(String jspFiles) 
{
        if(jspFiles == null) {
            return;
        }
        StringTokenizer tok = new StringTokenizer(jspFiles, ",");
        while (tok.hasMoreTokens()) {
            pages.add(tok.nextToken());
        }
}

Parses comma-separated list of JSP files to be processed. If the argument is null, nothing is done.

Each file is interpreted relative to uriroot, unless it is absolute, in which case it must start with uriroot.

 public  void setListErrors(boolean b) 
{
        listErrors = b;
}

 public  void setOutputDir(String s) 
{
        if( s!= null ) {
            scratchDir = resolveFile(s).getAbsoluteFile();
        } else {
            scratchDir=null;
        }
}

 public  void setPackage(String p) 
{
        targetPackage=p;
}

 public  void setPoolingEnabled(boolean poolingEnabled) 
{
        this.poolingEnabled = poolingEnabled;
}

 public  void setProject(Project theProject) 
{
        project = theProject;
}

Sets the project.

 public  void setSmapDumped(boolean smapDumped) 
{
        this.smapDumped = smapDumped;
}

Set smapSuppressed flag.

 public  void setSmapSuppressed(boolean smapSuppressed) 
{
        this.smapSuppressed = smapSuppressed;
}

Set smapSuppressed flag.

 public  void setTrimSpaces(boolean ts) 
{
        this.trimSpaces = ts;
}

 public  void setUriroot(String s) 
{
        if( s==null ) {
            uriRoot = s;
            return;
        }
        try {
            uriRoot = resolveFile(s).getCanonicalPath();
        } catch( Exception ex ) {
            uriRoot = s;
        }
}

Base dir for the webapp. Used to generate class names and resolve includes

 public  void setValidateXml(boolean b) 
{
        org.apache.jasper.xmlparser.ParserUtils.validating=b;
}

 public  void setVerbose(int level) 
{
        if (level  > 0) {
            verbose = true;
            showSuccess = true;
            listErrors = true;
        }
}

Sets the verbosity level. The actual number doesn't matter: if it's greater than zero, the verbose flag will be true.

 public  void setWebXml(String s) 
{
        webxmlFile=resolveFile(s).getAbsolutePath();
        webxmlLevel=ALL_WEBXML;
}

File where we generate a complete web.xml with the class definitions.

 public  void setWebXmlFragment(String s) 
{
        webxmlFile=resolveFile(s).getAbsolutePath();
        webxmlLevel=INC_WEBXML;
}

File where we generate a web.xml fragment with the class definitions.

 public  void setXpoweredBy(boolean xpoweredBy) 
{
        this.xpoweredBy = xpoweredBy;
}