Lines Matching defs:pattern
63 # define regcomp(preg, pattern, cflags) __regcomp (preg, pattern, cflags)
74 # define re_compile_pattern(pattern, length, bufp) \
75 __re_compile_pattern (pattern, length, bufp)
155 /* This must be nonzero for the wordchar and notwordchar pattern
423 the range 0 to one less than the pattern buffer's re_nsub
433 pattern buffer, and one byte with the number of inner groups,
531 /* Common operations on the compiled pattern. */
667 /* Print a compiled pattern string in human-readable form, starting at
686 /* Loop over pattern commands. */
901 printf ("%d:\tend of pattern.\n", p - start);
984 also be assigned to arbitrarily: each pattern buffer stores its own
1378 DEBUG_PRINT2 (" Pushing pattern %p:\n", pattern_place); \
1424 PAT -- the saved pattern position.
1462 DEBUG_PRINT2 (" Popping pattern %p:\n", pat); \
1568 static reg_errcode_t regex_compile _RE_ARGS ((const char *pattern, size_t size,
1578 static boolean at_begline_loc_p _RE_ARGS ((const char *pattern, const char *p,
1588 /* Fetch the next character in the uncompiled pattern---translating it
1600 /* Fetch the next character in the uncompiled pattern, with no
1607 /* Go backwards one character in the pattern. */
1621 /* Macros for outputting the compiled pattern into `buffer'. */
1677 into the pattern are two bytes long. So if 2^16 bytes turns out to
1775 /* Get the next unsigned number in the uncompiled pattern. */
1882 `buffer' is the compiled pattern;
1884 `used' is set to the length of the compiled pattern;
1897 regex_compile (pattern, size, syntax, bufp)
1898 const char *pattern;
1917 /* Points to the current (ending) position in the pattern. */
1918 const char *p = pattern;
1919 const char *pend = pattern + size;
1921 /* How to translate the characters in the pattern. */
1938 /* Place in the uncompiled pattern (i.e., the {) to
1953 DEBUG_PRINT1 ("\nCompiling pattern: ");
1959 putchar (pattern[debug_count]);
1972 /* Initialize the pattern buffer. */
1977 /* Set `used' to zero, so that if we return an error, the pattern
1978 printer (for debugging) will think there's no pattern. We reset it
2009 /* Loop through the uncompiled pattern until we're at the end. */
2018 if ( /* If at start of pattern, it's an operator. */
2019 p == pattern + 1
2023 || at_begline_loc_p (pattern, p, syntax))
2033 if ( /* If at end of pattern, it's an operator. */
2053 /* If there is no previous pattern... */
2111 /* Star, etc. applied to an empty pattern is equivalent
2112 to an empty pattern. */
2129 assert (p - 1 > pattern);
2134 /* We know we are not at the first character of the pattern,
2250 && !(p - 2 >= pattern && p[-2] == '[')
2251 && !(p - 3 >= pattern && p[-3] == '[' && p[-2] == '^')
2280 /* If pattern is `[[:'. */
2473 whole pattern moves because of realloc, they will still
2484 represent in the compiled pattern. */
2624 || (p - 2 == pattern && p == pend))
2703 we're all done, the pattern will look like:
2753 inserting into the middle of the pattern --
2782 if (p > pattern && p[-1] == '\\')
2934 /* Through the pattern now. */
2943 the first time we reach the end of the compiled pattern. */
2955 DEBUG_PRINT1 ("\nCompiled pattern: \n");
3078 at_begline_loc_p (pattern, p, syntax)
3079 const char *pattern, *p;
3083 boolean prev_prev_backslash = prev > pattern && prev[-1] == '\\';
3136 uncompiled pattern *P_PTR (which ends at PEND). We assume the
3139 ending characters (inclusive) in the compiled pattern B.
3161 /* Even though the pattern is a signed `char *', we need to fetch
3162 with unsigned char *'s; if the high bit of the pattern character
3172 /* Have to increment the pointer into the pattern string, so the
3193 /* re_compile_fastmap computes a ``fastmap'' for the compiled pattern in
3195 characters can start a string that matches the pattern. This fastmap
3202 the pattern buffer.
3219 unsigned char *pattern = bufp->buffer;
3220 unsigned char *p = pattern;
3221 register unsigned char *pend = pattern + bufp->used;
3229 /* Assume that each path through the pattern can be null until
3249 /* We have reached the (effective) end of pattern. */
3265 /* We should never be about to go beyond the end of the pattern. */
3421 end of the pattern. We don't want to push such a point,
3423 increment `p' past the end of the pattern. We don't need
3425 fastmap entries beyond `pend'. Such a pattern can match
3478 characters for one path of the pattern -- and that the empty
3488 pattern is empty). */
3559 /* Using the compiled pattern in BUFP->buffer, first tries to match the
3609 search for a pattern that must be anchored. */
3642 cannot be the start of a match. If the pattern can match the
3793 we use only one byte in the pattern for the register number), we can
3840 /* re_match_2 matches the compiled pattern in BUFP against the
3900 /* Where we are in the pattern, and the end of the pattern. */
3916 to resume scanning the pattern; the second one is where to resume
3945 attempt) by a subexpression part of the pattern, that is, the
3946 regnum-th regstart pointer points to where in the pattern we began
3949 keeps track of what the whole pattern matches.) */
3966 matched any of the pattern so far this time through the reg_num-th
4012 no groups in the pattern, as it takes a fair amount of time. If
4014 pattern), even though we never use it, since it simplifies the
4090 /* `p' scans through the pattern as `d' scans through the data.
4107 DEBUG_PRINT1 ("The compiled pattern is:\n");
4113 /* This loops over pattern commands. It exits by returning from the
4125 { /* End of pattern means we might have succeeded. */
4126 DEBUG_PRINT1 ("end of pattern ... ");
4176 For example, the pattern `x.*y.*z' against the
4265 were in the pattern, set the extra elements to -1. If
4288 /* Otherwise match next pattern command. */
4301 /* Match the next n pattern characters exactly. The following
4302 byte in the pattern defines n, and the n bytes after that
4516 /* If the next operation is a jump backwards in the pattern
4520 on_failure_jump's jump in the pattern, and d. */
4777 pattern follows its end. If we can establish that there
4811 /* If we're at the end of the pattern, we can change. */
4819 (" End of pattern: change to `pop_failure_jump'.\n");
4927 on_failure_jump; we got through the pattern to here from the
4977 pop_failure_jump, also, and with a pattern of, say, `a+', we
4983 the code at `fail' tests is the value for the pattern. */
5207 continue; /* Successfully executed one pattern command; keep going. */
5223 /* If we failed to the end of the pattern, don't examine *p. */
5273 Return true if the pattern up to the corresponding stop_memory can
5304 pattern. */
5312 with a jump, e.g., here is the pattern for `a|b|c':
5536 Returns 0 if the pattern was valid, otherwise an error string.
5544 re_compile_pattern (pattern, length, bufp)
5545 const char *pattern;
5563 ret = regex_compile (pattern, length, re_syntax_options, bufp);
5579 /* BSD has one and only one pattern buffer. */
5616 don't need to initialize the pattern buffer fields which affect it. */
5655 `buffer' to the compiled pattern;
5656 `used' to the length of the compiled pattern;
5665 PATTERN is the address of the pattern string.
5686 regcomp (preg, pattern, cflags)
5688 const char *pattern;
5696 /* regex_compile will allocate the space for the compiled pattern. */
5734 /* POSIX says a null character in the pattern terminates it, so we
5735 can use strlen here in compiling the pattern. */
5736 ret = regex_compile (pattern, strlen (pattern), syntax, preg);
5744 /* Compute the fastmap now, since regexec cannot modify the pattern
5762 /* regexec searches for a given pattern, specified by PREG, in the