FileDocCategorySizeDatePackage
ExpressionTokenizer.javaAPI DocGlassfish v2 API6808Fri May 04 22:32:20 BST 2007org.apache.catalina.ssi

ExpressionTokenizer

public class ExpressionTokenizer extends Object
Parses an expression string to return the individual tokens. This is patterned similar to the StreamTokenizer in the JDK but customized for SSI conditional expression parsing.
version
$Revision: 1.2 $
author
Paul Speed

Fields Summary
public static final int
TOKEN_STRING
public static final int
TOKEN_AND
public static final int
TOKEN_OR
public static final int
TOKEN_NOT
public static final int
TOKEN_EQ
public static final int
TOKEN_NOT_EQ
public static final int
TOKEN_RBRACE
public static final int
TOKEN_LBRACE
public static final int
TOKEN_GE
public static final int
TOKEN_LE
public static final int
TOKEN_GT
public static final int
TOKEN_LT
public static final int
TOKEN_END
private char[]
expr
private String
tokenVal
private int
index
private int
length
Constructors Summary
public ExpressionTokenizer(String expr)
Creates a new parser for the specified expression.



                 
       
        this.expr = expr.trim().toCharArray();
        this.length = this.expr.length;
    
Methods Summary
public intgetIndex()
Returns the current index for error reporting purposes.

        return index;
    
public java.lang.StringgetTokenValue()
Returns the String value of the token if it was type TOKEN_STRING. Otherwise null is returned.

        return tokenVal;
    
public booleanhasMoreTokens()
Returns true if there are more tokens.

        return index < length;
    
protected booleanisMetaChar(char c)

        return Character.isWhitespace(c) || c == '(" || c == ')" || c == '!"
                || c == '<" || c == '>" || c == '|" || c == '&" || c == '=";
    
public intnextToken()
Returns the next token type and initializes any state variables accordingly.

        // Skip any leading white space
        while (index < length && Character.isWhitespace(expr[index]))
            index++;
        // Clear the current token val
        tokenVal = null;
        if (index == length) return TOKEN_END; // End of string
        int start = index;
        char currentChar = expr[index];
        char nextChar = (char)0;
        index++;
        if (index < length) nextChar = expr[index];
        // Check for a known token start
        switch (currentChar) {
            case '(" :
                return TOKEN_LBRACE;
            case ')" :
                return TOKEN_RBRACE;
            case '=" :
                return TOKEN_EQ;
            case '!" :
                if (nextChar == '=") {
                    index++;
                    return TOKEN_NOT_EQ;
                } else {
                    return TOKEN_NOT;
                }
            case '|" :
                if (nextChar == '|") {
                    index++;
                    return TOKEN_OR;
                }
                break;
            case '&" :
                if (nextChar == '&") {
                    index++;
                    return TOKEN_AND;
                }
                break;
            case '>" :
                if (nextChar == '=") {
                    index++;
                    return TOKEN_GE; // Greater than or equal
                } else {
                    return TOKEN_GT; // Greater than
                }
            case '<" :
                if (nextChar == '=") {
                    index++;
                    return TOKEN_LE; // Less than or equal
                } else {
                    return TOKEN_LT; // Less than
                }
            default :
                // Otherwise it's a string
                break;
        }
        int end = index;
        // If it's a quoted string then end is the next unescaped quote
        if (currentChar == '"" || currentChar == '\'") {
            char endChar = currentChar;
            boolean escaped = false;
            start++;
            for (; index < length; index++) {
                if (expr[index] == '\\" && !escaped) {
                    escaped = true;
                    continue;
                }
                if (expr[index] == endChar && !escaped) break;
                escaped = false;
            }
            end = index;
            index++; // Skip the end quote
        } else {
            // End is the next whitespace character
            for (; index < length; index++) {
                if (isMetaChar(expr[index])) break;
            }
            end = index;
        }
        // Extract the string from the array
        this.tokenVal = new String(expr, start, end - start);
        return TOKEN_STRING;