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

Diff of /code/trunk/pcre_byte_order.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

code/branches/pcre16/pcre_try_flipped.c revision 764 by zherczeg, Wed Nov 23 17:23:20 2011 UTC code/trunk/pcre_byte_order.c revision 1313 by ph10, Wed Apr 24 12:07:09 2013 UTC
# Line 6  Line 6 
6  and semantics are as close as possible to those of the Perl 5 language.  and semantics are as close as possible to those of the Perl 5 language.
7    
8                         Written by Philip Hazel                         Written by Philip Hazel
9             Copyright (c) 1997-2009 University of Cambridge             Copyright (c) 1997-2013 University of Cambridge
10    
11  -----------------------------------------------------------------------------  -----------------------------------------------------------------------------
12  Redistribution and use in source and binary forms, with or without  Redistribution and use in source and binary forms, with or without
# Line 51  auxiliary local function to flip the app Line 51  auxiliary local function to flip the app
51    
52    
53  /*************************************************  /*************************************************
54  *         Flip bytes in an integer               *  *             Swap byte functions                *
55  *************************************************/  *************************************************/
56    
57  /* This function is called when the magic number in a regex doesn't match, in  /* The following functions swap the bytes of a pcre_uint16
58  order to flip its bytes to see if we are dealing with a pattern that was  and pcre_uint32 value.
 compiled on a host of different endianness. If so, this function is used to  
 flip other byte values.  
59    
60  Arguments:  Arguments:
61    value        the number to flip    value        any number
   n            the number of bytes to flip (assumed to be 2 or 4)  
62    
63  Returns:       the flipped value  Returns:       the byte swapped value
64  */  */
65    
66  static unsigned long int  static pcre_uint32
67  byteflip(unsigned long int value, int n)  swap_uint32(pcre_uint32 value)
68  {  {
 if (n == 2) return ((value & 0x00ff) << 8) | ((value & 0xff00) >> 8);  
69  return ((value & 0x000000ff) << 24) |  return ((value & 0x000000ff) << 24) |
70         ((value & 0x0000ff00) <<  8) |         ((value & 0x0000ff00) <<  8) |
71         ((value & 0x00ff0000) >>  8) |         ((value & 0x00ff0000) >>  8) |
72         ((value & 0xff000000) >> 24);         (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   *  *       Test for a byte-flipped compiled regex   *
84  *************************************************/  *************************************************/
85    
86  /* This function is called from pcre_exec(), pcre_dfa_exec(), and also from  /* This function swaps the bytes of a compiled pattern usually
87  pcre_fullinfo(). Its job is to test whether the regex is byte-flipped - that  loaded form the disk. It also sets the tables pointer, which
88  is, it was compiled on a system of opposite endianness. The function is called  is likely an invalid pointer after reload.
 only when the native MAGIC_NUMBER test fails. If the regex is indeed flipped,  
 we flip all the relevant values into a different data block, and return it.  
89    
90  Arguments:  Arguments:
91    re               points to the regex    argument_re     points to the compiled expression
92    study            points to study data, or NULL    extra_data      points to extra data or is NULL
93    internal_re      points to a new regex block    tables          points to the character tables or NULL
   internal_study   points to a new study block  
94    
95  Returns:           the new block if is is indeed a byte-flipped regex  Returns:          0 if the swap is successful, negative on error
                    NULL if it is not  
96  */  */
97    
98  real_pcre *  #if defined COMPILE_PCRE8
99  PRIV(try_flipped)(const real_pcre *re, real_pcre *internal_re,  PCRE_EXP_DECL int pcre_pattern_to_host_byte_order(pcre *argument_re,
100    const pcre_study_data *study, pcre_study_data *internal_study)    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  if (byteflip(re->magic_number, sizeof(re->magic_number)) != MAGIC_NUMBER)  REAL_PCRE *re = (REAL_PCRE *)argument_re;
110    return NULL;  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  *internal_re = *re;           /* To copy other fields */  if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_STUDY_DATA) != 0)
156  internal_re->size = byteflip(re->size, sizeof(re->size));    {
157  internal_re->options = byteflip(re->options, sizeof(re->options));    study = (pcre_study_data *)extra_data->study_data;
158  internal_re->flags = (pcre_uint16)byteflip(re->flags, sizeof(re->flags));    study->size = swap_uint32(study->size);
159  internal_re->top_bracket =    study->flags = swap_uint32(study->flags);
160    (pcre_uint16)byteflip(re->top_bracket, sizeof(re->top_bracket));    study->minlength = swap_uint32(study->minlength);
161  internal_re->top_backref =    }
162    (pcre_uint16)byteflip(re->top_backref, sizeof(re->top_backref));  
163  internal_re->first_byte =  #ifndef COMPILE_PCRE8
164    (pcre_uint16)byteflip(re->first_byte, sizeof(re->first_byte));  ptr = (pcre_uchar *)re + re->name_table_offset;
165  internal_re->req_byte =  length = re->name_count * re->name_entry_size;
166    (pcre_uint16)byteflip(re->req_byte, sizeof(re->req_byte));  #if defined SUPPORT_UTF && defined COMPILE_PCRE16
167  internal_re->name_table_offset =  utf = (re->options & PCRE_UTF16) != 0;
168    (pcre_uint16)byteflip(re->name_table_offset, sizeof(re->name_table_offset));  utf16_char = FALSE;
169  internal_re->name_entry_size =  #endif /* SUPPORT_UTF && COMPILE_PCRE16 */
   (pcre_uint16)byteflip(re->name_entry_size, sizeof(re->name_entry_size));  
 internal_re->name_count =  
   (pcre_uint16)byteflip(re->name_count, sizeof(re->name_count));  
170    
171  if (study != NULL)  while(TRUE)
172    {    {
173    *internal_study = *study;   /* To copy other fields */    /* Swap previous characters. */
174    internal_study->size = byteflip(study->size, sizeof(study->size));    while (length-- > 0)
175    internal_study->flags = byteflip(study->flags, sizeof(study->flags));      {
176    internal_study->minlength = byteflip(study->minlength,  #if defined COMPILE_PCRE16
177      sizeof(study->minlength));      *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    #endif /* !COMPILE_PCRE8 */
315    
316  return internal_re;  return 0;
317  }  }
318    
319  /* End of pcre_tryflipped.c */  /* End of pcre_byte_order.c */

Legend:
Removed from v.764  
changed lines
  Added in v.1313

  ViewVC Help
Powered by ViewVC 1.1.5