// $ANTLR 3.1.3 Mar 17, 2009 19:23:44 /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g 2009-11-19 13:17:34

  package hu.swankey.ammo.common.script;
  import java.util.LinkedList;
  import java.util.Map;
  import java.util.HashMap;
  import hu.swankey.ammo.common.yggdrasil.definition.AttributeDefinition;
  import hu.swankey.ammo.common.yggdrasil.definition.MethodDefinition;
  import hu.swankey.ammo.common.yggdrasil.definition.ComplexClassDefinition;
  import hu.swankey.ammo.common.yggdrasil.basics.Reference;
  import hu.swankey.ammo.common.yggdrasil.basics.YObject;
  import hu.swankey.ammo.common.yggdrasil.basics.IntegerField;
  import hu.swankey.ammo.common.yggdrasil.basics.StringField;
  import hu.swankey.ammo.common.script.statements.Block;
  import hu.swankey.ammo.common.script.statements.Call;
  import hu.swankey.ammo.common.script.statements.Constant;
  import hu.swankey.ammo.common.script.statements.DynamicVariable;
  import hu.swankey.ammo.common.script.statements.Expression;
  import hu.swankey.ammo.common.script.statements.Statement;
  import hu.swankey.ammo.common.script.statements.Switch;
  import hu.swankey.ammo.common.script.statements.Variable;
  import hu.swankey.ammo.common.script.yunits.YClass;
  import hu.swankey.ammo.common.script.yunits.YMethod;
 

import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;


import org.antlr.runtime.tree.*;

public class AmmoScriptParser extends Parser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "CLASSDEF", "SUPERIORS", "DEFINITIONS", "VARDEF", "METHODDEF", "PARAMDEFS", "PARAMDEF", "SOFTLINK", "PARAMETER", "BLOCK", "SWITCH", "SWITCHCASE", "IDENTIFIER", "KEYWORD_EXTENDS", "COLON", "OPENING_PARENTHESIS", "CLOSING_PARENTHESIS", "ASSIGN", "SEMICOLON", "OPENING_BRACKET", "CLOSING_BRACKET", "KEYWORD_PRIVATE", "KEYWORD_PROTECTED", "KEYWORD_PUBLIC", "CASE", "KETTOSPONT", "DELIMITER", "NUMBER", "STRING", "WHITESPACE", "MINUS", "DIGIT", "IDENTIFIER_SYMBOL", "QUOTATION_MARK", "STRING_SYMBOL", "CONTROL_SYMBOL", "ESCAPE", "LETTER", "NONCONTROL_SYMBOL", "ESCAPE_SYMBOL", "ADDITION", "MULTIPLICATION", "DIVISION", "MODULUS"
    };
    public static final int SOFTLINK=11;
    public static final int ADDITION=44;
    public static final int LETTER=41;
    public static final int SWITCHCASE=15;
    public static final int CASE=28;
    public static final int ESCAPE_SYMBOL=43;
    public static final int KEYWORD_PRIVATE=25;
    public static final int CLASSDEF=4;
    public static final int SUPERIORS=5;
    public static final int EOF=-1;
    public static final int IDENTIFIER_SYMBOL=36;
    public static final int OPENING_BRACKET=23;
    public static final int ESCAPE=40;
    public static final int IDENTIFIER=16;
    public static final int PARAMDEFS=9;
    public static final int PARAMETER=12;
    public static final int STRING_SYMBOL=38;
    public static final int DIVISION=46;
    public static final int KEYWORD_PROTECTED=26;
    public static final int DIGIT=35;
    public static final int PARAMDEF=10;
    public static final int VARDEF=7;
    public static final int CONTROL_SYMBOL=39;
    public static final int CLOSING_PARENTHESIS=20;
    public static final int METHODDEF=8;
    public static final int SWITCH=14;
    public static final int DEFINITIONS=6;
    public static final int NUMBER=31;
    public static final int WHITESPACE=33;
    public static final int SEMICOLON=22;
    public static final int KETTOSPONT=29;
    public static final int MINUS=34;
    public static final int OPENING_PARENTHESIS=19;
    public static final int KEYWORD_PUBLIC=27;
    public static final int COLON=18;
    public static final int CLOSING_BRACKET=24;
    public static final int QUOTATION_MARK=37;
    public static final int NONCONTROL_SYMBOL=42;
    public static final int MODULUS=47;
    public static final int BLOCK=13;
    public static final int ASSIGN=21;
    public static final int MULTIPLICATION=45;
    public static final int KEYWORD_EXTENDS=17;
    public static final int DELIMITER=30;
    public static final int STRING=32;

    // delegates
    // delegators


        public AmmoScriptParser(TokenStream input) {
            this(input, new RecognizerSharedState());
        }
        public AmmoScriptParser(TokenStream input, RecognizerSharedState state) {
            super(input, state);
             
        }
        
    protected TreeAdaptor adaptor = new CommonTreeAdaptor();

    public void setTreeAdaptor(TreeAdaptor adaptor) {
        this.adaptor = adaptor;
    }
    public TreeAdaptor getTreeAdaptor() {
        return adaptor;
    }

    public String[] getTokenNames() { return AmmoScriptParser.tokenNames; }
    public String getGrammarFileName() { return "/home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g"; }


        private List<String> errors = new LinkedList<String>();
        
        public void displayRecognitionError(String[] tokenNames, RecognitionException e) {
            String hdr = getErrorHeader(e);
            String msg = getErrorMessage(e, tokenNames);
            errors.add(hdr + " " + msg);
        }
        
        public List<String> getErrors() {
            return errors;
        }
        
        
        public Expression createExpr(Expression expr1, String operator, Expression expr2) {
        
          if (expr1 != null){
            Map<String, Expression> map = new HashMap<String, Expression>();
            map.put("value", expr2);  
            return new Call(expr1, operator, map);
          } else
            return expr2;
            
        }    


    public static class classDeclaration_return extends ParserRuleReturnScope {
        public ComplexClassDefinition def;
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "classDeclaration"
    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:84:1: classDeclaration returns [ComplexClassDefinition def] : level= accessLevel id= IDENTIFIER ( KEYWORD_EXTENDS p1= path[false] ( COLON p2= path[false] )* )? OPENING_PARENTHESIS (var= variableDeclaration | method= methodDeclaration )* CLOSING_PARENTHESIS ;
    public final AmmoScriptParser.classDeclaration_return classDeclaration() throws RecognitionException {
        AmmoScriptParser.classDeclaration_return retval = new AmmoScriptParser.classDeclaration_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token id=null;
        Token KEYWORD_EXTENDS1=null;
        Token COLON2=null;
        Token OPENING_PARENTHESIS3=null;
        Token CLOSING_PARENTHESIS4=null;
        AmmoScriptParser.accessLevel_return level = null;

        AmmoScriptParser.path_return p1 = null;

        AmmoScriptParser.path_return p2 = null;

        AmmoScriptParser.variableDeclaration_return var = null;

        AmmoScriptParser.methodDeclaration_return method = null;


        Object id_tree=null;
        Object KEYWORD_EXTENDS1_tree=null;
        Object COLON2_tree=null;
        Object OPENING_PARENTHESIS3_tree=null;
        Object CLOSING_PARENTHESIS4_tree=null;

        try {
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:85:3: (level= accessLevel id= IDENTIFIER ( KEYWORD_EXTENDS p1= path[false] ( COLON p2= path[false] )* )? OPENING_PARENTHESIS (var= variableDeclaration | method= methodDeclaration )* CLOSING_PARENTHESIS )
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:85:5: level= accessLevel id= IDENTIFIER ( KEYWORD_EXTENDS p1= path[false] ( COLON p2= path[false] )* )? OPENING_PARENTHESIS (var= variableDeclaration | method= methodDeclaration )* CLOSING_PARENTHESIS
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_accessLevel_in_classDeclaration143);
            level=accessLevel();

            state._fsp--;

            adaptor.addChild(root_0, level.getTree());
            id=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_classDeclaration147); 
            id_tree = (Object)adaptor.create(id);
            adaptor.addChild(root_0, id_tree);


                retval.def = ComplexClassDefinition.yclass().create((id!=null?id.getText():null));
                retval.def.setAccessLevel((level!=null?level.level:0));
              
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:91:3: ( KEYWORD_EXTENDS p1= path[false] ( COLON p2= path[false] )* )?
            int alt2=2;
            int LA2_0 = input.LA(1);

            if ( (LA2_0==KEYWORD_EXTENDS) ) {
                alt2=1;
            }
            switch (alt2) {
                case 1 :
                    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:91:5: KEYWORD_EXTENDS p1= path[false] ( COLON p2= path[false] )*
                    {
                    KEYWORD_EXTENDS1=(Token)match(input,KEYWORD_EXTENDS,FOLLOW_KEYWORD_EXTENDS_in_classDeclaration160); 
                    KEYWORD_EXTENDS1_tree = (Object)adaptor.create(KEYWORD_EXTENDS1);
                    adaptor.addChild(root_0, KEYWORD_EXTENDS1_tree);

                    pushFollow(FOLLOW_path_in_classDeclaration168);
                    p1=path(false);

                    state._fsp--;

                    adaptor.addChild(root_0, p1.getTree());
                     retval.def.addSuperior((p1!=null?p1.link:null)); 
                    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:93:5: ( COLON p2= path[false] )*
                    loop1:
                    do {
                        int alt1=2;
                        int LA1_0 = input.LA(1);

                        if ( (LA1_0==COLON) ) {
                            alt1=1;
                        }


                        switch (alt1) {
                    	case 1 :
                    	    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:93:6: COLON p2= path[false]
                    	    {
                    	    COLON2=(Token)match(input,COLON,FOLLOW_COLON_in_classDeclaration178); 
                    	    COLON2_tree = (Object)adaptor.create(COLON2);
                    	    adaptor.addChild(root_0, COLON2_tree);

                    	    pushFollow(FOLLOW_path_in_classDeclaration182);
                    	    p2=path(false);

                    	    state._fsp--;

                    	    adaptor.addChild(root_0, p2.getTree());
                    	     retval.def.addSuperior((p2!=null?p2.link:null)); 

                    	    }
                    	    break;

                    	default :
                    	    break loop1;
                        }
                    } while (true);


                    }
                    break;

            }

            OPENING_PARENTHESIS3=(Token)match(input,OPENING_PARENTHESIS,FOLLOW_OPENING_PARENTHESIS_in_classDeclaration198); 
            OPENING_PARENTHESIS3_tree = (Object)adaptor.create(OPENING_PARENTHESIS3);
            adaptor.addChild(root_0, OPENING_PARENTHESIS3_tree);

            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:97:5: (var= variableDeclaration | method= methodDeclaration )*
            loop3:
            do {
                int alt3=3;
                alt3 = dfa3.predict(input);
                switch (alt3) {
            	case 1 :
            	    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:97:7: var= variableDeclaration
            	    {
            	    pushFollow(FOLLOW_variableDeclaration_in_classDeclaration208);
            	    var=variableDeclaration();

            	    state._fsp--;

            	    adaptor.addChild(root_0, var.getTree());
            	     retval.def.addElement((var!=null?var.def:null)); 

            	    }
            	    break;
            	case 2 :
            	    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:98:9: method= methodDeclaration
            	    {
            	    pushFollow(FOLLOW_methodDeclaration_in_classDeclaration223);
            	    method=methodDeclaration();

            	    state._fsp--;

            	    adaptor.addChild(root_0, method.getTree());
            	     retval.def.addMethod((method!=null?method.def:null)); 

            	    }
            	    break;

            	default :
            	    break loop3;
                }
            } while (true);

            CLOSING_PARENTHESIS4=(Token)match(input,CLOSING_PARENTHESIS,FOLLOW_CLOSING_PARENTHESIS_in_classDeclaration236); 
            CLOSING_PARENTHESIS4_tree = (Object)adaptor.create(CLOSING_PARENTHESIS4);
            adaptor.addChild(root_0, CLOSING_PARENTHESIS4_tree);

             retval.def.setSource(input.toString(retval.start,input.LT(-1))); 

            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "classDeclaration"

    public static class variableDeclaration_return extends ParserRuleReturnScope {
        public AttributeDefinition def;
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "variableDeclaration"
    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:105:1: variableDeclaration returns [VariableDefinition def] : accessLevel t= path[false] id= IDENTIFIER ( ASSIGN expression )? SEMICOLON ;
    public final AmmoScriptParser.variableDeclaration_return variableDeclaration() throws RecognitionException {
        AmmoScriptParser.variableDeclaration_return retval = new AmmoScriptParser.variableDeclaration_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token id=null;
        Token ASSIGN6=null;
        Token SEMICOLON8=null;
        AmmoScriptParser.path_return t = null;

        AmmoScriptParser.accessLevel_return accessLevel5 = null;

        AmmoScriptParser.expression_return expression7 = null;


        Object id_tree=null;
        Object ASSIGN6_tree=null;
        Object SEMICOLON8_tree=null;

        try {
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:106:3: ( accessLevel t= path[false] id= IDENTIFIER ( ASSIGN expression )? SEMICOLON )
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:106:5: accessLevel t= path[false] id= IDENTIFIER ( ASSIGN expression )? SEMICOLON
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_accessLevel_in_variableDeclaration260);
            accessLevel5=accessLevel();

            state._fsp--;

            adaptor.addChild(root_0, accessLevel5.getTree());
            pushFollow(FOLLOW_path_in_variableDeclaration264);
            t=path(false);

            state._fsp--;

            adaptor.addChild(root_0, t.getTree());
            id=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_variableDeclaration270); 
            id_tree = (Object)adaptor.create(id);
            adaptor.addChild(root_0, id_tree);

            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:106:47: ( ASSIGN expression )?
            int alt4=2;
            int LA4_0 = input.LA(1);

            if ( (LA4_0==ASSIGN) ) {
                alt4=1;
            }
            switch (alt4) {
                case 1 :
                    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:106:48: ASSIGN expression
                    {
                    ASSIGN6=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_variableDeclaration274); 
                    ASSIGN6_tree = (Object)adaptor.create(ASSIGN6);
                    adaptor.addChild(root_0, ASSIGN6_tree);

                    pushFollow(FOLLOW_expression_in_variableDeclaration276);
                    expression7=expression();

                    state._fsp--;

                    adaptor.addChild(root_0, expression7.getTree());

                    }
                    break;

            }

            SEMICOLON8=(Token)match(input,SEMICOLON,FOLLOW_SEMICOLON_in_variableDeclaration280); 
            SEMICOLON8_tree = (Object)adaptor.create(SEMICOLON8);
            adaptor.addChild(root_0, SEMICOLON8_tree);


                //retval.def = new VariableDefinition((id!=null?id.getText():null), (t!=null?t.link:null).getValue(), null);
                YClass yclass = YClass.getYClass((t!=null?t.link:null));
                
                if (yclass == null)
                  throw new FailedPredicateException(input, "variableDeclaration", (t!=null?t.link:null).getValue() + " not exists!");
                
                retval.def = AttributeDefinition.yclass().create((id!=null?id.getText():null), yclass, null);
                retval.def.setSource(input.toString(retval.start,input.LT(-1)));
              

            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "variableDeclaration"

    public static class methodDeclaration_return extends ParserRuleReturnScope {
        public MethodDefinition def;
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "methodDeclaration"
    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:119:1: methodDeclaration returns [MethodDefinition def] : level= accessLevel type= path[false] id= IDENTIFIER OPENING_BRACKET (param= parameterDeclaration )* CLOSING_BRACKET b= block ;
    public final AmmoScriptParser.methodDeclaration_return methodDeclaration() throws RecognitionException {
        AmmoScriptParser.methodDeclaration_return retval = new AmmoScriptParser.methodDeclaration_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token id=null;
        Token OPENING_BRACKET9=null;
        Token CLOSING_BRACKET10=null;
        AmmoScriptParser.accessLevel_return level = null;

        AmmoScriptParser.path_return type = null;

        AmmoScriptParser.parameterDeclaration_return param = null;

        AmmoScriptParser.block_return b = null;


        Object id_tree=null;
        Object OPENING_BRACKET9_tree=null;
        Object CLOSING_BRACKET10_tree=null;

         HashMap<String, YClass> params = new HashMap<String, YClass>(); 
        try {
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:123:3: (level= accessLevel type= path[false] id= IDENTIFIER OPENING_BRACKET (param= parameterDeclaration )* CLOSING_BRACKET b= block )
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:123:5: level= accessLevel type= path[false] id= IDENTIFIER OPENING_BRACKET (param= parameterDeclaration )* CLOSING_BRACKET b= block
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_accessLevel_in_methodDeclaration317);
            level=accessLevel();

            state._fsp--;

            adaptor.addChild(root_0, level.getTree());
            pushFollow(FOLLOW_path_in_methodDeclaration321);
            type=path(false);

            state._fsp--;

            adaptor.addChild(root_0, type.getTree());
            id=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_methodDeclaration326); 
            id_tree = (Object)adaptor.create(id);
            adaptor.addChild(root_0, id_tree);

            OPENING_BRACKET9=(Token)match(input,OPENING_BRACKET,FOLLOW_OPENING_BRACKET_in_methodDeclaration330); 
            OPENING_BRACKET9_tree = (Object)adaptor.create(OPENING_BRACKET9);
            adaptor.addChild(root_0, OPENING_BRACKET9_tree);

            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:125:3: (param= parameterDeclaration )*
            loop5:
            do {
                int alt5=2;
                int LA5_0 = input.LA(1);

                if ( (LA5_0==IDENTIFIER) ) {
                    alt5=1;
                }


                switch (alt5) {
            	case 1 :
            	    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:125:4: param= parameterDeclaration
            	    {
            	    pushFollow(FOLLOW_parameterDeclaration_in_methodDeclaration337);
            	    param=parameterDeclaration();

            	    state._fsp--;

            	    adaptor.addChild(root_0, param.getTree());
            	     params.put((param!=null?param.name:null), YClass.getYClass((param!=null?param.type:null))); 

            	    }
            	    break;

            	default :
            	    break loop5;
                }
            } while (true);

            CLOSING_BRACKET10=(Token)match(input,CLOSING_BRACKET,FOLLOW_CLOSING_BRACKET_in_methodDeclaration345); 
            CLOSING_BRACKET10_tree = (Object)adaptor.create(CLOSING_BRACKET10);
            adaptor.addChild(root_0, CLOSING_BRACKET10_tree);

            pushFollow(FOLLOW_block_in_methodDeclaration349);
            b=block();

            state._fsp--;

            adaptor.addChild(root_0, b.getTree());

                retval.def = MethodDefinition.yclass().create( new YMethod((id!=null?id.getText():null), YClass.getYClass((type!=null?type.link:null)), params, null, (b!=null?b.block:null)) );
                retval.def.setSource(input.toString(retval.start,input.LT(-1)));
              

            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "methodDeclaration"

    public static class parameterDeclaration_return extends ParserRuleReturnScope {
        public Reference type;
        public String name;
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "parameterDeclaration"
    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:134:1: parameterDeclaration returns [SoftLink type, String name] : t= path[false] id= IDENTIFIER ;
    public final AmmoScriptParser.parameterDeclaration_return parameterDeclaration() throws RecognitionException {
        AmmoScriptParser.parameterDeclaration_return retval = new AmmoScriptParser.parameterDeclaration_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token id=null;
        AmmoScriptParser.path_return t = null;


        Object id_tree=null;

        try {
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:135:3: (t= path[false] id= IDENTIFIER )
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:135:5: t= path[false] id= IDENTIFIER
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_path_in_parameterDeclaration373);
            t=path(false);

            state._fsp--;

            adaptor.addChild(root_0, t.getTree());
            id=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_parameterDeclaration378); 
            id_tree = (Object)adaptor.create(id);
            adaptor.addChild(root_0, id_tree);

             retval.type =(t!=null?t.link:null); retval.name =(id!=null?id.getText():null); 

            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "parameterDeclaration"

    public static class block_return extends ParserRuleReturnScope {
        public Block block;
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "block"
    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:138:1: block returns [Block block] : OPENING_PARENTHESIS (s= statement )* CLOSING_PARENTHESIS ;
    public final AmmoScriptParser.block_return block() throws RecognitionException {
        AmmoScriptParser.block_return retval = new AmmoScriptParser.block_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token OPENING_PARENTHESIS11=null;
        Token CLOSING_PARENTHESIS12=null;
        AmmoScriptParser.statement_return s = null;


        Object OPENING_PARENTHESIS11_tree=null;
        Object CLOSING_PARENTHESIS12_tree=null;

         retval.block = new Block(); 
        try {
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:140:3: ( OPENING_PARENTHESIS (s= statement )* CLOSING_PARENTHESIS )
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:140:5: OPENING_PARENTHESIS (s= statement )* CLOSING_PARENTHESIS
            {
            root_0 = (Object)adaptor.nil();

            OPENING_PARENTHESIS11=(Token)match(input,OPENING_PARENTHESIS,FOLLOW_OPENING_PARENTHESIS_in_block406); 
            OPENING_PARENTHESIS11_tree = (Object)adaptor.create(OPENING_PARENTHESIS11);
            adaptor.addChild(root_0, OPENING_PARENTHESIS11_tree);

            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:140:25: (s= statement )*
            loop6:
            do {
                int alt6=2;
                int LA6_0 = input.LA(1);

                if ( (LA6_0==SWITCH||LA6_0==IDENTIFIER||LA6_0==OPENING_PARENTHESIS||(LA6_0>=NUMBER && LA6_0<=STRING)) ) {
                    alt6=1;
                }


                switch (alt6) {
            	case 1 :
            	    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:140:26: s= statement
            	    {
            	    pushFollow(FOLLOW_statement_in_block411);
            	    s=statement();

            	    state._fsp--;

            	    adaptor.addChild(root_0, s.getTree());
            	     retval.block.addStatement( (s!=null?s.statement:null)); 

            	    }
            	    break;

            	default :
            	    break loop6;
                }
            } while (true);

            CLOSING_PARENTHESIS12=(Token)match(input,CLOSING_PARENTHESIS,FOLLOW_CLOSING_PARENTHESIS_in_block423); 
            CLOSING_PARENTHESIS12_tree = (Object)adaptor.create(CLOSING_PARENTHESIS12);
            adaptor.addChild(root_0, CLOSING_PARENTHESIS12_tree);


            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "block"

    public static class accessLevel_return extends ParserRuleReturnScope {
        public int level;
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "accessLevel"
    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:145:1: accessLevel returns [int level] : ( KEYWORD_PRIVATE | KEYWORD_PROTECTED | KEYWORD_PUBLIC );
    public final AmmoScriptParser.accessLevel_return accessLevel() throws RecognitionException {
        AmmoScriptParser.accessLevel_return retval = new AmmoScriptParser.accessLevel_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token KEYWORD_PRIVATE13=null;
        Token KEYWORD_PROTECTED14=null;
        Token KEYWORD_PUBLIC15=null;

        Object KEYWORD_PRIVATE13_tree=null;
        Object KEYWORD_PROTECTED14_tree=null;
        Object KEYWORD_PUBLIC15_tree=null;

        try {
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:146:3: ( KEYWORD_PRIVATE | KEYWORD_PROTECTED | KEYWORD_PUBLIC )
            int alt7=3;
            switch ( input.LA(1) ) {
            case KEYWORD_PRIVATE:
                {
                alt7=1;
                }
                break;
            case KEYWORD_PROTECTED:
                {
                alt7=2;
                }
                break;
            case KEYWORD_PUBLIC:
                {
                alt7=3;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 7, 0, input);

                throw nvae;
            }

            switch (alt7) {
                case 1 :
                    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:146:5: KEYWORD_PRIVATE
                    {
                    root_0 = (Object)adaptor.nil();

                    KEYWORD_PRIVATE13=(Token)match(input,KEYWORD_PRIVATE,FOLLOW_KEYWORD_PRIVATE_in_accessLevel441); 
                    KEYWORD_PRIVATE13_tree = (Object)adaptor.create(KEYWORD_PRIVATE13);
                    adaptor.addChild(root_0, KEYWORD_PRIVATE13_tree);

                    retval.level =3;

                    }
                    break;
                case 2 :
                    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:147:5: KEYWORD_PROTECTED
                    {
                    root_0 = (Object)adaptor.nil();

                    KEYWORD_PROTECTED14=(Token)match(input,KEYWORD_PROTECTED,FOLLOW_KEYWORD_PROTECTED_in_accessLevel449); 
                    KEYWORD_PROTECTED14_tree = (Object)adaptor.create(KEYWORD_PROTECTED14);
                    adaptor.addChild(root_0, KEYWORD_PROTECTED14_tree);

                    retval.level =2;

                    }
                    break;
                case 3 :
                    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:148:5: KEYWORD_PUBLIC
                    {
                    root_0 = (Object)adaptor.nil();

                    KEYWORD_PUBLIC15=(Token)match(input,KEYWORD_PUBLIC,FOLLOW_KEYWORD_PUBLIC_in_accessLevel457); 
                    KEYWORD_PUBLIC15_tree = (Object)adaptor.create(KEYWORD_PUBLIC15);
                    adaptor.addChild(root_0, KEYWORD_PUBLIC15_tree);

                    retval.level =1;

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "accessLevel"

    public static class switch__return extends ParserRuleReturnScope {
        public Switch sw;
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "switch_"
    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:152:1: switch_ returns [Switch sw] : SWITCH OPENING_BRACKET switcher= expression CLOSING_BRACKET OPENING_PARENTHESIS (c= switchCase )* CLOSING_PARENTHESIS ;
    public final AmmoScriptParser.switch__return switch_() throws RecognitionException {
        AmmoScriptParser.switch__return retval = new AmmoScriptParser.switch__return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token SWITCH16=null;
        Token OPENING_BRACKET17=null;
        Token CLOSING_BRACKET18=null;
        Token OPENING_PARENTHESIS19=null;
        Token CLOSING_PARENTHESIS20=null;
        AmmoScriptParser.expression_return switcher = null;

        AmmoScriptParser.switchCase_return c = null;


        Object SWITCH16_tree=null;
        Object OPENING_BRACKET17_tree=null;
        Object CLOSING_BRACKET18_tree=null;
        Object OPENING_PARENTHESIS19_tree=null;
        Object CLOSING_PARENTHESIS20_tree=null;

         Map<Expression, Statement> cases = new HashMap<Expression, Statement>(); 
        try {
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:154:3: ( SWITCH OPENING_BRACKET switcher= expression CLOSING_BRACKET OPENING_PARENTHESIS (c= switchCase )* CLOSING_PARENTHESIS )
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:154:5: SWITCH OPENING_BRACKET switcher= expression CLOSING_BRACKET OPENING_PARENTHESIS (c= switchCase )* CLOSING_PARENTHESIS
            {
            root_0 = (Object)adaptor.nil();

            SWITCH16=(Token)match(input,SWITCH,FOLLOW_SWITCH_in_switch_484); 
            SWITCH16_tree = (Object)adaptor.create(SWITCH16);
            adaptor.addChild(root_0, SWITCH16_tree);

            OPENING_BRACKET17=(Token)match(input,OPENING_BRACKET,FOLLOW_OPENING_BRACKET_in_switch_486); 
            OPENING_BRACKET17_tree = (Object)adaptor.create(OPENING_BRACKET17);
            adaptor.addChild(root_0, OPENING_BRACKET17_tree);

            pushFollow(FOLLOW_expression_in_switch_490);
            switcher=expression();

            state._fsp--;

            adaptor.addChild(root_0, switcher.getTree());
            CLOSING_BRACKET18=(Token)match(input,CLOSING_BRACKET,FOLLOW_CLOSING_BRACKET_in_switch_492); 
            CLOSING_BRACKET18_tree = (Object)adaptor.create(CLOSING_BRACKET18);
            adaptor.addChild(root_0, CLOSING_BRACKET18_tree);

            OPENING_PARENTHESIS19=(Token)match(input,OPENING_PARENTHESIS,FOLLOW_OPENING_PARENTHESIS_in_switch_499); 
            OPENING_PARENTHESIS19_tree = (Object)adaptor.create(OPENING_PARENTHESIS19);
            adaptor.addChild(root_0, OPENING_PARENTHESIS19_tree);

            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:157:3: (c= switchCase )*
            loop8:
            do {
                int alt8=2;
                int LA8_0 = input.LA(1);

                if ( (LA8_0==CASE) ) {
                    alt8=1;
                }


                switch (alt8) {
            	case 1 :
            	    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:157:4: c= switchCase
            	    {
            	    pushFollow(FOLLOW_switchCase_in_switch_506);
            	    c=switchCase();

            	    state._fsp--;

            	    adaptor.addChild(root_0, c.getTree());
            	    cases.put( (c!=null?c.expression:null), (c!=null?c.statement:null));

            	    }
            	    break;

            	default :
            	    break loop8;
                }
            } while (true);

            CLOSING_PARENTHESIS20=(Token)match(input,CLOSING_PARENTHESIS,FOLLOW_CLOSING_PARENTHESIS_in_switch_518); 
            CLOSING_PARENTHESIS20_tree = (Object)adaptor.create(CLOSING_PARENTHESIS20);
            adaptor.addChild(root_0, CLOSING_PARENTHESIS20_tree);

             retval.sw = new Switch((switcher!=null?switcher.expression:null), cases, null);  

            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "switch_"

    public static class switchCase_return extends ParserRuleReturnScope {
        public Expression expression;
        public Statement statement;
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "switchCase"
    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:163:1: switchCase returns [Expression expression, Statement statement] : CASE f= expression KETTOSPONT s= statement ;
    public final AmmoScriptParser.switchCase_return switchCase() throws RecognitionException {
        AmmoScriptParser.switchCase_return retval = new AmmoScriptParser.switchCase_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token CASE21=null;
        Token KETTOSPONT22=null;
        AmmoScriptParser.expression_return f = null;

        AmmoScriptParser.statement_return s = null;


        Object CASE21_tree=null;
        Object KETTOSPONT22_tree=null;

        try {
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:164:3: ( CASE f= expression KETTOSPONT s= statement )
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:164:5: CASE f= expression KETTOSPONT s= statement
            {
            root_0 = (Object)adaptor.nil();

            CASE21=(Token)match(input,CASE,FOLLOW_CASE_in_switchCase540); 
            CASE21_tree = (Object)adaptor.create(CASE21);
            adaptor.addChild(root_0, CASE21_tree);

            pushFollow(FOLLOW_expression_in_switchCase544);
            f=expression();

            state._fsp--;

            adaptor.addChild(root_0, f.getTree());
            KETTOSPONT22=(Token)match(input,KETTOSPONT,FOLLOW_KETTOSPONT_in_switchCase546); 
            KETTOSPONT22_tree = (Object)adaptor.create(KETTOSPONT22);
            adaptor.addChild(root_0, KETTOSPONT22_tree);

            pushFollow(FOLLOW_statement_in_switchCase550);
            s=statement();

            state._fsp--;

            adaptor.addChild(root_0, s.getTree());
             retval.expression = (f!=null?f.expression:null); retval.statement = (s!=null?s.statement:null); 

            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "switchCase"

    public static class statement_return extends ParserRuleReturnScope {
        public Statement statement;
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "statement"
    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:166:1: statement returns [Statement statement] : (b= block | expression ';' | sw= switch_ );
    public final AmmoScriptParser.statement_return statement() throws RecognitionException {
        AmmoScriptParser.statement_return retval = new AmmoScriptParser.statement_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token char_literal24=null;
        AmmoScriptParser.block_return b = null;

        AmmoScriptParser.switch__return sw = null;

        AmmoScriptParser.expression_return expression23 = null;


        Object char_literal24_tree=null;

        try {
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:167:3: (b= block | expression ';' | sw= switch_ )
            int alt9=3;
            switch ( input.LA(1) ) {
            case OPENING_PARENTHESIS:
                {
                alt9=1;
                }
                break;
            case IDENTIFIER:
            case NUMBER:
            case STRING:
                {
                alt9=2;
                }
                break;
            case SWITCH:
                {
                alt9=3;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 9, 0, input);

                throw nvae;
            }

            switch (alt9) {
                case 1 :
                    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:167:5: b= block
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_block_in_statement569);
                    b=block();

                    state._fsp--;

                    adaptor.addChild(root_0, b.getTree());
                     retval.statement = (b!=null?b.block:null); 

                    }
                    break;
                case 2 :
                    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:168:5: expression ';'
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_expression_in_statement577);
                    expression23=expression();

                    state._fsp--;

                    adaptor.addChild(root_0, expression23.getTree());
                    char_literal24=(Token)match(input,SEMICOLON,FOLLOW_SEMICOLON_in_statement579); 
                    char_literal24_tree = (Object)adaptor.create(char_literal24);
                    adaptor.addChild(root_0, char_literal24_tree);

                    retval.statement = (expression23!=null?expression23.expression:null); 

                    }
                    break;
                case 3 :
                    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:169:5: sw= switch_
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_switch__in_statement589);
                    sw=switch_();

                    state._fsp--;

                    adaptor.addChild(root_0, sw.getTree());
                     retval.statement = (sw!=null?sw.sw:null); 

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "statement"

    public static class expression_return extends ParserRuleReturnScope {
        public Expression expression;
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "expression"
    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:195:1: expression returns [Expression expression] : ( variable '=' )? additiveExpression ;
    public final AmmoScriptParser.expression_return expression() throws RecognitionException {
        AmmoScriptParser.expression_return retval = new AmmoScriptParser.expression_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token char_literal26=null;
        AmmoScriptParser.variable_return variable25 = null;

        AmmoScriptParser.additiveExpression_return additiveExpression27 = null;


        Object char_literal26_tree=null;

         Variable var = null; 
        try {
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:197:3: ( ( variable '=' )? additiveExpression )
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:197:5: ( variable '=' )? additiveExpression
            {
            root_0 = (Object)adaptor.nil();

            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:197:5: ( variable '=' )?
            int alt10=2;
            alt10 = dfa10.predict(input);
            switch (alt10) {
                case 1 :
                    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:197:6: variable '='
                    {
                    pushFollow(FOLLOW_variable_in_expression643);
                    variable25=variable();

                    state._fsp--;

                    adaptor.addChild(root_0, variable25.getTree());
                    char_literal26=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_expression645); 
                    char_literal26_tree = (Object)adaptor.create(char_literal26);
                    adaptor.addChild(root_0, char_literal26_tree);

                     var=(variable25!=null?variable25.variable:null); 

                    }
                    break;

            }

            pushFollow(FOLLOW_additiveExpression_in_expression652);
            additiveExpression27=additiveExpression();

            state._fsp--;

            adaptor.addChild(root_0, additiveExpression27.getTree());
             retval.expression = createExpr(var, "=", (additiveExpression27!=null?additiveExpression27.expression:null)); 

            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "expression"

    public static class additiveExpression_return extends ParserRuleReturnScope {
        public Expression expression;
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "additiveExpression"
    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:202:1: additiveExpression returns [Expression expression] : m= multiplicativeExpression ( ( '+' | '-' ) m= multiplicativeExpression )* ;
    public final AmmoScriptParser.additiveExpression_return additiveExpression() throws RecognitionException {
        AmmoScriptParser.additiveExpression_return retval = new AmmoScriptParser.additiveExpression_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token char_literal28=null;
        Token char_literal29=null;
        AmmoScriptParser.multiplicativeExpression_return m = null;


        Object char_literal28_tree=null;
        Object char_literal29_tree=null;

         String op = null; 
        try {
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:204:3: (m= multiplicativeExpression ( ( '+' | '-' ) m= multiplicativeExpression )* )
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:204:5: m= multiplicativeExpression ( ( '+' | '-' ) m= multiplicativeExpression )*
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression687);
            m=multiplicativeExpression();

            state._fsp--;

            adaptor.addChild(root_0, m.getTree());
             retval.expression = (m!=null?m.expression:null); 
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:205:5: ( ( '+' | '-' ) m= multiplicativeExpression )*
            loop12:
            do {
                int alt12=2;
                int LA12_0 = input.LA(1);

                if ( (LA12_0==MINUS||LA12_0==ADDITION) ) {
                    alt12=1;
                }


                switch (alt12) {
            	case 1 :
            	    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:205:8: ( '+' | '-' ) m= multiplicativeExpression
            	    {
            	    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:205:8: ( '+' | '-' )
            	    int alt11=2;
            	    int LA11_0 = input.LA(1);

            	    if ( (LA11_0==ADDITION) ) {
            	        alt11=1;
            	    }
            	    else if ( (LA11_0==MINUS) ) {
            	        alt11=2;
            	    }
            	    else {
            	        NoViableAltException nvae =
            	            new NoViableAltException("", 11, 0, input);

            	        throw nvae;
            	    }
            	    switch (alt11) {
            	        case 1 :
            	            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:205:9: '+'
            	            {
            	            char_literal28=(Token)match(input,ADDITION,FOLLOW_ADDITION_in_additiveExpression699); 
            	            char_literal28_tree = (Object)adaptor.create(char_literal28);
            	            adaptor.addChild(root_0, char_literal28_tree);

            	            op = "+";

            	            }
            	            break;
            	        case 2 :
            	            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:205:25: '-'
            	            {
            	            char_literal29=(Token)match(input,MINUS,FOLLOW_MINUS_in_additiveExpression703); 
            	            char_literal29_tree = (Object)adaptor.create(char_literal29);
            	            adaptor.addChild(root_0, char_literal29_tree);

            	            op = "-";

            	            }
            	            break;

            	    }

            	    pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression715);
            	    m=multiplicativeExpression();

            	    state._fsp--;

            	    adaptor.addChild(root_0, m.getTree());
            	     retval.expression = createExpr(retval.expression, op, (m!=null?m.expression:null)); 

            	    }
            	    break;

            	default :
            	    break loop12;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "additiveExpression"

    public static class multiplicativeExpression_return extends ParserRuleReturnScope {
        public Expression expression;
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "multiplicativeExpression"
    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:209:1: multiplicativeExpression returns [Expression expression] : p= primary ( ( '*' | '/' | '%' ) p= primary )* ;
    public final AmmoScriptParser.multiplicativeExpression_return multiplicativeExpression() throws RecognitionException {
        AmmoScriptParser.multiplicativeExpression_return retval = new AmmoScriptParser.multiplicativeExpression_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token char_literal30=null;
        Token char_literal31=null;
        Token char_literal32=null;
        AmmoScriptParser.primary_return p = null;


        Object char_literal30_tree=null;
        Object char_literal31_tree=null;
        Object char_literal32_tree=null;

         String op = null; 
        try {
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:211:3: (p= primary ( ( '*' | '/' | '%' ) p= primary )* )
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:211:5: p= primary ( ( '*' | '/' | '%' ) p= primary )*
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_primary_in_multiplicativeExpression747);
            p=primary();

            state._fsp--;

            adaptor.addChild(root_0, p.getTree());
             retval.expression = (p!=null?p.expression:null); 
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:212:5: ( ( '*' | '/' | '%' ) p= primary )*
            loop14:
            do {
                int alt14=2;
                int LA14_0 = input.LA(1);

                if ( ((LA14_0>=MULTIPLICATION && LA14_0<=MODULUS)) ) {
                    alt14=1;
                }


                switch (alt14) {
            	case 1 :
            	    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:212:9: ( '*' | '/' | '%' ) p= primary
            	    {
            	    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:212:9: ( '*' | '/' | '%' )
            	    int alt13=3;
            	    switch ( input.LA(1) ) {
            	    case MULTIPLICATION:
            	        {
            	        alt13=1;
            	        }
            	        break;
            	    case DIVISION:
            	        {
            	        alt13=2;
            	        }
            	        break;
            	    case MODULUS:
            	        {
            	        alt13=3;
            	        }
            	        break;
            	    default:
            	        NoViableAltException nvae =
            	            new NoViableAltException("", 13, 0, input);

            	        throw nvae;
            	    }

            	    switch (alt13) {
            	        case 1 :
            	            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:212:10: '*'
            	            {
            	            char_literal30=(Token)match(input,MULTIPLICATION,FOLLOW_MULTIPLICATION_in_multiplicativeExpression760); 
            	            char_literal30_tree = (Object)adaptor.create(char_literal30);
            	            adaptor.addChild(root_0, char_literal30_tree);

            	            op = "*";

            	            }
            	            break;
            	        case 2 :
            	            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:212:26: '/'
            	            {
            	            char_literal31=(Token)match(input,DIVISION,FOLLOW_DIVISION_in_multiplicativeExpression764); 
            	            char_literal31_tree = (Object)adaptor.create(char_literal31);
            	            adaptor.addChild(root_0, char_literal31_tree);

            	            op = "/";

            	            }
            	            break;
            	        case 3 :
            	            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:212:42: '%'
            	            {
            	            char_literal32=(Token)match(input,MODULUS,FOLLOW_MODULUS_in_multiplicativeExpression768); 
            	            char_literal32_tree = (Object)adaptor.create(char_literal32);
            	            adaptor.addChild(root_0, char_literal32_tree);

            	            op = "%";

            	            }
            	            break;

            	    }

            	    pushFollow(FOLLOW_primary_in_multiplicativeExpression779);
            	    p=primary();

            	    state._fsp--;

            	    adaptor.addChild(root_0, p.getTree());
            	     retval.expression = createExpr(retval.expression, op, (p!=null?p.expression:null)); 

            	    }
            	    break;

            	default :
            	    break loop14;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "multiplicativeExpression"

    public static class primary_return extends ParserRuleReturnScope {
        public Expression expression;
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "primary"
    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:216:1: primary returns [Expression expression] : ( literal | p= path[false] | c= call );
    public final AmmoScriptParser.primary_return primary() throws RecognitionException {
        AmmoScriptParser.primary_return retval = new AmmoScriptParser.primary_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        AmmoScriptParser.path_return p = null;

        AmmoScriptParser.call_return c = null;

        AmmoScriptParser.literal_return literal33 = null;



        try {
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:217:5: ( literal | p= path[false] | c= call )
            int alt15=3;
            alt15 = dfa15.predict(input);
            switch (alt15) {
                case 1 :
                    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:217:7: literal
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_literal_in_primary805);
                    literal33=literal();

                    state._fsp--;

                    adaptor.addChild(root_0, literal33.getTree());
                     retval.expression = (literal33!=null?literal33.constantVar:null); 

                    }
                    break;
                case 2 :
                    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:218:7: p= path[false]
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_path_in_primary817);
                    p=path(false);

                    state._fsp--;

                    adaptor.addChild(root_0, p.getTree());
                     retval.expression = new DynamicVariable((p!=null?p.link:null)); 

                    }
                    break;
                case 3 :
                    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:219:7: c= call
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_call_in_primary830);
                    c=call();

                    state._fsp--;

                    adaptor.addChild(root_0, c.getTree());
                     retval.expression = (c!=null?c.call:null); 

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "primary"

    public static class call_return extends ParserRuleReturnScope {
        public Call call;
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "call"
    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:223:1: call returns [Call call] : path[true] OPENING_BRACKET parameterList CLOSING_BRACKET ;
    public final AmmoScriptParser.call_return call() throws RecognitionException {
        AmmoScriptParser.call_return retval = new AmmoScriptParser.call_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token OPENING_BRACKET35=null;
        Token CLOSING_BRACKET37=null;
        AmmoScriptParser.path_return path34 = null;

        AmmoScriptParser.parameterList_return parameterList36 = null;


        Object OPENING_BRACKET35_tree=null;
        Object CLOSING_BRACKET37_tree=null;

        try {
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:224:3: ( path[true] OPENING_BRACKET parameterList CLOSING_BRACKET )
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:224:5: path[true] OPENING_BRACKET parameterList CLOSING_BRACKET
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_path_in_call856);
            path34=path(true);

            state._fsp--;

            adaptor.addChild(root_0, path34.getTree());
            OPENING_BRACKET35=(Token)match(input,OPENING_BRACKET,FOLLOW_OPENING_BRACKET_in_call859); 
            OPENING_BRACKET35_tree = (Object)adaptor.create(OPENING_BRACKET35);
            adaptor.addChild(root_0, OPENING_BRACKET35_tree);

            pushFollow(FOLLOW_parameterList_in_call861);
            parameterList36=parameterList();

            state._fsp--;

            adaptor.addChild(root_0, parameterList36.getTree());
            CLOSING_BRACKET37=(Token)match(input,CLOSING_BRACKET,FOLLOW_CLOSING_BRACKET_in_call863); 
            CLOSING_BRACKET37_tree = (Object)adaptor.create(CLOSING_BRACKET37);
            adaptor.addChild(root_0, CLOSING_BRACKET37_tree);

             retval.call = new Call( new DynamicVariable((path34!=null?path34.link:null)), (path34!=null?path34.target:null), (parameterList36!=null?parameterList36.map:null)); 

            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "call"

    public static class parameterList_return extends ParserRuleReturnScope {
        public Map<String, Expression> map;
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "parameterList"
    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:227:1: parameterList returns [Map<String, Expression> map] : (param1= parameter ( COLON param2= parameter )* )? ;
    public final AmmoScriptParser.parameterList_return parameterList() throws RecognitionException {
        AmmoScriptParser.parameterList_return retval = new AmmoScriptParser.parameterList_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token COLON38=null;
        AmmoScriptParser.parameter_return param1 = null;

        AmmoScriptParser.parameter_return param2 = null;


        Object COLON38_tree=null;

         retval.map = new HashMap<String, Expression>(); 
        try {
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:229:3: ( (param1= parameter ( COLON param2= parameter )* )? )
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:229:5: (param1= parameter ( COLON param2= parameter )* )?
            {
            root_0 = (Object)adaptor.nil();

            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:229:5: (param1= parameter ( COLON param2= parameter )* )?
            int alt17=2;
            int LA17_0 = input.LA(1);

            if ( (LA17_0==IDENTIFIER) ) {
                alt17=1;
            }
            switch (alt17) {
                case 1 :
                    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:229:6: param1= parameter ( COLON param2= parameter )*
                    {
                    pushFollow(FOLLOW_parameter_in_parameterList897);
                    param1=parameter();

                    state._fsp--;

                    adaptor.addChild(root_0, param1.getTree());
                     retval.map.put(param1.name, param1.expression); 
                    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:230:5: ( COLON param2= parameter )*
                    loop16:
                    do {
                        int alt16=2;
                        int LA16_0 = input.LA(1);

                        if ( (LA16_0==COLON) ) {
                            alt16=1;
                        }


                        switch (alt16) {
                    	case 1 :
                    	    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:230:6: COLON param2= parameter
                    	    {
                    	    COLON38=(Token)match(input,COLON,FOLLOW_COLON_in_parameterList908); 
                    	    COLON38_tree = (Object)adaptor.create(COLON38);
                    	    adaptor.addChild(root_0, COLON38_tree);

                    	    pushFollow(FOLLOW_parameter_in_parameterList912);
                    	    param2=parameter();

                    	    state._fsp--;

                    	    adaptor.addChild(root_0, param2.getTree());
                    	     retval.map.put(param2.name, param2.expression); 

                    	    }
                    	    break;

                    	default :
                    	    break loop16;
                        }
                    } while (true);


                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "parameterList"

    public static class parameter_return extends ParserRuleReturnScope {
        public String name;
        public Expression expression;
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "parameter"
    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:234:1: parameter returns [String name, Expression expression] : i= IDENTIFIER KETTOSPONT e= expression ;
    public final AmmoScriptParser.parameter_return parameter() throws RecognitionException {
        AmmoScriptParser.parameter_return retval = new AmmoScriptParser.parameter_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token i=null;
        Token KETTOSPONT39=null;
        AmmoScriptParser.expression_return e = null;


        Object i_tree=null;
        Object KETTOSPONT39_tree=null;

        try {
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:235:3: (i= IDENTIFIER KETTOSPONT e= expression )
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:235:5: i= IDENTIFIER KETTOSPONT e= expression
            {
            root_0 = (Object)adaptor.nil();

            i=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_parameter942); 
            i_tree = (Object)adaptor.create(i);
            adaptor.addChild(root_0, i_tree);

            KETTOSPONT39=(Token)match(input,KETTOSPONT,FOLLOW_KETTOSPONT_in_parameter944); 
            KETTOSPONT39_tree = (Object)adaptor.create(KETTOSPONT39);
            adaptor.addChild(root_0, KETTOSPONT39_tree);

            pushFollow(FOLLOW_expression_in_parameter948);
            e=expression();

            state._fsp--;

            adaptor.addChild(root_0, e.getTree());
            retval.name = (i!=null?i.getText():null); retval.expression = (e!=null?e.expression:null); 

            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "parameter"

    public static class literal_return extends ParserRuleReturnScope {
        public Constant constantVar;
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "literal"
    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:238:1: literal returns [ConstantVariable constantVar] : (num= number | str= string );
    public final AmmoScriptParser.literal_return literal() throws RecognitionException {
        AmmoScriptParser.literal_return retval = new AmmoScriptParser.literal_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        AmmoScriptParser.number_return num = null;

        AmmoScriptParser.string_return str = null;



        try {
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:239:3: (num= number | str= string )
            int alt18=2;
            int LA18_0 = input.LA(1);

            if ( (LA18_0==NUMBER) ) {
                alt18=1;
            }
            else if ( (LA18_0==STRING) ) {
                alt18=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 18, 0, input);

                throw nvae;
            }
            switch (alt18) {
                case 1 :
                    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:239:5: num= number
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_number_in_literal977);
                    num=number();

                    state._fsp--;

                    adaptor.addChild(root_0, num.getTree());
                     retval.constantVar = new Constant((num!=null?num.intField:null)); 

                    }
                    break;
                case 2 :
                    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:240:5: str= string
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_string_in_literal987);
                    str=string();

                    state._fsp--;

                    adaptor.addChild(root_0, str.getTree());
                     retval.constantVar = new Constant((str!=null?str.strField:null)); 

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "literal"

    public static class variable_return extends ParserRuleReturnScope {
        public Variable variable;
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "variable"
    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:244:1: variable returns [Variable variable] : p= path[false] ;
    public final AmmoScriptParser.variable_return variable() throws RecognitionException {
        AmmoScriptParser.variable_return retval = new AmmoScriptParser.variable_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        AmmoScriptParser.path_return p = null;



        try {
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:245:3: (p= path[false] )
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:245:5: p= path[false]
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_path_in_variable1011);
            p=path(false);

            state._fsp--;

            adaptor.addChild(root_0, p.getTree());
             retval.variable = new DynamicVariable((p!=null?p.link:null)); 

            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "variable"

    public static class path_return extends ParserRuleReturnScope {
        public Reference link;
        public String target;
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "path"
    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:247:1: path[boolean separated] returns [SoftLink link, String target] : id= IDENTIFIER ( DELIMITER id= IDENTIFIER )* ;
    public final AmmoScriptParser.path_return path(boolean separated) throws RecognitionException {
        AmmoScriptParser.path_return retval = new AmmoScriptParser.path_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token id=null;
        Token DELIMITER40=null;

        Object id_tree=null;
        Object DELIMITER40_tree=null;

        String path = null;
        try {
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:254:3: (id= IDENTIFIER ( DELIMITER id= IDENTIFIER )* )
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:254:5: id= IDENTIFIER ( DELIMITER id= IDENTIFIER )*
            {
            root_0 = (Object)adaptor.nil();

            id=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_path1051); 
            id_tree = (Object)adaptor.create(id);
            adaptor.addChild(root_0, id_tree);

            retval.target = (id!=null?id.getText():null); 
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:255:5: ( DELIMITER id= IDENTIFIER )*
            loop19:
            do {
                int alt19=2;
                int LA19_0 = input.LA(1);

                if ( (LA19_0==DELIMITER) ) {
                    alt19=1;
                }


                switch (alt19) {
            	case 1 :
            	    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:255:6: DELIMITER id= IDENTIFIER
            	    {
            	    DELIMITER40=(Token)match(input,DELIMITER,FOLLOW_DELIMITER_in_path1060); 
            	    DELIMITER40_tree = (Object)adaptor.create(DELIMITER40);
            	    adaptor.addChild(root_0, DELIMITER40_tree);

            	    id=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_path1064); 
            	    id_tree = (Object)adaptor.create(id);
            	    adaptor.addChild(root_0, id_tree);


            	            if (path == null)
            	              path = retval.target;
            	            else
            	              path += YObject.DELIMITER + retval.target;
            	              
            	           retval.target = (id!=null?id.getText():null); 

            	    }
            	    break;

            	default :
            	    break loop19;
                }
            } while (true);


                  if (separated)
                    retval.link = new Reference(path);
                  else
                    retval.link = new Reference( (path != null ? path + YObject.DELIMITER + retval.target : retval.target));
                    
                

            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "path"

    public static class number_return extends ParserRuleReturnScope {
        public IntegerField intField;
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "number"
    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:294:1: number returns [IntegerField intField] : num= NUMBER ;
    public final AmmoScriptParser.number_return number() throws RecognitionException {
        AmmoScriptParser.number_return retval = new AmmoScriptParser.number_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token num=null;

        Object num_tree=null;

        try {
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:295:3: (num= NUMBER )
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:295:5: num= NUMBER
            {
            root_0 = (Object)adaptor.nil();

            num=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_number1143); 
            num_tree = (Object)adaptor.create(num);
            adaptor.addChild(root_0, num_tree);

             retval.intField = new IntegerField( Integer.parseInt((num!=null?num.getText():null)) ); 

            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "number"

    public static class string_return extends ParserRuleReturnScope {
        public StringField strField;
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "string"
    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:305:1: string returns [StringField strField] : str= STRING ;
    public final AmmoScriptParser.string_return string() throws RecognitionException {
        AmmoScriptParser.string_return retval = new AmmoScriptParser.string_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token str=null;

        Object str_tree=null;

        try {
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:306:3: (str= STRING )
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:306:5: str= STRING
            {
            root_0 = (Object)adaptor.nil();

            str=(Token)match(input,STRING,FOLLOW_STRING_in_string1171); 
            str_tree = (Object)adaptor.create(str);
            adaptor.addChild(root_0, str_tree);

             String value = (str!=null?str.getText():null); retval.strField = new StringField(value, value.substring(1, value.length()-1) ); 

            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "string"

    public static class assignmentOperator_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "assignmentOperator"
    // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:309:1: assignmentOperator : '=' ;
    public final AmmoScriptParser.assignmentOperator_return assignmentOperator() throws RecognitionException {
        AmmoScriptParser.assignmentOperator_return retval = new AmmoScriptParser.assignmentOperator_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token char_literal41=null;

        Object char_literal41_tree=null;

        try {
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:310:2: ( '=' )
            // /home/solusa/Projects/AMMO/Eclipse_3.5_Workspace/AMMO_Common/src/hu/swankey/ammo/common/script/AmmoScript.g:310:4: '='
            {
            root_0 = (Object)adaptor.nil();

            char_literal41=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_assignmentOperator1183); 
            char_literal41_tree = (Object)adaptor.create(char_literal41);
            adaptor.addChild(root_0, char_literal41_tree);


            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "assignmentOperator"

    // Delegated rules


    protected DFA3 dfa3 = new DFA3(this);
    protected DFA10 dfa10 = new DFA10(this);
    protected DFA15 dfa15 = new DFA15(this);
    static final String DFA3_eotS =
        "\13\uffff";
    static final String DFA3_eofS =
        "\13\uffff";
    static final String DFA3_minS =
        "\1\24\1\uffff\5\20\1\25\1\20\2\uffff";
    static final String DFA3_maxS =
        "\1\33\1\uffff\3\20\1\36\1\20\1\27\1\36\2\uffff";
    static final String DFA3_acceptS =
        "\1\uffff\1\3\7\uffff\1\2\1\1";
    static final String DFA3_specialS =
        "\13\uffff}>";
    static final String[] DFA3_transitionS = {
            "\1\1\4\uffff\1\2\1\3\1\4",
            "",
            "\1\5",
            "\1\5",
            "\1\5",
            "\1\7\15\uffff\1\6",
            "\1\10",
            "\2\12\1\11",
            "\1\7\15\uffff\1\6",
            "",
            ""
    };

    static final short[] DFA3_eot = DFA.unpackEncodedString(DFA3_eotS);
    static final short[] DFA3_eof = DFA.unpackEncodedString(DFA3_eofS);
    static final char[] DFA3_min = DFA.unpackEncodedStringToUnsignedChars(DFA3_minS);
    static final char[] DFA3_max = DFA.unpackEncodedStringToUnsignedChars(DFA3_maxS);
    static final short[] DFA3_accept = DFA.unpackEncodedString(DFA3_acceptS);
    static final short[] DFA3_special = DFA.unpackEncodedString(DFA3_specialS);
    static final short[][] DFA3_transition;

    static {
        int numStates = DFA3_transitionS.length;
        DFA3_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA3_transition[i] = DFA.unpackEncodedString(DFA3_transitionS[i]);
        }
    }

    class DFA3 extends DFA {

        public DFA3(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 3;
            this.eot = DFA3_eot;
            this.eof = DFA3_eof;
            this.min = DFA3_min;
            this.max = DFA3_max;
            this.accept = DFA3_accept;
            this.special = DFA3_special;
            this.transition = DFA3_transition;
        }
        public String getDescription() {
            return "()* loopback of 97:5: (var= variableDeclaration | method= methodDeclaration )*";
        }
    }
    static final String DFA10_eotS =
        "\6\uffff";
    static final String DFA10_eofS =
        "\6\uffff";
    static final String DFA10_minS =
        "\1\20\1\22\1\uffff\1\20\1\uffff\1\22";
    static final String DFA10_maxS =
        "\1\40\1\57\1\uffff\1\20\1\uffff\1\57";
    static final String DFA10_acceptS =
        "\2\uffff\1\2\1\uffff\1\1\1\uffff";
    static final String DFA10_specialS =
        "\6\uffff}>";
    static final String[] DFA10_transitionS = {
            "\1\1\16\uffff\2\2",
            "\1\2\2\uffff\1\4\3\2\4\uffff\1\2\1\3\3\uffff\1\2\11\uffff\4"+
            "\2",
            "",
            "\1\5",
            "",
            "\1\2\2\uffff\1\4\3\2\4\uffff\1\2\1\3\3\uffff\1\2\11\uffff\4"+
            "\2"
    };

    static final short[] DFA10_eot = DFA.unpackEncodedString(DFA10_eotS);
    static final short[] DFA10_eof = DFA.unpackEncodedString(DFA10_eofS);
    static final char[] DFA10_min = DFA.unpackEncodedStringToUnsignedChars(DFA10_minS);
    static final char[] DFA10_max = DFA.unpackEncodedStringToUnsignedChars(DFA10_maxS);
    static final short[] DFA10_accept = DFA.unpackEncodedString(DFA10_acceptS);
    static final short[] DFA10_special = DFA.unpackEncodedString(DFA10_specialS);
    static final short[][] DFA10_transition;

    static {
        int numStates = DFA10_transitionS.length;
        DFA10_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA10_transition[i] = DFA.unpackEncodedString(DFA10_transitionS[i]);
        }
    }

    class DFA10 extends DFA {

        public DFA10(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 10;
            this.eot = DFA10_eot;
            this.eof = DFA10_eof;
            this.min = DFA10_min;
            this.max = DFA10_max;
            this.accept = DFA10_accept;
            this.special = DFA10_special;
            this.transition = DFA10_transition;
        }
        public String getDescription() {
            return "197:5: ( variable '=' )?";
        }
    }
    static final String DFA15_eotS =
        "\7\uffff";
    static final String DFA15_eofS =
        "\7\uffff";
    static final String DFA15_minS =
        "\1\20\1\uffff\1\22\1\20\2\uffff\1\22";
    static final String DFA15_maxS =
        "\1\40\1\uffff\1\57\1\20\2\uffff\1\57";
    static final String DFA15_acceptS =
        "\1\uffff\1\1\2\uffff\1\3\1\2\1\uffff";
    static final String DFA15_specialS =
        "\7\uffff}>";
    static final String[] DFA15_transitionS = {
            "\1\2\16\uffff\2\1",
            "",
            "\1\5\3\uffff\1\5\1\4\1\5\4\uffff\1\5\1\3\3\uffff\1\5\11\uffff"+
            "\4\5",
            "\1\6",
            "",
            "",
            "\1\5\3\uffff\1\5\1\4\1\5\4\uffff\1\5\1\3\3\uffff\1\5\11\uffff"+
            "\4\5"
    };

    static final short[] DFA15_eot = DFA.unpackEncodedString(DFA15_eotS);
    static final short[] DFA15_eof = DFA.unpackEncodedString(DFA15_eofS);
    static final char[] DFA15_min = DFA.unpackEncodedStringToUnsignedChars(DFA15_minS);
    static final char[] DFA15_max = DFA.unpackEncodedStringToUnsignedChars(DFA15_maxS);
    static final short[] DFA15_accept = DFA.unpackEncodedString(DFA15_acceptS);
    static final short[] DFA15_special = DFA.unpackEncodedString(DFA15_specialS);
    static final short[][] DFA15_transition;

    static {
        int numStates = DFA15_transitionS.length;
        DFA15_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA15_transition[i] = DFA.unpackEncodedString(DFA15_transitionS[i]);
        }
    }

    class DFA15 extends DFA {

        public DFA15(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 15;
            this.eot = DFA15_eot;
            this.eof = DFA15_eof;
            this.min = DFA15_min;
            this.max = DFA15_max;
            this.accept = DFA15_accept;
            this.special = DFA15_special;
            this.transition = DFA15_transition;
        }
        public String getDescription() {
            return "216:1: primary returns [Expression expression] : ( literal | p= path[false] | c= call );";
        }
    }
 

    public static final BitSet FOLLOW_accessLevel_in_classDeclaration143 = new BitSet(new long[]{0x0000000000010000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_classDeclaration147 = new BitSet(new long[]{0x00000000000A0000L});
    public static final BitSet FOLLOW_KEYWORD_EXTENDS_in_classDeclaration160 = new BitSet(new long[]{0x0000000000010000L});
    public static final BitSet FOLLOW_path_in_classDeclaration168 = new BitSet(new long[]{0x00000000000C0000L});
    public static final BitSet FOLLOW_COLON_in_classDeclaration178 = new BitSet(new long[]{0x0000000000010000L});
    public static final BitSet FOLLOW_path_in_classDeclaration182 = new BitSet(new long[]{0x00000000000C0000L});
    public static final BitSet FOLLOW_OPENING_PARENTHESIS_in_classDeclaration198 = new BitSet(new long[]{0x000000000E100000L});
    public static final BitSet FOLLOW_variableDeclaration_in_classDeclaration208 = new BitSet(new long[]{0x000000000E100000L});
    public static final BitSet FOLLOW_methodDeclaration_in_classDeclaration223 = new BitSet(new long[]{0x000000000E100000L});
    public static final BitSet FOLLOW_CLOSING_PARENTHESIS_in_classDeclaration236 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_accessLevel_in_variableDeclaration260 = new BitSet(new long[]{0x0000000000010000L});
    public static final BitSet FOLLOW_path_in_variableDeclaration264 = new BitSet(new long[]{0x0000000000010000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_variableDeclaration270 = new BitSet(new long[]{0x0000000000600000L});
    public static final BitSet FOLLOW_ASSIGN_in_variableDeclaration274 = new BitSet(new long[]{0x0000000180010000L});
    public static final BitSet FOLLOW_expression_in_variableDeclaration276 = new BitSet(new long[]{0x0000000000400000L});
    public static final BitSet FOLLOW_SEMICOLON_in_variableDeclaration280 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_accessLevel_in_methodDeclaration317 = new BitSet(new long[]{0x0000000000010000L});
    public static final BitSet FOLLOW_path_in_methodDeclaration321 = new BitSet(new long[]{0x0000000000010000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_methodDeclaration326 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_OPENING_BRACKET_in_methodDeclaration330 = new BitSet(new long[]{0x0000000001010000L});
    public static final BitSet FOLLOW_parameterDeclaration_in_methodDeclaration337 = new BitSet(new long[]{0x0000000001010000L});
    public static final BitSet FOLLOW_CLOSING_BRACKET_in_methodDeclaration345 = new BitSet(new long[]{0x0000000000080000L});
    public static final BitSet FOLLOW_block_in_methodDeclaration349 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_path_in_parameterDeclaration373 = new BitSet(new long[]{0x0000000000010000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_parameterDeclaration378 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_OPENING_PARENTHESIS_in_block406 = new BitSet(new long[]{0x0000000180194000L});
    public static final BitSet FOLLOW_statement_in_block411 = new BitSet(new long[]{0x0000000180194000L});
    public static final BitSet FOLLOW_CLOSING_PARENTHESIS_in_block423 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_KEYWORD_PRIVATE_in_accessLevel441 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_KEYWORD_PROTECTED_in_accessLevel449 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_KEYWORD_PUBLIC_in_accessLevel457 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SWITCH_in_switch_484 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_OPENING_BRACKET_in_switch_486 = new BitSet(new long[]{0x0000000180010000L});
    public static final BitSet FOLLOW_expression_in_switch_490 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_CLOSING_BRACKET_in_switch_492 = new BitSet(new long[]{0x0000000000080000L});
    public static final BitSet FOLLOW_OPENING_PARENTHESIS_in_switch_499 = new BitSet(new long[]{0x0000000010100000L});
    public static final BitSet FOLLOW_switchCase_in_switch_506 = new BitSet(new long[]{0x0000000010100000L});
    public static final BitSet FOLLOW_CLOSING_PARENTHESIS_in_switch_518 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CASE_in_switchCase540 = new BitSet(new long[]{0x0000000180010000L});
    public static final BitSet FOLLOW_expression_in_switchCase544 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_KETTOSPONT_in_switchCase546 = new BitSet(new long[]{0x0000000180094000L});
    public static final BitSet FOLLOW_statement_in_switchCase550 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_block_in_statement569 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expression_in_statement577 = new BitSet(new long[]{0x0000000000400000L});
    public static final BitSet FOLLOW_SEMICOLON_in_statement579 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_switch__in_statement589 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_variable_in_expression643 = new BitSet(new long[]{0x0000000000200000L});
    public static final BitSet FOLLOW_ASSIGN_in_expression645 = new BitSet(new long[]{0x0000000180010000L});
    public static final BitSet FOLLOW_additiveExpression_in_expression652 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_multiplicativeExpression_in_additiveExpression687 = new BitSet(new long[]{0x0000100400000002L});
    public static final BitSet FOLLOW_ADDITION_in_additiveExpression699 = new BitSet(new long[]{0x0000000180010000L});
    public static final BitSet FOLLOW_MINUS_in_additiveExpression703 = new BitSet(new long[]{0x0000000180010000L});
    public static final BitSet FOLLOW_multiplicativeExpression_in_additiveExpression715 = new BitSet(new long[]{0x0000100400000002L});
    public static final BitSet FOLLOW_primary_in_multiplicativeExpression747 = new BitSet(new long[]{0x0000E00000000002L});
    public static final BitSet FOLLOW_MULTIPLICATION_in_multiplicativeExpression760 = new BitSet(new long[]{0x0000000180010000L});
    public static final BitSet FOLLOW_DIVISION_in_multiplicativeExpression764 = new BitSet(new long[]{0x0000000180010000L});
    public static final BitSet FOLLOW_MODULUS_in_multiplicativeExpression768 = new BitSet(new long[]{0x0000000180010000L});
    public static final BitSet FOLLOW_primary_in_multiplicativeExpression779 = new BitSet(new long[]{0x0000E00000000002L});
    public static final BitSet FOLLOW_literal_in_primary805 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_path_in_primary817 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_call_in_primary830 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_path_in_call856 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_OPENING_BRACKET_in_call859 = new BitSet(new long[]{0x0000000001010000L});
    public static final BitSet FOLLOW_parameterList_in_call861 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_CLOSING_BRACKET_in_call863 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_parameter_in_parameterList897 = new BitSet(new long[]{0x0000000000040002L});
    public static final BitSet FOLLOW_COLON_in_parameterList908 = new BitSet(new long[]{0x0000000000010000L});
    public static final BitSet FOLLOW_parameter_in_parameterList912 = new BitSet(new long[]{0x0000000000040002L});
    public static final BitSet FOLLOW_IDENTIFIER_in_parameter942 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_KETTOSPONT_in_parameter944 = new BitSet(new long[]{0x0000000180010000L});
    public static final BitSet FOLLOW_expression_in_parameter948 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_number_in_literal977 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_string_in_literal987 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_path_in_variable1011 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENTIFIER_in_path1051 = new BitSet(new long[]{0x0000000040000002L});
    public static final BitSet FOLLOW_DELIMITER_in_path1060 = new BitSet(new long[]{0x0000000000010000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_path1064 = new BitSet(new long[]{0x0000000040000002L});
    public static final BitSet FOLLOW_NUMBER_in_number1143 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_STRING_in_string1171 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ASSIGN_in_assignmentOperator1183 = new BitSet(new long[]{0x0000000000000002L});

}