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
 369
 370
 371   SKIP_WHITESPACE ();           /* leading whitespace is part of operand. */
 372   c = *input_line_pointer++;    /* input_line_pointer->past char in c. */
 373
 374   switch (c)
 375     {
 376 #ifdef MRI
 377     case '%':
 378       integer_constant (2, expressionP);
 379       break;
 380     case '@':
 381       integer_constant (8, expressionP);
 382       break;
 383     case '$':
 384       integer_constant (16, expressionP);
 385       break;
 386 #endif
 387     case '1':
 388     case '2':
 389     case '3':
 390     case '4':
 391     case '5':
 392     case '6':
 393     case '7':
 394     case '8':
 395     case '9':
 396       input_line_pointer--;
 397
 398       integer_constant (10, expressionP);
 399       break;
 400
 401     case '0':
 402       /* non-decimal radix */
 403
 404
 405       c = *input_line_pointer;
 406       switch (c)
 407         {
 408
 409         default:
 410           if (c && strchr (FLT_CHARS, c))
 411             {
 412               input_line_pointer++;
 413               floating_constant (expressionP);
 414             }
 415           else
 416             {
 417               /* The string was only zero */
 418               expressionP->X_add_symbol = 0;
 419               expressionP->X_add_number = 0;
 420               expressionP->X_seg = SEG_ABSOLUTE;
 421             }
 422
 423           break;
 424
 425         case 'x':
 426         case 'X':
 427           input_line_pointer++;
 428           integer_constant (16, expressionP);
 429           break;
 430
 431         case 'b':
 432 #ifdef LOCAL_LABELS_FB
 433           if (!*input_line_pointer
 434               || (!strchr ("+-.0123456789", *input_line_pointer)
 435                   && !strchr (EXP_CHARS, *input_line_pointer)))
 436             {
 437               input_line_pointer--;
 438               integer_constant (10, expressionP);
 439               break;
 440             }
 441 #endif
 442         case 'B':
 443           input_line_pointer++;
 444           integer_constant (2, expressionP);
 445           break;
 446
 447         case '0':
 448         case '1':
 449         case '2':
 450         case '3':
 451         case '4':
 452         case '5':
 453         case '6':
 454         case '7':
 455           integer_constant (8, expressionP);
 456           break;
 457
 458         case 'f':
 459 #ifdef LOCAL_LABELS_FB
 460           /* if it says '0f' and the line ends or it doesn't look like
 461          a floating point #, its a local label ref.  dtrt */
 462           /* likewise for the b's.  xoxorich. */
 463           if (c == 'f'
 464               && (!*input_line_pointer ||
 465                   (!strchr ("+-.0123456789", *input_line_pointer) &&
 466                    !strchr (EXP_CHARS, *input_line_pointer))))
 467             {
 468               input_line_pointer -= 1;
 469               integer_constant (10, expressionP);
 470               break;
 471             }
 472 #endif
 473
 474         case 'd':
 475         case 'D':
 476         case 'F':
 477         case 'r':
 478         case 'e':
 479         case 'E':
 480         case 'g':
 481         case 'G':
 482
 483           input_line_pointer++;
 484           floating_constant (expressionP);
 485           break;
 486
 487 #ifdef LOCAL_LABELS_DOLLAR
 488         case '$':
 489           integer_constant (10, expressionP);
 490           break;
 491 #endif
 492         }
 493
 494       break;
 495     case '(':
 496       /* didn't begin with digit & not a name */
 497       {
 498         (void) expression (expressionP);
 499         /* Expression() will pass trailing whitespace */
 500         if (*input_line_pointer++ != ')')
 501           {
 502             as_bad ("Missing ')' assumed");
 503             input_line_pointer--;
 504           }
 505         /* here with input_line_pointer->char after "(...)" */
 506       }
 507       return expressionP->X_seg;
 508
 509
 510     case '\'':
 511       /*
 512      * Warning: to conform to other people's assemblers NO ESCAPEMENT is permitted
 513      * for a single quote. The next character, parity errors and all, is taken
 514      * as the value of the operand. VERY KINKY.
 515      */
 516       expressionP->X_add_number = *input_line_pointer++;
 517       expressionP->X_seg = SEG_ABSOLUTE;
 518       break;
 519
 520     case '~':
 521     case '-':
 522     case '+':
 523
 524       {
 525         /* unary operator: hope for SEG_ABSOLUTE */
 526         switch (operand (expressionP))
 527           {
 528           case SEG_ABSOLUTE:
 529             /* input_line_pointer -> char after operand */
 530             if (c == '-')
 531               {
 532                 expressionP->X_add_number = -expressionP->X_add_number;
 533                 /*
 534            * Notice: '-' may  overflow: no warning is given. This is compatible
 535            * with other people's assemblers. Sigh.
 536            */
 537               }
 538             else
 539               {
 540                 expressionP->X_add_number = ~expressionP->X_add_number;
 541               }
 542             break;
 543
 544           case SEG_TEXT:
 545           case SEG_DATA:
 546           case SEG_BSS:
 547           case SEG_PASS1:
 548           case SEG_UNKNOWN:
 549             if (c == '-')
 550               {                 /* JF I hope this hack works */
 551                 expressionP->X_subtract_symbol = expressionP->X_add_symbol;
 552                 expressionP->X_add_symbol = 0;
 553                 expressionP->X_seg = SEG_DIFFERENCE;
 554                 break;
 555               }
 556           default:              /* unary on non-absolute is unsuported */
 557             as_warn ("Unary operator %c ignored because bad operand follows", c);
 558             break;
 559             /* Expression undisturbed from operand(). */
 560           }
 561       }
 562
 563
 564
 565       break;
 566
 567     case '.':
 568       if (!is_part_of_name (*input_line_pointer))
 569         {
 570           extern struct obstack frags;
 571
 572           /*
 573         JF:  '.' is pseudo symbol with value of current location in current
 574         segment. . .
 575         */
 576           symbolP = symbol_new ("L0\001",
 577                                 now_seg,
 578                (valueT) (obstack_next_free (&frags) - frag_now->fr_literal),
 579                                 frag_now);
 580
 581           expressionP->X_add_number = 0;
 582           expressionP->X_add_symbol = symbolP;
 583           expressionP->X_seg = now_seg;
 584           break;
 585
 586         }
 587       else
 588         {
 589           goto isname;
 590
 591
 592         }
 593     case ',':
 594     case '\n':
 595       /* can't imagine any other kind of operand */
 596       expressionP->X_seg = SEG_ABSENT;
 597       input_line_pointer--;
 598       md_operand (expressionP);
 599       break;
 600       /* Fall through */
 601     default:
 602       if (is_name_beginner (c)) /* here if did not begin with a digit */
 603         {
 604           /*
 605        * Identifier begins here.
 606        * This is kludged for speed, so code is repeated.
 607        */
 608         isname:
 609           name = --input_line_pointer;
 610           c = get_symbol_end ();
 611           symbolP = symbol_find_or_make (name);
 612           /*
 613        * If we have an absolute symbol or a reg, then we know its value now.
 614        */
 615           expressionP->X_seg = S_GET_SEGMENT (symbolP);
 616           switch (expressionP->X_seg)
 617             {
 618             case SEG_ABSOLUTE:
 619             case SEG_REGISTER:
 620               expressionP->X_add_number = S_GET_VALUE (symbolP);
 621               break;
 622
 623             default:
 624               expressionP->X_add_number = 0;
 625               expressionP->X_add_symbol = symbolP;
 626             }
 627           *input_line_pointer = c;
 628           expressionP->X_subtract_symbol = NULL;
 629         }
 630       else
 631         {
 632           as_bad ("Bad expression");
 633           expressionP->X_add_number = 0;
 634           expressionP->X_seg = SEG_ABSOLUTE;
 635
 636         }
 637
 638     }
 639
 640
 641
 642
 643
 644
 645
 646   /*
 647    * It is more 'efficient' to clean up the expressionS when they are created.
 648    * Doing it here saves lines of code.
 649    */
 650   clean_up_expression (expressionP);
 651   SKIP_WHITESPACE ();           /*->1st char after operand. */
 652   know (*input_line_pointer != ' ');
 653   return (expressionP->X_seg);
 654 }                               /* operand() */
 655 \f
 656
 657 /* Internal. Simplify a struct expression for use by expr() */
 658
 659 /*
 660  * In:  address of a expressionS.
 661  *      The X_seg field of the expressionS may only take certain values.
 662  *      Now, we permit SEG_PASS1 to make code smaller & faster.
 663  *      Elsewise we waste time special-case testing. Sigh. Ditto SEG_ABSENT.
 664  * Out: expressionS may have been modified:
 665  *      'foo-foo' symbol references cancelled to 0,
 666  *              which changes X_seg from SEG_DIFFERENCE to SEG_ABSOLUTE;
 667  *      Unused fields zeroed to help expr().
 668  */
 669
 670 static void
 671 clean_up_expression (expressionP)
 672      register expressionS *expressionP;
 673 {
 674   switch (expressionP->X_seg)
 675     {
 676     case SEG_ABSENT:
 677     case SEG_PASS1:
 678       expressionP->X_add_symbol = NULL;
 679       expressionP->X_subtract_symbol = NULL;
 680       expressionP->X_add_number = 0;
 681       break;
 682
 683     case SEG_BIG:
 684     case SEG_ABSOLUTE:
 685       expressionP->X_subtract_symbol = NULL;
 686       expressionP->X_add_symbol = NULL;
 687       break;
 688
 689     case SEG_UNKNOWN:
 690       expressionP->X_subtract_symbol = NULL;
 691       break;
 692
 693     case SEG_DIFFERENCE:
 694       /*
 695          * It does not hurt to 'cancel' NULL==NULL
 696          * when comparing symbols for 'eq'ness.
 697          * It is faster to re-cancel them to NULL
 698          * than to check for this special case.
 699          */
 700       if (expressionP->X_subtract_symbol == expressionP->X_add_symbol
 701           || (expressionP->X_subtract_symbol
 702               && expressionP->X_add_symbol
 703               && expressionP->X_subtract_symbol->sy_frag == expressionP->X_add_symbol->sy_frag
 704               && S_GET_VALUE (expressionP->X_subtract_symbol) == S_GET_VALUE (expressionP->X_add_symbol)))
 705         {
 706           expressionP->X_subtract_symbol = NULL;
 707           expressionP->X_add_symbol = NULL;
 708           expressionP->X_seg = SEG_ABSOLUTE;
 709         }
 710       break;
 711
 712     case SEG_REGISTER:
 713       expressionP->X_add_symbol = NULL;
 714       expressionP->X_subtract_symbol = NULL;
 715       break;
 716
 717     default:
 718       if (SEG_NORMAL (expressionP->X_seg))
 719         {
 720           expressionP->X_subtract_symbol = NULL;
 721         }
 722       else
 723         {
 724           BAD_CASE (expressionP->X_seg);
 725         }
 726       break;
 727     }
 728 }                               /* clean_up_expression() */
 729 \f
 730 /*
 731  *                      expr_part ()
 732  *
 733  * Internal. Made a function because this code is used in 2 places.
 734  * Generate error or correct X_?????_symbol of expressionS.
 735  */
 736
 737 /*
 738  * symbol_1 += symbol_2 ... well ... sort of.
 739  */
 740
 741 static segT
 742 expr_part (symbol_1_PP, symbol_2_P)
 743      symbolS **symbol_1_PP;
 744      symbolS *symbol_2_P;
 745 {
 746   segT return_value;
 747 #ifndef MANY_SEGMENTS
 748   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)));
 749   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)));
 750 #endif
 751   if (*symbol_1_PP)
 752     {
 753       if (!S_IS_DEFINED (*symbol_1_PP))
 754         {
 755           if (symbol_2_P)
 756             {
 757               return_value = SEG_PASS1;
 758               *symbol_1_PP = NULL;
 759             }
 760           else
 761             {
 762               know (!S_IS_DEFINED (*symbol_1_PP));
 763               return_value = SEG_UNKNOWN;
 764             }
 765         }
 766       else
 767         {
 768           if (symbol_2_P)
 769             {
 770               if (!S_IS_DEFINED (symbol_2_P))
 771                 {
 772                   *symbol_1_PP = NULL;
 773                   return_value = SEG_PASS1;
 774                 }
 775               else
 776                 {
 777                   /* {seg1} - {seg2} */
 778                   as_bad ("Expression too complex, 2 symbolS forgotten: \"%s\" \"%s\"",
 779                         S_GET_NAME (*symbol_1_PP), S_GET_NAME (symbol_2_P));
 780                   *symbol_1_PP = NULL;
 781                   return_value = SEG_ABSOLUTE;
 782                 }
 783             }
 784           else
 785             {
 786               return_value = S_GET_SEGMENT (*symbol_1_PP);
 787             }
 788         }
 789     }
 790   else
 791     {                           /* (* symbol_1_PP) == NULL */
 792       if (symbol_2_P)
 793         {
 794           *symbol_1_PP = symbol_2_P;
 795           return_value = S_GET_SEGMENT (symbol_2_P);
 796         }
 797       else
 798         {
 799           *symbol_1_PP = NULL;
 800           return_value = SEG_ABSOLUTE;
 801         }
 802     }
 803 #ifndef MANY_SEGMENTS
 804   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);
 805 #endif
 806   know ((*symbol_1_PP) == NULL || (S_GET_SEGMENT (*symbol_1_PP) == return_value));
 807   return (return_value);
 808 }                               /* expr_part() */
 809 \f
 810 /* Expression parser. */
 811
 812 /*
 813  * We allow an empty expression, and just assume (absolute,0) silently.
 814  * Unary operators and parenthetical expressions are treated as operands.
 815  * As usual, Q==quantity==operand, O==operator, X==expression mnemonics.
 816  *
 817  * We used to do a aho/ullman shift-reduce parser, but the logic got so
 818  * warped that I flushed it and wrote a recursive-descent parser instead.
 819  * Now things are stable, would anybody like to write a fast parser?
 820  * Most expressions are either register (which does not even reach here)
 821  * or 1 symbol. Then "symbol+constant" and "symbol-symbol" are common.
 822  * So I guess it doesn't really matter how inefficient more complex expressions
 823  * are parsed.
 824  *
 825  * After expr(RANK,resultP) input_line_pointer->operator of rank <= RANK.
 826  * Also, we have consumed any leading or trailing spaces (operand does that)
 827  * and done all intervening operators.
 828  */
 829
 830 typedef enum
 831 {
 832   O_illegal,                    /* (0)  what we get for illegal op */
 833
 834   O_multiply,                   /* (1)  * */
 835   O_divide,                     /* (2)  / */
 836   O_modulus,                    /* (3)  % */
 837   O_left_shift,                 /* (4)  < */
 838   O_right_shift,                /* (5)  > */
 839   O_bit_inclusive_or,           /* (6)  | */
 840   O_bit_or_not,                 /* (7)  ! */
 841   O_bit_exclusive_or,           /* (8)  ^ */
 842   O_bit_and,                    /* (9)  & */
 843   O_add,                        /* (10) + */
 844   O_subtract                    /* (11) - */
 845 }
 846
 847 operatorT;
 848
 849 #define __ O_illegal
 850
 851 static const operatorT op_encoding[256] =
 852 {                               /* maps ASCII->operators */
 853
 854   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
 855   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
 856
 857   __, O_bit_or_not, __, __, __, O_modulus, O_bit_and, __,
 858   __, __, O_multiply, O_add, __, O_subtract, __, O_divide,
 859   __, __, __, __, __, __, __, __,
 860   __, __, __, __, O_left_shift, __, O_right_shift, __,
 861   __, __, __, __, __, __, __, __,
 862   __, __, __, __, __, __, __, __,
 863   __, __, __, __, __, __, __, __,
 864   __, __, __, __, __, __, O_bit_exclusive_or, __,
 865   __, __, __, __, __, __, __, __,
 866   __, __, __, __, __, __, __, __,
 867   __, __, __, __, __, __, __, __,
 868   __, __, __, __, O_bit_inclusive_or, __, __, __,
 869
 870   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
 871   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
 872   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
 873   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
 874   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
 875   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
 876   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
 877   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __
 878 };
 879
 880
 881 /*
 882  *      Rank    Examples
 883  *      0       operand, (expression)
 884  *      1       + -
 885  *      2       & ^ ! |
 886  *      3       * / % << >>
 887  */
 888 static const operator_rankT
 889   op_rank[] =
 890 {0, 3, 3, 3, 3, 3, 2, 2, 2, 2, 1, 1};
 891 \f
 892 /* Return resultP->X_seg. */
 893 segT
 894 expr (rank, resultP)
 895      register operator_rankT rank;      /* Larger # is higher rank. */
 896      register expressionS *resultP;     /* Deliver result here. */
 897 {
 898   expressionS right;
 899   register operatorT op_left;
 900   register char c_left;         /* 1st operator character. */
 901   register operatorT op_right;
 902   register char c_right;
 903
 904   know (rank >= 0);
 905   (void) operand (resultP);
 906   know (*input_line_pointer != ' ');    /* Operand() gobbles spaces. */
 907   c_left = *input_line_pointer; /* Potential operator character. */
 908   op_left = op_encoding[c_left];
 909   while (op_left != O_illegal && op_rank[(int) op_left] > rank)
 910     {
 911       input_line_pointer++;     /*->after 1st character of operator. */
 912       /* Operators "<<" and ">>" have 2 characters. */
 913       if (*input_line_pointer == c_left && (c_left == '<' || c_left == '>'))
 914         {
 915           input_line_pointer++;
 916         }                       /*->after operator. */
 917       if (SEG_ABSENT == expr (op_rank[(int) op_left], &right))
 918         {
 919           as_warn ("Missing operand value assumed absolute 0.");
 920           resultP->X_add_number = 0;
 921           resultP->X_subtract_symbol = NULL;
 922           resultP->X_add_symbol = NULL;
 923           resultP->X_seg = SEG_ABSOLUTE;
 924         }
 925       know (*input_line_pointer != ' ');
 926       c_right = *input_line_pointer;
 927       op_right = op_encoding[c_right];
 928       if (*input_line_pointer == c_right && (c_right == '<' || c_right == '>'))
 929         {
 930           input_line_pointer++;
 931         }                       /*->after operator. */
 932       know ((int) op_right == 0 || op_rank[(int) op_right] <= op_rank[(int) op_left]);
 933       /* input_line_pointer->after right-hand quantity. */
 934       /* left-hand quantity in resultP */
 935       /* right-hand quantity in right. */
 936       /* operator in op_left. */
 937       if (resultP->X_seg == SEG_PASS1 || right.X_seg == SEG_PASS1)
 938         {
 939           resultP->X_seg = SEG_PASS1;
 940         }
 941       else
 942         {
 943           if (resultP->X_seg == SEG_BIG)
 944             {
 945               as_warn ("Left operand of %c is a %s.  Integer 0 assumed.",
 946                     c_left, resultP->X_add_number > 0 ? "bignum" : "float");
 947               resultP->X_seg = SEG_ABSOLUTE;
 948               resultP->X_add_symbol = 0;
 949               resultP->X_subtract_symbol = 0;
 950               resultP->X_add_number = 0;
 951             }
 952           if (right.X_seg == SEG_BIG)
 953             {
 954               as_warn ("Right operand of %c is a %s.  Integer 0 assumed.",
 955                        c_left, right.X_add_number > 0 ? "bignum" : "float");
 956               right.X_seg = SEG_ABSOLUTE;
 957               right.X_add_symbol = 0;
 958               right.X_subtract_symbol = 0;
 959               right.X_add_number = 0;
 960             }
 961           if (op_left == O_subtract)
 962             {
 963               /*
 964                * Convert - into + by exchanging symbolS and negating number.
 965                * I know -infinity can't be negated in 2's complement:
 966                * but then it can't be subtracted either. This trick
 967                * does not cause any further inaccuracy.
 968                */
 969
 970               register symbolS *symbolP;
 971
 972               right.X_add_number = -right.X_add_number;
 973               symbolP = right.X_add_symbol;
 974               right.X_add_symbol = right.X_subtract_symbol;
 975               right.X_subtract_symbol = symbolP;
 976               if (symbolP)
 977                 {
 978                   right.X_seg = SEG_DIFFERENCE;
 979                 }
 980               op_left = O_add;
 981             }
 982 \f
 983           if (op_left == O_add)
 984             {
 985               segT seg1;
 986               segT seg2;
 987 #ifndef MANY_SEGMENTS
 988
 989               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);
 990
 991               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);
 992 #endif
 993               clean_up_expression (&right);
 994               clean_up_expression (resultP);
 995
 996               seg1 = expr_part (&resultP->X_add_symbol, right.X_add_symbol);
 997               seg2 = expr_part (&resultP->X_subtract_symbol, right.X_subtract_symbol);
 998               if (seg1 == SEG_PASS1 || seg2 == SEG_PASS1)
 999                 {
1000                   need_pass_2 = 1;
1001                   resultP->X_seg = SEG_PASS1;
1002                 }
1003               else if (seg2 == SEG_ABSOLUTE)
1004                 resultP->X_seg = seg1;
1005               else if (seg1 != SEG_UNKNOWN
1006                        && seg1 != SEG_ABSOLUTE
1007                        && seg2 != SEG_UNKNOWN
1008                        && seg1 != seg2)
1009                 {
1010                   know (seg2 != SEG_ABSOLUTE);
1011                   know (resultP->X_subtract_symbol);
1012 #ifndef MANY_SEGMENTS
1013                   know (seg1 == SEG_TEXT || seg1 == SEG_DATA || seg1 == SEG_BSS);
1014                   know (seg2 == SEG_TEXT || seg2 == SEG_DATA || seg2 == SEG_BSS);
1015 #endif
1016                   know (resultP->X_add_symbol);
1017                   know (resultP->X_subtract_symbol);
1018                   as_bad ("Expression too complex: forgetting %s - %s",
1019                           S_GET_NAME (resultP->X_add_symbol),
1020                           S_GET_NAME (resultP->X_subtract_symbol));
1021                   resultP->X_seg = SEG_ABSOLUTE;
1022                   /* Clean_up_expression() will do the rest. */
1023                 }
1024               else
1025                 resultP->X_seg = SEG_DIFFERENCE;
1026
1027               resultP->X_add_number += right.X_add_number;
1028               clean_up_expression (resultP);
1029             }
1030           else
1031             {                   /* Not +. */
1032               if (resultP->X_seg == SEG_UNKNOWN || right.X_seg == SEG_UNKNOWN)
1033                 {
1034                   resultP->X_seg = SEG_PASS1;
1035                   need_pass_2 = 1;
1036                 }
1037               else
1038                 {
1039                   resultP->X_subtract_symbol = NULL;
1040                   resultP->X_add_symbol = NULL;
1041                   /* Will be SEG_ABSOLUTE. */
1042                   if (resultP->X_seg != SEG_ABSOLUTE || right.X_seg != SEG_ABSOLUTE)
1043                     {
1044                       as_bad ("Relocation error. Absolute 0 assumed.");
1045                       resultP->X_seg = SEG_ABSOLUTE;
1046                       resultP->X_add_number = 0;
1047                     }
1048                   else
1049                     {
1050                       switch (op_left)
1051                         {
1052                         case O_bit_inclusive_or:
1053                           resultP->X_add_number |= right.X_add_number;
1054                           break;
1055
1056                         case O_modulus:
1057                           if (right.X_add_number)
1058                             {
1059                               resultP->X_add_number %= right.X_add_number;
1060                             }
1061                           else
1062                             {
1063                               as_warn ("Division by 0. 0 assumed.");
1064                               resultP->X_add_number = 0;
1065                             }
1066                           break;
1067
1068                         case O_bit_and:
1069                           resultP->X_add_number &= right.X_add_number;
1070                           break;
1071
1072                         case O_multiply:
1073                           resultP->X_add_number *= right.X_add_number;
1074                           break;
1075
1076                         case O_divide:
1077                           if (right.X_add_number)
1078                             {
1079                               resultP->X_add_number /= right.X_add_number;
1080                             }
1081                           else
1082                             {
1083                               as_warn ("Division by 0. 0 assumed.");
1084                               resultP->X_add_number = 0;
1085                             }
1086                           break;
1087
1088                         case O_left_shift:
1089                           resultP->X_add_number <<= right.X_add_number;
1090                           break;
1091
1092                         case O_right_shift:
1093                           resultP->X_add_number >>= right.X_add_number;
1094                           break;
1095
1096                         case O_bit_exclusive_or:
1097                           resultP->X_add_number ^= right.X_add_number;
1098                           break;
1099
1100                         case O_bit_or_not:
1101                           resultP->X_add_number |= ~right.X_add_number;
1102                           break;
1103
1104                         default:
1105                           BAD_CASE (op_left);
1106                           break;
1107                         }       /* switch(operator) */
1108                     }
1109                 }               /* If we have to force need_pass_2. */
1110             }                   /* If operator was +. */
1111         }                       /* If we didn't set need_pass_2. */
1112       op_left = op_right;
1113     }                           /* While next operator is >= this rank. */
1114   return (resultP->X_seg);
1115 }
1116 \f
1117 /*
1118  *                      get_symbol_end()
1119  *
1120  * This lives here because it belongs equally in expr.c & read.c.
1121  * Expr.c is just a branch office read.c anyway, and putting it
1122  * here lessens the crowd at read.c.
1123  *
1124  * Assume input_line_pointer is at start of symbol name.
1125  * Advance input_line_pointer past symbol name.
1126  * Turn that character into a '\0', returning its former value.
1127  * This allows a string compare (RMS wants symbol names to be strings)
1128  * of the symbol name.
1129  * There will always be a char following symbol name, because all good
1130  * lines end in end-of-line.
1131  */
1132 char
1133 get_symbol_end ()
1134 {
1135   register char c;
1136
1137   while (is_part_of_name (c = *input_line_pointer++))
1138     ;
1139   *--input_line_pointer = 0;
1140   return (c);
1141 }
1142
1143
1144 unsigned int
1145 get_single_number ()
1146 {
1147   expressionS exp;
1148   operand (&exp);
1149   return exp.X_add_number;
1150
1151 }
1152
1153 /*
1154  * Local Variables:
1155  * comment-column: 0
1156  * fill-column: 131
1157  * End:
1158  */
1159
1160 /* end of expr.c */