chiark / gitweb /
Patch from Graham Inggs to add symbols support (Closes: #767374)
[pcre3.git] / pcre_byte_order.c
1 /*************************************************
2 *      Perl-Compatible Regular Expressions       *
3 *************************************************/
4
5 /* PCRE is a library of functions to support regular expressions whose syntax
6 and semantics are as close as possible to those of the Perl 5 language.
7
8                        Written by Philip Hazel
9            Copyright (c) 1997-2014 University of Cambridge
10
11 -----------------------------------------------------------------------------
12 Redistribution and use in source and binary forms, with or without
13 modification, are permitted provided that the following conditions are met:
14
15     * Redistributions of source code must retain the above copyright notice,
16       this list of conditions and the following disclaimer.
17
18     * Redistributions in binary form must reproduce the above copyright
19       notice, this list of conditions and the following disclaimer in the
20       documentation and/or other materials provided with the distribution.
21
22     * Neither the name of the University of Cambridge nor the names of its
23       contributors may be used to endorse or promote products derived from
24       this software without specific prior written permission.
25
26 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
27 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
30 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
31 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
32 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
33 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
34 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36 POSSIBILITY OF SUCH DAMAGE.
37 -----------------------------------------------------------------------------
38 */
39
40
41 /* This module contains an internal function that tests a compiled pattern to
42 see if it was compiled with the opposite endianness. If so, it uses an
43 auxiliary local function to flip the appropriate bytes. */
44
45
46 #ifdef HAVE_CONFIG_H
47 #include "config.h"
48 #endif
49
50 #include "pcre_internal.h"
51
52
53 /*************************************************
54 *             Swap byte functions                *
55 *************************************************/
56
57 /* The following functions swap the bytes of a pcre_uint16
58 and pcre_uint32 value.
59
60 Arguments:
61   value        any number
62
63 Returns:       the byte swapped value
64 */
65
66 static pcre_uint32
67 swap_uint32(pcre_uint32 value)
68 {
69 return ((value & 0x000000ff) << 24) |
70        ((value & 0x0000ff00) <<  8) |
71        ((value & 0x00ff0000) >>  8) |
72        (value >> 24);
73 }
74
75 static pcre_uint16
76 swap_uint16(pcre_uint16 value)
77 {
78 return (value >> 8) | (value << 8);
79 }
80
81
82 /*************************************************
83 *       Test for a byte-flipped compiled regex   *
84 *************************************************/
85
86 /* This function swaps the bytes of a compiled pattern usually
87 loaded form the disk. It also sets the tables pointer, which
88 is likely an invalid pointer after reload.
89
90 Arguments:
91   argument_re     points to the compiled expression
92   extra_data      points to extra data or is NULL
93   tables          points to the character tables or NULL
94
95 Returns:          0 if the swap is successful, negative on error
96 */
97
98 #if defined COMPILE_PCRE8
99 PCRE_EXP_DECL int pcre_pattern_to_host_byte_order(pcre *argument_re,
100   pcre_extra *extra_data, const unsigned char *tables)
101 #elif defined COMPILE_PCRE16
102 PCRE_EXP_DECL int pcre16_pattern_to_host_byte_order(pcre16 *argument_re,
103   pcre16_extra *extra_data, const unsigned char *tables)
104 #elif defined COMPILE_PCRE32
105 PCRE_EXP_DECL int pcre32_pattern_to_host_byte_order(pcre32 *argument_re,
106   pcre32_extra *extra_data, const unsigned char *tables)
107 #endif
108 {
109 REAL_PCRE *re = (REAL_PCRE *)argument_re;
110 pcre_study_data *study;
111 #ifndef COMPILE_PCRE8
112 pcre_uchar *ptr;
113 int length;
114 #if defined SUPPORT_UTF && defined COMPILE_PCRE16
115 BOOL utf;
116 BOOL utf16_char;
117 #endif /* SUPPORT_UTF && COMPILE_PCRE16 */
118 #endif /* !COMPILE_PCRE8 */
119
120 if (re == NULL) return PCRE_ERROR_NULL;
121 if (re->magic_number == MAGIC_NUMBER)
122   {
123   if ((re->flags & PCRE_MODE) == 0) return PCRE_ERROR_BADMODE;
124   re->tables = tables;
125   return 0;
126   }
127
128 if (re->magic_number != REVERSED_MAGIC_NUMBER) return PCRE_ERROR_BADMAGIC;
129 if ((swap_uint32(re->flags) & PCRE_MODE) == 0) return PCRE_ERROR_BADMODE;
130
131 re->magic_number = MAGIC_NUMBER;
132 re->size = swap_uint32(re->size);
133 re->options = swap_uint32(re->options);
134 re->flags = swap_uint32(re->flags);
135 re->limit_match = swap_uint32(re->limit_match);
136 re->limit_recursion = swap_uint32(re->limit_recursion);
137
138 #if defined COMPILE_PCRE8 || defined COMPILE_PCRE16
139 re->first_char = swap_uint16(re->first_char);
140 re->req_char = swap_uint16(re->req_char);
141 #elif defined COMPILE_PCRE32
142 re->first_char = swap_uint32(re->first_char);
143 re->req_char = swap_uint32(re->req_char);
144 #endif
145
146 re->max_lookbehind = swap_uint16(re->max_lookbehind);
147 re->top_bracket = swap_uint16(re->top_bracket);
148 re->top_backref = swap_uint16(re->top_backref);
149 re->name_table_offset = swap_uint16(re->name_table_offset);
150 re->name_entry_size = swap_uint16(re->name_entry_size);
151 re->name_count = swap_uint16(re->name_count);
152 re->ref_count = swap_uint16(re->ref_count);
153 re->tables = tables;
154
155 if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_STUDY_DATA) != 0)
156   {
157   study = (pcre_study_data *)extra_data->study_data;
158   study->size = swap_uint32(study->size);
159   study->flags = swap_uint32(study->flags);
160   study->minlength = swap_uint32(study->minlength);
161   }
162
163 #ifndef COMPILE_PCRE8
164 ptr = (pcre_uchar *)re + re->name_table_offset;
165 length = re->name_count * re->name_entry_size;
166 #if defined SUPPORT_UTF && defined COMPILE_PCRE16
167 utf = (re->options & PCRE_UTF16) != 0;
168 utf16_char = FALSE;
169 #endif /* SUPPORT_UTF && COMPILE_PCRE16 */
170
171 while(TRUE)
172   {
173   /* Swap previous characters. */
174   while (length-- > 0)
175     {
176 #if defined COMPILE_PCRE16
177     *ptr = swap_uint16(*ptr);
178 #elif defined COMPILE_PCRE32
179     *ptr = swap_uint32(*ptr);
180 #endif
181     ptr++;
182     }
183 #if defined SUPPORT_UTF && defined COMPILE_PCRE16
184   if (utf16_char)
185     {
186     if (HAS_EXTRALEN(ptr[-1]))
187       {
188       /* We know that there is only one extra character in UTF-16. */
189       *ptr = swap_uint16(*ptr);
190       ptr++;
191       }
192     }
193   utf16_char = FALSE;
194 #endif /* SUPPORT_UTF */
195
196   /* Get next opcode. */
197   length = 0;
198 #if defined COMPILE_PCRE16
199   *ptr = swap_uint16(*ptr);
200 #elif defined COMPILE_PCRE32
201   *ptr = swap_uint32(*ptr);
202 #endif
203   switch (*ptr)
204     {
205     case OP_END:
206     return 0;
207
208 #if defined SUPPORT_UTF && defined COMPILE_PCRE16
209     case OP_CHAR:
210     case OP_CHARI:
211     case OP_NOT:
212     case OP_NOTI:
213     case OP_STAR:
214     case OP_MINSTAR:
215     case OP_PLUS:
216     case OP_MINPLUS:
217     case OP_QUERY:
218     case OP_MINQUERY:
219     case OP_UPTO:
220     case OP_MINUPTO:
221     case OP_EXACT:
222     case OP_POSSTAR:
223     case OP_POSPLUS:
224     case OP_POSQUERY:
225     case OP_POSUPTO:
226     case OP_STARI:
227     case OP_MINSTARI:
228     case OP_PLUSI:
229     case OP_MINPLUSI:
230     case OP_QUERYI:
231     case OP_MINQUERYI:
232     case OP_UPTOI:
233     case OP_MINUPTOI:
234     case OP_EXACTI:
235     case OP_POSSTARI:
236     case OP_POSPLUSI:
237     case OP_POSQUERYI:
238     case OP_POSUPTOI:
239     case OP_NOTSTAR:
240     case OP_NOTMINSTAR:
241     case OP_NOTPLUS:
242     case OP_NOTMINPLUS:
243     case OP_NOTQUERY:
244     case OP_NOTMINQUERY:
245     case OP_NOTUPTO:
246     case OP_NOTMINUPTO:
247     case OP_NOTEXACT:
248     case OP_NOTPOSSTAR:
249     case OP_NOTPOSPLUS:
250     case OP_NOTPOSQUERY:
251     case OP_NOTPOSUPTO:
252     case OP_NOTSTARI:
253     case OP_NOTMINSTARI:
254     case OP_NOTPLUSI:
255     case OP_NOTMINPLUSI:
256     case OP_NOTQUERYI:
257     case OP_NOTMINQUERYI:
258     case OP_NOTUPTOI:
259     case OP_NOTMINUPTOI:
260     case OP_NOTEXACTI:
261     case OP_NOTPOSSTARI:
262     case OP_NOTPOSPLUSI:
263     case OP_NOTPOSQUERYI:
264     case OP_NOTPOSUPTOI:
265     if (utf) utf16_char = TRUE;
266 #endif
267     /* Fall through. */
268
269     default:
270     length = PRIV(OP_lengths)[*ptr] - 1;
271     break;
272
273     case OP_CLASS:
274     case OP_NCLASS:
275     /* Skip the character bit map. */
276     ptr += 32/sizeof(pcre_uchar);
277     length = 0;
278     break;
279
280     case OP_XCLASS:
281     /* Reverse the size of the XCLASS instance. */
282     ptr++;
283 #if defined COMPILE_PCRE16
284     *ptr = swap_uint16(*ptr);
285 #elif defined COMPILE_PCRE32
286     *ptr = swap_uint32(*ptr);
287 #endif
288 #ifndef COMPILE_PCRE32
289     if (LINK_SIZE > 1)
290       {
291       /* LINK_SIZE can be 1 or 2 in 16 bit mode. */
292       ptr++;
293       *ptr = swap_uint16(*ptr);
294       }
295 #endif
296     ptr++;
297     length = (GET(ptr, -LINK_SIZE)) - (1 + LINK_SIZE + 1);
298 #if defined COMPILE_PCRE16
299     *ptr = swap_uint16(*ptr);
300 #elif defined COMPILE_PCRE32
301     *ptr = swap_uint32(*ptr);
302 #endif
303     if ((*ptr & XCL_MAP) != 0)
304       {
305       /* Skip the character bit map. */
306       ptr += 32/sizeof(pcre_uchar);
307       length -= 32/sizeof(pcre_uchar);
308       }
309     break;
310     }
311   ptr++;
312   }
313 /* Control should never reach here in 16/32 bit mode. */
314 #else  /* In 8-bit mode, the pattern does not need to be processed. */
315 return 0;
316 #endif /* !COMPILE_PCRE8 */
317 }
318
319 /* End of pcre_byte_order.c */