/* SPDX-License-Identifier: BSD-2-Clause */
/* Copyright 1996-2020 The NASM Authors - All Rights Reserved */

/*
 * listing.c    listing file generator for the Netwide Assembler
 */

#include "compiler.h"

#include "nctype.h"

#include "nasm.h"
#include "nasmlib.h"
#include "error.h"
#include "strlist.h"
#include "listing.h"

#define LIST_MAX_LEN 1024       /* something sensible */
#define LIST_INDENT  40
#define LIST_HEXBIT  18

static const char xdigit[] = "0123456789ABCDEF";

#define HEX(a,b) (*(a)=xdigit[((b)>>4)&15],(a)[1]=xdigit[(b)&15])

uint64_t list_options, active_list_options;
bool user_nolist;

static char listline[LIST_MAX_LEN];
static bool listlinep;

static struct strlist *list_errors;

static char listdata[2 * LIST_INDENT];  /* we need less than that actually */
static int32_t listoffset;

static int32_t listlineno;

static int suppress;            /* for INCBIN & TIMES special cases */

static int listlevel, listlevel_e;

static FILE *listfp;

static inline char err_fill_char(errflags severity)
{
    severity &= ERR_MASK;

    if (severity < ERR_NOTE)
        return ' ';
    else if (severity < ERR_WARNING)
        return '-';
    else if (severity < ERR_CRITICAL)
        return '*';
    else
        return 'X';
}

static void list_emit(void)
{
    int i;
    const struct strlist_entry *e;

    if (listlinep || *listdata) {
        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 (list_errors) {
        strlist_for_each(e, list_errors) {
            char fillchar;

            fprintf(listfp, "%6"PRId32"          ", listlineno);
            fillchar = err_fill_char(e->pvt.u);
            for (i = 0; i < LIST_HEXBIT; i++)
                putc(fillchar, listfp);

            if (listlevel_e)
                fprintf(listfp, " %s<%d>", (listlevel < 10 ? " " : ""),
                        listlevel_e);
            else
                fprintf(listfp, "     ");

            fprintf(listfp, "  %s\n", e->str);
        }

        strlist_free(&list_errors);
    }
}

static void list_cleanup(void)
{
    if (!listfp)
        return;

    list_emit();
    fclose(listfp);
    listfp = NULL;
    active_list_options = 0;
}

static void list_init(const char *fname)
{
    enum file_flags flags = NF_TEXT;

    if (listfp)
        list_cleanup();

    if (!fname || fname[0] == '\0') {
	listfp = NULL;
	return;
    }

    if (list_option('w'))
        flags |= NF_IOLBF;

    listfp = nasm_open_write(fname, flags);
    if (!listfp) {
        nasm_nonfatal("unable to open listing file `%s'", fname);
        return;
    }

    active_list_options = list_options | 1;

    *listline = '\0';
    listlineno = 0;
    list_errors = NULL;
    listlevel = 0;
    suppress = 0;
    user_nolist = false;
}

static void list_out(int64_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_address(int64_t offset, const char *brackets,
			 int64_t addr, int size)
{
    char q[20];
    char *r = q;

    nasm_assert(size <= 8);

    *r++ = brackets[0];
    while (size--) {
	HEX(r, addr);
	addr >>= 8;
	r += 2;
    }
    *r++ = brackets[1];
    *r = '\0';
    list_out(offset, q);
}

static void list_size(int64_t offset, const char *tag, uint64_t size)
{
    char buf[64];
    const char *fmt;

    if (list_option('d'))
        fmt = "<%s %"PRIu64">";
    else
        fmt = "<%s %"PRIX64"h>";

    snprintf(buf, sizeof buf, fmt, tag, size);
    list_out(offset, buf);
}

static void list_output(const struct out_data *data)
{
    char q[24];
    uint64_t size = data->size;
    uint64_t offset = data->loc.offset;
    const uint8_t *p = data->data;


    if (!listfp || suppress || user_nolist)
        return;

    switch (data->type) {
    case OUT_ZERODATA:
        if (size > 16) {
            list_size(offset, "zero", size);
            break;
        } else {
            p = zero_buffer;
        }
        /* fall through */
    case OUT_RAWDATA:
    {
	if (size == 0) {
            if (!listdata[0])
                listoffset = data->loc.offset;
        } else if (p) {
            while (size--) {
                HEX(q, *p);
                q[2] = '\0';
                list_out(offset++, q);
                p++;
            }
        } else {
            /* Used for listing on non-code generation passes with -Lp */
            list_size(offset, "len", size);
        }
	break;
    }
    case OUT_ADDRESS:
        list_address(offset, "[]", data->toffset, size);
	break;
    case OUT_SEGMENT:
        q[0] = '[';
        memset(q+1, 's', size << 1);
        q[(size << 1)+1] = ']';
        q[(size << 1)+2] = '\0';
        list_out(offset, q);
        offset += size;
        break;
    case OUT_RELADDR:
	list_address(offset, "()", data->toffset, size);
	break;
    case OUT_RESERVE:
    {
        if (size > 8) {
            list_size(offset, "res", size);
        } else {
            memset(q, '?', size << 1);
            q[size << 1] = '\0';
            list_out(offset, q);
        }
	break;
    }
    default:
        panic();
    }
}

static void list_line(int type, int32_t lineno, const char *line)
{
    (void)type;

    if (!listfp)
        return;

    if (user_nolist)
      return;

    list_emit();
    if (lineno >= 0)
        listlineno = lineno;
    listlinep = true;
    strlcpy(listline, line, LIST_MAX_LEN-3);
    memcpy(listline + LIST_MAX_LEN-4, "...", 4);
    listlevel_e = listlevel;
}

static void list_uplevel(int type, int64_t size)
{
    if (!listfp)
        return;

    switch (type) {
    case LIST_INCBIN:
        suppress |= 1;
        list_size(listoffset, "bin", size);
        break;

    case LIST_TIMES:
        suppress |= 2;
        list_size(listoffset, "rep", size);
        break;

    case LIST_INCLUDE:
        listlevel++;
        break;

    default:
        listlevel++;
        break;
    }
}

static void list_downlevel(int type)
{
    if (!listfp)
        return;

    switch (type) {
    case LIST_INCBIN:
        suppress &= ~1;
        break;

    case LIST_TIMES:
        suppress &= ~2;
        break;

    default:
        listlevel--;
        break;
    }
}

static void printf_func(2, 3) list_error(errflags severity, const char *fmt, ...)
{
    va_list ap;

    if (!listfp)
	return;

    if (!list_errors)
        list_errors = strlist_alloc(false);

    va_start(ap, fmt);
    strlist_vprintf(list_errors, fmt, ap);
    va_end(ap);
    strlist_tail(list_errors)->pvt.u = severity;

    if ((severity & ERR_MASK) >= ERR_FATAL)
	list_emit();
}

static void list_set_offset(uint64_t offset)
{
    listoffset = offset;
}

static void list_update_options(const char *str)
{
    bool state = true;
    unsigned char c;
    uint64_t mask;

    while ((c = *str++)) {
        switch (c) {
        case '+':
            state = true;
            break;
        case '-':
            state = false;
            break;
        default:
            mask = list_option_mask(c);
            if (state) {
                list_options |= mask;
                active_list_options |= mask;
            } else {
                list_options &= ~mask;
                active_list_options &= ~mask;
            }
            break;
        }
    }
}

enum directive_result list_pragma(const struct pragma *pragma)
{
    switch (pragma->opcode) {
    case D_OPTIONS:
        list_update_options(pragma->tail);
        return DIRR_OK;

    default:
        return DIRR_UNKNOWN;
    }
}

static const struct lfmt nasm_list = {
    list_init,
    list_cleanup,
    list_output,
    list_line,
    list_uplevel,
    list_downlevel,
    list_error,
    list_set_offset
};

const struct lfmt *lfmt = &nasm_list;
