Update to the name (don't ask), and copyright dates. Now at v2.1.0.
[rmac] / expr.c
1 //
2 // RMAC - Renamed Macro Assembler for all Atari computers
3 // EXPR.C - Expression Analyzer
4 // Copyright (C) 199x Landon Dyer, 2011-2021 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, CR_FILESIZE, 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_FILESIZE:
170                         if (*tok++ != STRING)
171                                 return error("^^FILESIZE expects filename inside string");
172                         *evalTokenBuffer.u32++ = CONST;
173                         // @@copypasted from d_incbin, maybe factor this out somehow?
174                         // Attempt to open the include file in the current directory, then (if that
175                         // failed) try list of include files passed in the enviroment string or by
176                         // the "-d" option.
177                         int fd, i;
178                         char buf1[256];
179
180                         if ((fd = open(string[*tok], _OPEN_INC)) < 0)
181                         {
182                                 for(i=0; nthpath("RMACPATH", i, buf1)!=0; i++)
183                                 {
184                                         fd = strlen(buf1);
185
186                                         // Append path char if necessary
187                                         if ((fd > 0) && (buf1[fd - 1] != SLASHCHAR))
188                                                 strcat(buf1, SLASHSTRING);
189
190                                         strcat(buf1, string[*tok]);
191
192                                         if ((fd = open(buf1, _OPEN_INC)) >= 0)
193                                                 goto allright;
194                                 }
195
196                                 return error("cannot open: \"%s\"", string[tok[1]]);
197                         }
198
199 allright:
200                         *evalTokenBuffer.u64++ = (uint64_t)lseek(fd, 0L, SEEK_END);
201                         close(fd);
202
203                         // Advance tok because of consumed string token
204                         tok++;
205                         break;
206                 case CR_TIME:
207                         *evalTokenBuffer.u32++ = CONST;
208                         *evalTokenBuffer.u64++ = dos_time();
209                         break;
210                 case CR_DATE:
211                         *evalTokenBuffer.u32++ = CONST;
212                         *evalTokenBuffer.u64++ = dos_date();
213                         break;
214                 case CR_MACDEF: // ^^macdef <macro-name>
215                         if (*tok++ != SYMBOL)
216                                 return error(missym_error);
217
218                         p = string[*tok++];
219                         w = (lookup(p, MACRO, 0) == NULL ? 0 : 1);
220                         *evalTokenBuffer.u32++ = CONST;
221                         *evalTokenBuffer.u64++ = (uint64_t)w;
222                         break;
223                 case CR_DEFINED:
224                         w = DEFINED;
225                         goto getsym;
226                 case CR_REFERENCED:
227                         w = REFERENCED;
228 getsym:
229                         if (*tok++ != SYMBOL)
230                                 return error(missym_error);
231
232                         p = string[*tok++];
233                         int j = (*p == '.' ? curenv : 0);
234                         SYM * sy = lookup(p, LABEL, j);
235                         w = ((sy != NULL) && (sy->sattr & w ? 1 : 0));
236                         *evalTokenBuffer.u32++ = CONST;
237                         *evalTokenBuffer.u64++ = (uint64_t)w;
238                         break;
239                 case CR_STREQ:
240                         if (*tok != SYMBOL && *tok != STRING)
241                                 return error(str_error);
242
243                         p = string[tok[1]];
244                         tok +=2;
245
246                         if (*tok++ != ',')
247                                 return error(comma_error);
248
249                         if (*tok != SYMBOL && *tok != STRING)
250                                 return error(str_error);
251
252                         char * p2 = string[tok[1]];
253                         tok += 2;
254
255                         w = (WORD)(!strcmp(p, p2));
256                         *evalTokenBuffer.u32++ = CONST;
257                         *evalTokenBuffer.u64++ = (uint64_t)w;
258                         break;
259                 }
260         }
261         else
262                 return expr2();
263
264         return OK;
265 }
266
267
268 //
269 // Terminals (CONSTs) and parenthesis grouping
270 //
271 int expr2(void)
272 {
273         PTR ptk;
274
275         switch (*tok++)
276         {
277         case CONST:
278                 ptk.u32 = tok;
279                 *evalTokenBuffer.u32++ = CONST;
280                 *evalTokenBuffer.u64++ = *ptk.u64++;
281                 tok = ptk.u32;
282                 break;
283         case FCONST:
284                 ptk.u32 = tok;
285                 *evalTokenBuffer.u32++ = FCONST;
286                 *evalTokenBuffer.u64++ = *ptk.u64++;
287                 tok = ptk.u32;
288                 break;
289         case SYMBOL:
290         {
291                 char * p = string[*tok++];
292                 int j = (*p == '.' ? curenv : 0);
293                 SYM * sy = lookup(p, LABEL, j);
294
295                 if (sy == NULL)
296                         sy = NewSymbol(p, LABEL, j);
297
298                 // Check register bank usage
299                 if (sy->sattre & EQUATEDREG)
300                 {
301                         if ((regbank == BANK_0) && (sy->sattre & BANK_1) && !altbankok)
302                                 warn("equated symbol \'%s\' cannot be used in register bank 0", sy->sname);
303
304                         if ((regbank == BANK_1) && (sy->sattre & BANK_0) && !altbankok)
305                                 warn("equated symbol \'%s\' cannot be used in register bank 1", sy->sname);
306                 }
307
308                 *evalTokenBuffer.u32++ = SYMBOL;
309                 *evalTokenBuffer.u32++ = symbolNum;
310                 symbolPtr[symbolNum] = sy;
311                 symbolNum++;
312                 break;
313         }
314         case STRING:
315                 *evalTokenBuffer.u32++ = CONST;
316                 *evalTokenBuffer.u64++ = str_value(string[*tok++]);
317                 break;
318         case '(':
319                 if (expr0() != OK)
320                         return ERROR;
321
322                 if (*tok++ != ')')
323                         return error("missing closing parenthesis ')'");
324
325                 break;
326         case '[':
327                 if (expr0() != OK)
328                         return ERROR;
329
330                 if (*tok++ != ']')
331                         return error("missing closing bracket ']'");
332
333                 break;
334         case '{':
335                 if (expr0() != OK)      // Eat up first parameter (register or immediate)
336                         return ERROR;
337
338                 if (*tok++ != ':')      // Demand a ':' there
339                         return error("missing colon ':'");
340
341                 if (expr0() != OK)      // Eat up second parameter (register or immediate)
342                         return ERROR;
343
344                 if (*tok++ != '}')
345                         return error("missing closing brace '}'");
346
347                 break;
348         case '$':
349                 *evalTokenBuffer.u32++ = ACONST;                        // Attributed const
350                 *evalTokenBuffer.u32++ = sloc;                          // Current location
351                 *evalTokenBuffer.u32++ = cursect | DEFINED;     // Store attribs
352                 break;
353         case '*':
354                 *evalTokenBuffer.u32++ = ACONST;                        // Attributed const
355
356                 // pcloc == location at start of line
357                 *evalTokenBuffer.u32++ = (orgactive ? orgaddr : pcloc);
358                 // '*' takes attributes of current section, not ABS!
359                 *evalTokenBuffer.u32++ = cursect | DEFINED;
360                 break;
361         default:
362                 return error("bad expression");
363         }
364
365         return OK;
366 }
367
368
369 //
370 // Recursive-descent expression analyzer (with some simple speed hacks)
371 //
372 int expr(TOKEN * otk, uint64_t * a_value, WORD * a_attr, SYM ** a_esym)
373 {
374         // Passed in values (once derefenced, that is) can all be zero. They are
375         // there so that the expression analyzer can fill them in as needed. The
376         // expression analyzer gets its input from the global token pointer "tok",
377         // and not from anything passed in by the user.
378         SYM * symbol;
379         char * p;
380         int j;
381         PTR ptk;
382
383         evalTokenBuffer.u32 = otk;      // Set token pointer to 'exprbuf' (direct.c)
384                                                         // Also set in various other places too (riscasm.c,
385                                                         // e.g.)
386
387 //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]]);
388         // Optimize for single constant or single symbol.
389         // Shamus: Subtle bug here. EOL token is 101; if you have a constant token
390         //         followed by the value 101, it will trigger a bad evaluation here.
391         //         This is probably a really bad assumption to be making here...!
392         //         (assuming tok[1] == EOL is a single token that is)
393         //         Seems that even other tokens (SUNARY type) can fuck this up too.
394 #if 0
395 //      if ((tok[1] == EOL)
396         if ((tok[1] == EOL && ((tok[0] != CONST || tok[0] != FCONST) && tokenClass[tok[0]] != SUNARY))
397 //              || (((*tok == CONST || *tok == FCONST || *tok == SYMBOL) || (*tok >= KW_R0 && *tok <= KW_R31))
398 //              && (tokenClass[tok[2]] < UNARY)))
399                 || (((tok[0] == SYMBOL) || (tok[0] >= KW_R0 && tok[0] <= KW_R31))
400                         && (tokenClass[tok[2]] < UNARY))
401                 || ((tok[0] == CONST || tok[0] == FCONST) && (tokenClass[tok[3]] < UNARY))
402                 )
403 #else
404 // 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:
405         if ((tok[1] == EOL
406                         && (tok[0] != CONST && tokenClass[tok[0]] != SUNARY))
407                 || (((tok[0] == SYMBOL)
408                                 || (tok[0] >= KW_R0 && tok[0] <= KW_R31))
409                         && (tokenClass[tok[2]] < UNARY))
410                 || ((tok[0] == CONST) && (tokenClass[tok[3]] < UNARY))
411                 )
412 // 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
413 #endif
414         {
415                 if (*tok >= KW_R0 && *tok <= KW_R31)
416                 {
417                         *evalTokenBuffer.u32++ = CONST;
418                         *evalTokenBuffer.u64++ = *a_value = (*tok - KW_R0);
419                         *a_attr = ABS | DEFINED | RISCREG;
420
421                         if (a_esym != NULL)
422                                 *a_esym = NULL;
423
424                         tok++;
425                 }
426                 else if (*tok == CONST)
427                 {
428                         ptk.u32 = tok;
429                         *evalTokenBuffer.u32++ = *ptk.u32++;
430                         *evalTokenBuffer.u64++ = *a_value = *ptk.u64++;
431                         *a_attr = ABS | DEFINED;
432                         tok = ptk.u32;
433
434                         if (a_esym != NULL)
435                                 *a_esym = NULL;
436
437 //printf("Quick eval in expr(): CONST = %i, tokenClass[tok[2]] = %i\n", *a_value, tokenClass[*tok]);
438                 }
439 // Not sure that removing float constant here is going to break anything and/or
440 // make things significantly slower, but having this here seems to cause the
441 // complexity of the check to get to this part of the parse to go through the
442 // roof, and dammit, I just don't feel like fighting that fight ATM. :-P
443 #if 0
444                 else if (*tok == FCONST)
445                 {
446                         *evalTokenBuffer.u32++ = *tok++;
447                         *evalTokenBuffer.u64++ = *a_value = *tok.u64++;
448                         *a_attr = ABS | DEFINED | FLOAT;
449
450                         if (a_esym != NULL)
451                                 *a_esym = NULL;
452
453 //printf("Quick eval in expr(): CONST = %i, tokenClass[tok[2]] = %i\n", *a_value, tokenClass[*tok]);
454                 }
455 #endif
456                 else if (*tok == '*')
457                 {
458                         *evalTokenBuffer.u32++ = CONST;
459
460                         if (orgactive)
461                                 *evalTokenBuffer.u64++ = *a_value = orgaddr;
462                         else
463                                 *evalTokenBuffer.u64++ = *a_value = pcloc;
464
465                         // '*' takes attributes of current section, not ABS!
466                         *a_attr = cursect | DEFINED;
467
468                         if (a_esym != NULL)
469                                 *a_esym = NULL;
470
471                         tok++;
472                 }
473                 else if (*tok == STRING || *tok == SYMBOL)
474                 {
475                         p = string[tok[1]];
476                         j = (*p == '.' ? curenv : 0);
477                         symbol = lookup(p, LABEL, j);
478 #if 0
479 printf("eval: Looking up symbol (%s) [=%08X]\n", p, symbol);
480 if (symbol)
481         printf("      attr=%04X, attre=%08X, val=%i, name=%s\n", symbol->sattr, symbol->sattre, symbol->svalue, symbol->sname);
482 #endif
483
484                         if (symbol == NULL)
485                                 symbol = NewSymbol(p, LABEL, j);
486
487                         symbol->sattr |= REFERENCED;
488
489                         // Check for undefined register equates, but only if it's not part
490                         // of a #<SYMBOL> construct, as it could be that the label that's
491                         // been undefined may later be used as an address label--which
492                         // means it will be fixed up later, and thus, not an error.
493                         if ((symbol->sattre & UNDEF_EQUR) && !riscImmTokenSeen)
494                         {
495                                 error("undefined register equate '%s'", symbol->sname);
496 //if we return right away, it returns some spurious errors...
497 //                              return ERROR;
498                         }
499
500                         // Check register bank usage
501                         if (symbol->sattre & EQUATEDREG)
502                         {
503                                 if ((regbank == BANK_0) && (symbol->sattre & BANK_1) && !altbankok)
504                                         warn("equated symbol '%s' cannot be used in register bank 0", symbol->sname);
505
506                                 if ((regbank == BANK_1) && (symbol->sattre & BANK_0) && !altbankok)
507                                         warn("equated symbol '%s' cannot be used in register bank 1", symbol->sname);
508                         }
509
510                         *evalTokenBuffer.u32++ = SYMBOL;
511 #if 0
512                         *evalTokenBuffer++ = (TOKEN)symbol;
513 #else
514 /*
515 While this approach works, it's wasteful. It would be better to use something
516 that's already available, like the symbol "order defined" table (which needs to
517 be converted from a linked list into an array).
518 */
519                         *evalTokenBuffer.u32++ = symbolNum;
520                         symbolPtr[symbolNum] = symbol;
521                         symbolNum++;
522 #endif
523
524                         *a_value = (symbol->sattr & DEFINED ? symbol->svalue : 0);
525                         *a_attr = (WORD)(symbol->sattr & ~GLOBAL);
526
527 /*
528 All that extra crap that was put into the svalue when doing the equr stuff is
529 thrown away right here. What the hell is it for?
530 */
531                         if (symbol->sattre & EQUATEDREG)
532                         {
533                                 *a_value &= 0x1F;
534                                 *a_attr |= RISCREG; // Mark it as a register, 'cause it is
535                                 *a_esym = symbol;
536                         }
537
538                         if ((symbol->sattr & (GLOBAL | DEFINED)) == GLOBAL
539                                 && a_esym != NULL)
540                                 *a_esym = symbol;
541
542                         tok += 2;
543                 }
544                 // Holy hell... This is likely due to the fact that LSR is mistakenly set as a SUNARY type... Need to fix this... !!! FIX !!!
545                 else if (m6502)
546                 {
547                         *evalTokenBuffer.u32++ = *tok++;
548                 }
549                 else
550                 {
551                         // Unknown type here... Alert the user!,
552                         error("undefined RISC register in expression [token=$%X]", *tok);
553                         // Prevent spurious error reporting...
554                         tok++;
555                         return ERROR;
556                 }
557
558                 *evalTokenBuffer.u32++ = ENDEXPR;
559                 return OK;
560         }
561
562         if (expr0() != OK)
563                 return ERROR;
564
565         *evalTokenBuffer.u32++ = ENDEXPR;
566         return evexpr(otk, a_value, a_attr, a_esym);
567 }
568
569
570 //
571 // Evaluate expression.
572 // If the expression involves only ONE external symbol, the expression is
573 // UNDEFINED, but it's value includes everything but the symbol value, and
574 // 'a_esym' is set to the external symbol.
575 //
576 int evexpr(TOKEN * _tk, uint64_t * a_value, WORD * a_attr, SYM ** a_esym)
577 {
578         WORD attr;
579         SYM * sy;
580         uint64_t * sval = evstk;                                // (Empty) initial stack
581         WORD * sattr = evattr;
582         SYM * esym = NULL;                                              // No external symbol involved
583         WORD sym_seg = 0;
584         PTR tk;
585         tk.u32 = _tk;
586
587         while (*tk.u32 != ENDEXPR)
588         {
589                 switch ((int)*tk.u32++)
590                 {
591                 case SYMBOL:
592 //printf("evexpr(): SYMBOL\n");
593                         sy = symbolPtr[*tk.u32++];
594                         sy->sattr |= REFERENCED;                // Set "referenced" bit
595
596                         if (!(sy->sattr & DEFINED))
597                         {
598                                 // Reference to undefined symbol
599                                 if (!(sy->sattr & GLOBAL))
600                                 {
601                                         *a_attr = 0;
602                                         *a_value = 0;
603                                         return OK;
604                                 }
605
606                                 if (esym != NULL)                       // Check for multiple externals
607                                         return error(seg_error);
608
609                                 esym = sy;
610                         }
611
612                         if (sy->sattr & DEFINED)
613                                 *++sval = sy->svalue;           // Push symbol's value
614                         else
615                                 *++sval = 0;                            // 0 for undefined symbols
616
617                         *++sattr = (WORD)(sy->sattr & ~GLOBAL); // Push attribs
618                         sym_seg = (WORD)(sy->sattr & TDB);
619                         break;
620
621                 case CONST:
622                         *++sval = *tk.u64++;
623 //printf("evexpr(): CONST = %lX\n", *sval);
624                         *++sattr = ABS | DEFINED;               // Push simple attribs
625                         break;
626
627                 case FCONST:
628 //printf("evexpr(): FCONST = %lf\n", *tk.dp);
629                         // Even though it's a double, we can treat it like a uint64_t since
630                         // we're just moving the bits around.
631                         *++sval = *tk.u64++;
632                         *++sattr = ABS | DEFINED | FLOAT; // Push simple attribs
633                         break;
634
635                 case ACONST:
636 //printf("evexpr(): ACONST = %i\n", *tk.u32);
637                         *++sval = *tk.u32++;                            // Push value
638                         *++sattr = (WORD)*tk.u32++;                     // Push attribs
639                         break;
640
641                         // Binary "+" and "-" matrix:
642                         //
643                         //                ABS    Sect     Other
644                         //     ----------------------------
645                         //   ABS     |  ABS   |  Sect  |  Other |
646                         //   Sect    |  Sect  |  [1]   |  Error |
647                         //   Other   |  Other |  Error |  [1]   |
648                         //      ----------------------------
649                         //
650                         //   [1] + : Error
651                         //       - : ABS
652
653                 case '+':
654 //printf("evexpr(): +\n");
655                         --sval;                                                 // Pop value
656                         --sattr;                                                // Pop attrib
657 //printf("--> N+N: %i + %i = ", *sval, sval[1]);
658                         // Get FLOAT attribute, if any
659                         attr = (sattr[0] | sattr[1]) & FLOAT;
660
661                         // Since adding an int to a fp value promotes it to a fp value, we
662                         // don't care whether it's first or second; we cast to to a double
663                         // regardless.
664                         if (attr == FLOAT)
665                         {
666                                 PTR p;
667                                 p.u64 = sval;
668                                 double fpval1 = (sattr[0] & FLOAT ? *p.dp : (double)*p.i64);
669                                 p.u64++;
670                                 double fpval2 = (sattr[1] & FLOAT ? *p.dp : (double)*p.i64);
671                                 *(double *)sval = fpval1 + fpval2;
672                         }
673                         else
674                         {
675                                 *sval += sval[1];                               // Compute value
676                         }
677 //printf("%i\n", *sval);
678
679                         if (!(*sattr & TDB))
680                                 *sattr = sattr[1] | attr;
681                         else if (sattr[1] & TDB)
682                                 return error(seg_error);
683
684                         break;
685
686                 case '-':
687 //printf("evexpr(): -\n");
688                         --sval;                                                 // Pop value
689                         --sattr;                                                // Pop attrib
690 //printf("--> N-N: %i - %i = ", *sval, sval[1]);
691                         // Get FLOAT attribute, if any
692                         attr = (sattr[0] | sattr[1]) & FLOAT;
693
694                         // Since subtracting an int to a fp value promotes it to a fp
695                         // value, we don't care whether it's first or second; we cast to to
696                         // a double regardless.
697                         if (attr == FLOAT)
698                         {
699                                 PTR p;
700                                 p.u64 = sval;
701                                 double fpval1 = (sattr[0] & FLOAT ? *p.dp : (double)*p.i64);
702                                 p.u64++;
703                                 double fpval2 = (sattr[1] & FLOAT ? *p.dp : (double)*p.i64);
704                                 *(double *)sval = fpval1 - fpval2;
705                         }
706                         else
707                         {
708                                 *sval -= sval[1];
709                         }
710 //printf("%i\n", *sval);
711
712                         *sattr |= attr;                                 // Inherit FLOAT attribute
713                         attr = (WORD)(*sattr & TDB);
714 #if 0
715 printf("EVEXPR (-): sym1 = %X, sym2 = %X\n", attr, sattr[1]);
716 #endif
717                         // If symbol1 is ABS, take attributes from symbol2
718                         if (!attr)
719                                 *sattr = sattr[1];
720                         // Otherwise, they're both TDB and so attributes cancel out
721                         else if (sattr[1] & TDB)
722                                 *sattr &= ~TDB;
723
724                         break;
725
726                 // Unary operators only work on ABS items
727                 case UNMINUS:
728 //printf("evexpr(): UNMINUS\n");
729                         if (*sattr & TDB)
730                                 return error(seg_error);
731
732                         if (*sattr & FLOAT)
733                         {
734                                 double * dst = (double *)sval;
735                                 *dst = -*dst;
736                                 *sattr = ABS | DEFINED | FLOAT; // Expr becomes absolute
737                         }
738                         else
739                         {
740                                 *sval = -(int64_t)*sval;
741                                 *sattr = ABS | DEFINED;                 // Expr becomes absolute
742                         }
743
744                         break;
745
746                 case UNLT: // Unary < (get the low byte of a word)
747 //printf("evexpr(): UNLT\n");
748                         if (*sattr & TDB)
749                                 return error(seg_error);
750
751                         if (*sattr & FLOAT)
752                                 return error(noflt_error);
753
754                         *sval = (int64_t)((*sval) & 0x00FF);
755                         *sattr = ABS | DEFINED;                 // Expr becomes absolute
756                         break;
757
758                 case UNGT: // Unary > (get the high byte of a word)
759 //printf("evexpr(): UNGT\n");
760                         if (*sattr & TDB)
761                                 return error(seg_error);
762
763                         if (*sattr & FLOAT)
764                                 return error(noflt_error);
765
766                         *sval = (int64_t)(((*sval) >> 8) & 0x00FF);
767                         *sattr = ABS | DEFINED;                 // Expr becomes absolute
768                         break;
769
770                 case '!':
771 //printf("evexpr(): !\n");
772                         if (*sattr & TDB)
773                                 return error(seg_error);
774
775                         if (*sattr & FLOAT)
776                                 return error("floating point numbers not allowed with operator '!'.");
777
778                         *sval = !*sval;
779                         *sattr = ABS | DEFINED;                 // Expr becomes absolute
780                         break;
781
782                 case '~':
783 //printf("evexpr(): ~\n");
784                         if (*sattr & TDB)
785                                 return error(seg_error);
786
787                         if (*sattr & FLOAT)
788                                 return error("floating point numbers not allowed with operator '~'.");
789
790                         *sval = ~*sval;
791                         *sattr = ABS | DEFINED;                 // Expr becomes absolute
792                         break;
793
794                 // Comparison operators must have two values that
795                 // are in the same segment, but that's the only requirement.
796                 case LE:
797 //printf("evexpr(): LE\n");
798                         sattr--;
799                         sval--;
800
801                         if ((*sattr & TDB) != (sattr[1] & TDB))
802                                 return error(seg_error);
803
804                         // Get FLOAT attribute, if any
805                         attr = (sattr[0] | sattr[1]) & FLOAT;
806
807                         // Cast any ints in the comparison to double, if there's at least
808                         // one double in the comparison.
809                         if (attr == FLOAT)
810                         {
811                                 PTR p;
812                                 p.u64 = sval;
813                                 double fpval1 = (sattr[0] & FLOAT ? *p.dp : (double)*p.i64);
814                                 p.u64++;
815                                 double fpval2 = (sattr[1] & FLOAT ? *p.dp : (double)*p.i64);
816                                 *sval = (fpval1 <= fpval2);
817                         }
818                         else
819                         {
820                                 *sval = (*sval <= sval[1]);
821                         }
822
823                         *sattr = ABS | DEFINED;
824                         break;
825
826                 case GE:
827 //printf("evexpr(): GE\n");
828                         sattr--;
829                         sval--;
830
831                         if ((*sattr & TDB) != (sattr[1] & TDB))
832                                 return error(seg_error);
833
834                         // Get FLOAT attribute, if any
835                         attr = (sattr[0] | sattr[1]) & FLOAT;
836
837                         // Cast any ints in the comparison to double, if there's at least
838                         // one double in the comparison.
839                         if (attr == FLOAT)
840                         {
841                                 PTR p;
842                                 p.u64 = sval;
843                                 double fpval1 = (sattr[0] & FLOAT ? *p.dp : (double)*p.i64);
844                                 p.u64++;
845                                 double fpval2 = (sattr[1] & FLOAT ? *p.dp : (double)*p.i64);
846                                 *sval = (fpval1 >= fpval2);
847                         }
848                         else
849                         {
850                                 *sval = (*sval >= sval[1]);
851                         }
852
853                         *sattr = ABS | DEFINED;
854                         break;
855
856                 case '>':
857 //printf("evexpr(): >\n");
858                         sattr--;
859                         sval--;
860
861                         if ((*sattr & TDB) != (sattr[1] & TDB))
862                                 return error(seg_error);
863
864                         // Get FLOAT attribute, if any
865                         attr = (sattr[0] | sattr[1]) & FLOAT;
866
867                         // Cast any ints in the comparison to double, if there's at least
868                         // one double in the comparison.
869                         if (attr == FLOAT)
870                         {
871                                 PTR p;
872                                 p.u64 = sval;
873                                 double fpval1 = (sattr[0] & FLOAT ? *p.dp : (double)*p.i64);
874                                 p.u64++;
875                                 double fpval2 = (sattr[1] & FLOAT ? *p.dp : (double)*p.i64);
876                                 *sval = (fpval1 > fpval2);
877                         }
878                         else
879                         {
880                                 *sval = (*sval > sval[1]);
881                         }
882
883                         *sattr = ABS | DEFINED;
884                         break;
885
886                 case '<':
887 //printf("evexpr(): <\n");
888                         sattr--;
889                         sval--;
890
891                         if ((*sattr & TDB) != (sattr[1] & TDB))
892                                 return error(seg_error);
893
894                         // Get FLOAT attribute, if any
895                         attr = (sattr[0] | sattr[1]) & FLOAT;
896
897                         // Cast any ints in the comparison to double, if there's at least
898                         // one double in the comparison.
899                         if (attr == FLOAT)
900                         {
901                                 PTR p;
902                                 p.u64 = sval;
903                                 double fpval1 = (sattr[0] & FLOAT ? *p.dp : (double)*p.i64);
904                                 p.u64++;
905                                 double fpval2 = (sattr[1] & FLOAT ? *p.dp : (double)*p.i64);
906                                 *sval = (fpval1 < fpval2);
907                         }
908                         else
909                         {
910                                 *sval = (*sval < sval[1]);
911                         }
912
913                         *sattr = ABS | DEFINED;         // Expr forced to ABS
914                         break;
915
916                 case NE:
917 //printf("evexpr(): NE\n");
918                         sattr--;
919                         sval--;
920
921                         if ((*sattr & TDB) != (sattr[1] & TDB))
922                                 return error(seg_error);
923
924                         // Get FLOAT attribute, if any
925                         attr = (sattr[0] | sattr[1]) & FLOAT;
926
927                         // Cast any ints in the comparison to double, if there's at least
928                         // one double in the comparison.
929                         if (attr == FLOAT)
930                         {
931                                 PTR p;
932                                 p.u64 = sval;
933                                 double fpval1 = (sattr[0] & FLOAT ? *p.dp : (double)*p.i64);
934                                 p.u64++;
935                                 double fpval2 = (sattr[1] & FLOAT ? *p.dp : (double)*p.i64);
936                                 *sval = (fpval1 != fpval2);
937                         }
938                         else
939                         {
940                                 *sval = (*sval != sval[1]);
941                         }
942
943                         *sattr = ABS | DEFINED;         // Expr forced to ABS
944                         break;
945
946                 case '=':
947 //printf("evexpr(): =\n");
948                         sattr--;
949                         sval--;
950
951                         if ((*sattr & TDB) != (sattr[1] & TDB))
952                                 return error(seg_error);
953
954                         // Get FLOAT attribute, if any
955                         attr = (sattr[0] | sattr[1]) & FLOAT;
956
957                         // Cast any ints in the comparison to double, if there's at least
958                         // one double in the comparison.
959                         if (attr == FLOAT)
960                         {
961                                 PTR p;
962                                 p.u64 = sval;
963                                 double fpval1 = (sattr[0] & FLOAT ? *p.dp : (double)*p.i64);
964                                 p.u64++;
965                                 double fpval2 = (sattr[1] & FLOAT ? *p.dp : (double)*p.i64);
966                                 *sval = (fpval1 == fpval2);
967                         }
968                         else
969                         {
970                                 *sval = (*sval == sval[1]);
971                         }
972
973                         *sattr = ABS | DEFINED;         // Expr forced to ABS
974
975                         break;
976
977                 // All other binary operators must have two ABS items to work with.
978                 // They all produce an ABS value.
979                 // Shamus: Is this true? There's at least one counterexample of legit
980                 //         code where this assumption fails to produce correct code.
981                 default:
982 //printf("evexpr(): default\n");
983
984                         switch ((int)tk.u32[-1])
985                         {
986                         case '*':
987                                 sval--;
988                                 sattr--;
989 //printf("--> NxN: %i x %i = ", *sval, sval[1]);
990                                 // Get FLOAT attribute, if any
991                                 attr = (sattr[0] | sattr[1]) & FLOAT;
992
993                                 // Since multiplying an int to a fp value promotes it to a fp
994                                 // value, we don't care whether it's first or second; it will
995                                 // be cast to a double regardless.
996 /*
997 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.
998 */
999                                 if (attr == FLOAT)
1000                                 {
1001                                         PTR p;
1002                                         p.u64 = sval;
1003                                         double fpval1 = (sattr[0] & FLOAT ? *p.dp : (double)*p.i64);
1004                                         p.u64++;
1005                                         double fpval2 = (sattr[1] & FLOAT ? *p.dp : (double)*p.i64);
1006                                         *(double *)sval = fpval1 * fpval2;
1007                                 }
1008                                 else
1009                                 {
1010                                         *sval *= sval[1];
1011                                 }
1012 //printf("%i\n", *sval);
1013
1014 //no                            *sattr = ABS | DEFINED | attr;          // Expr becomes absolute
1015                                 break;
1016
1017                         case '/':
1018                                 sval--;
1019                                 sattr--;
1020 //printf("--> N/N: %i / %i = ", sval[0], sval[1]);
1021                                 // Get FLOAT attribute, if any
1022                                 attr = (sattr[0] | sattr[1]) & FLOAT;
1023
1024                                 if (attr == FLOAT)
1025                                 {
1026                                         PTR p;
1027                                         p.u64 = sval;
1028                                         double fpval1 = (sattr[0] & FLOAT ? *p.dp : (double)*p.i64);
1029                                         p.u64++;
1030                                         double fpval2 = (sattr[1] & FLOAT ? *p.dp : (double)*p.i64);
1031
1032                                         if (fpval2 == 0)
1033                                                 return error("divide by zero");
1034
1035                                         *(double *)sval = fpval1 / fpval2;
1036                                 }
1037                                 else
1038                                 {
1039                                         if (sval[1] == 0)
1040                                                 return error("divide by zero");
1041 //printf("--> N/N: %i / %i = ", sval[0], sval[1]);
1042
1043                                         // Compiler is picky here: Without casting these, it
1044                                         // discards the sign if dividing a negative # by a
1045                                         // positive one, creating a bad result. :-/
1046                                         // Definitely a side effect of using uint32_ts intead of
1047                                         // ints.
1048                                         *sval = (int32_t)sval[0] / (int32_t)sval[1];
1049                                 }
1050 //printf("%i\n", *sval);
1051
1052 //no                            *sattr = ABS | DEFINED | attr;          // Expr becomes absolute
1053                                 break;
1054
1055                         case '%':
1056                                 sval--;
1057                                 sattr--;
1058
1059                                 if ((*sattr | sattr[1]) & FLOAT)
1060                                         return error("floating point numbers not allowed with operator '%'.");
1061
1062                                 if (sval[1] == 0)
1063                                         return error("mod (%) by zero");
1064
1065                                 *sval %= sval[1];
1066 //no                            *sattr = ABS | DEFINED;                 // Expr becomes absolute
1067                                 break;
1068
1069                         case SHL:
1070                                 sval--;
1071                                 sattr--;                                        // Pop attrib
1072
1073                                 if ((*sattr | sattr[1]) & FLOAT)
1074                                         return error("floating point numbers not allowed with operator '<<'.");
1075
1076                                 *sval <<= sval[1];
1077 //no                            *sattr = ABS | DEFINED;                 // Expr becomes absolute
1078                                 break;
1079
1080                         case SHR:
1081                                 sval--;
1082                                 sattr--;                                        // Pop attrib
1083
1084                                 if ((*sattr | sattr[1]) & FLOAT)
1085                                         return error("floating point numbers not allowed with operator '>>'.");
1086
1087                                 *sval >>= sval[1];
1088 //no                            *sattr = ABS | DEFINED;                 // Expr becomes absolute
1089                                 break;
1090
1091                         case '&':
1092                                 sval--;
1093                                 sattr--;                                        // Pop attrib
1094
1095                                 if ((*sattr | sattr[1]) & FLOAT)
1096                                         return error("floating point numbers not allowed with operator '&'.");
1097
1098                                 *sval &= sval[1];
1099 //no                            *sattr = ABS | DEFINED;                 // Expr becomes absolute
1100                                 break;
1101
1102                         case '^':
1103                                 sval--;
1104                                 sattr--;                                        // Pop attrib
1105
1106                                 if ((*sattr | sattr[1]) & FLOAT)
1107                                         return error("floating point numbers not allowed with operator '^'.");
1108
1109                                 *sval ^= sval[1];
1110 //no                            *sattr = ABS | DEFINED;                 // Expr becomes absolute
1111                                 break;
1112
1113                         case '|':
1114                                 sval--;
1115                                 sattr--;
1116
1117                                 if ((*sattr | sattr[1]) & FLOAT)
1118                                         return error("floating point numbers not allowed with operator '|'.");
1119
1120                                 *sval |= sval[1];
1121 //no                            *sattr = ABS | DEFINED;                 // Expr becomes absolute
1122                                 break;
1123
1124                         default:
1125                                 // Bad operator in expression stream (this should never happen!)
1126                                 interror(5);
1127                         }
1128                 }
1129         }
1130
1131         if (esym != NULL)
1132                 *sattr &= ~DEFINED;
1133
1134         if (a_esym != NULL)
1135                 *a_esym = esym;
1136
1137         // Copy value + attrib into return variables
1138         *a_value = *sval;
1139         *a_attr = *sattr;
1140
1141         return OK;
1142 }
1143
1144
1145 //
1146 // Count the # of tokens in the passed in expression
1147 // N.B.: 64-bit constants count as two tokens each
1148 //
1149 uint16_t ExpressionLength(TOKEN * tk)
1150 {
1151         uint16_t length;
1152
1153         for(length=0; tk[length]!=ENDEXPR; length++)
1154         {
1155                 // Add one to length for 2X tokens, two for 3X tokens
1156                 if (tk[length] == SYMBOL)
1157                         length++;
1158                 else if ((tk[length] == CONST) || (tk[length] == FCONST))
1159                         length += 2;
1160         }
1161
1162         // Add 1 for ENDEXPR
1163         length++;
1164
1165         return length;
1166 }
1167