X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?p=rmac;a=blobdiff_plain;f=expr.c;h=01868e8a0b17ecc1c222bd0cdd73ebd557f81228;hp=6373114484d70b845c10c4e68ada293c9340999d;hb=5cd8a4814b805f1ef8ce689423eb5eeba12573c5;hpb=062214e62031c26d372edc2e68473ebb64f6a506 diff --git a/expr.c b/expr.c index 6373114..01868e8 100644 --- a/expr.c +++ b/expr.c @@ -1,9 +1,9 @@ // // RMAC - Reboot's Macro Assembler for the Atari Jaguar Console System // EXPR.C - Expression Analyzer -// Copyright (C) 199x Landon Dyer, 2011 Reboot and Friends +// Copyright (C) 199x Landon Dyer, 2017 Reboot and Friends // RMAC derived from MADMAC v1.07 Written by Landon Dyer, 1986 -// Source Utilised with the Kind Permission of Landon Dyer +// Source utilised with the kind permission of Landon Dyer // #include "expr.h" @@ -17,45 +17,49 @@ #include "symbol.h" #include "token.h" -#define DEF_KW // Declare keyword values -#include "kwtab.h" // Incl generated keyword tables & defs +#define DEF_KW // Declare keyword values +#include "kwtab.h" // Incl generated keyword tables & defs -static char tokenClass[128]; // Generated table of token classes -static VALUE evstk[EVSTACKSIZE]; // Evaluator value stack -static WORD evattr[EVSTACKSIZE]; // Evaluator attribute stack +// N.B.: The size of tokenClass should be identical to the largest value of +// a token; we're assuming 256 but not 100% sure! +static char tokenClass[256]; // Generated table of token classes +static VALUE evstk[EVSTACKSIZE]; // Evaluator value stack +static WORD evattr[EVSTACKSIZE]; // Evaluator attribute stack // Token-class initialization list char itokcl[] = { - 0, // END - CONST, SYMBOL, 0, // ID - '(', '[', '{', 0, // OPAR - ')', ']', '}', 0, // CPAR - CR_DEFINED, CR_REFERENCED, // SUNARY (special unary) + 0, // END + CONST, SYMBOL, 0, // ID + '(', '[', '{', 0, // OPAR + ')', ']', '}', 0, // CPAR + CR_DEFINED, CR_REFERENCED, // SUNARY (special unary) CR_STREQ, CR_MACDEF, - CR_DATE, CR_TIME, 0, - '!', '~', UNMINUS, 0, // UNARY - '*', '/', '%', 0, // MULT - '+', '-', 0, // ADD - SHL, SHR, 0, // SHIFT - LE, GE, '<', '>', NE, '=', 0, // REL - '&', 0, // AND - '^', 0, // XOR - '|', 0, // OR - 1 // (the end) + CR_DATE, CR_TIME, + CR_ABSCOUNT, 0, + '!', '~', UNMINUS, 0, // UNARY + '*', '/', '%', 0, // MULT + '+', '-', 0, // ADD + SHL, SHR, 0, // SHIFT + LE, GE, '<', '>', NE, '=', 0, // REL + '&', 0, // AND + '^', 0, // XOR + '|', 0, // OR + 1 // (the end) }; const char missym_error[] = "missing symbol"; const char str_error[] = "missing symbol or string"; // Convert expression to postfix -static TOKEN * evalTokenBuffer; // Deposit tokens here (this is really a - // pointer to exprbuf from direct.c) - // (Can also be from others, like riscasm.c) -static symbolNum; // Pointer to the entry in symbolPtr[] +static TOKEN * evalTokenBuffer; // Deposit tokens here (this is really a + // pointer to exprbuf from direct.c) + // (Can also be from others, like + // riscasm.c) +static int symbolNum; // Pointer to the entry in symbolPtr[] // -// Obtain a String Value +// Obtain a string value // static VALUE str_value(char * p) { @@ -69,22 +73,21 @@ static VALUE str_value(char * p) // -// Initialize Expression Analyzer +// Initialize expression analyzer // void InitExpression(void) { - int i; // Iterator - char * p; // Token pointer - // Initialize token-class table (all set to END) - for(i=0; i<128; i++) + for(int i=0; i<256; i++) tokenClass[i] = END; - for(i=0, p=itokcl; *p!=1; p++) + int i = 0; + + for(char * p=itokcl; *p!=1; p++) { if (*p == 0) i++; - else + else tokenClass[(int)(*p)] = (char)i; } @@ -101,7 +104,7 @@ int expr0(void) if (expr1() != OK) return ERROR; - + while (tokenClass[*tok] >= MULT) { t = *tok++; @@ -118,6 +121,9 @@ int expr0(void) // // Unary operators (detect unary '-') +// ggn: If expression starts with a plus then also eat it up. +// For some reason the parser gets confused when this happens and +// emits a "bad expression". // int expr1(void) { @@ -130,7 +136,7 @@ int expr1(void) class = tokenClass[*tok]; - if (*tok == '-' || class == UNARY) + if (*tok == '-' || *tok == '+' || class == UNARY) { t = *tok++; @@ -146,6 +152,10 @@ int expr1(void) { switch ((int)*tok++) { + case CR_ABSCOUNT: + *evalTokenBuffer++ = CONST; + *evalTokenBuffer++ = (LONG)sect[ABS].sloc; + break; case CR_TIME: *evalTokenBuffer++ = CONST; *evalTokenBuffer++ = dos_time(); @@ -191,7 +201,7 @@ getsym: if (*tok != SYMBOL && *tok != STRING) return error(str_error); - p = string[tok[1]]; + p2 = string[tok[1]]; tok += 2; w = (WORD)(!strcmp(p, p2)); @@ -200,7 +210,7 @@ getsym: break; } } - else + else return expr2(); return OK; @@ -233,7 +243,7 @@ int expr2(void) // Check register bank usage if (sy->sattre & EQUATEDREG) { - if ((regbank == BANK_0) && (sy->sattre & BANK_1) && !altbankok) + if ((regbank == BANK_0) && (sy->sattre & BANK_1) && !altbankok) warns("equated symbol \'%s\' cannot be used in register bank 0", sy->sname); if ((regbank == BANK_1) && (sy->sattre & BANK_0) && !altbankok) @@ -273,17 +283,24 @@ int expr2(void) case '*': *evalTokenBuffer++ = ACONST; // Attributed const -#if 0 - if (orgactive) - *evalTokenBuffer++ = orgaddr; - else - *evalTokenBuffer++ = pcloc; // Location at start of line -#else // pcloc == location at start of line *evalTokenBuffer++ = (orgactive ? orgaddr : pcloc); -#endif + // '*' takes attributes of current section, not ABS! + *evalTokenBuffer++ = cursect | DEFINED; + break; + case '{': + if (expr0() != OK) // Eat up first parameter (register or immediate) + return ERROR; + + if (*tok++ != ':') // Demand a ':' there + return error("missing colon ':'"); + + if (expr0() != OK) // Eat up second parameter (register or immediate) + return ERROR; + + if (*tok++ != '}') + return error("missing close bracket '}'"); - *evalTokenBuffer++ = ABS | DEFINED; // Store attribs break; default: return error("bad expression"); @@ -315,8 +332,9 @@ int expr(TOKEN * otk, VALUE * a_value, WORD * a_attr, SYM ** a_esym) // followed by the value 101, it will trigger a bad evaluation here. // This is probably a really bad assumption to be making here...! // (assuming tok[1] == EOL is a single token that is) + // Seems that even other tokens (SUNARY type) can fuck this up too. // if ((tok[1] == EOL) - if ((tok[1] == EOL && tok[0] != CONST) + if ((tok[1] == EOL && (tok[0] != CONST && tokenClass[tok[0]] != SUNARY)) || (((*tok == CONST || *tok == SYMBOL) || (*tok >= KW_R0 && *tok <= KW_R31)) && (tokenClass[tok[2]] < UNARY))) { @@ -352,7 +370,8 @@ int expr(TOKEN * otk, VALUE * a_value, WORD * a_attr, SYM ** a_esym) else *evalTokenBuffer++ = *a_value = pcloc; - *a_attr = ABS | DEFINED; + // '*' takes attributes of current section, not ABS! + *a_attr = cursect | DEFINED; if (a_esym != NULL) *a_esym = NULL; @@ -365,7 +384,7 @@ int expr(TOKEN * otk, VALUE * a_value, WORD * a_attr, SYM ** a_esym) j = (*p == '.' ? curenv : 0); symbol = lookup(p, LABEL, j); #if 0 -printf("eval: Looking up symbol [=%08X]\n", symbol); +printf("eval: Looking up symbol (%s) [=%08X]\n", p, symbol); if (symbol) printf(" attr=%04X, attre=%08X, val=%i, name=%s\n", symbol->sattr, symbol->sattre, symbol->svalue, symbol->sname); #endif @@ -375,8 +394,11 @@ if (symbol) symbol->sattr |= REFERENCED; - // Check for undefined register equates - if (symbol->sattre & UNDEF_EQUR) + // Check for undefined register equates, but only if it's not part + // of a # construct, as it could be that the label that's + // been undefined may later be used as an address label--which + // means it will be fixed up later, and thus, not an error. + if ((symbol->sattre & UNDEF_EQUR) && !riscImmTokenSeen) { errors("undefined register equate '%s'", symbol->sname); //if we return right away, it returns some spurious errors... @@ -386,7 +408,7 @@ if (symbol) // Check register bank usage if (symbol->sattre & EQUATEDREG) { - if ((regbank == BANK_0) && (symbol->sattre & BANK_1) && !altbankok) + if ((regbank == BANK_0) && (symbol->sattre & BANK_1) && !altbankok) warns("equated symbol '%s' cannot be used in register bank 0", symbol->sname); if ((regbank == BANK_1) && (symbol->sattre & BANK_0) && !altbankok) @@ -416,19 +438,20 @@ be converted from a linked list into an array). All that extra crap that was put into the svalue when doing the equr stuff is thrown away right here. What the hell is it for? */ - if (symbol->sattre & EQUATEDREG) + if (symbol->sattre & EQUATEDREG) *a_value &= 0x1F; *a_attr = (WORD)(symbol->sattr & ~GLOBAL); - if ((symbol->sattr & (GLOBAL | DEFINED)) == GLOBAL && a_esym != NULL) + if ((symbol->sattr & (GLOBAL | DEFINED)) == GLOBAL + && a_esym != NULL) *a_esym = symbol; tok += 2; } else { - // Unknown type here... Alert the user! + // Unknown type here... Alert the user!, error("undefined RISC register in expression"); // Prevent spurious error reporting... tok++; @@ -455,17 +478,12 @@ thrown away right here. What the hell is it for? // int evexpr(TOKEN * tk, VALUE * a_value, WORD * a_attr, SYM ** a_esym) { - WORD * sattr; - VALUE * sval; WORD attr; SYM * sy; - SYM * esym; - WORD sym_seg; - - sval = evstk; // (Empty) initial stack - sattr = evattr; - esym = NULL; // No external symbol involved - sym_seg = 0; + VALUE * sval = evstk; // (Empty) initial stack + WORD * sattr = evattr; + SYM * esym = NULL; // No external symbol involved + WORD sym_seg = 0; while (*tk != ENDEXPR) { @@ -474,7 +492,7 @@ int evexpr(TOKEN * tk, VALUE * a_value, WORD * a_attr, SYM ** a_esym) case SYMBOL: //printf("evexpr(): SYMBOL\n"); sy = symbolPtr[*tk++]; - sy->sattr |= REFERENCED; // Set "referenced" bit + sy->sattr |= REFERENCED; // Set "referenced" bit if (!(sy->sattr & DEFINED)) { @@ -498,11 +516,11 @@ int evexpr(TOKEN * tk, VALUE * a_value, WORD * a_attr, SYM ** a_esym) } else { - *++sval = 0; // 0 for undefined symbols + *++sval = 0; // 0 for undefined symbols } *++sattr = (WORD)(sy->sattr & ~GLOBAL); // Push attribs - sym_seg = (WORD)(sy->sattr & (TEXT | DATA | BSS)); + sym_seg = (WORD)(sy->sattr & TDB); break; case CONST: //printf("evexpr(): CONST = %i\n", *tk); @@ -516,51 +534,54 @@ int evexpr(TOKEN * tk, VALUE * a_value, WORD * a_attr, SYM ** a_esym) break; // Binary "+" and "-" matrix: - // + // // ABS Sect Other // ---------------------------- // ABS | ABS | Sect | Other | // Sect | Sect | [1] | Error | // Other | Other | Error | [1] | // ---------------------------- - // + // // [1] + : Error // - : ABS case '+': //printf("evexpr(): +\n"); --sval; // Pop value - --sattr; // Pop attrib + --sattr; // Pop attrib +//printf("--> N+N: %i + %i = ", *sval, sval[1]); *sval += sval[1]; // Compute value +//printf("%i\n", *sval); - if (!(*sattr & (TEXT | DATA | BSS))) + if (!(*sattr & TDB)) *sattr = sattr[1]; - else if (sattr[1] & (TEXT | DATA | BSS)) + else if (sattr[1] & TDB) return error(seg_error); break; case '-': //printf("evexpr(): -\n"); --sval; // Pop value - --sattr; // Pop attrib + --sattr; // Pop attrib +//printf("--> N-N: %i - %i = ", *sval, sval[1]); *sval -= sval[1]; // Compute value +//printf("%i\n", *sval); - attr = (WORD)(*sattr & (TEXT | DATA | BSS)); - + attr = (WORD)(*sattr & TDB); +#if 0 +printf("EVEXPR (-): sym1 = %X, sym2 = %X\n", attr, sattr[1]); +#endif + // If symbol1 is ABS, take attributes from symbol2 if (!attr) *sattr = sattr[1]; - else if (sattr[1] & (TEXT | DATA | BSS)) - { - if (!(attr & sattr[1])) - return error(seg_error); - else - *sattr &= ~(TEXT | DATA | BSS); - } + // Otherwise, they're both TDB and so attributes cancel out + else if (sattr[1] & TDB) + *sattr &= ~TDB; break; // Unary operators only work on ABS items case UNMINUS: //printf("evexpr(): UNMINUS\n"); - if (*sattr & (TEXT | DATA | BSS)) + if (*sattr & TDB) error(seg_error); *sval = -(int)*sval; @@ -568,7 +589,7 @@ int evexpr(TOKEN * tk, VALUE * a_value, WORD * a_attr, SYM ** a_esym) break; case '!': //printf("evexpr(): !\n"); - if (*sattr & (TEXT | DATA | BSS)) + if (*sattr & TDB) error(seg_error); *sval = !*sval; @@ -576,7 +597,7 @@ int evexpr(TOKEN * tk, VALUE * a_value, WORD * a_attr, SYM ** a_esym) break; case '~': //printf("evexpr(): ~\n"); - if (*sattr & (TEXT | DATA | BSS)) + if (*sattr & TDB) error(seg_error); *sval = ~*sval; @@ -586,8 +607,8 @@ int evexpr(TOKEN * tk, VALUE * a_value, WORD * a_attr, SYM ** a_esym) // are in the same segment, but that's the only requirement. case LE: //printf("evexpr(): LE\n"); - --sattr; - --sval; + sattr--; + sval--; if ((*sattr & TDB) != (sattr[1] & TDB)) error(seg_error); @@ -597,8 +618,8 @@ int evexpr(TOKEN * tk, VALUE * a_value, WORD * a_attr, SYM ** a_esym) break; case GE: //printf("evexpr(): GE\n"); - --sattr; - --sval; + sattr--; + sval--; if ((*sattr & TDB) != (sattr[1] & TDB)) error(seg_error); @@ -608,8 +629,8 @@ int evexpr(TOKEN * tk, VALUE * a_value, WORD * a_attr, SYM ** a_esym) break; case '>': //printf("evexpr(): >\n"); - --sattr; - --sval; + sattr--; + sval--; if ((*sattr & TDB) != (sattr[1] & TDB)) error(seg_error); @@ -619,8 +640,8 @@ int evexpr(TOKEN * tk, VALUE * a_value, WORD * a_attr, SYM ** a_esym) break; case '<': //printf("evexpr(): <\n"); - --sattr; - --sval; + sattr--; + sval--; if ((*sattr & TDB) != (sattr[1] & TDB)) error(seg_error); @@ -630,8 +651,8 @@ int evexpr(TOKEN * tk, VALUE * a_value, WORD * a_attr, SYM ** a_esym) break; case NE: //printf("evexpr(): NE\n"); - --sattr; - --sval; + sattr--; + sval--; if ((*sattr & TDB) != (sattr[1] & TDB)) error(seg_error); @@ -641,8 +662,8 @@ int evexpr(TOKEN * tk, VALUE * a_value, WORD * a_attr, SYM ** a_esym) break; case '=': //printf("evexpr(): =\n"); - --sattr; - --sval; + sattr--; + sval--; if ((*sattr & TDB) != (sattr[1] & TDB)) error(seg_error); @@ -662,22 +683,30 @@ int evexpr(TOKEN * tk, VALUE * a_value, WORD * a_attr, SYM ** a_esym) switch ((int)tk[-1]) { case '*': - --sval; - --sattr; // Pop attrib + sval--; + sattr--; // Pop attrib +//printf("--> NxN: %i x %i = ", *sval, sval[1]); *sval *= sval[1]; +//printf("%i\n", *sval); break; case '/': - --sval; - --sattr; // Pop attrib + sval--; + sattr--; // Pop attrib if (sval[1] == 0) return error("divide by zero"); - *sval /= sval[1]; +//printf("--> N/N: %i / %i = ", sval[0], sval[1]); + // Compiler is picky here: Without casting these, it discards + // the sign if dividing a negative # by a positive one, + // creating a bad result. :-/ + // Probably a side effect of using VALUE intead of ints. + *sval = (int)sval[0] / (int)sval[1]; +//printf("%i\n", *sval); break; case '%': - --sval; - --sattr; // Pop attrib + sval--; + sattr--; // Pop attrib if (sval[1] == 0) return error("mod (%) by zero"); @@ -685,28 +714,28 @@ int evexpr(TOKEN * tk, VALUE * a_value, WORD * a_attr, SYM ** a_esym) *sval %= sval[1]; break; case SHL: - --sval; - --sattr; // Pop attrib + sval--; + sattr--; // Pop attrib *sval <<= sval[1]; break; case SHR: - --sval; - --sattr; // Pop attrib + sval--; + sattr--; // Pop attrib *sval >>= sval[1]; break; case '&': - --sval; - --sattr; // Pop attrib + sval--; + sattr--; // Pop attrib *sval &= sval[1]; break; case '^': - --sval; - --sattr; // Pop attrib + sval--; + sattr--; // Pop attrib *sval ^= sval[1]; break; case '|': - --sval; - --sattr; // Pop attrib + sval--; + sattr--; // Pop attrib *sval |= sval[1]; break; default: @@ -724,10 +753,11 @@ int evexpr(TOKEN * tk, VALUE * a_value, WORD * a_attr, SYM ** a_esym) // sym_seg added in 1.0.16 to solve a problem with forward symbols in // expressions where absolute values also existed. The absolutes were // overiding the symbol segments and not being included :( - //*a_attr = *sattr | sym_seg; // Copy value + attrib + //*a_attr = *sattr | sym_seg; // Copy value + attrib *a_attr = *sattr; // Copy value + attrib *a_value = *sval; return OK; } +