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