public  void addDateHeader(String name,
    long date) 
{
        XSPResponseHelper.addDateHeader(this.response, name, date);
}

 public  void addDateHeader(String name,
    Date date) 
{
        XSPResponseHelper.addDateHeader(this.response, name, date);
}

 public  void addDateHeader(String name,
    String date) throws ParseException 
{
        XSPResponseHelper.addDateHeader(this.response, name, date);
}

 public  void addDateHeader(String name,
    String date,
    String format) throws ParseException 
{
        XSPResponseHelper.addDateHeader(this.response, name, date, format);
}

 public  void addDateHeader(String name,
    String date,
    DateFormat format) throws ParseException 
{
        XSPResponseHelper.addDateHeader(this.response, name, date, format);
}

 public  void configure(Configuration configuration) throws ConfigurationException 
{
        this.file = new File(configuration.getChild("file").getValue());
        Configuration[] dependencies = configuration.getChildren("dependency");
        this.dependencies = new File[dependencies.length];
        for (int i = 0; i <  dependencies.length; i ++) {
            this.dependencies[i] = new File(dependencies[i].getValue());
        }
}

 public  void dispose() 
{
        global.delete("page");
        global.delete("logger");
        global.delete("xspAttr");
        this.global = null;
        this.script = null;
        this.compileError = null;
        super.dispose();
}

 public  void generate() throws IOException, ProcessingException 
{
        Context context = Context.enter();
        try {
            global.put("contentHandler", global, Context.toObject(this.contentHandler, global));
            context.setOptimizationLevel(-1);
            if (getLogger().isDebugEnabled()) {
                getLogger().debug("Executing script " + file);
            }
            script.exec(context, global);
        } catch (JavaScriptException e) {
            throw new ProcessingException("generate: Got Javascript exception", e);
        } finally {
            Context.exit();
        }
}

 public String[] getAttributeNames() 
{
        return XSPRequestHelper.getAttributeNames(this.objectModel);
}

 public  void getAttributeNames(ContentHandler contentHandler) throws SAXException 
{
        XSPRequestHelper.getAttributeNames(this.objectModel, contentHandler);
}

 public Date getDateHeader(String name) 
{
        return XSPRequestHelper.getDateHeader(this.objectModel, name);
}

 public String getDateHeader(String name,
    String format) 
{
        return XSPRequestHelper.getDateHeader(this.objectModel, name, format);
}

 public String[] getHeaderNames() 
{
        return XSPRequestHelper.getHeaderNames(this.objectModel);
}

 public  void getHeaderNamesAsXML() throws SAXException 
{
        XSPRequestHelper.getHeaderNames(this.objectModel, this.contentHandler);
}

 public String[] getHeaders(String name) 
{
        return XSPRequestHelper.getHeaders(this.objectModel, name);
}

 public  void getHeadersAsXML(String name) throws SAXException 
{
        XSPRequestHelper.getHeaders(this.objectModel, name, this.contentHandler);
}

 public  void getLocale() throws SAXException 
{
        XSPRequestHelper.getLocale(this.objectModel, this.contentHandler);
}

 public Locale[] getLocalesAsArray() 
{
        return XSPRequestHelper.getLocales(this.objectModel);
}

 public  void getLocalesAsXML() throws SAXException 
{
        XSPRequestHelper.getLocale(this.objectModel, this.contentHandler);
}

 public String getParameter(String name,
    String defaultValue) 
{
        return XSPRequestHelper.getParameter(this.objectModel, name, defaultValue);
}

 public String getParameter(String name,
    String defaultValue,
    String form_encoding,
    String container_encoding) 
{
        return XSPRequestHelper.getParameter(this.objectModel, name, defaultValue,
                form_encoding, container_encoding);
}

 public  void getParameterAsXML(String name,
    String defaultValue,
    String form_encoding,
    String container_encoding) throws SAXException 
{
        XSPRequestHelper.getParameter(this.objectModel, this.contentHandler, name, defaultValue,
                form_encoding, container_encoding);
}

 public String[] getParameterNames() 
{
        return XSPRequestHelper.getParameterNames(this.objectModel);
}

 public  void getParameterNamesAsXML() throws SAXException 
{
        XSPRequestHelper.getParameterNames(this.objectModel, this.contentHandler);
}

 public String[] getParameterValues(String name,
    String form_encoding,
    String container_encoding) 
{
        return XSPRequestHelper.getParameterValues(this.objectModel,
                name, form_encoding, container_encoding);
}

 public  void getParameterValuesAsXML(String name,
    String form_encoding,
    String container_encoding) throws SAXException 
{
        XSPRequestHelper.getParameterValues(this.objectModel, this.contentHandler,
                name, form_encoding, container_encoding);
}

 public String getRequestedURL() 
{
        return XSPRequestHelper.getRequestedURL(this.objectModel);
}

 public Object getSessionAttribute(Session session,
    String name,
    Object defaultValue) 
{
        return XSPSessionHelper.getSessionAttribute(session, name, defaultValue);
}

 public String[] getSessionAttributeNames(Session session) 
{
        Collection c = XSPSessionHelper.getSessionAttributeNames(session);
        return (String[])c.toArray(new String[c.size()]);
}

 public  void initialize() throws Exception 
{
        Context context = Context.enter();
        try {
            global = new ImporterTopLevel(context);
            global.put("page", global, Context.toObject(this, global));
            global.put("logger", global, Context.toObject(getLogger(), global));
            global.put("xspAttr", global, Context.toObject(new AttributesImpl(), global));
            context.setOptimizationLevel(-1);
            if (getLogger().isDebugEnabled()) {
                getLogger().debug("Compiling script " + file);
            }
            script = context.compileReader(global, new FileReader(file), file.toString(), 1, null);
        } catch (Exception e) {
            compileError = e;
        } finally {
            Context.exit();
        }
}

 public boolean modifiedSince(long date) 
{
        if (this.file.lastModified() <  date) {
            return true;
        }
        for (int i = 0; i <  dependencies.length; i++) {
            if (this.file.lastModified() <  dependencies[i].lastModified()) {
                return true;
            }
        }
        return false;
}

Determines whether this generator's source files have changed

 public  void recycle() 
{
        global.delete("contentHandler");
        global.delete("objectModel");
        global.delete("request");
        global.delete("response");
        global.delete("context");
        global.delete("resolver");
        global.delete("parameters");
        super.recycle();
}

 public  void responseGetLocale() throws SAXException 
{
        XSPResponseHelper.getLocale(this.response, this.contentHandler);
}

 public  void setDateHeader(String name,
    long date) 
{
        XSPResponseHelper.setDateHeader(this.response, name, date);
}

 public  void setDateHeader(String name,
    Date date) 
{
        XSPResponseHelper.setDateHeader(this.response, name, date);
}

 public  void setDateHeader(String name,
    String date) throws ParseException 
{
        XSPResponseHelper.setDateHeader(this.response, name, date);
}

 public  void setDateHeader(String name,
    String date,
    String format) throws ParseException 
{
        XSPResponseHelper.setDateHeader(this.response, name, date, format);
}

 public  void setDateHeader(String name,
    String date,
    DateFormat format) throws ParseException 
{
        XSPResponseHelper.setDateHeader(this.response, name, date, format);
}

 public  void setup(SourceResolver resolver,
    Map objectModel,
    String src,
    Parameters par) throws IOException, SAXException, ProcessingException 
{
        super.setup(resolver, objectModel, src, par);
        if (compileError != null) {
            throw new ProcessingException("Failed to compile script", compileError);
        }
        // add enter/exit here, too 
        Context.enter();
        try {
            global.put("objectModel", global, Context.toObject(this.objectModel, global));
            global.put("request", global, Context.toObject(this.request, global));
            global.put("response", global, Context.toObject(this.response, global));
            global.put("context", global, Context.toObject(this.context, global));
            global.put("resolver", global, Context.toObject(this.resolver, global));
            global.put("parameters", global, Context.toObject(this.parameters, global));
        } catch (Exception e) {
            throw new ProcessingException("setup: Got exception", e);
        } finally {
            Context.exit();
        }
}