../inputs/grep1.dat:/*** end of cfe purpose **/
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:	 inserts a sentinel newline at the end of the buffer
../inputs/grep1.dat:#endif
../inputs/grep1.dat:   points just after the end.  Return count of new stuff. */
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:static int pending;		/* Pending lines of output. */
../inputs/grep1.dat:/* Print pending lines of trailing context prior to LIM. */
../inputs/grep1.dat:prpending(lim)
../inputs/grep1.dat:  while (pending > 0 && lastout < lim)
../inputs/grep1.dat:      --pending;
../inputs/grep1.dat:  if (!out_quiet && pending > 0)
../inputs/grep1.dat:    prpending(beg);
../inputs/grep1.dat:  pending = out_after;
../inputs/grep1.dat:  char *endp;
../inputs/grep1.dat:  while ((b = (*execute)(p, lim - p, &endp)) != 0)
../inputs/grep1.dat:      /* Avoid matching the empty line at the end of the buffer. */
../inputs/grep1.dat:	  prtext(b, endp, (int *) 0);
../inputs/grep1.dat:      p = endp;
../inputs/grep1.dat:  pending = 0;
../inputs/grep1.dat:	  if (pending)
../inputs/grep1.dat:	    prpending(lim);
../inputs/grep1.dat:      if (pending)
../inputs/grep1.dat:	prpending(buflim);
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif /* alloca.h */
../inputs/grep1.dat:#endif /* not __GNUC__ */
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif	/* GNU C library.  */
../inputs/grep1.dat:   all application programs are extended to handle flexible argument order.
../inputs/grep1.dat:   so that eventually all the non-options are at the end.  This allows options
../inputs/grep1.dat:   The special argument `--' forces an end of option-scanning regardless
../inputs/grep1.dat:#endif
../inputs/grep1.dat:/* Avoid depending on library functions or files
../inputs/grep1.dat:#endif				/* GNU C library.  */
../inputs/grep1.dat:   But we pretend they're const in the prototype to be compatible
../inputs/grep1.dat:	     and extend the range of non-options previously skipped.  */
../inputs/grep1.dat:#endif				/* GETOPT_COMPAT */
../inputs/grep1.dat:      /* Special ARGV-element `--' means premature end of options.
../inputs/grep1.dat:#endif				/* GETOPT_COMPAT */
../inputs/grep1.dat:#endif				/* GETOPT_COMPAT */
../inputs/grep1.dat:#endif				/* GETOPT_COMPAT */
../inputs/grep1.dat:#endif
../inputs/grep1.dat:		/* If we end this ARGV-element by taking the rest as an arg,
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif	/* _LIBC or not __GNU_LIBRARY__.  */
../inputs/grep1.dat:#endif /* TEST */
../inputs/grep1.dat:/* Extended regular expression matching and search library,
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif /* not SYNTAX_TABLE */
../inputs/grep1.dat:#endif /* not emacs */
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:   not functions -- `alloca'-allocated space disappears at the end of the
../inputs/grep1.dat:#endif 
../inputs/grep1.dat:#endif /* not _AIX */
../inputs/grep1.dat:#endif /* not HAVE_ALLOCA_H */ 
../inputs/grep1.dat:#endif /* not __GNUC__ */
../inputs/grep1.dat:#endif /* not alloca */
../inputs/grep1.dat:#endif /* not REGEX_MALLOC */
../inputs/grep1.dat:   `string1' or just past its end.  This works if PTR is NULL, which is
../inputs/grep1.dat:        /* Fail unless at end of line.  */
../inputs/grep1.dat:  endline,
../inputs/grep1.dat:        /* Analogously, for end of buffer/string.  */
../inputs/grep1.dat:  endbuf,
../inputs/grep1.dat:	/* Same as jump, but marks the end of an alternative.  */
../inputs/grep1.dat:	/* Push a dummy failure point and continue.  Used at the end of
../inputs/grep1.dat:  wordend,	/* Succeeds if at word end.  */
../inputs/grep1.dat:#endif /* emacs */
../inputs/grep1.dat:#endif /* not EXTRACT_MACROS */
../inputs/grep1.dat:#endif /* DEBUG */
../inputs/grep1.dat:#endif /* not EXTRACT_MACROS */
../inputs/grep1.dat:#endif /* DEBUG */
../inputs/grep1.dat:   the START pointer into it and ending just before the pointer END.  */
../inputs/grep1.dat:print_partial_compiled_pattern (start, end)
../inputs/grep1.dat:    unsigned char *end;
../inputs/grep1.dat:  unsigned char *pend = end;
../inputs/grep1.dat:  while (p < pend)
../inputs/grep1.dat:            assert (p + *p < pend);
../inputs/grep1.dat:	case endline:
../inputs/grep1.dat:          printf ("/endline");
../inputs/grep1.dat:	case wordend:
../inputs/grep1.dat:	  printf ("/wordend");
../inputs/grep1.dat:#endif /* emacs */
../inputs/grep1.dat:	case endbuf:
../inputs/grep1.dat:	  printf ("/endbuf");
../inputs/grep1.dat:  printf ("%d:\tend of pattern.\n", p - start);
../inputs/grep1.dat:#endif /* not DEBUG */
../inputs/grep1.dat:    "Invalid range end",			/* REG_ERANGE */
../inputs/grep1.dat:    "Premature end of regular expression",	/* REG_EEND */
../inputs/grep1.dat:static boolean at_begline_loc_p (), at_endline_loc_p ();
../inputs/grep1.dat:  do {if (p == pend) return REG_EEND;					\
../inputs/grep1.dat:  do {if (p == pend) return REG_EEND;					\
../inputs/grep1.dat:/* Ensure we have two more bytes of buffer space and then append C1 and C2.  */
../inputs/grep1.dat:/* Like `STORE_JUMP', but for inserting.  Assume `b' is the buffer end.  */
../inputs/grep1.dat:/* Like `STORE_JUMP2', but for inserting.  Assume `b' is the buffer end.  */
../inputs/grep1.dat:/* Extend the buffer by twice its current size via realloc and
../inputs/grep1.dat:   correct places in the new one.  If extending the buffer results in it
../inputs/grep1.dat:        if (pending_exact)						\
../inputs/grep1.dat:          pending_exact = (pending_exact - old_buffer) + bufp->buffer;	\
../inputs/grep1.dat:  { if (p != pend)							\
../inputs/grep1.dat:           if (p == pend) 						\
../inputs/grep1.dat:  /* Points to the end of the buffer, where we should append.  */
../inputs/grep1.dat:  /* Points to the current (ending) position in the pattern.  */
../inputs/grep1.dat:  const char *pend = pattern + size;
../inputs/grep1.dat:  unsigned char *pending_exact = 0;
../inputs/grep1.dat:  /* Address of the place where a forward jump should go to the end of
../inputs/grep1.dat:     last -- ends with a forward jump of this sort.  */
../inputs/grep1.dat:#endif /* DEBUG */
../inputs/grep1.dat:     at the end.  */
../inputs/grep1.dat:#endif
../inputs/grep1.dat:  /* Loop through the uncompiled pattern until we're at the end.  */
../inputs/grep1.dat:  while (p != pend)
../inputs/grep1.dat:                   /* If context independent, it's an operator.  */
../inputs/grep1.dat:                   /* Otherwise, depends on what's come before.  */
../inputs/grep1.dat:            if (   /* If at end of pattern, it's an operator.  */
../inputs/grep1.dat:                   p == pend 
../inputs/grep1.dat:                   /* If context independent, it's an operator.  */
../inputs/grep1.dat:                   /* Otherwise, depends on what's next.  */
../inputs/grep1.dat:                || at_endline_loc_p (p, pend, syntax))
../inputs/grep1.dat:               BUF_PUSH (endline);
../inputs/grep1.dat:                if (p == pend)
../inputs/grep1.dat:                    if (p == pend) return REG_EESCAPE;
../inputs/grep1.dat:                   end a backward relative jump from `b' to before the next
../inputs/grep1.dat:                    && p < pend && TRANSLATE (*p) == TRANSLATE ('\n')
../inputs/grep1.dat:               end of the buffer after this jump is inserted.  */
../inputs/grep1.dat:            pending_exact = 0;
../inputs/grep1.dat:            if (p == pend) return REG_EBRACK;
../inputs/grep1.dat:                if (p == pend) return REG_EBRACK;
../inputs/grep1.dat:                    if (p == pend) return REG_EESCAPE;
../inputs/grep1.dat:                /* Could be the end of the bracket expression.  If it's
../inputs/grep1.dat:                   beginning or the end of a list, then it's the range
../inputs/grep1.dat:                      = compile_range (&p, pend, translate, syntax, b);
../inputs/grep1.dat:                    ret = compile_range (&p, pend, translate, syntax, b);
../inputs/grep1.dat:                    if (p == pend) return REG_EBRACK;
../inputs/grep1.dat:                        if (c == ':' || c == ']' || p == pend
../inputs/grep1.dat:                       undo the ending character, the letters, and leave 
../inputs/grep1.dat:                        /* Throw away the ] at the end of the character
../inputs/grep1.dat:                        if (p == pend) return REG_EBRACK;
../inputs/grep1.dat:               end of the map.  Decrease the map-length byte too.  */
../inputs/grep1.dat:          if (p == pend) return REG_EESCAPE;
../inputs/grep1.dat:              /* These are the values to restore when we hit end of this
../inputs/grep1.dat:		 clear pending_exact explicitly.  */
../inputs/grep1.dat:	      pending_exact = 0;
../inputs/grep1.dat:                { /* Push a dummy failure point at the end of the
../inputs/grep1.dat:		   clear pending_exact explicitly.  */
../inputs/grep1.dat:		pending_exact = 0;
../inputs/grep1.dat:                /* We're at the end of the group, so now we know how many
../inputs/grep1.dat:              pending_exact = 0;
../inputs/grep1.dat:                 when know we're at the end of a series of alternatives.  */
../inputs/grep1.dat:                  || (p - 2 == pattern  &&  p == pend))
../inputs/grep1.dat:                if (p == pend)
../inputs/grep1.dat:                   the end of the buffer after we insert the jump.  */
../inputs/grep1.dat:                        more at the end of the loop.  */
../inputs/grep1.dat:                        attendant `set_number_at' (inserted next),
../inputs/grep1.dat:                            append a backward jump to the `succeed_n'
../inputs/grep1.dat:                pending_exact = 0;
../inputs/grep1.dat:#endif /* emacs */
../inputs/grep1.dat:              BUF_PUSH (wordend);
../inputs/grep1.dat:              BUF_PUSH (endbuf);
../inputs/grep1.dat:          if (!pending_exact 
../inputs/grep1.dat:              || pending_exact + *pending_exact + 1 != b
../inputs/grep1.dat:	      || *pending_exact == (1 << BYTEWIDTH) - 1
../inputs/grep1.dat:	      pending_exact = b - 1;
../inputs/grep1.dat:          (*pending_exact)++;
../inputs/grep1.dat:    } /* while p != pend */
../inputs/grep1.dat:#endif /* DEBUG */
../inputs/grep1.dat:insert_op1 (op, loc, arg, end)
../inputs/grep1.dat:    unsigned char *end;    
../inputs/grep1.dat:  register unsigned char *pfrom = end;
../inputs/grep1.dat:  register unsigned char *pto = end + 3;
../inputs/grep1.dat:insert_op2 (op, loc, arg1, arg2, end)
../inputs/grep1.dat:    unsigned char *end;    
../inputs/grep1.dat:  register unsigned char *pfrom = end;
../inputs/grep1.dat:  register unsigned char *pto = end + 5;
../inputs/grep1.dat:at_endline_loc_p (p, pend, syntax)
../inputs/grep1.dat:    const char *p, *pend;
../inputs/grep1.dat:  const char *next_next = p + 1 < pend ? p + 1 : NULL;
../inputs/grep1.dat:/* Read the ending character of a range (in a bracket expression) from the
../inputs/grep1.dat:   uncompiled pattern *P_PTR (which ends at PEND).  We assume the
../inputs/grep1.dat:   ending characters (inclusive) in the compiled pattern B.
../inputs/grep1.dat:compile_range (p_ptr, pend, translate, syntax, b)
../inputs/grep1.dat:    const char **p_ptr, *pend;
../inputs/grep1.dat:  int range_start, range_end;
../inputs/grep1.dat:  if (p == pend)
../inputs/grep1.dat:     is set, the range endpoints will be negative if we fetch using a
../inputs/grep1.dat:     We also want to fetch the endpoints without translating them; the 
../inputs/grep1.dat:  range_end   = ((unsigned char *) p)[0];
../inputs/grep1.dat:     caller isn't still at the ending character.  */
../inputs/grep1.dat:  /* If the start is after the end, the range is empty.  */
../inputs/grep1.dat:  if (range_start > range_end)
../inputs/grep1.dat:     char' -- the range is inclusive, so if `range_end' == 0xff
../inputs/grep1.dat:  for (this_char = range_start; this_char <= range_end; this_char++)
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:   Requires variables fail_stack, regstart, regend, reg_info, and
../inputs/grep1.dat:	DEBUG_PRINT2 ("    end: 0x%x\n", regend[this_reg]);		\
../inputs/grep1.dat:        PUSH_FAILURE_ITEM (regend[this_reg]);				\
../inputs/grep1.dat:    DEBUG_PRINT_COMPILED_PATTERN (bufp, pattern_place, pend);		\
../inputs/grep1.dat:#endif
../inputs/grep1.dat:   `pend', `string1', `size1', `string2', and `size2'.  */
../inputs/grep1.dat:#define POP_FAILURE_POINT(str, pat, low_reg, high_reg, regstart, regend, reg_info)\
../inputs/grep1.dat:  DEBUG_PRINT_COMPILED_PATTERN (bufp, pat, pend);			\
../inputs/grep1.dat:      regend[this_reg] = (const char *) POP_FAILURE_ITEM ();		\
../inputs/grep1.dat:      DEBUG_PRINT2 ("      end: 0x%x\n", regend[this_reg]);		\
../inputs/grep1.dat:#endif
../inputs/grep1.dat:  register unsigned char *pend = pattern + size;
../inputs/grep1.dat:  while (p != pend || !FAIL_STACK_EMPTY ())
../inputs/grep1.dat:      if (p == pend)
../inputs/grep1.dat:      /* We should never be about to go beyond the end of the pattern.  */
../inputs/grep1.dat:      assert (p < pend);
../inputs/grep1.dat:#endif
../inputs/grep1.dat:      /* Following are the cases which match a character.  These end
../inputs/grep1.dat:	  /* Chars beyond end of map must be allowed.  */
../inputs/grep1.dat:      /* All cases after this match the empty string.  These end with
../inputs/grep1.dat:#endif /* not emacs */
../inputs/grep1.dat:        case endline:
../inputs/grep1.dat:	case endbuf:
../inputs/grep1.dat:	case wordend:
../inputs/grep1.dat:             end of the pattern.  We don't want to push such a point,
../inputs/grep1.dat:             increment `p' past the end of the pattern.  We don't need
../inputs/grep1.dat:             fastmap entries beyond `pend'.  Such a pattern can match
../inputs/grep1.dat:          if (p + j < pend)
../inputs/grep1.dat:      p = pend;
../inputs/grep1.dat:re_set_registers (bufp, regs, num_regs, starts, ends)
../inputs/grep1.dat:    regoff_t *starts, *ends;
../inputs/grep1.dat:      regs->end = ends;
../inputs/grep1.dat:      regs->start = regs->end = (regoff_t) 0;
../inputs/grep1.dat:  int endpos = startpos + range;
../inputs/grep1.dat:  if (endpos < -1)
../inputs/grep1.dat:  else if (endpos > total_size)
../inputs/grep1.dat:   starting and ending positions (which are addresses), and the list of
../inputs/grep1.dat:#define MATCHING_IN_FIRST_STRING  (dend == end_match_1)
../inputs/grep1.dat:  while (d == dend)						    	\
../inputs/grep1.dat:      if (dend == end_match_2) 						\
../inputs/grep1.dat:      dend = end_match_2;						\
../inputs/grep1.dat:/* Test if at very beginning or at very end of the virtual concatenation
../inputs/grep1.dat:#define AT_STRINGS_END(d) ((d) == end2)	
../inputs/grep1.dat:   two special cases to check for: if past the end of string1, look at
../inputs/grep1.dat:  (SYNTAX ((d) == end1 ? *string2					\
../inputs/grep1.dat:           : (d) == string2 - 1 ? *(end1 - 1) : *(d))			\
../inputs/grep1.dat:    FREE_VAR (regend);							\
../inputs/grep1.dat:    FREE_VAR (old_regend);						\
../inputs/grep1.dat:    FREE_VAR (best_regend);						\
../inputs/grep1.dat:#endif /* not REGEX_MALLOC */
../inputs/grep1.dat:#endif /* not emacs */
../inputs/grep1.dat:  /* Just past the end of the corresponding string.  */
../inputs/grep1.dat:  const char *end1, *end2;
../inputs/grep1.dat:  const char *end_match_1, *end_match_2;
../inputs/grep1.dat:  /* Where we are in the data, and the end of the current string.  */
../inputs/grep1.dat:  const char *d, *dend;
../inputs/grep1.dat:  /* Where we are in the pattern, and the end of the pattern.  */
../inputs/grep1.dat:  register unsigned char *pend = p + bufp->used;
../inputs/grep1.dat:     restart, regend, and reg_info for all registers corresponding to
../inputs/grep1.dat:#endif
../inputs/grep1.dat:  /* We fill all the registers internally, independent of what we
../inputs/grep1.dat:     matching and the regnum-th regend points to right after where we
../inputs/grep1.dat:  const char **regstart, **regend;
../inputs/grep1.dat:     register's end.  */
../inputs/grep1.dat:  const char **old_regstart, **old_regend;
../inputs/grep1.dat:  const char **best_regstart, **best_regend;
../inputs/grep1.dat:  /* Logically, this is `best_regend[0]'.  But we don't want to have to
../inputs/grep1.dat:     treat `best_regend' differently than the rest.  So we keep track of
../inputs/grep1.dat:     the end of the best match so far in a separate variable.  We
../inputs/grep1.dat:  const char *match_end = NULL;
../inputs/grep1.dat:#endif
../inputs/grep1.dat:      regend = REGEX_TALLOC (num_regs, const char *);
../inputs/grep1.dat:      old_regend = REGEX_TALLOC (num_regs, const char *);
../inputs/grep1.dat:      best_regend = REGEX_TALLOC (num_regs, const char *);
../inputs/grep1.dat:      if (!(regstart && regend && old_regstart && old_regend && reg_info 
../inputs/grep1.dat:            && best_regstart && best_regend && reg_dummy && reg_info_dummy)) 
../inputs/grep1.dat:      regstart = regend = old_regstart = old_regend = best_regstart
../inputs/grep1.dat:        = best_regend = reg_dummy = NULL;
../inputs/grep1.dat:#endif /* REGEX_MALLOC */
../inputs/grep1.dat:      regstart[mcnt] = regend[mcnt] 
../inputs/grep1.dat:        = old_regstart[mcnt] = old_regend[mcnt] = REG_UNSET_VALUE;
../inputs/grep1.dat:  end1 = string1 + size1;
../inputs/grep1.dat:  end2 = string2 + size2;
../inputs/grep1.dat:      end_match_1 = string1 + stop;
../inputs/grep1.dat:      end_match_2 = string2;
../inputs/grep1.dat:      end_match_1 = end1;
../inputs/grep1.dat:      end_match_2 = string2 + stop - size1;
../inputs/grep1.dat:     `dend' is the end of the input string that `d' points within.  `d'
../inputs/grep1.dat:     loop, `d' can be pointing at the end of a string, but it cannot
../inputs/grep1.dat:      dend = end_match_1;
../inputs/grep1.dat:      dend = end_match_2;
../inputs/grep1.dat:  DEBUG_PRINT_COMPILED_PATTERN (bufp, p, pend);
../inputs/grep1.dat:      if (p == pend)
../inputs/grep1.dat:          DEBUG_PRINT1 ("end of pattern ... ");
../inputs/grep1.dat:          if (d != end_match_2)
../inputs/grep1.dat:                  boolean same_str_p = (FIRST_STRING_P (match_end) 
../inputs/grep1.dat:                      || (same_str_p && d > match_end)
../inputs/grep1.dat:                      match_end = d;
../inputs/grep1.dat:                          best_regend[mcnt] = regend[mcnt];
../inputs/grep1.dat:                  /* Restore best match.  It may happen that `dend ==
../inputs/grep1.dat:                     end_match_1' while the restored d is in string2.
../inputs/grep1.dat:                  d = match_end;
../inputs/grep1.dat:                  dend = ((d >= string1 && d <= end1)
../inputs/grep1.dat:		           ? end_match_1 : end_match_2);
../inputs/grep1.dat:		      regend[mcnt] = best_regend[mcnt];
../inputs/grep1.dat:            } /* d != end_match_2 */
../inputs/grep1.dat:                  regs->end = TALLOC (regs->num_regs, regoff_t);
../inputs/grep1.dat:                  if (regs->start == NULL || regs->end == NULL)
../inputs/grep1.dat:                      RETALLOC (regs->end, regs->num_regs, regoff_t);
../inputs/grep1.dat:                      if (regs->start == NULL || regs->end == NULL)
../inputs/grep1.dat:		  /* These braces fend off a "empty body in an else-statement"
../inputs/grep1.dat:              /* Convert the pointer data in `regstart' and `regend' to
../inputs/grep1.dat:                  regs->end[0] = (MATCHING_IN_FIRST_STRING ? d - string1
../inputs/grep1.dat:                  if (REG_UNSET (regstart[mcnt]) || REG_UNSET (regend[mcnt]))
../inputs/grep1.dat:                    regs->start[mcnt] = regs->end[mcnt] = -1;
../inputs/grep1.dat:                      regs->end[mcnt] = POINTER_TO_OFFSET (regend[mcnt]);
../inputs/grep1.dat:                 -1 at the end.  */
../inputs/grep1.dat:                regs->start[mcnt] = regs->end[mcnt] = -1;
../inputs/grep1.dat:#endif
../inputs/grep1.dat:	  p1 = p;		/* To send to group_match_null_string_p.  */
../inputs/grep1.dat:              = group_match_null_string_p (&p1, pend, reg_info);
../inputs/grep1.dat:        /* The stop_memory opcode represents the end of a group.  Its
../inputs/grep1.dat:          old_regend[*p] = REG_MATCH_NULL_STRING_P (reg_info[*p])
../inputs/grep1.dat:                           ? REG_UNSET (regend[*p]) ? d : regend[*p]
../inputs/grep1.dat:			   : regend[*p];
../inputs/grep1.dat:	  DEBUG_PRINT2 ("      old_regend: %d\n", 
../inputs/grep1.dat:			 POINTER_TO_OFFSET (old_regend[*p]));
../inputs/grep1.dat:          regend[*p] = d;
../inputs/grep1.dat:	  DEBUG_PRINT2 ("      regend: %d\n", POINTER_TO_OFFSET (regend[*p]));
../inputs/grep1.dat:                 (a(b)c(d(e)f)g).  When group 3 ends, after the f), the
../inputs/grep1.dat:              /* If we end up at register zero, that means that we saved
../inputs/grep1.dat:	      && (p + 2) < pend)              
../inputs/grep1.dat:                     against `aba' for regend[3].
../inputs/grep1.dat:                          if ((int) old_regend[r] >= (int) regstart[r])
../inputs/grep1.dat:                            regend[r] = old_regend[r];
../inputs/grep1.dat:	    register const char *d2, *dend2;
../inputs/grep1.dat:            if (REG_UNSET (regstart[regno]) || REG_UNSET (regend[regno]))
../inputs/grep1.dat:               the end of the first string.  */
../inputs/grep1.dat:            dend2 = ((FIRST_STRING_P (regstart[regno]) 
../inputs/grep1.dat:		      == FIRST_STRING_P (regend[regno]))
../inputs/grep1.dat:		     ? regend[regno] : end_match_1);
../inputs/grep1.dat:		while (d2 == dend2)
../inputs/grep1.dat:		    if (dend2 == end_match_2) break;
../inputs/grep1.dat:		    if (dend2 == regend[regno]) break;
../inputs/grep1.dat:                    dend2 = regend[regno];
../inputs/grep1.dat:		/* At end of register contents => success */
../inputs/grep1.dat:		if (d2 == dend2) break;
../inputs/grep1.dat:		mcnt = dend - d;
../inputs/grep1.dat:                if (mcnt > dend2 - d2)
../inputs/grep1.dat:		  mcnt = dend2 - d2;
../inputs/grep1.dat:        /* endline is the dual of begline.  */
../inputs/grep1.dat:	case endline:
../inputs/grep1.dat:          DEBUG_PRINT1 ("EXECUTING endline.\n");
../inputs/grep1.dat:          else if ((d == end1 ? *string2 : *d) == '\n'
../inputs/grep1.dat:	/* Match at the very end of the data.  */
../inputs/grep1.dat:        case endbuf:
../inputs/grep1.dat:          DEBUG_PRINT1 ("EXECUTING endbuf.\n");
../inputs/grep1.dat:           except the last ends with a jump that in effect jumps past
../inputs/grep1.dat:           ending jump of the following alternative, because tensioning
../inputs/grep1.dat:          while (p1 < pend && (re_opcode_t) *p1 == no_op)
../inputs/grep1.dat:          if (p1 < pend && (re_opcode_t) *p1 == start_memory)
../inputs/grep1.dat:        /* A smart repeat ends with `maybe_pop_jump'.
../inputs/grep1.dat:               pattern follows its end. If we can establish that there
../inputs/grep1.dat:               failure point which is what we will end up popping.  */
../inputs/grep1.dat:	    while (p2 + 2 < pend
../inputs/grep1.dat:            /* If we're at the end of the pattern, we can change.  */
../inputs/grep1.dat:            if (p2 == pend)
../inputs/grep1.dat:		     || (bufp->newline_anchor && (re_opcode_t) *p2 == endline))
../inputs/grep1.dat:                  = *p2 == (unsigned char) endline ? '\n' : p2[2];
../inputs/grep1.dat:	/* The end of a simple repeat has a pop_failure_jump back to
../inputs/grep1.dat:        /* We need this opcode so we can detect where alternatives end
../inputs/grep1.dat:           then gets popped at pop_failure_jump.  We will end up at
../inputs/grep1.dat:        /* At the end of an alternative, we need to push a dummy failure
../inputs/grep1.dat:	case wordend:
../inputs/grep1.dat:          DEBUG_PRINT1 ("EXECUTING wordend.\n");
../inputs/grep1.dat:#endif /* not emacs19 */
../inputs/grep1.dat:#endif /* not emacs */
../inputs/grep1.dat:                             regstart, regend, reg_info);
../inputs/grep1.dat:          /* If we failed to the end of the pattern, don't examine *p.  */
../inputs/grep1.dat:	  assert (p <= pend);
../inputs/grep1.dat:          if (p < pend)
../inputs/grep1.dat:          if (d >= string1 && d <= end1)
../inputs/grep1.dat:	    dend = end_match_1;
../inputs/grep1.dat:group_match_null_string_p (p, end, reg_info)
../inputs/grep1.dat:    unsigned char **p, *end;
../inputs/grep1.dat:  while (p1 < end)
../inputs/grep1.dat:                 whereas the rest start with on_failure_jump and end
../inputs/grep1.dat:                     is, including the ending `jump_past_alt' and
../inputs/grep1.dat:          if (!common_op_match_null_string_p (&p1, end, reg_info))
../inputs/grep1.dat:    } /* while p1 < end */
../inputs/grep1.dat:alt_match_null_string_p (p, end, reg_info)
../inputs/grep1.dat:    unsigned char *p, *end;
../inputs/grep1.dat:  while (p1 < end)
../inputs/grep1.dat:          if (!common_op_match_null_string_p (&p1, end, reg_info))
../inputs/grep1.dat:    }  /* while p1 < end */
../inputs/grep1.dat:common_op_match_null_string_p (p, end, reg_info)
../inputs/grep1.dat:    unsigned char **p, *end;
../inputs/grep1.dat:    case endline:
../inputs/grep1.dat:    case endbuf:
../inputs/grep1.dat:    case wordend:
../inputs/grep1.dat:#endif
../inputs/grep1.dat:      ret = group_match_null_string_p (&p1, end, reg_info);
../inputs/grep1.dat:#endif /* not emacs and not _POSIX_SOURCE */
../inputs/grep1.dat:     If REG_EXTENDED is set, we use POSIX extended syntax; otherwise, we
../inputs/grep1.dat:   string; if REG_NOTEOL is set, then $ does not match at the end.
../inputs/grep1.dat:      regs.end = TALLOC (nmatch, regoff_t);
../inputs/grep1.dat:      if (regs.start == NULL || regs.end == NULL)
../inputs/grep1.dat:              pmatch[r].rm_eo = regs.end[r];
../inputs/grep1.dat:      free (regs.end);
../inputs/grep1.dat:#endif /* not emacs  */
../inputs/grep1.dat:/* dfa.c - deterministic extended regexp routines for GNU
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif /* DEBUG */
../inputs/grep1.dat:#endif
../inputs/grep1.dat:  d->states[i].first_end = 0;
../inputs/grep1.dat:	if (! d->states[i].first_end)
../inputs/grep1.dat:	  d->states[i].first_end = d->tokens[s->elems[j].index];
../inputs/grep1.dat:   Note that at this point, we're pretending constructs like \< are real
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:   the beginning of the buffer, and end points to the first character after
../inputs/grep1.dat:   its end.  We store a newline in *end to act as a sentinel, so end had
../inputs/grep1.dat:dfaexec(d, begin, end, newline, count, backref)
../inputs/grep1.dat:     char *end;
../inputs/grep1.dat:  *end = '\n';
../inputs/grep1.dat:      if (s >= 0 && p <= (unsigned char *) end && d->fails[s])
../inputs/grep1.dat:      if (count && (char *) p <= end && p[-1] == '\n')
../inputs/grep1.dat:      /* Check if we've run off the end of the buffer. */
../inputs/grep1.dat:      if ((char *) p > end)
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:  int maxshift;			/* Max shift of self and descendents. */
../inputs/grep1.dat:  /* Descend the trie (built of reversed keywords) character-by-character,
../inputs/grep1.dat:      /* Descend the tree of outgoing links for this trie node,
../inputs/grep1.dat:     node that has a descendent on the current label. */
../inputs/grep1.dat:	  /* Enqueue the immediate descendents in the level order queue. */
../inputs/grep1.dat:	  /* Update the delta table for the descendents of this node. */
../inputs/grep1.dat:	  /* Compute the failure function for the decendents of this node. */
../inputs/grep1.dat:		 fail and its descendents should be no larger than the
../inputs/grep1.dat:  register char *end, *qlim;
../inputs/grep1.dat:  end = text;
../inputs/grep1.dat:  while (lim - end >= d)
../inputs/grep1.dat:      if (qlim && end <= qlim)
../inputs/grep1.dat:	  end += d - 1;
../inputs/grep1.dat:	  while ((d = delta[c = *end]) && end < qlim)
../inputs/grep1.dat:	      end += d;
../inputs/grep1.dat:	      end += delta[(unsigned char) *end];
../inputs/grep1.dat:	      end += delta[(unsigned char) *end];
../inputs/grep1.dat:	  ++end;
../inputs/grep1.dat:	d = delta[c = (end += d)[-1]];
../inputs/grep1.dat:      beg = end - 1;
../inputs/grep1.dat:  while (lim - end >= d)
../inputs/grep1.dat:      if ((d = delta[c = (end += d)[-1]]) != 0)
../inputs/grep1.dat:      beg = end - 1;
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:   Copies any partial object from the end of the old chunk
../inputs/grep1.dat:     at the end of an adjacent chunk. */
../inputs/grep1.dat:     at the end of another chunk.  */
../inputs/grep1.dat:     at the end of another chunk.  */
../inputs/grep1.dat:#endif /* __STDC__ */
../inputs/grep1.dat:#endif /* 0 */
../inputs/grep1.dat:#endif	/* _LIBC or not __GNU_LIBRARY__.  */
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:#endif
../inputs/grep1.dat:	 BUG: Using [A-Za-z_] is locale-dependent!  */
../inputs/grep1.dat:#endif
../inputs/grep1.dat:	 BUG: Using [A-Za-z_] is locale-dependent!  */
../inputs/grep1.dat:EGexecute(buf, size, endp)
../inputs/grep1.dat:     char **endp;
../inputs/grep1.dat:  register char *buflim, *beg, *end, save;
../inputs/grep1.dat:  for (beg = end = buf; end < buflim; beg = end + 1)
../inputs/grep1.dat:	  end = memchr(beg, '\n', buflim - beg);
../inputs/grep1.dat:	  if (!end)
../inputs/grep1.dat:	    end = buflim;
../inputs/grep1.dat:	  save = *end;
../inputs/grep1.dat:	  if (!dfaexec(&dfa_1, beg, end, 0, (int *) 0, &backref))
../inputs/grep1.dat:	      *end = save;
../inputs/grep1.dat:	  *end = save;
../inputs/grep1.dat:	  end = memchr(beg, '\n', buflim - beg);
../inputs/grep1.dat:	  if (!end)
../inputs/grep1.dat:	    end = buflim;
../inputs/grep1.dat:      if ((start = re_search(&regex, beg, end - beg, 0, end - beg, &regs)) >= 0)
../inputs/grep1.dat:	  len = regs.end[0] - start;
../inputs/grep1.dat:	  if (!match_lines && !match_words || match_lines && len == end - beg)
../inputs/grep1.dat:		    && (len == end - beg || !WCHAR(beg[start + len])))
../inputs/grep1.dat:		    if (start == end - beg)
../inputs/grep1.dat:		    start = re_search(&regex, beg, end - beg,
../inputs/grep1.dat:				      start, end - beg - start, &regs);
../inputs/grep1.dat:		    len = regs.end[0] - start;
../inputs/grep1.dat:  *endp = end < buflim ? end + 1 : end;
../inputs/grep1.dat:Fexecute(buf, size, endp)
../inputs/grep1.dat:     char **endp;
../inputs/grep1.dat:  register char *beg, *try, *end;
../inputs/grep1.dat:  if ((end = memchr(beg + len, '\n', (buf + size) - (beg + len))) != 0)
../inputs/grep1.dat:    ++end;
../inputs/grep1.dat:    end = buf + size;
../inputs/grep1.dat:  *endp = end;
../inputs/grep1.dat:if agout end = buf + size;
../inputs/grep1.dat:3eif agout end = buf + size;
../inputs/grep1.dat:3eif agoutvf end = buf + size;
../inputs/grep1.dat:argue if agout end = buf + size;
