394 print_compiled_pattern (rxb)  in print_compiled_pattern()  argument
395      struct re_pattern_buffer * rxb;  in print_compiled_pattern()
4207 inverse_translation (struct re_pattern_buffer * rxb,  in inverse_translation()  argument
4212 inverse_translation (rxb, valid, cache, translate, c)  in inverse_translation()
4213      struct re_pattern_buffer * rxb;  in inverse_translation()
4221     = cache + c * rx_bitset_numb_subsets (rxb->rx.local_cset_size); 
4227       rx_bitset_null (rxb->rx.local_cset_size, cs);
4282 compile_range (struct re_pattern_buffer * rxb, rx_Bitset cs,
4288 compile_range (rxb, cs, p_ptr, pend, translate, syntax, inv_tr, valid_inv_tr)
4289      struct re_pattern_buffer * rxb;
4319 	inverse_translation (rxb, valid_inv_tr, inv_tr, translate, this_char);
4320       rx_bitset_union (rxb->rx.local_cset_size, cs, it);
4328 compile_range (struct re_pattern_buffer * rxb, rx_Bitset cs, unsigned short range_start, unsigned s…  in compile_range()  argument
4331 compile_range (rxb, cs, range_start, range_end, translate, syntax, inv_tr, valid_inv_tr)  in compile_range()
4332      struct re_pattern_buffer * rxb;  in compile_range()
4356 	      inverse_translation (rxb, valid_inv_tr, inv_tr, translate, this_char);
4357 	    rx_bitset_union (rxb->rx.local_cset_size, cs, it);
4451 compute_fastset (struct re_pattern_buffer * rxb, struct rexp_node * rexp)  in compute_fastset()  argument
4454 compute_fastset (rxb, rexp)  in compute_fastset()
4455      struct re_pattern_buffer * rxb;  in compute_fastset()
4467 	rx_bitset_union (rxb->rx.local_cset_size,
4468 			 rxb->fastset, rexp->params.cset);
4473       return (compute_fastset (rxb, rexp->params.pair.left)
4474 	      && compute_fastset (rxb, rexp->params.pair.right));
4476       compute_fastset (rxb, rexp->params.pair.left);
4480       return !!(compute_fastset (rxb, rexp->params.pair.left)
4481 		+ compute_fastset (rxb, rexp->params.pair.right));
4484       compute_fastset (rxb, rexp->params.pair.left);
4705 registers_on_stack (struct re_pattern_buffer * rxb,  in registers_on_stack()  argument
4710 registers_on_stack (rxb, rexp, in_danger, params)  in registers_on_stack()
4711      struct re_pattern_buffer * rxb;  in registers_on_stack()
4728 	return (   registers_on_stack (rxb, rexp->params.pair.left,
4731 		    (rxb, rexp->params.pair.right,
4734 	return registers_on_stack (rxb, rexp->params.pair.left, 0, params);
4736 	return registers_on_stack (rxb, rexp->params.pair.left, 1, params);
4739 	  (   registers_on_stack (rxb, rexp->params.pair.left, 1, params)
4740 	   || registers_on_stack (rxb, rexp->params.pair.right, 1, params));
5140 	    struct re_pattern_buffer * rxb)   in rx_compile()  argument
5143 rx_compile (pattern, size, syntax, rxb)  in rx_compile()
5147      struct re_pattern_buffer * rxb;
5174   unsigned char *translate = (rxb->translate
5175 			      ? rxb->translate
5212   rxb->rx.instruction_table = rx_id_instruction_table;
5224   rxb->rx.cache = &default_cache;
5225   rxb->syntax = syntax;
5226   rxb->fastmap_accurate = 0;
5227   rxb->not_bol = rxb->not_eol = 0;
5228   rxb->least_subs = 0;
5234   rxb->re_nsub = 0;
5258 		  = rx_mk_r_side_effect (&rxb->rx, (rx_side_effect)re_se_hat);
5280 		  = rx_mk_r_side_effect (&rxb->rx, (rx_side_effect)re_se_dollar);
5369 		  && has_non_idempotent_epsilon_path (&rxb->rx,
5373 		    = rx_mk_r_side_effect (&rxb->rx,
5376 		    = rx_mk_r_side_effect (&rxb->rx,
5379 		    = rx_mk_r_side_effect (&rxb->rx,
5381 		  rx_Bitset cs = rx_cset (&rxb->rx);
5382 		  struct rexp_node * lit_t = rx_mk_r_cset (&rxb->rx, cs);
5384 		    = rx_mk_r_concat (&rxb->rx, pushback, lit_t);
5386 		    = rx_mk_r_concat (&rxb->rx, checker, fake_state);
5388 		    = rx_mk_r_side_effect (&rxb->rx,
5391 		    = rx_mk_r_2phase_star (&rxb->rx, inner_exp, phase2);
5393 		    = rx_mk_r_concat (&rxb->rx, pusher, star);
5395 		    = rx_mk_r_concat (&rxb->rx, a, popper);
5407 		      (&rxb->rx, *last_expression);
5411 		  need_sync = has_any_se (&rxb->rx, *last_expression);
5416 		    = rx_mk_r_concat (&rxb->rx,
5417 				      rx_copy_rexp (&rxb->rx,
5450 	    rx_Bitset cs = rx_cset (&rxb->rx);
5451 	    struct rexp_node * n = rx_mk_r_cset (&rxb->rx, cs);
5456 	      rx_Bitset it = csetbit (rxb->rx.local_cset_size, cs_ready, cs_cset, syntax, 0);
5457 	      rx_bitset_union (rxb->rx.local_cset_size, cs, it);
5475 		  struct rexp_node * mbcs_cset = rx_mbcset (&rxb->rx);
5477 		    = rx_mk_r_side_effect (&rxb->rx, (rx_side_effect) sync_se);
5478 		  struct rexp_node * conc = rx_mk_r_concat (&rxb->rx, sync, mbcs_cset);
5479 		  struct rexp_node * alt = rx_mk_r_alternate (&rxb->rx, n, conc);
5484 		      = csetbit (rxb->rx.local_cset_size, cs_ready, cs_cset, syntax, 1);
5485 		    rx_bitset_union (rxb->rx.local_cset_size, RX_mbhcset (mbcs_cset), it);
5489 		      = csetbit (rxb->rx.local_cset_size, cs_ready, cs_cset, syntax, 2);
5490 		    rx_bitset_union (rxb->rx.local_cset_size, RX_mblcset (mbcs_cset), it);
5507 	    rx_Bitset cs = rx_cset (&rxb->rx);
5508 	    struct rexp_node * node = rx_mk_r_cset (&rxb->rx, cs);
5554 		      rx_Bitset it = inverse_translation (rxb, 
5559 		      rx_bitset_union (rxb->rx.local_cset_size, mbcset, it);
5610 		    ret = compile_range (rxb, mbcset, last_char, c1, translate, syntax,
5632                     ret = compile_range (rxb, mbcset, c, c1, translate, syntax,
5705 				  inverse_translation (rxb, 
5710 				rx_bitset_union (rxb->rx.local_cset_size,
5726 			    inverse_translation (rxb, 
5731 			  rx_bitset_union (rxb->rx.local_cset_size,
5736 			    inverse_translation (rxb, 
5741 			  rx_bitset_union (rxb->rx.local_cset_size,
5751 		    compile_range (rxb, mbcset, c, c, translate, syntax,
5760 		rx_bitset_complement (rxb->rx.local_cset_size, mbcset);
5764 	    rx_bitset_union (rxb->rx.local_cset_size, cs, mbcset);
5766 	      rx_Bitset it = csetbit (rxb->rx.local_cset_size, cs_ready, cs_cset, syntax, 4);
5767 	      rx_bitset_intersection (rxb->rx.local_cset_size, cs, it);
5773 		  = csetbit (rxb->rx.local_cset_size, cs_ready, cs_cset,
5777 		if (rx_bitset_empty (rxb->rx.local_cset_size, cs))
5779 		    rx_free_rexp (&rxb->rx, append);
5787 			rx_bitset_intersection (rxb->rx.local_cset_size, cs, it);
5789 			    && rx_bitset_is_equal (rxb->rx.local_cset_size,
5792 			else if (!rx_bitset_empty (rxb->rx.local_cset_size, cs))
5794 			    mbcs_cset = rx_mbcset (&rxb->rx);
5798 			    rx_bitset_union (rxb->rx.local_cset_size,
5818 				    = rx_mk_r_side_effect (&rxb->rx, (rx_side_effect) sync_se);
5820 				    = rx_mk_r_concat (&rxb->rx, sync, mbcs_cset);
5822 				    = rx_mk_r_alternate (&rxb->rx, append, conc);
5890               rxb->re_nsub++;
5905 		    = rx_mk_r_concat (&rxb->rx, *last_expression, 0);
5971 		      = rx_mk_r_side_effect (&rxb->rx,
5974 		      = rx_mk_r_side_effect (&rxb->rx,
5978 			 ? rx_mk_r_concat (&rxb->rx, left, *inner) : left);
5980 		      = rx_mk_r_concat (&rxb->rx, c1, right);
5998 		  = rx_mk_r_alternate (&rxb->rx, *top_expression, 0);
6019 		      = rx_mk_r_side_effect (&rxb->rx,
6022 		      = rx_mk_r_concat (&rxb->rx, sync, 0);
6114 			 rx_free_rexp (&rxb->rx, *last_expression);
6141 			= rx_mk_r_side_effect (&rxb->rx,
6144 			= rx_mk_r_side_effect (&rxb->rx,
6147 			= rx_mk_r_concat (&rxb->rx, start_one_iter,
6150 			= rx_mk_r_side_effect (&rxb->rx,
6152 		      rx_Bitset cs = rx_cset (&rxb->rx);
6154 			= rx_mk_r_cset (&rxb->rx, cs);
6156 			= rx_mk_r_concat (&rxb->rx, pushback, lit_t);
6158 			= rx_mk_r_2phase_star (&rxb->rx, phase1, phase2);
6160 			= rx_mk_r_concat (&rxb->rx, push0, loop);
6162 			= rx_mk_r_side_effect (&rxb->rx,
6165 			= rx_mk_r_concat (&rxb->rx, push_n_loop, final_test);
6207 		rx_Bitset cs = rx_cset (&rxb->rx);
6208 		struct rexp_node * set = rx_mk_r_cset (&rxb->rx, cs);
6212 		  rx_bitset_universe (rxb->rx.local_cset_size, cs);
6224 			    inverse_translation (rxb, validate_inv_tr,
6227 			  rx_bitset_xor (rxb->rx.local_cset_size, cs, it);
6241 		rx_Bitset cs = rx_cset (&rxb->rx);
6242 		struct rexp_node * n = (cs ? rx_mk_r_cset (&rxb->rx, cs) : 0);
6246 		  rx_bitset_universe (rxb->rx.local_cset_size ,cs);
6249 		  for (x = rxb->rx.local_cset_size - 1; x > 0; --x)
6255 		    = csetbit (rxb->rx.local_cset_size, cs_ready, cs_cset, syntax, 4);
6256 		  rx_bitset_intersection (rxb->rx.local_cset_size, cs, it);
6274 		      struct rexp_node * mbcs_cset = rx_mbcset (&rxb->rx);
6276 			= rx_mk_r_side_effect (&rxb->rx, (rx_side_effect) sync_se);
6277 		      struct rexp_node * conc = rx_mk_r_concat (&rxb->rx, sync, mbcs_cset);
6278 		      struct rexp_node * alt = rx_mk_r_alternate (&rxb->rx, n, conc);
6283 			  = csetbit (rxb->rx.local_cset_size, cs_ready, cs_cset, syntax, 5);
6284 			rx_bitset_union (rxb->rx.local_cset_size, RX_mbhcset (mbcs_cset), it);
6288 			  = csetbit (rxb->rx.local_cset_size, cs_ready, cs_cset, syntax, 6);
6289 			rx_bitset_union (rxb->rx.local_cset_size, RX_mblcset (mbcs_cset), it);
6337 		  = rx_mk_r_side_effect (&rxb->rx, side);
6406 		  struct rexp_node * mbcs_cset = rx_mbcset (&rxb->rx);
6417 	      cs = rx_cset(&rxb->rx);
6418 	      match = rx_mk_r_cset (&rxb->rx, cs);
6421 	      it = inverse_translation (rxb, validate_inv_tr,
6433 		    = rx_mk_r_concat (&rxb->rx, *last_expression, append);
6460 	= rx_mk_r_side_effect (&rxb->rx, (rx_side_effect)win_se);
6462 	= rx_mk_r_concat (&rxb->rx, rexp, se);
6481       dbug_rxb = rxb;
6485       rxb->se_params = params;
6486       print_rexp (&rxb->rx, orig_rexp, 2, re_seprint, stdout);
6490     rx_Bitset cs = rx_cset(&rxb->rx);
6491     rx_Bitset cs2 = rx_cset(&rxb->rx);
6499       remove_unecessary_side_effects (&rxb->rx, se_map,
6500 				      rx_copy_rexp (&rxb->rx, rexp), params);
6502     speed_up_alt (&rxb->rx, rexp, 0);
6503     speed_up_alt (&rxb->rx, fewer_side_effects, 1);
6506       char * syntax_parens = rxb->syntax_parens;
6509 	  (&rxb->rx, se_map, rexp, params);
6519 	    (&rxb->rx, se_map, rexp, params);
6555 	(&rxb->rx,
6556 	 rx_mk_r_concat (&rxb->rx, rx_mk_r_cset (&rxb->rx, cs2), rexp),
6557 	 rx_mk_r_concat (&rxb->rx,
6558 			 rx_mk_r_cset (&rxb->rx, cs), fewer_side_effects));
6571       print_rexp (&rxb->rx, rexp, 2, re_seprint, stdout);
6578     if (!rx_build_nfa (&rxb->rx, rexp, &start, &end))
6582 	void * mem = (void *)rxb->buffer;
6583 	unsigned long size = rxb->allocated;
6590 	rx_name_nfa_states (&rxb->rx);
6596 	    dbug_rxb = rxb;
6597 	    print_nfa (&rxb->rx, rxb->rx.nfa_states, re_seprint, stdout);
6600 	if (!rx_eclose_nfa (&rxb->rx))
6604 	    rx_delete_epsilon_transitions (&rxb->rx);
6609 	    rxb->rx.reserved = (   sizeof (params[0]) * paramc
6610 				+  rx_sizeof_bitset (rxb->rx.local_cset_size));
6614 		dbug_rxb = rxb;
6616 		print_nfa (&rxb->rx, rxb->rx.nfa_states, re_seprint, stdout);
6619 	    if (!rx_compactify_nfa (&rxb->rx, &mem, &size))
6621 	    rxb->buffer = mem;
6622 	    rxb->allocated = size;
6623 	    rxb->rx.buffer = mem;
6624 	    rxb->rx.allocated = size;
6625 	    perm_mem = ((char *)rxb->rx.buffer
6626 			+ rxb->rx.allocated - rxb->rx.reserved);
6627 	    rxb->se_params = ((struct re_se_params *)perm_mem);
6628 	    bcopy (params, rxb->se_params, iterator_size);
6630 	    rxb->fastset = (rx_Bitset) perm_mem;
6631 	    rxb->start = rx_id_to_nfa_state (&rxb->rx, start_id);
6633 	rx_bitset_null (rxb->rx.local_cset_size, rxb->fastset);
6634 	rxb->can_match_empty = compute_fastset (rxb, orig_rexp);
6635 	rxb->match_regs_on_stack =
6636 	  registers_on_stack (rxb, orig_rexp, 0, params); 
6637 	rxb->search_regs_on_stack =
6638 	  registers_on_stack (rxb, fewer_side_effects, 0, params);
6639 	if (rxb->can_match_empty)
6640 	  rx_bitset_universe (rxb->rx.local_cset_size, rxb->fastset);
6641 	rxb->is_anchored = is_anchored (orig_rexp, (rx_side_effect) re_se_hat);
6642 	rxb->begbuf_only = is_anchored (orig_rexp,
6645     rx_free_rexp (&rxb->rx, rexp);
6651 	dbug_rxb = rxb;
6653 	print_nfa (&rxb->rx, rxb->rx.nfa_states, re_seprint, stdout);
6710 rx_blow_up_fastmap (struct re_pattern_buffer * rxb)  in rx_blow_up_fastmap()  argument
6713 rx_blow_up_fastmap (rxb)  in rx_blow_up_fastmap()
6714      struct re_pattern_buffer * rxb;  in rx_blow_up_fastmap()
6719     rxb->fastmap [x] = !!RX_bitset_member (rxb->fastset, x);
6720   rxb->fastmap_accurate = 1;
6916 RE_SEARCH_2_FN (struct re_pattern_buffer *rxb,  in RE_SEARCH_2_FN()  argument
6924 RE_SEARCH_2_FN (rxb,  in RE_SEARCH_2_FN()
6926      struct re_pattern_buffer *rxb;  in RE_SEARCH_2_FN()
6943   answer = rx_search (rxb, startpos, range, stop, size1 + size2,
6968 re_rx_search (rxb, startpos, range, stop, total_size,  in re_rx_search()  argument
6971      struct re_pattern_buffer * rxb;  in re_rx_search()
6984   return rx_search (rxb, startpos, range, stop, total_size,
6992 re_search_2 (struct re_pattern_buffer *rxb,  in re_search_2()  argument
7000 re_search_2 (rxb, string1, size1, string2, size2, startpos, range, regs, stop)  in re_search_2()
7001      struct re_pattern_buffer *rxb;  in re_search_2()
7013   ret = inner_re_search_2 (rxb, string1, size1, string2, size2, startpos,
7027 re_search (struct re_pattern_buffer * rxb, __const__ char *string,  in re_search()  argument
7032 re_search (rxb, string, size, startpos, range, regs)  in re_search()
7033      struct re_pattern_buffer * rxb;  in re_search()
7041   return re_search_2 (rxb, 0, 0, string, size, startpos, range, regs, size);
7046 re_match_2 (struct re_pattern_buffer * rxb,  in re_match_2()  argument
7052 re_match_2 (rxb, string1, size1, string2, size2, pos, regs, stop)  in re_match_2()
7053      struct re_pattern_buffer * rxb;  in re_match_2()
7067   int save = rxb->regs_allocated;
7076       rxb->regs_allocated = REGS_FIXED;
7079   srch = re_search_2 (rxb, string1, size1, string2, size2,
7082     rxb->regs_allocated = save;
7092 re_match (struct re_pattern_buffer * rxb,  in re_match()  argument
7098 re_match (rxb, string, size, pos, regs)  in re_match()
7099      struct re_pattern_buffer * rxb;  in re_match()
7106   return re_match_2 (rxb, string, size, 0, 0, pos, regs, size);
7289 		    struct re_pattern_buffer * rxb)  in re_compile_pattern()  argument
7292 re_compile_pattern (pattern, length, rxb)  in re_compile_pattern()
7295      struct re_pattern_buffer * rxb;
7302   rxb->regs_allocated = REGS_UNALLOCATED;
7307   rxb->no_sub = 0;
7309   rxb->rx.local_cset_size = 256;
7312   rxb->newline_anchor = 1;
7314   rxb->re_nsub = 0;
7315   rxb->start = 0;
7316   rxb->se_params = 0;
7317   rxb->rx.nodec = 0;
7318   rxb->rx.epsnodec = 0;
7319   rxb->rx.instruction_table = 0;
7320   rxb->rx.nfa_states = 0;
7321   rxb->rx.se_list_cmp = posix_se_list_order;
7322   rxb->rx.start_set = 0;
7324   ret = rx_compile (pattern, length, re_syntax_options, rxb);
7333 re_compile_fastmap (struct re_pattern_buffer * rxb)  in re_compile_fastmap()  argument
7336 re_compile_fastmap (rxb)  in re_compile_fastmap()
7337      struct re_pattern_buffer * rxb;  in re_compile_fastmap()
7340   rx_blow_up_fastmap (rxb);