/[pcre]/code/trunk/pcre_byte_order.c
ViewVC logotype

Contents of /code/trunk/pcre_byte_order.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 850 - (hide annotations) (download)
Wed Jan 4 17:29:11 2012 UTC (2 years, 9 months ago) by zherczeg
File MIME type: text/plain
File size: 8055 byte(s)
add pcre16_callout_block and pcre16_extra
1 nigel 77 /*************************************************
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 ph10 830 Copyright (c) 1997-2012 University of Cambridge
10 nigel 77
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 ph10 200 #ifdef HAVE_CONFIG_H
47 ph10 236 #include "config.h"
48 ph10 200 #endif
49 ph10 199
50 nigel 77 #include "pcre_internal.h"
51    
52    
53     /*************************************************
54 zherczeg 809 * Swap byte functions *
55 nigel 77 *************************************************/
56    
57 zherczeg 809 /* The following functions swap the bytes of a pcre_uint16
58     and pcre_uint32 value.
59 nigel 77
60     Arguments:
61 zherczeg 809 value any number
62 nigel 77
63 zherczeg 809 Returns: the byte swapped value
64 nigel 77 */
65    
66 zherczeg 809 static pcre_uint32
67     swap_uint32(pcre_uint32 value)
68 nigel 77 {
69     return ((value & 0x000000ff) << 24) |
70     ((value & 0x0000ff00) << 8) |
71     ((value & 0x00ff0000) >> 8) |
72 zherczeg 809 (value >> 24);
73 nigel 77 }
74    
75 zherczeg 809 static pcre_uint16
76     swap_uint16(pcre_uint16 value)
77     {
78     return (value >> 8) | (value << 8);
79     }
80 nigel 77
81    
82     /*************************************************
83     * Test for a byte-flipped compiled regex *
84     *************************************************/
85    
86 zherczeg 809 /* This function swaps the bytes of a compiled pattern usually
87 zherczeg 811 loaded form the disk. It also sets the tables pointer, which
88 zherczeg 809 is likely an invalid pointer after reload.
89 nigel 77
90     Arguments:
91 zherczeg 809 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 nigel 77
95 zherczeg 809 Returns: 0 if the swap is successful, negative on error
96 nigel 77 */
97    
98 zherczeg 809 #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(pcre *argument_re,
103 zherczeg 850 pcre16_extra *extra_data, const unsigned char *tables)
104 zherczeg 809 #endif
105 nigel 77 {
106 zherczeg 809 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 nigel 77
117 zherczeg 809 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 nigel 77
125 zherczeg 809 if (re->magic_number != REVERSED_MAGIC_NUMBER) return PCRE_ERROR_BADMAGIC;
126 zherczeg 811 if ((swap_uint16(re->flags) & PCRE_MODE) == 0) return PCRE_ERROR_BADMODE;
127 zherczeg 809
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 zherczeg 811 re->tables = tables;
141 zherczeg 809
142 zherczeg 839 if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_STUDY_DATA) != 0)
143 nigel 77 {
144 zherczeg 809 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 nigel 77 }
149    
150 zherczeg 809 #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 zherczeg 816 #ifdef SUPPORT_UTF
188 zherczeg 809 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 ph10 813 if (utf) utf16_char = TRUE;
245 zherczeg 816 #endif
246     /* Fall through. */
247    
248     default:
249 zherczeg 809 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 nigel 77 }
287    
288 zherczeg 809 /* End of pcre_byte_order.c */

Properties

Name Value
svn:eol-style native
svn:keywords "Author Date Id Revision Url"

webmaster@exim.org
ViewVC Help
Powered by ViewVC 1.1.12