Index: object.c =================================================================== --- object.c (Revision 2426) +++ object.c (Arbeitskopie) @@ -6599,7 +6599,8 @@ save_version = sp->u.number >= 0 ? sp->u.number : CURRENT_VERSION; - /* The main code wants sp == filename */ + /* The main code wants sp == filename (T_NUMBER svalues need no free.) + */ sp--; numarg--; break; @@ -6651,18 +6652,19 @@ /* Create the final and the temporary filename */ - len = (long)mstrsize(sfile); - name = alloca(len + (sizeof save_file_suffix) + - len + (sizeof save_file_suffix) + 4); - + inter_sp = sp; + name = alloc_with_error_handler(len + (sizeof save_file_suffix) + + len + (sizeof save_file_suffix) + 4); if (!name) { free_mstring(sfile); - errorf("Stack overflow in save_object('%s')\n", get_txt(sp->u.str)); + errorf("Out of memory (%ld bytes) in save_object('%s')\n", + 2*len+2*sizeof(save_file_suffix)+4, get_txt(sp->u.str)); /* NOTREACHED */ return sp; } + sp = inter_sp; tmp_name = name + len + sizeof save_file_suffix; strcpy(name, get_txt(sfile)); @@ -6804,8 +6806,9 @@ close(f); unlink(tmp_name); add_message("Failed to save to file '%s'. Disk could be full.\n", file); - if (numarg) - sp = pop_n_elems(numarg, sp); + /* free the error handler and the arguments (numarg + 1 from sp). + */ + sp = pop_n_elems(numarg + 1, sp); sp++; put_number(sp, 1); return sp; @@ -6836,21 +6839,24 @@ unlink(tmp_name); #endif - if (numarg) - sp = pop_n_elems(numarg, sp); + /* free the error handler and the arguments (numarg + 1 from sp) and + * push result on the stack. + */ + sp = pop_n_elems(numarg + 1, sp); sp++; put_number(sp, i); - } + } /* if (file) */ else { /* Finish up the operation. Note that there propably is some * data pending in the save_buffer. */ - if (numarg) - sp = pop_n_elems(numarg, sp); + /* free the error handler and the arguments (numarg + 1 from sp). + */ + sp = pop_n_elems(numarg + 1, sp); + sp++; /* for the result */ - if (failed) put_number(sp, 0); /* Shouldn't happen */ else if (buf_left != SAVE_OBJECT_BUFSIZE) @@ -8497,7 +8503,8 @@ int * pNesting; /* The nesting counter */ char * buff; /* The optional allocated line buffer. */ FILE * f; /* The optional input file */ - struct discarded * dp; + struct discarded * dp; + char * filename; /* optional buffer for the filename */ /* List of values for which the variables no longer exist. */ } restore_cleanup_t; @@ -8531,6 +8538,10 @@ (*data->pNesting)--; free_shared_restored_values(); + + if (data->filename) + xfree(data->filename); + xfree(arg); } /* restore_object_cleanup() */ @@ -8576,6 +8587,7 @@ size_t len; FILE *f; struct stat st; /* stat() info of the savefile */ + svalue_t *arg; /* pointer to the argument on the stack - for convenience */ int var_rest; /* Number of variables left after rover */ int num_var; /* Number of variables in the object */ @@ -8584,17 +8596,30 @@ * to restore is searched from here, taking advantage of * the locality of save_object(). */ - restore_cleanup_t * rcp; /* Cleanup structure */ - -#define FREE_BUFF() MACRO( \ - if (nesting > 1) xfree(buff); else mb_free(mbFile); \ - ) - /* Free buff correctly. - */ - - + + arg = sp; + + /* Allocate memory for the error cleanup structure first. We need it + * anway and if we can't allocate it, then this is anyway a lost cause. */ + rcp = xalloc(sizeof(*rcp)); + if (!rcp) + { + errorf("(restore) Out of memory: (%zu bytes) for cleanup structure\n" + , sizeof(*rcp)); + /* NOTREACHED */ + return sp; + } + rcp->pNesting = &nesting; + rcp->buff = NULL; + rcp->f = NULL; + rcp->dp = NULL; + rcp->filename = NULL; + /* Push it on top of the argument on the stack. */ + push_error_handler(restore_object_cleanup, &(rcp->head)); + sp = inter_sp; + /* Keep track of recursive calls */ nesting++; @@ -8605,17 +8630,18 @@ ob = current_object; if (ob->flags & O_DESTRUCTED) { - free_svalue(sp); + sp = pop_n_elems(2, sp); /* pop and free error handler + argument */ + sp++; put_number(sp, 0); - nesting--; return sp; } + /* no need to restore objects without variables */ if (ob->prog->num_variables == 0) { - free_svalue(sp); + sp = pop_n_elems(2, sp); /* pop and free error handler + argument */ + sp++; put_number(sp, 1); - nesting--; return sp; } @@ -8625,24 +8651,25 @@ file = NULL; f = NULL; lineno = 0; - if (get_txt(sp->u.str)[0] == '#') + if (get_txt(arg->u.str)[0] == '#') { /* We need a copy of the value string because we're * going to modify it a bit. */ - len = mstrsize(sp->u.str); + len = mstrsize(arg->u.str); buff = (nesting > 1) ? xalloc(len+1) : mb_alloc(mbFile, len+1); if (buff == NULL) { - nesting--; outofmem(len+1, "copy of value string"); } - memcpy(buff, get_txt(sp->u.str), len); + /* keep track of buff in the cleanup structure. */ + rcp->buff = buff; + memcpy(buff, get_txt(arg->u.str), len); buff[len] = '\0'; } else { - file = get_txt(sp->u.str); + file = get_txt(arg->u.str); } /* If restoring from a file, set it up */ @@ -8653,29 +8680,25 @@ /* Get a valid filename */ - sfile = check_valid_path(sp->u.str, ob, STR_RESTORE_OBJECT, MY_FALSE); + sfile = check_valid_path(arg->u.str, ob, STR_RESTORE_OBJECT, MY_FALSE); if (sfile == NULL) { - nesting--; - errorf("Illegal use of restore_object('%s')\n", get_txt(sp->u.str)); + errorf("Illegal use of restore_object('%s')\n", get_txt(arg->u.str)); /* NOTREACHED */ return sp; } - /* Create the full filename */ - len = mstrsize(sfile); - name = alloca(len + (sizeof save_file_suffix)); - + name = xalloc(len + (sizeof save_file_suffix)); if (!name) { free_mstring(sfile); - nesting--; - errorf("Stack overflow in restore_object('%s')\n", get_txt(sp->u.str)); + errorf("Stack overflow in restore_object('%s')\n", get_txt(arg->u.str)); /* NOTREACHED */ return sp; } + rcp->filename = name; /* in case of errrors -> cleanup structure */ strcpy(name, get_txt(sfile)); if (name[len-2] == '.' && name[len-1] == 'c') @@ -8685,22 +8708,21 @@ free_mstring(sfile); /* Open the file and gets its length */ - f = fopen(name, "r"); if (!f || fstat(fileno(f), &st) == -1) { if (f) fclose(f); - free_svalue(sp); + sp = pop_n_elems(2, sp); /* pop and free error handler + argument */ + sp++; put_number(sp, 0); - nesting--; return sp; } + rcp->f = f; /* keep track of f in case of errors */ if (st.st_size == 0) { - fclose(f); - free_svalue(sp); + sp = pop_n_elems(2, sp); /* pop and free error handler + argument */ + sp++; put_number(sp, 0); - nesting--; return sp; } FCOUNT_REST(name); @@ -8708,13 +8730,10 @@ /* Allocate the linebuffer. Unfortunately, the whole file * can be one single line. */ - buff = (nesting > 1) ? xalloc((size_t)(st.st_size + 1)) : mb_alloc(mbFile, (size_t)(st.st_size+1)); if (!buff) { - fclose(f); - nesting--; /* TODO: st_size is off_t which is most often int64_t or int32_t. * TODO:: PRIdMAX or PRId64 should be used, I think. */ errorf("(restore) Out of memory (%ld bytes) for linebuffer.\n" @@ -8722,6 +8741,7 @@ /* NOTREACHED */ return sp; } + rcp->buff = buff; } /* if (file) */ /* Initialise the variables */ @@ -8739,37 +8759,12 @@ if (!shared_restored_values) { - if (f) - fclose(f); - FREE_BUFF(); - nesting--; errorf("(restore) Out of memory (%lu bytes) for shared values.\n" , sizeof(svalue_t)*(unsigned long)max_shared_restored); /* NOTREACHED */ return sp; } - - /* Setup the error cleanup */ - inter_sp = sp; - rcp = xalloc(sizeof(*rcp)); - if (!rcp) - { - if (f) - fclose(f); - FREE_BUFF(); - nesting--; - errorf("(restore) Out of memory: (%zu bytes) for cleanup structure\n" - , sizeof(*rcp)); - /* NOTREACHED */ - return sp; - } - - rcp->pNesting = &nesting; - rcp->buff = buff; - rcp->f = f; - rcp->dp = NULL; - push_error_handler(restore_object_cleanup, &(rcp->head)); - + num_var = ob->prog->num_variables; var_rest = 0; restored_version = -1; @@ -8829,7 +8824,8 @@ } /* No version line: illegal format. - * Deallocate what we allocated so far and return. + * Most of the cleanup will be done by the error handler during + * stack unwinding. */ if (file) errorf("Illegal format (version line) when restoring %s " @@ -8962,13 +8958,11 @@ , time_stamp(), get_txt(ob->name) , file ? name : "passed value"); - free_svalue(inter_sp--); /* calls the cleanup handler */ - - free_svalue(inter_sp); - put_number(inter_sp, 1); + free_svalue(sp--); /* calls the cleanup handler */ + free_svalue(sp); /* frees the argument */ + put_number(sp, 1); return sp; -#undef FREE_BUFF } /* f_restore_object() */ /*-------------------------------------------------------------------------*/