From 79be979e1366a6cbb5b501a93e9f9354cef57c66 Mon Sep 17 00:00:00 2001 From: Apoorva Ranade Date: Tue, 9 Mar 2021 16:33:48 +0530 Subject: [PATCH] Added class analyze method --- .../common/analysis/types/ClassVType.java | 56 ++++++++++ .../common/analysis/types/FuncType.java | 4 +- .../common/analysis/types/FuncValueType.java | 49 +++++++++ .../java/chocopy/pa2/DeclarationAnalyzer.java | 102 +++++++++++++++--- 4 files changed, 194 insertions(+), 17 deletions(-) create mode 100644 src/main/java/chocopy/common/analysis/types/ClassVType.java create mode 100644 src/main/java/chocopy/common/analysis/types/FuncValueType.java diff --git a/src/main/java/chocopy/common/analysis/types/ClassVType.java b/src/main/java/chocopy/common/analysis/types/ClassVType.java new file mode 100644 index 0000000..42a312f --- /dev/null +++ b/src/main/java/chocopy/common/analysis/types/ClassVType.java @@ -0,0 +1,56 @@ +package chocopy.common.analysis.types; + +import chocopy.common.astnodes.ClassType; +import chocopy.common.astnodes.Identifier; + +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonProperty; +import chocopy.common.analysis.SymbolTable; +import java.util.Objects; + +/** Represents the semantic value of a simple class reference. */ +public class ClassVType extends ValueType { + + /** The name of the class. */ + private final String className; + public SymbolTable scope; + public Identifier super_class; + /** A class type for the class named CLASSNAME. */ + @JsonCreator + public ClassVType(@JsonProperty String className) { + this.className = className; + } + + /** A class type for the class referenced by CLASSTYPEANNOTATION. */ + public ClassVType(ClassType classTypeAnnotation) { + this.className = classTypeAnnotation.className; + } + + @Override + @JsonProperty + public String className() { + return className; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + ClassVType classType = (ClassVType) o; + return Objects.equals(className, classType.className); + } + + @Override + public int hashCode() { + return Objects.hash(className); + } + + @Override + public String toString() { + return className; + } +} diff --git a/src/main/java/chocopy/common/analysis/types/FuncType.java b/src/main/java/chocopy/common/analysis/types/FuncType.java index f729958..7d0f7a5 100644 --- a/src/main/java/chocopy/common/analysis/types/FuncType.java +++ b/src/main/java/chocopy/common/analysis/types/FuncType.java @@ -8,11 +8,9 @@ import java.util.List; /** Semantic information for a function or method. */ public class FuncType extends Type { - /** Function's name. */ - //public final String name; /** Types of parameters. */ - public List parameters; + public final List parameters; /** Function's return type. */ public final ValueType returnType; diff --git a/src/main/java/chocopy/common/analysis/types/FuncValueType.java b/src/main/java/chocopy/common/analysis/types/FuncValueType.java new file mode 100644 index 0000000..5e73b46 --- /dev/null +++ b/src/main/java/chocopy/common/analysis/types/FuncValueType.java @@ -0,0 +1,49 @@ +package chocopy.common.analysis.types; + +import com.fasterxml.jackson.annotation.JsonCreator; + +import java.util.ArrayList; +import java.util.List; + +/** Semantic information for a function or method. */ +public class FuncValueType extends Type { + + /** Function's name. */ + //public final String name; + + /** Types of parameters. */ + public List parameters; + /** Function's return type. */ + public final ValueType returnType; + + + /** Create a FuncType returning RETURNTYPE0, initially parameterless. */ + public FuncValueType(ValueType returnType0) { + this(new ArrayList<>(), returnType0); + } + + /** + * Create a FuncType for NAME0 with formal parameter types PARAMETERS0, returning type + * RETURNTYPE0. + */ + @JsonCreator + public FuncValueType(List parameters0, ValueType returnType0) { + this.parameters = parameters0; + this.returnType = returnType0; + } + + @Override + public boolean isFuncType() { + return true; + } + + /** Return the type of the K-th parameter. */ + public ValueType getParamType(int k) { + return parameters.get(k); + } + + @Override + public String toString() { + return ""; + } +} diff --git a/src/main/java/chocopy/pa2/DeclarationAnalyzer.java b/src/main/java/chocopy/pa2/DeclarationAnalyzer.java index 9f9673f..33bfe91 100644 --- a/src/main/java/chocopy/pa2/DeclarationAnalyzer.java +++ b/src/main/java/chocopy/pa2/DeclarationAnalyzer.java @@ -6,7 +6,8 @@ import chocopy.common.analysis.types.*; import chocopy.common.astnodes.*; /** Analyzes declarations to create a top-level symbol table. */ -public class DeclarationAnalyzer extends AbstractNodeAnalyzer { +public class DeclarationAnalyzer extends AbstractNodeAnalyzer +{ /** Current symbol table. Changes with new declarative region. */ private SymbolTable sym = new SymbolTable<>(); @@ -16,33 +17,63 @@ public class DeclarationAnalyzer extends AbstractNodeAnalyzer { private final Errors errors; /** A new declaration analyzer sending errors to ERRORS0. */ - public DeclarationAnalyzer(Errors errors0) { + public DeclarationAnalyzer(Errors errors0) + { errors = errors0; + ClassVType cvt = new ClassVType("object"); + FuncValueType init = new FuncValueType(Type.OBJECT_TYPE); + init.parameters.add(Type.OBJECT_TYPE); + sym.put("object", cvt); + cvt = new ClassVType("int"); + init = new FuncValueType(Type.INT_TYPE); + init.parameters.add(Type.INT_TYPE); + sym.put("int", cvt); + cvt = new ClassVType("str"); + init = new FuncValueType(Type.STR_TYPE); + init.parameters.add(Type.STR_TYPE); + sym.put("str", cvt); + cvt = new ClassVType("bool"); + init = new FuncValueType(Type.BOOL_TYPE); + init.parameters.add(Type.BOOL_TYPE); + sym.put("bool", cvt); } - public SymbolTable getGlobals() { + public SymbolTable getGlobals() + { return globals; } @Override - public Type analyze(Program program) { - for (Declaration decl : program.declarations) { + public Type analyze(Program program) + { + for (Declaration decl : program.declarations) + { Identifier id = decl.getIdentifier(); String name = id.name; Type type = decl.dispatch(this); - if (type == null) { + if (type == null) + { continue; } - if (sym.declares(name)) { + if (sym.declares(name)) + { errors.semError( id, "Duplicate declaration of identifier in same " + "scope: %s", name); - } else { + } + else + { sym.put(name, type); } } - + // Check for return statements at top + for (Stmt stmt : program.statements) + { + if (stmt instanceof ReturnStmt) + errors.semError( + stmt, "Return statement cannot appear at the top level"); + } return null; } @@ -52,7 +83,7 @@ public class DeclarationAnalyzer extends AbstractNodeAnalyzer { } @Override public Type analyze(FuncDef node) { - FuncType current_func=new FuncType((ValueType) node.returnType.dispatch(this)); + FuncValueType current_func=new FuncValueType((ValueType) node.returnType.dispatch(this)); SymbolTable current_scope=new SymbolTable<>(sym); sym=current_scope; for (TypedVar param : node.params) @@ -64,21 +95,21 @@ public class DeclarationAnalyzer extends AbstractNodeAnalyzer { node.name, "Duplicate declaration of identifier in same " + "scope: %s", param.identifier.name); continue; } - /* - else if (sym.get(param.identifier.name)!= null) + else if (sym.get(param.identifier.name)!= null && sym.get(param.identifier.name) instanceof ClassVType) { System.out.println("Error:"+sym.get(param.identifier.name)); errors.semError( node.name, "Parameter shadows class name: %s", param.identifier.name); continue; - }*/ + } Type p = param.dispatch(this); current_func.parameters.add((ValueType)p); sym.put(param.identifier.name, p); } - for (Declaration decl : node.declarations) { + for (Declaration decl : node.declarations) + { Identifier id = decl.getIdentifier(); String name = id.name; Type type = decl.dispatch(this); @@ -109,4 +140,47 @@ public class DeclarationAnalyzer extends AbstractNodeAnalyzer { } return globals.get(node.variable.name); } + @Override + public Type analyze(ClassDef node) + { + ClassVType cvt=new ClassVType(node.name.name); + SymbolTable current_scope=new SymbolTable<>(sym); + sym=current_scope; + Type super_class = sym.get(node.superClass.name); + cvt.super_class = node.superClass; + if (super_class == null) + { + errors.semError( + node.name, "Super-class not defined: %s", node.superClass.name); + } + else if ((super_class instanceof ClassVType)==false) + { + errors.semError( + node.name, "Super-class must be a class: %s", node.superClass.name); + } + else if (node.superClass.name.equals("int") || node.superClass.name.equals("bool") || node.superClass.name.equals("str")) + { + errors.semError( + node.name, "Cannot extend special class: %s", node.superClass.name); + } + else + { + for (Declaration decl : node.declarations) + { + Identifier id = decl.getIdentifier(); + String name = id.name; + Type type = decl.dispatch(this); + if (sym.declares(name)) { + errors.semError( + id, "Duplicate declaration of identifier in same " + "scope: %s", name); + } + else + { + sym.put(name, type); + } + } + } + sym = sym.getParent(); + return cvt; + } }