Lines Matching refs:code
15 * Redistributions of source code must retain the above copyright notice,
100 soon as they can be, so that hopefully there will never be an overrun. The code
109 /(?1){0,1999}(b)/, and one user did hit the limit. The code has been changed so
359 POSIX classes (e.g. graph, print, punct) a special property code is compiled
476 "internal error: code overflow\0"
536 "disallowed Unicode code point (>= 0xd800 && <= 0xdfff)\0"
557 may mark arbitrary characters as digits - but the PCRE compiling code expects
569 Then we can use ctype_digit and ctype_xdigit in the code. */
572 is much faster, and the resulting code is simpler (the compiler turns it
700 zero because property types are handled separately in the code. The last four
797 because they can all use the same code. For more details see the comment where
1106 the ESC_g code (cf \k). */
1244 larger first octal digit. The original code used just to take the least
1434 otherwise, for Perl compatibility, it is a literal. This code looks a bit
1486 errorcodeptr points to the error code variable
1581 errorcodeptr points to error code variable
1633 * Find first significant op code *
1637 for a fixed first character, or an anchoring op code etc. It skips over things
1643 code pointer to the start of the group
1650 first_significant_code(const pcre_uchar *code, BOOL skipassert)
1654 switch ((int)*code)
1659 if (!skipassert) return code;
1660 do code += GET(code, 1); while (*code == OP_ALT);
1661 code += PRIV(OP_lengths)[*code];
1666 if (!skipassert) return code;
1675 code += PRIV(OP_lengths)[*code];
1679 return code;
1703 code points to the start of the pattern (the bracket)
1716 find_fixedlength(pcre_uchar *code, BOOL utf, BOOL atend, compile_data *cd)
1721 register pcre_uchar *cc = code + 1 + LINK_SIZE;
1754 the same code. Note that we must not include the OP_KETRxxx opcodes here,
1899 /* The original code caused an unsigned overflow in 64 bit systems,
2042 code points to start of expression
2050 PRIV(find_bracket)(const pcre_uchar *code, BOOL utf, int number)
2054 register pcre_uchar c = *code;
2060 the table is zero; the actual length is stored in the compiled code. */
2062 if (c == OP_XCLASS) code += GET(code, 1);
2068 if (number < 0) return (pcre_uchar *)code;
2069 code += PRIV(OP_lengths)[c];
2077 int n = (int)GET2(code, 1+LINK_SIZE);
2078 if (n == number) return (pcre_uchar *)code;
2079 code += PRIV(OP_lengths)[c];
2100 if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;
2107 if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)
2108 code += 2;
2115 code += code[1];
2121 code += PRIV(OP_lengths)[c];
2158 if (HAS_EXTRALEN(code[-1])) code += GET_EXTRALEN(code[-1]);
2178 code points to start of expression
2185 find_recurse(const pcre_uchar *code, BOOL utf)
2189 register pcre_uchar c = *code;
2191 if (c == OP_RECURSE) return code;
2195 the table is zero; the actual length is stored in the compiled code. */
2197 if (c == OP_XCLASS) code += GET(code, 1);
2217 if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;
2224 if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)
2225 code += 2;
2232 code += code[1];
2238 code += PRIV(OP_lengths)[c];
2303 if (HAS_EXTRALEN(code[-1])) code += GET_EXTRALEN(code[-1]);
2328 code points to start of search
2343 could_be_empty_branch(const pcre_uchar *code, const pcre_uchar *endcode,
2349 for (code = first_significant_code(code + PRIV(OP_lengths)[*code], TRUE);
2350 code < endcode;
2351 code = first_significant_code(code + PRIV(OP_lengths)[c], TRUE))
2355 c = *code;
2362 do code += GET(code, 1); while (*code == OP_ALT);
2363 c = *code;
2376 const pcre_uchar *scode = cd->start_code + GET(code, 1);
2388 if ((int)GET(tcode, 0) == (int)(code + 1 - cd->start_code)) return TRUE;
2398 if (code >= scode && code <= endgroup) continue; /* Simple recursion */
2434 code += PRIV(OP_lengths)[c];
2435 do code += GET(code, 1); while (*code == OP_ALT);
2436 c = *code;
2446 do code += GET(code, 1); while (*code == OP_ALT);
2447 c = *code;
2459 if (GET(code, 1) == 0) return TRUE; /* Hit unclosed bracket */
2465 if (c == OP_COND && code[GET(code, 1)] != OP_ALT)
2466 code += GET(code, 1);
2472 if (!empty_branch && could_be_empty_branch(code, endcode, utf, cd, NULL))
2474 code += GET(code, 1);
2476 while (*code == OP_ALT);
2480 c = *code;
2491 actual length is stored in the compiled code, so we must update "code"
2496 ccode = code += GET(code, 1);
2502 ccode = code + PRIV(OP_lengths)[OP_CLASS];
2596 if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;
2604 if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)
2605 code += 2;
2652 if (utf && HAS_EXTRALEN(code[1])) code += GET_EXTRALEN(code[1]);
2670 if (utf && HAS_EXTRALEN(code[1 + IMM2_SIZE])) code += GET_EXTRALEN(code[1 + IMM2_SIZE]);
2681 code += code[1];
2708 code points to start of the recursion
2718 could_be_empty(const pcre_uchar *code, const pcre_uchar *endcode,
2721 while (bcptr != NULL && bcptr->current_branch >= code)
2844 /* Checks whether the code points to an opcode that can take part in auto-
2848 code points to start of expression
2857 Returns: points to the start of the next opcode if *code is accepted
2858 NULL if *code is not accepted
2862 get_chr_property_list(const pcre_uchar *code, BOOL utf,
2865 pcre_uchar c = *code;
2879 code++;
2887 code += IMM2_SIZE;
2910 list[0] = *code;
2911 code++;
2937 return code;
2941 GETCHARINCTEST(chr, code);
2944 return code;
2949 GETCHARINCTEST(chr, code);
2969 return code;
2974 if (code[0] != PT_CLIST)
2976 list[2] = code[0];
2977 list[3] = code[1];
2978 return code + 2;
2983 clist_src = PRIV(ucd_caseless_sets) + code[1];
2985 code += 2;
2992 list[2] = code[0];
2993 list[3] = code[1];
2994 return code;
3004 return code;
3012 end = code + GET(code, 0) - 1;
3015 end = code + 32 / sizeof(pcre_uchar);
3042 list[2] = (pcre_uint32)(end - code);
3058 code points to the byte code
3067 compare_opcodes(const pcre_uchar *code, BOOL utf, const compile_data *cd,
3092 /* All operations move the code pointer forward.
3095 c = *code;
3101 code += PRIV(OP_lengths)[c];
3107 do code += GET(code, 1); while (*code == OP_ALT);
3108 c = *code;
3128 switch(*(code - GET(code, 1)))
3143 code += PRIV(OP_lengths)[c];
3150 next_code = code + GET(code, 1);
3151 code += PRIV(OP_lengths)[c];
3155 if (!compare_opcodes(code, utf, cd, base_list, base_end)) return FALSE;
3156 code = next_code + 1 + LINK_SIZE;
3166 next_code = code + 1;
3178 code += PRIV(OP_lengths)[c];
3187 code = get_chr_property_list(code, utf, cd->fcc, list);
3188 if (code == NULL) return FALSE; /* Unsupported */
3224 set1 = (pcre_uint8 *)(code - list[2]);
3234 ((list_ptr == list ? code : base_end) - list_ptr[2]);
3239 xclass_flags = (list_ptr == list ? code : base_end) - list_ptr[2] + LINK_SIZE;
3352 /* This code is logically tricky. Think hard before fiddling with it.
3356 others means they can all use the same code below.
3555 ((list_ptr == list ? code : base_end) - list_ptr[2]);
3561 if (PRIV(xclass)(chr, (list_ptr == list ? code : base_end) -
3594 code points to start of the byte code
3602 auto_possessify(pcre_uchar *code, BOOL utf, const compile_data *cd)
3611 c = *code;
3617 get_chr_property_list(code, utf, cd->fcc, list) : NULL;
3625 *code += OP_POSSTAR - OP_STAR;
3629 *code += OP_POSSTAR - OP_MINSTAR;
3633 *code += OP_POSPLUS - OP_PLUS;
3637 *code += OP_POSPLUS - OP_MINPLUS;
3641 *code += OP_POSQUERY - OP_QUERY;
3645 *code += OP_POSQUERY - OP_MINQUERY;
3649 *code += OP_POSUPTO - OP_UPTO;
3653 *code += OP_POSUPTO - OP_MINUPTO;
3657 c = *code;
3663 repeat_opcode = code + GET(code, 1);
3666 repeat_opcode = code + 1 + (32 / sizeof(pcre_uchar));
3672 end = get_chr_property_list(code, utf, cd->fcc, list);
3702 c = *code;
3719 if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;
3726 if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)
3727 code += 2;
3732 code += GET(code, 1);
3740 code += code[1];
3746 code += PRIV(OP_lengths)[c];
3811 if (HAS_EXTRALEN(code[-1])) code += GET_EXTRALEN(code[-1]);
3839 class, but [abc[:x\]pqr:]] is (so that an error can be generated). The code
4002 code current code pointer
4006 Returns: new code pointer
4010 auto_callout(pcre_uchar *code, const pcre_uchar *ptr, compile_data *cd)
4012 *code++ = OP_CALLOUT;
4013 *code++ = 255;
4014 PUT(code, 0, (int)(ptr - cd->start_pattern)); /* Pattern offset */
4015 PUT(code, LINK_SIZE, 0); /* Default length */
4016 return code + 2 * LINK_SIZE;
4364 codeptr points to the pointer to the current code point
4366 errorcodeptr points to error code variable
4403 register pcre_uchar *code = *codeptr;
4404 pcre_uchar *last_code = code;
4405 pcre_uchar *orig_code = code;
4519 if (code > cd->hwm) cd->hwm = code; /* High water info */
4521 if (code > cd->start_workspace + cd->workspace_size -
4528 /* There is at least one situation where code goes backwards: this is the
4534 if (code < last_code) code = last_code;
4538 if (OFLOW_MAX - *lengthptr < code - last_code)
4544 *lengthptr += (int)(code - last_code);
4546 (int)(code - last_code), c, c));
4550 if "previous" is NULL, reset the current code pointer to the start. */
4556 memmove(orig_code, previous, IN_UCHARS(code - previous));
4557 code -= previous - orig_code;
4561 else code = orig_code;
4563 /* Remember where this code item starts so we can pick up the length
4566 last_code = code;
4599 previous_callout = code;
4600 code = auto_callout(code, ptr, cd);
4655 previous_callout = code;
4656 code = auto_callout(code, ptr, cd);
4671 *codeptr = code;
4675 if (OFLOW_MAX - *lengthptr < code - last_code)
4680 *lengthptr += (int)(code - last_code); /* To include callout length */
4696 *code++ = OP_CIRCM;
4698 else *code++ = OP_CIRC;
4703 *code++ = ((options & PCRE_MULTILINE) != 0)? OP_DOLLM : OP_DOLL;
4715 previous = code;
4716 *code++ = ((options & PCRE_DOTALL) != 0)? OP_ALLANY: OP_ANY;
4747 erroneous and are handled by the normal code below. */
4766 previous = code;
4802 an initial ']' is taken as a data character -- the code below handles
4809 *code++ = negate_class? OP_ALLANY : OP_FAIL;
4827 class_uchardata = code + LINK_SIZE + 2; /* For XCLASS items */
4845 8-bit characters because in that case the compiled code doesn't use the bit
5188 code for handling \Q and \E is messy. */
5348 *code++ = OP_NOTPROP;
5349 *code++ = PT_CLIST;
5350 *code++ = d;
5357 *code++ = ((options & PCRE_CASELESS) != 0)? OP_NOTI: OP_NOT;
5360 code += PRIV(ord2utf)(c, code);
5363 *code++ = c;
5372 then we can handle this with the normal one-character code. */
5415 uchar_classdata is emptied, and that's why this code is the way it is here
5438 actual compiled code. */
5448 *code++ = OP_XCLASS;
5449 code += LINK_SIZE;
5450 *code = negate_class? XCL_NOT:0;
5451 if (xclass_has_prop) *code |= XCL_HASPROP;
5454 otherwise just move the code pointer to the end of the extra data. */
5458 *code++ |= XCL_MAP;
5459 memmove(code + (32 / sizeof(pcre_uchar)), code,
5460 IN_UCHARS(class_uchardata - code));
5463 memcpy(code, classbits, 32);
5464 code = class_uchardata + (32 / sizeof(pcre_uchar));
5466 else code = class_uchardata;
5470 PUT(previous, 1, (int)(code - previous));
5478 (non-UCP) in the class. Then copy the 32-byte map into the code vector,
5481 *code++ = (negate_class == should_flip_negation) ? OP_CLASS : OP_NCLASS;
5486 memcpy(code, classbits, 32);
5488 code += 32 / sizeof(pcre_uchar);
5596 but for the moment we rely on the code for repeating groups. */
5605 code += 2 + 2 * LINK_SIZE;
5645 if (utf && NOT_FIRSTCHAR(code[-1]))
5647 pcre_uchar *lastchar = code - 1;
5649 c = (int)(code - lastchar); /* Length of UTF-8 character */
5659 c = code[-1];
5671 create a suitable repeat item. The code is shared with single-character
5674 defined, but we don't wrap the little bits of code here because it just
5692 oldcode = code;
5693 code = previous; /* Usually overwrite previous item */
5709 if (repeat_max == -1) *code++ = OP_STAR + repeat_type;
5710 else if (repeat_max == 1) *code++ = OP_QUERY + repeat_type;
5713 *code++ = OP_UPTO + repeat_type;
5714 PUT2INC(code, 0, repeat_max);
5726 *code++ = OP_PLUS + repeat_type;
5729 code = oldcode; /* leave previous item in place */
5731 *code++ = OP_UPTO + repeat_type;
5732 PUT2INC(code, 0, repeat_max - 1);
5741 *code++ = OP_EXACT + op_type; /* NB EXACT doesn't have repeat_type */
5742 PUT2INC(code, 0, repeat_min);
5745 we have to insert the character for the previous code. For a repeated
5755 memcpy(code, utf_chars, IN_UCHARS(c & 7));
5756 code += c & 7;
5761 *code++ = c;
5764 *code++ = prop_type;
5765 *code++ = prop_value;
5768 *code++ = OP_STAR + repeat_type;
5772 preceded by the character, for the previously inserted code. If the
5780 memcpy(code, utf_chars, IN_UCHARS(c & 7));
5781 code += c & 7;
5785 *code++ = c;
5788 *code++ = prop_type;
5789 *code++ = prop_value;
5795 *code++ = OP_QUERY + repeat_type;
5799 *code++ = OP_UPTO + repeat_type;
5800 PUT2INC(code, 0, repeat_max);
5810 memcpy(code, utf_chars, IN_UCHARS(c & 7));
5811 code += c & 7;
5815 *code++ = c;
5823 *code++ = prop_type;
5824 *code++ = prop_value;
5841 code = previous;
5846 *code++ = OP_CRSTAR + repeat_type;
5848 *code++ = OP_CRPLUS + repeat_type;
5850 *code++ = OP_CRQUERY + repeat_type;
5853 *code++ = OP_CRRANGE + repeat_type;
5854 PUT2INC(code, 0, repeat_min);
5856 PUT2INC(code, 0, repeat_max);
5872 int len = (int)(code - previous);
5897 the code gets far too messy. There are several special subcases when the
5907 ** code = previous;
5926 *code = OP_END;
5929 code++;
5942 copy, which has to be moved up. The remainder can be handled by code
5950 *code = OP_END;
5953 code += 2 + LINK_SIZE;
6015 memcpy(code, previous, IN_UCHARS(len));
6034 code += len;
6042 /* This code is common to both the zero and non-zero minimum cases. If
6080 *code++ = OP_BRAZERO + repeat_type;
6088 *code++ = OP_BRA;
6089 offset = (bralink == NULL)? 0 : (int)(code - bralink);
6090 bralink = code;
6091 PUTINC(code, 0, offset);
6094 memcpy(code, previous, IN_UCHARS(len));
6116 code += len;
6125 int offset = (int)(code - bralink + 1);
6126 pcre_uchar *bra = code - offset;
6129 *code++ = OP_KET;
6130 PUTINC(code, 0, offset);
6148 conditional, we convert the BRA code to the POS form, and the KET code to
6162 pcre_uchar *ketcode = code - 1 - LINK_SIZE;
6204 versions of the COND opcodes. Because we are moving code along, we
6209 int nlen = (int)(code - bracode);
6210 *code = OP_END;
6213 code += 1 + LINK_SIZE;
6216 *code++ = OP_KETRPOS;
6217 PUTINC(code, 0, nlen);
6221 /* For non-COND brackets, we modify the BRA code and use KETRPOS. */
6265 completely handled in the code just above. For them, possessive_quantifier
6320 /* If tempcode is equal to code (which points to the end of the repeated
6324 be less than code, so the value of len will be greater than 0. */
6326 len = (int)(code - tempcode);
6339 ONCE brackets. Because we are moving code along, we must ensure that any
6344 *code = OP_END;
6347 code += 1 + LINK_SIZE;
6350 *code++ = OP_KET;
6351 PUTINC(code, 0, len);
6389 /* Because we are moving code along, we must ensure that any
6393 *code = OP_END;
6396 code += 1 + LINK_SIZE;
6399 *code++ = OP_KET;
6400 PUTINC(code, 0, len);
6490 *code++ = OP_CLOSE;
6491 PUT2INC(code, 0, oc->number);
6493 setverb = *code++ =
6509 setverb = *code++ = verbs[i].op;
6519 setverb = *code++ = verbs[i].op_arg;
6520 *code++ = arglen;
6521 memcpy(code, arg, IN_UCHARS(arglen));
6522 code += arglen;
6523 *code++ = 0;
6629 code[1+LINK_SIZE] = OP_CREF;
6643 code[1+LINK_SIZE] = OP_RREF; /* Change the type of test */
6737 PUT2(code, 2+LINK_SIZE, recno);
6770 PUT2(code, 2+LINK_SIZE, offset);
6771 PUT2(code, 2+LINK_SIZE+IMM2_SIZE, count);
6773 code[1+LINK_SIZE]++;
6777 PUT2(code, 2+LINK_SIZE, recno);
6809 code[1+LINK_SIZE] = OP_RREF; /* Change test type */
6810 PUT2(code, 2+LINK_SIZE, recno);
6818 code[1+LINK_SIZE] = OP_DEF;
6852 *code++ = OP_FAIL;
6896 previous_callout = code; /* Save for later completion */
6898 *code++ = OP_CALLOUT;
6914 *code++ = n;
6915 PUT(code, 0, (int)(ptr - cd->start_pattern + 1)); /* Pattern offset */
6916 PUT(code, LINK_SIZE, 0); /* Default length */
6917 code += 2 * LINK_SIZE;
7151 /* In both phases, for recursions, we can now go to the code than
7177 previous = code;
7178 *code++ = ((options & PCRE_CASELESS) != 0)? OP_DNREFI : OP_DNREF;
7179 PUT2INC(code, 0, index);
7180 PUT2INC(code, 0, count);
7228 /* Come here from the \g<...> and \g'...' code (Oniguruma
7286 /* Come here from code above that handles a named recursion */
7290 previous = code;
7302 *code = OP_END;
7327 PUTINC(cd->hwm, 0, (int)(code + 1 - cd->start_code));
7340 could_be_empty(called, code, bcptr, utf, cd))
7351 *code = OP_RECURSE;
7352 PUT(code, 1, (int)(called - cd->start_code));
7353 code += 1 + LINK_SIZE;
7404 If the code pointer is not (cd->start_code + 1 + LINK_SIZE), we are
7406 compiled. In the pre-compile phase, however, the code pointer can have
7407 that value after the start, because it gets reset as code is discarded
7420 if (code == cd->start_code + 1 + LINK_SIZE &&
7465 PUT2(code, 1+LINK_SIZE, cd->bracount);
7479 compatibility, so all kinds can now be repeated. We copy code into a
7483 previous = code; /* For handling repetition */
7484 *code = bravalue;
7485 tempcode = code;
7492 &tempcode, /* Where to put code (updated) */
7518 *code = OP_ONCE_NC;
7523 /* At the end of compiling, code is still pointing to the start of the
7534 pcre_uchar *tc = code;
7546 if (code[LINK_SIZE+1] == OP_DEF)
7580 less the brackets at either end. Then reduce the compiled code to just a
7592 code++; /* This already contains bravalue */
7593 PUTINC(code, 0, 1 + LINK_SIZE);
7594 *code++ = OP_KET;
7595 PUTINC(code, 0, 1 + LINK_SIZE);
7599 /* Otherwise update the main code pointer to the end of the group. */
7601 code = tempcode;
7610 branches (see code above). If the bracket is followed by a quantifier with
7797 previous = code;
7798 *code++ = ((options & PCRE_CASELESS) != 0)? OP_REFI : OP_REF;
7799 PUT2INC(code, 0, recno);
7826 previous = code;
7827 *code++ = ((escape == ESC_p) != negated)? OP_PROP : OP_NOTPROP;
7828 *code++ = ptype;
7829 *code++ = pdata;
7866 previous = (escape > ESC_b && escape < ESC_Z)? code : NULL;
7867 *code++ = (!utf && escape == ESC_C)? OP_ALLANY : escape;
7909 previous = code;
7921 *code++ = OP_PROP;
7922 *code++ = PT_CLIST;
7923 *code++ = c;
7933 *code++ = ((options & PCRE_CASELESS) != 0)? OP_CHARI : OP_CHAR;
7934 for (c = 0; c < mclength; c++) *code++ = mcbuffer[c];
7963 reqchar = code[-1];
7981 reqchar = code[-1];
8007 points to the closing bracket, or vertical bar, or end of string. The code
8015 codeptr -> the address of the current code pointer
8017 errorcodeptr -> pointer to error code variable
8043 pcre_uchar *code = *codeptr;
8044 pcre_uchar *last_branch = code;
8045 pcre_uchar *start_bracket = code;
8069 bc.current_branch = code;
8077 lenthptr for NULL. We cannot do this by looking at the value of code at the
8084 the code that abstracts option settings at the start of the pattern and makes
8094 if (*code == OP_CBRA)
8096 capnumber = GET2(code, 1 + LINK_SIZE);
8105 PUT(code, 1, 0);
8106 code += 1 + LINK_SIZE + skipbytes;
8122 *code++ = OP_REVERSE;
8123 reverse_count = code;
8124 PUTINC(code, 0, 0);
8131 if (!compile_branch(&options, &code, &ptr, errorcodeptr, &branchfirstchar,
8213 *code = OP_END;
8248 int branch_length = (int)(code - last_branch);
8261 *code = OP_KET;
8262 PUT(code, 1, (int)(code - start_bracket));
8263 code += 1 + LINK_SIZE;
8267 Because we are moving code along, we must ensure that any pending recursive
8274 *code = OP_END;
8278 IN_UCHARS(code - start_bracket));
8280 code += 1 + LINK_SIZE;
8281 PUT(start_bracket, 1, (int)(code - start_bracket));
8282 *code = OP_KET;
8283 PUT(code, 1, (int)(code - start_bracket));
8284 code += 1 + LINK_SIZE;
8296 *codeptr = code;
8314 /* Another branch follows. In the pre-compile phase, we can move the code
8325 code = *codeptr + 1 + LINK_SIZE + skipbytes;
8330 *code = OP_ALT;
8331 PUT(code, 1, (int)(code - last_branch));
8332 bc.current_branch = last_branch = code;
8333 code += 1 + LINK_SIZE;
8355 This is the code for \G, which means "match at start of match position, taking
8375 code points to start of expression (the bracket)
8386 is_anchored(register const pcre_uchar *code, unsigned int bracket_map,
8391 code + PRIV(OP_lengths)[*code], FALSE);
8443 code += GET(code, 1);
8445 while (*code == OP_ALT); /* Loop for each alternative */
8465 code points to start of expression (the bracket)
8476 is_startline(const pcre_uchar *code, unsigned int bracket_map,
8481 code + PRIV(OP_lengths)[*code], FALSE);
8566 code += GET(code, 1);
8568 while (*code == OP_ALT); /* Loop for each alternative */
8588 code points to start of expression (the bracket)
8596 find_firstassertedchar(const pcre_uchar *code, pcre_int32 *flags,
8606 int xl = (*code == OP_CBRA || *code == OP_SCBRA ||
8607 *code == OP_CBRAPOS || *code == OP_SCBRAPOS)? IMM2_SIZE:0;
8608 const pcre_uchar *scode = first_significant_code(code + 1+LINK_SIZE + xl,
8659 code += GET(code, 1);
8661 while (*code == OP_ALT);
8730 function had no error code return variable; it is retained for backwards
8736 errorcodeptr pointer to error code variable (pcre_compile2() only)
8737 can be NULL if you don't want a code value
8796 pcre_uchar *code;
8821 can do is just return NULL, but we can set a code value if there is a code
8969 /* Can't support UTF unless PCRE has been compiled to include the code. The
8970 return of an error code from PRIV(valid_utf)() is a new feature, introduced in
8995 /* Can't support UCP unless PCRE has been compiled to include the code. */
9015 current code allows for fixed one- or two-byte sequences, plus "any" and
9072 to compile parts of the pattern into; the compiled code is discarded when it is
9104 code = cworkspace;
9105 *code = OP_BRA;
9107 (void)compile_regex(cd->external_options, &code, &ptr, &errorcode, FALSE,
9170 /* The starting points of the name/number translation table and of the code are
9211 code = (pcre_uchar *)codestart;
9212 *code = OP_BRA;
9213 (void)compile_regex(re->options, &code, &ptr, &errorcode, FALSE, FALSE, 0, 0,
9233 *code++ = OP_END;
9236 if (code - codestart > length) errorcode = ERR23;
9243 VALGRIND_MAKE_MEM_NOACCESS(code, (length - (code - codestart)) * sizeof(pcre_uchar));
9284 used in this code because at least one compiler gives a warning about loss of
9478 /* This check is done here in the debugging case so that the code that
9481 if (code - codestart > length)
9496 if (could_be_empty_branch(codestart, code, utf, cd, NULL))