コード例 #1
0
ファイル: Visitors.cs プロジェクト: MonoBrasil/historico
 public MainMethodVisitor()
 {
     // create public class __MAIN
     cd__MAIN = new CLASS_DECLARATION(PHP.Core.Modifiers.PUBLIC, "__MAIN", null, new StatementList(), 0, 0);
     // create public function __MAIN()
     ArrayList modifiers = new ArrayList();
     modifiers.Add(PHP.Core.Modifiers.PUBLIC);
     modifiers.Add(PHP.Core.Modifiers.STATIC);
     fd__MAIN = new FUNCTION_DECLARATION(modifiers, false, "__MAIN", new ArrayList(), new StatementList(), 0, 0);
     // add function __MAIN() to class __MAIN
     cd__MAIN.stmt_list.Add(fd__MAIN);
     // create modified statement list
     modifiedStmtList = new StatementList();
 }
コード例 #2
0
ファイル: Visitors.cs プロジェクト: MonoBrasil/historico
        protected void Visit(ASTNode node)
        {
            if (node == null)
                return;
            else if (node is CLASS_DECLARATION) {
                cd = (CLASS_DECLARATION)node;
                // process each statement of class
                foreach (Statement stmt in cd.stmt_list)
                    Visit(stmt);
                // bake the class
                cd.typ = cd.typBld.CreateType();
                cd = null;
            }
            else if (node is FUNCTION_DECLARATION) {
                fd = (FUNCTION_DECLARATION)node;
                // get ILGenerator and check if this is a static function or not
                bool staticFunction;
                if (fd.name == "__construct" || fd.name == "__constructStatic") {
                    ilGen = fd.ctrBld.GetILGenerator();
                    staticFunction = fd.ctrBld.IsStatic;
                }
                else {
                    ilGen = fd.mthBld.GetILGenerator();
                    staticFunction = fd.mthBld.IsStatic;
                }
                // in constructors, store initial class member values
                if (fd.name == "__construct" || fd.name == "__constructStatic") {
                    CLASS_DECLARATION tmpCd = cd;
                    ArrayList namesAlreadyAdded = new ArrayList();
                    do { // fetch class variable declarations of current class
                        ArrayList classVarDecls = tmpCd.scope.lookup(SymbolTable.CLASS_VARIABLE);
                        foreach (SymbolTableEntry cvdEntry in classVarDecls) {
                            CLASS_VARIABLE_DECLARATION cvd = (CLASS_VARIABLE_DECLARATION)cvdEntry.node;
                            for (int i = 0; i < cvd.names.Count; i++) {
                                FieldBuilder fb = (FieldBuilder)cvd.fieldBuilders[i];
                                string name = (string)cvd.names[i];
                                Expression value = cvd.values.Get(i);
                                // only process names not already added
                                if (namesAlreadyAdded.Contains(name))
                                    continue;
                                bool cvdIsVisible = tmpCd == cd || !cvd.modifiers.Contains(Modifiers.PRIVATE);
                                bool cvdIsStatic = cvd.modifiers.Contains(Modifiers.STATIC) || cvd.modifiers.Contains(Modifiers.CONST);
                                // in a static constructor, store initial static class member values
                                if (fd.name == "__constructStatic" && cvdIsVisible && cvdIsStatic) {
                                    if (value == null)
                                        ilGen.Emit(OpCodes.Newobj, PHPNull.GetConstructor(Type.EmptyTypes));
                                    else
                                        Visit(value);
                                    ilGen.Emit(OpCodes.Stsfld, fb);
                                    namesAlreadyAdded.Add(name);
                                }
                                // in a local constructor, store initial local class member values
                                if (fd.name == "__construct" && cvdIsVisible && !cvdIsStatic) {
                                    ilGen.Emit(OpCodes.Ldarg_0);
                                    if (value == null)
                                        ilGen.Emit(OpCodes.Newobj, PHPNull.GetConstructor(Type.EmptyTypes));
                                    else
                                        Visit(value);
                                    ilGen.Emit(OpCodes.Stfld, fb);
                                    namesAlreadyAdded.Add(name);
                                }
                            }
                        }
                        // fetch parent class declaration
                        if (tmpCd.extends == null)
                            tmpCd = null;
                        else {
                            SymbolTableEntry parentCdEntry = SymbolTable.getInstance().lookupGlobal(tmpCd.extends.ToLower(), SymbolTable.CLASS);
                            tmpCd = (CLASS_DECLARATION)parentCdEntry.node;
                        }
                    } while (tmpCd != null);

                }
                // store parameters passed as local variable
                PARAMETER_DECLARATION pd;
                for (int i = 0; i < fd.parameters.Count; i++) {
                    pd = (PARAMETER_DECLARATION)fd.parameters[i];
                    // push value passed
                    ilGen.Emit(OpCodes.Ldarg, i + (staticFunction ? 0 : 1));
                    // if value passed is Null, use default value, if available
                    if (pd.default_value != null) {
                        Label skip = ilGen.DefineLabel();
                        ilGen.Emit(OpCodes.Dup);
                        ilGen.Emit(OpCodes.Isinst, PHPNull);
                        ilGen.Emit(OpCodes.Brfalse, skip);
                        ilGen.Emit(OpCodes.Pop);
                        Visit(pd.default_value);
                        ilGen.MarkLabel(skip);
                    }
                    // check if class type hint is ok
                    if (pd.type != null) {
                        ilGen.Emit(OpCodes.Dup);
                        ilGen.Emit(OpCodes.Ldstr, pd.type);
                        ilGen.Emit(OpCodes.Ldc_I4_0);
                        ilGen.Emit(OpCodes.Ldc_I4_1);
                        ilGen.Emit(OpCodes.Call, typeof(Type).GetMethod("GetType", new Type[] { typeof(string), typeof(bool), typeof(bool) }));
                        ilGen.Emit(OpCodes.Ldc_I4, i + (staticFunction ? 1 : 2));
                        ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("CheckTypeHint", new Type[] { PHPMixed, typeof(Type), typeof(int) }));
                    }
                    // store
                    StoreToVariable(pd.name);
                }
                // process statements
                if (fd.stmt_list.Count() == 0)
                    ilGen.Emit(OpCodes.Nop);
                else
                    foreach (Statement stmt in fd.stmt_list)
                        Visit(stmt);
                ilGen = null;
                fd = null;
            }
            else if (node is GLOBAL) {
                GLOBAL g = (GLOBAL)node;
                foreach (VARIABLE var in g.var_list)
                    fd.scope.globalVariables.Add(var.name);
            }
            else if (node is STATIC_DECLARATION) {
                STATIC_DECLARATION sd = (STATIC_DECLARATION)node;
                foreach (Expression expr in sd.expr_list) {
                    if (expr is VARIABLE) {
                        ilGen.Emit(OpCodes.Newobj, PHPNull.GetConstructor(Type.EmptyTypes));
                        StoreToStaticVariable(((VARIABLE)expr).name);
                    }
                    if (expr is EQUALS) {
                        Visit(((EQUALS)expr).expr2);
                        StoreToStaticVariable(((VARIABLE)((EQUALS)expr).expr1).name);
                    }
                }
            }
            else if (node is ECHO) {
                ECHO e = (ECHO)node;
                foreach (Expression e2 in e.expr_list) {
                    Visit(e2);
                    ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Echo", new Type[] { PHPMixed }));
                }
            }
            else if (node is BLOCK) {
                BLOCK b = (BLOCK)node;
                foreach (Statement stmt in b.stmt_list)
                    Visit(stmt);
            }
            else if (node is StatementList) {
                StatementList s = (StatementList)node;
                // process statements of block
                foreach (Statement stmt in s)
                    Visit(stmt);
            }
            else if (node is IF) {
                IF i = (IF)node;
                Label nextCheck = ilGen.DefineLabel();
                Label endIf = ilGen.DefineLabel();
                // process if statement
                Visit(i.expr);
                ilGen.Emit(OpCodes.Call, PHPCoreConvert.GetMethod("ToValueBool", new Type[] { PHPMixed }));
                ilGen.Emit(OpCodes.Brfalse, nextCheck);
                Visit(i.stmt);
                ilGen.Emit(OpCodes.Br, endIf);
                ilGen.MarkLabel(nextCheck);
                // process elseif statements
                foreach (ELSEIF e in i.elseif_list) {
                    //Visit(e);
                    ELSEIF ei = (ELSEIF)node;
                    Label nextCheck2 = ilGen.DefineLabel();
                    // process else statement
                    Visit(ei.expr);
                    ilGen.Emit(OpCodes.Call, PHPCoreConvert.GetMethod("ToValueBool", new Type[] { PHPMixed }));
                    ilGen.Emit(OpCodes.Brfalse, nextCheck2);
                    Visit(ei.stmt);
                    ilGen.Emit(OpCodes.Br, endIf);
                    ilGen.MarkLabel(nextCheck2);
                }
                // process else statement
                Visit(i.else_stmt);
                // done
                ilGen.MarkLabel(endIf);
                endIf = new Label();
            }
            else if (node is WHILE) {
                WHILE w = (WHILE)node;
                enterLoop = ilGen.DefineLabel();
                exitLoop = ilGen.DefineLabel();
                ilGen.MarkLabel(enterLoop);
                Visit(w.expr);
                ilGen.Emit(OpCodes.Call, PHPCoreConvert.GetMethod("ToValueBool", new Type[] { PHPMixed }));
                ilGen.Emit(OpCodes.Brfalse, exitLoop);
                Visit(w.stmt);
                ilGen.Emit(OpCodes.Br, enterLoop);
                ilGen.MarkLabel(exitLoop);
            }
            else if (node is DO) {
                DO d = (DO)node;
                enterLoop = ilGen.DefineLabel();
                exitLoop = ilGen.DefineLabel();
                ilGen.MarkLabel(enterLoop);
                Visit(d.stmt);
                Visit(d.expr);
                ilGen.Emit(OpCodes.Call, PHPCoreConvert.GetMethod("ToValueBool", new Type[] { PHPMixed }));
                ilGen.Emit(OpCodes.Brfalse, exitLoop);
                ilGen.Emit(OpCodes.Br, enterLoop);
                ilGen.MarkLabel(exitLoop);
            }
            else if (node is FOR) {
                FOR f = (FOR)node;
                enterLoop = ilGen.DefineLabel();
                exitLoop = ilGen.DefineLabel();
                foreach (Expression expr in f.expr_list1) {
                    Visit(expr);
                    // pop to treat for expression(s) 1 as statement(s)
                    ilGen.Emit(OpCodes.Pop);
                }
                ilGen.MarkLabel(enterLoop);
                IEnumerator ienum = f.expr_list2.GetEnumerator();
                bool hasMore = ienum.MoveNext();
                while (hasMore) {
                    Visit((Expression)ienum.Current);
                    hasMore = ienum.MoveNext();
                    if (hasMore)
                        // if more than one expression 2, pop all except last one to only decide on last one for jumping
                        ilGen.Emit(OpCodes.Pop);
                }
                // if for expression 2 is empty, the loop should run indefinitely
                if (f.expr_list2.Count() > 0) {
                    ilGen.Emit(OpCodes.Call, PHPCoreConvert.GetMethod("ToValueBool", new Type[] { PHPMixed }));
                    ilGen.Emit(OpCodes.Brfalse, exitLoop);
                }
                Visit(f.stmt);
                foreach (Expression expr in f.expr_list3) {
                    Visit(expr);
                    // pop to treat for expression(s) 3 as statement(s)
                    ilGen.Emit(OpCodes.Pop);
                }
                ilGen.Emit(OpCodes.Br, enterLoop);
                ilGen.MarkLabel(exitLoop);
            }
            else if (node is FOREACH) {
                FOREACH f = (FOREACH)node;
                if (f.key != null && f.key is FUNCTION_CALL)
                    Report.Error(408, f.key.line, f.key.column);
                if (f.value is FUNCTION_CALL)
                    Report.Error(408, f.value.line, f.value.column);
                enterLoop = ilGen.DefineLabel();
                exitLoop = ilGen.DefineLabel();
                Label warn = ilGen.DefineLabel();
                // push array reference
                Visit(f.array);
                // if type is not array, jump to end
                ilGen.Emit(OpCodes.Dup);
                ilGen.Emit(OpCodes.Isinst, PHPArray);
                ilGen.Emit(OpCodes.Brfalse, warn);
                // if array is not referenced, clone to acheive value semantics
                if (!(f.value is REFERENCE))
                    ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Clone", new Type[] { PHPMixed }));
                // declare key and value variable
                string valueName;
                if (f.value is VARIABLE)
                    valueName = ((VARIABLE)f.value).name;
                else
                    valueName = ((VARIABLE)((REFERENCE)f.value).variable).name;
                if (f.key != null) {
                    ilGen.Emit(OpCodes.Ldnull);
                    StoreToVariable(((VARIABLE)f.key).name);
                }
                ilGen.Emit(OpCodes.Ldnull);
                StoreToVariable(valueName);
                // reset public array pointer
                ilGen.Emit(OpCodes.Dup);
                ilGen.Emit(OpCodes.Callvirt, PHPArray.GetMethod("Reset", Type.EmptyTypes));
                ilGen.Emit(OpCodes.Pop);
                // enter loop
                ilGen.MarkLabel(enterLoop);
                // check if public array pointer is inside the array
                ilGen.Emit(OpCodes.Dup);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("CurrentIsValid", new Type[] { PHPArray }));
                // if not, exit loop
                ilGen.Emit(OpCodes.Brfalse, exitLoop);
                // if key variable declared, push current key of array and store to key variable
                if (f.key != null) {
                    ilGen.Emit(OpCodes.Dup);
                    ilGen.Emit(OpCodes.Callvirt, PHPArray.GetMethod("Key", Type.EmptyTypes));
                    StoreToVariable(((VARIABLE)f.key).name);
                }
                // push current value of array and store to value variable
                ilGen.Emit(OpCodes.Dup);
                ilGen.Emit(OpCodes.Callvirt, PHPArray.GetMethod("Current", Type.EmptyTypes));
                StoreToVariable(valueName);
                // process foreach statement
                Visit(f.stmt);
                // load value variable and store as current value of array
                ilGen.Emit(OpCodes.Dup);
                ilGen.Emit(OpCodes.Dup);
                ilGen.Emit(OpCodes.Callvirt, PHPArray.GetMethod("Key", Type.EmptyTypes));
                LoadFromVariable(valueName);
                ilGen.Emit(OpCodes.Callvirt, PHPArray.GetMethod("Append", new Type[] { PHPMixed, PHPMixed }));
                // advance public array pointer
                ilGen.Emit(OpCodes.Dup);
                ilGen.Emit(OpCodes.Callvirt, PHPArray.GetMethod("Next", Type.EmptyTypes));
                ilGen.Emit(OpCodes.Pop);
                // and reenter loop
                ilGen.Emit(OpCodes.Br, enterLoop);
                // report invalid argument
                ilGen.MarkLabel(warn);
                ilGen.Emit(OpCodes.Ldc_I4, 407);
                ilGen.Emit(OpCodes.Ldc_I4, f.line);
                ilGen.Emit(OpCodes.Ldc_I4, f.column);
                ilGen.Emit(OpCodes.Call, mPHPRuntime.GetType("PHP.Core.Report").GetMethod("Warn", new Type[] { typeof(int), typeof(int), typeof(int) }));
                // pop array reference
                ilGen.MarkLabel(exitLoop);
                ilGen.Emit(OpCodes.Pop);
            }
            else if (node is SWITCH) {
                SWITCH s = (SWITCH)node;
                enterLoop = ilGen.DefineLabel();
                exitLoop = ilGen.DefineLabel();
                // push switch expression and enter loop
                Visit(s.expr);
                ilGen.MarkLabel(enterLoop);
                // process case and default statements
                foreach (ASTNode node2 in s.switch_case_list) {
                    if (node2 is CASE)
                        Visit((CASE)node2);
                    else if (node2 is DEFAULT)
                        Visit((DEFAULT)node2);
                }
                // done
                ilGen.MarkLabel(exitLoop);
                ilGen.Emit(OpCodes.Pop);
                ilGen.Emit(OpCodes.Ldc_I4_0);
                ilGen.Emit(OpCodes.Stsfld, PHPCoreRuntime.GetField("switchInProgress"));
            }
            else if (node is CASE) {
                CASE c = (CASE)node;
                Label processCase = ilGen.DefineLabel();
                Label nextCase = ilGen.DefineLabel();
                // if statements already processing, process this one as well
                ilGen.Emit(OpCodes.Ldsfld, PHPCoreRuntime.GetField("switchInProgress"));
                ilGen.Emit(OpCodes.Brtrue, processCase);
                // else if case expression doesn't equal switch expression, jump to next case
                ilGen.Emit(OpCodes.Dup);
                Visit(c.expr);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("IsEqual", new Type[] { PHPMixed, PHPMixed }));
                ilGen.Emit(OpCodes.Call, PHPCoreConvert.GetMethod("ToValueBool", new Type[] { PHPMixed }));
                ilGen.Emit(OpCodes.Brfalse, nextCase);
                // else start processing switch statements
                ilGen.Emit(OpCodes.Ldc_I4_1);
                ilGen.Emit(OpCodes.Stsfld, PHPCoreRuntime.GetField("switchInProgress"));
                // process case statement
                ilGen.MarkLabel(processCase);
                Visit(c.stmt);
                // mark start of next case
                ilGen.MarkLabel(nextCase);
            }
            else if (node is DEFAULT) {
                DEFAULT d = (DEFAULT)node;
                // process default statement
                ilGen.Emit(OpCodes.Ldc_I4_1);
                ilGen.Emit(OpCodes.Stsfld, PHPCoreRuntime.GetField("switchInProgress"));
                Visit(d.stmt);
            }
            else if (node is BREAK) {
                BREAK b = (BREAK)node;
                ilGen.Emit(OpCodes.Br, exitLoop);
            }
            else if (node is CONTINUE) {
                CONTINUE c = (CONTINUE)node;
                ilGen.Emit(OpCodes.Br, enterLoop);
            }
            else if (node is RETURN) {
                RETURN r = (RETURN)node;
                if (fd.name != "__MAIN" && fd.name != "__construct" && fd.name != "__constructStatic") {
                    // if no return value specified, use Null as return value; otherwise use return value specified
                    if (r.expr == null)
                        ilGen.Emit(OpCodes.Newobj, PHPNull.GetConstructor(Type.EmptyTypes));
                    else
                        Visit(r.expr);
                }
                ilGen.Emit(OpCodes.Ret);
            }
            else if (node is UNSET) {
                UNSET u = (UNSET)node;
                // unset variables
                for (int i = 0; i < u.var_list.Count(); i++) {
                    if (u.var_list.Get(i) is FUNCTION_CALL)
                        Report.Error(408, u.var_list.Get(i).line, u.var_list.Get(i).column);
                    VARIABLE var = (VARIABLE)u.var_list.Get(i);
                    // regular variable, so unset
                    if (var.offset == null) {
                        ilGen.Emit(OpCodes.Ldstr, var.name);
                        ilGen.Emit(OpCodes.Newobj, PHPString.GetConstructor(new Type[] { typeof(string) }));
                        ilGen.Emit(OpCodes.Call, PHPCoreRuntime.GetMethod("UnsetVariable", new Type[] { PHPMixed }));
                    }
                    // array item, so remove from array
                    else if (var.offset.kind == OFFSET.SQUARE) {
                        LoadFromVariable(var.name);
                        // convert to Array (in case the variable was unset)
                        ilGen.Emit(OpCodes.Call, PHPCoreConvert.GetMethod("ToArray", new Type[] { PHPMixed }));
                        if (var.offset.value == null)
                            ilGen.Emit(OpCodes.Ldnull);
                        else
                            Visit(var.offset);
                        ilGen.Emit(OpCodes.Callvirt, PHPArray.GetMethod("Remove", new Type[] { PHPMixed }));
                    }
                }
            }
            else if (node is EXPRESSION_AS_STATEMENT) {
                EXPRESSION_AS_STATEMENT eas = (EXPRESSION_AS_STATEMENT)node;
                Visit(eas.expr);
                ilGen.Emit(OpCodes.Pop);
            }
            else if (node is VARIABLE) {
                VARIABLE var = (VARIABLE)node;
                // get desired variable value
                LoadFromVariable(var.name);
                // process offset, if available
                if (var.offset != null) {
                    // this is an array
                    if (var.offset.kind == OFFSET.SQUARE) {
                        if (var.offset.value == null)
                            ilGen.Emit(OpCodes.Ldnull);
                        else
                            Visit(var.offset);
                        ilGen.Emit(OpCodes.Ldc_I4, OFFSET.SQUARE);
                        ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Offset", new Type[] { PHPMixed, PHPMixed, typeof(int) }));
                    }
                }
            }
            else if (node is REFERENCE) {
                REFERENCE r = (REFERENCE)node;
                // process enclosed variable or function call
                if (r.variable is VARIABLE)
                    Visit((VARIABLE)r.variable);
                else if (r.variable is FUNCTION_CALL)
                    Visit((FUNCTION_CALL)r.variable);
            }
            else if (node is OFFSET) {
                OFFSET o = (OFFSET)node;
                // process offset expression
                Visit(o.value);
            }
            else if (node is FUNCTION_CALL) {
                FUNCTION_CALL fc = (FUNCTION_CALL)node;
                // catch predefined functions
                if (fc.function_name.ToLower() == "define") {
                    PushParameters(fc.parameters, 3);
                    ilGen.Emit(OpCodes.Call, PHPCoreRuntime.GetMethod("DefineConstant", new Type[] { PHPMixed, PHPMixed, PHPMixed }));
                }
                // otherwise call user defined function
                else {
                    // look in global scope as calls to functions in user defined classed are handled by object operator or paamayim nekudotayim
                    SymbolTable st = SymbolTable.getInstance();
                    SymbolTableEntry entry = cd.scope.lookup(fc.function_name.ToLower(), SymbolTable.FUNCTION);
                    if (entry == null)
                        Report.Error(212, fc.function_name, fc.line, fc.column);
                    FUNCTION_DECLARATION fd = (FUNCTION_DECLARATION)entry.node;
                    // pass parameters (only as many as needed)
                    int parametersPassedActually = (int)Math.Min(fd.parameters.Count, fc.parameters.Count());
                    for (int i = 0; i < parametersPassedActually; i++) {
                        PARAMETER_DECLARATION pd = (PARAMETER_DECLARATION)fd.parameters[i];
                        Expression expr = (Expression)fc.parameters.Get(i);
                        Visit(expr);
                        // clone if value semantics is desired
                        if (!pd.by_reference && !(expr is REFERENCE))
                            ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Clone", new Type[] { PHPMixed }));
                    }
                    // if less parameters actually passed then necessary, pass Null objects instead
                    for (int i = parametersPassedActually; i < fd.parameters.Count; i++) {
                        PARAMETER_DECLARATION pd = (PARAMETER_DECLARATION)fd.parameters[i];
                        if (pd.default_value == null)
                            Report.Warn(300, System.Convert.ToString(i + 1), fc.line, fc.column);
                        ilGen.Emit(OpCodes.Newobj, PHPNull.GetConstructor(Type.EmptyTypes));
                    }
                    // ensure parameters passed by reference are variables
                    for (int i = 0; i < parametersPassedActually; i++) {
                        PARAMETER_DECLARATION pd = (PARAMETER_DECLARATION)fd.parameters[i];
                        Expression variableSupplied = (Expression)fc.parameters.Get(i);
                        if (pd.by_reference || variableSupplied is REFERENCE)
                            if (!(variableSupplied is VARIABLE || variableSupplied is REFERENCE))
                                Report.Error(301, System.Convert.ToString(i + 1), variableSupplied.line, variableSupplied.column);
                    }
                    // add function call to call trace
                    ilGen.Emit(OpCodes.Ldstr, cd.name + "->" + fc.function_name);
                    ilGen.Emit(OpCodes.Call, PHPCoreRuntime.GetMethod("AddFunctionCallToTrace", new Type[] { typeof(string) }));
                    // if an object operator in progress, call instance function
                    if (objectOperatorInProgress)
                        ilGen.Emit(OpCodes.Call, fd.mthBld);
                    // else call static function
                    else
                        ilGen.Emit(OpCodes.Call, fd.mthBld);
                    // remove function call from call trace
                    ilGen.Emit(OpCodes.Call, PHPCoreRuntime.GetMethod("RemoveFunctionCallFromTrace", Type.EmptyTypes));
                }
            }
            else if (node is NEW) {
                NEW n = (NEW)node;
                SymbolTableEntry cdEntry = SymbolTable.getInstance().lookupGlobal(n.type.ToLower(), SymbolTable.CLASS);
                if (cdEntry == null)
                    Report.Error(203, n.type, n.line, n.column);
                CLASS_DECLARATION cd = (CLASS_DECLARATION)cdEntry.node;
                SymbolTableEntry ctorEntry = cd.scope.lookup("__construct", SymbolTable.FUNCTION);
                FUNCTION_DECLARATION ctorDecl = (FUNCTION_DECLARATION)ctorEntry.node;
                // pass parameters (only as many as needed)
                int parametersPassedActually = (int)Math.Min(ctorDecl.parameters.Count, n.ctor_args.Count());
                for (int i = 0; i < parametersPassedActually; i++) {
                    Expression expr = (Expression)n.ctor_args.Get(i);
                    Visit(expr);
                }
                // if less parameters actually passed then necessary, pass Null objects instead
                for (int i = parametersPassedActually; i < ctorDecl.parameters.Count; i++) {
                    PARAMETER_DECLARATION pd = (PARAMETER_DECLARATION)ctorDecl.parameters[i];
                    if (pd.default_value == null)
                        Report.Warn(300, System.Convert.ToString(i + 1), n.line, n.column);
                    ilGen.Emit(OpCodes.Newobj, PHPNull.GetConstructor(Type.EmptyTypes));
                }
                // ensure parameters passed by reference are vairables
                for (int i = 0; i < parametersPassedActually; i++) {
                    PARAMETER_DECLARATION pd = (PARAMETER_DECLARATION)ctorDecl.parameters[i];
                    Expression variableSupplied = (Expression)n.ctor_args.Get(i);
                    if (pd.by_reference || variableSupplied is REFERENCE)
                        if (!(variableSupplied is VARIABLE || variableSupplied is REFERENCE))
                            Report.Error(301, System.Convert.ToString(i + 1), variableSupplied.line, variableSupplied.column);
                }
                // add constructor call to call trace
                ilGen.Emit(OpCodes.Ldstr, n.type + "->__construct");
                ilGen.Emit(OpCodes.Call, PHPCoreRuntime.GetMethod("AddFunctionCallToTrace", new Type[] { typeof(string) }));
                // call constructor
                ilGen.Emit(OpCodes.Newobj, ctorDecl.ctrBld);
                // remove constructor call from call trace
                ilGen.Emit(OpCodes.Call, PHPCoreRuntime.GetMethod("RemoveFunctionCallFromTrace", Type.EmptyTypes));
            }
            else if (node is INSTANCEOF) {
                INSTANCEOF i = (INSTANCEOF)node;
                Visit(i.expr);
                ilGen.Emit(OpCodes.Ldstr, i.type);
                ilGen.Emit(OpCodes.Ldc_I4_0);
                ilGen.Emit(OpCodes.Ldc_I4_1);
                ilGen.Emit(OpCodes.Call, typeof(Type).GetMethod("GetType", new Type[] { typeof(string), typeof(bool), typeof(bool) }));
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Instanceof", new Type[] { PHPMixed, typeof(Type) }));
            }
            else if (node is ARRAY) {
                ARRAY a = (ARRAY)node;
                // create new empty array
                ilGen.Emit(OpCodes.Newobj, PHPArray.GetConstructor(Type.EmptyTypes));
                // process array pairs
                foreach (ARRAY_PAIR ap in a.array_pair_list) {
                    // duplicate reference to array (in order not to loose it after append)
                    ilGen.Emit(OpCodes.Dup);
                    // process key
                    if (ap.key == null)
                        ilGen.Emit(OpCodes.Ldnull);
                    else
                        Visit(ap.key);
                    // process value
                    if (ap.value is REFERENCE)
                        if (((REFERENCE)ap.value).variable is FUNCTION_CALL)
                            Report.Error(408, ap.line, ap.column);
                    Visit(ap.value);
                    ilGen.Emit(OpCodes.Callvirt, PHPArray.GetMethod("Append", new Type[] { PHPMixed, PHPMixed }));
                }
            }
            else if (node is INC) {
                INC i = (INC)node;
                if (i.expr is FUNCTION_CALL)
                    Report.Error(408, i.expr.line, i.expr.column);
                LoadFromVariable(((VARIABLE)i.expr).name);
                if (i.kind == 1) {
                    ilGen.Emit(OpCodes.Dup);
                    ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Clone", new Type[] { PHPMixed }));
                }
                ilGen.Emit(OpCodes.Ldc_I4_1);
                ilGen.Emit(OpCodes.Newobj, PHPInteger.GetConstructor(new Type[] { typeof(int) }));
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Plus", new Type[] { PHPMixed, PHPMixed }));
                if (i.kind == 0) {
                    ilGen.Emit(OpCodes.Dup);
                    ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Clone", new Type[] { PHPMixed }));
                }
                StoreToVariable(((VARIABLE)i.expr).name);
            }
            else if (node is DEC) {
                DEC d = (DEC)node;
                if (d.expr is FUNCTION_CALL)
                    Report.Error(408, d.expr.line, d.expr.column);
                LoadFromVariable(((VARIABLE)d.expr).name);
                if (d.kind == 1)
                    ilGen.Emit(OpCodes.Dup);
                ilGen.Emit(OpCodes.Ldc_I4_1);
                ilGen.Emit(OpCodes.Newobj, PHPInteger.GetConstructor(new Type[] { typeof(int) }));
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Minus", new Type[] { PHPMixed, PHPMixed }));
                if (d.kind == 0)
                    ilGen.Emit(OpCodes.Dup);
                StoreToVariable(((VARIABLE)d.expr).name);
            }
            else if (node is BOOLEAN_NOT) {
                BOOLEAN_NOT bn = (BOOLEAN_NOT)node;
                Visit(bn.expr);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("BooleanNot", new Type[] { PHPMixed }));
            }
            else if (node is NOT) {
                NOT n = (NOT)node;
                Visit(n.expr);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Not", new Type[] { PHPMixed }));
            }
            else if (node is EXIT) {
                EXIT e = (EXIT)node;
                if (e.expr == null)
                    ilGen.Emit(OpCodes.Newobj, PHPNull.GetConstructor(Type.EmptyTypes));
                else
                    Visit(e.expr);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Exit", new Type[] { PHPMixed }));
            }
            else if (node is PRINT) {
                PRINT p = (PRINT)node;
                Visit(p.expr);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Print", new Type[] { PHPMixed }));
            }
            else if (node is BOOL_CAST) {
                BOOL_CAST bc = (BOOL_CAST)node;
                Visit(bc.expr);
                ilGen.Emit(OpCodes.Call, PHPCoreConvert.GetMethod("ToBoolean", new Type[] { PHPMixed }));
            }
            else if (node is INT_CAST) {
                INT_CAST ic = (INT_CAST)node;
                Visit(ic.expr);
                ilGen.Emit(OpCodes.Call, PHPCoreConvert.GetMethod("ToInteger", new Type[] { PHPMixed }));
            }
            else if (node is DOUBLE_CAST) {
                DOUBLE_CAST dc = (DOUBLE_CAST)node;
                Visit(dc.expr);
                ilGen.Emit(OpCodes.Call, PHPCoreConvert.GetMethod("ToDouble", new Type[] { PHPMixed }));
            }
            else if (node is STRING_CAST) {
                STRING_CAST sc = (STRING_CAST)node;
                Visit(sc.expr);
                ilGen.Emit(OpCodes.Call, PHPCoreConvert.GetMethod("ToString", new Type[] { PHPMixed }));
            }
            else if (node is ARRAY_CAST) {
                ARRAY_CAST ac = (ARRAY_CAST)node;
                Visit(ac.expr);
                ilGen.Emit(OpCodes.Call, PHPCoreConvert.GetMethod("ToArray", new Type[] { PHPMixed }));
            }
            else if (node is OBJECT_CAST) {
                OBJECT_CAST oc = (OBJECT_CAST)node;
                Visit(oc.expr);
                ilGen.Emit(OpCodes.Call, PHPCoreConvert.GetMethod("ToObject", new Type[] { PHPMixed }));
            }
            else if (node is CLONE) {
                CLONE c = (CLONE)node;
                Visit(c.expr);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Clone", new Type[] { PHPMixed }));
            }
            else if (node is PAAMAYIM_NEKUDOTAYIM) {
                PAAMAYIM_NEKUDOTAYIM pn = (PAAMAYIM_NEKUDOTAYIM)node;
                LoadFromPaamayimNekudotayim(pn);
            }
            else if (node is OBJECT_OPERATOR) {
                OBJECT_OPERATOR oo = (OBJECT_OPERATOR)node;
                LoadFromObjectOperator(oo);
            }
            else if (node is EQUALS) {
                EQUALS e = (EQUALS)node;
                if (e.expr1 is FUNCTION_CALL)
                    Report.Error(408, e.expr1.line, e.expr1.column);
                // push assigned value as result of this equals expression
                Visit(e.expr2);
                // store to an object operator expression
                if (e.expr1 is OBJECT_OPERATOR)
                    StoreToObjectOperator((OBJECT_OPERATOR)e.expr1, e.expr2);
                // store to an object operator expression
                else if (e.expr1 is PAAMAYIM_NEKUDOTAYIM)
                    StoreToPaamayimNekudotayim((PAAMAYIM_NEKUDOTAYIM)e.expr1, e.expr2);
                // store to a variable expression
                else if (e.expr1 is VARIABLE) {
                    VARIABLE var = (VARIABLE)e.expr1;
                    // determine value or reference semantis
                    bool referenceSemantics = false;
                    // if assigned expr is a reference
                    if (e.expr2 is REFERENCE) {
                        REFERENCE r = (REFERENCE)e.expr2;
                        // and a variable is called, it's reference semantics
                        if (r.variable is VARIABLE)
                            referenceSemantics = true;
                        // and a function not returnung a reference is called, it's reference semantics
                        if (r.variable is FUNCTION_CALL) {
                            SymbolTableEntry entry = SymbolTable.getInstance().lookup(((FUNCTION_CALL)r.variable).function_name.ToLower(), SymbolTable.FUNCTION);
                            FUNCTION_DECLARATION fd = (FUNCTION_DECLARATION)entry.node;
                            if (fd.return_by_reference)
                                referenceSemantics = true;
                        }
                    }
                    // if there is no offset, just store to that variable
                    if (var.offset == null) {
                        ilGen.Emit(OpCodes.Dup);
                        if (!referenceSemantics)
                            ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Clone", new Type[] { PHPMixed }));
                        StoreToVariable(var.name);
                    }
                    // if there is an array offset, load array and store to specified place of that array
                    else if (var.offset.kind == OFFSET.SQUARE) {
                        LoadFromVariable(var.name);
                        // if array loaded is null, create a new one and store
                        Label skip = ilGen.DefineLabel();
                        ilGen.Emit(OpCodes.Isinst, PHPNull);
                        ilGen.Emit(OpCodes.Brfalse, skip);
                        ilGen.Emit(OpCodes.Newobj, PHPArray.GetConstructor(Type.EmptyTypes));
                        StoreToVariable(var.name);
                        ilGen.MarkLabel(skip);
                        LoadFromVariable(var.name);
                        // convert to Array (in case the variable was unset)
                        ilGen.Emit(OpCodes.Call, PHPCoreConvert.GetMethod("ToArray", new Type[] { PHPMixed }));
                        // if value of offset is null, push null to automatically calculate key
                        if (var.offset.value == null)
                            ilGen.Emit(OpCodes.Ldnull);
                        // if a value is given, push that value
                        else
                            Visit(var.offset.value);
                        Visit(e.expr2);
                        if (!referenceSemantics)
                            ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Clone", new Type[] { PHPMixed }));
                        ilGen.Emit(OpCodes.Callvirt, PHPArray.GetMethod("Append", new Type[] { PHPMixed, PHPMixed }));
                    }
                }
            }
            else if (node is PLUS_EQUAL) {
                PLUS_EQUAL pe = (PLUS_EQUAL)node;
                if (pe.expr1 is FUNCTION_CALL)
                    Report.Error(408, pe.expr1.line, pe.expr1.column);
                LoadFromVariable(((VARIABLE)pe.expr1).name);
                Visit(pe.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Plus", new Type[] { PHPMixed, PHPMixed }));
                ilGen.Emit(OpCodes.Dup);
                StoreToVariable(((VARIABLE)pe.expr1).name);
            }
            else if (node is MINUS_EQUAL) {
                MINUS_EQUAL me = (MINUS_EQUAL)node;
                if (me.expr1 is FUNCTION_CALL)
                    Report.Error(408, me.expr1.line, me.expr1.column);
                LoadFromVariable(((VARIABLE)me.expr1).name);
                Visit(me.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Minus", new Type[] { PHPMixed, PHPMixed }));
                ilGen.Emit(OpCodes.Dup);
                StoreToVariable(((VARIABLE)me.expr1).name);
            }
            else if (node is MUL_EQUAL) {
                MUL_EQUAL me = (MUL_EQUAL)node;
                if (me.expr1 is FUNCTION_CALL)
                    Report.Error(408, me.expr1.line, me.expr1.column);
                LoadFromVariable(((VARIABLE)me.expr1).name);
                Visit(me.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Mul", new Type[] { PHPMixed, PHPMixed }));
                ilGen.Emit(OpCodes.Dup);
                StoreToVariable(((VARIABLE)me.expr1).name);
            }
            else if (node is DIV_EQUAL) {
                DIV_EQUAL de = (DIV_EQUAL)node;
                if (de.expr1 is FUNCTION_CALL)
                    Report.Error(408, de.expr1.line, de.expr1.column);
                LoadFromVariable(((VARIABLE)de.expr1).name);
                Visit(de.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Div", new Type[] { PHPMixed, PHPMixed }));
                ilGen.Emit(OpCodes.Dup);
                StoreToVariable(((VARIABLE)de.expr1).name);
            }
            else if (node is CONCAT_EQUAL) {
                CONCAT_EQUAL ce = (CONCAT_EQUAL)node;
                if (ce.expr1 is FUNCTION_CALL)
                    Report.Error(408, ce.expr1.line, ce.expr1.column);
                LoadFromVariable(((VARIABLE)ce.expr1).name);
                Visit(ce.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Concat", new Type[] { PHPMixed, PHPMixed }));
                ilGen.Emit(OpCodes.Dup);
                StoreToVariable(((VARIABLE)ce.expr1).name);
            }
            else if (node is MOD_EQUAL) {
                MOD_EQUAL me = (MOD_EQUAL)node;
                if (me.expr1 is FUNCTION_CALL)
                    Report.Error(408, me.expr1.line, me.expr1.column);
                LoadFromVariable(((VARIABLE)me.expr1).name);
                Visit(me.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Mod", new Type[] { PHPMixed, PHPMixed }));
                ilGen.Emit(OpCodes.Dup);
                StoreToVariable(((VARIABLE)me.expr1).name);
            }
            else if (node is AND_EQUAL) {
                AND_EQUAL ae = (AND_EQUAL)node;
                if (ae.expr1 is FUNCTION_CALL)
                    Report.Error(408, ae.expr1.line, ae.expr1.column);
                LoadFromVariable(((VARIABLE)ae.expr1).name);
                Visit(ae.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("And", new Type[] { PHPMixed, PHPMixed }));
                ilGen.Emit(OpCodes.Dup);
                StoreToVariable(((VARIABLE)ae.expr1).name);
            }
            else if (node is OR_EQUAL) {
                OR_EQUAL oe = (OR_EQUAL)node;
                if (oe.expr1 is FUNCTION_CALL)
                    Report.Error(408, oe.expr1.line, oe.expr1.column);
                LoadFromVariable(((VARIABLE)oe.expr1).name);
                Visit(oe.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Or", new Type[] { PHPMixed, PHPMixed }));
                ilGen.Emit(OpCodes.Dup);
                StoreToVariable(((VARIABLE)oe.expr1).name);
            }
            else if (node is XOR_EQUAL) {
                XOR_EQUAL xe = (XOR_EQUAL)node;
                if (xe.expr1 is FUNCTION_CALL)
                    Report.Error(408, xe.expr1.line, xe.expr1.column);
                LoadFromVariable(((VARIABLE)xe.expr1).name);
                Visit(xe.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Xor", new Type[] { PHPMixed, PHPMixed }));
                ilGen.Emit(OpCodes.Dup);
                StoreToVariable(((VARIABLE)xe.expr1).name);
            }
            else if (node is SL_EQUAL) {
                SL_EQUAL se = (SL_EQUAL)node;
                if (se.expr1 is FUNCTION_CALL)
                    Report.Error(408, se.expr1.line, se.expr1.column);
                LoadFromVariable(((VARIABLE)se.expr1).name);
                Visit(se.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Sl", new Type[] { PHPMixed, PHPMixed }));
                ilGen.Emit(OpCodes.Dup);
                StoreToVariable(((VARIABLE)se.expr1).name);
            }
            else if (node is SR_EQUAL) {
                SR_EQUAL se = (SR_EQUAL)node;
                if (se.expr1 is FUNCTION_CALL)
                    Report.Error(408, se.expr1.line, se.expr1.column);
                LoadFromVariable(((VARIABLE)se.expr1).name);
                Visit(se.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Sr", new Type[] { PHPMixed, PHPMixed }));
                ilGen.Emit(OpCodes.Dup);
                StoreToVariable(((VARIABLE)se.expr1).name);
            }
            else if (node is BOOLEAN_AND) {
                BOOLEAN_AND ba = (BOOLEAN_AND)node;
                Visit(ba.expr1);
                Visit(ba.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("BooleanAnd", new Type[] { PHPMixed, PHPMixed }));
            }
            else if (node is BOOLEAN_OR) {
                BOOLEAN_OR bo = (BOOLEAN_OR)node;
                Visit(bo.expr1);
                Visit(bo.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("BooleanOr", new Type[] { PHPMixed, PHPMixed }));
            }
            else if (node is LOGICAL_AND) {
                LOGICAL_AND la = (LOGICAL_AND)node;
                Visit(la.expr1);
                Visit(la.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("LogicalAnd", new Type[] { PHPMixed, PHPMixed }));
            }
            else if (node is LOGICAL_OR) {
                LOGICAL_OR lo = (LOGICAL_OR)node;
                Visit(lo.expr1);
                Visit(lo.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("LogicalOr", new Type[] { PHPMixed, PHPMixed }));
            }
            else if (node is LOGICAL_XOR) {
                LOGICAL_XOR lx = (LOGICAL_XOR)node;
                Visit(lx.expr1);
                Visit(lx.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("LogicalXor", new Type[] { PHPMixed, PHPMixed }));
            }
            else if (node is CONCAT) {
                CONCAT c = (CONCAT)node;
                Visit(c.expr1);
                Visit(c.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Concat", new Type[] { PHPMixed, PHPMixed }));
            }
            else if (node is PLUS) {
                PLUS p = (PLUS)node;
                Visit(p.expr1);
                Visit(p.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Plus", new Type[] { PHPMixed, PHPMixed }));
            }
            else if (node is MINUS) {
                MINUS m = (MINUS)node;
                Visit(m.expr1);
                Visit(m.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Minus", new Type[] { PHPMixed, PHPMixed }));
            }
            else if (node is TIMES) {
                TIMES t = (TIMES)node;
                Visit(t.expr1);
                Visit(t.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Times", new Type[] { PHPMixed, PHPMixed }));
            }
            else if (node is DIV) {
                DIV d = (DIV)node;
                Visit(d.expr1);
                Visit(d.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Div", new Type[] { PHPMixed, PHPMixed }));
            }
            else if (node is MOD) {
                MOD m = (MOD)node;
                Visit(m.expr1);
                Visit(m.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Mod", new Type[] { PHPMixed, PHPMixed }));
            }
            else if (node is AND) {
                AND a = (AND)node;
                Visit(a.expr1);
                Visit(a.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("And", new Type[] { PHPMixed, PHPMixed }));
            }
            else if (node is OR) {
                OR o = (OR)node;
                Visit(o.expr1);
                Visit(o.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Or", new Type[] { PHPMixed, PHPMixed }));
            }
            else if (node is XOR) {
                XOR x = (XOR)node;
                Visit(x.expr1);
                Visit(x.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Xor", new Type[] { PHPMixed, PHPMixed }));
            }
            else if (node is SL) {
                SL s = (SL)node;
                Visit(s.expr1);
                Visit(s.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Sl", new Type[] { PHPMixed, PHPMixed }));
            }
            else if (node is SR) {
                SL s = (SL)node;
                Visit(s.expr1);
                Visit(s.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Sr", new Type[] { PHPMixed, PHPMixed }));
            }
            else if (node is IS_EQUAL) {
                IS_EQUAL ie = (IS_EQUAL)node;
                Visit(ie.expr1);
                Visit(ie.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("IsEqual", new Type[] { PHPMixed, PHPMixed }));
            }
            else if (node is IS_NOT_EQUAL) {
                IS_NOT_EQUAL ine = (IS_NOT_EQUAL)node;
                Visit(ine.expr1);
                Visit(ine.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("IsNotEqual", new Type[] { PHPMixed, PHPMixed }));
            }
            else if (node is IS_IDENTICAL) {
                IS_IDENTICAL ii = (IS_IDENTICAL)node;
                Visit(ii.expr1);
                Visit(ii.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("IsIdentical", new Type[] { PHPMixed, PHPMixed }));
            }
            else if (node is IS_NOT_IDENTICAL) {
                IS_NOT_IDENTICAL ini = (IS_NOT_IDENTICAL)node;
                Visit(ini.expr1);
                Visit(ini.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("IsNotIdentical", new Type[] { PHPMixed, PHPMixed }));
            }
            else if (node is LOWER) {
                LOWER l = (LOWER)node;
                Visit(l.expr1);
                Visit(l.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Lower", new Type[] { PHPMixed, PHPMixed }));
            }
            else if (node is IS_LOWER_OR_EQUAL) {
                IS_LOWER_OR_EQUAL iloe = (IS_LOWER_OR_EQUAL)node;
                Visit(iloe.expr1);
                Visit(iloe.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("IsLowerOrEqual", new Type[] { PHPMixed, PHPMixed }));
            }
            else if (node is GREATER) {
                GREATER g = (GREATER)node;
                Visit(g.expr1);
                Visit(g.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Greater", new Type[] { PHPMixed, PHPMixed }));
            }
            else if (node is IS_GREATER_OR_EQUAL) {
                IS_GREATER_OR_EQUAL igoe = (IS_GREATER_OR_EQUAL)node;
                Visit(igoe.expr1);
                Visit(igoe.expr2);
                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("IsGreaterOrEqual", new Type[] { PHPMixed, PHPMixed }));
            }
            else if (node is IF_EXPR) {
                IF_EXPR ie = (IF_EXPR)node;
                Label falseBranch = ilGen.DefineLabel();
                Label mergeBranches = ilGen.DefineLabel();
                Visit(ie.expr1);
                ilGen.Emit(OpCodes.Call, PHPCoreConvert.GetMethod("ToValueBool", new Type[] { PHPMixed }));
                ilGen.Emit(OpCodes.Brfalse, falseBranch);
                Visit(ie.expr2);
                ilGen.Emit(OpCodes.Br, mergeBranches);
                ilGen.MarkLabel(falseBranch);
                Visit(ie.expr3);
                ilGen.MarkLabel(mergeBranches);
            }
            else if (node is LNUMBER_SCALAR) {
                LNUMBER_SCALAR ls = (LNUMBER_SCALAR)node;
                ilGen.Emit(OpCodes.Ldc_I4, ls.value);
                ilGen.Emit(OpCodes.Newobj, PHPInteger.GetConstructor(new Type[] { typeof(int) }));
            }
            else if (node is DNUMBER_SCALAR) {
                DNUMBER_SCALAR ds = (DNUMBER_SCALAR)node;
                ilGen.Emit(OpCodes.Ldc_R8, ds.value);
                ilGen.Emit(OpCodes.Newobj, PHPDouble.GetConstructor(new Type[] { typeof(double) }));
            }
            else if (node is STRING_SCALAR) {
                STRING_SCALAR ss = (STRING_SCALAR)node;
                if (ss.value.ToLower() == "true") {
                    ilGen.Emit(OpCodes.Ldc_I4_1);
                    ilGen.Emit(OpCodes.Newobj, PHPBoolean.GetConstructor(new Type[] { typeof(bool) }));
                }
                else if (ss.value.ToLower() == "false") {
                    ilGen.Emit(OpCodes.Ldc_I4_0);
                    ilGen.Emit(OpCodes.Newobj, PHPBoolean.GetConstructor(new Type[] { typeof(bool) }));
                }
                else {
                    ilGen.Emit(OpCodes.Ldstr, ss.value);
                    ilGen.Emit(OpCodes.Newobj, PHPString.GetConstructor(new Type[] { typeof(string) }));
                }
            }
            else if (node is SINGLE_QUOTES) {
                SINGLE_QUOTES sq = (SINGLE_QUOTES)node;
                StringBuilder result = new StringBuilder();
                foreach (object o in sq.encaps_list) {
                    if (o is string)
                        result.Append((string)o);
                    else if (o is VARIABLE) {
                        result.Append('$');
                        result.Append(((VARIABLE)o).name);
                    }
                }
                ilGen.Emit(OpCodes.Ldstr, result.ToString());
                ilGen.Emit(OpCodes.Newobj, PHPString.GetConstructor(new Type[] { typeof(string) }));
            }
            else if (node is DOUBLE_QUOTES) {
                DOUBLE_QUOTES dq = (DOUBLE_QUOTES)node;
                StringBuilder output = new StringBuilder();
                bool concat = false;
                foreach (object o in dq.encaps_list) {
                    if (o is string)
                        output.Append((string)o);
                    else {
                        // push substring between last variable and current one and concat, if necessary
                        if (output.Length > 0) {
                            ilGen.Emit(OpCodes.Ldstr, output.ToString());
                            ilGen.Emit(OpCodes.Newobj, PHPString.GetConstructor(new Type[] { typeof(string) }));
                            if (concat)
                                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Concat", new Type[] { PHPMixed, PHPMixed }));
                            concat = true;
                            output = new StringBuilder();
                        }
                        // push variable value
                        if (o is VARIABLE)
                            Visit((VARIABLE)o);
                        // or push object operator result
                        else if (o is OBJECT_OPERATOR)
                            Visit((OBJECT_OPERATOR)o);
                        // or push Null
                        else
                            ilGen.Emit(OpCodes.Newobj, PHPNull.GetConstructor(Type.EmptyTypes));
                        // concat, if necessary
                        if (concat)
                            ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Concat", new Type[] { PHPMixed, PHPMixed }));
                        concat = true;
                    }
                }
                // push substring after last variable and concat, if necessary
                if (output.Length > 0) {
                    ilGen.Emit(OpCodes.Ldstr, output.ToString());
                    ilGen.Emit(OpCodes.Newobj, PHPString.GetConstructor(new Type[] { typeof(string) }));
                    if (concat)
                        ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Concat", new Type[] { PHPMixed, PHPMixed }));
                    output = null;
                }
            }
            else if (node is HEREDOC) {
                HEREDOC h = (HEREDOC)node;
                StringBuilder output = new StringBuilder();
                bool concat = false;
                foreach (object o in h.encaps_list) {
                    if (o is string)
                        output.Append((string)o);
                    else {
                        // push substring between last variable and current one and concat, if necessary
                        if (output.Length > 0) {
                            ilGen.Emit(OpCodes.Ldstr, output.ToString());
                            ilGen.Emit(OpCodes.Newobj, PHPString.GetConstructor(new Type[] { typeof(string) }));
                            if (concat)
                                ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Concat", new Type[] { PHPMixed, PHPMixed }));
                            concat = true;
                            output = new StringBuilder();
                        }
                        // push variable value
                        if (o is VARIABLE)
                            Visit((VARIABLE)o);
                        // or push object operator result
                        else if (o is OBJECT_OPERATOR)
                            Visit((OBJECT_OPERATOR)o);
                        // or push Null
                        else
                            ilGen.Emit(OpCodes.Newobj, PHPNull.GetConstructor(Type.EmptyTypes));
                        // concat, if necessary
                        if (concat)
                            ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Concat", new Type[] { PHPMixed, PHPMixed }));
                        concat = true;
                    }
                }
                // push substring after last variable and concat, if necessary
                if (output.Length > 0) {
                    ilGen.Emit(OpCodes.Ldstr, output.ToString());
                    ilGen.Emit(OpCodes.Newobj, PHPString.GetConstructor(new Type[] { typeof(string) }));
                    if (concat)
                        ilGen.Emit(OpCodes.Call, PHPCoreLang.GetMethod("Concat", new Type[] { PHPMixed, PHPMixed }));
                    output = null;
                }
            }
            else if (node is CONSTANT) {
                CONSTANT c = (CONSTANT)node;
                // push constant value
                ilGen.Emit(OpCodes.Ldstr, c.name);
                ilGen.Emit(OpCodes.Newobj, PHPString.GetConstructor(new Type[] { typeof(string) }));
                ilGen.Emit(OpCodes.Call, PHPCoreRuntime.GetMethod("GetConstant", new Type[] { PHPMixed }));
            }
            else if (node is UnaryExpression) {
                UnaryExpression ue = (UnaryExpression)node;
                // process expression
                Visit(ue.expr);
            }
            else if (node is BinaryExpression) {
                BinaryExpression be = (BinaryExpression)node;
                // process expressions
                Visit(be.expr1);
                Visit(be.expr2);
            }
            else if (node is TernaryExpression) {
                TernaryExpression te = (TernaryExpression)node;
                // process expressions
                Visit(te.expr1);
                Visit(te.expr2);
                Visit(te.expr3);
            }
            else if (node is Expression) {
                Expression e = (Expression)node;
                if (e is VARIABLE)
                    Visit((VARIABLE)e);
                else if (e is FUNCTION_CALL)
                    Visit((FUNCTION_CALL)e);
                else if (e is ARRAY)
                    Visit((ARRAY)e);
                else if (e is UnaryExpression)
                    Visit((UnaryExpression)e);
                else if (e is BinaryExpression)
                    Visit((BinaryExpression)e);
                else if (e is TernaryExpression)
                    Visit((TernaryExpression)e);
            }
        }
コード例 #3
0
ファイル: Visitors.cs プロジェクト: MonoBrasil/historico
 protected void Visit(ASTNode node)
 {
     if (node == null)
         return;
     else if (node is CLASS_DECLARATION) {
         cd = (CLASS_DECLARATION)node;
         // check if class extends a final class
         if (cd.extends != null) {
             SymbolTableEntry parentCdEntry = SymbolTable.getInstance().lookupGlobal(cd.extends.ToLower(), SymbolTable.CLASS);
             CLASS_DECLARATION parentCd = (CLASS_DECLARATION)parentCdEntry.node;
             if (parentCd.modifier == Modifiers.FINAL)
                 Report.Error(101, parentCd.name, cd.line, cd.column);
         }
         // create type builder
         TypeAttributes modifier = TypeAttributes.Class;
         if (cd.modifier == PHP.Core.Modifiers.PUBLIC)
             modifier |= TypeAttributes.Public;
         //else if (cd.modifier == PHP.Core.Modifiers.ABSTRACT)
         //	modifier |= TypeAttributes.Abstract;
         else if (cd.modifier == PHP.Core.Modifiers.FINAL)
             modifier |= TypeAttributes.Sealed;
         Type parent;
         if (cd.extends == null || typesAlreadyProcessed[cd.extends] == null) {
             if (cd.name == "__MAIN")
                 parent = typeof(object);
             else
                 parent = PHPObject;
         }
         else
             parent = (Type)typesAlreadyProcessed[cd.extends];
         cd.typBld = PEmitter.modBld.DefineType(cd.name, modifier, parent);
         typesAlreadyProcessed.Add(cd.name, cd.typBld);
         // insert class symbol (which is case insensitive)
         SymbolTable.getInstance().insertGlobal(cd.name.ToLower(), SymbolTable.CLASS, cd);
         // process each statement within class
         SymbolTable.getInstance().openScope();
         cd.scope = SymbolTable.getInstance().cur_scope;
         foreach (Statement stmt in cd.stmt_list)
             Visit(stmt);
         SymbolTable.getInstance().closeScope();
         cd = null;
     }
     else if (node is CLASS_VARIABLE_DECLARATION) {
         CLASS_VARIABLE_DECLARATION cvd = (CLASS_VARIABLE_DECLARATION)node;
         // create field builders
         FieldAttributes modifiers = 0;
         if (cvd.modifiers.Count == 0)
             modifiers = FieldAttributes.Public | FieldAttributes.Static;
         else if (cvd.modifiers.Contains(Modifiers.CONST))
             modifiers = FieldAttributes.Public | FieldAttributes.Static | FieldAttributes.InitOnly;
         else if (!cvd.modifiers.Contains(PHP.Core.Modifiers.PUBLIC) && !cvd.modifiers.Contains(PHP.Core.Modifiers.PROTECTED) && !cvd.modifiers.Contains(PHP.Core.Modifiers.PRIVATE))
             modifiers = FieldAttributes.Public;
         else {
             ArrayList tmpModifiers = (ArrayList)cvd.modifiers.Clone();
             if (cvd.modifiers.Contains(PHP.Core.Modifiers.PUBLIC)) {
                 modifiers = FieldAttributes.Public;
                 tmpModifiers.Remove(PHP.Core.Modifiers.PUBLIC);
             }
             else if (cvd.modifiers.Contains(PHP.Core.Modifiers.PROTECTED)) {
                 modifiers = FieldAttributes.Family;
                 tmpModifiers.Remove(PHP.Core.Modifiers.PROTECTED);
             }
             else if (cvd.modifiers.Contains(PHP.Core.Modifiers.PRIVATE)) {
                 modifiers = FieldAttributes.Private;
                 tmpModifiers.Remove(PHP.Core.Modifiers.PRIVATE);
             }
             if (tmpModifiers.Contains(PHP.Core.Modifiers.PUBLIC) || tmpModifiers.Contains(PHP.Core.Modifiers.PROTECTED) || tmpModifiers.Contains(PHP.Core.Modifiers.PRIVATE))
                 Report.Error(105, cvd.line, cvd.column);
         }
         foreach (int modifier in cvd.modifiers) {
             switch (modifier) {
                 case PHP.Core.Modifiers.STATIC: modifiers |= FieldAttributes.Static; break;
                 //case PHP.Core.Modifiers.ABSTRACT: Report.Error(103, "abstract", cvd.line, cvd.column); break;
                 case PHP.Core.Modifiers.FINAL: Report.Error(103, "abstract", cvd.line, cvd.column); break;
             }
         }
         cvd.fieldBuilders = new ArrayList();
         foreach (string name in cvd.names) {
             cvd.fieldBuilders.Add(cd.typBld.DefineField(name, PHPMixed, modifiers));
             // insert member symbol
             SymbolTable.getInstance().insertLocal(name, SymbolTable.CLASS_VARIABLE, cvd);
         }
     }
     else if (node is FUNCTION_DECLARATION) {
         fd = (FUNCTION_DECLARATION)node;
         // check if function overrides a final function with the same name
         CLASS_DECLARATION tmpCd = cd;
         while (tmpCd.extends != null) {
             SymbolTableEntry parentCdEntry = SymbolTable.getInstance().lookupGlobal(cd.extends.ToLower(), SymbolTable.CLASS);
             tmpCd = (CLASS_DECLARATION)parentCdEntry.node;
             SymbolTableEntry superFdEntry = tmpCd.scope.lookup(fd.name.ToLower(), SymbolTable.FUNCTION);
             if (superFdEntry != null) {
                 FUNCTION_DECLARATION superFd = (FUNCTION_DECLARATION)superFdEntry.node;
                 if (superFd.modifiers.Contains(Modifiers.FINAL)) {
                     StringBuilder parameters = new StringBuilder();
                     foreach (PARAMETER_DECLARATION pd in superFd.parameters) {
                         if (pd.type != null) {
                             parameters.Append(pd.type);
                             parameters.Append(" ");
                         }
                         parameters.Append(pd.name);
                         parameters.Append(", ");
                     }
                     if (parameters.Length > 0)
                         parameters.Remove(parameters.Length - 2, 2);
                     Report.Error(102, tmpCd.name + "::" + superFd.name + "(" + parameters.ToString() + ")", fd.line, fd.column);
                 }
             }
         }
         // create constructor and method builders
         MethodAttributes modifiers = 0;
         if (fd.modifiers.Count == 0)
             modifiers = MethodAttributes.Public;
         else if (!fd.modifiers.Contains(PHP.Core.Modifiers.PUBLIC) && !fd.modifiers.Contains(PHP.Core.Modifiers.PROTECTED) && !fd.modifiers.Contains(PHP.Core.Modifiers.PRIVATE))
             modifiers = MethodAttributes.Public;
         else {
             ArrayList tmpModifiers = (ArrayList)fd.modifiers.Clone();
             if (fd.modifiers.Contains(PHP.Core.Modifiers.PUBLIC)) {
                 modifiers = MethodAttributes.Public;
                 tmpModifiers.Remove(PHP.Core.Modifiers.PUBLIC);
             }
             else if (fd.modifiers.Contains(PHP.Core.Modifiers.PROTECTED)) {
                 modifiers = MethodAttributes.Family;
                 tmpModifiers.Remove(PHP.Core.Modifiers.PROTECTED);
             }
             else if (fd.modifiers.Contains(PHP.Core.Modifiers.PRIVATE)) {
                 modifiers = MethodAttributes.Private;
                 tmpModifiers.Remove(PHP.Core.Modifiers.PRIVATE);
             }
             if (tmpModifiers.Contains(PHP.Core.Modifiers.PUBLIC) || tmpModifiers.Contains(PHP.Core.Modifiers.PROTECTED) || tmpModifiers.Contains(PHP.Core.Modifiers.PRIVATE))
                 Report.Error(105, fd.line, fd.column);
         }
         foreach (int modifier in fd.modifiers) {
             if (fd.name == "__construct")
                 switch (modifier) {
                     case PHP.Core.Modifiers.STATIC: Report.Error(104, "static", fd.line, fd.column); break;
                     //case PHP.Core.Modifiers.ABSTRACT: Report.Error(104, "abstract", fd.line, fd.column); break;
                     case PHP.Core.Modifiers.FINAL: modifiers |= MethodAttributes.Final; break;
                 }
             else if (fd.name == "__constructStatic")
                 modifiers |= MethodAttributes.Static;
             else
                 switch (modifier) {
                     case PHP.Core.Modifiers.STATIC: modifiers |= MethodAttributes.Static; break;
                     //case PHP.Core.Modifiers.ABSTRACT: modifiers |= MethodAttributes.Abstract; break;
                     case PHP.Core.Modifiers.FINAL: modifiers |= MethodAttributes.Final; break;
                 }
         }
         Type[] parameterTypes = new Type[fd.parameters.Count];
         for (int i = 0; i < parameterTypes.Length; i++)
             parameterTypes[i] = PHPMixed;
         Type returnType;
         if (fd.name == "__MAIN")
             returnType = typeof(void);
         else
             returnType = PHPMixed;
         if (fd.name == "__construct" || fd.name == "__constructStatic")
             fd.ctrBld = cd.typBld.DefineConstructor(modifiers, CallingConventions.Standard, parameterTypes);
         else
             fd.mthBld = cd.typBld.DefineMethod(fd.name, modifiers, returnType, parameterTypes);
         // at beginning of script
         if (fd.name == "__MAIN") {
             mainMethod = fd.mthBld;
             // disable warnings, if desired
             if (!Report.warningsEnabled) {
                 mPHPRuntime = Assembly.LoadFrom("mPHPRuntime.dll");
                 Type report = mPHPRuntime.GetType("PHP.Core.Report");
                 fd.mthBld.GetILGenerator().Emit(OpCodes.Ldc_I4_0);
                 fd.mthBld.GetILGenerator().Emit(OpCodes.Stsfld, report.GetField("warningsEnabled"));
             }
             // initialize local settings to en-US
             fd.mthBld.GetILGenerator().Emit(OpCodes.Call, PHPCoreLang.GetMethod("Init", Type.EmptyTypes));
         }
         // insert function symbol (which is case insensitive)
         SymbolTable.getInstance().insertLocal(fd.name.ToLower(), SymbolTable.FUNCTION, fd);
         // remember scope
         SymbolTable.getInstance().openScope();
         fd.scope = SymbolTable.getInstance().cur_scope;
         SymbolTable.getInstance().closeScope();
         fd = null;
     }
 }
コード例 #4
0
ファイル: Parser.cs プロジェクト: MonoBrasil/historico
    /** Method with the actual generated action code. */
    public TUVienna.CS_CUP.Runtime.Symbol CUP_Parser_do_action(
    int                        CUP_Parser_act_num,
    TUVienna.CS_CUP.Runtime.lr_parser CUP_Parser_parser,
    System.Collections.Stack            xstack1,
    int                        CUP_Parser_top)
    {
        /* Symbol object for return from actions */
          mStack CUP_Parser_stack =new mStack(xstack1);
          TUVienna.CS_CUP.Runtime.Symbol CUP_Parser_result;

          /* select the action based on the action number */
          switch (CUP_Parser_act_num)
        {
          /*. . . . . . . . . . . . . . . . . . . .*/
          case 354: // class_constant ::= fully_qualified_class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING
            {
              Expression RESULT = null;
        int fqcnleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int fqcnright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string fqcn = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int sleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int sright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string s = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new PAAMAYIM_NEKUDOTAYIM(fqcn, new VARIABLE(s, sleft, sright), fqcnleft, fqcnright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(47/*class_constant*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 353: // isset_variables ::= isset_variables COMMA variable
            {
              object RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(103/*isset_variables*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 352: // isset_variables ::= variable
            {
              object RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(103/*isset_variables*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 351: // internal_functions_in_yacc ::= T_REQUIRE_ONCE expr
            {
              object RESULT = null;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string e = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         Report.Error(900, e);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(102/*internal_functions_in_yacc*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 350: // internal_functions_in_yacc ::= T_REQUIRE expr
            {
              object RESULT = null;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string e = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         Report.Error(900, e);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(102/*internal_functions_in_yacc*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 349: // internal_functions_in_yacc ::= T_EVAL BRACE_OPEN expr BRACE_CLOSE
            {
              object RESULT = null;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).right;
        string e = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-3)).value;
         Report.Error(900, e);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(102/*internal_functions_in_yacc*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 348: // internal_functions_in_yacc ::= T_INCLUDE_ONCE expr
            {
              object RESULT = null;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string e = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         Report.Error(900, e);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(102/*internal_functions_in_yacc*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 347: // internal_functions_in_yacc ::= T_INCLUDE expr
            {
              object RESULT = null;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string e = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         Report.Error(900, e);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(102/*internal_functions_in_yacc*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 346: // internal_functions_in_yacc ::= T_EMPTY BRACE_OPEN variable BRACE_CLOSE
            {
              object RESULT = null;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).right;
        string e = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-3)).value;
         Report.Error(900, e);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(102/*internal_functions_in_yacc*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 345: // internal_functions_in_yacc ::= T_ISSET BRACE_OPEN isset_variables BRACE_CLOSE
            {
              object RESULT = null;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).right;
        string e = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-3)).value;
         Report.Error(900, e);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(102/*internal_functions_in_yacc*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 344: // encaps_var_offset ::= T_VARIABLE
            {
              Expression RESULT = null;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string v = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new VARIABLE(v, vleft, vright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(46/*encaps_var_offset*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 343: // encaps_var_offset ::= T_NUM_STRING
            {
              Expression RESULT = null;
        int nsleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int nsright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string ns = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new STRING_SCALAR(ns, nsleft, nsright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(46/*encaps_var_offset*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 342: // encaps_var_offset ::= T_STRING
            {
              Expression RESULT = null;
        int sleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int sright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string s = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new STRING_SCALAR(s, sleft, sright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(46/*encaps_var_offset*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 341: // encaps_var ::= T_CURLY_OPEN variable CURLY_BRACE_CLOSE
            {
              Expression RESULT = null;
         Report.Error(900, "variable variables");
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(45/*encaps_var*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 340: // encaps_var ::= T_DOLLAR_OPEN_CURLY_BRACES T_STRING_VARNAME SQUARE_BRACE_OPEN expr SQUARE_BRACE_CLOSE CURLY_BRACE_CLOSE
            {
              Expression RESULT = null;
         Report.Error(900, "variable variables");
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(45/*encaps_var*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-5)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 339: // encaps_var ::= T_DOLLAR_OPEN_CURLY_BRACES expr CURLY_BRACE_CLOSE
            {
              Expression RESULT = null;
         Report.Error(900, "variable variables");
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(45/*encaps_var*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 338: // encaps_var ::= T_VARIABLE T_OBJECT_OPERATOR T_STRING
            {
              Expression RESULT = null;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string v = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int sleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int sright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string s = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new OBJECT_OPERATOR(new VARIABLE(v, vleft, vright), new VARIABLE(s, sleft, sright), vleft, vright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(45/*encaps_var*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 337: // encaps_var ::= T_VARIABLE SQUARE_BRACE_OPEN encaps_var_offset SQUARE_BRACE_CLOSE
            {
              Expression RESULT = null;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).right;
        string v = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-3)).value;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int evoleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int evoright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        Expression evo = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         RESULT = new VARIABLE(v, new OFFSET(OFFSET.SQUARE, evo, tleft, tright), vleft, vright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(45/*encaps_var*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 336: // encaps_var ::= T_VARIABLE
            {
              Expression RESULT = null;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string v = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new VARIABLE(v, vleft, vright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(45/*encaps_var*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 335: // encaps_list ::=
            {
              ArrayList RESULT = null;
         RESULT = new ArrayList();
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(76/*encaps_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 334: // encaps_list ::= encaps_list T_OBJECT_OPERATOR
            {
              ArrayList RESULT = null;
        int elleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int elright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        ArrayList el = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int ooleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int ooright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string oo = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         el.Add(oo); RESULT = el;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(76/*encaps_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 333: // encaps_list ::= encaps_list CURLY_BRACE_CLOSE
            {
              ArrayList RESULT = null;
        int elleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int elright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        ArrayList el = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int cbcleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int cbcright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string cbc = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         el.Add(cbc); RESULT = el;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(76/*encaps_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 332: // encaps_list ::= encaps_list CURLY_BRACE_OPEN
            {
              ArrayList RESULT = null;
        int elleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int elright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        ArrayList el = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int cboleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int cboright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string cbo = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         el.Add(cbo); RESULT = el;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(76/*encaps_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 331: // encaps_list ::= encaps_list SQUARE_BRACE_CLOSE
            {
              ArrayList RESULT = null;
        int elleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int elright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        ArrayList el = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int sbcleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int sbcright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string sbc = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         el.Add(sbc); RESULT = el;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(76/*encaps_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 330: // encaps_list ::= encaps_list SQUARE_BRACE_OPEN
            {
              ArrayList RESULT = null;
        int elleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int elright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        ArrayList el = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int sboleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int sboright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string sbo = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         el.Add(sbo); RESULT = el;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(76/*encaps_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 329: // encaps_list ::= encaps_list T_BAD_CHARACTER
            {
              ArrayList RESULT = null;
        int elleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int elright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        ArrayList el = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int bcleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int bcright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string bc = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         el.Add(bc); RESULT = el;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(76/*encaps_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 328: // encaps_list ::= encaps_list T_CHARACTER
            {
              ArrayList RESULT = null;
        int elleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int elright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        ArrayList el = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int cleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int cright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string c = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         el.Add(c); RESULT = el;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(76/*encaps_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 327: // encaps_list ::= encaps_list T_ENCAPSED_AND_WHITESPACE
            {
              ArrayList RESULT = null;
        int elleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int elright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        ArrayList el = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int eawleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eawright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string eaw = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         el.Add(eaw); RESULT = el;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(76/*encaps_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 326: // encaps_list ::= encaps_list T_NUM_STRING
            {
              ArrayList RESULT = null;
        int elleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int elright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        ArrayList el = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int nsleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int nsright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string ns = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         el.Add(ns); RESULT = el;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(76/*encaps_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 325: // encaps_list ::= encaps_list T_STRING
            {
              ArrayList RESULT = null;
        int elleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int elright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        ArrayList el = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int sleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int sright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string s = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         el.Add(s); RESULT = el;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(76/*encaps_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 324: // encaps_list ::= encaps_list encaps_var
            {
              ArrayList RESULT = null;
        int elleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int elright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        ArrayList el = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int evleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int evright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression ev = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         el.Add(ev); RESULT = el;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(76/*encaps_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 323: // non_empty_array_pair_list ::= AND w_variable
            {
              ArrayList RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int wvleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int wvright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression wv = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         ArrayList neapl = new ArrayList(); neapl.Add(new ARRAY_PAIR(null, new REFERENCE(wv, tleft, tright), tleft, tright)); RESULT = neapl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(75/*non_empty_array_pair_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 322: // non_empty_array_pair_list ::= expr T_DOUBLE_ARROW AND w_variable
            {
              ArrayList RESULT = null;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-3)).value;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int wvleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int wvright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression wv = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         ArrayList neapl = new ArrayList(); neapl.Add(new ARRAY_PAIR(e, new REFERENCE(wv, tleft, tright), eleft, eright)); RESULT = neapl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(75/*non_empty_array_pair_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 321: // non_empty_array_pair_list ::= non_empty_array_pair_list COMMA AND w_variable
            {
              ArrayList RESULT = null;
        int neaplleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left;
        int neaplright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).right;
        ArrayList neapl = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-3)).value;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int wvleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int wvright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression wv = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         neapl.Add(new ARRAY_PAIR(null, new REFERENCE(wv, tleft, tright), tleft, tright)); RESULT = neapl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(75/*non_empty_array_pair_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 320: // non_empty_array_pair_list ::= non_empty_array_pair_list COMMA expr T_DOUBLE_ARROW AND w_variable
            {
              ArrayList RESULT = null;
        int neaplleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-5)).left;
        int neaplright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-5)).right;
        ArrayList neapl = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-5)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-3)).value;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int wvleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int wvright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression wv = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         neapl.Add(new ARRAY_PAIR(e, new REFERENCE(wv, tleft, tright), eleft, eright)); RESULT = neapl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(75/*non_empty_array_pair_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-5)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 319: // non_empty_array_pair_list ::= expr
            {
              ArrayList RESULT = null;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         ArrayList neapl = new ArrayList(); neapl.Add(new ARRAY_PAIR(null, e, eleft, eright)); RESULT = neapl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(75/*non_empty_array_pair_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 318: // non_empty_array_pair_list ::= expr T_DOUBLE_ARROW expr
            {
              ArrayList RESULT = null;
        int e1left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int e1right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression e1 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int e2left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int e2right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e2 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         ArrayList neapl = new ArrayList(); neapl.Add(new ARRAY_PAIR(e1, e2, e1left, e1right)); RESULT = neapl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(75/*non_empty_array_pair_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 317: // non_empty_array_pair_list ::= non_empty_array_pair_list COMMA expr
            {
              ArrayList RESULT = null;
        int neaplleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int neaplright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        ArrayList neapl = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         neapl.Add(new ARRAY_PAIR(null, e, eleft, eright)); RESULT = neapl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(75/*non_empty_array_pair_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 316: // non_empty_array_pair_list ::= non_empty_array_pair_list COMMA expr T_DOUBLE_ARROW expr
            {
              ArrayList RESULT = null;
        int neaplleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left;
        int neaplright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).right;
        ArrayList neapl = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-4)).value;
        int e1left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int e1right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression e1 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int e2left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int e2right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e2 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         neapl.Add(new ARRAY_PAIR(e1, e2, e1left, e1right)); RESULT = neapl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(75/*non_empty_array_pair_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 315: // array_pair_list ::= non_empty_array_pair_list possible_comma
            {
              ArrayList RESULT = null;
        int neaplleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int neaplright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        ArrayList neapl = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         RESULT = neapl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(74/*array_pair_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 314: // array_pair_list ::=
            {
              ArrayList RESULT = null;
         RESULT = new ArrayList();
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(74/*array_pair_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 313: // assignment_list_element ::=
            {
              object RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(101/*assignment_list_element*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 312: // assignment_list_element ::= T_LIST BRACE_OPEN assignment_list BRACE_CLOSE
            {
              object RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(101/*assignment_list_element*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 311: // assignment_list_element ::= variable
            {
              object RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(101/*assignment_list_element*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 310: // assignment_list ::= assignment_list_element
            {
              object RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(100/*assignment_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 309: // assignment_list ::= assignment_list COMMA assignment_list_element
            {
              object RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(100/*assignment_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 308: // simple_indirect_reference ::= simple_indirect_reference DOLLAR
            {
              object RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(99/*simple_indirect_reference*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 307: // simple_indirect_reference ::= DOLLAR
            {
              object RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(99/*simple_indirect_reference*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 306: // variable_name ::= CURLY_BRACE_OPEN expr CURLY_BRACE_CLOSE
            {
              Expression RESULT = null;
         Report.Error(900, "variable variables");
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(44/*variable_name*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 305: // variable_name ::= T_STRING
            {
              Expression RESULT = null;
        int sleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int sright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string s = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new VARIABLE(s, sleft, sright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(44/*variable_name*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 304: // object_dim_list ::= variable_name
            {
              Expression RESULT = null;
        int vnleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int vnright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression vn = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = vn;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(43/*object_dim_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 303: // object_dim_list ::= object_dim_list CURLY_BRACE_OPEN expr CURLY_BRACE_CLOSE
            {
              Expression RESULT = null;
         Report.Error(900, "offset");
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(43/*object_dim_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 302: // object_dim_list ::= object_dim_list SQUARE_BRACE_OPEN dim_offset SQUARE_BRACE_CLOSE
            {
              Expression RESULT = null;
        int odlleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left;
        int odlright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).right;
        Expression odl = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-3)).value;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int dosleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int dosright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        Expression dos = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         ((VARIABLE)odl).offset = new OFFSET(OFFSET.SQUARE, dos, tleft, tright); RESULT = odl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(43/*object_dim_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 301: // object_property ::= variable_without_objects
            {
              Expression RESULT = null;
        int wvoleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int wvoright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression wvo = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = wvo;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(42/*object_property*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 300: // object_property ::= object_dim_list
            {
              Expression RESULT = null;
        int odlleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int odlright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression odl = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = odl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(42/*object_property*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 299: // dim_offset ::= expr
            {
              Expression RESULT = null;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = e;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(41/*dim_offset*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 298: // dim_offset ::=
            {
              Expression RESULT = null;
         RESULT = null;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(41/*dim_offset*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 297: // compound_variable ::= DOLLAR CURLY_BRACE_OPEN expr CURLY_BRACE_CLOSE
            {
              Expression RESULT = null;
         Report.Error(900, "variable variables");
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(40/*compound_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 296: // compound_variable ::= T_VARIABLE
            {
              Expression RESULT = null;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string v = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new VARIABLE(v, vleft, vright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(40/*compound_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 295: // reference_variable ::= compound_variable
            {
              Expression RESULT = null;
        int cvleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int cvright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression cv = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = cv;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(39/*reference_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 294: // reference_variable ::= reference_variable CURLY_BRACE_OPEN expr CURLY_BRACE_CLOSE
            {
              Expression RESULT = null;
         Report.Error(900, "offset");
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(39/*reference_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 293: // reference_variable ::= reference_variable SQUARE_BRACE_OPEN dim_offset SQUARE_BRACE_CLOSE
            {
              Expression RESULT = null;
        int rvleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left;
        int rvright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).right;
        Expression rv = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-3)).value;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int dofleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int dofright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        Expression dof = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         ((VARIABLE)rv).offset = new OFFSET(OFFSET.SQUARE, dof, tleft, tright); RESULT = rv;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(39/*reference_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 292: // base_variable ::= static_member
            {
              Expression RESULT = null;
        int smleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int smright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression sm = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = sm;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(38/*base_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 291: // base_variable ::= simple_indirect_reference reference_variable
            {
              Expression RESULT = null;
         Report.Error(900, "variable variables");
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(38/*base_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 290: // base_variable ::= reference_variable
            {
              Expression RESULT = null;
        int rvleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int rvright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression rv = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = rv;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(38/*base_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 289: // base_variable_with_function_calls ::= function_call
            {
              Expression RESULT = null;
        int fcleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int fcright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression fc = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = fc;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(37/*base_variable_with_function_calls*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 288: // base_variable_with_function_calls ::= base_variable
            {
              Expression RESULT = null;
        int bvleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int bvright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression bv = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = bv;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(37/*base_variable_with_function_calls*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 287: // static_member ::= fully_qualified_class_name T_PAAMAYIM_NEKUDOTAYIM variable_without_objects
            {
              Expression RESULT = null;
        int fqcnleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int fqcnright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string fqcn = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int vwoleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int vworight = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression vwo = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new PAAMAYIM_NEKUDOTAYIM(fqcn, vwo, fqcnleft, fqcnright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(36/*static_member*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 286: // variable_without_objects ::= simple_indirect_reference reference_variable
            {
              Expression RESULT = null;
         Report.Error(900, "variable variables");
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(35/*variable_without_objects*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 285: // variable_without_objects ::= reference_variable
            {
              Expression RESULT = null;
        int rvleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int rvright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression rv = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = rv;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(35/*variable_without_objects*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 284: // method_or_not ::=
            {
              ExpressionList RESULT = null;
         RESULT = null;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(62/*method_or_not*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 283: // method_or_not ::= BRACE_OPEN function_call_parameter_list BRACE_CLOSE
            {
              ExpressionList RESULT = null;
        int fcplleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int fcplright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        ExpressionList fcpl = (ExpressionList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         RESULT = fcpl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(62/*method_or_not*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 282: // variable_property ::= T_OBJECT_OPERATOR object_property method_or_not
            {
              Expression RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int opleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int opright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        Expression op = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int monleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int monright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        ExpressionList mon = (ExpressionList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         Expression expr2; if (mon == null) expr2 = (VARIABLE)op; else expr2 = new FUNCTION_CALL(((VARIABLE)op).name, mon, opleft, opright);
           RESULT = new OBJECT_OPERATOR(null, expr2, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(34/*variable_property*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 281: // variable_properties ::=
            {
              ExpressionList RESULT = null;
         RESULT = new ExpressionList();
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(61/*variable_properties*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 280: // variable_properties ::= variable_properties variable_property
            {
              ExpressionList RESULT = null;
        int vpsleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int vpsright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        ExpressionList vps = (ExpressionList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int vpleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int vpright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression vp = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         vps.Add(vp); RESULT = vps;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(61/*variable_properties*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 279: // variable ::= base_variable_with_function_calls
            {
              Expression RESULT = null;
        int bvwfcleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int bvwfcright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression bvwfc = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = bvwfc;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(33/*variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 278: // variable ::= base_variable_with_function_calls T_OBJECT_OPERATOR object_property method_or_not variable_properties
            {
              Expression RESULT = null;
        int bvwfcleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left;
        int bvwfcright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).right;
        Expression bvwfc = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-4)).value;
        int opleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int opright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression op = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int monleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int monright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        ExpressionList mon = (ExpressionList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int vpsleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int vpsright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        ExpressionList vps = (ExpressionList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         Expression expr;
           if (mon == null) expr = (VARIABLE)op; else expr = new FUNCTION_CALL(((VARIABLE)op).name, mon, opleft, opright);
           if (vps.Count() == 0) { RESULT = new OBJECT_OPERATOR(bvwfc, expr, bvwfcleft, bvwfcright); }
           else { for (int i = vps.Count() - 1; i > 0; i--) {
                      OBJECT_OPERATOR curr = (OBJECT_OPERATOR)vps.Get(i);
                      OBJECT_OPERATOR prev = (OBJECT_OPERATOR)vps.Get(i-1);
                      curr.expr1 = prev.expr2;
                      prev.expr2 = curr;
                  }
                  ((OBJECT_OPERATOR)vps.Get(0)).expr1 = expr;
                  RESULT = new OBJECT_OPERATOR(bvwfc, vps.Get(0), bvwfcleft, bvwfcright); }

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(33/*variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 277: // rw_variable ::= variable
            {
              Expression RESULT = null;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression v = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = v;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(32/*rw_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 276: // w_variable ::= variable
            {
              Expression RESULT = null;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression v = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = v;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(31/*w_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 275: // r_variable ::= variable
            {
              Expression RESULT = null;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression v = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = v;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(30/*r_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 274: // expr ::= expr_without_variable
            {
              Expression RESULT = null;
        int ewvleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int ewvright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression ewv = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = ewv;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(29/*expr*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 273: // expr ::= r_variable
            {
              Expression RESULT = null;
        int rleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int rright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression r = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = r;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(29/*expr*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 272: // non_empty_static_array_pair_list ::= static_scalar
            {
              ArrayList RESULT = null;
        int ssleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int ssright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression ss = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         ArrayList nesapl = new ArrayList(); nesapl.Add(new ARRAY_PAIR(null, ss, ssleft, ssright)); RESULT = nesapl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(73/*non_empty_static_array_pair_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 271: // non_empty_static_array_pair_list ::= static_scalar T_DOUBLE_ARROW static_scalar
            {
              ArrayList RESULT = null;
        int ss1left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int ss1right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression ss1 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int ss2left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int ss2right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression ss2 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         ArrayList nesapl = new ArrayList(); nesapl.Add(new ARRAY_PAIR(ss1, ss2, ss1left, ss1right)); RESULT = nesapl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(73/*non_empty_static_array_pair_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 270: // non_empty_static_array_pair_list ::= non_empty_static_array_pair_list COMMA static_scalar
            {
              ArrayList RESULT = null;
        int nesaplleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int nesaplright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        ArrayList nesapl = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int ssleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int ssright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression ss = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         nesapl.Add(new ARRAY_PAIR(null, ss, ssleft, ssright)); RESULT = nesapl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(73/*non_empty_static_array_pair_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 269: // non_empty_static_array_pair_list ::= non_empty_static_array_pair_list COMMA static_scalar T_DOUBLE_ARROW static_scalar
            {
              ArrayList RESULT = null;
        int nesaplleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left;
        int nesaplright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).right;
        ArrayList nesapl = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-4)).value;
        int ss1left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int ss1right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression ss1 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int ss2left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int ss2right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression ss2 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         nesapl.Add(new ARRAY_PAIR(ss1, ss2, ss1left, ss1right)); RESULT = nesapl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(73/*non_empty_static_array_pair_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 268: // possible_comma ::= COMMA
            {
              object RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(85/*possible_comma*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 267: // possible_comma ::=
            {
              object RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(85/*possible_comma*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 266: // static_array_pair_list ::= non_empty_static_array_pair_list
            {
              ArrayList RESULT = null;
        int nesaplleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int nesaplright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        ArrayList nesapl = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = nesapl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(72/*static_array_pair_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 265: // static_array_pair_list ::=
            {
              ArrayList RESULT = null;
         RESULT = new ArrayList();
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(72/*static_array_pair_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 264: // scalar ::= T_START_HEREDOC encaps_list T_END_HEREDOC
            {
              Expression RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int elleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int elright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        ArrayList el = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         RESULT = new HEREDOC(el, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(28/*scalar*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 263: // scalar ::= SINGLE_QUOTE encaps_list SINGLE_QUOTE
            {
              Expression RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int elleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int elright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        ArrayList el = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         RESULT = new SINGLE_QUOTES(el, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(28/*scalar*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 262: // scalar ::= DOUBLE_QUOTES encaps_list DOUBLE_QUOTES
            {
              Expression RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int elleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int elright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        ArrayList el = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         RESULT = new DOUBLE_QUOTES(el, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(28/*scalar*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 261: // scalar ::= common_scalar
            {
              Expression RESULT = null;
        int csleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int csright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression cs = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = cs;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(28/*scalar*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 260: // scalar ::= class_constant
            {
              Expression RESULT = null;
        int ccleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int ccright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression cc = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = cc;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(28/*scalar*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 259: // scalar ::= T_STRING_VARNAME
            {
              Expression RESULT = null;
        int svleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int svright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string sv = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new VARIABLE(sv, svleft, svright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(28/*scalar*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 258: // scalar ::= T_STRING
            {
              Expression RESULT = null;
        int sleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int sright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string s = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         if (s == "true".ToLower() || s == "false".ToLower()) RESULT = new STRING_SCALAR(s, sleft, sright); else RESULT = new CONSTANT(s, sleft, sright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(28/*scalar*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 257: // static_class_constant ::= T_STRING T_PAAMAYIM_NEKUDOTAYIM T_STRING
            {
              Expression RESULT = null;
        int s1left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int s1right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string s1 = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int s2left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int s2right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string s2 = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new PAAMAYIM_NEKUDOTAYIM(s1, new VARIABLE(s2, s1left, s1right), s1left, s1right);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(27/*static_class_constant*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 256: // static_scalar ::= static_class_constant
            {
              Expression RESULT = null;
        int sccleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int sccright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression scc = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = scc;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(26/*static_scalar*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 255: // static_scalar ::= T_ARRAY BRACE_OPEN static_array_pair_list BRACE_CLOSE
            {
              Expression RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-3)).value;
        int saplleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int saplright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        ArrayList sapl = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         RESULT = new ARRAY(sapl, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(26/*static_scalar*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 254: // static_scalar ::= MINUS static_scalar
            {
              Expression RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int ssleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int ssright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression ss = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new MINUS(new LNUMBER_SCALAR(0, tleft, tright), ss, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(26/*static_scalar*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 253: // static_scalar ::= PLUS static_scalar
            {
              Expression RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int ssleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int ssright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression ss = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new PLUS(new LNUMBER_SCALAR(0, tleft, tright), ss, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(26/*static_scalar*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 252: // static_scalar ::= T_STRING
            {
              Expression RESULT = null;
        int sleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int sright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string s = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         if (s == "true".ToLower() || s == "false".ToLower()) RESULT = new STRING_SCALAR(s, sleft, sright); else RESULT = new CONSTANT(s, sleft, sright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(26/*static_scalar*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 251: // static_scalar ::= common_scalar
            {
              Expression RESULT = null;
        int csleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int csright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression cs = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = cs;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(26/*static_scalar*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 250: // common_scalar ::= T_FUNC_C
            {
              Expression RESULT = null;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string e = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         Report.Error(900, e);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(25/*common_scalar*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 249: // common_scalar ::= T_METHOD_C
            {
              Expression RESULT = null;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string e = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         Report.Error(900, e);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(25/*common_scalar*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 248: // common_scalar ::= T_CLASS_C
            {
              Expression RESULT = null;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string e = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         Report.Error(900, e);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(25/*common_scalar*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 247: // common_scalar ::= T_FILE
            {
              Expression RESULT = null;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string e = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         Report.Error(900, e);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(25/*common_scalar*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 246: // common_scalar ::= T_LINE
            {
              Expression RESULT = null;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string e = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         Report.Error(900, e);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(25/*common_scalar*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 245: // common_scalar ::= T_CONSTANT_ENCAPSED_STRING
            {
              Expression RESULT = null;
        int cesleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int cesright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string ces = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new STRING_SCALAR(ces, cesleft, cesright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(25/*common_scalar*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 244: // common_scalar ::= T_DNUMBER
            {
              Expression RESULT = null;
        int dleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int dright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string d = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new DNUMBER_SCALAR(System.Convert.ToDouble(d), dleft, dright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(25/*common_scalar*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 243: // common_scalar ::= T_LNUMBER
            {
              Expression RESULT = null;
        int lleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int lright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string l = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new LNUMBER_SCALAR(System.Convert.ToInt32(l), lleft, lright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(25/*common_scalar*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 242: // ctor_arguments ::= BRACE_OPEN function_call_parameter_list BRACE_CLOSE
            {
              ExpressionList RESULT = null;
        int fcplleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int fcplright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        ExpressionList fcpl = (ExpressionList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         RESULT = fcpl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(60/*ctor_arguments*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 241: // ctor_arguments ::=
            {
              ExpressionList RESULT = null;
         RESULT = new ExpressionList();
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(60/*ctor_arguments*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 240: // exit_expr ::= BRACE_OPEN expr BRACE_CLOSE
            {
              Expression RESULT = null;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         RESULT = e;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(24/*exit_expr*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 239: // exit_expr ::= BRACE_OPEN BRACE_CLOSE
            {
              Expression RESULT = null;
         RESULT = null;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(24/*exit_expr*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 238: // exit_expr ::=
            {
              Expression RESULT = null;
         RESULT = null;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(24/*exit_expr*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 237: // dynamic_class_name_variable_property ::= T_OBJECT_OPERATOR object_property
            {
              object RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(98/*dynamic_class_name_variable_property*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 236: // dynamic_class_name_variable_properties ::=
            {
              object RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(97/*dynamic_class_name_variable_properties*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 235: // dynamic_class_name_variable_properties ::= dynamic_class_name_variable_properties dynamic_class_name_variable_property
            {
              object RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(97/*dynamic_class_name_variable_properties*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 234: // dynamic_class_name_reference ::= base_variable
            {
              object RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(96/*dynamic_class_name_reference*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 233: // dynamic_class_name_reference ::= base_variable T_OBJECT_OPERATOR object_property dynamic_class_name_variable_properties
            {
              object RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(96/*dynamic_class_name_reference*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 232: // class_name_reference ::= dynamic_class_name_reference
            {
              string RESULT = null;
         Report.Error(900, "dynamic class name references");
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(80/*class_name_reference*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 231: // class_name_reference ::= T_STRING
            {
              string RESULT = null;
        int sleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int sright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string s = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = s;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(80/*class_name_reference*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 230: // fully_qualified_class_name ::= T_STRING
            {
              string RESULT = null;
        int sleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int sright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string s = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = s;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(79/*fully_qualified_class_name*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 229: // function_call ::= variable_without_objects BRACE_OPEN function_call_parameter_list BRACE_CLOSE
            {
              Expression RESULT = null;
        int vwoleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left;
        int vworight = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).right;
        Expression vwo = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-3)).value;
        int fcplleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int fcplright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        ExpressionList fcpl = (ExpressionList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         Report.Error(900, "variable functions");
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(23/*function_call*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 228: // function_call ::= fully_qualified_class_name T_PAAMAYIM_NEKUDOTAYIM variable_without_objects BRACE_OPEN function_call_parameter_list BRACE_CLOSE
            {
              Expression RESULT = null;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).right;
        string e = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-4)).value;
         Report.Error(900, "variable functions");
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(23/*function_call*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-5)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 227: // function_call ::= fully_qualified_class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING BRACE_OPEN function_call_parameter_list BRACE_CLOSE
            {
              Expression RESULT = null;
        int fqcnleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-5)).left;
        int fqcnright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-5)).right;
        string fqcn = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-5)).value;
        int sleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left;
        int sright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).right;
        string s = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-3)).value;
        int fcplleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int fcplright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        ExpressionList fcpl = (ExpressionList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         RESULT = new PAAMAYIM_NEKUDOTAYIM(fqcn, new FUNCTION_CALL(s, fcpl, fqcnleft, fqcnright), fqcnleft, fqcnright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(23/*function_call*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-5)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 226: // function_call ::= T_STRING BRACE_OPEN function_call_parameter_list BRACE_CLOSE
            {
              Expression RESULT = null;
        int sleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left;
        int sright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).right;
        string s = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-3)).value;
        int fcplleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int fcplright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        ExpressionList fcpl = (ExpressionList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         RESULT = new FUNCTION_CALL(s, fcpl, sleft, sright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(23/*function_call*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 225: // expr_without_variable ::= T_PRINT expr
            {
              Expression RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new PRINT(e, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 224: // expr_without_variable ::= BACK_QUOTE encaps_list BACK_QUOTE
            {
              Expression RESULT = null;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string e = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
         Report.Error(900, e);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 223: // expr_without_variable ::= T_ARRAY BRACE_OPEN array_pair_list BRACE_CLOSE
            {
              Expression RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-3)).value;
        int aplleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int aplright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        ArrayList apl = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         RESULT = new ARRAY(apl, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 222: // expr_without_variable ::= scalar
            {
              Expression RESULT = null;
        int sleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int sright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression s = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = s;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 221: // expr_without_variable ::= AT expr
            {
              Expression RESULT = null;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string e = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         Report.Error(900, e);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 220: // expr_without_variable ::= T_EXIT exit_expr
            {
              Expression RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int eeleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eeright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression ee = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new EXIT(ee, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 219: // expr_without_variable ::= T_UNSET_CAST expr
            {
              Expression RESULT = null;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string e = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         Report.Error(900, e);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 218: // expr_without_variable ::= T_BOOL_CAST expr
            {
              Expression RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new BOOL_CAST(e, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 217: // expr_without_variable ::= T_OBJECT_CAST expr
            {
              Expression RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new OBJECT_CAST(e, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 216: // expr_without_variable ::= T_ARRAY_CAST expr
            {
              Expression RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new ARRAY_CAST(e, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 215: // expr_without_variable ::= T_STRING_CAST expr
            {
              Expression RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new STRING_CAST(e, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 214: // expr_without_variable ::= T_DOUBLE_CAST expr
            {
              Expression RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new DOUBLE_CAST(e, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 213: // expr_without_variable ::= T_INT_CAST expr
            {
              Expression RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new INT_CAST(e, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 212: // expr_without_variable ::= internal_functions_in_yacc
            {
              Expression RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 211: // expr_without_variable ::= expr QUESTION expr COLON expr
            {
              Expression RESULT = null;
        int e1left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left;
        int e1right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).right;
        Expression e1 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-4)).value;
        int e2left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int e2right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression e2 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int e3left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int e3right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e3 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new IF_EXPR(e1, e2, e3, e1left, e1right);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 210: // expr_without_variable ::= BRACE_OPEN expr BRACE_CLOSE
            {
              Expression RESULT = null;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         RESULT = e;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 209: // expr_without_variable ::= expr T_INSTANCEOF class_name_reference
            {
              Expression RESULT = null;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int cnrleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int cnrright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string cnr = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new INSTANCEOF(e, cnr, eleft, eright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 208: // expr_without_variable ::= expr T_IS_GREATER_OR_EQUAL expr
            {
              Expression RESULT = null;
        int e1left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int e1right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression e1 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int e2left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int e2right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e2 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new IS_GREATER_OR_EQUAL(e1, e2, e1left, e1right);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 207: // expr_without_variable ::= expr GREATER expr
            {
              Expression RESULT = null;
        int e1left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int e1right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression e1 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int e2left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int e2right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e2 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new GREATER(e1, e2, e1left, e1right);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 206: // expr_without_variable ::= expr T_IS_LOWER_OR_EQUAL expr
            {
              Expression RESULT = null;
        int e1left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int e1right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression e1 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int e2left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int e2right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e2 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new IS_LOWER_OR_EQUAL(e1, e2, e1left, e1right);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 205: // expr_without_variable ::= expr LOWER expr
            {
              Expression RESULT = null;
        int e1left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int e1right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression e1 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int e2left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int e2right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e2 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new LOWER(e1, e2, e1left, e1right);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 204: // expr_without_variable ::= expr T_IS_NOT_EQUAL expr
            {
              Expression RESULT = null;
        int e1left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int e1right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression e1 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int e2left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int e2right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e2 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new IS_NOT_EQUAL(e1, e2, e1left, e1right);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 203: // expr_without_variable ::= expr T_IS_EQUAL expr
            {
              Expression RESULT = null;
        int e1left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int e1right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression e1 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int e2left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int e2right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e2 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new IS_EQUAL(e1, e2, e1left, e1right);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 202: // expr_without_variable ::= expr T_IS_NOT_IDENTICAL expr
            {
              Expression RESULT = null;
        int e1left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int e1right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression e1 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int e2left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int e2right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e2 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new IS_NOT_IDENTICAL(e1, e2, e1left, e1right);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 201: // expr_without_variable ::= expr T_IS_IDENTICAL expr
            {
              Expression RESULT = null;
        int e1left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int e1right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression e1 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int e2left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int e2right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e2 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new IS_IDENTICAL(e1, e2, e1left, e1right);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 200: // expr_without_variable ::= NOT expr
            {
              Expression RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new NOT(e, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 199: // expr_without_variable ::= BOOLEAN_NOT expr
            {
              Expression RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new BOOLEAN_NOT(e, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 198: // expr_without_variable ::= MINUS expr
            {
              Expression RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new MINUS(new LNUMBER_SCALAR(0, tleft, tright), e, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 197: // expr_without_variable ::= PLUS expr
            {
              Expression RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new PLUS(new LNUMBER_SCALAR(0, tleft, tright), e, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 196: // expr_without_variable ::= expr T_SR expr
            {
              Expression RESULT = null;
        int e1left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int e1right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression e1 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int e2left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int e2right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e2 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new SR(e1, e2, e1left, e1right);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 195: // expr_without_variable ::= expr T_SL expr
            {
              Expression RESULT = null;
        int e1left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int e1right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression e1 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int e2left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int e2right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e2 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new SL(e1, e2, e1left, e1right);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 194: // expr_without_variable ::= expr MOD expr
            {
              Expression RESULT = null;
        int e1left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int e1right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression e1 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int e2left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int e2right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e2 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new MOD(e1, e2, e1left, e1right);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 193: // expr_without_variable ::= expr DIV expr
            {
              Expression RESULT = null;
        int e1left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int e1right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression e1 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int e2left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int e2right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e2 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new DIV(e1, e2, e1left, e1right);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 192: // expr_without_variable ::= expr TIMES expr
            {
              Expression RESULT = null;
        int e1left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int e1right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression e1 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int e2left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int e2right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e2 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new TIMES(e1, e2, e1left, e1right);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 191: // expr_without_variable ::= expr MINUS expr
            {
              Expression RESULT = null;
        int e1left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int e1right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression e1 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int e2left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int e2right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e2 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new MINUS(e1, e2, e1left, e1right);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 190: // expr_without_variable ::= expr PLUS expr
            {
              Expression RESULT = null;
        int e1left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int e1right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression e1 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int e2left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int e2right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e2 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new PLUS(e1, e2, e1left, e1right);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 189: // expr_without_variable ::= expr CONCAT expr
            {
              Expression RESULT = null;
        int e1left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int e1right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression e1 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int e2left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int e2right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e2 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new CONCAT(e1, e2, e1left, e1right);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 188: // expr_without_variable ::= expr XOR expr
            {
              Expression RESULT = null;
        int e1left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int e1right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression e1 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int e2left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int e2right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e2 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new XOR(e1, e2, e1left, e1right);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 187: // expr_without_variable ::= expr AND expr
            {
              Expression RESULT = null;
        int e1left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int e1right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression e1 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int e2left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int e2right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e2 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new AND(e1, e2, e1left, e1right);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 186: // expr_without_variable ::= expr OR expr
            {
              Expression RESULT = null;
        int e1left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int e1right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression e1 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int e2left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int e2right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e2 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new OR(e1, e2, e1left, e1right);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 185: // expr_without_variable ::= expr T_LOGICAL_XOR expr
            {
              Expression RESULT = null;
        int e1left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int e1right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression e1 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int e2left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int e2right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e2 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new LOGICAL_XOR(e1, e2, e1left, e1right);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 184: // expr_without_variable ::= expr T_LOGICAL_AND expr
            {
              Expression RESULT = null;
        int e1left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int e1right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression e1 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int e2left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int e2right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e2 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new LOGICAL_AND(e1, e2, e1left, e1right);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 183: // expr_without_variable ::= expr T_LOGICAL_OR expr
            {
              Expression RESULT = null;
        int e1left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int e1right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression e1 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int e2left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int e2right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e2 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new LOGICAL_OR(e1, e2, e1left, e1right);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 182: // expr_without_variable ::= expr T_BOOLEAN_AND expr
            {
              Expression RESULT = null;
        int e1left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int e1right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression e1 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int e2left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int e2right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e2 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new BOOLEAN_AND(e1, e2, e1left, e1right);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 181: // expr_without_variable ::= expr T_BOOLEAN_OR expr
            {
              Expression RESULT = null;
        int e1left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int e1right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression e1 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int e2left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int e2right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e2 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new BOOLEAN_OR(e1, e2, e1left, e1right);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 180: // expr_without_variable ::= T_DEC rw_variable
            {
              Expression RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int rwleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int rwright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression rw = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new DEC(rw, 0, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 179: // expr_without_variable ::= rw_variable T_DEC
            {
              Expression RESULT = null;
        int rwleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int rwright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        Expression rw = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         RESULT = new DEC(rw, 1, rwleft, rwright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 178: // expr_without_variable ::= T_INC rw_variable
            {
              Expression RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int rwleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int rwright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression rw = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new INC(rw, 0, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 177: // expr_without_variable ::= rw_variable T_INC
            {
              Expression RESULT = null;
        int rwleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int rwright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        Expression rw = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         RESULT = new INC(rw, 1, rwleft, rwright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 176: // expr_without_variable ::= variable T_SR_EQUAL expr
            {
              Expression RESULT = null;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression v = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new SR_EQUAL(v, e, vleft, vright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 175: // expr_without_variable ::= variable T_SL_EQUAL expr
            {
              Expression RESULT = null;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression v = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new SL_EQUAL(v, e, vleft, vright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 174: // expr_without_variable ::= variable T_XOR_EQUAL expr
            {
              Expression RESULT = null;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression v = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new XOR_EQUAL(v, e, vleft, vright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 173: // expr_without_variable ::= variable T_OR_EQUAL expr
            {
              Expression RESULT = null;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression v = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new OR_EQUAL(v, e, vleft, vright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 172: // expr_without_variable ::= variable T_AND_EQUAL expr
            {
              Expression RESULT = null;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression v = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new AND_EQUAL(v, e, vleft, vright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 171: // expr_without_variable ::= variable T_MOD_EQUAL expr
            {
              Expression RESULT = null;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression v = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new MOD_EQUAL(v, e, vleft, vright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 170: // expr_without_variable ::= variable T_CONCAT_EQUAL expr
            {
              Expression RESULT = null;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression v = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new CONCAT_EQUAL(v, e, vleft, vright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 169: // expr_without_variable ::= variable T_DIV_EQUAL expr
            {
              Expression RESULT = null;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression v = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new DIV_EQUAL(v, e, vleft, vright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 168: // expr_without_variable ::= variable T_MUL_EQUAL expr
            {
              Expression RESULT = null;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression v = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new MUL_EQUAL(v, e, vleft, vright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 167: // expr_without_variable ::= variable T_MINUS_EQUAL expr
            {
              Expression RESULT = null;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression v = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new MINUS_EQUAL(v, e, vleft, vright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 166: // expr_without_variable ::= variable T_PLUS_EQUAL expr
            {
              Expression RESULT = null;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression v = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new PLUS_EQUAL(v, e, vleft, vright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 165: // expr_without_variable ::= T_CLONE expr
            {
              Expression RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new CLONE(e, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 164: // expr_without_variable ::= T_NEW class_name_reference ctor_arguments
            {
              Expression RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int cnrleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int cnrright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string cnr = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int caleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int caright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        ExpressionList ca = (ExpressionList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new NEW(cnr, ca, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 163: // expr_without_variable ::= variable EQUALS AND T_NEW class_name_reference ctor_arguments
            {
              Expression RESULT = null;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-5)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-5)).right;
        Expression v = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-5)).value;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int cnrleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int cnrright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string cnr = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int caleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int caright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        ExpressionList ca = (ExpressionList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         Report.Warn(303); RESULT = new EQUALS(v, new NEW(cnr, ca, tleft, tright), vleft, vright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-5)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 162: // expr_without_variable ::= variable EQUALS AND variable
            {
              Expression RESULT = null;
        int v1left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left;
        int v1right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).right;
        Expression v1 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-3)).value;
        int v2left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int v2right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression v2 = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new EQUALS(v1, new REFERENCE(v2, v1left, v1right), v1left, v1right);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 161: // expr_without_variable ::= variable EQUALS expr
            {
              Expression RESULT = null;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression v = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new EQUALS(v, e, vleft, vright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 160: // expr_without_variable ::= T_LIST BRACE_OPEN assignment_list BRACE_CLOSE EQUALS expr
            {
              Expression RESULT = null;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-5)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-5)).right;
        string e = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-5)).value;
         Report.Error(900, e);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(22/*expr_without_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-5)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 159: // non_empty_for_expr ::= expr
            {
              ExpressionList RESULT = null;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         ExpressionList nefe = new ExpressionList(); nefe.Add(e); RESULT = nefe;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(59/*non_empty_for_expr*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 158: // non_empty_for_expr ::= non_empty_for_expr COMMA expr
            {
              ExpressionList RESULT = null;
        int nefeleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int neferight = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        ExpressionList nefe = (ExpressionList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         nefe.Add(e); RESULT = nefe;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(59/*non_empty_for_expr*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 157: // for_expr ::= non_empty_for_expr
            {
              ExpressionList RESULT = null;
        int nefeleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int neferight = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        ExpressionList nefe = (ExpressionList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = nefe;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(58/*for_expr*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 156: // for_expr ::=
            {
              ExpressionList RESULT = null;
         RESULT = new ExpressionList();
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(58/*for_expr*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 155: // echo_expr_list ::= expr
            {
              ExpressionList RESULT = null;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         ExpressionList eel = new ExpressionList(); eel.Add(e); RESULT = eel;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(57/*echo_expr_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 154: // echo_expr_list ::= echo_expr_list COMMA expr
            {
              ExpressionList RESULT = null;
        int eelleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int eelright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        ExpressionList eel = (ExpressionList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         eel.Add(e); RESULT = eel;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(57/*echo_expr_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 153: // class_constant_declaration ::= T_CONST T_STRING EQUALS static_scalar
            {
              Statement RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-3)).value;
        int sleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int sright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string s = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int ssleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int ssright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression ss = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         ArrayList modifiers = new ArrayList(); modifiers.Add(Modifiers.CONST); ArrayList names = new ArrayList(); names.Add(s); RESULT = new CLASS_VARIABLE_DECLARATION(modifiers, names, new ExpressionList(ss), tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(17/*class_constant_declaration*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 152: // class_constant_declaration ::= class_constant_declaration COMMA T_STRING EQUALS static_scalar
            {
              Statement RESULT = null;
        int ccdleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left;
        int ccdright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).right;
        Statement ccd = (Statement)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-4)).value;
        int sleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int sright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string s = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int ssleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int ssright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression ss = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         ((CLASS_VARIABLE_DECLARATION)ccd).names.Add(s); ((CLASS_VARIABLE_DECLARATION)ccd).values.Add(ss); RESULT = ccd;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(17/*class_constant_declaration*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 151: // class_variable_declaration ::= T_VARIABLE EQUALS static_scalar
            {
              Statement RESULT = null;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string v = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int ssleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int ssright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression ss = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         ArrayList names = new ArrayList(); names.Add(v); RESULT = new CLASS_VARIABLE_DECLARATION(new ArrayList(), names, new ExpressionList(ss), vleft, vright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(16/*class_variable_declaration*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 150: // class_variable_declaration ::= T_VARIABLE
            {
              Statement RESULT = null;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string v = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         ArrayList names = new ArrayList(); names.Add(v); RESULT = new CLASS_VARIABLE_DECLARATION(new ArrayList(), names, new ExpressionList(null), vleft, vright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(16/*class_variable_declaration*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 149: // class_variable_declaration ::= class_variable_declaration COMMA T_VARIABLE EQUALS static_scalar
            {
              Statement RESULT = null;
        int cvdleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left;
        int cvdright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).right;
        Statement cvd = (Statement)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-4)).value;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string v = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int ssleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int ssright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression ss = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         ((CLASS_VARIABLE_DECLARATION)cvd).names.Add(v); ((CLASS_VARIABLE_DECLARATION)cvd).values.Add(ss); RESULT = cvd;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(16/*class_variable_declaration*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 148: // class_variable_declaration ::= class_variable_declaration COMMA T_VARIABLE
            {
              Statement RESULT = null;
        int cvdleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int cvdright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Statement cvd = (Statement)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string v = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         ((CLASS_VARIABLE_DECLARATION)cvd).names.Add(v); ((CLASS_VARIABLE_DECLARATION)cvd).values.Add(null); RESULT = cvd;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(16/*class_variable_declaration*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 147: // member_modifier ::= T_FINAL
            {
              object RESULT = null;
         RESULT = PHP.Core.Modifiers.FINAL;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(84/*member_modifier*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 146: // member_modifier ::= T_ABSTRACT
            {
              object RESULT = null;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string e = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         Report.Error(900, e);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(84/*member_modifier*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 145: // member_modifier ::= T_STATIC
            {
              object RESULT = null;
         RESULT = PHP.Core.Modifiers.STATIC;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(84/*member_modifier*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 144: // member_modifier ::= T_PRIVATE
            {
              object RESULT = null;
         RESULT = PHP.Core.Modifiers.PRIVATE;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(84/*member_modifier*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 143: // member_modifier ::= T_PROTECTED
            {
              object RESULT = null;
         RESULT = PHP.Core.Modifiers.PROTECTED;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(84/*member_modifier*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 142: // member_modifier ::= T_PUBLIC
            {
              object RESULT = null;
         RESULT = PHP.Core.Modifiers.PUBLIC;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(84/*member_modifier*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 141: // non_empty_member_modifiers ::= non_empty_member_modifiers member_modifier
            {
              ArrayList RESULT = null;
        int nemmleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int nemmright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        ArrayList nemm = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int mmleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int mmright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        object mm = (object)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         nemm.Add(mm); RESULT = nemm;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(71/*non_empty_member_modifiers*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 140: // non_empty_member_modifiers ::= member_modifier
            {
              ArrayList RESULT = null;
        int mmleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int mmright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        object mm = (object)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         ArrayList nemm = new ArrayList(); nemm.Add(mm); RESULT = nemm;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(71/*non_empty_member_modifiers*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 139: // method_modifiers ::= non_empty_member_modifiers
            {
              ArrayList RESULT = null;
        int nemmleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int nemmright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        ArrayList nemm = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = nemm;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(70/*method_modifiers*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 138: // method_modifiers ::=
            {
              ArrayList RESULT = null;
         RESULT = new ArrayList();
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(70/*method_modifiers*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 137: // variable_modifiers ::= T_VAR
            {
              ArrayList RESULT = null;
         ArrayList vm = new ArrayList(); vm.Add(6); RESULT = vm;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(69/*variable_modifiers*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 136: // variable_modifiers ::= non_empty_member_modifiers
            {
              ArrayList RESULT = null;
        int nemmleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int nemmright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        ArrayList nemm = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = nemm;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(69/*variable_modifiers*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 135: // method_body ::= CURLY_BRACE_OPEN inner_statement_list CURLY_BRACE_CLOSE
            {
              StatementList RESULT = null;
        int istlleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int istlright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        StatementList istl = (StatementList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         RESULT = istl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(51/*method_body*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 134: // method_body ::= SEMICOLON
            {
              StatementList RESULT = null;
         RESULT = new StatementList();
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(51/*method_body*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 133: // class_statement ::= method_modifiers T_FUNCTION is_reference T_STRING BRACE_OPEN parameter_list BRACE_CLOSE method_body
            {
              Statement RESULT = null;
        int mmleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-7)).left;
        int mmright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-7)).right;
        ArrayList mm = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-7)).value;
        int irleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-5)).left;
        int irright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-5)).right;
        object ir = (object)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-5)).value;
        int sleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left;
        int sright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).right;
        string s = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-4)).value;
        int plleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int plright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        ArrayList pl = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int mbleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int mbright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        StatementList mb = (StatementList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new FUNCTION_DECLARATION(mm, (bool)ir, s, pl, mb, mmleft, mmright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(15/*class_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-7)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 132: // class_statement ::= class_constant_declaration SEMICOLON
            {
              Statement RESULT = null;
        int ccdleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int ccdright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        Statement ccd = (Statement)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         RESULT = ccd;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(15/*class_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 131: // class_statement ::= variable_modifiers class_variable_declaration SEMICOLON
            {
              Statement RESULT = null;
        int vmleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int vmright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        ArrayList vm = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int cvdleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int cvdright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        Statement cvd = (Statement)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         ((CLASS_VARIABLE_DECLARATION)cvd).modifiers = vm; RESULT = cvd;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(15/*class_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 130: // class_statement_list ::=
            {
              StatementList RESULT = null;
         RESULT = new StatementList();
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(50/*class_statement_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 129: // class_statement_list ::= class_statement_list class_statement
            {
              StatementList RESULT = null;
        int cstlleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int cstlright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        StatementList cstl = (StatementList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int cstleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int cstright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Statement cst = (Statement)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         cstl.Add(cst); RESULT = cstl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(50/*class_statement_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 128: // static_var_list ::= T_VARIABLE EQUALS static_scalar
            {
              ExpressionList RESULT = null;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string v = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int ssleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int ssright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression ss = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new ExpressionList(new EQUALS(new VARIABLE(v, vleft, vright), ss, vleft, vright));
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(56/*static_var_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 127: // static_var_list ::= T_VARIABLE
            {
              ExpressionList RESULT = null;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string v = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new ExpressionList(new VARIABLE(v, vleft, vright));
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(56/*static_var_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 126: // static_var_list ::= static_var_list COMMA T_VARIABLE EQUALS static_scalar
            {
              ExpressionList RESULT = null;
        int svlleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left;
        int svlright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).right;
        ExpressionList svl = (ExpressionList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-4)).value;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string v = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int ssleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int ssright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression ss = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         svl.Add(new EQUALS(new VARIABLE(v, vleft, vright), ss, vleft, vright)); RESULT = svl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(56/*static_var_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 125: // static_var_list ::= static_var_list COMMA T_VARIABLE
            {
              ExpressionList RESULT = null;
        int svlleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int svlright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        ExpressionList svl = (ExpressionList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string v = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         svl.Add(new VARIABLE(v, vleft, vright)); RESULT = svl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(56/*static_var_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 124: // global_var ::= DOLLAR CURLY_BRACE_OPEN expr CURLY_BRACE_CLOSE
            {
              Expression RESULT = null;
         Report.Error(900, "variable variables");
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(21/*global_var*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 123: // global_var ::= DOLLAR r_variable
            {
              Expression RESULT = null;
        int rvleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int rvright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression rv = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = (VARIABLE)rv;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(21/*global_var*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 122: // global_var ::= T_VARIABLE
            {
              Expression RESULT = null;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string v = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new VARIABLE(v, vleft, vright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(21/*global_var*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 121: // global_var_list ::= global_var
            {
              ExpressionList RESULT = null;
        int gvleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int gvright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression gv = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new ExpressionList(gv);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(55/*global_var_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 120: // global_var_list ::= global_var_list COMMA global_var
            {
              ExpressionList RESULT = null;
        int gvlleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int gvlright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        ExpressionList gvl = (ExpressionList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int gvleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int gvright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression gv = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         gvl.Add(gv); RESULT = gvl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(55/*global_var_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 119: // non_empty_function_call_parameter_list ::= non_empty_function_call_parameter_list COMMA AND w_variable
            {
              ExpressionList RESULT = null;
        int nefcplleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left;
        int nefcplright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).right;
        ExpressionList nefcpl = (ExpressionList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-3)).value;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int wvleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int wvright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression wv = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         nefcpl.Add(new REFERENCE(wv, tleft, tright)); RESULT = nefcpl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(54/*non_empty_function_call_parameter_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 118: // non_empty_function_call_parameter_list ::= non_empty_function_call_parameter_list COMMA variable
            {
              ExpressionList RESULT = null;
        int nefcplleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int nefcplright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        ExpressionList nefcpl = (ExpressionList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression v = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         nefcpl.Add(v); RESULT = nefcpl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(54/*non_empty_function_call_parameter_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 117: // non_empty_function_call_parameter_list ::= non_empty_function_call_parameter_list COMMA expr_without_variable
            {
              ExpressionList RESULT = null;
        int nefcplleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int nefcplright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        ExpressionList nefcpl = (ExpressionList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int ewvleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int ewvright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression ewv = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         nefcpl.Add(ewv); RESULT = nefcpl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(54/*non_empty_function_call_parameter_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 116: // non_empty_function_call_parameter_list ::= AND w_variable
            {
              ExpressionList RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int wvleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int wvright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression wv = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new ExpressionList(new REFERENCE(wv, tleft, tright));
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(54/*non_empty_function_call_parameter_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 115: // non_empty_function_call_parameter_list ::= variable
            {
              ExpressionList RESULT = null;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression v = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new ExpressionList(v);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(54/*non_empty_function_call_parameter_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 114: // non_empty_function_call_parameter_list ::= expr_without_variable
            {
              ExpressionList RESULT = null;
        int ewvleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int ewvright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression ewv = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new ExpressionList(ewv);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(54/*non_empty_function_call_parameter_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 113: // function_call_parameter_list ::=
            {
              ExpressionList RESULT = null;
         RESULT = new ExpressionList();
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(53/*function_call_parameter_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 112: // function_call_parameter_list ::= non_empty_function_call_parameter_list
            {
              ExpressionList RESULT = null;
        int nefcplleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int nefcplright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        ExpressionList nefcpl = (ExpressionList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = nefcpl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(53/*function_call_parameter_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 111: // optional_class_type ::= T_STRING
            {
              string RESULT = null;
        int sleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int sright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string s = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = s;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(78/*optional_class_type*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 110: // optional_class_type ::=
            {
              string RESULT = null;
         RESULT = null;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(78/*optional_class_type*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 109: // non_empty_parameter_list ::= non_empty_parameter_list COMMA optional_class_type T_VARIABLE EQUALS static_scalar
            {
              ArrayList RESULT = null;
        int neplleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-5)).left;
        int neplright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-5)).right;
        ArrayList nepl = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-5)).value;
        int octleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left;
        int octright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).right;
        string oct = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-3)).value;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string v = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int ssleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int ssright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression ss = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         nepl.Add(new PARAMETER_DECLARATION(oct, false, v, ss, octleft, octright)); RESULT = nepl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(68/*non_empty_parameter_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-5)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 108: // non_empty_parameter_list ::= non_empty_parameter_list COMMA optional_class_type AND T_VARIABLE EQUALS static_scalar
            {
              ArrayList RESULT = null;
        int neplleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-6)).left;
        int neplright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-6)).right;
        ArrayList nepl = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-6)).value;
        int octleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left;
        int octright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).right;
        string oct = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-4)).value;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string v = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int ssleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int ssright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression ss = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         nepl.Add(new PARAMETER_DECLARATION(oct, true, v, ss, octleft, octright)); RESULT = nepl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(68/*non_empty_parameter_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-6)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 107: // non_empty_parameter_list ::= non_empty_parameter_list COMMA optional_class_type AND T_VARIABLE
            {
              ArrayList RESULT = null;
        int neplleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left;
        int neplright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).right;
        ArrayList nepl = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-4)).value;
        int octleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int octright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string oct = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string v = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         nepl.Add(new PARAMETER_DECLARATION(oct, true, v, null, octleft, octright)); RESULT = nepl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(68/*non_empty_parameter_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 106: // non_empty_parameter_list ::= non_empty_parameter_list COMMA optional_class_type T_VARIABLE
            {
              ArrayList RESULT = null;
        int neplleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left;
        int neplright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).right;
        ArrayList nepl = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-3)).value;
        int octleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int octright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string oct = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string v = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         nepl.Add(new PARAMETER_DECLARATION(oct, false, v, null, octleft, octright)); RESULT = nepl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(68/*non_empty_parameter_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 105: // non_empty_parameter_list ::= optional_class_type T_VARIABLE EQUALS static_scalar
            {
              ArrayList RESULT = null;
        int octleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left;
        int octright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).right;
        string oct = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-3)).value;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string v = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int ssleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int ssright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression ss = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         ArrayList nepl = new ArrayList(); nepl.Add(new PARAMETER_DECLARATION(oct, false, v, ss, octleft, octright)); RESULT = nepl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(68/*non_empty_parameter_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 104: // non_empty_parameter_list ::= optional_class_type AND T_VARIABLE EQUALS static_scalar
            {
              ArrayList RESULT = null;
        int octleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left;
        int octright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).right;
        string oct = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-4)).value;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string v = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int ssleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int ssright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression ss = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         ArrayList nepl = new ArrayList(); nepl.Add(new PARAMETER_DECLARATION(oct, true, v, ss, octleft, octright)); RESULT = nepl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(68/*non_empty_parameter_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 103: // non_empty_parameter_list ::= optional_class_type AND T_VARIABLE
            {
              ArrayList RESULT = null;
        int octleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int octright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string oct = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string v = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         ArrayList nepl = new ArrayList(); nepl.Add(new PARAMETER_DECLARATION(oct, true, v, null, octleft, octright)); RESULT = nepl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(68/*non_empty_parameter_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 102: // non_empty_parameter_list ::= optional_class_type T_VARIABLE
            {
              ArrayList RESULT = null;
        int octleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int octright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string oct = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string v = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         ArrayList nepl = new ArrayList(); nepl.Add(new PARAMETER_DECLARATION(oct, false, v, null, octleft, octright)); RESULT = nepl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(68/*non_empty_parameter_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 101: // parameter_list ::=
            {
              ArrayList RESULT = null;
         RESULT = new ArrayList();
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(67/*parameter_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 100: // parameter_list ::= non_empty_parameter_list
            {
              ArrayList RESULT = null;
        int neplleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int neplright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        ArrayList nepl = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = nepl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(67/*parameter_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 99: // new_else_single ::= T_ELSE COLON inner_statement_list
            {
              Statement RESULT = null;
        int istlleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int istlright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        StatementList istl = (StatementList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = istl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(14/*new_else_single*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 98: // new_else_single ::=
            {
              Statement RESULT = null;
         RESULT = null;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(14/*new_else_single*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 97: // else_single ::= T_ELSE statement
            {
              Statement RESULT = null;
        int stleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int stright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Statement st = (Statement)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = st;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(13/*else_single*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 96: // else_single ::=
            {
              Statement RESULT = null;
         RESULT = null;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(13/*else_single*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 95: // new_elseif_list ::= new_elseif_list T_ELSEIF BRACE_OPEN expr BRACE_CLOSE COLON inner_statement_list
            {
              ArrayList RESULT = null;
        int nelleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-6)).left;
        int nelright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-6)).right;
        ArrayList nel = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-6)).value;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-5)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-5)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-5)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-3)).value;
        int istlleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int istlright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        StatementList istl = (StatementList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         nel.Add(new ELSEIF(e, istl, tleft, tright)); RESULT = nel;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(66/*new_elseif_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-6)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 94: // new_elseif_list ::=
            {
              ArrayList RESULT = null;
         RESULT = new ArrayList();
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(66/*new_elseif_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 93: // elseif_list ::= elseif_list T_ELSEIF BRACE_OPEN expr BRACE_CLOSE statement
            {
              ArrayList RESULT = null;
        int elleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-5)).left;
        int elright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-5)).right;
        ArrayList el = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-5)).value;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-4)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int stleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int stright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Statement st = (Statement)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         el.Add(new ELSEIF(e, st, tleft, tright)); RESULT = el;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(65/*elseif_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-5)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 92: // elseif_list ::=
            {
              ArrayList RESULT = null;
         RESULT = new ArrayList();
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(65/*elseif_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 91: // while_statement ::= COLON inner_statement_list T_ENDWHILE SEMICOLON
            {
              Statement RESULT = null;
        int istlleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int istlright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        StatementList istl = (StatementList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
         RESULT = istl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(12/*while_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 90: // while_statement ::= statement
            {
              Statement RESULT = null;
        int sleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int sright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Statement s = (Statement)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = s;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(12/*while_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 89: // case_separator ::= SEMICOLON
            {
              object RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(83/*case_separator*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 88: // case_separator ::= COLON
            {
              object RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(83/*case_separator*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 87: // case_list ::= case_list T_DEFAULT case_separator inner_statement_list
            {
              ArrayList RESULT = null;
        int clleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left;
        int clright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).right;
        ArrayList cl = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-3)).value;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int csleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int csright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        object cs = (object)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int istlleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int istlright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        StatementList istl = (StatementList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         cl.Add(new DEFAULT(istl, tleft, tright)); RESULT = cl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(64/*case_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 86: // case_list ::= case_list T_CASE expr case_separator inner_statement_list
            {
              ArrayList RESULT = null;
        int clleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left;
        int clright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).right;
        ArrayList cl = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-4)).value;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-3)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int csleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int csright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        object cs = (object)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int istlleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int istlright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        StatementList istl = (StatementList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         cl.Add(new CASE(e, istl, tleft, tright)); RESULT = cl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(64/*case_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 85: // case_list ::=
            {
              ArrayList RESULT = null;
         RESULT = new ArrayList();
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(64/*case_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 84: // switch_case_list ::= COLON SEMICOLON case_list T_ENDSWITCH SEMICOLON
            {
              ArrayList RESULT = null;
        int csleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int csright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        ArrayList cs = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
         RESULT = cs;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(63/*switch_case_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 83: // switch_case_list ::= COLON case_list T_ENDSWITCH SEMICOLON
            {
              ArrayList RESULT = null;
        int csleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int csright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        ArrayList cs = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
         RESULT = cs;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(63/*switch_case_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 82: // switch_case_list ::= CURLY_BRACE_OPEN SEMICOLON case_list CURLY_BRACE_CLOSE
            {
              ArrayList RESULT = null;
        int csleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int csright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        ArrayList cs = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         RESULT = cs;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(63/*switch_case_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 81: // switch_case_list ::= CURLY_BRACE_OPEN case_list CURLY_BRACE_CLOSE
            {
              ArrayList RESULT = null;
        int csleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int csright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        ArrayList cs = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         RESULT = cs;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(63/*switch_case_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 80: // declare_list ::= declare_list COMMA T_STRING EQUALS static_scalar
            {
              object RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(95/*declare_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 79: // declare_list ::= T_STRING EQUALS static_scalar
            {
              object RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(95/*declare_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 78: // declare_statement ::= COLON inner_statement_list T_ENDDECLARE SEMICOLON
            {
              object RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(94/*declare_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 77: // declare_statement ::= statement
            {
              object RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(94/*declare_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 76: // foreach_statement ::= COLON inner_statement_list T_ENDFOREACH SEMICOLON
            {
              Statement RESULT = null;
        int istlleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int istlright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        StatementList istl = (StatementList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
         RESULT = istl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(11/*foreach_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 75: // foreach_statement ::= statement
            {
              Statement RESULT = null;
        int stleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int stright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Statement st = (Statement)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = st;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(11/*foreach_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 74: // for_statement ::= COLON inner_statement_list T_ENDFOR SEMICOLON
            {
              Statement RESULT = null;
        int istlleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int istlright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        StatementList istl = (StatementList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
         RESULT = istl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(10/*for_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 73: // for_statement ::= statement
            {
              Statement RESULT = null;
        int stleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int stright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Statement st = (Statement)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = st;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(10/*for_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 72: // foreach_variable ::= AND w_variable
            {
              Expression RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int wvleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int wvright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression wv = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new REFERENCE(wv, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(20/*foreach_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 71: // foreach_variable ::= w_variable
            {
              Expression RESULT = null;
        int wvleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int wvright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression wv = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = wv;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(20/*foreach_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 70: // foreach_optional_arg ::= T_DOUBLE_ARROW foreach_variable
            {
              Expression RESULT = null;
        int fvleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int fvright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression fv = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = fv;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(19/*foreach_optional_arg*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 69: // foreach_optional_arg ::=
            {
              Expression RESULT = null;
         RESULT = null;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(19/*foreach_optional_arg*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 68: // interface_list ::= interface_list COMMA fully_qualified_class_name
            {
              object RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(93/*interface_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 67: // interface_list ::= fully_qualified_class_name
            {
              object RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(93/*interface_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 66: // implements_list ::= T_IMPLEMENTS interface_list
            {
              object RESULT = null;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string e = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         Report.Error(900, e);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(92/*implements_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 65: // implements_list ::=
            {
              object RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(92/*implements_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 64: // interface_extends_list ::= T_EXTENDS interface_list
            {
              object RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(91/*interface_extends_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 63: // interface_extends_list ::=
            {
              object RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(91/*interface_extends_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 62: // interface_entry ::= T_INTERFACE
            {
              object RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(90/*interface_entry*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 61: // extends_from ::= T_EXTENDS fully_qualified_class_name
            {
              string RESULT = null;
        int fqcnleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int fqcnright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        string fqcn = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = fqcn;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(77/*extends_from*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 60: // extends_from ::=
            {
              string RESULT = null;
         RESULT = null;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(77/*extends_from*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 59: // class_entry_type ::= T_FINAL T_CLASS
            {
              object RESULT = null;
         RESULT = PHP.Core.Modifiers.FINAL;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(82/*class_entry_type*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 58: // class_entry_type ::= T_ABSTRACT T_CLASS
            {
              object RESULT = null;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string e = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         Report.Error(900, e);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(82/*class_entry_type*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 57: // class_entry_type ::= T_CLASS
            {
              object RESULT = null;
         RESULT = PHP.Core.Modifiers.PUBLIC;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(82/*class_entry_type*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 56: // unticked_class_declaration_statement ::= interface_entry T_STRING interface_extends_list CURLY_BRACE_OPEN class_statement_list CURLY_BRACE_CLOSE
            {
              Statement RESULT = null;
         Report.Error(900, "interface");
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(9/*unticked_class_declaration_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-5)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 55: // unticked_class_declaration_statement ::= class_entry_type T_STRING extends_from implements_list CURLY_BRACE_OPEN class_statement_list CURLY_BRACE_CLOSE
            {
              Statement RESULT = null;
        int cetleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-6)).left;
        int cetright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-6)).right;
        object cet = (object)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-6)).value;
        int sleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-5)).left;
        int sright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-5)).right;
        string s = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-5)).value;
        int efleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left;
        int efright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).right;
        string ef = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-4)).value;
        int cstlleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int cstlright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        StatementList cstl = (StatementList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         RESULT = new CLASS_DECLARATION((int)cet, s, ef, cstl, cetleft, cetright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(9/*unticked_class_declaration_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-6)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 54: // unticked_function_declaration_statement ::= T_FUNCTION is_reference T_STRING BRACE_OPEN parameter_list BRACE_CLOSE CURLY_BRACE_OPEN inner_statement_list CURLY_BRACE_CLOSE
            {
              Statement RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-8)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-8)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-8)).value;
        int irleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-7)).left;
        int irright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-7)).right;
        object ir = (object)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-7)).value;
        int sleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-6)).left;
        int sright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-6)).right;
        string s = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-6)).value;
        int plleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left;
        int plright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).right;
        ArrayList pl = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-4)).value;
        int istlleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int istlright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        StatementList istl = (StatementList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         RESULT = new FUNCTION_DECLARATION(new ArrayList(), (bool)ir, s, pl, istl, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(8/*unticked_function_declaration_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-8)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 53: // is_reference ::= AND
            {
              object RESULT = null;
         RESULT = true;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(81/*is_reference*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 52: // is_reference ::=
            {
              object RESULT = null;
         RESULT = false;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(81/*is_reference*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 51: // class_declaration_statement ::= unticked_class_declaration_statement
            {
              Statement RESULT = null;
        int ucdsleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int ucdsright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Statement ucds = (Statement)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = ucds;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(7/*class_declaration_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 50: // function_declaration_statement ::= unticked_function_declaration_statement
            {
              Statement RESULT = null;
        int ufdsleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int ufdsright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Statement ufds = (Statement)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = ufds;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(6/*function_declaration_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 49: // use_filename ::= BRACE_OPEN T_CONSTANT_ENCAPSED_STRING BRACE_CLOSE
            {
              object RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(89/*use_filename*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 48: // use_filename ::= T_CONSTANT_ENCAPSED_STRING
            {
              object RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(89/*use_filename*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 47: // unset_variable ::= variable
            {
              Expression RESULT = null;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression v = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = v;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(18/*unset_variable*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 46: // unset_variables ::= unset_variables COMMA unset_variable
            {
              ExpressionList RESULT = null;
        int uvsleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int uvsright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        ExpressionList uvs = (ExpressionList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int uvleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int uvright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression uv = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         uvs.Add(uv); RESULT = uvs;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(52/*unset_variables*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 45: // unset_variables ::= unset_variable
            {
              ExpressionList RESULT = null;
        int uvleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int uvright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Expression uv = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new ExpressionList(uv);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(52/*unset_variables*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 44: // additional_catch ::= T_CATCH BRACE_OPEN fully_qualified_class_name T_VARIABLE BRACE_CLOSE CURLY_BRACE_OPEN inner_statement_list CURLY_BRACE_CLOSE
            {
              object RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(88/*additional_catch*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-7)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 43: // non_empty_additional_catches ::= non_empty_additional_catches additional_catch
            {
              object RESULT = null;
        int neacleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int neacright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        object neac = (object)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(87/*non_empty_additional_catches*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 42: // non_empty_additional_catches ::= additional_catch
            {
              object RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(87/*non_empty_additional_catches*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 41: // additional_catches ::=
            {
              object RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(86/*additional_catches*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 40: // additional_catches ::= non_empty_additional_catches
            {
              object RESULT = null;

              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(86/*additional_catches*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 39: // unticked_statement ::= T_THROW expr SEMICOLON
            {
              Statement RESULT = null;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string e = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
         Report.Error(900, e);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(5/*unticked_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 38: // unticked_statement ::= T_TRY CURLY_BRACE_OPEN inner_statement_list CURLY_BRACE_CLOSE T_CATCH BRACE_OPEN fully_qualified_class_name T_VARIABLE BRACE_CLOSE CURLY_BRACE_OPEN inner_statement_list CURLY_BRACE_CLOSE additional_catches
            {
              Statement RESULT = null;
         Report.Error(900, "try/catch");
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(5/*unticked_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-12)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 37: // unticked_statement ::= SEMICOLON
            {
              Statement RESULT = null;
         RESULT = null;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(5/*unticked_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 36: // unticked_statement ::= T_DECLARE BRACE_OPEN declare_list BRACE_CLOSE declare_statement
            {
              Statement RESULT = null;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).right;
        string e = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-4)).value;
         Report.Error(900, e);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(5/*unticked_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 35: // unticked_statement ::= T_FOREACH BRACE_OPEN expr_without_variable T_AS w_variable foreach_optional_arg BRACE_CLOSE foreach_statement
            {
              Statement RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-7)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-7)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-7)).value;
        int ewvleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-5)).left;
        int ewvright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-5)).right;
        Expression ewv = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-5)).value;
        int wvleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left;
        int wvright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).right;
        Expression wv = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-3)).value;
        int foaleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int foaright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression foa = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int fstleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int fstright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Statement fst = (Statement)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         Expression array = ewv; Expression key = (foa == null) ? null : wv; Expression value = (foa == null) ? wv : foa; RESULT = new FOREACH(array, key, value, fst, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(5/*unticked_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-7)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 34: // unticked_statement ::= T_FOREACH BRACE_OPEN variable T_AS foreach_variable foreach_optional_arg BRACE_CLOSE foreach_statement
            {
              Statement RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-7)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-7)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-7)).value;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-5)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-5)).right;
        Expression v = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-5)).value;
        int fvleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left;
        int fvright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).right;
        Expression fv = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-3)).value;
        int foaleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int foaright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression foa = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int fstleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int fstright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Statement fst = (Statement)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         Expression array = v; Expression key = (foa == null) ? null : fv; Expression value = (foa == null) ? fv : foa; RESULT = new FOREACH(array, key, value, fst, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(5/*unticked_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-7)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 33: // unticked_statement ::= T_UNSET BRACE_OPEN unset_variables BRACE_CLOSE SEMICOLON
            {
              Statement RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-4)).value;
        int uvsleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int uvsright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        ExpressionList uvs = (ExpressionList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
         RESULT = new UNSET(uvs, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(5/*unticked_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 32: // unticked_statement ::= T_USE use_filename SEMICOLON
            {
              Statement RESULT = null;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string e = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
         Report.Error(900, e);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(5/*unticked_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 31: // unticked_statement ::= expr SEMICOLON
            {
              Statement RESULT = null;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         RESULT = new EXPRESSION_AS_STATEMENT(e, eleft, eright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(5/*unticked_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 30: // unticked_statement ::= T_INLINE_HTML
            {
              Statement RESULT = null;
         /* This case will never be entered as HTML code is filtered by the parser */
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(5/*unticked_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 29: // unticked_statement ::= T_ECHO echo_expr_list SEMICOLON
            {
              Statement RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int eelleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int eelright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        ExpressionList eel = (ExpressionList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         RESULT = new ECHO(eel, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(5/*unticked_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 28: // unticked_statement ::= T_STATIC static_var_list SEMICOLON
            {
              Statement RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int svlleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int svlright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        ExpressionList svl = (ExpressionList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         RESULT = new STATIC_DECLARATION((ExpressionList)svl, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(5/*unticked_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 27: // unticked_statement ::= T_GLOBAL global_var_list SEMICOLON
            {
              Statement RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int gvlleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int gvlright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        ExpressionList gvl = (ExpressionList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         RESULT = new GLOBAL(gvl, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(5/*unticked_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 26: // unticked_statement ::= T_RETURN variable SEMICOLON
            {
              Statement RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        Expression v = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         RESULT = new RETURN(v, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(5/*unticked_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 25: // unticked_statement ::= T_RETURN expr_without_variable SEMICOLON
            {
              Statement RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int ewvleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int ewvright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        Expression ewv = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         RESULT = new RETURN(ewv, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(5/*unticked_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 24: // unticked_statement ::= T_RETURN SEMICOLON
            {
              Statement RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         RESULT = new RETURN(null, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(5/*unticked_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 23: // unticked_statement ::= T_CONTINUE expr SEMICOLON
            {
              Statement RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         RESULT = new CONTINUE(e, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(5/*unticked_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 22: // unticked_statement ::= T_CONTINUE SEMICOLON
            {
              Statement RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         RESULT = new CONTINUE(null, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(5/*unticked_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 21: // unticked_statement ::= T_BREAK expr SEMICOLON
            {
              Statement RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         RESULT = new BREAK(e, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(5/*unticked_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 20: // unticked_statement ::= T_BREAK SEMICOLON
            {
              Statement RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         RESULT = new BREAK(null, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(5/*unticked_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 19: // unticked_statement ::= T_SWITCH BRACE_OPEN expr BRACE_CLOSE switch_case_list
            {
              Statement RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-4)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int sclleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int sclright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        ArrayList scl = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new SWITCH(e, scl, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(5/*unticked_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 18: // unticked_statement ::= T_FOR BRACE_OPEN for_expr SEMICOLON for_expr SEMICOLON for_expr BRACE_CLOSE for_statement
            {
              Statement RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-8)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-8)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-8)).value;
        int fe1left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-6)).left;
        int fe1right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-6)).right;
        ExpressionList fe1 = (ExpressionList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-6)).value;
        int fe2left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left;
        int fe2right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).right;
        ExpressionList fe2 = (ExpressionList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-4)).value;
        int fe3left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int fe3right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        ExpressionList fe3 = (ExpressionList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int fsleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int fsright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Statement fs = (Statement)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new FOR(fe1, fe2, fe3, fs, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(5/*unticked_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-8)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 17: // unticked_statement ::= T_DO statement T_WHILE BRACE_OPEN expr BRACE_CLOSE
            {
              Statement RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-5)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-5)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-5)).value;
        int sleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left;
        int sright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).right;
        Statement s = (Statement)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-4)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         RESULT = new DO(s, e, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(5/*unticked_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-5)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 16: // unticked_statement ::= T_WHILE BRACE_OPEN expr BRACE_CLOSE while_statement
            {
              Statement RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-4)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int wstleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int wstright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Statement wst = (Statement)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new WHILE(e, wst, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(5/*unticked_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 15: // unticked_statement ::= T_IF BRACE_OPEN expr BRACE_CLOSE COLON inner_statement_list new_elseif_list new_else_single T_ENDIF SEMICOLON
            {
              Statement RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-9)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-9)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-9)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-7)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-7)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-7)).value;
        int istlleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left;
        int istlright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).right;
        StatementList istl = (StatementList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-4)).value;
        int nelleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).left;
        int nelright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-3)).right;
        ArrayList nel = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-3)).value;
        int nesleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int nesright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Statement nes = (Statement)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
         RESULT = new IF(e, istl, nel, nes, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(5/*unticked_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-9)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 14: // unticked_statement ::= T_IF BRACE_OPEN expr BRACE_CLOSE statement elseif_list else_single
            {
              Statement RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-6)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-6)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-6)).value;
        int eleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).left;
        int eright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-4)).right;
        Expression e = (Expression)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-4)).value;
        int stleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int stright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        Statement st = (Statement)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int elleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int elright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        ArrayList el = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int esleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int esright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Statement es = (Statement)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new IF(e, st, el, es, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(5/*unticked_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-6)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 13: // unticked_statement ::= CURLY_BRACE_OPEN inner_statement_list CURLY_BRACE_CLOSE
            {
              Statement RESULT = null;
        int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left;
        int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).right;
        string t = (string)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-2)).value;
        int istlleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int istlright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        StatementList istl = (StatementList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
         RESULT = new BLOCK(istl, tleft, tright);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(5/*unticked_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-2)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 12: // statement ::= unticked_statement
            {
              Statement RESULT = null;
        int usleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int usright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Statement us = (Statement)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = us;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(4/*statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 11: // inner_statement ::= class_declaration_statement
            {
              Statement RESULT = null;
        int cdsleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int cdsright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Statement cds = (Statement)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = cds;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(3/*inner_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 10: // inner_statement ::= function_declaration_statement
            {
              Statement RESULT = null;
        int fdsleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int fdsright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Statement fds = (Statement)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = fds;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(3/*inner_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 9: // inner_statement ::= statement
            {
              Statement RESULT = null;
        int sleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int sright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Statement s = (Statement)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = s;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(3/*inner_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 8: // inner_statement_list ::=
            {
              StatementList RESULT = null;
         RESULT = new StatementList();
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(49/*inner_statement_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 7: // inner_statement_list ::= inner_statement_list inner_statement
            {
              StatementList RESULT = null;
        int istlleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int istlright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        StatementList istl = (StatementList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int istleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int istright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Statement ist = (Statement)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         istl.Add(ist); RESULT = istl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(49/*inner_statement_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 6: // top_statement ::= class_declaration_statement
            {
              Statement RESULT = null;
        int cdsleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int cdsright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Statement cds = (Statement)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = cds;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(2/*top_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 5: // top_statement ::= function_declaration_statement
            {
              Statement RESULT = null;
        int fdsleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int fdsright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Statement fds = (Statement)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = fds;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(2/*top_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 4: // top_statement ::= statement
            {
              Statement RESULT = null;
        int sleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int sright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Statement s = (Statement)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = s;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(2/*top_statement*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 3: // top_statement_list ::=
            {
              StatementList RESULT = null;
         RESULT = new StatementList();
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(48/*top_statement_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 2: // top_statement_list ::= top_statement_list top_statement
            {
              StatementList RESULT = null;
        int tslleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int tslright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        StatementList tsl = (StatementList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        int tsleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int tsright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        Statement ts = (Statement)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         tsl.Add(ts); RESULT = tsl;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(48/*top_statement_list*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 1: // $START ::= begin EOF
            {
              object RESULT = null;
        int start_valleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left;
        int start_valright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).right;
        AST start_val = (AST)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-1)).value;
        RESULT = start_val;
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(0/*$START*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-1)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          /* ACCEPT */
          CUP_Parser_parser.done_parsing();
          return CUP_Parser_result;

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 0: // begin ::= top_statement_list
            {
              AST RESULT = null;
        int tslleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left;
        int tslright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right;
        StatementList tsl = (StatementList)((TUVienna.CS_CUP.Runtime.Symbol) CUP_Parser_stack.elementAt(CUP_Parser_top-0)).value;
         RESULT = new AST(tsl);
              CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(1/*begin*/, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).left, ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top-0)).right, RESULT);
            }
          return CUP_Parser_result;

          /* . . . . . .*/
          default:
            throw new System.Exception(
               "Invalid action number found in internal parse table");

        }
    }