home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / x / volume13 / xmail / part05 / parser.c < prev   
C/C++ Source or Header  |  1991-06-15  |  17KB  |  466 lines
  1. /*
  2.  * xmail - X window system interface to the mail program
  3.  *
  4.  * Copyright 1989 The University of Texas at Austin
  5.  *
  6.  * Author:    Po Cheung
  7.  * Date:    March 10, 1989
  8.  *
  9.  * Permission to use, copy, modify, and distribute this software and
  10.  * its documentation for any purpose and without fee is hereby granted,
  11.  * provided that the above copyright notice appear in all copies and that
  12.  * both that copyright notice and this permission notice appear in
  13.  * supporting documentation.  The University of Texas at Austin makes no 
  14.  * representations about the suitability of this software for any purpose.  
  15.  * It is provided "as is" without express or implied warranty.
  16.  *
  17.  * Copyright 1990 by National Semiconductor Corporation
  18.  *
  19.  * Permission to use, copy, modify, and distribute this software and its
  20.  * documentation for any purpose is hereby granted without fee, provided that
  21.  * the above copyright notice appear in all copies and that both that
  22.  * copyright notice and this permission notice appear in supporting
  23.  * documentation, and that the name of National Semiconductor Corporation not
  24.  * be used in advertising or publicity pertaining to distribution of the
  25.  * software without specific, written prior permission.
  26.  *
  27.  * NATIONAL SEMICONDUCTOR CORPORATION MAKES NO REPRESENTATIONS ABOUT THE
  28.  * SUITABILITY OF THIS SOFTWARE FOR ANY PURPOSE.  IT IS PROVIDED "AS IS"
  29.  * WITHOUT EXPRESS OR IMPLIED WARRANTY.  NATIONAL SEMICONDUCTOR CORPORATION
  30.  * DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED
  31.  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO
  32.  * EVENT SHALL NATIONAL SEMICONDUCTOR CORPORATION BE LIABLE FOR ANY SPECIAL,
  33.  * INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  34.  * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  35.  * OR OTHER TORTUOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  36.  * PERFORMANCE OF THIS SOFTWARE.
  37.  *
  38.  * Author:  Michael C. Wagnitz - National Semiconductor Corporation
  39.  *
  40.  */
  41.  
  42. #define    PARSER
  43.  
  44. #include    "global.h"
  45. #include    "regex.h"
  46. #include    "xmailregex.h"
  47.  
  48. #define        BYTEWIDTH    8
  49. #define        RE_BUFFER    100
  50.  
  51. extern void    reset_mailbox();
  52.  
  53. /*
  54. **  @(#)compile() - regular expression patterns into a pattern table.
  55. **  A pattern table is an array of pattern records.
  56. **  Each pattern record consists of a regular expression,
  57. **  and a buffer for the to-be-compiled regular expression,
  58. */
  59. static void
  60. compile(patternTable)
  61. PatternRec *patternTable;
  62. {
  63.  PatternRec    *p;
  64.  char     fastmap[(1 << BYTEWIDTH)];
  65.  int        i;
  66.  
  67.     for (i=0; patternTable[i].pat; i++) {
  68.     p = &patternTable[i];
  69.     p->buf = (struct re_pattern_buffer *) 
  70.       XtMalloc (sizeof (struct re_pattern_buffer));
  71.     p->buf->allocated = RE_BUFFER;
  72.     p->buf->buffer = (char *) XtMalloc (p->buf->allocated);
  73.     p->buf->fastmap = fastmap;
  74.     p->buf->translate = NULL;
  75.     re_compile_pattern(p->pat, strlen(p->pat), p->buf);
  76.     re_compile_fastmap(p->buf);
  77.     }
  78. } 
  79.  
  80. /*
  81. ** @(#)match() - string against regular expressions in pattern table.
  82. ** The best match is found, and function returns index to the pattern table.
  83. */
  84. int
  85. match(patternTable, string)
  86. PatternRec     *patternTable;
  87. char     *string;
  88. {
  89.     int            m, bestmatch = -1, index = -1, i;
  90.  
  91.     if (strcmp(string, "") == NULL) return -1;
  92.     for (i=0; patternTable[i].pat; i++) {
  93.     m = re_match(patternTable[i].buf, string, strlen(string), 0, NULL);
  94.     if (m > bestmatch) {
  95.         bestmatch = m;
  96.         index = i;
  97.     }
  98.     }
  99.     return index;
  100. }
  101.  
  102. /*
  103. ** @(#)parser_init()- compile output and command pattern tables.
  104. */
  105. void
  106. parser_init()
  107. {
  108.  compile(output_pattern);
  109.  compile(command_pattern);
  110. }
  111.  
  112.  
  113. /*
  114. ** @(#)parse() - command and output and call appropriate handler
  115. */
  116. void
  117. parse(msg)
  118. String    msg;
  119. {
  120.  Cardinal    j, k, msgnum;
  121.  Widget        button, icon, iw;
  122.  char        tmp[128], *c, *s;
  123.  static    Boolean    first_time = True;
  124.  
  125.  
  126.  j = match(command_pattern, Command);
  127.  switch (j) {
  128. /*
  129. ** If error on startup, mail has terminated connection.  Remove our input
  130. ** handler, close the file from our end, and indicate that no connection
  131. ** exists.  Otherwise, establish conversation requirements and display the
  132. ** current message.  If *Show_Last: resource is NOT False, show latest, if
  133. ** none are newer.  We delay setting the icon event handler until now, to
  134. ** ensure mail startup completed before being interrupted by a map event,
  135. ** for the case where we have been started iconic.
  136. */
  137.     case C_START :  if (O_BELL == match(output_pattern, msg)) {
  138.                        if (mailpid) {
  139.                           XtRemoveInput(mailInputId);
  140.                           close(mail_fd);
  141.                           mailpid = 0;
  142.                          }
  143.                LASTCH(msg) = '\0';    /* Don't ring Bell() for this */
  144.                Bell(msg);
  145.                (void) UpdateTitleBar("No current folder");
  146.                        XtFree(msg);
  147.                *msg = '\0';
  148.                       } else {
  149. /*
  150. ** To prevent a race condition (?) when starting the application iconic,
  151. ** (which would cause this loop to repeat multiple times), test the value
  152. ** of the ``screen'' mail environment variable.  If 10,000 then we're done.
  153. */
  154.                        j = True;
  155.                        if (c = GetMailEnv("screen")) {
  156.                           j = (strcmp("10000", c) != 0) ? True : False;
  157.                           XtFree(c);
  158.                          }
  159.                        if (j) {            /* if not yet set to 10000... */
  160.                           strcpy(tmp, "set screen=10000 toplines=100 ");
  161.  
  162.                           /* default action for xmail is hold (ala mailtool) */
  163.  
  164.                           if (c = GetMailrc("nohold")) XtFree(c);
  165.                           else strcat(tmp, "hold");
  166.  
  167.                           c = QueryMail(tmp);
  168.                           XtFree(c);
  169.  
  170.                           strcpy(tmp, "unset crt replyall");
  171.  
  172.                           c = QueryMail(tmp);
  173.                           XtFree(c);
  174.  
  175.                           if (msgnum = file_handler()) {
  176.                              sprintf(tmp, "%d", msgnum);
  177.                              XtFree(msg);
  178.                              msg = QueryMail(tmp);
  179.                             }
  180.                           Bell("");        /* reset any worthy-ness flag */
  181.                           Bell(Default_Status_Info);
  182.                          }
  183.                       }
  184.                     if (first_time) {        /* only need to do this once */
  185.                        first_time = False;
  186.                        icon = XtNameToWidget(toplevel, "icon");
  187.                        XtAddEventHandler(icon, StructureNotifyMask, False,
  188.                                          icon_handler, NULL);
  189.                        if (In_Bogus_Mail_File) {
  190.                           unlink(sprintf(tmp, "%s+", tmpName));
  191.                           XtFree(msg);
  192.                   *msg = '\0';        /* ignore 'skipping' message */
  193.                          }
  194.                       }
  195.                 break;
  196. /*
  197. ** In response to normal or change folder commands, test output.  If an
  198. ** error, display message in status window, and ring bell unless command
  199. ** was save, Save to author, or undelete.  If our current mail message
  200. ** folder is the bogus folder, erase any text and index and note state.
  201. ** If we have text of next mail message, tell index_handler to mark its
  202. ** number, else retrieve the appropriate message text (which also marks
  203. ** its number).  If *Show_Last: resource is NOT False, file cmd shows
  204. ** latest, if none new.
  205. */
  206.     case C_EXEC  :
  207.     case C_FILE  :  j = match(output_pattern, msg);
  208.             switch (j) {
  209.                case O_BELL  :
  210.                               if (strchr("Ssu", *Command))
  211.                                  LASTCH(msg) = '\0';
  212.                               Bell(msg);
  213.                                       XtFree(msg);
  214. /*
  215. ** Save our current message number, because asking about our 'file' status
  216. ** will reset mail's idea of the 'current message' count to one, regardless.
  217. */
  218.                                       msgnum = SelectionNumber(False);
  219. /*
  220. ** Now ask for 'file' status to determine if we are still caught in our 'bogus'
  221. ** mailfile, in order to generate a more meaningful title-bar status message.
  222. */
  223.                                       msg = QueryMail("file");
  224.                                       if (strncmp(&msg[1], tmpName, strlen(tmpName)) == 0) {
  225.                                  (void) UpdateTitleBar("No current folder");
  226.                                          iw = XtNameToWidget(toplevel, "topBox");
  227.                                          writeTo(XtNameToWidget(iw, "indexWindow"), " ");
  228.                                          writeTo(XtNameToWidget(iw, "textWindow.text"), " ");
  229.                                         } else {
  230.                                          (void) UpdateTitleBar(msg);
  231.                                          XtFree(msg);
  232. /*
  233. ** If not in our bogus mail folder, reset the current message
  234. ** number in Mail by again pointing at that numbered message.
  235. */
  236.                                          sprintf(tmp, "f %d", msgnum);
  237.                                          msg = QueryMail(tmp);
  238.                                          if (strchr("Ss", *Command))
  239.                                             markIndex(">S");
  240.                                         }
  241.                                       XtFree(msg);
  242.                                       *msg='\0';
  243.                                       break;
  244.                case O_EXEC  : msgnum = index_handler(0, 0);
  245.                                       break;
  246.                case O_FILE  : msgnum = file_handler();
  247.                               c = strchr(msg, '\n');
  248.                               if ((int)(c - msg) < strlen(msg) - 1) {
  249.                                          *c = '\0';    /* don't bell this */
  250.                      Bell("");    /* clear worthy flag */
  251.                      Bell(msg);
  252.                                 }
  253.                                       XtFree(msg);
  254.                                       *msg = '\0';
  255.                                       if (msgnum) {
  256.                                          sprintf(tmp, "%d", msgnum);
  257.                                          msg = QueryMail(tmp);
  258.                                         }
  259.                               break;
  260.                   }
  261.                     break;
  262. /*
  263. ** When deleting a message, simply mark that index line with a capital 'D'.
  264. ** If un-deleting, mark that index line with a blank ' '.  If no current
  265. ** index, restore it.  If autoprinting, mail will include text of next msg.
  266. */
  267.     case C_DELETE : if (O_BELL == match(output_pattern, msg)) {
  268.                        Bell(msg);
  269.                        XtFree(msg);
  270.                        *msg = '\0';
  271.                       } else {
  272.                        msgnum = SelectionNumber(False);
  273.                        if (*Command == 'd') {
  274.                           if (msgnum) {
  275.                              markIndex("D");
  276.                      msgnum = index_handler(msgnum+1, 0);
  277.                             }
  278.                          } else {        /* if we are 'undeleting' */
  279.                   c = QueryMail("=");
  280.                   sscanf(c, "%d", &msgnum);
  281.                   XtFree(c);
  282.                           iw = XtNameToWidget(toplevel, "topBox.indexWindow");
  283.                           if (TextGetLastPos(iw) < (XawTextPosition) 4) {
  284.                              c = QueryMail("h");
  285.                              writeTo(iw, c);
  286.                      XtFree(c);
  287.                             }
  288.                   msgnum = index_handler(msgnum, 1);
  289.                          }
  290.                        c = QueryMail("file");    /* resets current msg to 1 */
  291.                        (void) UpdateTitleBar(c);
  292.                XtFree(c);
  293.  
  294.                        if (msgnum == 0)    {    /* if was last msg in file */
  295.                           XtFree(msg);
  296.                           msg = XtNewString("\n");    /* erase its text */
  297.                          } else {        /* reset mail's idea of the */
  298.                           sprintf(tmp, "f %d", msgnum); /* current message */
  299.                           c = QueryMail(tmp);
  300.                           XtFree(c);
  301.                          }
  302.                        if (! *msg)        /* Don't allow memory leaks */
  303.                           XtFree(msg);        /* to accumulate if no text */
  304.                       }
  305.             break;
  306. /*
  307. ** In response to a request to view new mail, first reset the mailbox flag.
  308. ** If mail came back with an error, complain to the user.  Otherwise, clear
  309. ** the Newmail command button highlighting. Then display any new mail text.
  310. */
  311.     case C_NEWMAIL:
  312.             button = XtNameToWidget(toplevel, "topBox.commandPanel.Folder");
  313.             UnsetNewmail(button, NULL, NULL);
  314.                     if (O_BELL == match(output_pattern, msg)) {
  315.                        if (strncmp(msg, "No mail for ", 12) == 0) {
  316.                           Bell("No mail in your system mailbox\n");
  317.                          } else { Bell(msg); }
  318.                        XtFree(msg);
  319.                        *msg = '\0';
  320.                       } else {
  321.                        Bell("");        /* reset any worthy-ness flag */
  322.                        Bell(Default_Status_Info);
  323.                        msgnum = file_handler();
  324.                if (*msg) {
  325.                   s = msg;
  326.                   c = strchr(msg, '\n');
  327.                   if ((c - s) + 1 < strlen(msg)) {
  328.                              *c = '\0';    /* don't bell this */
  329.                  Bell(msg);
  330.                             }
  331.                          }
  332.                        XtFree(msg);
  333.                        *msg = '\0';
  334.                        if (msgnum) {
  335.                           sprintf(tmp, "%d", msgnum);
  336.                           msg = QueryMail(tmp);
  337.                          }
  338.                       }
  339.             break;
  340.  
  341.            default: j = match(output_pattern, msg);
  342.             switch (j) {
  343.                        case O_BELL:
  344.                             Bell(msg);
  345.                             XtFree(msg);
  346.                             *msg = '\0';
  347.                     break;
  348. /*
  349. ** If output is from the print command, display a status message
  350. */
  351.                case O_PRINT:
  352.                             sscanf(&Command[2], "%d", &j);
  353.                             c = strrchr(msg, '/');
  354.                             sscanf(c, "/%d", &k);
  355.                             sprintf(tmp,
  356.                              "Message %d sent to printer -- %d bytes\n", j, k);
  357.                             Bell(tmp);
  358.                             XtFree(msg);
  359.                             *msg = '\0';
  360.                     break;
  361.                       }
  362.             break;
  363.    }
  364. /*
  365. ** If any text remains, display it in the bottom (text) window.
  366. */
  367.  if (*msg) {
  368.     for (j = strlen(msg)-1; j > 1 && msg[j] == '\n' && msg[j-1] == '\n'; j--);
  369.     msg[++j] = '\0';            /* drop all but the last newline */
  370.     writeTo(XtNameToWidget(toplevel, "topBox.textWindow.text"), msg);
  371.     XtFree(msg);
  372.     *msg = '\0';
  373.    }
  374. } /* parse */
  375.  
  376. #define    FILEBUF    4096
  377.  
  378. /*
  379. ** @(#)QueryMail() - Sends a command and returns corresponding output.
  380. ** If called by the Xt input procedure readMail, no command is included.
  381. */
  382. char *
  383. QueryMail(cmd)
  384. char    *cmd;
  385. {
  386.  int        j, outputsize, size, length = strlen(MailPrompt);
  387.  char        *temp, s[FILEBUF];
  388.  static char    *output;
  389.  
  390.  
  391.  SetCursor(1);
  392. /*
  393. ** allocate one block to 'output' to begin with
  394. */
  395.  outputsize = FILEBUF;
  396.  output = XtMalloc(outputsize);
  397.  output[0] = '\0';
  398.  
  399.  if (! mailpid)
  400.     Bell("No current mail program connection\n");
  401.  else {
  402.     if (*cmd) {                /* allow us to be called by readMail */
  403.        if (LASTCH(cmd) != '\n')
  404.           sprintf(s, "%s\n", cmd);
  405.        else
  406.           strcpy(s, cmd);
  407.        writeMail(s);
  408.       }
  409.  
  410.     for (;;) {
  411.         if ((size = read(mail_fd, s, FILEBUF)) < 1) {    /* EOF or an error? */
  412.            if (! *output) {
  413.               strcpy(output, "No current mail service connection\n");
  414.               if (mailpid) {
  415.                  XtRemoveInput(mailInputId);
  416.                  close(mail_fd);
  417.                  mailpid = 0;
  418.                 }
  419.              }
  420.            break;
  421.           }
  422.  
  423.         if (size < FILEBUF)
  424.            s[size] = '\0';
  425.  
  426.         if (strlen(output) + size > outputsize) {
  427.            outputsize += FILEBUF;
  428.            temp = XtRealloc(output, outputsize);
  429.            output = temp;
  430.           }
  431.         strcat(output, s);
  432.  
  433.         j = strlen(output) - length;    /* no accidents allowed here */
  434.         if (j < 0) j = 0;        /* no references before zero */
  435.         if (strcmp(&output[j], MailPrompt) == 0) {
  436.            output[j] = '\0';        /* Drop prompt from end of text */
  437.            break;            /* and return from read routine */
  438.           }
  439.  
  440.         if (!strcmp(Command,"Start")) {    /* see if somehow missed the prompt */
  441.            j = strlen(output) - 3;    /* no accidents allowed here either */
  442.            if (j < 0) j = 0;        /* no string references before zero */
  443.            if (strcmp(&output[j], "\n& ") == 0) { /* if default mail prompt */
  444.               output[++j] = '\0';    /* drop prompt from end of string */
  445.               XtFree(MailPrompt);    /* intended prompt is now bogus */
  446.               MailPrompt = XtNewString("& ");    /* reset the mail prompt */
  447.               break;            /* and return from read routine */
  448.              }
  449.           }
  450.  
  451.         if (O_BELL == match(output_pattern,output) && !strcmp(Command,"Start"))
  452.            break;
  453.        }
  454.  
  455.     if (*cmd) 
  456.        LASTCH(output) = '\0';        /* drop newline for normal queries */
  457.    }
  458.  
  459.  temp = XtRealloc(output, strlen(output) + 1);
  460.  output = temp;
  461.  
  462.  SetCursor(0);
  463.  
  464.  return(output);
  465. } /* QueryMail */
  466.