tree.c

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

#else
(ppos, pexpression)
tPosition ppos;
tTree pexpression;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yget_class_of_expr));
 Tree_InitHead (yyt, kget_class_of_expr)
 yyt->get_class_of_expr.pos = ppos;
 begintTree(yyt->get_class_of_expr.env)
 yyt->get_class_of_expr.expression = pexpression;
 return yyt;
}

tTree mget_class
#if defined __STDC__ | defined __cplusplus
(tPosition ppos, tTree ptype)
#else
(ppos, ptype)
tPosition ppos;
tTree ptype;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yget_class));
 Tree_InitHead (yyt, kget_class)
 yyt->get_class.pos = ppos;
 begintTree(yyt->get_class.env)
 yyt->get_class.type = ptype;
 return yyt;
}

tTree msubscript
#if defined __STDC__ | defined __cplusplus
(tPosition ppos, tTree pbase, tTree pindex)
#else
(ppos, pbase, pindex)
tPosition ppos;
tTree pbase;
tTree pindex;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ysubscript));
 Tree_InitHead (yyt, ksubscript)
 yyt->subscript.pos = ppos;
 begintTree(yyt->subscript.env)
 yyt->subscript.base = pbase;
 yyt->subscript.index = pindex;
 return yyt;
}

tTree mtype_compare
#if defined __STDC__ | defined __cplusplus
(tPosition ppos, tTree pexpression, tTree ptype)
#else
(ppos, pexpression, ptype)
tPosition ppos;
tTree pexpression;
tTree ptype;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ytype_compare));
 Tree_InitHead (yyt, ktype_compare)
 yyt->type_compare.pos = ppos;
 begintTree(yyt->type_compare.env)
 yyt->type_compare.expression = pexpression;
 yyt->type_compare.type = ptype;
 return yyt;
}

tTree mtype_cast
#if defined __STDC__ | defined __cplusplus
(tPosition ppos, tTree ptype, tTree pdims, tTree pexpression)
#else
(ppos, ptype, pdims, pexpression)
tPosition ppos;
tTree ptype;
tTree pdims;
tTree pexpression;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ytype_cast));
 Tree_InitHead (yyt, ktype_cast)
 yyt->type_cast.pos = ppos;
 begintTree(yyt->type_cast.env)
 yyt->type_cast.type = ptype;
 yyt->type_cast.dims = pdims;
 yyt->type_cast.expression = pexpression;
 return yyt;
}

tTree mnew
#if defined __STDC__ | defined __cplusplus
(tPosition ppos, tTree ptype, tTree pdims, tTree pexpression_list, tTree pexpression)
#else
(ppos, ptype, pdims, pexpression_list, pexpression)
tPosition ppos;
tTree ptype;
tTree pdims;
tTree pexpression_list;
tTree pexpression;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ynew));
 Tree_InitHead (yyt, knew)
 yyt->new.pos = ppos;
 begintTree(yyt->new.env)
 yyt->new.type = ptype;
 yyt->new.dims = pdims;
 yyt->new.expression_list = pexpression_list;
 yyt->new.expression = pexpression;
 return yyt;
}

tTree manonymous
#if defined __STDC__ | defined __cplusplus
(tPosition ppos, tTree ptype, tTree pexpression_list, tTree pblock)
#else
(ppos, ptype, pexpression_list, pblock)
tPosition ppos;
tTree ptype;
tTree pexpression_list;
tTree pblock;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yanonymous));
 Tree_InitHead (yyt, kanonymous)
 yyt->anonymous.pos = ppos;
 begintTree(yyt->anonymous.env)
 yyt->anonymous.type = ptype;
 yyt->anonymous.expression_list = pexpression_list;
 yyt->anonymous.block = pblock;
 return yyt;
}

tTree mconditional
#if defined __STDC__ | defined __cplusplus
(tPosition ppos, tTree pcondition, tTree ptrue_expr, tTree pfalse_expr)
#else
(ppos, pcondition, ptrue_expr, pfalse_expr)
tPosition ppos;
tTree pcondition;
tTree ptrue_expr;
tTree pfalse_expr;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yconditional));
 Tree_InitHead (yyt, kconditional)
 yyt->conditional.pos = ppos;
 begintTree(yyt->conditional.env)
 yyt->conditional.condition = pcondition;
 yyt->conditional.true_expr = ptrue_expr;
 yyt->conditional.false_expr = pfalse_expr;
 return yyt;
}

tTree msuper
#if defined __STDC__ | defined __cplusplus
(tPosition ppos)
#else
(ppos)
tPosition ppos;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ysuper));
 Tree_InitHead (yyt, ksuper)
 yyt->super.pos = ppos;
 begintTree(yyt->super.env)
 return yyt;
}

tTree mthis
#if defined __STDC__ | defined __cplusplus
(tPosition ppos)
#else
(ppos)
tPosition ppos;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ythis));
 Tree_InitHead (yyt, kthis)
 yyt->this.pos = ppos;
 begintTree(yyt->this.env)
 return yyt;
}

tTree mnull
#if defined __STDC__ | defined __cplusplus
(tPosition ppos)
#else
(ppos)
tPosition ppos;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ynull));
 Tree_InitHead (yyt, knull)
 yyt->null.pos = ppos;
 begintTree(yyt->null.env)
 return yyt;
}

tTree mint_literal
#if defined __STDC__ | defined __cplusplus
(tPosition ppos, long pvalue)
#else
(ppos, pvalue)
tPosition ppos;
long pvalue;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yint_literal));
 Tree_InitHead (yyt, kint_literal)
 yyt->int_literal.pos = ppos;
 begintTree(yyt->int_literal.env)
 yyt->int_literal.value = pvalue;
 return yyt;
}

tTree mlong_literal
#if defined __STDC__ | defined __cplusplus
(tPosition ppos, long pvalue)
#else
(ppos, pvalue)
tPosition ppos;
long pvalue;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ylong_literal));
 Tree_InitHead (yyt, klong_literal)
 yyt->long_literal.pos = ppos;
 begintTree(yyt->long_literal.env)
 yyt->long_literal.value = pvalue;
 return yyt;
}

tTree mbool_literal
#if defined __STDC__ | defined __cplusplus
(tPosition ppos, rbool pvalue)
#else
(ppos, pvalue)
tPosition ppos;
rbool pvalue;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ybool_literal));
 Tree_InitHead (yyt, kbool_literal)
 yyt->bool_literal.pos = ppos;
 begintTree(yyt->bool_literal.env)
 yyt->bool_literal.value = pvalue;
 return yyt;
}

tTree mfloat_literal
#if defined __STDC__ | defined __cplusplus
(tPosition ppos, tStringRef pvalue)
#else
(ppos, pvalue)
tPosition ppos;
tStringRef pvalue;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yfloat_literal));
 Tree_InitHead (yyt, kfloat_literal)
 yyt->float_literal.pos = ppos;
 begintTree(yyt->float_literal.env)
 yyt->float_literal.value = pvalue;
 return yyt;
}

tTree mchar_literal
#if defined __STDC__ | defined __cplusplus
(tPosition ppos, tStringRef pvalue)
#else
(ppos, pvalue)
tPosition ppos;
tStringRef pvalue;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ychar_literal));
 Tree_InitHead (yyt, kchar_literal)
 yyt->char_literal.pos = ppos;
 begintTree(yyt->char_literal.env)
 yyt->char_literal.value = pvalue;
 return yyt;
}

tTree mstring_literal
#if defined __STDC__ | defined __cplusplus
(tPosition ppos, tStringRef pvalue)
#else
(ppos, pvalue)
tPosition ppos;
tStringRef pvalue;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ystring_literal));
 Tree_InitHead (yyt, kstring_literal)
 yyt->string_literal.pos = ppos;
 begintTree(yyt->string_literal.env)
 yyt->string_literal.value = pvalue;
 return yyt;
}

tTree menvs
#if defined __STDC__ | defined __cplusplus
(void)
#else
()
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yenvs));
 Tree_InitHead (yyt, kenvs)
 return yyt;
}

tTree menv
#if defined __STDC__ | defined __cplusplus
(tTree pobjects, tTree penv, tTree pobject, tHashTable pHashTable, int pHashSize)
#else
(pobjects, penv, pobject, pHashTable, pHashSize)
tTree pobjects;
tTree penv;
tTree pobject;
tHashTable pHashTable;
int pHashSize;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yenv));
 Tree_InitHead (yyt, kenv)
 yyt->env.objects = pobjects;
 yyt->env.env = penv;
 yyt->env.object = pobject;
 yyt->env.HashTable = pHashTable;
 yyt->env.HashSize = pHashSize;
 return yyt;
}

tTree menv2
#if defined __STDC__ | defined __cplusplus
(tTree penv1, tTree penv2)
#else
(penv1, penv2)
tTree penv1;
tTree penv2;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yenv2));
 Tree_InitHead (yyt, kenv2)
 yyt->env2.env1 = penv1;
 yyt->env2.env2 = penv2;
 return yyt;
}

tTree mobjects
#if defined __STDC__ | defined __cplusplus
(void)
#else
()
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yobjects));
 Tree_InitHead (yyt, kobjects)
 return yyt;
}

tTree mobject
#if defined __STDC__ | defined __cplusplus
(tTree pobject, tIdent pident, tTree pnext)
#else
(pobject, pident, pnext)
tTree pobject;
tIdent pident;
tTree pnext;
#endif
{
 register tTree yyt = yyALLOCt (sizeof (yobject));
 Tree_InitHead (yyt, kobject)
 yyt->object.object = pobject;
 yyt->object.ident = pident;
 yyt->object.next = pnext;
 begintTree(yyt->object.collision)
 return yyt;
}

tTree mnoobject
#if defined __STDC__ | defined __cplusplus
(void)
#else
()
#endif
{
 register tTree yyt = yyALLOCt (sizeof (ynoobject));
 Tree_InitHead (yyt, knoobject)
 return yyt;
}

static FILE * yyf;

static void yyMark
#if defined __STDC__ | defined __cplusplus
 (register tTree yyt)
#else
 (yyt) register tTree yyt;
#endif
{
 for (;;) {
  if (yyt == NoTree || ++ yyt->yyHead.yyMark > 1) return;

  switch (yyt->Kind) {
case kcompilation_unit:
yyMark (yyt->compilation_unit.package);
yyMark (yyt->compilation_unit.import_list);
yyt = yyt->compilation_unit.field_list; break;
case kimport:
yyMark (yyt->import.qualified_symbol);
yyt = yyt->import.next; break;
case kimport_asterisk:
yyMark (yyt->import_asterisk.qualified_symbol);
yyt = yyt->import_asterisk.next; break;
case kfield:
yyt = yyt->field.next; break;
case kfunction:
yyMark (yyt->function.decl_list);
yyMark (yyt->function.throws);
yyMark (yyt->function.block);
yyt = yyt->function.next; break;
case kmethod:
yyMark (yyt->method.decl_list);
yyMark (yyt->method.throws);
yyMark (yyt->method.block);
yyMark (yyt->method.type);
yyMark (yyt->method.array);
yyt = yyt->method.next; break;
case kconstructor:
yyMark (yyt->constructor.decl_list);
yyMark (yyt->constructor.throws);
yyMark (yyt->constructor.block);
yyt = yyt->constructor.next; break;
case kvar_decl:
yyMark (yyt->var_decl.type);
yyMark (yyt->var_decl.decl_list);
yyt = yyt->var_decl.next; break;
case kstatic_initializer:
yyMark (yyt->static_initializer.statement_c);
yyt = yyt->static_initializer.next; break;
case kinitializer:
yyMark (yyt->initializer.statement_c);
yyt = yyt->initializer.next; break;
case ktype_decl:
yyMark (yyt->type_decl.block);
yyt = yyt->type_decl.next; break;
case kclass:
yyMark (yyt->class.block);
yyMark (yyt->class.extends);
yyMark (yyt->class.interfaces);
yyt = yyt->class.next; break;
case kinterface:
yyMark (yyt->my_interface.block);
yyMark (yyt->my_interface.extends);
yyt = yyt->my_interface.next; break;
case kdecl:
yyMark (yyt->decl.type);
yyMark (yyt->decl.array);
yyt = yyt->decl.next; break;
case kvariable:
yyMark (yyt->variable.type);
yyMark (yyt->variable.array);
yyMark (yyt->variable.expression);
yyt = yyt->variable.next; break;
case kparameter:
yyMark (yyt->parameter.type);
yyMark (yyt->parameter.array);
yyt = yyt->parameter.next; break;
case kstatement:
yyMark (yyt->statement.statement);
yyt = yyt->statement.next; break;
case kcompound_stmt:
yyt = yyt->compound_stmt.statement_list; break;
case kexpression_stmt:
yyt = yyt->expression_stmt.expression; break;
case kvar_decl_stmt:
yyMark (yyt->var_decl_stmt.type);
yyt = yyt->var_decl_stmt.decl_list; break;
case ktype_decl_stmt:
yyt = yyt->type_decl_stmt.type_decl; break;
case kif_stmt:
yyMark (yyt->if_stmt.expression);
yyt = yyt->if_stmt.then; break;
case kif_else_stmt:
yyMark (yyt->if_else_stmt.expression);
yyMark (yyt->if_else_stmt.then);
yyt = yyt->if_else_stmt.Else; break;
case kwhile_stmt:
yyMark (yyt->while_stmt.expression);
yyt = yyt->while_stmt.statement; break;
case kdo_stmt:
yyMark (yyt->do_stmt.statement);
yyt = yyt->do_stmt.expression; break;
case kbreak_id_stmt:
yyt = yyt->break_id_stmt.expression; break;
case kcontinue_id_stmt:
yyt = yyt->continue_id_stmt.expression; break;
case kreturn_expr_stmt:
yyt = yyt->return_expr_stmt.expression; break;
case kfor_stmt:
yyMark (yyt->for_stmt.for_init);
yyMark (yyt->for_stmt.expression);
yyMark (yyt->for_stmt.for_incr);
yyt = yyt->for_stmt.statement; break;
case kthrow_stmt:
yyt = yyt->throw_stmt.expression; break;
case ksynchronized_stmt:
yyMark (yyt->synchronized_stmt.expression);
yyt = yyt->synchronized_stmt.statement; break;
case klabeled_stmt:
yyt = yyt->labeled_stmt.statement; break;
case ktry_stmt:
yyMark (yyt->try_stmt.statement);
yyMark (yyt->try_stmt.catch_list);
yyt = yyt->try_stmt.finally; break;
case kswitch_stmt:
yyMark (yyt->switch_stmt.expression);
yyt = yyt->switch_stmt.switch_list; break;
case kswitch_:
yyMark (yyt->switch_.expression_list);
yyMark (yyt->switch_.statement_list);
yyt = yyt->switch_.next; break;
case kcatch:
yyMark (yyt->catch.decl_list);
yyMark (yyt->catch.statement);
yyt = yyt->catch.next; break;
case ktype_name:
yyMark (yyt->type_name.named_type);
yyt = yyt->type_name.next; break;
case knamed_type:
yyt = yyt->named_type.qualified_symbol; break;
case karray_type:
yyt = yyt->array_type.type; break;
case kexpression:
yyMark (yyt->expression.expression);
yyt = yyt->expression.next; break;
case kqualification:
yyt = yyt->qualification.qualified_symbol; break;
case kunary:
yyt = yyt->unary.expression; break;
case kbinary:
yyMark (yyt->binary.lop);
yyt = yyt->binary.rop; break;
case kassign:
yyMark (yyt->assign.lval);
yyt = yyt->assign.rval; break;
case kaggregate:
yyt = yyt->aggregate.expression_list; break;
case kcall:
yyMark (yyt->call.expression);
yyt = yyt->call.expression_list; break;
case kselect:
yyt = yyt->select.expression; break;
case kget_class_of_expr:
yyt = yyt->get_class_of_expr.expression; break;
case kget_class:
yyt = yyt->get_class.type; break;
case ksubscript:
yyMark (yyt->subscript.base);
yyt = yyt->subscript.index; break;
case ktype_compare:
yyMark (yyt->type_compare.expression);
yyt = yyt->type_compare.type; break;
case ktype_cast:
yyMark (yyt->type_cast.type);
yyMark (yyt->type_cast.dims);
yyt = yyt->type_cast.expression; break;
case knew:
yyMark (yyt->new.type);
yyMark (yyt->new.dims);
yyMark (yyt->new.expression_list);
yyt = yyt->new.expression; break;
case kanonymous:
yyMark (yyt->anonymous.type);
yyMark (yyt->anonymous.expression_list);
yyt = yyt->anonymous.block; break;
case kconditional:
yyMark (yyt->conditional.condition);
yyMark (yyt->conditional.true_expr);
yyt = yyt->conditional.false_expr; break;
case kenv:
yyMark (yyt->env.objects);
yyt = yyt->env.env; break;
case kenv2:
yyMark (yyt->env2.env1);
yyt = yyt->env2.env2; break;
case kobject: