OoasTools

// $ANTLR 3.2 Sep 23, 2009 12:02:23 C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g 2011-02-10 11:21:05

// The variable 'variable' is assigned but its value is never used.

#pragma warning disable 168, 219

// Unreachable code detected.

#pragma warning disable 162

/*

    Ulysses OO-Action System Parser

    Copyright Willibald Krenn 2009

 */

using System;

using Antlr.Runtime;

using IList 		= System.Collections.IList;

using ArrayList 	= System.Collections.ArrayList;

using Stack 		= Antlr.Runtime.Collections.StackList;

using IDictionary	= System.Collections.IDictionary;

using Hashtable 	= System.Collections.Hashtable;

namespace  TUG.Mogentes 

{

public partial class ooaLexer : Lexer {

    public const int T_FLOATNUMBER = 29;

    public const int T_SYSTEM = 6;

    public const int T_ELSE = 87;

    public const int T_LPAREN = 12;

    public const int T_DUNION = 102;

    public const int T_BOOL = 25;

    public const int T_METHODS = 35;

    public const int T_INDS = 105;

    public const int T_OR = 69;

    public const int EOF = -1;

    public const int T_OD = 38;

    public const int T_AND = 75;

    public const int T_OF = 18;

    public const int T_STRINGLITERAL = 93;

    public const int T_SET = 66;

    public const int T_SKIP = 52;

    public const int T_WITH = 57;

    public const int T_DOM = 108;

    public const int T_WS = 111;

    public const int T_VAR = 34;

    public const int T_SUM = 47;

    public const int T_REQUIRES = 45;

    public const int T_DINTER = 101;

    public const int T_AUTOCONS = 33;

    public const int T_HEAD = 104;

    public const int T_END = 43;

    public const int T_TRUE = 90;

    public const int T_LSQPAREN = 15;

    public const int T_MAPS = 96;

    public const int T_PRIMED = 97;

    public const int T_INFTY = 24;

    public const int T_NIL = 92;

    public const int T_IF = 85;

    public const int LINE_COMMENT = 113;

    public const int T_THEN = 86;

    public const int T_FLOAT = 28;

    public const int T_SELF = 55;

    public const int T_TAIL = 107;

    public const int T_DIFF = 48;

    public const int T_MERGE = 110;

    public const int T_FOLDRL = 51;

    public const int T_QUANTITY = 22;

    public const int T_IN = 65;

    public const int T_MUNION = 82;

    public const int T__126 = 126;

    public const int T__125 = 125;

    public const int T_INTER = 74;

    public const int T_SEMICOLON = 7;

    public const int T_FOLDLR = 50;

    public const int T_CARD = 99;

    public const int T_FALSE = 91;

    public const int T_CONT = 44;

    public const int T_SUBSET = 68;

    public const int T_COMMA = 19;

    public const int T_RANGETO = 27;

    public const int T_MINUS = 23;

    public const int T_CONC = 77;

    public const int T_IDIV = 71;

    public const int T_FORALL = 88;

    public const int T_DERIV = 46;

    public const int T_CONSTS = 4;

    public const int T_TYPES = 5;

    public const int T_GREATEREQUAL = 60;

    public const int T__118 = 118;

    public const int T_RNG = 109;

    public const int T__119 = 119;

    public const int T_MOD = 72;

    public const int T__117 = 117;

    public const int T_SEQMOD_MAPOVERRIDE = 83;

    public const int T__124 = 124;

    public const int T__123 = 123;

    public const int T_ELEMS = 103;

    public const int T__122 = 122;

    public const int T__121 = 121;

    public const int T_IMPLIES = 64;

    public const int T__120 = 120;

    public const int T_EXISTS = 89;

    public const int T_POW = 76;

    public const int T_COMMENT = 112;

    public const int T_RPAREN = 13;

    public const int T_PRIO = 10;

    public const int T_RNGRESBY = 80;

    public const int T_ABS = 98;

    public const int T_DIV = 70;

    public const int T_LIST = 14;

    public const int T_CBRL = 31;

    public const int T_DCONC = 100;

    public const int T_ABORT = 53;

    public const int T_CHAR = 30;

    public const int T_STATIC = 39;

    public const int T_POINT = 84;

    public const int T_INT = 26;

    public const int T_CBRR = 32;

    public const int T_PROD = 49;

    public const int T_COLON = 42;

    public const int T_ACTIONS = 36;

    public const int T_LESS = 61;

    public const int T_DIGIT = 114;

    public const int T_BAR = 95;

    public const int T_TO = 21;

    public const int T_NONDET = 11;

    public const int T_DOMRESBY = 78;

    public const int T_DOMRESTO = 79;

    public const int T_EQUAL = 9;

    public const int T_GREATER = 59;

    public const int T_KILL = 54;

    public const int T_RNGRESTO = 81;

    public const int T_RSQPAREN = 17;

    public const int T_NEW = 94;

    public const int T_INTNUMBER = 16;

    public const int T_UNION = 73;

    public const int T_OBS = 40;

    public const int T_BIIMPLIES = 58;

    public const int T_NOTEQUAL = 63;

    public const int T_IDENTIFIER = 8;

    public const int T_DO = 37;

    public const int FLOAT_OR_INT_OR_RANGE = 115;

    public const int T_NOT = 67;

    public const int T_LEN = 106;

    public const int T_ASSIGNMENT = 56;

    public const int T_LETTER = 116;

    public const int T_LESSEQUAL = 62;

    public const int T_MAP = 20;

    public const int T_CTRL = 41;

    // delegates

    // delegators

    public ooaLexer() 

    {

		InitializeCyclicDFAs();

    }

    public ooaLexer(ICharStream input)

		: this(input, null) {

    }

    public ooaLexer(ICharStream input, RecognizerSharedState state)

		: base(input, state) {

		InitializeCyclicDFAs(); 

    }

    override public string GrammarFileName

    {

    	get { return "C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g";} 

    }

    // $ANTLR start "T__117"

    public void mT__117() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T__117;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:17:8: ( '|[' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:17:10: '|['

            {

            	Match("|["); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T__117"

    // $ANTLR start "T__118"

    public void mT__118() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T__118;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:18:8: ( ']|' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:18:10: ']|'

            {

            	Match("]|"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T__118"

    // $ANTLR start "T__119"

    public void mT__119() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T__119;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:19:8: ( 'begin' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:19:10: 'begin'

            {

            	Match("begin"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T__119"

    // $ANTLR start "T__120"

    public void mT__120() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T__120;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:20:8: ( '&' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:20:10: '&'

            {

            	Match('&'); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T__120"

    // $ANTLR start "T__121"

    public void mT__121() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T__121;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:21:8: ( 'as' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:21:10: 'as'

            {

            	Match("as"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T__121"

    // $ANTLR start "T__122"

    public void mT__122() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T__122;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:22:8: ( 'qval' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:22:10: 'qval'

            {

            	Match("qval"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T__122"

    // $ANTLR start "T__123"

    public void mT__123() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T__123;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:23:8: ( 'steady' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:23:10: 'steady'

            {

            	Match("steady"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T__123"

    // $ANTLR start "T__124"

    public void mT__124() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T__124;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:24:8: ( 'inc' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:24:10: 'inc'

            {

            	Match("inc"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T__124"

    // $ANTLR start "T__125"

    public void mT__125() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T__125;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:25:8: ( 'dec' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:25:10: 'dec'

            {

            	Match("dec"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T__125"

    // $ANTLR start "T__126"

    public void mT__126() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T__126;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:26:8: ( '::' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:26:10: '::'

            {

            	Match("::"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T__126"

    // $ANTLR start "T_WS"

    public void mT_WS() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_WS;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:989:8: ( ( ' ' | '\\r' | '\\t' | '\\u000C' | '\\n' ) )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:989:10: ( ' ' | '\\r' | '\\t' | '\\u000C' | '\\n' )

            {

            	if ( (input.LA(1) >= '\t' && input.LA(1) <= '\n') || (input.LA(1) >= '\f' && input.LA(1) <= '\r') || input.LA(1) == ' ' ) 

            	{

            	    input.Consume();

            	state.failed = false;

            	}

            	else 

            	{

            	    if ( state.backtracking > 0 ) {state.failed = true; return ;}

            	    MismatchedSetException mse = new MismatchedSetException(null,input);

            	    Recover(mse);

            	    throw mse;}

            	if ( (state.backtracking==0) )

            	{

            	  _channel=HIDDEN;

            	}

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_WS"

    // $ANTLR start "T_COMMENT"

    public void mT_COMMENT() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_COMMENT;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:993:6: ( '/*' ( . )* '*/' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:993:8: '/*' ( . )* '*/'

            {

            	Match("/*"); if (state.failed) return ;

            	// C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:993:13: ( . )*

            	do 

            	{

            	    int alt1 = 2;

            	    int LA1_0 = input.LA(1);

            	    if ( (LA1_0 == '*') )

            	    {

            	        int LA1_1 = input.LA(2);

            	        if ( (LA1_1 == '/') )

            	        {

            	            alt1 = 2;

            	        }

            	        else if ( ((LA1_1 >= '\u0000' && LA1_1 <= '.') || (LA1_1 >= '0' && LA1_1 <= '\uFFFF')) )

            	        {

            	            alt1 = 1;

            	        }

            	    }

            	    else if ( ((LA1_0 >= '\u0000' && LA1_0 <= ')') || (LA1_0 >= '+' && LA1_0 <= '\uFFFF')) )

            	    {

            	        alt1 = 1;

            	    }

            	    switch (alt1) 

            		{

            			case 1 :

            			    // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:993:13: .

            			    {

            			    	MatchAny(); if (state.failed) return ;

            			    }

            			    break;

            			default:

            			    goto loop1;

            	    }

            	} while (true);

            	loop1:

            		;	// Stops C# compiler whining that label 'loop1' has no statements

            	Match("*/"); if (state.failed) return ;

            	if ( (state.backtracking==0) )

            	{

            	  _channel=HIDDEN;

            	}

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_COMMENT"

    // $ANTLR start "LINE_COMMENT"

    public void mLINE_COMMENT() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = LINE_COMMENT;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:997:6: ( '#' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:997:8: '#' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n'

            {

            	Match('#'); if (state.failed) return ;

            	// C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:997:12: (~ ( '\\n' | '\\r' ) )*

            	do 

            	{

            	    int alt2 = 2;

            	    int LA2_0 = input.LA(1);

            	    if ( ((LA2_0 >= '\u0000' && LA2_0 <= '\t') || (LA2_0 >= '\u000B' && LA2_0 <= '\f') || (LA2_0 >= '\u000E' && LA2_0 <= '\uFFFF')) )

            	    {

            	        alt2 = 1;

            	    }

            	    switch (alt2) 

            		{

            			case 1 :

            			    // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:997:12: ~ ( '\\n' | '\\r' )

            			    {

            			    	if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '\t') || (input.LA(1) >= '\u000B' && input.LA(1) <= '\f') || (input.LA(1) >= '\u000E' && input.LA(1) <= '\uFFFF') ) 

            			    	{

            			    	    input.Consume();

            			    	state.failed = false;

            			    	}

            			    	else 

            			    	{

            			    	    if ( state.backtracking > 0 ) {state.failed = true; return ;}

            			    	    MismatchedSetException mse = new MismatchedSetException(null,input);

            			    	    Recover(mse);

            			    	    throw mse;}

            			    }

            			    break;

            			default:

            			    goto loop2;

            	    }

            	} while (true);

            	loop2:

            		;	// Stops C# compiler whining that label 'loop2' has no statements

            	// C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:997:26: ( '\\r' )?

            	int alt3 = 2;

            	int LA3_0 = input.LA(1);

            	if ( (LA3_0 == '\r') )

            	{

            	    alt3 = 1;

            	}

            	switch (alt3) 

            	{

            	    case 1 :

            	        // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:997:26: '\\r'

            	        {

            	        	Match('\r'); if (state.failed) return ;

            	        }

            	        break;

            	}

            	Match('\n'); if (state.failed) return ;

            	if ( (state.backtracking==0) )

            	{

            	  _channel=HIDDEN;

            	}

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "LINE_COMMENT"

    // $ANTLR start "T_PRIMED"

    public void mT_PRIMED() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_PRIMED;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1001:2: ( '\\'' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1001:4: '\\''

            {

            	Match('\''); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_PRIMED"

    // $ANTLR start "T_STRINGLITERAL"

    public void mT_STRINGLITERAL() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_STRINGLITERAL;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1004:2: ( '\"' ( ( '\"' '\"' )=> '\"' | ~ '\"' )* '\"' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1004:4: '\"' ( ( '\"' '\"' )=> '\"' | ~ '\"' )* '\"'

            {

            	Match('\"'); if (state.failed) return ;

            	// C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1005:3: ( ( '\"' '\"' )=> '\"' | ~ '\"' )*

            	do 

            	{

            	    int alt4 = 3;

            	    int LA4_0 = input.LA(1);

            	    if ( (LA4_0 == '\"') )

            	    {

            	        int LA4_1 = input.LA(2);

            	        if ( (LA4_1 == '\"') && (synpred1_ooa()) )

            	        {

            	            alt4 = 1;

            	        }

            	        else if ( ((LA4_1 >= '\u0000' && LA4_1 <= '!') || (LA4_1 >= '#' && LA4_1 <= '\uFFFF')) && (synpred1_ooa()) )

            	        {

            	            alt4 = 1;

            	        }

            	    }

            	    else if ( ((LA4_0 >= '\u0000' && LA4_0 <= '!') || (LA4_0 >= '#' && LA4_0 <= '\uFFFF')) )

            	    {

            	        alt4 = 2;

            	    }

            	    switch (alt4) 

            		{

            			case 1 :

            			    // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1006:9: ( '\"' '\"' )=> '\"'

            			    {

            			    	Match('\"'); if (state.failed) return ;

            			    }

            			    break;

            			case 2 :

            			    // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1007:13: ~ '\"'

            			    {

            			    	if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '!') || (input.LA(1) >= '#' && input.LA(1) <= '\uFFFF') ) 

            			    	{

            			    	    input.Consume();

            			    	state.failed = false;

            			    	}

            			    	else 

            			    	{

            			    	    if ( state.backtracking > 0 ) {state.failed = true; return ;}

            			    	    MismatchedSetException mse = new MismatchedSetException(null,input);

            			    	    Recover(mse);

            			    	    throw mse;}

            			    }

            			    break;

            			default:

            			    goto loop4;

            	    }

            	} while (true);

            	loop4:

            		;	// Stops C# compiler whining that label 'loop4' has no statements

            	Match('\"'); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_STRINGLITERAL"

    // $ANTLR start "T_ABORT"

    public void mT_ABORT() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_ABORT;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1013:9: ( 'abort' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1013:11: 'abort'

            {

            	Match("abort"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_ABORT"

    // $ANTLR start "T_ACTIONS"

    public void mT_ACTIONS() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_ACTIONS;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1015:2: ( 'actions' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1015:4: 'actions'

            {

            	Match("actions"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_ACTIONS"

    // $ANTLR start "T_ASSIGNMENT"

    public void mT_ASSIGNMENT() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_ASSIGNMENT;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1017:2: ( ':=' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1017:4: ':='

            {

            	Match(":="); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_ASSIGNMENT"

    // $ANTLR start "T_AUTOCONS"

    public void mT_AUTOCONS() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_AUTOCONS;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1018:11: ( 'autocons' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1018:13: 'autocons'

            {

            	Match("autocons"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_AUTOCONS"

    // $ANTLR start "T_BAR"

    public void mT_BAR() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_BAR;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1019:7: ( '|' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1019:9: '|'

            {

            	Match('|'); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_BAR"

    // $ANTLR start "T_BOOL"

    public void mT_BOOL() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_BOOL;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1020:8: ( 'bool' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1020:10: 'bool'

            {

            	Match("bool"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_BOOL"

    // $ANTLR start "T_CBRL"

    public void mT_CBRL() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_CBRL;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1021:8: ( '{' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1021:10: '{'

            {

            	Match('{'); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_CBRL"

    // $ANTLR start "T_CBRR"

    public void mT_CBRR() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_CBRR;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1022:8: ( '}' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1022:10: '}'

            {

            	Match('}'); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_CBRR"

    // $ANTLR start "T_COLON"

    public void mT_COLON() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_COLON;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1023:9: ( ':' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1023:11: ':'

            {

            	Match(':'); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_COLON"

    // $ANTLR start "T_COMMA"

    public void mT_COMMA() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_COMMA;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1024:9: ( ',' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1024:11: ','

            {

            	Match(','); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_COMMA"

    // $ANTLR start "T_CONT"

    public void mT_CONT() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_CONT;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1025:8: ( 'qual' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1025:10: 'qual'

            {

            	Match("qual"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_CONT"

    // $ANTLR start "T_CHAR"

    public void mT_CHAR() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_CHAR;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1026:8: ( 'char' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1026:10: 'char'

            {

            	Match("char"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_CHAR"

    // $ANTLR start "T_CTRL"

    public void mT_CTRL() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_CTRL;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1027:9: ( 'ctr' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1027:11: 'ctr'

            {

            	Match("ctr"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_CTRL"

    // $ANTLR start "T_SYSTEM"

    public void mT_SYSTEM() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_SYSTEM;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1029:2: ( 'system' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1029:4: 'system'

            {

            	Match("system"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_SYSTEM"

    // $ANTLR start "T_DO"

    public void mT_DO() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_DO;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1030:6: ( 'do' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1030:8: 'do'

            {

            	Match("do"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_DO"

    // $ANTLR start "T_ELSE"

    public void mT_ELSE() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_ELSE;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1031:8: ( 'else' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1031:10: 'else'

            {

            	Match("else"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_ELSE"

    // $ANTLR start "T_END"

    public void mT_END() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_END;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1032:7: ( 'end' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1032:9: 'end'

            {

            	Match("end"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_END"

    // $ANTLR start "T_EQUAL"

    public void mT_EQUAL() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_EQUAL;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1033:9: ( '=' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1033:11: '='

            {

            	Match('='); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_EQUAL"

    // $ANTLR start "T_EXISTS"

    public void mT_EXISTS() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_EXISTS;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1034:9: ( 'exists' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1034:11: 'exists'

            {

            	Match("exists"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_EXISTS"

    // $ANTLR start "T_FLOAT"

    public void mT_FLOAT() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_FLOAT;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1035:9: ( 'float' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1035:11: 'float'

            {

            	Match("float"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_FLOAT"

    // $ANTLR start "T_FORALL"

    public void mT_FORALL() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_FORALL;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1036:9: ( 'forall' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1036:11: 'forall'

            {

            	Match("forall"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_FORALL"

    // $ANTLR start "T_FALSE"

    public void mT_FALSE() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_FALSE;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1037:9: ( 'false' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1037:11: 'false'

            {

            	Match("false"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_FALSE"

    // $ANTLR start "T_IF"

    public void mT_IF() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_IF;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1038:6: ( 'if' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1038:8: 'if'

            {

            	Match("if"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_IF"

    // $ANTLR start "T_IN"

    public void mT_IN() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_IN;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1039:6: ( 'in' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1039:8: 'in'

            {

            	Match("in"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_IN"

    // $ANTLR start "T_INT"

    public void mT_INT() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_INT;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1040:7: ( 'int' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1040:9: 'int'

            {

            	Match("int"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_INT"

    // $ANTLR start "T_KILL"

    public void mT_KILL() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_KILL;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1041:8: ( 'kill' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1041:10: 'kill'

            {

            	Match("kill"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_KILL"

    // $ANTLR start "T_LIST"

    public void mT_LIST() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_LIST;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1042:8: ( 'list' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1042:10: 'list'

            {

            	Match("list"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_LIST"

    // $ANTLR start "T_LPAREN"

    public void mT_LPAREN() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_LPAREN;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1043:9: ( '(' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1043:11: '('

            {

            	Match('('); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_LPAREN"

    // $ANTLR start "T_LSQPAREN"

    public void mT_LSQPAREN() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_LSQPAREN;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1044:11: ( '[' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1044:13: '['

            {

            	Match('['); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_LSQPAREN"

    // $ANTLR start "T_MAP"

    public void mT_MAP() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_MAP;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1045:7: ( 'map' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1045:9: 'map'

            {

            	Match("map"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_MAP"

    // $ANTLR start "T_MAPS"

    public void mT_MAPS() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_MAPS;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1046:8: ( '->' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1046:10: '->'

            {

            	Match("->"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_MAPS"

    // $ANTLR start "T_METHODS"

    public void mT_METHODS() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_METHODS;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1048:2: ( 'methods' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1048:4: 'methods'

            {

            	Match("methods"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_METHODS"

    // $ANTLR start "T_NEW"

    public void mT_NEW() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_NEW;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1049:7: ( 'new' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1049:9: 'new'

            {

            	Match("new"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_NEW"

    // $ANTLR start "T_NIL"

    public void mT_NIL() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_NIL;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1050:7: ( 'nil' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1050:9: 'nil'

            {

            	Match("nil"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_NIL"

    // $ANTLR start "T_NONDET"

    public void mT_NONDET() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_NONDET;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1051:9: ( '[]' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1051:11: '[]'

            {

            	Match("[]"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_NONDET"

    // $ANTLR start "T_OBS"

    public void mT_OBS() // throws RecognitionException [2]

    {

    		try

    		{

            int _type = T_OBS;

    	int _channel = DEFAULT_TOKEN_CHANNEL;

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1052:7: ( 'obs' )

            // C:\\Users\\stiran\\homer\\argos\\trunk\\src\\ooa.g:1052:9: 'obs'

            {

            	Match("obs"); if (state.failed) return ;

            }

            state.type = _type;

            state.channel = _channel;

        }

        finally 

    	{

        }

    }

    // $ANTLR end "T_OBS"