stdxmlparser.java

Nano的XML解析器

            return;

         case 'D':
            this.processDocType();
            return;

         case '-':
            XMLUtil.skipComment(this.reader);
            return;
      }
   }


   /**
    * Processes a CDATA section.
    *
    * @throws java.lang.Exception
    *     if something went wrong
    */
   protected void processCDATA()
      throws Exception
   {
      if (! XMLUtil.checkLiteral(this.reader, "CDATA[")) {
         XMLUtil.errorExpectedInput(reader.getSystemID(),
                                    reader.getLineNr(),
                                    "<![[CDATA[");
      }

      this.validator.PCDataAdded(this.reader.getSystemID(),
                                 this.reader.getLineNr());
      Reader reader = new CDATAReader(this.reader);
      this.builder.addPCData(reader, this.reader.getSystemID(),
                             this.reader.getLineNr());
      reader.close();
   }


   /**
    * Processes a document type declaration.
    *
    * @throws java.lang.Exception
    *		if an error occurred reading or parsing the data
    */
   protected void processDocType()
      throws Exception
   {
      if (! XMLUtil.checkLiteral(this.reader, "OCTYPE")) {
         XMLUtil.errorExpectedInput(reader.getSystemID(),
                                    reader.getLineNr(),
                                    "<!DOCTYPE");
         return;
      }

      XMLUtil.skipWhitespace(this.reader, null);
      String systemID = null;
      StringBuffer publicID = new StringBuffer();
      String rootElement = XMLUtil.scanIdentifier(this.reader);
      XMLUtil.skipWhitespace(this.reader, null);
      char ch = this.reader.read();

      if (ch == 'P') {
         systemID = XMLUtil.scanPublicID(publicID, reader);
         XMLUtil.skipWhitespace(this.reader, null);
         ch = this.reader.read();
      } else if (ch == 'S') {
         systemID = XMLUtil.scanSystemID(reader);
         XMLUtil.skipWhitespace(this.reader, null);
         ch = this.reader.read();
      }

      if (ch == '[') {
         this.validator.parseDTD(publicID.toString(),
                                 this.reader,
                                 this.entityResolver,
                                 false);
         XMLUtil.skipWhitespace(this.reader, null);
         ch = this.reader.read();
      }

      if (ch != '>') {
         XMLUtil.errorExpectedInput(reader.getSystemID(),
                                    reader.getLineNr(),
                                    "`>'");
      }

      if (systemID != null) {
         Reader reader = this.reader.openStream(publicID.toString(),
                                                systemID);
         this.reader.startNewStream(reader);
         this.reader.setSystemID(systemID);
         this.reader.setPublicID(publicID.toString());
         this.validator.parseDTD(publicID.toString(),
                                 this.reader,
                                 this.entityResolver,
                                 true);
      }
   }


   /**
    * Processes a regular element.
    *
    * @param defaultNamespace the default namespace URI (or null)
    * @param namespaces list of defined namespaces
    *
    * @throws java.lang.Exception
    *     if something went wrong
    */
   protected void processElement(String     defaultNamespace,
                                 Properties namespaces)
      throws Exception
   {
      String fullName = XMLUtil.scanIdentifier(this.reader);
      String name = fullName;
      XMLUtil.skipWhitespace(this.reader, null);
      String prefix = null;
      int colonIndex = name.indexOf(':');

      if (colonIndex > 0) {
         prefix = name.substring(0, colonIndex);
         name = name.substring(colonIndex + 1);
      }

      Vector attrNames = new Vector();
      Vector attrValues = new Vector();
      Vector attrTypes = new Vector();

      this.validator.elementStarted(fullName,
                                    this.reader.getSystemID(),
                                    this.reader.getLineNr());
      char ch;

      for (;;) {
         ch = this.reader.read();

         if ((ch == '/') || (ch == '>')) {
            break;
         }

         this.reader.unread(ch);
         this.processAttribute(attrNames, attrValues, attrTypes);
         XMLUtil.skipWhitespace(this.reader, null);
      }

      Properties extraAttributes = new Properties();
      this.validator.elementAttributesProcessed(fullName,
                                                extraAttributes,
                                                this.reader.getSystemID(),
                                                this.reader.getLineNr());
      Enumeration enum = extraAttributes.keys();

      while (enum.hasMoreElements()) {
         String key = (String) enum.nextElement();
         String value = extraAttributes.getProperty(key);
         attrNames.addElement(key);
         attrValues.addElement(value);
         attrTypes.addElement("CDATA");
      }

      for (int i = 0; i < attrNames.size(); i++) {
         String key = (String) attrNames.elementAt(i);
         String value = (String) attrValues.elementAt(i);
         String type = (String) attrTypes.elementAt(i);

         if (key.equals("xmlns")) {
            defaultNamespace = value;
         } else if (key.startsWith("xmlns:")) {
            namespaces.put(key.substring(6), value);
         }
      }

      if (prefix == null) {
         this.builder.startElement(name, prefix, defaultNamespace,
                                   this.reader.getSystemID(),
                                   this.reader.getLineNr());
      } else {
         this.builder.startElement(name, prefix,
                                   namespaces.getProperty(prefix),
                                   this.reader.getSystemID(),
                                   this.reader.getLineNr());
      }

      for (int i = 0; i < attrNames.size(); i++) {
         String key = (String) attrNames.elementAt(i);

         if (key.startsWith("xmlns")) {
            continue;
         }

         String value = (String) attrValues.elementAt(i);
         String type = (String) attrTypes.elementAt(i);
         colonIndex = key.indexOf(':');

         if (colonIndex > 0) {
            String attPrefix = key.substring(0, colonIndex);
            key = key.substring(colonIndex + 1);
            this.builder.addAttribute(key, attPrefix,
                                      namespaces.getProperty(attPrefix),
                                      value, type);
         } else {
            this.builder.addAttribute(key, null, null, value, type);
         }
      }

      if (prefix == null) {
         this.builder.elementAttributesProcessed(name, prefix,
                                                 defaultNamespace);
      } else {
         this.builder.elementAttributesProcessed(name, prefix,
                                                 namespaces
                                                   .getProperty(prefix));
      }

      if (ch == '/') {
         if (this.reader.read() != '>') {
            XMLUtil.errorExpectedInput(reader.getSystemID(),
                                       reader.getLineNr(),
                                       "`>'");
         }

         this.validator.elementEnded(name,
                                     this.reader.getSystemID(),
                                     this.reader.getLineNr());

         if (prefix == null) {
            this.builder.endElement(name, prefix, defaultNamespace);
         } else {
            this.builder.endElement(name, prefix,
                                    namespaces.getProperty(prefix));
         }

         return;
      }

      StringBuffer buffer = new StringBuffer(16);

      for (;;) {
         buffer.setLength(0);
         String str;

         for (;;) {
            XMLUtil.skipWhitespace(this.reader, buffer);
            str = XMLUtil.read(this.reader, '&');

            if ((str.charAt(0) == '&') && (str.charAt(1) != '#')) {
               XMLUtil.processEntity(str, this.reader,
                                     this.entityResolver);
            } else {
               break;
            }
         }

         if (str.charAt(0) == '<') {
            str = XMLUtil.read(this.reader, '\0');

            if (str.charAt(0) == '/') {
               XMLUtil.skipWhitespace(this.reader, null);
               str = XMLUtil.scanIdentifier(this.reader);

               if (! str.equals(fullName)) {
                  XMLUtil.errorWrongClosingTag(reader.getSystemID(),
                                               reader.getLineNr(),
                                               name, str);
               }

               XMLUtil.skipWhitespace(this.reader, null);

               if (this.reader.read() != '>') {
                  XMLUtil.errorClosingTagNotEmpty(reader.getSystemID(),
                                                  reader.getLineNr());
               }

               this.validator.elementEnded(fullName,
                                           this.reader.getSystemID(),
                                           this.reader.getLineNr());
               if (prefix == null) {
                   this.builder.endElement(name, prefix, defaultNamespace);
               } else {
                   this.builder.endElement(name, prefix,
                                           namespaces.getProperty(prefix));
               }
               break;
            } else { // <[^/]
               this.reader.unread(str.charAt(0));
               this.scanSomeTag(true, //CDATA allowed
                                defaultNamespace,
                                (Properties) namespaces.clone());
            }
         } else { // [^<]
            if (str.charAt(0) == '&') {
               ch = XMLUtil.processCharLiteral(str);
               buffer.append(ch);
            } else {
               reader.unread(str.charAt(0));
            }
            this.validator.PCDataAdded(this.reader.getSystemID(),
                                       this.reader.getLineNr());
            Reader r = new ContentReader(this.reader,
                                         this.entityResolver,
                                         buffer.toString());
            this.builder.addPCData(r, this.reader.getSystemID(),
                                   this.reader.getLineNr());
            r.close();
         }
      }
   }


   /**
    * Processes an attribute of an element.
    *
    * @param attrNames contains the names of the attributes.
    * @param attrValues contains the values of the attributes.
    * @param attrTypes contains the types of the attributes.
    *
    * @throws java.lang.Exception
    *     if something went wrong
    */
   protected void processAttribute(Vector attrNames,
                                   Vector attrValues,
                                   Vector attrTypes)
      throws Exception
   {
      String key = XMLUtil.scanIdentifier(this.reader);
      XMLUtil.skipWhitespace(this.reader, null);

      if (! XMLUtil.read(this.reader, '&').equals("=")) {
         XMLUtil.errorExpectedInput(reader.getSystemID(),
                                    reader.getLineNr(),
                                    "`='");
      }

      XMLUtil.skipWhitespace(this.reader, null);
      String value = XMLUtil.scanString(this.reader, '&',
                                        this.entityResolver);
      attrNames.addElement(key);
      attrValues.addElement(value);
      attrTypes.addElement("CDATA");
      this.validator.attributeAdded(key, value,
                                    this.reader.getSystemID(),
                                    this.reader.getLineNr());
   }

}