xmlparser.java

该源码是一个J2ME项目

/* kXML
 *
 * The contents of this file are subject to the Enhydra Public License
 * Version 1.1 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License
 * on the Enhydra web site ( http://www.enhydra.org/ ).
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific terms governing rights and limitations
 * under the License.
 *
 * The Initial Developer of kXML is Stefan Haustein. Copyright (C)
 * 2000, 2001 Stefan Haustein, D-46045 Oberhausen (Rhld.),
 * Germany. All Rights Reserved.
 *
 * Contributor(s): Paul Palaszewski, Wilhelm Fitzpatrick,
 *                 Eric Foster-Johnson, Michael Angel, Jan Andrle
 *
 * */

package org.kxml.parser;

import java.io.*;
import java.util.*;

import org.kxml.*;
import org.kxml.io.*;

/** A simple, pull based "Common XML" parser. Attention: This class has
    been renamed from DefaultParser for consitency with the org.kxml.io
    package. */

public class XmlParser
      extends AbstractXmlParser
{

  static final String UNEXPECTED_EOF = "Unexpected EOF";

  char[] buf;
  boolean eof;
  int bufPos = 0;
  int bufCount = 0;
  Reader reader;
  boolean relaxed;
  int line = 1;
  int column = 1;
  String astring;
  Vector qNames = new Vector();

  boolean immediateClose = false;
  StartTag current;

  /** The next event. May be null at startup. */

  protected ParseEvent next;

  /*
     int peekChar () throws IOException
     {
    if (eof) return -1;
    if (bufPos >= bufCount)
    {
         if (buf.length == 1)
         {
            int c = reader.read ();
            if (c == -1)
            {
                eof = true;
                return -1;
            }
            bufCount = 1;
            buf [0] = (char) c;
            //System.err.println( "int="+c);
         }
         else
         {
            bufCount = reader.read (buf, 0, buf.length);
            if (bufCount == -1)
            {
               eof = true;
               return -1;
            }
         }
      bufPos = 0;
    }
    return buf[bufPos];
     }
   */

  int peekChar() throws IOException
  {
    if (eof)
    {
      return -1;
    }

    if (bufCount == 0)
    {
      bufCount = astring.length();
      astring.getChars(0, astring.length(), buf, 0);
      return buf[0];
    }
    if (bufPos < bufCount)
    {
      return buf[bufPos];
    }
    else
    {
      eof = true;
      return -1;
    }

  }

  int readChar() throws IOException
  {
    int p = peekChar();
    bufPos++;
    column++;
    if (p == 10)
    {
      line++;
      column = 1;
    }
    return p;
  }

  void skipWhitespace() throws IOException
  {
    while (!eof && peekChar() <= ' ')
    {
      readChar();
    }
  }

  public String readName() throws IOException
  {

    int c = readChar();
    if (c < 128 && c != '_' && c != ':'
        && (c < 'a' || c > 'z')
        && (c < 'A' || c > 'Z'))
    {
      throw new DefaultParserException("name expected!", null);
    }

    StringBuffer buf = new StringBuffer();
    buf.append( (char) c);

    while (!eof)
    {
      c = peekChar();

      if (c < 128 && c != '_' && c != '-' && c != ':' && c != '.'
          && (c < '0' || c > '9')
          && (c < 'a' || c > 'z')
          && (c < 'A' || c > 'Z'))
      {

        break;
      }

      buf.append( (char) readChar());
    }

    return buf.toString();
  }

  /** Reads chars to the given buffer until the given stopChar
    is reached. The stopChar itself is not consumed. */

  public StringBuffer readTo(char stopChar,
                             StringBuffer buf) throws IOException
  {

    while (!eof && peekChar() != stopChar)
    {
      buf.append( (char) readChar());

    }
    return buf;
  }

  /** creates a new Parser based on the give reader */

  class DefaultParserException
        extends ParseException
  {
    DefaultParserException(String msg, Exception chained)
    {
      super(msg, chained, XmlParser.this.line, XmlParser.this.column);
    }
  }

  public XmlParser(Reader reader) throws IOException
  {
    this(reader,
         Runtime.getRuntime().freeMemory() >= 1048576 ? 8192 : 1);
  }

  public XmlParser(Reader reader, int bufSize) throws IOException
  {

    this.reader = reader; //new LookAheadReader (reader);
    buf = new char[bufSize];
  }

  public XmlParser(Reader reader, String astring) throws IOException
  {

    this.reader = reader; //new LookAheadReader (reader);
    buf = new char[astring.length()];
    this.astring = new String(astring);
  }

  public String resolveCharacterEntity(String name) throws IOException
  {

    throw new DefaultParserException("Undefined: &" + name + ";", null);
  }

  /* precondition: &lt;!- consumed */

  ParseEvent parseComment() throws IOException
  {

    StringBuffer buf = new StringBuffer();

    if (readChar() != '-')
    {
      throw new DefaultParserException("'-' expected", null);
    }

    int cnt;
    int lst;

    while (true)
    {
      readTo('-', buf);

      if (readChar() == -1)
      {
        throw new DefaultParserException(UNEXPECTED_EOF, null);
      }

      cnt = 0;

      do
      {
        lst = readChar();
        cnt++; // adds one more, but first is not cnted
      }
      while (lst == '-');

      if (lst == '>' && cnt >= 2)
      {
        break;
      }

      while (cnt-- > 0)
      {
        buf.append('-');

      }
      buf.append( (char) lst);
    }

    while (cnt-- > 2)
    {
      buf.append('-');

    }
    return new ParseEvent(Xml.COMMENT, buf.toString());
  }

  /* precondition: &lt! consumed */

  ParseEvent parseDoctype() throws IOException
  {

    StringBuffer buf = new StringBuffer();
    int nesting = 1;

    while (true)
    {
      int i = readChar();
      switch (i)
      {
        case -1:
          throw new DefaultParserException(UNEXPECTED_EOF, null);
        case '<':
          nesting++;
          break;
        case '>':
          if ( (--nesting) == 0)
          {
            return new ParseEvent(Xml.DOCTYPE, buf.toString());
          }
          break;
      }
      buf.append( (char) i);
    }
  }

  ParseEvent parseCData() throws IOException
  {

    StringBuffer buf = readTo('[', new StringBuffer());

    if (!buf.toString().equals("CDATA"))
    {
      throw new DefaultParserException("Invalid CDATA start!", null);
    }

    buf.setLength(0);

    readChar(); // skip '['

    int c0 = readChar();
    int c1 = readChar();

    while (true)
    {
      int c2 = readChar();

      if (c2 == -1)
      {
        throw new DefaultParserException(UNEXPECTED_EOF, null);
      }

      if (c0 == ']' && c1 == ']' && c2 == '>')
      {
        break;
      }

      buf.append( (char) c0);
      c0 = c1;
      c1 = c2;
    }

    return new ParseEvent(Xml.TEXT, buf.toString());
  }

  /* precondition: &lt;/ consumed */

  ParseEvent parseEndTag() throws IOException
  {

    skipWhitespace();
    String name = readName();
    skipWhitespace();

    if (readChar() != '>')
    {
      throw new DefaultParserException("'>' expected", null);
    }

    int last = qNames.size();
    while (true)
    {
      if (last == 0)
      {
        if (relaxed)
        {
          return new ParseEvent(Xml.END_DOCUMENT, null);
        }
        throw new DefaultParserException
              ("tagstack empty parsing </" + name + ">", null);
      }
      String qName = (String) qNames.elementAt(--last);
      qNames.removeElementAt(last);

      if (qName.equals(name))
      {
        break;
      }
      if (!relaxed)
      {
        throw new DefaultParserException
              ("StartTag <" + qName
               + "> does not match end tag </" + name + ">", null);
      }
      if (qName.toLowerCase().equals(name.toLowerCase()))
      {
        break;
      }
      current = current.parent;
    }

    Tag result = new Tag