/*
* NAME: item()
* DESCRIPTION: dereference strings when iterating through items
*/
virtual bool item(node *n) {
if (n->type == N_STR || n->type == N_GOTO || n->type == N_LABEL) {
str_del(n->l.string);
} else if (n->type == N_TYPE && n->sclass != (String *) NULL) {
str_del(n->sclass);
}
return TRUE;
}
/*
* NAME: node->toint()
* DESCRIPTION: convert node type to integer constant
*/
void node_toint(node *n, Int i)
{
if (n->type == N_STR) {
str_del(n->l.string);
} else if (n->type == N_TYPE && n->sclass != (String *) NULL) {
str_del(n->sclass);
}
n->type = N_INT;
n->flags = F_CONST;
n->l.number = i;
}
/*
* NAME: node->tostr()
* DESCRIPTION: convert node type to string constant
*/
void node_tostr(node *n, String *str)
{
str_ref(str);
if (n->type == N_STR) {
str_del(n->l.string);
} else if (n->type == N_TYPE && n->sclass != (String *) NULL) {
str_del(n->sclass);
}
n->type = N_STR;
n->flags = F_CONST;
n->l.string = str;
}
/*
* NAME: parser->del()
* DESCRIPTION: delete parser
*/
void ps_del(parser *ps)
{
ps->data->parser = (parser *) NULL;
str_del(ps->source);
str_del(ps->grammar);
if (ps->fastr != (char *) NULL) {
FREE(ps->fastr);
}
if (ps->lrstr != (char *) NULL) {
FREE(ps->lrstr);
}
dfa_del(ps->fa);
srp_del(ps->lr);
FREE(ps);
}
/*
* NAME: kfun->old_compile_object()
* DESCRIPTION: compile an object
*/
int kf_old_compile_object(frame *f)
{
char file[STRINGSZ];
object *obj;
if (path_string(file, f->sp->u.string->text,
f->sp->u.string->len) == (char *) NULL) {
return 1;
}
obj = o_find(file, OACC_MODIFY);
if (obj != (object *) NULL) {
if (!(obj->flags & O_MASTER)) {
error("Cannot recompile cloned object");
}
if (O_UPGRADING(obj)) {
error("Object is already being upgraded");
}
if (O_INHERITED(obj)) {
error("Cannot recompile inherited object");
}
}
obj = c_compile(f, file, obj, (string **) NULL, 0,
(OBJR(f->oindex)->flags & O_DRIVER) &&
strcmp(d_get_strconst(f->p_ctrl, f->func->inherit,
f->func->index)->text,
"inherit_program") == 0);
str_del(f->sp->u.string);
PUT_OBJVAL(f->sp, obj);
return 0;
}
/*
* NAME: data->free_call_out()
* DESCRIPTION: free a callout
*/
static void d_free_call_out(dataspace *data, unsigned int handle)
{
dcallout *co;
value *v;
uindex n;
co = &data->callouts[handle - 1];
v = co->val;
switch (co->nargs) {
default:
del_lhs(data, &v[3]);
i_del_value(&v[3]);
case 2:
del_lhs(data, &v[2]);
i_del_value(&v[2]);
case 1:
del_lhs(data, &v[1]);
i_del_value(&v[1]);
case 0:
del_lhs(data, &v[0]);
str_del(v[0].u.string);
break;
}
v[0] = nil_value;
n = data->fcallouts;
if (n != 0) {
data->callouts[n - 1].co_prev = handle;
}
co->co_next = n;
data->fcallouts = handle;
data->plane->flags |= MOD_CALLOUT;
}
/*
Delete a character at position p in the window text.
*/
static void
del_char(struct Window *win, int p){
// No text ==> nothing to delete
if ( (0 == win->text_len) || (p > win->text_len) )
return;
/* Clear old cursor */
cursor_on = 0;
draw_cursor(win, cursor_pos, 0);
if (p == win->text_len) {
win->text_len = str_del(win->txt, win->text_len - 1);
} else {
win->text_len = str_del(win->txt, p);
};
win_draw_text(win);
};
/* frees up all memory allocated by str */
void
str_free()
{
str_t *s = xhp->str;
if (s != NULL) {
while(s->size > 0) str_del();
free(s);
s = NULL;
}
}
static void test_random_edits() {
// This string should always have the same content as the rope.
_string *str = str_create();
rope *r = rope_new();
const size_t max_stringsize = 1000;
uint8_t strbuffer[max_stringsize + 1];
for (int i = 0; i < 1000; i++) {
// First, some sanity checks.
check(r, (char *)str->mem);
rope *r2 = rope_copy(r);
check(r2, (char *)str->mem);
rope_free(r2);
// printf("String contains '%s'\n", str->mem);
test(rope_byte_count(r) == str->len);
size_t len = strlen_utf8(str->mem);
test(rope_char_count(r) == len);
test(str_num_chars(str) == len);
if (len == 0 || rand_float() < 0.5f) {
// Insert.
//uint8_t *text = random_ascii_string(11);
random_unicode_string(strbuffer, 1 + random() % max_stringsize);
size_t pos = random() % (len + 1);
// printf("inserting %s at %zd\n", strbuffer, pos);
rope_insert(r, pos, strbuffer);
str_insert(str, pos, strbuffer);
} else {
// Delete
size_t pos = random() % len;
size_t dellen = random() % 10;
dellen = MIN(len - pos, dellen);
// printf("deleting %zd chars at %zd\n", dellen, pos);
//deletedText = str[pos...pos + length]
//test.strictEqual deletedText, r.substring pos, length
rope_del(r, pos, dellen);
str_del(str, pos, dellen);
}
}
rope_free(r);
str_destroy(str);
}
void
svec_del( SVec v )
{
int i;
for ( i=0 ; i < v->fEntries ; i++ ) {
str_del( v->fV[i] );
}
free( (void *) v->fV );
free( (void *) v );
}
/*
* NAME: del_lhs()
* DESCRIPTION: delete the left-hand side in an assignment
*/
static void del_lhs(dataspace *data, value *lhs)
{
string *str;
array *arr;
switch (lhs->type) {
case T_STRING:
str = lhs->u.string;
if (str->primary != (strref *) NULL && str->primary->data == data) {
/* in this object */
if (--(str->primary->ref) == 0) {
str->primary->str = (string *) NULL;
str->primary = (strref *) NULL;
str_del(str);
data->plane->schange++; /* last reference removed */
}
data->plane->flags |= MOD_STRINGREF;
} else {
/* not in this object: deref imported string */
data->plane->schange--;
}
break;
case T_ARRAY:
case T_MAPPING:
case T_LWOBJECT:
arr = lhs->u.array;
if (arr->primary->data == data) {
/* in this object */
if (arr->primary->arr != (array *) NULL) {
/* swapped in */
data->plane->flags |= MOD_ARRAYREF;
if ((--(arr->primary->ref) & ~ARR_MOD) == 0) {
d_get_elts(arr);
arr->primary->arr = (array *) NULL;
arr->primary = &arr->primary->plane->alocal;
arr_del(arr);
data->plane->achange++;
}
} else {
/* deref new array */
data->plane->achange--;
}
} else {
/* not in this object: deref imported array */
data->plane->imports--;
data->plane->achange--;
}
break;
}
}
/*
* NAME: rule->clear()
* DESCRIPTION: free all rules
*/
static void rl_clear(rlchunk *c)
{
rlchunk *f;
rule *rl;
int i;
while (c != (rlchunk *) NULL) {
for (rl = c->rl, i = c->chunksz; i != 0; rl++, --i) {
if (rl->symb != (string *) NULL) {
str_del(rl->symb);
}
if (rl->type == RULE_REGEXP && rl->u.rgx != (string *) NULL) {
str_del(rl->u.rgx);
}
if (rl->func != (string *) NULL) {
str_del(rl->func);
}
}
f = c;
c = c->next;
FREE(f);
}
}
/*
* NAME: strchunk->clean()
* DESCRIPTION: remove string chunks, and strings, from memory
*/
static void sc_clean(strchunk *c)
{
strchunk *f;
int i;
while (c != (strchunk *) NULL) {
for (i = c->chunksz; --i >= 0; ) {
str_del(c->str[i]);
}
f = c;
c = c->next;
FREE(f);
}
}
/*
* NAME: path->include()
* DESCRIPTION: resolve an include path
*/
char *path_include(char *buf, char *from, char *file, string ***strs, int *nstr)
{
frame *f;
int i;
value *v;
string **str;
*strs = NULL;
*nstr = 0;
if (c_autodriver()) {
return path_from(buf, from, file);
}
f = cframe;
PUSH_STRVAL(f, str_new(from, strlen(from)));
PUSH_STRVAL(f, str_new(file, (long) strlen(file)));
if (!call_driver_object(f, "include_file", 2)) {
f->sp++;
return path_from(buf, from, file);
}
if (f->sp->type == T_STRING) {
/* simple path */
path_resolve(buf, f->sp->u.string->text);
str_del((f->sp++)->u.string);
return buf;
} else if (f->sp->type == T_ARRAY) {
/*
* Array of strings. Check that the array does indeed contain only
* strings, then return it.
*/
i = f->sp->u.array->size;
if (i != 0) {
v = d_get_elts(f->sp->u.array);
while ((v++)->type == T_STRING) {
if (--i == 0) {
*nstr = i = f->sp->u.array->size;
str = ALLOC(string*, i);
do {
str_ref(*str++ = (--v)->u.string);
} while (--i != 0);
*strs = str;
arr_del((f->sp++)->u.array);
/* return the untranslated path, as well */
return path_from(buf, from, file);
}
}
/*
* NAME: path->ed_write()
* DESCRIPTION: resolve an editor write file path
*/
char *path_ed_write(char *buf, char *file)
{
frame *f;
f = cframe;
if (OBJR(f->oindex)->flags & O_DRIVER) {
return path_resolve(buf, file);
} else {
PUSH_STRVAL(f, str_new(file, (long) strlen(file)));
call_driver_object(f, "path_write", 1);
if (f->sp->type != T_STRING) {
i_del_value(f->sp++);
return (char *) NULL;
}
path_resolve(buf, f->sp->u.string->text);
str_del((f->sp++)->u.string);
return buf;
}
}
void lex_del(lexer * lex) {
if(0 == lex) { return; }
scr_del(lex->s);
str_del(lex->tok_buf);
mem_free(lex);
}
int vfu_get_dir_name( const char *prompt, VString &target, int should_exist )
{
int res = -1;
/*
#ifdef _TARGET_UNIX_
leaveok(stdscr, FALSE);
#endif
*/
VArray dir_list;
say1(prompt);
say2("");
int pos = 0;
int page = 0;
int ch = 0;
int insert = 1;
int firsthit = 1;
pos = str_len( target );
//------------------------------------------------------------------
con_cshow();
say2( target, firsthit ? cINPUT2 : cINPUT );
while(1)
{
int mx = con_max_x() - 1;
VString target_out = target;
if ( (pos < page) || (pos+1 > page + mx) || (page > 0 && pos == page) )
page = pos - mx / 2;
if ( page < 0 ) page = 0;
str_trim_left( target_out, page );
str_sleft( target_out, mx );
str_pad( target_out, -mx );
if ( page > 0 )
str_set_ch( target_out, 0, '<' );
if ( str_len( target ) - page > mx )
str_set_ch( target_out, mx-1, '>' );
say2( target_out, firsthit ? cINPUT2 : cINPUT );
con_xy( pos-page+1, con_max_y() );
if (ch == 0) ch = con_getch();
if (ch == '\\') ch = '/'; /* dos hack :)) */
if ( ch == '/' && str_find( target, '/' ) == -1 && target[0] == '~' )
{
target = tilde_expand( target );
str_fix_path( target );
pos = str_len( target );
ch = 0;
}
if ((ch == 8 || ch == KEY_BACKSPACE) && pos > 0)
{
pos--;
str_del( target, pos, 1 );
}
else
if (ch == KEY_CTRL_A && str_len( target ) > 0)
{
int z = str_len( target )-1;
if ( str_get_ch(target, z) == '/' ) z--;
while ( z > 0 && str_get_ch(target,z) != '/' ) z--;
z++;
str_sleft(target,z);
pos = z;
}
else
if ( ch == 9 && str_len( target ) > 0)
{
int z;
dir_list.undef();
VString dmain; /* main/base path */
VString dtail; /* item that should be expanded/glob */
dmain = str_file_path( target );
dtail = str_file_name_ext( target );
/*
int lastslash = str_rfind(target, '/');
if ( lastslash == -1 )
{
dmain = "";
dtail = target;
}
else
{
dmain = target;
dtail = target;
str_sleft( dmain, lastslash+1 );
str_trim_left( dtail, lastslash+1 );
}
*/
__glob_gdn( dmain, dtail, dir_list );
z = dir_list.count()-1;
if (dir_list.count())
{
if ( dir_list.count() > 1)
{
int mc = 0; /* match count */
int mi = 0; /* match letter index */
while(4)
{
mc = 0;
int li; /* counter */
for ( li = 0; li < dir_list.count(); li++ )
{
if ( str_get_ch( dir_list[ 0], mi ) ==
str_get_ch( dir_list[li], mi ) )
mc++;
}
if ( mc != dir_list.count() )
break;
mi++;
}
target.setn( dmain + dir_list[0], str_len( dmain ) + mi );
pos = str_len( target );
say2( target, cINPUT );
con_xy( pos+1, con_max_y() );
vfu_beep();
ch = con_getch();
if ( ch != 9 ) { dir_list.undef(); continue; }
dir_list.sort();
con_chide();
z = vfu_menu_box( 10, 5, "Complete...", &dir_list );
con_cshow();
ch = 0;
}
else
ch = 0;
if ( z != -1 )
{
while( str_len( target ) > 0 && target[-1] != '/' )
str_chop( target );
target += dir_list[z];
}
pos = str_len( target );
dir_list.undef();
if (ch != 0) continue;
}
else
{ /* no match found -- cannot complete */
vfu_beep();
}
}
else
if (ch == 13)
{
res = 1;
break;
}
else
if (ch == 27)
{
target = "";
res = 0;
break;
}
if (ch == KEY_CTRL_U)
{
target = "";
pos = 0;
}
else
if (ch == KEY_CTRL_X)
{
char t[MAX_PATH];
if ( target[0] == '~' )
target = tilde_expand( target );
expand_path( target, t );
str_fix_path( t );
target = t;
pos = str_len( target );
}
else
if (ch >= 32 && ch <= 255 ) // && pos < 70)
{
if (firsthit)
{
target = "";
pos = 0;
}
if (!insert) str_del( target, pos, 1 );
str_ins_ch( target, pos, ch );
pos++;
} else
if( ch == KEY_LEFT )
{
if (pos > 0)
pos--;
} else
if( ch == KEY_RIGHT )
{
if (pos < str_len( target ))
pos++;
} else
if ( ch == KEY_IC ) insert = !insert; else
if ( ch == KEY_HOME ) pos = 0; else
if ( ch == KEY_END ) pos = str_len(target); else
if ( ch == KEY_DC && pos < str_len(target) )
str_del( target, pos, 1 ); else
if ( ch == KEY_NPAGE || ch == KEY_PPAGE )
{
con_chide();
int zz = vfu_hist_menu( 5, 5, ( ch == KEY_PPAGE ) ? "Dir Entry History" : "ChDir History",
( ch == KEY_PPAGE ) ? HID_GETDIR : HID_CHDIR );
con_cshow();
if (zz != -1)
{
const char* pc = vfu_hist_get( ( ch == KEY_PPAGE ) ? HID_GETDIR : HID_CHDIR, zz );
if ( pc )
{
target = pc;
pos = str_len( target );
}
}
}
ch = 0;
firsthit = 0;
}
con_chide();
//------------------------------------------------------------------
str_cut_spc( target );
if ( res == 1 && target[0] == '~' )
{
target = tilde_expand( target );
str_fix_path( target );
}
/*
if ( target.len() > 0 )
{
// well this tmp is kind of s... ama k'vo da pravi chovek :)
// FIXME: dos version?
if ( __ExpandGetDirName && target[0] != '/'
#ifdef _TARGET_GO32_
&& !( target[1] == ':' && target[2] == '/' )
#endif
)
target = CPath + target;
StrFixPath( target ); // add trailing slash if not exist
}
*/
/*
#ifdef _TARGET_UNIX_
leaveok(stdscr, TRUE);
#endif
*/
if ( res == 1 && str_len( target ) > 0 && should_exist && !dir_exist( target ))
{
vfu_beep();
int ch = tolower( vfu_ask( "Directory does not exist! Create? "
"( ENTER=Yes, ESC=cancel )",
"\033\rcC" ));
if ( ch == 27 )
{
res = 0;
target = "";
}
else
if ( ch == 13 )
if (make_path( target ))
{
if(tolower(
vfu_ask( "Cannot create path! ( ESC=cancel, C=continue-anyway )",
"\033Cc" )) == 27)
{
res = 0;
target = "";
}
}
}
say1(" ");
say2(" ");
if ( str_len( target ) > 0)
{
str_fix_path( target );
vfu_hist_add( HID_GETDIR, target );
}
str_cut_spc( target );
ASSERT( res == 0 || res == 1 );
return res;
}
int TextInput( int x, int y, const char *prompt, int maxlen, int fieldlen, VString *strres, void (*handlekey)( int key, VString &s, int &pos ) )
{
int res = 0;
int insert = 1;
VString str = *strres;
VString tmp;
int ch;
ScrollPos scroll;
scroll.set_min_max( 0, str_len( str ) );
scroll.set_pagesize( fieldlen );
scroll.go( str_len(str) );
int show = 1;
int firsthit = 1;
int opage = -1;
con_cshow();
while(1)
{
if (opage != scroll.page()) show = 1;
if (show)
{
str_copy( tmp, str, scroll.page(), scroll.pagesize() );
str_pad( tmp, -scroll.pagesize() );
tmp = " " + tmp + " ";
if ( scroll.page() > 0 ) str_set_ch( tmp, 0, '<' );
if ( scroll.page()+scroll.pagesize() < str_len(str) ) str_set_ch( tmp, str_len(tmp)-1, '>' );
con_out(x, y, tmp, firsthit ? EditStrFH : EditStrBF );
show = 0;
opage = scroll.page();
}
con_xy( x + scroll.pos() - scroll.page() + 1 , y );
ch = con_getch();
if( ch >= 32 && ch <= 255 && ch != KEY_BACKSPACE && str_len(str) < maxlen - 1 )
{
if (firsthit)
{
str = "";
scroll.go(0);
firsthit = 0;
}
if (!insert) str_del( str, scroll.pos(), 1 );
str_ins_ch( str, scroll.pos(), ch );
scroll.set_min_max( 0, str_len( str ) );
scroll.go( scroll.pos() );
scroll.down();
show = 1;
};
if (firsthit)
{
show = 1;
firsthit = 0;
}
if( ch == 27 )
{
res = 0;
break;
} else
if( ch == 13 )
{
*strres = str;
res = 1;
break;
} else
if( ch == KEY_CTRL_U )
{
scroll.go(0);
str = "";
show = 1;
} else
if( (ch == KEY_BACKSPACE || ch == 8 ) && (scroll.pos() > 0) )
{
scroll.up();
str_del( str, scroll.pos(), 1 );
show = 1;
} else
if ( ch == KEY_IC ) insert = !insert; else
if ( ch == KEY_LEFT ) scroll.up(); else
if ( ch == KEY_RIGHT ) scroll.down(); else
/*
if ( ch == KEY_PPAGE ) scroll.ppage(); else
if ( ch == KEY_NPAGE ) scroll.npage(); else
*/
if ( ch == KEY_HOME || ch == KEY_CTRL_A ) scroll.go(0); else
if ( ch == KEY_END || ch == KEY_CTRL_E ) scroll.go(str_len(str)); else
if ( ( ch == KEY_DC || ch == KEY_CTRL_D ) && scroll.pos() < str_len(str) )
{
str_del( str, scroll.pos(), 1 );
show = 1;
} else
if ( handlekey )
{
int npos = scroll.pos();
handlekey( ch, str, npos );
scroll.set_min_max( 0, str_len( str ) );
scroll.go( scroll.pos() );
if (scroll.pos() != npos) scroll.go( npos );
show = 1;
}
scroll.set_min_max( 0, str_len( str ) );
scroll.go( scroll.pos() );
}
con_chide();
return res;
}
/*
* NAME: data->discard_plane()
* DESCRIPTION: discard the current data plane without committing it
*/
void d_discard_plane(Int level)
{
dataplane *p;
dataspace *data;
value *v;
Uint i;
for (p = plist; p != (dataplane *) NULL && p->level == level; p = p->plist)
{
/*
* discard changes except for callout mods
*/
p->prev->flags |= p->flags & (MOD_CALLOUT | MOD_NEWCALLOUT);
data = p->alocal.data;
if (p->original != (value *) NULL) {
/* restore original variable values */
for (v = data->variables, i = data->nvariables; i != 0; --i, v++) {
i_del_value(v);
}
memcpy(data->variables, p->original,
data->nvariables * sizeof(value));
FREE(p->original);
}
if (p->coptab != (coptable *) NULL) {
/* undo callout changes */
discard_callouts(p);
if (p->prev == &data->base) {
cop_clean(p);
} else {
p->prev->coptab = p->coptab;
}
}
arr_discard(&p->achunk);
if (p->arrays != (arrref *) NULL) {
arrref *a;
/* delete new array refs */
for (a = p->arrays, i = data->narrays; i != 0; a++, --i) {
if (a->arr != (array *) NULL) {
arr_del(a->arr);
}
}
FREE(p->arrays);
/* fix old ones */
for (a = p->prev->arrays, i = data->narrays; i != 0; a++, --i) {
if (a->arr != (array *) NULL) {
a->arr->primary = a;
}
}
}
if (p->strings != (strref *) NULL) {
strref *s;
/* delete new string refs */
for (s = p->strings, i = data->nstrings; i != 0; s++, --i) {
if (s->str != (string *) NULL) {
str_del(s->str);
}
}
FREE(p->strings);
/* fix old ones */
for (s = p->prev->strings, i = data->nstrings; i != 0; s++, --i) {
if (s->str != (string *) NULL) {
s->str->primary = s;
}
}
}
data->plane = p->prev;
plist = p->plist;
FREE(p);
}
}
static void _scr_del_str(string_script * scr) {
if(!scr) { return; }
str_del(scr->s);
mem_free(scr);
}
/*
* NAME: data->commit_plane()
* DESCRIPTION: commit the current data plane
*/
void d_commit_plane(Int level, value *retval)
{
dataplane *p, *commit, **r, **cr;
dataspace *data;
value *v;
Uint i;
dataplane *clist;
/*
* pass 1: construct commit planes
*/
clist = (dataplane *) NULL;
cr = &clist;
for (r = &plist, p = *r; p != (dataplane *) NULL && p->level == level;
r = &p->plist, p = *r) {
if (p->prev->level != level - 1) {
/* insert commit plane */
commit = ALLOC(dataplane, 1);
commit->level = level - 1;
commit->original = (value *) NULL;
commit->alocal.arr = (array *) NULL;
commit->alocal.plane = commit;
commit->alocal.data = p->alocal.data;
commit->alocal.state = AR_CHANGED;
commit->arrays = p->arrays;
commit->achunk = p->achunk;
commit->strings = p->strings;
commit->coptab = p->coptab;
commit->prev = p->prev;
*cr = commit;
cr = &commit->plist;
p->prev = commit;
} else {
p->flags |= PLANE_MERGE;
}
}
if (clist != (dataplane *) NULL) {
/* insert commit planes in plane list */
*cr = p;
*r = clist;
}
clist = *r; /* sentinel */
/*
* pass 2: commit
*/
for (p = plist; p != clist; p = p->plist) {
/*
* commit changes to previous plane
*/
data = p->alocal.data;
if (p->original != (value *) NULL) {
if (p->level == 1 || p->prev->original != (value *) NULL) {
/* free backed-up variable values */
for (v = p->original, i = data->nvariables; i != 0; v++, --i) {
i_del_value(v);
}
FREE(p->original);
} else {
/* move originals to previous plane */
p->prev->original = p->original;
}
commit_values(data->variables, data->nvariables, level - 1);
}
if (p->coptab != (coptable *) NULL) {
/* commit callout changes */
commit_callouts(p, p->flags & PLANE_MERGE);
if (p->level == 1) {
cop_clean(p);
} else {
p->prev->coptab = p->coptab;
}
}
arr_commit(&p->achunk, p->prev, p->flags & PLANE_MERGE);
if (p->flags & PLANE_MERGE) {
if (p->arrays != (arrref *) NULL) {
arrref *a;
/* remove old array refs */
for (a = p->prev->arrays, i = data->narrays; i != 0; a++, --i) {
if (a->arr != (array *) NULL) {
if (a->arr->primary == &p->alocal) {
a->arr->primary = &p->prev->alocal;
}
arr_del(a->arr);
}
}
FREE(p->prev->arrays);
p->prev->arrays = p->arrays;
}
if (p->strings != (strref *) NULL) {
strref *s;
/* remove old string refs */
for (s = p->prev->strings, i = data->nstrings; i != 0; s++, --i)
{
if (s->str != (string *) NULL) {
str_del(s->str);
}
}
FREE(p->prev->strings);
p->prev->strings = p->strings;
}
}
}
commit_values(retval, 1, level - 1);
/*
* pass 3: deallocate
*/
for (p = plist; p != clist; p = plist) {
p->prev->flags = (p->flags & MOD_ALL) | MOD_SAVE;
p->prev->schange = p->schange;
p->prev->achange = p->achange;
p->prev->imports = p->imports;
p->alocal.data->plane = p->prev;
plist = p->plist;
FREE(p);
}
}
