mirrored from git://gcc.gnu.org/git/gcc.git
/
regex.c
8202 lines (6981 loc) · 253 KB
/
regex.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/* Extended regular expression matching and search library,
version 0.12.
(Implements POSIX draft P1003.2/D11.2, except for some of the
internationalization features.)
Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
2002, 2005, 2010 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, write to the Free
Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA. */
/* This file has been modified for usage in libiberty. It includes "xregex.h"
instead of <regex.h>. The "xregex.h" header file renames all external
routines with an "x" prefix so they do not collide with the native regex
routines or with other components regex routines. */
/* AIX requires this to be the first thing in the file. */
#if defined _AIX && !defined __GNUC__ && !defined REGEX_MALLOC
#pragma alloca
#endif
#undef _GNU_SOURCE
#define _GNU_SOURCE
#ifndef INSIDE_RECURSION
# ifdef HAVE_CONFIG_H
# include <config.h>
# endif
#endif
#include <ansidecl.h>
#ifndef INSIDE_RECURSION
# if defined STDC_HEADERS && !defined emacs
# include <stddef.h>
# else
/* We need this for `regex.h', and perhaps for the Emacs include files. */
# include <sys/types.h>
# endif
# define WIDE_CHAR_SUPPORT (HAVE_WCTYPE_H && HAVE_WCHAR_H && HAVE_BTOWC)
/* For platform which support the ISO C amendement 1 functionality we
support user defined character classes. */
# if defined _LIBC || WIDE_CHAR_SUPPORT
/* Solaris 2.5 has a bug: <wchar.h> must be included before <wctype.h>. */
# include <wchar.h>
# include <wctype.h>
# endif
# ifdef _LIBC
/* We have to keep the namespace clean. */
# define regfree(preg) __regfree (preg)
# define regexec(pr, st, nm, pm, ef) __regexec (pr, st, nm, pm, ef)
# define regcomp(preg, pattern, cflags) __regcomp (preg, pattern, cflags)
# define regerror(errcode, preg, errbuf, errbuf_size) \
__regerror(errcode, preg, errbuf, errbuf_size)
# define re_set_registers(bu, re, nu, st, en) \
__re_set_registers (bu, re, nu, st, en)
# define re_match_2(bufp, string1, size1, string2, size2, pos, regs, stop) \
__re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
# define re_match(bufp, string, size, pos, regs) \
__re_match (bufp, string, size, pos, regs)
# define re_search(bufp, string, size, startpos, range, regs) \
__re_search (bufp, string, size, startpos, range, regs)
# define re_compile_pattern(pattern, length, bufp) \
__re_compile_pattern (pattern, length, bufp)
# define re_set_syntax(syntax) __re_set_syntax (syntax)
# define re_search_2(bufp, st1, s1, st2, s2, startpos, range, regs, stop) \
__re_search_2 (bufp, st1, s1, st2, s2, startpos, range, regs, stop)
# define re_compile_fastmap(bufp) __re_compile_fastmap (bufp)
# define btowc __btowc
/* We are also using some library internals. */
# include <locale/localeinfo.h>
# include <locale/elem-hash.h>
# include <langinfo.h>
# include <locale/coll-lookup.h>
# endif
/* This is for other GNU distributions with internationalized messages. */
# if (HAVE_LIBINTL_H && ENABLE_NLS) || defined _LIBC
# include <libintl.h>
# ifdef _LIBC
# undef gettext
# define gettext(msgid) __dcgettext ("libc", msgid, LC_MESSAGES)
# endif
# else
# define gettext(msgid) (msgid)
# endif
# ifndef gettext_noop
/* This define is so xgettext can find the internationalizable
strings. */
# define gettext_noop(String) String
# endif
/* The `emacs' switch turns on certain matching commands
that make sense only in Emacs. */
# ifdef emacs
# include "lisp.h"
# include "buffer.h"
# include "syntax.h"
# else /* not emacs */
/* If we are not linking with Emacs proper,
we can't use the relocating allocator
even if config.h says that we can. */
# undef REL_ALLOC
# if defined STDC_HEADERS || defined _LIBC
# include <stdlib.h>
# else
char *malloc ();
char *realloc ();
# endif
/* When used in Emacs's lib-src, we need to get bzero and bcopy somehow.
If nothing else has been done, use the method below. */
# ifdef INHIBIT_STRING_HEADER
# if !(defined HAVE_BZERO && defined HAVE_BCOPY)
# if !defined bzero && !defined bcopy
# undef INHIBIT_STRING_HEADER
# endif
# endif
# endif
/* This is the normal way of making sure we have a bcopy and a bzero.
This is used in most programs--a few other programs avoid this
by defining INHIBIT_STRING_HEADER. */
# ifndef INHIBIT_STRING_HEADER
# if defined HAVE_STRING_H || defined STDC_HEADERS || defined _LIBC
# include <string.h>
# ifndef bzero
# ifndef _LIBC
# define bzero(s, n) (memset (s, '\0', n), (s))
# else
# define bzero(s, n) __bzero (s, n)
# endif
# endif
# else
# include <strings.h>
# ifndef memcmp
# define memcmp(s1, s2, n) bcmp (s1, s2, n)
# endif
# ifndef memcpy
# define memcpy(d, s, n) (bcopy (s, d, n), (d))
# endif
# endif
# endif
/* Define the syntax stuff for \<, \>, etc. */
/* This must be nonzero for the wordchar and notwordchar pattern
commands in re_match_2. */
# ifndef Sword
# define Sword 1
# endif
# ifdef SWITCH_ENUM_BUG
# define SWITCH_ENUM_CAST(x) ((int)(x))
# else
# define SWITCH_ENUM_CAST(x) (x)
# endif
# endif /* not emacs */
# if defined _LIBC || HAVE_LIMITS_H
# include <limits.h>
# endif
# ifndef MB_LEN_MAX
# define MB_LEN_MAX 1
# endif
/* Get the interface, including the syntax bits. */
# include "xregex.h" /* change for libiberty */
/* isalpha etc. are used for the character classes. */
# include <ctype.h>
/* Jim Meyering writes:
"... Some ctype macros are valid only for character codes that
isascii says are ASCII (SGI's IRIX-4.0.5 is one such system --when
using /bin/cc or gcc but without giving an ansi option). So, all
ctype uses should be through macros like ISPRINT... If
STDC_HEADERS is defined, then autoconf has verified that the ctype
macros don't need to be guarded with references to isascii. ...
Defining isascii to 1 should let any compiler worth its salt
eliminate the && through constant folding."
Solaris defines some of these symbols so we must undefine them first. */
# undef ISASCII
# if defined STDC_HEADERS || (!defined isascii && !defined HAVE_ISASCII)
# define ISASCII(c) 1
# else
# define ISASCII(c) isascii(c)
# endif
# ifdef isblank
# define ISBLANK(c) (ISASCII (c) && isblank (c))
# else
# define ISBLANK(c) ((c) == ' ' || (c) == '\t')
# endif
# ifdef isgraph
# define ISGRAPH(c) (ISASCII (c) && isgraph (c))
# else
# define ISGRAPH(c) (ISASCII (c) && isprint (c) && !isspace (c))
# endif
# undef ISPRINT
# define ISPRINT(c) (ISASCII (c) && isprint (c))
# define ISDIGIT(c) (ISASCII (c) && isdigit (c))
# define ISALNUM(c) (ISASCII (c) && isalnum (c))
# define ISALPHA(c) (ISASCII (c) && isalpha (c))
# define ISCNTRL(c) (ISASCII (c) && iscntrl (c))
# define ISLOWER(c) (ISASCII (c) && islower (c))
# define ISPUNCT(c) (ISASCII (c) && ispunct (c))
# define ISSPACE(c) (ISASCII (c) && isspace (c))
# define ISUPPER(c) (ISASCII (c) && isupper (c))
# define ISXDIGIT(c) (ISASCII (c) && isxdigit (c))
# ifdef _tolower
# define TOLOWER(c) _tolower(c)
# else
# define TOLOWER(c) tolower(c)
# endif
# ifndef NULL
# define NULL (void *)0
# endif
/* We remove any previous definition of `SIGN_EXTEND_CHAR',
since ours (we hope) works properly with all combinations of
machines, compilers, `char' and `unsigned char' argument types.
(Per Bothner suggested the basic approach.) */
# undef SIGN_EXTEND_CHAR
# if __STDC__
# define SIGN_EXTEND_CHAR(c) ((signed char) (c))
# else /* not __STDC__ */
/* As in Harbison and Steele. */
# define SIGN_EXTEND_CHAR(c) ((((unsigned char) (c)) ^ 128) - 128)
# endif
# ifndef emacs
/* How many characters in the character set. */
# define CHAR_SET_SIZE 256
# ifdef SYNTAX_TABLE
extern char *re_syntax_table;
# else /* not SYNTAX_TABLE */
static char re_syntax_table[CHAR_SET_SIZE];
static void init_syntax_once (void);
static void
init_syntax_once (void)
{
register int c;
static int done = 0;
if (done)
return;
bzero (re_syntax_table, sizeof re_syntax_table);
for (c = 0; c < CHAR_SET_SIZE; ++c)
if (ISALNUM (c))
re_syntax_table[c] = Sword;
re_syntax_table['_'] = Sword;
done = 1;
}
# endif /* not SYNTAX_TABLE */
# define SYNTAX(c) re_syntax_table[(unsigned char) (c)]
# endif /* emacs */
/* Integer type for pointers. */
# if !defined _LIBC && !defined HAVE_UINTPTR_T
typedef unsigned long int uintptr_t;
# endif
/* Should we use malloc or alloca? If REGEX_MALLOC is not defined, we
use `alloca' instead of `malloc'. This is because using malloc in
re_search* or re_match* could cause memory leaks when C-g is used in
Emacs; also, malloc is slower and causes storage fragmentation. On
the other hand, malloc is more portable, and easier to debug.
Because we sometimes use alloca, some routines have to be macros,
not functions -- `alloca'-allocated space disappears at the end of the
function it is called in. */
# ifdef REGEX_MALLOC
# define REGEX_ALLOCATE malloc
# define REGEX_REALLOCATE(source, osize, nsize) realloc (source, nsize)
# define REGEX_FREE free
# else /* not REGEX_MALLOC */
/* Emacs already defines alloca, sometimes. */
# ifndef alloca
/* Make alloca work the best possible way. */
# ifdef __GNUC__
# define alloca __builtin_alloca
# else /* not __GNUC__ */
# if HAVE_ALLOCA_H
# include <alloca.h>
# endif /* HAVE_ALLOCA_H */
# endif /* not __GNUC__ */
# endif /* not alloca */
# define REGEX_ALLOCATE alloca
/* Assumes a `char *destination' variable. */
# define REGEX_REALLOCATE(source, osize, nsize) \
(destination = (char *) alloca (nsize), \
memcpy (destination, source, osize))
/* No need to do anything to free, after alloca. */
# define REGEX_FREE(arg) ((void)0) /* Do nothing! But inhibit gcc warning. */
# endif /* not REGEX_MALLOC */
/* Define how to allocate the failure stack. */
# if defined REL_ALLOC && defined REGEX_MALLOC
# define REGEX_ALLOCATE_STACK(size) \
r_alloc (&failure_stack_ptr, (size))
# define REGEX_REALLOCATE_STACK(source, osize, nsize) \
r_re_alloc (&failure_stack_ptr, (nsize))
# define REGEX_FREE_STACK(ptr) \
r_alloc_free (&failure_stack_ptr)
# else /* not using relocating allocator */
# ifdef REGEX_MALLOC
# define REGEX_ALLOCATE_STACK malloc
# define REGEX_REALLOCATE_STACK(source, osize, nsize) realloc (source, nsize)
# define REGEX_FREE_STACK free
# else /* not REGEX_MALLOC */
# define REGEX_ALLOCATE_STACK alloca
# define REGEX_REALLOCATE_STACK(source, osize, nsize) \
REGEX_REALLOCATE (source, osize, nsize)
/* No need to explicitly free anything. */
# define REGEX_FREE_STACK(arg)
# endif /* not REGEX_MALLOC */
# endif /* not using relocating allocator */
/* True if `size1' is non-NULL and PTR is pointing anywhere inside
`string1' or just past its end. This works if PTR is NULL, which is
a good thing. */
# define FIRST_STRING_P(ptr) \
(size1 && string1 <= (ptr) && (ptr) <= string1 + size1)
/* (Re)Allocate N items of type T using malloc, or fail. */
# define TALLOC(n, t) ((t *) malloc ((n) * sizeof (t)))
# define RETALLOC(addr, n, t) ((addr) = (t *) realloc (addr, (n) * sizeof (t)))
# define RETALLOC_IF(addr, n, t) \
if (addr) RETALLOC((addr), (n), t); else (addr) = TALLOC ((n), t)
# define REGEX_TALLOC(n, t) ((t *) REGEX_ALLOCATE ((n) * sizeof (t)))
# define BYTEWIDTH 8 /* In bits. */
# define STREQ(s1, s2) ((strcmp (s1, s2) == 0))
# undef MAX
# undef MIN
# define MAX(a, b) ((a) > (b) ? (a) : (b))
# define MIN(a, b) ((a) < (b) ? (a) : (b))
typedef char boolean;
# define false 0
# define true 1
static reg_errcode_t byte_regex_compile (const char *pattern, size_t size,
reg_syntax_t syntax,
struct re_pattern_buffer *bufp);
static int byte_re_match_2_internal (struct re_pattern_buffer *bufp,
const char *string1, int size1,
const char *string2, int size2,
int pos,
struct re_registers *regs,
int stop);
static int byte_re_search_2 (struct re_pattern_buffer *bufp,
const char *string1, int size1,
const char *string2, int size2,
int startpos, int range,
struct re_registers *regs, int stop);
static int byte_re_compile_fastmap (struct re_pattern_buffer *bufp);
#ifdef MBS_SUPPORT
static reg_errcode_t wcs_regex_compile (const char *pattern, size_t size,
reg_syntax_t syntax,
struct re_pattern_buffer *bufp);
static int wcs_re_match_2_internal (struct re_pattern_buffer *bufp,
const char *cstring1, int csize1,
const char *cstring2, int csize2,
int pos,
struct re_registers *regs,
int stop,
wchar_t *string1, int size1,
wchar_t *string2, int size2,
int *mbs_offset1, int *mbs_offset2);
static int wcs_re_search_2 (struct re_pattern_buffer *bufp,
const char *string1, int size1,
const char *string2, int size2,
int startpos, int range,
struct re_registers *regs, int stop);
static int wcs_re_compile_fastmap (struct re_pattern_buffer *bufp);
#endif
/* These are the command codes that appear in compiled regular
expressions. Some opcodes are followed by argument bytes. A
command code can specify any interpretation whatsoever for its
arguments. Zero bytes may appear in the compiled regular expression. */
typedef enum
{
no_op = 0,
/* Succeed right away--no more backtracking. */
succeed,
/* Followed by one byte giving n, then by n literal bytes. */
exactn,
# ifdef MBS_SUPPORT
/* Same as exactn, but contains binary data. */
exactn_bin,
# endif
/* Matches any (more or less) character. */
anychar,
/* Matches any one char belonging to specified set. First
following byte is number of bitmap bytes. Then come bytes
for a bitmap saying which chars are in. Bits in each byte
are ordered low-bit-first. A character is in the set if its
bit is 1. A character too large to have a bit in the map is
automatically not in the set. */
/* ifdef MBS_SUPPORT, following element is length of character
classes, length of collating symbols, length of equivalence
classes, length of character ranges, and length of characters.
Next, character class element, collating symbols elements,
equivalence class elements, range elements, and character
elements follow.
See regex_compile function. */
charset,
/* Same parameters as charset, but match any character that is
not one of those specified. */
charset_not,
/* Start remembering the text that is matched, for storing in a
register. Followed by one byte with the register number, in
the range 0 to one less than the pattern buffer's re_nsub
field. Then followed by one byte with the number of groups
inner to this one. (This last has to be part of the
start_memory only because we need it in the on_failure_jump
of re_match_2.) */
start_memory,
/* Stop remembering the text that is matched and store it in a
memory register. Followed by one byte with the register
number, in the range 0 to one less than `re_nsub' in the
pattern buffer, and one byte with the number of inner groups,
just like `start_memory'. (We need the number of inner
groups here because we don't have any easy way of finding the
corresponding start_memory when we're at a stop_memory.) */
stop_memory,
/* Match a duplicate of something remembered. Followed by one
byte containing the register number. */
duplicate,
/* Fail unless at beginning of line. */
begline,
/* Fail unless at end of line. */
endline,
/* Succeeds if at beginning of buffer (if emacs) or at beginning
of string to be matched (if not). */
begbuf,
/* Analogously, for end of buffer/string. */
endbuf,
/* Followed by two byte relative address to which to jump. */
jump,
/* Same as jump, but marks the end of an alternative. */
jump_past_alt,
/* Followed by two-byte relative address of place to resume at
in case of failure. */
/* ifdef MBS_SUPPORT, the size of address is 1. */
on_failure_jump,
/* Like on_failure_jump, but pushes a placeholder instead of the
current string position when executed. */
on_failure_keep_string_jump,
/* Throw away latest failure point and then jump to following
two-byte relative address. */
/* ifdef MBS_SUPPORT, the size of address is 1. */
pop_failure_jump,
/* Change to pop_failure_jump if know won't have to backtrack to
match; otherwise change to jump. This is used to jump
back to the beginning of a repeat. If what follows this jump
clearly won't match what the repeat does, such that we can be
sure that there is no use backtracking out of repetitions
already matched, then we change it to a pop_failure_jump.
Followed by two-byte address. */
/* ifdef MBS_SUPPORT, the size of address is 1. */
maybe_pop_jump,
/* Jump to following two-byte address, and push a dummy failure
point. This failure point will be thrown away if an attempt
is made to use it for a failure. A `+' construct makes this
before the first repeat. Also used as an intermediary kind
of jump when compiling an alternative. */
/* ifdef MBS_SUPPORT, the size of address is 1. */
dummy_failure_jump,
/* Push a dummy failure point and continue. Used at the end of
alternatives. */
push_dummy_failure,
/* Followed by two-byte relative address and two-byte number n.
After matching N times, jump to the address upon failure. */
/* ifdef MBS_SUPPORT, the size of address is 1. */
succeed_n,
/* Followed by two-byte relative address, and two-byte number n.
Jump to the address N times, then fail. */
/* ifdef MBS_SUPPORT, the size of address is 1. */
jump_n,
/* Set the following two-byte relative address to the
subsequent two-byte number. The address *includes* the two
bytes of number. */
/* ifdef MBS_SUPPORT, the size of address is 1. */
set_number_at,
wordchar, /* Matches any word-constituent character. */
notwordchar, /* Matches any char that is not a word-constituent. */
wordbeg, /* Succeeds if at word beginning. */
wordend, /* Succeeds if at word end. */
wordbound, /* Succeeds if at a word boundary. */
notwordbound /* Succeeds if not at a word boundary. */
# ifdef emacs
,before_dot, /* Succeeds if before point. */
at_dot, /* Succeeds if at point. */
after_dot, /* Succeeds if after point. */
/* Matches any character whose syntax is specified. Followed by
a byte which contains a syntax code, e.g., Sword. */
syntaxspec,
/* Matches any character whose syntax is not that specified. */
notsyntaxspec
# endif /* emacs */
} re_opcode_t;
#endif /* not INSIDE_RECURSION */
#ifdef BYTE
# define CHAR_T char
# define UCHAR_T unsigned char
# define COMPILED_BUFFER_VAR bufp->buffer
# define OFFSET_ADDRESS_SIZE 2
# define PREFIX(name) byte_##name
# define ARG_PREFIX(name) name
# define PUT_CHAR(c) putchar (c)
#else
# ifdef WCHAR
# define CHAR_T wchar_t
# define UCHAR_T wchar_t
# define COMPILED_BUFFER_VAR wc_buffer
# define OFFSET_ADDRESS_SIZE 1 /* the size which STORE_NUMBER macro use */
# define CHAR_CLASS_SIZE ((__alignof__(wctype_t)+sizeof(wctype_t))/sizeof(CHAR_T)+1)
# define PREFIX(name) wcs_##name
# define ARG_PREFIX(name) c##name
/* Should we use wide stream?? */
# define PUT_CHAR(c) printf ("%C", c);
# define TRUE 1
# define FALSE 0
# else
# ifdef MBS_SUPPORT
# define WCHAR
# define INSIDE_RECURSION
# include "regex.c"
# undef INSIDE_RECURSION
# endif
# define BYTE
# define INSIDE_RECURSION
# include "regex.c"
# undef INSIDE_RECURSION
# endif
#endif
#ifdef INSIDE_RECURSION
/* Common operations on the compiled pattern. */
/* Store NUMBER in two contiguous bytes starting at DESTINATION. */
/* ifdef MBS_SUPPORT, we store NUMBER in 1 element. */
# ifdef WCHAR
# define STORE_NUMBER(destination, number) \
do { \
*(destination) = (UCHAR_T)(number); \
} while (0)
# else /* BYTE */
# define STORE_NUMBER(destination, number) \
do { \
(destination)[0] = (number) & 0377; \
(destination)[1] = (number) >> 8; \
} while (0)
# endif /* WCHAR */
/* Same as STORE_NUMBER, except increment DESTINATION to
the byte after where the number is stored. Therefore, DESTINATION
must be an lvalue. */
/* ifdef MBS_SUPPORT, we store NUMBER in 1 element. */
# define STORE_NUMBER_AND_INCR(destination, number) \
do { \
STORE_NUMBER (destination, number); \
(destination) += OFFSET_ADDRESS_SIZE; \
} while (0)
/* Put into DESTINATION a number stored in two contiguous bytes starting
at SOURCE. */
/* ifdef MBS_SUPPORT, we store NUMBER in 1 element. */
# ifdef WCHAR
# define EXTRACT_NUMBER(destination, source) \
do { \
(destination) = *(source); \
} while (0)
# else /* BYTE */
# define EXTRACT_NUMBER(destination, source) \
do { \
(destination) = *(source) & 0377; \
(destination) += SIGN_EXTEND_CHAR (*((source) + 1)) << 8; \
} while (0)
# endif
# ifdef DEBUG
static void PREFIX(extract_number) (int *dest, UCHAR_T *source);
static void
PREFIX(extract_number) (int *dest, UCHAR_T *source)
{
# ifdef WCHAR
*dest = *source;
# else /* BYTE */
int temp = SIGN_EXTEND_CHAR (*(source + 1));
*dest = *source & 0377;
*dest += temp << 8;
# endif
}
# ifndef EXTRACT_MACROS /* To debug the macros. */
# undef EXTRACT_NUMBER
# define EXTRACT_NUMBER(dest, src) PREFIX(extract_number) (&dest, src)
# endif /* not EXTRACT_MACROS */
# endif /* DEBUG */
/* Same as EXTRACT_NUMBER, except increment SOURCE to after the number.
SOURCE must be an lvalue. */
# define EXTRACT_NUMBER_AND_INCR(destination, source) \
do { \
EXTRACT_NUMBER (destination, source); \
(source) += OFFSET_ADDRESS_SIZE; \
} while (0)
# ifdef DEBUG
static void PREFIX(extract_number_and_incr) (int *destination,
UCHAR_T **source);
static void
PREFIX(extract_number_and_incr) (int *destination, UCHAR_T **source)
{
PREFIX(extract_number) (destination, *source);
*source += OFFSET_ADDRESS_SIZE;
}
# ifndef EXTRACT_MACROS
# undef EXTRACT_NUMBER_AND_INCR
# define EXTRACT_NUMBER_AND_INCR(dest, src) \
PREFIX(extract_number_and_incr) (&dest, &src)
# endif /* not EXTRACT_MACROS */
# endif /* DEBUG */
/* If DEBUG is defined, Regex prints many voluminous messages about what
it is doing (if the variable `debug' is nonzero). If linked with the
main program in `iregex.c', you can enter patterns and strings
interactively. And if linked with the main program in `main.c' and
the other test files, you can run the already-written tests. */
# ifdef DEBUG
# ifndef DEFINED_ONCE
/* We use standard I/O for debugging. */
# include <stdio.h>
/* It is useful to test things that ``must'' be true when debugging. */
# include <assert.h>
static int debug;
# define DEBUG_STATEMENT(e) e
# define DEBUG_PRINT1(x) if (debug) printf (x)
# define DEBUG_PRINT2(x1, x2) if (debug) printf (x1, x2)
# define DEBUG_PRINT3(x1, x2, x3) if (debug) printf (x1, x2, x3)
# define DEBUG_PRINT4(x1, x2, x3, x4) if (debug) printf (x1, x2, x3, x4)
# endif /* not DEFINED_ONCE */
# define DEBUG_PRINT_COMPILED_PATTERN(p, s, e) \
if (debug) PREFIX(print_partial_compiled_pattern) (s, e)
# define DEBUG_PRINT_DOUBLE_STRING(w, s1, sz1, s2, sz2) \
if (debug) PREFIX(print_double_string) (w, s1, sz1, s2, sz2)
/* Print the fastmap in human-readable form. */
# ifndef DEFINED_ONCE
void
print_fastmap (char *fastmap)
{
unsigned was_a_range = 0;
unsigned i = 0;
while (i < (1 << BYTEWIDTH))
{
if (fastmap[i++])
{
was_a_range = 0;
putchar (i - 1);
while (i < (1 << BYTEWIDTH) && fastmap[i])
{
was_a_range = 1;
i++;
}
if (was_a_range)
{
printf ("-");
putchar (i - 1);
}
}
}
putchar ('\n');
}
# endif /* not DEFINED_ONCE */
/* Print a compiled pattern string in human-readable form, starting at
the START pointer into it and ending just before the pointer END. */
void
PREFIX(print_partial_compiled_pattern) (UCHAR_T *start, UCHAR_T *end)
{
int mcnt, mcnt2;
UCHAR_T *p1;
UCHAR_T *p = start;
UCHAR_T *pend = end;
if (start == NULL)
{
printf ("(null)\n");
return;
}
/* Loop over pattern commands. */
while (p < pend)
{
# ifdef _LIBC
printf ("%td:\t", p - start);
# else
printf ("%ld:\t", (long int) (p - start));
# endif
switch ((re_opcode_t) *p++)
{
case no_op:
printf ("/no_op");
break;
case exactn:
mcnt = *p++;
printf ("/exactn/%d", mcnt);
do
{
putchar ('/');
PUT_CHAR (*p++);
}
while (--mcnt);
break;
# ifdef MBS_SUPPORT
case exactn_bin:
mcnt = *p++;
printf ("/exactn_bin/%d", mcnt);
do
{
printf("/%lx", (long int) *p++);
}
while (--mcnt);
break;
# endif /* MBS_SUPPORT */
case start_memory:
mcnt = *p++;
printf ("/start_memory/%d/%ld", mcnt, (long int) *p++);
break;
case stop_memory:
mcnt = *p++;
printf ("/stop_memory/%d/%ld", mcnt, (long int) *p++);
break;
case duplicate:
printf ("/duplicate/%ld", (long int) *p++);
break;
case anychar:
printf ("/anychar");
break;
case charset:
case charset_not:
{
# ifdef WCHAR
int i, length;
wchar_t *workp = p;
printf ("/charset [%s",
(re_opcode_t) *(workp - 1) == charset_not ? "^" : "");
p += 5;
length = *workp++; /* the length of char_classes */
for (i=0 ; i<length ; i++)
printf("[:%lx:]", (long int) *p++);
length = *workp++; /* the length of collating_symbol */
for (i=0 ; i<length ;)
{
printf("[.");
while(*p != 0)
PUT_CHAR((i++,*p++));
i++,p++;
printf(".]");
}
length = *workp++; /* the length of equivalence_class */
for (i=0 ; i<length ;)
{
printf("[=");
while(*p != 0)
PUT_CHAR((i++,*p++));
i++,p++;
printf("=]");
}
length = *workp++; /* the length of char_range */
for (i=0 ; i<length ; i++)
{
wchar_t range_start = *p++;
wchar_t range_end = *p++;
printf("%C-%C", range_start, range_end);
}
length = *workp++; /* the length of char */
for (i=0 ; i<length ; i++)
printf("%C", *p++);
putchar (']');
# else
register int c, last = -100;
register int in_range = 0;
printf ("/charset [%s",
(re_opcode_t) *(p - 1) == charset_not ? "^" : "");
assert (p + *p < pend);
for (c = 0; c < 256; c++)
if (c / 8 < *p
&& (p[1 + (c/8)] & (1 << (c % 8))))
{
/* Are we starting a range? */
if (last + 1 == c && ! in_range)
{
putchar ('-');
in_range = 1;
}
/* Have we broken a range? */
else if (last + 1 != c && in_range)
{
putchar (last);
in_range = 0;
}
if (! in_range)
putchar (c);
last = c;
}
if (in_range)
putchar (last);
putchar (']');
p += 1 + *p;
# endif /* WCHAR */
}
break;
case begline:
printf ("/begline");
break;
case endline:
printf ("/endline");
break;
case on_failure_jump:
PREFIX(extract_number_and_incr) (&mcnt, &p);
# ifdef _LIBC
printf ("/on_failure_jump to %td", p + mcnt - start);
# else
printf ("/on_failure_jump to %ld", (long int) (p + mcnt - start));
# endif
break;
case on_failure_keep_string_jump:
PREFIX(extract_number_and_incr) (&mcnt, &p);
# ifdef _LIBC
printf ("/on_failure_keep_string_jump to %td", p + mcnt - start);
# else
printf ("/on_failure_keep_string_jump to %ld",
(long int) (p + mcnt - start));
# endif
break;
case dummy_failure_jump:
PREFIX(extract_number_and_incr) (&mcnt, &p);
# ifdef _LIBC
printf ("/dummy_failure_jump to %td", p + mcnt - start);
# else
printf ("/dummy_failure_jump to %ld", (long int) (p + mcnt - start));
# endif
break;
case push_dummy_failure:
printf ("/push_dummy_failure");
break;
case maybe_pop_jump:
PREFIX(extract_number_and_incr) (&mcnt, &p);