Esempio n. 1
0
  /**
   * Scans External ID and return the public and system IDs.
   *
   * @param identifiers An array of size 2 to return the system id, and public id (in that order).
   * @param optionalSystemId Specifies whether the system id is optional.
   *     <p><strong>Note:</strong> This method uses fString and fStringBuffer, anything in them at
   *     the time of calling is lost.
   */
  protected void scanExternalID(String[] identifiers, boolean optionalSystemId)
      throws IOException, XNIException {

    String systemId = null;
    String publicId = null;
    if (fEntityScanner.skipString("PUBLIC")) {
      if (!fEntityScanner.skipSpaces()) {
        reportFatalError("SpaceRequiredAfterPUBLIC", null);
      }
      scanPubidLiteral(fString);
      publicId = fString.toString();

      if (!fEntityScanner.skipSpaces() && !optionalSystemId) {
        reportFatalError("SpaceRequiredBetweenPublicAndSystem", null);
      }
    }

    if (publicId != null || fEntityScanner.skipString("SYSTEM")) {
      if (publicId == null && !fEntityScanner.skipSpaces()) {
        reportFatalError("SpaceRequiredAfterSYSTEM", null);
      }
      int quote = fEntityScanner.peekChar();
      if (quote != '\'' && quote != '"') {
        if (publicId != null && optionalSystemId) {
          // looks like we don't have any system id
          // simply return the public id
          identifiers[0] = null;
          identifiers[1] = publicId;
          return;
        }
        reportFatalError("QuoteRequiredInSystemID", null);
      }
      fEntityScanner.scanChar();
      XMLString ident = fString;
      if (fEntityScanner.scanLiteral(quote, ident) != quote) {
        fStringBuffer.clear();
        do {
          fStringBuffer.append(ident);
          int c = fEntityScanner.peekChar();
          if (XMLChar.isMarkup(c) || c == ']') {
            fStringBuffer.append((char) fEntityScanner.scanChar());
          } else if (c != -1 && isInvalidLiteral(c)) {
            reportFatalError("InvalidCharInSystemID", new Object[] {Integer.toString(c, 16)});
          }
        } while (fEntityScanner.scanLiteral(quote, ident) != quote);
        fStringBuffer.append(ident);
        ident = fStringBuffer;
      }
      systemId = ident.toString();
      if (!fEntityScanner.skipChar(quote)) {
        reportFatalError("SystemIDUnterminated", null);
      }
    }

    // store result in array
    identifiers[0] = systemId;
    identifiers[1] = publicId;
  }
Esempio n. 2
0
  /**
   * Scans a processing data. This is needed to handle the situation where a document starts with a
   * processing instruction whose target name <em>starts with</em> "xml". (e.g. xmlfoo)
   *
   * <p><strong>Note:</strong> This method uses fStringBuffer, anything in it at the time of calling
   * is lost.
   *
   * @param target The PI target
   * @param data The string to fill in with the data
   */
  protected void scanPIData(String target, XMLString data) throws IOException, XNIException {

    // check target
    if (target.length() == 3) {
      char c0 = Character.toLowerCase(target.charAt(0));
      char c1 = Character.toLowerCase(target.charAt(1));
      char c2 = Character.toLowerCase(target.charAt(2));
      if (c0 == 'x' && c1 == 'm' && c2 == 'l') {
        reportFatalError("ReservedPITarget", null);
      }
    }

    // spaces
    if (!fEntityScanner.skipSpaces()) {
      if (fEntityScanner.skipString("?>")) {
        // we found the end, there is no data
        data.clear();
        return;
      } else {
        if (fNamespaces && fEntityScanner.peekChar() == ':') {
          fEntityScanner.scanChar();
          XMLStringBuffer colonName = new XMLStringBuffer(target);
          colonName.append(":");
          String str = fEntityScanner.scanName();
          if (str != null) colonName.append(str);
          reportFatalError("ColonNotLegalWithNS", new Object[] {colonName.toString()});
          fEntityScanner.skipSpaces();
        } else {
          // if there is data there should be some space
          reportFatalError("SpaceRequiredInPI", null);
        }
      }
    }

    fStringBuffer.clear();
    // data
    if (fEntityScanner.scanData("?>", fStringBuffer)) {
      do {
        int c = fEntityScanner.peekChar();
        if (c != -1) {
          if (XMLChar.isHighSurrogate(c)) {
            scanSurrogates(fStringBuffer);
          } else if (isInvalidLiteral(c)) {
            reportFatalError("InvalidCharInPI", new Object[] {Integer.toHexString(c)});
            fEntityScanner.scanChar();
          }
        }
      } while (fEntityScanner.scanData("?>", fStringBuffer));
    }
    data.setValues(fStringBuffer);
  } // scanPIData(String,XMLString)
Esempio n. 3
0
  /**
   * Scans surrogates and append them to the specified buffer.
   *
   * <p><strong>Note:</strong> This assumes the current char has already been identified as a high
   * surrogate.
   *
   * @param buf The StringBuffer to append the read surrogates to.
   * @return True if it succeeded.
   */
  protected boolean scanSurrogates(XMLStringBuffer buf) throws IOException, XNIException {

    int high = fEntityScanner.scanChar();
    int low = fEntityScanner.peekChar();
    if (!XMLChar.isLowSurrogate(low)) {
      reportFatalError("InvalidCharInContent", new Object[] {Integer.toString(high, 16)});
      return false;
    }
    fEntityScanner.scanChar();

    // convert surrogates to supplemental character
    int c = XMLChar.supplemental((char) high, (char) low);

    // supplemental character must be a valid XML character
    if (isInvalid(c)) {
      reportFatalError("InvalidCharInContent", new Object[] {Integer.toString(c, 16)});
      return false;
    }

    // fill in the buffer
    buf.append((char) high);
    buf.append((char) low);

    return true;
  } // scanSurrogates():boolean
Esempio n. 4
0
  /**
   * Scans a comment.
   *
   * <p>
   *
   * <pre>
   * [15] Comment ::= '&lt!--' ((Char - '-') | ('-' (Char - '-')))* '-->'
   * </pre>
   *
   * <p><strong>Note:</strong> Called after scanning past '&lt;!--' <strong>Note:</strong> This
   * method uses fString, anything in it at the time of calling is lost.
   *
   * @param text The buffer to fill in with the text.
   */
  protected void scanComment(XMLStringBuffer text) throws IOException, XNIException {

    // System.out.println( "XMLScanner#scanComment# In Scan Comment" );
    // text
    // REVISIT: handle invalid character, eof
    text.clear();
    while (fEntityScanner.scanData("--", text)) {
      int c = fEntityScanner.peekChar();

      // System.out.println( "XMLScanner#scanComment#text.toString() == " + text.toString() );
      // System.out.println( "XMLScanner#scanComment#c == " + c );

      if (c != -1) {
        if (XMLChar.isHighSurrogate(c)) {
          scanSurrogates(text);
        }
        if (isInvalidLiteral(c)) {
          reportFatalError("InvalidCharInComment", new Object[] {Integer.toHexString(c)});
          fEntityScanner.scanChar();
        }
      }
    }
    if (!fEntityScanner.skipChar('>')) {
      reportFatalError("DashDashInComment", null);
    }
  } // scanComment()
Esempio n. 5
0
  /**
   * Scans a pseudo attribute.
   *
   * @param scanningTextDecl True if scanning this pseudo-attribute for a TextDecl; false if
   *     scanning XMLDecl. This flag is needed to report the correct type of error.
   * @param value The string to fill in with the attribute value.
   * @return The name of the attribute
   *     <p><strong>Note:</strong> This method uses fStringBuffer2, anything in it at the time of
   *     calling is lost.
   */
  public String scanPseudoAttribute(boolean scanningTextDecl, XMLString value)
      throws IOException, XNIException {

    String name = scanPseudoAttributeName();
    // XMLEntityManager.print(fEntityManager.getCurrentEntity());

    if (name == null) {
      reportFatalError("PseudoAttrNameExpected", null);
    }
    fEntityScanner.skipSpaces();
    if (!fEntityScanner.skipChar('=')) {
      reportFatalError(
          scanningTextDecl ? "EqRequiredInTextDecl" : "EqRequiredInXMLDecl", new Object[] {name});
    }
    fEntityScanner.skipSpaces();
    int quote = fEntityScanner.peekChar();
    if (quote != '\'' && quote != '"') {
      reportFatalError(
          scanningTextDecl ? "QuoteRequiredInTextDecl" : "QuoteRequiredInXMLDecl",
          new Object[] {name});
    }
    fEntityScanner.scanChar();
    int c = fEntityScanner.scanLiteral(quote, value);
    if (c != quote) {
      fStringBuffer2.clear();
      do {
        fStringBuffer2.append(value);
        if (c != -1) {
          if (c == '&' || c == '%' || c == '<' || c == ']') {
            fStringBuffer2.append((char) fEntityScanner.scanChar());
          } else if (XMLChar.isHighSurrogate(c)) {
            scanSurrogates(fStringBuffer2);
          } else if (isInvalidLiteral(c)) {
            String key = scanningTextDecl ? "InvalidCharInTextDecl" : "InvalidCharInXMLDecl";
            reportFatalError(key, new Object[] {Integer.toString(c, 16)});
            fEntityScanner.scanChar();
          }
        }
        c = fEntityScanner.scanLiteral(quote, value);
      } while (c != quote);
      fStringBuffer2.append(value);
      value.setValues(fStringBuffer2);
    }
    if (!fEntityScanner.skipChar(quote)) {
      reportFatalError(
          scanningTextDecl ? "CloseQuoteMissingInTextDecl" : "CloseQuoteMissingInXMLDecl",
          new Object[] {name});
    }

    // return
    return name;
  } // scanPseudoAttribute(XMLString):String
Esempio n. 6
0
 /**
  * Scans the name of a pseudo attribute. The only legal names in XML 1.0/1.1 documents are
  * 'version', 'encoding' and 'standalone'.
  *
  * @return the name of the pseudo attribute or <code>null</code> if a legal pseudo attribute name
  *     could not be scanned.
  */
 private String scanPseudoAttributeName() throws IOException, XNIException {
   final int ch = fEntityScanner.peekChar();
   switch (ch) {
     case 'v':
       if (fEntityScanner.skipString(fVersionSymbol)) {
         return fVersionSymbol;
       }
       break;
     case 'e':
       if (fEntityScanner.skipString(fEncodingSymbol)) {
         return fEncodingSymbol;
       }
       break;
     case 's':
       if (fEntityScanner.skipString(fStandaloneSymbol)) {
         return fStandaloneSymbol;
       }
       break;
   }
   return null;
 } // scanPseudoAttributeName()
Esempio n. 7
0
  protected void scanPIData(String target, XMLStringBuffer data) throws IOException, XNIException {

    // check target
    if (target.length() == 3) {
      char c0 = Character.toLowerCase(target.charAt(0));
      char c1 = Character.toLowerCase(target.charAt(1));
      char c2 = Character.toLowerCase(target.charAt(2));
      if (c0 == 'x' && c1 == 'm' && c2 == 'l') {
        reportFatalError("ReservedPITarget", null);
      }
    }

    // spaces
    if (!fEntityScanner.skipSpaces()) {
      if (fEntityScanner.skipString("?>")) {
        // we found the end, there is no data just return
        return;
      } else {
        // if there is data there should be some space
        reportFatalError("SpaceRequiredInPI", null);
      }
    }

    // since scanData appends the parsed data to the buffer passed
    // a while loop would append the whole of parsed data to the buffer(data:XMLStringBuffer)
    // until all of the data is buffered.
    if (fEntityScanner.scanData("?>", data)) {
      do {
        int c = fEntityScanner.peekChar();
        if (c != -1) {
          if (XMLChar.isHighSurrogate(c)) {
            scanSurrogates(data);
          } else if (isInvalidLiteral(c)) {
            reportFatalError("InvalidCharInPI", new Object[] {Integer.toHexString(c)});
            fEntityScanner.scanChar();
          }
        }
      } while (fEntityScanner.scanData("?>", data));
    }
  } // scanPIData(String,XMLString)
Esempio n. 8
0
  /**
   * Scans an attribute value and normalizes whitespace converting all whitespace characters to
   * space characters.
   *
   * <p>[10] AttValue ::= '"' ([^<&"] | Reference)* '"' | "'" ([^<&'] | Reference)* "'"
   *
   * @param value The XMLString to fill in with the value.
   * @param nonNormalizedValue The XMLString to fill in with the non-normalized value.
   * @param atName The name of the attribute being parsed (for error msgs).
   * @param checkEntities true if undeclared entities should be reported as VC violation, false if
   *     undeclared entities should be reported as WFC violation.
   * @param eleName The name of element to which this attribute belongs.
   *     <p><strong>Note:</strong> This method uses fStringBuffer2, anything in it at the time of
   *     calling is lost.
   */
  protected void scanAttributeValue(
      XMLString value,
      XMLString nonNormalizedValue,
      String atName,
      boolean checkEntities,
      String eleName)
      throws IOException, XNIException {
    // quote
    int quote = fEntityScanner.peekChar();
    if (quote != '\'' && quote != '"') {
      reportFatalError("OpenQuoteExpected", new Object[] {eleName, atName});
    }

    fEntityScanner.scanChar();
    int entityDepth = fEntityDepth;

    int c = fEntityScanner.scanLiteral(quote, value);
    if (DEBUG_ATTR_NORMALIZATION) {
      System.out.println("** scanLiteral -> \"" + value.toString() + "\"");
    }
    fStringBuffer2.clear();
    fStringBuffer2.append(value);
    normalizeWhitespace(value);
    if (DEBUG_ATTR_NORMALIZATION) {
      System.out.println("** normalizeWhitespace -> \"" + value.toString() + "\"");
    }
    if (c != quote) {
      fScanningAttribute = true;
      fStringBuffer.clear();
      do {
        fStringBuffer.append(value);
        if (DEBUG_ATTR_NORMALIZATION) {
          System.out.println("** value2: \"" + fStringBuffer.toString() + "\"");
        }
        if (c == '&') {
          fEntityScanner.skipChar('&');
          if (entityDepth == fEntityDepth) {
            fStringBuffer2.append('&');
          }
          if (fEntityScanner.skipChar('#')) {
            if (entityDepth == fEntityDepth) {
              fStringBuffer2.append('#');
            }
            int ch = scanCharReferenceValue(fStringBuffer, fStringBuffer2);
            if (ch != -1) {
              if (DEBUG_ATTR_NORMALIZATION) {
                System.out.println("** value3: \"" + fStringBuffer.toString() + "\"");
              }
            }
          } else {
            String entityName = fEntityScanner.scanName();
            if (entityName == null) {
              reportFatalError("NameRequiredInReference", null);
            } else if (entityDepth == fEntityDepth) {
              fStringBuffer2.append(entityName);
            }
            if (!fEntityScanner.skipChar(';')) {
              reportFatalError("SemicolonRequiredInReference", new Object[] {entityName});
            } else if (entityDepth == fEntityDepth) {
              fStringBuffer2.append(';');
            }
            if (entityName == fAmpSymbol) {
              fStringBuffer.append('&');
              if (DEBUG_ATTR_NORMALIZATION) {
                System.out.println("** value5: \"" + fStringBuffer.toString() + "\"");
              }
            } else if (entityName == fAposSymbol) {
              fStringBuffer.append('\'');
              if (DEBUG_ATTR_NORMALIZATION) {
                System.out.println("** value7: \"" + fStringBuffer.toString() + "\"");
              }
            } else if (entityName == fLtSymbol) {
              fStringBuffer.append('<');
              if (DEBUG_ATTR_NORMALIZATION) {
                System.out.println("** value9: \"" + fStringBuffer.toString() + "\"");
              }
            } else if (entityName == fGtSymbol) {
              fStringBuffer.append('>');
              if (DEBUG_ATTR_NORMALIZATION) {
                System.out.println("** valueB: \"" + fStringBuffer.toString() + "\"");
              }
            } else if (entityName == fQuotSymbol) {
              fStringBuffer.append('"');
              if (DEBUG_ATTR_NORMALIZATION) {
                System.out.println("** valueD: \"" + fStringBuffer.toString() + "\"");
              }
            } else {
              if (fEntityManager.isExternalEntity(entityName)) {
                reportFatalError("ReferenceToExternalEntity", new Object[] {entityName});
              } else {
                if (!fEntityManager.isDeclaredEntity(entityName)) {
                  // WFC & VC: Entity Declared
                  if (checkEntities) {
                    if (fValidation) {
                      fErrorReporter.reportError(
                          XMLMessageFormatter.XML_DOMAIN,
                          "EntityNotDeclared",
                          new Object[] {entityName},
                          XMLErrorReporter.SEVERITY_ERROR);
                    }
                  } else {
                    reportFatalError("EntityNotDeclared", new Object[] {entityName});
                  }
                }
                fEntityManager.startEntity(entityName, true);
              }
            }
          }
        } else if (c == '<') {
          reportFatalError("LessthanInAttValue", new Object[] {eleName, atName});
          fEntityScanner.scanChar();
          if (entityDepth == fEntityDepth) {
            fStringBuffer2.append((char) c);
          }
        } else if (c == '%' || c == ']') {
          fEntityScanner.scanChar();
          fStringBuffer.append((char) c);
          if (entityDepth == fEntityDepth) {
            fStringBuffer2.append((char) c);
          }
          if (DEBUG_ATTR_NORMALIZATION) {
            System.out.println("** valueF: \"" + fStringBuffer.toString() + "\"");
          }
        } else if (c == '\n' || c == '\r') {
          fEntityScanner.scanChar();
          fStringBuffer.append(' ');
          if (entityDepth == fEntityDepth) {
            fStringBuffer2.append('\n');
          }
        } else if (c != -1 && XMLChar.isHighSurrogate(c)) {
          fStringBuffer3.clear();
          if (scanSurrogates(fStringBuffer3)) {
            fStringBuffer.append(fStringBuffer3);
            if (entityDepth == fEntityDepth) {
              fStringBuffer2.append(fStringBuffer3);
            }
            if (DEBUG_ATTR_NORMALIZATION) {
              System.out.println("** valueI: \"" + fStringBuffer.toString() + "\"");
            }
          }
        } else if (c != -1 && isInvalidLiteral(c)) {
          reportFatalError(
              "InvalidCharInAttValue", new Object[] {eleName, atName, Integer.toString(c, 16)});
          fEntityScanner.scanChar();
          if (entityDepth == fEntityDepth) {
            fStringBuffer2.append((char) c);
          }
        }
        c = fEntityScanner.scanLiteral(quote, value);
        if (entityDepth == fEntityDepth) {
          fStringBuffer2.append(value);
        }
        normalizeWhitespace(value);
      } while (c != quote || entityDepth != fEntityDepth);
      fStringBuffer.append(value);
      if (DEBUG_ATTR_NORMALIZATION) {
        System.out.println("** valueN: \"" + fStringBuffer.toString() + "\"");
      }
      value.setValues(fStringBuffer);
      fScanningAttribute = false;
    }
    nonNormalizedValue.setValues(fStringBuffer2);

    // quote
    int cquote = fEntityScanner.scanChar();
    if (cquote != quote) {
      reportFatalError("CloseQuoteExpected", new Object[] {eleName, atName});
    }
  } // scanAttributeValue()
Esempio n. 9
0
  /**
   * Scans a pseudo attribute.
   *
   * @param scanningTextDecl True if scanning this pseudo-attribute for a TextDecl; false if
   *     scanning XMLDecl. This flag is needed to report the correct type of error.
   * @param value The string to fill in with the attribute value.
   * @return The name of the attribute
   *     <p><strong>Note:</strong> This method uses fStringBuffer2, anything in it at the time of
   *     calling is lost.
   */
  public String scanPseudoAttribute(boolean scanningTextDecl, XMLString value)
      throws IOException, XNIException {

    // REVISIT: This method is used for generic scanning of
    // pseudo attributes, but since there are only three such
    // attributes: version, encoding, and standalone there are
    // for performant ways of scanning them. Every decl must
    // have a version, and in TextDecls this version must
    // be followed by an encoding declaration. Also the
    // methods we invoke on the scanners allow non-ASCII
    // characters to be parsed in the decls, but since
    // we don't even know what the actual encoding of the
    // document is until we scan the encoding declaration
    // you cannot reliably read any characters outside
    // of the ASCII range here. -- mrglavas
    String name = fEntityScanner.scanName();
    XMLEntityManager.print(fEntityManager.getCurrentEntity());
    if (name == null) {
      reportFatalError("PseudoAttrNameExpected", null);
    }
    fEntityScanner.skipDeclSpaces();
    if (!fEntityScanner.skipChar('=')) {
      reportFatalError(
          scanningTextDecl ? "EqRequiredInTextDecl" : "EqRequiredInXMLDecl", new Object[] {name});
    }
    fEntityScanner.skipDeclSpaces();
    int quote = fEntityScanner.peekChar();
    if (quote != '\'' && quote != '"') {
      reportFatalError(
          scanningTextDecl ? "QuoteRequiredInTextDecl" : "QuoteRequiredInXMLDecl",
          new Object[] {name});
    }
    fEntityScanner.scanChar();
    int c = fEntityScanner.scanLiteral(quote, value);
    if (c != quote) {
      fStringBuffer2.clear();
      do {
        fStringBuffer2.append(value);
        if (c != -1) {
          if (c == '&' || c == '%' || c == '<' || c == ']') {
            fStringBuffer2.append((char) fEntityScanner.scanChar());
          }
          // REVISIT: Even if you could reliably read non-ASCII chars
          // why bother scanning for surrogates here? Only ASCII chars
          // match the productions in XMLDecls and TextDecls. -- mrglavas
          else if (XMLChar.isHighSurrogate(c)) {
            scanSurrogates(fStringBuffer2);
          } else if (isInvalidLiteral(c)) {
            String key = scanningTextDecl ? "InvalidCharInTextDecl" : "InvalidCharInXMLDecl";
            reportFatalError(key, new Object[] {Integer.toString(c, 16)});
            fEntityScanner.scanChar();
          }
        }
        c = fEntityScanner.scanLiteral(quote, value);
      } while (c != quote);
      fStringBuffer2.append(value);
      value.setValues(fStringBuffer2);
    }
    if (!fEntityScanner.skipChar(quote)) {
      reportFatalError(
          scanningTextDecl ? "CloseQuoteMissingInTextDecl" : "CloseQuoteMissingInXMLDecl",
          new Object[] {name});
    }

    // return
    return name;
  } // scanPseudoAttribute(XMLString):String
Esempio n. 10
0
  /**
   * Scans an XML or text declaration.
   *
   * <p>
   *
   * <pre>
   * [23] XMLDecl ::= '<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>'
   * [24] VersionInfo ::= S 'version' Eq (' VersionNum ' | " VersionNum ")
   * [80] EncodingDecl ::= S 'encoding' Eq ('"' EncName '"' |  "'" EncName "'" )
   * [81] EncName ::= [A-Za-z] ([A-Za-z0-9._] | '-')*
   * [32] SDDecl ::= S 'standalone' Eq (("'" ('yes' | 'no') "'")
   *                 | ('"' ('yes' | 'no') '"'))
   *
   * [77] TextDecl ::= '<?xml' VersionInfo? EncodingDecl S? '?>'
   * </pre>
   *
   * @param scanningTextDecl True if a text declaration is to be scanned instead of an XML
   *     declaration.
   * @param pseudoAttributeValues An array of size 3 to return the version, encoding and standalone
   *     pseudo attribute values (in that order).
   *     <p><strong>Note:</strong> This method uses fString, anything in it at the time of calling
   *     is lost.
   */
  protected void scanXMLDeclOrTextDecl(boolean scanningTextDecl, String[] pseudoAttributeValues)
      throws IOException, XNIException {

    // pseudo-attribute values
    String version = null;
    String encoding = null;
    String standalone = null;

    // scan pseudo-attributes
    final int STATE_VERSION = 0;
    final int STATE_ENCODING = 1;
    final int STATE_STANDALONE = 2;
    final int STATE_DONE = 3;
    int state = STATE_VERSION;

    boolean dataFoundForTarget = false;
    boolean sawSpace = fEntityScanner.skipDeclSpaces();
    // since pseudoattributes are *not* attributes,
    // their quotes don't need to be preserved in external parameter entities.
    // the XMLEntityScanner#scanLiteral method will continue to
    // emit -1 in such cases when it finds a quote; this is
    // fine for other methods that parse scanned entities,
    // but not for the scanning of pseudoattributes.  So,
    // temporarily, we must mark the current entity as not being "literal"
    XMLEntityManager.ScannedEntity currEnt = fEntityManager.getCurrentEntity();
    boolean currLiteral = currEnt.literal;
    currEnt.literal = false;
    while (fEntityScanner.peekChar() != '?') {
      dataFoundForTarget = true;
      String name = scanPseudoAttribute(scanningTextDecl, fString);
      switch (state) {
        case STATE_VERSION:
          {
            if (name == fVersionSymbol) {
              if (!sawSpace) {
                reportFatalError(
                    scanningTextDecl
                        ? "SpaceRequiredBeforeVersionInTextDecl"
                        : "SpaceRequiredBeforeVersionInXMLDecl",
                    null);
              }
              version = fString.toString();
              state = STATE_ENCODING;
              if (!versionSupported(version)) {
                reportFatalError(getVersionNotSupportedKey(), new Object[] {version});
              }
            } else if (name == fEncodingSymbol) {
              if (!scanningTextDecl) {
                reportFatalError("VersionInfoRequired", null);
              }
              if (!sawSpace) {
                reportFatalError(
                    scanningTextDecl
                        ? "SpaceRequiredBeforeEncodingInTextDecl"
                        : "SpaceRequiredBeforeEncodingInXMLDecl",
                    null);
              }
              encoding = fString.toString();
              state = scanningTextDecl ? STATE_DONE : STATE_STANDALONE;
            } else {
              if (scanningTextDecl) {
                reportFatalError("EncodingDeclRequired", null);
              } else {
                reportFatalError("VersionInfoRequired", null);
              }
            }
            break;
          }
        case STATE_ENCODING:
          {
            if (name == fEncodingSymbol) {
              if (!sawSpace) {
                reportFatalError(
                    scanningTextDecl
                        ? "SpaceRequiredBeforeEncodingInTextDecl"
                        : "SpaceRequiredBeforeEncodingInXMLDecl",
                    null);
              }
              encoding = fString.toString();
              state = scanningTextDecl ? STATE_DONE : STATE_STANDALONE;
              // TODO: check encoding name; set encoding on
              //       entity scanner
            } else if (!scanningTextDecl && name == fStandaloneSymbol) {
              if (!sawSpace) {
                reportFatalError("SpaceRequiredBeforeStandalone", null);
              }
              standalone = fString.toString();
              state = STATE_DONE;
              if (!standalone.equals("yes") && !standalone.equals("no")) {
                reportFatalError("SDDeclInvalid", new Object[] {standalone});
              }
            } else {
              reportFatalError("EncodingDeclRequired", null);
            }
            break;
          }
        case STATE_STANDALONE:
          {
            if (name == fStandaloneSymbol) {
              if (!sawSpace) {
                reportFatalError("SpaceRequiredBeforeStandalone", null);
              }
              standalone = fString.toString();
              state = STATE_DONE;
              if (!standalone.equals("yes") && !standalone.equals("no")) {
                reportFatalError("SDDeclInvalid", new Object[] {standalone});
              }
            } else {
              reportFatalError("EncodingDeclRequired", null);
            }
            break;
          }
        default:
          {
            reportFatalError("NoMorePseudoAttributes", null);
          }
      }
      sawSpace = fEntityScanner.skipDeclSpaces();
    }
    // restore original literal value
    if (currLiteral) currEnt.literal = true;
    // REVISIT: should we remove this error reporting?
    if (scanningTextDecl && state != STATE_DONE) {
      reportFatalError("MorePseudoAttributes", null);
    }

    // If there is no data in the xml or text decl then we fail to report error
    // for version or encoding info above.
    if (scanningTextDecl) {
      if (!dataFoundForTarget && encoding == null) {
        reportFatalError("EncodingDeclRequired", null);
      }
    } else {
      if (!dataFoundForTarget && version == null) {
        reportFatalError("VersionInfoRequired", null);
      }
    }

    // end
    if (!fEntityScanner.skipChar('?')) {
      reportFatalError("XMLDeclUnterminated", null);
    }
    if (!fEntityScanner.skipChar('>')) {
      reportFatalError("XMLDeclUnterminated", null);
    }

    // fill in return array
    pseudoAttributeValues[0] = version;
    pseudoAttributeValues[1] = encoding;
    pseudoAttributeValues[2] = standalone;
  } // scanXMLDeclOrTextDecl(boolean)
Esempio n. 11
0
  /**
   * Scans a character reference and append the corresponding chars to the specified buffer.
   *
   * <p>
   *
   * <pre>
   * [66] CharRef ::= '&#' [0-9]+ ';' | '&#x' [0-9a-fA-F]+ ';'
   * </pre>
   *
   * <strong>Note:</strong> This method uses fStringBuffer, anything in it at the time of calling is
   * lost.
   *
   * @param buf the character buffer to append chars to
   * @param buf2 the character buffer to append non-normalized chars to
   * @return the character value or (-1) on conversion failure
   */
  protected int scanCharReferenceValue(XMLStringBuffer buf, XMLStringBuffer buf2)
      throws IOException, XNIException {

    // scan hexadecimal value
    boolean hex = false;
    if (fEntityScanner.skipChar('x')) {
      if (buf2 != null) {
        buf2.append('x');
      }
      hex = true;
      fStringBuffer3.clear();
      boolean digit = true;

      int c = fEntityScanner.peekChar();
      digit = (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
      if (digit) {
        if (buf2 != null) {
          buf2.append((char) c);
        }
        fEntityScanner.scanChar();
        fStringBuffer3.append((char) c);

        do {
          c = fEntityScanner.peekChar();
          digit = (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
          if (digit) {
            if (buf2 != null) {
              buf2.append((char) c);
            }
            fEntityScanner.scanChar();
            fStringBuffer3.append((char) c);
          }
        } while (digit);
      } else {
        reportFatalError("HexdigitRequiredInCharRef", null);
      }
    }

    // scan decimal value
    else {
      fStringBuffer3.clear();
      boolean digit = true;

      int c = fEntityScanner.peekChar();
      digit = c >= '0' && c <= '9';
      if (digit) {
        if (buf2 != null) {
          buf2.append((char) c);
        }
        fEntityScanner.scanChar();
        fStringBuffer3.append((char) c);

        do {
          c = fEntityScanner.peekChar();
          digit = c >= '0' && c <= '9';
          if (digit) {
            if (buf2 != null) {
              buf2.append((char) c);
            }
            fEntityScanner.scanChar();
            fStringBuffer3.append((char) c);
          }
        } while (digit);
      } else {
        reportFatalError("DigitRequiredInCharRef", null);
      }
    }

    // end
    if (!fEntityScanner.skipChar(';')) {
      reportFatalError("SemicolonRequiredInCharRef", null);
    }
    if (buf2 != null) {
      buf2.append(';');
    }

    // convert string to number
    int value = -1;
    try {
      value = Integer.parseInt(fStringBuffer3.toString(), hex ? 16 : 10);

      // character reference must be a valid XML character
      if (isInvalid(value)) {
        StringBuffer errorBuf = new StringBuffer(fStringBuffer3.length + 1);
        if (hex) errorBuf.append('x');
        errorBuf.append(fStringBuffer3.ch, fStringBuffer3.offset, fStringBuffer3.length);
        reportFatalError("InvalidCharRef", new Object[] {errorBuf.toString()});
      }
    } catch (NumberFormatException e) {
      // Conversion failed, let -1 value drop through.
      // If we end up here, the character reference was invalid.
      StringBuffer errorBuf = new StringBuffer(fStringBuffer3.length + 1);
      if (hex) errorBuf.append('x');
      errorBuf.append(fStringBuffer3.ch, fStringBuffer3.offset, fStringBuffer3.length);
      reportFatalError("InvalidCharRef", new Object[] {errorBuf.toString()});
    }

    // append corresponding chars to the given buffer
    if (!XMLChar.isSupplemental(value)) {
      buf.append((char) value);
    } else {
      // character is supplemental, split it into surrogate chars
      buf.append(XMLChar.highSurrogate(value));
      buf.append(XMLChar.lowSurrogate(value));
    }

    // char refs notification code
    if (fNotifyCharRefs && value != -1) {
      String literal = "#" + (hex ? "x" : "") + fStringBuffer3.toString();
      if (!fScanningAttribute) {
        fCharRefLiteral = literal;
      }
    }

    return value;
  }
Esempio n. 12
0
  /**
   * Scans an XML or text declaration.
   *
   * <p>
   *
   * <pre>
   * [23] XMLDecl ::= '<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>'
   * [24] VersionInfo ::= S 'version' Eq (' VersionNum ' | " VersionNum ")
   * [80] EncodingDecl ::= S 'encoding' Eq ('"' EncName '"' |  "'" EncName "'" )
   * [81] EncName ::= [A-Za-z] ([A-Za-z0-9._] | '-')*
   * [32] SDDecl ::= S 'standalone' Eq (("'" ('yes' | 'no') "'")
   *                 | ('"' ('yes' | 'no') '"'))
   *
   * [77] TextDecl ::= '<?xml' VersionInfo? EncodingDecl S? '?>'
   * </pre>
   *
   * @param scanningTextDecl True if a text declaration is to be scanned instead of an XML
   *     declaration.
   * @param pseudoAttributeValues An array of size 3 to return the version, encoding and standalone
   *     pseudo attribute values (in that order).
   *     <p><strong>Note:</strong> This method uses fString, anything in it at the time of calling
   *     is lost.
   */
  protected void scanXMLDeclOrTextDecl(boolean scanningTextDecl, String[] pseudoAttributeValues)
      throws IOException, XNIException {

    // pseudo-attribute values
    String version = null;
    String encoding = null;
    String standalone = null;

    // scan pseudo-attributes
    final int STATE_VERSION = 0;
    final int STATE_ENCODING = 1;
    final int STATE_STANDALONE = 2;
    final int STATE_DONE = 3;
    int state = STATE_VERSION;

    boolean dataFoundForTarget = false;
    boolean sawSpace = fEntityScanner.skipSpaces();
    while (fEntityScanner.peekChar() != '?') {
      dataFoundForTarget = true;
      String name = scanPseudoAttribute(scanningTextDecl, fString);
      switch (state) {
        case STATE_VERSION:
          {
            if (name.equals(fVersionSymbol)) {
              if (!sawSpace) {
                reportFatalError(
                    scanningTextDecl
                        ? "SpaceRequiredBeforeVersionInTextDecl"
                        : "SpaceRequiredBeforeVersionInXMLDecl",
                    null);
              }
              version = fString.toString();
              state = STATE_ENCODING;
              if (!versionSupported(version)) {
                reportFatalError("VersionNotSupported", new Object[] {version});
              }

              if (version.equals("1.1")) {
                Entity.ScannedEntity top = fEntityManager.getTopLevelEntity();
                if (top != null && (top.version == null || top.version.equals("1.0"))) {
                  reportFatalError("VersionMismatch", null);
                }
                fEntityManager.setScannerVersion(Constants.XML_VERSION_1_1);
              }

            } else if (name.equals(fEncodingSymbol)) {
              if (!scanningTextDecl) {
                reportFatalError("VersionInfoRequired", null);
              }
              if (!sawSpace) {
                reportFatalError(
                    scanningTextDecl
                        ? "SpaceRequiredBeforeEncodingInTextDecl"
                        : "SpaceRequiredBeforeEncodingInXMLDecl",
                    null);
              }
              encoding = fString.toString();
              state = scanningTextDecl ? STATE_DONE : STATE_STANDALONE;
            } else {
              if (scanningTextDecl) {
                reportFatalError("EncodingDeclRequired", null);
              } else {
                reportFatalError("VersionInfoRequired", null);
              }
            }
            break;
          }
        case STATE_ENCODING:
          {
            if (name.equals(fEncodingSymbol)) {
              if (!sawSpace) {
                reportFatalError(
                    scanningTextDecl
                        ? "SpaceRequiredBeforeEncodingInTextDecl"
                        : "SpaceRequiredBeforeEncodingInXMLDecl",
                    null);
              }
              encoding = fString.toString();
              state = scanningTextDecl ? STATE_DONE : STATE_STANDALONE;
              // TODO: check encoding name; set encoding on
              //       entity scanner
            } else if (!scanningTextDecl && name.equals(fStandaloneSymbol)) {
              if (!sawSpace) {
                reportFatalError("SpaceRequiredBeforeStandalone", null);
              }
              standalone = fString.toString();
              state = STATE_DONE;
              if (!standalone.equals("yes") && !standalone.equals("no")) {
                reportFatalError("SDDeclInvalid", new Object[] {standalone});
              }
            } else {
              reportFatalError("EncodingDeclRequired", null);
            }
            break;
          }
        case STATE_STANDALONE:
          {
            if (name.equals(fStandaloneSymbol)) {
              if (!sawSpace) {
                reportFatalError("SpaceRequiredBeforeStandalone", null);
              }
              standalone = fString.toString();
              state = STATE_DONE;
              if (!standalone.equals("yes") && !standalone.equals("no")) {
                reportFatalError("SDDeclInvalid", new Object[] {standalone});
              }
            } else {
              reportFatalError("EncodingDeclRequired", null);
            }
            break;
          }
        default:
          {
            reportFatalError("NoMorePseudoAttributes", null);
          }
      }
      sawSpace = fEntityScanner.skipSpaces();
    }
    // REVISIT: should we remove this error reporting?
    if (scanningTextDecl && state != STATE_DONE) {
      reportFatalError("MorePseudoAttributes", null);
    }

    // If there is no data in the xml or text decl then we fail to report error
    // for version or encoding info above.
    if (scanningTextDecl) {
      if (!dataFoundForTarget && encoding == null) {
        reportFatalError("EncodingDeclRequired", null);
      }
    } else {
      if (!dataFoundForTarget && version == null) {
        reportFatalError("VersionInfoRequired", null);
      }
    }

    // end
    if (!fEntityScanner.skipChar('?')) {
      reportFatalError("XMLDeclUnterminated", null);
    }
    if (!fEntityScanner.skipChar('>')) {
      reportFatalError("XMLDeclUnterminated", null);
    }

    // fill in return array
    pseudoAttributeValues[0] = version;
    pseudoAttributeValues[1] = encoding;
    pseudoAttributeValues[2] = standalone;
  } // scanXMLDeclOrTextDecl(boolean)