示例#1
0
 public override void Visit(AssignmentStatementNode node)
 {
     Console.WriteLine(this.indentation + "=          ---- Assignment Statement ----");
     indentation = indentation + "   ";
     node.identifier.Accept(this);
     node.expression.Accept(this);
     indentation = indentation.Substring(0, indentation.Length - 3);
 }
示例#2
0
 private void Write(AssignmentStatementNode stmt)
 {
     Fill();
     foreach (var expression in stmt.Children.GetRange(0, stmt.Children.Count - 1))
     {
         Write(expression);
         _code.Append(" = ");
     }
     Write(stmt.Children.Last());
 }
示例#3
0
        private static PythonNode Wrap(AssignmentStatement stmt, PythonNode parent)
        {
            var result = new AssignmentStatementNode(stmt)
            {
                Parent = parent
            };

            foreach (var expression in stmt.Left)
            {
                result.AddChild(Wrap(expression, result));
            }
            result.AddChild(Wrap(stmt.Right, result));
            return(result);
        }
示例#4
0
        public override void Visit(AssignmentStatementNode node)
        {
            try
            {
                node.expression.Accept(this);

                if (!AreTypeCompatible(LookupSymbolType(node.identifier.name).GetType(), node.expression.ExpressionType.GetType()) ||
                    (LookupSymbolType(node.identifier.name).GetType() == typeof(ClassType) && !IsClassCompatible((ClassType)LookupSymbolType(node.identifier.name), (ClassType)node.expression.ExpressionType)))
                {
                    throw new Exception("Type Mismatch in Assignment Statement!");
                }
            }
            catch (Exception e)
            {
                Analysis.LogSemanticError(e.Message, node.lineNumber);
            }
        }
示例#5
0
 public override void Visit(AssignmentStatementNode node)
 {
     node.expression.Accept(this);
     if (MethodBeingVisited.LocalVariables.Contains(node.identifier.name))
     {
         VariableDefinition LocalVariableDefinition = MethodBeingVisited.LocalVariables.Lookup(node.identifier.name);
         Gen("mov", "[ebp-" + LocalVariableDefinition.Location.ToString() + "]", "eax", "Assigning eax into variable " + LocalVariableDefinition.Name);
     }
     else if (MethodBeingVisited.Parameters.Contains(node.identifier.name))
     {
         ParameterDefinition parameterDefinition = MethodBeingVisited.Parameters.Lookup(node.identifier.name);
         Gen("mov", "[ebp+" + parameterDefinition.Location.ToString() + "]", "eax", "Assigning eax into parameter " + parameterDefinition.Name);
     }
     else
     {
         FieldDefinition fieldDefinition = Analysis.Environment.LookupFieldInClass(node.identifier.name, ClassBeingVisited);
         Gen("mov", "[ecx+" + fieldDefinition.Location.ToString() + "]", "eax", "Assigning eax into field " + fieldDefinition.Name);
     }
 }
示例#6
0
    protected override void DoAction(int action)
    {
        switch (action)
        {
        case 2: // Program -> MainClassDecl, ClassDeclList_Opt
        { CurrentSemanticValue = new ProgramNode((MainClassDeclNode)ValueStack[ValueStack.Depth - 2], (ClassDeclListNode)ValueStack[ValueStack.Depth - 1], LineNumber); Analysis.AST = (ProgramNode)CurrentSemanticValue; }
        break;

        case 3: // MainClassDecl -> ClassKeyword, Identifier, CurlyBracketOpen, PublicKeyword,
                //                  StaticKeyword, VoidKeyword, MainKeyword, RoundBracketOpen,
                //                  StringKeyword, SquareBracketOpen, SquareBracketClose,
                //                  Identifier, RoundBracketClose, CurlyBracketOpen, Statement,
                //                  CurlyBracketClose, CurlyBracketClose
        { CurrentSemanticValue = new MainClassDeclNode((IdentifierNode)ValueStack[ValueStack.Depth - 16], (IdentifierNode)ValueStack[ValueStack.Depth - 6], (StatementNode)ValueStack[ValueStack.Depth - 3], LineNumber); }
        break;

        case 4: // ClassDeclList_Opt -> ClassDeclList_Opt, ClassDecl
        { ((ClassDeclListNode)ValueStack[ValueStack.Depth - 2]).AddClassDecl((ClassDeclNode)ValueStack[ValueStack.Depth - 1]); CurrentSemanticValue = ValueStack[ValueStack.Depth - 2]; }
        break;

        case 5: // ClassDeclList_Opt -> /* empty */
        { CurrentSemanticValue = new ClassDeclListNode(LineNumber); }
        break;

        case 6: // ClassDecl -> ClassKeyword, Identifier, Extends_Opt, CurlyBracketOpen,
                //              VariableDeclList_Opt, MethodDeclList_Opt, CurlyBracketClose
        { CurrentSemanticValue = new ClassDeclNode((IdentifierNode)ValueStack[ValueStack.Depth - 6], (ExtendsNode)ValueStack[ValueStack.Depth - 5], (VariableDeclListNode)ValueStack[ValueStack.Depth - 3], (MethodDeclListNode)ValueStack[ValueStack.Depth - 2], LineNumber); }
        break;

        case 7: // Extends_Opt -> ExtendsKeyword, Identifier
        { CurrentSemanticValue = new ExtendsNode((IdentifierNode)ValueStack[ValueStack.Depth - 1], LineNumber); }
        break;

        case 9: // MethodDeclList_Opt -> MethodDeclList_Opt, MethodDecl
        { ((MethodDeclListNode)ValueStack[ValueStack.Depth - 2]).AddMethodDecl((MethodDeclNode)ValueStack[ValueStack.Depth - 1]); CurrentSemanticValue = ValueStack[ValueStack.Depth - 2]; }
        break;

        case 10: // MethodDeclList_Opt -> /* empty */
        { CurrentSemanticValue = new MethodDeclListNode(LineNumber); }
        break;

        case 11: // MethodDecl -> PublicKeyword, Type, Identifier, RoundBracketOpen,
                 //               ParamDeclList_Opt, RoundBracketClose, CurlyBracketOpen,
                 //               VariableDeclList_Opt, StatementListEndingInReturn,
                 //               CurlyBracketClose
        { ((StatementListNode)ValueStack[ValueStack.Depth - 2]).statementList.Reverse(); CurrentSemanticValue = new MethodDeclNode((TypeNode)ValueStack[ValueStack.Depth - 9], (IdentifierNode)ValueStack[ValueStack.Depth - 8], (ParamDeclListNode)ValueStack[ValueStack.Depth - 6], (VariableDeclListNode)ValueStack[ValueStack.Depth - 3], (StatementListNode)ValueStack[ValueStack.Depth - 2], LineNumber); }
        break;

        case 12: // VariableDeclList_Opt -> VariableDeclList_Opt, VariableDecl
        { ((VariableDeclListNode)ValueStack[ValueStack.Depth - 2]).AddVariableDecl((VariableDeclNode)ValueStack[ValueStack.Depth - 1]); CurrentSemanticValue = ValueStack[ValueStack.Depth - 2]; }
        break;

        case 13: // VariableDeclList_Opt -> /* empty */
        { CurrentSemanticValue = new VariableDeclListNode(LineNumber); }
        break;

        case 14: // VariableDecl -> Type, Identifier, SemiColon
        { CurrentSemanticValue = new VariableDeclNode((TypeNode)ValueStack[ValueStack.Depth - 3], (IdentifierNode)ValueStack[ValueStack.Depth - 2], LineNumber); }
        break;

        case 15: // StatementListEndingInReturn -> Statement, StatementListEndingInReturn
        { ((StatementListNode)ValueStack[ValueStack.Depth - 1]).AddStatement((StatementNode)ValueStack[ValueStack.Depth - 2]); CurrentSemanticValue = ValueStack[ValueStack.Depth - 1]; }
        break;

        case 16: // StatementListEndingInReturn -> ReturnKeyword, Expr, SemiColon
        { CurrentSemanticValue = new StatementListNode(LineNumber); ((StatementListNode)CurrentSemanticValue).AddStatement(new ReturnStatementNode((ExpressionNode)ValueStack[ValueStack.Depth - 2], LineNumber)); }
        break;

        case 17: // ParamDeclList_Opt -> Type, Identifier, ParamDeclListRest_Opt
        { ((ParamDeclListNode)ValueStack[ValueStack.Depth - 1]).paramDeclList.Reverse(); ((ParamDeclListNode)ValueStack[ValueStack.Depth - 1]).AddParamDecl(new ParamDeclNode((TypeNode)ValueStack[ValueStack.Depth - 3], (IdentifierNode)ValueStack[ValueStack.Depth - 2], LineNumber)); ((ParamDeclListNode)ValueStack[ValueStack.Depth - 1]).paramDeclList.Reverse(); CurrentSemanticValue = ValueStack[ValueStack.Depth - 1]; }
        break;

        case 19: // ParamDeclListRest_Opt -> ParamDeclListRest_Opt, Comma, Type, Identifier
        { ((ParamDeclListNode)ValueStack[ValueStack.Depth - 4]).AddParamDecl(new ParamDeclNode((TypeNode)ValueStack[ValueStack.Depth - 2], (IdentifierNode)ValueStack[ValueStack.Depth - 1], LineNumber)); CurrentSemanticValue = ValueStack[ValueStack.Depth - 4]; }
        break;

        case 20: // ParamDeclListRest_Opt -> /* empty */
        { CurrentSemanticValue = new ParamDeclListNode(LineNumber); }
        break;

        case 21: // Type -> IntKeyword, SquareBracketOpen, SquareBracketClose
        { CurrentSemanticValue = new IntegerArrayTypeNode(LineNumber); }
        break;

        case 22: // Type -> IntKeyword
        { CurrentSemanticValue = new IntegerTypeNode(LineNumber); }
        break;

        case 23: // Type -> BooleanKeyword
        { CurrentSemanticValue = new BooleanTypeNode(LineNumber); }
        break;

        case 24: // Type -> Identifier
        { CurrentSemanticValue = new IdentifierTypeNode(((IdentifierNode)ValueStack[ValueStack.Depth - 1]).name, LineNumber); }
        break;

        case 25: // Statement -> CurlyBracketOpen, StatementList_Opt, CurlyBracketClose
        { CurrentSemanticValue = new StatementBlockNode((StatementListNode)ValueStack[ValueStack.Depth - 2], LineNumber); }
        break;

        case 26: // Statement -> IfKeyword, RoundBracketOpen, Expr, RoundBracketClose, Statement,
                 //              ElseKeyword, Statement
        { CurrentSemanticValue = new IfStatementNode((ExpressionNode)ValueStack[ValueStack.Depth - 5], (StatementNode)ValueStack[ValueStack.Depth - 3], (StatementNode)ValueStack[ValueStack.Depth - 1], LineNumber); }
        break;

        case 27: // Statement -> WhileKeyword, RoundBracketOpen, Expr, RoundBracketClose, Statement
        { CurrentSemanticValue = new WhileStatementNode((ExpressionNode)ValueStack[ValueStack.Depth - 3], (StatementNode)ValueStack[ValueStack.Depth - 1], LineNumber); }
        break;

        case 28: // Statement -> SystemOutPrintLnKeyword, RoundBracketOpen, Expr, RoundBracketClose,
                 //              SemiColon
        { CurrentSemanticValue = new SystemOutPrintLnStatementNode((ExpressionNode)ValueStack[ValueStack.Depth - 3], LineNumber); }
        break;

        case 29: // Statement -> Identifier, EqualsOperator, Expr, SemiColon
        { CurrentSemanticValue = new AssignmentStatementNode((IdentifierNode)ValueStack[ValueStack.Depth - 4], (ExpressionNode)ValueStack[ValueStack.Depth - 2], LineNumber); }
        break;

        case 30: // Statement -> Identifier, Dot, Identifier, EqualsOperator, Expr, SemiColon
        { CurrentSemanticValue = new FieldAssignmentStatementNode((IdentifierNode)ValueStack[ValueStack.Depth - 6], (IdentifierNode)ValueStack[ValueStack.Depth - 4], (ExpressionNode)ValueStack[ValueStack.Depth - 2], LineNumber); }
        break;

        case 31: // Statement -> Identifier, SquareBracketOpen, Expr, SquareBracketClose,
                 //              EqualsOperator, Expr, SemiColon
        { CurrentSemanticValue = new ArrayAssignmentStatementNode((IdentifierNode)ValueStack[ValueStack.Depth - 7], (ExpressionNode)ValueStack[ValueStack.Depth - 5], (ExpressionNode)ValueStack[ValueStack.Depth - 2], LineNumber); }
        break;

        case 32: // Statement -> error, SemiColon
        { CurrentSemanticValue = new StatementBlockNode(new StatementListNode(LineNumber), LineNumber); yyclearin(); Analysis.LogSyntaxError("Syntax error", LineNumber); }
        break;

        case 33: // Statement -> error, CurlyBracketClose
        { CurrentSemanticValue = new StatementBlockNode(new StatementListNode(LineNumber), LineNumber); yyclearin(); Analysis.LogSyntaxError("Syntax error", LineNumber); }
        break;

        case 34: // StatementList_Opt -> StatementList_Opt, Statement
        { ((StatementListNode)ValueStack[ValueStack.Depth - 2]).AddStatement((StatementNode)ValueStack[ValueStack.Depth - 1]); CurrentSemanticValue = ValueStack[ValueStack.Depth - 2]; }
        break;

        case 35: // StatementList_Opt -> /* empty */
        { CurrentSemanticValue = new StatementListNode(LineNumber); }
        break;

        case 36: // Expr -> RoundBracketOpen, Expr, RoundBracketClose
        { CurrentSemanticValue = ValueStack[ValueStack.Depth - 2]; }
        break;

        case 37: // Expr -> NotOperator, Expr
        { CurrentSemanticValue = new NotExpressionNode((ExpressionNode)ValueStack[ValueStack.Depth - 1], LineNumber); }
        break;

        case 38: // Expr -> NewKeyword, IntKeyword, SquareBracketOpen, Expr, SquareBracketClose
        { CurrentSemanticValue = new NewIntegerArrayExpressionNode((ExpressionNode)ValueStack[ValueStack.Depth - 2], LineNumber); }
        break;

        case 39: // Expr -> NewKeyword, Identifier, RoundBracketOpen, RoundBracketClose
        { CurrentSemanticValue = new NewObjectExpressionNode((IdentifierNode)ValueStack[ValueStack.Depth - 3], LineNumber); }
        break;

        case 40: // Expr -> Expr, AndAndOperator, Expr
        { CurrentSemanticValue = new AndExpressionNode((ExpressionNode)ValueStack[ValueStack.Depth - 3], (ExpressionNode)ValueStack[ValueStack.Depth - 1], LineNumber); }
        break;

        case 41: // Expr -> Expr, LessThanOperator, Expr
        { CurrentSemanticValue = new LessThanExpressionNode((ExpressionNode)ValueStack[ValueStack.Depth - 3], (ExpressionNode)ValueStack[ValueStack.Depth - 1], LineNumber); }
        break;

        case 42: // Expr -> Expr, AddOperator, Expr
        { CurrentSemanticValue = new AddExpressionNode((ExpressionNode)ValueStack[ValueStack.Depth - 3], (ExpressionNode)ValueStack[ValueStack.Depth - 1], LineNumber); }
        break;

        case 43: // Expr -> Expr, SubtractOperator, Expr
        { CurrentSemanticValue = new SubtractExpressionNode((ExpressionNode)ValueStack[ValueStack.Depth - 3], (ExpressionNode)ValueStack[ValueStack.Depth - 1], LineNumber); }
        break;

        case 44: // Expr -> Expr, MultiplyOperator, Expr
        { CurrentSemanticValue = new MultiplyExpressionNode((ExpressionNode)ValueStack[ValueStack.Depth - 3], (ExpressionNode)ValueStack[ValueStack.Depth - 1], LineNumber); }
        break;

        case 45: // Expr -> Expr, SquareBracketOpen, Expr, SquareBracketClose
        { CurrentSemanticValue = new ArrayLookupExpressionNode((ExpressionNode)ValueStack[ValueStack.Depth - 4], (ExpressionNode)ValueStack[ValueStack.Depth - 2], LineNumber); }
        break;

        case 46: // Expr -> Expr, Dot, LengthKeyword
        { CurrentSemanticValue = new LengthExpressionNode((ExpressionNode)ValueStack[ValueStack.Depth - 3], LineNumber); }
        break;

        case 47: // Expr -> Expr, Dot, Identifier
        { CurrentSemanticValue = new FieldAccessExpressionNode((ExpressionNode)ValueStack[ValueStack.Depth - 3], (IdentifierNode)ValueStack[ValueStack.Depth - 1], LineNumber); }
        break;

        case 48: // Expr -> Expr, Dot, Identifier, RoundBracketOpen, ExprList_Opt,
                 //         RoundBracketClose
        { CurrentSemanticValue = new MethodCallExpressionNode((ExpressionNode)ValueStack[ValueStack.Depth - 6], (IdentifierNode)ValueStack[ValueStack.Depth - 4], (ExpressionListNode)ValueStack[ValueStack.Depth - 2], LineNumber); }
        break;

        case 49: // Expr -> ThisKeyword
        { CurrentSemanticValue = new ThisExpressionNode(LineNumber); }
        break;

        case 50: // Expr -> Identifier
        { CurrentSemanticValue = new IdentifierExpressionNode((IdentifierNode)ValueStack[ValueStack.Depth - 1], LineNumber); }
        break;

        case 51: // Expr -> IntegerConstant
        { CurrentSemanticValue = ValueStack[ValueStack.Depth - 1]; }
        break;

        case 52: // Expr -> TrueKeyword
        { CurrentSemanticValue = ValueStack[ValueStack.Depth - 1]; }
        break;

        case 53: // Expr -> FalseKeyword
        { CurrentSemanticValue = ValueStack[ValueStack.Depth - 1]; }
        break;

        case 54: // Expr -> error, IntegerConstant
        { CurrentSemanticValue = new InvalidExpressionNode(LineNumber); yyclearin(); Analysis.LogSyntaxError("Syntax error", LineNumber); }
        break;

        case 55: // Expr -> error, TrueKeyword
        { CurrentSemanticValue = new InvalidExpressionNode(LineNumber); yyclearin(); Analysis.LogSyntaxError("Syntax error", LineNumber); }
        break;

        case 56: // Expr -> error, FalseKeyword
        { CurrentSemanticValue = new InvalidExpressionNode(LineNumber); yyclearin(); Analysis.LogSyntaxError("Syntax error", LineNumber); }
        break;

        case 57: // Expr -> error, Identifier
        { CurrentSemanticValue = new InvalidExpressionNode(LineNumber); yyclearin(); Analysis.LogSyntaxError("Syntax error", LineNumber); }
        break;

        case 58: // Expr -> error, ThisKeyword
        { CurrentSemanticValue = new InvalidExpressionNode(LineNumber); yyclearin(); Analysis.LogSyntaxError("Syntax error", LineNumber); }
        break;

        case 59: // Expr -> error, SquareBracketClose
        { CurrentSemanticValue = new InvalidExpressionNode(LineNumber); yyclearin(); Analysis.LogSyntaxError("Syntax error", LineNumber); }
        break;

        case 60: // Expr -> error, RoundBracketClose
        { CurrentSemanticValue = new InvalidExpressionNode(LineNumber); yyclearin(); Analysis.LogSyntaxError("Syntax error", LineNumber); }
        break;

        case 61: // Expr -> error, LengthKeyword
        { CurrentSemanticValue = new InvalidExpressionNode(LineNumber); yyclearin(); Analysis.LogSyntaxError("Syntax error", LineNumber); }
        break;

        case 62: // ExprList_Opt -> Expr, ExprListRest_Opt
        { ((ExpressionListNode)ValueStack[ValueStack.Depth - 1]).expressionList.Reverse(); ((ExpressionListNode)ValueStack[ValueStack.Depth - 1]).AddExpression((ExpressionNode)ValueStack[ValueStack.Depth - 2]); ((ExpressionListNode)ValueStack[ValueStack.Depth - 1]).expressionList.Reverse(); CurrentSemanticValue = ValueStack[ValueStack.Depth - 1]; }
        break;

        case 63: // ExprList_Opt -> /* empty */
        { new ExpressionListNode(LineNumber); }
        break;

        case 64: // ExprListRest_Opt -> ExprListRest_Opt, Comma, Expr
        { ((ExpressionListNode)ValueStack[ValueStack.Depth - 3]).AddExpression((ExpressionNode)ValueStack[ValueStack.Depth - 1]); CurrentSemanticValue = ValueStack[ValueStack.Depth - 3]; }
        break;

        case 65: // ExprListRest_Opt -> /* empty */
        { CurrentSemanticValue = new ExpressionListNode(LineNumber); }
        break;
        }
    }
示例#7
0
 internal override void Visit(AssignmentStatementNode node)
 {
 }
示例#8
0
 public virtual void Visit(AssignmentStatementNode node)
 {
     node.identifier.Accept(this);
     node.expression.Accept(this);
 }