diff options
| -rw-r--r-- | ChangeLog | 5 | ||||
| -rw-r--r-- | locale/programs/ld-collate.c | 2610 |
2 files changed, 393 insertions, 2222 deletions
diff --git a/ChangeLog b/ChangeLog index ad946bd90b..e08445df95 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,8 @@ +1999-12-12 Ulrich Drepper <drepper@cygnus.com> + + * locale/programs/ld-collate.c (collate_read): Make symbolic + ellipsis work. Remove old and unused code. + 1999-12-11 Ulrich Drepper <drepper@cygnus.com> * locale/programs/ld-collate.c (collate_read): Implement diff --git a/locale/programs/ld-collate.c b/locale/programs/ld-collate.c index e1c4d14f9e..42fd601064 100644 --- a/locale/programs/ld-collate.c +++ b/locale/programs/ld-collate.c @@ -21,8 +21,10 @@ # include <config.h> #endif +#include <errno.h> #include <error.h> #include <stdlib.h> +#include <wchar.h> #include "charmap.h" #include "localeinfo.h" @@ -67,6 +69,8 @@ struct element_list_t /* Data type for collating element. */ struct element_t { + const char *name; + const char *mbs; const uint32_t *wcs; int order; @@ -85,6 +89,11 @@ struct element_t struct element_t *next; }; +/* Special element value. */ +#define ELEMENT_ELLIPSIS2 ((struct element_t *) 1) +#define ELEMENT_ELLIPSIS3 ((struct element_t *) 2) +#define ELEMENT_ELLIPSIS4 ((struct element_t *) 3) + /* Data type for collating symbol. */ struct symbol_t { @@ -124,8 +133,8 @@ struct locale_collate_t /* This is the cursor for `reorder_after' insertions. */ struct element_t *cursor; - /* Remember whether last weight was an ellipsis. */ - int was_ellipsis; + /* This value is used when handling ellipsis. */ + struct element_t ellipsis_weight; /* Known collating elements. */ hash_table elem_table; @@ -168,14 +177,25 @@ make_seclist_elem (struct locale_collate_t *collate, const char *string, static struct element_t * new_element (struct locale_collate_t *collate, const char *mbs, - size_t len, const uint32_t *wcs) + const uint32_t *wcs, const char *name, size_t namelen) { struct element_t *newp; newp = (struct element_t *) obstack_alloc (&collate->mempool, sizeof (*newp)); - newp->mbs = obstack_copy0 (&collate->mempool, mbs, len); - newp->wcs = wcs; + newp->name = name == NULL ? NULL : obstack_copy (&collate->mempool, + name, namelen); + newp->mbs = mbs; + if (wcs != NULL) + { + size_t nwcs = wcslen ((wchar_t *) wcs) + 1; + uint32_t zero = 0; + obstack_grow (&collate->mempool, wcs, nwcs * sizeof (uint32_t)); + obstack_grow (&collate->mempool, &zero, sizeof (uint32_t)); + newp->wcs = (uint32_t *) obstack_finish (&collate->mempool); + } + else + newp->wcs = NULL; newp->order = 0; /* Will be allocated later. */ @@ -437,14 +457,14 @@ find_element (struct linereader *ldfile, struct locale_collate_t *collate, result = sym->order; if (result == NULL) - result = sym->order = new_element (collate, str, len, NULL); + result = sym->order = new_element (collate, NULL, NULL, NULL, 0); } else if (find_entry (&collate->elem_table, str, len, (void **) &result) != 0) { - /* It's also no collation element. So it is an element defined - later. */ - result = new_element (collate, str, len, wcstr); + /* It's also no collation element. So it is an character + element defined later. */ + result = new_element (collate, NULL, NULL, str, len); if (result != NULL) /* Insert it into the sequence table. */ insert_entry (&collate->seq_table, str, len, result); @@ -456,9 +476,20 @@ find_element (struct linereader *ldfile, struct locale_collate_t *collate, static void +unlink_element (struct locale_collate_t *collate) +{ + if (collate->cursor->next != NULL) + collate->cursor->next->last = collate->cursor->last; + if (collate->cursor->last != NULL) + collate->cursor->last->next = collate->cursor->next; + collate->cursor = collate->cursor->last; +} + + +static void insert_weights (struct linereader *ldfile, struct element_t *elem, struct charmap_t *charmap, struct repertoire_t *repertoire, - struct locale_collate_t *collate) + struct locale_collate_t *collate, enum token_t ellipsis) { int weight_cnt; struct token *arg; @@ -494,7 +525,7 @@ insert_weights (struct linereader *ldfile, struct element_t *elem, elem->weights[weight_cnt].w = (struct element_t **) obstack_alloc (&collate->mempool, sizeof (struct element_t *)); elem->weights[weight_cnt].w[0] = NULL; - elem->weights[weight_cnt].cnt = 0; + elem->weights[weight_cnt].cnt = 1; } else if (arg->tok == tok_bsymbol) { @@ -583,6 +614,24 @@ insert_weights (struct linereader *ldfile, struct element_t *elem, /* We don't need the string anymore. */ free (arg->val.str.startmb); } + else if (ellipsis != tok_none + && (arg->tok == tok_ellipsis2 + || arg->tok == tok_ellipsis3 + || arg->tok == tok_ellipsis4)) + { + /* It must be the same ellipsis as used in the initial column. */ + if (arg->tok != ellipsis) + lr_error (ldfile, _("\ +%s: weights must use the same ellipsis symbol as the name"), + "LC_COLLATE"); + + /* The weight for this level has to be ignored. We use the + null pointer to indicate this. */ + elem->weights[weight_cnt].w = (struct element_t **) + obstack_alloc (&collate->mempool, sizeof (struct element_t *)); + elem->weights[weight_cnt].w[0] = ELEMENT_ELLIPSIS2; + elem->weights[weight_cnt].cnt = 1; + } else { syntax: @@ -644,14 +693,20 @@ insert_value (struct linereader *ldfile, struct token *arg, uint32_t wc; struct element_t *elem = NULL; - /* First determine the wide character. There must be such a value, - otherwise we ignore it (if it is no collatio symbol or element). */ - wc = repertoire_find_value (repertoire, arg->val.str.startmb, - arg->val.str.lenmb); - /* Try to find the character in the charmap. */ seq = charmap_find_value (charmap, arg->val.str.startmb, arg->val.str.lenmb); + /* Determine the wide character. */ + if (seq == NULL || seq->ucs4 == UNINITIALIZED_CHAR_VALUE) + { + wc = repertoire_find_value (repertoire, arg->val.str.startmb, + arg->val.str.lenmb); + if (seq != NULL) + seq->ucs4 = wc; + } + else + wc = seq->ucs4; + if (wc == ILLEGAL_CHAR_VALUE && seq == NULL) { /* It's no character, so look through the collation elements and @@ -666,9 +721,7 @@ insert_value (struct linereader *ldfile, struct token *arg, elem = sym->order; if (elem == NULL) - elem = sym->order = new_element (collate, arg->val.str.startmb, - arg->val.str.lenmb, - arg->val.str.startwc); + elem = sym->order = new_element (collate, NULL, NULL, NULL, 0); } else if (find_entry (&collate->elem_table, arg->val.str.startmb, arg->val.str.lenmb, (void **) &elem) != 0) @@ -684,16 +737,17 @@ insert_value (struct linereader *ldfile, struct token *arg, if (find_entry (&collate->seq_table, arg->val.str.startmb, arg->val.str.lenmb, (void **) &elem) != 0) { + uint32_t wcs[2] = { wc, 0 }; + /* We have to allocate an entry. */ - elem = new_element (collate, arg->val.str.startmb, - arg->val.str.lenmb, - arg->val.str.startwc); + elem = new_element (collate, seq != NULL ? seq->bytes : NULL, + wcs, arg->val.str.startmb, arg->val.str.lenmb); /* And add it to the table. */ if (insert_entry (&collate->seq_table, arg->val.str.startmb, arg->val.str.lenmb, elem) != 0) /* This cannot happen. */ - abort (); + assert (! "Internal error"); } } @@ -708,7 +762,229 @@ insert_value (struct linereader *ldfile, struct token *arg, return; } - insert_weights (ldfile, elem, charmap, repertoire, collate); + insert_weights (ldfile, elem, charmap, repertoire, collate, tok_none); +} + + +static void +handle_ellipsis (struct linereader *ldfile, struct token *arg, + enum token_t ellipsis, struct charmap_t *charmap, + struct repertoire_t *repertoire, + struct locale_collate_t *collate) +{ + struct element_t *startp; + struct element_t *endp; + + /* Unlink the entry added for the ellipsis. */ + unlink_element (collate); + startp = collate->cursor; + + /* Process and add the end-entry. */ + if (arg != NULL) + insert_value (ldfile, arg, charmap, repertoire, collate); + + /* Reset the cursor. */ + collate->cursor = startp; + + /* Now we have to handle many different situations: + - we have to distinguish between the three different ellipsis forms + - the is the ellipsis at the beginning, in the middle, or at the end. + */ + endp = collate->cursor->next; + assert (arg == NULL || endp != NULL); + + /* Both, the start and the end symbol, must stand for characters. */ + if ((startp == NULL || startp->name == NULL) + || (endp == NULL || endp->name == NULL)) + { + lr_error (ldfile, _("\ +%s: the start end the end symbol of a range must stand for characters"), + "LC_COLLATE"); + return; + } + + if (ellipsis == tok_ellipsis3) + { + /* XXX */ + } + else + { + /* For symbolic range we naturally must have a beginning and an + end specified by the user. */ + if (startp == NULL) + lr_error (ldfile, _("\ +%s: symbolic range ellipsis must not directly follow `order_start'"), + "LC_COLLATE"); + else if (endp == NULL) + lr_error (ldfile, _("\ +%s: symbolic range ellipsis must not be direct followed by `order_end'"), + "LC_COLLATE"); + else + { + /* Determine the range. To do so we have to determine the + common prefix of the both names and then the numeric + values of both ends. */ + size_t lenfrom = strlen (startp->name); + size_t lento = strlen (endp->name); + char buf[lento + 1]; + int preflen = 0; + long int from; + long int to; + char *cp; + int base = ellipsis == tok_ellipsis2 ? 16 : 10; + + if (lenfrom != lento) + { + invalid_range: + lr_error (ldfile, _("\ +`%s' and `%.*s' are no valid names for symbolic range"), + startp->name, lento, endp->name); + return; + } + + while (startp->name[preflen] == endp->name[preflen]) + if (startp->name[preflen] == '\0') + /* Nothing to be done. The start and end point are identical + and while inserting the end point we have already given + the user an error message. */ + return; + else + ++preflen; + + errno = 0; + from = strtol (startp->name + preflen, &cp, base); + if ((from == UINT_MAX && errno == ERANGE) || *cp != '\0') + goto invalid_range; + + errno = 0; + to = strtol (endp->name + preflen, &cp, base); + if ((to == UINT_MAX && errno == ERANGE) || *cp != '\0') + goto invalid_range; + + /* Copy the prefix. */ + memcpy (buf, startp->name, preflen); + + /* Loop over all values. */ + for (++from; from < to; ++from) + { + struct element_t *elem = NULL; + struct charseq *seq; + uint32_t wc; + int cnt; + + /* Generate the the name. */ + sprintf (buf + preflen, base == 10 ? "%d" : "%x", from); + + /* Look whether this name is already defined. */ + if (find_entry (&collate->seq_table, arg->val.str.startmb, + arg->val.str.lenmb, (void **) &elem) == 0) + { + if (elem->next != NULL || (collate->cursor != NULL + && elem->next == collate->cursor)) + { + lr_error (ldfile, _("\ +%s: order for `%.*s' already defined at %s:%Z"), + "LC_COLLATE", lenfrom, buf, + elem->file, elem->line); + continue; + } + + if (elem->name == NULL) + { + lr_error (ldfile, _("%s: `%s' must be a charater"), + "LC_COLLATE", buf); + continue; + } + } + + if (elem == NULL || (elem->mbs == NULL && elem->wcs == NULL)) + { + /* Search for a character of this name. */ + seq = charmap_find_value (charmap, buf, lenfrom); + if (seq == NULL || seq->ucs4 == UNINITIALIZED_CHAR_VALUE) + { + wc = repertoire_find_value (repertoire, buf, lenfrom); + + if (seq != NULL) + seq->ucs4 = wc; + } + else + wc = seq->ucs4; + + if (wc == ILLEGAL_CHAR_VALUE && seq == NULL) + /* We don't know anything about a character with this + name. XXX Should we warn? */ + continue; + + if (elem == NULL) + { + uint32_t wcs[2] = { wc, 0 }; + + /* We have to allocate an entry. */ + elem = new_element (collate, + seq != NULL ? seq->bytes : NULL, + wc == ILLEGAL_CHAR_VALUE + ? NULL : wcs, + buf, lenfrom); + } + else + { + /* Update the element. */ + if (seq != NULL) + elem->mbs = obstack_copy0 (&collate->mempool, + seq->bytes, seq->nbytes); + + if (wc != ILLEGAL_CHAR_VALUE) + { + uint32_t zero = 0; + + obstack_grow (&collate->mempool, + &wc, sizeof (uint32_t)); + obstack_grow (&collate->mempool, + &zero, sizeof (uint32_t)); + elem->wcs = obstack_finish (&collate->mempool); + } + } + + elem->file = ldfile->fname; + elem->line = ldfile->lineno; + } + + /* Enqueue the new element. */ + elem->last = collate->cursor; + elem->next = collate->cursor->next; + elem->last->next = elem; + if (elem->next != NULL) + elem->next->last = elem; + collate->cursor = elem; + + /* Now add the weights. They come from the `ellipsis_weights' + member of `collate'. */ + elem->weights = (struct element_list_t *) + obstack_alloc (&collate->mempool, + nrules * sizeof (struct element_list_t)); + for (cnt = 0; cnt < nrules; ++cnt) + if (collate->ellipsis_weight.weights[cnt].cnt == 1 + && (collate->ellipsis_weight.weights[cnt].w[0] + == ELEMENT_ELLIPSIS2)) + { + elem->weights[cnt].w = (struct element_t **) + obstack_alloc (&collate->mempool, + sizeof (struct element_t *)); + elem->weights[cnt].w[0] = elem; + elem->weights[cnt].cnt = 1; + } + else + { + /* Simly use the weight from `ellipsis_weight'. */ + elem->weights[cnt].w = + collate->ellipsis_weight.weights[cnt].w; + elem->weights[cnt].cnt = + collate->ellipsis_weight.weights[cnt].cnt; + } + } + } + } } @@ -768,7 +1044,7 @@ collate_read (struct linereader *ldfile, struct localedef_t *result, struct token *arg = NULL; enum token_t nowtok; int state = 0; - int was_ellipsis = 0; + enum token_t was_ellipsis = tok_none; struct localedef_t *copy_locale = NULL; /* Get the repertoire we have to use. */ @@ -981,10 +1257,7 @@ collate_read (struct linereader *ldfile, struct localedef_t *result, if (insert_entry (&collate->elem_table, symbol, symbol_len, new_element (collate, - arg->val.str.startmb, - arg->val.str.lenmb, - arg->val.str.startwc)) - < 0) + NULL, NULL, NULL, 0)) < 0) lr_error (ldfile, _("\ error while adding collating element")); } @@ -1244,6 +1517,12 @@ error while adding equivalent collating symbol")); if (state != 1) goto err_label; + + /* Handle ellipsis at end of list. */ + if (was_ellipsis) + /* XXX */ + abort (); + state = 2; lr_ignore_rest (ldfile, 1); break; @@ -1257,7 +1536,18 @@ error while adding equivalent collating symbol")); break; } - if (state != 2 && state != 3) + if (state == 1) + { + lr_error (ldfile, _("%s: missing `order_end' keyword"), + "LC_COLLATE"); + state = 2; + + /* Handle ellipsis at end of list. */ + if (was_ellipsis) + /* XXX */ + abort (); + } + else if (state != 2 && state != 3) goto err_label; state = 3; @@ -1313,7 +1603,24 @@ error while adding equivalent collating symbol")); break; } - if (state != 2 && state != 4) + if (state == 1) + { + lr_error (ldfile, _("%s: missing `order_end' keyword"), + "LC_COLLATE"); + state = 2; + + /* Handle ellipsis at end of list. */ + if (was_ellipsis) + /* XXX */ + abort (); + } + else if (state == 3) + { + error (0, 0, _("%s: missing `reorder-end' keyword"), + "LC_COLLATE"); + state = 4; + } + else if (state != 2 && state != 4) goto err_label; state = 5; @@ -1490,6 +1797,23 @@ error while adding equivalent collating symbol")); read_directions (ldfile, arg, charmap, repertoire, collate); } + break; + } + else if (was_ellipsis != tok_none) + { + /* Using the information in the `ellipsis_weight' + element and this and the last value we have to handle + the ellipsis now. */ + assert (state == 1); + + handle_ellipsis (ldfile, arg, was_ellipsis, charmap, repertoire, + collate); + + /* Remember that we processed the ellipsis. */ + was_ellipsis = tok_none; + + /* And don't add the value a second time. */ + break; } /* Now insert in the new place. */ @@ -1508,37 +1832,48 @@ error while adding equivalent collating symbol")); if (state != 1) goto err_label; + if (was_ellipsis != tok_none) + { + lr_error (ldfile, + _("%s: cannot have `%s' as end of ellipsis range"), + "LC_COLLATE", "UNDEFINED"); + + unlink_element (collate); + was_ellipsis = tok_none; + } + /* See whether UNDEFINED already appeared somewhere. */ if (collate->undefined.next != NULL || (collate->cursor != NULL && collate->undefined.next == collate->cursor)) { - lr_error (ldfile, _("order for `%.*s' already defined at %s:%Z"), - 9, "UNDEFINED", collate->undefined.file, + lr_error (ldfile, + _("%s: order for `%.*s' already defined at %s:%Z"), + "LC_COLLATE", 9, "UNDEFINED", collate->undefined.file, collate->undefined.line); lr_ignore_rest (ldfile, 0); } else /* Parse the weights. */ insert_weights (ldfile, &collate->undefined, charmap, - repertoire, collate); + repertoire, collate, tok_none); break; + case tok_ellipsis2: case tok_ellipsis3: - /* Ignore the rest of the line if we don't need the input of - this line. */ - if (ignore_content) - { - lr_ignore_rest (ldfile, 0); - break; - } + case tok_ellipsis4: + /* This is the symbolic (decimal or hexadecimal) or absolute + ellipsis. */ + if (was_ellipsis != tok_none) + goto err_label; if (state != 1 && state != 3) goto err_label; - was_ellipsis = 1; - /* XXX Read the remainder of the line and remember what are - the weights. */ + was_ellipsis = nowtok; + + insert_weights (ldfile, &collate->ellipsis_weight, charmap, + repertoire, collate, nowtok); break; case tok_end: @@ -1552,8 +1887,15 @@ error while adding equivalent collating symbol")); _("%s: empty category description not allowed"), "LC_COLLATE"); else if (state == 1) - lr_error (ldfile, _("%s: missing `order_end' keyword"), - "LC_COLLATE"); + { + lr_error (ldfile, _("%s: missing `order_end' keyword"), + "LC_COLLATE"); + + /* Handle ellipsis at end of list. */ + if (was_ellipsis) + /* XXX */ + abort (); + } else if (state == 3) error (0, 0, _("%s: missing `reorder-end' keyword"), "LC_COLLATE"); @@ -1585,2179 +1927,3 @@ error while adding equivalent collating symbol")); /* When we come here we reached the end of the file. */ lr_error (ldfile, _("%s: premature end of file"), "LC_COLLATE"); } - - -#if 0 - -/* What kind of symbols get defined? */ -enum coll_symbol -{ - undefined, - ellipsis, - character, - element, - symbol -}; - - -typedef struct patch_t -{ - const char *fname; - size_t lineno; - const char *token; - union - { - unsigned int *pos; - size_t idx; - } where; - struct patch_t *next; -} patch_t; - - -typedef struct element_t -{ - const char *namemb; - const uint32_t *namewc; - unsigned int this_weight; - - struct element_t *next; - - unsigned int *ordering; - size_t ordering_len; -} element_t; - - -/* The real definition of the struct for the LC_COLLATE locale. */ -struct locale_collate_t -{ - /* Collate symbol table. Simple mapping to number. */ - hash_table symbols; - - /* The collation elements. */ - hash_table elements; - struct obstack element_mem; - - /* The result tables. */ - hash_table resultmb; - hash_table resultwc; - - /* Sorting rules given in order_start line. */ - uint32_t nrules; - enum coll_sort_rule *rules; - - /* Used while recognizing symbol composed of multiple tokens - (collating-element). */ - const char *combine_token; - size_t combine_token_len; - - /* How many sorting order specifications so far. */ - unsigned int order_cnt; - - /* Was lastline ellipsis? */ - int was_ellipsis; - /* Value of last entry if was character. */ - uint32_t last_char; - /* Current element. */ - element_t *current_element; - /* What kind of symbol is current element. */ - enum coll_symbol kind; - - /* Patch lists. */ - patch_t *current_patch; - patch_t *all_patches; - - /* Room for the UNDEFINED information. */ - element_t undefined; - unsigned int undefined_len; - - /* Script information. */ - const char **scripts; - unsigned int nscripts; -}; - - -/* Be verbose? Defined in localedef.c. */ -extern int verbose; - - - -#define obstack_chunk_alloc malloc -#define obstack_chunk_free free - - -/* Prototypes for local functions. */ -static void collate_startup (struct linereader *ldfile, - struct localedef_t *locale, - struct charmap_t *charmap, int ignore_content); - - -static void -collate_startup (struct linereader *ldfile, struct localedef_t *locale, - struct charmap_t *charset, int ignore_content) -{ - struct locale_collate_t *collate; - - /* Allocate the needed room. */ - locale->categories[LC_COLLATE].collate = collate = - (struct locale_collate_t *) xmalloc (sizeof (struct locale_collate_t)); - - /* Allocate hash table for collating elements. */ - if (init_hash (&collate->elements, 512)) - error (4, 0, _("memory exhausted")); - collate->combine_token = NULL; - obstack_init (&collate->element_mem); - - /* Allocate hash table for collating elements. */ - if (init_hash (&collate->symbols, 64)) - error (4, 0, _("memory exhausted")); - - /* Allocate hash table for result. */ - if (init_hash (&collate->result, 512)) - error (4, 0, _("memory exhausted")); - - collate->nrules = 0; - collate->nrules_max = 10; - collate->rules - = (enum coll_sort_rule *) xmalloc (collate->nrules_max - * sizeof (enum coll_sort_rule)); - - collate->order_cnt = 1; /* The smallest weight is 2. */ - - collate->was_ellipsis = 0; - collate->last_char = L'\0'; /* 0 because leading ellipsis is allowed. */ - - collate->all_patches = NULL; - - /* This tells us no UNDEFINED entry was found until now. */ - memset (&collate->undefined, '\0', sizeof (collate->undefined)); - - ldfile->translate_strings = 0; - ldfile->return_widestr = 0; -} - - -void -collate_finish (struct localedef_t *locale, struct charset_t *charset, - struct repertoire_t *repertoire) -{ - struct locale_collate_t *collate = locale->categories[LC_COLLATE].collate; - patch_t *patch; - size_t cnt; - - /* Patch the constructed table so that forward references are - correctly filled. */ - for (patch = collate->all_patches; patch != NULL; patch = patch->next) - { - uint32_t wch; - size_t toklen = strlen (patch->token); - void *ptmp; - unsigned int value = 0; - - wch = charset_find_value (&charset->char_table, patch->token, toklen); - if (wch != ILLEGAL_CHAR_VALUE) - { - element_t *runp; - - if (find_entry (&collate->result, &wch, sizeof (uint32_t), - (void *) &runp) < 0) - runp = NULL; - for (; runp != NULL; runp = runp->next) - if (runp->name[0] == wch && runp->name[1] == L'\0') - break; - - value = runp == NULL ? 0 : runp->this_weight; - } - else if (find_entry (&collate->elements, patch->token, toklen, &ptmp) - >= 0) - { - value = ((element_t *) ptmp)->this_weight; - } - else if (find_entry (&collate->symbols, patch->token, toklen, &ptmp) - >= 0) - { - value = (unsigned long int) ptmp; - } - else - value = 0; - - if (value == 0) - { - if (!be_quiet) - error_at_line (0, 0, patch->fname, patch->lineno, - _("no weight defined for symbol `%s'"), - patch->token); - } - else - *patch->where.pos = value; - } - - /* If no definition for UNDEFINED is given, all characters in the - given charset must be specified. */ - if (collate->undefined.ordering == NULL) - { - /**************************************************************\ - |* XXX We should test whether really an unspecified character *| - |* exists before giving the message. *| - \**************************************************************/ - uint32_t weight; - - if (!be_quiet) - error (0, 0, _("no definition of `UNDEFINED'")); - - collate->undefined.ordering_len = collate->nrules; - weight = ++collate->order_cnt; - - for (cnt = 0; cnt < collate->nrules; ++cnt) - { - uint32_t one = 1; - obstack_grow (&collate->element_mem, &one, sizeof (one)); - } - - for (cnt = 0; cnt < collate->nrules; ++cnt) - obstack_grow (&collate->element_mem, &weight, sizeof (weight)); - - collate->undefined.ordering = obstack_finish (&collate->element_mem); - } - - collate->undefined_len = 2; /* For the name: 1 x uint32_t + L'\0'. */ - for (cnt = 0; cnt < collate->nrules; ++cnt) - collate->undefined_len += 1 + collate->undefined.ordering[cnt]; -} - - - -void -collate_output (struct localedef_t *locale, struct charset_t *charset, - struct repertoire_t *repertoire, const char *output_path) -{ - struct locale_collate_t *collate = locale->categories[LC_COLLATE].collate; - uint32_t table_size, table_best, level_best, sum_best; - void *last; - element_t *pelem; - uint32_t *name; - size_t len; - const size_t nelems = _NL_ITEM_INDEX (_NL_NUM_LC_COLLATE); - struct iovec iov[2 + nelems]; - struct locale_file data; - uint32_t idx[nelems]; - struct obstack non_simple; - struct obstack string_pool; - size_t cnt, entry_size; - uint32_t undefined_offset = UINT_MAX; - uint32_t *table, *extra, *table2, *extra2; - size_t extra_len; - uint32_t element_hash_tab_size; - uint32_t *element_hash_tab; - uint32_t *element_hash_tab_ob; - uint32_t element_string_pool_size; - char *element_string_pool; - uint32_t element_value_size; - uint32_t *element_value; - uint32_t *element_value_ob; - uint32_t symbols_hash_tab_size; - uint32_t *symbols_hash_tab; - uint32_t *symbols_hash_tab_ob; - uint32_t symbols_string_pool_size; - char *symbols_string_pool; - uint32_t symbols_class_size; - uint32_t *symbols_class; - uint32_t *symbols_class_ob; - hash_table *hash_tab; - unsigned int dummy_weights[collate->nrules + 1]; - - sum_best = UINT_MAX; - table_best = 0xffff; - level_best = 0xffff; - - /* Compute table size. */ - if (!be_quiet) - fputs (_("\ -Computing table size for collation information might take a while..."), - stderr); - for (table_size = 256; table_size < sum_best; ++table_size) - { - size_t hits[table_size]; - unsigned int worst = 1; - size_t cnt; - - last = NULL; - - for (cnt = 0; cnt < 256; ++cnt) - hits[cnt] = 1; - memset (&hits[256], '\0', sizeof (hits) - 256 * sizeof (size_t)); - - while (iterate_table (&collate->result, &last, (const void **) &name, - &len, (void **) &pelem) >= 0) - if (pelem->ordering != NULL && pelem->name[0] > 0xff) - if (++hits[(unsigned int) pelem->name[0] % table_size] > worst) - { - worst = hits[(unsigned int) pelem->name[0] % table_size]; - if (table_size * worst > sum_best) - break; - } - - if (table_size * worst < sum_best) - { - sum_best = table_size * worst; - table_best = table_size; - level_best = worst; - } - } - assert (table_best != 0xffff || level_best != 0xffff); - if (!be_quiet) - fputs (_(" done\n"), stderr); - - obstack_init (&non_simple); - obstack_init (&string_pool); - - data.magic = LIMAGIC (LC_COLLATE); - data.n = nelems; - iov[0].iov_base = (void *) &data; - iov[0].iov_len = sizeof (data); - - iov[1].iov_base = (void *) idx; - iov[1].iov_len = sizeof (idx); - - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_NRULES)].iov_base = &collate->nrules; - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_NRULES)].iov_len = sizeof (uint32_t); - - table = (uint32_t *) alloca (collate->nrules * sizeof (uint32_t)); - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_RULES)].iov_base = table; - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_RULES)].iov_len - = collate->nrules * sizeof (uint32_t); - /* Another trick here. Describing the collation method needs only a - few bits (3, to be exact). But the binary file should be - accessible by machines with both endianesses and so we store both - forms in the same word. */ - for (cnt = 0; cnt < collate->nrules; ++cnt) - table[cnt] = collate->rules[cnt] | bswap_32 (collate->rules[cnt]); - - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_HASH_SIZE)].iov_base = &table_best; - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_HASH_SIZE)].iov_len = sizeof (uint32_t); - - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_HASH_LAYERS)].iov_base = &level_best; - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_HASH_LAYERS)].iov_len - = sizeof (uint32_t); - - entry_size = 1 + MAX (collate->nrules, 2); - - table = (uint32_t *) alloca (table_best * level_best * entry_size - * sizeof (table[0])); - memset (table, '\0', table_best * level_best * entry_size - * sizeof (table[0])); - - - /* Macros for inserting in output table. */ -#define ADD_VALUE(expr) \ - do { \ - uint32_t to_write = (uint32_t) expr; \ - obstack_grow (&non_simple, &to_write, sizeof (to_write)); \ - } while (0) - -#define ADD_ELEMENT(pelem, len) \ - do { \ - size_t cnt, idx; \ - \ - ADD_VALUE (len); \ - \ - wlen = wcslen (pelem->name); \ - obstack_grow (&non_simple, pelem->name, (wlen + 1) * sizeof (uint32_t)); \ - \ - idx = collate->nrules; \ - for (cnt = 0; cnt < collate->nrules; ++cnt) \ - { \ - size_t disp; \ - \ - ADD_VALUE (pelem->ordering[cnt]); \ - for (disp = 0; disp < pelem->ordering[cnt]; ++disp) \ - ADD_VALUE (pelem->ordering[idx++]); \ - } \ - } while (0) - -#define ADD_FORWARD(pelem) \ - do { \ - /* We leave a reference in the main table and put all \ - information in the table for the extended entries. */ \ - element_t *runp; \ - element_t *has_simple = NULL; \ - size_t wlen; \ - \ - table[(level * table_best + slot) * entry_size + 1] \ - = FORWARD_CHAR; \ - table[(level * table_best + slot) * entry_size + 2] \ - = obstack_object_size (&non_simple) / sizeof (uint32_t); \ - \ - /* Here we have to construct the non-simple table entry. First \ - compute the total length of this entry. */ \ - for (runp = (pelem); runp != NULL; runp = runp->next) \ - if (runp->ordering != NULL) \ - { \ - uint32_t value; \ - size_t cnt; \ - \ - value = 1 + wcslen (runp->name) + 1; \ - \ - for (cnt = 0; cnt < collate->nrules; ++cnt) \ - /* We have to take care for entries without ordering \ - information. While reading them they get inserted in the \ - table and later not removed when something goes wrong with \ - reading its weights. */ \ - value += 1 + runp->ordering[cnt]; \ - \ - if (runp->name[1] == L'\0') \ - has_simple = runp; \ - \ - ADD_ELEMENT (runp, value); \ - } \ - \ - if (has_simple == NULL) \ - { \ - size_t idx, cnt; \ - \ - ADD_VALUE (collate->undefined_len + 1); \ - \ - /* Add the name. */ \ - ADD_VALUE ((pelem)->name[0]); \ - ADD_VALUE (0); \ - \ - idx = collate->nrules; \ - for (cnt = 0; cnt < collate->nrules; ++cnt) \ - { \ - size_t disp; \ - \ - ADD_VALUE (collate->undefined.ordering[cnt]); \ - for (disp = 0; disp < collate->undefined.ordering[cnt]; ++disp) \ - { \ - if ((uint32_t) collate->undefined.ordering[idx] \ - == ELLIPSIS_CHAR) \ - ADD_VALUE ((pelem)->name[0]); \ - else \ - ADD_VALUE (collate->undefined.ordering[idx++]); \ - ++idx; \ - } \ - } \ - } \ - } while (0) - - - - /* Fill the table now. First we look for all the characters which - fit into one single byte. This speeds up the 8-bit string - functions. */ - last = NULL; - while (iterate_table (&collate->result, &last, (const void **) &name, - &len, (void **) &pelem) >= 0) - if (pelem->name[0] <= 0xff) - { - /* We have a single byte name. Now we must distinguish - between entries in simple form (i.e., only one value per - weight and no collation element starting with the same - character) and those which are not. */ - size_t slot = ((size_t) pelem->name[0]); - const size_t level = 0; - - table[slot * entry_size] = pelem->name[0]; - - if (pelem->name[1] == L'\0' && pelem->next == NULL - && pelem->ordering_len == collate->nrules) - { - /* Yes, we have a simple one. Lucky us. */ - size_t cnt; - - for (cnt = 0; cnt < collate->nrules; ++cnt) - table[slot * entry_size + 1 + cnt] - = pelem->ordering[collate->nrules + cnt]; - } - else - ADD_FORWARD (pelem); - } - - /* Now check for missing single byte entries. If one exist we fill - with the UNDEFINED entry. */ - for (cnt = 0; cnt < 256; ++cnt) - /* The first weight is never 0 for existing entries. */ - if (table[cnt * entry_size + 1] == 0) - { - /* We have to fill in the information from the UNDEFINED - entry. */ - table[cnt * entry_size] = (uint32_t) cnt; - - if (collate->undefined.ordering_len == collate->nrules) - { - size_t inner; - - for (inner = 0; inner < collate->nrules; ++inner) - if ((uint32_t)collate->undefined.ordering[collate->nrules - + inner] - == ELLIPSIS_CHAR) - table[cnt * entry_size + 1 + inner] = cnt; - else - table[cnt * entry_size + 1 + inner] - = collate->undefined.ordering[collate->nrules + inner]; - } - else - { - if (undefined_offset != UINT_MAX) - { - table[cnt * entry_size + 1] = FORWARD_CHAR; - table[cnt * entry_size + 2] = undefined_offset; - } - else - { - const size_t slot = cnt; - const size_t level = 0; - - ADD_FORWARD (&collate->undefined); - undefined_offset = table[cnt * entry_size + 2]; - } - } - } - - /* Now we are ready for inserting the whole rest. */ - last = NULL; - while (iterate_table (&collate->result, &last, (const void **) &name, - &len, (void **) &pelem) >= 0) - if (pelem->name[0] > 0xff) - { - /* Find the position. */ - size_t slot = ((size_t) pelem->name[0]) % table_best; - size_t level = 0; - - while (table[(level * table_best + slot) * entry_size + 1] != 0) - ++level; - assert (level < level_best); - - if (pelem->name[1] == L'\0' && pelem->next == NULL - && pelem->ordering_len == collate->nrules) - { - /* Again a simple entry. */ - size_t inner; - - for (inner = 0; inner < collate->nrules; ++inner) - table[(level * table_best + slot) * entry_size + 1 + inner] - = pelem->ordering[collate->nrules + inner]; - } - else - ADD_FORWARD (pelem); - } - - /* Add the UNDEFINED entry. */ - { - /* Here we have to construct the non-simple table entry. */ - size_t idx, cnt; - - undefined_offset = obstack_object_size (&non_simple); - - idx = collate->nrules; - for (cnt = 0; cnt < collate->nrules; ++cnt) - { - size_t disp; - - ADD_VALUE (collate->undefined.ordering[cnt]); - for (disp = 0; disp < collate->undefined.ordering[cnt]; ++disp) - ADD_VALUE (collate->undefined.ordering[idx++]); - } - } - - /* Finish the extra block. */ - extra_len = obstack_object_size (&non_simple); - extra = (uint32_t *) obstack_finish (&non_simple); - assert ((extra_len % sizeof (uint32_t)) == 0); - - /* Now we have to build the two array for the other byte ordering. */ - table2 = (uint32_t *) alloca (table_best * level_best * entry_size - * sizeof (table[0])); - extra2 = (uint32_t *) alloca (extra_len); - - for (cnt = 0; cnt < table_best * level_best * entry_size; ++cnt) - table2[cnt] = bswap_32 (table[cnt]); - - for (cnt = 0; cnt < extra_len / sizeof (uint32_t); ++cnt) - extra2[cnt] = bswap_32 (extra2[cnt]); - - /* We need a simple hashing table to get a collation-element->chars - mapping. We again use internal hashing using a secondary hashing - function. - - Each string has an associate hashing value V, computed by a - fixed function. To locate the string we use open addressing with - double hashing. The first index will be V % M, where M is the - size of the hashing table. If no entry is found, iterating with - a second, independent hashing function takes place. This second - value will be 1 + V % (M - 2). The approximate number of probes - will be - - for unsuccessful search: (1 - N / M) ^ -1 - for successful search: - (N / M) ^ -1 * ln (1 - N / M) - - where N is the number of keys. - - If we now choose M to be the next prime bigger than 4 / 3 * N, - we get the values 4 and 1.85 resp. Because unsuccessful searches - are unlikely this is a good value. Formulas: [Knuth, The Art of - Computer Programming, Volume 3, Sorting and Searching, 1973, - Addison Wesley] */ - if (collate->elements.filled == 0) - { - /* We don't need any element table since there are no collating - elements. */ - element_hash_tab_size = 0; - element_hash_tab = NULL; - element_hash_tab_ob = NULL; - element_string_pool_size = 0; - element_string_pool = NULL; - element_value_size = 0; - element_value = NULL; - element_value_ob = NULL; - } - else - { - void *ptr; /* Running pointer. */ - const char *key; /* Key for current bucket. */ - size_t keylen; /* Length of key data. */ - const element_t *data; /* Data, i.e., the character sequence. */ - - element_hash_tab_size = next_prime ((collate->elements.filled * 4) / 3); - if (element_hash_tab_size < 7) - /* We need a minimum to make the following code work. */ - element_hash_tab_size = 7; - - element_hash_tab = obstack_alloc (&non_simple, (2 * element_hash_tab_size - * sizeof (uint32_t))); - memset (element_hash_tab, '\377', (2 * element_hash_tab_size - * sizeof (uint32_t))); - - ptr = NULL; - while (iterate_table (&collate->elements, &ptr, (const void **) &key, - &keylen, (void **) &data) == 0) - { - size_t hash_val = hash_string (key, keylen); - size_t idx = hash_val % element_hash_tab_size; - - if (element_hash_tab[2 * idx] != (~((uint32_t) 0))) - { - /* We need the second hashing function. */ - size_t c = 1 + (hash_val % (element_hash_tab_size - 2)); - - do - if (idx >= element_hash_tab_size - c) - idx -= element_hash_tab_size - c; - else - idx += c; - while (element_hash_tab[2 * idx] != (~((uint32_t) 0))); - } - - element_hash_tab[2 * idx] = obstack_object_size (&non_simple); - element_hash_tab[2 * idx + 1] = (obstack_object_size (&string_pool) - / sizeof (uint32_t)); - - obstack_grow0 (&non_simple, key, keylen); - obstack_grow (&string_pool, data->name, - (wcslen (data->name) + 1) * sizeof (uint32_t)); - } - - if (obstack_object_size (&non_simple) % 4 != 0) - obstack_blank (&non_simple, - 4 - (obstack_object_size (&non_simple) % 4)); - element_string_pool_size = obstack_object_size (&non_simple); - element_string_pool = obstack_finish (&non_simple); - - element_value_size = obstack_object_size (&string_pool); - element_value = obstack_finish (&string_pool); - - /* Create the tables for the other byte order. */ - element_hash_tab_ob = obstack_alloc (&non_simple, - (2 * element_hash_tab_size - * sizeof (uint32_t))); - for (cnt = 0; cnt < 2 * element_hash_tab_size; ++cnt) - element_hash_tab_ob[cnt] = bswap_U32 (element_hash_tab[cnt]); - - element_value_ob = obstack_alloc (&string_pool, element_value_size); - for (cnt = 0; cnt < element_value_size / 4; ++cnt) - element_value_ob[cnt] = bswap_32 (element_value[cnt]); - } - - /* Store collation elements as map to collation class. There are - three kinds of symbols: - - simple characters - - collation elements - - collation symbols - We need to make a table which lets the user to access the primary - weight based on the symbol string. */ - symbols_hash_tab_size = next_prime ((4 * (charset->char_table.filled - + collate->elements.filled - + collate->symbols.filled)) / 3); - symbols_hash_tab = obstack_alloc (&non_simple, (2 * symbols_hash_tab_size - * sizeof (uint32_t))); - memset (symbols_hash_tab, '\377', (2 * symbols_hash_tab_size - * sizeof (uint32_t))); - - /* Now fill the array. First the symbols from the character set, - then the collation elements and last the collation symbols. */ - hash_tab = &charset->char_table; - while (1) - { - void *ptr; /* Running pointer. */ - const char *key; /* Key for current bucket. */ - size_t keylen; /* Length of key data. */ - void *data; /* Data. */ - - ptr = NULL; - while (iterate_table (hash_tab, &ptr, (const void **) &key, - &keylen, (void **) &data) == 0) - { - size_t hash_val; - size_t idx; - uint32_t word; - unsigned int *weights; - - if (hash_tab == &charset->char_table - || hash_tab == &collate->elements) - { - element_t *lastp, *firstp; - uint32_t dummy_name[2]; - const uint32_t *name; - size_t name_len; - - if (hash_tab == &charset->char_table) - { - dummy_name[0] = (uint32_t) ((unsigned long int) data); - dummy_name[1] = L'\0'; - name = dummy_name; - name_len = sizeof (uint32_t); - } - else - { - element_t *elemp = (element_t *) data; - name = elemp->name; - name_len = wcslen (name) * sizeof (uint32_t); - } - - /* First check whether this character is used at all. */ - if (find_entry (&collate->result, name, name_len, - (void *) &firstp) < 0) - /* The symbol is not directly mentioned in the collation. - I.e., we use the value for UNDEFINED. */ - lastp = &collate->undefined; - else - { - /* The entry for the simple character is always found at - the end. */ - lastp = firstp; - while (lastp->next != NULL && wcscmp (name, lastp->name)) - lastp = lastp->next; - } - - weights = lastp->ordering; - } - else - { - dummy_weights[0] = 1; - dummy_weights[collate->nrules] - = (unsigned int) ((unsigned long int) data); - - weights = dummy_weights; - } - - /* In LASTP->ordering we now have the collation class. - Determine the place in the hashing table next. */ - hash_val = hash_string (key, keylen); - idx = hash_val % symbols_hash_tab_size; - - if (symbols_hash_tab[2 * idx] != (~((uint32_t) 0))) - { - /* We need the second hashing function. */ - size_t c = 1 + (hash_val % (symbols_hash_tab_size - 2)); - - do - if (idx >= symbols_hash_tab_size - c) - idx -= symbols_hash_tab_size - c; - else - idx += c; - while (symbols_hash_tab[2 * idx] != (~((uint32_t) 0))); - } - - symbols_hash_tab[2 * idx] = obstack_object_size (&string_pool); - symbols_hash_tab[2 * idx + 1] = (obstack_object_size (&non_simple) - / sizeof (uint32_t)); - - obstack_grow0 (&string_pool, key, keylen); - /* Adding the first weight looks complicated. We have to deal - with the kind it is stored and with the fact that original - form uses `unsigned int's while we need `uint32_t' here. */ - word = weights[0]; - obstack_grow (&non_simple, &word, sizeof (uint32_t)); - for (cnt = 0; cnt < weights[0]; ++cnt) - { - word = weights[collate->nrules + cnt]; - obstack_grow (&non_simple, &word, sizeof (uint32_t)); - } - } - - if (hash_tab == &charset->char_table) - hash_tab = &collate->elements; - else if (hash_tab == &collate->elements) - hash_tab = &collate->symbols; - else - break; - } - - /* Now we have the complete tables. */ - if (obstack_object_size (&string_pool) % 4 != 0) - obstack_blank (&non_simple, 4 - (obstack_object_size (&string_pool) % 4)); - symbols_string_pool_size = obstack_object_size (&string_pool); - symbols_string_pool = obstack_finish (&string_pool); - - symbols_class_size = obstack_object_size (&non_simple); - symbols_class = obstack_finish (&non_simple); - - /* Generate tables with other byte order. */ - symbols_hash_tab_ob = obstack_alloc (&non_simple, (2 * symbols_hash_tab_size - * sizeof (uint32_t))); - for (cnt = 0; cnt < 2 * symbols_hash_tab_size; ++cnt) - symbols_hash_tab_ob[cnt] = bswap_32 (symbols_hash_tab[cnt]); - - symbols_class_ob = obstack_alloc (&non_simple, symbols_class_size); - for (cnt = 0; cnt < symbols_class_size / 4; ++cnt) - symbols_class_ob[cnt] = bswap_32 (symbols_class[cnt]); - - - /* Store table addresses and lengths. */ -#if __BYTE_ORDER == __BIG_ENDIAN - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_TABLE_EB)].iov_base = table; - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_TABLE_EB)].iov_len - = table_best * level_best * entry_size * sizeof (table[0]); - - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_TABLE_EL)].iov_base = table2; - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_TABLE_EL)].iov_len - = table_best * level_best * entry_size * sizeof (table[0]); - - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_EXTRA_EB)].iov_base = extra; - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_EXTRA_EB)].iov_len = extra_len; - - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_EXTRA_EL)].iov_base = extra2; - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_EXTRA_EL)].iov_len = extra_len; -#else - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_TABLE_EB)].iov_base = table2; - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_TABLE_EB)].iov_len - = table_best * level_best * entry_size * sizeof (table[0]); - - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_TABLE_EL)].iov_base = table; - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_TABLE_EL)].iov_len - = table_best * level_best * entry_size * sizeof (table[0]); - - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_EXTRA_EB)].iov_base = extra2; - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_EXTRA_EB)].iov_len = extra_len; - - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_EXTRA_EL)].iov_base = extra; - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_EXTRA_EL)].iov_len = extra_len; -#endif - - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_UNDEFINED)].iov_base = &undefined_offset; - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_UNDEFINED)].iov_len = sizeof (uint32_t); - - - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_HASH_SIZE)].iov_base - = &element_hash_tab_size; - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_HASH_SIZE)].iov_len - = sizeof (uint32_t); - -#if __BYTE_ORDER == __BIG_ENDIAN - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_HASH_EB)].iov_base - = element_hash_tab; - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_HASH_EB)].iov_len - = 2 * element_hash_tab_size * sizeof (uint32_t); - - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_HASH_EL)].iov_base - = element_hash_tab_ob; - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_HASH_EL)].iov_len - = 2 * element_hash_tab_size * sizeof (uint32_t); -#else - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_HASH_EL)].iov_base - = element_hash_tab; - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_HASH_EL)].iov_len - = 2 * element_hash_tab_size * sizeof (uint32_t); - - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_HASH_EB)].iov_base - = element_hash_tab_ob; - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_HASH_EB)].iov_len - = 2 * element_hash_tab_size * sizeof (uint32_t); -#endif - - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_STR_POOL)].iov_base - = element_string_pool; - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_STR_POOL)].iov_len - = element_string_pool_size; - -#if __BYTE_ORDER == __BIG_ENDIAN - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_VAL_EB)].iov_base - = element_value; - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_VAL_EB)].iov_len - = element_value_size; - - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_VAL_EL)].iov_base - = element_value_ob; - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_VAL_EL)].iov_len - = element_value_size; -#else - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_VAL_EL)].iov_base - = element_value; - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_VAL_EL)].iov_len - = element_value_size; - - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_VAL_EB)].iov_base - = element_value_ob; - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_VAL_EB)].iov_len - = element_value_size; -#endif - - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_HASH_SIZE)].iov_base - = &symbols_hash_tab_size; - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_HASH_SIZE)].iov_len - = sizeof (uint32_t); - -#if __BYTE_ORDER == __BIG_ENDIAN - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_HASH_EB)].iov_base - = symbols_hash_tab; - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_HASH_EB)].iov_len - = 2 * symbols_hash_tab_size * sizeof (uint32_t); - - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_HASH_EL)].iov_base - = symbols_hash_tab_ob; - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_HASH_EL)].iov_len - = 2 * symbols_hash_tab_size * sizeof (uint32_t); -#else - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_HASH_EL)].iov_base - = symbols_hash_tab; - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_HASH_EL)].iov_len - = 2 * symbols_hash_tab_size * sizeof (uint32_t); - - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_HASH_EB)].iov_base - = symbols_hash_tab_ob; - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_HASH_EB)].iov_len - = 2 * symbols_hash_tab_size * sizeof (uint32_t); -#endif - - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_STR_POOL)].iov_base - = symbols_string_pool; - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_STR_POOL)].iov_len - = symbols_string_pool_size; - -#if __BYTE_ORDER == __BIG_ENDIAN - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_CLASS_EB)].iov_base - = symbols_class; - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_CLASS_EB)].iov_len - = symbols_class_size; - - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_CLASS_EL)].iov_base - = symbols_class_ob; - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_CLASS_EL)].iov_len - = symbols_class_size; -#else - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_CLASS_EL)].iov_base - = symbols_class; - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_CLASS_EL)].iov_len - = symbols_class_size; - - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_CLASS_EB)].iov_base - = symbols_class_ob; - iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_CLASS_EB)].iov_len - = symbols_class_size; -#endif - - /* Update idx array. */ - idx[0] = iov[0].iov_len + iov[1].iov_len; - for (cnt = 1; cnt < nelems; ++cnt) - idx[cnt] = idx[cnt - 1] + iov[1 + cnt].iov_len; - - write_locale_data (output_path, "LC_COLLATE", 2 + nelems, iov); - - obstack_free (&non_simple, NULL); - obstack_free (&string_pool, NULL); -} - - -static int -collate_element_to (struct linereader *ldfile, - struct locale_collate_t *collate, - struct token *code, struct charmap_t *charmap, - struct repertoire_t *repertoire) -{ - struct charseq *seq; - uint32_t value; - void *not_used; - - seq = charmap_find_value (charmap, code->val.str.start, code->val.str.len); - if (seq != NULL) - { - lr_error (ldfile, _("symbol for multicharacter collating element " - "`%.*s' duplicates symbolic name in charmap"), - (int) code->val.str.len, code->val.str.start); - return 1; - } - - value = repertoire_find_value (repertoire, code->val.str.start, - code->val.str.len); - if (value != ILLEGAL_CHAR_VALUE) - { - lr_error (ldfile, _("symbol for multicharacter collating element " - "`%.*s' duplicates symbolic name in repertoire"), - (int) code->val.str.len, code->val.str.start); - return 1; - } - - if (find_entry (&collate->elements, code->val.str.start, code->val.str.len, - ¬_used) >= 0) - { - lr_error (ldfile, _("symbol for multicharacter collating element " - "`%.*s' duplicates other element definition"), - (int) code->val.str.len, code->val.str.start); - return 1; - } - - if (find_entry (&collate->elements, code->val.str.start, code->val.str.len, - ¬_used) >= 0) - { - lr_error (ldfile, _("symbol for multicharacter collating element " - "`%.*s' duplicates symbol definition"), - (int) code->val.str.len, code->val.str.start); - return 1; - } - - return 0; -} - - -static void -collate_element_from (struct linereader *ldfile, - struct locale_collate_t *collate, - const char *to_str, struct token *code, - struct charmap_t *charmap, - struct repertoire_t *repertoire) -{ - element_t *elemp, *runp; - - /* CODE is a string. */ - elemp = (element_t *) obstack_alloc (&collate->element_mem, - sizeof (element_t)); - - /* We have to translate the string. It may contain <...> character - names. */ - elemp->namemb = code->val.str.startmb; - elemp->namewc = code->val.str.startwc; - elemp->this_weight = 0; - elemp->ordering = NULL; - elemp->ordering_len = 0; - - if (elemp->namemb == NULL && elemp->namewc == NULL) - { - /* The string contains characters which are not in the charmap nor - in the repertoire. Ignore the string. */ - if (verbose) - lr_error (ldfile, _("\ -`from' string in collation element declaration contains unknown character")); - return; - } - - /* The entries in the linked lists of RESULT are sorting in - descending order. The order is important for the `strcoll' and - `wcscoll' functions. */ - if (find_entry (&collate->resultwc, elemp->namewc, sizeof (uint32_t), - (void *) &runp) >= 0) - { - /* We already have an entry with this key. Check whether it is - identical. */ - element_t *prevp = NULL; - int cmpres; - - do - { - cmpres = wcscmp (elemp->namewc, runp->namewc); - if (cmpres <= 0) - break; - prevp = runp; - } - while ((runp = runp->next) != NULL); - - if (cmpres == 0) - lr_error (ldfile, _("\ -duplicate collating element definition (repertoire)")); - else - { - elemp->next = runp; - if (prevp == NULL) - { - if (set_entry (&collate->resultwc, elemp->namewc, - sizeof (uint32_t), elemp) < 0) - error (EXIT_FAILURE, 0, _("\ -error while inserting collation element into hash table")); - } - else - prevp->next = elemp; - } - } - else - { - elemp->next = NULL; - if (insert_entry (&collate->resultwc, elemp->namewc, sizeof (uint32_t), - elemp) < 0) - error (EXIT_FAILURE, errno, _("error while inserting to hash table")); - } - - /* Now also insert the element definition in the multibyte table. */ - if (find_entry (&collate->resultmb, elemp->namemb, 1, (void *) &runp) >= 0) - { - /* We already have an entry with this key. Check whether it is - identical. */ - element_t *prevp = NULL; - int cmpres; - - do - { - cmpres = strcmp (elemp->namemb, runp->namemb); - if (cmpres <= 0) - break; - prevp = runp; - } - while ((runp = runp->next) != NULL); - - if (cmpres == 0) - lr_error (ldfile, _("\ -duplicate collating element definition (charmap)")); - else - { - elemp->next = runp; - if (prevp == NULL) - { - if (set_entry (&collate->resultmb, elemp->namemb, 1, elemp) < 0) - error (EXIT_FAILURE, 0, _("\ -error while inserting collation element into hash table")); - } - else - prevp->next = elemp; - } - } - else - { - elemp->next = NULL; - if (insert_entry (&collate->resultmb, elemp->namemb, 1, elemp) < 0) - error (EXIT_FAILURE, errno, _("error while inserting to hash table")); - } - - /* Finally install the mapping from the `to'-name to the `from'-name. */ - if (insert_entry (&collate->elements, to_str, strlen (to_str), - (void *) elemp) < 0) - lr_error (ldfile, _("cannot insert new collating symbol definition: %s"), - strerror (errno)); -} - - -static void -collate_symbol (struct linereader *ldfile, struct locale_collate_t *collate, - struct token *code, struct charmap_t *charmap, - struct repertoire_t *repertoire) -{ - uint32_t value; - struct charseq *seq; - void *not_used; - - seq = charset_find_value (charmap, code->val.str.start, code->val.str.len); - if (seq != NULL) - { - lr_error (ldfile, _("symbol for multicharacter collating element " - "`%.*s' duplicates symbolic name in charmap"), - (int) code->val.str.len, code->val.str.start); - return; - } - - value = repertoire (repertoire, code->val.str.start, code->val.str.len); - if (value != ILLEGAL_CHAR_VALUE) - { - lr_error (ldfile, _("symbol for multicharacter collating element " - "`%.*s' duplicates symbolic name in repertoire"), - (int) code->val.str.len, code->val.str.start); - return; - } - - if (find_entry (&collate->elements, code->val.str.start, code->val.str.len, - ¬_used) >= 0) - { - lr_error (ldfile, _("symbol for multicharacter collating element " - "`%.*s' duplicates element definition"), - (int) code->val.str.len, code->val.str.start); - return; - } - - if (find_entry (&collate->symbols, code->val.str.start, code->val.str.len, - ¬_used) >= 0) - { - lr_error (ldfile, _("symbol for multicharacter collating element " - "`%.*s' duplicates other symbol definition"), - (int) code->val.str.len, code->val.str.start); - return; - } - - if (insert_entry (&collate->symbols, code->val.str.start, code->val.str.len, - (void *) 0) < 0) - lr_error (ldfile, _("cannot insert new collating symbol definition: %s"), - strerror (errno)); -} - - -void -collate_new_order (struct linereader *ldfile, struct localedef_t *locale, - enum coll_sort_rule sort_rule) -{ - struct locale_collate_t *collate = locale->categories[LC_COLLATE].collate; - - if (collate->nrules >= collate->nrules_max) - { - collate->nrules_max *= 2; - collate->rules - = (enum coll_sort_rule *) xrealloc (collate->rules, - collate->nrules_max - * sizeof (enum coll_sort_rule)); - } - - collate->rules[collate->nrules++] = sort_rule; -} - - -void -collate_build_arrays (struct linereader *ldfile, struct localedef_t *locale) -{ - struct locale_collate_t *collate = locale->categories[LC_COLLATE].collate; - - collate->rules - = (enum coll_sort_rule *) xrealloc (collate->rules, - collate->nrules - * sizeof (enum coll_sort_rule)); - - /* Allocate arrays for temporary weights. */ - collate->weight_cnt = (int *) xmalloc (collate->nrules * sizeof (int)); - - /* Choose arbitrary start value for table size. */ - collate->nweight_max = 5 * collate->nrules; - collate->weight = (int *) xmalloc (collate->nweight_max * sizeof (int)); -} - - -int -collate_order_elem (struct linereader *ldfile, struct localedef_t *locale, - struct token *code, struct charset_t *charset) -{ - const uint32_t zero = L'\0'; - struct locale_collate_t *collate = locale->categories[LC_COLLATE].collate; - int result = 0; - uint32_t value; - void *tmp; - unsigned int i; - - switch (code->tok) - { - case tok_bsymbol: - /* We have a string to find in one of the three hashing tables. */ - value = charset_find_value (&charset->char_table, code->val.str.start, - code->val.str.len); - if (value != ILLEGAL_CHAR_VALUE) - { - element_t *lastp, *firstp; - - collate->kind = character; - - if (find_entry (&collate->result, &value, sizeof (uint32_t), - (void *) &firstp) < 0) - firstp = lastp = NULL; - else - { - /* The entry for the simple character is always found at - the end. */ - lastp = firstp; - while (lastp->next != NULL) - lastp = lastp->next; - - if (lastp->name[0] == value && lastp->name[1] == L'\0') - { - lr_error (ldfile, - _("duplicate definition for character `%.*s'"), - (int) code->val.str.len, code->val.str.start); - lr_ignore_rest (ldfile, 0); - result = -1; - break; - } - } - - collate->current_element - = (element_t *) obstack_alloc (&collate->element_mem, - sizeof (element_t)); - - obstack_grow (&collate->element_mem, &value, sizeof (value)); - obstack_grow (&collate->element_mem, &zero, sizeof (zero)); - - collate->current_element->name = - (const uint32_t *) obstack_finish (&collate->element_mem); - - collate->current_element->this_weight = ++collate->order_cnt; - - collate->current_element->next = NULL; - - if (firstp == NULL) - { - if (insert_entry (&collate->result, &value, sizeof (uint32_t), - (void *) collate->current_element) < 0) - { - lr_error (ldfile, _("cannot insert collation element `%.*s'"), - (int) code->val.str.len, code->val.str.start); - exit (4); - } - } - else - lastp->next = collate->current_element; - } - else if (find_entry (&collate->elements, code->val.str.start, - code->val.str.len, &tmp) >= 0) - { - collate->current_element = (element_t *) tmp; - - if (collate->current_element->this_weight != 0) - { - lr_error (ldfile, _("\ -collation element `%.*s' appears more than once: ignore line"), - (int) code->val.str.len, code->val.str.start); - lr_ignore_rest (ldfile, 0); - result = -1; - break; - } - - collate->kind = element; - collate->current_element->this_weight = ++collate->order_cnt; - } - else if (find_entry (&collate->symbols, code->val.str.start, - code->val.str.len, &tmp) >= 0) - { - unsigned int order = ++collate->order_cnt; - - if ((unsigned long int) tmp != 0ul) - { - lr_error (ldfile, _("\ -collation symbol `%.*s' appears more than once: ignore line"), - (int) code->val.str.len, code->val.str.start); - lr_ignore_rest (ldfile, 0); - result = -1; - break; - } - - collate->kind = symbol; - - if (set_entry (&collate->symbols, code->val.str.start, - code->val.str.len, (void *) order) < 0) - { - lr_error (ldfile, _("cannot process order specification")); - exit (4); - } - } - else - { - if (verbose) - lr_error (ldfile, _("unknown symbol `%.*s': line ignored"), - (int) code->val.str.len, code->val.str.start); - lr_ignore_rest (ldfile, 0); - - result = -1; - } - break; - - case tok_undefined: - collate->kind = undefined; - collate->current_element = &collate->undefined; - break; - - case tok_ellipsis: - if (collate->was_ellipsis) - { - lr_error (ldfile, _("\ -two lines in a row containing `...' are not allowed")); - result = -1; - } - else if (collate->kind != character) - { - /* An ellipsis requires the previous line to be an - character definition. */ - lr_error (ldfile, _("\ -line before ellipsis does not contain definition for character constant")); - lr_ignore_rest (ldfile, 0); - result = -1; - } - else - collate->kind = ellipsis; - break; - - default: - assert (! "illegal token in `collate_order_elem'"); - } - - /* Now it's time to handle the ellipsis in the previous line. We do - this only when the last line contained an definition for a - character, the current line also defines an character, the - character code for the later is bigger than the former. */ - if (collate->was_ellipsis) - { - if (collate->kind != character) - { - lr_error (ldfile, _("\ -line after ellipsis must contain character definition")); - lr_ignore_rest (ldfile, 0); - result = -1; - } - else if (collate->last_char > value) - { - lr_error (ldfile, _("end point of ellipsis range is bigger then start")); - lr_ignore_rest (ldfile, 0); - result = -1; - } - else - { - /* We can fill the arrays with the information we need. */ - uint32_t name[2]; - unsigned int *data; - size_t *ptr; - size_t cnt; - - name[0] = collate->last_char + 1; - name[1] = L'\0'; - - data = (unsigned int *) alloca ((collate->nrules + collate->nweight) - * sizeof (unsigned int)); - ptr = (size_t *) alloca (collate->nrules * sizeof (size_t)); - - /* Prepare data. Because the characters covered by an - ellipsis all have equal values we prepare the data once - and only change the variable number (if there are any). - PTR[...] will point to the entries which will have to be - fixed during the output loop. */ - for (cnt = 0; cnt < collate->nrules; ++cnt) - { - data[cnt] = collate->weight_cnt[cnt]; - ptr[cnt] = (cnt == 0 - ? collate->nweight - : ptr[cnt - 1] + collate->weight_cnt[cnt - 1]); - } - - for (cnt = 0; cnt < collate->nweight; ++cnt) - data[collate->nrules + cnt] = collate->weight[cnt]; - - for (cnt = 0; cnt < collate->nrules; ++cnt) - if ((uint32_t) data[ptr[cnt]] != ELLIPSIS_CHAR) - ptr[cnt] = 0; - - while (name[0] <= value) - { - element_t *pelem; - - pelem = (element_t *) obstack_alloc (&collate->element_mem, - sizeof (element_t)); - pelem->name - = (const uint32_t *) obstack_copy (&collate->element_mem, - name, 2 * sizeof (uint32_t)); - pelem->this_weight = ++collate->order_cnt; - - pelem->ordering_len = collate->nweight; - pelem->ordering - = (unsigned int *) obstack_copy (&collate->element_mem, data, - (collate->nrules - + pelem->ordering_len) - * sizeof (unsigned int)); - - /* `...' weights need to be adjusted. */ - for (cnt = 0; cnt < collate->nrules; ++cnt) - if (ptr[cnt] != 0) - pelem->ordering[ptr[cnt]] = pelem->this_weight; - - /* Insert new entry into result table. */ - if (find_entry (&collate->result, name, sizeof (uint32_t), - (void *) &pelem->next) >= 0) - { - if (set_entry (&collate->result, name, sizeof (uint32_t), - (void *) pelem) < 0) - error (4, 0, _("cannot insert into result table")); - } - else - { - pelem->next = NULL; - if (insert_entry (&collate->result, name, sizeof (uint32_t), - (void *) pelem) < 0) - error (4, 0, _("cannot insert into result table")); - } - - /* Increment counter. */ - ++name[0]; - } - } - } - - /* Reset counters for weights. */ - collate->weight_idx = 0; - collate->nweight = 0; - for (i = 0; i < collate->nrules; ++i) - collate->weight_cnt[i] = 0; - collate->current_patch = NULL; - - return result; -} - - -int -collate_weight_bsymbol (struct linereader *ldfile, struct localedef_t *locale, - struct token *code, struct charset_t *charset) -{ - struct locale_collate_t *collate = locale->categories[LC_COLLATE].collate; - unsigned int here_weight; - uint32_t value; - void *tmp; - - assert (code->tok == tok_bsymbol); - - value = charset_find_value (&charset->char_table, code->val.str.start, - code->val.str.len); - if (value != ILLEGAL_CHAR_VALUE) - { - element_t *runp; - - if (find_entry (&collate->result, &value, sizeof (uint32_t), - (void *)&runp) < 0) - runp = NULL; - - while (runp != NULL - && (runp->name[0] != value || runp->name[1] != L'\0')) - runp = runp->next; - - here_weight = runp == NULL ? 0 : runp->this_weight; - } - else if (find_entry (&collate->elements, code->val.str.start, - code->val.str.len, &tmp) >= 0) - { - element_t *runp = (element_t *) tmp; - - here_weight = runp->this_weight; - } - else if (find_entry (&collate->symbols, code->val.str.start, - code->val.str.len, &tmp) >= 0) - { - here_weight = (unsigned int) tmp; - } - else - { - if (verbose) - lr_error (ldfile, _("unknown symbol `%.*s': line ignored"), - (int) code->val.str.len, code->val.str.start); - lr_ignore_rest (ldfile, 0); - return -1; - } - - /* When we currently work on a collation symbol we do not expect any - weight. */ - if (collate->kind == symbol) - { - lr_error (ldfile, _("\ -specification of sorting weight for collation symbol does not make sense")); - lr_ignore_rest (ldfile, 0); - return -1; - } - - /* Add to the current collection of weights. */ - if (collate->nweight >= collate->nweight_max) - { - collate->nweight_max *= 2; - collate->weight = (unsigned int *) xrealloc (collate->weight, - collate->nweight_max); - } - - /* If the weight is currently not known, we remember to patch the - resulting tables. */ - if (here_weight == 0) - { - patch_t *newp; - - newp = (patch_t *) obstack_alloc (&collate->element_mem, - sizeof (patch_t)); - newp->fname = ldfile->fname; - newp->lineno = ldfile->lineno; - newp->token = (const char *) obstack_copy0 (&collate->element_mem, - code->val.str.start, - code->val.str.len); - newp->where.idx = collate->nweight++; - newp->next = collate->current_patch; - collate->current_patch = newp; - } - else - collate->weight[collate->nweight++] = here_weight; - ++collate->weight_cnt[collate->weight_idx]; - - return 0; -} - - -int -collate_next_weight (struct linereader *ldfile, struct localedef_t *locale) -{ - struct locale_collate_t *collate = locale->categories[LC_COLLATE].collate; - - if (collate->kind == symbol) - { - lr_error (ldfile, _("\ -specification of sorting weight for collation symbol does not make sense")); - lr_ignore_rest (ldfile, 0); - return -1; - } - - ++collate->weight_idx; - if (collate->weight_idx >= collate->nrules) - { - lr_error (ldfile, _("too many weights")); - lr_ignore_rest (ldfile, 0); - return -1; - } - - return 0; -} - - -int -collate_simple_weight (struct linereader *ldfile, struct localedef_t *locale, - struct token *code, struct charset_t *charset) -{ - struct locale_collate_t *collate = locale->categories[LC_COLLATE].collate; - unsigned int value = 0; - - /* There current tokens can be `IGNORE', `...', or a string. */ - switch (code->tok) - { - case tok_ignore: - /* This token is allowed in all situations. */ - value = IGNORE_CHAR; - break; - - case tok_ellipsis: - /* The ellipsis is only allowed for the `...' or `UNDEFINED' - entry. */ - if (collate->kind != ellipsis && collate->kind != undefined) - { - lr_error (ldfile, _("\ -`...' must only be used in `...' and `UNDEFINED' entries")); - lr_ignore_rest (ldfile, 0); - return -1; - } - value = ELLIPSIS_CHAR; - break; - - case tok_string: - /* This can become difficult. We have to get the weights which - correspond to the single wide chars in the string. But some - of the `chars' might not be real characters, but collation - elements or symbols. And so the string decoder might have - signaled errors. The string at this point is not translated. - I.e., all <...> sequences are still there. */ - { - char *runp = code->val.str.start; - void *tmp; - - while (*runp != '\0') - { - char *startp = (char *) runp; - char *putp = (char *) runp; - uint32_t wch; - - /* Lookup weight for char and store it. */ - if (*runp == '<') - { - while (*++runp != '\0' && *runp != '>') - { - if (*runp == ldfile->escape_char) - if (*++runp == '\0') - { - lr_error (ldfile, _("unterminated weight name")); - lr_ignore_rest (ldfile, 0); - return -1; - } - *putp++ = *runp; - } - if (*runp == '>') - ++runp; - - if (putp == startp) - { - lr_error (ldfile, _("empty weight name: line ignored")); - lr_ignore_rest (ldfile, 0); - return -1; - } - - wch = charset_find_value (&charset->char_table, startp, - putp - startp); - if (wch != ILLEGAL_CHAR_VALUE) - { - element_t *pelem; - - if (find_entry (&collate->result, &wch, sizeof (uint32_t), - (void *)&pelem) < 0) - pelem = NULL; - - while (pelem != NULL - && (pelem->name[0] != wch - || pelem->name[1] != L'\0')) - pelem = pelem->next; - - value = pelem == NULL ? 0 : pelem->this_weight; - } - else if (find_entry (&collate->elements, startp, putp - startp, - &tmp) >= 0) - { - element_t *pelem = (element_t *) tmp; - - value = pelem->this_weight; - } - else if (find_entry (&collate->symbols, startp, putp - startp, - &tmp) >= 0) - { - value = (unsigned int) tmp; - } - else - { - if (verbose) - lr_error (ldfile, _("unknown symbol `%.*s': line ignored"), - (int) (putp - startp), startp); - lr_ignore_rest (ldfile, 0); - return -1; - } - } - else - { - element_t *wp; - uint32_t wch; - - if (*runp == ldfile->escape_char) - { - static const char digits[] = "0123456789abcdef"; - const char *dp; - int base; - - ++runp; - if (tolower (*runp) == 'x') - { - ++runp; - base = 16; - } - else if (tolower (*runp) == 'd') - { - ++runp; - base = 10; - } - else - base = 8; - - dp = strchr (digits, tolower (*runp)); - if (dp == NULL || (dp - digits) >= base) - { - illegal_char: - lr_error (ldfile, _("\ -illegal character constant in string")); - lr_ignore_rest (ldfile, 0); - return -1; - } - wch = dp - digits; - ++runp; - - dp = strchr (digits, tolower (*runp)); - if (dp == NULL || (dp - digits) >= base) - goto illegal_char; - wch *= base; - wch += dp - digits; - ++runp; - - if (base != 16) - { - dp = strchr (digits, tolower (*runp)); - if (dp != NULL && (dp - digits < base)) - { - wch *= base; - wch += dp - digits; - ++runp; - } - } - } - else - wch = (uint32_t) *runp++; - - /* Lookup the weight for WCH. */ - if (find_entry (&collate->result, &wch, sizeof (wch), - (void *)&wp) < 0) - wp = NULL; - - while (wp != NULL - && (wp->name[0] != wch || wp->name[1] != L'\0')) - wp = wp->next; - - value = wp == NULL ? 0 : wp->this_weight; - - /* To get the correct name for the error message. */ - putp = runp; - - /**************************************************\ - |* I know here is something wrong. Characters in *| - |* the string which are not in the <...> form *| - |* cannot be declared forward for now!!! *| - \**************************************************/ - } - - /* Store in weight array. */ - if (collate->nweight >= collate->nweight_max) - { - collate->nweight_max *= 2; - collate->weight - = (unsigned int *) xrealloc (collate->weight, - collate->nweight_max); - } - - if (value == 0) - { - patch_t *newp; - - newp = (patch_t *) obstack_alloc (&collate->element_mem, - sizeof (patch_t)); - newp->fname = ldfile->fname; - newp->lineno = ldfile->lineno; - newp->token - = (const char *) obstack_copy0 (&collate->element_mem, - startp, putp - startp); - newp->where.idx = collate->nweight++; - newp->next = collate->current_patch; - collate->current_patch = newp; - } - else - collate->weight[collate->nweight++] = value; - ++collate->weight_cnt[collate->weight_idx]; - } - } - return 0; - - default: - assert (! "should not happen"); - } - - - if (collate->nweight >= collate->nweight_max) - { - collate->nweight_max *= 2; - collate->weight = (unsigned int *) xrealloc (collate->weight, - collate->nweight_max); - } - - collate->weight[collate->nweight++] = value; - ++collate->weight_cnt[collate->weight_idx]; - - return 0; -} - - -void -collate_end_weight (struct linereader *ldfile, struct localedef_t *locale) -{ - struct locale_collate_t *collate = locale->categories[LC_COLLATE].collate; - element_t *pelem = collate->current_element; - - if (collate->kind == symbol) - { - /* We don't have to do anything. */ - collate->was_ellipsis = 0; - return; - } - - if (collate->kind == ellipsis) - { - /* Before the next line is processed the ellipsis is handled. */ - collate->was_ellipsis = 1; - return; - } - - assert (collate->kind == character || collate->kind == element - || collate->kind == undefined); - - /* Fill in the missing weights. */ - while (++collate->weight_idx < collate->nrules) - { - collate->weight[collate->nweight++] = pelem->this_weight; - ++collate->weight_cnt[collate->weight_idx]; - } - - /* Now we know how many ordering weights the current - character/element has. Allocate room in the element structure - and copy information. */ - pelem->ordering_len = collate->nweight; - - /* First we write an array with the number of values for each - weight. */ - obstack_grow (&collate->element_mem, collate->weight_cnt, - collate->nrules * sizeof (unsigned int)); - - /* Now the weights itselves. */ - obstack_grow (&collate->element_mem, collate->weight, - collate->nweight * sizeof (unsigned int)); - - /* Get result. */ - pelem->ordering = obstack_finish (&collate->element_mem); - - /* Now we handle the "patches". */ - while (collate->current_patch != NULL) - { - patch_t *this_patch; - - this_patch = collate->current_patch; - - this_patch->where.pos = &pelem->ordering[collate->nrules - + this_patch->where.idx]; - - collate->current_patch = this_patch->next; - this_patch->next = collate->all_patches; - collate->all_patches = this_patch; - } - - /* Set information for next round. */ - collate->was_ellipsis = 0; - if (collate->kind != undefined) - collate->last_char = pelem->name[0]; -} - - -/* The parser for the LC_CTYPE section of the locale definition. */ -void -read_lc_collate (struct linereader *ldfile, struct localedef_t *result, - struct charmap_t *charmap, struct repertoire_t *repertoire, - int ignore_content) -{ - struct locale_collate_t *collate; - int did_copy = 0; - const char *save_str; - - /* The rest of the line containing `LC_COLLATE' must be free. */ - lr_ignore_rest (ldfile, 1); - - now = lr_token (ldfile, charmap, NULL); - nowtok = now->tok; - - /* If we see `copy' now we are almost done. */ - if (nowtok == tok_copy) - { - handle_copy (ldfile, charmap, repertoire, result, tok_lc_collate, - LC_COLLATE, "LC_COLLATE", ignore_content); - did_copy = 1; - } - - /* Prepare the data structures. */ - collate_startup (ldfile, result, charmap, ignore_content); - collate = result->categories[LC_COLLATE].collate; - - while (1) - { - /* Of course we don't proceed beyond the end of file. */ - if (nowtok == tok_eof) - break; - - /* Ignore empty lines. */ - if (nowtok == tok_eol) - { - now = lr_token (ldfile, charmap, NULL); - nowtok = now->tok; - continue; - } - - switch (nowtok) - { - case tok_coll_weight_max: - if (did_copy) - goto err_label; - /* The rest of the line must be a single integer value. */ - now = lr_token (ldfile, charmap, NULL); - if (now->tok != tok_number) - goto err_label; - /* We simply forget about the value we just read, the implementation - has no fixed limits. */ - lr_ignore_rest (ldfile, 1); - break; - - case tok_script: - if (did_copy) - goto err_label; - /* We expect the name of the script in brackets. */ - now = lr_token (ldfile, charmap, NULL); - if (now->tok != tok_bsymbol && now->tok != tok_ucs4) - goto err_label; - if (now->tok != tok_bsymbol) - { - lr_error (ldfile, _("\ -script name `%s' must not duplicate any known name"), - tok->val.str.startmb); - lr_ignore_rest (ldfile, 0); - break; - } - collate->scripts = xmalloc (collate->scripts, - (collate->nscripts - * sizeof (const char *))); - collate->scripts[collate->nscripts++] = tok->val.str.startmb; - lr_ignore_rest (ldfile, 1); - break; - - case tok_collating_element: - if (did_copy) - goto err_label; - /* Get the first argument, a symbol in brackets. */ - now = lr_token (ldfile, charmap, NULL); - if (now->tok != tok_bsymbol) - goto err_label; - /* Test it. */ - if (collate_element_to (ldfile, collate, now, charmap, repertoire)) - { - /* An error occurred. */ - lr_ignore_rest (ldfile, 0); - break; - } - save_str = tok->val.str.startmb; - /* Next comes `from'. */ - now = lr_token (ldfile, charmap, NULL); - if (now->tok != tok_from) - goto err_label; - /* Now comes a string. */ - now = lr_token (ldfile, charmap, repertoire); - if (now->tok != tok_string) - goto err_label; - collate_element_from (ldfile, collate, save_str, now, charmap, - repertoire); - /* The rest of the line should be empty. */ - lr_ignore_rest (ldfile, 1); - break; - - case tok_collating_symbol: - if (did_copy) - goto err_label; - /* Get the argument, a single symbol in brackets. */ - now = lr_token (ldfile, charmap, NULL); - if (now->tok != tok_bsymbol) - goto err_label; - collate_symbol (ldfile, collate, now, charmap, repertoire); - break; - - case tok_order_start: - if (did_copy) - goto err_label; - - /* We expect now a scripting symbol or start right away - with the order keywords. Or we have no argument at all - in which means `forward'. */ - now = lr_token (ldfile, charmap, NULL); - if (now->tok == tok_eol) - { - static enum coll_sort_rule default_rule = sort_forward; - /* Use a single `forward' rule. */ - collate->nrules = 1; - collate->rules = &default_rule; - } - else - { - /* XXX We don't recognize the ISO 14651 extensions yet. */ - uint32_t nrules = 0; - uint32_t nrules_max = 32; - enum coll_sort_rule *rules = alloca (nrules_max - * sizeof (*rules)); - int saw_semicolon = 0; - - memset (rules, '\0', nrules_max * sizeof (*rules)); - do - { - if (now->tok != tok_forward && now->tok != tok_backward - && now->tok != tok_position) - goto err_label; - - if (saw_semicolon) - { - if (nrules == nrules_max) - { - newp = alloca (nrules_max * 2 * sizeof (*rules)); - rules = memcpy (newp, rules, - nrules_max * sizeof (*rules)); - memset (&rules[nrules_max], '\0', - nrules_max * sizeof (*rules)); - nrules_max *= 2; - } - ++nrules; - } - - switch (now->tok) - { - case tok_forward: - if ((rules[nrules] & sort_backward) != 0) - { - lr_error (ldfile, _("\ -`forward' and `backward' order exclude each other")); - lr_ignore_rest (ldfile, 0); - goto error_sort; - } - rules[nrules] |= sort_forward; - break; - case tok_backward: - if ((rules[nrules] & sort_forward) != 0) - { - lr_error (ldfile, _("\ -`forward' and `backward' order exclude each other")); - lr_ignore_rest (ldfile, 0); - goto error_sort; - } - rules[nrules] |= sort_backward; - break; - case tok_position: - rules[nrules] |= tok_position; - break; - } - - /* Get the next token. This is either the end of the line, - a comma or a semicolon. */ - now = lr_token (ldfile, charmap, NULL); - if (now->tok == tok_comma || now->tok == tok_semicolon) - { - saw_semicolon = now->tok == tok_semicolon; - now = lr_token (ldfile, charmap, NULL); - } - } - while (now->tok != tok_eol || now->tok != tok_eof); - - error_sort: - collate->nrules = nrules; - collate->rules = memcpy (xmalloc (nrules * sizeof (*rules)), - rules, nrules * sizeof (*rules)); - } - - /* Now read the rules. */ - read_rules (ldfile, collate, charmap, repertoire); - break; - - case tok_reorder_after: - break; - - case tok_reorder_script_after: - break; - - default: - err_label: - if (now->tok != tok_eof) - SYNTAX_ERROR (_("syntax error in %s locale definition"), - "LC_COLLATE"); - } - - /* Prepare for the next round. */ - now = lr_token (ldfile, charmap, NULL); - nowtok = now->tok; - } - - /* When we come here we reached the end of the file. */ - lr_error (ldfile, _("premature end of file while reading category `%s'"), - "LC_COLLATE"); -} - -#endif |