home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / x / volume3 / xdbx / part03 / parser.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-03-14  |  6.6 KB  |  248 lines
  1. /****************************************************************************** 
  2.  *
  3.  *  xdbx - X Window System interface to dbx
  4.  *
  5.  *  Copyright 1989 The University of Texas at Austin
  6.  *
  7.  *  Author:    Po Cheung
  8.  *  Date:    March 10, 1989
  9.  *
  10.  *  Permission to use, copy, modify, and distribute this software and
  11.  *  its documentation for any purpose and without fee is hereby granted,
  12.  *  provided that the above copyright notice appear in all copies and that
  13.  *  both that copyright notice and this permission notice appear in
  14.  *  supporting documentation.  The University of Texas at Austin makes no 
  15.  *  representations about the suitability of this software for any purpose.  
  16.  *  It is provided "as is" without express or implied warranty.
  17.  *
  18.  ******************************************************************************/
  19.  
  20.  
  21. #include    "global.h"
  22. #include    "regex.h"
  23.  
  24. #ifdef BSD
  25. #include    "bsd_regex.h"
  26. #else
  27. #include    "sun_regex.h"
  28. #endif
  29.  
  30. #define        BYTEWIDTH    8
  31. #define        RE_BUFFER    100
  32.  
  33. Tokens             token;        /* token structure */
  34.  
  35. /*
  36.  *  Compile all the regular expression patterns in a pattern table.
  37.  *  A pattern table is an array of pattern records.
  38.  *  Each pattern record consists of a regular
  39.  *  expression, a buffer for the to-be-compiled regular expression,
  40.  *  and an array to associate a given token with a matched register number.
  41.  */
  42. static void compile(patternTable)
  43. PatternRec *patternTable;
  44. {
  45.     PatternRec    *p;
  46.     char     fastmap[(1 << BYTEWIDTH)];
  47.     int        i;
  48.  
  49.     for (i=0; patternTable[i].pat; i++) {
  50.     p = &patternTable[i];
  51.     p->buf = (struct re_pattern_buffer *) 
  52.       XtMalloc (sizeof (struct re_pattern_buffer));
  53.     p->buf->allocated = RE_BUFFER;
  54.     p->buf->buffer = (char *) XtMalloc (p->buf->allocated);
  55.     p->buf->fastmap = fastmap;
  56.     p->buf->translate = NULL;
  57.     re_compile_pattern(p->pat, strlen(p->pat), p->buf);
  58.     re_compile_fastmap(p->buf);
  59.     }
  60. } 
  61.  
  62. /*
  63.  *  This routine tries to match a given string with each regular 
  64.  *  expression in a given pattern table.  The best match is found, and
  65.  *  the function returns an index to the pattern table.
  66.  */
  67. static int match(patternTable, string)
  68.     PatternRec     *patternTable;
  69.     char     *string;
  70. {
  71.     struct re_registers    regs;
  72.     int            m, bestmatch = -1, index = -1, i, j, r, start, n;
  73.     char         *s;
  74.  
  75.     if (strcmp(string, "") == NULL) return -1;
  76.     for (i=0; patternTable[i].pat; i++) {
  77.     m = re_match(patternTable[i].buf, string, strlen(string), 0, ®s);
  78.     if (m > bestmatch) {
  79.         bestmatch = m;
  80.         index = i;
  81.         token.mesg = token.file = token.func = NULL;
  82.         token.line = token.stop = 0;
  83.         for (j=0; j<NTOKENS; j++) {
  84.         if ((r = patternTable[i].reg_token[j]) >= 0) {
  85.             start = regs.start[r];
  86.             if ((n = regs.end[r] - start) > 0) {
  87.             s = (char *) XtMalloc ((n+1) * sizeof(char));
  88.             strncpy(s, string+start, n);
  89.             s[n] = '\0';
  90.                 switch (j) {
  91.                 case 0: token.mesg = s; break;
  92.                 case 1: token.stop = atoi(s); XtFree(s); break;
  93.                 case 2: token.func = s; break;
  94.                 case 3: token.line = atoi(s); XtFree(s); break;
  95.                 case 4: token.file = s; break;
  96.                 }
  97.             }
  98.         }
  99.         }
  100.     }
  101.     }
  102.     return index;
  103. }
  104.  
  105. /*  PUBLIC ROUTINES */
  106.  
  107. /*  Compile the regular expressions in the output and command pattern tables. */
  108.  
  109. void parser_init()
  110. {
  111.     compile(output_pattern);
  112.     compile(command_pattern);
  113. }
  114.  
  115.  
  116. /*  This routine first parses the command string.  
  117.  *  If the command is one of run, cont, next, step, stop at, stop in, 
  118.  *  where, up, or down, it parses the dbx output to decide what action 
  119.  *  to take and dispatch it to one of the handlers.
  120.  *  For other commands, the appropriate handler is called.
  121.  */
  122. void parse(output)
  123. char *output;
  124. {
  125.     int  handler, command_flag;
  126.  
  127.     command_flag = match(command_pattern, Command);
  128.     switch (command_flag) {
  129.           case C_EXEC: 
  130.     case C_STOPAT: 
  131.     case C_STOPIN: 
  132.     case C_UPDOWN:
  133.         handler = match(output_pattern, output);
  134.         switch (handler) {
  135.           case O_EXEC  : exec_handler(&token, FALSE); break;
  136.           case O_DONE  : exec_handler(&token, TRUE); break;
  137.           case O_STOPAT: stop_at_handler(&token); break;
  138.           case O_STOPIN: stop_in_handler(&token); break;
  139.           case O_UPDOWN: updown_handler(&token); break;
  140.           case O_BELL  : Bell(0); break;
  141.         }
  142.         break;
  143.           case C_DELETE:
  144.         delete_handler(); 
  145.         break;
  146.     case C_FUNC:
  147.         if (strcmp(output, "") == NULL)
  148.             func_handler(&token); 
  149.         break;
  150.     case C_FILE:
  151.         file_handler(&token); 
  152.         break;
  153.     case C_DEBUG:
  154.         debug_handler(); 
  155.         break;
  156.     case C_CD:
  157.         if (strcmp(output, "") == NULL)
  158.             cd_handler(); 
  159.         break;
  160.     }
  161. }
  162.  
  163.  
  164. /*  This function edits the dbx output so that unnecessary information is 
  165.  *  not displayed on the dialog window.
  166.  *  It filters away the information about the halted execution point,
  167.  *  returned by the execution commands.
  168.  *  On Sun dbx, it also filters away the output returned by the up and 
  169.  *  down commands.
  170.  */
  171. void filter(s)
  172. char *s;
  173. {
  174.     struct re_registers regs;
  175.     char         *p, *q;
  176.     int            r;
  177.     static Boolean    DeleteNextLine = FALSE;
  178.  
  179.     if ((s && strcmp(s, "") == NULL) || strcmp(Command, "") == NULL)
  180.     return;
  181.  
  182. #ifndef BSD  /* for Sun dbx only */
  183.     if (re_match(command_pattern[C_UPDOWN].buf, Command, strlen(Command), 
  184.          0, NULL) > 0) {
  185.     if (re_match(output_pattern[O_BELL].buf, s, strlen(s), 0, ®s) < 0) {
  186.         if (strcmp(s+strlen(s)-strlen(PROMPT), PROMPT) == NULL)
  187.             strcpy(s, PROMPT);
  188.         else
  189.         strcpy(s, "");
  190.     }
  191.     return;
  192.     }
  193. #endif
  194.  
  195.     if (re_match(command_pattern[C_EXEC].buf, Command, strlen(Command), 
  196.          0, NULL) > 0
  197.     && re_match(output_pattern[O_EXEC].buf, s, strlen(s), 0, ®s) > 0) {
  198.     r = output_pattern[O_EXEC].reg_token[TK_MESG];
  199.     for (p=s+regs.start[r]; p!=s && *(p-1) != '\n'; p--);
  200.     if (q = (char *) strchr(s+regs.end[r]+1, '\n'))
  201.         strcpy(p, q+1);
  202.     else {
  203.         DeleteNextLine = TRUE;
  204.         *p = '\0';
  205.     }
  206.     return;
  207.     }
  208.  
  209.     if (DeleteNextLine) {
  210.     p = (char *) strchr(s, '\n');
  211.     strcpy(s, p+1);
  212.     DeleteNextLine = FALSE;
  213.     }
  214. }
  215.  
  216.  
  217. /*  Sends a command to dbx and read the corresponding output, bypassing the
  218.  *  Xt input procedure, readDbx.
  219.  */
  220. int QueryDbx(command, do_match)
  221. char *command;
  222. Boolean do_match;
  223. {
  224.     char s[LINESIZ], *output;
  225.     int  outputsize;
  226.  
  227.     Echo = FALSE;
  228.     writeDbx(command);
  229.     /* allocate one block to 'output' to begin with */
  230.     outputsize = BUFSIZ;
  231.     output = XtMalloc(outputsize);
  232.     strcpy(output, "");
  233.  
  234.     while (fgets(s, LINESIZ, dbxfp) == NULL);
  235.     do {
  236.     if (strlen(output) + strlen(s) > outputsize) {
  237.         output = XtRealloc(output, outputsize + BUFSIZ);
  238.         outputsize += BUFSIZ;
  239.     }
  240.         strcat(output, s);
  241.     } while (fgets(s, LINESIZ, dbxfp));
  242.     Echo = TRUE;
  243.     if (do_match)
  244.         return match(output_pattern, output);
  245.     else
  246.         return -1;
  247. }
  248.