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 "direct.h"
  11 #include "error.h"
  12 #include "listing.h"
  13 #include "mach.h"
  14 #include "procln.h"
  15 #include "riscasm.h"
  16 #include "sect.h"
  17 #include "symbol.h"
  18 #include "token.h"
  19
  20 #define DEF_KW                                                  // Declare keyword values
  21 #include "kwtab.h"                                              // Incl generated keyword tables & defs
  22
  23 static char tokenClass[128];                                    // Generated table of token classes
  24 static VALUE evstk[EVSTACKSIZE];                // Evaluator value stack
  25 static WORD evattr[EVSTACKSIZE];                // Evaluator attribute stack
  26
  27 // Token-class initialization list
  28 char itokcl[] = {
  29         0,                                                                      // END
  30         CONST, SYMBOL, 0,                                       // ID
  31         '(', '[', '{', 0,                                       // OPAR
  32         ')', ']', '}', 0,                                       // CPAR
  33         CR_DEFINED, CR_REFERENCED,                      // SUNARY (special unary)
  34         CR_STREQ, CR_MACDEF,
  35         CR_DATE, CR_TIME, 0,
  36         '!', '~', UNMINUS, 0,                           // UNARY
  37         '*', '/', '%', 0,                                       // MULT
  38         '+', '-', 0,                                            // ADD
  39         SHL, SHR, 0,                                            // SHIFT
  40         LE, GE, '<', '>', NE, '=', 0,           // REL
  41         '&', 0,                                                         // AND
  42         '^', 0,                                                         // XOR
  43         '|', 0,                                                         // OR
  44         1                                                                       // (the end)
  45 };
  46
  47 const char missym_error[] = "missing symbol";
  48 const char str_error[] = "missing symbol or string";
  49
  50 // Convert expression to postfix
  51 static TOKEN * evalTokenBuffer;                 // Deposit tokens here (this is really a
  52                                                                                 // pointer to exprbuf from direct.c)
  53                                                                                 // (Can also be from others, like riscasm.c)
  54 static symbolNum;                                               // Pointer to the entry in symbolPtr[]
  55
  56
  57 //
  58 // Obtain a String Value
  59 //
  60 static VALUE str_value(char * p)
  61 {
  62         VALUE v;
  63
  64         for(v=0; *p; p++)
  65                 v = (v << 8) | (*p & 0xFF);
  66
  67         return v;
  68 }
  69
  70
  71 //
  72 // Initialize Expression Analyzer
  73 //
  74 void InitExpression(void)
  75 {
  76         int i;                                                                  // Iterator
  77         char * p;                                                               // Token pointer
  78
  79         // Initialize token-class table (all set to END)
  80         for(i=0; i<128; i++)
  81                 tokenClass[i] = END;
  82
  83         for(i=0, p=itokcl; *p!=1; p++)
  84         {
  85                 if (*p == 0)
  86                         i++;
  87                 else
  88                         tokenClass[(int)(*p)] = (char)i;
  89         }
  90
  91         symbolNum = 0;
  92 }
  93
  94
  95 //
  96 // Binary operators (all the same precedence)
  97 //
  98 int expr0(void)
  99 {
 100         TOKEN t;
 101
 102         if (expr1() != OK)
 103                 return ERROR;
 104
 105         while (tokenClass[*tok] >= MULT)
 106         {
 107                 t = *tok++;
 108
 109                 if (expr1() != OK)
 110                         return ERROR;
 111
 112                 *evalTokenBuffer++ = t;
 113         }
 114
 115         return OK;
 116 }
 117
 118
 119 //
 120 // Unary operators (detect unary '-')
 121 //
 122 int expr1(void)
 123 {
 124         int class;
 125         TOKEN t;
 126         SYM * sy;
 127         char * p, * p2;
 128         WORD w;
 129         int j;
 130
 131         class = tokenClass[*tok];
 132
 133         if (*tok == '-' || class == UNARY)
 134         {
 135                 t = *tok++;
 136
 137                 if (expr2() != OK)
 138                         return ERROR;
 139
 140                 if (t == '-')
 141                         t = UNMINUS;
 142
 143                 *evalTokenBuffer++ = t;
 144         }
 145         else if (class == SUNARY)
 146         {
 147                 switch ((int)*tok++)
 148                 {
 149                 case CR_TIME:
 150                         *evalTokenBuffer++ = CONST;
 151                         *evalTokenBuffer++ = dos_time();
 152                         break;
 153                 case CR_DATE:
 154                         *evalTokenBuffer++ = CONST;
 155                         *evalTokenBuffer++ = dos_date();
 156                         break;
 157                 case CR_MACDEF:                                    // ^^macdef <macro-name>
 158                         if (*tok++ != SYMBOL)
 159                                 return error(missym_error);
 160
 161                         p = string[*tok++];
 162                         w = (lookup(p, MACRO, 0) == NULL ? 0 : 1);
 163                         *evalTokenBuffer++ = CONST;
 164                         *evalTokenBuffer++ = (TOKEN)w;
 165                         break;
 166                 case CR_DEFINED:
 167                         w = DEFINED;
 168                         goto getsym;
 169                 case CR_REFERENCED:
 170                         w = REFERENCED;
 171 getsym:
 172                         if (*tok++ != SYMBOL)
 173                                 return error(missym_error);
 174
 175                         p = string[*tok++];
 176                         j = (*p == '.' ? curenv : 0);
 177                         w = ((sy = lookup(p, LABEL, j)) != NULL && (sy->sattr & w) ? 1 : 0);
 178                         *evalTokenBuffer++ = CONST;
 179                         *evalTokenBuffer++ = (TOKEN)w;
 180                         break;
 181                 case CR_STREQ:
 182                         if (*tok != SYMBOL && *tok != STRING)
 183                                 return error(str_error);
 184
 185                         p = string[tok[1]];
 186                         tok +=2;
 187
 188                         if (*tok++ != ',')
 189                                 return error(comma_error);
 190
 191                         if (*tok != SYMBOL && *tok != STRING)
 192                                 return error(str_error);
 193
 194                         p = string[tok[1]];
 195                         tok += 2;
 196
 197                         w = (WORD)(!strcmp(p, p2));
 198                         *evalTokenBuffer++ = CONST;
 199                         *evalTokenBuffer++ = (TOKEN)w;
 200                         break;
 201                 }
 202         }
 203         else
 204                 return expr2();
 205
 206         return OK;
 207 }
 208
 209
 210 //
 211 // Terminals (CONSTs) and parenthesis grouping
 212 //
 213 int expr2(void)
 214 {
 215         char * p;
 216         SYM * sy;
 217         int j;
 218
 219         switch ((int)*tok++)
 220         {
 221         case CONST:
 222                 *evalTokenBuffer++ = CONST;
 223                 *evalTokenBuffer++ = *tok++;
 224                 break;
 225         case SYMBOL:
 226                 p = string[*tok++];
 227                 j = (*p == '.' ? curenv : 0);
 228                 sy = lookup(p, LABEL, j);
 229
 230                 if (sy == NULL)
 231                         sy = NewSymbol(p, LABEL, j);
 232
 233                 // Check register bank usage
 234                 if (sy->sattre & EQUATEDREG)
 235                 {
 236                         if ((regbank == BANK_0) && (sy->sattre & BANK_1) && !altbankok)
 237                                 warns("equated symbol \'%s\' cannot be used in register bank 0", sy->sname);
 238
 239                         if ((regbank == BANK_1) && (sy->sattre & BANK_0) && !altbankok)
 240                                 warns("equated symbol \'%s\' cannot be used in register bank 1", sy->sname);
 241                 }
 242
 243                 *evalTokenBuffer++ = SYMBOL;
 244 #if 0
 245                 *evalTokenBuffer++ = (TOKEN)sy;
 246 #else
 247                 *evalTokenBuffer++ = symbolNum;
 248                 symbolPtr[symbolNum] = sy;
 249                 symbolNum++;
 250 #endif
 251                 break;
 252         case STRING:
 253                 *evalTokenBuffer++ = CONST;
 254                 *evalTokenBuffer++ = str_value(string[*tok++]);
 255                 break;
 256         case '(':
 257                 if (expr0() != OK)
 258                         return ERROR;
 259
 260                 if (*tok++ != ')')
 261                         return error("missing close parenthesis ')'");
 262
 263                 break;
 264         case '[':
 265                 if (expr0() != OK)
 266                         return ERROR;
 267
 268                 if (*tok++ != ']')
 269                         return error("missing close parenthesis ']'");
 270
 271                 break;
 272         case '$':
 273                 *evalTokenBuffer++ = ACONST;                            // Attributed const
 274                 *evalTokenBuffer++ = sloc;                                      // Current location
 275                 *evalTokenBuffer++ = cursect | DEFINED;         // Store attribs
 276                 break;
 277         case '*':
 278                 *evalTokenBuffer++ = ACONST;                            // Attributed const
 279
 280                 if (orgactive)
 281                         *evalTokenBuffer++ = orgaddr;
 282                 else
 283                         *evalTokenBuffer++ = pcloc;                             // Location at start of line
 284
 285                 *evalTokenBuffer++ = ABS | DEFINED;                     // Store attribs
 286                 break;
 287         default:
 288                 return error("bad expression");
 289         }
 290
 291         return OK;
 292 }
 293
 294
 295 //
 296 // Recursive-descent expression analyzer (with some simple speed hacks)
 297 //
 298 int expr(TOKEN * otk, VALUE * a_value, WORD * a_attr, SYM ** a_esym)
 299 {
 300         // Passed in values (once derefenced, that is) can all be zero. They are
 301         // there so that the expression analyzer can fill them in as needed. The
 302         // expression analyzer gets its input from the global token pointer "tok",
 303         // and not from anything passed in by the user.
 304         SYM * symbol;
 305         char * p;
 306         int j;
 307
 308         evalTokenBuffer = otk;  // Set token pointer to 'exprbuf' (direct.c)
 309                                                         // Also set in various other places too (riscasm.c, e.g.)
 310
 311         // Optimize for single constant or single symbol.
 312         if ((tok[1] == EOL)
 313                 || (((*tok == CONST || *tok == SYMBOL) || (*tok >= KW_R0 && *tok <= KW_R31))
 314                 && (tokenClass[tok[2]] < UNARY)))
 315         {
 316                 if (*tok >= KW_R0 && *tok <= KW_R31)
 317                 {
 318                         *evalTokenBuffer++ = CONST;
 319                         *evalTokenBuffer++ = *a_value = (*tok - KW_R0);
 320                         *a_attr = ABS | DEFINED;
 321
 322                         if (a_esym != NULL)
 323                                 *a_esym = NULL;
 324
 325                         tok++;
 326                         *evalTokenBuffer++ = ENDEXPR;
 327                         return OK;
 328                 }
 329                 else if (*tok == CONST)
 330                 {
 331                         *evalTokenBuffer++ = CONST;
 332                         *evalTokenBuffer++ = *a_value = tok[1];
 333                         *a_attr = ABS | DEFINED;
 334
 335                         if (a_esym != NULL)
 336                                 *a_esym = NULL;
 337                 }
 338                 else if (*tok == '*')
 339                 {
 340                         *evalTokenBuffer++ = CONST;
 341
 342                         if (orgactive)
 343                                 *evalTokenBuffer++ = *a_value = orgaddr;
 344                         else
 345                                 *evalTokenBuffer++ = *a_value = pcloc;
 346
 347                         *a_attr = ABS | DEFINED;
 348
 349                         if (a_esym != NULL)
 350                                 *a_esym = NULL;
 351
 352                         tok--;
 353                 }
 354                 else
 355                 {
 356                         p = string[tok[1]];
 357                         j = (*p == '.' ? curenv : 0);
 358                         symbol = lookup(p, LABEL, j);
 359
 360                         if (symbol == NULL)
 361                                 symbol = NewSymbol(p, LABEL, j);
 362
 363                         symbol->sattr |= REFERENCED;
 364
 365                         // Check for undefined register equates
 366                         if (symbol->sattre & UNDEF_EQUR)
 367                         {
 368                                 errors("undefined register equate '%s'", symbol->sname);
 369 //if we return right away, it returns some spurious errors...
 370 //                              return ERROR;
 371                         }
 372
 373                         // Check register bank usage
 374                         if (symbol->sattre & EQUATEDREG)
 375                         {
 376                                 if ((regbank == BANK_0) && (symbol->sattre & BANK_1) && !altbankok)
 377                                         warns("equated symbol '%s' cannot be used in register bank 0", symbol->sname);
 378
 379                                 if ((regbank == BANK_1) && (symbol->sattre & BANK_0) && !altbankok)
 380                                         warns("equated symbol '%s' cannot be used in register bank 1", symbol->sname);
 381                         }
 382
 383                         *evalTokenBuffer++ = SYMBOL;
 384 #if 0
 385                         *evalTokenBuffer++ = (TOKEN)symbol;
 386 #else
 387 /*
 388 While this approach works, it's wasteful. It would be better to use something
 389 that's already available, like the symbol "order defined" table (which needs to
 390 be converted from a linked list into an array).
 391 */
 392                         *evalTokenBuffer++ = symbolNum;
 393                         symbolPtr[symbolNum] = symbol;
 394                         symbolNum++;
 395 #endif
 396
 397                         if (symbol->sattr & DEFINED)
 398                                 *a_value = symbol->svalue;
 399                         else
 400                                 *a_value = 0;
 401
 402 /*
 403 All that extra crap that was put into the svalue when doing the equr stuff is
 404 thrown away right here. What the hell is it for?
 405 */
 406                         if (symbol->sattre & EQUATEDREG)
 407                                 *a_value &= 0x1F;
 408
 409                         *a_attr = (WORD)(symbol->sattr & ~GLOBAL);
 410
 411                         if ((symbol->sattr & (GLOBAL | DEFINED)) == GLOBAL && a_esym != NULL)
 412                                 *a_esym = symbol;
 413                 }
 414
 415                 tok += 2;
 416                 *evalTokenBuffer++ = ENDEXPR;
 417                 return OK;
 418         }
 419
 420         if (expr0() != OK)
 421                 return ERROR;
 422
 423         *evalTokenBuffer++ = ENDEXPR;
 424         return evexpr(otk, a_value, a_attr, a_esym);
 425 }
 426
 427
 428 //
 429 // Evaluate expression.
 430 // If the expression involves only ONE external symbol, the expression is
 431 // UNDEFINED, but it's value includes everything but the symbol value, and
 432 // `a_esym' is set to the external symbol.
 433 //
 434 int evexpr(TOKEN * tk, VALUE * a_value, WORD * a_attr, SYM ** a_esym)
 435 {
 436         WORD * sattr;
 437         VALUE * sval;
 438         WORD attr;
 439         SYM * sy;
 440         SYM * esym;
 441         WORD sym_seg;
 442
 443         sval = evstk;                                                   // (Empty) initial stack
 444         sattr = evattr;
 445         esym = NULL;                                                    // No external symbol involved
 446         sym_seg = 0;
 447
 448         while (*tk != ENDEXPR)
 449         {
 450                 switch ((int)*tk++)
 451                 {
 452                 case SYMBOL:
 453 //                      sy = (SYM *)*tk++;
 454                         sy = symbolPtr[*tk++];
 455                         sy->sattr |= REFERENCED;                // Set "referenced" bit
 456
 457                         if (!(sy->sattr & DEFINED))
 458                         {
 459                                 // Reference to undefined symbol
 460                                 if (!(sy->sattr & GLOBAL))
 461                                 {
 462                                         *a_attr = 0;
 463                                         *a_value = 0;
 464                                         return OK;
 465                                 }
 466
 467                                 if (esym != NULL)                       // Check for multiple externals
 468                                         return error(seg_error);
 469
 470                                 esym = sy;
 471                         }
 472
 473                         if (sy->sattr & DEFINED)
 474                         {
 475                                 *++sval = sy->svalue;           // Push symbol's value
 476                         }
 477                         else
 478                         {
 479                                 *++sval = 0;                            // 0 for undefined symbols
 480                         }
 481
 482                         *++sattr = (WORD)(sy->sattr & ~GLOBAL); // Push attribs
 483                         sym_seg = (WORD)(sy->sattr & (TEXT | DATA | BSS));
 484                         break;
 485                 case CONST:
 486                         *++sval = *tk++;                                // Push value
 487                         *++sattr = ABS | DEFINED;               // Push simple attribs
 488                         break;
 489                 case ACONST:
 490                         *++sval = *tk++;                                // Push value
 491                         *++sattr = (WORD)*tk++;                 // Push attribs
 492                         break;
 493
 494                         // Binary "+" and "-" matrix:
 495                         //
 496                         //                ABS    Sect     Other
 497                         //     ----------------------------
 498                         //   ABS     |  ABS   |  Sect  |  Other |
 499                         //   Sect    |  Sect  |  [1]   |  Error |
 500                         //   Other   |  Other |  Error |  [1]   |
 501                         //      ----------------------------
 502                         //
 503                         //   [1] + : Error
 504                         //       - : ABS
 505                 case '+':
 506                         --sval;                                                 // Pop value
 507                         --sattr;                                                // Pop attrib
 508                         *sval += sval[1];                               // Compute value
 509
 510                         if (!(*sattr & (TEXT | DATA | BSS)))
 511                                 *sattr = sattr[1];
 512                         else if (sattr[1] & (TEXT | DATA | BSS))
 513                                 return error(seg_error);
 514
 515                         break;
 516                 case '-':
 517                         --sval;                                                 // Pop value
 518                         --sattr;                                                // Pop attrib
 519                         *sval -= sval[1];                               // Compute value
 520
 521                         attr = (WORD)(*sattr & (TEXT | DATA | BSS));
 522
 523                         if (!attr)
 524                                 *sattr = sattr[1];
 525                         else if (sattr[1] & (TEXT | DATA | BSS))
 526                         {
 527                                 if (!(attr & sattr[1]))
 528                                         return error(seg_error);
 529                                 else
 530                                         *sattr &= ~(TEXT | DATA | BSS);
 531                         }
 532
 533                         break;
 534                 // Unary operators only work on ABS items
 535                 case UNMINUS:
 536                         if (*sattr & (TEXT | DATA | BSS))
 537                                 error(seg_error);
 538
 539                         *sval = -(int)*sval;
 540                         *sattr = ABS | DEFINED;                 // Expr becomes absolute
 541                         break;
 542                 case '!':
 543                         if (*sattr & (TEXT | DATA | BSS))
 544                                 error(seg_error);
 545
 546                         *sval = !*sval;
 547                         *sattr = ABS | DEFINED;                 // Expr becomes absolute
 548                         break;
 549                 case '~':
 550                         if (*sattr & (TEXT | DATA | BSS))
 551                                 error(seg_error);
 552
 553                         *sval = ~*sval;
 554                         *sattr = ABS | DEFINED;                 // Expr becomes absolute
 555                         break;
 556                 // Comparison operators must have two values that
 557                 // are in the same segment, but that's the only requirement.
 558                 case LE:
 559                         --sattr;
 560                         --sval;
 561
 562                         if ((*sattr & TDB) != (sattr[1] & TDB))
 563                                 error(seg_error);
 564
 565                         *sattr = ABS | DEFINED;
 566                         *sval = *sval <= sval[1];
 567                         break;
 568                 case GE:
 569                         --sattr;
 570                         --sval;
 571
 572                         if ((*sattr & TDB) != (sattr[1] & TDB))
 573                                 error(seg_error);
 574
 575                         *sattr = ABS | DEFINED;
 576                         *sval = *sval >= sval[1];
 577                         break;
 578                 case '>':
 579                         --sattr;
 580                         --sval;
 581
 582                         if ((*sattr & TDB) != (sattr[1] & TDB))
 583                                 error(seg_error);
 584
 585                         *sattr = ABS | DEFINED;
 586                         *sval = *sval > sval[1];
 587                         break;
 588                 case '<':
 589                         --sattr;
 590                         --sval;
 591
 592                         if ((*sattr & TDB) != (sattr[1] & TDB))
 593                                 error(seg_error);
 594
 595                         *sattr = ABS | DEFINED;
 596                         *sval = *sval < sval[1];
 597                         break;
 598                 case NE:
 599                         --sattr;
 600                         --sval;
 601
 602                         if ((*sattr & TDB) != (sattr[1] & TDB))
 603                                 error(seg_error);
 604
 605                         *sattr = ABS | DEFINED;
 606                         *sval = *sval != sval[1];
 607                         break;
 608                 case '=':
 609                         --sattr;
 610                         --sval;
 611
 612                         if ((*sattr & TDB) != (sattr[1] & TDB))
 613                                 error(seg_error);
 614
 615                         *sattr = ABS | DEFINED;
 616                         *sval = *sval == sval[1];
 617                         break;
 618                 // All other binary operators must have two ABS items
 619                 // to work with.  They all produce an ABS value.
 620                 default:
 621                         // GH - Removed for v1.0.15 as part of the fix for indexed loads.
 622                         //if ((*sattr & (TEXT|DATA|BSS)) || (*--sattr & (TEXT|DATA|BSS)))
 623                         //error(seg_error);
 624                         *sattr = ABS | DEFINED;                 // Expr becomes absolute
 625
 626                         switch ((int)tk[-1])
 627                         {
 628                         case '*':
 629                                 --sval;
 630                                 --sattr;                                        // Pop attrib
 631                                 *sval *= sval[1];
 632                                 break;
 633                         case '/':
 634                                 --sval;
 635                                 --sattr;                                        // Pop attrib
 636
 637                                 if (sval[1] == 0)
 638                                         return error("divide by zero");
 639
 640                                 *sval /= sval[1];
 641                                 break;
 642                         case '%':
 643                                 --sval;
 644                                 --sattr;                                        // Pop attrib
 645
 646                                 if (sval[1] == 0)
 647                                         return error("mod (%) by zero");
 648
 649                                 *sval %= sval[1];
 650                                 break;
 651                         case SHL:
 652                                 --sval;
 653                                 --sattr;                                        // Pop attrib
 654                                 *sval <<= sval[1];
 655                                 break;
 656                         case SHR:
 657                                 --sval;
 658                                 --sattr;                                        // Pop attrib
 659                                 *sval >>= sval[1];
 660                                 break;
 661                         case '&':
 662                                 --sval;
 663                                 --sattr;                                        // Pop attrib
 664                                 *sval &= sval[1];
 665                                 break;
 666                         case '^':
 667                                 --sval;
 668                                 --sattr;                                        // Pop attrib
 669                                 *sval ^= sval[1];
 670                                 break;
 671                         case '|':
 672                                 --sval;
 673                                 --sattr;                                        // Pop attrib
 674                                 *sval |= sval[1];
 675                                 break;
 676                         default:
 677                                 interror(5);                            // Bad operator in expression stream
 678                         }
 679                 }
 680         }
 681
 682         if (esym != NULL)
 683                 *sattr &= ~DEFINED;
 684
 685         if (a_esym != NULL)
 686                 *a_esym = esym;
 687
 688         // sym_seg added in 1.0.16 to solve a problem with forward symbols in
 689         // expressions where absolute values also existed. The absolutes were
 690         // overiding the symbol segments and not being included :(
 691         //*a_attr = *sattr | sym_seg;                                        // Copy value + attrib
 692
 693         *a_attr = *sattr;                                               // Copy value + attrib
 694         *a_value = *sval;
 695
 696         return OK;
 697 }