/*
 * YASM assembler virtual line mapping handling (for parse stage)
 *
 *  Copyright (C) 2002-2007  Peter Johnson
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. 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 AUTHOR AND OTHER 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 AUTHOR OR OTHER 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.
 */
#include "util.h"

#include "coretype.h"
#include "hamt.h"

#include "errwarn.h"
#include "linemap.h"


typedef struct line_mapping {
    /* monotonically increasing virtual line */
    unsigned long line;

    /* related info */
    /* "original" source filename */
    /*@null@*/ /*@dependent@*/ const char *filename;
    /* "original" source base line number */
    unsigned long file_line;
    /* "original" source line number increment (for following lines) */
    unsigned long line_inc;
} line_mapping;

typedef struct line_source_info {
    /* first bytecode on line; NULL if no bytecodes on line */
    /*@null@*/ /*@dependent@*/ yasm_bytecode *bc;

    /* source code line */
    /*@owned@*/ char *source;
} line_source_info;

struct yasm_linemap {
    /* Shared storage for filenames */
    /*@only@*/ /*@null@*/ HAMT *filenames;

    /* Current virtual line number. */
    unsigned long current;

    /* Mappings from virtual to physical line numbers */
    struct line_mapping *map_vector;
    unsigned long map_size;
    unsigned long map_allocated;

    /* Bytecode and source line information */
    /*@only@*/ line_source_info *source_info;
    size_t source_info_size;
};

static void
filename_delete_one(/*@only@*/ void *d)
{
    yasm_xfree(d);
}

void
yasm_linemap_set(yasm_linemap *linemap, const char *filename,
                 unsigned long virtual_line, unsigned long file_line,
                 unsigned long line_inc)
{
    char *copy;
    unsigned long i;
    int replace = 0;
    line_mapping *mapping = NULL;

    if (virtual_line == 0) {
        virtual_line = linemap->current;
    }

    /* Replace all existing mappings that have line numbers >= this one. */
    for (i = linemap->map_size; i > 0; i--) {
        if (linemap->map_vector[i-1].line < virtual_line) {
            if (i < linemap->map_size) {
                mapping = &linemap->map_vector[i];
                linemap->map_size = i + 1;
            }
            break;
        }
    }

    if (mapping == NULL) {
        /* Create a new mapping in the map */
        if (linemap->map_size >= linemap->map_allocated) {
            /* allocate another size bins when full for 2x space */
            linemap->map_vector = yasm_xrealloc(linemap->map_vector,
                2*linemap->map_allocated*sizeof(line_mapping));
            linemap->map_allocated *= 2;
        }
        mapping = &linemap->map_vector[linemap->map_size];
        linemap->map_size++;
    }

    /* Fill it */

    if (!filename) {
        if (linemap->map_size >= 2)
            mapping->filename =
                linemap->map_vector[linemap->map_size-2].filename;
        else
            filename = "unknown";
    }
    if (filename) {
        /* Copy the filename (via shared storage) */
        copy = yasm__xstrdup(filename);
        /*@-aliasunique@*/
        mapping->filename = HAMT_insert(linemap->filenames, copy, copy,
                                        &replace, filename_delete_one);
        /*@=aliasunique@*/
    }

    mapping->line = virtual_line;
    mapping->file_line = file_line;
    mapping->line_inc = line_inc;
}

unsigned long
yasm_linemap_poke(yasm_linemap *linemap, const char *filename,
                  unsigned long file_line)
{
    unsigned long line;
    line_mapping *mapping;

    linemap->current++;
    yasm_linemap_set(linemap, filename, 0, file_line, 0);

    mapping = &linemap->map_vector[linemap->map_size-1];

    line = linemap->current;

    linemap->current++;
    yasm_linemap_set(linemap, mapping->filename, 0,
                     mapping->file_line +
                     mapping->line_inc*(linemap->current-2-mapping->line),
                     mapping->line_inc);

    return line;
}

yasm_linemap *
yasm_linemap_create(void)
{
    size_t i;
    yasm_linemap *linemap = yasm_xmalloc(sizeof(yasm_linemap));

    linemap->filenames = HAMT_create(0, yasm_internal_error_);

    linemap->current = 1;

    /* initialize mapping vector */
    linemap->map_vector = yasm_xmalloc(8*sizeof(line_mapping));
    linemap->map_size = 0;
    linemap->map_allocated = 8;
    
    /* initialize source line information array */
    linemap->source_info_size = 2;
    linemap->source_info = yasm_xmalloc(linemap->source_info_size *
                                        sizeof(line_source_info));
    for (i=0; i<linemap->source_info_size; i++) {
        linemap->source_info[i].bc = NULL;
        linemap->source_info[i].source = NULL;
    }

    return linemap;
}

void
yasm_linemap_destroy(yasm_linemap *linemap)
{
    size_t i;
    for (i=0; i<linemap->source_info_size; i++) {
        if (linemap->source_info[i].source)
            yasm_xfree(linemap->source_info[i].source);
    }
    yasm_xfree(linemap->source_info);

    yasm_xfree(linemap->map_vector);

    if (linemap->filenames)
        HAMT_destroy(linemap->filenames, filename_delete_one);

    yasm_xfree(linemap);
}

unsigned long
yasm_linemap_get_current(yasm_linemap *linemap)
{
    return linemap->current;
}

void
yasm_linemap_add_source(yasm_linemap *linemap, yasm_bytecode *bc,
                        const char *source)
{
    size_t i;

    while (linemap->current > linemap->source_info_size) {
        /* allocate another size bins when full for 2x space */
        linemap->source_info = yasm_xrealloc(linemap->source_info,
            2*linemap->source_info_size*sizeof(line_source_info));
        for (i=linemap->source_info_size; i<linemap->source_info_size*2; i++) {
            linemap->source_info[i].bc = NULL;
            linemap->source_info[i].source = NULL;
        }
        linemap->source_info_size *= 2;
    }

    /* Delete existing info for that line (if any) */
    if (linemap->source_info[linemap->current-1].source)
        yasm_xfree(linemap->source_info[linemap->current-1].source);

    linemap->source_info[linemap->current-1].bc = bc;
    linemap->source_info[linemap->current-1].source = yasm__xstrdup(source);
}

unsigned long
yasm_linemap_goto_next(yasm_linemap *linemap)
{
    return ++(linemap->current);
}

void
yasm_linemap_lookup(yasm_linemap *linemap, unsigned long line,
                    const char **filename, unsigned long *file_line)
{
    line_mapping *mapping;
    unsigned long vindex, step;

    assert(line <= linemap->current);

    /* Binary search through map to find highest line_index <= index */
    vindex = 0;
    /* start step as the greatest power of 2 <= size */
    step = 1;
    while (step*2<=linemap->map_size)
        step*=2;
    while (step>0) {
        if (vindex+step < linemap->map_size
                && linemap->map_vector[vindex+step].line <= line)
            vindex += step;
        step /= 2;
    }
    mapping = &linemap->map_vector[vindex];

    *filename = mapping->filename;
    *file_line = (line ? mapping->file_line + mapping->line_inc*(line-mapping->line) : 0);
}

int
yasm_linemap_traverse_filenames(yasm_linemap *linemap, /*@null@*/ void *d,
                                int (*func) (const char *filename, void *d))
{
    return HAMT_traverse(linemap->filenames, d, (int (*) (void *, void *))func);
}

int
yasm_linemap_get_source(yasm_linemap *linemap, unsigned long line,
                        yasm_bytecode **bcp, const char **sourcep)
{
    if (line > linemap->source_info_size) {
        *bcp = NULL;
        *sourcep = NULL;
        return 1;
    }

    *bcp = linemap->source_info[line-1].bc;
    *sourcep = linemap->source_info[line-1].source;

    return (!(*sourcep));
}