Quadcap Embeddable Database

com/quadcap/text/sax/Parser.java

Go to the documentation of this file.

package com.quadcap.text.sax;

/* 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.InputStreamReader;
import java.io.Reader;

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.SAXException;

import com.quadcap.text.NoStringPool;
import com.quadcap.text.StringPool;
import com.quadcap.util.collections.ArrayQueue;

import com.quadcap.util.Debug;

/**
 * SAX Parser implementation.
 *
 * @author Stan Bailes
 */
public class Parser implements org.xml.sax.Parser {
    boolean                     docStarted      = false;
    StringPool                  pool            = new NoStringPool();
    Reader                      r;
    char[]                      ebuf            = new char[6];
    char[]                      tag             = new char[1024*32];
    int                         taglen          = 0;
    CharArrayWriter             data            = new CharArrayWriter();
    AttributeList               attributes      = new AttributeList();
    String                      attrName        = null;
    String                      tagName         = null;
    ArrayQueue                  inStack         = null;
    ArrayQueue                  locStack        = null;
    int                         lineNumber      = 1;
    int                         columnNumber    = 1;
    String                      lastEntityVal   = "";
    boolean                     trace           = false;
    int                         commentLevel    = 0;

    public Parser() {}

        this.in = in;
        this.r = getCharacterStream(in);
        taglen = 0;
        lineNumber = 1;
        columnNumber = 1;
        data.reset();
        try {
            parse();
            if (locStack != null) {
                for (int i = 0; i < locStack.size(); i++) {
                    com.quadcap.util.Debug.println(" at " + locStack.top(i));
                }
            }
            throw ex;
        }
    }

        if (rd == null) {
        }
        return rd;
    }
    
        if (inStack == null) {
            inStack = new ArrayQueue();
            locStack = new ArrayQueue();
        }
        inStack.push(in);
        locStack.push("" + lineNumber + ":" + columnNumber);
        lineNumber = 1;
        columnNumber = 1;
        in = in2;
        r = getCharacterStream(in);
    }

    boolean popInputSource() {
        if (inStack == null || inStack.size() == 0) return false;
        String s = locStack.pop().toString();
        int idx = s.indexOf(':');
        lineNumber = Integer.parseInt(s.substring(0, idx));
        columnNumber = Integer.parseInt(s.substring(idx+1));
        r = getCharacterStream(in);
        return true;
    }

        tag[taglen++] = (char)c;
    }
    
    public void parse(String s) {
    }

        this.docHandler = dh;
    }
    
        this.dtdHandler = dh;
    }

        this.entityResolver = er;
    }

        return entityResolver;
    }

        errorHandler = er;
    }

    public void setLocale(java.util.Locale locale) {
    }

    final int read() throws IOException {
        int c = r.read();
        if (c == '\n') {
            lineNumber++;
            columnNumber = 1;
        } else {
            columnNumber++;
        }
        return c;
    }

        int len = 0;
        int c;
        int state = 0;
        while ((c = read()) >= 0) {
            ebuf[len++] = (char)c;
            if (!Character.isLetter((char)c) || len >= ebuf.length) break;
        }
        lastEntityVal = new String(ebuf, 0, len);
        if (len == 5 && ebuf[0] == 'q' && ebuf[1] == 'u' &&
            ebuf[2] == 'o' && ebuf[3] == 't') {
            return '"';
        }
        if (len == 4 && ebuf[0] == 'a' && ebuf[1] == 'm' && ebuf[2] == 'p') {
            return '&';
        }
        if (len == 3) {
            if (ebuf[0] == 'l') {
                if (ebuf[1] == 't') return '<';
            } else if (ebuf[0] == 'g') {
                if (ebuf[1] == 't') return '>';
            }
        }
        throw new SAXException("unknown entity: " + lastEntityVal);
            
    }
    
//         Debug.println("step[" + state + " " + commentLevel +
//                       "]: " + ((char)c));
        switch (state) {
        case 0:
            if (c == '<') {
                if (data.size() > 0) {
                    data.reset();
                }
                state = 1;
            } else {
                if (c == '&') {
                    try {
                        c = parseEntity();
                        data.write('&');
                        data.write(lastEntityVal);
                        break;
                    }
                }
                data.write(c);
            }
            break;
        case 1:             // seen '<'
            switch (c) {
            case '!':
                state = 30;
                break;
            case '\\':
                state = 4;
                break;
            case '/':
                state = 8;
                break;
            case '?':
                data.reset();
                state = 20;
                break;
            default:
                addTagChar(c);
                state = 5;
                break;
            }
            break;
        case 4:             // seen <\
            data.write('<');
            data.write(c);
            state = 0;
            break;
        case 5:             // collect tag name
            switch (c) {
            case ' ': case '\r': case '\n': case '\t':
                tagName = pool.intern(tag, 0, taglen);
                taglen = 0;
                state = 6;
                break;
            case '/':
                tagName = pool.intern(tag, 0, taglen);
                taglen = 0;
                state = 9;
                break;
            case '>':
                tagName = pool.intern(tag, 0, taglen);
                taglen = 0;
                state = 0;
                startElement(tagName, attributes);
                break;
            case '<':
                tagName = pool.intern(tag, 0, taglen);
                taglen = 0;
                if (data.size() > 0) {
                                          0, data.size());
                    data.reset();       
                }
                state = 1;
                break;
            default:
                if (Character.isLetter((char)c) ||
                    Character.isDigit((char)c) ||
                    c == '.' || c == '-' || c == '_' || c == ':') {
                    addTagChar(c);
                } else {
                    // this isn't a tag after all (e.g., inside a <script>
                    // section, we've found "if (a < b) ..."
                    for (int i = 0; i < taglen; i++) {
                        data.write(tag[i]);
                    }
                    data.write(c);
                    state = 0;
                    taglen = 0;
                    break;
                }
                    
            }
            break;
        case 6:             // collect attributes
            switch (c) {
            case ' ': case '\n': case '\r': case '\t':
                break;
            case '/':
                state = 9;
                break;
            case '%':
                addTagChar(c);
                break;
            case '>':
                state = 0;
                startElement(tagName, attributes);
                break;
            case '=':
                attrName = pool.intern(tag, 0, taglen);
                taglen = 0;
                state = 10;
                break;
            case '<':
                state = 61;
                break;
            default:
                addTagChar(c);
            }
            break;
        case 61:
            switch (c) {
            case '?':
                state = 62;
                break;
            default:
                addTagChar('<');
                addTagChar(c);
                state = 6;
                break;
            }
            break;
        case 62:
            switch (c) {
            case '?':
                state = 63;
                break;
            default:
                addTagChar(c);
                break;
            }
            break;
        case 63:
            switch(c) {
            case '>':
                addTagChar(c);
                state = 6;
                break;
            default:
                addTagChar('?');
                if (c != '?') state = 62;
                break;
            }
            break;
        case 8:             // seen </
            if (c == '>') {
                tagName = pool.intern(tag, 0, taglen);
                taglen = 0;
                state = 0;
            } else {
                addTagChar(c);
            }
            break;
        case 9:             // in <tag, seen /
            if (c == '>') {
                startElement(tagName, attributes);
                state = 0;
            } else {
                addTagChar('/');
                addTagChar(c);
                state = 6;
            }
            break;
        case 10:            // in attriblist, seen name=
            if (c == '"') {
                state = 12;
            } else if (c == '\'') {
                state = 121;
            } else {
                addTagChar(c);
                state = 13;
            }
            break;
        case 12:            // in attriblist, seen name="
            if (c == '"') {
                attributes.addAttribute(attrName, "CDATA",
                                        pool.intern(tag, 0, taglen));
                taglen = 0;
                state = 6;
            } else {
                addTagChar(c);
            }
            break;
        case 121:            // in attriblist, seen name='
            if (c == '\'') {
                attributes.addAttribute(attrName, "CDATA",
                                        pool.intern(tag, 0, taglen));
                taglen = 0;
                state = 6;
            } else {
                addTagChar(c);
            }
            break;
        case 13:            // in attriblist, seen name=c
            switch (c) {
            case ' ':
                attributes.addAttribute(attrName, "CDATA",
                                        pool.intern(tag, 0, taglen));
                taglen = 0;
                state = 6;
                break;
            case '/':
                state = 14;
                break;
            case '>':
                attributes.addAttribute(attrName, "CDATA",
                                        pool.intern(tag, 0, taglen));
                taglen = 0;
                state = 0;
                startElement(tagName, attributes);
                break;
            default:
                addTagChar(c);
            }
            break;
        case 14:            // in attriblist, seen name=dfdf/
            if (c == '>') {
                attributes.addAttribute(attrName, "CDATA",
                                        pool.intern(tag, 0, taglen));
                taglen = 0;
                state = 0;
                startElement(tagName, attributes);
            } else {
                addTagChar('/');
                if (c != '/') {
                    addTagChar(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;
        case 20:
            if (c == '?') state = 21;
            else data.write(c);
            break;
        case 21:
            if (c == '>') {
                String s = data.toString().trim();
                if (s.startsWith("xml")) {
                    if (inStack == null || inStack.size() == 0) {
                        if (!docStarted) {
                            docStarted = true;
                        }
                    }
                } else {
                    int idx = s.indexOf(' ');
                    String dat = "";
                    String target = s;
                    if (idx >= 0) {
                        target = s.substring(0, idx);
                        dat = s.substring(idx+1).trim();
                    }
                }
                data.reset();
                state = 0;
            } else {
                data.write('?');
                if (c != '?') {
                    data.write(c);
                    state = 20;
                }
            }
            break;
        case 30:    // seen <!
            if (c == '-') state = 31;
            else if (c == '[') state = 41;
            else state = 40;
            break;
        case 31:    // seen <!-
            if (c == '-') {
                commentLevel = 1;
                state = 32;
            }
            else state = 40;
            break;
        case 32:    // in comment, look for '-'
            if (c == '-') state = 33;
            else if (c == '<') state = 320;
            break;
        case 320:   // in comment, seen <
            if (c == '!') state = 321;
            else if (c == '-') state = 33;
            else state = 32;
            break;
        case 321:   // in comment, seen <!
            if (c == '-') state = 322;
            else state = 32;
            break;
        case 322:   // in comment, seen <!-
            if (c == '-') {
                commentLevel++;
            }
            state = 32;
            break;
        case 33:    // in comment, seen -
            if (c == '-') state = 34;
            else state = 32;
            break;
        case 34:    // in comment, seen --
            if (c == '>') {
                if (--commentLevel == 0) {
                    state = 0;
                } else {
                    state = 32;
                }
            }
            else if (c != '-') state = 32;
            break;
        case 40:    // seen <!, but not comment
            if (c == '>') state = 0;
            break;
        case 41:    // seen <![
            if (c == '[') {
                if (data.toString().equals("CDATA")) {
                    data.reset();
                    state = 42;
                } else {
                    state = 40;
                }
            } else {
                data.write(c);
            }                
            break;
        case 42:    // in CDATA section
            if (c == ']') {
                state = 43;
            } else {
                data.write(c);
            }
            break;
        case 43:    // in CDATA, seen ']'
            if (c == ']') {
                state = 44;
            } else {
                data.write(']');
                data.write(c);
                state = 42;
            }
            break;
        case 44:    // in CDATA, seen ']]'
            if (c == '>') {
                state = 0;
            } else if (c == ']') {
                data.write(']');
            } else {
                data.write("]]");
                data.write(c);
                state = 42;
            }
            break;
        default:
        }
        return state;
    }
    
        int state = 0;
        while (parseUntilEOF()) {}
    }

        boolean ret = false;
        int state = 0;
        while (state >= 0) {
            int c = read();
            if (c < 0) {
                try { r.close(); } catch (Exception e) {}
                ret = popInputSource();
                state = -1;
            } else {
                state = step(state, c);
            }
        }
        return ret;
    }

    public int getLineNumber() {
        return lineNumber;
    }

    public int getColumnNumber() {
        return columnNumber;
    }

        if (!docStarted) {
            docStarted = true;
        }
        attributes.clear();
    }
    
}