Shamusworld >> Repos - rmac/blob - expr.c

   1 //
   2 // RMAC - Reboot's Macro Assembler for the Atari Jaguar Console System
   3 // EXPR.C - Expression Analyzer
   4 // Copyright (C) 199x Landon Dyer, 2011 Reboot and Friends
   5 // RMAC derived from MADMAC v1.07 Written by Landon Dyer, 1986
   6 // Source Utilised with the Kind Permission of Landon Dyer
   7 //
   8
   9 #include "expr.h"
  10 #include "token.h"
  11 #include "listing.h"
  12 #include "error.h"
  13 #include "procln.h"
  14 #include "symbol.h"
  15 #include "sect.h"
  16 #include "mach.h"
  17 #include "risca.h"
  18
  19 #define DEF_KW                                              // Declare keyword values
  20 #include "kwtab.h"                                          // Incl generated keyword tables & defs
  21
  22 static char tokcl[128];                                     // Generated table of token classes
  23 static VALUE evstk[EVSTACKSIZE];                            // Evaluator value stack
  24 static WORD evattr[EVSTACKSIZE];                            // Evaluator attribute stack
  25
  26 // Token-class initialization list
  27 char itokcl[] = {
  28    0,                                                       // END
  29    CONST, SYMBOL, 0,                                        // ID
  30    '(', '[', '{', 0,                                        // OPAR
  31    ')', ']', '}', 0,                                        // CPAR
  32    CR_DEFINED, CR_REFERENCED,                                 // SUNARY (special unary)
  33    CR_STREQ, CR_MACDEF,
  34    CR_DATE, CR_TIME, 0,
  35    '!', '~', UNMINUS, 0,                                    // UNARY
  36    '*', '/', '%', 0,                                        // MULT
  37    '+', '-', 0,                                             // ADD
  38    SHL, SHR, 0,                                             // SHIFT
  39    LE, GE, '<', '>', NE, '=', 0,                            // REL
  40    '&', 0,                                                  // AND
  41    '^', 0,                                                  // XOR
  42    '|', 0,                                                  // OR
  43    1                                                        // (the end)
  44 };
  45
  46 char missym_error[] = "missing symbol";
  47 char *str_error = "missing symbol or string";
  48
  49 // Convert expression to postfix
  50 static TOKEN *tk;                                           // Deposit tokens here
  51 SYM *lookup();
  52 SYM *newsym();
  53
  54 //
  55 // --- Obtain a String Value -----------------------------------------------------------------------
  56 //
  57
  58 static VALUE str_value(char *p) {
  59    VALUE v;
  60
  61    for(v = 0; *p; ++p)
  62       v = (v << 8) | (*p & 0xff);
  63    return(v);
  64 }
  65
  66 //
  67 // --- Initialize Expression Analyzer --------------------------------------------------------------
  68 //
  69
  70 void init_expr(void) {
  71    int i;                                                   // Iterator
  72    char *p;                                                 // Token pointer
  73
  74    // Initialize token-class table
  75    for(i = 0; i < 128; ++i)                                 // Mark all entries END
  76       tokcl[i] = END;
  77
  78    for(i = 0, p = itokcl; *p != 1; ++p)
  79       if(*p == 0)
  80          ++i;
  81       else
  82          tokcl[(int)(*p)] = (char)i;
  83 }
  84
  85 //
  86 // --- Binary operators (all the same precedence) --------------------------------------------------
  87 //
  88
  89 int expr0(void) {
  90    TOKEN t;
  91
  92    if(expr1() != OK)
  93       return(ERROR);
  94    while(tokcl[*tok] >= MULT) {
  95       t = *tok++;
  96       if(expr1() != OK)
  97          return(ERROR);
  98       *tk++ = t;
  99    }
 100    return(OK);
 101 }
 102
 103 //
 104 // --- Unary operators (detect unary '-') ----------------------------------------------------------
 105 //
 106
 107 int expr1(void) {
 108    int class;
 109    TOKEN t;
 110    SYM *sy;
 111    char *p, *p2;
 112    WORD w;
 113    int j;
 114
 115    class = tokcl[*tok];
 116
 117    if(*tok == '-' || class == UNARY) {
 118       t = *tok++;
 119       if(expr2() != OK)
 120          return(ERROR);
 121       if(t == '-')
 122          t = UNMINUS;
 123       *tk++ = t;
 124    } else if(class == SUNARY)
 125       switch((int)*tok++) {
 126          case CR_TIME:
 127             *tk++ = CONST;
 128             *tk++ = dos_time();
 129             break;
 130          case CR_DATE:
 131             *tk++ = CONST;
 132             *tk++ = dos_date();
 133             break;
 134          case CR_MACDEF:                                    // ^^macdef <macro-name>
 135             if(*tok++ != SYMBOL) return(error(missym_error));
 136             p = (char *)*tok++;
 137             if(lookup(p, MACRO, 0) == NULL) w = 0;
 138             else w = 1;
 139
 140             *tk++ = CONST;
 141             *tk++ = (TOKEN)w;
 142             break;
 143          case CR_DEFINED:
 144             w = DEFINED;
 145             goto getsym;
 146          case CR_REFERENCED:
 147             w = REFERENCED;
 148
 149             getsym:
 150
 151             if(*tok++ != SYMBOL) return(error(missym_error));
 152             p = (char *)*tok++;
 153             j = 0;
 154             if(*p == '.') j = curenv;
 155             if((sy = lookup(p, LABEL, j)) != NULL && (sy->sattr & w)) w = 1;
 156             else w = 0;
 157
 158             *tk++ = CONST;
 159             *tk++ = (TOKEN)w;
 160             break;
 161          case CR_STREQ:
 162             if(*tok != SYMBOL && *tok != STRING) return(error(str_error));
 163             p = (char *)tok[1];
 164             tok +=2;
 165
 166             if(*tok++ != ',') return(error(comma_error));
 167
 168             if(*tok != SYMBOL && *tok != STRING) return(error(str_error));
 169             p2 = (char *)tok[1];
 170             tok += 2;
 171
 172             w = (WORD)(!strcmp(p, p2));
 173             *tk++ = CONST;
 174             *tk++ = (TOKEN)w;
 175             break;
 176       }
 177         else
 178       return(expr2());
 179
 180    return(OK);
 181 }
 182
 183 //
 184 // --- Terminals (CONSTs) and parenthesis grouping -------------------------------------------------
 185 //
 186
 187 int expr2(void) {
 188    char *p;
 189    SYM *sy;
 190    int j;
 191
 192    switch((int)*tok++) {
 193       case CONST:
 194          *tk++ = CONST;
 195          *tk++ = *tok++;
 196          break;
 197       case SYMBOL:
 198          p = (char *)*tok++;
 199          j = 0;
 200          if(*p == '.')
 201             j = curenv;
 202          sy = lookup(p, LABEL, j);
 203          if(sy == NULL)
 204             sy = newsym(p, LABEL, j);
 205
 206          if(sy->sattre & EQUATEDREG) {                      // Check register bank usage
 207             if((regbank == BANK_0) && (sy->sattre & BANK_1) && !altbankok)
 208                warns("equated symbol \'%s\' cannot be used in register bank 0", sy->sname);
 209             if((regbank == BANK_1) && (sy->sattre & BANK_0) && !altbankok)
 210                warns("equated symbol \'%s\' cannot be used in register bank 1", sy->sname);
 211          }
 212
 213          *tk++ = SYMBOL;
 214          *tk++ = (TOKEN)sy;
 215          break;
 216       case STRING:
 217          *tk++ = CONST;
 218          *tk++ = str_value((char *)*tok++);
 219          break;
 220       case '(':
 221          if(expr0() != OK)
 222             return(ERROR);
 223          if(*tok++ != ')')
 224             return(error("missing close parenthesis ')'"));
 225          break;
 226       case '[':
 227          if(expr0() != OK)
 228             return(ERROR);
 229          if(*tok++ != ']')
 230             return(error("missing close parenthesis ']'"));
 231          break;
 232       case '$':
 233          *tk++ = ACONST;                                    // Attributed const
 234          *tk++ = sloc;                                      // Current location
 235          *tk++ = cursect | DEFINED;                         // Store attribs
 236          break;
 237       case '*':
 238          *tk++ = ACONST;                                    // Attributed const
 239          if(orgactive)
 240             *tk++ = orgaddr;
 241          else
 242             *tk++ = pcloc;                                  // Location at start of line
 243          *tk++ = ABS | DEFINED;                             // Store attribs
 244          break;
 245       default:
 246          return(error("bad expression"));
 247    }
 248    return(OK);
 249 }
 250
 251 //
 252 // --- Recursive-descent expression analyzer (with some simple speed hacks) ------------------------
 253 //
 254
 255 int expr(TOKEN *otk, VALUE *a_value, WORD *a_attr, SYM **a_esym) {
 256    SYM *sy;
 257    char *p;
 258    int j;
 259
 260    tk = otk;
 261
 262    // Optimize for single constant or single symbol.
 263    if((tok[1] == EOL) ||
 264       (((*tok == CONST || *tok == SYMBOL) || (*tok >= KW_R0 && *tok <= KW_R31)) &&
 265        (tokcl[tok[2]] < UNARY))) {
 266
 267       if(*tok >= KW_R0 && *tok <= KW_R31) {
 268          *tk++ = CONST;
 269          *tk++ = *a_value = (*tok - KW_R0);
 270          *a_attr = ABS | DEFINED;
 271          if(a_esym != NULL)
 272             *a_esym = NULL;
 273          tok++;
 274          *tk++ = ENDEXPR;
 275          return(OK);
 276       } else if(*tok == CONST) {
 277          *tk++ = CONST;
 278          *tk++ = *a_value = tok[1];
 279          *a_attr = ABS | DEFINED;
 280          if(a_esym != NULL)
 281             *a_esym = NULL;
 282       } else if(*tok == '*') {
 283          *tk++ = CONST;
 284          if(orgactive)
 285             *tk++ = *a_value = orgaddr;
 286          else
 287             *tk++ = *a_value = pcloc;
 288          *a_attr = ABS | DEFINED;
 289          //*tk++ =
 290          if(a_esym != NULL)
 291             *a_esym = NULL;
 292          tok--;
 293       } else {
 294          p = (char *)tok[1];
 295          j = 0;
 296          if(*p == '.')
 297             j = curenv;
 298          sy = lookup(p, LABEL, j);
 299
 300          if(sy == NULL)
 301             sy = newsym(p, LABEL, j);
 302          sy->sattr |= REFERENCED;
 303
 304          if(sy->sattre & EQUATEDREG) {                      // Check register bank usage
 305             if((regbank == BANK_0) && (sy->sattre & BANK_1) && !altbankok)
 306                warns("equated symbol \'%s\' cannot be used in register bank 0", sy->sname);
 307             if((regbank == BANK_1) && (sy->sattre & BANK_0) && !altbankok)
 308                warns("equated symbol \'%s\' cannot be used in register bank 1", sy->sname);
 309          }
 310
 311          *tk++ = SYMBOL;
 312          *tk++ = (TOKEN)sy;
 313
 314          if(sy->sattr & DEFINED)
 315             *a_value = sy->svalue;
 316          else *a_value = 0;
 317
 318          if(sy->sattre & EQUATEDREG)
 319             *a_value &= 0x1F;
 320
 321          *a_attr = (WORD)(sy->sattr & ~GLOBAL);
 322
 323          if((sy->sattr & (GLOBAL|DEFINED)) == GLOBAL && a_esym != NULL) {
 324             *a_esym = sy;
 325          }
 326       }
 327       tok += 2;
 328       *tk++ = ENDEXPR;
 329       return(OK);
 330    }
 331
 332    if(expr0() != OK)
 333       return(ERROR);
 334    *tk++ = ENDEXPR;
 335    return(evexpr(otk, a_value, a_attr, a_esym));
 336 }
 337
 338 //
 339 // -------------------------------------------------------------------------------------------------
 340 // Evaluate expression.
 341 // If the expression involves only ONE external symbol, the expression is UNDEFINED, but it's value
 342 // includes everything but the symbol value, and `a_esym' is set to the external symbol.
 343 // -------------------------------------------------------------------------------------------------
 344 //
 345
 346 int evexpr(TOKEN *tk, VALUE *a_value, WORD *a_attr, SYM **a_esym) {
 347    WORD *sattr;
 348    VALUE *sval;
 349    WORD attr;
 350    SYM *sy;
 351    SYM *esym;
 352    WORD sym_seg;
 353
 354    sval = evstk;                                            // (Empty) initial stack
 355    sattr = evattr;
 356    esym = NULL;                                             // No external symbol involved
 357    sym_seg = 0;
 358
 359    while(*tk != ENDEXPR)
 360       switch((int)*tk++) {
 361          case SYMBOL:
 362             sy = (SYM *)*tk++;
 363             sy->sattr |= REFERENCED;                        // Set "referenced" bit
 364
 365             if(!(sy->sattr & DEFINED)) {
 366                if(!(sy->sattr & GLOBAL)) {                  // Reference to undefined symbol
 367                   *a_attr = 0;
 368                   *a_value = 0;
 369                   return(OK);
 370                }
 371                if(esym != NULL)                             // Check for multiple externals
 372                   return(error(seg_error));
 373                esym = sy;
 374             }
 375
 376             if(sy->sattr & DEFINED) {
 377                *++sval = sy->svalue;                        // Push symbol's value
 378             } else {
 379                *++sval = 0;                               // 0 for undefined symbols
 380             }
 381
 382             *++sattr = (WORD)(sy->sattr & ~GLOBAL);         // Push attribs
 383             sym_seg = (WORD)(sy->sattr & (TEXT|DATA|BSS));
 384             break;
 385          case CONST:
 386             *++sval = *tk++;                                // Push value
 387             *++sattr = ABS|DEFINED;                         // Push simple attribs
 388             break;
 389          case ACONST:
 390             *++sval = *tk++;                                // Push value
 391             *++sattr = (WORD)*tk++;                         // Push attribs
 392             break;
 393
 394             // Binary "+" and "-" matrix:
 395             //
 396             //            ABS    Sect     Other
 397             //     ----------------------------
 398             //   ABS     |      ABS   |  Sect  |  Other |
 399             //   Sect    |      Sect  |  [1]   |  Error |
 400             //   Other   |      Other |  Error |  [1]   |
 401             //      ----------------------------
 402             //
 403             //   [1] + : Error
 404             //       - : ABS
 405          case '+':
 406             --sval;                                         // Pop value
 407             --sattr;                                        // Pop attrib
 408             *sval += sval[1];                               // Compute value
 409
 410             if(!(*sattr & (TEXT|DATA|BSS)))
 411                *sattr = sattr[1];
 412             else if(sattr[1] & (TEXT|DATA|BSS))
 413                return(error(seg_error));
 414             break;
 415          case '-':
 416             --sval;                                         // Pop value
 417             --sattr;                                        // Pop attrib
 418             *sval -= sval[1];                               // Compute value
 419
 420             attr = (WORD)(*sattr & (TEXT|DATA|BSS));
 421             if(!attr)
 422                *sattr = sattr[1];
 423             else if(sattr[1] & (TEXT|DATA|BSS)) {
 424                if(!(attr & sattr[1])) {
 425                   return(error(seg_error));
 426                } else {
 427                   *sattr &= ~(TEXT|DATA|BSS);
 428                }
 429             }
 430             break;
 431             // Unary operators only work on ABS items
 432          case UNMINUS:
 433             if(*sattr & (TEXT|DATA|BSS))
 434                error(seg_error);
 435             *sval = -(int)*sval;
 436             *sattr = ABS|DEFINED;                           // Expr becomes absolute
 437             break;
 438          case '!':
 439             if(*sattr & (TEXT|DATA|BSS))
 440                error(seg_error);
 441             *sval = !*sval;
 442             *sattr = ABS|DEFINED;                           // Expr becomes absolute
 443             break;
 444          case '~':
 445             if(*sattr & (TEXT|DATA|BSS))
 446                error(seg_error);
 447             *sval = ~*sval;
 448             *sattr = ABS|DEFINED;                           // Expr becomes absolute
 449             break;
 450             // Comparison operators must have two values that
 451             // are in the same segment, but that's the only requirement.
 452          case LE:
 453             --sattr;
 454             --sval;
 455             if((*sattr & TDB) != (sattr[1] & TDB)) error(seg_error);
 456             *sattr = ABS|DEFINED;
 457             *sval = *sval <= sval[1];
 458             break;
 459          case GE:
 460             --sattr;
 461             --sval;
 462             if((*sattr & TDB) != (sattr[1] & TDB)) error(seg_error);
 463             *sattr = ABS|DEFINED;
 464             *sval = *sval >= sval[1];
 465             break;
 466          case '>':
 467             --sattr;
 468             --sval;
 469             if((*sattr & TDB) != (sattr[1] & TDB)) error(seg_error);
 470             *sattr = ABS|DEFINED;
 471             *sval = *sval > sval[1];
 472             break;
 473          case '<':
 474             --sattr;
 475             --sval;
 476             if((*sattr & TDB) != (sattr[1] & TDB)) error(seg_error);
 477             *sattr = ABS|DEFINED;
 478             *sval = *sval < sval[1];
 479             break;
 480          case NE:
 481             --sattr;
 482             --sval;
 483             if((*sattr & TDB) != (sattr[1] & TDB)) error(seg_error);
 484             *sattr = ABS|DEFINED;
 485             *sval = *sval != sval[1];
 486             break;
 487          case '=':
 488             --sattr;
 489             --sval;
 490             if((*sattr & TDB) != (sattr[1] & TDB)) error(seg_error);
 491             *sattr = ABS|DEFINED;
 492             *sval = *sval == sval[1];
 493             break;
 494             // All other binary operators must have two ABS items
 495             // to work with.  They all produce an ABS value.
 496          default:
 497             // GH - Removed for v1.0.15 as part of the fix for indexed loads.
 498             //if((*sattr & (TEXT|DATA|BSS)) || (*--sattr & (TEXT|DATA|BSS)))
 499                //error(seg_error);
 500
 501             *sattr = ABS|DEFINED;                           // Expr becomes absolute
 502             switch((int)tk[-1]) {
 503                case '*':
 504                   --sval;
 505                   --sattr;                                        // Pop attrib
 506                   *sval *= sval[1];
 507                   break;
 508                case '/':
 509                   --sval;
 510                   --sattr;                                        // Pop attrib
 511                   if(sval[1] == 0)
 512                      return(error("divide by zero"));
 513                   *sval /= sval[1];
 514                   break;
 515                case '%':
 516                   --sval;
 517                   --sattr;                                        // Pop attrib
 518                   if(sval[1] == 0)
 519                      return(error("mod (%) by zero"));
 520                   *sval %= sval[1];
 521                   break;
 522                case SHL:
 523                   --sval;
 524                   --sattr;                                        // Pop attrib
 525                   *sval <<= sval[1];
 526                   break;
 527                case SHR:
 528                   --sval;
 529                   --sattr;                                        // Pop attrib
 530                   *sval >>= sval[1];
 531                   break;
 532                case '&':
 533                   --sval;
 534                   --sattr;                                        // Pop attrib
 535                   *sval &= sval[1];
 536                   break;
 537                case '^':
 538                   --sval;
 539                   --sattr;                                        // Pop attrib
 540                   *sval ^= sval[1];
 541                   break;
 542                case '|':
 543                   --sval;
 544                   --sattr;                                        // Pop attrib
 545                   *sval |= sval[1];
 546                   break;
 547                default:
 548                   interror(5);                              // Bad operator in expression stream
 549             }
 550       }
 551
 552    if(esym != NULL) *sattr &= ~DEFINED;
 553    if(a_esym != NULL) *a_esym = esym;
 554
 555    // sym_seg added in 1.0.16 to solve a problem with forward symbols in expressions where absolute
 556    // values also existed. The absolutes were overiding the symbol segments and not being included :(
 557    //*a_attr = *sattr | sym_seg;                                        // Copy value + attrib
 558
 559    *a_attr = *sattr;                                        // Copy value + attrib
 560    *a_value = *sval;
 561
 562         return(OK);
 563 }
 564
 565