/** * Compiles a statement (or a block). * <code>recordParams()</code> must be called before invoking * this method. * * <p>Local variables that are not declared * in the compiled source text might not be accessible within that * source text. Fields and method parameters ($0, $1, ..) are available. */ public void compileStmnt(String src) throws CompileError { Parser p = new Parser(new Lex(src)); SymbolTable stb = new SymbolTable(stable); while (p.hasMore()) { Stmnt s = p.parseStatement(stb); if (s != null) s.accept(gen); } }
private ASTree binaryExpr2(SymbolTable tbl, ASTree expr, int prec) throws CompileError { int t = lex.get(); if (t == INSTANCEOF) return parseInstanceOf(tbl, expr); ASTree expr2 = parseUnaryExpr(tbl); for (;;) { int t2 = lex.lookAhead(); int p2 = getOpPrecedence(t2); if (p2 != 0 && prec > p2) expr2 = binaryExpr2(tbl, expr2, p2); else return BinExpr.makeBin(t, expr, expr2); } }
public ASTree parseExpression(SymbolTable tbl) throws CompileError { ASTree left = parseConditionalExpr(tbl); if (!isAssignOp(lex.lookAhead())) return left; int t = lex.get(); ASTree right = parseExpression(tbl); return AssignExpr.makeAssign(t, left, right); }
private ASTree parseBinaryExpr(SymbolTable tbl) throws CompileError { ASTree expr = parseUnaryExpr(tbl); for (;;) { int t = lex.lookAhead(); int p = getOpPrecedence(t); if (p == 0) return expr; else expr = binaryExpr2(tbl, expr, p); } }
private Stmnt parseWhile(SymbolTable tbl) throws CompileError { int t = lex.get(); // WHILE ASTree expr = parseParExpression(tbl); Stmnt body = parseStatement(tbl); return new Stmnt(t, expr, body); }
return parseBlock(tbl); else if (t == ';') { lex.get(); return Stmnt.make(LABEL, new Symbol(label), parseStatement(tbl)); return parseIf(tbl); else if (t == WHILE) return parseWhile(tbl); else if (t == DO) return parseDo(tbl); else if (t == FOR) return parseFor(tbl); else if (t == TRY) return parseTry(tbl); else if (t == SWITCH) return parseSwitch(tbl); else if (t == SYNCHRONIZED) return parseSynchronized(tbl); else if (t == RETURN) return parseReturn(tbl); else if (t == THROW) return parseThrow(tbl); else if (t == BREAK) return parseBreak(tbl); else if (t == CONTINUE) return parseContinue(tbl); else return parseDeclarationOrExpression(tbl, false);
private ASTree parseCast(SymbolTable tbl) throws CompileError { int t = lex.lookAhead(1); if (isBuiltinType(t) && nextIsBuiltinCast()) { lex.get(); // '(' lex.get(); // primitive type int dim = parseArrayDimension(); if (lex.get() != ')') throw new CompileError(") is missing", lex); return new CastExpr(t, dim, parseUnaryExpr(tbl)); } else if (t == Identifier && nextIsClassCast()) { lex.get(); // '(' ASTList name = parseClassType(tbl); int dim = parseArrayDimension(); if (lex.get() != ')') throw new CompileError(") is missing", lex); return new CastExpr(name, dim, parseUnaryExpr(tbl)); } else return parsePostfix(tbl); }
if (isBuiltinType(t)) { t = lex.get(); int dim = parseArrayDimension(); return parseDeclarators(tbl, new Declarator(t, dim)); int i = nextIsClassType(0); if (i >= 0) if (lex.lookAhead(i) == Identifier) { ASTList name = parseClassType(tbl); int dim = parseArrayDimension(); return parseDeclarators(tbl, new Declarator(name, dim)); expr = parseExprList(tbl); else expr = new Stmnt(EXPR, parseExpression(tbl));
private Declarator parseFormalType(SymbolTable tbl) throws CompileError { int t = lex.lookAhead(); if (isBuiltinType(t) || t == VOID) { lex.get(); // primitive type int dim = parseArrayDimension(); return new Declarator(t, dim); } else { ASTList name = parseClassType(tbl); int dim = parseArrayDimension(); return new Declarator(name, dim); } }
/** * Parsers an expression. */ public static ASTree parseExpr(String src, SymbolTable st) throws CompileError { Parser p = new Parser(new Lex(src)); return p.parseExpression(st); }
private NewExpr parseNew(SymbolTable tbl) throws CompileError { ArrayInit init = null; int t = lex.lookAhead(); if (isBuiltinType(t)) { lex.get(); ASTList size = parseArraySize(tbl); if (lex.lookAhead() == '{') init = parseArrayInitializer(tbl); return new NewExpr(t, size, init); } else if (t == Identifier) { ASTList name = parseClassType(tbl); t = lex.lookAhead(); if (t == '(') { ASTList args = parseArgumentList(tbl); return new NewExpr(name, args); } else if (t == '[') { ASTList size = parseArraySize(tbl); if (lex.lookAhead() == '{') init = parseArrayInitializer(tbl); return NewExpr.makeObjectArray(name, size, init); } } throw new SyntaxError(lex); }
return new StringL(lex.getString()); case NEW : return parseNew(tbl); case '(' : expr = parseExpression(tbl); if (lex.get() == ')') return expr; throw new CompileError(") is missing", lex); default : if (isBuiltinType(t) || t == VOID) { int dim = parseArrayDimension(); if (lex.get() == '.' && lex.get() == CLASS) return parseDotClass(t, dim);
private Stmnt parseFor(SymbolTable tbl) throws CompileError { Stmnt expr1, expr3; ASTree expr2; int t = lex.get(); // FOR SymbolTable tbl2 = new SymbolTable(tbl); if (lex.get() != '(') throw new SyntaxError(lex); if (lex.lookAhead() == ';') { lex.get(); expr1 = null; } else expr1 = parseDeclarationOrExpression(tbl2, true); if (lex.lookAhead() == ';') expr2 = null; else expr2 = parseExpression(tbl2); if (lex.get() != ';') throw new CompileError("; is missing", lex); if (lex.lookAhead() == ')') expr3 = null; else expr3 = parseExprList(tbl2); if (lex.get() != ')') throw new CompileError(") is missing", lex); Stmnt body = parseStatement(tbl2); return new Stmnt(t, expr1, new ASTList(expr2, new ASTList(expr3, body))); }
private Stmnt parseStmntOrCase(SymbolTable tbl) throws CompileError { int t = lex.lookAhead(); if (t != CASE && t != DEFAULT) return parseStatement(tbl); lex.get(); Stmnt s; if (t == CASE) s = new Stmnt(t, parseExpression(tbl)); else s = new Stmnt(DEFAULT); if (lex.get() != ':') throw new CompileError(": is missing", lex); return s; }
Parser p = new Parser(new Lex(src)); ASTList mem = p.parseMember1(stable); try { if (mem instanceof FieldDecl)
private boolean nextIsClassCast() { int i = nextIsClassType(1); if (i < 0) return false; int t = lex.lookAhead(i); if (t != ')') return false; t = lex.lookAhead(i + 1); return t == '(' || t == NULL || t == StringL || t == Identifier || t == THIS || t == SUPER || t == NEW || t == TRUE || t == FALSE || t == LongConstant || t == IntConstant || t == CharConstant || t == DoubleConstant || t == FloatConstant; }
private Stmnt parseBlock(SymbolTable tbl) throws CompileError { if (lex.get() != '{') throw new SyntaxError(lex); Stmnt body = null; SymbolTable tbl2 = new SymbolTable(tbl); while (lex.lookAhead() != '}') { Stmnt s = parseStatement(tbl2); if (s != null) body = (Stmnt)ASTList.concat(body, new Stmnt(BLOCK, s)); } lex.get(); // '}' if (body == null) return new Stmnt(BLOCK); // empty block else return body; }
return parseBlock(tbl); else if (t == ';') { lex.get(); return Stmnt.make(LABEL, new Symbol(label), parseStatement(tbl)); return parseIf(tbl); else if (t == WHILE) return parseWhile(tbl); else if (t == DO) return parseDo(tbl); else if (t == FOR) return parseFor(tbl); else if (t == TRY) return parseTry(tbl); else if (t == SWITCH) return parseSwitch(tbl); else if (t == SYNCHRONIZED) return parseSynchronized(tbl); else if (t == RETURN) return parseReturn(tbl); else if (t == THROW) return parseThrow(tbl); else if (t == BREAK) return parseBreak(tbl); else if (t == CONTINUE) return parseContinue(tbl); else return parseDeclarationOrExpression(tbl, false);
private ASTree parseCast(SymbolTable tbl) throws CompileError { int t = lex.lookAhead(1); if (isBuiltinType(t) && nextIsBuiltinCast()) { lex.get(); // '(' lex.get(); // primitive type int dim = parseArrayDimension(); if (lex.get() != ')') throw new CompileError(") is missing", lex); return new CastExpr(t, dim, parseUnaryExpr(tbl)); } else if (t == Identifier && nextIsClassCast()) { lex.get(); // '(' ASTList name = parseClassType(tbl); int dim = parseArrayDimension(); if (lex.get() != ')') throw new CompileError(") is missing", lex); return new CastExpr(name, dim, parseUnaryExpr(tbl)); } else return parsePostfix(tbl); }
if (isBuiltinType(t)) { t = lex.get(); int dim = parseArrayDimension(); return parseDeclarators(tbl, new Declarator(t, dim)); int i = nextIsClassType(0); if (i >= 0) if (lex.lookAhead(i) == Identifier) { ASTList name = parseClassType(tbl); int dim = parseArrayDimension(); return parseDeclarators(tbl, new Declarator(name, dim)); expr = parseExprList(tbl); else expr = new Stmnt(EXPR, parseExpression(tbl));