modules/preprocs/nasm/nasm-eval.c - third_party/yasm - Git at Google

 /* eval.c    expression evaluator for the Netwide Assembler
  *
  * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
  * Julian Hall. All rights reserved. The software is
  * redistributable under the licence given in the file "Licence"
  * distributed in the NASM archive.
  *
  * initial version 27/iii/95 by Simon Tatham
  */
 #include <util.h>
 #include <libyasm/coretype.h>
 #include <ctype.h>

 #include "nasm.h"
 #include "nasmlib.h"
 #include "nasm-eval.h"
 /*#include "labels.h"*/

 #define TEMPEXPRS_DELTA 128
 #define TEMPEXPR_DELTA 8

 static scanner scan;	/* Address of scanner routine */
 static efunc error;	/* Address of error reporting routine */
 static lfunc labelfunc;	/* Address of label routine */

 static struct ofmt *outfmt;  /* Structure of addresses of output routines */

 static nasm_expr **tempexprs = NULL;
 static int    ntempexprs;
 static int    tempexprs_size = 0;

 static nasm_expr  *tempexpr;
 static int   ntempexpr;
 static int   tempexpr_size;

 static struct tokenval *tokval;	  /* The current token */
 static int i;			  /* The t_type of tokval */

 static void *scpriv;
 static loc_t *location;		/* Pointer to current line's segment,offset */
 static int *opflags;

 static struct eval_hints *hint;

 static int  in_abs_seg = 0;		/* ABSOLUTE segment flag */
 static long abs_seg = 0;		/* ABSOLUTE segment */
 static long abs_offset = 0;		/* ABSOLUTE segment offset */

 /*
  * Unimportant cleanup is done to avoid confusing people who are trying
  * to debug real memory leaks
  */
 void nasm_eval_cleanup(void)
 {
     while (ntempexprs) {
 	ntempexprs--;
 	nasm_free (tempexprs[ntempexprs]);
     }
     nasm_free (tempexprs);
 }

 /*
  * Construct a temporary expression.
  */
 static void begintemp(void)
 {
     tempexpr = NULL;
     tempexpr_size = ntempexpr = 0;
 }

 static void addtotemp(long type, long value)
 {
     while (ntempexpr >= tempexpr_size) {
 	tempexpr_size += TEMPEXPR_DELTA;
 	tempexpr = nasm_realloc(tempexpr,
 				 tempexpr_size*sizeof(*tempexpr));
     }
     tempexpr[ntempexpr].type = type;
     tempexpr[ntempexpr++].value = value;
 }

 static nasm_expr *finishtemp(void)
 {
     addtotemp (0L, 0L);		       /* terminate */
     while (ntempexprs >= tempexprs_size) {
 	tempexprs_size += TEMPEXPRS_DELTA;
 	tempexprs = nasm_realloc(tempexprs,
 				 tempexprs_size*sizeof(*tempexprs));
     }
     return tempexprs[ntempexprs++] = tempexpr;
 }

 /*
  * Add two vector datatypes. We have some bizarre behaviour on far-
  * absolute segment types: we preserve them during addition _only_
  * if one of the segments is a truly pure scalar.
  */
 static nasm_expr *add_vectors(nasm_expr *p, nasm_expr *q)
 {
     int preserve;

     preserve = nasm_is_really_simple(p) || nasm_is_really_simple(q);

     begintemp();

     while (p->type && q->type &&
 	   p->type < EXPR_SEGBASE+SEG_ABS &&
 	   q->type < EXPR_SEGBASE+SEG_ABS)
     {
 	int lasttype;

     	if (p->type > q->type) {
 	    addtotemp(q->type, q->value);
 	    lasttype = q++->type;
 	} else if (p->type < q->type) {
 	    addtotemp(p->type, p->value);
 	    lasttype = p++->type;
 	} else {		       /* *p and *q have same type */
 	    long sum = p->value + q->value;
 	    if (sum)
 		addtotemp(p->type, sum);
 	    lasttype = p->type;
 	    p++, q++;
 	}
 	if (lasttype == EXPR_UNKNOWN) {
 	    return finishtemp();
 	}
     }
     while (p->type &&
 	   (preserve || p->type < EXPR_SEGBASE+SEG_ABS))
     {
 	addtotemp(p->type, p->value);
 	p++;
     }
     while (q->type &&
 	   (preserve || q->type < EXPR_SEGBASE+SEG_ABS))
     {
 	addtotemp(q->type, q->value);
 	q++;
     }

     return finishtemp();
 }

 /*
  * Multiply a vector by a scalar. Strip far-absolute segment part
  * if present.
  *
  * Explicit treatment of UNKNOWN is not required in this routine,
  * since it will silently do the Right Thing anyway.
  *
  * If `affect_hints' is set, we also change the hint type to
  * NOTBASE if a MAKEBASE hint points at a register being
  * multiplied. This allows [eax*1+ebx] to hint EBX rather than EAX
  * as the base register.
  */
 static nasm_expr *scalar_mult(nasm_expr *vect, long scalar, int affect_hints)
 {
     nasm_expr *p = vect;

     while (p->type && p->type < EXPR_SEGBASE+SEG_ABS) {
 	p->value = scalar * (p->value);
 	if (hint && hint->type == EAH_MAKEBASE &&
 	    p->type == hint->base && affect_hints)
 	    hint->type = EAH_NOTBASE;
 	p++;
     }
     p->type = 0;

     return vect;
 }

 static nasm_expr *scalarvect (long scalar)
 {
     begintemp();
     addtotemp(EXPR_SIMPLE, scalar);
     return finishtemp();
 }

 static nasm_expr *unknown_expr (void)
 {
     begintemp();
     addtotemp(EXPR_UNKNOWN, 1L);
     return finishtemp();
 }

 /*
  * The SEG operator: calculate the segment part of a relocatable
  * value. Return NULL, as usual, if an error occurs. Report the
  * error too.
  */
 static nasm_expr *segment_part (nasm_expr *e)
 {
     long seg;

     if (nasm_is_unknown(e))
 	return unknown_expr();

     if (!nasm_is_reloc(e)) {
 	error(ERR_NONFATAL, "cannot apply SEG to a non-relocatable value");
 	return NULL;
     }

     seg = nasm_reloc_seg(e);
     if (seg == NO_SEG) {
 	error(ERR_NONFATAL, "cannot apply SEG to a non-relocatable value");
 	return NULL;
     } else if (seg & SEG_ABS) {
 	return scalarvect(seg & ~SEG_ABS);
     } else if (seg & 1) {
 	error(ERR_NONFATAL, "SEG applied to something which"
 	      " is already a segment base");
 	return NULL;
     }
     else {
 	long base = outfmt->segbase(seg+1);

 	begintemp();
 	addtotemp((base == NO_SEG ? EXPR_UNKNOWN : EXPR_SEGBASE+base), 1L);
 	return finishtemp();
     }
 }

 /*
  * Recursive-descent parser. Called with a single boolean operand,
  * which is TRUE if the evaluation is critical (i.e. unresolved
  * symbols are an error condition). Must update the global `i' to
  * reflect the token after the parsed string. May return NULL.
  *
  * evaluate() should report its own errors: on return it is assumed
  * that if NULL has been returned, the error has already been
  * reported.
  */

 /*
  * Grammar parsed is:
  *
  * expr  : bexpr [ WRT expr6 ]
  * bexpr : rexp0 or expr0 depending on relative-mode setting
  * rexp0 : rexp1 [ {||} rexp1...]
  * rexp1 : rexp2 [ {^^} rexp2...]
  * rexp2 : rexp3 [ {&&} rexp3...]
  * rexp3 : expr0 [ {=,==,<>,!=,<,>,<=,>=} expr0 ]
  * expr0 : expr1 [ {|} expr1...]
  * expr1 : expr2 [ {^} expr2...]
  * expr2 : expr3 [ {&} expr3...]
  * expr3 : expr4 [ {<<,>>} expr4...]
  * expr4 : expr5 [ {+,-} expr5...]
  * expr5 : expr6 [ {*,/,%,//,%%} expr6...]
  * expr6 : { ~,+,-,SEG } expr6
  *       | (bexpr)
  *       | symbol
  *       | $
  *       | number
  */

 static nasm_expr *rexp0(int), *rexp1(int), *rexp2(int), *rexp3(int);

 static nasm_expr *expr0(int), *expr1(int), *expr2(int), *expr3(int);
 static nasm_expr *expr4(int), *expr5(int), *expr6(int);

 static nasm_expr *(*bexpr)(int);

 static nasm_expr *rexp0(int critical)
 {
     nasm_expr *e, *f;

     e = rexp1(critical);
     if (!e)
 	return NULL;

     while (i == TOKEN_DBL_OR)
     {
 	i = scan(scpriv, tokval);
 	f = rexp1(critical);
 	if (!f)
 	    return NULL;
 	if (!(nasm_is_simple(e) || nasm_is_just_unknown(e)) ||
 	    !(nasm_is_simple(f) || nasm_is_just_unknown(f)))
 	{
 	    error(ERR_NONFATAL, "`|' operator may only be applied to"
 		  " scalar values");
 	}

 	if (nasm_is_just_unknown(e) || nasm_is_just_unknown(f))
 	    e = unknown_expr();
 	else
 	    e = scalarvect ((long) (nasm_reloc_value(e) || nasm_reloc_value(f)));
     }
     return e;
 }

 static nasm_expr *rexp1(int critical)
 {
     nasm_expr *e, *f;

     e = rexp2(critical);
     if (!e)
 	return NULL;

     while (i == TOKEN_DBL_XOR)
     {
 	i = scan(scpriv, tokval);
 	f = rexp2(critical);
 	if (!f)
 	    return NULL;
 	if (!(nasm_is_simple(e) || nasm_is_just_unknown(e)) ||
 	    !(nasm_is_simple(f) || nasm_is_just_unknown(f)))
 	{
 	    error(ERR_NONFATAL, "`^' operator may only be applied to"
 		  " scalar values");
 	}

 	if (nasm_is_just_unknown(e) || nasm_is_just_unknown(f))
 	    e = unknown_expr();
 	else
 	    e = scalarvect ((long) (!nasm_reloc_value(e) ^ !nasm_reloc_value(f)));
     }
     return e;
 }

 static nasm_expr *rexp2(int critical)
 {
     nasm_expr *e, *f;

     e = rexp3(critical);
     if (!e)
 	return NULL;
     while (i == TOKEN_DBL_AND)
     {
 	i = scan(scpriv, tokval);
 	f = rexp3(critical);
 	if (!f)
 	    return NULL;
 	if (!(nasm_is_simple(e) || nasm_is_just_unknown(e)) ||
 	    !(nasm_is_simple(f) || nasm_is_just_unknown(f)))
 	{
 	    error(ERR_NONFATAL, "`&' operator may only be applied to"
 		  " scalar values");
 	}
 	if (nasm_is_just_unknown(e) || nasm_is_just_unknown(f))
 	    e = unknown_expr();
 	else
 	    e = scalarvect ((long) (nasm_reloc_value(e) && nasm_reloc_value(f)));
     }
     return e;
 }

 static nasm_expr *rexp3(int critical)
 {
     nasm_expr *e, *f;
     long v;

     e = expr0(critical);
     if (!e)
 	return NULL;

     while (i == TOKEN_EQ || i == TOKEN_LT || i == TOKEN_GT ||
 	   i == TOKEN_NE || i == TOKEN_LE || i == TOKEN_GE)
     {
 	int j = i;
 	i = scan(scpriv, tokval);
 	f = expr0(critical);
 	if (!f)
 	    return NULL;

 	e = add_vectors (e, scalar_mult(f, -1L, FALSE));

 	switch (j)
 	{
 	  case TOKEN_EQ: case TOKEN_NE:
 	    if (nasm_is_unknown(e))
 		v = -1;		       /* means unknown */
 	    else if (!nasm_is_really_simple(e) || nasm_reloc_value(e) != 0)
 		v = (j == TOKEN_NE);   /* unequal, so return TRUE if NE */
 	    else
 		v = (j == TOKEN_EQ);   /* equal, so return TRUE if EQ */
 	    break;
 	  default:
 	    if (nasm_is_unknown(e))
 		v = -1;		       /* means unknown */
 	    else if (!nasm_is_really_simple(e)) {
 		error(ERR_NONFATAL, "`%s': operands differ by a non-scalar",
 		      (j == TOKEN_LE ? "<=" : j == TOKEN_LT ? "<" :
 		       j == TOKEN_GE ? ">=" : ">"));
 		v = 0;		       /* must set it to _something_ */
 	    } else {
 		int vv = nasm_reloc_value(e);
 		if (vv == 0)
 		    v = (j == TOKEN_LE || j == TOKEN_GE);
 		else if (vv > 0)
 		    v = (j == TOKEN_GE || j == TOKEN_GT);
 		else /* vv < 0 */
 		    v = (j == TOKEN_LE || j == TOKEN_LT);
 	    }
 	    break;
 	}

 	if (v == -1)
 	    e = unknown_expr();
 	else
 	    e = scalarvect(v);
     }
     return e;
 }

 static nasm_expr *expr0(int critical)
 {
     nasm_expr *e, *f;

     e = expr1(critical);
     if (!e)
 	return NULL;

     while (i == '|')
     {
 	i = scan(scpriv, tokval);
 	f = expr1(critical);
 	if (!f)
 	    return NULL;
 	if (!(nasm_is_simple(e) || nasm_is_just_unknown(e)) ||
 	    !(nasm_is_simple(f) || nasm_is_just_unknown(f)))
 	{
 	    error(ERR_NONFATAL, "`|' operator may only be applied to"
 		  " scalar values");
 	}
 	if (nasm_is_just_unknown(e) || nasm_is_just_unknown(f))
 	    e = unknown_expr();
 	else
 	    e = scalarvect (nasm_reloc_value(e) | nasm_reloc_value(f));
     }
     return e;
 }

 static nasm_expr *expr1(int critical)
 {
     nasm_expr *e, *f;

     e = expr2(critical);
     if (!e)
 	return NULL;

     while (i == '^') {
 	i = scan(scpriv, tokval);
 	f = expr2(critical);
 	if (!f)
 	    return NULL;
 	if (!(nasm_is_simple(e) || nasm_is_just_unknown(e)) ||
 	    !(nasm_is_simple(f) || nasm_is_just_unknown(f)))
 	{
 	    error(ERR_NONFATAL, "`^' operator may only be applied to"
 		  " scalar values");
 	}
 	if (nasm_is_just_unknown(e) || nasm_is_just_unknown(f))
 	    e = unknown_expr();
 	else
 	    e = scalarvect (nasm_reloc_value(e) ^ nasm_reloc_value(f));
     }
     return e;
 }

 static nasm_expr *expr2(int critical)
 {
     nasm_expr *e, *f;

     e = expr3(critical);
     if (!e)
 	return NULL;

     while (i == '&') {
 	i = scan(scpriv, tokval);
 	f = expr3(critical);
 	if (!f)
 	    return NULL;
 	if (!(nasm_is_simple(e) || nasm_is_just_unknown(e)) ||
 	    !(nasm_is_simple(f) || nasm_is_just_unknown(f)))
 	{
 	    error(ERR_NONFATAL, "`&' operator may only be applied to"
 		  " scalar values");
 	}
 	if (nasm_is_just_unknown(e) || nasm_is_just_unknown(f))
 	    e = unknown_expr();
 	else
 	    e = scalarvect (nasm_reloc_value(e) & nasm_reloc_value(f));
     }
     return e;
 }

 static nasm_expr *expr3(int critical)
 {
     nasm_expr *e, *f;

     e = expr4(critical);
     if (!e)
 	return NULL;

     while (i == TOKEN_SHL || i == TOKEN_SHR)
     {
 	int j = i;
 	i = scan(scpriv, tokval);
 	f = expr4(critical);
 	if (!f)
 	    return NULL;
 	if (!(nasm_is_simple(e) || nasm_is_just_unknown(e)) ||
 	    !(nasm_is_simple(f) || nasm_is_just_unknown(f)))
 	{
 	    error(ERR_NONFATAL, "shift operator may only be applied to"
 		  " scalar values");
 	} else if (nasm_is_just_unknown(e) || nasm_is_just_unknown(f)) {
 	    e = unknown_expr();
 	} else switch (j) {
 	  case TOKEN_SHL:
 	    e = scalarvect (nasm_reloc_value(e) << nasm_reloc_value(f));
 	    break;
 	  case TOKEN_SHR:
 	    e = scalarvect ((long)(((unsigned long)nasm_reloc_value(e)) >>
 			    nasm_reloc_value(f)));
 	    break;
 	}
     }
     return e;
 }

 static nasm_expr *expr4(int critical)
 {
     nasm_expr *e, *f;

     e = expr5(critical);
     if (!e)
 	return NULL;
     while (i == '+' || i == '-')
     {
 	int j = i;
 	i = scan(scpriv, tokval);
 	f = expr5(critical);
 	if (!f)
 	    return NULL;
 	switch (j) {
 	  case '+':
 	    e = add_vectors (e, f);
 	    break;
 	  case '-':
 	    e = add_vectors (e, scalar_mult(f, -1L, FALSE));
 	    break;
 	}
     }
     return e;
 }

 static nasm_expr *expr5(int critical)
 {
     nasm_expr *e, *f;

     e = expr6(critical);
     if (!e)
 	return NULL;
     while (i == '*' || i == '/' || i == '%' ||
 	   i == TOKEN_SDIV || i == TOKEN_SMOD)
     {
 	int j = i;
 	i = scan(scpriv, tokval);
 	f = expr6(critical);
 	if (!f)
 	    return NULL;
 	if (j != '*' && (!(nasm_is_simple(e) || nasm_is_just_unknown(e)) ||
 			 !(nasm_is_simple(f) || nasm_is_just_unknown(f))))
 	{
 	    error(ERR_NONFATAL, "division operator may only be applied to"
 		  " scalar values");
 	    return NULL;
 	}
 	if (j != '*' && !nasm_is_unknown(f) && nasm_reloc_value(f) == 0) {
 	    error(ERR_NONFATAL, "division by zero");
 	    return NULL;
 	}
 	switch (j) {
 	  case '*':
 	    if (nasm_is_simple(e))
 		e = scalar_mult (f, nasm_reloc_value(e), TRUE);
 	    else if (nasm_is_simple(f))
 		e = scalar_mult (e, nasm_reloc_value(f), TRUE);
 	    else if (nasm_is_just_unknown(e) && nasm_is_just_unknown(f))
 		e = unknown_expr();
 	    else {
 		error(ERR_NONFATAL, "unable to multiply two "
 		      "non-scalar objects");
 		return NULL;
 	    }
 	    break;
 	  case '/':
 	    if (nasm_is_just_unknown(e) || nasm_is_just_unknown(f))
 		e = unknown_expr();
 	    else
 		e = scalarvect ((long)(((unsigned long)nasm_reloc_value(e)) /
 				((unsigned long)nasm_reloc_value(f))));
 	    break;
 	  case '%':
 	    if (nasm_is_just_unknown(e) || nasm_is_just_unknown(f))
 		e = unknown_expr();
 	    else
 		e = scalarvect ((long)(((unsigned long)nasm_reloc_value(e)) %
 				((unsigned long)nasm_reloc_value(f))));
 	    break;
 	  case TOKEN_SDIV:
 	    if (nasm_is_just_unknown(e) || nasm_is_just_unknown(f))
 		e = unknown_expr();
 	    else
 		e = scalarvect (((signed long)nasm_reloc_value(e)) /
 				((signed long)nasm_reloc_value(f)));
 	    break;
 	  case TOKEN_SMOD:
 	    if (nasm_is_just_unknown(e) || nasm_is_just_unknown(f))
 		e = unknown_expr();
 	    else
 		e = scalarvect (((signed long)nasm_reloc_value(e)) %
 				((signed long)nasm_reloc_value(f)));
 	    break;
 	}
     }
     return e;
 }

 static nasm_expr *expr6(int critical)
 {
     long type;
     nasm_expr *e;
     long label_seg, label_ofs;

     if (i == '-') {
 	i = scan(scpriv, tokval);
 	e = expr6(critical);
 	if (!e)
 	    return NULL;
 	return scalar_mult (e, -1L, FALSE);
     } else if (i == '+') {
 	i = scan(scpriv, tokval);
 	return expr6(critical);
     } else if (i == '~') {
 	i = scan(scpriv, tokval);
 	e = expr6(critical);
 	if (!e)
 	    return NULL;
 	if (nasm_is_just_unknown(e))
 	    return unknown_expr();
 	else if (!nasm_is_simple(e)) {
 	    error(ERR_NONFATAL, "`~' operator may only be applied to"
 		  " scalar values");
 	    return NULL;
 	}
 	return scalarvect(~nasm_reloc_value(e));
     } else if (i == TOKEN_SEG) {
 	i = scan(scpriv, tokval);
 	e = expr6(critical);
 	if (!e)
 	    return NULL;
 	e = segment_part(e);
 	if (!e)
 	    return NULL;
 	if (nasm_is_unknown(e) && critical) {
 	    error(ERR_NONFATAL, "unable to determine segment base");
 	    return NULL;
 	}
 	return e;
     } else if (i == '(') {
 	i = scan(scpriv, tokval);
 	e = bexpr(critical);
 	if (!e)
 	    return NULL;
 	if (i != ')') {
 	    error(ERR_NONFATAL, "expecting `)'");
 	    return NULL;
 	}
 	i = scan(scpriv, tokval);
 	return e;
     }
     else if (i == TOKEN_NUM || i == TOKEN_REG || i == TOKEN_ID ||
 	     i == TOKEN_HERE || i == TOKEN_BASE)
     {
 	begintemp();
 	switch (i) {
 	  case TOKEN_NUM:
 	    addtotemp(EXPR_SIMPLE, tokval->t_integer);
 	    break;
 	  case TOKEN_REG:
 	    addtotemp(tokval->t_integer, 1L);
 	    if (hint && hint->type == EAH_NOHINT)
 		hint->base = tokval->t_integer, hint->type = EAH_MAKEBASE;
 	    break;
 	  case TOKEN_ID:
 	  case TOKEN_HERE:
 	  case TOKEN_BASE:
 	    /*
 	     * If !location->known, this indicates that no
 	     * symbol, Here or Base references are valid because we
 	     * are in preprocess-only mode.
 	     */
 	    if (!location || !location->known) {
 		error(ERR_NONFATAL,
 		      "%s not supported",
 		      (i == TOKEN_ID ? "symbol references" :
 		       i == TOKEN_HERE ? "`$'" : "`$$'"));
 		addtotemp(EXPR_UNKNOWN, 1L);
 		break;
 	    }

 	    type = EXPR_SIMPLE;	       /* might get overridden by UNKNOWN */
 	    if (i == TOKEN_BASE)
 	    {
 		label_seg = in_abs_seg ? abs_seg : location->segment;
 		label_ofs = 0;
 	    } else if (i == TOKEN_HERE) {
 		label_seg = in_abs_seg ? abs_seg : location->segment;
 		label_ofs = in_abs_seg ? abs_offset : location->offset;
 	    } else {
 		if (!labelfunc(tokval->t_charptr,&label_seg,&label_ofs))
 		{
 		if (critical == 2) {
 		    error (ERR_NONFATAL, "symbol `%s' undefined",
 			   tokval->t_charptr);
 		    return NULL;
 		} else if (critical == 1) {
 			error (ERR_NONFATAL,
 				"symbol `%s' not defined before use",
 			   tokval->t_charptr);
 		    return NULL;
 		} else {
 		    if (opflags)
 			*opflags |= 1;
 		    type = EXPR_UNKNOWN;
 		    label_seg = NO_SEG;
 		    label_ofs = 1;
 		}
 	    }
 #if 0
 		if (opflags && nasm_is_extern (tokval->t_charptr))
 		    *opflags |= OPFLAG_EXTERN;
 #endif
 	    }
 	    addtotemp(type, label_ofs);
 	    if (label_seg!=NO_SEG)
 		addtotemp(EXPR_SEGBASE + label_seg, 1L);
 	    break;
 	}
 	i = scan(scpriv, tokval);
 	return finishtemp();
     } else {
 	error(ERR_NONFATAL, "expression syntax error");
 	return NULL;
     }
 }

 void nasm_eval_global_info (struct ofmt *output, lfunc lookup_label, loc_t *locp)
 {
     outfmt = output;
     labelfunc = lookup_label;
     location = locp;
 }

 nasm_expr *nasm_evaluate (scanner sc, void *scprivate, struct tokenval *tv,
 		int *fwref, int critical, efunc report_error,
 		struct eval_hints *hints)
 {
     nasm_expr *e;
     nasm_expr *f = NULL;

     hint = hints;
     if (hint)
 	hint->type = EAH_NOHINT;

     if (critical & CRITICAL) {
 	critical &= ~CRITICAL;
 	bexpr = rexp0;
     } else
 	bexpr = expr0;

     scan = sc;
     scpriv = scprivate;
     tokval = tv;
     error = report_error;
     opflags = fwref;

     if (tokval->t_type == TOKEN_INVALID)
 	i = scan(scpriv, tokval);
     else
 	i = tokval->t_type;

     while (ntempexprs) {	       /* initialise temporary storage */
 	ntempexprs--;
 	nasm_free (tempexprs[ntempexprs]);
     }

     e = bexpr (critical);
     if (!e)
 	return NULL;

     if (i == TOKEN_WRT) {
 	i = scan(scpriv, tokval);      /* eat the WRT */
 	f = expr6 (critical);
 	if (!f)
 	    return NULL;
     }
     e = scalar_mult (e, 1L, FALSE);    /* strip far-absolute segment part */
     if (f) {
 	nasm_expr *g;
 	if (nasm_is_just_unknown(f))
 	    g = unknown_expr();
 	else {
 	    long value;
 	    begintemp();
 	    if (!nasm_is_reloc(f)) {
 		error(ERR_NONFATAL, "invalid right-hand operand to WRT");
 		return NULL;
 	    }
 	    value = nasm_reloc_seg(f);
 	    if (value == NO_SEG)
 		value = nasm_reloc_value(f) | SEG_ABS;
 	    else if (!(value & SEG_ABS) && !(value % 2) && critical)
 	    {
 		error(ERR_NONFATAL, "invalid right-hand operand to WRT");
 		return NULL;
 	    }
 	    addtotemp(EXPR_WRT, value);
 	    g = finishtemp();
 	}
 	e = add_vectors (e, g);
     }
     return e;
 }
	/* eval.c expression evaluator for the Netwide Assembler
	*
	* The Netwide Assembler is copyright (C) 1996 Simon Tatham and
	* Julian Hall. All rights reserved. The software is
	* redistributable under the licence given in the file "Licence"
	* distributed in the NASM archive.
	*
	* initial version 27/iii/95 by Simon Tatham
	*/
	#include <util.h>
	#include <libyasm/coretype.h>
	#include <ctype.h>

	#include "nasm.h"
	#include "nasmlib.h"
	#include "nasm-eval.h"
	/#include "labels.h"/

	#define TEMPEXPRS_DELTA 128
	#define TEMPEXPR_DELTA 8

	static scanner scan; /* Address of scanner routine */
	static efunc error; /* Address of error reporting routine */
	static lfunc labelfunc; /* Address of label routine */

	static struct ofmt outfmt; / Structure of addresses of output routines */

	static nasm_expr **tempexprs = NULL;
	static int ntempexprs;
	static int tempexprs_size = 0;

	static nasm_expr *tempexpr;
	static int ntempexpr;
	static int tempexpr_size;

	static struct tokenval tokval; / The current token */
	static int i; /* The t_type of tokval */

	static void *scpriv;
	static loc_t location; / Pointer to current line's segment,offset */
	static int *opflags;

	static struct eval_hints *hint;

	static int in_abs_seg = 0; /* ABSOLUTE segment flag */
	static long abs_seg = 0; /* ABSOLUTE segment */
	static long abs_offset = 0; /* ABSOLUTE segment offset */

	/*
	* Unimportant cleanup is done to avoid confusing people who are trying
	* to debug real memory leaks
	*/
	void nasm_eval_cleanup(void)
	{
	while (ntempexprs) {
	ntempexprs--;
	nasm_free (tempexprs[ntempexprs]);
	}
	nasm_free (tempexprs);
	}

	/*
	* Construct a temporary expression.
	*/
	static void begintemp(void)
	{
	tempexpr = NULL;
	tempexpr_size = ntempexpr = 0;
	}

	static void addtotemp(long type, long value)
	{
	while (ntempexpr >= tempexpr_size) {
	tempexpr_size += TEMPEXPR_DELTA;
	tempexpr = nasm_realloc(tempexpr,
	tempexpr_sizesizeof(tempexpr));
	}
	tempexpr[ntempexpr].type = type;
	tempexpr[ntempexpr++].value = value;
	}

	static nasm_expr *finishtemp(void)
	{
	addtotemp (0L, 0L); /* terminate */
	while (ntempexprs >= tempexprs_size) {
	tempexprs_size += TEMPEXPRS_DELTA;
	tempexprs = nasm_realloc(tempexprs,
	tempexprs_sizesizeof(tempexprs));
	}
	return tempexprs[ntempexprs++] = tempexpr;
	}

	/*
	* Add two vector datatypes. We have some bizarre behaviour on far-
	* absolute segment types: we preserve them during addition _only_
	* if one of the segments is a truly pure scalar.
	*/
	static nasm_expr add_vectors(nasm_expr p, nasm_expr *q)
	{
	int preserve;

	preserve = nasm_is_really_simple(p) \|\| nasm_is_really_simple(q);

	begintemp();

	while (p->type && q->type &&
	p->type < EXPR_SEGBASE+SEG_ABS &&
	q->type < EXPR_SEGBASE+SEG_ABS)
	{
	int lasttype;

	if (p->type > q->type) {
	addtotemp(q->type, q->value);
	lasttype = q++->type;
	} else if (p->type < q->type) {
	addtotemp(p->type, p->value);
	lasttype = p++->type;
	} else { /* p and q have same type */
	long sum = p->value + q->value;
	if (sum)
	addtotemp(p->type, sum);
	lasttype = p->type;
	p++, q++;
	}
	if (lasttype == EXPR_UNKNOWN) {
	return finishtemp();
	}
	}
	while (p->type &&
	(preserve \|\| p->type < EXPR_SEGBASE+SEG_ABS))
	{
	addtotemp(p->type, p->value);
	p++;
	}
	while (q->type &&
	(preserve \|\| q->type < EXPR_SEGBASE+SEG_ABS))
	{
	addtotemp(q->type, q->value);
	q++;
	}

	return finishtemp();
	}

	/*
	* Multiply a vector by a scalar. Strip far-absolute segment part
	* if present.
	*
	* Explicit treatment of UNKNOWN is not required in this routine,
	* since it will silently do the Right Thing anyway.
	*
	* If `affect_hints' is set, we also change the hint type to
	* NOTBASE if a MAKEBASE hint points at a register being
	* multiplied. This allows [eax*1+ebx] to hint EBX rather than EAX
	* as the base register.
	*/
	static nasm_expr scalar_mult(nasm_expr vect, long scalar, int affect_hints)
	{
	nasm_expr *p = vect;

	while (p->type && p->type < EXPR_SEGBASE+SEG_ABS) {
	p->value = scalar * (p->value);
	if (hint && hint->type == EAH_MAKEBASE &&
	p->type == hint->base && affect_hints)
	hint->type = EAH_NOTBASE;
	p++;
	}
	p->type = 0;

	return vect;
	}

	static nasm_expr *scalarvect (long scalar)
	{
	begintemp();
	addtotemp(EXPR_SIMPLE, scalar);
	return finishtemp();
	}

	static nasm_expr *unknown_expr (void)
	{
	begintemp();
	addtotemp(EXPR_UNKNOWN, 1L);
	return finishtemp();
	}

	/*
	* The SEG operator: calculate the segment part of a relocatable
	* value. Return NULL, as usual, if an error occurs. Report the
	* error too.
	*/
	static nasm_expr segment_part (nasm_expr e)
	{
	long seg;

	if (nasm_is_unknown(e))
	return unknown_expr();

	if (!nasm_is_reloc(e)) {
	error(ERR_NONFATAL, "cannot apply SEG to a non-relocatable value");
	return NULL;
	}

	seg = nasm_reloc_seg(e);
	if (seg == NO_SEG) {
	error(ERR_NONFATAL, "cannot apply SEG to a non-relocatable value");
	return NULL;
	} else if (seg & SEG_ABS) {
	return scalarvect(seg & ~SEG_ABS);
	} else if (seg & 1) {
	error(ERR_NONFATAL, "SEG applied to something which"
	" is already a segment base");
	return NULL;
	}
	else {
	long base = outfmt->segbase(seg+1);

	begintemp();
	addtotemp((base == NO_SEG ? EXPR_UNKNOWN : EXPR_SEGBASE+base), 1L);
	return finishtemp();
	}
	}

	/*
	* Recursive-descent parser. Called with a single boolean operand,
	* which is TRUE if the evaluation is critical (i.e. unresolved
	* symbols are an error condition). Must update the global `i' to
	* reflect the token after the parsed string. May return NULL.
	*
	* evaluate() should report its own errors: on return it is assumed
	* that if NULL has been returned, the error has already been
	* reported.
	*/

	/*
	* Grammar parsed is:
	*
	* expr : bexpr [ WRT expr6 ]
	* bexpr : rexp0 or expr0 depending on relative-mode setting
	* rexp0 : rexp1 [ {\|\|} rexp1...]
	* rexp1 : rexp2 [ {^^} rexp2...]
	* rexp2 : rexp3 [ {&&} rexp3...]
	* rexp3 : expr0 [ {=,==,<>,!=,<,>,<=,>=} expr0 ]
	* expr0 : expr1 [ {\|} expr1...]
	* expr1 : expr2 [ {^} expr2...]
	* expr2 : expr3 [ {&} expr3...]
	* expr3 : expr4 [ {<<,>>} expr4...]
	* expr4 : expr5 [ {+,-} expr5...]
	* expr5 : expr6 [ {*,/,%,//,%%} expr6...]
	* expr6 : { ~,+,-,SEG } expr6
	* \| (bexpr)
	* \| symbol
	* \| $
	* \| number
	*/

	static nasm_expr rexp0(int), rexp1(int), rexp2(int), rexp3(int);

	static nasm_expr expr0(int), expr1(int), expr2(int), expr3(int);
	static nasm_expr expr4(int), expr5(int), *expr6(int);

	static nasm_expr (bexpr)(int);

	static nasm_expr *rexp0(int critical)
	{
	nasm_expr e, f;

	e = rexp1(critical);
	if (!e)
	return NULL;

	while (i == TOKEN_DBL_OR)
	{
	i = scan(scpriv, tokval);
	f = rexp1(critical);
	if (!f)
	return NULL;
	if (!(nasm_is_simple(e) \|\| nasm_is_just_unknown(e)) \|\|
	!(nasm_is_simple(f) \|\| nasm_is_just_unknown(f)))
	{
	error(ERR_NONFATAL, "`\|' operator may only be applied to"
	" scalar values");
	}

	if (nasm_is_just_unknown(e) \|\| nasm_is_just_unknown(f))
	e = unknown_expr();
	else
	e = scalarvect ((long) (nasm_reloc_value(e) \|\| nasm_reloc_value(f)));
	}
	return e;
	}

	static nasm_expr *rexp1(int critical)
	{
	nasm_expr e, f;

	e = rexp2(critical);
	if (!e)
	return NULL;

	while (i == TOKEN_DBL_XOR)
	{
	i = scan(scpriv, tokval);
	f = rexp2(critical);
	if (!f)
	return NULL;
	if (!(nasm_is_simple(e) \|\| nasm_is_just_unknown(e)) \|\|
	!(nasm_is_simple(f) \|\| nasm_is_just_unknown(f)))
	{
	error(ERR_NONFATAL, "`^' operator may only be applied to"
	" scalar values");
	}

	if (nasm_is_just_unknown(e) \|\| nasm_is_just_unknown(f))
	e = unknown_expr();
	else
	e = scalarvect ((long) (!nasm_reloc_value(e) ^ !nasm_reloc_value(f)));
	}
	return e;
	}

	static nasm_expr *rexp2(int critical)
	{
	nasm_expr e, f;

	e = rexp3(critical);
	if (!e)
	return NULL;
	while (i == TOKEN_DBL_AND)
	{
	i = scan(scpriv, tokval);
	f = rexp3(critical);
	if (!f)
	return NULL;
	if (!(nasm_is_simple(e) \|\| nasm_is_just_unknown(e)) \|\|
	!(nasm_is_simple(f) \|\| nasm_is_just_unknown(f)))
	{
	error(ERR_NONFATAL, "`&' operator may only be applied to"
	" scalar values");
	}
	if (nasm_is_just_unknown(e) \|\| nasm_is_just_unknown(f))
	e = unknown_expr();
	else
	e = scalarvect ((long) (nasm_reloc_value(e) && nasm_reloc_value(f)));
	}
	return e;
	}

	static nasm_expr *rexp3(int critical)
	{
	nasm_expr e, f;
	long v;

	e = expr0(critical);
	if (!e)
	return NULL;

	while (i == TOKEN_EQ \|\| i == TOKEN_LT \|\| i == TOKEN_GT \|\|
	i == TOKEN_NE \|\| i == TOKEN_LE \|\| i == TOKEN_GE)
	{
	int j = i;
	i = scan(scpriv, tokval);
	f = expr0(critical);
	if (!f)
	return NULL;

	e = add_vectors (e, scalar_mult(f, -1L, FALSE));

	switch (j)
	{
	case TOKEN_EQ: case TOKEN_NE:
	if (nasm_is_unknown(e))
	v = -1; /* means unknown */
	else if (!nasm_is_really_simple(e) \|\| nasm_reloc_value(e) != 0)
	v = (j == TOKEN_NE); /* unequal, so return TRUE if NE */
	else
	v = (j == TOKEN_EQ); /* equal, so return TRUE if EQ */
	break;
	default:
	if (nasm_is_unknown(e))
	v = -1; /* means unknown */
	else if (!nasm_is_really_simple(e)) {
	error(ERR_NONFATAL, "`%s': operands differ by a non-scalar",
	(j == TOKEN_LE ? "<=" : j == TOKEN_LT ? "<" :
	j == TOKEN_GE ? ">=" : ">"));
	v = 0; /* must set it to _something_ */
	} else {
	int vv = nasm_reloc_value(e);
	if (vv == 0)
	v = (j == TOKEN_LE \|\| j == TOKEN_GE);
	else if (vv > 0)
	v = (j == TOKEN_GE \|\| j == TOKEN_GT);
	else /* vv < 0 */
	v = (j == TOKEN_LE \|\| j == TOKEN_LT);
	}
	break;
	}

	if (v == -1)
	e = unknown_expr();
	else
	e = scalarvect(v);
	}
	return e;
	}

	static nasm_expr *expr0(int critical)
	{
	nasm_expr e, f;

	e = expr1(critical);
	if (!e)
	return NULL;

	while (i == '\|')
	{
	i = scan(scpriv, tokval);
	f = expr1(critical);
	if (!f)
	return NULL;
	if (!(nasm_is_simple(e) \|\| nasm_is_just_unknown(e)) \|\|
	!(nasm_is_simple(f) \|\| nasm_is_just_unknown(f)))
	{
	error(ERR_NONFATAL, "`\|' operator may only be applied to"
	" scalar values");
	}
	if (nasm_is_just_unknown(e) \|\| nasm_is_just_unknown(f))
	e = unknown_expr();
	else
	e = scalarvect (nasm_reloc_value(e) \| nasm_reloc_value(f));
	}
	return e;
	}

	static nasm_expr *expr1(int critical)
	{
	nasm_expr e, f;

	e = expr2(critical);
	if (!e)
	return NULL;

	while (i == '^') {
	i = scan(scpriv, tokval);
	f = expr2(critical);
	if (!f)
	return NULL;
	if (!(nasm_is_simple(e) \|\| nasm_is_just_unknown(e)) \|\|
	!(nasm_is_simple(f) \|\| nasm_is_just_unknown(f)))
	{
	error(ERR_NONFATAL, "`^' operator may only be applied to"
	" scalar values");
	}
	if (nasm_is_just_unknown(e) \|\| nasm_is_just_unknown(f))
	e = unknown_expr();
	else
	e = scalarvect (nasm_reloc_value(e) ^ nasm_reloc_value(f));
	}
	return e;
	}

	static nasm_expr *expr2(int critical)
	{
	nasm_expr e, f;

	e = expr3(critical);
	if (!e)
	return NULL;

	while (i == '&') {
	i = scan(scpriv, tokval);
	f = expr3(critical);
	if (!f)
	return NULL;
	if (!(nasm_is_simple(e) \|\| nasm_is_just_unknown(e)) \|\|
	!(nasm_is_simple(f) \|\| nasm_is_just_unknown(f)))
	{
	error(ERR_NONFATAL, "`&' operator may only be applied to"
	" scalar values");
	}
	if (nasm_is_just_unknown(e) \|\| nasm_is_just_unknown(f))
	e = unknown_expr();
	else
	e = scalarvect (nasm_reloc_value(e) & nasm_reloc_value(f));
	}
	return e;
	}

	static nasm_expr *expr3(int critical)
	{
	nasm_expr e, f;

	e = expr4(critical);
	if (!e)
	return NULL;

	while (i == TOKEN_SHL \|\| i == TOKEN_SHR)
	{
	int j = i;
	i = scan(scpriv, tokval);
	f = expr4(critical);
	if (!f)
	return NULL;
	if (!(nasm_is_simple(e) \|\| nasm_is_just_unknown(e)) \|\|
	!(nasm_is_simple(f) \|\| nasm_is_just_unknown(f)))
	{
	error(ERR_NONFATAL, "shift operator may only be applied to"
	" scalar values");
	} else if (nasm_is_just_unknown(e) \|\| nasm_is_just_unknown(f)) {
	e = unknown_expr();
	} else switch (j) {
	case TOKEN_SHL:
	e = scalarvect (nasm_reloc_value(e) << nasm_reloc_value(f));
	break;
	case TOKEN_SHR:
	e = scalarvect ((long)(((unsigned long)nasm_reloc_value(e)) >>
	nasm_reloc_value(f)));
	break;
	}
	}
	return e;
	}

	static nasm_expr *expr4(int critical)
	{
	nasm_expr e, f;

	e = expr5(critical);
	if (!e)
	return NULL;
	while (i == '+' \|\| i == '-')
	{
	int j = i;
	i = scan(scpriv, tokval);
	f = expr5(critical);
	if (!f)
	return NULL;
	switch (j) {
	case '+':
	e = add_vectors (e, f);
	break;
	case '-':
	e = add_vectors (e, scalar_mult(f, -1L, FALSE));
	break;
	}
	}
	return e;
	}

	static nasm_expr *expr5(int critical)
	{
	nasm_expr e, f;

	e = expr6(critical);
	if (!e)
	return NULL;
	while (i == '*' \|\| i == '/' \|\| i == '%' \|\|
	i == TOKEN_SDIV \|\| i == TOKEN_SMOD)
	{
	int j = i;
	i = scan(scpriv, tokval);
	f = expr6(critical);
	if (!f)
	return NULL;
	if (j != '*' && (!(nasm_is_simple(e) \|\| nasm_is_just_unknown(e)) \|\|
	!(nasm_is_simple(f) \|\| nasm_is_just_unknown(f))))
	{
	error(ERR_NONFATAL, "division operator may only be applied to"
	" scalar values");
	return NULL;
	}
	if (j != '*' && !nasm_is_unknown(f) && nasm_reloc_value(f) == 0) {
	error(ERR_NONFATAL, "division by zero");
	return NULL;
	}
	switch (j) {
	case '*':
	if (nasm_is_simple(e))
	e = scalar_mult (f, nasm_reloc_value(e), TRUE);
	else if (nasm_is_simple(f))
	e = scalar_mult (e, nasm_reloc_value(f), TRUE);
	else if (nasm_is_just_unknown(e) && nasm_is_just_unknown(f))
	e = unknown_expr();
	else {
	error(ERR_NONFATAL, "unable to multiply two "
	"non-scalar objects");
	return NULL;
	}
	break;
	case '/':
	if (nasm_is_just_unknown(e) \|\| nasm_is_just_unknown(f))
	e = unknown_expr();
	else
	e = scalarvect ((long)(((unsigned long)nasm_reloc_value(e)) /
	((unsigned long)nasm_reloc_value(f))));
	break;
	case '%':
	if (nasm_is_just_unknown(e) \|\| nasm_is_just_unknown(f))
	e = unknown_expr();
	else
	e = scalarvect ((long)(((unsigned long)nasm_reloc_value(e)) %
	((unsigned long)nasm_reloc_value(f))));
	break;
	case TOKEN_SDIV:
	if (nasm_is_just_unknown(e) \|\| nasm_is_just_unknown(f))
	e = unknown_expr();
	else
	e = scalarvect (((signed long)nasm_reloc_value(e)) /
	((signed long)nasm_reloc_value(f)));
	break;
	case TOKEN_SMOD:
	if (nasm_is_just_unknown(e) \|\| nasm_is_just_unknown(f))
	e = unknown_expr();
	else
	e = scalarvect (((signed long)nasm_reloc_value(e)) %
	((signed long)nasm_reloc_value(f)));
	break;
	}
	}
	return e;
	}

	static nasm_expr *expr6(int critical)
	{
	long type;
	nasm_expr *e;
	long label_seg, label_ofs;

	if (i == '-') {
	i = scan(scpriv, tokval);
	e = expr6(critical);
	if (!e)
	return NULL;
	return scalar_mult (e, -1L, FALSE);
	} else if (i == '+') {
	i = scan(scpriv, tokval);
	return expr6(critical);
	} else if (i == '~') {
	i = scan(scpriv, tokval);
	e = expr6(critical);
	if (!e)
	return NULL;
	if (nasm_is_just_unknown(e))
	return unknown_expr();
	else if (!nasm_is_simple(e)) {
	error(ERR_NONFATAL, "`~' operator may only be applied to"
	" scalar values");
	return NULL;
	}
	return scalarvect(~nasm_reloc_value(e));
	} else if (i == TOKEN_SEG) {
	i = scan(scpriv, tokval);
	e = expr6(critical);
	if (!e)
	return NULL;
	e = segment_part(e);
	if (!e)
	return NULL;
	if (nasm_is_unknown(e) && critical) {
	error(ERR_NONFATAL, "unable to determine segment base");
	return NULL;
	}
	return e;
	} else if (i == '(') {
	i = scan(scpriv, tokval);
	e = bexpr(critical);
	if (!e)
	return NULL;
	if (i != ')') {
	error(ERR_NONFATAL, "expecting `)'");
	return NULL;
	}
	i = scan(scpriv, tokval);
	return e;
	}
	else if (i == TOKEN_NUM \|\| i == TOKEN_REG \|\| i == TOKEN_ID \|\|
	i == TOKEN_HERE \|\| i == TOKEN_BASE)
	{
	begintemp();
	switch (i) {
	case TOKEN_NUM:
	addtotemp(EXPR_SIMPLE, tokval->t_integer);
	break;
	case TOKEN_REG:
	addtotemp(tokval->t_integer, 1L);
	if (hint && hint->type == EAH_NOHINT)
	hint->base = tokval->t_integer, hint->type = EAH_MAKEBASE;
	break;
	case TOKEN_ID:
	case TOKEN_HERE:
	case TOKEN_BASE:
	/*
	* If !location->known, this indicates that no
	* symbol, Here or Base references are valid because we
	* are in preprocess-only mode.
	*/
	if (!location \|\| !location->known) {
	error(ERR_NONFATAL,
	"%s not supported",
	(i == TOKEN_ID ? "symbol references" :
	i == TOKEN_HERE ? "`$'" : "`$$'"));
	addtotemp(EXPR_UNKNOWN, 1L);
	break;
	}

	type = EXPR_SIMPLE; /* might get overridden by UNKNOWN */
	if (i == TOKEN_BASE)
	{
	label_seg = in_abs_seg ? abs_seg : location->segment;
	label_ofs = 0;
	} else if (i == TOKEN_HERE) {
	label_seg = in_abs_seg ? abs_seg : location->segment;
	label_ofs = in_abs_seg ? abs_offset : location->offset;
	} else {
	if (!labelfunc(tokval->t_charptr,&label_seg,&label_ofs))
	{
	if (critical == 2) {
	error (ERR_NONFATAL, "symbol `%s' undefined",
	tokval->t_charptr);
	return NULL;
	} else if (critical == 1) {
	error (ERR_NONFATAL,
	"symbol `%s' not defined before use",
	tokval->t_charptr);
	return NULL;
	} else {
	if (opflags)
	*opflags \|= 1;
	type = EXPR_UNKNOWN;
	label_seg = NO_SEG;
	label_ofs = 1;
	}
	}
	#if 0
	if (opflags && nasm_is_extern (tokval->t_charptr))
	*opflags \|= OPFLAG_EXTERN;
	#endif
	}
	addtotemp(type, label_ofs);
	if (label_seg!=NO_SEG)
	addtotemp(EXPR_SEGBASE + label_seg, 1L);
	break;
	}
	i = scan(scpriv, tokval);
	return finishtemp();
	} else {
	error(ERR_NONFATAL, "expression syntax error");
	return NULL;
	}
	}

	void nasm_eval_global_info (struct ofmt output, lfunc lookup_label, loc_t locp)
	{
	outfmt = output;
	labelfunc = lookup_label;
	location = locp;
	}

	nasm_expr nasm_evaluate (scanner sc, void scprivate, struct tokenval *tv,
	int *fwref, int critical, efunc report_error,
	struct eval_hints *hints)
	{
	nasm_expr *e;
	nasm_expr *f = NULL;

	hint = hints;
	if (hint)
	hint->type = EAH_NOHINT;

	if (critical & CRITICAL) {
	critical &= ~CRITICAL;
	bexpr = rexp0;
	} else
	bexpr = expr0;

	scan = sc;
	scpriv = scprivate;
	tokval = tv;
	error = report_error;
	opflags = fwref;

	if (tokval->t_type == TOKEN_INVALID)
	i = scan(scpriv, tokval);
	else
	i = tokval->t_type;

	while (ntempexprs) { /* initialise temporary storage */
	ntempexprs--;
	nasm_free (tempexprs[ntempexprs]);
	}

	e = bexpr (critical);
	if (!e)
	return NULL;

	if (i == TOKEN_WRT) {
	i = scan(scpriv, tokval); /* eat the WRT */
	f = expr6 (critical);
	if (!f)
	return NULL;
	}
	e = scalar_mult (e, 1L, FALSE); /* strip far-absolute segment part */
	if (f) {
	nasm_expr *g;
	if (nasm_is_just_unknown(f))
	g = unknown_expr();
	else {
	long value;
	begintemp();
	if (!nasm_is_reloc(f)) {
	error(ERR_NONFATAL, "invalid right-hand operand to WRT");
	return NULL;
	}
	value = nasm_reloc_seg(f);
	if (value == NO_SEG)
	value = nasm_reloc_value(f) \| SEG_ABS;
	else if (!(value & SEG_ABS) && !(value % 2) && critical)
	{
	error(ERR_NONFATAL, "invalid right-hand operand to WRT");
	return NULL;
	}
	addtotemp(EXPR_WRT, value);
	g = finishtemp();
	}
	e = add_vectors (e, g);
	}
	return e;
	}