Update our yasm copy to yasm 1.1.0 (Part 1: yasm side)...

third_party/yasm/patched-yasm/modules/preprocs/nasm/nasm-pp.c

 /* -*- mode: c; c-file-style: "bsd" -*- */
 /* preproc.c   macro preprocessor 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 18/iii/97 by Simon Tatham
  */
@@ skipping 45 matching lines @@
 typedef struct Include Include;
 typedef struct Cond Cond;
 
 /*
  * Store the definition of a single-line macro.
  */
 struct SMacro
 {
     SMacro *next;
     char *name;
+    int level;
     int casesense;
     int nparam;
     int in_progress;
     Token *expansion;
 };
 
 /*
  * Store the definition of a multi-line macro. This is also used to
  * store the interiors of `%rep...%endrep' blocks, which are
  * effectively self-re-invoking multi-line macros which simply
@@ skipping 193 matching lines @@
 
 /*
  * Directive names.
  */
 static const char *directives[] = {
     "%arg",
     "%assign", "%clear", "%define", "%elif", "%elifctx", "%elifdef",
     "%elifid", "%elifidn", "%elifidni", "%elifmacro", "%elifnctx", "%elifndef",
     "%elifnid", "%elifnidn", "%elifnidni", "%elifnmacro", "%elifnnum", "%elifnstr",
     "%elifnum", "%elifstr", "%else", "%endif", "%endm", "%endmacro",
-    "%endrep", "%error", "%exitrep", "%iassign", "%idefine", "%if",
+    "%endrep", "%endscope", "%error", "%exitrep", "%iassign", "%idefine", "%if",
     "%ifctx", "%ifdef", "%ifid", "%ifidn", "%ifidni", "%ifmacro", "%ifnctx",
     "%ifndef", "%ifnid", "%ifnidn", "%ifnidni", "%ifnmacro", "%ifnnum",
     "%ifnstr", "%ifnum", "%ifstr", "%imacro", "%include",
     "%ixdefine", "%line",
     "%local",
     "%macro", "%pop", "%push", "%rep", "%repl", "%rotate",
-    "%stacksize",
+    "%scope", "%stacksize",
     "%strlen", "%substr", "%undef", "%xdefine"
 };
 enum
 {
     PP_ARG,
     PP_ASSIGN, PP_CLEAR, PP_DEFINE, PP_ELIF, PP_ELIFCTX, PP_ELIFDEF,
     PP_ELIFID, PP_ELIFIDN, PP_ELIFIDNI, PP_ELIFMACRO, PP_ELIFNCTX, PP_ELIFNDEF,
     PP_ELIFNID, PP_ELIFNIDN, PP_ELIFNIDNI, PP_ELIFNMACRO, PP_ELIFNNUM, PP_ELIFNSTR,
     PP_ELIFNUM, PP_ELIFSTR, PP_ELSE, PP_ENDIF, PP_ENDM, PP_ENDMACRO,
-    PP_ENDREP, PP_ERROR, PP_EXITREP, PP_IASSIGN, PP_IDEFINE, PP_IF,
+    PP_ENDREP, PP_ENDSCOPE, PP_ERROR, PP_EXITREP, PP_IASSIGN, PP_IDEFINE, PP_IF,
     PP_IFCTX, PP_IFDEF, PP_IFID, PP_IFIDN, PP_IFIDNI, PP_IFMACRO, PP_IFNCTX,
     PP_IFNDEF, PP_IFNID, PP_IFNIDN, PP_IFNIDNI, PP_IFNMACRO, PP_IFNNUM,
     PP_IFNSTR, PP_IFNUM, PP_IFSTR, PP_IMACRO, PP_INCLUDE,
     PP_IXDEFINE, PP_LINE,
     PP_LOCAL,
     PP_MACRO, PP_POP, PP_PUSH, PP_REP, PP_REPL, PP_ROTATE,
-    PP_STACKSIZE,
+    PP_SCOPE, PP_STACKSIZE,
     PP_STRLEN, PP_SUBSTR, PP_UNDEF, PP_XDEFINE
 };
 
 /* If this is a an IF, ELIF, ELSE or ENDIF keyword */
 static int is_condition(int arg)
 {
     return ((arg >= PP_ELIF) && (arg <= PP_ENDIF)) ||
         ((arg >= PP_IF) && (arg <= PP_IFSTR));
 }
 
@@ skipping 17 matching lines @@
 
 static const char *tasm_directives[] = {
     "arg", "elif", "else", "endif", "if", "ifdef", "ifdifi",
     "ifndef", "include", "local"
 };
 
 static int StackSize = 4;
 static const char *StackPointer = "ebp";
 static int ArgOffset = 8;
 static int LocalOffset = 4;
+static int Level = 0;
 
 
 static Context *cstk;
 static Include *istk;
 
 static FILE *first_fp = NULL;
 
 static efunc _error;            /* Pointer to client-provided error reporting function */
 static evalfunc evaluate;
 
@@ skipping 180 matching lines @@
 }
 
 static char *
 check_tasm_directive(char *line)
 {
     int i, j, k, m;
     size_t len, len2;
     char *p, *oldline, oldchar, *q, oldchar2;
     TMEndItem *end;
 
-    if ((p = strchr(line, ';')))
-        *p = '\0';
-
     p = line;
 
     /* Skip whitespace */
-    while (isspace(*p) && *p != 0)
+    while (isspace(*p) && *p != 0 && *p != ';')
         p++;
 
     /* Ignore nasm directives */
     if (*p == '%')
         return line;
 
     /* Binary search for the directive name */
     len = 0;
-    while (!isspace(p[len]) && p[len] != 0)
+    while (!isspace(p[len]) && p[len] != 0 && p[len] != ';')
         len++;
     if (!len)
         return line;
 
     oldchar = p[len];
     p[len] = 0;
     i = -1;
     j = elements(tasm_directives);
     while (j - i > 1)
     {
@@ skipping 297 matching lines @@
         /* handle ASSUME */
         if (!TAssumes) {
             TAssumes = nasm_malloc(sizeof(*TAssumes));
             TAssumes[0].segreg = NULL;
         }
         i = 0;
         q[len2] = oldchar2;
         /* Skip whitespaces */
         while (isspace(*q) && *q)
             q++;
-        while (*q) {
+        while (*q && *q != ';') {
             p = q;
-            for (; *q && *q != ':' && !isspace(*q); q++);
-            if (!*q)
+            for (; *q && *q != ';' && *q != ':' && !isspace(*q); q++);
+            if (!*q || *q == ';')
                 break;
             /* segment register name */
             for (assume = TAssumes; assume->segreg; assume++)
                 if (strlen(assume->segreg) == (size_t)(q-p) &&
                     !yasm__strncasecmp(assume->segreg, p, q-p))
                     break;
             if (!assume->segreg) {
                 i = assume - TAssumes + 1;
                 TAssumes = nasm_realloc(TAssumes, (i+1)*sizeof(*TAssumes));
                 assume = TAssumes + i - 1;
                 assume->segreg = nasm_strndup(p, q-p);
                 assume[1].segreg = NULL;
             }
-            for (; *q && *q != ':' && isspace(*q); q++);
+            for (; *q && *q != ';' && *q != ':' && isspace(*q); q++);
             if (*q != ':')
                 error(ERR_FATAL, "expected `:' instead of `%c'", *q);
             for (q++; *q && isspace(*q); q++);
 
             /* segment name */
             p = q;
-            for (; *q && *q != ',' && !isspace(*q); q++);
+            for (; *q && *q != ';' && *q != ',' && !isspace(*q); q++);
             assume->segment = nasm_strndup(p, q-p);
             for (; *q && isspace(*q); q++);
-            if (*q && *q != ',')
+            if (*q && *q != ';' && *q != ',')
                 error(ERR_FATAL, "expected `,' instead of `%c'", *q);
         
-            for (q++; *q && isspace(*q); q++);
+            if (*q && *q != ';')
+                q++;
+            for (; *q && isspace(*q); q++);
         }
         TAssumes[i].segreg = NULL;
         TAssumes = nasm_realloc(TAssumes, (i+1)*sizeof(*TAssumes));
         nasm_free(line);
         return nasm_strdup("");
     } else if (inTstruc) {
         struct TStrucField *field;
         /* TODO: handle unnamed data */
         field = nasm_malloc(sizeof(*field));
         field->name = nasm_strdup(p);
@@ skipping 972 matching lines @@
  * If you already know which context macro belongs to, you can pass
  * the context pointer as first parameter; if you won't but name begins
  * with %$ the context will be automatically computed. If all_contexts
  * is true, macro will be searched in outer contexts as well.
  */
 static int
 smacro_defined(Context * ctx, char *name, int nparam, SMacro ** defn,
         int nocase)
 {
     SMacro *m;
+    int highest_level = -1;
 
     if (ctx)
         m = ctx->localmac;
     else if (name[0] == '%' && name[1] == '$')
     {
         if (cstk)
             ctx = get_ctx(name, FALSE);
         if (!ctx)
             return FALSE;       /* got to return _something_ */
         m = ctx->localmac;
     }
     else
         m = smacros[hash(name)];
 
     while (m)
     {
         if (!mstrcmp(m->name, name, m->casesense && nocase) &&
-                (nparam <= 0 || m->nparam == 0 || nparam == m->nparam))
+                (nparam <= 0 || m->nparam == 0 || nparam == m->nparam) && (highest_level < 0 || m->level > highest_level))
         {
+            highest_level = m->level;
             if (defn)
             {
                 if (nparam == m->nparam || nparam == -1)
                     *defn = m;
                 else
                     *defn = NULL;
             }
-            return TRUE;
         }
         m = m->next;
     }
 
-    return FALSE;
+    return highest_level >= 0;
 }
 
 /*
  * 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)
@@ skipping 845 matching lines @@
             if (tline->next)
                 error(ERR_WARNING, "trailing garbage after `%%pop' ignored");
             if (!cstk)
                 error(ERR_NONFATAL,
                         "`%%pop': context stack is already empty");
             else
                 ctx_pop();
             free_tlist(origline);
             break;
 
+        case PP_SCOPE:
+            if (tline->next)
+                error(ERR_WARNING, "trailing garbage after `%%scope' ignored");
+            Level++;
+            free_tlist(origline);
+            break;
+
+        case PP_ENDSCOPE:
+            if (tline->next)
+                error(ERR_WARNING, "trailing garbage after `%%endscope' ignored");
+            if (!Level)
+                error(ERR_NONFATAL,
+                        "`%%endscope': already popped all levels");
+            else
+            {
+                for (k = 0; k < NHASH; k++)
+                {
+                    SMacro **smlast = &smacros[k];
+                    smac = smacros[k];
+                    while (smac)
+                    {
+                        if (smac->level < Level)
+                        {
+                            smlast = &smac->next;
+                            smac = smac->next;
+                        }
+                        else
+                        {
+                            *smlast = smac->next;
+                            nasm_free(smac->name);
+                            free_tlist(smac->expansion);
+                            nasm_free(smac);
+                            smac = *smlast;
+                        }
+                    }
+                }
+                for (ctx = cstk; ctx; ctx = ctx->next)
+                {
+                    SMacro **smlast = &ctx->localmac;
+                    smac = ctx->localmac;
+                    while (smac)
+                    {
+                        if (smac->level < Level)
+                        {
+                            smlast = &smac->next;
+                            smac = smac->next;
+                        }
+                        else
+                        {
+                            *smlast = smac->next;
+                            nasm_free(smac->name);
+                            free_tlist(smac->expansion);
+                            nasm_free(smac);
+                            smac = *smlast;
+                        }
+                    }
+                }
+                Level--;
+            }
+            free_tlist(origline);
+            break;
+
         case PP_ERROR:
             tline->next = expand_smacro(tline->next);
             tline = tline->next;
             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 */
                 expand_macros_in_string(&p);
                 error(ERR_NONFATAL, "%s", p);
@@ skipping 504 matching lines @@
             {
                 if (!smac)
                 {
                     error(ERR_WARNING,
                             "single-line macro `%s' defined both with and"
                             " without parameters", mname);
                     free_tlist(origline);
                     free_tlist(macro_start);
                     return DIRECTIVE_FOUND;
                 }
-                else
+                else if (smac->level == Level)
                 {
                     /*
-                     * We're redefining, so we have to take over an
-                     * existing SMacro structure. This means freeing
-                     * what was already in it.
+                     * We're redefining in the same level, so we have to 
+                     * take over an existing SMacro structure. This means 
+                     * freeing what was already in it.
                      */
                     nasm_free(smac->name);
                     free_tlist(smac->expansion);
                 }
+                else
+                {
+                    smac = nasm_malloc(sizeof(SMacro));
+                    smac->next = *smhead;
+                    *smhead = smac;
+                }
             }
             else
             {
                 smac = nasm_malloc(sizeof(SMacro));
                 smac->next = *smhead;
                 *smhead = smac;
             }
             smac->name = nasm_strdup(mname);
             smac->casesense = ((i == PP_DEFINE) || (i == PP_XDEFINE));
             smac->nparam = nparam;
+            smac->level = Level;
             smac->expansion = macro_start;
             smac->in_progress = FALSE;
             free_tlist(origline);
             return DIRECTIVE_FOUND;
 
         case PP_UNDEF:
             tline = tline->next;
             skip_white_(tline);
             tline = expand_id(tline);
             if (!tline || (tline->type != TOK_ID &&
@@ skipping 104 matching lines @@
             }
             else
             {
                 smac = nasm_malloc(sizeof(SMacro));
                 smac->next = *smhead;
                 *smhead = smac;
             }
             smac->name = nasm_strdup(mname);
             smac->casesense = (i == PP_STRLEN);
             smac->nparam = 0;
+            smac->level = 0;
             smac->expansion = macro_start;
             smac->in_progress = FALSE;
             free_tlist(tline);
             free_tlist(origline);
             return DIRECTIVE_FOUND;
 
         case PP_SUBSTR:
             tline = tline->next;
             skip_white_(tline);
             tline = expand_id(tline);
@@ skipping 90 matching lines @@
             }
             else
             {
                 smac = nasm_malloc(sizeof(SMacro));
                 smac->next = *smhead;
                 *smhead = smac;
             }
             smac->name = nasm_strdup(mname);
             smac->casesense = (i == PP_SUBSTR);
             smac->nparam = 0;
+            smac->level = 0;
             smac->expansion = macro_start;
             smac->in_progress = FALSE;
             free_tlist(tline);
             free_tlist(origline);
             return DIRECTIVE_FOUND;
 
 
         case PP_ASSIGN:
         case PP_IASSIGN:
             tline = tline->next;
@@ skipping 75 matching lines @@
             }
             else
             {
                 smac = nasm_malloc(sizeof(SMacro));
                 smac->next = *smhead;
                 *smhead = smac;
             }
             smac->name = nasm_strdup(mname);
             smac->casesense = (i == PP_ASSIGN);
             smac->nparam = 0;
+            smac->level = 0;
             smac->expansion = macro_start;
             smac->in_progress = FALSE;
             free_tlist(origline);
             return DIRECTIVE_FOUND;
 
         case PP_LINE:
             /*
              * Syntax is `%line nnn[+mmm] [filename]'
              */
             tline = tline->next;
@@ skipping 100 matching lines @@
     while (tline)
     {
         if (tline->type == TOK_PREPROC_ID &&
                 (((tline->text[1] == '+' || tline->text[1] == '-')
                                 && tline->text[2]) || tline->text[1] == '%'
                         || (tline->text[1] >= '0' && tline->text[1] <= '9')))
         {
             char *text = NULL;
             int type = 0, cc;   /* type = 0 to placate optimisers */
             char tmpbuf[30];
+            char *second_text = NULL;
             int n, i;
             MMacro *mac;
 
             t = tline;
             tline = tline->next;
 
+            second_text = strchr(t->text, ':');
+
             mac = istk->mstk;
             while (mac && !mac->name)   /* avoid mistaking %reps for macros */
                 mac = mac->next_active;
             if (!mac)
                 error(ERR_NONFATAL, "`%s': not in a macro call", t->text);
             else
-                switch (t->text[1])
+            {
+                if (second_text)
                 {
-                        /*
-                         * We have to make a substitution of one of the
-                         * forms %1, %-1, %+1, %%foo, %0.
-                         */
-                    case '0':
-                        type = TOK_NUMBER;
-                        sprintf(tmpbuf, "%ld", mac->nparam);
-                        text = nasm_strdup(tmpbuf);
-                        break;
-                    case '%':
-                        type = TOK_ID;
-                        sprintf(tmpbuf, "..@%lu.", mac->unique);
-                        text = nasm_strcat(tmpbuf, t->text + 2);
-                        break;
-                    case '-':
-                        n = atoi(t->text + 2) - 1;
-                        if (n >= mac->nparam)
+                    int end = atoi(second_text+1)-1;
+                    int is_fst = 1;
+                    int k;
+                    n = atoi(t->text + 1)-1;
+                    if (end < 0)
+                        end += mac->nparam;
+
+                    for (k = n; k <= end; k++)
+                    {
+                        if (k >= mac->nparam)
                             tt = NULL;
                         else
                         {
                             if (mac->nparam > 1)
-                                n = (n + mac->rotate) % mac->nparam;
-                            tt = mac->params[n];
-                        }
-                        cc = find_cc(tt);
-                        if (cc == -1)
-                        {
-                            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,
-                                        "condition code `%s' is not invertible",
-                                        conditions[cc]);
-                                text = NULL;
-                            }
-                            else
-                                text =
-                                        nasm_strdup(conditions[inverse_ccs
-                                                 [cc]]);
-                        }
-                        break;
-                    case '+':
-                        n = atoi(t->text + 2) - 1;
-                        if (n >= mac->nparam)
-                            tt = NULL;
-                        else
-                        {
-                            if (mac->nparam > 1)
-                                n = (n + mac->rotate) % mac->nparam;
-                            tt = mac->params[n];
-                        }
-                        cc = find_cc(tt);
-                        if (cc == -1)
-                        {
-                            error(ERR_NONFATAL,
-                                    "macro parameter %d is not a condition code",
-                                    n + 1);
-                            text = NULL;
-                        }
-                        else
-                        {
-                            type = TOK_ID;
-                            text = nasm_strdup(conditions[cc]);
-                        }
-                        break;
-                    default:
-                        n = atoi(t->text + 1) - 1;
-                        if (n >= mac->nparam)
-                            tt = NULL;
-                        else
-                        {
-                            if (mac->nparam > 1)
-                                n = (n + mac->rotate) % mac->nparam;
-                            tt = mac->params[n];
+                                k = (k + mac->rotate) % mac->nparam;
+                            tt = mac->params[k];
                         }
                         if (tt)
                         {
-                            for (i = 0; i < mac->paramlen[n]; i++)
+                            if (!is_fst && mac->paramlen[k])
+                            {
+                                *tail = new_Token(NULL, TOK_OTHER, ",", 0);
+                                tail = &(*tail)->next;
+                            }
+                            if (mac->paramlen[k])
+                                is_fst = 0;
+                            for (i = 0; i < mac->paramlen[k]; i++)
                             {
                                 *tail =
                                         new_Token(NULL, tt->type, tt->text,
                                         0);
                                 tail = &(*tail)->next;
                                 tt = tt->next;
                             }
                         }
                         text = NULL;    /* we've done it here */
-                        break;
+                    }
                 }
+                else
+                {
+                    switch (t->text[1])
+                    {
+                            /*
+                             * We have to make a substitution of one of the
+                             * forms %1, %-1, %+1, %%foo, %0.
+                             */
+                        case '0':
+                            type = TOK_NUMBER;
+                            sprintf(tmpbuf, "%ld", mac->nparam);
+                            text = nasm_strdup(tmpbuf);
+                            break;
+                        case '%':
+                            type = TOK_ID;
+                            sprintf(tmpbuf, "..@%lu.", mac->unique);
+                            text = nasm_strcat(tmpbuf, t->text + 2);
+                            break;
+                        case '-':
+                            n = atoi(t->text + 2) - 1;
+                            if (n >= mac->nparam)
+                                tt = NULL;
+                            else
+                            {
+                                if (mac->nparam > 1)
+                                    n = (n + mac->rotate) % mac->nparam;
+                                tt = mac->params[n];
+                            }
+                            cc = find_cc(tt);
+                            if (cc == -1)
+                            {
+                                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,
+                                            "condition code `%s' is not invertible",
+                                            conditions[cc]);
+                                    text = NULL;
+                                }
+                                else
+                                    text =
+                                            nasm_strdup(conditions[inverse_ccs
+                                                     [cc]]);
+                            }
+                            break;
+                        case '+':
+                            n = atoi(t->text + 2) - 1;
+                            if (n >= mac->nparam)
+                                tt = NULL;
+                            else
+                            {
+                                if (mac->nparam > 1)
+                                    n = (n + mac->rotate) % mac->nparam;
+                                tt = mac->params[n];
+                            }
+                            cc = find_cc(tt);
+                            if (cc == -1)
+                            {
+                                error(ERR_NONFATAL,
+                                        "macro parameter %d is not a condition code",
+                                        n + 1);
+                                text = NULL;
+                            }
+                            else
+                            {
+                                type = TOK_ID;
+                                text = nasm_strdup(conditions[cc]);
+                            }
+                            break;
+                        default:
+                            n = atoi(t->text + 1) - 1;
+                            if (n >= mac->nparam)
+                                tt = NULL;
+                            else
+                            {
+                                if (mac->nparam > 1)
+                                    n = (n + mac->rotate) % mac->nparam;
+                                tt = mac->params[n];
+                            }
+                            if (tt)
+                            {
+                                for (i = 0; i < mac->paramlen[n]; i++)
+                                {
+                                    *tail =
+                                            new_Token(NULL, tt->type, tt->text,
+                                            0);
+                                    tail = &(*tail)->next;
+                                    tt = tt->next;
+                                }
+                            }
+                            text = NULL;    /* we've done it here */
+                            break;
+                    }
+                }
+            }
+
             if (!text)
             {
                 delete_Token(t);
             }
             else
             {
                 *tail = t;
                 tail = &t->next;
                 t->type = type;
                 nasm_free(t->text);
@@ skipping 760 matching lines @@
             }
         }
     }
 
     list->uplevel(m->nolist ? LIST_MACRO_NOLIST : LIST_MACRO);
 
     return 1;
 }
 
 /*
- * Since preprocessor always operate only on the line that didn't
- * arrived yet, we should always use ERR_OFFBY1. Also since user
+ * Since preprocessor always operates only on the line that didn't
+ * arrive yet, we should always use ERR_OFFBY1. Also since user
  * won't want to see same error twice (preprocessing is done once
  * per pass) we will want to show errors only during pass one.
  */
 static void
 error(int severity, const char *fmt, ...)
 {
     va_list arg;
     char buff[1024];
 
     /* If we're in a dead branch of IF or something like it, ignore the error */
     if (istk && istk->conds && !emitting(istk->conds->state))
         return;
 
     va_start(arg, fmt);
+#ifdef HAVE_VSNPRINTF
+    vsnprintf(buff, sizeof(buff), fmt, arg);
+#else
     vsprintf(buff, fmt, arg);
+#endif
     va_end(arg);
 
     if (istk && istk->mstk && istk->mstk->name)
         _error(severity | ERR_PASS1, "(%s:%d) %s", istk->mstk->name,
                 istk->mstk->lineno, buff);
     else 
         _error(severity | ERR_PASS1, "%s", buff);
 }
 
 static void
@@ skipping 351 matching lines @@
         nasm_free(i->fname);
         nasm_free(i);
     }
     while (cstk)
         ctx_pop();
     if (pass_ == 0)
         {
                 free_llist(builtindef);
                 free_llist(stddef);
                 free_llist(predef);
+                builtindef = NULL;
+                stddef = NULL;
+                predef = NULL;
+                freeTokens = NULL;
                 delete_Blocks();
+                blocks.next = NULL;
+                blocks.chunk = NULL;
         }
 }
 
 void
 pp_pre_include(const char *fname)
 {
     Token *inc, *space, *name;
     Line *l;
 
     name = new_Token(NULL, TOK_INTERNAL_STRING, fname, 0);
@@ skipping 98 matching lines @@
 {
     tok->text = yasm_intnum_get_str(val);
     tok->type = TOK_NUMBER;
 }
 
 Preproc nasmpp = {
     pp_reset,
     pp_getline,
     pp_cleanup
 };