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