PageRenderTime 62ms CodeModel.GetById 24ms RepoModel.GetById 0ms app.codeStats 0ms

/tags/harbour-1.0.0/source/hbpcre/pcrecomp.c

#
C | 2147 lines | 1300 code | 310 blank | 537 comment | 426 complexity | 77a2ead75113a065678eef12a603e3c3 MD5 | raw file
Possible License(s): AGPL-1.0, BSD-3-Clause, CC-BY-SA-3.0, LGPL-3.0, GPL-2.0, LGPL-2.0, LGPL-2.1

Large files files are truncated, but you can click here to view the full file

    

  1. /*************************************************
    2. 

  2. *      Perl-Compatible Regular Expressions       *
    3. 

  3. *************************************************/
    4. 

  4. 

  5. /* PCRE is a library of functions to support regular expressions whose syntax
    6. 

  6. and semantics are as close as possible to those of the Perl 5 language.
    7. 

    8. 

  8.                        Written by Philip Hazel
    9. 

  9.            Copyright (c) 1997-2008 University of Cambridge
    10. 

    11. 

  11. -----------------------------------------------------------------------------
    12. 

  12. Redistribution and use in source and binary forms, with or without
    13. 

  13. modification, are permitted provided that the following conditions are met:
    14. 

    15. 

  15.     * Redistributions of source code must retain the above copyright notice,
    16. 

  16.       this list of conditions and the following disclaimer.
    17. 

    18. 

  18.     * Redistributions in binary form must reproduce the above copyright
    19. 

  19.       notice, this list of conditions and the following disclaimer in the
    20. 

  20.       documentation and/or other materials provided with the distribution.
    21. 

    22. 

  22.     * Neither the name of the University of Cambridge nor the names of its
    23. 

  23.       contributors may be used to endorse or promote products derived from
    24. 

  24.       this software without specific prior written permission.
    25. 

    26. 

  26. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    27. 

  27. AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    28. 

  28. IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    29. 

  29. ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
    30. 

  30. LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    31. 

  31. CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    32. 

  32. SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    33. 

  33. INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
    34. 

  34. CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    35. 

  35. ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    36. 

  36. POSSIBILITY OF SUCH DAMAGE.
    37. 

  37. -----------------------------------------------------------------------------
    38. 

  38. */
    39. 

  39. 

  40. 

  41. /* This module contains the external function pcre_compile(), along with
    42. 

  42. supporting internal functions that are not used by other modules. */
    43. 

  43. 

  44. 

  45. #if 1
    46. 

  46. #include "_hbconf.h"
    47. 

  47. #endif
    48. 

  48. 

  49. #define NLBLOCK cd             /* Block containing newline information */
    50. 

  50. #define PSSTART start_pattern  /* Field containing processed string start */
    51. 

  51. #define PSEND   end_pattern    /* Field containing processed string end */
    52. 

  52. 

  53. #include "pcreinal.h"
    54. 

  54. 

  55. 

  56. /* When DEBUG is defined, we need the pcre_printint() function, which is also
    57. 

  57. used by pcretest. DEBUG is not defined when building a production library. */
    58. 

  58. 

  59. #ifdef DEBUG
    60. 

  60. #include "pcreprni.h"
    61. 

  61. #endif
    62. 

  62. 

  63. 

  64. /* Macro for setting individual bits in class bitmaps. */
    65. 

  65. 

  66. #define SETBIT(a,b) a[b/8] |= (1 << (b%8))
    67. 

  67. 

  68. /* Maximum length value to check against when making sure that the integer that
    69. 

  69. holds the compiled pattern length does not overflow. We make it a bit less than
    70. 

  70. INT_MAX to allow for adding in group terminating bytes, so that we don't have
    71. 

  71. to check them every time. */
    72. 

  72. 

  73. #define OFLOW_MAX (INT_MAX - 20)
    74. 

  74. 

  75. 

  76. /*************************************************
    77. 

  77. *      Code parameters and static tables         *
    78. 

  78. *************************************************/
    79. 

  79. 

  80. /* This value specifies the size of stack workspace that is used during the
    81. 

  81. first pre-compile phase that determines how much memory is required. The regex
    82. 

  82. is partly compiled into this space, but the compiled parts are discarded as
    83. 

  83. soon as they can be, so that hopefully there will never be an overrun. The code
    84. 

  84. does, however, check for an overrun. The largest amount I've seen used is 218,
    85. 

  85. so this number is very generous.
    86. 

    87. 

  87. The same workspace is used during the second, actual compile phase for
    88. 

  88. remembering forward references to groups so that they can be filled in at the
    89. 

  89. end. Each entry in this list occupies LINK_SIZE bytes, so even when LINK_SIZE
    90. 

  90. is 4 there is plenty of room. */
    91. 

  91. 

  92. #define COMPILE_WORK_SIZE (4096)
    93. 

  93. 

  94. 

  95. /* Table for handling escaped characters in the range '0'-'z'. Positive returns
    96. 

  96. are simple data values; negative values are for special things like \d and so
    97. 

  97. on. Zero means further processing is needed (for things like \x), or the escape
    98. 

  98. is invalid. */
    99. 

  99. 

  100. #ifndef EBCDIC  /* This is the "normal" table for ASCII systems */
    101. 

  101. static const short int escapes[] = {
    102. 

  102.      0,      0,      0,      0,      0,      0,      0,      0,   /* 0 - 7 */
    103. 

  103.      0,      0,    ':',    ';',    '<',    '=',    '>',    '?',   /* 8 - ? */
    104. 

  104.    '@', -ESC_A, -ESC_B, -ESC_C, -ESC_D, -ESC_E,      0, -ESC_G,   /* @ - G */
    105. 

  105. -ESC_H,      0,      0, -ESC_K,      0,      0,      0,      0,   /* H - O */
    106. 

  106. -ESC_P, -ESC_Q, -ESC_R, -ESC_S,      0,      0, -ESC_V, -ESC_W,   /* P - W */
    107. 

  107. -ESC_X,      0, -ESC_Z,    '[',   '\\',    ']',    '^',    '_',   /* X - _ */
    108. 

  108.    '`',      7, -ESC_b,      0, -ESC_d,  ESC_e,  ESC_f,      0,   /* ` - g */
    109. 

  109. -ESC_h,      0,      0, -ESC_k,      0,      0,  ESC_n,      0,   /* h - o */
    110. 

  110. -ESC_p,      0,  ESC_r, -ESC_s,  ESC_tee,    0, -ESC_v, -ESC_w,   /* p - w */
    111. 

  111.      0,      0, -ESC_z                                            /* x - z */
    112. 

  112. };
    113. 

  113. 

  114. #else           /* This is the "abnormal" table for EBCDIC systems */
    115. 

  115. static const short int escapes[] = {
    116. 

  116. /*  48 */     0,     0,      0,     '.',    '<',   '(',    '+',    '|',
    117. 

  117. /*  50 */   '&',     0,      0,       0,      0,     0,      0,      0,
    118. 

  118. /*  58 */     0,     0,    '!',     '$',    '*',   ')',    ';',    '~',
    119. 

  119. /*  60 */   '-',   '/',      0,       0,      0,     0,      0,      0,
    120. 

  120. /*  68 */     0,     0,    '|',     ',',    '%',   '_',    '>',    '?',
    121. 

  121. /*  70 */     0,     0,      0,       0,      0,     0,      0,      0,
    122. 

  122. /*  78 */     0,   '`',    ':',     '#',    '@',  '\'',    '=',    '"',
    123. 

  123. /*  80 */     0,     7, -ESC_b,       0, -ESC_d, ESC_e,  ESC_f,      0,
    124. 

  124. /*  88 */-ESC_h,     0,      0,     '{',      0,     0,      0,      0,
    125. 

  125. /*  90 */     0,     0, -ESC_k,     'l',      0, ESC_n,      0, -ESC_p,
    126. 

  126. /*  98 */     0, ESC_r,      0,     '}',      0,     0,      0,      0,
    127. 

  127. /*  A0 */     0,   '~', -ESC_s, ESC_tee,      0,-ESC_v, -ESC_w,      0,
    128. 

  128. /*  A8 */     0,-ESC_z,      0,       0,      0,   '[',      0,      0,
    129. 

  129. /*  B0 */     0,     0,      0,       0,      0,     0,      0,      0,
    130. 

  130. /*  B8 */     0,     0,      0,       0,      0,   ']',    '=',    '-',
    131. 

  131. /*  C0 */   '{',-ESC_A, -ESC_B,  -ESC_C, -ESC_D,-ESC_E,      0, -ESC_G,
    132. 

  132. /*  C8 */-ESC_H,     0,      0,       0,      0,     0,      0,      0,
    133. 

  133. /*  D0 */   '}',     0, -ESC_K,       0,      0,     0,      0, -ESC_P,
    134. 

  134. /*  D8 */-ESC_Q,-ESC_R,      0,       0,      0,     0,      0,      0,
    135. 

  135. /*  E0 */  '\\',     0, -ESC_S,       0,      0,-ESC_V, -ESC_W, -ESC_X,
    136. 

  136. /*  E8 */     0,-ESC_Z,      0,       0,      0,     0,      0,      0,
    137. 

  137. /*  F0 */     0,     0,      0,       0,      0,     0,      0,      0,
    138. 

  138. /*  F8 */     0,     0,      0,       0,      0,     0,      0,      0
    139. 

  139. };
    140. 

  140. #endif
    141. 

  141. 

  142. 

  143. /* Table of special "verbs" like (*PRUNE). This is a short table, so it is
    144. 

  144. searched linearly. Put all the names into a single string, in order to reduce
    145. 

  145. the number of relocations when a shared library is dynamically linked. */
    146. 

  146. 

  147. typedef struct verbitem {
    148. 

  148.   int   len;
    149. 

  149.   int   op;
    150. 

  150. } verbitem;
    151. 

  151. 

  152. static const char verbnames[] =
    153. 

  153.   "ACCEPT\0"
    154. 

  154.   "COMMIT\0"
    155. 

  155.   "F\0"
    156. 

  156.   "FAIL\0"
    157. 

  157.   "PRUNE\0"
    158. 

  158.   "SKIP\0"
    159. 

  159.   "THEN";
    160. 

  160. 

  161. static const verbitem verbs[] = {
    162. 

  162.   { 6, OP_ACCEPT },
    163. 

  163.   { 6, OP_COMMIT },
    164. 

  164.   { 1, OP_FAIL },
    165. 

  165.   { 4, OP_FAIL },
    166. 

  166.   { 5, OP_PRUNE },
    167. 

  167.   { 4, OP_SKIP  },
    168. 

  168.   { 4, OP_THEN  }
    169. 

  169. };
    170. 

  170. 

  171. static const int verbcount = sizeof(verbs)/sizeof(verbitem);
    172. 

  172. 

  173. 

  174. /* Tables of names of POSIX character classes and their lengths. The names are
    175. 

  175. now all in a single string, to reduce the number of relocations when a shared
    176. 

  176. library is dynamically loaded. The list of lengths is terminated by a zero
    177. 

  177. length entry. The first three must be alpha, lower, upper, as this is assumed
    178. 

  178. for handling case independence. */
    179. 

  179. 

  180. static const char posix_names[] =
    181. 

  181.   "alpha\0"  "lower\0"  "upper\0"  "alnum\0"  "ascii\0"  "blank\0"
    182. 

  182.   "cntrl\0"  "digit\0"  "graph\0"  "print\0"  "punct\0"  "space\0"
    183. 

  183.   "word\0"   "xdigit";
    184. 

  184. 

  185. static const uschar posix_name_lengths[] = {
    186. 

  186.   5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 6, 0 };
    187. 

  187. 

  188. /* Table of class bit maps for each POSIX class. Each class is formed from a
    189. 

  189. base map, with an optional addition or removal of another map. Then, for some
    190. 

  190. classes, there is some additional tweaking: for [:blank:] the vertical space
    191. 

  191. characters are removed, and for [:alpha:] and [:alnum:] the underscore
    192. 

  192. character is removed. The triples in the table consist of the base map offset,
    193. 

  193. second map offset or -1 if no second map, and a non-negative value for map
    194. 

  194. addition or a negative value for map subtraction (if there are two maps). The
    195. 

  195. absolute value of the third field has these meanings: 0 => no tweaking, 1 =>
    196. 

  196. remove vertical space characters, 2 => remove underscore. */
    197. 

  197. 

  198. static const int posix_class_maps[] = {
    199. 

  199.   cbit_word,  cbit_digit, -2,             /* alpha */
    200. 

  200.   cbit_lower, -1,          0,             /* lower */
    201. 

  201.   cbit_upper, -1,          0,             /* upper */
    202. 

  202.   cbit_word,  -1,          2,             /* alnum - word without underscore */
    203. 

  203.   cbit_print, cbit_cntrl,  0,             /* ascii */
    204. 

  204.   cbit_space, -1,          1,             /* blank - a GNU extension */
    205. 

  205.   cbit_cntrl, -1,          0,             /* cntrl */
    206. 

  206.   cbit_digit, -1,          0,             /* digit */
    207. 

  207.   cbit_graph, -1,          0,             /* graph */
    208. 

  208.   cbit_print, -1,          0,             /* print */
    209. 

  209.   cbit_punct, -1,          0,             /* punct */
    210. 

  210.   cbit_space, -1,          0,             /* space */
    211. 

  211.   cbit_word,  -1,          0,             /* word - a Perl extension */
    212. 

  212.   cbit_xdigit,-1,          0              /* xdigit */
    213. 

  213. };
    214. 

  214. 

  215. 

  216. #define STRING(a)  # a
    217. 

  217. #define XSTRING(s) STRING(s)
    218. 

  218. 

  219. /* The texts of compile-time error messages. These are "char *" because they
    220. 

  220. are passed to the outside world. Do not ever re-use any error number, because
    221. 

  221. they are documented. Always add a new error instead. Messages marked DEAD below
    222. 

  222. are no longer used. This used to be a table of strings, but in order to reduce
    223. 

  223. the number of relocations needed when a shared library is loaded dynamically,
    224. 

  224. it is now one long string. We cannot use a table of offsets, because the
    225. 

  225. lengths of inserts such as XSTRING(MAX_NAME_SIZE) are not known. Instead, we
    226. 

  226. simply count through to the one we want - this isn't a performance issue
    227. 

  227. because these strings are used only when there is a compilation error. */
    228. 

  228. 

  229. static const char error_texts[] =
    230. 

  230.   "no error\0"
    231. 

  231.   "\\ at end of pattern\0"
    232. 

  232.   "\\c at end of pattern\0"
    233. 

  233.   "unrecognized character follows \\\0"
    234. 

  234.   "numbers out of order in {} quantifier\0"
    235. 

  235.   /* 5 */
    236. 

  236.   "number too big in {} quantifier\0"
    237. 

  237.   "missing terminating ] for character class\0"
    238. 

  238.   "invalid escape sequence in character class\0"
    239. 

  239.   "range out of order in character class\0"
    240. 

  240.   "nothing to repeat\0"
    241. 

  241.   /* 10 */
    242. 

  242.   "operand of unlimited repeat could match the empty string\0"  /** DEAD **/
    243. 

  243.   "internal error: unexpected repeat\0"
    244. 

  244.   "unrecognized character after (? or (?-\0"
    245. 

  245.   "POSIX named classes are supported only within a class\0"
    246. 

  246.   "missing )\0"
    247. 

  247.   /* 15 */
    248. 

  248.   "reference to non-existent subpattern\0"
    249. 

  249.   "erroffset passed as NULL\0"
    250. 

  250.   "unknown option bit(s) set\0"
    251. 

  251.   "missing ) after comment\0"
    252. 

  252.   "parentheses nested too deeply\0"  /** DEAD **/
    253. 

  253.   /* 20 */
    254. 

  254.   "regular expression is too large\0"
    255. 

  255.   "failed to get memory\0"
    256. 

  256.   "unmatched parentheses\0"
    257. 

  257.   "internal error: code overflow\0"
    258. 

  258.   "unrecognized character after (?<\0"
    259. 

  259.   /* 25 */
    260. 

  260.   "lookbehind assertion is not fixed length\0"
    261. 

  261.   "malformed number or name after (?(\0"
    262. 

  262.   "conditional group contains more than two branches\0"
    263. 

  263.   "assertion expected after (?(\0"
    264. 

  264.   "(?R or (?[+-]digits must be followed by )\0"
    265. 

  265.   /* 30 */
    266. 

  266.   "unknown POSIX class name\0"
    267. 

  267.   "POSIX collating elements are not supported\0"
    268. 

  268.   "this version of PCRE is not compiled with PCRE_UTF8 support\0"
    269. 

  269.   "spare error\0"  /** DEAD **/
    270. 

  270.   "character value in \\x{...} sequence is too large\0"
    271. 

  271.   /* 35 */
    272. 

  272.   "invalid condition (?(0)\0"
    273. 

  273.   "\\C not allowed in lookbehind assertion\0"
    274. 

  274.   "PCRE does not support \\L, \\l, \\N, \\U, or \\u\0"
    275. 

  275.   "number after (?C is > 255\0"
    276. 

  276.   "closing ) for (?C expected\0"
    277. 

  277.   /* 40 */
    278. 

  278.   "recursive call could loop indefinitely\0"
    279. 

  279.   "unrecognized character after (?P\0"
    280. 

  280.   "syntax error in subpattern name (missing terminator)\0"
    281. 

  281.   "two named subpatterns have the same name\0"
    282. 

  282.   "invalid UTF-8 string\0"
    283. 

  283.   /* 45 */
    284. 

  284.   "support for \\P, \\p, and \\X has not been compiled\0"
    285. 

  285.   "malformed \\P or \\p sequence\0"
    286. 

  286.   "unknown property name after \\P or \\p\0"
    287. 

  287.   "subpattern name is too long (maximum " XSTRING(MAX_NAME_SIZE) " characters)\0"
    288. 

  288.   "too many named subpatterns (maximum " XSTRING(MAX_NAME_COUNT) ")\0"
    289. 

  289.   /* 50 */
    290. 

  290.   "repeated subpattern is too long\0"    /** DEAD **/
    291. 

  291.   "octal value is greater than \\377 (not in UTF-8 mode)\0"
    292. 

  292.   "internal error: overran compiling workspace\0"
    293. 

  293.   "internal error: previously-checked referenced subpattern not found\0"
    294. 

  294.   "DEFINE group contains more than one branch\0"
    295. 

  295.   /* 55 */
    296. 

  296.   "repeating a DEFINE group is not allowed\0"
    297. 

  297.   "inconsistent NEWLINE options\0"
    298. 

  298.   "\\g is not followed by a braced, angle-bracketed, or quoted name/number or by a plain number\0"
    299. 

  299.   "a numbered reference must not be zero\0"
    300. 

  300.   "(*VERB) with an argument is not supported\0"
    301. 

  301.   /* 60 */
    302. 

  302.   "(*VERB) not recognized\0"
    303. 

  303.   "number is too big\0"
    304. 

  304.   "subpattern name expected\0"
    305. 

  305.   "digit expected after (?+\0"
    306. 

  306.   "] is an invalid data character in JavaScript compatibility mode";
    307. 

  307. 

  308. 

  309. /* Table to identify digits and hex digits. This is used when compiling
    310. 

  310. patterns. Note that the tables in chartables are dependent on the locale, and
    311. 

  311. may mark arbitrary characters as digits - but the PCRE compiling code expects
    312. 

  312. to handle only 0-9, a-z, and A-Z as digits when compiling. That is why we have
    313. 

  313. a private table here. It costs 256 bytes, but it is a lot faster than doing
    314. 

  314. character value tests (at least in some simple cases I timed), and in some
    315. 

  315. applications one wants PCRE to compile efficiently as well as match
    316. 

  316. efficiently.
    317. 

    318. 

  318. For convenience, we use the same bit definitions as in chartables:
    319. 

    320. 

  320.   0x04   decimal digit
    321. 

  321.   0x08   hexadecimal digit
    322. 

    323. 

  323. Then we can use ctype_digit and ctype_xdigit in the code. */
    324. 

  324. 

  325. #ifndef EBCDIC  /* This is the "normal" case, for ASCII systems */
    326. 

  326. static const unsigned char digitab[] =
    327. 

  327.   {
    328. 

  328.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*   0-  7 */
    329. 

  329.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*   8- 15 */
    330. 

  330.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  16- 23 */
    331. 

  331.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  24- 31 */
    332. 

  332.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*    - '  */
    333. 

  333.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  ( - /  */
    334. 

  334.   0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c, /*  0 - 7  */
    335. 

  335.   0x0c,0x0c,0x00,0x00,0x00,0x00,0x00,0x00, /*  8 - ?  */
    336. 

  336.   0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /*  @ - G  */
    337. 

  337.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  H - O  */
    338. 

  338.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  P - W  */
    339. 

  339.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  X - _  */
    340. 

  340.   0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /*  ` - g  */
    341. 

  341.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  h - o  */
    342. 

  342.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  p - w  */
    343. 

  343.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  x -127 */
    344. 

  344.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 128-135 */
    345. 

  345.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 136-143 */
    346. 

  346.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 144-151 */
    347. 

  347.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 152-159 */
    348. 

  348.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 160-167 */
    349. 

  349.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 168-175 */
    350. 

  350.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 176-183 */
    351. 

  351.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191 */
    352. 

  352.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 192-199 */
    353. 

  353.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 200-207 */
    354. 

  354.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 208-215 */
    355. 

  355.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 216-223 */
    356. 

  356.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 224-231 */
    357. 

  357.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 232-239 */
    358. 

  358.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 240-247 */
    359. 

  359.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};/* 248-255 */
    360. 

  360. 

  361. #else           /* This is the "abnormal" case, for EBCDIC systems */
    362. 

  362. static const unsigned char digitab[] =
    363. 

  363.   {
    364. 

  364.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*   0-  7  0 */
    365. 

  365.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*   8- 15    */
    366. 

  366.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  16- 23 10 */
    367. 

  367.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  24- 31    */
    368. 

  368.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  32- 39 20 */
    369. 

  369.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  40- 47    */
    370. 

  370.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  48- 55 30 */
    371. 

  371.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  56- 63    */
    372. 

  372.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*    - 71 40 */
    373. 

  373.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  72- |     */
    374. 

  374.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  & - 87 50 */
    375. 

  375.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  88- 95    */
    376. 

  376.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  - -103 60 */
    377. 

  377.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 104- ?     */
    378. 

  378.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 112-119 70 */
    379. 

  379.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 120- "     */
    380. 

  380.   0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /* 128- g  80 */
    381. 

  381.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  h -143    */
    382. 

  382.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 144- p  90 */
    383. 

  383.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  q -159    */
    384. 

  384.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 160- x  A0 */
    385. 

  385.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  y -175    */
    386. 

  386.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  ^ -183 B0 */
    387. 

  387.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191    */
    388. 

  388.   0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /*  { - G  C0 */
    389. 

  389.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  H -207    */
    390. 

  390.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  } - P  D0 */
    391. 

  391.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  Q -223    */
    392. 

  392.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  \ - X  E0 */
    393. 

  393.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  Y -239    */
    394. 

  394.   0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c, /*  0 - 7  F0 */
    395. 

  395.   0x0c,0x0c,0x00,0x00,0x00,0x00,0x00,0x00};/*  8 -255    */
    396. 

  396. 

  397. static const unsigned char ebcdic_chartab[] = { /* chartable partial dup */
    398. 

  398.   0x80,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /*   0-  7 */
    399. 

  399.   0x00,0x00,0x00,0x00,0x01,0x01,0x00,0x00, /*   8- 15 */
    400. 

  400.   0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /*  16- 23 */
    401. 

  401.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  24- 31 */
    402. 

  402.   0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /*  32- 39 */
    403. 

  403.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  40- 47 */
    404. 

  404.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  48- 55 */
    405. 

  405.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  56- 63 */
    406. 

  406.   0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*    - 71 */
    407. 

  407.   0x00,0x00,0x00,0x80,0x00,0x80,0x80,0x80, /*  72- |  */
    408. 

  408.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  & - 87 */
    409. 

  409.   0x00,0x00,0x00,0x80,0x80,0x80,0x00,0x00, /*  88- 95 */
    410. 

  410.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  - -103 */
    411. 

  411.   0x00,0x00,0x00,0x00,0x00,0x10,0x00,0x80, /* 104- ?  */
    412. 

  412.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 112-119 */
    413. 

  413.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 120- "  */
    414. 

  414.   0x00,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /* 128- g  */
    415. 

  415.   0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  h -143 */
    416. 

  416.   0x00,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* 144- p  */
    417. 

  417.   0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  q -159 */
    418. 

  418.   0x00,0x00,0x12,0x12,0x12,0x12,0x12,0x12, /* 160- x  */
    419. 

  419.   0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  y -175 */
    420. 

  420.   0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  ^ -183 */
    421. 

  421.   0x00,0x00,0x80,0x00,0x00,0x00,0x00,0x00, /* 184-191 */
    422. 

  422.   0x80,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /*  { - G  */
    423. 

  423.   0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  H -207 */
    424. 

  424.   0x00,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /*  } - P  */
    425. 

  425.   0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  Q -223 */
    426. 

  426.   0x00,0x00,0x12,0x12,0x12,0x12,0x12,0x12, /*  \ - X  */
    427. 

  427.   0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  Y -239 */
    428. 

  428.   0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c, /*  0 - 7  */
    429. 

  429.   0x1c,0x1c,0x00,0x00,0x00,0x00,0x00,0x00};/*  8 -255 */
    430. 

  430. #endif
    431. 

  431. 

  432. 

  433. /* Definition to allow mutual recursion */
    434. 

  434. 

  435. static BOOL
    436. 

  436.   compile_regex(int, int, uschar **, const uschar **, int *, BOOL, BOOL, int,
    437. 

  437.     int *, int *, branch_chain *, compile_data *, int *);
    438. 

  438. 

  439. 

  440. 

  441. /*************************************************
    442. 

  442. *            Find an error text                  *
    443. 

  443. *************************************************/
    444. 

  444. 

  445. /* The error texts are now all in one long string, to save on relocations. As
    446. 

  446. some of the text is of unknown length, we can't use a table of offsets.
    447. 

  447. Instead, just count through the strings. This is not a performance issue
    448. 

  448. because it happens only when there has been a compilation error.
    449. 

    450. 

  450. Argument:   the error number
    451. 

  451. Returns:    pointer to the error string
    452. 

  452. */
    453. 

  453. 

  454. static const char *
    455. 

  455. find_error_text(int n)
    456. 

  456. {
    457. 

  457. const char *s = error_texts;
    458. 

  458. for (; n > 0; n--) while (*s++ != 0) {};
    459. 

  459. return s;
    460. 

  460. }
    461. 

  461. 

  462. 

  463. /*************************************************
    464. 

  464. *            Handle escapes                      *
    465. 

  465. *************************************************/
    466. 

  466. 

  467. /* This function is called when a \ has been encountered. It either returns a
    468. 

  468. positive value for a simple escape such as \n, or a negative value which
    469. 

  469. encodes one of the more complicated things such as \d. A backreference to group
    470. 

  470. n is returned as -(ESC_REF + n); ESC_REF is the highest ESC_xxx macro. When
    471. 

  471. UTF-8 is enabled, a positive value greater than 255 may be returned. On entry,
    472. 

  472. ptr is pointing at the \. On exit, it is on the final character of the escape
    473. 

  473. sequence.
    474. 

    475. 

  475. Arguments:
    476. 

  476.   ptrptr         points to the pattern position pointer
    477. 

  477.   errorcodeptr   points to the errorcode variable
    478. 

  478.   bracount       number of previous extracting brackets
    479. 

  479.   options        the options bits
    480. 

  480.   isclass        TRUE if inside a character class
    481. 

    482. 

  482. Returns:         zero or positive => a data character
    483. 

  483.                  negative => a special escape sequence
    484. 

  484.                  on error, errorcodeptr is set
    485. 

  485. */
    486. 

  486. 

  487. static int
    488. 

  488. check_escape(const uschar **ptrptr, int *errorcodeptr, int bracount,
    489. 

  489.   int options, BOOL isclass)
    490. 

  490. {
    491. 

  491. BOOL utf8 = (options & PCRE_UTF8) != 0;
    492. 

  492. const uschar *ptr = *ptrptr + 1;
    493. 

  493. int c, i;
    494. 

  494. 

  495. GETCHARINCTEST(c, ptr);           /* Get character value, increment pointer */
    496. 

  496. ptr--;                            /* Set pointer back to the last byte */
    497. 

  497. 

  498. /* If backslash is at the end of the pattern, it's an error. */
    499. 

  499. 

  500. if (c == 0) *errorcodeptr = ERR1;
    501. 

  501. 

  502. /* Non-alphanumerics are literals. For digits or letters, do an initial lookup
    503. 

  503. in a table. A non-zero result is something that can be returned immediately.
    504. 

  504. Otherwise further processing may be required. */
    505. 

  505. 

  506. #ifndef EBCDIC  /* ASCII coding */
    507. 

  507. else if (c < '0' || c > 'z') {}                           /* Not alphanumeric */
    508. 

  508. else if ((i = escapes[c - '0']) != 0) c = i;
    509. 

  509. 

  510. #else           /* EBCDIC coding */
    511. 

  511. else if (c < 'a' || (ebcdic_chartab[c] & 0x0E) == 0) {}   /* Not alphanumeric */
    512. 

  512. else if ((i = escapes[c - 0x48]) != 0)  c = i;
    513. 

  513. #endif
    514. 

  514. 

  515. /* Escapes that need further processing, or are illegal. */
    516. 

  516. 

  517. else
    518. 

  518.   {
    519. 

  519.   const uschar *oldptr;
    520. 

  520.   BOOL braced, negated;
    521. 

  521. 

  522.   switch (c)
    523. 

  523.     {
    524. 

  524.     /* A number of Perl escapes are not handled by PCRE. We give an explicit
    525. 

  525.     error. */
    526. 

  526. 

  527.     case 'l':
    528. 

  528.     case 'L':
    529. 

  529.     case 'N':
    530. 

  530.     case 'u':
    531. 

  531.     case 'U':
    532. 

  532.     *errorcodeptr = ERR37;
    533. 

  533.     break;
    534. 

  534. 

  535.     /* \g must be followed by one of a number of specific things:
    536. 

    537. 

  537.     (1) A number, either plain or braced. If positive, it is an absolute
    538. 

  538.     backreference. If negative, it is a relative backreference. This is a Perl
    539. 

  539.     5.10 feature.
    540. 

    541. 

  541.     (2) Perl 5.10 also supports \g{name} as a reference to a named group. This
    542. 

  542.     is part of Perl's movement towards a unified syntax for back references. As
    543. 

  543.     this is synonymous with \k{name}, we fudge it up by pretending it really
    544. 

  544.     was \k.
    545. 

    546. 

  546.     (3) For Oniguruma compatibility we also support \g followed by a name or a
    547. 

  547.     number either in angle brackets or in single quotes. However, these are
    548. 

  548.     (possibly recursive) subroutine calls, _not_ backreferences. Just return
    549. 

  549.     the -ESC_g code (cf \k). */
    550. 

  550. 

  551.     case 'g':
    552. 

  552.     if (ptr[1] == '<' || ptr[1] == '\'')
    553. 

  553.       {
    554. 

  554.       c = -ESC_g;
    555. 

  555.       break;
    556. 

  556.       }
    557. 

  557. 

  558.     /* Handle the Perl-compatible cases */
    559. 

  559. 

  560.     if (ptr[1] == '{')
    561. 

  561.       {
    562. 

  562.       const uschar *p;
    563. 

  563.       for (p = ptr+2; *p != 0 && *p != '}'; p++)
    564. 

  564.         if (*p != '-' && (digitab[*p] & ctype_digit) == 0) break;
    565. 

  565.       if (*p != 0 && *p != '}')
    566. 

  566.         {
    567. 

  567.         c = -ESC_k;
    568. 

  568.         break;
    569. 

  569.         }
    570. 

  570.       braced = TRUE;
    571. 

  571.       ptr++;
    572. 

  572.       }
    573. 

  573.     else braced = FALSE;
    574. 

  574. 

  575.     if (ptr[1] == '-')
    576. 

  576.       {
    577. 

  577.       negated = TRUE;
    578. 

  578.       ptr++;
    579. 

  579.       }
    580. 

  580.     else negated = FALSE;
    581. 

  581. 

  582.     c = 0;
    583. 

  583.     while ((digitab[ptr[1]] & ctype_digit) != 0)
    584. 

  584.       c = c * 10 + *(++ptr) - '0';
    585. 

  585. 

  586.     if (c < 0)   /* Integer overflow */
    587. 

  587.       {
    588. 

  588.       *errorcodeptr = ERR61;
    589. 

  589.       break;
    590. 

  590.       }
    591. 

  591. 

  592.     if (braced && *(++ptr) != '}')
    593. 

  593.       {
    594. 

  594.       *errorcodeptr = ERR57;
    595. 

  595.       break;
    596. 

  596.       }
    597. 

  597. 

  598.     if (c == 0)
    599. 

  599.       {
    600. 

  600.       *errorcodeptr = ERR58;
    601. 

  601.       break;
    602. 

  602.       }
    603. 

  603. 

  604.     if (negated)
    605. 

  605.       {
    606. 

  606.       if (c > bracount)
    607. 

  607.         {
    608. 

  608.         *errorcodeptr = ERR15;
    609. 

  609.         break;
    610. 

  610.         }
    611. 

  611.       c = bracount - (c - 1);
    612. 

  612.       }
    613. 

  613. 

  614.     c = -(ESC_REF + c);
    615. 

  615.     break;
    616. 

  616. 

  617.     /* The handling of escape sequences consisting of a string of digits
    618. 

  618.     starting with one that is not zero is not straightforward. By experiment,
    619. 

  619.     the way Perl works seems to be as follows:
    620. 

    621. 

  621.     Outside a character class, the digits are read as a decimal number. If the
    622. 

  622.     number is less than 10, or if there are that many previous extracting
    623. 

  623.     left brackets, then it is a back reference. Otherwise, up to three octal
    624. 

  624.     digits are read to form an escaped byte. Thus \123 is likely to be octal
    625. 

  625.     123 (cf \0123, which is octal 012 followed by the literal 3). If the octal
    626. 

  626.     value is greater than 377, the least significant 8 bits are taken. Inside a
    627. 

  627.     character class, \ followed by a digit is always an octal number. */
    628. 

  628. 

  629.     case '1': case '2': case '3': case '4': case '5':
    630. 

  630.     case '6': case '7': case '8': case '9':
    631. 

  631. 

  632.     if (!isclass)
    633. 

  633.       {
    634. 

  634.       oldptr = ptr;
    635. 

  635.       c -= '0';
    636. 

  636.       while ((digitab[ptr[1]] & ctype_digit) != 0)
    637. 

  637.         c = c * 10 + *(++ptr) - '0';
    638. 

  638.       if (c < 0)    /* Integer overflow */
    639. 

  639.         {
    640. 

  640.         *errorcodeptr = ERR61;
    641. 

  641.         break;
    642. 

  642.         }
    643. 

  643.       if (c < 10 || c <= bracount)
    644. 

  644.         {
    645. 

  645.         c = -(ESC_REF + c);
    646. 

  646.         break;
    647. 

  647.         }
    648. 

  648.       ptr = oldptr;      /* Put the pointer back and fall through */
    649. 

  649.       }
    650. 

  650. 

  651.     /* Handle an octal number following \. If the first digit is 8 or 9, Perl
    652. 

  652.     generates a binary zero byte and treats the digit as a following literal.
    653. 

  653.     Thus we have to pull back the pointer by one. */
    654. 

  654. 

  655.     if ((c = *ptr) >= '8')
    656. 

  656.       {
    657. 

  657.       ptr--;
    658. 

  658.       c = 0;
    659. 

  659.       break;
    660. 

  660.       }
    661. 

  661. 

  662.     /* \0 always starts an octal number, but we may drop through to here with a
    663. 

  663.     larger first octal digit. The original code used just to take the least
    664. 

  664.     significant 8 bits of octal numbers (I think this is what early Perls used
    665. 

  665.     to do). Nowadays we allow for larger numbers in UTF-8 mode, but no more
    666. 

  666.     than 3 octal digits. */
    667. 

  667. 

  668.     case '0':
    669. 

  669.     c -= '0';
    670. 

  670.     while(i++ < 2 && ptr[1] >= '0' && ptr[1] <= '7')
    671. 

  671.         c = c * 8 + *(++ptr) - '0';
    672. 

  672.     if (!utf8 && c > 255) *errorcodeptr = ERR51;
    673. 

  673.     break;
    674. 

  674. 

  675.     /* \x is complicated. \x{ddd} is a character number which can be greater
    676. 

  676.     than 0xff in utf8 mode, but only if the ddd are hex digits. If not, { is
    677. 

  677.     treated as a data character. */
    678. 

  678. 

  679.     case 'x':
    680. 

  680.     if (ptr[1] == '{')
    681. 

  681.       {
    682. 

  682.       const uschar *pt = ptr + 2;
    683. 

  683.       int count = 0;
    684. 

  684. 

  685.       c = 0;
    686. 

  686.       while ((digitab[*pt] & ctype_xdigit) != 0)
    687. 

  687.         {
    688. 

  688.         register int cc = *pt++;
    689. 

  689.         if (c == 0 && cc == '0') continue;     /* Leading zeroes */
    690. 

  690.         count++;
    691. 

  691. 

  692. #ifndef EBCDIC  /* ASCII coding */
    693. 

  693.         if (cc >= 'a') cc -= 32;               /* Convert to upper case */
    694. 

  694.         c = (c << 4) + cc - ((cc < 'A')? '0' : ('A' - 10));
    695. 

  695. #else           /* EBCDIC coding */
    696. 

  696.         if (cc >= 'a' && cc <= 'z') cc += 64;  /* Convert to upper case */
    697. 

  697.         c = (c << 4) + cc - ((cc >= '0')? '0' : ('A' - 10));
    698. 

  698. #endif
    699. 

  699.         }
    700. 

  700. 

  701.       if (*pt == '}')
    702. 

  702.         {
    703. 

  703.         if (c < 0 || count > (utf8? 8 : 2)) *errorcodeptr = ERR34;
    704. 

  704.         ptr = pt;
    705. 

  705.         break;
    706. 

  706.         }
    707. 

  707. 

  708.       /* If the sequence of hex digits does not end with '}', then we don't
    709. 

  709.       recognize this construct; fall through to the normal \x handling. */
    710. 

  710.       }
    711. 

  711. 

  712.     /* Read just a single-byte hex-defined char */
    713. 

  713. 

  714.     c = 0;
    715. 

  715.     while (i++ < 2 && (digitab[ptr[1]] & ctype_xdigit) != 0)
    716. 

  716.       {
    717. 

  717.       int cc;                               /* Some compilers don't like ++ */
    718. 

  718.       cc = *(++ptr);                        /* in initializers */
    719. 

  719. #ifndef EBCDIC  /* ASCII coding */
    720. 

  720.       if (cc >= 'a') cc -= 32;              /* Convert to upper case */
    721. 

  721.       c = c * 16 + cc - ((cc < 'A')? '0' : ('A' - 10));
    722. 

  722. #else           /* EBCDIC coding */
    723. 

  723.       if (cc <= 'z') cc += 64;              /* Convert to upper case */
    724. 

  724.       c = c * 16 + cc - ((cc >= '0')? '0' : ('A' - 10));
    725. 

  725. #endif
    726. 

  726.       }
    727. 

  727.     break;
    728. 

  728. 

  729.     /* For \c, a following letter is upper-cased; then the 0x40 bit is flipped.
    730. 

  730.     This coding is ASCII-specific, but then the whole concept of \cx is
    731. 

  731.     ASCII-specific. (However, an EBCDIC equivalent has now been added.) */
    732. 

  732. 

  733.     case 'c':
    734. 

  734.     c = *(++ptr);
    735. 

  735.     if (c == 0)
    736. 

  736.       {
    737. 

  737.       *errorcodeptr = ERR2;
    738. 

  738.       break;
    739. 

  739.       }
    740. 

  740. 

  741. #ifndef EBCDIC  /* ASCII coding */
    742. 

  742.     if (c >= 'a' && c <= 'z') c -= 32;
    743. 

  743.     c ^= 0x40;
    744. 

  744. #else           /* EBCDIC coding */
    745. 

  745.     if (c >= 'a' && c <= 'z') c += 64;
    746. 

  746.     c ^= 0xC0;
    747. 

  747. #endif
    748. 

  748.     break;
    749. 

  749. 

  750.     /* PCRE_EXTRA enables extensions to Perl in the matter of escapes. Any
    751. 

  751.     other alphanumeric following \ is an error if PCRE_EXTRA was set;
    752. 

  752.     otherwise, for Perl compatibility, it is a literal. This code looks a bit
    753. 

  753.     odd, but there used to be some cases other than the default, and there may
    754. 

  754.     be again in future, so I haven't "optimized" it. */
    755. 

  755. 

  756.     default:
    757. 

  757.     if ((options & PCRE_EXTRA) != 0) switch(c)
    758. 

  758.       {
    759. 

  759.       default:
    760. 

  760.       *errorcodeptr = ERR3;
    761. 

  761.       break;
    762. 

  762.       }
    763. 

  763.     break;
    764. 

  764.     }
    765. 

  765.   }
    766. 

  766. 

  767. *ptrptr = ptr;
    768. 

  768. return c;
    769. 

  769. }
    770. 

  770. 

  771. 

  772. 

  773. #ifdef SUPPORT_UCP
    774. 

  774. /*************************************************
    775. 

  775. *               Handle \P and \p                 *
    776. 

  776. *************************************************/
    777. 

  777. 

  778. /* This function is called after \P or \p has been encountered, provided that
    779. 

  779. PCRE is compiled with support for Unicode properties. On entry, ptrptr is
    780. 

  780. pointing at the P or p. On exit, it is pointing at the final character of the
    781. 

  781. escape sequence.
    782. 

    783. 

  783. Argument:
    784. 

  784.   ptrptr         points to the pattern position pointer
    785. 

  785.   negptr         points to a boolean that is set TRUE for negation else FALSE
    786. 

  786.   dptr           points to an int that is set to the detailed property value
    787. 

  787.   errorcodeptr   points to the error code variable
    788. 

    789. 

  789. Returns:         type value from ucp_type_table, or -1 for an invalid type
    790. 

  790. */
    791. 

  791. 

  792. static int
    793. 

  793. get_ucp(const uschar **ptrptr, BOOL *negptr, int *dptr, int *errorcodeptr)
    794. 

  794. {
    795. 

  795. int c, i, bot, top;
    796. 

  796. const uschar *ptr = *ptrptr;
    797. 

  797. char name[32];
    798. 

  798. 

  799. c = *(++ptr);
    800. 

  800. if (c == 0) goto ERROR_RETURN;
    801. 

  801. 

  802. *negptr = FALSE;
    803. 

  803. 

  804. /* \P or \p can be followed by a name in {}, optionally preceded by ^ for
    805. 

  805. negation. */
    806. 

  806. 

  807. if (c == '{')
    808. 

  808.   {
    809. 

  809.   if (ptr[1] == '^')
    810. 

  810.     {
    811. 

  811.     *negptr = TRUE;
    812. 

  812.     ptr++;
    813. 

  813.     }
    814. 

  814.   for (i = 0; i < (int)sizeof(name) - 1; i++)
    815. 

  815.     {
    816. 

  816.     c = *(++ptr);
    817. 

  817.     if (c == 0) goto ERROR_RETURN;
    818. 

  818.     if (c == '}') break;
    819. 

  819.     name[i] = c;
    820. 

  820.     }
    821. 

  821.   if (c !='}') goto ERROR_RETURN;
    822. 

  822.   name[i] = 0;
    823. 

  823.   }
    824. 

  824. 

  825. /* Otherwise there is just one following character */
    826. 

  826. 

  827. else
    828. 

  828.   {
    829. 

  829.   name[0] = c;
    830. 

  830.   name[1] = 0;
    831. 

  831.   }
    832. 

  832. 

  833. *ptrptr = ptr;
    834. 

  834. 

  835. /* Search for a recognized property name using binary chop */
    836. 

  836. 

  837. bot = 0;
    838. 

  838. top = _pcre_utt_size;
    839. 

  839. 

  840. while (bot < top)
    841. 

  841.   {
    842. 

  842.   i = (bot + top) >> 1;
    843. 

  843.   c = strcmp(name, _pcre_utt_names + _pcre_utt[i].name_offset);
    844. 

  844.   if (c == 0)
    845. 

  845.     {
    846. 

  846.     *dptr = _pcre_utt[i].value;
    847. 

  847.     return _pcre_utt[i].type;
    848. 

  848.     }
    849. 

  849.   if (c > 0) bot = i + 1; else top = i;
    850. 

  850.   }
    851. 

  851. 

  852. *errorcodeptr = ERR47;
    853. 

  853. *ptrptr = ptr;
    854. 

  854. return -1;
    855. 

  855. 

  856. ERROR_RETURN:
    857. 

  857. *errorcodeptr = ERR46;
    858. 

  858. *ptrptr = ptr;
    859. 

  859. return -1;
    860. 

  860. }
    861. 

  861. #endif
    862. 

  862. 

  863. 

  864. 

  865. 

  866. /*************************************************
    867. 

  867. *            Check for counted repeat            *
    868. 

  868. *************************************************/
    869. 

  869. 

  870. /* This function is called when a '{' is encountered in a place where it might
    871. 

  871. start a quantifier. It looks ahead to see if it really is a quantifier or not.
    872. 

  872. It is only a quantifier if it is one of the forms {ddd} {ddd,} or {ddd,ddd}
    873. 

  873. where the ddds are digits.
    874. 

    875. 

  875. Arguments:
    876. 

  876.   p         pointer to the first char after '{'
    877. 

    878. 

  878. Returns:    TRUE or FALSE
    879. 

  879. */
    880. 

  880. 

  881. static BOOL
    882. 

  882. is_counted_repeat(const uschar *p)
    883. 

  883. {
    884. 

  884. if ((digitab[*p++] & ctype_digit) == 0) return FALSE;
    885. 

  885. while ((digitab[*p] & ctype_digit) != 0) p++;
    886. 

  886. if (*p == '}') return TRUE;
    887. 

  887. 

  888. if (*p++ != ',') return FALSE;
    889. 

  889. if (*p == '}') return TRUE;
    890. 

  890. 

  891. if ((digitab[*p++] & ctype_digit) == 0) return FALSE;
    892. 

  892. while ((digitab[*p] & ctype_digit) != 0) p++;
    893. 

  893. 

  894. return (*p == '}');
    895. 

  895. }
    896. 

  896. 

  897. 

  898. 

  899. /*************************************************
    900. 

  900. *         Read repeat counts                     *
    901. 

  901. *************************************************/
    902. 

  902. 

  903. /* Read an item of the form {n,m} and return the values. This is called only
    904. 

  904. after is_counted_repeat() has confirmed that a repeat-count quantifier exists,
    905. 

  905. so the syntax is guaranteed to be correct, but we need to check the values.
    906. 

    907. 

  907. Arguments:
    908. 

  908.   p              pointer to first char after '{'
    909. 

  909.   minp           pointer to int for min
    910. 

  910.   maxp           pointer to int for max
    911. 

  911.                  returned as -1 if no max
    912. 

  912.   errorcodeptr   points to error code variable
    913. 

    914. 

  914. Returns:         pointer to '}' on success;
    915. 

  915.                  current ptr on error, with errorcodeptr set non-zero
    916. 

  916. */
    917. 

  917. 

  918. static const uschar *
    919. 

  919. read_repeat_counts(const uschar *p, int *minp, int *maxp, int *errorcodeptr)
    920. 

  920. {
    921. 

  921. int min = 0;
    922. 

  922. int max = -1;
    923. 

  923. 

  924. /* Read the minimum value and do a paranoid check: a negative value indicates
    925. 

  925. an integer overflow. */
    926. 

  926. 

  927. while ((digitab[*p] & ctype_digit) != 0) min = min * 10 + *p++ - '0';
    928. 

  928. if (min < 0 || min > 65535)
    929. 

  929.   {
    930. 

  930.   *errorcodeptr = ERR5;
    931. 

  931.   return p;
    932. 

  932.   }
    933. 

  933. 

  934. /* Read the maximum value if there is one, and again do a paranoid on its size.
    935. 

  935. Also, max must not be less than min. */
    936. 

  936. 

  937. if (*p == '}') max = min; else
    938. 

  938.   {
    939. 

  939.   if (*(++p) != '}')
    940. 

  940.     {
    941. 

  941.     max = 0;
    942. 

  942.     while((digitab[*p] & ctype_digit) != 0) max = max * 10 + *p++ - '0';
    943. 

  943.     if (max < 0 || max > 65535)
    944. 

  944.       {
    945. 

  945.       *errorcodeptr = ERR5;
    946. 

  946.       return p;
    947. 

  947.       }
    948. 

  948.     if (max < min)
    949. 

  949.       {
    950. 

  950.       *errorcodeptr = ERR4;
    951. 

  951.       return p;
    952. 

  952.       }
    953. 

  953.     }
    954. 

  954.   }
    955. 

  955. 

  956. /* Fill in the required variables, and pass back the pointer to the terminating
    957. 

  957. '}'. */
    958. 

  958. 

  959. *minp = min;
    960. 

  960. *maxp = max;
    961. 

  961. return p;
    962. 

  962. }
    963. 

  963. 

  964. 

  965. 

  966. /*************************************************
    967. 

  967. *       Find forward referenced subpattern       *
    968. 

  968. *************************************************/
    969. 

  969. 

  970. /* This function scans along a pattern's text looking for capturing
    971. 

  971. subpatterns, and counting them. If it finds a named pattern that matches the
    972. 

  972. name it is given, it returns its number. Alternatively, if the name is NULL, it
    973. 

  973. returns when it reaches a given numbered subpattern. This is used for forward
    974. 

  974. references to subpatterns. We know that if (?P< is encountered, the name will
    975. 

  975. be terminated by '>' because that is checked in the first pass.
    976. 

    977. 

  977. Arguments:
    978. 

  978.   ptr          current position in the pattern
    979. 

  979.   cd           compile background data
    980. 

  980.   name         name to seek, or NULL if seeking a numbered subpattern
    981. 

  981.   lorn         name length, or subpattern number if name is NULL
    982. 

  982.   xmode        TRUE if we are in /x mode
    983. 

    984. 

  984. Returns:       the number of the named subpattern, or -1 if not found
    985. 

  985. */
    986. 

  986. 

  987. static int
    988. 

  988. find_parens(const uschar *ptr, compile_data *cd, const uschar *name, int lorn,
    989. 

  989.   BOOL xmode)
    990. 

  990. {
    991. 

  991. const uschar *thisname;
    992. 

  992. int count = cd->bracount;
    993. 

  993. 

  994. for (; *ptr != 0; ptr++)
    995. 

  995.   {
    996. 

  996.   int term;
    997. 

  997. 

  998.   /* Skip over backslashed characters and also entire \Q...\E */
    999. 

  999. 

  1000.   if (*ptr == '\\')
    1001. 

  1001.     {
    1002. 

  1002.     if (*(++ptr) == 0) return -1;
    1003. 

  1003.     if (*ptr == 'Q') for (;;)
    1004. 

  1004.       {
    1005. 

  1005.       while (*(++ptr) != 0 && *ptr != '\\') {};
    1006. 

  1006.       if (*ptr == 0) return -1;
    1007. 

  1007.       if (*(++ptr) == 'E') break;
    1008. 

  1008.       }
    1009. 

  1009.     continue;
    1010. 

  1010.     }
    1011. 

  1011. 

  1012.   /* Skip over character classes; this logic must be similar to the way they
    1013. 

  1013.   are handled for real. If the first character is '^', skip it. Also, if the
    1014. 

  1014.   first few characters (either before or after ^) are \Q\E or \E we skip them
    1015. 

  1015.   too. This makes for compatibility with Perl. */
    1016. 

  1016. 

  1017.   if (*ptr == '[')
    1018. 

  1018.     {
    1019. 

  1019.     BOOL negate_class = FALSE;
    1020. 

  1020.     for (;;)
    1021. 

  1021.       {
    1022. 

  1022.       int c = *(++ptr);
    1023. 

  1023.       if (c == '\\')
    1024. 

  1024.         {
    1025. 

  1025.         if (ptr[1] == 'E') ptr++;
    1026. 

  1026.           else if (strncmp((const char *)ptr+1, "Q\\E", 3) == 0) ptr += 3;
    1027. 

  1027.             else break;
    1028. 

  1028.         }
    1029. 

  1029.       else if (!negate_class && c == '^')
    1030. 

  1030.         negate_class = TRUE;
    1031. 

  1031.       else break;
    1032. 

  1032.       }
    1033. 

  1033. 

  1034.     /* If the next character is ']', it is a data character that must be
    1035. 

  1035.     skipped, except in JavaScript compatibility mode. */
    1036. 

  1036. 

  1037.     if (ptr[1] == ']' && (cd->external_options & PCRE_JAVASCRIPT_COMPAT) == 0)
    1038. 

  1038.       ptr++;
    1039. 

  1039. 

  1040.     while (*(++ptr) != ']')
    1041. 

  1041.       {
    1042. 

  1042.       if (*ptr == 0) return -1;
    1043. 

  1043.       if (*ptr == '\\')
    1044. 

  1044.         {
    1045. 

  1045.         if (*(++ptr) == 0) return -1;
    1046. 

  1046.         if (*ptr == 'Q') for (;;)
    1047. 

  1047.           {
    1048. 

  1048.           while (*(++ptr) != 0 && *ptr != '\\') {};
    1049. 

  1049.           if (*ptr == 0) return -1;
    1050. 

  1050.           if (*(++ptr) == 'E') break;
    1051. 

  1051.           }
    1052. 

  1052.         continue;
    1053. 

  1053.         }
    1054. 

  1054.       }
    1055. 

  1055.     continue;
    1056. 

  1056.     }
    1057. 

  1057. 

  1058.   /* Skip comments in /x mode */
    1059. 

  1059. 

  1060.   if (xmode && *ptr == '#')
    1061. 

  1061.     {
    1062. 

  1062.     while (*(++ptr) != 0 && *ptr != '\n') {};
    1063. 

  1063.     if (*ptr == 0) return -1;
    1064. 

  1064.     continue;
    1065. 

  1065.     }
    1066. 

  1066. 

  1067.   /* An opening parens must now be a real metacharacter */
    1068. 

  1068. 

  1069.   if (*ptr != '(') continue;
    1070. 

  1070.   if (ptr[1] != '?' && ptr[1] != '*')
    1071. 

  1071.     {
    1072. 

  1072.     count++;
    1073. 

  1073.     if (name == NULL && count == lorn) return count;
    1074. 

  1074.     continue;
    1075. 

  1075.     }
    1076. 

  1076. 

  1077.   ptr += 2;
    1078. 

  1078.   if (*ptr == 'P') ptr++;                      /* Allow optional P */
    1079. 

  1079. 

  1080.   /* We have to disambiguate (?<! and (?<= from (?<name> */
    1081. 

  1081. 

  1082.   if ((*ptr != '<' || ptr[1] == '!' || ptr[1] == '=') &&
    1083. 

  1083.        *ptr != '\'')
    1084. 

  1084.     continue;
    1085. 

  1085. 

  1086.   count++;
    1087. 

  1087. 

  1088.   if (name == NULL && count == lorn) return count;
    1089. 

  1089.   term = *ptr++;
    1090. 

  1090.   if (term == '<') term = '>';
    1091. 

  1091.   thisname = ptr;
    1092. 

  1092.   while (*ptr != term) ptr++;
    1093. 

  1093.   if (name != NULL && lorn == ptr - thisname &&
    1094. 

  1094.       strncmp((const char *)name, (const char *)thisname, lorn) == 0)
    1095. 

  1095.     return count;
    1096. 

  1096.   }
    1097. 

  1097. 

  1098. return -1;
    1099. 

  1099. }
    1100. 

  1100. 

  1101. 

  1102. 

  1103. /*************************************************
    1104. 

  1104. *      Find first significant op code            *
    1105. 

  1105. *************************************************/
    1106. 

  1106. 

  1107. /* This is called by several functions that scan a compiled expression looking
    1108. 

  1108. for a fixed first character, or an anchoring op code etc. It skips over things
    1109. 

  1109. that do not influence this. For some calls, a change of option is important.
    1110. 

  1110. For some calls, it makes sense to skip negative forward and all backward
    1111. 

  1111. assertions, and also the \b assertion; for others it does not.
    1112. 

    1113. 

  1113. Arguments:
    1114. 

  1114.   code         pointer to the start of the group
    1115. 

  1115.   options      pointer to external options
    1116. 

  1116.   optbit       the option bit whose changing is significant, or
    1117. 

  1117.                  zero if none are
    1118. 

  1118.   skipassert   TRUE if certain assertions are to be skipped
    1119. 

    1120. 

  1120. Returns:       pointer to the first significant opcode
    1121. 

  1121. */
    1122. 

  1122. 

  1123. static const uschar*
    1124. 

  1124. first_significant_code(const uschar *code, int *options, int optbit,
    1125. 

  1125.   BOOL skipassert)
    1126. 

  1126. {
    1127. 

  1127. for (;;)
    1128. 

  1128.   {
    1129. 

  1129.   switch ((int)*code)
    1130. 

  1130.     {
    1131. 

  1131.     case OP_OPT:
    1132. 

  1132.     if (optbit > 0 && ((int)code[1] & optbit) != (*options & optbit))
    1133. 

  1133.       *options = (int)code[1];
    1134. 

  1134.     code += 2;
    1135. 

  1135.     break;
    1136. 

  1136. 

  1137.     case OP_ASSERT_NOT:
    1138. 

  1138.     case OP_ASSERTBACK:
    1139. 

  1139.     case OP_ASSERTBACK_NOT:
    1140. 

  1140.     if (!skipassert) return code;
    1141. 

  1141.     do code += GET(code, 1); while (*code == OP_ALT);
    1142. 

  1142.     code += _pcre_OP_lengths[*code];
    1143. 

  1143.     break;
    1144. 

  1144. 

  1145.     case OP_WORD_BOUNDARY:
    1146. 

  1146.     case OP_NOT_WORD_BOUNDARY:
    1147. 

  1147.     if (!skipassert) return code;
    1148. 

  1148.     /* Fall through */
    1149. 

  1149. 

  1150.     case OP_CALLOUT:
    1151. 

  1151.     case OP_CREF:
    1152. 

  1152.     case OP_RREF:
    1153. 

  1153.     case OP_DEF:
    1154. 

  1154.     code += _pcre_OP_lengths[*code];
    1155. 

  1155.     break;
    1156. 

  1156. 

  1157.     default:
    1158. 

  1158.     return code;
    1159. 

  1159.     }
    1160. 

  1160.   }
    1161. 

  1161. /* Control never reaches here */
    1162. 

  1162. }
    1163. 

  1163. 

  1164. 

  1165. 

  1166. 

  1167. /*************************************************
    1168. 

  1168. *        Find the fixed length of a pattern      *
    1169. 

  1169. *************************************************/
    1170. 

  1170. 

  1171. /* Scan a pattern and compute the fixed length of subject that will match it,
    1172. 

  1172. if the length is fixed. This is needed for dealing with backward assertions.
    1173. 

  1173. In UTF8 mode, the result is in characters rather than bytes.
    1174. 

    1175. 

  1175. Arguments:
    1176. 

  1176.   code     points to the start of the pattern (the bracket)
    1177. 

  1177.   options  the compiling options
    1178. 

    1179. 

  1179. Returns:   the fixed length, or -1 if there is no fixed length,
    1180. 

  1180.              or -2 if \C was encountered
    1181. 

  1181. */
    1182. 

  1182. 

  1183. static int
    1184. 

  1184. find_fixedlength(uschar *code, int options)
    1185. 

  1185. {
    1186. 

  1186. int length = -1;
    1187. 

  1187. 

  1188. register int branchlength = 0;
    1189. 

  1189. register uschar *cc = code + 1 + LINK_SIZE;
    1190. 

  1190. 

  1191. /* Scan along the opcodes for this branch. If we get to the end of the
    1192. 

  1192. branch, check the length against that of the other branches. */
    1193. 

  1193. 

  1194. for (;;)
    1195. 

  1195.   {
    1196. 

  1196.   int d;
    1197. 

  1197.   register int op = *cc;
    1198. 

  1198.   switch (op)
    1199. 

  1199.     {
    1200. 

  1200.     case OP_CBRA:
    1201. 

  1201.     case OP_BRA:
    1202. 

  1202.     case OP_ONCE:
    1203. 

  1203.     case OP_COND:
    1204. 

  1204.     d = find_fixedlength(cc + ((op == OP_CBRA)? 2:0), options);
    1205. 

  1205.     if (d < 0) return d;
    1206. 

  1206.     branchlength += d;
    1207. 

  1207.     do cc += GET(cc, 1); while (*cc == OP_ALT);
    1208. 

  1208.     cc += 1 + LINK_SIZE;
    1209. 

  1209.     break;
    1210. 

  1210. 

  1211.     /* Reached end of a branch; if it's a ket it is the end of a nested
    1212. 

  1212.     call. If it's ALT it is an alternation in a nested call. If it is
    1213. 

  1213.     END it's the end of the outer call. All can be handled by the same code. */
    1214. 

  1214. 

  1215.     case OP_ALT:
    1216. 

  1216.     case OP_KET:
    1217. 

  1217.     case OP_KETRMAX:
    1218. 

  1218.     case OP_KETRMIN:
    1219. 

  1219.     case OP_END:
    1220. 

  1220.     if (length < 0) length = branchlength;
    1221. 

  1221.       else if (length != branchlength) return -1;
    1222. 

  1222.     if (*cc != OP_ALT) return length;
    1223. 

  1223.     cc += 1 + LINK_SIZE;
    1224. 

  1224.     branchlength = 0;
    1225. 

  1225.     break;
    1226. 

  1226. 

  1227.     /* Skip over assertive subpatterns */
    1228. 

  1228. 

  1229.     case OP_ASSERT:
    1230. 

  1230.     case OP_ASSERT_NOT:
    1231. 

  1231.     case OP_ASSERTBACK:
    1232. 

  1232.     case OP_ASSERTBACK_NOT:
    1233. 

  1233.     do cc += GET(cc, 1); while (*cc == OP_ALT);
    1234. 

  1234.     /* Fall through */
    1235. 

  1235. 

  1236.     /* Skip over things that don't match chars */
    1237. 

  1237. 

  1238.     case OP_REVERSE:
    1239. 

  1239.     case OP_CREF:
    1240. 

  1240.     case OP_RREF:
    1241. 

  1241.     case OP_DEF:
    1242. 

  1242.     case OP_OPT:
    1243. 

  1243.     case OP_CALLOUT:
    1244. 

  1244.     case OP_SOD:
    1245. 

  1245.     case OP_SOM:
    1246. 

  1246.     case OP_EOD:
    1247. 

  1247.     case OP_EODN:
    1248. 

  1248.     case OP_CIRC:
    1249. 

  1249.     case OP_DOLL:
    1250. 

  1250.     case OP_NOT_WORD_BOUNDARY:
    1251. 

  1251.     case OP_WORD_BOUNDARY:
    1252. 

  1252.     cc += _pcre_OP_lengths[*cc];
    1253. 

  1253.     break;
    1254. 

  1254. 

  1255.     /* Handle literal characters */
    1256. 

  1256. 

  1257.     case OP_CHAR:
    1258. 

  1258.     case OP_CHARNC:
    1259. 

  1259.     case OP_NOT:
    1260. 

  1260.     branchlength++;
    1261. 

  1261.     cc += 2;
    1262. 

  1262. #ifdef SUPPORT_UTF8
    1263. 

  1263.     if ((options & PCRE_UTF8) != 0)
    1264. 

  1264.       {
    1265. 

  1265.       while ((*cc & 0xc0) == 0x80) cc++;
    1266. 

  1266.       }
    1267. 

  1267. #endif
    1268. 

  1268.     break;
    1269. 

  1269. 

  1270.     /* Handle exact repetitions. The count is already in characters, but we
    1271. 

  1271.     need to skip over a multibyte character in UTF8 mode.  */
    1272. 

  1272. 

  1273.     case OP_EXACT:
    1274. 

  1274.     branchlength += GET2(cc,1);
    1275. 

  1275.     cc += 4;
    1276. 

  1276. #ifdef SUPPORT_UTF8
    1277. 

  1277.     if ((options & PCRE_UTF8) != 0)
    1278. 

  1278.       {
    1279. 

  1279.       while((*cc & 0x80) == 0x80) cc++;
    1280. 

  1280.       }
    1281. 

  1281. #endif
    1282. 

  1282.     break;
    1283. 

  1283. 

  1284.     case OP_TYPEEXACT:
    1285. 

  1285.     branchlength += GET2(cc,1);
    1286. 

  1286.     if (cc[3] == OP_PROP || cc[3] == OP_NOTPROP) cc += 2;
    1287. 

  1287.     cc += 4;
    1288. 

  1288.     break;
    1289. 

  1289. 

  1290.     /* Handle single-char matchers */
    1291. 

  1291. 

  1292.     case OP_PROP:
    1293. 

  1293.     case OP_NOTPROP:
    1294. 

  1294.     cc += 2;
    1295. 

  1295.     /* Fall through */
    1296. 

  1296. 

  1297.     case OP_NOT_DIGIT:
    1298. 

  1298.     case OP_DIGIT:
    1299. 

  1299.     case OP_NOT_WHITESPACE:
    1300. 

  1300.     case OP_WHITESPACE:
    1301. 

  1301.     case OP_NOT_WORDCHAR:
    1302. 

  1302.     case OP_WORDCHAR:
    1303. 

  1303.     case OP_ANY:
    1304. 

  1304.     case OP_ALLANY:
    1305. 

  1305.     branchlength++;
    1306. 

  1306.     cc++;
    1307. 

  1307.     break;
    1308. 

  1308. 

  1309.     /* The single-byte matcher isn't allowed */
    1310. 

  1310. 

  1311.     case OP_ANYBYTE:
    1312. 

  1312.     return -2;
    1313. 

  1313. 

  1314.     /* Check a class for variable quantification */
    1315. 

  1315. 

  1316. #ifdef SUPPORT_UTF8
    1317. 

  1317.     case OP_XCLASS:
    1318. 

  1318.     cc += GET(cc, 1) - 33;
    1319. 

  1319.     /* Fall through */
    1320. 

  1320. #endif
    1321. 

  1321. 

  1322.     case OP_CLASS:
    1323. 

  1323.     case OP_NCLASS:
    1324. 

  1324.     cc += 33;
    1325. 

  1325. 

  1326.     switch (*cc)
    1327. 

  1327.       {
    1328. 

  1328.       case OP_CRSTAR:
    1329. 

  1329.       case OP_CRMINSTAR:
    1330. 

  1330.       case OP_CRQUERY:
    1331. 

  1331.       case OP_CRMINQUERY:
    1332. 

  1332.       return -1;
    1333. 

  1333. 

  1334.       case OP_CRRANGE:
    1335. 

  1335.       case OP_CRMINRANGE:
    1336. 

  1336.       if (GET2(cc,1) != GET2(cc,3)) return -1;
    1337. 

  1337.       branchlength += GET2(cc,1);
    1338. 

  1338.       cc += 5;
    1339. 

  1339.       break;
    1340. 

  1340. 

  1341.       default:
    1342. 

  1342.       branchlength++;
    1343. 

  1343.       }
    1344. 

  1344.     break;
    1345. 

  1345. 

  1346.     /* Anything else is variable length */
    1347. 

  1347. 

  1348.     default:
    1349. 

  1349.     return -1;
    1350. 

  1350.     }
    1351. 

  1351.   }
    1352. 

  1352. /* Control never gets here */
    1353. 

  1353. }
    1354. 

  1354. 

  1355. 

  1356. 

  1357. 

  1358. /*************************************************
    1359. 

  1359. *    Scan compiled regex for numbered bracket    *
    1360. 

  1360. *************************************************/
    1361. 

  1361. 

  1362. /* This little function scans through a compiled pattern until it finds a
    1363. 

  1363. capturing bracket with the given number.
    1364. 

    1365. 

  1365. Arguments:
    1366. 

  1366.   code        points to start of expression
    1367. 

  1367.   utf8        TRUE in UTF-8 mode
    1368. 

  1368.   number      the required bracket number
    1369. 

    1370. 

  1370. Returns:      pointer to the opcode for the bracket, or NULL if not found
    1371. 

  1371. */
    1372. 

  1372. 

  1373. static const uschar *
    1374. 

  1374. find_bracket(const uschar *code, BOOL utf8, int number)
    1375. 

  1375. {
    1376. 

  1376. for (;;)
    1377. 

  1377.   {
    1378. 

  1378.   register int c = *code;
    1379. 

  1379.   if (c == OP_END) return NULL;
    1380. 

  1380. 

  1381.   /* XCLASS is used for classes that cannot be represented just by a bit
    1382. 

  1382.   map. This includes negated single high-valued characters. The length in
    1383. 

  1383.   the table is zero; the actual length is stored in the compiled code. */
    1384. 

  1384. 

  1385.   if (c == OP_XCLASS) code += GET(code, 1);
    1386. 

  1386. 

  1387.   /* Handle capturing bracket */
    1388. 

  1388. 

  1389.   else if (c == OP_CBRA)
    1390. 

  1390.     {
    1391. 

  1391.     int n = GET2(code, 1+LINK_SIZE);
    1392. 

  1392.     if (n == number) return (uschar *)code;
    1393. 

  1393.     code += _pcre_OP_lengths[c];
    1394. 

  1394.     }
    1395. 

  1395. 

  1396.   /* Otherwise, we can get the item's length from the table, except that for
    1397. 

  1397.   repeated character types, we have to test for \p and \P, which have an extra
    1398. 

  1398.   two bytes of parameters. */
    1399. 

  1399. 

  1400.   else
    1401. 

  1401.     {
    1402. 

  1402.     switch(c)
    1403. 

  1403.       {
    1404. 

  1404.       case OP_TYPESTAR:
    1405. 

  1405.       case OP_TYPEMINSTAR:
    1406. 

  1406.       case OP_TYPEPLUS:
    1407. 

  1407.       case OP_TYPEMINPLUS:
    1408. 

  1408.       case OP_TYPEQUERY:
    1409. 

  1409.       case OP_TYPEMINQUERY:
    1410. 

  1410.       case OP_TYPEPOSSTAR:
    1411. 

  1411.       case OP_TYPEPOSPLUS:
    1412. 

  1412.       case OP_TYPEPOSQUERY:
    1413. 

  1413.       if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;
    1414. 

  1414.       break;
    1415. 

  1415. 

  1416.       case OP_TYPEUPTO:
    1417. 

  1417.       case OP_TYPEMINUPTO:
    1418. 

  1418.       case OP_TYPEEXACT:
    1419. 

  1419.       case OP_TYPEPOSUPTO:
    1420. 

  1420.       if (code[3] == OP_PROP || code[3] == OP_NOTPROP) code += 2;
    1421. 

  1421.       break;
    1422. 

  1422.       }
    1423. 

  1423. 

  1424.     /* Add in the fixed length from the table */
    1425. 

  1425. 

  1426.     code += _pcre_OP_lengths[c];
    1427. 

  1427. 

  1428.   /* In UTF-8 mode, opcodes that are followed by a character may be followed by
    1429. 

  1429.   a multi-byte character. The length in the table is a minimum, so we have to
    1430. 

  1430.   arrange to skip the extra bytes. */
    1431. 

  1431. 

  1432. #ifdef SUPPORT_UTF8
    1433. 

  1433.     if (utf8) switch(c)
    1434. 

  1434.       {
    1435. 

  1435.       case OP_CHAR:
    1436. 

  1436.       case OP_CHARNC:
    1437. 

  1437.       case OP_EXACT:
    1438. 

  1438.       case OP_UPTO:
    1439. 

  1439.       case OP_MINUPTO:
    1440. 

  1440.       case OP_POSUPTO:
    1441. 

  1441.       case OP_STAR:
    1442. 

  1442.       case OP_MINSTAR:
    1443. 

  1443.       case OP_POSSTAR:
    1444. 

  1444.       case OP_PLUS:
    1445. 

  1445.       case OP_MINPLUS:
    1446. 

  1446.       case OP_POSPLUS:
    1447. 

  1447.       case OP_QUERY:
    1448. 

  1448.       case OP_MINQUERY:
    1449. 

  1449.       case OP_POSQUERY:
    1450. 

  1450.       if (code[-1] >= 0xc0) code += _pcre_utf8_table4[code[-1] & 0x3f];
    1451. 

  1451.       break;
    1452. 

  1452.       }
    1453. 

  1453. #else
    1454. 

  1454.     /* pacify warnings */
    1455. 

  1455.     (void)(utf8);
    1456. 

  1456. #endif
    1457. 

  1457.     }
    1458. 

  1458.   }
    1459. 

  1459. }
    1460. 

  1460. 

  1461. 

  1462. 

  1463. /*************************************************
    1464. 

  1464. *   Scan compiled regex for recursion reference  *
    1465. 

  1465. *************************************************/
    1466. 

  1466. 

  1467. /* This little function scans through a compiled pattern until it finds an
    1468. 

  1468. instance of OP_RECURSE.
    1469. 

    1470. 

  1470. Arguments:
    1471. 

  1471.   code        points to start of expression
    1472. 

  1472.   utf8        TRUE in UTF-8 mode
    1473. 

    1474. 

  1474. Returns:      pointer to the opcode for OP_RECURSE, or NULL if not found
    1475. 

  1475. */
    1476. 

  1476. 

  1477. static const uschar *
    1478. 

  1478. find_recurse(const uschar *code, BOOL utf8)
    1479. 

  1479. {
    1480. 

  1480. for (;;)
    1481. 

  1481.   {
    1482. 

  1482.   register int c = *code;
    1483. 

  1483.   if (c == OP_END) return NULL;
    1484. 

  1484.   if (c == OP_RECURSE) return code;
    1485. 

  1485. 

  1486.   /* XCLASS is used for classes that cannot be represented just by a bit
    1487. 

  1487.   map. This includes negated single high-valued characters. The length in
    1488. 

  1488.   the table is zero; the actual length is stored in the compiled code. */
    1489. 

  1489. 

  1490.   if (c == OP_XCLASS) code += GET(code, 1);
    1491. 

  1491. 

  1492.   /* Otherwise, we can get the item's length from the table, except that for
    1493. 

  1493.   repeated character types, we have to test for \p and \P, which have an extra
    1494. 

  1494.   two bytes of parameters. */
    1495. 

  1495. 

  1496.   else
    1497. 

  1497.     {
    1498. 

  1498.     switch(c)
    1499. 

  1499.       {
    1500. 

  1500.       case OP_TYPESTAR:
    1501. 

  1501.       case OP_TYPEMINSTAR:
    1502. 

  1502.       case OP_TYPEPLUS:
    1503. 

  1503.       case OP_TYPEMINPLUS:
    1504. 

  1504.       case OP_TYPEQUERY:
    1505. 

  1505.       case OP_TYPEMINQUERY:
    1506. 

  1506.       case OP_TYPEPOSSTAR:
    1507. 

  1507.       case OP_TYPEPOSPLUS:
    1508. 

  1508.       case OP_TYPEPOSQUERY:
    1509. 

  1509.       if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;
    1510. 

  1510.       break;
    1511. 

  1511. 

  1512.       case OP_TYPEPOSUPTO:
    1513. 

  1513.       case OP_TYPEUPTO:
    1514. 

  1514.       case OP_TYPEMINUPTO:
    1515. 

  1515.       case OP_TYPEEXACT:
    1516. 

  1516.       if (code[3] == OP_PROP || code[3] == OP_NOTPROP) code += 2;
    1517. 

  1517.       break;
    1518. 

  1518.       }
    1519. 

  1519. 

  1520.     /* Add in the fixed length from the table */
    1521. 

  1521. 

  1522.     code += _pcre_OP_lengths[c];
    1523. 

  1523. 

  1524.     /* In UTF-8 mode, opcodes that are followed by a character may be followed
    1525. 

  1525.     by a multi-byte character. The length in the table is a minimum, so we have
    1526. 

  1526.     to arrange to skip the extra bytes. */
    1527. 

  1527. 

  1528. #ifdef SUPPORT_UTF8
    1529. 

  1529.     if (utf8) switch(c)
    1530. 

  1530.       {
    1531. 

  1531.       case OP_CHAR:
    1532. 

  1532.       case OP_CHARNC:
    1533. 

  1533.       case OP_EXACT:
    1534. 

  1534.       case OP_UPTO:
    1535. 

  1535.       case OP_MINUPTO:
    1536. 

  1536.       case OP_POSUPTO:
    1537. 

  1537.       case OP_STAR:
    1538. 

  1538.       case OP_MINSTAR:
    1539. 

  1539.       case OP_POSSTAR:
    1540. 

  1540.       case OP_PLUS:
    1541. 

  1541.       case OP_MINPLUS:
    1542. 

  1542.       case OP_POSPLUS:
    1543. 

  1543.       case OP_QUERY:
    1544. 

  1544.       case OP_MINQUERY:
    1545. 

  1545.       case OP_POSQUERY:
    1546. 

  1546.       if (code[-1] >= 0xc0) code += _pcre_utf8_table4[code[-1] & 0x3f];
    1547. 

  1547.       break;
    1548. 

  1548.       }
    1549. 

  1549. #else
    1550. 

  1550.     /* pacify warnings */
    1551. 

  1551.     (void)(utf8);
    1552. 

  1552. #endif
    1553. 

  1553.     }
    1554. 

  1554.   }
    1555. 

  1555. }
    1556. 

  1556. 

  1557. 

  1558. 

  1559. /*************************************************
    1560. 

  1560. *    Scan compiled branch for non-emptiness      *
    1561. 

  1561. *************************************************/
    1562. 

  1562. 

  1563. /* This function scans through a branch of a compiled pattern to see whether it
    1564. 

  1564. can match the empty string or not. It is called from could_be_empty()
    1565. 

  1565. below and from compile_branch() when checking for an unlimited repeat of a
    1566. 

  1566. group that can match nothing. Note that first_significant_code() skips over
    1567. 

  1567. backward and negative forward assertions when its final argument is TRUE. If we
    1568. 

  1568. hit an unclosed bracket, we return "empty" - this means we've struck an inner
    1569. 

  1569. bracket whose current branch will already have been scanned.
    1570. 

    1571. 

  1571. Arguments:
    1572. 

  1572.   code        points to start of search
    1573. 

  1573.   endcode     points to where to stop
    1574. 

  1574.   utf8        TRUE if in UTF8 mode
    1575. 

    1576. 

  1576. Returns:      TRUE if what is matched could be empty
    1577. 

  1577. */
    1578. 

  1578. 

  1579. static BOOL
    1580. 

  1580. could_be_empty_branch(const…
    1581.

Large files files are truncated, but you can click here to view the full file