Upstream version 2.08rc7

1 files changed, 387 insertions, 0 deletions

diff --git a/listing.c b/listing.c
new file mode 100644
index 0000000..5a09440
--- /dev/null
+++ b/listing.c
@@ -0,0 +1,387 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *   Copyright 1996-2009 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *     
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * listing.c    listing file generator for the Netwide Assembler
+ */
+
+#include "compiler.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <string.h>
+#include <ctype.h>
+#include <inttypes.h>
+
+#include "nasm.h"
+#include "nasmlib.h"
+#include "listing.h"
+
+#define LIST_MAX_LEN 216        /* something sensible */
+#define LIST_INDENT  40
+#define LIST_HEXBIT  18
+
+typedef struct MacroInhibit MacroInhibit;
+
+static struct MacroInhibit {
+    MacroInhibit *next;
+    int level;
+    int inhibiting;
+} *mistack;
+
+static char xdigit[] = "0123456789ABCDEF";
+
+#define HEX(a,b) (*(a)=xdigit[((b)>>4)&15],(a)[1]=xdigit[(b)&15]);
+
+static char listline[LIST_MAX_LEN];
+static bool listlinep;
+
+static char listerror[LIST_MAX_LEN];
+
+static char listdata[2 * LIST_INDENT];  /* we need less than that actually */
+static int32_t listoffset;
+
+static int32_t listlineno;
+
+static int32_t listp;
+
+static int suppress;            /* for INCBIN & TIMES special cases */
+
+static int listlevel, listlevel_e;
+
+static FILE *listfp;
+
+static void list_emit(void)
+{
+    int i;
+
+    if (!listlinep && !listdata[0])
+        return;
+
+    fprintf(listfp, "%6"PRId32" ", ++listlineno);
+
+    if (listdata[0])
+        fprintf(listfp, "%08"PRIX32" %-*s", listoffset, LIST_HEXBIT + 1,
+                listdata);
+    else
+        fprintf(listfp, "%*s", LIST_HEXBIT + 10, "");
+
+    if (listlevel_e)
+        fprintf(listfp, "%s<%d>", (listlevel < 10 ? " " : ""),
+                listlevel_e);
+    else if (listlinep)
+        fprintf(listfp, "    ");
+
+    if (listlinep)
+        fprintf(listfp, " %s", listline);
+
+    putc('\n', listfp);
+    listlinep = false;
+    listdata[0] = '\0';
+
+    if (listerror[0]) {
+	fprintf(listfp, "%6"PRId32"          ", ++listlineno);
+	for (i = 0; i < LIST_HEXBIT; i++)
+	    putc('*', listfp);
+	
+	if (listlevel_e)
+	    fprintf(listfp, " %s<%d>", (listlevel < 10 ? " " : ""),
+		    listlevel_e);
+	else
+	    fprintf(listfp, "     ");
+
+	fprintf(listfp, "  %s\n", listerror);
+	listerror[0] = '\0';
+    }
+}
+
+static void list_init(char *fname, efunc error)
+{
+    listfp = fopen(fname, "w");
+    if (!listfp) {
+        error(ERR_NONFATAL, "unable to open listing file `%s'",
+	      fname);
+        return;
+    }
+
+    *listline = '\0';
+    listlineno = 0;
+    *listerror = '\0';
+    listp = true;
+    listlevel = 0;
+    suppress = 0;
+    mistack = nasm_malloc(sizeof(MacroInhibit));
+    mistack->next = NULL;
+    mistack->level = 0;
+    mistack->inhibiting = true;
+}
+
+static void list_cleanup(void)
+{
+    if (!listp)
+        return;
+
+    while (mistack) {
+        MacroInhibit *temp = mistack;
+        mistack = temp->next;
+        nasm_free(temp);
+    }
+
+    list_emit();
+    fclose(listfp);
+}
+
+static void list_out(int32_t offset, char *str)
+{
+    if (strlen(listdata) + strlen(str) > LIST_HEXBIT) {
+        strcat(listdata, "-");
+        list_emit();
+    }
+    if (!listdata[0])
+        listoffset = offset;
+    strcat(listdata, str);
+}
+
+static void list_output(int32_t offset, const void *data,
+			enum out_type type, uint64_t size)
+{
+    if (!listp || suppress || user_nolist)      /* fbk - 9/2/00 */
+        return;
+
+    switch (type) {
+    case OUT_RAWDATA:
+    {
+        uint8_t const *p = data;
+        char q[3];
+	if (size == 0 && !listdata[0])
+	    listoffset = offset;
+        while (size--) {
+            HEX(q, *p);
+            q[2] = '\0';
+            list_out(offset++, q);
+            p++;
+        }
+	break;
+    }
+    case OUT_ADDRESS:
+    {
+        uint64_t d = *(int64_t *)data;
+        char q[20];
+        uint8_t p[8], *r = p;
+        if (size == 4) {
+            q[0] = '[';
+            q[9] = ']';
+            q[10] = '\0';
+            WRITELONG(r, d);
+            HEX(q + 1, p[0]);
+            HEX(q + 3, p[1]);
+            HEX(q + 5, p[2]);
+            HEX(q + 7, p[3]);
+            list_out(offset, q);
+        } else if (size == 8) {
+            q[0] = '[';
+            q[17] = ']';
+            q[18] = '\0';
+            WRITEDLONG(r, d);
+            HEX(q + 1,  p[0]);
+            HEX(q + 3,  p[1]);
+            HEX(q + 5,  p[2]);
+            HEX(q + 7,  p[3]);
+            HEX(q + 9,  p[4]);
+            HEX(q + 11, p[5]);
+            HEX(q + 13, p[6]);
+            HEX(q + 15, p[7]);
+            list_out(offset, q);
+        } else {
+            q[0] = '[';
+            q[5] = ']';
+            q[6] = '\0';
+            WRITESHORT(r, d);
+            HEX(q + 1, p[0]);
+            HEX(q + 3, p[1]);
+            list_out(offset, q);
+        }
+	break;
+    }
+    case OUT_REL2ADR:
+    {
+        uint32_t d = *(int32_t *)data;
+        char q[11];
+        uint8_t p[4], *r = p;
+        q[0] = '(';
+        q[5] = ')';
+        q[6] = '\0';
+        WRITESHORT(r, d);
+        HEX(q + 1, p[0]);
+        HEX(q + 3, p[1]);
+        list_out(offset, q);
+	break;
+    }
+    case OUT_REL4ADR:
+    {
+        uint32_t d = *(int32_t *)data;
+        char q[11];
+        uint8_t p[4], *r = p;
+        q[0] = '(';
+        q[9] = ')';
+        q[10] = '\0';
+        WRITELONG(r, d);
+        HEX(q + 1, p[0]);
+        HEX(q + 3, p[1]);
+        HEX(q + 5, p[2]);
+        HEX(q + 7, p[3]);
+        list_out(offset, q);
+	break;
+    }
+    case OUT_REL8ADR:
+    {
+        uint64_t d = *(int64_t *)data;
+        char q[19];
+        uint8_t p[8], *r = p;
+        q[0] = '(';
+        q[17] = ')';
+        q[18] = '\0';
+        WRITEDLONG(r, d);
+        HEX(q + 1, p[0]);
+        HEX(q + 3, p[1]);
+        HEX(q + 5, p[2]);
+        HEX(q + 7, p[3]);
+        HEX(q + 9, p[4]);
+        HEX(q + 11, p[5]);
+        HEX(q + 13, p[6]);
+        HEX(q + 15, p[7]);
+        list_out(offset, q);
+	break;
+    }
+    case OUT_RESERVE:
+    {
+        char q[20];
+        snprintf(q, sizeof(q), "<res %08"PRIX64">", size);
+        list_out(offset, q);
+	break;
+    }
+    }
+}
+
+static void list_line(int type, char *line)
+{
+    if (!listp)
+        return;
+    if (user_nolist) {          /* fbk - 9/2/00 */
+        listlineno++;
+        return;
+    }
+
+    if (mistack && mistack->inhibiting) {
+        if (type == LIST_MACRO)
+            return;
+        else {                  /* pop the m i stack */
+            MacroInhibit *temp = mistack;
+            mistack = temp->next;
+            nasm_free(temp);
+        }
+    }
+    list_emit();
+    listlinep = true;
+    strncpy(listline, line, LIST_MAX_LEN - 1);
+    listline[LIST_MAX_LEN - 1] = '\0';
+    listlevel_e = listlevel;
+}
+
+static void list_uplevel(int type)
+{
+    if (!listp)
+        return;
+    if (type == LIST_INCBIN || type == LIST_TIMES) {
+        suppress |= (type == LIST_INCBIN ? 1 : 2);
+        list_out(listoffset, type == LIST_INCBIN ? "<incbin>" : "<rept>");
+        return;
+    }
+
+    listlevel++;
+
+    if (mistack && mistack->inhibiting && type == LIST_INCLUDE) {
+        MacroInhibit *temp = nasm_malloc(sizeof(MacroInhibit));
+        temp->next = mistack;
+        temp->level = listlevel;
+        temp->inhibiting = false;
+        mistack = temp;
+    } else if (type == LIST_MACRO_NOLIST) {
+        MacroInhibit *temp = nasm_malloc(sizeof(MacroInhibit));
+        temp->next = mistack;
+        temp->level = listlevel;
+        temp->inhibiting = true;
+        mistack = temp;
+    }
+}
+
+static void list_downlevel(int type)
+{
+    if (!listp)
+        return;
+
+    if (type == LIST_INCBIN || type == LIST_TIMES) {
+        suppress &= ~(type == LIST_INCBIN ? 1 : 2);
+        return;
+    }
+
+    listlevel--;
+    while (mistack && mistack->level > listlevel) {
+        MacroInhibit *temp = mistack;
+        mistack = temp->next;
+        nasm_free(temp);
+    }
+}
+
+static void list_error(int severity, const char *pfx, const char *msg)
+{
+    if (!listfp)
+	return;
+
+    snprintf(listerror, sizeof listerror, "%s%s", pfx, msg);
+
+    if ((severity & ERR_MASK) >= ERR_FATAL)
+	list_emit();
+}
+
+
+ListGen nasmlist = {
+    list_init,
+    list_cleanup,
+    list_output,
+    list_line,
+    list_uplevel,
+    list_downlevel,
+    list_error
+};