// TODO: structs added as requirement // TypeDeclaring (n/a only for array and struct types) private void VisitNode(ClassDeclaration node) { AbstractNode modifiers = node.Child; AbstractNode identifier = modifiers.Sib; AbstractNode classBody = identifier.Sib; ClassTypeDescriptor classDesc = new ClassTypeDescriptor(); classDesc.ClassBody = new ScopeTable(); Modifiers mods = modifiers as Modifiers; if (mods != null) { classDesc.Modifiers = mods.ModifierTokens; } else { node.TypeDescriptor = new ErrorDescriptor("Expected " + "modifier node, found: " + nameof(node)); } Attr attr = new Attr(); attr.Kind = Kind.ClassType; attr.TypeDescriptor = classDesc; string id = ((Identifier)identifier).ID; Table.enter(id, attr); CurrentClass = classDesc; node.TypeDescriptor = classDesc; node.AttributesRef = attr; // push the class body scope table onto the symbol table stack Table.openScope (((ClassTypeDescriptor)attr.TypeDescriptor).ClassBody); AbstractNode fieldDecls = classBody.Child; // grammar allows one class: if body empty, parsing complete if (fieldDecls == null) { return; } fieldDecls.Accept(this); Table.closeScope(); CurrentClass = null; }
private void VisitNode(PrimitiveTypeBoolean node) { Attributes attr = new Attr(node.TypeDescriptor); node.AttributesRef = attr; }
private void VisitNode(MethodCall node) { AbstractNode methodReference = node.Child; AbstractNode argumentList = methodReference.Sib; // may be null TypeDescriptor descriptor; QualifiedName qualifiedName = methodReference as QualifiedName; if (qualifiedName == null) { descriptor = new ErrorDescriptor ("Only Qualified Name supported for Method Call reference"); } else { // get parameters from method call List <TypeDescriptor> argListTypes = GetParameterTypes(argumentList as ArgumentList); // get parameters (signature) from declared method Attributes attr = Table.lookup(qualifiedName.GetStringName()); MethodTypeDescriptor methodDescriptor = attr.TypeDescriptor as MethodTypeDescriptor; if (methodDescriptor != null) { SignatureDescriptor methodSignature = methodDescriptor.Signature; if (methodSignature != null && ParametersMatch(methodSignature, argListTypes)) { // method descriptor for only current signature MethodTypeDescriptor temp = new MethodTypeDescriptor(); temp.ReturnType = methodDescriptor.ReturnType; temp.Signature.ParameterTypes = argListTypes; temp.Signature.Next = null; descriptor = temp; } else if (methodSignature == null) { descriptor = new ErrorDescriptor ("No signature found for method: " + qualifiedName.GetStringName()); } else { descriptor = new ErrorDescriptor ("No method signature found matching: (" + String.Join(", ", argListTypes) + ")"); } } else { descriptor = new ErrorDescriptor("Method not declared: " + qualifiedName.GetStringName()); } node.TypeDescriptor = descriptor; Attributes methodCallAttr = new Attr(descriptor); methodCallAttr.Kind = Kind.MethodType; node.AttributesRef = methodCallAttr; } }
private void setBaseline() { ScopeTable currScopeTable = symbolTable.Pop(); // Until given additional info, Java objects are placeholders Attr javaAttr = new Attr(new JavaObjectDescriptor()); javaAttr.Kind = Kind.TypeAttributes; currScopeTable.Add("java", javaAttr); currScopeTable.Add("io", javaAttr); currScopeTable.Add("lang", javaAttr); currScopeTable.Add("System", javaAttr); currScopeTable.Add("out", javaAttr); currScopeTable.Add("print", javaAttr); currScopeTable.Add("outint", javaAttr); currScopeTable.Add("PrintStream", javaAttr); currScopeTable.Add("TestClasses", javaAttr); // primitive types PrimitiveAttributes primVoidAttrs = new PrimitiveAttributes(new PrimitiveTypeVoidDescriptor()); currScopeTable.Add("VOID", primVoidAttrs); PrimitiveAttributes primIntAttrs = new PrimitiveAttributes(new PrimitiveTypeIntDescriptor()); currScopeTable.Add("INT", primIntAttrs); PrimitiveAttributes primBooleanAttrs = new PrimitiveAttributes(new PrimitiveTypeBooleanDescriptor()); currScopeTable.Add("BOOLEAN", primBooleanAttrs); // special names SpecialNameAttributes spNameThis = new SpecialNameAttributes (SpecialNameEnums.THIS); currScopeTable.Add(spNameThis.Name, spNameThis); SpecialNameAttributes spNameNull = new SpecialNameAttributes( SpecialNameEnums.NULL); currScopeTable.Add(spNameNull.Name, spNameNull); // Write & WriteLine PrimitiveTypeVoidDescriptor returnType = new PrimitiveTypeVoidDescriptor(); // no parameters SignatureDescriptor sigDescNone = new SignatureDescriptor(); // integer parameter SignatureDescriptor sigDescInt = new SignatureDescriptor(); sigDescInt.AddParameter(new PrimitiveTypeIntDescriptor()); // boolean parameter SignatureDescriptor sigDescBoolean = new SignatureDescriptor(); sigDescBoolean.AddParameter(new PrimitiveTypeBooleanDescriptor()); // literal parameter (string) SignatureDescriptor sigDescLiteral = new SignatureDescriptor(); sigDescLiteral.AddParameter(new LiteralTypeDescriptor()); // chain signature type descriptors together (sigDescNode = first) sigDescNone.Next = sigDescInt; sigDescInt.Next = sigDescBoolean; sigDescBoolean.Next = sigDescLiteral; MethodTypeDescriptor methodTypeDescriptor = new MethodTypeDescriptor(); methodTypeDescriptor.ReturnType = returnType; methodTypeDescriptor.Signature = sigDescNone; Attr methodAttr = new Attr(methodTypeDescriptor); currScopeTable.Add("Write", methodAttr); currScopeTable.Add("WriteLine", methodAttr); // TODO: add additional baseline information symbolTable.Push(currScopeTable); }
private void VisitNode(MethodDeclaration node) { AbstractNode modifiers = node.Child; AbstractNode typeSpecifier = modifiers.Sib; AbstractNode methodDeclarator = typeSpecifier.Sib; AbstractNode methodBody = methodDeclarator.Sib; AbstractNode retType = typeSpecifier.Child; if (retType is PrimitiveTypeVoid) { ((PrimitiveTypeVoid)retType).Accept(TypeVisitor); } else if (retType is PrimitiveTypeBoolean) { ((PrimitiveTypeBoolean)retType).Accept(TypeVisitor); } else if (retType is PrimitiveTypeInt) { ((PrimitiveTypeInt)retType).Accept(TypeVisitor); } else if (retType is QualifiedName) { ((QualifiedName)retType).Accept(TypeVisitor); } else { string msg = "Return type of a method must be a " + "PrimitiveType or QualifiedName (found: " + GetSimpleName(retType.TypeDescriptor); retType.TypeDescriptor = new ErrorDescriptor(msg); } AbstractNode methodDeclaratorName = methodDeclarator.Child; AbstractNode parameterList = methodDeclaratorName.Sib; // may be null MethodTypeDescriptor methDesc = new MethodTypeDescriptor(); methDesc.ReturnType = retType.TypeDescriptor; methDesc.Modifiers = ((Modifiers)modifiers).ModifierTokens; methDesc.Locals = new ScopeTable(); methDesc.IsDefinedIn = CurrentClass; Attributes attr = new Attr(methDesc); attr.Kind = Kind.MethodType; string name = ((Identifier)methodDeclaratorName).ID; Table.enter(name, attr); node.TypeDescriptor = attr.TypeDescriptor; node.AttributesRef = attr; Table.openScope(methDesc.Locals); MethodTypeDescriptor oldCurrentMethod = CurrentMethod; CurrentMethod = methDesc; if (parameterList != null) { parameterList.Accept(this); methDesc.Signature.ParameterTypes = ((ParameterListTypeDescriptor) parameterList.TypeDescriptor).ParamTypeDescriptors; attr.TypeDescriptor = methDesc; Table.updateValue(name, attr); node.TypeDescriptor = methDesc; node.AttributesRef = Table.lookup(name); } methodBody.Accept(this); CurrentMethod = oldCurrentMethod; Table.closeScope(); }