home *** CD-ROM | disk | FTP | other *** search
/ ARM Club 1 / ARM_CLUB_CD.iso / contents / apps / clib / progs / cutils / Regex / Changes
Encoding:
Text File  |  1991-09-19  |  7.7 KB  |  263 lines
  1. *** SCSI::SCSIDisc4.$.Programs.Utils.Regex.C.Regex  Sun May 12 15:07:30 1991
  2. --- SCSI::SCSIDisc4.$.Programs.Utils.Regex.C.Regex1 Thu Sep 19 01:27:55 1991
  3. *************** enum regexpcod
  4. *** 149,154 ****
  5. --- 149,156 ----
  6.       notspacechar, /* Matches any non-whitespace character */
  7.       digit,        /* Matches any digit character */
  8.       notdigit,     /* Matches any non-digit character */
  9. +     begword,      /* Succeeds if at beginning of word.  */
  10. +     endword,      /* Succeeds if at end of word.  */
  11.       wordbound,    /* Succeeds if at a word boundary */
  12.       notwordbound  /* Succeeds if not at a word boundary */
  13.     };
  14. *************** enum regexpcod
  15. *** 167,173 ****
  16.   /* Store NUMBER in two contiguous bytes starting at DESTINATION.  */
  17.   #define STORE_NUMBER(destination, number)\
  18.     { (destination)[0] = (number) & 0377;\
  19. !     (destination)[1] = (number) >> 8; }
  20.     
  21.   /* Same as STORE_NUMBER, except increment the destination pointer to
  22.      the byte after where the number is stored.  Watch out that values for
  23. --- 169,175 ----
  24.   /* Store NUMBER in two contiguous bytes starting at DESTINATION.  */
  25.   #define STORE_NUMBER(destination, number)\
  26.     { (destination)[0] = (number) & 0377;\
  27. !     (destination)[1] = ((number) >> 8) & 0377; }
  28.     
  29.   /* Same as STORE_NUMBER, except increment the destination pointer to
  30.      the byte after where the number is stored.  Watch out that values for
  31. *************** int obscure_syntax = 0
  32. *** 221,226 ****
  33. --- 223,229 ----
  34.   #define PATFETCH(c)\
  35.     {if (p == pend) goto end_of_pattern;\
  36.     c = * (unsigned char *) p++;\
  37. + fprintf(stderr,"%c",c);\
  38.     if (translate) c = translate[c]; }
  39.   
  40.   /* Fetch the next character in the uncompiled pattern, with no
  41. *************** char *re_compile_pattern (char *pattern, int size
  42. *** 787,793 ****
  43.                     /* When hit this when matching, reset the
  44.                        preceding jump_n's n to upper_bound - 1.  */
  45.                     BUFPUSH (set_number_at);
  46. !           GET_BUFFER_SPACE (2);
  47.                     STORE_NUMBER_AND_INCR (b, -5);
  48.                     STORE_NUMBER_AND_INCR (b, upper_bound - 1);
  49.                   }
  50. --- 790,796 ----
  51.                     /* When hit this when matching, reset the
  52.                        preceding jump_n's n to upper_bound - 1.  */
  53.                     BUFPUSH (set_number_at);
  54. !           GET_BUFFER_SPACE (4);
  55.                     STORE_NUMBER_AND_INCR (b, -5);
  56.                     STORE_NUMBER_AND_INCR (b, upper_bound - 1);
  57.                   }
  58. *************** char *re_compile_pattern (char *pattern, int size
  59. *** 936,941 ****
  60. --- 939,952 ----
  61.         BUFPUSH (notwordbound);
  62.         break;
  63.   
  64. +     case '<':
  65. +       BUFPUSH (begword);
  66. +       break;
  67. + 
  68. +     case '>':
  69. +       BUFPUSH (endword);
  70. +       break;
  71. + 
  72.       case '`':
  73.         BUFPUSH (begbuf);
  74.         break;
  75. *************** static void insert_op_2 (char op, char *there, char *current
  76. *** 1136,1142 ****
  77.      quickly over totally implausible text.
  78.   
  79.      The caller must supply the address of a CHAR_NUM-byte data 
  80. !    area as bufp->fastmap.
  81.      The other components of bufp describe the pattern to be used.  */
  82.   
  83.   void re_compile_fastmap (struct re_pattern_buffer *bufp)
  84. --- 1147,1154 ----
  85.      quickly over totally implausible text.
  86.   
  87.      The caller must supply the address of a CHAR_NUM-byte data 
  88. !    area as bufp->fastmap, or NULL (in which case, re_compile_fastmap
  89. !    will allocate an area, using malloc()).
  90.      The other components of bufp describe the pattern to be used.  */
  91.   
  92.   void re_compile_fastmap (struct re_pattern_buffer *bufp)
  93. *************** void re_compile_fastmap (struct re_pattern_buffer *bufp
  94. *** 1154,1161 ****
  95.   
  96.     unsigned is_a_succeed_n;
  97.   
  98. -   bzero (fastmap, CHAR_NUM);
  99.     bufp->fastmap_accurate = 1;
  100.     bufp->can_be_null = 0;
  101.         
  102.     while (p)
  103. --- 1166,1187 ----
  104.   
  105.     unsigned is_a_succeed_n;
  106.   
  107.     bufp->fastmap_accurate = 1;
  108. + 
  109. +   if (fastmap == NULL)
  110. +     {
  111. +       fastmap = malloc(CHAR_NUM);
  112. + 
  113. +       /* If no luck, return without a fastmap (but with fastmap_accurate set,
  114. +  so that callers know we tried).  */
  115. + 
  116. +       if (fastmap == NULL)
  117. + return;
  118. + 
  119. +       bufp->fastmap = fastmap;
  120. +     }
  121. + 
  122. +   bzero (fastmap, CHAR_NUM);
  123.     bufp->can_be_null = 0;
  124.         
  125.     while (p)
  126. *************** void re_compile_fastmap (struct re_pattern_buffer *bufp
  127. *** 1179,1184 ****
  128. --- 1205,1212 ----
  129.           case begline:
  130.   case begbuf:
  131.   case endbuf:
  132. + case begword:
  133. + case endword:
  134.   case wordbound:
  135.   case notwordbound:
  136.             continue;
  137. *************** int re_search_2 (struct re_pattern_buffer *pbufp, char *stri
  138. *** 1383,1388 ****
  139. --- 1411,1421 ----
  140.     if (startpos < 0  ||  startpos > total_size)
  141.       return -1;
  142.       
  143. +   /* A range of zero means "as far as possible" (use re_match for an
  144. +      anchored match).  */
  145. +   if (range == 0)
  146. +     range = total_size - startpos;
  147. + 
  148.     /* Fix up range if it would eventually take startpos outside of the
  149.        virtual concatenation of string1 and string2.  */
  150.     if (endpos < -1)
  151. *************** int re_search_2 (struct re_pattern_buffer *pbufp, char *stri
  152. *** 1391,1398 ****
  153.       range = total_size - startpos;
  154.   
  155.     /* Update the fastmap now if not correct already.  */
  156. !   if (fastmap && !pbufp->fastmap_accurate)
  157. !     re_compile_fastmap (pbufp);
  158.     
  159.     /* If the search isn't to be a backwards one, don't waste time in a
  160.        long search for a pattern that says it is anchored.  */
  161. --- 1424,1435 ----
  162.       range = total_size - startpos;
  163.   
  164.     /* Update the fastmap now if not correct already.  */
  165. !   if (!pbufp->fastmap_accurate)
  166. !     {
  167. !       re_compile_fastmap (pbufp);
  168. !       /* Re-assign fastmap, in case re_compile_fastmap() allocated it */
  169. !       fastmap = pbufp->fastmap;
  170. !     }
  171.     
  172.     /* If the search isn't to be a backwards one, don't waste time in a
  173.        long search for a pattern that says it is anchored.  */
  174. *************** struct register_inf
  175. *** 1640,1645 ****
  176. --- 1677,1688 ----
  177.   #define IS_A_LETTER(d)\
  178.     (HAS_SYNTAX (CURRENT_CHAR(d),Sword))
  179.   
  180. + #define AT_WORD_BEG\
  181. +   (AT_STRINGS_BEG || (!IS_A_LETTER (d - 1) && IS_A_LETTER (d)))
  182. + 
  183. + #define AT_WORD_END\
  184. +   (AT_STRINGS_END || (IS_A_LETTER (d - 1) && !IS_A_LETTER (d)))
  185. + 
  186.   #define AT_WORD_BOUNDARY\
  187.     (AT_STRINGS_BEG || AT_STRINGS_END || IS_A_LETTER (d - 1) != IS_A_LETTER (d))
  188.   
  189. *************** int re_match_2 (struct re_pattern_buffer *pbufp, char *strin
  190. *** 2265,2270 ****
  191. --- 2308,2323 ----
  192.     d++;
  193.     break;
  194.   
  195. + case begword:
  196. +           if (AT_WORD_BEG)
  197. +             break;
  198. +           goto fail;
  199. + 
  200. +         case endword:
  201. +   if (AT_WORD_END)
  202. +     break;
  203. +   goto fail;
  204. + 
  205.   case begbuf:
  206.             if (AT_STRINGS_BEG)
  207.               break;
  208. *************** int main (void
  209. *** 2493,2499 ****
  210.   {
  211.     char pat[80];
  212.     struct re_pattern_buffer buf;
  213. !   int i;
  214.     char fastmap[CHAR_NUM];
  215.   
  216.     buf.allocated = 40;
  217. --- 2546,2554 ----
  218.   {
  219.     char pat[80];
  220.     struct re_pattern_buffer buf;
  221. !   struct re_registers regs;
  222. !   int i, j;
  223. !   char *p;
  224.     char fastmap[CHAR_NUM];
  225.   
  226.     buf.allocated = 40;
  227. *************** int main (void
  228. *** 2534,2541 ****
  229.     if (*pat == 0)
  230.       break;
  231.   
  232. !   i = re_match (&buf, pat, strlen (pat), 0, 0);
  233. !   printf ("Match value %d.\n", i);
  234.   }
  235.       }
  236.   }
  237. --- 2589,2598 ----
  238.     if (*pat == 0)
  239.       break;
  240.   
  241. !   i = re_search (&buf, pat, strlen (pat), 0, 0, ®s);
  242. !   j = regs.end[0] - regs.start[0];
  243. !   p = pat + regs.start[0];
  244. !   printf ("Found \"%.*s\" at %d.\n", j, p, i);
  245.   }
  246.       }
  247.   }
  248. *************** static void dump_buffer (struct re_pattern_buffer *bufp
  249. *** 2629,2634 ****
  250. --- 2686,2697 ----
  251.         break;
  252.       case duplicate:
  253.         printf("Duplicate (%d)", *p++);
  254. +       break;
  255. +     case begword:
  256. +       printf("Start of word");
  257. +       break;
  258. +     case endword:
  259. +       printf("End of word");
  260.         break;
  261.       case begbuf:
  262.         printf("Start of buffer");
  263.