Examples with ExpressionSyntaxErrorException com.googlecode.aviator.exception.ExpressionSyntaxErrorException used on opensource projects

Example 1 with ExpressionSyntaxErrorException

use of com.googlecode.aviator.exception.ExpressionSyntaxErrorException in project aviatorscript by killme2008.

the class ExpressionLexer method scan.

public Token<?> scan(final boolean analyse) {
    // If buffer is not empty,return
    if (this.tokenBuffer != null && !this.tokenBuffer.isEmpty()) {
        return this.tokenBuffer.pop();
    }
    // Skip white space or line
    for (; ; nextChar()) {
        if (this.peek == CharacterIterator.DONE) {
            return null;
        }
        if (analyse) {
            if (this.peek == ' ' || this.peek == '\t' || this.peek == '\r' || this.peek == '\n') {
                if (this.peek == '\n') {
                    this.lineNo++;
                }
                continue;
            }
            break;
        } else {
            char ch = this.peek;
            int index = this.iterator.getIndex();
            nextChar();
            return new CharToken(ch, this.lineNo, index);
        }
    }
    // if it is a hex digit
    if (Character.isDigit(this.peek) && this.peek == '0') {
        nextChar();
        if (this.peek == 'x' || this.peek == 'X') {
            nextChar();
            StringBuilder sb = new StringBuilder();
            int startIndex = this.iterator.getIndex() - 2;
            long value = 0L;
            do {
                sb.append(this.peek);
                value = 16 * value + Character.digit(this.peek, 16);
                nextChar();
            } while (isValidHexChar(this.peek));
            return new NumberToken(value, sb.toString(), this.lineNo, startIndex);
        } else {
            prevChar();
        }
    }
    // If it is a digit
    if (Character.isDigit(this.peek) || this.peek == '.') {
        StringBuilder sb = new StringBuilder();
        int startIndex = this.iterator.getIndex();
        long lval = 0L;
        double dval = 0d;
        boolean hasDot = false;
        double d = 10.0;
        boolean isBigInt = false;
        boolean isBigDecimal = false;
        boolean scientificNotation = false;
        boolean negExp = false;
        boolean isOverflow = false;
        do {
            sb.append(this.peek);
            if (this.peek == '.') {
                if (scientificNotation) {
                    throw new CompileExpressionErrorException("Illegal number " + sb + " at " + this.iterator.getIndex());
                }
                if (hasDot) {
                    throw new CompileExpressionErrorException("Illegal Number " + sb + " at " + this.iterator.getIndex());
                } else {
                    hasDot = true;
                    nextChar();
                }
            } else if (this.peek == 'N') {
                // big integer
                if (hasDot) {
                    throw new CompileExpressionErrorException("Illegal number " + sb + " at " + this.iterator.getIndex());
                }
                isBigInt = true;
                nextChar();
                break;
            } else if (this.peek == 'M') {
                isBigDecimal = true;
                nextChar();
                break;
            } else if (this.peek == 'e' || this.peek == 'E') {
                if (scientificNotation) {
                    throw new CompileExpressionErrorException("Illegal number " + sb + " at " + this.iterator.getIndex());
                }
                scientificNotation = true;
                nextChar();
                if (this.peek == '-') {
                    negExp = true;
                    sb.append(this.peek);
                    nextChar();
                }
            } else {
                int digit = Character.digit(this.peek, 10);
                if (scientificNotation) {
                    int n = digit;
                    nextChar();
                    while (Character.isDigit(this.peek)) {
                        sb.append(this.peek);
                        n = 10 * n + Character.digit(this.peek, 10);
                        nextChar();
                    }
                    while (n-- > 0) {
                        if (negExp) {
                            dval = dval / 10;
                        } else {
                            dval = 10 * dval;
                        }
                    }
                    hasDot = true;
                } else if (hasDot) {
                    dval = dval + digit / d;
                    d = d * 10;
                    nextChar();
                } else {
                    if (!isOverflow && (lval > OVERFLOW_FLAG || (lval == OVERFLOW_FLAG && digit > OVERFLOW_SINGLE))) {
                        isOverflow = true;
                    }
                    lval = 10 * lval + digit;
                    dval = 10 * dval + digit;
                    nextChar();
                }
            }
        } while (Character.isDigit(this.peek) || this.peek == '.' || this.peek == 'E' || this.peek == 'e' || this.peek == 'M' || this.peek == 'N');
        Number value;
        if (isBigDecimal) {
            value = new BigDecimal(getBigNumberLexeme(sb), this.mathContext);
        } else if (isBigInt) {
            value = new BigInteger(getBigNumberLexeme(sb));
        } else if (hasDot) {
            if (this.parseFloatIntoDecimal && sb.length() > 1) {
                value = new BigDecimal(sb.toString(), this.mathContext);
            } else if (sb.length() == 1) {
                // only have a dot character.
                return new CharToken('.', this.lineNo, startIndex);
            } else {
                value = dval;
            }
        } else {
            if (this.parseIntegralNumberIntoDecimal) {
                // we make integral number as a BigDecimal.
                value = new BigDecimal(sb.toString(), this.mathContext);
            } else {
                // The long value is overflow, we should prompt it to be a BigInteger.
                if (isOverflow) {
                    value = new BigInteger(sb.toString());
                } else {
                    value = lval;
                }
            }
        }
        String lexeme = sb.toString();
        if (isBigDecimal || isBigInt) {
            lexeme = lexeme.substring(0, lexeme.length() - 1);
        }
        return new NumberToken(value, lexeme, this.lineNo, startIndex);
    }
    // It is a variable
    if (this.peek == '#') {
        int startIndex = this.iterator.getIndex();
        // skip '#'
        nextChar();
        boolean hasBackquote = false;
        if (this.peek == '#') {
            // ## comments
            while (this.peek != CharacterIterator.DONE && this.peek != '\n') {
                nextChar();
            }
            return this.scan(analyse);
        } else if (this.peek == '`') {
            hasBackquote = true;
            nextChar();
        }
        StringBuilder sb = new StringBuilder();
        if (hasBackquote) {
            while (this.peek != '`') {
                if (this.peek == CharacterIterator.DONE) {
                    throw new CompileExpressionErrorException("EOF while reading string at index: " + this.iterator.getIndex());
                }
                sb.append(this.peek);
                nextChar();
            }
            // skip '`'
            nextChar();
        } else {
            while (Character.isJavaIdentifierPart(this.peek) || this.peek == '.' || this.peek == '[' || this.peek == ']') {
                sb.append(this.peek);
                nextChar();
            }
        }
        String lexeme = sb.toString();
        if (lexeme.isEmpty()) {
            throw new ExpressionSyntaxErrorException("Blank variable name after '#'");
        }
        Variable variable = new Variable(lexeme, this.lineNo, startIndex);
        variable.setQuote(true);
        return this.symbolTable.reserve(variable);
    }
    if (Character.isJavaIdentifierStart(this.peek)) {
        int startIndex = this.iterator.getIndex();
        StringBuilder sb = new StringBuilder();
        do {
            sb.append(this.peek);
            nextChar();
        } while (Character.isJavaIdentifierPart(this.peek) || this.peek == '.');
        String lexeme = sb.toString();
        Variable variable = new Variable(lexeme, this.lineNo, startIndex);
        return this.symbolTable.reserve(variable);
    }
    if (isBinaryOP(this.peek)) {
        CharToken opToken = new CharToken(this.peek, this.lineNo, this.iterator.getIndex());
        nextChar();
        return opToken;
    }
    // String
    if (this.peek == '"' || this.peek == '\'') {
        char left = this.peek;
        int startIndex = this.iterator.getIndex();
        StringBuilder sb = new StringBuilder();
        boolean hasInterpolation = false;
        // char prev = this.peek;
        while ((this.peek = this.iterator.next()) != left) {
            // It's not accurate,but acceptable.
            if (this.peek == '#' && !hasInterpolation) {
                hasInterpolation = true;
            }
            if (this.peek == '\\') {
                // escape
                nextChar();
                if (this.peek == CharacterIterator.DONE) {
                    throw new CompileExpressionErrorException("EOF while reading string at index: " + this.iterator.getIndex());
                }
                if (this.peek == left) {
                    sb.append(this.peek);
                    continue;
                }
                switch(this.peek) {
                    case 't':
                        this.peek = '\t';
                        break;
                    case 'r':
                        this.peek = '\r';
                        break;
                    case 'n':
                        this.peek = '\n';
                        break;
                    case '\\':
                        break;
                    case 'b':
                        this.peek = '\b';
                        break;
                    case 'f':
                        this.peek = '\f';
                        break;
                    case '#':
                        hasInterpolation = hasInterpolation || true;
                        if (this.instance.isFeatureEnabled(Feature.StringInterpolation)) {
                            sb.append('\\');
                            this.peek = '#';
                            break;
                        }
                    default:
                        {
                            throw new CompileExpressionErrorException("Unsupported escape character: \\" + this.peek);
                        }
                }
            }
            if (this.peek == CharacterIterator.DONE) {
                throw new CompileExpressionErrorException("EOF while reading string at index: " + this.iterator.getIndex());
            }
            sb.append(this.peek);
        }
        nextChar();
        return new StringToken(sb.toString(), this.lineNo, startIndex).withMeta(Constants.INTER_META, hasInterpolation);
    }
    Token<Character> token = new CharToken(this.peek, this.lineNo, this.iterator.getIndex());
    nextChar();
    return token;
}

Example 2 with ExpressionSyntaxErrorException

use of com.googlecode.aviator.exception.ExpressionSyntaxErrorException in project aviatorscript by killme2008.

the class ExpressionParser method reportSyntaxError.

public void reportSyntaxError(final String message) {
    int index = isValidLookhead() ? this.lookhead.getStartIndex() : this.lexer.getCurrentIndex();
    if (this.lookhead != null) {
        this.lexer.pushback(this.lookhead);
    }
    String msg = // 
    "Syntax error: " + message + " at " + // 
    index + ", lineNumber: " + // 
    this.lexer.getLineNo() + // 
    ", token : " + this.lookhead + // 
    ",\nwhile parsing expression: `\n" + this.lexer.getScanString() + "^^^\n`";
    ExpressionSyntaxErrorException e = new ExpressionSyntaxErrorException(msg);
    StackTraceElement[] traces = e.getStackTrace();
    List<StackTraceElement> filteredTraces = new ArrayList<>();
    for (StackTraceElement t : traces) {
        if (!this.instance.getOptionValue(Options.TRACE_EVAL).bool && t.getClassName().equals(this.getClass().getName())) {
            continue;
        }
        filteredTraces.add(t);
    }
    e.setStackTrace(filteredTraces.toArray(new StackTraceElement[filteredTraces.size()]));
    throw e;
}

Example 3 with ExpressionSyntaxErrorException

use of com.googlecode.aviator.exception.ExpressionSyntaxErrorException in project aviatorscript by killme2008.

the class TestScripts method testUseStatement.

@Test
public void testUseStatement() {
    Env env = (Env) testScript("use1.av", "Long", Long.class);
    assertNotNull(env);
    List<String> symbols = env.getImportedSymbols();
    assertNotNull(symbols);
    assertEquals(2, symbols.size());
    assertTrue(symbols.contains("com.googlecode.aviator.runtime.type.AviatorObject"));
    assertTrue(symbols.contains("java.util.List"));
    testScript("use2.av");
    testScript("use3.av");
    testScript("use4.av");
    try {
        testScript("use5.av");
        fail();
    } catch (ExpressionSyntaxErrorException e) {
        assertTrue(e.getMessage().contains("expect variable name or * to use at"));
    }
}

Example 4 with ExpressionSyntaxErrorException

use of com.googlecode.aviator.exception.ExpressionSyntaxErrorException in project aviatorscript by killme2008.

the class GrammarUnitTest method testTernaryOperator.

/*
   * 测试三元表达式
   */
@Test
public void testTernaryOperator() {
    Map<String, Object> env = new HashMap<String, Object>();
    int i = 0;
    float f = 3.14f;
    String email = "killme2008@gmail.com";
    char ch = 'a';
    boolean t = true;
    env.put("i", i);
    env.put("f", f);
    env.put("email", email);
    env.put("ch", ch);
    env.put("t", t);
    assertEquals(1, this.instance.execute("2>1?1:0"));
    assertEquals(0, this.instance.execute("2<1?1:0"));
    assertEquals(f, (Float) this.instance.execute("false?i:f", env), 0.001);
    assertEquals(i, this.instance.execute("true?i:f", env));
    assertEquals("killme2008", this.instance.execute("email=~/([\\w0-9]+)@\\w+\\.\\w+/ ? $1:'unknow'", env));
    assertEquals(f, (Float) this.instance.execute("ch!='a'?i:f", env), 0.001);
    assertEquals(i, this.instance.execute("ch=='a'?i:f", env));
    assertEquals(email, this.instance.execute("t?email:ch", env));
    // 多层嵌套
    assertEquals(ch, this.instance.execute("t? i>0? f:ch : email", env));
    assertEquals(email, this.instance.execute("!t? i>0? f:ch : f>3?email:ch", env));
    // 使用括号
    assertEquals(email, this.instance.execute("!t? (i>0? f:ch) :( f>3?email:ch)", env));
    // 测试错误情况
    try {
        this.instance.execute("f?1:0", env);
        Assert.fail();
    } catch (ExpressionRuntimeException e) {
    }
    try {
        this.instance.execute("'hello'?1:0");
        Assert.fail();
    } catch (ExpressionRuntimeException e) {
    }
    try {
        this.instance.execute("/test/?1:0");
        Assert.fail();
    } catch (ExpressionRuntimeException e) {
    }
    try {
        this.instance.execute("!t? (i>0? f:ch) : f>3?email:ch)", env);
        Assert.fail();
    } catch (ExpressionSyntaxErrorException e) {
    }
    try {
        this.instance.execute("!t? (i>0? f:ch : (f>3?email:ch)", env);
        Assert.fail();
    } catch (ExpressionSyntaxErrorException e) {
    }
}