/** Performs semantic analysis on the function's signature and return type, but not the body. */ public void analyzeSignature(Log log, SymbolTable table, Subroutine owner, boolean inLoop) { SymbolTable tableForParameters; body.createTable(table); tableForParameters = body.getTable(); for (Variable parameter : parameters) { tableForParameters.insert(parameter, log); parameter.analyze(log, tableForParameters, owner, inLoop); } }
private Symbol tryDeclareSymbol(Token ident) { assert (ident.is(Token.Kind.IDENTIFIER)); String name = ident.lexeme(); try { symbolTable.insert(name); return new Symbol(name); } catch (RedeclarationError re) { String message = reportDeclareSymbolError(name, ident.lineNumber(), ident.charPosition()); return new ErrorSymbol(message); } }
@Override public void analyze(Log log, SymbolTable outer, Subroutine owner, boolean inLoop) { List<Subroutine> subroutines = getSubroutines(); // Create the table if it hasn't already been created. For blocks that are bodies of // functions or loops, the analyze() method of the function or loop will have created this // table already, since it is the table in which the parameters or loop indices belong. // For blocks that are entire scripts, the table will have already been created, too. // All other blocks will need their tables created here. if (table == null) { table = new SymbolTable(outer); } // Insert the routines into the table, but analyze ONLY the parameters and return types. // We can't analyze the function bodies until all the functions have been put into the // table (with analyzed parameters) because within any function body there can be a call // to any other function, and we have to be able to analyze the call. Notice also that the // functions are going in before any variables are being looked at since variables can call // any function in their initializing expressions. for (Subroutine subroutine : subroutines) { subroutine.analyzeSignature(log, table, owner, inLoop); table.insert(subroutine, log); } // Now just go through all the items in order and analyze everything, making sure to // insert variables because they have not yet been inserted. for (Statement s : statements) { if (s instanceof DecStatement) { DecStatement d = (DecStatement) s; for (String t : d.getNames()) { table.insert(new Variable(t), log); } } s.analyze(log, table, owner, inLoop); } }