/** * Implements the <code>parse</code> method. Calls <code>parseTerm(false)</code> * and throws an exception if the next token is not the end-of-string. * * @return The generated term. * @throws ParseException if a parse error occurs */ private Term parseImpl() throws ParseException { final Term expr = parseTerm(false); final int tt = tokenizer.next(); if (tt != Tokenizer.TT_EOS) { reportError("Incomplete expression."); /*I18N*/ } return expr; }
int tt = tokenizer.next(); if (tt == ',') { term = parseTerm(true);
/** * Parses a function argument list <i>'(' arg1 ',' arg2 ',' arg3 ',' ... ')'</i> * * @return The generated term. * @throws ParseException if a parse error occurs */ private Term[] parseArgumentList() throws ParseException { final Term[] args = parseTermList(); final int tt = tokenizer.next(); if (tt != ')') { tokenizer.pushBack(); reportError("Missing ')' or ','."); /*I18N*/ } return args; }
/** * Parses an assignment expression <i>x '=' y</i>. * * @param required true, if the expression is required. * @return The generated term. * @throws ParseException if a parse error occurs */ private Term parseAssign(final boolean required) throws ParseException { Term t1 = parseConditional(required); while (t1 != null) { int tt = tokenizer.next(); if (tt == '=') { Term t2 = parseAssign(true); if (t1 instanceof Term.Ref && ((Term.Ref) t1).getVariable() != null) { t1 = new Term.Assign(t1, t2); } else { reportError("Variable expected on the left side of assignment '='."); } } else { tokenizer.pushBack(); break; } } return t1; }
@Test public void testPlusFour() { final Tokenizer tokenizer = new Tokenizer("+4"); assertEquals('+', tokenizer.next()); assertEquals('+', tokenizer.getType()); assertEquals("+", tokenizer.getToken()); assertEquals(Tokenizer.TT_INT, tokenizer.next()); assertEquals(Tokenizer.TT_INT, tokenizer.getType()); assertEquals("4", tokenizer.getToken()); assertEquals(Tokenizer.TT_EOS, tokenizer.next()); }
@Test public void testMinusFour() { final Tokenizer tokenizer = new Tokenizer("-4"); assertEquals('-', tokenizer.next()); assertEquals('-', tokenizer.getType()); assertEquals("-", tokenizer.getToken()); assertEquals(Tokenizer.TT_INT, tokenizer.next()); assertEquals(Tokenizer.TT_INT, tokenizer.getType()); assertEquals("4", tokenizer.getToken()); assertEquals(Tokenizer.TT_EOS, tokenizer.next()); }
tokenizer.next(); if (isKeyword("if")) { Term t1 = parseTerm(true); tokenizer.next(); if (isKeyword("then")) { Term t2 = parseTerm(true); tokenizer.next(); if (isKeyword("else")) { if (isTypeChecking() && !t1.isB()) { int tt = tokenizer.next(); if (tt == '?') { Term t2 = parseTerm(true); tt = tokenizer.next(); if (tt == ':') { if (isTypeChecking() && !t1.isB()) {
@Test public void testThreePlusFour() { final Tokenizer tokenizer = new Tokenizer("3+4"); assertEquals(Tokenizer.TT_INT, tokenizer.next()); assertEquals(Tokenizer.TT_INT, tokenizer.getType()); assertEquals("3", tokenizer.getToken()); assertEquals('+', tokenizer.next()); assertEquals('+', tokenizer.getType()); assertEquals("+", tokenizer.getToken()); assertEquals(Tokenizer.TT_INT, tokenizer.next()); assertEquals(Tokenizer.TT_INT, tokenizer.getType()); assertEquals("4", tokenizer.getToken()); assertEquals(Tokenizer.TT_EOS, tokenizer.next()); }
@Test public void testThreeMinusFour() { final Tokenizer tokenizer = new Tokenizer("3-4"); assertEquals(Tokenizer.TT_INT, tokenizer.next()); assertEquals(Tokenizer.TT_INT, tokenizer.getType()); assertEquals("3", tokenizer.getToken()); assertEquals('-', tokenizer.next()); assertEquals('-', tokenizer.getType()); assertEquals("-", tokenizer.getToken()); assertEquals(Tokenizer.TT_INT, tokenizer.next()); assertEquals(Tokenizer.TT_INT, tokenizer.getType()); assertEquals("4", tokenizer.getToken()); assertEquals(Tokenizer.TT_EOS, tokenizer.next()); }
/** * Parses a bitwise XOR expression <i>x '^' y</i>. * * @param required true, if the expression is required. * @return The generated term. * @throws ParseException if a parse error occurs */ private Term parseBtwiseXOr(final boolean required) throws ParseException { Term t1 = parseBitwiseAnd(required); while (t1 != null) { int tt = tokenizer.next(); if (tt == '^') { Term t2 = parseBitwiseAnd(true); if ((t1.isI() && t2.isI()) || !isTypeChecking()) { t1 = new Term.XOrI(t1, t2); } else { reportTypeErrorI2("'^'"); } } else { tokenizer.pushBack(); break; } } return t1; }
/** * Parses a bitwise OR expression <i>x '|' y</i>. * * @param required true, if the expression is required. * @return The generated term. * @throws ParseException if a parse error occurs */ private Term parseBitwiseOr(final boolean required) throws ParseException { Term t1 = parseBtwiseXOr(required); while (t1 != null) { int tt = tokenizer.next(); if (tt == '|') { Term t2 = parseBtwiseXOr(true); if ((t1.isI() && t2.isI()) || !isTypeChecking()) { t1 = new Term.OrI(t1, t2); } else { reportTypeErrorI2("'|'"); } } else { tokenizer.pushBack(); break; } } return t1; }
/** * Parses a bitwise AND expression <i>x '&' y</i>. * * @param required true, if the expression is required. * @return The generated term. * @throws ParseException if a parse error occurs */ private Term parseBitwiseAnd(final boolean required) throws ParseException { Term t1 = parseAdd(required); while (t1 != null) { int tt = tokenizer.next(); if (tt == '&') { Term t2 = parseAdd(true); if ((t1.isI() && t2.isI()) || !isTypeChecking()) { t1 = new Term.AndI(t1, t2); } else { reportTypeErrorI2("'&'"); } } else { tokenizer.pushBack(); break; } } return t1; }
private Term parseCallOrRef(final String name) throws ParseException { final int tt; Term t1 = null; tt = tokenizer.next(); if (tt == '(') { Term[] args = parseArgumentList(); Function function = defaultNamespace.resolveFunction(name, args); if (function != null) { t1 = new Term.Call(function, args); } else { reportError("Undefined function '" + getFunctionCallString(name, args) + "'."); /*I18N*/ } } else { tokenizer.pushBack(); Symbol symbol = defaultNamespace.resolveSymbol(name); if (symbol != null) { t1 = new Term.Ref(symbol); } else { reportError("Undefined symbol '" + name + "'."); /*I18N*/ } } return t1; }
/** * Parses a logical OR expression <i>x '||' y</i>. * * @param required true, if the expression is required. * @return The generated term. * @throws ParseException if a parse error occurs */ private Term parseLogicalOr(final boolean required) throws ParseException { Term t1 = parseLogicalAnd(required); while (t1 != null) { /*int tt =*/ tokenizer.next(); if (isSpecial("||") || isKeyword("or")) { Term t2 = parseLogicalAnd(true); if ((t1.isB() && t2.isB()) || !isTypeChecking()) { t1 = new Term.OrB(t1, t2); } else { reportTypeErrorB2("'||' or 'or'"); } } else { tokenizer.pushBack(); break; } } return t1; }
/** * Parses a logical AND expression <i>x '&&' y</i>. * * @param required true, if the expression is required. * @return The generated term. * @throws ParseException if a parse error occurs */ private Term parseLogicalAnd(final boolean required) throws ParseException { Term t1 = parseComparison(required); while (t1 != null) { /*int tt =*/ tokenizer.next(); if (isSpecial("&&") || isKeyword("and")) { Term t2 = parseComparison(true); if ((t1.isB() && t2.isB()) || !isTypeChecking()) { t1 = new Term.AndB(t1, t2); } else { reportTypeErrorB2("'&&' or 'and'"); } } else { tokenizer.pushBack(); break; } } return t1; }
Term t1 = parseMul(required); while (t1 != null) { int tt = tokenizer.next(); if (tt == '+') { Term t2 = parseMul(true);
final int tt = tokenizer.next(); if (tt == '+') { Term t2 = parseUnary(true);
Term t1 = parseUnary(required); while (t1 != null) { int tt = tokenizer.next(); if (tt == '*') { Term t2 = parseUnary(true);
Term t1 = parseBitwiseOr(required); while (t1 != null) { int tt = tokenizer.next(); if (tt == '<') { Term t2 = parseBitwiseOr(true);