static void list_cat_anything(t_list_cat *x, t_symbol *s,
int argc, t_atom *argv)
{
t_atom *outv;
int outc = x->x_alist.l_n + argc + 1;
XL_ATOMS_ALLOCA(outv, outc);
SETSYMBOL(outv + x->x_alist.l_n, s);
atoms_copy(argc, argv, outv + x->x_alist.l_n + 1);
if (x->x_alist.l_npointer)
{
t_alist y;
alist_clone(&x->x_alist, &y);
alist_toatoms(&y, outv);
outlet_list(x->x_obj.ob_outlet, &s_list, outc, outv);
alist_clear(&y);
}
else
{
alist_toatoms(&x->x_alist, outv);
outlet_list(x->x_obj.ob_outlet, &s_list, outc, outv);
}
if (x->x_alist.l_n <= 1)
alist_anything(&x->x_alist, s, outc, outv);
else
alist_list(&x->x_alist, s, outc, outv);
XL_ATOMS_FREEA(outv, outc);
}
static void CLEARBUFF(uint32_t w1, uint32_t w2)
{
uint16_t dmem = w1;
uint16_t count = w2;
alist_clear(dmem & ~3, (count + 3) & ~3);
}
static void CLEARBUFF(struct hle_t* hle, uint32_t w1, uint32_t w2)
{
uint16_t dmem = w1 + DMEM_BASE;
uint16_t count = w2;
if (count == 0)
return;
alist_clear(hle, dmem, align(count, 16));
}
static void list_prepend_list(t_list_prepend *x, t_symbol *s,
int argc, t_atom *argv)
{
t_atom *outv;
int outc = x->x_alist.l_n + argc;
XL_ATOMS_ALLOCA(outv, outc);
atoms_copy(argc, argv, outv + x->x_alist.l_n);
if (x->x_alist.l_npointer)
{
t_alist y;
alist_clone(&x->x_alist, &y);
alist_toatoms(&y, outv);
outlet_list(x->x_obj.ob_outlet, &s_list, outc, outv);
alist_clear(&y);
}
else
{
alist_toatoms(&x->x_alist, outv);
outlet_list(x->x_obj.ob_outlet, &s_list, outc, outv);
}
XL_ATOMS_FREEA(outv, outc);
}
void alist_list(t_alist *x, t_symbol *s, int argc, t_atom *argv)
{
int i;
alist_clear(x);
if (!(x->l_vec = (t_listelem *)getbytes(argc * sizeof(*x->l_vec))))
{
x->l_n = 0;
error("list_alloc: out of memory");
return;
}
x->l_n = argc;
x->l_npointer = 0;
for (i = 0; i < argc; i++)
{
x->l_vec[i].l_a = argv[i];
if (x->l_vec[i].l_a.a_type == A_POINTER)
{
x->l_npointer++;
gpointer_copy(x->l_vec[i].l_a.a_w.w_gpointer, &x->l_vec[i].l_p);
x->l_vec[i].l_a.a_w.w_gpointer = &x->l_vec[i].l_p;
}
}
}
static void list_append_anything(t_list_append *x, t_symbol *s,
int argc, t_atom *argv)
{
t_atom *outv;
int n, outc = x->x_alist.l_n + argc + 1;
ATOMS_ALLOCA(outv, outc);
SETSYMBOL(outv, s);
atoms_copy(argc, argv, outv + 1);
if (x->x_alist.l_npointer)
{
t_alist y;
alist_clone(&x->x_alist, &y);
alist_toatoms(&y, outv + 1 + argc);
outlet_list(x->x_obj.ob_outlet, &s_list, outc, outv);
alist_clear(&y);
}
else
{
alist_toatoms(&x->x_alist, outv + 1 + argc);
outlet_list(x->x_obj.ob_outlet, &s_list, outc, outv);
}
ATOMS_FREEA(outv, outc);
}
static void list_prepend_free(t_list_prepend *x)
{
alist_clear(&x->x_alist);
}
static void list_cat_free(t_list_cat *x)
{
alist_clear(&x->x_alist);
}
void alist_delete(alist al)
{
assert(al != NULL);
alist_clear(al);
free(al);
}
int main(void)
{
alist al;
char *t1 = "def", *t2 = "abc", *t3 = "xyz";
char *s;
al = alist_new();
assert(alist_count(al) == 0);
assert(alist_current(al) == NULL);
assert(alist_current_idx(al) == -1);
alist_append(al, t1);
assert(alist_count(al) == 1);
assert(alist_current(al) == t1);
assert(alist_current_idx(al) == 0);
alist_append(al, t2);
assert(alist_count(al) == 2);
assert(alist_current(al) == t2);
assert(alist_current_idx(al) == 1);
s = alist_first(al);
assert(s == t1);
assert(alist_current(al) == t1);
assert(alist_current_idx(al) == 0);
s = alist_next(al);
assert(s == t2);
assert(alist_current(al) == t2);
assert(alist_current_idx(al) == 1);
s = alist_next(al);
assert(s == NULL);
assert(alist_current(al) == NULL);
assert(alist_current_idx(al) == -1);
alist_prepend(al, t3);
assert(alist_count(al) == 3);
assert(alist_current(al) == t3);
assert(alist_current_idx(al) == 0);
printf("elements:\n");
for (s = alist_first(al); s != NULL; s = alist_next(al))
printf("element %d: %s\n", alist_current_idx(al), s);
alist_sort(al, sorter);
printf("sorted elements:\n");
for (s = alist_first(al); s != NULL; s = alist_next(al))
printf("element %d: %s\n", alist_current_idx(al), s)
; assert(alist_at(al, 0) == t2);
assert(alist_at(al, 1) == t1);
assert(alist_at(al, 2) == t3);
alist_clear(al);
assert(alist_count(al) == 0);
assert(alist_current(al) == NULL);
assert(alist_current_idx(al) == -1);
alist_insert(al, 5, t1);
assert(alist_count(al) == 1);
assert(alist_current(al) == t1);
assert(alist_current_idx(al) == 0);
alist_insert(al, 0, t2);
assert(alist_count(al) == 2);
assert(alist_current(al) == t2);
assert(alist_current_idx(al) == 0);
alist_insert(al, 1, t3);
assert(alist_count(al) == 3);
assert(alist_at(al, 0) == t2);
assert(alist_at(al, 1) == t3);
assert(alist_at(al, 2) == t1);
assert(alist_current(al) == t3);
assert(alist_current_idx(al) == 1);
alist_delete(al);
printf("alist test successful.\n");
return 0;
}
void list_clear(llist* l)
{
lnode* nextnode;
register lnode* current;
current = l->head;
while (current) {
nextnode=current->next;
free(current->message);
free(current);
current=nextnode;
}
l->head = NULL;
l->cur = NULL;
l->cnt = 0;
l->e.milli = 0L;
l->e.sec = 0L;
l->e.serial = 0L;
free((char *)l->e.node);
l->e.node = NULL;
l->e.type = 0;
l->s.gid = -1;
l->s.egid = -1;
l->s.ppid = -1;
l->s.pid = -1;
l->s.success = S_UNSET;
l->s.uid = -1;
l->s.euid = -1;
l->s.loginuid = -2;
free(l->s.hostname);
l->s.hostname = NULL;
if (l->s.filename) {
slist_clear(l->s.filename);
free(l->s.filename);
l->s.filename = NULL;
}
free(l->s.terminal);
l->s.terminal = NULL;
free(l->s.cwd);
l->s.cwd = NULL;
free(l->s.exe);
l->s.exe = NULL;
if (l->s.key) {
slist_clear(l->s.key);
free(l->s.key);
l->s.key = NULL;
}
free(l->s.comm);
l->s.comm = NULL;
if (l->s.avc) {
alist_clear(l->s.avc);
free(l->s.avc);
l->s.avc = NULL;
}
free(l->s.acct);
l->s.acct = NULL;
l->s.arch = 0;
l->s.syscall = 0;
l->s.session_id = -2;
free(l->s.uuid);
l->s.uuid = NULL;
free(l->s.vmname);
l->s.vmname = NULL;
l->s.exit = 0;
l->s.exit_is_set = 0;
}
void stack_clear(stack_t* stack) {
alist_clear(stack);
}
/*
* Free everything that we allocated.
* Can be used to detect memory leaks, e.g., with ccmalloc.
* NOTE: This is tricky! Things are freed that functions depend on. Don't be
* surprised if Vim crashes...
* Some things can't be freed, esp. things local to a library function.
*/
void free_all_mem(void)
{
buf_T *buf, *nextbuf;
static int entered = FALSE;
/* When we cause a crash here it is caught and Vim tries to exit cleanly.
* Don't try freeing everything again. */
if (entered)
return;
entered = TRUE;
block_autocmds(); /* don't want to trigger autocommands here */
/* Close all tabs and windows. Reset 'equalalways' to avoid redraws. */
p_ea = FALSE;
if (first_tabpage->tp_next != NULL)
do_cmdline_cmd((char_u *)"tabonly!");
if (firstwin != lastwin)
do_cmdline_cmd((char_u *)"only!");
/* Free all spell info. */
spell_free_all();
/* Clear user commands (before deleting buffers). */
ex_comclear(NULL);
/* Clear menus. */
do_cmdline_cmd((char_u *)"aunmenu *");
do_cmdline_cmd((char_u *)"menutranslate clear");
/* Clear mappings, abbreviations, breakpoints. */
do_cmdline_cmd((char_u *)"lmapclear");
do_cmdline_cmd((char_u *)"xmapclear");
do_cmdline_cmd((char_u *)"mapclear");
do_cmdline_cmd((char_u *)"mapclear!");
do_cmdline_cmd((char_u *)"abclear");
do_cmdline_cmd((char_u *)"breakdel *");
do_cmdline_cmd((char_u *)"profdel *");
do_cmdline_cmd((char_u *)"set keymap=");
free_titles();
free_findfile();
/* Obviously named calls. */
free_all_autocmds();
clear_termcodes();
free_all_options();
free_all_marks();
alist_clear(&global_alist);
free_homedir();
free_users();
free_search_patterns();
free_old_sub();
free_last_insert();
free_prev_shellcmd();
free_regexp_stuff();
free_tag_stuff();
free_cd_dir();
free_signs();
set_expr_line(NULL);
diff_clear(curtab);
clear_sb_text(); /* free any scrollback text */
/* Free some global vars. */
vim_free(last_cmdline);
vim_free(new_last_cmdline);
set_keep_msg(NULL, 0);
/* Clear cmdline history. */
p_hi = 0;
init_history();
{
win_T *win;
tabpage_T *tab;
qf_free_all(NULL);
/* Free all location lists */
FOR_ALL_TAB_WINDOWS(tab, win)
qf_free_all(win);
}
/* Close all script inputs. */
close_all_scripts();
/* Destroy all windows. Must come before freeing buffers. */
win_free_all();
/* Free all buffers. Reset 'autochdir' to avoid accessing things that
* were freed already. */
p_acd = FALSE;
for (buf = firstbuf; buf != NULL; ) {
nextbuf = buf->b_next;
close_buffer(NULL, buf, DOBUF_WIPE, FALSE);
if (buf_valid(buf))
buf = nextbuf; /* didn't work, try next one */
else
buf = firstbuf;
}
free_cmdline_buf();
/* Clear registers. */
clear_registers();
ResetRedobuff();
ResetRedobuff();
/* highlight info */
free_highlight();
reset_last_sourcing();
free_tabpage(first_tabpage);
first_tabpage = NULL;
# ifdef UNIX
/* Machine-specific free. */
mch_free_mem();
# endif
/* message history */
for (;; )
if (delete_first_msg() == FAIL)
break;
eval_clear();
free_termoptions();
/* screenlines (can't display anything now!) */
free_screenlines();
clear_hl_tables();
vim_free(NameBuff);
}
