home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Usenet 1994 October
/
usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso
/
unix
/
volume9
/
elm2
/
part08
< prev
next >
Wrap
Text File
|
1987-03-08
|
49KB
|
1,828 lines
Subject: v09i008: ELM Mail System, Part08/19
Newsgroups: mod.sources
Approved: rs@mirror.TMC.COM
Submitted by: Dave Taylor <hplabs!taylor>
Mod.sources: Volume 9, Issue 8
Archive-name: elm2/Part08
#! /bin/sh
# This is a shell archive. Remove anything before this line,
# then unpack it by saving it in a file and typing "sh file".
# If this archive is complete, you will see the message:
# "End of archive 8 (of 19)."
# Contents: filter/parse.c src/input_utils.c src/mailmsg1.c
# src/options.c utils/answer.c
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
echo shar: Extracting \"filter/parse.c\" \(8929 characters\)
if test -f filter/parse.c ; then
echo shar: Will not over-write existing file \"filter/parse.c\"
else
sed "s/^X//" >filter/parse.c <<'END_OF_filter/parse.c'
X/** filter_parse.c **/
X
X/** This is the parser for the filter program. It accepts a wide variety of
X constructs, building the ruleset table as it goes along. Check the
X data structure in filter.h for more information on how the rules are
X stored. The parser is a cunning state-table based program.
X
X (C) Copyright 1986, Dave Taylor
X**/
X
X#include <stdio.h>
X#include <ctype.h>
X
X#include "defs.h"
X#include "filter.h"
X
X#define NONE 0
X#define AND 10
X
X#define NEXT_CONDITION 0
X#define GETTING_OP 1
X#define READING_ARGUMENT 2
X#define READING_ACTION 3
X#define ACTION_ARGUMENT 4
X
Xchar *strtok(), *whatname(), *actionname();
X
Xint
Xget_filter_rules()
X{
X /** Given the users home directory, open and parse their rules table,
X building the data structure as we go along.
X returns -1 if we hit an error of any sort...
X **/
X
X FILE *fd; /* the file descriptor */
X char buffer[SLEN], /* fd reading buffer */
X *str, /* ptr to read string */
X *word, /* ptr to 'token' */
X filename[SLEN], /* the name of the ruleset */
X action_argument[SLEN], /* action arg, per rule */
X cond_argument[SLEN]; /* cond arg, per condition */
X int not_condition = FALSE, /* are we in a "not" ?? */
X type=NONE, /* what TYPE of condition? */
X lasttype, /* and the previous TYPE? */
X state = NEXT_CONDITION, /* the current state */
X in_single, in_double, /* for handling spaces. */
X i, /* misc integer for loops */
X relop = NONE, /* relational operator */
X action, /* the current action type */
X line = 0; /* line number we're on */
X
X struct condition_rec *cond, *newcond;
X
X sprintf(filename,"%s/%s", home, filterfile);
X
X if ((fd = fopen(filename,"r")) == NULL) {
X fprintf(stderr,"filter (%s): Couldn't read user filter rules file!\n",
X username);
X return(-1);
X }
X
X cond_argument[0] = action_argument[0] = '\0';
X
X /* Now, for each line... **/
X
X if ((cond = (struct condition_rec *)
X malloc(sizeof(struct condition_rec))) == NULL) {
X fprintf(stderr,"couldn't malloc first condition rec!\n");
X return(-1);
X }
X
X rules[total_rules].condition = cond; /* hooked in! */
X
X while (fgets(buffer, SLEN, fd) != NULL) {
X line++;
X
X if (buffer[0] == '#' || strlen(buffer) < 2)
X continue; /* nothing to look at! */
X
X in_single = in_double = 0;
X
X for (i=0; i < strlen(buffer); i++) {
X if (buffer[i] == '"')
X in_double = ! in_double;
X else if (buffer[i] == '\'')
X in_single = ! in_single;
X if ((in_double || in_single) && buffer[i] == ' ')
X buffer[i] = '_';
X }
X
X lasttype = type;
X type = NONE;
X str = (char *) buffer;
X
X /** Three pieces to this loop - get the `field', the 'relop' (if
X there) then, if needed, get the argument to check against (not
X needed for errors or the AND, of course)
X **/
X
X while ((word = strtok(str, " ()[]:\t\n")) != NULL) {
X
X str = (char *) NULL; /* we can start stomping! */
X
X lowercase(word);
X
X if (strcmp(word, "if") == 0) { /* only ONE 'if' allowed */
X if ((word = strtok(str, " ()[]:\t\n")) == NULL) /* NEXT! */
X continue;
X lowercase(word);
X }
X
X if (state == NEXT_CONDITION) {
X lasttype = type;
X type = NONE;
X
X if (the_same(word, "not") || the_same(word, "!")) {
X not_condition = TRUE;
X if ((word = strtok(str, " ()[]'\"\t\n")) == NULL)
X continue;
X }
X
X if (the_same(word, "from")) type = FROM;
X else if (the_same(word, "to")) type = TO;
X else if (the_same(word, "subject")) type = SUBJECT;
X else if (the_same(word, "lines")) type = LINES;
X else if (the_same(word, "contains")) type = CONTAINS;
X else if (the_same(word, "and") ||
X the_same(word, "&&")) type = AND;
X
X else if (the_same(word,"?") || the_same(word, "then")) {
X
X /** shove THIS puppy into the structure and let's continue! **/
X
X if (lasttype == AND) {
X fprintf(stderr,
X "%sfilter (%s): Error reading line %d of rules - badly placed \"and\"\n",
X BEEP, username, line);
X return(-1);
X }
X
X cond->matchwhat = lasttype;
X if (relop == NONE) relop = EQ; /* otherwise can't do -relop */
X cond->relation = (not_condition? - (relop) : relop);
X
X for (i=0;i<strlen(cond_argument);i++)
X if (cond_argument[i] == '_') cond_argument[i] = ' ';
X
X strcpy(cond->argument1, cond_argument);
X if ((newcond = (struct condition_rec *)
X malloc(sizeof(struct condition_rec))) == NULL) {
X fprintf(stderr,"Couldn't malloc new cond rec!!\n");
X return(-1);
X }
X cond->next = NULL;
X
X relop = EQ; /* default relational condition */
X
X state = READING_ACTION;
X if ((word = strtok(str, " ()[]'\"\t\n")) == NULL)
X continue;
X goto get_outta_loop;
X }
X
X if (type == NONE) {
X fprintf(stderr,
X "%sfilter (%s): Error reading line %d of rules - field \"%s\" unknown!\n",
X BEEP, username, line, word);
X return(-1);
X }
X
X if (type == AND) {
X
X /** shove THIS puppy into the structure and let's continue! **/
X
X cond->matchwhat = lasttype;
X cond->relation = (not_condition? - (relop) : relop);
X strcpy(cond->argument1, cond_argument);
X if ((newcond = (struct condition_rec *)
X malloc(sizeof(struct condition_rec))) == NULL) {
X fprintf(stderr,"Couldn't malloc new cond rec!!\n");
X return(-1);
X }
X cond->next = newcond;
X cond = newcond;
X cond->next = NULL;
X
X not_condition = FALSE;
X state = NEXT_CONDITION;
X }
X else {
X state = GETTING_OP;
X }
X }
X
Xget_outta_loop: /* jump out when we change state, if needed */
X
X if (state == GETTING_OP) {
X
X if ((word = strtok(str, " ()[]'\"\t\n")) == NULL)
X continue;
X
X lowercase(word);
X
X relop = NONE;
X
X if (the_same(word, "=") || the_same(word, "in") ||
X the_same(word, "contains")) {
X state = READING_ARGUMENT;
X relop = EQ;
X }
X else {
X if (the_same(word, "<=")) relop = LE;
X else if (the_same(word, ">=")) relop = GE;
X else if (the_same(word, ">")) relop = GT;
X else if (the_same(word, "<>")||
X the_same(word, "!=")) relop = NE;
X else if (the_same(word, "<")) relop = LT;
X
X /* maybe there isn't a relop at all!! */
X
X state=READING_ARGUMENT;
X
X }
X }
X
X if (state == READING_ARGUMENT) {
X if (relop != NONE) {
X if ((word = strtok(str, " ()[]'\"\t\n")) == NULL)
X continue;
X }
X for (i=0;i<strlen(word);i++)
X if (word[i] == '_') word[i] = ' ';
X
X strcpy(cond_argument, word);
X state = NEXT_CONDITION;
X }
X
X if (state == READING_ACTION) {
X action = NONE;
X
X not_condition = FALSE;
X
X if (the_same(word, "delete")) action = DELETE;
X else if (the_same(word, "savec")) action = SAVECC;
X else if (the_same(word, "save")) action = SAVE;
X else if (the_same(word, "forward")) action = FORWARD;
X else if (the_same(word, "exec")) action = EXEC;
X else if (the_same(word, "leave")) action = LEAVE;
X else {
X fprintf(stderr,
X "%sfilter (%s): Error on line %d of rules - action \"%s\" unknown\n",
X BEEP, username, line, word);
X }
X
X if (action == DELETE || action == LEAVE) {
X /** add this to the rules section and alloc next... **/
X
X rules[total_rules].action = action;
X rules[total_rules].argument2[0] = '\0'; /* nothing! */
X total_rules++;
X
X if ((cond = (struct condition_rec *)
X malloc(sizeof(struct condition_rec))) == NULL) {
X fprintf(stderr,"couldn't malloc first condition rec!\n");
X return(-1);
X }
X
X rules[total_rules].condition = cond; /* hooked in! */
X state = NEXT_CONDITION;
X }
X else {
X state = ACTION_ARGUMENT;
X }
X
X if ((word = strtok(str, " ()[]'\"\t\n")) == NULL)
X continue;
X
X }
X
X if (state == ACTION_ARGUMENT) {
X strcpy(action_argument, word);
X
X /** add this to the rules section and alloc next... **/
X
X rules[total_rules].action = action;
X expand_macros(action_argument, rules[total_rules].argument2,line);
X total_rules++;
X
X if ((cond = (struct condition_rec *)
X malloc(sizeof(struct condition_rec))) == NULL) {
X fprintf(stderr,"couldn't malloc first condition rec!\n");
X return(-1);
X }
X
X rules[total_rules].condition = cond; /* hooked in! */
X
X state = NEXT_CONDITION;
X if ((word = strtok(str, " ()[]'\"\t\n")) == NULL)
X continue;
X }
X }
X }
X
X return(0);
X}
END_OF_filter/parse.c
if test 8929 -ne `wc -c <filter/parse.c`; then
echo shar: \"filter/parse.c\" unpacked with wrong size!?
fi
# end of overwriting check
fi
echo shar: Extracting \"src/input_utils.c\" \(8598 characters\)
if test -f src/input_utils.c ; then
echo shar: Will not over-write existing file \"src/input_utils.c\"
else
sed "s/^X//" >src/input_utils.c <<'END_OF_src/input_utils.c'
X/** input_utils.c **/
X
X/** Mindless I/O routines for ELM
X
X (C) Copyright 1985 Dave Taylor
X**/
X
X#include "headers.h"
X#include <errno.h>
X
Xextern int errno; /* system error number */
X
Xunsigned alarm();
X
X#define special_char(c) (c == ' ' || c == '\t' || c == '/' || c == ',' \
X || c == '\0')
X
X#define erase_a_char() { Writechar(BACKSPACE); Writechar(' '); \
X Writechar(BACKSPACE); fflush(stdout); }
X
Xint
Xwant_to(question, dflt, echo_answer)
Xchar *question, dflt;
Xint echo_answer;
X{
X /** Ask 'question' at LINES-2, COLUMNS-40, returning the answer in
X lower case. If 'echo_answer', then echo answer. 'dflt' is the
X default answer if <return> is pressed. (Note: 'dflt' is also what
X will be returned if <return> is pressed!)
X **/
X register char ch, cols;
X
X cols = (strlen(question) < 30)? COLUMNS-40 : COLUMNS-50;
X
X PutLine3(LINES-3, cols,"%s%c%c", question, dflt, BACKSPACE);
X fflush(stdout);
X fflush(stdin);
X ch = tolower(ReadCh());
X
X if (echo_answer && ch > (char) ' ') {
X Writechar(ch);
X fflush(stdout);
X }
X
X return(ch == '\n' || ch == '\r' ? dflt : ch);
X}
X
Xint
Xread_number(ch)
Xchar ch;
X{
X /** Read a number, where 'ch' is the leading digit! **/
X
X char buff[SHORT_SLEN];
X int num;
X
X buff[0] = ch;
X buff[1] = '\0';
X
X PutLine0(LINES-3, COLUMNS-40,"Set current message to :");
X if (optionally_enter(buff, LINES-3, COLUMNS-15, TRUE) == -1)
X return(current);
X
X sscanf(buff,"%d", &num);
X return(num);
X}
X
Xint
Xoptionally_enter(string, x, y, append_current)
Xchar *string;
Xint x,y, append_current;
X{
X /** Display the string on the screen and if RETURN is pressed, return
X it. Otherwise, allow standard text input, including backspaces
X and such until RETURN is hit.
X If "append_current" is set, then leave the default string in
X place and edit AFTER it...assume 'x,y' is placing us at the
X beginning of the string...
X This routine returns zero unless INTERRUPT hit, then it returns
X -1 and must be treated accordingly.
X Added ^W and ^R support...
X Also added that if x and y are < 0 don't try any cursor stuff
X **/
X
X char ch;
X register int index = 0, use_cursor_control;
X
X use_cursor_control = ((! mail_only) && x >= 0 && y >= 0);
X
X if (use_cursor_control)
X PutLine1(x,y, "%s", string);
X else
X printf("%s", string);
X
X CleartoEOLN();
X
X if (! append_current)
X if (use_cursor_control)
X MoveCursor(x,y);
X else
X non_destructive_back_up(strlen(string));
X
X if (cursor_control)
X transmit_functions(OFF);
X
X ch = getchar();
X
X if (ch == '\n' || ch == '\r') {
X if (cursor_control)
X transmit_functions(ON);
X return(0); /* we're done. No change needed */
X }
X
X CleartoEOLN();
X
X index = (append_current? strlen(string) : 0);
X
X if (ch == kill_line) {
X if (use_cursor_control)
X MoveCursor(x,y);
X else
X back_up(index);
X CleartoEOLN();
X index = 0;
X }
X else if (ch != backspace) {
X Writechar(ch);
X string[index++] = ch;
X }
X else if (index > 0) {
X index--;
X erase_a_char();
X }
X else {
X Writechar(' ');
X Writechar(BACKSPACE);
X fflush(stdout);
X }
X
X do {
X ch = getchar();
X
X /* the following is converted from a case statement to
X allow the variable characters (backspace, kill_line
X and break) to be processed. Case statements in
X C require constants as labels, so it failed ...
X */
X
X if (ch == backspace) {
X if (index > 0) {
X erase_a_char();
X index--;
X }
X else {
X Writechar(' ');
X Writechar(BACKSPACE);
X fflush(stdout);
X }
X }
X else if (ch == '\n' || ch == '\r') {
X string[index] = '\0';
X if (cursor_control)
X transmit_functions(ON);
X return(0);
X }
X else if (ch == ctrl('W')) { /* back up a word! */
X if (special_char(string[index]) && index > 0) {
X index--;
X erase_a_char();
X }
X while (index > 0 && ! special_char(string[index])) {
X index--;
X erase_a_char();
X }
X }
X else if (ch == ctrl('R')) {
X string[index] = '\0';
X if (use_cursor_control) {
X PutLine1(x,y, "%s", string);
X CleartoEOLN();
X }
X else
X printf("\n%s", string);
X }
X else if (ch == kill_line) {
X if (use_cursor_control)
X MoveCursor(x,y);
X else
X back_up(index+1);
X CleartoEOLN();
X index = 0;
X }
X else if (ch == NULL) {
X if (cursor_control)
X transmit_functions(ON);
X fflush(stdin); /* remove extraneous chars, if any */
X string[0] = '\0'; /* clean up string, and... */
X return(-1);
X }
X else { /* default case */
X
X string[index++] = ch;
X Writechar(ch);
X }
X } while (index < SLEN);
X
X string[index] = '\0';
X
X if (cursor_control)
X transmit_functions(ON);
X return(0);
X}
X
Xint
Xpattern_enter(string, alt_string, x, y, alternate_prompt)
Xchar *string, *alt_string, *alternate_prompt;
Xint x,y;
X{
X /** This function is functionally similar to the routine
X optionally-enter, but if the first character pressed
X is a '/' character, then the alternate prompt and string
X are used rather than the normal one. This routine
X returns 1 if alternate was used, 0 if not
X **/
X
X char ch;
X register index = 0;
X
X PutLine1(x, y, "%s", string);
X CleartoEOLN();
X MoveCursor(x,y);
X
X if (cursor_control)
X transmit_functions(OFF);
X
X ch = getchar();
X
X if (ch == '\n' || ch == '\r') {
X if (cursor_control)
X transmit_functions(ON);
X return(0); /* we're done. No change needed */
X }
X
X if (ch == '/') {
X PutLine1(x, 0, "%s", alternate_prompt);
X CleartoEOLN();
X (void) optionally_enter(alt_string, x, strlen(alternate_prompt)+1,
X FALSE);
X return(1);
X }
X
X CleartoEOLN();
X
X index = 0;
X
X if (ch == kill_line) {
X MoveCursor(x,y);
X CleartoEOLN();
X index = 0;
X }
X else if (ch != backspace) {
X Writechar(ch);
X string[index++] = ch;
X }
X else if (index > 0) {
X index--;
X erase_a_char();
X }
X else {
X Writechar(' ');
X Writechar(BACKSPACE);
X }
X
X do {
X fflush(stdout);
X ch = getchar();
X
X /* the following is converted from a case statement to
X allow the variable characters (backspace, kill_line
X and break) to be processed. Case statements in
X C require constants as labels, so it failed ...
X */
X
X if (ch == backspace) {
X if (index > 0) {
X index--;
X erase_a_char();
X }
X else {
X Writechar(' ');
X Writechar(BACKSPACE);
X }
X }
X else if (ch == '\n' || ch == '\r') {
X string[index] = '\0';
X if (cursor_control)
X transmit_functions(ON);
X return(0);
X }
X else if (ch == ctrl('W')) {
X /* get to rightmost non-alpha */
X if (special_char (string[index]) && index > 0)
X index--;
X while (index > 0 && ! special_char(string[index])) {
X erase_a_char();
X index--;
X }
X }
X else if (ch == ctrl('R')) {
X string[index] = '\0';
X if (!mail_only) {
X PutLine1(x,y, "%s", string);
X CleartoEOLN();
X }
X else
X printf("\n%s", string);
X }
X else if (ch == kill_line) {
X MoveCursor(x,y);
X CleartoEOLN();
X index = 0;
X }
X else if (ch == NULL) {
X if (cursor_control)
X transmit_functions(ON);
X fflush(stdin); /* remove extraneous chars, if any */
X string[0] = '\0'; /* clean up string, and... */
X return(-1);
X }
X else { /* default case */
X
X string[index++] = ch;
X Writechar(ch);
X }
X } while (index < SLEN);
X
X string[index] = '\0';
X
X if (cursor_control)
X transmit_functions(ON);
X return(0);
X}
X
Xback_up(spaces)
Xint spaces;
X{
X /** this routine is to replace the goto x,y call for when sending
X mail without starting the entire "elm" system up... **/
X
X while (spaces--) {
X erase_a_char();
X }
X}
X
Xnon_destructive_back_up(spaces)
Xint spaces;
X{
X /** same as back_up() but doesn't ERASE the characters on the screen **/
X
X while (spaces--)
X Writechar(BACKSPACE);
X fflush(stdout);
X}
X
Xint
XGetPrompt()
X{
X /** This routine does a read/timeout for a single character.
X The way that this is determined is that the routine to
X read a character is called, then the "errno" is checked
X against EINTR (interrupted call). If they match, this
X returns NO_OP_COMMAND otherwise it returns the normal
X command.
X **/
X
X int ch;
X
X if (timeout > 0) {
X alarm((unsigned) timeout);
X errno = 0; /* we actually have to do this. *sigh* */
X ch = ReadCh();
X if (errno == EINTR) ch = NO_OP_COMMAND;
X alarm((unsigned) 0);
X }
X else
X ch = ReadCh();
X
X return(ch);
X}
END_OF_src/input_utils.c
if test 8598 -ne `wc -c <src/input_utils.c`; then
echo shar: \"src/input_utils.c\" unpacked with wrong size!?
fi
# end of overwriting check
fi
echo shar: Extracting \"src/mailmsg1.c\" \(8412 characters\)
if test -f src/mailmsg1.c ; then
echo shar: Will not over-write existing file \"src/mailmsg1.c\"
else
sed "s/^X//" >src/mailmsg1.c <<'END_OF_src/mailmsg1.c'
X/** mailmsg1.c **/
X
X/** Interface to allow mail to be sent to users. Part of ELM **/
X
X/** (C) Copyright 1986, Dave Taylor **/
X
X#include "headers.h"
X
X/** strings defined for the hdrconfg routines **/
X
Xchar subject[SLEN], action[SLEN], reply_to[SLEN], expires[SLEN], priority[SLEN];
Xchar to[VERY_LONG_STRING], cc[VERY_LONG_STRING], in_reply_to[SLEN];
Xchar user_defined_header[SLEN];
X
Xchar expanded_to[VERY_LONG_STRING], expanded_cc[VERY_LONG_STRING];
X
X#ifdef ALLOW_BCC
Xchar bcc[VERY_LONG_STRING], expanded_bcc[VERY_LONG_STRING];
X#endif
X
Xchar *format_long(), *strip_commas(), *tail_of_string(), *strcpy();
Xunsigned long sleep();
X
Xint
Xsend(given_to, given_subject, edit_message, form_letter)
Xchar *given_to, *given_subject;
Xint edit_message, form_letter;
X{
X /** Prompt for fields and then call mail() to send the specified
X message. If 'edit_message' is true then don't allow the
X message to be edited. 'form_letter' can be "YES" "NO" or "MAYBE".
X if YES, then add the header. If MAYBE, then add the M)ake form
X option to the last question (see mailsg2.c) etc. etc. **/
X
X int copy_msg = FALSE, is_a_response = FALSE;
X
X /* First: zero all current global message strings */
X
X cc[0] = action[0] = reply_to[0] = expires[0] = priority[0] = '\0';
X#ifdef ALLOW_BCC
X bcc[0] = expanded_bcc[0] = '\0';
X#endif
X in_reply_to[0] = expanded_to[0] = expanded_cc[0] = '\0';
X
X strcpy(subject, given_subject); /* copy given subject */
X strcpy(to, given_to); /* copy given to: */
X
X /******* And now the real stuff! *******/
X
X copy_msg=copy_the_msg(&is_a_response); /* copy msg into edit buffer? */
X
X if (get_to(to, expanded_to) == 0) /* get the To: address and expand */
X return(0);
X
X /** are we by any chance just checking the addresses? **/
X
X if (check_only) {
X printf("Expands to: %s\n", format_long(expanded_to, 12));
X putchar('\r'); /* don't ask... */
X leave();
X }
X
X /** if we're batchmailing, let's send it and GET OUTTA HERE! **/
X
X if (mail_only && strlen(batch_subject) > 0) {
X strcpy(subject, batch_subject); /* get the batch subject */
X return(mail(FALSE, FALSE, TRUE, form_letter));
X }
X
X display_to(expanded_to); /* display the To: field on screen... */
X
X dprint1(3,"\nMailing to %s\n", expanded_to);
X
X if (get_subject(subject) == 0) /* get the Subject: field */
X return(0);
X
X dprint1(4,"Subject is %s\n", subject);
X
X if (get_copies(cc, expanded_to, expanded_cc) == 0)
X return(0);
X
X if (strlen(cc) > 0)
X dprint1(4,"Copies to %s\n", expanded_cc);
X
X if (mail_only) /* indicate next step... */
X printf("\n\r");
X else
X MoveCursor(LINES,0); /* you know you're hit <return> ! */
X
X /** generate the In-Reply-To: header... **/
X
X if (is_a_response)
X generate_reply_to(current-1);
X
X /* and mail that puppy outta here! */
X
X mail(copy_msg, edit_message, FALSE, form_letter);
X
X return(edit_message);
X}
X
Xget_to(to_field, address)
Xchar *to_field, *address;
X{
X /** prompt for the "To:" field, expanding into address if possible.
X This routine returns ZERO if errored, or non-zero if okay **/
X
X if (strlen(to_field) == 0) {
X if (user_level < 2) {
X PutLine0(LINES-2, 0, "Send the message to: ");
X (void) optionally_enter(to_field, LINES-2, 21, FALSE);
X }
X else {
X PutLine0(LINES-2, 0, "To: ");
X (void) optionally_enter(to_field, LINES-2, 4, FALSE);
X }
X if (strlen(to_field) == 0) {
X ClearLine(LINES-2);
X return(0);
X }
X build_address(strip_commas(to_field), address);
X }
X else if (mail_only)
X build_address(strip_commas(to_field), address);
X else
X strcpy(address, to_field);
X
X if (strlen(address) == 0) { /* bad address! Removed!! */
X if (! mail_only)
X ClearLine(LINES-2);
X return(0);
X }
X
X return(1); /* everything is okay... */
X}
X
Xget_subject(subject_field)
Xchar *subject_field;
X{
X /** get the subject and return non-zero if all okay... **/
X int len = 9;
X
X if (mail_only)
X printf("Subject: ");
X else
X if (user_level == 0) {
X PutLine0(LINES-2,0,"Subject of message: ");
X len = 21;
X }
X else
X PutLine0(LINES-2,0,"Subject: ");
X
X CleartoEOLN();
X
X if (optionally_enter(subject_field, LINES-2, len, TRUE) == -1) {
X /** User hit the BREAK key! **/
X MoveCursor(LINES-2,0);
X CleartoEOLN();
X error("mail not sent");
X return(0);
X }
X
X if (strlen(subject_field) == 0) { /* zero length subject?? */
X if (mail_only)
X printf("\n\rNo subject - Continue with message? (y/n) n%c",
X BACKSPACE);
X else
X PutLine1(LINES-2,0,"No subject - Continue with message? (y/n) n%c",
X BACKSPACE);
X
X if (tolower(ReadCh()) != 'y') { /* user says no! */
X if (mail_only) {
X printf("\n\r\n\rMail Cancelled!\n\r");
X return(0);
X }
X ClearLine(LINES-2);
X error("mail not sent");
X return(0);
X }
X else if (! mail_only) {
X PutLine0(LINES-2,0,"Subject: <none>");
X CleartoEOLN();
X }
X }
X
X return(1); /** everything is cruising along okay **/
X}
X
Xget_copies(cc_field, address, addressII)
Xchar *cc_field, *address, *addressII;
X{
X /** Get the list of people that should be cc'd, returning ZERO if
X any problems arise. Address and AddressII are for expanding
X the aliases out after entry!
X If 'bounceback' is nonzero, add a cc to ourselves via the remote
X site, but only if hops to machine are > bounceback threshold.
X **/
X
X if (mail_only)
X printf("\n\rCopies To: ");
X else
X PutLine0(LINES-1,0,"Copies To: ");
X
X fflush(stdout);
X
X if (optionally_enter(cc_field, LINES-1, 11, FALSE) == -1) {
X if (mail_only) {
X printf("\n\r\n\rMail not sent!\n\r");
X return(0);
X }
X ClearLine(LINES-2);
X ClearLine(LINES-1);
X
X error("mail not sent");
X return(0);
X }
X
X build_address(strip_commas(cc_field), addressII);
X
X if (strlen(address) + strlen(addressII) > VERY_LONG_STRING) {
X dprint0(2,
X "String length of \"To:\" + \"Cc\" too long! (get_copies)\n");
X error("Too many people. Copies ignored");
X sleep(2);
X cc_field[0] = '\0';
X }
X
X return(1); /* everything looks okay! */
X}
X
Xint
Xcopy_the_msg(is_a_response)
Xint *is_a_response;
X{
X /** Returns True iff the user wants to copy the message being
X replied to into the edit buffer before invoking the editor!
X Sets "is_a_response" to true if message is a response...
X **/
X
X int answer = FALSE;
X
X if (strlen(to) > 0 && !mail_only) { /* predefined 'to' line! */
X if (auto_copy)
X answer = TRUE;
X else
X answer = (want_to("Copy message? (y/n) ", 'n', TRUE) == 'y');
X *is_a_response = TRUE;
X }
X else
X if (strlen(subject) > 0) /* predefined 'subject' (Forward) */
X answer = TRUE;
X
X return(answer);
X}
X
Xdisplay_to(address)
Xchar *address;
X{
X /** Simple routine to display the "To:" line according to the
X current configuration (etc)
X **/
X register int open_paren;
X
X if (mail_only)
X printf("To: %s\n\r", format_long(address, 3));
X else {
X if (names_only)
X if ((open_paren = chloc(address, '(')) > 0) {
X if (open_paren < chloc(address, ')')) {
X output_abbreviated_to(address);
X return;
X }
X }
X if (strlen(address) > 45)
X PutLine1(LINES-3, COLUMNS-50, "To: (%s)",
X tail_of_string(address, 40));
X else {
X if (strlen(address) > 30)
X PutLine1(LINES-3, COLUMNS-50, "To: %s", address);
X else
X PutLine1(LINES-3, COLUMNS-50, " To: %s", address);
X CleartoEOLN();
X }
X }
X}
X
Xoutput_abbreviated_to(address)
Xchar *address;
X{
X /** Output just the fields in parens, separated by commas if need
X be, and up to COLUMNS-50 characters...This is only used if the
X user is at level BEGINNER.
X **/
X
X char newaddress[LONG_STRING];
X register int index, newindex = 0, in_paren = 0;
X
X index = 0;
X
X while (newindex < 55 && index < strlen(address)) {
X if (address[index] == '(') in_paren++;
X else if (address[index] == ')') {
X in_paren--;
X if (index < strlen(address)-4) {
X newaddress[newindex++] = ',';
X newaddress[newindex++] = ' ';
X }
X }
X
X if (in_paren && address[index] != '(')
X newaddress[newindex++] = address[index];
X
X index++;
X }
X
X newaddress[newindex] = '\0';
X
X if (strlen(newaddress) > 50)
X PutLine1(LINES-3, COLUMNS-50, "To: (%s)",
X tail_of_string(newaddress, 40));
X else {
X if (strlen(newaddress) > 30)
X PutLine1(LINES-3, COLUMNS-50, "To: %s", newaddress);
X else
X PutLine1(LINES-3, COLUMNS-50, " To: %s", newaddress);
X CleartoEOLN();
X }
X
X return;
X}
END_OF_src/mailmsg1.c
if test 8412 -ne `wc -c <src/mailmsg1.c`; then
echo shar: \"src/mailmsg1.c\" unpacked with wrong size!?
fi
# end of overwriting check
fi
echo shar: Extracting \"src/options.c\" \(9046 characters\)
if test -f src/options.c ; then
echo shar: Will not over-write existing file \"src/options.c\"
else
sed "s/^X//" >src/options.c <<'END_OF_src/options.c'
X/** options.c **/
X
X/** This set of routines allows the alteration of a number of paramaters
X in the Elm mailer, including the following;
X
X calendar-file <where to put calendar entries>
X display pager <how to page messages>
X editor <name of composition editor>
X folder-dir <folder directory>
X sort-by <how to sort mailboxes>
X savefile <file to save outbound message copies to>
X printmail <how to print messages>
X full_username <your full user name for outgoing mail>
X
X arrow-cursor <on or off>
X menu-display <on or off>
X
X user-level <BEGINNER|INTERMEDIATE|EXPERT>
X names-only <on or off>
X
X And others as they seem useful.
X
X (C) Copyright 1986, Dave Taylor
X**/
X
X#include "headers.h"
X
X#undef onoff
X#define onoff(n) (n == 1? "ON ":"OFF")
X
Xchar *one_liner_for(), *level_name();
Xunsigned long sleep();
X
Xoptions()
X{
X /** change options... **/
X
X char ch;
X
X display_options();
X
X do {
X ClearLine(LINES-4);
X
X Centerline(LINES-4,
X "Select first letter of Option line, '>' to Save, or R)eturn");
X
X PutLine0(LINES-2, 0, "Command: ");
X
X ch = tolower(ReadCh());
X
X clear_error(); /* remove possible "sorting" message etc... */
X
X one_liner(one_liner_for(ch));
X
X switch (ch) {
X case 'c' : optionally_enter(calendar_file, 2, 23, FALSE); break;
X case 'd' : optionally_enter(pager, 3, 23, FALSE); break;
X case 'e' : optionally_enter(editor, 4, 23, FALSE); break;
X case 'f' : optionally_enter(folders, 5, 23, FALSE); break;
X case 's' : change_sort(6,23); break;
X case 'o' : optionally_enter(savefile, 7, 23, FALSE); break;
X case 'p' : optionally_enter(printout, 8, 23, FALSE); break;
X case 'y' : optionally_enter(full_username, 9, 23, FALSE); break;
X case 'a' : on_or_off(&arrow_cursor, 12, 23); break;
X case 'm' : on_or_off(&mini_menu, 13, 23);
X headers_per_page = LINES - (mini_menu ? 13 : 8); break;
X
X case 'u' : switch_user_level(&user_level,15, 23); break;
X case 'n' : on_or_off(&names_only, 16, 23); break;
X
X case '?' : options_help();
X PutLine0(LINES-2,0,"Command: "); break;
X
X case '>' : printf("Save options in .elmrc...");
X fflush(stdout); save_options(); break;
X
X case 'x' :
X case 'r' :
X case ctrl('M'):
X case ctrl('J'): return;
X case ctrl('L'): display_options(); break;
X default: error("Command unknown!");
X }
X
X } while (ch != 'r');
X}
X
Xdisplay_options()
X{
X /** Display all the available options.. **/
X
X char *sort_name();
X
X ClearScreen();
X Centerline(0,"-- Elm Options Editor --");
X
X#ifdef ENABLE_CALENDAR
X PutLine1(2, 0, "C)alendar file : %s", calendar_file);
X#endif
X PutLine1(3, 0, "D)isplay mail using : %s", pager);
X PutLine1(4, 0, "E)ditor : %s", editor);
X PutLine1(5, 0, "F)older directory : %s", folders);
X PutLine1(6, 0, "S)orting criteria : %s", sort_name(FULL));
X PutLine1(7, 0, "O)utbound mail saved : %s", savefile);
X PutLine1(8, 0, "P)rint mail using : %s", printout);
X PutLine1(9, 0, "Y)our full name : %s", full_username);
X
X PutLine1(12,0, "A)rrow cursor : %s", onoff(arrow_cursor));
X PutLine1(13,0, "M)enu display : %s", onoff(mini_menu));
X
X PutLine1(15,0, "U)ser level : %s", level_name(user_level));
X PutLine1(16,0, "N)ames only : %s", onoff(names_only));
X}
X
Xon_or_off(var, x, y)
Xint *var, x,y;
X{
X /** 'var' field at x.y toggles between on and off... **/
X
X char ch;
X
X PutLine0(x, y+6,
X "(use <space> to toggle, any other key to leave)");
X
X MoveCursor(x,y+3); /* at end of value... */
X
X do {
X ch = ReadCh();
X
X if (ch == SPACE) {
X *var = ! *var;
X PutLine0(x,y, onoff(*var));
X }
X } while (ch == SPACE);
X
X MoveCursor(x,y+4); CleartoEOLN(); /* remove help prompt */
X}
X
X
Xswitch_user_level(ulevel, x, y)
Xint *ulevel, x, y;
X{
X /** step through possible user levels... **/
X
X PutLine0(x, y+20, "<space> to change");
X
X MoveCursor(x,y); /* at end of value... */
X
X while (ReadCh() == ' ') {
X *ulevel = (*ulevel == 2? 0 : *ulevel + 1);
X PutLine1(x,y, "%s", level_name(*ulevel));
X }
X
X MoveCursor(x,y+20); CleartoEOLN(); /* remove help prompt */
X}
X
Xchange_sort(x, y)
Xint x,y;
X{
X /** change the sorting scheme... **/
X
X int last_sortby, /* so we know if it changes... */
X sign = 1; /* are we reverse sorting?? */
X char ch; /* character typed in ... */
X
X last_sortby = sortby; /* remember current ordering */
X
X PutLine0(x, COLUMNS-29, "(SPACE for next, or R)everse)");
X sort_one_liner(sortby);
X MoveCursor(x, y);
X
X do {
X ch = tolower(ReadCh());
X switch (ch) {
X case SPACE : if (sortby < 0) {
X sign = -1;
X sortby = - sortby;
X }
X else sign = 1; /* insurance! */
X sortby = sign * ((sortby + 1) % (STATUS+1));
X if (sortby == 0) sortby = sign; /* snicker */
X PutLine0(x, y, sort_name(PAD));
X sort_one_liner(sortby);
X MoveCursor(x, y);
X break;
X
X case 'r' : sortby = - sortby;
X PutLine0(x, y, sort_name(PAD));
X sort_one_liner(sortby);
X MoveCursor(x, y);
X }
X } while (ch == SPACE || ch == 'r');
X
X MoveCursor(x, COLUMNS-30); CleartoEOLN();
X
X if (sortby != last_sortby) {
X error("resorting mailbox...");
X sleep(1);
X sort_mailbox(message_count, 0);
X }
X ClearLine(LINES-2); /* clear sort_one_liner()! */
X}
X
Xone_liner(string)
Xchar *string;
X{
X /** A single-line description of the selected item... **/
X
X ClearLine(LINES-4);
X Centerline(LINES-4, string);
X}
X
Xsort_one_liner(sorting_by)
Xint sorting_by;
X{
X /** A one line summary of the particular sorting scheme... **/
X
X ClearLine(LINES-2);
X
X switch (sorting_by) {
X
X case -SENT_DATE : Centerline(LINES-2,
X"This sort will order most-recently-sent to least-recently-sent"); break;
X case -RECEIVED_DATE : Centerline(LINES-2,
X"This sort will order most-recently-received to least-recently-received");
X break;
X case -SENDER : Centerline(LINES-2,
X"This sort will order by sender name, in reverse alphabetical order"); break;
X case -SIZE : Centerline(LINES-2,
X"This sort will order messages by longest to shortest"); break;
X case -SUBJECT : Centerline(LINES-2,
X"This sort will order by subject, in reverse alphabetical order"); break;
X case -STATUS : Centerline(LINES-2,
X"This sort will order by reverse status - Deleted through Tagged..."); break;
X
X case SENT_DATE : Centerline(LINES-2,
X"This sort will order least-recently-sent to most-recently-sent"); break;
X case RECEIVED_DATE : Centerline(LINES-2,
X"This sort will order least-recently-received to most-recently-received");
X break;
X case SENDER : Centerline(LINES-2,
X "This sort will order by sender name"); break;
X case SIZE : Centerline(LINES-2,
X "This sort will order messages by shortest to longest");
X break;
X case SUBJECT : Centerline(LINES-2,
X "This sort will order messages by subject"); break;
X case STATUS : Centerline(LINES-2,
X"This sort will order by status - Tagged through Deleted..."); break;
X }
X}
X
Xchar *one_liner_for(c)
Xchar c;
X{
X /** returns the one-line description of the command char... **/
X
X switch (c) {
X case 'c' : return(
X"This is the file where calendar entries from messages are saved.");
X
X case 'd' : return(
X"This is the program invoked to display individual messages (try 'builtin')");
X
X case 'e' : return(
X"This is the editor that will be used for sending messages, etc.");
X
X case 'f' : return(
X"This is the folders directory used when '=' (etc) is used in filenames");
X
X case 'm' : return(
X"This determines if you have the mini-menu displayed or not");
X
X case 'n' : return(
X"Whether to display the names and addresses on mail, or names only");
X case 'o' : return(
X"This is where copies of outbound messages are saved automatically.");
X
X case 'p' : return(
X"This is how printouts are generated. \"%s\" will be replaced by the filename.");
X
X case 's' : return(
X"This is used to specify the sorting criteria for the mailboxes");
X
X case 'y' : return(
X"When mail is sent out, this is what your full name will be recorded as.");
X
X case 'a' : return(
X"This defines whether the ELM cursor is an arrow or a highlight bar.");
X
X case 'u' : return(
X"The level of knowledge you have about the Elm mail system.");
X
X default : return(""); /* nothing if we don't know! */
X }
X}
X
Xoptions_help()
X{
X /** help menu for the options screen... **/
X
X char c, *ptr;
X
X Centerline(LINES-3,
X "Enter the key you want help on, '?' for a list, or '.' to exit help");
X
X lower_prompt("Key : ");
X
X while ((c = tolower(ReadCh())) != '.') {
X if (c == '?') {
X display_helpfile(OPTIONS_HELP);
X display_options();
X return;
X }
X if ((ptr = one_liner_for(c)) != NULL)
X error2("%c = %s", c, ptr);
X else
X error1("%c isn't used in this section", c);
X lower_prompt("Key : ");
X }
X}
X
Xchar *level_name(n)
Xint n;
X{
X /** return the 'name' of the level... **/
X
X switch (n) {
X case 0 : return("Beginning User ");
X case 1 : return("Intermediate User");
X default: return("Expert User ");
X }
X}
END_OF_src/options.c
if test 9046 -ne `wc -c <src/options.c`; then
echo shar: \"src/options.c\" unpacked with wrong size!?
fi
# end of overwriting check
fi
echo shar: Extracting \"utils/answer.c\" \(8992 characters\)
if test -f utils/answer.c ; then
echo shar: Will not over-write existing file \"utils/answer.c\"
else
sed "s/^X//" >utils/answer.c <<'END_OF_utils/answer.c'
X/** answer.c **/
X
X/** This program is a phone message transcription system, and
X is designed for secretaries and the like, to allow them to
X painlessly generate electronic mail instead of paper forms.
X
X Note: this program ONLY uses the local alias file, and does not
X even read in the system alias file at all.
X
X (C) Copyright 1986, Dave Taylor
X
X**/
X
X#include <stdio.h>
X#include <fcntl.h>
X#include <ctype.h>
X
X#include "defs.h" /* ELM system definitions */
X
X#define ELM "elm" /* where the elm program lives */
X
X#define answer_temp_file "/tmp/answer."
X
Xstatic char ident[] = { WHAT_STRING };
X
Xstruct alias_rec user_hash_table [MAX_UALIASES];
X
Xint user_data; /* fileno of user data file */
X
Xchar *expand_group(), *get_alias_address(), *get_token(), *strip_parens();
X
Xmain()
X{
X FILE *fd;
X char *address, buffer[LONG_STRING], tempfile[SLEN];
X char name[SLEN], user_name[SLEN];
X int msgnum = 0, eof;
X
X read_alias_files();
X
X while (1) {
X if (msgnum > 9999) msgnum = 0;
X
X printf("\n-------------------------------------------------------------------------------\n");
X
Xprompt: printf("\nMessage to: ");
X gets(user_name, SLEN);
X if (user_name == NULL)
X goto prompt;
X
X if ((strcmp(user_name,"quit") == 0) ||
X (strcmp(user_name,"exit") == 0) ||
X (strcmp(user_name,"done") == 0) ||
X (strcmp(user_name,"bye") == 0))
X exit(0);
X
X if (translate(user_name, name) == 0)
X goto prompt;
X
X address = get_alias_address(name, 1, 0);
X
X printf("address '%s'\n", address);
X
X if (address == NULL || strlen(address) == 0) {
X printf("Sorry, could not find '%s' [%s] in list!\n", user_name,
X name);
X goto prompt;
X }
X
X sprintf(tempfile, "%s%d", answer_temp_file, msgnum++);
X
X if ((fd = fopen(tempfile,"w")) == NULL)
X exit(printf("** Fatal Error: could not open %s to write\n",
X tempfile));
X
X
X printf("\nEnter message for %s ending with a blank line.\n\n",
X user_name);
X
X fprintf(fd,"\n\n");
X
X do {
X printf("> ");
X if (! (eof = (gets(buffer, SLEN) == NULL)))
X fprintf(fd, "%s\n", buffer);
X } while (! eof && strlen(buffer) > 0);
X
X fclose(fd);
X
X sprintf(buffer,
X "((%s -s \"While You Were Out\" %s ; %s %s) & ) < %s > /dev/null",
X ELM, strip_parens(address), remove, tempfile, tempfile);
X
X system(buffer);
X }
X}
X
Xint
Xtranslate(fullname, name)
Xchar *fullname, *name;
X{
X /** translate fullname into name..
X 'first last' translated to first_initial - underline - last
X 'initial last' translated to initial - underline - last
X Return 0 if error.
X **/
X register int i, lastname = 0;
X
X for (i=0; i < strlen(fullname); i++) {
X
X if (isupper(fullname[i]))
X fullname[i] = tolower(fullname[i]);
X
X if (fullname[i] == ' ')
X if (lastname) {
X printf(
X "** Can't have more than 'FirstName LastName' as address!\n");
X return(0);
X }
X else
X lastname = i+1;
X
X }
X
X if (lastname)
X sprintf(name, "%c_%s", fullname[0], (char *) fullname + lastname);
X else
X strcpy(name, fullname);
X
X return(1);
X}
X
X
Xread_alias_files()
X{
X /** read the user alias file **/
X
X char fname[SLEN];
X int hash;
X
X sprintf(fname, "%s/.alias_hash", getenv("HOME"));
X
X if ((hash = open(fname, O_RDONLY)) == -1)
X exit(printf("** Fatal Error: Could not open %s!\n", fname));
X
X read(hash, user_hash_table, sizeof user_hash_table);
X close(hash);
X
X sprintf(fname, "%s/.alias_data", getenv("HOME"));
X
X if ((user_data = open(fname, O_RDONLY)) == -1)
X return;
X}
X
Xchar *get_alias_address(name, mailing, depth)
Xchar *name;
Xint mailing, depth;
X{
X /** return the line from either datafile that corresponds
X to the specified name. If 'mailing' specified, then
X fully expand group names. Returns NULL if not found.
X Depth is the nesting depth, and varies according to the
X nesting level of the routine. **/
X
X static char buffer[VERY_LONG_STRING];
X int loc;
X
X if ((loc = find(name, user_hash_table, MAX_UALIASES)) >= 0) {
X lseek(user_data, user_hash_table[loc].byte, 0L);
X get_line(user_data, buffer, LONG_STRING);
X if (buffer[0] == '!' && mailing)
X return( (char *) expand_group(buffer, depth));
X else
X return( (char *) buffer);
X }
X
X return( (char *) NULL);
X}
X
Xchar *expand_group(members, depth)
Xchar *members;
Xint depth;
X{
X /** given a group of names separated by commas, this routine
X will return a string that is the full addresses of each
X member separated by spaces. Depth is the current recursion
X depth of the expansion (for the 'get_token' routine) **/
X
X char buffer[VERY_LONG_STRING];
X char buf[LONG_STRING], *word, *address, *bufptr;
X
X strcpy(buf, members); /* parameter safety! */
X buffer[0] = '\0'; /* nothing in yet! */
X bufptr = (char *) buf; /* grab the address */
X depth++; /* one more deeply into stack */
X
X while ((word = (char *) get_token(bufptr, "!, ", depth)) != NULL) {
X if ((address = (char *) get_alias_address(word, 1, depth)) == NULL) {
X fprintf(stderr, "Alias %s not found for group expansion!", word);
X return( (char *) NULL);
X }
X else if (strcmp(buffer,address) != 0) {
X sprintf(buffer,"%s %s", buffer, address);
X }
X
X bufptr = NULL;
X }
X
X return( (char *) buffer);
X}
X
Xint
Xfind(word, table, size)
Xchar *word;
Xstruct alias_rec table[];
Xint size;
X{
X /** find word and return loc, or -1 **/
X register int loc;
X
X if (strlen(word) > 20)
X exit(printf("Bad alias name: %s. Too long.\n", word));
X
X loc = hash_it(word, size);
X
X while (strcmp(word, table[loc].name) != 0) {
X if (table[loc].name[0] == '\0')
X return(-1);
X loc = (loc + 1) % size;
X }
X
X return(loc);
X}
X
Xint
Xhash_it(string, table_size)
Xchar *string;
Xint table_size;
X{
X /** compute the hash function of the string, returning
X it (mod table_size) **/
X
X register int i, sum = 0;
X
X for (i=0; string[i] != '\0'; i++)
X sum += (int) string[i];
X
X return(sum % table_size);
X}
X
Xget_line(fd, buffer)
Xint fd;
Xchar *buffer;
X{
X /* read from file fd. End read upon reading either
X EOF or '\n' character (this is where it differs
X from a straight 'read' command!) */
X
X register int i= 0;
X char ch;
X
X while (read(fd, &ch, 1) > 0)
X if (ch == '\n' || ch == '\r') {
X buffer[i] = 0;
X return;
X }
X else
X buffer[i++] = ch;
X}
X
Xprint_long(buffer, init_len)
Xchar *buffer;
Xint init_len;
X{
X /** print buffer out, 80 characters (or less) per line, for
X as many lines as needed. If 'init_len' is specified,
X it is the length that the first line can be.
X **/
X
X register int i, loc=0, space, length;
X
X /* In general, go to 80 characters beyond current character
X being processed, and then work backwards until space found! */
X
X length = init_len;
X
X do {
X if (strlen(buffer) > loc + length) {
X space = loc + length;
X while (buffer[space] != ' ' && space > loc + 50) space--;
X for (i=loc;i <= space;i++)
X putchar(buffer[i]);
X putchar('\n');
X loc = space;
X }
X else {
X for (i=loc;i < strlen(buffer);i++)
X putchar(buffer[i]);
X putchar('\n');
X loc = strlen(buffer);
X }
X length = 80;
X } while (loc < strlen(buffer));
X}
X
X/****
X The following is a newly chopped version of the 'strtok' routine
X that can work in a recursive way (up to 20 levels of recursion) by
X changing the character buffer to an array of character buffers....
X****/
X
X#define MAX_RECURSION 20 /* up to 20 deep recursion */
X
X#undef NULL
X#define NULL (char *) 0 /* for this routine only */
X
Xextern int strspn();
Xextern char *strpbrk();
X
Xchar *get_token(string, sepset, depth)
Xchar *string, *sepset;
Xint depth;
X{
X
X /** string is the string pointer to break up, sepstr are the
X list of characters that can break the line up and depth
X is the current nesting/recursion depth of the call **/
X
X register char *p, *q, *r;
X static char *savept[MAX_RECURSION];
X
X /** is there space on the recursion stack? **/
X
X if (depth >= MAX_RECURSION) {
X fprintf(stderr,"Error: Get_token calls nested greated than %d deep!\n",
X MAX_RECURSION);
X exit(1);
X }
X
X /* set up the pointer for the first or subsequent call */
X p = (string == NULL)? savept[depth]: string;
X
X if(p == 0) /* return if no tokens remaining */
X return(NULL);
X
X q = p + strspn(p, sepset); /* skip leading separators */
X
X if (*q == '\0') /* return if no tokens remaining */
X return(NULL);
X
X if ((r = strpbrk(q, sepset)) == NULL) /* move past token */
X savept[depth] = 0; /* indicate this is last token */
X else {
X *r = '\0';
X savept[depth] = ++r;
X }
X return(q);
X}
X
Xchar *strip_parens(string)
Xchar *string;
X{
X /** Return string with all parenthesized information removed.
X This is a non-destructive algorithm... **/
X
X static char buffer[LONG_STRING];
X register int i, depth = 0, buffer_index = 0;
X
X for (i=0; i < strlen(string); i++) {
X if (string[i] == '(')
X depth++;
X else if (string[i] == ')')
X depth--;
X else if (depth == 0)
X buffer[buffer_index++] = string[i];
X }
X
X buffer[buffer_index] = '\0';
X
X return( (char *) buffer);
X}
END_OF_utils/answer.c
if test 8992 -ne `wc -c <utils/answer.c`; then
echo shar: \"utils/answer.c\" unpacked with wrong size!?
fi
# end of overwriting check
fi
echo shar: End of archive 8 \(of 19\).
cp /dev/null ark8isdone
DONE=true
for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ; do
if test ! -f ark${I}isdone ; then
echo shar: You still need to run archive ${I}.
DONE=false
fi
done
if test "$DONE" = "true" ; then
echo You have unpacked all 19 archives.
echo "See the Instructions file"
rm -f ark[1-9]isdone ark[1-9][0-9]isdone
fi
## End of shell archive.
exit 0
