← Back to branch summary

~ubuntu-branches/ubuntu/trusty/pcre3/trusty

« back to all changes in this revision

Viewing changes to pcre.h.generic

  • Committer: Package Import Robot
  • Author(s): Mark Baker
  • Date: 2012-03-23 22:34:54 UTC
  • mfrom: (23.1.9 sid)
  • Revision ID: package-import@ubuntu.com-20120323223454-grhqqolk8a7x1h24
Tags: 1:8.30-4
* Reluctantly using an epoch, as it seems the funny version number with
  extra dots causes problems
* Bumped standard version to 3.9.3. No changes needed
* Converted to use new source format / quilt
* Put back obsolete pcre_info() API that upstream have dropped (Closes:
  #665300, #665356)
* Don't include pcregrep binary in debug package

Thanks to Elimar Riesebieter for the conversion to the new source format.

Show diffs side-by-side

added added

removed removed

Lines of Context:
pcre.h.generic
5
5
/* This is the public header file for the PCRE library, to be #included by
6
6
applications that call the PCRE functions.
7
7
 
8
 
           Copyright (c) 1997-2010 University of Cambridge
 
8
           Copyright (c) 1997-2012 University of Cambridge
9
9
 
10
10
-----------------------------------------------------------------------------
11
11
Redistribution and use in source and binary forms, with or without
42
42
/* The current PCRE version information. */
43
43
 
44
44
#define PCRE_MAJOR          8
45
 
#define PCRE_MINOR          12
 
45
#define PCRE_MINOR          30
46
46
#define PCRE_PRERELEASE     
47
 
#define PCRE_DATE           2011-01-15
 
47
#define PCRE_DATE           2012-02-04
48
48
 
49
49
/* When an application links to a PCRE DLL in Windows, the symbols that are
50
50
imported have to be identified as such. When building PCRE, the appropriate
98
98
/* Options. Some are compile-time only, some are run-time only, and some are
99
99
both, so we keep them all distinct. However, almost all the bits in the options
100
100
word are now used. In the long run, we may have to re-use some of the
101
 
compile-time only bits for runtime options, or vice versa. */
 
101
compile-time only bits for runtime options, or vice versa. In the comments
 
102
below, "compile", "exec", and "DFA exec" mean that the option is permitted to
 
103
be set for those functions; "used in" means that an option may be set only for
 
104
compile, but is subsequently referenced in exec and/or DFA exec. Any of the
 
105
compile-time options may be inspected during studying (and therefore JIT
 
106
compiling). */
102
107
 
103
108
#define PCRE_CASELESS           0x00000001  /* Compile */
104
109
#define PCRE_MULTILINE          0x00000002  /* Compile */
105
110
#define PCRE_DOTALL             0x00000004  /* Compile */
106
111
#define PCRE_EXTENDED           0x00000008  /* Compile */
107
112
#define PCRE_ANCHORED           0x00000010  /* Compile, exec, DFA exec */
108
 
#define PCRE_DOLLAR_ENDONLY     0x00000020  /* Compile */
 
113
#define PCRE_DOLLAR_ENDONLY     0x00000020  /* Compile, used in exec, DFA exec */
109
114
#define PCRE_EXTRA              0x00000040  /* Compile */
110
115
#define PCRE_NOTBOL             0x00000080  /* Exec, DFA exec */
111
116
#define PCRE_NOTEOL             0x00000100  /* Exec, DFA exec */
112
117
#define PCRE_UNGREEDY           0x00000200  /* Compile */
113
118
#define PCRE_NOTEMPTY           0x00000400  /* Exec, DFA exec */
114
 
#define PCRE_UTF8               0x00000800  /* Compile */
 
119
/* The next two are also used in exec and DFA exec */
 
120
#define PCRE_UTF8               0x00000800  /* Compile (same as PCRE_UTF16) */
 
121
#define PCRE_UTF16              0x00000800  /* Compile (same as PCRE_UTF8) */
115
122
#define PCRE_NO_AUTO_CAPTURE    0x00001000  /* Compile */
116
 
#define PCRE_NO_UTF8_CHECK      0x00002000  /* Compile, exec, DFA exec */
 
123
/* The next two are also used in exec and DFA exec */
 
124
#define PCRE_NO_UTF8_CHECK      0x00002000  /* Compile (same as PCRE_NO_UTF16_CHECK) */
 
125
#define PCRE_NO_UTF16_CHECK     0x00002000  /* Compile (same as PCRE_NO_UTF8_CHECK) */
117
126
#define PCRE_AUTO_CALLOUT       0x00004000  /* Compile */
118
127
#define PCRE_PARTIAL_SOFT       0x00008000  /* Exec, DFA exec */
119
128
#define PCRE_PARTIAL            0x00008000  /* Backwards compatible synonym */
120
129
#define PCRE_DFA_SHORTEST       0x00010000  /* DFA exec */
121
130
#define PCRE_DFA_RESTART        0x00020000  /* DFA exec */
122
 
#define PCRE_FIRSTLINE          0x00040000  /* Compile */
 
131
#define PCRE_FIRSTLINE          0x00040000  /* Compile, used in exec, DFA exec */
123
132
#define PCRE_DUPNAMES           0x00080000  /* Compile */
124
133
#define PCRE_NEWLINE_CR         0x00100000  /* Compile, exec, DFA exec */
125
134
#define PCRE_NEWLINE_LF         0x00200000  /* Compile, exec, DFA exec */
128
137
#define PCRE_NEWLINE_ANYCRLF    0x00500000  /* Compile, exec, DFA exec */
129
138
#define PCRE_BSR_ANYCRLF        0x00800000  /* Compile, exec, DFA exec */
130
139
#define PCRE_BSR_UNICODE        0x01000000  /* Compile, exec, DFA exec */
131
 
#define PCRE_JAVASCRIPT_COMPAT  0x02000000  /* Compile */
 
140
#define PCRE_JAVASCRIPT_COMPAT  0x02000000  /* Compile, used in exec */
132
141
#define PCRE_NO_START_OPTIMIZE  0x04000000  /* Compile, exec, DFA exec */
133
142
#define PCRE_NO_START_OPTIMISE  0x04000000  /* Synonym */
134
143
#define PCRE_PARTIAL_HARD       0x08000000  /* Exec, DFA exec */
135
144
#define PCRE_NOTEMPTY_ATSTART   0x10000000  /* Exec, DFA exec */
136
 
#define PCRE_UCP                0x20000000  /* Compile */
 
145
#define PCRE_UCP                0x20000000  /* Compile, used in exec, DFA exec */
137
146
 
138
147
/* Exec-time and get/set-time error codes */
139
148
 
140
 
#define PCRE_ERROR_NOMATCH         (-1)
141
 
#define PCRE_ERROR_NULL            (-2)
142
 
#define PCRE_ERROR_BADOPTION       (-3)
143
 
#define PCRE_ERROR_BADMAGIC        (-4)
144
 
#define PCRE_ERROR_UNKNOWN_OPCODE  (-5)
145
 
#define PCRE_ERROR_UNKNOWN_NODE    (-5)  /* For backward compatibility */
146
 
#define PCRE_ERROR_NOMEMORY        (-6)
147
 
#define PCRE_ERROR_NOSUBSTRING     (-7)
148
 
#define PCRE_ERROR_MATCHLIMIT      (-8)
149
 
#define PCRE_ERROR_CALLOUT         (-9)  /* Never used by PCRE itself */
150
 
#define PCRE_ERROR_BADUTF8        (-10)
151
 
#define PCRE_ERROR_BADUTF8_OFFSET (-11)
152
 
#define PCRE_ERROR_PARTIAL        (-12)
153
 
#define PCRE_ERROR_BADPARTIAL     (-13)
154
 
#define PCRE_ERROR_INTERNAL       (-14)
155
 
#define PCRE_ERROR_BADCOUNT       (-15)
156
 
#define PCRE_ERROR_DFA_UITEM      (-16)
157
 
#define PCRE_ERROR_DFA_UCOND      (-17)
158
 
#define PCRE_ERROR_DFA_UMLIMIT    (-18)
159
 
#define PCRE_ERROR_DFA_WSSIZE     (-19)
160
 
#define PCRE_ERROR_DFA_RECURSE    (-20)
161
 
#define PCRE_ERROR_RECURSIONLIMIT (-21)
162
 
#define PCRE_ERROR_NULLWSLIMIT    (-22)  /* No longer actually used */
163
 
#define PCRE_ERROR_BADNEWLINE     (-23)
164
 
#define PCRE_ERROR_BADOFFSET      (-24)
165
 
#define PCRE_ERROR_SHORTUTF8      (-25)
 
149
#define PCRE_ERROR_NOMATCH          (-1)
 
150
#define PCRE_ERROR_NULL             (-2)
 
151
#define PCRE_ERROR_BADOPTION        (-3)
 
152
#define PCRE_ERROR_BADMAGIC         (-4)
 
153
#define PCRE_ERROR_UNKNOWN_OPCODE   (-5)
 
154
#define PCRE_ERROR_UNKNOWN_NODE     (-5)  /* For backward compatibility */
 
155
#define PCRE_ERROR_NOMEMORY         (-6)
 
156
#define PCRE_ERROR_NOSUBSTRING      (-7)
 
157
#define PCRE_ERROR_MATCHLIMIT       (-8)
 
158
#define PCRE_ERROR_CALLOUT          (-9)  /* Never used by PCRE itself */
 
159
#define PCRE_ERROR_BADUTF8         (-10)  /* Same for 8/16 */
 
160
#define PCRE_ERROR_BADUTF16        (-10)  /* Same for 8/16 */
 
161
#define PCRE_ERROR_BADUTF8_OFFSET  (-11)  /* Same for 8/16 */
 
162
#define PCRE_ERROR_BADUTF16_OFFSET (-11)  /* Same for 8/16 */
 
163
#define PCRE_ERROR_PARTIAL         (-12)
 
164
#define PCRE_ERROR_BADPARTIAL      (-13)
 
165
#define PCRE_ERROR_INTERNAL        (-14)
 
166
#define PCRE_ERROR_BADCOUNT        (-15)
 
167
#define PCRE_ERROR_DFA_UITEM       (-16)
 
168
#define PCRE_ERROR_DFA_UCOND       (-17)
 
169
#define PCRE_ERROR_DFA_UMLIMIT     (-18)
 
170
#define PCRE_ERROR_DFA_WSSIZE      (-19)
 
171
#define PCRE_ERROR_DFA_RECURSE     (-20)
 
172
#define PCRE_ERROR_RECURSIONLIMIT  (-21)
 
173
#define PCRE_ERROR_NULLWSLIMIT     (-22)  /* No longer actually used */
 
174
#define PCRE_ERROR_BADNEWLINE      (-23)
 
175
#define PCRE_ERROR_BADOFFSET       (-24)
 
176
#define PCRE_ERROR_SHORTUTF8       (-25)
 
177
#define PCRE_ERROR_SHORTUTF16      (-25)  /* Same for 8/16 */
 
178
#define PCRE_ERROR_RECURSELOOP     (-26)
 
179
#define PCRE_ERROR_JIT_STACKLIMIT  (-27)
 
180
#define PCRE_ERROR_BADMODE         (-28)
 
181
#define PCRE_ERROR_BADENDIANNESS   (-29)
 
182
 
 
183
/* Specific error codes for UTF-8 validity checks */
 
184
 
 
185
#define PCRE_UTF8_ERR0               0
 
186
#define PCRE_UTF8_ERR1               1
 
187
#define PCRE_UTF8_ERR2               2
 
188
#define PCRE_UTF8_ERR3               3
 
189
#define PCRE_UTF8_ERR4               4
 
190
#define PCRE_UTF8_ERR5               5
 
191
#define PCRE_UTF8_ERR6               6
 
192
#define PCRE_UTF8_ERR7               7
 
193
#define PCRE_UTF8_ERR8               8
 
194
#define PCRE_UTF8_ERR9               9
 
195
#define PCRE_UTF8_ERR10             10
 
196
#define PCRE_UTF8_ERR11             11
 
197
#define PCRE_UTF8_ERR12             12
 
198
#define PCRE_UTF8_ERR13             13
 
199
#define PCRE_UTF8_ERR14             14
 
200
#define PCRE_UTF8_ERR15             15
 
201
#define PCRE_UTF8_ERR16             16
 
202
#define PCRE_UTF8_ERR17             17
 
203
#define PCRE_UTF8_ERR18             18
 
204
#define PCRE_UTF8_ERR19             19
 
205
#define PCRE_UTF8_ERR20             20
 
206
#define PCRE_UTF8_ERR21             21
 
207
 
 
208
/* Specific error codes for UTF-16 validity checks */
 
209
 
 
210
#define PCRE_UTF16_ERR0              0
 
211
#define PCRE_UTF16_ERR1              1
 
212
#define PCRE_UTF16_ERR2              2
 
213
#define PCRE_UTF16_ERR3              3
 
214
#define PCRE_UTF16_ERR4              4
166
215
 
167
216
/* Request types for pcre_fullinfo() */
168
217
 
183
232
#define PCRE_INFO_JCHANGED          13
184
233
#define PCRE_INFO_HASCRORLF         14
185
234
#define PCRE_INFO_MINLENGTH         15
 
235
#define PCRE_INFO_JIT               16
 
236
#define PCRE_INFO_JITSIZE           17
186
237
 
187
238
/* Request types for pcre_config(). Do not re-arrange, in order to remain
188
239
compatible. */
196
247
#define PCRE_CONFIG_UNICODE_PROPERTIES      6
197
248
#define PCRE_CONFIG_MATCH_LIMIT_RECURSION   7
198
249
#define PCRE_CONFIG_BSR                     8
199
 
 
200
 
/* Bit flags for the pcre_extra structure. Do not re-arrange or redefine
 
250
#define PCRE_CONFIG_JIT                     9
 
251
#define PCRE_CONFIG_UTF16                  10
 
252
#define PCRE_CONFIG_JITTARGET              11
 
253
 
 
254
/* Request types for pcre_study(). Do not re-arrange, in order to remain
 
255
compatible. */
 
256
 
 
257
#define PCRE_STUDY_JIT_COMPILE            0x0001
 
258
 
 
259
/* Bit flags for the pcre[16]_extra structure. Do not re-arrange or redefine
201
260
these bits, just add new ones on the end, in order to remain compatible. */
202
261
 
203
262
#define PCRE_EXTRA_STUDY_DATA             0x0001
206
265
#define PCRE_EXTRA_TABLES                 0x0008
207
266
#define PCRE_EXTRA_MATCH_LIMIT_RECURSION  0x0010
208
267
#define PCRE_EXTRA_MARK                   0x0020
 
268
#define PCRE_EXTRA_EXECUTABLE_JIT         0x0040
209
269
 
210
270
/* Types */
211
271
 
212
272
struct real_pcre;                 /* declaration; the definition is private  */
213
273
typedef struct real_pcre pcre;
214
274
 
 
275
struct real_pcre16;               /* declaration; the definition is private  */
 
276
typedef struct real_pcre16 pcre16;
 
277
 
 
278
struct real_pcre_jit_stack;       /* declaration; the definition is private  */
 
279
typedef struct real_pcre_jit_stack pcre_jit_stack;
 
280
 
 
281
struct real_pcre16_jit_stack;     /* declaration; the definition is private  */
 
282
typedef struct real_pcre16_jit_stack pcre16_jit_stack;
 
283
 
 
284
/* If PCRE is compiled with 16 bit character support, PCRE_UCHAR16 must contain
 
285
a 16 bit wide signed data type. Otherwise it can be a dummy data type since
 
286
pcre16 functions are not implemented. There is a check for this in pcre_internal.h. */
 
287
#ifndef PCRE_UCHAR16
 
288
#define PCRE_UCHAR16 unsigned short
 
289
#endif
 
290
 
 
291
#ifndef PCRE_SPTR16
 
292
#define PCRE_SPTR16 const PCRE_UCHAR16 *
 
293
#endif
 
294
 
215
295
/* When PCRE is compiled as a C++ library, the subject pointer type can be
216
296
replaced with a custom type. For conventional use, the public interface is a
217
297
const char *. */
232
312
  const unsigned char *tables;    /* Pointer to character tables */
233
313
  unsigned long int match_limit_recursion; /* Max recursive calls to match() */
234
314
  unsigned char **mark;           /* For passing back a mark pointer */
 
315
  void *executable_jit;           /* Contains a pointer to a compiled jit code */
235
316
} pcre_extra;
236
317
 
 
318
/* Same structure as above, but with 16 bit char pointers. */
 
319
 
 
320
typedef struct pcre16_extra {
 
321
  unsigned long int flags;        /* Bits for which fields are set */
 
322
  void *study_data;               /* Opaque data from pcre_study() */
 
323
  unsigned long int match_limit;  /* Maximum number of calls to match() */
 
324
  void *callout_data;             /* Data passed back in callouts */
 
325
  const unsigned char *tables;    /* Pointer to character tables */
 
326
  unsigned long int match_limit_recursion; /* Max recursive calls to match() */
 
327
  PCRE_UCHAR16 **mark;            /* For passing back a mark pointer */
 
328
  void *executable_jit;           /* Contains a pointer to a compiled jit code */
 
329
} pcre16_extra;
 
330
 
237
331
/* The structure for passing out data via the pcre_callout_function. We use a
238
332
structure so that new fields can be added on the end in future versions,
239
333
without changing the API of the function, thereby allowing old clients to work
254
348
  /* ------------------- Added for Version 1 -------------------------- */
255
349
  int          pattern_position;  /* Offset to next item in the pattern */
256
350
  int          next_item_length;  /* Length of next item in the pattern */
 
351
  /* ------------------- Added for Version 2 -------------------------- */
 
352
  const unsigned char *mark;      /* Pointer to current mark or NULL    */
257
353
  /* ------------------------------------------------------------------ */
258
354
} pcre_callout_block;
259
355
 
 
356
/* Same structure as above, but with 16 bit char pointers. */
 
357
 
 
358
typedef struct pcre16_callout_block {
 
359
  int          version;           /* Identifies version of block */
 
360
  /* ------------------------ Version 0 ------------------------------- */
 
361
  int          callout_number;    /* Number compiled into pattern */
 
362
  int         *offset_vector;     /* The offset vector */
 
363
  PCRE_SPTR16  subject;           /* The subject being matched */
 
364
  int          subject_length;    /* The length of the subject */
 
365
  int          start_match;       /* Offset to start of this match attempt */
 
366
  int          current_position;  /* Where we currently are in the subject */
 
367
  int          capture_top;       /* Max current capture */
 
368
  int          capture_last;      /* Most recently closed capture */
 
369
  void        *callout_data;      /* Data passed in with the call */
 
370
  /* ------------------- Added for Version 1 -------------------------- */
 
371
  int          pattern_position;  /* Offset to next item in the pattern */
 
372
  int          next_item_length;  /* Length of next item in the pattern */
 
373
  /* ------------------- Added for Version 2 -------------------------- */
 
374
  const PCRE_UCHAR16 *mark;       /* Pointer to current mark or NULL    */
 
375
  /* ------------------------------------------------------------------ */
 
376
} pcre16_callout_block;
 
377
 
260
378
/* Indirection for store get and free functions. These can be set to
261
379
alternative malloc/free functions if required. Special ones are used in the
262
380
non-recursive case for "frames". There is also an optional callout function
269
387
PCRE_EXP_DECL void *(*pcre_stack_malloc)(size_t);
270
388
PCRE_EXP_DECL void  (*pcre_stack_free)(void *);
271
389
PCRE_EXP_DECL int   (*pcre_callout)(pcre_callout_block *);
 
390
 
 
391
PCRE_EXP_DECL void *(*pcre16_malloc)(size_t);
 
392
PCRE_EXP_DECL void  (*pcre16_free)(void *);
 
393
PCRE_EXP_DECL void *(*pcre16_stack_malloc)(size_t);
 
394
PCRE_EXP_DECL void  (*pcre16_stack_free)(void *);
 
395
PCRE_EXP_DECL int   (*pcre16_callout)(pcre16_callout_block *);
272
396
#else   /* VPCOMPAT */
273
397
PCRE_EXP_DECL void *pcre_malloc(size_t);
274
398
PCRE_EXP_DECL void  pcre_free(void *);
275
399
PCRE_EXP_DECL void *pcre_stack_malloc(size_t);
276
400
PCRE_EXP_DECL void  pcre_stack_free(void *);
277
401
PCRE_EXP_DECL int   pcre_callout(pcre_callout_block *);
 
402
 
 
403
PCRE_EXP_DECL void *pcre16_malloc(size_t);
 
404
PCRE_EXP_DECL void  pcre16_free(void *);
 
405
PCRE_EXP_DECL void *pcre16_stack_malloc(size_t);
 
406
PCRE_EXP_DECL void  pcre16_stack_free(void *);
 
407
PCRE_EXP_DECL int   pcre16_callout(pcre16_callout_block *);
278
408
#endif  /* VPCOMPAT */
279
409
 
 
410
/* User defined callback which provides a stack just before the match starts. */
 
411
 
 
412
typedef pcre_jit_stack *(*pcre_jit_callback)(void *);
 
413
typedef pcre16_jit_stack *(*pcre16_jit_callback)(void *);
 
414
 
280
415
/* Exported PCRE functions */
281
416
 
282
417
PCRE_EXP_DECL pcre *pcre_compile(const char *, int, const char **, int *,
283
418
                  const unsigned char *);
 
419
PCRE_EXP_DECL pcre16 *pcre16_compile(PCRE_SPTR16, int, const char **, int *,
 
420
                  const unsigned char *);
284
421
PCRE_EXP_DECL pcre *pcre_compile2(const char *, int, int *, const char **,
285
422
                  int *, const unsigned char *);
 
423
PCRE_EXP_DECL pcre16 *pcre16_compile2(PCRE_SPTR16, int, int *, const char **,
 
424
                  int *, const unsigned char *);
286
425
PCRE_EXP_DECL int  pcre_config(int, void *);
 
426
PCRE_EXP_DECL int  pcre16_config(int, void *);
287
427
PCRE_EXP_DECL int  pcre_copy_named_substring(const pcre *, const char *,
288
428
                  int *, int, const char *, char *, int);
289
 
PCRE_EXP_DECL int  pcre_copy_substring(const char *, int *, int, int, char *,
290
 
                  int);
 
429
PCRE_EXP_DECL int  pcre16_copy_named_substring(const pcre16 *, PCRE_SPTR16,
 
430
                  int *, int, PCRE_SPTR16, PCRE_UCHAR16 *, int);
 
431
PCRE_EXP_DECL int  pcre_copy_substring(const char *, int *, int, int,
 
432
                  char *, int);
 
433
PCRE_EXP_DECL int  pcre16_copy_substring(PCRE_SPTR16, int *, int, int,
 
434
                  PCRE_UCHAR16 *, int);
291
435
PCRE_EXP_DECL int  pcre_dfa_exec(const pcre *, const pcre_extra *,
292
436
                  const char *, int, int, int, int *, int , int *, int);
 
437
PCRE_EXP_DECL int  pcre16_dfa_exec(const pcre16 *, const pcre16_extra *,
 
438
                  PCRE_SPTR16, int, int, int, int *, int , int *, int);
293
439
PCRE_EXP_DECL int  pcre_exec(const pcre *, const pcre_extra *, PCRE_SPTR,
294
440
                   int, int, int, int *, int);
 
441
PCRE_EXP_DECL int  pcre16_exec(const pcre16 *, const pcre16_extra *,
 
442
                   PCRE_SPTR16, int, int, int, int *, int);
295
443
PCRE_EXP_DECL void pcre_free_substring(const char *);
 
444
PCRE_EXP_DECL void pcre16_free_substring(PCRE_SPTR16);
296
445
PCRE_EXP_DECL void pcre_free_substring_list(const char **);
 
446
PCRE_EXP_DECL void pcre16_free_substring_list(PCRE_SPTR16 *);
297
447
PCRE_EXP_DECL int  pcre_fullinfo(const pcre *, const pcre_extra *, int,
298
448
                  void *);
 
449
PCRE_EXP_DECL int  pcre16_fullinfo(const pcre16 *, const pcre16_extra *, int,
 
450
                  void *);
299
451
PCRE_EXP_DECL int  pcre_get_named_substring(const pcre *, const char *,
300
452
                  int *, int, const char *, const char **);
 
453
PCRE_EXP_DECL int  pcre16_get_named_substring(const pcre16 *, PCRE_SPTR16,
 
454
                  int *, int, PCRE_SPTR16, PCRE_SPTR16 *);
301
455
PCRE_EXP_DECL int  pcre_get_stringnumber(const pcre *, const char *);
 
456
PCRE_EXP_DECL int  pcre16_get_stringnumber(const pcre16 *, PCRE_SPTR16);
302
457
PCRE_EXP_DECL int  pcre_get_stringtable_entries(const pcre *, const char *,
303
458
                  char **, char **);
 
459
PCRE_EXP_DECL int  pcre16_get_stringtable_entries(const pcre16 *, PCRE_SPTR16,
 
460
                  PCRE_UCHAR16 **, PCRE_UCHAR16 **);
304
461
PCRE_EXP_DECL int  pcre_get_substring(const char *, int *, int, int,
305
462
                  const char **);
 
463
PCRE_EXP_DECL int  pcre16_get_substring(PCRE_SPTR16, int *, int, int,
 
464
                  PCRE_SPTR16 *);
306
465
PCRE_EXP_DECL int  pcre_get_substring_list(const char *, int *, int,
307
466
                  const char ***);
308
 
PCRE_EXP_DECL int  pcre_info(const pcre *, int *, int *);
 
467
PCRE_EXP_DECL int  pcre16_get_substring_list(PCRE_SPTR16, int *, int,
 
468
                  PCRE_SPTR16 **);
309
469
PCRE_EXP_DECL const unsigned char *pcre_maketables(void);
 
470
PCRE_EXP_DECL const unsigned char *pcre16_maketables(void);
310
471
PCRE_EXP_DECL int  pcre_refcount(pcre *, int);
 
472
PCRE_EXP_DECL int  pcre16_refcount(pcre16 *, int);
311
473
PCRE_EXP_DECL pcre_extra *pcre_study(const pcre *, int, const char **);
 
474
PCRE_EXP_DECL pcre16_extra *pcre16_study(const pcre16 *, int, const char **);
 
475
PCRE_EXP_DECL void pcre_free_study(pcre_extra *);
 
476
PCRE_EXP_DECL void pcre16_free_study(pcre16_extra *);
312
477
PCRE_EXP_DECL const char *pcre_version(void);
 
478
PCRE_EXP_DECL const char *pcre16_version(void);
 
479
 
 
480
/* Utility functions for byte order swaps. */
 
481
PCRE_EXP_DECL int  pcre_pattern_to_host_byte_order(pcre *, pcre_extra *,
 
482
                  const unsigned char *);
 
483
PCRE_EXP_DECL int  pcre16_pattern_to_host_byte_order(pcre16 *, pcre16_extra *,
 
484
                  const unsigned char *);
 
485
PCRE_EXP_DECL int  pcre16_utf16_to_host_byte_order(PCRE_UCHAR16 *,
 
486
                  PCRE_SPTR16, int, int *, int);
 
487
 
 
488
/* JIT compiler related functions. */
 
489
 
 
490
PCRE_EXP_DECL pcre_jit_stack *pcre_jit_stack_alloc(int, int);
 
491
PCRE_EXP_DECL pcre16_jit_stack *pcre16_jit_stack_alloc(int, int);
 
492
PCRE_EXP_DECL void pcre_jit_stack_free(pcre_jit_stack *);
 
493
PCRE_EXP_DECL void pcre16_jit_stack_free(pcre16_jit_stack *);
 
494
PCRE_EXP_DECL void pcre_assign_jit_stack(pcre_extra *,
 
495
                  pcre_jit_callback, void *);
 
496
PCRE_EXP_DECL void pcre16_assign_jit_stack(pcre16_extra *,
 
497
                  pcre16_jit_callback, void *);
313
498
 
314
499
#ifdef __cplusplus
315
500
}  /* extern "C" */