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     switch (i) {
 613     case '-':
 614         i = scan(scpriv, tokval);
 615         e = expr6(critical);
 616         if (!e)
 617             return NULL;
 618         return scalar_mult(e, -1L, FALSE);
 619
 620
 621     case '+':
 622         i = scan(scpriv, tokval);
 623         return expr6(critical);
 624
 625     case '~':
 626         i = scan(scpriv, tokval);
 627         e = expr6(critical);
 628         if (!e)
 629             return NULL;
 630         if (is_just_unknown(e))
 631             return unknown_expr();
 632         else if (!is_simple(e)) {
 633             error(ERR_NONFATAL, "`~' operator may only be applied to"
 634                   " scalar values");
 635             return NULL;
 636         }
 637         return scalarvect(~reloc_value(e));
 638
 639     case '!':
 640         i = scan(scpriv, tokval);
 641         e = expr6(critical);
 642         if (!e)
 643             return NULL;
 644         if (is_just_unknown(e))
 645             return unknown_expr();
 646         else if (!is_simple(e)) {
 647             error(ERR_NONFATAL, "`!' operator may only be applied to"
 648                   " scalar values");
 649             return NULL;
 650         }
 651         return scalarvect(!reloc_value(e));
 652
 653     case TOKEN_SEG:
 654         i = scan(scpriv, tokval);
 655         e = expr6(critical);
 656         if (!e)
 657             return NULL;
 658         e = segment_part(e);
 659         if (!e)
 660             return NULL;
 661         if (is_unknown(e) && critical) {
 662             error(ERR_NONFATAL, "unable to determine segment base");
 663             return NULL;
 664         }
 665         return e;
 666
 667     case '(':
 668         i = scan(scpriv, tokval);
 669         e = bexpr(critical);
 670         if (!e)
 671             return NULL;
 672         if (i != ')') {
 673             error(ERR_NONFATAL, "expecting `)'");
 674             return NULL;
 675         }
 676         i = scan(scpriv, tokval);
 677         return e;
 678
 679     case TOKEN_NUM:
 680     case TOKEN_REG:
 681     case TOKEN_ID:
 682     case TOKEN_HERE:
 683     case TOKEN_BASE:
 684         begintemp();
 685         switch (i) {
 686         case TOKEN_NUM:
 687             addtotemp(EXPR_SIMPLE, tokval->t_integer);
 688             break;
 689         case TOKEN_REG:
 690             addtotemp(tokval->t_integer, 1L);
 691             if (hint && hint->type == EAH_NOHINT)
 692                 hint->base = tokval->t_integer, hint->type = EAH_MAKEBASE;
 693             break;
 694         case TOKEN_ID:
 695         case TOKEN_HERE:
 696         case TOKEN_BASE:
 697             /*
 698              * If !location->known, this indicates that no
 699              * symbol, Here or Base references are valid because we
 700              * are in preprocess-only mode.
 701              */
 702             if (!location->known) {
 703                 error(ERR_NONFATAL,
 704                       "%s not supported in preprocess-only mode",
 705                       (i == TOKEN_ID ? "symbol references" :
 706                        i == TOKEN_HERE ? "`$'" : "`$$'"));
 707                 addtotemp(EXPR_UNKNOWN, 1L);
 708                 break;
 709             }
 710
 711             type = EXPR_SIMPLE; /* might get overridden by UNKNOWN */
 712             if (i == TOKEN_BASE) {
 713                 label_seg = in_abs_seg ? abs_seg : location->segment;
 714                 label_ofs = 0;
 715             } else if (i == TOKEN_HERE) {
 716                 label_seg = in_abs_seg ? abs_seg : location->segment;
 717                 label_ofs = in_abs_seg ? abs_offset : location->offset;
 718             } else {
 719                 if (!labelfunc(tokval->t_charptr, &label_seg, &label_ofs)) {
 720                     if (critical == 2) {
 721                         error(ERR_NONFATAL, "symbol `%s' undefined",
 722                               tokval->t_charptr);
 723                         return NULL;
 724                     } else if (critical == 1) {
 725                         error(ERR_NONFATAL,
 726                               "symbol `%s' not defined before use",
 727                               tokval->t_charptr);
 728                         return NULL;
 729                     } else {
 730                         if (opflags)
 731                             *opflags |= 1;
 732                         type = EXPR_UNKNOWN;
 733                         label_seg = NO_SEG;
 734                         label_ofs = 1;
 735                     }
 736                 }
 737                 if (opflags && is_extern(tokval->t_charptr))
 738                     *opflags |= OPFLAG_EXTERN;
 739             }
 740             addtotemp(type, label_ofs);
 741             if (label_seg != NO_SEG)
 742                 addtotemp(EXPR_SEGBASE + label_seg, 1L);
 743             break;
 744         }
 745         i = scan(scpriv, tokval);
 746         return finishtemp();
 747
 748     default:
 749         error(ERR_NONFATAL, "expression syntax error");
 750         return NULL;
 751     }
 752 }
 753
 754 void eval_global_info(struct ofmt *output, lfunc lookup_label,
 755                       loc_t * locp)
 756 {
 757     outfmt = output;
 758     labelfunc = lookup_label;
 759     location = locp;
 760 }
 761
 762 expr *evaluate(scanner sc, void *scprivate, struct tokenval *tv,
 763                int *fwref, int critical, efunc report_error,
 764                struct eval_hints *hints)
 765 {
 766     expr *e;
 767     expr *f = NULL;
 768
 769     hint = hints;
 770     if (hint)
 771         hint->type = EAH_NOHINT;
 772
 773     if (critical & CRITICAL) {
 774         critical &= ~CRITICAL;
 775         bexpr = rexp0;
 776     } else
 777         bexpr = expr0;
 778
 779     scan = sc;
 780     scpriv = scprivate;
 781     tokval = tv;
 782     error = report_error;
 783     opflags = fwref;
 784
 785     if (tokval->t_type == TOKEN_INVALID)
 786         i = scan(scpriv, tokval);
 787     else
 788         i = tokval->t_type;
 789
 790     while (ntempexprs)          /* initialize temporary storage */
 791         nasm_free(tempexprs[--ntempexprs]);
 792
 793     e = bexpr(critical);
 794     if (!e)
 795         return NULL;
 796
 797     if (i == TOKEN_WRT) {
 798         i = scan(scpriv, tokval);       /* eat the WRT */
 799         f = expr6(critical);
 800         if (!f)
 801             return NULL;
 802     }
 803     e = scalar_mult(e, 1L, FALSE);      /* strip far-absolute segment part */
 804     if (f) {
 805         expr *g;
 806         if (is_just_unknown(f))
 807             g = unknown_expr();
 808         else {
 809             int64_t value;
 810             begintemp();
 811             if (!is_reloc(f)) {
 812                 error(ERR_NONFATAL, "invalid right-hand operand to WRT");
 813                 return NULL;
 814             }
 815             value = reloc_seg(f);
 816             if (value == NO_SEG)
 817                 value = reloc_value(f) | SEG_ABS;
 818             else if (!(value & SEG_ABS) && !(value % 2) && critical) {
 819                 error(ERR_NONFATAL, "invalid right-hand operand to WRT");
 820                 return NULL;
 821             }
 822             addtotemp(EXPR_WRT, value);
 823             g = finishtemp();
 824         }
 825         e = add_vectors(e, g);
 826     }
 827     return e;
 828 }