#include "std.h"
#include "replace_program.h"
#include "simul_efun.h"
#include "swap.h"
#include "efun_protos.h"

/*
 * replace_program.c
 * replaces the program in a running object with one of the programs
 * it inherits, in order to save memory.
 * Ported from Amylaars LP 3.2 driver
 */

replace_ob_t *obj_list_replace = 0;

static program_t *search_inherited PROT((char *, program_t *, int *));
static replace_ob_t *retrieve_replace_program_entry PROT((void));

int replace_program_pending P1(object_t *, ob)
{
    replace_ob_t *r_ob;

    for (r_ob = obj_list_replace;  r_ob;  r_ob = r_ob->next) {
	if (r_ob->ob == ob)
	    return 1;
    }

    return 0;
}

void replace_programs PROT((void))
{
    replace_ob_t *r_ob, *r_next;
    int i, num_fewer, offset;
    svalue_t *svp;

    debug(d_flag, ("start of replace_programs"));

    for (r_ob = obj_list_replace; r_ob; r_ob = r_next) {
	program_t *old_prog;

	if (r_ob->ob->flags & O_SWAPPED)
	    load_ob_from_swap(r_ob->ob);
	num_fewer = r_ob->ob->prog->num_variables_total - r_ob->new_prog->num_variables_total;

	debug(d_flag, ("%d less variables\n", num_fewer));

	tot_alloc_object_size -= num_fewer * sizeof(svalue_t[1]);
	if ((offset = r_ob->var_offset)) {
	    svp = r_ob->ob->variables;
	    /* move our variables up to the top */
	    for (i = 0; i < r_ob->new_prog->num_variables_total; i++) {
		free_svalue(svp, "replace_programs");
		*svp = *(svp + offset);
		*(svp + offset) = const0u;
		svp++;
	    }
	    /* free the rest */
	    for (i = 0; i < num_fewer; i++) {
		free_svalue(svp, "replace_programs");
		*svp++ = const0u;
	    }
	} else {
	    /* We just need to remove the last num_fewer variables */
	    svp = &r_ob->ob->variables[r_ob->new_prog->num_variables_total];
	    for (i = 0; i < num_fewer; i++) {
		free_svalue(svp, "replace_programs");
		*svp++ = const0u;
	    }
	}

        if (r_ob->ob->replaced_program) {
            FREE_MSTR(r_ob->ob->replaced_program);
            r_ob->ob->replaced_program = 0;
        }
        r_ob->ob->replaced_program = string_copy(r_ob->new_prog->name, "replace_programs");

	reference_prog(r_ob->new_prog, "replace_programs");
	old_prog = r_ob->ob->prog;
	r_ob->ob->prog = r_ob->new_prog;
	r_next = r_ob->next;
	free_prog(old_prog, 1);

	debug(d_flag, ("program freed."));
#ifndef NO_SHADOWS
	if (r_ob->ob->shadowing) {
	    /*
	     * The master couldn't decide if it's a legal shadowing before
	     * the program was actually replaced. It is possible that the
	     * blueprint to the replacing program is already destructed, and
	     * it's source changed. On the other hand, if we called the
	     * master now, all kind of volatile data structures could result,
	     * even new entries for obj_list_replace. This would eventually
	     * require to reference it, and all the lrpp's , in
	     * check_a_lot_ref_counts() and garbage_collection() . Being able
	     * to use replace_program() in shadows is hardly worth this
	     * effort. Thus, we simply stop the shadowing.
	     */
	    r_ob->ob->shadowing->shadowed = r_ob->ob->shadowed;
	    if (r_ob->ob->shadowed) {
		r_ob->ob->shadowed->shadowing = r_ob->ob->shadowing;
		r_ob->ob->shadowed = 0;
	    }
	    r_ob->ob->shadowing = 0;
	}
#endif
	FREE((char *) r_ob);
    }
    obj_list_replace = (replace_ob_t *) 0;
    debug(d_flag, ("end of replace_programs"));
}

#ifdef F_REPLACE_PROGRAM
static program_t *search_inherited P3(char *, str, program_t *, prg, int *, offpnt)
{
    program_t *tmp;
    int i;

    debug(d_flag, ("search_inherited started"));
    debug(d_flag, ("searching for PRG(/%s) in PRG(/%s)", str, prg->name));
    debug(d_flag, ("num_inherited=%d\n", prg->num_inherited));

    for (i = 0; i < (int) prg->num_inherited; i++) {
	debug(d_flag, ("index %d:", i));
	debug(d_flag, ("checking PRG(/%s)", prg->inherit[i].prog->name));

	if (strcmp(str, prg->inherit[i].prog->name) == 0) {
	    debug(d_flag, ("match found"));

	    *offpnt = prg->inherit[i].variable_index_offset;
	    return prg->inherit[i].prog;
	} else if ((tmp = search_inherited(str, prg->inherit[i].prog,
					  offpnt))) {
	    debug(d_flag, ("deferred match found"));

	    *offpnt += prg->inherit[i].variable_index_offset;
	    return tmp;
	}
    }
    debug(d_flag, ("search_inherited failed"));

    return (program_t *) 0;
}

static replace_ob_t *retrieve_replace_program_entry PROT((void))
{
    replace_ob_t *r_ob;

    for (r_ob = obj_list_replace; r_ob; r_ob = r_ob->next) {
	if (r_ob->ob == current_object) {
	    return r_ob;
	}
    }
    return 0;
}

void
f_replace_program PROT((void))
{
    replace_ob_t *tmp;
    int name_len;
    char *name, *xname;
    program_t *new_prog;
    int var_offset;

    if (sp->type != T_STRING)
	bad_arg(1, F_REPLACE_PROGRAM);
    debug(d_flag, ("replace_program called"));

    if (!current_object)
	error("replace_program called with no current object\n");
    if (current_object == simul_efun_ob)
	error("replace_program on simul_efun object\n");

    if (current_object->prog->func_ref)
	error("cannot replace a program with function references.\n");

    name_len = SVALUE_STRLEN(sp);
    name = (char *) DMALLOC(name_len + 3, TAG_TEMPORARY, "replace_program");
    xname = name;
    strcpy(name, sp->u.string);
    if (name[name_len - 2] != '.' || name[name_len - 1] != 'c')
	strcat(name, ".c");
    if (*name == '/')
	name++;
    new_prog = search_inherited(name, current_object->prog, &var_offset);
    FREE(xname);
    if (!new_prog) {
	error("program to replace the current with has to be inherited\n");
    }
    if (!(tmp = retrieve_replace_program_entry())) {
	tmp = ALLOCATE(replace_ob_t, TAG_TEMPORARY, "replace_program");
	tmp->ob = current_object;
	tmp->next = obj_list_replace;
	obj_list_replace = tmp;
    }
    tmp->new_prog = new_prog;
    tmp->var_offset = var_offset;

    debug(d_flag, ("replace_program finished"));

    free_string_svalue(sp--);
}

#endif