← Back to branch summary

~ubuntu-branches/ubuntu/raring/man-db/raring

« back to all changes in this revision

Viewing changes to gnulib/lib/regex.h

  • Committer: Package Import Robot
  • Author(s): Colin Watson
  • Date: 2012-06-18 22:56:56 UTC
  • mfrom: (1.2.11)
  • Revision ID: package-import@ubuntu.com-20120618225656-6ecxcastua6vmgxs
Tags: 2.6.2-1
https://launchpad.net/bugs/927028
http://bugs.debian.org/672661
https://launchpad.net/bugs/1001189
* New upstream release:
  - Optimise apropos when given many arguments (LP: #927028).
  - apropos prints an error message and returns non-zero when it finds no
    matches (closes: #672661).
  - Avoid fatal errors when opening a 64-bit GDBM database from a 32-bit
    process (LP: #1001189).
* Configure with --with-xz=xz --with-lzip=lzip.
* Adjust debian/watch to track .tar.xz releases.
* Convert debian/copyright to copyright-format 1.0.
* Override hardening-no-fortify-functions Lintian warning for
  /usr/bin/manpath, as a false positive.

Show diffs side-by-side

added added

removed removed

Lines of Context:
gnulib/lib/regex.h
1
1
/* Definitions for data structures and routines for the regular
2
2
   expression library.
3
 
   Copyright (C) 1985, 1989-1993, 1995-1998, 2000-2003, 2005-2006, 2009-2011
 
3
   Copyright (C) 1985, 1989-1993, 1995-1998, 2000-2003, 2005-2012
4
4
   Free Software Foundation, Inc.
5
5
   This file is part of the GNU C Library.
6
6
 
15
15
   GNU General Public License for more details.
16
16
 
17
17
   You should have received a copy of the GNU General Public License along
18
 
   with this program; if not, write to the Free Software Foundation,
19
 
   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
 
18
   with this program; if not, see <http://www.gnu.org/licenses/>.  */
20
19
 
21
20
#ifndef _REGEX_H
22
21
#define _REGEX_H 1
28
27
extern "C" {
29
28
#endif
30
29
 
31
 
/* Define __USE_GNU_REGEX to declare GNU extensions that violate the
 
30
/* Define __USE_GNU to declare GNU extensions that violate the
32
31
   POSIX name space rules.  */
33
 
#undef __USE_GNU_REGEX
34
 
#if (defined _GNU_SOURCE                                        \
35
 
     || (!defined _POSIX_C_SOURCE && !defined _POSIX_SOURCE     \
36
 
         && !defined _XOPEN_SOURCE))
37
 
# define __USE_GNU_REGEX 1
 
32
#ifdef _GNU_SOURCE
 
33
# define __USE_GNU 1
38
34
#endif
39
35
 
40
36
#ifdef _REGEX_LARGE_OFFSETS
45
41
   supported within glibc itself, and glibc users should not define
46
42
   _REGEX_LARGE_OFFSETS.  */
47
43
 
48
 
/* The type of the offset of a byte within a string.
49
 
   For historical reasons POSIX 1003.1-2004 requires that regoff_t be
50
 
   at least as wide as off_t.  However, many common POSIX platforms set
51
 
   regoff_t to the more-sensible ssize_t and the Open Group has
52
 
   signalled its intention to change the requirement to be that
53
 
   regoff_t be at least as wide as ptrdiff_t and ssize_t; see XBD ERN
54
 
   60 (2005-08-25).  We don't know of any hosts where ssize_t or
55
 
   ptrdiff_t is wider than ssize_t, so ssize_t is safe.  */
56
 
typedef ssize_t regoff_t;
57
 
 
58
44
/* The type of nonnegative object indexes.  Traditionally, GNU regex
59
45
   uses 'int' for these.  Code that uses __re_idx_t should work
60
46
   regardless of whether the type is signed.  */
69
55
 
70
56
#else
71
57
 
72
 
/* Use types that are binary-compatible with the traditional GNU regex
73
 
   implementation, which mishandles strings longer than INT_MAX.  */
74
 
 
75
 
typedef int regoff_t;
 
58
/* The traditional GNU regex implementation mishandles strings longer
 
59
   than INT_MAX.  */
76
60
typedef int __re_idx_t;
77
61
typedef unsigned int __re_size_t;
78
62
typedef unsigned long int __re_long_size_t;
93
77
   add or remove a bit, only one other definition need change.  */
94
78
typedef unsigned long int reg_syntax_t;
95
79
 
96
 
#ifdef __USE_GNU_REGEX
97
 
 
 
80
#ifdef __USE_GNU
98
81
/* If this bit is not set, then \ inside a bracket expression is literal.
99
82
   If set, then such a \ quotes the following character.  */
100
83
# define RE_BACKSLASH_ESCAPE_IN_LISTS ((unsigned long int) 1)
161
144
   If not set, newline is literal.  */
162
145
# define RE_NEWLINE_ALT (RE_LIMITED_OPS << 1)
163
146
 
164
 
/* If this bit is set, then `{...}' defines an interval, and \{ and \}
 
147
/* If this bit is set, then '{...}' defines an interval, and \{ and \}
165
148
     are literals.
166
 
  If not set, then `\{...\}' defines an interval.  */
 
149
  If not set, then '\{...\}' defines an interval.  */
167
150
# define RE_NO_BK_BRACES (RE_NEWLINE_ALT << 1)
168
151
 
169
152
/* If this bit is set, (...) defines a group, and \( and \) are literals.
225
208
/* If this bit is set, then no_sub will be set to 1 during
226
209
   re_compile_pattern.  */
227
210
# define RE_NO_SUB (RE_CONTEXT_INVALID_DUP << 1)
228
 
 
229
 
#endif /* defined __USE_GNU_REGEX */
 
211
#endif
230
212
 
231
213
/* This global variable defines the particular regexp syntax to use (for
232
214
   some interfaces).  When a regexp is compiled, the syntax used is
234
216
   already-compiled regexps.  */
235
217
extern reg_syntax_t re_syntax_options;
236
218
 
237
 
#ifdef __USE_GNU_REGEX
 
219
#ifdef __USE_GNU
238
220
/* Define combinations of the above bits for the standard possibilities.
239
221
   (The [[[ comments delimit what gets put into the Texinfo file, so
240
222
   don't delete them!)  */
246
228
   | RE_NO_BK_PARENS              | RE_NO_BK_REFS                       \
247
229
   | RE_NO_BK_VBAR                | RE_NO_EMPTY_RANGES                  \
248
230
   | RE_DOT_NEWLINE               | RE_CONTEXT_INDEP_ANCHORS            \
 
231
   | RE_CHAR_CLASSES                                                    \
249
232
   | RE_UNMATCHED_RIGHT_PAREN_ORD | RE_NO_GNU_OPS)
250
233
 
251
234
# define RE_SYNTAX_GNU_AWK                                              \
252
 
  ((RE_SYNTAX_POSIX_EXTENDED | RE_BACKSLASH_ESCAPE_IN_LISTS | RE_DEBUG) \
253
 
   & ~(RE_DOT_NOT_NULL | RE_INTERVALS | RE_CONTEXT_INDEP_OPS            \
254
 
       | RE_CONTEXT_INVALID_OPS ))
 
235
  ((RE_SYNTAX_POSIX_EXTENDED | RE_BACKSLASH_ESCAPE_IN_LISTS             \
 
236
    | RE_INVALID_INTERVAL_ORD)                                          \
 
237
   & ~(RE_DOT_NOT_NULL | RE_CONTEXT_INDEP_OPS                           \
 
238
      | RE_CONTEXT_INVALID_OPS ))
255
239
 
256
240
# define RE_SYNTAX_POSIX_AWK                                            \
257
241
  (RE_SYNTAX_POSIX_EXTENDED | RE_BACKSLASH_ESCAPE_IN_LISTS              \
258
 
   | RE_INTERVALS           | RE_NO_GNU_OPS)
 
242
   | RE_INTERVALS           | RE_NO_GNU_OPS                             \
 
243
   | RE_INVALID_INTERVAL_ORD)
259
244
 
260
245
# define RE_SYNTAX_GREP                                                 \
261
246
  (RE_BK_PLUS_QM              | RE_CHAR_CLASSES                         \
306
291
   | RE_NO_BK_VBAR          | RE_UNMATCHED_RIGHT_PAREN_ORD)
307
292
/* [[[end syntaxes]]] */
308
293
 
309
 
#endif /* defined __USE_GNU_REGEX */
310
 
 
311
 
#ifdef __USE_GNU_REGEX
312
 
 
313
294
/* Maximum number of duplicates an interval can allow.  POSIX-conforming
314
295
   systems might define this in <limits.h>, but we want our
315
296
   value, so remove any previous define.  */
 
297
# ifdef _REGEX_INCLUDE_LIMITS_H
 
298
#  include <limits.h>
 
299
# endif
316
300
# ifdef RE_DUP_MAX
317
301
#  undef RE_DUP_MAX
318
302
# endif
320
304
/* RE_DUP_MAX is 2**15 - 1 because an earlier implementation stored
321
305
   the counter as a 2-byte signed integer.  This is no longer true, so
322
306
   RE_DUP_MAX could be increased to (INT_MAX / 10 - 1), or to
323
 
   ((SIZE_MAX - 2) / 10 - 1) if _REGEX_LARGE_OFFSETS is defined.
 
307
   ((SIZE_MAX - 9) / 10) if _REGEX_LARGE_OFFSETS is defined.
324
308
   However, there would be a huge performance problem if someone
325
309
   actually used a pattern like a\{214748363\}, so RE_DUP_MAX retains
326
310
   its historical value.  */
327
311
# define RE_DUP_MAX (0x7fff)
328
 
 
329
 
#endif /* defined __USE_GNU_REGEX */
330
 
 
331
 
 
332
 
/* POSIX `cflags' bits (i.e., information for `regcomp').  */
 
312
#endif
 
313
 
 
314
 
 
315
/* POSIX 'cflags' bits (i.e., information for 'regcomp').  */
333
316
 
334
317
/* If this bit is set, then use extended regular expression syntax.
335
318
   If not set, then use basic regular expression syntax.  */
349
332
#define REG_NOSUB (1 << 3)
350
333
 
351
334
 
352
 
/* POSIX `eflags' bits (i.e., information for regexec).  */
 
335
/* POSIX 'eflags' bits (i.e., information for regexec).  */
353
336
 
354
337
/* If this bit is set, then the beginning-of-line operator doesn't match
355
338
     the beginning of the string (presumably because it's not the
367
350
 
368
351
 
369
352
/* If any error codes are removed, changed, or added, update the
370
 
   `__re_error_msgid' table in regcomp.c.  */
 
353
   '__re_error_msgid' table in regcomp.c.  */
371
354
 
372
355
typedef enum
373
356
{
392
375
 
393
376
  /* Error codes we've added.  */
394
377
  _REG_EEND,            /* Premature end.  */
395
 
  _REG_ESIZE,           /* Compiled pattern bigger than 2^16 bytes.  */
 
378
  _REG_ESIZE,           /* Too large (e.g., repeat count too large).  */
396
379
  _REG_ERPAREN          /* Unmatched ) or \); not returned from regcomp.  */
397
380
} reg_errcode_t;
398
381
 
399
 
#ifdef _XOPEN_SOURCE
 
382
#if defined _XOPEN_SOURCE || defined __USE_XOPEN2K
400
383
# define REG_ENOSYS     _REG_ENOSYS
401
384
#endif
402
385
#define REG_NOERROR     _REG_NOERROR
417
400
#define REG_ESIZE       _REG_ESIZE
418
401
#define REG_ERPAREN     _REG_ERPAREN
419
402
 
420
 
/* struct re_pattern_buffer normally uses member names like `buffer'
421
 
   that POSIX does not allow.  In POSIX mode these members have names
422
 
   with leading `re_' (e.g., `re_buffer').  */
423
 
#ifdef __USE_GNU_REGEX
424
 
# define _REG_RE_NAME(id) id
425
 
# define _REG_RM_NAME(id) id
426
 
#else
427
 
# define _REG_RE_NAME(id) re_##id
428
 
# define _REG_RM_NAME(id) rm_##id
429
 
#endif
430
 
 
431
 
/* The user can specify the type of the re_translate member by
432
 
   defining the macro RE_TRANSLATE_TYPE, which defaults to unsigned
433
 
   char *.  This pollutes the POSIX name space, so in POSIX mode just
434
 
   use unsigned char *.  */
435
 
#ifdef __USE_GNU_REGEX
436
 
# ifndef RE_TRANSLATE_TYPE
437
 
#  define RE_TRANSLATE_TYPE unsigned char *
438
 
# endif
439
 
# define REG_TRANSLATE_TYPE RE_TRANSLATE_TYPE
440
 
#else
441
 
# define REG_TRANSLATE_TYPE unsigned char *
442
 
#endif
443
 
 
444
403
/* This data structure represents a compiled pattern.  Before calling
445
 
   the pattern compiler, the fields `buffer', `allocated', `fastmap',
446
 
   `translate', and `no_sub' can be set.  After the pattern has been
447
 
   compiled, the `re_nsub' field is available.  All other fields are
448
 
   private to the regex routines.  */
 
404
   the pattern compiler, the fields 'buffer', 'allocated', 'fastmap',
 
405
   and 'translate' can be set.  After the pattern has been compiled,
 
406
   the fields 're_nsub', 'not_bol' and 'not_eol' are available.  All
 
407
   other fields are private to the regex routines.  */
 
408
 
 
409
#ifndef RE_TRANSLATE_TYPE
 
410
# define __RE_TRANSLATE_TYPE unsigned char *
 
411
# ifdef __USE_GNU
 
412
#  define RE_TRANSLATE_TYPE __RE_TRANSLATE_TYPE
 
413
# endif
 
414
#endif
 
415
 
 
416
#ifdef __USE_GNU
 
417
# define __REPB_PREFIX(name) name
 
418
#else
 
419
# define __REPB_PREFIX(name) __##name
 
420
#endif
449
421
 
450
422
struct re_pattern_buffer
451
423
{
452
424
  /* Space that holds the compiled pattern.  It is declared as
453
 
     `unsigned char *' because its elements are sometimes used as
 
425
     'unsigned char *' because its elements are sometimes used as
454
426
     array indexes.  */
455
 
  unsigned char *_REG_RE_NAME (buffer);
456
 
 
457
 
  /* Number of bytes to which `buffer' points.  */
458
 
  __re_long_size_t _REG_RE_NAME (allocated);
459
 
 
460
 
  /* Number of bytes actually used in `buffer'.  */
461
 
  __re_long_size_t _REG_RE_NAME (used);
 
427
  unsigned char *__REPB_PREFIX(buffer);
 
428
 
 
429
  /* Number of bytes to which 'buffer' points.  */
 
430
  __re_long_size_t __REPB_PREFIX(allocated);
 
431
 
 
432
  /* Number of bytes actually used in 'buffer'.  */
 
433
  __re_long_size_t __REPB_PREFIX(used);
462
434
 
463
435
  /* Syntax setting with which the pattern was compiled.  */
464
 
  reg_syntax_t _REG_RE_NAME (syntax);
 
436
  reg_syntax_t __REPB_PREFIX(syntax);
465
437
 
466
438
  /* Pointer to a fastmap, if any, otherwise zero.  re_search uses the
467
439
     fastmap, if there is one, to skip over impossible starting points
468
440
     for matches.  */
469
 
  char *_REG_RE_NAME (fastmap);
 
441
  char *__REPB_PREFIX(fastmap);
470
442
 
471
443
  /* Either a translate table to apply to all characters before
472
444
     comparing them, or zero for no translation.  The translation is
473
445
     applied to a pattern when it is compiled and to a string when it
474
446
     is matched.  */
475
 
  REG_TRANSLATE_TYPE _REG_RE_NAME (translate);
 
447
  __RE_TRANSLATE_TYPE __REPB_PREFIX(translate);
476
448
 
477
449
  /* Number of subexpressions found by the compiler.  */
478
450
  size_t re_nsub;
479
451
 
480
452
  /* Zero if this pattern cannot match the empty string, one else.
481
 
     Well, in truth it's used only in `re_search_2', to see whether or
 
453
     Well, in truth it's used only in 're_search_2', to see whether or
482
454
     not we should use the fastmap, so we don't set this absolutely
483
 
     perfectly; see `re_compile_fastmap' (the `duplicate' case).  */
484
 
  unsigned int _REG_RE_NAME (can_be_null) : 1;
 
455
     perfectly; see 're_compile_fastmap' (the "duplicate" case).  */
 
456
  unsigned __REPB_PREFIX(can_be_null) : 1;
485
457
 
486
 
  /* If REGS_UNALLOCATED, allocate space in the `regs' structure
487
 
     for `max (RE_NREGS, re_nsub + 1)' groups.
 
458
  /* If REGS_UNALLOCATED, allocate space in the 'regs' structure
 
459
     for 'max (RE_NREGS, re_nsub + 1)' groups.
488
460
     If REGS_REALLOCATE, reallocate space if necessary.
489
461
     If REGS_FIXED, use what's there.  */
490
 
#ifdef __USE_GNU_REGEX
 
462
#ifdef __USE_GNU
491
463
# define REGS_UNALLOCATED 0
492
464
# define REGS_REALLOCATE 1
493
465
# define REGS_FIXED 2
494
466
#endif
495
 
  unsigned int _REG_RE_NAME (regs_allocated) : 2;
496
 
 
497
 
  /* Set to zero when `re_compile_pattern' compiles a pattern; set to
498
 
     one by `re_compile_fastmap' if it updates the fastmap.  */
499
 
  unsigned int _REG_RE_NAME (fastmap_accurate) : 1;
500
 
 
501
 
  /* If set, `re_match_2' does not return information about
 
467
  unsigned __REPB_PREFIX(regs_allocated) : 2;
 
468
 
 
469
  /* Set to zero when 're_compile_pattern' compiles a pattern; set to
 
470
     one by 're_compile_fastmap' if it updates the fastmap.  */
 
471
  unsigned __REPB_PREFIX(fastmap_accurate) : 1;
 
472
 
 
473
  /* If set, 're_match_2' does not return information about
502
474
     subexpressions.  */
503
 
  unsigned int _REG_RE_NAME (no_sub) : 1;
 
475
  unsigned __REPB_PREFIX(no_sub) : 1;
504
476
 
505
477
  /* If set, a beginning-of-line anchor doesn't match at the beginning
506
478
     of the string.  */
507
 
  unsigned int _REG_RE_NAME (not_bol) : 1;
 
479
  unsigned __REPB_PREFIX(not_bol) : 1;
508
480
 
509
481
  /* Similarly for an end-of-line anchor.  */
510
 
  unsigned int _REG_RE_NAME (not_eol) : 1;
 
482
  unsigned __REPB_PREFIX(not_eol) : 1;
511
483
 
512
484
  /* If true, an anchor at a newline matches.  */
513
 
  unsigned int _REG_RE_NAME (newline_anchor) : 1;
514
 
 
515
 
/* [[[end pattern_buffer]]] */
 
485
  unsigned __REPB_PREFIX(newline_anchor) : 1;
516
486
};
517
487
 
518
488
typedef struct re_pattern_buffer regex_t;
519
489
 
 
490
/* Type for byte offsets within the string.  POSIX mandates this.  */
 
491
#ifdef _REGEX_LARGE_OFFSETS
 
492
/* POSIX 1003.1-2008 requires that regoff_t be at least as wide as
 
493
   ptrdiff_t and ssize_t.  We don't know of any hosts where ptrdiff_t
 
494
   is wider than ssize_t, so ssize_t is safe.  */
 
495
typedef ssize_t regoff_t;
 
496
#else
 
497
/* The traditional GNU regex implementation mishandles strings longer
 
498
   than INT_MAX.  */
 
499
typedef int regoff_t;
 
500
#endif
 
501
 
 
502
 
 
503
#ifdef __USE_GNU
520
504
/* This is the structure we store register match data in.  See
521
505
   regex.texinfo for a full description of what registers match.  */
522
506
struct re_registers
523
507
{
524
 
  __re_size_t _REG_RM_NAME (num_regs);
525
 
  regoff_t *_REG_RM_NAME (start);
526
 
  regoff_t *_REG_RM_NAME (end);
 
508
  __re_size_t num_regs;
 
509
  regoff_t *start;
 
510
  regoff_t *end;
527
511
};
528
512
 
529
513
 
530
 
/* If `regs_allocated' is REGS_UNALLOCATED in the pattern buffer,
531
 
   `re_match_2' returns information about at least this many registers
532
 
   the first time a `regs' structure is passed.  */
533
 
#if !defined RE_NREGS && defined __USE_GNU_REGEX
534
 
# define RE_NREGS 30
 
514
/* If 'regs_allocated' is REGS_UNALLOCATED in the pattern buffer,
 
515
   're_match_2' returns information about at least this many registers
 
516
   the first time a 'regs' structure is passed.  */
 
517
# ifndef RE_NREGS
 
518
#  define RE_NREGS 30
 
519
# endif
535
520
#endif
536
521
 
537
522
 
538
523
/* POSIX specification for registers.  Aside from the different names than
539
 
   `re_registers', POSIX uses an array of structures, instead of a
 
524
   're_registers', POSIX uses an array of structures, instead of a
540
525
   structure of arrays.  */
541
526
typedef struct
542
527
{
546
531
 
547
532
/* Declarations for routines.  */
548
533
 
 
534
#ifdef __USE_GNU
549
535
/* Sets the current default syntax to SYNTAX, and return the old syntax.
550
 
   You can also simply assign to the `re_syntax_options' variable.  */
 
536
   You can also simply assign to the 're_syntax_options' variable.  */
551
537
extern reg_syntax_t re_set_syntax (reg_syntax_t __syntax);
552
538
 
553
539
/* Compile the regular expression PATTERN, with length LENGTH
554
 
   and syntax given by the global `re_syntax_options', into the buffer
555
 
   BUFFER.  Return NULL if successful, and an error string if not.  */
 
540
   and syntax given by the global 're_syntax_options', into the buffer
 
541
   BUFFER.  Return NULL if successful, and an error string if not.
 
542
 
 
543
   To free the allocated storage, you must call 'regfree' on BUFFER.
 
544
   Note that the translate table must either have been initialised by
 
545
   'regcomp', with a malloc'ed value, or set to NULL before calling
 
546
   'regfree'.  */
556
547
extern const char *re_compile_pattern (const char *__pattern, size_t __length,
557
548
                                       struct re_pattern_buffer *__buffer);
558
549
 
574
565
                           struct re_registers *__regs);
575
566
 
576
567
 
577
 
/* Like `re_search', but search in the concatenation of STRING1 and
 
568
/* Like 're_search', but search in the concatenation of STRING1 and
578
569
   STRING2.  Also, stop searching at index START + STOP.  */
579
570
extern regoff_t re_search_2 (struct re_pattern_buffer *__buffer,
580
571
                             const char *__string1, __re_idx_t __length1,
584
575
                             __re_idx_t __stop);
585
576
 
586
577
 
587
 
/* Like `re_search', but return how many characters in STRING the regexp
 
578
/* Like 're_search', but return how many characters in STRING the regexp
588
579
   in BUFFER matched, starting at position START.  */
589
580
extern regoff_t re_match (struct re_pattern_buffer *__buffer,
590
581
                          const char *__string, __re_idx_t __length,
591
582
                          __re_idx_t __start, struct re_registers *__regs);
592
583
 
593
584
 
594
 
/* Relates to `re_match' as `re_search_2' relates to `re_search'.  */
 
585
/* Relates to 're_match' as 're_search_2' relates to 're_search'.  */
595
586
extern regoff_t re_match_2 (struct re_pattern_buffer *__buffer,
596
587
                            const char *__string1, __re_idx_t __length1,
597
588
                            const char *__string2, __re_idx_t __length2,
602
593
/* Set REGS to hold NUM_REGS registers, storing them in STARTS and
603
594
   ENDS.  Subsequent matches using BUFFER and REGS will use this memory
604
595
   for recording register information.  STARTS and ENDS must be
605
 
   allocated with malloc, and must each be at least `NUM_REGS * sizeof
 
596
   allocated with malloc, and must each be at least 'NUM_REGS * sizeof
606
597
   (regoff_t)' bytes long.
607
598
 
608
599
   If NUM_REGS == 0, then subsequent matches should allocate their own
609
600
   register data.
610
601
 
611
602
   Unless this function is called, the first search or match using
612
 
   BUFFER will allocate its own register data, without freeing the old
613
 
   data.  */
 
603
   BUFFER will allocate its own register data, without
 
604
   freeing the old data.  */
614
605
extern void re_set_registers (struct re_pattern_buffer *__buffer,
615
606
                              struct re_registers *__regs,
616
607
                              __re_size_t __num_regs,
617
608
                              regoff_t *__starts, regoff_t *__ends);
 
609
#endif  /* Use GNU */
618
610
 
619
 
#if defined _REGEX_RE_COMP || defined _LIBC
 
611
#if defined _REGEX_RE_COMP || (defined _LIBC && defined __USE_BSD)
620
612
# ifndef _CRAY
621
613
/* 4.2 bsd compatibility.  */
622
614
extern char *re_comp (const char *);