6502/acme
1
0
Fork 0
mirror of https://github.com/uffejakobsen/acme.git synced 2024-11-26 15:49:18 +00:00
Code Issues Projects Releases Wiki Activity

renamed stuff

Browse Source 
git-svn-id: https://svn.code.sf.net/p/acme-crossass/code-0/trunk@163 4df02467-bbd4-4a76-a152-e7ce94205b78
This commit is contained in:
marcobaye 2020-05-14 10:19:21 +00:00
parent c055688355
commit 7c732fca59
1 changed files with 216 additions and 216 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

432
src/alu.c
View File

@ -54,109 +54,109 @@ enum op_group {
OPGROUP_MONADIC, // {result} = {op} {arg} OPGROUP_MONADIC, // {result} = {op} {arg}
OPGROUP_DYADIC // {result} = {arg1} {op} {arg2} OPGROUP_DYADIC // {result} = {arg1} {op} {arg2}
}; };
enum op_handle { enum op_id {
// special (pseudo) operators: // special (pseudo) operators:
OPHANDLE_START_OF_EXPR, // "start of expression" OPID_START_EXPRESSION, // "start of expression"
OPHANDLE_END_OF_EXPR, // "end of expression" OPID_END_EXPRESSION, // "end of expression"
OPHANDLE_OPENING, // (v '(', starts subexpression (handled like monadic) OPID_OPENING, // (v '(', starts subexpression (handled like monadic)
OPHANDLE_CLOSING, // v) ')', ends subexpression (handled like dyadic) OPID_CLOSING, // v) ')', ends subexpression (handled like dyadic)
// monadic operators (including functions): // monadic operators (including functions):
OPHANDLE_NOT, // !v NOT v bit-wise NOT OPID_NOT, // !v NOT v bit-wise NOT
OPHANDLE_NEGATE, // -v Negate OPID_NEGATE, // -v Negate
OPHANDLE_LOWBYTEOF, // <v Lowbyte of OPID_LOWBYTEOF, // <v Lowbyte of
OPHANDLE_HIGHBYTEOF, // >v Highbyte of OPID_HIGHBYTEOF, // >v Highbyte of
OPHANDLE_BANKBYTEOF, // ^v Bankbyte of OPID_BANKBYTEOF, // ^v Bankbyte of
OPHANDLE_ADDR, // addr(v) FIXME - add nonaddr()? OPID_ADDRESS, // addr(v) FIXME - add nonaddr()?
OPHANDLE_INT, // int(v) OPID_INT, // int(v)
OPHANDLE_FLOAT, // float(v) OPID_FLOAT, // float(v)
OPHANDLE_SIN, // sin(v) OPID_SIN, // sin(v)
OPHANDLE_COS, // cos(v) OPID_COS, // cos(v)
OPHANDLE_TAN, // tan(v) OPID_TAN, // tan(v)
OPHANDLE_ARCSIN, // arcsin(v) OPID_ARCSIN, // arcsin(v)
OPHANDLE_ARCCOS, // arccos(v) OPID_ARCCOS, // arccos(v)
OPHANDLE_ARCTAN, // arctan(v) OPID_ARCTAN, // arctan(v)
// dyadic operators: // dyadic operators:
OPHANDLE_POWEROF, // v^w OPID_POWEROF, // v^w
OPHANDLE_MULTIPLY, // v*w OPID_MULTIPLY, // v*w
OPHANDLE_DIVIDE, // v/w (Integer) Division OPID_DIVIDE, // v/w (Integer) Division
OPHANDLE_INTDIV, // v/w v DIV w Integer Division OPID_INTDIV, // v/w v DIV w Integer Division
OPHANDLE_MODULO, // v%w v MOD w Remainder OPID_MODULO, // v%w v MOD w Remainder
OPHANDLE_SL, // v<<w v ASL w v LSL w Shift left OPID_SL, // v<<w v ASL w v LSL w Shift left
OPHANDLE_ASR, // v>>w v ASR w Arithmetic shift right OPID_ASR, // v>>w v ASR w Arithmetic shift right
OPHANDLE_LSR, // v>>>w v LSR w Logical shift right OPID_LSR, // v>>>w v LSR w Logical shift right
OPHANDLE_ADD, // v+w OPID_ADD, // v+w
OPHANDLE_SUBTRACT, // v-w OPID_SUBTRACT, // v-w
OPHANDLE_EQUALS, // v=w OPID_EQUALS, // v=w
OPHANDLE_LE, // v<=w OPID_LE, // v<=w
OPHANDLE_LESSTHAN, // v< w OPID_LESSTHAN, // v< w
OPHANDLE_GE, // v>=w OPID_GE, // v>=w
OPHANDLE_GREATERTHAN, // v> w OPID_GREATERTHAN, // v> w
OPHANDLE_NOTEQUAL, // v!=w v<>w v><w OPID_NOTEQUAL, // v!=w v<>w v><w
OPHANDLE_AND, // v&w v AND w OPID_AND, // v&w v AND w
OPHANDLE_OR, // v|w v OR w OPID_OR, // v|w v OR w
OPHANDLE_EOR, // v EOR w v XOR w FIXME - remove OPID_EOR, // v EOR w v XOR w FIXME - remove
OPHANDLE_XOR, // v XOR w OPID_XOR, // v XOR w
}; };
struct op { struct op {
#define IS_RIGHT_ASSOCIATIVE(prio) ((prio) & 1) #define IS_RIGHT_ASSOCIATIVE(prio) ((prio) & 1)
int priority; // lsb holds "is_right_associative" info! int priority; // lsb holds "is_right_associative" info!
enum op_group group; enum op_group group;
enum op_handle handle; enum op_id id;
// FIXME - add text version of op to struct, for better error messages! // FIXME - add text version of op to struct, for better error messages!
}; };
static struct op ops_end_of_expr = {0, OPGROUP_SPECIAL, OPHANDLE_END_OF_EXPR }; static struct op ops_end_of_expr = {0, OPGROUP_SPECIAL, OPID_END_EXPRESSION };
static struct op ops_start_of_expr = {2, OPGROUP_SPECIAL, OPHANDLE_START_OF_EXPR }; static struct op ops_start_of_expr = {2, OPGROUP_SPECIAL, OPID_START_EXPRESSION };
static struct op ops_closing = {4, OPGROUP_SPECIAL, OPHANDLE_CLOSING }; static struct op ops_closing = {4, OPGROUP_SPECIAL, OPID_CLOSING };
static struct op ops_opening = {6, OPGROUP_SPECIAL, OPHANDLE_OPENING }; static struct op ops_opening = {6, OPGROUP_SPECIAL, OPID_OPENING };
//static struct op ops_closeindex = {8, OPGROUP_SPECIAL, OPHANDLE_ }; //static struct op ops_closeindex = {8, OPGROUP_SPECIAL, OPID_ };
//static struct op ops_openindex = {10, OPGROUP_SPECIAL, OPHANDLE_ }; //static struct op ops_openindex = {10, OPGROUP_SPECIAL, OPID_ };
static struct op ops_or = {16, OPGROUP_DYADIC, OPHANDLE_OR }; static struct op ops_or = {16, OPGROUP_DYADIC, OPID_OR };
static struct op ops_eor = {18, OPGROUP_DYADIC, OPHANDLE_EOR }; // FIXME - remove static struct op ops_eor = {18, OPGROUP_DYADIC, OPID_EOR }; // FIXME - remove
static struct op ops_xor = {18, OPGROUP_DYADIC, OPHANDLE_XOR }; static struct op ops_xor = {18, OPGROUP_DYADIC, OPID_XOR };
static struct op ops_and = {20, OPGROUP_DYADIC, OPHANDLE_AND }; static struct op ops_and = {20, OPGROUP_DYADIC, OPID_AND };
static struct op ops_equals = {22, OPGROUP_DYADIC, OPHANDLE_EQUALS }; static struct op ops_equals = {22, OPGROUP_DYADIC, OPID_EQUALS };
static struct op ops_notequal = {24, OPGROUP_DYADIC, OPHANDLE_NOTEQUAL }; static struct op ops_notequal = {24, OPGROUP_DYADIC, OPID_NOTEQUAL };
// same priority for all comparison operators // same priority for all comparison operators
static struct op ops_le = {26, OPGROUP_DYADIC, OPHANDLE_LE }; static struct op ops_le = {26, OPGROUP_DYADIC, OPID_LE };
static struct op ops_lessthan = {26, OPGROUP_DYADIC, OPHANDLE_LESSTHAN }; static struct op ops_lessthan = {26, OPGROUP_DYADIC, OPID_LESSTHAN };
static struct op ops_ge = {26, OPGROUP_DYADIC, OPHANDLE_GE }; static struct op ops_ge = {26, OPGROUP_DYADIC, OPID_GE };
static struct op ops_greaterthan = {26, OPGROUP_DYADIC, OPHANDLE_GREATERTHAN }; static struct op ops_greaterthan = {26, OPGROUP_DYADIC, OPID_GREATERTHAN };
// same priority for all byte extraction operators // same priority for all byte extraction operators
static struct op ops_lowbyteof = {28, OPGROUP_MONADIC, OPHANDLE_LOWBYTEOF }; static struct op ops_lowbyteof = {28, OPGROUP_MONADIC, OPID_LOWBYTEOF };
static struct op ops_highbyteof = {28, OPGROUP_MONADIC, OPHANDLE_HIGHBYTEOF }; static struct op ops_highbyteof = {28, OPGROUP_MONADIC, OPID_HIGHBYTEOF };
static struct op ops_bankbyteof = {28, OPGROUP_MONADIC, OPHANDLE_BANKBYTEOF }; static struct op ops_bankbyteof = {28, OPGROUP_MONADIC, OPID_BANKBYTEOF };
// same priority for all shift operators (left-associative, though they could be argued to be made right-associative :)) // same priority for all shift operators (left-associative, though they could be argued to be made right-associative :))
static struct op ops_sl = {30, OPGROUP_DYADIC, OPHANDLE_SL }; static struct op ops_sl = {30, OPGROUP_DYADIC, OPID_SL };
static struct op ops_asr = {30, OPGROUP_DYADIC, OPHANDLE_ASR }; static struct op ops_asr = {30, OPGROUP_DYADIC, OPID_ASR };
static struct op ops_lsr = {30, OPGROUP_DYADIC, OPHANDLE_LSR }; static struct op ops_lsr = {30, OPGROUP_DYADIC, OPID_LSR };
// same priority for "+" and "-" // same priority for "+" and "-"
static struct op ops_add = {32, OPGROUP_DYADIC, OPHANDLE_ADD }; static struct op ops_add = {32, OPGROUP_DYADIC, OPID_ADD };
static struct op ops_subtract = {32, OPGROUP_DYADIC, OPHANDLE_SUBTRACT }; static struct op ops_subtract = {32, OPGROUP_DYADIC, OPID_SUBTRACT };
// same priority for "*", "/" and "%" // same priority for "*", "/" and "%"
static struct op ops_multiply = {34, OPGROUP_DYADIC, OPHANDLE_MULTIPLY }; static struct op ops_multiply = {34, OPGROUP_DYADIC, OPID_MULTIPLY };
static struct op ops_divide = {34, OPGROUP_DYADIC, OPHANDLE_DIVIDE }; static struct op ops_divide = {34, OPGROUP_DYADIC, OPID_DIVIDE };
static struct op ops_intdiv = {34, OPGROUP_DYADIC, OPHANDLE_INTDIV }; static struct op ops_intdiv = {34, OPGROUP_DYADIC, OPID_INTDIV };
static struct op ops_modulo = {34, OPGROUP_DYADIC, OPHANDLE_MODULO }; static struct op ops_modulo = {34, OPGROUP_DYADIC, OPID_MODULO };
// highest "real" priorities // highest "real" priorities
static struct op ops_negate = {36, OPGROUP_MONADIC, OPHANDLE_NEGATE }; static struct op ops_negate = {36, OPGROUP_MONADIC, OPID_NEGATE };
static struct op ops_powerof = {37, OPGROUP_DYADIC, OPHANDLE_POWEROF }; // right-associative! static struct op ops_powerof = {37, OPGROUP_DYADIC, OPID_POWEROF }; // right-associative!
static struct op ops_not = {38, OPGROUP_MONADIC, OPHANDLE_NOT }; static struct op ops_not = {38, OPGROUP_MONADIC, OPID_NOT };
//static struct op ops_atindex = {40, OPGROUP_DYADIC, OPHANDLE_ }; //static struct op ops_atindex = {40, OPGROUP_DYADIC, OPID_ };
// function calls act as if they were monadic operators. // function calls act as if they were monadic operators.
// they need high priorities to make sure they are evaluated once the // they need high priorities to make sure they are evaluated once the
// parentheses' content is known: // parentheses' content is known:
// "sin(3 + 4) DYADIC_OPERATOR 5" becomes "sin 7 DYADIC_OPERATOR 5", // "sin(3 + 4) DYADIC_OPERATOR 5" becomes "sin 7 DYADIC_OPERATOR 5",
// so function calls' priority must be higher than all dyadic operators. // so function calls' priority must be higher than all dyadic operators.
static struct op ops_addr = {42, OPGROUP_MONADIC, OPHANDLE_ADDR }; static struct op ops_addr = {42, OPGROUP_MONADIC, OPID_ADDRESS };
static struct op ops_int = {42, OPGROUP_MONADIC, OPHANDLE_INT }; static struct op ops_int = {42, OPGROUP_MONADIC, OPID_INT };
static struct op ops_float = {42, OPGROUP_MONADIC, OPHANDLE_FLOAT }; static struct op ops_float = {42, OPGROUP_MONADIC, OPID_FLOAT };
static struct op ops_sin = {42, OPGROUP_MONADIC, OPHANDLE_SIN }; static struct op ops_sin = {42, OPGROUP_MONADIC, OPID_SIN };
static struct op ops_cos = {42, OPGROUP_MONADIC, OPHANDLE_COS }; static struct op ops_cos = {42, OPGROUP_MONADIC, OPID_COS };
static struct op ops_tan = {42, OPGROUP_MONADIC, OPHANDLE_TAN }; static struct op ops_tan = {42, OPGROUP_MONADIC, OPID_TAN };
static struct op ops_arcsin = {42, OPGROUP_MONADIC, OPHANDLE_ARCSIN }; static struct op ops_arcsin = {42, OPGROUP_MONADIC, OPID_ARCSIN };
static struct op ops_arccos = {42, OPGROUP_MONADIC, OPHANDLE_ARCCOS }; static struct op ops_arccos = {42, OPGROUP_MONADIC, OPID_ARCCOS };
static struct op ops_arctan = {42, OPGROUP_MONADIC, OPHANDLE_ARCTAN }; static struct op ops_arctan = {42, OPGROUP_MONADIC, OPID_ARCTAN };
//static struct op ops_len = {42, OPGROUP_MONADIC, OPHANDLE_ }; //static struct op ops_len = {42, OPGROUP_MONADIC, OPID_ };
// variables // variables
@ -994,57 +994,57 @@ static void int_handle_monadic_operator(struct object *self, struct op *op)
{ {
int refs = 0; // default for "addr_refs", shortens this fn int refs = 0; // default for "addr_refs", shortens this fn
switch (op->handle) { switch (op->id) {
case OPHANDLE_ADDR: case OPID_ADDRESS:
refs = 1; // result now is an address refs = 1; // result now is an address
break; break;
case OPHANDLE_INT: case OPID_INT:
break; break;
case OPHANDLE_FLOAT: case OPID_FLOAT:
int_to_float(self); int_to_float(self);
break; break;
case OPHANDLE_SIN: case OPID_SIN:
case OPHANDLE_COS: case OPID_COS:
case OPHANDLE_TAN: case OPID_TAN:
case OPHANDLE_ARCSIN: case OPID_ARCSIN:
case OPHANDLE_ARCCOS: case OPID_ARCCOS:
case OPHANDLE_ARCTAN: case OPID_ARCTAN:
// convert int to fp and ask fp handler to do the work // convert int to fp and ask fp handler to do the work
int_to_float(self); int_to_float(self);
type_float.handle_monadic_operator(self, op); // TODO - put recursion check around this? type_float.handle_monadic_operator(self, op); // TODO - put recursion check around this?
return; // float handler has done everything return; // float handler has done everything
case OPHANDLE_NOT: case OPID_NOT:
self->u.number.val.intval = ~(self->u.number.val.intval); self->u.number.val.intval = ~(self->u.number.val.intval);
self->u.number.flags &= ~NUMBER_FITS_BYTE; self->u.number.flags &= ~NUMBER_FITS_BYTE;
refs = -(self->u.number.addr_refs); // negate address ref count refs = -(self->u.number.addr_refs); // negate address ref count
break; break;
case OPHANDLE_NEGATE: case OPID_NEGATE:
self->u.number.val.intval = -(self->u.number.val.intval); self->u.number.val.intval = -(self->u.number.val.intval);
self->u.number.flags &= ~NUMBER_FITS_BYTE; self->u.number.flags &= ~NUMBER_FITS_BYTE;
refs = -(self->u.number.addr_refs); // negate address ref count as well refs = -(self->u.number.addr_refs); // negate address ref count as well
break; break;
case OPHANDLE_LOWBYTEOF: case OPID_LOWBYTEOF:
self->u.number.val.intval = (self->u.number.val.intval) & 255; self->u.number.val.intval = (self->u.number.val.intval) & 255;
self->u.number.flags |= NUMBER_FITS_BYTE; self->u.number.flags |= NUMBER_FITS_BYTE;
self->u.number.flags &= ~NUMBER_FORCEBITS; self->u.number.flags &= ~NUMBER_FORCEBITS;
break; break;
case OPHANDLE_HIGHBYTEOF: case OPID_HIGHBYTEOF:
self->u.number.val.intval = ((self->u.number.val.intval) >> 8) & 255; self->u.number.val.intval = ((self->u.number.val.intval) >> 8) & 255;
self->u.number.flags |= NUMBER_FITS_BYTE; self->u.number.flags |= NUMBER_FITS_BYTE;
self->u.number.flags &= ~NUMBER_FORCEBITS; self->u.number.flags &= ~NUMBER_FORCEBITS;
break; break;
case OPHANDLE_BANKBYTEOF: case OPID_BANKBYTEOF:
self->u.number.val.intval = ((self->u.number.val.intval) >> 16) & 255; self->u.number.val.intval = ((self->u.number.val.intval) >> 16) & 255;
self->u.number.flags |= NUMBER_FITS_BYTE; self->u.number.flags |= NUMBER_FITS_BYTE;
self->u.number.flags &= ~NUMBER_FORCEBITS; self->u.number.flags &= ~NUMBER_FORCEBITS;
break; break;
// add new monadic operators here // add new monadic operators here
// case OPHANDLE_: // case OPID_:
// Throw_error("'int' type does not support this operation"); // Throw_error("'int' type does not support this operation");
// break; // break;
default: default:
Bug_found("IllegalOperatorHandleIM", op->handle); Bug_found("IllegalOperatorIdIM", op->id);
} }
self->u.number.addr_refs = refs; // update address refs with local copy self->u.number.addr_refs = refs; // update address refs with local copy
} }
@ -1069,53 +1069,53 @@ static void float_handle_monadic_operator(struct object *self, struct op *op)
{ {
int refs = 0; // default for "addr_refs", shortens this fn int refs = 0; // default for "addr_refs", shortens this fn
switch (op->handle) { switch (op->id) {
case OPHANDLE_ADDR: case OPID_ADDRESS:
refs = 1; // result now is an address refs = 1; // result now is an address
break; break;
case OPHANDLE_INT: case OPID_INT:
float_to_int(self); float_to_int(self);
break; break;
case OPHANDLE_FLOAT: case OPID_FLOAT:
break; break;
case OPHANDLE_SIN: case OPID_SIN:
self->u.number.val.fpval = sin(self->u.number.val.fpval); self->u.number.val.fpval = sin(self->u.number.val.fpval);
break; break;
case OPHANDLE_COS: case OPID_COS:
self->u.number.val.fpval = cos(self->u.number.val.fpval); self->u.number.val.fpval = cos(self->u.number.val.fpval);
break; break;
case OPHANDLE_TAN: case OPID_TAN:
self->u.number.val.fpval = tan(self->u.number.val.fpval); self->u.number.val.fpval = tan(self->u.number.val.fpval);
break; break;
case OPHANDLE_ARCSIN: case OPID_ARCSIN:
float_ranged_fn(asin, self); float_ranged_fn(asin, self);
break; break;
case OPHANDLE_ARCCOS: case OPID_ARCCOS:
float_ranged_fn(acos, self); float_ranged_fn(acos, self);
break; break;
case OPHANDLE_ARCTAN: case OPID_ARCTAN:
self->u.number.val.fpval = atan(self->u.number.val.fpval); self->u.number.val.fpval = atan(self->u.number.val.fpval);
break; break;
case OPHANDLE_NEGATE: case OPID_NEGATE:
self->u.number.val.fpval = -(self->u.number.val.fpval); self->u.number.val.fpval = -(self->u.number.val.fpval);
self->u.number.flags &= ~NUMBER_FITS_BYTE; self->u.number.flags &= ~NUMBER_FITS_BYTE;
refs = -(self->u.number.addr_refs); // negate address ref count as well refs = -(self->u.number.addr_refs); // negate address ref count as well
break; break;
case OPHANDLE_NOT: case OPID_NOT:
case OPHANDLE_LOWBYTEOF: case OPID_LOWBYTEOF:
case OPHANDLE_HIGHBYTEOF: case OPID_HIGHBYTEOF:
case OPHANDLE_BANKBYTEOF: case OPID_BANKBYTEOF:
// convert fp to int and ask int handler to do the work // convert fp to int and ask int handler to do the work
float_to_int(self); float_to_int(self);
type_int.handle_monadic_operator(self, op); // TODO - put recursion check around this? type_int.handle_monadic_operator(self, op); // TODO - put recursion check around this?
return; // int handler has done everything return; // int handler has done everything
// add new monadic operators here // add new monadic operators here
// case OPHANDLE_: // case OPID_:
// Throw_error("'float' type does not support this operation"); // Throw_error("'float' type does not support this operation");
// break; // break;
default: default:
Bug_found("IllegalOperatorHandleFM", op->handle); Bug_found("IllegalOperatorIdFM", op->id);
} }
self->u.number.addr_refs = refs; // update address refs with local copy self->u.number.addr_refs = refs; // update address refs with local copy
} }
@ -1152,41 +1152,41 @@ static void int_handle_dyadic_operator(struct object *self, struct op *op, struc
// ok // ok
} else if (other->type == &type_float) { } else if (other->type == &type_float) {
// handle according to operation // handle according to operation
switch (op->handle) { switch (op->id) {
case OPHANDLE_POWEROF: case OPID_POWEROF:
case OPHANDLE_MULTIPLY: case OPID_MULTIPLY:
case OPHANDLE_DIVIDE: case OPID_DIVIDE:
case OPHANDLE_INTDIV: case OPID_INTDIV:
case OPHANDLE_ADD: case OPID_ADD:
case OPHANDLE_SUBTRACT: case OPID_SUBTRACT:
case OPHANDLE_EQUALS: case OPID_EQUALS:
case OPHANDLE_LE: case OPID_LE:
case OPHANDLE_LESSTHAN: case OPID_LESSTHAN:
case OPHANDLE_GE: case OPID_GE:
case OPHANDLE_GREATERTHAN: case OPID_GREATERTHAN:
case OPHANDLE_NOTEQUAL: case OPID_NOTEQUAL:
// become float, delegate to float handler // become float, delegate to float handler
int_to_float(self); int_to_float(self);
type_float.handle_dyadic_operator(self, op, other); // TODO - put recursion check around this? type_float.handle_dyadic_operator(self, op, other); // TODO - put recursion check around this?
return; // float handler has done everything return; // float handler has done everything
case OPHANDLE_MODULO: case OPID_MODULO:
case OPHANDLE_SL: case OPID_SL:
case OPHANDLE_ASR: case OPID_ASR:
// convert other to int // convert other to int
float_to_int(other); float_to_int(other);
break; break;
case OPHANDLE_LSR: case OPID_LSR:
case OPHANDLE_AND: case OPID_AND:
case OPHANDLE_OR: case OPID_OR:
case OPHANDLE_EOR: case OPID_EOR:
case OPHANDLE_XOR: case OPID_XOR:
// convert other to int, warning user // convert other to int, warning user
float_to_int(other); float_to_int(other);
warn_float_to_int(); warn_float_to_int();
break; break;
// add new dyadic operators here: // add new dyadic operators here:
// case OPHANDLE_: // case OPID_:
// break; // break;
default: default:
unsupported_dyadic(self, op, other); unsupported_dyadic(self, op, other);
@ -1202,11 +1202,11 @@ static void int_handle_dyadic_operator(struct object *self, struct op *op, struc
// maybe put this into an extra "int_dyadic_int" function? // maybe put this into an extra "int_dyadic_int" function?
// sanity check, now "other" must be an int // sanity check, now "other" must be an int
if (other->type != &type_int) if (other->type != &type_int)
Bug_found("SecondArgIsNotAnInt", op->handle); // FIXME - rename? then add to docs! Bug_found("SecondArgIsNotAnInt", op->id); // FIXME - rename? then add to docs!
// part 2: now we got rid of floats, perform actual operation: // part 2: now we got rid of floats, perform actual operation:
switch (op->handle) { switch (op->id) {
case OPHANDLE_POWEROF: case OPID_POWEROF:
if (other->u.number.val.intval >= 0) { if (other->u.number.val.intval >= 0) {
self->u.number.val.intval = my_pow(self->u.number.val.intval, other->u.number.val.intval); self->u.number.val.intval = my_pow(self->u.number.val.intval, other->u.number.val.intval);
} else { } else {
@ -1215,18 +1215,18 @@ static void int_handle_dyadic_operator(struct object *self, struct op *op, struc
self->u.number.val.intval = 0; self->u.number.val.intval = 0;
} }
break; break;
case OPHANDLE_MULTIPLY: case OPID_MULTIPLY:
self->u.number.val.intval *= other->u.number.val.intval; self->u.number.val.intval *= other->u.number.val.intval;
break; break;
case OPHANDLE_DIVIDE: case OPID_DIVIDE:
case OPHANDLE_INTDIV: case OPID_INTDIV:
if (other->u.number.val.intval) { if (other->u.number.val.intval) {
self->u.number.val.intval /= other->u.number.val.intval; self->u.number.val.intval /= other->u.number.val.intval;
break; break;
} }
// "division by zero" output is below // "division by zero" output is below
/*FALLTHROUGH*/ /*FALLTHROUGH*/
case OPHANDLE_MODULO: case OPID_MODULO:
if (other->u.number.val.intval) { if (other->u.number.val.intval) {
self->u.number.val.intval %= other->u.number.val.intval; self->u.number.val.intval %= other->u.number.val.intval;
} else { } else {
@ -1235,62 +1235,62 @@ static void int_handle_dyadic_operator(struct object *self, struct op *op, struc
self->u.number.val.intval = 0; self->u.number.val.intval = 0;
} }
break; break;
case OPHANDLE_ADD: case OPID_ADD:
self->u.number.val.intval += other->u.number.val.intval; self->u.number.val.intval += other->u.number.val.intval;
refs = self->u.number.addr_refs + other->u.number.addr_refs; // add address references refs = self->u.number.addr_refs + other->u.number.addr_refs; // add address references
break; break;
case OPHANDLE_SUBTRACT: case OPID_SUBTRACT:
self->u.number.val.intval -= other->u.number.val.intval; self->u.number.val.intval -= other->u.number.val.intval;
refs = self->u.number.addr_refs - other->u.number.addr_refs; // subtract address references refs = self->u.number.addr_refs - other->u.number.addr_refs; // subtract address references
break; break;
case OPHANDLE_SL: case OPID_SL:
self->u.number.val.intval <<= other->u.number.val.intval; self->u.number.val.intval <<= other->u.number.val.intval;
break; break;
case OPHANDLE_ASR: case OPID_ASR:
self->u.number.val.intval = my_asr(self->u.number.val.intval, other->u.number.val.intval); self->u.number.val.intval = my_asr(self->u.number.val.intval, other->u.number.val.intval);
break; break;
case OPHANDLE_LSR: case OPID_LSR:
self->u.number.val.intval = ((uintval_t) (self->u.number.val.intval)) >> other->u.number.val.intval; self->u.number.val.intval = ((uintval_t) (self->u.number.val.intval)) >> other->u.number.val.intval;
break; break;
case OPHANDLE_LE: case OPID_LE:
self->u.number.val.intval = (self->u.number.val.intval <= other->u.number.val.intval); self->u.number.val.intval = (self->u.number.val.intval <= other->u.number.val.intval);
break; break;
case OPHANDLE_LESSTHAN: case OPID_LESSTHAN:
self->u.number.val.intval = (self->u.number.val.intval < other->u.number.val.intval); self->u.number.val.intval = (self->u.number.val.intval < other->u.number.val.intval);
break; break;
case OPHANDLE_GE: case OPID_GE:
self->u.number.val.intval = (self->u.number.val.intval >= other->u.number.val.intval); self->u.number.val.intval = (self->u.number.val.intval >= other->u.number.val.intval);
break; break;
case OPHANDLE_GREATERTHAN: case OPID_GREATERTHAN:
self->u.number.val.intval = (self->u.number.val.intval > other->u.number.val.intval); self->u.number.val.intval = (self->u.number.val.intval > other->u.number.val.intval);
break; break;
case OPHANDLE_NOTEQUAL: case OPID_NOTEQUAL:
self->u.number.val.intval = (self->u.number.val.intval != other->u.number.val.intval); self->u.number.val.intval = (self->u.number.val.intval != other->u.number.val.intval);
break; break;
case OPHANDLE_EQUALS: case OPID_EQUALS:
self->u.number.val.intval = (self->u.number.val.intval == other->u.number.val.intval); self->u.number.val.intval = (self->u.number.val.intval == other->u.number.val.intval);
break; break;
case OPHANDLE_AND: case OPID_AND:
self->u.number.val.intval &= other->u.number.val.intval; self->u.number.val.intval &= other->u.number.val.intval;
refs = self->u.number.addr_refs + other->u.number.addr_refs; // add address references refs = self->u.number.addr_refs + other->u.number.addr_refs; // add address references
break; break;
case OPHANDLE_OR: case OPID_OR:
self->u.number.val.intval |= other->u.number.val.intval; self->u.number.val.intval |= other->u.number.val.intval;
refs = self->u.number.addr_refs + other->u.number.addr_refs; // add address references refs = self->u.number.addr_refs + other->u.number.addr_refs; // add address references
break; break;
case OPHANDLE_EOR: case OPID_EOR:
Throw_first_pass_warning("\"EOR\" is deprecated; use \"XOR\" instead."); Throw_first_pass_warning("\"EOR\" is deprecated; use \"XOR\" instead.");
/*FALLTHROUGH*/ /*FALLTHROUGH*/
case OPHANDLE_XOR: case OPID_XOR:
self->u.number.val.intval ^= other->u.number.val.intval; self->u.number.val.intval ^= other->u.number.val.intval;
refs = self->u.number.addr_refs + other->u.number.addr_refs; // add address references refs = self->u.number.addr_refs + other->u.number.addr_refs; // add address references
break; break;
// add new dyadic operators here // add new dyadic operators here
// case OPHANDLE_: // case OPID_:
// Throw_error("'int' type does not support this operation"); // Throw_error("'int' type does not support this operation");
// break; // break;
default: default:
Bug_found("IllegalOperatorHandleID", op->handle); Bug_found("IllegalOperatorIdID", op->id);
} }
self->u.number.addr_refs = refs; // update address refs with local copy self->u.number.addr_refs = refs; // update address refs with local copy
number_fix_result_after_dyadic(self, other); // fix result flags number_fix_result_after_dyadic(self, other); // fix result flags
@ -1307,36 +1307,36 @@ static void float_handle_dyadic_operator(struct object *self, struct op *op, str
// ok // ok
} else if (other->type == &type_int) { } else if (other->type == &type_int) {
// handle according to operation // handle according to operation
switch (op->handle) { switch (op->id) {
// these want two floats // these want two floats
case OPHANDLE_POWEROF: case OPID_POWEROF:
case OPHANDLE_MULTIPLY: case OPID_MULTIPLY:
case OPHANDLE_DIVIDE: case OPID_DIVIDE:
case OPHANDLE_INTDIV: case OPID_INTDIV:
case OPHANDLE_ADD: case OPID_ADD:
case OPHANDLE_SUBTRACT: case OPID_SUBTRACT:
case OPHANDLE_LE: case OPID_LE:
case OPHANDLE_LESSTHAN: case OPID_LESSTHAN:
case OPHANDLE_GE: case OPID_GE:
case OPHANDLE_GREATERTHAN: case OPID_GREATERTHAN:
case OPHANDLE_NOTEQUAL: case OPID_NOTEQUAL:
case OPHANDLE_EQUALS: case OPID_EQUALS:
// convert other to float // convert other to float
int_to_float(other); int_to_float(other);
break; break;
// these jump to int handler anyway // these jump to int handler anyway
case OPHANDLE_MODULO: case OPID_MODULO:
case OPHANDLE_LSR: case OPID_LSR:
case OPHANDLE_AND: case OPID_AND:
case OPHANDLE_OR: case OPID_OR:
case OPHANDLE_EOR: case OPID_EOR:
case OPHANDLE_XOR: case OPID_XOR:
// these actually want a float and an int // these actually want a float and an int
case OPHANDLE_SL: case OPID_SL:
case OPHANDLE_ASR: case OPID_ASR:
break; break;
// add new dyadic operators here // add new dyadic operators here
// case OPHANDLE_: // case OPID_:
// break; // break;
default: default:
unsupported_dyadic(self, op, other); unsupported_dyadic(self, op, other);
@ -1350,14 +1350,14 @@ static void float_handle_dyadic_operator(struct object *self, struct op *op, str
return; return;
} }
switch (op->handle) { switch (op->id) {
case OPHANDLE_POWEROF: case OPID_POWEROF:
self->u.number.val.fpval = pow(self->u.number.val.fpval, other->u.number.val.fpval); self->u.number.val.fpval = pow(self->u.number.val.fpval, other->u.number.val.fpval);
break; break;
case OPHANDLE_MULTIPLY: case OPID_MULTIPLY:
self->u.number.val.fpval *= other->u.number.val.fpval; self->u.number.val.fpval *= other->u.number.val.fpval;
break; break;
case OPHANDLE_DIVIDE: case OPID_DIVIDE:
if (other->u.number.val.fpval) { if (other->u.number.val.fpval) {
self->u.number.val.fpval /= other->u.number.val.fpval; self->u.number.val.fpval /= other->u.number.val.fpval;
} else { } else {
@ -1366,7 +1366,7 @@ static void float_handle_dyadic_operator(struct object *self, struct op *op, str
self->u.number.val.fpval = 0; self->u.number.val.fpval = 0;
} }
break; break;
case OPHANDLE_INTDIV: case OPID_INTDIV:
if (other->u.number.val.fpval) { if (other->u.number.val.fpval) {
self->u.number.val.intval = self->u.number.val.fpval / other->u.number.val.fpval; // fp becomes int! self->u.number.val.intval = self->u.number.val.fpval / other->u.number.val.fpval; // fp becomes int!
} else { } else {
@ -1376,67 +1376,67 @@ static void float_handle_dyadic_operator(struct object *self, struct op *op, str
} }
self->type = &type_int; // result is int self->type = &type_int; // result is int
break; break;
case OPHANDLE_LSR: case OPID_LSR:
case OPHANDLE_AND: case OPID_AND:
case OPHANDLE_OR: case OPID_OR:
case OPHANDLE_EOR: case OPID_EOR:
case OPHANDLE_XOR: case OPID_XOR:
warn_float_to_int(); warn_float_to_int();
/*FALLTHROUGH*/ /*FALLTHROUGH*/
case OPHANDLE_MODULO: case OPID_MODULO:
float_to_int(self); float_to_int(self);
// int handler will check other and, if needed, convert to int // int handler will check other and, if needed, convert to int
type_int.handle_dyadic_operator(self, op, other); // TODO - put recursion check around this? type_int.handle_dyadic_operator(self, op, other); // TODO - put recursion check around this?
return; // int handler has done everything return; // int handler has done everything
case OPHANDLE_ADD: case OPID_ADD:
self->u.number.val.fpval += other->u.number.val.fpval; self->u.number.val.fpval += other->u.number.val.fpval;
refs = self->u.number.addr_refs + other->u.number.addr_refs; // add address references refs = self->u.number.addr_refs + other->u.number.addr_refs; // add address references
break; break;
case OPHANDLE_SUBTRACT: case OPID_SUBTRACT:
self->u.number.val.fpval -= other->u.number.val.fpval; self->u.number.val.fpval -= other->u.number.val.fpval;
refs = self->u.number.addr_refs - other->u.number.addr_refs; // subtract address references refs = self->u.number.addr_refs - other->u.number.addr_refs; // subtract address references
break; break;
case OPHANDLE_SL: case OPID_SL:
if (other->type == &type_float) if (other->type == &type_float)
float_to_int(other); float_to_int(other);
self->u.number.val.fpval *= pow(2.0, other->u.number.val.intval); self->u.number.val.fpval *= pow(2.0, other->u.number.val.intval);
break; break;
case OPHANDLE_ASR: case OPID_ASR:
if (other->type == &type_float) if (other->type == &type_float)
float_to_int(other); float_to_int(other);
self->u.number.val.fpval /= (1 << other->u.number.val.intval); // FIXME - why not use pow() as in SL above? self->u.number.val.fpval /= (1 << other->u.number.val.intval); // FIXME - why not use pow() as in SL above?
break; break;
case OPHANDLE_LE: case OPID_LE:
self->u.number.val.intval = (self->u.number.val.fpval <= other->u.number.val.fpval); self->u.number.val.intval = (self->u.number.val.fpval <= other->u.number.val.fpval);
self->type = &type_int; // result is int self->type = &type_int; // result is int
break; break;
case OPHANDLE_LESSTHAN: case OPID_LESSTHAN:
self->u.number.val.intval = (self->u.number.val.fpval < other->u.number.val.fpval); self->u.number.val.intval = (self->u.number.val.fpval < other->u.number.val.fpval);
self->type = &type_int; // result is int self->type = &type_int; // result is int
break; break;
case OPHANDLE_GE: case OPID_GE:
self->u.number.val.intval = (self->u.number.val.fpval >= other->u.number.val.fpval); self->u.number.val.intval = (self->u.number.val.fpval >= other->u.number.val.fpval);
self->type = &type_int; // result is int self->type = &type_int; // result is int
break; break;
case OPHANDLE_GREATERTHAN: case OPID_GREATERTHAN:
self->u.number.val.intval = (self->u.number.val.fpval > other->u.number.val.fpval); self->u.number.val.intval = (self->u.number.val.fpval > other->u.number.val.fpval);
self->type = &type_int; // result is int self->type = &type_int; // result is int
break; break;
case OPHANDLE_NOTEQUAL: case OPID_NOTEQUAL:
self->u.number.val.intval = (self->u.number.val.fpval != other->u.number.val.fpval); self->u.number.val.intval = (self->u.number.val.fpval != other->u.number.val.fpval);
self->type = &type_int; // result is int self->type = &type_int; // result is int
break; break;
case OPHANDLE_EQUALS: case OPID_EQUALS:
self->u.number.val.intval = (self->u.number.val.fpval == other->u.number.val.fpval); self->u.number.val.intval = (self->u.number.val.fpval == other->u.number.val.fpval);
self->type = &type_int; // result is int self->type = &type_int; // result is int
break; break;
// add new dyadic operators here // add new dyadic operators here
// case OPHANDLE_: // case OPID_:
// Throw_error("var type does not support this operation"); // Throw_error("var type does not support this operation");
// break; // break;
default: default:
Bug_found("IllegalOperatorHandleFD", op->handle); Bug_found("IllegalOperatorIdFD", op->id);
} }
self->u.number.addr_refs = refs; // update address refs with local copy self->u.number.addr_refs = refs; // update address refs with local copy
number_fix_result_after_dyadic(self, other); // fix result flags number_fix_result_after_dyadic(self, other); // fix result flags
@ -1542,10 +1542,10 @@ struct type type_list = {
// handler for special operators like parentheses and start/end of expression: // handler for special operators like parentheses and start/end of expression:
// returns whether caller should just return without fixing stack (because this fn has fixed it) // returns whether caller should just return without fixing stack (because this fn has fixed it)
static boolean handle_special_operator(struct expression *expression, enum op_handle previous, enum op_handle current) static boolean handle_special_operator(struct expression *expression, enum op_id previous, enum op_id current)
{ {
switch (previous) { switch (previous) {
case OPHANDLE_START_OF_EXPR: case OPID_START_EXPRESSION:
// the only operator with a lower priority than this // the only operator with a lower priority than this
// "start-of-expression" operator is "end-of-expression", // "start-of-expression" operator is "end-of-expression",
// therefore we know we are done. // therefore we know we are done.
@ -1553,15 +1553,15 @@ static boolean handle_special_operator(struct expression *expression, enum op_ha
--op_sp; // decrement operator stack pointer --op_sp; // decrement operator stack pointer
alu_state = STATE_END; // done alu_state = STATE_END; // done
break; break;
case OPHANDLE_OPENING: case OPID_OPENING:
expression->is_parenthesized = TRUE; // found parentheses. if this is not the outermost level, the outermost level will fix this. expression->is_parenthesized = TRUE; // found parentheses. if this is not the outermost level, the outermost level will fix this.
// check current operator // check current operator
switch (current) { switch (current) {
case OPHANDLE_CLOSING: // matching parentheses case OPID_CLOSING: // matching parentheses
op_sp -= 2; // remove both of them op_sp -= 2; // remove both of them
alu_state = STATE_EXPECT_DYADIC_OP; alu_state = STATE_EXPECT_DYADIC_OP;
break; break;
case OPHANDLE_END_OF_EXPR: // unmatched parenthesis case OPID_END_EXPRESSION: // unmatched parenthesis
++(expression->open_parentheses); // count ++(expression->open_parentheses); // count
return FALSE; // caller can remove operator from stack return FALSE; // caller can remove operator from stack
@ -1569,12 +1569,12 @@ static boolean handle_special_operator(struct expression *expression, enum op_ha
Bug_found("StrangeParenthesis", current); Bug_found("StrangeParenthesis", current);
} }
break; break;
case OPHANDLE_CLOSING: case OPID_CLOSING:
Throw_error("Too many ')'."); Throw_error("Too many ')'.");
alu_state = STATE_ERROR; alu_state = STATE_ERROR;
break; break;
default: default:
Bug_found("IllegalOperatorHandleS", previous); Bug_found("IllegalOperatorIdS", previous);
} }
return TRUE; // stack is done, so caller shouldn't touch it return TRUE; // stack is done, so caller shouldn't touch it
} }
@ -1629,13 +1629,13 @@ static void try_to_reduce_stacks(struct expression *expression)
expression->is_parenthesized = FALSE; expression->is_parenthesized = FALSE;
break; break;
case OPGROUP_SPECIAL: // special (pseudo) operators case OPGROUP_SPECIAL: // special (pseudo) operators
if (handle_special_operator(expression, previous_op->handle, current_op->handle)) if (handle_special_operator(expression, previous_op->id, current_op->id))
return; // called fn has fixed the stack, so we return and don't touch it return; // called fn has fixed the stack, so we return and don't touch it
// both monadics and dyadics clear "is_parenthesized", but here we don't touch it! // both monadics and dyadics clear "is_parenthesized", but here we don't touch it!
break; break;
default: default:
Bug_found("IllegalOperatorHandle", previous_op->group); // FIXME - change to IllegalOperatorGroup! Bug_found("IllegalOperatorGroup", previous_op->group); // FIXME - add to docs!
} }
// shared endings for "we did the operation indicated by previous operator": // shared endings for "we did the operation indicated by previous operator":
// fix stack: // fix stack: