NASM 0.98p3

1 files changed, 760 insertions, 700 deletions

diff --git a/preproc.c b/preproc.c
index 032854e..291b57e 100644
--- a/preproc.c
+++ b/preproc.c
@@ -8,6 +8,11 @@
  * initial version 18/iii/97 by Simon Tatham
  */
 
+#define br0 '{'
+#define br1 "{"
+#define br2 '}'
+#define br3 "}"
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <stddef.h>
@@ -64,12 +69,14 @@ struct MMacro {
     int plus;			       /* is the last parameter greedy? */
     int nolist;			       /* is this macro listing-inhibited? */
     int in_progress;
-    Token **defaults, *dlist;
+    Token *dlist;		       /* All defaults as one list */
+    Token **defaults;		       /* Parameter default pointers */
     int ndefs;			       /* number of default parameters */
     Line *expansion;
 
     MMacro *next_active;
-    Token **params, *iline;
+    Token **params;		       /* actual parameters */
+    Token *iline;		       /* invocation line */
     int nparam, rotate, *paramlen;
     unsigned long unique;
 };
@@ -88,11 +95,6 @@ struct Context {
  * This is the internal form which we break input lines up into.
  * Typically stored in linked lists.
  *
- * TOK_PS_OTHER is a token type used internally within
- * expand_smacro(), to denote a token which has already been
- * checked for being a potential macro, but may still be a context-
- * local label.
- *
  * Note that `type' serves a double meaning: TOK_SMAC_PARAM is not
  * necessarily used as-is, but is intended to denote the number of
  * the substituted parameter. So in the definition
@@ -116,7 +118,7 @@ struct Token {
 };
 enum {
     TOK_WHITESPACE = 1, TOK_COMMENT, TOK_ID, TOK_PREPROC_ID, TOK_STRING,
-    TOK_NUMBER, TOK_SMAC_END, TOK_OTHER, TOK_PS_OTHER, TOK_SMAC_PARAM,
+    TOK_NUMBER, TOK_SMAC_END, TOK_OTHER, TOK_SMAC_PARAM,
     TOK_INTERNAL_STRING
 };
 
@@ -271,14 +273,14 @@ static int pass;
 
 static unsigned long unique;	       /* unique identifier numbers */
 
-static char *linesync, *outline;
-
 static Line *predef = NULL;
 
 static ListGen *list;
 
 /*
  * The number of hash values we use for the macro lookup tables.
+ * FIXME: We should *really* be able to configure this at run time,
+ * or even have the hash table automatically expanding when necessary.
  */
 #define NHASH 31
 
@@ -321,7 +323,15 @@ int any_extrastdmac;
  * Forward declarations.
  */
 static Token *expand_smacro (Token *tline);
-static void update_fileline (int which);
+static void make_tok_num(Token *tok, long val);
+
+/*
+ * Macros for safe checking of token pointers, avoid *(NULL)
+ */
+#define tok_type_(x,t) ((x) && (x)->type == (t))
+#define skip_white_(x) if (tok_type_((x), TOK_WHITESPACE)) (x)=(x)->next
+#define tok_is_(x,v) (tok_type_((x), TOK_OTHER) && !strcmp((x)->text,(v)))
+#define tok_isnt_(x,v) ((x) && ((x)->type!=TOK_OTHER || strcmp((x)->text,(v))))
 
 /*
  * The pre-preprocessing stage... This function translates line
@@ -329,7 +339,8 @@ static void update_fileline (int which);
  * flags') into NASM preprocessor line number indications (`%line
  * lineno file').
  */
-static char *prepreproc(char *line) {
+static char *prepreproc(char *line) 
+{
     int lineno, fnlen;
     char *fname, *oldline;
 
@@ -354,7 +365,10 @@ static char *prepreproc(char *line) {
  * invariant under case changes. We implement this by applying a
  * perfectly normal hash function to the uppercase of the string.
  */
-static int hash(char *s) {
+static int hash(char *s) 
+{
+    unsigned int h = 0;
+    int i = 0;
     /*
      * Powers of three, mod 31.
      */
@@ -362,8 +376,7 @@ static int hash(char *s) {
 	1, 3, 9, 27, 19, 26, 16, 17, 20, 29, 25, 13, 8, 24, 10,
 	30, 28, 22, 4, 12, 5, 15, 14, 11, 2, 6, 18, 23, 7, 21
     };
-    int h = 0;
-    int i = 0;
+
 
     while (*s) {
 	h += multipliers[i] * (unsigned char) (toupper(*s));
@@ -378,7 +391,8 @@ static int hash(char *s) {
 /*
  * Free a linked list of tokens.
  */
-static void free_tlist (Token *list) {
+static void free_tlist (Token *list) 
+{
     Token *t;
     while (list) {
 	t = list;
@@ -391,7 +405,8 @@ static void free_tlist (Token *list) {
 /*
  * Free a linked list of lines.
  */
-static void free_llist (Line *list) {
+static void free_llist (Line *list) 
+{
     Line *l;
     while (list) {
 	l = list;
@@ -402,9 +417,22 @@ static void free_llist (Line *list) {
 }
 
 /*
+ * Free an MMacro
+ */
+static void free_mmacro (MMacro *m) 
+{
+    nasm_free (m->name);
+    free_tlist (m->dlist);
+    nasm_free (m->defaults);
+    free_llist (m->expansion);
+    nasm_free (m);
+}
+
+/*
  * Pop the context stack.
  */
-static void ctx_pop (void) {
+static void ctx_pop (void) 
+{
     Context *c = cstk;
     SMacro *smac, *s;
 
@@ -421,19 +449,6 @@ static void ctx_pop (void) {
     nasm_free (c);
 }
 
-/*
- * Generate a line synchronisation comment, to ensure the assembler
- * knows which source file the current output has really come from.
- */
-static void line_sync (void) {
-    char text[30+FILENAME_MAX];
-    sprintf(text, "%%line %d+%d %s",
-	    (istk->expansion ? istk->lineno - istk->lineinc : istk->lineno),
-	    (istk->expansion ? 0 : istk->lineinc), istk->fname);
-    nasm_free (linesync);
-    linesync = nasm_strdup(text);
-}
-
 #define BUF_DELTA 512
 /*
  * Read a line from the top file in istk, handling multiple CR/LFs
@@ -441,14 +456,16 @@ static void line_sync (void) {
  * return lines from the standard macro set if this has not already
  * been done.
  */
-static char *read_line (void) {
+static char *read_line (void) 
+{
     char *buffer, *p, *q;
     int bufsize;
 
     if (stdmacpos) {
 	if (*stdmacpos) {
 	    char *ret = nasm_strdup(*stdmacpos++);
-	    if (!*stdmacpos && any_extrastdmac) {
+	    if (!*stdmacpos && any_extrastdmac) 
+	    {
 		stdmacpos = extrastdmac;
 		any_extrastdmac = FALSE;
 		return ret;
@@ -459,7 +476,8 @@ static char *read_line (void) {
 	     * most convenient way to implement the pre-include and
 	     * pre-define features.
 	     */
-	    if (!*stdmacpos) {
+	    if (!*stdmacpos) 
+	    {
 		Line *pd, *l;
 		Token *head, **tail, *t, *tt;
 
@@ -482,10 +500,9 @@ static char *read_line (void) {
 		}
 	    }
 	    return ret;
-	} else {
+	} 
+	else {
 	    stdmacpos = NULL;
-	    line_sync();
-	    update_fileline(3);	       /* update __FILE__ and __LINE__ */
 	}
     }
 
@@ -498,13 +515,13 @@ static char *read_line (void) {
 	    break;
 	p += strlen(p);
 	if (p > buffer && p[-1] == '\n') {
-	    istk->lineno += istk->lineinc;
-	    update_fileline(1);	       /* update __LINE__ only */
 	    break;
 	}
 	if (p-buffer > bufsize-10) {
+	    long offset = p-buffer;
 	    bufsize += BUF_DELTA;
 	    buffer = nasm_realloc(buffer, bufsize);
+	    p = buffer+offset;	       /* prevent stale-pointer problems */
 	}
     }
 
@@ -513,12 +530,14 @@ static char *read_line (void) {
 	return NULL;
     }
 
+    src_set_linnum(src_get_linnum() + istk->lineinc);
+
     /*
      * Play safe: remove CRs as well as LFs, if any of either are
      * present at the end of the line.
      */
-    while (p > buffer && (p[-1] == '\n' || p[-1] == '\r'))
-	*--p = '\0';
+    while (--p >= buffer && (*p == '\n' || *p == '\r'))
+	*p = '\0';
 
     /*
      * Handle spurious ^Z, which may be inserted into source files
@@ -536,7 +555,8 @@ static char *read_line (void) {
  * don't need to parse the value out of e.g. numeric tokens: we
  * simply split one string into many.
  */
-static Token *tokenise (char *line) {
+static Token *tokenise (char *line) 
+{
     char *p = line;
     int type;
     Token *list = NULL;
@@ -544,31 +564,42 @@ static Token *tokenise (char *line) {
 
     while (*line) {
 	p = line;
-	if (*p == '%' &&
-	    (p[1] == '{' || p[1] == '!' || (p[1] == '%' && isidchar(p[2])) ||
-	     p[1] == '$' || p[1] == '+' || p[1] == '-' || isidchar(p[1]))) {
-	    type = TOK_PREPROC_ID;
+	if (*p == '%' && ( isdigit(p[1]) || 
+	      ((p[1] == '-' || p[1] == '+') && isdigit(p[2]))))
+	{
 	    p++;
-	    if (*p == '{') {
+	    do {
+		p++;
+	    } while (isdigit(*p));
+	    type = TOK_PREPROC_ID;
+	}
+	else if (*p == '%' && p[1] == '{') {
+	    p += 2;
+	    while (*p && *p != '}') {
+		p[-1] = *p;
 		p++;
-		while (*p && *p != '}') {
-		    p[-1] = *p;
-		    p++;
-		}
-		p[-1] = '\0';
-		if (*p) p++;
-	    } else {
-		if (*p == '!' || *p == '%' || *p == '$' ||
-		    *p == '+' || *p == '-') p++;
-		while (*p && isidchar(*p))
-		    p++;
 	    }
-	} else if (isidstart(*p) || (*p == '$' && isidstart(p[1]))) {
+	    p[-1] = '\0';
+	    if (*p) p++;
+	    type = TOK_PREPROC_ID;
+	}
+	else if (*p == '%' && (isidchar(p[1]) ||
+		  ((p[1] == '!' || p[1] == '%' || p[1] == '$') &&
+		  isidchar(p[2]))))
+	{
+	    p++;
+	    do {
+		p++;
+	    } while (isidchar(*p));
+	    type = TOK_PREPROC_ID;
+	}
+	else if (isidstart(*p) || (*p == '$' && isidstart(p[1]))) {
 	    type = TOK_ID;
 	    p++;
 	    while (*p && isidchar(*p))
 		p++;
-	} else if (*p == '\'' || *p == '"') {
+	}
+	else if (*p == '\'' || *p == '"') {
 	    /*
 	     * A string token.
 	     */
@@ -578,7 +609,8 @@ static Token *tokenise (char *line) {
 	    while (*p && *p != c)
 		p++;
 	    if (*p) p++;
-	} else if (isnumstart(*p)) {
+	} 
+	else if (isnumstart(*p)) {
 	    /*
 	     * A number token.
 	     */
@@ -586,7 +618,8 @@ static Token *tokenise (char *line) {
 	    p++;
 	    while (*p && isnumchar(*p))
 		p++;
-	} else if (isspace(*p)) {
+	} 
+	else if (isspace(*p)) {
 	    type = TOK_WHITESPACE;
 	    p++;
 	    while (*p && isspace(*p))
@@ -600,10 +633,12 @@ static Token *tokenise (char *line) {
 		type = TOK_COMMENT;
 		while (*p) p++;
 	    }
-	} else if (*p == ';') {
+	} 
+	else if (*p == ';') {
 	    type = TOK_COMMENT;
 	    while (*p) p++;
-	} else {
+	} 
+	else {
 	    /*
 	     * Anything else is an operator of some kind. We check
 	     * for all the double-character operators (>>, <<, //,
@@ -623,7 +658,9 @@ static Token *tokenise (char *line) {
 		(p[0] == '&' && p[1] == '&') ||
 		(p[0] == '|' && p[1] == '|') ||
 		(p[0] == '^' && p[1] == '^'))
+	    {
 		p++;
+	    }
 	    p++;
 	}
 	if (type != TOK_COMMENT) {
@@ -644,7 +681,8 @@ static Token *tokenise (char *line) {
 /*
  * Convert a line of tokens back into text.
  */
-static char *detoken (Token *tlist) {
+char *detoken (Token *tlist) 
+{
     Token *t;
     int len;
     char *line, *p;
@@ -679,7 +717,8 @@ static char *detoken (Token *tlist) {
  * the first token in the line to be passed in as its private_data
  * field.
  */
-static int ppscan(void *private_data, struct tokenval *tokval) {
+static int ppscan(void *private_data, struct tokenval *tokval) 
+{
     Token **tlineptr = private_data;
     Token *tline;
 
@@ -724,6 +763,25 @@ static int ppscan(void *private_data, struct tokenval *tokval) {
 	return tokval->t_type = TOKEN_NUM;
     }
 
+    if (tline->type == TOK_STRING) {
+	int rn_warn;
+	char q, *r;
+	int l;
+
+	r = tline->text;
+	q = *r++;
+	l = strlen(r);
+
+	if (l == 0 || r[l-1] != q)
+	    return tokval->t_type = TOKEN_ERRNUM;
+	tokval->t_integer = readstrnum(r, l-1, &rn_warn);
+	if (rn_warn)
+	    error(ERR_WARNING|ERR_PASS1,
+		  "character constant too long");
+	tokval->t_charptr = NULL;
+	return tokval->t_type = TOKEN_NUM;
+    }
+
     if (tline->type == TOK_OTHER) {
 	if (!strcmp(tline->text, "<<")) return tokval->t_type = TOKEN_SHL;
 	if (!strcmp(tline->text, ">>")) return tokval->t_type = TOKEN_SHR;
@@ -752,12 +810,13 @@ static int ppscan(void *private_data, struct tokenval *tokval) {
  * context stack isn't deep enough for the supplied number of $
  * signs.
  */
-static Context *get_ctx (char *name) {
+static Context *get_ctx (char *name) 
+{
     Context *ctx;
     int i;
 
     if (!cstk) {
-	error (ERR_NONFATAL|ERR_OFFBY1, "`%s': context stack is empty", name);
+	error (ERR_NONFATAL, "`%s': context stack is empty", name);
 	return NULL;
     }
 
@@ -767,7 +826,7 @@ static Context *get_ctx (char *name) {
 	i++;
 	ctx = ctx->next;
 	if (!ctx) {
-	    error (ERR_NONFATAL|ERR_OFFBY1, "`%s': context stack is only"
+	    error (ERR_NONFATAL, "`%s': context stack is only"
 		   " %d level%s deep", name, i-1, (i==2 ? "" : "s"));
 	    return NULL;
 	}
@@ -780,7 +839,8 @@ static Context *get_ctx (char *name) {
  * simple wrapper which calls either strcmp or nasm_stricmp
  * depending on the value of the `casesense' parameter.
  */
-static int mstrcmp(char *p, char *q, int casesense) {
+static int mstrcmp(char *p, char *q, int casesense) 
+{
     return casesense ? strcmp(p,q) : nasm_stricmp(p,q);
 }
 
@@ -791,26 +851,25 @@ static int mstrcmp(char *p, char *q, int casesense) {
  * the include path one by one until it finds the file or reaches
  * the end of the path.
  */
-static FILE *inc_fopen(char *file) {
+static FILE *inc_fopen(char *file) 
+{
     FILE *fp;
     char *prefix = "", *combine;
     IncPath *ip = ipath;
-    int len = strlen(file);
 
-    do {
-	combine = nasm_malloc(strlen(prefix)+len+1);
-	strcpy(combine, prefix);
-	strcat(combine, file);
+    while (1) {
+	combine = nasm_strcat(prefix,file);
 	fp = fopen(combine, "r");
 	nasm_free (combine);
 	if (fp)
 	    return fp;
-	prefix = ip ? ip->path : NULL;
-	if (ip)
-	    ip = ip->next;
-    } while (prefix);
+	if (!ip)
+	    break;
+	prefix = ip->path;
+	ip = ip->next;
+    }
 
-    error (ERR_FATAL|ERR_OFFBY1,
+    error (ERR_FATAL,
 	   "unable to open include file `%s'", file);
     return NULL;		       /* never reached - placate compilers */
 }
@@ -831,7 +890,8 @@ static FILE *inc_fopen(char *file) {
  * Note that this is also called with nparam zero to resolve
  * `ifdef'.
  */
-static int smacro_defined (char *name, int nparam, SMacro **defn) {
+static int smacro_defined (char *name, int nparam, SMacro **defn, int nocase) 
+{
     SMacro *m;
     Context *ctx;
     char *p;
@@ -849,7 +909,7 @@ static int smacro_defined (char *name, int nparam, SMacro **defn) {
     }
 
     while (m) {
-	if (!mstrcmp(m->name, p, m->casesense) &&
+	if (!mstrcmp(m->name, p, m->casesense & nocase) &&
 	    (nparam == 0 || m->nparam == 0 || nparam == m->nparam)) {
 	    if (defn) {
 		if (nparam == m->nparam)
@@ -865,48 +925,13 @@ static int smacro_defined (char *name, int nparam, SMacro **defn) {
 }
 
 /*
- * Update the __FILE__ and __LINE__ macros. Specifically, update
- * __FILE__ if bit 1 of our argument is set, and update __LINE__ if
- * bit 0 is set.
- *
- * If the macros don't exist, a `%clear' must have happened, in
- * which case we should exit quite happily and carry on going. It's
- * not an error condition.
- */
-static void update_fileline(int which) {
-    SMacro *sm;
-    char num[20];
-
-    if ((which & 3) && smacro_defined ("__FILE__", 0, &sm) && sm) {
-	free_tlist(sm->expansion);
-	sm->expansion = nasm_malloc(sizeof(Token));
-	sm->expansion->next = NULL;
-	sm->expansion->mac = NULL;
-	sm->expansion->type = TOK_STRING;
-	sm->expansion->text = nasm_malloc(3+strlen(istk->fname));
-	/* FIXME: throw an error if both sorts of quote are present */
-	/* Better still, invent a way for us to cope with that case */
-	sprintf(sm->expansion->text, "\"%s\"", istk->fname);
-    }
-
-    if ((which & 1) && smacro_defined ("__LINE__", 0, &sm) && sm) {
-	free_tlist(sm->expansion);
-	sm->expansion = nasm_malloc(sizeof(Token));
-	sm->expansion->next = NULL;
-	sm->expansion->mac = NULL;
-	sm->expansion->type = TOK_NUMBER;
-	sprintf(num, "%d", istk->lineno - istk->lineinc);
-	sm->expansion->text = nasm_strdup(num);
-    }
-}
-
-/*
  * Count and mark off the parameters in a multi-line macro call.
  * This is called both from within the multi-line macro expansion
  * code, and also to mark off the default parameters when provided
  * in a %macro definition line.
  */
-static void count_mmac_params (Token *t, int *nparam, Token ***params) {
+static void count_mmac_params (Token *t, int *nparam, Token ***params) 
+{
     int paramsize, brace;
 
     *nparam = paramsize = 0;
@@ -916,14 +941,12 @@ static void count_mmac_params (Token *t, int *nparam, Token ***params) {
 	    paramsize += PARAM_DELTA;
 	    *params = nasm_realloc(*params, sizeof(**params) * paramsize);
 	}
-	if (t && t->type == TOK_WHITESPACE)
-	    t = t->next;
+	skip_white_(t);
 	brace = FALSE;
-	if (t && t->type == TOK_OTHER && !strcmp(t->text, "{"))
+	if (tok_is_(t, "{"))
 	    brace = TRUE;
 	(*params)[(*nparam)++] = t;
-	while (t && (t->type != TOK_OTHER ||
-		     strcmp(t->text, brace ? "}" : ",")))
+	while (tok_isnt_(t, brace ? "}" : ","))
 	    t = t->next;
 	if (t) {		       /* got a comma/brace */
 	    t = t->next;
@@ -932,21 +955,17 @@ static void count_mmac_params (Token *t, int *nparam, Token ***params) {
 		 * Now we've found the closing brace, look further
 		 * for the comma.
 		 */
-		if (t && t->type == TOK_WHITESPACE)
-		    t = t->next;
-		if (t && (t->type != TOK_OTHER || strcmp(t->text, ","))) {
-		    error (ERR_NONFATAL|ERR_OFFBY1,
+		skip_white_(t);
+		if (tok_isnt_(t, ",")) {
+		    error (ERR_NONFATAL,
 			   "braces do not enclose all of macro parameter");
-		    while (t && (t->type != TOK_OTHER ||
-				 strcmp(t->text, ",")))
+		    while (tok_isnt_(t, ","))
 			t = t->next;
 		}
 		if (t)
 		    t = t->next;	       /* eat the comma */
 	    }
 	}
-	else			       /* got EOL */
-	    break;
     }
 }
 
@@ -956,11 +975,12 @@ static void count_mmac_params (Token *t, int *nparam, Token ***params) {
  *
  * We must free the tline we get passed.
  */
-static int if_condition (Token *tline, int i) {
-    int j, casesense;
-    Token *t, *tt, **tptr, *origline;
+static int if_condition (Token *tline, int i) 
+{
+    int    j, casesense;
+    Token  * t, * tt, ** tptr, * origline;
     struct tokenval tokval;
-    expr *evalresult;
+    expr   * evalresult;
 
     origline = tline;
 
@@ -969,13 +989,12 @@ static int if_condition (Token *tline, int i) {
       case PP_IFNCTX: case PP_ELIFNCTX:
 	j = FALSE;		       /* have we matched yet? */
 	if (!cstk)
-	    error(ERR_FATAL|ERR_OFFBY1,
+	    error(ERR_FATAL,
 		  "`%s': context stack is empty", directives[i]);
 	else while (tline) {
-	    if (tline->type == TOK_WHITESPACE)
-		tline = tline->next;
+	    skip_white_(tline);
 	    if (!tline || tline->type != TOK_ID) {
-		error(ERR_NONFATAL|ERR_OFFBY1,
+		error(ERR_NONFATAL,
 		      "`%s' expects context identifiers", directives[i]);
 		free_tlist (origline);
 		return -1;
@@ -993,18 +1012,17 @@ static int if_condition (Token *tline, int i) {
       case PP_IFNDEF: case PP_ELIFNDEF:
 	j = FALSE;		       /* have we matched yet? */
 	while (tline) {
-	    if (tline->type == TOK_WHITESPACE)
-		tline = tline->next;
+	    skip_white_(tline);
 	    if (!tline || (tline->type != TOK_ID &&
 			   (tline->type != TOK_PREPROC_ID ||
 			    tline->text[1] != '$'))) {
-		error(ERR_NONFATAL|ERR_OFFBY1,
+		error(ERR_NONFATAL,
 		      "`%%if%sdef' expects macro identifiers",
 		      (i==PP_ELIFNDEF ? "n" : ""));
 		free_tlist (origline);
 		return -1;
 	    }
-	    if (smacro_defined(tline->text, 0, NULL))
+	    if (smacro_defined(tline->text, 0, NULL, 1))
 		j = TRUE;
 		tline = tline->next;
 	}
@@ -1017,7 +1035,7 @@ static int if_condition (Token *tline, int i) {
       case PP_IFIDNI: case PP_ELIFIDNI: case PP_IFNIDNI: case PP_ELIFNIDNI:
 	tline = expand_smacro(tline);
 	t = tt = tline;
-	while (tt && (tt->type != TOK_OTHER || strcmp(tt->text, ",")))
+	while (tok_isnt_(tt, ","))
 	    tt = tt->next;
 	if (!tt) {
 	    error(ERR_NONFATAL, "`%s' expects two comma-separated arguments");
@@ -1054,7 +1072,8 @@ static int if_condition (Token *tline, int i) {
 	}
 	if ((t->type != TOK_OTHER || strcmp(t->text, ",")) || tt)
 	    j = FALSE;		       /* trailing gunk on one end or other */
-	if (i == PP_IFNIDN || i == PP_ELIFNIDN)
+	if (i == PP_IFNIDN || i == PP_ELIFNIDN ||
+	    i == PP_IFNIDNI || i == PP_ELIFNIDNI)
 	    j = !j;
 	free_tlist (tline);
 	return j;
@@ -1064,10 +1083,10 @@ static int if_condition (Token *tline, int i) {
       case PP_IFSTR: case PP_ELIFSTR: case PP_IFNSTR: case PP_ELIFNSTR:
 	tline = expand_smacro(tline);
 	t = tline;
-	while (t && t->type == TOK_WHITESPACE)
+	while (tok_type_(t, TOK_WHITESPACE))
 	    t = t->next;
 	j = FALSE;		       /* placate optimiser */
-	switch (i) {
+	if (t) switch (i) {
 	  case PP_IFID: case PP_ELIFID: case PP_IFNID: case PP_ELIFNID:
 	    j = (t->type == TOK_ID);
 	    break;
@@ -1095,17 +1114,17 @@ static int if_condition (Token *tline, int i) {
 	if (!evalresult)
 	    return -1;
 	if (tokval.t_type)
-	    error(ERR_WARNING|ERR_OFFBY1,
+	    error(ERR_WARNING,
 		  "trailing garbage after expression ignored");
 	if (!is_simple(evalresult)) {
-	    error(ERR_NONFATAL|ERR_OFFBY1,
+	    error(ERR_NONFATAL,
 		  "non-constant value given to `%s'", directives[i]);
 	    return -1;
 	}
 	return reloc_value(evalresult) != 0;
 
       default:
-	error(ERR_FATAL|ERR_OFFBY1,
+	error(ERR_FATAL,
 	      "preprocessor directive `%s' not yet implemented",
 	      directives[i]);
 	free_tlist (origline);
@@ -1123,14 +1142,9 @@ static int if_condition (Token *tline, int i) {
  * Return values go like this:
  * 
  * bit 0 is set if a directive was found (so the line gets freed)
- * bit 1 is set if a blank line should be emitted
- * bit 2 is set if a re-sync line number comment should be emitted
- *
- * (bits 1 and 2 are mutually exclusive in that the rest of the
- * preprocessor doesn't guarantee to be able to handle the case in
- * which both are set)
  */
-static int do_directive (Token *tline) {
+static int do_directive (Token *tline) 
+{
     int i, j, k, m, nparam, nolist;
     char *p, *mname;
     Include *inc;
@@ -1145,9 +1159,8 @@ static int do_directive (Token *tline) {
 
     origline = tline;
 
-    if (tline && tline->type == TOK_WHITESPACE)
-	tline = tline->next;
-    if (!tline || tline->type != TOK_PREPROC_ID ||
+    skip_white_(tline);
+    if (!tok_type_(tline, TOK_PREPROC_ID) ||
 	(tline->text[1]=='%' || tline->text[1]=='$' || tline->text[1]=='!'))
 	return 0;
 
@@ -1190,21 +1203,26 @@ static int do_directive (Token *tline) {
 	i != PP_IFNUM && i != PP_ELIFNUM &&
 	i != PP_IFSTR && i != PP_ELIFSTR &&
 	i != PP_ELSE && i != PP_ENDIF)
+    {
 	return 0;
+    }
 
     /*
      * If we're defining a macro or reading a %rep block, we should
      * ignore all directives except for %macro/%imacro (which
      * generate an error), %endm/%endmacro, and (only if we're in a
-     * %rep block) %endrep.
+     * %rep block) %endrep. If we're in a %rep block, another %rep
+     * causes an error, so should be let through.
      */
     if (defining && i != PP_MACRO && i != PP_IMACRO &&
 	i != PP_ENDMACRO && i != PP_ENDM &&
-	(defining->name || i != PP_ENDREP))
+	(defining->name || (i != PP_ENDREP && i != PP_REP)))
+    {
 	return 0;
+    }
 
     if (j != -2) {
-	error(ERR_NONFATAL|ERR_OFFBY1, "unknown preprocessor directive `%s'",
+	error(ERR_NONFATAL, "unknown preprocessor directive `%s'",
 	      tline->text);
 	return 0;		       /* didn't get it */
     }
@@ -1213,16 +1231,13 @@ static int do_directive (Token *tline) {
 
       case PP_CLEAR:
 	if (tline->next)
-	    error(ERR_WARNING|ERR_OFFBY1,
+	    error(ERR_WARNING,
 		  "trailing garbage after `%%clear' ignored");
 	for (j=0; j<NHASH; j++) {
 	    while (mmacros[j]) {
 		MMacro *m = mmacros[j];
-		mmacros[j] = mmacros[j]->next;
-		nasm_free (m->name);
-		free_tlist (m->dlist);
-		free_llist (m->expansion);
-		nasm_free (m);
+		mmacros[j] = m->next;
+		free_mmacro(m);
 	    }
 	    while (smacros[j]) {
 		SMacro *s = smacros[j];
@@ -1237,16 +1252,16 @@ static int do_directive (Token *tline) {
 
       case PP_INCLUDE:
 	tline = tline->next;
-	if (tline && tline->type == TOK_WHITESPACE)
-	    tline = tline->next;
+	skip_white_(tline);
 	if (!tline || (tline->type != TOK_STRING &&
-		       tline->type != TOK_INTERNAL_STRING)) {
-	    error(ERR_NONFATAL|ERR_OFFBY1, "`%%include' expects a file name");
+		       tline->type != TOK_INTERNAL_STRING)) 
+	{
+	    error(ERR_NONFATAL, "`%%include' expects a file name");
 	    free_tlist (origline);
 	    return 3;		       /* but we did _something_ */
 	}
 	if (tline->next)
-	    error(ERR_WARNING|ERR_OFFBY1,
+	    error(ERR_WARNING,
 		  "trailing garbage after `%%include' ignored");
 	if (tline->type != TOK_INTERNAL_STRING) {
 	    p = tline->text+1;	       /* point past the quote to the name */
@@ -1257,28 +1272,27 @@ static int do_directive (Token *tline) {
 	inc->next = istk;
 	inc->conds = NULL;
 	inc->fp = inc_fopen(p);
-	inc->fname = nasm_strdup(p);
-	inc->lineno = inc->lineinc = 1;
+	inc->fname = src_set_fname(nasm_strdup(p));
+	inc->lineno = src_set_linnum(0);
+	inc->lineinc = 1;
 	inc->expansion = NULL;
 	inc->mstk = NULL;
 	istk = inc;
 	list->uplevel (LIST_INCLUDE);
-	update_fileline(3);	       /* update __FILE__ and __LINE__ */
 	free_tlist (origline);
 	return 5;
 
       case PP_PUSH:
 	tline = tline->next;
-	if (tline && tline->type == TOK_WHITESPACE)
-	    tline = tline->next;
-	if (!tline || tline->type != TOK_ID) {
-	    error(ERR_NONFATAL|ERR_OFFBY1,
+	skip_white_(tline);
+	if (!tok_type_(tline, TOK_ID)) {
+	    error(ERR_NONFATAL,
 		  "`%%push' expects a context identifier");
 	    free_tlist (origline);
 	    return 3;		       /* but we did _something_ */
 	}
 	if (tline->next)
-	    error(ERR_WARNING|ERR_OFFBY1,
+	    error(ERR_WARNING,
 		  "trailing garbage after `%%push' ignored");
 	ctx = nasm_malloc(sizeof(Context));
 	ctx->next = cstk;
@@ -1291,19 +1305,18 @@ static int do_directive (Token *tline) {
 
       case PP_REPL:
 	tline = tline->next;
-	if (tline && tline->type == TOK_WHITESPACE)
-	    tline = tline->next;
-	if (!tline || tline->type != TOK_ID) {
-	    error(ERR_NONFATAL|ERR_OFFBY1,
+	skip_white_(tline);
+	if (!tok_type_(tline, TOK_ID)) {
+	    error(ERR_NONFATAL,
 		  "`%%repl' expects a context identifier");
 	    free_tlist (origline);
 	    return 3;		       /* but we did _something_ */
 	}
 	if (tline->next)
-	    error(ERR_WARNING|ERR_OFFBY1,
+	    error(ERR_WARNING,
 		  "trailing garbage after `%%repl' ignored");
 	if (!cstk)
-	    error(ERR_NONFATAL|ERR_OFFBY1,
+	    error(ERR_NONFATAL,
 		  "`%%repl': context stack is empty");
 	else {
 	    nasm_free (cstk->name);
@@ -1314,10 +1327,10 @@ static int do_directive (Token *tline) {
 
       case PP_POP:
 	if (tline->next)
-	    error(ERR_WARNING|ERR_OFFBY1,
+	    error(ERR_WARNING,
 		  "trailing garbage after `%%pop' ignored");
 	if (!cstk)
-	    error(ERR_NONFATAL|ERR_OFFBY1,
+	    error(ERR_NONFATAL,
 		  "`%%pop': context stack is already empty");
 	else
 	    ctx_pop();
@@ -1325,21 +1338,18 @@ static int do_directive (Token *tline) {
 	break;
 
       case PP_ERROR:
+	tline->next = expand_smacro (tline->next);
 	tline = tline->next;
-	if (tline && tline->type == TOK_WHITESPACE)
-	    tline = tline->next;
-	if (!tline || tline->type != TOK_STRING) {
-	    error(ERR_NONFATAL|ERR_OFFBY1,
-		  "`%%error' expects an error string");
-	    free_tlist (origline);
-	    return 3;		       /* but we did _something_ */
+	skip_white_(tline);
+	if (tok_type_(tline, TOK_STRING)) {
+	    p = tline->text+1;	       /* point past the quote to the name */
+	    p[strlen(p)-1] = '\0';     /* remove the trailing quote */
+	    error(ERR_NONFATAL, "user error: %s", p);
+	} else {
+	    p = detoken(tline);
+	    error(ERR_WARNING, "user error: %s", p);
+	    nasm_free(p);
 	}
-	if (tline->next)
-	    error(ERR_WARNING|ERR_OFFBY1,
-		  "trailing garbage after `%%error' ignored");
-	p = tline->text+1;	       /* point past the quote to the name */
-	p[strlen(p)-1] = '\0';	       /* remove the trailing quote */
-	error(ERR_NONFATAL|ERR_OFFBY1, "user error: %s", p);
 	free_tlist (origline);
 	break;
 
@@ -1365,7 +1375,12 @@ static int do_directive (Token *tline) {
 	    tline->next = NULL;	       /* it got freed */
 	    free_tlist (origline);
 	    if (j < 0)
-		return 3;
+		/*
+		 * Bogus expression in %if, but we should pretend
+		 * it was OK anyway, so that we don't get an error
+		 * cascade on the subsequent %else / %endif.
+		 */
+		j = COND_NEVER;
 	    else
 		j = j ? COND_IF_TRUE : COND_IF_FALSE;
 	}
@@ -1391,7 +1406,7 @@ static int do_directive (Token *tline) {
       case PP_ELIFNUM:
       case PP_ELIFSTR:
 	if (!istk->conds)
-	    error(ERR_FATAL|ERR_OFFBY1, "`%s': no matching `%%if'",
+	    error(ERR_FATAL, "`%s': no matching `%%if'",
 		  directives[i]);
 	if (emitting(istk->conds->state) || istk->conds->state == COND_NEVER)
 	    istk->conds->state = COND_NEVER;
@@ -1400,7 +1415,11 @@ static int do_directive (Token *tline) {
 	    tline->next = NULL;	       /* it got freed */
 	    free_tlist (origline);
 	    if (j < 0)
-		return 3;
+		/*
+		 * The expression was bogus, but let's make
+		 * %endif not complain about missing %if
+		 */
+		j = COND_NEVER;
 	    else
 		istk->conds->state = j ? COND_IF_TRUE : COND_IF_FALSE;
 	}
@@ -1408,10 +1427,10 @@ static int do_directive (Token *tline) {
 
       case PP_ELSE:
 	if (tline->next)
-	    error(ERR_WARNING|ERR_OFFBY1,
+	    error(ERR_WARNING,
 		  "trailing garbage after `%%else' ignored");
 	if (!istk->conds)
-	    error(ERR_FATAL|ERR_OFFBY1,
+	    error(ERR_FATAL,
 		  "`%%else': no matching `%%if'");
 	if (emitting(istk->conds->state) || istk->conds->state == COND_NEVER)
 	    istk->conds->state = COND_ELSE_FALSE;
@@ -1422,10 +1441,10 @@ static int do_directive (Token *tline) {
 
       case PP_ENDIF:
 	if (tline->next)
-	    error(ERR_WARNING|ERR_OFFBY1,
+	    error(ERR_WARNING,
 		  "trailing garbage after `%%endif' ignored");
 	if (!istk->conds)
-	    error(ERR_FATAL|ERR_OFFBY1,
+	    error(ERR_FATAL,
 		  "`%%endif': no matching `%%if'");
 	cond = istk->conds;
 	istk->conds = cond->next;
@@ -1436,14 +1455,13 @@ static int do_directive (Token *tline) {
       case PP_MACRO:
       case PP_IMACRO:
 	if (defining)
-	    error (ERR_FATAL|ERR_OFFBY1,
+	    error (ERR_FATAL,
 		   "`%%%smacro': already defining a macro",
 		   (i == PP_IMACRO ? "i" : ""));
 	tline = tline->next;
-	if (tline && tline->type == TOK_WHITESPACE)
-	    tline = tline->next;
-	if (!tline || tline->type != TOK_ID) {
-	    error (ERR_NONFATAL|ERR_OFFBY1,
+	skip_white_(tline);
+	if (!tok_type_(tline, TOK_ID)) {
+	    error (ERR_NONFATAL,
 		   "`%%%smacro' expects a macro name",
 		   (i == PP_IMACRO ? "i" : ""));
 	    return 3;
@@ -1455,10 +1473,9 @@ static int do_directive (Token *tline) {
 	defining->nolist = FALSE;
 	defining->in_progress = FALSE;
 	tline = tline->next;
-	if (tline && tline->type == TOK_WHITESPACE)
-	    tline = tline->next;
-	if (!tline || tline->type != TOK_NUMBER) {
-	    error (ERR_NONFATAL|ERR_OFFBY1,
+	skip_white_(tline);
+	if (!tok_type_(tline, TOK_NUMBER)) {
+	    error (ERR_NONFATAL,
 		   "`%%%smacro' expects a parameter count",
 		   (i == PP_IMACRO ? "i" : ""));
 	    defining->nparam_min = defining->nparam_max = 0;
@@ -1466,37 +1483,35 @@ static int do_directive (Token *tline) {
 	    defining->nparam_min = defining->nparam_max =
 		readnum(tline->text, &j);
 	    if (j)
-		error (ERR_NONFATAL|ERR_OFFBY1,
+		error (ERR_NONFATAL,
 		       "unable to parse parameter count `%s'", tline->text);
 	}
-	if (tline && tline->next && tline->next->type == TOK_OTHER &&
-	    !strcmp(tline->next->text, "-")) {
+	if (tline && tok_is_(tline->next, "-")) {
 	    tline = tline->next->next;
-	    if (tline && tline->type == TOK_OTHER &&
-		!strcmp(tline->text, "*"))
+	    if (tok_is_(tline, "*"))
 		defining->nparam_max = INT_MAX;
-	    else if (!tline || tline->type != TOK_NUMBER)
-		error (ERR_NONFATAL|ERR_OFFBY1,
+	    else if (!tok_type_(tline, TOK_NUMBER))
+		error (ERR_NONFATAL,
 		       "`%%%smacro' expects a parameter count after `-'",
 		       (i == PP_IMACRO ? "i" : ""));
 	    else {
 		defining->nparam_max = readnum(tline->text, &j);
 		if (j)
-		    error (ERR_NONFATAL|ERR_OFFBY1,
+		    error (ERR_NONFATAL,
 			   "unable to parse parameter count `%s'",
 			   tline->text);
 		if (defining->nparam_min > defining->nparam_max)
-		    error (ERR_NONFATAL|ERR_OFFBY1,
+		    error (ERR_NONFATAL,
 			   "minimum parameter count exceeds maximum");
 	    }
 	}
-	if (tline && tline->next && tline->next->type == TOK_OTHER &&
-	    !strcmp(tline->next->text, "+")) {
+	if (tline && tok_is_(tline->next, "+")) {
 	    tline = tline->next;
 	    defining->plus = TRUE;
 	}
-	if (tline && tline->next && tline->next->type == TOK_ID &&
-	    !nasm_stricmp(tline->next->text, ".nolist")) {
+	if (tline && tok_type_(tline->next, TOK_ID) &&
+	    !nasm_stricmp(tline->next->text, ".nolist")) 
+	{
 	    tline = tline->next;
 	    defining->nolist = TRUE;
 	}
@@ -1504,8 +1519,9 @@ static int do_directive (Token *tline) {
 	while (mmac) {
 	    if (!strcmp(mmac->name, defining->name) &&
 		(mmac->nparam_min<=defining->nparam_max || defining->plus) &&
-		(defining->nparam_min<=mmac->nparam_max || mmac->plus)) {
-		error (ERR_WARNING|ERR_OFFBY1,
+		(defining->nparam_min<=mmac->nparam_max || mmac->plus)) 
+	    {
+		error (ERR_WARNING,
 		       "redefining multi-line macro `%s'", defining->name);
 		break;
 	    }
@@ -1530,7 +1546,7 @@ static int do_directive (Token *tline) {
       case PP_ENDM:
       case PP_ENDMACRO:
 	if (!defining) {
-	    error (ERR_NONFATAL|ERR_OFFBY1, "`%s': not defining a macro",
+	    error (ERR_NONFATAL, "`%s': not defining a macro",
 		   tline->text);
 	    return 3;
 	}
@@ -1555,10 +1571,10 @@ static int do_directive (Token *tline) {
 	if (!evalresult)
 	    return 3;
 	if (tokval.t_type)
-	    error(ERR_WARNING|ERR_OFFBY1,
+	    error(ERR_WARNING,
 		  "trailing garbage after expression ignored");
 	if (!is_simple(evalresult)) {
-	    error(ERR_NONFATAL|ERR_OFFBY1,
+	    error(ERR_NONFATAL,
 		  "non-constant value given to `%%rotate'");
 	    return 3;
 	}
@@ -1566,7 +1582,7 @@ static int do_directive (Token *tline) {
 	while (mmac && !mmac->name)    /* avoid mistaking %reps for macros */
 	    mmac = mmac->next_active;
 	if (!mmac)
-	    error(ERR_NONFATAL, "`%rotate' invoked outside a macro call");
+	    error(ERR_NONFATAL, "`%%rotate' invoked outside a macro call");
 	mmac->rotate = mmac->rotate + reloc_value(evalresult);
 	if (mmac->rotate < 0)
 	    mmac->rotate = mmac->nparam - (-mmac->rotate) % mmac->nparam;
@@ -1574,6 +1590,24 @@ static int do_directive (Token *tline) {
 	return 1;
 
       case PP_REP:
+	  if (defining) {
+	      /*
+	       * We don't allow nested %reps, because of a strange bug
+	       * that was causing a panic. The cause of the bug appears to be
+	       * that the nested %rep isn't taken into account when matching
+	       * against the %endreps, so some mechanism to count the
+	       * %reps in and the %endreps out may well work here.
+	       * 
+	       * That's for experimentation with later, though.
+	       * For informations sake, the panic produced by
+	       * nesting %reps was:
+	       *
+	       * istk->mstk has no name but defining is set at end
+	       * of expansion
+	       */
+	      error(ERR_NONFATAL, "nested `%%rep' invocation not allowed");
+	      break;
+	  }
 	nolist = FALSE;
 	tline = tline->next;
 	if (tline->next && tline->next->type == TOK_WHITESPACE)
@@ -1594,10 +1628,10 @@ static int do_directive (Token *tline) {
 	if (!evalresult)
 	    return 3;
 	if (tokval.t_type)
-	    error(ERR_WARNING|ERR_OFFBY1,
+	    error(ERR_WARNING,
 		  "trailing garbage after expression ignored");
 	if (!is_simple(evalresult)) {
-	    error(ERR_NONFATAL|ERR_OFFBY1,
+	    error(ERR_NONFATAL,
 		  "non-constant value given to `%%rep'");
 	    return 3;
 	}
@@ -1608,13 +1642,15 @@ static int do_directive (Token *tline) {
 	defining->nolist = nolist;
 	defining->in_progress = reloc_value(evalresult) + 1;
 	defining->nparam_min = defining->nparam_max = 0;
+	defining->defaults = NULL;
+	defining->dlist = NULL;
 	defining->expansion = NULL;
 	defining->next_active = istk->mstk;
 	return 1;
 
       case PP_ENDREP:
-	if (!defining) {
-	    error (ERR_NONFATAL|ERR_OFFBY1,
+	if (!defining || defining->name) {
+	    error (ERR_NONFATAL,
 		   "`%%endrep': no matching `%%rep'");
 	    return 3;
 	}
@@ -1641,7 +1677,7 @@ static int do_directive (Token *tline) {
 	list->uplevel (defining->nolist ? LIST_MACRO_NOLIST : LIST_MACRO);
 	defining = NULL;
 	free_tlist (origline);
-	return 1;		       /* the expansion will line-sync */
+	return 1;
 
       case PP_EXITREP:
 	/*
@@ -1653,22 +1689,21 @@ static int do_directive (Token *tline) {
 	    if (l->finishes && !l->finishes->name)
 		break;
 
-	if (l->finishes && !l->finishes->name)
+	if (l)
 	    l->finishes->in_progress = 0;
 	else
 	    error (ERR_NONFATAL, "`%%exitrep' not within `%%rep' block");
 	free_tlist (origline);
-	return 1;		       /* the end marker will line-sync */
+	return 1;
 
       case PP_DEFINE:
       case PP_IDEFINE:
 	tline = tline->next;
-	if (tline && tline->type == TOK_WHITESPACE)
-	    tline = tline->next;
+	skip_white_(tline);
 	if (!tline || (tline->type != TOK_ID &&
 		       (tline->type != TOK_PREPROC_ID ||
 			tline->text[1] != '$'))) {
-	    error (ERR_NONFATAL|ERR_OFFBY1,
+	    error (ERR_NONFATAL,
 		   "`%%%sdefine' expects a macro identifier",
 		   (i == PP_IDEFINE ? "i" : ""));
 	    free_tlist (origline);
@@ -1691,23 +1726,22 @@ static int do_directive (Token *tline) {
 	last = tline;
 	param_start = tline = tline->next;
 	nparam = 0;
-	if (tline && tline->type == TOK_OTHER && !strcmp(tline->text, "(")) {
+	if (tok_is_(tline, "(")) {
 	    /*
 	     * This macro has parameters.
 	     */
 
 	    tline = tline->next;
 	    while (1) {
-		if (tline && tline->type == TOK_WHITESPACE)
-		    tline = tline->next;
+		skip_white_(tline);
 		if (!tline) {
-		    error (ERR_NONFATAL|ERR_OFFBY1,
+		    error (ERR_NONFATAL,
 			   "parameter identifier expected");
 		    free_tlist (origline);
 		    return 3;
 		}
 		if (tline->type != TOK_ID) {
-		    error (ERR_NONFATAL|ERR_OFFBY1,
+		    error (ERR_NONFATAL,
 			   "`%s': parameter identifier expected",
 			   tline->text);
 		    free_tlist (origline);
@@ -1715,16 +1749,13 @@ static int do_directive (Token *tline) {
 		}
 		tline->type = TOK_SMAC_PARAM + nparam++;
 		tline = tline->next;
-		if (tline && tline->type == TOK_WHITESPACE)
-		    tline = tline->next;
-		if (tline && tline->type == TOK_OTHER &&
-		    !strcmp(tline->text, ",")) {
+		skip_white_(tline);
+		if (tok_is_(tline, ",")) {
 		    tline = tline->next;
 		    continue;
 		}
-		if (!tline || tline->type != TOK_OTHER ||
-		    strcmp(tline->text, ")")) {
-		    error (ERR_NONFATAL|ERR_OFFBY1,
+		if (!tok_is_(tline, ")")) {
+		    error (ERR_NONFATAL,
 			   "`)' expected to terminate macro template");
 		    free_tlist (origline);
 		    return 3;
@@ -1734,7 +1765,7 @@ static int do_directive (Token *tline) {
 	    last = tline;
 	    tline = tline->next;
 	}
-	if (tline && tline->type == TOK_WHITESPACE)
+	if (tok_type_(tline, TOK_WHITESPACE))
 	    last = tline, tline = tline->next;
 	macro_start = NULL;
 	last->next = NULL;
@@ -1759,12 +1790,15 @@ static int do_directive (Token *tline) {
 	 * carefully re-terminated after chopping off the expansion
 	 * from the end).
 	 */
-	if (smacro_defined (mname, nparam, &smac)) {
-	    if (!smac)
-		error (ERR_WARNING|ERR_OFFBY1,
+	if (smacro_defined (mname, nparam, &smac, i==PP_DEFINE)) {
+	    if (!smac) {
+		error (ERR_WARNING,
 		       "single-line macro `%s' defined both with and"
 		       " without parameters", mname);
-	    else {
+		free_tlist (origline);
+		free_tlist (macro_start);
+		return 3;
+	    } else {
 		/*
 		 * We're redefining, so we have to take over an
 		 * existing SMacro structure. This means freeing
@@ -1789,12 +1823,11 @@ static int do_directive (Token *tline) {
       case PP_ASSIGN:
       case PP_IASSIGN:
 	tline = tline->next;
-	if (tline && tline->type == TOK_WHITESPACE)
-	    tline = tline->next;
+	skip_white_(tline);
 	if (!tline || (tline->type != TOK_ID &&
 		       (tline->type != TOK_PREPROC_ID ||
 			tline->text[1] != '$'))) {
-	    error (ERR_NONFATAL|ERR_OFFBY1,
+	    error (ERR_NONFATAL,
 		   "`%%%sassign' expects a macro identifier",
 		   (i == PP_IASSIGN ? "i" : ""));
 	    free_tlist (origline);
@@ -1831,11 +1864,11 @@ static int do_directive (Token *tline) {
 	}
 
 	if (tokval.t_type)
-	    error(ERR_WARNING|ERR_OFFBY1,
+	    error(ERR_WARNING,
 		  "trailing garbage after expression ignored");
 
 	if (!is_simple(evalresult)) {
-	    error(ERR_NONFATAL|ERR_OFFBY1,
+	    error(ERR_NONFATAL,
 		  "non-constant value given to `%%%sassign'",
 		  (i == PP_IASSIGN ? "i" : ""));
 	    free_tlist (origline);
@@ -1844,22 +1877,17 @@ static int do_directive (Token *tline) {
 
 	macro_start = nasm_malloc(sizeof(*macro_start));
 	macro_start->next = NULL;
-	{
-	    char numbuf[20];
-	    sprintf(numbuf, "%ld", reloc_value(evalresult));
-	    macro_start->text = nasm_strdup(numbuf);
-	}
+	make_tok_num(macro_start, reloc_value(evalresult));
 	macro_start->mac = NULL;
-	macro_start->type = TOK_NUMBER;
 
 	/*
 	 * We now have a macro name, an implicit parameter count of
 	 * zero, and a numeric token to use as an expansion. Create
 	 * and store an SMacro.
 	 */
-	if (smacro_defined (mname, 0, &smac)) {
+	if (smacro_defined (mname, 0, &smac, i==PP_ASSIGN)) {
 	    if (!smac)
-		error (ERR_WARNING|ERR_OFFBY1,
+		error (ERR_WARNING,
 		       "single-line macro `%s' defined both with and"
 		       " without parameters", mname);
 	    else {
@@ -1871,7 +1899,8 @@ static int do_directive (Token *tline) {
 		nasm_free (smac->name);
 		free_tlist (smac->expansion);
 	    }
-	} else {
+	} 
+	else {
 	    smac = nasm_malloc(sizeof(SMacro));
 	    smac->next = *smhead;
 	    *smhead = smac;
@@ -1889,20 +1918,19 @@ static int do_directive (Token *tline) {
 	 * Syntax is `%line nnn[+mmm] [filename]'
 	 */
 	tline = tline->next;
-	if (tline && tline->type == TOK_WHITESPACE)
-	    tline = tline->next;
-	if (!tline || tline->type != TOK_NUMBER) {
-	    error (ERR_NONFATAL|ERR_OFFBY1, "`%%line' expects line number");
+	skip_white_(tline);
+	if (!tok_type_(tline, TOK_NUMBER)) {
+	    error (ERR_NONFATAL, "`%%line' expects line number");
 	    free_tlist (origline);
 	    return 3;
 	}
 	k = readnum(tline->text, &j);
 	m = 1;
 	tline = tline->next;
-	if (tline && tline->type == TOK_OTHER && !strcmp(tline->text, "+")) {
+	if (tok_is_(tline, "+")) {
 	    tline = tline->next;
-	    if (!tline || tline->type != TOK_NUMBER) {
-		error (ERR_NONFATAL|ERR_OFFBY1,
+	    if (!tok_type_(tline, TOK_NUMBER)) {
+		error (ERR_NONFATAL,
 		       "`%%line' expects line increment");
 		free_tlist (origline);
 		return 3;
@@ -1910,21 +1938,17 @@ static int do_directive (Token *tline) {
 	    m = readnum(tline->text, &j);
 	    tline = tline->next;
 	}
-	if (tline && tline->type == TOK_WHITESPACE)
-	    tline = tline->next;
-	istk->lineno = k;
+	skip_white_(tline);
+	src_set_linnum(k);
 	istk->lineinc = m;
-	update_fileline(3);	       /* update __FILE__ and __LINE__ */
 	if (tline) {
-	    char *s = detoken(tline);
-	    nasm_free (istk->fname);
-	    istk->fname = s;
+	    nasm_free ( src_set_fname ( detoken(tline) ) );
 	}
 	free_tlist (origline);
 	return 5;
 
       default:
-	error(ERR_FATAL|ERR_OFFBY1,
+	error(ERR_FATAL,
 	      "preprocessor directive `%s' not yet implemented",
 	      directives[i]);
 	break;
@@ -1937,17 +1961,16 @@ static int do_directive (Token *tline) {
  * nothing else. Return the condition code index if so, or -1
  * otherwise.
  */
-static int find_cc (Token *t) {
+static int find_cc (Token *t) 
+{
     Token *tt;
     int i, j, k, m;
 
-    if (t && t->type == TOK_WHITESPACE)
-	t = t->next;
+    skip_white_(t);
     if (t->type != TOK_ID)
 	return -1;
     tt = t->next;
-    if (tt && tt->type == TOK_WHITESPACE)
-	tt = tt->next;
+    skip_white_(tt);
     if (tt && (tt->type != TOK_OTHER || strcmp(tt->text, ",")))
 	return -1;
 
@@ -1974,7 +1997,8 @@ static int find_cc (Token *t) {
  * Expand MMacro-local things: parameter references (%0, %n, %+n,
  * %-n) and MMacro-local identifiers (%%foo).
  */
-static Token *expand_mmac_params (Token *tline) {
+static Token *expand_mmac_params (Token *tline) 
+{
     Token *t, *tt, *ttt, **tail, *thead;
 
     tail = &thead;
@@ -2012,9 +2036,7 @@ static Token *expand_mmac_params (Token *tline) {
 	      case '%':
 		type = TOK_ID;
 		sprintf(tmpbuf, "..@%lu.", mac->unique);
-		text = nasm_malloc(strlen(tmpbuf)+strlen(t->text+2)+1);
-		strcpy(text, tmpbuf);
-		strcat(text, t->text+2);
+		text = nasm_strcat(tmpbuf, t->text+2);
 		break;
 	      case '-':
 		n = atoi(t->text+2)-1;
@@ -2027,14 +2049,14 @@ static Token *expand_mmac_params (Token *tline) {
 		}
 		cc = find_cc (tt);
 		if (cc == -1) {
-		    error (ERR_NONFATAL|ERR_OFFBY1,
+		    error (ERR_NONFATAL,
 			   "macro parameter %d is not a condition code",
 			   n+1);
 		    text = NULL;
 		} else {
 		    type = TOK_ID;
 		    if (inverse_ccs[cc] == -1) {
-			error (ERR_NONFATAL|ERR_OFFBY1,
+			error (ERR_NONFATAL,
 			       "condition code `%s' is not invertible",
 			       conditions[cc]);
 			text = NULL;
@@ -2053,7 +2075,7 @@ static Token *expand_mmac_params (Token *tline) {
 		}
 		cc = find_cc (tt);
 		if (cc == -1) {
-		    error (ERR_NONFATAL|ERR_OFFBY1,
+		    error (ERR_NONFATAL,
 			   "macro parameter %d is not a condition code",
 			   n+1);
 		    text = NULL;
@@ -2074,7 +2096,6 @@ static Token *expand_mmac_params (Token *tline) {
 		if (tt) {
 		    for (i=0; i<mac->paramlen[n]; i++) {
 			ttt = *tail = nasm_malloc(sizeof(Token));
-			ttt->next = NULL;
 			tail = &ttt->next;
 			ttt->type = tt->type;
 			ttt->text = nasm_strdup(tt->text);
@@ -2086,10 +2107,10 @@ static Token *expand_mmac_params (Token *tline) {
 		break;
 	    }
 	    nasm_free (t->text);
-	    nasm_free (t);
-	    if (text) {
-		t = *tail = nasm_malloc(sizeof(Token));
-		t->next = NULL;
+	    if (!text) {
+		nasm_free (t);
+	    } else {
+		*tail = t;
 		tail = &t->next;
 		t->type = type;
 		t->text = text;
@@ -2100,10 +2121,42 @@ static Token *expand_mmac_params (Token *tline) {
 	    t = *tail = tline;
 	    tline = tline->next;
 	    t->mac = NULL;
-	    t->next = NULL;
 	    tail = &t->next;
 	}
     }
+    *tail = NULL;
+    t = thead;
+    for (; t && (tt=t->next)!=NULL ; t = t->next)
+	switch (t->type) {
+	case TOK_WHITESPACE:
+	    if (tt->type == TOK_WHITESPACE) {
+		t->next = tt->next;
+		nasm_free(tt->text);
+		nasm_free(tt); 
+	    }
+	    break;
+	case TOK_ID:
+	    if (tt->type == TOK_ID || tt->type == TOK_NUMBER) {
+		char *tmp = nasm_strcat(t->text, tt->text);
+		nasm_free(t->text);
+		t->text = tmp;
+		t->next = tt->next;
+		nasm_free(tt->text);
+		nasm_free(tt); 
+	    }
+	    break;
+	case TOK_NUMBER:
+	    if (tt->type == TOK_NUMBER) {
+		char *tmp = nasm_strcat(t->text, tt->text);
+		nasm_free(t->text);
+		t->text = tmp;
+		t->next = tt->next;
+		nasm_free(tt->text);
+		nasm_free(tt); 
+	    }
+	    break;
+	}
+		
     return thead;
 }
 
@@ -2114,9 +2167,10 @@ static Token *expand_mmac_params (Token *tline) {
  * Tokens from input to output a lot of the time, rather than
  * actually bothering to destroy and replicate.)
  */
-static Token *expand_smacro (Token *tline) {
+static Token *expand_smacro (Token *tline) 
+{
     Token *t, *tt, *mstart, **tail, *thead;
-    SMacro *head, *m;
+    SMacro *head = NULL, *m;
     Token **params;
     int *paramsize;
     int nparam, sparam, brackets;
@@ -2125,239 +2179,256 @@ static Token *expand_smacro (Token *tline) {
     tail = &thead;
     thead = NULL;
 
-    while (tline) {
-	while (tline && tline->type != TOK_ID &&
-	       (tline->type != TOK_PREPROC_ID || tline->text[1] != '$')) {
-	    if (tline->type == TOK_SMAC_END) {
-		tline->mac->in_progress = FALSE;
-		t = tline;
-		tline = tline->next;
-		nasm_free (t);
-	    } else {
-		t = *tail = tline;
-		tline = tline->next;
-		t->mac = NULL;
-		t->next = NULL;
-		tail = &t->next;
-		if (t->type == TOK_PS_OTHER) {
-		    /*
-		     * If we see a PS_OTHER, we must at the very
-		     * least restore its correct token type. We
-		     * should also check for a %$ token, since this
-		     * is the point at which we expand context-
-		     * local labels.
-		     */
-		    t->type = TOK_ID;
-		    if (t->text[0] == '%' && t->text[1] == '$') {
-			Context *c = get_ctx (t->text);
-			char *p, *q, buffer[40];
-
-			if (c) {
-			    q = t->text+1;
-			    q += strspn(q, "$");
-			    sprintf(buffer, "..@%lu.", c->number);
-			    p = nasm_malloc (strlen(buffer)+strlen(q)+1);
-			    strcpy (p, buffer);
-			    strcat (p, q);
-			    nasm_free (t->text);
-			    t->text = p;
-			}
-		    }
-		}
-	    }
-	}
-
-	if (!tline)
-	    break;
-	/*
-	 * We've hit an identifier. As in is_mmacro below, we first
-	 * check whether the identifier is a single-line macro at
-	 * all, then think about checking for parameters if
-	 * necessary.
-	 */
+    while (tline) {  /* main token loop */
+	p = NULL;
 	if (tline->type == TOK_ID) {
 	    head = smacros[hash(tline->text)];
 	    p = tline->text;
-	} else {
+	} else if (tline->type == TOK_PREPROC_ID && tline->text[1] == '$') {
 	    Context *ctx = get_ctx (tline->text);
 	    if (ctx) {
-		p = tline->text+1;
-		p += strspn(p, "$");
 		head = ctx->localmac;
-	    } else {
-		tline->type = TOK_OTHER; /* so it will get copied above */
-		continue;		
+		p = tline->text+2;
+		p += strspn(p, "$");
 	    }
 	}
-	for (m = head; m; m = m->next)
-	    if (!mstrcmp(m->name, p, m->casesense))
-		break;
-	if (!m || m->in_progress) {
-	    /*
-	     * Either we didn't find a macro, so this can't be a
-	     * macro call, or we found a macro which was already in
-	     * progress, in which case we don't _treat_ this as a
-	     * macro call. Copy it through and ignore it.
-	     */
-	    tline->type = TOK_PS_OTHER;   /* so it will get copied above */
-	    continue;
-	}
-	mstart = tline;
-	if (m->nparam == 0) {
-	    /*
-	     * Simple case: the macro is parameterless. Discard the
-	     * one token that the macro call took, and push the
-	     * expansion back on the to-do stack.
-	     */
-	    params = NULL;
-	    paramsize = NULL;
-	} else {
-	    /*
-	     * Complicated case: at least one macro with this name
-	     * exists and takes parameters. We must find the
-	     * parameters in the call, count them, find the SMacro
-	     * that corresponds to that form of the macro call, and
-	     * substitute for the parameters when we expand. What a
-	     * pain.
-	     */
-	    nparam = sparam = 0;
-	    params = NULL;
-	    paramsize = NULL;
-	    tline = tline->next;
-	    if (tline && tline->type == TOK_WHITESPACE)
-		tline = tline->next;
-	    if (!tline || tline->type != TOK_OTHER ||
-		strcmp(tline->text, "(")) {
+	if (p) {
+	/*
+	 * We've hit an identifier. As in is_mmacro below, we first
+	 * check whether the identifier is a single-line macro at
+	 * all, then think about checking for parameters if
+	 * necessary.
+	 */
+	    for (m = head; m; m = m->next)
+		if (!mstrcmp(m->name, p, m->casesense))
+		    break;
+	    if (m) {
+	      mstart = tline;
+	      params = NULL;
+	      paramsize = NULL;
+	      if (m->nparam == 0) {
 		/*
-		 * This macro wasn't called with parameters: ignore
-		 * the call. (Behaviour borrowed from gnu cpp.)
+	 	 * Simple case: the macro is parameterless. Discard the
+		 * one token that the macro call took, and push the
+		 * expansion back on the to-do stack.
 		 */
-		tline = mstart;
-		tline->type = TOK_PS_OTHER;
-		continue;
-	    }
-	    tline = tline->next;
-	    while (1) {
-		if (tline && tline->type == TOK_WHITESPACE)
+		if (!m->expansion) 
+		{
+		    if (!strcmp("__FILE__", m->name)) {
+			long num=0;
+			src_get(&num, &(tline->text));
+			nasm_quote(&(tline->text));
+			tline->type = TOK_STRING;
+			continue;
+		    }
+		    if (!strcmp("__LINE__", m->name)) {
+			nasm_free(tline->text);
+			make_tok_num(tline, src_get_linnum());
+			continue;
+		    }
+		    t = tline;
 		    tline = tline->next;
-		if (!tline) {
-		    error(ERR_NONFATAL|ERR_OFFBY1,
-			  "macro call expects terminating `)'");
-		    break;
+		    nasm_free (t->text);
+		    nasm_free (t);
+		    continue;
 		}
-		if (nparam >= sparam) {
-		    sparam += PARAM_DELTA;
-		    params = nasm_realloc (params, sparam*sizeof(Token *));
-		    paramsize = nasm_realloc (paramsize, sparam*sizeof(int));
+	      } 
+	      else {
+		  /*
+		   * Complicated case: at least one macro with this name
+		   * exists and takes parameters. We must find the
+		   * parameters in the call, count them, find the SMacro
+		   * that corresponds to that form of the macro call, and
+		   * substitute for the parameters when we expand. What a
+		   * pain.
+		   */
+		  tline = tline->next;
+		  skip_white_(tline);
+		  if (!tok_is_(tline, "(")) {
+		      /*
+		       * This macro wasn't called with parameters: ignore
+		       * the call. (Behaviour borrowed from gnu cpp.)
+		       */
+		      tline = mstart;
+		      m = NULL;
+		  } 
+		  else {
+		      int paren = 0;
+		      int white = 0;
+		      brackets = 0;
+		      nparam = 0;
+		      tline = tline->next;
+		      sparam = PARAM_DELTA;
+		      params = nasm_malloc (sparam*sizeof(Token *));
+		      params[0] = tline;
+		      paramsize = nasm_malloc (sparam*sizeof(int));
+		      paramsize[0] = 0;
+		      for (;;tline = tline->next) {    /* parameter loop */
+			  if (!tline) {
+			      error(ERR_NONFATAL,
+				    "macro call expects terminating `)'");
+			      break;
+			  }
+			  if (tline->type == TOK_WHITESPACE && brackets<=0) {
+			      if (paramsize[nparam])
+				  white++;
+			      else
+				  params[nparam] = tline->next;
+			      continue;    /* parameter loop */
+			  }
+			  if (tline->type == TOK_OTHER && tline->text[1]==0) {
+			      char ch = tline->text[0];
+			      if (ch == ',' && !paren && brackets<=0) {
+				  if (++nparam >= sparam) {
+				      sparam += PARAM_DELTA;
+				      params = nasm_realloc (params, 
+						     sparam*sizeof(Token *));
+				      paramsize = nasm_realloc (paramsize,
+						     sparam*sizeof(int));
+				  }
+				  params[nparam] = tline->next;
+				  paramsize[nparam] = 0;
+				  white = 0;
+				  continue; /* parameter loop */
+			      }
+			      if (ch == br0 && 
+				  (brackets>0 || (brackets==0 &&
+						  !paramsize[nparam])))
+			      {
+				  if (!(brackets++))
+				  {
+				      params[nparam] = tline->next;
+				      continue; /* parameter loop */
+				  }
+			      }
+			      if (ch == br2 && brackets>0)
+				  if (--brackets == 0) {
+				      brackets = -1;
+				      continue; /* parameter loop */
+				  }
+			      if (ch == '(' && !brackets)
+				  paren++;
+			      if (ch == ')' && brackets<=0)
+				  if (--paren < 0)
+				      break;
+			  }
+			  if (brackets<0) {
+			      brackets = 0;
+			      error (ERR_NONFATAL, "braces do not "
+				     "enclose all of macro parameter");
+			  }
+			  paramsize[nparam] += white+1;
+			  white = 0;
+		      } /* parameter loop */
+		      nparam++;
+		      while (m && (m->nparam != nparam ||
+				   mstrcmp(m->name, p, m->casesense)))
+			  m = m->next;
+		      if (!m)
+			  error (ERR_WARNING|ERR_WARN_MNP, 
+				 "macro `%s' exists, "
+				 "but not taking %d parameters",
+				 mstart->text, nparam);
+		  }
+	      }
+	      if (m && m->in_progress)
+		  m = NULL;
+	      if (!m) 	 /* in progess or didn't find '(' or wrong nparam */
+	      {
+                  /* 
+		   * Design question: should we handle !tline, which
+		   * indicates missing ')' here, or expand those
+		   * macros anyway, which requires the (t) test a few
+		   * lines down?  
+		   */
+		  nasm_free (params);
+		  nasm_free (paramsize);
+		  tline = mstart;
+	      } 
+	      else {
+		/*
+		 * Expand the macro: we are placed on the last token of the
+		 * call, so that we can easily split the call from the
+		 * following tokens. We also start by pushing an SMAC_END
+		 * token for the cycle removal.
+		 */
+		t = tline;
+		if (t) {
+		    tline = t->next;
+		    t->next = NULL;
 		}
-		params[nparam] = tline;
-		paramsize[nparam] = 0;
-		brackets = 0;
-		if (tline && tline->type == TOK_OTHER &&
-		    !strcmp(tline->text, "{")) {
-		    params[nparam] = tline = tline->next;
-		    while (tline && (brackets > 0 ||
-				     tline->type != TOK_OTHER ||
-				     strcmp(tline->text, "}"))) {
-			tline = tline->next;
-			paramsize[nparam]++;
-		    }
-		    tline = tline->next;
-		    if (tline && tline->type == TOK_WHITESPACE)
-			tline = tline->next;
-		    if (tline && (tline->type != TOK_OTHER ||
-				  (strcmp(tline->text, ")") &&
-				   strcmp(tline->text, ",")))) {
-			error (ERR_NONFATAL|ERR_OFFBY1, "braces do not "
-			       "enclose all of macro parameter");
-		    }
-		    if (tline && tline->type == TOK_OTHER &&
-			!strcmp(tline->text, ","))
-			tline = tline->next;
-		} else {
-		    while (tline && (brackets > 0 ||
-				     tline->type != TOK_OTHER ||
-				     (strcmp(tline->text, ",") &&
-				      strcmp(tline->text, ")")))) {
-			if (tline->type == TOK_OTHER && !tline->text[1])
-			    brackets += (tline->text[0] == '(' ? 1 :
-					 tline->text[0] == ')' ? -1 : 0);
-			tline = tline->next;
-			paramsize[nparam]++;
+		tt = nasm_malloc(sizeof(Token));
+		tt->type = TOK_SMAC_END;
+		tt->text = NULL;
+		tt->mac = m;
+		m->in_progress = TRUE;
+		tt->next = tline;
+		tline = tt;
+		for (t = m->expansion; t; t = t->next) {
+		    if (t->type >= TOK_SMAC_PARAM) {
+			Token *pcopy = tline, **ptail = &pcopy;
+			Token *ttt, *pt;
+			int i;
+			
+			ttt = params[t->type - TOK_SMAC_PARAM];
+			for (i=paramsize[t->type-TOK_SMAC_PARAM]; --i>=0;) {
+			    pt = *ptail = nasm_malloc(sizeof(Token));
+			    pt->next = tline;
+			    ptail = &pt->next;
+			    pt->text = nasm_strdup(ttt->text);
+			    pt->type = ttt->type;
+			    pt->mac = NULL;
+			    ttt = ttt->next;
+			}
+			tline = pcopy;
+		    } else {
+			tt = nasm_malloc(sizeof(Token));
+			tt->type = t->type;
+			tt->text = nasm_strdup(t->text);
+			tt->mac = NULL;
+			tt->next = tline;
+			tline = tt;
 		    }
 		}
-		nparam++;
-		if (tline && !strcmp(tline->text, ")"))
-		    break;
-		if (tline && !strcmp(tline->text, ","))
-		    tline = tline->next;
-	    }
-	    while (m && m->nparam != nparam) {
-		while ( (m = m->next) )
-		    if (!strcmp(m->name, mstart->text))
-			break;
-	    }
-	    if (!m) {
-		error (ERR_WARNING|ERR_OFFBY1|ERR_WARN_MNP,
-		       "macro `%s' exists, but not taking %d parameters",
-		       mstart->text, nparam);
+	
+		/*
+		 * Having done that, get rid of the macro call, and clean
+		 * up the parameters.
+		 */
 		nasm_free (params);
 		nasm_free (paramsize);
-		tline = mstart;
-		tline->type = TOK_PS_OTHER;
-		continue;
+		free_tlist (mstart);
+		continue;  /* main token loop */
+	      }
 	    }
 	}
-	/*
-	 * Expand the macro: we are placed on the last token of the
-	 * call, so that we can easily split the call from the
-	 * following tokens. We also start by pushing an SMAC_END
-	 * token for the cycle removal.
-	 */
-	t = tline;
-	tline = tline->next;
-	t->next = NULL;
-	tt = nasm_malloc(sizeof(Token));
-	tt->type = TOK_SMAC_END;
-	tt->text = NULL;
-	tt->mac = m;
-	m->in_progress = TRUE;
-	tt->next = tline;
-	tline = tt;
-	for (t = m->expansion; t; t = t->next) {
-	    if (t->type >= TOK_SMAC_PARAM) {
-		Token *pcopy = tline, **ptail = &pcopy;
-		Token *ttt, *pt;
-		int i;
-		
-		ttt = params[t->type - TOK_SMAC_PARAM];
-		for (i=0; i<paramsize[t->type-TOK_SMAC_PARAM]; i++) {
-		    pt = *ptail = nasm_malloc(sizeof(Token));
-		    pt->next = tline;
-		    ptail = &pt->next;
-		    pt->text = nasm_strdup(ttt->text);
-		    pt->type = ttt->type;
-		    pt->mac = NULL;
-		    ttt = ttt->next;
+
+	if (tline->type == TOK_SMAC_END) {
+	    tline->mac->in_progress = FALSE;
+	    t = tline;
+	    tline = tline->next;
+	    nasm_free (t);
+	} else {
+	    t = *tail = tline;
+	    tline = tline->next;
+	    t->mac = NULL;
+	    t->next = NULL;
+	    tail = &t->next;
+	    if (t->type == TOK_PREPROC_ID && t->text[1] == '$') {
+		Context *c = get_ctx (t->text);
+		char *p, *q, buffer[40];
+
+		t->type = TOK_ID;
+		if (c) {
+		    q = t->text+1;
+		    q += strspn(q, "$");
+		    sprintf(buffer, "..@%lu.", c->number);
+		    p = nasm_strcat (buffer,q);
+		    nasm_free (t->text);
+		    t->text = p;
 		}
-		tline = pcopy;
-	    } else {
-		tt = nasm_malloc(sizeof(Token));
-		tt->type = t->type;
-		tt->text = nasm_strdup(t->text);
-		tt->mac = NULL;
-		tt->next = tline;
-		tline = tt;
 	    }
 	}
-
-	/*
-	 * Having done that, get rid of the macro call, and clean
-	 * up the parameters.
-	 */
-	nasm_free (params);
-	nasm_free (paramsize);
-	free_tlist (mstart);
     }
 
     return thead;
@@ -2371,7 +2442,8 @@ static Token *expand_smacro (Token *tline) {
  * to be called with tline->type == TOK_ID, so the putative macro
  * name is easy to find.
  */
-static MMacro *is_mmacro (Token *tline, Token ***params_array) {
+static MMacro *is_mmacro (Token *tline, Token ***params_array) 
+{
     MMacro *head, *m;
     Token **params;
     int nparam;
@@ -2407,9 +2479,11 @@ static MMacro *is_mmacro (Token *tline, Token ***params_array) {
 	     * prohibits us using it before we actually celebrate...
 	     */
 	    if (m->in_progress) {
-		error (ERR_NONFATAL|ERR_OFFBY1,
+#if 0
+		error (ERR_NONFATAL,
 		       "self-reference in multi-line macro `%s'",
 		       m->name);
+#endif
 		nasm_free (params);
 		return NULL;
 	    }
@@ -2456,7 +2530,7 @@ static MMacro *is_mmacro (Token *tline, Token ***params_array) {
      * After all that, we didn't find one with the right number of
      * parameters. Issue a warning, and fail to expand the macro.
      */
-    error (ERR_WARNING|ERR_OFFBY1|ERR_WARN_MNP,
+    error (ERR_WARNING|ERR_WARN_MNP,
 	   "macro `%s' exists, but not taking %d parameters",
 	   tline->text, nparam);
     nasm_free (params);
@@ -2466,62 +2540,54 @@ static MMacro *is_mmacro (Token *tline, Token ***params_array) {
 /*
  * Expand the multi-line macro call made by the given line, if
  * there is one to be expanded. If there is, push the expansion on
- * istk->expansion and return 1 or 2, as according to whether a
- * line sync is needed (2 if it is). Otherwise return 0.
+ * istk->expansion and return 1. Otherwise return 0.
  */
-static int expand_mmacro (Token *tline) {
-    Token *label = NULL, **params, *t, *tt, *last = NULL;
-    MMacro *m = NULL;
+static int expand_mmacro (Token *tline) 
+{
+    Token *startline = tline;
+    Token *label = NULL;
+    int dont_prepend = 0;
+    Token **params, *t, *tt;
+    MMacro *m;
     Line *l, *ll;
     int i, nparam, *paramlen;
-    int need_sync = FALSE;
 
     t = tline;
-    if (t && t->type == TOK_WHITESPACE)
+    skip_white_(t);
+    if (!tok_type_(t, TOK_ID))
+	return 0;
+    m = is_mmacro (t, &params);
+    if (!m) {
+	Token *last;
+	/*
+	 * We have an id which isn't a macro call. We'll assume
+	 * it might be a label; we'll also check to see if a
+	 * colon follows it. Then, if there's another id after
+	 * that lot, we'll check it again for macro-hood.
+	 */
+	label = last = t;
 	t = t->next;
-    if (t && t->type == TOK_ID) {
-	m = is_mmacro (t, &params);
-	if (!m) {
-	    /*
-	     * We have an id which isn't a macro call. We'll assume
-	     * it might be a label; we'll also check to see if a
-	     * colon follows it. Then, if there's another id after
-	     * that lot, we'll check it again for macro-hood.
-	     */
+	if (tok_type_(t, TOK_WHITESPACE))
 	    last = t, t = t->next;
-	    if (t && t->type == TOK_WHITESPACE)
-		last = t, t = t->next;
-	    if (t && t->type == TOK_OTHER && !strcmp(t->text, ":"))
-		last = t, t = t->next;
-	    if (t && t->type == TOK_WHITESPACE)
+	if (tok_is_(t, ":")) {
+	    dont_prepend = 1;
+	    last = t, t = t->next;
+	    if (tok_type_(t, TOK_WHITESPACE))
 		last = t, t = t->next;
-	    if (t && t->type == TOK_ID) {
-		m = is_mmacro(t, &params);
-		if (m) {
-		    last->next = NULL;
-		    label = tline;
-		    tline = t;
-		}
-	    }
-	}	
+	}
+	if (!tok_type_(t, TOK_ID) || (m = is_mmacro(t, &params)) == NULL)
+	    return 0;
+	last->next = NULL;
+	tline = t;
     }
-    if (!m)
-	return 0;
-
-    /*
-     * If we're not already inside another macro expansion, we'd
-     * better push a line synchronisation to ensure we stay put on
-     * line numbering.
-     */
-    if (!istk->expansion)
-	need_sync = TRUE;
 
     /*
      * Fix up the parameters: this involves stripping leading and
      * trailing whitespace, then stripping braces if they are
      * present.
      */
-    for (nparam = 0; params[nparam]; nparam++);
+    for (nparam = 0; params[nparam]; nparam++)
+	;
     paramlen = nparam ? nasm_malloc(nparam*sizeof(*paramlen)) : NULL;
 
     for (i = 0; params[i]; i++) {
@@ -2529,19 +2595,15 @@ static int expand_mmacro (Token *tline) {
 	int comma = (!m->plus || i < nparam-1);
 
 	t = params[i];
-	if (t && t->type == TOK_WHITESPACE)
-	    t = t->next;
-	if (t && t->type == TOK_OTHER && !strcmp(t->text, "{"))
+	skip_white_(t);
+	if (tok_is_(t, "{"))
 	    t = t->next, brace = TRUE, comma = FALSE;
 	params[i] = t;
 	paramlen[i] = 0;
 	while (t) {
-	    if (!t)		       /* end of param because EOL */
-		break;
 	    if (comma && t->type == TOK_OTHER && !strcmp(t->text, ","))
 		break;		       /* ... because we have hit a comma */
-	    if (comma && t->type == TOK_WHITESPACE &&
-		t->next->type == TOK_OTHER && !strcmp(t->next->text, ","))
+	    if (comma && t->type == TOK_WHITESPACE && tok_is_(t->next, ","))
 		break;		       /* ... or a space then a comma */
 	    if (brace && t->type == TOK_OTHER && !strcmp(t->text, "}"))
 		break;		       /* ... or a brace */
@@ -2584,61 +2646,76 @@ static int expand_mmacro (Token *tline) {
 	Token **tail;
 
 	ll = nasm_malloc(sizeof(Line));
-	ll->next = istk->expansion;
 	ll->finishes = NULL;
-	ll->first = NULL;
+	ll->next = istk->expansion;
+	istk->expansion = ll;
 	tail = &ll->first;
 
 	for (t = l->first; t; t = t->next) {
+	    Token *x = t;
+	    if (t->type == TOK_PREPROC_ID && 
+		t->text[1]=='0' && t->text[2]=='0') 
+	    {
+		dont_prepend = -1;
+		x = label;
+		if (!x)
+		    continue;
+	    }
 	    tt = *tail = nasm_malloc(sizeof(Token));
-	    tt->next = NULL;
 	    tail = &tt->next;
-	    tt->type = t->type;
-	    tt->text = nasm_strdup(t->text);
+	    tt->type = x->type;
+	    tt->text = nasm_strdup(x->text);
 	    tt->mac = NULL;
 	}
-
-	istk->expansion = ll;
-
+	*tail = NULL;
     }
 
     /*
-     * If we had a label, push it on the front of the first line of
-     * the macro expansion. We must check that this doesn't give
-     * two consecutive TOK_WHITESPACE.
+     * If we had a label, push it on as the first line of
+     * the macro expansion.
      */
-    if (label) {
-	if (last->type == TOK_WHITESPACE &&
-	    istk->expansion->first->type == TOK_WHITESPACE) {
-	    Token *victim = istk->expansion->first; /* kill this whitespace */
-	    istk->expansion->first = victim->next;
-	    nasm_free (victim->text);
-	    nasm_free (victim);
-	}
-	last->next = istk->expansion->first;
-	istk->expansion->first = label;
-    }
+    if (label)
+	if (dont_prepend<0)
+	    free_tlist(startline);
+	else {
+	    ll = nasm_malloc(sizeof(Line));
+	    ll->finishes = NULL;
+	    ll->next = istk->expansion;
+	    istk->expansion = ll;
+	    ll->first = startline;
+	    if (!dont_prepend) {
+		while (label->next)
+		    label = label->next;
+		label->next = tt = nasm_malloc(sizeof(Token));
+		tt->next = NULL;
+		tt->mac = NULL;
+		tt->type = TOK_OTHER;
+		tt->text = nasm_strdup(":");
+	    }
+	}
 
     list->uplevel (m->nolist ? LIST_MACRO_NOLIST : LIST_MACRO);
 
-    return need_sync ? 2 : 1;
+    return 1;
 }
 
 static void pp_reset (char *file, int apass, efunc errfunc, evalfunc eval,
-		      ListGen *listgen) {
+		      ListGen *listgen) 
+{
     int h;
 
     error = errfunc;
     cstk = NULL;
-    linesync = outline = NULL;
     istk = nasm_malloc(sizeof(Include));
     istk->next = NULL;
     istk->conds = NULL;
     istk->expansion = NULL;
     istk->mstk = NULL;
     istk->fp = fopen(file, "r");
-    istk->fname = nasm_strdup(file);
-    istk->lineno = istk->lineinc = 1;
+    istk->fname = NULL;
+    src_set_fname(nasm_strdup(file));
+    src_set_linnum(0);
+    istk->lineinc = 1;
     if (!istk->fp)
 	error (ERR_FATAL|ERR_NOFILE, "unable to open input file `%s'", file);
     defining = NULL;
@@ -2654,17 +2731,12 @@ static void pp_reset (char *file, int apass, efunc errfunc, evalfunc eval,
     pass = apass;
 }
 
-static char *pp_getline (void) {
+static char *pp_getline (void) 
+{
     char *line;
     Token *tline;
     int ret;
 
-    if (outline) {
-	line = outline;
-	outline = NULL;
-	return line;
-    }
-
     while (1) {
 	/*
 	 * Fetch a tokenised line, either from the macro-expansion
@@ -2712,7 +2784,6 @@ static char *pp_getline (void) {
 
 		    istk->expansion = ll;
 		}
-		line_sync();
 	    } else {
 		/*
 		 * Check whether a `%rep' was started and not ended
@@ -2733,62 +2804,68 @@ static char *pp_getline (void) {
 			       " expansion of macro `%s'", istk->mstk->name);
 		}
 
-		if (istk->mstk->name) {
-		    /*
-		     * This was a real macro call, not a %rep, and
-		     * therefore the parameter information needs to
-		     * be freed.
-		     */
-		    nasm_free(istk->mstk->params);
-		    free_tlist(istk->mstk->iline);
-		    nasm_free(istk->mstk->paramlen);
+                /*
+		 * FIXME:  investigate the relationship at this point between
+		 * istk->mstk and l->finishes
+		 */
+		{
+		    MMacro *m = istk->mstk;
+		    istk->mstk = m->next_active;
+		    if (m->name) {
+			/*
+			 * This was a real macro call, not a %rep, and
+			 * therefore the parameter information needs to
+			 * be freed.
+			 */
+			nasm_free(m->params);
+			free_tlist(m->iline);
+			nasm_free(m->paramlen);
+			l->finishes->in_progress = FALSE;
+		    } 
+		    else
+			free_mmacro(m);
 		}
-		istk->mstk = istk->mstk->next_active;
-		l->finishes->in_progress = FALSE;
 		istk->expansion = l->next;
 		nasm_free (l);
 		list->downlevel (LIST_MACRO);
-		if (!istk->expansion)
-		    line_sync();
 	    }
 	}
-	if (istk->expansion) {
-	    char *p;
-	    Line *l = istk->expansion;
-	    tline = l->first;
-	    istk->expansion = l->next;
-	    nasm_free (l);
-	    p = detoken(tline);
-	    list->line (LIST_MACRO, p);
-	    nasm_free(p);
-	    if (!istk->expansion)
-		line_sync();
-	} else {
+	while (1) {  /* until we get a line we can use */
+
+	    if (istk->expansion) {   /* from a macro expansion */
+		char *p;
+		Line *l = istk->expansion;
+		tline = l->first;
+		istk->expansion = l->next;
+		nasm_free (l);
+		p = detoken(tline);
+		list->line (LIST_MACRO, p);
+		nasm_free(p);
+		break;
+	    }
 	    line = read_line();
-	    while (!line) {
-		/*
-		 * The current file has ended; work down the istk
-		 * until we find a file we can read from.
-		 */
-		Include *i;
-		fclose(istk->fp);
-		if (istk->conds)
+	    if (line) {    /* from the current input file */
+		line = prepreproc(line);
+		tline = tokenise(line);
+		nasm_free (line);
+		break;
+	    }
+	    /*
+	     * The current file has ended; work down the istk
+	     */
+	    {
+		Include *i = istk;
+		fclose(i->fp);
+		if (i->conds)
 		    error(ERR_FATAL, "expected `%%endif' before end of file");
-		i = istk;
-		istk = istk->next;
+		istk = i->next;
 		list->downlevel (LIST_INCLUDE);
-		nasm_free (i->fname);
+		src_set_linnum(i->lineno);
+		nasm_free ( src_set_fname(i->fname) );
 		nasm_free (i);
 		if (!istk)
 		    return NULL;
-		else
-		    line_sync();
-		update_fileline(3);    /* update __FILE__ and __LINE__ */
-		line = read_line();
 	    }
-	    line = prepreproc(line);
-	    tline = tokenise(line);
-	    nasm_free (line);
 	}
 
 	/*
@@ -2797,9 +2874,11 @@ static char *pp_getline (void) {
 	 * with things like `%define something %1' such as STRUC
 	 * uses. Unless we're _defining_ a MMacro, in which case
 	 * those tokens should be left alone to go into the
-	 * definition.
+	 * definition; and unless we're in a non-emitting
+	 * condition, in which case we don't want to meddle with
+	 * anything.
 	 */
-	if (!defining)
+	if (!defining && !(istk->conds && !emitting(istk->conds->state)))
 	    tline = expand_mmac_params(tline);
 
 	/*
@@ -2807,20 +2886,11 @@ static char *pp_getline (void) {
 	 */
 	ret = do_directive(tline);
 	if (ret & 1) {
-	    if (ret & 4)
-		line_sync();
-	    if ((ret & 2) && !stdmacpos) {/* give a blank line to the output */
-		outline = nasm_strdup("");
-		break;
-	    }
-	    else
 		continue;
 	} else if (defining) {
 	    /*
 	     * We're defining a multi-line macro. We emit nothing
-	     * at all, not even a blank line (when we finish
-	     * defining the macro, we'll emit a line-number
-	     * directive so that we keep sync properly), and just
+	     * at all, and just
 	     * shove the tokenised line on to the macro definition.
 	     */
 	    Line *l = nasm_malloc(sizeof(Line));
@@ -2858,54 +2928,32 @@ static char *pp_getline (void) {
 		 */
 		line = detoken(tline);
 		free_tlist (tline);
-		outline = line;
 		break;
 	    } else {
-		if (ret == 2)
-		    line_sync();
 		continue;	       /* expand_mmacro calls free_tlist */
 	    }
 	}
     }
 
-    /*
-     * Once we're out of this loop, outline _must_ be non-NULL. The
-     * only question is whether linesync is NULL or not.
-     */
-    if (linesync) {
-	line = linesync;
-	linesync = NULL;
-    } else {
-	line = outline;
-	outline = NULL;
-    }
     return line;
 }
 
-static void pp_cleanup (void) {
+static void pp_cleanup (void) 
+{
     int h;
 
     if (defining) {
 	error (ERR_NONFATAL, "end of file while still defining macro `%s'",
 	       defining->name);
-	nasm_free (defining->name);
-	free_tlist (defining->dlist);
-	free_llist (defining->expansion);
-	nasm_free (defining);
+	free_mmacro (defining);
     }
-    nasm_free (linesync);	       /* might just be necessary */
-    nasm_free (outline);	       /* really shouldn't be necessary */
     while (cstk)
 	ctx_pop();
     for (h=0; h<NHASH; h++) {
 	while (mmacros[h]) {
 	    MMacro *m = mmacros[h];
 	    mmacros[h] = mmacros[h]->next;
-	    nasm_free (m->name);
-	    free_tlist (m->dlist);
-	    nasm_free (m->defaults);
-	    free_llist (m->expansion);
-	    nasm_free (m);
+	    free_mmacro(m);
 	}
 	while (smacros[h]) {
 	    SMacro *s = smacros[h];
@@ -2926,7 +2974,8 @@ static void pp_cleanup (void) {
 	ctx_pop();
 }
 
-void pp_include_path (char *path) {
+void pp_include_path (char *path) 
+{
     IncPath *i;
 
     i = nasm_malloc(sizeof(IncPath));
@@ -2936,7 +2985,8 @@ void pp_include_path (char *path) {
     ipath = i;
 }
 
-void pp_pre_include (char *fname) {
+void pp_pre_include (char *fname) 
+{
     Token *inc, *space, *name;
     Line *l;
 
@@ -2961,8 +3011,9 @@ void pp_pre_include (char *fname) {
     predef = l;
 }
 
-void pp_pre_define (char *definition) {
-    Token *def, *space, *name;
+void pp_pre_define (char *definition) 
+{
+    Token *def, *space;
     Line *l;
     char *equals;
 
@@ -2972,7 +3023,7 @@ void pp_pre_define (char *definition) {
     def->next = space = nasm_malloc(sizeof(Token));
     if (equals)
 	*equals = ' ';
-    space->next = name = tokenise(definition);
+    space->next = tokenise(definition);
     if (equals)
 	*equals = '=';
 
@@ -2990,10 +3041,19 @@ void pp_pre_define (char *definition) {
     predef = l;
 }
 
-void pp_extra_stdmac (char **macros) {
+void pp_extra_stdmac (char **macros) 
+{
     extrastdmac = macros;
 }
 
+static void make_tok_num(Token *tok, long val)	
+{
+    char numbuf[20];
+    sprintf(numbuf, "%ld", val);
+    tok->text = nasm_strdup(numbuf);
+    tok->type = TOK_NUMBER;
+}
+
 Preproc nasmpp = {
     pp_reset,
     pp_getline,