/[pcre]/code/trunk/pcre_internal.h
ViewVC logotype

Diff of /code/trunk/pcre_internal.h

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

revision 1075 by chpe, Tue Oct 16 15:54:51 2012 UTC revision 1199 by chpe, Sat Nov 3 19:21:37 2012 UTC
# Line 53  depending on the PRIV macro. */ Line 53  depending on the PRIV macro. */
53  #endif  #endif
54    
55  /* PCRE is compiled as an 8 bit library if it is not requested otherwise. */  /* PCRE is compiled as an 8 bit library if it is not requested otherwise. */
56  #if !defined COMPILE_PCRE16 && ! defined COMPILE_PCRE32  
57    #if !defined COMPILE_PCRE16 && !defined COMPILE_PCRE32
58  #define COMPILE_PCRE8  #define COMPILE_PCRE8
59  #endif  #endif
60    
# Line 111  setjmp and stdarg are used is when NO_RE Line 112  setjmp and stdarg are used is when NO_RE
112  #include <stdlib.h>  #include <stdlib.h>
113  #include <string.h>  #include <string.h>
114    
115    /* Valgrind (memcheck) support */
116    
117    #ifdef SUPPORT_VALGRIND
118    #include <valgrind/memcheck.h>
119    #endif
120    
121  /* When compiling a DLL for Windows, the exported symbols have to be declared  /* When compiling a DLL for Windows, the exported symbols have to be declared
122  using some MS magic. I found some useful information on this web page:  using some MS magic. I found some useful information on this web page:
123  http://msdn2.microsoft.com/en-us/library/y4h7bcy6(VS.80).aspx. According to the  http://msdn2.microsoft.com/en-us/library/y4h7bcy6(VS.80).aspx. According to the
# Line 214  stdint.h is available, include it; it ma Line 221  stdint.h is available, include it; it ma
221  have stdint.h (e.g. Solaris) may have inttypes.h. The macro int64_t may be set  have stdint.h (e.g. Solaris) may have inttypes.h. The macro int64_t may be set
222  by "configure". */  by "configure". */
223    
224  #if HAVE_STDINT_H  #if defined HAVE_STDINT_H
225  #include <stdint.h>  #include <stdint.h>
226  #elif HAVE_INTTYPES_H  #elif defined HAVE_INTTYPES_H
227  #include <inttypes.h>  #include <inttypes.h>
228  #endif  #endif
229    
# Line 272  typedef pcre_uint32 pcre_uchar; Line 279  typedef pcre_uint32 pcre_uchar;
279  #define MAX_255(c) ((c) <= 255u)  #define MAX_255(c) ((c) <= 255u)
280  #define TABLE_GET(c, table, default) (MAX_255(c)? ((table)[c]):(default))  #define TABLE_GET(c, table, default) (MAX_255(c)? ((table)[c]):(default))
281    
 /* Assert that pcre_uchar32 is a 32-bit type */  
 typedef int __assert_pcre_uchar32_size[sizeof(pcre_uchar) == 4 ? 1 : -1];  
   
282  #else  #else
283  #error Unsupported compiling mode  #error Unsupported compiling mode
284  #endif /* COMPILE_PCRE[8|16|32] */  #endif /* COMPILE_PCRE[8|16|32] */
# Line 304  start/end of string field names are. */ Line 308  start/end of string field names are. */
308         &(NLBLOCK->nllen), utf)) \         &(NLBLOCK->nllen), utf)) \
309      : \      : \
310      ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \      ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \
311       (p)[0] == NLBLOCK->nl[0] && \       RAWUCHARTEST(p) == NLBLOCK->nl[0] && \
312       (NLBLOCK->nllen == 1 || (p)[1] == NLBLOCK->nl[1]) \       (NLBLOCK->nllen == 1 || RAWUCHARTEST(p+1) == NLBLOCK->nl[1])       \
313      ) \      ) \
314    )    )
315    
# Line 318  start/end of string field names are. */ Line 322  start/end of string field names are. */
322         &(NLBLOCK->nllen), utf)) \         &(NLBLOCK->nllen), utf)) \
323      : \      : \
324      ((p) >= NLBLOCK->PSSTART + NLBLOCK->nllen && \      ((p) >= NLBLOCK->PSSTART + NLBLOCK->nllen && \
325       (p)[-NLBLOCK->nllen] == NLBLOCK->nl[0] && \       RAWUCHARTEST(p - NLBLOCK->nllen) == NLBLOCK->nl[0] &&              \
326       (NLBLOCK->nllen == 1 || (p)[-NLBLOCK->nllen+1] == NLBLOCK->nl[1]) \       (NLBLOCK->nllen == 1 || RAWUCHARTEST(p - NLBLOCK->nllen + 1) == NLBLOCK->nl[1]) \
327      ) \      ) \
328    )    )
329    
# Line 344  values. */ Line 348  values. */
348  #include "pcre.h"  #include "pcre.h"
349  #include "ucp.h"  #include "ucp.h"
350    
351    #ifdef COMPILE_PCRE32
352    /* Assert that the public PCRE_UCHAR32 is a 32-bit type */
353    typedef int __assert_pcre_uchar32_size[sizeof(PCRE_UCHAR32) == 4 ? 1 : -1];
354    #endif
355    
356  /* When compiling for use with the Virtual Pascal compiler, these functions  /* When compiling for use with the Virtual Pascal compiler, these functions
357  need to have their names changed. PCRE must be compiled with the -DVPCOMPAT  need to have their names changed. PCRE must be compiled with the -DVPCOMPAT
358  option on the command line. */  option on the command line. */
# Line 522  capturing parenthesis numbers in back re Line 531  capturing parenthesis numbers in back re
531  #define PUT2(a,n,d)   \  #define PUT2(a,n,d)   \
532    a[n] = (d) >> 8; \    a[n] = (d) >> 8; \
533    a[(n)+1] = (d) & 255    a[(n)+1] = (d) & 255
534    
535    /* For reasons that I do not understand, the expression in this GET2 macro is
536    treated by gcc as a signed expression, even when a is declared as unsigned. It
537    seems that any kind of arithmetic results in a signed value. */
538    
539  #define GET2(a,n) \  #define GET2(a,n) \
540    (((a)[n] << 8) | (a)[(n)+1])    (unsigned int)(((a)[n] << 8) | (a)[(n)+1])
541    
542  #elif defined COMPILE_PCRE16  #elif defined COMPILE_PCRE16
543    
# Line 579  we don't even define them. */ Line 592  we don't even define them. */
592  #define GETCHARINC(c, eptr) c = *eptr++;  #define GETCHARINC(c, eptr) c = *eptr++;
593  #define GETCHARINCTEST(c, eptr) c = *eptr++;  #define GETCHARINCTEST(c, eptr) c = *eptr++;
594  #define GETCHARLEN(c, eptr, len) c = *eptr;  #define GETCHARLEN(c, eptr, len) c = *eptr;
595    #define RAWUCHAR(eptr) (*(eptr))
596    #define RAWUCHARINC(eptr) (*(eptr)++)
597    #define RAWUCHARTEST(eptr) (*(eptr))
598    #define RAWUCHARINCTEST(eptr) (*(eptr)++)
599  /* #define GETCHARLENTEST(c, eptr, len) */  /* #define GETCHARLENTEST(c, eptr, len) */
600  /* #define BACKCHAR(eptr) */  /* #define BACKCHAR(eptr) */
601  /* #define FORWARDCHAR(eptr) */  /* #define FORWARDCHAR(eptr) */
# Line 586  we don't even define them. */ Line 603  we don't even define them. */
603    
604  #else   /* SUPPORT_UTF */  #else   /* SUPPORT_UTF */
605    
 #if defined COMPILE_PCRE8  
   
 /* These macros were originally written in the form of loops that used data  
 from the tables whose names start with PRIV(utf8_table). They were rewritten by  
 a user so as not to use loops, because in some environments this gives a  
 significant performance advantage, and it seems never to do any harm. */  
   
 /* Tells the biggest code point which can be encoded as a single character. */  
   
 #define MAX_VALUE_FOR_SINGLE_CHAR 127  
   
606  /* Tests whether the code point needs extra characters to decode. */  /* Tests whether the code point needs extra characters to decode. */
607    
608  #define HAS_EXTRALEN(c) ((c) >= 0xc0)  #define HASUTF8EXTRALEN(c) ((c) >= 0xc0)
   
 /* Returns with the additional number of characters if IS_MULTICHAR(c) is TRUE.  
 Otherwise it has an undefined behaviour. */  
   
 #define GET_EXTRALEN(c) (PRIV(utf8_table4)[(c) & 0x3f])  
   
 /* Returns TRUE, if the given character is not the first character  
 of a UTF sequence. */  
   
 #define NOT_FIRSTCHAR(c) (((c) & 0xc0) == 0x80)  
609    
610  /* Base macro to pick up the remaining bytes of a UTF-8 character, not  /* Base macro to pick up the remaining bytes of a UTF-8 character, not
611  advancing the pointer. */  advancing the pointer. */
# Line 633  advancing the pointer. */ Line 629  advancing the pointer. */
629            ((eptr[4] & 0x3f) << 6) | (eptr[5] & 0x3f); \            ((eptr[4] & 0x3f) << 6) | (eptr[5] & 0x3f); \
630      }      }
631    
 /* Get the next UTF-8 character, not advancing the pointer. This is called when  
 we know we are in UTF-8 mode. */  
   
 #define GETCHAR(c, eptr) \  
   c = *eptr; \  
   if (c >= 0xc0) GETUTF8(c, eptr);  
   
 /* Get the next UTF-8 character, testing for UTF-8 mode, and not advancing the  
 pointer. */  
   
 #define GETCHARTEST(c, eptr) \  
   c = *eptr; \  
   if (utf && c >= 0xc0) GETUTF8(c, eptr);  
   
632  /* Base macro to pick up the remaining bytes of a UTF-8 character, advancing  /* Base macro to pick up the remaining bytes of a UTF-8 character, advancing
633  the pointer. */  the pointer. */
634    
# Line 681  the pointer. */ Line 663  the pointer. */
663        } \        } \
664      }      }
665    
666    #if defined COMPILE_PCRE8
667    
668    /* These macros were originally written in the form of loops that used data
669    from the tables whose names start with PRIV(utf8_table). They were rewritten by
670    a user so as not to use loops, because in some environments this gives a
671    significant performance advantage, and it seems never to do any harm. */
672    
673    /* Tells the biggest code point which can be encoded as a single character. */
674    
675    #define MAX_VALUE_FOR_SINGLE_CHAR 127
676    
677    /* Tests whether the code point needs extra characters to decode. */
678    
679    #define HAS_EXTRALEN(c) ((c) >= 0xc0)
680    
681    /* Returns with the additional number of characters if IS_MULTICHAR(c) is TRUE.
682    Otherwise it has an undefined behaviour. */
683    
684    #define GET_EXTRALEN(c) (PRIV(utf8_table4)[(c) & 0x3f])
685    
686    /* Returns TRUE, if the given character is not the first character
687    of a UTF sequence. */
688    
689    #define NOT_FIRSTCHAR(c) (((c) & 0xc0) == 0x80)
690    
691    /* Get the next UTF-8 character, not advancing the pointer. This is called when
692    we know we are in UTF-8 mode. */
693    
694    #define GETCHAR(c, eptr) \
695      c = *eptr; \
696      if (c >= 0xc0) GETUTF8(c, eptr);
697    
698    /* Get the next UTF-8 character, testing for UTF-8 mode, and not advancing the
699    pointer. */
700    
701    #define GETCHARTEST(c, eptr) \
702      c = *eptr; \
703      if (utf && c >= 0xc0) GETUTF8(c, eptr);
704    
705  /* Get the next UTF-8 character, advancing the pointer. This is called when we  /* Get the next UTF-8 character, advancing the pointer. This is called when we
706  know we are in UTF-8 mode. */  know we are in UTF-8 mode. */
707    
# Line 747  do not know if we are in UTF-8 mode. */ Line 768  do not know if we are in UTF-8 mode. */
768    c = *eptr; \    c = *eptr; \
769    if (utf && c >= 0xc0) GETUTF8LEN(c, eptr, len);    if (utf && c >= 0xc0) GETUTF8LEN(c, eptr, len);
770    
771    /* Returns the next uchar, not advancing the pointer. This is called when
772    we know we are in UTF mode. */
773    
774    #define RAWUCHAR(eptr) \
775      (*(eptr))
776    
777    /* Returns the next uchar, advancing the pointer. This is called when
778    we know we are in UTF mode. */
779    
780    #define RAWUCHARINC(eptr) \
781      (*((eptr)++))
782    
783    /* Returns the next uchar, testing for UTF mode, and not advancing the
784    pointer. */
785    
786    #define RAWUCHARTEST(eptr) \
787      (*(eptr))
788    
789    /* Returns the next uchar, testing for UTF mode, advancing the
790    pointer. */
791    
792    #define RAWUCHARINCTEST(eptr) \
793      (*((eptr)++))
794    
795  /* If the pointer is not at the start of a character, move it back until  /* If the pointer is not at the start of a character, move it back until
796  it is. This is called only in UTF-8 mode - we don't put a test within the macro  it is. This is called only in UTF-8 mode - we don't put a test within the macro
797  because almost all calls are already within a block of UTF-8 only code. */  because almost all calls are already within a block of UTF-8 only code. */
# Line 842  we do not know if we are in UTF-16 mode. Line 887  we do not know if we are in UTF-16 mode.
887    c = *eptr; \    c = *eptr; \
888    if (utf && (c & 0xfc00) == 0xd800) GETUTF16LEN(c, eptr, len);    if (utf && (c & 0xfc00) == 0xd800) GETUTF16LEN(c, eptr, len);
889    
890    /* Returns the next uchar, not advancing the pointer. This is called when
891    we know we are in UTF mode. */
892    
893    #define RAWUCHAR(eptr) \
894      (*(eptr))
895    
896    /* Returns the next uchar, advancing the pointer. This is called when
897    we know we are in UTF mode. */
898    
899    #define RAWUCHARINC(eptr) \
900      (*((eptr)++))
901    
902    /* Returns the next uchar, testing for UTF mode, and not advancing the
903    pointer. */
904    
905    #define RAWUCHARTEST(eptr) \
906      (*(eptr))
907    
908    /* Returns the next uchar, testing for UTF mode, advancing the
909    pointer. */
910    
911    #define RAWUCHARINCTEST(eptr) \
912      (*((eptr)++))
913    
914  /* If the pointer is not at the start of a character, move it back until  /* If the pointer is not at the start of a character, move it back until
915  it is. This is called only in UTF-16 mode - we don't put a test within the  it is. This is called only in UTF-16 mode - we don't put a test within the
916  macro because almost all calls are already within a block of UTF-16 only  macro because almost all calls are already within a block of UTF-16 only
# Line 858  code. */ Line 927  code. */
927    
928  #elif defined COMPILE_PCRE32  #elif defined COMPILE_PCRE32
929    
930  /* These are unnecessary for the 32-bit library */  /* These are trivial for the 32-bit library, since all UTF-32 characters fit
931  #undef MAX_VALUE_FOR_SINGLE_CHAR  into one pcre_uchar unit. */
932  #undef HAS_EXTRALEN  #define MAX_VALUE_FOR_SINGLE_CHAR (0x10ffffu)
933  #undef GET_EXTRALEN  #define HAS_EXTRALEN(c) (0)
934  #undef NOT_FIRSTCHAR  #define GET_EXTRALEN(c) (0)
935    #define NOT_FIRSTCHAR(c) (0)
936    
937    #define UTF32_MASK (0x1fffffu)
938    
939    /* Base macro to pick up an UTF-32 character out of a uint32 */
940    
941    #define MASKHIGHBITS(c) ((c) & UTF32_MASK)
942    
943    /* Base macro to pick up an UTF-32 character, not advancing the pointer */
944    
945    #define GETUTF32(eptr) (MASKHIGHBITS(*(eptr)))
946    
947    /* Base macro to pick up an UTF-32 character, advancing the pointer */
948    
949    #define GETUTF32INC(eptr) (MASKHIGHBITS(*((eptr)++)))
950    
951  /* Get the next UTF-32 character, not advancing the pointer. This is called when  /* Get the next UTF-32 character, not advancing the pointer. This is called when
952  we know we are in UTF-32 mode. */  we know we are in UTF-32 mode. */
953    
954  #define GETCHAR(c, eptr) \  #define GETCHAR(c, eptr) \
955    c = *eptr;    c = GETUTF32(eptr);
956    
957  /* Get the next UTF-32 character, testing for UTF-32 mode, and not advancing the  /* Get the next UTF-32 character, testing for UTF-32 mode, and not advancing the
958  pointer. */  pointer. */
959    
960  #define GETCHARTEST(c, eptr) \  #define GETCHARTEST(c, eptr) \
961    c = *eptr;    c = (utf ? GETUTF32(eptr) : *(eptr));
962    
963  /* Get the next UTF-32 character, advancing the pointer. This is called when we  /* Get the next UTF-32 character, advancing the pointer. This is called when we
964  know we are in UTF-32 mode. */  know we are in UTF-32 mode. */
965    
966  #define GETCHARINC(c, eptr) \  #define GETCHARINC(c, eptr) \
967    c = *eptr++;    c = GETUTF32INC(eptr);
968    
969  /* Get the next character, testing for UTF-32 mode, and advancing the pointer.  /* Get the next character, testing for UTF-32 mode, and advancing the pointer.
970  This is called when we don't know if we are in UTF-32 mode. */  This is called when we don't know if we are in UTF-32 mode. */
971    
972  #define GETCHARINCTEST(c, eptr) \  #define GETCHARINCTEST(c, eptr) \
973    c = *eptr++;    c = (utf ? GETUTF32INC(eptr) : *((eptr)++));
974    
975  /* Get the next UTF-32 character, not advancing the pointer, not incrementing  /* Get the next UTF-32 character, not advancing the pointer, not incrementing
976  length (since all UTF-32 is of length 1). This is called when we know we are in  length (since all UTF-32 is of length 1). This is called when we know we are in
977  UTF-32 mode. */  UTF-32 mode. */
978    
979  #define GETCHARLEN(c, eptr, len) \  #define GETCHARLEN(c, eptr, len) \
980    c = *eptr;    GETCHAR(c, eptr)
981    
982  /* Get the next UTF-832character, testing for UTF-32 mode, not advancing the  /* Get the next UTF-32character, testing for UTF-32 mode, not advancing the
983  pointer, not incrementing the length (since all UTF-32 is of length 1).  pointer, not incrementing the length (since all UTF-32 is of length 1).
984  This is called when we do not know if we are in UTF-32 mode. */  This is called when we do not know if we are in UTF-32 mode. */
985    
986  #define GETCHARLENTEST(c, eptr, len) \  #define GETCHARLENTEST(c, eptr, len) \
987    c = *eptr;    GETCHARTEST(c, eptr)
988    
989    /* Returns the next uchar, not advancing the pointer. This is called when
990    we know we are in UTF mode. */
991    
992    #define RAWUCHAR(eptr) \
993      (MASKHIGHBITS(*(eptr)))
994    
995    /* Returns the next uchar, advancing the pointer. This is called when
996    we know we are in UTF mode. */
997    
998    #define RAWUCHARINC(eptr) \
999      (MASKHIGHBITS(*((eptr)++)))
1000    
1001    /* Returns the next uchar, testing for UTF mode, and not advancing the
1002    pointer. */
1003    
1004    #define RAWUCHARTEST(eptr) \
1005      (utf ? (MASKHIGHBITS(*(eptr))) : *(eptr))
1006    
1007    /* Returns the next uchar, testing for UTF mode, advancing the
1008    pointer. */
1009    
1010    #define RAWUCHARINCTEST(eptr) \
1011      (utf ? (MASKHIGHBITS(*((eptr)++))) : *((eptr)++))
1012    
1013  /* If the pointer is not at the start of a character, move it back until  /* If the pointer is not at the start of a character, move it back until
1014  it is. This is called only in UTF-32 mode - we don't put a test within the  it is. This is called only in UTF-32 mode - we don't put a test within the
1015  macro because almost all calls are already within a block of UTF-32 only  macro because almost all calls are already within a block of UTF-32 only
1016  code. */  code.
1017    These are all no-ops since all UTF-32 characters fit into one pcre_uchar. */
1018    
1019  #define BACKCHAR(eptr) do { } while (0)  #define BACKCHAR(eptr) do { } while (0)
1020    
# Line 1086  time, run time, or study time, respectiv Line 1195  time, run time, or study time, respectiv
1195     (PCRE_STUDY_JIT_COMPILE|PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE| \     (PCRE_STUDY_JIT_COMPILE|PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE| \
1196      PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE|PCRE_STUDY_EXTRA_NEEDED)      PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE|PCRE_STUDY_EXTRA_NEEDED)
1197    
1198    #define PUBLIC_JIT_EXEC_OPTIONS \
1199       (PCRE_NO_UTF8_CHECK|PCRE_NOTBOL|PCRE_NOTEOL|PCRE_NOTEMPTY|\
1200        PCRE_NOTEMPTY_ATSTART|PCRE_PARTIAL_SOFT|PCRE_PARTIAL_HARD)
1201    
1202  /* Magic number to provide a small check against being handed junk. */  /* Magic number to provide a small check against being handed junk. */
1203    
1204  #define MAGIC_NUMBER  0x50435245UL   /* 'PCRE' */  #define MAGIC_NUMBER  0x50435245UL   /* 'PCRE' */
# Line 1095  in different endianness. */ Line 1208  in different endianness. */
1208    
1209  #define REVERSED_MAGIC_NUMBER  0x45524350UL   /* 'ERCP' */  #define REVERSED_MAGIC_NUMBER  0x45524350UL   /* 'ERCP' */
1210    
 /* Negative values for the firstchar and reqchar variables */  
   
 #define REQ_UNSET (-2)  
 #define REQ_NONE  (-1)  
   
1211  /* The maximum remaining length of subject we are prepared to search for a  /* The maximum remaining length of subject we are prepared to search for a
1212  req_byte match. */  req_byte match. */
1213    
# Line 1194  a positive value. */ Line 1302  a positive value. */
1302    
1303  /* The remaining definitions work in both environments. */  /* The remaining definitions work in both environments. */
1304    
1305    #define CHAR_NULL                   '\0'
1306  #define CHAR_HT                     '\t'  #define CHAR_HT                     '\t'
1307  #define CHAR_VT                     '\v'  #define CHAR_VT                     '\v'
1308  #define CHAR_FF                     '\f'  #define CHAR_FF                     '\f'
# Line 1463  only. */ Line 1572  only. */
1572  #define CHAR_ESC                    '\033'  #define CHAR_ESC                    '\033'
1573  #define CHAR_DEL                    '\177'  #define CHAR_DEL                    '\177'
1574    
1575    #define CHAR_NULL                   '\0'
1576  #define CHAR_SPACE                  '\040'  #define CHAR_SPACE                  '\040'
1577  #define CHAR_EXCLAMATION_MARK       '\041'  #define CHAR_EXCLAMATION_MARK       '\041'
1578  #define CHAR_QUOTATION_MARK         '\042'  #define CHAR_QUOTATION_MARK         '\042'
# Line 2312  typedef struct compile_data { Line 2422  typedef struct compile_data {
2422    int  names_found;                 /* Number of entries so far */    int  names_found;                 /* Number of entries so far */
2423    int  name_entry_size;             /* Size of each entry */    int  name_entry_size;             /* Size of each entry */
2424    int  workspace_size;              /* Size of workspace */    int  workspace_size;              /* Size of workspace */
2425    int  bracount;                    /* Count of capturing parens as we compile */    unsigned int  bracount;           /* Count of capturing parens as we compile */
2426    int  final_bracount;              /* Saved value after first pass */    int  final_bracount;              /* Saved value after first pass */
2427    int  max_lookbehind;              /* Maximum lookbehind (characters) */    int  max_lookbehind;              /* Maximum lookbehind (characters) */
2428    int  top_backref;                 /* Maximum back reference */    int  top_backref;                 /* Maximum back reference */
# Line 2342  call within the pattern; used by pcre_ex Line 2452  call within the pattern; used by pcre_ex
2452    
2453  typedef struct recursion_info {  typedef struct recursion_info {
2454    struct recursion_info *prevrec; /* Previous recursion record (or NULL) */    struct recursion_info *prevrec; /* Previous recursion record (or NULL) */
2455    int group_num;                  /* Number of group that was called */    unsigned int group_num;         /* Number of group that was called */
2456    int *offset_save;               /* Pointer to start of saved offsets */    int *offset_save;               /* Pointer to start of saved offsets */
2457    int saved_max;                  /* Number of saved offsets */    int saved_max;                  /* Number of saved offsets */
2458    PCRE_PUCHAR subject_position;   /* Position at start of recursion */    PCRE_PUCHAR subject_position;   /* Position at start of recursion */
# Line 2578  extern unsigned int      PRIV(strlen_uc) Line 2688  extern unsigned int      PRIV(strlen_uc)
2688    
2689  #endif /* COMPILE_PCRE[8|16|32] */  #endif /* COMPILE_PCRE[8|16|32] */
2690    
2691    #if defined COMPILE_PCRE8 || defined COMPILE_PCRE16
2692    
2693    #define STRCMP_UC_UC_TEST(str1, str2) STRCMP_UC_UC(str1, str2)
2694    #define STRCMP_UC_C8_TEST(str1, str2) STRCMP_UC_C8(str1, str2)
2695    
2696    #elif defined COMPILE_PCRE32
2697    
2698    extern int               PRIV(strcmp_uc_uc_utf)(const pcre_uchar *,
2699                               const pcre_uchar *);
2700    extern int               PRIV(strcmp_uc_c8_utf)(const pcre_uchar *,
2701                               const char *);
2702    
2703    #define STRCMP_UC_UC_TEST(str1, str2) \
2704      (utf ? PRIV(strcmp_uc_uc_utf)((str1), (str2)) : PRIV(strcmp_uc_uc)((str1), (str2)))
2705    #define STRCMP_UC_C8_TEST(str1, str2) \
2706      (utf ? PRIV(strcmp_uc_c8_utf)((str1), (str2)) : PRIV(strcmp_uc_c8)((str1), (str2)))
2707    
2708    #endif /* COMPILE_PCRE[8|16|32] */
2709    
2710  extern const pcre_uchar *PRIV(find_bracket)(const pcre_uchar *, BOOL, int);  extern const pcre_uchar *PRIV(find_bracket)(const pcre_uchar *, BOOL, int);
2711  extern BOOL              PRIV(is_newline)(PCRE_PUCHAR, int, PCRE_PUCHAR,  extern BOOL              PRIV(is_newline)(PCRE_PUCHAR, int, PCRE_PUCHAR,
2712                             int *, BOOL);                             int *, BOOL);
2713  extern int               PRIV(ord2utf)(pcre_uint32, pcre_uchar *);  extern unsigned int      PRIV(ord2utf)(pcre_uint32, pcre_uchar *);
2714  extern int               PRIV(valid_utf)(PCRE_PUCHAR, int, int *);  extern int               PRIV(valid_utf)(PCRE_PUCHAR, int, int *);
2715  extern BOOL              PRIV(was_newline)(PCRE_PUCHAR, int, PCRE_PUCHAR,  extern BOOL              PRIV(was_newline)(PCRE_PUCHAR, int, PCRE_PUCHAR,
2716                             int *, BOOL);                             int *, BOOL);
# Line 2590  extern BOOL              PRIV(xclass)(pc Line 2719  extern BOOL              PRIV(xclass)(pc
2719  #ifdef SUPPORT_JIT  #ifdef SUPPORT_JIT
2720  extern void              PRIV(jit_compile)(const REAL_PCRE *,  extern void              PRIV(jit_compile)(const REAL_PCRE *,
2721                             PUBL(extra) *, int);                             PUBL(extra) *, int);
2722  extern int               PRIV(jit_exec)(const REAL_PCRE *, const PUBL(extra) *,  extern int               PRIV(jit_exec)(const PUBL(extra) *,
2723                             const pcre_uchar *, int, int, int, int *, int);                             const pcre_uchar *, int, int, int, int *, int);
2724  extern void              PRIV(jit_free)(void *);  extern void              PRIV(jit_free)(void *);
2725  extern int               PRIV(jit_get_size)(void *);  extern int               PRIV(jit_get_size)(void *);
# Line 2611  extern const pcre_uint32 PRIV(ucd_casele Line 2740  extern const pcre_uint32 PRIV(ucd_casele
2740  extern const ucd_record  PRIV(ucd_records)[];  extern const ucd_record  PRIV(ucd_records)[];
2741  extern const pcre_uint8  PRIV(ucd_stage1)[];  extern const pcre_uint8  PRIV(ucd_stage1)[];
2742  extern const pcre_uint16 PRIV(ucd_stage2)[];  extern const pcre_uint16 PRIV(ucd_stage2)[];
2743  extern const int         PRIV(ucp_gentype)[];  extern const pcre_uint32 PRIV(ucp_gentype)[];
2744  extern const pcre_uint32 PRIV(ucp_gbtable)[];  extern const pcre_uint32 PRIV(ucp_gbtable)[];
2745  #ifdef SUPPORT_JIT  #ifdef SUPPORT_JIT
2746  extern const int         PRIV(ucp_typerange)[];  extern const int         PRIV(ucp_typerange)[];

Legend:
Removed from v.1075  
changed lines
  Added in v.1199

  ViewVC Help
Powered by ViewVC 1.1.5