home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_progs / fileutil / scan.lha / src / findrestofmt.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-05-21  |  30.4 KB  |  931 lines
  1.  
  2. /* Copyright © 1991, 1992 by Walter Rothe. You may freely use and modify this
  3.  * program, but not for commercial profit. A modest fee for distribution is
  4.  * allowed. Derivative works must be released with source along with the
  5.  * executable or provisions made to provide the user source, if requested.
  6.  * Uploading source to a major bulletin board system within 6 months of the
  7.  * time of the request satisfies this requirement. This copyright notice
  8.  * must not be deleted from the source.
  9.  */
  10.  
  11. /* This program makes sure the rest of a major term matches the specified  */
  12. /* pattern.                                                                */
  13.  
  14. /* The "&" function requires that patterns on the left and right of the    */
  15. /* "&" match what they are supposed to and that both are in the same       */
  16. /* sentence or context. A sentence or context is delimited by the          */
  17. /* following items:                                                        */
  18. /*                                                                         */
  19. /* 1) period followed by a space or line feed                              */
  20. /* 2) a maximum of OVERLAP characters                                      */
  21. /* 3) two newline chars with no chars but ">" between them                 */
  22. /* 4) start or end of article                                              */
  23. /* 5) newline before a colon                                               */
  24.  
  25. /* The "*" function requires that the pattern on the left and right of the */
  26. /* "*" match what they are supposed to and that both are in the same word. */
  27. /* A space or newline char delimits words.                                 */
  28.  
  29. /* Note: Since end of article delimiter is not known until later, there is */
  30. /* a possibility of matching something in the next article during a right  */
  31. /* look. Normally this should not present a major problem since the data   */
  32. /* around an article separator is usually not used to search on and a      */
  33. /* sentence delimiter will usually be very quickly found. This should not  */
  34. /* be handled in this routine. BP should be saved on exit from this pgm    */
  35. /* and used to determine if a real match occured when the next article     */
  36. /* delimiter is found. At that point, you can rescan the article. You      */
  37. /* could also modify scan.c so that once OutArt is set, you continue to    */
  38. /* check for matches and when you find the article sep, determine if a     */
  39. /* real match occured.                                                     */
  40.  
  41. #include <stdio.h>
  42. #include <exec/types.h>
  43. #include <exec/memory.h>
  44. #include <libraries/dos.h>
  45. #include <libraries/dosextens.h>
  46. #include <functions.h>
  47. #include "fcntl.h"
  48. #include "ctype.h"
  49. #include <string.h>
  50. #include "scan.h"
  51.  
  52. #define FRSTWRDLCKSTP  0
  53. #define FRSTWRDLCKSTP1 1
  54. #define FRSTWRDLCKSTP2 2
  55. #define FRSTWRDLCKSTP3 3
  56. #define WRDLOCKSTEP    4
  57. #define WRDLOCKSTEP1   5
  58. #define WRDLOCKSTEP2   6
  59. #define SENTENCELOOK   7
  60. #define WORDLOOK       8
  61. #define WORDLOOK1      9
  62. #define FRSTWRDLOOK    10
  63. #define FRSTWRDLOOK1   11
  64. #define FRSTWRDLOOK2   12
  65.  
  66. int FindRestOfMT(BI,MTI)
  67. char *BI;                         /* Buffer Index                            */
  68. unsigned char MTI;                /* Major Term Index                        */
  69. {
  70.    extern int FDsplTbl[];         /* offset from BI to strt of token         */
  71.    extern Lines NoBrakAry[];      /* same as above but no 0's for &,*,?,[    */
  72.    extern char *NBAryEnd[];       /* pntrs to end of MT string in NBAry      */
  73.    extern int TokStrt[];          /* indx 2 1st byte of token in nobrakarray */
  74.    extern int TokEnd[];           /* indx 2 last byte of token in nobrak     */
  75.    extern char *EOCB;             /* end of current buffer + 1               */
  76.    extern int ArtInPrevBuf;       /* 1 if article strt is in previous buffer */
  77.    extern char *CurArtStrt;       /* Pntr 2 strt of article in a buffer      */
  78.    extern ErrP();
  79.    extern char LowrCs[];          /* Convert mixed case to lower case        */
  80.    extern BrakTyp1 *BrakIdx;
  81.    extern BrakTyp2 *BrakPtr;
  82.  
  83.    char *BP;                      /* Buffer pointer                          */
  84.    char *BPPntr;
  85.    char *FStrt;
  86.    char *FEnd;
  87.    char *LookSrcP;
  88.    char *NBAS;
  89.    char *SenStrt;          /* earliest into buffer that sentence could start */
  90.    char *SenEnd;
  91.    char *LookStrt,*LookStrt1,*LookStrt2;
  92.    char *BPStrt,*BPStrt1,*BPStrt2;
  93.    unsigned char MTN;
  94.    int FoundColon=0;
  95.    unsigned char Mode;
  96.  
  97.    MTN = MTI >> 1;
  98.    BP = BI + FDsplTbl[MTI];
  99.    LookSrcP = &NoBrakAry[MTN][TokStrt[MTI]] - 1;
  100.    FStrt = (char *)&NoBrakAry[MTN];
  101.    Mode = FRSTWRDLCKSTP;
  102.    SenStrt = BI - OVERLAP + MAXKWSZ;
  103.    /* if article start is in current buffer and is bigger than the earliest */
  104.    /* into the buff that the sentence could start, set sentence start to it */
  105.    if (!ArtInPrevBuf && (CurArtStrt > SenStrt)) { SenStrt = CurArtStrt; }
  106.    while (LookSrcP >= FStrt) {
  107.       switch(*LookSrcP) {
  108.  
  109.          case('*'):
  110.             LookSrcP--;
  111.             if (LookSrcP < FStrt) { continue; }
  112.             switch(Mode) {
  113.                case(FRSTWRDLCKSTP):
  114.                   LookStrt = LookSrcP;
  115.                   Mode = FRSTWRDLOOK; break;
  116.                case(FRSTWRDLCKSTP1):
  117.                   LookStrt1 = LookSrcP;
  118.                   Mode = FRSTWRDLOOK1; break;
  119.                case(FRSTWRDLCKSTP2):
  120.                   LookStrt2 = LookSrcP;
  121.                   Mode = FRSTWRDLOOK2; break;
  122.                case(FRSTWRDLCKSTP3):
  123.                   ErrP("Only supports up to 3 * in a word\n");
  124.                case(WRDLOCKSTEP):
  125.                   LookStrt1 = LookSrcP;
  126.                   Mode = WORDLOOK; break;
  127.                case(WRDLOCKSTEP1):
  128.                   LookStrt2 = LookSrcP;
  129.                   Mode = WORDLOOK1; break;
  130.                case(WRDLOCKSTEP2):
  131.                   ErrP("Only supports up to 3 * in a word\n");
  132.             }
  133.             break;
  134.  
  135.          case('&'):
  136.             if (--LookSrcP < FStrt) { continue; }
  137.             if (*LookSrcP == '*') {
  138.                if (--LookSrcP < FStrt) { continue; }
  139.             }
  140.             LookStrt = LookSrcP;
  141.             Mode = SENTENCELOOK; break;
  142.  
  143.          case('['):
  144.             NBAS = &NoBrakAry[MTN][0];
  145.             break;
  146.  
  147.          default: { break; }
  148.       }
  149.       BP--;
  150.       switch(Mode) {
  151.  
  152.          case(SENTENCELOOK):
  153.             /* check if BP is passed a sentence/context delimiter */
  154.             if (BP < SenStrt) { return(0); }
  155.             switch(*BP) {
  156.                case(':'):
  157.                   FoundColon = 1; break;
  158.                case('\n'):
  159.                   if(FoundColon) { return(0); }
  160.                   BPPntr = BP + 1;
  161.                   while (*BPPntr == '>') { BPPntr++; }
  162.                   if (*BPPntr == '\n') { return(0); }
  163.                   break;
  164.                case('.'):
  165.                   if(*(BP+1) == ' ' || *(BP+1) == '\n') { return(0); }
  166.                   break;
  167.             }
  168.             switch(*LookSrcP) {
  169.                case('?'):
  170.                   Mode = WRDLOCKSTEP;
  171.                   BPStrt = BP;
  172.                   LookSrcP--;
  173.                   break;
  174.                case('['):
  175.                   if (BrakPtr[MTN][BrakIdx[MTN][LookSrcP-NBAS]][*BP]) {
  176.                      Mode = WRDLOCKSTEP;
  177.                      BPStrt = BP;
  178.                      LookSrcP--;
  179.                   }
  180.                   break;
  181.                default:
  182.                   if (LowrCs[*BP] == LowrCs[*LookSrcP]) {
  183.                      Mode = WRDLOCKSTEP;
  184.                      BPStrt = BP;
  185.                      LookSrcP--;
  186.                   }
  187.                   break;
  188.             }
  189.             break;
  190.  
  191.          case(WORDLOOK)    :
  192.             if ((BP < SenStrt) || (*BP==' ') || (*BP=='\n')) {
  193.                /* word did not match */
  194.                LookSrcP = LookStrt;
  195.                Mode = SENTENCELOOK;
  196.                BP = BPStrt;
  197.             }
  198.             else {
  199.                switch(*LookSrcP) {
  200.                   case('?'):
  201.                      Mode = WRDLOCKSTEP1;
  202.                      BPStrt1 = BP;
  203.                      LookSrcP--;
  204.                      break;
  205.                   case('['):
  206.                      if (BrakPtr[MTN][BrakIdx[MTN][LookSrcP-NBAS]][*BP]) {
  207.                         Mode = WRDLOCKSTEP1;
  208.                         BPStrt1 = BP;
  209.                         LookSrcP--;
  210.                      }
  211.                      break;
  212.                   default:
  213.                      if (LowrCs[*BP] == LowrCs[*LookSrcP]) {
  214.                         Mode = WRDLOCKSTEP1;
  215.                         BPStrt1 = BP;
  216.                         LookSrcP--;
  217.                      }
  218.                      break;
  219.                }
  220.             }
  221.             break;
  222.  
  223.          case(WORDLOOK1)    :
  224.             if ((BP < SenStrt) || (*BP==' ') || (*BP=='\n')) {
  225.                /* word did not match */
  226.                LookSrcP = LookStrt;
  227.                Mode = WORDLOOK;
  228.                BP = BPStrt1;
  229.             }
  230.             else {
  231.                switch(*LookSrcP) {
  232.                   case('?'):
  233.                      Mode = WRDLOCKSTEP2;
  234.                      BPStrt2 = BP;
  235.                      LookSrcP--;
  236.                      break;
  237.                   case('['):
  238.                      if (BrakPtr[MTN][BrakIdx[MTN][LookSrcP-NBAS]][*BP]) {
  239.                         Mode = WRDLOCKSTEP2;
  240.                         BPStrt2 = BP;
  241.                         LookSrcP--;
  242.                      }
  243.                      break;
  244.                   default:
  245.                      if (LowrCs[*BP] == LowrCs[*LookSrcP]) {
  246.                         Mode = WRDLOCKSTEP2;
  247.                         BPStrt2 = BP;
  248.                         LookSrcP--;
  249.                      }
  250.                      break;
  251.                }
  252.             }
  253.             break;
  254.  
  255.          case(FRSTWRDLOOK)    :
  256.             if ((*BP==' ') || (*BP=='\n')) {
  257.                /* word did not match */
  258.                return(0);
  259.             }
  260.             else {
  261.                switch(*LookSrcP) {
  262.                   case('?'):
  263.                      Mode = FRSTWRDLCKSTP1;
  264.                      BPStrt = BP;
  265.                      LookSrcP--;
  266.                      break;
  267.                   case('['):
  268.                      if (BrakPtr[MTN][BrakIdx[MTN][LookSrcP-NBAS]][*BP]) {
  269.                         Mode = FRSTWRDLCKSTP1;
  270.                         BPStrt = BP;
  271.                         LookSrcP--;
  272.                      }
  273.                      break;
  274.                   default:
  275.                      if (LowrCs[*BP] == LowrCs[*LookSrcP]) {
  276.                         Mode = FRSTWRDLCKSTP1;
  277.                         BPStrt = BP;
  278.                         LookSrcP--;
  279.                      }
  280.                      break;
  281.                }
  282.             }
  283.             break;
  284.  
  285.          case(FRSTWRDLOOK1)    :
  286.             if ((*BP==' ') || (*BP=='\n')) {
  287.                /* word did not match */
  288.                Mode = FRSTWRDLOOK;
  289.                BP = BPStrt;
  290.                LookSrcP = LookStrt;
  291.             }
  292.             else {
  293.                switch(*LookSrcP) {
  294.                   case('?'):
  295.                      Mode = FRSTWRDLCKSTP2;
  296.                      BPStrt1 = BP;
  297.                      LookSrcP--;
  298.                      break;
  299.                   case('['):
  300.                      if (BrakPtr[MTN][BrakIdx[MTN][LookSrcP-NBAS]][*BP]) {
  301.                         Mode = FRSTWRDLCKSTP2;
  302.                         BPStrt1 = BP;
  303.                         LookSrcP--;
  304.                      }
  305.                      break;
  306.                   default:
  307.                      if (LowrCs[*BP] == LowrCs[*LookSrcP]) {
  308.                         Mode = FRSTWRDLCKSTP2;
  309.                         BPStrt1 = BP;
  310.                         LookSrcP--;
  311.                      }
  312.                      break;
  313.                }
  314.             }
  315.             break;
  316.  
  317.          case(FRSTWRDLOOK2)    :
  318.             if ((*BP==' ') || (*BP=='\n')) {
  319.                /* word did not match */
  320.                Mode = FRSTWRDLOOK1;
  321.                BP = BPStrt1;
  322.                LookSrcP = LookStrt1;
  323.             }
  324.             else {
  325.                switch(*LookSrcP) {
  326.                   case('?'):
  327.                      Mode = FRSTWRDLCKSTP3;
  328.                      BPStrt2 = BP;
  329.                      LookSrcP--;
  330.                      break;
  331.                   case('['):
  332.                      if (BrakPtr[MTN][BrakIdx[MTN][LookSrcP-NBAS]][*BP]) {
  333.                         Mode = FRSTWRDLCKSTP3;
  334.                         BPStrt2 = BP;
  335.                         LookSrcP--;
  336.                      }
  337.                      break;
  338.                   default:
  339.                      if (LowrCs[*BP] == LowrCs[*LookSrcP]) {
  340.                         Mode = FRSTWRDLCKSTP3;
  341.                         BPStrt2 = BP;
  342.                         LookSrcP--;
  343.                      }
  344.                      break;
  345.                }
  346.             }
  347.             break;
  348.  
  349.          case(WRDLOCKSTEP) :
  350.             switch(*LookSrcP) {
  351.                case('?'):
  352.                   LookSrcP--;
  353.                   break;
  354.                case('['):
  355.                   if (!BrakPtr[MTN][BrakIdx[MTN][LookSrcP-NBAS]][*BP]) {
  356.                      LookSrcP = LookStrt;
  357.                      Mode = SENTENCELOOK;
  358.                      BP = BPStrt;
  359.                   }
  360.                   else { LookSrcP--; }
  361.                   break;
  362.                default:
  363.                   if (LowrCs[*BP] != LowrCs[*LookSrcP]) {
  364.                      LookSrcP = LookStrt;
  365.                      Mode = SENTENCELOOK;
  366.                      BP = BPStrt;
  367.                   }
  368.                   else { LookSrcP--; }
  369.                   break;
  370.             }
  371.             break;
  372.  
  373.          case(WRDLOCKSTEP1) :
  374.             switch(*LookSrcP) {
  375.                case('?'):
  376.                   LookSrcP--;
  377.                   break;
  378.                case('['):
  379.                   if (!BrakPtr[MTN][BrakIdx[MTN][LookSrcP-NBAS]][*BP]) {
  380.                      LookSrcP = LookStrt1;
  381.                      Mode = WORDLOOK;
  382.                      BP = BPStrt1;
  383.                   }
  384.                   else { LookSrcP--; }
  385.                   break;
  386.                default:
  387.                   if (LowrCs[*BP] != LowrCs[*LookSrcP]) {
  388.                      LookSrcP = LookStrt1;
  389.                      Mode = WORDLOOK;
  390.                      BP = BPStrt1;
  391.                   }
  392.                   else { LookSrcP--; }
  393.                   break;
  394.             }
  395.             break;
  396.  
  397.          case(WRDLOCKSTEP2) :
  398.             switch(*LookSrcP) {
  399.                case('?'):
  400.                   LookSrcP--;
  401.                   break;
  402.                case('['):
  403.                   if (!BrakPtr[MTN][BrakIdx[MTN][LookSrcP-NBAS]][*BP]) {
  404.                      LookSrcP = LookStrt2;
  405.                      Mode = WORDLOOK1;
  406.                      BP = BPStrt2;
  407.                   }
  408.                   else { LookSrcP--; }
  409.                   break;
  410.                default:
  411.                   if (LowrCs[*BP] != LowrCs[*LookSrcP]) {
  412.                      LookSrcP = LookStrt2;
  413.                      Mode = WORDLOOK1;
  414.                      BP = BPStrt2;
  415.                   }
  416.                   else { LookSrcP--; }
  417.                   break;
  418.             }
  419.             break;
  420.  
  421.          case(FRSTWRDLCKSTP) :
  422.             switch(*LookSrcP) {
  423.                case('?'):
  424.                   LookSrcP--;
  425.                   break;
  426.                case('['):
  427.                   if (!BrakPtr[MTN][BrakIdx[MTN][LookSrcP-NBAS]][*BP]) {
  428.                      return(0);
  429.                   }
  430.                   LookSrcP--;
  431.                   break;
  432.                default:
  433.                   if (LowrCs[*BP] != LowrCs[*LookSrcP]) {
  434.                      return(0);
  435.                   }
  436.                   LookSrcP--;
  437.                   break;
  438.             }
  439.             break;
  440.  
  441.          case(FRSTWRDLCKSTP1) :
  442.             switch(*LookSrcP) {
  443.                case('?'):
  444.                   LookSrcP--;
  445.                   break;
  446.                case('['):
  447.                   if (!BrakPtr[MTN][BrakIdx[MTN][LookSrcP-NBAS]][*BP]) {
  448.                      Mode = FRSTWRDLOOK;
  449.                      LookSrcP = LookStrt;
  450.                      BP = BPStrt;
  451.                   }
  452.                   else { LookSrcP--; }
  453.                   break;
  454.                default:
  455.                   if (LowrCs[*BP] != LowrCs[*LookSrcP]) {
  456.                      Mode = FRSTWRDLOOK;
  457.                      LookSrcP = LookStrt;
  458.                      BP = BPStrt;
  459.                   }
  460.                   else { LookSrcP--; }
  461.                   break;
  462.             }
  463.             break;
  464.  
  465.          case(FRSTWRDLCKSTP2) :
  466.             switch(*LookSrcP) {
  467.                case('?'):
  468.                   LookSrcP--;
  469.                   break;
  470.                case('['):
  471.                   if (!BrakPtr[MTN][BrakIdx[MTN][LookSrcP-NBAS]][*BP]) {
  472.                      Mode = FRSTWRDLOOK1;
  473.                      LookSrcP = LookStrt1;
  474.                      BP = BPStrt1;
  475.                   }
  476.                   else { LookSrcP--; }
  477.                   break;
  478.                default:
  479.                   if (LowrCs[*BP] != LowrCs[*LookSrcP]) {
  480.                      Mode = FRSTWRDLOOK1;
  481.                      LookSrcP = LookStrt1;
  482.                      BP = BPStrt1;
  483.                   }
  484.                   else { LookSrcP--; }
  485.                   break;
  486.             }
  487.             break;
  488.  
  489.          case(FRSTWRDLCKSTP3) :
  490.             switch(*LookSrcP) {
  491.                case('?'):
  492.                   LookSrcP--;
  493.                   break;
  494.                case('['):
  495.                   if (!BrakPtr[MTN][BrakIdx[MTN][LookSrcP-NBAS]][*BP]) {
  496.                      Mode = FRSTWRDLOOK2;
  497.                      LookSrcP = LookStrt2;
  498.                      BP = BPStrt2;
  499.                   }
  500.                   else { LookSrcP--; }
  501.                   break;
  502.                default:
  503.                   if (LowrCs[*BP] != LowrCs[*LookSrcP]) {
  504.                      Mode = FRSTWRDLOOK2;
  505.                      LookSrcP = LookStrt2;
  506.                      BP = BPStrt2;
  507.                   }
  508.                   else { LookSrcP--; }
  509.                   break;
  510.             }
  511.             break;
  512.       }
  513.    }
  514.    BP = BI + FDsplTbl[MTI] + TokEnd[MTI] - TokStrt[MTI];
  515.    LookSrcP = &NoBrakAry[MTN][TokEnd[MTI]] + 1;
  516.    FEnd  = NBAryEnd[MTN];
  517.    Mode = FRSTWRDLCKSTP;
  518.    SenEnd = BI + OVERLAP - MAXKWSZ;
  519.    if (EOCB <= SenEnd) { SenEnd = EOCB - 1; }
  520.    while (LookSrcP <= FEnd) {
  521.       switch(*LookSrcP) {
  522.          case('*'):
  523.             LookSrcP++;
  524.             if (LookSrcP > FEnd) { continue; }
  525.             switch(Mode) {
  526.                case(FRSTWRDLCKSTP):
  527.                   LookStrt = LookSrcP;
  528.                   Mode = FRSTWRDLOOK; break;
  529.                case(FRSTWRDLCKSTP1):
  530.                   LookStrt1 = LookSrcP;
  531.                   Mode = FRSTWRDLOOK1; break;
  532.                case(FRSTWRDLCKSTP2):
  533.                   LookStrt2 = LookSrcP;
  534.                   Mode = FRSTWRDLOOK2; break;
  535.                case(FRSTWRDLCKSTP3):
  536.                   ErrP("Only supports up to 3 * in a word\n");
  537.                case(WRDLOCKSTEP):
  538.                   LookStrt1 = LookSrcP;
  539.                   Mode = WORDLOOK; break;
  540.                case(WRDLOCKSTEP1):
  541.                   LookStrt2 = LookSrcP;
  542.                   Mode = WORDLOOK1; break;
  543.                case(WRDLOCKSTEP2):
  544.                   ErrP("Only supports up to 3 * in a word\n");
  545.             }
  546.             break;
  547.  
  548.          case('&'):
  549.             if (++LookSrcP > FEnd) { continue; }
  550.             if (*LookSrcP == '*') {
  551.                if (++LookSrcP > FEnd) { continue; }
  552.             }
  553.             LookStrt = LookSrcP;
  554.             Mode = SENTENCELOOK; break;
  555.  
  556.          case('['):
  557.             NBAS = &NoBrakAry[MTN][0];
  558.             break;
  559.  
  560.          default: { break; }
  561.       }
  562.       BP++;
  563.       switch(Mode) {
  564.  
  565.          case(SENTENCELOOK):
  566.             /* check if BP is passed a sentence/context delimiter */
  567.             if (BP > SenEnd) { return(0); }
  568.             switch(*BP) {
  569.                case('\n'):
  570.                   BPPntr = BP - 1;
  571.                   if(*(BPPntr) == '.') { return(0); }
  572.                   while (*BPPntr == '>') { BPPntr--; }
  573.                   if (*BPPntr == '\n') { return(0); }
  574.                   break;
  575.  
  576.                case(' '):
  577.                   if(*(BP-1) == '.') { return(0); }
  578.                   break;
  579.             }
  580.             switch(*LookSrcP) {
  581.                case('?'):
  582.                   Mode = WRDLOCKSTEP;
  583.                   BPStrt = BP;
  584.                   LookSrcP++;
  585.                   break;
  586.                case('['):
  587.                   if (BrakPtr[MTN][BrakIdx[MTN][LookSrcP-NBAS]][*BP]) {
  588.                      Mode = WRDLOCKSTEP;
  589.                      BPStrt = BP;
  590.                      LookSrcP++;
  591.                   }
  592.                   break;
  593.                default:
  594.                   if (LowrCs[*BP] == LowrCs[*LookSrcP]) {
  595.                      Mode = WRDLOCKSTEP;
  596.                      BPStrt = BP;
  597.                      LookSrcP++;
  598.                   }
  599.                   break;
  600.             }
  601.             break;
  602.  
  603.          case(WORDLOOK)    :
  604.             if ((BP > SenEnd) || (*BP==' ') || (*BP=='\n')) {
  605.                /* word did not match */
  606.                LookSrcP = LookStrt;
  607.                Mode = SENTENCELOOK;
  608.                BP = BPStrt;
  609.             }
  610.             else {
  611.                switch(*LookSrcP) {
  612.                   case('?'):
  613.                      Mode = WRDLOCKSTEP1;
  614.                      BPStrt1 = BP;
  615.                      LookSrcP++;
  616.                      break;
  617.                   case('['):
  618.                      if (BrakPtr[MTN][BrakIdx[MTN][LookSrcP-NBAS]][*BP]) {
  619.                         Mode = WRDLOCKSTEP1;
  620.                         BPStrt1 = BP;
  621.                         LookSrcP++;
  622.                      }
  623.                      break;
  624.                   default:
  625.                      if (LowrCs[*BP] == LowrCs[*LookSrcP]) {
  626.                         Mode = WRDLOCKSTEP1;
  627.                         BPStrt1 = BP;
  628.                         LookSrcP++;
  629.                      }
  630.                      break;
  631.                }
  632.             }
  633.             break;
  634.  
  635.          case(WORDLOOK1)    :
  636.             if ((BP > SenEnd) || (*BP==' ') || (*BP=='\n')) {
  637.                /* word did not match */
  638.                LookSrcP = LookStrt;
  639.                Mode = WORDLOOK;
  640.                BP = BPStrt1;
  641.             }
  642.             else {
  643.                switch(*LookSrcP) {
  644.                   case('?'):
  645.                      Mode = WRDLOCKSTEP2;
  646.                      BPStrt2 = BP;
  647.                      LookSrcP++;
  648.                      break;
  649.                   case('['):
  650.                      if (BrakPtr[MTN][BrakIdx[MTN][LookSrcP-NBAS]][*BP]) {
  651.                         Mode = WRDLOCKSTEP2;
  652.                         BPStrt2 = BP;
  653.                         LookSrcP++;
  654.                      }
  655.                      break;
  656.                   default:
  657.                      if (LowrCs[*BP] == LowrCs[*LookSrcP]) {
  658.                         Mode = WRDLOCKSTEP2;
  659.                         BPStrt2 = BP;
  660.                         LookSrcP++;
  661.                      }
  662.                      break;
  663.                }
  664.             }
  665.             break;
  666.  
  667.          case(FRSTWRDLOOK)    :
  668.             if ((*BP==' ') || (*BP=='\n')) {
  669.                /* word did not match */
  670.                return(0);
  671.             }
  672.             else {
  673.                switch(*LookSrcP) {
  674.                   case('?'):
  675.                      Mode = FRSTWRDLCKSTP1;
  676.                      BPStrt = BP;
  677.                      LookSrcP++;
  678.                      break;
  679.                   case('['):
  680.                      if (BrakPtr[MTN][BrakIdx[MTN][LookSrcP-NBAS]][*BP]) {
  681.                         Mode = FRSTWRDLCKSTP1;
  682.                         BPStrt = BP;
  683.                         LookSrcP++;
  684.                      }
  685.                      break;
  686.                   default:
  687.                      if (LowrCs[*BP] == LowrCs[*LookSrcP]) {
  688.                         Mode = FRSTWRDLCKSTP1;
  689.                         BPStrt = BP;
  690.                         LookSrcP++;
  691.                      }
  692.                      break;
  693.                }
  694.             }
  695.             break;
  696.  
  697.          case(FRSTWRDLOOK1)    :
  698.             if ((*BP==' ') || (*BP=='\n')) {
  699.                /* word did not match */
  700.                Mode = FRSTWRDLOOK;
  701.                BP = BPStrt;
  702.                LookSrcP = LookStrt;
  703.             }
  704.             else {
  705.                switch(*LookSrcP) {
  706.                   case('?'):
  707.                      Mode = FRSTWRDLCKSTP2;
  708.                      BPStrt1 = BP;
  709.                      LookSrcP++;
  710.                      break;
  711.                   case('['):
  712.                      if (BrakPtr[MTN][BrakIdx[MTN][LookSrcP-NBAS]][*BP]) {
  713.                         Mode = FRSTWRDLCKSTP2;
  714.                         BPStrt1 = BP;
  715.                         LookSrcP++;
  716.                      }
  717.                      break;
  718.                   default:
  719.                      if (LowrCs[*BP] == LowrCs[*LookSrcP]) {
  720.                         Mode = FRSTWRDLCKSTP2;
  721.                         BPStrt1 = BP;
  722.                         LookSrcP++;
  723.                      }
  724.                      break;
  725.                }
  726.             }
  727.             break;
  728.  
  729.          case(FRSTWRDLOOK2)    :
  730.             if ((*BP==' ') || (*BP=='\n')) {
  731.                /* word did not match */
  732.                Mode = FRSTWRDLOOK1;
  733.                BP = BPStrt1;
  734.                LookSrcP = LookStrt1;
  735.             }
  736.             else {
  737.                switch(*LookSrcP) {
  738.                   case('?'):
  739.                      Mode = FRSTWRDLCKSTP3;
  740.                      BPStrt2 = BP;
  741.                      LookSrcP++;
  742.                      break;
  743.                   case('['):
  744.                      if (BrakPtr[MTN][BrakIdx[MTN][LookSrcP-NBAS]][*BP]) {
  745.                         Mode = FRSTWRDLCKSTP3;
  746.                         BPStrt2 = BP;
  747.                         LookSrcP++;
  748.                      }
  749.                      break;
  750.                   default:
  751.                      if (LowrCs[*BP] == LowrCs[*LookSrcP]) {
  752.                         Mode = FRSTWRDLCKSTP3;
  753.                         BPStrt2 = BP;
  754.                         LookSrcP++;
  755.                      }
  756.                      break;
  757.                }
  758.             }
  759.             break;
  760.  
  761.          case(WRDLOCKSTEP) :
  762.             switch(*LookSrcP) {
  763.                case('?'):
  764.                   LookSrcP++;
  765.                   break;
  766.  
  767.                case('['):
  768.                   if (!BrakPtr[MTN][BrakIdx[MTN][LookSrcP-NBAS]][*BP]) {
  769.                      LookSrcP = LookStrt;
  770.                      Mode = SENTENCELOOK;
  771.                      BP = BPStrt;
  772.                   }
  773.                   else { LookSrcP++; }
  774.                   break;
  775.  
  776.                default:
  777.                   if (LowrCs[*BP] != LowrCs[*LookSrcP]) {
  778.                      LookSrcP = LookStrt;
  779.                      Mode = SENTENCELOOK;
  780.                      BP = BPStrt;
  781.                   }
  782.                   else { LookSrcP++; }
  783.                   break;
  784.             }
  785.             break;
  786.  
  787.          case(WRDLOCKSTEP1) :
  788.             switch(*LookSrcP) {
  789.                case('?'):
  790.                   LookSrcP++;
  791.                   break;
  792.                case('['):
  793.                   if (!BrakPtr[MTN][BrakIdx[MTN][LookSrcP-NBAS]][*BP]) {
  794.                      LookSrcP = LookStrt1;
  795.                      Mode = WORDLOOK;
  796.                      BP = BPStrt1;
  797.                   }
  798.                   else { LookSrcP++; }
  799.                   break;
  800.                default:
  801.                   if (LowrCs[*BP] != LowrCs[*LookSrcP]) {
  802.                      LookSrcP = LookStrt1;
  803.                      Mode = WORDLOOK;
  804.                      BP = BPStrt1;
  805.                   }
  806.                   else { LookSrcP++; }
  807.                   break;
  808.             }
  809.             break;
  810.  
  811.          case(WRDLOCKSTEP2) :
  812.             switch(*LookSrcP) {
  813.                case('?'):
  814.                   LookSrcP++;
  815.                   break;
  816.                case('['):
  817.                   if (!BrakPtr[MTN][BrakIdx[MTN][LookSrcP-NBAS]][*BP]) {
  818.                      LookSrcP = LookStrt2;
  819.                      Mode = WORDLOOK1;
  820.                      BP = BPStrt2;
  821.                   }
  822.                   else { LookSrcP++; }
  823.                   break;
  824.                default:
  825.                   if (LowrCs[*BP] != LowrCs[*LookSrcP]) {
  826.                      LookSrcP = LookStrt2;
  827.                      Mode = WORDLOOK1;
  828.                      BP = BPStrt2;
  829.                   }
  830.                   else { LookSrcP++; }
  831.                   break;
  832.             }
  833.             break;
  834.  
  835.          case(FRSTWRDLCKSTP) :
  836.             switch(*LookSrcP) {
  837.                case('?'):
  838.                   LookSrcP++;
  839.                   break;
  840.                case('['):
  841.                   if (!BrakPtr[MTN][BrakIdx[MTN][LookSrcP-NBAS]][*BP]) {
  842.                      return(0);
  843.                   }
  844.                   LookSrcP++;
  845.                   break;
  846.                default:
  847.                   if (LowrCs[*BP] != LowrCs[*LookSrcP]) {
  848.                      return(0);
  849.                   }
  850.                   LookSrcP++;
  851.                   break;
  852.             }
  853.             break;
  854.  
  855.          case(FRSTWRDLCKSTP1) :
  856.             switch(*LookSrcP) {
  857.                case('?'):
  858.                   LookSrcP++;
  859.                   break;
  860.                case('['):
  861.                   if (!BrakPtr[MTN][BrakIdx[MTN][LookSrcP-NBAS]][*BP]) {
  862.                      Mode = FRSTWRDLOOK;
  863.                      LookSrcP = LookStrt;
  864.                      BP = BPStrt;
  865.                   }
  866.                   else { LookSrcP++; }
  867.                   break;
  868.                default:
  869.                   if (LowrCs[*BP] != LowrCs[*LookSrcP]) {
  870.                      Mode = FRSTWRDLOOK;
  871.                      LookSrcP = LookStrt;
  872.                      BP = BPStrt;
  873.                   }
  874.                   else { LookSrcP++; }
  875.                   break;
  876.             }
  877.             break;
  878.  
  879.          case(FRSTWRDLCKSTP2) :
  880.             switch(*LookSrcP) {
  881.                case('?'):
  882.                   LookSrcP++;
  883.                   break;
  884.                case('['):
  885.                   if (!BrakPtr[MTN][BrakIdx[MTN][LookSrcP-NBAS]][*BP]) {
  886.                      Mode = FRSTWRDLOOK1;
  887.                      LookSrcP = LookStrt1;
  888.                      BP = BPStrt1;
  889.                   }
  890.                   else { LookSrcP++; }
  891.                   break;
  892.                default:
  893.                   if (LowrCs[*BP] != LowrCs[*LookSrcP]) {
  894.                      Mode = FRSTWRDLOOK1;
  895.                      LookSrcP = LookStrt1;
  896.                      BP = BPStrt1;
  897.                   }
  898.                   else { LookSrcP++; }
  899.                   break;
  900.             }
  901.             break;
  902.  
  903.          case(FRSTWRDLCKSTP3) :
  904.             switch(*LookSrcP) {
  905.                case('?'):
  906.                   LookSrcP++;
  907.                   break;
  908.                case('['):
  909.                   if (!BrakPtr[MTN][BrakIdx[MTN][LookSrcP-NBAS]][*BP]) {
  910.                      Mode = FRSTWRDLOOK2;
  911.                      LookSrcP = LookStrt2;
  912.                      BP = BPStrt2;
  913.                   }
  914.                   else { LookSrcP++; }
  915.                   break;
  916.                default:
  917.                   if (LowrCs[*BP] != LowrCs[*LookSrcP]) {
  918.                      Mode = FRSTWRDLOOK2;
  919.                      LookSrcP = LookStrt2;
  920.                      BP = BPStrt2;
  921.                   }
  922.                   else { LookSrcP++; }
  923.                   break;
  924.             }
  925.             break;
  926.       }
  927.    }
  928.    return(1);
  929. }
  930.  
  931.