cocoon-cvs mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jheym...@apache.org
Subject svn commit: r330548 [35/132] - in /cocoon/whiteboard/maven2/cocoon-flat-layout: ./ cocoon-ajax-block/ cocoon-ajax-block/api/ cocoon-ajax-block/api/src/ cocoon-ajax-block/api/src/main/ cocoon-ajax-block/api/src/main/java/ cocoon-ajax-block/api/src/main/...
Date Thu, 03 Nov 2005 14:00:48 GMT
Added: cocoon/whiteboard/maven2/cocoon-flat-layout/cocoon-core/src/main/java/org/apache/cocoon/components/xpointer/parser/XPointerFrameworkParser.java
URL: http://svn.apache.org/viewcvs/cocoon/whiteboard/maven2/cocoon-flat-layout/cocoon-core/src/main/java/org/apache/cocoon/components/xpointer/parser/XPointerFrameworkParser.java?rev=330548&view=auto
==============================================================================
--- cocoon/whiteboard/maven2/cocoon-flat-layout/cocoon-core/src/main/java/org/apache/cocoon/components/xpointer/parser/XPointerFrameworkParser.java (added)
+++ cocoon/whiteboard/maven2/cocoon-flat-layout/cocoon-core/src/main/java/org/apache/cocoon/components/xpointer/parser/XPointerFrameworkParser.java Thu Nov  3 05:41:06 2005
@@ -0,0 +1,615 @@
+/*
+ * Copyright 1999-2005 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.cocoon.components.xpointer.parser;
+
+import java.util.HashMap;
+
+import org.apache.cocoon.components.xpointer.ElementPathPart;
+import org.apache.cocoon.components.xpointer.ShorthandPart;
+import org.apache.cocoon.components.xpointer.UnsupportedPart;
+import org.apache.cocoon.components.xpointer.XPointer;
+import org.apache.cocoon.components.xpointer.XPointerPart;
+import org.apache.cocoon.components.xpointer.XmlnsPart;
+
+public class XPointerFrameworkParser
+    implements XPointerFrameworkParserConstants {
+    private XPointer xpointer = new XPointer();
+    private HashMap namespaces = new HashMap();
+
+    public static void main(String[] args) throws Exception {
+        System.out.println("will parse this: " + 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));
+        try {
+            xfp.pointer();
+        } catch (TokenMgrError e) {
+            // Rethrow TokenMgrErrors as ParseExceptions, because errors aren't caught by Cocoon,
+            // and mistyping in a xpointer isn't such a grave error
+            throw new ParseException(e.getMessage());
+        }
+        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);
+
+        // parse schemeName in prefix and localName
+        String schemeNamespace = null, schemeLocalName = null;
+        int colonPos = schemeName.indexOf(':');
+        if (colonPos != -1) {
+            String schemePrefix = schemeName.substring(0, colonPos);
+            schemeNamespace = (String) namespaces.get(schemePrefix);
+            schemeLocalName = schemeName.substring(colonPos + 1);
+        } else {
+            schemeLocalName = schemeName;
+        }
+
+        // add the pointer part
+        if (schemeNamespace == null && schemeLocalName.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));
+            namespaces.put(prefix, namespace);
+        } else if (
+            schemeNamespace == null && schemeLocalName.equals("xpointer")) {
+            xpointer.addPart(new XPointerPart(schemeData));
+        } else if (
+            "http://apache.org/cocoon/xpointer".equals(schemeNamespace)
+                && schemeLocalName.equals("elementpath")) {
+            xpointer.addPart(new ElementPathPart(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_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;
+    }
+
+    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;
+    }
+
+    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 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 enumeration = jj_expentries.elements();
+                enumeration.hasMoreElements();
+                ) {
+                int[] oldentry = (int[]) (enumeration.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;
+    }
+
+}

Propchange: cocoon/whiteboard/maven2/cocoon-flat-layout/cocoon-core/src/main/java/org/apache/cocoon/components/xpointer/parser/XPointerFrameworkParser.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: cocoon/whiteboard/maven2/cocoon-flat-layout/cocoon-core/src/main/java/org/apache/cocoon/components/xpointer/parser/XPointerFrameworkParserConstants.java
URL: http://svn.apache.org/viewcvs/cocoon/whiteboard/maven2/cocoon-flat-layout/cocoon-core/src/main/java/org/apache/cocoon/components/xpointer/parser/XPointerFrameworkParserConstants.java?rev=330548&view=auto
==============================================================================
--- cocoon/whiteboard/maven2/cocoon-flat-layout/cocoon-core/src/main/java/org/apache/cocoon/components/xpointer/parser/XPointerFrameworkParserConstants.java (added)
+++ cocoon/whiteboard/maven2/cocoon-flat-layout/cocoon-core/src/main/java/org/apache/cocoon/components/xpointer/parser/XPointerFrameworkParserConstants.java Thu Nov  3 05:41:06 2005
@@ -0,0 +1,59 @@
+/*
+ * Copyright 1999-2004 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+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>",
+  };
+
+}

Propchange: cocoon/whiteboard/maven2/cocoon-flat-layout/cocoon-core/src/main/java/org/apache/cocoon/components/xpointer/parser/XPointerFrameworkParserConstants.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: cocoon/whiteboard/maven2/cocoon-flat-layout/cocoon-core/src/main/java/org/apache/cocoon/components/xpointer/parser/XPointerFrameworkParserTokenManager.java
URL: http://svn.apache.org/viewcvs/cocoon/whiteboard/maven2/cocoon-flat-layout/cocoon-core/src/main/java/org/apache/cocoon/components/xpointer/parser/XPointerFrameworkParserTokenManager.java?rev=330548&view=auto
==============================================================================
--- cocoon/whiteboard/maven2/cocoon-flat-layout/cocoon-core/src/main/java/org/apache/cocoon/components/xpointer/parser/XPointerFrameworkParserTokenManager.java (added)
+++ cocoon/whiteboard/maven2/cocoon-flat-layout/cocoon-core/src/main/java/org/apache/cocoon/components/xpointer/parser/XPointerFrameworkParserTokenManager.java Thu Nov  3 05:41:06 2005
@@ -0,0 +1,747 @@
+/*
+ * Copyright 1999-2004 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.cocoon.components.xpointer.parser;
+
+public class XPointerFrameworkParserTokenManager
+    implements XPointerFrameworkParserConstants {
+    public java.io.PrintStream debugStream = System.out;
+    public void setDebugStream(java.io.PrintStream ds) {
+        debugStream = ds;
+    }
+    private final int jjStopAtPos(int pos, int kind) {
+        jjmatchedKind = kind;
+        jjmatchedPos = pos;
+        return 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);
+    }
+    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 startsAt = 0;
+        jjnewStateCnt = 7;
+        int i = 1;
+        jjstateSet[0] = startState;
+        int 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 = (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 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 startsAt = 0;
+        jjnewStateCnt = 1;
+        int i = 1;
+        jjstateSet[0] = startState;
+        int 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 = (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() {
+        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);
+        }
+    }
+
+}

Propchange: cocoon/whiteboard/maven2/cocoon-flat-layout/cocoon-core/src/main/java/org/apache/cocoon/components/xpointer/parser/XPointerFrameworkParserTokenManager.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: cocoon/whiteboard/maven2/cocoon-flat-layout/cocoon-core/src/main/java/org/apache/cocoon/components/xpointer/parser/xpointer-fw.jj
URL: http://svn.apache.org/viewcvs/cocoon/whiteboard/maven2/cocoon-flat-layout/cocoon-core/src/main/java/org/apache/cocoon/components/xpointer/parser/xpointer-fw.jj?rev=330548&view=auto
==============================================================================
--- cocoon/whiteboard/maven2/cocoon-flat-layout/cocoon-core/src/main/java/org/apache/cocoon/components/xpointer/parser/xpointer-fw.jj (added)
+++ cocoon/whiteboard/maven2/cocoon-flat-layout/cocoon-core/src/main/java/org/apache/cocoon/components/xpointer/parser/xpointer-fw.jj Thu Nov  3 05:41:06 2005
@@ -0,0 +1,304 @@
+/*
+ * Copyright 1999-2004 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/*
+   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.*;
+  import java.util.HashMap;
+
+  public class XPointerFrameworkParser {
+    private XPointer xpointer = new XPointer();
+    private HashMap namespaces = new HashMap();
+
+    public static void main(String [] args) throws Exception {
+      System.out.println("will parse this: " + 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);
+
+      // parse schemeName in prefix and localName
+      String schemeNamespace = null, schemeLocalName = null;
+      int colonPos = schemeName.indexOf(':');
+      if (colonPos != -1) {
+         String schemePrefix = schemeName.substring(0, colonPos);
+         schemeNamespace = (String)namespaces.get(schemePrefix);
+         schemeLocalName = schemeName.substring(colonPos + 1);
+       } else {
+         schemeLocalName = schemeName;
+       }
+
+
+      // add the pointer part
+      if (schemeNamespace == null && schemeLocalName.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));
+        namespaces.put(prefix, namespace);
+      } else if (schemeNamespace == null && schemeLocalName.equals("xpointer")) {
+        xpointer.addPart(new XPointerPart(schemeData));
+      } else if ("http://apache.org/cocoon/xpointer".equals(schemeNamespace) && schemeLocalName.equals("elementpath")) {
+        xpointer.addPart(new ElementPathPart(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();
+  }
+}

Added: cocoon/whiteboard/maven2/cocoon-flat-layout/cocoon-core/src/main/java/org/apache/cocoon/components/xslt/TraxErrorListener.java
URL: http://svn.apache.org/viewcvs/cocoon/whiteboard/maven2/cocoon-flat-layout/cocoon-core/src/main/java/org/apache/cocoon/components/xslt/TraxErrorListener.java?rev=330548&view=auto
==============================================================================
--- cocoon/whiteboard/maven2/cocoon-flat-layout/cocoon-core/src/main/java/org/apache/cocoon/components/xslt/TraxErrorListener.java (added)
+++ cocoon/whiteboard/maven2/cocoon-flat-layout/cocoon-core/src/main/java/org/apache/cocoon/components/xslt/TraxErrorListener.java Thu Nov  3 05:41:06 2005
@@ -0,0 +1,112 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.cocoon.components.xslt;
+
+import javax.xml.transform.ErrorListener;
+import javax.xml.transform.TransformerException;
+
+import org.apache.avalon.framework.logger.Logger;
+import org.apache.cocoon.util.location.Location;
+import org.apache.cocoon.util.location.LocationUtils;
+
+/**
+ * A smart error listener for <code>javax.xml.tranform</code> that does its best to provide
+ * useful error messages.
+ * 
+ * @version $Id: TraxErrorListener.java 326713 2005-10-19 21:19:29Z sylvain $
+ * @since 2.1.8
+ */
+public class TraxErrorListener implements ErrorListener{
+
+    private Logger logger;
+    private String uri;
+    
+    /** The exception we had from warning() */
+    private TransformerException warningEx;
+    
+    /** The exception we had from error() or fatalError() */
+    private TransformerException exception;
+
+    public TraxErrorListener(Logger logger, String uri) {
+        this.logger = logger;
+        this.uri = uri;
+    }
+
+    /**
+     * Get the exception that was catched by this listener, if any.
+     * 
+     * @return the exception
+     */
+    public Throwable getThrowable() {
+        if (exception == null) {
+            return null;
+        }
+        
+        Location loc = LocationUtils.getLocation(exception);
+        if (LocationUtils.isKnown(loc)) {
+            // Has a location: don't loose this precious information!
+            return exception;
+        }
+        
+        // No location: if it's just a wrapper, consider only the wrapped exception
+        if (exception.getCause() != null) {
+            return exception.getCause();
+        }
+        
+        // That's the actual exception!
+        return exception;
+    }
+
+    public void warning(TransformerException ex) throws TransformerException {
+        // TODO: We may want here to allow some special formatting of the messages, such as
+        // "DEBUG:A debug message" or "INFO:Transforming <foo> in mode 'bar'" to use the different
+        // log levels. This can include also deprecation logs for system-defined stylesheets
+        // using "DEPRECATED:WARN:Styling 'foo' is replaced by 'bar'".    
+
+        if (logger.isWarnEnabled()) {
+            Location loc = LocationUtils.getLocation(ex);
+            logger.warn(ex.getMessage() + " at "+ loc == null ? uri : loc.toString());
+        }
+        // Keep the warning (see below)
+        warningEx = ex;
+    }
+
+    public void error(TransformerException ex) throws TransformerException {
+
+        // If we had a warning previoulsy, and the current exception has no cause, then use the warning.
+        // This is how Xalan behaves on <xsl:message terminate="yes">: it first issues a warning with all
+        // the useful information, then a useless "stylesheed directed termination" error.
+        if (warningEx != null && ex.getCause() == null) {
+            ex = warningEx;
+        }
+        warningEx = null;
+
+        // Keep the exception for later use.
+        exception = ex;
+        // and rethrow it
+        throw ex;
+    }
+
+    public void fatalError(TransformerException ex) throws TransformerException {
+        if (warningEx != null && ex.getCause() == null) {
+            ex = warningEx;
+        }
+        warningEx = null;
+
+        exception = ex;
+        throw ex;
+    }
+}

Propchange: cocoon/whiteboard/maven2/cocoon-flat-layout/cocoon-core/src/main/java/org/apache/cocoon/components/xslt/TraxErrorListener.java
------------------------------------------------------------------------------
    svn:eol-style = native



Mime
View raw message