Commit | Line | Data |
---|---|---|
fecd2382 | 1 | /* expr.c -operands, expressions- |
c593cf41 | 2 | Copyright (C) 1987, 1990, 1991, 1992 Free Software Foundation, Inc. |
2ed83a59 | 3 | |
a39116f1 | 4 | This file is part of GAS, the GNU Assembler. |
2ed83a59 | 5 | |
a39116f1 RP |
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. | |
2ed83a59 | 10 | |
a39116f1 RP |
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. | |
2ed83a59 | 15 | |
a39116f1 RP |
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. */ | |
fecd2382 RP |
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 | ||
c593cf41 | 34 | #if __STDC__ == 1 |
2ed83a59 | 35 | static void clean_up_expression (expressionS * expressionP); |
fecd2382 | 36 | #else /* __STDC__ */ |
2ed83a59 | 37 | static void clean_up_expression (); /* Internal. */ |
c593cf41 | 38 | #endif /* not __STDC__ */ |
fecd2382 RP |
39 | extern const char EXP_CHARS[]; /* JF hide MD floating pt stuff all the same place */ |
40 | extern const char FLT_CHARS[]; | |
41 | ||
fecd2382 RP |
42 | /* |
43 | * Build any floating-point literal here. | |
44 | * Also build any bignum literal here. | |
45 | */ | |
46 | ||
2ed83a59 | 47 | /* LITTLENUM_TYPE generic_buffer [6]; *//* JF this is a hack */ |
fecd2382 RP |
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. | |
a39116f1 | 53 | */ |
2ed83a59 KR |
54 | LITTLENUM_TYPE generic_bignum[SIZE_OF_LARGE_NUMBER + 6]; |
55 | FLONUM_TYPE generic_floating_point_number = | |
fecd2382 | 56 | { |
2ed83a59 KR |
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 | }; | |
fecd2382 RP |
63 | /* If nonzero, we've been asked to assemble nan, +inf or -inf */ |
64 | int generic_floating_point_magic; | |
65 | \f | |
2ed83a59 KR |
66 | floating_constant (expressionP) |
67 | expressionS *expressionP; | |
c593cf41 SC |
68 | { |
69 | /* input_line_pointer->*/ | |
70 | /* floating-point constant. */ | |
71 | int error_code; | |
72 | ||
73 | error_code = atof_generic | |
2ed83a59 KR |
74 | (&input_line_pointer, ".", EXP_CHARS, |
75 | &generic_floating_point_number); | |
c593cf41 SC |
76 | |
77 | if (error_code) | |
c593cf41 | 78 | { |
2ed83a59 KR |
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 | } | |
c593cf41 | 87 | } |
c593cf41 SC |
88 | expressionP->X_seg = SEG_BIG; |
89 | /* input_line_pointer->just after constant, */ | |
90 | /* which may point to whitespace. */ | |
2ed83a59 | 91 | expressionP->X_add_number = -1; |
c593cf41 SC |
92 | } |
93 | ||
94 | ||
95 | ||
2ed83a59 KR |
96 | integer_constant (radix, expressionP) |
97 | int radix; | |
98 | expressionS *expressionP; | |
c593cf41 | 99 | { |
2ed83a59 | 100 | register char *digit_2; /*->2nd digit of number. */ |
c593cf41 | 101 | char c; |
2ed83a59 KR |
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 | ||
c593cf41 SC |
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 | */ | |
2ed83a59 KR |
129 | |
130 | switch (radix) | |
f8701a3f | 131 | { |
2ed83a59 | 132 | |
f8701a3f SC |
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: | |
2ed83a59 KR |
142 | |
143 | ||
f8701a3f SC |
144 | maxdig = radix = 16; |
145 | too_many_digits = 9; | |
146 | break; | |
147 | case 10: | |
148 | maxdig = radix = 10; | |
149 | too_many_digits = 11; | |
150 | } | |
c593cf41 SC |
151 | c = *input_line_pointer; |
152 | input_line_pointer++; | |
153 | digit_2 = input_line_pointer; | |
2ed83a59 | 154 | for (number = 0; (digit = hex_value[c]) < maxdig; c = *input_line_pointer++) |
f8701a3f SC |
155 | { |
156 | number = number * radix + digit; | |
157 | } | |
c593cf41 SC |
158 | /* c contains character after number. */ |
159 | /* input_line_pointer->char after c. */ | |
160 | small = input_line_pointer - digit_2 < too_many_digits; | |
2ed83a59 | 161 | if (!small) |
c593cf41 | 162 | { |
f8701a3f SC |
163 | /* |
164 | * we saw a lot of digits. manufacture a bignum the hard way. | |
165 | */ | |
2ed83a59 KR |
166 | LITTLENUM_TYPE *leader; /*->high order littlenum of the bignum. */ |
167 | LITTLENUM_TYPE *pointer; /*->littlenum we are frobbing now. */ | |
f8701a3f | 168 | long carry; |
2ed83a59 | 169 | |
f8701a3f | 170 | leader = generic_bignum; |
2ed83a59 KR |
171 | generic_bignum[0] = 0; |
172 | generic_bignum[1] = 0; | |
f8701a3f | 173 | /* we could just use digit_2, but lets be mnemonic. */ |
2ed83a59 | 174 | input_line_pointer = --digit_2; /*->1st digit. */ |
f8701a3f | 175 | c = *input_line_pointer++; |
2ed83a59 | 176 | for (; (carry = hex_value[c]) < maxdig; c = *input_line_pointer++) |
f8701a3f SC |
177 | { |
178 | for (pointer = generic_bignum; | |
179 | pointer <= leader; | |
180 | pointer++) | |
181 | { | |
182 | long work; | |
2ed83a59 KR |
183 | |
184 | work = carry + radix * *pointer; | |
f8701a3f SC |
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) | |
2ed83a59 | 191 | { /* room to grow a longer bignum. */ |
f8701a3f SC |
192 | *++leader = carry; |
193 | } | |
194 | } | |
195 | } | |
196 | /* again, c is char after number, */ | |
197 | /* input_line_pointer->after c. */ | |
2ed83a59 KR |
198 | know (sizeof (int) * 8 == 32); |
199 | know (LITTLENUM_NUMBER_OF_BITS == 16); | |
f8701a3f SC |
200 | /* hence the constant "2" in the next line. */ |
201 | if (leader < generic_bignum + 2) | |
2ed83a59 | 202 | { /* will fit into 32 bits. */ |
f8701a3f | 203 | number = |
2ed83a59 KR |
204 | ((generic_bignum[1] & LITTLENUM_MASK) << LITTLENUM_NUMBER_OF_BITS) |
205 | | (generic_bignum[0] & LITTLENUM_MASK); | |
f8701a3f SC |
206 | small = 1; |
207 | } | |
208 | else | |
209 | { | |
2ed83a59 | 210 | number = leader - generic_bignum + 1; /* number of littlenums in the bignum. */ |
c593cf41 | 211 | } |
c593cf41 | 212 | } |
2ed83a59 KR |
213 | if (small) |
214 | { | |
f8701a3f | 215 | /* |
2ed83a59 KR |
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! | |
f8701a3f | 220 | */ |
2ed83a59 KR |
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. */ | |
c593cf41 | 271 | #ifndef many_segments |
2ed83a59 KR |
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); | |
c593cf41 | 275 | #endif |
2ed83a59 KR |
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 | ||
f8701a3f | 284 | #endif /* LOCAL_LABELS_FB */ |
2ed83a59 | 285 | |
f8701a3f | 286 | #ifdef LOCAL_LABELS_DOLLAR |
f8701a3f | 287 | |
2ed83a59 KR |
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 | ||
f8701a3f | 315 | #endif /* LOCAL_LABELS_DOLLAR */ |
2ed83a59 KR |
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 */ | |
c593cf41 | 331 | expressionP->X_add_number = number; |
2ed83a59 KR |
332 | expressionP->X_seg = SEG_BIG; |
333 | input_line_pointer--; /*->char following number. */ | |
334 | } /* if (small) */ | |
335 | } /* integer_constant() */ | |
c593cf41 SC |
336 | |
337 | ||
fecd2382 RP |
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 | |
c593cf41 SC |
351 | |
352 | ||
fecd2382 | 353 | static segT |
c593cf41 | 354 | operand (expressionP) |
2ed83a59 | 355 | register expressionS *expressionP; |
fecd2382 | 356 | { |
c593cf41 | 357 | register char c; |
2ed83a59 KR |
358 | register symbolS *symbolP; /* points to symbol */ |
359 | register char *name; /* points to name of symbol */ | |
c593cf41 SC |
360 | /* invented for humans only, hope */ |
361 | /* optimising compiler flushes it! */ | |
2ed83a59 | 362 | register short int radix; /* 2, 8, 10 or 16, 0 when floating */ |
c593cf41 SC |
363 | /* 0 means we saw start of a floating- */ |
364 | /* point constant. */ | |
365 | ||
366 | /* digits, assume it is a bignum. */ | |
367 | ||
368 | ||
369 | ||
370 | ||
2ed83a59 KR |
371 | SKIP_WHITESPACE (); /* leading whitespace is part of operand. */ |
372 | c = *input_line_pointer++; /* input_line_pointer->past char in c. */ | |
c593cf41 SC |
373 | |
374 | switch (c) | |
fecd2382 | 375 | { |
2ed83a59 KR |
376 | #ifdef MRI |
377 | case '%': | |
378 | integer_constant (2, expressionP); | |
c593cf41 | 379 | break; |
2ed83a59 KR |
380 | case '@': |
381 | integer_constant (8, expressionP); | |
c593cf41 | 382 | break; |
2ed83a59 KR |
383 | case '$': |
384 | integer_constant (16, expressionP); | |
c593cf41 | 385 | break; |
2ed83a59 | 386 | #endif |
c593cf41 SC |
387 | case '1': |
388 | case '2': | |
389 | case '3': | |
390 | case '4': | |
391 | case '5': | |
392 | case '6': | |
393 | case '7': | |
2ed83a59 KR |
394 | case '8': |
395 | case '9': | |
396 | input_line_pointer--; | |
397 | ||
398 | integer_constant (10, expressionP); | |
c593cf41 SC |
399 | break; |
400 | ||
2ed83a59 KR |
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 | |
c593cf41 | 461 | a floating point #, its a local label ref. dtrt */ |
2ed83a59 KR |
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 | ||
c593cf41 | 494 | break; |
2ed83a59 KR |
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; | |
c593cf41 SC |
508 | |
509 | ||
2ed83a59 KR |
510 | case '\'': |
511 | /* | |
c593cf41 SC |
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 | */ | |
2ed83a59 KR |
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 | /* | |
c593cf41 SC |
534 | * Notice: '-' may overflow: no warning is given. This is compatible |
535 | * with other people's assemblers. Sigh. | |
536 | */ | |
2ed83a59 KR |
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); | |
a39116f1 | 558 | break; |
2ed83a59 | 559 | /* Expression undisturbed from operand(). */ |
c593cf41 | 560 | } |
c593cf41 | 561 | } |
c593cf41 | 562 | |
c593cf41 | 563 | |
2ed83a59 KR |
564 | |
565 | break; | |
566 | ||
567 | case '.': | |
568 | if (!is_part_of_name (*input_line_pointer)) | |
569 | { | |
570 | extern struct obstack frags; | |
571 | ||
572 | /* | |
c593cf41 SC |
573 | JF: '.' is pseudo symbol with value of current location in current |
574 | segment. . . | |
575 | */ | |
2ed83a59 KR |
576 | symbolP = symbol_new ("L0\001", |
577 | now_seg, | |
578 | (valueT) (obstack_next_free (&frags) - frag_now->fr_literal), | |
579 | frag_now); | |
c593cf41 | 580 | |
2ed83a59 KR |
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 | /* | |
c593cf41 SC |
605 | * Identifier begins here. |
606 | * This is kludged for speed, so code is repeated. | |
607 | */ | |
2ed83a59 KR |
608 | isname: |
609 | name = --input_line_pointer; | |
610 | c = get_symbol_end (); | |
611 | symbolP = symbol_find_or_make (name); | |
612 | /* | |
c593cf41 SC |
613 | * If we have an absolute symbol or a reg, then we know its value now. |
614 | */ | |
2ed83a59 KR |
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 | } | |
c593cf41 SC |
637 | |
638 | } | |
c593cf41 SC |
639 | |
640 | ||
2ed83a59 KR |
641 | |
642 | ||
643 | ||
644 | ||
c593cf41 SC |
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); | |
2ed83a59 KR |
651 | SKIP_WHITESPACE (); /*->1st char after operand. */ |
652 | know (*input_line_pointer != ' '); | |
c593cf41 | 653 | return (expressionP->X_seg); |
2ed83a59 | 654 | } /* operand() */ |
fecd2382 | 655 | \f |
2ed83a59 | 656 | |
fecd2382 RP |
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 | |
c593cf41 | 671 | clean_up_expression (expressionP) |
2ed83a59 | 672 | register expressionS *expressionP; |
fecd2382 | 673 | { |
c593cf41 | 674 | switch (expressionP->X_seg) |
2ed83a59 KR |
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 | /* | |
a39116f1 RP |
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 | */ | |
2ed83a59 KR |
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; | |
a39116f1 | 709 | } |
2ed83a59 | 710 | break; |
c593cf41 | 711 | |
2ed83a59 KR |
712 | case SEG_REGISTER: |
713 | expressionP->X_add_symbol = NULL; | |
714 | expressionP->X_subtract_symbol = NULL; | |
715 | break; | |
c593cf41 | 716 | |
2ed83a59 KR |
717 | default: |
718 | if (SEG_NORMAL (expressionP->X_seg)) | |
719 | { | |
720 | expressionP->X_subtract_symbol = NULL; | |
a39116f1 | 721 | } |
2ed83a59 KR |
722 | else |
723 | { | |
724 | BAD_CASE (expressionP->X_seg); | |
a39116f1 | 725 | } |
2ed83a59 KR |
726 | break; |
727 | } | |
728 | } /* clean_up_expression() */ | |
fecd2382 RP |
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 | |
c593cf41 | 742 | expr_part (symbol_1_PP, symbol_2_P) |
2ed83a59 KR |
743 | symbolS **symbol_1_PP; |
744 | symbolS *symbol_2_P; | |
fecd2382 | 745 | { |
2ed83a59 | 746 | segT return_value; |
a39116f1 | 747 | #ifndef MANY_SEGMENTS |
2ed83a59 KR |
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))); | |
a39116f1 | 750 | #endif |
2ed83a59 | 751 | if (*symbol_1_PP) |
fecd2382 | 752 | { |
2ed83a59 | 753 | if (!S_IS_DEFINED (*symbol_1_PP)) |
fecd2382 | 754 | { |
c593cf41 | 755 | if (symbol_2_P) |
fecd2382 | 756 | { |
2ed83a59 KR |
757 | return_value = SEG_PASS1; |
758 | *symbol_1_PP = NULL; | |
fecd2382 | 759 | } |
c593cf41 | 760 | else |
fecd2382 | 761 | { |
2ed83a59 KR |
762 | know (!S_IS_DEFINED (*symbol_1_PP)); |
763 | return_value = SEG_UNKNOWN; | |
fecd2382 RP |
764 | } |
765 | } | |
c593cf41 | 766 | else |
fecd2382 | 767 | { |
c593cf41 | 768 | if (symbol_2_P) |
fecd2382 | 769 | { |
2ed83a59 | 770 | if (!S_IS_DEFINED (symbol_2_P)) |
fecd2382 | 771 | { |
2ed83a59 | 772 | *symbol_1_PP = NULL; |
c593cf41 | 773 | return_value = SEG_PASS1; |
fecd2382 | 774 | } |
c593cf41 | 775 | else |
fecd2382 | 776 | { |
c593cf41 | 777 | /* {seg1} - {seg2} */ |
2ed83a59 KR |
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; | |
c593cf41 | 781 | return_value = SEG_ABSOLUTE; |
fecd2382 RP |
782 | } |
783 | } | |
c593cf41 | 784 | else |
fecd2382 | 785 | { |
2ed83a59 | 786 | return_value = S_GET_SEGMENT (*symbol_1_PP); |
fecd2382 RP |
787 | } |
788 | } | |
789 | } | |
c593cf41 | 790 | else |
fecd2382 | 791 | { /* (* symbol_1_PP) == NULL */ |
c593cf41 | 792 | if (symbol_2_P) |
fecd2382 | 793 | { |
2ed83a59 KR |
794 | *symbol_1_PP = symbol_2_P; |
795 | return_value = S_GET_SEGMENT (symbol_2_P); | |
fecd2382 | 796 | } |
c593cf41 | 797 | else |
fecd2382 | 798 | { |
2ed83a59 | 799 | *symbol_1_PP = NULL; |
c593cf41 | 800 | return_value = SEG_ABSOLUTE; |
fecd2382 RP |
801 | } |
802 | } | |
a39116f1 | 803 | #ifndef MANY_SEGMENTS |
2ed83a59 | 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); |
a39116f1 | 805 | #endif |
2ed83a59 | 806 | know ((*symbol_1_PP) == NULL || (S_GET_SEGMENT (*symbol_1_PP) == return_value)); |
c593cf41 | 807 | return (return_value); |
fecd2382 RP |
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 | { | |
2ed83a59 KR |
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 | ||
fecd2382 RP |
847 | operatorT; |
848 | ||
849 | #define __ O_illegal | |
850 | ||
2ed83a59 KR |
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 | }; | |
fecd2382 RP |
879 | |
880 | ||
881 | /* | |
882 | * Rank Examples | |
883 | * 0 operand, (expression) | |
884 | * 1 + - | |
885 | * 2 & ^ ! | | |
886 | * 3 * / % << >> | |
887 | */ | |
888 | static const operator_rankT | |
2ed83a59 KR |
889 | op_rank[] = |
890 | {0, 3, 3, 3, 3, 3, 2, 2, 2, 2, 1, 1}; | |
fecd2382 RP |
891 | \f |
892 | /* Return resultP->X_seg. */ | |
2ed83a59 KR |
893 | segT |
894 | expr (rank, resultP) | |
895 | register operator_rankT rank; /* Larger # is higher rank. */ | |
896 | register expressionS *resultP; /* Deliver result here. */ | |
fecd2382 | 897 | { |
2ed83a59 KR |
898 | expressionS right; |
899 | register operatorT op_left; | |
900 | register char c_left; /* 1st operator character. */ | |
901 | register operatorT op_right; | |
c593cf41 SC |
902 | register char c_right; |
903 | ||
2ed83a59 KR |
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) | |
fecd2382 | 910 | { |
2ed83a59 KR |
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 == '>')) | |
fecd2382 | 914 | { |
2ed83a59 | 915 | input_line_pointer++; |
fecd2382 | 916 | } /*->after operator. */ |
c593cf41 | 917 | if (SEG_ABSENT == expr (op_rank[(int) op_left], &right)) |
fecd2382 | 918 | { |
2ed83a59 KR |
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; | |
c593cf41 | 923 | resultP->X_seg = SEG_ABSOLUTE; |
fecd2382 | 924 | } |
2ed83a59 KR |
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 == '>')) | |
fecd2382 | 929 | { |
2ed83a59 | 930 | input_line_pointer++; |
fecd2382 | 931 | } /*->after operator. */ |
2ed83a59 | 932 | know ((int) op_right == 0 || op_rank[(int) op_right] <= op_rank[(int) op_left]); |
c593cf41 SC |
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. */ | |
2ed83a59 | 937 | if (resultP->X_seg == SEG_PASS1 || right.X_seg == SEG_PASS1) |
fecd2382 | 938 | { |
c593cf41 | 939 | resultP->X_seg = SEG_PASS1; |
fecd2382 | 940 | } |
c593cf41 | 941 | else |
fecd2382 | 942 | { |
c593cf41 | 943 | if (resultP->X_seg == SEG_BIG) |
fecd2382 | 944 | { |
2ed83a59 KR |
945 | as_warn ("Left operand of %c is a %s. Integer 0 assumed.", |
946 | c_left, resultP->X_add_number > 0 ? "bignum" : "float"); | |
c593cf41 SC |
947 | resultP->X_seg = SEG_ABSOLUTE; |
948 | resultP->X_add_symbol = 0; | |
949 | resultP->X_subtract_symbol = 0; | |
950 | resultP->X_add_number = 0; | |
fecd2382 | 951 | } |
2ed83a59 | 952 | if (right.X_seg == SEG_BIG) |
fecd2382 | 953 | { |
2ed83a59 KR |
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; | |
fecd2382 | 960 | } |
c593cf41 | 961 | if (op_left == O_subtract) |
fecd2382 | 962 | { |
c593cf41 SC |
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 | ||
2ed83a59 | 970 | register symbolS *symbolP; |
c593cf41 | 971 | |
2ed83a59 KR |
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; | |
c593cf41 | 976 | if (symbolP) |
fecd2382 | 977 | { |
2ed83a59 | 978 | right.X_seg = SEG_DIFFERENCE; |
fecd2382 | 979 | } |
c593cf41 | 980 | op_left = O_add; |
fecd2382 | 981 | } |
c593cf41 SC |
982 | \f |
983 | if (op_left == O_add) | |
fecd2382 | 984 | { |
2ed83a59 KR |
985 | segT seg1; |
986 | segT seg2; | |
a39116f1 | 987 | #ifndef MANY_SEGMENTS |
2ed83a59 KR |
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); | |
a39116f1 | 992 | #endif |
2ed83a59 | 993 | clean_up_expression (&right); |
c593cf41 SC |
994 | clean_up_expression (resultP); |
995 | ||
2ed83a59 KR |
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; | |
c593cf41 SC |
1005 | else if (seg1 != SEG_UNKNOWN |
1006 | && seg1 != SEG_ABSOLUTE | |
1007 | && seg2 != SEG_UNKNOWN | |
2ed83a59 KR |
1008 | && seg1 != seg2) |
1009 | { | |
1010 | know (seg2 != SEG_ABSOLUTE); | |
1011 | know (resultP->X_subtract_symbol); | |
a39116f1 | 1012 | #ifndef MANY_SEGMENTS |
2ed83a59 KR |
1013 | know (seg1 == SEG_TEXT || seg1 == SEG_DATA || seg1 == SEG_BSS); |
1014 | know (seg2 == SEG_TEXT || seg2 == SEG_DATA || seg2 == SEG_BSS); | |
a39116f1 | 1015 | #endif |
2ed83a59 KR |
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; | |
c593cf41 | 1026 | |
2ed83a59 | 1027 | resultP->X_add_number += right.X_add_number; |
c593cf41 | 1028 | clean_up_expression (resultP); |
2ed83a59 | 1029 | } |
c593cf41 | 1030 | else |
fecd2382 | 1031 | { /* Not +. */ |
2ed83a59 | 1032 | if (resultP->X_seg == SEG_UNKNOWN || right.X_seg == SEG_UNKNOWN) |
fecd2382 | 1033 | { |
c593cf41 SC |
1034 | resultP->X_seg = SEG_PASS1; |
1035 | need_pass_2 = 1; | |
fecd2382 | 1036 | } |
c593cf41 | 1037 | else |
fecd2382 | 1038 | { |
c593cf41 SC |
1039 | resultP->X_subtract_symbol = NULL; |
1040 | resultP->X_add_symbol = NULL; | |
1041 | /* Will be SEG_ABSOLUTE. */ | |
2ed83a59 | 1042 | if (resultP->X_seg != SEG_ABSOLUTE || right.X_seg != SEG_ABSOLUTE) |
fecd2382 | 1043 | { |
2ed83a59 KR |
1044 | as_bad ("Relocation error. Absolute 0 assumed."); |
1045 | resultP->X_seg = SEG_ABSOLUTE; | |
c593cf41 | 1046 | resultP->X_add_number = 0; |
fecd2382 | 1047 | } |
c593cf41 | 1048 | else |
fecd2382 | 1049 | { |
c593cf41 | 1050 | switch (op_left) |
fecd2382 RP |
1051 | { |
1052 | case O_bit_inclusive_or: | |
2ed83a59 | 1053 | resultP->X_add_number |= right.X_add_number; |
c593cf41 SC |
1054 | break; |
1055 | ||
fecd2382 | 1056 | case O_modulus: |
2ed83a59 | 1057 | if (right.X_add_number) |
fecd2382 | 1058 | { |
2ed83a59 | 1059 | resultP->X_add_number %= right.X_add_number; |
fecd2382 | 1060 | } |
c593cf41 | 1061 | else |
fecd2382 | 1062 | { |
2ed83a59 | 1063 | as_warn ("Division by 0. 0 assumed."); |
c593cf41 | 1064 | resultP->X_add_number = 0; |
fecd2382 | 1065 | } |
c593cf41 SC |
1066 | break; |
1067 | ||
fecd2382 | 1068 | case O_bit_and: |
2ed83a59 | 1069 | resultP->X_add_number &= right.X_add_number; |
c593cf41 SC |
1070 | break; |
1071 | ||
fecd2382 | 1072 | case O_multiply: |
2ed83a59 | 1073 | resultP->X_add_number *= right.X_add_number; |
c593cf41 SC |
1074 | break; |
1075 | ||
fecd2382 | 1076 | case O_divide: |
2ed83a59 | 1077 | if (right.X_add_number) |
fecd2382 | 1078 | { |
2ed83a59 | 1079 | resultP->X_add_number /= right.X_add_number; |
fecd2382 | 1080 | } |
c593cf41 | 1081 | else |
fecd2382 | 1082 | { |
2ed83a59 KR |
1083 | as_warn ("Division by 0. 0 assumed."); |
1084 | resultP->X_add_number = 0; | |
fecd2382 | 1085 | } |
2ed83a59 KR |
1086 | break; |
1087 | ||
fecd2382 | 1088 | case O_left_shift: |
2ed83a59 KR |
1089 | resultP->X_add_number <<= right.X_add_number; |
1090 | break; | |
1091 | ||
fecd2382 | 1092 | case O_right_shift: |
2ed83a59 KR |
1093 | resultP->X_add_number >>= right.X_add_number; |
1094 | break; | |
1095 | ||
fecd2382 | 1096 | case O_bit_exclusive_or: |
2ed83a59 KR |
1097 | resultP->X_add_number ^= right.X_add_number; |
1098 | break; | |
1099 | ||
fecd2382 | 1100 | case O_bit_or_not: |
2ed83a59 KR |
1101 | resultP->X_add_number |= ~right.X_add_number; |
1102 | break; | |
1103 | ||
fecd2382 | 1104 | default: |
2ed83a59 KR |
1105 | BAD_CASE (op_left); |
1106 | break; | |
1107 | } /* switch(operator) */ | |
fecd2382 RP |
1108 | } |
1109 | } /* If we have to force need_pass_2. */ | |
1110 | } /* If operator was +. */ | |
1111 | } /* If we didn't set need_pass_2. */ | |
2ed83a59 | 1112 | op_left = op_right; |
fecd2382 | 1113 | } /* While next operator is >= this rank. */ |
2ed83a59 | 1114 | return (resultP->X_seg); |
fecd2382 RP |
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 | |
2ed83a59 | 1133 | get_symbol_end () |
fecd2382 | 1134 | { |
2ed83a59 KR |
1135 | register char c; |
1136 | ||
1137 | while (is_part_of_name (c = *input_line_pointer++)) | |
1138 | ; | |
1139 | *--input_line_pointer = 0; | |
1140 | return (c); | |
fecd2382 RP |
1141 | } |
1142 | ||
a39116f1 | 1143 | |
2ed83a59 KR |
1144 | unsigned int |
1145 | get_single_number () | |
a39116f1 | 1146 | { |
2ed83a59 KR |
1147 | expressionS exp; |
1148 | operand (&exp); | |
1149 | return exp.X_add_number; | |
1150 | ||
a39116f1 | 1151 | } |
2ed83a59 | 1152 | |
fecd2382 RP |
1153 | /* |
1154 | * Local Variables: | |
1155 | * comment-column: 0 | |
1156 | * fill-column: 131 | |
1157 | * End: | |
1158 | */ | |
1159 | ||
8b228fe9 | 1160 | /* end of expr.c */ |