symbol.cpp

c语言的简化编译器

    sym1PassEXP(e->val.nequalsE.right, sym);    
    break;
  case lessK:
    sym1PassEXP(e->val.lessE.left, sym);
    sym1PassEXP(e->val.lessE.right, sym);    
    break;
  case greaterK:
    sym1PassEXP(e->val.greaterE.left, sym);
    sym1PassEXP(e->val.greaterE.right, sym);    
    break;
  case lequalsK:
    sym1PassEXP(e->val.lequalsE.left, sym);
    sym1PassEXP(e->val.lequalsE.right, sym);    
    break;
  case gequalsK:
    sym1PassEXP(e->val.gequalsE.left, sym);
    sym1PassEXP(e->val.gequalsE.right, sym);    
    break;
  case plusK:
    sym1PassEXP(e->val.plusE.left, sym);
    sym1PassEXP(e->val.plusE.right, sym);    
    break;
  case minusK:
    sym1PassEXP(e->val.minusE.left, sym);
    sym1PassEXP(e->val.minusE.right, sym);    
    break;
  case multK:
    sym1PassEXP(e->val.multE.left, sym);
    sym1PassEXP(e->val.multE.right, sym);    
    break;
  case divK:
    sym1PassEXP(e->val.divE.left, sym);
    sym1PassEXP(e->val.divE.right, sym);    
    break;
  case moduloK:
    sym1PassEXP(e->val.moduloE.left, sym);
    sym1PassEXP(e->val.moduloE.right, sym);    
    break;
  case andK:
    sym1PassEXP(e->val.andE.left, sym);
    sym1PassEXP(e->val.andE.right, sym);    
    break;
  case orK:
    sym1PassEXP(e->val.orE.left, sym);
    sym1PassEXP(e->val.orE.right, sym);    
    break;
  case callK:
    /* function name check is in 2nd pass */
    if (e->val.callE.arguments != NULL) 
      sym1PassEXP(e->val.callE.arguments, sym);    
    break;
  case castK:
    sym1PassEXP(e->val.castE.exp, sym);   
    break;
  } /* end switch */
  
  if (e->next != NULL)
    sym1PassEXP(e->next, sym);

}


void sym1PassLVALUE(LVALUE *l, SymbolTable *sym) 
{
  SYMBOL *symbol;
  switch(l->kind) {
  case idK:
    symbol = getSymbol(sym, l->val.idL);
    if (symbol == NULL)
      reportError(l->lineno, "Variable '%s' is referenced but not defined", l->val.idL);    
    else {
      if (symbol->kind != declSym)
	reportError(l->lineno, "Identifier '%s' is not a variable", 
		    l->val.idL);
      else { 
	l->symbol = symbol;
  
	/* Set the modifier: */
	if (l->symbol->val.declS->kind == variableK)
	  l->modifier = l->symbol->val.declS->val.variableD.modifier;
	else
	  l->modifier = noneMod;
      }
    }
   break;
 }
}


/*** Second pass: ***/

void sym2PassSCRIPTCOLLECTION(SCRIPTCOLLECTION *s)
{
  if (s->toplevels != NULL)
    sym2PassTOPLEVEL(s->toplevels, s->sym);
}

void sym2PassTOPLEVEL(TOPLEVEL *t, SymbolTable *sym)
{
  switch (t->kind) {
  case functionK:
    sym2PassFUNCTION(t->val.functionT, sym);
    break;
  case programK:
    sym2PassPROGRAM(t->val.programT, sym);
    break;
  case simpledeclK:                              /* chenhongyu, 2004-9-17. */
    sym2PassSIMPLEDECL(t->val.decl, sym);;
	break;
  }
  
  if (t->next != NULL)
    sym2PassTOPLEVEL(t->next, sym);
}

void sym2PassFUNCTION(FUNCTION *f, SymbolTable *sym)
{
  if (f->stms != NULL)   
    sym2PassSTM(f->stms, f->sym);
}

void sym2PassPROGRAM(PROGRAM *s, SymbolTable *sym)
{  
  if (s->stms != NULL)   
    sym2PassSTM(s->stms, s->sym);
}

/* chenhongyu, 2004-9-17. */
void sym2PassSIMPLEDECL(DECL *d, SymbolTable *sym)
{
  if (d->val.simplevarD.initialization != NULL)    
    sym2PassEXP(d->val.simplevarD.initialization, sym);
}

void sym2PassDECL(DECL *d, SymbolTable *sym)
{
  switch (d->kind) {
  case formalK:
    break;
  case variableK:
    if (d->val.variableD.initialization != NULL)    
      sym2PassEXP(d->val.variableD.initialization, sym);
    break;
  case simplevarK:
    if (d->val.simplevarD.initialization != NULL)    
      sym2PassEXP(d->val.simplevarD.initialization, sym);
    break;
  }
  
  if (d->next != NULL)
    sym2PassDECL(d->next, sym);
}

void sym2PassFORINIT(FORINIT *f, SymbolTable *sym)
{
  switch (f->kind) {
  case declforinitK:
    sym2PassDECL(f->val.declforinitF, sym);
    break;
  case expforinitK:
    sym2PassEXP(f->val.expforinitF, sym);
    break;
  }
  
  if (f->next != NULL)
    sym2PassFORINIT(f->next, sym);
}

void sym2PassSTM(STM *s, SymbolTable *sym)
{
  switch (s->kind) {
  case skipK:
    break;
  case expK:
    sym2PassEXP(s->val.expS, sym);
    break;
  case declstmK:
    sym2PassDECL(s->val.declstmS, sym);
    break;
  case returnK:
    if(s->val.returnS.exp != NULL)
      sym2PassEXP(s->val.returnS.exp, sym);
    break;
  case ifK:
    sym2PassEXP(s->val.ifS.condition, sym);
    sym2PassSTM(s->val.ifS.body, sym);
    break;
  case ifelseK:
    sym2PassEXP(s->val.ifelseS.condition, sym);
    sym2PassSTM(s->val.ifelseS.thenpart, sym);
    sym2PassSTM(s->val.ifelseS.elsepart, sym);
    break;
  case whileK:
    sym2PassEXP(s->val.whileS.condition, sym);
    sym2PassSTM(s->val.whileS.body, sym);
    break;
  case forK:
    sym2PassFORINIT(s->val.forS.inits, sym);
    sym2PassEXP(s->val.forS.condition, sym);
    sym2PassEXP(s->val.forS.updates, sym);
    sym2PassSTM(s->val.forS.body, sym);
    break;
  case sequenceK:
    sym2PassSTM(s->val.sequenceS.first, sym);
    sym2PassSTM(s->val.sequenceS.second, sym);
    break;
  case scopeK:
    sym2PassSTM(s->val.scopeS.stm, s->val.scopeS.sym);
    break;
  case setintK:
    sym2PassEXP(s->val.setintS.modelname, sym);
    sym2PassEXP(s->val.setintS.nr, sym);
    sym2PassEXP(s->val.setintS.val, sym);
    break;
  case sleepK:
    sym2PassEXP(s->val.sleepS.time, sym);
    break;
  }
}

void sym2PassEXP(EXP * e, SymbolTable *sym) 
{
  SYMBOL *symbol;
  if(e == NULL)
   return;
      
  switch (e->kind) {
  case intconstK:
    break;
  case boolconstK:
    break;
  case stringconstK:
    break;
  case uminusK:
    sym2PassEXP(e->val.uminusE, sym);
    break;
  case notK:
    sym2PassEXP(e->val.notE.exp, sym);
    break;
  case lvalueK:
    break;
  case assignmentK:
    sym2PassEXP(e->val.assignmentE.right, sym);
    break;
  case equalsK:
    sym2PassEXP(e->val.equalsE.left, sym);
    sym2PassEXP(e->val.equalsE.right, sym);    
    break;
  case nequalsK:
    sym2PassEXP(e->val.nequalsE.left, sym);
    sym2PassEXP(e->val.nequalsE.right, sym);    
    break;
  case lessK:
    sym2PassEXP(e->val.lessE.left, sym);
    sym2PassEXP(e->val.lessE.right, sym);    
    break;
  case greaterK:
    sym2PassEXP(e->val.greaterE.left, sym);
    sym2PassEXP(e->val.greaterE.right, sym);    
    break;
  case lequalsK:
    sym2PassEXP(e->val.lequalsE.left, sym);
    sym2PassEXP(e->val.lequalsE.right, sym);    
    break;
  case gequalsK:
    sym2PassEXP(e->val.gequalsE.left, sym);
    sym2PassEXP(e->val.gequalsE.right, sym);    
    break;
  case plusK:
    sym2PassEXP(e->val.plusE.left, sym);
    sym2PassEXP(e->val.plusE.right, sym);    
    break;
  case minusK:
    sym2PassEXP(e->val.minusE.left, sym);
    sym2PassEXP(e->val.minusE.right, sym);    
    break;
  case multK:
    sym2PassEXP(e->val.multE.left, sym);
    sym2PassEXP(e->val.multE.right, sym);    
    break;
  case divK:
    sym2PassEXP(e->val.divE.left, sym);
    sym2PassEXP(e->val.divE.right, sym);    
    break;
  case moduloK:
    sym2PassEXP(e->val.moduloE.left, sym);
    sym2PassEXP(e->val.moduloE.right, sym);    
    break;
  case andK:
    sym2PassEXP(e->val.andE.left, sym);
    sym2PassEXP(e->val.andE.right, sym);    
    break;
  case orK:
    sym2PassEXP(e->val.orE.left, sym);
    sym2PassEXP(e->val.orE.right, sym);    
    break;

  case callK:
    
    /* do function name check now */
    symbol = getSymbol(sym, e->val.callE.name);
    
	/* chenhongyu, 2004-9-16. */
	/* 当调用系统函数时, getSymbol返回空, 需要在系统函数库内查询 */
    if (symbol == NULL)
	{
		symbol = getSymbol_SysFun(e->val.callE.name);
	}
	if (symbol == NULL)
		reportError(e->lineno, "Function or program '%s' is referenced but not defined",  e->val.callE.name);	
    else if (symbol->kind != functionSym && symbol->kind != programSym)
      reportError(e->lineno, "Trying to use variable %s as a function", e->val.callE.name);
    else
      e->val.callE.symbol = symbol;
    
    if (e->val.callE.arguments != NULL) 
      sym2PassEXP(e->val.callE.arguments, sym);    
    break;
  case castK:
    sym2PassEXP(e->val.castE.exp, sym);   
    break;
  } /* end switch */
  
  if (e->next != NULL)
    sym2PassEXP(e->next, sym);
}