ebb17b86d5b7033d04b98b7b5568adfd9379f5c5
[rmac] / expr.c
1 //
2 // RMAC - Reboot's Macro Assembler for all Atari computers
3 // EXPR.C - Expression Analyzer
4 // Copyright (C) 199x Landon Dyer, 2011-2019 Reboot and Friends
5 // RMAC derived from MADMAC v1.07 Written by Landon Dyer, 1986
6 // Source utilised with the kind permission of Landon Dyer
7 //
8
9 #include "expr.h"
10 #include "direct.h"
11 #include "error.h"
12 #include "listing.h"
13 #include "mach.h"
14 #include "procln.h"
15 #include "riscasm.h"
16 #include "sect.h"
17 #include "symbol.h"
18 #include "token.h"
19
20 #define DEF_KW                                          // Declare keyword values
21 #include "kwtab.h"                                      // Incl generated keyword tables & defs
22
23 // N.B.: The size of tokenClass should be identical to the largest value of
24 //       a token; we're assuming 256 but not 100% sure!
25 static char tokenClass[256];            // Generated table of token classes
26 static uint64_t evstk[EVSTACKSIZE];     // Evaluator value stack
27 static WORD evattr[EVSTACKSIZE];        // Evaluator attribute stack
28
29 // Token-class initialization list
30 char itokcl[] = {
31         0,                                                              // END
32         CONST, FCONST, SYMBOL, 0,               // ID
33         '(', '[', '{', 0,                               // OPAR
34         ')', ']', '}', 0,                               // CPAR
35         CR_DEFINED, CR_REFERENCED,              // SUNARY (special unary)
36         CR_STREQ, CR_MACDEF,
37         CR_DATE, CR_TIME,
38         CR_ABSCOUNT, 0,
39         '!', '~', UNMINUS, UNLT, UNGT, 0,       // UNARY
40         '*', '/', '%', 0,                               // MULT
41         '+', '-', 0,                                    // ADD
42         SHL, SHR, 0,                                    // SHIFT
43         LE, GE, '<', '>', NE, '=', 0,   // REL
44         '&', 0,                                                 // AND
45         '^', 0,                                                 // XOR
46         '|', 0,                                                 // OR
47         1                                                               // (the end)
48 };
49
50 const char missym_error[] = "missing symbol";
51 const char str_error[] = "missing symbol or string";
52 const char noflt_error[] = "operator not usable with float";
53
54 // Convert expression to postfix
55 static PTR evalTokenBuffer;             // Deposit tokens here (this is really a
56                                                                 // pointer to exprbuf from direct.c)
57                                                                 // (Can also be from others, like
58                                                                 // riscasm.c)
59 static int symbolNum;                   // Pointer to the entry in symbolPtr[]
60
61
62 //
63 // Obtain a string value
64 //
65 static uint32_t str_value(char * p)
66 {
67         uint32_t v;
68
69         for(v=0; *p; p++)
70                 v = (v << 8) | (*p & 0xFF);
71
72         return v;
73 }
74
75
76 //
77 // Initialize expression analyzer
78 //
79 void InitExpression(void)
80 {
81         // Initialize token-class table (all set to END)
82         for(int i=0; i<256; i++)
83                 tokenClass[i] = END;
84
85         int i = 0;
86
87         for(char * p=itokcl; *p!=1; p++)
88         {
89                 if (*p == 0)
90                         i++;
91                 else
92                         tokenClass[(int)(*p)] = (char)i;
93         }
94
95         symbolNum = 0;
96 }
97
98
99 //
100 // Binary operators (all the same precedence)
101 //
102 int expr0(void)
103 {
104         if (expr1() != OK)
105                 return ERROR;
106
107         while (tokenClass[*tok] >= MULT)
108         {
109                 TOKEN t = *tok++;
110
111                 if (expr1() != OK)
112                         return ERROR;
113
114                 *evalTokenBuffer.u32++ = t;
115         }
116
117         return OK;
118 }
119
120
121 //
122 // Unary operators (detect unary '-')
123 // ggn: If expression starts with a plus then also eat it up. For some reason
124 //      the parser gets confused when this happens and emits a "bad
125 //      expression".
126 //
127 int expr1(void)
128 {
129         char * p;
130         WORD w;
131
132         int class = tokenClass[*tok];
133
134         if (*tok == '-' || *tok == '+' || *tok == '<' || *tok == '>' || class == UNARY)
135         {
136                 TOKEN t = *tok++;
137
138                 if (expr2() != OK)
139                         return ERROR;
140
141                 if (t == '-')
142                         t = UNMINUS;
143                 else if (t == '<')
144                         t = UNLT;
145                 else if (t == '>')
146                         t = UNGT;
147
148                 // With leading + we don't have to deposit anything to the buffer
149                 // because there's no unary '+' nor we have to do anything about it
150                 if (t != '+')
151                         *evalTokenBuffer.u32++ = t;
152         }
153         else if (class == SUNARY)
154         {
155                 switch (*tok++)
156                 {
157                 case CR_ABSCOUNT:
158                         if (cursect != ABS)
159                         {
160                                 *evalTokenBuffer.u32++ = CONST;
161                                 *evalTokenBuffer.u64++ = sect[ABS].sloc;
162                         }
163                         else
164                         {
165                                 *evalTokenBuffer.u32++ = CONST;
166                                 *evalTokenBuffer.u64++ = sloc;
167                         }
168                         break;
169                 case CR_TIME:
170                         *evalTokenBuffer.u32++ = CONST;
171                         *evalTokenBuffer.u64++ = dos_time();
172                         break;
173                 case CR_DATE:
174                         *evalTokenBuffer.u32++ = CONST;
175                         *evalTokenBuffer.u64++ = dos_date();
176                         break;
177                 case CR_MACDEF: // ^^macdef <macro-name>
178                         if (*tok++ != SYMBOL)
179                                 return error(missym_error);
180
181                         p = string[*tok++];
182                         w = (lookup(p, MACRO, 0) == NULL ? 0 : 1);
183                         *evalTokenBuffer.u32++ = CONST;
184                         *evalTokenBuffer.u64++ = (uint64_t)w;
185                         break;
186                 case CR_DEFINED:
187                         w = DEFINED;
188                         goto getsym;
189                 case CR_REFERENCED:
190                         w = REFERENCED;
191 getsym:
192                         if (*tok++ != SYMBOL)
193                                 return error(missym_error);
194
195                         p = string[*tok++];
196                         int j = (*p == '.' ? curenv : 0);
197                         SYM * sy = lookup(p, LABEL, j);
198                         w = ((sy != NULL) && (sy->sattr & w ? 1 : 0));
199                         *evalTokenBuffer.u32++ = CONST;
200                         *evalTokenBuffer.u64++ = (uint64_t)w;
201                         break;
202                 case CR_STREQ:
203                         if (*tok != SYMBOL && *tok != STRING)
204                                 return error(str_error);
205
206                         p = string[tok[1]];
207                         tok +=2;
208
209                         if (*tok++ != ',')
210                                 return error(comma_error);
211
212                         if (*tok != SYMBOL && *tok != STRING)
213                                 return error(str_error);
214
215                         char * p2 = string[tok[1]];
216                         tok += 2;
217
218                         w = (WORD)(!strcmp(p, p2));
219                         *evalTokenBuffer.u32++ = CONST;
220                         *evalTokenBuffer.u64++ = (uint64_t)w;
221                         break;
222                 }
223         }
224         else
225                 return expr2();
226
227         return OK;
228 }
229
230
231 //
232 // Terminals (CONSTs) and parenthesis grouping
233 //
234 int expr2(void)
235 {
236         PTR ptk;
237
238         switch (*tok++)
239         {
240         case CONST:
241                 ptk.u32 = tok;
242                 *evalTokenBuffer.u32++ = CONST;
243                 *evalTokenBuffer.u64++ = *ptk.u64++;
244                 tok = ptk.u32;
245                 break;
246         case FCONST:
247                 ptk.u32 = tok;
248                 *evalTokenBuffer.u32++ = FCONST;
249                 *evalTokenBuffer.u64++ = *ptk.u64++;
250                 tok = ptk.u32;
251                 break;
252         case SYMBOL:
253         {
254                 char * p = string[*tok++];
255                 int j = (*p == '.' ? curenv : 0);
256                 SYM * sy = lookup(p, LABEL, j);
257
258                 if (sy == NULL)
259                         sy = NewSymbol(p, LABEL, j);
260
261                 // Check register bank usage
262                 if (sy->sattre & EQUATEDREG)
263                 {
264                         if ((regbank == BANK_0) && (sy->sattre & BANK_1) && !altbankok)
265                                 warn("equated symbol \'%s\' cannot be used in register bank 0", sy->sname);
266
267                         if ((regbank == BANK_1) && (sy->sattre & BANK_0) && !altbankok)
268                                 warn("equated symbol \'%s\' cannot be used in register bank 1", sy->sname);
269                 }
270
271                 *evalTokenBuffer.u32++ = SYMBOL;
272                 *evalTokenBuffer.u32++ = symbolNum;
273                 symbolPtr[symbolNum] = sy;
274                 symbolNum++;
275                 break;
276         }
277         case STRING:
278                 *evalTokenBuffer.u32++ = CONST;
279                 *evalTokenBuffer.u64++ = str_value(string[*tok++]);
280                 break;
281         case '(':
282                 if (expr0() != OK)
283                         return ERROR;
284
285                 if (*tok++ != ')')
286                         return error("missing closing parenthesis ')'");
287
288                 break;
289         case '[':
290                 if (expr0() != OK)
291                         return ERROR;
292
293                 if (*tok++ != ']')
294                         return error("missing closing bracket ']'");
295
296                 break;
297         case '{':
298                 if (expr0() != OK)      // Eat up first parameter (register or immediate)
299                         return ERROR;
300
301                 if (*tok++ != ':')      // Demand a ':' there
302                         return error("missing colon ':'");
303
304                 if (expr0() != OK)      // Eat up second parameter (register or immediate)
305                         return ERROR;
306
307                 if (*tok++ != '}')
308                         return error("missing closing brace '}'");
309
310                 break;
311         case '$':
312                 *evalTokenBuffer.u32++ = ACONST;                        // Attributed const
313                 *evalTokenBuffer.u32++ = sloc;                          // Current location
314                 *evalTokenBuffer.u32++ = cursect | DEFINED;     // Store attribs
315                 break;
316         case '*':
317                 *evalTokenBuffer.u32++ = ACONST;                        // Attributed const
318
319                 // pcloc == location at start of line
320                 *evalTokenBuffer.u32++ = (orgactive ? orgaddr : pcloc);
321                 // '*' takes attributes of current section, not ABS!
322                 *evalTokenBuffer.u32++ = cursect | DEFINED;
323                 break;
324         default:
325                 return error("bad expression");
326         }
327
328         return OK;
329 }
330
331
332 //
333 // Recursive-descent expression analyzer (with some simple speed hacks)
334 //
335 int expr(TOKEN * otk, uint64_t * a_value, WORD * a_attr, SYM ** a_esym)
336 {
337         // Passed in values (once derefenced, that is) can all be zero. They are
338         // there so that the expression analyzer can fill them in as needed. The
339         // expression analyzer gets its input from the global token pointer "tok",
340         // and not from anything passed in by the user.
341         SYM * symbol;
342         char * p;
343         int j;
344         PTR ptk;
345
346         evalTokenBuffer.u32 = otk;      // Set token pointer to 'exprbuf' (direct.c)
347                                                         // Also set in various other places too (riscasm.c,
348                                                         // e.g.)
349
350 //printf("expr(): tokens 0-2: %i %i %i (%c %c %c); tc[2] = %i\n", tok[0], tok[1], tok[2], tok[0], tok[1], tok[2], tokenClass[tok[2]]);
351         // Optimize for single constant or single symbol.
352         // Shamus: Subtle bug here. EOL token is 101; if you have a constant token
353         //         followed by the value 101, it will trigger a bad evaluation here.
354         //         This is probably a really bad assumption to be making here...!
355         //         (assuming tok[1] == EOL is a single token that is)
356         //         Seems that even other tokens (SUNARY type) can fuck this up too.
357 #if 0
358 //      if ((tok[1] == EOL)
359         if ((tok[1] == EOL && ((tok[0] != CONST || tok[0] != FCONST) && tokenClass[tok[0]] != SUNARY))
360 //              || (((*tok == CONST || *tok == FCONST || *tok == SYMBOL) || (*tok >= KW_R0 && *tok <= KW_R31))
361 //              && (tokenClass[tok[2]] < UNARY)))
362                 || (((tok[0] == SYMBOL) || (tok[0] >= KW_R0 && tok[0] <= KW_R31))
363                         && (tokenClass[tok[2]] < UNARY))
364                 || ((tok[0] == CONST || tok[0] == FCONST) && (tokenClass[tok[3]] < UNARY))
365                 )
366 #else
367 // Shamus: Seems to me that this could be greatly simplified by 1st checking if the first token is a multibyte token, *then* checking if there's an EOL after it depending on the actual length of the token (multiple vs. single). Otherwise, we have the horror show that is the following:
368         if ((tok[1] == EOL
369                         && (tok[0] != CONST && tokenClass[tok[0]] != SUNARY))
370                 || (((tok[0] == SYMBOL)
371                                 || (tok[0] >= KW_R0 && tok[0] <= KW_R31))
372                         && (tokenClass[tok[2]] < UNARY))
373                 || ((tok[0] == CONST) && (tokenClass[tok[3]] < UNARY))
374                 )
375 // Shamus: Yes, you can parse that out and make some kind of sense of it, but damn, it takes a while to get it and understand the subtle bugs that result from not being careful about what you're checking; especially vis-a-vis niavely checking tok[1] for an EOL. O_o
376 #endif
377         {
378                 if (*tok >= KW_R0 && *tok <= KW_R31)
379                 {
380                         *evalTokenBuffer.u32++ = CONST;
381                         *evalTokenBuffer.u64++ = *a_value = (*tok - KW_R0);
382                         *a_attr = ABS | DEFINED;
383
384                         if (a_esym != NULL)
385                                 *a_esym = NULL;
386
387                         tok++;
388                 }
389                 else if (*tok == CONST)
390                 {
391                         ptk.u32 = tok;
392                         *evalTokenBuffer.u32++ = *ptk.u32++;
393                         *evalTokenBuffer.u64++ = *a_value = *ptk.u64++;
394                         *a_attr = ABS | DEFINED;
395                         tok = ptk.u32;
396
397                         if (a_esym != NULL)
398                                 *a_esym = NULL;
399
400 //printf("Quick eval in expr(): CONST = %i, tokenClass[tok[2]] = %i\n", *a_value, tokenClass[*tok]);
401                 }
402 // Not sure that removing float constant here is going to break anything and/or
403 // make things significantly slower, but having this here seems to cause the
404 // complexity of the check to get to this part of the parse to go through the
405 // roof, and dammit, I just don't feel like fighting that fight ATM. :-P
406 #if 0
407                 else if (*tok == FCONST)
408                 {
409                         *evalTokenBuffer.u32++ = *tok++;
410                         *evalTokenBuffer.u64++ = *a_value = *tok.u64++;
411                         *a_attr = ABS | DEFINED | FLOAT;
412
413                         if (a_esym != NULL)
414                                 *a_esym = NULL;
415
416 //printf("Quick eval in expr(): CONST = %i, tokenClass[tok[2]] = %i\n", *a_value, tokenClass[*tok]);
417                 }
418 #endif
419                 else if (*tok == '*')
420                 {
421                         *evalTokenBuffer.u32++ = CONST;
422
423                         if (orgactive)
424                                 *evalTokenBuffer.u64++ = *a_value = orgaddr;
425                         else
426                                 *evalTokenBuffer.u64++ = *a_value = pcloc;
427
428                         // '*' takes attributes of current section, not ABS!
429                         *a_attr = cursect | DEFINED;
430
431                         if (a_esym != NULL)
432                                 *a_esym = NULL;
433
434                         tok++;
435                 }
436                 else if (*tok == STRING || *tok == SYMBOL)
437                 {
438                         p = string[tok[1]];
439                         j = (*p == '.' ? curenv : 0);
440                         symbol = lookup(p, LABEL, j);
441 #if 0
442 printf("eval: Looking up symbol (%s) [=%08X]\n", p, symbol);
443 if (symbol)
444         printf("      attr=%04X, attre=%08X, val=%i, name=%s\n", symbol->sattr, symbol->sattre, symbol->svalue, symbol->sname);
445 #endif
446
447                         if (symbol == NULL)
448                                 symbol = NewSymbol(p, LABEL, j);
449
450                         symbol->sattr |= REFERENCED;
451
452                         // Check for undefined register equates, but only if it's not part
453                         // of a #<SYMBOL> construct, as it could be that the label that's
454                         // been undefined may later be used as an address label--which
455                         // means it will be fixed up later, and thus, not an error.
456                         if ((symbol->sattre & UNDEF_EQUR) && !riscImmTokenSeen)
457                         {
458                                 error("undefined register equate '%s'", symbol->sname);
459 //if we return right away, it returns some spurious errors...
460 //                              return ERROR;
461                         }
462
463                         // Check register bank usage
464                         if (symbol->sattre & EQUATEDREG)
465                         {
466                                 if ((regbank == BANK_0) && (symbol->sattre & BANK_1) && !altbankok)
467                                         warn("equated symbol '%s' cannot be used in register bank 0", symbol->sname);
468
469                                 if ((regbank == BANK_1) && (symbol->sattre & BANK_0) && !altbankok)
470                                         warn("equated symbol '%s' cannot be used in register bank 1", symbol->sname);
471                         }
472
473                         *evalTokenBuffer.u32++ = SYMBOL;
474 #if 0
475                         *evalTokenBuffer++ = (TOKEN)symbol;
476 #else
477 /*
478 While this approach works, it's wasteful. It would be better to use something
479 that's already available, like the symbol "order defined" table (which needs to
480 be converted from a linked list into an array).
481 */
482                         *evalTokenBuffer.u32++ = symbolNum;
483                         symbolPtr[symbolNum] = symbol;
484                         symbolNum++;
485 #endif
486
487                         if (symbol->sattr & DEFINED)
488                                 *a_value = symbol->svalue;
489                         else
490                                 *a_value = 0;
491
492 /*
493 All that extra crap that was put into the svalue when doing the equr stuff is
494 thrown away right here. What the hell is it for?
495 */
496                         if (symbol->sattre & EQUATEDREG)
497                                 *a_value &= 0x1F;
498
499                         *a_attr = (WORD)(symbol->sattr & ~GLOBAL);
500
501                         if ((symbol->sattr & (GLOBAL | DEFINED)) == GLOBAL
502                                 && a_esym != NULL)
503                                 *a_esym = symbol;
504
505                         tok += 2;
506                 }
507                 // Holy hell... This is likely due to the fact that LSR is mistakenly set as a SUNARY type... Need to fix this... !!! FIX !!!
508                 else if (m6502)
509                 {
510                         *evalTokenBuffer.u32++ = *tok++;
511                 }
512                 else
513                 {
514                         // Unknown type here... Alert the user!,
515                         error("undefined RISC register in expression [token=$%X]", *tok);
516                         // Prevent spurious error reporting...
517                         tok++;
518                         return ERROR;
519                 }
520
521                 *evalTokenBuffer.u32++ = ENDEXPR;
522                 return OK;
523         }
524
525         if (expr0() != OK)
526                 return ERROR;
527
528         *evalTokenBuffer.u32++ = ENDEXPR;
529         return evexpr(otk, a_value, a_attr, a_esym);
530 }
531
532
533 //
534 // Evaluate expression.
535 // If the expression involves only ONE external symbol, the expression is
536 // UNDEFINED, but it's value includes everything but the symbol value, and
537 // 'a_esym' is set to the external symbol.
538 //
539 int evexpr(TOKEN * _tk, uint64_t * a_value, WORD * a_attr, SYM ** a_esym)
540 {
541         WORD attr;
542         SYM * sy;
543         uint64_t * sval = evstk;                                // (Empty) initial stack
544         WORD * sattr = evattr;
545         SYM * esym = NULL;                                              // No external symbol involved
546         WORD sym_seg = 0;
547         PTR tk;
548         tk.u32 = _tk;
549
550         while (*tk.u32 != ENDEXPR)
551         {
552                 switch ((int)*tk.u32++)
553                 {
554                 case SYMBOL:
555 //printf("evexpr(): SYMBOL\n");
556                         sy = symbolPtr[*tk.u32++];
557                         sy->sattr |= REFERENCED;                // Set "referenced" bit
558
559                         if (!(sy->sattr & DEFINED))
560                         {
561                                 // Reference to undefined symbol
562                                 if (!(sy->sattr & GLOBAL))
563                                 {
564                                         *a_attr = 0;
565                                         *a_value = 0;
566                                         return OK;
567                                 }
568
569                                 if (esym != NULL)                       // Check for multiple externals
570                                         return error(seg_error);
571
572                                 esym = sy;
573                         }
574
575                         if (sy->sattr & DEFINED)
576                                 *++sval = sy->svalue;           // Push symbol's value
577                         else
578                                 *++sval = 0;                            // 0 for undefined symbols
579
580                         *++sattr = (WORD)(sy->sattr & ~GLOBAL); // Push attribs
581                         sym_seg = (WORD)(sy->sattr & TDB);
582                         break;
583
584                 case CONST:
585                         *++sval = *tk.u64++;
586 //printf("evexpr(): CONST = %lX\n", *sval);
587                         *++sattr = ABS | DEFINED;               // Push simple attribs
588                         break;
589
590                 case FCONST:
591 //printf("evexpr(): FCONST = %lf\n", *tk.dp);
592                         // Even though it's a double, we can treat it like a uint64_t since
593                         // we're just moving the bits around.
594                         *++sval = *tk.u64++;
595                         *++sattr = ABS | DEFINED | FLOAT; // Push simple attribs
596                         break;
597
598                 case ACONST:
599 //printf("evexpr(): ACONST = %i\n", *tk.u32);
600                         *++sval = *tk.u32++;                            // Push value
601                         *++sattr = (WORD)*tk.u32++;                     // Push attribs
602                         break;
603
604                         // Binary "+" and "-" matrix:
605                         //
606                         //                ABS    Sect     Other
607                         //     ----------------------------
608                         //   ABS     |  ABS   |  Sect  |  Other |
609                         //   Sect    |  Sect  |  [1]   |  Error |
610                         //   Other   |  Other |  Error |  [1]   |
611                         //      ----------------------------
612                         //
613                         //   [1] + : Error
614                         //       - : ABS
615
616                 case '+':
617 //printf("evexpr(): +\n");
618                         --sval;                                                 // Pop value
619                         --sattr;                                                // Pop attrib
620 //printf("--> N+N: %i + %i = ", *sval, sval[1]);
621                         // Get FLOAT attribute, if any
622                         attr = (sattr[0] | sattr[1]) & FLOAT;
623
624                         // Since adding an int to a fp value promotes it to a fp value, we
625                         // don't care whether it's first or second; we cast to to a double
626                         // regardless.
627                         if (attr == FLOAT)
628                         {
629                                 PTR p;
630                                 p.u64 = sval;
631                                 double fpval1 = (sattr[0] & FLOAT ? *p.dp : (double)*p.i64);
632                                 p.u64++;
633                                 double fpval2 = (sattr[1] & FLOAT ? *p.dp : (double)*p.i64);
634                                 *(double *)sval = fpval1 + fpval2;
635                         }
636                         else
637                         {
638                                 *sval += sval[1];                               // Compute value
639                         }
640 //printf("%i\n", *sval);
641
642                         if (!(*sattr & TDB))
643                                 *sattr = sattr[1] | attr;
644                         else if (sattr[1] & TDB)
645                                 return error(seg_error);
646
647                         break;
648
649                 case '-':
650 //printf("evexpr(): -\n");
651                         --sval;                                                 // Pop value
652                         --sattr;                                                // Pop attrib
653 //printf("--> N-N: %i - %i = ", *sval, sval[1]);
654                         // Get FLOAT attribute, if any
655                         attr = (sattr[0] | sattr[1]) & FLOAT;
656
657                         // Since subtracting an int to a fp value promotes it to a fp
658                         // value, we don't care whether it's first or second; we cast to to
659                         // a double regardless.
660                         if (attr == FLOAT)
661                         {
662                                 PTR p;
663                                 p.u64 = sval;
664                                 double fpval1 = (sattr[0] & FLOAT ? *p.dp : (double)*p.i64);
665                                 p.u64++;
666                                 double fpval2 = (sattr[1] & FLOAT ? *p.dp : (double)*p.i64);
667                                 *(double *)sval = fpval1 - fpval2;
668                         }
669                         else
670                         {
671                                 *sval -= sval[1];
672                         }
673 //printf("%i\n", *sval);
674
675                         *sattr |= attr;                                 // Inherit FLOAT attribute
676                         attr = (WORD)(*sattr & TDB);
677 #if 0
678 printf("EVEXPR (-): sym1 = %X, sym2 = %X\n", attr, sattr[1]);
679 #endif
680                         // If symbol1 is ABS, take attributes from symbol2
681                         if (!attr)
682                                 *sattr = sattr[1];
683                         // Otherwise, they're both TDB and so attributes cancel out
684                         else if (sattr[1] & TDB)
685                                 *sattr &= ~TDB;
686
687                         break;
688
689                 // Unary operators only work on ABS items
690                 case UNMINUS:
691 //printf("evexpr(): UNMINUS\n");
692                         if (*sattr & TDB)
693                                 return error(seg_error);
694
695                         if (*sattr & FLOAT)
696                         {
697                                 double * dst = (double *)sval;
698                                 *dst = -*dst;
699                                 *sattr = ABS | DEFINED | FLOAT; // Expr becomes absolute
700                         }
701                         else
702                         {
703                                 *sval = -(int64_t)*sval;
704                                 *sattr = ABS | DEFINED;                 // Expr becomes absolute
705                         }
706
707                         break;
708
709                 case UNLT: // Unary < (get the low byte of a word)
710 //printf("evexpr(): UNLT\n");
711                         if (*sattr & TDB)
712                                 return error(seg_error);
713
714                         if (*sattr & FLOAT)
715                                 return error(noflt_error);
716
717                         *sval = (int64_t)((*sval) & 0x00FF);
718                         *sattr = ABS | DEFINED;                 // Expr becomes absolute
719                         break;
720
721                 case UNGT: // Unary > (get the high byte of a word)
722 //printf("evexpr(): UNGT\n");
723                         if (*sattr & TDB)
724                                 return error(seg_error);
725
726                         if (*sattr & FLOAT)
727                                 return error(noflt_error);
728
729                         *sval = (int64_t)(((*sval) >> 8) & 0x00FF);
730                         *sattr = ABS | DEFINED;                 // Expr becomes absolute
731                         break;
732
733                 case '!':
734 //printf("evexpr(): !\n");
735                         if (*sattr & TDB)
736                                 return error(seg_error);
737
738                         if (*sattr & FLOAT)
739                                 return error("floating point numbers not allowed with operator '!'.");
740
741                         *sval = !*sval;
742                         *sattr = ABS | DEFINED;                 // Expr becomes absolute
743                         break;
744
745                 case '~':
746 //printf("evexpr(): ~\n");
747                         if (*sattr & TDB)
748                                 return error(seg_error);
749
750                         if (*sattr & FLOAT)
751                                 return error("floating point numbers not allowed with operator '~'.");
752
753                         *sval = ~*sval;
754                         *sattr = ABS | DEFINED;                 // Expr becomes absolute
755                         break;
756
757                 // Comparison operators must have two values that
758                 // are in the same segment, but that's the only requirement.
759                 case LE:
760 //printf("evexpr(): LE\n");
761                         sattr--;
762                         sval--;
763
764                         if ((*sattr & TDB) != (sattr[1] & TDB))
765                                 return error(seg_error);
766
767                         // Get FLOAT attribute, if any
768                         attr = (sattr[0] | sattr[1]) & FLOAT;
769
770                         // Cast any ints in the comparison to double, if there's at least
771                         // one double in the comparison.
772                         if (attr == FLOAT)
773                         {
774                                 PTR p;
775                                 p.u64 = sval;
776                                 double fpval1 = (sattr[0] & FLOAT ? *p.dp : (double)*p.i64);
777                                 p.u64++;
778                                 double fpval2 = (sattr[1] & FLOAT ? *p.dp : (double)*p.i64);
779                                 *sval = (fpval1 <= fpval2);
780                         }
781                         else
782                         {
783                                 *sval = (*sval <= sval[1]);
784                         }
785
786                         *sattr = ABS | DEFINED;
787                         break;
788
789                 case GE:
790 //printf("evexpr(): GE\n");
791                         sattr--;
792                         sval--;
793
794                         if ((*sattr & TDB) != (sattr[1] & TDB))
795                                 return error(seg_error);
796
797                         // Get FLOAT attribute, if any
798                         attr = (sattr[0] | sattr[1]) & FLOAT;
799
800                         // Cast any ints in the comparison to double, if there's at least
801                         // one double in the comparison.
802                         if (attr == FLOAT)
803                         {
804                                 PTR p;
805                                 p.u64 = sval;
806                                 double fpval1 = (sattr[0] & FLOAT ? *p.dp : (double)*p.i64);
807                                 p.u64++;
808                                 double fpval2 = (sattr[1] & FLOAT ? *p.dp : (double)*p.i64);
809                                 *sval = (fpval1 >= fpval2);
810                         }
811                         else
812                         {
813                                 *sval = (*sval >= sval[1]);
814                         }
815
816                         *sattr = ABS | DEFINED;
817                         break;
818
819                 case '>':
820 //printf("evexpr(): >\n");
821                         sattr--;
822                         sval--;
823
824                         if ((*sattr & TDB) != (sattr[1] & TDB))
825                                 return error(seg_error);
826
827                         // Get FLOAT attribute, if any
828                         attr = (sattr[0] | sattr[1]) & FLOAT;
829
830                         // Cast any ints in the comparison to double, if there's at least
831                         // one double in the comparison.
832                         if (attr == FLOAT)
833                         {
834                                 PTR p;
835                                 p.u64 = sval;
836                                 double fpval1 = (sattr[0] & FLOAT ? *p.dp : (double)*p.i64);
837                                 p.u64++;
838                                 double fpval2 = (sattr[1] & FLOAT ? *p.dp : (double)*p.i64);
839                                 *sval = (fpval1 > fpval2);
840                         }
841                         else
842                         {
843                                 *sval = (*sval > sval[1]);
844                         }
845
846                         *sattr = ABS | DEFINED;
847                         break;
848
849                 case '<':
850 //printf("evexpr(): <\n");
851                         sattr--;
852                         sval--;
853
854                         if ((*sattr & TDB) != (sattr[1] & TDB))
855                                 return error(seg_error);
856
857                         // Get FLOAT attribute, if any
858                         attr = (sattr[0] | sattr[1]) & FLOAT;
859
860                         // Cast any ints in the comparison to double, if there's at least
861                         // one double in the comparison.
862                         if (attr == FLOAT)
863                         {
864                                 PTR p;
865                                 p.u64 = sval;
866                                 double fpval1 = (sattr[0] & FLOAT ? *p.dp : (double)*p.i64);
867                                 p.u64++;
868                                 double fpval2 = (sattr[1] & FLOAT ? *p.dp : (double)*p.i64);
869                                 *sval = (fpval1 < fpval2);
870                         }
871                         else
872                         {
873                                 *sval = (*sval < sval[1]);
874                         }
875
876                         *sattr = ABS | DEFINED;         // Expr forced to ABS
877                         break;
878
879                 case NE:
880 //printf("evexpr(): NE\n");
881                         sattr--;
882                         sval--;
883
884                         if ((*sattr & TDB) != (sattr[1] & TDB))
885                                 return error(seg_error);
886
887                         // Get FLOAT attribute, if any
888                         attr = (sattr[0] | sattr[1]) & FLOAT;
889
890                         // Cast any ints in the comparison to double, if there's at least
891                         // one double in the comparison.
892                         if (attr == FLOAT)
893                         {
894                                 PTR p;
895                                 p.u64 = sval;
896                                 double fpval1 = (sattr[0] & FLOAT ? *p.dp : (double)*p.i64);
897                                 p.u64++;
898                                 double fpval2 = (sattr[1] & FLOAT ? *p.dp : (double)*p.i64);
899                                 *sval = (fpval1 != fpval2);
900                         }
901                         else
902                         {
903                                 *sval = (*sval != sval[1]);
904                         }
905
906                         *sattr = ABS | DEFINED;         // Expr forced to ABS
907                         break;
908
909                 case '=':
910 //printf("evexpr(): =\n");
911                         sattr--;
912                         sval--;
913
914                         if ((*sattr & TDB) != (sattr[1] & TDB))
915                                 return error(seg_error);
916
917                         // Get FLOAT attribute, if any
918                         attr = (sattr[0] | sattr[1]) & FLOAT;
919
920                         // Cast any ints in the comparison to double, if there's at least
921                         // one double in the comparison.
922                         if (attr == FLOAT)
923                         {
924                                 PTR p;
925                                 p.u64 = sval;
926                                 double fpval1 = (sattr[0] & FLOAT ? *p.dp : (double)*p.i64);
927                                 p.u64++;
928                                 double fpval2 = (sattr[1] & FLOAT ? *p.dp : (double)*p.i64);
929                                 *sval = (fpval1 == fpval2);
930                         }
931                         else
932                         {
933                                 *sval = (*sval == sval[1]);
934                         }
935
936                         *sattr = ABS | DEFINED;         // Expr forced to ABS
937
938                         break;
939
940                 // All other binary operators must have two ABS items to work with.
941                 // They all produce an ABS value.
942                 // Shamus: Is this true? There's at least one counterexample of legit
943                 //         code where this assumption fails to produce correct code.
944                 default:
945 //printf("evexpr(): default\n");
946
947                         switch ((int)tk.u32[-1])
948                         {
949                         case '*':
950                                 sval--;
951                                 sattr--;
952 //printf("--> NxN: %i x %i = ", *sval, sval[1]);
953                                 // Get FLOAT attribute, if any
954                                 attr = (sattr[0] | sattr[1]) & FLOAT;
955
956                                 // Since multiplying an int to a fp value promotes it to a fp
957                                 // value, we don't care whether it's first or second; it will
958                                 // be cast to a double regardless.
959 /*
960 An open question here is do we promote ints to floats as signed or unsigned? It makes a difference if, say, the int is put in as -1 but is promoted to a double as $FFFFFFFFFFFFFFFF--you get very different results that way! For now, we promote as signed until proven detrimental otherwise.
961 */
962                                 if (attr == FLOAT)
963                                 {
964                                         PTR p;
965                                         p.u64 = sval;
966                                         double fpval1 = (sattr[0] & FLOAT ? *p.dp : (double)*p.i64);
967                                         p.u64++;
968                                         double fpval2 = (sattr[1] & FLOAT ? *p.dp : (double)*p.i64);
969                                         *(double *)sval = fpval1 * fpval2;
970                                 }
971                                 else
972                                 {
973                                         *sval *= sval[1];
974                                 }
975 //printf("%i\n", *sval);
976
977 //no                            *sattr = ABS | DEFINED | attr;          // Expr becomes absolute
978                                 break;
979
980                         case '/':
981                                 sval--;
982                                 sattr--;
983 //printf("--> N/N: %i / %i = ", sval[0], sval[1]);
984                                 // Get FLOAT attribute, if any
985                                 attr = (sattr[0] | sattr[1]) & FLOAT;
986
987                                 if (attr == FLOAT)
988                                 {
989                                         PTR p;
990                                         p.u64 = sval;
991                                         double fpval1 = (sattr[0] & FLOAT ? *p.dp : (double)*p.i64);
992                                         p.u64++;
993                                         double fpval2 = (sattr[1] & FLOAT ? *p.dp : (double)*p.i64);
994
995                                         if (fpval2 == 0)
996                                                 return error("divide by zero");
997
998                                         *(double *)sval = fpval1 / fpval2;
999                                 }
1000                                 else
1001                                 {
1002                                         if (sval[1] == 0)
1003                                                 return error("divide by zero");
1004 //printf("--> N/N: %i / %i = ", sval[0], sval[1]);
1005
1006                                         // Compiler is picky here: Without casting these, it
1007                                         // discards the sign if dividing a negative # by a
1008                                         // positive one, creating a bad result. :-/
1009                                         // Definitely a side effect of using uint32_ts intead of
1010                                         // ints.
1011                                         *sval = (int32_t)sval[0] / (int32_t)sval[1];
1012                                 }
1013 //printf("%i\n", *sval);
1014
1015 //no                            *sattr = ABS | DEFINED | attr;          // Expr becomes absolute
1016                                 break;
1017
1018                         case '%':
1019                                 sval--;
1020                                 sattr--;
1021
1022                                 if ((*sattr | sattr[1]) & FLOAT)
1023                                         return error("floating point numbers not allowed with operator '%'.");
1024
1025                                 if (sval[1] == 0)
1026                                         return error("mod (%) by zero");
1027
1028                                 *sval %= sval[1];
1029 //no                            *sattr = ABS | DEFINED;                 // Expr becomes absolute
1030                                 break;
1031
1032                         case SHL:
1033                                 sval--;
1034                                 sattr--;                                        // Pop attrib
1035
1036                                 if ((*sattr | sattr[1]) & FLOAT)
1037                                         return error("floating point numbers not allowed with operator '<<'.");
1038
1039                                 *sval <<= sval[1];
1040 //no                            *sattr = ABS | DEFINED;                 // Expr becomes absolute
1041                                 break;
1042
1043                         case SHR:
1044                                 sval--;
1045                                 sattr--;                                        // Pop attrib
1046
1047                                 if ((*sattr | sattr[1]) & FLOAT)
1048                                         return error("floating point numbers not allowed with operator '>>'.");
1049
1050                                 *sval >>= sval[1];
1051 //no                            *sattr = ABS | DEFINED;                 // Expr becomes absolute
1052                                 break;
1053
1054                         case '&':
1055                                 sval--;
1056                                 sattr--;                                        // Pop attrib
1057
1058                                 if ((*sattr | sattr[1]) & FLOAT)
1059                                         return error("floating point numbers not allowed with operator '&'.");
1060
1061                                 *sval &= sval[1];
1062 //no                            *sattr = ABS | DEFINED;                 // Expr becomes absolute
1063                                 break;
1064
1065                         case '^':
1066                                 sval--;
1067                                 sattr--;                                        // Pop attrib
1068
1069                                 if ((*sattr | sattr[1]) & FLOAT)
1070                                         return error("floating point numbers not allowed with operator '^'.");
1071
1072                                 *sval ^= sval[1];
1073 //no                            *sattr = ABS | DEFINED;                 // Expr becomes absolute
1074                                 break;
1075
1076                         case '|':
1077                                 sval--;
1078                                 sattr--;
1079
1080                                 if ((*sattr | sattr[1]) & FLOAT)
1081                                         return error("floating point numbers not allowed with operator '|'.");
1082
1083                                 *sval |= sval[1];
1084 //no                            *sattr = ABS | DEFINED;                 // Expr becomes absolute
1085                                 break;
1086
1087                         default:
1088                                 // Bad operator in expression stream (this should never happen!)
1089                                 interror(5);
1090                         }
1091                 }
1092         }
1093
1094         if (esym != NULL)
1095                 *sattr &= ~DEFINED;
1096
1097         if (a_esym != NULL)
1098                 *a_esym = esym;
1099
1100         // Copy value + attrib into return variables
1101         *a_value = *sval;
1102         *a_attr = *sattr;
1103
1104         return OK;
1105 }
1106
1107
1108 //
1109 // Count the # of tokens in the passed in expression
1110 // N.B.: 64-bit constants count as two tokens each
1111 //
1112 uint16_t ExpressionLength(TOKEN * tk)
1113 {
1114         uint16_t length;
1115
1116         for(length=0; tk[length]!=ENDEXPR; length++)
1117         {
1118                 // Add one to length for 2X tokens, two for 3X tokens
1119                 if (tk[length] == SYMBOL)
1120                         length++;
1121                 else if ((tk[length] == CONST) || (tk[length] == FCONST))
1122                         length += 2;
1123         }
1124
1125         // Add 1 for ENDEXPR
1126         length++;
1127
1128         return length;
1129 }
1130