← Back to branch summary

~ubuntu-branches/ubuntu/utopic/coreutils/utopic-proposed

« back to all changes in this revision

Viewing changes to lib/regex.h

  • Committer: Package Import Robot
  • Author(s): Colin Watson
  • Date: 2012-11-28 03:03:42 UTC
  • mfrom: (8.3.4 sid)
  • Revision ID: package-import@ubuntu.com-20121128030342-21zanj8354gas5gr
Tags: 8.20-3ubuntu1
* Resynchronise with Debian.  Remaining changes:
  - Make 'uname -i -p' return the real processor/hardware, instead of
    unknown.
  - Build-depend on gettext:any instead of on gettext, so that apt-get can
    properly resolve build-dependencies on the tool when cross-building.

Show diffs side-by-side

added added

removed removed

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