gas/expr.c

   1 /* expr.c -operands, expressions-
   2    Copyright (C) 1987, 1990, 1991, 1992 Free Software Foundation, Inc.
   3
   4    This file is part of GAS, the GNU Assembler.
   5
   6    GAS is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2, or (at your option)
   9    any later version.
  10
  11    GAS is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with GAS; see the file COPYING.  If not, write to
  18    the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
  19
  20 /*
  21  * This is really a branch office of as-read.c. I split it out to clearly
  22  * distinguish the world of expressions from the world of statements.
  23  * (It also gives smaller files to re-compile.)
  24  * Here, "operand"s are of expressions, not instructions.
  25  */
  26
  27 #include <ctype.h>
  28 #include <string.h>
  29
  30 #include "as.h"
  31
  32 #include "obstack.h"
  33
  34 #if __STDC__ == 1
  35 static void clean_up_expression (expressionS * expressionP);
  36 #else /* __STDC__ */
  37 static void clean_up_expression ();     /* Internal. */
  38 #endif /* not __STDC__ */
  39 extern const char EXP_CHARS[];  /* JF hide MD floating pt stuff all the same place */
  40 extern const char FLT_CHARS[];
  41
  42 /*
  43  * Build any floating-point literal here.
  44  * Also build any bignum literal here.
  45  */
  46
  47 /* LITTLENUM_TYPE       generic_buffer [6]; *//* JF this is a hack */
  48 /* Seems atof_machine can backscan through generic_bignum and hit whatever
  49    happens to be loaded before it in memory.  And its way too complicated
  50    for me to fix right.  Thus a hack.  JF:  Just make generic_bignum bigger,
  51    and never write into the early words, thus they'll always be zero.
  52    I hate Dean's floating-point code.  Bleh.
  53    */
  54 LITTLENUM_TYPE generic_bignum[SIZE_OF_LARGE_NUMBER + 6];
  55 FLONUM_TYPE generic_floating_point_number =
  56 {
  57   &generic_bignum[6],           /* low (JF: Was 0) */
  58   &generic_bignum[SIZE_OF_LARGE_NUMBER + 6 - 1],        /* high JF: (added +6) */
  59   0,                            /* leader */
  60   0,                            /* exponent */
  61   0                             /* sign */
  62 };
  63 /* If nonzero, we've been asked to assemble nan, +inf or -inf */
  64 int generic_floating_point_magic;
  65 \f
  66 floating_constant (expressionP)
  67      expressionS *expressionP;
  68 {
  69   /* input_line_pointer->*/
  70   /* floating-point constant. */
  71   int error_code;
  72
  73   error_code = atof_generic
  74     (&input_line_pointer, ".", EXP_CHARS,
  75      &generic_floating_point_number);
  76
  77   if (error_code)
  78     {
  79       if (error_code == ERROR_EXPONENT_OVERFLOW)
  80         {
  81           as_bad ("bad floating-point constant: exponent overflow, probably assembling junk");
  82         }
  83       else
  84         {
  85           as_bad ("bad floating-point constant: unknown error code=%d.", error_code);
  86         }
  87     }
  88   expressionP->X_seg = SEG_BIG;
  89   /* input_line_pointer->just after constant, */
  90   /* which may point to whitespace. */
  91   expressionP->X_add_number = -1;
  92 }
  93
  94
  95
  96 integer_constant (radix, expressionP)
  97      int radix;
  98      expressionS *expressionP;
  99 {
 100   register char *digit_2;       /*->2nd digit of number. */
 101   char c;
 102
 103   register valueT number;       /* offset or (absolute) value */
 104   register short int digit;     /* value of next digit in current radix */
 105   register short int maxdig = 0;/* highest permitted digit value. */
 106   register int too_many_digits = 0;     /* if we see >= this number of */
 107   register char *name;          /* points to name of symbol */
 108   register symbolS *symbolP;    /* points to symbol */
 109
 110   int small;                    /* true if fits in 32 bits. */
 111   extern char hex_value[];      /* in hex_value.c */
 112
 113   /* may be bignum, or may fit in 32 bits. */
 114   /*
 115    * most numbers fit into 32 bits, and we want this case to be fast.
 116    * so we pretend it will fit into 32 bits. if, after making up a 32
 117    * bit number, we realise that we have scanned more digits than
 118    * comfortably fit into 32 bits, we re-scan the digits coding
 119    * them into a bignum. for decimal and octal numbers we are conservative: some
 120    * numbers may be assumed bignums when in fact they do fit into 32 bits.
 121    * numbers of any radix can have excess leading zeros: we strive
 122    * to recognise this and cast them back into 32 bits.
 123    * we must check that the bignum really is more than 32
 124    * bits, and change it back to a 32-bit number if it fits.
 125    * the number we are looking for is expected to be positive, but
 126    * if it fits into 32 bits as an unsigned number, we let it be a 32-bit
 127    * number. the cavalier approach is for speed in ordinary cases.
 128    */
 129
 130   switch (radix)
 131     {
 132
 133     case 2:
 134       maxdig = 2;
 135       too_many_digits = 33;
 136       break;
 137     case 8:
 138       maxdig = radix = 8;
 139       too_many_digits = 11;
 140       break;
 141     case 16:
 142
 143
 144       maxdig = radix = 16;
 145       too_many_digits = 9;
 146       break;
 147     case 10:
 148       maxdig = radix = 10;
 149       too_many_digits = 11;
 150     }
 151   c = *input_line_pointer;
 152   input_line_pointer++;
 153   digit_2 = input_line_pointer;
 154   for (number = 0; (digit = hex_value[c]) < maxdig; c = *input_line_pointer++)
 155     {
 156       number = number * radix + digit;
 157     }
 158   /* c contains character after number. */
 159   /* input_line_pointer->char after c. */
 160   small = input_line_pointer - digit_2 < too_many_digits;
 161   if (!small)
 162     {
 163       /*
 164        * we saw a lot of digits. manufacture a bignum the hard way.
 165        */
 166       LITTLENUM_TYPE *leader;   /*->high order littlenum of the bignum. */
 167       LITTLENUM_TYPE *pointer;  /*->littlenum we are frobbing now. */
 168       long carry;
 169
 170       leader = generic_bignum;
 171       generic_bignum[0] = 0;
 172       generic_bignum[1] = 0;
 173       /* we could just use digit_2, but lets be mnemonic. */
 174       input_line_pointer = --digit_2;   /*->1st digit. */
 175       c = *input_line_pointer++;
 176       for (; (carry = hex_value[c]) < maxdig; c = *input_line_pointer++)
 177         {
 178           for (pointer = generic_bignum;
 179                pointer <= leader;
 180                pointer++)
 181             {
 182               long work;
 183
 184               work = carry + radix * *pointer;
 185               *pointer = work & LITTLENUM_MASK;
 186               carry = work >> LITTLENUM_NUMBER_OF_BITS;
 187             }
 188           if (carry)
 189             {
 190               if (leader < generic_bignum + SIZE_OF_LARGE_NUMBER - 1)
 191                 {               /* room to grow a longer bignum. */
 192                   *++leader = carry;
 193                 }
 194             }
 195         }
 196       /* again, c is char after number, */
 197       /* input_line_pointer->after c. */
 198       know (sizeof (int) * 8 == 32);
 199       know (LITTLENUM_NUMBER_OF_BITS == 16);
 200       /* hence the constant "2" in the next line. */
 201       if (leader < generic_bignum + 2)
 202         {                       /* will fit into 32 bits. */
 203           number =
 204             ((generic_bignum[1] & LITTLENUM_MASK) << LITTLENUM_NUMBER_OF_BITS)
 205             | (generic_bignum[0] & LITTLENUM_MASK);
 206           small = 1;
 207         }
 208       else
 209         {
 210           number = leader - generic_bignum + 1; /* number of littlenums in the bignum. */
 211         }
 212     }
 213   if (small)
 214     {
 215       /*
 216        * here with number, in correct radix. c is the next char.
 217        * note that unlike un*x, we allow "011f" "0x9f" to
 218        * both mean the same as the (conventional) "9f". this is simply easier
 219        * than checking for strict canonical form. syntax sux!
 220        */
 221
 222       switch (c)
 223         {
 224
 225 #ifdef LOCAL_LABELS_FB
 226         case 'b':
 227           {
 228             /*
 229              * backward ref to local label.
 230              * because it is backward, expect it to be defined.
 231              */
 232             /* Construct a local label.  */
 233             name = fb_label_name ((int) number, 0);
 234
 235             /* seen before, or symbol is defined: ok */
 236             symbolP = symbol_find (name);
 237             if ((symbolP != NULL) && (S_IS_DEFINED (symbolP)))
 238               {
 239
 240                 /* local labels are never absolute. don't waste time
 241                    checking absoluteness. */
 242                 know (SEG_NORMAL (S_GET_SEGMENT (symbolP)));
 243
 244                 expressionP->X_add_symbol = symbolP;
 245                 expressionP->X_seg = S_GET_SEGMENT (symbolP);
 246
 247               }
 248             else
 249               {                 /* either not seen or not defined. */
 250                 as_bad ("backw. ref to unknown label \"%d:\", 0 assumed.", number);
 251                 expressionP->X_seg = SEG_ABSOLUTE;
 252               }
 253
 254             expressionP->X_add_number = 0;
 255             break;
 256           }                     /* case 'b' */
 257
 258         case 'f':
 259           {
 260             /*
 261              * forward reference. expect symbol to be undefined or
 262              * unknown. undefined: seen it before. unknown: never seen
 263              * it before.
 264              * construct a local label name, then an undefined symbol.
 265              * don't create a xseg frag for it: caller may do that.
 266              * just return it as never seen before.
 267              */
 268             name = fb_label_name ((int) number, 1);
 269             symbolP = symbol_find_or_make (name);
 270             /* we have no need to check symbol properties. */
 271 #ifndef many_segments
 272             /* since "know" puts its arg into a "string", we
 273                can't have newlines in the argument.  */
 274             know (S_GET_SEGMENT (symbolP) == SEG_UNKNOWN || S_GET_SEGMENT (symbolP) == SEG_TEXT || S_GET_SEGMENT (symbolP) == SEG_DATA);
 275 #endif
 276             expressionP->X_add_symbol = symbolP;
 277             expressionP->X_seg = SEG_UNKNOWN;
 278             expressionP->X_subtract_symbol = NULL;
 279             expressionP->X_add_number = 0;
 280
 281             break;
 282           }                     /* case 'f' */
 283
 284 #endif /* LOCAL_LABELS_FB */
 285
 286 #ifdef LOCAL_LABELS_DOLLAR
 287
 288         case '$':
 289           {
 290
 291             /* If the dollar label is *currently* defined, then this is just
 292                another reference to it.  If it is not *currently* defined,
 293                then this is a fresh instantiation of that number, so create
 294                it.  */
 295
 296             if (dollar_label_defined (number))
 297               {
 298                 name = dollar_label_name (number, 0);
 299                 symbolP = symbol_find (name);
 300                 know (symbolP != NULL);
 301               }
 302             else
 303               {
 304                 name = dollar_label_name (number, 1);
 305                 symbolP = symbol_find_or_make (name);
 306               }
 307
 308             expressionP->X_add_symbol = symbolP;
 309             expressionP->X_add_number = 0;
 310             expressionP->X_seg = S_GET_SEGMENT (symbolP);
 311
 312             break;
 313           }                     /* case '$' */
 314
 315 #endif /* LOCAL_LABELS_DOLLAR */
 316
 317         default:
 318           {
 319             expressionP->X_add_number = number;
 320             expressionP->X_seg = SEG_ABSOLUTE;
 321             input_line_pointer--;       /* restore following character. */
 322             break;
 323           }                     /* really just a number */
 324
 325         }                       /* switch on char following the number */
 326
 327
 328     }
 329   else
 330     {                           /* not a small number */
 331       expressionP->X_add_number = number;
 332       expressionP->X_seg = SEG_BIG;
 333       input_line_pointer--;     /*->char following number. */
 334     }                           /* if (small) */
 335 }                               /* integer_constant() */
 336
 337
 338 /*
 339  * Summary of operand().
 340  *
 341  * in:  Input_line_pointer points to 1st char of operand, which may
 342  *      be a space.
 343  *
 344  * out: A expressionS. X_seg determines how to understand the rest of the
 345  *      expressionS.
 346  *      The operand may have been empty: in this case X_seg == SEG_ABSENT.
 347  *      Input_line_pointer->(next non-blank) char after operand.
 348  *
 349  */
 350 \f
 351
 352
 353 static segT
 354 operand (expressionP)
 355      register expressionS *expressionP;
 356 {
 357   register char c;
 358   register symbolS *symbolP;    /* points to symbol */
 359   register char *name;          /* points to name of symbol */
 360   /* invented for humans only, hope */
 361   /* optimising compiler flushes it! */
 362   register short int radix;     /* 2, 8, 10 or 16, 0 when floating */
 363   /* 0 means we saw start of a floating- */
 364   /* point constant. */
 365
 366   /* digits, assume it is a bignum. */
 367
 368   SKIP_WHITESPACE ();           /* leading whitespace is part of operand. */
 369   c = *input_line_pointer++;    /* input_line_pointer->past char in c. */
 370
 371   switch (c)
 372     {
 373 #ifdef MRI
 374     case '%':
 375       integer_constant (2, expressionP);
 376       break;
 377     case '@':
 378       integer_constant (8, expressionP);
 379       break;
 380     case '$':
 381       integer_constant (16, expressionP);
 382       break;
 383 #endif
 384     case '1':
 385     case '2':
 386     case '3':
 387     case '4':
 388     case '5':
 389     case '6':
 390     case '7':
 391     case '8':
 392     case '9':
 393       input_line_pointer--;
 394
 395       integer_constant (10, expressionP);
 396       break;
 397
 398     case '0':
 399       /* non-decimal radix */
 400
 401
 402       c = *input_line_pointer;
 403       switch (c)
 404         {
 405
 406         default:
 407           if (c && strchr (FLT_CHARS, c))
 408             {
 409               input_line_pointer++;
 410               floating_constant (expressionP);
 411             }
 412           else
 413             {
 414               /* The string was only zero */
 415               expressionP->X_add_symbol = 0;
 416               expressionP->X_add_number = 0;
 417               expressionP->X_seg = SEG_ABSOLUTE;
 418             }
 419
 420           break;
 421
 422         case 'x':
 423         case 'X':
 424           input_line_pointer++;
 425           integer_constant (16, expressionP);
 426           break;
 427
 428         case 'b':
 429 #ifdef LOCAL_LABELS_FB
 430           if (!*input_line_pointer
 431               || (!strchr ("+-.0123456789", *input_line_pointer)
 432                   && !strchr (EXP_CHARS, *input_line_pointer)))
 433             {
 434               input_line_pointer--;
 435               integer_constant (10, expressionP);
 436               break;
 437             }
 438 #endif
 439         case 'B':
 440           input_line_pointer++;
 441           integer_constant (2, expressionP);
 442           break;
 443
 444         case '0':
 445         case '1':
 446         case '2':
 447         case '3':
 448         case '4':
 449         case '5':
 450         case '6':
 451         case '7':
 452           integer_constant (8, expressionP);
 453           break;
 454
 455         case 'f':
 456 #ifdef LOCAL_LABELS_FB
 457           /* if it says '0f' and the line ends or it doesn't look like
 458              a floating point #, its a local label ref.  dtrt */
 459           /* likewise for the b's.  xoxorich. */
 460           if (c == 'f'
 461               && (!*input_line_pointer ||
 462                   (!strchr ("+-.0123456789", *input_line_pointer) &&
 463                    !strchr (EXP_CHARS, *input_line_pointer))))
 464             {
 465               input_line_pointer -= 1;
 466               integer_constant (10, expressionP);
 467               break;
 468             }
 469 #endif
 470
 471         case 'd':
 472         case 'D':
 473         case 'F':
 474         case 'r':
 475         case 'e':
 476         case 'E':
 477         case 'g':
 478         case 'G':
 479
 480           input_line_pointer++;
 481           floating_constant (expressionP);
 482           break;
 483
 484 #ifdef LOCAL_LABELS_DOLLAR
 485         case '$':
 486           integer_constant (10, expressionP);
 487           break;
 488 #endif
 489         }
 490
 491       break;
 492     case '(':
 493       /* didn't begin with digit & not a name */
 494       {
 495         (void) expression (expressionP);
 496         /* Expression() will pass trailing whitespace */
 497         if (*input_line_pointer++ != ')')
 498           {
 499             as_bad ("Missing ')' assumed");
 500             input_line_pointer--;
 501           }
 502         /* here with input_line_pointer->char after "(...)" */
 503       }
 504       return expressionP->X_seg;
 505
 506
 507     case '\'':
 508       /* Warning: to conform to other people's assemblers NO ESCAPEMENT is
 509          permitted for a single quote. The next character, parity errors and
 510          all, is taken as the value of the operand. VERY KINKY.  */
 511       expressionP->X_add_number = *input_line_pointer++;
 512       expressionP->X_seg = SEG_ABSOLUTE;
 513       break;
 514
 515     case '~':
 516     case '-':
 517     case '+':
 518
 519       {
 520         /* unary operator: hope for SEG_ABSOLUTE */
 521         switch (operand (expressionP))
 522           {
 523           case SEG_ABSOLUTE:
 524             /* input_line_pointer -> char after operand */
 525             if (c == '-')
 526               {
 527                 expressionP->X_add_number = -expressionP->X_add_number;
 528                 /* Notice: '-' may overflow: no warning is given. This is
 529                    compatible with other people's assemblers. Sigh.  */
 530               }
 531             else
 532               {
 533                 expressionP->X_add_number = ~expressionP->X_add_number;
 534               }
 535             break;
 536
 537           case SEG_TEXT:
 538           case SEG_DATA:
 539           case SEG_BSS:
 540           case SEG_PASS1:
 541           case SEG_UNKNOWN:
 542             if (c == '-')
 543               {                 /* JF I hope this hack works */
 544                 expressionP->X_subtract_symbol = expressionP->X_add_symbol;
 545                 expressionP->X_add_symbol = 0;
 546                 expressionP->X_seg = SEG_DIFFERENCE;
 547                 break;
 548               }
 549           default:              /* unary on non-absolute is unsuported */
 550             as_warn ("Unary operator %c ignored because bad operand follows", c);
 551             break;
 552             /* Expression undisturbed from operand(). */
 553           }
 554       }
 555
 556
 557
 558       break;
 559
 560     case '.':
 561       if (!is_part_of_name (*input_line_pointer))
 562         {
 563           char *fake;
 564           extern struct obstack frags;
 565
 566           /* JF: '.' is pseudo symbol with value of current location
 567              in current segment.  */
 568 #ifdef DOT_LABEL_PREFIX
 569           fake = ".L0\001";
 570 #else
 571           fake = "L0\001";
 572 #endif
 573           symbolP = symbol_new (fake,
 574                                 now_seg,
 575                (valueT) (obstack_next_free (&frags) - frag_now->fr_literal),
 576                                 frag_now);
 577
 578           expressionP->X_add_number = 0;
 579           expressionP->X_add_symbol = symbolP;
 580           expressionP->X_seg = now_seg;
 581           break;
 582
 583         }
 584       else
 585         {
 586           goto isname;
 587
 588
 589         }
 590     case ',':
 591     case '\n':
 592       /* can't imagine any other kind of operand */
 593       expressionP->X_seg = SEG_ABSENT;
 594       input_line_pointer--;
 595       md_operand (expressionP);
 596       break;
 597       /* Fall through */
 598     default:
 599       if (is_name_beginner (c)) /* here if did not begin with a digit */
 600         {
 601           /*
 602            * Identifier begins here.
 603            * This is kludged for speed, so code is repeated.
 604            */
 605         isname:
 606           name = --input_line_pointer;
 607           c = get_symbol_end ();
 608           symbolP = symbol_find_or_make (name);
 609           /* If we have an absolute symbol or a reg, then we know its value
 610              now.  */
 611           expressionP->X_seg = S_GET_SEGMENT (symbolP);
 612           switch (expressionP->X_seg)
 613             {
 614             case SEG_ABSOLUTE:
 615             case SEG_REGISTER:
 616               expressionP->X_add_number = S_GET_VALUE (symbolP);
 617               break;
 618
 619             default:
 620               expressionP->X_add_number = 0;
 621               expressionP->X_add_symbol = symbolP;
 622             }
 623           *input_line_pointer = c;
 624           expressionP->X_subtract_symbol = NULL;
 625         }
 626       else
 627         {
 628           as_bad ("Bad expression");
 629           expressionP->X_add_number = 0;
 630           expressionP->X_seg = SEG_ABSOLUTE;
 631
 632         }
 633
 634     }
 635
 636
 637
 638
 639
 640
 641
 642   /*
 643    * It is more 'efficient' to clean up the expressionS when they are created.
 644    * Doing it here saves lines of code.
 645    */
 646   clean_up_expression (expressionP);
 647   SKIP_WHITESPACE ();           /*->1st char after operand. */
 648   know (*input_line_pointer != ' ');
 649   return (expressionP->X_seg);
 650 }                               /* operand() */
 651 \f
 652
 653 /* Internal. Simplify a struct expression for use by expr() */
 654
 655 /*
 656  * In:  address of a expressionS.
 657  *      The X_seg field of the expressionS may only take certain values.
 658  *      Now, we permit SEG_PASS1 to make code smaller & faster.
 659  *      Elsewise we waste time special-case testing. Sigh. Ditto SEG_ABSENT.
 660  * Out: expressionS may have been modified:
 661  *      'foo-foo' symbol references cancelled to 0,
 662  *              which changes X_seg from SEG_DIFFERENCE to SEG_ABSOLUTE;
 663  *      Unused fields zeroed to help expr().
 664  */
 665
 666 static void
 667 clean_up_expression (expressionP)
 668      register expressionS *expressionP;
 669 {
 670   switch (expressionP->X_seg)
 671     {
 672     case SEG_ABSENT:
 673     case SEG_PASS1:
 674       expressionP->X_add_symbol = NULL;
 675       expressionP->X_subtract_symbol = NULL;
 676       expressionP->X_add_number = 0;
 677       break;
 678
 679     case SEG_BIG:
 680     case SEG_ABSOLUTE:
 681       expressionP->X_subtract_symbol = NULL;
 682       expressionP->X_add_symbol = NULL;
 683       break;
 684
 685     case SEG_UNKNOWN:
 686       expressionP->X_subtract_symbol = NULL;
 687       break;
 688
 689     case SEG_DIFFERENCE:
 690       /*
 691          * It does not hurt to 'cancel' NULL==NULL
 692          * when comparing symbols for 'eq'ness.
 693          * It is faster to re-cancel them to NULL
 694          * than to check for this special case.
 695          */
 696       if (expressionP->X_subtract_symbol == expressionP->X_add_symbol
 697           || (expressionP->X_subtract_symbol
 698               && expressionP->X_add_symbol
 699               && expressionP->X_subtract_symbol->sy_frag == expressionP->X_add_symbol->sy_frag
 700               && S_GET_VALUE (expressionP->X_subtract_symbol) == S_GET_VALUE (expressionP->X_add_symbol)))
 701         {
 702           expressionP->X_subtract_symbol = NULL;
 703           expressionP->X_add_symbol = NULL;
 704           expressionP->X_seg = SEG_ABSOLUTE;
 705         }
 706       break;
 707
 708     case SEG_REGISTER:
 709       expressionP->X_add_symbol = NULL;
 710       expressionP->X_subtract_symbol = NULL;
 711       break;
 712
 713     default:
 714       if (SEG_NORMAL (expressionP->X_seg))
 715         {
 716           expressionP->X_subtract_symbol = NULL;
 717         }
 718       else
 719         {
 720           BAD_CASE (expressionP->X_seg);
 721         }
 722       break;
 723     }
 724 }                               /* clean_up_expression() */
 725 \f
 726 /*
 727  *                      expr_part ()
 728  *
 729  * Internal. Made a function because this code is used in 2 places.
 730  * Generate error or correct X_?????_symbol of expressionS.
 731  */
 732
 733 /*
 734  * symbol_1 += symbol_2 ... well ... sort of.
 735  */
 736
 737 static segT
 738 expr_part (symbol_1_PP, symbol_2_P)
 739      symbolS **symbol_1_PP;
 740      symbolS *symbol_2_P;
 741 {
 742   segT return_value;
 743 #ifndef MANY_SEGMENTS
 744   know ((*symbol_1_PP) == NULL || (S_GET_SEGMENT (*symbol_1_PP) == SEG_TEXT) || (S_GET_SEGMENT (*symbol_1_PP) == SEG_DATA) || (S_GET_SEGMENT (*symbol_1_PP) == SEG_BSS) || (!S_IS_DEFINED (*symbol_1_PP)));
 745   know (symbol_2_P == NULL || (S_GET_SEGMENT (symbol_2_P) == SEG_TEXT) || (S_GET_SEGMENT (symbol_2_P) == SEG_DATA) || (S_GET_SEGMENT (symbol_2_P) == SEG_BSS) || (!S_IS_DEFINED (symbol_2_P)));
 746 #endif
 747   if (*symbol_1_PP)
 748     {
 749       if (!S_IS_DEFINED (*symbol_1_PP))
 750         {
 751           if (symbol_2_P)
 752             {
 753               return_value = SEG_PASS1;
 754               *symbol_1_PP = NULL;
 755             }
 756           else
 757             {
 758               know (!S_IS_DEFINED (*symbol_1_PP));
 759               return_value = SEG_UNKNOWN;
 760             }
 761         }
 762       else
 763         {
 764           if (symbol_2_P)
 765             {
 766               if (!S_IS_DEFINED (symbol_2_P))
 767                 {
 768                   *symbol_1_PP = NULL;
 769                   return_value = SEG_PASS1;
 770                 }
 771               else
 772                 {
 773                   /* {seg1} - {seg2} */
 774                   as_bad ("Expression too complex, 2 symbolS forgotten: \"%s\" \"%s\"",
 775                         S_GET_NAME (*symbol_1_PP), S_GET_NAME (symbol_2_P));
 776                   *symbol_1_PP = NULL;
 777                   return_value = SEG_ABSOLUTE;
 778                 }
 779             }
 780           else
 781             {
 782               return_value = S_GET_SEGMENT (*symbol_1_PP);
 783             }
 784         }
 785     }
 786   else
 787     {                           /* (* symbol_1_PP) == NULL */
 788       if (symbol_2_P)
 789         {
 790           *symbol_1_PP = symbol_2_P;
 791           return_value = S_GET_SEGMENT (symbol_2_P);
 792         }
 793       else
 794         {
 795           *symbol_1_PP = NULL;
 796           return_value = SEG_ABSOLUTE;
 797         }
 798     }
 799 #ifndef MANY_SEGMENTS
 800   know (return_value == SEG_ABSOLUTE || return_value == SEG_TEXT || return_value == SEG_DATA || return_value == SEG_BSS || return_value == SEG_UNKNOWN || return_value == SEG_PASS1);
 801 #endif
 802   know ((*symbol_1_PP) == NULL || (S_GET_SEGMENT (*symbol_1_PP) == return_value));
 803   return (return_value);
 804 }                               /* expr_part() */
 805 \f
 806 /* Expression parser. */
 807
 808 /*
 809  * We allow an empty expression, and just assume (absolute,0) silently.
 810  * Unary operators and parenthetical expressions are treated as operands.
 811  * As usual, Q==quantity==operand, O==operator, X==expression mnemonics.
 812  *
 813  * We used to do a aho/ullman shift-reduce parser, but the logic got so
 814  * warped that I flushed it and wrote a recursive-descent parser instead.
 815  * Now things are stable, would anybody like to write a fast parser?
 816  * Most expressions are either register (which does not even reach here)
 817  * or 1 symbol. Then "symbol+constant" and "symbol-symbol" are common.
 818  * So I guess it doesn't really matter how inefficient more complex expressions
 819  * are parsed.
 820  *
 821  * After expr(RANK,resultP) input_line_pointer->operator of rank <= RANK.
 822  * Also, we have consumed any leading or trailing spaces (operand does that)
 823  * and done all intervening operators.
 824  */
 825
 826 typedef enum
 827 {
 828   O_illegal,                    /* (0)  what we get for illegal op */
 829
 830   O_multiply,                   /* (1)  * */
 831   O_divide,                     /* (2)  / */
 832   O_modulus,                    /* (3)  % */
 833   O_left_shift,                 /* (4)  < */
 834   O_right_shift,                /* (5)  > */
 835   O_bit_inclusive_or,           /* (6)  | */
 836   O_bit_or_not,                 /* (7)  ! */
 837   O_bit_exclusive_or,           /* (8)  ^ */
 838   O_bit_and,                    /* (9)  & */
 839   O_add,                        /* (10) + */
 840   O_subtract                    /* (11) - */
 841 }
 842
 843 operatorT;
 844
 845 #define __ O_illegal
 846
 847 static const operatorT op_encoding[256] =
 848 {                               /* maps ASCII->operators */
 849
 850   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
 851   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
 852
 853   __, O_bit_or_not, __, __, __, O_modulus, O_bit_and, __,
 854   __, __, O_multiply, O_add, __, O_subtract, __, O_divide,
 855   __, __, __, __, __, __, __, __,
 856   __, __, __, __, O_left_shift, __, O_right_shift, __,
 857   __, __, __, __, __, __, __, __,
 858   __, __, __, __, __, __, __, __,
 859   __, __, __, __, __, __, __, __,
 860   __, __, __, __, __, __, O_bit_exclusive_or, __,
 861   __, __, __, __, __, __, __, __,
 862   __, __, __, __, __, __, __, __,
 863   __, __, __, __, __, __, __, __,
 864   __, __, __, __, O_bit_inclusive_or, __, __, __,
 865
 866   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
 867   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
 868   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
 869   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
 870   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
 871   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
 872   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
 873   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __
 874 };
 875
 876
 877 /*
 878  *      Rank    Examples
 879  *      0       operand, (expression)
 880  *      1       + -
 881  *      2       & ^ ! |
 882  *      3       * / % << >>
 883  */
 884 static const operator_rankT
 885   op_rank[] =
 886 {0, 3, 3, 3, 3, 3, 2, 2, 2, 2, 1, 1};
 887 \f
 888 /* Return resultP->X_seg. */
 889 segT
 890 expr (rank, resultP)
 891      register operator_rankT rank;      /* Larger # is higher rank. */
 892      register expressionS *resultP;     /* Deliver result here. */
 893 {
 894   expressionS right;
 895   register operatorT op_left;
 896   register char c_left;         /* 1st operator character. */
 897   register operatorT op_right;
 898   register char c_right;
 899
 900   know (rank >= 0);
 901   (void) operand (resultP);
 902   know (*input_line_pointer != ' ');    /* Operand() gobbles spaces. */
 903   c_left = *input_line_pointer; /* Potential operator character. */
 904   op_left = op_encoding[c_left];
 905   while (op_left != O_illegal && op_rank[(int) op_left] > rank)
 906     {
 907       input_line_pointer++;     /*->after 1st character of operator. */
 908       /* Operators "<<" and ">>" have 2 characters. */
 909       if (*input_line_pointer == c_left && (c_left == '<' || c_left == '>'))
 910         {
 911           input_line_pointer++;
 912         }                       /*->after operator. */
 913       if (SEG_ABSENT == expr (op_rank[(int) op_left], &right))
 914         {
 915           as_warn ("Missing operand value assumed absolute 0.");
 916           resultP->X_add_number = 0;
 917           resultP->X_subtract_symbol = NULL;
 918           resultP->X_add_symbol = NULL;
 919           resultP->X_seg = SEG_ABSOLUTE;
 920         }
 921       know (*input_line_pointer != ' ');
 922       c_right = *input_line_pointer;
 923       op_right = op_encoding[c_right];
 924       if (*input_line_pointer == c_right && (c_right == '<' || c_right == '>'))
 925         {
 926           input_line_pointer++;
 927         }                       /*->after operator. */
 928       know ((int) op_right == 0 || op_rank[(int) op_right] <= op_rank[(int) op_left]);
 929       /* input_line_pointer->after right-hand quantity. */
 930       /* left-hand quantity in resultP */
 931       /* right-hand quantity in right. */
 932       /* operator in op_left. */
 933       if (resultP->X_seg == SEG_PASS1 || right.X_seg == SEG_PASS1)
 934         {
 935           resultP->X_seg = SEG_PASS1;
 936         }
 937       else
 938         {
 939           if (resultP->X_seg == SEG_BIG)
 940             {
 941               as_warn ("Left operand of %c is a %s.  Integer 0 assumed.",
 942                     c_left, resultP->X_add_number > 0 ? "bignum" : "float");
 943               resultP->X_seg = SEG_ABSOLUTE;
 944               resultP->X_add_symbol = 0;
 945               resultP->X_subtract_symbol = 0;
 946               resultP->X_add_number = 0;
 947             }
 948           if (right.X_seg == SEG_BIG)
 949             {
 950               as_warn ("Right operand of %c is a %s.  Integer 0 assumed.",
 951                        c_left, right.X_add_number > 0 ? "bignum" : "float");
 952               right.X_seg = SEG_ABSOLUTE;
 953               right.X_add_symbol = 0;
 954               right.X_subtract_symbol = 0;
 955               right.X_add_number = 0;
 956             }
 957           if (op_left == O_subtract)
 958             {
 959               /*
 960                * Convert - into + by exchanging symbolS and negating number.
 961                * I know -infinity can't be negated in 2's complement:
 962                * but then it can't be subtracted either. This trick
 963                * does not cause any further inaccuracy.
 964                */
 965
 966               register symbolS *symbolP;
 967
 968               right.X_add_number = -right.X_add_number;
 969               symbolP = right.X_add_symbol;
 970               right.X_add_symbol = right.X_subtract_symbol;
 971               right.X_subtract_symbol = symbolP;
 972               if (symbolP)
 973                 {
 974                   right.X_seg = SEG_DIFFERENCE;
 975                 }
 976               op_left = O_add;
 977             }
 978 \f
 979           if (op_left == O_add)
 980             {
 981               segT seg1;
 982               segT seg2;
 983 #ifndef MANY_SEGMENTS
 984
 985               know (resultP->X_seg == SEG_DATA || resultP->X_seg == SEG_TEXT || resultP->X_seg == SEG_BSS || resultP->X_seg == SEG_UNKNOWN || resultP->X_seg == SEG_DIFFERENCE || resultP->X_seg == SEG_ABSOLUTE || resultP->X_seg == SEG_PASS1 || resultP->X_seg == SEG_REGISTER);
 986
 987               know (right.X_seg == SEG_DATA || right.X_seg == SEG_TEXT || right.X_seg == SEG_BSS || right.X_seg == SEG_UNKNOWN || right.X_seg == SEG_DIFFERENCE || right.X_seg == SEG_ABSOLUTE || right.X_seg == SEG_PASS1);
 988 #endif
 989               clean_up_expression (&right);
 990               clean_up_expression (resultP);
 991
 992               seg1 = expr_part (&resultP->X_add_symbol, right.X_add_symbol);
 993               seg2 = expr_part (&resultP->X_subtract_symbol, right.X_subtract_symbol);
 994               if (seg1 == SEG_PASS1 || seg2 == SEG_PASS1)
 995                 {
 996                   need_pass_2 = 1;
 997                   resultP->X_seg = SEG_PASS1;
 998                 }
 999               else if (seg2 == SEG_ABSOLUTE)
1000                 resultP->X_seg = seg1;
1001               else if (seg1 != SEG_UNKNOWN
1002                        && seg1 != SEG_ABSOLUTE
1003                        && seg2 != SEG_UNKNOWN
1004                        && seg1 != seg2)
1005                 {
1006                   know (seg2 != SEG_ABSOLUTE);
1007                   know (resultP->X_subtract_symbol);
1008 #ifndef MANY_SEGMENTS
1009                   know (seg1 == SEG_TEXT || seg1 == SEG_DATA || seg1 == SEG_BSS);
1010                   know (seg2 == SEG_TEXT || seg2 == SEG_DATA || seg2 == SEG_BSS);
1011 #endif
1012                   know (resultP->X_add_symbol);
1013                   know (resultP->X_subtract_symbol);
1014                   as_bad ("Expression too complex: forgetting %s - %s",
1015                           S_GET_NAME (resultP->X_add_symbol),
1016                           S_GET_NAME (resultP->X_subtract_symbol));
1017                   resultP->X_seg = SEG_ABSOLUTE;
1018                   /* Clean_up_expression() will do the rest. */
1019                 }
1020               else
1021                 resultP->X_seg = SEG_DIFFERENCE;
1022
1023               resultP->X_add_number += right.X_add_number;
1024               clean_up_expression (resultP);
1025             }
1026           else
1027             {                   /* Not +. */
1028               if (resultP->X_seg == SEG_UNKNOWN || right.X_seg == SEG_UNKNOWN)
1029                 {
1030                   resultP->X_seg = SEG_PASS1;
1031                   need_pass_2 = 1;
1032                 }
1033               else
1034                 {
1035                   resultP->X_subtract_symbol = NULL;
1036                   resultP->X_add_symbol = NULL;
1037                   /* Will be SEG_ABSOLUTE. */
1038                   if (resultP->X_seg != SEG_ABSOLUTE || right.X_seg != SEG_ABSOLUTE)
1039                     {
1040                       as_bad ("Relocation error. Absolute 0 assumed.");
1041                       resultP->X_seg = SEG_ABSOLUTE;
1042                       resultP->X_add_number = 0;
1043                     }
1044                   else
1045                     {
1046                       switch (op_left)
1047                         {
1048                         case O_bit_inclusive_or:
1049                           resultP->X_add_number |= right.X_add_number;
1050                           break;
1051
1052                         case O_modulus:
1053                           if (right.X_add_number)
1054                             {
1055                               resultP->X_add_number %= right.X_add_number;
1056                             }
1057                           else
1058                             {
1059                               as_warn ("Division by 0. 0 assumed.");
1060                               resultP->X_add_number = 0;
1061                             }
1062                           break;
1063
1064                         case O_bit_and:
1065                           resultP->X_add_number &= right.X_add_number;
1066                           break;
1067
1068                         case O_multiply:
1069                           resultP->X_add_number *= right.X_add_number;
1070                           break;
1071
1072                         case O_divide:
1073                           if (right.X_add_number)
1074                             {
1075                               resultP->X_add_number /= right.X_add_number;
1076                             }
1077                           else
1078                             {
1079                               as_warn ("Division by 0. 0 assumed.");
1080                               resultP->X_add_number = 0;
1081                             }
1082                           break;
1083
1084                         case O_left_shift:
1085                           resultP->X_add_number <<= right.X_add_number;
1086                           break;
1087
1088                         case O_right_shift:
1089                           resultP->X_add_number >>= right.X_add_number;
1090                           break;
1091
1092                         case O_bit_exclusive_or:
1093                           resultP->X_add_number ^= right.X_add_number;
1094                           break;
1095
1096                         case O_bit_or_not:
1097                           resultP->X_add_number |= ~right.X_add_number;
1098                           break;
1099
1100                         default:
1101                           BAD_CASE (op_left);
1102                           break;
1103                         }       /* switch(operator) */
1104                     }
1105                 }               /* If we have to force need_pass_2. */
1106             }                   /* If operator was +. */
1107         }                       /* If we didn't set need_pass_2. */
1108       op_left = op_right;
1109     }                           /* While next operator is >= this rank. */
1110   return (resultP->X_seg);
1111 }
1112 \f
1113 /*
1114  *                      get_symbol_end()
1115  *
1116  * This lives here because it belongs equally in expr.c & read.c.
1117  * Expr.c is just a branch office read.c anyway, and putting it
1118  * here lessens the crowd at read.c.
1119  *
1120  * Assume input_line_pointer is at start of symbol name.
1121  * Advance input_line_pointer past symbol name.
1122  * Turn that character into a '\0', returning its former value.
1123  * This allows a string compare (RMS wants symbol names to be strings)
1124  * of the symbol name.
1125  * There will always be a char following symbol name, because all good
1126  * lines end in end-of-line.
1127  */
1128 char
1129 get_symbol_end ()
1130 {
1131   register char c;
1132
1133   while (is_part_of_name (c = *input_line_pointer++))
1134     ;
1135   *--input_line_pointer = 0;
1136   return (c);
1137 }
1138
1139
1140 unsigned int
1141 get_single_number ()
1142 {
1143   expressionS exp;
1144   operand (&exp);
1145   return exp.X_add_number;
1146
1147 }
1148
1149 /* end of expr.c */