xml.java

来自「RESIN 3.2 最新源码」· Java 代码 · 共 1,012 行 · 第 1/2 页

  /**
   *
   * @param option
   * @return relevant value
   */
  public Value xml_parser_get_option(int option)
  {
    switch (option) {
    case XmlModule.XML_OPTION_CASE_FOLDING:
      return (_xmlOptionCaseFolding ? LongValue.ONE : LongValue.ZERO);
    case XmlModule.XML_OPTION_SKIP_TAGSTART:
      return LongValue.create(_xmlOptionSkipTagstart);
    case XmlModule.XML_OPTION_SKIP_WHITE:
      return (_xmlOptionSkipWhite ? LongValue.ONE : LongValue.ZERO);
    case XmlModule.XML_OPTION_TARGET_ENCODING:
      return _env.createString(_xmlOptionTargetEncoding);
    default:
      return BooleanValue.FALSE;
    }
  }

  public String toString()
  {
    return "Xml[]";
  }

  /**
   * handler solely for xml_parse_into_struct
   */
  class StructHandler extends DefaultHandler {
    private ArrayValueImpl _valueArray;
    private ArrayValueImpl _indexArray;

    //Keeps track of depth within tree;
    //startElement increments, endElement decrements
    private int _level = 1;

    private HashMap<Integer, String> _paramHashMap = new HashMap<Integer, String> ();
    private HashMap<StringValue, ArrayValueImpl> _indexArrayHashMap = new HashMap<StringValue, ArrayValueImpl>();
    private ArrayList<StringValue> _indexArrayKeys = new ArrayList<StringValue>();

    // Used to determine whether a given element has sub elements
    private boolean _isComplete = true;
    private boolean _isOutside = true;

    private int _valueArrayIndex = 0;

    private Locator _locator;

    public StructHandler(ArrayValueImpl valueArray,
                         ArrayValueImpl indexArray)
    {
      _valueArray = valueArray;
      _indexArray = indexArray;
    }

    public void setDocumentLocator(Locator locator)
    {
      _locator = locator;
    }

    public int getLine()
    {
      if (_locator != null)
	return _locator.getLineNumber();
      else
	return 0;
    }

    public int getColumn()
    {
      if (_locator != null)
	return _locator.getColumnNumber();
      else
	return 0;
    }

    /**
     * helper function to create an array of attributes for a tag
     * @param attrs
     * @return array of attributes
     */
    private ArrayValueImpl createAttributeArray(Attributes attrs)
    {
      ArrayValueImpl result = new ArrayValueImpl();

      // turn attrs into an array of name, value pairs
      for (int i = 0; i < attrs.getLength(); i++) {
        String aName = attrs.getLocalName(i); // Attr name
        if ("".equals(aName)) aName = attrs.getQName(i);
        if (_xmlOptionCaseFolding) aName = aName.toUpperCase();
        result.put(_env.createString(aName), _env.createString(attrs.getValue(i)));
      }

      return result;
    }

    public void endDocument()
      throws SAXException
    {
      for(StringValue sv : _indexArrayKeys) {
        _indexArray.put(sv, _indexArrayHashMap.get(sv));
      }
    }

    public void startElement(String namespaceURI,
                             String lName,
                             String qName,
                             Attributes attrs)
      throws SAXException
    {
      Value elementArray = new ArrayValueImpl();

      String eName = lName; // element name
      if ("".equals(eName)) eName = qName;
      if (_xmlOptionCaseFolding) eName = eName.toUpperCase();

      elementArray.put(_env.createString("tag"), _env.createString(eName));
      elementArray.put(_env.createString("type"), _env.createString("open"));
      elementArray.put(_env.createString("level"), LongValue.create(_level));
      _paramHashMap.put(_level, eName);

      if (attrs.getLength() > 0) {
        elementArray.put(_env.createString("attributes"), createAttributeArray(attrs));
      }

      _valueArray.put(LongValue.create(_valueArrayIndex), elementArray);

      addToIndexArrayHashMap(eName);

      _valueArrayIndex++;
      _level++;
      _isComplete = true;
      _isOutside = false;
    }

    public void endElement(String namespaceURI,
                           String sName,
                           String qName)
      throws SAXException
    {
      Value elementArray;

      _level--;

      if (_isComplete) {
        elementArray = _valueArray.get(LongValue.create(_valueArrayIndex - 1));
        elementArray.put(_env.createString("type"), _env.createString("complete"));
      } else {
        elementArray = new ArrayValueImpl();
        String eName = sName; // element name
        if ("".equals(sName)) eName = qName;
        if (_xmlOptionCaseFolding) eName = eName.toUpperCase();
        elementArray.put(_env.createString("tag"), _env.createString(eName));
        elementArray.put(_env.createString("type"), _env.createString("close"));
        elementArray.put(_env.createString("level"), LongValue.create(_level));
        _valueArray.put(LongValue.create(_valueArrayIndex), elementArray);

        addToIndexArrayHashMap(eName);
        _valueArrayIndex++;
      }

      _isComplete = false;
      _isOutside = true;
    }

    private void addToIndexArrayHashMap(String eName)
    {
      StringValue key = _env.createString(eName);
      ArrayValueImpl indexArray = _indexArrayHashMap.get(key);

      if (indexArray == null) {
        indexArray = new ArrayValueImpl();
        _indexArrayKeys.add(key);
      }

      indexArray.put(LongValue.create(_valueArrayIndex));
      _indexArrayHashMap.put(key, indexArray);
    }

    public void characters(char[] ch,
                           int start,
                           int length)
      throws SAXException
    {
      String s = new String(ch, start, length);

      if (_isOutside) {
        Value elementArray = new ArrayValueImpl();
        elementArray.put(_env.createString("tag"), _env.createString(_paramHashMap.get(_level - 1)));
        elementArray.put(_env.createString("value"), _env.createString(s));
        elementArray.put(_env.createString("type"), _env.createString("cdata"));
        elementArray.put(_env.createString("level"), LongValue.create(_level - 1));
        _valueArray.put(LongValue.create(_valueArrayIndex), elementArray);

        Value indexArray = _indexArray.get(_env.createString(_paramHashMap.get(_level - 1)));
        indexArray.put(LongValue.create(_valueArrayIndex));

        _valueArrayIndex++;
      } else {
        Value elementArray = _valueArray.get(LongValue.create(_valueArrayIndex - 1));
        elementArray.put(_env.createString("value"), _env.createString(s));
      }
    }
  }

  class XmlHandler extends DefaultHandler {
    private Locator _locator;

    public void setDocumentLocator(Locator locator)
    {
      _locator = locator;
    }

    public int getLine()
    {
      if (_locator != null)
	return _locator.getLineNumber();
      else
	return 0;
    }

    public int getColumn()
    {
      if (_locator != null)
	return _locator.getColumnNumber();
      else
	return 0;
    }

    /**
     * wrapper for _startElementHandler.  creates Value[] args
     *
     * @param namespaceURI
     * @param lName
     * @param qName
     * @param attrs
     * @throws SAXException
     */
    public void startElement(String namespaceURI,
                             String lName,
                             String qName,
                             Attributes attrs)
      throws SAXException
    {
      /**
       *  args[0] reference to this parser
       *  args[1] name of element
       *  args[2] array of attributes
       *
       *  Typical call in PHP looks like:
       *
       *  function startElement($parser, $name, $attrs) {...}
       */
      Value[] args = new Value[3];

      args[0] = _parser;

      String eName = lName; // element name
      if ("".equals(eName))
	eName = qName;
      
      if (_xmlOptionCaseFolding)
	eName = eName.toUpperCase();
      
      args[1] = _env.createString(eName);

      // turn attrs into an array of name, value pairs
      args[2] = new ArrayValueImpl();
      for (int i = 0; i < attrs.getLength(); i++) {
        String aName = attrs.getLocalName(i); // Attr name
	
        if ("".equals(aName))
	  aName = attrs.getQName(i);
	
        if (_xmlOptionCaseFolding)
	  aName = aName.toUpperCase();
	
        args[2].put(_env.createString(aName), _env.createString(attrs.getValue(i)));
      }

      try {
        if (_startElementHandler != null)
          _startElementHandler.call(_env, args);
        else {
          if (log.isLoggable(Level.FINER))
            log.finer(this + " startElement " + qName);
        }
      } catch (Exception t) {
        log.log(Level.FINE, t.toString(), t);
        throw new SAXException(L.l(t.getMessage()));
      }
    }

    /**
     * wrapper for _endElementHandler
     *
     * @param namespaceURI
     * @param sName
     * @param qName
     * @throws SAXException
     */
    public void endElement(String namespaceURI,
                           String sName,
                           String qName)
      throws SAXException
    {
      try {
        String eName = sName; // element name
        if ("".equals(eName)) eName = qName;
        if (_xmlOptionCaseFolding) eName = eName.toUpperCase();

        if (_endElementHandler != null)
          _endElementHandler.call(_env, _parser, _env.createString(eName));
        else {
	  if (log.isLoggable(Level.FINER))
	    log.finer(this + " endElement " + sName);
	}
      } catch (Exception t) {
        log.log(Level.FINE, t.toString(), t);
        throw new SAXException(L.l(t.getMessage()));
      }
    }

    /**
     * wrapper for _characterDataHandler
     *
     * @param ch
     * @param start
     * @param length
     * @throws SAXException
     */
    public void characters(char[] buf,
                           int start,
                           int length)
      throws SAXException
    {
      StringValue value;
      
      if (_env.isUnicodeSemantics()) {
        value = _env.createString(buf, start, length);
      }
      else {
        String s = new String(buf, start, length);
        
        byte[] bytes;
        
        try {
          bytes = s.getBytes(_xmlOptionTargetEncoding);
        } catch (UnsupportedEncodingException e) {
          throw new QuercusException(e);
        }

        value = _env.createStringBuilder();
        
        value.append(bytes);
      }

      try {
        if (_characterDataHandler != null)
          _characterDataHandler.call(_env, _parser, value);
        else if (_defaultHandler != null)
          _defaultHandler.call(_env, _parser, value);
        else {
          if (log.isLoggable(Level.FINER))
            log.finer(this + " characters '" + value + "'");
        }
      } catch (Exception t) {
        log.log(Level.FINE, t.toString(), t);
        throw new SAXException(L.l(t.getMessage()));
      }
    }

    /**
     * wrapper for _processingInstructionHandler
     * @param target
     * @param data
     * @throws SAXException
     */
    public void processingInstruction(String target,
                                      String data)
      throws SAXException
    {
      try {
        if (_processingInstructionHandler != null) {
          _processingInstructionHandler.call(_env, _parser,
					     _env.createString(target),
					     _env.createString(data));
	}
        else {
	  if (log.isLoggable(Level.FINER))
	    log.finer(this + " processingInstruction " + target);
	}
      } catch (Exception t) {
        log.log(Level.FINE, t.toString(), t);
        throw new SAXException(L.l(t.getMessage()));
      }
    }

    /**
     * wrapper for _startNamespaceDeclHandler
     * @param prefix
     * @param uri
     * @throws SAXException
     */
    public void startPrefixMapping (String prefix,
                                    String uri)
      throws SAXException
    {
      try {
        if (_startNamespaceDeclHandler != null)
          _startNamespaceDeclHandler.call(_env, _env.createString(prefix), _env.createString(uri));
        else {
	  if (log.isLoggable(Level.FINER))
	    log.finer(this + " startPrefixMapping " + prefix + " " + uri);
	}
      } catch (Exception t) {
        log.log(Level.FINE, t.toString(), t);
        throw new SAXException(L.l(t.getMessage()));
      }
    }

    /**
     * wrapper for _endNamespaceDeclHandler
     *
     * @param prefix
     * @throws SAXException
     */
    public void endPrefixMapping(String prefix)
      throws SAXException
    {
      try {
        if (_endNamespaceDeclHandler != null)
          _endNamespaceDeclHandler.call(_env, _env.createString(prefix));
        else {
	  if (log.isLoggable(Level.FINER))
	    log.finer(this + " endPrefixMapping");
	}
      } catch (Exception t) {
        log.log(Level.FINE, t.toString(), t);
        throw new SAXException(L.l(t.getMessage()));
      }
    }

    public void notationDecl(String name,
                             String publicId,
                             String systemId)
      throws SAXException
    {
      try {
        if (_notationDeclHandler != null)
          _notationDeclHandler.call(_env,
                                    _parser,
                                    _env.createString(name),
                                    _env.createString(""),
                                    _env.createString(systemId),
                                    _env.createString(publicId));
        else {
	  if (log.isLoggable(Level.FINER))
	    log.finer(this + " notation " + name);
	}
      } catch (Exception t) {
        log.log(Level.FINE, t.toString(), t);
        throw new SAXException(L.l(t.getMessage()));
      }
    }

    @Override
    public void unparsedEntityDecl(String name,
                                   String publicId,
                                   String systemId,
                                   String notationName)
      throws SAXException
    {
      /**
       * args[0] reference to this parser
       * args[1] name
       * args[2] base (always "")
       * args[3] systemId
       * args[4] publicId
       * args[5] notationName
       */
      Value[] args = new Value[6];

      args[0] = _parser;
      args[1] = _env.createString(name);
      args[2] = _env.createString("");
      args[3] = _env.createString(systemId);
      args[4] = _env.createString(publicId);
      args[5] = _env.createString(notationName);

      try {
        if (_unparsedEntityDeclHandler != null)
          _unparsedEntityDeclHandler.call(_env, args);
        else {
	  if (log.isLoggable(Level.FINER))
	    log.finer(this + " unparsedEntity " + name);
	}
      } catch (Exception t) {
        log.log(Level.FINE, t.toString(), t);
        throw new SAXException(L.l(t.getMessage()));
      }
    }
  }
}