sub.c

一个非常小的C语言编译器!!! !!! !!! !!!!

  if (lSymp == NULL) {                  // New symbol.
    lName = sym_string.Append(pString); // Record the name. 
    lNew = new SymbolT;                 // Get new instance.
    lNew->name = lName;
    lNew->kind = pKind;
    tail->next = lNew;
    tail = lNew;
    lNew->hashChain = hash[lHash];      // Insert this at top of chain.
    hash[lHash] = lNew;
    lSymp = lNew;
  }
  return lSymp;
} //---- SearchOrAdd end ----//

//--------------------//
SymbolP SymbolT::Get( // Read a token and return its symbol table ptr.
  char   pExpected)   //   Token kind expected (a: Id, 0: integer,
                      //   ?: any symbol, other special char: that char.)
{
  Tkn_kindT lTknKind;
  SymbolP   lSymp;
  Boolean   lError;
  
  tkn_curr.Get();
  if (tkn_curr.Kind() != tknEof) {
    lSymp = SearchOrAdd(tkn_curr.Name(), tkn_curr.Leng(),
                         tkn_curr.Kind());
    lError = false;
    if (tkn_curr.Kind() == tknId) {
      if ((pExpected != 'a')&&(pExpected != '?'))
        lError = true;
    }else if (tkn_curr.Kind() == tknIntC) {
      lSymp->IValueSet(tkn_curr.Value());
      if ((pExpected != '0')&&(pExpected != '?'))
        lError = true;
    }else if ((*(lSymp->name) != pExpected)&&(pExpected != '?'))
      lError = true;
    if (lError)
      lSymp->Error(10, StrAppend(" should be class ", pExpected));
    sym_curr = lSymp;
    return lSymp;
  }else {
    sym_curr = sym_eof;
    return sym_eof;
  }
} //---- Get end ----//

//--------------------//
SymbolP SymbolT::GeneratedVar() // Generate a temporal variable.
{                               // NOT USED IN THE CURRENT VERSION.
  char lGeneratedName[16];
  SymbolP lName;
  VarInfP lVarInf;
  
  sym_tempVar++;
  strcat(strcpy(lGeneratedName, "_temp"), Itoaf(sym_tempVar));
  lName = SearchOrAdd(lGeneratedName, strlen(lGeneratedName), tknVar);
  lVarInf = new VarInf;
  lName->VarPSet(lVarInf);
  lVarInf->ElemCountSet(1);
  lVarInf->IndexSet(sym_tempVar);
  return lName;
} //---- GeneratedName end ----//

//--------------------//
void SymbolT::Print()   // Print symbol informations for debug.
{
  SymbolP lSym;

    if (this == sym_eof)
      fprintf(prtFile, "\n ");
    else 
      fprintf(prtFile, "\n %s ", Name()); 
    fprintf(prtFile, "%s sz %d h %s ",  
      KindName(),  Size(), hashChain->NameStr());
    switch (Kind()) {
    case tknIntC:
      fprintf(prtFile, "%d ", IValue());
      break;
    case tknOper:
      fprintf(prtFile, "%s ", sym_opCodeName[OpCode()]);
      break;
    case tknVar:
    case tknParam:
      fprintf(prtFile, "vt %s ec %d ix %d pn %s ", VTypeName(), 
        VarP()->ElemCount(), VarP()->Index(), VarP()->ParamChain()->NameStr());
      break;
    case tknFunc:
      fprintf(prtFile, "pn %s pc %d ", FuncP()->ParamChain()->NameStr(), 
        FuncP()->ParamCount());
      break;
    case tknReg:
      RegP()->Print();
      break;
    case tknMrg:
      MrgP()->Print();
      break;
    default:
      break;
    }
} //---- Print end ----//

//--------------------//
void SymbolT::PrintAll() // Print all symbols in the symbol table.
{
  SymbolP lSymp;
  
  for (lSymp = head; lSymp != NULL; lSymp = lSymp->next)
    lSymp->Print();
  fprintf(prtFile, "\n");
} //---- PrintAll end ----//

//--------------------//
void SymbolT::Error(    // Print error message with symbol name.
  int    pErrorCode,    //   Error code.
  String pMessage)      //   Error message.
{
  fprintf(prtFile, "\n ** ERROR %d %s %s ",
          pErrorCode, name, pMessage);
// Error( 10, StrAppend(" should be class ", pExpected)) in symTbl.Get
// Error( 20, "Parameter name is expected \n") in FuncDecl
// Error(100, "Id expected \n"); in VarDecl
// Error(110, " encountered. ") in Expect
// Error(130, "without preceeding if.") in Block
} //---- Error end ----//

//--------------------//
SymbolP SymbolT::Set(   // Set to the symbol table as pKind symbol.
  String    pString,    //   Name string of the symbol.
  Tkn_kindT pKind)      //   Token kind to be set for the symbol.
{
  SymbolP lSymp;
  
  lSymp = SearchOrAdd(pString, strlen(pString), pKind);
  lSymp->KindSet(pKind);
  return lSymp;
} //---- Set end ----//

//--------------------//
SymbolP SymbolT::SetOp( // Set operator to the symbol table.
  String      pString,  //   Name string of the operator.
  Tkn_kindT   pKind,    //   Token kind.
  Sym_opCodeT pCode)    //   Abstract operation code of the operator.
{
  SymbolP lSymp;
  
  lSymp = SearchOrAdd(pString, strlen(pString), pKind);
  lSymp->KindSet(pKind);
  lSymp->OpCodeSet(pCode);
  return lSymp;
} //---- SetOp end ----//

//-------- Static Variables --------//
  SymbolP SymbolT::hash[SYM_hashLim]; // Hash table. 
  SymbolP SymbolT::head;              // Head of symbol list.
  SymbolP SymbolT::tail;              // Tail of symbol list.

//------ Global Variable ------//
  String sym_opCodeName[] = {
    "prog   ","pend   ","subp   ","end    ",
    "export ","import ","entry  ","label  ",
    "add    ","adda   ","sub    ","mult   ","div    ","mod    ",
    "jump   ","call   ","return ","load   ","loada  ","store  ",
	"stack",
    "comp   ","breq   ","brne   ","brgt   ","brge   ","brle   ","brlt   ",  
    "prolog ","epilog ","sect   ","dword  ","dconst ","dparam "
  };

//========== Utility Implementation ==========//

//--------------------//
char *StrSyn(char *pStr1, char *pStr2)  // Synthesize pStr1 and pStr2
{                                       //   in a work area.
  static char lStr[256];  // Work area holding the result.
  
  strcpy(lStr, pStr1);
  strcat(lStr, pStr2);
  return lStr;
}  //---- StrSyn end ----//
//--------------------//
char *StrAppend(char *pStr, char pChar) // Append pChar to pStr
{                                       //   in a work area.
  static char lStr[256];  // Work area holding the result.
  int li;
  
  strcpy(lStr, pStr);
  li = strlen(lStr);
  lStr[li] = pChar;
  lStr[li+1] = '\0';
  return lStr;
}  // StrAppend end ----//
//--------------------//
void StrReverse(char *pStr)    // Reverse given character string pStr.
{
  int  li, lj;
  char lc;
  
  for (li = 0, lj = strlen(pStr)-1; li < lj; li++, lj--) {
    lc = pStr[li];
    pStr[li] = pStr[lj];
    pStr[lj] = lc;
  }
}  //---- StrReverse end ----//
//--------------------//
char *Itoaf(int pi) /* Change binary integer pi to character string */
{
  static char lStr[16];
  int    li, lVal, lSign;
  
  lVal  = pi;
  lSign = pi;
  if (lVal < 0) 
    lVal = -lVal;
  li = 0;
  do {
    lStr[li++] = lVal%10 + '0';
  } while ((lVal /= 10) > 0);
  if (lSign < 0)
    lStr[li++] = '-';
  lStr[li] = '\0';
  StrReverse(lStr);
  return lStr;
}  //---- Itoaf ----//