Quadcap Embeddable Server

com/quadcap/http/servlets/jsp/JspParser.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.CharArrayWriter;
import java.io.IOException;
import java.io.Reader;

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.InputSource;
import org.xml.sax.Parser;
import org.xml.sax.SAXException;

import org.xml.sax.helpers.AttributeListImpl;

import com.quadcap.util.collections.ArrayQueue;

/**
 * JSP Parser class that fires SAX events. 
 *
 * @author Stan Bailes
 */
public class JspParser implements Parser {
    InputSource                 in;
    Reader                      r;
    DocumentHandler             docHandler      = null;
    DTDHandler                  dtdHandler      = null;
    EntityResolver              entityResolver  = null;
    CharArrayWriter             tag             = new CharArrayWriter();
    CharArrayWriter             data            = new CharArrayWriter();
    AttributeListImpl           attributes      = new AttributeListImpl();
    int                         tagState        = 0;
    String                      tagName         = null;
    JspHandler                  jspHandler      = null;
    String                      nonJspTag       = null;
    ArrayQueue                  inStack         = null;

    final static int            TAG             = 1;
    final static int            DIRECTIVE       = 2;
    final static int            DECLARATION     = 3;
    final static int            SCRIPTLET       = 4;
    final static int            EXPRESSION      = 5;

    public JspParser() {}

        this.in = in;
        this.r = in.getCharacterStream();
        tag.reset();
        data.reset();
        parse();
    }

    public void pushInputSource(InputSource in2) {
        if (inStack == null) inStack = new ArrayQueue();
        inStack.push(in);
        in = in2;
        r = in.getCharacterStream();
    }

    boolean popInputSource() {
        if (inStack == null || inStack.size() == 0) return false;
        in = (InputSource)inStack.pop();
        r = in.getCharacterStream();
        return true;
    }

    public void setJspHandler(JspHandler jspHandler) {
        this.jspHandler = jspHandler;
    }

    public void parse(String s) {
    }

    public void setDocumentHandler(DocumentHandler dh) {
        this.docHandler = dh;
    }
    
    public void setDTDHandler(DTDHandler dh) {
        this.dtdHandler = dh;
    }

    public void setEntityResolver(EntityResolver er) {
        this.entityResolver = er;
    }

    public EntityResolver getEntityResolver() {
        return entityResolver;
    }

    }

    public void setLocale(java.util.Locale locale) {
    }
    
        int state = 0;
        int commentState = 0;
        String attrName = null;
        docHandler.startDocument();
        docHandler.startElement("jsp:root", attributes);
        while (state >= 0) {
            int c = r.read();
            //System.out.println("[" + ((char)c) + "] [" + state + "] <" + tag.toString() + ">");
            if (c < 0) {
                if (popInputSource()) continue;
                state = -1;
                break;
            }
            switch (commentState) {
            case 0:
                break;
            case 1:
                if (c == '-') commentState = 2;
                break;
            case 2:
                if (c == '-') commentState = 3;
                else commentState = 1;
                break;
            case 3:
                if (c == '>') commentState = 0;
                else if (c != '-') commentState = 1;
            }
            
            switch (state) {
            case 0:
                if (c == '<') {
                    if (data.size() > 0) {
                        docHandler.characters(data.toCharArray(), 0, data.size());
                        data.reset();
                    }
                    state = 1;
                } else {
                    data.write(c);
                }
                break;
            case 1:             // seen '<'
                switch (c) {
                case '%':
                    state = 2;
                    break;
                case '!':
                    data.write('<');
                    data.write('!');
                    commentState = 1;
                    state = 0;
                    break;
                case '\\':
                    state = 4;
                    break;
                case '/':
                    state = 8;
                    break;
                default:
                    tag.write(c);
                    tagState = TAG;
                    state = 5;
                    break;
                }
                break;
            case 2:             // seen '<%'
                tag.reset();
                state = 3;
                switch (c) {
                case '@':
                    state = 51;
                    tagState = DIRECTIVE;
                    break;
                case '!':
                    tagState = DECLARATION;
                    break;
                case '=':
                    tagState = EXPRESSION;
                    break;
                case  '-':
                    state = 15;
                    break;
                default:
                    tag.write(c);
                    tagState = SCRIPTLET;
                    break;
                }
                break;
            case 3:             // in <% %>
                if (c == '%') state = 7;
                else tag.write(c);
                break;
            case 4:             // seen <\
                data.write('<');
                data.write(c);
                state = 0;
                break;
            case 51:            // collect directive name
                if (c != ' ') {
                    tag.write(c);
                    state = 52;
                }
                break;
            case 52:
                if (c == ' ') {
                    tagName = tag.toString();
                    tag.reset();
                    state = 6;
                } else {
                    tag.write(c);
                }
                break;
            case 5:             // collect tag name
                switch (c) {
                case ' ':
                    tagName = tag.toString();
                    tag.reset();
                    state = checkTag(6);
                    break;
                case '/':
                    tagName = tag.toString();
                    tag.reset();
                    state = 9;
                    break;
                case '>':
                    tagName = tag.toString();
                    tag.reset();
                    docHandler.startElement(tagName, attributes);
                    attributes.clear();
                    state = 0;
                    break;
                case '<':
                    tagName = tag.toString();
                    tag.reset();
                    if (checkTag(1) == 0) {
                        if (data.size() > 0) {
                            docHandler.characters(data.toCharArray(), 
                                                  0, data.size());
                            data.reset();
                        }
                        state = 1;
                    }
                    break;
                default:
                    tag.write(c);
                }
                break;
            case 6:             // collect attributes
                switch (c) {
                case ' ': case '\n': case '\r': case '\t':
                    break;
                case '/':
                    if (tagState == TAG) {
                        state = 9;
                    } else {
                        tag.write(c);
                    }
                    break;
                case '%':
                    if (tagState != TAG) {
                        state = 11;
                    } else {
                        tag.write(c);
                    }
                    break;
                case '>':
                    docHandler.startElement(tagName, attributes);
                    attributes.clear();
                    state = 0;
                    break;
                case '=':
                    attrName = tag.toString();
                    tag.reset();
                    state = 10;
                    break;
                default:
                    tag.write(c);
                }
                break;
            case 7:             // in <%, seen %
                if (c == '>') {
                    doTag();
                    state = 0;
                } else {
                    tag.write('%');
                    if (c != '%') {
                        tag.write(c);
                        state = 3;
                    }
                }
                break;
            case 8:             // seen </
                if (c == '>') {
                    tagName = tag.toString();
                    tag.reset();
                    if (nonJspTag != null && tagName.equals(nonJspTag)) {
                        nonJspTag = null;
                        data.write("</");
                        data.write(tagName);
                        data.write('>');
                    } else {
                        docHandler.endElement(tagName);
                    }
                    state = 0;
                } else {
                    tag.write(c);
                }
                break;
            case 9:             // in <tag, seen /
                if (c == '>') {
                    docHandler.startElement(tagName, attributes);
                    attributes.clear();
                    docHandler.endElement(tagName);
                    state = 0;
                } else {
                    tag.write('/');
                    tag.write(c);
                    state = 6;
                }
                break;
            case 10:            // in attriblist, seen name=
                if (c == '"') {
                    state = 12;
                } else if (c == '\'') {
                    state = 121;
                } else {
                    tag.write(c);
                    state = 13;
                }
                break;
            case 11:            // in <%@, seen %
                if (c == '>') {
                    doDirective();
                    state = 0;
                } else {
                    tag.write('%');
                    tag.write(c);
                    state = 6;
                }
                break;
            case 12:            // in attriblist, seen name="
                if (c == '"') {
                    attributes.addAttribute(attrName, "string",
                                            tag.toString());
                    tag.reset();
                    state = 6;
                } else {
                    tag.write(c);
                }
                break;
            case 121:            // in attriblist, seen name='
                if (c == '\'') {
                    attributes.addAttribute(attrName, "string",
                                            tag.toString());
                    tag.reset();
                    state = 6;
                } else {
                    tag.write(c);
                }
                break;
            case 13:            // in attriblist, seen name=c
                switch (c) {
                case ' ':
                    attributes.addAttribute(attrName, "string",
                                            tag.toString());
                    tag.reset();
                    state = 6;
                    break;
                case '/':
                    state = 14;
                    break;
                case '>':
                    attributes.addAttribute(attrName, "string",
                                            tag.toString());
                    tag.reset();
                    docHandler.startElement(tagName, attributes);
                    attributes.clear();
                    state = 0;
                    break;
                default:
                    tag.write(c);
                }
                break;
            case 14:            // in attriblist, seen name=dfdf/
                if (c == '>') {
                    attributes.addAttribute(attrName, "string",
                                            tag.toString());
                    tag.reset();
                    docHandler.startElement(tagName, attributes);
                    attributes.clear();
                    state = 0;
                } else {
                    tag.write('/');
                    if (c != '/') {
                        tag.write(c);
                        state = 13;
                    }
                }
                break;
            case 15:
                if (c == '-') state = 16;
                break;
            case 16:
                if (c == '-') state = 17;
                else state = 15;
                break;
            case 17:
                if (c == '>') state = 0;
                else if (c != '-') state = 15;
                break;
            }
        }
        docHandler.endElement("jsp:root");
    }

    public int checkTag(int validState) throws IOException {
        if (jspHandler.isValidTag(tagName)) {
            return validState;
        } else {
            nonJspTag = tagName;
            data.write('<');
            data.write(tagName);
            data.write(' ');
            return 0;
        }
    }

        switch (tagState) {
        case TAG:
            break;
        case EXPRESSION:
            docHandler.startElement("jsp:expression", attributes);
            docHandler.characters(tag.toCharArray(), 0, tag.size());
            docHandler.endElement("jsp:expression");
            tag.reset();
            attributes.clear();
            break;
        case DECLARATION:
            docHandler.startElement("jsp:decl", attributes);
            docHandler.characters(tag.toCharArray(), 0, tag.size());
            docHandler.endElement("jsp:decl");
            tag.reset();
            attributes.clear();
            break;
        case SCRIPTLET:
            docHandler.startElement("jsp:scriptlet", attributes);
            docHandler.characters(tag.toCharArray(), 0, tag.size());
            docHandler.endElement("jsp:scriptlet");
            tag.reset();
            attributes.clear();
            break;
        }
    }

        docHandler.startElement("jsp:directive." + tagName, attributes);
        docHandler.endElement("jsp:directive." + tagName);
        attributes.clear();
    }
}