tree.c

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

tTree mreturn_expr_stmt
#if defined __STDC__ | defined __cplusplus
(tTree pexpression)
#else
(pexpression)
tTree pexpression;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yreturn_expr_stmt));
 Tree_InitHead (yyt, kreturn_expr_stmt)
 begintTree(yyt->return_expr_stmt.env)
 yyt->return_expr_stmt.expression = pexpression;
 return yyt;
}

tTree mfor_stmt
#if defined __STDC__ | defined __cplusplus
(tTree pfor_init, tTree pexpression, tTree pfor_incr, tTree pstatement)
#else
(pfor_init, pexpression, pfor_incr, pstatement)
tTree pfor_init;
tTree pexpression;
tTree pfor_incr;
tTree pstatement;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yfor_stmt));
 Tree_InitHead (yyt, kfor_stmt)
 begintTree(yyt->for_stmt.env)
 yyt->for_stmt.for_init = pfor_init;
 yyt->for_stmt.expression = pexpression;
 yyt->for_stmt.for_incr = pfor_incr;
 yyt->for_stmt.statement = pstatement;
 return yyt;
}

tTree mthrow_stmt
#if defined __STDC__ | defined __cplusplus
(tTree pexpression)
#else
(pexpression)
tTree pexpression;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ythrow_stmt));
 Tree_InitHead (yyt, kthrow_stmt)
 begintTree(yyt->throw_stmt.env)
 yyt->throw_stmt.expression = pexpression;
 return yyt;
}

tTree msynchronized_stmt
#if defined __STDC__ | defined __cplusplus
(tTree pexpression, tTree pstatement)
#else
(pexpression, pstatement)
tTree pexpression;
tTree pstatement;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ysynchronized_stmt));
 Tree_InitHead (yyt, ksynchronized_stmt)
 begintTree(yyt->synchronized_stmt.env)
 yyt->synchronized_stmt.expression = pexpression;
 yyt->synchronized_stmt.statement = pstatement;
 return yyt;
}

tTree mlabeled_stmt
#if defined __STDC__ | defined __cplusplus
(tIdent pident, tPosition ppos, tTree pstatement)
#else
(pident, ppos, pstatement)
tIdent pident;
tPosition ppos;
tTree pstatement;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ylabeled_stmt));
 Tree_InitHead (yyt, klabeled_stmt)
 begintTree(yyt->labeled_stmt.env)
 yyt->labeled_stmt.ident = pident;
 yyt->labeled_stmt.pos = ppos;
 yyt->labeled_stmt.statement = pstatement;
 return yyt;
}

tTree mtry_stmt
#if defined __STDC__ | defined __cplusplus
(tTree pstatement, tTree pcatch_list, tTree pfinally)
#else
(pstatement, pcatch_list, pfinally)
tTree pstatement;
tTree pcatch_list;
tTree pfinally;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ytry_stmt));
 Tree_InitHead (yyt, ktry_stmt)
 begintTree(yyt->try_stmt.env)
 yyt->try_stmt.statement = pstatement;
 yyt->try_stmt.catch_list = pcatch_list;
 yyt->try_stmt.finally = pfinally;
 return yyt;
}

tTree mswitch_stmt
#if defined __STDC__ | defined __cplusplus
(tTree pexpression, tTree pswitch_list)
#else
(pexpression, pswitch_list)
tTree pexpression;
tTree pswitch_list;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yswitch_stmt));
 Tree_InitHead (yyt, kswitch_stmt)
 begintTree(yyt->switch_stmt.env)
 yyt->switch_stmt.expression = pexpression;
 yyt->switch_stmt.switch_list = pswitch_list;
 return yyt;
}

tTree mnull_stmt
#if defined __STDC__ | defined __cplusplus
(void)
#else
()
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ynull_stmt));
 Tree_InitHead (yyt, knull_stmt)
 begintTree(yyt->null_stmt.env)
 return yyt;
}

tTree mswitch_list
#if defined __STDC__ | defined __cplusplus
(void)
#else
()
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yswitch_list));
 Tree_InitHead (yyt, kswitch_list)
 begintTree(yyt->switch_list.env)
 return yyt;
}

tTree mnoswitch
#if defined __STDC__ | defined __cplusplus
(void)
#else
()
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ynoswitch));
 Tree_InitHead (yyt, knoswitch)
 begintTree(yyt->noswitch.env)
 return yyt;
}

tTree mswitch_
#if defined __STDC__ | defined __cplusplus
(tTree pnext, tTree pexpression_list, tTree pstatement_list)
#else
(pnext, pexpression_list, pstatement_list)
tTree pnext;
tTree pexpression_list;
tTree pstatement_list;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yswitch_));
 Tree_InitHead (yyt, kswitch_)
 begintTree(yyt->switch_.env)
 yyt->switch_.next = pnext;
 yyt->switch_.expression_list = pexpression_list;
 yyt->switch_.statement_list = pstatement_list;
 return yyt;
}

tTree mcatch_list
#if defined __STDC__ | defined __cplusplus
(void)
#else
()
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ycatch_list));
 Tree_InitHead (yyt, kcatch_list)
 begintTree(yyt->catch_list.env)
 return yyt;
}

tTree mnocatch
#if defined __STDC__ | defined __cplusplus
(void)
#else
()
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ynocatch));
 Tree_InitHead (yyt, knocatch)
 begintTree(yyt->nocatch.env)
 return yyt;
}

tTree mcatch
#if defined __STDC__ | defined __cplusplus
(tTree pnext, tTree pdecl_list, tTree pstatement)
#else
(pnext, pdecl_list, pstatement)
tTree pnext;
tTree pdecl_list;
tTree pstatement;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ycatch));
 Tree_InitHead (yyt, kcatch)
 begintTree(yyt->catch.env)
 yyt->catch.next = pnext;
 yyt->catch.decl_list = pdecl_list;
 yyt->catch.statement = pstatement;
 return yyt;
}

tTree mtype_name_list
#if defined __STDC__ | defined __cplusplus
(void)
#else
()
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ytype_name_list));
 Tree_InitHead (yyt, ktype_name_list)
 begintTree(yyt->type_name_list.env)
 return yyt;
}

tTree mnotype_name
#if defined __STDC__ | defined __cplusplus
(void)
#else
()
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ynotype_name));
 Tree_InitHead (yyt, knotype_name)
 begintTree(yyt->notype_name.env)
 return yyt;
}

tTree mtype_name
#if defined __STDC__ | defined __cplusplus
(tTree pnext, tTree pnamed_type)
#else
(pnext, pnamed_type)
tTree pnext;
tTree pnamed_type;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ytype_name));
 Tree_InitHead (yyt, ktype_name)
 begintTree(yyt->type_name.env)
 yyt->type_name.next = pnext;
 yyt->type_name.named_type = pnamed_type;
 return yyt;
}

tTree mtype
#if defined __STDC__ | defined __cplusplus
(void)
#else
()
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ytype));
 Tree_InitHead (yyt, ktype)
 begintTree(yyt->type.env)
 return yyt;
}

tTree msimple_type
#if defined __STDC__ | defined __cplusplus
(ttype ptype)
#else
(ptype)
ttype ptype;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ysimple_type));
 Tree_InitHead (yyt, ksimple_type)
 begintTree(yyt->simple_type.env)
 yyt->simple_type.type = ptype;
 return yyt;
}

tTree mnamed_type
#if defined __STDC__ | defined __cplusplus
(tTree pqualified_symbol)
#else
(pqualified_symbol)
tTree pqualified_symbol;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ynamed_type));
 Tree_InitHead (yyt, knamed_type)
 begintTree(yyt->named_type.env)
 yyt->named_type.qualified_symbol = pqualified_symbol;
 return yyt;
}

tTree marray_type
#if defined __STDC__ | defined __cplusplus
(tTree ptype)
#else
(ptype)
tTree ptype;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yarray_type));
 Tree_InitHead (yyt, karray_type)
 begintTree(yyt->array_type.env)
 yyt->array_type.type = ptype;
 return yyt;
}

tTree mnotype
#if defined __STDC__ | defined __cplusplus
(void)
#else
()
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ynotype));
 Tree_InitHead (yyt, knotype)
 begintTree(yyt->notype.env)
 return yyt;
}

tTree mexpression_list
#if defined __STDC__ | defined __cplusplus
(void)
#else
()
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yexpression_list));
 Tree_InitHead (yyt, kexpression_list)
 begintTree(yyt->expression_list.env)
 beginshort(yyt->expression_list.no_of_args)
 return yyt;
}

tTree mnoexpression_l
#if defined __STDC__ | defined __cplusplus
(void)
#else
()
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ynoexpression_l));
 Tree_InitHead (yyt, knoexpression_l)
 begintTree(yyt->noexpression_l.env)
 beginshort(yyt->noexpression_l.no_of_args)
 return yyt;
}

tTree mexpression
#if defined __STDC__ | defined __cplusplus
(tTree pnext, tTree pexpression)
#else
(pnext, pexpression)
tTree pnext;
tTree pexpression;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yexpression));
 Tree_InitHead (yyt, kexpression)
 begintTree(yyt->expression.env)
 beginshort(yyt->expression.no_of_args)
 yyt->expression.next = pnext;
 yyt->expression.expression = pexpression;
 return yyt;
}

tTree mexpression_c
#if defined __STDC__ | defined __cplusplus
(tPosition ppos)
#else
(ppos)
tPosition ppos;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yexpression_c));
 Tree_InitHead (yyt, kexpression_c)
 yyt->expression_c.pos = ppos;
 begintTree(yyt->expression_c.env)
 return yyt;
}

tTree mqualified_symbol
#if defined __STDC__ | defined __cplusplus
(tPosition ppos)
#else
(ppos)
tPosition ppos;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yqualified_symbol));
 Tree_InitHead (yyt, kqualified_symbol)
 yyt->qualified_symbol.pos = ppos;
 begintTree(yyt->qualified_symbol.env)
 begintTree(yyt->qualified_symbol.object)
 return yyt;
}

tTree mqualification
#if defined __STDC__ | defined __cplusplus
(tPosition ppos, tTree pqualified_symbol, tIdent pident)
#else
(ppos, pqualified_symbol, pident)
tPosition ppos;
tTree pqualified_symbol;
tIdent pident;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yqualification));
 Tree_InitHead (yyt, kqualification)
 yyt->qualification.pos = ppos;
 begintTree(yyt->qualification.env)
 begintTree(yyt->qualification.object)
 yyt->qualification.qualified_symbol = pqualified_symbol;
 yyt->qualification.ident = pident;
 return yyt;
}

tTree mident
#if defined __STDC__ | defined __cplusplus
(tPosition ppos, tIdent pident)
#else
(ppos, pident)
tPosition ppos;
tIdent pident;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yident));
 Tree_InitHead (yyt, kident)
 yyt->ident.pos = ppos;
 begintTree(yyt->ident.env)
 begintTree(yyt->ident.object)
 yyt->ident.ident = pident;
 return yyt;
}

tTree mnoexpression
#if defined __STDC__ | defined __cplusplus
(tPosition ppos)
#else
(ppos)
tPosition ppos;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ynoexpression));
 Tree_InitHead (yyt, knoexpression)
 yyt->noexpression.pos = ppos;
 begintTree(yyt->noexpression.env)
 begintTree(yyt->noexpression.object)
 return yyt;
}

tTree munary
#if defined __STDC__ | defined __cplusplus
(tPosition ppos, tTree pexpression, toperator poperator)
#else
(ppos, pexpression, poperator)
tPosition ppos;
tTree pexpression;
toperator poperator;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yunary));
 Tree_InitHead (yyt, kunary)
 yyt->unary.pos = ppos;
 begintTree(yyt->unary.env)
 yyt->unary.expression = pexpression;
 yyt->unary.operator = poperator;
 return yyt;
}

tTree mbinary
#if defined __STDC__ | defined __cplusplus
(tPosition ppos, tTree plop, tTree prop, toperator poperator)
#else
(ppos, plop, prop, poperator)
tPosition ppos;
tTree plop;
tTree prop;
toperator poperator;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ybinary));
 Tree_InitHead (yyt, kbinary)
 yyt->binary.pos = ppos;
 begintTree(yyt->binary.env)
 yyt->binary.lop = plop;
 yyt->binary.rop = prop;
 yyt->binary.operator = poperator;
 return yyt;
}

tTree massign
#if defined __STDC__ | defined __cplusplus
(tPosition ppos, tTree plval, tTree prval, toperator poperator)
#else
(ppos, plval, prval, poperator)
tPosition ppos;
tTree plval;
tTree prval;
toperator poperator;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yassign));
 Tree_InitHead (yyt, kassign)
 yyt->assign.pos = ppos;
 begintTree(yyt->assign.env)
 yyt->assign.lval = plval;
 yyt->assign.rval = prval;
 yyt->assign.operator = poperator;
 return yyt;
}

tTree maggregate
#if defined __STDC__ | defined __cplusplus
(tPosition ppos, tTree pexpression_list)
#else
(ppos, pexpression_list)
tPosition ppos;
tTree pexpression_list;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yaggregate));
 Tree_InitHead (yyt, kaggregate)
 yyt->aggregate.pos = ppos;
 begintTree(yyt->aggregate.env)
 yyt->aggregate.expression_list = pexpression_list;
 return yyt;
}

tTree mcall
#if defined __STDC__ | defined __cplusplus
(tPosition ppos, tTree pexpression, tTree pexpression_list)
#else
(ppos, pexpression, pexpression_list)
tPosition ppos;
tTree pexpression;
tTree pexpression_list;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ycall));
 Tree_InitHead (yyt, kcall)
 yyt->call.pos = ppos;
 begintTree(yyt->call.env)
 yyt->call.expression = pexpression;
 yyt->call.expression_list = pexpression_list;
 return yyt;
}

tTree mselect
#if defined __STDC__ | defined __cplusplus
(tPosition ppos, tTree pexpression, tIdent pident)
#else
(ppos, pexpression, pident)
tPosition ppos;
tTree pexpression;
tIdent pident;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yselect));
 Tree_InitHead (yyt, kselect)
 yyt->select.pos = ppos;
 begintTree(yyt->select.env)
 yyt->select.expression = pexpression;
 yyt->select.ident = pident;
 return yyt;
}

tTree mget_class_of_expr
#if defined __STDC__ | defined __cplusplus
(tPosition ppos, tTree pexpression)