Examples of tree.expression.Assignment

tree.expression.Assignment
Example of assignment: x += 5. @author kondratyevMaria Savenko


                    root_0 = (Object)adaptor.nil();
                    // 152:28: -> EQ
                    {
                        adaptor.addChild(root_0, 
                        new Assignment(stream_EQ.nextToken())
                        );


                    }




                    retval.tree = root_0;
                    }


                    }
                    break;
                case 2 :
                    // Haxe.g:153:19: PLUSEQ
                    {
                    PLUSEQ39=(Token)match(input,PLUSEQ,FOLLOW_PLUSEQ_in_assignOp1076); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_PLUSEQ.add(PLUSEQ39);




                    // AST REWRITE
                    // elements: PLUSEQ
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {


                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);


                    root_0 = (Object)adaptor.nil();
                    // 153:28: -> PLUSEQ
                    {
                        adaptor.addChild(root_0, 
                        new Assignment(stream_PLUSEQ.nextToken())
                        );


                    }




                    retval.tree = root_0;
                    }


                    }
                    break;
                case 3 :
                    // Haxe.g:154:19: SUBEQ
                    {
                    SUBEQ40=(Token)match(input,SUBEQ,FOLLOW_SUBEQ_in_assignOp1105); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_SUBEQ.add(SUBEQ40);




                    // AST REWRITE
                    // elements: SUBEQ
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {


                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);


                    root_0 = (Object)adaptor.nil();
                    // 154:28: -> SUBEQ
                    {
                        adaptor.addChild(root_0, 
                        new Assignment(stream_SUBEQ.nextToken())
                        );


                    }




                    retval.tree = root_0;
                    }


                    }
                    break;
                case 4 :
                    // Haxe.g:155:19: STAREQ
                    {
                    STAREQ41=(Token)match(input,STAREQ,FOLLOW_STAREQ_in_assignOp1135); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_STAREQ.add(STAREQ41);




                    // AST REWRITE
                    // elements: STAREQ
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {


                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);


                    root_0 = (Object)adaptor.nil();
                    // 155:28: -> STAREQ
                    {
                        adaptor.addChild(root_0, 
                        new Assignment(stream_STAREQ.nextToken())
                        );


                    }




                    retval.tree = root_0;
                    }


                    }
                    break;
                case 5 :
                    // Haxe.g:156:19: SLASHEQ
                    {
                    SLASHEQ42=(Token)match(input,SLASHEQ,FOLLOW_SLASHEQ_in_assignOp1164); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_SLASHEQ.add(SLASHEQ42);




                    // AST REWRITE
                    // elements: SLASHEQ
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {


                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);


                    root_0 = (Object)adaptor.nil();
                    // 156:28: -> SLASHEQ
                    {
                        adaptor.addChild(root_0, 
                        new Assignment(stream_SLASHEQ.nextToken())
                        );


                    }




                    retval.tree = root_0;
                    }


                    }
                    break;
                case 6 :
                    // Haxe.g:157:19: PERCENTEQ
                    {
                    PERCENTEQ43=(Token)match(input,PERCENTEQ,FOLLOW_PERCENTEQ_in_assignOp1192); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_PERCENTEQ.add(PERCENTEQ43);




                    // AST REWRITE
                    // elements: PERCENTEQ
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {


                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);


                    root_0 = (Object)adaptor.nil();
                    // 157:29: -> PERCENTEQ
                    {
                        adaptor.addChild(root_0, 
                        new Assignment(stream_PERCENTEQ.nextToken())
                        );


                    }




                    retval.tree = root_0;
                    }


                    }
                    break;
                case 7 :
                    // Haxe.g:158:19: AMPEQ
                    {
                    AMPEQ44=(Token)match(input,AMPEQ,FOLLOW_AMPEQ_in_assignOp1219); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_AMPEQ.add(AMPEQ44);




                    // AST REWRITE
                    // elements: AMPEQ
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {


                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);


                    root_0 = (Object)adaptor.nil();
                    // 158:28: -> AMPEQ
                    {
                        adaptor.addChild(root_0, 
                        new Assignment(stream_AMPEQ.nextToken())
                        );


                    }




                    retval.tree = root_0;
                    }


                    }
                    break;
                case 8 :
                    // Haxe.g:159:19: BAREQ
                    {
                    BAREQ45=(Token)match(input,BAREQ,FOLLOW_BAREQ_in_assignOp1249); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_BAREQ.add(BAREQ45);




                    // AST REWRITE
                    // elements: BAREQ
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {


                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);


                    root_0 = (Object)adaptor.nil();
                    // 159:28: -> BAREQ
                    {
                        adaptor.addChild(root_0, 
                        new Assignment(stream_BAREQ.nextToken())
                        );


                    }




                    retval.tree = root_0;
                    }


                    }
                    break;
                case 9 :
                    // Haxe.g:160:19: CARETEQ
                    {
                    CARETEQ46=(Token)match(input,CARETEQ,FOLLOW_CARETEQ_in_assignOp1279); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_CARETEQ.add(CARETEQ46);




                    // AST REWRITE
                    // elements: CARETEQ
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {


                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);


                    root_0 = (Object)adaptor.nil();
                    // 160:28: -> CARETEQ
                    {
                        adaptor.addChild(root_0, 
                        new Assignment(stream_CARETEQ.nextToken())
                        );


                    }




                    retval.tree = root_0;
                    }


                    }
                    break;
                case 10 :
                    // Haxe.g:161:19: LTLTEQ
                    {
                    LTLTEQ47=(Token)match(input,LTLTEQ,FOLLOW_LTLTEQ_in_assignOp1307); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_LTLTEQ.add(LTLTEQ47);




                    // AST REWRITE
                    // elements: LTLTEQ
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {


                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);


                    root_0 = (Object)adaptor.nil();
                    // 161:28: -> LTLTEQ
                    {
                        adaptor.addChild(root_0, 
                        new Assignment(stream_LTLTEQ.nextToken())
                        );


                    }




                    retval.tree = root_0;
                    }


                    }
                    break;
                case 11 :
                    // Haxe.g:162:19: GTGTEQ
                    {
                    GTGTEQ48=(Token)match(input,GTGTEQ,FOLLOW_GTGTEQ_in_assignOp1336); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_GTGTEQ.add(GTGTEQ48);




                    // AST REWRITE
                    // elements: GTGTEQ
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {


                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);


                    root_0 = (Object)adaptor.nil();
                    // 162:28: -> GTGTEQ
                    {
                        adaptor.addChild(root_0, 
                        new Assignment(stream_GTGTEQ.nextToken())
                        );


                    }




                    retval.tree = root_0;
                    }


                    }
                    break;
                case 12 :
                    // Haxe.g:163:19: GTGTGTEQ
                    {
                    GTGTGTEQ49=(Token)match(input,GTGTGTEQ,FOLLOW_GTGTGTEQ_in_assignOp1365); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_GTGTGTEQ.add(GTGTGTEQ49);




                    // AST REWRITE
                    // elements: GTGTGTEQ
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {


                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);


                    root_0 = (Object)adaptor.nil();
                    // 163:28: -> GTGTGTEQ
                    {
                        adaptor.addChild(root_0, 
                        new Assignment(stream_GTGTGTEQ.nextToken())
                        );


                    }

View Full Code Here

    @Test
    public void testIntToFloat() throws RecognitionException 
    {
        HaxeTree tree = parseFunction("function main() { var x:Int; x=123.1;}");
        linker.visit(tree, new Environment());
        Assignment node = TestHelper.getAssignment(tree);
        
        HaxeType firstType = node.getLeftOperand().getHaxeType();
        HaxeType secondType = node.getRightOperand().getHaxeType(); 
        assertTrue(!TypeUtils.isAvailableAssignement(firstType, secondType));
    }

View Full Code Here

    @Test
    public void testFloatToInt() throws RecognitionException 
    {
        HaxeTree tree = parseFunction("function main() { var x:Int; x=123;}");
        linker.visit(tree, new Environment());
        Assignment node = TestHelper.getAssignment(tree);


        HaxeType firstType = node.getLeftOperand().getHaxeType();
        HaxeType secondType = node.getRightOperand().getHaxeType(); 
        assertTrue(TypeUtils.isAvailableAssignement(secondType, firstType));
    }

View Full Code Here

            {
                return (Assignment)i;
            }
            else if (i.getChildCount() > 0)
            {
                Assignment result = getAssignment(i);
                if (result != null)
                {
                    return result;
                }
            }

View Full Code Here

TOP

Related Classes of tree.expression.Assignment

imp.parser.antlr.HaxeParser

tests.AssignOperation

tree.type.HaxeType

utils.TestHelper

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.