mirror of git://gcc.gnu.org/git/gcc.git
593 lines
18 KiB
Java
593 lines
18 KiB
Java
/* XPathTokenizer.java --
|
|
Copyright (C) 2004 Free Software Foundation, Inc.
|
|
|
|
This file is part of GNU Classpath.
|
|
|
|
GNU Classpath is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
any later version.
|
|
|
|
GNU Classpath is distributed in the hope that it will be useful, but
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GNU Classpath; see the file COPYING. If not, write to the
|
|
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
02110-1301 USA.
|
|
|
|
Linking this library statically or dynamically with other modules is
|
|
making a combined work based on this library. Thus, the terms and
|
|
conditions of the GNU General Public License cover the whole
|
|
combination.
|
|
|
|
As a special exception, the copyright holders of this library give you
|
|
permission to link this library with independent modules to produce an
|
|
executable, regardless of the license terms of these independent
|
|
modules, and to copy and distribute the resulting executable under
|
|
terms of your choice, provided that you also meet, for each linked
|
|
independent module, the terms and conditions of the license of that
|
|
module. An independent module is a module which is not derived from
|
|
or based on this library. If you modify this library, you may extend
|
|
this exception to your version of the library, but you are not
|
|
obligated to do so. If you do not wish to do so, delete this
|
|
exception statement from your version. */
|
|
|
|
package gnu.xml.xpath;
|
|
|
|
import java.io.BufferedReader;
|
|
import java.io.IOException;
|
|
import java.io.Reader;
|
|
import java.io.StringReader;
|
|
import java.util.Map;
|
|
import java.util.TreeMap;
|
|
|
|
/*import antlr.Token;
|
|
import antlr.TokenStream;
|
|
import antlr.TokenStreamException;
|
|
import antlr.TokenStreamIOException;*/
|
|
|
|
/**
|
|
* XPath 1.0 expression tokenizer.
|
|
*
|
|
* @author <a href='mailto:dog@gnu.org'>Chris Burdess</a>
|
|
*/
|
|
public class XPathTokenizer
|
|
implements XPathParser.yyInput
|
|
//implements TokenStream
|
|
{
|
|
|
|
static class XPathToken
|
|
//extends Token
|
|
{
|
|
|
|
int type;
|
|
String val;
|
|
|
|
XPathToken (int type)
|
|
{
|
|
this (type, null);
|
|
}
|
|
|
|
XPathToken (int type, String val)
|
|
{
|
|
//super (type);
|
|
this.type = type;
|
|
this.val = val;
|
|
}
|
|
|
|
public String getText ()
|
|
{
|
|
return val;
|
|
}
|
|
|
|
public String toString ()
|
|
{
|
|
return val;
|
|
}
|
|
|
|
}
|
|
|
|
static final Map keywords = new TreeMap ();
|
|
static
|
|
{
|
|
keywords.put ("ancestor", new Integer (XPathParser.ANCESTOR));
|
|
keywords.put ("ancestor-or-self", new Integer (XPathParser.ANCESTOR_OR_SELF));
|
|
keywords.put ("attribute", new Integer (XPathParser.ATTRIBUTE));
|
|
keywords.put ("child", new Integer (XPathParser.CHILD));
|
|
keywords.put ("descendant", new Integer (XPathParser.DESCENDANT));
|
|
keywords.put ("descendant-or-self", new Integer (XPathParser.DESCENDANT_OR_SELF));
|
|
keywords.put ("following", new Integer (XPathParser.FOLLOWING));
|
|
keywords.put ("following-sibling", new Integer (XPathParser.FOLLOWING_SIBLING));
|
|
keywords.put ("namespace", new Integer (XPathParser.NAMESPACE));
|
|
keywords.put ("parent", new Integer (XPathParser.PARENT));
|
|
keywords.put ("preceding", new Integer (XPathParser.PRECEDING));
|
|
keywords.put ("preceding-sibling", new Integer (XPathParser.PRECEDING_SIBLING));
|
|
keywords.put ("self", new Integer (XPathParser.SELF));
|
|
keywords.put ("div", new Integer (XPathParser.DIV));
|
|
keywords.put ("mod", new Integer (XPathParser.MOD));
|
|
keywords.put ("or", new Integer (XPathParser.OR));
|
|
keywords.put ("and", new Integer (XPathParser.AND));
|
|
keywords.put ("comment", new Integer (XPathParser.COMMENT));
|
|
keywords.put ("processing-instruction", new Integer (XPathParser.PROCESSING_INSTRUCTION));
|
|
keywords.put ("text", new Integer (XPathParser.TEXT));
|
|
keywords.put ("node", new Integer (XPathParser.NODE));
|
|
}
|
|
|
|
Reader in;
|
|
XPathToken token;
|
|
XPathToken lastToken;
|
|
|
|
public XPathTokenizer (String expr)
|
|
{
|
|
this (new StringReader (expr));
|
|
}
|
|
|
|
XPathTokenizer (Reader in)
|
|
{
|
|
this.in = in.markSupported () ? in : new BufferedReader (in);
|
|
}
|
|
|
|
/* Begin ANTLR specific *
|
|
|
|
public Token nextToken ()
|
|
throws TokenStreamException
|
|
{
|
|
try
|
|
{
|
|
if (!advance ())
|
|
{
|
|
throw new TokenStreamException ("eof");
|
|
}
|
|
token ();
|
|
return token;
|
|
}
|
|
catch (IOException e)
|
|
{
|
|
throw new TokenStreamIOException (e);
|
|
}
|
|
}
|
|
|
|
* End ANTLR specific */
|
|
|
|
public boolean advance ()
|
|
throws IOException
|
|
{
|
|
lastToken = token;
|
|
int c = in.read ();
|
|
switch (c)
|
|
{
|
|
case -1: // eof
|
|
return false;
|
|
case 0x20:
|
|
case 0x09:
|
|
case 0x0d:
|
|
case 0x0a: // skip whitespace
|
|
return advance ();
|
|
case 0x22: // "
|
|
case 0x27: // '
|
|
token = consume_literal (c);
|
|
break;
|
|
case 0x28: // (
|
|
token = new XPathToken (XPathParser.LP);
|
|
break;
|
|
case 0x29: // )
|
|
token = new XPathToken (XPathParser.RP);
|
|
break;
|
|
case 0x5b: // [
|
|
token = new XPathToken (XPathParser.LB);
|
|
break;
|
|
case 0x5d: // ]
|
|
token = new XPathToken (XPathParser.RB);
|
|
break;
|
|
case 0x2c: // ,
|
|
token = new XPathToken (XPathParser.COMMA);
|
|
break;
|
|
case 0x7c: // |
|
|
token = new XPathToken (XPathParser.PIPE);
|
|
break;
|
|
case 0x2f: // /
|
|
in.mark (1);
|
|
int d1 = in.read ();
|
|
if (d1 == 0x2f)
|
|
{
|
|
token = new XPathToken (XPathParser.DOUBLE_SLASH);
|
|
}
|
|
else
|
|
{
|
|
in.reset ();
|
|
token = new XPathToken (XPathParser.SLASH);
|
|
}
|
|
break;
|
|
case 0x3d: // =
|
|
token = new XPathToken (XPathParser.EQ);
|
|
break;
|
|
case 0x21: // !
|
|
in.mark (1);
|
|
int d2 = in.read ();
|
|
if (d2 == 0x3d) // =
|
|
{
|
|
token = new XPathToken (XPathParser.NE);
|
|
}
|
|
else
|
|
{
|
|
in.reset ();
|
|
token = new XPathToken (XPathParser.yyErrorCode);
|
|
}
|
|
break;
|
|
case 0x3e: // >
|
|
in.mark (1);
|
|
int d3 = in.read ();
|
|
if (d3 == 0x3d) // =
|
|
{
|
|
token = new XPathToken (XPathParser.GTE);
|
|
}
|
|
else
|
|
{
|
|
in.reset ();
|
|
token = new XPathToken (XPathParser.GT);
|
|
}
|
|
break;
|
|
case 0x3c: // <
|
|
in.mark (1);
|
|
int d4 = in.read ();
|
|
if (d4 == 0x3d) // =
|
|
{
|
|
token = new XPathToken (XPathParser.LTE);
|
|
}
|
|
else
|
|
{
|
|
in.reset ();
|
|
token = new XPathToken (XPathParser.LT);
|
|
}
|
|
break;
|
|
case 0x2b: // +
|
|
token = new XPathToken (XPathParser.PLUS);
|
|
break;
|
|
case 0x2d: // -
|
|
token = new XPathToken (XPathParser.MINUS);
|
|
break;
|
|
case 0x40: // @
|
|
token = new XPathToken (XPathParser.AT);
|
|
break;
|
|
case 0x2a: // *
|
|
token = new XPathToken (XPathParser.STAR);
|
|
break;
|
|
case 0x24: // $
|
|
token = new XPathToken (XPathParser.DOLLAR);
|
|
break;
|
|
case 0x3a: // :
|
|
in.mark (1);
|
|
int d5 = in.read ();
|
|
if (d5 == 0x3a)
|
|
{
|
|
token = new XPathToken (XPathParser.DOUBLE_COLON);
|
|
}
|
|
else
|
|
{
|
|
in.reset ();
|
|
token = new XPathToken (XPathParser.COLON);
|
|
}
|
|
break;
|
|
case 0x2e: // .
|
|
in.mark (1);
|
|
int d6 = in.read ();
|
|
if (d6 == 0x2e)
|
|
{
|
|
token = new XPathToken (XPathParser.DOUBLE_DOT);
|
|
}
|
|
else
|
|
{
|
|
in.reset ();
|
|
token = new XPathToken (XPathParser.DOT);
|
|
}
|
|
break;
|
|
default:
|
|
if (c >= 0x30 && c <= 0x39)
|
|
{
|
|
token = consume_digits (c);
|
|
}
|
|
else if (c == 0x5f || Character.isLetter ((char) c))
|
|
{
|
|
token = consume_name (c);
|
|
}
|
|
else
|
|
{
|
|
token = new XPathToken (XPathParser.yyErrorCode);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public int token ()
|
|
{
|
|
return token.type;
|
|
}
|
|
|
|
public Object value ()
|
|
{
|
|
return token.val;
|
|
}
|
|
|
|
XPathToken consume_literal (int delimiter)
|
|
throws IOException
|
|
{
|
|
StringBuffer buf = new StringBuffer ();
|
|
while (true)
|
|
{
|
|
int c = in.read ();
|
|
if (c == -1)
|
|
{
|
|
return new XPathToken (XPathParser.yyErrorCode);
|
|
}
|
|
else if (c == delimiter)
|
|
{
|
|
return new XPathToken (XPathParser.LITERAL, buf.toString ());
|
|
}
|
|
else
|
|
{
|
|
buf.append ((char) c);
|
|
}
|
|
}
|
|
}
|
|
|
|
XPathToken consume_digits (int c)
|
|
throws IOException
|
|
{
|
|
StringBuffer buf = new StringBuffer ();
|
|
buf.append ((char) c);
|
|
while (true)
|
|
{
|
|
in.mark (1);
|
|
c = in.read ();
|
|
if (c >= 0x30 && c <= 0x39)
|
|
{
|
|
buf.append ((char) c);
|
|
}
|
|
else
|
|
{
|
|
in.reset ();
|
|
return new XPathToken (XPathParser.DIGITS, buf.toString ());
|
|
}
|
|
}
|
|
}
|
|
|
|
XPathToken consume_name (int c)
|
|
throws IOException
|
|
{
|
|
StringBuffer buf = new StringBuffer ();
|
|
buf.append ((char) c);
|
|
while (true)
|
|
{
|
|
in.mark (1);
|
|
c = in.read ();
|
|
if (isNameChar (c))
|
|
{
|
|
buf.append ((char) c);
|
|
}
|
|
else
|
|
{
|
|
in.reset ();
|
|
String name = buf.toString ();
|
|
Integer keyword = (Integer) keywords.get (name);
|
|
if (keyword == null)
|
|
{
|
|
return new XPathToken (XPathParser.NAME, name);
|
|
}
|
|
else
|
|
{
|
|
int val = keyword.intValue ();
|
|
switch (val)
|
|
{
|
|
case XPathParser.NODE:
|
|
case XPathParser.COMMENT:
|
|
case XPathParser.TEXT:
|
|
case XPathParser.PROCESSING_INSTRUCTION:
|
|
// Consume subsequent (
|
|
in.mark (1);
|
|
do
|
|
{
|
|
c = in.read ();
|
|
}
|
|
while (c == 0x20 || c == 0x09);
|
|
if (c != 0x28)
|
|
{
|
|
in.reset ();
|
|
return new XPathToken (XPathParser.NAME, name);
|
|
}
|
|
break;
|
|
case XPathParser.CHILD:
|
|
case XPathParser.PARENT:
|
|
case XPathParser.SELF:
|
|
case XPathParser.DESCENDANT:
|
|
case XPathParser.ANCESTOR:
|
|
case XPathParser.DESCENDANT_OR_SELF:
|
|
case XPathParser.ANCESTOR_OR_SELF:
|
|
case XPathParser.ATTRIBUTE:
|
|
case XPathParser.NAMESPACE:
|
|
case XPathParser.FOLLOWING:
|
|
case XPathParser.FOLLOWING_SIBLING:
|
|
case XPathParser.PRECEDING:
|
|
case XPathParser.PRECEDING_SIBLING:
|
|
// Check that this is an axis specifier
|
|
in.mark(1);
|
|
do
|
|
{
|
|
c = in.read();
|
|
}
|
|
while (c == 0x20 || c == 0x09);
|
|
if (c == 0x3a)
|
|
{
|
|
c = in.read();
|
|
if (c == 0x3a)
|
|
{
|
|
in.reset();
|
|
return new XPathToken(val);
|
|
}
|
|
}
|
|
in.reset();
|
|
return new XPathToken(XPathParser.NAME, name);
|
|
case XPathParser.DIV:
|
|
case XPathParser.MOD:
|
|
// May be a name
|
|
if (lastToken == null)
|
|
{
|
|
return new XPathToken(XPathParser.NAME, name);
|
|
}
|
|
switch (lastToken.type)
|
|
{
|
|
case XPathParser.LP:
|
|
case XPathParser.LB:
|
|
case XPathParser.COMMA:
|
|
case XPathParser.PIPE:
|
|
case XPathParser.EQ:
|
|
case XPathParser.NE:
|
|
case XPathParser.GT:
|
|
case XPathParser.LT:
|
|
case XPathParser.GTE:
|
|
case XPathParser.LTE:
|
|
case XPathParser.PLUS:
|
|
case XPathParser.MINUS:
|
|
case XPathParser.STAR:
|
|
case XPathParser.AT:
|
|
case XPathParser.DOLLAR:
|
|
case XPathParser.COLON:
|
|
case XPathParser.DOUBLE_COLON:
|
|
case XPathParser.DIV:
|
|
case XPathParser.MOD:
|
|
case XPathParser.OR:
|
|
case XPathParser.AND:
|
|
case XPathParser.SLASH:
|
|
return new XPathToken(XPathParser.NAME, name);
|
|
}
|
|
break;
|
|
}
|
|
return new XPathToken (val);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
boolean isNameChar (int c)
|
|
{
|
|
/* Name */
|
|
return (c == 0x5f
|
|
|| c == 0x2d
|
|
|| c == 0x2e
|
|
|| (c >= 0x30 && c <= 0x39)
|
|
/* CombiningChar */
|
|
|| (c >= 0x0300 && c <= 0x0345)
|
|
|| (c >= 0x0360 && c <= 0x0361)
|
|
|| (c >= 0x0483 && c <= 0x0486)
|
|
|| (c >= 0x0591 && c <= 0x05A1)
|
|
|| (c >= 0x05A3 && c <= 0x05B9)
|
|
|| (c >= 0x05BB && c <= 0x05BD)
|
|
|| c == 0x05BF
|
|
|| (c >= 0x05C1 && c <= 0x05C2)
|
|
|| c == 0x05C4
|
|
|| (c >= 0x064B && c <= 0x0652)
|
|
|| c == 0x0670
|
|
|| (c >= 0x06D6 && c <= 0x06DC)
|
|
|| (c >= 0x06DD && c <= 0x06DF)
|
|
|| (c >= 0x06E0 && c <= 0x06E4)
|
|
|| (c >= 0x06E7 && c <= 0x06E8)
|
|
|| (c >= 0x06EA && c <= 0x06ED)
|
|
|| (c >= 0x0901 && c <= 0x0903)
|
|
|| c == 0x093C
|
|
|| (c >= 0x093E && c <= 0x094C)
|
|
|| c == 0x094D
|
|
|| (c >= 0x0951 && c <= 0x0954)
|
|
|| (c >= 0x0962 && c <= 0x0963)
|
|
|| (c >= 0x0981 && c <= 0x0983)
|
|
|| c == 0x09BC
|
|
|| c == 0x09BE
|
|
|| c == 0x09BF
|
|
|| (c >= 0x09C0 && c <= 0x09C4)
|
|
|| (c >= 0x09C7 && c <= 0x09C8)
|
|
|| (c >= 0x09CB && c <= 0x09CD)
|
|
|| c == 0x09D7
|
|
|| (c >= 0x09E2 && c <= 0x09E3)
|
|
|| c == 0x0A02
|
|
|| c == 0x0A3C
|
|
|| c == 0x0A3E
|
|
|| c == 0x0A3F
|
|
|| (c >= 0x0A40 && c <= 0x0A42)
|
|
|| (c >= 0x0A47 && c <= 0x0A48)
|
|
|| (c >= 0x0A4B && c <= 0x0A4D)
|
|
|| (c >= 0x0A70 && c <= 0x0A71)
|
|
|| (c >= 0x0A81 && c <= 0x0A83)
|
|
|| c == 0x0ABC
|
|
|| (c >= 0x0ABE && c <= 0x0AC5)
|
|
|| (c >= 0x0AC7 && c <= 0x0AC9)
|
|
|| (c >= 0x0ACB && c <= 0x0ACD)
|
|
|| (c >= 0x0B01 && c <= 0x0B03)
|
|
|| c == 0x0B3C
|
|
|| (c >= 0x0B3E && c <= 0x0B43)
|
|
|| (c >= 0x0B47 && c <= 0x0B48)
|
|
|| (c >= 0x0B4B && c <= 0x0B4D)
|
|
|| (c >= 0x0B56 && c <= 0x0B57)
|
|
|| (c >= 0x0B82 && c <= 0x0B83)
|
|
|| (c >= 0x0BBE && c <= 0x0BC2)
|
|
|| (c >= 0x0BC6 && c <= 0x0BC8)
|
|
|| (c >= 0x0BCA && c <= 0x0BCD)
|
|
|| c == 0x0BD7
|
|
|| (c >= 0x0C01 && c <= 0x0C03)
|
|
|| (c >= 0x0C3E && c <= 0x0C44)
|
|
|| (c >= 0x0C46 && c <= 0x0C48)
|
|
|| (c >= 0x0C4A && c <= 0x0C4D)
|
|
|| (c >= 0x0C55 && c <= 0x0C56)
|
|
|| (c >= 0x0C82 && c <= 0x0C83)
|
|
|| (c >= 0x0CBE && c <= 0x0CC4)
|
|
|| (c >= 0x0CC6 && c <= 0x0CC8)
|
|
|| (c >= 0x0CCA && c <= 0x0CCD)
|
|
|| (c >= 0x0CD5 && c <= 0x0CD6)
|
|
|| (c >= 0x0D02 && c <= 0x0D03)
|
|
|| (c >= 0x0D3E && c <= 0x0D43)
|
|
|| (c >= 0x0D46 && c <= 0x0D48)
|
|
|| (c >= 0x0D4A && c <= 0x0D4D)
|
|
|| c == 0x0D57
|
|
|| c == 0x0E31
|
|
|| (c >= 0x0E34 && c <= 0x0E3A)
|
|
|| (c >= 0x0E47 && c <= 0x0E4E)
|
|
|| c == 0x0EB1
|
|
|| (c >= 0x0EB4 && c <= 0x0EB9)
|
|
|| (c >= 0x0EBB && c <= 0x0EBC)
|
|
|| (c >= 0x0EC8 && c <= 0x0ECD)
|
|
|| (c >= 0x0F18 && c <= 0x0F19)
|
|
|| c == 0x0F35
|
|
|| c == 0x0F37
|
|
|| c == 0x0F39
|
|
|| c == 0x0F3E
|
|
|| c == 0x0F3F
|
|
|| (c >= 0x0F71 && c <= 0x0F84)
|
|
|| (c >= 0x0F86 && c <= 0x0F8B)
|
|
|| (c >= 0x0F90 && c <= 0x0F95)
|
|
|| c == 0x0F97
|
|
|| (c >= 0x0F99 && c <= 0x0FAD)
|
|
|| (c >= 0x0FB1 && c <= 0x0FB7)
|
|
|| c == 0x0FB9
|
|
|| (c >= 0x20D0 && c <= 0x20DC)
|
|
|| c == 0x20E1
|
|
|| (c >= 0x302A && c <= 0x302F)
|
|
|| c == 0x3099
|
|
|| c == 0x309A
|
|
/* Extender */
|
|
|| c == 0x00B7
|
|
|| c == 0x02D0
|
|
|| c == 0x02D1
|
|
|| c == 0x0387
|
|
|| c == 0x0640
|
|
|| c == 0x0E46
|
|
|| c == 0x0EC6
|
|
|| c == 0x3005
|
|
|| (c >= 0x3031 && c <= 0x3035)
|
|
|| (c >= 0x309D && c <= 0x309E)
|
|
|| (c >= 0x30FC && c <= 0x30FE)
|
|
/* Name */
|
|
|| Character.isLetter ((char) c));
|
|
}
|
|
|
|
}
|