Quadcap Embeddable Server

com/quadcap/http/servlets/jsp/JspHandler.java

Go to the documentation of this file.

package com.quadcap.http.servlets.jsp;

/* Copyright 1999 - 2003 Quadcap Software.  All rights reserved.
 *
 * This software is distributed under the Quadcap Free Software License.
 * This software may be used or modified for any purpose, personal or
 * commercial.  Open Source redistributions are permitted.  Commercial
 * redistribution of larger works derived from, or works which bundle
 * this software requires a "Commercial Redistribution License"; see
 * http://www.quadcap.com/purchase.
 *
 * Redistributions qualify as "Open Source" under  one of the following terms:
 *   
 *    Redistributions are made at no charge beyond the reasonable cost of
 *    materials and delivery.
 *
 *    Redistributions are accompanied by a copy of the Source Code or by an
 *    irrevocable offer to provide a copy of the Source Code for up to three
 *    years at the cost of materials and delivery.  Such redistributions
 *    must allow further use, modification, and redistribution of the Source
 *    Code under substantially the same terms as this license.
 *
 * Redistributions of source code must retain the copyright notices as they
 * appear in each source code file, these license terms, and the
 * disclaimer/limitation of liability set forth as paragraph 6 below.
 *
 * Redistributions in binary form must reproduce this Copyright Notice,
 * these license terms, and the disclaimer/limitation of liability set
 * forth as paragraph 6 below, in the documentation and/or other materials
 * provided with the distribution.
 *
 * The Software is provided on an "AS IS" basis.  No warranty is
 * provided that the Software is free of defects, or fit for a
 * particular purpose.  
 *
 * Limitation of Liability. Quadcap Software shall not be liable
 * for any damages suffered by the Licensee or any third party resulting
 * from use of the Software.
 */

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.CharArrayWriter;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.Writer;

import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;

import javax.servlet.ServletContext;

import org.xml.sax.AttributeList;
import org.xml.sax.DocumentHandler;
import org.xml.sax.DTDHandler;
import org.xml.sax.EntityResolver;
import org.xml.sax.ErrorHandler;
import org.xml.sax.HandlerBase;
import org.xml.sax.InputSource;
import org.xml.sax.Locator;
import org.xml.sax.Parser;
import org.xml.sax.SAXException;

import com.quadcap.util.collections.ArrayQueue;

import com.quadcap.util.Debug;

/**
 * This class is a SAX parser handler for parsing JSP documents.
 *
 * @author Stan Bailes
 */
public class JspHandler implements DocumentHandler, EntityResolver, TagContext {
    ServletContext              context;
    JspParser                   parser;
    JspObject                   jsp;
    Hashtable                   tagHandlers     = new Hashtable();
    PrintWriter                 w;
    CharArrayWriter             cw = null;
    boolean                     written         = false;
    ArrayQueue                  tagStack        = new ArrayQueue(0, -1);
    ArrayQueue                  wStack          = new ArrayQueue(0, -1);
    Hashtable                   pageDirectives  = new Hashtable();

    public JspHandler(ServletContext context, JspParser parser,
                      PrintWriter w, JspObject jsp) {
        this.context = context;
        this.parser = parser;
        this.jsp = jsp;
        this.w = w;
        addHandler("jsp:root", new TagJspRoot());
        addHandler("jsp:useBean", new TagJspUseBean());
        addHandler("jsp:expression", new TagJspExpression());
        addHandler("jsp:expr", new TagJspExpression());
        addHandler("jsp:declaration", new TagJspDeclaration());
        addHandler("jsp:decl", new TagJspDeclaration());
        addHandler("jsp:scriptlet", new TagJspScriptlet());
        addHandler("jsp:directive.page", new TagJspPage());
        addHandler("jsp:directive.include", new TagDirInclude());
        addHandler("jsp:forward", new TagJspForward());
        addHandler("jsp:include", new TagJspInclude());
        addHandler("jsp:getProperty", new TagJspGetProperty());
        addHandler("jsp:setProperty", new TagJspSetProperty());
    }

    public PrintWriter getPrintWriter() { return w; }
    public String getPackageName() { return jsp.getPackageName(); }
    public String getClassName() { return jsp.getClassName(); }

        EntityResolver resolver = parser.getEntityResolver();
        if (resolver != null) {
            in = resolver.resolveEntity(null, file);
        } else {
            FileReader f = new FileReader(file);
        }
        if (in == null) {
            throw new IOException("Can't resolve entity: " + file);
        }
        parser.pushInputSource(in);
    }

    public PrintWriter pushPrintWriter(PrintWriter p) {
        wStack.addBack(w);
        PrintWriter oldW = w;
        w = p;
        return oldW;
    }

    public PrintWriter popPrintWriter() {
        w = (PrintWriter)wStack.popBack();
        return w;
    }

    public void addPageDirective(String name, String val) {
        Vector v = (Vector)pageDirectives.get(name);
        if (v == null) {
            v = new Vector();
            pageDirectives.put(name, v);
        }
        v.addElement(val);
    }

    public Enumeration getPageDirectives(String name) {
        Vector v = (Vector)pageDirectives.get(name);
        if (v == null) v = new Vector();
        return v.elements();
    }

    public String getPageDirective(String name) {
        String s = null;
        Vector v = (Vector)pageDirectives.get(name);
        if (v != null && v.size() > 0) s = v.elementAt(0).toString();
        return s;
    }

    public String getPageDirective(String name, String dflt) {
        String s = dflt;
        Vector v = (Vector)pageDirectives.get(name);
        if (v != null && v.size() > 0) s = v.elementAt(0).toString();
        return s;
    }

    public boolean isValidTag(String name) {
        return tagHandlers.get(name) != null;
    }

    public void addHandler(String name, TagHandler h) {
        tagHandlers.put(name, h);
    }

    public void startDocument() {
    }

    public void endDocument() {
    }

    public void ignorableWhitespace(char[] ch, int off, int cnt) 
    {
        characters(ch, off, cnt);
    }

    public void processingInstruction(String target, String data) {
    }

    }

    {
        //Debug.println("START: " + tag + " " + TagJsp.toString(attrs));
        try {
            TagHandler h = (TagHandler)tagHandlers.get(tag);
            if (h != null) {
                TagInstance t = h.makeInstance(this);
                t.doStartTag(tag, attrs);
                tagStack.addBack(t);
            } else {
                CharArrayWriter cw = new CharArrayWriter();
                cw.write('<');
                cw.write(tag);
                for (int i = 0; i < attrs.getLength(); i++) {
                    cw.write(' ');
                    cw.write(attrs.getName(i));
                    cw.write('=');
                    cw.write('"');
                    cw.write(attrs.getValue(i));
                    cw.write('"');
                }
                cw.write('>');
                char[] ch = cw.toCharArray();
                characters(ch, 0, ch.length);
            }
        } catch (Exception e) {
            Debug.print(e);
        }
    }
   
        try {
            TagInstance t = (TagInstance)tagStack.tail();
            if (t != null) {
                t.doCharacters(ch, off, len);
            }
        } catch (Exception e) {
            Debug.print(e);
        }
    }

        //Debug.println("END: " + tag);
        try {
            TagInstance t = (TagInstance)tagStack.tail();
            //Debug.println("t = " + t);
            if (t != null && t.getTagName().equals(tag)) {
                tagStack.popBack();
                t.doEndTag();
            } else {
                CharArrayWriter cw = new CharArrayWriter();
                cw.write("</");
                cw.write(tag);
                cw.write(">");
                char[] ch = cw.toCharArray();
                characters(ch, 0, ch.length);
            }
        } catch (Exception e) {
            Debug.print(e);
        }
    }

    /**
     * Entity resolver interface.
     */
        throws IOException
    {
        String name = null;
        if (!systemId.startsWith("/")) {
            name = jsp.getPackageName() + "/" + systemId;
        }
        InputStream in = context.getResourceAsStream(name);
        if (is != null) {
            BufferedInputStream bin = new BufferedInputStream(in);
            InputStreamReader r = new InputStreamReader(bin);
        }
        return is;
    }
}