void ATmarkArray(ATerm *start, int size)
{
if ( at_mark_young == ATtrue )
{
mark_memory_young(start,start+size);
} else {
mark_memory(start,start+size);
}
}
VOIDCDECL mark_phase()
{
unsigned int i,j;
unsigned long stack_size;
ATerm *stackTop;
ATerm *start, *stop;
ProtEntry *prot;
#ifdef WIN32
unsigned int r_eax, r_ebx, r_ecx, r_edx, \
r_esi, r_edi, r_esp, r_ebp;
ATerm reg[8], *real_term;
__asm {
/* Get the registers into local variables to check them
for aterms later. */
mov r_eax, eax
mov r_ebx, ebx
mov r_ecx, ecx
mov r_edx, edx
mov r_esi, esi
mov r_edi, edi
mov r_esp, esp
mov r_ebp, ebp
}
/* Put the register-values into an array */
reg[0] = (ATerm) r_eax;
reg[1] = (ATerm) r_ebx;
reg[2] = (ATerm) r_ecx;
reg[3] = (ATerm) r_edx;
reg[4] = (ATerm) r_esi;
reg[5] = (ATerm) r_edi;
reg[6] = (ATerm) r_esp;
reg[7] = (ATerm) r_ebp;
for(i=0; i<8; i++) {
real_term = AT_isInsideValidTerm(reg[i]);
if (real_term != NULL) {
AT_markTerm(real_term);
}
if (AT_isValidSymbol((Symbol)reg[i])) {
AT_markSymbol((Symbol)reg[i]);
}
}
/* The register variables are on the stack aswell
I set them to zero so they won't be processed again when
the stack is traversed. The reg-array is also in the stack
but that will be adjusted later */
r_eax = 0;
r_ebx = 0;
r_ecx = 0;
r_edx = 0;
r_esi = 0;
r_edi = 0;
r_esp = 0;
r_ebp = 0;
#else
sigjmp_buf env;
/* Traverse possible register variables */
sigsetjmp(env,0);
start = (ATerm *)((char *)env);
stop = ((ATerm *)(((char *)env) + sizeof(sigjmp_buf)));
mark_memory(start, stop);
#endif
stackTop = stack_top();
start = MIN(stackTop, stackBot);
stop = MAX(stackTop, stackBot);
stack_size = stop-start;
STATS(stack_depth, stack_size);
mark_memory(start, stop);
/* Traverse protected terms */
for(i=0; i<at_prot_table_size; i++) {
ProtEntry *cur = at_prot_table[i];
while(cur) {
for(j=0; j<cur->size; j++) {
if(cur->start[j])
AT_markTerm(cur->start[j]);
}
cur = cur->next;
}
}
for (prot=at_prot_memory; prot != NULL; prot=prot->next) {
mark_memory((ATerm *)prot->start, (ATerm *)(((char *)prot->start) + prot->size));
}
AT_markProtectedSymbols();
/* Mark 'parked' symbol */
if (AT_isValidSymbol(at_parked_symbol)) {
AT_markSymbol(at_parked_symbol);
}
}
int
folder_menu(char *path, int mode)
{
FILE *folder;
register article_header *ah;
news_header_buffer dgbuf;
char buffer[256];
int more, length, re, menu_cmd, was_raw;
memory_marker mem_marker;
group_header fake_group;
int cc_save;
char folder_name[FILENAME], folder_file[FILENAME];
int orig_layout;
char *orig_hdr_lines;
orig_layout = fmt_linenum;
orig_hdr_lines = header_lines;
strcpy(folder_name, path);
fake_group.group_name = folder_name;
fake_group.kill_list = NULL;
if (!expand_file_name(folder_file, folder_name, 1))
return ME_NO_REDRAW;
fake_group.archive_file = path = folder_file;
fake_group.next_group = fake_group.prev_group = NULL;
fake_group.group_flag = G_FOLDER | G_FAKED;
fake_group.master_flag = 0;
fake_group.save_file = NULL;
current_group = NULL;
init_group(&fake_group);
folder = open_file(path, OPEN_READ);
if (folder == NULL) {
msg("%s not found", path);
return ME_NO_REDRAW;
}
switch (get_folder_type(folder)) {
case 0:
msg("Reading: %-.65s", path);
break;
case 1:
case 2:
msg("Reading %s folder: %-.50s",
current_folder_type == 1 ? "mail" : "mmdf", path);
break;
default:
msg("Folder is empty");
fclose(folder);
return ME_NO_REDRAW;
}
rewind(folder);
was_raw = no_raw();
s_keyboard = 0;
current_group = &fake_group;
mark_memory(&mem_marker);
ah = alloc_art();
more = 1;
while (more && (more = get_digest_article(folder, dgbuf)) >= 0) {
if (s_keyboard)
break;
ah->a_number = 0;
ah->flag = A_FOLDER;
ah->attr = 0;
ah->lines = digest.dg_lines;
ah->hpos = digest.dg_hpos;
ah->fpos = digest.dg_fpos;
ah->lpos = digest.dg_lpos;
if (digest.dg_from) {
length = pack_name(buffer, digest.dg_from, Name_Length);
ah->sender = alloc_str(length);
strcpy(ah->sender, buffer);
ah->name_length = length;
if (mode == 1)
fold_string(ah->sender);
} else {
ah->sender = "";
ah->name_length = 0;
}
if (digest.dg_subj) {
length = pack_subject(buffer, digest.dg_subj, &re, 255);
ah->replies = re;
ah->subject = alloc_str(length);
strcpy(ah->subject, buffer);
ah->subj_length = length;
if (mode == 1 && length > 1)
fold_string(ah->subject + 1);
} else {
ah->replies = 0;
ah->subject = "";
ah->subj_length = 0;
}
ah->t_stamp = digest.dg_date ? pack_date(digest.dg_date) : 0;
add_article(ah);
ah = alloc_art();
}
fclose(folder);
if (s_keyboard) {
menu_cmd = ME_NO_REDRAW;
} else if (n_articles == 0) {
msg("Not a folder (no article header)");
menu_cmd = ME_NO_REDRAW;
} else {
if (n_articles > 1) {
clrdisp();
prompt_line = 2;
if (mode == 0 && !dont_sort_folders)
sort_articles(-1);
else if (mode == 1) {
article_number n;
for (n = 0; n < n_articles; n++) {
ah = articles[n];
if (n == 0)
ah->flag |= A_ROOT_ART;
else if (strcmp(ah->sender, articles[n - 1]->sender) == 0)
articles[n - 1]->flag |= A_NEXT_SAME;
else
ah->flag |= A_ROOT_ART;
}
bypass_consolidation = consolidated_manual ? 2 : 1;
} else
no_sort_articles();
} else
no_sort_articles();
cc_save = cancel_count;
cancel_count = 0;
if (mode == 1) {
fmt_linenum = -1;
header_lines = "*";
}
reenter_menu:
ignore_fancy_select = 1;
menu_cmd = menu(folder_header);
ignore_fancy_select = 0;
if (mode == 0 && cancel_count) {
register article_number cur;
cancel_count = 0;
for (cur = 0; cur < n_articles; cur++) {
if (articles[cur]->attr == A_CANCEL)
cancel_count++;
}
}
if (mode == 0 && cancel_count) {
clrdisp();
tprintf("\rFolder: %s\n\rFile: %s\n\n\r", folder_name, folder_file);
if (cancel_count == n_articles)
tprintf("Cancel all articles and remove folder? ");
else
tprintf("Remove %d article%s from folder? ",
cancel_count, plural((long) cancel_count));
fl;
switch (yes(1)) {
case 1:
tprintf("\n\n");
if (cancel_count == n_articles) {
if (unlink(group_path_name) < 0 &&
nn_truncate(group_path_name, (off_t) 0) < 0) {
tprintf("\rCould not unlink %s\n\r", group_path_name);
any_key(0);
}
} else
rewrite_folder();
break;
case 0:
break;
default:
goto reenter_menu;
}
}
cancel_count = cc_save;
}
release_memory(&mem_marker);
if (fmt_linenum == -1) {
fmt_linenum = orig_layout;
header_lines = orig_hdr_lines;
}
if (was_raw)
nn_raw();
return menu_cmd;
}
static void
mark_stack (void)
{
void *end;
mark_memory (stack_base, &end);
}
