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