cocoon-cvs mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From br...@apache.org
Subject cvs commit: cocoon-2.1/src/java/org/apache/cocoon/components/xpointer/parser ParseException.java SimpleCharStream.java Token.java TokenMgrError.java XPointerFrameworkParser.java XPointerFrameworkParserConstants.java XPointerFrameworkParserTokenManager.java xpointer-fw.jj
Date Tue, 20 May 2003 11:57:15 GMT
bruno       2003/05/20 04:57:15

  Added:       src/java/org/apache/cocoon/components/xpointer
                        PointerPart.java ShorthandPart.java
                        UnsupportedPart.java XPointer.java
                        XPointerContext.java XPointerPart.java
                        XmlnsPart.java
               src/java/org/apache/cocoon/components/xpointer/parser
                        ParseException.java SimpleCharStream.java
                        Token.java TokenMgrError.java
                        XPointerFrameworkParser.java
                        XPointerFrameworkParserConstants.java
                        XPointerFrameworkParserTokenManager.java
                        xpointer-fw.jj
  Log:
  initial commit -- xpointer framework implementation
  
  Revision  Changes    Path
  1.1                  cocoon-2.1/src/java/org/apache/cocoon/components/xpointer/PointerPart.java
  
  Index: PointerPart.java
  ===================================================================
  /*
  
   ============================================================================
                     The Apache Software License, Version 1.1
   ============================================================================
  
   Copyright (C) 1999-2003 The Apache Software Foundation. All rights reserved.
  
   Redistribution and use in source and binary forms, with or without modifica-
   tion, are permitted provided that the following conditions are met:
  
   1. Redistributions of  source code must  retain the above copyright  notice,
      this list of conditions and the following disclaimer.
  
   2. Redistributions in binary form must reproduce the above copyright notice,
      this list of conditions and the following disclaimer in the documentation
      and/or other materials provided with the distribution.
  
   3. The end-user documentation included with the redistribution, if any, must
      include  the following  acknowledgment:  "This product includes  software
      developed  by the  Apache Software Foundation  (http://www.apache.org/)."
      Alternately, this  acknowledgment may  appear in the software itself,  if
      and wherever such third-party acknowledgments normally appear.
  
   4. The names "Apache Cocoon" and  "Apache Software Foundation" must  not  be
      used to  endorse or promote  products derived from  this software without
      prior written permission. For written permission, please contact
      apache@apache.org.
  
   5. Products  derived from this software may not  be called "Apache", nor may
      "Apache" appear  in their name,  without prior written permission  of the
      Apache Software Foundation.
  
   THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
   FITNESS  FOR A PARTICULAR  PURPOSE ARE  DISCLAIMED.  IN NO  EVENT SHALL  THE
   APACHE SOFTWARE  FOUNDATION  OR ITS CONTRIBUTORS  BE LIABLE FOR  ANY DIRECT,
   INDIRECT, INCIDENTAL, SPECIAL,  EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLU-
   DING, BUT NOT LIMITED TO, PROCUREMENT  OF SUBSTITUTE GOODS OR SERVICES; LOSS
   OF USE, DATA, OR  PROFITS; OR BUSINESS  INTERRUPTION)  HOWEVER CAUSED AND ON
   ANY  THEORY OF LIABILITY,  WHETHER  IN CONTRACT,  STRICT LIABILITY,  OR TORT
   (INCLUDING  NEGLIGENCE OR  OTHERWISE) ARISING IN  ANY WAY OUT OF THE  USE OF
   THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  
   This software  consists of voluntary contributions made  by many individuals
   on  behalf of the Apache Software  Foundation and was  originally created by
   Stefano Mazzocchi  <stefano@apache.org>. For more  information on the Apache
   Software Foundation, please see <http://www.apache.org/>.
  
  */
  package org.apache.cocoon.components.xpointer;
  
  import org.xml.sax.SAXException;
  
  /**
   * Interface to be implemented by pointer parts (xpointer schemes).
   */
  public interface PointerPart {
      /**
       * If this pointer part successfully identifies any subresources, it should
       * stream them to the XMLConsumer available from the XPointerContext and return true.
       * Otherwise this method should return false.
       */
      public boolean process(XPointerContext xpointerContext) throws SAXException;
  }
  
  
  
  1.1                  cocoon-2.1/src/java/org/apache/cocoon/components/xpointer/ShorthandPart.java
  
  Index: ShorthandPart.java
  ===================================================================
  /*
  
   ============================================================================
                     The Apache Software License, Version 1.1
   ============================================================================
  
   Copyright (C) 1999-2003 The Apache Software Foundation. All rights reserved.
  
   Redistribution and use in source and binary forms, with or without modifica-
   tion, are permitted provided that the following conditions are met:
  
   1. Redistributions of  source code must  retain the above copyright  notice,
      this list of conditions and the following disclaimer.
  
   2. Redistributions in binary form must reproduce the above copyright notice,
      this list of conditions and the following disclaimer in the documentation
      and/or other materials provided with the distribution.
  
   3. The end-user documentation included with the redistribution, if any, must
      include  the following  acknowledgment:  "This product includes  software
      developed  by the  Apache Software Foundation  (http://www.apache.org/)."
      Alternately, this  acknowledgment may  appear in the software itself,  if
      and wherever such third-party acknowledgments normally appear.
  
   4. The names "Apache Cocoon" and  "Apache Software Foundation" must  not  be
      used to  endorse or promote  products derived from  this software without
      prior written permission. For written permission, please contact
      apache@apache.org.
  
   5. Products  derived from this software may not  be called "Apache", nor may
      "Apache" appear  in their name,  without prior written permission  of the
      Apache Software Foundation.
  
   THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
   FITNESS  FOR A PARTICULAR  PURPOSE ARE  DISCLAIMED.  IN NO  EVENT SHALL  THE
   APACHE SOFTWARE  FOUNDATION  OR ITS CONTRIBUTORS  BE LIABLE FOR  ANY DIRECT,
   INDIRECT, INCIDENTAL, SPECIAL,  EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLU-
   DING, BUT NOT LIMITED TO, PROCUREMENT  OF SUBSTITUTE GOODS OR SERVICES; LOSS
   OF USE, DATA, OR  PROFITS; OR BUSINESS  INTERRUPTION)  HOWEVER CAUSED AND ON
   ANY  THEORY OF LIABILITY,  WHETHER  IN CONTRACT,  STRICT LIABILITY,  OR TORT
   (INCLUDING  NEGLIGENCE OR  OTHERWISE) ARISING IN  ANY WAY OUT OF THE  USE OF
   THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  
   This software  consists of voluntary contributions made  by many individuals
   on  behalf of the Apache Software  Foundation and was  originally created by
   Stefano Mazzocchi  <stefano@apache.org>. For more  information on the Apache
   Software Foundation, please see <http://www.apache.org/>.
  
  */
  package org.apache.cocoon.components.xpointer;
  
  import org.apache.cocoon.xml.dom.DOMStreamer;
  import org.w3c.dom.Document;
  import org.w3c.dom.Element;
  import org.xml.sax.SAXException;
  
  /**
   * Implements support for shorthand XPointers (= id-based lookup). We treat them here as if they
   * were a pointerpart too.
   *
   * <p>Note that although this is implemented here, this feature depends on the presence of a DTD,
   * and a validating parser. Currently, this means its unuseable within Cocoon.
   */
  public class ShorthandPart implements PointerPart {
      private String shorthand;
  
      public ShorthandPart(String shorthand) {
          this.shorthand = shorthand;
      }
  
      public boolean process(XPointerContext xpointerContext) throws SAXException {
          Document document = xpointerContext.getDocument();
          Element element = document.getElementById(shorthand);
          if (element != null) {
              DOMStreamer streamer = new DOMStreamer();
              streamer.setConsumer(xpointerContext.getXmlConsumer());
              streamer.stream(element);
              return true;
          } else {
              if (xpointerContext.getLogger().isDebugEnabled())
                  xpointerContext.getLogger().debug("XPointer: found no element with id " + shorthand + " in document " + xpointerContext.getSource().getURI());
          }
          return false;
      }
  }
  
  
  
  1.1                  cocoon-2.1/src/java/org/apache/cocoon/components/xpointer/UnsupportedPart.java
  
  Index: UnsupportedPart.java
  ===================================================================
  /*
  
   ============================================================================
                     The Apache Software License, Version 1.1
   ============================================================================
  
   Copyright (C) 1999-2003 The Apache Software Foundation. All rights reserved.
  
   Redistribution and use in source and binary forms, with or without modifica-
   tion, are permitted provided that the following conditions are met:
  
   1. Redistributions of  source code must  retain the above copyright  notice,
      this list of conditions and the following disclaimer.
  
   2. Redistributions in binary form must reproduce the above copyright notice,
      this list of conditions and the following disclaimer in the documentation
      and/or other materials provided with the distribution.
  
   3. The end-user documentation included with the redistribution, if any, must
      include  the following  acknowledgment:  "This product includes  software
      developed  by the  Apache Software Foundation  (http://www.apache.org/)."
      Alternately, this  acknowledgment may  appear in the software itself,  if
      and wherever such third-party acknowledgments normally appear.
  
   4. The names "Apache Cocoon" and  "Apache Software Foundation" must  not  be
      used to  endorse or promote  products derived from  this software without
      prior written permission. For written permission, please contact
      apache@apache.org.
  
   5. Products  derived from this software may not  be called "Apache", nor may
      "Apache" appear  in their name,  without prior written permission  of the
      Apache Software Foundation.
  
   THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
   FITNESS  FOR A PARTICULAR  PURPOSE ARE  DISCLAIMED.  IN NO  EVENT SHALL  THE
   APACHE SOFTWARE  FOUNDATION  OR ITS CONTRIBUTORS  BE LIABLE FOR  ANY DIRECT,
   INDIRECT, INCIDENTAL, SPECIAL,  EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLU-
   DING, BUT NOT LIMITED TO, PROCUREMENT  OF SUBSTITUTE GOODS OR SERVICES; LOSS
   OF USE, DATA, OR  PROFITS; OR BUSINESS  INTERRUPTION)  HOWEVER CAUSED AND ON
   ANY  THEORY OF LIABILITY,  WHETHER  IN CONTRACT,  STRICT LIABILITY,  OR TORT
   (INCLUDING  NEGLIGENCE OR  OTHERWISE) ARISING IN  ANY WAY OUT OF THE  USE OF
   THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  
   This software  consists of voluntary contributions made  by many individuals
   on  behalf of the Apache Software  Foundation and was  originally created by
   Stefano Mazzocchi  <stefano@apache.org>. For more  information on the Apache
   Software Foundation, please see <http://www.apache.org/>.
  
  */
  package org.apache.cocoon.components.xpointer;
  
  import org.xml.sax.SAXException;
  
  public class UnsupportedPart implements PointerPart {
      private String schemeName;
  
      public UnsupportedPart(String schemeName) {
          this.schemeName = schemeName;
      }
  
      public boolean process(XPointerContext xpointerContext) throws SAXException {
          if (xpointerContext.getLogger().isDebugEnabled())
              xpointerContext.getLogger().debug("Scheme " + schemeName + " not supported by this XPointer implementation, as used in the fragment identifier " + xpointerContext.getXPointer());
          return false;
      }
  }
  
  
  
  1.1                  cocoon-2.1/src/java/org/apache/cocoon/components/xpointer/XPointer.java
  
  Index: XPointer.java
  ===================================================================
  /*
  
   ============================================================================
                     The Apache Software License, Version 1.1
   ============================================================================
  
   Copyright (C) 1999-2003 The Apache Software Foundation. All rights reserved.
  
   Redistribution and use in source and binary forms, with or without modifica-
   tion, are permitted provided that the following conditions are met:
  
   1. Redistributions of  source code must  retain the above copyright  notice,
      this list of conditions and the following disclaimer.
  
   2. Redistributions in binary form must reproduce the above copyright notice,
      this list of conditions and the following disclaimer in the documentation
      and/or other materials provided with the distribution.
  
   3. The end-user documentation included with the redistribution, if any, must
      include  the following  acknowledgment:  "This product includes  software
      developed  by the  Apache Software Foundation  (http://www.apache.org/)."
      Alternately, this  acknowledgment may  appear in the software itself,  if
      and wherever such third-party acknowledgments normally appear.
  
   4. The names "Apache Cocoon" and  "Apache Software Foundation" must  not  be
      used to  endorse or promote  products derived from  this software without
      prior written permission. For written permission, please contact
      apache@apache.org.
  
   5. Products  derived from this software may not  be called "Apache", nor may
      "Apache" appear  in their name,  without prior written permission  of the
      Apache Software Foundation.
  
   THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
   FITNESS  FOR A PARTICULAR  PURPOSE ARE  DISCLAIMED.  IN NO  EVENT SHALL  THE
   APACHE SOFTWARE  FOUNDATION  OR ITS CONTRIBUTORS  BE LIABLE FOR  ANY DIRECT,
   INDIRECT, INCIDENTAL, SPECIAL,  EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLU-
   DING, BUT NOT LIMITED TO, PROCUREMENT  OF SUBSTITUTE GOODS OR SERVICES; LOSS
   OF USE, DATA, OR  PROFITS; OR BUSINESS  INTERRUPTION)  HOWEVER CAUSED AND ON
   ANY  THEORY OF LIABILITY,  WHETHER  IN CONTRACT,  STRICT LIABILITY,  OR TORT
   (INCLUDING  NEGLIGENCE OR  OTHERWISE) ARISING IN  ANY WAY OUT OF THE  USE OF
   THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  
   This software  consists of voluntary contributions made  by many individuals
   on  behalf of the Apache Software  Foundation and was  originally created by
   Stefano Mazzocchi  <stefano@apache.org>. For more  information on the Apache
   Software Foundation, please see <http://www.apache.org/>.
  
  */
  package org.apache.cocoon.components.xpointer;
  
  import org.xml.sax.SAXException;
  
  import java.util.List;
  import java.util.LinkedList;
  import java.util.Iterator;
  
  /**
   * Represents a fragment identifier conforming to the XML Pointer Language Framework.
   * See also the specification at <a href="http://www.w3.org/TR/2003/REC-xptr-framework-20030325">
   * http://www.w3.org/TR/2003/REC-xptr-framework-20030325</a>.
   *
   * <p>To create an instance of this class, call
   * {@link org.apache.cocoon.components.xpointer.parser.XPointerFrameworkParser#parse XPointerFrameworkParser.parse}.
   */
  public class XPointer {
      private List pointerParts = new LinkedList();
  
      public void addPart(PointerPart part) {
          pointerParts.add(part);
      }
  
      public void process(XPointerContext context) throws SAXException {
          Iterator pointerPartsIt = pointerParts.iterator();
          while (pointerPartsIt.hasNext()) {
              PointerPart part = (PointerPart)pointerPartsIt.next();
              part.process(context);
          }
      }
  }
  
  
  
  1.1                  cocoon-2.1/src/java/org/apache/cocoon/components/xpointer/XPointerContext.java
  
  Index: XPointerContext.java
  ===================================================================
  /*
  
   ============================================================================
                     The Apache Software License, Version 1.1
   ============================================================================
  
   Copyright (C) 1999-2003 The Apache Software Foundation. All rights reserved.
  
   Redistribution and use in source and binary forms, with or without modifica-
   tion, are permitted provided that the following conditions are met:
  
   1. Redistributions of  source code must  retain the above copyright  notice,
      this list of conditions and the following disclaimer.
  
   2. Redistributions in binary form must reproduce the above copyright notice,
      this list of conditions and the following disclaimer in the documentation
      and/or other materials provided with the distribution.
  
   3. The end-user documentation included with the redistribution, if any, must
      include  the following  acknowledgment:  "This product includes  software
      developed  by the  Apache Software Foundation  (http://www.apache.org/)."
      Alternately, this  acknowledgment may  appear in the software itself,  if
      and wherever such third-party acknowledgments normally appear.
  
   4. The names "Apache Cocoon" and  "Apache Software Foundation" must  not  be
      used to  endorse or promote  products derived from  this software without
      prior written permission. For written permission, please contact
      apache@apache.org.
  
   5. Products  derived from this software may not  be called "Apache", nor may
      "Apache" appear  in their name,  without prior written permission  of the
      Apache Software Foundation.
  
   THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
   FITNESS  FOR A PARTICULAR  PURPOSE ARE  DISCLAIMED.  IN NO  EVENT SHALL  THE
   APACHE SOFTWARE  FOUNDATION  OR ITS CONTRIBUTORS  BE LIABLE FOR  ANY DIRECT,
   INDIRECT, INCIDENTAL, SPECIAL,  EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLU-
   DING, BUT NOT LIMITED TO, PROCUREMENT  OF SUBSTITUTE GOODS OR SERVICES; LOSS
   OF USE, DATA, OR  PROFITS; OR BUSINESS  INTERRUPTION)  HOWEVER CAUSED AND ON
   ANY  THEORY OF LIABILITY,  WHETHER  IN CONTRACT,  STRICT LIABILITY,  OR TORT
   (INCLUDING  NEGLIGENCE OR  OTHERWISE) ARISING IN  ANY WAY OUT OF THE  USE OF
   THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  
   This software  consists of voluntary contributions made  by many individuals
   on  behalf of the Apache Software  Foundation and was  originally created by
   Stefano Mazzocchi  <stefano@apache.org>. For more  information on the Apache
   Software Foundation, please see <http://www.apache.org/>.
  
  */
  package org.apache.cocoon.components.xpointer;
  
  import org.w3c.dom.Document;
  import org.apache.excalibur.source.Source;
  import org.apache.excalibur.xml.xpath.PrefixResolver;
  import org.apache.avalon.framework.logger.Logger;
  import org.apache.avalon.framework.component.ComponentManager;
  import org.apache.cocoon.components.source.SourceUtil;
  import org.apache.cocoon.xml.XMLConsumer;
  import org.xml.sax.SAXException;
  
  import java.util.HashMap;
  
  /**
   * A context object used during the evaluating of XPointers.
   */
  public class XPointerContext implements PrefixResolver {
      private Source source;
      private Document document;
      private XMLConsumer xmlConsumer;
      private Logger logger;
      private String xpointer;
      private HashMap prefixes = new HashMap();
      private ComponentManager componentManager;
  
      /**
       * Constructs an XPointerContext object.
       *
       * @param xpointer the original fragment identifier string, used for debugging purposes
       * @param source the source into which the xpointer points
       * @param xmlConsumer the consumer to which the result of the xpointer evaluation should be send
       */
      public XPointerContext(String xpointer, Source source, XMLConsumer xmlConsumer, Logger logger, ComponentManager componentManager) {
          this.source = source;
          this.xmlConsumer = xmlConsumer;
          this.logger = logger;
          this.componentManager = componentManager;
          this.xpointer = xpointer;
  
          prefixes.put("xml", "http://www.w3.org/XML/1998/namespace");
      }
  
      public Document getDocument() throws SAXException {
          if (document == null) {
              try {
                  document = SourceUtil.toDOM(source);
              } catch (Exception e) {
                  throw new SAXException("Error during XPointer evaluation while trying to load " + source.getURI(), e);
              }
          }
          return document;
      }
  
      public Source getSource() {
          return source;
      }
  
      public XMLConsumer getXmlConsumer() {
          return xmlConsumer;
      }
  
      public Logger getLogger() {
          return logger;
      }
  
      public String getXPointer() {
          return xpointer;
      }
  
      public ComponentManager getComponentManager() {
          return componentManager;
      }
  
      public void addPrefix(String prefix, String namespace) throws SAXException {
          // according to the xmlns() scheme spec, these should not result to any change in namespace context
          if (prefix.equalsIgnoreCase("xml"))
              return;
          else if (prefix.equals("xmlns"))
              return;
          else if (namespace.equals("http://www.w3.org/XML/1998/namespace"))
              return;
          else if (namespace.equals("http://www.w3.org/2000/xmlns/"))
              return;
  
          prefixes.put(prefix, namespace);
      }
  
      public String prefixToNamespace(String prefix) {
          return (String)prefixes.get(prefix);
      }
  }
  
  
  
  1.1                  cocoon-2.1/src/java/org/apache/cocoon/components/xpointer/XPointerPart.java
  
  Index: XPointerPart.java
  ===================================================================
  /*
  
   ============================================================================
                     The Apache Software License, Version 1.1
   ============================================================================
  
   Copyright (C) 1999-2003 The Apache Software Foundation. All rights reserved.
  
   Redistribution and use in source and binary forms, with or without modifica-
   tion, are permitted provided that the following conditions are met:
  
   1. Redistributions of  source code must  retain the above copyright  notice,
      this list of conditions and the following disclaimer.
  
   2. Redistributions in binary form must reproduce the above copyright notice,
      this list of conditions and the following disclaimer in the documentation
      and/or other materials provided with the distribution.
  
   3. The end-user documentation included with the redistribution, if any, must
      include  the following  acknowledgment:  "This product includes  software
      developed  by the  Apache Software Foundation  (http://www.apache.org/)."
      Alternately, this  acknowledgment may  appear in the software itself,  if
      and wherever such third-party acknowledgments normally appear.
  
   4. The names "Apache Cocoon" and  "Apache Software Foundation" must  not  be
      used to  endorse or promote  products derived from  this software without
      prior written permission. For written permission, please contact
      apache@apache.org.
  
   5. Products  derived from this software may not  be called "Apache", nor may
      "Apache" appear  in their name,  without prior written permission  of the
      Apache Software Foundation.
  
   THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
   FITNESS  FOR A PARTICULAR  PURPOSE ARE  DISCLAIMED.  IN NO  EVENT SHALL  THE
   APACHE SOFTWARE  FOUNDATION  OR ITS CONTRIBUTORS  BE LIABLE FOR  ANY DIRECT,
   INDIRECT, INCIDENTAL, SPECIAL,  EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLU-
   DING, BUT NOT LIMITED TO, PROCUREMENT  OF SUBSTITUTE GOODS OR SERVICES; LOSS
   OF USE, DATA, OR  PROFITS; OR BUSINESS  INTERRUPTION)  HOWEVER CAUSED AND ON
   ANY  THEORY OF LIABILITY,  WHETHER  IN CONTRACT,  STRICT LIABILITY,  OR TORT
   (INCLUDING  NEGLIGENCE OR  OTHERWISE) ARISING IN  ANY WAY OUT OF THE  USE OF
   THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  
   This software  consists of voluntary contributions made  by many individuals
   on  behalf of the Apache Software  Foundation and was  originally created by
   Stefano Mazzocchi  <stefano@apache.org>. For more  information on the Apache
   Software Foundation, please see <http://www.apache.org/>.
  
  */
  package org.apache.cocoon.components.xpointer;
  
  import org.xml.sax.SAXException;
  import org.xml.sax.Locator;
  import org.xml.sax.helpers.LocatorImpl;
  import org.w3c.dom.Document;
  import org.w3c.dom.NodeList;
  import org.apache.avalon.framework.component.ComponentManager;
  import org.apache.avalon.framework.component.Component;
  import org.apache.excalibur.xml.xpath.XPathProcessor;
  import org.apache.cocoon.xml.dom.DOMStreamer;
  import org.apache.cocoon.xml.XMLConsumer;
  
  /**
   * Partly implementation of the xpointer() scheme. Only the XPath subset of xpointer is supported.
   */
  public class XPointerPart implements PointerPart {
      private String expression;
  
      public XPointerPart(String expression) {
          this.expression = expression;
      }
  
      public boolean process(XPointerContext xpointerContext) throws SAXException {
          Document document = xpointerContext.getDocument();
          ComponentManager manager = xpointerContext.getComponentManager();
          XPathProcessor xpathProcessor = null;
          try {
              try {
                  xpathProcessor = (XPathProcessor)manager.lookup(XPathProcessor.ROLE);
              } catch (Exception e) {
                  throw new SAXException("XPointerPart: error looking up XPathProcessor.", e);
              }
              NodeList nodeList = xpathProcessor.selectNodeList(document, expression, xpointerContext);
              if (nodeList.getLength() > 0) {
                  XMLConsumer consumer = xpointerContext.getXmlConsumer();
                  LocatorImpl locator = new LocatorImpl();
                  locator.setSystemId(xpointerContext.getSource().getURI());
                  consumer.setDocumentLocator(locator);
                  for (int i = 0; i < nodeList.getLength(); i++) {
                      DOMStreamer streamer = new DOMStreamer();
                      streamer.setConsumer(consumer);
                      streamer.stream(nodeList.item(i));
                  }
                  return true;
              } else {
                  if (xpointerContext.getLogger().isDebugEnabled())
                      xpointerContext.getLogger().debug("XPointer: expression \"" + expression + "\" gave no results.");
                  return false;
              }
          } finally {
              if (xpathProcessor != null)
                  manager.release((Component)xpathProcessor);
          }
      }
  }
  
  
  
  1.1                  cocoon-2.1/src/java/org/apache/cocoon/components/xpointer/XmlnsPart.java
  
  Index: XmlnsPart.java
  ===================================================================
  /*
  
   ============================================================================
                     The Apache Software License, Version 1.1
   ============================================================================
  
   Copyright (C) 1999-2003 The Apache Software Foundation. All rights reserved.
  
   Redistribution and use in source and binary forms, with or without modifica-
   tion, are permitted provided that the following conditions are met:
  
   1. Redistributions of  source code must  retain the above copyright  notice,
      this list of conditions and the following disclaimer.
  
   2. Redistributions in binary form must reproduce the above copyright notice,
      this list of conditions and the following disclaimer in the documentation
      and/or other materials provided with the distribution.
  
   3. The end-user documentation included with the redistribution, if any, must
      include  the following  acknowledgment:  "This product includes  software
      developed  by the  Apache Software Foundation  (http://www.apache.org/)."
      Alternately, this  acknowledgment may  appear in the software itself,  if
      and wherever such third-party acknowledgments normally appear.
  
   4. The names "Apache Cocoon" and  "Apache Software Foundation" must  not  be
      used to  endorse or promote  products derived from  this software without
      prior written permission. For written permission, please contact
      apache@apache.org.
  
   5. Products  derived from this software may not  be called "Apache", nor may
      "Apache" appear  in their name,  without prior written permission  of the
      Apache Software Foundation.
  
   THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
   FITNESS  FOR A PARTICULAR  PURPOSE ARE  DISCLAIMED.  IN NO  EVENT SHALL  THE
   APACHE SOFTWARE  FOUNDATION  OR ITS CONTRIBUTORS  BE LIABLE FOR  ANY DIRECT,
   INDIRECT, INCIDENTAL, SPECIAL,  EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLU-
   DING, BUT NOT LIMITED TO, PROCUREMENT  OF SUBSTITUTE GOODS OR SERVICES; LOSS
   OF USE, DATA, OR  PROFITS; OR BUSINESS  INTERRUPTION)  HOWEVER CAUSED AND ON
   ANY  THEORY OF LIABILITY,  WHETHER  IN CONTRACT,  STRICT LIABILITY,  OR TORT
   (INCLUDING  NEGLIGENCE OR  OTHERWISE) ARISING IN  ANY WAY OUT OF THE  USE OF
   THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  
   This software  consists of voluntary contributions made  by many individuals
   on  behalf of the Apache Software  Foundation and was  originally created by
   Stefano Mazzocchi  <stefano@apache.org>. For more  information on the Apache
   Software Foundation, please see <http://www.apache.org/>.
  
  */
  package org.apache.cocoon.components.xpointer;
  
  import org.xml.sax.SAXException;
  
  /**
   * Implements support for the XPointer xmlns() Scheme.
   * See also <a href="http://www.w3.org/TR/xptr-xmlns/">http://www.w3.org/TR/xptr-xmlns/</a>.
   */
  public class XmlnsPart implements PointerPart {
      private String prefix;
      private String namespace;
  
      /**
       * Creates an XmlnsPart.
       */
      public XmlnsPart(String prefix, String namespace) {
          this.prefix = prefix;
          this.namespace = namespace;
      }
  
      public boolean process(XPointerContext xpointerContext) throws SAXException {
          xpointerContext.addPrefix(prefix, namespace);
          return false;
      }
  }
  
  
  
  1.1                  cocoon-2.1/src/java/org/apache/cocoon/components/xpointer/parser/ParseException.java
  
  Index: ParseException.java
  ===================================================================
  /* Generated By:JavaCC: Do not edit this line. ParseException.java Version 3.0 */
  package org.apache.cocoon.components.xpointer.parser;
  
  /**
   * This exception is thrown when parse errors are encountered.
   * You can explicitly create objects of this exception type by
   * calling the method generateParseException in the generated
   * parser.
   *
   * You can modify this class to customize your error reporting
   * mechanisms so long as you retain the public fields.
   */
  public class ParseException extends Exception {
  
    /**
     * This constructor is used by the method "generateParseException"
     * in the generated parser.  Calling this constructor generates
     * a new object of this type with the fields "currentToken",
     * "expectedTokenSequences", and "tokenImage" set.  The boolean
     * flag "specialConstructor" is also set to true to indicate that
     * this constructor was used to create this object.
     * This constructor calls its super class with the empty string
     * to force the "toString" method of parent class "Throwable" to
     * print the error message in the form:
     *     ParseException: <result of getMessage>
     */
    public ParseException(Token currentTokenVal,
                          int[][] expectedTokenSequencesVal,
                          String[] tokenImageVal
                         )
    {
      super("");
      specialConstructor = true;
      currentToken = currentTokenVal;
      expectedTokenSequences = expectedTokenSequencesVal;
      tokenImage = tokenImageVal;
    }
  
    /**
     * The following constructors are for use by you for whatever
     * purpose you can think of.  Constructing the exception in this
     * manner makes the exception behave in the normal way - i.e., as
     * documented in the class "Throwable".  The fields "errorToken",
     * "expectedTokenSequences", and "tokenImage" do not contain
     * relevant information.  The JavaCC generated code does not use
     * these constructors.
     */
  
    public ParseException() {
      super();
      specialConstructor = false;
    }
  
    public ParseException(String message) {
      super(message);
      specialConstructor = false;
    }
  
    /**
     * This variable determines which constructor was used to create
     * this object and thereby affects the semantics of the
     * "getMessage" method (see below).
     */
    protected boolean specialConstructor;
  
    /**
     * This is the last token that has been consumed successfully.  If
     * this object has been created due to a parse error, the token
     * followng this token will (therefore) be the first error token.
     */
    public Token currentToken;
  
    /**
     * Each entry in this array is an array of integers.  Each array
     * of integers represents a sequence of tokens (by their ordinal
     * values) that is expected at this point of the parse.
     */
    public int[][] expectedTokenSequences;
  
    /**
     * This is a reference to the "tokenImage" array of the generated
     * parser within which the parse error occurred.  This array is
     * defined in the generated ...Constants interface.
     */
    public String[] tokenImage;
  
    /**
     * This method has the standard behavior when this object has been
     * created using the standard constructors.  Otherwise, it uses
     * "currentToken" and "expectedTokenSequences" to generate a parse
     * error message and returns it.  If this object has been created
     * due to a parse error, and you do not catch it (it gets thrown
     * from the parser), then this method is called during the printing
     * of the final stack trace, and hence the correct error message
     * gets displayed.
     */
    public String getMessage() {
      if (!specialConstructor) {
        return super.getMessage();
      }
      String expected = "";
      int maxSize = 0;
      for (int i = 0; i < expectedTokenSequences.length; i++) {
        if (maxSize < expectedTokenSequences[i].length) {
          maxSize = expectedTokenSequences[i].length;
        }
        for (int j = 0; j < expectedTokenSequences[i].length; j++) {
          expected += tokenImage[expectedTokenSequences[i][j]] + " ";
        }
        if (expectedTokenSequences[i][expectedTokenSequences[i].length - 1] != 0) {
          expected += "...";
        }
        expected += eol + "    ";
      }
      String retval = "Encountered \"";
      Token tok = currentToken.next;
      for (int i = 0; i < maxSize; i++) {
        if (i != 0) retval += " ";
        if (tok.kind == 0) {
          retval += tokenImage[0];
          break;
        }
        retval += add_escapes(tok.image);
        tok = tok.next; 
      }
      retval += "\" at line " + currentToken.next.beginLine + ", column " + currentToken.next.beginColumn;
      retval += "." + eol;
      if (expectedTokenSequences.length == 1) {
        retval += "Was expecting:" + eol + "    ";
      } else {
        retval += "Was expecting one of:" + eol + "    ";
      }
      retval += expected;
      return retval;
    }
  
    /**
     * The end of line string for this machine.
     */
    protected String eol = System.getProperty("line.separator", "\n");
   
    /**
     * Used to convert raw characters to their escaped version
     * when these raw version cannot be used as part of an ASCII
     * string literal.
     */
    protected String add_escapes(String str) {
        StringBuffer retval = new StringBuffer();
        char ch;
        for (int i = 0; i < str.length(); i++) {
          switch (str.charAt(i))
          {
             case 0 :
                continue;
             case '\b':
                retval.append("\\b");
                continue;
             case '\t':
                retval.append("\\t");
                continue;
             case '\n':
                retval.append("\\n");
                continue;
             case '\f':
                retval.append("\\f");
                continue;
             case '\r':
                retval.append("\\r");
                continue;
             case '\"':
                retval.append("\\\"");
                continue;
             case '\'':
                retval.append("\\\'");
                continue;
             case '\\':
                retval.append("\\\\");
                continue;
             default:
                if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) {
                   String s = "0000" + Integer.toString(ch, 16);
                   retval.append("\\u" + s.substring(s.length() - 4, s.length()));
                } else {
                   retval.append(ch);
                }
                continue;
          }
        }
        return retval.toString();
     }
  
  }
  
  
  
  1.1                  cocoon-2.1/src/java/org/apache/cocoon/components/xpointer/parser/SimpleCharStream.java
  
  Index: SimpleCharStream.java
  ===================================================================
  /* Generated By:JavaCC: Do not edit this line. SimpleCharStream.java Version 3.0 */
  package org.apache.cocoon.components.xpointer.parser;
  
  /**
   * An implementation of interface CharStream, where the stream is assumed to
   * contain only ASCII characters (without unicode processing).
   */
  
  public class SimpleCharStream
  {
    public static final boolean staticFlag = false;
    int bufsize;
    int available;
    int tokenBegin;
    public int bufpos = -1;
    protected int bufline[];
    protected int bufcolumn[];
  
    protected int column = 0;
    protected int line = 1;
  
    protected boolean prevCharIsCR = false;
    protected boolean prevCharIsLF = false;
  
    protected java.io.Reader inputStream;
  
    protected char[] buffer;
    protected int maxNextCharInd = 0;
    protected int inBuf = 0;
  
    protected void ExpandBuff(boolean wrapAround)
    {
       char[] newbuffer = new char[bufsize + 2048];
       int newbufline[] = new int[bufsize + 2048];
       int newbufcolumn[] = new int[bufsize + 2048];
  
       try
       {
          if (wrapAround)
          {
             System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
             System.arraycopy(buffer, 0, newbuffer,
                                               bufsize - tokenBegin, bufpos);
             buffer = newbuffer;
  
             System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
             System.arraycopy(bufline, 0, newbufline, bufsize - tokenBegin, bufpos);
             bufline = newbufline;
  
             System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
             System.arraycopy(bufcolumn, 0, newbufcolumn, bufsize - tokenBegin, bufpos);
             bufcolumn = newbufcolumn;
  
             maxNextCharInd = (bufpos += (bufsize - tokenBegin));
          }
          else
          {
             System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
             buffer = newbuffer;
  
             System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
             bufline = newbufline;
  
             System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
             bufcolumn = newbufcolumn;
  
             maxNextCharInd = (bufpos -= tokenBegin);
          }
       }
       catch (Throwable t)
       {
          throw new Error(t.getMessage());
       }
  
  
       bufsize += 2048;
       available = bufsize;
       tokenBegin = 0;
    }
  
    protected void FillBuff() throws java.io.IOException
    {
       if (maxNextCharInd == available)
       {
          if (available == bufsize)
          {
             if (tokenBegin > 2048)
             {
                bufpos = maxNextCharInd = 0;
                available = tokenBegin;
             }
             else if (tokenBegin < 0)
                bufpos = maxNextCharInd = 0;
             else
                ExpandBuff(false);
          }
          else if (available > tokenBegin)
             available = bufsize;
          else if ((tokenBegin - available) < 2048)
             ExpandBuff(true);
          else
             available = tokenBegin;
       }
  
       int i;
       try {
          if ((i = inputStream.read(buffer, maxNextCharInd,
                                      available - maxNextCharInd)) == -1)
          {
             inputStream.close();
             throw new java.io.IOException();
          }
          else
             maxNextCharInd += i;
          return;
       }
       catch(java.io.IOException e) {
          --bufpos;
          backup(0);
          if (tokenBegin == -1)
             tokenBegin = bufpos;
          throw e;
       }
    }
  
    public char BeginToken() throws java.io.IOException
    {
       tokenBegin = -1;
       char c = readChar();
       tokenBegin = bufpos;
  
       return c;
    }
  
    protected void UpdateLineColumn(char c)
    {
       column++;
  
       if (prevCharIsLF)
       {
          prevCharIsLF = false;
          line += (column = 1);
       }
       else if (prevCharIsCR)
       {
          prevCharIsCR = false;
          if (c == '\n')
          {
             prevCharIsLF = true;
          }
          else
             line += (column = 1);
       }
  
       switch (c)
       {
          case '\r' :
             prevCharIsCR = true;
             break;
          case '\n' :
             prevCharIsLF = true;
             break;
          case '\t' :
             column--;
             column += (8 - (column & 07));
             break;
          default :
             break;
       }
  
       bufline[bufpos] = line;
       bufcolumn[bufpos] = column;
    }
  
    public char readChar() throws java.io.IOException
    {
       if (inBuf > 0)
       {
          --inBuf;
  
          if (++bufpos == bufsize)
             bufpos = 0;
  
          return buffer[bufpos];
       }
  
       if (++bufpos >= maxNextCharInd)
          FillBuff();
  
       char c = buffer[bufpos];
  
       UpdateLineColumn(c);
       return (c);
    }
  
    /**
     * @deprecated 
     * @see #getEndColumn
     */
  
    public int getColumn() {
       return bufcolumn[bufpos];
    }
  
    /**
     * @deprecated 
     * @see #getEndLine
     */
  
    public int getLine() {
       return bufline[bufpos];
    }
  
    public int getEndColumn() {
       return bufcolumn[bufpos];
    }
  
    public int getEndLine() {
       return bufline[bufpos];
    }
  
    public int getBeginColumn() {
       return bufcolumn[tokenBegin];
    }
  
    public int getBeginLine() {
       return bufline[tokenBegin];
    }
  
    public void backup(int amount) {
  
      inBuf += amount;
      if ((bufpos -= amount) < 0)
         bufpos += bufsize;
    }
  
    public SimpleCharStream(java.io.Reader dstream, int startline,
    int startcolumn, int buffersize)
    {
      inputStream = dstream;
      line = startline;
      column = startcolumn - 1;
  
      available = bufsize = buffersize;
      buffer = new char[buffersize];
      bufline = new int[buffersize];
      bufcolumn = new int[buffersize];
    }
  
    public SimpleCharStream(java.io.Reader dstream, int startline,
                                                             int startcolumn)
    {
       this(dstream, startline, startcolumn, 4096);
    }
  
    public SimpleCharStream(java.io.Reader dstream)
    {
       this(dstream, 1, 1, 4096);
    }
    public void ReInit(java.io.Reader dstream, int startline,
    int startcolumn, int buffersize)
    {
      inputStream = dstream;
      line = startline;
      column = startcolumn - 1;
  
      if (buffer == null || buffersize != buffer.length)
      {
        available = bufsize = buffersize;
        buffer = new char[buffersize];
        bufline = new int[buffersize];
        bufcolumn = new int[buffersize];
      }
      prevCharIsLF = prevCharIsCR = false;
      tokenBegin = inBuf = maxNextCharInd = 0;
      bufpos = -1;
    }
  
    public void ReInit(java.io.Reader dstream, int startline,
                                                             int startcolumn)
    {
       ReInit(dstream, startline, startcolumn, 4096);
    }
  
    public void ReInit(java.io.Reader dstream)
    {
       ReInit(dstream, 1, 1, 4096);
    }
    public SimpleCharStream(java.io.InputStream dstream, int startline,
    int startcolumn, int buffersize)
    {
       this(new java.io.InputStreamReader(dstream), startline, startcolumn, 4096);
    }
  
    public SimpleCharStream(java.io.InputStream dstream, int startline,
                                                             int startcolumn)
    {
       this(dstream, startline, startcolumn, 4096);
    }
  
    public SimpleCharStream(java.io.InputStream dstream)
    {
       this(dstream, 1, 1, 4096);
    }
  
    public void ReInit(java.io.InputStream dstream, int startline,
                            int startcolumn, int buffersize)
    {
       ReInit(new java.io.InputStreamReader(dstream), startline, startcolumn, 4096);
    }
  
    public void ReInit(java.io.InputStream dstream)
    {
       ReInit(dstream, 1, 1, 4096);
    }
    public void ReInit(java.io.InputStream dstream, int startline,
                                                             int startcolumn)
    {
       ReInit(dstream, startline, startcolumn, 4096);
    }
    public String GetImage()
    {
       if (bufpos >= tokenBegin)
          return new String(buffer, tokenBegin, bufpos - tokenBegin + 1);
       else
          return new String(buffer, tokenBegin, bufsize - tokenBegin) +
                                new String(buffer, 0, bufpos + 1);
    }
  
    public char[] GetSuffix(int len)
    {
       char[] ret = new char[len];
  
       if ((bufpos + 1) >= len)
          System.arraycopy(buffer, bufpos - len + 1, ret, 0, len);
       else
       {
          System.arraycopy(buffer, bufsize - (len - bufpos - 1), ret, 0,
                                                            len - bufpos - 1);
          System.arraycopy(buffer, 0, ret, len - bufpos - 1, bufpos + 1);
       }
  
       return ret;
    }
  
    public void Done()
    {
       buffer = null;
       bufline = null;
       bufcolumn = null;
    }
  
    /**
     * Method to adjust line and column numbers for the start of a token.<BR>
     */
    public void adjustBeginLineColumn(int newLine, int newCol)
    {
       int start = tokenBegin;
       int len;
  
       if (bufpos >= tokenBegin)
       {
          len = bufpos - tokenBegin + inBuf + 1;
       }
       else
       {
          len = bufsize - tokenBegin + bufpos + 1 + inBuf;
       }
  
       int i = 0, j = 0, k = 0;
       int nextColDiff = 0, columnDiff = 0;
  
       while (i < len &&
              bufline[j = start % bufsize] == bufline[k = ++start % bufsize])
       {
          bufline[j] = newLine;
          nextColDiff = columnDiff + bufcolumn[k] - bufcolumn[j];
          bufcolumn[j] = newCol + columnDiff;
          columnDiff = nextColDiff;
          i++;
       } 
  
       if (i < len)
       {
          bufline[j] = newLine++;
          bufcolumn[j] = newCol + columnDiff;
  
          while (i++ < len)
          {
             if (bufline[j = start % bufsize] != bufline[++start % bufsize])
                bufline[j] = newLine++;
             else
                bufline[j] = newLine;
          }
       }
  
       line = bufline[j];
       column = bufcolumn[j];
    }
  
  }
  
  
  
  1.1                  cocoon-2.1/src/java/org/apache/cocoon/components/xpointer/parser/Token.java
  
  Index: Token.java
  ===================================================================
  /* Generated By:JavaCC: Do not edit this line. Token.java Version 3.0 */
  package org.apache.cocoon.components.xpointer.parser;
  
  /**
   * Describes the input token stream.
   */
  
  public class Token {
  
    /**
     * An integer that describes the kind of this token.  This numbering
     * system is determined by JavaCCParser, and a table of these numbers is
     * stored in the file ...Constants.java.
     */
    public int kind;
  
    /**
     * beginLine and beginColumn describe the position of the first character
     * of this token; endLine and endColumn describe the position of the
     * last character of this token.
     */
    public int beginLine, beginColumn, endLine, endColumn;
  
    /**
     * The string image of the token.
     */
    public String image;
  
    /**
     * A reference to the next regular (non-special) token from the input
     * stream.  If this is the last token from the input stream, or if the
     * token manager has not read tokens beyond this one, this field is
     * set to null.  This is true only if this token is also a regular
     * token.  Otherwise, see below for a description of the contents of
     * this field.
     */
    public Token next;
  
    /**
     * This field is used to access special tokens that occur prior to this
     * token, but after the immediately preceding regular (non-special) token.
     * If there are no such special tokens, this field is set to null.
     * When there are more than one such special token, this field refers
     * to the last of these special tokens, which in turn refers to the next
     * previous special token through its specialToken field, and so on
     * until the first special token (whose specialToken field is null).
     * The next fields of special tokens refer to other special tokens that
     * immediately follow it (without an intervening regular token).  If there
     * is no such token, this field is null.
     */
    public Token specialToken;
  
    /**
     * Returns the image.
     */
    public String toString()
    {
       return image;
    }
  
    /**
     * Returns a new Token object, by default. However, if you want, you
     * can create and return subclass objects based on the value of ofKind.
     * Simply add the cases to the switch for all those special cases.
     * For example, if you have a subclass of Token called IDToken that
     * you want to create if ofKind is ID, simlpy add something like :
     *
     *    case MyParserConstants.ID : return new IDToken();
     *
     * to the following switch statement. Then you can cast matchedToken
     * variable to the appropriate type and use it in your lexical actions.
     */
    public static final Token newToken(int ofKind)
    {
       switch(ofKind)
       {
         default : return new Token();
       }
    }
  
  }
  
  
  
  1.1                  cocoon-2.1/src/java/org/apache/cocoon/components/xpointer/parser/TokenMgrError.java
  
  Index: TokenMgrError.java
  ===================================================================
  /* Generated By:JavaCC: Do not edit this line. TokenMgrError.java Version 3.0 */
  package org.apache.cocoon.components.xpointer.parser;
  
  public class TokenMgrError extends Error
  {
     /*
      * Ordinals for various reasons why an Error of this type can be thrown.
      */
  
     /**
      * Lexical error occured.
      */
     static final int LEXICAL_ERROR = 0;
  
     /**
      * An attempt wass made to create a second instance of a static token manager.
      */
     static final int STATIC_LEXER_ERROR = 1;
  
     /**
      * Tried to change to an invalid lexical state.
      */
     static final int INVALID_LEXICAL_STATE = 2;
  
     /**
      * Detected (and bailed out of) an infinite loop in the token manager.
      */
     static final int LOOP_DETECTED = 3;
  
     /**
      * Indicates the reason why the exception is thrown. It will have
      * one of the above 4 values.
      */
     int errorCode;
  
     /**
      * Replaces unprintable characters by their espaced (or unicode escaped)
      * equivalents in the given string
      */
     protected static final String addEscapes(String str) {
        StringBuffer retval = new StringBuffer();
        char ch;
        for (int i = 0; i < str.length(); i++) {
          switch (str.charAt(i))
          {
             case 0 :
                continue;
             case '\b':
                retval.append("\\b");
                continue;
             case '\t':
                retval.append("\\t");
                continue;
             case '\n':
                retval.append("\\n");
                continue;
             case '\f':
                retval.append("\\f");
                continue;
             case '\r':
                retval.append("\\r");
                continue;
             case '\"':
                retval.append("\\\"");
                continue;
             case '\'':
                retval.append("\\\'");
                continue;
             case '\\':
                retval.append("\\\\");
                continue;
             default:
                if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) {
                   String s = "0000" + Integer.toString(ch, 16);
                   retval.append("\\u" + s.substring(s.length() - 4, s.length()));
                } else {
                   retval.append(ch);
                }
                continue;
          }
        }
        return retval.toString();
     }
  
     /**
      * Returns a detailed message for the Error when it is thrown by the
      * token manager to indicate a lexical error.
      * Parameters : 
      *    EOFSeen     : indicates if EOF caused the lexicl error
      *    curLexState : lexical state in which this error occured
      *    errorLine   : line number when the error occured
      *    errorColumn : column number when the error occured
      *    errorAfter  : prefix that was seen before this error occured
      *    curchar     : the offending character
      * Note: You can customize the lexical error message by modifying this method.
      */
     protected static String LexicalError(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, char curChar) {
        return("Lexical error at line " +
             errorLine + ", column " +
             errorColumn + ".  Encountered: " +
             (EOFSeen ? "<EOF> " : ("\"" + addEscapes(String.valueOf(curChar)) + "\"") + " (" + (int)curChar + "), ") +
             "after : \"" + addEscapes(errorAfter) + "\"");
     }
  
     /**
      * You can also modify the body of this method to customize your error messages.
      * For example, cases like LOOP_DETECTED and INVALID_LEXICAL_STATE are not
      * of end-users concern, so you can return something like : 
      *
      *     "Internal Error : Please file a bug report .... "
      *
      * from this method for such cases in the release version of your parser.
      */
     public String getMessage() {
        return super.getMessage();
     }
  
     /*
      * Constructors of various flavors follow.
      */
  
     public TokenMgrError() {
     }
  
     public TokenMgrError(String message, int reason) {
        super(message);
        errorCode = reason;
     }
  
     public TokenMgrError(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, char curChar, int reason) {
        this(LexicalError(EOFSeen, lexState, errorLine, errorColumn, errorAfter, curChar), reason);
     }
  }
  
  
  
  1.1                  cocoon-2.1/src/java/org/apache/cocoon/components/xpointer/parser/XPointerFrameworkParser.java
  
  Index: XPointerFrameworkParser.java
  ===================================================================
  /* Generated By:JavaCC: Do not edit this line. XPointerFrameworkParser.java */
    package org.apache.cocoon.components.xpointer.parser;
  
    import org.apache.cocoon.components.xpointer.*;
  
    public class XPointerFrameworkParser implements XPointerFrameworkParserConstants {
      private XPointer xpointer = new XPointer();
  
      public static void main(String [] args) throws Exception {
        System.out.println("zal dit parsen: " + args[0]);
        XPointerFrameworkParser xfp = new XPointerFrameworkParser(new java.io.StringReader(args[0]));
        xfp.pointer();
      }
  
      public static XPointer parse(String xpointer) throws ParseException {
        XPointerFrameworkParser xfp = new XPointerFrameworkParser(new java.io.StringReader(xpointer));
        xfp.pointer();
        return xfp.getXPointer();
      }
  
      public XPointer getXPointer() {
        return xpointer;
      }
  
      private String unescape(String data) throws ParseException {
        StringBuffer result = new StringBuffer(data.length());
        boolean inCircumflex = false;
        for (int i = 0; i < data.length(); i++) {
          char c = data.charAt(i);
          if (inCircumflex) {
            switch (c) {
              case '^':
              case '(':
              case ')':
                result.append(c);
                inCircumflex = false;
                break;
              default:
                throw new ParseException("Incorrect use of circumflex character at position " + i + " in the string " + data);
            }
          } else if (c == '^') {
            inCircumflex = true;
          } else {
            result.append(c);
          }
        }
        return result.toString();
      }
  
    final public void pointer() throws ParseException {
      if (jj_2_1(2)) {
        schemeBased();
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case NCName:
          shortHand();
          break;
        default:
          jj_la1[0] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
    }
  
    final public void shortHand() throws ParseException {
    Token x;
      x = jj_consume_token(NCName);
      xpointer.addPart(new ShorthandPart(x.image));
    }
  
    final public void schemeBased() throws ParseException {
      pointerPart();
      label_1:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case NCName:
        case WS:
        case QName:
          ;
          break;
        default:
          jj_la1[1] = jj_gen;
          break label_1;
        }
        label_2:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case WS:
            ;
            break;
          default:
            jj_la1[2] = jj_gen;
            break label_2;
          }
          jj_consume_token(WS);
        }
        pointerPart();
      }
    }
  
    final public void pointerPart() throws ParseException {
    Token x;
    String schemeName;
    String schemeData;
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case NCName:
        x = jj_consume_token(NCName);
        break;
      case QName:
        x = jj_consume_token(QName);
        break;
      default:
        jj_la1[3] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      jj_consume_token(LBRACE);
        // when going inside the scheme data, swith to a different lexical state
        token_source.SwitchTo(IN_SCHEME);
  
        // store the scheme name
        schemeName = x.image;
      schemeData = schemeData();
      jj_consume_token(RBRACE);
        // when going outside the scheme data, swith back to the default lexical state
        token_source.SwitchTo(DEFAULT);
  
        // add the pointer part
        if (schemeName.equals("xmlns")) {
          int eqPos = schemeData.indexOf("=");
          if (eqPos == -1)
            {if (true) throw new ParseException("xmlns scheme data should contain an equals sign");}
  
          // Note: the trimming below is not entirely correct, since space is only allowed left
          // and right of the equal sign, but not at the beginning and end of the schemeData
          String prefix = schemeData.substring(0, eqPos).trim();
          String namespace = schemeData.substring(eqPos + 1, schemeData.length()).trim();
          xpointer.addPart(new XmlnsPart(prefix, namespace));
        } else if (schemeName.equals("xpointer")) {
          xpointer.addPart(new XPointerPart(schemeData));
        } else {
          xpointer.addPart(new UnsupportedPart(schemeName));
        }
    }
  
    final public String schemeData() throws ParseException {
    String temp;
    StringBuffer schemeData = new StringBuffer();
      label_3:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case LBRACE:
        case CIRC_LBRACE:
        case CIRC_RBRACE:
        case DOUBLE_CIRC:
        case NormalChar:
          ;
          break;
        default:
          jj_la1[4] = jj_gen;
          break label_3;
        }
        temp = escapedData();
                              schemeData.append(temp);
      }
      {if (true) return unescape(schemeData.toString());}
      throw new Error("Missing return statement in function");
    }
  
    final public String escapedData() throws ParseException {
    Token x;
    String temp;
    StringBuffer data = new StringBuffer();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case NormalChar:
        x = jj_consume_token(NormalChar);
                        data.append(x.image);
        break;
      case CIRC_LBRACE:
        x = jj_consume_token(CIRC_LBRACE);
                           data.append(x.image);
        break;
      case CIRC_RBRACE:
        x = jj_consume_token(CIRC_RBRACE);
                           data.append(x.image);
        break;
      case DOUBLE_CIRC:
        x = jj_consume_token(DOUBLE_CIRC);
                           data.append(x.image);
        break;
      case LBRACE:
        x = jj_consume_token(LBRACE);
                      data.append(x.image);
        temp = schemeData();
                             data.append(temp);
        x = jj_consume_token(RBRACE);
                      data.append(x.image);
        break;
      default:
        jj_la1[5] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      {if (true) return data.toString();}
      throw new Error("Missing return statement in function");
    }
  
    final private boolean jj_2_1(int xla) {
      jj_la = xla; jj_lastpos = jj_scanpos = token;
      boolean retval = !jj_3_1();
      jj_save(0, xla);
      return retval;
    }
  
    final private boolean jj_3R_7() {
      if (jj_scan_token(QName)) return true;
      if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
      return false;
    }
  
    final private boolean jj_3_1() {
      if (jj_3R_4()) return true;
      if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
      return false;
    }
  
    final private boolean jj_3R_6() {
      if (jj_scan_token(NCName)) return true;
      if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
      return false;
    }
  
    final private boolean jj_3R_4() {
      if (jj_3R_5()) return true;
      if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
      return false;
    }
  
    final private boolean jj_3R_5() {
      Token xsp;
      xsp = jj_scanpos;
      if (jj_3R_6()) {
      jj_scanpos = xsp;
      if (jj_3R_7()) return true;
      if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
      } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
      if (jj_scan_token(LBRACE)) return true;
      if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
      return false;
    }
  
    public XPointerFrameworkParserTokenManager token_source;
    SimpleCharStream jj_input_stream;
    public Token token, jj_nt;
    private int jj_ntk;
    private Token jj_scanpos, jj_lastpos;
    private int jj_la;
    public boolean lookingAhead = false;
    private boolean jj_semLA;
    private int jj_gen;
    final private int[] jj_la1 = new int[6];
    static private int[] jj_la1_0;
    static {
        jj_la1_0();
     }
     private static void jj_la1_0() {
        jj_la1_0 = new int[] {0x80,0x380,0x100,0x280,0xf400,0xf400,};
     }
    final private JJCalls[] jj_2_rtns = new JJCalls[1];
    private boolean jj_rescan = false;
    private int jj_gc = 0;
  
    public XPointerFrameworkParser(java.io.InputStream stream) {
      jj_input_stream = new SimpleCharStream(stream, 1, 1);
      token_source = new XPointerFrameworkParserTokenManager(jj_input_stream);
      token = new Token();
      jj_ntk = -1;
      jj_gen = 0;
      for (int i = 0; i < 6; i++) jj_la1[i] = -1;
      for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    }
  
    public void ReInit(java.io.InputStream stream) {
      jj_input_stream.ReInit(stream, 1, 1);
      token_source.ReInit(jj_input_stream);
      token = new Token();
      jj_ntk = -1;
      jj_gen = 0;
      for (int i = 0; i < 6; i++) jj_la1[i] = -1;
      for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    }
  
    public XPointerFrameworkParser(java.io.Reader stream) {
      jj_input_stream = new SimpleCharStream(stream, 1, 1);
      token_source = new XPointerFrameworkParserTokenManager(jj_input_stream);
      token = new Token();
      jj_ntk = -1;
      jj_gen = 0;
      for (int i = 0; i < 6; i++) jj_la1[i] = -1;
      for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    }
  
    public void ReInit(java.io.Reader stream) {
      jj_input_stream.ReInit(stream, 1, 1);
      token_source.ReInit(jj_input_stream);
      token = new Token();
      jj_ntk = -1;
      jj_gen = 0;
      for (int i = 0; i < 6; i++) jj_la1[i] = -1;
      for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    }
  
    public XPointerFrameworkParser(XPointerFrameworkParserTokenManager tm) {
      token_source = tm;
      token = new Token();
      jj_ntk = -1;
      jj_gen = 0;
      for (int i = 0; i < 6; i++) jj_la1[i] = -1;
      for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    }
  
    public void ReInit(XPointerFrameworkParserTokenManager tm) {
      token_source = tm;
      token = new Token();
      jj_ntk = -1;
      jj_gen = 0;
      for (int i = 0; i < 6; i++) jj_la1[i] = -1;
      for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    }
  
    final private Token jj_consume_token(int kind) throws ParseException {
      Token oldToken;
      if ((oldToken = token).next != null) token = token.next;
      else token = token.next = token_source.getNextToken();
      jj_ntk = -1;
      if (token.kind == kind) {
        jj_gen++;
        if (++jj_gc > 100) {
          jj_gc = 0;
          for (int i = 0; i < jj_2_rtns.length; i++) {
            JJCalls c = jj_2_rtns[i];
            while (c != null) {
              if (c.gen < jj_gen) c.first = null;
              c = c.next;
            }
          }
        }
        return token;
      }
      token = oldToken;
      jj_kind = kind;
      throw generateParseException();
    }
  
    final private boolean jj_scan_token(int kind) {
      if (jj_scanpos == jj_lastpos) {
        jj_la--;
        if (jj_scanpos.next == null) {
          jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
        } else {
          jj_lastpos = jj_scanpos = jj_scanpos.next;
        }
      } else {
        jj_scanpos = jj_scanpos.next;
      }
      if (jj_rescan) {
        int i = 0; Token tok = token;
        while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
        if (tok != null) jj_add_error_token(kind, i);
      }
      return (jj_scanpos.kind != kind);
    }
  
    final public Token getNextToken() {
      if (token.next != null) token = token.next;
      else token = token.next = token_source.getNextToken();
      jj_ntk = -1;
      jj_gen++;
      return token;
    }
  
    final public Token getToken(int index) {
      Token t = lookingAhead ? jj_scanpos : token;
      for (int i = 0; i < index; i++) {
        if (t.next != null) t = t.next;
        else t = t.next = token_source.getNextToken();
      }
      return t;
    }
  
    final private int jj_ntk() {
      if ((jj_nt=token.next) == null)
        return (jj_ntk = (token.next=token_source.getNextToken()).kind);
      else
        return (jj_ntk = jj_nt.kind);
    }
  
    private java.util.Vector jj_expentries = new java.util.Vector();
    private int[] jj_expentry;
    private int jj_kind = -1;
    private int[] jj_lasttokens = new int[100];
    private int jj_endpos;
  
    private void jj_add_error_token(int kind, int pos) {
      if (pos >= 100) return;
      if (pos == jj_endpos + 1) {
        jj_lasttokens[jj_endpos++] = kind;
      } else if (jj_endpos != 0) {
        jj_expentry = new int[jj_endpos];
        for (int i = 0; i < jj_endpos; i++) {
          jj_expentry[i] = jj_lasttokens[i];
        }
        boolean exists = false;
        for (java.util.Enumeration enum = jj_expentries.elements(); enum.hasMoreElements();) {
          int[] oldentry = (int[])(enum.nextElement());
          if (oldentry.length == jj_expentry.length) {
            exists = true;
            for (int i = 0; i < jj_expentry.length; i++) {
              if (oldentry[i] != jj_expentry[i]) {
                exists = false;
                break;
              }
            }
            if (exists) break;
          }
        }
        if (!exists) jj_expentries.addElement(jj_expentry);
        if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
      }
    }
  
    public ParseException generateParseException() {
      jj_expentries.removeAllElements();
      boolean[] la1tokens = new boolean[16];
      for (int i = 0; i < 16; i++) {
        la1tokens[i] = false;
      }
      if (jj_kind >= 0) {
        la1tokens[jj_kind] = true;
        jj_kind = -1;
      }
      for (int i = 0; i < 6; i++) {
        if (jj_la1[i] == jj_gen) {
          for (int j = 0; j < 32; j++) {
            if ((jj_la1_0[i] & (1<<j)) != 0) {
              la1tokens[j] = true;
            }
          }
        }
      }
      for (int i = 0; i < 16; i++) {
        if (la1tokens[i]) {
          jj_expentry = new int[1];
          jj_expentry[0] = i;
          jj_expentries.addElement(jj_expentry);
        }
      }
      jj_endpos = 0;
      jj_rescan_token();
      jj_add_error_token(0, 0);
      int[][] exptokseq = new int[jj_expentries.size()][];
      for (int i = 0; i < jj_expentries.size(); i++) {
        exptokseq[i] = (int[])jj_expentries.elementAt(i);
      }
      return new ParseException(token, exptokseq, tokenImage);
    }
  
    final public void enable_tracing() {
    }
  
    final public void disable_tracing() {
    }
  
    final private void jj_rescan_token() {
      jj_rescan = true;
      for (int i = 0; i < 1; i++) {
        JJCalls p = jj_2_rtns[i];
        do {
          if (p.gen > jj_gen) {
            jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
            switch (i) {
              case 0: jj_3_1(); break;
            }
          }
          p = p.next;
        } while (p != null);
      }
      jj_rescan = false;
    }
  
    final private void jj_save(int index, int xla) {
      JJCalls p = jj_2_rtns[index];
      while (p.gen > jj_gen) {
        if (p.next == null) { p = p.next = new JJCalls(); break; }
        p = p.next;
      }
      p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
    }
  
    static final class JJCalls {
      int gen;
      Token first;
      int arg;
      JJCalls next;
    }
  
    }
  
  
  
  1.1                  cocoon-2.1/src/java/org/apache/cocoon/components/xpointer/parser/XPointerFrameworkParserConstants.java
  
  Index: XPointerFrameworkParserConstants.java
  ===================================================================
  /* Generated By:JavaCC: Do not edit this line. XPointerFrameworkParserConstants.java */
  package org.apache.cocoon.components.xpointer.parser;
  
  public interface XPointerFrameworkParserConstants {
  
    int EOF = 0;
    int Letter = 1;
    int BaseChar = 2;
    int Ideographic = 3;
    int CombiningChar = 4;
    int UnicodeDigit = 5;
    int Extender = 6;
    int NCName = 7;
    int WS = 8;
    int QName = 9;
    int LBRACE = 10;
    int RBRACE = 11;
    int CIRC_LBRACE = 12;
    int CIRC_RBRACE = 13;
    int DOUBLE_CIRC = 14;
    int NormalChar = 15;
  
    int DEFAULT = 0;
    int IN_SCHEME = 1;
  
    String[] tokenImage = {
      "<EOF>",
      "<Letter>",
      "<BaseChar>",
      "<Ideographic>",
      "<CombiningChar>",
      "<UnicodeDigit>",
      "<Extender>",
      "<NCName>",
      "<WS>",
      "<QName>",
      "\"(\"",
      "\")\"",
      "\"^(\"",
      "\"^)\"",
      "\"^^\"",
      "<NormalChar>",
    };
  
  }
  
  
  
  1.1                  cocoon-2.1/src/java/org/apache/cocoon/components/xpointer/parser/XPointerFrameworkParserTokenManager.java
  
  Index: XPointerFrameworkParserTokenManager.java
  ===================================================================
  /* Generated By:JavaCC: Do not edit this line. XPointerFrameworkParserTokenManager.java */
  package org.apache.cocoon.components.xpointer.parser;
  import org.apache.cocoon.components.xpointer.*;
  
  public class XPointerFrameworkParserTokenManager implements XPointerFrameworkParserConstants
  {
    public  java.io.PrintStream debugStream = System.out;
    public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
  private final int jjStopStringLiteralDfa_0(int pos, long active0)
  {
     switch (pos)
     {
        default :
           return -1;
     }
  }
  private final int jjStartNfa_0(int pos, long active0)
  {
     return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
  }
  private final int jjStopAtPos(int pos, int kind)
  {
     jjmatchedKind = kind;
     jjmatchedPos = pos;
     return pos + 1;
  }
  private final int jjStartNfaWithStates_0(int pos, int kind, int state)
  {
     jjmatchedKind = kind;
     jjmatchedPos = pos;
     try { curChar = input_stream.readChar(); }
     catch(java.io.IOException e) { return pos + 1; }
     return jjMoveNfa_0(state, pos + 1);
  }
  private final int jjMoveStringLiteralDfa0_0()
  {
     switch(curChar)
     {
        case 40:
           return jjStopAtPos(0, 10);
        case 41:
           return jjStopAtPos(0, 11);
        default :
           return jjMoveNfa_0(0, 0);
     }
  }
  private final void jjCheckNAdd(int state)
  {
     if (jjrounds[state] != jjround)
     {
        jjstateSet[jjnewStateCnt++] = state;
        jjrounds[state] = jjround;
     }
  }
  private final void jjAddStates(int start, int end)
  {
     do {
        jjstateSet[jjnewStateCnt++] = jjnextStates[start];
     } while (start++ != end);
  }
  private final void jjCheckNAddTwoStates(int state1, int state2)
  {
     jjCheckNAdd(state1);
     jjCheckNAdd(state2);
  }
  private final void jjCheckNAddStates(int start, int end)
  {
     do {
        jjCheckNAdd(jjnextStates[start]);
     } while (start++ != end);
  }
  private final void jjCheckNAddStates(int start)
  {
     jjCheckNAdd(jjnextStates[start]);
     jjCheckNAdd(jjnextStates[start + 1]);
  }
  static final long[] jjbitVec0 = {
     0x0L, 0xffffffffffffc000L, 0xfffff0007fffffffL, 0x7fffffL
  };
  static final long[] jjbitVec2 = {
     0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
  };
  static final long[] jjbitVec3 = {
     0x7ff3ffffffffffffL, 0x7ffffffffffffdfeL, 0xffffffffffffffffL, 0xfc31ffffffffe00fL
  };
  static final long[] jjbitVec4 = {
     0xffffffL, 0xffffffffffff0000L, 0xf80001ffffffffffL, 0x3L
  };
  static final long[] jjbitVec5 = {
     0x0L, 0x0L, 0xfffffffbffffd740L, 0xffffd547f7fffL
  };
  static final long[] jjbitVec6 = {
     0xffffffffffffdffeL, 0xffffffffdffeffffL, 0xffffffffffff0003L, 0x33fcfffffff199fL
  };
  static final long[] jjbitVec7 = {
     0xfffe000000000000L, 0xfffffffe027fffffL, 0x7fL, 0x707ffffff0000L
  };
  static final long[] jjbitVec8 = {
     0x7fffffe00000000L, 0xfffe0000000007feL, 0x7cffffffffffffffL, 0x60002f7fffL
  };
  static final long[] jjbitVec9 = {
     0x23ffffffffffffe0L, 0x3ff000000L, 0x3c5fdfffff99fe0L, 0x30003b0000000L
  };
  static final long[] jjbitVec10 = {
     0x36dfdfffff987e0L, 0x1c00005e000000L, 0x23edfdfffffbafe0L, 0x100000000L
  };
  static final long[] jjbitVec11 = {
     0x23cdfdfffff99fe0L, 0x3b0000000L, 0x3bfc718d63dc7e0L, 0x0L
  };
  static final long[] jjbitVec12 = {
     0x3effdfffffddfe0L, 0x300000000L, 0x3effdfffffddfe0L, 0x340000000L
  };
  static final long[] jjbitVec13 = {
     0x3fffdfffffddfe0L, 0x300000000L, 0x0L, 0x0L
  };
  static final long[] jjbitVec14 = {
     0xd7ffffffffffeL, 0x3fL, 0x200d6caefef02596L, 0x1fL
  };
  static final long[] jjbitVec15 = {
     0x0L, 0x3fffffffeffL, 0x0L, 0x0L
  };
  static final long[] jjbitVec16 = {
     0x0L, 0x0L, 0xffffffff00000000L, 0x7fffffffff003fL
  };
  static final long[] jjbitVec17 = {
     0x500000000007daedL, 0x2c62ab82315001L, 0xf580c90040000000L, 0x201080000000007L
  };
  static final long[] jjbitVec18 = {
     0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffff0fffffffL, 0x3ffffffffffffffL
  };
  static final long[] jjbitVec19 = {
     0xffffffff3f3fffffL, 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL, 0x1fdc1fff0fcf1fdcL
  };
  static final long[] jjbitVec20 = {
     0x4c4000000000L, 0x0L, 0x7L, 0x0L
  };
  static final long[] jjbitVec21 = {
     0x3fe00000080L, 0xfffffffffffffffeL, 0xfffffffe001fffffL, 0x7ffffffffffffffL
  };
  static final long[] jjbitVec22 = {
     0x1fffffffffe0L, 0x0L, 0x0L, 0x0L
  };
  static final long[] jjbitVec23 = {
     0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffL, 0x0L
  };
  static final long[] jjbitVec24 = {
     0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffL, 0x0L
  };
  static final long[] jjbitVec25 = {
     0x0L, 0x0L, 0x80000000000000L, 0xff7fffffff7fffffL
  };
  static final long[] jjbitVec26 = {
     0xffffffL, 0xffffffffffff0000L, 0xf80001ffffffffffL, 0x30003L
  };
  static final long[] jjbitVec27 = {
     0xffffffffffffffffL, 0x30000003fL, 0xfffffffbffffd7c0L, 0xffffd547f7fffL
  };
  static final long[] jjbitVec28 = {
     0xffffffffffffdffeL, 0xffffffffdffeffffL, 0xffffffffffff007bL, 0x33fcfffffff199fL
  };
  static final long[] jjbitVec29 = {
     0xfffe000000000000L, 0xfffffffe027fffffL, 0xbbfffffbfffe007fL, 0x707ffffff0016L
  };
  static final long[] jjbitVec30 = {
     0x7fffffe00000000L, 0xffff03ff0007ffffL, 0x7cffffffffffffffL, 0x3ff3dffffef7fffL
  };
  static final long[] jjbitVec31 = {
     0xf3ffffffffffffeeL, 0xffcfff1e3fffL, 0xd3c5fdfffff99feeL, 0x3ffcfb080399fL
  };
  static final long[] jjbitVec32 = {
     0xd36dfdfffff987e4L, 0x1fffc05e003987L, 0xf3edfdfffffbafeeL, 0xffc100003bbfL
  };
  static final long[] jjbitVec33 = {
     0xf3cdfdfffff99feeL, 0xffc3b0c0398fL, 0xc3bfc718d63dc7ecL, 0xff8000803dc7L
  };
  static final long[] jjbitVec34 = {
     0xc3effdfffffddfeeL, 0xffc300603ddfL, 0xc3effdfffffddfecL, 0xffc340603ddfL
  };
  static final long[] jjbitVec35 = {
     0xc3fffdfffffddfecL, 0xffc300803dcfL, 0x0L, 0x0L
  };
  static final long[] jjbitVec36 = {
     0x7ff7ffffffffffeL, 0x3ff7fffL, 0x3bff6caefef02596L, 0x3ff3f5fL
  };
  static final long[] jjbitVec37 = {
     0xc2a003ff03000000L, 0xfffe03fffffffeffL, 0x2fe3ffffebf0fdfL, 0x0L
  };
  static final long[] jjbitVec38 = {
     0x0L, 0x0L, 0x0L, 0x21fff0000L
  };
  static final long[] jjbitVec39 = {
     0x3efffe000000a0L, 0xfffffffffffffffeL, 0xfffffffe661fffffL, 0x77ffffffffffffffL
  };
  private final int jjMoveNfa_0(int startState, int curPos)
  {
     int[] nextStates;
     int startsAt = 0;
     jjnewStateCnt = 7;
     int i = 1;
     jjstateSet[0] = startState;
     int j, kind = 0x7fffffff;
     for (;;)
     {
        if (++jjround == 0x7fffffff)
           ReInitRounds();
        if (curChar < 64)
        {
           long l = 1L << curChar;
           MatchLoop: do
           {
              switch(jjstateSet[--i])
              {
                 case 0:
                    if ((0x100002600L & l) != 0L)
                       kind = 8;
                    break;
                 case 2:
                    if ((0x3ff600000000000L & l) == 0L)
                       break;
                    if (kind > 7)
                       kind = 7;
                    jjstateSet[jjnewStateCnt++] = 2;
                    break;
                 case 3:
                    if ((0x3ff600000000000L & l) != 0L)
                       jjAddStates(0, 1);
                    break;
                 case 4:
                    if (curChar == 58)
                       jjstateSet[jjnewStateCnt++] = 5;
                    break;
                 case 6:
                    if ((0x3ff600000000000L & l) == 0L)
                       break;
                    if (kind > 9)
                       kind = 9;
                    jjstateSet[jjnewStateCnt++] = 6;
                    break;
                 default : break;
              }
           } while(i != startsAt);
        }
        else if (curChar < 128)
        {
           long l = 1L << (curChar & 077);
           MatchLoop: do
           {
              switch(jjstateSet[--i])
              {
                 case 0:
                    if ((0x7fffffe87fffffeL & l) == 0L)
                       break;
                    if (kind > 7)
                       kind = 7;
                    jjCheckNAddStates(2, 5);
                    break;
                 case 2:
                    if ((0x7fffffe87fffffeL & l) == 0L)
                       break;
                    if (kind > 7)
                       kind = 7;
                    jjCheckNAdd(2);
                    break;
                 case 3:
                    if ((0x7fffffe87fffffeL & l) != 0L)
                       jjCheckNAddTwoStates(3, 4);
                    break;
                 case 5:
                 case 6:
                    if ((0x7fffffe87fffffeL & l) == 0L)
                       break;
                    if (kind > 9)
                       kind = 9;
                    jjCheckNAdd(6);
                    break;
                 default : break;
              }
           } while(i != startsAt);
        }
        else
        {
           int hiByte = (int)(curChar >> 8);
           int i1 = hiByte >> 6;
           long l1 = 1L << (hiByte & 077);
           int i2 = (curChar & 0xff) >> 6;
           long l2 = 1L << (curChar & 077);
           MatchLoop: do
           {
              switch(jjstateSet[--i])
              {
                 case 0:
                    if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
                       break;
                    if (kind > 7)
                       kind = 7;
                    jjCheckNAddStates(2, 5);
                    break;
                 case 2:
                    if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
                       break;
                    if (kind > 7)
                       kind = 7;
                    jjCheckNAdd(2);
                    break;
                 case 3:
                    if (jjCanMove_1(hiByte, i1, i2, l1, l2))
                       jjCheckNAddTwoStates(3, 4);
                    break;
                 case 5:
                    if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
                       break;
                    if (kind > 9)
                       kind = 9;
                    jjCheckNAdd(6);
                    break;
                 case 6:
                    if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
                       break;
                    if (kind > 9)
                       kind = 9;
                    jjCheckNAdd(6);
                    break;
                 default : break;
              }
           } while(i != startsAt);
        }
        if (kind != 0x7fffffff)
        {
           jjmatchedKind = kind;
           jjmatchedPos = curPos;
           kind = 0x7fffffff;
        }
        ++curPos;
        if ((i = jjnewStateCnt) == (startsAt = 7 - (jjnewStateCnt = startsAt)))
           return curPos;
        try { curChar = input_stream.readChar(); }
        catch(java.io.IOException e) { return curPos; }
     }
  }
  private final int jjStopStringLiteralDfa_1(int pos, long active0)
  {
     switch (pos)
     {
        default :
           return -1;
     }
  }
  private final int jjStartNfa_1(int pos, long active0)
  {
     return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0), pos + 1);
  }
  private final int jjStartNfaWithStates_1(int pos, int kind, int state)
  {
     jjmatchedKind = kind;
     jjmatchedPos = pos;
     try { curChar = input_stream.readChar(); }
     catch(java.io.IOException e) { return pos + 1; }
     return jjMoveNfa_1(state, pos + 1);
  }
  private final int jjMoveStringLiteralDfa0_1()
  {
     switch(curChar)
     {
        case 40:
           return jjStopAtPos(0, 10);
        case 41:
           return jjStopAtPos(0, 11);
        case 94:
           return jjMoveStringLiteralDfa1_1(0x7000L);
        default :
           return jjMoveNfa_1(0, 0);
     }
  }
  private final int jjMoveStringLiteralDfa1_1(long active0)
  {
     try { curChar = input_stream.readChar(); }
     catch(java.io.IOException e) {
        jjStopStringLiteralDfa_1(0, active0);
        return 1;
     }
     switch(curChar)
     {
        case 40:
           if ((active0 & 0x1000L) != 0L)
              return jjStopAtPos(1, 12);
           break;
        case 41:
           if ((active0 & 0x2000L) != 0L)
              return jjStopAtPos(1, 13);
           break;
        case 94:
           if ((active0 & 0x4000L) != 0L)
              return jjStopAtPos(1, 14);
           break;
        default :
           break;
     }
     return jjStartNfa_1(0, active0);
  }
  static final long[] jjbitVec40 = {
     0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
  };
  static final long[] jjbitVec41 = {
     0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
  };
  private final int jjMoveNfa_1(int startState, int curPos)
  {
     int[] nextStates;
     int startsAt = 0;
     jjnewStateCnt = 1;
     int i = 1;
     jjstateSet[0] = startState;
     int j, kind = 0x7fffffff;
     for (;;)
     {
        if (++jjround == 0x7fffffff)
           ReInitRounds();
        if (curChar < 64)
        {
           long l = 1L << curChar;
           MatchLoop: do
           {
              switch(jjstateSet[--i])
              {
                 case 0:
                    if ((0xfffffcffffffffffL & l) != 0L)
                       kind = 15;
                    break;
                 default : break;
              }
           } while(i != startsAt);
        }
        else if (curChar < 128)
        {
           long l = 1L << (curChar & 077);
           MatchLoop: do
           {
              switch(jjstateSet[--i])
              {
                 case 0:
                    if ((0xffffffffbfffffffL & l) != 0L)
                       kind = 15;
                    break;
                 default : break;
              }
           } while(i != startsAt);
        }
        else
        {
           int hiByte = (int)(curChar >> 8);
           int i1 = hiByte >> 6;
           long l1 = 1L << (hiByte & 077);
           int i2 = (curChar & 0xff) >> 6;
           long l2 = 1L << (curChar & 077);
           MatchLoop: do
           {
              switch(jjstateSet[--i])
              {
                 case 0:
                    if (jjCanMove_2(hiByte, i1, i2, l1, l2) && kind > 15)
                       kind = 15;
                    break;
                 default : break;
              }
           } while(i != startsAt);
        }
        if (kind != 0x7fffffff)
        {
           jjmatchedKind = kind;
           jjmatchedPos = curPos;
           kind = 0x7fffffff;
        }
        ++curPos;
        if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
           return curPos;
        try { curChar = input_stream.readChar(); }
        catch(java.io.IOException e) { return curPos; }
     }
  }
  static final int[] jjnextStates = {
     3, 4, 2, 3, 4, 6, 
  };
  private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
  {
     switch(hiByte)
     {
        case 0:
           return ((jjbitVec2[i2] & l2) != 0L);
        case 1:
           return ((jjbitVec3[i2] & l2) != 0L);
        case 2:
           return ((jjbitVec4[i2] & l2) != 0L);
        case 3:
           return ((jjbitVec5[i2] & l2) != 0L);
        case 4:
           return ((jjbitVec6[i2] & l2) != 0L);
        case 5:
           return ((jjbitVec7[i2] & l2) != 0L);
        case 6:
           return ((jjbitVec8[i2] & l2) != 0L);
        case 9:
           return ((jjbitVec9[i2] & l2) != 0L);
        case 10:
           return ((jjbitVec10[i2] & l2) != 0L);
        case 11:
           return ((jjbitVec11[i2] & l2) != 0L);
        case 12:
           return ((jjbitVec12[i2] & l2) != 0L);
        case 13:
           return ((jjbitVec13[i2] & l2) != 0L);
        case 14:
           return ((jjbitVec14[i2] & l2) != 0L);
        case 15:
           return ((jjbitVec15[i2] & l2) != 0L);
        case 16:
           return ((jjbitVec16[i2] & l2) != 0L);
        case 17:
           return ((jjbitVec17[i2] & l2) != 0L);
        case 30:
           return ((jjbitVec18[i2] & l2) != 0L);
        case 31:
           return ((jjbitVec19[i2] & l2) != 0L);
        case 33:
           return ((jjbitVec20[i2] & l2) != 0L);
        case 48:
           return ((jjbitVec21[i2] & l2) != 0L);
        case 49:
           return ((jjbitVec22[i2] & l2) != 0L);
        case 159:
           return ((jjbitVec23[i2] & l2) != 0L);
        case 215:
           return ((jjbitVec24[i2] & l2) != 0L);
        default : 
           if ((jjbitVec0[i1] & l1) != 0L)
              return true;
           return false;
     }
  }
  private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
  {
     switch(hiByte)
     {
        case 0:
           return ((jjbitVec25[i2] & l2) != 0L);
        case 1:
           return ((jjbitVec3[i2] & l2) != 0L);
        case 2:
           return ((jjbitVec26[i2] & l2) != 0L);
        case 3:
           return ((jjbitVec27[i2] & l2) != 0L);
        case 4:
           return ((jjbitVec28[i2] & l2) != 0L);
        case 5:
           return ((jjbitVec29[i2] & l2) != 0L);
        case 6:
           return ((jjbitVec30[i2] & l2) != 0L);
        case 9:
           return ((jjbitVec31[i2] & l2) != 0L);
        case 10:
           return ((jjbitVec32[i2] & l2) != 0L);
        case 11:
           return ((jjbitVec33[i2] & l2) != 0L);
        case 12:
           return ((jjbitVec34[i2] & l2) != 0L);
        case 13:
           return ((jjbitVec35[i2] & l2) != 0L);
        case 14:
           return ((jjbitVec36[i2] & l2) != 0L);
        case 15:
           return ((jjbitVec37[i2] & l2) != 0L);
        case 16:
           return ((jjbitVec16[i2] & l2) != 0L);
        case 17:
           return ((jjbitVec17[i2] & l2) != 0L);
        case 30:
           return ((jjbitVec18[i2] & l2) != 0L);
        case 31:
           return ((jjbitVec19[i2] & l2) != 0L);
        case 32:
           return ((jjbitVec38[i2] & l2) != 0L);
        case 33:
           return ((jjbitVec20[i2] & l2) != 0L);
        case 48:
           return ((jjbitVec39[i2] & l2) != 0L);
        case 49:
           return ((jjbitVec22[i2] & l2) != 0L);
        case 159:
           return ((jjbitVec23[i2] & l2) != 0L);
        case 215:
           return ((jjbitVec24[i2] & l2) != 0L);
        default : 
           if ((jjbitVec0[i1] & l1) != 0L)
              return true;
           return false;
     }
  }
  private static final boolean jjCanMove_2(int hiByte, int i1, int i2, long l1, long l2)
  {
     switch(hiByte)
     {
        case 0:
           return ((jjbitVec41[i2] & l2) != 0L);
        default : 
           if ((jjbitVec40[i1] & l1) != 0L)
              return true;
           return false;
     }
  }
  public static final String[] jjstrLiteralImages = {
  "", null, null, null, null, null, null, null, null, null, "\50", "\51", 
  "\136\50", "\136\51", "\136\136", null, };
  public static final String[] lexStateNames = {
     "DEFAULT", 
     "IN_SCHEME", 
  };
  public static final int[] jjnewLexState = {
     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
  };
  protected SimpleCharStream input_stream;
  private final int[] jjrounds = new int[7];
  private final int[] jjstateSet = new int[14];
  protected char curChar;
  public XPointerFrameworkParserTokenManager(SimpleCharStream stream)
  {
     if (SimpleCharStream.staticFlag)
        throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
     input_stream = stream;
  }
  public XPointerFrameworkParserTokenManager(SimpleCharStream stream, int lexState)
  {
     this(stream);
     SwitchTo(lexState);
  }
  public void ReInit(SimpleCharStream stream)
  {
     jjmatchedPos = jjnewStateCnt = 0;
     curLexState = defaultLexState;
     input_stream = stream;
     ReInitRounds();
  }
  private final void ReInitRounds()
  {
     int i;
     jjround = 0x80000001;
     for (i = 7; i-- > 0;)
        jjrounds[i] = 0x80000000;
  }
  public void ReInit(SimpleCharStream stream, int lexState)
  {
     ReInit(stream);
     SwitchTo(lexState);
  }
  public void SwitchTo(int lexState)
  {
     if (lexState >= 2 || lexState < 0)
        throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
     else
        curLexState = lexState;
  }
  
  protected Token jjFillToken()
  {
     Token t = Token.newToken(jjmatchedKind);
     t.kind = jjmatchedKind;
     String im = jjstrLiteralImages[jjmatchedKind];
     t.image = (im == null) ? input_stream.GetImage() : im;
     t.beginLine = input_stream.getBeginLine();
     t.beginColumn = input_stream.getBeginColumn();
     t.endLine = input_stream.getEndLine();
     t.endColumn = input_stream.getEndColumn();
     return t;
  }
  
  int curLexState = 0;
  int defaultLexState = 0;
  int jjnewStateCnt;
  int jjround;
  int jjmatchedPos;
  int jjmatchedKind;
  
  public Token getNextToken() 
  {
    int kind;
    Token specialToken = null;
    Token matchedToken;
    int curPos = 0;
  
    EOFLoop :
    for (;;)
    {   
     try   
     {     
        curChar = input_stream.BeginToken();
     }     
     catch(java.io.IOException e)
     {        
        jjmatchedKind = 0;
        matchedToken = jjFillToken();
        return matchedToken;
     }
  
     switch(curLexState)
     {
       case 0:
         jjmatchedKind = 0x7fffffff;
         jjmatchedPos = 0;
         curPos = jjMoveStringLiteralDfa0_0();
         break;
       case 1:
         jjmatchedKind = 0x7fffffff;
         jjmatchedPos = 0;
         curPos = jjMoveStringLiteralDfa0_1();
         break;
     }
       if (jjmatchedKind != 0x7fffffff)
       {
          if (jjmatchedPos + 1 < curPos)
             input_stream.backup(curPos - jjmatchedPos - 1);
             matchedToken = jjFillToken();
         if (jjnewLexState[jjmatchedKind] != -1)
           curLexState = jjnewLexState[jjmatchedKind];
             return matchedToken;
       }
       int error_line = input_stream.getEndLine();
       int error_column = input_stream.getEndColumn();
       String error_after = null;
       boolean EOFSeen = false;
       try { input_stream.readChar(); input_stream.backup(1); }
       catch (java.io.IOException e1) {
          EOFSeen = true;
          error_after = curPos <= 1 ? "" : input_stream.GetImage();
          if (curChar == '\n' || curChar == '\r') {
             error_line++;
             error_column = 0;
          }
          else
             error_column++;
       }
       if (!EOFSeen) {
          input_stream.backup(1);
          error_after = curPos <= 1 ? "" : input_stream.GetImage();
       }
       throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
    }
  }
  
  }
  
  
  
  1.1                  cocoon-2.1/src/java/org/apache/cocoon/components/xpointer/parser/xpointer-fw.jj
  
  Index: xpointer-fw.jj
  ===================================================================
  /*
  
   ============================================================================
                     The Apache Software License, Version 1.1
   ============================================================================
  
   Copyright (C) 1999-2003 The Apache Software Foundation. All rights reserved.
  
   Redistribution and use in source and binary forms, with or without modifica-
   tion, are permitted provided that the following conditions are met:
  
   1. Redistributions of  source code must  retain the above copyright  notice,
      this list of conditions and the following disclaimer.
  
   2. Redistributions in binary form must reproduce the above copyright notice,
      this list of conditions and the following disclaimer in the documentation
      and/or other materials provided with the distribution.
  
   3. The end-user documentation included with the redistribution, if any, must
      include  the following  acknowledgment:  "This product includes  software
      developed  by the  Apache Software Foundation  (http://www.apache.org/)."
      Alternately, this  acknowledgment may  appear in the software itself,  if
      and wherever such third-party acknowledgments normally appear.
  
   4. The names "Apache Cocoon" and  "Apache Software Foundation" must  not  be
      used to  endorse or promote  products derived from  this software without
      prior written permission. For written permission, please contact
      apache@apache.org.
  
   5. Products  derived from this software may not  be called "Apache", nor may
      "Apache" appear  in their name,  without prior written permission  of the
      Apache Software Foundation.
  
   THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
   FITNESS  FOR A PARTICULAR  PURPOSE ARE  DISCLAIMED.  IN NO  EVENT SHALL  THE
   APACHE SOFTWARE  FOUNDATION  OR ITS CONTRIBUTORS  BE LIABLE FOR  ANY DIRECT,
   INDIRECT, INCIDENTAL, SPECIAL,  EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLU-
   DING, BUT NOT LIMITED TO, PROCUREMENT  OF SUBSTITUTE GOODS OR SERVICES; LOSS
   OF USE, DATA, OR  PROFITS; OR BUSINESS  INTERRUPTION)  HOWEVER CAUSED AND ON
   ANY  THEORY OF LIABILITY,  WHETHER  IN CONTRACT,  STRICT LIABILITY,  OR TORT
   (INCLUDING  NEGLIGENCE OR  OTHERWISE) ARISING IN  ANY WAY OUT OF THE  USE OF
   THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  
   This software  consists of voluntary contributions made  by many individuals
   on  behalf of the Apache Software  Foundation and was  originally created by
   Stefano Mazzocchi  <stefano@apache.org>. For more  information on the Apache
   Software Foundation, please see <http://www.apache.org/>.
  
  */
  /*
     Parser for the XPointer Framework Syntax, see the specification at:
     http://www.w3.org/TR/2003/REC-xptr-framework-20030325/
  
     Some of the token definitions (for recognizing NCName's) were copied from
     the JXPath parser from Jakarta Commons (to save some typing), written by
     Ingo Macherius, Gerald Huck <{macherius, huck}@gmd.de> and Dmitri Plotnikov.
  */
  
  options {
    STATIC = false;
  }
  
  PARSER_BEGIN(XPointerFrameworkParser)
  
    package org.apache.cocoon.components.xpointer.parser;
  
    import org.apache.cocoon.components.xpointer.*;
  
    public class XPointerFrameworkParser {
      private XPointer xpointer = new XPointer();
  
      public static void main(String [] args) throws Exception {
        System.out.println("zal dit parsen: " + args[0]);
        XPointerFrameworkParser xfp = new XPointerFrameworkParser(new java.io.StringReader(args[0]));
        xfp.pointer();
      }
  
      public static XPointer parse(String xpointer) throws ParseException {
        XPointerFrameworkParser xfp = new XPointerFrameworkParser(new java.io.StringReader(xpointer));
        xfp.pointer();
        return xfp.getXPointer();
      }
  
      public XPointer getXPointer() {
        return xpointer;
      }
  
      private String unescape(String data) throws ParseException {
        StringBuffer result = new StringBuffer(data.length());
        boolean inCircumflex = false;
        for (int i = 0; i < data.length(); i++) {
          char c = data.charAt(i);
          if (inCircumflex) {
            switch (c) {
              case '^':
              case '(':
              case ')':
                result.append(c);
                inCircumflex = false;
                break;
              default:
                throw new ParseException("Incorrect use of circumflex character at position " + i + " in the string " + data);
            }
          } else if (c == '^') {
            inCircumflex = true;
          } else {
            result.append(c);
          }
        }
        return result.toString();
      }
    }
  
  PARSER_END(XPointerFrameworkParser)
  
  TOKEN :
  {
    <#Letter : <BaseChar> | <Ideographic> >
  | <#BaseChar :
          (
          ["\u0041"-"\u005A"] | ["\u0061"-"\u007A"] | ["\u00C0"-"\u00D6"] | ["\u00D8"-"\u00F6"] |
          ["\u00F8"-"\u00FF"] | ["\u0100"-"\u0131"] | ["\u0134"-"\u013E"] | ["\u0141"-"\u0148"] |
          ["\u014A"-"\u017E"] | ["\u0180"-"\u01C3"] | ["\u01CD"-"\u01F0"] | ["\u01F4"-"\u01F5"] |
          ["\u01FA"-"\u0217"] | ["\u0250"-"\u02A8"] | ["\u02BB"-"\u02C1"] | "\u0386" | ["\u0388"-"\u038A"] |
          "\u038C" | ["\u038E"-"\u03A1"] | ["\u03A3"-"\u03CE"] | ["\u03D0"-"\u03D6"] | "\u03DA" |
          "\u03DC" |  "\u03DE" | "\u03E0" | ["\u03E2"-"\u03F3"] | ["\u0401"-"\u040C"] | ["\u040E"-"\u044F"] |
          ["\u0451"-"\u045C"] | ["\u045E"-"\u0481"] | ["\u0490"-"\u04C4"] | ["\u04C7"-"\u04C8"] |
          ["\u04CB"-"\u04CC"] | ["\u04D0"-"\u04EB"] | ["\u04EE"-"\u04F5"] | ["\u04F8"-"\u04F9"] |
          ["\u0531"-"\u0556"] | "\u0559" | ["\u0561"-"\u0586"] | ["\u05D0"-"\u05EA"] | ["\u05F0"-"\u05F2"] |
          ["\u0621"-"\u063A"] | ["\u0641"-"\u064A"] | ["\u0671"-"\u06B7"] | ["\u06BA"-"\u06BE"] |
          ["\u06C0"-"\u06CE"] | ["\u06D0"-"\u06D3"] | "\u06D5" | ["\u06E5"-"\u06E6"] | ["\u0905"-"\u0939"] |
          "\u093D" | ["\u0958"-"\u0961"] | ["\u0985"-"\u098C"] | ["\u098F"-"\u0990"] | ["\u0993"-"\u09A8"] |
          ["\u09AA"-"\u09B0"] | "\u09B2" | ["\u09B6"-"\u09B9"] | ["\u09DC"-"\u09DD"] | ["\u09DF"-"\u09E1"] |
          ["\u09F0"-"\u09F1"] | ["\u0A05"-"\u0A0A"] | ["\u0A0F"-"\u0A10"] | ["\u0A13"-"\u0A28"] |
          ["\u0A2A"-"\u0A30"] | ["\u0A32"-"\u0A33"] | ["\u0A35"-"\u0A36"] | ["\u0A38"-"\u0A39"] |
          ["\u0A59"-"\u0A5C"] | "\u0A5E" | ["\u0A72"-"\u0A74"] | ["\u0A85"-"\u0A8B"] | "\u0A8D" |
          ["\u0A8F"-"\u0A91"] | ["\u0A93"-"\u0AA8"] | ["\u0AAA"-"\u0AB0"] | ["\u0AB2"-"\u0AB3"] |
          ["\u0AB5"-"\u0AB9"] | "\u0ABD" | "\u0AE0" |  ["\u0B05"-"\u0B0C"] | ["\u0B0F"-"\u0B10"] |
          ["\u0B13"-"\u0B28"] | ["\u0B2A"-"\u0B30"] | ["\u0B32"-"\u0B33"] | ["\u0B36"-"\u0B39"] |
          "\u0B3D" | ["\u0B5C"-"\u0B5D"] | ["\u0B5F"-"\u0B61"] | ["\u0B85"-"\u0B8A"] |  ["\u0B8E"-"\u0B90"] |
          ["\u0B92"-"\u0B95"] |  ["\u0B99"-"\u0B9A"] | "\u0B9C" | ["\u0B9E"-"\u0B9F"] | ["\u0BA3"-"\u0BA4"] |
          ["\u0BA8"-"\u0BAA"] | ["\u0BAE"-"\u0BB5"] | ["\u0BB7"-"\u0BB9"] | ["\u0C05"-"\u0C0C"] |
          ["\u0C0E"-"\u0C10"] | ["\u0C12"-"\u0C28"] | ["\u0C2A"-"\u0C33"] | ["\u0C35"-"\u0C39"] |
          ["\u0C60"-"\u0C61"] | ["\u0C85"-"\u0C8C"] | ["\u0C8E"-"\u0C90"] | ["\u0C92"-"\u0CA8"] |
          ["\u0CAA"-"\u0CB3"] | ["\u0CB5"-"\u0CB9"] | "\u0CDE" | ["\u0CE0"-"\u0CE1"] | ["\u0D05"-"\u0D0C"] |
          ["\u0D0E"-"\u0D10"] | ["\u0D12"-"\u0D28"] | ["\u0D2A"-"\u0D39"] | ["\u0D60"-"\u0D61"] |
          ["\u0E01"-"\u0E2E"] | "\u0E30" | ["\u0E32"-"\u0E33"] | ["\u0E40"-"\u0E45"] | ["\u0E81"-"\u0E82"] |
          "\u0E84" | ["\u0E87"-"\u0E88"] | "\u0E8A" | "\u0E8D" | ["\u0E94"-"\u0E97"] | ["\u0E99"-"\u0E9F"] |
          ["\u0EA1"-"\u0EA3"] | "\u0EA5" | "\u0EA7" | ["\u0EAA"-"\u0EAB"] | ["\u0EAD"-"\u0EAE"] | "\u0EB0" |
          ["\u0EB2"-"\u0EB3"] | "\u0EBD" | ["\u0EC0"-"\u0EC4"] | ["\u0F40"-"\u0F47"] | ["\u0F49"-"\u0F69"] |
          ["\u10A0"-"\u10C5"] | ["\u10D0"-"\u10F6"] | "\u1100" | ["\u1102"-"\u1103"] | ["\u1105"-"\u1107"] |
          "\u1109" | ["\u110B"-"\u110C"] | ["\u110E"-"\u1112"] | "\u113C" | "\u113E" | "\u1140" | "\u114C" |
          "\u114E" | "\u1150" | ["\u1154"-"\u1155"] | "\u1159" | ["\u115F"-"\u1161"] | "\u1163" | "\u1165" |
          "\u1167" | "\u1169" | ["\u116D"-"\u116E"] | ["\u1172"-"\u1173"] | "\u1175" | "\u119E" | "\u11A8" |
          "\u11AB" | ["\u11AE"-"\u11AF"] | ["\u11B7"-"\u11B8"] | "\u11BA" |  ["\u11BC"-"\u11C2"] | "\u11EB" |
          "\u11F0" | "\u11F9" | ["\u1E00"-"\u1E9B"] | ["\u1EA0"-"\u1EF9"] | ["\u1F00"-"\u1F15"] |
          ["\u1F18"-"\u1F1D"] |
          ["\u1F20"-"\u1F45"] | ["\u1F48"-"\u1F4D"] | ["\u1F50"-"\u1F57"] | "\u1F59" | "\u1F5B" | "\u1F5D" |
          ["\u1F5F"-"\u1F7D"] | ["\u1F80"-"\u1FB4"] | ["\u1FB6"-"\u1FBC"] | "\u1FBE" |  ["\u1FC2"-"\u1FC4"] |
          ["\u1FC6"-"\u1FCC"] | ["\u1FD0"-"\u1FD3"] | ["\u1FD6"-"\u1FDB"] | ["\u1FE0"-"\u1FEC"] |
          ["\u1FF2"-"\u1FF4"] | ["\u1FF6"-"\u1FFC"] | "\u2126" | ["\u212A"-"\u212B"] | "\u212E" |
          ["\u2180"-"\u2182"] | ["\u3041"-"\u3094"] | ["\u30A1"-"\u30FA"] | ["\u3105"-"\u312C"] |
          ["\uAC00"-"\uD7A3"]
          ) >
  | <#Ideographic : (["\u4E00"-"\u9FA5"] | "\u3007" | ["\u3021"-"\u3029"]) >
  | <#CombiningChar :
          (
          ["\u0300"-"\u0345"]    |    ["\u0360"-"\u0361"]     |    ["\u0483"-"\u0486"]    |    ["\u0591"-"\u05A1"] |
          ["\u05A3"-"\u05B9"]    |    ["\u05BB"-"\u05BD"]        |    "\u05BF"             |    ["\u05C1"-"\u05C2"] |
          "\u05C4"             | ["\u064B"-"\u0652"] | "\u0670"             | ["\u06D6"-"\u06DC"] |
          ["\u06DD"-"\u06DF"] | ["\u06E0"-"\u06E4"] | ["\u06E7"-"\u06E8"] | ["\u06EA"-"\u06ED"] |
          ["\u0901"-"\u0903"] | "\u093C"    |["\u093E"-"\u094C"] | "\u094D" | ["\u0951"-"\u0954"] |
          ["\u0962"-"\u0963"] | ["\u0981"-"\u0983"] | "\u09BC" | "\u09BE" | "\u09BF" | ["\u09C0"-"\u09C4"] |
          ["\u09C7"-"\u09C8"] | ["\u09CB"-"\u09CD"] | "\u09D7" | ["\u09E2"-"\u09E3"] | "\u0A02" | "\u0A3C" |
          "\u0A3E" | "\u0A3F" | ["\u0A40"-"\u0A42"] |
          ["\u0A47"-"\u0A48"] | ["\u0A4B"-"\u0A4D"] | ["\u0A70"-"\u0A71"] | ["\u0A81"-"\u0A83"] | "\u0ABC" |
          ["\u0ABE"-"\u0AC5"] | ["\u0AC7"-"\u0AC9"] | ["\u0ACB"-"\u0ACD"] | ["\u0B01"-"\u0B03"] | "\u0B3C" |
          ["\u0B3E"-"\u0B43"] | ["\u0B47"-"\u0B48"] | ["\u0B4B"-"\u0B4D"] | ["\u0B56"-"\u0B57"] |
          ["\u0B82"-"\u0B83"] | ["\u0BBE"-"\u0BC2"] | ["\u0BC6"-"\u0BC8"] | ["\u0BCA"-"\u0BCD"] | "\u0BD7" |
          ["\u0C01"-"\u0C03"] | ["\u0C3E"-"\u0C44"] | ["\u0C46"-"\u0C48"] | ["\u0C4A"-"\u0C4D"] |
          ["\u0C55"-"\u0C56"] | ["\u0C82"-"\u0C83"] | ["\u0CBE"-"\u0CC4"] | ["\u0CC6"-"\u0CC8"] |
          ["\u0CCA"-"\u0CCD"] | ["\u0CD5"-"\u0CD6"] | ["\u0D02"-"\u0D03"] | ["\u0D3E"-"\u0D43"] |
          ["\u0D46"-"\u0D48"] | ["\u0D4A"-"\u0D4D"] | "\u0D57" | "\u0E31" | ["\u0E34"-"\u0E3A"] |
          ["\u0E47"-"\u0E4E"] | "\u0EB1" | ["\u0EB4"-"\u0EB9"] | ["\u0EBB"-"\u0EBC"] | ["\u0EC8"-"\u0ECD"] |
          ["\u0F18"-"\u0F19"] | "\u0F35" | "\u0F37" | "\u0F39" | "\u0F3E" | "\u0F3F" | ["\u0F71"-"\u0F84"] |
          ["\u0F86"-"\u0F8B"] | ["\u0F90"-"\u0F95"] | "\u0F97" | ["\u0F99"-"\u0FAD"] | ["\u0FB1"-"\u0FB7"] |
          "\u0FB9" | ["\u20D0"-"\u20DC"] | "\u20E1" | ["\u302A"-"\u302F"] | "\u3099" | "\u309A"
          )
      >
  | <#UnicodeDigit :
          ["\u0030"-"\u0039"] | ["\u0660"-"\u0669"] | ["\u06F0"-"\u06F9"] | ["\u0966"-"\u096F"] |
          ["\u09E6"-"\u09EF"] | ["\u0A66"-"\u0A6F"] | ["\u0AE6"-"\u0AEF"] | ["\u0B66"-"\u0B6F"] |
          ["\u0BE7"-"\u0BEF"] | ["\u0C66"-"\u0C6F"] | ["\u0CE6"-"\u0CEF"] | ["\u0D66"-"\u0D6F"] |
          ["\u0E50"-"\u0E59"] | ["\u0ED0"-"\u0ED9"] | ["\u0F20"-"\u0F29"]
      >
  | <#Extender :
          "\u00B7" | "\u02D0" | "\u02D1" | "\u0387" | "\u0640" | "\u0E46" | "\u0EC6" |
          "\u3005" | ["\u3031"-"\u3035"] | ["\u309D"-"\u309E"] | ["\u30FC"-"\u30FE"]
      >
  | <NCName : (<Letter> | ["_"]) (<Letter> | <UnicodeDigit> | [".","-","_"] | <CombiningChar> | <Extender>)* >
  | <WS: ["\t", "\r", "\n", " "] >
  | <QName : (<NCName> ":")? <NCName> >
  }
  
  <DEFAULT, IN_SCHEME>
  TOKEN :
  {
    <LBRACE: "(" >
  | <RBRACE: ")" >
  }
  
  <IN_SCHEME>
  TOKEN :
  {
    <CIRC_LBRACE: "^(" >
  | <CIRC_RBRACE: "^)" >
  | <DOUBLE_CIRC: "^^" >
  | <NormalChar: ~["(", ")", "^"] >
  }
  
  void pointer():
  {
  }
  {
    LOOKAHEAD(2) schemeBased() | shortHand()
  }
  
  void shortHand():
  {
    Token x;
  }
  {
    x = <NCName>
    {
      xpointer.addPart(new ShorthandPart(x.image));
    }
  }
  
  void schemeBased():
  {
  }
  {
    pointerPart() ( (<WS>)* pointerPart() )*
  }
  
  void pointerPart():
  {
    Token x;
    String schemeName;
    String schemeData;
  }
  {
    (x = <NCName> | x = <QName>)
      <LBRACE>
      {
        // when going inside the scheme data, swith to a different lexical state
        token_source.SwitchTo(IN_SCHEME);
  
        // store the scheme name
        schemeName = x.image;
      }
    schemeData = schemeData()
      <RBRACE>
      {
        // when going outside the scheme data, swith back to the default lexical state
        token_source.SwitchTo(DEFAULT);
  
        // add the pointer part
        if (schemeName.equals("xmlns")) {
          int eqPos = schemeData.indexOf("=");
          if (eqPos == -1)
            throw new ParseException("xmlns scheme data should contain an equals sign");
  
          // Note: the trimming below is not entirely correct, since space is only allowed left
          // and right of the equal sign, but not at the beginning and end of the schemeData
          String prefix = schemeData.substring(0, eqPos).trim();
          String namespace = schemeData.substring(eqPos + 1, schemeData.length()).trim();
          xpointer.addPart(new XmlnsPart(prefix, namespace));
        } else if (schemeName.equals("xpointer")) {
          xpointer.addPart(new XPointerPart(schemeData));
        } else {
          xpointer.addPart(new UnsupportedPart(schemeName));
        }
      }
  }
  
  String schemeData():
  {
    String temp;
    StringBuffer schemeData = new StringBuffer();
  }
  {
    (
     ( temp = escapedData() { schemeData.append(temp); } )*
    )
    {
      return unescape(schemeData.toString());
    }
  }
  
  String escapedData():
  {
    Token x;
    String temp;
    StringBuffer data = new StringBuffer();
  }
  {
    // The reason for not making a token out of this all is that tokens cannot contain recursive definitions
    (
     x = <NormalChar> { data.append(x.image); }
     | x = <CIRC_LBRACE> { data.append(x.image); }
     | x = <CIRC_RBRACE> { data.append(x.image); }
     | x = <DOUBLE_CIRC> { data.append(x.image); }
     | x = <LBRACE> { data.append(x.image); }
       temp = schemeData() { data.append(temp); }
       x = <RBRACE> { data.append(x.image); }
    )
    {
      return data.toString();
    }
  }
  
  
  

Mime
View raw message