From ddcd172a03b3e986bcab3bcd41caa303af63a665 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 4 Jun 2001 02:41:45 +0000 Subject: [PATCH] re-write the opcode selection to be a hash table lookup and statment generation to get the opcode from the table record rather than the location within the table (ewww). gives a nice speed boost /and/ makes the opcode table easier to maintain. --- tools/qfcc/include/qfcc.h | 21 ++- tools/qfcc/source/Makefile.am | 2 +- tools/qfcc/source/pr_comp.c | 231 +++++----------------------- tools/qfcc/source/pr_opcode.c | 277 ++++++++++++++++++++++++++++++++++ tools/qfcc/source/qfcc.c | 8 +- 5 files changed, 340 insertions(+), 199 deletions(-) create mode 100644 tools/qfcc/source/pr_opcode.c diff --git a/tools/qfcc/include/qfcc.h b/tools/qfcc/include/qfcc.h index 731e16cbc..eed000a85 100644 --- a/tools/qfcc/include/qfcc.h +++ b/tools/qfcc/include/qfcc.h @@ -321,18 +321,29 @@ extern pr_info_t pr; typedef struct { - char *name; - char *opname; - float priority; + const char *name; + const char *opname; + pr_opcode_e opcode; + int priority; qboolean right_associative; def_t *type_a, *type_b, *type_c; } opcode_t; +extern opcode_t *op_done; +extern opcode_t *op_return; +extern opcode_t *op_if; +extern opcode_t *op_ifnot; +extern opcode_t *op_state; +extern opcode_t *op_goto; + +def_t *PR_Statement (opcode_t *op, def_t *var_a, def_t *var_b); +opcode_t *PR_Opcode_Find (const char *name, int priority, def_t *var_a, def_t *var_b, def_t *var_c); +opcode_t *PR_Opcode (short opcode); +void PR_Opcode_Init (void); + //============================================================================ -extern opcode_t pr_opcodes[99]; // sized by initialization - extern qboolean pr_dumpasm; extern def_t *pr_global_defs[MAX_REGS]; // to find def for a global variable diff --git a/tools/qfcc/source/Makefile.am b/tools/qfcc/source/Makefile.am index 7f4060b42..58debf697 100644 --- a/tools/qfcc/source/Makefile.am +++ b/tools/qfcc/source/Makefile.am @@ -32,5 +32,5 @@ INCLUDES= -I$(top_srcdir)/include bin_PROGRAMS= qfcc -qfcc_SOURCES= cmdlib.c pr_comp.c pr_def.c pr_imm.c pr_lex.c qfcc.c +qfcc_SOURCES= cmdlib.c pr_comp.c pr_def.c pr_imm.c pr_lex.c pr_opcode.c qfcc.c qfcc_LDADD= -lQFutil diff --git a/tools/qfcc/source/pr_comp.c b/tools/qfcc/source/pr_comp.c index 0c813b5c2..620e9f35d 100644 --- a/tools/qfcc/source/pr_comp.c +++ b/tools/qfcc/source/pr_comp.c @@ -21,6 +21,8 @@ # include "config.h" #endif +#include + #include "qfcc.h" @@ -42,100 +44,6 @@ void PR_ParseDefs (void); //======================================== - -opcode_t pr_opcodes[] = { - {"", "DONE", -1, false, &def_entity, &def_field, &def_void}, - - {"*", "MUL_F", 2, false, &def_float, &def_float, &def_float}, - {"*", "MUL_V", 2, false, &def_vector, &def_vector, &def_float}, - {"*", "MUL_FV", 2, false, &def_float, &def_vector, &def_vector}, - {"*", "MUL_VF", 2, false, &def_vector, &def_float, &def_vector}, - - {"/", "DIV", 2, false, &def_float, &def_float, &def_float}, - - {"+", "ADD_F", 3, false, &def_float, &def_float, &def_float}, - {"+", "ADD_V", 3, false, &def_vector, &def_vector, &def_vector}, - - {"-", "SUB_F", 3, false, &def_float, &def_float, &def_float}, - {"-", "SUB_V", 3, false, &def_vector, &def_vector, &def_vector}, - - {"==", "EQ_F", 4, false, &def_float, &def_float, &def_float}, - {"==", "EQ_V", 4, false, &def_vector, &def_vector, &def_float}, - {"==", "EQ_S", 4, false, &def_string, &def_string, &def_float}, - {"==", "EQ_E", 4, false, &def_entity, &def_entity, &def_float}, - {"==", "EQ_FNC", 4, false, &def_function, &def_function, &def_float}, - - {"!=", "NE_F", 4, false, &def_float, &def_float, &def_float}, - {"!=", "NE_V", 4, false, &def_vector, &def_vector, &def_float}, - {"!=", "NE_S", 4, false, &def_string, &def_string, &def_float}, - {"!=", "NE_E", 4, false, &def_entity, &def_entity, &def_float}, - {"!=", "NE_FNC", 4, false, &def_function, &def_function, &def_float}, - - {"<=", "LE", 4, false, &def_float, &def_float, &def_float}, - {">=", "GE", 4, false, &def_float, &def_float, &def_float}, - {"<", "LT", 4, false, &def_float, &def_float, &def_float}, - {">", "GT", 4, false, &def_float, &def_float, &def_float}, - - {".", "INDIRECT", 1, false, &def_entity, &def_field, &def_float}, - {".", "INDIRECT", 1, false, &def_entity, &def_field, &def_vector}, - {".", "INDIRECT", 1, false, &def_entity, &def_field, &def_string}, - {".", "INDIRECT", 1, false, &def_entity, &def_field, &def_entity}, - {".", "INDIRECT", 1, false, &def_entity, &def_field, &def_field}, - {".", "INDIRECT", 1, false, &def_entity, &def_field, &def_function}, - - {".", "ADDRESS", 1, false, &def_entity, &def_field, &def_pointer}, - - {"=", "STORE_F", 5, true, &def_float, &def_float, &def_float}, - {"=", "STORE_V", 5, true, &def_vector, &def_vector, &def_vector}, - {"=", "STORE_S", 5, true, &def_string, &def_string, &def_string}, - {"=", "STORE_ENT", 5, true, &def_entity, &def_entity, &def_entity}, - {"=", "STORE_FLD", 5, true, &def_field, &def_field, &def_field}, - {"=", "STORE_FNC", 5, true, &def_function, &def_function, &def_function}, - - {"=", "STOREP_F", 5, true, &def_pointer, &def_float, &def_float}, - {"=", "STOREP_V", 5, true, &def_pointer, &def_vector, &def_vector}, - {"=", "STOREP_S", 5, true, &def_pointer, &def_string, &def_string}, - {"=", "STOREP_ENT", 5, true, &def_pointer, &def_entity, &def_entity}, - {"=", "STOREP_FLD", 5, true, &def_pointer, &def_field, &def_field}, - {"=", "STOREP_FNC", 5, true, &def_pointer, &def_function, &def_function}, - - {"", "RETURN", -1, false, &def_void, &def_void, &def_void}, - - {"!", "NOT_F", -1, false, &def_float, &def_void, &def_float}, - {"!", "NOT_V", -1, false, &def_vector, &def_void, &def_float}, - {"!", "NOT_S", -1, false, &def_vector, &def_void, &def_float}, - {"!", "NOT_ENT", -1, false, &def_entity, &def_void, &def_float}, - {"!", "NOT_FNC", -1, false, &def_function, &def_void, &def_float}, - - {"", "IF", -1, false, &def_float, &def_float, &def_void}, - {"", "IFNOT", -1, false, &def_float, &def_float, &def_void}, - -// calls returns REG_RETURN - {"", "CALL0", -1, false, &def_function, &def_void, &def_void}, - {"", "CALL1", -1, false, &def_function, &def_void, &def_void}, - {"", "CALL2", -1, false, &def_function, &def_void, &def_void}, - {"", "CALL3", -1, false, &def_function, &def_void, &def_void}, - {"", "CALL4", -1, false, &def_function, &def_void, &def_void}, - {"", "CALL5", -1, false, &def_function, &def_void, &def_void}, - {"", "CALL6", -1, false, &def_function, &def_void, &def_void}, - {"", "CALL7", -1, false, &def_function, &def_void, &def_void}, - {"", "CALL8", -1, false, &def_function, &def_void, &def_void}, - - {"", "STATE", -1, false, &def_float, &def_float, &def_void}, - - {"", "GOTO", -1, false, &def_float, &def_void, &def_void}, - - {"&&", "AND", 6, false, &def_float, &def_float, &def_float}, - {"||", "OR", 6, false, &def_float, &def_float, &def_float}, - - {"&", "BITAND", 2, false, &def_float, &def_float, &def_float}, - {"|", "BITOR", 2, false, &def_float, &def_float, &def_float}, - - {"+", "ADD_S", 3, false, &def_string, &def_string, &def_string}, - - {NULL} -}; - #define TOP_PRIORITY 6 #define NOT_PRIORITY 4 @@ -146,45 +54,6 @@ def_t *PR_Expression (int priority); //=========================================================================== -/* - PR_Statement - - Emits a primitive statement, returning the var it places it's value in -*/ -def_t * -PR_Statement (opcode_t * op, def_t * var_a, def_t * var_b) -{ - dstatement_t *statement; - def_t *var_c; - - statement = &statements[numstatements]; - numstatements++; - - statement_linenums[statement - statements] = pr_source_line; - statement->op = op - pr_opcodes; - statement->a = var_a ? var_a->ofs : 0; - statement->b = var_b ? var_b->ofs : 0; - if (op->type_c == &def_void || op->right_associative) { - // ifs, gotos, and assignments don't need vars allocated - var_c = NULL; - statement->c = 0; - } else { // allocate result space - var_c = malloc (sizeof (def_t)); - memset (var_c, 0, sizeof (def_t)); - var_c->ofs = numpr_globals; - var_c->type = op->type_c->type; - - statement->c = numpr_globals; - numpr_globals += type_size[op->type_c->type->type]; - } - - if (op->right_associative) - return var_a; - - return var_c; -} - - void PrecacheSound (def_t *e, int ch) { @@ -281,6 +150,7 @@ PR_ParseFunctionCall (def_t *func) def_t *e; int arg; type_t *t; + opcode_t *op; t = func->type; @@ -311,7 +181,8 @@ PR_ParseFunctionCall (def_t *func) // a vector copy will copy everything def_parms[arg].type = t->parm_types[arg]; - PR_Statement (&pr_opcodes[OP_STORE_V], e, &def_parms[arg]); + op = PR_Opcode_Find ("=", 5, &def_vector, &def_vector, &def_vector); + PR_Statement (op, e, &def_parms[arg]); arg++; } while (PR_Check (tt_punct, ",")); @@ -323,7 +194,8 @@ PR_ParseFunctionCall (def_t *func) if (arg > 8) PR_ParseError ("More than eight parameters"); - PR_Statement (&pr_opcodes[OP_CALL0 + arg], func, 0); + op = PR_Opcode_Find (va ("", arg), -1, &def_function, &def_void, &def_void); + PR_Statement (op, func, 0); def_ret.type = t->aux_type; return &def_ret; @@ -361,25 +233,16 @@ def_t * PR_Term (void) { def_t *e; - etype_t t; + opcode_t *op; if (PR_Check (tt_punct, "!")) { e = PR_Expression (NOT_PRIORITY); - t = e->type->type; - switch (t) { - case ev_float: - return PR_Statement (&pr_opcodes[OP_NOT_F], e, 0); - case ev_string: - return PR_Statement (&pr_opcodes[OP_NOT_S], e, 0); - case ev_entity: - return PR_Statement (&pr_opcodes[OP_NOT_ENT], e, 0); - case ev_vector: - return PR_Statement (&pr_opcodes[OP_NOT_V], e, 0); - case ev_func: - return PR_Statement (&pr_opcodes[OP_NOT_FNC], e, 0); - default: - PR_ParseError ("Type mismatch for !"); - return NULL; + op = PR_Opcode_Find ("!", -1, e, &def_void, &def_float); + if (op) { + return PR_Statement (op, e, 0); + } else { + PR_ParseError ("Type mismatch for !"); + return NULL; } } @@ -401,7 +264,8 @@ PR_Expression (int priority) { opcode_t *op, *oldop; def_t *e, *e2; - etype_t type_a, type_b, type_c; + def_t var_c; + char *token; if (!priority) return PR_Term (); @@ -412,14 +276,10 @@ PR_Expression (int priority) if (priority == 1 && PR_Check (tt_punct, "(")) return PR_ParseFunctionCall (e); - for (op = pr_opcodes; op->name; op++) { - - if (op->priority != priority) - continue; - - if (!PR_Check (tt_punct, op->name)) - continue; - + op = PR_Opcode_Find (pr_token, priority, 0, 0, 0); + if (op) { + token = strdup (pr_token); + PR_Lex (); if (op->right_associative) { // if last statement is an indirect, change it to an address of if ((unsigned) (statements[numstatements - 1].op - OP_LOAD_F) < 6) { @@ -433,29 +293,20 @@ PR_Expression (int priority) } // type check - type_a = e->type->type; - type_b = e2->type->type; - if (op->name[0] == '.') { // field access gets type from field - if (e2->type->aux_type) - type_c = e2->type->aux_type->type; - else - type_c = -1; // not a field + var_c.type = e2->type->aux_type; } else { - type_c = ev_void; + var_c.type = &type_void; } - + oldop = op; - while (type_a != op->type_a->type->type - || type_b != op->type_b->type->type - || (type_c != ev_void && type_c != op->type_c->type->type) - || strcmp (op->name, oldop->name)) { - op++; - if (!op->name)// || strcmp (op->name, oldop->name)) - PR_ParseError ("type mismatch for %s", oldop->name); - } + op = PR_Opcode_Find (token, priority, e, e2, &var_c); + free (token); - if (type_a == ev_pointer && type_b != e->type->aux_type->type) + if (!op) + PR_ParseError ("type mismatch for %s", oldop->name); + + if (e->type->type == ev_pointer && e2->type->type != e->type->aux_type->type) PR_ParseError ("type mismatch for %s", op->name); if (op->right_associative) @@ -463,13 +314,11 @@ PR_Expression (int priority) else e = PR_Statement (op, e, e2); - if (type_c != ev_void) // field access gets type from field + if (var_c.type != &type_void) // field access gets type from field e->type = e2->type->aux_type; - - break; } - if (!op->name) // next token isn't at this priority level + if (!op) // next token isn't at this priority level break; } @@ -495,14 +344,14 @@ PR_ParseStatement (void) if (PR_Check (tt_name, "return")) { if (PR_Check (tt_punct, ";")) { - PR_Statement (&pr_opcodes[OP_RETURN], 0, 0); + PR_Statement (op_return, 0, 0); return; } e = PR_Expression (TOP_PRIORITY); PR_Expect (tt_punct, ";"); - PR_Statement (&pr_opcodes[OP_RETURN], e, 0); + PR_Statement (op_return, e, 0); return; } @@ -513,10 +362,10 @@ PR_ParseStatement (void) e = PR_Expression (TOP_PRIORITY); PR_Expect (tt_punct, ")"); patch1 = &statements[numstatements]; - PR_Statement (&pr_opcodes[OP_IFNOT], e, 0); + PR_Statement (op_ifnot, e, 0); PR_ParseStatement (); junkdef.ofs = patch2 - &statements[numstatements]; - PR_Statement (&pr_opcodes[OP_GOTO], &junkdef, 0); + PR_Statement (op_goto, &junkdef, 0); patch1->b = &statements[numstatements] - patch1; return; } @@ -530,7 +379,7 @@ PR_ParseStatement (void) PR_Expect (tt_punct, ")"); PR_Expect (tt_punct, ";"); junkdef.ofs = patch1 - &statements[numstatements]; - PR_Statement (&pr_opcodes[OP_IF], e, &junkdef); + PR_Statement (op_if, e, &junkdef); return; } @@ -546,13 +395,13 @@ PR_ParseStatement (void) PR_Expect (tt_punct, ")"); patch1 = &statements[numstatements]; - PR_Statement (&pr_opcodes[OP_IFNOT], e, 0); + PR_Statement (op_ifnot, e, 0); PR_ParseStatement (); if (PR_Check (tt_name, "else")) { patch2 = &statements[numstatements]; - PR_Statement (&pr_opcodes[OP_GOTO], 0, 0); + PR_Statement (op_goto, 0, 0); patch1->b = &statements[numstatements] - patch1; PR_ParseStatement (); patch2->a = &statements[numstatements] - patch2; @@ -606,7 +455,7 @@ PR_ParseState (void) PR_Expect (tt_punct, "]"); - PR_Statement (&pr_opcodes[OP_STATE], s1, def); + PR_Statement (op_state, s1, def); } /* @@ -659,7 +508,7 @@ PR_ParseImmediateStatements (type_t *type) PR_ParseStatement (); // emit an end of statements opcode - PR_Statement (pr_opcodes, 0, 0); + PR_Statement (op_done, 0, 0); return f; } diff --git a/tools/qfcc/source/pr_opcode.c b/tools/qfcc/source/pr_opcode.c new file mode 100644 index 000000000..99947e3db --- /dev/null +++ b/tools/qfcc/source/pr_opcode.c @@ -0,0 +1,277 @@ +/* Copyright (C) 1996-1997 Id Software, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + See file, 'COPYING', for details. +*/ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include + +#include "qfcc.h" + +hashtab_t *opcode_table; +hashtab_t *opcode_priority_table; +hashtab_t *opcode_priority_type_table_ab; +hashtab_t *opcode_priority_type_table_abc; + +opcode_t *op_done; +opcode_t *op_return; +opcode_t *op_if; +opcode_t *op_ifnot; +opcode_t *op_state; +opcode_t *op_goto; + +opcode_t pr_opcodes[] = { + {"", "DONE", OP_DONE, -1, false, &def_entity, &def_field, &def_void}, + + {"*", "MUL_F", OP_MUL_F, 2, false, &def_float, &def_float, &def_float}, + {"*", "MUL_V", OP_MUL_V, 2, false, &def_vector, &def_vector, &def_float}, + {"*", "MUL_FV", OP_MUL_FV, 2, false, &def_float, &def_vector, &def_vector}, + {"*", "MUL_VF", OP_MUL_VF, 2, false, &def_vector, &def_float, &def_vector}, + + {"/", "DIV_F", OP_DIV_F, 2, false, &def_float, &def_float, &def_float}, + + {"+", "ADD_F", OP_ADD_F, 3, false, &def_float, &def_float, &def_float}, + {"+", "ADD_V", OP_ADD_V, 3, false, &def_vector, &def_vector, &def_vector}, + + {"-", "SUB_F", OP_SUB_F, 3, false, &def_float, &def_float, &def_float}, + {"-", "SUB_V", OP_SUB_V, 3, false, &def_vector, &def_vector, &def_vector}, + + {"==", "EQ_F", OP_EQ_F, 4, false, &def_float, &def_float, &def_float}, + {"==", "EQ_V", OP_EQ_V, 4, false, &def_vector, &def_vector, &def_float}, + {"==", "EQ_S", OP_EQ_S, 4, false, &def_string, &def_string, &def_float}, + {"==", "EQ_E", OP_EQ_E, 4, false, &def_entity, &def_entity, &def_float}, + {"==", "EQ_FNC", OP_EQ_FNC, 4, false, &def_function, &def_function, &def_float}, + + {"!=", "NE_F", OP_NE_F, 4, false, &def_float, &def_float, &def_float}, + {"!=", "NE_V", OP_NE_V, 4, false, &def_vector, &def_vector, &def_float}, + {"!=", "NE_S", OP_NE_S, 4, false, &def_string, &def_string, &def_float}, + {"!=", "NE_E", OP_NE_E, 4, false, &def_entity, &def_entity, &def_float}, + {"!=", "NE_FNC", OP_NE_FNC, 4, false, &def_function, &def_function, &def_float}, + + {"<=", "LE", OP_LE, 4, false, &def_float, &def_float, &def_float}, + {">=", "GE", OP_GE, 4, false, &def_float, &def_float, &def_float}, + {"<", "LT", OP_LT, 4, false, &def_float, &def_float, &def_float}, + {">", "GT", OP_GT, 4, false, &def_float, &def_float, &def_float}, + + {".", "INDIRECT", OP_LOAD_F, 1, false, &def_entity, &def_field, &def_float}, + {".", "INDIRECT", OP_LOAD_V, 1, false, &def_entity, &def_field, &def_vector}, + {".", "INDIRECT", OP_LOAD_S, 1, false, &def_entity, &def_field, &def_string}, + {".", "INDIRECT", OP_LOAD_ENT, 1, false, &def_entity, &def_field, &def_entity}, + {".", "INDIRECT", OP_LOAD_FLD, 1, false, &def_entity, &def_field, &def_field}, + {".", "INDIRECT", OP_LOAD_FNC, 1, false, &def_entity, &def_field, &def_function}, + + {".", "ADDRESS", OP_ADDRESS, 1, false, &def_entity, &def_field, &def_pointer}, + + {"=", "STORE_F", OP_STORE_F, 5, true, &def_float, &def_float, &def_float}, + {"=", "STORE_V", OP_STORE_V, 5, true, &def_vector, &def_vector, &def_vector}, + {"=", "STORE_S", OP_STORE_S, 5, true, &def_string, &def_string, &def_string}, + {"=", "STORE_ENT", OP_STORE_ENT, 5, true, &def_entity, &def_entity, &def_entity}, + {"=", "STORE_FLD", OP_STORE_FLD, 5, true, &def_field, &def_field, &def_field}, + {"=", "STORE_FNC", OP_STORE_FNC, 5, true, &def_function, &def_function, &def_function}, + + {"=", "STOREP_F", OP_STOREP_F, 5, true, &def_pointer, &def_float, &def_float}, + {"=", "STOREP_V", OP_STOREP_V, 5, true, &def_pointer, &def_vector, &def_vector}, + {"=", "STOREP_S", OP_STOREP_S, 5, true, &def_pointer, &def_string, &def_string}, + {"=", "STOREP_ENT", OP_STOREP_ENT, 5, true, &def_pointer, &def_entity, &def_entity}, + {"=", "STOREP_FLD", OP_STOREP_FLD, 5, true, &def_pointer, &def_field, &def_field}, + {"=", "STOREP_FNC", OP_STOREP_FNC, 5, true, &def_pointer, &def_function, &def_function}, + + {"", "RETURN", OP_RETURN, -1, false, &def_void, &def_void, &def_void}, + + {"!", "NOT_F", OP_NOT_F, -1, false, &def_float, &def_void, &def_float}, + {"!", "NOT_V", OP_NOT_V, -1, false, &def_vector, &def_void, &def_float}, + {"!", "NOT_S", OP_NOT_S, -1, false, &def_string, &def_void, &def_float}, + {"!", "NOT_ENT", OP_NOT_ENT, -1, false, &def_entity, &def_void, &def_float}, + {"!", "NOT_FNC", OP_NOT_FNC, -1, false, &def_function, &def_void, &def_float}, + + {"", "IF", OP_IF, -1, false, &def_float, &def_float, &def_void}, + {"", "IFNOT", OP_IFNOT, -1, false, &def_float, &def_float, &def_void}, + +// calls returns REG_RETURN + {"", "CALL0", OP_CALL0, -1, false, &def_function, &def_void, &def_void}, + {"", "CALL1", OP_CALL1, -1, false, &def_function, &def_void, &def_void}, + {"", "CALL2", OP_CALL2, -1, false, &def_function, &def_void, &def_void}, + {"", "CALL3", OP_CALL3, -1, false, &def_function, &def_void, &def_void}, + {"", "CALL4", OP_CALL4, -1, false, &def_function, &def_void, &def_void}, + {"", "CALL5", OP_CALL5, -1, false, &def_function, &def_void, &def_void}, + {"", "CALL6", OP_CALL6, -1, false, &def_function, &def_void, &def_void}, + {"", "CALL7", OP_CALL7, -1, false, &def_function, &def_void, &def_void}, + {"", "CALL8", OP_CALL8, -1, false, &def_function, &def_void, &def_void}, + + {"", "STATE", OP_STATE, -1, false, &def_float, &def_float, &def_void}, + + {"", "GOTO", OP_GOTO, -1, false, &def_float, &def_void, &def_void}, + + {"&&", "AND", OP_AND, 6, false, &def_float, &def_float, &def_float}, + {"||", "OR", OP_OR, 6, false, &def_float, &def_float, &def_float}, + + {"&", "BITAND", OP_BITAND, 2, false, &def_float, &def_float, &def_float}, + {"|", "BITOR", OP_BITOR, 2, false, &def_float, &def_float, &def_float}, + + {"+", "ADD_S", OP_ADD_S, 3, false, &def_string, &def_string, &def_string}, +}; + +/* + PR_Statement + + Emits a primitive statement, returning the var it places it's value in +*/ +def_t * +PR_Statement (opcode_t * op, def_t * var_a, def_t * var_b) +{ + dstatement_t *statement; + def_t *var_c; + + statement = &statements[numstatements]; + numstatements++; + + statement_linenums[statement - statements] = pr_source_line; + statement->op = op->opcode; + statement->a = var_a ? var_a->ofs : 0; + statement->b = var_b ? var_b->ofs : 0; + if (op->type_c == &def_void || op->right_associative) { + // ifs, gotos, and assignments don't need vars allocated + var_c = NULL; + statement->c = 0; + } else { // allocate result space + var_c = malloc (sizeof (def_t)); + memset (var_c, 0, sizeof (def_t)); + var_c->ofs = numpr_globals; + var_c->type = op->type_c->type; + + statement->c = numpr_globals; + numpr_globals += type_size[op->type_c->type->type]; + } + + if (op->right_associative) + return var_a; + + return var_c; +} + +static char * +get_key (void *_op, void *_tab) +{ + opcode_t *op = (opcode_t *)_op; + hashtab_t **tab = (hashtab_t **)_tab; + static char rep[100]; + char *r = rep; + const char *s = op->name; + + if (tab == &opcode_priority_table) { + while (*s) + *r++ = *s++; + *r++ = op->priority + 2; + *r = 0; + } else if (tab == &opcode_priority_type_table_ab) { + while (*s) + *r++ = *s++; + *r++ = op->priority + 2; + *r++ = op->type_a->type->type + 2; + *r++ = op->type_b->type->type + 2; + *r = 0; + } else if (tab == &opcode_priority_type_table_abc) { + while (*s) + *r++ = *s++; + *r++ = op->priority + 2; + *r++ = op->type_a->type->type + 2; + *r++ = op->type_b->type->type + 2; + *r++ = (op->type_c->type ? op->type_c->type->type : -1) + 2; + *r = 0; + } else if (tab == &opcode_table) { + *r++ = (op->opcode & 0xff) + 2; + *r++ = ((op->opcode >> 8) & 0xff) + 2; + *r = 0; + } else { + abort (); + } + return rep; +} + +opcode_t * +PR_Opcode_Find (const char *name, int priority, def_t *var_a, def_t *var_b, def_t *var_c) +{ + opcode_t op; + hashtab_t **tab; + char rep[100]; + + op.name = name; + op.priority = priority; + if (var_a && var_b && var_c) { + op.type_a = var_a; + op.type_b = var_b; + op.type_c = var_c; + if (op.type_c->type && op.type_c->type->type == ev_void) + tab = &opcode_priority_type_table_ab; + else + tab = &opcode_priority_type_table_abc; + strcpy (rep, get_key (&op, tab)); + //printf ("%s\n", rep); + return Hash_Find (*tab, rep); + } else { + strcpy (rep, get_key (&op, &opcode_priority_table)); + return Hash_Find (opcode_priority_table, rep); + } +} + +opcode_t * +PR_Opcode (short opcode) +{ + opcode_t op; + char rep[100]; + + op.opcode = opcode; + strcpy (rep, get_key (&op, &opcode_table)); + return Hash_Find (opcode_table, rep); +} + +void +PR_Opcode_Init (void) +{ + int i; + + opcode_table = Hash_NewTable (1021, get_key, 0, &opcode_table); + opcode_priority_table = Hash_NewTable (1021, get_key, 0, + &opcode_priority_table); + opcode_priority_type_table_ab = Hash_NewTable (1021, get_key, 0, + &opcode_priority_type_table_ab); + opcode_priority_type_table_abc = Hash_NewTable (1021, get_key, 0, + &opcode_priority_type_table_abc); + for (i = 0; i < sizeof (pr_opcodes) / sizeof (pr_opcodes[0]); i++) { + opcode_t *op = &pr_opcodes[i]; + Hash_Add (opcode_table, op); + Hash_Add (opcode_priority_table, op); + Hash_Add (opcode_priority_type_table_ab, op); + Hash_Add (opcode_priority_type_table_abc, op); + if (!strcmp (op->name, "")) { + op_done = op; + } else if (!strcmp (op->name, "")) { + op_return = op; + } else if (!strcmp (op->name, "")) { + op_if = op; + } else if (!strcmp (op->name, "")) { + op_ifnot = op; + } else if (!strcmp (op->name, "")) { + op_state = op; + } else if (!strcmp (op->name, "")) { + op_goto = op; + } + } +} diff --git a/tools/qfcc/source/qfcc.c b/tools/qfcc/source/qfcc.c index 9e5ccab25..d5ffcd91b 100644 --- a/tools/qfcc/source/qfcc.c +++ b/tools/qfcc/source/qfcc.c @@ -533,11 +533,13 @@ void PR_PrintStatement (dstatement_t *s) { int i; + opcode_t *op; + op = PR_Opcode (s->op); printf ("%4i : %4i : %s ", (int) (s - statements), - statement_linenums[s - statements], pr_opcodes[s->op].opname); + statement_linenums[s - statements], op->opname); - for (i = strlen (pr_opcodes[s->op].opname); i < 10; i++) { + for (i = strlen (op->opname); i < 10; i++) { printf (" "); } @@ -804,6 +806,8 @@ Options: \n\ printf ("Source directory: %s\n", sourcedir); } + PR_Opcode_Init (); + InitData (); sprintf (filename, "%s/progs.src", sourcedir);