src/libcpu/m68kmake.c

   1 /* ======================================================================== */
   2 /* ========================= LICENSING & COPYRIGHT ======================== */
   3 /* ======================================================================== */
   4 /*
   5  *                                  MUSASHI
   6  *                                Version 3.4
   7  *
   8  * A portable Motorola M680x0 processor emulation engine.
   9  * Copyright 1998-2001 Karl Stenerud.  All rights reserved.
  10  *
  11  * Permission is hereby granted, free of charge, to any person obtaining a copy
  12  * of this software and associated documentation files (the "Software"), to deal
  13  * in the Software without restriction, including without limitation the rights
  14  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  15  * copies of the Software, and to permit persons to whom the Software is
  16  * furnished to do so, subject to the following conditions:
  17  *
  18  * The above copyright notice and this permission notice shall be included in
  19  * all copies or substantial portions of the Software.
  20
  21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  22  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  23  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  24  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  25  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  26  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  27  * THE SOFTWARE.
  28  */
  29
  30
  31
  32 /* ======================================================================== */
  33 /* ============================ CODE GENERATOR ============================ */
  34 /* ======================================================================== */
  35 /*
  36  * This is the code generator program which will generate the opcode table
  37  * and the final opcode handlers.
  38  *
  39  * It requires an input file to function (default m68k_in.c), but you can
  40  * specify your own like so:
  41  *
  42  * m68kmake <output path> <input file>
  43  *
  44  * where output path is the path where the output files should be placed, and
  45  * input file is the file to use for input.
  46  *
  47  * If you modify the input file greatly from its released form, you may have
  48  * to tweak the configuration section a bit since I'm using static allocation
  49  * to keep things simple.
  50  *
  51  *
  52  * TODO: - build a better code generator for the move instruction.
  53  *       - Add callm and rtm instructions
  54  *       - Fix RTE to handle other format words
  55  *       - Add address error (and bus error?) handling
  56  */
  57
  58
  59 char* g_version = "3.3";
  60
  61 /* ======================================================================== */
  62 /* =============================== INCLUDES =============================== */
  63 /* ======================================================================== */
  64
  65 #include <stdio.h>
  66 #include <stdlib.h>
  67 #include <string.h>
  68 #include <ctype.h>
  69 #include <stdarg.h>
  70
  71
  72
  73 /* ======================================================================== */
  74 /* ============================= CONFIGURATION ============================ */
  75 /* ======================================================================== */
  76
  77 #define M68K_MAX_PATH 1024
  78 #define M68K_MAX_DIR  1024
  79
  80 #define NUM_CPUS                          3     /* 000, 010, 020 */
  81 #define MAX_LINE_LENGTH                 200     /* length of 1 line */
  82 #define MAX_BODY_LENGTH                 300     /* Number of lines in 1 function */
  83 #define MAX_REPLACE_LENGTH               30     /* Max number of replace strings */
  84 #define MAX_INSERT_LENGTH              5000     /* Max size of insert piece */
  85 #define MAX_NAME_LENGTH                  30     /* Max length of ophandler name */
  86 #define MAX_SPEC_PROC_LENGTH              4     /* Max length of special processing str */
  87 #define MAX_SPEC_EA_LENGTH                5     /* Max length of specified EA str */
  88 #define EA_ALLOWED_LENGTH                11     /* Max length of ea allowed str */
  89 #define MAX_OPCODE_INPUT_TABLE_LENGTH  1000     /* Max length of opcode handler tbl */
  90 #define MAX_OPCODE_OUTPUT_TABLE_LENGTH 3000     /* Max length of opcode handler tbl */
  91
  92 /* Default filenames */
  93 #define FILENAME_INPUT      "m68k_in.c"
  94 #define FILENAME_PROTOTYPE  "m68kops.h"
  95 #define FILENAME_TABLE      "m68kops.c"
  96 #define FILENAME_OPS_AC     "m68kopac.c"
  97 #define FILENAME_OPS_DM     "m68kopdm.c"
  98 #define FILENAME_OPS_NZ     "m68kopnz.c"
  99
 100
 101 /* Identifier sequences recognized by this program */
 102
 103 #define ID_INPUT_SEPARATOR "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
 104
 105 #define ID_BASE                 "M68KMAKE"
 106 #define ID_PROTOTYPE_HEADER     ID_BASE "_PROTOTYPE_HEADER"
 107 #define ID_PROTOTYPE_FOOTER     ID_BASE "_PROTOTYPE_FOOTER"
 108 #define ID_TABLE_HEADER         ID_BASE "_TABLE_HEADER"
 109 #define ID_TABLE_FOOTER         ID_BASE "_TABLE_FOOTER"
 110 #define ID_TABLE_BODY           ID_BASE "_TABLE_BODY"
 111 #define ID_TABLE_START          ID_BASE "_TABLE_START"
 112 #define ID_OPHANDLER_HEADER     ID_BASE "_OPCODE_HANDLER_HEADER"
 113 #define ID_OPHANDLER_FOOTER     ID_BASE "_OPCODE_HANDLER_FOOTER"
 114 #define ID_OPHANDLER_BODY       ID_BASE "_OPCODE_HANDLER_BODY"
 115 #define ID_END                  ID_BASE "_END"
 116
 117 #define ID_OPHANDLER_NAME       ID_BASE "_OP"
 118 #define ID_OPHANDLER_EA_AY_8    ID_BASE "_GET_EA_AY_8"
 119 #define ID_OPHANDLER_EA_AY_16   ID_BASE "_GET_EA_AY_16"
 120 #define ID_OPHANDLER_EA_AY_32   ID_BASE "_GET_EA_AY_32"
 121 #define ID_OPHANDLER_OPER_AY_8  ID_BASE "_GET_OPER_AY_8"
 122 #define ID_OPHANDLER_OPER_AY_16 ID_BASE "_GET_OPER_AY_16"
 123 #define ID_OPHANDLER_OPER_AY_32 ID_BASE "_GET_OPER_AY_32"
 124 #define ID_OPHANDLER_CC         ID_BASE "_CC"
 125 #define ID_OPHANDLER_NOT_CC     ID_BASE "_NOT_CC"
 126
 127
 128 #ifndef DECL_SPEC
 129 #define DECL_SPEC
 130 #endif /* DECL_SPEC */
 131
 132
 133
 134 /* ======================================================================== */
 135 /* ============================== PROTOTYPES ============================== */
 136 /* ======================================================================== */
 137
 138 #define CPU_TYPE_000 0
 139 #define CPU_TYPE_010 1
 140 #define CPU_TYPE_020 2
 141
 142 #define UNSPECIFIED "."
 143 #define UNSPECIFIED_CH '.'
 144
 145 #define HAS_NO_EA_MODE(A) (strcmp(A, "..........") == 0)
 146 #define HAS_EA_AI(A)   ((A)[0] == 'A')
 147 #define HAS_EA_PI(A)   ((A)[1] == '+')
 148 #define HAS_EA_PD(A)   ((A)[2] == '-')
 149 #define HAS_EA_DI(A)   ((A)[3] == 'D')
 150 #define HAS_EA_IX(A)   ((A)[4] == 'X')
 151 #define HAS_EA_AW(A)   ((A)[5] == 'W')
 152 #define HAS_EA_AL(A)   ((A)[6] == 'L')
 153 #define HAS_EA_PCDI(A) ((A)[7] == 'd')
 154 #define HAS_EA_PCIX(A) ((A)[8] == 'x')
 155 #define HAS_EA_I(A)    ((A)[9] == 'I')
 156
 157 enum
 158 {
 159         EA_MODE_NONE,   /* No special addressing mode */
 160         EA_MODE_AI,             /* Address register indirect */
 161         EA_MODE_PI,             /* Address register indirect with postincrement */
 162         EA_MODE_PI7,    /* Address register 7 indirect with postincrement */
 163         EA_MODE_PD,             /* Address register indirect with predecrement */
 164         EA_MODE_PD7,    /* Address register 7 indirect with predecrement */
 165         EA_MODE_DI,             /* Address register indirect with displacement */
 166         EA_MODE_IX,             /* Address register indirect with index */
 167         EA_MODE_AW,             /* Absolute word */
 168         EA_MODE_AL,             /* Absolute long */
 169         EA_MODE_PCDI,   /* Program counter indirect with displacement */
 170         EA_MODE_PCIX,   /* Program counter indirect with index */
 171         EA_MODE_I               /* Immediate */
 172 };
 173
 174
 175 /* Everything we need to know about an opcode */
 176 typedef struct
 177 {
 178         char name[MAX_NAME_LENGTH];           /* opcode handler name */
 179         unsigned char size;                   /* Size of operation */
 180         char spec_proc[MAX_SPEC_PROC_LENGTH]; /* Special processing mode */
 181         char spec_ea[MAX_SPEC_EA_LENGTH];     /* Specified effective addressing mode */
 182         unsigned char bits;                   /* Number of significant bits (used for sorting the table) */
 183         unsigned short op_mask;               /* Mask to apply for matching an opcode to a handler */
 184         unsigned short op_match;              /* Value to match after masking */
 185         char ea_allowed[EA_ALLOWED_LENGTH];   /* Effective addressing modes allowed */
 186         char cpu_mode[NUM_CPUS];              /* User or supervisor mode */
 187         char cpus[NUM_CPUS+1];                /* Allowed CPUs */
 188         unsigned char cycles[NUM_CPUS];       /* cycles for 000, 010, 020 */
 189 } opcode_struct;
 190
 191
 192 /* All modifications necessary for a specific EA mode of an instruction */
 193 typedef struct
 194 {
 195         char* fname_add;
 196         char* ea_add;
 197         unsigned int mask_add;
 198         unsigned int match_add;
 199 } ea_info_struct;
 200
 201
 202 /* Holds the body of a function */
 203 typedef struct
 204 {
 205         char body[MAX_BODY_LENGTH][MAX_LINE_LENGTH+1];
 206         int length;
 207 } body_struct;
 208
 209
 210 /* Holds a sequence of search / replace strings */
 211 typedef struct
 212 {
 213         char replace[MAX_REPLACE_LENGTH][2][MAX_LINE_LENGTH+1];
 214         int length;
 215 } replace_struct;
 216
 217
 218 /* Function Prototypes */
 219 void error_exit(char* fmt, ...);
 220 void perror_exit(char* fmt, ...);
 221 int check_strsncpy(char* dst, char* src, int maxlength);
 222 int check_atoi(char* str, int *result);
 223 int skip_spaces(char* str);
 224 int num_bits(int value);
 225 int atoh(char* buff);
 226 int fgetline(char* buff, int nchars, FILE* file);
 227 int get_oper_cycles(opcode_struct* op, int ea_mode, int cpu_type);
 228 opcode_struct* find_opcode(char* name, int size, char* spec_proc, char* spec_ea);
 229 opcode_struct* find_illegal_opcode(void);
 230 int extract_opcode_info(char* src, char* name, int* size, char* spec_proc, char* spec_ea);
 231 void add_replace_string(replace_struct* replace, char* search_str, char* replace_str);
 232 void write_body(FILE* filep, body_struct* body, replace_struct* replace);
 233 void get_base_name(char* base_name, opcode_struct* op);
 234 void write_prototype(FILE* filep, char* base_name);
 235 void write_function_name(FILE* filep, char* base_name);
 236 void add_opcode_output_table_entry(opcode_struct* op, char* name);
 237 static int DECL_SPEC compare_nof_true_bits(const void* aptr, const void* bptr);
 238 void print_opcode_output_table(FILE* filep);
 239 void write_table_entry(FILE* filep, opcode_struct* op);
 240 void set_opcode_struct(opcode_struct* src, opcode_struct* dst, int ea_mode);
 241 void generate_opcode_handler(FILE* filep, body_struct* body, replace_struct* replace, opcode_struct* opinfo, int ea_mode);
 242 void generate_opcode_ea_variants(FILE* filep, body_struct* body, replace_struct* replace, opcode_struct* op);
 243 void generate_opcode_cc_variants(FILE* filep, body_struct* body, replace_struct* replace, opcode_struct* op_in, int offset);
 244 void process_opcode_handlers(void);
 245 void populate_table(void);
 246 void read_insert(char* insert);
 247
 248
 249
 250 /* ======================================================================== */
 251 /* ================================= DATA ================================= */
 252 /* ======================================================================== */
 253
 254 /* Name of the input file */
 255 char g_input_filename[M68K_MAX_PATH] = FILENAME_INPUT;
 256
 257 /* File handles */
 258 FILE* g_input_file = NULL;
 259 FILE* g_prototype_file = NULL;
 260 FILE* g_table_file = NULL;
 261 FILE* g_ops_ac_file = NULL;
 262 FILE* g_ops_dm_file = NULL;
 263 FILE* g_ops_nz_file = NULL;
 264
 265 int g_num_functions = 0;  /* Number of functions processed */
 266 int g_num_primitives = 0; /* Number of function primitives read */
 267 int g_line_number = 1;    /* Current line number */
 268
 269 /* Opcode handler table */
 270 opcode_struct g_opcode_input_table[MAX_OPCODE_INPUT_TABLE_LENGTH];
 271
 272 opcode_struct g_opcode_output_table[MAX_OPCODE_OUTPUT_TABLE_LENGTH];
 273 int g_opcode_output_table_length = 0;
 274
 275 ea_info_struct g_ea_info_table[13] =
 276 {/* fname    ea        mask  match */
 277         {"",     "",       0x00, 0x00}, /* EA_MODE_NONE */
 278         {"ai",   "AY_AI",  0x38, 0x10}, /* EA_MODE_AI   */
 279         {"pi",   "AY_PI",  0x38, 0x18}, /* EA_MODE_PI   */
 280         {"pi7",  "A7_PI",  0x3f, 0x1f}, /* EA_MODE_PI7  */
 281         {"pd",   "AY_PD",  0x38, 0x20}, /* EA_MODE_PD   */
 282         {"pd7",  "A7_PD",  0x3f, 0x27}, /* EA_MODE_PD7  */
 283         {"di",   "AY_DI",  0x38, 0x28}, /* EA_MODE_DI   */
 284         {"ix",   "AY_IX",  0x38, 0x30}, /* EA_MODE_IX   */
 285         {"aw",   "AW",     0x3f, 0x38}, /* EA_MODE_AW   */
 286         {"al",   "AL",     0x3f, 0x39}, /* EA_MODE_AL   */
 287         {"pcdi", "PCDI",   0x3f, 0x3a}, /* EA_MODE_PCDI */
 288         {"pcix", "PCIX",   0x3f, 0x3b}, /* EA_MODE_PCIX */
 289         {"i",    "I",      0x3f, 0x3c}, /* EA_MODE_I    */
 290 };
 291
 292
 293 char* g_cc_table[16][2] =
 294 {
 295         { "t",  "T"}, /* 0000 */
 296         { "f",  "F"}, /* 0001 */
 297         {"hi", "HI"}, /* 0010 */
 298         {"ls", "LS"}, /* 0011 */
 299         {"cc", "CC"}, /* 0100 */
 300         {"cs", "CS"}, /* 0101 */
 301         {"ne", "NE"}, /* 0110 */
 302         {"eq", "EQ"}, /* 0111 */
 303         {"vc", "VC"}, /* 1000 */
 304         {"vs", "VS"}, /* 1001 */
 305         {"pl", "PL"}, /* 1010 */
 306         {"mi", "MI"}, /* 1011 */
 307         {"ge", "GE"}, /* 1100 */
 308         {"lt", "LT"}, /* 1101 */
 309         {"gt", "GT"}, /* 1110 */
 310         {"le", "LE"}, /* 1111 */
 311 };
 312
 313 /* size to index translator (0 -> 0, 8 and 16 -> 1, 32 -> 2) */
 314 int g_size_select_table[33] =
 315 {
 316         0,                                                                                              /* unsized */
 317         0, 0, 0, 0, 0, 0, 0, 1,                                                 /*    8    */
 318         0, 0, 0, 0, 0, 0, 0, 1,                                                 /*   16    */
 319         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2  /*   32    */
 320 };
 321
 322 /* Extra cycles required for certain EA modes */
 323 int g_ea_cycle_table[13][NUM_CPUS][3] =
 324 {/*       000           010           020   */
 325         {{ 0,  0,  0}, { 0,  0,  0}, { 0,  0,  0}}, /* EA_MODE_NONE */
 326         {{ 0,  4,  8}, { 0,  4,  8}, { 0,  4,  4}}, /* EA_MODE_AI   */
 327         {{ 0,  4,  8}, { 0,  4,  8}, { 0,  4,  4}}, /* EA_MODE_PI   */
 328         {{ 0,  4,  8}, { 0,  4,  8}, { 0,  4,  4}}, /* EA_MODE_PI7  */
 329         {{ 0,  6, 10}, { 0,  6, 10}, { 0,  5,  5}}, /* EA_MODE_PD   */
 330         {{ 0,  6, 10}, { 0,  6, 10}, { 0,  5,  5}}, /* EA_MODE_PD7  */
 331         {{ 0,  8, 12}, { 0,  8, 12}, { 0,  5,  5}}, /* EA_MODE_DI   */
 332         {{ 0, 10, 14}, { 0, 10, 14}, { 0,  7,  7}}, /* EA_MODE_IX   */
 333         {{ 0,  8, 12}, { 0,  8, 12}, { 0,  4,  4}}, /* EA_MODE_AW   */
 334         {{ 0, 12, 16}, { 0, 12, 16}, { 0,  4,  4}}, /* EA_MODE_AL   */
 335         {{ 0,  8, 12}, { 0,  8, 12}, { 0,  5,  5}}, /* EA_MODE_PCDI */
 336         {{ 0, 10, 14}, { 0, 10, 14}, { 0,  7,  7}}, /* EA_MODE_PCIX */
 337         {{ 0,  4,  8}, { 0,  4,  8}, { 0,  2,  4}}, /* EA_MODE_I    */
 338 };
 339
 340 /* Extra cycles for JMP instruction (000, 010) */
 341 int g_jmp_cycle_table[13] =
 342 {
 343          0, /* EA_MODE_NONE */
 344          4, /* EA_MODE_AI   */
 345          0, /* EA_MODE_PI   */
 346          0, /* EA_MODE_PI7  */
 347          0, /* EA_MODE_PD   */
 348          0, /* EA_MODE_PD7  */
 349          6, /* EA_MODE_DI   */
 350          10, /* EA_MODE_IX   */
 351          6, /* EA_MODE_AW   */
 352          8, /* EA_MODE_AL   */
 353          6, /* EA_MODE_PCDI */
 354         10, /* EA_MODE_PCIX */
 355          0, /* EA_MODE_I    */
 356 };
 357
 358 /* Extra cycles for JSR instruction (000, 010) */
 359 int g_jsr_cycle_table[13] =
 360 {
 361          0, /* EA_MODE_NONE */
 362          4, /* EA_MODE_AI   */
 363          0, /* EA_MODE_PI   */
 364          0, /* EA_MODE_PI7  */
 365          0, /* EA_MODE_PD   */
 366          0, /* EA_MODE_PD7  */
 367          6, /* EA_MODE_DI   */
 368         10, /* EA_MODE_IX   */
 369          6, /* EA_MODE_AW   */
 370          8, /* EA_MODE_AL   */
 371          6, /* EA_MODE_PCDI */
 372         10, /* EA_MODE_PCIX */
 373          0, /* EA_MODE_I    */
 374 };
 375
 376 /* Extra cycles for LEA instruction (000, 010) */
 377 int g_lea_cycle_table[13] =
 378 {
 379          0, /* EA_MODE_NONE */
 380          4, /* EA_MODE_AI   */
 381          0, /* EA_MODE_PI   */
 382          0, /* EA_MODE_PI7  */
 383          0, /* EA_MODE_PD   */
 384          0, /* EA_MODE_PD7  */
 385          8, /* EA_MODE_DI   */
 386         12, /* EA_MODE_IX   */
 387          8, /* EA_MODE_AW   */
 388         12, /* EA_MODE_AL   */
 389          8, /* EA_MODE_PCDI */
 390         12, /* EA_MODE_PCIX */
 391          0, /* EA_MODE_I    */
 392 };
 393
 394 /* Extra cycles for PEA instruction (000, 010) */
 395 int g_pea_cycle_table[13] =
 396 {
 397          0, /* EA_MODE_NONE */
 398          6, /* EA_MODE_AI   */
 399          0, /* EA_MODE_PI   */
 400          0, /* EA_MODE_PI7  */
 401          0, /* EA_MODE_PD   */
 402          0, /* EA_MODE_PD7  */
 403         10, /* EA_MODE_DI   */
 404         14, /* EA_MODE_IX   */
 405         10, /* EA_MODE_AW   */
 406         14, /* EA_MODE_AL   */
 407         10, /* EA_MODE_PCDI */
 408         14, /* EA_MODE_PCIX */
 409          0, /* EA_MODE_I    */
 410 };
 411
 412 /* Extra cycles for MOVES instruction (010) */
 413 int g_moves_cycle_table[13][3] =
 414 {
 415         { 0,  0,  0}, /* EA_MODE_NONE */
 416         { 0,  4,  6}, /* EA_MODE_AI   */
 417         { 0,  4,  6}, /* EA_MODE_PI   */
 418         { 0,  4,  6}, /* EA_MODE_PI7  */
 419         { 0,  6, 12}, /* EA_MODE_PD   */
 420         { 0,  6, 12}, /* EA_MODE_PD7  */
 421         { 0, 12, 16}, /* EA_MODE_DI   */
 422         { 0, 16, 20}, /* EA_MODE_IX   */
 423         { 0, 12, 16}, /* EA_MODE_AW   */
 424         { 0, 16, 20}, /* EA_MODE_AL   */
 425         { 0,  0,  0}, /* EA_MODE_PCDI */
 426         { 0,  0,  0}, /* EA_MODE_PCIX */
 427         { 0,  0,  0}, /* EA_MODE_I    */
 428 };
 429
 430 /* Extra cycles for CLR instruction (010) */
 431 int g_clr_cycle_table[13][3] =
 432 {
 433         { 0,  0,  0}, /* EA_MODE_NONE */
 434         { 0,  4,  6}, /* EA_MODE_AI   */
 435         { 0,  4,  6}, /* EA_MODE_PI   */
 436         { 0,  4,  6}, /* EA_MODE_PI7  */
 437         { 0,  6,  8}, /* EA_MODE_PD   */
 438         { 0,  6,  8}, /* EA_MODE_PD7  */
 439         { 0,  8, 10}, /* EA_MODE_DI   */
 440         { 0, 10, 14}, /* EA_MODE_IX   */
 441         { 0,  8, 10}, /* EA_MODE_AW   */
 442         { 0, 10, 14}, /* EA_MODE_AL   */
 443         { 0,  0,  0}, /* EA_MODE_PCDI */
 444         { 0,  0,  0}, /* EA_MODE_PCIX */
 445         { 0,  0,  0}, /* EA_MODE_I    */
 446 };
 447
 448
 449
 450 /* ======================================================================== */
 451 /* =========================== UTILITY FUNCTIONS ========================== */
 452 /* ======================================================================== */
 453
 454 /* Print an error message and exit with status error */
 455 void error_exit(char* fmt, ...)
 456 {
 457         va_list args;
 458         fprintf(stderr, "In %s, near or on line %d:\n\t", g_input_filename, g_line_number);
 459         va_start(args, fmt);
 460         vfprintf(stderr, fmt, args);
 461         va_end(args);
 462         fprintf(stderr, "\n");
 463
 464         if(g_prototype_file) fclose(g_prototype_file);
 465         if(g_table_file) fclose(g_table_file);
 466         if(g_ops_ac_file) fclose(g_ops_ac_file);
 467         if(g_ops_dm_file) fclose(g_ops_dm_file);
 468         if(g_ops_nz_file) fclose(g_ops_nz_file);
 469         if(g_input_file) fclose(g_input_file);
 470
 471         exit(EXIT_FAILURE);
 472 }
 473
 474 /* Print an error message, call perror(), and exit with status error */
 475 void perror_exit(char* fmt, ...)
 476 {
 477         va_list args;
 478         va_start(args, fmt);
 479         vfprintf(stderr, fmt, args);
 480         va_end(args);
 481         perror("");
 482
 483         if(g_prototype_file) fclose(g_prototype_file);
 484         if(g_table_file) fclose(g_table_file);
 485         if(g_ops_ac_file) fclose(g_ops_ac_file);
 486         if(g_ops_dm_file) fclose(g_ops_dm_file);
 487         if(g_ops_nz_file) fclose(g_ops_nz_file);
 488         if(g_input_file) fclose(g_input_file);
 489
 490         exit(EXIT_FAILURE);
 491 }
 492
 493
 494 /* copy until 0 or space and exit with error if we read too far */
 495 int check_strsncpy(char* dst, char* src, int maxlength)
 496 {
 497         char* p = dst;
 498         while(*src && *src != ' ')
 499         {
 500                 *p++ = *src++;
 501                 if(p - dst > maxlength)
 502                         error_exit("Field too long");
 503         }
 504         *p = 0;
 505         return p - dst;
 506 }
 507
 508 /* copy until 0 or specified character and exit with error if we read too far */
 509 int check_strcncpy(char* dst, char* src, char delim, int maxlength)
 510 {
 511         char* p = dst;
 512         while(*src && *src != delim)
 513         {
 514                 *p++ = *src++;
 515                 if(p - dst > maxlength)
 516                         error_exit("Field too long");
 517         }
 518         *p = 0;
 519         return p - dst;
 520 }
 521
 522 /* convert ascii to integer and exit with error if we find invalid data */
 523 int check_atoi(char* str, int *result)
 524 {
 525         int accum = 0;
 526         char* p = str;
 527         while(*p >= '0' && *p <= '9')
 528         {
 529                 accum *= 10;
 530                 accum += *p++ - '0';
 531         }
 532         if(*p != ' ' && *p != 0)
 533                 error_exit("Malformed integer value (%c)", *p);
 534         *result = accum;
 535         return p - str;
 536 }
 537
 538 /* Skip past spaces in a string */
 539 int skip_spaces(char* str)
 540 {
 541         char* p = str;
 542
 543         while(*p == ' ')
 544                 p++;
 545
 546         return p - str;
 547 }
 548
 549 /* Count the number of set bits in a value */
 550 int num_bits(int value)
 551 {
 552     value = ((value & 0xaaaa) >> 1) + (value & 0x5555);
 553     value = ((value & 0xcccc) >> 2) + (value & 0x3333);
 554     value = ((value & 0xf0f0) >> 4) + (value & 0x0f0f);
 555     value = ((value & 0xff00) >> 8) + (value & 0x00ff);
 556         return value;
 557 }
 558
 559 /* Convert a hex value written in ASCII */
 560 int atoh(char* buff)
 561 {
 562         int accum = 0;
 563
 564         for(;;buff++)
 565         {
 566                 if(*buff >= '0' && *buff <= '9')
 567                 {
 568                         accum <<= 4;
 569                         accum += *buff - '0';
 570                 }
 571                 else if(*buff >= 'a' && *buff <= 'f')
 572                 {
 573                         accum <<= 4;
 574                         accum += *buff - 'a' + 10;
 575                 }
 576                 else break;
 577         }
 578         return accum;
 579 }
 580
 581 /* Get a line of text from a file, discarding any end-of-line characters */
 582 int fgetline(char* buff, int nchars, FILE* file)
 583 {
 584         int length;
 585
 586         if(fgets(buff, nchars, file) == NULL)
 587                 return -1;
 588         if(buff[0] == '\r')
 589                 memcpy(buff, buff + 1, nchars - 1);
 590
 591         length = strlen(buff);
 592         while(length && (buff[length-1] == '\r' || buff[length-1] == '\n'))
 593                 length--;
 594         buff[length] = 0;
 595         g_line_number++;
 596
 597         return length;
 598 }
 599
 600
 601
 602 /* ======================================================================== */
 603 /* =========================== HELPER FUNCTIONS =========================== */
 604 /* ======================================================================== */
 605
 606 /* Calculate the number of cycles an opcode requires */
 607 int get_oper_cycles(opcode_struct* op, int ea_mode, int cpu_type)
 608 {
 609         int size = g_size_select_table[op->size];
 610
 611         if(op->cpus[cpu_type] == '.')
 612                 return 0;
 613
 614         if(cpu_type < CPU_TYPE_020)
 615         {
 616                 if(cpu_type == CPU_TYPE_010)
 617                 {
 618                         if(strcmp(op->name, "moves") == 0)
 619                                 return op->cycles[cpu_type] + g_moves_cycle_table[ea_mode][size];
 620                         if(strcmp(op->name, "clr") == 0)
 621                                 return op->cycles[cpu_type] + g_clr_cycle_table[ea_mode][size];
 622                 }
 623
 624                 /* ASG: added these cases -- immediate modes take 2 extra cycles here */
 625                 if(cpu_type == CPU_TYPE_000 && ea_mode == EA_MODE_I &&
 626                    ((strcmp(op->name, "add") == 0 && strcmp(op->spec_proc, "er") == 0) ||
 627                         strcmp(op->name, "adda")   == 0                                    ||
 628                         (strcmp(op->name, "and") == 0 && strcmp(op->spec_proc, "er") == 0) ||
 629                         (strcmp(op->name, "or") == 0 && strcmp(op->spec_proc, "er") == 0)  ||
 630                         (strcmp(op->name, "sub") == 0 && strcmp(op->spec_proc, "er") == 0) ||
 631                         strcmp(op->name, "suba")   == 0))
 632                         return op->cycles[cpu_type] + g_ea_cycle_table[ea_mode][cpu_type][size] + 2;
 633
 634                 if(strcmp(op->name, "jmp") == 0)
 635                         return op->cycles[cpu_type] + g_jmp_cycle_table[ea_mode];
 636                 if(strcmp(op->name, "jsr") == 0)
 637                         return op->cycles[cpu_type] + g_jsr_cycle_table[ea_mode];
 638                 if(strcmp(op->name, "lea") == 0)
 639                         return op->cycles[cpu_type] + g_lea_cycle_table[ea_mode];
 640                 if(strcmp(op->name, "pea") == 0)
 641                         return op->cycles[cpu_type] + g_pea_cycle_table[ea_mode];
 642         }
 643         return op->cycles[cpu_type] + g_ea_cycle_table[ea_mode][cpu_type][size];
 644 }
 645
 646 /* Find an opcode in the opcode handler list */
 647 opcode_struct* find_opcode(char* name, int size, char* spec_proc, char* spec_ea)
 648 {
 649         opcode_struct* op;
 650
 651
 652         for(op = g_opcode_input_table;op->name != NULL;op++)
 653         {
 654                 if(     strcmp(name, op->name) == 0 &&
 655                         (size == op->size) &&
 656                         strcmp(spec_proc, op->spec_proc) == 0 &&
 657                         strcmp(spec_ea, op->spec_ea) == 0)
 658                                 return op;
 659         }
 660         return NULL;
 661 }
 662
 663 /* Specifically find the illegal opcode in the list */
 664 opcode_struct* find_illegal_opcode(void)
 665 {
 666         opcode_struct* op;
 667
 668         for(op = g_opcode_input_table;op->name != NULL;op++)
 669         {
 670                 if(strcmp(op->name, "illegal") == 0)
 671                         return op;
 672         }
 673         return NULL;
 674 }
 675
 676 /* Parse an opcode handler name */
 677 int extract_opcode_info(char* src, char* name, int* size, char* spec_proc, char* spec_ea)
 678 {
 679         char* ptr = strstr(src, ID_OPHANDLER_NAME);
 680
 681         if(ptr == NULL)
 682                 return 0;
 683
 684         ptr += strlen(ID_OPHANDLER_NAME) + 1;
 685
 686         ptr += check_strcncpy(name, ptr, ',', MAX_NAME_LENGTH);
 687         if(*ptr != ',') return 0;
 688         ptr++;
 689         ptr += skip_spaces(ptr);
 690
 691         *size = atoi(ptr);
 692         ptr = strstr(ptr, ",");
 693         if(ptr == NULL) return 0;
 694     ptr++;
 695         ptr += skip_spaces(ptr);
 696
 697         ptr += check_strcncpy(spec_proc, ptr, ',', MAX_SPEC_PROC_LENGTH);
 698         if(*ptr != ',') return 0;
 699         ptr++;
 700         ptr += skip_spaces(ptr);
 701
 702         ptr += check_strcncpy(spec_ea, ptr, ')', MAX_SPEC_EA_LENGTH);
 703         if(*ptr != ')') return 0;
 704         ptr++;
 705         ptr += skip_spaces(ptr);
 706
 707         return 1;
 708 }
 709
 710
 711 /* Add a search/replace pair to a replace structure */
 712 void add_replace_string(replace_struct* replace, char* search_str, char* replace_str)
 713 {
 714         if(replace->length >= MAX_REPLACE_LENGTH)
 715                 error_exit("overflow in replace structure");
 716
 717         strcpy(replace->replace[replace->length][0], search_str);
 718         strcpy(replace->replace[replace->length++][1], replace_str);
 719 }
 720
 721 /* Write a function body while replacing any selected strings */
 722 void write_body(FILE* filep, body_struct* body, replace_struct* replace)
 723 {
 724         int i;
 725         int j;
 726         char* ptr;
 727         char output[MAX_LINE_LENGTH+1];
 728         char temp_buff[MAX_LINE_LENGTH+1];
 729         int found;
 730
 731         for(i=0;i<body->length;i++)
 732         {
 733                 strcpy(output, body->body[i]);
 734                 /* Check for the base directive header */
 735                 if(strstr(output, ID_BASE) != NULL)
 736                 {
 737                         /* Search for any text we need to replace */
 738                         found = 0;
 739                         for(j=0;j<replace->length;j++)
 740                         {
 741                                 ptr = strstr(output, replace->replace[j][0]);
 742                                 if(ptr)
 743                                 {
 744                                         /* We found something to replace */
 745                                         found = 1;
 746                                         strcpy(temp_buff, ptr+strlen(replace->replace[j][0]));
 747                                         strcpy(ptr, replace->replace[j][1]);
 748                                         strcat(ptr, temp_buff);
 749                                 }
 750                         }
 751                         /* Found a directive with no matching replace string */
 752                         if(!found)
 753                                 error_exit("Unknown " ID_BASE " directive");
 754                 }
 755                 fprintf(filep, "%s\n", output);
 756         }
 757         fprintf(filep, "\n\n");
 758 }
 759
 760 /* Generate a base function name from an opcode struct */
 761 void get_base_name(char* base_name, opcode_struct* op)
 762 {
 763         sprintf(base_name, "m68k_op_%s", op->name);
 764         if(op->size > 0)
 765                 sprintf(base_name+strlen(base_name), "_%d", op->size);
 766         if(strcmp(op->spec_proc, UNSPECIFIED) != 0)
 767                 sprintf(base_name+strlen(base_name), "_%s", op->spec_proc);
 768         if(strcmp(op->spec_ea, UNSPECIFIED) != 0)
 769                 sprintf(base_name+strlen(base_name), "_%s", op->spec_ea);
 770 }
 771
 772 /* Write the prototype of an opcode handler function */
 773 void write_prototype(FILE* filep, char* base_name)
 774 {
 775         fprintf(filep, "void %s(void);\n", base_name);
 776 }
 777
 778 /* Write the name of an opcode handler function */
 779 void write_function_name(FILE* filep, char* base_name)
 780 {
 781         fprintf(filep, "void %s(void)\n", base_name);
 782 }
 783
 784 void add_opcode_output_table_entry(opcode_struct* op, char* name)
 785 {
 786         opcode_struct* ptr;
 787         if(g_opcode_output_table_length > MAX_OPCODE_OUTPUT_TABLE_LENGTH)
 788                 error_exit("Opcode output table overflow");
 789
 790         ptr = g_opcode_output_table + g_opcode_output_table_length++;
 791
 792         *ptr = *op;
 793         strcpy(ptr->name, name);
 794         ptr->bits = num_bits(ptr->op_mask);
 795 }
 796
 797 /*
 798  * Comparison function for qsort()
 799  * For entries with an equal number of set bits in
 800  * the mask compare the match values
 801  */
 802 static int DECL_SPEC compare_nof_true_bits(const void* aptr, const void* bptr)
 803 {
 804         const opcode_struct *a = aptr, *b = bptr;
 805         if(a->bits != b->bits)
 806                 return a->bits - b->bits;
 807         if(a->op_mask != b->op_mask)
 808                 return a->op_mask - b->op_mask;
 809         return a->op_match - b->op_match;
 810 }
 811
 812 void print_opcode_output_table(FILE* filep)
 813 {
 814         int i;
 815         qsort((void *)g_opcode_output_table, g_opcode_output_table_length, sizeof(g_opcode_output_table[0]), compare_nof_true_bits);
 816
 817         for(i=0;i<g_opcode_output_table_length;i++)
 818                 write_table_entry(filep, g_opcode_output_table+i);
 819 }
 820
 821 /* Write an entry in the opcode handler table */
 822 void write_table_entry(FILE* filep, opcode_struct* op)
 823 {
 824         int i;
 825
 826         fprintf(filep, "\t{%-28s, 0x%04x, 0x%04x, {",
 827                 op->name, op->op_mask, op->op_match);
 828
 829         for(i=0;i<NUM_CPUS;i++)
 830         {
 831                 fprintf(filep, "%3d", op->cycles[i]);
 832                 if(i < NUM_CPUS-1)
 833                         fprintf(filep, ", ");
 834         }
 835
 836         fprintf(filep, "}},\n");
 837 }
 838
 839 /* Fill out an opcode struct with a specific addressing mode of the source opcode struct */
 840 void set_opcode_struct(opcode_struct* src, opcode_struct* dst, int ea_mode)
 841 {
 842         int i;
 843
 844         *dst = *src;
 845
 846         for(i=0;i<NUM_CPUS;i++)
 847                 dst->cycles[i] = get_oper_cycles(dst, ea_mode, i);
 848         if(strcmp(dst->spec_ea, UNSPECIFIED) == 0 && ea_mode != EA_MODE_NONE)
 849                 sprintf(dst->spec_ea, "%s", g_ea_info_table[ea_mode].fname_add);
 850         dst->op_mask |= g_ea_info_table[ea_mode].mask_add;
 851         dst->op_match |= g_ea_info_table[ea_mode].match_add;
 852 }
 853
 854
 855 /* Generate a final opcode handler from the provided data */
 856 void generate_opcode_handler(FILE* filep, body_struct* body, replace_struct* replace, opcode_struct* opinfo, int ea_mode)
 857 {
 858         char str[MAX_LINE_LENGTH+1];
 859         opcode_struct* op = malloc(sizeof(opcode_struct));
 860
 861         /* Set the opcode structure and write the tables, prototypes, etc */
 862         set_opcode_struct(opinfo, op, ea_mode);
 863         get_base_name(str, op);
 864         write_prototype(g_prototype_file, str);
 865         add_opcode_output_table_entry(op, str);
 866         write_function_name(filep, str);
 867
 868         /* Add any replace strings needed */
 869         if(ea_mode != EA_MODE_NONE)
 870         {
 871                 sprintf(str, "EA_%s_8()", g_ea_info_table[ea_mode].ea_add);
 872                 add_replace_string(replace, ID_OPHANDLER_EA_AY_8, str);
 873                 sprintf(str, "EA_%s_16()", g_ea_info_table[ea_mode].ea_add);
 874                 add_replace_string(replace, ID_OPHANDLER_EA_AY_16, str);
 875                 sprintf(str, "EA_%s_32()", g_ea_info_table[ea_mode].ea_add);
 876                 add_replace_string(replace, ID_OPHANDLER_EA_AY_32, str);
 877                 sprintf(str, "OPER_%s_8()", g_ea_info_table[ea_mode].ea_add);
 878                 add_replace_string(replace, ID_OPHANDLER_OPER_AY_8, str);
 879                 sprintf(str, "OPER_%s_16()", g_ea_info_table[ea_mode].ea_add);
 880                 add_replace_string(replace, ID_OPHANDLER_OPER_AY_16, str);
 881                 sprintf(str, "OPER_%s_32()", g_ea_info_table[ea_mode].ea_add);
 882                 add_replace_string(replace, ID_OPHANDLER_OPER_AY_32, str);
 883         }
 884
 885         /* Now write the function body with the selected replace strings */
 886         write_body(filep, body, replace);
 887         g_num_functions++;
 888         free(op);
 889 }
 890
 891 /* Generate opcode variants based on available addressing modes */
 892 void generate_opcode_ea_variants(FILE* filep, body_struct* body, replace_struct* replace, opcode_struct* op)
 893 {
 894         int old_length = replace->length;
 895
 896         /* No ea modes available for this opcode */
 897         if(HAS_NO_EA_MODE(op->ea_allowed))
 898         {
 899                 generate_opcode_handler(filep, body, replace, op, EA_MODE_NONE);
 900                 return;
 901         }
 902
 903         /* Check for and create specific opcodes for each available addressing mode */
 904         if(HAS_EA_AI(op->ea_allowed))
 905                 generate_opcode_handler(filep, body, replace, op, EA_MODE_AI);
 906         replace->length = old_length;
 907         if(HAS_EA_PI(op->ea_allowed))
 908         {
 909                 generate_opcode_handler(filep, body, replace, op, EA_MODE_PI);
 910                 replace->length = old_length;
 911                 if(op->size == 8)
 912                         generate_opcode_handler(filep, body, replace, op, EA_MODE_PI7);
 913         }
 914         replace->length = old_length;
 915         if(HAS_EA_PD(op->ea_allowed))
 916         {
 917                 generate_opcode_handler(filep, body, replace, op, EA_MODE_PD);
 918                 replace->length = old_length;
 919                 if(op->size == 8)
 920                         generate_opcode_handler(filep, body, replace, op, EA_MODE_PD7);
 921         }
 922         replace->length = old_length;
 923         if(HAS_EA_DI(op->ea_allowed))
 924                 generate_opcode_handler(filep, body, replace, op, EA_MODE_DI);
 925         replace->length = old_length;
 926         if(HAS_EA_IX(op->ea_allowed))
 927                 generate_opcode_handler(filep, body, replace, op, EA_MODE_IX);
 928         replace->length = old_length;
 929         if(HAS_EA_AW(op->ea_allowed))
 930                 generate_opcode_handler(filep, body, replace, op, EA_MODE_AW);
 931         replace->length = old_length;
 932         if(HAS_EA_AL(op->ea_allowed))
 933                 generate_opcode_handler(filep, body, replace, op, EA_MODE_AL);
 934         replace->length = old_length;
 935         if(HAS_EA_PCDI(op->ea_allowed))
 936                 generate_opcode_handler(filep, body, replace, op, EA_MODE_PCDI);
 937         replace->length = old_length;
 938         if(HAS_EA_PCIX(op->ea_allowed))
 939                 generate_opcode_handler(filep, body, replace, op, EA_MODE_PCIX);
 940         replace->length = old_length;
 941         if(HAS_EA_I(op->ea_allowed))
 942                 generate_opcode_handler(filep, body, replace, op, EA_MODE_I);
 943         replace->length = old_length;
 944 }
 945
 946 /* Generate variants of condition code opcodes */
 947 void generate_opcode_cc_variants(FILE* filep, body_struct* body, replace_struct* replace, opcode_struct* op_in, int offset)
 948 {
 949         char repl[20];
 950         char replnot[20];
 951         int i;
 952         int old_length = replace->length;
 953         opcode_struct* op = malloc(sizeof(opcode_struct));
 954
 955         *op = *op_in;
 956
 957         op->op_mask |= 0x0f00;
 958
 959         /* Do all condition codes except t and f */
 960         for(i=2;i<16;i++)
 961         {
 962                 /* Add replace strings for this condition code */
 963                 sprintf(repl, "COND_%s()", g_cc_table[i][1]);
 964                 sprintf(replnot, "COND_NOT_%s()", g_cc_table[i][1]);
 965
 966                 add_replace_string(replace, ID_OPHANDLER_CC, repl);
 967                 add_replace_string(replace, ID_OPHANDLER_NOT_CC, replnot);
 968
 969                 /* Set the new opcode info */
 970                 strcpy(op->name+offset, g_cc_table[i][0]);
 971
 972                 op->op_match = (op->op_match & 0xf0ff) | (i<<8);
 973
 974                 /* Generate all opcode variants for this modified opcode */
 975                 generate_opcode_ea_variants(filep, body, replace, op);
 976                 /* Remove the above replace strings */
 977                 replace->length = old_length;
 978         }
 979         free(op);
 980 }
 981
 982 /* Process the opcode handlers section of the input file */
 983 void process_opcode_handlers(void)
 984 {
 985         FILE* input_file = g_input_file;
 986         FILE* output_file;
 987         char func_name[MAX_LINE_LENGTH+1];
 988         char oper_name[MAX_LINE_LENGTH+1];
 989         int  oper_size;
 990         char oper_spec_proc[MAX_LINE_LENGTH+1];
 991         char oper_spec_ea[MAX_LINE_LENGTH+1];
 992         opcode_struct* opinfo;
 993         replace_struct* replace = malloc(sizeof(replace_struct));
 994         body_struct* body = malloc(sizeof(body_struct));
 995
 996
 997         output_file = g_ops_ac_file;
 998
 999         for(;;)
1000         {
1001                 /* Find the first line of the function */
1002                 func_name[0] = 0;
1003                 while(strstr(func_name, ID_OPHANDLER_NAME) == NULL)
1004                 {
1005                         if(strcmp(func_name, ID_INPUT_SEPARATOR) == 0)
1006                         {
1007                                 free(replace);
1008                                 free(body);
1009                                 return; /* all done */
1010                         }
1011                         if(fgetline(func_name, MAX_LINE_LENGTH, input_file) < 0)
1012                                 error_exit("Premature end of file when getting function name");
1013                 }
1014                 /* Get the rest of the function */
1015                 for(body->length=0;;body->length++)
1016                 {
1017                         if(body->length > MAX_BODY_LENGTH)
1018                                 error_exit("Function too long");
1019
1020                         if(fgetline(body->body[body->length], MAX_LINE_LENGTH, input_file) < 0)
1021                                 error_exit("Premature end of file when getting function body");
1022
1023                         if(body->body[body->length][0] == '}')
1024                         {
1025                                 body->length++;
1026                                 break;
1027                         }
1028                 }
1029
1030                 g_num_primitives++;
1031
1032                 /* Extract the function name information */
1033                 if(!extract_opcode_info(func_name, oper_name, &oper_size, oper_spec_proc, oper_spec_ea))
1034                         error_exit("Invalid " ID_OPHANDLER_NAME " format");
1035
1036                 /* Find the corresponding table entry */
1037                 opinfo = find_opcode(oper_name, oper_size, oper_spec_proc, oper_spec_ea);
1038                 if(opinfo == NULL)
1039                         error_exit("Unable to find matching table entry for %s", func_name);
1040
1041         /* Change output files if we pass 'c' or 'n' */
1042                 if(output_file == g_ops_ac_file && oper_name[0] > 'c')
1043                         output_file = g_ops_dm_file;
1044                 else if(output_file == g_ops_dm_file && oper_name[0] > 'm')
1045                         output_file = g_ops_nz_file;
1046
1047                 replace->length = 0;
1048
1049                 /* Generate opcode variants */
1050                 if(strcmp(opinfo->name, "bcc") == 0 || strcmp(opinfo->name, "scc") == 0)
1051                         generate_opcode_cc_variants(output_file, body, replace, opinfo, 1);
1052                 else if(strcmp(opinfo->name, "dbcc") == 0)
1053                         generate_opcode_cc_variants(output_file, body, replace, opinfo, 2);
1054                 else if(strcmp(opinfo->name, "trapcc") == 0)
1055                         generate_opcode_cc_variants(output_file, body, replace, opinfo, 4);
1056                 else
1057                         generate_opcode_ea_variants(output_file, body, replace, opinfo);
1058         }
1059
1060         free(replace);
1061         free(body);
1062 }
1063
1064
1065 /* Populate the opcode handler table from the input file */
1066 void populate_table(void)
1067 {
1068         char* ptr;
1069         char bitpattern[17];
1070         opcode_struct* op;
1071         char buff[MAX_LINE_LENGTH];
1072         int i;
1073         int temp;
1074
1075         buff[0] = 0;
1076
1077         /* Find the start of the table */
1078         while(strcmp(buff, ID_TABLE_START) != 0)
1079                 if(fgetline(buff, MAX_LINE_LENGTH, g_input_file) < 0)
1080                         error_exit("Premature EOF while reading table");
1081
1082         /* Process the entire table */
1083         for(op = g_opcode_input_table;;op++)
1084         {
1085                 if(fgetline(buff, MAX_LINE_LENGTH, g_input_file) < 0)
1086                         error_exit("Premature EOF while reading table");
1087                 if(strlen(buff) == 0)
1088                         continue;
1089                 /* We finish when we find an input separator */
1090                 if(strcmp(buff, ID_INPUT_SEPARATOR) == 0)
1091                         break;
1092
1093                 /* Extract the info from the table */
1094                 ptr = buff;
1095
1096                 /* Name */
1097                 ptr += skip_spaces(ptr);
1098                 ptr += check_strsncpy(op->name, ptr, MAX_NAME_LENGTH);
1099
1100                 /* Size */
1101                 ptr += skip_spaces(ptr);
1102                 ptr += check_atoi(ptr, &temp);
1103                 op->size = (unsigned char)temp;
1104
1105                 /* Special processing */
1106                 ptr += skip_spaces(ptr);
1107                 ptr += check_strsncpy(op->spec_proc, ptr, MAX_SPEC_PROC_LENGTH);
1108
1109                 /* Specified EA Mode */
1110                 ptr += skip_spaces(ptr);
1111                 ptr += check_strsncpy(op->spec_ea, ptr, MAX_SPEC_EA_LENGTH);
1112
1113                 /* Bit Pattern (more processing later) */
1114                 ptr += skip_spaces(ptr);
1115                 ptr += check_strsncpy(bitpattern, ptr, 17);
1116
1117                 /* Allowed Addressing Mode List */
1118                 ptr += skip_spaces(ptr);
1119                 ptr += check_strsncpy(op->ea_allowed, ptr, EA_ALLOWED_LENGTH);
1120
1121                 /* CPU operating mode (U = user or supervisor, S = supervisor only */
1122                 ptr += skip_spaces(ptr);
1123                 for(i=0;i<NUM_CPUS;i++)
1124                 {
1125                         op->cpu_mode[i] = *ptr++;
1126                         ptr += skip_spaces(ptr);
1127                 }
1128
1129                 /* Allowed CPUs for this instruction */
1130                 for(i=0;i<NUM_CPUS;i++)
1131                 {
1132                         ptr += skip_spaces(ptr);
1133                         if(*ptr == UNSPECIFIED_CH)
1134                         {
1135                                 op->cpus[i] = UNSPECIFIED_CH;
1136                                 op->cycles[i] = 0;
1137                                 ptr++;
1138                         }
1139                         else
1140                         {
1141                                 op->cpus[i] = '0' + i;
1142                                 ptr += check_atoi(ptr, &temp);
1143                                 op->cycles[i] = (unsigned char)temp;
1144                         }
1145                 }
1146
1147                 /* generate mask and match from bitpattern */
1148                 op->op_mask = 0;
1149                 op->op_match = 0;
1150                 for(i=0;i<16;i++)
1151                 {
1152                         op->op_mask |= (bitpattern[i] != '.') << (15-i);
1153                         op->op_match |= (bitpattern[i] == '1') << (15-i);
1154                 }
1155         }
1156         /* Terminate the list */
1157         op->name[0] = 0;
1158 }
1159
1160 /* Read a header or footer insert from the input file */
1161 void read_insert(char* insert)
1162 {
1163         char* ptr = insert;
1164         char* overflow = insert + MAX_INSERT_LENGTH - MAX_LINE_LENGTH;
1165         int length;
1166         char* first_blank = NULL;
1167
1168         first_blank = NULL;
1169
1170         /* Skip any leading blank lines */
1171         for(length = 0;length == 0;length = fgetline(ptr, MAX_LINE_LENGTH, g_input_file))
1172                 if(ptr >= overflow)
1173                         error_exit("Buffer overflow reading inserts");
1174         if(length < 0)
1175                 error_exit("Premature EOF while reading inserts");
1176
1177         /* Advance and append newline */
1178         ptr += length;
1179         strcpy(ptr++, "\n");
1180
1181         /* Read until next separator */
1182         for(;;)
1183         {
1184                 /* Read a new line */
1185                 if(ptr >= overflow)
1186                         error_exit("Buffer overflow reading inserts");
1187                 if((length = fgetline(ptr, MAX_LINE_LENGTH, g_input_file)) < 0)
1188                         error_exit("Premature EOF while reading inserts");
1189
1190                 /* Stop if we read a separator */
1191                 if(strcmp(ptr, ID_INPUT_SEPARATOR) == 0)
1192                         break;
1193
1194                 /* keep track in case there are trailing blanks */
1195                 if(length == 0)
1196                 {
1197                         if(first_blank == NULL)
1198                                 first_blank = ptr;
1199                 }
1200                 else
1201                         first_blank = NULL;
1202
1203                 /* Advance and append newline */
1204                 ptr += length;
1205                 strcpy(ptr++, "\n");
1206         }
1207
1208         /* kill any trailing blank lines */
1209         if(first_blank)
1210                 ptr = first_blank;
1211         *ptr++ = 0;
1212 }
1213
1214
1215
1216 /* ======================================================================== */
1217 /* ============================= MAIN FUNCTION ============================ */
1218 /* ======================================================================== */
1219
1220 int main(int argc, char **argv)
1221 {
1222         /* File stuff */
1223         char output_path[M68K_MAX_DIR] = "";
1224         char filename[M68K_MAX_PATH];
1225         /* Section identifier */
1226         char section_id[MAX_LINE_LENGTH+1];
1227         /* Inserts */
1228         char temp_insert[MAX_INSERT_LENGTH+1];
1229         char prototype_footer_insert[MAX_INSERT_LENGTH+1];
1230         char table_footer_insert[MAX_INSERT_LENGTH+1];
1231         char ophandler_footer_insert[MAX_INSERT_LENGTH+1];
1232         /* Flags if we've processed certain parts already */
1233         int prototype_header_read = 0;
1234         int prototype_footer_read = 0;
1235         int table_header_read = 0;
1236         int table_footer_read = 0;
1237         int ophandler_header_read = 0;
1238         int ophandler_footer_read = 0;
1239         int table_body_read = 0;
1240         int ophandler_body_read = 0;
1241
1242         printf("\n\t\tMusashi v%s 68000, 68010, 68EC020, 68020 emulator\n", g_version);
1243         printf("\t\tCopyright 1998-2000 Karl Stenerud (karl@mame.net)\n\n");
1244
1245         /* Check if output path and source for the input file are given */
1246     if(argc > 1)
1247         {
1248                 char *ptr;
1249                 strcpy(output_path, argv[1]);
1250
1251                 for(ptr = strchr(output_path, '\\'); ptr; ptr = strchr(ptr, '\\'))
1252                         *ptr = '/';
1253         if(output_path[strlen(output_path)-1] != '/')
1254                         strcat(output_path, "/");
1255                 if(argc > 2)
1256                         strcpy(g_input_filename, argv[2]);
1257         }
1258
1259
1260         /* Open the files we need */
1261         sprintf(filename, "%s%s", output_path, FILENAME_PROTOTYPE);
1262         if((g_prototype_file = fopen(filename, "wt")) == NULL)
1263                 perror_exit("Unable to create prototype file (%s)\n", filename);
1264
1265         sprintf(filename, "%s%s", output_path, FILENAME_TABLE);
1266         if((g_table_file = fopen(filename, "wt")) == NULL)
1267                 perror_exit("Unable to create table file (%s)\n", filename);
1268
1269         sprintf(filename, "%s%s", output_path, FILENAME_OPS_AC);
1270         if((g_ops_ac_file = fopen(filename, "wt")) == NULL)
1271                 perror_exit("Unable to create ops ac file (%s)\n", filename);
1272
1273         sprintf(filename, "%s%s", output_path, FILENAME_OPS_DM);
1274         if((g_ops_dm_file = fopen(filename, "wt")) == NULL)
1275                 perror_exit("Unable to create ops dm file (%s)\n", filename);
1276
1277         sprintf(filename, "%s%s", output_path, FILENAME_OPS_NZ);
1278         if((g_ops_nz_file = fopen(filename, "wt")) == NULL)
1279                 perror_exit("Unable to create ops nz file (%s)\n", filename);
1280
1281         if((g_input_file=fopen(g_input_filename, "rt")) == NULL)
1282                 perror_exit("can't open %s for input", g_input_filename);
1283
1284
1285         /* Get to the first section of the input file */
1286         section_id[0] = 0;
1287         while(strcmp(section_id, ID_INPUT_SEPARATOR) != 0)
1288                 if(fgetline(section_id, MAX_LINE_LENGTH, g_input_file) < 0)
1289                         error_exit("Premature EOF while reading input file");
1290
1291         /* Now process all sections */
1292         for(;;)
1293         {
1294                 if(fgetline(section_id, MAX_LINE_LENGTH, g_input_file) < 0)
1295                         error_exit("Premature EOF while reading input file");
1296                 if(strcmp(section_id, ID_PROTOTYPE_HEADER) == 0)
1297                 {
1298                         if(prototype_header_read)
1299                                 error_exit("Duplicate prototype header");
1300                         read_insert(temp_insert);
1301                         fprintf(g_prototype_file, "%s\n\n", temp_insert);
1302                         prototype_header_read = 1;
1303                 }
1304                 else if(strcmp(section_id, ID_TABLE_HEADER) == 0)
1305                 {
1306                         if(table_header_read)
1307                                 error_exit("Duplicate table header");
1308                         read_insert(temp_insert);
1309                         fprintf(g_table_file, "%s", temp_insert);
1310                         table_header_read = 1;
1311                 }
1312                 else if(strcmp(section_id, ID_OPHANDLER_HEADER) == 0)
1313                 {
1314                         if(ophandler_header_read)
1315                                 error_exit("Duplicate opcode handler header");
1316                         read_insert(temp_insert);
1317                         fprintf(g_ops_ac_file, "%s\n\n", temp_insert);
1318                         fprintf(g_ops_dm_file, "%s\n\n", temp_insert);
1319                         fprintf(g_ops_nz_file, "%s\n\n", temp_insert);
1320                         ophandler_header_read = 1;
1321                 }
1322                 else if(strcmp(section_id, ID_PROTOTYPE_FOOTER) == 0)
1323                 {
1324                         if(prototype_footer_read)
1325                                 error_exit("Duplicate prototype footer");
1326                         read_insert(prototype_footer_insert);
1327                         prototype_footer_read = 1;
1328                 }
1329                 else if(strcmp(section_id, ID_TABLE_FOOTER) == 0)
1330                 {
1331                         if(table_footer_read)
1332                                 error_exit("Duplicate table footer");
1333                         read_insert(table_footer_insert);
1334                         table_footer_read = 1;
1335                 }
1336                 else if(strcmp(section_id, ID_OPHANDLER_FOOTER) == 0)
1337                 {
1338                         if(ophandler_footer_read)
1339                                 error_exit("Duplicate opcode handler footer");
1340                         read_insert(ophandler_footer_insert);
1341                         ophandler_footer_read = 1;
1342                 }
1343                 else if(strcmp(section_id, ID_TABLE_BODY) == 0)
1344                 {
1345                         if(!prototype_header_read)
1346                                 error_exit("Table body encountered before prototype header");
1347                         if(!table_header_read)
1348                                 error_exit("Table body encountered before table header");
1349                         if(!ophandler_header_read)
1350                                 error_exit("Table body encountered before opcode handler header");
1351
1352                         if(table_body_read)
1353                                 error_exit("Duplicate table body");
1354
1355                         populate_table();
1356                         table_body_read = 1;
1357                 }
1358                 else if(strcmp(section_id, ID_OPHANDLER_BODY) == 0)
1359                 {
1360                         if(!prototype_header_read)
1361                                 error_exit("Opcode handlers encountered before prototype header");
1362                         if(!table_header_read)
1363                                 error_exit("Opcode handlers encountered before table header");
1364                         if(!ophandler_header_read)
1365                                 error_exit("Opcode handlers encountered before opcode handler header");
1366                         if(!table_body_read)
1367                                 error_exit("Opcode handlers encountered before table body");
1368
1369                         if(ophandler_body_read)
1370                                 error_exit("Duplicate opcode handler section");
1371
1372                         process_opcode_handlers();
1373
1374                         ophandler_body_read = 1;
1375                 }
1376                 else if(strcmp(section_id, ID_END) == 0)
1377                 {
1378                         /* End of input file.  Do a sanity check and then write footers */
1379                         if(!prototype_header_read)
1380                                 error_exit("Missing prototype header");
1381                         if(!prototype_footer_read)
1382                                 error_exit("Missing prototype footer");
1383                         if(!table_header_read)
1384                                 error_exit("Missing table header");
1385                         if(!table_footer_read)
1386                                 error_exit("Missing table footer");
1387                         if(!table_body_read)
1388                                 error_exit("Missing table body");
1389                         if(!ophandler_header_read)
1390                                 error_exit("Missing opcode handler header");
1391                         if(!ophandler_footer_read)
1392                                 error_exit("Missing opcode handler footer");
1393                         if(!ophandler_body_read)
1394                                 error_exit("Missing opcode handler body");
1395
1396                         print_opcode_output_table(g_table_file);
1397
1398                         fprintf(g_prototype_file, "%s\n\n", prototype_footer_insert);
1399                         fprintf(g_table_file, "%s\n\n", table_footer_insert);
1400                         fprintf(g_ops_ac_file, "%s\n\n", ophandler_footer_insert);
1401                         fprintf(g_ops_dm_file, "%s\n\n", ophandler_footer_insert);
1402                         fprintf(g_ops_nz_file, "%s\n\n", ophandler_footer_insert);
1403
1404                         break;
1405                 }
1406                 else
1407                 {
1408                         error_exit("Unknown section identifier: %s", section_id);
1409                 }
1410         }
1411
1412         /* Close all files and exit */
1413         fclose(g_prototype_file);
1414         fclose(g_table_file);
1415         fclose(g_ops_ac_file);
1416         fclose(g_ops_dm_file);
1417         fclose(g_ops_nz_file);
1418         fclose(g_input_file);
1419
1420         printf("Generated %d opcode handlers from %d primitives\n", g_num_functions, g_num_primitives);
1421
1422         return 0;
1423 }
1424
1425
1426
1427 /* ======================================================================== */
1428 /* ============================== END OF FILE ============================= */
1429 /* ======================================================================== */