void exit_alias(void)
{
int i;
/* Clear the deletes from all aliases. */
for(i = 0; i < num_aliases; i++)
if (ison(aliases[i]->status, DELETED))
clearit(aliases[i]->status, DELETED);
dprint(6, (debugfile, "\nexit_alias: Done clearing deletes.\n"));
}
static void
delete_function()
{
char *str = XmTextGetString(function_name);
int warn = !!ison(glob_flags, WARNINGS);
ask_item = function_name;
turnon(glob_flags, WARNINGS);
(void) cmd_line(zmVaStr("\\function -d %s", str), NULL_GRP);
if (!warn)
turnoff(glob_flags, WARNINGS);
XtFree(str);
XmTextSetString(function_name, NULL);
XmTextSetString(script_input, NULL);
}
/*
* Make the current board setup. It picks a random pattern and
* calls ison() to determine if the character is on that pattern
* or not.
*/
makeboard()
{
reg int y, x;
reg LOCS *lp;
Pattern = rand() % MAXPATTERNS;
lp = Layout;
for (y = 0; y < NLINES; y++)
for (x = 0; x < NCOLS; x++)
if (ison(y, x)) {
lp->y = y;
lp->x = x;
lp++;
}
Numstars = lp - Layout;
}
int main(void)
{
int tree[SIZE] = { 0 };
int num, p = 0; /* the number and its position */
int i; /* just a counter */
srand( time(NULL) );
for(i = 1; i <= SIZE; i++) {
num = 1 + rand() % 20;
if( !ison(num, tree, SIZE) )
tree[p++] = num;
}
for(i = 0; i < SIZE; i++)
if(tree[i])
printf("%d ", tree[i]);
printf("\n");
return 0;
} /* E0F main */
static int add_alias(int replace, int to_replace)
{
/*
* Add an alias to the user alias text file. If there
* are aliases tagged, the user is asked if he wants to
* create a group alias from the tagged files.
*
* Return zero if alias not added in actuality.
*
* If replace == FALSE, then we will ask for the new
* aliasname.
*
* If replace == TRUE, then we are replacing the alias
* denoted by to_replace.
*
* Note that even if replace == FALSE, if the user types
* in the name of a current alias then we can still do
* a replacement.
*/
int i, ans;
int tagged = 0;
int leftoff = 0;
char aliasname[SLEN], firstname[SLEN], lastname[SLEN];
char address1[LONG_STRING], buffer[SLEN];
char comment[LONG_STRING];
char *ch_ptr;
/*
* See if there are any tagged aliases.
*/
for (i=0; i < num_aliases; i++) {
if (ison(aliases[i]->status, TAGGED)) {
if (tagged == 0) leftoff = i;
tagged++;
}
}
if (tagged == 1) {
/*
* There is only on alias tagged. Ask the question
* but the default response is NO.
*/
PutLine(LINES-2,0, catgets(elm_msg_cat,
AliasesSet, AliasesOneTagged,
"There is 1 alias tagged..."));
CleartoEOLN();
ans = enter_yn(catgets(elm_msg_cat, AliasesSet, AliasesCreateGroup,
"Create group alias?"), FALSE, LINES-3, FALSE);
}
else if (tagged > 1) {
/*
* If multiple tagged aliases then we assume the user
* wants to create a group alias. The default response
* is YES.
*/
PutLine(LINES-2,0, catgets(elm_msg_cat,
AliasesSet, AliasesManyTagged,
"There are %d aliases tagged..."), tagged);
CleartoEOLN();
ans = enter_yn(catgets(elm_msg_cat, AliasesSet, AliasesCreateGroup,
"Create group alias?"), TRUE, LINES-3, FALSE);
} else {
/*
* Nothing tagged ... thus nothing to make a group of.
*/
ans = FALSE;
}
/*
* If requested above, create the group alias address.
*/
if (ans) {
strcpy(address1, aliases[leftoff]->alias);
for (i=leftoff+1; i < num_aliases; i++) {
if (ison(aliases[i]->status, TAGGED)) {
strcat(address1, ",");
strcat(address1, aliases[i]->alias);
}
}
}
else {
tagged = 0;
}
/*
* Only ask for an aliasname if we are NOT replacing the
* current alias.
*/
if (replace) {
strcpy(aliasname, aliases[to_replace]->alias);
/*
* First, see if what we are replacing is a SYSTEM
* alias. If so, we need to ask a question.
*/
if(aliases[to_replace]->type & SYSTEM) {
dprint(3, (debugfile,
"Aliasname [%s] is SYSTEM in add_alias\n", aliasname));
/*
* If they don't want to superceed the SYSTEM alias then
* just return.
*/
if( ! superceed_system(to_replace)) {
ClearLine(LINES-2);
return(0);
}
}
}
else {
strcpy(buffer, catgets(elm_msg_cat,
AliasesSet, AliasesEnterAliasName, "Enter alias name: "));
PutLine(LINES-2,0, buffer);
CleartoEOLN();
*aliasname = '\0';
if ((replace = get_aliasname(aliasname, buffer, &to_replace)) < 0) {
dprint(3, (debugfile,
"Aliasname [%s] was rejected in add_alias\n", aliasname));
ClearLine(LINES-2);
return(0);
}
}
/*
* If we are replacing an existing alias, we will assume that
* they might want to be just editing most of what is already
* there. So we copy some defaults from the existing alias.
*/
if (replace) {
strcpy(lastname, aliases[to_replace]->last_name);
strcpy(firstname, aliases[to_replace]->name);
ch_ptr = strstr(firstname, lastname);
*(ch_ptr-1) = '\0';
strcpy(comment, aliases[to_replace]->comment);
}
else {
*lastname = '\0';
*firstname = '\0';
*comment = '\0';
}
get_realnames(aliasname, firstname, lastname, comment, buffer);
/*
* Since there are no tagged aliases, we must ask for an
* address. If we are replacing, a default address is
* presented.
*/
if (tagged == 0) {
sprintf(buffer, catgets(elm_msg_cat,
AliasesSet, AliasesEnterAddress,
"Enter address for %s: "), aliasname);
PutLine(LINES-2, 0, buffer);
if (replace)
strcpy(address1, aliases[to_replace]->address);
else
*address1 = '\0';
if (enter_string(address1, sizeof(address1), -1, -1,
ESTR_REPLACE) < 0 || address1[0] == '\0') {
Raw(ON);
show_error(catgets(elm_msg_cat, AliasesSet, AliasesNoAddressSpec,
"No address specified!"));
return(0);
}
Raw(ON);
despace_address(address1);
clear_error(); /* Just in case */
}
if(ask_accept(aliasname, firstname, lastname, comment, address1,
buffer, replace, to_replace)) {
/*
* We can only clear the tags after we know that the
* alias was added. This allows the user to back out
* and rethink without losing the tags.
*/
if (tagged > 0) {
for (i=leftoff; i < num_aliases; i++) {
if (ison(aliases[i]->status, TAGGED)) {
clearit(aliases[i]->status, TAGGED);
show_msg_tag(i);
}
}
}
return(1);
}
else {
return(0);
}
}
static int ask_accept(char *aliasname, char *firstname, char *lastname,
char *comment, char *address, char *buffer,
int replace, int replacement)
{
int ans;
char *(old_alias[1]);
/*
* If firstname == lastname, they probably just took all
* the deafaults. We *assume* they don't want lastname
* entered twice, so we will truncate it.
*/
if (strcmp(firstname, lastname) == 0) {
*firstname = '\0';
}
if (strlen(firstname) == 0) {
strcpy(buffer, lastname);
}
else {
sprintf(buffer, "%s %s", firstname, lastname);
}
PutLine(LINES-1,0, catgets(elm_msg_cat, AliasesSet, AliasesAddressAs,
"Messages addressed as: %s (%s)"), address, buffer);
if (strlen(comment) != 0) {
strcat(buffer, ", ");
strcat(buffer, comment);
}
PutLine(LINES-2,0, catgets(elm_msg_cat, AliasesSet, AliasesAddressTo,
"New alias: %s is '%s'."), aliasname, buffer);
CleartoEOLN();
/*
* Kludge Alert: Spaces are padded to the front of the prompt
* to write over the previous question. Should probably record
* the end of the line, move to it, and CleartoEOLN() it.
*/
ans = enter_yn(catgets(elm_msg_cat, AliasesSet, AliasesAcceptNew,
" Accept new alias?"), TRUE, LINES-3, FALSE);
if(ans) {
if (replace) {
old_alias[0] = aliases[replacement]->alias;
/*
* First, clear flag if this is marked to be deleted.
* This prevents the problem where they marked it for
* deletion and then figured out that it could be
* c)hanged but didn't explicitly U)ndelete it. Without
* this test, the resync action would then delete
* the new alias we just so carefully added to the
* text file.
*/
if (ison(aliases[replacement]->status, DELETED)) {
clearit(aliases[replacement]->status, DELETED);
}
/*
* Changed aliases are given the NEW flag.
*/
setit(aliases[replacement]->status, NEW);
show_msg_status(replacement);
/*
* Now we can delete it...
*/
delete_from_alias_text(old_alias, 1);
/*
* Kludge Alert: We need to get the trailing comma
* (added in delete_from_alias_text()) off of the
* alias since the display won't be re-sync'd right
* away.
*/
*((old_alias[0])+strlen(old_alias[0])-1) = '\0';
}
add_to_alias_text(aliasname, firstname, lastname, comment, address);
}
ClearLine(LINES-2);
ClearLine(LINES-1);
return ans;
}
char *
REmatch(char *str, /* string to test */
size_t str_len, /* ...its length */
PTR machine, /* compiled regular expression */
size_t *lenp) /* where to return matched-length */
{
register STATE *m = (STATE *) machine;
char *s = str;
char *ss;
register RT_STATE *stackp;
int u_flag, t;
char *str_end = s + str_len;
RT_POS_ENTRY *sp;
char *ts;
/* state of current best match stored here */
char *cb_ss; /* the start */
char *cb_e = 0; /* the end , pts at first char not matched */
STATE *m_best = 0;
*lenp = 0;
/* check for the easy case */
if ((m + 1)->s_type == M_ACCEPT && m->s_type == M_STR) {
if ((ts = str_str(s, str_len, m->s_data.str, (size_t) m->s_len)))
*lenp = m->s_len;
return ts;
}
u_flag = U_ON;
cb_ss = ss = (char *) 0;
stackp = RE_run_stack_empty;
sp = RE_pos_stack_empty;
goto reswitch;
refill:
if (stackp == RE_run_stack_empty) {
if (cb_ss)
*lenp = (unsigned) (cb_e - cb_ss);
return cb_ss;
}
ss = stackp->ss;
s = (stackp--)->s;
if (cb_ss) { /* does new state start too late ? */
if (ss) {
if (cb_ss < ss || (cb_ss == ss && cb_e == str_end)) {
goto refill;
}
} else if (cb_ss < s || (cb_ss == s && cb_e == str_end)) {
goto refill;
}
}
m = (stackp + 1)->m;
sp = RE_pos_stack_base + (stackp + 1)->sp;
sp->prev_offset = (stackp + 1)->tp;
u_flag = (stackp + 1)->u;
reswitch:
switch (m->s_type + u_flag) {
case M_STR + U_OFF + END_OFF:
if (strncmp(s, m->s_data.str, (size_t) m->s_len)) {
goto refill;
}
if (!ss) {
if (cb_ss && s > cb_ss) {
goto refill;
} else {
ss = s;
}
}
s += m->s_len;
m++;
goto reswitch;
case M_STR + U_OFF + END_ON:
if (strcmp(s, m->s_data.str)) {
goto refill;
}
if (!ss) {
if (cb_ss && s > cb_ss) {
goto refill;
} else {
ss = s;
}
}
s += m->s_len;
m++;
goto reswitch;
case M_STR + U_ON + END_OFF:
if (s >= str_end) {
goto refill;
}
if (!(s = str_str(s, (size_t) (str_end - s), m->s_data.str, (size_t) m->s_len))) {
goto refill;
}
if (s >= str + strlen(str)) {
goto refill;
}
push(m, s + 1, sp, ss, U_ON);
if (!ss) {
if (cb_ss && s > cb_ss) {
goto refill;
} else {
ss = s;
}
}
s += m->s_len;
m++;
u_flag = U_OFF;
goto reswitch;
case M_STR + U_ON + END_ON:
t = (int) ((str_end - s) - m->s_len);
if (t < 0 || memcmp(ts = s + t, m->s_data.str, (size_t) m->s_len)) {
goto refill;
}
if (!ss) {
if (cb_ss && ts > cb_ss) {
goto refill;
} else {
ss = ts;
}
}
s = str_end;
m++;
u_flag = U_OFF;
goto reswitch;
case M_CLASS + U_OFF + END_OFF:
if (s >= str_end)
goto refill;
if (!ison(*m->s_data.bvp, s[0])) {
goto refill;
}
if (!ss) {
if (cb_ss && s > cb_ss) {
goto refill;
} else {
ss = s;
}
}
s++;
m++;
goto reswitch;
case M_CLASS + U_OFF + END_ON:
if (s >= str_end)
goto refill;
if (s[1] || !ison(*m->s_data.bvp, s[0])) {
goto refill;
}
if (!ss) {
if (cb_ss && s > cb_ss) {
goto refill;
} else {
ss = s;
}
}
s++;
m++;
goto reswitch;
case M_CLASS + U_ON + END_OFF:
if (s >= str_end)
goto refill;
while (!ison(*m->s_data.bvp, s[0])) {
if (s >= str_end) {
goto refill;
} else {
s++;
}
}
if (s >= str_end) {
goto refill;
}
s++;
push(m, s, sp, ss, U_ON);
if (!ss) {
if (cb_ss && s - 1 > cb_ss) {
goto refill;
} else {
ss = s - 1;
}
}
m++;
u_flag = U_OFF;
goto reswitch;
case M_CLASS + U_ON + END_ON:
if ((s >= str_end) || !ison(*m->s_data.bvp, str_end[-1])) {
goto refill;
}
if (!ss) {
if (cb_ss && str_end - 1 > cb_ss) {
goto refill;
} else {
ss = str_end - 1;
}
}
s = str_end;
m++;
u_flag = U_OFF;
goto reswitch;
case M_ANY + U_OFF + END_OFF:
if (s >= str_end) {
goto refill;
}
if (!ss) {
if (cb_ss && s > cb_ss) {
goto refill;
} else {
ss = s;
}
}
s++;
m++;
goto reswitch;
case M_ANY + U_OFF + END_ON:
if ((s >= str_end) || ((s + 1) < str_end)) {
goto refill;
}
if (!ss) {
if (cb_ss && s > cb_ss) {
goto refill;
} else {
ss = s;
}
}
s++;
m++;
goto reswitch;
case M_ANY + U_ON + END_OFF:
if (s >= str_end) {
goto refill;
}
s++;
push(m, s, sp, ss, U_ON);
if (!ss) {
if (cb_ss && s - 1 > cb_ss) {
goto refill;
} else {
ss = s - 1;
}
}
m++;
u_flag = U_OFF;
goto reswitch;
case M_ANY + U_ON + END_ON:
if (s >= str_end) {
goto refill;
}
if (!ss) {
if (cb_ss && str_end - 1 > cb_ss) {
goto refill;
} else {
ss = str_end - 1;
}
}
s = str_end;
m++;
u_flag = U_OFF;
goto reswitch;
case M_START + U_OFF + END_OFF:
case M_START + U_ON + END_OFF:
if (s != str) {
goto refill;
}
ss = s;
m++;
u_flag = U_OFF;
goto reswitch;
case M_START + U_OFF + END_ON:
case M_START + U_ON + END_ON:
if (s != str || (s < str_end)) {
goto refill;
}
ss = s;
m++;
u_flag = U_OFF;
goto reswitch;
case M_END + U_OFF:
if (s < str_end) {
goto refill;
}
if (!ss) {
if (cb_ss && s > cb_ss) {
goto refill;
} else {
ss = s;
}
}
m++;
goto reswitch;
case M_END + U_ON:
s = str_end;
if (!ss) {
if (cb_ss && s > cb_ss) {
goto refill;
} else {
ss = s;
}
}
m++;
u_flag = U_OFF;
goto reswitch;
CASE_UANY(M_U):
if (!ss) {
if (cb_ss && s > cb_ss) {
goto refill;
} else {
ss = s;
}
}
u_flag = U_ON;
m++;
goto reswitch;
CASE_UANY(M_1J):
m += m->s_data.jump;
goto reswitch;
CASE_UANY(M_SAVE_POS): /* save position for a later M_2JC */
/* see also REtest */
sp = RE_pos_push(sp, stackp, s);
m++;
goto reswitch;
CASE_UANY(M_2JA): /* take the non jump branch */
push(m + m->s_data.jump, s, sp, ss, u_flag);
m++;
goto reswitch;
CASE_UANY(M_2JC): /* take the jump branch if position changed */
/* see REtest */
if (RE_pos_pop(&sp, stackp) == s) {
m++;
goto reswitch;
}
/* fall thru */
CASE_UANY(M_2JB): /* take the jump branch */
push(m + 1, s, sp, ss, u_flag);
m += m->s_data.jump;
goto reswitch;
case M_ACCEPT + U_OFF:
if (!ss)
ss = s;
if (!cb_ss || ss < cb_ss || (ss == cb_ss && s > cb_e)) {
/* we have a new current best */
cb_ss = ss;
cb_e = s;
m_best = m;
}
goto refill;
case M_ACCEPT + U_ON:
if (!ss) {
ss = s;
} else {
s = str_end;
}
if (!cb_ss || ss < cb_ss || (ss == cb_ss && s > cb_e)) {
/* we have a new current best */
cb_ss = ss;
cb_e = s;
m_best = m;
}
goto refill;
default:
RE_panic("unexpected case in REmatch");
}
}
char *
REmatch(char *str, /* string to test */
unsigned str_len, /* ...its length */
PTR machine, /* compiled regular expression */
unsigned *lenp) /* where to return matched-length */
{
register STATE *m = (STATE *) machine;
register char *s = str;
char *ss;
register RT_STATE *stackp;
int u_flag, t;
char *str_end = s + str_len;
char *ts;
/* state of current best match stored here */
char *cb_ss; /* the start */
char *cb_e = 0; /* the end , pts at first char not matched */
*lenp = 0;
/* check for the easy case */
if ((m + 1)->s_type == M_ACCEPT && m->s_type == M_STR) {
if ((ts = str_str(s, str_len, m->s_data.str, m->s_len)))
*lenp = m->s_len;
return ts;
}
u_flag = U_ON;
cb_ss = ss = (char *) 0;
stackp = RE_run_stack_empty;
goto reswitch;
refill:
if (stackp == RE_run_stack_empty) {
if (cb_ss)
*lenp = (unsigned) (cb_e - cb_ss);
return cb_ss;
}
ss = stackp->ss;
s = (stackp--)->s;
if (cb_ss) { /* does new state start too late ? */
if (ss) {
if (cb_ss < ss)
goto refill;
} else if (cb_ss < s) {
goto refill;
}
}
m = (stackp + 1)->m;
u_flag = (stackp + 1)->u;
reswitch:
switch (m->s_type + u_flag) {
case M_STR + U_OFF + END_OFF:
if (strncmp(s, m->s_data.str, m->s_len))
goto refill;
if (!ss) {
if (cb_ss && s > cb_ss)
goto refill;
else
ss = s;
}
s += m->s_len;
m++;
goto reswitch;
case M_STR + U_OFF + END_ON:
if (strcmp(s, m->s_data.str))
goto refill;
if (!ss) {
if (cb_ss && s > cb_ss) {
goto refill;
} else {
ss = s;
}
}
s += m->s_len;
m++;
goto reswitch;
case M_STR + U_ON + END_OFF:
if (!(s = str_str(s, str_len, m->s_data.str, m->s_len)))
goto refill;
if (s >= str + strlen(str))
goto refill;
push(m, s + 1, ss, U_ON);
if (!ss) {
if (cb_ss && s > cb_ss) {
goto refill;
} else {
ss = s;
}
}
s += m->s_len;
m++;
u_flag = U_OFF;
goto reswitch;
case M_STR + U_ON + END_ON:
t = (str_end - s) - m->s_len;
if (t < 0 || memcmp(ts = s + t, m->s_data.str, m->s_len))
goto refill;
if (!ss) {
if (cb_ss && ts > cb_ss)
goto refill;
else
ss = ts;
}
s = str_end;
m++;
u_flag = U_OFF;
goto reswitch;
case M_CLASS + U_OFF + END_OFF:
if (!ison(*m->s_data.bvp, s[0]))
goto refill;
if (!ss) {
if (cb_ss && s > cb_ss)
goto refill;
else
ss = s;
}
s++;
m++;
goto reswitch;
case M_CLASS + U_OFF + END_ON:
if (s[1] || !ison(*m->s_data.bvp, s[0]))
goto refill;
if (!ss) {
if (cb_ss && s > cb_ss)
goto refill;
else
ss = s;
}
s++;
m++;
goto reswitch;
case M_CLASS + U_ON + END_OFF:
while (!ison(*m->s_data.bvp, s[0])) {
if (s[0] == 0)
goto refill;
else
s++;
}
s++;
push(m, s, ss, U_ON);
if (!ss) {
if (cb_ss && s - 1 > cb_ss)
goto refill;
else
ss = s - 1;
}
m++;
u_flag = U_OFF;
goto reswitch;
case M_CLASS + U_ON + END_ON:
if (s[0] == 0 || !ison(*m->s_data.bvp, str_end[-1]))
goto refill;
if (!ss) {
if (cb_ss && str_end - 1 > cb_ss)
goto refill;
else
ss = str_end - 1;
}
s = str_end;
m++;
u_flag = U_OFF;
goto reswitch;
case M_ANY + U_OFF + END_OFF:
if (s[0] == 0)
goto refill;
if (!ss) {
if (cb_ss && s > cb_ss)
goto refill;
else
ss = s;
}
s++;
m++;
goto reswitch;
case M_ANY + U_OFF + END_ON:
if (s[0] == 0 || s[1] != 0)
goto refill;
if (!ss) {
if (cb_ss && s > cb_ss)
goto refill;
else
ss = s;
}
s++;
m++;
goto reswitch;
case M_ANY + U_ON + END_OFF:
if (s[0] == 0)
goto refill;
s++;
push(m, s, ss, U_ON);
if (!ss) {
if (cb_ss && s - 1 > cb_ss)
goto refill;
else
ss = s - 1;
}
m++;
u_flag = U_OFF;
goto reswitch;
case M_ANY + U_ON + END_ON:
if (s[0] == 0)
goto refill;
if (!ss) {
if (cb_ss && str_end - 1 > cb_ss)
goto refill;
else
ss = str_end - 1;
}
s = str_end;
m++;
u_flag = U_OFF;
goto reswitch;
case M_START + U_OFF + END_OFF:
case M_START + U_ON + END_OFF:
if (s != str)
goto refill;
ss = s;
m++;
u_flag = U_OFF;
goto reswitch;
case M_START + U_OFF + END_ON:
case M_START + U_ON + END_ON:
if (s != str || s[0] != 0)
goto refill;
ss = s;
m++;
u_flag = U_OFF;
goto reswitch;
case M_END + U_OFF:
if (s[0] != 0)
goto refill;
if (!ss) {
if (cb_ss && s > cb_ss)
goto refill;
else
ss = s;
}
m++;
goto reswitch;
case M_END + U_ON:
s = str_end;
if (!ss) {
if (cb_ss && s > cb_ss)
goto refill;
else
ss = s;
}
m++;
u_flag = U_OFF;
goto reswitch;
CASE_UANY(M_U):
if (!ss) {
if (cb_ss && s > cb_ss)
goto refill;
else
ss = s;
}
u_flag = U_ON;
m++;
goto reswitch;
CASE_UANY(M_1J):
m += m->s_data.jump;
goto reswitch;
CASE_UANY(M_2JA): /* take the non jump branch */
push(m + m->s_data.jump, s, ss, u_flag);
m++;
goto reswitch;
CASE_UANY(M_2JB): /* take the jump branch */
push(m + 1, s, ss, u_flag);
m += m->s_data.jump;
goto reswitch;
case M_ACCEPT + U_OFF:
if (!ss)
ss = s;
if (!cb_ss || ss < cb_ss || (ss == cb_ss && s > cb_e)) {
/* we have a new current best */
cb_ss = ss;
cb_e = s;
}
goto refill;
case M_ACCEPT + U_ON:
if (!ss) {
ss = s;
} else {
s = str_end;
}
if (!cb_ss || ss < cb_ss || (ss == cb_ss && s > cb_e)) {
/* we have a new current best */
cb_ss = ss;
cb_e = s;
}
goto refill;
default:
RE_panic("unexpected case in REmatch");
}
}
int delete_aliases(int newaliases, int prompt)
{
/*
* Update aliases by processing deletions. Prompting is
* done as directed by user input and elmrc options.
*
* If "prompt" is false, then no prompting is done.
* Otherwise prompting is dependent upon the variable
* ask_delete, as set by an elmrc option. This behavior
* makes the 'q' command prompt just like '$', while
* retaining the 'Q' command for a quick exit that never
* prompts.
*
* Return 1 Aliases were deleted
* newalias Aliases were not deleted
*
* The return allows the caller to determine if the "newalias"
* routine should be run.
*/
char buffer[SLEN];
char **list;
int to_delete = 0, to_keep = 0, i,
marked_deleted = 0,
ask_questions;
char answer;
dprint(1, (debugfile, "\n\n-- leaving aliases --\n\n"));
if (num_aliases == 0)
return(newaliases); /* nothing changed */
ask_questions = ((!prompt) ? FALSE : ask_delete);
/* Determine if deleted messages are really to be deleted */
/* we need to know how many there are to delete */
for (i=0; i<num_aliases; i++)
if (ison(aliases[i]->status, DELETED))
marked_deleted++;
dprint(6, (debugfile, "Number of aliases marked deleted = %d\n",
marked_deleted));
if(marked_deleted) {
if(ask_questions) {
if (marked_deleted == 1)
strcpy(buffer, catgets(elm_msg_cat, AliasesSet, AliasesDelete,
"Delete 1 alias?"));
else
sprintf(buffer, catgets(elm_msg_cat, AliasesSet, AliasesDeletePlural,
"Delete %d aliases?"), marked_deleted);
answer = enter_yn(buffer, always_delete, LINES-3, FALSE);
} else {
answer = always_delete;
}
if(answer) {
list = (char **) malloc(marked_deleted*sizeof(*list));
for (i = 0; i < num_aliases; i++) {
if (ison(aliases[i]->status, DELETED)) {
list[to_delete] = aliases[i]->alias;
dprint(8,(debugfile, "Alias number %d, %s is deletion %d\n",
i, list[to_delete], to_delete));
to_delete++;
}
else {
to_keep++;
}
}
/*
* Formulate message as to number of keeps and deletes.
* This is only complex so that the message is good English.
*/
if (to_keep > 0) {
curr_alias = 1; /* Reset current alias */
if (to_keep == 1)
sprintf(buffer, catgets(elm_msg_cat, AliasesSet, AliasesKeepDelete,
"[Keeping 1 alias and deleting %d.]"), to_delete);
else
sprintf(buffer, catgets(elm_msg_cat, AliasesSet, AliasesKeepDeletePlural,
"[Keeping %d aliases and deleting %d.]"), to_keep, to_delete);
}
else {
curr_alias = 0; /* No aliases left */
sprintf(buffer, catgets(elm_msg_cat, AliasesSet, AliasesDeleteAll,
"[Deleting all aliases.]"));
}
dprint(2, (debugfile, "Action: %s\n", buffer));
show_error(buffer);
delete_from_alias_text(list, to_delete);
free((char *) list);
}
}
dprint(3, (debugfile, "Aliases deleted: %d\n", to_delete));
/* If all aliases are to be kept we don't need to do anything
* (like run newalias for the deleted messages).
*/
if(to_delete == 0) {
dprint(3, (debugfile, "Aliases kept as is!\n"));
return(newaliases);
}
return(1);
}
/*
* test if str ~ /machine/
*/
int
REtest(char *str, /* string to test */
size_t len, /* ...its length */
PTR machine) /* compiled regular-expression */
{
register STATE *m = (STATE *) machine;
char *s = str;
register RT_STATE *stackp;
int u_flag;
char *str_end = str + len;
RT_POS_ENTRY *sp;
int t; /*convenient temps */
STATE *tm;
/* handle the easy case quickly */
if ((m + 1)->s_type == M_ACCEPT && m->s_type == M_STR) {
return str_str(s, len, m->s_data.str, (size_t) m->s_len) != (char *) 0;
} else {
u_flag = U_ON;
stackp = RE_run_stack_empty;
sp = RE_pos_stack_empty;
goto reswitch;
}
refill:
if (stackp == RE_run_stack_empty)
return 0;
m = stackp->m;
s = stackp->s;
sp = RE_pos_stack_base + stackp->sp;
sp->prev_offset = stackp->tp;
u_flag = (stackp--)->u;
reswitch:
switch (m->s_type + u_flag) {
case M_STR + U_OFF + END_OFF:
if (strncmp(s, m->s_data.str, (size_t) m->s_len))
goto refill;
s += m->s_len;
m++;
goto reswitch;
case M_STR + U_OFF + END_ON:
if (strcmp(s, m->s_data.str))
goto refill;
s += m->s_len;
m++;
goto reswitch;
case M_STR + U_ON + END_OFF:
if (!(s = str_str(s, (size_t) (str_end - s), m->s_data.str, (size_t) m->s_len)))
goto refill;
push(m, s + 1, sp, U_ON);
s += m->s_len;
m++;
u_flag = U_OFF;
goto reswitch;
case M_STR + U_ON + END_ON:
t = (str_end - s) - m->s_len;
if (t < 0 || memcmp(s + t, m->s_data.str, (size_t) m->s_len))
goto refill;
s = str_end;
m++;
u_flag = U_OFF;
goto reswitch;
case M_CLASS + U_OFF + END_OFF:
if (s >= str_end || !ison(*m->s_data.bvp, s[0]))
goto refill;
s++;
m++;
goto reswitch;
case M_CLASS + U_OFF + END_ON:
if (s >= str_end)
goto refill;
if ((s + 1) < str_end || !ison(*m->s_data.bvp, s[0]))
goto refill;
s++;
m++;
goto reswitch;
case M_CLASS + U_ON + END_OFF:
for (;;) {
if (s >= str_end)
goto refill;
else if (ison(*m->s_data.bvp, s[0]))
break;
s++;
}
s++;
push(m, s, sp, U_ON);
m++;
u_flag = U_OFF;
goto reswitch;
case M_CLASS + U_ON + END_ON:
if (s >= str_end || !ison(*m->s_data.bvp, str_end[-1]))
goto refill;
s = str_end;
m++;
u_flag = U_OFF;
goto reswitch;
case M_ANY + U_OFF + END_OFF:
if (s >= str_end)
goto refill;
s++;
m++;
goto reswitch;
case M_ANY + U_OFF + END_ON:
if (s >= str_end || (s + 1) < str_end)
goto refill;
s++;
m++;
goto reswitch;
case M_ANY + U_ON + END_OFF:
if (s >= str_end)
goto refill;
s++;
push(m, s, sp, U_ON);
m++;
u_flag = U_OFF;
goto reswitch;
case M_ANY + U_ON + END_ON:
if (s >= str_end)
goto refill;
s = str_end;
m++;
u_flag = U_OFF;
goto reswitch;
case M_START + U_OFF + END_OFF:
case M_START + U_ON + END_OFF:
if (s != str)
goto refill;
m++;
u_flag = U_OFF;
goto reswitch;
case M_START + U_OFF + END_ON:
case M_START + U_ON + END_ON:
if (s != str || s < str_end)
goto refill;
m++;
u_flag = U_OFF;
goto reswitch;
case M_END + U_OFF:
if (s < str_end)
goto refill;
m++;
goto reswitch;
case M_END + U_ON:
s += strlen(s);
m++;
u_flag = U_OFF;
goto reswitch;
CASE_UANY(M_U):
u_flag = U_ON;
m++;
goto reswitch;
CASE_UANY(M_1J):
m += m->s_data.jump;
goto reswitch;
CASE_UANY(M_SAVE_POS): /* save position for a later M_2JC */
sp = RE_pos_push(sp, stackp, s);
m++;
goto reswitch;
CASE_UANY(M_2JA): /* take the non jump branch */
/* don't stack an ACCEPT */
if ((tm = m + m->s_data.jump)->s_type == M_ACCEPT)
return 1;
push(tm, s, sp, u_flag);
m++;
goto reswitch;
CASE_UANY(M_2JC): /* take the jump branch if position changed */
if (RE_pos_pop(&sp, stackp) == s) {
/* did not advance: do not jump back */
m++;
goto reswitch;
}
/* fall thru */
CASE_UANY(M_2JB): /* take the jump branch */
/* don't stack an ACCEPT */
if ((tm = m + 1)->s_type == M_ACCEPT)
return 1;
push(tm, s, sp, u_flag);
m += m->s_data.jump;
goto reswitch;
CASE_UANY(M_ACCEPT):
return 1;
default:
RE_panic("unexpected case in REtest");
}
}
