public ArgumentDeclarationList(Parser yyp, ArgumentDeclarationList adl, Declaration d)
     : base(((LSLSyntax
         )yyp))
 {
     while (0 < adl.kids.Count) kids.Add(adl.kids.Pop());
     kids.Add(d);
 }

/// <summary/>
/// <param name='yyq'></param>
  public OptionalSegment_2_1(Parser yyq):base(yyq){
				((PhonEnvParser
)yyq).CreateErrorMessage(PhonEnvParser.SyntaxErrType.missingClosingParen.ToString(),
	((TOKEN)(yyq.StackAt(2).m_value))
	.yytext,
	((error)(yyq.StackAt(0).m_value))
	.pos);
					((PhonEnvParser
)yyq).SyntaxErrorType = PhonEnvParser.SyntaxErrType.missingClosingParen;
					((PhonEnvParser
)yyq).Position =
	((error)(yyq.StackAt(0).m_value))
	.pos;
					}}

		public ParseStackEntry(Parser yyp,int state,SYMBOL value) 
		{
			yyps = yyp; m_state = state; m_value = value;
		}

		// support for actions
		public virtual object Action(Parser yyp,SYMBOL yysym, int yyact) { return null; } // will be generated for the generated parser

 public Null(Parser yyp, int proxy) : base(yyp) { num = proxy; }

		public error(Parser yyp,ParseStackEntry s):base(yyp) { state=s.m_state; sym=s.m_value; } //4.4c
		public error(Parser yyp):base(yyp) {}

		public Statement_13(Parser yyq):base(yyq,
		                                     ((CompoundStatement)(yyq.StackAt(0).m_value))
		                                    ){}}

		public Statement_12(Parser yyq):base(yyq,
		                                     ((ForLoop)(yyq.StackAt(0).m_value))
		                                    ){}}

		public Statement_11(Parser yyq):base(yyq,
		                                     ((DoWhileStatement)(yyq.StackAt(0).m_value))
		                                    ){}}

		public Statement_9(Parser yyq):base(yyq,
		                                    ((IfStatement)(yyq.StackAt(0).m_value))
		                                   ){}}

		public Statement_8(Parser yyq):base(yyq,
		                                    ((StateChange)(yyq.StackAt(1).m_value))
		                                   ){}}

		public Statement_7(Parser yyq):base(yyq,
		                                    ((JumpStatement)(yyq.StackAt(1).m_value))
		                                   ){}}

		public Statement_6(Parser yyq):base(yyq,
		                                    ((JumpLabel)(yyq.StackAt(1).m_value))
		                                   ){}}

		public DoWhileStatement_2(Parser yyq):base(yyq,
		                                           ((SimpleAssignment)(yyq.StackAt(2).m_value))
		                                           ,
		                                           ((Statement)(yyq.StackAt(5).m_value))
		                                          ){}}

		public ForLoop_1(Parser yyq):base(yyq,
		                                  ((ForLoopStatement)(yyq.StackAt(6).m_value))
		                                  ,
		                                  ((Expression)(yyq.StackAt(4).m_value))
		                                  ,
		                                  ((ForLoopStatement)(yyq.StackAt(2).m_value))
		                                  ,
		                                  ((Statement)(yyq.StackAt(0).m_value))
		                                 ){}}

		public JumpStatement_1(Parser yyq):base(yyq,
		                                        ((IDENT)(yyq.StackAt(0).m_value))
		                                        .yytext){}}

		public StateChange_1(Parser yyq):base(yyq,
		                                      ((IDENT)(yyq.StackAt(0).m_value))
		                                      .yytext){}}

		public recoveredError(Parser yyp,ParseStackEntry s):base(yyp,s) {}

		public StateChange_2(Parser yyq):base(yyq,
		                                      ((DEFAULT_STATE)(yyq.StackAt(0).m_value))
		                                      .yytext){}}

		public static object create(string cls_name,Parser yyp) 
		{
			SCreator cr = (SCreator)yyp.m_symbols.types[cls_name];
			// Console.WriteLine("TCreating {0} <{1}>",cls_name,yyl.yytext);
			if (cr==null) 
				yyp.m_symbols.erh.Error(new CSToolsException(16,yyp.m_lexer,"no factory for {"+cls_name+")"));
			try 
			{
				return cr(yyp);
			}
			catch (CSToolsException e)
			{
				yyp.m_symbols.erh.Error(e);
			}
			catch (Exception e) 
			{
				yyp.m_symbols.erh.Error(new CSToolsException(17,yyp.m_lexer,string.Format("Create of {0} failed ({1})",cls_name,e.Message)));
			}
			int j = cls_name.LastIndexOf('_');
			if (j>0) 
			{
				cr = (SCreator)yyp.m_symbols.types[cls_name.Substring(0,j)];
				if (cr!=null) 
				{
					SYMBOL s = (SYMBOL)cr(yyp);
					s.m_dollar = 0;
					return s;
				}
			}
			return null;
		}