063066ede1dd58ba9265ae1bba965d5789d4593e
[rmac] / expr.c
1 //
2 // RMAC - Reboot's Macro Assembler for the Atari Jaguar Console System
3 // EXPR.C - Expression Analyzer
4 // Copyright (C) 199x Landon Dyer, 2011 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 VALUE 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, 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 symbolNum;                                       // Pointer to the entry in symbolPtr[]
59
60
61 //
62 // Obtain a string value
63 //
64 static VALUE str_value(char * p)
65 {
66         VALUE 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         int i;
81         char * p;
82
83         // Initialize token-class table (all set to END)
84         for(i=0; i<256; i++)
85                 tokenClass[i] = END;
86
87         for(i=0, 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         TOKEN t;
105
106         if (expr1() != OK)
107                 return ERROR;
108         
109         while (tokenClass[*tok] >= MULT)
110         {
111                 t = *tok++;
112
113                 if (expr1() != OK)
114                         return ERROR;
115
116                 *evalTokenBuffer++ = t;
117         }
118
119         return OK;
120 }
121
122
123 //
124 // Unary operators (detect unary '-')
125 // ggn: If expression starts with a plus then also eat it up.
126 //      For some reason the parser gets confused when this happens and
127 //      emits a "bad expression".
128 //
129 int expr1(void)
130 {
131         int class;
132         TOKEN t;
133         SYM * sy;
134         char * p, * p2;
135         WORD w;
136         int j;
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                 *evalTokenBuffer++ = t;
151         }
152         else if (class == SUNARY)
153         {
154                 switch ((int)*tok++)
155                 {
156                 case CR_ABSCOUNT:
157                         *evalTokenBuffer++ = CONST;
158                         *evalTokenBuffer++ = (LONG)sect[ABS].sloc;
159                         break;
160                 case CR_TIME:
161                         *evalTokenBuffer++ = CONST;
162                         *evalTokenBuffer++ = dos_time();
163                         break;
164                 case CR_DATE:
165                         *evalTokenBuffer++ = CONST;
166                         *evalTokenBuffer++ = dos_date();
167                         break;
168                 case CR_MACDEF:                                    // ^^macdef <macro-name>
169                         if (*tok++ != SYMBOL)
170                                 return error(missym_error);
171
172                         p = string[*tok++];
173                         w = (lookup(p, MACRO, 0) == NULL ? 0 : 1);
174                         *evalTokenBuffer++ = CONST;
175                         *evalTokenBuffer++ = (TOKEN)w;
176                         break;
177                 case CR_DEFINED:
178                         w = DEFINED;
179                         goto getsym;
180                 case CR_REFERENCED:
181                         w = REFERENCED;
182 getsym:
183                         if (*tok++ != SYMBOL)
184                                 return error(missym_error);
185
186                         p = string[*tok++];
187                         j = (*p == '.' ? curenv : 0);
188                         w = ((sy = lookup(p, LABEL, j)) != NULL && (sy->sattr & w) ? 1 : 0);
189                         *evalTokenBuffer++ = CONST;
190                         *evalTokenBuffer++ = (TOKEN)w;
191                         break;
192                 case CR_STREQ:
193                         if (*tok != SYMBOL && *tok != STRING)
194                                 return error(str_error);
195
196                         p = string[tok[1]];
197                         tok +=2;
198
199                         if (*tok++ != ',')
200                                 return error(comma_error);
201
202                         if (*tok != SYMBOL && *tok != STRING)
203                                 return error(str_error);
204
205                         p2 = string[tok[1]];
206                         tok += 2;
207
208                         w = (WORD)(!strcmp(p, p2));
209                         *evalTokenBuffer++ = CONST;
210                         *evalTokenBuffer++ = (TOKEN)w;
211                         break;
212                 }
213         }
214         else 
215                 return expr2();
216
217         return OK;
218 }
219
220
221 //
222 // Terminals (CONSTs) and parenthesis grouping
223 //
224 int expr2(void)
225 {
226         char * p;
227         SYM * sy;
228         int j;
229
230         switch ((int)*tok++)
231         {
232         case CONST:
233                 *evalTokenBuffer++ = CONST;
234                 *evalTokenBuffer++ = *tok++;
235                 break;
236         case SYMBOL:
237                 p = string[*tok++];
238                 j = (*p == '.' ? curenv : 0);
239                 sy = lookup(p, LABEL, j);
240
241                 if (sy == NULL)
242                         sy = NewSymbol(p, LABEL, j);
243
244                 // Check register bank usage
245                 if (sy->sattre & EQUATEDREG)
246                 {
247                         if ((regbank == BANK_0) && (sy->sattre & BANK_1) && !altbankok)   
248                                 warns("equated symbol \'%s\' cannot be used in register bank 0", sy->sname);
249
250                         if ((regbank == BANK_1) && (sy->sattre & BANK_0) && !altbankok)
251                                 warns("equated symbol \'%s\' cannot be used in register bank 1", sy->sname);
252                 }
253
254                 *evalTokenBuffer++ = SYMBOL;
255                 *evalTokenBuffer++ = symbolNum;
256                 symbolPtr[symbolNum] = sy;
257                 symbolNum++;
258                 break;
259         case STRING:
260                 *evalTokenBuffer++ = CONST;
261                 *evalTokenBuffer++ = str_value(string[*tok++]);
262                 break;
263         case '(':
264                 if (expr0() != OK)
265                         return ERROR;
266
267                 if (*tok++ != ')')
268                         return error("missing close parenthesis ')'");
269
270                 break;
271         case '[':
272                 if (expr0() != OK)
273                         return ERROR;
274
275                 if (*tok++ != ']')
276                         return error("missing close parenthesis ']'");
277
278                 break;
279         case '$':
280                 *evalTokenBuffer++ = ACONST;                            // Attributed const
281                 *evalTokenBuffer++ = sloc;                                      // Current location
282                 *evalTokenBuffer++ = cursect | DEFINED;         // Store attribs
283                 break;
284         case '*':
285                 *evalTokenBuffer++ = ACONST;                            // Attributed const
286
287                 // pcloc == location at start of line
288                 *evalTokenBuffer++ = (orgactive ? orgaddr : pcloc);
289                 // '*' takes attributes of current section, not ABS!
290                 *evalTokenBuffer++ = cursect | DEFINED;
291                 break;
292         default:
293                 return error("bad expression");
294         }
295
296         return OK;
297 }
298
299
300 //
301 // Recursive-descent expression analyzer (with some simple speed hacks)
302 //
303 int expr(TOKEN * otk, VALUE * a_value, WORD * a_attr, SYM ** a_esym)
304 {
305         // Passed in values (once derefenced, that is) can all be zero. They are
306         // there so that the expression analyzer can fill them in as needed. The
307         // expression analyzer gets its input from the global token pointer "tok",
308         // and not from anything passed in by the user.
309         SYM * symbol;
310         char * p;
311         int j;
312
313         evalTokenBuffer = otk;  // Set token pointer to 'exprbuf' (direct.c)
314                                                         // Also set in various other places too (riscasm.c, e.g.)
315
316 //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]]);
317         // Optimize for single constant or single symbol.
318         // Shamus: Subtle bug here. EOL token is 101; if you have a constant token
319         //         followed by the value 101, it will trigger a bad evaluation here.
320         //         This is probably a really bad assumption to be making here...!
321         //         (assuming tok[1] == EOL is a single token that is)
322         //         Seems that even other tokens (SUNARY type) can fuck this up too.
323 //      if ((tok[1] == EOL)
324         if ((tok[1] == EOL && (tok[0] != CONST && tokenClass[tok[0]] != SUNARY))
325                 || (((*tok == CONST || *tok == SYMBOL) || (*tok >= KW_R0 && *tok <= KW_R31))
326                 && (tokenClass[tok[2]] < UNARY)))
327         {
328                 if (*tok >= KW_R0 && *tok <= KW_R31)
329                 {
330                         *evalTokenBuffer++ = CONST;
331                         *evalTokenBuffer++ = *a_value = (*tok - KW_R0);
332                         *a_attr = ABS | DEFINED;
333
334                         if (a_esym != NULL)
335                                 *a_esym = NULL;
336
337                         tok++;
338                 }
339                 else if (*tok == CONST)
340                 {
341                         *evalTokenBuffer++ = CONST;
342                         *evalTokenBuffer++ = *a_value = tok[1];
343                         *a_attr = ABS | DEFINED;
344
345                         if (a_esym != NULL)
346                                 *a_esym = NULL;
347
348                         tok += 2;
349 //printf("Quick eval in expr(): CONST = %i, tokenClass[tok[2]] = %i\n", *a_value, tokenClass[*tok]);
350                 }
351                 else if (*tok == '*')
352                 {
353                         *evalTokenBuffer++ = CONST;
354
355                         if (orgactive)
356                                 *evalTokenBuffer++ = *a_value = orgaddr;
357                         else
358                                 *evalTokenBuffer++ = *a_value = pcloc;
359
360                         // '*' takes attributes of current section, not ABS!
361                         *a_attr = cursect | DEFINED;
362
363                         if (a_esym != NULL)
364                                 *a_esym = NULL;
365
366                         tok++;
367                 }
368                 else if (*tok == STRING || *tok == SYMBOL)
369                 {
370                         p = string[tok[1]];
371                         j = (*p == '.' ? curenv : 0);
372                         symbol = lookup(p, LABEL, j);
373 #if 0
374 printf("eval: Looking up symbol (%s) [=%08X]\n", p, symbol);
375 if (symbol)
376         printf("      attr=%04X, attre=%08X, val=%i, name=%s\n", symbol->sattr, symbol->sattre, symbol->svalue, symbol->sname);
377 #endif
378
379                         if (symbol == NULL)
380                                 symbol = NewSymbol(p, LABEL, j);
381
382                         symbol->sattr |= REFERENCED;
383
384                         // Check for undefined register equates, but only if it's not part
385                         // of a #<SYMBOL> construct, as it could be that the label that's
386                         // been undefined may later be used as an address label--which
387                         // means it will be fixed up later, and thus, not an error.
388                         if ((symbol->sattre & UNDEF_EQUR) && !riscImmTokenSeen)
389                         {
390                                 errors("undefined register equate '%s'", symbol->sname);
391 //if we return right away, it returns some spurious errors...
392 //                              return ERROR;
393                         }
394
395                         // Check register bank usage
396                         if (symbol->sattre & EQUATEDREG)
397                         {
398                                 if ((regbank == BANK_0) && (symbol->sattre & BANK_1) && !altbankok)   
399                                         warns("equated symbol '%s' cannot be used in register bank 0", symbol->sname);
400
401                                 if ((regbank == BANK_1) && (symbol->sattre & BANK_0) && !altbankok)
402                                         warns("equated symbol '%s' cannot be used in register bank 1", symbol->sname);
403                         }
404
405                         *evalTokenBuffer++ = SYMBOL;
406 #if 0
407                         *evalTokenBuffer++ = (TOKEN)symbol;
408 #else
409 /*
410 While this approach works, it's wasteful. It would be better to use something
411 that's already available, like the symbol "order defined" table (which needs to
412 be converted from a linked list into an array).
413 */
414                         *evalTokenBuffer++ = symbolNum;
415                         symbolPtr[symbolNum] = symbol;
416                         symbolNum++;
417 #endif
418
419                         if (symbol->sattr & DEFINED)
420                                 *a_value = symbol->svalue;
421                         else
422                                 *a_value = 0;
423
424 /*
425 All that extra crap that was put into the svalue when doing the equr stuff is
426 thrown away right here. What the hell is it for?
427 */
428                         if (symbol->sattre & EQUATEDREG) 
429                                 *a_value &= 0x1F;
430
431                         *a_attr = (WORD)(symbol->sattr & ~GLOBAL);
432
433                         if ((symbol->sattr & (GLOBAL | DEFINED)) == GLOBAL
434                                 && a_esym != NULL)
435                                 *a_esym = symbol;
436
437                         tok += 2;
438                 }
439                 else
440                 {
441                         // Unknown type here... Alert the user!,
442                         error("undefined RISC register in expression");
443                         // Prevent spurious error reporting...
444                         tok++;
445                         return ERROR;
446                 }
447
448                 *evalTokenBuffer++ = ENDEXPR;
449                 return OK;
450         }
451
452         if (expr0() != OK)
453                 return ERROR;
454
455         *evalTokenBuffer++ = ENDEXPR;
456         return evexpr(otk, a_value, a_attr, a_esym);
457 }
458
459
460 //
461 // Evaluate expression.
462 // If the expression involves only ONE external symbol, the expression is
463 // UNDEFINED, but it's value includes everything but the symbol value, and
464 // `a_esym' is set to the external symbol.
465 //
466 int evexpr(TOKEN * tk, VALUE * a_value, WORD * a_attr, SYM ** a_esym)
467 {
468         WORD * sattr;
469         VALUE * sval;
470         WORD attr;
471         SYM * sy;
472         SYM * esym;
473         WORD sym_seg;
474
475         sval = evstk;                                                   // (Empty) initial stack
476         sattr = evattr;
477         esym = NULL;                                                    // No external symbol involved
478         sym_seg = 0;
479
480         while (*tk != ENDEXPR)
481         {
482                 switch ((int)*tk++)
483                 {
484                 case SYMBOL:
485 //printf("evexpr(): SYMBOL\n");
486                         sy = symbolPtr[*tk++];
487                         sy->sattr |= REFERENCED;                // Set "referenced" bit 
488
489                         if (!(sy->sattr & DEFINED))
490                         {
491                                 // Reference to undefined symbol
492                                 if (!(sy->sattr & GLOBAL))
493                                 {
494                                         *a_attr = 0;
495                                         *a_value = 0;
496                                         return OK;
497                                 }
498
499                                 if (esym != NULL)                       // Check for multiple externals
500                                         return error(seg_error);
501
502                                 esym = sy;
503                         }
504
505                         if (sy->sattr & DEFINED)
506                         {
507                                 *++sval = sy->svalue;           // Push symbol's value
508                         }
509                         else
510                         {
511                                 *++sval = 0;                            // 0 for undefined symbols 
512                         }
513
514                         *++sattr = (WORD)(sy->sattr & ~GLOBAL); // Push attribs
515                         sym_seg = (WORD)(sy->sattr & TDB);
516                         break;
517                 case CONST:
518 //printf("evexpr(): CONST = %i\n", *tk);
519                         *++sval = *tk++;                                // Push value
520                         *++sattr = ABS | DEFINED;               // Push simple attribs
521                         break;
522                 case ACONST:
523 //printf("evexpr(): ACONST = %i\n", *tk);
524                         *++sval = *tk++;                                // Push value
525                         *++sattr = (WORD)*tk++;                 // Push attribs
526                         break;
527
528                         // Binary "+" and "-" matrix:
529                         // 
530                         //                ABS    Sect     Other
531                         //     ----------------------------
532                         //   ABS     |  ABS   |  Sect  |  Other |
533                         //   Sect    |  Sect  |  [1]   |  Error |
534                         //   Other   |  Other |  Error |  [1]   |
535                         //      ----------------------------
536                         // 
537                         //   [1] + : Error
538                         //       - : ABS
539                 case '+':
540 //printf("evexpr(): +\n");
541                         --sval;                                                 // Pop value
542                         --sattr;                                                // Pop attrib 
543 //printf("--> N+N: %i + %i = ", *sval, sval[1]);
544                         *sval += sval[1];                               // Compute value
545 //printf("%i\n", *sval);
546
547                         if (!(*sattr & TDB))
548                                 *sattr = sattr[1];
549                         else if (sattr[1] & TDB)
550                                 return error(seg_error);
551
552                         break;
553                 case '-':
554 //printf("evexpr(): -\n");
555                         --sval;                                                 // Pop value
556                         --sattr;                                                // Pop attrib 
557 //printf("--> N-N: %i - %i = ", *sval, sval[1]);
558                         *sval -= sval[1];                               // Compute value
559 //printf("%i\n", *sval);
560
561                         attr = (WORD)(*sattr & TDB);
562 #if 0
563 printf("EVEXPR (-): sym1 = %X, sym2 = %X\n", attr, sattr[1]);
564 #endif
565                         // If symbol1 is ABS, take attributes from symbol2
566                         if (!attr)
567                                 *sattr = sattr[1];
568                         // Otherwise, they're both TDB and so attributes cancel out
569                         else if (sattr[1] & TDB)
570                                 *sattr &= ~TDB;
571
572                         break;
573                 // Unary operators only work on ABS items
574                 case UNMINUS:
575 //printf("evexpr(): UNMINUS\n");
576                         if (*sattr & TDB)
577                                 error(seg_error);
578
579                         *sval = -(int)*sval;
580                         *sattr = ABS | DEFINED;                 // Expr becomes absolute
581                         break;
582                 case '!':
583 //printf("evexpr(): !\n");
584                         if (*sattr & TDB)
585                                 error(seg_error);
586
587                         *sval = !*sval;
588                         *sattr = ABS | DEFINED;                 // Expr becomes absolute
589                         break;
590                 case '~':
591 //printf("evexpr(): ~\n");
592                         if (*sattr & TDB)
593                                 error(seg_error);
594
595                         *sval = ~*sval;
596                         *sattr = ABS | DEFINED;                 // Expr becomes absolute
597                         break;
598                 // Comparison operators must have two values that
599                 // are in the same segment, but that's the only requirement.
600                 case LE:
601 //printf("evexpr(): LE\n");
602                         --sattr;
603                         --sval;
604
605                         if ((*sattr & TDB) != (sattr[1] & TDB))
606                                 error(seg_error);
607
608                         *sattr = ABS | DEFINED;
609                         *sval = *sval <= sval[1];
610                         break;
611                 case GE:
612 //printf("evexpr(): GE\n");
613                         --sattr;
614                         --sval;
615
616                         if ((*sattr & TDB) != (sattr[1] & TDB))
617                                 error(seg_error);
618
619                         *sattr = ABS | DEFINED;
620                         *sval = *sval >= sval[1];
621                         break;
622                 case '>':
623 //printf("evexpr(): >\n");
624                         --sattr;
625                         --sval;
626
627                         if ((*sattr & TDB) != (sattr[1] & TDB))
628                                 error(seg_error);
629
630                         *sattr = ABS | DEFINED;
631                         *sval = *sval > sval[1];
632                         break;
633                 case '<':
634 //printf("evexpr(): <\n");
635                         --sattr;
636                         --sval;
637
638                         if ((*sattr & TDB) != (sattr[1] & TDB))
639                                 error(seg_error);
640
641                         *sattr = ABS | DEFINED;
642                         *sval = *sval < sval[1];
643                         break;
644                 case NE:
645 //printf("evexpr(): NE\n");
646                         --sattr;
647                         --sval;
648
649                         if ((*sattr & TDB) != (sattr[1] & TDB))
650                                 error(seg_error);
651
652                         *sattr = ABS | DEFINED;
653                         *sval = *sval != sval[1];
654                         break;
655                 case '=':
656 //printf("evexpr(): =\n");
657                         --sattr;
658                         --sval;
659
660                         if ((*sattr & TDB) != (sattr[1] & TDB))
661                                 error(seg_error);
662
663                         *sattr = ABS | DEFINED;
664                         *sval = *sval == sval[1];
665                         break;
666                 // All other binary operators must have two ABS items
667                 // to work with.  They all produce an ABS value.
668                 default:
669 //printf("evexpr(): default\n");
670                         // GH - Removed for v1.0.15 as part of the fix for indexed loads.
671                         //if ((*sattr & (TEXT|DATA|BSS)) || (*--sattr & (TEXT|DATA|BSS)))
672                         //error(seg_error);
673                         *sattr = ABS | DEFINED;                 // Expr becomes absolute
674
675                         switch ((int)tk[-1])
676                         {
677                         case '*':
678                                 --sval;
679                                 --sattr;                                        // Pop attrib 
680 //printf("--> NxN: %i x %i = ", *sval, sval[1]);
681                                 *sval *= sval[1];
682 //printf("%i\n", *sval);
683                                 break;
684                         case '/':
685                                 --sval;
686                                 --sattr;                                        // Pop attrib 
687
688                                 if (sval[1] == 0)
689                                         return error("divide by zero");
690
691 //printf("--> N/N: %i / %i = ", sval[0], sval[1]);
692                                 // Compiler is picky here: Without casting these, it discards
693                                 // the sign if dividing a negative # by a positive one,
694                                 // creating a bad result. :-/
695                                 // Probably a side effect of using VALUE intead of ints.
696                                 *sval = (int)sval[0] / (int)sval[1];
697 //printf("%i\n", *sval);
698                                 break;
699                         case '%':
700                                 --sval;
701                                 --sattr;                                        // Pop attrib 
702
703                                 if (sval[1] == 0)
704                                         return error("mod (%) by zero");
705
706                                 *sval %= sval[1];
707                                 break;
708                         case SHL:
709                                 --sval;
710                                 --sattr;                                        // Pop attrib 
711                                 *sval <<= sval[1];
712                                 break;
713                         case SHR:
714                                 --sval;
715                                 --sattr;                                        // Pop attrib 
716                                 *sval >>= sval[1];
717                                 break;
718                         case '&':
719                                 --sval;
720                                 --sattr;                                        // Pop attrib 
721                                 *sval &= sval[1];
722                                 break;
723                         case '^':
724                                 --sval;
725                                 --sattr;                                        // Pop attrib 
726                                 *sval ^= sval[1];
727                                 break;
728                         case '|':
729                                 --sval;
730                                 --sattr;                                        // Pop attrib 
731                                 *sval |= sval[1];
732                                 break;
733                         default:
734                                 interror(5);                            // Bad operator in expression stream
735                         }
736                 }
737         }
738
739         if (esym != NULL)
740                 *sattr &= ~DEFINED;
741
742         if (a_esym != NULL)
743                 *a_esym = esym;
744
745         // sym_seg added in 1.0.16 to solve a problem with forward symbols in
746         // expressions where absolute values also existed. The absolutes were
747         // overiding the symbol segments and not being included :(
748         //*a_attr = *sattr | sym_seg;                                        // Copy value + attrib
749
750         *a_attr = *sattr;                                               // Copy value + attrib
751         *a_value = *sval;
752
753         return OK;
754 }
755