#include "std.h"
#include "simul_efun.h"
#include "lex.h"
#include "otable.h"

/*
 * This file rewritten by Beek because it was inefficient and slow.  We
 * now keep track of two mappings:
 *     name -> index       and     index -> function
 * 
 * index->function is used at runtime since it's very fast.  name->index
 * is used at compile time.  It's sorted so we can search it in O(log n)
 * as opposed to a linear search on the function table.  Note that we
 * can't sort the function table b/c then indices wouldn't be preserved
 * across updates.
 *
 * note, the name list holds names for past and present simul_efuns and
 * is now sorted for finding entries faster etc.  The identifier hash
 * table is used at compile time.
 */

typedef struct {
  char *name;
  short index;
} simul_entry;

simul_entry *simul_names = 0;
function_lookup_info_t *simuls = 0;
int num_simul_efun = 0;
object_t *simul_efun_ob;

static void find_or_add_simul_efun (function_t *, int);
static void remove_simuls (void);

#ifdef DEBUGMALLOC_EXTENSIONS
void mark_simuls() {
    int i;

    for (i = 0; i < num_simul_efun; i++) 
        EXTRA_REF(BLOCK(simul_names[i].name))++;
}
#endif

/*
 * If there is a simul_efun file, then take care of it and extract all
 * information we need.
 */
void init_simul_efun (char * file)
{
    char buf[512];
    object_t *new_ob;
    
    if (!file || !file[0]) {
        fprintf(stderr, "No simul_efun\n");
        return;
    }
    if (!strip_name(file, buf, sizeof buf))
        error("Ilegal simul_efun file name '%s'\n", file);
    
    if (file[strlen(file) - 2] != '.')
        strcat(buf, ".c");

    new_ob = load_object(buf, compiled_version);
    if (new_ob == 0) {
        fprintf(stderr, "The simul_efun file %s was not loaded.\n", buf);
        exit(-1);
    }
    set_simul_efun(new_ob);
}

static void remove_simuls() {
    int i;
    ident_hash_elem_t *ihe;
    /* inactivate all old simul_efuns */
    for (i=0; i<num_simul_efun; i++) {
        simuls[i].index = 0;
        simuls[i].func = 0;
    }
    for (i=0; i<num_simul_efun; i++) {
        if ((ihe = lookup_ident(simul_names[i].name))) {
            if (ihe->dn.simul_num != -1)
                ihe->sem_value--;
            ihe->dn.simul_num = -1;
            ihe->token &= ~IHE_SIMUL;
            ihe->token |= IHE_ORPHAN;
        }
    }    
}

static
void get_simul_efuns (program_t * prog)
{
    int i;
    int num_new = prog->num_functions_defined + prog->last_inherited;

    if (num_simul_efun) {
        remove_simuls();
        if (!num_new) {
            FREE(simul_names);
            FREE(simuls);
            num_simul_efun = 0;
        } else {
            /* will be resized later */
            simul_names = RESIZE(simul_names, num_simul_efun + num_new,
                                 simul_entry, TAG_SIMULS, "get_simul_efuns");
            simuls = RESIZE(simuls, num_simul_efun + num_new,
                            function_lookup_info_t, TAG_SIMULS, "get_simul_efuns: 2");
        }
    } else {
        if (num_new) {
            simul_names = CALLOCATE(num_new, simul_entry, TAG_SIMULS, "get_simul_efuns");
            simuls = CALLOCATE(num_new, function_lookup_info_t, TAG_SIMULS, "get_simul_efuns: 2");
        }
    }
    for (i=0; i < num_new; i++) {
        if (prog->function_flags[i] & 
            (FUNC_NO_CODE|DECL_PROTECTED|DECL_PRIVATE|DECL_HIDDEN))
            continue;

        find_or_add_simul_efun(find_func_entry(prog,i), i);
    }
    
    if (num_simul_efun) {
        /* shrink to fit */
        simul_names = RESIZE(simul_names, num_simul_efun, simul_entry,
                             TAG_SIMULS, "get_simul_efuns");
        simuls = RESIZE(simuls, num_simul_efun, function_lookup_info_t,
                        TAG_SIMULS, "get_simul_efuns");
    }
}

/*
 * Define a new simul_efun
 */
static void
find_or_add_simul_efun (function_t * funp, int runtime_index) {
    ident_hash_elem_t *ihe;
    int first = 0;
    int last = num_simul_efun - 1;
    int i,j;
    
    while (first <= last) {
        j = ((first + last) >> 1);
        if (funp->funcname < simul_names[j].name) last = j - 1;
        else if (funp->funcname > simul_names[j].name) first = j + 1;
        else {
            ihe = find_or_add_perm_ident(simul_names[j].name);
            ihe->token |= IHE_SIMUL;
            ihe->token &= ~IHE_ORPHAN;
            ihe->sem_value++;
            ihe->dn.simul_num = simul_names[j].index;
            simuls[simul_names[j].index].index = runtime_index;
            simuls[simul_names[j].index].func = funp;
            return;
        }
    }
    for (i=num_simul_efun - 1; i > last; i--)
        simul_names[i+1] = simul_names[i];
    simuls[num_simul_efun].index = runtime_index;
    simuls[num_simul_efun].func = funp;
    simul_names[first].name = funp->funcname;
    simul_names[first].index = num_simul_efun;
    ihe = find_or_add_perm_ident(funp->funcname);
    ihe->token |= IHE_SIMUL;
    ihe->token &= ~IHE_ORPHAN;
    ihe->sem_value++;
    ihe->dn.simul_num = num_simul_efun++;
    ref_string(funp->funcname);
}

void
set_simul_efun (object_t * ob) {
    get_simul_efuns(ob->prog);
    
    simul_efun_ob = ob;
    add_ref(simul_efun_ob, "set_simul_efun");
}