diff options
| -rw-r--r-- | ChangeLog | 34 | ||||
| -rwxr-xr-x | configure | 26 | ||||
| -rw-r--r-- | libintl.h | 1 | ||||
| -rw-r--r-- | locale/Makefile | 34 | ||||
| -rw-r--r-- | locale/categories.def | 4 | ||||
| -rw-r--r-- | locale/charmap.c | 524 | ||||
| -rw-r--r-- | locale/collate.c | 212 | ||||
| -rw-r--r-- | locale/config.h | 45 | ||||
| -rw-r--r-- | locale/ctype.c | 817 | ||||
| -rw-r--r-- | locale/ctypedump.c | 163 | ||||
| -rw-r--r-- | locale/hash.c | 254 | ||||
| -rw-r--r-- | locale/hash.h | 50 | ||||
| -rw-r--r-- | locale/iso-4217.def | 36 | ||||
| -rw-r--r-- | locale/keyword.gperf | 77 | ||||
| -rw-r--r-- | locale/keyword.h | 180 | ||||
| -rw-r--r-- | locale/langinfo.h | 4 | ||||
| -rw-r--r-- | locale/libintl.h | 77 | ||||
| -rw-r--r-- | locale/loadlocale.c | 9 | ||||
| -rw-r--r-- | locale/locale.c | 538 | ||||
| -rw-r--r-- | locale/localedef.c | 261 | ||||
| -rw-r--r-- | locale/localedef.h | 196 | ||||
| -rw-r--r-- | locale/locfile-lex.c | 533 | ||||
| -rw-r--r-- | locale/locfile-parse.c | 820 | ||||
| -rw-r--r-- | locale/messages.c | 76 | ||||
| -rw-r--r-- | locale/monetary.c | 132 | ||||
| -rw-r--r-- | locale/numeric.c | 62 | ||||
| -rw-r--r-- | locale/token.h | 54 | ||||
| -rw-r--r-- | posix/Makefile | 6 | ||||
| -rw-r--r-- | posix/regex.c | 5400 | ||||
| -rw-r--r-- | posix/regex.h | 495 | ||||
| -rw-r--r-- | regex.h | 1 |
31 files changed, 11096 insertions, 25 deletions
diff --git a/ChangeLog b/ChangeLog index 4d55f3fa15..e0440179aa 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,37 @@ +Wed May 17 16:50:21 1995 Roland McGrath <roland@churchy.gnu.ai.mit.edu> + + Merged 1003.2 locale and localedef programs by Ulrich Drepper. + * locale/charmap.c: New file. + * locale/collate.c: New file. + * locale/config.h: New file. + * locale/ctype.c: New file. + * locale/ctypedump.c: New file. + * locale/hash.c: New file. + * locale/hash.h: New file. + * locale/iso-4217.def: New file. + * locale/keyword.gperf: New file. + * locale/keyword.h: New file. + * locale/libintl.h: New file. + * locale/locale.c: New file. + * locale/localedef.c: New file. + * locale/localedef.h: New file. + * locale/locfile-lex.c: New file. + * locale/locfile-parse.c: New file. + * locale/messages.c: New file. + * locale/monetary.c: New file. + * locale/numeric.c: New file. + * locale/token.h: New file. + + * posix/regex.c, posix/regex.h: New files, incorporated from GNU regex. + * posix/Makefile (headers): Add regex.h. + (routines): Add regex. + (gpl2lgpl): Add regex.c and regex.h. + +Tue May 16 17:35:07 1995 Roland McGrath <roland@churchy.gnu.ai.mit.edu> + + * locale/loadlocale.c: Expect macro LOCALE_PATH to be defined, + instead of hard-coding "/share/locale". + Sat May 13 02:16:42 1995 Roland McGrath <roland@churchy.gnu.ai.mit.edu> * configure.in (os=gnu*): Always set elf=yes, not just for os=gnu*elf*. diff --git a/configure b/configure index c543fb56fa..a543befe61 100755 --- a/configure +++ b/configure @@ -571,6 +571,19 @@ echo "$ac_t""$host" 1>&4 # $machine, $vendor, and $os, and changes them whenever convenient. config_machine=$host_cpu config_vendor=$host_vendor config_os=$host_os +# Some configurations imply other options. +case "$host_os" in +gnu* | linux* | bsd4.4* | netbsd* | freebsd*) + # These systems always use GNU tools. + gnu_ld=yes gnu_as=yes +esac +case "$host_os" in +gnu* | linux* | sysv4* | solaris2*) + # These systems always use the ELF format. + elf=yes +esac + +# Compute the list of sysdep directories for this configuration. sysdep_dir=$srcdir/sysdeps echo $ac_n "checking sysdep dirs""... $ac_c" 1>&4 if eval "test \"`echo '$''{'libc_cv_sysdirs'+set}'`\" = set"; then @@ -621,19 +634,6 @@ none) base_os='' ;; esac -# Some configurations imply other options. -case "$os" in -gnu* | linux* | bsd4.4* | netbsd* | freebsd*) - # These systems always use GNU tools. - gnu_ld=yes gnu_as=yes -esac -case "$os" in -gnu* | linux* | sysv4* | solaris2*) - # These systems always use the ELF format. - elf=yes -esac - - # For sunos4.1.1, try sunos4.1.1, then sunos4.1, then sunos4, then sunos. tail=$os ostry=$os diff --git a/libintl.h b/libintl.h new file mode 100644 index 0000000000..38a33d232b --- /dev/null +++ b/libintl.h @@ -0,0 +1 @@ +#include <locale/libintl.h> diff --git a/locale/Makefile b/locale/Makefile index 87a6706e05..c3abc2c62e 100644 --- a/locale/Makefile +++ b/locale/Makefile @@ -21,10 +21,36 @@ # subdir := locale -headers := locale.h -distribute := localeinfo.h categories.def -routines := setlocale loadlocale localeconv -categories := ctype messages monetary numeric time collate +headers = locale.h +distribute = localeinfo.h categories.def \ + $(localedef-modules:=.c) $(locale-modules:=.c) \ + $(lib-modules:=.c) config.h hash.h iso-4217.def \ + keyword.gperf keyword.h localedef.h token.h +routines = setlocale loadlocale localeconv nl_langinfo +categories = ctype messages monetary numeric time collate aux = $(categories:%=lc-%) $(categories:%=C-%) +others = localedef locale +install-bin = localedef locale +extra-objs = $(localedef-modules:=.o) $(locale-modules:=.o) \ + $(lib-modules:=.o) + +localedef-modules := charmap locfile-lex locfile-parse ctype \ + monetary messages collate numeric +locale-modules := ctypedump +lib-modules := error hash xmalloc + + +GPERF = gperf +GPERFFLAGS = -acCgopt -k1,2,5,$$ include ../Rules + +keyword.h: keyword.gperf + $(GPERF) $(GPERFFLAGS) $< > $@.new + mv -f $@.new $@ + +$(objpfx)localedef: $(localedef-modules:%=$(objpfx)%.o) +$(objpfx)locale: $(locale-modules:%=$(objpfx)%.o) +$(objpfx)localedef $(objpfx)locale: $(lib-modules:%=$(objpfx)%.o) + +CPPFLAGS += -DLOCALE_PATH='"$(localedir)"' -DCHARMAP_PATH='"$(nlsdir)/charmap"' diff --git a/locale/categories.def b/locale/categories.def index 6bdad35e17..be3c6bc549 100644 --- a/locale/categories.def +++ b/locale/categories.def @@ -101,6 +101,10 @@ DEFINE_CATEGORY (LC_TIME, "LC_TIME", { D_FMT, "d_fmt", std, string }, { T_FMT, "t_fmt", std, string }, { T_FMT_AMPM, "t_fmt_ampm", std, string }, + { ERA, "era", opt, string }, + { ERA_YEAR, "era_year", opt, string }, + { ERA_D_FMT, "era_d_fmt", opt, string }, + { ALT_DIGITS, "alt_digits", opt, stringarray, 0, 100 }, { 0 } ), NO_POSTLOAD, NULL, NULL, NULL ) diff --git a/locale/charmap.c b/locale/charmap.c new file mode 100644 index 0000000000..ad1075e5bc --- /dev/null +++ b/locale/charmap.c @@ -0,0 +1,524 @@ +/* Copyright (C) 1995 Free Software Foundation, Inc. + +The GNU C Library is free software; you can redistribute it and/or +modify it under the terms of the GNU Library General Public License as +published by the Free Software Foundation; either version 2 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 +Library General Public License for more details. + +You should have received a copy of the GNU Library General Public +License along with the GNU C Library; see the file COPYING.LIB. If +not, write to the Free Software Foundation, Inc., 675 Mass Ave, +Cambridge, MA 02139, USA. */ + +#include <ctype.h> +#include <errno.h> +#include <libintl.h> +#include <limits.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#include "localedef.h" +#include "hash.h" + +/* Data structure for representing charmap database. */ +struct charmap charmap_data; + +/* Line number in charmap file. */ +static unsigned int line_no; + +/* Prototypes for local functions. */ +static void read_prolog (FILE *infile); +static unsigned long read_body (FILE *infile); + + +/* Read complete table of symbolic names for character set from file. If + this file does not exist or is not readable a default file is tried. + If this also is not readable no character map is defined. */ +void +charmap_read (const char *filename) +{ + unsigned long max_char; + long path_max = pathconf (".", _PC_PATH_MAX); + char buf[path_max]; + FILE *infile = NULL; + + /* Initialize charmap data. */ + charmap_data.codeset_name = NULL; + charmap_data.mb_cur_max = -1; + charmap_data.mb_cur_min = -1; + charmap_data.escape_char = '\\'; + charmap_data.comment_char = '#'; + + if (filename != NULL) + { + strcpy (buf, filename); + infile = fopen (filename, "r"); + if (infile == NULL && filename[0] != '/') + { + snprintf (buf, path_max, "%s/%s", CHARMAP_PATH, filename); + infile = fopen (buf, "r"); + } + } + if (infile == NULL) + { + if (filename != NULL) + error (0, errno, gettext ("input file `%s' not found"), filename); + + snprintf (buf, path_max, "%s/%s", CHARMAP_PATH, DEFAULT_CHARMAP); + infile = fopen (buf, "r"); + + if (infile == NULL) + error (4, errno, gettext ("input file `%s' not found"), filename); + } + + charmap_data.filename = buf; + init_hash (&charmap_data.table, 500); + line_no = 0; + + /* Read the prolog of the charmap file. */ + read_prolog (infile); + + /* Last works on the charmap tables global data. */ + if (charmap_data.mb_cur_max == -1) + charmap_data.mb_cur_max = 1; + if (charmap_data.mb_cur_min == -1) + charmap_data.mb_cur_min = charmap_data.mb_cur_max; + + if ((size_t) charmap_data.mb_cur_max > sizeof (long)) + { + error (2, 0, gettext ("program limitation: for now only upto %Zu " + "bytes per character are allowed"), sizeof (long)); + } + + /* Now process all entries. */ + max_char = read_body (infile); + + /* We don't need the file anymore. */ + fclose (infile); + + + /* Determine the optimal table size when using the simple modulo hashing + function. */ + if (max_char >= 256) + { + int size; + /* Current best values, initialized to some never reached high value. */ + int best_count = 10000; + int best_size = 10000; + int best_product = best_count * best_size; + + /* Give warning. */ + error (-1, 0, gettext ("computing character table size: this may take " + "a while")); + + for (size = 256; size <= best_product; ++size) + { + /* Array with slot counters. */ + int cnt[size]; + /* Current character. */ + int ch; + /* Maximal number of characters in any slot. */ + int maxcnt = 0; + /* Product of current size and maximal count. */ + int product = 0; + /* Iteration pointer through hashing table. */ + char *ptr = NULL; + + /* Initializes counters to zero. */ + memset(cnt, 0, size * sizeof (int)); + + /* Iterate through whole hashing table. */ + while (product < best_product + && iterate_table (&charmap_data.table, (void **) &ptr, + (void **) &ch)) + { + /* Increment slot counter. */ + ++cnt[ch % size]; + /* Test for current maximum. */ + if (cnt[ch % size] > maxcnt) + { + maxcnt = cnt[ch % size]; + product = maxcnt * size; + } + } + + if (product < best_product) + { + best_count = maxcnt; + best_size = size; + best_product = best_count * best_size; + } + } + + charmap_data.hash_size = best_size; + charmap_data.hash_layers = best_count; + } + else + { + charmap_data.hash_size = 256; + charmap_data.hash_layers = 1; + } +} + + +#define SYNTAX_ERROR \ + do { error (0, 0, gettext ("%s:%u: syntax error in charmap file"), \ + charmap_data.filename, line_no); \ + goto end_of_loop; } while (0) + +/* Read the prolog of the charmap file until the line containing `CHARMAP'. + All possible entries are processed. */ +static void +read_prolog (FILE *infile) +{ + size_t bufsize = sysconf (_SC_LINE_MAX); + char buf[bufsize]; + + while (1) + { + char *cp = buf; + char len; + + /* Read the next line. */ + fgets (buf, bufsize, infile); + len = strlen (buf); + + /* On EOF simply return. */ + if (len == 0 || buf[len - 1] != '\n') + error (4, 0, gettext ("%s: unexpected end of file in charmap"), + charmap_data.filename); + + /* This is the next line. */ + ++line_no; + + /* Comments and empty lines are ignored. */ + if (len == 1 || buf[0] == charmap_data.comment_char) + continue; + + buf[len - 1] = '\0'; + + /* Throw away leading white spaces. This is not defined in POSIX.2 + so don't do it if conformance is requested. */ + if (!posix_conformance) + while (isspace (*cp)) + ++cp; + + /* If `CHARMAP' is read the prolog is over. */ + if (strncmp (cp, "CHARMAP", 7) == 0 + && (!posix_conformance || cp[7] == '\0')) + return; + + /* Now it can be only one of special symbols defining the charmap + parameters. All are beginning with '<'. */ + if (*cp != '<') + SYNTAX_ERROR; + + ++cp; + if (strncmp (cp, "code_set_name>", 14) == 0) + { + char *startp; + +#define cp_to_arg(no,pred) \ + cp += no; \ + while (isspace (*cp)) \ + ++cp; \ + if (*cp == '\0' || !pred (*cp)) \ + SYNTAX_ERROR; + + cp_to_arg (14,isgraph) + + if (charmap_data.codeset_name != NULL) + { + error (0, 0, gettext ("%s:%u: duplicate code set name " + "specification"), + charmap_data.filename, line_no); + free (charmap_data.codeset_name); + } + + startp = cp; + while (*cp != '\0' && isgraph (*cp) && !isspace (*cp)) + ++cp; + + charmap_data.codeset_name = (char *) xmalloc (cp - startp + 1); + strncpy (startp, startp, cp - startp); + } + else if (strncmp (cp, "mb_cur_max>", 11) == 0) + { + int new_val; + cp_to_arg (11,isdigit) + + if (charmap_data.mb_cur_max != -1) + error (0, 0, + gettext ("%s:%u: duplicate definition of mb_cur_max"), + charmap_data.filename, line_no); + + new_val = (int) strtol (cp, &cp, posix_conformance ? 10 : 0); + if (new_val < 1) + error (0, 0, gettext ("%s:%u: illegal value for mb_cur_max: %d"), + charmap_data.filename, line_no, new_val); + else + charmap_data.mb_cur_max = new_val; + } + else if (strncmp (cp, "mb_cur_min>", 11) == 0) + { + int new_val; + cp_to_arg (11,isdigit) + + if (charmap_data.mb_cur_max != -1) + error (0, 0, + gettext ("%s:%u: duplicate definition of mb_cur_min"), + charmap_data.filename, line_no); + + new_val = (int) strtol (cp, &cp, posix_conformance ? 10 : 0); + if (new_val < 1) + error (0, 0, gettext ("%s:%u: illegal value for mb_cur_min: %d"), + charmap_data.filename, line_no, new_val); + else + charmap_data.mb_cur_min = new_val; + } + else if (strncmp (cp, "escape_char>", 12) == 0) + { + cp_to_arg (12, isgraph) + charmap_data.escape_char = *cp; + } + else if (strncmp (cp, "comment_char>", 13) == 0) + { + cp_to_arg (13, isgraph) + charmap_data.comment_char = *cp; + } + else + SYNTAX_ERROR; + end_of_loop: + } +} +#undef cp_to_arg + + +static unsigned long +read_body (FILE *infile) +{ + unsigned long max_char = 0; + size_t bufsize = sysconf (_SC_LINE_MAX); + char buf[bufsize]; + char name_str[bufsize / 2]; + char code_str[bufsize / 2]; + + while (1) + { + char *cp = buf; + size_t len; + + /* Read the next line. */ + fgets (buf, bufsize, infile); + len = strlen (buf); + + /* On EOF simply return. */ + if (len == 0) + error (0, 0, gettext ("%s: `END CHARMAP' is missing"), + charmap_data.filename); + + /* This is the next line. */ + ++line_no; + + if (len == bufsize - 1) + { + error (0, 0, gettext ("%s:%u: line too long; use `getconf " + "LINE_MAX' to get the current maximum line" + "length"), charmap_data.filename, line_no); + do + { + fgets (buf, bufsize, infile); + len = strlen (buf); + } + while (len == bufsize - 1); + continue; + } + + /* Comments and empty lines are ignored. */ + if (len == 1 || buf[0] == charmap_data.comment_char) + continue; + + buf[len - 1] = '\0'; + + /* Throw away leading white spaces. This is not defined in POSIX.2 + so don't do it if conformance is requested. */ + if (!posix_conformance) + while (isspace (*cp)) + ++cp; + + if (*cp == '<') + { + char *end1p, *end2p, *start2p; + size_t cnt = 0; + unsigned long char_value = 0; + + if (sscanf (cp + 1, "%s %s", name_str, code_str) != 2) + SYNTAX_ERROR; + + end1p = cp = name_str; + while (*cp != '\0' && *cp != '>') + { + if (*cp == charmap_data.escape_char) + if (*++cp == '\0') + SYNTAX_ERROR; + *end1p++ = *cp++; + } + if (*cp == '\0') + /* No final '>'. Make error condition. */ + end1p = name_str; + else + ++cp; + + *end1p = '\0'; + + if (*cp == '.' && *++cp == '.' && *++cp == '.' && *++cp == '<') + { + /* This might be the alternate form. */ + start2p = end2p = ++cp; + while (*cp != '\0' && *cp != '>') + { + if (*cp == charmap_data.escape_char) + if (*++cp == '\0') + SYNTAX_ERROR; + *end2p = *cp++; + } + if (*cp == '\0') + /* NO final '>'. Make error condition. */ + end2p = start2p; + else + ++cp; + } + else + start2p = end2p = NULL; + + + if (end1p == name_str || (start2p != NULL && start2p != end2p) + || *cp != '\0' + || *code_str != charmap_data.escape_char) + SYNTAX_ERROR; + + cp = code_str; + do + { + char *begin; + long val; + + switch (*++cp) + { + case 'd': + val = strtol ((begin = cp + 1), &cp, 10); + break; + case 'x': + val = strtol ((begin = cp + 1), &cp, 16); + break; + default: + val = strtol ((begin = cp), &cp, 8); + break; + } + if (begin == cp) + SYNTAX_ERROR; + + if (posix_conformance && cp - begin < 2) + error (0, 0, gettext ("%s:%u: byte constant has less than " + "two digits"), + charmap_data.filename, line_no); + + if (val < 0 || val > 255) + { + error (0, 0, gettext ("%s:%u: character encoding must be " + "given in 8-bit bytes"), + charmap_data.filename, line_no); + goto end_of_loop; + } + + if (cnt < (size_t) charmap_data.mb_cur_max) + { + if (cnt < sizeof (long)) /* FIXME */ + char_value = (char_value << 8) | val; + } + else + { + error (0, 0, gettext ("%s:%u: number of bytes in character " + "definition exceeds `mb_cur_max'"), + charmap_data.filename, line_no); + break; + } + ++cnt; + } + while (*cp == charmap_data.escape_char); + + /* Ignore the rest of the line (comment). */ + if (end2p == NULL) + { + if (insert_entry (&charmap_data.table, name_str, + end1p - name_str, (void *) char_value)) + error (0, 0, gettext ("%s:%u: duplicate entry"), + charmap_data.filename, line_no); + + max_char = MAX (max_char, char_value); + } + else + { + char *en1, *en2, *start1p; + long n1, n2, n; + + start1p = name_str; + + while (*start1p == *start2p && !isdigit (*start1p) + && start1p < end1p) + ++start1p, ++start2p; + + n1 = strtol (start1p, &en1, 10); + n2 = strtol (start2p, &en2, 10); + + if (en1 - start1p != en2 - start2p || en1 != end1p + || en2 != end2p) + SYNTAX_ERROR; + + if (n1 > n2) + error (0, 0, gettext ("%s:%u: starting character is bigger " + "than last"), + charmap_data.filename, line_no); + + n = n1; + while (n <= n2) + { + snprintf(start1p, en1 - start1p, "%0*d", en1 - start1p, n); + + if (insert_entry (&charmap_data.table, name_str, + en1 - name_str, + (void *) (char_value + n - n1))) + error (0, 0, gettext ("%s:%u: duplicate entry"), + charmap_data.filename, line_no); + + max_char = MAX (max_char, char_value + n - n1); + ++n; + } + } + } + else + { + if (strncmp (cp, "END CHARMAP", 11) == 0) + return max_char; + + SYNTAX_ERROR; + } + end_of_loop: + } + + return max_char; +} + +/* + * Local Variables: + * mode:c + * c-basic-offset:2 + * End: + */ diff --git a/locale/collate.c b/locale/collate.c new file mode 100644 index 0000000000..f06964efcb --- /dev/null +++ b/locale/collate.c @@ -0,0 +1,212 @@ +/* Copyright (C) 1995 Free Software Foundation, Inc. + +The GNU C Library is free software; you can redistribute it and/or +modify it under the terms of the GNU Library General Public License as +published by the Free Software Foundation; either version 2 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 +Library General Public License for more details. + +You should have received a copy of the GNU Library General Public +License along with the GNU C Library; see the file COPYING.LIB. If +not, write to the Free Software Foundation, Inc., 675 Mass Ave, +Cambridge, MA 02139, USA. */ + +#include <langinfo.h> +#include <libintl.h> + +#include "localedef.h" +#include "token.h" + + +/* defined in locfile-lex.c: flag to indicate that unknown element names + are allowed. */ +extern int reject_new_char; + + +#define SYNTAX_ERROR \ + error (0, 0, gettext ("%s:%Zd: syntax error in locale definition file"), \ + locfile_data.filename, locfile_data.line_no); + +void +collate_input (int token) +{ + int read_order_start = 0; + + while (1) + { + char *ptr; + int len; + + if (token == TOK_END) + /* This is the end of the category. */ + { + token = xlocfile_lex (&ptr, &len); + + if (token != _NL_NUM_LC_COLLATE) + { + error (0, 0, gettext ("%s:%Zd: category `%s' does not end " + "with `END %s'"), locfile_data.filename, + locfile_data.line_no, "LC_COLLATE", "LC_COLLATE"); + ignore_to_eol (0, 0); + } + else + ignore_to_eol (0, 1); + + /* Start next category. */ + break; + } + +#if 0 + /* Process line. */ + if (read_order_start == 0) + /* We're still in the preambel. */ + { + switch (token) + { + case TOK_COLLATING_ELEMENT: + reject_new_char = 0; + token = xlocfile_lex (&ptr, &len); + reject_new_char = 1; + if (token == TOK_CHAR) + { + error (0, 0, gettext ("%s:%Zd: symbolic name must not be " + "duplicate name in charmap"), + locfile_data.filename, locfile_data.line_no); + ignore_to_eol (0, 0); + break; + } + else if (token != TOK_ILL_CHAR) + { + SYNTAX_ERROR; + ignore_to_eol (0, 0); + break; + } + else + { + char elem_name[len + 1]; + memcpy (elem_name, ptr, len); + elem_name[len] = '\0'; + + /* Test whether defined in symbol table. */ + + token = xlocfile_lex (&ptr, &len); + if (token != TOK_FROM) + { + SYNTAX_ERROR; + ignore_to_eol (0, 0); + break; + } + + token = xlocfile_lex (&ptr, &len); + if (token != TOK_STRING) + { + SYNTAX_ERROR; + ignore_to_eol (0, 0); + break; + } + + /* Insert collating element into table. */ + + /* Rest of the line should be empty. */ + ignore_to_eol (0, 1); + } + break; + case TOK_COLLATING_SYMBOL: + reject_new_char = 0; + token = xlocfile_lex (&ptr, &len); + reject_new_char = 1; + if (token == TOK_CHAR) + { + error (0, 0, gettext ("%s:%Zd: symbolic name must not " + "duplicate name in charmap"), + locfile_data.filename, locfile_data.line_no); + ignore_to_eol (0, 0); + break; + } + else if (token != TOK_ILL_CHAR) + { + SYNTAX_ERROR; + ignore_to_eol (0, 0); + break; + } + else + { + /* Test whether defined in element table. */ + + /* Insert collating symbol into table. */ + + ignore_to_eol (0, 1); + } + case TOK_ORDER_START: + nsort_rules = 0; + + do + { + token = xlocfile_lex (&ptr, &len); + + if (nsort_rules == 0 && token == ENDOFLINE) + break; + + if (token != TOK_BACKWARD && token != TOK_FORWARD + && token != TOK_POSITION) + { + SYNTAX_ERROR; + break; + } + + switch (token) + { + case TOK_BACKWARD: + if ((sort_rule[nsort_rules] & FORWARD_BIT) != 0) + error (0, 0, gettext ("%s:%Zd: directives `forward' " + "and `backward' are mutually " + "exclusive"), + locfile_data.filename, locfile_data.lineno); + else + sort_rule[nsort_rules] |= BACKWARD_BIT; + break; + case TOK_FORWARD: + if ((sort_rule[nsort_rules] & BACKWARD_BIT) != 0) + error (0, 0, gettext ("%s:%Zd: directives `forward' " + "and `backward' are mutually " + "exclusive"), + locfile_data.filename, locfile_data.lineno); + else + sort_rule[nsort_rules] |= FORWARD_BIT; + break; + case TOK_POSITION: + sort_rule[nsort_rules] |= POSITION_BIT; + break; + } + + ++nsort_rules; + + + } + break; + default: + SYNTAX_ERROR; + ignore_to_eol (token, 0); + } + } + else + { + } +#endif + + ignore_to_eol(token,0); + /* Get next token. */ + token = xlocfile_lex (&ptr, &len); + } +} + +/* + * Local Variables: + * mode:c + * c-basic-offset:2 + * End: + */ diff --git a/locale/config.h b/locale/config.h new file mode 100644 index 0000000000..65dfb33e9a --- /dev/null +++ b/locale/config.h @@ -0,0 +1,45 @@ +/* config.h used by locale and localedef programs in GNU libc. +Copyright (C) 1995 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 Library General Public License as +published by the Free Software Foundation; either version 2 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 +Library General Public License for more details. + +You should have received a copy of the GNU Library General Public +License along with the GNU C Library; see the file COPYING.LIB. If +not, write to the Free Software Foundation, Inc., 675 Mass Ave, +Cambridge, MA 02139, USA. */ + +#ifndef _CONFIG_H +#define _CONFIG_H + +#define PACKAGE "libc" +#define VERSION __libc_version +extern const char __libc_version[]; + +#define DEFAULT_CHARMAP "POSIX" + + +/* These are tested by xmalloc.c and error.c. */ +#define HAVE_VPRINTF 1 +#define STDC_HEADERS 1 +#define HAVE_STRERROR 1 + +#define program_name program_invocation_name + +typedef unsigned short u16; +typedef int i32; +typedef int u32; + + +/* Get the global libc configuration info. */ +#include_next <config.h> + +#endif /* config.h */ diff --git a/locale/ctype.c b/locale/ctype.c new file mode 100644 index 0000000000..1ce09bab2b --- /dev/null +++ b/locale/ctype.c @@ -0,0 +1,817 @@ +/* Copyright (C) 1995 Free Software Foundation, Inc. + +The GNU C Library is free software; you can redistribute it and/or +modify it under the terms of the GNU Library General Public License as +published by the Free Software Foundation; either version 2 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 +Library General Public License for more details. + +You should have received a copy of the GNU Library General Public +License along with the GNU C Library; see the file COPYING.LIB. If +not, write to the Free Software Foundation, Inc., 675 Mass Ave, +Cambridge, MA 02139, USA. */ + +#include <alloca.h> +#include <fcntl.h> +#include <libintl.h> +#include <locale.h> +#include <localeinfo.h> +#include <langinfo.h> +#include <string.h> +#include <unistd.h> +#include <netinet/in.h> +#include <sys/uio.h> + +#include "localedef.h" +#include "token.h" + +/* Arrays representing ctype tables. They must be initialized for the + right size to hold the full charmap. */ +static u16 *ctype_b; +static i32 *names_b, *toupper_b, *tolower_b; + +/* For accessing the element of the (possibly sparse) array we use this + macro. */ +#define ELEM(arr, idx) \ + (arr)[({ int h = idx % charmap_data.hash_size; \ + int n = 0; \ + while (n < charmap_data.hash_layers \ + && names_b[n * charmap_data.hash_size + h] != idx) \ + ++n; \ + if (n >= charmap_data.hash_layers) \ + error (6, 0, gettext ("internal error in %s, line %u"), \ + __FUNCTION__, __LINE__); \ + n * charmap_data.hash_size + h; })] + +/* The bit used for representing a special class. */ +#define BITPOS(class) ((class) - TOK_UPPER) +#define BIT(class) (1 << BITPOS (class)) + +/* Remember which class or conversion is already done. */ +static unsigned short class_done = 0; +static unsigned short toupper_done = 0; +static unsigned short tolower_done = 0; + +#define SYNTAX_ERROR \ + error (0, 0, gettext ("%s:%Zd: syntax error in locale definition file"), \ + locfile_data.filename, locfile_data.line_no); + + +/* Prototypes for local functions. */ +static void allocate_arrays (void); +static void set_class_defaults (void); +static int valid_char (int ch); + + +/* Read CTYPE category. The initial token is given as a parameter. */ +void +ctype_input (int token) +{ + char *ptr; + int len; + + /* If necessary allocate arrays. */ + allocate_arrays (); + + while (token != TOK_END) + { + switch (token) + { + case TOK_UPPER: case TOK_LOWER: case TOK_ALPHA: case TOK_DIGIT: + case TOK_XDIGIT: case TOK_SPACE: case TOK_PRINT: case TOK_GRAPH: + case TOK_BLANK: case TOK_CNTRL: case TOK_PUNCT: + { + /* TAKE CARE: the order of the tokens in "token.h" determines + the bit used to indicate the membership in the class. This + also has to correspond to the values used in <ctype.h>. */ + int bit = BIT (token); + int was_ell = 0; + int last = -1; + + if ((class_done & bit) != 0) + { + char tmp[len + 1]; + memcpy (tmp, ptr, len); + tmp[len] = '\0'; + + error (0, 0, gettext ("%s:%Zd: duplicate definiton of item " + "`%s' in category `LC_CTYPE'"), + locfile_data.filename, locfile_data.line_no, tmp); + } + class_done |= bit; + + do + { + token = xlocfile_lex (&ptr, &len); + + if (token == TOK_ENDOFLINE) + { + SYNTAX_ERROR; + break; + } + + if (token == TOK_ELLIPSIS) + { + if (was_ell != 0 || last < 0) + { + error (0, 0, gettext ("%s:%Zd: illegal use of `...'"), + locfile_data.filename, locfile_data.line_no); + break; + } + was_ell = 1; + continue; + } + + if (token != TOK_CHAR) + { + if (token != TOK_ILL_CHAR) + SYNTAX_ERROR; + was_ell = 0; + last = -1; + continue; + } + + if (len < 0 || !valid_char (len)) + { + was_ell = 0; + last = -1; + continue; + } + + /* We have found a valid character. Include it to + the class' bit set. */ + if (was_ell == 0) + { + ELEM (ctype_b, len) |= bit; + last = len; + } + else + { + int i; + + if (last > len) + { + error (0, 0, gettext ("%s:%Zd: lower bound of " + "ellipsis not smaller"), + locfile_data.filename, locfile_data.line_no); + was_ell = 0; + last = -1; + continue; + } + + for (i = last + 1; i <= len; ++i) + ELEM (ctype_b, i) |= bit; + + last = -1; + } + was_ell = 0; + } + while ((token = locfile_lex (&ptr, &len)) == TOK_CHAR + && len == ';'); + + /* Rest of the line should be empty. */ + ignore_to_eol (token, 0); + } + break; + case TOK_TOUPPER: case TOK_TOLOWER: + { + int from; + int to = -1; + int is_upper = token == TOK_TOUPPER; + + if (((is_upper ? toupper_done : tolower_done) & BIT (token)) != 0) + error (0, 0, gettext ("%s:%Zd: duplicate definition of item " + "`%s' in category `LC_CTYPE'"), + locfile_data.filename, locfile_data.line_no, + is_upper ? "toupper" : "tolower"); + (is_upper ? toupper_done : tolower_done) |= BIT (token); + + do + { + int ignore; + + token = xlocfile_lex (&ptr, &len); + if (token != TOK_CHAR || len != '(') + { + SYNTAX_ERROR; + break; + } + + token = xlocfile_lex (&ptr, &len); + if (token != TOK_CHAR && token != TOK_ILL_CHAR) + { + SYNTAX_ERROR; + break; + } + from = len; + ignore = token == TOK_ILL_CHAR; + + token = xlocfile_lex (&ptr, &len); + if (token != TOK_CHAR || len != ',') + { + SYNTAX_ERROR; + break; + } + + token = xlocfile_lex (&ptr, &len); + if (token != TOK_CHAR && token != TOK_ILL_CHAR) + { + SYNTAX_ERROR; + break; + } + to = len; + ignore |= token == TOK_ILL_CHAR; + + token = xlocfile_lex (&ptr, &len); + if (token != TOK_CHAR || len != ')') + { + SYNTAX_ERROR; + break; + } + + if (!ignore && valid_char (from) && valid_char (to)) + /* Have a valid pair. */ + ELEM (is_upper ? toupper_b : tolower_b, from) = to; + } + while ((token = locfile_lex (&ptr, &len)) == TOK_CHAR + && len == ';'); + + /* Rest of the line should be empty. */ + ignore_to_eol (token, 1); + } + break; + default: + SYNTAX_ERROR; + ignore_to_eol (0, 0); + break; + } + + /* Read next token. */ + token = xlocfile_lex (&ptr, &len); + } + + token = xlocfile_lex (&ptr, &len); + + if (token != _NL_NUM_LC_CTYPE) + { + error (0, 0, gettext ("%s:%Zd: category `%s' does not end with " + "`END %s'"), locfile_data.filename, + locfile_data.line_no, "LC_CTYPE", "LC_CTYPE"); + ignore_to_eol (0, 0); + } + else + ignore_to_eol (0, posix_conformance); +} + + +void +ctype_check(void) +{ + /* Here are a lot of things to check. See POSIX.2, table 2-6. */ + #define NCLASS 11 + static const struct + { + const char *name; + const char allow[NCLASS]; + } + valid_table[NCLASS] = + { + /* The order is important. See token.h for more information. + M = Always, D = Default, - = Permitted, X = Mutually exclusive */ + [BITPOS (TOK_UPPER)] = { "upper", "--MX-XDDXXX" }, + [BITPOS (TOK_LOWER)] = { "lower", "--MX-XDDXXX" }, + [BITPOS (TOK_ALPHA)] = { "alpha", "---X-XDDXXX" }, + [BITPOS (TOK_DIGIT)] = { "digit", "XXX--XDDXXX" }, + [BITPOS (TOK_XDIGIT)] = { "xdigit", "-----XDDXXX" }, + [BITPOS (TOK_SPACE)] = { "space", "XXXXX------" }, + [BITPOS (TOK_PRINT)] = { "print", "---------X-" }, + [BITPOS (TOK_GRAPH)] = { "graph", "---------X-" }, + [BITPOS (TOK_BLANK)] = { "blank", "XXXXXM-----" }, + [BITPOS (TOK_CNTRL)] = { "cntrl", "XXXXX-XX--X" }, + [BITPOS (TOK_PUNCT)] = { "punct", "XXXXX-DD-X-" } + }; + int ch, cls1, cls2, eq, space_char; + u16 tmp; + + /* Set default value for classes not specified. */ + set_class_defaults (); + + /* Check according to table. */ + for (ch = 0; ch < charmap_data.hash_size * charmap_data.hash_layers; ++ch) + { + if (ch != 0 && names_b[ch] == 0) + continue; + tmp = ELEM (ctype_b, names_b[ch]); + for (cls1 = 0; cls1 < NCLASS; ++cls1) + if ((tmp & (1 << cls1)) != 0) + for (cls2 = 0; cls2 < NCLASS; ++cls2) + if (cls2 != cls1 && valid_table[cls1].allow[cls2] != '-') + { + eq = (tmp & (1 << cls2)) != 0; + switch (valid_table[cls1].allow[cls2]) + { + case 'M': + if (!eq) + error (0, 0, gettext ("character '\\%o' in class `%s' " + "must be in class `%s'"), ch, + valid_table[cls1].name, valid_table[cls2].name); + break; + case 'X': + if (eq) + error (0, 0, gettext ("character '\\%o' inc class `%s' " + "must not be in class `%s'"), ch, + valid_table[cls1].name, valid_table[cls2].name); + break; + case 'D': + ELEM (ctype_b, names_b[ch]) |= 1 << cls2; + break; + default: + error (5, 0, gettext ("internal error in %s, line %u"), + __FUNCTION__, __LINE__); + } + } + } + + /* ... and now test <SP> as a special case. */ + if (find_entry (&charmap_data.table, "SP", 2, (void **) &space_char) == 0) + error (0, 0, gettext ("character <SP> not defined in character map")); + else if ((tmp = BITPOS (TOK_SPACE), + (ELEM (ctype_b, space_char) & BIT (TOK_SPACE)) == 0) + || (tmp = BITPOS (TOK_BLANK), + (ELEM (ctype_b, space_char) & BIT (TOK_BLANK)) == 0)) + error (0, 0, gettext ("<SP> character not in class `%s'"), + valid_table[tmp].name); + else if ((tmp = BITPOS (TOK_PUNCT), + (ELEM (ctype_b, space_char) & BIT (TOK_PUNCT)) != 0) + || (tmp = BITPOS (TOK_GRAPH), + (ELEM (ctype_b, space_char) & BIT (TOK_GRAPH)) != 0)) + error (0, 0, gettext ("<SP> character must not be in class `%s'"), + valid_table[tmp].name); + else + ELEM (ctype_b, space_char) |= BIT (TOK_PRINT); +} + + +/* These macros can change little to big endian and vice versa. */ +#define SWAP16(v) \ + ((u16) (((((unsigned short) (v)) & 0x00ff) << 8) \ + | ((((unsigned short) (v)) & 0xff00) >> 8))) +#define SWAP32(v) \ + ((u32) (((((u32) (v)) & 0x000000ff) << 24) \ + | ((((u32) (v)) & 0x0000ff00) << 8) \ + | ((((u32) (v)) & 0x00ff0000) >> 8) \ + | ((((u32) (v)) & 0xff000000) >> 24))) + + +int +ctype_output (void) +{ + char *path, *t; + int ch; + /* File descriptor for output file. */ + int fd; + /* Magic number. */ + i32 magic = LIMAGIC (LC_CTYPE); + /* Number of table. */ + int tables = 6; + /* Number ints in leading information table. */ +#if 0 + i32 n = 2 + 2 * tables; +#else + i32 n = 5; +#endif + /* Values describing the character set. */ + char mb_cur_min = (char) charmap_data.mb_cur_min; + char mb_cur_max = (char) charmap_data.mb_cur_max; + /* Optimal size of hashing table. */ + i32 hash_size = charmap_data.hash_size; + i32 hash_layers = charmap_data.hash_layers; + /* Number of elements in the tables. */ + int size = hash_size * charmap_data.hash_layers; + /* Positions of the tables. */ + i32 pos[14] = + { + /* No, no. We don't play towers of Hanoi. This is a more or less + readable table of the offsets of the different strings in the + produced file. It is seperated in three columns which represent + the number of values with 1, 2, and 4 bytes. */ + +#if 0 + 4 * (2 + n), + 1 + 4 * (2 + n), + 2 + 4 * (2 + n), + 2 + 4 * (3 + n), + 2 + 4 * (4 + n), + 2 + 2 * (128 + size) + 4 * (4 + n), + 2 + 2 * (128 + size) + 4 * ((4 + n) + (size + 128)), + 2 + 2 * (128 + size) + 4 * ((4 + n) + 2 * (size + 128)), + 2 + 2 * (128 + size) + 4 * ((4 + n) + 2 * (size + 128) + 1 * size), + 2 + 2 * (128 + size) + 4 * ((5 + n) + 2 * (size + 128) + 1 * size), + 2 + 2 * (128 + size) + 4 * ((6 + n) + 2 * (size + 128) + 1 * size), + 2 + 2 * (2 * (128 + size)) + 4 * ((6 + n) + 2 * (size + 128) + 1 * size), + 2 + 2 * (2 * (128 + size)) + 4 * ((6 + n) + 3 * (size + 128) + 1 * size), + 2 + 2 * (2 * (128 + size)) + 4 * ((6 + n) + 4 * (size + 128) + 1 * size), +#else + 4 * (2 + n), + 2 * (128 + size) + 4 * (2 + n), + 2 * (128 + size) + 4 * ((2 + n) + (size + 128)), + 2 * (128 + size) + 4 * ((2 + n) + 2 * (size + 128)), + 2 * (128 + size) + 4 * ((2 + n) + 3 * (size + 128)), +#endif + }; + /* Parameter to writev. */ + struct iovec iov[11] = + { + { &magic, sizeof (i32) }, + { &n, sizeof (i32) }, +#if 0 + { pos, sizeof (pos) }, + { &mb_cur_min, 1 }, + { &mb_cur_max, 1 }, + { &hash_size, sizeof (i32) }, + { &hash_layers, sizeof (i32) }, +#else + { pos, 5 * 4 }, +#endif + { ctype_b - 128, (size + 128) * sizeof (u16) }, + { toupper_b - 128, (size + 128) * sizeof (i32) }, + { tolower_b - 128, (size + 128) * sizeof (i32) }, + { names_b, size * sizeof (i32) } + }; + int result = 0; + + /* Now we can bring the representations into the right form. */ + for (ch = -128; ch < -1; ++ch) + { + ctype_b[ch] = ctype_b[256 + ch]; + toupper_b[ch] = toupper_b[256 + ch]; + tolower_b[ch] = tolower_b[256 + ch]; + } + /* Set value for EOF. */ + ctype_b[-1] = 0; + toupper_b[-1] = -1; + tolower_b[-1] = -1; + + for (ch = -128; ch < size; ++ch) + ctype_b[ch] = htons (ctype_b[ch]); + + /* Construct the output filename from the argument given to + localedef on the command line. */ + path = (char *) alloca (strlen (output_path) + + strlen (category[LC_CTYPE].name) + 1); + t = stpcpy (path, output_path); + strcpy (t, category[LC_CTYPE].name); + + fd = creat (path, 0666); + if (fd == -1) + { + error (0, 0, gettext ("cannot open output file `%s': %m"), path); + result = 1; + } + else + { + int idx; + +#if 0 + if (writev (fd, iov, 10) == -1) +#else + if (writev (fd, iov, 6) == -1) +#endif + { + error (0, 0, gettext ("cannot write output file `%s': %m"), path); + result = 1; + goto close_and_return; + } + + /* Now we have to write the three tables with different endianess. */ + hash_size = SWAP32 (hash_size); + for (idx = -128; idx < size; ++idx) + { + ctype_b[idx] = SWAP16 (ctype_b[idx]); + toupper_b[idx] = SWAP32 (toupper_b[idx]); + tolower_b[idx] = SWAP32 (tolower_b[idx]); + if (idx >= 0) + names_b[idx] = SWAP32 (names_b[idx]); + } + +#if 0 + if (writev (fd, iov + 5, 6) == -1) +#else + if (writev (fd, iov + 3, 2) == -1) +#endif + { + error (0, 0, gettext ("cannot write output file `%s': %m"), path); + result = 1; + } + + close_and_return: + close (fd); + } + + return result; +} + + +/* If necessary allocate the memory for the arrays according to the + current character map. */ +static void +allocate_arrays (void) +{ + /* Init ctype data structures. */ + if (ctype_b == NULL) + /* All data structures are not initialized yet. */ + { + /* You wonder about this amount of memory? This is only because + some users do not manage to address the array with unsigned + values or data types with range >= 256. '\200' would result + in the array index -128. To help these poor people we + duplicate the entries for 128 upto 255 below the entry for \0. */ + int ch, h, n; + char *ptr; + int size = charmap_data.hash_size * charmap_data.hash_layers; + + ctype_b = (u16 *) xcalloc (size - (-128), sizeof (u16)); + ctype_b += 128; + + + names_b = (i32 *) xcalloc (size, sizeof (i32)); + + toupper_b = (i32 *) xcalloc ((size - (-128)), sizeof (i32)); + toupper_b += 128; + + tolower_b = (i32 *) xcalloc ((size - (-128)), sizeof (i32)); + tolower_b += 128; + + ptr = NULL; + /* Mark the place of the NUL character as occupied. */ + names_b[0] = 1; + + while (iterate_table (&charmap_data.table, (void **) &ptr, + (void **) &ch)) + { + /* We already handled the NUL character. */ + if (ch == 0) + continue; + + h = ch % charmap_data.hash_size; + n = 0; + while (names_b[h + n * charmap_data.hash_size] != 0) + ++n; + + names_b[h + n * charmap_data.hash_size] = ch; + toupper_b[h + n * charmap_data.hash_size] = ch; + tolower_b[h + n * charmap_data.hash_size] = ch; + } + /* Correct the value for NUL character. */ + names_b[0] = 0; + } +} + +static void +set_class_defaults (void) +{ + /* These function defines the default values for the classes and conversions + according to POSIX.2 2.5.2.1. + It may seem that the order of these if-blocks is arbitrary but it is NOT. + Don't move them unless you know what you do! */ + + void set_default (int bit, int from, int to) + { + char tmp[4]; + int ch; + /* Define string. */ + strcpy (tmp, "<?>"); + + for (ch = from; ch <= to; ++ch) + { + int code; + tmp[1] = ch; + + code = find_char (tmp + 1, 1); + if (code == -1) + error (5, 0, gettext ("character `%s' not defined while needed " + "as default value"), tmp); + ELEM (ctype_b, code) |= bit; + } + } + + /* If necessary allocate arrays. */ + allocate_arrays (); + + /* Set default values if keyword was not present. */ + if ((class_done & BIT (TOK_UPPER)) == 0) + /* "If this keyword [lower] is not specified, the lowercase letters + `A' through `Z', ..., shall automatically belong to this class, + with implementation defined character values." */ + set_default (BIT (TOK_UPPER), 'A', 'Z'); + + if ((class_done & BIT (TOK_LOWER)) == 0) + /* "If this keyword [lower] is not specified, the lowercase letters + `a' through `z', ..., shall automatically belong to this class, + with implementation defined character values." */ + set_default (BIT (TOK_LOWER), 'a', 'z'); + + if ((class_done & BIT (TOK_DIGIT)) == 0) + /* "If this keyword [digit] is not specified, the digits `0' through + `9', ..., shall automatically belong to this class, with + implementation-defined character values." */ + set_default (BIT (TOK_DIGIT), '0', '9'); + + if ((class_done & BIT (TOK_SPACE)) == 0) + /* "If this keyword [space] is not specified, the characters <space>, + <form-feed>, <newline>, <carriage-return>, <tab>, and + <vertical-tab>, ..., shall automatically belong to this class, + with implementtation-defined character values." */ + { + int code; + + code = find_char ("space", 5); + if (code == -1) + error (5, 0, gettext ("character `%s' not defined while needed as " + "default value"), "<space>"); + ELEM (ctype_b, code) |= BIT (TOK_SPACE); + + code = find_char ("form-feed", 9); + if (code == -1) + error (5, 0, gettext ("character `%s' not defined while needed as " + "default value"), "<form-feed>"); + ELEM (ctype_b, code) |= BIT (TOK_SPACE); + + code = find_char ("newline", 7); + if (code == -1) + error (5, 0, gettext ("character `%s' not defined while needed as " + "default value"), "<newline>"); + ELEM (ctype_b, code) |= BIT (TOK_SPACE); + + code = find_char ("carriage-return", 15); + if (code == -1) + error (5, 0, gettext ("character `%s' not defined while needed as " + "default value"), "<carriage-return>"); + ELEM (ctype_b, code) |= BIT (TOK_SPACE); + + code = find_char ("tab", 3); + if (code == -1) + error (5, 0, gettext ("character `%s' not defined while needed as " + "default value"), "<tab>"); + ELEM (ctype_b, code) |= BIT (TOK_SPACE); + + code = find_char ("vertical-tab", 11); + if (code == -1) + error (5, 0, gettext ("character `%s' not defined while needed as " + "default value"), "<vertical-tab>"); + ELEM (ctype_b, code) |= BIT (TOK_SPACE); + } + + if ((class_done & BIT (TOK_XDIGIT)) == 0) + /* "If this keyword is not specified, the digits `0' to `9', the + uppercase letters `A' through `F', and the lowercase letters `a' + through `f', ..., shell automatically belong to this class, with + implementation defined character values." */ + { + if ((class_done & BIT (TOK_XDIGIT)) == 0) + set_default (BIT (TOK_XDIGIT), '0', '9'); + + if ((class_done & BIT (TOK_XDIGIT)) == 0) + set_default (BIT (TOK_XDIGIT), 'A', 'F'); + + if ((class_done & BIT (TOK_XDIGIT)) == 0) + set_default (BIT (TOK_XDIGIT), 'a', 'f'); + } + + if ((class_done & BIT (TOK_BLANK)) == 0) + /* "If this keyword [blank] is unspecified, the characters <space> and + <tab> shall belong to this character class." */ + { + int code; + + code = find_char ("space", 5); + if (code == -1) + error (5, 0, gettext ("character `%s' not defined while needed as " + "default value"), "<space>"); + ELEM (ctype_b, code) |= BIT (TOK_BLANK); + + code = find_char ("tab", 3); + if (code == -1) + error (5, 0, gettext ("character `%s' not defined while needed as " + "default value"), "<tab>"); + ELEM (ctype_b, code) |= BIT (TOK_BLANK); + } + + if ((class_done & BIT (TOK_GRAPH)) == 0) + /* "If this keyword [graph] is not specified, characters specified for + the keywords `upper', `lower', `alpha', `digit', `xdigit' and `punct', + shall belong to this character class." */ + { + int ch; + unsigned short int mask = BIT (TOK_UPPER) | BIT (TOK_LOWER) | + BIT (TOK_ALPHA) | BIT (TOK_DIGIT) | BIT (TOK_XDIGIT) | BIT (TOK_PUNCT); + + for (ch = 0; ch < charmap_data.hash_size * charmap_data.hash_layers; + ++ch) + { + if (ch != 0 && names_b[ch] == 0) + continue; + if ((ELEM (ctype_b, names_b[ch]) & mask) != 0) + ELEM (ctype_b, names_b[ch]) |= BIT (TOK_GRAPH); + } + } + + if ((class_done & BIT (TOK_PRINT)) == 0) + /* "If this keyword [print] is not provided, characters specified for + the keywords `upper', `lower', `alpha', `digit', `xdigit', `punct', + and the <space> character shall belong to this character class." */ + { + int ch; + int space = find_char ("space", 5); + unsigned short int mask = BIT (TOK_UPPER) | BIT (TOK_LOWER) | + BIT (TOK_ALPHA) | BIT (TOK_DIGIT) | BIT (TOK_XDIGIT) | BIT (TOK_PUNCT); + + if (space == -1) + error (5, 0, gettext ("character `%s' not defined while needed as " + "default value"), "<space>"); + + for (ch = 0; ch < charmap_data.hash_size * charmap_data.hash_layers; + ++ch) + { + if (ch != 0 && names_b[ch] == 0) + continue; + if ((ELEM (ctype_b, names_b[ch]) & mask) != 0) + ELEM (ctype_b, names_b[ch]) |= BIT (TOK_PRINT); + } + ELEM (ctype_b, space) |= BIT (TOK_PRINT); + } + + if (toupper_done == 0) + /* "If this keyword [toupper] is not spcified, the lowercase letters + `a' through `z', and their corresponding uppercase letters `A' to + `Z', ..., shall automatically be included, with implementation- + defined character values." */ + { + char tmp[4]; + int ch; + + strcpy (tmp, "<?>"); + + for (ch = 'a'; ch <= 'z'; ++ch) + { + int code_to, code_from; + + tmp[1] = ch; + code_from = find_char (tmp + 1, 1); + if (code_from == -1) + error (5, 0, gettext ("character `%s' not defined while needed " + "as default value"), tmp); + + /* This conversion is implementation defined. */ + tmp[1] = ch + ('A' - 'a'); + code_to = find_char (tmp + 1, 1); + if (code_to == -1) + error (5, 0, gettext ("character `%s' not defined while needed " + "as default value"), tmp); + + ELEM (toupper_b, code_from) = code_to; + } + } + + if (tolower_done == 0) + /* "If this keyword [tolower] is not specified, the mapping shall be + the reverse mapping of the one specified to `toupper'." */ + { + int ch; + + for (ch = 0; ch < charmap_data.hash_size * charmap_data.hash_layers; + ++ch) + { + if (ch != 0 && names_b[ch] == 0) + continue; + + if (toupper_b[ch] != names_b[ch]) + ELEM (tolower_b, toupper_b[ch]) = names_b[ch]; + } + } +} + + +/* Test whether the given character is valid for the current charmap. */ +static int +valid_char (int ch) +{ + /* FIXME: this assumes 32-bit integers. */ + int ok = ch >= 0 + && (charmap_data.mb_cur_max < 4 + ? ch < 1 << (8 * charmap_data.mb_cur_max) : 1); + + return ok; +} + + +/* + * Local Variables: + * mode:c + * c-basic-offset:2 + * End: + */ diff --git a/locale/ctypedump.c b/locale/ctypedump.c new file mode 100644 index 0000000000..e00f3e0f11 --- /dev/null +++ b/locale/ctypedump.c @@ -0,0 +1,163 @@ +/* Copyright (C) 1995 Free Software Foundation, Inc. + +The GNU C Library is free software; you can redistribute it and/or +modify it under the terms of the GNU Library General Public License as +published by the Free Software Foundation; either version 2 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 +Library General Public License for more details. + +You should have received a copy of the GNU Library General Public +License along with the GNU C Library; see the file COPYING.LIB. If +not, write to the Free Software Foundation, Inc., 675 Mass Ave, +Cambridge, MA 02139, USA. */ + +#include <ctype.h> +#include <endian.h> +#include <stdlib.h> +#include <stdio.h> +#include <netinet/in.h> /* Just for htons() */ + +#include "localedef.h" +#include "localeinfo.h" + + +/* FIXME: these values should be part of the LC_CTYPE information. */ +#define mb_cur_max 1 +#define mb_cur_min 1 + + +#define SWAP32(v) \ + ((u32) (((((u32) (v)) & 0x000000ff) << 24) \ + | ((((u32) (v)) & 0x0000ff00) << 8) \ + | ((((u32) (v)) & 0x00ff0000) >> 8) \ + | ((((u32) (v)) & 0xff000000) >> 24))) + + + +static inline void +print_short_in_char (unsigned short val) +{ + const unsigned char *p = (const unsigned char *) &val; + printf ("\"\\%03o\\%03o\"", p[0], p[1]); +} + + +static inline void +print_int_in_char (unsigned int val) +{ + const unsigned char *p = (const unsigned char *) &val; + printf ("\"\\%03o\\%03o\\%03o\\%03o\"", p[0], p[1], p[2], p[3]); +} + + +int +ctype_output (void) +{ + int ch; + int result = 0; + const char *locname = (getenv ("LC_ALL") ?: getenv ("LC_CTYPE") ?: + getenv ("LANG") ?: "POSIX"); + + puts ("#include <endian.h>\n"); + + if (mb_cur_max == 1) + { + printf ("const char _nl_%s_LC_CTYPE_class[] = \n", locname); + for (ch = -128; ch < (1 << (8 * MB_CUR_MAX)); ++ch) + { + if (((ch + 128) % 6) == 0) + printf (" /* 0x%02x */ ", ch < 0 ? 256 + ch : ch); + print_short_in_char (htons (__ctype_b [ch < 0 ? 256 + ch : ch])); + fputc (((ch + 128) % 6) == 5 ? '\n' : ' ', stdout); + } + puts (";"); + } + + printf ("#if BYTE_ORDER == %s\n", + BYTE_ORDER == LITTLE_ENDIAN ? "LITTLE_ENDIAN" : "BIG_ENDIAN"); + + if (mb_cur_max == 1) + { + printf ("const char _nl_%s_LC_CTYPE_toupper[] = \n", locname); + for (ch = -128; ch < (1 << (8 * MB_CUR_MAX)); ++ch) + { + if (((ch + 128) % 3) == 0) + printf (" /* 0x%02x */ ", ch < 0 ? 256 + ch : ch); + print_int_in_char (__ctype_toupper[ch < 0 ? 256 + ch : ch]); + fputc (((ch + 128) % 3) == 2 ? '\n' : ' ', stdout); + } + puts (";"); + + printf ("const char _nl_%s_LC_CTYPE_tolower[] = \n", locname); + for (ch = -128; ch < (1 << (8 * MB_CUR_MAX)); ++ch) + { + if (((ch + 128) % 3) == 0) + printf (" /* 0x%02x */ ", ch < 0 ? 256 + ch : ch); + print_int_in_char (__ctype_tolower[ch < 0 ? 256 + ch : ch]); + fputc (((ch + 128) % 3) == 2 ? '\n' : ' ', stdout); + } + puts (";"); + } + else + /* not implemented */; + + printf ("#elif BYTE_ORDER == %s\n", + BYTE_ORDER == LITTLE_ENDIAN ? "BIG_ENDIAN" : "LITTLE_ENDIAN"); + + if (mb_cur_max == 1) + { + printf ("const char _nl_%s_LC_CTYPE_toupper[] = \n", locname); + for (ch = -128; ch < (1 << (8 * MB_CUR_MAX)); ++ch) + { + if (((ch + 128) % 3) == 0) + printf (" /* 0x%02x */ ", ch < 0 ? 256 + ch : ch); + print_int_in_char (SWAP32 (__ctype_toupper[ch < 0 ? 256 + ch : ch])); + fputc (((ch + 128) % 3) == 2 ? '\n' : ' ', stdout); + } + puts (";"); + + printf ("const char _nl_%s_LC_CTYPE_tolower[] = \n", locname); + for (ch = -128; ch < (1 << (8 * MB_CUR_MAX)); ++ch) + { + if (((ch + 128) % 3) == 0) + printf (" /* 0x%02x */ ", ch < 0 ? 256 + ch : ch); + print_int_in_char (SWAP32 (__ctype_tolower[ch < 0 ? 256 + ch : ch])); + fputc (((ch + 128) % 3) == 2 ? '\n' : ' ', stdout); + } + puts (";"); + } + else + /* not implemented */; + + puts ("#else\n#error \"BYTE_ORDER\" BYTE_ORDER \" not handled.\"\n#endif\n"); + + printf("const struct locale_data _nl_%s_LC_CTYPE = \n\ +{\n\ + NULL, 0, /* no file mapped */\n\ + 5,\n\ + {\n\ + _nl_C_LC_CTYPE_class,\n\ +#ifdef BYTE_ORDER == LITTLE_ENDIAN\n\ + NULL, NULL,\n\ +#endif\n\ + _nl_C_LC_CTYPE_toupper,\n\ + _nl_C_LC_CTYPE_tolower,\n\ +#ifdef BYTE_ORDER == BIG_ENDIAN\n\ + NULL, NULL,\n\ +#endif\n\ + }\n\ +};\n", locname); + + return result; +} + +/* + * Local Variables: + * mode:c + * c-basic-offset:2 + * End: + */ diff --git a/locale/hash.c b/locale/hash.c new file mode 100644 index 0000000000..75cb77f882 --- /dev/null +++ b/locale/hash.c @@ -0,0 +1,254 @@ +/* Copyright (C) 1995 Free Software Foundation, Inc. + +The GNU C Library is free software; you can redistribute it and/or +modify it under the terms of the GNU Library General Public License as +published by the Free Software Foundation; either version 2 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 +Library General Public License for more details. + +You should have received a copy of the GNU Library General Public +License along with the GNU C Library; see the file COPYING.LIB. If +not, write to the Free Software Foundation, Inc., 675 Mass Ave, +Cambridge, MA 02139, USA. */ + +#include <obstack.h> +#include <stdlib.h> +#include <string.h> +#include <values.h> + +#include "hash.h" + +#define obstack_chunk_alloc xmalloc +#define obstack_chunk_free free + +void *xmalloc (size_t n); + +typedef struct hash_entry + { + int used; + char *key; + void *data; + struct hash_entry *next; + } +hash_entry; + +/* Prototypes for local functions. */ +static size_t lookup (hash_table *htab, const char *key, size_t keylen, + unsigned long hval); +static unsigned long compute_hashval(const char *key, size_t keylen); +static unsigned long next_prime(unsigned long seed); +static int is_prime(unsigned long candidate); + + +int +init_hash(hash_table *htab, unsigned long init_size) +{ + /* We need the size to be a prime. */ + init_size = next_prime (init_size); + + /* Initialize the data structure. */ + htab->size = init_size; + htab->filled = 0; + htab->first = NULL; + htab->table = calloc (init_size + 1, sizeof (hash_entry)); + obstack_init (&htab->mem_pool); + + return htab->table == NULL; +} + + +int +delete_hash(hash_table *htab) +{ + free (htab->table); + obstack_free (&htab->mem_pool, NULL); + return 0; +} + + +int +insert_entry (hash_table *htab, const char *key, size_t keylen, void *data) +{ + unsigned long hval = compute_hashval (key, keylen); + hash_entry *table = (hash_entry *) htab->table; + size_t idx = lookup (htab, key, keylen, hval); + + if (table[idx].used) + /* We don't want to overwrite the old value. */ + return 1; + else + { + hash_entry **p; + + /* An empty bucket has been found. */ + table[idx].used = hval; + table[idx].key = obstack_copy0 (&htab->mem_pool, key, keylen); + table[idx].data = data; + + /* List the new value in the ordered list. */ + for (p = (hash_entry **) &htab->first; *p != NULL && (*p)->data < data; + p = &(*p)->next); + if (*p == NULL || (*p)->data > data) + /* Insert new value in the list. */ + { + table[idx].next = *p; + *p = &table[idx]; + } + + ++htab->filled; + if (100 * htab->filled > 90 * htab->size) + { + /* Resize the table. */ + unsigned long old_size = htab->size; + + htab->size = next_prime (htab->size * 2); + htab->filled = 0; + htab->first = NULL; + htab->table = calloc (htab->size, sizeof (hash_entry)); + + for (idx = 1; idx <= old_size; ++idx) + if (table[idx].used) + insert_entry (htab, table[idx].key, strlen(table[idx].key), + table[idx].data); + + free (table); + } + return 0; + } + /* NOTREACHED */ +} + + +int +find_entry (hash_table *htab, const char *key, size_t keylen, void **result) +{ + hash_entry *table = (hash_entry *) htab->table; + size_t idx = lookup (htab, key, keylen, compute_hashval (key, keylen)); + int retval; + + retval = table[idx].used; + *result = retval ? table[idx].data : NULL; + + return retval; +} + + +int +iterate_table (hash_table *htab, void **ptr, void **result) +{ + if (*ptr == NULL) + *ptr = (void *) htab->first; + else + { + *ptr = (void *) (((hash_entry *) *ptr)->next); + if (*ptr == NULL) + return 0; + } + + *result = ((hash_entry *) *ptr)->data; + return 1; +} + + +static size_t +lookup (hash_table *htab, const char *key, size_t keylen, unsigned long hval) +{ + unsigned long hash; + size_t idx; + hash_entry *table = (hash_entry *) htab->table; + + /* First hash function: simply take the modul but prevent zero. */ + hash = 1 + hval % htab->size; + + idx = hash; + + if (table[idx].used) + { + if (table[idx].used == hval && table[idx].key[keylen] == '\0' + && strncmp (key, table[idx].key, keylen) == 0) + return idx; + + /* Second hash function as suggested in [Knuth]. */ + hash = 1 + hash % (htab->size - 2); + + do + { + if (idx <= hash) + idx = htab->size + idx - hash; + else + idx -= hash; + + /* If entry is found use it. */ + if (table[idx].used == hval && table[idx].key[keylen] == '\0' + && strncmp (key, table[idx].key, keylen) == 0) + return idx; + } + while (table[idx].used); + } + return idx; +} + + +static unsigned long +compute_hashval(const char *key, size_t keylen) +{ + size_t cnt; + unsigned long hval, g; + /* Compute the hash value for the given string. */ + cnt = 0; + hval = keylen; + while (cnt < keylen) + { + hval <<= 4; + hval += key[cnt++]; + g = hval & (0xf << (LONGBITS - 4)); + if (g != 0) + { + hval ^= g >> (LONGBITS - 8); + hval ^= g; + } + } + return hval; +} + + +static unsigned long +next_prime(unsigned long seed) +{ + /* Make it definitely odd. */ + seed |= 1; + + while (!is_prime (seed)) + seed += 2; + + return seed; +} + + +static int +is_prime(unsigned long candidate) +{ + /* No even number and none less than 10 will be passwd here. */ + unsigned long div = 3; + unsigned long sq = div * div; + + while (sq < candidate && candidate % div != 0) + { + ++div; + sq += 4 * div; + ++div; + } + + return candidate % div != 0; +} + +/* + * Local Variables: + * mode:c + * c-basic-offset:2 + * End: + */ diff --git a/locale/hash.h b/locale/hash.h new file mode 100644 index 0000000000..5f60a44a5b --- /dev/null +++ b/locale/hash.h @@ -0,0 +1,50 @@ +/* Copyright (C) 1995 Free Software Foundation, Inc. + +The GNU C Library is free software; you can redistribute it and/or +modify it under the terms of the GNU Library General Public License as +published by the Free Software Foundation; either version 2 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 +Library General Public License for more details. + +You should have received a copy of the GNU Library General Public +License along with the GNU C Library; see the file COPYING.LIB. If +not, write to the Free Software Foundation, Inc., 675 Mass Ave, +Cambridge, MA 02139, USA. */ + +#ifndef _HASH_H +#define _HASH_H + +#include <obstack.h> + +typedef struct hash_table + { + unsigned long size; + unsigned long filled; + void *first; + void *table; + struct obstack mem_pool; + } +hash_table; + + +int init_hash (hash_table *htab, unsigned long init_size); +int delete_hash(hash_table *htab); +int insert_entry (hash_table *htab, const char *key, size_t keylen, + void *data); +int find_entry (hash_table *htab, const char *key, size_t keylen, + void **result); + +int iterate_table (hash_table *htab, void **ptr, void **result); + +#endif /* hash.h */ +/* + * Local Variables: + * mode:c + * c-basic-offset:2 + * End: + */ + diff --git a/locale/iso-4217.def b/locale/iso-4217.def new file mode 100644 index 0000000000..849420365e --- /dev/null +++ b/locale/iso-4217.def @@ -0,0 +1,36 @@ +/* + * Defines the valid international currency symbols according to ISO-4217. + * This is used in monetary.c(monetary_check). + * + * !!! The list has to be sorted !!! + */ +DEFINE_INT_CURR("ATS ") /* Austria */ +DEFINE_INT_CURR("BEF ") /* Belgium */ +DEFINE_INT_CURR("CAD ") /* Canada */ +DEFINE_INT_CURR("CHF ") /* Switzerland */ +DEFINE_INT_CURR("DEM ") /* Germany */ +DEFINE_INT_CURR("DKK ") /* Denmark */ +DEFINE_INT_CURR("EEK ") /* Estonia */ +DEFINE_INT_CURR("ESP ") /* Spain */ +DEFINE_INT_CURR("FIM ") /* Finland */ +DEFINE_INT_CURR("FRF ") /* France */ +DEFINE_INT_CURR("GBP ") /* Great Britain */ +DEFINE_INT_CURR("GRD ") /* Greece */ +DEFINE_INT_CURR("HRD ") /* Croatia */ +DEFINE_INT_CURR("HUF ") /* Hungary */ +DEFINE_INT_CURR("IEP ") /* Ireland */ +DEFINE_INT_CURR("ILS ") /* Israel */ +DEFINE_INT_CURR("ISK ") /* Iceland */ +DEFINE_INT_CURR("ITL ") /* Italy */ +DEFINE_INT_CURR("LTL ") /* Lithuania */ +DEFINE_INT_CURR("LUF ") /* Luxemburg */ +DEFINE_INT_CURR("LVL ") /* Latvia */ +DEFINE_INT_CURR("NLG ") /* Netherlands */ +DEFINE_INT_CURR("NOK ") /* Norway */ +DEFINE_INT_CURR("PLZ ") /* Poland */ +DEFINE_INT_CURR("PTE ") /* Portugal */ +DEFINE_INT_CURR("ROL ") /* Romania */ +DEFINE_INT_CURR("RUR ") /* Russia */ +DEFINE_INT_CURR("SEK ") /* Sweden */ +DEFINE_INT_CURR("SIT ") /* Slovenia */ +DEFINE_INT_CURR("USD ") /* United States */ diff --git a/locale/keyword.gperf b/locale/keyword.gperf new file mode 100644 index 0000000000..20941bc03d --- /dev/null +++ b/locale/keyword.gperf @@ -0,0 +1,77 @@ +%{ +/* `strncmp' is used for comparison. */ +#include <string.h> + +/* This file defines `enum token'. */ +#include "token.h" +%} +struct locale_keyword { char *name; enum token token_id; }; +%% +END, TOK_END +IGNORE, TOK_IGNORE +LC_COLLATE, _NL_NUM_LC_COLLATE +LC_CTYPE, _NL_NUM_LC_CTYPE +LC_MESSAGES, _NL_NUM_LC_MESSAGES +LC_MONETARY, _NL_NUM_LC_MONETARY +LC_NUMERIC, _NL_NUM_LC_NUMERIC +LC_TIME, _NL_NUM_LC_TIME +UNDEFINED, TOK_UNDEFINED +abday, ABDAY_1 +abmon, ABMON_1 +alpha, TOK_ALPHA +alt_digits, ALT_DIGITS +am_pm, AM_STR +backward, TOK_BACKWARD +blank, TOK_BLANK +cntrl, TOK_CNTRL +collating_element, TOK_COLLATING_ELEMENT +collating_symbol, TOK_COLLATING_SYMBOL +comment_char, TOK_COMMENT_CHAR +copy, TOK_COPY +currency_symbol, CURRENCY_SYMBOL +d_fmt, D_FMT +d_t_fmt, D_T_FMT +day, DAY_1 +decimal_point, DECIMAL_POINT +digit, TOK_DIGIT +era, ERA +era_d_fmt, ERA_D_FMT +era_year, ERA_YEAR +escape_char, TOK_ESCAPE_CHAR +forward, TOK_FORWARD +frac_digits, FRAC_DIGITS +from, TOK_FROM +graph, TOK_GRAPH +grouping, GROUPING +int_curr_symbol, INT_CURR_SYMBOL +int_frac_digits, INT_FRAC_DIGITS +lower, TOK_LOWER +mon, MON_1 +mon_decimal_point, MON_DECIMAL_POINT +mon_grouping, MON_GROUPING +mon_thousands_sep, MON_THOUSANDS_SEP +n_cs_precedes, N_CS_PRECEDES +n_sep_by_space, N_SEP_BY_SPACE +n_sign_posn, N_SIGN_POSN +negative_sign, NEGATIVE_SIGN +noexpr, NOEXPR +nostr, NOSTR +order_end, TOK_ORDER_END +order_start, TOK_ORDER_START +p_cs_precedes, P_CS_PRECEDES +p_sep_by_space, P_SEP_BY_SPACE +p_sign_posn, P_SIGN_POSN +position, TOK_POSITION +positive_sign, POSITIVE_SIGN +print, TOK_PRINT +punct, TOK_PUNCT +space, TOK_SPACE +t_fmt, T_FMT +t_fmt_ampm, T_FMT_AMPM +thousands_sep, THOUSANDS_SEP +tolower, TOK_TOLOWER +toupper, TOK_TOUPPER +upper, TOK_UPPER +xdigit, TOK_XDIGIT +yesexpr, YESEXPR +yesstr, YESSTR diff --git a/locale/keyword.h b/locale/keyword.h new file mode 100644 index 0000000000..1dc442aee5 --- /dev/null +++ b/locale/keyword.h @@ -0,0 +1,180 @@ +/* C code produced by gperf version 2.5 (GNU C++ version) */ +/* Command-line: gperf -acCgopt -k1,2,5, keyword.gperf */ +/* `strncmp' is used for comparison. */ +#include <string.h> + +/* This file defines `enum token'. */ +#include "token.h" +struct locale_keyword { char *name; enum token token_id; }; + +#define TOTAL_KEYWORDS 68 +#define MIN_WORD_LENGTH 3 +#define MAX_WORD_LENGTH 17 +#define MIN_HASH_VALUE 4 +#define MAX_HASH_VALUE 140 +/* maximum key range = 137, duplicates = 0 */ + +#ifdef __GNUC__ +inline +#endif +static unsigned int +hash (register const char *str, register int len) +{ + static const unsigned char asso_values[] = + { + 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, + 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, + 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, + 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, + 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, + 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, + 141, 141, 141, 141, 141, 141, 141, 0, 141, 65, + 5, 0, 141, 30, 141, 141, 0, 141, 0, 95, + 141, 141, 0, 141, 45, 10, 141, 141, 141, 141, + 141, 141, 141, 141, 141, 5, 141, 10, 85, 0, + 20, 0, 40, 35, 30, 10, 141, 0, 30, 15, + 15, 0, 0, 141, 55, 0, 0, 80, 141, 15, + 10, 0, 141, 141, 141, 141, 141, 141, + }; + register int hval = len; + + switch (hval) + { + default: + case 5: + hval += asso_values[str[4]]; + case 4: + case 3: + case 2: + hval += asso_values[str[1]]; + case 1: + hval += asso_values[str[0]]; + } + return hval; +} + +#ifdef __GNUC__ +inline +#endif +const struct locale_keyword * +in_word_set (register const char *str, register int len) +{ + static const struct locale_keyword wordlist[] = + { + {"",}, {"",}, {"",}, {"",}, + {"copy", TOK_COPY}, + {"space", TOK_SPACE}, + {"yesstr", YESSTR}, + {"toupper", TOK_TOUPPER}, + {"position", TOK_POSITION}, + {"",}, + {"t_fmt", T_FMT}, + {"escape_char", TOK_ESCAPE_CHAR}, + {"comment_char", TOK_COMMENT_CHAR}, + {"positive_sign", POSITIVE_SIGN}, + {"",}, + {"t_fmt_ampm", T_FMT_AMPM}, + {"",}, + {"yesexpr", YESEXPR}, + {"mon", MON_1}, + {"p_sep_by_space", P_SEP_BY_SPACE}, + {"LC_NUMERIC", _NL_NUM_LC_NUMERIC}, + {"noexpr", NOEXPR}, + {"tolower", TOK_TOLOWER}, + {"p_cs_precedes", P_CS_PRECEDES}, + {"UNDEFINED", TOK_UNDEFINED}, + {"",}, + {"collating_symbol", TOK_COLLATING_SYMBOL}, + {"collating_element", TOK_COLLATING_ELEMENT}, + {"negative_sign", NEGATIVE_SIGN}, + {"",}, + {"d_fmt", D_FMT}, + {"",}, + {"mon_thousands_sep", MON_THOUSANDS_SEP}, + {"day", DAY_1}, + {"n_sep_by_space", N_SEP_BY_SPACE}, + {"digit", TOK_DIGIT}, + {"IGNORE", TOK_IGNORE}, + {"LC_TIME", _NL_NUM_LC_TIME}, + {"n_cs_precedes", N_CS_PRECEDES}, + {"",}, + {"int_curr_symbol", INT_CURR_SYMBOL}, + {"",}, {"",}, + {"thousands_sep", THOUSANDS_SEP}, + {"",}, + {"am_pm", AM_STR}, + {"xdigit", TOK_XDIGIT}, + {"",}, + {"decimal_point", DECIMAL_POINT}, + {"",}, + {"cntrl", TOK_CNTRL}, + {"p_sign_posn", P_SIGN_POSN}, + {"mon_decimal_point", MON_DECIMAL_POINT}, + {"LC_CTYPE", _NL_NUM_LC_CTYPE}, + {"",}, + {"alpha", TOK_ALPHA}, + {"",}, + {"forward", TOK_FORWARD}, + {"era", ERA}, + {"",}, + {"print", TOK_PRINT}, + {"",}, + {"mon_grouping", MON_GROUPING}, + {"era_year", ERA_YEAR}, + {"",}, {"",}, + {"n_sign_posn", N_SIGN_POSN}, + {"",}, + {"END", TOK_END}, + {"",}, + {"alt_digits", ALT_DIGITS}, + {"",}, + {"d_t_fmt", D_T_FMT}, + {"",}, {"",}, + {"nostr", NOSTR}, + {"LC_MESSAGES", _NL_NUM_LC_MESSAGES}, + {"",}, {"",}, {"",}, + {"int_frac_digits", INT_FRAC_DIGITS}, + {"",}, {"",}, {"",}, + {"era_d_fmt", ERA_D_FMT}, + {"punct", TOK_PUNCT}, + {"",}, {"",}, {"",}, {"",}, + {"lower", TOK_LOWER}, + {"",}, {"",}, {"",}, {"",}, + {"currency_symbol", CURRENCY_SYMBOL}, + {"",}, {"",}, + {"grouping", GROUPING}, + {"from", TOK_FROM}, + {"abday", ABDAY_1}, + {"",}, {"",}, {"",}, {"",}, + {"LC_COLLATE", _NL_NUM_LC_COLLATE}, + {"LC_MONETARY", _NL_NUM_LC_MONETARY}, + {"",}, {"",}, {"",}, {"",}, + {"frac_digits", FRAC_DIGITS}, + {"",}, {"",}, {"",}, + {"abmon", ABMON_1}, + {"",}, {"",}, + {"backward", TOK_BACKWARD}, + {"order_end", TOK_ORDER_END}, + {"blank", TOK_BLANK}, + {"order_start", TOK_ORDER_START}, + {"",}, {"",}, {"",}, + {"graph", TOK_GRAPH}, + {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, + {"",}, {"",}, {"",}, {"",}, {"",}, + {"upper", TOK_UPPER}, + }; + + if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH) + { + register int key = hash (str, len); + + if (key <= MAX_HASH_VALUE && key >= 0) + { + register const char *s = wordlist[key].name; + + if (*s == *str && !strncmp (str + 1, s + 1, len - 1)) + return &wordlist[key]; + } + } + return 0; +} diff --git a/locale/langinfo.h b/locale/langinfo.h index e94be68430..245dcf8b92 100644 --- a/locale/langinfo.h +++ b/locale/langinfo.h @@ -145,8 +145,10 @@ typedef enum _NL_NUM_LC_MESSAGES, /* Stubs for unfinished categories. */ - _NL_NUM_LC_COLLATE = 0, + _NL_NUM_LC_COLLATE = _NL_ITEM (LC_COLLATE, 0), + /* This marks the highest value used. */ + _NL_NUM } nl_item; diff --git a/locale/libintl.h b/locale/libintl.h new file mode 100644 index 0000000000..802bd45492 --- /dev/null +++ b/locale/libintl.h @@ -0,0 +1,77 @@ +/* libintl.h -- Message catalogs for internationalization. +Copyright (C) 1995 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 Library General Public License as +published by the Free Software Foundation; either version 2 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 +Library General Public License for more details. + +You should have received a copy of the GNU Library General Public +License along with the GNU C Library; see the file COPYING.LIB. If +not, write to the Free Software Foundation, Inc., 675 Mass Ave, +Cambridge, MA 02139, USA. */ + +#ifndef _LIBINTL_H +#define _LIBINTL_H 1 + +#include <locale.h> + + +/* Look up MSGID in the current default message catalog for the current + LC_MESSAGES locale. If not found, returns MSGID itself (the default + text). */ +extern char *gettext __P ((const char *__msgid)); + +/* Look up MSGID in the DOMAINNAME message catalog for the current + LC_MESSAGES locale. */ +extern char *dgettext __P ((const char *__domainname, const char *__msgid)); + +/* Look up MSGID in the DOMAINNAME message catalog for the current CATEGORY + locale. */ +extern char *__dcgettext __P ((const char *__domainname, const char *__msgid, + int __category)); +extern char *dcgettext __P ((const char *__domainname, const char *__msgid, + int __category)); + + +/* Set the current default message catalog to DOMAINNAME. + If DOMAINNAME is null, return the current default. + If DOMAINNAME is "", reset to the default of "messages". */ +extern char *textdomain __P ((const char *__domainname)); + +/* Specify that the DOMAINNAME message catalog will be found + in DIRNAME rather than in the system locale data base. */ +extern char *bindtextdomain __P ((const char *__domainname, + const char *__dirname)); + + +#if 1 /* XXX stub for the moment */ +#define gettext(msgid) (msgid) +#define textdomain(domain) (void)(domain) +#else +#define gettext(msgid) __gettext (msgid) +#define __gettext(msgid) __dgettext (NULL, (msgid)) + +#define dgettext(domainname, msgid) __dgettext (domainname, msgid) +#define __dgettext(domainname, msgid) \ + __dcgettext (NULL, (msgid), LC_MESSAGES) + +#ifdef __GNUC__ +#define __dcgettext(domainname, msgid, category) \ + (__extension__ \ + ({ \ + static char *__translation__; \ + if (! __translation__) \ + __translation__ = (__dcgettext) ((domainname), (msgid), (category)); \ + __translation__; \ + })) +#endif +#endif + +#endif /* libintl.h */ diff --git a/locale/loadlocale.c b/locale/loadlocale.c index 5073bd4be3..7e29c97205 100644 --- a/locale/loadlocale.c +++ b/locale/loadlocale.c @@ -69,13 +69,14 @@ _nl_load_locale (int category, char **name) } { - const char localedir[] = "/share/locale/"; /* XXX */ const char *catname = _nl_category_names[category]; size_t namelen = strlen (*name); size_t catlen = strlen (catname); - char file[sizeof localedir + namelen + catlen * 2 + 4]; - sprintf (file, "%s%s/%s", - strchr (*name, '/') != NULL ? "" : localedir, *name, catname); + char file[sizeof LOCALE_PATH + 1 + namelen + catlen * 2 + 4]; + if (strchr (*name, '/') != NULL) + sprintf (file, "%s/%s", *name, catname); + else + sprintf (file, "%s/%s/%s", LOCALE_PATH, *name, catname); fd = __open (file, O_RDONLY); if (fd < 0) return NULL; diff --git a/locale/locale.c b/locale/locale.c new file mode 100644 index 0000000000..20385f07d8 --- /dev/null +++ b/locale/locale.c @@ -0,0 +1,538 @@ +/* Copyright (C) 1995 Free Software Foundation, Inc. + +The GNU C Library is free software; you can redistribute it and/or +modify it under the terms of the GNU Library General Public License as +published by the Free Software Foundation; either version 2 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 +Library General Public License for more details. + +You should have received a copy of the GNU Library General Public +License along with the GNU C Library; see the file COPYING.LIB. If +not, write to the Free Software Foundation, Inc., 675 Mass Ave, +Cambridge, MA 02139, USA. */ + +#include <dirent.h> +#include <getopt.h> +#include <langinfo.h> +#include <libintl.h> +#include <limits.h> +#include <locale.h> +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> + +#include "localedef.h" + + +/* If set dump C code describing the current locale. */ +static int do_dump; + +/* If set print the name of the category. */ +static int show_category_name; + +/* If set print the name of the item. */ +static int show_keyword_name; + +/* Long options. */ +static const struct option long_options[] = + { + { "all-locales", no_argument, NULL, 'a' }, + { "category-name", no_argument, &show_category_name, 1 }, + { "charmaps", no_argument, NULL, 'm' }, + { "dump", no_argument, &do_dump, 1 }, + { "help", no_argument, NULL, 'h' }, + { "keyword-name", no_argument, &show_keyword_name, 1 }, + { "version", no_argument, NULL, 'v' }, + { NULL, 0, NULL, 0 } + }; + + +/* We don't have these constants defined because we don't use them. Give + default values. */ +#define CTYPE_MB_CUR_MIN 0 +#define CTYPE_MB_CUR_MAX 0 +#define CTYPE_HASH_SIZE 0 +#define CTYPE_HASH_LAYERS 0 +#define CTYPE_CLASS 0 +#define CTYPE_TOUPPER_EB 0 +#define CTYPE_TOLOWER_EB 0 +#define CTYPE_TOUPPER_EL 0 +#define CTYPE_TOLOWER_EL 0 + + +/* We have all categories defined in `categories.def'. Now construct + the description and data structure used for all categories. */ +#define DEFINE_CATEGORY(category, name, items, postload, in, check, out) \ + static struct cat_item category##_desc[] = \ + { \ + NO_PAREN items \ + }; + +#include "categories.def" +#undef DEFINE_CATEGORY + +static struct category category[] = + { +#define DEFINE_CATEGORY(category, name, items, postload, in, check, out) \ + { _NL_NUM_##category, name, NELEMS (category##_desc) - 1, \ + category##_desc, NULL, NULL, NULL, out }, +#include "categories.def" +#undef DEFINE_CATEGORY + }; +#define NCATEGORIES NELEMS (category) + + +/* Prototypes for local functions. */ +static void usage (int status) __attribute__ ((noreturn)); +static void write_locales (void); +static void write_charmaps (void); +static void show_locale_vars (void); +static void show_info (const char *name); +static void dump_category (const char *name); + + +int +main (int argc, char *argv[]) +{ + int optchar; + int do_all = 0; + int do_help = 0; + int do_version = 0; + int do_charmaps = 0; + + /* Set initial values for global varaibles. */ + do_dump = 0; + show_category_name = 0; + show_keyword_name = 0; + + /* Set locale. Do not set LC_ALL because the other categories must + not be affected (acccording to POSIX.2). */ + setlocale (LC_CTYPE, ""); + setlocale (LC_MESSAGES, ""); + + /* Initialize the message catalog. */ + textdomain (PACKAGE); + + while ((optchar = getopt_long (argc, argv, "achkmv", long_options, NULL)) + != EOF) + switch (optchar) + { + case '\0': + break; + case 'a': + do_all = 1; + break; + case 'c': + show_category_name = 1; + break; + case 'h': + do_help = 1; + break; + case 'k': + show_keyword_name = 1; + break; + case 'm': + do_charmaps = 1; + break; + case 'v': + do_version = 1; + break; + default: + error (1, 0, gettext ("illegal option \"%s\""), optarg); + break; + } + + /* Version information is requested. */ + if (do_version) + { + fprintf (stderr, "GNU %s %s\n", PACKAGE, VERSION); + exit (EXIT_SUCCESS); + } + + /* Help is requested. */ + if (do_help) + usage (EXIT_SUCCESS); + + /* Dump C code. */ + if (do_dump) + { + printf ("\ +/* Generated by GNU %s %s. */\n\ +\n\ +#include \"localeinfo.h\"\n", program_invocation_name, VERSION); + + while (optind < argc) + dump_category (argv[optind++]); + + exit (EXIT_SUCCESS); + } + + /* `-a' requests the names of all available locales. */ + if (do_all != 0) + { + write_locales (); + exit (EXIT_SUCCESS); + } + + /* `m' requests the names of all available charmaps. The names can be + used for the -f argument to localedef(3). */ + if (do_charmaps != 0) + { + write_charmaps (); + exit (EXIT_SUCCESS); + } + + /* If no real argument is given we have to print the contents of the + current locale definition variables. These are LANG and the LC_*. */ + if (optind == argc && show_keyword_name == 0 && show_category_name == 0) + { + show_locale_vars (); + exit (EXIT_SUCCESS); + } + + /* Process all given names. */ + while (optind < argc) + show_info (argv[optind++]); + + exit (EXIT_SUCCESS); +} + + +/* Display usage information and exit. */ +static void +usage(int status) +{ + if (status != EXIT_SUCCESS) + fprintf (stderr, gettext ("Try `%s --help' for more information.\n"), + program_invocation_name); + else + printf(gettext ("\ +Usage: %s [OPTION]... name\n\ +Mandatory arguments to long options are mandatory for short options too.\n\ + -h, --help display this help and exit\n\ + -v, --version output version information and exit\n\ +\n\ + -a, --all-locales write names of available locales\n\ + -m, --charmaps write names of available charmaps\n\ +\n\ + -c, --category-name write names of selected categories\n\ + -k, --keyword-name write names of selected keywords\n\ +\n\ + --dump dump C code describing the current locale\n\ + (this code can be used in the C library)\n\ +"), program_invocation_name); + + exit (status); +} + + +/* Write the names of all available locales to stdout. */ +static void +write_locales (void) +{ + DIR *dir; + struct dirent *dirent; + + /* `POSIX' locale is always available (POSIX.2 4.34.3). */ + puts ("POSIX"); + + dir = opendir (LOCALE_PATH); + if (dir == NULL) + { + error (1, errno, gettext ("cannot read locale directory `%s'"), + LOCALE_PATH); + return; + } + + /* Now we can look for all files in the directory. */ + while ((dirent = readdir (dir)) != NULL) + if (strcmp (dirent->d_name, ".") != 0 + && strcmp (dirent->d_name, "..") != 0) + puts (dirent->d_name); + + closedir (dir); +} + + +/* Write the names of all available character maps to stdout. */ +static void +write_charmaps (void) +{ + DIR *dir; + struct dirent *dirent; + + dir = opendir (CHARMAP_PATH); + if (dir == NULL) + { + error (1, errno, gettext ("cannot read character map directory `%s'"), + CHARMAP_PATH); + return; + } + + /* Now we can look for all files in the directory. */ + while ((dirent = readdir (dir)) != NULL) + if (strcmp (dirent->d_name, ".") != 0 + && strcmp (dirent->d_name, "..") != 0) + puts (dirent->d_name); + + closedir (dir); +} + + +/* We have to show the contents of the environments determining the + locale. */ +static void +show_locale_vars (void) +{ + size_t cat_no; + const char *lcall = getenv ("LC_ALL"); + const char *lang = getenv ("LANG") ? : "POSIX"; + + void get_source (const char *name) + { + char *val = getenv (name); + + if (lcall != NULL || val == NULL) + printf ("%s=\"%s\"\n", name, lcall ? : lang); + else + printf ("%s=%s\n", name, val); + } + + /* LANG has to be the first value. */ + printf ("LANG=%s\n", lang); + + /* Now all categories in an unspecified order. */ + for (cat_no = 0; cat_no < NCATEGORIES; ++cat_no) + get_source (category[cat_no].name); + + /* The last is the LC_ALL value. */ + printf ("LC_ALL=%s\n", lcall ? : ""); +} + + +/* Show the information request for NAME. */ +static void +show_info (const char *name) +{ + size_t cat_no; + + void print_item (struct cat_item *item) + { + if (show_keyword_name != 0) + printf ("%s=", item->name); + + switch (item->value_type) + { + case string: + printf ("%s%s%s", show_keyword_name ? "\"" : "", + nl_langinfo (item->item_id) ? : "", + show_keyword_name ? "\"" : ""); + break; + case stringarray: + { + int cnt; + const char *val; + + if (show_keyword_name) + putchar ('"'); + + for (cnt = 0; cnt < item->max - 1; ++cnt) + { + val = nl_langinfo (item->item_id + cnt); + printf ("%s;", val ? : ""); + } + + val = nl_langinfo (item->item_id + cnt); + printf ("%s", val ? : ""); + + if (show_keyword_name) + putchar ('"'); + } + break; + case byte: + { + const char *val = nl_langinfo (item->item_id); + + if (val != NULL) + printf ("%d", *val == CHAR_MAX ? -1 : *val); + } + break; + case bytearray: + { + const char *val = nl_langinfo (item->item_id); + int cnt = val ? strlen (val) : 0; + + while (cnt > 1) + { + printf ("%d;", *val == CHAR_MAX ? -1 : *val); + --cnt; + ++val; + } + + printf ("%d", cnt == 0 || *val == CHAR_MAX ? -1 : *val); + } + break; + default: + } + putchar ('\n'); + } + + for (cat_no = 0; cat_no < NCATEGORIES; ++cat_no) + { + size_t item_no; + + if (category[cat_no].outfct != NULL) + /* Categories which need special handling of the output are + not written. This is especially for LC_CTYPE and LC_COLLATE. + It does not make sense to have this large number of cryptic + characters displayed. */ + continue; + + if (strcmp (name, category[cat_no].name) == 0) + /* Print the whole category. */ + { + if (show_category_name != 0) + puts (category[cat_no].name); + + for (item_no = 0; item_no < category[cat_no].number; ++item_no) + print_item (&category[cat_no].item_desc[item_no]); + + return; + } + + for (item_no = 0; item_no < category[cat_no].number; ++item_no) + if (strcmp (name, category[cat_no].item_desc[item_no].name) == 0) + { + if (show_category_name != 0) + puts (category[cat_no].name); + + print_item (&category[cat_no].item_desc[item_no]); + return; + } + } +} + + +static void +dump_category (const char *name) +{ + char *locname; + size_t cat_no, item_no, nstrings; + + for (cat_no = 0; cat_no < NCATEGORIES; ++cat_no) + if (strcmp (name, category[cat_no].name) == 0) + break; + + if (cat_no >= NCATEGORIES) + return; + + /* The NAME specifies a correct locale category. */ + if (category[cat_no].outfct != NULL) + { + category[cat_no].outfct (); + return; + } + + locname = (getenv ("LC_ALL") ?: getenv (name) ?: + getenv ("LANG") ?: (char *) "POSIX"); + + /* Determine the number of strings in advance. */ + nstrings = 0; + for (item_no = 0; item_no < category[cat_no].number; ++item_no) + switch (category[cat_no].item_desc[item_no].value_type) + { + case string: + case byte: + case bytearray: + ++nstrings; + break; + case stringarray: + nstrings += category[cat_no].item_desc[item_no].max; + default: + } + + printf ("\nconst struct locale_data _nl_%s_%s =\n{\n" + " NULL, 0, /* no file mapped */\n %Zu,\n {\n", + locname, name, nstrings); + + for (item_no = 0; item_no < category[cat_no].number; ++item_no) + switch (category[cat_no].item_desc[item_no].value_type) + { + case string: + { + const char *val = nl_langinfo ( + category[cat_no].item_desc[item_no].item_id); + + if (val != NULL) + printf (" \"%s\",\n", val); + else + puts (" NULL,"); + } + break; + case stringarray: + { + const char *val; + int cnt; + + for (cnt = 0; cnt < category[cat_no].item_desc[item_no].max; ++cnt) + { + val = nl_langinfo ( + category[cat_no].item_desc[item_no].item_id + cnt); + + if (val != NULL) + printf (" \"%s\",\n", val); + else + puts (" NULL,"); + } + } + break; + case byte: + { + const char *val = nl_langinfo ( + category[cat_no].item_desc[item_no].item_id); + + if (val != NULL) + printf (" \"\\%o\",\n", + *(unsigned char *) val ? : UCHAR_MAX); + else + puts (" NULL,"); + } + break; + case bytearray: + { + const char *bytes = nl_langinfo ( + category[cat_no].item_desc[item_no].item_id); + + if (bytes != NULL) + { + fputs (" \"", stdout); + if (*bytes != '\0') + do + printf ("\\%o", *(unsigned char *) bytes++); + while (*bytes != '\0'); + else + printf ("\\%o", UCHAR_MAX); + + puts ("\","); + } + else + puts (" NULL,"); + } + break; + default: + break; + } + + puts (" }\n};"); +} + +/* + * Local Variables: + * mode:c + * c-basic-offset:2 + * End: + */ diff --git a/locale/localedef.c b/locale/localedef.c new file mode 100644 index 0000000000..c331e11888 --- /dev/null +++ b/locale/localedef.c @@ -0,0 +1,261 @@ +/* Copyright (C) 1995 Free Software Foundation, Inc. + +The GNU C Library is free software; you can redistribute it and/or +modify it under the terms of the GNU Library General Public License as +published by the Free Software Foundation; either version 2 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 +Library General Public License for more details. + +You should have received a copy of the GNU Library General Public +License along with the GNU C Library; see the file COPYING.LIB. If +not, write to the Free Software Foundation, Inc., 675 Mass Ave, +Cambridge, MA 02139, USA. */ + +#include <getopt.h> +#include <libintl.h> +#include <locale.h> +#include <stdarg.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <sys/stat.h> + +#include "localedef.h" + +/* The charmap file used. If none given DEFAULT_CHARMAP is used. */ +static char *charmap_file; + +/* If set output is always written, even when warning are given. */ +static int force_output; + +/* The input file name. */ +static char *input_file; + +/* Path leading to the destination directory for the produced files. */ +char *output_path; + +/* If this is defined be POSIX conform. */ +int posix_conformance; + +/* If not zero give a lot more messages. */ +int verbose; + +/* Long options. */ +static const struct option long_options[] = + { + { "charmap", required_argument, NULL, 'f' }, + { "debug", no_argument, NULL, 'd' }, + { "help", no_argument, NULL, 'h' }, + { "force", no_argument, NULL, 'c' }, + { "inputfile", required_argument, NULL, 'i' }, + { "posix", no_argument, &posix_conformance, 1 }, + { "verbose", no_argument, &verbose, 1}, + { "version", no_argument, NULL, 'V' }, + { NULL, 0, NULL, 0 } + }; + + +/* This is defined in error-msg.h. */ +extern int warning_cntr; + + +/* Prototypes for local functions. */ +static void usage (int status) __attribute__ ((noreturn)); +static int construct_output_path (const char *path); + +int +main(int argc, char *argv[]) +{ + int optchar; + int cannot_write; + int do_help = 0; + int do_version = 0; + + /* Set initial values for global varaibles. */ + charmap_file = NULL; + force_output = 0; + input_file = 0; + posix_conformance = getenv ("POSIXLY_CORRECT") != NULL; + verbose = 0; + + /* Set locale. Do not set LC_ALL because the other categories must + not be affected (acccording to POSIX.2). */ + setlocale (LC_MESSAGES, ""); + setlocale (LC_CTYPE, ""); + + /* Initialize the message catalog. */ + textdomain (PACKAGE); + + while ((optchar = getopt_long (argc, argv, "cdf:hi:vV", long_options, NULL)) + != EOF) + switch (optchar) + { + case '\0': + break; + case 'c': + force_output = 1; + break; + case 'f': + if (charmap_file != NULL) + error (0, 0, gettext ("\"%s %s\" overwrites old option \"%s\""), + "-f", optarg, charmap_file); + charmap_file = optarg; + break; + case 'h': + do_help = 1; + break; + case 'i': + if (input_file != NULL) + error (0, 0, gettext ("\"%s %s\" overwrites old option \"%s\""), + "-i", optarg, input_file); + input_file = optarg; + break; + case 'v': + verbose = 1; + break; + case 'V': + do_version = 1; + break; + default: + usage (4); + break; + } + + /* POSIX.2 requires to be verbose about missing characters in the + character map. */ + verbose |= posix_conformance; + + /* Version information is requested. */ + if (do_version) + { + fprintf (stderr, "GNU %s %s\n", PACKAGE, VERSION); + exit (EXIT_SUCCESS); + } + + /* Help is requested. */ + if (do_help) + usage (0); + + if (argc - optind != 1) + /* We need exactly one non-option parameter. */ + usage (4); + + /* The parameter describes the output path of the constructed files. + If the files cannot be written return a non-zero value. */ + cannot_write = construct_output_path (argv[optind]); + + /* Now that the parameters are processed we have to reset the local + ctype locale. (POSIX.2 4.35.5.2) */ + setlocale (LC_CTYPE, "POSIX"); + + /* Look whether the system really allows locale definitions. */ + if (sysconf (_SC_2_LOCALEDEF) < 0) + error (3, 0, + gettext ("warning: system does not define `_POSIX2_LOCALEDEF'")); + + /* Process charmap file. */ + charmap_read (charmap_file); + + /* Now read the locale file. */ + locfile_read (input_file); + + /* Check all categories for consistency. */ + categories_check (); + + /* We are now able to write the data files. If warning were given we + do it only if it is explicitly requested (--force). */ + if (warning_cntr == 0 || force_output != 0) + if (cannot_write != 0) + error (0, 0, gettext ("cannot write output file `%s': %s"), + output_path, strerror (cannot_write)); + else + categories_write (); + else + error (0, 0, + gettext ("no output file produced because warning were issued")); + + exit (EXIT_SUCCESS); +} + + +/* Display usage information and exit. */ +static void +usage(int status) +{ + if (status != EXIT_SUCCESS) + fprintf (stderr, gettext ("Try `%s --help' for more information.\n"), + program_invocation_name); + else + printf(gettext ("\ +Usage: %s [OPTION]... name\n\ +Mandatory arguments to long options are mandatory for short options too.\n\ + -c, --force create output even if warning messages have been issued\n\ + -h, --help display this help and exit\n\ + -V, --version output version information and exit\n\ +\n\ + -i, --inputfile=FILE source definitions are found in FILE\n\ + -f, --charmap=FILE symbolic character names defined in FILE\n\ +\n\ + -v, --verbose print more messages\n\ + --posix be strictly POSIX conform\n\ +\n\ +System's directory for character maps: %s\n\ + locale files : %s\n\ +"), program_invocation_name, CHARMAP_PATH, LOCALE_PATH); + + exit (status); +} + + +/* The parameter to localedef describes the output path. If it does + contain a '/' character it is a relativ path. Otherwise it names the + locale this definition is for. */ +static int +construct_output_path (const char *path) +{ + int result = 0; + + if (strchr (path, '/') == NULL) + { + /* This is a system path. */ + int path_max_len = pathconf (LOCALE_PATH, _PC_PATH_MAX) + 1; + output_path = (char *) xmalloc (path_max_len); + + snprintf (output_path, path_max_len, "%s/%s", LOCALE_PATH, path); + } + else + { + char *t; + /* This is a user path. */ + output_path = malloc (strlen (path) + 2); + t = stpcpy (output_path, path); + *t = '\0'; + } + + if (euidaccess (output_path, W_OK) == -1) + /* Perhaps the directory does not exist now. Try to create it. */ + if (errno == ENOENT) + { + if (mkdir (output_path, 0777) == -1) + result = errno; + } + else + result = errno; + + if (result == 0) + strcat (output_path, "/"); + + return result; +} + +/* + * Local Variables: + * mode:c + * c-basic-offset:2 + * End: + */ diff --git a/locale/localedef.h b/locale/localedef.h new file mode 100644 index 0000000000..5958a9c5d2 --- /dev/null +++ b/locale/localedef.h @@ -0,0 +1,196 @@ +/* Copyright (C) 1995 Free Software Foundation, Inc. + +The GNU C Library is free software; you can redistribute it and/or +modify it under the terms of the GNU Library General Public License as +published by the Free Software Foundation; either version 2 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 +Library General Public License for more details. + +You should have received a copy of the GNU Library General Public +License along with the GNU C Library; see the file COPYING.LIB. If +not, write to the Free Software Foundation, Inc., 675 Mass Ave, +Cambridge, MA 02139, USA. */ + +#ifndef _LOCALEDEF_H +#define _LOCALEDEF_H 1 + +#define __need_wchar_t +#include <stddef.h> + +#include "config.h" + +#include "hash.h" + + +/* Needed always. */ +#define MAX(a, b) ({typeof (a) _a = (a); typeof (b) _b = (b); \ + _a > _b ? _a : _b; }) +#define MIN(a, b) ({typeof (a) _a = (a); typeof (b) _b = (b); \ + _a < _b ? _a : _b; }) + +/* Determine number of elements in ARR. */ +#define NELEMS(arr) ((sizeof (arr)) / (sizeof (arr[0]))) + +/* I simply love these GCC features ... :) */ +#define NO_PAREN(arg, rest...) arg, ##rest + + +/* The character set used in the locale is defined in a character map file. + The information of the file is stored in the following struct. */ +struct charmap + { + char *filename; + char *codeset_name; + int mb_cur_min; + int mb_cur_max; + char escape_char; + char comment_char; + hash_table table; + int hash_size; + int hash_layers; + }; + +/* Data structure for representing charmap database. */ +extern struct charmap charmap_data; + + +/* We can map the types of the entries into four categories. */ +enum value_type { none, string, stringarray, byte, bytearray, integer }; + +/* Definition of the data structure which represents a category and its + items. */ +struct category +{ + int cat_id; + const char *name; + size_t number; + struct cat_item + { + int item_id; + const char *name; + enum { std, opt } status; + enum value_type value_type; + int min; + int max; + } *item_desc; + char **item_value; + void (*infct)(int); + void (*checkfct)(void); + int (*outfct)(void); + int filled; + char *copy_locale; +}; + +/* This a the structure which contains all information about all + categories. */ +extern struct category category[]; + + +/* The function used to load the contents of a charmap file into the + the global variable `charmap_data'. */ +void charmap_read (const char *filename); + +/* Find a character constant given by its name in the hash table. */ +static inline wchar_t find_char (const char *name, size_t len) +{ + wchar_t retval; + if (find_entry (&charmap_data.table, name, len, (void **) &retval) != 0) + return retval; + else + return -1; +} + +/* Path to the directory the output files are written in. */ +extern char *output_path; + +/* If this is defined be POSIX conform. */ +extern int posix_conformance; + +/* If not zero give a lot more messages. */ +extern int verbose; + +/* This structure contains all informations about the status of of + reading the locale definition file. */ +struct locfile_data + { + const char *filename; + char escape_char; + char comment_char; + size_t bufsize; + char *buf; + char *strbuf; + size_t buf_ptr; + int continue_line; + size_t returned_tokens; + size_t line_no; + }; + +/* The status variable. */ +extern struct locfile_data locfile_data; + +/* Open the locale definition file. */ +void locfile_open (const char *fname); + +/* Return the next token from the locale definition file. */ +int locfile_lex (char **token, int *token_len); +/* Dito, but check for EOF. */ +int xlocfile_lex (char **token, int *token_len); + +/* Ignore the rest of the line. First TOKEN given if != 0. Warn about + anything other than end of line if WARN_FLAG nonzero. */ +void ignore_to_eol (int token, int warn_flag); + +/* Code a character with UTF-8 if the character map has multi-byte + characters. */ +int char_to_utf (char *buf, int char_val); + + +/* Read the locale defintion file FNAME and fill the appropriate + data structures. */ +void locfile_read (const char *fname); + +/* Check categories for consistency. */ +void categories_check (void); + +/* Write out the binary representation of the category data. */ +void categories_write (void); + + +/* Treat reading the LC_COLLATE definition. */ +void collate_input (int token); + +/* Treat reading the LC_CTYPE definition. */ +void ctype_input (int token); +void ctype_check (void); +int ctype_output (void); + +/* Treat reading the LC_MONETARY definition. */ +void monetary_check (void); + +/* Treat reading the LC_MESSAGES definition. */ +void messages_check (void); + +/* Treat reading the LC_NUMERIC definition. */ +void numeric_check (void); + + +/* Print an error message, possibly with NLS. */ +void error (int status, int errnum, const char *format, ...) + __attribute__ ((format (printf, 3, 4))); + +/* Library functions. */ +void *xmalloc (size_t n); +void *xcalloc (size_t n, size_t s); +void *xrealloc (void *p, size_t n); + +/* + * Local Variables: + * mode:c + * c-basic-offset:2 + * End: + */ +#endif /* _LOCALEDEF_H */ diff --git a/locale/locfile-lex.c b/locale/locfile-lex.c new file mode 100644 index 0000000000..20e4f0f9cd --- /dev/null +++ b/locale/locfile-lex.c @@ -0,0 +1,533 @@ +/* Copyright (C) 1995 Free Software Foundation, Inc. + +The GNU C Library is free software; you can redistribute it and/or +modify it under the terms of the GNU Library General Public License as +published by the Free Software Foundation; either version 2 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 +Library General Public License for more details. + +You should have received a copy of the GNU Library General Public +License along with the GNU C Library; see the file COPYING.LIB. If +not, write to the Free Software Foundation, Inc., 675 Mass Ave, +Cambridge, MA 02139, USA. */ + +#include <ctype.h> +#include <langinfo.h> +#include <libintl.h> +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> + +#include "localedef.h" +#include "token.h" + + +/* Include the hashing table for the keywords. */ +const struct locale_keyword* in_word_set (register const char *str, + register int len); +#include "keyword.h" + + +/* Contains the status of reading the locale definition file. */ +struct locfile_data locfile_data; + +/* This is a flag used while collation input. This is the only place + where element names beside the ones defined in the character map are + allowed. There we must not give error messages. */ +int reject_new_char = 1; + +/* Prototypes for local functions. */ +static int get_char (void); + + +#define LD locfile_data + +/* Opens the locale definition file and initializes the status data structure + for following calls of `locfile_lex'. */ +void +locfile_open (const char *fname) +{ + if (fname == NULL) + /* We read from stdin. */ + LD.filename = "<stdin>"; + else + { + if (freopen (fname, "r", stdin) == NULL) + error (4, 0, gettext ("input file `%s' not found"), fname); + LD.filename = fname; + } + + /* Set default values. */ + LD.escape_char = '\\'; + LD.comment_char = '#'; + + LD.bufsize = sysconf (_SC_LINE_MAX); + LD.buf = (char *) xmalloc (LD.bufsize); + LD.strbuf = (char *) xmalloc (LD.bufsize); + + LD.buf_ptr = LD.returned_tokens = LD.line_no = 0; + + /* Now sign that we want immediately read a line. */ + LD.continue_line = 1; + LD.buf[LD.buf_ptr] = '\0'; +} + + +int +xlocfile_lex (char **token, int *token_len) +{ + int retval = locfile_lex (token, token_len); + + if (retval == 0) + /* I.e. end of file. */ + error (4, 0, gettext ("%s: unexpected end of file in locale defintion " + "file"), locfile_data.filename); + + return retval; +} + +int +locfile_lex (char **token, int *token_len) +{ + int start_again; + int retval = 0; + + do + { + int start_ptr; + + start_again = 0; + + /* Read the next line. Skip over empty lines and comments. */ + if ((LD.buf[LD.buf_ptr] == '\0' && LD.continue_line != 0) + || LD.buf_ptr >= LD.bufsize + || (posix_conformance == 0 && LD.buf[LD.buf_ptr] == LD.comment_char)) + do + { + size_t linelen; + + LD.buf_ptr = 0; + + if (fgets (LD.buf, LD.bufsize, stdin) == NULL) + { + /* This makes subsequent calls also return EOF. */ + LD.buf[0] = '\0'; + return 0; + } + + /* Increment line number counter. */ + ++LD.line_no; + + /* We now have to look whether this line is continued and + whether it at all fits into our buffer. */ + linelen = strlen (LD.buf); + + if (linelen == LD.bufsize - 1) + /* The did not fit into the buffer. */ + error (2, 0, gettext ("%s:%Zd: line too long; use " + "`getconf LINE_MAX' to get the maximum " + "line length"), LD.filename, LD.line_no); + + /* Remove '\n' at end of line. */ + if (LD.buf[linelen - 1] == '\n') + LD.buf[--linelen] = '\0'; + + if (linelen > 0 && LD.buf[linelen - 1] == LD.escape_char) + { + LD.buf[--linelen] = '\0'; + LD.continue_line = 1; + } + else + LD.continue_line = 0; + + while (isspace (LD.buf[LD.buf_ptr])) + ++LD.buf_ptr; + + /* We are not so restrictive and allow white spaces before + a comment. */ + if (posix_conformance == 0 + && LD.buf[LD.buf_ptr] == LD.comment_char + && LD.buf_ptr != 0) + error (0, 0, gettext ("%s:%Zd: comment does not start in " + "column 1"), LD.filename, LD.line_no); + } + while (LD.buf[LD.buf_ptr] == '\0' + || LD.buf[LD.buf_ptr] == LD.comment_char); + + + /* Get information for return values. */ + *token = LD.buf + LD.buf_ptr; + start_ptr = LD.buf_ptr; + + /* If no further character is in the line this is the end of a logical + line. This information is needed in the parser. */ + if (LD.buf[LD.buf_ptr] == '\0') + { + LD.buf_ptr = LD.bufsize; + retval = TOK_ENDOFLINE; + } + else if (isalpha (LD.buf[LD.buf_ptr])) + /* The token is an identifier. The POSIX standard does not say + what characters might be contained but offical POSIX locale + definition files contain beside alnum characters '_', '-' and + '+'. */ + { + const struct locale_keyword *kw; + + do + ++LD.buf_ptr; + while (isalnum (LD.buf[LD.buf_ptr]) || LD.buf[LD.buf_ptr] == '_' + || LD.buf[LD.buf_ptr] == '-' || LD.buf[LD.buf_ptr] == '+'); + + /* Look in table of keywords. */ + kw = in_word_set (*token, LD.buf_ptr - start_ptr); + if (kw == NULL) + retval = TOK_IDENT; + else + { + if (kw->token_id == TOK_ESCAPE_CHAR + || kw->token_id == TOK_COMMENT_CHAR) + /* `escape_char' and `comment_char' are keywords for the + lexer. Do not give them to the parser. */ + { + start_again = 1; + + if (!isspace (LD.buf[LD.buf_ptr]) + || (posix_conformance && LD.returned_tokens > 0)) + error (0, 0, gettext ("%s:%Zd: syntax error in locale " + "definition file"), + LD.filename, LD.line_no); + + do + ++LD.buf_ptr; + while (isspace (LD.buf[LD.buf_ptr])); + + kw->token_id == TOK_ESCAPE_CHAR + ? LD.escape_char + : LD.comment_char = LD.buf[LD.buf_ptr++]; + + ignore_to_eol (0, posix_conformance); + } + else + /* It is one of the normal keywords. */ + retval = kw->token_id; + } + + *token_len = LD.buf_ptr - start_ptr; + } + else if (LD.buf[LD.buf_ptr] == '"') + /* Read a string. All symbolic character descriptions are expanded. + This has to be done in a local buffer because a simple symbolic + character like <A> may expand to upto 6 bytes. */ + { + char *last = LD.strbuf; + + ++LD.buf_ptr; + while (LD.buf[LD.buf_ptr] != '"') + { + int pre = LD.buf_ptr; + int char_val = get_char (); /* token, token_len); */ + + if (char_val == 0) + { + error (4, 0, gettext ("%s:%Zd: unterminated string at end " + "of line"), LD.filename, LD.line_no); + /* NOTREACHED */ + } + + if (char_val > 0) + /* Unknown characters are simply not stored. */ + last += char_to_utf (last, char_val); + else + { + char tmp[LD.buf_ptr - pre + 1]; + memcpy (tmp, &LD.buf[pre], LD.buf_ptr - pre); + tmp[LD.buf_ptr - pre] = '\0'; + error (0, 0, gettext ("%s:%Zd: character `%s' not defined"), + LD.filename, LD.line_no, tmp); + } + } + if (LD.buf[LD.buf_ptr] != '\0') + ++LD.buf_ptr; + + *last = '\0'; + *token = LD.strbuf; + *token_len = last - LD.strbuf; + retval = TOK_STRING; + } + else if (LD.buf[LD.buf_ptr] == '.' && LD.buf[LD.buf_ptr + 1] == '.' + && LD.buf[LD.buf_ptr + 2] == '.') + { + LD.buf_ptr += 3; + retval = TOK_ELLIPSIS; + } + else if (LD.buf[LD.buf_ptr] == LD.escape_char) + { + char *endp; + + ++LD.buf_ptr; + switch (LD.buf[LD.buf_ptr]) + { + case 'x': + if (isdigit (LD.buf[++LD.buf_ptr])) + { + retval = strtol (&LD.buf[LD.buf_ptr], &endp, 16); + if (endp - (LD.buf + LD.buf_ptr) < 2 || retval > 255) + retval = 'x'; + else + LD.buf_ptr = endp - LD.buf; + } + else + retval = 'x'; + break; + case 'd': + if (isdigit (LD.buf[++LD.buf_ptr])) + { + retval = strtol (&LD.buf[LD.buf_ptr], &endp, 10); + if (endp - (LD.buf + LD.buf_ptr) < 2 || retval > 255) + retval = 'd'; + else + LD.buf_ptr = endp - LD.buf; + } + else + retval = 'd'; + break; + case '0'...'9': + retval = strtol (&LD.buf[LD.buf_ptr], &endp, 8); + if (endp - (LD.buf + LD.buf_ptr) < 2 || retval > 255) + retval = LD.buf[LD.buf_ptr++]; + else + LD.buf_ptr = endp - LD.buf; + break; + case 'a': + retval = '\a'; + ++LD.buf_ptr; + break; + case 'b': + retval = '\b'; + ++LD.buf_ptr; + break; + case 'f': + retval = '\f'; + ++LD.buf_ptr; + break; + case 'n': + retval = '\n'; + ++LD.buf_ptr; + break; + case 'r': + retval = '\r'; + ++LD.buf_ptr; + break; + case 't': + retval = '\t'; + ++LD.buf_ptr; + break; + case 'v': + retval = '\v'; + ++LD.buf_ptr; + break; + default: + retval = LD.buf[LD.buf_ptr++]; + break; + } + } + else if (isdigit (LD.buf[LD.buf_ptr])) + { + char *endp; + + *token_len = strtol (&LD.buf[LD.buf_ptr], &endp, 10); + LD.buf_ptr = endp - LD.buf; + retval = TOK_NUMBER; + } + else if (LD.buf[LD.buf_ptr] == '-' && LD.buf[LD.buf_ptr + 1] == '1') + { + LD.buf_ptr += 2; + retval = TOK_MINUS1; + } + else + { + int ch = get_char (); /* token, token_len); */ + if (ch != -1) + { + *token_len = ch; + retval = TOK_CHAR; + } + else + retval = TOK_ILL_CHAR; + } + + /* Ignore white space. */ + while (isspace (LD.buf[LD.buf_ptr])) + ++LD.buf_ptr; + } + while (start_again != 0); + + ++LD.returned_tokens; + return retval; +} + + +/* Code a character with UTF-8 if the character map has multi-byte + characters. */ +int +char_to_utf (char *buf, int char_val) +{ + if (charmap_data.mb_cur_max == 1) + { + *buf++ = char_val; + return 1; + } + else + { +/* The number of bits coded in each character. */ +#define CBPC 6 + static struct coding_tab + { + int mask; + int val; + } + tab[] = + { + { 0x7f, 0x00 }, + { 0x7ff, 0xc0 }, + { 0xffff, 0xe0 }, + { 0x1fffff, 0xf0 }, + { 0x3ffffff, 0xf8 }, + { 0x7fffffff, 0xfc }, + { 0, } + }; + struct coding_tab *t; + int c; + int cnt = 1; + + for (t = tab; char_val > t->mask; ++t, ++cnt) + ; + + c = cnt; + + buf += cnt; + while (c > 1) + { + *--buf = 0x80 | (char_val & ((1 << CBPC) - 1)); + char_val >>= CBPC; + --c; + } + + *--buf = t->val | char_val; + + return cnt; + } +} + + +/* Ignore rest of line upto ENDOFLINE token, starting with given token. + If WARN_FLAG is set warn about any token but ENDOFLINE. */ +void +ignore_to_eol (int token, int warn_flag) +{ + if (token == TOK_ENDOFLINE) + return; + + if (LD.buf[LD.buf_ptr] != '\0' && warn_flag) + error (0, 0, gettext ("%s:%Zd: trailing garbage at end of line"), + locfile_data.filename, locfile_data.line_no); + + while (LD.continue_line) + { + LD.continue_line = 0; + + /* Increment line number counter. */ + ++LD.line_no; + + if (fgets (LD.buf, LD.bufsize, stdin) != NULL) + { + /* We now have to look whether this line is continued and + whether it at all fits into our buffer. */ + int linelen = strlen (LD.buf); + + if (linelen == LD.bufsize - 1) + /* The did not fit into the buffer. */ + error (2, 0, gettext ("%s:%Zd: line too long; use `getconf " + "LINE_MAX' to get the current maximum " + "line length"), LD.filename, LD.line_no); + + /* Remove '\n' at end of line. */ + if (LD.buf[linelen - 1] == '\n') + --linelen; + + if (LD.buf[linelen - 1] == LD.escape_char) + LD.continue_line = 1; + } + } + + /* This causes to begin the next line. */ + LD.buf_ptr = LD.bufsize; +} + + +/* Return the value of the character at the beginning of the input buffer. + Symbolic character constants are expanded. */ +static int +get_char (void) +{ + if (LD.buf[LD.buf_ptr] == '<') + /* This is a symbolic character name. */ + { + int char_val; + char *startp = LD.buf + (++LD.buf_ptr); + char *endp = startp; + + while (LD.buf[LD.buf_ptr] != '>' && isprint (LD.buf[LD.buf_ptr])) + { + if (LD.buf[LD.buf_ptr] == '\0' + || (LD.buf[LD.buf_ptr] == LD.escape_char + && LD.buf[++LD.buf_ptr] == '\0')) + break; + + *endp++ = LD.buf[LD.buf_ptr++]; + } + + if (LD.buf[LD.buf_ptr] != '>' && LD.buf[LD.buf_ptr] == '\0') + { + error (0, 0, gettext ("%s:%Zd: end of line in character symbol"), + LD.filename, LD.line_no); + + if (startp == endp) + return -1; + } + else + ++LD.buf_ptr; + + char_val = find_char (startp, endp - startp); + if (char_val == -1 && verbose != 0 && reject_new_char != 0) + { + /* Locale defintions are often given very general. Missing + characters are only reported when explicitely requested. */ + char tmp[endp - startp + 3]; + + tmp[0] = '<'; + memcpy (tmp + 1, startp, endp - startp); + tmp[endp - startp + 1] = '>'; + tmp[endp - startp + 2] = '\0'; + + error (0, 0, gettext ("%s:%Zd: character `%s' not defined"), + LD.filename, LD.line_no, tmp); + } + + return char_val; + } + else + return (int) LD.buf[LD.buf_ptr++]; +} + +/* + * Local Variables: + * mode:c + * c-basic-offset:2 + * End: + */ diff --git a/locale/locfile-parse.c b/locale/locfile-parse.c new file mode 100644 index 0000000000..15e25c7afe --- /dev/null +++ b/locale/locfile-parse.c @@ -0,0 +1,820 @@ +/* Copyright (C) 1995 Free Software Foundation, Inc. + +The GNU C Library is free software; you can redistribute it and/or +modify it under the terms of the GNU Library General Public License as +published by the Free Software Foundation; either version 2 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 +Library General Public License for more details. + +You should have received a copy of the GNU Library General Public +License along with the GNU C Library; see the file COPYING.LIB. If +not, write to the Free Software Foundation, Inc., 675 Mass Ave, +Cambridge, MA 02139, USA. */ + +#include <assert.h> +#include <dirent.h> +#include <fcntl.h> +#include <langinfo.h> +#include <libintl.h> +#include <limits.h> +#include <obstack.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <sys/stat.h> +#include <sys/uio.h> + +#include "localedef.h" +#include "localeinfo.h" +#include "token.h" + +/* We don't have these constants defined because we don't use them. Give + default values. */ +#define CTYPE_MB_CUR_MIN 0 +#define CTYPE_MB_CUR_MAX 0 +#define CTYPE_HASH_SIZE 0 +#define CTYPE_HASH_LAYERS 0 +#define CTYPE_CLASS 0 +#define CTYPE_TOUPPER_EB 0 +#define CTYPE_TOLOWER_EB 0 +#define CTYPE_TOUPPER_EL 0 +#define CTYPE_TOLOWER_EL 0 + + +/* We have all categories defined in `categories.def'. Now construct + the description and data structure used for all categories. */ +#define DEFINE_CATEGORY(category, name, items, postload, in, check, out) \ + struct cat_item category##_desc[] = \ + { \ + NO_PAREN items \ + }; \ + \ + char *category##_values[NELEMS (category##_desc) - 1] = { NULL, }; +#include "categories.def" +#undef DEFINE_CATEGORY + +struct category category[] = + { +#define DEFINE_CATEGORY(category, name, items, postload, in, check, out) \ + [category] = { _NL_NUM_##category, name, NELEMS (category##_desc) - 1, \ + category##_desc, category##_values, in, check, out }, +#include "categories.def" +#undef DEFINE_CATEGORY + }; +#define NCATEGORIES NELEMS (category) + + +#define SYNTAX_ERROR \ + error (0, 0, gettext ("%s:%Zd: syntax error in locale definition file"), \ + locfile_data.filename, locfile_data.line_no) + + +/* Prototypes for local functions. */ +static int get_byte (char *byte_ptr); +static char *is_locale_name (int cat_no, const char *str, int len); + + +/* Read a locale definition file FILE. The format is defined in + POSIX.2 2.5.3. */ +void +locfile_read (const char *fname) +{ + /* Pointer to text of last token. */ + char *ptr; + /* Length of last token (or if NUMBER the value itself). */ + int len; + /* The last returned token. */ + int token; + /* For error correction we remember whether the last token was correct. */ + int correct_token = 1; + + /* Open the desired input file on stdin. */ + locfile_open (fname); + + while ((token = locfile_lex (&ptr, &len)) != 0) + { + int cat_no; + + for (cat_no = 0; cat_no < NCATEGORIES; ++cat_no) + if (token == category[cat_no].cat_id) + break; + + if (cat_no >= NCATEGORIES) + /* A syntax error occured. No valid category defintion starts. */ + { + if (correct_token != 0) + error (0, 0, gettext ("%s:%Zd: locale category start expected"), + locfile_data.filename, locfile_data.line_no); + + /* To prevent following errors mark as error case. */ + correct_token = 0; + + /* Synchronization point is the beginning of a new category. + Overread all line upto this silently. */ + ignore_to_eol (0, 0); + continue; + } + + /* Rest of the line should be empty. */ + ignore_to_eol (0, 1); + + /* Perhaps these category is already specified. We simply give a + warning and overwrite the values. */ + if (category[cat_no].filled != 0) + error (0, 0, gettext ("%s:%Zd: multiple definition of locale " + "category %s"), locfile_data.filename, + locfile_data.line_no, category[cat_no].name); + + /* We read the first token because this could be the copy statement. */ + token = xlocfile_lex (&ptr, &len); + + if (token == TOK_COPY) + /* Copying the definitions from an existing locale is requested. */ + { + char *str; + + /* Get the name of the locale to copy from. */ + token = xlocfile_lex (&ptr, &len); + if (token != TOK_IDENT && token != TOK_STRING) + /* No name, then mark error and ignore everything upto next + start of an category section. */ + { + /* To prevent following errors mark as error case. */ + correct_token = 0; + + /* Synchronization point is the beginning of a new category. + Overread all line upto this silently. */ + ignore_to_eol (0, 0); + } + else if ((str = is_locale_name (cat_no, ptr, len)) != NULL) + /* Yes the name really names an existing locale file. We are + returned the complete file name. Store it so that we can + copy it in the output phase. */ + { + category[cat_no].copy_locale = str; + category[cat_no].filled = 1; + + ignore_to_eol (0, 1); + } + else + /* No, the name does not address a valid locale file. Mark + error case and ignore rest of category. */ + { + char tmp[len + 1]; + memcpy (tmp, ptr, len); + tmp[len] = '\0'; + error (0, 0, gettext ("%s:%Zd: invalid locale `%s' in copy " + "statement"), locfile_data.filename, + locfile_data.line_no, tmp); + correct_token = 0; + ignore_to_eol (0, 0); + } + + /* This should END as the next token. */ + token = xlocfile_lex (&ptr, &len); + + if (token == TOK_END) + /* This is the end of the category. */ + { + token = xlocfile_lex (&ptr, &len); + + if (token != category[cat_no].cat_id) + /* Wrong category name after END. */ + { + error (0, 0, gettext ("%s:%Zd: category `%s' does not " + "end with `END %s'"), + locfile_data.filename, locfile_data.line_no, + category[cat_no].name, category[cat_no].name); + ignore_to_eol (0, 0); + } + else + ignore_to_eol (0, 1); + + correct_token = 1; + } + else + /* No END following copy. Give error while not in error case. */ + { + if (correct_token != 0) + error (0, 0, gettext ("%s:%Zd: `copy' must be sole rule"), + locfile_data.filename, locfile_data.line_no); + correct_token = 0; + ignore_to_eol (0, 0); + } + + continue; + } + + /* Now it's time to mark as mentioned in the locale file. */ + category[cat_no].filled = 1; + + if (category[cat_no].infct != NULL) + /* The category needs a special input handling. */ + { + category[cat_no].infct(token); + continue; + } + + /* Now process the given items. */ + while (1) + { + int item_no; + + if (token == TOK_END) + /* This is the end of the category. */ + { + token = xlocfile_lex (&ptr, &len); + + if (token != category[cat_no].cat_id) + { + error (0, 0, gettext ("%s:%Zd: category `%s' does not end " + "with `END %s'"), + locfile_data.filename, locfile_data.line_no, + category[cat_no].name, category[cat_no].name); + ignore_to_eol (0, 0); + } + else + ignore_to_eol (0, 1); + + /* Start next category. */ + break; + } + + /* All other lines should describe valid items of the category. */ + for (item_no = 0; item_no < category[cat_no].number; ++item_no) + if (category[cat_no].item_desc[item_no].item_id == token) + break; + + if (item_no >= category[cat_no].number) + /* This is not a valid item of the category. */ + { + SYNTAX_ERROR; + ignore_to_eol (0, 0); + + token = xlocfile_lex (&ptr, &len); + + /* And process next item. */ + continue; + } + + /* Test whether already a value is defined. */ + if (category[cat_no].item_value[item_no] != NULL) + error (0, 0, gettext ("%s:%Zd: category item `%s' already " + "defined"), + locfile_data.filename, locfile_data.line_no, + category[cat_no].item_desc[item_no].name); + + switch (category[cat_no].item_desc[item_no].value_type) + { + case string: + /* Get next token. This is the argument to the item. */ + token = xlocfile_lex (&ptr, &len); + + if (token != TOK_STRING) + SYNTAX_ERROR; + else + category[cat_no].item_value[item_no] = strdup (ptr); + ignore_to_eol (0, ptr != NULL); + break; + case stringarray: + /* This is a difficult case. The number of strings in + the array may vary. But for now its only necessary + with ALT_DIGITS from LC_TIME. This item is the last + so be can solve it by storing the number of string in + the first place and the string indeces following + that. */ + { + int cnt; + char **buffer; + if (category[cat_no].item_value[item_no] != NULL) + buffer = (char **) category[cat_no].item_value[item_no]; + else + buffer = (char **) xmalloc ( + sizeof (char *) * category[cat_no].item_desc[item_no].max); + + category[cat_no].item_value[item_no] = (char *) buffer; + + /* As explained we may need a place to store the real number + of strings. */ + if (category[cat_no].item_desc[item_no].min + != category[cat_no].item_desc[item_no].max) + ++buffer; + + cnt = 0; + do + { + token = xlocfile_lex (&ptr, &len); + if (token != TOK_STRING) + { + SYNTAX_ERROR; + break; + } + + if (cnt >= category[cat_no].item_desc[item_no].max) + { + error (0, 0, gettext ("%s:%Zd: too many elements " + "for item `%s`"), + locfile_data.filename, locfile_data.line_no, + category[cat_no].item_desc[item_no].name); + break; + } + + buffer[cnt++] = strdup (ptr); + + token = locfile_lex (&ptr, &len); + } + while (token == TOK_CHAR && len == ';'); + + ignore_to_eol (token, ptr != NULL); + + if (cnt < category[cat_no].item_desc[item_no].min) + error (0, 0, gettext ("%s:%Zd: too few elements for item " + "`%s'"), + locfile_data.filename, locfile_data.line_no, + category[cat_no].item_desc[item_no].name); + + if (category[cat_no].item_desc[item_no].min + != category[cat_no].item_desc[item_no].max) + *(int *) category[cat_no].item_value[item_no] = cnt; + } + break; + case byte: + { + int ok; + category[cat_no].item_value[item_no] = (char *) xmalloc ( + __alignof__ (char)); + ok = get_byte (category[cat_no].item_value[item_no]); + ignore_to_eol (0, ok); + } + break; + case bytearray: + { + char *buffer; + int maxsize; + int cnt; + char byte; + int ok; + + buffer = (char *) xmalloc ((maxsize = 30)); + cnt = 0; + + while ((ok = get_byte (&byte))) + { + if (cnt >= maxsize) + buffer = (char *) xmalloc ((maxsize *= 2)); + + buffer[cnt++] = byte; + + token = locfile_lex (&ptr, &len); + if (token != TOK_CHAR || len != ';') + break; + } + + buffer[cnt] = '\0'; + category[cat_no].item_value[item_no] = buffer; + ignore_to_eol (token, ok); + } + break; + default: + error (5, 0, gettext ("internal error in %s, line %u"), + __FUNCTION__, __LINE__); + /* NOTREACHED */ + } + + /* Get next token. */ + token = xlocfile_lex (&ptr, &len); + } /* while (1) */ + } +} + + +/* Check given values for categories for consistency. */ +void +categories_check (void) +{ + int cat_no; + + for (cat_no = 0; cat_no < NCATEGORIES; ++cat_no) + if (category[cat_no].copy_locale == NULL) + if (category[cat_no].filled != 0) + if (category[cat_no].checkfct) + category[cat_no].checkfct(); + else + { + int item_no; + + for (item_no = 0; item_no < category[cat_no].number; ++item_no) + if (category[cat_no].item_value[item_no] == NULL) + { + int errcode; + + /* If the item is defined in the standard is it an error to + have it not defined. */ + errcode = category[cat_no].item_desc[item_no].status == std + ? 5 : 0; + + error (errcode, 0, gettext ("item `%s' of category `%s' " + "undefined"), + category[cat_no].item_desc[item_no].name, + category[cat_no].name); + } + } + else + error (0, 0, gettext ("category `%s' not defined"), + category[cat_no].name); +} + + +/* Write out the binary representation of the category data which can be + loaded by setlocale(1). */ +void +categories_write (void) +{ + struct locale_file + { + int magic; + int n; + int idx[0]; + } *data; + struct obstack obstk; + int cat_no; + +#define obstack_chunk_alloc xmalloc +#define obstack_chunk_free free + obstack_init (&obstk); + + for (cat_no = 0; cat_no < NCATEGORIES; ++cat_no) + { + int result = 0; + + if (category[cat_no].copy_locale != NULL) + /* Simply copy the addressed locale file of the specified + category. Please note that this is tried before the distinction + between categories which need special handling is made. */ + { + int source; + + /* Open source file. */ + source = open (category[cat_no].copy_locale, O_RDONLY); + if (source < 0) + error (0, 0, gettext ("cannot copy locale definition file `%s'"), + category[cat_no].copy_locale); + else + { + /* Construct file name of output file and open for writing. */ + char path[strlen (output_path) + + strlen(category[cat_no].name) + 1]; + int dest; + char *t; + + t = stpcpy (path, output_path); + strcpy (t, category[cat_no].name); + + dest = creat (path, 0666); + if (dest == -1) + error (0, 0, gettext ("cannot open output file `%s': %m"), + path); + else + { + char buffer[BUFSIZ]; + int size; + + /* Copy the files. */ + do + { + size = read (source, buffer, BUFSIZ); + write (dest, buffer, size); + } + while (size > 0); + + close (dest); + + /* Show success. */ + puts (category[cat_no].name); + } + close (source); + } + + /* Next category. */ + continue; + } + + if (category[cat_no].outfct) + result = category[cat_no].outfct(); + else + { + char *path, *t; + int fd; + struct iovec *iov; + int item_no, len, slen, cnt; + int elems = 0; + + /* Count number of elements. */ + for (item_no = 0; item_no < category[cat_no].number; ++item_no) + { + switch (category[cat_no].item_desc[item_no].value_type) + { + case string: + case byte: + case bytearray: + ++elems; + break; + case stringarray: + elems += category[cat_no].item_desc[item_no].max; + break; + default: + error (5, 0, gettext ("internal error in %s, line %u"), + __FUNCTION__, __LINE__); + /* NOTREACHED */ + } + } + + /* We now have the number of elements. We build the structure + and a helper structure for writing all out. */ + len = sizeof (struct locale_file) + elems * sizeof (int); + data = obstack_alloc (&obstk, len); + iov = obstack_alloc (&obstk, (elems + 1) * sizeof (struct iovec)); + + data->magic = LIMAGIC (cat_no); + data->n = elems; + iov[0].iov_base = data; + iov[0].iov_len = len; + + cnt = 0; + for (item_no = 0; item_no < category[cat_no].number; ++item_no) + if (category[cat_no].item_value[item_no] == NULL) + { + switch (category[cat_no].item_desc[item_no].value_type) + { + case string: + case byte: + case bytearray: + data->idx[cnt] = len; + ++len; /* We reserve one single byte for this entry. */ + iov[1 + cnt].iov_base = (char *) ""; + iov[1 + cnt].iov_len = 1; + ++cnt; + break; + case stringarray: + { + int max; + int nstr; + + max = category[cat_no].item_desc[item_no].max; + + for (nstr = 0; nstr < max; ++nstr) + { + data->idx[cnt] = len; + ++len; + iov[1 + cnt].iov_base = (char *) ""; + iov[1 + cnt].iov_len = 1; + ++cnt; + } + } + } + } + else + switch (category[cat_no].item_desc[item_no].value_type) + { + case string: + case bytearray: + data->idx[cnt] = len; + slen = strlen (category[cat_no].item_value[item_no]) + 1; + len += slen; + iov[1 + cnt].iov_base = category[cat_no].item_value[item_no]; + iov[1 + cnt].iov_len = slen; + ++cnt; + break; + case byte: + data->idx[cnt] = len; + slen = 1; + len += slen; + iov[1 + cnt].iov_base = category[cat_no].item_value[item_no]; + iov[1 + cnt].iov_len = slen; + ++cnt; + break; + case stringarray: + { + int nstr, nact; + char **first; + + if (category[cat_no].item_desc[item_no].min + == category[cat_no].item_desc[item_no].max) + { + nstr = category[cat_no].item_desc[item_no].min; + first = (char **) category[cat_no].item_value[item_no]; + } + else + { + nstr = *(int *) category[cat_no].item_value[item_no]; + first = + ((char **) category[cat_no].item_value[item_no]) + 1; + } + nact = nstr; + while (nstr > 0) + { + data->idx[cnt] = len; + if (*first != NULL) + { + slen = strlen (*first) + 1; + iov[1 + cnt].iov_base = first; + } + else + { + slen = 1; + iov[1 + cnt].iov_base = (char *) ""; + } + len += slen; + iov[1 + cnt].iov_len = slen; + ++cnt; + ++first; + --nstr; + } + while (nact < category[cat_no].item_desc[item_no].max) + { + data->idx[cnt] = len; + len += 1; + iov[1 + cnt].iov_base = (char *) ""; + iov[1 + cnt].iov_len = 1; + ++cnt; + ++nact; + } + } + break; + default: + /* Cannot happen. */ + break; + } + assert (cnt <= elems); + + /* Construct the output filename from the argument given to + localedef on the command line. */ + path = (char *) obstack_alloc (&obstk, strlen (output_path) + + strlen (category[cat_no].name) + 1); + t = stpcpy (path, output_path); + strcpy (t, category[cat_no].name); + + fd = creat (path, 0666); + if (fd == -1) + { + error (0, 0, gettext ("cannot open output file `%s': %m"), path); + result = 1; + } + else + { + if (writev (fd, iov, cnt + 1) == -1) + { + error (0, 0, gettext ("cannot write output file `%s': %m"), + path); + result = 1; + } + +if (elems==0) write(fd, &elems, 1); + + close (fd); + } + /* The old data is not needed anymore, but keep the obstack + intact. */ + obstack_free (&obstk, data); + } + + if (result == 0) + puts (category[cat_no].name); + } + /* Now the whole obstack can be removed. */ + obstack_free (&obstk, NULL); +} + + +/* Get the representation of a number. This is a positive integer or + the number -1 which is handled as a special symbol by the scanner. */ +static int +get_byte (char *byte_ptr) +{ + int token; + char *ptr; + int len; + + token = locfile_lex (&ptr, &len); + if (token != TOK_NUMBER && token != TOK_MINUS1) + /* None of the valid number format. */ + { + error (0, 0, gettext ("%s:%Zd: number expected"), + locfile_data.filename, locfile_data.line_no); + *byte_ptr = 0; + return 0; + } + + if (token == TOK_MINUS1) + { + *byte_ptr = CHAR_MAX; + return 1; + } + + if (len > CHAR_MAX) + /* The value of the numbers has to be less than CHAR_MAX. This is + ok for the information they have to express. */ + { + error (0, 0, gettext ("%s:%Zd: invalid number"), + locfile_data.filename, locfile_data.line_no); + *byte_ptr = 0; + return 0; + } + + *byte_ptr = len; + return 1; +} + + +/* Test whether the string STR with length LEN is the name of an existing + locale and whether a file for category CAT_NO is found in this directory. + This categories are looked for in the system locale definition file + directory. + Return the complete file name for the category file. */ +static char * +is_locale_name (int cat_no, const char *str, int len) +{ + static char **locale_names = NULL; + static int max_count = 0; + static int locale_count = 0; + int cnt, exist, fd; + char *fname; + struct stat st; + + if (locale_names == NULL) + /* Read in the list of all available locales. */ + { + DIR *dir; + struct dirent *dirent; + + /* LOCALE_NAMES is not NULL anymore, but LOCALE_COUNT == 0. */ + ++locale_names; + + dir = opendir (LOCALE_PATH); + if (dir == NULL) + { + error (1, errno, gettext ("cannot read locale directory `%s'"), + LOCALE_PATH); + + return NULL; + } + + /* Now we can look for all files in the directory. */ + while ((dirent = readdir (dir)) != NULL) + if (strcmp (dirent->d_name, ".") != 0 + && strcmp (dirent->d_name, "..") != 0) + { + if (max_count == 0) + locale_names = (char **) xmalloc ((max_count = 10) + * sizeof (char *)); + else + locale_names = (char **) xrealloc (locale_names, + (max_count *= 2) + * sizeof (char *)); + locale_names[locale_count++] = strdup (dirent->d_name); + } + closedir (dir); + } + + for (cnt = 0; cnt < locale_count; ++cnt) + if (strncmp (str, locale_names[cnt], len) == 0 + && locale_names[cnt][len] == '\0') + break; + + if (cnt >= locale_count) + return NULL; + + /* Now search for this specific locale file. */ + asprintf (&fname, "%s/%s/%s", LOCALE_PATH, locale_names[cnt], + category[cat_no].name); + + fd = open (fname, O_RDONLY); + if (fd < 0) + { + free (fname); + return NULL; + } + + exist = fstat (fd, &st); + close (fd); + + if (exist < 0) + { + free (fname); + return NULL; + } + + return fname; +} + +/* + * Local Variables: + * mode:c + * c-basic-offset:2 + * End: + */ diff --git a/locale/messages.c b/locale/messages.c new file mode 100644 index 0000000000..842e5ef5b2 --- /dev/null +++ b/locale/messages.c @@ -0,0 +1,76 @@ +/* Copyright (C) 1995 Free Software Foundation, Inc. + +The GNU C Library is free software; you can redistribute it and/or +modify it under the terms of the GNU Library General Public License as +published by the Free Software Foundation; either version 2 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 +Library General Public License for more details. + +You should have received a copy of the GNU Library General Public +License along with the GNU C Library; see the file COPYING.LIB. If +not, write to the Free Software Foundation, Inc., 675 Mass Ave, +Cambridge, MA 02139, USA. */ + +#include <langinfo.h> +#include <libintl.h> +#include <locale.h> +#include <stdio.h> +#include <regex.h> + +#include "localedef.h" + +/* These are defined in locfile-parse.c. */ +extern struct cat_item LC_MESSAGES_desc[]; +extern char *LC_MESSAGES_values[]; + +void +messages_check(void) +{ + int item_no; + + /* First general check for existence. */ + for (item_no = 0; item_no < category[LC_MESSAGES].number; ++item_no) + if (LC_MESSAGES_values[item_no] == NULL) + { + int errcode; + + errcode = LC_MESSAGES_desc[item_no].status == std ? 5 : 0; + + error (errcode, 0, gettext ("item `%s' of category `%s' undefined"), + LC_MESSAGES_desc[item_no].name, "LC_MESSAGES"); + } + else + { + /* Some fields need special tests. */ + if (LC_MESSAGES_desc[item_no].item_id == YESEXPR + || LC_MESSAGES_desc[item_no].item_id == NOEXPR) + /* The expression has to be a POSIX extended regular expression. */ + { + regex_t re; + int result; + + result = regcomp (&re, LC_MESSAGES_values[item_no], REG_EXTENDED); + + if (result != 0) + { + char errbuf[BUFSIZ]; + + (void) regerror (result, &re, errbuf, BUFSIZ); + error (0, 0, gettext ("no correct regular expression for " + "item `%s' in category `%s': %s"), + LC_MESSAGES_desc[item_no].name, "LC_MESSAGES", errbuf); + } + } + } +} + +/* + * Local Variables: + * mode:c + * c-basic-offset:2 + * End: + */ diff --git a/locale/monetary.c b/locale/monetary.c new file mode 100644 index 0000000000..2683eb2bf0 --- /dev/null +++ b/locale/monetary.c @@ -0,0 +1,132 @@ +/* Copyright (C) 1995 Free Software Foundation, Inc. + +The GNU C Library is free software; you can redistribute it and/or +modify it under the terms of the GNU Library General Public License as +published by the Free Software Foundation; either version 2 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 +Library General Public License for more details. + +You should have received a copy of the GNU Library General Public +License along with the GNU C Library; see the file COPYING.LIB. If +not, write to the Free Software Foundation, Inc., 675 Mass Ave, +Cambridge, MA 02139, USA. */ + +#include <langinfo.h> +#include <libintl.h> +#include <stdlib.h> +#include <string.h> + +#include "localedef.h" +#include "token.h" + + +/* The content iof the field int_curr_symbol has to be taken from + ISO-4217. We test for correct values. */ +#define DEFINE_INT_CURR(str) str, +static const char *const valid_int_curr[] = + { +# include "iso-4217.def" + }; +#define NVALID_INT_CURR ((sizeof (valid_int_curr) \ + / sizeof (valid_int_curr[0]))) +#undef DEFINE_INT_CURR + + +/* These are defined in locfile-parse.c. */ +extern struct cat_item LC_MONETARY_desc[]; +extern char *LC_MONETARY_values[]; + +static int _curr_strcmp(const char *s1, const char **s2); + + + +void +monetary_check(void) +{ + int item_no, val; + + for (item_no = 0; LC_MONETARY_desc[item_no].item_id != 0; ++item_no) + /* Test whether the entry has been defined. Byte values are simply + stored. */ + if (LC_MONETARY_values[item_no] == NULL) + { + int errcode; + + errcode = LC_MONETARY_desc[item_no].status = std ? 5 : 0; + + error (errcode, 0, gettext ("item `%s' of category `%s' undefined"), + LC_MONETARY_desc[item_no].name, "LC_MONETARY"); + } + else + switch (LC_MONETARY_desc[item_no].item_id) + { + case INT_CURR_SYMBOL: + if (strlen (LC_MONETARY_values[item_no]) != 4) + error (0, 0, + gettext ("item `%s' of category `%s' has wrong length"), + LC_MONETARY_desc[item_no].name, "LC_MONETARY"); + else if (bsearch (LC_MONETARY_values[item_no], valid_int_curr, + NVALID_INT_CURR, sizeof (char *), + (comparison_fn_t) _curr_strcmp) == NULL) + error (0, 0, gettext ("item `%s' does not correspond to any " + "valid name in ISO-4217"), + LC_MONETARY_desc[item_no].name); + break; + case P_CS_PRECEDES: + case P_SEP_BY_SPACE: + case N_CS_PRECEDES: + case N_SEP_BY_SPACE: + case P_SIGN_POSN: + case N_SIGN_POSN: + val = (int) *(char *) LC_MONETARY_values[item_no]; + if (val < LC_MONETARY_desc[item_no].min + || val > LC_MONETARY_desc[item_no].max) + error (0, 0, gettext ("value for item `%s' in category `%s' " + "must be in range %d...%d"), + LC_MONETARY_desc[item_no].name, "LC_MONETARY", + LC_MONETARY_desc[item_no].min, + LC_MONETARY_desc[item_no].max); + break; + case MON_DECIMAL_POINT: + /* The decimal point must not be empty. This is not said + explicitly in POSIX but ANSI C (ISO/IEC 9899) says in + 4.4.2.1 it has to be != "". */ + if (LC_MONETARY_values[item_no][0] == '\0') + error (0, 0, + gettext ("item `%s' in category `%s' must not be empty"), + LC_MONETARY_desc[item_no].name, "LC_MONETARY"); + break; + case CURRENCY_SYMBOL: + case MON_THOUSANDS_SEP: + case MON_GROUPING: + case POSITIVE_SIGN: + case NEGATIVE_SIGN: + case INT_FRAC_DIGITS: + case FRAC_DIGITS: + /* Everything is ok for these values. */ + break; + default: + error (5, 0, gettext ("Internal error in %s, line %u"), + __FUNCTION__, __LINE__); + /* NOTREACHED */ + } + +} + + +static int +_curr_strcmp(const char *s1, const char **s2) +{ + return strcmp (s1, *s2); +} + +/* + * Local Variables: + * mode:c + * c-basic-offset:2 + * End: + */ diff --git a/locale/numeric.c b/locale/numeric.c new file mode 100644 index 0000000000..93f4bc481e --- /dev/null +++ b/locale/numeric.c @@ -0,0 +1,62 @@ +/* Copyright (C) 1995 Free Software Foundation, Inc. + +The GNU C Library is free software; you can redistribute it and/or +modify it under the terms of the GNU Library General Public License as +published by the Free Software Foundation; either version 2 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 +Library General Public License for more details. + +You should have received a copy of the GNU Library General Public +License along with the GNU C Library; see the file COPYING.LIB. If +not, write to the Free Software Foundation, Inc., 675 Mass Ave, +Cambridge, MA 02139, USA. */ + +#include <langinfo.h> +#include <libintl.h> +#include <locale.h> + +#include "localedef.h" + +/* These are defined in locfile-parse.c. */ +extern struct cat_item LC_NUMERIC_desc[]; +extern char *LC_NUMERIC_values[]; + +void +numeric_check(void) +{ + int item_no; + + /* First general check for existence. */ + for (item_no = 0; item_no < category[LC_NUMERIC].number; ++item_no) + if (LC_NUMERIC_values[item_no] == NULL) + { + int errcode; + + errcode = LC_NUMERIC_desc[item_no].status = std ? 5 : 0; + + error (errcode, 0, gettext ("item `%s' of category `%s' undefined"), + LC_NUMERIC_desc[item_no].name, "LC_NUMERIC"); + } + else + { + if (LC_NUMERIC_desc[item_no].item_id == DECIMAL_POINT + && LC_NUMERIC_values[item_no][0] == '\0') + /* The decimal point must not be empty. This is not said + explicitly in POSIX but ANSI C (ISO/IEC 9899) says in + 4.4.2.1 it has to be != "". */ + error (0, 0, + gettext ("item `%s' in category `%s' must not be empty"), + LC_NUMERIC_desc[item_no].name, "LC_NUMERIC"); + } +} + +/* + * Local Variables: + * mode:c + * c-basic-offset:2 + * End: + */ diff --git a/locale/token.h b/locale/token.h new file mode 100644 index 0000000000..1227920083 --- /dev/null +++ b/locale/token.h @@ -0,0 +1,54 @@ +/* Copyright (C) 1995 Free Software Foundation, Inc. + +The GNU C Library is free software; you can redistribute it and/or +modify it under the terms of the GNU Library General Public License as +published by the Free Software Foundation; either version 2 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 +Library General Public License for more details. + +You should have received a copy of the GNU Library General Public +License along with the GNU C Library; see the file COPYING.LIB. If +not, write to the Free Software Foundation, Inc., 675 Mass Ave, +Cambridge, MA 02139, USA. */ + +#ifndef _TOKEN_H +#define _TOKEN_H 1 + +/* Define those keywords which does not correspond directly to any + item in a category. Those already have values. */ + +enum token + { + /* We must make sure that these values do not overlap with the + other possible return values of the lexer. */ + TOK_LAST_USED = _NL_NUM, + + /* General tokens. */ + TOK_END, TOK_COMMENT_CHAR, TOK_COPY, TOK_ESCAPE_CHAR, TOK_FROM, + TOK_ENDOFLINE, TOK_IDENT, TOK_STRING, TOK_ELLIPSIS, TOK_CHAR, + TOK_ILL_CHAR, TOK_NUMBER, TOK_MINUS1, + + /* Tokens from the collate category. */ + TOK_IGNORE, TOK_UNDEFINED, TOK_BACKWARD, TOK_FORWARD, TOK_POSITION, + TOK_COLLATING_ELEMENT, TOK_COLLATING_SYMBOL, TOK_ORDER_END, + TOK_ORDER_START, + + /* Tokens from the ctype category. */ + TOK_TOLOWER, TOK_TOUPPER, + /* The order here is important. It must correspond to the bits + used for indicating the class membership (ctype.h). */ + TOK_UPPER, TOK_LOWER, TOK_ALPHA, TOK_DIGIT, TOK_XDIGIT, TOK_SPACE, + TOK_PRINT, TOK_GRAPH, TOK_BLANK, TOK_CNTRL, TOK_PUNCT, + }; + +/* + * Local Variables: + * mode:c + * c-basic-offset:2 + * End: + */ +#endif /* token.h */ diff --git a/posix/Makefile b/posix/Makefile index 34fe4bb162..6931727288 100644 --- a/posix/Makefile +++ b/posix/Makefile @@ -22,7 +22,7 @@ subdir := posix headers := sys/utsname.h sys/times.h sys/wait.h sys/types.h unistd.h \ - glob.h wordexp.h fnmatch.h gnu/types.h getopt.h \ + glob.h regex.h wordexp.h fnmatch.h gnu/types.h getopt.h \ posix1_lim.h posix2_lim.h posix_opt.h local_lim.h tar.h \ utsnamelen.h confname.h waitflags.h waitstatus.h sys/unistd.h @@ -40,7 +40,7 @@ routines := \ getpgid setpgid getpgrp setsid \ getlogin setlogin \ pathconf sysconf fpathconf \ - glob fnmatch \ + glob fnmatch regex \ confstr \ getopt getopt1 aux := init-posix environ @@ -48,7 +48,7 @@ tests := tstgetopt testfnm others := getconf install-bin := getconf install-lib := libposix.a -gpl2lgpl := getopt.c getopt1.c getopt.h # Frob these guys' copying notices. +gpl2lgpl := getopt.c getopt1.c getopt.h regex.c regex.h include ../Rules diff --git a/posix/regex.c b/posix/regex.c new file mode 100644 index 0000000000..897295aa27 --- /dev/null +++ b/posix/regex.c @@ -0,0 +1,5400 @@ +/* Extended regular expression matching and search library, + version 0.12. + (Implements POSIX draft P10003.2/D11.2, except for + internationalization features.) + + Copyright (C) 1993, 1994, 1995 Free Software Foundation, Inc. + +This file is part of the GNU C Library. Its master source is NOT part of +the C library, however. The master source lives in /gd/gnu/lib. + +The GNU C Library is free software; you can redistribute it and/or +modify it under the terms of the GNU Library General Public License as +published by the Free Software Foundation; either version 2 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 +Library General Public License for more details. + +You should have received a copy of the GNU Library General Public +License along with the GNU C Library; see the file COPYING.LIB. If +not, write to the Free Software Foundation, Inc., 675 Mass Ave, +Cambridge, MA 02139, USA. */ + +/* AIX requires this to be the first thing in the file. */ +#if defined (_AIX) && !defined (REGEX_MALLOC) + #pragma alloca +#endif + +#define _GNU_SOURCE + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +/* We need this for `regex.h', and perhaps for the Emacs include files. */ +#include <sys/types.h> + +/* This is for other GNU distributions with internationalized messages. */ +#if HAVE_LIBINTL_H || defined (_LIBC) +# include <libintl.h> +#else +# define gettext(msgid) (msgid) +#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 + +/* We used to test for `BSTRING' here, but only GCC and Emacs define + `BSTRING', as far as I know, and neither of them use this code. */ +#ifndef INHIBIT_STRING_HEADER +#if HAVE_STRING_H || STDC_HEADERS || defined (_LIBC) +#include <string.h> +#ifndef bcmp +#define bcmp(s1, s2, n) memcmp ((s1), (s2), (n)) +#endif +#ifndef bcopy +#define bcopy(s, d, n) memcpy ((d), (s), (n)) +#endif +#ifndef bzero +#define bzero(s, n) memset ((s), 0, (n)) +#endif +#else +#include <strings.h> +#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 + +#ifdef SYNTAX_TABLE + +extern char *re_syntax_table; + +#else /* not SYNTAX_TABLE */ + +/* How many characters in the character set. */ +#define CHAR_SET_SIZE 256 + +static char re_syntax_table[CHAR_SET_SIZE]; + +static void +init_syntax_once () +{ + register int c; + static int done = 0; + + if (done) + return; + + bzero (re_syntax_table, sizeof re_syntax_table); + + for (c = 'a'; c <= 'z'; c++) + re_syntax_table[c] = Sword; + + for (c = 'A'; c <= 'Z'; c++) + re_syntax_table[c] = Sword; + + for (c = '0'; c <= '9'; c++) + re_syntax_table[c] = Sword; + + re_syntax_table['_'] = Sword; + + done = 1; +} + +#endif /* not SYNTAX_TABLE */ + +#define SYNTAX(c) re_syntax_table[c] + +#endif /* not emacs */ + +/* Get the interface, including the syntax bits. */ +#include "regex.h" + +/* 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." */ + +#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 + +#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)) + +#ifndef NULL +#define NULL 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 + +/* 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> +#else /* not __GNUC__ or HAVE_ALLOCA_H */ +#ifndef _AIX /* Already did AIX, up at the top. */ +char *alloca (); +#endif /* not _AIX */ +#endif /* not 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), \ + bcopy (source, destination, osize), \ + destination) + +/* No need to do anything to free, after alloca. */ +#define REGEX_FREE(arg) (0) + +#endif /* not REGEX_MALLOC */ + +/* Define how to allocate the failure stack. */ + +#ifdef REL_ALLOC +#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 REL_ALLOC */ + +#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 REL_ALLOC */ + + +/* 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 int re_match_2_internal (); + +/* 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, + + /* 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. */ + 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. */ + 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. */ + 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. */ + 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. */ + 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. */ + succeed_n, + + /* Followed by two-byte relative address, and two-byte number n. + Jump to the address N times, then fail. */ + jump_n, + + /* Set the following two-byte relative address to the + subsequent two-byte number. The address *includes* the two + bytes of number. */ + 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; + +/* Common operations on the compiled pattern. */ + +/* Store NUMBER in two contiguous bytes starting at DESTINATION. */ + +#define STORE_NUMBER(destination, number) \ + do { \ + (destination)[0] = (number) & 0377; \ + (destination)[1] = (number) >> 8; \ + } while (0) + +/* Same as STORE_NUMBER, except increment DESTINATION to + the byte after where the number is stored. Therefore, DESTINATION + must be an lvalue. */ + +#define STORE_NUMBER_AND_INCR(destination, number) \ + do { \ + STORE_NUMBER (destination, number); \ + (destination) += 2; \ + } while (0) + +/* Put into DESTINATION a number stored in two contiguous bytes starting + at SOURCE. */ + +#define EXTRACT_NUMBER(destination, source) \ + do { \ + (destination) = *(source) & 0377; \ + (destination) += SIGN_EXTEND_CHAR (*((source) + 1)) << 8; \ + } while (0) + +#ifdef DEBUG +static void +extract_number (dest, source) + int *dest; + unsigned char *source; +{ + int temp = SIGN_EXTEND_CHAR (*(source + 1)); + *dest = *source & 0377; + *dest += temp << 8; +} + +#ifndef EXTRACT_MACROS /* To debug the macros. */ +#undef EXTRACT_NUMBER +#define EXTRACT_NUMBER(dest, src) 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) += 2; \ + } while (0) + +#ifdef DEBUG +static void +extract_number_and_incr (destination, source) + int *destination; + unsigned char **source; +{ + extract_number (destination, *source); + *source += 2; +} + +#ifndef EXTRACT_MACROS +#undef EXTRACT_NUMBER_AND_INCR +#define EXTRACT_NUMBER_AND_INCR(dest, src) \ + 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 + +/* 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 = 0; + +#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) +#define DEBUG_PRINT_COMPILED_PATTERN(p, s, e) \ + if (debug) print_partial_compiled_pattern (s, e) +#define DEBUG_PRINT_DOUBLE_STRING(w, s1, sz1, s2, sz2) \ + if (debug) print_double_string (w, s1, sz1, s2, sz2) + + +/* Print the fastmap in human-readable form. */ + +void +print_fastmap (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'); +} + + +/* Print a compiled pattern string in human-readable form, starting at + the START pointer into it and ending just before the pointer END. */ + +void +print_partial_compiled_pattern (start, end) + unsigned char *start; + unsigned char *end; +{ + int mcnt, mcnt2; + unsigned char *p = start; + unsigned char *pend = end; + + if (start == NULL) + { + printf ("(null)\n"); + return; + } + + /* Loop over pattern commands. */ + while (p < pend) + { + printf ("%d:\t", p - start); + + switch ((re_opcode_t) *p++) + { + case no_op: + printf ("/no_op"); + break; + + case exactn: + mcnt = *p++; + printf ("/exactn/%d", mcnt); + do + { + putchar ('/'); + putchar (*p++); + } + while (--mcnt); + break; + + case start_memory: + mcnt = *p++; + printf ("/start_memory/%d/%d", mcnt, *p++); + break; + + case stop_memory: + mcnt = *p++; + printf ("/stop_memory/%d/%d", mcnt, *p++); + break; + + case duplicate: + printf ("/duplicate/%d", *p++); + break; + + case anychar: + printf ("/anychar"); + break; + + case charset: + case charset_not: + { + 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; + } + break; + + case begline: + printf ("/begline"); + break; + + case endline: + printf ("/endline"); + break; + + case on_failure_jump: + extract_number_and_incr (&mcnt, &p); + printf ("/on_failure_jump to %d", p + mcnt - start); + break; + + case on_failure_keep_string_jump: + extract_number_and_incr (&mcnt, &p); + printf ("/on_failure_keep_string_jump to %d", p + mcnt - start); + break; + + case dummy_failure_jump: + extract_number_and_incr (&mcnt, &p); + printf ("/dummy_failure_jump to %d", p + mcnt - start); + break; + + case push_dummy_failure: + printf ("/push_dummy_failure"); + break; + + case maybe_pop_jump: + extract_number_and_incr (&mcnt, &p); + printf ("/maybe_pop_jump to %d", p + mcnt - start); + break; + + case pop_failure_jump: + extract_number_and_incr (&mcnt, &p); + printf ("/pop_failure_jump to %d", p + mcnt - start); + break; + + case jump_past_alt: + extract_number_and_incr (&mcnt, &p); + printf ("/jump_past_alt to %d", p + mcnt - start); + break; + + case jump: + extract_number_and_incr (&mcnt, &p); + printf ("/jump to %d", p + mcnt - start); + break; + + case succeed_n: + extract_number_and_incr (&mcnt, &p); + extract_number_and_incr (&mcnt2, &p); + printf ("/succeed_n to %d, %d times", p + mcnt - start, mcnt2); + break; + + case jump_n: + extract_number_and_incr (&mcnt, &p); + extract_number_and_incr (&mcnt2, &p); + printf ("/jump_n to %d, %d times", p + mcnt - start, mcnt2); + break; + + case set_number_at: + extract_number_and_incr (&mcnt, &p); + extract_number_and_incr (&mcnt2, &p); + printf ("/set_number_at location %d to %d", p + mcnt - start, mcnt2); + break; + + case wordbound: + printf ("/wordbound"); + break; + + case notwordbound: + printf ("/notwordbound"); + break; + + case wordbeg: + printf ("/wordbeg"); + break; + + case wordend: + printf ("/wordend"); + +#ifdef emacs + case before_dot: + printf ("/before_dot"); + break; + + case at_dot: + printf ("/at_dot"); + break; + + case after_dot: + printf ("/after_dot"); + break; + + case syntaxspec: + printf ("/syntaxspec"); + mcnt = *p++; + printf ("/%d", mcnt); + break; + + case notsyntaxspec: + printf ("/notsyntaxspec"); + mcnt = *p++; + printf ("/%d", mcnt); + break; +#endif /* emacs */ + + case wordchar: + printf ("/wordchar"); + break; + + case notwordchar: + printf ("/notwordchar"); + break; + + case begbuf: + printf ("/begbuf"); + break; + + case endbuf: + printf ("/endbuf"); + break; + + default: + printf ("?%d", *(p-1)); + } + + putchar ('\n'); + } + + printf ("%d:\tend of pattern.\n", p - start); +} + + +void +print_compiled_pattern (bufp) + struct re_pattern_buffer *bufp; +{ + unsigned char *buffer = bufp->buffer; + + print_partial_compiled_pattern (buffer, buffer + bufp->used); + printf ("%d bytes used/%d bytes allocated.\n", bufp->used, bufp->allocated); + + if (bufp->fastmap_accurate && bufp->fastmap) + { + printf ("fastmap: "); + print_fastmap (bufp->fastmap); + } + + printf ("re_nsub: %d\t", bufp->re_nsub); + printf ("regs_alloc: %d\t", bufp->regs_allocated); + printf ("can_be_null: %d\t", bufp->can_be_null); + printf ("newline_anchor: %d\n", bufp->newline_anchor); + printf ("no_sub: %d\t", bufp->no_sub); + printf ("not_bol: %d\t", bufp->not_bol); + printf ("not_eol: %d\t", bufp->not_eol); + printf ("syntax: %d\n", bufp->syntax); + /* Perhaps we should print the translate table? */ +} + + +void +print_double_string (where, string1, size1, string2, size2) + const char *where; + const char *string1; + const char *string2; + int size1; + int size2; +{ + unsigned this_char; + + if (where == NULL) + printf ("(null)"); + else + { + if (FIRST_STRING_P (where)) + { + for (this_char = where - string1; this_char < size1; this_char++) + putchar (string1[this_char]); + + where = string2; + } + + for (this_char = where - string2; this_char < size2; this_char++) + putchar (string2[this_char]); + } +} + +#else /* not DEBUG */ + +#undef assert +#define assert(e) + +#define DEBUG_STATEMENT(e) +#define DEBUG_PRINT1(x) +#define DEBUG_PRINT2(x1, x2) +#define DEBUG_PRINT3(x1, x2, x3) +#define DEBUG_PRINT4(x1, x2, x3, x4) +#define DEBUG_PRINT_COMPILED_PATTERN(p, s, e) +#define DEBUG_PRINT_DOUBLE_STRING(w, s1, sz1, s2, sz2) + +#endif /* not DEBUG */ + +/* Set by `re_set_syntax' to the current regexp syntax to recognize. Can + also be assigned to arbitrarily: each pattern buffer stores its own + syntax, so it can be changed between regex compilations. */ +/* This has no initializer because initialized variables in Emacs + become read-only after dumping. */ +reg_syntax_t re_syntax_options; + + +/* Specify the precise syntax of regexps for compilation. This provides + for compatibility for various utilities which historically have + different, incompatible syntaxes. + + The argument SYNTAX is a bit mask comprised of the various bits + defined in regex.h. We return the old syntax. */ + +reg_syntax_t +re_set_syntax (syntax) + reg_syntax_t syntax; +{ + reg_syntax_t ret = re_syntax_options; + + re_syntax_options = syntax; + return ret; +} + +/* This table gives an error message for each of the error codes listed + in regex.h. Obviously the order here has to be same as there. + POSIX doesn't require that we do anything for REG_NOERROR, + but why not be nice? */ + +static const char *re_error_msgid[] = + { "Success", /* REG_NOERROR */ + "No match", /* REG_NOMATCH */ + "Invalid regular expression", /* REG_BADPAT */ + "Invalid collation character", /* REG_ECOLLATE */ + "Invalid character class name", /* REG_ECTYPE */ + "Trailing backslash", /* REG_EESCAPE */ + "Invalid back reference", /* REG_ESUBREG */ + "Unmatched [ or [^", /* REG_EBRACK */ + "Unmatched ( or \\(", /* REG_EPAREN */ + "Unmatched \\{", /* REG_EBRACE */ + "Invalid content of \\{\\}", /* REG_BADBR */ + "Invalid range end", /* REG_ERANGE */ + "Memory exhausted", /* REG_ESPACE */ + "Invalid preceding regular expression", /* REG_BADRPT */ + "Premature end of regular expression", /* REG_EEND */ + "Regular expression too big", /* REG_ESIZE */ + "Unmatched ) or \\)", /* REG_ERPAREN */ + }; + +/* Avoiding alloca during matching, to placate r_alloc. */ + +/* Define MATCH_MAY_ALLOCATE unless we need to make sure that the + searching and matching functions should not call alloca. On some + systems, alloca is implemented in terms of malloc, and if we're + using the relocating allocator routines, then malloc could cause a + relocation, which might (if the strings being searched are in the + ralloc heap) shift the data out from underneath the regexp + routines. + + Here's another reason to avoid allocation: Emacs + processes input from X in a signal handler; processing X input may + call malloc; if input arrives while a matching routine is calling + malloc, then we're scrod. But Emacs can't just block input while + calling matching routines; then we don't notice interrupts when + they come in. So, Emacs blocks input around all regexp calls + except the matching calls, which it leaves unprotected, in the + faith that they will not malloc. */ + +/* Normally, this is fine. */ +#define MATCH_MAY_ALLOCATE + +/* When using GNU C, we are not REALLY using the C alloca, no matter + what config.h may say. So don't take precautions for it. */ +#ifdef __GNUC__ +#undef C_ALLOCA +#endif + +/* The match routines may not allocate if (1) they would do it with malloc + and (2) it's not safe for them to use malloc. + Note that if REL_ALLOC is defined, matching would not use malloc for the + failure stack, but we would still use it for the register vectors; + so REL_ALLOC should not affect this. */ +#if (defined (C_ALLOCA) || defined (REGEX_MALLOC)) && defined (emacs) +#undef MATCH_MAY_ALLOCATE +#endif + + +/* Failure stack declarations and macros; both re_compile_fastmap and + re_match_2 use a failure stack. These have to be macros because of + REGEX_ALLOCATE_STACK. */ + + +/* Number of failure points for which to initially allocate space + when matching. If this number is exceeded, we allocate more + space, so it is not a hard limit. */ +#ifndef INIT_FAILURE_ALLOC +#define INIT_FAILURE_ALLOC 5 +#endif + +/* Roughly the maximum number of failure points on the stack. Would be + exactly that if always used MAX_FAILURE_SPACE each time we failed. + This is a variable only so users of regex can assign to it; we never + change it ourselves. */ +#if defined (MATCH_MAY_ALLOCATE) +int re_max_failures = 200000; +#else +int re_max_failures = 2000; +#endif + +union fail_stack_elt +{ + unsigned char *pointer; + int integer; +}; + +typedef union fail_stack_elt fail_stack_elt_t; + +typedef struct +{ + fail_stack_elt_t *stack; + unsigned size; + unsigned avail; /* Offset of next open position. */ +} fail_stack_type; + +#define FAIL_STACK_EMPTY() (fail_stack.avail == 0) +#define FAIL_STACK_PTR_EMPTY() (fail_stack_ptr->avail == 0) +#define FAIL_STACK_FULL() (fail_stack.avail == fail_stack.size) + + +/* Define macros to initialize and free the failure stack. + Do `return -2' if the alloc fails. */ + +#ifdef MATCH_MAY_ALLOCATE +#define INIT_FAIL_STACK() \ + do { \ + fail_stack.stack = (fail_stack_elt_t *) \ + REGEX_ALLOCATE_STACK (INIT_FAILURE_ALLOC * sizeof (fail_stack_elt_t)); \ + \ + if (fail_stack.stack == NULL) \ + return -2; \ + \ + fail_stack.size = INIT_FAILURE_ALLOC; \ + fail_stack.avail = 0; \ + } while (0) + +#define RESET_FAIL_STACK() REGEX_FREE_STACK (fail_stack.stack) +#else +#define INIT_FAIL_STACK() \ + do { \ + fail_stack.avail = 0; \ + } while (0) + +#define RESET_FAIL_STACK() +#endif + + +/* Double the size of FAIL_STACK, up to approximately `re_max_failures' items. + + Return 1 if succeeds, and 0 if either ran out of memory + allocating space for it or it was already too large. + + REGEX_REALLOCATE_STACK requires `destination' be declared. */ + +#define DOUBLE_FAIL_STACK(fail_stack) \ + ((fail_stack).size > re_max_failures * MAX_FAILURE_ITEMS \ + ? 0 \ + : ((fail_stack).stack = (fail_stack_elt_t *) \ + REGEX_REALLOCATE_STACK ((fail_stack).stack, \ + (fail_stack).size * sizeof (fail_stack_elt_t), \ + ((fail_stack).size << 1) * sizeof (fail_stack_elt_t)), \ + \ + (fail_stack).stack == NULL \ + ? 0 \ + : ((fail_stack).size <<= 1, \ + 1))) + + +/* Push pointer POINTER on FAIL_STACK. + Return 1 if was able to do so and 0 if ran out of memory allocating + space to do so. */ +#define PUSH_PATTERN_OP(POINTER, FAIL_STACK) \ + ((FAIL_STACK_FULL () \ + && !DOUBLE_FAIL_STACK (FAIL_STACK)) \ + ? 0 \ + : ((FAIL_STACK).stack[(FAIL_STACK).avail++].pointer = POINTER, \ + 1)) + +/* Push a pointer value onto the failure stack. + Assumes the variable `fail_stack'. Probably should only + be called from within `PUSH_FAILURE_POINT'. */ +#define PUSH_FAILURE_POINTER(item) \ + fail_stack.stack[fail_stack.avail++].pointer = (unsigned char *) (item) + +/* This pushes an integer-valued item onto the failure stack. + Assumes the variable `fail_stack'. Probably should only + be called from within `PUSH_FAILURE_POINT'. */ +#define PUSH_FAILURE_INT(item) \ + fail_stack.stack[fail_stack.avail++].integer = (item) + +/* Push a fail_stack_elt_t value onto the failure stack. + Assumes the variable `fail_stack'. Probably should only + be called from within `PUSH_FAILURE_POINT'. */ +#define PUSH_FAILURE_ELT(item) \ + fail_stack.stack[fail_stack.avail++] = (item) + +/* These three POP... operations complement the three PUSH... operations. + All assume that `fail_stack' is nonempty. */ +#define POP_FAILURE_POINTER() fail_stack.stack[--fail_stack.avail].pointer +#define POP_FAILURE_INT() fail_stack.stack[--fail_stack.avail].integer +#define POP_FAILURE_ELT() fail_stack.stack[--fail_stack.avail] + +/* Used to omit pushing failure point id's when we're not debugging. */ +#ifdef DEBUG +#define DEBUG_PUSH PUSH_FAILURE_INT +#define DEBUG_POP(item_addr) *(item_addr) = POP_FAILURE_INT () +#else +#define DEBUG_PUSH(item) +#define DEBUG_POP(item_addr) +#endif + + +/* Push the information about the state we will need + if we ever fail back to it. + + Requires variables fail_stack, regstart, regend, reg_info, and + num_regs be declared. DOUBLE_FAIL_STACK requires `destination' be + declared. + + Does `return FAILURE_CODE' if runs out of memory. */ + +#define PUSH_FAILURE_POINT(pattern_place, string_place, failure_code) \ + do { \ + char *destination; \ + /* Must be int, so when we don't save any registers, the arithmetic \ + of 0 + -1 isn't done as unsigned. */ \ + int this_reg; \ + \ + DEBUG_STATEMENT (failure_id++); \ + DEBUG_STATEMENT (nfailure_points_pushed++); \ + DEBUG_PRINT2 ("\nPUSH_FAILURE_POINT #%u:\n", failure_id); \ + DEBUG_PRINT2 (" Before push, next avail: %d\n", (fail_stack).avail);\ + DEBUG_PRINT2 (" size: %d\n", (fail_stack).size);\ + \ + DEBUG_PRINT2 (" slots needed: %d\n", NUM_FAILURE_ITEMS); \ + DEBUG_PRINT2 (" available: %d\n", REMAINING_AVAIL_SLOTS); \ + \ + /* Ensure we have enough space allocated for what we will push. */ \ + while (REMAINING_AVAIL_SLOTS < NUM_FAILURE_ITEMS) \ + { \ + if (!DOUBLE_FAIL_STACK (fail_stack)) \ + return failure_code; \ + \ + DEBUG_PRINT2 ("\n Doubled stack; size now: %d\n", \ + (fail_stack).size); \ + DEBUG_PRINT2 (" slots available: %d\n", REMAINING_AVAIL_SLOTS);\ + } \ + \ + /* Push the info, starting with the registers. */ \ + DEBUG_PRINT1 ("\n"); \ + \ + for (this_reg = lowest_active_reg; this_reg <= highest_active_reg; \ + this_reg++) \ + { \ + DEBUG_PRINT2 (" Pushing reg: %d\n", this_reg); \ + DEBUG_STATEMENT (num_regs_pushed++); \ + \ + DEBUG_PRINT2 (" start: 0x%x\n", regstart[this_reg]); \ + PUSH_FAILURE_POINTER (regstart[this_reg]); \ + \ + DEBUG_PRINT2 (" end: 0x%x\n", regend[this_reg]); \ + PUSH_FAILURE_POINTER (regend[this_reg]); \ + \ + DEBUG_PRINT2 (" info: 0x%x\n ", reg_info[this_reg]); \ + DEBUG_PRINT2 (" match_null=%d", \ + REG_MATCH_NULL_STRING_P (reg_info[this_reg])); \ + DEBUG_PRINT2 (" active=%d", IS_ACTIVE (reg_info[this_reg])); \ + DEBUG_PRINT2 (" matched_something=%d", \ + MATCHED_SOMETHING (reg_info[this_reg])); \ + DEBUG_PRINT2 (" ever_matched=%d", \ + EVER_MATCHED_SOMETHING (reg_info[this_reg])); \ + DEBUG_PRINT1 ("\n"); \ + PUSH_FAILURE_ELT (reg_info[this_reg].word); \ + } \ + \ + DEBUG_PRINT2 (" Pushing low active reg: %d\n", lowest_active_reg);\ + PUSH_FAILURE_INT (lowest_active_reg); \ + \ + DEBUG_PRINT2 (" Pushing high active reg: %d\n", highest_active_reg);\ + PUSH_FAILURE_INT (highest_active_reg); \ + \ + DEBUG_PRINT2 (" Pushing pattern 0x%x: ", pattern_place); \ + DEBUG_PRINT_COMPILED_PATTERN (bufp, pattern_place, pend); \ + PUSH_FAILURE_POINTER (pattern_place); \ + \ + DEBUG_PRINT2 (" Pushing string 0x%x: `", string_place); \ + DEBUG_PRINT_DOUBLE_STRING (string_place, string1, size1, string2, \ + size2); \ + DEBUG_PRINT1 ("'\n"); \ + PUSH_FAILURE_POINTER (string_place); \ + \ + DEBUG_PRINT2 (" Pushing failure id: %u\n", failure_id); \ + DEBUG_PUSH (failure_id); \ + } while (0) + +/* This is the number of items that are pushed and popped on the stack + for each register. */ +#define NUM_REG_ITEMS 3 + +/* Individual items aside from the registers. */ +#ifdef DEBUG +#define NUM_NONREG_ITEMS 5 /* Includes failure point id. */ +#else +#define NUM_NONREG_ITEMS 4 +#endif + +/* We push at most this many items on the stack. */ +#define MAX_FAILURE_ITEMS ((num_regs - 1) * NUM_REG_ITEMS + NUM_NONREG_ITEMS) + +/* We actually push this many items. */ +#define NUM_FAILURE_ITEMS \ + ((highest_active_reg - lowest_active_reg + 1) * NUM_REG_ITEMS \ + + NUM_NONREG_ITEMS) + +/* How many items can still be added to the stack without overflowing it. */ +#define REMAINING_AVAIL_SLOTS ((fail_stack).size - (fail_stack).avail) + + +/* Pops what PUSH_FAIL_STACK pushes. + + We restore into the parameters, all of which should be lvalues: + STR -- the saved data position. + PAT -- the saved pattern position. + LOW_REG, HIGH_REG -- the highest and lowest active registers. + REGSTART, REGEND -- arrays of string positions. + REG_INFO -- array of information about each subexpression. + + Also assumes the variables `fail_stack' and (if debugging), `bufp', + `pend', `string1', `size1', `string2', and `size2'. */ + +#define POP_FAILURE_POINT(str, pat, low_reg, high_reg, regstart, regend, reg_info)\ +{ \ + DEBUG_STATEMENT (fail_stack_elt_t failure_id;) \ + int this_reg; \ + const unsigned char *string_temp; \ + \ + assert (!FAIL_STACK_EMPTY ()); \ + \ + /* Remove failure points and point to how many regs pushed. */ \ + DEBUG_PRINT1 ("POP_FAILURE_POINT:\n"); \ + DEBUG_PRINT2 (" Before pop, next avail: %d\n", fail_stack.avail); \ + DEBUG_PRINT2 (" size: %d\n", fail_stack.size); \ + \ + assert (fail_stack.avail >= NUM_NONREG_ITEMS); \ + \ + DEBUG_POP (&failure_id); \ + DEBUG_PRINT2 (" Popping failure id: %u\n", failure_id); \ + \ + /* If the saved string location is NULL, it came from an \ + on_failure_keep_string_jump opcode, and we want to throw away the \ + saved NULL, thus retaining our current position in the string. */ \ + string_temp = POP_FAILURE_POINTER (); \ + if (string_temp != NULL) \ + str = (const char *) string_temp; \ + \ + DEBUG_PRINT2 (" Popping string 0x%x: `", str); \ + DEBUG_PRINT_DOUBLE_STRING (str, string1, size1, string2, size2); \ + DEBUG_PRINT1 ("'\n"); \ + \ + pat = (unsigned char *) POP_FAILURE_POINTER (); \ + DEBUG_PRINT2 (" Popping pattern 0x%x: ", pat); \ + DEBUG_PRINT_COMPILED_PATTERN (bufp, pat, pend); \ + \ + /* Restore register info. */ \ + high_reg = (unsigned) POP_FAILURE_INT (); \ + DEBUG_PRINT2 (" Popping high active reg: %d\n", high_reg); \ + \ + low_reg = (unsigned) POP_FAILURE_INT (); \ + DEBUG_PRINT2 (" Popping low active reg: %d\n", low_reg); \ + \ + for (this_reg = high_reg; this_reg >= low_reg; this_reg--) \ + { \ + DEBUG_PRINT2 (" Popping reg: %d\n", this_reg); \ + \ + reg_info[this_reg].word = POP_FAILURE_ELT (); \ + DEBUG_PRINT2 (" info: 0x%x\n", reg_info[this_reg]); \ + \ + regend[this_reg] = (const char *) POP_FAILURE_POINTER (); \ + DEBUG_PRINT2 (" end: 0x%x\n", regend[this_reg]); \ + \ + regstart[this_reg] = (const char *) POP_FAILURE_POINTER (); \ + DEBUG_PRINT2 (" start: 0x%x\n", regstart[this_reg]); \ + } \ + \ + set_regs_matched_done = 0; \ + DEBUG_STATEMENT (nfailure_points_popped++); \ +} /* POP_FAILURE_POINT */ + + + +/* Structure for per-register (a.k.a. per-group) information. + Other register information, such as the + starting and ending positions (which are addresses), and the list of + inner groups (which is a bits list) are maintained in separate + variables. + + We are making a (strictly speaking) nonportable assumption here: that + the compiler will pack our bit fields into something that fits into + the type of `word', i.e., is something that fits into one item on the + failure stack. */ + +typedef union +{ + fail_stack_elt_t word; + struct + { + /* This field is one if this group can match the empty string, + zero if not. If not yet determined, `MATCH_NULL_UNSET_VALUE'. */ +#define MATCH_NULL_UNSET_VALUE 3 + unsigned match_null_string_p : 2; + unsigned is_active : 1; + unsigned matched_something : 1; + unsigned ever_matched_something : 1; + } bits; +} register_info_type; + +#define REG_MATCH_NULL_STRING_P(R) ((R).bits.match_null_string_p) +#define IS_ACTIVE(R) ((R).bits.is_active) +#define MATCHED_SOMETHING(R) ((R).bits.matched_something) +#define EVER_MATCHED_SOMETHING(R) ((R).bits.ever_matched_something) + + +/* Call this when have matched a real character; it sets `matched' flags + for the subexpressions which we are currently inside. Also records + that those subexprs have matched. */ +#define SET_REGS_MATCHED() \ + do \ + { \ + if (!set_regs_matched_done) \ + { \ + unsigned r; \ + set_regs_matched_done = 1; \ + for (r = lowest_active_reg; r <= highest_active_reg; r++) \ + { \ + MATCHED_SOMETHING (reg_info[r]) \ + = EVER_MATCHED_SOMETHING (reg_info[r]) \ + = 1; \ + } \ + } \ + } \ + while (0) + +/* Registers are set to a sentinel when they haven't yet matched. */ +static char reg_unset_dummy; +#define REG_UNSET_VALUE (®_unset_dummy) +#define REG_UNSET(e) ((e) == REG_UNSET_VALUE) + +/* Subroutine declarations and macros for regex_compile. */ + +static void store_op1 (), store_op2 (); +static void insert_op1 (), insert_op2 (); +static boolean at_begline_loc_p (), at_endline_loc_p (); +static boolean group_in_compile_stack (); +static reg_errcode_t compile_range (); + +/* Fetch the next character in the uncompiled pattern---translating it + if necessary. Also cast from a signed character in the constant + string passed to us by the user to an unsigned char that we can use + as an array index (in, e.g., `translate'). */ +#define PATFETCH(c) \ + do {if (p == pend) return REG_EEND; \ + c = (unsigned char) *p++; \ + if (translate) c = translate[c]; \ + } while (0) + +/* Fetch the next character in the uncompiled pattern, with no + translation. */ +#define PATFETCH_RAW(c) \ + do {if (p == pend) return REG_EEND; \ + c = (unsigned char) *p++; \ + } while (0) + +/* Go backwards one character in the pattern. */ +#define PATUNFETCH p-- + + +/* If `translate' is non-null, return translate[D], else just D. We + cast the subscript to translate because some data is declared as + `char *', to avoid warnings when a string constant is passed. But + when we use a character as a subscript we must make it unsigned. */ +#define TRANSLATE(d) (translate ? translate[(unsigned char) (d)] : (d)) + + +/* Macros for outputting the compiled pattern into `buffer'. */ + +/* If the buffer isn't allocated when it comes in, use this. */ +#define INIT_BUF_SIZE 32 + +/* Make sure we have at least N more bytes of space in buffer. */ +#define GET_BUFFER_SPACE(n) \ + while (b - bufp->buffer + (n) > bufp->allocated) \ + EXTEND_BUFFER () + +/* Make sure we have one more byte of buffer space and then add C to it. */ +#define BUF_PUSH(c) \ + do { \ + GET_BUFFER_SPACE (1); \ + *b++ = (unsigned char) (c); \ + } while (0) + + +/* Ensure we have two more bytes of buffer space and then append C1 and C2. */ +#define BUF_PUSH_2(c1, c2) \ + do { \ + GET_BUFFER_SPACE (2); \ + *b++ = (unsigned char) (c1); \ + *b++ = (unsigned char) (c2); \ + } while (0) + + +/* As with BUF_PUSH_2, except for three bytes. */ +#define BUF_PUSH_3(c1, c2, c3) \ + do { \ + GET_BUFFER_SPACE (3); \ + *b++ = (unsigned char) (c1); \ + *b++ = (unsigned char) (c2); \ + *b++ = (unsigned char) (c3); \ + } while (0) + + +/* Store a jump with opcode OP at LOC to location TO. We store a + relative address offset by the three bytes the jump itself occupies. */ +#define STORE_JUMP(op, loc, to) \ + store_op1 (op, loc, (to) - (loc) - 3) + +/* Likewise, for a two-argument jump. */ +#define STORE_JUMP2(op, loc, to, arg) \ + store_op2 (op, loc, (to) - (loc) - 3, arg) + +/* Like `STORE_JUMP', but for inserting. Assume `b' is the buffer end. */ +#define INSERT_JUMP(op, loc, to) \ + insert_op1 (op, loc, (to) - (loc) - 3, b) + +/* Like `STORE_JUMP2', but for inserting. Assume `b' is the buffer end. */ +#define INSERT_JUMP2(op, loc, to, arg) \ + insert_op2 (op, loc, (to) - (loc) - 3, arg, b) + + +/* This is not an arbitrary limit: the arguments which represent offsets + into the pattern are two bytes long. So if 2^16 bytes turns out to + be too small, many things would have to change. */ +#define MAX_BUF_SIZE (1L << 16) + + +/* Extend the buffer by twice its current size via realloc and + reset the pointers that pointed into the old block to point to the + correct places in the new one. If extending the buffer results in it + being larger than MAX_BUF_SIZE, then flag memory exhausted. */ +#define EXTEND_BUFFER() \ + do { \ + unsigned char *old_buffer = bufp->buffer; \ + if (bufp->allocated == MAX_BUF_SIZE) \ + return REG_ESIZE; \ + bufp->allocated <<= 1; \ + if (bufp->allocated > MAX_BUF_SIZE) \ + bufp->allocated = MAX_BUF_SIZE; \ + bufp->buffer = (unsigned char *) realloc (bufp->buffer, bufp->allocated);\ + if (bufp->buffer == NULL) \ + return REG_ESPACE; \ + /* If the buffer moved, move all the pointers into it. */ \ + if (old_buffer != bufp->buffer) \ + { \ + b = (b - old_buffer) + bufp->buffer; \ + begalt = (begalt - old_buffer) + bufp->buffer; \ + if (fixup_alt_jump) \ + fixup_alt_jump = (fixup_alt_jump - old_buffer) + bufp->buffer;\ + if (laststart) \ + laststart = (laststart - old_buffer) + bufp->buffer; \ + if (pending_exact) \ + pending_exact = (pending_exact - old_buffer) + bufp->buffer; \ + } \ + } while (0) + + +/* Since we have one byte reserved for the register number argument to + {start,stop}_memory, the maximum number of groups we can report + things about is what fits in that byte. */ +#define MAX_REGNUM 255 + +/* But patterns can have more than `MAX_REGNUM' registers. We just + ignore the excess. */ +typedef unsigned regnum_t; + + +/* Macros for the compile stack. */ + +/* Since offsets can go either forwards or backwards, this type needs to + be able to hold values from -(MAX_BUF_SIZE - 1) to MAX_BUF_SIZE - 1. */ +typedef int pattern_offset_t; + +typedef struct +{ + pattern_offset_t begalt_offset; + pattern_offset_t fixup_alt_jump; + pattern_offset_t inner_group_offset; + pattern_offset_t laststart_offset; + regnum_t regnum; +} compile_stack_elt_t; + + +typedef struct +{ + compile_stack_elt_t *stack; + unsigned size; + unsigned avail; /* Offset of next open position. */ +} compile_stack_type; + + +#define INIT_COMPILE_STACK_SIZE 32 + +#define COMPILE_STACK_EMPTY (compile_stack.avail == 0) +#define COMPILE_STACK_FULL (compile_stack.avail == compile_stack.size) + +/* The next available element. */ +#define COMPILE_STACK_TOP (compile_stack.stack[compile_stack.avail]) + + +/* Set the bit for character C in a list. */ +#define SET_LIST_BIT(c) \ + (b[((unsigned char) (c)) / BYTEWIDTH] \ + |= 1 << (((unsigned char) c) % BYTEWIDTH)) + + +/* Get the next unsigned number in the uncompiled pattern. */ +#define GET_UNSIGNED_NUMBER(num) \ + { if (p != pend) \ + { \ + PATFETCH (c); \ + while (ISDIGIT (c)) \ + { \ + if (num < 0) \ + num = 0; \ + num = num * 10 + c - '0'; \ + if (p == pend) \ + break; \ + PATFETCH (c); \ + } \ + } \ + } + +#define CHAR_CLASS_MAX_LENGTH 6 /* Namely, `xdigit'. */ + +#define IS_CHAR_CLASS(string) \ + (STREQ (string, "alpha") || STREQ (string, "upper") \ + || STREQ (string, "lower") || STREQ (string, "digit") \ + || STREQ (string, "alnum") || STREQ (string, "xdigit") \ + || STREQ (string, "space") || STREQ (string, "print") \ + || STREQ (string, "punct") || STREQ (string, "graph") \ + || STREQ (string, "cntrl") || STREQ (string, "blank")) + +#ifndef MATCH_MAY_ALLOCATE + +/* If we cannot allocate large objects within re_match_2_internal, + we make the fail stack and register vectors global. + The fail stack, we grow to the maximum size when a regexp + is compiled. + The register vectors, we adjust in size each time we + compile a regexp, according to the number of registers it needs. */ + +static fail_stack_type fail_stack; + +/* Size with which the following vectors are currently allocated. + That is so we can make them bigger as needed, + but never make them smaller. */ +static int regs_allocated_size; + +static const char ** regstart, ** regend; +static const char ** old_regstart, ** old_regend; +static const char **best_regstart, **best_regend; +static register_info_type *reg_info; +static const char **reg_dummy; +static register_info_type *reg_info_dummy; + +/* Make the register vectors big enough for NUM_REGS registers, + but don't make them smaller. */ + +static +regex_grow_registers (num_regs) + int num_regs; +{ + if (num_regs > regs_allocated_size) + { + RETALLOC_IF (regstart, num_regs, const char *); + RETALLOC_IF (regend, num_regs, const char *); + RETALLOC_IF (old_regstart, num_regs, const char *); + RETALLOC_IF (old_regend, num_regs, const char *); + RETALLOC_IF (best_regstart, num_regs, const char *); + RETALLOC_IF (best_regend, num_regs, const char *); + RETALLOC_IF (reg_info, num_regs, register_info_type); + RETALLOC_IF (reg_dummy, num_regs, const char *); + RETALLOC_IF (reg_info_dummy, num_regs, register_info_type); + + regs_allocated_size = num_regs; + } +} + +#endif /* not MATCH_MAY_ALLOCATE */ + +/* `regex_compile' compiles PATTERN (of length SIZE) according to SYNTAX. + Returns one of error codes defined in `regex.h', or zero for success. + + Assumes the `allocated' (and perhaps `buffer') and `translate' + fields are set in BUFP on entry. + + If it succeeds, results are put in BUFP (if it returns an error, the + contents of BUFP are undefined): + `buffer' is the compiled pattern; + `syntax' is set to SYNTAX; + `used' is set to the length of the compiled pattern; + `fastmap_accurate' is zero; + `re_nsub' is the number of subexpressions in PATTERN; + `not_bol' and `not_eol' are zero; + + The `fastmap' and `newline_anchor' fields are neither + examined nor set. */ + +/* Return, freeing storage we allocated. */ +#define FREE_STACK_RETURN(value) \ + return (free (compile_stack.stack), value) + +static reg_errcode_t +regex_compile (pattern, size, syntax, bufp) + const char *pattern; + int size; + reg_syntax_t syntax; + struct re_pattern_buffer *bufp; +{ + /* We fetch characters from PATTERN here. Even though PATTERN is + `char *' (i.e., signed), we declare these variables as unsigned, so + they can be reliably used as array indices. */ + register unsigned char c, c1; + + /* A random temporary spot in PATTERN. */ + const char *p1; + + /* Points to the end of the buffer, where we should append. */ + register unsigned char *b; + + /* Keeps track of unclosed groups. */ + compile_stack_type compile_stack; + + /* Points to the current (ending) position in the pattern. */ + const char *p = pattern; + const char *pend = pattern + size; + + /* How to translate the characters in the pattern. */ + char *translate = bufp->translate; + + /* Address of the count-byte of the most recently inserted `exactn' + command. This makes it possible to tell if a new exact-match + character can be added to that command or if the character requires + a new `exactn' command. */ + unsigned char *pending_exact = 0; + + /* Address of start of the most recently finished expression. + This tells, e.g., postfix * where to find the start of its + operand. Reset at the beginning of groups and alternatives. */ + unsigned char *laststart = 0; + + /* Address of beginning of regexp, or inside of last group. */ + unsigned char *begalt; + + /* Place in the uncompiled pattern (i.e., the {) to + which to go back if the interval is invalid. */ + const char *beg_interval; + + /* Address of the place where a forward jump should go to the end of + the containing expression. Each alternative of an `or' -- except the + last -- ends with a forward jump of this sort. */ + unsigned char *fixup_alt_jump = 0; + + /* Counts open-groups as they are encountered. Remembered for the + matching close-group on the compile stack, so the same register + number is put in the stop_memory as the start_memory. */ + regnum_t regnum = 0; + +#ifdef DEBUG + DEBUG_PRINT1 ("\nCompiling pattern: "); + if (debug) + { + unsigned debug_count; + + for (debug_count = 0; debug_count < size; debug_count++) + putchar (pattern[debug_count]); + putchar ('\n'); + } +#endif /* DEBUG */ + + /* Initialize the compile stack. */ + compile_stack.stack = TALLOC (INIT_COMPILE_STACK_SIZE, compile_stack_elt_t); + if (compile_stack.stack == NULL) + return REG_ESPACE; + + compile_stack.size = INIT_COMPILE_STACK_SIZE; + compile_stack.avail = 0; + + /* Initialize the pattern buffer. */ + bufp->syntax = syntax; + bufp->fastmap_accurate = 0; + bufp->not_bol = bufp->not_eol = 0; + + /* Set `used' to zero, so that if we return an error, the pattern + printer (for debugging) will think there's no pattern. We reset it + at the end. */ + bufp->used = 0; + + /* Always count groups, whether or not bufp->no_sub is set. */ + bufp->re_nsub = 0; + +#if !defined (emacs) && !defined (SYNTAX_TABLE) + /* Initialize the syntax table. */ + init_syntax_once (); +#endif + + if (bufp->allocated == 0) + { + if (bufp->buffer) + { /* If zero allocated, but buffer is non-null, try to realloc + enough space. This loses if buffer's address is bogus, but + that is the user's responsibility. */ + RETALLOC (bufp->buffer, INIT_BUF_SIZE, unsigned char); + } + else + { /* Caller did not allocate a buffer. Do it for them. */ + bufp->buffer = TALLOC (INIT_BUF_SIZE, unsigned char); + } + if (!bufp->buffer) FREE_STACK_RETURN (REG_ESPACE); + + bufp->allocated = INIT_BUF_SIZE; + } + + begalt = b = bufp->buffer; + + /* Loop through the uncompiled pattern until we're at the end. */ + while (p != pend) + { + PATFETCH (c); + + switch (c) + { + case '^': + { + if ( /* If at start of pattern, it's an operator. */ + p == pattern + 1 + /* If context independent, it's an operator. */ + || syntax & RE_CONTEXT_INDEP_ANCHORS + /* Otherwise, depends on what's come before. */ + || at_begline_loc_p (pattern, p, syntax)) + BUF_PUSH (begline); + else + goto normal_char; + } + break; + + + case '$': + { + if ( /* If at end of pattern, it's an operator. */ + p == pend + /* If context independent, it's an operator. */ + || syntax & RE_CONTEXT_INDEP_ANCHORS + /* Otherwise, depends on what's next. */ + || at_endline_loc_p (p, pend, syntax)) + BUF_PUSH (endline); + else + goto normal_char; + } + break; + + + case '+': + case '?': + if ((syntax & RE_BK_PLUS_QM) + || (syntax & RE_LIMITED_OPS)) + goto normal_char; + handle_plus: + case '*': + /* If there is no previous pattern... */ + if (!laststart) + { + if (syntax & RE_CONTEXT_INVALID_OPS) + FREE_STACK_RETURN (REG_BADRPT); + else if (!(syntax & RE_CONTEXT_INDEP_OPS)) + goto normal_char; + } + + { + /* Are we optimizing this jump? */ + boolean keep_string_p = false; + + /* 1 means zero (many) matches is allowed. */ + char zero_times_ok = 0, many_times_ok = 0; + + /* If there is a sequence of repetition chars, collapse it + down to just one (the right one). We can't combine + interval operators with these because of, e.g., `a{2}*', + which should only match an even number of `a's. */ + + for (;;) + { + zero_times_ok |= c != '+'; + many_times_ok |= c != '?'; + + if (p == pend) + break; + + PATFETCH (c); + + if (c == '*' + || (!(syntax & RE_BK_PLUS_QM) && (c == '+' || c == '?'))) + ; + + else if (syntax & RE_BK_PLUS_QM && c == '\\') + { + if (p == pend) FREE_STACK_RETURN (REG_EESCAPE); + + PATFETCH (c1); + if (!(c1 == '+' || c1 == '?')) + { + PATUNFETCH; + PATUNFETCH; + break; + } + + c = c1; + } + else + { + PATUNFETCH; + break; + } + + /* If we get here, we found another repeat character. */ + } + + /* Star, etc. applied to an empty pattern is equivalent + to an empty pattern. */ + if (!laststart) + break; + + /* Now we know whether or not zero matches is allowed + and also whether or not two or more matches is allowed. */ + if (many_times_ok) + { /* More than one repetition is allowed, so put in at the + end a backward relative jump from `b' to before the next + jump we're going to put in below (which jumps from + laststart to after this jump). + + But if we are at the `*' in the exact sequence `.*\n', + insert an unconditional jump backwards to the ., + instead of the beginning of the loop. This way we only + push a failure point once, instead of every time + through the loop. */ + assert (p - 1 > pattern); + + /* Allocate the space for the jump. */ + GET_BUFFER_SPACE (3); + + /* We know we are not at the first character of the pattern, + because laststart was nonzero. And we've already + incremented `p', by the way, to be the character after + the `*'. Do we have to do something analogous here + for null bytes, because of RE_DOT_NOT_NULL? */ + if (TRANSLATE (*(p - 2)) == TRANSLATE ('.') + && zero_times_ok + && p < pend && TRANSLATE (*p) == TRANSLATE ('\n') + && !(syntax & RE_DOT_NEWLINE)) + { /* We have .*\n. */ + STORE_JUMP (jump, b, laststart); + keep_string_p = true; + } + else + /* Anything else. */ + STORE_JUMP (maybe_pop_jump, b, laststart - 3); + + /* We've added more stuff to the buffer. */ + b += 3; + } + + /* On failure, jump from laststart to b + 3, which will be the + end of the buffer after this jump is inserted. */ + GET_BUFFER_SPACE (3); + INSERT_JUMP (keep_string_p ? on_failure_keep_string_jump + : on_failure_jump, + laststart, b + 3); + pending_exact = 0; + b += 3; + + if (!zero_times_ok) + { + /* At least one repetition is required, so insert a + `dummy_failure_jump' before the initial + `on_failure_jump' instruction of the loop. This + effects a skip over that instruction the first time + we hit that loop. */ + GET_BUFFER_SPACE (3); + INSERT_JUMP (dummy_failure_jump, laststart, laststart + 6); + b += 3; + } + } + break; + + + case '.': + laststart = b; + BUF_PUSH (anychar); + break; + + + case '[': + { + boolean had_char_class = false; + + if (p == pend) FREE_STACK_RETURN (REG_EBRACK); + + /* Ensure that we have enough space to push a charset: the + opcode, the length count, and the bitset; 34 bytes in all. */ + GET_BUFFER_SPACE (34); + + laststart = b; + + /* We test `*p == '^' twice, instead of using an if + statement, so we only need one BUF_PUSH. */ + BUF_PUSH (*p == '^' ? charset_not : charset); + if (*p == '^') + p++; + + /* Remember the first position in the bracket expression. */ + p1 = p; + + /* Push the number of bytes in the bitmap. */ + BUF_PUSH ((1 << BYTEWIDTH) / BYTEWIDTH); + + /* Clear the whole map. */ + bzero (b, (1 << BYTEWIDTH) / BYTEWIDTH); + + /* charset_not matches newline according to a syntax bit. */ + if ((re_opcode_t) b[-2] == charset_not + && (syntax & RE_HAT_LISTS_NOT_NEWLINE)) + SET_LIST_BIT ('\n'); + + /* Read in characters and ranges, setting map bits. */ + for (;;) + { + if (p == pend) FREE_STACK_RETURN (REG_EBRACK); + + PATFETCH (c); + + /* \ might escape characters inside [...] and [^...]. */ + if ((syntax & RE_BACKSLASH_ESCAPE_IN_LISTS) && c == '\\') + { + if (p == pend) FREE_STACK_RETURN (REG_EESCAPE); + + PATFETCH (c1); + SET_LIST_BIT (c1); + continue; + } + + /* Could be the end of the bracket expression. If it's + not (i.e., when the bracket expression is `[]' so + far), the ']' character bit gets set way below. */ + if (c == ']' && p != p1 + 1) + break; + + /* Look ahead to see if it's a range when the last thing + was a character class. */ + if (had_char_class && c == '-' && *p != ']') + FREE_STACK_RETURN (REG_ERANGE); + + /* Look ahead to see if it's a range when the last thing + was a character: if this is a hyphen not at the + beginning or the end of a list, then it's the range + operator. */ + if (c == '-' + && !(p - 2 >= pattern && p[-2] == '[') + && !(p - 3 >= pattern && p[-3] == '[' && p[-2] == '^') + && *p != ']') + { + reg_errcode_t ret + = compile_range (&p, pend, translate, syntax, b); + if (ret != REG_NOERROR) FREE_STACK_RETURN (ret); + } + + else if (p[0] == '-' && p[1] != ']') + { /* This handles ranges made up of characters only. */ + reg_errcode_t ret; + + /* Move past the `-'. */ + PATFETCH (c1); + + ret = compile_range (&p, pend, translate, syntax, b); + if (ret != REG_NOERROR) FREE_STACK_RETURN (ret); + } + + /* See if we're at the beginning of a possible character + class. */ + + else if (syntax & RE_CHAR_CLASSES && c == '[' && *p == ':') + { /* Leave room for the null. */ + char str[CHAR_CLASS_MAX_LENGTH + 1]; + + PATFETCH (c); + c1 = 0; + + /* If pattern is `[[:'. */ + if (p == pend) FREE_STACK_RETURN (REG_EBRACK); + + for (;;) + { + PATFETCH (c); + if (c == ':' || c == ']' || p == pend + || c1 == CHAR_CLASS_MAX_LENGTH) + break; + str[c1++] = c; + } + str[c1] = '\0'; + + /* If isn't a word bracketed by `[:' and:`]': + undo the ending character, the letters, and leave + the leading `:' and `[' (but set bits for them). */ + if (c == ':' && *p == ']') + { + int ch; + boolean is_alnum = STREQ (str, "alnum"); + boolean is_alpha = STREQ (str, "alpha"); + boolean is_blank = STREQ (str, "blank"); + boolean is_cntrl = STREQ (str, "cntrl"); + boolean is_digit = STREQ (str, "digit"); + boolean is_graph = STREQ (str, "graph"); + boolean is_lower = STREQ (str, "lower"); + boolean is_print = STREQ (str, "print"); + boolean is_punct = STREQ (str, "punct"); + boolean is_space = STREQ (str, "space"); + boolean is_upper = STREQ (str, "upper"); + boolean is_xdigit = STREQ (str, "xdigit"); + + if (!IS_CHAR_CLASS (str)) + FREE_STACK_RETURN (REG_ECTYPE); + + /* Throw away the ] at the end of the character + class. */ + PATFETCH (c); + + if (p == pend) FREE_STACK_RETURN (REG_EBRACK); + + for (ch = 0; ch < 1 << BYTEWIDTH; ch++) + { + /* This was split into 3 if's to + avoid an arbitrary limit in some compiler. */ + if ( (is_alnum && ISALNUM (ch)) + || (is_alpha && ISALPHA (ch)) + || (is_blank && ISBLANK (ch)) + || (is_cntrl && ISCNTRL (ch))) + SET_LIST_BIT (ch); + if ( (is_digit && ISDIGIT (ch)) + || (is_graph && ISGRAPH (ch)) + || (is_lower && ISLOWER (ch)) + || (is_print && ISPRINT (ch))) + SET_LIST_BIT (ch); + if ( (is_punct && ISPUNCT (ch)) + || (is_space && ISSPACE (ch)) + || (is_upper && ISUPPER (ch)) + || (is_xdigit && ISXDIGIT (ch))) + SET_LIST_BIT (ch); + } + had_char_class = true; + } + else + { + c1++; + while (c1--) + PATUNFETCH; + SET_LIST_BIT ('['); + SET_LIST_BIT (':'); + had_char_class = false; + } + } + else + { + had_char_class = false; + SET_LIST_BIT (c); + } + } + + /* Discard any (non)matching list bytes that are all 0 at the + end of the map. Decrease the map-length byte too. */ + while ((int) b[-1] > 0 && b[b[-1] - 1] == 0) + b[-1]--; + b += b[-1]; + } + break; + + + case '(': + if (syntax & RE_NO_BK_PARENS) + goto handle_open; + else + goto normal_char; + + + case ')': + if (syntax & RE_NO_BK_PARENS) + goto handle_close; + else + goto normal_char; + + + case '\n': + if (syntax & RE_NEWLINE_ALT) + goto handle_alt; + else + goto normal_char; + + + case '|': + if (syntax & RE_NO_BK_VBAR) + goto handle_alt; + else + goto normal_char; + + + case '{': + if (syntax & RE_INTERVALS && syntax & RE_NO_BK_BRACES) + goto handle_interval; + else + goto normal_char; + + + case '\\': + if (p == pend) FREE_STACK_RETURN (REG_EESCAPE); + + /* Do not translate the character after the \, so that we can + distinguish, e.g., \B from \b, even if we normally would + translate, e.g., B to b. */ + PATFETCH_RAW (c); + + switch (c) + { + case '(': + if (syntax & RE_NO_BK_PARENS) + goto normal_backslash; + + handle_open: + bufp->re_nsub++; + regnum++; + + if (COMPILE_STACK_FULL) + { + RETALLOC (compile_stack.stack, compile_stack.size << 1, + compile_stack_elt_t); + if (compile_stack.stack == NULL) return REG_ESPACE; + + compile_stack.size <<= 1; + } + + /* These are the values to restore when we hit end of this + group. They are all relative offsets, so that if the + whole pattern moves because of realloc, they will still + be valid. */ + COMPILE_STACK_TOP.begalt_offset = begalt - bufp->buffer; + COMPILE_STACK_TOP.fixup_alt_jump + = fixup_alt_jump ? fixup_alt_jump - bufp->buffer + 1 : 0; + COMPILE_STACK_TOP.laststart_offset = b - bufp->buffer; + COMPILE_STACK_TOP.regnum = regnum; + + /* We will eventually replace the 0 with the number of + groups inner to this one. But do not push a + start_memory for groups beyond the last one we can + represent in the compiled pattern. */ + if (regnum <= MAX_REGNUM) + { + COMPILE_STACK_TOP.inner_group_offset = b - bufp->buffer + 2; + BUF_PUSH_3 (start_memory, regnum, 0); + } + + compile_stack.avail++; + + fixup_alt_jump = 0; + laststart = 0; + begalt = b; + /* If we've reached MAX_REGNUM groups, then this open + won't actually generate any code, so we'll have to + clear pending_exact explicitly. */ + pending_exact = 0; + break; + + + case ')': + if (syntax & RE_NO_BK_PARENS) goto normal_backslash; + + if (COMPILE_STACK_EMPTY) + if (syntax & RE_UNMATCHED_RIGHT_PAREN_ORD) + goto normal_backslash; + else + FREE_STACK_RETURN (REG_ERPAREN); + + handle_close: + if (fixup_alt_jump) + { /* Push a dummy failure point at the end of the + alternative for a possible future + `pop_failure_jump' to pop. See comments at + `push_dummy_failure' in `re_match_2'. */ + BUF_PUSH (push_dummy_failure); + + /* We allocated space for this jump when we assigned + to `fixup_alt_jump', in the `handle_alt' case below. */ + STORE_JUMP (jump_past_alt, fixup_alt_jump, b - 1); + } + + /* See similar code for backslashed left paren above. */ + if (COMPILE_STACK_EMPTY) + if (syntax & RE_UNMATCHED_RIGHT_PAREN_ORD) + goto normal_char; + else + FREE_STACK_RETURN (REG_ERPAREN); + + /* Since we just checked for an empty stack above, this + ``can't happen''. */ + assert (compile_stack.avail != 0); + { + /* We don't just want to restore into `regnum', because + later groups should continue to be numbered higher, + as in `(ab)c(de)' -- the second group is #2. */ + regnum_t this_group_regnum; + + compile_stack.avail--; + begalt = bufp->buffer + COMPILE_STACK_TOP.begalt_offset; + fixup_alt_jump + = COMPILE_STACK_TOP.fixup_alt_jump + ? bufp->buffer + COMPILE_STACK_TOP.fixup_alt_jump - 1 + : 0; + laststart = bufp->buffer + COMPILE_STACK_TOP.laststart_offset; + this_group_regnum = COMPILE_STACK_TOP.regnum; + /* If we've reached MAX_REGNUM groups, then this open + won't actually generate any code, so we'll have to + clear pending_exact explicitly. */ + pending_exact = 0; + + /* We're at the end of the group, so now we know how many + groups were inside this one. */ + if (this_group_regnum <= MAX_REGNUM) + { + unsigned char *inner_group_loc + = bufp->buffer + COMPILE_STACK_TOP.inner_group_offset; + + *inner_group_loc = regnum - this_group_regnum; + BUF_PUSH_3 (stop_memory, this_group_regnum, + regnum - this_group_regnum); + } + } + break; + + + case '|': /* `\|'. */ + if (syntax & RE_LIMITED_OPS || syntax & RE_NO_BK_VBAR) + goto normal_backslash; + handle_alt: + if (syntax & RE_LIMITED_OPS) + goto normal_char; + + /* Insert before the previous alternative a jump which + jumps to this alternative if the former fails. */ + GET_BUFFER_SPACE (3); + INSERT_JUMP (on_failure_jump, begalt, b + 6); + pending_exact = 0; + b += 3; + + /* The alternative before this one has a jump after it + which gets executed if it gets matched. Adjust that + jump so it will jump to this alternative's analogous + jump (put in below, which in turn will jump to the next + (if any) alternative's such jump, etc.). The last such + jump jumps to the correct final destination. A picture: + _____ _____ + | | | | + | v | v + a | b | c + + If we are at `b', then fixup_alt_jump right now points to a + three-byte space after `a'. We'll put in the jump, set + fixup_alt_jump to right after `b', and leave behind three + bytes which we'll fill in when we get to after `c'. */ + + if (fixup_alt_jump) + STORE_JUMP (jump_past_alt, fixup_alt_jump, b); + + /* Mark and leave space for a jump after this alternative, + to be filled in later either by next alternative or + when know we're at the end of a series of alternatives. */ + fixup_alt_jump = b; + GET_BUFFER_SPACE (3); + b += 3; + + laststart = 0; + begalt = b; + break; + + + case '{': + /* If \{ is a literal. */ + if (!(syntax & RE_INTERVALS) + /* If we're at `\{' and it's not the open-interval + operator. */ + || ((syntax & RE_INTERVALS) && (syntax & RE_NO_BK_BRACES)) + || (p - 2 == pattern && p == pend)) + goto normal_backslash; + + handle_interval: + { + /* If got here, then the syntax allows intervals. */ + + /* At least (most) this many matches must be made. */ + int lower_bound = -1, upper_bound = -1; + + beg_interval = p - 1; + + if (p == pend) + { + if (syntax & RE_NO_BK_BRACES) + goto unfetch_interval; + else + FREE_STACK_RETURN (REG_EBRACE); + } + + GET_UNSIGNED_NUMBER (lower_bound); + + if (c == ',') + { + GET_UNSIGNED_NUMBER (upper_bound); + if (upper_bound < 0) upper_bound = RE_DUP_MAX; + } + else + /* Interval such as `{1}' => match exactly once. */ + upper_bound = lower_bound; + + if (lower_bound < 0 || upper_bound > RE_DUP_MAX + || lower_bound > upper_bound) + { + if (syntax & RE_NO_BK_BRACES) + goto unfetch_interval; + else + FREE_STACK_RETURN (REG_BADBR); + } + + if (!(syntax & RE_NO_BK_BRACES)) + { + if (c != '\\') FREE_STACK_RETURN (REG_EBRACE); + + PATFETCH (c); + } + + if (c != '}') + { + if (syntax & RE_NO_BK_BRACES) + goto unfetch_interval; + else + FREE_STACK_RETURN (REG_BADBR); + } + + /* We just parsed a valid interval. */ + + /* If it's invalid to have no preceding re. */ + if (!laststart) + { + if (syntax & RE_CONTEXT_INVALID_OPS) + FREE_STACK_RETURN (REG_BADRPT); + else if (syntax & RE_CONTEXT_INDEP_OPS) + laststart = b; + else + goto unfetch_interval; + } + + /* If the upper bound is zero, don't want to succeed at + all; jump from `laststart' to `b + 3', which will be + the end of the buffer after we insert the jump. */ + if (upper_bound == 0) + { + GET_BUFFER_SPACE (3); + INSERT_JUMP (jump, laststart, b + 3); + b += 3; + } + + /* Otherwise, we have a nontrivial interval. When + we're all done, the pattern will look like: + set_number_at <jump count> <upper bound> + set_number_at <succeed_n count> <lower bound> + succeed_n <after jump addr> <succeed_n count> + <body of loop> + jump_n <succeed_n addr> <jump count> + (The upper bound and `jump_n' are omitted if + `upper_bound' is 1, though.) */ + else + { /* If the upper bound is > 1, we need to insert + more at the end of the loop. */ + unsigned nbytes = 10 + (upper_bound > 1) * 10; + + GET_BUFFER_SPACE (nbytes); + + /* Initialize lower bound of the `succeed_n', even + though it will be set during matching by its + attendant `set_number_at' (inserted next), + because `re_compile_fastmap' needs to know. + Jump to the `jump_n' we might insert below. */ + INSERT_JUMP2 (succeed_n, laststart, + b + 5 + (upper_bound > 1) * 5, + lower_bound); + b += 5; + + /* Code to initialize the lower bound. Insert + before the `succeed_n'. The `5' is the last two + bytes of this `set_number_at', plus 3 bytes of + the following `succeed_n'. */ + insert_op2 (set_number_at, laststart, 5, lower_bound, b); + b += 5; + + if (upper_bound > 1) + { /* More than one repetition is allowed, so + append a backward jump to the `succeed_n' + that starts this interval. + + When we've reached this during matching, + we'll have matched the interval once, so + jump back only `upper_bound - 1' times. */ + STORE_JUMP2 (jump_n, b, laststart + 5, + upper_bound - 1); + b += 5; + + /* The location we want to set is the second + parameter of the `jump_n'; that is `b-2' as + an absolute address. `laststart' will be + the `set_number_at' we're about to insert; + `laststart+3' the number to set, the source + for the relative address. But we are + inserting into the middle of the pattern -- + so everything is getting moved up by 5. + Conclusion: (b - 2) - (laststart + 3) + 5, + i.e., b - laststart. + + We insert this at the beginning of the loop + so that if we fail during matching, we'll + reinitialize the bounds. */ + insert_op2 (set_number_at, laststart, b - laststart, + upper_bound - 1, b); + b += 5; + } + } + pending_exact = 0; + beg_interval = NULL; + } + break; + + unfetch_interval: + /* If an invalid interval, match the characters as literals. */ + assert (beg_interval); + p = beg_interval; + beg_interval = NULL; + + /* normal_char and normal_backslash need `c'. */ + PATFETCH (c); + + if (!(syntax & RE_NO_BK_BRACES)) + { + if (p > pattern && p[-1] == '\\') + goto normal_backslash; + } + goto normal_char; + +#ifdef emacs + /* There is no way to specify the before_dot and after_dot + operators. rms says this is ok. --karl */ + case '=': + BUF_PUSH (at_dot); + break; + + case 's': + laststart = b; + PATFETCH (c); + BUF_PUSH_2 (syntaxspec, syntax_spec_code[c]); + break; + + case 'S': + laststart = b; + PATFETCH (c); + BUF_PUSH_2 (notsyntaxspec, syntax_spec_code[c]); + break; +#endif /* emacs */ + + + case 'w': + laststart = b; + BUF_PUSH (wordchar); + break; + + + case 'W': + laststart = b; + BUF_PUSH (notwordchar); + break; + + + case '<': + BUF_PUSH (wordbeg); + break; + + case '>': + BUF_PUSH (wordend); + break; + + case 'b': + BUF_PUSH (wordbound); + break; + + case 'B': + BUF_PUSH (notwordbound); + break; + + case '`': + BUF_PUSH (begbuf); + break; + + case '\'': + BUF_PUSH (endbuf); + break; + + case '1': case '2': case '3': case '4': case '5': + case '6': case '7': case '8': case '9': + if (syntax & RE_NO_BK_REFS) + goto normal_char; + + c1 = c - '0'; + + if (c1 > regnum) + FREE_STACK_RETURN (REG_ESUBREG); + + /* Can't back reference to a subexpression if inside of it. */ + if (group_in_compile_stack (compile_stack, c1)) + goto normal_char; + + laststart = b; + BUF_PUSH_2 (duplicate, c1); + break; + + + case '+': + case '?': + if (syntax & RE_BK_PLUS_QM) + goto handle_plus; + else + goto normal_backslash; + + default: + normal_backslash: + /* You might think it would be useful for \ to mean + not to translate; but if we don't translate it + it will never match anything. */ + c = TRANSLATE (c); + goto normal_char; + } + break; + + + default: + /* Expects the character in `c'. */ + normal_char: + /* If no exactn currently being built. */ + if (!pending_exact + + /* If last exactn not at current position. */ + || pending_exact + *pending_exact + 1 != b + + /* We have only one byte following the exactn for the count. */ + || *pending_exact == (1 << BYTEWIDTH) - 1 + + /* If followed by a repetition operator. */ + || *p == '*' || *p == '^' + || ((syntax & RE_BK_PLUS_QM) + ? *p == '\\' && (p[1] == '+' || p[1] == '?') + : (*p == '+' || *p == '?')) + || ((syntax & RE_INTERVALS) + && ((syntax & RE_NO_BK_BRACES) + ? *p == '{' + : (p[0] == '\\' && p[1] == '{')))) + { + /* Start building a new exactn. */ + + laststart = b; + + BUF_PUSH_2 (exactn, 0); + pending_exact = b - 1; + } + + BUF_PUSH (c); + (*pending_exact)++; + break; + } /* switch (c) */ + } /* while p != pend */ + + + /* Through the pattern now. */ + + if (fixup_alt_jump) + STORE_JUMP (jump_past_alt, fixup_alt_jump, b); + + if (!COMPILE_STACK_EMPTY) + FREE_STACK_RETURN (REG_EPAREN); + + /* If we don't want backtracking, force success + the first time we reach the end of the compiled pattern. */ + if (syntax & RE_NO_POSIX_BACKTRACKING) + BUF_PUSH (succeed); + + free (compile_stack.stack); + + /* We have succeeded; set the length of the buffer. */ + bufp->used = b - bufp->buffer; + +#ifdef DEBUG + if (debug) + { + DEBUG_PRINT1 ("\nCompiled pattern: \n"); + print_compiled_pattern (bufp); + } +#endif /* DEBUG */ + +#ifndef MATCH_MAY_ALLOCATE + /* Initialize the failure stack to the largest possible stack. This + isn't necessary unless we're trying to avoid calling alloca in + the search and match routines. */ + { + int num_regs = bufp->re_nsub + 1; + + /* Since DOUBLE_FAIL_STACK refuses to double only if the current size + is strictly greater than re_max_failures, the largest possible stack + is 2 * re_max_failures failure points. */ + if (fail_stack.size < (2 * re_max_failures * MAX_FAILURE_ITEMS)) + { + fail_stack.size = (2 * re_max_failures * MAX_FAILURE_ITEMS); + +#ifdef emacs + if (! fail_stack.stack) + fail_stack.stack + = (fail_stack_elt_t *) xmalloc (fail_stack.size + * sizeof (fail_stack_elt_t)); + else + fail_stack.stack + = (fail_stack_elt_t *) xrealloc (fail_stack.stack, + (fail_stack.size + * sizeof (fail_stack_elt_t))); +#else /* not emacs */ + if (! fail_stack.stack) + fail_stack.stack + = (fail_stack_elt_t *) malloc (fail_stack.size + * sizeof (fail_stack_elt_t)); + else + fail_stack.stack + = (fail_stack_elt_t *) realloc (fail_stack.stack, + (fail_stack.size + * sizeof (fail_stack_elt_t))); +#endif /* not emacs */ + } + + regex_grow_registers (num_regs); + } +#endif /* not MATCH_MAY_ALLOCATE */ + + return REG_NOERROR; +} /* regex_compile */ + +/* Subroutines for `regex_compile'. */ + +/* Store OP at LOC followed by two-byte integer parameter ARG. */ + +static void +store_op1 (op, loc, arg) + re_opcode_t op; + unsigned char *loc; + int arg; +{ + *loc = (unsigned char) op; + STORE_NUMBER (loc + 1, arg); +} + + +/* Like `store_op1', but for two two-byte parameters ARG1 and ARG2. */ + +static void +store_op2 (op, loc, arg1, arg2) + re_opcode_t op; + unsigned char *loc; + int arg1, arg2; +{ + *loc = (unsigned char) op; + STORE_NUMBER (loc + 1, arg1); + STORE_NUMBER (loc + 3, arg2); +} + + +/* Copy the bytes from LOC to END to open up three bytes of space at LOC + for OP followed by two-byte integer parameter ARG. */ + +static void +insert_op1 (op, loc, arg, end) + re_opcode_t op; + unsigned char *loc; + int arg; + unsigned char *end; +{ + register unsigned char *pfrom = end; + register unsigned char *pto = end + 3; + + while (pfrom != loc) + *--pto = *--pfrom; + + store_op1 (op, loc, arg); +} + + +/* Like `insert_op1', but for two two-byte parameters ARG1 and ARG2. */ + +static void +insert_op2 (op, loc, arg1, arg2, end) + re_opcode_t op; + unsigned char *loc; + int arg1, arg2; + unsigned char *end; +{ + register unsigned char *pfrom = end; + register unsigned char *pto = end + 5; + + while (pfrom != loc) + *--pto = *--pfrom; + + store_op2 (op, loc, arg1, arg2); +} + + +/* P points to just after a ^ in PATTERN. Return true if that ^ comes + after an alternative or a begin-subexpression. We assume there is at + least one character before the ^. */ + +static boolean +at_begline_loc_p (pattern, p, syntax) + const char *pattern, *p; + reg_syntax_t syntax; +{ + const char *prev = p - 2; + boolean prev_prev_backslash = prev > pattern && prev[-1] == '\\'; + + return + /* After a subexpression? */ + (*prev == '(' && (syntax & RE_NO_BK_PARENS || prev_prev_backslash)) + /* After an alternative? */ + || (*prev == '|' && (syntax & RE_NO_BK_VBAR || prev_prev_backslash)); +} + + +/* The dual of at_begline_loc_p. This one is for $. We assume there is + at least one character after the $, i.e., `P < PEND'. */ + +static boolean +at_endline_loc_p (p, pend, syntax) + const char *p, *pend; + int syntax; +{ + const char *next = p; + boolean next_backslash = *next == '\\'; + const char *next_next = p + 1 < pend ? p + 1 : NULL; + + return + /* Before a subexpression? */ + (syntax & RE_NO_BK_PARENS ? *next == ')' + : next_backslash && next_next && *next_next == ')') + /* Before an alternative? */ + || (syntax & RE_NO_BK_VBAR ? *next == '|' + : next_backslash && next_next && *next_next == '|'); +} + + +/* Returns true if REGNUM is in one of COMPILE_STACK's elements and + false if it's not. */ + +static boolean +group_in_compile_stack (compile_stack, regnum) + compile_stack_type compile_stack; + regnum_t regnum; +{ + int this_element; + + for (this_element = compile_stack.avail - 1; + this_element >= 0; + this_element--) + if (compile_stack.stack[this_element].regnum == regnum) + return true; + + return false; +} + + +/* Read the ending character of a range (in a bracket expression) from the + uncompiled pattern *P_PTR (which ends at PEND). We assume the + starting character is in `P[-2]'. (`P[-1]' is the character `-'.) + Then we set the translation of all bits between the starting and + ending characters (inclusive) in the compiled pattern B. + + Return an error code. + + We use these short variable names so we can use the same macros as + `regex_compile' itself. */ + +static reg_errcode_t +compile_range (p_ptr, pend, translate, syntax, b) + const char **p_ptr, *pend; + char *translate; + reg_syntax_t syntax; + unsigned char *b; +{ + unsigned this_char; + + const char *p = *p_ptr; + int range_start, range_end; + + if (p == pend) + return REG_ERANGE; + + /* Even though the pattern is a signed `char *', we need to fetch + with unsigned char *'s; if the high bit of the pattern character + is set, the range endpoints will be negative if we fetch using a + signed char *. + + We also want to fetch the endpoints without translating them; the + appropriate translation is done in the bit-setting loop below. */ + /* The SVR4 compiler on the 3B2 had trouble with unsigned const char *. */ + range_start = ((const unsigned char *) p)[-2]; + range_end = ((const unsigned char *) p)[0]; + + /* Have to increment the pointer into the pattern string, so the + caller isn't still at the ending character. */ + (*p_ptr)++; + + /* If the start is after the end, the range is empty. */ + if (range_start > range_end) + return syntax & RE_NO_EMPTY_RANGES ? REG_ERANGE : REG_NOERROR; + + /* Here we see why `this_char' has to be larger than an `unsigned + char' -- the range is inclusive, so if `range_end' == 0xff + (assuming 8-bit characters), we would otherwise go into an infinite + loop, since all characters <= 0xff. */ + for (this_char = range_start; this_char <= range_end; this_char++) + { + SET_LIST_BIT (TRANSLATE (this_char)); + } + + return REG_NOERROR; +} + +/* re_compile_fastmap computes a ``fastmap'' for the compiled pattern in + BUFP. A fastmap records which of the (1 << BYTEWIDTH) possible + characters can start a string that matches the pattern. This fastmap + is used by re_search to skip quickly over impossible starting points. + + The caller must supply the address of a (1 << BYTEWIDTH)-byte data + area as BUFP->fastmap. + + We set the `fastmap', `fastmap_accurate', and `can_be_null' fields in + the pattern buffer. + + Returns 0 if we succeed, -2 if an internal error. */ + +int +re_compile_fastmap (bufp) + struct re_pattern_buffer *bufp; +{ + int j, k; +#ifdef MATCH_MAY_ALLOCATE + fail_stack_type fail_stack; +#endif +#ifndef REGEX_MALLOC + char *destination; +#endif + /* We don't push any register information onto the failure stack. */ + unsigned num_regs = 0; + + register char *fastmap = bufp->fastmap; + unsigned char *pattern = bufp->buffer; + unsigned long size = bufp->used; + unsigned char *p = pattern; + register unsigned char *pend = pattern + size; + + /* This holds the pointer to the failure stack, when + it is allocated relocatably. */ + fail_stack_elt_t *failure_stack_ptr; + + /* Assume that each path through the pattern can be null until + proven otherwise. We set this false at the bottom of switch + statement, to which we get only if a particular path doesn't + match the empty string. */ + boolean path_can_be_null = true; + + /* We aren't doing a `succeed_n' to begin with. */ + boolean succeed_n_p = false; + + assert (fastmap != NULL && p != NULL); + + INIT_FAIL_STACK (); + bzero (fastmap, 1 << BYTEWIDTH); /* Assume nothing's valid. */ + bufp->fastmap_accurate = 1; /* It will be when we're done. */ + bufp->can_be_null = 0; + + while (1) + { + if (p == pend || *p == succeed) + { + /* We have reached the (effective) end of pattern. */ + if (!FAIL_STACK_EMPTY ()) + { + bufp->can_be_null |= path_can_be_null; + + /* Reset for next path. */ + path_can_be_null = true; + + p = fail_stack.stack[--fail_stack.avail].pointer; + + continue; + } + else + break; + } + + /* We should never be about to go beyond the end of the pattern. */ + assert (p < pend); + + switch (SWITCH_ENUM_CAST ((re_opcode_t) *p++)) + { + + /* I guess the idea here is to simply not bother with a fastmap + if a backreference is used, since it's too hard to figure out + the fastmap for the corresponding group. Setting + `can_be_null' stops `re_search_2' from using the fastmap, so + that is all we do. */ + case duplicate: + bufp->can_be_null = 1; + goto done; + + + /* Following are the cases which match a character. These end + with `break'. */ + + case exactn: + fastmap[p[1]] = 1; + break; + + + case charset: + for (j = *p++ * BYTEWIDTH - 1; j >= 0; j--) + if (p[j / BYTEWIDTH] & (1 << (j % BYTEWIDTH))) + fastmap[j] = 1; + break; + + + case charset_not: + /* Chars beyond end of map must be allowed. */ + for (j = *p * BYTEWIDTH; j < (1 << BYTEWIDTH); j++) + fastmap[j] = 1; + + for (j = *p++ * BYTEWIDTH - 1; j >= 0; j--) + if (!(p[j / BYTEWIDTH] & (1 << (j % BYTEWIDTH)))) + fastmap[j] = 1; + break; + + + case wordchar: + for (j = 0; j < (1 << BYTEWIDTH); j++) + if (SYNTAX (j) == Sword) + fastmap[j] = 1; + break; + + + case notwordchar: + for (j = 0; j < (1 << BYTEWIDTH); j++) + if (SYNTAX (j) != Sword) + fastmap[j] = 1; + break; + + + case anychar: + { + int fastmap_newline = fastmap['\n']; + + /* `.' matches anything ... */ + for (j = 0; j < (1 << BYTEWIDTH); j++) + fastmap[j] = 1; + + /* ... except perhaps newline. */ + if (!(bufp->syntax & RE_DOT_NEWLINE)) + fastmap['\n'] = fastmap_newline; + + /* Return if we have already set `can_be_null'; if we have, + then the fastmap is irrelevant. Something's wrong here. */ + else if (bufp->can_be_null) + goto done; + + /* Otherwise, have to check alternative paths. */ + break; + } + +#ifdef emacs + case syntaxspec: + k = *p++; + for (j = 0; j < (1 << BYTEWIDTH); j++) + if (SYNTAX (j) == (enum syntaxcode) k) + fastmap[j] = 1; + break; + + + case notsyntaxspec: + k = *p++; + for (j = 0; j < (1 << BYTEWIDTH); j++) + if (SYNTAX (j) != (enum syntaxcode) k) + fastmap[j] = 1; + break; + + + /* All cases after this match the empty string. These end with + `continue'. */ + + + case before_dot: + case at_dot: + case after_dot: + continue; +#endif /* not emacs */ + + + case no_op: + case begline: + case endline: + case begbuf: + case endbuf: + case wordbound: + case notwordbound: + case wordbeg: + case wordend: + case push_dummy_failure: + continue; + + + case jump_n: + case pop_failure_jump: + case maybe_pop_jump: + case jump: + case jump_past_alt: + case dummy_failure_jump: + EXTRACT_NUMBER_AND_INCR (j, p); + p += j; + if (j > 0) + continue; + + /* Jump backward implies we just went through the body of a + loop and matched nothing. Opcode jumped to should be + `on_failure_jump' or `succeed_n'. Just treat it like an + ordinary jump. For a * loop, it has pushed its failure + point already; if so, discard that as redundant. */ + if ((re_opcode_t) *p != on_failure_jump + && (re_opcode_t) *p != succeed_n) + continue; + + p++; + EXTRACT_NUMBER_AND_INCR (j, p); + p += j; + + /* If what's on the stack is where we are now, pop it. */ + if (!FAIL_STACK_EMPTY () + && fail_stack.stack[fail_stack.avail - 1].pointer == p) + fail_stack.avail--; + + continue; + + + case on_failure_jump: + case on_failure_keep_string_jump: + handle_on_failure_jump: + EXTRACT_NUMBER_AND_INCR (j, p); + + /* For some patterns, e.g., `(a?)?', `p+j' here points to the + end of the pattern. We don't want to push such a point, + since when we restore it above, entering the switch will + increment `p' past the end of the pattern. We don't need + to push such a point since we obviously won't find any more + fastmap entries beyond `pend'. Such a pattern can match + the null string, though. */ + if (p + j < pend) + { + if (!PUSH_PATTERN_OP (p + j, fail_stack)) + { + RESET_FAIL_STACK (); + return -2; + } + } + else + bufp->can_be_null = 1; + + if (succeed_n_p) + { + EXTRACT_NUMBER_AND_INCR (k, p); /* Skip the n. */ + succeed_n_p = false; + } + + continue; + + + case succeed_n: + /* Get to the number of times to succeed. */ + p += 2; + + /* Increment p past the n for when k != 0. */ + EXTRACT_NUMBER_AND_INCR (k, p); + if (k == 0) + { + p -= 4; + succeed_n_p = true; /* Spaghetti code alert. */ + goto handle_on_failure_jump; + } + continue; + + + case set_number_at: + p += 4; + continue; + + + case start_memory: + case stop_memory: + p += 2; + continue; + + + default: + abort (); /* We have listed all the cases. */ + } /* switch *p++ */ + + /* Getting here means we have found the possible starting + characters for one path of the pattern -- and that the empty + string does not match. We need not follow this path further. + Instead, look at the next alternative (remembered on the + stack), or quit if no more. The test at the top of the loop + does these things. */ + path_can_be_null = false; + p = pend; + } /* while p */ + + /* Set `can_be_null' for the last path (also the first path, if the + pattern is empty). */ + bufp->can_be_null |= path_can_be_null; + + done: + RESET_FAIL_STACK (); + return 0; +} /* re_compile_fastmap */ + +/* Set REGS to hold NUM_REGS registers, storing them in STARTS and + ENDS. Subsequent matches using PATTERN_BUFFER and REGS will use + this memory for recording register information. STARTS and ENDS + must be allocated using the malloc library routine, and must each + be at least NUM_REGS * sizeof (regoff_t) bytes long. + + If NUM_REGS == 0, then subsequent matches should allocate their own + register data. + + Unless this function is called, the first search or match using + PATTERN_BUFFER will allocate its own register data, without + freeing the old data. */ + +void +re_set_registers (bufp, regs, num_regs, starts, ends) + struct re_pattern_buffer *bufp; + struct re_registers *regs; + unsigned num_regs; + regoff_t *starts, *ends; +{ + if (num_regs) + { + bufp->regs_allocated = REGS_REALLOCATE; + regs->num_regs = num_regs; + regs->start = starts; + regs->end = ends; + } + else + { + bufp->regs_allocated = REGS_UNALLOCATED; + regs->num_regs = 0; + regs->start = regs->end = (regoff_t *) 0; + } +} + +/* Searching routines. */ + +/* Like re_search_2, below, but only one string is specified, and + doesn't let you say where to stop matching. */ + +int +re_search (bufp, string, size, startpos, range, regs) + struct re_pattern_buffer *bufp; + const char *string; + int size, startpos, range; + struct re_registers *regs; +{ + return re_search_2 (bufp, NULL, 0, string, size, startpos, range, + regs, size); +} + + +/* Using the compiled pattern in BUFP->buffer, first tries to match the + virtual concatenation of STRING1 and STRING2, starting first at index + STARTPOS, then at STARTPOS + 1, and so on. + + STRING1 and STRING2 have length SIZE1 and SIZE2, respectively. + + RANGE is how far to scan while trying to match. RANGE = 0 means try + only at STARTPOS; in general, the last start tried is STARTPOS + + RANGE. + + In REGS, return the indices of the virtual concatenation of STRING1 + and STRING2 that matched the entire BUFP->buffer and its contained + subexpressions. + + Do not consider matching one past the index STOP in the virtual + concatenation of STRING1 and STRING2. + + We return either the position in the strings at which the match was + found, -1 if no match, or -2 if error (such as failure + stack overflow). */ + +int +re_search_2 (bufp, string1, size1, string2, size2, startpos, range, regs, stop) + struct re_pattern_buffer *bufp; + const char *string1, *string2; + int size1, size2; + int startpos; + int range; + struct re_registers *regs; + int stop; +{ + int val; + register char *fastmap = bufp->fastmap; + register char *translate = bufp->translate; + int total_size = size1 + size2; + int endpos = startpos + range; + + /* Check for out-of-range STARTPOS. */ + if (startpos < 0 || startpos > total_size) + return -1; + + /* Fix up RANGE if it might eventually take us outside + the virtual concatenation of STRING1 and STRING2. */ + if (endpos < -1) + range = -1 - startpos; + else if (endpos > total_size) + range = total_size - startpos; + + /* If the search isn't to be a backwards one, don't waste time in a + search for a pattern that must be anchored. */ + if (bufp->used > 0 && (re_opcode_t) bufp->buffer[0] == begbuf && range > 0) + { + if (startpos > 0) + return -1; + else + range = 1; + } + + /* Update the fastmap now if not correct already. */ + if (fastmap && !bufp->fastmap_accurate) + if (re_compile_fastmap (bufp) == -2) + return -2; + + /* Loop through the string, looking for a place to start matching. */ + for (;;) + { + /* If a fastmap is supplied, skip quickly over characters that + cannot be the start of a match. If the pattern can match the + null string, however, we don't need to skip characters; we want + the first null string. */ + if (fastmap && startpos < total_size && !bufp->can_be_null) + { + if (range > 0) /* Searching forwards. */ + { + register const char *d; + register int lim = 0; + int irange = range; + + if (startpos < size1 && startpos + range >= size1) + lim = range - (size1 - startpos); + + d = (startpos >= size1 ? string2 - size1 : string1) + startpos; + + /* Written out as an if-else to avoid testing `translate' + inside the loop. */ + if (translate) + while (range > lim + && !fastmap[(unsigned char) + translate[(unsigned char) *d++]]) + range--; + else + while (range > lim && !fastmap[(unsigned char) *d++]) + range--; + + startpos += irange - range; + } + else /* Searching backwards. */ + { + register char c = (size1 == 0 || startpos >= size1 + ? string2[startpos - size1] + : string1[startpos]); + + if (!fastmap[(unsigned char) TRANSLATE (c)]) + goto advance; + } + } + + /* If can't match the null string, and that's all we have left, fail. */ + if (range >= 0 && startpos == total_size && fastmap + && !bufp->can_be_null) + return -1; + + val = re_match_2_internal (bufp, string1, size1, string2, size2, + startpos, regs, stop); +#ifndef REGEX_MALLOC +#ifdef C_ALLOCA + alloca (0); +#endif +#endif + + if (val >= 0) + return startpos; + + if (val == -2) + return -2; + + advance: + if (!range) + break; + else if (range > 0) + { + range--; + startpos++; + } + else + { + range++; + startpos--; + } + } + return -1; +} /* re_search_2 */ + +/* Declarations and macros for re_match_2. */ + +static int bcmp_translate (); +static boolean alt_match_null_string_p (), + common_op_match_null_string_p (), + group_match_null_string_p (); + +/* This converts PTR, a pointer into one of the search strings `string1' + and `string2' into an offset from the beginning of that string. */ +#define POINTER_TO_OFFSET(ptr) \ + (FIRST_STRING_P (ptr) \ + ? ((regoff_t) ((ptr) - string1)) \ + : ((regoff_t) ((ptr) - string2 + size1))) + +/* Macros for dealing with the split strings in re_match_2. */ + +#define MATCHING_IN_FIRST_STRING (dend == end_match_1) + +/* Call before fetching a character with *d. This switches over to + string2 if necessary. */ +#define PREFETCH() \ + while (d == dend) \ + { \ + /* End of string2 => fail. */ \ + if (dend == end_match_2) \ + goto fail; \ + /* End of string1 => advance to string2. */ \ + d = string2; \ + dend = end_match_2; \ + } + + +/* Test if at very beginning or at very end of the virtual concatenation + of `string1' and `string2'. If only one string, it's `string2'. */ +#define AT_STRINGS_BEG(d) ((d) == (size1 ? string1 : string2) || !size2) +#define AT_STRINGS_END(d) ((d) == end2) + + +/* Test if D points to a character which is word-constituent. We have + two special cases to check for: if past the end of string1, look at + the first character in string2; and if before the beginning of + string2, look at the last character in string1. */ +#define WORDCHAR_P(d) \ + (SYNTAX ((d) == end1 ? *string2 \ + : (d) == string2 - 1 ? *(end1 - 1) : *(d)) \ + == Sword) + +/* Test if the character before D and the one at D differ with respect + to being word-constituent. */ +#define AT_WORD_BOUNDARY(d) \ + (AT_STRINGS_BEG (d) || AT_STRINGS_END (d) \ + || WORDCHAR_P (d - 1) != WORDCHAR_P (d)) + + +/* Free everything we malloc. */ +#ifdef MATCH_MAY_ALLOCATE +#define FREE_VAR(var) if (var) REGEX_FREE (var); var = NULL +#define FREE_VARIABLES() \ + do { \ + REGEX_FREE_STACK (fail_stack.stack); \ + FREE_VAR (regstart); \ + FREE_VAR (regend); \ + FREE_VAR (old_regstart); \ + FREE_VAR (old_regend); \ + FREE_VAR (best_regstart); \ + FREE_VAR (best_regend); \ + FREE_VAR (reg_info); \ + FREE_VAR (reg_dummy); \ + FREE_VAR (reg_info_dummy); \ + } while (0) +#else +#define FREE_VARIABLES() ((void)0) /* Do nothing! But inhibit gcc warning. */ +#endif /* not MATCH_MAY_ALLOCATE */ + +/* These values must meet several constraints. They must not be valid + register values; since we have a limit of 255 registers (because + we use only one byte in the pattern for the register number), we can + use numbers larger than 255. They must differ by 1, because of + NUM_FAILURE_ITEMS above. And the value for the lowest register must + be larger than the value for the highest register, so we do not try + to actually save any registers when none are active. */ +#define NO_HIGHEST_ACTIVE_REG (1 << BYTEWIDTH) +#define NO_LOWEST_ACTIVE_REG (NO_HIGHEST_ACTIVE_REG + 1) + +/* Matching routines. */ + +#ifndef emacs /* Emacs never uses this. */ +/* re_match is like re_match_2 except it takes only a single string. */ + +int +re_match (bufp, string, size, pos, regs) + struct re_pattern_buffer *bufp; + const char *string; + int size, pos; + struct re_registers *regs; +{ + int result = re_match_2_internal (bufp, NULL, 0, string, size, + pos, regs, size); + alloca (0); + return result; +} +#endif /* not emacs */ + + +/* re_match_2 matches the compiled pattern in BUFP against the + the (virtual) concatenation of STRING1 and STRING2 (of length SIZE1 + and SIZE2, respectively). We start matching at POS, and stop + matching at STOP. + + If REGS is non-null and the `no_sub' field of BUFP is nonzero, we + store offsets for the substring each group matched in REGS. See the + documentation for exactly how many groups we fill. + + We return -1 if no match, -2 if an internal error (such as the + failure stack overflowing). Otherwise, we return the length of the + matched substring. */ + +int +re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop) + struct re_pattern_buffer *bufp; + const char *string1, *string2; + int size1, size2; + int pos; + struct re_registers *regs; + int stop; +{ + int result = re_match_2_internal (bufp, string1, size1, string2, size2, + pos, regs, stop); + alloca (0); + return result; +} + +/* This is a separate function so that we can force an alloca cleanup + afterwards. */ +static int +re_match_2_internal (bufp, string1, size1, string2, size2, pos, regs, stop) + struct re_pattern_buffer *bufp; + const char *string1, *string2; + int size1, size2; + int pos; + struct re_registers *regs; + int stop; +{ + /* General temporaries. */ + int mcnt; + unsigned char *p1; + + /* Just past the end of the corresponding string. */ + const char *end1, *end2; + + /* Pointers into string1 and string2, just past the last characters in + each to consider matching. */ + const char *end_match_1, *end_match_2; + + /* Where we are in the data, and the end of the current string. */ + const char *d, *dend; + + /* Where we are in the pattern, and the end of the pattern. */ + unsigned char *p = bufp->buffer; + register unsigned char *pend = p + bufp->used; + + /* Mark the opcode just after a start_memory, so we can test for an + empty subpattern when we get to the stop_memory. */ + unsigned char *just_past_start_mem = 0; + + /* We use this to map every character in the string. */ + char *translate = bufp->translate; + + /* Failure point stack. Each place that can handle a failure further + down the line pushes a failure point on this stack. It consists of + restart, regend, and reg_info for all registers corresponding to + the subexpressions we're currently inside, plus the number of such + registers, and, finally, two char *'s. The first char * is where + to resume scanning the pattern; the second one is where to resume + scanning the strings. If the latter is zero, the failure point is + a ``dummy''; if a failure happens and the failure point is a dummy, + it gets discarded and the next next one is tried. */ +#ifdef MATCH_MAY_ALLOCATE /* otherwise, this is global. */ + fail_stack_type fail_stack; +#endif +#ifdef DEBUG + static unsigned failure_id = 0; + unsigned nfailure_points_pushed = 0, nfailure_points_popped = 0; +#endif + + /* This holds the pointer to the failure stack, when + it is allocated relocatably. */ + fail_stack_elt_t *failure_stack_ptr; + + /* We fill all the registers internally, independent of what we + return, for use in backreferences. The number here includes + an element for register zero. */ + unsigned num_regs = bufp->re_nsub + 1; + + /* The currently active registers. */ + unsigned lowest_active_reg = NO_LOWEST_ACTIVE_REG; + unsigned highest_active_reg = NO_HIGHEST_ACTIVE_REG; + + /* Information on the contents of registers. These are pointers into + the input strings; they record just what was matched (on this + attempt) by a subexpression part of the pattern, that is, the + regnum-th regstart pointer points to where in the pattern we began + matching and the regnum-th regend points to right after where we + stopped matching the regnum-th subexpression. (The zeroth register + keeps track of what the whole pattern matches.) */ +#ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global. */ + const char **regstart, **regend; +#endif + + /* If a group that's operated upon by a repetition operator fails to + match anything, then the register for its start will need to be + restored because it will have been set to wherever in the string we + are when we last see its open-group operator. Similarly for a + register's end. */ +#ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global. */ + const char **old_regstart, **old_regend; +#endif + + /* The is_active field of reg_info helps us keep track of which (possibly + nested) subexpressions we are currently in. The matched_something + field of reg_info[reg_num] helps us tell whether or not we have + matched any of the pattern so far this time through the reg_num-th + subexpression. These two fields get reset each time through any + loop their register is in. */ +#ifdef MATCH_MAY_ALLOCATE /* otherwise, this is global. */ + register_info_type *reg_info; +#endif + + /* The following record the register info as found in the above + variables when we find a match better than any we've seen before. + This happens as we backtrack through the failure points, which in + turn happens only if we have not yet matched the entire string. */ + unsigned best_regs_set = false; +#ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global. */ + const char **best_regstart, **best_regend; +#endif + + /* Logically, this is `best_regend[0]'. But we don't want to have to + allocate space for that if we're not allocating space for anything + else (see below). Also, we never need info about register 0 for + any of the other register vectors, and it seems rather a kludge to + treat `best_regend' differently than the rest. So we keep track of + the end of the best match so far in a separate variable. We + initialize this to NULL so that when we backtrack the first time + and need to test it, it's not garbage. */ + const char *match_end = NULL; + + /* This helps SET_REGS_MATCHED avoid doing redundant work. */ + int set_regs_matched_done = 0; + + /* Used when we pop values we don't care about. */ +#ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global. */ + const char **reg_dummy; + register_info_type *reg_info_dummy; +#endif + +#ifdef DEBUG + /* Counts the total number of registers pushed. */ + unsigned num_regs_pushed = 0; +#endif + + DEBUG_PRINT1 ("\n\nEntering re_match_2.\n"); + + INIT_FAIL_STACK (); + +#ifdef MATCH_MAY_ALLOCATE + /* Do not bother to initialize all the register variables if there are + no groups in the pattern, as it takes a fair amount of time. If + there are groups, we include space for register 0 (the whole + pattern), even though we never use it, since it simplifies the + array indexing. We should fix this. */ + if (bufp->re_nsub) + { + regstart = REGEX_TALLOC (num_regs, const char *); + regend = REGEX_TALLOC (num_regs, const char *); + old_regstart = REGEX_TALLOC (num_regs, const char *); + old_regend = REGEX_TALLOC (num_regs, const char *); + best_regstart = REGEX_TALLOC (num_regs, const char *); + best_regend = REGEX_TALLOC (num_regs, const char *); + reg_info = REGEX_TALLOC (num_regs, register_info_type); + reg_dummy = REGEX_TALLOC (num_regs, const char *); + reg_info_dummy = REGEX_TALLOC (num_regs, register_info_type); + + if (!(regstart && regend && old_regstart && old_regend && reg_info + && best_regstart && best_regend && reg_dummy && reg_info_dummy)) + { + FREE_VARIABLES (); + return -2; + } + } + else + { + /* We must initialize all our variables to NULL, so that + `FREE_VARIABLES' doesn't try to free them. */ + regstart = regend = old_regstart = old_regend = best_regstart + = best_regend = reg_dummy = NULL; + reg_info = reg_info_dummy = (register_info_type *) NULL; + } +#endif /* MATCH_MAY_ALLOCATE */ + + /* The starting position is bogus. */ + if (pos < 0 || pos > size1 + size2) + { + FREE_VARIABLES (); + return -1; + } + + /* Initialize subexpression text positions to -1 to mark ones that no + start_memory/stop_memory has been seen for. Also initialize the + register information struct. */ + for (mcnt = 1; mcnt < num_regs; mcnt++) + { + regstart[mcnt] = regend[mcnt] + = old_regstart[mcnt] = old_regend[mcnt] = REG_UNSET_VALUE; + + REG_MATCH_NULL_STRING_P (reg_info[mcnt]) = MATCH_NULL_UNSET_VALUE; + IS_ACTIVE (reg_info[mcnt]) = 0; + MATCHED_SOMETHING (reg_info[mcnt]) = 0; + EVER_MATCHED_SOMETHING (reg_info[mcnt]) = 0; + } + + /* We move `string1' into `string2' if the latter's empty -- but not if + `string1' is null. */ + if (size2 == 0 && string1 != NULL) + { + string2 = string1; + size2 = size1; + string1 = 0; + size1 = 0; + } + end1 = string1 + size1; + end2 = string2 + size2; + + /* Compute where to stop matching, within the two strings. */ + if (stop <= size1) + { + end_match_1 = string1 + stop; + end_match_2 = string2; + } + else + { + end_match_1 = end1; + end_match_2 = string2 + stop - size1; + } + + /* `p' scans through the pattern as `d' scans through the data. + `dend' is the end of the input string that `d' points within. `d' + is advanced into the following input string whenever necessary, but + this happens before fetching; therefore, at the beginning of the + loop, `d' can be pointing at the end of a string, but it cannot + equal `string2'. */ + if (size1 > 0 && pos <= size1) + { + d = string1 + pos; + dend = end_match_1; + } + else + { + d = string2 + pos - size1; + dend = end_match_2; + } + + DEBUG_PRINT1 ("The compiled pattern is: "); + DEBUG_PRINT_COMPILED_PATTERN (bufp, p, pend); + DEBUG_PRINT1 ("The string to match is: `"); + DEBUG_PRINT_DOUBLE_STRING (d, string1, size1, string2, size2); + DEBUG_PRINT1 ("'\n"); + + /* This loops over pattern commands. It exits by returning from the + function if the match is complete, or it drops through if the match + fails at this starting point in the input data. */ + for (;;) + { + DEBUG_PRINT2 ("\n0x%x: ", p); + + if (p == pend) + { /* End of pattern means we might have succeeded. */ + DEBUG_PRINT1 ("end of pattern ... "); + + /* If we haven't matched the entire string, and we want the + longest match, try backtracking. */ + if (d != end_match_2) + { + /* 1 if this match ends in the same string (string1 or string2) + as the best previous match. */ + boolean same_str_p = (FIRST_STRING_P (match_end) + == MATCHING_IN_FIRST_STRING); + /* 1 if this match is the best seen so far. */ + boolean best_match_p; + + /* AIX compiler got confused when this was combined + with the previous declaration. */ + if (same_str_p) + best_match_p = d > match_end; + else + best_match_p = !MATCHING_IN_FIRST_STRING; + + DEBUG_PRINT1 ("backtracking.\n"); + + if (!FAIL_STACK_EMPTY ()) + { /* More failure points to try. */ + + /* If exceeds best match so far, save it. */ + if (!best_regs_set || best_match_p) + { + best_regs_set = true; + match_end = d; + + DEBUG_PRINT1 ("\nSAVING match as best so far.\n"); + + for (mcnt = 1; mcnt < num_regs; mcnt++) + { + best_regstart[mcnt] = regstart[mcnt]; + best_regend[mcnt] = regend[mcnt]; + } + } + goto fail; + } + + /* If no failure points, don't restore garbage. And if + last match is real best match, don't restore second + best one. */ + else if (best_regs_set && !best_match_p) + { + restore_best_regs: + /* Restore best match. It may happen that `dend == + end_match_1' while the restored d is in string2. + For example, the pattern `x.*y.*z' against the + strings `x-' and `y-z-', if the two strings are + not consecutive in memory. */ + DEBUG_PRINT1 ("Restoring best registers.\n"); + + d = match_end; + dend = ((d >= string1 && d <= end1) + ? end_match_1 : end_match_2); + + for (mcnt = 1; mcnt < num_regs; mcnt++) + { + regstart[mcnt] = best_regstart[mcnt]; + regend[mcnt] = best_regend[mcnt]; + } + } + } /* d != end_match_2 */ + + succeed_label: + DEBUG_PRINT1 ("Accepting match.\n"); + + /* If caller wants register contents data back, do it. */ + if (regs && !bufp->no_sub) + { + /* Have the register data arrays been allocated? */ + if (bufp->regs_allocated == REGS_UNALLOCATED) + { /* No. So allocate them with malloc. We need one + extra element beyond `num_regs' for the `-1' marker + GNU code uses. */ + regs->num_regs = MAX (RE_NREGS, num_regs + 1); + regs->start = TALLOC (regs->num_regs, regoff_t); + regs->end = TALLOC (regs->num_regs, regoff_t); + if (regs->start == NULL || regs->end == NULL) + { + FREE_VARIABLES (); + return -2; + } + bufp->regs_allocated = REGS_REALLOCATE; + } + else if (bufp->regs_allocated == REGS_REALLOCATE) + { /* Yes. If we need more elements than were already + allocated, reallocate them. If we need fewer, just + leave it alone. */ + if (regs->num_regs < num_regs + 1) + { + regs->num_regs = num_regs + 1; + RETALLOC (regs->start, regs->num_regs, regoff_t); + RETALLOC (regs->end, regs->num_regs, regoff_t); + if (regs->start == NULL || regs->end == NULL) + { + FREE_VARIABLES (); + return -2; + } + } + } + else + { + /* These braces fend off a "empty body in an else-statement" + warning under GCC when assert expands to nothing. */ + assert (bufp->regs_allocated == REGS_FIXED); + } + + /* Convert the pointer data in `regstart' and `regend' to + indices. Register zero has to be set differently, + since we haven't kept track of any info for it. */ + if (regs->num_regs > 0) + { + regs->start[0] = pos; + regs->end[0] = (MATCHING_IN_FIRST_STRING + ? ((regoff_t) (d - string1)) + : ((regoff_t) (d - string2 + size1))); + } + + /* Go through the first `min (num_regs, regs->num_regs)' + registers, since that is all we initialized. */ + for (mcnt = 1; mcnt < MIN (num_regs, regs->num_regs); mcnt++) + { + if (REG_UNSET (regstart[mcnt]) || REG_UNSET (regend[mcnt])) + regs->start[mcnt] = regs->end[mcnt] = -1; + else + { + regs->start[mcnt] + = (regoff_t) POINTER_TO_OFFSET (regstart[mcnt]); + regs->end[mcnt] + = (regoff_t) POINTER_TO_OFFSET (regend[mcnt]); + } + } + + /* If the regs structure we return has more elements than + were in the pattern, set the extra elements to -1. If + we (re)allocated the registers, this is the case, + because we always allocate enough to have at least one + -1 at the end. */ + for (mcnt = num_regs; mcnt < regs->num_regs; mcnt++) + regs->start[mcnt] = regs->end[mcnt] = -1; + } /* regs && !bufp->no_sub */ + + DEBUG_PRINT4 ("%u failure points pushed, %u popped (%u remain).\n", + nfailure_points_pushed, nfailure_points_popped, + nfailure_points_pushed - nfailure_points_popped); + DEBUG_PRINT2 ("%u registers pushed.\n", num_regs_pushed); + + mcnt = d - pos - (MATCHING_IN_FIRST_STRING + ? string1 + : string2 - size1); + + DEBUG_PRINT2 ("Returning %d from re_match_2.\n", mcnt); + + FREE_VARIABLES (); + return mcnt; + } + + /* Otherwise match next pattern command. */ + switch (SWITCH_ENUM_CAST ((re_opcode_t) *p++)) + { + /* Ignore these. Used to ignore the n of succeed_n's which + currently have n == 0. */ + case no_op: + DEBUG_PRINT1 ("EXECUTING no_op.\n"); + break; + + case succeed: + DEBUG_PRINT1 ("EXECUTING succeed.\n"); + goto succeed_label; + + /* Match the next n pattern characters exactly. The following + byte in the pattern defines n, and the n bytes after that + are the characters to match. */ + case exactn: + mcnt = *p++; + DEBUG_PRINT2 ("EXECUTING exactn %d.\n", mcnt); + + /* This is written out as an if-else so we don't waste time + testing `translate' inside the loop. */ + if (translate) + { + do + { + PREFETCH (); + if (translate[(unsigned char) *d++] != (char) *p++) + goto fail; + } + while (--mcnt); + } + else + { + do + { + PREFETCH (); + if (*d++ != (char) *p++) goto fail; + } + while (--mcnt); + } + SET_REGS_MATCHED (); + break; + + + /* Match any character except possibly a newline or a null. */ + case anychar: + DEBUG_PRINT1 ("EXECUTING anychar.\n"); + + PREFETCH (); + + if ((!(bufp->syntax & RE_DOT_NEWLINE) && TRANSLATE (*d) == '\n') + || (bufp->syntax & RE_DOT_NOT_NULL && TRANSLATE (*d) == '\000')) + goto fail; + + SET_REGS_MATCHED (); + DEBUG_PRINT2 (" Matched `%d'.\n", *d); + d++; + break; + + + case charset: + case charset_not: + { + register unsigned char c; + boolean not = (re_opcode_t) *(p - 1) == charset_not; + + DEBUG_PRINT2 ("EXECUTING charset%s.\n", not ? "_not" : ""); + + PREFETCH (); + c = TRANSLATE (*d); /* The character to match. */ + + /* Cast to `unsigned' instead of `unsigned char' in case the + bit list is a full 32 bytes long. */ + if (c < (unsigned) (*p * BYTEWIDTH) + && p[1 + c / BYTEWIDTH] & (1 << (c % BYTEWIDTH))) + not = !not; + + p += 1 + *p; + + if (!not) goto fail; + + SET_REGS_MATCHED (); + d++; + break; + } + + + /* The beginning of a group is represented by start_memory. + The arguments are the register number in the next byte, and the + number of groups inner to this one in the next. The text + matched within the group is recorded (in the internal + registers data structure) under the register number. */ + case start_memory: + DEBUG_PRINT3 ("EXECUTING start_memory %d (%d):\n", *p, p[1]); + + /* Find out if this group can match the empty string. */ + p1 = p; /* To send to group_match_null_string_p. */ + + if (REG_MATCH_NULL_STRING_P (reg_info[*p]) == MATCH_NULL_UNSET_VALUE) + REG_MATCH_NULL_STRING_P (reg_info[*p]) + = group_match_null_string_p (&p1, pend, reg_info); + + /* Save the position in the string where we were the last time + we were at this open-group operator in case the group is + operated upon by a repetition operator, e.g., with `(a*)*b' + against `ab'; then we want to ignore where we are now in + the string in case this attempt to match fails. */ + old_regstart[*p] = REG_MATCH_NULL_STRING_P (reg_info[*p]) + ? REG_UNSET (regstart[*p]) ? d : regstart[*p] + : regstart[*p]; + DEBUG_PRINT2 (" old_regstart: %d\n", + POINTER_TO_OFFSET (old_regstart[*p])); + + regstart[*p] = d; + DEBUG_PRINT2 (" regstart: %d\n", POINTER_TO_OFFSET (regstart[*p])); + + IS_ACTIVE (reg_info[*p]) = 1; + MATCHED_SOMETHING (reg_info[*p]) = 0; + + /* Clear this whenever we change the register activity status. */ + set_regs_matched_done = 0; + + /* This is the new highest active register. */ + highest_active_reg = *p; + + /* If nothing was active before, this is the new lowest active + register. */ + if (lowest_active_reg == NO_LOWEST_ACTIVE_REG) + lowest_active_reg = *p; + + /* Move past the register number and inner group count. */ + p += 2; + just_past_start_mem = p; + + break; + + + /* The stop_memory opcode represents the end of a group. Its + arguments are the same as start_memory's: the register + number, and the number of inner groups. */ + case stop_memory: + DEBUG_PRINT3 ("EXECUTING stop_memory %d (%d):\n", *p, p[1]); + + /* We need to save the string position the last time we were at + this close-group operator in case the group is operated + upon by a repetition operator, e.g., with `((a*)*(b*)*)*' + against `aba'; then we want to ignore where we are now in + the string in case this attempt to match fails. */ + old_regend[*p] = REG_MATCH_NULL_STRING_P (reg_info[*p]) + ? REG_UNSET (regend[*p]) ? d : regend[*p] + : regend[*p]; + DEBUG_PRINT2 (" old_regend: %d\n", + POINTER_TO_OFFSET (old_regend[*p])); + + regend[*p] = d; + DEBUG_PRINT2 (" regend: %d\n", POINTER_TO_OFFSET (regend[*p])); + + /* This register isn't active anymore. */ + IS_ACTIVE (reg_info[*p]) = 0; + + /* Clear this whenever we change the register activity status. */ + set_regs_matched_done = 0; + + /* If this was the only register active, nothing is active + anymore. */ + if (lowest_active_reg == highest_active_reg) + { + lowest_active_reg = NO_LOWEST_ACTIVE_REG; + highest_active_reg = NO_HIGHEST_ACTIVE_REG; + } + else + { /* We must scan for the new highest active register, since + it isn't necessarily one less than now: consider + (a(b)c(d(e)f)g). When group 3 ends, after the f), the + new highest active register is 1. */ + unsigned char r = *p - 1; + while (r > 0 && !IS_ACTIVE (reg_info[r])) + r--; + + /* If we end up at register zero, that means that we saved + the registers as the result of an `on_failure_jump', not + a `start_memory', and we jumped to past the innermost + `stop_memory'. For example, in ((.)*) we save + registers 1 and 2 as a result of the *, but when we pop + back to the second ), we are at the stop_memory 1. + Thus, nothing is active. */ + if (r == 0) + { + lowest_active_reg = NO_LOWEST_ACTIVE_REG; + highest_active_reg = NO_HIGHEST_ACTIVE_REG; + } + else + highest_active_reg = r; + } + + /* If just failed to match something this time around with a + group that's operated on by a repetition operator, try to + force exit from the ``loop'', and restore the register + information for this group that we had before trying this + last match. */ + if ((!MATCHED_SOMETHING (reg_info[*p]) + || just_past_start_mem == p - 1) + && (p + 2) < pend) + { + boolean is_a_jump_n = false; + + p1 = p + 2; + mcnt = 0; + switch ((re_opcode_t) *p1++) + { + case jump_n: + is_a_jump_n = true; + case pop_failure_jump: + case maybe_pop_jump: + case jump: + case dummy_failure_jump: + EXTRACT_NUMBER_AND_INCR (mcnt, p1); + if (is_a_jump_n) + p1 += 2; + break; + + default: + /* do nothing */ ; + } + p1 += mcnt; + + /* If the next operation is a jump backwards in the pattern + to an on_failure_jump right before the start_memory + corresponding to this stop_memory, exit from the loop + by forcing a failure after pushing on the stack the + on_failure_jump's jump in the pattern, and d. */ + if (mcnt < 0 && (re_opcode_t) *p1 == on_failure_jump + && (re_opcode_t) p1[3] == start_memory && p1[4] == *p) + { + /* If this group ever matched anything, then restore + what its registers were before trying this last + failed match, e.g., with `(a*)*b' against `ab' for + regstart[1], and, e.g., with `((a*)*(b*)*)*' + against `aba' for regend[3]. + + Also restore the registers for inner groups for, + e.g., `((a*)(b*))*' against `aba' (register 3 would + otherwise get trashed). */ + + if (EVER_MATCHED_SOMETHING (reg_info[*p])) + { + unsigned r; + + EVER_MATCHED_SOMETHING (reg_info[*p]) = 0; + + /* Restore this and inner groups' (if any) registers. */ + for (r = *p; r < *p + *(p + 1); r++) + { + regstart[r] = old_regstart[r]; + + /* xx why this test? */ + if (old_regend[r] >= regstart[r]) + regend[r] = old_regend[r]; + } + } + p1++; + EXTRACT_NUMBER_AND_INCR (mcnt, p1); + PUSH_FAILURE_POINT (p1 + mcnt, d, -2); + + goto fail; + } + } + + /* Move past the register number and the inner group count. */ + p += 2; + break; + + + /* \<digit> has been turned into a `duplicate' command which is + followed by the numeric value of <digit> as the register number. */ + case duplicate: + { + register const char *d2, *dend2; + int regno = *p++; /* Get which register to match against. */ + DEBUG_PRINT2 ("EXECUTING duplicate %d.\n", regno); + + /* Can't back reference a group which we've never matched. */ + if (REG_UNSET (regstart[regno]) || REG_UNSET (regend[regno])) + goto fail; + + /* Where in input to try to start matching. */ + d2 = regstart[regno]; + + /* Where to stop matching; if both the place to start and + the place to stop matching are in the same string, then + set to the place to stop, otherwise, for now have to use + the end of the first string. */ + + dend2 = ((FIRST_STRING_P (regstart[regno]) + == FIRST_STRING_P (regend[regno])) + ? regend[regno] : end_match_1); + for (;;) + { + /* If necessary, advance to next segment in register + contents. */ + while (d2 == dend2) + { + if (dend2 == end_match_2) break; + if (dend2 == regend[regno]) break; + + /* End of string1 => advance to string2. */ + d2 = string2; + dend2 = regend[regno]; + } + /* At end of register contents => success */ + if (d2 == dend2) break; + + /* If necessary, advance to next segment in data. */ + PREFETCH (); + + /* How many characters left in this segment to match. */ + mcnt = dend - d; + + /* Want how many consecutive characters we can match in + one shot, so, if necessary, adjust the count. */ + if (mcnt > dend2 - d2) + mcnt = dend2 - d2; + + /* Compare that many; failure if mismatch, else move + past them. */ + if (translate + ? bcmp_translate (d, d2, mcnt, translate) + : bcmp (d, d2, mcnt)) + goto fail; + d += mcnt, d2 += mcnt; + + /* Do this because we've match some characters. */ + SET_REGS_MATCHED (); + } + } + break; + + + /* begline matches the empty string at the beginning of the string + (unless `not_bol' is set in `bufp'), and, if + `newline_anchor' is set, after newlines. */ + case begline: + DEBUG_PRINT1 ("EXECUTING begline.\n"); + + if (AT_STRINGS_BEG (d)) + { + if (!bufp->not_bol) break; + } + else if (d[-1] == '\n' && bufp->newline_anchor) + { + break; + } + /* In all other cases, we fail. */ + goto fail; + + + /* endline is the dual of begline. */ + case endline: + DEBUG_PRINT1 ("EXECUTING endline.\n"); + + if (AT_STRINGS_END (d)) + { + if (!bufp->not_eol) break; + } + + /* We have to ``prefetch'' the next character. */ + else if ((d == end1 ? *string2 : *d) == '\n' + && bufp->newline_anchor) + { + break; + } + goto fail; + + + /* Match at the very beginning of the data. */ + case begbuf: + DEBUG_PRINT1 ("EXECUTING begbuf.\n"); + if (AT_STRINGS_BEG (d)) + break; + goto fail; + + + /* Match at the very end of the data. */ + case endbuf: + DEBUG_PRINT1 ("EXECUTING endbuf.\n"); + if (AT_STRINGS_END (d)) + break; + goto fail; + + + /* on_failure_keep_string_jump is used to optimize `.*\n'. It + pushes NULL as the value for the string on the stack. Then + `pop_failure_point' will keep the current value for the + string, instead of restoring it. To see why, consider + matching `foo\nbar' against `.*\n'. The .* matches the foo; + then the . fails against the \n. But the next thing we want + to do is match the \n against the \n; if we restored the + string value, we would be back at the foo. + + Because this is used only in specific cases, we don't need to + check all the things that `on_failure_jump' does, to make + sure the right things get saved on the stack. Hence we don't + share its code. The only reason to push anything on the + stack at all is that otherwise we would have to change + `anychar's code to do something besides goto fail in this + case; that seems worse than this. */ + case on_failure_keep_string_jump: + DEBUG_PRINT1 ("EXECUTING on_failure_keep_string_jump"); + + EXTRACT_NUMBER_AND_INCR (mcnt, p); + DEBUG_PRINT3 (" %d (to 0x%x):\n", mcnt, p + mcnt); + + PUSH_FAILURE_POINT (p + mcnt, NULL, -2); + break; + + + /* Uses of on_failure_jump: + + Each alternative starts with an on_failure_jump that points + to the beginning of the next alternative. Each alternative + except the last ends with a jump that in effect jumps past + the rest of the alternatives. (They really jump to the + ending jump of the following alternative, because tensioning + these jumps is a hassle.) + + Repeats start with an on_failure_jump that points past both + the repetition text and either the following jump or + pop_failure_jump back to this on_failure_jump. */ + case on_failure_jump: + on_failure: + DEBUG_PRINT1 ("EXECUTING on_failure_jump"); + + EXTRACT_NUMBER_AND_INCR (mcnt, p); + DEBUG_PRINT3 (" %d (to 0x%x)", mcnt, p + mcnt); + + /* If this on_failure_jump comes right before a group (i.e., + the original * applied to a group), save the information + for that group and all inner ones, so that if we fail back + to this point, the group's information will be correct. + For example, in \(a*\)*\1, we need the preceding group, + and in \(\(a*\)b*\)\2, we need the inner group. */ + + /* We can't use `p' to check ahead because we push + a failure point to `p + mcnt' after we do this. */ + p1 = p; + + /* We need to skip no_op's before we look for the + start_memory in case this on_failure_jump is happening as + the result of a completed succeed_n, as in \(a\)\{1,3\}b\1 + against aba. */ + while (p1 < pend && (re_opcode_t) *p1 == no_op) + p1++; + + if (p1 < pend && (re_opcode_t) *p1 == start_memory) + { + /* We have a new highest active register now. This will + get reset at the start_memory we are about to get to, + but we will have saved all the registers relevant to + this repetition op, as described above. */ + highest_active_reg = *(p1 + 1) + *(p1 + 2); + if (lowest_active_reg == NO_LOWEST_ACTIVE_REG) + lowest_active_reg = *(p1 + 1); + } + + DEBUG_PRINT1 (":\n"); + PUSH_FAILURE_POINT (p + mcnt, d, -2); + break; + + + /* A smart repeat ends with `maybe_pop_jump'. + We change it to either `pop_failure_jump' or `jump'. */ + case maybe_pop_jump: + EXTRACT_NUMBER_AND_INCR (mcnt, p); + DEBUG_PRINT2 ("EXECUTING maybe_pop_jump %d.\n", mcnt); + { + register unsigned char *p2 = p; + + /* Compare the beginning of the repeat with what in the + pattern follows its end. If we can establish that there + is nothing that they would both match, i.e., that we + would have to backtrack because of (as in, e.g., `a*a') + then we can change to pop_failure_jump, because we'll + never have to backtrack. + + This is not true in the case of alternatives: in + `(a|ab)*' we do need to backtrack to the `ab' alternative + (e.g., if the string was `ab'). But instead of trying to + detect that here, the alternative has put on a dummy + failure point which is what we will end up popping. */ + + /* Skip over open/close-group commands. + If what follows this loop is a ...+ construct, + look at what begins its body, since we will have to + match at least one of that. */ + while (1) + { + if (p2 + 2 < pend + && ((re_opcode_t) *p2 == stop_memory + || (re_opcode_t) *p2 == start_memory)) + p2 += 3; + else if (p2 + 6 < pend + && (re_opcode_t) *p2 == dummy_failure_jump) + p2 += 6; + else + break; + } + + p1 = p + mcnt; + /* p1[0] ... p1[2] are the `on_failure_jump' corresponding + to the `maybe_finalize_jump' of this case. Examine what + follows. */ + + /* If we're at the end of the pattern, we can change. */ + if (p2 == pend) + { + /* Consider what happens when matching ":\(.*\)" + against ":/". I don't really understand this code + yet. */ + p[-3] = (unsigned char) pop_failure_jump; + DEBUG_PRINT1 + (" End of pattern: change to `pop_failure_jump'.\n"); + } + + else if ((re_opcode_t) *p2 == exactn + || (bufp->newline_anchor && (re_opcode_t) *p2 == endline)) + { + register unsigned char c + = *p2 == (unsigned char) endline ? '\n' : p2[2]; + + if ((re_opcode_t) p1[3] == exactn && p1[5] != c) + { + p[-3] = (unsigned char) pop_failure_jump; + DEBUG_PRINT3 (" %c != %c => pop_failure_jump.\n", + c, p1[5]); + } + + else if ((re_opcode_t) p1[3] == charset + || (re_opcode_t) p1[3] == charset_not) + { + int not = (re_opcode_t) p1[3] == charset_not; + + if (c < (unsigned char) (p1[4] * BYTEWIDTH) + && p1[5 + c / BYTEWIDTH] & (1 << (c % BYTEWIDTH))) + not = !not; + + /* `not' is equal to 1 if c would match, which means + that we can't change to pop_failure_jump. */ + if (!not) + { + p[-3] = (unsigned char) pop_failure_jump; + DEBUG_PRINT1 (" No match => pop_failure_jump.\n"); + } + } + } + else if ((re_opcode_t) *p2 == charset) + { +#ifdef DEBUG + register unsigned char c + = *p2 == (unsigned char) endline ? '\n' : p2[2]; +#endif + + if ((re_opcode_t) p1[3] == exactn + && ! ((int) p2[1] * BYTEWIDTH > (int) p1[4] + && (p2[1 + p1[4] / BYTEWIDTH] + & (1 << (p1[4] % BYTEWIDTH))))) + { + p[-3] = (unsigned char) pop_failure_jump; + DEBUG_PRINT3 (" %c != %c => pop_failure_jump.\n", + c, p1[5]); + } + + else if ((re_opcode_t) p1[3] == charset_not) + { + int idx; + /* We win if the charset_not inside the loop + lists every character listed in the charset after. */ + for (idx = 0; idx < (int) p2[1]; idx++) + if (! (p2[2 + idx] == 0 + || (idx < (int) p1[4] + && ((p2[2 + idx] & ~ p1[5 + idx]) == 0)))) + break; + + if (idx == p2[1]) + { + p[-3] = (unsigned char) pop_failure_jump; + DEBUG_PRINT1 (" No match => pop_failure_jump.\n"); + } + } + else if ((re_opcode_t) p1[3] == charset) + { + int idx; + /* We win if the charset inside the loop + has no overlap with the one after the loop. */ + for (idx = 0; + idx < (int) p2[1] && idx < (int) p1[4]; + idx++) + if ((p2[2 + idx] & p1[5 + idx]) != 0) + break; + + if (idx == p2[1] || idx == p1[4]) + { + p[-3] = (unsigned char) pop_failure_jump; + DEBUG_PRINT1 (" No match => pop_failure_jump.\n"); + } + } + } + } + p -= 2; /* Point at relative address again. */ + if ((re_opcode_t) p[-1] != pop_failure_jump) + { + p[-1] = (unsigned char) jump; + DEBUG_PRINT1 (" Match => jump.\n"); + goto unconditional_jump; + } + /* Note fall through. */ + + + /* The end of a simple repeat has a pop_failure_jump back to + its matching on_failure_jump, where the latter will push a + failure point. The pop_failure_jump takes off failure + points put on by this pop_failure_jump's matching + on_failure_jump; we got through the pattern to here from the + matching on_failure_jump, so didn't fail. */ + case pop_failure_jump: + { + /* We need to pass separate storage for the lowest and + highest registers, even though we don't care about the + actual values. Otherwise, we will restore only one + register from the stack, since lowest will == highest in + `pop_failure_point'. */ + unsigned dummy_low_reg, dummy_high_reg; + unsigned char *pdummy; + const char *sdummy; + + DEBUG_PRINT1 ("EXECUTING pop_failure_jump.\n"); + POP_FAILURE_POINT (sdummy, pdummy, + dummy_low_reg, dummy_high_reg, + reg_dummy, reg_dummy, reg_info_dummy); + } + /* Note fall through. */ + + + /* Unconditionally jump (without popping any failure points). */ + case jump: + unconditional_jump: + EXTRACT_NUMBER_AND_INCR (mcnt, p); /* Get the amount to jump. */ + DEBUG_PRINT2 ("EXECUTING jump %d ", mcnt); + p += mcnt; /* Do the jump. */ + DEBUG_PRINT2 ("(to 0x%x).\n", p); + break; + + + /* We need this opcode so we can detect where alternatives end + in `group_match_null_string_p' et al. */ + case jump_past_alt: + DEBUG_PRINT1 ("EXECUTING jump_past_alt.\n"); + goto unconditional_jump; + + + /* Normally, the on_failure_jump pushes a failure point, which + then gets popped at pop_failure_jump. We will end up at + pop_failure_jump, also, and with a pattern of, say, `a+', we + are skipping over the on_failure_jump, so we have to push + something meaningless for pop_failure_jump to pop. */ + case dummy_failure_jump: + DEBUG_PRINT1 ("EXECUTING dummy_failure_jump.\n"); + /* It doesn't matter what we push for the string here. What + the code at `fail' tests is the value for the pattern. */ + PUSH_FAILURE_POINT (0, 0, -2); + goto unconditional_jump; + + + /* At the end of an alternative, we need to push a dummy failure + point in case we are followed by a `pop_failure_jump', because + we don't want the failure point for the alternative to be + popped. For example, matching `(a|ab)*' against `aab' + requires that we match the `ab' alternative. */ + case push_dummy_failure: + DEBUG_PRINT1 ("EXECUTING push_dummy_failure.\n"); + /* See comments just above at `dummy_failure_jump' about the + two zeroes. */ + PUSH_FAILURE_POINT (0, 0, -2); + break; + + /* Have to succeed matching what follows at least n times. + After that, handle like `on_failure_jump'. */ + case succeed_n: + EXTRACT_NUMBER (mcnt, p + 2); + DEBUG_PRINT2 ("EXECUTING succeed_n %d.\n", mcnt); + + assert (mcnt >= 0); + /* Originally, this is how many times we HAVE to succeed. */ + if (mcnt > 0) + { + mcnt--; + p += 2; + STORE_NUMBER_AND_INCR (p, mcnt); + DEBUG_PRINT3 (" Setting 0x%x to %d.\n", p, mcnt); + } + else if (mcnt == 0) + { + DEBUG_PRINT2 (" Setting two bytes from 0x%x to no_op.\n", p+2); + p[2] = (unsigned char) no_op; + p[3] = (unsigned char) no_op; + goto on_failure; + } + break; + + case jump_n: + EXTRACT_NUMBER (mcnt, p + 2); + DEBUG_PRINT2 ("EXECUTING jump_n %d.\n", mcnt); + + /* Originally, this is how many times we CAN jump. */ + if (mcnt) + { + mcnt--; + STORE_NUMBER (p + 2, mcnt); + goto unconditional_jump; + } + /* If don't have to jump any more, skip over the rest of command. */ + else + p += 4; + break; + + case set_number_at: + { + DEBUG_PRINT1 ("EXECUTING set_number_at.\n"); + + EXTRACT_NUMBER_AND_INCR (mcnt, p); + p1 = p + mcnt; + EXTRACT_NUMBER_AND_INCR (mcnt, p); + DEBUG_PRINT3 (" Setting 0x%x to %d.\n", p1, mcnt); + STORE_NUMBER (p1, mcnt); + break; + } + + case wordbound: + DEBUG_PRINT1 ("EXECUTING wordbound.\n"); + if (AT_WORD_BOUNDARY (d)) + break; + goto fail; + + case notwordbound: + DEBUG_PRINT1 ("EXECUTING notwordbound.\n"); + if (AT_WORD_BOUNDARY (d)) + goto fail; + break; + + case wordbeg: + DEBUG_PRINT1 ("EXECUTING wordbeg.\n"); + if (WORDCHAR_P (d) && (AT_STRINGS_BEG (d) || !WORDCHAR_P (d - 1))) + break; + goto fail; + + case wordend: + DEBUG_PRINT1 ("EXECUTING wordend.\n"); + if (!AT_STRINGS_BEG (d) && WORDCHAR_P (d - 1) + && (!WORDCHAR_P (d) || AT_STRINGS_END (d))) + break; + goto fail; + +#ifdef emacs + case before_dot: + DEBUG_PRINT1 ("EXECUTING before_dot.\n"); + if (PTR_CHAR_POS ((unsigned char *) d) >= point) + goto fail; + break; + + case at_dot: + DEBUG_PRINT1 ("EXECUTING at_dot.\n"); + if (PTR_CHAR_POS ((unsigned char *) d) != point) + goto fail; + break; + + case after_dot: + DEBUG_PRINT1 ("EXECUTING after_dot.\n"); + if (PTR_CHAR_POS ((unsigned char *) d) <= point) + goto fail; + break; +#if 0 /* not emacs19 */ + case at_dot: + DEBUG_PRINT1 ("EXECUTING at_dot.\n"); + if (PTR_CHAR_POS ((unsigned char *) d) + 1 != point) + goto fail; + break; +#endif /* not emacs19 */ + + case syntaxspec: + DEBUG_PRINT2 ("EXECUTING syntaxspec %d.\n", mcnt); + mcnt = *p++; + goto matchsyntax; + + case wordchar: + DEBUG_PRINT1 ("EXECUTING Emacs wordchar.\n"); + mcnt = (int) Sword; + matchsyntax: + PREFETCH (); + /* Can't use *d++ here; SYNTAX may be an unsafe macro. */ + d++; + if (SYNTAX (d[-1]) != (enum syntaxcode) mcnt) + goto fail; + SET_REGS_MATCHED (); + break; + + case notsyntaxspec: + DEBUG_PRINT2 ("EXECUTING notsyntaxspec %d.\n", mcnt); + mcnt = *p++; + goto matchnotsyntax; + + case notwordchar: + DEBUG_PRINT1 ("EXECUTING Emacs notwordchar.\n"); + mcnt = (int) Sword; + matchnotsyntax: + PREFETCH (); + /* Can't use *d++ here; SYNTAX may be an unsafe macro. */ + d++; + if (SYNTAX (d[-1]) == (enum syntaxcode) mcnt) + goto fail; + SET_REGS_MATCHED (); + break; + +#else /* not emacs */ + case wordchar: + DEBUG_PRINT1 ("EXECUTING non-Emacs wordchar.\n"); + PREFETCH (); + if (!WORDCHAR_P (d)) + goto fail; + SET_REGS_MATCHED (); + d++; + break; + + case notwordchar: + DEBUG_PRINT1 ("EXECUTING non-Emacs notwordchar.\n"); + PREFETCH (); + if (WORDCHAR_P (d)) + goto fail; + SET_REGS_MATCHED (); + d++; + break; +#endif /* not emacs */ + + default: + abort (); + } + continue; /* Successfully executed one pattern command; keep going. */ + + + /* We goto here if a matching operation fails. */ + fail: + if (!FAIL_STACK_EMPTY ()) + { /* A restart point is known. Restore to that state. */ + DEBUG_PRINT1 ("\nFAIL:\n"); + POP_FAILURE_POINT (d, p, + lowest_active_reg, highest_active_reg, + regstart, regend, reg_info); + + /* If this failure point is a dummy, try the next one. */ + if (!p) + goto fail; + + /* If we failed to the end of the pattern, don't examine *p. */ + assert (p <= pend); + if (p < pend) + { + boolean is_a_jump_n = false; + + /* If failed to a backwards jump that's part of a repetition + loop, need to pop this failure point and use the next one. */ + switch ((re_opcode_t) *p) + { + case jump_n: + is_a_jump_n = true; + case maybe_pop_jump: + case pop_failure_jump: + case jump: + p1 = p + 1; + EXTRACT_NUMBER_AND_INCR (mcnt, p1); + p1 += mcnt; + + if ((is_a_jump_n && (re_opcode_t) *p1 == succeed_n) + || (!is_a_jump_n + && (re_opcode_t) *p1 == on_failure_jump)) + goto fail; + break; + default: + /* do nothing */ ; + } + } + + if (d >= string1 && d <= end1) + dend = end_match_1; + } + else + break; /* Matching at this starting point really fails. */ + } /* for (;;) */ + + if (best_regs_set) + goto restore_best_regs; + + FREE_VARIABLES (); + + return -1; /* Failure to match. */ +} /* re_match_2 */ + +/* Subroutine definitions for re_match_2. */ + + +/* We are passed P pointing to a register number after a start_memory. + + Return true if the pattern up to the corresponding stop_memory can + match the empty string, and false otherwise. + + If we find the matching stop_memory, sets P to point to one past its number. + Otherwise, sets P to an undefined byte less than or equal to END. + + We don't handle duplicates properly (yet). */ + +static boolean +group_match_null_string_p (p, end, reg_info) + unsigned char **p, *end; + register_info_type *reg_info; +{ + int mcnt; + /* Point to after the args to the start_memory. */ + unsigned char *p1 = *p + 2; + + while (p1 < end) + { + /* Skip over opcodes that can match nothing, and return true or + false, as appropriate, when we get to one that can't, or to the + matching stop_memory. */ + + switch ((re_opcode_t) *p1) + { + /* Could be either a loop or a series of alternatives. */ + case on_failure_jump: + p1++; + EXTRACT_NUMBER_AND_INCR (mcnt, p1); + + /* If the next operation is not a jump backwards in the + pattern. */ + + if (mcnt >= 0) + { + /* Go through the on_failure_jumps of the alternatives, + seeing if any of the alternatives cannot match nothing. + The last alternative starts with only a jump, + whereas the rest start with on_failure_jump and end + with a jump, e.g., here is the pattern for `a|b|c': + + /on_failure_jump/0/6/exactn/1/a/jump_past_alt/0/6 + /on_failure_jump/0/6/exactn/1/b/jump_past_alt/0/3 + /exactn/1/c + + So, we have to first go through the first (n-1) + alternatives and then deal with the last one separately. */ + + + /* Deal with the first (n-1) alternatives, which start + with an on_failure_jump (see above) that jumps to right + past a jump_past_alt. */ + + while ((re_opcode_t) p1[mcnt-3] == jump_past_alt) + { + /* `mcnt' holds how many bytes long the alternative + is, including the ending `jump_past_alt' and + its number. */ + + if (!alt_match_null_string_p (p1, p1 + mcnt - 3, + reg_info)) + return false; + + /* Move to right after this alternative, including the + jump_past_alt. */ + p1 += mcnt; + + /* Break if it's the beginning of an n-th alternative + that doesn't begin with an on_failure_jump. */ + if ((re_opcode_t) *p1 != on_failure_jump) + break; + + /* Still have to check that it's not an n-th + alternative that starts with an on_failure_jump. */ + p1++; + EXTRACT_NUMBER_AND_INCR (mcnt, p1); + if ((re_opcode_t) p1[mcnt-3] != jump_past_alt) + { + /* Get to the beginning of the n-th alternative. */ + p1 -= 3; + break; + } + } + + /* Deal with the last alternative: go back and get number + of the `jump_past_alt' just before it. `mcnt' contains + the length of the alternative. */ + EXTRACT_NUMBER (mcnt, p1 - 2); + + if (!alt_match_null_string_p (p1, p1 + mcnt, reg_info)) + return false; + + p1 += mcnt; /* Get past the n-th alternative. */ + } /* if mcnt > 0 */ + break; + + + case stop_memory: + assert (p1[1] == **p); + *p = p1 + 2; + return true; + + + default: + if (!common_op_match_null_string_p (&p1, end, reg_info)) + return false; + } + } /* while p1 < end */ + + return false; +} /* group_match_null_string_p */ + + +/* Similar to group_match_null_string_p, but doesn't deal with alternatives: + It expects P to be the first byte of a single alternative and END one + byte past the last. The alternative can contain groups. */ + +static boolean +alt_match_null_string_p (p, end, reg_info) + unsigned char *p, *end; + register_info_type *reg_info; +{ + int mcnt; + unsigned char *p1 = p; + + while (p1 < end) + { + /* Skip over opcodes that can match nothing, and break when we get + to one that can't. */ + + switch ((re_opcode_t) *p1) + { + /* It's a loop. */ + case on_failure_jump: + p1++; + EXTRACT_NUMBER_AND_INCR (mcnt, p1); + p1 += mcnt; + break; + + default: + if (!common_op_match_null_string_p (&p1, end, reg_info)) + return false; + } + } /* while p1 < end */ + + return true; +} /* alt_match_null_string_p */ + + +/* Deals with the ops common to group_match_null_string_p and + alt_match_null_string_p. + + Sets P to one after the op and its arguments, if any. */ + +static boolean +common_op_match_null_string_p (p, end, reg_info) + unsigned char **p, *end; + register_info_type *reg_info; +{ + int mcnt; + boolean ret; + int reg_no; + unsigned char *p1 = *p; + + switch ((re_opcode_t) *p1++) + { + case no_op: + case begline: + case endline: + case begbuf: + case endbuf: + case wordbeg: + case wordend: + case wordbound: + case notwordbound: +#ifdef emacs + case before_dot: + case at_dot: + case after_dot: +#endif + break; + + case start_memory: + reg_no = *p1; + assert (reg_no > 0 && reg_no <= MAX_REGNUM); + ret = group_match_null_string_p (&p1, end, reg_info); + + /* Have to set this here in case we're checking a group which + contains a group and a back reference to it. */ + + if (REG_MATCH_NULL_STRING_P (reg_info[reg_no]) == MATCH_NULL_UNSET_VALUE) + REG_MATCH_NULL_STRING_P (reg_info[reg_no]) = ret; + + if (!ret) + return false; + break; + + /* If this is an optimized succeed_n for zero times, make the jump. */ + case jump: + EXTRACT_NUMBER_AND_INCR (mcnt, p1); + if (mcnt >= 0) + p1 += mcnt; + else + return false; + break; + + case succeed_n: + /* Get to the number of times to succeed. */ + p1 += 2; + EXTRACT_NUMBER_AND_INCR (mcnt, p1); + + if (mcnt == 0) + { + p1 -= 4; + EXTRACT_NUMBER_AND_INCR (mcnt, p1); + p1 += mcnt; + } + else + return false; + break; + + case duplicate: + if (!REG_MATCH_NULL_STRING_P (reg_info[*p1])) + return false; + break; + + case set_number_at: + p1 += 4; + + default: + /* All other opcodes mean we cannot match the empty string. */ + return false; + } + + *p = p1; + return true; +} /* common_op_match_null_string_p */ + + +/* Return zero if TRANSLATE[S1] and TRANSLATE[S2] are identical for LEN + bytes; nonzero otherwise. */ + +static int +bcmp_translate (s1, s2, len, translate) + unsigned char *s1, *s2; + register int len; + char *translate; +{ + register unsigned char *p1 = s1, *p2 = s2; + while (len) + { + if (translate[*p1++] != translate[*p2++]) return 1; + len--; + } + return 0; +} + +/* Entry points for GNU code. */ + +/* re_compile_pattern is the GNU regular expression compiler: it + compiles PATTERN (of length SIZE) and puts the result in BUFP. + Returns 0 if the pattern was valid, otherwise an error string. + + Assumes the `allocated' (and perhaps `buffer') and `translate' fields + are set in BUFP on entry. + + We call regex_compile to do the actual compilation. */ + +const char * +re_compile_pattern (pattern, length, bufp) + const char *pattern; + int length; + struct re_pattern_buffer *bufp; +{ + reg_errcode_t ret; + + /* GNU code is written to assume at least RE_NREGS registers will be set + (and at least one extra will be -1). */ + bufp->regs_allocated = REGS_UNALLOCATED; + + /* And GNU code determines whether or not to get register information + by passing null for the REGS argument to re_match, etc., not by + setting no_sub. */ + bufp->no_sub = 0; + + /* Match anchors at newline. */ + bufp->newline_anchor = 1; + + ret = regex_compile (pattern, length, re_syntax_options, bufp); + + if (!ret) + return NULL; + return gettext (re_error_msgid[(int) ret]); +} + +/* Entry points compatible with 4.2 BSD regex library. We don't define + them unless specifically requested. */ + +#ifdef _REGEX_RE_COMP + +/* BSD has one and only one pattern buffer. */ +static struct re_pattern_buffer re_comp_buf; + +char * +re_comp (s) + const char *s; +{ + reg_errcode_t ret; + + if (!s) + { + if (!re_comp_buf.buffer) + return gettext ("No previous regular expression"); + return 0; + } + + if (!re_comp_buf.buffer) + { + re_comp_buf.buffer = (unsigned char *) malloc (200); + if (re_comp_buf.buffer == NULL) + return gettext (re_error_msgid[(int) REG_ESPACE]); + re_comp_buf.allocated = 200; + + re_comp_buf.fastmap = (char *) malloc (1 << BYTEWIDTH); + if (re_comp_buf.fastmap == NULL) + return gettext (re_error_msgid[(int) REG_ESPACE]); + } + + /* Since `re_exec' always passes NULL for the `regs' argument, we + don't need to initialize the pattern buffer fields which affect it. */ + + /* Match anchors at newlines. */ + re_comp_buf.newline_anchor = 1; + + ret = regex_compile (s, strlen (s), re_syntax_options, &re_comp_buf); + + if (!ret) + return NULL; + + /* Yes, we're discarding `const' here if !HAVE_LIBINTL. */ + return (char *) gettext (re_error_msgid[(int) ret]); +} + + +int +re_exec (s) + const char *s; +{ + const int len = strlen (s); + return + 0 <= re_search (&re_comp_buf, s, len, 0, len, (struct re_registers *) 0); +} +#endif /* _REGEX_RE_COMP */ + +/* POSIX.2 functions. Don't define these for Emacs. */ + +#ifndef emacs + +/* regcomp takes a regular expression as a string and compiles it. + + PREG is a regex_t *. We do not expect any fields to be initialized, + since POSIX says we shouldn't. Thus, we set + + `buffer' to the compiled pattern; + `used' to the length of the compiled pattern; + `syntax' to RE_SYNTAX_POSIX_EXTENDED if the + REG_EXTENDED bit in CFLAGS is set; otherwise, to + RE_SYNTAX_POSIX_BASIC; + `newline_anchor' to REG_NEWLINE being set in CFLAGS; + `fastmap' and `fastmap_accurate' to zero; + `re_nsub' to the number of subexpressions in PATTERN. + + PATTERN is the address of the pattern string. + + CFLAGS is a series of bits which affect compilation. + + If REG_EXTENDED is set, we use POSIX extended syntax; otherwise, we + use POSIX basic syntax. + + If REG_NEWLINE is set, then . and [^...] don't match newline. + Also, regexec will try a match beginning after every newline. + + If REG_ICASE is set, then we considers upper- and lowercase + versions of letters to be equivalent when matching. + + If REG_NOSUB is set, then when PREG is passed to regexec, that + routine will report only success or failure, and nothing about the + registers. + + It returns 0 if it succeeds, nonzero if it doesn't. (See regex.h for + the return codes and their meanings.) */ + +int +regcomp (preg, pattern, cflags) + regex_t *preg; + const char *pattern; + int cflags; +{ + reg_errcode_t ret; + unsigned syntax + = (cflags & REG_EXTENDED) ? + RE_SYNTAX_POSIX_EXTENDED : RE_SYNTAX_POSIX_BASIC; + + /* regex_compile will allocate the space for the compiled pattern. */ + preg->buffer = 0; + preg->allocated = 0; + preg->used = 0; + + /* Don't bother to use a fastmap when searching. This simplifies the + REG_NEWLINE case: if we used a fastmap, we'd have to put all the + characters after newlines into the fastmap. This way, we just try + every character. */ + preg->fastmap = 0; + + if (cflags & REG_ICASE) + { + unsigned i; + + preg->translate = (char *) malloc (CHAR_SET_SIZE); + if (preg->translate == NULL) + return (int) REG_ESPACE; + + /* Map uppercase characters to corresponding lowercase ones. */ + for (i = 0; i < CHAR_SET_SIZE; i++) + preg->translate[i] = ISUPPER (i) ? tolower (i) : i; + } + else + preg->translate = NULL; + + /* If REG_NEWLINE is set, newlines are treated differently. */ + if (cflags & REG_NEWLINE) + { /* REG_NEWLINE implies neither . nor [^...] match newline. */ + syntax &= ~RE_DOT_NEWLINE; + syntax |= RE_HAT_LISTS_NOT_NEWLINE; + /* It also changes the matching behavior. */ + preg->newline_anchor = 1; + } + else + preg->newline_anchor = 0; + + preg->no_sub = !!(cflags & REG_NOSUB); + + /* POSIX says a null character in the pattern terminates it, so we + can use strlen here in compiling the pattern. */ + ret = regex_compile (pattern, strlen (pattern), syntax, preg); + + /* POSIX doesn't distinguish between an unmatched open-group and an + unmatched close-group: both are REG_EPAREN. */ + if (ret == REG_ERPAREN) ret = REG_EPAREN; + + return (int) ret; +} + + +/* regexec searches for a given pattern, specified by PREG, in the + string STRING. + + If NMATCH is zero or REG_NOSUB was set in the cflags argument to + `regcomp', we ignore PMATCH. Otherwise, we assume PMATCH has at + least NMATCH elements, and we set them to the offsets of the + corresponding matched substrings. + + EFLAGS specifies `execution flags' which affect matching: if + REG_NOTBOL is set, then ^ does not match at the beginning of the + string; if REG_NOTEOL is set, then $ does not match at the end. + + We return 0 if we find a match and REG_NOMATCH if not. */ + +int +regexec (preg, string, nmatch, pmatch, eflags) + const regex_t *preg; + const char *string; + size_t nmatch; + regmatch_t pmatch[]; + int eflags; +{ + int ret; + struct re_registers regs; + regex_t private_preg; + int len = strlen (string); + boolean want_reg_info = !preg->no_sub && nmatch > 0; + + private_preg = *preg; + + private_preg.not_bol = !!(eflags & REG_NOTBOL); + private_preg.not_eol = !!(eflags & REG_NOTEOL); + + /* The user has told us exactly how many registers to return + information about, via `nmatch'. We have to pass that on to the + matching routines. */ + private_preg.regs_allocated = REGS_FIXED; + + if (want_reg_info) + { + regs.num_regs = nmatch; + regs.start = TALLOC (nmatch, regoff_t); + regs.end = TALLOC (nmatch, regoff_t); + if (regs.start == NULL || regs.end == NULL) + return (int) REG_NOMATCH; + } + + /* Perform the searching operation. */ + ret = re_search (&private_preg, string, len, + /* start: */ 0, /* range: */ len, + want_reg_info ? ®s : (struct re_registers *) 0); + + /* Copy the register information to the POSIX structure. */ + if (want_reg_info) + { + if (ret >= 0) + { + unsigned r; + + for (r = 0; r < nmatch; r++) + { + pmatch[r].rm_so = regs.start[r]; + pmatch[r].rm_eo = regs.end[r]; + } + } + + /* If we needed the temporary register info, free the space now. */ + free (regs.start); + free (regs.end); + } + + /* We want zero return to mean success, unlike `re_search'. */ + return ret >= 0 ? (int) REG_NOERROR : (int) REG_NOMATCH; +} + + +/* Returns a message corresponding to an error code, ERRCODE, returned + from either regcomp or regexec. We don't use PREG here. */ + +size_t +regerror (errcode, preg, errbuf, errbuf_size) + int errcode; + const regex_t *preg; + char *errbuf; + size_t errbuf_size; +{ + const char *msg; + size_t msg_size; + + if (errcode < 0 + || errcode >= (sizeof (re_error_msgid) / sizeof (re_error_msgid[0]))) + /* Only error codes returned by the rest of the code should be passed + to this routine. If we are given anything else, or if other regex + code generates an invalid error code, then the program has a bug. + Dump core so we can fix it. */ + abort (); + + msg = gettext (re_error_msgid[errcode]); + + msg_size = strlen (msg) + 1; /* Includes the null. */ + + if (errbuf_size != 0) + { + if (msg_size > errbuf_size) + { + strncpy (errbuf, msg, errbuf_size - 1); + errbuf[errbuf_size - 1] = 0; + } + else + strcpy (errbuf, msg); + } + + return msg_size; +} + + +/* Free dynamically allocated space used by PREG. */ + +void +regfree (preg) + regex_t *preg; +{ + if (preg->buffer != NULL) + free (preg->buffer); + preg->buffer = NULL; + + preg->allocated = 0; + preg->used = 0; + + if (preg->fastmap != NULL) + free (preg->fastmap); + preg->fastmap = NULL; + preg->fastmap_accurate = 0; + + if (preg->translate != NULL) + free (preg->translate); + preg->translate = NULL; +} + +#endif /* not emacs */ + +/* +Local variables: +make-backup-files: t +version-control: t +trim-versions-without-asking: nil +End: +*/ diff --git a/posix/regex.h b/posix/regex.h new file mode 100644 index 0000000000..42afd84881 --- /dev/null +++ b/posix/regex.h @@ -0,0 +1,495 @@ +/* Definitions for data structures and routines for the regular + expression library, version 0.12. + + Copyright (C) 1985, 89, 90, 91, 92, 93, 95 Free Software Foundation, Inc. + +This file is part of the GNU C Library. Its master source is NOT part of +the C library, however. The master source lives in /gd/gnu/lib. + +The GNU C Library is free software; you can redistribute it and/or +modify it under the terms of the GNU Library General Public License as +published by the Free Software Foundation; either version 2 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 +Library General Public License for more details. + +You should have received a copy of the GNU Library General Public +License along with the GNU C Library; see the file COPYING.LIB. If +not, write to the Free Software Foundation, Inc., 675 Mass Ave, +Cambridge, MA 02139, USA. */ + +#ifndef __REGEXP_LIBRARY_H__ +#define __REGEXP_LIBRARY_H__ + +/* POSIX says that <sys/types.h> must be included (by the caller) before + <regex.h>. */ + +#if !defined (_POSIX_C_SOURCE) && !defined (_POSIX_SOURCE) && defined (VMS) +/* VMS doesn't have `size_t' in <sys/types.h>, even though POSIX says it + should be there. */ +#include <stddef.h> +#endif + + +/* The following bits are used to determine the regexp syntax we + recognize. The set/not-set meanings are chosen so that Emacs syntax + remains the value 0. The bits are given in alphabetical order, and + the definitions shifted by one from the previous bit; thus, when we + add or remove a bit, only one other definition need change. */ +typedef unsigned reg_syntax_t; + +/* If this bit is not set, then \ inside a bracket expression is literal. + If set, then such a \ quotes the following character. */ +#define RE_BACKSLASH_ESCAPE_IN_LISTS (1) + +/* If this bit is not set, then + and ? are operators, and \+ and \? are + literals. + If set, then \+ and \? are operators and + and ? are literals. */ +#define RE_BK_PLUS_QM (RE_BACKSLASH_ESCAPE_IN_LISTS << 1) + +/* If this bit is set, then character classes are supported. They are: + [:alpha:], [:upper:], [:lower:], [:digit:], [:alnum:], [:xdigit:], + [:space:], [:print:], [:punct:], [:graph:], and [:cntrl:]. + If not set, then character classes are not supported. */ +#define RE_CHAR_CLASSES (RE_BK_PLUS_QM << 1) + +/* If this bit is set, then ^ and $ are always anchors (outside bracket + expressions, of course). + If this bit is not set, then it depends: + ^ is an anchor if it is at the beginning of a regular + expression or after an open-group or an alternation operator; + $ is an anchor if it is at the end of a regular expression, or + before a close-group or an alternation operator. + + This bit could be (re)combined with RE_CONTEXT_INDEP_OPS, because + POSIX draft 11.2 says that * etc. in leading positions is undefined. + We already implemented a previous draft which made those constructs + invalid, though, so we haven't changed the code back. */ +#define RE_CONTEXT_INDEP_ANCHORS (RE_CHAR_CLASSES << 1) + +/* If this bit is set, then special characters are always special + regardless of where they are in the pattern. + If this bit is not set, then special characters are special only in + some contexts; otherwise they are ordinary. Specifically, + * + ? and intervals are only special when not after the beginning, + open-group, or alternation operator. */ +#define RE_CONTEXT_INDEP_OPS (RE_CONTEXT_INDEP_ANCHORS << 1) + +/* If this bit is set, then *, +, ?, and { cannot be first in an re or + immediately after an alternation or begin-group operator. */ +#define RE_CONTEXT_INVALID_OPS (RE_CONTEXT_INDEP_OPS << 1) + +/* If this bit is set, then . matches newline. + If not set, then it doesn't. */ +#define RE_DOT_NEWLINE (RE_CONTEXT_INVALID_OPS << 1) + +/* If this bit is set, then . doesn't match NUL. + If not set, then it does. */ +#define RE_DOT_NOT_NULL (RE_DOT_NEWLINE << 1) + +/* If this bit is set, nonmatching lists [^...] do not match newline. + If not set, they do. */ +#define RE_HAT_LISTS_NOT_NEWLINE (RE_DOT_NOT_NULL << 1) + +/* If this bit is set, either \{...\} or {...} defines an + interval, depending on RE_NO_BK_BRACES. + If not set, \{, \}, {, and } are literals. */ +#define RE_INTERVALS (RE_HAT_LISTS_NOT_NEWLINE << 1) + +/* If this bit is set, +, ? and | aren't recognized as operators. + If not set, they are. */ +#define RE_LIMITED_OPS (RE_INTERVALS << 1) + +/* If this bit is set, newline is an alternation operator. + If not set, newline is literal. */ +#define RE_NEWLINE_ALT (RE_LIMITED_OPS << 1) + +/* If this bit is set, then `{...}' defines an interval, and \{ and \} + are literals. + If not set, then `\{...\}' defines an interval. */ +#define RE_NO_BK_BRACES (RE_NEWLINE_ALT << 1) + +/* If this bit is set, (...) defines a group, and \( and \) are literals. + If not set, \(...\) defines a group, and ( and ) are literals. */ +#define RE_NO_BK_PARENS (RE_NO_BK_BRACES << 1) + +/* If this bit is set, then \<digit> matches <digit>. + If not set, then \<digit> is a back-reference. */ +#define RE_NO_BK_REFS (RE_NO_BK_PARENS << 1) + +/* If this bit is set, then | is an alternation operator, and \| is literal. + If not set, then \| is an alternation operator, and | is literal. */ +#define RE_NO_BK_VBAR (RE_NO_BK_REFS << 1) + +/* If this bit is set, then an ending range point collating higher + than the starting range point, as in [z-a], is invalid. + If not set, then when ending range point collates higher than the + starting range point, the range is ignored. */ +#define RE_NO_EMPTY_RANGES (RE_NO_BK_VBAR << 1) + +/* If this bit is set, then an unmatched ) is ordinary. + If not set, then an unmatched ) is invalid. */ +#define RE_UNMATCHED_RIGHT_PAREN_ORD (RE_NO_EMPTY_RANGES << 1) + +/* If this bit is set, succeed as soon as we match the whole pattern, + without further backtracking. */ +#define RE_NO_POSIX_BACKTRACKING (RE_UNMATCHED_RIGHT_PAREN_ORD << 1) + +/* This global variable defines the particular regexp syntax to use (for + some interfaces). When a regexp is compiled, the syntax used is + stored in the pattern buffer, so changing this does not affect + already-compiled regexps. */ +extern reg_syntax_t re_syntax_options; + +/* Define combinations of the above bits for the standard possibilities. + (The [[[ comments delimit what gets put into the Texinfo file, so + don't delete them!) */ +/* [[[begin syntaxes]]] */ +#define RE_SYNTAX_EMACS 0 + +#define RE_SYNTAX_AWK \ + (RE_BACKSLASH_ESCAPE_IN_LISTS | RE_DOT_NOT_NULL \ + | RE_NO_BK_PARENS | RE_NO_BK_REFS \ + | RE_NO_BK_VBAR | RE_NO_EMPTY_RANGES \ + | RE_UNMATCHED_RIGHT_PAREN_ORD) + +#define RE_SYNTAX_POSIX_AWK \ + (RE_SYNTAX_POSIX_EXTENDED | RE_BACKSLASH_ESCAPE_IN_LISTS) + +#define RE_SYNTAX_GREP \ + (RE_BK_PLUS_QM | RE_CHAR_CLASSES \ + | RE_HAT_LISTS_NOT_NEWLINE | RE_INTERVALS \ + | RE_NEWLINE_ALT) + +#define RE_SYNTAX_EGREP \ + (RE_CHAR_CLASSES | RE_CONTEXT_INDEP_ANCHORS \ + | RE_CONTEXT_INDEP_OPS | RE_HAT_LISTS_NOT_NEWLINE \ + | RE_NEWLINE_ALT | RE_NO_BK_PARENS \ + | RE_NO_BK_VBAR) + +#define RE_SYNTAX_POSIX_EGREP \ + (RE_SYNTAX_EGREP | RE_INTERVALS | RE_NO_BK_BRACES) + +/* P1003.2/D11.2, section 4.20.7.1, lines 5078ff. */ +#define RE_SYNTAX_ED RE_SYNTAX_POSIX_BASIC + +#define RE_SYNTAX_SED RE_SYNTAX_POSIX_BASIC + +/* Syntax bits common to both basic and extended POSIX regex syntax. */ +#define _RE_SYNTAX_POSIX_COMMON \ + (RE_CHAR_CLASSES | RE_DOT_NEWLINE | RE_DOT_NOT_NULL \ + | RE_INTERVALS | RE_NO_EMPTY_RANGES) + +#define RE_SYNTAX_POSIX_BASIC \ + (_RE_SYNTAX_POSIX_COMMON | RE_BK_PLUS_QM) + +/* Differs from ..._POSIX_BASIC only in that RE_BK_PLUS_QM becomes + RE_LIMITED_OPS, i.e., \? \+ \| are not recognized. Actually, this + isn't minimal, since other operators, such as \`, aren't disabled. */ +#define RE_SYNTAX_POSIX_MINIMAL_BASIC \ + (_RE_SYNTAX_POSIX_COMMON | RE_LIMITED_OPS) + +#define RE_SYNTAX_POSIX_EXTENDED \ + (_RE_SYNTAX_POSIX_COMMON | RE_CONTEXT_INDEP_ANCHORS \ + | RE_CONTEXT_INDEP_OPS | RE_NO_BK_BRACES \ + | RE_NO_BK_PARENS | RE_NO_BK_VBAR \ + | RE_UNMATCHED_RIGHT_PAREN_ORD) + +/* Differs from ..._POSIX_EXTENDED in that RE_CONTEXT_INVALID_OPS + replaces RE_CONTEXT_INDEP_OPS and RE_NO_BK_REFS is added. */ +#define RE_SYNTAX_POSIX_MINIMAL_EXTENDED \ + (_RE_SYNTAX_POSIX_COMMON | RE_CONTEXT_INDEP_ANCHORS \ + | RE_CONTEXT_INVALID_OPS | RE_NO_BK_BRACES \ + | RE_NO_BK_PARENS | RE_NO_BK_REFS \ + | RE_NO_BK_VBAR | RE_UNMATCHED_RIGHT_PAREN_ORD) +/* [[[end syntaxes]]] */ + +/* Maximum number of duplicates an interval can allow. Some systems + (erroneously) define this in other header files, but we want our + value, so remove any previous define. */ +#ifdef RE_DUP_MAX +#undef RE_DUP_MAX +#endif +#define RE_DUP_MAX ((1 << 15) - 1) + + +/* POSIX `cflags' bits (i.e., information for `regcomp'). */ + +/* If this bit is set, then use extended regular expression syntax. + If not set, then use basic regular expression syntax. */ +#define REG_EXTENDED 1 + +/* If this bit is set, then ignore case when matching. + If not set, then case is significant. */ +#define REG_ICASE (REG_EXTENDED << 1) + +/* If this bit is set, then anchors do not match at newline + characters in the string. + If not set, then anchors do match at newlines. */ +#define REG_NEWLINE (REG_ICASE << 1) + +/* If this bit is set, then report only success or fail in regexec. + If not set, then returns differ between not matching and errors. */ +#define REG_NOSUB (REG_NEWLINE << 1) + + +/* POSIX `eflags' bits (i.e., information for regexec). */ + +/* If this bit is set, then the beginning-of-line operator doesn't match + the beginning of the string (presumably because it's not the + beginning of a line). + If not set, then the beginning-of-line operator does match the + beginning of the string. */ +#define REG_NOTBOL 1 + +/* Like REG_NOTBOL, except for the end-of-line. */ +#define REG_NOTEOL (1 << 1) + + +/* If any error codes are removed, changed, or added, update the + `re_error_msg' table in regex.c. */ +typedef enum +{ + REG_NOERROR = 0, /* Success. */ + REG_NOMATCH, /* Didn't find a match (for regexec). */ + + /* POSIX regcomp return error codes. (In the order listed in the + standard.) */ + REG_BADPAT, /* Invalid pattern. */ + REG_ECOLLATE, /* Not implemented. */ + REG_ECTYPE, /* Invalid character class name. */ + REG_EESCAPE, /* Trailing backslash. */ + REG_ESUBREG, /* Invalid back reference. */ + REG_EBRACK, /* Unmatched left bracket. */ + REG_EPAREN, /* Parenthesis imbalance. */ + REG_EBRACE, /* Unmatched \{. */ + REG_BADBR, /* Invalid contents of \{\}. */ + REG_ERANGE, /* Invalid range end. */ + REG_ESPACE, /* Ran out of memory. */ + REG_BADRPT, /* No preceding re for repetition op. */ + + /* Error codes we've added. */ + REG_EEND, /* Premature end. */ + REG_ESIZE, /* Compiled pattern bigger than 2^16 bytes. */ + REG_ERPAREN /* Unmatched ) or \); not returned from regcomp. */ +} reg_errcode_t; + +/* This data structure represents a compiled pattern. Before calling + the pattern compiler, the fields `buffer', `allocated', `fastmap', + `translate', and `no_sub' can be set. After the pattern has been + compiled, the `re_nsub' field is available. All other fields are + private to the regex routines. */ + +struct re_pattern_buffer +{ +/* [[[begin pattern_buffer]]] */ + /* Space that holds the compiled pattern. It is declared as + `unsigned char *' because its elements are + sometimes used as array indexes. */ + unsigned char *buffer; + + /* Number of bytes to which `buffer' points. */ + unsigned long allocated; + + /* Number of bytes actually used in `buffer'. */ + unsigned long used; + + /* Syntax setting with which the pattern was compiled. */ + reg_syntax_t syntax; + + /* Pointer to a fastmap, if any, otherwise zero. re_search uses + the fastmap, if there is one, to skip over impossible + starting points for matches. */ + char *fastmap; + + /* Either a translate table to apply to all characters before + comparing them, or zero for no translation. The translation + is applied to a pattern when it is compiled and to a string + when it is matched. */ + char *translate; + + /* Number of subexpressions found by the compiler. */ + size_t re_nsub; + + /* Zero if this pattern cannot match the empty string, one else. + Well, in truth it's used only in `re_search_2', to see + whether or not we should use the fastmap, so we don't set + this absolutely perfectly; see `re_compile_fastmap' (the + `duplicate' case). */ + unsigned can_be_null : 1; + + /* If REGS_UNALLOCATED, allocate space in the `regs' structure + for `max (RE_NREGS, re_nsub + 1)' groups. + If REGS_REALLOCATE, reallocate space if necessary. + If REGS_FIXED, use what's there. */ +#define REGS_UNALLOCATED 0 +#define REGS_REALLOCATE 1 +#define REGS_FIXED 2 + unsigned regs_allocated : 2; + + /* Set to zero when `regex_compile' compiles a pattern; set to one + by `re_compile_fastmap' if it updates the fastmap. */ + unsigned fastmap_accurate : 1; + + /* If set, `re_match_2' does not return information about + subexpressions. */ + unsigned no_sub : 1; + + /* If set, a beginning-of-line anchor doesn't match at the + beginning of the string. */ + unsigned not_bol : 1; + + /* Similarly for an end-of-line anchor. */ + unsigned not_eol : 1; + + /* If true, an anchor at a newline matches. */ + unsigned newline_anchor : 1; + +/* [[[end pattern_buffer]]] */ +}; + +typedef struct re_pattern_buffer regex_t; + +/* Type for byte offsets within the string. POSIX mandates this. */ +typedef int regoff_t; + + +/* This is the structure we store register match data in. See + regex.texinfo for a full description of what registers match. */ +struct re_registers +{ + unsigned num_regs; + regoff_t *start; + regoff_t *end; +}; + + +/* If `regs_allocated' is REGS_UNALLOCATED in the pattern buffer, + `re_match_2' returns information about at least this many registers + the first time a `regs' structure is passed. */ +#ifndef RE_NREGS +#define RE_NREGS 30 +#endif + + +/* POSIX specification for registers. Aside from the different names than + `re_registers', POSIX uses an array of structures, instead of a + structure of arrays. */ +typedef struct +{ + regoff_t rm_so; /* Byte offset from string's start to substring's start. */ + regoff_t rm_eo; /* Byte offset from string's start to substring's end. */ +} regmatch_t; + +/* Declarations for routines. */ + +/* To avoid duplicating every routine declaration -- once with a + prototype (if we are ANSI), and once without (if we aren't) -- we + use the following macro to declare argument types. This + unfortunately clutters up the declarations a bit, but I think it's + worth it. */ + +#if __STDC__ + +#define _RE_ARGS(args) args + +#else /* not __STDC__ */ + +#define _RE_ARGS(args) () + +#endif /* not __STDC__ */ + +/* Sets the current default syntax to SYNTAX, and return the old syntax. + You can also simply assign to the `re_syntax_options' variable. */ +extern reg_syntax_t re_set_syntax _RE_ARGS ((reg_syntax_t syntax)); + +/* Compile the regular expression PATTERN, with length LENGTH + and syntax given by the global `re_syntax_options', into the buffer + BUFFER. Return NULL if successful, and an error string if not. */ +extern const char *re_compile_pattern + _RE_ARGS ((const char *pattern, int length, + struct re_pattern_buffer *buffer)); + + +/* Compile a fastmap for the compiled pattern in BUFFER; used to + accelerate searches. Return 0 if successful and -2 if was an + internal error. */ +extern int re_compile_fastmap _RE_ARGS ((struct re_pattern_buffer *buffer)); + + +/* Search in the string STRING (with length LENGTH) for the pattern + compiled into BUFFER. Start searching at position START, for RANGE + characters. Return the starting position of the match, -1 for no + match, or -2 for an internal error. Also return register + information in REGS (if REGS and BUFFER->no_sub are nonzero). */ +extern int re_search + _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string, + int length, int start, int range, struct re_registers *regs)); + + +/* Like `re_search', but search in the concatenation of STRING1 and + STRING2. Also, stop searching at index START + STOP. */ +extern int re_search_2 + _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1, + int length1, const char *string2, int length2, + int start, int range, struct re_registers *regs, int stop)); + + +/* Like `re_search', but return how many characters in STRING the regexp + in BUFFER matched, starting at position START. */ +extern int re_match + _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string, + int length, int start, struct re_registers *regs)); + + +/* Relates to `re_match' as `re_search_2' relates to `re_search'. */ +extern int re_match_2 + _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1, + int length1, const char *string2, int length2, + int start, struct re_registers *regs, int stop)); + + +/* Set REGS to hold NUM_REGS registers, storing them in STARTS and + ENDS. Subsequent matches using BUFFER and REGS will use this memory + for recording register information. STARTS and ENDS must be + allocated with malloc, and must each be at least `NUM_REGS * sizeof + (regoff_t)' bytes long. + + If NUM_REGS == 0, then subsequent matches should allocate their own + register data. + + Unless this function is called, the first search or match using + PATTERN_BUFFER will allocate its own register data, without + freeing the old data. */ +extern void re_set_registers + _RE_ARGS ((struct re_pattern_buffer *buffer, struct re_registers *regs, + unsigned num_regs, regoff_t *starts, regoff_t *ends)); + +#ifdef _REGEX_RE_COMP +/* 4.2 bsd compatibility. */ +extern char *re_comp _RE_ARGS ((const char *)); +extern int re_exec _RE_ARGS ((const char *)); +#endif + +/* POSIX compatibility. */ +extern int regcomp _RE_ARGS ((regex_t *preg, const char *pattern, int cflags)); +extern int regexec + _RE_ARGS ((const regex_t *preg, const char *string, size_t nmatch, + regmatch_t pmatch[], int eflags)); +extern size_t regerror + _RE_ARGS ((int errcode, const regex_t *preg, char *errbuf, + size_t errbuf_size)); +extern void regfree _RE_ARGS ((regex_t *preg)); + +#endif /* not __REGEXP_LIBRARY_H__ */ + +/* +Local variables: +make-backup-files: t +version-control: t +trim-versions-without-asking: nil +End: +*/ diff --git a/regex.h b/regex.h new file mode 100644 index 0000000000..22bfc89e77 --- /dev/null +++ b/regex.h @@ -0,0 +1 @@ +#include <posix/regex.h> |