home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 8 / FreshFishVol8-CD2.bin / bbs / gnu / sed-2.05-src.lha / sed-2.05 / rx.c < prev    next >
C/C++ Source or Header  |  1994-05-13  |  221KB  |  8,713 lines
  1. /*    Copyright (C) 1992, 1993 Free Software Foundation, Inc.
  2.  
  3. This program is free software; you can redistribute it and/or modify
  4. it under the terms of the GNU General Public License as published by
  5. the Free Software Foundation; either version 2, or (at your option)
  6. any later version.
  7.  
  8. This program is distributed in the hope that it will be useful,
  9. but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11. GNU General Public License for more details.
  12.  
  13. You should have received a copy of the GNU General Public License
  14. along with this software; see the file COPYING.  If not, write to
  15. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  16.  
  17. /* NOTE!!!  AIX requires this to be the first thing in the file.
  18.  * Do not put ANYTHING before it!  
  19.  */
  20. #if !defined (__GNUC__) && defined (_AIX)
  21.  #pragma alloca
  22. #endif
  23.  
  24. static char rx_version_string[] = "GNU Rx version 0.03";
  25.  
  26.             /* ``Too hard!''
  27.              *        -- anon.
  28.              */
  29.  
  30. /* N.B.:
  31.  *
  32.  * I think Joe Keane thought of the clever name `superstate'.
  33.  */
  34.  
  35.  
  36. #include <stdio.h>
  37. #include <ctype.h>
  38. #ifndef isgraph
  39. #define isgraph(c) (isprint (c) && !isspace (c))
  40. #endif
  41. #ifndef isblank
  42. #define isblank(c) ((c) == ' ' || (c) == '\t')
  43. #endif
  44.  
  45. #include <sys/types.h>
  46. #include <stdio.h>
  47. #include "rx.h"
  48.  
  49. #undef MAX
  50. #undef MIN
  51. #define MAX(a, b) ((a) > (b) ? (a) : (b))
  52. #define MIN(a, b) ((a) < (b) ? (a) : (b))
  53.  
  54. typedef char boolean;
  55. #define false 0
  56. #define true 1
  57.  
  58.  
  59. /* This page is decls to the interesting subsystems and lower layers
  60.  * of rx.  Everything which doesn't have a public counterpart in 
  61.  * regex.c is declared here.
  62.  * 
  63.  * A useful (i hope) system is obtained by removing all or part of the regex.c
  64.  * reimplementation and making these all extern.  I think this package
  65.  * could be used to implement on-line lexers and parsers and who knows what 
  66.  * else.
  67.  */
  68. /* In the definitions, these functions are qualified by `RX_DECL' */
  69. #define RX_DECL static
  70.  
  71. #ifdef __STDC__
  72.  
  73. RX_DECL int rx_bitset_is_subset (int size, rx_Bitset a, rx_Bitset b);
  74. RX_DECL void rx_bitset_null (int size, rx_Bitset b);
  75. RX_DECL void rx_bitset_universe (int size, rx_Bitset b);
  76. RX_DECL void rx_bitset_complement (int size, rx_Bitset b);
  77. RX_DECL void rx_bitset_assign (int size, rx_Bitset a, rx_Bitset b);
  78. RX_DECL void rx_bitset_union (int size, rx_Bitset a, rx_Bitset b);
  79. RX_DECL void rx_bitset_intersection (int size,
  80.                      rx_Bitset a, rx_Bitset b);
  81. RX_DECL void rx_bitset_difference (int size, rx_Bitset a, rx_Bitset b);
  82. RX_DECL unsigned long rx_bitset_hash (int size, rx_Bitset b);
  83. RX_DECL struct rx_hash_item * rx_hash_find (struct rx_hash * table,
  84.                         unsigned long hash,
  85.                         void * value,
  86.                         struct rx_hash_rules * rules);
  87. RX_DECL struct rx_hash_item * rx_hash_store (struct rx_hash * table,
  88.                          unsigned long hash,
  89.                          void * value,
  90.                          struct rx_hash_rules * rules);
  91. RX_DECL void rx_hash_free (struct rx_hash_item * it,
  92.                struct rx_hash_rules * rules);
  93. RX_DECL rx_Bitset rx_cset (struct rx *rx);
  94. RX_DECL rx_Bitset rx_copy_cset (struct rx *rx, rx_Bitset a);
  95. RX_DECL void rx_free_cset (struct rx * rx, rx_Bitset c);
  96. RX_DECL struct rexp_node * rexp_node (struct rx *rx,
  97.                       enum rexp_node_type type);
  98. RX_DECL struct rexp_node * rx_mk_r_cset (struct rx * rx,
  99.                      rx_Bitset b);
  100. RX_DECL struct rexp_node * rx_mk_r_concat (struct rx * rx,
  101.                        struct rexp_node * a,
  102.                        struct rexp_node * b);
  103. RX_DECL struct rexp_node * rx_mk_r_alternate (struct rx * rx,
  104.                           struct rexp_node * a,
  105.                           struct rexp_node * b);
  106. RX_DECL struct rexp_node * rx_mk_r_opt (struct rx * rx,
  107.                     struct rexp_node * a);
  108. RX_DECL struct rexp_node * rx_mk_r_star (struct rx * rx,
  109.                      struct rexp_node * a);
  110. RX_DECL struct rexp_node * rx_mk_r_2phase_star (struct rx * rx,
  111.                         struct rexp_node * a,
  112.                         struct rexp_node * b);
  113. RX_DECL struct rexp_node * rx_mk_r_side_effect (struct rx * rx,
  114.                         rx_side_effect a);
  115. RX_DECL struct rexp_node * rx_mk_r_data  (struct rx * rx,
  116.                       void * a);
  117. RX_DECL void rx_free_rexp (struct rx * rx, struct rexp_node * node);
  118. RX_DECL struct rexp_node * rx_copy_rexp (struct rx *rx,
  119.                      struct rexp_node *node);
  120. RX_DECL struct rx_nfa_state * rx_nfa_state (struct rx *rx);
  121. RX_DECL void rx_free_nfa_state (struct rx_nfa_state * n);
  122. RX_DECL struct rx_nfa_state * rx_id_to_nfa_state (struct rx * rx,
  123.                           int id);
  124. RX_DECL struct rx_nfa_edge * rx_nfa_edge (struct rx *rx,
  125.                       enum rx_nfa_etype type,
  126.                       struct rx_nfa_state *start,
  127.                       struct rx_nfa_state *dest);
  128. RX_DECL void rx_free_nfa_edge (struct rx_nfa_edge * e);
  129. RX_DECL void rx_free_nfa (struct rx *rx);
  130. RX_DECL int rx_build_nfa (struct rx *rx,
  131.               struct rexp_node *rexp,
  132.               struct rx_nfa_state **start,
  133.               struct rx_nfa_state **end);
  134. RX_DECL void rx_name_nfa_states (struct rx *rx);
  135. RX_DECL int rx_eclose_nfa (struct rx *rx);
  136. RX_DECL void rx_delete_epsilon_transitions (struct rx *rx);
  137. RX_DECL int rx_compactify_nfa (struct rx *rx,
  138.                    void **mem, unsigned long *size);
  139. RX_DECL struct rx_superset * rx_superstate_eclosure_union
  140.   (struct rx * rx, struct rx_superset *set, struct rx_nfa_state_set *ecl) ;
  141. RX_DECL void rx_release_superset (struct rx *rx,
  142.                   struct rx_superset *set);
  143. RX_DECL struct rx_superstate * rx_superstate (struct rx *rx,
  144.                           struct rx_superset *set);
  145. RX_DECL struct rx_inx * rx_handle_cache_miss
  146.   (struct rx *rx, struct rx_superstate *super, unsigned char chr, void *data) ;
  147.  
  148. #else /* ndef __STDC__ */
  149. RX_DECL int rx_bitset_is_subset ();
  150. RX_DECL void rx_bitset_null ();
  151. RX_DECL void rx_bitset_universe ();
  152. RX_DECL void rx_bitset_complement ();
  153. RX_DECL void rx_bitset_assign ();
  154. RX_DECL void rx_bitset_union ();
  155. RX_DECL void rx_bitset_intersection ();
  156. RX_DECL void rx_bitset_difference ();
  157. RX_DECL unsigned long rx_bitset_hash ();
  158. RX_DECL struct rx_hash_item * rx_hash_find ();
  159. RX_DECL struct rx_hash_item * rx_hash_store ();
  160. RX_DECL void rx_hash_free ();
  161. RX_DECL rx_Bitset rx_cset ();
  162. RX_DECL rx_Bitset rx_copy_cset ();
  163. RX_DECL void rx_free_cset ();
  164. RX_DECL struct rexp_node * rexp_node ();
  165. RX_DECL struct rexp_node * rx_mk_r_cset ();
  166. RX_DECL struct rexp_node * rx_mk_r_concat ();
  167. RX_DECL struct rexp_node * rx_mk_r_alternate ();
  168. RX_DECL struct rexp_node * rx_mk_r_opt ();
  169. RX_DECL struct rexp_node * rx_mk_r_star ();
  170. RX_DECL struct rexp_node * rx_mk_r_2phase_star ();
  171. RX_DECL struct rexp_node * rx_mk_r_side_effect ();
  172. RX_DECL struct rexp_node * rx_mk_r_data  ();
  173. RX_DECL void rx_free_rexp ();
  174. RX_DECL struct rexp_node * rx_copy_rexp ();
  175. RX_DECL struct rx_nfa_state * rx_nfa_state ();
  176. RX_DECL void rx_free_nfa_state ();
  177. RX_DECL struct rx_nfa_state * rx_id_to_nfa_state ();
  178. RX_DECL struct rx_nfa_edge * rx_nfa_edge ();
  179. RX_DECL void rx_free_nfa_edge ();
  180. RX_DECL void rx_free_nfa ();
  181. RX_DECL int rx_build_nfa ();
  182. RX_DECL void rx_name_nfa_states ();
  183. RX_DECL int rx_eclose_nfa ();
  184. RX_DECL void rx_delete_epsilon_transitions ();
  185. RX_DECL int rx_compactify_nfa ();
  186. RX_DECL struct rx_superset * rx_superstate_eclosure_union ();
  187. RX_DECL void rx_release_superset ();
  188. RX_DECL struct rx_superstate * rx_superstate ();
  189. RX_DECL struct rx_inx * rx_handle_cache_miss ();
  190.   
  191. #endif /* ndef __STDC__ */
  192.  
  193.  
  194.  
  195. /* Emacs already defines alloca, sometimes.  */
  196. #ifndef alloca
  197.  
  198. /* Make alloca work the best possible way.  */
  199. #ifdef __GNUC__
  200. #define alloca __builtin_alloca
  201. #else /* not __GNUC__ */
  202. #if HAVE_ALLOCA_H
  203. #include <alloca.h>
  204. #else /* not __GNUC__ or HAVE_ALLOCA_H */
  205. #ifndef _AIX /* Already did AIX, up at the top.  */
  206. char *alloca ();
  207. #endif /* not _AIX */
  208. #endif /* not HAVE_ALLOCA_H */ 
  209. #endif /* not __GNUC__ */
  210.  
  211. #endif /* not alloca */
  212.  
  213.  
  214. /* Should we use malloc or alloca?  If REGEX_MALLOC is not defined, we
  215.  * use `alloca' instead of `malloc' for the backtracking stack.
  216.  *
  217.  * Emacs will die miserably if we don't do this.
  218.  */
  219.  
  220. #ifdef REGEX_MALLOC
  221.  
  222. #define REGEX_ALLOCATE malloc
  223.  
  224. #else /* not REGEX_MALLOC  */
  225.  
  226. #define REGEX_ALLOCATE alloca
  227.  
  228. #endif /* not REGEX_MALLOC */
  229.  
  230.  
  231.  
  232.  
  233. /* Memory management and stuff for emacs. */
  234.  
  235. #define BYTEWIDTH 8 /* In bits.  */
  236.  
  237. /* (Re)Allocate N items of type T using malloc.  */
  238. #define TALLOC(n, t) ((t *) malloc ((n) * sizeof (t)))
  239. #define RETALLOC(addr, n, t) ((addr) = (t *) realloc (addr, (n) * sizeof (t)))
  240.  
  241. #define remalloc(M, S) (M ? realloc (M, S) : malloc (S))
  242.  
  243. #ifdef emacs
  244. /* The `emacs' switch turns on certain matching commands
  245.  * that make sense only in Emacs. 
  246.  */
  247.  
  248. #include "config.h"
  249. #include "lisp.h"
  250. #include "buffer.h"
  251. #include "syntax.h"
  252.  
  253. /* Emacs uses `NULL' as a predicate.  */
  254. #undef NULL
  255. #else  /* not emacs */
  256.  
  257. /* Setting RX_MEMDBUG is useful if you have dbmalloc.  Maybe with similar
  258.  * packages too.
  259.  */
  260. #ifdef RX_MEMDBUG
  261. #include <malloc.h>
  262. #else /* not RX_RX_MEMDBUG */
  263.  
  264. /* We used to test for `BSTRING' here, but only GCC and Emacs define
  265.  * `BSTRING', as far as I know, and neither of them use this code.  
  266.  */
  267. #if HAVE_STRING_H || STDC_HEADERS
  268. #include <string.h>
  269. #ifndef bcmp
  270. #define bcmp(s1, s2, n)    memcmp ((s1), (s2), (n))
  271. #endif
  272. #ifndef bcopy
  273. #define bcopy(s, d, n)    memcpy ((d), (s), (n))
  274. #endif
  275. #ifndef bzero
  276. #define bzero(s, n)    memset ((s), 0, (n))
  277. #endif
  278. #else
  279. #include <strings.h>
  280. #endif
  281.  
  282. #ifdef STDC_HEADERS
  283. #include <stdlib.h>
  284. #else /* not STDC_HEADERS */
  285.  
  286. char *malloc ();
  287. char *realloc ();
  288. #endif /* not STDC_HEADERS */
  289.  
  290. #endif /* not RX_RX_MEMDBUG */
  291.  
  292.  
  293.  
  294. /* Define the syntax basics for \<, \>, etc.
  295.  * This must be nonzero for the wordchar and notwordchar pattern
  296.  * commands in re_match_2.
  297.  */
  298. #ifndef Sword 
  299. #define Sword 1
  300. #endif
  301.  
  302. #ifdef SYNTAX_TABLE
  303. extern char *re_syntax_table;
  304. #else /* not SYNTAX_TABLE */
  305.  
  306. /* How many characters in the character set.  */
  307. #define CHAR_SET_SIZE (1 << BYTEWIDTH)
  308. static char re_syntax_table[CHAR_SET_SIZE];
  309.  
  310. #ifdef __STDC__
  311. static void
  312. init_syntax_once (void)
  313. #else
  314. static void
  315. init_syntax_once ()
  316. #endif
  317. {
  318.    register int c;
  319.    static int done = 0;
  320.  
  321.    if (done)
  322.      return;
  323.  
  324.    bzero (re_syntax_table, sizeof re_syntax_table);
  325.  
  326.    for (c = 'a'; c <= 'z'; c++)
  327.      re_syntax_table[c] = Sword;
  328.  
  329.    for (c = 'A'; c <= 'Z'; c++)
  330.      re_syntax_table[c] = Sword;
  331.  
  332.    for (c = '0'; c <= '9'; c++)
  333.      re_syntax_table[c] = Sword;
  334.  
  335.    re_syntax_table['_'] = Sword;
  336.  
  337.    done = 1;
  338. }
  339. #endif /* not SYNTAX_TABLE */
  340.  
  341. #define SYNTAX(c) re_syntax_table[c]
  342.  
  343. #endif /* not emacs */
  344.  
  345.  
  346. /* Compile with `-DRX_DEBUG' and use the following flags.
  347.  *
  348.  * Debugging flags:
  349.  *       rx_debug - print information as a regexp is compiled
  350.  *     rx_debug_trace - print information as a regexp is executed
  351.  */
  352.  
  353. #ifdef RX_DEBUG
  354.  
  355. int rx_debug_compile = 0;
  356. int rx_debug_trace = 0;
  357. static struct re_pattern_buffer * dbug_rxb = 0;
  358.  
  359. #ifdef __STDC__
  360. typedef void (*side_effect_printer) (struct rx *, void *, FILE *);
  361. #else
  362. typedef void (*side_effect_printer) ();
  363. #endif
  364.  
  365. #ifdef __STDC__
  366. static void print_cset (struct rx *rx, rx_Bitset cset, FILE * fp);
  367. #else
  368. static void print_cset ();
  369. #endif
  370.  
  371. #ifdef __STDC__
  372. static void
  373. print_rexp (struct rx *rx,
  374.         struct rexp_node *node, int depth,
  375.         side_effect_printer seprint, FILE * fp)
  376. #else
  377. static void
  378. print_rexp (rx, node, depth, seprint, fp)
  379.      struct rx *rx;
  380.      struct rexp_node *node;
  381.      int depth;
  382.      side_effect_printer seprint;
  383.      FILE * fp;
  384. #endif
  385. {
  386.   if (!node)
  387.     return;
  388.   else
  389.     {
  390.       switch (node->type)
  391.     {
  392.     case r_cset:
  393.       {
  394.         fprintf (fp, "%*s", depth, "");
  395.         print_cset (rx, node->params.cset, fp);
  396.         fputc ('\n', fp);
  397.         break;
  398.       }
  399.  
  400.      case r_opt:
  401.     case r_star:
  402.       fprintf (fp, "%*s%s\n", depth, "",
  403.            node->type == r_opt ? "opt" : "star");
  404.       print_rexp (rx, node->params.pair.left, depth + 3, seprint, fp);
  405.       break;
  406.  
  407.     case r_2phase_star:
  408.       fprintf (fp, "%*s2phase star\n", depth, "");
  409.       print_rexp (rx, node->params.pair.right, depth + 3, seprint, fp);
  410.       print_rexp (rx, node->params.pair.left, depth + 3, seprint, fp);
  411.       break;
  412.  
  413.  
  414.     case r_alternate:
  415.     case r_concat:
  416.       fprintf (fp, "%*s%s\n", depth, "",
  417.            node->type == r_alternate ? "alt" : "concat");
  418.       print_rexp (rx, node->params.pair.left, depth + 3, seprint, fp);
  419.       print_rexp (rx, node->params.pair.right, depth + 3, seprint, fp);
  420.       break;
  421.     case r_side_effect:
  422.       fprintf (fp, "%*sSide effect: ", depth, "");
  423.       seprint (rx, node->params.side_effect, fp);
  424.       fputc ('\n', fp);
  425.     }
  426.     }
  427. }
  428.  
  429.  
  430. #ifdef __STDC__
  431. static void
  432. print_nfa (struct rx * rx,
  433.        struct rx_nfa_state * n,
  434.        side_effect_printer seprint, FILE * fp)
  435. #else
  436. static void
  437. print_nfa (rx, n, seprint, fp)
  438.      struct rx * rx;
  439.      struct rx_nfa_state * n;
  440.      side_effect_printer seprint;
  441.      FILE * fp;
  442. #endif
  443. {
  444.   while (n)
  445.     {
  446.       struct rx_nfa_edge *e = n->edges;
  447.       struct rx_possible_future *ec = n->futures;
  448.       fprintf (fp, "node %d %s\n", n->id,
  449.            n->is_final ? "final" : (n->is_start ? "start" : ""));
  450.       while (e)
  451.     {
  452.       fprintf (fp, "   edge to %d, ", e->dest->id);
  453.       switch (e->type)
  454.         {
  455.         case ne_epsilon:
  456.           fprintf (fp, "epsilon\n");
  457.           break;
  458.         case ne_side_effect:
  459.           fprintf (fp, "side effect ");
  460.           seprint (rx, e->params.side_effect, fp);
  461.           fputc ('\n', fp);
  462.           break;
  463.         case ne_cset:
  464.           fprintf (fp, "cset ");
  465.           print_cset (rx, e->params.cset, fp);
  466.           fputc ('\n', fp);
  467.           break;
  468.         }
  469.       e = e->next;
  470.     }
  471.  
  472.       while (ec)
  473.     {
  474.       int x;
  475.       struct rx_nfa_state_set * s;
  476.       struct rx_se_list * l;
  477.       fprintf (fp, "   eclosure to {");
  478.       for (s = ec->destset; s; s = s->cdr)
  479.         fprintf (fp, "%d ", s->car->id);
  480.       fprintf (fp, "} (");
  481.       for (l = ec->effects; l; l = l->cdr)
  482.         {
  483.           seprint (rx, l->car, fp);
  484.           fputc (' ', fp);
  485.         }
  486.       fprintf (fp, ")\n");
  487.       ec = ec->next;
  488.     }
  489.       n = n->next;
  490.     }
  491. }
  492.  
  493. static char * efnames [] =
  494. {
  495.   "bogon",
  496.   "re_se_try",
  497.   "re_se_pushback",
  498.   "re_se_push0",
  499.   "re_se_pushpos",
  500.   "re_se_chkpos",
  501.   "re_se_poppos",
  502.   "re_se_at_dot",
  503.   "re_se_syntax",
  504.   "re_se_not_syntax",
  505.   "re_se_begbuf",
  506.   "re_se_hat",
  507.   "re_se_wordbeg",
  508.   "re_se_wordbound",
  509.   "re_se_notwordbound",
  510.   "re_se_wordend",
  511.   "re_se_endbuf",
  512.   "re_se_dollar",
  513.   "re_se_fail",
  514. };
  515.  
  516. static char * efnames2[] =
  517. {
  518.   "re_se_win"
  519.   "re_se_lparen",
  520.   "re_se_rparen",
  521.   "re_se_backref",
  522.   "re_se_iter",
  523.   "re_se_end_iter",
  524.   "re_se_tv"
  525. };
  526.  
  527. static char * inx_names[] = 
  528. {
  529.   "rx_backtrack_point",
  530.   "rx_do_side_effects",
  531.   "rx_cache_miss",
  532.   "rx_next_char",
  533.   "rx_backtrack",
  534.   "rx_error_inx",
  535.   "rx_num_instructions"
  536. };
  537.  
  538.  
  539. #ifdef __STDC__
  540. static void
  541. re_seprint (struct rx * rx, void * effect, FILE * fp)
  542. #else
  543. static void
  544. re_seprint (rx, effect, fp)
  545.      struct rx * rx;
  546.      void * effect;
  547.      FILE * fp;
  548. #endif
  549. {
  550.   if ((int)effect < 0)
  551.     fputs (efnames[-(int)effect], fp);
  552.   else if (dbug_rxb)
  553.     {
  554.       struct re_se_params * p = &dbug_rxb->se_params[(int)effect];
  555.       fprintf (fp, "%s(%d,%d)", efnames2[p->se], p->op1, p->op2);
  556.     }
  557.   else
  558.     fprintf (fp, "[complex op # %d]", (int)effect);
  559. }
  560.  
  561.  
  562. /* These are for so the regex.c regression tests will compile. */
  563. void
  564. print_compiled_pattern (rxb)
  565.      struct re_pattern_buffer * rxb;
  566. {
  567. }
  568.  
  569. void
  570. print_fastmap (fm)
  571.      char * fm;
  572. {
  573. }
  574.  
  575.  
  576.  
  577. #endif /* RX_DEBUG */
  578.  
  579.  
  580.  
  581. /* This page: Bitsets.  Completely unintersting. */
  582.  
  583. #if 0
  584. #ifdef __STDC__
  585. RX_DECL int
  586. rx_bitset_is_equal (int size, rx_Bitset a, rx_Bitset b)
  587. #else
  588. RX_DECL int
  589. rx_bitset_is_equal (size, a, b)
  590.      int size;
  591.      rx_Bitset a;
  592.      rx_Bitset b;
  593. #endif
  594. {
  595.   int x;
  596.   RX_subset s = b[0];
  597.   b[0] = ~a[0];
  598.  
  599.   for (x = rx_bitset_numb_subsets(size) - 1; a[x] == b[x]; --x)
  600.     ;
  601.  
  602.   b[0] = s;
  603.   return !x && s == a[0];
  604. }
  605. #endif
  606.  
  607. #ifdef __STDC__
  608. RX_DECL int
  609. rx_bitset_is_subset (int size, rx_Bitset a, rx_Bitset b)
  610. #else
  611. RX_DECL int
  612. rx_bitset_is_subset (size, a, b)
  613.      int size;
  614.      rx_Bitset a;
  615.      rx_Bitset b;
  616. #endif
  617. {
  618.   int x = rx_bitset_numb_subsets(size) - 1;
  619.   while (x-- && (a[x] & b[x]) == a[x]);
  620.   return x == -1;
  621. }
  622.  
  623.  
  624. #if 0
  625. #ifdef __STDC__
  626. RX_DECL int
  627. rx_bitset_empty (int size, rx_Bitset set)
  628. #else
  629. RX_DECL int
  630. rx_bitset_empty (size, set)
  631.      int size;
  632.      rx_Bitset set;
  633. #endif
  634. {
  635.   int x;
  636.   RX_subset s = set[0];
  637.   set[0] = 1;
  638.   for (x = rx_bitset_numb_subsets(size) - 1; !set[x]; --x)
  639.     ;
  640.   set[0] = s;
  641.   return !s;
  642. }
  643. #endif
  644.  
  645. #ifdef __STDC__
  646. RX_DECL void
  647. rx_bitset_null (int size, rx_Bitset b)
  648. #else
  649. RX_DECL void
  650. rx_bitset_null (size, b)
  651.      int size;
  652.      rx_Bitset b;
  653. #endif
  654. {
  655.   bzero (b, rx_sizeof_bitset(size));
  656. }
  657.  
  658.  
  659. #ifdef __STDC__
  660. RX_DECL void
  661. rx_bitset_universe (int size, rx_Bitset b)
  662. #else
  663. RX_DECL void
  664. rx_bitset_universe (size, b)
  665.      int size;
  666.      rx_Bitset b;
  667. #endif
  668. {
  669.   int x = rx_bitset_numb_subsets (size);
  670.   while (x--)
  671.     *b++ = ~(RX_subset)0;
  672. }
  673.  
  674.  
  675. #ifdef __STDC__
  676. RX_DECL void
  677. rx_bitset_complement (int size, rx_Bitset b)
  678. #else
  679. RX_DECL void
  680. rx_bitset_complement (size, b)
  681.      int size;
  682.      rx_Bitset b;
  683. #endif
  684. {
  685.   int x = rx_bitset_numb_subsets (size);
  686.   while (x--)
  687.     {
  688.       *b = ~*b;
  689.       ++b;
  690.     }
  691. }
  692.  
  693.  
  694. #ifdef __STDC__
  695. RX_DECL void
  696. rx_bitset_assign (int size, rx_Bitset a, rx_Bitset b)
  697. #else
  698. RX_DECL void
  699. rx_bitset_assign (size, a, b)
  700.      int size;
  701.      rx_Bitset a;
  702.      rx_Bitset b;
  703. #endif
  704. {
  705.   int x;
  706.   for (x = rx_bitset_numb_subsets(size) - 1; x >=0; --x)
  707.     a[x] = b[x];
  708. }
  709.  
  710.  
  711. #ifdef __STDC__
  712. RX_DECL void
  713. rx_bitset_union (int size, rx_Bitset a, rx_Bitset b)
  714. #else
  715. RX_DECL void
  716. rx_bitset_union (size, a, b)
  717.      int size;
  718.      rx_Bitset a;
  719.      rx_Bitset b;
  720. #endif
  721. {
  722.   int x;
  723.   for (x = rx_bitset_numb_subsets(size) - 1; x >=0; --x)
  724.     a[x] |= b[x];
  725. }
  726.  
  727.  
  728. #ifdef __STDC__
  729. RX_DECL void
  730. rx_bitset_intersection (int size,
  731.             rx_Bitset a, rx_Bitset b)
  732. #else
  733. RX_DECL void
  734. rx_bitset_intersection (size, a, b)
  735.      int size;
  736.      rx_Bitset a;
  737.      rx_Bitset b;
  738. #endif
  739. {
  740.   int x;
  741.   for (x = rx_bitset_numb_subsets(size) - 1; x >=0; --x)
  742.     a[x] &= b[x];
  743. }
  744.  
  745.  
  746. #ifdef __STDC__
  747. RX_DECL void
  748. rx_bitset_difference (int size, rx_Bitset a, rx_Bitset b)
  749. #else
  750. RX_DECL void
  751. rx_bitset_difference (size, a, b)
  752.      int size;
  753.      rx_Bitset a;
  754.      rx_Bitset b;
  755. #endif
  756. {
  757.   int x;
  758.   for (x = rx_bitset_numb_subsets(size) - 1; x >=0; --x)
  759.     a[x] &=  ~ b[x];
  760. }
  761.  
  762.  
  763. #if 0
  764. #ifdef __STDC__
  765. RX_DECL void
  766. rx_bitset_revdifference (int size,
  767.              rx_Bitset a, rx_Bitset b)
  768. #else
  769. RX_DECL void
  770. rx_bitset_revdifference (size, a, b)
  771.      int size;
  772.      rx_Bitset a;
  773.      rx_Bitset b;
  774. #endif
  775. {
  776.   int x;
  777.   for (x = rx_bitset_numb_subsets(size) - 1; x >=0; --x)
  778.     a[x] = ~a[x] & b[x];
  779. }
  780.  
  781. #ifdef __STDC__
  782. RX_DECL void
  783. rx_bitset_xor (int size, rx_Bitset a, rx_Bitset b)
  784. #else
  785. RX_DECL void
  786. rx_bitset_xor (size, a, b)
  787.      int size;
  788.      rx_Bitset a;
  789.      rx_Bitset b;
  790. #endif
  791. {
  792.   int x;
  793.   for (x = rx_bitset_numb_subsets(size) - 1; x >=0; --x)
  794.     a[x] ^= b[x];
  795. }
  796. #endif
  797.  
  798.  
  799. #ifdef __STDC__
  800. RX_DECL unsigned long
  801. rx_bitset_hash (int size, rx_Bitset b)
  802. #else
  803. RX_DECL unsigned long
  804. rx_bitset_hash (size, b)
  805.      int size;
  806.      rx_Bitset b;
  807. #endif
  808. {
  809.   int x;
  810.   unsigned long hash = (unsigned long)rx_bitset_hash;
  811.  
  812.   for (x = rx_bitset_numb_subsets(size) - 1; x >= 0; --x)
  813.     hash ^= rx_bitset_subset_val(b, x);
  814.  
  815.   return hash;
  816. }
  817.  
  818.  
  819. RX_DECL RX_subset rx_subset_singletons [RX_subset_bits] = 
  820. {
  821.   0x1,
  822.   0x2,
  823.   0x4,
  824.   0x8,
  825.   0x10,
  826.   0x20,
  827.   0x40,
  828.   0x80,
  829.   0x100,
  830.   0x200,
  831.   0x400,
  832.   0x800,
  833.   0x1000,
  834.   0x2000,
  835.   0x4000,
  836.   0x8000,
  837.   0x10000,
  838.   0x20000,
  839.   0x40000,
  840.   0x80000,
  841.   0x100000,
  842.   0x200000,
  843.   0x400000,
  844.   0x800000,
  845.   0x1000000,
  846.   0x2000000,
  847.   0x4000000,
  848.   0x8000000,
  849.   0x10000000,
  850.   0x20000000,
  851.   0x40000000,
  852.   0x80000000
  853. };
  854.  
  855. #ifdef RX_DEBUG
  856.  
  857. #ifdef __STDC__
  858. static void
  859. print_cset (struct rx *rx, rx_Bitset cset, FILE * fp)
  860. #else
  861. static void
  862. print_cset (rx, cset, fp)
  863.      struct rx *rx;
  864.      rx_Bitset cset;
  865.      FILE * fp;
  866. #endif
  867. {
  868.   int x;
  869.   fputc ('[', fp);
  870.   for (x = 0; x < rx->local_cset_size; ++x)
  871.     if (isprint(x) && RX_bitset_member (cset, x))
  872.       fputc (x, fp);
  873.   fputc (']', fp);
  874. }
  875.  
  876. #endif /*  RX_DEBUG */
  877.  
  878.  
  879.  
  880. static unsigned long rx_hash_masks[4] =
  881. {
  882.   0x12488421,
  883.   0x96699669,
  884.   0xbe7dd7eb,
  885.   0xffffffff
  886. };
  887.  
  888.  
  889. /* Hash tables */
  890. #ifdef __STDC__
  891. RX_DECL struct rx_hash_item * 
  892. rx_hash_find (struct rx_hash * table,
  893.           unsigned long hash,
  894.           void * value,
  895.           struct rx_hash_rules * rules)
  896. #else
  897. RX_DECL struct rx_hash_item * 
  898. rx_hash_find (table, hash, value, rules)
  899.      struct rx_hash * table;
  900.      unsigned long hash;
  901.      void * value;
  902.      struct rx_hash_rules * rules;
  903. #endif
  904. {
  905.   rx_hash_eq eq = rules->eq;
  906.   int maskc = 0;
  907.   int mask = rx_hash_masks [0];
  908.   int bucket = (hash & mask) % 13;
  909.  
  910.   while (table->children [bucket])
  911.     {
  912.       table = table->children [bucket];
  913.       ++maskc;
  914.       mask = rx_hash_masks[maskc];
  915.       bucket = (hash & mask) % 13;
  916.     }
  917.  
  918.   {
  919.     struct rx_hash_item * it = table->buckets[bucket];
  920.     while (it)
  921.       if (eq (it->data, value))
  922.     return it;
  923.       else
  924.     it = it->next_same_hash;
  925.   }
  926.  
  927.   return 0;
  928. }
  929.  
  930. #ifdef __STDC__
  931. RX_DECL struct rx_hash_item *
  932. rx_hash_store (struct rx_hash * table,
  933.            unsigned long hash,
  934.            void * value,
  935.            struct rx_hash_rules * rules)
  936. #else
  937. RX_DECL struct rx_hash_item *
  938. rx_hash_store (table, hash, value, rules)
  939.      struct rx_hash * table;
  940.      unsigned long hash;
  941.      void * value;
  942.      struct rx_hash_rules * rules;
  943. #endif
  944. {
  945.   rx_hash_eq eq = rules->eq;
  946.   int maskc = 0;
  947.   int mask = rx_hash_masks[0];
  948.   int bucket = (hash & mask) % 13;
  949.   int depth = 0;
  950.   
  951.   while (table->children [bucket])
  952.     {
  953.       table = table->children [bucket];
  954.       ++maskc;
  955.       mask = rx_hash_masks[maskc];
  956.       bucket = (hash & mask) % 13;
  957.       ++depth;
  958.     }
  959.   
  960.   {
  961.     struct rx_hash_item * it = table->buckets[bucket];
  962.     while (it)
  963.       if (eq (it->data, value))
  964.     return it;
  965.       else
  966.     it = it->next_same_hash;
  967.   }
  968.   
  969.   {
  970.     if (   (depth < 3)
  971.     && (table->bucket_size [bucket] >= 4))
  972.       {
  973.     struct rx_hash * newtab = ((struct rx_hash *)
  974.                    rules->hash_alloc (rules));
  975.     if (!newtab)
  976.       goto add_to_bucket;
  977.     bzero (newtab, sizeof (*newtab));
  978.     newtab->parent = table;
  979.     {
  980.       struct rx_hash_item * them = table->buckets[bucket];
  981.       unsigned long newmask = rx_hash_masks[maskc + 1];
  982.       while (them)
  983.         {
  984.           struct rx_hash_item * save = them->next_same_hash;
  985.           int new_buck = (them->hash & newmask) % 13;
  986.           them->next_same_hash = newtab->buckets[new_buck];
  987.           newtab->buckets[new_buck] = them;
  988.           them->table = newtab;
  989.           them = save;
  990.           ++newtab->bucket_size[new_buck];
  991.           ++newtab->refs;
  992.         }
  993.       table->refs = (table->refs - table->bucket_size[bucket] + 1);
  994.       table->bucket_size[bucket] = 0;
  995.       table->buckets[bucket] = 0;
  996.       table->children[bucket] = newtab;
  997.       table = newtab;
  998.       bucket = (hash & newmask) % 13;
  999.     }
  1000.       }
  1001.   }
  1002.  add_to_bucket:
  1003.   {
  1004.     struct rx_hash_item  * it = ((struct rx_hash_item *)
  1005.                  rules->hash_item_alloc (rules, value));
  1006.     if (!it)
  1007.       return 0;
  1008.     it->hash = hash;
  1009.     it->table = table;
  1010.     /* DATA and BINDING are to be set in hash_item_alloc */
  1011.     it->next_same_hash = table->buckets [bucket];
  1012.     table->buckets[bucket] = it;
  1013.     ++table->bucket_size [bucket];
  1014.     ++table->refs;
  1015.     return it;
  1016.   }
  1017. }
  1018.  
  1019. #ifdef __STDC__
  1020. RX_DECL void
  1021. rx_hash_free (struct rx_hash_item * it, struct rx_hash_rules * rules)
  1022. #else
  1023. RX_DECL void
  1024. rx_hash_free (it, rules)
  1025.      struct rx_hash_item * it;
  1026.      struct rx_hash_rules * rules;
  1027. #endif
  1028. {
  1029.   if (it)
  1030.     {
  1031.       struct rx_hash * table = it->table;
  1032.       unsigned long hash = it->hash;
  1033.       int depth = (table->parent
  1034.            ? (table->parent->parent
  1035.               ? (table->parent->parent->parent
  1036.              ? 3
  1037.              : 2)
  1038.               : 1)
  1039.            : 0);
  1040.       int bucket = (hash & rx_hash_masks [depth]) % 13;
  1041.       struct rx_hash_item ** pos = &table->buckets [bucket];
  1042.       
  1043.       while (*pos != it)
  1044.     pos = &(*pos)->next_same_hash;
  1045.       *pos = it->next_same_hash;
  1046.       rules->free_hash_item (it, rules);
  1047.       --table->bucket_size[bucket];
  1048.       --table->refs;
  1049.       while (!table->refs && depth)
  1050.     {
  1051.       struct rx_hash * save = table;
  1052.       table = table->parent;
  1053.       --depth;
  1054.       bucket = (hash & rx_hash_masks [depth]) % 13;
  1055.       --table->refs;
  1056.       table->children[bucket] = 0;
  1057.       rules->free_hash (save, rules);
  1058.     }
  1059.     }
  1060. }
  1061.  
  1062. #ifdef __STDC__
  1063. typedef void (*rx_hash_freefn) (struct rx_hash_item * it);
  1064. #else /* ndef __STDC__ */
  1065. typedef void (*rx_hash_freefn) ();
  1066. #endif /* ndef __STDC__ */
  1067.  
  1068. #ifdef __STDC__
  1069. RX_DECL void
  1070. rx_free_hash_table (struct rx_hash * tab, rx_hash_freefn freefn,
  1071.             struct rx_hash_rules * rules)
  1072. #else
  1073. RX_DECL void
  1074. rx_free_hash_table (tab, freefn, rules)
  1075.      struct rx_hash * tab;
  1076.      rx_hash_freefn freefn;
  1077.      struct rx_hash_rules * rules;
  1078. #endif
  1079. {
  1080.   int x;
  1081.  
  1082.   for (x = 0; x < 13; ++x)
  1083.     if (tab->children[x])
  1084.       {
  1085.     rx_free_hash_table (tab->children[x], freefn, rules);
  1086.     rules->free_hash (tab->children[x], rules);
  1087.       }
  1088.     else
  1089.       {
  1090.     struct rx_hash_item * them = tab->buckets[x];
  1091.     while (them)
  1092.       {
  1093.         struct rx_hash_item * that = them;
  1094.         them = that->next_same_hash;
  1095.         freefn (that);
  1096.         rules->free_hash_item (that, rules);
  1097.       }
  1098.       }
  1099. }
  1100.  
  1101.  
  1102.  
  1103. /* Utilities for manipulating bitset represntations of characters sets. */
  1104.  
  1105. #ifdef __STDC__
  1106. RX_DECL rx_Bitset
  1107. rx_cset (struct rx *rx)
  1108. #else
  1109. RX_DECL rx_Bitset
  1110. rx_cset (rx)
  1111.      struct rx *rx;
  1112. #endif
  1113. {
  1114.   rx_Bitset b = (rx_Bitset) malloc (rx_sizeof_bitset (rx->local_cset_size));
  1115.   if (b)
  1116.     rx_bitset_null (rx->local_cset_size, b);
  1117.   return b;
  1118. }
  1119.  
  1120.  
  1121. #ifdef __STDC__
  1122. RX_DECL rx_Bitset
  1123. rx_copy_cset (struct rx *rx, rx_Bitset a)
  1124. #else
  1125. RX_DECL rx_Bitset
  1126. rx_copy_cset (rx, a)
  1127.      struct rx *rx;
  1128.      rx_Bitset a;
  1129. #endif
  1130. {
  1131.   rx_Bitset cs = rx_cset (rx);
  1132.  
  1133.   if (cs)
  1134.     rx_bitset_union (rx->local_cset_size, cs, a);
  1135.  
  1136.   return cs;
  1137. }
  1138.  
  1139.  
  1140. #ifdef __STDC__
  1141. RX_DECL void
  1142. rx_free_cset (struct rx * rx, rx_Bitset c)
  1143. #else
  1144. RX_DECL void
  1145. rx_free_cset (rx, c)
  1146.      struct rx * rx;
  1147.      rx_Bitset c;
  1148. #endif
  1149. {
  1150.   if (c)
  1151.     free ((char *)c);
  1152. }
  1153.  
  1154.  
  1155. /* Hash table memory allocation policy for the regexp compiler */
  1156.  
  1157. #ifdef __STDC__
  1158. struct rx_hash *
  1159. compiler_hash_alloc (struct rx_hash_rules * rules)
  1160. #else
  1161. struct rx_hash *
  1162. compiler_hash_alloc (rules)
  1163.      struct rx_hash_rules * rules;
  1164. #endif
  1165. {
  1166.   return (struct rx_hash *)malloc (sizeof (struct rx_hash));
  1167. }
  1168.  
  1169. #ifdef __STDC__
  1170. struct rx_hash_item *
  1171. compiler_hash_item_alloc (struct rx_hash_rules * rules, void * value)
  1172. #else
  1173. struct rx_hash_item *
  1174. compiler_hash_item_alloc (rules, value)
  1175.      struct rx_hash_rules * rules;
  1176.      void * value;
  1177. #endif
  1178. {
  1179.   struct rx_hash_item * it;
  1180.   it = (struct rx_hash_item *)malloc (sizeof (*it));
  1181.   if (it)
  1182.     {
  1183.       it->data = value;
  1184.       it->binding = 0;
  1185.     }
  1186.   return it;
  1187. }
  1188.  
  1189. #ifdef __STDC__
  1190. void
  1191. compiler_free_hash (struct rx_hash * tab,
  1192.             struct rx_hash_rules * rules)
  1193. #else
  1194. void
  1195. compiler_free_hash (tab, rules)
  1196.      struct rx_hash * tab;
  1197.      struct rx_hash_rules * rules;
  1198. #endif
  1199. {
  1200.   free ((char *)tab);
  1201. }
  1202.  
  1203. #ifdef __STDC__
  1204. void
  1205. compiler_free_hash_item (struct rx_hash_item * item,
  1206.              struct rx_hash_rules * rules)
  1207. #else
  1208. void
  1209. compiler_free_hash_item (item, rules)
  1210.      struct rx_hash_item * item;
  1211.      struct rx_hash_rules * rules;
  1212. #endif
  1213. {
  1214.   free ((char *)item);
  1215. }
  1216.  
  1217.  
  1218. /* This page: REXP_NODE (expression tree) structures. */
  1219.  
  1220. #ifdef __STDC__
  1221. RX_DECL struct rexp_node *
  1222. rexp_node (struct rx *rx,
  1223.        enum rexp_node_type type)
  1224. #else
  1225. RX_DECL struct rexp_node *
  1226. rexp_node (rx, type)
  1227.      struct rx *rx;
  1228.      enum rexp_node_type type;
  1229. #endif
  1230. {
  1231.   struct rexp_node *n;
  1232.  
  1233.   n = (struct rexp_node *)malloc (sizeof (*n));
  1234.   bzero (n, sizeof (*n));
  1235.   if (n)
  1236.     n->type = type;
  1237.   return n;
  1238. }
  1239.  
  1240.  
  1241. /* free_rexp_node assumes that the bitset passed to rx_mk_r_cset
  1242.  * can be freed using rx_free_cset.
  1243.  */
  1244. #ifdef __STDC__
  1245. RX_DECL struct rexp_node *
  1246. rx_mk_r_cset (struct rx * rx,
  1247.           rx_Bitset b)
  1248. #else
  1249. RX_DECL struct rexp_node *
  1250. rx_mk_r_cset (rx, b)
  1251.      struct rx * rx;
  1252.      rx_Bitset b;
  1253. #endif
  1254. {
  1255.   struct rexp_node * n = rexp_node (rx, r_cset);
  1256.   if (n)
  1257.     n->params.cset = b;
  1258.   return n;
  1259. }
  1260.  
  1261.  
  1262. #ifdef __STDC__
  1263. RX_DECL struct rexp_node *
  1264. rx_mk_r_concat (struct rx * rx,
  1265.         struct rexp_node * a,
  1266.         struct rexp_node * b)
  1267. #else
  1268. RX_DECL struct rexp_node *
  1269. rx_mk_r_concat (rx, a, b)
  1270.      struct rx * rx;
  1271.      struct rexp_node * a;
  1272.      struct rexp_node * b;
  1273. #endif
  1274. {
  1275.   struct rexp_node * n = rexp_node (rx, r_concat);
  1276.   if (n)
  1277.     {
  1278.       n->params.pair.left = a;
  1279.       n->params.pair.right = b;
  1280.     }
  1281.   return n;
  1282. }
  1283.  
  1284.  
  1285. #ifdef __STDC__
  1286. RX_DECL struct rexp_node *
  1287. rx_mk_r_alternate (struct rx * rx,
  1288.            struct rexp_node * a,
  1289.            struct rexp_node * b)
  1290. #else
  1291. RX_DECL struct rexp_node *
  1292. rx_mk_r_alternate (rx, a, b)
  1293.      struct rx * rx;
  1294.      struct rexp_node * a;
  1295.      struct rexp_node * b;
  1296. #endif
  1297. {
  1298.   struct rexp_node * n = rexp_node (rx, r_alternate);
  1299.   if (n)
  1300.     {
  1301.       n->params.pair.left = a;
  1302.       n->params.pair.right = b;
  1303.     }
  1304.   return n;
  1305. }
  1306.  
  1307.  
  1308. #ifdef __STDC__
  1309. RX_DECL struct rexp_node *
  1310. rx_mk_r_opt (struct rx * rx,
  1311.          struct rexp_node * a)
  1312. #else
  1313. RX_DECL struct rexp_node *
  1314. rx_mk_r_opt (rx, a)
  1315.      struct rx * rx;
  1316.      struct rexp_node * a;
  1317. #endif
  1318. {
  1319.   struct rexp_node * n = rexp_node (rx, r_opt);
  1320.   if (n)
  1321.     {
  1322.       n->params.pair.left = a;
  1323.       n->params.pair.right = 0;
  1324.     }
  1325.   return n;
  1326. }
  1327.  
  1328.  
  1329. #ifdef __STDC__
  1330. RX_DECL struct rexp_node *
  1331. rx_mk_r_star (struct rx * rx,
  1332.           struct rexp_node * a)
  1333. #else
  1334. RX_DECL struct rexp_node *
  1335. rx_mk_r_star (rx, a)
  1336.      struct rx * rx;
  1337.      struct rexp_node * a;
  1338. #endif
  1339. {
  1340.   struct rexp_node * n = rexp_node (rx, r_star);
  1341.   if (n)
  1342.     {
  1343.       n->params.pair.left = a;
  1344.       n->params.pair.right = 0;
  1345.     }
  1346.   return n;
  1347. }
  1348.  
  1349.  
  1350. #ifdef __STDC__
  1351. RX_DECL struct rexp_node *
  1352. rx_mk_r_2phase_star (struct rx * rx,
  1353.              struct rexp_node * a,
  1354.              struct rexp_node * b)
  1355. #else
  1356. RX_DECL struct rexp_node *
  1357. rx_mk_r_2phase_star (rx, a, b)
  1358.      struct rx * rx;
  1359.      struct rexp_node * a;
  1360.      struct rexp_node * b;
  1361. #endif
  1362. {
  1363.   struct rexp_node * n = rexp_node (rx, r_2phase_star);
  1364.   if (n)
  1365.     {
  1366.       n->params.pair.left = a;
  1367.       n->params.pair.right = b;
  1368.     }
  1369.   return n;
  1370. }
  1371.  
  1372.  
  1373.  
  1374. #ifdef __STDC__
  1375. RX_DECL struct rexp_node *
  1376. rx_mk_r_side_effect (struct rx * rx,
  1377.              rx_side_effect a)
  1378. #else
  1379. RX_DECL struct rexp_node *
  1380. rx_mk_r_side_effect (rx, a)
  1381.      struct rx * rx;
  1382.      rx_side_effect a;
  1383. #endif
  1384. {
  1385.   struct rexp_node * n = rexp_node (rx, r_side_effect);
  1386.   if (n)
  1387.     {
  1388.       n->params.side_effect = a;
  1389.       n->params.pair.right = 0;
  1390.     }
  1391.   return n;
  1392. }
  1393.  
  1394.  
  1395. #ifdef __STDC__
  1396. RX_DECL struct rexp_node *
  1397. rx_mk_r_data  (struct rx * rx,
  1398.            void * a)
  1399. #else
  1400. RX_DECL struct rexp_node *
  1401. rx_mk_r_data  (rx, a)
  1402.      struct rx * rx;
  1403.      void * a;
  1404. #endif
  1405. {
  1406.   struct rexp_node * n = rexp_node (rx, r_data);
  1407.   if (n)
  1408.     {
  1409.       n->params.pair.left = a;
  1410.       n->params.pair.right = 0;
  1411.     }
  1412.   return n;
  1413. }
  1414.  
  1415.  
  1416. #ifdef __STDC__
  1417. RX_DECL void
  1418. rx_free_rexp (struct rx * rx, struct rexp_node * node)
  1419. #else
  1420. RX_DECL void
  1421. rx_free_rexp (rx, node)
  1422.      struct rx * rx;
  1423.      struct rexp_node * node;
  1424. #endif
  1425. {
  1426.   if (node)
  1427.     {
  1428.       switch (node->type)
  1429.     {
  1430.     case r_cset:
  1431.       if (node->params.cset)
  1432.         rx_free_cset (rx, node->params.cset);
  1433.  
  1434.     case r_side_effect:
  1435.       break;
  1436.       
  1437.     case r_concat:
  1438.     case r_alternate:
  1439.     case r_2phase_star:
  1440.     case r_opt:
  1441.     case r_star:
  1442.       rx_free_rexp (rx, node->params.pair.left);
  1443.       rx_free_rexp (rx, node->params.pair.right);
  1444.       break;
  1445.  
  1446.     case r_data:
  1447.       /* This shouldn't occur. */
  1448.       break;
  1449.     }
  1450.       free ((char *)node);
  1451.     }
  1452. }
  1453.  
  1454.  
  1455. #ifdef __STDC__
  1456. RX_DECL struct rexp_node * 
  1457. rx_copy_rexp (struct rx *rx,
  1458.        struct rexp_node *node)
  1459. #else
  1460. RX_DECL struct rexp_node * 
  1461. rx_copy_rexp (rx, node)
  1462.      struct rx *rx;
  1463.      struct rexp_node *node;
  1464. #endif
  1465. {
  1466.   if (!node)
  1467.     return 0;
  1468.   else
  1469.     {
  1470.       struct rexp_node *n = rexp_node (rx, node->type);
  1471.       if (!n)
  1472.     return 0;
  1473.       switch (node->type)
  1474.     {
  1475.     case r_cset:
  1476.       n->params.cset = rx_copy_cset (rx, node->params.cset);
  1477.       if (!n->params.cset)
  1478.         {
  1479.           rx_free_rexp (rx, n);
  1480.           return 0;
  1481.         }
  1482.       break;
  1483.  
  1484.     case r_side_effect:
  1485.       n->params.side_effect = node->params.side_effect;
  1486.       break;
  1487.  
  1488.     case r_concat:
  1489.     case r_alternate:
  1490.     case r_opt:
  1491.     case r_2phase_star:
  1492.     case r_star:
  1493.       n->params.pair.left =
  1494.         rx_copy_rexp (rx, node->params.pair.left);
  1495.       n->params.pair.right =
  1496.         rx_copy_rexp (rx, node->params.pair.right);
  1497.       if (   (node->params.pair.left && !n->params.pair.left)
  1498.           || (node->params.pair.right && !n->params.pair.right))
  1499.         {
  1500.           rx_free_rexp  (rx, n);
  1501.           return 0;
  1502.         }
  1503.       break;
  1504.     case r_data:
  1505.       /* shouldn't happen */
  1506.       break;
  1507.     }
  1508.       return n;
  1509.     }
  1510. }
  1511.  
  1512.  
  1513.  
  1514. /* This page: functions to build and destroy graphs that describe nfa's */
  1515.  
  1516. /* Constructs a new nfa node. */
  1517. #ifdef __STDC__
  1518. RX_DECL struct rx_nfa_state *
  1519. rx_nfa_state (struct rx *rx)
  1520. #else
  1521. RX_DECL struct rx_nfa_state *
  1522. rx_nfa_state (rx)
  1523.      struct rx *rx;
  1524. #endif
  1525. {
  1526.   struct rx_nfa_state * n = (struct rx_nfa_state *)malloc (sizeof (*n));
  1527.   if (!n)
  1528.     return 0;
  1529.   bzero (n, sizeof (*n));
  1530.   n->next = rx->nfa_states;
  1531.   rx->nfa_states = n;
  1532.   return n;
  1533. }
  1534.  
  1535.  
  1536. #ifdef __STDC__
  1537. RX_DECL void
  1538. rx_free_nfa_state (struct rx_nfa_state * n)
  1539. #else
  1540. RX_DECL void
  1541. rx_free_nfa_state (n)
  1542.   struct rx_nfa_state * n;
  1543. #endif
  1544. {
  1545.   free ((char *)n);
  1546. }
  1547.  
  1548.  
  1549. /* This looks up an nfa node, given a numeric id.  Numeric id's are
  1550.  * assigned after the nfa has been built.
  1551.  */
  1552. #ifdef __STDC__
  1553. RX_DECL struct rx_nfa_state * 
  1554. rx_id_to_nfa_state (struct rx * rx,
  1555.             int id)
  1556. #else
  1557. RX_DECL struct rx_nfa_state * 
  1558. rx_id_to_nfa_state (rx, id)
  1559.      struct rx * rx;
  1560.      int id;
  1561. #endif
  1562. {
  1563.   struct rx_nfa_state * n;
  1564.   for (n = rx->nfa_states; n; n = n->next)
  1565.     if (n->id == id)
  1566.       return n;
  1567.   return 0;
  1568. }
  1569.  
  1570.  
  1571. /* This adds an edge between two nodes, but doesn't initialize the 
  1572.  * edge label.
  1573.  */
  1574.  
  1575. #ifdef __STDC__
  1576. RX_DECL struct rx_nfa_edge * 
  1577. rx_nfa_edge (struct rx *rx,
  1578.          enum rx_nfa_etype type,
  1579.          struct rx_nfa_state *start,
  1580.          struct rx_nfa_state *dest)
  1581. #else
  1582. RX_DECL struct rx_nfa_edge * 
  1583. rx_nfa_edge (rx, type, start, dest)
  1584.      struct rx *rx;
  1585.      enum rx_nfa_etype type;
  1586.      struct rx_nfa_state *start;
  1587.      struct rx_nfa_state *dest;
  1588. #endif
  1589. {
  1590.   struct rx_nfa_edge *e;
  1591.   e = (struct rx_nfa_edge *)malloc (sizeof (*e));
  1592.   if (!e)
  1593.     return 0;
  1594.   e->next = start->edges;
  1595.   start->edges = e;
  1596.   e->type = type;
  1597.   e->dest = dest;
  1598.   return e;
  1599. }
  1600.  
  1601.  
  1602. #ifdef __STDC__
  1603. RX_DECL void
  1604. rx_free_nfa_edge (struct rx_nfa_edge * e)
  1605. #else
  1606. RX_DECL void
  1607. rx_free_nfa_edge (e)
  1608.      struct rx_nfa_edge * e;
  1609. #endif
  1610. {
  1611.   free ((char *)e);
  1612. }
  1613.  
  1614.  
  1615. /* This constructs a POSSIBLE_FUTURE, which is a kind epsilon-closure
  1616.  * of an NFA.  These are added to an nfa automaticly by eclose_nfa.
  1617.  */  
  1618.  
  1619. #ifdef __STDC__
  1620. static struct rx_possible_future * 
  1621. rx_possible_future (struct rx * rx,
  1622.          struct rx_se_list * effects)
  1623. #else
  1624. static struct rx_possible_future * 
  1625. rx_possible_future (rx, effects)
  1626.      struct rx * rx;
  1627.      struct rx_se_list * effects;
  1628. #endif
  1629. {
  1630.   struct rx_possible_future *ec;
  1631.   ec = (struct rx_possible_future *) malloc (sizeof (*ec));
  1632.   if (!ec)
  1633.     return 0;
  1634.   ec->destset = 0;
  1635.   ec->next = 0;
  1636.   ec->effects = effects;
  1637.   return ec;
  1638. }
  1639.  
  1640.  
  1641. #ifdef __STDC__
  1642. static void
  1643. rx_free_possible_future (struct rx_possible_future * pf)
  1644. #else
  1645. static void
  1646. rx_free_possible_future (pf)
  1647.      struct rx_possible_future * pf;
  1648. #endif
  1649. {
  1650.   free ((char *)pf);
  1651. }
  1652.  
  1653.  
  1654. #ifdef __STDC__
  1655. RX_DECL void
  1656. rx_free_nfa (struct rx *rx)
  1657. #else
  1658. RX_DECL void
  1659. rx_free_nfa (rx)
  1660.      struct rx *rx;
  1661. #endif
  1662. {
  1663.   while (rx->nfa_states)
  1664.     {
  1665.       while (rx->nfa_states->edges)
  1666.     {
  1667.       switch (rx->nfa_states->edges->type)
  1668.         {
  1669.         case ne_cset:
  1670.           rx_free_cset (rx, rx->nfa_states->edges->params.cset);
  1671.           break;
  1672.         default:
  1673.           break;
  1674.         }
  1675.       {
  1676.         struct rx_nfa_edge * e;
  1677.         e = rx->nfa_states->edges;
  1678.         rx->nfa_states->edges = rx->nfa_states->edges->next;
  1679.         rx_free_nfa_edge (e);
  1680.       }
  1681.     } /* while (rx->nfa_states->edges) */
  1682.       {
  1683.     /* Iterate over the partial epsilon closures of rx->nfa_states */
  1684.     struct rx_possible_future * pf = rx->nfa_states->futures;
  1685.     while (pf)
  1686.       {
  1687.         struct rx_possible_future * pft = pf;
  1688.         pf = pf->next;
  1689.         rx_free_possible_future (pft);
  1690.       }
  1691.       }
  1692.       {
  1693.     struct rx_nfa_state *n;
  1694.     n = rx->nfa_states;
  1695.     rx->nfa_states = rx->nfa_states->next;
  1696.     rx_free_nfa_state (n);
  1697.       }
  1698.     }
  1699. }
  1700.  
  1701.  
  1702.  
  1703. /* This page: translating a pattern expression in to an nfa and doing the 
  1704.  * static part of the nfa->super-nfa translation.
  1705.  */
  1706.  
  1707. /* This is the thompson regexp->nfa algorithm. */
  1708. #ifdef __STDC__
  1709. RX_DECL int
  1710. rx_build_nfa (struct rx *rx,
  1711.           struct rexp_node *rexp,
  1712.           struct rx_nfa_state **start,
  1713.           struct rx_nfa_state **end)
  1714. #else
  1715. RX_DECL int
  1716. rx_build_nfa (rx, rexp, start, end)
  1717.      struct rx *rx;
  1718.      struct rexp_node *rexp;
  1719.      struct rx_nfa_state **start;
  1720.      struct rx_nfa_state **end;
  1721. #endif
  1722. {
  1723.   struct rx_nfa_edge *edge;
  1724.  
  1725.   /* Start & end nodes may have been allocated by the caller. */
  1726.   *start = *start ? *start : rx_nfa_state (rx);
  1727.  
  1728.   if (!*start)
  1729.     return 0;
  1730.  
  1731.   if (!rexp)
  1732.     {
  1733.       *end = *start;
  1734.       return 1;
  1735.     }
  1736.  
  1737.   *end = *end ? *end : rx_nfa_state (rx);
  1738.  
  1739.   if (!*end)
  1740.     {
  1741.       rx_free_nfa_state (*start);
  1742.       return 0;
  1743.     }
  1744.  
  1745.   switch (rexp->type)
  1746.     {
  1747.     case r_data:
  1748.       return 0;
  1749.  
  1750.     case r_cset:
  1751.       edge = rx_nfa_edge (rx, ne_cset, *start, *end);
  1752.       if (!edge)
  1753.     return 0;
  1754.       edge->params.cset = rx_copy_cset (rx, rexp->params.cset);
  1755.       if (!edge->params.cset)
  1756.     {
  1757.       rx_free_nfa_edge (edge);
  1758.       return 0;
  1759.     }
  1760.       return 1;
  1761.  
  1762.     case r_opt:
  1763.       return (rx_build_nfa (rx, rexp->params.pair.left, start, end)
  1764.           && rx_nfa_edge (rx, ne_epsilon, *start, *end));
  1765.  
  1766.     case r_star:
  1767.       {
  1768.     struct rx_nfa_state * star_start = 0;
  1769.     struct rx_nfa_state * star_end = 0;
  1770.     return (rx_build_nfa (rx, rexp->params.pair.left,
  1771.                   &star_start, &star_end)
  1772.         && star_start
  1773.         && star_end
  1774.         && rx_nfa_edge (rx, ne_epsilon, star_start, star_end)
  1775.         && rx_nfa_edge (rx, ne_epsilon, *start, star_start)
  1776.         && rx_nfa_edge (rx, ne_epsilon, star_end, *end)
  1777.  
  1778.         && rx_nfa_edge (rx, ne_epsilon, star_end, star_start));
  1779.       }
  1780.  
  1781.     case r_2phase_star:
  1782.       {
  1783.     struct rx_nfa_state * star_start = 0;
  1784.     struct rx_nfa_state * star_end = 0;
  1785.     struct rx_nfa_state * loop_exp_start = 0;
  1786.     struct rx_nfa_state * loop_exp_end = 0;
  1787.  
  1788.     return (rx_build_nfa (rx, rexp->params.pair.left,
  1789.                   &star_start, &star_end)
  1790.         && rx_build_nfa (rx, rexp->params.pair.right,
  1791.                  &loop_exp_start, &loop_exp_end)
  1792.         && star_start
  1793.         && star_end
  1794.         && loop_exp_end
  1795.         && loop_exp_start
  1796.         && rx_nfa_edge (rx, ne_epsilon, star_start, *end)
  1797.         && rx_nfa_edge (rx, ne_epsilon, *start, star_start)
  1798.         && rx_nfa_edge (rx, ne_epsilon, star_end, *end)
  1799.  
  1800.         && rx_nfa_edge (rx, ne_epsilon, star_end, loop_exp_start)
  1801.         && rx_nfa_edge (rx, ne_epsilon, loop_exp_end, star_start));
  1802.       }
  1803.  
  1804.  
  1805.     case r_concat:
  1806.       {
  1807.     struct rx_nfa_state *shared = 0;
  1808.     return
  1809.       (rx_build_nfa (rx, rexp->params.pair.left, start, &shared)
  1810.        && rx_build_nfa (rx, rexp->params.pair.right, &shared, end));
  1811.       }
  1812.  
  1813.     case r_alternate:
  1814.       {
  1815.     struct rx_nfa_state *ls = 0;
  1816.     struct rx_nfa_state *le = 0;
  1817.     struct rx_nfa_state *rs = 0;
  1818.     struct rx_nfa_state *re = 0;
  1819.     return (rx_build_nfa (rx, rexp->params.pair.left, &ls, &le)
  1820.         && rx_build_nfa (rx, rexp->params.pair.right, &rs, &re)
  1821.         && rx_nfa_edge (rx, ne_epsilon, *start, ls)
  1822.         && rx_nfa_edge (rx, ne_epsilon, *start, rs)
  1823.         && rx_nfa_edge (rx, ne_epsilon, le, *end)
  1824.         && rx_nfa_edge (rx, ne_epsilon, re, *end));
  1825.       }
  1826.  
  1827.     case r_side_effect:
  1828.       edge = rx_nfa_edge (rx, ne_side_effect, *start, *end);
  1829.       if (!edge)
  1830.     return 0;
  1831.       edge->params.side_effect = rexp->params.side_effect;
  1832.       return 1;
  1833.     }
  1834.  
  1835.   /* this should never happen */
  1836.   return 0;
  1837. }
  1838.  
  1839.  
  1840. /* NAME_RX->NFA_STATES identifies all nodes with non-epsilon transitions.
  1841.  * These nodes can occur in super-states.  All nodes are given an integer id.
  1842.  * The id is non-negative if the node has non-epsilon out-transitions, negative
  1843.  * otherwise (this is because we want the non-negative ids to be used as 
  1844.  * array indexes in a few places).
  1845.  */
  1846.  
  1847. #ifdef __STDC__
  1848. RX_DECL void
  1849. rx_name_nfa_states (struct rx *rx)
  1850. #else
  1851. RX_DECL void
  1852. rx_name_nfa_states (rx)
  1853.      struct rx *rx;
  1854. #endif
  1855. {
  1856.   struct rx_nfa_state *n = rx->nfa_states;
  1857.  
  1858.   rx->nodec = 0;
  1859.   rx->epsnodec = -1;
  1860.  
  1861.   while (n)
  1862.     {
  1863.       struct rx_nfa_edge *e = n->edges;
  1864.  
  1865.       if (n->is_start)
  1866.     n->eclosure_needed = 1;
  1867.  
  1868.       while (e)
  1869.     {
  1870.       switch (e->type)
  1871.         {
  1872.         case ne_epsilon:
  1873.         case ne_side_effect:
  1874.           break;
  1875.  
  1876.         case ne_cset:
  1877.           n->id = rx->nodec++;
  1878.           {
  1879.         struct rx_nfa_edge *from_n = n->edges;
  1880.         while (from_n)
  1881.           {
  1882.             from_n->dest->eclosure_needed = 1;
  1883.             from_n = from_n->next;
  1884.           }
  1885.           }
  1886.           goto cont;
  1887.         }
  1888.       e = e->next;
  1889.     }
  1890.       n->id = rx->epsnodec--;
  1891.     cont:
  1892.       n = n->next;
  1893.     }
  1894.   rx->epsnodec = -rx->epsnodec;
  1895. }
  1896.  
  1897.  
  1898. /* This page: data structures for the static part of the nfa->supernfa
  1899.  * translation.
  1900.  */
  1901.  
  1902. /* The next several functions compare, construct, etc. lists of side
  1903.  * effects.  See ECLOSE_NFA (below) for details.
  1904.  */
  1905.  
  1906. /* Ordering of rx_se_list
  1907.  * (-1, 0, 1 return value convention).
  1908.  */
  1909.  
  1910. #ifdef __STDC__
  1911. static int 
  1912. se_list_cmp (void * va, void * vb)
  1913. #else
  1914. static int 
  1915. se_list_cmp (va, vb)
  1916.      void * va;
  1917.      void * vb;
  1918. #endif
  1919. {
  1920.   struct rx_se_list * a = (struct rx_se_list *)va;
  1921.   struct rx_se_list * b = (struct rx_se_list *)vb;
  1922.  
  1923.   return ((va == vb)
  1924.       ? 0
  1925.       : (!va
  1926.          ? -1
  1927.          : (!vb
  1928.         ? 1
  1929.         : ((long)a->car < (long)b->car
  1930.            ? 1
  1931.            : ((long)a->car > (long)b->car
  1932.               ? -1
  1933.               : se_list_cmp ((void *)a->cdr, (void *)b->cdr))))));
  1934. }
  1935.  
  1936.  
  1937. #ifdef __STDC__
  1938. static int 
  1939. se_list_equal (void * va, void * vb)
  1940. #else
  1941. static int 
  1942. se_list_equal (va, vb)
  1943.      void * va;
  1944.      void * vb;
  1945. #endif
  1946. {
  1947.   return !(se_list_cmp (va, vb));
  1948. }
  1949.  
  1950. static struct rx_hash_rules se_list_hash_rules =
  1951. {
  1952.   se_list_equal,
  1953.   compiler_hash_alloc,
  1954.   compiler_free_hash,
  1955.   compiler_hash_item_alloc,
  1956.   compiler_free_hash_item
  1957. };
  1958.  
  1959.  
  1960. #ifdef __STDC__
  1961. static struct rx_se_list * 
  1962. side_effect_cons (struct rx * rx,
  1963.           void * se, struct rx_se_list * list)
  1964. #else
  1965. static struct rx_se_list * 
  1966. side_effect_cons (rx, se, list)
  1967.      struct rx * rx;
  1968.      void * se;
  1969.      struct rx_se_list * list;
  1970. #endif
  1971. {
  1972.   struct rx_se_list * l;
  1973.   l = ((struct rx_se_list *) malloc (sizeof (*l)));
  1974.   if (!l)
  1975.     return 0;
  1976.   l->car = se;
  1977.   l->cdr = list;
  1978.   return l;
  1979. }
  1980.  
  1981.  
  1982. #ifdef __STDC__
  1983. static struct rx_se_list *
  1984. hash_cons_se_prog (struct rx * rx,
  1985.            struct rx_hash * memo,
  1986.            void * car, struct rx_se_list * cdr)
  1987. #else
  1988. static struct rx_se_list *
  1989. hash_cons_se_prog (rx, memo, car, cdr)
  1990.      struct rx * rx;
  1991.      struct rx_hash * memo;
  1992.      void * car;
  1993.      struct rx_se_list * cdr;
  1994. #endif
  1995. {
  1996.   long hash = (long)car ^ (long)cdr;
  1997.   struct rx_se_list template;
  1998.  
  1999.   template.car = car;
  2000.   template.cdr = cdr;
  2001.   {
  2002.     struct rx_hash_item * it = rx_hash_store (memo, hash,
  2003.                           (void *)&template,
  2004.                           &se_list_hash_rules);
  2005.     if (!it)
  2006.       return 0;
  2007.     if (it->data == (void *)&template)
  2008.       {
  2009.     struct rx_se_list * consed;
  2010.     consed = (struct rx_se_list *) malloc (sizeof (*consed));
  2011.     *consed = template;
  2012.     it->data = (void *)consed;
  2013.       }
  2014.     return (struct rx_se_list *)it->data;
  2015.   }
  2016. }
  2017.      
  2018.  
  2019. #ifdef __STDC__
  2020. static struct rx_se_list *
  2021. hash_se_prog (struct rx * rx, struct rx_hash * memo, struct rx_se_list * prog)
  2022. #else
  2023. static struct rx_se_list *
  2024. hash_se_prog (rx, memo, prog)
  2025.      struct rx * rx;
  2026.      struct rx_hash * memo;
  2027.      struct rx_se_list * prog;
  2028. #endif
  2029. {
  2030.   struct rx_se_list * answer = 0;
  2031.   while (prog)
  2032.     {
  2033.       answer = hash_cons_se_prog (rx, memo, prog->car, answer);
  2034.       if (!answer)
  2035.     return 0;
  2036.       prog = prog->cdr;
  2037.     }
  2038.   return answer;
  2039. }
  2040.  
  2041.  
  2042. /* This page: more data structures for nfa->supernfa.  Specificly,
  2043.  * sets of nfa states.
  2044.  */
  2045.  
  2046. #ifdef __STDC__
  2047. static int 
  2048. nfa_set_cmp (void * va, void * vb)
  2049. #else
  2050. static int 
  2051. nfa_set_cmp (va, vb)
  2052.      void * va;
  2053.      void * vb;
  2054. #endif
  2055. {
  2056.   struct rx_nfa_state_set * a = (struct rx_nfa_state_set *)va;
  2057.   struct rx_nfa_state_set * b = (struct rx_nfa_state_set *)vb;
  2058.  
  2059.   return ((va == vb)
  2060.       ? 0
  2061.       : (!va
  2062.          ? -1
  2063.          : (!vb
  2064.         ? 1
  2065.         : (a->car->id < b->car->id
  2066.            ? 1
  2067.            : (a->car->id > b->car->id
  2068.               ? -1
  2069.               : nfa_set_cmp ((void *)a->cdr, (void *)b->cdr))))));
  2070. }
  2071.  
  2072. #ifdef __STDC__
  2073. static int 
  2074. nfa_set_equal (void * va, void * vb)
  2075. #else
  2076. static int 
  2077. nfa_set_equal (va, vb)
  2078.      void * va;
  2079.      void * vb;
  2080. #endif
  2081. {
  2082.   return !nfa_set_cmp (va, vb);
  2083. }
  2084.  
  2085. static struct rx_hash_rules nfa_set_hash_rules =
  2086. {
  2087.   nfa_set_equal,
  2088.   compiler_hash_alloc,
  2089.   compiler_free_hash,
  2090.   compiler_hash_item_alloc,
  2091.   compiler_free_hash_item
  2092. };
  2093.  
  2094.  
  2095. /* CONS -- again, sets with == elements are ==. */
  2096.  
  2097. #ifdef __STDC__
  2098. static struct rx_nfa_state_set * 
  2099. nfa_set_cons (struct rx * rx,
  2100.           struct rx_hash * memo, struct rx_nfa_state * state,
  2101.           struct rx_nfa_state_set * set)
  2102. #else
  2103. static struct rx_nfa_state_set * 
  2104. nfa_set_cons (rx, memo, state, set)
  2105.      struct rx * rx;
  2106.      struct rx_hash * memo;
  2107.      struct rx_nfa_state * state;
  2108.      struct rx_nfa_state_set * set;
  2109. #endif
  2110. {
  2111.   struct rx_nfa_state_set template;
  2112.   struct rx_hash_item * node;
  2113.   template.car = state;
  2114.   template.cdr = set;
  2115.   node = rx_hash_store (memo,
  2116.             (((long)state) >> 8) ^ (long)set,
  2117.             &template, &nfa_set_hash_rules);
  2118.   if (!node)
  2119.     return 0;
  2120.   if (node->data == &template)
  2121.     {
  2122.       struct rx_nfa_state_set * l;
  2123.       l = (struct rx_nfa_state_set *) malloc (sizeof (*l));
  2124.       node->data = (void *) l;
  2125.       if (!l)
  2126.     return 0;
  2127.       *l = template;
  2128.     }
  2129.   return (struct rx_nfa_state_set *)node->data;
  2130. }
  2131.  
  2132.  
  2133. #ifdef __STDC__
  2134. static struct rx_nfa_state_set * 
  2135. nfa_set_enjoin (struct rx * rx,
  2136.         struct rx_hash * memo, struct rx_nfa_state * state,
  2137.         struct rx_nfa_state_set * set)
  2138. #else
  2139. static struct rx_nfa_state_set * 
  2140. nfa_set_enjoin (rx, memo, state, set)
  2141.      struct rx * rx;
  2142.      struct rx_hash * memo;
  2143.      struct rx_nfa_state * state;
  2144.      struct rx_nfa_state_set * set;
  2145. #endif
  2146. {
  2147.   if (!set || state->id < set->car->id)
  2148.     return nfa_set_cons (rx, memo, state, set);
  2149.   if (state->id == set->car->id)
  2150.     return set;
  2151.   else
  2152.     {
  2153.       struct rx_nfa_state_set * newcdr
  2154.     = nfa_set_enjoin (rx, memo, state, set->cdr);
  2155.       if (newcdr != set->cdr)
  2156.     set = nfa_set_cons (rx, memo, set->car, newcdr);
  2157.       return set;
  2158.     }
  2159. }
  2160.  
  2161.  
  2162.  
  2163. /* This page: computing epsilon closures.  The closures aren't total.
  2164.  * Each node's closures are partitioned according to the side effects entailed
  2165.  * along the epsilon edges.  Return true on success.
  2166.  */ 
  2167.  
  2168. struct eclose_frame
  2169. {
  2170.   struct rx_se_list *prog_backwards;
  2171. };
  2172.  
  2173.  
  2174. #ifdef __STDC__
  2175. static int 
  2176. eclose_node (struct rx *rx, struct rx_nfa_state *outnode,
  2177.          struct rx_nfa_state *node, struct eclose_frame *frame)
  2178. #else
  2179. static int 
  2180. eclose_node (rx, outnode, node, frame)
  2181.      struct rx *rx;
  2182.      struct rx_nfa_state *outnode;
  2183.      struct rx_nfa_state *node;
  2184.      struct eclose_frame *frame;
  2185. #endif
  2186. {
  2187.   struct rx_nfa_edge *e = node->edges;
  2188.  
  2189.   /* For each node, we follow all epsilon paths to build the closure.
  2190.    * The closure omits nodes that have only epsilon edges.
  2191.    * The closure is split into partial closures -- all the states in
  2192.    * a partial closure are reached by crossing the same list of
  2193.    * of side effects (though not necessarily the same path).
  2194.    */
  2195.   if (node->mark)
  2196.     return 1;
  2197.   node->mark = 1;
  2198.  
  2199.   if (node->id >= 0 || node->is_final)
  2200.     {
  2201.       struct rx_possible_future **ec;
  2202.       struct rx_se_list * prog_in_order
  2203.     = ((struct rx_se_list *)hash_se_prog (rx,
  2204.                           &rx->se_list_memo,
  2205.                           frame->prog_backwards));
  2206.       int cmp;
  2207.  
  2208.       ec = &outnode->futures;
  2209.  
  2210.       while (*ec)
  2211.     {
  2212.       cmp = se_list_cmp ((void *)(*ec)->effects, (void *)prog_in_order);
  2213.       if (cmp <= 0)
  2214.         break;
  2215.       ec = &(*ec)->next;
  2216.     }
  2217.       if (!*ec || (cmp < 0))
  2218.     {
  2219.       struct rx_possible_future * saved = *ec;
  2220.       *ec = rx_possible_future (rx, prog_in_order);
  2221.       (*ec)->next = saved;
  2222.       if (!*ec)
  2223.         return 0;
  2224.     }
  2225.       if (node->id >= 0)
  2226.     {
  2227.       (*ec)->destset = nfa_set_enjoin (rx, &rx->set_list_memo,
  2228.                        node, (*ec)->destset);
  2229.       if (!(*ec)->destset)
  2230.         return 0;
  2231.     }
  2232.     }
  2233.  
  2234.   while (e)
  2235.     {
  2236.       switch (e->type)
  2237.     {
  2238.     case ne_epsilon:
  2239.       if (!eclose_node (rx, outnode, e->dest, frame))
  2240.         return 0;
  2241.       break;
  2242.     case ne_side_effect:
  2243.       {
  2244.         frame->prog_backwards = side_effect_cons (rx, 
  2245.                               e->params.side_effect,
  2246.                               frame->prog_backwards);
  2247.         if (!frame->prog_backwards)
  2248.           return 0;
  2249.         if (!eclose_node (rx, outnode, e->dest, frame))
  2250.           return 0;
  2251.         {
  2252.           struct rx_se_list * dying = frame->prog_backwards;
  2253.           frame->prog_backwards = frame->prog_backwards->cdr;
  2254.           free ((char *)dying);
  2255.         }
  2256.         break;
  2257.       }
  2258.     default:
  2259.       break;
  2260.     }
  2261.       e = e->next;
  2262.     }
  2263.   node->mark = 0;
  2264.   return 1;
  2265. }
  2266.  
  2267.  
  2268. #ifdef __STDC__
  2269. RX_DECL int 
  2270. rx_eclose_nfa (struct rx *rx)
  2271. #else
  2272. RX_DECL int 
  2273. rx_eclose_nfa (rx)
  2274.      struct rx *rx;
  2275. #endif
  2276. {
  2277.   struct rx_nfa_state *n = rx->nfa_states;
  2278.   struct eclose_frame frame;
  2279.   static int rx_id = 0;
  2280.   
  2281.   frame.prog_backwards = 0;
  2282.   rx->rx_id = rx_id++;
  2283.   bzero (&rx->se_list_memo, sizeof (rx->se_list_memo));
  2284.   bzero (&rx->set_list_memo, sizeof (rx->set_list_memo));
  2285.   while (n)
  2286.     {
  2287.       n->futures = 0;
  2288.       if (n->eclosure_needed && !eclose_node (rx, n, n, &frame))
  2289.     return 0;
  2290.       /* clear_marks (rx); */
  2291.       n = n->next;
  2292.     }
  2293.   return 1;
  2294. }
  2295.  
  2296.  
  2297. /* This deletes epsilon edges from an NFA.  After running eclose_node,
  2298.  * we have no more need for these edges.  They are removed to simplify
  2299.  * further operations on the NFA.
  2300.  */
  2301.  
  2302. #ifdef __STDC__
  2303. RX_DECL void 
  2304. rx_delete_epsilon_transitions (struct rx *rx)
  2305. #else
  2306. RX_DECL void 
  2307. rx_delete_epsilon_transitions (rx)
  2308.      struct rx *rx;
  2309. #endif
  2310. {
  2311.   struct rx_nfa_state *n = rx->nfa_states;
  2312.   struct rx_nfa_edge **e;
  2313.  
  2314.   while (n)
  2315.     {
  2316.       e = &n->edges;
  2317.       while (*e)
  2318.     {
  2319.       struct rx_nfa_edge *t;
  2320.       switch ((*e)->type)
  2321.         {
  2322.         case ne_epsilon:
  2323.         case ne_side_effect:
  2324.           t = *e;
  2325.           *e = t->next;
  2326.           rx_free_nfa_edge (t);
  2327.           break;
  2328.  
  2329.         default:
  2330.           e = &(*e)->next;
  2331.           break;
  2332.         }
  2333.     }
  2334.       n = n->next;
  2335.     }
  2336. }
  2337.  
  2338.  
  2339. /* This page: storing the nfa in a contiguous region of memory for
  2340.  * subsequent conversion to a super-nfa.
  2341.  */
  2342.  
  2343.  
  2344. /* This is for qsort on an array of nfa_states. The order
  2345.  * is based on state ids and goes 
  2346.  *        [0...MAX][MIN..-1] where (MAX>=0) and (MIN<0)
  2347.  * This way, positive ids double as array indices.
  2348.  */
  2349.  
  2350. #ifdef __STDC__
  2351. static int 
  2352. nfacmp (void * va, void * vb)
  2353. #else
  2354. static int 
  2355. nfacmp (va, vb)
  2356.      void * va;
  2357.      void * vb;
  2358. #endif
  2359. {
  2360.   struct rx_nfa_state **a = (struct rx_nfa_state **)va;
  2361.   struct rx_nfa_state **b = (struct rx_nfa_state **)vb;
  2362.   return (*a == *b        /* &&&& 3.18 */
  2363.       ? 0
  2364.       : (((*a)->id < 0) == ((*b)->id < 0)
  2365.          ? (((*a)->id  < (*b)->id) ? -1 : 1)
  2366.          : (((*a)->id < 0)
  2367.         ? 1 : -1)));
  2368. }
  2369.  
  2370. #ifdef __STDC__
  2371. static int 
  2372. count_hash_nodes (struct rx_hash * st)
  2373. #else
  2374. static int 
  2375. count_hash_nodes (st)
  2376.      struct rx_hash * st;
  2377. #endif
  2378. {
  2379.   int x;
  2380.   int count = 0;
  2381.   for (x = 0; x < 13; ++x)
  2382.     count += ((st->children[x])
  2383.           ? count_hash_nodes (st->children[x])
  2384.           : st->bucket_size[x]);
  2385.   
  2386.   return count;
  2387. }
  2388.  
  2389.  
  2390. #ifdef __STDC__
  2391. static void 
  2392. se_memo_freer (struct rx_hash_item * node)
  2393. #else
  2394. static void 
  2395. se_memo_freer (node)
  2396.      struct rx_hash_item * node;
  2397. #endif
  2398. {
  2399.   free ((char *)node->data);
  2400. }
  2401.  
  2402.  
  2403. #ifdef __STDC__
  2404. static void 
  2405. nfa_set_freer (struct rx_hash_item * node)
  2406. #else
  2407. static void 
  2408. nfa_set_freer (node)
  2409.      struct rx_hash_item * node;
  2410. #endif
  2411. {
  2412.   free ((char *)node->data);
  2413. }
  2414.  
  2415.  
  2416. /* This copies an entire NFA into a single malloced block of memory.
  2417.  * Mostly this is for compatability with regex.c, though it is convenient
  2418.  * to have the nfa nodes in an array.
  2419.  */
  2420.  
  2421. #ifdef __STDC__
  2422. RX_DECL int 
  2423. rx_compactify_nfa (struct rx *rx,
  2424.            void **mem, unsigned long *size)
  2425. #else
  2426. RX_DECL int 
  2427. rx_compactify_nfa (rx, mem, size)
  2428.      struct rx *rx;
  2429.      void **mem;
  2430.      unsigned long *size;
  2431. #endif
  2432. {
  2433.   int total_nodec;
  2434.   struct rx_nfa_state *n;
  2435.   int edgec = 0;
  2436.   int eclosec = 0;
  2437.   int se_list_consc = count_hash_nodes (&rx->se_list_memo);
  2438.   int nfa_setc = count_hash_nodes (&rx->set_list_memo);
  2439.   unsigned long total_size;
  2440.  
  2441.   /* This takes place in two stages.   First, the total size of the
  2442.    * nfa is computed, then structures are copied.  
  2443.    */   
  2444.   n = rx->nfa_states;
  2445.   total_nodec = 0;
  2446.   while (n)
  2447.     {
  2448.       struct rx_nfa_edge *e = n->edges;
  2449.       struct rx_possible_future *ec = n->futures;
  2450.       ++total_nodec;
  2451.       while (e)
  2452.     {
  2453.       ++edgec;
  2454.       e = e->next;
  2455.     }
  2456.       while (ec)
  2457.     {
  2458.       ++eclosec;
  2459.       ec = ec->next;
  2460.     }
  2461.       n = n->next;
  2462.     }
  2463.  
  2464.   total_size = (total_nodec * sizeof (struct rx_nfa_state)
  2465.         + edgec * rx_sizeof_bitset (rx->local_cset_size)
  2466.         + edgec * sizeof (struct rx_nfa_edge)
  2467.         + nfa_setc * sizeof (struct rx_nfa_state_set)
  2468.         + eclosec * sizeof (struct rx_possible_future)
  2469.         + se_list_consc * sizeof (struct rx_se_list)
  2470.         + rx->reserved);
  2471.  
  2472.   if (total_size > *size)
  2473.     {
  2474.       *mem = remalloc (*mem, total_size);
  2475.       if (*mem)
  2476.     *size = total_size;
  2477.       else
  2478.     return 0;
  2479.     }
  2480.   /* Now we've allocated the memory; this copies the NFA. */
  2481.   {
  2482.     static struct rx_nfa_state **scratch = 0;
  2483.     static int scratch_alloc = 0;
  2484.     struct rx_nfa_state *state_base = (struct rx_nfa_state *) * mem;
  2485.     struct rx_nfa_state *new_state = state_base;
  2486.     struct rx_nfa_edge *new_edge =
  2487.       (struct rx_nfa_edge *)
  2488.     ((char *) state_base + total_nodec * sizeof (struct rx_nfa_state));
  2489.     struct rx_se_list * new_se_list =
  2490.       (struct rx_se_list *)
  2491.     ((char *)new_edge + edgec * sizeof (struct rx_nfa_edge));
  2492.     struct rx_possible_future *new_close =
  2493.       ((struct rx_possible_future *)
  2494.        ((char *) new_se_list
  2495.     + se_list_consc * sizeof (struct rx_se_list)));
  2496.     struct rx_nfa_state_set * new_nfa_set =
  2497.       ((struct rx_nfa_state_set *)
  2498.        ((char *)new_close + eclosec * sizeof (struct rx_possible_future)));
  2499.     char *new_bitset =
  2500.       ((char *) new_nfa_set + nfa_setc * sizeof (struct rx_nfa_state_set));
  2501.     int x;
  2502.     struct rx_nfa_state *n;
  2503.  
  2504.     if (scratch_alloc < total_nodec)
  2505.       {
  2506.     scratch = ((struct rx_nfa_state **)
  2507.            remalloc (scratch, total_nodec * sizeof (*scratch)));
  2508.     if (scratch)
  2509.       scratch_alloc = total_nodec;
  2510.     else
  2511.       {
  2512.         scratch_alloc = 0;
  2513.         return 0;
  2514.       }
  2515.       }
  2516.  
  2517.     for (x = 0, n = rx->nfa_states; n; n = n->next)
  2518.       scratch[x++] = n;
  2519.  
  2520.     qsort (scratch, total_nodec,
  2521.        sizeof (struct rx_nfa_state *), (int (*)())nfacmp);
  2522.  
  2523.     for (x = 0; x < total_nodec; ++x)
  2524.       {
  2525.     struct rx_possible_future *eclose = scratch[x]->futures;
  2526.     struct rx_nfa_edge *edge = scratch[x]->edges;
  2527.     struct rx_nfa_state *cn = new_state++;
  2528.     cn->futures = 0;
  2529.     cn->edges = 0;
  2530.     cn->next = (x == total_nodec - 1) ? 0 : (cn + 1);
  2531.     cn->id = scratch[x]->id;
  2532.     cn->is_final = scratch[x]->is_final;
  2533.     cn->is_start = scratch[x]->is_start;
  2534.     cn->mark = 0;
  2535.     while (edge)
  2536.       {
  2537.         int indx = (edge->dest->id < 0
  2538.              ? (total_nodec + edge->dest->id)
  2539.              : edge->dest->id);
  2540.         struct rx_nfa_edge *e = new_edge++;
  2541.         rx_Bitset cset = (rx_Bitset) new_bitset;
  2542.         new_bitset += rx_sizeof_bitset (rx->local_cset_size);
  2543.         rx_bitset_null (rx->local_cset_size, cset);
  2544.         rx_bitset_union (rx->local_cset_size, cset, edge->params.cset);
  2545.         e->next = cn->edges;
  2546.         cn->edges = e;
  2547.         e->type = edge->type;
  2548.         e->dest = state_base + indx;
  2549.         e->params.cset = cset;
  2550.         edge = edge->next;
  2551.       }
  2552.     while (eclose)
  2553.       {
  2554.         struct rx_possible_future *ec = new_close++;
  2555.         struct rx_hash_item * sp;
  2556.         struct rx_se_list ** sepos;
  2557.         struct rx_se_list * sesrc;
  2558.         struct rx_nfa_state_set * destlst;
  2559.         struct rx_nfa_state_set ** destpos;
  2560.         ec->next = cn->futures;
  2561.         cn->futures = ec;
  2562.         for (sepos = &ec->effects, sesrc = eclose->effects;
  2563.          sesrc;
  2564.          sesrc = sesrc->cdr, sepos = &(*sepos)->cdr)
  2565.           {
  2566.         sp = rx_hash_find (&rx->se_list_memo,
  2567.                    (long)sesrc->car ^ (long)sesrc->cdr,
  2568.                    sesrc, &se_list_hash_rules);
  2569.         if (sp->binding)
  2570.           {
  2571.             sesrc = (struct rx_se_list *)sp->binding;
  2572.             break;
  2573.           }
  2574.         *new_se_list = *sesrc;
  2575.         sp->binding = (void *)new_se_list;
  2576.         *sepos = new_se_list;
  2577.         ++new_se_list;
  2578.           }
  2579.         *sepos = sesrc;
  2580.         for (destpos = &ec->destset, destlst = eclose->destset;
  2581.          destlst;
  2582.          destpos = &(*destpos)->cdr, destlst = destlst->cdr)
  2583.           {
  2584.         sp = rx_hash_find (&rx->set_list_memo,
  2585.                    ((((long)destlst->car) >> 8)
  2586.                     ^ (long)destlst->cdr),
  2587.                    destlst, &nfa_set_hash_rules);
  2588.         if (sp->binding)
  2589.           {
  2590.             destlst = (struct rx_nfa_state_set *)sp->binding;
  2591.             break;
  2592.           }
  2593.         *new_nfa_set = *destlst;
  2594.         new_nfa_set->car = state_base + destlst->car->id;
  2595.         sp->binding = (void *)new_nfa_set;
  2596.         *destpos = new_nfa_set;
  2597.         ++new_nfa_set;
  2598.           }
  2599.         *destpos = destlst;
  2600.         eclose = eclose->next;
  2601.       }
  2602.       }
  2603.   }
  2604.   rx_free_hash_table (&rx->se_list_memo, se_memo_freer, &se_list_hash_rules);
  2605.   bzero (&rx->se_list_memo, sizeof (rx->se_list_memo));
  2606.   rx_free_hash_table (&rx->set_list_memo, nfa_set_freer, &nfa_set_hash_rules);
  2607.   bzero (&rx->set_list_memo, sizeof (rx->set_list_memo));
  2608.  
  2609.   rx_free_nfa (rx);
  2610.   rx->nfa_states = (struct rx_nfa_state *)*mem;
  2611.   return 1;
  2612. }
  2613.  
  2614.  
  2615. /* The functions in the next several pages define the lazy-NFA-conversion used
  2616.  * by matchers.  The input to this construction is an NFA such as 
  2617.  * is built by compactify_nfa (rx.c).  The output is the superNFA.
  2618.  */
  2619.  
  2620.  
  2621. /* Match engines can use arbitrary values for opcodes.  So, the parse tree 
  2622.  * is built using instructions names (enum rx_opcode), but the superstate
  2623.  * nfa is populated with mystery opcodes (void *).
  2624.  *
  2625.  * For convenience, here is an id table.  The opcodes are == to their inxs
  2626.  *
  2627.  * The lables in re_search_2 would make good values for instructions.
  2628.  */
  2629.  
  2630. void * rx_id_instruction_table[rx_num_instructions] =
  2631. {
  2632.   (void *) rx_backtrack_point,
  2633.   (void *) rx_do_side_effects,
  2634.   (void *) rx_cache_miss,
  2635.   (void *) rx_next_char,
  2636.   (void *) rx_backtrack,
  2637.   (void *) rx_error_inx
  2638. };
  2639.  
  2640.  
  2641.  
  2642. /* Memory mgt. for superstate graphs. */
  2643.  
  2644. #ifdef __STDC__
  2645. static char *
  2646. rx_cache_malloc (struct rx_cache * cache, int bytes)
  2647. #else
  2648. static char *
  2649. rx_cache_malloc (cache, bytes)
  2650.      struct rx_cache * cache;
  2651.      int bytes;
  2652. #endif
  2653. {
  2654.   while (cache->bytes_left < bytes)
  2655.     {
  2656.       if (cache->memory_pos)
  2657.     cache->memory_pos = cache->memory_pos->next;
  2658.       if (!cache->memory_pos)
  2659.     {
  2660.       cache->morecore (cache);
  2661.       if (!cache->memory_pos)
  2662.         return 0;
  2663.     }
  2664.       cache->bytes_left = cache->memory_pos->bytes;
  2665.       cache->memory_addr = ((char *)cache->memory_pos
  2666.                 + sizeof (struct rx_blocklist));
  2667.     }
  2668.   cache->bytes_left -= bytes;
  2669.   {
  2670.     char * addr = cache->memory_addr;
  2671.     cache->memory_addr += bytes;
  2672.     return addr;
  2673.   }
  2674. }
  2675.  
  2676. #ifdef __STDC__
  2677. static void
  2678. rx_cache_free (struct rx_cache * cache,
  2679.            struct rx_freelist ** freelist, char * mem)
  2680. #else
  2681. static void
  2682. rx_cache_free (cache, freelist, mem)
  2683.      struct rx_cache * cache;
  2684.      struct rx_freelist ** freelist;
  2685.      char * mem;
  2686. #endif
  2687. {
  2688.   struct rx_freelist * it = (struct rx_freelist *)mem;
  2689.   it->next = *freelist;
  2690.   *freelist = it;
  2691. }
  2692.  
  2693.  
  2694. /* The partially instantiated superstate graph has a transition 
  2695.  * table at every node.  There is one entry for every character.
  2696.  * This fills in the transition for a set.
  2697.  */
  2698. #ifdef __STDC__
  2699. static void 
  2700. install_transition (struct rx_superstate *super,
  2701.             struct rx_inx *answer, rx_Bitset trcset) 
  2702. #else
  2703. static void 
  2704. install_transition (super, answer, trcset)
  2705.      struct rx_superstate *super;
  2706.      struct rx_inx *answer;
  2707.      rx_Bitset trcset;
  2708. #endif
  2709. {
  2710.   struct rx_inx * transitions = super->transitions;
  2711.   int chr;
  2712.   for (chr = 0; chr < 256; )
  2713.     if (!*trcset)
  2714.       {
  2715.     ++trcset;
  2716.     chr += 32;
  2717.       }
  2718.     else
  2719.       {
  2720.     RX_subset sub = *trcset;
  2721.     RX_subset mask = 1;
  2722.     int bound = chr + 32;
  2723.     while (chr < bound)
  2724.       {
  2725.         if (sub & mask)
  2726.           transitions [chr] = *answer;
  2727.         ++chr;
  2728.         mask <<= 1;
  2729.       }
  2730.     ++trcset;
  2731.       }
  2732. }
  2733.  
  2734.  
  2735. #if 1
  2736. static int
  2737. qlen (q)
  2738.      struct rx_superstate * q;
  2739. {
  2740.   int count = 1;
  2741.   struct rx_superstate * it;
  2742.   if (!q)
  2743.     return 0;
  2744.   for (it = q->next_recyclable; it != q; it = it->next_recyclable)
  2745.     ++count;
  2746.   return count;
  2747. }
  2748.  
  2749. static void
  2750. check_cache (cache)
  2751.      struct rx_cache * cache;
  2752. {
  2753.   struct rx_cache * you_fucked_up = 0;
  2754.   int total = cache->superstates;
  2755.   int semi = cache->semifree_superstates;
  2756.   if (semi != qlen (cache->semifree_superstate))
  2757.     check_cache (you_fucked_up);
  2758.   if ((total - semi) != qlen (cache->lru_superstate))
  2759.     check_cache (you_fucked_up);
  2760. }
  2761. #endif
  2762.  
  2763. #ifdef __STDC__
  2764. static void
  2765. semifree_superstate (struct rx_cache * cache)
  2766. #else
  2767. static void
  2768. semifree_superstate (cache)
  2769.      struct rx_cache * cache;
  2770. #endif
  2771. {
  2772.   int disqualified = cache->semifree_superstates;
  2773.   if (disqualified == cache->superstates)
  2774.     return;
  2775.   while (cache->lru_superstate->locks)
  2776.     {
  2777.       cache->lru_superstate = cache->lru_superstate->next_recyclable;
  2778.       ++disqualified;
  2779.       if (disqualified == cache->superstates)
  2780.     return;
  2781.     }
  2782.   {
  2783.     struct rx_superstate * it = cache->lru_superstate;
  2784.     it->next_recyclable->prev_recyclable = it->prev_recyclable;
  2785.     it->prev_recyclable->next_recyclable = it->next_recyclable;
  2786.     cache->lru_superstate = (it == it->next_recyclable
  2787.                  ? 0
  2788.                  : it->next_recyclable);
  2789.     if (!cache->semifree_superstate)
  2790.       {
  2791.     cache->semifree_superstate = it;
  2792.     it->next_recyclable = it;
  2793.     it->prev_recyclable = it;
  2794.       }
  2795.     else
  2796.       {
  2797.     it->prev_recyclable = cache->semifree_superstate->prev_recyclable;
  2798.     it->next_recyclable = cache->semifree_superstate;
  2799.     it->prev_recyclable->next_recyclable = it;
  2800.     it->next_recyclable->prev_recyclable = it;
  2801.       }
  2802.     {
  2803.       struct rx_distinct_future *df;
  2804.       it->is_semifree = 1;
  2805.       ++cache->semifree_superstates;
  2806.       df = it->transition_refs;
  2807.       if (df)
  2808.     {
  2809.       df->prev_same_dest->next_same_dest = 0;
  2810.       for (df = it->transition_refs; df; df = df->next_same_dest)
  2811.         {
  2812.           df->future_frame.inx = cache->instruction_table[rx_cache_miss];
  2813.           df->future_frame.data = 0;
  2814.           df->future_frame.data_2 = (void *) df;
  2815.           /* If there are any NEXT-CHAR instruction frames that
  2816.            * refer to this state, we convert them to CACHE-MISS frames.
  2817.            */
  2818.           if (!df->effects
  2819.           && (df->edge->options->next_same_super_edge[0]
  2820.               == df->edge->options))
  2821.         install_transition (df->present, &df->future_frame,
  2822.                     df->edge->cset);
  2823.         }
  2824.       df = it->transition_refs;
  2825.       df->prev_same_dest->next_same_dest = df;
  2826.     }
  2827.     }
  2828.   }
  2829. }
  2830.  
  2831.  
  2832. #ifdef __STDC__
  2833. static void 
  2834. refresh_semifree_superstate (struct rx_cache * cache,
  2835.                  struct rx_superstate * super)
  2836. #else
  2837. static void 
  2838. refresh_semifree_superstate (cache, super)
  2839.      struct rx_cache * cache;
  2840.      struct rx_superstate * super;
  2841. #endif
  2842. {
  2843.   struct rx_distinct_future *df;
  2844.  
  2845.   if (super->transition_refs)
  2846.     {
  2847.       super->transition_refs->prev_same_dest->next_same_dest = 0; 
  2848.       for (df = super->transition_refs; df; df = df->next_same_dest)
  2849.     {
  2850.       df->future_frame.inx = cache->instruction_table[rx_next_char];
  2851.       df->future_frame.data = (void *) super->transitions;
  2852.       /* CACHE-MISS instruction frames that refer to this state,
  2853.        * must be converted to NEXT-CHAR frames.
  2854.        */
  2855.       if (!df->effects
  2856.           && (df->edge->options->next_same_super_edge[0]
  2857.           == df->edge->options))
  2858.         install_transition (df->present, &df->future_frame,
  2859.                 df->edge->cset);
  2860.     }
  2861.       super->transition_refs->prev_same_dest->next_same_dest
  2862.     = super->transition_refs;
  2863.     }
  2864.   if (cache->semifree_superstate == super)
  2865.     cache->semifree_superstate = (super->prev_recyclable == super
  2866.                   ? 0
  2867.                   : super->prev_recyclable);
  2868.   super->next_recyclable->prev_recyclable = super->prev_recyclable;
  2869.   super->prev_recyclable->next_recyclable = super->next_recyclable;
  2870.  
  2871.   if (!cache->lru_superstate)
  2872.     (cache->lru_superstate
  2873.      = super->next_recyclable
  2874.      = super->prev_recyclable
  2875.      = super);
  2876.   else
  2877.     {
  2878.       super->next_recyclable = cache->lru_superstate;
  2879.       super->prev_recyclable = cache->lru_superstate->prev_recyclable;
  2880.       super->next_recyclable->prev_recyclable = super;
  2881.       super->prev_recyclable->next_recyclable = super;
  2882.     }
  2883.   super->is_semifree = 0;
  2884.   --cache->semifree_superstates;
  2885. }
  2886.  
  2887. #ifdef __STDC__
  2888. static void
  2889. rx_refresh_this_superstate (struct rx_cache * cache, struct rx_superstate * superstate)
  2890. #else
  2891. static void
  2892. rx_refresh_this_superstate (cache, superstate)
  2893.      struct rx_cache * cache;
  2894.      struct rx_superstate * superstate;
  2895. #endif
  2896. {
  2897.   if (superstate->is_semifree)
  2898.     refresh_semifree_superstate (cache, superstate);
  2899.   else if (cache->lru_superstate == superstate)
  2900.     cache->lru_superstate = superstate->next_recyclable;
  2901.   else if (superstate != cache->lru_superstate->prev_recyclable)
  2902.     {
  2903.       superstate->next_recyclable->prev_recyclable
  2904.     = superstate->prev_recyclable;
  2905.       superstate->prev_recyclable->next_recyclable
  2906.     = superstate->next_recyclable;
  2907.       superstate->next_recyclable = cache->lru_superstate;
  2908.       superstate->prev_recyclable = cache->lru_superstate->prev_recyclable;
  2909.       superstate->next_recyclable->prev_recyclable = superstate;
  2910.       superstate->prev_recyclable->next_recyclable = superstate;
  2911.     }
  2912. }
  2913.  
  2914. #ifdef __STDC__
  2915. static void 
  2916. release_superset_low (struct rx_cache * cache,
  2917.              struct rx_superset *set)
  2918. #else
  2919. static void 
  2920. release_superset_low (cache, set)
  2921.      struct rx_cache * cache;
  2922.      struct rx_superset *set;
  2923. #endif
  2924. {
  2925.   if (!--set->refs)
  2926.     {
  2927.       if (set->cdr)
  2928.     release_superset_low (cache, set->cdr);
  2929.  
  2930.       set->starts_for = 0;
  2931.  
  2932.       rx_hash_free
  2933.     (rx_hash_find
  2934.      (&cache->superset_table,
  2935.       (unsigned long)set->car ^ set->id ^ (unsigned long)set->cdr,
  2936.       (void *)set,
  2937.       &cache->superset_hash_rules),
  2938.      &cache->superset_hash_rules);
  2939.       rx_cache_free (cache, &cache->free_supersets, (char *)set);
  2940.     }
  2941. }
  2942.  
  2943. #ifdef __STDC__
  2944. RX_DECL void 
  2945. rx_release_superset (struct rx *rx,
  2946.              struct rx_superset *set)
  2947. #else
  2948. RX_DECL void 
  2949. rx_release_superset (rx, set)
  2950.      struct rx *rx;
  2951.      struct rx_superset *set;
  2952. #endif
  2953. {
  2954.   release_superset_low (rx->cache, set);
  2955. }
  2956.  
  2957. /* This tries to add a new superstate to the superstate freelist.
  2958.  * It might, as a result, free some edge pieces or hash tables.
  2959.  * If nothing can be freed because too many locks are being held, fail.
  2960.  */
  2961.  
  2962. #ifdef __STDC__
  2963. static int
  2964. rx_really_free_superstate (struct rx_cache * cache)
  2965. #else
  2966. static int
  2967. rx_really_free_superstate (cache)
  2968.      struct rx_cache * cache;
  2969. #endif
  2970. {
  2971.   int locked_superstates = 0;
  2972.   struct rx_superstate * it;
  2973.  
  2974.   if (!cache->superstates)
  2975.     return 0;
  2976.  
  2977.   {
  2978.     /* This is a total guess.  The idea is that we should expect as
  2979.      * many misses as we've recently experienced.  I.e., cache->misses
  2980.      * should be the same as cache->semifree_superstates.
  2981.      */
  2982.     while ((cache->hits + cache->misses) > cache->superstates_allowed)
  2983.       {
  2984.     cache->hits >>= 1;
  2985.     cache->misses >>= 1;
  2986.       }
  2987.     if (  ((cache->hits + cache->misses) * cache->semifree_superstates)
  2988.     < (cache->superstates         * cache->misses))
  2989.       {
  2990.     semifree_superstate (cache);
  2991.     semifree_superstate (cache);
  2992.       }
  2993.   }
  2994.  
  2995.   while (cache->semifree_superstate && cache->semifree_superstate->locks)
  2996.     {
  2997.       refresh_semifree_superstate (cache, cache->semifree_superstate);
  2998.       ++locked_superstates;
  2999.       if (locked_superstates == cache->superstates)
  3000.     return 0;
  3001.     }
  3002.  
  3003.   if (cache->semifree_superstate)
  3004.     {
  3005.       it = cache->semifree_superstate;
  3006.       it->next_recyclable->prev_recyclable = it->prev_recyclable;
  3007.       it->prev_recyclable->next_recyclable = it->next_recyclable;
  3008.       cache->semifree_superstate = ((it == it->next_recyclable)
  3009.                     ? 0
  3010.                     : it->next_recyclable);
  3011.       --cache->semifree_superstates;
  3012.     }
  3013.   else
  3014.     {
  3015.       while (cache->lru_superstate->locks)
  3016.     {
  3017.       cache->lru_superstate = cache->lru_superstate->next_recyclable;
  3018.       ++locked_superstates;
  3019.       if (locked_superstates == cache->superstates)
  3020.         return 0;
  3021.     }
  3022.       it = cache->lru_superstate;
  3023.       it->next_recyclable->prev_recyclable = it->prev_recyclable;
  3024.       it->prev_recyclable->next_recyclable = it->next_recyclable;
  3025.       cache->lru_superstate = ((it == it->next_recyclable)
  3026.                     ? 0
  3027.                     : it->next_recyclable);
  3028.     }
  3029.  
  3030.   if (it->transition_refs)
  3031.     {
  3032.       struct rx_distinct_future *df;
  3033.       for (df = it->transition_refs,
  3034.        df->prev_same_dest->next_same_dest = 0;
  3035.        df;
  3036.        df = df->next_same_dest)
  3037.     {
  3038.       df->future_frame.inx = cache->instruction_table[rx_cache_miss];
  3039.       df->future_frame.data = 0;
  3040.       df->future_frame.data_2 = (void *) df;
  3041.       df->future = 0;
  3042.     }
  3043.       it->transition_refs->prev_same_dest->next_same_dest =
  3044.     it->transition_refs;
  3045.     }
  3046.   {
  3047.     struct rx_super_edge *tc = it->edges;
  3048.     while (tc)
  3049.       {
  3050.     struct rx_distinct_future * df;
  3051.     struct rx_super_edge *tct = tc->next;
  3052.     df = tc->options;
  3053.     df->next_same_super_edge[1]->next_same_super_edge[0] = 0;
  3054.     while (df)
  3055.       {
  3056.         struct rx_distinct_future *dft = df;
  3057.         df = df->next_same_super_edge[0];
  3058.         
  3059.         
  3060.         if (dft->future && dft->future->transition_refs == dft)
  3061.           {
  3062.         dft->future->transition_refs = dft->next_same_dest;
  3063.         if (dft->future->transition_refs == dft)
  3064.           dft->future->transition_refs = 0;
  3065.           }
  3066.         dft->next_same_dest->prev_same_dest = dft->prev_same_dest;
  3067.         dft->prev_same_dest->next_same_dest = dft->next_same_dest;
  3068.         rx_cache_free (cache, &cache->free_discernable_futures,
  3069.                (char *)dft);
  3070.       }
  3071.     rx_cache_free (cache, &cache->free_transition_classes, (char *)tc);
  3072.     tc = tct;
  3073.       }
  3074.   }
  3075.   
  3076.   if (it->contents->superstate == it)
  3077.     it->contents->superstate = 0;
  3078.   release_superset_low (cache, it->contents);
  3079.   rx_cache_free (cache, &cache->free_superstates, (char *)it);
  3080.   --cache->superstates;
  3081.   return 1;
  3082. }
  3083.  
  3084. #ifdef __STDC__
  3085. static char *
  3086. rx_cache_get (struct rx_cache * cache,
  3087.           struct rx_freelist ** freelist)
  3088. #else
  3089. static char *
  3090. rx_cache_get (cache, freelist)
  3091.      struct rx_cache * cache;
  3092.      struct rx_freelist ** freelist;
  3093. #endif
  3094. {
  3095.   while (!*freelist && rx_really_free_superstate (cache))
  3096.     ;
  3097.   if (!*freelist)
  3098.     return 0;
  3099.   {
  3100.     struct rx_freelist * it = *freelist;
  3101.     *freelist = it->next;
  3102.     return (char *)it;
  3103.   }
  3104. }
  3105.  
  3106. #ifdef __STDC__
  3107. static char *
  3108. rx_cache_malloc_or_get (struct rx_cache * cache,
  3109.             struct rx_freelist ** freelist, int bytes)
  3110. #else
  3111. static char *
  3112. rx_cache_malloc_or_get (cache, freelist, bytes)
  3113.      struct rx_cache * cache;
  3114.      struct rx_freelist ** freelist;
  3115.      int bytes;
  3116. #endif
  3117. {
  3118.   if (!*freelist)
  3119.     {
  3120.       char * answer = rx_cache_malloc (cache, bytes);
  3121.       if (answer)
  3122.     return answer;
  3123.     }
  3124.  
  3125.   return rx_cache_get (cache, freelist);
  3126. }
  3127.  
  3128. #ifdef __STDC__
  3129. static char *
  3130. rx_cache_get_superstate (struct rx_cache * cache)
  3131. #else
  3132. static char *
  3133. rx_cache_get_superstate (cache)
  3134.       struct rx_cache * cache;
  3135. #endif
  3136. {
  3137.   char * answer;
  3138.   int bytes = (   sizeof (struct rx_superstate)
  3139.            +  cache->local_cset_size * sizeof (struct rx_inx));
  3140.   if (!cache->free_superstates
  3141.       && (cache->superstates < cache->superstates_allowed))
  3142.     {
  3143.       answer = rx_cache_malloc (cache, bytes);
  3144.       if (answer)
  3145.     {
  3146.       ++cache->superstates;
  3147.       return answer;
  3148.     }
  3149.     }
  3150.   answer = rx_cache_get (cache, &cache->free_superstates);
  3151.   if (!answer)
  3152.     {
  3153.       answer = rx_cache_malloc (cache, bytes);
  3154.       if (answer)
  3155.     ++cache->superstates_allowed;
  3156.     }
  3157.   ++cache->superstates;
  3158.   return answer;
  3159. }
  3160.  
  3161.  
  3162.  
  3163. static int
  3164. supersetcmp (va, vb)
  3165.      void * va;
  3166.      void * vb;
  3167. {
  3168.   struct rx_superset * a = (struct rx_superset *)va;
  3169.   struct rx_superset * b = (struct rx_superset *)vb;
  3170.   return (   (a == b)
  3171.       || (a && b && (a->car == b->car) && (a->cdr == b->cdr)));
  3172. }
  3173.  
  3174.  
  3175. #ifdef __STDC__
  3176. static struct rx_hash_item *
  3177. superset_allocator (struct rx_hash_rules * rules, void * val)
  3178. #else
  3179. static struct rx_hash_item *
  3180. superset_allocator (rules, val)
  3181.      struct rx_hash_rules * rules;
  3182.      void * val;
  3183. #endif
  3184. {
  3185.   struct rx_cache * cache
  3186.     = ((struct rx_cache *)
  3187.        ((char *)rules
  3188.     - (unsigned long)(&((struct rx_cache *)0)->superset_hash_rules)));
  3189.   struct rx_superset * template = (struct rx_superset *)val;
  3190.   struct rx_superset * newset
  3191.     = ((struct rx_superset *)
  3192.        rx_cache_malloc_or_get (cache,
  3193.                    &cache->free_supersets,
  3194.                    sizeof (*template)));
  3195.   if (!newset)
  3196.     return 0;
  3197.   newset->refs = 0;
  3198.   newset->car = template->car;
  3199.   newset->id = template->car->id;
  3200.   newset->cdr = template->cdr;
  3201.   newset->superstate = 0;
  3202.   rx_protect_superset (rx, template->cdr);
  3203.   newset->hash_item.data = (void *)newset;
  3204.   newset->hash_item.binding = 0;
  3205.   return &newset->hash_item;
  3206. }
  3207.  
  3208. #ifdef __STDC__
  3209. static struct rx_hash * 
  3210. super_hash_allocator (struct rx_hash_rules * rules)
  3211. #else
  3212. static struct rx_hash * 
  3213. super_hash_allocator (rules)
  3214.      struct rx_hash_rules * rules;
  3215. #endif
  3216. {
  3217.   struct rx_cache * cache
  3218.     = ((struct rx_cache *)
  3219.        ((char *)rules
  3220.     - (unsigned long)(&((struct rx_cache *)0)->superset_hash_rules)));
  3221.   return ((struct rx_hash *)
  3222.       rx_cache_malloc_or_get (cache,
  3223.                   &cache->free_hash, sizeof (struct rx_hash)));
  3224. }
  3225.  
  3226.  
  3227. #ifdef __STDC__
  3228. static void
  3229. super_hash_liberator (struct rx_hash * hash, struct rx_hash_rules * rules)
  3230. #else
  3231. static void
  3232. super_hash_liberator (hash, rules)
  3233.      struct rx_hash * hash;
  3234.      struct rx_hash_rules * rules;
  3235. #endif
  3236. {
  3237.   struct rx_cache * cache
  3238.     = ((struct rx_cache *)
  3239.        (char *)rules - (long)(&((struct rx_cache *)0)->superset_hash_rules));
  3240.   rx_cache_free (cache, &cache->free_hash, (char *)hash);
  3241. }
  3242.  
  3243. #ifdef __STDC__
  3244. static void
  3245. superset_hash_item_liberator (struct rx_hash_item * it,
  3246.                   struct rx_hash_rules * rules)
  3247. #else
  3248. static void
  3249. superset_hash_item_liberator (it, rules) /* Well, it does ya know. */
  3250.      struct rx_hash_item * it;
  3251.      struct rx_hash_rules * rules;
  3252. #endif
  3253. {
  3254. }
  3255.  
  3256. int rx_cache_bound = 128;
  3257. static int rx_default_cache_got = 0;
  3258.  
  3259. #ifdef __STDC__
  3260. static int
  3261. bytes_for_cache_size (int supers, int cset_size)
  3262. #else
  3263. static int
  3264. bytes_for_cache_size (supers, cset_size)
  3265.      int supers;
  3266.      int cset_size;
  3267. #endif
  3268. {
  3269.   return (int)
  3270.     ((float)supers *
  3271.      (  (1.03 * (float) (  rx_sizeof_bitset (cset_size)
  3272.              + sizeof (struct rx_super_edge)))
  3273.       + (1.80 * (float) sizeof (struct rx_possible_future))
  3274.       + (float) (  sizeof (struct rx_superstate)
  3275.          + cset_size * sizeof (struct rx_inx))));
  3276. }
  3277.  
  3278. #ifdef __STDC__
  3279. static void
  3280. rx_morecore (struct rx_cache * cache)
  3281. #else
  3282. static void
  3283. rx_morecore (cache)
  3284.      struct rx_cache * cache;
  3285. #endif
  3286. {
  3287.   if (rx_default_cache_got >= rx_cache_bound)
  3288.     return;
  3289.  
  3290.   rx_default_cache_got += 16;
  3291.   cache->superstates_allowed = rx_cache_bound;
  3292.   {
  3293.     struct rx_blocklist ** pos = &cache->memory;
  3294.     int size = bytes_for_cache_size (16, cache->local_cset_size);
  3295.     while (*pos)
  3296.       pos = &(*pos)->next;
  3297.     *pos = ((struct rx_blocklist *)
  3298.         malloc (size + sizeof (struct rx_blocklist))); 
  3299.     if (!*pos)
  3300.       return;
  3301.  
  3302.     (*pos)->next = 0;
  3303.     (*pos)->bytes = size;
  3304.     cache->memory_pos = *pos;
  3305.     cache->memory_addr = (char *)*pos + sizeof (**pos);
  3306.     cache->bytes_left = size;
  3307.   }
  3308. }
  3309.  
  3310. static struct rx_cache default_cache = 
  3311. {
  3312.   {
  3313.     supersetcmp,
  3314.     super_hash_allocator,
  3315.     super_hash_liberator,
  3316.     superset_allocator,
  3317.     superset_hash_item_liberator,
  3318.   },
  3319.   0,
  3320.   0,
  3321.   0,
  3322.   0,
  3323.   rx_morecore,
  3324.  
  3325.   0,
  3326.   0,
  3327.   0,
  3328.   0,
  3329.   0,
  3330.  
  3331.   0,
  3332.   0,
  3333.  
  3334.   0,
  3335.  
  3336.   0,
  3337.   0,
  3338.   0,
  3339.   0,
  3340.   128,
  3341.  
  3342.   256,
  3343.   rx_id_instruction_table,
  3344.  
  3345.   {
  3346.     0,
  3347.     0,
  3348.     {0},
  3349.     {0},
  3350.     {0}
  3351.   }
  3352. };
  3353.  
  3354. /* This adds an element to a superstate set.  These sets are lists, such
  3355.  * that lists with == elements are ==.  The empty set is returned by
  3356.  * superset_cons (rx, 0, 0) and is NOT equivelent to 
  3357.  * (struct rx_superset)0.
  3358.  */
  3359.  
  3360. #ifdef __STDC__
  3361. RX_DECL struct rx_superset *
  3362. rx_superset_cons (struct rx * rx,
  3363.           struct rx_nfa_state *car, struct rx_superset *cdr)
  3364. #else
  3365. RX_DECL struct rx_superset *
  3366. rx_superset_cons (rx, car, cdr)
  3367.      struct rx * rx;
  3368.      struct rx_nfa_state *car;
  3369.      struct rx_superset *cdr;
  3370. #endif
  3371. {
  3372.   struct rx_cache * cache = rx->cache;
  3373.   if (!car && !cdr)
  3374.     {
  3375.       if (!cache->empty_superset)
  3376.     {
  3377.       cache->empty_superset
  3378.         = ((struct rx_superset *)
  3379.            rx_cache_malloc_or_get (cache, &cache->free_supersets,
  3380.                        sizeof (struct rx_superset)));
  3381.       if (!cache->empty_superset)
  3382.         return 0;
  3383.       bzero (cache->empty_superset, sizeof (struct rx_superset));
  3384.       cache->empty_superset->refs = 1000;
  3385.     }
  3386.       return cache->empty_superset;
  3387.     }
  3388.   {
  3389.     struct rx_superset template;
  3390.     struct rx_hash_item * hit;
  3391.     template.car = car;
  3392.     template.cdr = cdr;
  3393.     template.id = car->id;
  3394.     hit = rx_hash_store (&cache->superset_table,
  3395.              (unsigned long)car ^ car->id ^ (unsigned long)cdr,
  3396.              (void *)&template,
  3397.              &cache->superset_hash_rules);
  3398.     return (hit
  3399.         ?  (struct rx_superset *)hit->data
  3400.         : 0);
  3401.   }
  3402. }
  3403.  
  3404. /* This computes a union of two NFA state sets.  The sets do not have the
  3405.  * same representation though.  One is a RX_SUPERSET structure (part
  3406.  * of the superstate NFA) and the other is an NFA_STATE_SET (part of the NFA).
  3407.  */
  3408.  
  3409. #ifdef __STDC__
  3410. RX_DECL struct rx_superset *
  3411. rx_superstate_eclosure_union
  3412.   (struct rx * rx, struct rx_superset *set, struct rx_nfa_state_set *ecl) 
  3413. #else
  3414. RX_DECL struct rx_superset *
  3415. rx_superstate_eclosure_union (rx, set, ecl)
  3416.      struct rx * rx;
  3417.      struct rx_superset *set;
  3418.      struct rx_nfa_state_set *ecl;
  3419. #endif
  3420. {
  3421.   if (!ecl)
  3422.     return set;
  3423.  
  3424.   if (!set->car)
  3425.     return rx_superset_cons (rx, ecl->car,
  3426.                  rx_superstate_eclosure_union (rx, set, ecl->cdr));
  3427.   if (set->car == ecl->car)
  3428.     return rx_superstate_eclosure_union (rx, set, ecl->cdr);
  3429.  
  3430.   {
  3431.     struct rx_superset * tail;
  3432.     struct rx_nfa_state * first;
  3433.  
  3434.     if (set->car > ecl->car)
  3435.       {
  3436.     tail = rx_superstate_eclosure_union (rx, set->cdr, ecl);
  3437.     first = set->car;
  3438.       }
  3439.     else
  3440.       {
  3441.     tail = rx_superstate_eclosure_union (rx, set, ecl->cdr);
  3442.     first = ecl->car;
  3443.       }
  3444.     if (!tail)
  3445.       return 0;
  3446.     else
  3447.       {
  3448.     struct rx_superset * answer;
  3449.     answer = rx_superset_cons (rx, first, tail);
  3450.     if (!answer)
  3451.       {
  3452.         rx_protect_superset (rx, tail);
  3453.         rx_release_superset (rx, tail);
  3454.       }
  3455.     return answer;
  3456.       }
  3457.   }
  3458. }
  3459.  
  3460.  
  3461.  
  3462.  
  3463. /*
  3464.  * This makes sure that a list of rx_distinct_futures contains
  3465.  * a future for each possible set of side effects in the eclosure
  3466.  * of a given state.  This is some of the work of filling in a
  3467.  * superstate transition. 
  3468.  */
  3469.  
  3470. #ifdef __STDC__
  3471. static struct rx_distinct_future *
  3472. include_futures (struct rx *rx,
  3473.          struct rx_distinct_future *df, struct rx_nfa_state
  3474.          *state, struct rx_superstate *superstate) 
  3475. #else
  3476. static struct rx_distinct_future *
  3477. include_futures (rx, df, state, superstate)
  3478.      struct rx *rx;
  3479.      struct rx_distinct_future *df;
  3480.      struct rx_nfa_state *state;
  3481.      struct rx_superstate *superstate;
  3482. #endif
  3483. {
  3484.   struct rx_possible_future *future;
  3485.   struct rx_cache * cache = rx->cache;
  3486.   for (future = state->futures; future; future = future->next)
  3487.     {
  3488.       struct rx_distinct_future *dfp;
  3489.       struct rx_distinct_future *insert_before = 0;
  3490.       if (df)
  3491.     df->next_same_super_edge[1]->next_same_super_edge[0] = 0;
  3492.       for (dfp = df; dfp; dfp = dfp->next_same_super_edge[0])
  3493.     if (dfp->effects == future->effects)
  3494.       break;
  3495.     else
  3496.       {
  3497.         int order = rx->se_list_cmp (rx, dfp->effects, future->effects);
  3498.         if (order > 0)
  3499.           {
  3500.         insert_before = dfp;
  3501.         dfp = 0;
  3502.         break;
  3503.           }
  3504.       }
  3505.       if (df)
  3506.     df->next_same_super_edge[1]->next_same_super_edge[0] = df;
  3507.       if (!dfp)
  3508.     {
  3509.       dfp
  3510.         = ((struct rx_distinct_future *)
  3511.            rx_cache_malloc_or_get (cache, &cache->free_discernable_futures,
  3512.                        sizeof (struct rx_distinct_future)));
  3513.       if (!dfp)
  3514.         return 0;
  3515.       if (!df)
  3516.         {
  3517.           df = insert_before = dfp;
  3518.           df->next_same_super_edge[0] = df->next_same_super_edge[1] = df;
  3519.         }
  3520.       else if (!insert_before)
  3521.         insert_before = df;
  3522.       else if (insert_before == df)
  3523.         df = dfp;
  3524.  
  3525.       dfp->next_same_super_edge[0] = insert_before;
  3526.       dfp->next_same_super_edge[1]
  3527.         = insert_before->next_same_super_edge[1];
  3528.       dfp->next_same_super_edge[1]->next_same_super_edge[0] = dfp;
  3529.       dfp->next_same_super_edge[0]->next_same_super_edge[1] = dfp;
  3530.       dfp->next_same_dest = dfp->prev_same_dest = dfp;
  3531.       dfp->future = 0;
  3532.       dfp->present = superstate;
  3533.       dfp->future_frame.inx = rx->instruction_table[rx_cache_miss];
  3534.       dfp->future_frame.data = 0;
  3535.       dfp->future_frame.data_2 = (void *) dfp;
  3536.       dfp->side_effects_frame.inx
  3537.         = rx->instruction_table[rx_do_side_effects];
  3538.       dfp->side_effects_frame.data = 0;
  3539.       dfp->side_effects_frame.data_2 = (void *) dfp;
  3540.       dfp->effects = future->effects;
  3541.     }
  3542.     }
  3543.   return df;
  3544. }
  3545.  
  3546.  
  3547.  
  3548.  
  3549. /* This constructs a new superstate from its state set.  The only 
  3550.  * complexity here is memory management.
  3551.  */
  3552. #ifdef __STDC__
  3553. RX_DECL struct rx_superstate *
  3554. rx_superstate (struct rx *rx,
  3555.            struct rx_superset *set)
  3556. #else
  3557. RX_DECL struct rx_superstate *
  3558. rx_superstate (rx, set)
  3559.      struct rx *rx;
  3560.      struct rx_superset *set;
  3561. #endif
  3562. {
  3563.   struct rx_cache * cache = rx->cache;
  3564.   struct rx_superstate * superstate = 0;
  3565.  
  3566.   /* Does the superstate already exist in the cache? */
  3567.   if (set->superstate)
  3568.     {
  3569.       if (set->superstate->rx_id != rx->rx_id)
  3570.     {
  3571.       /* Aha.  It is in the cache, but belongs to a superstate
  3572.        * that refers to an NFA that no longer exists.
  3573.        * (We know it no longer exists because it was evidently
  3574.        *  stored in the same region of memory as the current nfa
  3575.        *  yet it has a different id.)
  3576.        */
  3577.       superstate = set->superstate;
  3578.       if (!superstate->is_semifree)
  3579.         {
  3580.           if (cache->lru_superstate == superstate)
  3581.         {
  3582.           cache->lru_superstate = superstate->next_recyclable;
  3583.           if (cache->lru_superstate == superstate)
  3584.             cache->lru_superstate = 0;
  3585.         }
  3586.           {
  3587.         superstate->next_recyclable->prev_recyclable
  3588.           = superstate->prev_recyclable;
  3589.         superstate->prev_recyclable->next_recyclable
  3590.           = superstate->next_recyclable;
  3591.         if (!cache->semifree_superstate)
  3592.           {
  3593.             (cache->semifree_superstate
  3594.              = superstate->next_recyclable
  3595.              = superstate->prev_recyclable
  3596.              = superstate);
  3597.           }
  3598.         else
  3599.           {
  3600.             superstate->next_recyclable = cache->semifree_superstate;
  3601.             superstate->prev_recyclable
  3602.               = cache->semifree_superstate->prev_recyclable;
  3603.             superstate->next_recyclable->prev_recyclable
  3604.               = superstate;
  3605.             superstate->prev_recyclable->next_recyclable
  3606.               = superstate;
  3607.             cache->semifree_superstate = superstate;
  3608.           }
  3609.         ++cache->semifree_superstates;
  3610.           }
  3611.         }
  3612.       set->superstate = 0;
  3613.       goto handle_cache_miss;
  3614.     }
  3615.       ++cache->hits;
  3616.       superstate = set->superstate;
  3617.  
  3618.       rx_refresh_this_superstate (cache, superstate);
  3619.       return superstate;
  3620.     }
  3621.  
  3622.  handle_cache_miss:
  3623.  
  3624.   /* This point reached only for cache misses. */
  3625.   ++cache->misses;
  3626. #if RX_DEBUG
  3627.   if (rx_debug_trace > 1)
  3628.     {
  3629.       struct rx_superset * setp = set;
  3630.       fprintf (stderr, "Building a superstet %d(%d): ", rx->rx_id, set);
  3631.       while (setp)
  3632.     {
  3633.       fprintf (stderr, "%d ", setp->id);
  3634.       setp = setp->cdr;
  3635.     }
  3636.       fprintf (stderr, "(%d)\n", set);
  3637.     }
  3638. #endif
  3639.   superstate = (struct rx_superstate *)rx_cache_get_superstate (cache);
  3640.   if (!superstate)
  3641.     return 0;
  3642.  
  3643.   if (!cache->lru_superstate)
  3644.     (cache->lru_superstate
  3645.      = superstate->next_recyclable
  3646.      = superstate->prev_recyclable
  3647.      = superstate);
  3648.   else
  3649.     {
  3650.       superstate->next_recyclable = cache->lru_superstate;
  3651.       superstate->prev_recyclable = cache->lru_superstate->prev_recyclable;
  3652.       (  superstate->prev_recyclable->next_recyclable
  3653.        = superstate->next_recyclable->prev_recyclable
  3654.        = superstate);
  3655.     }
  3656.   superstate->rx_id = rx->rx_id;
  3657.   superstate->transition_refs = 0;
  3658.   superstate->locks = 0;
  3659.   superstate->is_semifree = 0;
  3660.   set->superstate = superstate;
  3661.   superstate->contents = set;
  3662.   rx_protect_superset (rx, set);
  3663.   superstate->edges = 0;
  3664.   {
  3665.     int x;
  3666.     /* None of the transitions from this superstate are known yet. */
  3667.     for (x = 0; x < rx->local_cset_size; ++x) /* &&&&& 3.8 % */
  3668.       {
  3669.     struct rx_inx * ifr = &superstate->transitions[x];
  3670.     ifr->inx = rx->instruction_table [rx_cache_miss];
  3671.     ifr->data = ifr->data_2 = 0;
  3672.       }
  3673.   }
  3674.   return superstate;
  3675. }
  3676.  
  3677.  
  3678. /* This computes the destination set of one edge of the superstate NFA.
  3679.  * Note that a RX_DISTINCT_FUTURE is a superstate edge.
  3680.  * Returns 0 on an allocation failure.
  3681.  */
  3682.  
  3683. #ifdef __STDC__
  3684. static int 
  3685. solve_destination (struct rx *rx, struct rx_distinct_future *df)
  3686. #else
  3687. static int 
  3688. solve_destination (rx, df)
  3689.      struct rx *rx;
  3690.      struct rx_distinct_future *df;
  3691. #endif
  3692. {
  3693.   struct rx_super_edge *tc = df->edge;
  3694.   struct rx_superset *nfa_state;
  3695.   struct rx_superset *nil_set = rx_superset_cons (rx, 0, 0);
  3696.   struct rx_superset *solution = nil_set;
  3697.   struct rx_superstate *dest;
  3698.  
  3699.   rx_protect_superset (rx, solution);
  3700.   /* Iterate over all NFA states in the state set of this superstate. */
  3701.   for (nfa_state = df->present->contents;
  3702.        nfa_state->car;
  3703.        nfa_state = nfa_state->cdr)
  3704.     {
  3705.       struct rx_nfa_edge *e;
  3706.       /* Iterate over all edges of each NFA state. */
  3707.       for (e = nfa_state->car->edges; e; e = e->next)
  3708.         /* If we find an edge that is labeled with 
  3709.      * the characters we are solving for.....
  3710.      */
  3711.     if (rx_bitset_is_subset (rx->local_cset_size,
  3712.                  tc->cset, e->params.cset))
  3713.       {
  3714.         struct rx_nfa_state *n = e->dest;
  3715.         struct rx_possible_future *pf;
  3716.         /* ....search the partial epsilon closures of the destination
  3717.          * of that edge for a path that involves the same set of
  3718.          * side effects we are solving for.
  3719.          * If we find such a RX_POSSIBLE_FUTURE, we add members to the
  3720.          * stateset we are computing.
  3721.          */
  3722.         for (pf = n->futures; pf; pf = pf->next)
  3723.           if (pf->effects == df->effects)
  3724.         {
  3725.           struct rx_superset * old_sol;
  3726.           old_sol = solution;
  3727.           solution = rx_superstate_eclosure_union (rx, solution,
  3728.                                pf->destset);
  3729.           if (!solution)
  3730.             return 0;
  3731.           rx_protect_superset (rx, solution);
  3732.           rx_release_superset (rx, old_sol);
  3733.         }
  3734.       }
  3735.     }
  3736.   /* It is possible that the RX_DISTINCT_FUTURE we are working on has 
  3737.    * the empty set of NFA states as its definition.  In that case, this
  3738.    * is a failure point.
  3739.    */
  3740.   if (solution == nil_set)
  3741.     {
  3742.       df->future_frame.inx = (void *) rx_backtrack;
  3743.       df->future_frame.data = 0;
  3744.       df->future_frame.data_2 = 0;
  3745.       return 1;
  3746.     }
  3747.   dest = rx_superstate (rx, solution);
  3748.   rx_release_superset (rx, solution);
  3749.   if (!dest)
  3750.     return 0;
  3751.  
  3752.   {
  3753.     struct rx_distinct_future *dft;
  3754.     dft = df;
  3755.     df->prev_same_dest->next_same_dest = 0;
  3756.     while (dft)
  3757.       {
  3758.     dft->future = dest;
  3759.     dft->future_frame.inx = rx->instruction_table[rx_next_char];
  3760.     dft->future_frame.data = (void *) dest->transitions;
  3761.     dft = dft->next_same_dest;
  3762.       }
  3763.     df->prev_same_dest->next_same_dest = df;
  3764.   }
  3765.   if (!dest->transition_refs)
  3766.     dest->transition_refs = df;
  3767.   else
  3768.     {
  3769.       struct rx_distinct_future *dft = dest->transition_refs->next_same_dest;
  3770.       dest->transition_refs->next_same_dest = df->next_same_dest;
  3771.       df->next_same_dest->prev_same_dest = dest->transition_refs;
  3772.       df->next_same_dest = dft;
  3773.       dft->prev_same_dest = df;
  3774.     }
  3775.   return 1;
  3776. }
  3777.  
  3778.  
  3779. /* This takes a superstate and a character, and computes some edges
  3780.  * from the superstate NFA.  In particular, this computes all edges
  3781.  * that lead from SUPERSTATE given CHR.   This function also 
  3782.  * computes the set of characters that share this edge set.
  3783.  * This returns 0 on allocation error.
  3784.  * The character set and list of edges are returned through 
  3785.  * the paramters CSETOUT and DFOUT.
  3786. } */
  3787.  
  3788. #ifdef __STDC__
  3789. static int 
  3790. compute_super_edge (struct rx *rx, struct rx_distinct_future **dfout,
  3791.               rx_Bitset csetout, struct rx_superstate *superstate,
  3792.               unsigned char chr)  
  3793. #else
  3794. static int 
  3795. compute_super_edge (rx, dfout, csetout, superstate, chr)
  3796.      struct rx *rx;
  3797.      struct rx_distinct_future **dfout;
  3798.      rx_Bitset csetout;
  3799.      struct rx_superstate *superstate;
  3800.      unsigned char chr;
  3801. #endif
  3802. {
  3803.   struct rx_superset *stateset = superstate->contents;
  3804.  
  3805.   /* To compute the set of characters that share edges with CHR, 
  3806.    * we start with the full character set, and subtract.
  3807.    */
  3808.   rx_bitset_universe (rx->local_cset_size, csetout);
  3809.   *dfout = 0;
  3810.  
  3811.   /* Iterate over the NFA states in the superstate state-set. */
  3812.   while (stateset->car)
  3813.     {
  3814.       struct rx_nfa_edge *e;
  3815.       for (e = stateset->car->edges; e; e = e->next)
  3816.     if (RX_bitset_member (e->params.cset, chr))
  3817.       {
  3818.         /* If we find an NFA edge that applies, we make sure there
  3819.          * are corresponding edges in the superstate NFA.
  3820.          */
  3821.         {
  3822.           struct rx_distinct_future * saved;
  3823.           saved = *dfout;
  3824.           *dfout = include_futures (rx, *dfout, e->dest, superstate);
  3825.           if (!*dfout)
  3826.         {
  3827.           struct rx_distinct_future * df;
  3828.           df = saved;
  3829.           df->next_same_super_edge[1]->next_same_super_edge[0] = 0;
  3830.           while (df)
  3831.             {
  3832.               struct rx_distinct_future *dft;
  3833.               dft = df;
  3834.               df = df->next_same_super_edge[0];
  3835.  
  3836.               if (dft->future && dft->future->transition_refs == dft)
  3837.             {
  3838.               dft->future->transition_refs = dft->next_same_dest;
  3839.               if (dft->future->transition_refs == dft)
  3840.                 dft->future->transition_refs = 0;
  3841.             }
  3842.               dft->next_same_dest->prev_same_dest = dft->prev_same_dest;
  3843.               dft->prev_same_dest->next_same_dest = dft->next_same_dest;
  3844.               rx_cache_free (rx->cache,
  3845.                      &rx->cache->free_discernable_futures,
  3846.                      (char *)dft);
  3847.             }
  3848.           return 0;
  3849.         }
  3850.         }
  3851.         /* We also trim the character set a bit. */
  3852.         rx_bitset_intersection (rx->local_cset_size,
  3853.                     csetout, e->params.cset);
  3854.       }
  3855.     else
  3856.       /* An edge that doesn't apply at least tells us some characters
  3857.        * that don't share the same edge set as CHR.
  3858.        */
  3859.       rx_bitset_difference (rx->local_cset_size, csetout, e->params.cset);
  3860.       stateset = stateset->cdr;
  3861.     }
  3862.   return 1;
  3863. }
  3864.  
  3865.  
  3866. /* This is a constructor for RX_SUPER_EDGE structures.  These are
  3867.  * wrappers for lists of superstate NFA edges that share character sets labels.
  3868.  * If a transition class contains more than one rx_distinct_future (superstate
  3869.  * edge), then it represents a non-determinism in the superstate NFA.
  3870.  */
  3871.  
  3872. #ifdef __STDC__
  3873. static struct rx_super_edge *
  3874. rx_super_edge (struct rx *rx,
  3875.            struct rx_superstate *super, rx_Bitset cset,
  3876.            struct rx_distinct_future *df) 
  3877. #else
  3878. static struct rx_super_edge *
  3879. rx_super_edge (rx, super, cset, df)
  3880.      struct rx *rx;
  3881.      struct rx_superstate *super;
  3882.      rx_Bitset cset;
  3883.      struct rx_distinct_future *df;
  3884. #endif
  3885. {
  3886.   struct rx_super_edge *tc =
  3887.     (struct rx_super_edge *)rx_cache_malloc_or_get
  3888.       (rx->cache, &rx->cache->free_transition_classes,
  3889.        sizeof (struct rx_super_edge) + rx_sizeof_bitset (rx->local_cset_size));
  3890.  
  3891.   if (!tc)
  3892.     return 0;
  3893.   tc->next = super->edges;
  3894.   super->edges = tc;
  3895.   tc->rx_backtrack_frame.inx = rx->instruction_table[rx_backtrack_point];
  3896.   tc->rx_backtrack_frame.data = 0;
  3897.   tc->rx_backtrack_frame.data_2 = (void *) tc;
  3898.   tc->options = df;
  3899.   tc->cset = (rx_Bitset) ((char *) tc + sizeof (*tc));
  3900.   rx_bitset_assign (rx->local_cset_size, tc->cset, cset);
  3901.   if (df)
  3902.     {
  3903.       struct rx_distinct_future * dfp = df;
  3904.       df->next_same_super_edge[1]->next_same_super_edge[0] = 0;
  3905.       while (dfp)
  3906.     {
  3907.       dfp->edge = tc;
  3908.       dfp = dfp->next_same_super_edge[0];
  3909.     }
  3910.       df->next_same_super_edge[1]->next_same_super_edge[0] = df;
  3911.     }
  3912.   return tc;
  3913. }
  3914.  
  3915.  
  3916. /* There are three kinds of cache miss.  The first occurs when a
  3917.  * transition is taken that has never been computed during the
  3918.  * lifetime of the source superstate.  That cache miss is handled by
  3919.  * calling COMPUTE_SUPER_EDGE.  The second kind of cache miss
  3920.  * occurs when the destination superstate of a transition doesn't
  3921.  * exist.  SOLVE_DESTINATION is used to construct the destination superstate.
  3922.  * Finally, the third kind of cache miss occurs when the destination
  3923.  * superstate of a transition is in a `semi-free state'.  That case is
  3924.  * handled by UNFREE_SUPERSTATE.
  3925.  *
  3926.  * The function of HANDLE_CACHE_MISS is to figure out which of these
  3927.  * cases applies.
  3928.  */
  3929.  
  3930. #ifdef __STDC__
  3931. static void
  3932. install_partial_transition  (struct rx_superstate *super,
  3933.                  struct rx_inx *answer,
  3934.                  RX_subset set, int offset)
  3935. #else
  3936. static void
  3937. install_partial_transition  (super, answer, set, offset)
  3938.      struct rx_superstate *super;
  3939.      struct rx_inx *answer;
  3940.      RX_subset set;
  3941.      int offset;
  3942. #endif
  3943. {
  3944.   int start = offset;
  3945.   int end = start + 32;
  3946.   RX_subset pos = 1;
  3947.   struct rx_inx * transitions = super->transitions;
  3948.   
  3949.   while (start < end)
  3950.     {
  3951.       if (set & pos)
  3952.     transitions[start] = *answer;
  3953.       pos <<= 1;
  3954.       ++start;
  3955.     }
  3956. }
  3957.  
  3958.  
  3959. #ifdef __STDC__
  3960. RX_DECL struct rx_inx *
  3961. rx_handle_cache_miss
  3962.   (struct rx *rx, struct rx_superstate *super, unsigned char chr, void *data) 
  3963. #else
  3964. RX_DECL struct rx_inx *
  3965. rx_handle_cache_miss (rx, super, chr, data)
  3966.      struct rx *rx;
  3967.      struct rx_superstate *super;
  3968.      unsigned char chr;
  3969.      void *data;
  3970. #endif
  3971. {
  3972.   int offset = chr / RX_subset_bits;
  3973.   struct rx_distinct_future *df = data;
  3974.  
  3975.   if (!df)            /* must be the shared_cache_miss_frame */
  3976.     {
  3977.       /* Perhaps this is just a transition waiting to be filled. */
  3978.       struct rx_super_edge *tc;
  3979.       RX_subset mask = rx_subset_singletons [chr % RX_subset_bits];
  3980.  
  3981.       for (tc = super->edges; tc; tc = tc->next)
  3982.     if (tc->cset[offset] & mask)
  3983.       {
  3984.         struct rx_inx * answer;
  3985.         df = tc->options;
  3986.         answer = ((tc->options->next_same_super_edge[0] != tc->options)
  3987.               ? &tc->rx_backtrack_frame
  3988.               : (df->effects
  3989.              ? &df->side_effects_frame
  3990.              : &df->future_frame));
  3991.         install_partial_transition (super, answer,
  3992.                     tc->cset [offset], offset * 32);
  3993.         return answer;
  3994.       }
  3995.       /* Otherwise, it's a flushed or  newly encountered edge. */
  3996.       {
  3997.     char cset_space[1024];    /* this limit is far from unreasonable */
  3998.     rx_Bitset trcset;
  3999.     struct rx_inx *answer;
  4000.  
  4001.     if (rx_sizeof_bitset (rx->local_cset_size) > sizeof (cset_space))
  4002.       return 0;        /* If the arbitrary limit is hit, always fail */
  4003.                 /* cleanly. */
  4004.     trcset = (rx_Bitset)cset_space;
  4005.     rx_lock_superstate (rx, super);
  4006.     if (!compute_super_edge (rx, &df, trcset, super, chr))
  4007.       {
  4008.         rx_unlock_superstate (rx, super);
  4009.         return 0;
  4010.       }
  4011.     if (!df)        /* We just computed the fail transition. */
  4012.       {
  4013.         static struct rx_inx
  4014.           shared_fail_frame = { (void *)rx_backtrack, 0, 0 };
  4015.         answer = &shared_fail_frame;
  4016.       }
  4017.     else
  4018.       {
  4019.         tc = rx_super_edge (rx, super, trcset, df);
  4020.         if (!tc)
  4021.           {
  4022.         rx_unlock_superstate (rx, super);
  4023.         return 0;
  4024.           }
  4025.         answer = ((tc->options->next_same_super_edge[0] != tc->options)
  4026.               ? &tc->rx_backtrack_frame
  4027.               : (df->effects
  4028.              ? &df->side_effects_frame
  4029.              : &df->future_frame));
  4030.       }
  4031.     install_partial_transition (super, answer,
  4032.                     trcset[offset], offset * 32);
  4033.     rx_unlock_superstate (rx, super);
  4034.     return answer;
  4035.       }
  4036.     }
  4037.   else if (df->future) /* A cache miss on an edge with a future? Must be
  4038.             * a semi-free destination. */
  4039.     {                
  4040.       if (df->future->is_semifree)
  4041.     refresh_semifree_superstate (rx->cache, df->future);
  4042.       return &df->future_frame;
  4043.     }
  4044.   else
  4045.     /* no future superstate on an existing edge */
  4046.     {
  4047.       rx_lock_superstate (rx, super);
  4048.       if (!solve_destination (rx, df))
  4049.     {
  4050.       rx_unlock_superstate (rx, super);
  4051.       return 0;
  4052.     }
  4053.       if (!df->effects
  4054.       && (df->edge->options->next_same_super_edge[0] == df->edge->options))
  4055.     install_partial_transition (super, &df->future_frame,
  4056.                     df->edge->cset[offset], offset * 32);
  4057.       rx_unlock_superstate (rx, super);
  4058.       return &df->future_frame;
  4059.     }
  4060. }
  4061.  
  4062.  
  4063.  
  4064.  
  4065. /* The rest of the code provides a regex.c compatable interface. */
  4066.  
  4067.  
  4068. const char *re_error_msg[] =
  4069. {
  4070.   0,                        /* REG_NOUT */
  4071.   "No match",                    /* REG_NOMATCH */
  4072.   "Invalid regular expression",            /* REG_BADPAT */
  4073.   "Invalid collation character",        /* REG_ECOLLATE */
  4074.   "Invalid character class name",        /* REG_ECTYPE */
  4075.   "Trailing backslash",                /* REG_EESCAPE */
  4076.   "Invalid back reference",            /* REG_ESUBREG */
  4077.   "Unmatched [ or [^",                /* REG_EBRACK */
  4078.   "Unmatched ( or \\(",                /* REG_EPAREN */
  4079.   "Unmatched \\{",                /* REG_EBRACE */
  4080.   "Invalid content of \\{\\}",            /* REG_BADBR */
  4081.   "Invalid range end",                /* REG_ERANGE */
  4082.   "Memory exhausted",                /* REG_ESPACE */
  4083.   "Invalid preceding regular expression",    /* REG_BADRPT */
  4084.   "Premature end of regular expression",    /* REG_EEND */
  4085.   "Regular expression too big",            /* REG_ESIZE */
  4086.   "Unmatched ) or \\)",                /* REG_ERPAREN */
  4087. };
  4088.  
  4089.  
  4090.  
  4091. /* 
  4092.  * Macros used while compiling patterns.
  4093.  *
  4094.  * By convention, PEND points just past the end of the uncompiled pattern,
  4095.  * P points to the read position in the pattern.  `translate' is the name
  4096.  * of the translation table (`TRANSLATE' is the name of a macro that looks
  4097.  * things up in `translate').
  4098.  */
  4099.  
  4100.  
  4101. /*
  4102.  * Fetch the next character in the uncompiled pattern---translating it 
  4103.  * if necessary. *Also cast from a signed character in the constant
  4104.  * string passed to us by the user to an unsigned char that we can use
  4105.  * as an array index (in, e.g., `translate').
  4106.  */
  4107. #define PATFETCH(c)                            \
  4108.  do {if (p == pend) return REG_EEND;                    \
  4109.     c = (unsigned char) *p++;                        \
  4110.     c = translate[c];                             \
  4111.  } while (0)
  4112.  
  4113. /* 
  4114.  * Fetch the next character in the uncompiled pattern, with no
  4115.  * translation.
  4116.  */
  4117. #define PATFETCH_RAW(c)                            \
  4118.   do {if (p == pend) return REG_EEND;                    \
  4119.     c = (unsigned char) *p++;                         \
  4120.   } while (0)
  4121.  
  4122. /* Go backwards one character in the pattern.  */
  4123. #define PATUNFETCH p--
  4124.  
  4125.  
  4126. #define TRANSLATE(d) translate[(unsigned char) (d)]
  4127.  
  4128. typedef unsigned regnum_t;
  4129.  
  4130. /* Since offsets can go either forwards or backwards, this type needs to
  4131.  * be able to hold values from -(MAX_BUF_SIZE - 1) to MAX_BUF_SIZE - 1.
  4132.  */
  4133. typedef int pattern_offset_t;
  4134.  
  4135. typedef struct
  4136. {
  4137.   struct rexp_node ** top_expression; /* was begalt */
  4138.   struct rexp_node ** last_expression; /* was laststart */
  4139.   pattern_offset_t inner_group_offset;
  4140.   regnum_t regnum;
  4141. } compile_stack_elt_t;
  4142.  
  4143. typedef struct
  4144. {
  4145.   compile_stack_elt_t *stack;
  4146.   unsigned size;
  4147.   unsigned avail;            /* Offset of next open position.  */
  4148. } compile_stack_type;
  4149.  
  4150.  
  4151. #define INIT_COMPILE_STACK_SIZE 32
  4152.  
  4153. #define COMPILE_STACK_EMPTY  (compile_stack.avail == 0)
  4154. #define COMPILE_STACK_FULL  (compile_stack.avail == compile_stack.size)
  4155.  
  4156. /* The next available element.  */
  4157. #define COMPILE_STACK_TOP (compile_stack.stack[compile_stack.avail])
  4158.  
  4159.  
  4160. /* Set the bit for character C in a list.  */
  4161. #define SET_LIST_BIT(c)                               \
  4162.   (b[((unsigned char) (c)) / BYTEWIDTH]               \
  4163.    |= 1 << (((unsigned char) c) % BYTEWIDTH))
  4164.  
  4165. /* Get the next unsigned number in the uncompiled pattern.  */
  4166. #define GET_UNSIGNED_NUMBER(num)                     \
  4167.   { if (p != pend)                            \
  4168.      {                                    \
  4169.        PATFETCH (c);                             \
  4170.        while (isdigit (c))                         \
  4171.          {                                 \
  4172.            if (num < 0)                            \
  4173.               num = 0;                            \
  4174.            num = num * 10 + c - '0';                     \
  4175.            if (p == pend)                         \
  4176.               break;                             \
  4177.            PATFETCH (c);                        \
  4178.          }                                 \
  4179.        }                                 \
  4180.     }        
  4181.  
  4182. #define CHAR_CLASS_MAX_LENGTH  6 /* Namely, `xdigit'.  */
  4183.  
  4184. #define IS_CHAR_CLASS(string)                        \
  4185.    (!strcmp (string, "alpha") || !strcmp (string, "upper")        \
  4186.     || !strcmp (string, "lower") || !strcmp (string, "digit")        \
  4187.     || !strcmp (string, "alnum") || !strcmp (string, "xdigit")        \
  4188.     || !strcmp (string, "space") || !strcmp (string, "print")        \
  4189.     || !strcmp (string, "punct") || !strcmp (string, "graph")        \
  4190.     || !strcmp (string, "cntrl") || !strcmp (string, "blank"))
  4191.  
  4192.  
  4193. /* These predicates are used in regex_compile. */
  4194.  
  4195. /* P points to just after a ^ in PATTERN.  Return true if that ^ comes
  4196.  * after an alternative or a begin-subexpression.  We assume there is at
  4197.  * least one character before the ^.  
  4198.  */
  4199.  
  4200. #ifdef __STDC__
  4201. static boolean
  4202. at_begline_loc_p (const char *pattern, const char * p, reg_syntax_t syntax)
  4203. #else
  4204. static boolean
  4205. at_begline_loc_p (pattern, p, syntax)
  4206.      const char *pattern;
  4207.      const char * p;
  4208.      reg_syntax_t syntax;
  4209. #endif
  4210. {
  4211.   const char *prev = p - 2;
  4212.   boolean prev_prev_backslash = ((prev > pattern) && (prev[-1] == '\\'));
  4213.   
  4214.     return
  4215.       
  4216.       (/* After a subexpression?  */
  4217.        ((*prev == '(') && ((syntax & RE_NO_BK_PARENS) || prev_prev_backslash))
  4218.        ||
  4219.        /* After an alternative?  */
  4220.        ((*prev == '|') && ((syntax & RE_NO_BK_VBAR) || prev_prev_backslash))
  4221.        );
  4222. }
  4223.  
  4224. /* The dual of at_begline_loc_p.  This one is for $.  We assume there is
  4225.  * at least one character after the $, i.e., `P < PEND'.
  4226.  */
  4227.  
  4228. #ifdef __STDC__
  4229. static boolean
  4230. at_endline_loc_p (const char *p, const char *pend, int syntax)
  4231. #else
  4232. static boolean
  4233. at_endline_loc_p (p, pend, syntax)
  4234.      const char *p;
  4235.      const char *pend;
  4236.      int syntax;
  4237. #endif
  4238. {
  4239.   const char *next = p;
  4240.   boolean next_backslash = (*next == '\\');
  4241.   const char *next_next = (p + 1 < pend) ? (p + 1) : 0;
  4242.   
  4243.   return
  4244.     (
  4245.      /* Before a subexpression?  */
  4246.      ((syntax & RE_NO_BK_PARENS)
  4247.       ? (*next == ')')
  4248.       : (next_backslash && next_next && (*next_next == ')')))
  4249.     ||
  4250.      /* Before an alternative?  */
  4251.      ((syntax & RE_NO_BK_VBAR)
  4252.       ? (*next == '|')
  4253.       : (next_backslash && next_next && (*next_next == '|')))
  4254.      );
  4255. }
  4256.  
  4257.  
  4258. static unsigned char id_translation[256] =
  4259. {
  4260.   0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
  4261.  10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
  4262.  20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
  4263.  30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
  4264.  40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
  4265.  50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
  4266.  60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
  4267.  70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
  4268.  80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
  4269.  90, 91, 92, 93, 94, 95, 96, 97, 98, 99,
  4270.  
  4271.  100, 101, 102, 103, 104, 105, 106, 107, 108, 109,
  4272.  110, 111, 112, 113, 114, 115, 116, 117, 118, 119,
  4273.  120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
  4274.  130, 131, 132, 133, 134, 135, 136, 137, 138, 139,
  4275.  140, 141, 142, 143, 144, 145, 146, 147, 148, 149,
  4276.  150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
  4277.  160, 161, 162, 163, 164, 165, 166, 167, 168, 169,
  4278.  170, 171, 172, 173, 174, 175, 176, 177, 178, 179,
  4279.  180, 181, 182, 183, 184, 185, 186, 187, 188, 189,
  4280.  190, 191, 192, 193, 194, 195, 196, 197, 198, 199,
  4281.  
  4282.  200, 201, 202, 203, 204, 205, 206, 207, 208, 209,
  4283.  210, 211, 212, 213, 214, 215, 216, 217, 218, 219,
  4284.  220, 221, 222, 223, 224, 225, 226, 227, 228, 229,
  4285.  230, 231, 232, 233, 234, 235, 236, 237, 238, 239,
  4286.  240, 241, 242, 243, 244, 245, 246, 247, 248, 249,
  4287.  250, 251, 252, 253, 254, 255
  4288. };
  4289.  
  4290. /* The compiler keeps an inverted translation table.
  4291.  * This looks up/inititalize elements.
  4292.  * VALID is an array of booleans that validate CACHE.
  4293.  */
  4294.  
  4295. #ifdef __STDC__
  4296. static rx_Bitset
  4297. inverse_translation (struct re_pattern_buffer * rxb,
  4298.              char * valid, rx_Bitset cache,
  4299.              unsigned char * translate, int c)
  4300. #else
  4301. static rx_Bitset
  4302. inverse_translation (rxb, valid, cache, translate, c)
  4303.      struct re_pattern_buffer * rxb;
  4304.      char * valid;
  4305.      rx_Bitset cache;
  4306.      unsigned char * translate;
  4307.      int c;
  4308. #endif
  4309. {
  4310.   rx_Bitset cs
  4311.     = cache + c * rx_bitset_numb_subsets (rxb->rx.local_cset_size); 
  4312.  
  4313.   if (!valid[c])
  4314.     {
  4315.       int x;
  4316.       int c_tr = TRANSLATE(c);
  4317.       rx_bitset_null (rxb->rx.local_cset_size, cs);
  4318.       for (x = 0; x < 256; ++x)    /* &&&& 13.37 */
  4319.     if (TRANSLATE(x) == c_tr)
  4320.       RX_bitset_enjoin (cs, x);
  4321.       valid[c] = 1;
  4322.     }
  4323.   return cs;
  4324. }
  4325.  
  4326.  
  4327.  
  4328.  
  4329. /* More subroutine declarations and macros for regex_compile.  */
  4330.  
  4331. /* Returns true if REGNUM is in one of COMPILE_STACK's elements and 
  4332.    false if it's not.  */
  4333.  
  4334. #ifdef __STDC__
  4335. static boolean
  4336. group_in_compile_stack (compile_stack_type compile_stack, regnum_t regnum)
  4337. #else
  4338. static boolean
  4339. group_in_compile_stack (compile_stack, regnum)
  4340.     compile_stack_type compile_stack;
  4341.     regnum_t regnum;
  4342. #endif
  4343. {
  4344.   int this_element;
  4345.  
  4346.   for (this_element = compile_stack.avail - 1;  
  4347.        this_element >= 0; 
  4348.        this_element--)
  4349.     if (compile_stack.stack[this_element].regnum == regnum)
  4350.       return true;
  4351.  
  4352.   return false;
  4353. }
  4354.  
  4355.  
  4356. /*
  4357.  * Read the ending character of a range (in a bracket expression) from the
  4358.  * uncompiled pattern *P_PTR (which ends at PEND).  We assume the
  4359.  * starting character is in `P[-2]'.  (`P[-1]' is the character `-'.)
  4360.  * Then we set the translation of all bits between the starting and
  4361.  * ending characters (inclusive) in the compiled pattern B.
  4362.  * 
  4363.  * Return an error code.
  4364.  * 
  4365.  * We use these short variable names so we can use the same macros as
  4366.  * `regex_compile' itself.  
  4367.  */
  4368.  
  4369. #ifdef __STDC__
  4370. static reg_errcode_t
  4371. compile_range (struct re_pattern_buffer * rxb, rx_Bitset cs,
  4372.            const char ** p_ptr, const char * pend,
  4373.            unsigned char * translate, reg_syntax_t syntax,
  4374.            rx_Bitset inv_tr,  char * valid_inv_tr)
  4375. #else
  4376. static reg_errcode_t
  4377. compile_range (rxb, cs, p_ptr, pend, translate, syntax, inv_tr, valid_inv_tr)
  4378.      struct re_pattern_buffer * rxb;
  4379.      rx_Bitset cs;
  4380.      const char ** p_ptr;
  4381.      const char * pend;
  4382.      unsigned char * translate;
  4383.      reg_syntax_t syntax;
  4384.      rx_Bitset inv_tr;
  4385.      char * valid_inv_tr;
  4386. #endif
  4387. {
  4388.   unsigned this_char;
  4389.  
  4390.   const char *p = *p_ptr;
  4391.  
  4392.   unsigned char range_end;
  4393.   unsigned char range_start = TRANSLATE(p[-2]);
  4394.  
  4395.   if (p == pend)
  4396.     return REG_ERANGE;
  4397.  
  4398.   PATFETCH (range_end);
  4399.  
  4400.   (*p_ptr)++;
  4401.  
  4402.   if (range_start > range_end)
  4403.     return syntax & RE_NO_EMPTY_RANGES ? REG_ERANGE : REG_NOERROR;
  4404.  
  4405.   for (this_char = range_start; this_char <= range_end; this_char++)
  4406.     {
  4407.       rx_Bitset it =
  4408.     inverse_translation (rxb, valid_inv_tr, inv_tr, translate, this_char);
  4409.       rx_bitset_union (rxb->rx.local_cset_size, cs, it);
  4410.     }
  4411.   
  4412.   return REG_NOERROR;
  4413. }
  4414.  
  4415.  
  4416. /* This searches a regexp for backreference side effects.
  4417.  * It fills in the array OUT with 1 at the index of every register pair
  4418.  * referenced by a backreference.
  4419.  *
  4420.  * This is used to help optimize patterns for searching.  The information is
  4421.  * useful because, if the caller doesn't want register values, backreferenced
  4422.  * registers are the only registers for which we need rx_backtrack.
  4423.  */
  4424.  
  4425. #ifdef __STDC__
  4426. static void
  4427. find_backrefs (char * out, struct rexp_node * rexp,
  4428.            struct re_se_params * params)
  4429. #else
  4430. static void
  4431. find_backrefs (out, rexp, params)
  4432.      char * out;
  4433.      struct rexp_node * rexp;
  4434.      struct re_se_params * params;
  4435. #endif
  4436. {
  4437.   if (rexp)
  4438.     switch (rexp->type)
  4439.       {
  4440.       case r_cset:
  4441.       case r_data:
  4442.     return;
  4443.       case r_alternate:
  4444.       case r_concat:
  4445.       case r_opt:
  4446.       case r_star:
  4447.       case r_2phase_star:
  4448.     find_backrefs (out, rexp->params.pair.left, params);
  4449.     find_backrefs (out, rexp->params.pair.right, params);
  4450.     return;
  4451.       case r_side_effect:
  4452.     if (   ((int)rexp->params.side_effect >= 0)
  4453.         && (params [(int)rexp->params.side_effect].se == re_se_backref))
  4454.       out[ params [(int)rexp->params.side_effect].op1] = 1;
  4455.     return;
  4456.       }
  4457. }
  4458.  
  4459.  
  4460.  
  4461. /* Returns 0 unless the pattern can match the empty string. */
  4462.  
  4463. #ifdef __STDC__
  4464. static int
  4465. compute_fastset (struct re_pattern_buffer * rxb, struct rexp_node * rexp)
  4466. #else
  4467. static int
  4468. compute_fastset (rxb, rexp)
  4469.      struct re_pattern_buffer * rxb;
  4470.      struct rexp_node * rexp;
  4471. #endif
  4472. {
  4473.   if (!rexp)
  4474.     return 1;
  4475.   switch (rexp->type)
  4476.     {
  4477.     case r_data:
  4478.       return 1;
  4479.     case r_cset:
  4480.       {
  4481.     rx_bitset_union (rxb->rx.local_cset_size,
  4482.              rxb->fastset, rexp->params.cset);
  4483.       }
  4484.       return 0;
  4485.     case r_concat:
  4486.       return (compute_fastset (rxb, rexp->params.pair.left)
  4487.           && compute_fastset (rxb, rexp->params.pair.right));
  4488.     case r_2phase_star:
  4489.       compute_fastset (rxb, rexp->params.pair.left);
  4490.       /* compute_fastset (rxb, rexp->params.pair.right);  nope... */
  4491.       return 1;
  4492.     case r_alternate:
  4493.       return !!(compute_fastset (rxb, rexp->params.pair.left)
  4494.         + compute_fastset (rxb, rexp->params.pair.right));
  4495.     case r_opt:
  4496.     case r_star:
  4497.       compute_fastset (rxb, rexp->params.pair.left);
  4498.       return 1;
  4499.     case r_side_effect:
  4500.       return 1;
  4501.     }
  4502.  
  4503.   /* this should never happen */
  4504.   return 0;
  4505. }
  4506.  
  4507.  
  4508. /* returns
  4509.  *  1 -- yes, definately anchored by the given side effect.
  4510.  *  2 -- maybe anchored, maybe the empty string.
  4511.  *  0 -- definately not anchored
  4512.  *  There is simply no other possibility.
  4513.  */
  4514.  
  4515. #ifdef __STDC__
  4516. static int
  4517. is_anchored (struct rexp_node * rexp, rx_side_effect se)
  4518. #else
  4519. static int
  4520. is_anchored (rexp, se)
  4521.      struct rexp_node * rexp;
  4522.      rx_side_effect se;
  4523. #endif
  4524. {
  4525.   if (!rexp)
  4526.     return 2;
  4527.   switch (rexp->type)
  4528.     {
  4529.     case r_cset:
  4530.     case r_data:
  4531.       return 0;
  4532.     case r_concat:
  4533.     case r_2phase_star:
  4534.       {
  4535.     int l = is_anchored (rexp->params.pair.left, se);
  4536.     return (l == 2 ? is_anchored (rexp->params.pair.right, se) : l);
  4537.       }
  4538.     case r_alternate:
  4539.       {
  4540.     int l = is_anchored (rexp->params.pair.left, se);
  4541.     int r = l ? is_anchored (rexp->params.pair.right, se) : 0;
  4542.     return MAX (l, r);
  4543.       }
  4544.     case r_opt:
  4545.     case r_star:
  4546.       return is_anchored (rexp->params.pair.left, se) ? 2 : 0;
  4547.       
  4548.     case r_side_effect:
  4549.       return ((rexp->params.side_effect == se)
  4550.           ? 1 : 2);
  4551.     }
  4552.  
  4553.   /* this should never happen */
  4554.   return 0;
  4555. }
  4556.  
  4557.  
  4558. /* This removes register assignments that aren't required by backreferencing.
  4559.  * This can speed up explore_future, especially if it eliminates
  4560.  * non-determinism in the superstate NFA.
  4561.  * 
  4562.  * NEEDED is an array of characters, presumably filled in by FIND_BACKREFS.
  4563.  * The non-zero elements of the array indicate which register assignments
  4564.  * can NOT be removed from the expression.
  4565.  */
  4566.  
  4567. #ifdef __STDC__
  4568. static struct rexp_node *
  4569. remove_unecessary_side_effects (struct rx * rx, char * needed,
  4570.                 struct rexp_node * rexp,
  4571.                 struct re_se_params * params)
  4572. #else
  4573. static struct rexp_node *
  4574. remove_unecessary_side_effects (rx, needed, rexp, params)
  4575.      struct rx * rx;
  4576.      char * needed;
  4577.      struct rexp_node * rexp;
  4578.      struct re_se_params * params;
  4579. #endif
  4580. {
  4581.   struct rexp_node * l;
  4582.   struct rexp_node * r;
  4583.   if (!rexp)
  4584.     return 0;
  4585.   else
  4586.     switch (rexp->type)
  4587.       {
  4588.       case r_cset:
  4589.       case r_data:
  4590.     return rexp;
  4591.       case r_alternate:
  4592.       case r_concat:
  4593.       case r_2phase_star:
  4594.     l = remove_unecessary_side_effects (rx, needed,
  4595.                         rexp->params.pair.left, params);
  4596.     r = remove_unecessary_side_effects (rx, needed,
  4597.                         rexp->params.pair.right, params);
  4598.     if ((l && r) || (rexp->type != r_concat))
  4599.       {
  4600.         rexp->params.pair.left = l;
  4601.         rexp->params.pair.right = r;
  4602.         return rexp;
  4603.       }
  4604.     else
  4605.       {
  4606.         rexp->params.pair.left = rexp->params.pair.right = 0;
  4607.         rx_free_rexp (rx, rexp);
  4608.         return l ? l : r;
  4609.       }
  4610.       case r_opt:
  4611.       case r_star:
  4612.     l = remove_unecessary_side_effects (rx, needed,
  4613.                         rexp->params.pair.left, params);
  4614.     if (l)
  4615.       {
  4616.         rexp->params.pair.left = l;
  4617.         return rexp;
  4618.       }
  4619.     else
  4620.       {
  4621.         rexp->params.pair.left = 0;
  4622.         rx_free_rexp (rx, rexp);
  4623.         return 0;
  4624.       }
  4625.       case r_side_effect:
  4626.     {
  4627.       int se = (int)rexp->params.side_effect;
  4628.       if (   (se >= 0)
  4629.           && (   ((enum re_side_effects)params[se].se == re_se_lparen)
  4630.           || ((enum re_side_effects)params[se].se == re_se_rparen))
  4631.           && (params [se].op1 > 0)
  4632.           && (!needed [params [se].op1]))
  4633.         {
  4634.           rx_free_rexp (rx, rexp);
  4635.           return 0;
  4636.         }
  4637.       else
  4638.         return rexp;
  4639.     }
  4640.       }
  4641.  
  4642.   /* this should never happen */
  4643.   return 0;
  4644. }
  4645.  
  4646.  
  4647.  
  4648. #ifdef __STDC__
  4649. static int
  4650. pointless_if_repeated (struct rexp_node * node, struct re_se_params * params)
  4651. #else
  4652. static int
  4653. pointless_if_repeated (node, params)
  4654.      struct rexp_node * node;
  4655.      struct re_se_params * params;
  4656. #endif
  4657. {
  4658.   if (!node)
  4659.     return 1;
  4660.   switch (node->type)
  4661.     {
  4662.     case r_cset:
  4663.       return 0;
  4664.     case r_alternate:
  4665.     case r_concat:
  4666.     case r_2phase_star:
  4667.       return (pointless_if_repeated (node->params.pair.left, params)
  4668.           && pointless_if_repeated (node->params.pair.right, params));
  4669.     case r_opt:
  4670.     case r_star:
  4671.       return pointless_if_repeated (node->params.pair.left, params);
  4672.     case r_side_effect:
  4673.       switch (((int)node->params.side_effect < 0)
  4674.           ? (enum re_side_effects)node->params.side_effect
  4675.           : (enum re_side_effects)params[(int)node->params.side_effect].se)
  4676.     {
  4677.     case re_se_try:
  4678.     case re_se_at_dot:
  4679.     case re_se_begbuf:
  4680.     case re_se_hat:
  4681.     case re_se_wordbeg:
  4682.     case re_se_wordbound:
  4683.     case re_se_notwordbound:
  4684.     case re_se_wordend:
  4685.     case re_se_endbuf:
  4686.     case re_se_dollar:
  4687.     case re_se_fail:
  4688.     case re_se_win:
  4689.       return 1;
  4690.     case re_se_lparen:
  4691.     case re_se_rparen:
  4692.     case re_se_iter:
  4693.     case re_se_end_iter:
  4694.     case re_se_syntax:
  4695.     case re_se_not_syntax:
  4696.     case re_se_backref:
  4697.       return 0;
  4698.     }
  4699.     case r_data:
  4700.     default:
  4701.       return 0;
  4702.     }
  4703. }
  4704.  
  4705.  
  4706.  
  4707. #ifdef __STDC__
  4708. static int
  4709. registers_on_stack (struct re_pattern_buffer * rxb,
  4710.             struct rexp_node * rexp, int in_danger,
  4711.             struct re_se_params * params)
  4712. #else
  4713. static int
  4714. registers_on_stack (rxb, rexp, in_danger, params)
  4715.      struct re_pattern_buffer * rxb;
  4716.      struct rexp_node * rexp;
  4717.      int in_danger;
  4718.      struct re_se_params * params;
  4719. #endif
  4720. {
  4721.   if (!rexp)
  4722.     return 0;
  4723.   else
  4724.     switch (rexp->type)
  4725.       {
  4726.       case r_cset:
  4727.       case r_data:
  4728.     return 0;
  4729.       case r_alternate:
  4730.       case r_concat:
  4731.     return (   registers_on_stack (rxb, rexp->params.pair.left,
  4732.                        in_danger, params)
  4733.         || (registers_on_stack
  4734.             (rxb, rexp->params.pair.right,
  4735.              in_danger, params)));
  4736.       case r_opt:
  4737.     return registers_on_stack (rxb, rexp->params.pair.left, 0, params);
  4738.       case r_star:
  4739.     return registers_on_stack (rxb, rexp->params.pair.left, 1, params);
  4740.       case r_2phase_star:
  4741.     return
  4742.       (   registers_on_stack (rxb, rexp->params.pair.left, 1, params)
  4743.        || registers_on_stack (rxb, rexp->params.pair.right, 1, params));
  4744.       case r_side_effect:
  4745.     {
  4746.       int se = (int)rexp->params.side_effect;
  4747.       if (   in_danger
  4748.           && (se >= 0)
  4749.           && (params [se].op1 > 0)
  4750.           && (   ((enum re_side_effects)params[se].se == re_se_lparen)
  4751.           || ((enum re_side_effects)params[se].se == re_se_rparen)))
  4752.         return 1;
  4753.       else
  4754.         return 0;
  4755.     }
  4756.       }
  4757.  
  4758.   /* this should never happen */
  4759.   return 0;
  4760. }
  4761.  
  4762.  
  4763.  
  4764. static char idempotent_complex_se[] =
  4765. {
  4766. #define RX_WANT_SE_DEFS 1
  4767. #undef RX_DEF_SE
  4768. #undef RX_DEF_CPLX_SE
  4769. #define RX_DEF_SE(IDEM, NAME, VALUE)          
  4770. #define RX_DEF_CPLX_SE(IDEM, NAME, VALUE)     IDEM,
  4771. #include "rx.h"
  4772. #undef RX_DEF_SE
  4773. #undef RX_DEF_CPLX_SE
  4774. #undef RX_WANT_SE_DEFS
  4775.   23
  4776. };
  4777.  
  4778. static char idempotent_se[] =
  4779. {
  4780.   13,
  4781. #define RX_WANT_SE_DEFS 1
  4782. #undef RX_DEF_SE
  4783. #undef RX_DEF_CPLX_SE
  4784. #define RX_DEF_SE(IDEM, NAME, VALUE)          IDEM,
  4785. #define RX_DEF_CPLX_SE(IDEM, NAME, VALUE)     
  4786. #include "rx.h"
  4787. #undef RX_DEF_SE
  4788. #undef RX_DEF_CPLX_SE
  4789. #undef RX_WANT_SE_DEFS
  4790.   42
  4791. };
  4792.  
  4793.  
  4794.  
  4795.  
  4796. #ifdef __STDC__
  4797. static int
  4798. has_any_se (struct rx * rx,
  4799.         struct rexp_node * rexp)
  4800. #else
  4801. static int
  4802. has_any_se (rx, rexp)
  4803.      struct rx * rx;
  4804.      struct rexp_node * rexp;
  4805. #endif
  4806. {
  4807.   if (!rexp)
  4808.     return 0;
  4809.  
  4810.   switch (rexp->type)
  4811.     {
  4812.     case r_cset:
  4813.     case r_data:
  4814.       return 0;
  4815.  
  4816.     case r_side_effect:
  4817.       return 1;
  4818.       
  4819.     case r_2phase_star:
  4820.     case r_concat:
  4821.     case r_alternate:
  4822.       return
  4823.     (   has_any_se (rx, rexp->params.pair.left)
  4824.      || has_any_se (rx, rexp->params.pair.right));
  4825.  
  4826.     case r_opt:
  4827.     case r_star:
  4828.       return has_any_se (rx, rexp->params.pair.left);
  4829.     }
  4830.  
  4831.   /* this should never happen */
  4832.   return 0;
  4833. }
  4834.  
  4835.  
  4836.  
  4837. /* This must be called AFTER `convert_hard_loops' for a given REXP. */
  4838. #ifdef __STDC__
  4839. static int
  4840. has_non_idempotent_epsilon_path (struct rx * rx,
  4841.                  struct rexp_node * rexp,
  4842.                  struct re_se_params * params)
  4843. #else
  4844. static int
  4845. has_non_idempotent_epsilon_path (rx, rexp, params)
  4846.      struct rx * rx;
  4847.      struct rexp_node * rexp;
  4848.      struct re_se_params * params;
  4849. #endif
  4850. {
  4851.   if (!rexp)
  4852.     return 0;
  4853.  
  4854.   switch (rexp->type)
  4855.     {
  4856.     case r_cset:
  4857.     case r_data:
  4858.     case r_star:
  4859.       return 0;
  4860.  
  4861.     case r_side_effect:
  4862.       return
  4863.     !((int)rexp->params.side_effect > 0
  4864.       ? idempotent_complex_se [ params [(int)rexp->params.side_effect].se ]
  4865.       : idempotent_se [-(int)rexp->params.side_effect]);
  4866.       
  4867.     case r_alternate:
  4868.       return
  4869.     (   has_non_idempotent_epsilon_path (rx,
  4870.                          rexp->params.pair.left, params)
  4871.      || has_non_idempotent_epsilon_path (rx,
  4872.                          rexp->params.pair.right, params));
  4873.  
  4874.     case r_2phase_star:
  4875.     case r_concat:
  4876.       return
  4877.     (   has_non_idempotent_epsilon_path (rx,
  4878.                          rexp->params.pair.left, params)
  4879.      && has_non_idempotent_epsilon_path (rx,
  4880.                          rexp->params.pair.right, params));
  4881.  
  4882.     case r_opt:
  4883.       return has_non_idempotent_epsilon_path (rx,
  4884.                           rexp->params.pair.left, params);
  4885.     }
  4886.  
  4887.   /* this should never happen */
  4888.   return 0;
  4889. }
  4890.  
  4891.  
  4892.  
  4893. /* This computes rougly what it's name suggests.   It can (and does) go wrong 
  4894.  * in the direction of returning spurious 0 without causing disasters.
  4895.  */
  4896. #ifdef __STDC__
  4897. static int
  4898. begins_with_complex_se (struct rx * rx, struct rexp_node * rexp)
  4899. #else
  4900. static int
  4901. begins_with_complex_se (rx, rexp)
  4902.      struct rx * rx;
  4903.      struct rexp_node * rexp;
  4904. #endif
  4905. {
  4906.   if (!rexp)
  4907.     return 0;
  4908.  
  4909.   switch (rexp->type)
  4910.     {
  4911.     case r_cset:
  4912.     case r_data:
  4913.       return 0;
  4914.  
  4915.     case r_side_effect:
  4916.       return ((int)rexp->params.side_effect >= 0);
  4917.       
  4918.     case r_alternate:
  4919.       return
  4920.     (   begins_with_complex_se (rx, rexp->params.pair.left)
  4921.      && begins_with_complex_se (rx, rexp->params.pair.right));
  4922.  
  4923.  
  4924.     case r_concat:
  4925.       return has_any_se (rx, rexp->params.pair.left);
  4926.     case r_opt:
  4927.     case r_star:
  4928.     case r_2phase_star:
  4929.       return 0;
  4930.     }
  4931.  
  4932.   /* this should never happen */
  4933.   return 0;
  4934. }
  4935.  
  4936.  
  4937. /* This destructively removes some of the re_se_tv side effects from 
  4938.  * a rexp tree.  In particular, during parsing re_se_tv was inserted on the
  4939.  * right half of every | to guarantee that posix path preference could be 
  4940.  * honored.  This function removes some which it can be determined aren't 
  4941.  * needed.  
  4942.  */
  4943.  
  4944. #ifdef __STDC__
  4945. static void
  4946. speed_up_alt (struct rx * rx,
  4947.           struct rexp_node * rexp,
  4948.           int unposix)
  4949. #else
  4950. static void
  4951. speed_up_alt (rx, rexp, unposix)
  4952.      struct rx * rx;
  4953.      struct rexp_node * rexp;
  4954.      int unposix;
  4955. #endif
  4956. {
  4957.   if (!rexp)
  4958.     return;
  4959.  
  4960.   switch (rexp->type)
  4961.     {
  4962.     case r_cset:
  4963.     case r_data:
  4964.     case r_side_effect:
  4965.       return;
  4966.  
  4967.     case r_opt:
  4968.     case r_star:
  4969.       speed_up_alt (rx, rexp->params.pair.left, unposix);
  4970.       return;
  4971.  
  4972.     case r_2phase_star:
  4973.     case r_concat:
  4974.       speed_up_alt (rx, rexp->params.pair.left, unposix);
  4975.       speed_up_alt (rx, rexp->params.pair.right, unposix);
  4976.       return;
  4977.  
  4978.     case r_alternate:
  4979.       /* the right child is guaranteed to be (concat re_se_tv <subexp>) */
  4980.  
  4981.       speed_up_alt (rx, rexp->params.pair.left, unposix);
  4982.       speed_up_alt (rx, rexp->params.pair.right->params.pair.right, unposix);
  4983.       
  4984.       if (   unposix
  4985.       || (begins_with_complex_se
  4986.           (rx, rexp->params.pair.right->params.pair.right))
  4987.       || !(   has_any_se (rx, rexp->params.pair.right->params.pair.right)
  4988.            || has_any_se (rx, rexp->params.pair.left)))
  4989.     {
  4990.       struct rexp_node * conc = rexp->params.pair.right;
  4991.       rexp->params.pair.right = conc->params.pair.right;
  4992.       conc->params.pair.right = 0;
  4993.       rx_free_rexp (rx, conc);
  4994.     }
  4995.     }
  4996. }
  4997.  
  4998.  
  4999.  
  5000.  
  5001.  
  5002. /* `regex_compile' compiles PATTERN (of length SIZE) according to SYNTAX.
  5003.    Returns one of error codes defined in `regex.h', or zero for success.
  5004.  
  5005.    Assumes the `allocated' (and perhaps `buffer') and `translate'
  5006.    fields are set in BUFP on entry.
  5007.  
  5008.    If it succeeds, results are put in BUFP (if it returns an error, the
  5009.    contents of BUFP are undefined):
  5010.      `buffer' is the compiled pattern;
  5011.      `syntax' is set to SYNTAX;
  5012.      `used' is set to the length of the compiled pattern;
  5013.      `fastmap_accurate' is set to zero;
  5014.      `re_nsub' is set to the number of groups in PATTERN;
  5015.      `not_bol' and `not_eol' are set to zero.
  5016.    
  5017.    The `fastmap' and `newline_anchor' fields are neither
  5018.    examined nor set.  */
  5019.  
  5020.  
  5021.  
  5022. #ifdef __STDC__
  5023. reg_errcode_t
  5024. rx_compile (const char *pattern, int size,
  5025.         reg_syntax_t syntax,
  5026.         struct re_pattern_buffer * rxb) 
  5027. #else
  5028. reg_errcode_t
  5029. rx_compile (pattern, size, syntax, rxb)
  5030.      const char *pattern;
  5031.      int size;
  5032.      reg_syntax_t syntax;
  5033.      struct re_pattern_buffer * rxb;
  5034. #endif
  5035. {
  5036.   RX_subset
  5037.     inverse_translate [CHAR_SET_SIZE * rx_bitset_numb_subsets(CHAR_SET_SIZE)];
  5038.   char
  5039.     validate_inv_tr [CHAR_SET_SIZE * rx_bitset_numb_subsets(CHAR_SET_SIZE)];
  5040.  
  5041.   /* We fetch characters from PATTERN here.  Even though PATTERN is
  5042.      `char *' (i.e., signed), we declare these variables as unsigned, so
  5043.      they can be reliably used as array indices.  */
  5044.   register unsigned char c, c1;
  5045.   
  5046.   /* A random tempory spot in PATTERN.  */
  5047.   const char *p1;
  5048.   
  5049.   /* Keeps track of unclosed groups.  */
  5050.   compile_stack_type compile_stack;
  5051.  
  5052.   /* Points to the current (ending) position in the pattern.  */
  5053.   const char *p = pattern;
  5054.   const char *pend = pattern + size;
  5055.   
  5056.   /* How to translate the characters in the pattern.  */
  5057.   unsigned char *translate = (rxb->translate
  5058.                   ? (unsigned char *)rxb->translate
  5059.                   : (unsigned char *)id_translation);
  5060.  
  5061.   /* When parsing is done, this will hold the expression tree. */
  5062.   struct rexp_node * rexp = 0;
  5063.  
  5064.   /* In the midst of compilation, this holds onto the regexp 
  5065.    * first parst while rexp goes on to aquire additional constructs.
  5066.    */
  5067.   struct rexp_node * orig_rexp = 0;
  5068.   struct rexp_node * fewer_side_effects = 0;
  5069.  
  5070.   /* This and top_expression are saved on the compile stack. */
  5071.   struct rexp_node ** top_expression = &rexp;
  5072.   struct rexp_node ** last_expression = top_expression;
  5073.   
  5074.   /* Parameter to `goto append_node' */
  5075.   struct rexp_node * append;
  5076.  
  5077.   /* Counts open-groups as they are encountered.  This is the index of the
  5078.    * innermost group being compiled.
  5079.    */
  5080.   regnum_t regnum = 0;
  5081.  
  5082.   /* Place in the uncompiled pattern (i.e., the {) to
  5083.    * which to go back if the interval is invalid.  
  5084.    */
  5085.   const char *beg_interval;
  5086.  
  5087.   struct re_se_params * params = 0;
  5088.   int paramc = 0;        /* How many complex side effects so far? */
  5089.  
  5090.   rx_side_effect side;        /* param to `goto add_side_effect' */
  5091.  
  5092.   bzero (validate_inv_tr, sizeof (validate_inv_tr));
  5093.  
  5094.   rxb->rx.instruction_table = rx_id_instruction_table;
  5095.  
  5096.  
  5097.   /* Initialize the compile stack.  */
  5098.   compile_stack.stack = TALLOC (INIT_COMPILE_STACK_SIZE, compile_stack_elt_t);
  5099.   if (compile_stack.stack == 0)
  5100.     return REG_ESPACE;
  5101.  
  5102.   compile_stack.size = INIT_COMPILE_STACK_SIZE;
  5103.   compile_stack.avail = 0;
  5104.  
  5105.   /* Initialize the pattern buffer.  */
  5106.   rxb->rx.cache = &default_cache;
  5107.   rxb->syntax = syntax;
  5108.   rxb->fastmap_accurate = 0;
  5109.   rxb->not_bol = rxb->not_eol = 0;
  5110.   rxb->least_subs = 0;
  5111.   
  5112.   /* Always count groups, whether or not rxb->no_sub is set.  
  5113.    * The whole pattern is implicitly group 0, so counting begins
  5114.    * with 1.
  5115.    */
  5116.   rxb->re_nsub = 0;
  5117.  
  5118. #if !defined (emacs) && !defined (SYNTAX_TABLE)
  5119.   /* Initialize the syntax table.  */
  5120.    init_syntax_once ();
  5121. #endif
  5122.  
  5123.   /* Loop through the uncompiled pattern until we're at the end.  */
  5124.   while (p != pend)
  5125.     {
  5126.       PATFETCH (c);
  5127.  
  5128.       switch (c)
  5129.         {
  5130.         case '^':
  5131.           {
  5132.             if (   /* If at start of pattern, it's an operator.  */
  5133.                    p == pattern + 1
  5134.                    /* If context independent, it's an operator.  */
  5135.                 || syntax & RE_CONTEXT_INDEP_ANCHORS
  5136.                    /* Otherwise, depends on what's come before.  */
  5137.                 || at_begline_loc_p (pattern, p, syntax))
  5138.           {
  5139.         struct rexp_node * n
  5140.           = rx_mk_r_side_effect (&rxb->rx, (rx_side_effect)re_se_hat);
  5141.         if (!n)
  5142.           return REG_ESPACE;
  5143.         append = n;
  5144.         goto append_node;
  5145.           }
  5146.             else
  5147.               goto normal_char;
  5148.           }
  5149.           break;
  5150.  
  5151.  
  5152.         case '$':
  5153.           {
  5154.             if (   /* If at end of pattern, it's an operator.  */
  5155.                    p == pend 
  5156.                    /* If context independent, it's an operator.  */
  5157.                 || syntax & RE_CONTEXT_INDEP_ANCHORS
  5158.                    /* Otherwise, depends on what's next.  */
  5159.                 || at_endline_loc_p (p, pend, syntax))
  5160.           {
  5161.         struct rexp_node * n
  5162.           = rx_mk_r_side_effect (&rxb->rx, (rx_side_effect)re_se_dollar);
  5163.         if (!n)
  5164.           return REG_ESPACE;
  5165.         append = n;
  5166.         goto append_node;
  5167.           }
  5168.              else
  5169.                goto normal_char;
  5170.            }
  5171.            break;
  5172.  
  5173.  
  5174.     case '+':
  5175.         case '?':
  5176.           if ((syntax & RE_BK_PLUS_QM)
  5177.               || (syntax & RE_LIMITED_OPS))
  5178.             goto normal_char;
  5179.  
  5180.         handle_plus:
  5181.         case '*':
  5182.           /* If there is no previous pattern... */
  5183.           if (pointless_if_repeated (*last_expression, params))
  5184.             {
  5185.               if (syntax & RE_CONTEXT_INVALID_OPS)
  5186.                 return REG_BADRPT;
  5187.               else if (!(syntax & RE_CONTEXT_INDEP_OPS))
  5188.                 goto normal_char;
  5189.             }
  5190.  
  5191.           {
  5192.             /* 1 means zero (many) matches is allowed.  */
  5193.             char zero_times_ok = 0, many_times_ok = 0;
  5194.  
  5195.             /* If there is a sequence of repetition chars, collapse it
  5196.                down to just one (the right one).  We can't combine
  5197.                interval operators with these because of, e.g., `a{2}*',
  5198.                which should only match an even number of `a's.  */
  5199.  
  5200.             for (;;)
  5201.               {
  5202.                 zero_times_ok |= c != '+';
  5203.                 many_times_ok |= c != '?';
  5204.  
  5205.                 if (p == pend)
  5206.                   break;
  5207.  
  5208.                 PATFETCH (c);
  5209.  
  5210.                 if (c == '*'
  5211.                     || (!(syntax & RE_BK_PLUS_QM) && (c == '+' || c == '?')))
  5212.                   ;
  5213.  
  5214.                 else if (syntax & RE_BK_PLUS_QM  &&  c == '\\')
  5215.                   {
  5216.                     if (p == pend) return REG_EESCAPE;
  5217.  
  5218.                     PATFETCH (c1);
  5219.                     if (!(c1 == '+' || c1 == '?'))
  5220.                       {
  5221.                         PATUNFETCH;
  5222.                         PATUNFETCH;
  5223.                         break;
  5224.                       }
  5225.  
  5226.                     c = c1;
  5227.                   }
  5228.                 else
  5229.                   {
  5230.                     PATUNFETCH;
  5231.                     break;
  5232.                   }
  5233.  
  5234.                 /* If we get here, we found another repeat character.  */
  5235.                }
  5236.  
  5237.             /* Star, etc. applied to an empty pattern is equivalent
  5238.                to an empty pattern.  */
  5239.             if (!last_expression)
  5240.               break;
  5241.  
  5242.         /* Now we know whether or not zero matches is allowed
  5243.          * and also whether or not two or more matches is allowed.
  5244.          */
  5245.  
  5246.         {
  5247.           struct rexp_node * inner_exp = *last_expression;
  5248.           int need_sync = 0;
  5249.  
  5250.           if (many_times_ok
  5251.           && has_non_idempotent_epsilon_path (&rxb->rx,
  5252.                               inner_exp, params))
  5253.         {
  5254.           struct rexp_node * pusher
  5255.             = rx_mk_r_side_effect (&rxb->rx,
  5256.                        (rx_side_effect)re_se_pushpos);
  5257.           struct rexp_node * checker
  5258.             = rx_mk_r_side_effect (&rxb->rx,
  5259.                        (rx_side_effect)re_se_chkpos);
  5260.           struct rexp_node * pushback
  5261.             = rx_mk_r_side_effect (&rxb->rx,
  5262.                        (rx_side_effect)re_se_pushback);
  5263.           rx_Bitset cs = rx_cset (&rxb->rx);
  5264.           struct rexp_node * lit_t = rx_mk_r_cset (&rxb->rx, cs);
  5265.           struct rexp_node * fake_state
  5266.             = rx_mk_r_concat (&rxb->rx, pushback, lit_t);
  5267.           struct rexp_node * phase2
  5268.             = rx_mk_r_concat (&rxb->rx, checker, fake_state);
  5269.           struct rexp_node * popper
  5270.             = rx_mk_r_side_effect (&rxb->rx,
  5271.                        (rx_side_effect)re_se_poppos);
  5272.           struct rexp_node * star
  5273.             = rx_mk_r_2phase_star (&rxb->rx, inner_exp, phase2);
  5274.           struct rexp_node * a
  5275.             = rx_mk_r_concat (&rxb->rx, pusher, star);
  5276.           struct rexp_node * whole_thing
  5277.             = rx_mk_r_concat (&rxb->rx, a, popper);
  5278.           if (!(pusher && star && pushback && lit_t && fake_state
  5279.             && lit_t && phase2 && checker && popper
  5280.             && a && whole_thing))
  5281.             return REG_ESPACE;
  5282.           RX_bitset_enjoin (cs, 't');
  5283.           *last_expression = whole_thing;
  5284.         }
  5285.           else
  5286.         {
  5287.           struct rexp_node * star =
  5288.             (many_times_ok ? rx_mk_r_star : rx_mk_r_opt)
  5289.               (&rxb->rx, *last_expression);
  5290.           if (!star)
  5291.             return REG_ESPACE;
  5292.           *last_expression = star;
  5293.           need_sync = has_any_se (&rxb->rx, *last_expression);
  5294.         }
  5295.           if (!zero_times_ok)
  5296.         {
  5297.           struct rexp_node * concat
  5298.             = rx_mk_r_concat (&rxb->rx, inner_exp,
  5299.                       rx_copy_rexp (&rxb->rx,
  5300.                             *last_expression));
  5301.           if (!concat)
  5302.             return REG_ESPACE;
  5303.           *last_expression = concat;
  5304.         }
  5305.           if (need_sync)
  5306.         {
  5307.           int sync_se = paramc;
  5308.           params = (params
  5309.                 ? ((struct re_se_params *)
  5310.                    realloc (params,
  5311.                     sizeof (*params) * (1 + paramc)))
  5312.                 : ((struct re_se_params *)
  5313.                    malloc (sizeof (*params))));
  5314.           if (!params)
  5315.             return REG_ESPACE;
  5316.           ++paramc;
  5317.           params [sync_se].se = re_se_tv;
  5318.           side = (rx_side_effect)sync_se;
  5319.           goto add_side_effect;
  5320.         }
  5321.         }
  5322.         /* The old regex.c used to optimize `.*\n'.  
  5323.          * Maybe rx should too?
  5324.          */
  5325.       }
  5326.       break;
  5327.  
  5328.  
  5329.     case '.':
  5330.       {
  5331.         rx_Bitset cs = rx_cset (&rxb->rx);
  5332.         struct rexp_node * n = rx_mk_r_cset (&rxb->rx, cs);
  5333.         if (!(cs && n))
  5334.           return REG_ESPACE;
  5335.  
  5336.         rx_bitset_universe (rxb->rx.local_cset_size, cs);
  5337.         if (!(rxb->syntax & RE_DOT_NEWLINE))
  5338.           RX_bitset_remove (cs, '\n');
  5339.         if (!(rxb->syntax & RE_DOT_NOT_NULL))
  5340.           RX_bitset_remove (cs, 0);
  5341.  
  5342.         append = n;
  5343.         goto append_node;
  5344.         break;
  5345.       }
  5346.  
  5347.  
  5348.         case '[':
  5349.       if (p == pend) return REG_EBRACK;
  5350.           {
  5351.             boolean had_char_class = false;
  5352.         rx_Bitset cs = rx_cset (&rxb->rx);
  5353.         struct rexp_node * node = rx_mk_r_cset (&rxb->rx, cs);
  5354.         int is_inverted = *p == '^';
  5355.         
  5356.         if (!(node && cs))
  5357.           return REG_ESPACE;
  5358.         
  5359.         /* This branch of the switch is normally exited with
  5360.          *`goto append_node'
  5361.          */
  5362.         append = node;
  5363.         
  5364.             if (is_inverted)
  5365.           p++;
  5366.         
  5367.             /* Remember the first position in the bracket expression.  */
  5368.             p1 = p;
  5369.         
  5370.             /* Read in characters and ranges, setting map bits.  */
  5371.             for (;;)
  5372.               {
  5373.                 if (p == pend) return REG_EBRACK;
  5374.         
  5375.                 PATFETCH (c);
  5376.         
  5377.                 /* \ might escape characters inside [...] and [^...].  */
  5378.                 if ((syntax & RE_BACKSLASH_ESCAPE_IN_LISTS) && c == '\\')
  5379.                   {
  5380.                     if (p == pend) return REG_EESCAPE;
  5381.             
  5382.                     PATFETCH (c1);
  5383.             {
  5384.               rx_Bitset it = inverse_translation (rxb, 
  5385.                               validate_inv_tr,
  5386.                               inverse_translate,
  5387.                               translate,
  5388.                               c1);
  5389.               rx_bitset_union (rxb->rx.local_cset_size, cs, it);
  5390.             }
  5391.                     continue;
  5392.                   }
  5393.         
  5394.                 /* Could be the end of the bracket expression.  If it's
  5395.                    not (i.e., when the bracket expression is `[]' so
  5396.                    far), the ']' character bit gets set way below.  */
  5397.                 if (c == ']' && p != p1 + 1)
  5398.                   goto finalize_class_and_append;
  5399.         
  5400.                 /* Look ahead to see if it's a range when the last thing
  5401.                    was a character class.  */
  5402.                 if (had_char_class && c == '-' && *p != ']')
  5403.                   return REG_ERANGE;
  5404.         
  5405.                 /* Look ahead to see if it's a range when the last thing
  5406.                    was a character: if this is a hyphen not at the
  5407.                    beginning or the end of a list, then it's the range
  5408.                    operator.  */
  5409.                 if (c == '-' 
  5410.                     && !(p - 2 >= pattern && p[-2] == '[') 
  5411.                     && !(p - 3 >= pattern && p[-3] == '[' && p[-2] == '^')
  5412.                     && *p != ']')
  5413.                   {
  5414.                     reg_errcode_t ret
  5415.                       = compile_range (rxb, cs, &p, pend, translate, syntax,
  5416.                        inverse_translate, validate_inv_tr);
  5417.                     if (ret != REG_NOERROR) return ret;
  5418.                   }
  5419.         
  5420.                 else if (p[0] == '-' && p[1] != ']')
  5421.                   { /* This handles ranges made up of characters only.  */
  5422.                     reg_errcode_t ret;
  5423.             
  5424.             /* Move past the `-'.  */
  5425.                     PATFETCH (c1);
  5426.                     
  5427.                     ret = compile_range (rxb, cs, &p, pend, translate, syntax,
  5428.                      inverse_translate, validate_inv_tr);
  5429.                     if (ret != REG_NOERROR) return ret;
  5430.                   }
  5431.         
  5432.                 /* See if we're at the beginning of a possible character
  5433.                    class.  */
  5434.         
  5435.         else if ((syntax & RE_CHAR_CLASSES)
  5436.              && (c == '[') && (*p == ':'))
  5437.                   {
  5438.                     char str[CHAR_CLASS_MAX_LENGTH + 1];
  5439.             
  5440.                     PATFETCH (c);
  5441.                     c1 = 0;
  5442.             
  5443.                     /* If pattern is `[[:'.  */
  5444.                     if (p == pend) return REG_EBRACK;
  5445.             
  5446.                     for (;;)
  5447.                       {
  5448.                         PATFETCH (c);
  5449.                         if (c == ':' || c == ']' || p == pend
  5450.                             || c1 == CHAR_CLASS_MAX_LENGTH)
  5451.               break;
  5452.                         str[c1++] = c;
  5453.                       }
  5454.                     str[c1] = '\0';
  5455.             
  5456.                     /* If isn't a word bracketed by `[:' and:`]':
  5457.                        undo the ending character, the letters, and leave 
  5458.                        the leading `:' and `[' (but set bits for them).  */
  5459.                     if (c == ':' && *p == ']')
  5460.                       {
  5461.                         int ch;
  5462.                         boolean is_alnum = !strcmp (str, "alnum");
  5463.                         boolean is_alpha = !strcmp (str, "alpha");
  5464.                         boolean is_blank = !strcmp (str, "blank");
  5465.                         boolean is_cntrl = !strcmp (str, "cntrl");
  5466.                         boolean is_digit = !strcmp (str, "digit");
  5467.                         boolean is_graph = !strcmp (str, "graph");
  5468.                         boolean is_lower = !strcmp (str, "lower");
  5469.                         boolean is_print = !strcmp (str, "print");
  5470.                         boolean is_punct = !strcmp (str, "punct");
  5471.                         boolean is_space = !strcmp (str, "space");
  5472.                         boolean is_upper = !strcmp (str, "upper");
  5473.                         boolean is_xdigit = !strcmp (str, "xdigit");
  5474.                         
  5475.                         if (!IS_CHAR_CLASS (str)) return REG_ECTYPE;
  5476.             
  5477.                         /* Throw away the ] at the end of the character
  5478.                            class.  */
  5479.                         PATFETCH (c);                    
  5480.             
  5481.                         if (p == pend) return REG_EBRACK;
  5482.             
  5483.                         for (ch = 0; ch < 1 << BYTEWIDTH; ch++)
  5484.                           {
  5485.                             if (   (is_alnum  && isalnum (ch))
  5486.                                 || (is_alpha  && isalpha (ch))
  5487.                                 || (is_blank  && isblank (ch))
  5488.                                 || (is_cntrl  && iscntrl (ch))
  5489.                                 || (is_digit  && isdigit (ch))
  5490.                                 || (is_graph  && isgraph (ch))
  5491.                                 || (is_lower  && islower (ch))
  5492.                                 || (is_print  && isprint (ch))
  5493.                                 || (is_punct  && ispunct (ch))
  5494.                                 || (is_space  && isspace (ch))
  5495.                                 || (is_upper  && isupper (ch))
  5496.                                 || (is_xdigit && isxdigit (ch)))
  5497.                   {
  5498.                 rx_Bitset it =
  5499.                   inverse_translation (rxb, 
  5500.                                validate_inv_tr,
  5501.                                inverse_translate,
  5502.                                translate,
  5503.                                ch);
  5504.                 rx_bitset_union (rxb->rx.local_cset_size,
  5505.                          cs, it);
  5506.                   }
  5507.                           }
  5508.                         had_char_class = true;
  5509.                       }
  5510.                     else
  5511.                       {
  5512.                         c1++;
  5513.                         while (c1--)    
  5514.                           PATUNFETCH;
  5515.             {
  5516.               rx_Bitset it =
  5517.                 inverse_translation (rxb, 
  5518.                          validate_inv_tr,
  5519.                          inverse_translate,
  5520.                          translate,
  5521.                          '[');
  5522.               rx_bitset_union (rxb->rx.local_cset_size,
  5523.                        cs, it);
  5524.             }
  5525.             {
  5526.               rx_Bitset it =
  5527.                 inverse_translation (rxb, 
  5528.                          validate_inv_tr,
  5529.                          inverse_translate,
  5530.                          translate,
  5531.                          ':');
  5532.               rx_bitset_union (rxb->rx.local_cset_size,
  5533.                        cs, it);
  5534.             }
  5535.                         had_char_class = false;
  5536.                       }
  5537.                   }
  5538.                 else
  5539.                   {
  5540.                     had_char_class = false;
  5541.             {
  5542.               rx_Bitset it = inverse_translation (rxb, 
  5543.                               validate_inv_tr,
  5544.                               inverse_translate,
  5545.                               translate,
  5546.                               c);
  5547.               rx_bitset_union (rxb->rx.local_cset_size, cs, it);
  5548.             }
  5549.                   }
  5550.               }
  5551.  
  5552.       finalize_class_and_append:
  5553.         if (is_inverted)
  5554.           {
  5555.         rx_bitset_complement (rxb->rx.local_cset_size, cs);
  5556.         if (syntax & RE_HAT_LISTS_NOT_NEWLINE)
  5557.           RX_bitset_remove (cs, '\n');
  5558.           }
  5559.         goto append_node;
  5560.           }
  5561.           break;
  5562.  
  5563.  
  5564.     case '(':
  5565.           if (syntax & RE_NO_BK_PARENS)
  5566.             goto handle_open;
  5567.           else
  5568.             goto normal_char;
  5569.  
  5570.  
  5571.         case ')':
  5572.           if (syntax & RE_NO_BK_PARENS)
  5573.             goto handle_close;
  5574.           else
  5575.             goto normal_char;
  5576.  
  5577.  
  5578.         case '\n':
  5579.           if (syntax & RE_NEWLINE_ALT)
  5580.             goto handle_alt;
  5581.           else
  5582.             goto normal_char;
  5583.  
  5584.  
  5585.     case '|':
  5586.           if (syntax & RE_NO_BK_VBAR)
  5587.             goto handle_alt;
  5588.           else
  5589.             goto normal_char;
  5590.  
  5591.  
  5592.         case '{':
  5593.       if ((syntax & RE_INTERVALS) && (syntax & RE_NO_BK_BRACES))
  5594.         goto handle_interval;
  5595.       else
  5596.         goto normal_char;
  5597.  
  5598.  
  5599.         case '\\':
  5600.           if (p == pend) return REG_EESCAPE;
  5601.  
  5602.           /* Do not translate the character after the \, so that we can
  5603.              distinguish, e.g., \B from \b, even if we normally would
  5604.              translate, e.g., B to b.  */
  5605.           PATFETCH_RAW (c);
  5606.  
  5607.           switch (c)
  5608.             {
  5609.             case '(':
  5610.               if (syntax & RE_NO_BK_PARENS)
  5611.                 goto normal_backslash;
  5612.  
  5613.             handle_open:
  5614.               rxb->re_nsub++;
  5615.               regnum++;
  5616.               if (COMPILE_STACK_FULL)
  5617.                 { 
  5618.                   RETALLOC (compile_stack.stack, compile_stack.size << 1,
  5619.                             compile_stack_elt_t);
  5620.                   if (compile_stack.stack == 0) return REG_ESPACE;
  5621.  
  5622.                   compile_stack.size <<= 1;
  5623.                 }
  5624.  
  5625.           if (*last_expression)
  5626.         {
  5627.           struct rexp_node * concat
  5628.             = rx_mk_r_concat (&rxb->rx, *last_expression, 0);
  5629.           if (!concat)
  5630.             return REG_ESPACE;
  5631.           *last_expression = concat;
  5632.           last_expression = &concat->params.pair.right;
  5633.         }
  5634.  
  5635.               /*
  5636.            * These are the values to restore when we hit end of this
  5637.                * group.  
  5638.            */
  5639.           COMPILE_STACK_TOP.top_expression = top_expression;
  5640.           COMPILE_STACK_TOP.last_expression = last_expression;
  5641.               COMPILE_STACK_TOP.regnum = regnum;
  5642.           
  5643.               compile_stack.avail++;
  5644.           
  5645.           top_expression = last_expression;
  5646.           break;
  5647.  
  5648.  
  5649.             case ')':
  5650.               if (syntax & RE_NO_BK_PARENS) goto normal_backslash;
  5651.  
  5652.             handle_close:
  5653.               /* See similar code for backslashed left paren above.  */
  5654.               if (COMPILE_STACK_EMPTY)
  5655.                 if (syntax & RE_UNMATCHED_RIGHT_PAREN_ORD)
  5656.                   goto normal_char;
  5657.                 else
  5658.                   return REG_ERPAREN;
  5659.  
  5660.               /* Since we just checked for an empty stack above, this
  5661.                  ``can't happen''.  */
  5662.  
  5663.               {
  5664.                 /* We don't just want to restore into `regnum', because
  5665.                    later groups should continue to be numbered higher,
  5666.                    as in `(ab)c(de)' -- the second group is #2.  */
  5667.                 regnum_t this_group_regnum;
  5668.         struct rexp_node ** inner = top_expression;
  5669.  
  5670.                 compile_stack.avail--;
  5671.         top_expression = COMPILE_STACK_TOP.top_expression;
  5672.         last_expression = COMPILE_STACK_TOP.last_expression;
  5673.                 this_group_regnum = COMPILE_STACK_TOP.regnum;
  5674.         {
  5675.           int left_se = paramc;
  5676.           int right_se = paramc + 1;
  5677.  
  5678.           params = (params
  5679.                 ? ((struct re_se_params *)
  5680.                    realloc (params,
  5681.                     (paramc + 2) * sizeof (params[0])))
  5682.                 : ((struct re_se_params *)
  5683.                    malloc (2 * sizeof (params[0]))));
  5684.           if (!params)
  5685.             return REG_ESPACE;
  5686.           paramc += 2;
  5687.  
  5688.           params[left_se].se = re_se_lparen;
  5689.           params[left_se].op1 = this_group_regnum;
  5690.           params[right_se].se = re_se_rparen;
  5691.           params[right_se].op1 = this_group_regnum;
  5692.           {
  5693.             struct rexp_node * left
  5694.               = rx_mk_r_side_effect (&rxb->rx,
  5695.                          (rx_side_effect)left_se);
  5696.             struct rexp_node * right
  5697.               = rx_mk_r_side_effect (&rxb->rx,
  5698.                          (rx_side_effect)right_se);
  5699.             struct rexp_node * c1
  5700.               = (*inner
  5701.              ? rx_mk_r_concat (&rxb->rx, left, *inner) : left);
  5702.             struct rexp_node * c2
  5703.               = rx_mk_r_concat (&rxb->rx, c1, right);
  5704.             if (!(left && right && c1 && c2))
  5705.               return REG_ESPACE;
  5706.             *inner = c2;
  5707.           }
  5708.         }
  5709.         break;
  5710.           }
  5711.  
  5712.             case '|':                    /* `\|'.  */
  5713.               if ((syntax & RE_LIMITED_OPS) || (syntax & RE_NO_BK_VBAR))
  5714.                 goto normal_backslash;
  5715.             handle_alt:
  5716.               if (syntax & RE_LIMITED_OPS)
  5717.                 goto normal_char;
  5718.  
  5719.           {
  5720.         struct rexp_node * alt
  5721.           = rx_mk_r_alternate (&rxb->rx, *top_expression, 0);
  5722.         if (!alt)
  5723.           return REG_ESPACE;
  5724.         *top_expression = alt;
  5725.         last_expression = &alt->params.pair.right;
  5726.         {
  5727.           int sync_se = paramc;
  5728.  
  5729.           params = (params
  5730.                 ? ((struct re_se_params *)
  5731.                    realloc (params,
  5732.                     (paramc + 1) * sizeof (params[0])))
  5733.                 : ((struct re_se_params *)
  5734.                    malloc (sizeof (params[0]))));
  5735.           if (!params)
  5736.             return REG_ESPACE;
  5737.           ++paramc;
  5738.  
  5739.           params[sync_se].se = re_se_tv;
  5740.           {
  5741.             struct rexp_node * sync
  5742.               = rx_mk_r_side_effect (&rxb->rx,
  5743.                          (rx_side_effect)sync_se);
  5744.             struct rexp_node * conc
  5745.               = rx_mk_r_concat (&rxb->rx, sync, 0);
  5746.  
  5747.             if (!sync || !conc)
  5748.               return REG_ESPACE;
  5749.  
  5750.             *last_expression = conc;
  5751.             last_expression = &conc->params.pair.right;
  5752.           }
  5753.         }
  5754.           }
  5755.               break;
  5756.  
  5757.  
  5758.             case '{': 
  5759.               /* If \{ is a literal.  */
  5760.               if (!(syntax & RE_INTERVALS)
  5761.                      /* If we're at `\{' and it's not the open-interval 
  5762.                         operator.  */
  5763.                   || ((syntax & RE_INTERVALS) && (syntax & RE_NO_BK_BRACES))
  5764.                   || (p - 2 == pattern  &&  p == pend))
  5765.                 goto normal_backslash;
  5766.  
  5767.             handle_interval:
  5768.               {
  5769.                 /* If got here, then the syntax allows intervals.  */
  5770.  
  5771.                 /* At least (most) this many matches must be made.  */
  5772.                 int lower_bound = -1, upper_bound = -1;
  5773.  
  5774.                 beg_interval = p - 1;
  5775.  
  5776.                 if (p == pend)
  5777.                   {
  5778.                     if (syntax & RE_NO_BK_BRACES)
  5779.                       goto unfetch_interval;
  5780.                     else
  5781.                       return REG_EBRACE;
  5782.                   }
  5783.  
  5784.                 GET_UNSIGNED_NUMBER (lower_bound);
  5785.  
  5786.                 if (c == ',')
  5787.                   {
  5788.                     GET_UNSIGNED_NUMBER (upper_bound);
  5789.                     if (upper_bound < 0) upper_bound = RE_DUP_MAX;
  5790.                   }
  5791.                 else
  5792.                   /* Interval such as `{1}' => match exactly once. */
  5793.                   upper_bound = lower_bound;
  5794.  
  5795.                 if (lower_bound < 0 || upper_bound > RE_DUP_MAX
  5796.                     || lower_bound > upper_bound)
  5797.                   {
  5798.                     if (syntax & RE_NO_BK_BRACES)
  5799.                       goto unfetch_interval;
  5800.                     else 
  5801.                       return REG_BADBR;
  5802.                   }
  5803.  
  5804.                 if (!(syntax & RE_NO_BK_BRACES)) 
  5805.                   {
  5806.                     if (c != '\\') return REG_EBRACE;
  5807.                     PATFETCH (c);
  5808.                   }
  5809.  
  5810.                 if (c != '}')
  5811.                   {
  5812.                     if (syntax & RE_NO_BK_BRACES)
  5813.                       goto unfetch_interval;
  5814.                     else 
  5815.                       return REG_BADBR;
  5816.                   }
  5817.  
  5818.                 /* We just parsed a valid interval.  */
  5819.  
  5820.                 /* If it's invalid to have no preceding re.  */
  5821.                 if (pointless_if_repeated (*last_expression, params))
  5822.                   {
  5823.                     if (syntax & RE_CONTEXT_INVALID_OPS)
  5824.                       return REG_BADRPT;
  5825.                     else if (!(syntax & RE_CONTEXT_INDEP_OPS))
  5826.                       goto unfetch_interval;
  5827.             /* was: else laststart = b; */
  5828.                   }
  5829.  
  5830.                 /* If the upper bound is zero, don't want to iterate
  5831.                  * at all.
  5832.          */
  5833.                  if (upper_bound == 0)
  5834.            {
  5835.              if (*last_expression)
  5836.                {
  5837.              rx_free_rexp (&rxb->rx, *last_expression);
  5838.              *last_expression = 0;
  5839.                }
  5840.            }
  5841.         else
  5842.           /* Otherwise, we have a nontrivial interval. */
  5843.           {
  5844.             int iter_se = paramc;
  5845.             int end_se = paramc + 1;
  5846.             params = (params
  5847.                   ? ((struct re_se_params *)
  5848.                  realloc (params,
  5849.                       sizeof (*params) * (2 + paramc)))
  5850.                   : ((struct re_se_params *)
  5851.                  malloc (2 * sizeof (*params))));
  5852.             if (!params)
  5853.               return REG_ESPACE;
  5854.             paramc += 2;
  5855.             params [iter_se].se = re_se_iter;
  5856.             params [iter_se].op1 = lower_bound;
  5857.             params[iter_se].op2 = upper_bound;
  5858.  
  5859.             params[end_se].se = re_se_end_iter;
  5860.             params[end_se].op1 = lower_bound;
  5861.             params[end_se].op2 = upper_bound;
  5862.             {
  5863.               struct rexp_node * push0
  5864.             = rx_mk_r_side_effect (&rxb->rx,
  5865.                            (rx_side_effect)re_se_push0);
  5866.               struct rexp_node * start_one_iter
  5867.             = rx_mk_r_side_effect (&rxb->rx,
  5868.                            (rx_side_effect)iter_se);
  5869.               struct rexp_node * phase1
  5870.             = rx_mk_r_concat (&rxb->rx, start_one_iter,
  5871.                       *last_expression);
  5872.               struct rexp_node * pushback
  5873.             = rx_mk_r_side_effect (&rxb->rx,
  5874.                            (rx_side_effect)re_se_pushback);
  5875.               rx_Bitset cs = rx_cset (&rxb->rx);
  5876.               struct rexp_node * lit_t
  5877.             = rx_mk_r_cset (&rxb->rx, cs);
  5878.               struct rexp_node * phase2
  5879.             = rx_mk_r_concat (&rxb->rx, pushback, lit_t);
  5880.               struct rexp_node * loop
  5881.             = rx_mk_r_2phase_star (&rxb->rx, phase1, phase2);
  5882.               struct rexp_node * push_n_loop
  5883.             = rx_mk_r_concat (&rxb->rx, push0, loop);
  5884.               struct rexp_node * final_test
  5885.             = rx_mk_r_side_effect (&rxb->rx,
  5886.                            (rx_side_effect)end_se);
  5887.               struct rexp_node * full_exp
  5888.             = rx_mk_r_concat (&rxb->rx, push_n_loop, final_test);
  5889.  
  5890.               if (!(push0 && start_one_iter && phase1
  5891.                 && pushback && lit_t && phase2
  5892.                 && loop && push_n_loop && final_test && full_exp))
  5893.             return REG_ESPACE;
  5894.  
  5895.               RX_bitset_enjoin(cs, 't');
  5896.  
  5897.               *last_expression = full_exp;
  5898.             }
  5899.           }
  5900.                 beg_interval = 0;
  5901.               }
  5902.               break;
  5903.  
  5904.             unfetch_interval:
  5905.               /* If an invalid interval, match the characters as literals.  */
  5906.                p = beg_interval;
  5907.                beg_interval = NULL;
  5908.  
  5909.                /* normal_char and normal_backslash need `c'.  */
  5910.                PATFETCH (c);    
  5911.  
  5912.                if (!(syntax & RE_NO_BK_BRACES))
  5913.                  {
  5914.                    if (p > pattern  &&  p[-1] == '\\')
  5915.                      goto normal_backslash;
  5916.                  }
  5917.                goto normal_char;
  5918.  
  5919. #ifdef emacs
  5920.             /* There is no way to specify the before_dot and after_dot
  5921.                operators.  rms says this is ok.  --karl  */
  5922.             case '=':
  5923.           side = at_dot;
  5924.           goto add_side_effect;
  5925.               break;
  5926.  
  5927.             case 's':
  5928.         case 'S':
  5929.           {
  5930.         rx_Bitset cs = cset (&rxb->rx);
  5931.         struct rexp_node * set = rx_mk_r_cset (&rxb->rx, cs);
  5932.         if (!(cs && set))
  5933.           return REG_ESPACE;
  5934.         if (c == 'S')
  5935.           rx_bitset_universe (rxb->rx.local_cset_size, cs);
  5936.  
  5937.         PATFETCH (c);
  5938.         {
  5939.           int x;
  5940.           char code = syntax_spec_code (c);
  5941.           for (x = 0; x < 256; ++x)
  5942.             {
  5943.               
  5944.               if (SYNTAX (x) & code)
  5945.             {
  5946.               rx_Bitset it =
  5947.                 inverse_translation (rxb, validate_inv_tr,
  5948.                          inverse_translate,
  5949.                          translate, x);
  5950.               rx_bitset_xor (rxb->rx.local_cset_size, cs, it);
  5951.             }
  5952.             }
  5953.         }
  5954.         goto append_node;
  5955.           }
  5956.               break;
  5957. #endif /* emacs */
  5958.  
  5959.  
  5960.             case 'w':
  5961.             case 'W':
  5962.           {
  5963.         rx_Bitset cs = rx_cset (&rxb->rx);
  5964.         struct rexp_node * n = (cs ? rx_mk_r_cset (&rxb->rx, cs) : 0);
  5965.         if (!(cs && n))
  5966.           return REG_ESPACE;
  5967.         if (c == 'W')
  5968.           rx_bitset_universe (rxb->rx.local_cset_size ,cs);
  5969.         {
  5970.           int x;
  5971.           for (x = rxb->rx.local_cset_size - 1; x > 0; --x)
  5972.             if (re_syntax_table[x] & Sword)
  5973.               RX_bitset_toggle (cs, x);
  5974.         }
  5975.         append = n;
  5976.         goto append_node;
  5977.           }
  5978.               break;
  5979.  
  5980. /* With a little extra work, some of these side effects could be optimized
  5981.  * away (basicly by looking at what we already know about the surrounding
  5982.  * chars).  
  5983.  */
  5984.             case '<':
  5985.           side = (rx_side_effect)re_se_wordbeg;
  5986.           goto add_side_effect;
  5987.               break;
  5988.  
  5989.             case '>':
  5990.               side = (rx_side_effect)re_se_wordend;
  5991.           goto add_side_effect;
  5992.               break;
  5993.  
  5994.             case 'b':
  5995.               side = (rx_side_effect)re_se_wordbound;
  5996.           goto add_side_effect;
  5997.               break;
  5998.  
  5999.             case 'B':
  6000.               side = (rx_side_effect)re_se_notwordbound;
  6001.           goto add_side_effect;
  6002.               break;
  6003.  
  6004.             case '`':
  6005.           side = (rx_side_effect)re_se_begbuf;
  6006.           goto add_side_effect;
  6007.           break;
  6008.           
  6009.             case '\'':
  6010.           side = (rx_side_effect)re_se_endbuf;
  6011.           goto add_side_effect;
  6012.               break;
  6013.  
  6014.         add_side_effect:
  6015.           {
  6016.         struct rexp_node * se
  6017.           = rx_mk_r_side_effect (&rxb->rx, side);
  6018.         if (!se)
  6019.           return REG_ESPACE;
  6020.         append = se;
  6021.         goto append_node;
  6022.           }
  6023.           break;
  6024.  
  6025.             case '1': case '2': case '3': case '4': case '5':
  6026.             case '6': case '7': case '8': case '9':
  6027.               if (syntax & RE_NO_BK_REFS)
  6028.                 goto normal_char;
  6029.  
  6030.               c1 = c - '0';
  6031.  
  6032.               if (c1 > regnum)
  6033.                 return REG_ESUBREG;
  6034.  
  6035.               /* Can't back reference to a subexpression if inside of it.  */
  6036.               if (group_in_compile_stack (compile_stack, c1))
  6037.         return REG_ESUBREG;
  6038.  
  6039.           {
  6040.         int backref_se = paramc;
  6041.         params = (params
  6042.               ? ((struct re_se_params *)
  6043.                  realloc (params,
  6044.                       sizeof (*params) * (1 + paramc)))
  6045.               : ((struct re_se_params *)
  6046.                  malloc (sizeof (*params))));
  6047.         if (!params)
  6048.           return REG_ESPACE;
  6049.         ++paramc;
  6050.         params[backref_se].se = re_se_backref;
  6051.         params[backref_se].op1 = c1;
  6052.         side = (rx_side_effect)backref_se;
  6053.         goto add_side_effect;
  6054.           }
  6055.               break;
  6056.  
  6057.             case '+':
  6058.             case '?':
  6059.               if (syntax & RE_BK_PLUS_QM)
  6060.                 goto handle_plus;
  6061.               else
  6062.                 goto normal_backslash;
  6063.  
  6064.             default:
  6065.             normal_backslash:
  6066.               /* You might think it would be useful for \ to mean
  6067.                  not to translate; but if we don't translate it
  6068.                  it will never match anything.  */
  6069.               c = TRANSLATE (c);
  6070.               goto normal_char;
  6071.             }
  6072.           break;
  6073.  
  6074.  
  6075.     default:
  6076.         /* Expects the character in `c'.  */
  6077.     normal_char:
  6078.         {
  6079.           rx_Bitset cs = rx_cset(&rxb->rx);
  6080.           struct rexp_node * match = rx_mk_r_cset (&rxb->rx, cs);
  6081.           rx_Bitset it;
  6082.           if (!(cs && match))
  6083.         return REG_ESPACE;
  6084.           it = inverse_translation (rxb, validate_inv_tr,
  6085.                     inverse_translate, translate, c);
  6086.           rx_bitset_union (CHAR_SET_SIZE, cs, it);
  6087.           append = match;
  6088.  
  6089.         append_node:
  6090.           /* This genericly appends the rexp APPEND to *LAST_EXPRESSION
  6091.            * and then parses the next character normally.
  6092.            */
  6093.           if (*last_expression)
  6094.         {
  6095.           struct rexp_node * concat
  6096.             = rx_mk_r_concat (&rxb->rx, *last_expression, append);
  6097.           if (!concat)
  6098.             return REG_ESPACE;
  6099.           *last_expression = concat;
  6100.           last_expression = &concat->params.pair.right;
  6101.         }
  6102.           else
  6103.         *last_expression = append;
  6104.         }
  6105.     } /* switch (c) */
  6106.     } /* while p != pend */
  6107.  
  6108.   
  6109.   {
  6110.     int win_se = paramc;
  6111.     params = (params
  6112.           ? ((struct re_se_params *)
  6113.          realloc (params,
  6114.               sizeof (*params) * (1 + paramc)))
  6115.           : ((struct re_se_params *)
  6116.          malloc (sizeof (*params))));
  6117.     if (!params)
  6118.       return REG_ESPACE;
  6119.     ++paramc;
  6120.     params[win_se].se = re_se_win;
  6121.     {
  6122.       struct rexp_node * se
  6123.     = rx_mk_r_side_effect (&rxb->rx, (rx_side_effect)win_se);
  6124.       struct rexp_node * concat
  6125.     = rx_mk_r_concat (&rxb->rx, rexp, se);
  6126.       if (!(se && concat))
  6127.     return REG_ESPACE;
  6128.       rexp = concat;
  6129.     }
  6130.   }
  6131.  
  6132.  
  6133.   /* Through the pattern now.  */
  6134.  
  6135.   if (!COMPILE_STACK_EMPTY) 
  6136.     return REG_EPAREN;
  6137.  
  6138.       free (compile_stack.stack);
  6139.  
  6140.   orig_rexp = rexp;
  6141. #ifdef RX_DEBUG
  6142.   if (rx_debug_compile)
  6143.     {
  6144.       dbug_rxb = rxb;
  6145.       fputs ("\n\nCompiling ", stdout);
  6146.       fwrite (pattern, 1, size, stdout);
  6147.       fputs (":\n", stdout);
  6148.       rxb->se_params = params;
  6149.       print_rexp (&rxb->rx, orig_rexp, 2, re_seprint, stdout);
  6150.     }
  6151. #endif
  6152.   {
  6153.     rx_Bitset cs = rx_cset(&rxb->rx);
  6154.     rx_Bitset cs2 = rx_cset(&rxb->rx);
  6155.     char * se_map = (char *) alloca (paramc);
  6156.     struct rexp_node * new_rexp = 0;
  6157.  
  6158.  
  6159.     bzero (se_map, paramc);
  6160.     find_backrefs (se_map, rexp, params);
  6161.     fewer_side_effects =
  6162.       remove_unecessary_side_effects (&rxb->rx, se_map,
  6163.                       rx_copy_rexp (&rxb->rx, rexp), params);
  6164.  
  6165.     speed_up_alt (&rxb->rx, rexp, 0);
  6166.     speed_up_alt (&rxb->rx, fewer_side_effects, 1);
  6167.  
  6168.     {
  6169.       char * syntax_parens = rxb->syntax_parens;
  6170.       if (syntax_parens == (char *)0x1)
  6171.     rexp = remove_unecessary_side_effects
  6172.       (&rxb->rx, se_map, rexp, params);
  6173.       else if (syntax_parens)
  6174.     {
  6175.       int x;
  6176.       for (x = 0; x < paramc; ++x)
  6177.         if ((   (params[x].se == re_se_lparen)
  6178.          || (params[x].se == re_se_rparen))
  6179.         && (!syntax_parens [params[x].op1]))
  6180.           se_map [x] = 1;
  6181.       rexp = remove_unecessary_side_effects
  6182.         (&rxb->rx, se_map, rexp, params);
  6183.     }
  6184.     }
  6185.  
  6186.     /* At least one more optimization would be nice to have here but i ran out 
  6187.      * of time.  The idea would be to delay side effects.  
  6188.      * For examle, `(abc)' is the same thing as `abc()' except that the
  6189.      * left paren is offset by 3 (which we know at compile time).
  6190.      * (In this comment, write that second pattern `abc(:3:)' 
  6191.      * where `(:3:' is a syntactic unit.)
  6192.      *
  6193.      * Trickier:  `(abc|defg)'  is the same as `(abc(:3:|defg(:4:))'
  6194.      * (The paren nesting may be hard to follow -- that's an alternation
  6195.      *    of `abc(:3:' and `defg(:4:' inside (purely syntactic) parens
  6196.      *  followed by the closing paren from the original expression.)
  6197.      *
  6198.      * Neither the expression tree representation nor the the nfa make
  6199.      * this very easy to write. :(
  6200.      */
  6201.  
  6202.   /* What we compile is different than what the parser returns.
  6203.    * Suppose the parser returns expression R.
  6204.    * Let R' be R with unnecessary register assignments removed 
  6205.    * (see REMOVE_UNECESSARY_SIDE_EFFECTS, above).
  6206.    *
  6207.    * What we will compile is the expression:
  6208.    *
  6209.    *    m{try}R{win}\|s{try}R'{win}
  6210.    *
  6211.    * {try} and {win} denote side effect epsilons (see EXPLORE_FUTURE).
  6212.    * 
  6213.    * When trying a match, we insert an `m' at the beginning of the 
  6214.    * string if the user wants registers to be filled, `s' if not.
  6215.    */
  6216.     new_rexp =
  6217.       rx_mk_r_alternate
  6218.     (&rxb->rx,
  6219.      rx_mk_r_concat (&rxb->rx, rx_mk_r_cset (&rxb->rx, cs2), rexp),
  6220.      rx_mk_r_concat (&rxb->rx,
  6221.              rx_mk_r_cset (&rxb->rx, cs), fewer_side_effects));
  6222.  
  6223.     if (!(new_rexp && cs && cs2))
  6224.       return REG_ESPACE;
  6225.     RX_bitset_enjoin (cs2, '\0'); /* prefixed to the rexp used for matching. */
  6226.     RX_bitset_enjoin (cs, '\1'); /* prefixed to the rexp used for searching. */
  6227.     rexp = new_rexp;
  6228.   }
  6229.  
  6230. #ifdef RX_DEBUG
  6231.   if (rx_debug_compile)
  6232.     {
  6233.       fputs ("\n...which is compiled as:\n", stdout);
  6234.       print_rexp (&rxb->rx, rexp, 2, re_seprint, stdout);
  6235.     }
  6236. #endif
  6237.   {
  6238.     struct rx_nfa_state *start = 0;
  6239.     struct rx_nfa_state *end = 0;
  6240.  
  6241.     if (!rx_build_nfa (&rxb->rx, rexp, &start, &end))
  6242.       return REG_ESPACE;    /*  */
  6243.     else
  6244.       {
  6245.     void * mem = (void *)rxb->buffer;
  6246.     unsigned long size = rxb->allocated;
  6247.     int start_id;
  6248.     char * perm_mem;
  6249.     int iterator_size = paramc * sizeof (params[0]);
  6250.  
  6251.     end->is_final = 1;
  6252.     start->is_start = 1;
  6253.     rx_name_nfa_states (&rxb->rx);
  6254.     start_id = start->id;
  6255. #ifdef RX_DEBUG
  6256.     if (rx_debug_compile)
  6257.       {
  6258.         fputs ("...giving the NFA: \n", stdout);
  6259.         dbug_rxb = rxb;
  6260.         print_nfa (&rxb->rx, rxb->rx.nfa_states, re_seprint, stdout);
  6261.       }
  6262. #endif
  6263.     if (!rx_eclose_nfa (&rxb->rx))
  6264.       return REG_ESPACE;
  6265.     else
  6266.       {
  6267.         rx_delete_epsilon_transitions (&rxb->rx);
  6268.         
  6269.         /* For compatability reasons, we need to shove the
  6270.          * compiled nfa into one chunk of malloced memory.
  6271.          */
  6272.         rxb->rx.reserved = (   sizeof (params[0]) * paramc
  6273.                 +  rx_sizeof_bitset (rxb->rx.local_cset_size));
  6274. #ifdef RX_DEBUG
  6275.         if (rx_debug_compile)
  6276.           {
  6277.         dbug_rxb = rxb;
  6278.         fputs ("...which cooks down (uncompactified) to: \n", stdout);
  6279.         print_nfa (&rxb->rx, rxb->rx.nfa_states, re_seprint, stdout);
  6280.           }
  6281. #endif
  6282.         if (!rx_compactify_nfa (&rxb->rx, &mem, &size))
  6283.           return REG_ESPACE;
  6284.         rxb->buffer = mem;
  6285.         rxb->allocated = size;
  6286.         rxb->rx.buffer = mem;
  6287.         rxb->rx.allocated = size;
  6288.         perm_mem = ((char *)rxb->rx.buffer
  6289.             + rxb->rx.allocated - rxb->rx.reserved);
  6290.         rxb->se_params = ((struct re_se_params *)perm_mem);
  6291.         bcopy (params, rxb->se_params, iterator_size);
  6292.         perm_mem += iterator_size;
  6293.         rxb->fastset = (rx_Bitset) perm_mem;
  6294.         rxb->start = rx_id_to_nfa_state (&rxb->rx, start_id);
  6295.       }
  6296.     rx_bitset_null (rxb->rx.local_cset_size, rxb->fastset);
  6297.     rxb->can_match_empty = compute_fastset (rxb, orig_rexp);
  6298.     rxb->match_regs_on_stack =
  6299.       registers_on_stack (rxb, orig_rexp, 0, params); 
  6300.     rxb->search_regs_on_stack =
  6301.       registers_on_stack (rxb, fewer_side_effects, 0, params);
  6302.     if (rxb->can_match_empty)
  6303.       rx_bitset_universe (rxb->rx.local_cset_size, rxb->fastset);
  6304.     rxb->is_anchored = is_anchored (orig_rexp, (rx_side_effect) re_se_hat);
  6305.     rxb->begbuf_only = is_anchored (orig_rexp,
  6306.                     (rx_side_effect) re_se_begbuf);
  6307.       }
  6308.     rx_free_rexp (&rxb->rx, rexp);
  6309.     if (params)
  6310.       free (params);
  6311. #ifdef RX_DEBUG
  6312.     if (rx_debug_compile)
  6313.       {
  6314.     dbug_rxb = rxb;
  6315.     fputs ("...which cooks down to: \n", stdout);
  6316.     print_nfa (&rxb->rx, rxb->rx.nfa_states, re_seprint, stdout);
  6317.       }
  6318. #endif
  6319.   }
  6320.   return REG_NOERROR;
  6321. }
  6322.  
  6323.  
  6324.  
  6325. /* This table gives an error message for each of the error codes listed
  6326.    in regex.h.  Obviously the order here has to be same as there.  */
  6327.  
  6328. const char * rx_error_msg[] =
  6329. { 0,                        /* REG_NOERROR */
  6330.     "No match",                    /* REG_NOMATCH */
  6331.     "Invalid regular expression",        /* REG_BADPAT */
  6332.     "Invalid collation character",        /* REG_ECOLLATE */
  6333.     "Invalid character class name",        /* REG_ECTYPE */
  6334.     "Trailing backslash",            /* REG_EESCAPE */
  6335.     "Invalid back reference",            /* REG_ESUBREG */
  6336.     "Unmatched [ or [^",            /* REG_EBRACK */
  6337.     "Unmatched ( or \\(",            /* REG_EPAREN */
  6338.     "Unmatched \\{",                /* REG_EBRACE */
  6339.     "Invalid content of \\{\\}",        /* REG_BADBR */
  6340.     "Invalid range end",            /* REG_ERANGE */
  6341.     "Memory exhausted",                /* REG_ESPACE */
  6342.     "Invalid preceding regular expression",    /* REG_BADRPT */
  6343.     "Premature end of regular expression",    /* REG_EEND */
  6344.     "Regular expression too big",        /* REG_ESIZE */
  6345.     "Unmatched ) or \\)",            /* REG_ERPAREN */
  6346. };
  6347.  
  6348.  
  6349.  
  6350. /* Test if at very beginning or at very end of the virtual concatenation
  6351.  *  of `string1' and `string2'.  If only one string, it's `string2'.  
  6352.  */
  6353.  
  6354. #define AT_STRINGS_BEG() \
  6355.   (string1 \
  6356.    ? ((tst_half == 0) \
  6357.       && ((unsigned char *)tst_pos == (unsigned char *)string1 - 1)) \
  6358.    : ((unsigned char *)tst_pos == (unsigned char *)string2 - 1))
  6359.  
  6360. #define AT_STRINGS_END() \
  6361.   (string2 \
  6362.    ? ((tst_half == 1) \
  6363.       && ((unsigned char *)tst_pos \
  6364.       == ((unsigned char *)string2 + size2 - 1))) \
  6365.    : ((unsigned char *)tst_pos == ((unsigned char *)string1 + size1 - 1)))
  6366.  
  6367. /* Test if D points to a character which is word-constituent.  We have
  6368.  * two special cases to check for: if past the end of string1, look at
  6369.  * the first character in string2; and if before the beginning of
  6370.  * string2, look at the last character in string1.
  6371.  *
  6372.  * Assumes `string1' exists, so use in conjunction with AT_STRINGS_BEG ().  
  6373.  */
  6374. #define LETTER_P(d)                            \
  6375.   (SYNTAX ((string2 && (tst_half == 0)                    \
  6376.         && ((d) == ((unsigned char *)string1 + size1)))        \
  6377.        ? *(unsigned char *)string2                    \
  6378.        : ((string1 && (tst_half == 1)                \
  6379.            && ((d) == (unsigned char *)string2 - 1))        \
  6380.           ? *((unsigned char *)string1 + size1 - 1)            \
  6381.           : *(d))) == Sword)
  6382.  
  6383. /* Test if the character at D and the one after D differ with respect
  6384.  * to being word-constituent.  
  6385.  */
  6386. #define AT_WORD_BOUNDARY(d)                        \
  6387.   (AT_STRINGS_BEG () || AT_STRINGS_END () || LETTER_P (d) != LETTER_P (d + 1))
  6388.  
  6389.  
  6390. static char slowmap [256] =
  6391. {
  6392.   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  6393.   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  6394.   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  6395.   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  6396.   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  6397.   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  6398.   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  6399.   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  6400.   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  6401.   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  6402.   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  6403.   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  6404.   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  6405.   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  6406.   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  6407.   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  6408. };
  6409.  
  6410. #ifdef __STDC__
  6411. static void
  6412. rx_blow_up_fastmap (struct re_pattern_buffer * rxb)
  6413. #else
  6414. static void
  6415. rx_blow_up_fastmap (rxb)
  6416.      struct re_pattern_buffer * rxb;
  6417. #endif
  6418. {
  6419.   int x;
  6420.   for (x = 0; x < 256; ++x)    /* &&&& 3.6 % */
  6421.     rxb->fastmap [x] = !!RX_bitset_member (rxb->fastset, x);
  6422.   rxb->fastmap_accurate = 1;
  6423. }
  6424.  
  6425.  
  6426.  
  6427.  
  6428. struct stack_chunk
  6429. {
  6430.   struct stack_chunk * next_chunk;
  6431.   int bytes_left;
  6432.   char * sp;
  6433. };
  6434.  
  6435. #define PUSH(CHUNK_VAR,BYTES)   \
  6436.   if (!CHUNK_VAR || (CHUNK_VAR->bytes_left < (BYTES)))  \
  6437.     {                    \
  6438.       struct stack_chunk * new_chunk;    \
  6439.       if (free_chunks)            \
  6440.     {                \
  6441.       new_chunk = free_chunks;    \
  6442.       free_chunks = free_chunks->next_chunk; \
  6443.     }                \
  6444.       else                \
  6445.     {                \
  6446.       new_chunk = (struct stack_chunk *)alloca (chunk_bytes); \
  6447.       if (!new_chunk)        \
  6448.         {                \
  6449.           ret_val = 0;        \
  6450.           goto test_do_return;    \
  6451.         }                \
  6452.     }                \
  6453.       new_chunk->sp = (char *)new_chunk + sizeof (struct stack_chunk); \
  6454.       new_chunk->bytes_left = (chunk_bytes \
  6455.                    - (BYTES) \
  6456.                    - sizeof (struct stack_chunk)); \
  6457.       new_chunk->next_chunk = CHUNK_VAR; \
  6458.       CHUNK_VAR = new_chunk;        \
  6459.     } \
  6460.   else \
  6461.     (CHUNK_VAR->sp += (BYTES)), (CHUNK_VAR->bytes_left -= (BYTES))
  6462.  
  6463. #define POP(CHUNK_VAR,BYTES) \
  6464.   if (CHUNK_VAR->sp == ((char *)CHUNK_VAR + sizeof(*CHUNK_VAR))) \
  6465.     { \
  6466.       struct stack_chunk * new_chunk = CHUNK_VAR->next_chunk; \
  6467.       CHUNK_VAR->next_chunk = free_chunks; \
  6468.       free_chunks = CHUNK_VAR; \
  6469.       CHUNK_VAR = new_chunk; \
  6470.     } \
  6471.   else \
  6472.     (CHUNK_VAR->sp -= BYTES), (CHUNK_VAR->bytes_left += BYTES)
  6473.  
  6474. struct counter_frame
  6475. {
  6476.   int tag;
  6477.   int val;
  6478.   struct counter_frame * inherited_from; /* If this is a copy. */
  6479.   struct counter_frame * cdr;
  6480. };
  6481.  
  6482. struct backtrack_frame
  6483. {
  6484.   char * counter_stack_sp;
  6485.  
  6486.   /* A frame is used to save the matchers state when it crosses a 
  6487.    * backtracking point.  The `stk_' fields correspond to variables
  6488.    * in re_search_2 (just strip off thes `stk_').  They are documented
  6489.    * tere.
  6490.    */
  6491.   struct rx_superstate * stk_super;
  6492.   const unsigned char * stk_tst_pos;
  6493.   int stk_tst_half;
  6494.   unsigned int stk_c;
  6495.   const unsigned char * stk_tst_str_half;
  6496.   const unsigned char * stk_tst_end_half;
  6497.   int stk_last_l;
  6498.   int stk_last_r;
  6499.   int stk_test_ret;
  6500.  
  6501.   /* This is the list of options left to explore at the backtrack
  6502.    * point for which this frame was created. 
  6503.    */
  6504.   struct rx_distinct_future * df;
  6505.   struct rx_distinct_future * first_df;
  6506.  
  6507. #ifdef RX_DEBUG
  6508.    int stk_line_no;
  6509. #endif
  6510. };
  6511.  
  6512.  
  6513.  
  6514. #if !defined(REGEX_MALLOC) && !defined(__GNUC__)
  6515. #define RE_SEARCH_2_FN    inner_re_search_2
  6516. #else
  6517. #define RE_SEARCH_2_FN    re_search_2
  6518. #endif
  6519.  
  6520. #ifdef __STDC__
  6521. int
  6522. RE_SEARCH_2_FN (struct re_pattern_buffer *rxb,
  6523.         const char * string1, int size1,
  6524.         const char * string2, int size2,
  6525.         int startpos, int range,
  6526.         struct re_registers *regs,
  6527.         int stop)
  6528. #else
  6529. int
  6530. RE_SEARCH_2_FN (rxb,
  6531.         string1, size1, string2, size2, startpos, range, regs, stop)
  6532.      struct re_pattern_buffer *rxb;
  6533.      const char * string1;
  6534.      int size1;
  6535.      const char * string2;
  6536.      int size2;
  6537.      int startpos;
  6538.      int range;
  6539.      struct re_registers *regs;
  6540.      int stop;
  6541. #endif
  6542. {
  6543.   /* Two groups of registers are kept.  The group with the register state
  6544.    * of the current test match, and the group that holds the state at the end
  6545.    * of the best known match, if any.
  6546.    *
  6547.    * For some patterns, there may also be registers saved on the stack.
  6548.    */
  6549.   regoff_t * lparen = 0; /* scratch space for register returns */
  6550.   regoff_t * rparen = 0;
  6551.   regoff_t * best_lpspace = 0; /* in case the user doesn't want these */
  6552.   regoff_t * best_rpspace = 0; /* values, we still need space to store
  6553.                 * them.  Normally, this memoryis unused
  6554.                 * and the space pointed to by REGS is 
  6555.                 * used instead.
  6556.                 */
  6557.   
  6558.   int last_l;            /* Highest index of a valid lparen. */
  6559.   int last_r;            /* It's dual. */
  6560.  
  6561.   int * best_lparen;        /* This contains the best known register */
  6562.   int * best_rparen;        /* assignments. 
  6563.                  * This may point to the same mem as
  6564.                  * best_lpspace, or it might point to memory
  6565.                  * passed by the caller.
  6566.                  */
  6567.   int best_last_l;        /* best_last_l:best_lparen::last_l:lparen */
  6568.   int best_last_r;
  6569.   
  6570.   
  6571.  
  6572.   /* Figure the number of registers we may need for use in backreferences.
  6573.    * The number here includes an element for register zero.  
  6574.    */
  6575.   unsigned num_regs = rxb->re_nsub + 1;
  6576.  
  6577.   int total_size = size1 + size2;
  6578.  
  6579.  
  6580.   /***** INIT re_search_2 */
  6581.   
  6582.   /* Check for out-of-range STARTPOS.  */
  6583.   if ((startpos < 0) || (startpos > total_size))
  6584.     return -1;
  6585.  
  6586.   /* Fix up RANGE if it might eventually take us outside
  6587.    * the virtual concatenation of STRING1 and STRING2.
  6588.    */
  6589.   {
  6590.     int endpos = startpos + range;
  6591.     if (endpos < -1)
  6592.       range = (-1 - startpos);
  6593.     else if (endpos > total_size)
  6594.       range = total_size - startpos;
  6595.   }
  6596.  
  6597.   /* If the search isn't to be a backwards one, don't waste time in a
  6598.    * long search for a pattern that says it is anchored.
  6599.    */
  6600.   if (rxb->begbuf_only && (range > 0))
  6601.     {
  6602.       if (startpos > 0)
  6603.     return -1;
  6604.       else
  6605.     range = 1;
  6606.     }
  6607.  
  6608.   /* Then, decide whether to use internal or user-provided reg buffers. */
  6609.   if (!regs || rxb->no_sub)
  6610.     {
  6611.       best_lpspace = (regoff_t *)REGEX_ALLOCATE (num_regs * sizeof(regoff_t));
  6612.       best_rpspace = (regoff_t *)REGEX_ALLOCATE (num_regs * sizeof(regoff_t));
  6613.       best_lparen = best_lpspace;
  6614.       best_rparen = best_rpspace;
  6615.     }
  6616.   else
  6617.     {    
  6618.       /* Have the register data arrays been allocated?  */
  6619.       if (rxb->regs_allocated == REGS_UNALLOCATED)
  6620.     { /* No.  So allocate them with malloc.  We need one
  6621.          extra element beyond `num_regs' for the `-1' marker
  6622.          GNU code uses.  */
  6623.       regs->num_regs = MAX (RE_NREGS, rxb->re_nsub + 1);
  6624.       regs->start = TALLOC (regs->num_regs, regoff_t);
  6625.       regs->end = TALLOC (regs->num_regs, regoff_t);
  6626.       if (regs->start == 0 || regs->end == 0)
  6627.         return -2;
  6628.       rxb->regs_allocated = REGS_REALLOCATE;
  6629.     }
  6630.       else if (rxb->regs_allocated == REGS_REALLOCATE)
  6631.     { /* Yes.  If we need more elements than were already
  6632.          allocated, reallocate them.  If we need fewer, just
  6633.          leave it alone.  */
  6634.       if (regs->num_regs < num_regs + 1)
  6635.         {
  6636.           regs->num_regs = num_regs + 1;
  6637.           RETALLOC (regs->start, regs->num_regs, regoff_t);
  6638.           RETALLOC (regs->end, regs->num_regs, regoff_t);
  6639.           if (regs->start == 0 || regs->end == 0)
  6640.         return -2;
  6641.         }
  6642.     }
  6643.       else if (rxb->regs_allocated != REGS_FIXED)
  6644.     return -2;
  6645.  
  6646.       if (regs->num_regs < num_regs + 1)
  6647.     {
  6648.       best_lpspace = ((regoff_t *)
  6649.               REGEX_ALLOCATE (num_regs * sizeof(regoff_t)));
  6650.       best_rpspace = ((regoff_t *)
  6651.               REGEX_ALLOCATE (num_regs * sizeof(regoff_t)));
  6652.       best_lparen = best_lpspace;
  6653.       best_rparen = best_rpspace;
  6654.     }
  6655.       else
  6656.     {
  6657.       best_lparen = regs->start;
  6658.       best_rparen = regs->end;
  6659.     }
  6660.     }
  6661.   
  6662.   lparen = (regoff_t *) REGEX_ALLOCATE (num_regs * sizeof(regoff_t));
  6663.   rparen = (regoff_t *) REGEX_ALLOCATE (num_regs * sizeof(regoff_t)); 
  6664.   
  6665.   if (!(best_rparen && best_lparen && lparen && rparen))
  6666.     return -2;
  6667.   
  6668.   best_last_l = best_last_r = -1;
  6669.  
  6670.  
  6671.  
  6672.   /***** fastmap/search loop, initialization */
  6673.  
  6674.   /* This is the loop that scans using the fastmap, and sometimes tries to 
  6675.    * match. From this point on, don't return.  Instead, assign to ret_val
  6676.    * and goto fail.
  6677.    */
  6678.   {
  6679.     const unsigned char * translate = (rxb->translate
  6680.                        ? (unsigned char *)rxb->translate
  6681.                        : (unsigned char *)id_translation);
  6682.     
  6683.     /** This is state associated with returning to the caller. */
  6684.  
  6685.     int ret_val = -1;
  6686.  
  6687.     /*   A sentinal is sometimes installed in the fastmap.  This records
  6688.      *   where so it can be removed before returning.
  6689.      */
  6690.     int fastmap_chr = -1;
  6691.     int fastmap_val = 0;
  6692.  
  6693.     /** End of state associated with returning to the caller. */
  6694.  
  6695.     /** Start of variables associated with the fastmap based search: */
  6696.  
  6697.     char * fastmap = rxb->fastmap ? (char *)rxb->fastmap : (char *)slowmap;
  6698.     int search_direction;    /* 1 or -1 */
  6699.     int search_end;        /* first position to not try */
  6700.     int offset;            /* either size1 or 0 as string == string2 */
  6701.  
  6702.     /* The string-pair position of the fastmap/search loop: */
  6703.     const unsigned char * pos;    /* The current pos. */
  6704.     const unsigned char * string; /* The current string half. */
  6705.     const unsigned char * end;    /* End of current string. */
  6706.     int size;            /* Current string's size */
  6707.     int half;            /* 0 means string1, 1 means string2 */
  6708.  
  6709.     /** End of variables associated with the fastmap based search: */
  6710.  
  6711.  
  6712.     /** Start of variables associated with trying a match
  6713.      *  after the fastmap has found a plausible starting point.
  6714.      */
  6715.  
  6716.     struct rx_superstate * start_super = 0; /* The superNFA start state. */
  6717.  
  6718.     /*
  6719.      * Two nfa's were compiled.  
  6720.      * `0' is complete.
  6721.      * `1' faster but gets registers wrong and ends too soon.
  6722.      */
  6723.     int nfa_choice = ((regs && !rxb->least_subs) ? '\0' : '\1');
  6724.  
  6725.     const unsigned char * abs_end; /* Don't fetch a character from here. */
  6726.     int first_found;        /* If true, return after finding any match. */
  6727.  
  6728.     /** End of variables associated with trying a match. */
  6729.  
  6730.     /* Update the fastmap now if not correct already. 
  6731.      * When the regexp was compiled, the fastmap was computed
  6732.      * and stored in a bitset.  This expands the bitset into a
  6733.      * character array containing 1s and 0s.
  6734.      */
  6735.     if ((fastmap == rxb->fastmap) && !rxb->fastmap_accurate)
  6736.       rx_blow_up_fastmap (rxb);
  6737.  
  6738.     /* Now we build the starting state of the supernfa. */
  6739.     {
  6740.       struct rx_superset * start_contents;
  6741.       struct rx_nfa_state_set * start_nfa_set;
  6742.       
  6743.       /* We presume here that the nfa start state has only one
  6744.        * possible future with no side effects.  
  6745.        */
  6746.       start_nfa_set = rxb->start->futures->destset;
  6747.       if (   rxb->rx.start_set
  6748.       && (rxb->rx.start_set->starts_for == &rxb->rx))
  6749.     start_contents = rxb->rx.start_set;
  6750.       else
  6751.     {
  6752.       start_contents =
  6753.         rx_superstate_eclosure_union (&rxb->rx,
  6754.                       rx_superset_cons (&rxb->rx, 0, 0),
  6755.                       start_nfa_set);
  6756.       
  6757.       if (!start_contents)
  6758.         return -1;
  6759.  
  6760.       start_contents->starts_for = &rxb->rx;
  6761.       rxb->rx.start_set = start_contents;
  6762.     }
  6763.       if (   start_contents->superstate
  6764.       && (start_contents->superstate->rx_id == rxb->rx.rx_id))
  6765.     {
  6766.       start_super = start_contents->superstate;
  6767.       rx_lock_superstate (&rxb->rx, start_super);
  6768.     }
  6769.       else
  6770.     {
  6771.       rx_protect_superset (&rxb->rx, start_contents);
  6772.       
  6773.       start_super = rx_superstate (&rxb->rx, start_contents);
  6774.       if (!start_super)
  6775.         return -1;
  6776.       rx_lock_superstate (&rxb->rx, start_super);
  6777.       rx_release_superset (&rxb->rx, start_contents);
  6778.     }
  6779.     }
  6780.     
  6781.     /* This computes an upper bound on string addresses for use by
  6782.      * the match-test.
  6783.      */
  6784.     abs_end = ((const unsigned char *) ((stop <= size1)
  6785.                     ? string1 + stop
  6786.                     : string2 + stop - size1));
  6787.  
  6788.     /* We have the option to look for the best match or the first
  6789.      * one we can find.  If the user isn't asking for register information,
  6790.      * we don't need to find the best match.
  6791.      */
  6792.     first_found = !regs;
  6793.  
  6794.     /* Compute search_end & search_direction for the fastmap loop. */
  6795.     if (range >= 0)
  6796.       {
  6797.     search_end = MIN (size1 + size2, startpos + range) + 1;
  6798.     search_direction = 1;
  6799.       }
  6800.     else
  6801.       {
  6802.     search_end = MAX(-1, startpos + range);
  6803.     search_direction = -1;
  6804.       }
  6805.  
  6806.     /* The vacuous search always turns up nothing. */
  6807.     if ((search_direction == 1)
  6808.     ? (startpos > search_end)
  6809.     : (startpos < search_end))
  6810.       return -1;
  6811.  
  6812.     /* Set string/size/offset/end -- the state that tells the fastmap
  6813.      * loop which half of the string we're in.  Also set pos, which
  6814.      * is the addr of the current fastmap scan position.
  6815.      */
  6816.     if (!string2 || (startpos < size1))
  6817.       {
  6818.     string = (const unsigned char *)string1;
  6819.     size = size1;
  6820.     offset = 0;
  6821.     pos = (const unsigned char *)(string1 + startpos);
  6822.     half = 0;
  6823.     end = (const unsigned char *)MIN(string1 + size1, string1 + stop);
  6824.       }
  6825.     else
  6826.       {
  6827.     string = (const unsigned char *)string2;
  6828.     size = size2;
  6829.     offset = size1;
  6830.     pos = (const unsigned char *)(string2 + startpos - size1);
  6831.     half = 1;
  6832.     end = (const unsigned char *)MIN(string2 + size2,
  6833.                      string2 + stop - size1);
  6834.       }
  6835.  
  6836.  
  6837.  
  6838.  
  6839.     /***** fastmap/search loop,  body */
  6840.  
  6841.  
  6842.   init_fastmap_sentinal:
  6843.  
  6844.     /* For the sake of fast fastmapping, set a sentinal in the fastmap.
  6845.      * This sentinal will trap the fastmap loop when it reaches the last
  6846.      * valid character in a string half.
  6847.      *
  6848.      * This must be reset when the fastmap/search loop crosses a string 
  6849.      * boundry, and before returning to the caller.  So sometimes,
  6850.      * the fastmap loop is restarted with `continue', othertimes by
  6851.      * `goto init_fastmap_sentinal'.
  6852.      */
  6853.     if (size)
  6854.       {
  6855.     fastmap_chr = ((search_direction == 1)
  6856.                ? *(end - 1)
  6857.                : *string);
  6858.     fastmap_val = fastmap[fastmap_chr];
  6859.     fastmap[fastmap_chr] = 1;
  6860.       }
  6861.     else
  6862.       {
  6863.     fastmap_chr = -1;
  6864.     fastmap_val = 0;
  6865.       }
  6866.  
  6867.     do
  6868.       {
  6869.     /* If we haven't reached the end of a string half, and if the
  6870.      * pattern can't match the empty string, then the fastmap 
  6871.      * optimization applies.  This conditional scans using the 
  6872.      * fastmap -- stoping when a string half ends, or when a 
  6873.      * plausible starting point for a match is found.
  6874.      * It updates HIT_BOUND to tell which case occured.
  6875.      */
  6876.     if (pos == end)
  6877.       goto fastmap_hit_bound;
  6878.     else
  6879.       {
  6880.         if (search_direction == 1)
  6881.           {
  6882.         if (fastmap_val)
  6883.           {
  6884.             for (;;)
  6885.               {
  6886.             while (!fastmap[*pos])
  6887.               ++pos;
  6888.             goto commence_a_matchin;
  6889.               }
  6890.           }
  6891.         else
  6892.           {
  6893.             for (;;)
  6894.               {
  6895.             while (!fastmap[*pos])
  6896.               ++pos;
  6897.             if (*pos != fastmap_chr)
  6898.               goto commence_a_matchin;
  6899.             else 
  6900.               {
  6901.                 ++pos;
  6902.                 if (pos == end)
  6903.                   goto fastmap_hit_bound;
  6904.               }
  6905.               }
  6906.           }
  6907.           }
  6908.         else
  6909.           {
  6910.         const unsigned char * bound = string - 1;
  6911.         if (fastmap_val)
  6912.           {
  6913.             for (;;)
  6914.               {
  6915.             while (!fastmap[*pos])
  6916.               --pos;
  6917.             goto commence_a_matchin;
  6918.               }
  6919.           }
  6920.         else
  6921.           {
  6922.             for (;;)
  6923.               {
  6924.             while (!fastmap[*pos])
  6925.               --pos;
  6926.             if ((*pos != fastmap_chr) || fastmap_val)
  6927.               goto commence_a_matchin;
  6928.             else 
  6929.               {
  6930.                 --pos;
  6931.                 if (pos == bound)
  6932.                   goto fastmap_hit_bound;
  6933.               }
  6934.               }
  6935.           }
  6936.           }
  6937.       }
  6938.     
  6939.       fastmap_hit_bound:
  6940.     {
  6941.       /* If we hit a bound, it may simply be time to switch sides
  6942.        * between strings.
  6943.        */
  6944.       if ((search_direction == 1) && string2 && (half == 0))
  6945.         {
  6946.           string = (const unsigned char *)string2;
  6947.           size = size2;
  6948.           offset = size1;
  6949.           half = 1;
  6950.           end = (const unsigned char *)MIN(string2 + size2,
  6951.                            string2 + stop - size1);
  6952.           startpos = size1;
  6953.           pos = (const unsigned char *)string2;
  6954.           goto init_fastmap_sentinal;
  6955.         }
  6956.       else if (   string1
  6957.            && (search_direction == -1)
  6958.            && (half == 1))
  6959.         {
  6960.           string = (const unsigned char *)string1;
  6961.           size = size1;
  6962.           offset = 0;
  6963.           end = (const unsigned char *)string1 + size1;
  6964.           half = 0;
  6965.           startpos = size1 - 1;
  6966.           pos = (const unsigned char *)string1 + size1 - 1;
  6967.           goto init_fastmap_sentinal;
  6968.         }
  6969.       /* ...not a string split, simply no more string. 
  6970.        *
  6971.        * When searching backward, running out of string
  6972.        * is reason to quit.
  6973.        */
  6974.       else if (search_direction == -1)
  6975.         goto finish;
  6976.       
  6977.       /* ...when searching forward, we allow the possibility
  6978.        * of an (empty) match after the last character in the
  6979.        * virtual string.  So, fall through to the matcher
  6980.        */
  6981.     }
  6982.  
  6983.  
  6984.       commence_a_matchin:
  6985.  
  6986.     /***** fastmap/search loop body
  6987.      *          test for a match that begins at pos
  6988.      */
  6989.  
  6990.     /* Now the fastmap loop has brought us to a plausible 
  6991.      * starting point for a match.  So, it's time to run the
  6992.      * NFA and see if a match occured.
  6993.      */
  6994.  
  6995.     startpos = pos - string + offset;
  6996.     if (startpos == search_end)
  6997.       goto finish;
  6998.     
  6999.     last_l = last_r = 0;
  7000.     lparen[0] = startpos;    /* We know match-begin for this test... */
  7001.  
  7002.     /* The test matcher is essentially a recursive function
  7003.      * that does an exhaustive run of the superNFA at the 
  7004.      * test position.  For performance, that function has 
  7005.      * been in-lined by hand.
  7006.      */
  7007.  
  7008. #undef OF
  7009. #ifndef HAVE_GNUC_LABELS
  7010. #define OF(A,B)    A
  7011. #else
  7012. #define OF(A,B)    A: B
  7013.       static void * rx_labels_instruction_table[] =
  7014.         {
  7015.           [rx_backtrack_point] &&backtrack_point,
  7016.           [rx_backtrack] &&backtrack,
  7017.           [rx_do_side_effects] &&do_side_effects,
  7018.           [rx_cache_miss] &&cache_miss,
  7019.           [rx_next_char] 0,
  7020.           [rx_error_inx] 0
  7021.         };
  7022. #endif
  7023.     {      
  7024.       /* The current superNFA position of the matcher. */
  7025.       struct rx_superstate * super = start_super;
  7026.       
  7027.       /* The matcher interprets a series of instruction frames.
  7028.        * This is the `instruction counter' for the interpretation.
  7029.        */
  7030.       struct rx_inx * ifr;
  7031.       
  7032.       /* We insert a ghost character in the string to prime
  7033.        * the nfa.  tst_pos, tst_str_half, and tst_end_half
  7034.        * keep track of the test-match position and string-half.
  7035.        */
  7036.       const unsigned char * tst_pos = pos - 1;
  7037.       int tst_half = half;
  7038.       unsigned char c = nfa_choice;
  7039.       
  7040.       const unsigned char * tst_str_half = string;
  7041.       const unsigned char * tst_end_half = end;
  7042.       
  7043.       struct stack_chunk * counter_stack = 0;
  7044.       struct stack_chunk * backtrack_stack = 0;
  7045.       int backtrack_frame_bytes =
  7046.         (sizeof (struct backtrack_frame)
  7047.          + (rxb->match_regs_on_stack
  7048.         ? sizeof (regoff_t) * (num_regs + 1) * 2
  7049.         : 0));
  7050.       int chunk_bytes = backtrack_frame_bytes * 64;
  7051.       struct stack_chunk * free_chunks = 0;
  7052.  
  7053. #ifdef RX_DEBUG
  7054.       int backtrack_depth = 0;
  7055. #endif
  7056.  
  7057.       /* To return from this function, set test_ret and 
  7058.        * `goto test_do_return'.
  7059.        *
  7060.        * Possible return values are:
  7061.        *     1   --- end of string while the superNFA is still going
  7062.        *     0   --- internal error (out of memory)
  7063.        *    -1   --- search completed by reaching the superNFA fail state
  7064.        *    -2   --- a match was found, maybe not the longest.
  7065.        *
  7066.        * When the search is complete (-1), best_last_r indicates whether
  7067.        * a match was found.
  7068.        *
  7069.        * -2 is return only if first_found is non-zero.
  7070.        *
  7071.        * if first_found is non-zero, a return of -1 indicates no match,
  7072.        * otherwise, best_last_r has to be checked.
  7073.        */
  7074.       int test_ret = -1;
  7075.       
  7076.       while (1)
  7077.         {
  7078.           int inx;
  7079. #ifdef RX_DEBUG
  7080.           /* There is a search tree with every node as set of deterministic
  7081.            * transitions in the super nfa.  For every branch of a 
  7082.            * backtrack point is an edge in the tree.
  7083.            * This counts up a pre-order of nodes in that tree.
  7084.            * It's saved on the search stack and printed when debugging. 
  7085.            */
  7086.           int line_no = 0;
  7087.           int lines_found = 0;
  7088. #endif
  7089.  
  7090.  
  7091.         top_of_cycle:
  7092.           /* A superstate is basicly a transition table, indexed by 
  7093.            * characters from the string being tested, and containing 
  7094.            * RX_INX structures.
  7095.            */
  7096.           ifr = &super->transitions [c];
  7097.           
  7098.         recurse_test_match:
  7099.           /* This is the point to which control is sent when the
  7100.            * test matcher recurses.  Before jumping here, some variables
  7101.            * need to be saved on the stack and setup for the recursion.
  7102.            */
  7103.  
  7104.         restart:
  7105.           /* Some instructions don't advance the matcher, but just
  7106.            * carry out some side effects and fetch a new instruction.
  7107.            * To dispatch that new instruction, `goto restart'.
  7108.            */
  7109.           
  7110.           {
  7111.         struct rx_inx * next_tr_table = (struct rx_inx *)ifr->data;
  7112.         struct rx_inx * this_tr_table = super->transitions;
  7113.         /* The fastest route through the loop is when the instruction 
  7114.          * is RX_NEXT_CHAR.  This case is detected when IFR->DATA
  7115.          * is non-zero.  In that case, it points to the next
  7116.          * superstate. 
  7117.          *
  7118.          * This allows us to not bother fetching the bytecode.
  7119.          */
  7120.         while (next_tr_table)
  7121.           {
  7122. #ifdef RX_DEBUG
  7123.             if (rx_debug_trace)
  7124.               {
  7125.             struct rx_superset * setp;
  7126.  
  7127.             fprintf (stderr, "%d %d>> re_next_char @ %d (%d)",
  7128.                  line_no,
  7129.                  backtrack_depth,
  7130.                  (tst_pos - tst_str_half
  7131.                   + (tst_half == 0
  7132.                      ? 0 : size1)), c);
  7133.             
  7134.             super =
  7135.               ((struct rx_superstate *)
  7136.                ((char *)this_tr_table
  7137.                 - ((unsigned long)
  7138.                    ((struct rx_superstate *)0)->transitions)));
  7139.  
  7140.             setp = super->contents;
  7141.             fprintf (stderr, "   superstet (rx=%d, &=%x: ",
  7142.                  rxb->rx.rx_id, setp);
  7143.             while (setp)
  7144.               {
  7145.                 fprintf (stderr, "%d ", setp->id);
  7146.                 setp = setp->cdr;
  7147.               }
  7148.             fprintf (stderr, "\n");
  7149.               }
  7150. #endif
  7151.             this_tr_table = next_tr_table;
  7152.             ++tst_pos;
  7153.             if (tst_pos == tst_end_half)
  7154.               {
  7155.             if (   (tst_pos != abs_end)
  7156.                 && string2
  7157.                 && half == 0)
  7158.               {
  7159.                 /* Here we are crossing the break 
  7160.                  * in a split string. 
  7161.                  */
  7162.                 tst_str_half = (const unsigned char *)string2;
  7163.                 tst_end_half = abs_end;
  7164.                 tst_pos = (const unsigned char *)string2;
  7165.                 tst_half = 1;
  7166.               }
  7167.             else
  7168.               {
  7169.                 test_ret = 1;
  7170.                 goto test_do_return;
  7171.               }
  7172.               }
  7173.             c = *tst_pos;
  7174.             ifr = this_tr_table + c;
  7175.             next_tr_table = (struct rx_inx *)ifr->data;
  7176.           }
  7177.         
  7178.         /* Here when we ran out cached next-char transitions. 
  7179.          * So, it will be necessary to do a more expensive
  7180.          * dispatch on the current instruction.  The superstate
  7181.          * pointer is allowed to become invalid during next-char
  7182.          * transitions -- now we must bring it up to date.
  7183.          */
  7184.         super =
  7185.           ((struct rx_superstate *)
  7186.            ((char *)this_tr_table
  7187.             - ((unsigned long)
  7188.                ((struct rx_superstate *)0)->transitions)));
  7189.           }
  7190.           
  7191.           /* We've encountered an instruction other than next-char.
  7192.            * Dispatch that instruction:
  7193.            */
  7194.           inx = (int)ifr->inx;
  7195. #ifdef HAVE_GNUC_LABELS
  7196.           goto *rx_labels_instruction_table[inx];
  7197. #endif
  7198. #ifdef RX_DEBUG
  7199.           if (rx_debug_trace)
  7200.         {
  7201.           struct rx_superset * setp = super->contents;
  7202.           
  7203.           fprintf (stderr, "%d %d>> %s @ %d (%d)", line_no,
  7204.                backtrack_depth,
  7205.                inx_names[inx],
  7206.                (tst_pos - tst_str_half
  7207.                 + (tst_half == 0 ? 0 : size1)), c);
  7208.           
  7209.           fprintf (stderr, "   superstet (rx=%d, &=%x: ",
  7210.                rxb->rx.rx_id, setp);
  7211.           while (setp)
  7212.             {
  7213.               fprintf (stderr, "%d ", setp->id);
  7214.               setp = setp->cdr;
  7215.             }
  7216.           fprintf (stderr, "\n");
  7217.         }
  7218. #endif
  7219.           switch ((enum rx_opcode)inx)
  7220.         {
  7221.         case OF(rx_do_side_effects,do_side_effects):
  7222.  
  7223.           /*  RX_DO_SIDE_EFFECTS occurs when we cross epsilon 
  7224.            *  edges associated with parentheses, backreferencing, etc.
  7225.            */
  7226.           {
  7227.             struct rx_distinct_future * df =
  7228.               (struct rx_distinct_future *)ifr->data_2;
  7229.             struct rx_se_list * el = df->effects;
  7230.             /* Side effects come in lists.  This walks down
  7231.              * a list, dispatching.
  7232.              */
  7233.             while (el)
  7234.               {
  7235. #ifdef HAVE_GNUC_LABELS
  7236.             static void * se_labels[] =
  7237.               {
  7238.                 [-re_se_try] &&se_try,
  7239.                 [-re_se_pushback] &&se_pushback,
  7240.                 [-re_se_push0] &&se_push0,
  7241.                 [-re_se_pushpos] &&se_pushpos,
  7242.                 [-re_se_chkpos] &&se_chkpos,
  7243.                 [-re_se_poppos] &&se_poppos,
  7244. #ifdef emacs
  7245.                 [-re_se_at_dot] &&se_at_dot,
  7246.                 [-re_se_syntax] &&se_syntax,
  7247.                 [-re_se_not_syntax] &&se_not_syntax,
  7248. #endif
  7249.                 [-re_se_begbuf] &&se_begbuf,
  7250.                 [-re_se_hat] &&se_hat,
  7251.                 [-re_se_wordbeg] &&se_wordbeg,
  7252.                 [-re_se_wordbound] &&se_wordbound,
  7253.                 [-re_se_notwordbound] &&se_notwordbound,
  7254.                 [-re_se_wordend] &&se_wordend,
  7255.                 [-re_se_endbuf] &&se_endbuf,
  7256.                 [-re_se_dollar] &&se_dollar,
  7257.                 [-re_se_fail] &&se_fail,
  7258.               };
  7259.             static void * se_lables2[] =
  7260.               {
  7261.                 [re_se_win] &&se_win
  7262.                 [re_se_lparen] &&se_lparen,
  7263.                 [re_se_rparen] &&se_rparen,
  7264.                 [re_se_backref] &&se_backref,
  7265.                 [re_se_iter] &&se_iter,
  7266.                 [re_se_end_iter] &&se_end_iter,
  7267.                 [re_se_tv] &&se_tv
  7268.               };
  7269. #endif
  7270.             int effect = (int)el->car;
  7271.             if (effect < 0)
  7272.               {
  7273. #ifdef HAVE_GNUC_LABELS
  7274.                 goto *se_labels[-effect];
  7275. #endif
  7276. #ifdef RX_DEBUG
  7277.                 if (rx_debug_trace)
  7278.                   {
  7279.                 struct rx_superset * setp = super->contents;
  7280.                 
  7281.                 fprintf (stderr, "....%d %d>> %s\n", line_no,
  7282.                      backtrack_depth,
  7283.                      efnames[-effect]);
  7284.                   }
  7285. #endif
  7286.                 switch ((enum re_side_effects) effect)
  7287.                   {
  7288.                   case OF(re_se_pushback,se_pushback):
  7289.                 ifr = &df->future_frame;
  7290.                 if (!ifr->data)
  7291.                   {
  7292.                     struct rx_superstate * sup = super;
  7293.                     rx_lock_superstate (rx, sup);
  7294.                     if (!rx_handle_cache_miss (&rxb->rx,
  7295.                                    super, c,
  7296.                                    ifr->data_2))
  7297.                       {
  7298.                     rx_unlock_superstate (rx, sup);
  7299.                     test_ret = 0;
  7300.                     goto test_do_return;
  7301.                       }
  7302.                     rx_unlock_superstate (rx, sup);
  7303.                   }
  7304.                 /* --tst_pos; */
  7305.                 c = 't';
  7306.                 super
  7307.                   = ((struct rx_superstate *)
  7308.                      ((char *)ifr->data
  7309.                       - (long)(((struct rx_superstate *)0)
  7310.                            ->transitions)));
  7311.                 goto top_of_cycle;
  7312.                 break;
  7313.                   case OF(re_se_push0,se_push0):
  7314.                 {
  7315.                   struct counter_frame * old_cf
  7316.                      = (counter_stack
  7317.                     ? ((struct counter_frame *)
  7318.                        counter_stack->sp)
  7319.                     : 0);
  7320.                   struct counter_frame * cf;
  7321.                   PUSH (counter_stack,
  7322.                     sizeof (struct counter_frame));
  7323.                   cf = ((struct counter_frame *)
  7324.                     counter_stack->sp);
  7325.                   cf->tag = re_se_iter;
  7326.                   cf->val = 0;
  7327.                   cf->inherited_from = 0;
  7328.                   cf->cdr = old_cf;
  7329.                   break;
  7330.                 }
  7331.                   case OF(re_se_fail,se_fail):
  7332.                 goto test_do_return;
  7333.                   case OF(re_se_begbuf,se_begbuf):
  7334.                 if (!AT_STRINGS_BEG ())
  7335.                   goto test_do_return;
  7336.                 break;
  7337.                   case OF(re_se_endbuf,se_endbuf):
  7338.                 if (!AT_STRINGS_END ())
  7339.                   goto test_do_return;
  7340.                 break;
  7341.                   case OF(re_se_wordbeg,se_wordbeg):
  7342.                 if (   LETTER_P (tst_pos + 1)
  7343.                     && (   AT_STRINGS_BEG()
  7344.                     || !LETTER_P (tst_pos)))
  7345.                   break;
  7346.                 else
  7347.                   goto test_do_return;
  7348.                   case OF(re_se_wordend,se_wordend):
  7349.                 if (   !AT_STRINGS_BEG ()
  7350.                     && LETTER_P (tst_pos)
  7351.                     && (AT_STRINGS_END ()
  7352.                     || !LETTER_P (tst_pos + 1)))
  7353.                   break;
  7354.                 else
  7355.                   goto test_do_return;
  7356.                   case OF(re_se_wordbound,se_wordbound):
  7357.                 if (AT_WORD_BOUNDARY (tst_pos))
  7358.                   break;
  7359.                 else
  7360.                   goto test_do_return;
  7361.                   case OF(re_se_notwordbound,se_notwordbound):
  7362.                 if (!AT_WORD_BOUNDARY (tst_pos))
  7363.                   break;
  7364.                 else
  7365.                   goto test_do_return;
  7366.                   case OF(re_se_hat,se_hat):
  7367.                 if (AT_STRINGS_BEG ())
  7368.                   {
  7369.                     if (rxb->not_bol)
  7370.                       goto test_do_return;
  7371.                     else
  7372.                       break;
  7373.                   }
  7374.                 else
  7375.                   {
  7376.                     char pos_c = *tst_pos;
  7377.                     if (   (TRANSLATE (pos_c)
  7378.                         == TRANSLATE('\n'))
  7379.                     && rxb->newline_anchor)
  7380.                       break;
  7381.                     else
  7382.                       goto test_do_return;
  7383.                   }
  7384.                   case OF(re_se_dollar,se_dollar):
  7385.                 if (AT_STRINGS_END ())
  7386.                   {
  7387.                     if (rxb->not_eol)
  7388.                       goto test_do_return;
  7389.                     else
  7390.                       break;
  7391.                   }
  7392.                 else
  7393.                   {
  7394.                     const unsigned char * next_pos
  7395.                       = ((string2 && (tst_half == 0) &&
  7396.                       (tst_pos
  7397.                        == ((unsigned char *)
  7398.                            string1 + size1 - 1)))
  7399.                      ? (unsigned char *)string2
  7400.                      : tst_pos + 1);
  7401.                     
  7402.                     if (   (TRANSLATE (*next_pos)
  7403.                         == TRANSLATE ('\n'))
  7404.                     && rxb->newline_anchor)
  7405.                       break;
  7406.                     else
  7407.                       goto test_do_return;
  7408.                   }
  7409.                 
  7410.                   case OF(re_se_try,se_try):
  7411.                 /* This is the first side effect in every
  7412.                  * expression.
  7413.                  *
  7414.                  *  FOR NO GOOD REASON...get rid of it...
  7415.                  */
  7416.                 break;
  7417.  
  7418.                   case OF(re_se_pushpos,se_pushpos):
  7419.                 {
  7420.                   int urhere =
  7421.                     ((int)(tst_pos - tst_str_half)
  7422.                      + ((tst_half == 0) ? 0 : size1));
  7423.                   struct counter_frame * old_cf
  7424.                     = (counter_stack
  7425.                        ? ((struct counter_frame *)
  7426.                       counter_stack->sp)
  7427.                        : 0);
  7428.                   struct counter_frame * cf;
  7429.                   PUSH(counter_stack,
  7430.                        sizeof (struct counter_frame));
  7431.                   cf = ((struct counter_frame *)
  7432.                     counter_stack->sp);
  7433.                   cf->tag = re_se_pushpos;
  7434.                   cf->val = urhere;
  7435.                   cf->inherited_from = 0;
  7436.                   cf->cdr = old_cf;
  7437.                   break;
  7438.                 }
  7439.                 
  7440.                   case OF(re_se_chkpos,se_chkpos):
  7441.                 {
  7442.                   int urhere =
  7443.                     ((int)(tst_pos - tst_str_half)
  7444.                      + ((tst_half == 0) ? 0 : size1));
  7445.                   struct counter_frame * cf
  7446.                     = ((struct counter_frame *)
  7447.                        counter_stack->sp);
  7448.                   if (cf->val == urhere)
  7449.                     goto test_do_return;
  7450.                   cf->val = urhere;
  7451.                   break;
  7452.                 }
  7453.                 break;
  7454.  
  7455.                   case OF(re_se_poppos,se_poppos):
  7456.                 POP(counter_stack,
  7457.                     sizeof (struct counter_frame));
  7458.                 break;
  7459.                 
  7460.                 
  7461.                   case OF(re_se_at_dot,se_at_dot):
  7462.                   case OF(re_se_syntax,se_syntax):
  7463.                   case OF(re_se_not_syntax,se_not_syntax):
  7464. #ifdef emacs
  7465.                 this release lacks emacs support;
  7466.                 (coming soon);
  7467. #endif
  7468.                 break;
  7469.                   case re_se_win:
  7470.                   case re_se_lparen:
  7471.                   case re_se_rparen:
  7472.                   case re_se_backref:
  7473.                   case re_se_iter:
  7474.                   case re_se_end_iter:
  7475.                   case re_se_tv:
  7476.                   case re_floogle_flap:
  7477.                 ret_val = 0;
  7478.                 goto test_do_return;
  7479.                   }
  7480.               }
  7481.             else
  7482.               {
  7483. #ifdef HAVE_GNUC_LABELS
  7484.                 goto *se_lables2[(rxb->se_params [effect].se)];
  7485. #endif
  7486. #ifdef RX_DEBUG
  7487.               if (rx_debug_trace)
  7488.                 fprintf (stderr, "....%d %d>> %s %d %d\n", line_no,
  7489.                      backtrack_depth,
  7490.                      efnames2[rxb->se_params [effect].se],
  7491.                      rxb->se_params [effect].op1,
  7492.                      rxb->se_params [effect].op2);
  7493. #endif
  7494.                 switch (rxb->se_params [effect].se)
  7495.                   {
  7496.                   case OF(re_se_win,se_win):
  7497.                 /* This side effect indicates that we've 
  7498.                  * found a match, though not necessarily the 
  7499.                  * best match.  This is a fancy assignment to 
  7500.                  * register 0 unless the caller didn't 
  7501.                  * care about registers.  In which case,
  7502.                  * this stops the match.
  7503.                  */
  7504.                 {
  7505.                   int urhere =
  7506.                     ((int)(tst_pos - tst_str_half)
  7507.                      + ((tst_half == 0)
  7508.                     ? 0 : size1));
  7509.  
  7510.                   if (   (best_last_r < 0)
  7511.                       || (urhere + 1 > best_rparen[0]))
  7512.                     {
  7513.                       /* Record the best known and keep
  7514.                        * looking.
  7515.                        */
  7516.                       int x;
  7517.                       for (x = 0; x <= last_l; ++x)
  7518.                     best_lparen[x] = lparen[x];
  7519.                       best_last_l = last_l;
  7520.                       for (x = 0; x <= last_r; ++x)
  7521.                     best_rparen[x] = rparen[x];
  7522.                       best_rparen[0] = urhere + 1;
  7523.                       best_last_r = last_r;
  7524.                     }
  7525.                   /* If we're not reporting the match-length 
  7526.                    * or other register info, we need look no
  7527.                    * further.
  7528.                    */
  7529.                   if (first_found)
  7530.                     {
  7531.                       test_ret = -2;
  7532.                       goto test_do_return;
  7533.                     }
  7534.                 }
  7535.                 break;
  7536.                   case OF(re_se_lparen,se_lparen):
  7537.                 {
  7538.                   int urhere =
  7539.                     ((int)(tst_pos - tst_str_half)
  7540.                      + ((tst_half == 0) ? 0 : size1));
  7541.                   
  7542.                   int reg = rxb->se_params [effect].op1;
  7543. #if 0
  7544.                   if (reg > last_l)
  7545. #endif
  7546.                     {
  7547.                       lparen[reg] = urhere + 1;
  7548.                       /* In addition to making this assignment,
  7549.                        * we now know that lower numbered regs
  7550.                        * that haven't already been assigned,
  7551.                        * won't be.  We make sure they're
  7552.                        * filled with -1, so they can be
  7553.                        * recognized as unassigned.
  7554.                        */
  7555.                       if (last_l < reg)
  7556.                     while (++last_l < reg)
  7557.                       lparen[last_l] = -1;
  7558.                     }
  7559.                   break;
  7560.                 }
  7561.                 
  7562.                   case OF(re_se_rparen,se_rparen):
  7563.                 {
  7564.                   int urhere =
  7565.                     ((int)(tst_pos - tst_str_half)
  7566.                      + ((tst_half == 0) ? 0 : size1));
  7567.                   int reg = rxb->se_params [effect].op1;
  7568.                   rparen[reg] = urhere + 1;
  7569.                   if (last_r < reg)
  7570.                     {
  7571.                       while (++last_r < reg)
  7572.                     rparen[last_r] = -1;
  7573.                     }
  7574.                   break;
  7575.                 }
  7576.                 
  7577.                   case OF(re_se_backref,se_backref):
  7578.                 {
  7579.                   int reg = rxb->se_params [effect].op1;
  7580.                   if (reg > last_r || rparen[reg] < 0)
  7581.                     goto test_do_return;
  7582.                   {
  7583.                     /* fixme */
  7584.                     const unsigned char * there
  7585.                       = tst_str_half + lparen[reg];
  7586.                     const unsigned char * last
  7587.                       = tst_str_half + rparen[reg];
  7588.                     const unsigned char * here = tst_pos + 1;
  7589.  
  7590.                     if ((here == tst_end_half) && string2
  7591.                     && (tst_str_half
  7592.                         == (unsigned char *) string1)
  7593.                     && (tst_end_half != abs_end))
  7594.                       {
  7595.                     here = (unsigned char *)string2;
  7596.                     tst_end_half = abs_end;
  7597.                       }
  7598.                     
  7599.                     while (there < last && here < tst_end_half)    /* 4% */
  7600.                       if (TRANSLATE(*there) /* &&&& 6% */
  7601.                       != TRANSLATE(*here))
  7602.                     goto test_do_return;
  7603.                       else
  7604.                     {
  7605.                       ++there; ++here;
  7606.                       if ((here == tst_end_half) && string2
  7607.                           && (tst_str_half
  7608.                           == (unsigned char *)string1)
  7609.                           && (tst_end_half != abs_end))
  7610.                         {
  7611.                           here = (unsigned char *)string2;
  7612.                           tst_end_half = abs_end;
  7613.                           tst_half = 1;
  7614.                         }
  7615.                     }
  7616.                     if (there != last)
  7617.                       goto test_do_return;
  7618.                     tst_pos = here - 1;
  7619.                     if ((here == (unsigned char *)string2)
  7620.                     && (unsigned char *)string1)
  7621.                       {
  7622.                     tst_pos = ((unsigned char *)string1
  7623.                            + size1 - 1);
  7624.                     tst_end_half = tst_pos + 1;
  7625.                     tst_half = 0;
  7626.                       }
  7627.                   }
  7628.                   break;
  7629.                 }
  7630.                   case OF(re_se_iter,se_iter):
  7631.                 {
  7632.                   struct counter_frame * csp
  7633.                     = ((struct counter_frame *)
  7634.                        counter_stack->sp);
  7635.                   if (csp->val == rxb->se_params[effect].op2)
  7636.                     goto test_do_return;
  7637.                   else
  7638.                     ++csp->val;
  7639.                   break;
  7640.                 }
  7641.                   case OF(re_se_end_iter,se_end_iter):
  7642.                 {
  7643.                   struct counter_frame * csp
  7644.                     = ((struct counter_frame *)
  7645.                        counter_stack->sp);
  7646.                   if (csp->val < rxb->se_params[effect].op1)
  7647.                     goto test_do_return;
  7648.                   else
  7649.                     {
  7650.                       struct counter_frame * source = csp;
  7651.                       while (source->inherited_from)
  7652.                     source = source->inherited_from;
  7653.                       if (!source || !source->cdr)
  7654.                     {
  7655.                       POP(counter_stack,
  7656.                           sizeof(struct counter_frame));
  7657.                     }
  7658.                       else
  7659.                     {
  7660.                       source = source->cdr;
  7661.                       csp->val = source->val;
  7662.                       csp->tag = source->tag;
  7663.                       csp->cdr = 0;
  7664.                       csp->inherited_from = source;
  7665.                     }
  7666.                     }
  7667.                   break;
  7668.                 }
  7669.                   case OF(re_se_tv, se_tv):
  7670.                 /* is a noop */
  7671.                 break;
  7672.                   case re_se_try:
  7673.                   case re_se_pushback:
  7674.                   case re_se_push0:
  7675.                   case re_se_pushpos:
  7676.                   case re_se_chkpos:
  7677.                   case re_se_poppos:
  7678.                   case re_se_at_dot:
  7679.                   case re_se_syntax:
  7680.                   case re_se_not_syntax:
  7681.                   case re_se_begbuf:
  7682.                   case re_se_hat:
  7683.                   case re_se_wordbeg:
  7684.                   case re_se_wordbound:
  7685.                   case re_se_notwordbound:
  7686.                   case re_se_wordend:
  7687.                   case re_se_endbuf:
  7688.                   case re_se_dollar:
  7689.                   case re_se_fail:
  7690.                   case re_floogle_flap:
  7691.                 ret_val = 0;
  7692.                 goto test_do_return;
  7693.                   }
  7694.               }
  7695.             el = el->cdr;
  7696.               }
  7697.             /* Now the side effects are done,
  7698.              * so get the next instruction.
  7699.              * and move on.
  7700.              */
  7701.             ifr = &df->future_frame;
  7702.             goto restart;
  7703.           }
  7704.           
  7705.         case OF(rx_backtrack_point,backtrack_point):
  7706.           {
  7707.             /* A backtrack point indicates that we've reached a
  7708.              * non-determinism in the superstate NFA.  This is a
  7709.              * loop that exhaustively searches the possibilities.
  7710.              *
  7711.              * A backtracking strategy is used.  We keep track of what
  7712.              * registers are valid so we can erase side effects.
  7713.              *
  7714.              * First, make sure there is some stack space to hold 
  7715.              * our state.
  7716.              */
  7717.  
  7718.             struct backtrack_frame * bf;
  7719.  
  7720.             PUSH(backtrack_stack, backtrack_frame_bytes);
  7721. #ifdef RX_DEBUG
  7722.             ++backtrack_depth;
  7723. #endif
  7724.  
  7725.             bf = ((struct backtrack_frame *)
  7726.               backtrack_stack->sp);
  7727.             {
  7728.               bf->stk_super = super;
  7729.               /* We prevent the current superstate from being
  7730.                * deleted from the superstate cache.
  7731.                */
  7732.               rx_lock_superstate (&rxb->rx, super);
  7733.               bf->stk_tst_pos = tst_pos;
  7734. #ifdef RX_DEBUG
  7735.               bf->stk_line_no = line_no;
  7736. #endif
  7737.               bf->stk_tst_half = tst_half;
  7738.               bf->stk_c = c;
  7739.               bf->stk_tst_str_half = tst_str_half;
  7740.               bf->stk_tst_end_half = tst_end_half;
  7741.               bf->stk_last_l = last_l;
  7742.               bf->stk_last_r = last_r;
  7743.               bf->df = ((struct rx_super_edge *)ifr->data_2)->options;
  7744.               bf->first_df = bf->df;
  7745.               bf->counter_stack_sp = (counter_stack
  7746.                           ? counter_stack->sp
  7747.                           : 0);
  7748.               bf->stk_test_ret = test_ret;
  7749.               if (rxb->match_regs_on_stack)
  7750.             {
  7751.               int x;
  7752.               regoff_t * stk =
  7753.                 (regoff_t *)((char *)bf + sizeof (*bf));
  7754.               for (x = 0; x <= last_l; ++x)
  7755.                 stk[x] = lparen[x];
  7756.               stk += x;
  7757.               for (x = 0; x <= last_r; ++x)
  7758.                 stk[x] = rparen[x];
  7759.             }
  7760.  
  7761.             }
  7762.  
  7763.             /* Here is a while loop whose body is mainly a function
  7764.              * call and some code to handle a return from that
  7765.              * function.
  7766.              *
  7767.              * From here on for the rest of `case backtrack_point' it
  7768.              * is unsafe to assume that the variables saved on the
  7769.              * stack are valid -- so reread their values from the stack
  7770.              * as needed.
  7771.              *
  7772.              * This lets us re-use one generation fewer stack saves in
  7773.              * the call-graph of a search.
  7774.              */
  7775.             
  7776.           while_non_det_options:
  7777. #ifdef RX_DEBUG
  7778.             ++lines_found;
  7779.             if (rx_debug_trace)
  7780.               fprintf (stderr, "@@@ %d calls %d @@@\n",
  7781.                    line_no, lines_found);
  7782.             
  7783.             line_no = lines_found;
  7784. #endif
  7785.             
  7786.             if (bf->df->next_same_super_edge[0] == bf->first_df)
  7787.               {
  7788.             /* This is a tail-call optimization -- we don't recurse
  7789.              * for the last of the possible futures.
  7790.              */
  7791.             ifr = (bf->df->effects
  7792.                    ? &bf->df->side_effects_frame
  7793.                    : &bf->df->future_frame);
  7794.  
  7795.             rx_unlock_superstate (&rxb->rx, super);
  7796.             POP(backtrack_stack, backtrack_frame_bytes);
  7797. #ifdef RX_DEBUG
  7798.             --backtrack_depth;
  7799. #endif
  7800.             goto restart;
  7801.               }
  7802.             else
  7803.               {
  7804.             if (counter_stack)
  7805.               {
  7806.                 struct counter_frame * old_cf
  7807.                   = ((struct counter_frame *)counter_stack->sp);
  7808.                 struct counter_frame * cf;
  7809.                 PUSH(counter_stack, sizeof (struct counter_frame));
  7810.                 cf = ((struct counter_frame *)counter_stack->sp);
  7811.                 cf->tag = old_cf->tag;
  7812.                 cf->val = old_cf->val;
  7813.                 cf->inherited_from = old_cf;
  7814.                 cf->cdr = 0;
  7815.               }            
  7816.             /* `Call' this test-match block */
  7817.             ifr = (bf->df->effects
  7818.                    ? &bf->df->side_effects_frame
  7819.                    : &bf->df->future_frame);
  7820.             goto recurse_test_match;
  7821.               }
  7822.  
  7823.             /* Returns in this block are accomplished by
  7824.              * goto test_do_return.  There are two cases.
  7825.              * If there is some search-stack left,
  7826.              * then it is a return from a `recursive' call.
  7827.              * If there is no search-stack left, then
  7828.              * we should return to the fastmap/search loop.
  7829.              */
  7830.             
  7831.           test_do_return:
  7832.  
  7833.             if (!backtrack_stack)
  7834.               {
  7835. #ifdef RX_DEBUG
  7836.             if (rx_debug_trace)
  7837.               fprintf (stderr, "!!! %d bails returning %d !!!\n",
  7838.                    line_no, test_ret);
  7839. #endif
  7840.  
  7841.             /* No more search-stack -- this test is done. */
  7842.             if (test_ret)
  7843.               goto return_from_test_match;
  7844.             else
  7845.               goto error_in_testing_match;
  7846.               }
  7847.  
  7848.             /* Ok..we're returning from a recursive call to 
  7849.              * the test match block:
  7850.              */
  7851.             
  7852.             bf = ((struct backtrack_frame *)
  7853.               backtrack_stack->sp);
  7854. #ifdef RX_DEBUG
  7855.             if (rx_debug_trace)
  7856.               fprintf (stderr, "+++ %d returns %d (to %d)+++\n",
  7857.                    line_no, test_ret, bf->stk_line_no);
  7858. #endif
  7859.  
  7860.             while (counter_stack
  7861.                && (!bf->counter_stack_sp
  7862.                    || (bf->counter_stack_sp != counter_stack->sp)))
  7863.               {
  7864.             POP(counter_stack, sizeof (struct counter_frame));
  7865.               }
  7866.  
  7867.             if (!test_ret)
  7868.               {
  7869.             POP (backtrack_stack, backtrack_frame_bytes);
  7870.             goto test_do_return;
  7871.               }
  7872.  
  7873.             /* If any possible future reaches the end of the 
  7874.              * string without failing, make sure we propogate 
  7875.              * that information to the caller.
  7876.              */
  7877.             if ((test_ret == -2) && first_found)
  7878.               {
  7879.             rx_unlock_superstate (&rxb->rx, bf->stk_super);
  7880.             POP (backtrack_stack, backtrack_frame_bytes);
  7881.             goto test_do_return;
  7882.               }
  7883.  
  7884.             if (bf->stk_test_ret < 0)
  7885.               test_ret = bf->stk_test_ret;
  7886.  
  7887.             last_l = bf->stk_last_l;
  7888.             last_r = bf->stk_last_r;
  7889.             bf->df = bf->df->next_same_super_edge[0];
  7890.             super = bf->stk_super;
  7891.             tst_pos = bf->stk_tst_pos;
  7892.             tst_half = bf->stk_tst_half;
  7893.             c = bf->stk_c;
  7894.             tst_str_half = bf->stk_tst_str_half;
  7895.             tst_end_half = bf->stk_tst_end_half;
  7896. #ifdef RX_DEBUG
  7897.             line_no = bf->stk_line_no;
  7898. #endif
  7899.  
  7900.             if (rxb->match_regs_on_stack)
  7901.               {
  7902.             int x;
  7903.             regoff_t * stk =
  7904.               (regoff_t *)((char *)bf + sizeof (*bf));
  7905.             for (x = 0; x <= last_l; ++x)
  7906.               lparen[x] = stk[x];
  7907.             stk += x;
  7908.             for (x = 0; x <= last_r; ++x)
  7909.               rparen[x] = stk[x];
  7910.               }
  7911.  
  7912.             goto while_non_det_options;
  7913.           }
  7914.  
  7915.           
  7916.         case OF(rx_cache_miss,cache_miss):
  7917.           /* Because the superstate NFA is lazily constructed,
  7918.            * and in fact may erode from underneath us, we sometimes
  7919.            * have to construct the next instruction from the hard way.
  7920.            * This invokes one step in the lazy-conversion.
  7921.            */
  7922.           ifr = rx_handle_cache_miss (&rxb->rx, super, c, ifr->data_2);
  7923.           if (!ifr)
  7924.             {
  7925.               test_ret = 0;
  7926.               goto test_do_return;
  7927.             }
  7928.           goto restart;
  7929.           
  7930.         case OF(rx_backtrack,backtrack):
  7931.           /* RX_BACKTRACK means that we've reached the empty
  7932.            * superstate, indicating that match can't succeed
  7933.            * from this point.
  7934.            */
  7935.           goto test_do_return;
  7936.         case rx_next_char:
  7937.         case rx_error_inx:
  7938.         case rx_num_instructions:
  7939.           ret_val = 0;
  7940.           goto test_do_return;
  7941.         }
  7942.         }
  7943.     }
  7944.  
  7945.  
  7946.     /* Healthy exists from the test-match loop do a 
  7947.      * `goto return_from_test_match'   On the other hand, 
  7948.      * we might end up here.
  7949.      */
  7950.       error_in_testing_match:
  7951.     ret_val = -2;
  7952.     goto finish;
  7953.  
  7954.  
  7955.     /***** fastmap/search loop body
  7956.      *          considering the results testing for a match
  7957.      */
  7958.  
  7959.       return_from_test_match:
  7960.  
  7961.     if (best_last_l >= 0)
  7962.       {
  7963.         if (regs && (regs->start != best_lparen))
  7964.           {
  7965.         bcopy (best_lparen, regs->start,
  7966.                regs->num_regs * sizeof (int));
  7967.         bcopy (best_rparen, regs->end,
  7968.                regs->num_regs * sizeof (int));
  7969.           }
  7970.         if (regs && !rxb->no_sub)
  7971.           {
  7972.         int q;
  7973.         int bound = (regs->num_regs > num_regs
  7974.                  ? regs->num_regs
  7975.                  : num_regs);
  7976.         regoff_t * s = regs->start;
  7977.         regoff_t * e = regs->end;
  7978.         for (q = best_last_l + 1;  q < bound; ++q)
  7979.           s[q] = e[q] = -1;
  7980.           }
  7981.         ret_val = best_lparen[0];
  7982.         goto finish;
  7983.       }
  7984.  
  7985.     /***** fastmap/search loop,  increment and loop-test */
  7986.  
  7987.     pos += search_direction;
  7988.     startpos += search_direction;
  7989.  
  7990.       } while (startpos < search_end);
  7991.  
  7992.  
  7993.   /**** Exit code for fastmap/searchloop and the entire re_search_2 fn. */
  7994.  
  7995.   finish:
  7996.     /* Unset the fastmap sentinel */
  7997.     if (fastmap_chr >= 0)
  7998.       fastmap[fastmap_chr] = fastmap_val;
  7999.  
  8000.     if (start_super)
  8001.       rx_unlock_superstate (&rxb->rx, start_super);
  8002.  
  8003. #ifdef REGEX_MALLOC
  8004.     if (lparen) free (lparen);
  8005.     if (rparen) free (rparen);
  8006.     if (best_lpspace) free (best_lpspace);
  8007.     if (best_rpspace) free (best_rpspace);
  8008. #endif
  8009.     return ret_val;
  8010.   }
  8011. }
  8012.  
  8013. #if !defined(REGEX_MALLOC) && !defined(__GNUC__)
  8014. #ifdef __STDC__
  8015. int
  8016. re_search_2 (struct re_pattern_buffer *rxb,
  8017.          const char * string1, int size1,
  8018.          const char * string2, int size2,
  8019.          int startpos, int range,
  8020.          struct re_registers *regs,
  8021.          int stop)
  8022. #else
  8023. int
  8024. re_search_2 (rxb, string1, size1, string2, size2, startpos, range, regs, stop)
  8025.      struct re_pattern_buffer *rxb;
  8026.      const char * string1;
  8027.      int size1;
  8028.      const char * string2;
  8029.      int size2;
  8030.      int startpos;
  8031.      int range;
  8032.      struct re_registers *regs;
  8033.      int stop;
  8034. #endif
  8035. {
  8036.   int ret;
  8037.   ret = inner_re_search_2 (rxb, string1, size1, string2, size2, startpos,
  8038.                range, regs, stop);
  8039.   alloca (0);
  8040.   return ret;
  8041. }
  8042. #endif
  8043.  
  8044.  
  8045. /* Like re_search_2, above, but only one string is specified, and
  8046.  * doesn't let you say where to stop matching.
  8047.  */
  8048.  
  8049. #ifdef __STDC__
  8050. int
  8051. re_search (struct re_pattern_buffer * rxb, const char *string,
  8052.        int size, int startpos, int range,
  8053.        struct re_registers *regs)
  8054. #else
  8055. int
  8056. re_search (rxb, string, size, startpos, range, regs)
  8057.      struct re_pattern_buffer * rxb;
  8058.      const char * string;
  8059.      int size;
  8060.      int startpos;
  8061.      int range;
  8062.      struct re_registers *regs;
  8063. #endif
  8064. {
  8065.   return re_search_2 (rxb, 0, 0, string, size, startpos, range, regs, size);
  8066. }
  8067.  
  8068. #ifdef __STDC__
  8069. int
  8070. re_match_2 (struct re_pattern_buffer * rxb,
  8071.         const char * string1, int size1,
  8072.         const char * string2, int size2,
  8073.         int pos, struct re_registers *regs, int stop)
  8074. #else
  8075. int
  8076. re_match_2 (rxb, string1, size1, string2, size2, pos, regs, stop)
  8077.      struct re_pattern_buffer * rxb;
  8078.      const char * string1;
  8079.      int size1;
  8080.      const char * string2;
  8081.      int size2;
  8082.      int pos;
  8083.      struct re_registers *regs;
  8084.      int stop;
  8085. #endif
  8086. {
  8087.   struct re_registers some_regs;
  8088.   regoff_t start;
  8089.   regoff_t end;
  8090.   int srch;
  8091.   int save = rxb->regs_allocated;
  8092.   struct re_registers * regs_to_pass = regs;
  8093.  
  8094.   if (!regs)
  8095.     {
  8096.       some_regs.start = &start;
  8097.       some_regs.end = &end;
  8098.       some_regs.num_regs = 1;
  8099.       regs_to_pass = &some_regs;
  8100.       rxb->regs_allocated = REGS_FIXED;
  8101.     }
  8102.  
  8103.   srch = re_search_2 (rxb, string1, size1, string2, size2,
  8104.               pos, 1, regs_to_pass, stop);
  8105.   if (regs_to_pass != regs)
  8106.     rxb->regs_allocated = save;
  8107.   if (srch < 0)
  8108.     return srch;
  8109.   return regs_to_pass->end[0] - regs_to_pass->start[0];
  8110. }
  8111.  
  8112. /* re_match is like re_match_2 except it takes only a single string.  */
  8113.  
  8114. #ifdef __STDC__
  8115. int
  8116. re_match (struct re_pattern_buffer * rxb,
  8117.       const char * string,
  8118.       int size, int pos,
  8119.       struct re_registers *regs)
  8120. #else
  8121. int
  8122. re_match (rxb, string, size, pos, regs)
  8123.      struct re_pattern_buffer * rxb;
  8124.      const char *string;
  8125.      int size;
  8126.      int pos;
  8127.      struct re_registers *regs;
  8128. #endif
  8129. {
  8130.   return re_match_2 (rxb, string, size, 0, 0, pos, regs, size);
  8131. }
  8132.  
  8133.  
  8134.  
  8135. /* Set by `re_set_syntax' to the current regexp syntax to recognize.  Can
  8136.    also be assigned to arbitrarily: each pattern buffer stores its own
  8137.    syntax, so it can be changed between regex compilations.  */
  8138. reg_syntax_t re_syntax_options = RE_SYNTAX_EMACS;
  8139.  
  8140.  
  8141. /* Specify the precise syntax of regexps for compilation.  This provides
  8142.    for compatibility for various utilities which historically have
  8143.    different, incompatible syntaxes.
  8144.  
  8145.    The argument SYNTAX is a bit mask comprised of the various bits
  8146.    defined in regex.h.  We return the old syntax.  */
  8147.  
  8148. #ifdef __STDC__
  8149. reg_syntax_t
  8150. re_set_syntax (reg_syntax_t syntax)
  8151. #else
  8152. reg_syntax_t
  8153. re_set_syntax (syntax)
  8154.     reg_syntax_t syntax;
  8155. #endif
  8156. {
  8157.   reg_syntax_t ret = re_syntax_options;
  8158.  
  8159.   re_syntax_options = syntax;
  8160.   return ret;
  8161. }
  8162.  
  8163.  
  8164. /* Set REGS to hold NUM_REGS registers, storing them in STARTS and
  8165.    ENDS.  Subsequent matches using PATTERN_BUFFER and REGS will use
  8166.    this memory for recording register information.  STARTS and ENDS
  8167.    must be allocated using the malloc library routine, and must each
  8168.    be at least NUM_REGS * sizeof (regoff_t) bytes long.
  8169.  
  8170.    If NUM_REGS == 0, then subsequent matches should allocate their own
  8171.    register data.
  8172.  
  8173.    Unless this function is called, the first search or match using
  8174.    PATTERN_BUFFER will allocate its own register data, without
  8175.    freeing the old data.  */
  8176.  
  8177. #ifdef __STDC__
  8178. void
  8179. re_set_registers (struct re_pattern_buffer *bufp,
  8180.           struct re_registers *regs,
  8181.           unsigned num_regs,
  8182.           regoff_t * starts, regoff_t * ends)
  8183. #else
  8184. void
  8185. re_set_registers (bufp, regs, num_regs, starts, ends)
  8186.      struct re_pattern_buffer *bufp;
  8187.      struct re_registers *regs;
  8188.      unsigned num_regs;
  8189.      regoff_t * starts;
  8190.      regoff_t * ends;
  8191. #endif
  8192. {
  8193.   if (num_regs)
  8194.     {
  8195.       bufp->regs_allocated = REGS_REALLOCATE;
  8196.       regs->num_regs = num_regs;
  8197.       regs->start = starts;
  8198.       regs->end = ends;
  8199.     }
  8200.   else
  8201.     {
  8202.       bufp->regs_allocated = REGS_UNALLOCATED;
  8203.       regs->num_regs = 0;
  8204.       regs->start = regs->end = (regoff_t) 0;
  8205.     }
  8206. }
  8207.  
  8208.  
  8209.  
  8210.  
  8211. #ifdef __STDC__
  8212. static int 
  8213. cplx_se_sublist_len (struct rx_se_list * list)
  8214. #else
  8215. static int 
  8216. cplx_se_sublist_len (list)
  8217.      struct rx_se_list * list;
  8218. #endif
  8219. {
  8220.   int x = 0;
  8221.   while (list)
  8222.     {
  8223.       if ((int)list->car >= 0)
  8224.     ++x;
  8225.       list = list->cdr;
  8226.     }
  8227.   return x;
  8228. }
  8229.  
  8230.  
  8231. /* For rx->se_list_cmp */
  8232.  
  8233. #ifdef __STDC__
  8234. static int 
  8235. posix_se_list_order (struct rx * rx,
  8236.              struct rx_se_list * a, struct rx_se_list * b)
  8237. #else
  8238. static int 
  8239. posix_se_list_order (rx, a, b)
  8240.      struct rx * rx;
  8241.      struct rx_se_list * a;
  8242.      struct rx_se_list * b;
  8243. #endif
  8244. {
  8245.   int al = cplx_se_sublist_len (a);
  8246.   int bl = cplx_se_sublist_len (b);
  8247.  
  8248.   if (!al && !bl)
  8249.     return ((a == b)
  8250.         ? 0
  8251.         : ((a < b) ? -1 : 1));
  8252.   
  8253.   else if (!al)
  8254.     return -1;
  8255.  
  8256.   else if (!bl)
  8257.     return 1;
  8258.  
  8259.   else
  8260.     {
  8261.       rx_side_effect * av = ((rx_side_effect *)
  8262.                  alloca (sizeof (rx_side_effect) * (al + 1)));
  8263.       rx_side_effect * bv = ((rx_side_effect *)
  8264.                  alloca (sizeof (rx_side_effect) * (bl + 1)));
  8265.       struct rx_se_list * ap = a;
  8266.       struct rx_se_list * bp = b;
  8267.       int ai, bi;
  8268.       
  8269.       for (ai = al - 1; ai >= 0; --ai)
  8270.     {
  8271.       while ((int)ap->car < 0)
  8272.         ap = ap->cdr;
  8273.       av[ai] = ap->car;
  8274.       ap = ap->cdr;
  8275.     }
  8276.       av[al] = (rx_side_effect)-2;
  8277.       for (bi = bl - 1; bi >= 0; --bi)
  8278.     {
  8279.       while ((int)bp->car < 0)
  8280.         bp = bp->cdr;
  8281.       bv[bi] = bp->car;
  8282.       bp = bp->cdr;
  8283.     }
  8284.       bv[bl] = (rx_side_effect)-1;
  8285.  
  8286.       {
  8287.     int ret;
  8288.     int x = 0;
  8289.     while (av[x] == bv[x])
  8290.       ++x;
  8291.     ret = ((av[x] < bv[x]) ? -1 : 1);
  8292.     return ret;
  8293.       }
  8294.     }
  8295. }
  8296.  
  8297.  
  8298.  
  8299.  
  8300. /* re_compile_pattern is the GNU regular expression compiler: it
  8301.    compiles PATTERN (of length SIZE) and puts the result in RXB.
  8302.    Returns 0 if the pattern was valid, otherwise an error string.
  8303.  
  8304.    Assumes the `allocated' (and perhaps `buffer') and `translate' fields
  8305.    are set in RXB on entry.
  8306.  
  8307.    We call rx_compile to do the actual compilation.  */
  8308.  
  8309. #ifdef __STDC__
  8310. const char *
  8311. re_compile_pattern (const char *pattern,
  8312.             int length,
  8313.             struct re_pattern_buffer * rxb)
  8314. #else
  8315. const char *
  8316. re_compile_pattern (pattern, length, rxb)
  8317.      const char *pattern;
  8318.      int length;
  8319.      struct re_pattern_buffer * rxb;
  8320. #endif
  8321. {
  8322.   reg_errcode_t ret;
  8323.  
  8324.   /* GNU code is written to assume at least RE_NREGS registers will be set
  8325.      (and at least one extra will be -1).  */
  8326.   rxb->regs_allocated = REGS_UNALLOCATED;
  8327.  
  8328.   /* And GNU code determines whether or not to get register information
  8329.      by passing null for the REGS argument to re_match, etc., not by
  8330.      setting no_sub.  */
  8331.   rxb->no_sub = 0;
  8332.  
  8333.   rxb->rx.local_cset_size = 256;
  8334.  
  8335.   /* Match anchors at newline.  */
  8336.   rxb->newline_anchor = 1;
  8337.  
  8338.   rxb->re_nsub = 0;
  8339.   rxb->start = 0;
  8340.   rxb->se_params = 0;
  8341.   rxb->rx.nodec = 0;
  8342.   rxb->rx.epsnodec = 0;
  8343.   rxb->rx.instruction_table = 0;
  8344.   rxb->rx.nfa_states = 0;
  8345.   rxb->rx.se_list_cmp = posix_se_list_order;
  8346.   rxb->rx.start_set = 0;
  8347.  
  8348.   ret = rx_compile (pattern, length, re_syntax_options, rxb);
  8349.   alloca (0);
  8350.   return rx_error_msg[(int) ret];
  8351. }
  8352.  
  8353.  
  8354.  
  8355. #ifdef __STDC__
  8356. int
  8357. re_compile_fastmap (struct re_pattern_buffer * rxb)
  8358. #else
  8359. int
  8360. re_compile_fastmap (rxb)
  8361.      struct re_pattern_buffer * rxb;
  8362. #endif
  8363. {
  8364.   rx_blow_up_fastmap (rxb);
  8365.   return 0;
  8366. }
  8367.  
  8368.  
  8369.  
  8370.  
  8371. /* Entry points compatible with 4.2 BSD regex library.  We don't define
  8372.    them if this is an Emacs or POSIX compilation.  */
  8373.  
  8374. #if !defined (emacs) && !defined (_POSIX_SOURCE) && 0
  8375.  
  8376. /* BSD has one and only one pattern buffer.  */
  8377. static struct re_pattern_buffer rx_comp_buf;
  8378.  
  8379. #ifdef __STDC__
  8380. char *
  8381. re_comp (const char *s)
  8382. #else
  8383. char *
  8384. re_comp (s)
  8385.     const char *s;
  8386. #endif
  8387. {
  8388.   reg_errcode_t ret;
  8389.  
  8390.   if (!s)
  8391.     {
  8392.       if (!rx_comp_buf.buffer)
  8393.     return "No previous regular expression";
  8394.       return 0;
  8395.     }
  8396.  
  8397.   if (!rx_comp_buf.fastmap)
  8398.     {
  8399.       rx_comp_buf.fastmap = (char *) malloc (1 << BYTEWIDTH);
  8400.       if (!rx_comp_buf.fastmap)
  8401.     return "Memory exhausted";
  8402.     }
  8403.  
  8404.   /* Since `rx_exec' always passes NULL for the `regs' argument, we
  8405.      don't need to initialize the pattern buffer fields which affect it.  */
  8406.  
  8407.   /* Match anchors at newlines.  */
  8408.   rx_comp_buf.newline_anchor = 1;
  8409.  
  8410.   rx_comp_buf.re_nsub = 0;
  8411.   rx_comp_buf.start = 0;
  8412.   rx_comp_buf.se_params = 0;
  8413.   rx_comp_buf.rx.nodec = 0;
  8414.   rx_comp_buf.rx.epsnodec = 0;
  8415.   rx_comp_buf.rx.instruction_table = 0;
  8416.   rx_comp_buf.rx.nfa_states = 0;
  8417.   rx_comp_buf.rx.start = 0;
  8418.   rx_comp_buf.rx.se_list_cmp = posix_se_list_order;
  8419.  
  8420.   ret = rx_compile (s, strlen (s), rx_syntax_options, &rx_comp_buf);
  8421.   alloca (0);
  8422.  
  8423.   /* Yes, we're discarding `const' here.  */
  8424.   return (char *) rx_error_msg[(int) ret];
  8425. }
  8426.  
  8427.  
  8428. #ifdef __STDC__
  8429. int
  8430. rx_exec (const char *s)
  8431. #else
  8432. int
  8433. rx_exec (s)
  8434.     const char *s;
  8435. #endif
  8436. {
  8437.   const int len = strlen (s);
  8438.   return
  8439.     0 <= re_search (&rx_comp_buf, s, len, 0, len, (struct rx_registers *) 0);
  8440. }
  8441. #endif /* not emacs and not _POSIX_SOURCE */
  8442.  
  8443.  
  8444.  
  8445. /* POSIX.2 functions.  Don't define these for Emacs.  */
  8446.  
  8447. #if !defined(emacs)
  8448.  
  8449. /* regcomp takes a regular expression as a string and compiles it.
  8450.  
  8451.    PREG is a regex_t *.  We do not expect any fields to be initialized,
  8452.    since POSIX says we shouldn't.  Thus, we set
  8453.  
  8454.      `buffer' to the compiled pattern;
  8455.      `used' to the length of the compiled pattern;
  8456.      `syntax' to RE_SYNTAX_POSIX_EXTENDED if the
  8457.        REG_EXTENDED bit in CFLAGS is set; otherwise, to
  8458.        RE_SYNTAX_POSIX_BASIC;
  8459.      `newline_anchor' to REG_NEWLINE being set in CFLAGS;
  8460.      `fastmap' and `fastmap_accurate' to zero;
  8461.      `re_nsub' to the number of subexpressions in PATTERN.
  8462.  
  8463.    PATTERN is the address of the pattern string.
  8464.  
  8465.    CFLAGS is a series of bits which affect compilation.
  8466.  
  8467.      If REG_EXTENDED is set, we use POSIX extended syntax; otherwise, we
  8468.      use POSIX basic syntax.
  8469.  
  8470.      If REG_NEWLINE is set, then . and [^...] don't match newline.
  8471.      Also, regexec will try a match beginning after every newline.
  8472.  
  8473.      If REG_ICASE is set, then we considers upper- and lowercase
  8474.      versions of letters to be equivalent when matching.
  8475.  
  8476.      If REG_NOSUB is set, then when PREG is passed to regexec, that
  8477.      routine will report only success or failure, and nothing about the
  8478.      registers.
  8479.  
  8480.    It returns 0 if it succeeds, nonzero if it doesn't.  (See regex.h for
  8481.    the return codes and their meanings.)  */
  8482.  
  8483.  
  8484. #ifdef __STDC__
  8485. int
  8486. regcomp (regex_t * preg, const char * pattern, int cflags)
  8487. #else
  8488. int
  8489. regcomp (preg, pattern, cflags)
  8490.     regex_t * preg;
  8491.     const char * pattern;
  8492.     int cflags;
  8493. #endif
  8494. {
  8495.   reg_errcode_t ret;
  8496.   unsigned syntax
  8497.     = cflags & REG_EXTENDED ? RE_SYNTAX_POSIX_EXTENDED : RE_SYNTAX_POSIX_BASIC;
  8498.  
  8499.   /* regex_compile will allocate the space for the compiled pattern.  */
  8500.   preg->buffer = 0;
  8501.   preg->allocated = 0;
  8502.  
  8503.   preg->fastmap = malloc (256);
  8504.   if (!preg->fastmap)
  8505.     return REG_ESPACE;
  8506.   preg->fastmap_accurate = 0;
  8507.  
  8508.   if (cflags & REG_ICASE)
  8509.     {
  8510.       unsigned i;
  8511.  
  8512.       preg->translate = (char *) malloc (256);
  8513.       if (!preg->translate)
  8514.         return (int) REG_ESPACE;
  8515.  
  8516.       /* Map uppercase characters to corresponding lowercase ones.  */
  8517.       for (i = 0; i < CHAR_SET_SIZE; i++)
  8518.         preg->translate[i] = isupper (i) ? tolower (i) : i;
  8519.     }
  8520.   else
  8521.     preg->translate = 0;
  8522.  
  8523.   /* If REG_NEWLINE is set, newlines are treated differently.  */
  8524.   if (cflags & REG_NEWLINE)
  8525.     { /* REG_NEWLINE implies neither . nor [^...] match newline.  */
  8526.       syntax &= ~RE_DOT_NEWLINE;
  8527.       syntax |= RE_HAT_LISTS_NOT_NEWLINE;
  8528.       /* It also changes the matching behavior.  */
  8529.       preg->newline_anchor = 1;
  8530.     }
  8531.   else
  8532.     preg->newline_anchor = 0;
  8533.  
  8534.   preg->no_sub = !!(cflags & REG_NOSUB);
  8535.  
  8536.   /* POSIX says a null character in the pattern terminates it, so we
  8537.      can use strlen here in compiling the pattern.  */
  8538.   preg->re_nsub = 0;
  8539.   preg->start = 0;
  8540.   preg->se_params = 0;
  8541.   preg->rx.nodec = 0;
  8542.   preg->rx.epsnodec = 0;
  8543.   preg->rx.instruction_table = 0;
  8544.   preg->rx.nfa_states = 0;
  8545.   preg->rx.local_cset_size = 256;
  8546.   preg->rx.start = 0;
  8547.   preg->rx.se_list_cmp = posix_se_list_order;
  8548.   preg->rx.start_set = 0;
  8549.   ret = rx_compile (pattern, strlen (pattern), syntax, preg);
  8550.   alloca (0);
  8551.  
  8552.   /* POSIX doesn't distinguish between an unmatched open-group and an
  8553.      unmatched close-group: both are REG_EPAREN.  */
  8554.   if (ret == REG_ERPAREN) ret = REG_EPAREN;
  8555.  
  8556.   return (int) ret;
  8557. }
  8558.  
  8559.  
  8560. /* regexec searches for a given pattern, specified by PREG, in the
  8561.    string STRING.
  8562.  
  8563.    If NMATCH is zero or REG_NOSUB was set in the cflags argument to
  8564.    `regcomp', we ignore PMATCH.  Otherwise, we assume PMATCH has at
  8565.    least NMATCH elements, and we set them to the offsets of the
  8566.    corresponding matched substrings.
  8567.  
  8568.    EFLAGS specifies `execution flags' which affect matching: if
  8569.    REG_NOTBOL is set, then ^ does not match at the beginning of the
  8570.    string; if REG_NOTEOL is set, then $ does not match at the end.
  8571.  
  8572.    We return 0 if we find a match and REG_NOMATCH if not.  */
  8573.  
  8574. #ifdef __STDC__
  8575. int
  8576. regexec (const regex_t *preg, const char *string,
  8577.      size_t nmatch, regmatch_t pmatch[],
  8578.      int eflags)
  8579. #else
  8580. int
  8581. regexec (preg, string, nmatch, pmatch, eflags)
  8582.     const regex_t *preg;
  8583.     const char *string;
  8584.     size_t nmatch;
  8585.     regmatch_t pmatch[];
  8586.     int eflags;
  8587. #endif
  8588. {
  8589.   int ret;
  8590.   struct re_registers regs;
  8591.   regex_t private_preg;
  8592.   int len = strlen (string);
  8593.   boolean want_reg_info = !preg->no_sub && nmatch > 0;
  8594.  
  8595.   private_preg = *preg;
  8596.  
  8597.   private_preg.not_bol = !!(eflags & REG_NOTBOL);
  8598.   private_preg.not_eol = !!(eflags & REG_NOTEOL);
  8599.  
  8600.   /* The user has told us exactly how many registers to return
  8601.    * information about, via `nmatch'.  We have to pass that on to the
  8602.    * matching routines.
  8603.    */
  8604.   private_preg.regs_allocated = REGS_FIXED;
  8605.  
  8606.   if (want_reg_info)
  8607.     {
  8608.       regs.num_regs = nmatch;
  8609.       regs.start = TALLOC (nmatch, regoff_t);
  8610.       regs.end = TALLOC (nmatch, regoff_t);
  8611.       if (regs.start == 0 || regs.end == 0)
  8612.         return (int) REG_NOMATCH;
  8613.     }
  8614.  
  8615.   /* Perform the searching operation.  */
  8616.   ret = re_search (&private_preg,
  8617.            string, len,
  8618.                    /* start: */ 0,
  8619.            /* range: */ len,
  8620.                    want_reg_info ? ®s : (struct re_registers *) 0);
  8621.  
  8622.   /* Copy the register information to the POSIX structure.  */
  8623.   if (want_reg_info)
  8624.     {
  8625.       if (ret >= 0)
  8626.         {
  8627.           unsigned r;
  8628.  
  8629.           for (r = 0; r < nmatch; r++)
  8630.             {
  8631.               pmatch[r].rm_so = regs.start[r];
  8632.               pmatch[r].rm_eo = regs.end[r];
  8633.             }
  8634.         }
  8635.  
  8636.       /* If we needed the temporary register info, free the space now.  */
  8637.       free (regs.start);
  8638.       free (regs.end);
  8639.     }
  8640.  
  8641.   /* We want zero return to mean success, unlike `re_search'.  */
  8642.   return ret >= 0 ? (int) REG_NOERROR : (int) REG_NOMATCH;
  8643. }
  8644.  
  8645.  
  8646. /* Returns a message corresponding to an error code, ERRCODE, returned
  8647.    from either regcomp or regexec.   */
  8648.  
  8649. #ifdef __STDC__
  8650. size_t
  8651. regerror (int errcode, const regex_t *preg,
  8652.       char *errbuf, size_t errbuf_size)
  8653. #else
  8654. size_t
  8655. regerror (errcode, preg, errbuf, errbuf_size)
  8656.     int errcode;
  8657.     const regex_t *preg;
  8658.     char *errbuf;
  8659.     size_t errbuf_size;
  8660. #endif
  8661. {
  8662.   const char *msg
  8663.     = rx_error_msg[errcode] == 0 ? "Success" : rx_error_msg[errcode];
  8664.   size_t msg_size = strlen (msg) + 1; /* Includes the 0.  */
  8665.  
  8666.   if (errbuf_size != 0)
  8667.     {
  8668.       if (msg_size > errbuf_size)
  8669.         {
  8670.           strncpy (errbuf, msg, errbuf_size - 1);
  8671.           errbuf[errbuf_size - 1] = 0;
  8672.         }
  8673.       else
  8674.         strcpy (errbuf, msg);
  8675.     }
  8676.  
  8677.   return msg_size;
  8678. }
  8679.  
  8680.  
  8681. /* Free dynamically allocated space used by PREG.  */
  8682.  
  8683. #ifdef __STDC__
  8684. void
  8685. regfree (regex_t *preg)
  8686. #else
  8687. void
  8688. regfree (preg)
  8689.     regex_t *preg;
  8690. #endif
  8691. {
  8692.   if (preg->buffer != 0)
  8693.     free (preg->buffer);
  8694.   preg->buffer = 0;
  8695.   preg->allocated = 0;
  8696.  
  8697.   if (preg->fastmap != 0)
  8698.     free (preg->fastmap);
  8699.   preg->fastmap = 0;
  8700.   preg->fastmap_accurate = 0;
  8701.  
  8702.   if (preg->translate != 0)
  8703.     free (preg->translate);
  8704.   preg->translate = 0;
  8705. }
  8706.  
  8707. #endif /* not emacs  */
  8708.  
  8709.  
  8710.  
  8711.  
  8712.  
  8713.