eval.c

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