io.c

一个C style Assembler的source code

         Value = CP - CodeTab; return MNEMONIC;
      }
   for (C = Reserved; C < EndR; C++)
      if (CompS(Name, C->Name) == 0) {
         Value = C->Value; return C->Tag;
      }
   Sym = LookUp(Name);
   return SYMBOL;
}

typedef struct {
   char *Name; byte Type; word Val;
} ValCard;
static ValCard ValTab[] = {
/* Special function registers */
   { "P0", SFR, 0x80 }, { "P1", SFR, 0x90 },
   { "P2", SFR, 0xa0 }, { "P3", SFR, 0xb0 },
   { "PCON", SFR, 0x87 }, { "TCON", SFR, 0x88 }, { "TMOD", SFR, 0x89 },
   { "SCON", SFR, 0x98 }, { "SBUF", SFR, 0x99 },
   { "IE",   SFR, 0xa8 }, { "IP",   SFR, 0xb8 },
   { "TL0", SFR, 0x8a }, { "TL1", SFR, 0x8b },
   { "TH0", SFR, 0x8c }, { "TH1", SFR, 0x8d },
   { "SP",   SFR, 0x81 }, { "DPL",  SFR, 0x82 }, { "DPH",  SFR, 0x83 },
   { "PSW",  SFR, 0xd0 }, { "ACC",  SFR, 0xe0 }, { "B",    SFR, 0xf0 },
/* Special funcgtion register bits */
   { "RI",  BIT, 0x98 }, { "TI",  BIT, 0x99 },    /* SCON */
   { "RB8", BIT, 0x9a }, { "TB8", BIT, 0x9b },
   { "REN", BIT, 0x9c }, { "SM2", BIT, 0x9d },
   { "SM1", BIT, 0x9e }, { "SM0", BIT, 0x9f },
   { "RXD",  BIT, 0xb0 }, { "TXD",  BIT, 0xb1 },  /* Port 3 */
   { "INT0", BIT, 0xb2 }, { "INT1", BIT, 0xb3 },
   { "T0",   BIT, 0xb4 }, { "T1",   BIT, 0xb5 },
   { "WR",   BIT, 0xb6 }, { "RD",   BIT, 0xb7 },
   { "P",   BIT, 0xd0 }, { "OV",  BIT, 0xd2 },    /* PSW */
   { "RS0", BIT, 0xd3 }, { "RS1", BIT, 0xd4 },
   { "F0",  BIT, 0xd5 }, { "AC",  BIT, 0xd6 }, { "CY",  BIT, 0xd7 },
   { "IT0", BIT, 0x88 }, { "IE0", BIT, 0x89 },    /* TCON */
   { "IT1", BIT, 0x8a }, { "IE1", BIT, 0x8b },
   { "TR0", BIT, 0x8c }, { "TF0", BIT, 0x8d },
   { "TR1", BIT, 0x8e }, { "TF1", BIT, 0x8f },
   { "EX0", BIT, 0xa8 }, { "ET0", BIT, 0xa9 },    /* IE */
   { "EX1", BIT, 0xaa }, { "ET1", BIT, 0xab },
   { "ES",  BIT, 0xac }, { "EA",  BIT, 0xaf },
   { "PX0", BIT, 0xb8 }, { "PT0", BIT, 0xb9 },    /* IP */
   { "PX1", BIT, 0xba }, { "PT1", BIT, 0xbb }, { "PS",  BIT, 0xbc }
};

void RegInit(void) {
   ValCard *V; Symbol Sym;
   static ValCard *EndV = ValTab + ELEMENTS(ValTab);
   for (V = ValTab; V < EndV; V++) {
      Sym = LookUp(V->Name);
      Sym->Defined = Sym->Address = 1;
      Sym->Seg = &SegTab[V->Type], Sym->Offset = V->Val;
   }
}
 
#define isoctal(Ch) (isdigit(Ch) && Ch < '8')
#define isx(Ch) (tolower(Ch) == 'x' || tolower(Ch) == 'h')
#define isq(Ch) (tolower(Ch) == 'q' || tolower(Ch) == 'o')
 
char InExp = 0, InSemi = 0;
Lexical OldL;
#define Ret(Token) return (*U = '\0', OldL = (Token))
 
Lexical Scan(void) {
   char *S; int Bad;
Start:
   U = Text;
   if (isalpha(Next) || Next == '_') {
      while (isalnum(Next) || Next == '_') Get();
      Ret(FindKey(Text));
   } else if (isdigit(Next)) {
      char Ch = Next; Get();
      if (Ch == '0' && isx(Next)) {
         do Get(); while (isxdigit(Next));
         goto RetHex;
      }
      if (Next == ':' && !InExp) {
         char D = *Text - '0';
         if (Active) {
            Sym = BTab[D] = (FTab[D] == 0)? MakeLabel(): FTab[D];
            FTab[D] = 0;
            Sym->Global = 0, Sym->Defined = Sym->Address = Sym->Variable = 1,
            Sym->Seg = SegP, Sym->Offset = (word)LOC;
         } else Sym = 0;
         Ret(SYMBOL);
      }
      while (isxdigit(Next)) Get();
      if (isx(Next)) { Get(); goto RetHex; }
      if (isq(Next)) { Get(); goto RetOct; }
      if (U - Text == 2) {
         if (tolower(Text[1]) == 'b') {
            char D = *Text - '0';
            if (Active) {
               Sym = BTab[D];
               if (Sym == 0) {
                  BTab[D] = Sym = MakeLabel();
                  ERROR("Undefined local symbol %cb", D);
                  Sym->Global = Sym->Defined = 0,
                  Sym->Address = Sym->Variable = 1,
                  Sym->Seg = SegP, Sym->Offset = 0;
               }
            } else Sym = 0;
            Ret(SYMBOL);
         } else if (tolower(Text[1]) == 'f') {
            char D = *Text - '0';
            if (Active) {
               if (FTab[D] == 0) FTab[D] = MakeLabel();
               Sym = FTab[D];
            } else Sym = 0;
            Ret(SYMBOL);
         }
      }
      if (tolower(U[-1]) == 'b') goto RetBin;
      if (tolower(U[-1]) == 'd' || *Text != '0') goto RetDec;
      if (U == Text) { Value = 0; Ret(NUMBER); }
      if (isx(Text[1])) goto RetHex;
      if (tolower(Text[1]) == 'b') goto RetBin;
      goto RetDec;
RetBin:
      S = Text;
      if (tolower(U[-1]) == 'b') U--;
      else if (U >= S + 2 && S[0] == '0' && tolower(S[1]) == 'b') S += 2;
      for (Bad = 0, Value = 0; S < U; S++) {
         int D = *S - '0';
         if (!isdigit(*S) || D >= 2) Bad++, D = 0;
         Value = (Value << 1) | D;
      }
      if (Bad) ERROR("Binary number has non-binary digits.");
      Ret(NUMBER);
RetOct:
      if (isq(U[-1])) U--;
      for (Bad = 0, Value = 0, S = Text; S < U; S++) {
         int D = *S - '0';
         if (!isdigit(*S) || D >= 010) Bad++, D = 0;
         Value = (Value << 3) | D;
      }
      if (Bad) ERROR("Octal number has non-octal digits.");
      Ret(NUMBER);
RetDec:
      if (tolower(U[-1]) == 'd') U--;
      for (Bad = 0, Value = 0, S = Text; S < U; S++) {
         int D = *S - '0';
         if (!isdigit(*S)) Bad++, D = 0;
         Value = 10*Value + D;
      }
      if (Bad) ERROR("Decimal number has non-decimal digits.");
      Ret(NUMBER);
RetHex:
      S = Text;
      if (isx(U[-1])) U--;
      else if (U >= S + 2 && S[0] == '0' && isx(S[1])) S += 2;
      for (Value = 0; S < U; S++) {
         Value <<= 4, Value += isdigit(*S)? *S - '0': tolower(*S) - 'a' + 10;
      }
      Ret(NUMBER);
   }
   switch (Next) {
      case ';': switch (Get(), Next) {
         case ';':
            while (Next != '\n') {
               if (Next == EOF) FATAL("Unexpected EOF inside ;; comment.");
               Next = fgetc(InF);
            }
            Get();
            if (!InSemi) goto Start;
         default: Ret(SEMI);
      }
      break;
      case '/': switch (Get(), Next) {
         case '/':
            while (Next != '\n') {
               if (Next == EOF) FATAL("Unexpected EOF inside // comment.");
               Next = fgetc(InF);
            }
            Get();
            if (!InSemi) goto Start;
         Ret(SEMI);
         case '*': {
            int Line0 = Line;
            Next = fgetc(InF);
            while (Next != EOF) {
               if (Next == '*') {
                  while (Next == '*') Next = fgetc(InF);
                  if (Next == '/') {
                     Next = fgetc(InF);
                     if (Line <= Line0 || !InSemi) goto Start;
                     Ret(SEMI);
                  }
               } else {
                  if (Next == '\n') Line++; Next = fgetc(InF);
               }
            }
            FATAL("Unexpected EOF inside comment.");
         }
         default: Ret(DIV);
      }
      case '\'':
	 Get();
         if (Next == '\'') {
            ERROR("Empty character constant."); Get(); Value = 0; Ret(NUMBER);
         }
	 if (Next == '\\') {
            int I;
	    Get();
	    if (isoctal(Next)) {
	       for (Value = 0; isoctal(Next); Get())
                  Value <<= 3, Value += Next - '0';
	    } else if (tolower(Next) == 'x') {
	       Get();
               if (!isxdigit(Next)) {
                  ERROR("Bad hexadecimal character.");
                  Value = 'x';
               } else for (I = 0; I < 2 && isxdigit(Next); I++, Get()) {
                  Value <<= 4;
                  Value += isdigit(Next)? Next - '0': tolower(Next) - 'a' + 10;
               }
	    } else {
               switch (Next) {
                  case 'a': Value = 0x07; break;
                  case 'b': Value = 0x08; break;
                  case 't': Value = 0x09; break;
                  case 'n': Value = 0x0a; break;
                  case 'v': Value = 0x0b; break;
                  case 'f': Value = 0x0c; break;
                  case 'r': Value = 0x0d; break;
                  default: Value = Next; break;
               }
               Get();
            }
	 } else Value = Next, Get();
	 if (Next != '\'') ERROR("Missing a ' in character constant.");
         else Get();
      Ret(NUMBER);
      case '"':
         Next = fgetc(InF);
         while (Next != '\"') {
            if (Next == EOF) FATAL("Unexpected EOF inside string.");
            else if (Next == '\\') {
               Next = fgetc(InF);
               if (Next == EOF) FATAL("Unexpected EOF inside string.");
	       if (isoctal(Next)) {
                  char Value = 0;
                  while (isoctal(Next)) {
                     Value = (Value << 3) + (Next - '0');
                     Next = fgetc(InF);
                  }
                  *U++ = Value;
	       } else if (tolower(Next) == 'x') {
                  char Value;
                  Next = fgetc(InF);
                  if (!isxdigit(Next)) Value = 'x';
		  else while (isxdigit(Next)) {
                     Value <<= 4;
                     Value += isdigit(Next)? Next - '0': tolower(Next) - 'a' + 10;
                     Next = fgetc(InF);
                  }
                  *U++ = Value;
	       } else {
                  if (Next == '\n') Line++;
                  switch (Next) {
                     case 'a': *U++ = '\a'; break;
                     case 'b': *U++ = '\b'; break;
                     case 't': *U++ = '\t'; break;
                     case 'n': *U++ = '\n'; break;
                     case 'v': *U++ = '\v'; break;
                     case 'f': *U++ = '\f'; break;
                     case 'r': *U++ = '\r'; break;
                     default: *U++ = Next; break;
                  }
                  Next = fgetc(InF);
               }
	    } else {
               if (Next == '\n') Line++;
               *U++ = Next; Next = fgetc(InF);
            }
         }
         Next = fgetc(InF);
      Ret(STRING);
      case '<': switch (Get(), Next) {
	 case '=': Get(); Ret(LE);
	 case '<': Get(); Ret(SHL);
         default: Ret(LT);
      }
      case '>': switch (Get(), Next) {
	 case '=': Get(); Ret(GE);
	 case '>': Get(); Ret(SHR);
	 default: Ret(GT);
      }
      case '&': switch (Get(), Next) {
	 case '&': Get(); Ret(AND_AND);
	 default: Ret(AND);
      }
      case '|': switch (Get(), Next) {
	 case '|': Get(); Ret(OR_OR);
	 default: Ret(OR);
      }
      case '=': switch (Get(), Next) {
	 case '=': Get(); Ret(EQ);
	 default: Ret(SET);
      }
      case '!': switch (Get(), Next) {
	 case '=': Get(); Ret(NE);
	 default: Ret(NOT_NOT);
      }
      case '\n': Get(); if (!InSemi) goto Start; Ret(SEMI);
      case '^': Get(); Ret(XOR);
      case '+': Get(); Ret(PLUS);
      case '-': Get(); Ret(MINUS);
      case '*': Get(); Ret(MULT);
      case '%': Get(); Ret(MOD);
      case '@': Get(); Ret(AT);
      case '#': Get(); Ret(POUND);
      case '$': Get(); Ret(DOLLAR);
      case '.': Get(); Ret(DOT);
      case '~': Get(); Ret(NOT);
      case ',': Get(); Ret(COMMA);
      case ':': Get(); Ret(COLON);
      case '?': Get(); Ret(QUEST);
      case '{': Get(); Ret(LCURL);
      case '}': Get(); Ret(RCURL);
      case '(': Get(); Ret(LPAR);
      case ')': Get(); Ret(RPAR);
      case 0: Ret(0);
      default: Get(); goto Start;
   }
}