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