listing.c

   1 /* listing.c    listing file generator for the Netwide Assembler
   2  *
   3  * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
   4  * Julian Hall. All rights reserved. The software is
   5  * redistributable under the licence given in the file "Licence"
   6  * distributed in the NASM archive.
   7  *
   8  * initial version 2/vii/97 by Simon Tatham
   9  */
  10
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <stddef.h>
  14 #include <string.h>
  15 #include <ctype.h>
  16
  17 #include "nasm.h"
  18 #include "nasmlib.h"
  19 #include "listing.h"
  20
  21 #define LIST_MAX_LEN 216               /* something sensible */
  22 #define LIST_INDENT  40
  23 #define LIST_HEXBIT  18
  24
  25 typedef struct MacroInhibit MacroInhibit;
  26
  27 static struct MacroInhibit {
  28     MacroInhibit *next;
  29     int level;
  30     int inhibiting;
  31 } *mistack;
  32
  33 static char xdigit[] = "0123456789ABCDEF";
  34
  35 #define HEX(a,b) (*(a)=xdigit[((b)>>4)&15],(a)[1]=xdigit[(b)&15]);
  36
  37 static char listline[LIST_MAX_LEN];
  38 static int listlinep;
  39
  40 static char listdata[2*LIST_INDENT];   /* we need less than that actually */
  41 static long listoffset;
  42
  43 static long listlineno;
  44
  45 static long listp;
  46
  47 static int suppress;                   /* for INCBIN & TIMES special cases */
  48
  49 static int listlevel, listlevel_e;
  50
  51 static FILE *listfp;
  52
  53 static void list_emit (void)
  54 {
  55     if (!listlinep && !listdata[0])
  56         return;
  57
  58     fprintf(listfp, "%6ld ", ++listlineno);
  59
  60     if (listdata[0])
  61         fprintf(listfp, "%08lX %-*s", listoffset, LIST_HEXBIT+1, listdata);
  62     else
  63         fprintf(listfp, "%*s", LIST_HEXBIT+10, "");
  64
  65     if (listlevel_e)
  66         fprintf(listfp, "%s<%d>", (listlevel < 10 ? " " : ""), listlevel_e);
  67     else if (listlinep)
  68         fprintf(listfp, "    ");
  69
  70     if (listlinep)
  71         fprintf(listfp, " %s", listline);
  72
  73     fputc('\n', listfp);
  74     listlinep = FALSE;
  75     listdata[0] = '\0';
  76 }
  77
  78 static void list_init (char *fname, efunc error)
  79 {
  80     listfp = fopen (fname, "w");
  81     if (!listfp) {
  82         error (ERR_NONFATAL, "unable to open listing file `%s'", fname);
  83         return;
  84     }
  85
  86     *listline = '\0';
  87     listlineno = 0;
  88     listp = TRUE;
  89     listlevel = 0;
  90     suppress = 0;
  91     mistack = nasm_malloc(sizeof(MacroInhibit));
  92     mistack->next = NULL;
  93     mistack->level = 0;
  94     mistack->inhibiting = TRUE;
  95 }
  96
  97 static void list_cleanup (void)
  98 {
  99     if (!listp)
 100         return;
 101
 102     while (mistack) {
 103         MacroInhibit *temp = mistack;
 104         mistack = temp->next;
 105         nasm_free (temp);
 106     }
 107
 108     list_emit();
 109     fclose (listfp);
 110 }
 111
 112 static void list_out (long offset, char *str)
 113 {
 114     if (strlen(listdata) + strlen(str) > LIST_HEXBIT) {
 115         strcat(listdata, "-");
 116         list_emit();
 117     }
 118     if (!listdata[0])
 119         listoffset = offset;
 120     strcat(listdata, str);
 121 }
 122
 123 static void list_output (long offset, void *data, unsigned long type)
 124 {
 125     unsigned long typ;
 126     long size;
 127
 128     if (!listp || suppress)
 129         return;
 130
 131     typ = type & OUT_TYPMASK;
 132     size = type & OUT_SIZMASK;
 133
 134     if (typ == OUT_RAWDATA)
 135     {
 136         unsigned char *p = data;
 137         char q[3];
 138         while (size--)
 139         {
 140             HEX (q, *p);
 141             q[2] = '\0';
 142             list_out (offset++, q);
 143             p++;
 144         }
 145     }
 146     else if (typ == OUT_ADDRESS)
 147     {
 148         unsigned long d = *(long *)data;
 149         char q[11];
 150         unsigned char p[4], *r = p;
 151         if (size == 4)
 152         {
 153             q[0] = '['; q[9] = ']'; q[10] = '\0';
 154             WRITELONG (r, d);
 155             HEX (q+1, p[0]);
 156             HEX (q+3, p[1]);
 157             HEX (q+5, p[2]);
 158             HEX (q+7, p[3]);
 159             list_out (offset, q);
 160         }
 161         else {
 162             q[0] = '['; q[5] = ']'; q[6] = '\0';
 163             WRITESHORT (r, d);
 164             HEX (q+1, p[0]);
 165             HEX (q+3, p[1]);
 166             list_out (offset, q);
 167         }
 168     }
 169     else if (typ == OUT_REL2ADR)
 170     {
 171         unsigned long d = *(long *)data;
 172         char q[11];
 173         unsigned char p[4], *r = p;
 174         q[0] = '('; q[5] = ')'; q[6] = '\0';
 175         WRITESHORT (r, d);
 176         HEX (q+1, p[0]);
 177         HEX (q+3, p[1]);
 178         list_out (offset, q);
 179     }
 180     else if (typ == OUT_REL4ADR)
 181     {
 182         unsigned long d = *(long *)data;
 183         char q[11];
 184         unsigned char p[4], *r = p;
 185         q[0] = '('; q[9] = ')'; q[10] = '\0';
 186         WRITELONG (r, d);
 187         HEX (q+1, p[0]);
 188         HEX (q+3, p[1]);
 189         HEX (q+5, p[2]);
 190         HEX (q+7, p[3]);
 191         list_out (offset, q);
 192     }
 193     else if (typ == OUT_RESERVE)
 194     {
 195         char q[20];
 196         sprintf(q, "<res %08lX>", size);
 197         list_out (offset, q);
 198     }
 199 }
 200
 201 static void list_line (int type, char *line)
 202 {
 203     if (!listp)
 204         return;
 205
 206     if (mistack && mistack->inhibiting)
 207     {
 208         if (type == LIST_MACRO)
 209             return;
 210         else {                         /* pop the m i stack */
 211             MacroInhibit *temp = mistack;
 212             mistack = temp->next;
 213             nasm_free (temp);
 214         }
 215     }
 216     list_emit();
 217     listlinep = TRUE;
 218     strncpy (listline, line, LIST_MAX_LEN-1);
 219     listline[LIST_MAX_LEN-1] = '\0';
 220     listlevel_e = listlevel;
 221 }
 222
 223 static void list_uplevel (int type)
 224 {
 225     if (!listp)
 226         return;
 227     if (type == LIST_INCBIN || type == LIST_TIMES)
 228     {
 229         suppress |= (type == LIST_INCBIN ? 1 : 2);
 230         list_out (listoffset, type == LIST_INCBIN ? "<incbin>" : "<rept>");
 231         return;
 232     }
 233
 234     listlevel++;
 235
 236     if (mistack && mistack->inhibiting && type == LIST_INCLUDE)
 237     {
 238         MacroInhibit *temp = nasm_malloc(sizeof(MacroInhibit));
 239         temp->next = mistack;
 240         temp->level = listlevel;
 241         temp->inhibiting = FALSE;
 242         mistack = temp;
 243     }
 244     else if (type == LIST_MACRO_NOLIST)
 245     {
 246         MacroInhibit *temp = nasm_malloc(sizeof(MacroInhibit));
 247         temp->next = mistack;
 248         temp->level = listlevel;
 249         temp->inhibiting = TRUE;
 250         mistack = temp;
 251     }
 252 }
 253
 254 static void list_downlevel (int type)
 255 {
 256     if (!listp)
 257         return;
 258
 259     if (type == LIST_INCBIN || type == LIST_TIMES)
 260     {
 261         suppress &= ~(type == LIST_INCBIN ? 1 : 2);
 262         return;
 263     }
 264
 265     listlevel--;
 266     while (mistack && mistack->level > listlevel)
 267     {
 268         MacroInhibit *temp = mistack;
 269         mistack = temp->next;
 270         nasm_free (temp);
 271     }
 272 }
 273
 274 ListGen nasmlist = {
 275     list_init,
 276     list_cleanup,
 277     list_output,
 278     list_line,
 279     list_uplevel,
 280     list_downlevel
 281 };