Return to build68k.c CVS log

Up to [UNIX Amiga Emulator] / uae

Annotation of uae/build68k.c, revision 1.1.1.1

1.1       root        1: /* 
                      2:  * UAE - The Un*x Amiga Emulator
                      3:  *
                      4:  * Read 68000 CPU specs from file "table68k" and build table68k.c
                      5:  *
                      6:  * Copyright 1995,1996 Bernd Schmidt
                      7:  */
                      8: 
                      9: #include "sysconfig.h"
                     10: #include "sysdeps.h"
                     11: 
                     12: #include <assert.h>
                     13: #include <ctype.h>
                     14: 
                     15: #include "config.h"
                     16: #include "options.h"
                     17: #include "readcpu.h"
                     18: 
                     19: static FILE *tablef;
                     20: static int nextch = 0;
                     21: 
                     22: static void getnextch(void)
                     23: {
                     24:     do {
                     25:        nextch = fgetc(tablef);
                     26:        if (nextch == '%') {
                     27:            do {
                     28:                nextch = fgetc(tablef);
                     29:            } while (nextch != EOF && nextch != '\n');  
                     30:        }
                     31:     } while (nextch != EOF && isspace(nextch));        
                     32: }
                     33: 
                     34: int main(int argc, char **argv)
                     35: {
                     36:     int no_insns = 0;
                     37: 
                     38:     printf ("#include \"sysconfig.h\"\n");
                     39:     printf ("#include \"sysdeps.h\"\n");
                     40:     printf ("#include \"config.h\"\n");
                     41:     printf ("#include \"options.h\"\n");
                     42:     printf ("#include \"readcpu.h\"\n");
                     43:     printf ("struct instr_def defs68k[] = {\n");
                     44:     tablef = fopen("table68k","r");
                     45:     if (tablef == NULL) {
                     46:        fprintf(stderr, "table68k not found\n");
                     47:        exit(1);
                     48:     }
                     49:     getnextch();
                     50:     while (nextch != EOF) {
                     51:        int cpulevel, plevel;
                     52:        long int opc;
                     53:        int i;
                     54:        
                     55:        char patbits[16];
                     56:        char opcstr[256];
                     57:        int bitpos[16];
                     58:        
                     59:        UWORD bitmask,bitpattern;
                     60:        int n_variable;
                     61:        
                     62:        n_variable = 0;
                     63:        bitmask = bitpattern = 0;
                     64:        memset (bitpos, 0, sizeof(bitpos));
                     65:        for(i=0; i<16; i++) {
                     66:            int currbit;
                     67:            bitmask <<= 1;
                     68:            bitpattern <<= 1;
                     69:        
                     70:            switch (nextch) {
                     71:             case '0': currbit = bit0; bitmask |= 1; break;
                     72:             case '1': currbit = bit1; bitmask |= 1; bitpattern |= 1; break;
                     73:             case 'c': currbit = bitc; break;
                     74:             case 'C': currbit = bitC; break;
                     75:             case 'f': currbit = bitf; break;
                     76:             case 'i': currbit = biti; break;
                     77:             case 'I': currbit = bitI; break;
                     78:             case 'j': currbit = bitj; break;
                     79:             case 'J': currbit = bitJ; break;
                     80:             case 's': currbit = bits; break;
                     81:             case 'S': currbit = bitS; break;
                     82:             case 'd': currbit = bitd; break;
                     83:             case 'D': currbit = bitD; break;
                     84:             case 'r': currbit = bitr; break;
                     85:             case 'R': currbit = bitR; break;
                     86:             case 'z': currbit = bitz; break;
                     87:             default: abort();
                     88:            }
                     89:            if (!(bitmask & 1)) {
                     90:                bitpos[n_variable] = currbit;
                     91:                n_variable++;
                     92:            }
                     93:            
                     94:            if (nextch == '0' || nextch == '1') 
                     95:                bitmask |= 1;
                     96:            if (nextch == '1') 
                     97:                bitpattern |= 1;
                     98:            patbits[i] = nextch;
                     99:            getnextch();
                    100:        }
                    101:        while (isspace(nextch) || nextch == ':') 
                    102:            getnextch();
                    103:        switch (nextch) {
                    104:         case '0': cpulevel = 0; break;
                    105:         case '1': cpulevel = 1; break;
                    106:         case '2': cpulevel = 2; break;
                    107:         default: abort();
                    108:        }
                    109:        getnextch();
                    110:        
                    111:        switch (nextch) {
                    112:         case '0': plevel = 0; break;
                    113:         case '1': plevel = 1; break;
                    114:         case '2': plevel = 2; break;
                    115:         case '3': plevel = 3; break;
                    116:         default: abort();
                    117:        }
                    118:        getnextch();
                    119: 
                    120:        while (isspace(nextch))
                    121:            getnextch();
                    122:        
                    123:        if (nextch != ':')
                    124:            abort();
                    125:        fgets(opcstr, 250, tablef);
                    126:        getnextch();
                    127:        if (cpulevel <= CPU_LEVEL) {
                    128:            int j;
                    129:            /* Remove superfluous spaces from the string */
                    130:            char *opstrp = opcstr, *osendp;
                    131:            int slen = 0;
                    132: 
                    133:            while (isspace(*opstrp))
                    134:                opstrp++;
                    135:            
                    136:            osendp = opstrp;
                    137:            while (*osendp) {
                    138:                if (!isspace (*osendp))
                    139:                    slen = osendp - opstrp + 1;
                    140:                osendp++;
                    141:            }
                    142:            opstrp[slen] = 0;
                    143:            
                    144:            if (no_insns > 0)
                    145:                printf(",\n");
                    146:            no_insns++;
                    147:            printf("{ %d, %d, {", bitpattern, n_variable);
                    148:            for (j = 0; j < 16; j++) {
                    149:                printf("%d", bitpos[j]);
                    150:                if (j < 15)
                    151:                    printf(",");
                    152:            }
                    153:            printf ("}, %d, %d, \"%s\"}", bitmask, plevel, opstrp);
                    154:        }
                    155:     }
                    156:     printf("};\nint n_defs68k = %d;\n", no_insns);
                    157:     fclose(tablef);
                    158:     return 0;
                    159: }

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