Beispiel #1
0
		protected void Visit(ASTNode node) {
			if (node == null)
				return;
			else if (node is INTERFACE_DECLARATION) {
				ID = (INTERFACE_DECLARATION)node;
				// process each statement of interface
				foreach (Statement stmt in ID.StmtList)
					Visit(stmt);
				// bake the interface
				ID.Typ = ID.TypBld.CreateType();
				ID = null;
			}
			else if (node is CLASS_DECLARATION) {
				CD = (CLASS_DECLARATION)node;
				// remember __main class
				if (CD.Name == "__MAIN")
					CD__MAIN = CD;
				// process each statement of class
				foreach (Statement stmt in CD.StmtList)
					Visit(stmt);
				// bake the class
				CD.Typ = CD.TypBld.CreateType();
				CD = null;
			}
			else if (node is FUNCTION_DECLARATION) {
				FD = (FUNCTION_DECLARATION)node;
				// if function is abstract or an interface function, do nothing
				if (FD.StmtList == null)
					return;
				// remember __main method
				if (FD.Name == "__MAIN")
					FD__MAIN = FD;
				// 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.Ldnull);
									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.Ldnull);
									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, SymbolTable.CLASS);
							tmpCD = (CLASS_DECLARATION)parentCDEntry.Node;
						}
					} while (tmpCD != null);

				}
				// store parameters passed as local variables
				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.DefaultValue != null) {
						Label skip = IlGen.DefineLabel();
						IlGen.Emit(OpCodes.Dup);
						IlGen.Emit(OpCodes.Brtrue, skip);
						IlGen.Emit(OpCodes.Pop);
						Visit(pd.DefaultValue);
						IlGen.MarkLabel(skip);
					}
					// check if class type hint is ok
					if (pd.Type != null) {
						IlGen.Emit(OpCodes.Dup);
						SymbolTableEntry cdEntry = SymbolTable.GetInstance().LookupGlobal(pd.Type, SymbolTable.CLASS);
						// type is defined in an referenced assembly
						if (cdEntry == null) {
							Type t = SymbolTable.GetInstance().GetExternalType(pd.Type);
							IlGen.Emit(OpCodes.Ldstr, t.AssemblyQualifiedName);
						}
						// type is defined in script
						else
							IlGen.Emit(OpCodes.Ldstr, pd.Type);
						IlGen.Emit(OpCodes.Ldc_I4, i + (staticFunction ? 1 : 2));
						IlGen.Emit(OpCodes.Call, PHPRuntimeCore.GetMethod("CheckTypeHint", new Type[] { typeof(object), typeof(string), typeof(int) }));
					}
					// store
					StoreToVariable(pd.Name);
				}
				// process statements
				if (FD.StmtList.Count() == 0)
					IlGen.Emit(OpCodes.Nop);
				else
					foreach (Statement stmt in FD.StmtList)
						Visit(stmt);
				IlGen = null;
				FD = null;
			}
			else if (node is GLOBAL) {
				GLOBAL g = (GLOBAL)node;
				foreach (VARIABLE var in g.VarList) {
					IlGen.Emit(OpCodes.Ldstr, var.Name);
					IlGen.Emit(OpCodes.Call, PHPReference.GetMethod("CreateReferenceToGlobal", new Type[] { typeof(object) }));
					IlGen.Emit(OpCodes.Ldstr, var.Name);
					IlGen.Emit(OpCodes.Call, PHPRuntimeCore.GetMethod("StoreToVariable", new Type[] { typeof(object), typeof(object) }));
				}
			}
			else if (node is STATIC_DECLARATION) {
				STATIC_DECLARATION sd = (STATIC_DECLARATION)node;
				foreach (Expression expr in sd.ExprList) {
					if (expr is VARIABLE) {
						IlGen.Emit(OpCodes.Ldnull);
						StoreToStaticVariable(((VARIABLE)expr).Name);
					}
					if (expr is EQUALS) {
						Visit(((EQUALS)expr).Expr2);
						StoreToStaticVariable(((VARIABLE)((EQUALS)expr).Expr1).Name);
					}
				}
			}
			else if (node is BLOCK) {
				BLOCK b = (BLOCK)node;
				foreach (Statement stmt in b.StmtList)
					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 TRY) {
				TRY t = (TRY)node;
				// begin try block
				IlGen.BeginExceptionBlock();
				// process statements of try block
				foreach (Statement stmt in t.StmtList)
					Visit(stmt);
				// process catch blocks
				foreach (CATCH c in t.Catches)
					Visit(c);
				// end last catch block
				IlGen.EndExceptionBlock();
			}
			else if (node is CATCH) {
				CATCH c = (CATCH)node;
				// retrieve type of exception to be caught
				Type t;
				SymbolTableEntry cdEntry = SymbolTable.GetInstance().LookupGlobal(c.Type, SymbolTable.CLASS);
				if (cdEntry == null)
					t = SymbolTable.GetInstance().GetExternalType(c.Type);
				else {
					CLASS_DECLARATION cd = (CLASS_DECLARATION)cdEntry.Node;
					t = cd.TypBld;
				}
				// end last block (which is try or catch) and start new catch block
				IlGen.BeginCatchBlock(t);
				// make the current exception available as variable under the desired name
				StoreToVariable(c.Variable);
				// process catch statements
				foreach (Statement stmt in c.StmtList)
					Visit(stmt);
			}
			else if (node is THROW) {
				THROW t = (THROW)node;
				// process throw expression
				Visit(t.Expr);
				// ensure thrown object is an exception
				IlGen.Emit(OpCodes.Call, PHPRuntimeConvert.GetMethod("ToException", new Type[] { typeof(object) }));
				IlGen.Emit(OpCodes.Throw);
			}
			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, PHPRuntimeConvert.GetMethod("ToBool", new Type[] { typeof(object) }));
				IlGen.Emit(OpCodes.Brfalse, nextCheck);
				Visit(i.Stmt);
				IlGen.Emit(OpCodes.Br, endIf);
				IlGen.MarkLabel(nextCheck);
				// process elseif statements
				foreach (ELSEIF e in i.ElseifList) {
					//Visit(e);
					ELSEIF ei = (ELSEIF)node;
					Label nextCheck2 = IlGen.DefineLabel();
					// process else statement
					Visit(ei.Expr);
					IlGen.Emit(OpCodes.Call, PHPRuntimeConvert.GetMethod("ToBool", new Type[] { typeof(object) }));
					IlGen.Emit(OpCodes.Brfalse, nextCheck2);
					Visit(ei.Stmt);
					IlGen.Emit(OpCodes.Br, endIf);
					IlGen.MarkLabel(nextCheck2);
				}
				// process else statement
				Visit(i.ElseStmt);
				// done
				IlGen.MarkLabel(endIf);
				endIf = IlGen.DefineLabel();
			}
			else if (node is WHILE) {
				WHILE w = (WHILE)node;
				Label enterLoop = IlGen.DefineLabel();
				Label exitLoop = IlGen.DefineLabel();
				EnterLoopLabels.Add(enterLoop);
				ExitLoopLabels.Add(exitLoop);
				IlGen.MarkLabel(enterLoop);
				Visit(w.Expr);
				IlGen.Emit(OpCodes.Call, PHPRuntimeConvert.GetMethod("ToBool", new Type[] { typeof(object) }));
				IlGen.Emit(OpCodes.Brfalse, exitLoop);
				Visit(w.Stmt);
				IlGen.Emit(OpCodes.Br, enterLoop);
				IlGen.MarkLabel(exitLoop);
				EnterLoopLabels.RemoveAt(EnterLoopLabels.Count - 1);
				ExitLoopLabels.RemoveAt(ExitLoopLabels.Count - 1);
			}
			else if (node is DO) {
				DO d = (DO)node;
				Label enterLoop = IlGen.DefineLabel();
				Label exitLoop = IlGen.DefineLabel();
				EnterLoopLabels.Add(enterLoop);
				ExitLoopLabels.Add(exitLoop);
				IlGen.MarkLabel(enterLoop);
				Visit(d.Stmt);
				Visit(d.Expr);
				IlGen.Emit(OpCodes.Call, PHPRuntimeConvert.GetMethod("ToBool", new Type[] { typeof(object) }));
				IlGen.Emit(OpCodes.Brfalse, exitLoop);
				IlGen.Emit(OpCodes.Br, enterLoop);
				IlGen.MarkLabel(exitLoop);
				EnterLoopLabels.RemoveAt(EnterLoopLabels.Count - 1);
				ExitLoopLabels.RemoveAt(ExitLoopLabels.Count - 1);
			}
			else if (node is FOR) {
				FOR f = (FOR)node;
				Label enterLoop = IlGen.DefineLabel();
				Label exitLoop = IlGen.DefineLabel();
				EnterLoopLabels.Add(enterLoop);
				ExitLoopLabels.Add(exitLoop);
				foreach (Expression expr in f.ExprList1) {
					Visit(expr);
					// pop to treat for expression(s) 1 as statement(s)
					IlGen.Emit(OpCodes.Pop);
				}
				IlGen.MarkLabel(enterLoop);
				IEnumerator ienum = f.ExprList2.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.ExprList2.Count() > 0) {
					IlGen.Emit(OpCodes.Call, PHPRuntimeConvert.GetMethod("ToBool", new Type[] { typeof(object) }));
					IlGen.Emit(OpCodes.Brfalse, exitLoop);
				}
				Visit(f.Stmt);
				foreach (Expression expr in f.ExprList3) {
					Visit(expr);
					// pop to treat for expression(s) 3 as statement(s)
					IlGen.Emit(OpCodes.Pop);
				}
				IlGen.Emit(OpCodes.Br, enterLoop);
				IlGen.MarkLabel(exitLoop);
				EnterLoopLabels.RemoveAt(EnterLoopLabels.Count - 1);
				ExitLoopLabels.RemoveAt(ExitLoopLabels.Count - 1);
			}
			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);
				Label enterLoop = IlGen.DefineLabel();
				Label exitLoop = IlGen.DefineLabel();
				EnterLoopLabels.Add(enterLoop);
				ExitLoopLabels.Add(exitLoop);
				Label warn = IlGen.DefineLabel();
				// push array reference
				Visit(f.Array);
				// if type is not array, throw exception
				IlGen.Emit(OpCodes.Dup);
				IlGen.Emit(OpCodes.Call, PHPRuntimeCore.GetMethod("EnsureArray", new Type[] { typeof(object) }));
				// if array is not referenced, clone to work on a copy
				if (!(f.Value is REFERENCE))
					IlGen.Emit(OpCodes.Call, PHPRuntimeOperators.GetMethod("Clone", new Type[] { typeof(object) }));
				// declare key and value variable
				string valueName;
				if (f.Value is VARIABLE)
					valueName = ((VARIABLE)f.Value).Name;
				else
					valueName = ((VARIABLE)((REFERENCE)f.Value).Expr).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.Callvirt, PHPArray.GetMethod("CurrentIsValid", Type.EmptyTypes));
				// 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[] { typeof(object), typeof(object) }));
				// 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);
				// pop array reference
				IlGen.MarkLabel(exitLoop);
				IlGen.Emit(OpCodes.Pop);
				EnterLoopLabels.RemoveAt(EnterLoopLabels.Count - 1);
				ExitLoopLabels.RemoveAt(ExitLoopLabels.Count - 1);
			}
			else if (node is SWITCH) {
				SWITCH s = (SWITCH)node;
				Label enterLoop = IlGen.DefineLabel();
				Label exitLoop = IlGen.DefineLabel();
				EnterLoopLabels.Add(enterLoop);
				ExitLoopLabels.Add(exitLoop);
				// push switch expression and enter loop
				Visit(s.Expr);
				IlGen.MarkLabel(enterLoop);
				// process case and default statements
				foreach (ASTNode node2 in s.SwitchCaseList) {
					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, PHPRuntimeCore.GetField("SwitchInProgress"));
				EnterLoopLabels.RemoveAt(EnterLoopLabels.Count - 1);
				ExitLoopLabels.RemoveAt(ExitLoopLabels.Count - 1);
			}
			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, PHPRuntimeCore.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, PHPRuntimeOperators.GetMethod("IsEqual", new Type[] { typeof(object), typeof(object) }));
				IlGen.Emit(OpCodes.Call, PHPRuntimeConvert.GetMethod("ToBool", new Type[] { typeof(object) }));
				IlGen.Emit(OpCodes.Brfalse, nextCase);
				// else start processing switch statements
				IlGen.Emit(OpCodes.Ldc_I4_1);
				IlGen.Emit(OpCodes.Stsfld, PHPRuntimeCore.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, PHPRuntimeCore.GetField("SwitchInProgress"));
				Visit(d.Stmt);
			}
			else if (node is BREAK) {
				BREAK b = (BREAK)node;
				// if no number of levels to jump was performed jump out of current loop
				if (b.Expr == null) {
					Label exitLoop = (Label)ExitLoopLabels[ExitLoopLabels.Count - 1];
					IlGen.Emit(OpCodes.Br, exitLoop);
				}
				// otherwise jump out the number of levels desired
				else {
					// create jump table for each level
					Label[] jumpTable = new Label[ExitLoopLabels.Count + 1];
					jumpTable[0] = (Label)ExitLoopLabels[ExitLoopLabels.Count - 1];
					for (int i = 1; i <= ExitLoopLabels.Count; i++)
						jumpTable[i] = (Label)ExitLoopLabels[ExitLoopLabels.Count - i];
					// retrieve number of levels desired
					Visit(b.Expr);
					IlGen.Emit(OpCodes.Call, PHPRuntimeConvert.GetMethod("ToInt", new Type[] { typeof(object) }));
					// if a negative number of levels is provided, replace by 0
					Label skipReplace = IlGen.DefineLabel();
					IlGen.Emit(OpCodes.Dup);
					IlGen.Emit(OpCodes.Ldc_I4_0);
					IlGen.Emit(OpCodes.Bgt, skipReplace);
					IlGen.Emit(OpCodes.Pop);
					IlGen.Emit(OpCodes.Ldc_I4_0);
					IlGen.MarkLabel(skipReplace);
					// jump to the label desired
					IlGen.Emit(OpCodes.Switch, jumpTable);
					// if no jump was performed an invalid jump was requested
					IlGen.Emit(OpCodes.Ldc_I4, 504);
					IlGen.Emit(OpCodes.Call, mPHPRuntime.GetType("PHP.Report").GetMethod("Error", new Type[] { typeof(int) }));
				}
			}
			else if (node is CONTINUE) {
				CONTINUE c = (CONTINUE)node;
				// if no number of levels to jump was performed jump out of current loop
				if (c.Expr == null) {
					Label enterLoop = (Label)EnterLoopLabels[EnterLoopLabels.Count - 1];
					IlGen.Emit(OpCodes.Br, enterLoop);
				}
				// otherwise jump out the number of levels desired
				else {
					// create jump table for each level
					Label[] jumpTable = new Label[EnterLoopLabels.Count + 1];
					jumpTable[0] = (Label)EnterLoopLabels[EnterLoopLabels.Count - 1];
					for (int i = 1; i <= EnterLoopLabels.Count; i++)
						jumpTable[i] = (Label)EnterLoopLabels[EnterLoopLabels.Count - i];
					// retrieve number of levels desired
					Visit(c.Expr);
					IlGen.Emit(OpCodes.Call, PHPRuntimeConvert.GetMethod("ToInt", new Type[] { typeof(object) }));
					// if a negative number of levels is provided, replace by 0
					Label skipReplace = IlGen.DefineLabel();
					IlGen.Emit(OpCodes.Dup);
					IlGen.Emit(OpCodes.Ldc_I4_0);
					IlGen.Emit(OpCodes.Bgt, skipReplace);
					IlGen.Emit(OpCodes.Pop);
					IlGen.Emit(OpCodes.Ldc_I4_0);
					IlGen.MarkLabel(skipReplace);
					// jump to the label desired
					IlGen.Emit(OpCodes.Switch, jumpTable);
					// if no jump was performed an invalid jump was requested
					IlGen.Emit(OpCodes.Ldc_I4, 504);
					IlGen.Emit(OpCodes.Call, mPHPRuntime.GetType("PHP.Report").GetMethod("Error", new Type[] { typeof(int) }));
				}
			}
			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.Ldnull);
					else {
						// ensure a reference is returned if one is required
						if (FD.ReturnByReference)
							Visit(new REFERENCE(r.Expr, r.Line, r.Column));
						// if no reference should be returned, dereference
						else {
							Visit(r.Expr);
							IlGen.Emit(OpCodes.Call, PHPRuntimeCore.GetMethod("DeReference", new Type[] { typeof(object) }));
						}
					}
				}
				IlGen.Emit(OpCodes.Ret);
			}
			else if (node is UNSET) {
				UNSET u = (UNSET)node;
				// unset variables
				for (int i = 0; i < u.VarList.Count(); i++) {
					if (u.VarList.Get(i) is FUNCTION_CALL)
						Report.Error(408, u.VarList.Get(i).Line, u.VarList.Get(i).Column);
					VARIABLE var = (VARIABLE)u.VarList.Get(i);
					// regular variable, so unset
					if (var.Offset == null) {
						IlGen.Emit(OpCodes.Ldstr, var.Name);
						IlGen.Emit(OpCodes.Call, PHPRuntimeCore.GetMethod("UnsetVariable", new Type[] { typeof(object) }));
					}
					// 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, PHPRuntimeConvert.GetMethod("ToArray", new Type[] { typeof(object) }));
						if (var.Offset.Value == null)
							IlGen.Emit(OpCodes.Ldnull);
						else
							Visit(var.Offset);
						IlGen.Emit(OpCodes.Callvirt, PHPArray.GetMethod("Remove", new Type[] { typeof(object) }));
					}
				}
			}
			else if (node is ECHO) {
				ECHO e = (ECHO)node;
				foreach (Expression e2 in e.ExprList) {
					Visit(e2);
					IlGen.Emit(OpCodes.Call, PHPRuntimeOperators.GetMethod("Echo", new Type[] { typeof(object) }));
				}
			}
			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, PHPRuntimeCore.GetMethod("Offset", new Type[] { typeof(object), typeof(object), typeof(int) }));
					}
				}
			}
			else if (node is REFERENCE) {
				REFERENCE r = (REFERENCE)node;
				// process enclosed variable
				if (r.Expr is VARIABLE) {
					VARIABLE var = (VARIABLE)r.Expr;
					// if there is no offset, just reference to that variable
					if (var.Offset == null) {
						IlGen.Emit(OpCodes.Ldstr, var.Name);
						IlGen.Emit(OpCodes.Call, PHPReference.GetMethod("CreateReferenceToLocal", new Type[] { typeof(object) }));
					}
					// 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.Brtrue, skip);
						IlGen.Emit(OpCodes.Newobj, PHPArray.GetConstructor(Type.EmptyTypes));
						StoreToVariable(var.Name);
						IlGen.MarkLabel(skip);
						LoadFromVariable(var.Name);
						// if no offset available, append new key with null value and reference to that key
						if (var.Offset.Value == null) {
							IlGen.Emit(OpCodes.Ldnull);
							IlGen.Emit(OpCodes.Call, PHPReference.GetMethod("CreateReference", new Type[] { typeof(object), typeof(object) }));
						}
						// otherwise reference to the key desired
						else {
							Visit(var.Offset);
							IlGen.Emit(OpCodes.Call, PHPReference.GetMethod("CreateReference", new Type[] { typeof(object), typeof(object) }));
						}
					}
				}
				// process enclosed function call
				else if (r.Expr is FUNCTION_CALL) {
					FUNCTION_CALL fc = (FUNCTION_CALL)r.Expr;
					// look in global scope as calls to instance or static methods in user defined classes are handled by object operator or paamayim nekudotayim
					SymbolTableEntry entry = CD__MAIN.Scope.Lookup(fc.FunctionName, SymbolTable.FUNCTION);
					FUNCTION_DECLARATION fd = (FUNCTION_DECLARATION)entry.Node;
					if (!fd.ReturnByReference)
						Report.Error(305, fd.Name, fc.Line, fc.Column);
					// get returned reference
					Visit(fc);
				}
				// process enclosed pyymayim nedudotayim
				else if (r.Expr is PAAMAYIM_NEKUDOTAYIM) {
					PAAMAYIM_NEKUDOTAYIM pn = (PAAMAYIM_NEKUDOTAYIM)r.Expr;
					LoadFromPaamayimNekudotayimAsReference(pn);
				}
				// process enclosed object operator
				else if (r.Expr is OBJECT_OPERATOR) {
					OBJECT_OPERATOR oo = (OBJECT_OPERATOR)r.Expr;
					LoadFromObjectOperatorAsReference(oo);
				}
				// other expressions cannot be referenced
				else
					Report.Error(306, r.Line, r.Column);
			}
			else if (node is CONSTANT) {
				CONSTANT c = (CONSTANT)node;
				// check if a null is desired
				if (c.Name.ToLower() == "null")
					IlGen.Emit(OpCodes.Ldnull);
				else {
					// check if a function pointer is desired
					SymbolTableEntry tmpFDEntry = SymbolTable.GetInstance().Lookup(c.Name, SymbolTable.FUNCTION);
					if (tmpFDEntry != null) {
						FUNCTION_DECLARATION tmpFD = (FUNCTION_DECLARATION)tmpFDEntry.Node;
						IlGen.Emit(OpCodes.Ldftn, tmpFD.MthBld);
						IlGen.Emit(OpCodes.Box, typeof(IntPtr));
					}
					// push constant value
					else {
						IlGen.Emit(OpCodes.Ldstr, c.Name);
						IlGen.Emit(OpCodes.Call, PHPRuntimeCore.GetMethod("GetConstant", new Type[] { typeof(object) }));
					}
				}
			}
			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;
				// check if a predefined function is invoked
				string functionName = fc.FunctionName.ToLower();
				if (predefinedFunctions.ContainsKey(functionName)) {
					int numberOfParameters = (int)predefinedFunctions[functionName];
					PushParameters(fc.Parameters, numberOfParameters);
					Type[] parameterTypes = new Type[numberOfParameters];
					for (int i = 0; i < numberOfParameters; i++)
						parameterTypes[i] = typeof(object);
					IlGen.Emit(OpCodes.Call, PHPRuntimeLang.GetMethod(functionName, parameterTypes));
				}
				// otherwise call user defined function
				else {
					// look in global scope as calls to instance or static methods in user defined classes are handled by object operator or paamayim nekudotayim
					SymbolTableEntry entry = CD__MAIN.Scope.Lookup(fc.FunctionName, SymbolTable.FUNCTION);
					if (entry == null)
						Report.Error(212, fc.FunctionName, 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);
						// ensure a reference is passed, if a reference is required
						if (pd.ByReference && !(expr is REFERENCE))
							expr = new REFERENCE(expr, expr.Line, expr.Column);
						// process parameter
						Visit(expr);
					}
					// if less parameters actually passed then necessary, pass null references instead
					for (int i = parametersPassedActually; i < fd.Parameters.Count; i++) {
						PARAMETER_DECLARATION pd = (PARAMETER_DECLARATION)fd.Parameters[i];
						if (pd.DefaultValue == null)
							Report.Warn(300, System.Convert.ToString(i + 1), fc.Line, fc.Column);
						IlGen.Emit(OpCodes.Ldnull);
					}
					// add function call to call trace
					IlGen.Emit(OpCodes.Ldstr, CD.Name + "->" + fc.FunctionName);
					IlGen.Emit(OpCodes.Call, PHPRuntimeCore.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, PHPRuntimeCore.GetMethod("RemoveFunctionCallFromTrace", Type.EmptyTypes));
				}
			}
			else if (node is NEW) {
				NEW n = (NEW)node;
				SymbolTableEntry cdEntry = SymbolTable.GetInstance().LookupGlobal(n.Type, SymbolTable.CLASS);
				// type is defined in an referenced assembly
				if (cdEntry == null) {
					Type t = SymbolTable.GetInstance().GetExternalType(n.Type);
					IlGen.Emit(OpCodes.Ldstr, t.AssemblyQualifiedName);
					IlGen.Emit(OpCodes.Newobj, typeof(ArrayList).GetConstructor(Type.EmptyTypes));
					foreach (Expression expr in n.CtorArgs) {
						IlGen.Emit(OpCodes.Dup);
						Visit(expr);
						IlGen.Emit(OpCodes.Call, typeof(ArrayList).GetMethod("Add", new Type[] { typeof(object) }));
						IlGen.Emit(OpCodes.Pop);
					}
					IlGen.Emit(OpCodes.Call, PHPRuntimeCore.GetMethod("InvokeExternalConstructor", new Type[] { typeof(string), typeof(ArrayList) }));
				}
				// type is defined in script
				else {
					CLASS_DECLARATION cd = (CLASS_DECLARATION)cdEntry.Node;
					// ensure no instance of an abstract class is created
					if (cd.Modifier == Modifiers.ABSTRACT)
						Report.Error(409, cd.Name, n.Line, n.Column);
					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.CtorArgs.Count());
					for (int i = 0; i < parametersPassedActually; i++) {
						PARAMETER_DECLARATION pd = (PARAMETER_DECLARATION)ctorDecl.Parameters[i];
						Expression expr = (Expression)n.CtorArgs.Get(i);
						// ensure a reference is passed, if a reference is required
						if (pd.ByReference && !(expr is REFERENCE))
							expr = new REFERENCE(expr, expr.Line, expr.Column);
						// process parameter
						Visit(expr);
					}
					// if less parameters actually passed then necessary, pass null references instead
					for (int i = parametersPassedActually; i < ctorDecl.Parameters.Count; i++) {
						PARAMETER_DECLARATION pd = (PARAMETER_DECLARATION)ctorDecl.Parameters[i];
						if (pd.DefaultValue == null)
							Report.Warn(300, System.Convert.ToString(i + 1), n.Line, n.Column);
						IlGen.Emit(OpCodes.Ldnull);
					}
					// add constructor call to call trace
					IlGen.Emit(OpCodes.Ldstr, n.Type + "->__construct");
					IlGen.Emit(OpCodes.Call, PHPRuntimeCore.GetMethod("AddFunctionCallToTrace", new Type[] { typeof(string) }));
					// call constructor
					IlGen.Emit(OpCodes.Newobj, ctorDecl.CtrBld);
					// remove constructor call from call trace
					IlGen.Emit(OpCodes.Call, PHPRuntimeCore.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, PHPRuntimeOperators.GetMethod("Instanceof", new Type[] { typeof(object), 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.ArrayPairList) {
					// 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
					Visit(ap.Value);
					IlGen.Emit(OpCodes.Callvirt, PHPArray.GetMethod("Append", new Type[] { typeof(object), typeof(object) }));
				}
			}
			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.Ldc_I4_1);
				IlGen.Emit(OpCodes.Box, typeof(int));
				IlGen.Emit(OpCodes.Call, PHPRuntimeOperators.GetMethod("Plus", new Type[] { typeof(object), typeof(object) }));
				if (i.Kind == 0)
					IlGen.Emit(OpCodes.Dup);
				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.Box, typeof(int));
				IlGen.Emit(OpCodes.Call, PHPRuntimeOperators.GetMethod("Minus", new Type[] { typeof(object), typeof(object) }));
				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, PHPRuntimeOperators.GetMethod("BooleanNot", new Type[] { typeof(object) }));
			}
			else if (node is NOT) {
				NOT n = (NOT)node;
				Visit(n.Expr);
				IlGen.Emit(OpCodes.Call, PHPRuntimeOperators.GetMethod("Not", new Type[] { typeof(object) }));
			}
			else if (node is EXIT) {
				EXIT e = (EXIT)node;
				if (e.Expr == null)
					IlGen.Emit(OpCodes.Ldnull);
				else
					Visit(e.Expr);
				IlGen.Emit(OpCodes.Call, PHPRuntimeOperators.GetMethod("Exit", new Type[] { typeof(object) }));
			}
			else if (node is PRINT) {
				PRINT p = (PRINT)node;
				Visit(p.Expr);
				IlGen.Emit(OpCodes.Call, PHPRuntimeOperators.GetMethod("Print", new Type[] { typeof(object) }));
			}
			else if (node is BOOL_CAST) {
				BOOL_CAST bc = (BOOL_CAST)node;
				Visit(bc.Expr);
				IlGen.Emit(OpCodes.Call, PHPRuntimeConvert.GetMethod("ToBool", new Type[] { typeof(object) }));
			}
			else if (node is INT_CAST) {
				INT_CAST ic = (INT_CAST)node;
				Visit(ic.Expr);
				IlGen.Emit(OpCodes.Call, PHPRuntimeConvert.GetMethod("ToInt", new Type[] { typeof(object) }));
			}
			else if (node is DOUBLE_CAST) {
				DOUBLE_CAST dc = (DOUBLE_CAST)node;
				Visit(dc.Expr);
				IlGen.Emit(OpCodes.Call, PHPRuntimeConvert.GetMethod("ToDouble", new Type[] { typeof(object) }));
			}
			else if (node is STRING_CAST) {
				STRING_CAST sc = (STRING_CAST)node;
				Visit(sc.Expr);
				IlGen.Emit(OpCodes.Call, PHPRuntimeConvert.GetMethod("ToString", new Type[] { typeof(object) }));
			}
			else if (node is ARRAY_CAST) {
				ARRAY_CAST ac = (ARRAY_CAST)node;
				Visit(ac.Expr);
				IlGen.Emit(OpCodes.Call, PHPRuntimeConvert.GetMethod("ToArray", new Type[] { typeof(object) }));
			}
			else if (node is OBJECT_CAST) {
				OBJECT_CAST oc = (OBJECT_CAST)node;
				Visit(oc.Expr);
				IlGen.Emit(OpCodes.Call, PHPRuntimeConvert.GetMethod("ToObject", new Type[] { typeof(object) }));
			}
			else if (node is CLONE) {
				CLONE c = (CLONE)node;
				Visit(c.Expr);
				IlGen.Emit(OpCodes.Call, PHPRuntimeOperators.GetMethod("Clone", new Type[] { typeof(object) }));
			}
			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);
				// if no reference is desired, dereference in case a reference is evaluated
				if (!(e.Expr2 is REFERENCE))
					IlGen.Emit(OpCodes.Call, PHPRuntimeCore.GetMethod("DeReference", new Type[] { typeof(object) }));
				// 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;
					// if there is no offset, just store to that variable
					if (var.Offset == null) {
						IlGen.Emit(OpCodes.Dup);
						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.Brtrue, 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, PHPRuntimeConvert.GetMethod("ToArray", new Type[] { typeof(object) }));
						// if no offset available, append without user defined key
						if (var.Offset.Value == null) {
							Visit(e.Expr2);
							IlGen.Emit(OpCodes.Callvirt, PHPArray.GetMethod("Append", new Type[] { typeof(object) }));
						}
						// otherwise use user defined key
						else {
							Visit(var.Offset.Value);
							Visit(e.Expr2);
							IlGen.Emit(OpCodes.Callvirt, PHPArray.GetMethod("Append", new Type[] { typeof(object), typeof(object) }));
						}
					}
				}
			}
			else if (node is PLUS_EQUAL) {
				PLUS_EQUAL pe = (PLUS_EQUAL)node;
				// treat as if it was an EQUALS node
				Visit(new EQUALS(pe.Expr1, new PLUS(pe.Expr1, pe.Expr2, pe.Line, pe.Column), pe.Line, pe.Column));
			}
			else if (node is MINUS_EQUAL) {
				MINUS_EQUAL me = (MINUS_EQUAL)node;
				// treat as if it was an EQUALS node
				Visit(new EQUALS(me.Expr1, new MINUS(me.Expr1, me.Expr2, me.Line, me.Column), me.Line, me.Column));
			}
			else if (node is MUL_EQUAL) {
				MUL_EQUAL me = (MUL_EQUAL)node;
				// treat as if it was an EQUALS node
				Visit(new EQUALS(me.Expr1, new TIMES(me.Expr1, me.Expr2, me.Line, me.Column), me.Line, me.Column));
			}
			else if (node is DIV_EQUAL) {
				DIV_EQUAL de = (DIV_EQUAL)node;
				// treat as if it was an EQUALS node
				Visit(new EQUALS(de.Expr1, new DIV(de.Expr1, de.Expr2, de.Line, de.Column), de.Line, de.Column));
			}
			else if (node is CONCAT_EQUAL) {
				CONCAT_EQUAL ce = (CONCAT_EQUAL)node;
				// treat as if it was an EQUALS node
				Visit(new EQUALS(ce.Expr1, new CONCAT(ce.Expr1, ce.Expr2, ce.Line, ce.Column), ce.Line, ce.Column));
			}
			else if (node is MOD_EQUAL) {
				MOD_EQUAL me = (MOD_EQUAL)node;
				// treat as if it was an EQUALS node
				Visit(new EQUALS(me.Expr1, new MOD(me.Expr1, me.Expr2, me.Line, me.Column), me.Line, me.Column));
			}
			else if (node is AND_EQUAL) {
				AND_EQUAL ae = (AND_EQUAL)node;
				// treat as if it was an EQUALS node
				Visit(new EQUALS(ae.Expr1, new AND(ae.Expr1, ae.Expr2, ae.Line, ae.Column), ae.Line, ae.Column));
			}
			else if (node is OR_EQUAL) {
				OR_EQUAL oe = (OR_EQUAL)node;
				// treat as if it was an EQUALS node
				Visit(new EQUALS(oe.Expr1, new OR(oe.Expr1, oe.Expr2, oe.Line, oe.Column), oe.Line, oe.Column));
			}
			else if (node is XOR_EQUAL) {
				XOR_EQUAL xe = (XOR_EQUAL)node;
				// treat as if it was an EQUALS node
				Visit(new EQUALS(xe.Expr1, new XOR(xe.Expr1, xe.Expr2, xe.Line, xe.Column), xe.Line, xe.Column));
			}
			else if (node is SL_EQUAL) {
				SL_EQUAL se = (SL_EQUAL)node;
				// treat as if it was an EQUALS node
				Visit(new EQUALS(se.Expr1, new SL(se.Expr1, se.Expr2, se.Line, se.Column), se.Line, se.Column));
			}
			else if (node is SR_EQUAL) {
				SR_EQUAL se = (SR_EQUAL)node;
				// treat as if it was an EQUALS node
				Visit(new EQUALS(se.Expr1, new SR(se.Expr1, se.Expr2, se.Line, se.Column), se.Line, se.Column));
			}
			else if (node is BOOLEAN_AND) {
				BOOLEAN_AND ba = (BOOLEAN_AND)node;
				Visit(ba.Expr1);
				Visit(ba.Expr2);
				IlGen.Emit(OpCodes.Call, PHPRuntimeOperators.GetMethod("BooleanAnd", new Type[] { typeof(object), typeof(object) }));
			}
			else if (node is BOOLEAN_OR) {
				BOOLEAN_OR bo = (BOOLEAN_OR)node;
				Visit(bo.Expr1);
				Visit(bo.Expr2);
				IlGen.Emit(OpCodes.Call, PHPRuntimeOperators.GetMethod("BooleanOr", new Type[] { typeof(object), typeof(object) }));
			}
			else if (node is LOGICAL_AND) {
				LOGICAL_AND la = (LOGICAL_AND)node;
				Visit(la.Expr1);
				Visit(la.Expr2);
				IlGen.Emit(OpCodes.Call, PHPRuntimeOperators.GetMethod("LogicalAnd", new Type[] { typeof(object), typeof(object) }));
			}
			else if (node is LOGICAL_OR) {
				LOGICAL_OR lo = (LOGICAL_OR)node;
				Visit(lo.Expr1);
				Visit(lo.Expr2);
				IlGen.Emit(OpCodes.Call, PHPRuntimeOperators.GetMethod("LogicalOr", new Type[] { typeof(object), typeof(object) }));
			}
			else if (node is LOGICAL_XOR) {
				LOGICAL_XOR lx = (LOGICAL_XOR)node;
				Visit(lx.Expr1);
				Visit(lx.Expr2);
				IlGen.Emit(OpCodes.Call, PHPRuntimeOperators.GetMethod("LogicalXor", new Type[] { typeof(object), typeof(object) }));
			}
			else if (node is CONCAT) {
				CONCAT c = (CONCAT)node;
				Visit(c.Expr1);
				Visit(c.Expr2);
				IlGen.Emit(OpCodes.Call, PHPRuntimeOperators.GetMethod("Concat", new Type[] { typeof(object), typeof(object) }));
			}
			else if (node is PLUS) {
				PLUS p = (PLUS)node;
				Visit(p.Expr1);
				Visit(p.Expr2);
				IlGen.Emit(OpCodes.Call, PHPRuntimeOperators.GetMethod("Plus", new Type[] { typeof(object), typeof(object) }));
			}
			else if (node is MINUS) {
				MINUS m = (MINUS)node;
				Visit(m.Expr1);
				Visit(m.Expr2);
				IlGen.Emit(OpCodes.Call, PHPRuntimeOperators.GetMethod("Minus", new Type[] { typeof(object), typeof(object) }));
			}
			else if (node is TIMES) {
				TIMES t = (TIMES)node;
				Visit(t.Expr1);
				Visit(t.Expr2);
				IlGen.Emit(OpCodes.Call, PHPRuntimeOperators.GetMethod("Times", new Type[] { typeof(object), typeof(object) }));
			}
			else if (node is DIV) {
				DIV d = (DIV)node;
				Visit(d.Expr1);
				Visit(d.Expr2);
				IlGen.Emit(OpCodes.Call, PHPRuntimeOperators.GetMethod("Div", new Type[] { typeof(object), typeof(object) }));
			}
			else if (node is MOD) {
				MOD m = (MOD)node;
				Visit(m.Expr1);
				Visit(m.Expr2);
				IlGen.Emit(OpCodes.Call, PHPRuntimeOperators.GetMethod("Mod", new Type[] { typeof(object), typeof(object) }));
			}
			else if (node is AND) {
				AND a = (AND)node;
				Visit(a.Expr1);
				Visit(a.Expr2);
				IlGen.Emit(OpCodes.Call, PHPRuntimeOperators.GetMethod("And", new Type[] { typeof(object), typeof(object) }));
			}
			else if (node is OR) {
				OR o = (OR)node;
				Visit(o.Expr1);
				Visit(o.Expr2);
				IlGen.Emit(OpCodes.Call, PHPRuntimeOperators.GetMethod("Or", new Type[] { typeof(object), typeof(object) }));
			}
			else if (node is XOR) {
				XOR x = (XOR)node;
				Visit(x.Expr1);
				Visit(x.Expr2);
				IlGen.Emit(OpCodes.Call, PHPRuntimeOperators.GetMethod("Xor", new Type[] { typeof(object), typeof(object) }));
			}
			else if (node is SL) {
				SL s = (SL)node;
				Visit(s.Expr1);
				Visit(s.Expr2);
				IlGen.Emit(OpCodes.Call, PHPRuntimeOperators.GetMethod("Sl", new Type[] { typeof(object), typeof(object) }));
			}
			else if (node is SR) {
				SL s = (SL)node;
				Visit(s.Expr1);
				Visit(s.Expr2);
				IlGen.Emit(OpCodes.Call, PHPRuntimeOperators.GetMethod("Sr", new Type[] { typeof(object), typeof(object) }));
			}
			else if (node is IS_EQUAL) {
				IS_EQUAL ie = (IS_EQUAL)node;
				Visit(ie.Expr1);
				Visit(ie.Expr2);
				IlGen.Emit(OpCodes.Call, PHPRuntimeOperators.GetMethod("IsEqual", new Type[] { typeof(object), typeof(object) }));
			}
			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, PHPRuntimeOperators.GetMethod("IsNotEqual", new Type[] { typeof(object), typeof(object) }));
			}
			else if (node is IS_IDENTICAL) {
				IS_IDENTICAL ii = (IS_IDENTICAL)node;
				Visit(ii.Expr1);
				Visit(ii.Expr2);
				IlGen.Emit(OpCodes.Call, PHPRuntimeOperators.GetMethod("IsIdentical", new Type[] { typeof(object), typeof(object) }));
			}
			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, PHPRuntimeOperators.GetMethod("IsNotIdentical", new Type[] { typeof(object), typeof(object) }));
			}
			else if (node is LOWER) {
				LOWER l = (LOWER)node;
				Visit(l.Expr1);
				Visit(l.Expr2);
				IlGen.Emit(OpCodes.Call, PHPRuntimeOperators.GetMethod("Lower", new Type[] { typeof(object), typeof(object) }));
			}
			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, PHPRuntimeOperators.GetMethod("IsLowerOrEqual", new Type[] { typeof(object), typeof(object) }));
			}
			else if (node is GREATER) {
				GREATER g = (GREATER)node;
				Visit(g.Expr1);
				Visit(g.Expr2);
				IlGen.Emit(OpCodes.Call, PHPRuntimeOperators.GetMethod("Greater", new Type[] { typeof(object), typeof(object) }));
			}
			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, PHPRuntimeOperators.GetMethod("IsGreaterOrEqual", new Type[] { typeof(object), typeof(object) }));
			}
			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, PHPRuntimeConvert.GetMethod("ToBool", new Type[] { typeof(object) }));
				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 MAGIC_CONSTANT) {
				MAGIC_CONSTANT mc = (MAGIC_CONSTANT)node;
				if (mc.Kind == MAGIC_CONSTANT.LINE) {
					IlGen.Emit(OpCodes.Ldc_I4, mc.Line);
					IlGen.Emit(OpCodes.Box, typeof(int));
				}
				else if (mc.Kind == MAGIC_CONSTANT.FILE)
					IlGen.Emit(OpCodes.Ldstr, PEmitter.OutputFile.FullName);
				else if (mc.Kind == MAGIC_CONSTANT.CLASS)
					IlGen.Emit(OpCodes.Ldstr, CD.Name);
				else if (mc.Kind == MAGIC_CONSTANT.METHOD) {
					if (CD == CD__MAIN)
						IlGen.Emit(OpCodes.Ldstr, FD.Name);
					else
						IlGen.Emit(OpCodes.Ldstr, CD.Name + "::" + FD.Name);
				}
				else if (mc.Kind == MAGIC_CONSTANT.FUNCTION)
					IlGen.Emit(OpCodes.Ldstr, FD.Name);
			}
			else if (node is LNUMBER_SCALAR) {
				LNUMBER_SCALAR ls = (LNUMBER_SCALAR)node;
				IlGen.Emit(OpCodes.Ldc_I4, ls.Value);
				IlGen.Emit(OpCodes.Box, typeof(int));
			}
			else if (node is DNUMBER_SCALAR) {
				DNUMBER_SCALAR ds = (DNUMBER_SCALAR)node;
				IlGen.Emit(OpCodes.Ldc_R8, ds.Value);
				IlGen.Emit(OpCodes.Box, 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.Box, typeof(bool));
				}
				else if (ss.Value.ToLower() == "false") {
					IlGen.Emit(OpCodes.Ldc_I4_0);
					IlGen.Emit(OpCodes.Box, typeof(bool));
				}
				else
					IlGen.Emit(OpCodes.Ldstr, ss.Value);
			}
			else if (node is SINGLE_QUOTES) {
				SINGLE_QUOTES sq = (SINGLE_QUOTES)node;
				StringBuilder result = new StringBuilder();
				foreach (object o in sq.EncapsList) {
					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());
			}
			else if (node is DOUBLE_QUOTES) {
				DOUBLE_QUOTES dq = (DOUBLE_QUOTES)node;
				StringBuilder output = new StringBuilder();
				bool concat = false;
				foreach (object o in dq.EncapsList) {
					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());
							if (concat)
								IlGen.Emit(OpCodes.Call, PHPRuntimeOperators.GetMethod("Concat", new Type[] { typeof(object), typeof(object) }));
							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.Ldnull);
						// concat, if necessary
						if (concat)
							IlGen.Emit(OpCodes.Call, PHPRuntimeOperators.GetMethod("Concat", new Type[] { typeof(object), typeof(object) }));
						concat = true;
					}
				}
				// push substring after last variable and concat, if necessary
				if (output.Length > 0) {
					IlGen.Emit(OpCodes.Ldstr, output.ToString());
					if (concat)
						IlGen.Emit(OpCodes.Call, PHPRuntimeOperators.GetMethod("Concat", new Type[] { typeof(object), typeof(object) }));
					output = null;
				}
			}
			else if (node is HEREDOC) {
				HEREDOC h = (HEREDOC)node;
				StringBuilder output = new StringBuilder();
				bool concat = false;
				foreach (object o in h.EncapsList) {
					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());
							if (concat)
								IlGen.Emit(OpCodes.Call, PHPRuntimeOperators.GetMethod("Concat", new Type[] { typeof(object), typeof(object) }));
							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.Ldnull);
						// concat, if necessary
						if (concat)
							IlGen.Emit(OpCodes.Call, PHPRuntimeOperators.GetMethod("Concat", new Type[] { typeof(object), typeof(object) }));
						concat = true;
					}
				}
				// push substring after last variable and concat, if necessary
				if (output.Length > 0) {
					IlGen.Emit(OpCodes.Ldstr, output.ToString());
					if (concat)
						IlGen.Emit(OpCodes.Call, PHPRuntimeOperators.GetMethod("Concat", new Type[] { typeof(object), typeof(object) }));
					output = null;
				}
			}
			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);
			}
		}
Beispiel #2
0
		public void InvokeStaticFunction(string className, string functionName, ExpressionList parameters, int line, int column) {
			SymbolTableEntry cdEntry = SymbolTable.GetInstance().LookupGlobal(className, SymbolTable.CLASS);
			// type is defined in an referenced assembly
			if (cdEntry == null) {
				Type t = SymbolTable.GetInstance().GetExternalType(className);
				IlGen.Emit(OpCodes.Ldstr, t.AssemblyQualifiedName);
				IlGen.Emit(OpCodes.Newobj, typeof(ArrayList).GetConstructor(Type.EmptyTypes));
				foreach (Expression expr in parameters) {
					IlGen.Emit(OpCodes.Dup);
					Visit(expr);
					IlGen.Emit(OpCodes.Call, typeof(ArrayList).GetMethod("Add", new Type[] { typeof(object) }));
					IlGen.Emit(OpCodes.Pop);
				}
				IlGen.Emit(OpCodes.Ldstr, functionName);
				IlGen.Emit(OpCodes.Call, PHPRuntimeCore.GetMethod("InvokeExternalStaticFunction", new Type[] { typeof(string), typeof(ArrayList), typeof(object) }));
			}
			// type is defined in script
			else {
				CLASS_DECLARATION cd = (CLASS_DECLARATION)cdEntry.Node;
				CLASS_DECLARATION tmpCD = cd;
				SymbolTableEntry fdEntry = tmpCD.Scope.Lookup(functionName, SymbolTable.FUNCTION);
				while (fdEntry == null) {
					if (tmpCD.Extends == null)
						break;
					SymbolTableEntry parentCDEntry = SymbolTable.GetInstance().LookupGlobal(tmpCD.Extends, SymbolTable.CLASS);
					tmpCD = (CLASS_DECLARATION)parentCDEntry.Node;
					fdEntry = tmpCD.Scope.Lookup(functionName, SymbolTable.FUNCTION);
					if (fdEntry != null && !((FUNCTION_DECLARATION)fdEntry.Node).Modifiers.Contains(Modifiers.STATIC)) {
						Report.Error(215, functionName, line, column);
						IlGen.Emit(OpCodes.Ldnull);
						return;
					}
					if (fdEntry != null && ((FUNCTION_DECLARATION)fdEntry.Node).Modifiers.Contains(Modifiers.PRIVATE)) {
						Report.Error(217, functionName, line, column);
						IlGen.Emit(OpCodes.Ldnull);
						return;
					}
				}
				if (fdEntry == null) {
					Report.Error(216, functionName, line, column);
					IlGen.Emit(OpCodes.Ldnull);
					return;
				}
				FUNCTION_DECLARATION fd = (FUNCTION_DECLARATION)fdEntry.Node;
				if (!fd.Modifiers.Contains(Modifiers.STATIC)) {
					Report.Error(215, functionName, line, column);
					IlGen.Emit(OpCodes.Ldnull);
					return;
				}
				// pass parameters (only as many as needed)
				int parametersPassedActually = (int)Math.Min(fd.Parameters.Count, parameters.Count());
				for (int i = 0; i < parametersPassedActually; i++) {
					PARAMETER_DECLARATION pd = (PARAMETER_DECLARATION)fd.Parameters[i];
					Expression expr = (Expression)parameters.Get(i);
					// ensure a reference is passed, if a reference is required
					if (pd.ByReference && !(expr is REFERENCE))
						expr = new REFERENCE(expr, expr.Line, expr.Column);
					// process parameter
					Visit(expr);
				}
				// if less parameters actually passed then necessary, pass nulls instead
				for (int i = parametersPassedActually; i < fd.Parameters.Count; i++) {
					PARAMETER_DECLARATION pd = (PARAMETER_DECLARATION)fd.Parameters[i];
					if (pd.DefaultValue == null)
						Report.Warn(300, System.Convert.ToString(i + 1), line, column);
					IlGen.Emit(OpCodes.Ldnull);
				}
				// add function call to call trace
				IlGen.Emit(OpCodes.Ldstr, CD.Name + "->" + fd.Name);
				IlGen.Emit(OpCodes.Call, PHPRuntimeCore.GetMethod("AddFunctionCallToTrace", new Type[] { typeof(string) }));
				// call
				MethodBuilder mb = fd.MthBld;
				IlGen.Emit(OpCodes.Call, mb);
				// remove function call from call trace
				IlGen.Emit(OpCodes.Call, PHPRuntimeCore.GetMethod("RemoveFunctionCallFromTrace", Type.EmptyTypes));
			}
		}
Beispiel #3
0
    /** 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 358: // 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(48/*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 357: // isset_variables ::= isset_variables COMMA variable
                {
                    object RESULT = null;

                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(105/*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 356: // isset_variables ::= variable
                {
                    object RESULT = null;

                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(105/*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 355: // 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(104/*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 354: // 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(104/*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 353: // 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(104/*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 352: // 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(104/*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 351: // 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(104/*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_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(104/*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 349: // 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(104/*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: // 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(47/*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 347: // 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(47/*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 346: // 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(47/*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 345: // 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(46/*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 344: // 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(46/*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 343: // 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(46/*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 342: // 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(46/*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 341: // 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(46/*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 340: // 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(46/*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 339: // encaps_list ::=
                {
                    ArrayList RESULT = null;
                    RESULT = new ArrayList();
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(82/*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 338: // 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(82/*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 337: // 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(82/*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 336: // 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(82/*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 335: // 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(82/*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 334: // 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(82/*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 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(82/*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 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(82/*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 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(82/*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 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(82/*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_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(82/*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 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(82/*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: // 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(81/*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 326: // 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(81/*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 325: // 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(81/*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 324: // 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(81/*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 323: // 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(81/*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 322: // 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(81/*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 321: // 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(81/*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 320: // 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(81/*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 319: // 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(80/*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 318: // array_pair_list ::=
                {
                    ArrayList RESULT = null;
                    RESULT = new ArrayList();
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(80/*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 317: // assignment_list_element ::=
                {
                    object RESULT = null;

                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(103/*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 316: // assignment_list_element ::= T_LIST BRACE_OPEN assignment_list BRACE_CLOSE
                {
                    object RESULT = null;

                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(103/*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 315: // assignment_list_element ::= variable
                {
                    object RESULT = null;

                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(103/*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 314: // assignment_list ::= assignment_list_element
                {
                    object RESULT = null;

                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(102/*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 313: // assignment_list ::= assignment_list COMMA assignment_list_element
                {
                    object RESULT = null;

                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(102/*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 312: // simple_indirect_reference ::= simple_indirect_reference DOLLAR
                {
                    object RESULT = null;

                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(101/*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 311: // simple_indirect_reference ::= DOLLAR
                {
                    object RESULT = null;

                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(101/*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 310: // 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(45/*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 309: // 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(45/*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 308: // 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(44/*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 307: // 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(44/*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 306: // 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(44/*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 305: // 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(43/*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 304: // 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(43/*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 303: // 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(42/*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 302: // dim_offset ::=
                {
                    Expression RESULT = null;
                    RESULT = null;
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(42/*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 301: // 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(41/*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 300: // 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(41/*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 299: // 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(40/*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 298: // 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(40/*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 297: // 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(40/*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 296: // 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(39/*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 295: // base_variable ::= simple_indirect_reference reference_variable
                {
                    Expression RESULT = null;
                    Report.Error(900, "variable variables");
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(39/*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 294: // 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(39/*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 293: // 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(38/*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 292: // 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(38/*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 291: // 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(37/*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 290: // 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(36/*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 289: // 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(36/*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 288: // method_or_not ::=
                {
                    ExpressionList RESULT = null;
                    RESULT = null;
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(63/*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 287: // 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(63/*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 286: // 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(35/*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 285: // variable_properties ::=
                {
                    ExpressionList RESULT = null;
                    RESULT = new ExpressionList();
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(62/*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 284: // 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(62/*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 283: // 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(34/*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 282: // 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(34/*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 281: // 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(33/*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 280: // 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(32/*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 279: // 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(31/*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 278: // 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(30/*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 277: // 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(30/*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 276: // 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(79/*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 275: // 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(79/*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 274: // 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(79/*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 273: // 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(79/*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 272: // possible_comma ::= COMMA
                {
                    object RESULT = null;

                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(94/*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 271: // possible_comma ::=
                {
                    object RESULT = null;

                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(94/*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 270: // 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(78/*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 269: // static_array_pair_list ::=
                {
                    ArrayList RESULT = null;
                    RESULT = new ArrayList();
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(78/*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 268: // 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(29/*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 267: // 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(29/*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 266: // 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(29/*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 265: // 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(29/*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 264: // 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(29/*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 263: // 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(29/*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 262: // 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(29/*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 261: // 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(28/*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 260: // 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(27/*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 259: // 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(27/*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 258: // 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(27/*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 257: // 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(27/*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 256: // 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(27/*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 ::= 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(27/*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 254: // common_scalar ::= T_FUNC_C
                {
                    Expression RESULT = null;
                    int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 0)).left;
                    int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 0)).right;
                    string t = (string)((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 0)).value;
                    RESULT = new MAGIC_CONSTANT(MAGIC_CONSTANT.FUNCTION, tleft, tright);
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(26/*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 253: // common_scalar ::= T_METHOD_C
                {
                    Expression RESULT = null;
                    int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 0)).left;
                    int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 0)).right;
                    string t = (string)((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 0)).value;
                    RESULT = new MAGIC_CONSTANT(MAGIC_CONSTANT.METHOD, tleft, tright);
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(26/*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 252: // common_scalar ::= T_CLASS_C
                {
                    Expression RESULT = null;
                    int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 0)).left;
                    int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 0)).right;
                    string t = (string)((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 0)).value;
                    RESULT = new MAGIC_CONSTANT(MAGIC_CONSTANT.CLASS, tleft, tright);
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(26/*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 251: // common_scalar ::= T_FILE
                {
                    Expression RESULT = null;
                    int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 0)).left;
                    int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 0)).right;
                    string t = (string)((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 0)).value;
                    RESULT = new MAGIC_CONSTANT(MAGIC_CONSTANT.FILE, tleft, tright);
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(26/*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 250: // common_scalar ::= T_LINE
                {
                    Expression RESULT = null;
                    int tleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 0)).left;
                    int tright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 0)).right;
                    string t = (string)((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 0)).value;
                    RESULT = new MAGIC_CONSTANT(MAGIC_CONSTANT.LINE, tleft, tright);
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(26/*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_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(26/*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_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(26/*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_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(26/*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: // 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(61/*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 245: // ctor_arguments ::=
                {
                    ExpressionList RESULT = null;
                    RESULT = new ExpressionList();
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(61/*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 244: // 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(25/*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 243: // exit_expr ::= BRACE_OPEN BRACE_CLOSE
                {
                    Expression RESULT = null;
                    RESULT = null;
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(25/*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 242: // exit_expr ::=
                {
                    Expression RESULT = null;
                    RESULT = null;
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(25/*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 241: // dynamic_class_name_variable_property ::= T_OBJECT_OPERATOR object_property
                {
                    object RESULT = null;

                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(100/*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 240: // dynamic_class_name_variable_properties ::=
                {
                    object RESULT = null;

                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(99/*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 239: // 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(99/*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 238: // dynamic_class_name_reference ::= base_variable
                {
                    object RESULT = null;

                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(98/*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 237: // 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(98/*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 236: // 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(87/*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 235: // class_name_reference ::= 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(87/*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 234: // fully_qualified_class_name ::= fully_qualified_class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING
                {
                    string 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 = fqcn + "::" + s;
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(86/*fully_qualified_class_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 233: // 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(86/*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 232: // 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(24/*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 231: // 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(24/*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 230: // 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(24/*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 229: // 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(24/*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: // 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(23/*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 227: // 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(23/*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 226: // 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(23/*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 225: // 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(23/*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 224: // 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(23/*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 223: // 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(23/*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 222: // 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(23/*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 221: // 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(23/*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_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(23/*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_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(23/*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_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(23/*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_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(23/*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_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(23/*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 ::= internal_functions_in_yacc
                {
                    Expression RESULT = null;

                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(23/*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 214: // 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(23/*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 213: // 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(23/*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 212: // 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(23/*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 211: // 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(23/*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 210: // 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(23/*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_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(23/*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 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(23/*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 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(23/*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_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(23/*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 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(23/*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_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(23/*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 ::= 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(23/*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 202: // 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(23/*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 201: // 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(23/*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 200: // 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(23/*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 ::= 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(23/*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 198: // 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(23/*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 197: // 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(23/*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 196: // 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(23/*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 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(23/*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 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(23/*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 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(23/*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 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(23/*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 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(23/*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 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(23/*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 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(23/*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 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(23/*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 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(23/*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 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(23/*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_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(23/*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_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(23/*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 ::= 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(23/*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 182: // 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(23/*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 181: // 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(23/*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 180: // 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(23/*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 ::= 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(23/*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 178: // 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(23/*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 177: // 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(23/*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 176: // 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(23/*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_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(23/*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_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(23/*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_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(23/*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_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(23/*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_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(23/*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_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(23/*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_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(23/*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 ::= 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(23/*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 167: // 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(23/*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 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(23/*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 165: // 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(23/*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 164: // 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(23/*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 ::= 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(23/*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: // 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(60/*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 161: // 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(60/*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 160: // 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(59/*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 159: // for_expr ::=
                {
                    ExpressionList RESULT = null;
                    RESULT = new ExpressionList();
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(59/*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 158: // 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(58/*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 157: // 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(58/*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 156: // 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(18/*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 155: // 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(18/*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 154: // 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(17/*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 153: // 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(17/*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 152: // 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(17/*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 151: // 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(17/*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: // member_modifier ::= T_FINAL
                {
                    object RESULT = null;
                    RESULT = PHP.Compiler.Modifiers.FINAL;
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(93/*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 149: // 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;
                    RESULT = PHP.Compiler.Modifiers.ABSTRACT;
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(93/*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 148: // member_modifier ::= T_STATIC
                {
                    object RESULT = null;
                    RESULT = PHP.Compiler.Modifiers.STATIC;
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(93/*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 147: // member_modifier ::= T_PRIVATE
                {
                    object RESULT = null;
                    RESULT = PHP.Compiler.Modifiers.PRIVATE;
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(93/*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_PROTECTED
                {
                    object RESULT = null;
                    RESULT = PHP.Compiler.Modifiers.PROTECTED;
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(93/*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_PUBLIC
                {
                    object RESULT = null;
                    RESULT = PHP.Compiler.Modifiers.PUBLIC;
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(93/*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: // 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(77/*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 143: // 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(77/*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 142: // 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(76/*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 141: // method_modifiers ::=
                {
                    ArrayList RESULT = null;
                    RESULT = new ArrayList();
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(76/*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 140: // 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(75/*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 139: // 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(75/*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 138: // 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(52/*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 137: // method_body ::= SEMICOLON
                {
                    StatementList RESULT = null;
                    RESULT = null;
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(52/*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 136: // 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 fleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 6)).left;
                    int fright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 6)).right;
                    string f = (string)((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 6)).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 == 1) ? fleft : mmleft, (mmright == 1) ? fright : mmright);
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(16/*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 135: // 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(16/*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 134: // 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(16/*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 133: // class_statement_list ::=
                {
                    StatementList RESULT = null;
                    RESULT = new StatementList();
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(51/*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 132: // 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(51/*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 131: // 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(57/*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 130: // 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(57/*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 129: // 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(57/*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 128: // 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(57/*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: // 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(22/*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 126: // 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(22/*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 125: // 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(22/*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 124: // 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(56/*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 123: // 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(56/*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 122: // 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(55/*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 121: // 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(55/*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 120: // 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(55/*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 119: // 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(55/*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 118: // 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(55/*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 117: // 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(55/*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 116: // function_call_parameter_list ::=
                {
                    ExpressionList RESULT = null;
                    RESULT = new ExpressionList();
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(54/*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 115: // 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(54/*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: // 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(85/*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 113: // optional_class_type ::=
                {
                    string RESULT = null;
                    RESULT = null;
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(85/*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 112: // 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(74/*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 111: // 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(74/*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 110: // 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(74/*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 109: // 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(74/*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 108: // 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(74/*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 107: // 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(74/*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 ::= 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(74/*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 105: // 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(74/*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 104: // parameter_list ::=
                {
                    ArrayList RESULT = null;
                    RESULT = new ArrayList();
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(73/*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 103: // 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(73/*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 102: // 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(15/*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 101: // new_else_single ::=
                {
                    Statement RESULT = null;
                    RESULT = null;
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(15/*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 100: // 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(14/*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 99: // else_single ::=
                {
                    Statement RESULT = null;
                    RESULT = null;
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(14/*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 98: // 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(72/*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 97: // new_elseif_list ::=
                {
                    ArrayList RESULT = null;
                    RESULT = new ArrayList();
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(72/*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 96: // 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(71/*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 95: // elseif_list ::=
                {
                    ArrayList RESULT = null;
                    RESULT = new ArrayList();
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(71/*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 94: // 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(13/*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 93: // 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(13/*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 92: // case_separator ::= SEMICOLON
                {
                    object RESULT = null;

                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(92/*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 91: // case_separator ::= COLON
                {
                    object RESULT = null;

                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(92/*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 90: // 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(70/*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 89: // 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(70/*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 88: // case_list ::=
                {
                    ArrayList RESULT = null;
                    RESULT = new ArrayList();
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(70/*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 87: // 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(69/*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 86: // 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(69/*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 85: // 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(69/*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 84: // 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(69/*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 83: // declare_list ::= declare_list COMMA T_STRING EQUALS static_scalar
                {
                    object RESULT = null;

                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(97/*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 82: // declare_list ::= T_STRING EQUALS static_scalar
                {
                    object RESULT = null;

                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(97/*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 81: // declare_statement ::= COLON inner_statement_list T_ENDDECLARE SEMICOLON
                {
                    object RESULT = null;

                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(96/*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 80: // declare_statement ::= statement
                {
                    object RESULT = null;

                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(96/*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 79: // 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(12/*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 78: // 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(12/*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 77: // 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(11/*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 76: // 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(11/*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 75: // 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(21/*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 74: // 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(21/*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 73: // 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(20/*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 72: // foreach_optional_arg ::=
                {
                    Expression RESULT = null;
                    RESULT = null;
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(20/*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 71: // interface_list ::= interface_list COMMA fully_qualified_class_name
                {
                    ArrayList RESULT = null;
                    int illeft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 2)).left;
                    int ilright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 2)).right;
                    ArrayList il = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 2)).value;
                    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;
                    il.Add(fqcn);
                    RESULT = il;
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(68/*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 70: // interface_list ::= fully_qualified_class_name
                {
                    ArrayList 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;
                    ArrayList il = new ArrayList();
                    il.Add(fqcn);
                    RESULT = il;
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(68/*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 69: // implements_list ::= T_IMPLEMENTS interface_list
                {
                    ArrayList RESULT = null;
                    int illeft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 0)).left;
                    int ilright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 0)).right;
                    ArrayList il = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 0)).value;
                    RESULT = il;
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(67/*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 68: // implements_list ::=
                {
                    ArrayList RESULT = null;
                    RESULT = new ArrayList();
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(67/*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 67: // interface_extends_list ::= T_EXTENDS interface_list
                {
                    ArrayList RESULT = null;
                    int illeft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 0)).left;
                    int ilright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 0)).right;
                    ArrayList il = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 0)).value;
                    RESULT = il;
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(66/*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 66: // interface_extends_list ::=
                {
                    ArrayList RESULT = null;
                    RESULT = new ArrayList();
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(66/*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 65: // interface_entry ::= T_INTERFACE
                {
                    object RESULT = null;

                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(91/*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 64: // 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(84/*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 63: // extends_from ::=
                {
                    string RESULT = null;
                    RESULT = null;
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(84/*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 62: // class_entry_type ::= T_FINAL T_CLASS
                {
                    object RESULT = null;
                    RESULT = PHP.Compiler.Modifiers.FINAL;
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(90/*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 61: // class_entry_type ::= T_ABSTRACT T_CLASS
                {
                    object RESULT = null;
                    RESULT = PHP.Compiler.Modifiers.ABSTRACT;
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(90/*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 60: // class_entry_type ::= T_CLASS
                {
                    object RESULT = null;
                    RESULT = PHP.Compiler.Modifiers.PUBLIC;
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(90/*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 59: // unticked_class_declaration_statement ::= interface_entry T_STRING interface_extends_list CURLY_BRACE_OPEN class_statement_list CURLY_BRACE_CLOSE
                {
                    Statement RESULT = null;
                    int ieleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 5)).left;
                    int ieright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 5)).right;
                    object ie = (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 ielleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 3)).left;
                    int ielright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 3)).right;
                    ArrayList iel = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 3)).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 INTERFACE_DECLARATION(s, iel, cstl, ieleft, ieright);
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(10/*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 58: // 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 illeft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 3)).left;
                    int ilright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 3)).right;
                    ArrayList il = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 3)).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, il, cstl, cetleft, cetright);
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(10/*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 57: // 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(9/*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 56: // is_reference ::= AND
                {
                    object RESULT = null;
                    RESULT = true;
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(89/*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 55: // is_reference ::=
                {
                    object RESULT = null;
                    RESULT = false;
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(89/*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 54: // 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(8/*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 53: // 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(7/*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 52: // use_filename ::= BRACE_OPEN T_CONSTANT_ENCAPSED_STRING BRACE_CLOSE
                {
                    object RESULT = null;

                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(95/*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 51: // use_filename ::= T_CONSTANT_ENCAPSED_STRING
                {
                    object RESULT = null;

                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(95/*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 50: // 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(19/*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 49: // 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(53/*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 48: // 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(53/*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 47: // 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;
                    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 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 vleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 4)).left;
                    int vright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 4)).right;
                    string v = (string)((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 CATCH(fqcn, v, istl, tleft, tright);
                    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 46: // non_empty_additional_catches ::= non_empty_additional_catches additional_catch
                {
                    ArrayList 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;
                    ArrayList neac = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 1)).value;
                    int acleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 0)).left;
                    int acright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 0)).right;
                    object ac = (object)((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 0)).value;
                    neac.Add(ac);
                    RESULT = neac;
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(65/*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 45: // non_empty_additional_catches ::= additional_catch
                {
                    ArrayList RESULT = null;
                    int acleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 0)).left;
                    int acright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 0)).right;
                    object ac = (object)((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 0)).value;
                    ArrayList al = new ArrayList();
                    al.Add(ac);
                    RESULT = al;
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(65/*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 44: // additional_catches ::=
                {
                    ArrayList RESULT = null;
                    RESULT = new ArrayList();
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(64/*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 43: // additional_catches ::= non_empty_additional_catches
                {
                    ArrayList RESULT = null;
                    int neacleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 0)).left;
                    int neacright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 0)).right;
                    ArrayList neac = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 0)).value;
                    RESULT = neac;
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(64/*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 42: // unticked_statement ::= T_THROW 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 THROW(e, tleft, tright);
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(6/*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 41: // 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;
                    int t1left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 12)).left;
                    int t1right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 12)).right;
                    string t1 = (string)((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 12)).value;
                    int istl1left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 10)).left;
                    int istl1right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 10)).right;
                    StatementList istl1 = (StatementList)((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 10)).value;
                    int t2left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 8)).left;
                    int t2right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 8)).right;
                    string t2 = (string)((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 8)).value;
                    int fqcnleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 6)).left;
                    int fqcnright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 6)).right;
                    string fqcn = (string)((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 6)).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;
                    string v = (string)((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 5)).value;
                    int istl2left = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 2)).left;
                    int istl2right = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 2)).right;
                    StatementList istl2 = (StatementList)((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 2)).value;
                    int acleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 0)).left;
                    int acright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 0)).right;
                    ArrayList ac = (ArrayList)((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 0)).value;
                    ac.Add(new CATCH(fqcn, v, istl2, t2left, t2right));
                    RESULT = new TRY(istl1, ac, t1left, t1right);
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(6/*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 40: // unticked_statement ::= SEMICOLON
                {
                    Statement RESULT = null;
                    RESULT = null;
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(6/*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 39: // 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(6/*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 38: // 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(6/*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 37: // 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(6/*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 36: // 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(6/*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_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(6/*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 34: // 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(6/*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 33: // 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(6/*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 32: // 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(6/*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 ::= 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(6/*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 30: // 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(6/*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 29: // 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(6/*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_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(6/*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_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(6/*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 26: // 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(6/*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_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(6/*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 24: // 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(6/*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 23: // 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(6/*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 22: // 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(6/*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 21: // 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(6/*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 20: // 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(6/*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 19: // 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(6/*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_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(6/*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 17: // 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(6/*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 16: // unticked_statement ::= CURLY_BRACE_OPEN inner_statement_list CURLY_BRACE_CLOSE
                {
                    Statement RESULT = null;
                    int cleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 2)).left;
                    int cright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 2)).right;
                    string c = (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, cleft, cright);
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(6/*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 15: // 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(5/*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 14: // 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(4/*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 13: // 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(4/*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 12: // 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(4/*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 11: // inner_statement_list ::=
                {
                    StatementList RESULT = null;
                    RESULT = new StatementList();
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(50/*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 10: // 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(50/*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 9: // using_statement ::= T_USING T_STRING EQUALS fully_qualified_class_name 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 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 fqcnleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 1)).left;
                    int fqcnright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 1)).right;
                    string fqcn = (string)((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 1)).value;
                    RESULT = new USING(fqcn, s, tleft, tright);
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(3/*using_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 8: // using_statement ::= T_USING fully_qualified_class_name 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 fqcnleft = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 1)).left;
                    int fqcnright = ((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 1)).right;
                    string fqcn = (string)((TUVienna.CS_CUP.Runtime.Symbol)CUP_Parser_stack.elementAt(CUP_Parser_top - 1)).value;
                    RESULT = new USING(fqcn, null, tleft, tright);
                    CUP_Parser_result = new TUVienna.CS_CUP.Runtime.Symbol(3/*using_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 7: // top_statement ::= using_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(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 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(49/*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(49/*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");

        }
    }