tree.c

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

#else
 (yyt) tTree yyt;
#endif
{
 yWriteNodeword_c (yyt);
 yyWriteSelector ("qualification");
 yyWriteAdr (yyt->qual_word.qualification);
}

static void yWriteNodequal_words
#if defined __STDC__ | defined __cplusplus
 (tTree yyt)
#else
 (yyt) tTree yyt;
#endif
{
 yWriteNodeword_c (yyt);
 yyWriteSelector ("qualifications");
 yyWriteAdr (yyt->qual_words.qualifications);
}

static void yWriteNodequalifications
#if defined __STDC__ | defined __cplusplus
 (tTree yyt)
#else
 (yyt) tTree yyt;
#endif
{
 yyWriteSelector ("env");
 writetTree (yyt->qualifications.env) yyWriteNl ();
}

static void yWriteNodenoqualification
#if defined __STDC__ | defined __cplusplus
 (tTree yyt)
#else
 (yyt) tTree yyt;
#endif
{
 yWriteNodequalifications (yyt);
}

static void yWriteNodeone_qualification
#if defined __STDC__ | defined __cplusplus
 (tTree yyt)
#else
 (yyt) tTree yyt;
#endif
{
 yWriteNodequalifications (yyt);
 yyWriteSelector ("next");
 yyWriteAdr (yyt->one_qualification.next);
 yyWriteSelector ("qualification");
 yyWriteAdr (yyt->one_qualification.qualification);
}

static void yWriteNodetexts
#if defined __STDC__ | defined __cplusplus
 (tTree yyt)
#else
 (yyt) tTree yyt;
#endif
{
 yyWriteSelector ("env");
 writetTree (yyt->texts.env) yyWriteNl ();
}

static void yWriteNodenotext
#if defined __STDC__ | defined __cplusplus
 (tTree yyt)
#else
 (yyt) tTree yyt;
#endif
{
 yWriteNodetexts (yyt);
}

static void yWriteNodetext
#if defined __STDC__ | defined __cplusplus
 (tTree yyt)
#else
 (yyt) tTree yyt;
#endif
{
 yWriteNodetexts (yyt);
 yyWriteSelector ("next");
 yyWriteAdr (yyt->text.next);
 yyWriteSelector ("pos");
 writetPosition (yyt->text.pos) yyWriteNl ();
}

static void yWriteNodecharacter
#if defined __STDC__ | defined __cplusplus
 (tTree yyt)
#else
 (yyt) tTree yyt;
#endif
{
 yWriteNodetext (yyt);
 yyWriteSelector ("text");
 writechar (yyt->character.text) yyWriteNl ();
}

static void yWriteNodeident
#if defined __STDC__ | defined __cplusplus
 (tTree yyt)
#else
 (yyt) tTree yyt;
#endif
{
 yWriteNodetext (yyt);
 yyWriteSelector ("ident");
 writetIdent (yyt->ident.ident) yyWriteNl ();
}

static void yWriteNodeblock
#if defined __STDC__ | defined __cplusplus
 (tTree yyt)
#else
 (yyt) tTree yyt;
#endif
{
 yWriteNodetext (yyt);
 yyWriteSelector ("epos");
 writetPosition (yyt->block.epos) yyWriteNl ();
 yyWriteSelector ("stmts");
 yyWriteAdr (yyt->block.stmts);
 yyWriteSelector ("type");
 writechar (yyt->block.type) yyWriteNl ();
}

static void yWriteNodecontent
#if defined __STDC__ | defined __cplusplus
 (tTree yyt)
#else
 (yyt) tTree yyt;
#endif
{
 yWriteNodetext (yyt);
 yyWriteSelector ("qualification");
 yyWriteAdr (yyt->content.qualification);
}

static void yWriteNodeblock_content
#if defined __STDC__ | defined __cplusplus
 (tTree yyt)
#else
 (yyt) tTree yyt;
#endif
{
 yWriteNodetext (yyt);
 yyWriteSelector ("epos");
 writetPosition (yyt->block_content.epos) yyWriteNl ();
 yyWriteSelector ("stmts");
 yyWriteAdr (yyt->block_content.stmts);
}

static void yWriteNodequalification_c
#if defined __STDC__ | defined __cplusplus
 (tTree yyt)
#else
 (yyt) tTree yyt;
#endif
{
 yyWriteSelector ("pos");
 writetPosition (yyt->qualification_c.pos) yyWriteNl ();
 yyWriteSelector ("env");
 writetTree (yyt->qualification_c.env) yyWriteNl ();
}

static void yWriteNodelocal_ident
#if defined __STDC__ | defined __cplusplus
 (tTree yyt)
#else
 (yyt) tTree yyt;
#endif
{
 yWriteNodequalification_c (yyt);
 yyWriteSelector ("ident");
 writetIdent (yyt->local_ident.ident) yyWriteNl ();
}

static void yWriteNodeglobal_ident
#if defined __STDC__ | defined __cplusplus
 (tTree yyt)
#else
 (yyt) tTree yyt;
#endif
{
 yWriteNodequalification_c (yyt);
 yyWriteSelector ("ident");
 writetIdent (yyt->global_ident.ident) yyWriteNl ();
}

static void yWriteNodelocal_text
#if defined __STDC__ | defined __cplusplus
 (tTree yyt)
#else
 (yyt) tTree yyt;
#endif
{
 yWriteNodequalification_c (yyt);
 yyWriteSelector ("texts");
 yyWriteAdr (yyt->local_text.texts);
}

static void yWriteNodeglobal_text
#if defined __STDC__ | defined __cplusplus
 (tTree yyt)
#else
 (yyt) tTree yyt;
#endif
{
 yWriteNodequalification_c (yyt);
 yyWriteSelector ("texts");
 yyWriteAdr (yyt->global_text.texts);
}

static void yWriteNodequalification
#if defined __STDC__ | defined __cplusplus
 (tTree yyt)
#else
 (yyt) tTree yyt;
#endif
{
 yWriteNodequalification_c (yyt);
 yyWriteSelector ("qualification");
 yyWriteAdr (yyt->qualification.qualification);
 yyWriteSelector ("ident");
 writetIdent (yyt->qualification.ident) yyWriteNl ();
}

static void yWriteNodecomplex_qual
#if defined __STDC__ | defined __cplusplus
 (tTree yyt)
#else
 (yyt) tTree yyt;
#endif
{
 yWriteNodequalification_c (yyt);
 yyWriteSelector ("qualification");
 yyWriteAdr (yyt->complex_qual.qualification);
 yyWriteSelector ("texts");
 yyWriteAdr (yyt->complex_qual.texts);
}

static void yWriteNodesubscription
#if defined __STDC__ | defined __cplusplus
 (tTree yyt)
#else
 (yyt) tTree yyt;
#endif
{
 yWriteNodequalification_c (yyt);
 yyWriteSelector ("qualification");
 yyWriteAdr (yyt->subscription.qualification);
 yyWriteSelector ("index");
 yyWriteAdr (yyt->subscription.index);
}

static void yWriteNodeenv
#if defined __STDC__ | defined __cplusplus
 (tTree yyt)
#else
 (yyt) tTree yyt;
#endif
{
 yyWriteSelector ("objects");
 yyWriteAdr (yyt->env.objects);
 yyWriteSelector ("env");
 yyWriteAdr (yyt->env.env);
 yyWriteSelector ("object");
 writetTree (yyt->env.object) yyWriteNl ();
 yyWriteSelector ("HashTable");
 writetHashTable (yyt->env.HashTable) yyWriteNl ();
 yyWriteSelector ("HashSize");
 writeint (yyt->env.HashSize) yyWriteNl ();
}

static void yWriteNodeenv2
#if defined __STDC__ | defined __cplusplus
 (tTree yyt)
#else
 (yyt) tTree yyt;
#endif
{
 yyWriteSelector ("env1");
 yyWriteAdr (yyt->env2.env1);
 yyWriteSelector ("env2");
 yyWriteAdr (yyt->env2.env2);
}

static void yWriteNodeobject
#if defined __STDC__ | defined __cplusplus
 (tTree yyt)
#else
 (yyt) tTree yyt;
#endif
{
 yyWriteSelector ("object");
 writetTree (yyt->object.object) yyWriteNl ();
 yyWriteSelector ("ident");
 writetIdent (yyt->object.ident) yyWriteNl ();
 yyWriteSelector ("next");
 yyWriteAdr (yyt->object.next);
}

void WriteTreeNode
#if defined __STDC__ | defined __cplusplus
 (FILE * yyyf, tTree yyt)
#else
 (yyyf, yyt) FILE * yyyf; tTree yyt;
#endif
{
 yyf = yyyf;
 if (yyt == NoTree) { (void) fputs ("NoTree\n", yyf); return; }

 (void) fputs (Tree_NodeName [yyt->Kind], yyf); (void) fputc ('\n', yyf);
 writeNodeHead (yyt)
 switch (yyt->Kind) {
case kprogram:
 yWriteNodeprogram (yyt); break;
case kstmts:
 yWriteNodestmts (yyt); break;
case knostmt:
 yWriteNodenostmt (yyt); break;
case kstmt_c:
 yWriteNodestmt_c (yyt); break;
case kstmt:
 yWriteNodestmt (yyt); break;
case kproc_c:
 yWriteNodeproc_c (yyt); break;
case kproc:
 yWriteNodeproc (yyt); break;
case kmethod:
 yWriteNodemethod (yyt); break;
case kbody:
 yWriteNodebody (yyt); break;
case kconfigbody:
 yWriteNodeconfigbody (yyt); break;
case kconstructor:
 yWriteNodeconstructor (yyt); break;
case kdestructor:
 yWriteNodedestructor (yyt); break;
case knamespace_c:
 yWriteNodenamespace_c (yyt); break;
case knamespace:
 yWriteNodenamespace (yyt); break;
case kclass:
 yWriteNodeclass (yyt); break;
case kitcl_class:
 yWriteNodeitcl_class (yyt); break;
case kwords:
 yWriteNodewords (yyt); break;
case knoword:
 yWriteNodenoword (yyt); break;
case kword_c:
 yWriteNodeword_c (yyt); break;
case kone_word:
 yWriteNodeone_word (yyt); break;
case kobj_word:
 yWriteNodeobj_word (yyt); break;
case kqual_word:
 yWriteNodequal_word (yyt); break;
case kqual_words:
 yWriteNodequal_words (yyt); break;
case kqualifications:
 yWriteNodequalifications (yyt); break;
case knoqualification:
 yWriteNodenoqualification (yyt); break;
case kone_qualification:
 yWriteNodeone_qualification (yyt); break;
case ktexts:
 yWriteNodetexts (yyt); break;
case knotext:
 yWriteNodenotext (yyt); break;
case ktext:
 yWriteNodetext (yyt); break;
case kcharacter:
 yWriteNodecharacter (yyt); break;
case kident:
 yWriteNodeident (yyt); break;
case kblock:
 yWriteNodeblock (yyt); break;
case kcontent:
 yWriteNodecontent (yyt); break;
case kblock_content:
 yWriteNodeblock_content (yyt); break;
case kqualification_c:
 yWriteNodequalification_c (yyt); break;
case klocal_ident:
 yWriteNodelocal_ident (yyt); break;
case kglobal_ident:
 yWriteNodeglobal_ident (yyt); break;
case klocal_text:
 yWriteNodelocal_text (yyt); break;
case kglobal_text:
 yWriteNodeglobal_text (yyt); break;
case kqualification:
 yWriteNodequalification (yyt); break;
case kcomplex_qual:
 yWriteNodecomplex_qual (yyt); break;
case ksubscription:
 yWriteNodesubscription (yyt); break;
case kenv:
 yWriteNodeenv (yyt); break;
case kenv2:
 yWriteNodeenv2 (yyt); break;
case kobject:
 yWriteNodeobject (yyt); break;
 default: ;
 }
}

#define yyNil	(unsigned char) 0374
#define yyNoLabel	(unsigned char) 0375
#define yyLabelDef	(unsigned char) 0376
#define yyLabelUse	(unsigned char) 0377

void ReleaseTreeModule ARGS ((void))
{
 yytTree_BlockPtr yyBlockPtr;
 while (Tree_BlockList != (yytTree_BlockPtr) NoTree) {
  yyBlockPtr = Tree_BlockList;
  Tree_BlockList = Tree_BlockList->yySuccessor;
  Free ((unsigned long) sizeof (yytTree_Block), (char *) yyBlockPtr);
 }
 Tree_PoolFreePtr = (char *) & Tree_BlockList;
 Tree_PoolStartPtr = (char *) & Tree_BlockList;
 Tree_HeapUsed = 0;
}

static Tree_tProcTree yyProc;

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

  switch (yyt->Kind) {
case kprogram:
yyt = yyt->program.stmts; break;
case kstmt_c:
yyt = yyt->stmt_c.next; break;
case kstmt:
yyTraverseTreeTD (yyt->stmt.words);
yyt = yyt->stmt.next; break;
case kproc_c:
yyTraverseTreeTD (yyt->proc_c.qualification);
yyTraverseTreeTD (yyt->proc_c.param_names);
yyTraverseTreeTD (yyt->proc_c.parameter);
yyTraverseTreeTD (yyt->proc_c.block);
yyt = yyt->proc_c.next; break;
case kproc:
yyTraverseTreeTD (yyt->proc.qualification);
yyTraverseTreeTD (yyt->proc.param_names);
yyTraverseTreeTD (yyt->proc.parameter);
yyTraverseTreeTD (yyt->proc.block);
yyt = yyt->proc.next; break;
case kmethod:
yyTraverseTreeTD (yyt->method.qualification);
yyTraverseTreeTD (yyt->method.param_names);
yyTraverseTreeTD (yyt->method.parameter);
yyTraverseTreeTD (yyt->method.block);
yyt = yyt->method.next; break;
case kbody:
yyTraverseTreeTD (yyt->body.qualification);
yyTraverseTreeTD (yyt->body.param_names);
yyTraverseTreeTD (yyt->body.parameter);
yyTraverseTreeTD (yyt->body.block);
yyt = yyt->body.next; break;
case kconfigbody:
yyTraverseTreeTD (yyt->configbody.qualification);
yyTraverseTreeTD (yyt->configbody.param_names);
yyTraverseTreeTD (yyt->configbody.parameter);
yyTraverseTreeTD (yyt->configbody.block);
yyt = yyt->configbody.next; break;
case kconstructor:
yyTraverseTreeTD (yyt->constructor.qualification);
yyTraverseTreeTD (yyt->constructor.param_names);
yyTraverseTreeTD (yyt->constructor.parameter);
yyTraverseTreeTD (yyt->constructor.block);
yyTraverseTreeTD (yyt->constructor.init);
yyt = yyt->constructor.next; break;
case kdestructor:
yyTraverseTreeTD (yyt->destructor.qualification);
yyTraverseTreeTD (yyt->destructor.param_names);
yyTraverseTreeTD (yyt->destructor.parameter);
yyTraverseTreeTD (yyt->destructor.block);
yyt = yyt->destructor.next; break;
case knamespace_c:
yyTraverseTreeTD (yyt->namespace_c.qualification);
yyTraverseTreeTD (yyt->namespace_c.block);
yyt = yyt->namespace_c.next; break;
case knamespace:
yyTraverseTreeTD (yyt->namespace.qualification);
yyTraverseTreeTD (yyt->namespace.block);
yyt = yyt->namespace.next; break;
case kclass:
yyTraverseTreeTD (yyt->class.qualification);
yyTraverseTreeTD (yyt->class.block);
yyt = yyt->class.next; break;
case kitcl_class:
yyTraverseTreeTD (yyt->itcl_class.qualification);
yyTraverseTreeTD (yyt->itcl_class.block);
yyt = yyt->itcl_class.next; break;
case kword_c:
yyt = yyt->word_c.next; break;
case kone_word:
yyt = yyt->one_word.next; break;
case kobj_word:
yyt = yyt->obj_word.next; break;
case kqual_word:
yyTraverseTreeTD (yyt->qual_word.qualification);
yyt = yyt->qual_word.next; break;
case kqual_words:
yyTraverseTreeTD (yyt->qual_words.qualifications);
yyt = yyt->qual_words.next; break;
case kone_qualification:
yyTraverseTreeTD (yyt->one_qualification.qualification);
yyt = yyt->one_qualification.next; break;
case ktext:
yyt = yyt->text.next; break;
case kcharacter:
yyt = yyt->character.next; break;
case kident:
yyt = yyt->ident.next; break;
case kblock:
yyTraverseTreeTD (yyt->block.stmts);
yyt = yyt->block.next; break;
case kcontent:
yyTraverseTreeTD (yyt->content.qualification);
yyt = yyt->content.next; break;
case kblock_content: