Lines Matching +defs:jump +defs:syntax
81 # define re_set_syntax(syntax) __re_set_syntax (syntax)
118 # include "syntax.h"
168 /* Define the syntax stuff for \<, \>, etc. */
193 /* Get the interface, including the syntax bits. */
412 reg_syntax_t syntax,
430 reg_syntax_t syntax,
529 /* Followed by two byte relative address to which to jump. */
530 jump,
532 /* Same as jump, but marks the end of an alternative. */
544 /* Throw away latest failure point and then jump to following
550 match; otherwise change to jump. This is used to jump
551 back to the beginning of a repeat. If what follows this jump
563 of jump when compiling an alternative. */
572 After matching N times, jump to the address upon failure. */
601 /* Matches any character whose syntax is specified. Followed by
602 a byte which contains a syntax code, e.g., Sword. */
605 /* Matches any character whose syntax is not that specified. */
1032 case jump:
1035 printf ("/jump to %td", p + mcnt - start);
1037 printf ("/jump to %ld", (long int) (p + mcnt - start));
1172 printf ("syntax: %lx\n", bufp->syntax);
1315 /* Set by `re_set_syntax' to the current regexp syntax to recognize. Can
1317 syntax, so it can be changed between regex compilations. */
1323 /* Specify the precise syntax of regexps for compilation. This provides
1328 defined in regex.h. We return the old syntax. */
1331 re_set_syntax (reg_syntax_t syntax)
1335 re_syntax_options = syntax;
1337 if (syntax & RE_DEBUG)
1863 reg_syntax_t syntax);
1866 reg_syntax_t syntax);
1872 reg_syntax_t syntax,
1881 reg_syntax_t syntax,
1982 /* Store a jump with opcode OP at LOC to location TO. We store a
1983 relative address offset by the three bytes the jump itself occupies. */
1987 /* Likewise, for a two-argument jump. */
2276 `syntax' is set to SYNTAX;
2296 size_t ARG_PREFIX(size), reg_syntax_t syntax,
2351 /* Address of the place where a forward jump should go to the end of
2353 last -- ends with a forward jump of this sort. */
2413 bufp->syntax = syntax;
2426 /* Initialize the syntax table. */
2477 || syntax & RE_CONTEXT_INDEP_ANCHORS
2479 || PREFIX(at_begline_loc_p) (pattern, p, syntax))
2492 || syntax & RE_CONTEXT_INDEP_ANCHORS
2494 || PREFIX(at_endline_loc_p) (p, pend, syntax))
2504 if ((syntax & RE_BK_PLUS_QM)
2505 || (syntax & RE_LIMITED_OPS))
2512 if (syntax & RE_CONTEXT_INVALID_OPS)
2514 else if (!(syntax & RE_CONTEXT_INDEP_OPS))
2519 /* Are we optimizing this jump? */
2541 || (!(syntax & RE_BK_PLUS_QM) && (c == '+' || c == '?')))
2544 else if (syntax & RE_BK_PLUS_QM && c == '\\')
2576 end a backward relative jump from `b' to before the next
2577 jump we're going to put in below (which jumps from
2578 laststart to after this jump).
2581 insert an unconditional jump backwards to the .,
2587 /* Allocate the space for the jump. */
2598 && !(syntax & RE_DOT_NEWLINE))
2600 STORE_JUMP (jump, b, laststart);
2612 /* On failure, jump from laststart to b + 3, which will be the
2613 end of the buffer after this jump is inserted. */
2724 /* charset_not matches newline according to a syntax bit. */
2726 && (syntax & RE_HAT_LISTS_NOT_NEWLINE))
2740 if ((syntax & RE_BACKSLASH_ESCAPE_IN_LISTS) && c == '\\')
2777 syntax, b, laststart);
2791 ret = wcs_compile_range (c, &p, pend, translate, syntax, b,
2799 else if (syntax & RE_CHAR_CLASSES && c == '[' && *p == ':')
2872 else if (syntax & RE_CHAR_CLASSES && c == '[' && (*p == '='
3139 /* charset_not matches newline according to a syntax bit. */
3141 && (syntax & RE_HAT_LISTS_NOT_NEWLINE))
3152 if ((syntax & RE_BACKSLASH_ESCAPE_IN_LISTS) && c == '\\')
3184 syntax, b);
3196 ret = byte_compile_range (c, &p, pend, translate, syntax, b);
3204 else if (syntax & RE_CHAR_CLASSES && c == '[' && *p == ':')
3325 else if (syntax & RE_CHAR_CLASSES && c == '[' && *p == '=')
3459 else if (syntax & RE_CHAR_CLASSES && c == '[' && *p == '.')
3621 if (syntax & RE_NO_BK_PARENS)
3628 if (syntax & RE_NO_BK_PARENS)
3635 if (syntax & RE_NEWLINE_ALT)
3642 if (syntax & RE_NO_BK_VBAR)
3649 if (syntax & RE_INTERVALS && syntax & RE_NO_BK_BRACES)
3666 if (syntax & RE_NO_BK_PARENS)
3716 if (syntax & RE_NO_BK_PARENS) goto normal_backslash;
3720 if (syntax & RE_UNMATCHED_RIGHT_PAREN_ORD)
3734 /* We allocated space for this jump when we assigned
3742 if (syntax & RE_UNMATCHED_RIGHT_PAREN_ORD)
3786 if (syntax & RE_LIMITED_OPS || syntax & RE_NO_BK_VBAR)
3789 if (syntax & RE_LIMITED_OPS)
3792 /* Insert before the previous alternative a jump which
3800 /* The alternative before this one has a jump after it
3802 jump so it will jump to this alternative's analogous
3803 jump (put in below, which in turn will jump to the next
3804 (if any) alternative's such jump, etc.). The last such
3805 jump jumps to the correct final destination. A picture:
3812 three-byte space after `a'. We'll put in the jump, set
3819 /* Mark and leave space for a jump after this alternative,
3833 if (!(syntax & RE_INTERVALS)
3836 || (syntax & RE_NO_BK_BRACES))
3841 /* If got here, then the syntax allows intervals. */
3868 if (!(syntax & RE_NO_BK_BRACES))
3881 if (syntax & RE_CONTEXT_INVALID_OPS
3882 && !(syntax & RE_INVALID_INTERVAL_ORD))
3884 else if (syntax & RE_CONTEXT_INDEP_OPS)
3896 all; jump from `laststart' to `b + 3', which will be
3897 the end of the buffer after we insert the jump. */
3903 INSERT_JUMP (jump, laststart, b + 1
3910 set_number_at <jump count> <upper bound>
3912 succeed_n <after jump addr> <succeed_n count>
3914 jump_n <succeed_n addr> <jump count>
3949 append a backward jump to the `succeed_n'
3954 jump back only `upper_bound - 1' times. */
3984 if (!(syntax & RE_INVALID_INTERVAL_ORD))
3990 if (syntax & RE_NO_BK_BRACES)
4018 if (syntax & RE_NO_GNU_OPS)
4026 if (syntax & RE_NO_GNU_OPS)
4034 if (syntax & RE_NO_GNU_OPS)
4040 if (syntax & RE_NO_GNU_OPS)
4046 if (syntax & RE_NO_GNU_OPS)
4052 if (syntax & RE_NO_GNU_OPS)
4058 if (syntax & RE_NO_GNU_OPS)
4064 if (syntax & RE_NO_GNU_OPS)
4071 if (syntax & RE_NO_BK_REFS)
4090 if (syntax & RE_BK_PLUS_QM)
4125 || ((syntax & RE_BK_PLUS_QM)
4128 || ((syntax & RE_INTERVALS)
4129 && ((syntax & RE_NO_BK_BRACES)
4167 if (syntax & RE_NO_POSIX_BACKTRACKING)
4301 reg_syntax_t syntax)
4308 (*prev == '(' && (syntax & RE_NO_BK_PARENS || prev_prev_backslash))
4310 || (*prev == '|' && (syntax & RE_NO_BK_VBAR || prev_prev_backslash));
4319 reg_syntax_t syntax)
4327 (syntax & RE_NO_BK_PARENS ? *next == ')'
4330 || (syntax & RE_NO_BK_VBAR ? *next == '|'
4374 reg_syntax_t syntax, CHAR_T *b, CHAR_T *char_set)
4408 /* Report an error if the range is empty and the syntax prohibits
4410 ret = ((syntax & RE_NO_EMPTY_RANGES)
4425 /* Report an error if the range is empty and the syntax prohibits
4427 ret = ((syntax & RE_NO_EMPTY_RANGES)
4457 reg_syntax_t syntax, unsigned char *b)
4477 /* Report an error if the range is empty and the syntax prohibits this. */
4478 ret = syntax & RE_NO_EMPTY_RANGES ? REG_ERANGE : REG_NOERROR;
4705 if (!(bufp->syntax & RE_DOT_NEWLINE))
4761 case jump:
4772 ordinary jump. For a * loop, it has pushed its failure
6170 if ((!(bufp->syntax & RE_DOT_NEWLINE) && TRANSLATE (*d) == '\n')
6171 || (bufp->syntax & RE_DOT_NOT_NULL && TRANSLATE (*d) == '\000'))
6714 case jump:
6726 /* If the next operation is a jump backwards in the pattern
6730 on_failure_jump's jump in the pattern, and d. */
6926 except the last ends with a jump that in effect jumps past
6927 the rest of the alternatives. (They really jump to the
6928 ending jump of the following alternative, because tensioning
6932 the repetition text and either the following jump or
6980 We change it to either `pop_failure_jump' or `jump'. */
7136 p[-1] = (UCHAR_T) jump;
7137 DEBUG_PRINT1 (" Match => jump.\n");
7175 /* Unconditionally jump (without popping any failure points). */
7176 case jump:
7177 EXTRACT_NUMBER_AND_INCR (mcnt, p); /* Get the amount to jump. */
7178 DEBUG_PRINT2 ("EXECUTING jump %d ", mcnt);
7179 p += mcnt; /* Do the jump. */
7265 /* Originally, this is how many times we CAN jump. */
7280 /* If don't have to jump any more, skip over the rest of command. */
7462 /* If failed to a backwards jump that's part of a repetition
7470 case jump:
7535 /* If the next operation is not a jump backwards in the
7542 The last alternative starts with only a jump,
7544 with a jump, e.g., here is the pattern for `a|b|c':
7703 /* If this is an optimized succeed_n for zero times, make the jump. */
7704 case jump:
7901 `syntax' to RE_SYNTAX_POSIX_EXTENDED if the
7913 If REG_EXTENDED is set, we use POSIX extended syntax; otherwise, we
7914 use POSIX basic syntax.
7933 reg_syntax_t syntax
7965 syntax &= ~RE_DOT_NEWLINE;
7966 syntax |= RE_HAT_LISTS_NOT_NEWLINE;
7979 ret = wcs_regex_compile (pattern, strlen (pattern), syntax, preg);
7982 ret = byte_regex_compile (pattern, strlen (pattern), syntax, preg);