Quadcap Embeddable Server

com/quadcap/http/client/HtmlParser.java

Go to the documentation of this file.

package com.quadcap.http.client;

/* 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;

/**
 * A SAX Parser for HTML.
 *
 * @author Stan Bailes
 */
public class HtmlParser 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();
    String                      tagName         = null;

    final static int            TAG             = 1;

    public HtmlParser() {}

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

    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();
        while (state >= 0) {
            int c = r.read();
            //System.out.println("[" + ((char)c) + "] [" + state + "] <" + tag.toString() + ">");
            if (c < 0) {
                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 '!':
                    data.write('<');
                    data.write('!');
                    commentState = 1;
                    state = 0;
                    break;
                case '/':
                    state = 8;
                    break;
                default:
                    tag.write(c);
                    state = 5;
                    break;
                }
                break;
            case 5:             // collect tag name
                switch (c) {
                case ' ':
                    tagName = tag.toString();
                    tag.reset();
                    state = 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;
                default:
                    tag.write(c);
                }
                break;
            case 6:             // collect attributes
                switch (c) {
                case ' ': case '\n': case '\r': case '\t':
                    break;
                case '/':
                    state = 9;
                    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 8:             // seen </
                if (c == '>') {
                    tagName = tag.toString();
                    tag.reset();
                    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 12:            // in attriblist, seen name="
                if (c == '"') {
                    attributes.addAttribute(attrName.toLowerCase(), "string",
                                            tag.toString());
                    tag.reset();
                    state = 6;
                } else {
                    tag.write(c);
                }
                break;
            case 121:            // in attriblist, seen name='
                if (c == '\'') {
                    attributes.addAttribute(attrName.toLowerCase(), "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.toLowerCase(), "string",
                                            tag.toString());
                    tag.reset();
                    state = 6;
                    break;
                case '/':
                    state = 14;
                    break;
                case '>':
                    attributes.addAttribute(attrName.toLowerCase(), "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.toLowerCase(), "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;
            }
        }
    }

}