eval.c

   1 /* eval.c    expression evaluator for the Netwide Assembler
   2  *
   3  * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
   4  * Julian Hall. All rights reserved. The software is
   5  * redistributable under the licence given in the file "Licence"
   6  * distributed in the NASM archive.
   7  *
   8  * initial version 27/iii/95 by Simon Tatham
   9  */
  10
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <stddef.h>
  14 #include <string.h>
  15 #include <ctype.h>
  16 #include <inttypes.h>
  17
  18 #include "nasm.h"
  19 #include "nasmlib.h"
  20 #include "eval.h"
  21 #include "labels.h"
  22
  23 #define TEMPEXPRS_DELTA 128
  24 #define TEMPEXPR_DELTA 8
  25
  26 static scanner scan;            /* Address of scanner routine */
  27 static efunc error;             /* Address of error reporting routine */
  28 static lfunc labelfunc;         /* Address of label routine */
  29
  30 static struct ofmt *outfmt;     /* Structure of addresses of output routines */
  31
  32 static expr **tempexprs = NULL;
  33 static int ntempexprs;
  34 static int tempexprs_size = 0;
  35
  36 static expr *tempexpr;
  37 static int ntempexpr;
  38 static int tempexpr_size;
  39
  40 static struct tokenval *tokval; /* The current token */
  41 static int i;                   /* The t_type of tokval */
  42
  43 static void *scpriv;
  44 static loc_t *location;         /* Pointer to current line's segment,offset */
  45 static int *opflags;
  46
  47 static struct eval_hints *hint;
  48
  49 extern int in_abs_seg;          /* ABSOLUTE segment flag */
  50 extern int32_t abs_seg;            /* ABSOLUTE segment */
  51 extern int32_t abs_offset;         /* ABSOLUTE segment offset */
  52
  53 /*
  54  * Unimportant cleanup is done to avoid confusing people who are trying
  55  * to debug real memory leaks
  56  */
  57 void eval_cleanup(void)
  58 {
  59     while (ntempexprs)
  60         nasm_free(tempexprs[--ntempexprs]);
  61     nasm_free(tempexprs);
  62 }
  63
  64 /*
  65  * Construct a temporary expression.
  66  */
  67 static void begintemp(void)
  68 {
  69     tempexpr = NULL;
  70     tempexpr_size = ntempexpr = 0;
  71 }
  72
  73 static void addtotemp(int32_t type, int64_t value)
  74 {
  75     while (ntempexpr >= tempexpr_size) {
  76         tempexpr_size += TEMPEXPR_DELTA;
  77         tempexpr = nasm_realloc(tempexpr,
  78                                 tempexpr_size * sizeof(*tempexpr));
  79     }
  80     tempexpr[ntempexpr].type = type;
  81     tempexpr[ntempexpr++].value = value;
  82 }
  83
  84 static expr *finishtemp(void)
  85 {
  86     addtotemp(0L, 0L);          /* terminate */
  87     while (ntempexprs >= tempexprs_size) {
  88         tempexprs_size += TEMPEXPRS_DELTA;
  89         tempexprs = nasm_realloc(tempexprs,
  90                                  tempexprs_size * sizeof(*tempexprs));
  91     }
  92     return tempexprs[ntempexprs++] = tempexpr;
  93 }
  94
  95 /*
  96  * Add two vector datatypes. We have some bizarre behaviour on far-
  97  * absolute segment types: we preserve them during addition _only_
  98  * if one of the segments is a truly pure scalar.
  99  */
 100 static expr *add_vectors(expr * p, expr * q)
 101 {
 102     int preserve;
 103
 104     preserve = is_really_simple(p) || is_really_simple(q);
 105
 106     begintemp();
 107
 108     while (p->type && q->type &&
 109            p->type < EXPR_SEGBASE + SEG_ABS &&
 110            q->type < EXPR_SEGBASE + SEG_ABS) {
 111         int lasttype;
 112
 113         if (p->type > q->type) {
 114             addtotemp(q->type, q->value);
 115             lasttype = q++->type;
 116         } else if (p->type < q->type) {
 117             addtotemp(p->type, p->value);
 118             lasttype = p++->type;
 119         } else {                /* *p and *q have same type */
 120             int32_t sum = p->value + q->value;
 121             if (sum)
 122                 addtotemp(p->type, sum);
 123             lasttype = p->type;
 124             p++, q++;
 125         }
 126         if (lasttype == EXPR_UNKNOWN) {
 127             return finishtemp();
 128         }
 129     }
 130     while (p->type && (preserve || p->type < EXPR_SEGBASE + SEG_ABS)) {
 131         addtotemp(p->type, p->value);
 132         p++;
 133     }
 134     while (q->type && (preserve || q->type < EXPR_SEGBASE + SEG_ABS)) {
 135         addtotemp(q->type, q->value);
 136         q++;
 137     }
 138
 139     return finishtemp();
 140 }
 141
 142 /*
 143  * Multiply a vector by a scalar. Strip far-absolute segment part
 144  * if present.
 145  *
 146  * Explicit treatment of UNKNOWN is not required in this routine,
 147  * since it will silently do the Right Thing anyway.
 148  *
 149  * If `affect_hints' is set, we also change the hint type to
 150  * NOTBASE if a MAKEBASE hint points at a register being
 151  * multiplied. This allows [eax*1+ebx] to hint EBX rather than EAX
 152  * as the base register.
 153  */
 154 static expr *scalar_mult(expr * vect, int32_t scalar, int affect_hints)
 155 {
 156     expr *p = vect;
 157
 158     while (p->type && p->type < EXPR_SEGBASE + SEG_ABS) {
 159         p->value = scalar * (p->value);
 160         if (hint && hint->type == EAH_MAKEBASE &&
 161             p->type == hint->base && affect_hints)
 162             hint->type = EAH_NOTBASE;
 163         p++;
 164     }
 165     p->type = 0;
 166
 167     return vect;
 168 }
 169
 170 static expr *scalarvect(int32_t scalar)
 171 {
 172     begintemp();
 173     addtotemp(EXPR_SIMPLE, scalar);
 174     return finishtemp();
 175 }
 176
 177 static expr *unknown_expr(void)
 178 {
 179     begintemp();
 180     addtotemp(EXPR_UNKNOWN, 1L);
 181     return finishtemp();
 182 }
 183
 184 /*
 185  * The SEG operator: calculate the segment part of a relocatable
 186  * value. Return NULL, as usual, if an error occurs. Report the
 187  * error too.
 188  */
 189 static expr *segment_part(expr * e)
 190 {
 191     int32_t seg;
 192
 193     if (is_unknown(e))
 194         return unknown_expr();
 195
 196     if (!is_reloc(e)) {
 197         error(ERR_NONFATAL, "cannot apply SEG to a non-relocatable value");
 198         return NULL;
 199     }
 200
 201     seg = reloc_seg(e);
 202     if (seg == NO_SEG) {
 203         error(ERR_NONFATAL, "cannot apply SEG to a non-relocatable value");
 204         return NULL;
 205     } else if (seg & SEG_ABS) {
 206         return scalarvect(seg & ~SEG_ABS);
 207     } else if (seg & 1) {
 208         error(ERR_NONFATAL, "SEG applied to something which"
 209               " is already a segment base");
 210         return NULL;
 211     } else {
 212         int32_t base = outfmt->segbase(seg + 1);
 213
 214         begintemp();
 215         addtotemp((base == NO_SEG ? EXPR_UNKNOWN : EXPR_SEGBASE + base),
 216                   1L);
 217         return finishtemp();
 218     }
 219 }
 220
 221 /*
 222  * Recursive-descent parser. Called with a single boolean operand,
 223  * which is TRUE if the evaluation is critical (i.e. unresolved
 224  * symbols are an error condition). Must update the global `i' to
 225  * reflect the token after the parsed string. May return NULL.
 226  *
 227  * evaluate() should report its own errors: on return it is assumed
 228  * that if NULL has been returned, the error has already been
 229  * reported.
 230  */
 231
 232 /*
 233  * Grammar parsed is:
 234  *
 235  * expr  : bexpr [ WRT expr6 ]
 236  * bexpr : rexp0 or expr0 depending on relative-mode setting
 237  * rexp0 : rexp1 [ {||} rexp1...]
 238  * rexp1 : rexp2 [ {^^} rexp2...]
 239  * rexp2 : rexp3 [ {&&} rexp3...]
 240  * rexp3 : expr0 [ {=,==,<>,!=,<,>,<=,>=} expr0 ]
 241  * expr0 : expr1 [ {|} expr1...]
 242  * expr1 : expr2 [ {^} expr2...]
 243  * expr2 : expr3 [ {&} expr3...]
 244  * expr3 : expr4 [ {<<,>>} expr4...]
 245  * expr4 : expr5 [ {+,-} expr5...]
 246  * expr5 : expr6 [ {*,/,%,//,%%} expr6...]
 247  * expr6 : { ~,+,-,SEG } expr6
 248  *       | (bexpr)
 249  *       | symbol
 250  *       | $
 251  *       | number
 252  */
 253
 254 static expr *rexp0(int), *rexp1(int), *rexp2(int), *rexp3(int);
 255
 256 static expr *expr0(int), *expr1(int), *expr2(int), *expr3(int);
 257 static expr *expr4(int), *expr5(int), *expr6(int);
 258
 259 static expr *(*bexpr) (int);
 260
 261 static expr *rexp0(int critical)
 262 {
 263     expr *e, *f;
 264
 265     e = rexp1(critical);
 266     if (!e)
 267         return NULL;
 268
 269     while (i == TOKEN_DBL_OR) {
 270         i = scan(scpriv, tokval);
 271         f = rexp1(critical);
 272         if (!f)
 273             return NULL;
 274         if (!(is_simple(e) || is_just_unknown(e)) ||
 275             !(is_simple(f) || is_just_unknown(f))) {
 276             error(ERR_NONFATAL, "`|' operator may only be applied to"
 277                   " scalar values");
 278         }
 279
 280         if (is_just_unknown(e) || is_just_unknown(f))
 281             e = unknown_expr();
 282         else
 283             e = scalarvect((int32_t)(reloc_value(e) || reloc_value(f)));
 284     }
 285     return e;
 286 }
 287
 288 static expr *rexp1(int critical)
 289 {
 290     expr *e, *f;
 291
 292     e = rexp2(critical);
 293     if (!e)
 294         return NULL;
 295
 296     while (i == TOKEN_DBL_XOR) {
 297         i = scan(scpriv, tokval);
 298         f = rexp2(critical);
 299         if (!f)
 300             return NULL;
 301         if (!(is_simple(e) || is_just_unknown(e)) ||
 302             !(is_simple(f) || is_just_unknown(f))) {
 303             error(ERR_NONFATAL, "`^' operator may only be applied to"
 304                   " scalar values");
 305         }
 306
 307         if (is_just_unknown(e) || is_just_unknown(f))
 308             e = unknown_expr();
 309         else
 310             e = scalarvect((int32_t)(!reloc_value(e) ^ !reloc_value(f)));
 311     }
 312     return e;
 313 }
 314
 315 static expr *rexp2(int critical)
 316 {
 317     expr *e, *f;
 318
 319     e = rexp3(critical);
 320     if (!e)
 321         return NULL;
 322     while (i == TOKEN_DBL_AND) {
 323         i = scan(scpriv, tokval);
 324         f = rexp3(critical);
 325         if (!f)
 326             return NULL;
 327         if (!(is_simple(e) || is_just_unknown(e)) ||
 328             !(is_simple(f) || is_just_unknown(f))) {
 329             error(ERR_NONFATAL, "`&' operator may only be applied to"
 330                   " scalar values");
 331         }
 332         if (is_just_unknown(e) || is_just_unknown(f))
 333             e = unknown_expr();
 334         else
 335             e = scalarvect((int32_t)(reloc_value(e) && reloc_value(f)));
 336     }
 337     return e;
 338 }
 339
 340 static expr *rexp3(int critical)
 341 {
 342     expr *e, *f;
 343     int32_t v;
 344
 345     e = expr0(critical);
 346     if (!e)
 347         return NULL;
 348
 349     while (i == TOKEN_EQ || i == TOKEN_LT || i == TOKEN_GT ||
 350            i == TOKEN_NE || i == TOKEN_LE || i == TOKEN_GE) {
 351         int j = i;
 352         i = scan(scpriv, tokval);
 353         f = expr0(critical);
 354         if (!f)
 355             return NULL;
 356
 357         e = add_vectors(e, scalar_mult(f, -1L, FALSE));
 358
 359         switch (j) {
 360         case TOKEN_EQ:
 361         case TOKEN_NE:
 362             if (is_unknown(e))
 363                 v = -1;         /* means unknown */
 364             else if (!is_really_simple(e) || reloc_value(e) != 0)
 365                 v = (j == TOKEN_NE);    /* unequal, so return TRUE if NE */
 366             else
 367                 v = (j == TOKEN_EQ);    /* equal, so return TRUE if EQ */
 368             break;
 369         default:
 370             if (is_unknown(e))
 371                 v = -1;         /* means unknown */
 372             else if (!is_really_simple(e)) {
 373                 error(ERR_NONFATAL,
 374                       "`%s': operands differ by a non-scalar",
 375                       (j == TOKEN_LE ? "<=" : j == TOKEN_LT ? "<" : j ==
 376                        TOKEN_GE ? ">=" : ">"));
 377                 v = 0;          /* must set it to _something_ */
 378             } else {
 379                 int vv = reloc_value(e);
 380                 if (vv == 0)
 381                     v = (j == TOKEN_LE || j == TOKEN_GE);
 382                 else if (vv > 0)
 383                     v = (j == TOKEN_GE || j == TOKEN_GT);
 384                 else            /* vv < 0 */
 385                     v = (j == TOKEN_LE || j == TOKEN_LT);
 386             }
 387             break;
 388         }
 389
 390         if (v == -1)
 391             e = unknown_expr();
 392         else
 393             e = scalarvect(v);
 394     }
 395     return e;
 396 }
 397
 398 static expr *expr0(int critical)
 399 {
 400     expr *e, *f;
 401
 402     e = expr1(critical);
 403     if (!e)
 404         return NULL;
 405
 406     while (i == '|') {
 407         i = scan(scpriv, tokval);
 408         f = expr1(critical);
 409         if (!f)
 410             return NULL;
 411         if (!(is_simple(e) || is_just_unknown(e)) ||
 412             !(is_simple(f) || is_just_unknown(f))) {
 413             error(ERR_NONFATAL, "`|' operator may only be applied to"
 414                   " scalar values");
 415         }
 416         if (is_just_unknown(e) || is_just_unknown(f))
 417             e = unknown_expr();
 418         else
 419             e = scalarvect(reloc_value(e) | reloc_value(f));
 420     }
 421     return e;
 422 }
 423
 424 static expr *expr1(int critical)
 425 {
 426     expr *e, *f;
 427
 428     e = expr2(critical);
 429     if (!e)
 430         return NULL;
 431
 432     while (i == '^') {
 433         i = scan(scpriv, tokval);
 434         f = expr2(critical);
 435         if (!f)
 436             return NULL;
 437         if (!(is_simple(e) || is_just_unknown(e)) ||
 438             !(is_simple(f) || is_just_unknown(f))) {
 439             error(ERR_NONFATAL, "`^' operator may only be applied to"
 440                   " scalar values");
 441         }
 442         if (is_just_unknown(e) || is_just_unknown(f))
 443             e = unknown_expr();
 444         else
 445             e = scalarvect(reloc_value(e) ^ reloc_value(f));
 446     }
 447     return e;
 448 }
 449
 450 static expr *expr2(int critical)
 451 {
 452     expr *e, *f;
 453
 454     e = expr3(critical);
 455     if (!e)
 456         return NULL;
 457
 458     while (i == '&') {
 459         i = scan(scpriv, tokval);
 460         f = expr3(critical);
 461         if (!f)
 462             return NULL;
 463         if (!(is_simple(e) || is_just_unknown(e)) ||
 464             !(is_simple(f) || is_just_unknown(f))) {
 465             error(ERR_NONFATAL, "`&' operator may only be applied to"
 466                   " scalar values");
 467         }
 468         if (is_just_unknown(e) || is_just_unknown(f))
 469             e = unknown_expr();
 470         else
 471             e = scalarvect(reloc_value(e) & reloc_value(f));
 472     }
 473     return e;
 474 }
 475
 476 static expr *expr3(int critical)
 477 {
 478     expr *e, *f;
 479
 480     e = expr4(critical);
 481     if (!e)
 482         return NULL;
 483
 484     while (i == TOKEN_SHL || i == TOKEN_SHR) {
 485         int j = i;
 486         i = scan(scpriv, tokval);
 487         f = expr4(critical);
 488         if (!f)
 489             return NULL;
 490         if (!(is_simple(e) || is_just_unknown(e)) ||
 491             !(is_simple(f) || is_just_unknown(f))) {
 492             error(ERR_NONFATAL, "shift operator may only be applied to"
 493                   " scalar values");
 494         } else if (is_just_unknown(e) || is_just_unknown(f)) {
 495             e = unknown_expr();
 496         } else
 497             switch (j) {
 498             case TOKEN_SHL:
 499                 e = scalarvect(reloc_value(e) << reloc_value(f));
 500                 break;
 501             case TOKEN_SHR:
 502                 e = scalarvect(((uint32_t)reloc_value(e)) >>
 503                                reloc_value(f));
 504                 break;
 505             }
 506     }
 507     return e;
 508 }
 509
 510 static expr *expr4(int critical)
 511 {
 512     expr *e, *f;
 513
 514     e = expr5(critical);
 515     if (!e)
 516         return NULL;
 517     while (i == '+' || i == '-') {
 518         int j = i;
 519         i = scan(scpriv, tokval);
 520         f = expr5(critical);
 521         if (!f)
 522             return NULL;
 523         switch (j) {
 524         case '+':
 525             e = add_vectors(e, f);
 526             break;
 527         case '-':
 528             e = add_vectors(e, scalar_mult(f, -1L, FALSE));
 529             break;
 530         }
 531     }
 532     return e;
 533 }
 534
 535 static expr *expr5(int critical)
 536 {
 537     expr *e, *f;
 538
 539     e = expr6(critical);
 540     if (!e)
 541         return NULL;
 542     while (i == '*' || i == '/' || i == '%' ||
 543            i == TOKEN_SDIV || i == TOKEN_SMOD) {
 544         int j = i;
 545         i = scan(scpriv, tokval);
 546         f = expr6(critical);
 547         if (!f)
 548             return NULL;
 549         if (j != '*' && (!(is_simple(e) || is_just_unknown(e)) ||
 550                          !(is_simple(f) || is_just_unknown(f)))) {
 551             error(ERR_NONFATAL, "division operator may only be applied to"
 552                   " scalar values");
 553             return NULL;
 554         }
 555         if (j != '*' && !is_unknown(f) && reloc_value(f) == 0) {
 556             error(ERR_NONFATAL, "division by zero");
 557             return NULL;
 558         }
 559         switch (j) {
 560         case '*':
 561             if (is_simple(e))
 562                 e = scalar_mult(f, reloc_value(e), TRUE);
 563             else if (is_simple(f))
 564                 e = scalar_mult(e, reloc_value(f), TRUE);
 565             else if (is_just_unknown(e) && is_just_unknown(f))
 566                 e = unknown_expr();
 567             else {
 568                 error(ERR_NONFATAL, "unable to multiply two "
 569                       "non-scalar objects");
 570                 return NULL;
 571             }
 572             break;
 573         case '/':
 574             if (is_just_unknown(e) || is_just_unknown(f))
 575                 e = unknown_expr();
 576             else
 577                 e = scalarvect(((uint32_t)reloc_value(e)) /
 578                                ((uint32_t)reloc_value(f)));
 579             break;
 580         case '%':
 581             if (is_just_unknown(e) || is_just_unknown(f))
 582                 e = unknown_expr();
 583             else
 584                 e = scalarvect(((uint32_t)reloc_value(e)) %
 585                                ((uint32_t)reloc_value(f)));
 586             break;
 587         case TOKEN_SDIV:
 588             if (is_just_unknown(e) || is_just_unknown(f))
 589                 e = unknown_expr();
 590             else
 591                 e = scalarvect(((int32_t)reloc_value(e)) /
 592                                ((int32_t)reloc_value(f)));
 593             break;
 594         case TOKEN_SMOD:
 595             if (is_just_unknown(e) || is_just_unknown(f))
 596                 e = unknown_expr();
 597             else
 598                 e = scalarvect(((int32_t)reloc_value(e)) %
 599                                ((int32_t)reloc_value(f)));
 600             break;
 601         }
 602     }
 603     return e;
 604 }
 605
 606 static expr *expr6(int critical)
 607 {
 608     int32_t type;
 609     expr *e;
 610     int32_t label_seg, label_ofs;
 611
 612     if (i == '-') {
 613         i = scan(scpriv, tokval);
 614         e = expr6(critical);
 615         if (!e)
 616             return NULL;
 617         return scalar_mult(e, -1L, FALSE);
 618     } else if (i == '+') {
 619         i = scan(scpriv, tokval);
 620         return expr6(critical);
 621     } else if (i == '~') {
 622         i = scan(scpriv, tokval);
 623         e = expr6(critical);
 624         if (!e)
 625             return NULL;
 626         if (is_just_unknown(e))
 627             return unknown_expr();
 628         else if (!is_simple(e)) {
 629             error(ERR_NONFATAL, "`~' operator may only be applied to"
 630                   " scalar values");
 631             return NULL;
 632         }
 633         return scalarvect(~reloc_value(e));
 634     } else if (i == TOKEN_SEG) {
 635         i = scan(scpriv, tokval);
 636         e = expr6(critical);
 637         if (!e)
 638             return NULL;
 639         e = segment_part(e);
 640         if (!e)
 641             return NULL;
 642         if (is_unknown(e) && critical) {
 643             error(ERR_NONFATAL, "unable to determine segment base");
 644             return NULL;
 645         }
 646         return e;
 647     } else if (i == '(') {
 648         i = scan(scpriv, tokval);
 649         e = bexpr(critical);
 650         if (!e)
 651             return NULL;
 652         if (i != ')') {
 653             error(ERR_NONFATAL, "expecting `)'");
 654             return NULL;
 655         }
 656         i = scan(scpriv, tokval);
 657         return e;
 658     } else if (i == TOKEN_NUM || i == TOKEN_REG || i == TOKEN_ID ||
 659                i == TOKEN_HERE || i == TOKEN_BASE) {
 660         begintemp();
 661         switch (i) {
 662         case TOKEN_NUM:
 663             addtotemp(EXPR_SIMPLE, tokval->t_integer);
 664             break;
 665         case TOKEN_REG:
 666             addtotemp(tokval->t_integer, 1L);
 667             if (hint && hint->type == EAH_NOHINT)
 668                 hint->base = tokval->t_integer, hint->type = EAH_MAKEBASE;
 669             break;
 670         case TOKEN_ID:
 671         case TOKEN_HERE:
 672         case TOKEN_BASE:
 673             /*
 674              * If !location->known, this indicates that no
 675              * symbol, Here or Base references are valid because we
 676              * are in preprocess-only mode.
 677              */
 678             if (!location->known) {
 679                 error(ERR_NONFATAL,
 680                       "%s not supported in preprocess-only mode",
 681                       (i == TOKEN_ID ? "symbol references" :
 682                        i == TOKEN_HERE ? "`$'" : "`$$'"));
 683                 addtotemp(EXPR_UNKNOWN, 1L);
 684                 break;
 685             }
 686
 687             type = EXPR_SIMPLE; /* might get overridden by UNKNOWN */
 688             if (i == TOKEN_BASE) {
 689                 label_seg = in_abs_seg ? abs_seg : location->segment;
 690                 label_ofs = 0;
 691             } else if (i == TOKEN_HERE) {
 692                 label_seg = in_abs_seg ? abs_seg : location->segment;
 693                 label_ofs = in_abs_seg ? abs_offset : location->offset;
 694             } else {
 695                 if (!labelfunc(tokval->t_charptr, &label_seg, &label_ofs)) {
 696                     if (critical == 2) {
 697                         error(ERR_NONFATAL, "symbol `%s' undefined",
 698                               tokval->t_charptr);
 699                         return NULL;
 700                     } else if (critical == 1) {
 701                         error(ERR_NONFATAL,
 702                               "symbol `%s' not defined before use",
 703                               tokval->t_charptr);
 704                         return NULL;
 705                     } else {
 706                         if (opflags)
 707                             *opflags |= 1;
 708                         type = EXPR_UNKNOWN;
 709                         label_seg = NO_SEG;
 710                         label_ofs = 1;
 711                     }
 712                 }
 713                 if (opflags && is_extern(tokval->t_charptr))
 714                     *opflags |= OPFLAG_EXTERN;
 715             }
 716             addtotemp(type, label_ofs);
 717             if (label_seg != NO_SEG)
 718                 addtotemp(EXPR_SEGBASE + label_seg, 1L);
 719             break;
 720         }
 721         i = scan(scpriv, tokval);
 722         return finishtemp();
 723     } else {
 724         error(ERR_NONFATAL, "expression syntax error");
 725         return NULL;
 726     }
 727 }
 728
 729 void eval_global_info(struct ofmt *output, lfunc lookup_label,
 730                       loc_t * locp)
 731 {
 732     outfmt = output;
 733     labelfunc = lookup_label;
 734     location = locp;
 735 }
 736
 737 expr *evaluate(scanner sc, void *scprivate, struct tokenval *tv,
 738                int *fwref, int critical, efunc report_error,
 739                struct eval_hints *hints)
 740 {
 741     expr *e;
 742     expr *f = NULL;
 743
 744     hint = hints;
 745     if (hint)
 746         hint->type = EAH_NOHINT;
 747
 748     if (critical & CRITICAL) {
 749         critical &= ~CRITICAL;
 750         bexpr = rexp0;
 751     } else
 752         bexpr = expr0;
 753
 754     scan = sc;
 755     scpriv = scprivate;
 756     tokval = tv;
 757     error = report_error;
 758     opflags = fwref;
 759
 760     if (tokval->t_type == TOKEN_INVALID)
 761         i = scan(scpriv, tokval);
 762     else
 763         i = tokval->t_type;
 764
 765     while (ntempexprs)          /* initialize temporary storage */
 766         nasm_free(tempexprs[--ntempexprs]);
 767
 768     e = bexpr(critical);
 769     if (!e)
 770         return NULL;
 771
 772     if (i == TOKEN_WRT) {
 773         i = scan(scpriv, tokval);       /* eat the WRT */
 774         f = expr6(critical);
 775         if (!f)
 776             return NULL;
 777     }
 778     e = scalar_mult(e, 1L, FALSE);      /* strip far-absolute segment part */
 779     if (f) {
 780         expr *g;
 781         if (is_just_unknown(f))
 782             g = unknown_expr();
 783         else {
 784             int64_t value;
 785             begintemp();
 786             if (!is_reloc(f)) {
 787                 error(ERR_NONFATAL, "invalid right-hand operand to WRT");
 788                 return NULL;
 789             }
 790             value = reloc_seg(f);
 791             if (value == NO_SEG)
 792                 value = reloc_value(f) | SEG_ABS;
 793             else if (!(value & SEG_ABS) && !(value % 2) && critical) {
 794                 error(ERR_NONFATAL, "invalid right-hand operand to WRT");
 795                 return NULL;
 796             }
 797             addtotemp(EXPR_WRT, value);
 798             g = finishtemp();
 799         }
 800         e = add_vectors(e, g);
 801     }
 802     return e;
 803 }