#include "std.h" #include "replace_program.h" #include "simul_efun.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 (char *, program_t *, int *); static replace_ob_t *retrieve_replace_program_entry (void); int replace_program_pending (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 (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; 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->filename, "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); 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 (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->filename)); debug(d_flag, ("num_inherited=%d\n", prg->num_inherited)); for (i = 0; i < prg->num_inherited; i++) { debug(d_flag, ("index %d:", i)); debug(d_flag, ("checking PRG(/%s)", prg->inherit[i].prog->filename)); if (strcmp(str, prg->inherit[i].prog->filename) == 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 (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 (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