Annotation of embedaddon/pcre/pcre_byte_order.c, revision 1.1.1.1
1.1 misho 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-2012 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: #ifdef 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: #else
102: PCRE_EXP_DECL int pcre16_pattern_to_host_byte_order(pcre16 *argument_re,
103: pcre16_extra *extra_data, const unsigned char *tables)
104: #endif
105: {
106: REAL_PCRE *re = (REAL_PCRE *)argument_re;
107: pcre_study_data *study;
108: #ifndef COMPILE_PCRE8
109: pcre_uchar *ptr;
110: int length;
111: #ifdef SUPPORT_UTF
112: BOOL utf;
113: BOOL utf16_char;
114: #endif /* SUPPORT_UTF */
115: #endif /* !COMPILE_PCRE8 */
116:
117: if (re == NULL) return PCRE_ERROR_NULL;
118: if (re->magic_number == MAGIC_NUMBER)
119: {
120: if ((re->flags & PCRE_MODE) == 0) return PCRE_ERROR_BADMODE;
121: re->tables = tables;
122: return 0;
123: }
124:
125: if (re->magic_number != REVERSED_MAGIC_NUMBER) return PCRE_ERROR_BADMAGIC;
126: if ((swap_uint16(re->flags) & PCRE_MODE) == 0) return PCRE_ERROR_BADMODE;
127:
128: re->magic_number = MAGIC_NUMBER;
129: re->size = swap_uint32(re->size);
130: re->options = swap_uint32(re->options);
131: re->flags = swap_uint16(re->flags);
132: re->top_bracket = swap_uint16(re->top_bracket);
133: re->top_backref = swap_uint16(re->top_backref);
134: re->first_char = swap_uint16(re->first_char);
135: re->req_char = swap_uint16(re->req_char);
136: re->name_table_offset = swap_uint16(re->name_table_offset);
137: re->name_entry_size = swap_uint16(re->name_entry_size);
138: re->name_count = swap_uint16(re->name_count);
139: re->ref_count = swap_uint16(re->ref_count);
140: re->tables = tables;
141:
142: if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_STUDY_DATA) != 0)
143: {
144: study = (pcre_study_data *)extra_data->study_data;
145: study->size = swap_uint32(study->size);
146: study->flags = swap_uint32(study->flags);
147: study->minlength = swap_uint32(study->minlength);
148: }
149:
150: #ifndef COMPILE_PCRE8
151: ptr = (pcre_uchar *)re + re->name_table_offset;
152: length = re->name_count * re->name_entry_size;
153: #ifdef SUPPORT_UTF
154: utf = (re->options & PCRE_UTF16) != 0;
155: utf16_char = FALSE;
156: #endif
157:
158: while(TRUE)
159: {
160: /* Swap previous characters. */
161: while (length-- > 0)
162: {
163: *ptr = swap_uint16(*ptr);
164: ptr++;
165: }
166: #ifdef SUPPORT_UTF
167: if (utf16_char)
168: {
169: if (HAS_EXTRALEN(ptr[-1]))
170: {
171: /* We know that there is only one extra character in UTF-16. */
172: *ptr = swap_uint16(*ptr);
173: ptr++;
174: }
175: }
176: utf16_char = FALSE;
177: #endif /* SUPPORT_UTF */
178:
179: /* Get next opcode. */
180: length = 0;
181: *ptr = swap_uint16(*ptr);
182: switch (*ptr)
183: {
184: case OP_END:
185: return 0;
186:
187: #ifdef SUPPORT_UTF
188: case OP_CHAR:
189: case OP_CHARI:
190: case OP_NOT:
191: case OP_NOTI:
192: case OP_STAR:
193: case OP_MINSTAR:
194: case OP_PLUS:
195: case OP_MINPLUS:
196: case OP_QUERY:
197: case OP_MINQUERY:
198: case OP_UPTO:
199: case OP_MINUPTO:
200: case OP_EXACT:
201: case OP_POSSTAR:
202: case OP_POSPLUS:
203: case OP_POSQUERY:
204: case OP_POSUPTO:
205: case OP_STARI:
206: case OP_MINSTARI:
207: case OP_PLUSI:
208: case OP_MINPLUSI:
209: case OP_QUERYI:
210: case OP_MINQUERYI:
211: case OP_UPTOI:
212: case OP_MINUPTOI:
213: case OP_EXACTI:
214: case OP_POSSTARI:
215: case OP_POSPLUSI:
216: case OP_POSQUERYI:
217: case OP_POSUPTOI:
218: case OP_NOTSTAR:
219: case OP_NOTMINSTAR:
220: case OP_NOTPLUS:
221: case OP_NOTMINPLUS:
222: case OP_NOTQUERY:
223: case OP_NOTMINQUERY:
224: case OP_NOTUPTO:
225: case OP_NOTMINUPTO:
226: case OP_NOTEXACT:
227: case OP_NOTPOSSTAR:
228: case OP_NOTPOSPLUS:
229: case OP_NOTPOSQUERY:
230: case OP_NOTPOSUPTO:
231: case OP_NOTSTARI:
232: case OP_NOTMINSTARI:
233: case OP_NOTPLUSI:
234: case OP_NOTMINPLUSI:
235: case OP_NOTQUERYI:
236: case OP_NOTMINQUERYI:
237: case OP_NOTUPTOI:
238: case OP_NOTMINUPTOI:
239: case OP_NOTEXACTI:
240: case OP_NOTPOSSTARI:
241: case OP_NOTPOSPLUSI:
242: case OP_NOTPOSQUERYI:
243: case OP_NOTPOSUPTOI:
244: if (utf) utf16_char = TRUE;
245: #endif
246: /* Fall through. */
247:
248: default:
249: length = PRIV(OP_lengths)[*ptr] - 1;
250: break;
251:
252: case OP_CLASS:
253: case OP_NCLASS:
254: /* Skip the character bit map. */
255: ptr += 32/sizeof(pcre_uchar);
256: length = 0;
257: break;
258:
259: case OP_XCLASS:
260: /* Reverse the size of the XCLASS instance. */
261: ptr++;
262: *ptr = swap_uint16(*ptr);
263: if (LINK_SIZE > 1)
264: {
265: /* LINK_SIZE can be 1 or 2 in 16 bit mode. */
266: ptr++;
267: *ptr = swap_uint16(*ptr);
268: }
269: ptr++;
270: length = (GET(ptr, -LINK_SIZE)) - (1 + LINK_SIZE + 1);
271: *ptr = swap_uint16(*ptr);
272: if ((*ptr & XCL_MAP) != 0)
273: {
274: /* Skip the character bit map. */
275: ptr += 32/sizeof(pcre_uchar);
276: length -= 32/sizeof(pcre_uchar);
277: }
278: break;
279: }
280: ptr++;
281: }
282: /* Control should never reach here in 16 bit mode. */
283: #endif /* !COMPILE_PCRE8 */
284:
285: return 0;
286: }
287:
288: /* End of pcre_byte_order.c */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pcre_byte_order.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / pcre