diff options
Diffstat (limited to 'locale/locfile-parse.c')
| -rw-r--r-- | locale/locfile-parse.c | 820 |
1 files changed, 820 insertions, 0 deletions
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: + */ |