Return to def68k.c CVS log

Up to [Generator SEGA Genesis emulator] / generator / src

Annotation of generator/src/def68k.c, revision 1.1

1.1     ! root        1: /*****************************************************************************/
        !             2: /*     Generator - Sega Genesis emulation - (c) James Ponder 1997-1998       */
        !             3: /*****************************************************************************/
        !             4: /*                                                                           */
        !             5: /* def68k.c                                                                  */
        !             6: /*                                                                           */
        !             7: /*****************************************************************************/
        !             8: 
        !             9: #include <errno.h>
        !            10: #include <stdio.h>
        !            11: #include <string.h>
        !            12: #include <ctype.h>
        !            13: #include <stdlib.h>
        !            14: 
        !            15: #include "generator.h"
        !            16: 
        !            17: #define BUFLEN 1024
        !            18: #define FNAME_CPUDEF "def68k.def"
        !            19: #define FNAME_OUTIIBS "out/def68k-iibs.h"
        !            20: #define FNAME_OUTFUNCS "out/def68k-funcs.h"
        !            21: #define FNAME_OUTPROTO "out/def68k-proto.h"
        !            22: 
        !            23: typedef enum {
        !            24:   bit0, bit1, bitz, bite, bitE, bitf, bitF, biti, bitn, bitN, bitc, bitv
        !            25: } t_bit;
        !            26: 
        !            27: /* file-scope global variables */
        !            28: 
        !            29: static int total = 0;
        !            30: 
        !            31: /* private functions for forward references */
        !            32: 
        !            33: void procline(char *line, int lineno, FILE *outiibs, FILE *outfuncs,
        !            34:              FILE *outproto);
        !            35: int clocks_ea(t_datatype type);
        !            36: int clocks_eacalc(t_datatype type, t_size size);
        !            37: int clocks_eafetch(t_datatype type, t_size size);
        !            38: int clocks_standard(t_datatype stype, t_datatype dtype, t_size size);
        !            39: int clocks_single(t_datatype type, t_size size);
        !            40: 
        !            41: /* program entry routine */
        !            42: 
        !            43: int main(int argc, char *argv[])
        !            44: {
        !            45:   FILE *input, *outiibs, *outfuncs, *outproto;
        !            46:   char buf[BUFLEN], *p;
        !            47:   int lineno = 0;
        !            48: 
        !            49:   /* open output files and write headers */
        !            50: 
        !            51:   if ((outiibs = fopen(FNAME_OUTIIBS, "w")) == NULL) {
        !            52:     perror("fopen outiibs");
        !            53:     exit(1);
        !            54:   }
        !            55:   fprintf(outiibs, "/* automatically generated by def68k.c */\n\n");
        !            56:   fprintf(outiibs, "t_iib iibs[] = {\n");
        !            57:   fprintf(outiibs, "  /* mask, bits, mnemonic, { priv, endblk, zero, ");
        !            58:   fprintf(outiibs, "used, set },\n");
        !            59:   fprintf(outiibs, "     size, stype, dtype, sbitpos, dbitpos, immvalue, ");
        !            60:   fprintf(outiibs, "cc, funcnum */\n");
        !            61: 
        !            62:   if ((outfuncs = fopen(FNAME_OUTFUNCS, "w")) == NULL) {
        !            63:     perror("fopen outfuncs");
        !            64:     exit(1);
        !            65:   }
        !            66:   fprintf(outfuncs, "/* automatically generated by def68k.c */\n\n");
        !            67:   fprintf(outfuncs, "void (*cpu68k_funcindex[])(t_ipc *ipc) = {\n");
        !            68:   fprintf(outfuncs, "  /* function */\n");
        !            69: 
        !            70:   if ((outproto = fopen(FNAME_OUTPROTO, "w")) == NULL) {
        !            71:     perror("fopen outproto");
        !            72:     exit(1);
        !            73:   }
        !            74:   fprintf(outproto, "/* automatically generated by def68k.c */\n\n");
        !            75: 
        !            76:   /* open input file */
        !            77: 
        !            78:   if ((input = fopen(FNAME_CPUDEF, "r")) == NULL) {
        !            79:     perror("fopen input");
        !            80:     exit(1);
        !            81:   }
        !            82: 
        !            83:   /* loop until end of file */
        !            84: 
        !            85:   printf("Writing CPU definitions... ");
        !            86:   fflush(stdout);
        !            87: 
        !            88:   while (!feof(input)) {
        !            89:     /* use unix line numbering from 1 */
        !            90:     lineno++;
        !            91:     /* read a line */
        !            92:     if (ferror(input)) {
        !            93:       break;
        !            94:     }
        !            95:     if (fgets(buf, BUFLEN, input) == NULL) {
        !            96:       break;
        !            97:       /* huh? why does this cause fgets to say 'Unknown error'?! */
        !            98:       perror("fgets");
        !            99:       exit(1);
        !           100:     }
        !           101:     /* remove newline */
        !           102:     buf[strlen(buf)-1] = '\0';
        !           103:     /* remove comment */
        !           104:     if ((p = strchr(buf, ';')) != NULL) {
        !           105:       *p = '\0';
        !           106:     }
        !           107:     /* remove leading spaces */
        !           108:     p = buf;
        !           109:     while (*p == ' ')
        !           110:       p++;
        !           111:     /* blank line? */
        !           112:     if (!*p)
        !           113:       continue;
        !           114:     /* process line */
        !           115:     procline(buf, lineno, outiibs, outfuncs, outproto);
        !           116:   }
        !           117: 
        !           118:   /* close input */
        !           119: 
        !           120:   if (fclose(input)) {
        !           121:     perror("fclose input");
        !           122:     exit(1);
        !           123:   }
        !           124: 
        !           125:   /* output footer */
        !           126: 
        !           127:   fprintf(outiibs, "  { 0, 0, 0, { 0, 0, 0, 0, 0 }, "
        !           128:          "0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }\n");
        !           129:   fprintf(outiibs, "};\n");
        !           130:   fprintf(outiibs, "int iibs_num = %d;\n", total);
        !           131: 
        !           132:   fprintf(outfuncs, "};\n");
        !           133: 
        !           134:   /* close outputs */
        !           135: 
        !           136:   if (fclose(outiibs)) {
        !           137:     perror("fclose outiibs");
        !           138:     exit(1);
        !           139:   }
        !           140:   if (fclose(outfuncs)) {
        !           141:     perror("fclose outfuncs");
        !           142:     exit(1);
        !           143:   }
        !           144:   if (fclose(outproto)) {
        !           145:     perror("fclose outproto");
        !           146:     exit(1);
        !           147:   }
        !           148: 
        !           149:   printf("done.\n");
        !           150:   fflush(stdout);
        !           151: 
        !           152:   return(0);
        !           153: }  
        !           154: 
        !           155: /* process a line */
        !           156: 
        !           157: void procline(char *line, int lineno, FILE *outiibs, FILE *outfuncs,
        !           158:              FILE *outproto) {
        !           159:   int i;
        !           160:   char *p;
        !           161:   t_bit bit = bit0, lastbit = bit0;
        !           162:   int start[16] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
        !           163:   int num[16] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
        !           164:   char mnemonic[16], *m;
        !           165:   int setting;
        !           166:   int clocks;
        !           167: 
        !           168:   /* parameters to fill in about instruction */
        !           169:   int mnemonic_num;
        !           170:   uint16 mask = 0, bits = 0;        /* see struct t_iib for details on */
        !           171:   int priv = 0, endblk = 0;         /* these variables */
        !           172:   int imm_notzero = 0;
        !           173:   int used = 0, set = 0;
        !           174:   t_size isize = sz_none;
        !           175:   int expand_s_immsize = 0, expand_s_ea_e = 0;
        !           176:   int expand_d_ea_e = 0, expand_d_ea_f = 0;
        !           177:   t_datatype dtype = dt_Ill;
        !           178:   t_datatype stype = dt_Ill;
        !           179:   int e[16] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
        !           180:   int f[16] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
        !           181:   int immvalue = 0;
        !           182:   int sbitpos = 0, dbitpos = 0;
        !           183: 
        !           184:   p = line;
        !           185: 
        !           186:   /* bitpattern */
        !           187: 
        !           188:   for (i = 15; i >= 0; i--) {
        !           189:     while (*p == ' ')
        !           190:       p++;
        !           191: 
        !           192:     switch(*p) {
        !           193:     case '0': bit = bit0; mask |= 1<<i; break;
        !           194:     case '1': bit = bit1; mask |= 1<<i; bits |= 1<<i; break;
        !           195:     case 'z': bit = bitz; break;
        !           196:     case 'e': bit = bite; break;
        !           197:     case 'E': bit = bitE; break;
        !           198:     case 'f': bit = bitf; break;
        !           199:     case 'F': bit = bitF; break;
        !           200:     case 'n': bit = bitn; break;
        !           201:     case 'N': bit = bitN; break;
        !           202:     case 'i': bit = biti; break;
        !           203:     case 'c': bit = bitc; break;
        !           204:     case 'V': bit = bitv; break;
        !           205:     default:
        !           206:       fprintf(stderr, "%d: unknown char %c in bitpattern\n", lineno, *p);
        !           207:       exit(1);
        !           208:     }
        !           209: 
        !           210:     if (*p != '0' && *p != '1') {
        !           211:       if (num[bit]) {
        !           212:        /* we've seen this bit before, make sure the last bit was the same */
        !           213:        if (bit < 15 && bit != lastbit) {
        !           214:          fprintf(stderr, "%d: Non contiguous bits of %c\n", lineno, *p);
        !           215:          exit(1);
        !           216:        }
        !           217:       }
        !           218:       /* we're looping down, so the last time start[bit] is set is the start */
        !           219:       start[bit] = i;
        !           220:       /* record how many of these bits there are */
        !           221:       num[bit]++;
        !           222:     }
        !           223:     p++;
        !           224:     lastbit = bit;
        !           225:   }
        !           226:   /* skip spaces and skip tab to get to next field */
        !           227:   while (*p == ' ')
        !           228:     p++;
        !           229:   if (*p++ != '\t') {
        !           230:     fprintf(stderr, "%d: Tab not found at end of bitpattern\n", lineno);
        !           231:     exit(1);
        !           232:   }
        !           233: 
        !           234:   /* misc flags */
        !           235: 
        !           236:   if (*p == '0') {
        !           237:     priv = 0;
        !           238:   } else if (*p == '1') {
        !           239:     priv = 1;
        !           240:   } else {
        !           241:     fprintf(stderr, "%d: Priv flag not 0 or 1\n", lineno);
        !           242:     exit(1);
        !           243:   }
        !           244:   p++;
        !           245:   /* skip spaces to next field */
        !           246:   while (*p == ' ')
        !           247:     p++;
        !           248:   if (*p == '0') {
        !           249:     endblk = 0;
        !           250:   } else if (*p == '1') {
        !           251:     endblk = 1;
        !           252:   } else {
        !           253:     fprintf(stderr, "%d: End-block flag not 0 or 1\n", lineno);
        !           254:     exit(1);
        !           255:   }
        !           256:   p++;
        !           257:   /* skip spaces and skip tab to get to next field */
        !           258:   while (*p == ' ')
        !           259:     p++;
        !           260:   if (*p++ != '\t') {
        !           261:     fprintf(stderr, "%d: Tab not found at end of flags\n", lineno);
        !           262:     exit(1);
        !           263:   }
        !           264: 
        !           265:   /* used flags */
        !           266: 
        !           267:   for (i = 0; i < 5; i++) {
        !           268:     while (*p == ' ')
        !           269:       p++;
        !           270:     switch(*p++) {
        !           271:     case '-': break;
        !           272:     case 'x': break;
        !           273:     case 'X': used |= 1<<i; break;
        !           274:     case 'N': used |= 1<<i; break;
        !           275:     case 'Z': used |= 1<<i; break;
        !           276:     case 'V': used |= 1<<i; break;
        !           277:     case 'C': used |= 1<<i; break;
        !           278:     case '0': used |= 1<<i; break;
        !           279:     case '1': used |= 1<<i; break;
        !           280:     default:
        !           281:       fprintf(stderr, "%d: Did not understand used flag %d\n", lineno, i);
        !           282:       exit(1);
        !           283:     }
        !           284:   }
        !           285:   /* skip spaces and skip tab to get to next field */
        !           286:   while (*p == ' ')
        !           287:     p++;
        !           288:   if (*p++ != '\t') {
        !           289:     fprintf(stderr, "%d: Tab not found at end of used flags\n", lineno);
        !           290:     exit(1);
        !           291:   }
        !           292: 
        !           293:   /* set flags */
        !           294: 
        !           295:   for (i = 0; i < 5; i++) {
        !           296:     while (*p == ' ')
        !           297:       p++;
        !           298:     switch(*p++) {
        !           299:     case '-': break;
        !           300:     case 'x': break;
        !           301:     case 'X': set |= 1<<i; break;
        !           302:     case 'N': set |= 1<<i; break;
        !           303:     case 'Z': set |= 1<<i; break;
        !           304:     case 'V': set |= 1<<i; break;
        !           305:     case 'C': set |= 1<<i; break;
        !           306:     case '0': set |= 1<<i; break;
        !           307:     case '1': set |= 1<<i; break;
        !           308:     default:
        !           309:       fprintf(stderr, "%d: Did not understand set flag %d\n", lineno, i);
        !           310:       exit(1);
        !           311:     }
        !           312:   }
        !           313:   /* skip spaces and skip tab to get to next field */
        !           314:   while (*p == ' ')
        !           315:     p++;
        !           316:   if (*p++ != '\t') {
        !           317:     fprintf(stderr, "%d: Tab not found at end of set flags\n", lineno);
        !           318:     exit(1);
        !           319:   }
        !           320:       
        !           321:   /* mnemonic */
        !           322: 
        !           323:   m = mnemonic;
        !           324:   while (*p && (*p != '.') && (*p != ' ') && (*p != '\t')) {
        !           325:     *m++ = *p++;
        !           326:   }
        !           327:   if (*p == '\t') {
        !           328:     fprintf(stderr, "%d: Incorrect number of fields - extra tab found\n",
        !           329:            lineno);
        !           330:     exit(1);
        !           331:   }
        !           332:   *m = '\0';
        !           333:   for (mnemonic_num = 0; *mnemonic_table[mnemonic_num].name; mnemonic_num++)
        !           334:     if (!strcmp(mnemonic_table[mnemonic_num].name, mnemonic))
        !           335:       break;
        !           336:   if (!*mnemonic_table[mnemonic_num].name) {
        !           337:     fprintf(stderr, "%d: Unknown mnemonic '%s'\n", lineno, mnemonic);
        !           338:     exit(1);
        !           339:   }
        !           340:   /* set defaults for isize */
        !           341:   isize = sz_none;
        !           342:   if (*p == '.') {
        !           343:     switch(*++p) {
        !           344:     case 'B': isize = sz_byte; break;
        !           345:     case 'W': isize = sz_word; break;
        !           346:     case 'L': isize = sz_long; break;
        !           347:     case 'z':
        !           348:       if (!num[bitz]) {
        !           349:        fprintf(stderr, "%d: 'z' given as size but no 'z' in bit pattern\n",
        !           350:                lineno);
        !           351:        exit(1);
        !           352:       }
        !           353:       /* size will be set automatically later */
        !           354:       break;
        !           355:     default:
        !           356:       fprintf(stderr, "%d: Unknown size '%c' after mnemonic\n",
        !           357:              lineno, *p);
        !           358:       exit(1);
        !           359:     }
        !           360:     p++;
        !           361:   } else {
        !           362:     /* instruction is not sized */
        !           363:     if (num[bitz]) {
        !           364:       /* oh, perhaps it is but it's a mistake */
        !           365:       fprintf(stderr, "%d: 'z's in bit pattern but no .z after mnemonic\n",
        !           366:              lineno);
        !           367:       exit(1);
        !           368:     }
        !           369:   }
        !           370:   while (*p == ' ')
        !           371:     p++;
        !           372:   if (*p == '\0') {
        !           373:     /* no source and destination information given */
        !           374:     if (num[bite] || num[bitE] || num[bitf] || num[bitF] ||
        !           375:        num[biti] || num[bitn] || num[bitN] || num[bitv]) {
        !           376:       fprintf(stderr, "%d: No information given after mnemonic\n", lineno);
        !           377:       exit(1);
        !           378:     }
        !           379:   } else {
        !           380:     switch(*p++) {
        !           381:     case 'n':
        !           382:     case 'N':
        !           383:       if (*(p-1) == 'n') {
        !           384:        sbitpos = start[bitn];
        !           385:       } else {
        !           386:        sbitpos = start[bitN];
        !           387:       }
        !           388:       if (*p++ != '(') {
        !           389:        fprintf(stderr, "%d: missing qualifier for n()\n", lineno);
        !           390:        exit(1);
        !           391:       }
        !           392:       if (!strncmp(p, "Dreg", 4)) { stype = dt_Dreg; p = p+4;
        !           393:       } else if (!strncmp(p, "Areg", 4)) { stype = dt_Areg; p = p+4;
        !           394:       } else if (!strncmp(p, "Aind", 4)) { stype = dt_Aind; p = p+4;
        !           395:       } else if (!strncmp(p, "Ainc", 4)) { stype = dt_Ainc; p = p+4;
        !           396:       } else if (!strncmp(p, "Adec", 4)) { stype = dt_Adec; p = p+4;
        !           397:       } else if (!strncmp(p, "Adis", 4)) { stype = dt_Adis; p = p+4;
        !           398:       } else if (!strncmp(p, "Aidx", 4)) { stype = dt_Aidx; p = p+4;
        !           399:       } else if (!strncmp(p, "AbsW", 4)) { stype = dt_AbsW; p = p+4;
        !           400:       } else if (!strncmp(p, "AbsL", 4)) { stype = dt_AbsL; p = p+4;
        !           401:       } else if (!strncmp(p, "Pdis", 4)) { stype = dt_Pdis; p = p+4;
        !           402:       } else if (!strncmp(p, "Pidx", 4)) { stype = dt_Pidx; p = p+4;
        !           403:       } else {
        !           404:        fprintf(stderr, "%d: unknown qualifier for n()\n", lineno);
        !           405:        exit(1);
        !           406:       }
        !           407:       if (*p++ != ')') {
        !           408:        fprintf(stderr, "%d: unknown qualifier for n()\n", lineno);
        !           409:        exit(1);
        !           410:       }
        !           411:       break;
        !           412:     case '#':
        !           413:       switch(*p++) {
        !           414:       case 'B': stype = dt_ImmB; break;
        !           415:       case 'W': stype = dt_ImmW; break;
        !           416:       case 'L': stype = dt_ImmL; break;
        !           417:       case 'z': expand_s_immsize = 1; break;
        !           418:       case 's':
        !           419:        if (num[biti] != 8) {
        !           420:          fprintf(stderr, "%d: sign extend not from 8 bits\n", lineno);
        !           421:          exit(1);
        !           422:        }
        !           423:        stype = dt_Imm8s;
        !           424:        break;
        !           425:       case 'i':
        !           426:        switch (num[biti]) {
        !           427:        case 3: stype = dt_Imm3; break;
        !           428:        case 4: stype = dt_Imm4; break;
        !           429:        case 8: stype = dt_Imm8; break;
        !           430:        default:
        !           431:          fprintf(stderr, "%d: unknown immediate data size or bad dimension\n",
        !           432:                lineno);
        !           433:          exit(1);
        !           434:        }
        !           435:        sbitpos = start[biti]; 
        !           436:        break;
        !           437:       case 'I':
        !           438:        imm_notzero = 1;
        !           439:        switch (num[biti]) {
        !           440:        case 3: stype = dt_Imm3; break;
        !           441:        case 4: stype = dt_Imm4; break;
        !           442:        case 8: stype = dt_Imm8; break;
        !           443:        default:
        !           444:          fprintf(stderr, "%d: unknown immediate data size or bad dimension\n",
        !           445:                lineno);
        !           446:          exit(1);
        !           447:        }
        !           448:        sbitpos = start[biti]; 
        !           449:        break;
        !           450:       case 'V':
        !           451:        stype = dt_ImmV;
        !           452:        sbitpos = start[bitv]; 
        !           453:        break;
        !           454:       default:
        !           455:        p--;
        !           456:        if (isdigit((int)*p)) {
        !           457:          immvalue = strtol(p, &p, 10);
        !           458:          stype = dt_ImmS;
        !           459:        } else {
        !           460:          fprintf(stderr, "%d: unknown source immediate type #%c\n",
        !           461:                  lineno, *(p-1));
        !           462:          exit(1);
        !           463:        }
        !           464:       }
        !           465:       break;
        !           466:     case 'e':
        !           467:       expand_s_ea_e = 1;
        !           468: 
        !           469:       if (*p++ != '(') {
        !           470:        fprintf(stderr, "%d: missing qualifier for EA\n", lineno);
        !           471:        exit(1);
        !           472:       }
        !           473:       do {
        !           474:        setting = 1;
        !           475:        if (*p == '-') {
        !           476:          p++;
        !           477:          setting = 0;
        !           478:        }
        !           479:        if (!strncmp(p, "*", 1)) {
        !           480:          e[ea_Dreg] = e[ea_Areg] = e[ea_Aind] = e[ea_Ainc] = setting;
        !           481:          e[ea_Adec] = e[ea_Adis] = e[ea_Aidx] = e[ea_AbsW] = setting;
        !           482:          e[ea_AbsL] = e[ea_Pdis] = e[ea_Pidx] = e[ea_Imm] = setting;
        !           483:          p = p+1;
        !           484:        } else if (!strncmp(p, "Regs", 4)) {
        !           485:          e[ea_Dreg] = e[ea_Areg] = setting;
        !           486:          p = p+4;
        !           487:        } else if (!strncmp(p, "PC", 2)) {
        !           488:          e[ea_Pdis] = e[ea_Pidx] = setting;
        !           489:          p = p+2;
        !           490:        } else if (!strncmp(p, "Amod", 4)) {
        !           491:          e[ea_Ainc] = e[ea_Adec] = setting;
        !           492:          p = p+4;
        !           493:        } else if (!strncmp(p, "Dreg", 4)) { e[ea_Dreg] = setting; p = p+4;
        !           494:        } else if (!strncmp(p, "Areg", 4)) { e[ea_Areg] = setting; p = p+4;
        !           495:        } else if (!strncmp(p, "Aind", 4)) { e[ea_Aind] = setting; p = p+4;
        !           496:        } else if (!strncmp(p, "Ainc", 4)) { e[ea_Ainc] = setting; p = p+4;
        !           497:        } else if (!strncmp(p, "Adec", 4)) { e[ea_Adec] = setting; p = p+4;
        !           498:        } else if (!strncmp(p, "Adis", 4)) { e[ea_Adis] = setting; p = p+4;
        !           499:        } else if (!strncmp(p, "Aidx", 4)) { e[ea_Aidx] = setting; p = p+4;
        !           500:        } else if (!strncmp(p, "AbsW", 4)) { e[ea_AbsW] = setting; p = p+4;
        !           501:        } else if (!strncmp(p, "AbsL", 4)) { e[ea_AbsL] = setting; p = p+4;
        !           502:        } else if (!strncmp(p, "Pdis", 4)) { e[ea_Pdis] = setting; p = p+4;
        !           503:        } else if (!strncmp(p, "Pidx", 4)) { e[ea_Pidx] = setting; p = p+4;
        !           504:        } else if (!strncmp(p, "Imm", 3))  { e[ea_Imm]  = setting; p = p+3;
        !           505:        } else {
        !           506:          fprintf(stderr, "%d: unknown qualifier for EA\n", lineno);
        !           507:          exit(1);
        !           508:        }
        !           509:       } while (*p++ == ',');
        !           510:       if (*(p-1) != ')') {
        !           511:        fprintf(stderr, "%d: unknown qualifier for EA\n", lineno);
        !           512:        exit(1);
        !           513:       }
        !           514:       break;
        !           515:     default:
        !           516:       fprintf(stderr, "%d: did not understand source operand\n", lineno);
        !           517:       exit(1);
        !           518:     }
        !           519:     if (*p == ',') {
        !           520:       /* there is a destination part */
        !           521:       p++;
        !           522:       switch(*p++) {
        !           523:       case 'n':
        !           524:       case 'N':
        !           525:        if (*(p-1) == 'n') {
        !           526:          dbitpos = start[bitn];
        !           527:        } else {
        !           528:          dbitpos = start[bitN];
        !           529:        }
        !           530:        if (*p++ != '(') {
        !           531:          fprintf(stderr, "%d: missing qualifier for n()\n", lineno);
        !           532:          exit(1);
        !           533:        }
        !           534:        if (!strncmp(p, "Dreg", 4)) { dtype = dt_Dreg; p = p+4;
        !           535:        } else if (!strncmp(p, "Areg", 4)) { dtype = dt_Areg; p = p+4;
        !           536:        } else if (!strncmp(p, "Aind", 4)) { dtype = dt_Aind; p = p+4;
        !           537:        } else if (!strncmp(p, "Ainc", 4)) { dtype = dt_Ainc; p = p+4;
        !           538:        } else if (!strncmp(p, "Adec", 4)) { dtype = dt_Adec; p = p+4;
        !           539:        } else if (!strncmp(p, "Adis", 4)) { dtype = dt_Adis; p = p+4;
        !           540:        } else if (!strncmp(p, "Aidx", 4)) { dtype = dt_Aidx; p = p+4;
        !           541:        } else if (!strncmp(p, "AbsW", 4)) { dtype = dt_AbsW; p = p+4;
        !           542:        } else if (!strncmp(p, "AbsL", 4)) { dtype = dt_AbsL; p = p+4;
        !           543:        } else if (!strncmp(p, "Pdis", 4)) { dtype = dt_Pdis; p = p+4;
        !           544:        } else if (!strncmp(p, "Pidx", 4)) { dtype = dt_Pidx; p = p+4;
        !           545:        } else {
        !           546:          fprintf(stderr, "%d: unknown qualifier for n()\n", lineno);
        !           547:          exit(1);
        !           548:        }
        !           549:        if (*p++ != ')') {
        !           550:          fprintf(stderr, "%d: unknown qualifier for n()\n", lineno);
        !           551:          exit(1);
        !           552:        }
        !           553:        break;
        !           554:       case 'e':
        !           555:        expand_d_ea_e = 1;
        !           556: 
        !           557:        if (*p++ != '(') {
        !           558:          fprintf(stderr, "%d: missing qualifier for EA\n", lineno);
        !           559:          exit(1);
        !           560:        }
        !           561:        do {
        !           562:          setting = 1;
        !           563:          if (*p == '-') {
        !           564:            p++;
        !           565:            setting = 0;
        !           566:          }
        !           567:          if (!strncmp(p, "*", 1)) {
        !           568:            e[ea_Dreg] = e[ea_Areg] = e[ea_Aind] = e[ea_Ainc] = setting;
        !           569:            e[ea_Adec] = e[ea_Adis] = e[ea_Aidx] = e[ea_AbsW] = setting;
        !           570:            e[ea_AbsL] = e[ea_Pdis] = e[ea_Pidx] = e[ea_Imm] = setting;
        !           571:            p = p+1;
        !           572:          } else if (!strncmp(p, "Regs", 4)) {
        !           573:            e[ea_Dreg] = e[ea_Areg] = setting;
        !           574:            p = p+4;
        !           575:          } else if (!strncmp(p, "PC", 2)) {
        !           576:            e[ea_Pdis] = e[ea_Pidx] = setting;
        !           577:            p = p+2;
        !           578:          } else if (!strncmp(p, "Amod", 4)) {
        !           579:            e[ea_Ainc] = e[ea_Adec] = setting;
        !           580:            p = p+4;
        !           581:          } else if (!strncmp(p, "Dreg", 4)) { e[ea_Dreg] = setting; p = p+4;
        !           582:          } else if (!strncmp(p, "Areg", 4)) { e[ea_Areg] = setting; p = p+4;
        !           583:          } else if (!strncmp(p, "Aind", 4)) { e[ea_Aind] = setting; p = p+4;
        !           584:          } else if (!strncmp(p, "Ainc", 4)) { e[ea_Ainc] = setting; p = p+4;
        !           585:          } else if (!strncmp(p, "Adec", 4)) { e[ea_Adec] = setting; p = p+4;
        !           586:          } else if (!strncmp(p, "Adis", 4)) { e[ea_Adis] = setting; p = p+4;
        !           587:          } else if (!strncmp(p, "Aidx", 4)) { e[ea_Aidx] = setting; p = p+4;
        !           588:          } else if (!strncmp(p, "AbsW", 4)) { e[ea_AbsW] = setting; p = p+4;
        !           589:          } else if (!strncmp(p, "AbsL", 4)) { e[ea_AbsL] = setting; p = p+4;
        !           590:          } else if (!strncmp(p, "Pdis", 4)) { e[ea_Pdis] = setting; p = p+4;
        !           591:          } else if (!strncmp(p, "Pidx", 4)) { e[ea_Pidx] = setting; p = p+4;
        !           592:          } else if (!strncmp(p, "Imm", 3))  { e[ea_Imm]  = setting; p = p+3;
        !           593:          } else {
        !           594:            fprintf(stderr, "%d: unknown qualifier for EA\n", lineno);
        !           595:            exit(1);
        !           596:          }
        !           597:        } while (*p++ == ',');
        !           598:        if (*(p-1) != ')') {
        !           599:          fprintf(stderr, "%d: unknown qualifier for EA\n", lineno);
        !           600:          exit(1);
        !           601:        }
        !           602:        break;
        !           603:       case 'f':
        !           604:        expand_d_ea_f = 1;
        !           605: 
        !           606:        if (*p++ != '(') {
        !           607:          fprintf(stderr, "%d: missing qualifier for EA\n", lineno);
        !           608:          exit(1);
        !           609:        }
        !           610:        do {
        !           611:          setting = 1;
        !           612:          if (*p == '-') {
        !           613:            p++;
        !           614:            setting = 0;
        !           615:          }
        !           616:          if (!strncmp(p, "*", 1)) {
        !           617:            f[ea_Dreg] = f[ea_Areg] = f[ea_Aind] = f[ea_Ainc] = setting;
        !           618:            f[ea_Adec] = f[ea_Adis] = f[ea_Aidx] = f[ea_AbsW] = setting;
        !           619:            f[ea_AbsL] = f[ea_Pdis] = f[ea_Pidx] = f[ea_Imm] = setting;
        !           620:            p = p+1;
        !           621:          } else if (!strncmp(p, "Regs", 4)) {
        !           622:            f[ea_Dreg] = f[ea_Areg] = setting;
        !           623:            p = p+4;
        !           624:          } else if (!strncmp(p, "PC", 2)) {
        !           625:            f[ea_Pdis] = f[ea_Pidx] = setting;
        !           626:            p = p+2;
        !           627:          } else if (!strncmp(p, "Amod", 4)) {
        !           628:            f[ea_Ainc] = f[ea_Adec] = setting;
        !           629:            p = p+4;
        !           630:          } else if (!strncmp(p, "Dreg", 4)) { f[ea_Dreg] = setting; p = p+4;
        !           631:          } else if (!strncmp(p, "Areg", 4)) { f[ea_Areg] = setting; p = p+4;
        !           632:          } else if (!strncmp(p, "Aind", 4)) { f[ea_Aind] = setting; p = p+4;
        !           633:          } else if (!strncmp(p, "Ainc", 4)) { f[ea_Ainc] = setting; p = p+4;
        !           634:          } else if (!strncmp(p, "Adec", 4)) { f[ea_Adec] = setting; p = p+4;
        !           635:          } else if (!strncmp(p, "Adis", 4)) { f[ea_Adis] = setting; p = p+4;
        !           636:          } else if (!strncmp(p, "Aidx", 4)) { f[ea_Aidx] = setting; p = p+4;
        !           637:          } else if (!strncmp(p, "AbsW", 4)) { f[ea_AbsW] = setting; p = p+4;
        !           638:          } else if (!strncmp(p, "AbsL", 4)) { f[ea_AbsL] = setting; p = p+4;
        !           639:          } else if (!strncmp(p, "Pdis", 4)) { f[ea_Pdis] = setting; p = p+4;
        !           640:          } else if (!strncmp(p, "Pidx", 4)) { f[ea_Pidx] = setting; p = p+4;
        !           641:          } else if (!strncmp(p, "Imm", 3))  { f[ea_Imm]  = setting; p = p+3;
        !           642:          } else {
        !           643:            fprintf(stderr, "%d: unknown qualifier for EA\n", lineno);
        !           644:            exit(1);
        !           645:          }
        !           646:        } while (*p++ == ',');
        !           647:        if (*(p-1) != ')') {
        !           648:          fprintf(stderr, "%d: unknown qualifier for EA\n", lineno);
        !           649:          exit(1);
        !           650:        }
        !           651:        break;
        !           652:       default:
        !           653:        fprintf(stderr, "%d: did not understand dest operand\n", lineno);
        !           654:        exit(1);
        !           655:       }
        !           656:     }
        !           657:   }
        !           658:   if (*p != '\0') {
        !           659:     fprintf(stderr, "%d: no end-of-line found at end of line\n", lineno);
        !           660:     exit(1);
        !           661:   }
        !           662: 
        !           663:   /* checks */
        !           664: 
        !           665:   if (expand_d_ea_e) {
        !           666:     if (e[ea_Imm]) {
        !           667:       fprintf(stderr, "%d: Immediate data not allowed as dest\n", lineno);
        !           668:       exit(1);
        !           669:     }
        !           670:   } 
        !           671: 
        !           672:   if (expand_d_ea_f) {
        !           673:     if (f[ea_Imm]) {
        !           674:       fprintf(stderr, "%d: Immediate data not allowed as dest\n", lineno);
        !           675:       exit(1);
        !           676:     }
        !           677:   } 
        !           678: 
        !           679:   if ((num[bite] && !num[bitE]) || (num[bitE] && !num[bite])) {
        !           680:     fprintf(stderr, "%d: There must be both eee and EEE\n", lineno);
        !           681:     exit(1);
        !           682:   }
        !           683: 
        !           684:   if ((num[bitf] && !num[bitF]) || (num[bitF] && !num[bitf])) {
        !           685:     fprintf(stderr, "%d: There must be both fff and FFF\n", lineno);
        !           686:     exit(1);
        !           687:   }
        !           688: 
        !           689:   if (num[bitf] && !expand_d_ea_f) {
        !           690:     fprintf(stderr, "%d: EA 'f' found but not used in description!\n", lineno);
        !           691:     exit(1);
        !           692:   }
        !           693: 
        !           694:   if (num[bite] && expand_d_ea_e && expand_s_ea_e) {
        !           695:     fprintf(stderr, "%d: EA used as both source and destination!\n", lineno);
        !           696:     exit(1);
        !           697:   }
        !           698: 
        !           699:   /* ok, now write to the output a structure for each line we're going to
        !           700:      do a CPU emulation routine for - this means we will expand anything
        !           701:      that might require control flow statements, e.g. EA and size bit
        !           702:      sections but not registers and immediate data that can be done in a
        !           703:      single instruction-wide '&' (and) statement. */
        !           704: 
        !           705:   /* convert size/EA bits to static */
        !           706: 
        !           707:   {
        !           708:     t_size size;
        !           709:     t_datatype ea_e;
        !           710:     t_datatype ea_f;
        !           711:     int skip;
        !           712:     int cc;
        !           713:     int wordlen, type;
        !           714: 
        !           715:     /* loop through 3 different sizes or just once if no size to loop on */
        !           716: 
        !           717:     for (size = isize;
        !           718:         (size == isize) || (num[bitz] && (size <= sz_long)); size++) {
        !           719: 
        !           720:       /* loop through 'e' EA or just once if no EA 'e' to loop on */
        !           721: 
        !           722:       for (ea_e = ea_Dreg;
        !           723:           (ea_e == ea_Dreg) || (num[bite] && (ea_e <= ea_Imm)); ea_e++) {
        !           724: 
        !           725:        /* loop through 'f' EA or just once if no EA 'e' to loop on */
        !           726: 
        !           727:        for (ea_f = ea_Dreg;
        !           728:             (ea_f == ea_Dreg) || (num[bitf] && (ea_f <= ea_Imm)); ea_f++) {
        !           729: 
        !           730:          for (cc = 0; (cc == 0) || (num[bitc] && (cc < 16)); cc++) {
        !           731: 
        !           732:            if (cc == 1)
        !           733:              continue;
        !           734: 
        !           735:            if ((size == sz_none) && num[bitz])
        !           736:              continue;
        !           737: 
        !           738:            /* deal with size */
        !           739: 
        !           740:            if (num[bitz]) {
        !           741:              /* set mask where zz is */
        !           742:              mask |= (3<<start[bitz]);
        !           743:              /* clear bits where zz is */
        !           744:              bits &= ~(3<<start[bitz]);
        !           745:              /* set correct value into where zz is */
        !           746:              switch (size) {
        !           747:              case sz_byte: break;
        !           748:              case sz_word: bits |= (1<<start[bitz]); break;
        !           749:              case sz_long: bits |= (2<<start[bitz]); break;
        !           750:              default:
        !           751:                printf("%d: Invalid size\n", lineno);
        !           752:                continue;
        !           753:              }
        !           754:              if (expand_s_immsize) {
        !           755:                /* source immediate data depends on size of instruction */
        !           756:                switch (size) {
        !           757:                case sz_byte: stype = dt_ImmB; break;
        !           758:                case sz_word: stype = dt_ImmW; break;
        !           759:                case sz_long: stype = dt_ImmL; break;
        !           760:                default:
        !           761:                  printf("%d: Invalid size\n", lineno);
        !           762:                  exit(1);
        !           763:                }
        !           764:              }
        !           765:            }
        !           766: 
        !           767:            /* deal with cc */
        !           768: 
        !           769:            if (num[bitc]) {
        !           770:              /* set mask where cccc is */
        !           771:              mask |= (15<<start[bitc]);
        !           772:              /* clear bits where cccc is */
        !           773:              bits &= ~(15<<start[bitc]);
        !           774:              /* set correct value into where cccc is */
        !           775:              bits |= cc<<start[bitc];
        !           776:            }
        !           777:            
        !           778:            /* deal with EA 'e' when used as source */
        !           779:            
        !           780:            if (num[bite] && expand_s_ea_e) {
        !           781:              if (!e[ea_e]) {
        !           782:                /* this has been disabled using -Axyz */
        !           783:                continue;
        !           784:              }
        !           785:              /* clear everything */
        !           786:              mask |= (7<<start[bite]);  /* set mask for eee */
        !           787:              mask &= ~(7<<start[bitE]); /* clear mask for EEE */
        !           788:              bits &= ~(7<<start[bite]); /* clear bits in eee */
        !           789:              bits &= ~(7<<start[bitE]); /* clear bits in EEE */
        !           790:              if (ea_e <= ea_Aidx) {
        !           791:                /* ea mode with register in second part */
        !           792:                bits |= (ea_e<<start[bite]);
        !           793:                switch (ea_e) {
        !           794:                case ea_Dreg: stype = dt_Dreg; sbitpos = start[bitE]; break;
        !           795:                case ea_Areg: stype = dt_Areg; sbitpos = start[bitE]; break;
        !           796:                case ea_Aind: stype = dt_Aind; sbitpos = start[bitE]; break;
        !           797:                case ea_Ainc: stype = dt_Ainc; sbitpos = start[bitE]; break;
        !           798:                case ea_Adec: stype = dt_Adec; sbitpos = start[bitE]; break;
        !           799:                case ea_Adis: stype = dt_Adis; sbitpos = start[bitE]; break;
        !           800:                case ea_Aidx: stype = dt_Aidx; sbitpos = start[bitE]; break;
        !           801:                default: abort();
        !           802:                }
        !           803:              } else {
        !           804:                bits |= (7<<start[bite]); /* eee should be 111 */
        !           805:                mask |= (7<<start[bitE]);
        !           806:                switch (ea_e) {
        !           807:                case ea_AbsW: stype = dt_AbsW; bits |= (0<<start[bitE]); break;
        !           808:                case ea_AbsL: stype = dt_AbsL; bits |= (1<<start[bitE]); break;
        !           809:                case ea_Pdis: stype = dt_Pdis; bits |= (2<<start[bitE]); break;
        !           810:                case ea_Pidx: stype = dt_Pidx; bits |= (3<<start[bitE]); break;
        !           811:                case ea_Imm:
        !           812:                  bits |= (4<<start[bitE]);
        !           813:                  switch (size) {
        !           814:                  case sz_byte: stype = dt_ImmB; break;
        !           815:                  case sz_word: stype = dt_ImmW; break;
        !           816:                  case sz_long: stype = dt_ImmL; break;
        !           817:                  default:
        !           818:                    printf("%d: Invalid size\n", lineno);
        !           819:                    exit(1);
        !           820:                  }
        !           821:                  break;
        !           822:                default: abort();
        !           823:                }
        !           824:              }
        !           825:            }
        !           826:            
        !           827:            /* deal with EA 'e' when used as destination */
        !           828:            
        !           829:            if (num[bite] && expand_d_ea_e) {
        !           830:              if (!e[ea_e]) {
        !           831:                /* this has been disabled using -Axyz */
        !           832:                continue;
        !           833:              }
        !           834:              /* clear everything */
        !           835:              mask |= (7<<start[bite]);  /* set mask for eee */
        !           836:              mask &= ~(7<<start[bitE]); /* clear mask for EEE */
        !           837:              bits &= ~(7<<start[bite]); /* clear bits in eee */
        !           838:              bits &= ~(7<<start[bitE]); /* clear bits in EEE */
        !           839:              if (ea_e <= ea_Aidx) {
        !           840:                /* ea mode with register in second part */
        !           841:                bits |= (ea_e<<start[bite]);
        !           842:                switch (ea_e) {
        !           843:                case ea_Dreg: dtype = dt_Dreg; dbitpos = start[bitE]; break;
        !           844:                case ea_Areg: dtype = dt_Areg; dbitpos = start[bitE]; break;
        !           845:                case ea_Aind: dtype = dt_Aind; dbitpos = start[bitE]; break;
        !           846:                case ea_Ainc: dtype = dt_Ainc; dbitpos = start[bitE]; break;
        !           847:                case ea_Adec: dtype = dt_Adec; dbitpos = start[bitE]; break;
        !           848:                case ea_Adis: dtype = dt_Adis; dbitpos = start[bitE]; break;
        !           849:                case ea_Aidx: dtype = dt_Aidx; dbitpos = start[bitE]; break;
        !           850:                default: abort();
        !           851:                }
        !           852:              } else {
        !           853:                bits |= (7<<start[bite]); /* eee should be 111 */
        !           854:                mask |= (7<<start[bitE]);
        !           855:                switch (ea_e) {
        !           856:                case ea_AbsW: dtype = dt_AbsW; bits |= (0<<start[bitE]); break;
        !           857:                case ea_AbsL: dtype = dt_AbsL; bits |= (1<<start[bitE]); break;
        !           858:                case ea_Pdis: dtype = dt_Pdis; bits |= (2<<start[bitE]); break;
        !           859:                case ea_Pidx: dtype = dt_Pidx; bits |= (3<<start[bitE]); break;
        !           860:                case ea_Imm:
        !           861:                  bits |= (4<<start[bitE]);
        !           862:                  switch (size) {
        !           863:                  case sz_byte: dtype = dt_ImmB; break;
        !           864:                  case sz_word: dtype = dt_ImmW; break;
        !           865:                  case sz_long: dtype = dt_ImmL; break;
        !           866:                  default:
        !           867:                    printf("%d: Invalid size\n", lineno);
        !           868:                    exit(1);
        !           869:                  }
        !           870:                  break;
        !           871:                default: abort();
        !           872:                }
        !           873:              }
        !           874:            }
        !           875:            
        !           876:            /* deal with EA 'f' when used as destination */
        !           877:            
        !           878:            if (num[bitf] && expand_d_ea_f) {
        !           879:              if (!f[ea_f]) {
        !           880:                /* this has been disabled using -Axyz */
        !           881:                continue;
        !           882:              }
        !           883:              /* clear everything */
        !           884:              mask |= (7<<start[bitf]);  /* set mask for fff */
        !           885:              mask &= ~(7<<start[bitF]); /* clear mask for FFF */
        !           886:              bits &= ~(7<<start[bitf]); /* clear bits in fff */
        !           887:              bits &= ~(7<<start[bitF]); /* clear bits in FFF */
        !           888:              if (ea_f <= ea_Aidx) {
        !           889:                /* ea mode with register in second part */
        !           890:                bits |= (ea_f<<start[bitf]);
        !           891:                switch (ea_f) {
        !           892:                case ea_Dreg: dtype = dt_Dreg; dbitpos = start[bitF]; break;
        !           893:                case ea_Areg: dtype = dt_Areg; dbitpos = start[bitF]; break;
        !           894:                case ea_Aind: dtype = dt_Aind; dbitpos = start[bitF]; break;
        !           895:                case ea_Ainc: dtype = dt_Ainc; dbitpos = start[bitF]; break;
        !           896:                case ea_Adec: dtype = dt_Adec; dbitpos = start[bitF]; break;
        !           897:                case ea_Adis: dtype = dt_Adis; dbitpos = start[bitF]; break;
        !           898:                case ea_Aidx: dtype = dt_Aidx; dbitpos = start[bitF]; break;
        !           899:                default: abort();
        !           900:                }
        !           901:              } else {
        !           902:                bits |= (7<<start[bitf]); /* eee should be 111 */
        !           903:                mask |= (7<<start[bitF]);
        !           904:                switch (ea_f) {
        !           905:                case ea_AbsW: dtype = dt_AbsW; bits |= (0<<start[bitF]); break;
        !           906:                case ea_AbsL: dtype = dt_AbsL; bits |= (1<<start[bitF]); break;
        !           907:                case ea_Pdis: dtype = dt_Pdis; bits |= (2<<start[bitF]); break;
        !           908:                case ea_Pidx: dtype = dt_Pidx; bits |= (3<<start[bitF]); break;
        !           909:                case ea_Imm:
        !           910:                  bits |= (4<<start[bitF]);
        !           911:                  switch (size) {
        !           912:                  case sz_byte: dtype = dt_ImmB; break;
        !           913:                  case sz_word: dtype = dt_ImmW; break;
        !           914:                  case sz_long: dtype = dt_ImmL; break;
        !           915:                  default:
        !           916:                    printf("%d: Invalid size\n", lineno);
        !           917:                    exit(1);
        !           918:                  }
        !           919:                  break;
        !           920:                default: abort();
        !           921:                }
        !           922:              }
        !           923:            }
        !           924: 
        !           925:            wordlen = 1;
        !           926:            for (type = 0; type < 2; type++) {
        !           927:              switch(type ? stype : dtype) {
        !           928:              case dt_Ill:
        !           929:              case dt_Dreg:
        !           930:              case dt_Areg:
        !           931:              case dt_Aind:
        !           932:              case dt_Ainc:
        !           933:              case dt_Adec:
        !           934:                break;
        !           935:              case dt_Adis:
        !           936:              case dt_Aidx:
        !           937:              case dt_AbsW:
        !           938:              case dt_Pdis:
        !           939:              case dt_Pidx:
        !           940:              case dt_ImmB:
        !           941:              case dt_ImmW:
        !           942:                wordlen++;
        !           943:                break;
        !           944:              case dt_AbsL:
        !           945:              case dt_ImmL:
        !           946:                wordlen+= 2;
        !           947:                break;
        !           948:              case dt_ImmS:
        !           949:              case dt_Imm3:
        !           950:              case dt_Imm4:
        !           951:              case dt_Imm8:
        !           952:              case dt_Imm8s:
        !           953:              case dt_ImmV:
        !           954:                break;
        !           955:              default:
        !           956:                printf("%d: Invalid type\n", lineno);
        !           957:                exit(1);
        !           958:              }
        !           959:            }
        !           960: 
        !           961:            clocks = -1;
        !           962: 
        !           963:            switch(mnemonic_num) {
        !           964:            case i_OR:
        !           965:            case i_AND:
        !           966:            case i_EOR:
        !           967:              clocks = 4;
        !           968:              clocks+= clocks_eacalc(stype, size);
        !           969:              clocks+= clocks_eafetch(stype, size);
        !           970:              clocks+= clocks_eacalc(dtype, size);
        !           971:              clocks+= clocks_eafetch(dtype, size);
        !           972:              clocks+= clocks_standard(stype, dtype, size);
        !           973:              break;
        !           974:            case i_ORSR:
        !           975:            case i_ANDSR:
        !           976:            case i_EORSR:
        !           977:              clocks = 20;
        !           978:              break;
        !           979:            case i_SUB:
        !           980:            case i_SUBA:
        !           981:            case i_ADD:
        !           982:            case i_ADDA:
        !           983:              clocks = 4;
        !           984:              clocks+= clocks_eacalc(stype, size);
        !           985:              clocks+= clocks_eafetch(stype, size);
        !           986:              clocks+= clocks_eacalc(dtype, size);
        !           987:              clocks+= clocks_eafetch(dtype, size);
        !           988:              clocks+= clocks_standard(stype, dtype, size);
        !           989:              break;
        !           990:            case i_SUBX:
        !           991:            case i_ADDX:
        !           992:              if (stype == dt_Dreg) {
        !           993:                if (size != sz_long) {
        !           994:                  clocks = 4;
        !           995:                } else {
        !           996:                  clocks = 8;
        !           997:                }
        !           998:              } else {
        !           999:                if (size != sz_long) {
        !          1000:                  clocks = 18;
        !          1001:                } else {
        !          1002:                  clocks = 30;
        !          1003:                }
        !          1004:              }
        !          1005:              break;
        !          1006:            case i_MULU:
        !          1007:            case i_MULS:
        !          1008:              clocks = 54;
        !          1009:              clocks+= clocks_eacalc(stype, size);
        !          1010:              clocks+= clocks_eafetch(stype, size);
        !          1011:              break;
        !          1012:            case i_CMP:
        !          1013:            case i_CMPA:
        !          1014:              if (dtype == dt_Areg) {
        !          1015:                clocks = 6;
        !          1016:              } else {
        !          1017:                if (size != sz_long) {
        !          1018:                  clocks = 4;
        !          1019:                } else {
        !          1020:                  clocks = 6;
        !          1021:                }
        !          1022:              }
        !          1023:              clocks+= clocks_eacalc(stype, size);
        !          1024:              clocks+= clocks_eafetch(stype, size);
        !          1025:              break;
        !          1026:            case i_BTST:
        !          1027:              if (stype == dt_Dreg) {
        !          1028:                /* dynamic */
        !          1029:                if (dtype == dt_Dreg) {
        !          1030:                  clocks = 6;
        !          1031:                } else {
        !          1032:                  clocks = 4;
        !          1033:                }
        !          1034:              } else {
        !          1035:                /* static */
        !          1036:                if (dtype == dt_Dreg) {
        !          1037:                  clocks = 10;
        !          1038:                } else {
        !          1039:                  clocks = 8;
        !          1040:                }
        !          1041:              }
        !          1042:              clocks+= clocks_eacalc(dtype, size);
        !          1043:              clocks+= clocks_eafetch(dtype, size);
        !          1044:              break;
        !          1045:            case i_BCHG:
        !          1046:            case i_BSET:
        !          1047:              if (stype == dt_Dreg) {
        !          1048:                /* dynamic */
        !          1049:                clocks = 8;
        !          1050:              } else {
        !          1051:                /* static */
        !          1052:                clocks = 12;
        !          1053:              }
        !          1054:              clocks+= clocks_eacalc(dtype, size);
        !          1055:              clocks+= clocks_eafetch(dtype, size);
        !          1056:              break;
        !          1057:            case i_BCLR:
        !          1058:              if (stype == dt_Dreg) {
        !          1059:                /* dynamic */
        !          1060:                if (dtype == dt_Dreg) {
        !          1061:                  clocks = 10;
        !          1062:                } else {
        !          1063:                  clocks = 8;
        !          1064:                }
        !          1065:              } else {
        !          1066:                /* static */
        !          1067:                if (dtype == dt_Dreg) {
        !          1068:                  clocks = 14;
        !          1069:                } else {
        !          1070:                  clocks = 12;
        !          1071:                }
        !          1072:              }
        !          1073:              clocks+= clocks_eacalc(dtype, size);
        !          1074:              clocks+= clocks_eafetch(dtype, size);
        !          1075:              break;
        !          1076:            case i_MOVE:
        !          1077:            case i_MOVEA:
        !          1078:              clocks = 4;
        !          1079:              clocks+= clocks_eacalc(stype, size);
        !          1080:              clocks+= clocks_eafetch(stype, size);
        !          1081:              clocks+= clocks_eacalc(dtype, size);
        !          1082:              clocks+= clocks_eafetch(dtype, size);
        !          1083:              break;
        !          1084:            case i_MOVEPRM:
        !          1085:            case i_MOVEPMR:
        !          1086:              if (size == sz_long) {
        !          1087:                clocks = 24;
        !          1088:              } else {
        !          1089:                clocks = 16;
        !          1090:              }
        !          1091:              break;
        !          1092:            case i_MOVEFSR:
        !          1093:              if (stype == dt_Dreg) {
        !          1094:                clocks = 6;
        !          1095:              } else {
        !          1096:                clocks = 8;
        !          1097:              }
        !          1098:              clocks+= clocks_eacalc(stype, size);
        !          1099:              clocks+= clocks_eafetch(stype, size);
        !          1100:              break;
        !          1101:            case i_MOVETSR:
        !          1102:              clocks = 12;
        !          1103:              clocks+= clocks_eacalc(stype, size);
        !          1104:              clocks+= clocks_eafetch(stype, size);
        !          1105:              break;
        !          1106:            case i_MOVEMMR:
        !          1107:              clocks = 20;
        !          1108:              break;
        !          1109:            case i_MOVEMRM:
        !          1110:              clocks = 16;
        !          1111:              break;
        !          1112:            case i_MOVETUSP:
        !          1113:            case i_MOVEFUSP:
        !          1114:              clocks = 4;
        !          1115:            case i_NEG:
        !          1116:            case i_NEGX:
        !          1117:            case i_CLR:
        !          1118:            case i_NOT:
        !          1119:              clocks = clocks_single(stype, size);
        !          1120:              clocks+= clocks_eacalc(stype, size);
        !          1121:              clocks+= clocks_eafetch(stype, size);
        !          1122:              break;
        !          1123:            case i_ABCD:
        !          1124:            case i_SBCD:
        !          1125:              if (stype == dt_Dreg) {
        !          1126:                clocks = 6;
        !          1127:              } else {
        !          1128:                clocks = 18;
        !          1129:              }
        !          1130:              break;
        !          1131:            case i_NBCD:
        !          1132:              if (stype == dt_Dreg || stype == dt_Areg) {
        !          1133:                clocks = 6;
        !          1134:              } else {
        !          1135:                clocks = 8;
        !          1136:                clocks+= clocks_eacalc(stype, size);
        !          1137:                clocks+= clocks_eafetch(stype, size);
        !          1138:              }
        !          1139:              break;
        !          1140:            case i_SWAP:
        !          1141:              clocks = 4;
        !          1142:              break;
        !          1143:            case i_PEA:
        !          1144:              clocks = 8;
        !          1145:              clocks+= clocks_eacalc(stype, size);
        !          1146:              clocks+= clocks_eafetch(stype, size);
        !          1147:              break;
        !          1148:            case i_LEA:
        !          1149:              clocks = 4;
        !          1150:              clocks+= clocks_eacalc(stype, size);
        !          1151:              break;
        !          1152:            case i_EXT:
        !          1153:              clocks = 4;
        !          1154:              break;
        !          1155:            case i_EXG:
        !          1156:              clocks = 6;
        !          1157:              break;
        !          1158:            case i_TST:
        !          1159:              clocks = 4;
        !          1160:              clocks+= clocks_eacalc(stype, size);
        !          1161:              clocks+= clocks_eafetch(stype, size);
        !          1162:              break;
        !          1163:            case i_TAS:
        !          1164:              if (stype == dt_Dreg || stype == dt_Areg) {
        !          1165:                clocks = 4;
        !          1166:              } else {
        !          1167:                clocks = 10;
        !          1168:              }
        !          1169:              break;
        !          1170:            case i_CHK:
        !          1171:              clocks = 10;
        !          1172:              clocks+= clocks_eacalc(stype, size);
        !          1173:              clocks+= clocks_eafetch(stype, size);
        !          1174:              break;
        !          1175:            case i_TRAPV:
        !          1176:              clocks = 4;
        !          1177:              break;
        !          1178:            case i_TRAP:
        !          1179:              clocks = 4; /* exception */
        !          1180:              break;
        !          1181:            case i_RESET:
        !          1182:              clocks = 132;
        !          1183:              break;
        !          1184:            case i_NOP:
        !          1185:              clocks = 4;
        !          1186:              break;
        !          1187:            case i_STOP:
        !          1188:              clocks = 4;
        !          1189:              break;
        !          1190:            case i_LINK:
        !          1191:              clocks = 16;
        !          1192:              break;
        !          1193:            case i_UNLK:
        !          1194:              clocks = 12;
        !          1195:              break;
        !          1196:            case i_RTE:
        !          1197:              clocks = 20;
        !          1198:              break;
        !          1199:            case i_RTS:
        !          1200:              clocks = 16;
        !          1201:              break;
        !          1202:            case i_RTR:
        !          1203:              clocks = 20;
        !          1204:              break;
        !          1205:            case i_JSR:
        !          1206:              clocks = 16;
        !          1207:              clocks+= clocks_eacalc(stype, size);
        !          1208:              break;
        !          1209:            case i_JMP:
        !          1210:              clocks = 8;
        !          1211:              clocks+= clocks_eacalc(stype, size);
        !          1212:              break;
        !          1213:            case i_Scc:
        !          1214:              if (stype == dt_Dreg || stype == dt_Areg) {
        !          1215:                clocks = 4;
        !          1216:              } else {
        !          1217:                clocks = 8;
        !          1218:                clocks+= clocks_eacalc(stype, size);
        !          1219:                clocks+= clocks_eafetch(stype, size);
        !          1220:              }
        !          1221:              break;
        !          1222:            case i_SF:
        !          1223:              if (stype == dt_Dreg || stype == dt_Areg) {
        !          1224:                clocks = 4;
        !          1225:              } else {
        !          1226:                clocks = 8;
        !          1227:                clocks+= clocks_eacalc(stype, size);
        !          1228:                clocks+= clocks_eafetch(stype, size);
        !          1229:              }
        !          1230:              break;
        !          1231:            case i_DBcc:
        !          1232:            case i_DBRA:
        !          1233:              clocks = 10;
        !          1234:              break;
        !          1235:            case i_Bcc:
        !          1236:              if (size == sz_byte) {
        !          1237:                clocks = 8;
        !          1238:              } else {
        !          1239:                clocks = 10;
        !          1240:              }
        !          1241:              break;
        !          1242:            case i_BSR:
        !          1243:              clocks = 18;
        !          1244:              break;
        !          1245:            case i_DIVU:
        !          1246:              clocks = 140;
        !          1247:              clocks+= clocks_eacalc(stype, size);
        !          1248:              clocks+= clocks_eafetch(stype, size);
        !          1249:              break;
        !          1250:            case i_DIVS:
        !          1251:              clocks = 128;
        !          1252:              clocks+= clocks_eacalc(stype, size);
        !          1253:              clocks+= clocks_eafetch(stype, size);
        !          1254:              break;
        !          1255:            case i_ASR:
        !          1256:            case i_LSR:
        !          1257:            case i_ROXR:
        !          1258:            case i_ROR:
        !          1259:            case i_ASL:
        !          1260:            case i_LSL:
        !          1261:            case i_ROXL:
        !          1262:            case i_ROL:
        !          1263:              clocks = 8;
        !          1264:              clocks+= clocks_eacalc(dtype, size);
        !          1265:              clocks+= clocks_eafetch(dtype, size);
        !          1266:              break;
        !          1267:            case i_ILLG:
        !          1268:              clocks = 0;
        !          1269:              break;
        !          1270:            case i_LINE10:
        !          1271:            case i_LINE15:
        !          1272:              clocks = 4; /* exception */
        !          1273:              break;
        !          1274:            default:
        !          1275:              printf("%d: Invalid mnemonic type\n", lineno);
        !          1276:              exit(1);
        !          1277:            }
        !          1278: 
        !          1279:            if (clocks == -1) {
        !          1280:              printf("%d: Clocks not found\n", lineno);
        !          1281:              exit(1);
        !          1282:            }
        !          1283: 
        !          1284:            /* write output lines */
        !          1285:            
        !          1286:            fprintf(outiibs, "  { 0x%x, 0x%x, %d, { %d, %d, %d, %d, %d }, ",
        !          1287:                    mask, bits, mnemonic_num, priv, endblk, imm_notzero, used,
        !          1288:                    set);
        !          1289:            fprintf(outiibs, "%d, %d, %d, %d, %d, %d, %d, %d, %d, %d},\n",
        !          1290:                    size, stype, dtype, sbitpos, dbitpos, immvalue,
        !          1291:                    cc, total, wordlen, clocks);
        !          1292:            fprintf(outiibs, "%60s/* %s */\n", "", mnemonic);
        !          1293:            if (set == 0) {
        !          1294:              fprintf(outfuncs, "  cpu_op_%ia, /* %s */\n", total, mnemonic);
        !          1295:              fprintf(outfuncs, "  cpu_op_%ia, /* %s */\n", total, mnemonic);
        !          1296:              fprintf(outproto, "extern void cpu_op_%ia("
        !          1297:                      "t_ipc *ipc); /* %s */\n", total, mnemonic);
        !          1298:            } else {
        !          1299:              fprintf(outfuncs, "  cpu_op_%ia, /* %s - normal */\n", total,
        !          1300:                      mnemonic);
        !          1301:              fprintf(outfuncs, "  cpu_op_%ib, /* %s - no flags */\n", total,
        !          1302:                      mnemonic);
        !          1303:              fprintf(outproto, "extern void cpu_op_%ia("
        !          1304:                      "t_ipc *ipc); /* %s */\n", total, mnemonic);
        !          1305:              fprintf(outproto, "extern void cpu_op_%ib("
        !          1306:                      "t_ipc *ipc); /* %s */\n", total, mnemonic);
        !          1307:            }
        !          1308:            
        !          1309:            total++;
        !          1310: 
        !          1311:          } /* cc */
        !          1312:        } /* ea_f */
        !          1313:       } /* ea_e */
        !          1314:     } /* size */
        !          1315:   } /* block */
        !          1316: }
        !          1317: 
        !          1318: int clocks_eacalc(t_datatype type, t_size size)
        !          1319: {
        !          1320:   switch(type) {
        !          1321:   case dt_Dreg:
        !          1322:   case dt_Areg:
        !          1323:     break;
        !          1324:   case dt_Aind:
        !          1325:   case dt_Ainc:
        !          1326:     break;
        !          1327:   case dt_Adec:
        !          1328:     return 2;
        !          1329:   case dt_Adis:
        !          1330:     return 4;
        !          1331:   case dt_Aidx:
        !          1332:     return 6;
        !          1333:   case dt_AbsW:
        !          1334:     return 4;
        !          1335:   case dt_AbsL:
        !          1336:     return 8;
        !          1337:   case dt_Pdis:
        !          1338:     return 4;
        !          1339:   case dt_Pidx:
        !          1340:     return 6;
        !          1341:   case dt_ImmB:
        !          1342:   case dt_ImmW:
        !          1343:   case dt_ImmL:
        !          1344:     break;
        !          1345:   case dt_ImmS:
        !          1346:   case dt_Imm3:
        !          1347:   case dt_Imm4:
        !          1348:   case dt_Imm8:
        !          1349:   case dt_Imm8s:
        !          1350:   case dt_Ill:
        !          1351:     break;
        !          1352:   default:
        !          1353:     printf("Invalid type for clocks\n");
        !          1354:     exit(1);
        !          1355:   }
        !          1356:   return 0;
        !          1357: }
        !          1358: 
        !          1359: int clocks_eafetch(t_datatype type, t_size size)
        !          1360: {
        !          1361:   switch(type) {
        !          1362:   case dt_Dreg:
        !          1363:   case dt_Areg:
        !          1364:     break;
        !          1365:   case dt_Aind:
        !          1366:   case dt_Ainc:
        !          1367:   case dt_Adec:
        !          1368:   case dt_Adis:
        !          1369:   case dt_Aidx:
        !          1370:   case dt_AbsW:
        !          1371:   case dt_AbsL:
        !          1372:   case dt_Pdis:
        !          1373:   case dt_Pidx:
        !          1374:   case dt_ImmB:
        !          1375:   case dt_ImmW:
        !          1376:   case dt_ImmL:
        !          1377:     if (size == sz_long)
        !          1378:       return 8;
        !          1379:     else
        !          1380:       return 4;
        !          1381:     break;
        !          1382:   case dt_ImmS:
        !          1383:   case dt_Imm3:
        !          1384:   case dt_Imm4:
        !          1385:   case dt_Imm8:
        !          1386:   case dt_Imm8s:
        !          1387:   case dt_Ill:
        !          1388:     break;
        !          1389:   default:
        !          1390:     printf("Invalid type for clocks\n");
        !          1391:     exit(1);
        !          1392:   }
        !          1393:   return 0;
        !          1394: }
        !          1395: 
        !          1396: int clocks_standard(t_datatype stype, t_datatype dtype, t_size size)
        !          1397: {
        !          1398:   int stype_imm = (stype == dt_ImmB) || (stype == dt_ImmW) ||
        !          1399:     (stype == dt_ImmL) || (stype == dt_Imm3) || (stype == dt_Imm4) ||
        !          1400:     (stype == dt_Imm8) || (stype == dt_Imm8s) || (stype == dt_ImmS);
        !          1401: 
        !          1402:   if (stype_imm) {
        !          1403:     if (dtype == dt_Areg) {
        !          1404:       return 4;
        !          1405:     } else if (dtype == dt_Dreg) {
        !          1406:       if (size != sz_long) {
        !          1407:        return 0;
        !          1408:       } else {
        !          1409:        return 4;
        !          1410:       }
        !          1411:     } else {
        !          1412:       if (size != sz_long) {
        !          1413:        return 4;
        !          1414:       } else {
        !          1415:        return 8;
        !          1416:       }
        !          1417:     }
        !          1418:   }
        !          1419: 
        !          1420:   if (dtype == dt_Areg) {
        !          1421:     if (size != sz_long) {
        !          1422:       return 4;
        !          1423:     } else {
        !          1424:       if (stype == dt_Dreg || stype_imm) {
        !          1425:        return 4;
        !          1426:       } else {
        !          1427:        return 2;
        !          1428:       }
        !          1429:     }
        !          1430:   } else if (dtype == dt_Dreg) {
        !          1431:     if (size != sz_long) {
        !          1432:       return 0;
        !          1433:     } else {
        !          1434:       if (stype == dt_Dreg || stype_imm) {
        !          1435:        return 4;
        !          1436:       } else {
        !          1437:        return 2;
        !          1438:       }
        !          1439:     }
        !          1440:   } else if (stype == dt_Dreg) {
        !          1441:     if (size != sz_long) {
        !          1442:       return 4;
        !          1443:     } else {
        !          1444:       return 8;
        !          1445:     }
        !          1446:   } else {
        !          1447:     printf("Error %d %d.\n", stype, dtype);
        !          1448:     exit(1);
        !          1449:   }
        !          1450: }
        !          1451: 
        !          1452: int clocks_single(t_datatype type, t_size size)
        !          1453: {
        !          1454:   if (type == dt_Dreg || type == dt_Areg) {
        !          1455:     if (size != sz_long) {
        !          1456:       return 4;
        !          1457:     } else {
        !          1458:       return 6;
        !          1459:     }
        !          1460:   } else {
        !          1461:     if (size != sz_long) {
        !          1462:       return 8;
        !          1463:     } else {
        !          1464:       return 12;
        !          1465:     }
        !          1466:   }
        !          1467: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.