1 /* expr.c -operands, expressions-
2 Copyright (C) 1987, 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
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)
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.
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. */
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.
34 static void floating_constant PARAMS ((expressionS * expressionP));
35 static void integer_constant PARAMS ((int radix, expressionS * expressionP));
36 static void clean_up_expression PARAMS ((expressionS * expressionP));
37 static symbolS *make_expr_symbol PARAMS ((expressionS * expressionP));
39 extern const char EXP_CHARS[], FLT_CHARS[];
41 /* Build a dummy symbol to hold a complex expression. This is how we
42 build expressions up out of other expressions. The symbol is put
43 into the fake section expr_section. */
46 make_expr_symbol (expressionP)
47 expressionS *expressionP;
52 /* FIXME: This should be something which decode_local_label_name
54 fake = FAKE_LABEL_NAME;
56 /* Putting constant symbols in absolute_section rather than
57 expr_section is convenient for the old a.out code, for which
58 S_GET_SEGMENT does not always retrieve the value put in by
60 symbolP = symbol_new (fake,
61 (expressionP->X_op == O_constant
64 0, &zero_address_frag);
65 symbolP->sy_value = *expressionP;
70 * Build any floating-point literal here.
71 * Also build any bignum literal here.
74 /* Seems atof_machine can backscan through generic_bignum and hit whatever
75 happens to be loaded before it in memory. And its way too complicated
76 for me to fix right. Thus a hack. JF: Just make generic_bignum bigger,
77 and never write into the early words, thus they'll always be zero.
78 I hate Dean's floating-point code. Bleh. */
79 LITTLENUM_TYPE generic_bignum[SIZE_OF_LARGE_NUMBER + 6];
80 FLONUM_TYPE generic_floating_point_number =
82 &generic_bignum[6], /* low (JF: Was 0) */
83 &generic_bignum[SIZE_OF_LARGE_NUMBER + 6 - 1], /* high JF: (added +6) */
88 /* If nonzero, we've been asked to assemble nan, +inf or -inf */
89 int generic_floating_point_magic;
92 floating_constant (expressionP)
93 expressionS *expressionP;
95 /* input_line_pointer->*/
96 /* floating-point constant. */
99 error_code = atof_generic
100 (&input_line_pointer, ".", EXP_CHARS,
101 &generic_floating_point_number);
105 if (error_code == ERROR_EXPONENT_OVERFLOW)
107 as_bad ("bad floating-point constant: exponent overflow, probably assembling junk");
111 as_bad ("bad floating-point constant: unknown error code=%d.", error_code);
114 expressionP->X_op = O_big;
115 /* input_line_pointer->just after constant, */
116 /* which may point to whitespace. */
117 expressionP->X_add_number = -1;
121 integer_constant (radix, expressionP)
123 expressionS *expressionP;
125 char *start; /* start of number. */
128 valueT number; /* offset or (absolute) value */
129 short int digit; /* value of next digit in current radix */
130 short int maxdig = 0;/* highest permitted digit value. */
131 int too_many_digits = 0; /* if we see >= this number of */
132 char *name; /* points to name of symbol */
133 symbolS *symbolP; /* points to symbol */
135 int small; /* true if fits in 32 bits. */
136 extern const char hex_value[]; /* in hex_value.c */
138 /* May be bignum, or may fit in 32 bits. */
139 /* Most numbers fit into 32 bits, and we want this case to be fast.
140 so we pretend it will fit into 32 bits. If, after making up a 32
141 bit number, we realise that we have scanned more digits than
142 comfortably fit into 32 bits, we re-scan the digits coding them
143 into a bignum. For decimal and octal numbers we are
144 conservative: Some numbers may be assumed bignums when in fact
145 they do fit into 32 bits. Numbers of any radix can have excess
146 leading zeros: We strive to recognise this and cast them back
147 into 32 bits. We must check that the bignum really is more than
148 32 bits, and change it back to a 32-bit number if it fits. The
149 number we are looking for is expected to be positive, but if it
150 fits into 32 bits as an unsigned number, we let it be a 32-bit
151 number. The cavalier approach is for speed in ordinary cases. */
152 /* This has been extended for 64 bits. We blindly assume that if
153 you're compiling in 64-bit mode, the target is a 64-bit machine.
154 This should be cleaned up. */
158 #else /* includes non-bfd case, mostly */
166 too_many_digits = valuesize + 1;
170 too_many_digits = (valuesize + 2) / 3 + 1;
174 too_many_digits = (valuesize + 3) / 4 + 1;
178 too_many_digits = (valuesize + 12) / 4; /* very rough */
181 start = input_line_pointer;
182 c = *input_line_pointer++;
184 (digit = hex_value[(unsigned char) c]) < maxdig;
185 c = *input_line_pointer++)
187 number = number * radix + digit;
189 /* c contains character after number. */
190 /* input_line_pointer->char after c. */
191 small = (input_line_pointer - start - 1) < too_many_digits;
195 * we saw a lot of digits. manufacture a bignum the hard way.
197 LITTLENUM_TYPE *leader; /*->high order littlenum of the bignum. */
198 LITTLENUM_TYPE *pointer; /*->littlenum we are frobbing now. */
201 leader = generic_bignum;
202 generic_bignum[0] = 0;
203 generic_bignum[1] = 0;
204 input_line_pointer = start; /*->1st digit. */
205 c = *input_line_pointer++;
207 (carry = hex_value[(unsigned char) c]) < maxdig;
208 c = *input_line_pointer++)
210 for (pointer = generic_bignum;
216 work = carry + radix * *pointer;
217 *pointer = work & LITTLENUM_MASK;
218 carry = work >> LITTLENUM_NUMBER_OF_BITS;
222 if (leader < generic_bignum + SIZE_OF_LARGE_NUMBER - 1)
223 { /* room to grow a longer bignum. */
228 /* again, c is char after number, */
229 /* input_line_pointer->after c. */
230 know (LITTLENUM_NUMBER_OF_BITS == 16);
231 if (leader < generic_bignum + 2)
232 { /* will fit into 32 bits. */
234 ((generic_bignum[1] & LITTLENUM_MASK) << LITTLENUM_NUMBER_OF_BITS)
235 | (generic_bignum[0] & LITTLENUM_MASK);
240 number = leader - generic_bignum + 1; /* number of littlenums in the bignum. */
246 * here with number, in correct radix. c is the next char.
247 * note that unlike un*x, we allow "011f" "0x9f" to
248 * both mean the same as the (conventional) "9f". this is simply easier
249 * than checking for strict canonical form. syntax sux!
255 #ifdef LOCAL_LABELS_FB
259 * backward ref to local label.
260 * because it is backward, expect it to be defined.
262 /* Construct a local label. */
263 name = fb_label_name ((int) number, 0);
265 /* seen before, or symbol is defined: ok */
266 symbolP = symbol_find (name);
267 if ((symbolP != NULL) && (S_IS_DEFINED (symbolP)))
270 /* local labels are never absolute. don't waste time
271 checking absoluteness. */
272 know (SEG_NORMAL (S_GET_SEGMENT (symbolP)));
274 expressionP->X_op = O_symbol;
275 expressionP->X_add_symbol = symbolP;
280 /* either not seen or not defined. */
281 /* @@ Should print out the original string instead of
282 the parsed number. */
283 as_bad ("backw. ref to unknown label \"%d:\", 0 assumed.",
285 expressionP->X_op = O_constant;
288 expressionP->X_add_number = 0;
295 * forward reference. expect symbol to be undefined or
296 * unknown. undefined: seen it before. unknown: never seen
298 * construct a local label name, then an undefined symbol.
299 * don't create a xseg frag for it: caller may do that.
300 * just return it as never seen before.
302 name = fb_label_name ((int) number, 1);
303 symbolP = symbol_find_or_make (name);
304 /* we have no need to check symbol properties. */
305 #ifndef many_segments
306 /* since "know" puts its arg into a "string", we
307 can't have newlines in the argument. */
308 know (S_GET_SEGMENT (symbolP) == undefined_section || S_GET_SEGMENT (symbolP) == text_section || S_GET_SEGMENT (symbolP) == data_section);
310 expressionP->X_op = O_symbol;
311 expressionP->X_add_symbol = symbolP;
312 expressionP->X_add_number = 0;
317 #endif /* LOCAL_LABELS_FB */
319 #ifdef LOCAL_LABELS_DOLLAR
324 /* If the dollar label is *currently* defined, then this is just
325 another reference to it. If it is not *currently* defined,
326 then this is a fresh instantiation of that number, so create
329 if (dollar_label_defined ((long) number))
331 name = dollar_label_name ((long) number, 0);
332 symbolP = symbol_find (name);
333 know (symbolP != NULL);
337 name = dollar_label_name ((long) number, 1);
338 symbolP = symbol_find_or_make (name);
341 expressionP->X_op = O_symbol;
342 expressionP->X_add_symbol = symbolP;
343 expressionP->X_add_number = 0;
348 #endif /* LOCAL_LABELS_DOLLAR */
352 expressionP->X_op = O_constant;
353 expressionP->X_add_number = number;
354 input_line_pointer--; /* restore following character. */
356 } /* really just a number */
358 } /* switch on char following the number */
363 /* not a small number */
364 expressionP->X_op = O_big;
365 expressionP->X_add_number = number; /* number of littlenums */
366 input_line_pointer--; /*->char following number. */
372 * Summary of operand().
374 * in: Input_line_pointer points to 1st char of operand, which may
377 * out: A expressionS.
378 * The operand may have been empty: in this case X_op == O_absent.
379 * Input_line_pointer->(next non-blank) char after operand.
383 operand (expressionP)
384 expressionS *expressionP;
387 symbolS *symbolP; /* points to symbol */
388 char *name; /* points to name of symbol */
391 /* All integers are regarded as unsigned unless they are negated.
392 This is because the only thing which cares whether a number is
393 unsigned is the code in emit_expr which extends constants into
394 bignums. It should only sign extend negative numbers, so that
395 something like ``.quad 0x80000000'' is not sign extended even
396 though it appears negative if valueT is 32 bits. */
397 expressionP->X_unsigned = 1;
399 /* digits, assume it is a bignum. */
401 SKIP_WHITESPACE (); /* leading whitespace is part of operand. */
402 c = *input_line_pointer++; /* input_line_pointer->past char in c. */
408 integer_constant (2, expressionP);
411 integer_constant (8, expressionP);
414 integer_constant (16, expressionP);
426 input_line_pointer--;
428 integer_constant (10, expressionP);
432 /* non-decimal radix */
434 c = *input_line_pointer;
439 if (c && strchr (FLT_CHARS, c))
441 input_line_pointer++;
442 floating_constant (expressionP);
443 expressionP->X_add_number = -(isupper (c) ? tolower (c) : c);
447 /* The string was only zero */
448 expressionP->X_op = O_constant;
449 expressionP->X_add_number = 0;
456 input_line_pointer++;
457 integer_constant (16, expressionP);
461 #ifdef LOCAL_LABELS_FB
462 if (!input_line_pointer[1]
463 /* Strictly speaking, we should only need to check for
464 "+-01", since that's all you'd normally have in a
465 binary constant. But some of our code does permit
466 digits greater than the base we're expecting. */
467 || !strchr ("+-0123456789", input_line_pointer[1]))
469 input_line_pointer--;
470 integer_constant (10, expressionP);
475 input_line_pointer++;
476 integer_constant (2, expressionP);
487 integer_constant (8, expressionP);
491 #ifdef LOCAL_LABELS_FB
492 /* if it says '0f' and the line ends or it doesn't look like
493 a floating point #, its a local label ref. dtrt */
494 /* likewise for the b's. xoxorich. */
496 && (!input_line_pointer[1]
497 || (!strchr ("+-.0123456789", input_line_pointer[1])
498 && !strchr (EXP_CHARS, input_line_pointer[1]))))
500 input_line_pointer -= 1;
501 integer_constant (10, expressionP);
515 input_line_pointer++;
516 floating_constant (expressionP);
517 expressionP->X_add_number = -(isupper (c) ? tolower (c) : c);
520 #ifdef LOCAL_LABELS_DOLLAR
522 integer_constant (10, expressionP);
530 /* didn't begin with digit & not a name */
531 segment = expression (expressionP);
532 /* Expression() will pass trailing whitespace */
533 if (*input_line_pointer++ != ')')
535 as_bad ("Missing ')' assumed");
536 input_line_pointer--;
538 /* here with input_line_pointer->char after "(...)" */
542 /* Warning: to conform to other people's assemblers NO ESCAPEMENT is
543 permitted for a single quote. The next character, parity errors and
544 all, is taken as the value of the operand. VERY KINKY. */
545 expressionP->X_op = O_constant;
546 expressionP->X_add_number = *input_line_pointer++;
550 (void) operand (expressionP);
556 operand (expressionP);
557 if (expressionP->X_op == O_constant)
559 /* input_line_pointer -> char after operand */
562 expressionP->X_add_number = - expressionP->X_add_number;
563 /* Notice: '-' may overflow: no warning is given. This is
564 compatible with other people's assemblers. Sigh. */
565 expressionP->X_unsigned = 0;
568 expressionP->X_add_number = ~ expressionP->X_add_number;
570 else if (expressionP->X_op != O_illegal
571 && expressionP->X_op != O_absent)
573 expressionP->X_add_symbol = make_expr_symbol (expressionP);
575 expressionP->X_op = O_uminus;
577 expressionP->X_op = O_bit_not;
578 expressionP->X_add_number = 0;
581 as_warn ("Unary operator %c ignored because bad operand follows",
587 if (!is_part_of_name (*input_line_pointer))
591 /* JF: '.' is pseudo symbol with value of current location
592 in current segment. */
593 fake = FAKE_LABEL_NAME;
594 symbolP = symbol_new (fake,
596 (valueT) frag_now_fix (),
599 expressionP->X_op = O_symbol;
600 expressionP->X_add_symbol = symbolP;
601 expressionP->X_add_number = 0;
612 /* can't imagine any other kind of operand */
613 expressionP->X_op = O_absent;
614 input_line_pointer--;
615 md_operand (expressionP);
619 if (is_end_of_line[(unsigned char) c])
621 if (is_name_beginner (c)) /* here if did not begin with a digit */
624 * Identifier begins here.
625 * This is kludged for speed, so code is repeated.
628 name = --input_line_pointer;
629 c = get_symbol_end ();
630 symbolP = symbol_find_or_make (name);
632 /* If we have an absolute symbol or a reg, then we know its
634 segment = S_GET_SEGMENT (symbolP);
635 if (segment == absolute_section)
637 expressionP->X_op = O_constant;
638 expressionP->X_add_number = S_GET_VALUE (symbolP);
640 else if (segment == reg_section)
642 expressionP->X_op = O_register;
643 expressionP->X_add_number = S_GET_VALUE (symbolP);
647 expressionP->X_op = O_symbol;
648 expressionP->X_add_symbol = symbolP;
649 expressionP->X_add_number = 0;
651 *input_line_pointer = c;
655 as_bad ("Bad expression");
656 expressionP->X_op = O_constant;
657 expressionP->X_add_number = 0;
662 * It is more 'efficient' to clean up the expressionS when they are created.
663 * Doing it here saves lines of code.
665 clean_up_expression (expressionP);
666 SKIP_WHITESPACE (); /*->1st char after operand. */
667 know (*input_line_pointer != ' ');
669 /* The PA port needs this information. */
670 if (expressionP->X_add_symbol)
671 expressionP->X_add_symbol->sy_used = 1;
673 switch (expressionP->X_op)
676 return absolute_section;
678 return S_GET_SEGMENT (expressionP->X_add_symbol);
684 /* Internal. Simplify a struct expression for use by expr() */
687 * In: address of a expressionS.
688 * The X_op field of the expressionS may only take certain values.
689 * Elsewise we waste time special-case testing. Sigh. Ditto SEG_ABSENT.
690 * Out: expressionS may have been modified:
691 * 'foo-foo' symbol references cancelled to 0,
692 * which changes X_op from O_subtract to O_constant.
693 * Unused fields zeroed to help expr().
697 clean_up_expression (expressionP)
698 expressionS *expressionP;
700 switch (expressionP->X_op)
704 expressionP->X_add_number = 0;
709 expressionP->X_add_symbol = NULL;
714 expressionP->X_op_symbol = NULL;
717 if (expressionP->X_op_symbol == expressionP->X_add_symbol
718 || ((expressionP->X_op_symbol->sy_frag
719 == expressionP->X_add_symbol->sy_frag)
720 && SEG_NORMAL (S_GET_SEGMENT (expressionP->X_add_symbol))
721 && (S_GET_VALUE (expressionP->X_op_symbol)
722 == S_GET_VALUE (expressionP->X_add_symbol))))
724 expressionP->X_op = O_constant;
725 expressionP->X_add_symbol = NULL;
726 expressionP->X_op_symbol = NULL;
734 /* Expression parser. */
737 * We allow an empty expression, and just assume (absolute,0) silently.
738 * Unary operators and parenthetical expressions are treated as operands.
739 * As usual, Q==quantity==operand, O==operator, X==expression mnemonics.
741 * We used to do a aho/ullman shift-reduce parser, but the logic got so
742 * warped that I flushed it and wrote a recursive-descent parser instead.
743 * Now things are stable, would anybody like to write a fast parser?
744 * Most expressions are either register (which does not even reach here)
745 * or 1 symbol. Then "symbol+constant" and "symbol-symbol" are common.
746 * So I guess it doesn't really matter how inefficient more complex expressions
749 * After expr(RANK,resultP) input_line_pointer->operator of rank <= RANK.
750 * Also, we have consumed any leading or trailing spaces (operand does that)
751 * and done all intervening operators.
753 * This returns the segment of the result, which will be
754 * absolute_section or the segment of a symbol.
760 static const operatorT op_encoding[256] =
761 { /* maps ASCII->operators */
763 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
764 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
766 __, O_bit_or_not, __, __, __, O_modulus, O_bit_and, __,
767 __, __, O_multiply, O_add, __, O_subtract, __, O_divide,
768 __, __, __, __, __, __, __, __,
769 __, __, __, __, O_left_shift, __, O_right_shift, __,
770 __, __, __, __, __, __, __, __,
771 __, __, __, __, __, __, __, __,
772 __, __, __, __, __, __, __, __,
773 __, __, __, __, __, __, O_bit_exclusive_or, __,
774 __, __, __, __, __, __, __, __,
775 __, __, __, __, __, __, __, __,
776 __, __, __, __, __, __, __, __,
777 __, __, __, __, O_bit_inclusive_or, __, __, __,
779 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
780 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
781 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
782 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
783 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
784 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
785 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
786 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __
792 * 0 operand, (expression)
798 static const operator_rankT op_rank[] =
811 3, /* O_left_shift */
812 3, /* O_right_shift */
813 2, /* O_bit_inclusive_or */
814 2, /* O_bit_or_not */
815 2, /* O_bit_exclusive_or */
823 operator_rankT rank; /* Larger # is higher rank. */
824 expressionS *resultP; /* Deliver result here. */
829 char c_left; /* 1st operator character. */
835 retval = operand (resultP);
837 know (*input_line_pointer != ' '); /* Operand() gobbles spaces. */
839 c_left = *input_line_pointer; /* Potential operator character. */
840 op_left = op_encoding[(unsigned char) c_left];
841 while (op_left != O_illegal && op_rank[(int) op_left] > rank)
845 input_line_pointer++; /*->after 1st character of operator. */
846 /* Operators "<<" and ">>" have 2 characters. */
847 if (*input_line_pointer == c_left && (c_left == '<' || c_left == '>'))
848 ++input_line_pointer;
850 rightseg = expr (op_rank[(int) op_left], &right);
851 if (right.X_op == O_absent)
853 as_warn ("missing operand; zero assumed");
854 right.X_op = O_constant;
855 right.X_add_number = 0;
856 right.X_add_symbol = NULL;
857 right.X_op_symbol = NULL;
860 know (*input_line_pointer != ' ');
862 if (retval == undefined_section)
864 if (SEG_NORMAL (rightseg))
867 else if (! SEG_NORMAL (retval))
869 else if (SEG_NORMAL (rightseg)
870 && retval != rightseg
872 && op_left != O_subtract
875 as_bad ("operation combines symbols in different segments");
877 c_right = *input_line_pointer;
878 op_right = op_encoding[(unsigned char) c_right];
879 if (*input_line_pointer == c_right && (c_right == '<' || c_right == '>'))
880 ++input_line_pointer;
882 know (op_right == O_illegal || op_rank[(int) op_right] <= op_rank[(int) op_left]);
883 know ((int) op_left >= (int) O_multiply && (int) op_left <= (int) O_subtract);
885 /* input_line_pointer->after right-hand quantity. */
886 /* left-hand quantity in resultP */
887 /* right-hand quantity in right. */
888 /* operator in op_left. */
890 if (resultP->X_op == O_big)
892 as_warn ("left operand of %c is a %s; integer 0 assumed",
893 c_left, resultP->X_add_number > 0 ? "bignum" : "float");
894 resultP->X_op = O_constant;
895 resultP->X_add_number = 0;
896 resultP->X_add_symbol = NULL;
897 resultP->X_op_symbol = NULL;
899 if (right.X_op == O_big)
901 as_warn ("right operand of %c is a %s; integer 0 assumed",
902 c_left, right.X_add_number > 0 ? "bignum" : "float");
903 right.X_op = O_constant;
904 right.X_add_number = 0;
905 right.X_add_symbol = NULL;
906 right.X_op_symbol = NULL;
909 /* Optimize common cases. */
910 if (op_left == O_add && right.X_op == O_constant)
913 resultP->X_add_number += right.X_add_number;
915 else if (op_left == O_subtract && right.X_op == O_constant)
918 resultP->X_add_number -= right.X_add_number;
920 else if (op_left == O_add && resultP->X_op == O_constant)
923 resultP->X_op = right.X_op;
924 resultP->X_add_symbol = right.X_add_symbol;
925 resultP->X_op_symbol = right.X_op_symbol;
926 resultP->X_add_number += right.X_add_number;
929 else if (resultP->X_op == O_constant && right.X_op == O_constant)
931 /* Constant OP constant. */
932 offsetT v = right.X_add_number;
933 if (v == 0 && (op_left == O_divide || op_left == O_modulus))
935 as_warn ("division by zero");
940 case O_multiply: resultP->X_add_number *= v; break;
941 case O_divide: resultP->X_add_number /= v; break;
942 case O_modulus: resultP->X_add_number %= v; break;
943 case O_left_shift: resultP->X_add_number <<= v; break;
944 case O_right_shift: resultP->X_add_number >>= v; break;
945 case O_bit_inclusive_or: resultP->X_add_number |= v; break;
946 case O_bit_or_not: resultP->X_add_number |= ~v; break;
947 case O_bit_exclusive_or: resultP->X_add_number ^= v; break;
948 case O_bit_and: resultP->X_add_number &= v; break;
949 case O_add: resultP->X_add_number += v; break;
950 case O_subtract: resultP->X_add_number -= v; break;
954 else if (resultP->X_op == O_symbol
955 && right.X_op == O_symbol
957 || op_left == O_subtract
958 || (resultP->X_add_number == 0
959 && right.X_add_number == 0)))
961 /* Symbol OP symbol. */
962 resultP->X_op = op_left;
963 resultP->X_op_symbol = right.X_add_symbol;
964 if (op_left == O_add)
965 resultP->X_add_number += right.X_add_number;
966 else if (op_left == O_subtract)
967 resultP->X_add_number -= right.X_add_number;
971 /* The general case. */
972 resultP->X_add_symbol = make_expr_symbol (resultP);
973 resultP->X_op_symbol = make_expr_symbol (&right);
974 resultP->X_op = op_left;
975 resultP->X_add_number = 0;
976 resultP->X_unsigned = 1;
980 } /* While next operator is >= this rank. */
982 /* The PA port needs this information. */
983 if (resultP->X_add_symbol)
984 resultP->X_add_symbol->sy_used = 1;
986 return resultP->X_op == O_constant ? absolute_section : retval;
992 * This lives here because it belongs equally in expr.c & read.c.
993 * Expr.c is just a branch office read.c anyway, and putting it
994 * here lessens the crowd at read.c.
996 * Assume input_line_pointer is at start of symbol name.
997 * Advance input_line_pointer past symbol name.
998 * Turn that character into a '\0', returning its former value.
999 * This allows a string compare (RMS wants symbol names to be strings)
1000 * of the symbol name.
1001 * There will always be a char following symbol name, because all good
1002 * lines end in end-of-line.
1009 while (is_part_of_name (c = *input_line_pointer++))
1011 *--input_line_pointer = 0;
1017 get_single_number ()
1021 return exp.X_add_number;