1999-12-31 Ulrich Drepper <drepper@cygnus.com>
+ * locale/programs/ld-collate.c (collate_output): Emit correct
+ information for collation elements.
+ Don't write over end of array idx.
+ * posix/regex.c: Handle also collation elements at end of range.
+
+ * posix/PTESTS: Fix a few typos.
+
* posix/bits/posix2_lim.h: Remove _POSIX2_EQUIV_CLASS_MAX. I have
no idea where this came from.
* sysdeps/posix/sysconf.c: Remove _POSIX2_EQUIV_CLASS_MAX
unsigned int used_in_level;
struct element_list_t *weights;
- /* Index in the `weight' table in the output file for the character. */
- int32_t weights_idx;
/* Nonzero if this is a real character definition. */
int is_character;
/* Will be allocated later. */
newp->weights = NULL;
- newp->weights_idx = 0;
newp->file = NULL;
newp->line = 0;
obstack_grow (pool, buf, len);
}
- /* Remember the index. */
- elem->weights_idx = retval;
-
return retval | ((elem->section->ruleidx & 0x7f) << 24);
}
/* If we have no LC_COLLATE data emit only the number of rules as zero. */
if (collate == NULL)
{
+ int32_t dummy = 0;
+
while (cnt < _NL_ITEM_INDEX (_NL_NUM_LC_COLLATE))
{
- iov[2 + cnt].iov_base = (char *) "";
- iov[2 + cnt].iov_len = 0;
- idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len;
+ /* The words have to be handled specially. */
+ if (cnt == _NL_ITEM_INDEX (_NL_COLLATE_HASH_SIZE)
+ || cnt == _NL_ITEM_INDEX (_NL_COLLATE_HASH_LAYERS)
+ || cnt == _NL_ITEM_INDEX (_NL_COLLATE_SYMB_HASH_SIZEMB))
+ {
+ iov[2 + cnt].iov_base = &dummy;
+ iov[2 + cnt].iov_len = sizeof (int32_t);
+ }
+ else
+ {
+ iov[2 + cnt].iov_base = (char *) "";
+ iov[2 + cnt].iov_len = 0;
+ }
+
+ if (cnt + 1 < _NL_ITEM_INDEX (_NL_NUM_LC_COLLATE))
+ idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len;
++cnt;
}
elem_table[idx * 2] = hash;
elem_table[idx * 2 + 1] = obstack_object_size (&extrapool);
- /* Now add the index into the weights table. We know the
- address is always 32bit aligned. */
- if (sizeof (int) == sizeof (int32_t))
- obstack_int_grow (&extrapool, runp->weights_idx);
- else
- obstack_grow (&extrapool, &runp->weights_idx,
- sizeof (int32_t));
-
/* The the string itself including length. */
obstack_1grow (&extrapool, namelen);
obstack_grow (&extrapool, runp->name, namelen);
+ /* And the multibyte representation. */
+ obstack_1grow (&extrapool, runp->nmbs);
+ obstack_grow (&extrapool, runp->mbs, runp->nmbs);
+
/* And align again to 32 bits. */
- if ((1 + namelen) % sizeof (int32_t) != 0)
+ if ((1 + namelen + 1 + runp->nmbs) % sizeof (int32_t) != 0)
obstack_grow (&extrapool, "\0\0",
(sizeof (int32_t)
- - (1 + namelen) % sizeof (int32_t)));
+ - ((1 + namelen + 1 + runp->nmbs)
+ % sizeof (int32_t))));
}
}
assert (cnt == _NL_ITEM_INDEX (_NL_COLLATE_SYMB_EXTRAMB));
iov[2 + cnt].iov_len = obstack_object_size (&extrapool);
iov[2 + cnt].iov_base = obstack_finish (&extrapool);
- idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len;
++cnt;
3¦3¦[][.-.]-0]¦ab0-]¦
3¦3¦[A-[.].]c]¦ab]!¦
# GA122
--2¦-2¦[[.ch]]¦abc¦
+-2¦-2¦[[.ch.]]¦abc¦
-2¦-2¦[[.ab.][.CD.][.EF.]]¦yZabCDEFQ9¦
# GA125
2¦2¦[[=a=]b]¦Abc¦
2¦6¦bc[d-w]xy¦abchxyz¦
# GA129
1¦1¦[a-cd-f]¦dbccde¦
--1¦-1¦[a-ce-f¦dBCCdE¦
+-1¦-1¦[a-ce-f]¦dBCCdE¦
2¦4¦b[n-zA-M]Y¦absY9Z¦
2¦4¦b[n-zA-M]Y¦abGY9Z¦
# GA130
3¦3¦[-xy]¦ac-¦
-2¦4¦[c[-xy]D¦ac-D+¦
+2¦4¦c[-xy]D¦ac-D+¦
2¦2¦[--/]¦a.b¦
2¦4¦c[--/]D¦ac.D+b¦
2¦2¦[^-ac]¦abcde-¦
3¦4¦[a-c][e-f]¦acbedf¦
4¦8¦abc*XYZ¦890abXYZ#*¦
4¦9¦abc*XYZ¦890abcXYZ#*¦
-4¦15¦abc*XYZ¦890abccccccccXYZ#*¦
+4¦15¦abc*XYZ¦890abcccccccXYZ#*¦
-1¦-1¦abc*XYZ¦890abc*XYZ#*¦
# GA132
2¦4¦\(*bc\)¦a*bc¦
1¦1¦^a¦abc¦
-1¦-1¦^b¦abc¦
-1¦-1¦^[a-zA-Z]¦99Nine¦
-1¦4¦^[a-zA-Z]¦Nine99¦
+1¦4¦^[a-zA-Z]*¦Nine99¦
# GA145(1)
1¦2¦\(^a\)\1¦aabc¦
-1¦-1¦\(^a\)\1¦^a^abc¦
3¦3¦a$¦cba¦
-1¦-1¦a$¦abc¦
5¦7¦[a-z]*$¦99ZZxyz¦
--1¦-1¦[a-z]*$¦99ZZxyz99¦
+9¦9¦[a-z]*$¦99ZZxyz99¦
3¦3¦$$¦ab$¦
-1¦-1¦$$¦$ab¦
3¦3¦\$$¦ab$¦
{ 3, 3, "[][.-.]-0]", "ab0-]", },
{ 3, 3, "[A-[.].]c]", "ab]!", },
{ 0, 0, "GA122", NULL, },
- { -2, -2, "[[.ch]]", "abc", },
+ { -2, -2, "[[.ch.]]", "abc", },
{ -2, -2, "[[.ab.][.CD.][.EF.]]", "yZabCDEFQ9", },
{ 0, 0, "GA125", NULL, },
{ 2, 2, "[[=a=]b]", "Abc", },
{ 2, 6, "bc[d-w]xy", "abchxyz", },
{ 0, 0, "GA129", NULL, },
{ 1, 1, "[a-cd-f]", "dbccde", },
- { -1, -1, "[a-ce-f", "dBCCdE", },
+ { -1, -1, "[a-ce-f]", "dBCCdE", },
{ 2, 4, "b[n-zA-M]Y", "absY9Z", },
{ 2, 4, "b[n-zA-M]Y", "abGY9Z", },
{ 0, 0, "GA130", NULL, },
{ 3, 3, "[-xy]", "ac-", },
- { 2, 4, "[c[-xy]D", "ac-D+", },
+ { 2, 4, "c[-xy]D", "ac-D+", },
{ 2, 2, "[--/]", "a.b", },
{ 2, 4, "c[--/]D", "ac.D+b", },
{ 2, 2, "[^-ac]", "abcde-", },
{ 3, 4, "[a-c][e-f]", "acbedf", },
{ 4, 8, "abc*XYZ", "890abXYZ#*", },
{ 4, 9, "abc*XYZ", "890abcXYZ#*", },
- { 4, 15, "abc*XYZ", "890abccccccccXYZ#*", },
+ { 4, 15, "abc*XYZ", "890abcccccccXYZ#*", },
{ -1, -1, "abc*XYZ", "890abc*XYZ#*", },
{ 0, 0, "GA132", NULL, },
{ 2, 4, "\\(*bc\\)", "a*bc", },
{ 1, 1, "^a", "abc", },
{ -1, -1, "^b", "abc", },
{ -1, -1, "^[a-zA-Z]", "99Nine", },
- { 1, 4, "^[a-zA-Z]", "Nine99", },
+ { 1, 4, "^[a-zA-Z]*", "Nine99", },
{ 0, 0, "GA145(1)", NULL, },
{ 1, 2, "\\(^a\\)\\1", "aabc", },
{ -1, -1, "\\(^a\\)\\1", "^a^abc", },
{ 3, 3, "a$", "cba", },
{ -1, -1, "a$", "abc", },
{ 5, 7, "[a-z]*$", "99ZZxyz", },
- { -1, -1, "[a-z]*$", "99ZZxyz99", },
+ { 9, 9, "[a-z]*$", "99ZZxyz99", },
{ 3, 3, "$$", "ab$", },
{ -1, -1, "$$", "$ab", },
{ 3, 3, "\\$$", "ab$", },
reg_syntax_t syntax));
static boolean at_endline_loc_p _RE_ARGS ((const char *p, const char *pend,
reg_syntax_t syntax));
-static reg_errcode_t compile_range _RE_ARGS ((const char **p_ptr,
+static reg_errcode_t compile_range _RE_ARGS ((unsigned int range_start,
+ const char **p_ptr,
const char *pend,
char *translate,
reg_syntax_t syntax,
case '[':
{
boolean had_char_class = false;
+ unsigned int range_start = 0xffffffff;
if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
PATFETCH (c1);
SET_LIST_BIT (c1);
+ range_start = c1;
continue;
}
&& *p != ']')
{
reg_errcode_t ret
- = compile_range (&p, pend, translate, syntax, b);
+ = compile_range (range_start, &p, pend, translate,
+ syntax, b);
if (ret != REG_NOERROR) FREE_STACK_RETURN (ret);
+ range_start = 0xffffffff;
}
else if (p[0] == '-' && p[1] != ']')
/* Move past the `-'. */
PATFETCH (c1);
- ret = compile_range (&p, pend, translate, syntax, b);
+ ret = compile_range (c, &p, pend, translate, syntax, b);
if (ret != REG_NOERROR) FREE_STACK_RETURN (ret);
+ range_start = 0xffffffff;
}
/* See if we're at the beginning of a possible character
PATUNFETCH;
SET_LIST_BIT ('[');
SET_LIST_BIT (':');
+ range_start = ':';
had_char_class = false;
}
}
#endif
had_char_class = true;
}
+ else
+ {
+ c1++;
+ while (c1--)
+ PATUNFETCH;
+ SET_LIST_BIT ('[');
+ SET_LIST_BIT ('=');
+ range_start = '=';
+ had_char_class = false;
+ }
}
else if (syntax & RE_CHAR_CLASSES && c == '[' && *p == '.')
{
/* Set the bit for the character. */
SET_LIST_BIT (str[0]);
+ range_start = ((const unsigned char *) str)[0];
}
#ifdef _LIBC
else
those known to the collate implementation.
First find out whether the bytes in `str' are
actually from exactly one character. */
- const unsigned char *weights;
int32_t table_size;
- const int32_t *table;
const int32_t *symb_table;
const unsigned char *extra;
int32_t idx;
int32_t hash;
int ch;
- table = (const int32_t *)
- _NL_CURRENT (LC_COLLATE, _NL_COLLATE_TABLEMB);
- weights = (const unsigned char *)
- _NL_CURRENT (LC_COLLATE, _NL_COLLATE_WEIGHTMB);
table_size =
_NL_CURRENT_WORD (LC_COLLATE,
_NL_COLLATE_SYMB_HASH_SIZEMB);
{
/* First compare the hashing value. */
if (symb_table[2 * elem] == hash
- && (c1 == extra[symb_table[2 * elem + 1]
- + sizeof (int32_t)])
+ && c1 == extra[symb_table[2 * elem + 1]]
&& memcmp (str,
&extra[symb_table[2 * elem + 1]
- + sizeof (int32_t) + 1],
+ + 1],
c1) == 0)
{
/* Yep, this is the entry. */
- idx = *((int32_t *)
- (extra
- + symb_table[2 * elem + 1]));
+ idx = symb_table[2 * elem + 1];
+ idx += 1 + extra[idx];
break;
}
class. */
PATFETCH (c);
- /* Now we have to go throught the whole table
- and find all characters which have the same
- first level weight.
+ /* Now add the multibyte character(s) we found
+ to the acceptabed list.
XXX Note that this is not entirely correct.
we would have to match multibyte sequences
but this is not possible with the current
- implementation. */
- for (ch = 1; ch < 256; ++ch)
- /* XXX This test would have to be changed if we
- would allow matching multibyte sequences. */
- if (table[ch] > 0)
- {
- int32_t idx2 = table[ch];
- size_t len = weights[idx2];
-
- /* Test whether the lenghts match. */
- if (weights[idx] == len)
- {
- /* They do. New compare the bytes of
- the weight. */
- size_t cnt = 0;
-
- while (cnt < len
- && (weights[idx + 1 + cnt]
- == weights[idx2 + 1 + cnt]))
- ++len;
-
- if (cnt == len)
- /* They match. Mark the character as
- acceptable. */
- SET_LIST_BIT (ch);
- }
- }
+ implementation. Also, we have to match
+ collating symbols, which expand to more than
+ one file, as a whole and not allow the
+ individual bytes. */
+ c1 = extra[idx++];
+ if (c1 == 1)
+ range_start = extra[idx];
+ while (c1-- > 0)
+ SET_LIST_BIT (extra[idx++]);
}
#endif
had_char_class = false;
while (c1--)
PATUNFETCH;
SET_LIST_BIT ('[');
- SET_LIST_BIT ('=');
+ SET_LIST_BIT ('.');
+ range_start = '.';
had_char_class = false;
}
}
{
had_char_class = false;
SET_LIST_BIT (c);
+ range_start = c;
}
}
`regex_compile' itself. */
static reg_errcode_t
-compile_range (p_ptr, pend, translate, syntax, b)
+compile_range (range_start, p_ptr, pend, translate, syntax, b)
+ unsigned int range_start;
const char **p_ptr, *pend;
RE_TRANSLATE_TYPE translate;
reg_syntax_t syntax;
unsigned this_char;
const char *p = *p_ptr;
- unsigned int range_start, range_end;
+ unsigned int range_end;
if (p == pend)
return REG_ERANGE;
We also want to fetch the endpoints without translating them; the
appropriate translation is done in the bit-setting loop below. */
/* The SVR4 compiler on the 3B2 had trouble with unsigned const char *. */
- range_start = ((const unsigned char *) p)[-2];
range_end = ((const unsigned char *) p)[0];
/* Have to increment the pointer into the pattern string, so the
projects / external / glibc.git / commitdiff