tree.c

这是一个Linux下的集成开发环境

#else
(pnext)
tTree pnext;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yfield));
 Tree_InitHead (yyt, kfield)
 begintTree(yyt->field.env)
 yyt->field.next = pnext;
 return yyt;
}

tTree mfunction
#if defined __STDC__ | defined __cplusplus
(tTree pnext, long pmodifiers, tIdent pident, tPosition ppos, tTree pdecl_list, tTree pthrows, tTree pblock)
#else
(pnext, pmodifiers, pident, ppos, pdecl_list, pthrows, pblock)
tTree pnext;
long pmodifiers;
tIdent pident;
tPosition ppos;
tTree pdecl_list;
tTree pthrows;
tTree pblock;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yfunction));
 Tree_InitHead (yyt, kfunction)
 begintTree(yyt->function.env)
 yyt->function.next = pnext;
 yyt->function.modifiers = pmodifiers;
 yyt->function.ident = pident;
 yyt->function.pos = ppos;
 yyt->function.decl_list = pdecl_list;
 yyt->function.throws = pthrows;
 yyt->function.block = pblock;
 return yyt;
}

tTree mmethod
#if defined __STDC__ | defined __cplusplus
(tTree pnext, long pmodifiers, tIdent pident, tPosition ppos, tTree pdecl_list, tTree pthrows, tTree pblock, tTree ptype, tTree parray)
#else
(pnext, pmodifiers, pident, ppos, pdecl_list, pthrows, pblock, ptype, parray)
tTree pnext;
long pmodifiers;
tIdent pident;
tPosition ppos;
tTree pdecl_list;
tTree pthrows;
tTree pblock;
tTree ptype;
tTree parray;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ymethod));
 Tree_InitHead (yyt, kmethod)
 begintTree(yyt->method.env)
 yyt->method.next = pnext;
 yyt->method.modifiers = pmodifiers;
 yyt->method.ident = pident;
 yyt->method.pos = ppos;
 yyt->method.decl_list = pdecl_list;
 yyt->method.throws = pthrows;
 yyt->method.block = pblock;
 yyt->method.type = ptype;
 yyt->method.array = parray;
 return yyt;
}

tTree mconstructor
#if defined __STDC__ | defined __cplusplus
(tTree pnext, long pmodifiers, tIdent pident, tPosition ppos, tTree pdecl_list, tTree pthrows, tTree pblock)
#else
(pnext, pmodifiers, pident, ppos, pdecl_list, pthrows, pblock)
tTree pnext;
long pmodifiers;
tIdent pident;
tPosition ppos;
tTree pdecl_list;
tTree pthrows;
tTree pblock;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yconstructor));
 Tree_InitHead (yyt, kconstructor)
 begintTree(yyt->constructor.env)
 yyt->constructor.next = pnext;
 yyt->constructor.modifiers = pmodifiers;
 yyt->constructor.ident = pident;
 yyt->constructor.pos = ppos;
 yyt->constructor.decl_list = pdecl_list;
 yyt->constructor.throws = pthrows;
 yyt->constructor.block = pblock;
 return yyt;
}

tTree mvar_decl
#if defined __STDC__ | defined __cplusplus
(tTree pnext, long pmodifiers, tTree ptype, tTree pdecl_list)
#else
(pnext, pmodifiers, ptype, pdecl_list)
tTree pnext;
long pmodifiers;
tTree ptype;
tTree pdecl_list;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yvar_decl));
 Tree_InitHead (yyt, kvar_decl)
 begintTree(yyt->var_decl.env)
 yyt->var_decl.next = pnext;
 yyt->var_decl.modifiers = pmodifiers;
 yyt->var_decl.type = ptype;
 yyt->var_decl.decl_list = pdecl_list;
 return yyt;
}

tTree mstatic_initializer
#if defined __STDC__ | defined __cplusplus
(tTree pnext, tTree pstatement_c)
#else
(pnext, pstatement_c)
tTree pnext;
tTree pstatement_c;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ystatic_initializer));
 Tree_InitHead (yyt, kstatic_initializer)
 begintTree(yyt->static_initializer.env)
 yyt->static_initializer.next = pnext;
 yyt->static_initializer.statement_c = pstatement_c;
 return yyt;
}

tTree minitializer
#if defined __STDC__ | defined __cplusplus
(tTree pnext, tTree pstatement_c)
#else
(pnext, pstatement_c)
tTree pnext;
tTree pstatement_c;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yinitializer));
 Tree_InitHead (yyt, kinitializer)
 begintTree(yyt->initializer.env)
 yyt->initializer.next = pnext;
 yyt->initializer.statement_c = pstatement_c;
 return yyt;
}

tTree mtype_decl
#if defined __STDC__ | defined __cplusplus
(tTree pnext, long pmodifiers, tIdent pident, tPosition ppos, tTree pblock)
#else
(pnext, pmodifiers, pident, ppos, pblock)
tTree pnext;
long pmodifiers;
tIdent pident;
tPosition ppos;
tTree pblock;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ytype_decl));
 Tree_InitHead (yyt, ktype_decl)
 begintTree(yyt->type_decl.env)
 yyt->type_decl.next = pnext;
 yyt->type_decl.modifiers = pmodifiers;
 yyt->type_decl.ident = pident;
 yyt->type_decl.pos = ppos;
 yyt->type_decl.block = pblock;
 return yyt;
}

tTree mclass
#if defined __STDC__ | defined __cplusplus
(tTree pnext, long pmodifiers, tIdent pident, tPosition ppos, tTree pblock, tTree pextends, tTree pinterfaces)
#else
(pnext, pmodifiers, pident, ppos, pblock, pextends, pinterfaces)
tTree pnext;
long pmodifiers;
tIdent pident;
tPosition ppos;
tTree pblock;
tTree pextends;
tTree pinterfaces;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yclass));
 Tree_InitHead (yyt, kclass)
 begintTree(yyt->class.env)
 yyt->class.next = pnext;
 yyt->class.modifiers = pmodifiers;
 yyt->class.ident = pident;
 yyt->class.pos = ppos;
 yyt->class.block = pblock;
 yyt->class.extends = pextends;
 yyt->class.interfaces = pinterfaces;
 return yyt;
}

tTree minterface
#if defined __STDC__ | defined __cplusplus
(tTree pnext, long pmodifiers, tIdent pident, tPosition ppos, tTree pblock, tTree pextends)
#else
(pnext, pmodifiers, pident, ppos, pblock, pextends)
tTree pnext;
long pmodifiers;
tIdent pident;
tPosition ppos;
tTree pblock;
tTree pextends;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yinterface));
 Tree_InitHead (yyt, kinterface)
 begintTree(yyt->my_interface.env)
 yyt->my_interface.next = pnext;
 yyt->my_interface.modifiers = pmodifiers;
 yyt->my_interface.ident = pident;
 yyt->my_interface.pos = ppos;
 yyt->my_interface.block = pblock;
 yyt->my_interface.extends = pextends;
 return yyt;
}

tTree mdecl_list
#if defined __STDC__ | defined __cplusplus
(void)
#else
()
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ydecl_list));
 Tree_InitHead (yyt, kdecl_list)
 begintTree(yyt->decl_list.env)
 beginshort(yyt->decl_list.no_of_args)
 return yyt;
}

tTree mnodecl
#if defined __STDC__ | defined __cplusplus
(void)
#else
()
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ynodecl));
 Tree_InitHead (yyt, knodecl)
 begintTree(yyt->nodecl.env)
 beginshort(yyt->nodecl.no_of_args)
 return yyt;
}

tTree mdecl
#if defined __STDC__ | defined __cplusplus
(tTree pnext, long pmodifiers, tTree ptype, tIdent pident, tPosition ppos, tTree parray)
#else
(pnext, pmodifiers, ptype, pident, ppos, parray)
tTree pnext;
long pmodifiers;
tTree ptype;
tIdent pident;
tPosition ppos;
tTree parray;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ydecl));
 Tree_InitHead (yyt, kdecl)
 begintTree(yyt->decl.env)
 beginshort(yyt->decl.no_of_args)
 yyt->decl.next = pnext;
 yyt->decl.modifiers = pmodifiers;
 yyt->decl.type = ptype;
 yyt->decl.ident = pident;
 yyt->decl.pos = ppos;
 yyt->decl.array = parray;
 return yyt;
}

tTree mvariable
#if defined __STDC__ | defined __cplusplus
(tTree pnext, long pmodifiers, tTree ptype, tIdent pident, tPosition ppos, tTree parray, tTree pexpression)
#else
(pnext, pmodifiers, ptype, pident, ppos, parray, pexpression)
tTree pnext;
long pmodifiers;
tTree ptype;
tIdent pident;
tPosition ppos;
tTree parray;
tTree pexpression;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yvariable));
 Tree_InitHead (yyt, kvariable)
 begintTree(yyt->variable.env)
 beginshort(yyt->variable.no_of_args)
 yyt->variable.next = pnext;
 yyt->variable.modifiers = pmodifiers;
 yyt->variable.type = ptype;
 yyt->variable.ident = pident;
 yyt->variable.pos = ppos;
 yyt->variable.array = parray;
 yyt->variable.expression = pexpression;
 return yyt;
}

tTree mparameter
#if defined __STDC__ | defined __cplusplus
(tTree pnext, long pmodifiers, tTree ptype, tIdent pident, tPosition ppos, tTree parray)
#else
(pnext, pmodifiers, ptype, pident, ppos, parray)
tTree pnext;
long pmodifiers;
tTree ptype;
tIdent pident;
tPosition ppos;
tTree parray;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yparameter));
 Tree_InitHead (yyt, kparameter)
 begintTree(yyt->parameter.env)
 beginshort(yyt->parameter.no_of_args)
 yyt->parameter.next = pnext;
 yyt->parameter.modifiers = pmodifiers;
 yyt->parameter.type = ptype;
 yyt->parameter.ident = pident;
 yyt->parameter.pos = ppos;
 yyt->parameter.array = parray;
 return yyt;
}

tTree mstatement_list
#if defined __STDC__ | defined __cplusplus
(void)
#else
()
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ystatement_list));
 Tree_InitHead (yyt, kstatement_list)
 begintTree(yyt->statement_list.env)
 return yyt;
}

tTree mnostatement
#if defined __STDC__ | defined __cplusplus
(void)
#else
()
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ynostatement));
 Tree_InitHead (yyt, knostatement)
 begintTree(yyt->nostatement.env)
 return yyt;
}

tTree mstatement
#if defined __STDC__ | defined __cplusplus
(tTree pnext, tTree pstatement)
#else
(pnext, pstatement)
tTree pnext;
tTree pstatement;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ystatement));
 Tree_InitHead (yyt, kstatement)
 begintTree(yyt->statement.env)
 yyt->statement.next = pnext;
 yyt->statement.statement = pstatement;
 return yyt;
}

tTree mstatement_c
#if defined __STDC__ | defined __cplusplus
(void)
#else
()
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ystatement_c));
 Tree_InitHead (yyt, kstatement_c)
 begintTree(yyt->statement_c.env)
 return yyt;
}

tTree mcompound_stmt
#if defined __STDC__ | defined __cplusplus
(tTree pstatement_list)
#else
(pstatement_list)
tTree pstatement_list;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ycompound_stmt));
 Tree_InitHead (yyt, kcompound_stmt)
 begintTree(yyt->compound_stmt.env)
 yyt->compound_stmt.statement_list = pstatement_list;
 return yyt;
}

tTree mexpression_stmt
#if defined __STDC__ | defined __cplusplus
(tTree pexpression)
#else
(pexpression)
tTree pexpression;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yexpression_stmt));
 Tree_InitHead (yyt, kexpression_stmt)
 begintTree(yyt->expression_stmt.env)
 yyt->expression_stmt.expression = pexpression;
 return yyt;
}

tTree mvar_decl_stmt
#if defined __STDC__ | defined __cplusplus
(tTree ptype, tTree pdecl_list)
#else
(ptype, pdecl_list)
tTree ptype;
tTree pdecl_list;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yvar_decl_stmt));
 Tree_InitHead (yyt, kvar_decl_stmt)
 begintTree(yyt->var_decl_stmt.env)
 yyt->var_decl_stmt.type = ptype;
 yyt->var_decl_stmt.decl_list = pdecl_list;
 return yyt;
}

tTree mtype_decl_stmt
#if defined __STDC__ | defined __cplusplus
(tTree ptype_decl)
#else
(ptype_decl)
tTree ptype_decl;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ytype_decl_stmt));
 Tree_InitHead (yyt, ktype_decl_stmt)
 begintTree(yyt->type_decl_stmt.env)
 yyt->type_decl_stmt.type_decl = ptype_decl;
 return yyt;
}

tTree mif_stmt
#if defined __STDC__ | defined __cplusplus
(tTree pexpression, tTree pthen)
#else
(pexpression, pthen)
tTree pexpression;
tTree pthen;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yif_stmt));
 Tree_InitHead (yyt, kif_stmt)
 begintTree(yyt->if_stmt.env)
 yyt->if_stmt.expression = pexpression;
 yyt->if_stmt.then = pthen;
 return yyt;
}

tTree mif_else_stmt
#if defined __STDC__ | defined __cplusplus
(tTree pexpression, tTree pthen, tTree pElse)
#else
(pexpression, pthen, pElse)
tTree pexpression;
tTree pthen;
tTree pElse;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yif_else_stmt));
 Tree_InitHead (yyt, kif_else_stmt)
 begintTree(yyt->if_else_stmt.env)
 yyt->if_else_stmt.expression = pexpression;
 yyt->if_else_stmt.then = pthen;
 yyt->if_else_stmt.Else = pElse;
 return yyt;
}

tTree mwhile_stmt
#if defined __STDC__ | defined __cplusplus
(tTree pexpression, tTree pstatement)
#else
(pexpression, pstatement)
tTree pexpression;
tTree pstatement;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ywhile_stmt));
 Tree_InitHead (yyt, kwhile_stmt)
 begintTree(yyt->while_stmt.env)
 yyt->while_stmt.expression = pexpression;
 yyt->while_stmt.statement = pstatement;
 return yyt;
}

tTree mdo_stmt
#if defined __STDC__ | defined __cplusplus
(tTree pstatement, tTree pexpression)
#else
(pstatement, pexpression)
tTree pstatement;
tTree pexpression;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ydo_stmt));
 Tree_InitHead (yyt, kdo_stmt)
 begintTree(yyt->do_stmt.env)
 yyt->do_stmt.statement = pstatement;
 yyt->do_stmt.expression = pexpression;
 return yyt;
}

tTree mbreak_stmt
#if defined __STDC__ | defined __cplusplus
(void)
#else
()
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ybreak_stmt));
 Tree_InitHead (yyt, kbreak_stmt)
 begintTree(yyt->break_stmt.env)
 return yyt;
}

tTree mbreak_id_stmt
#if defined __STDC__ | defined __cplusplus
(tTree pexpression)
#else
(pexpression)
tTree pexpression;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ybreak_id_stmt));
 Tree_InitHead (yyt, kbreak_id_stmt)
 begintTree(yyt->break_id_stmt.env)
 yyt->break_id_stmt.expression = pexpression;
 return yyt;
}

tTree mcontinue_stmt
#if defined __STDC__ | defined __cplusplus
(void)
#else
()
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ycontinue_stmt));
 Tree_InitHead (yyt, kcontinue_stmt)
 begintTree(yyt->continue_stmt.env)
 return yyt;
}

tTree mcontinue_id_stmt
#if defined __STDC__ | defined __cplusplus
(tTree pexpression)
#else
(pexpression)
tTree pexpression;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ycontinue_id_stmt));
 Tree_InitHead (yyt, kcontinue_id_stmt)
 begintTree(yyt->continue_id_stmt.env)
 yyt->continue_id_stmt.expression = pexpression;
 return yyt;
}

tTree mreturn_stmt
#if defined __STDC__ | defined __cplusplus
(void)
#else
()
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yreturn_stmt));
 Tree_InitHead (yyt, kreturn_stmt)
 begintTree(yyt->return_stmt.env)
 return yyt;
}