diff --git a/src/main/java/chocopy/common/analysis/SymbolTable.java b/src/main/java/chocopy/common/analysis/SymbolTable.java index 8e95e5a5a66ce3d7d51d31682683b882d22f729d..da10666416d6bf6b4afe0298346c21cb7d65fd2e 100644 --- a/src/main/java/chocopy/common/analysis/SymbolTable.java +++ b/src/main/java/chocopy/common/analysis/SymbolTable.java @@ -39,6 +39,8 @@ public class SymbolTable<T> { /** Adds a new mapping of NAME -> VALUE to the current region, possibly * shadowing mappings in the enclosing parent. Returns modified table. */ public SymbolTable<T> put(String name, T value) { + if(declares(name)) + throw new RuntimeException("SymbolTable: duplicate identifier " + name); tab.put(name, value); return this; } diff --git a/src/main/java/chocopy/common/astnodes/FuncDef.java b/src/main/java/chocopy/common/astnodes/FuncDef.java index 6c1c20351ea3d1739145f268a41f261a0417b0b0..35070d32f27bbbd61d720b89b641bedf9b16e8ef 100644 --- a/src/main/java/chocopy/common/astnodes/FuncDef.java +++ b/src/main/java/chocopy/common/astnodes/FuncDef.java @@ -3,6 +3,8 @@ package chocopy.common.astnodes; import java.util.List; import chocopy.common.analysis.NodeAnalyzer; +import chocopy.common.analysis.SymbolTable; +import chocopy.common.analysis.types.SymbolType; import java_cup.runtime.ComplexSymbolFactory.Location; /** Def statements. */ @@ -19,6 +21,9 @@ public class FuncDef extends Declaration { /** Other statements. */ public final List<Stmt> statements; + // Recolic + public SymbolTable<SymbolType> symTable = null; + /** The AST for * def NAME(PARAMS) -> RETURNTYPE: * DECLARATIONS diff --git a/src/main/java/chocopy/pa2/DeclarationAnalyzer.java b/src/main/java/chocopy/pa2/DeclarationAnalyzer.java index 5f0814af62eaa370141cc59f11b2a6a4e7f84335..1130fe7626dfa10b5394ba1e4a2155fef51387aa 100644 --- a/src/main/java/chocopy/pa2/DeclarationAnalyzer.java +++ b/src/main/java/chocopy/pa2/DeclarationAnalyzer.java @@ -2,14 +2,15 @@ package chocopy.pa2; import chocopy.common.analysis.AbstractNodeAnalyzer; import chocopy.common.analysis.SymbolTable; +import chocopy.common.analysis.types.ClassValueType; +import chocopy.common.analysis.types.FuncType; import chocopy.common.analysis.types.SymbolType; import chocopy.common.analysis.types.ValueType; import chocopy.common.astnodes.*; -import javax.management.RuntimeErrorException; - /** * Analyzes declarations to create a top-level symbol table. + * Recolic: This class will ONLY fill the symTable. Every `Program` and `FuncDef` has a sym table. */ public class DeclarationAnalyzer extends AbstractNodeAnalyzer<SymbolType> { @@ -37,19 +38,14 @@ public class DeclarationAnalyzer extends AbstractNodeAnalyzer<SymbolType> { String name = id.name; SymbolType type = decl.dispatch(this); + System.out.println("decl type " + type.toString()); + // recolic: what's the teacher willing to do??? if (type == null) { continue; } - if (sym.declares(name)) { - errors.semError(id, - "Duplicate declaration of identifier in same " - + "scope: %s", - name); - } else { - sym.put(name, type); - } + sym.put(name, type); } return null; @@ -57,14 +53,45 @@ public class DeclarationAnalyzer extends AbstractNodeAnalyzer<SymbolType> { @Override public SymbolType analyze(VarDef varDef) { + System.out.println("debug"); return analyze(varDef.var); } + @Override + public SymbolType analyze(ClassDef classDef) { + System.out.println("debug: classdef"); + // TODO: check how do I create a obj type. + return new ClassValueType(classDef.name.name); + } + + @Override + public SymbolType analyze(FuncDef funcDef) { + System.out.println("debug: start funcDef"); + assert funcDef.symTable == null; + sym = funcDef.symTable = new SymbolTable<>(sym); + + // Func parameter list + for(TypedVar param : funcDef.params) { + String name = param.identifier.name; + sym.put(name, analyze(param)); + } + + for(Declaration decl : funcDef.declarations) { + String name = decl.getIdentifier().name; + SymbolType type = decl.dispatch(this); + sym.put(name, type); + } + + return new FuncType(ValueType.annotationToValueType(funcDef.returnType)); + } + @Override public SymbolType analyze(TypedVar node) { return ValueType.annotationToValueType(node.type); } + + /* @Override public SymbolType analyze(BinaryExpr node) { String op = node.operator; @@ -130,6 +157,7 @@ public class DeclarationAnalyzer extends AbstractNodeAnalyzer<SymbolType> { return result_type; } + */ }