Esempio n. 1
0
 public void VisitNode(AbstractNode node)
 {
     VisitChildren(node);
 }
Esempio n. 2
0
        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;
            }
        }
Esempio n. 3
0
        private void VisitNode(SelectionStatement node)
        {
            AbstractNode ifExp    = node.Child;
            AbstractNode thanStmt = ifExp.Sib;
            AbstractNode elseStmt = thanStmt.Sib;   // may be null

            SelectionStatementDescriptor ssDesc =
                new SelectionStatementDescriptor();

            String errMsg = "";

            // if expression
            ifExp.Accept(this);
            ssDesc.IfDescriptor = ifExp.TypeDescriptor;
            PrimitiveTypeBooleanDescriptor ifBoolDesc =
                ifExp.TypeDescriptor as PrimitiveTypeBooleanDescriptor;

            if (ifBoolDesc == null)
            {
                ifExp.TypeDescriptor = new ErrorDescriptor("If statement " +
                                                           "does not evaluate to a Boolean expression. (Has type: " +
                                                           ifExp.TypeDescriptor.GetType().Name + ")");
            }
            // than statement
            thanStmt.Accept(this);
            thanStmt.TypeDescriptor = thanStmt.Child.TypeDescriptor;
            ssDesc.ThanDescriptor   = thanStmt.TypeDescriptor;
            if (!IsCompatibleStatement(thanStmt.TypeDescriptor))
            {
                if (errMsg.Length > 0)
                {
                    errMsg += "\n";
                }
                errMsg += "Non-compatible THAN statement type: " +
                          thanStmt.TypeDescriptor.GetType().Name;
            }
            // else statement
            if (elseStmt != null)
            {
                elseStmt.Accept(this);
                ssDesc.HasElseStmt      = true;
                elseStmt.TypeDescriptor = elseStmt.Child.TypeDescriptor;
                ssDesc.ElseDescriptor   = elseStmt.TypeDescriptor;
                if (!IsCompatibleStatement(elseStmt.TypeDescriptor))
                {
                    if (errMsg.Length > 0)
                    {
                        errMsg += "\n";
                    }
                    errMsg += "Non-compatible ELSE statement type: " +
                              elseStmt.TypeDescriptor.GetType().Name;
                }
            }
            else
            {
                ssDesc.HasElseStmt = false;
            }

            // if any components have errors, propogate them up the tree
            if (ifExp.TypeDescriptor is ErrorDescriptor ||
                thanStmt.TypeDescriptor is ErrorDescriptor ||
                elseStmt?.TypeDescriptor is ErrorDescriptor)
            {
                // creates an error containing any and all errors lower in tree
                if (ifExp.TypeDescriptor is ErrorDescriptor)
                {
                    ssDesc.TypeDescriptor = ifExp.TypeDescriptor;
                    if (thanStmt.TypeDescriptor is ErrorDescriptor)
                    {
                        ((ErrorDescriptor)ssDesc.TypeDescriptor).CombineErrors
                            ((ErrorDescriptor)thanStmt.TypeDescriptor);
                    }
                    if (elseStmt?.TypeDescriptor is ErrorDescriptor)
                    {
                        ((ErrorDescriptor)ssDesc.TypeDescriptor).CombineErrors
                            ((ErrorDescriptor)elseStmt.TypeDescriptor);
                    }
                }
                else if (thanStmt.TypeDescriptor is ErrorDescriptor)
                {
                    ssDesc.TypeDescriptor = thanStmt.TypeDescriptor;
                    if (elseStmt?.TypeDescriptor is ErrorDescriptor)
                    {
                        ((ErrorDescriptor)ssDesc.TypeDescriptor).CombineErrors
                            ((ErrorDescriptor)elseStmt.TypeDescriptor);
                    }
                }
                else
                {
                    ssDesc.TypeDescriptor = elseStmt.TypeDescriptor;
                }
            }
            // if IF/THAN/ELSE was incompatible, create new error
            else if (errMsg.Length > 0)
            {
                ssDesc.TypeDescriptor = new ErrorDescriptor(errMsg);
            }
            // otherwise assign evaluated boolean to selection statement desc
            else
            {
                ssDesc.TypeDescriptor = ifExp.TypeDescriptor;
            }
            node.TypeDescriptor = ssDesc;
        }
Esempio n. 4
0
        private TypeDescriptor AssignmentExp(AbstractNode qualName, AbstractNode exp)
        {
            QualifiedName     name       = qualName as QualifiedName;
            Expression        expression = exp as Expression;
            PrimaryExpression primaryExp = exp as PrimaryExpression;

            TypeDescriptor nameDesc;

            if (name != null && (expression != null || primaryExp != null))
            {
                Attributes nameAttr = Table.lookup(name.GetStringName());
                qualName.AttributesRef  = nameAttr;
                qualName.TypeDescriptor = nameAttr.TypeDescriptor;

                exp.Accept(this);

                // Check for errors
                // if both types are Error Descriptors, combine errors
                ErrorDescriptor nameErrDesc =
                    nameAttr.TypeDescriptor as ErrorDescriptor;
                ErrorDescriptor expErrDesc =
                    exp.TypeDescriptor as ErrorDescriptor;
                if (nameErrDesc != null && expErrDesc != null)
                {
                    nameDesc = nameErrDesc.CombineErrors(expErrDesc);
                }
                // if one or the other is an error, propagate the error up
                else if (nameErrDesc != null)
                {
                    nameDesc = nameAttr.TypeDescriptor;
                }
                else if (expErrDesc != null)
                {
                    nameDesc = exp.TypeDescriptor;
                }
                // check that the variable being assigned to is assignable
                else if (nameAttr.IsAssignable)
                {
                    // if types compatible, assign successfully assigned type
                    if (TypesCompatible(nameAttr.TypeDescriptor,
                                        exp.TypeDescriptor))
                    {
                        nameDesc = GetAssignmentDesc(nameAttr.TypeDescriptor,
                                                     exp.TypeDescriptor);
                    }
                    // otherwise, assign new error for incompatible types
                    else
                    {
                        nameDesc = new ErrorDescriptor("Incompatible types: " +
                                                       "cannot assign " + GetSimpleName(exp.TypeDescriptor)
                                                       + " to " + GetSimpleName(nameAttr.TypeDescriptor) +
                                                       " variable");
                    }
                }
                // variable is not assignable
                else
                {
                    nameDesc = new ErrorDescriptor(nameAttr +
                                                   " is not assigable. Cannot assign as " +
                                                   GetSimpleName(exp.TypeDescriptor));
                }
            }
            // Assignment not made up of correct parts
            else
            {
                string message = "";
                if (name == null && expression == null)
                {
                    message += "EQUALS expression expects 'QualifiedName' " +
                               "on LHS, but has: " + qualName.GetType().Name +
                               " & 'Expression' or 'PrimaryExression' on " +
                               "RHS, but has " + exp.GetType().Name;
                }
                else if (name == null)
                {
                    message += "EQUALS expression expects 'QualifiedName' on" +
                               " LHS, but has: " + qualName.GetType().Name;
                }
                else
                {
                    message += "EQUALS expression expects 'Expression' or " +
                               "'PrimaryExpression' on RHS, but has: " +
                               exp.GetType().Name;
                }
                nameDesc = new ErrorDescriptor(message);
            }
            return(nameDesc);
        }
Esempio n. 5
0
 public void CreateIlFileContent(AbstractNode node)
 {
     node?.Accept(this);
 }
Esempio n. 6
0
 private string GetIlType(AbstractNode node)
 {
     return(GetIlType(node.TypeDescriptor, node));
 }
Esempio n. 7
0
        private string GetIlTypeParam(AbstractNode node)
        {
            AbstractNode typeSpecifier = node.Child;

            return($"{GetIlType(typeSpecifier)}");
        }
Esempio n. 8
0
 private new void VisitNode(AbstractNode node)
 {
     VisitChildren(node);
 }
Esempio n. 9
0
        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();
        }