vbatts/grub
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

resynced with gnulib. Cleaned up wrapping layer

Browse source
This commit is contained in:
Vladimir 'phcoder' Serbinenko 2010-03-28 21:43:42 +02:00
parent bbdb72a1f4
commit a64b15feed
20 changed files with 620 additions and 305 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
Makefile.in
View file

@ -79,7 +79,9 @@ LIBS = @LIBS@ $(LIBINTL)
CC = @CC@ CC = @CC@
CFLAGS = @CFLAGS@ CFLAGS = @CFLAGS@
GNULIB_CFLAGS = -Wno-undef -D_GL_UNUSED="__attribute__ ((unused))" POSIX_CFLAGS = -I$(srcdir)/lib/posix_wrap
GNULIB_UTIL_CFLAGS = -Wno-undef -Wno-sign-compare -Wno-unused -D_GL_UNUSED="__attribute__ ((unused))" -I$(srcdir)/gnulib
GNULIB_CFLAGS = $(GNULIB_UTIL_CFLAGS) $(POSIX_CFLAGS)
ASFLAGS = @ASFLAGS@ ASFLAGS = @ASFLAGS@
LDFLAGS = @LDFLAGS@ $(LIBS) LDFLAGS = @LDFLAGS@ $(LIBS)
CPPFLAGS = @CPPFLAGS@ -I$(builddir) -I$(builddir)/include -I$(srcdir)/gnulib -I$(srcdir)/include -Wall -W \ CPPFLAGS = @CPPFLAGS@ -I$(builddir) -I$(builddir)/include -I$(srcdir)/gnulib -I$(srcdir)/include -Wall -W \

6
conf/common.rmk
View file

@ -56,7 +56,7 @@ grub_mkisofs_SOURCES = util/mkisofs/eltorito.c \
gnulib/error.c gnulib/progname.c gnulib/error.c gnulib/progname.c
grub_mkisofs_CFLAGS = -D_FILE_OFFSET_BITS=64 \ grub_mkisofs_CFLAGS = -D_FILE_OFFSET_BITS=64 \
-I$(srcdir)/util/mkisofs/include \ -I$(srcdir)/util/mkisofs/include \
-Wno-all -Werror $(GNULIB_CFLAGS) -Wno-all -Werror $(GNULIB_UTIL_CFLAGS)
# For grub-fstest. # For grub-fstest.
util/grub-fstest.c_DEPENDENCIES = grub_fstest_init.h util/grub-fstest.c_DEPENDENCIES = grub_fstest_init.h
@ -111,7 +111,7 @@ grub_script_check_SOURCES = gnulib/progname.c gnulib/getdelim.c gnulib/getline.c
kern/handler.c kern/err.c kern/parser.c kern/list.c \ kern/handler.c kern/err.c kern/parser.c kern/list.c \
kern/misc.c kern/env.c grub_script_check_init.c grub_script.tab.c \ kern/misc.c kern/env.c grub_script_check_init.c grub_script.tab.c \
grub_script.yy.c grub_script.yy.c
grub_script_check_CFLAGS = $(GNULIB_CFLAGS) grub_script_check_CFLAGS = $(GNULIB_UTIL_CFLAGS)
MOSTLYCLEANFILES += symlist.c kernel_syms.lst MOSTLYCLEANFILES += symlist.c kernel_syms.lst
DEFSYMFILES += kernel_syms.lst DEFSYMFILES += kernel_syms.lst
@ -788,7 +788,7 @@ charset_mod_LDFLAGS = $(COMMON_LDFLAGS)
pkglib_MODULES += regexp.mod pkglib_MODULES += regexp.mod
regexp_mod_SOURCES = gnulib/regex.c commands/regexp.c regexp_mod_SOURCES = gnulib/regex.c commands/regexp.c
regexp_mod_CFLAGS = $(COMMON_CFLAGS) -Wno-sign-compare -Wno-unused regexp_mod_CFLAGS = $(COMMON_CFLAGS) $(GNULIB_CFLAGS)
regexp_mod_LDFLAGS = $(COMMON_LDFLAGS) regexp_mod_LDFLAGS = $(COMMON_LDFLAGS)
pkglib_MODULES += terminal.mod pkglib_MODULES += terminal.mod

172
gnulib/regcomp.c
View file

@ -1,6 +1,6 @@
/* Extended regular expression matching and search library. /* Extended regular expression matching and search library.
Copyright (C) 2002,2003,2004,2005,2006,2007,2008,2009 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free
Free Software Foundation, Inc. Software Foundation, Inc.
This file is part of the GNU C Library. This file is part of the GNU C Library.
Contributed by Isamu Hasegawa <isamu@yamato.ibm.com>. Contributed by Isamu Hasegawa <isamu@yamato.ibm.com>.
@ -383,7 +383,7 @@ re_compile_fastmap_iter (regex_t *bufp, const re_dfastate_t *init_state,
applies to multibyte character sets; for single byte character applies to multibyte character sets; for single byte character
sets, the SIMPLE_BRACKET again suffices. */ sets, the SIMPLE_BRACKET again suffices. */
if (dfa->mb_cur_max > 1 if (dfa->mb_cur_max > 1
&& (cset->nchar_classes || cset->non_match && (cset->nchar_classes || cset->non_match || cset->nranges
# ifdef _LIBC # ifdef _LIBC
|| cset->nequiv_classes || cset->nequiv_classes
# endif /* _LIBC */ # endif /* _LIBC */
@ -636,7 +636,7 @@ free_dfa_content (re_dfa_t *dfa)
re_dfastate_t *state = entry->array[j]; re_dfastate_t *state = entry->array[j];
free_state (state); free_state (state);
} }
re_free (entry->array); re_free (entry->array);
} }
re_free (dfa->state_table); re_free (dfa->state_table);
#ifdef RE_ENABLE_I18N #ifdef RE_ENABLE_I18N
@ -850,6 +850,9 @@ static reg_errcode_t
init_dfa (re_dfa_t *dfa, size_t pat_len) init_dfa (re_dfa_t *dfa, size_t pat_len)
{ {
__re_size_t table_size; __re_size_t table_size;
#ifndef _LIBC
char *codeset_name;
#endif
#ifdef RE_ENABLE_I18N #ifdef RE_ENABLE_I18N
size_t max_i18n_object_size = MAX (sizeof (wchar_t), sizeof (wctype_t)); size_t max_i18n_object_size = MAX (sizeof (wchar_t), sizeof (wctype_t));
#else #else
@ -893,7 +896,9 @@ init_dfa (re_dfa_t *dfa, size_t pat_len)
dfa->map_notascii = (_NL_CURRENT_WORD (LC_CTYPE, _NL_CTYPE_MAP_TO_NONASCII) dfa->map_notascii = (_NL_CURRENT_WORD (LC_CTYPE, _NL_CTYPE_MAP_TO_NONASCII)
!= 0); != 0);
#else #else
if (strcmp (locale_charset (), "UTF-8") == 0) codeset_name = nl_langinfo (CODESET);
if (strcasecmp (codeset_name, "UTF-8") == 0
|| strcasecmp (codeset_name, "UTF8") == 0)
dfa->is_utf8 = 1; dfa->is_utf8 = 1;
/* We check exhaustively in the loop below if this charset is a /* We check exhaustively in the loop below if this charset is a
@ -1016,7 +1021,10 @@ create_initial_state (re_dfa_t *dfa)
Idx dest_idx = dfa->edests[node_idx].elems[0]; Idx dest_idx = dfa->edests[node_idx].elems[0];
if (!re_node_set_contains (&init_nodes, dest_idx)) if (!re_node_set_contains (&init_nodes, dest_idx))
{ {
re_node_set_merge (&init_nodes, dfa->eclosures + dest_idx); reg_errcode_t merge_err
= re_node_set_merge (&init_nodes, dfa->eclosures + dest_idx);
if (merge_err != REG_NOERROR)
return merge_err;
i = 0; i = 0;
} }
} }
@ -1085,8 +1093,8 @@ optimize_utf8 (re_dfa_t *dfa)
} }
break; break;
case OP_PERIOD: case OP_PERIOD:
has_period = true; has_period = true;
break; break;
case OP_BACK_REF: case OP_BACK_REF:
case OP_ALT: case OP_ALT:
case END_OF_RE: case END_OF_RE:
@ -1187,7 +1195,7 @@ analyze (regex_t *preg)
{ {
dfa->inveclosures = re_malloc (re_node_set, dfa->nodes_len); dfa->inveclosures = re_malloc (re_node_set, dfa->nodes_len);
if (BE (dfa->inveclosures == NULL, 0)) if (BE (dfa->inveclosures == NULL, 0))
return REG_ESPACE; return REG_ESPACE;
ret = calc_inveclosure (dfa); ret = calc_inveclosure (dfa);
} }
@ -1209,16 +1217,16 @@ postorder (bin_tree_t *root, reg_errcode_t (fn (void *, bin_tree_t *)),
if that's the only child). */ if that's the only child). */
while (node->left || node->right) while (node->left || node->right)
if (node->left) if (node->left)
node = node->left; node = node->left;
else else
node = node->right; node = node->right;
do do
{ {
reg_errcode_t err = fn (extra, node); reg_errcode_t err = fn (extra, node);
if (BE (err != REG_NOERROR, 0)) if (BE (err != REG_NOERROR, 0))
return err; return err;
if (node->parent == NULL) if (node->parent == NULL)
return REG_NOERROR; return REG_NOERROR;
prev = node; prev = node;
node = node->parent; node = node->parent;
@ -1252,7 +1260,7 @@ preorder (bin_tree_t *root, reg_errcode_t (fn (void *, bin_tree_t *)),
prev = node; prev = node;
node = node->parent; node = node->parent;
if (!node) if (!node)
return REG_NOERROR; return REG_NOERROR;
} }
node = node->right; node = node->right;
} }
@ -1275,13 +1283,13 @@ optimize_subexps (void *extra, bin_tree_t *node)
} }
else if (node->token.type == SUBEXP else if (node->token.type == SUBEXP
&& node->left && node->left->token.type == SUBEXP) && node->left && node->left->token.type == SUBEXP)
{ {
Idx other_idx = node->left->token.opr.idx; Idx other_idx = node->left->token.opr.idx;
node->left = node->left->left; node->left = node->left->left;
if (node->left) if (node->left)
node->left->parent = node; node->left->parent = node;
dfa->subexp_map[other_idx] = dfa->subexp_map[node->token.opr.idx]; dfa->subexp_map[other_idx] = dfa->subexp_map[node->token.opr.idx];
if (other_idx < BITSET_WORD_BITS) if (other_idx < BITSET_WORD_BITS)
@ -1366,9 +1374,9 @@ calc_first (void *extra, bin_tree_t *node)
node->first = node; node->first = node;
node->node_idx = re_dfa_add_node (dfa, node->token); node->node_idx = re_dfa_add_node (dfa, node->token);
if (BE (node->node_idx == REG_MISSING, 0)) if (BE (node->node_idx == REG_MISSING, 0))
return REG_ESPACE; return REG_ESPACE;
if (node->token.type == ANCHOR) if (node->token.type == ANCHOR)
dfa->nodes[node->node_idx].constraint = node->token.opr.ctx_type; dfa->nodes[node->node_idx].constraint = node->token.opr.ctx_type;
} }
return REG_NOERROR; return REG_NOERROR;
} }
@ -1390,7 +1398,7 @@ calc_next (void *extra, bin_tree_t *node)
if (node->left) if (node->left)
node->left->next = node->next; node->left->next = node->next;
if (node->right) if (node->right)
node->right->next = node->next; node->right->next = node->next;
break; break;
} }
return REG_NOERROR; return REG_NOERROR;
@ -1441,7 +1449,7 @@ link_nfa_nodes (void *extra, bin_tree_t *node)
case OP_BACK_REF: case OP_BACK_REF:
dfa->nexts[idx] = node->next->node_idx; dfa->nexts[idx] = node->next->node_idx;
if (node->token.type == OP_BACK_REF) if (node->token.type == OP_BACK_REF)
re_node_set_init_1 (dfa->edests + idx, dfa->nexts[idx]); err = re_node_set_init_1 (dfa->edests + idx, dfa->nexts[idx]);
break; break;
default: default:
@ -1498,7 +1506,6 @@ duplicate_node_closure (re_dfa_t *dfa, Idx top_org_node, Idx top_clone_node,
destination. */ destination. */
org_dest = dfa->edests[org_node].elems[0]; org_dest = dfa->edests[org_node].elems[0];
re_node_set_empty (dfa->edests + clone_node); re_node_set_empty (dfa->edests + clone_node);
clone_dest = search_duplicated_node (dfa, org_dest, constraint);
/* If the node is root_node itself, it means the epsilon closure /* If the node is root_node itself, it means the epsilon closure
has a loop. Then tie it to the destination of the root_node. */ has a loop. Then tie it to the destination of the root_node. */
if (org_node == root_node && clone_node != org_node) if (org_node == root_node && clone_node != org_node)
@ -1542,7 +1549,7 @@ duplicate_node_closure (re_dfa_t *dfa, Idx top_org_node, Idx top_clone_node,
} }
else else
{ {
/* There is a duplicated node which satisfy the constraint, /* There is a duplicated node which satisfies the constraint,
use it to avoid infinite loop. */ use it to avoid infinite loop. */
ok = re_node_set_insert (dfa->edests + clone_node, clone_dest); ok = re_node_set_insert (dfa->edests + clone_node, clone_dest);
if (BE (! ok, 0)) if (BE (! ok, 0))
@ -1674,10 +1681,9 @@ calc_eclosure_iter (re_node_set *new_set, re_dfa_t *dfa, Idx node, bool root)
{ {
reg_errcode_t err; reg_errcode_t err;
Idx i; Idx i;
bool incomplete;
bool ok;
re_node_set eclosure; re_node_set eclosure;
incomplete = false; bool ok;
bool incomplete = false;
err = re_node_set_alloc (&eclosure, dfa->edests[node].nelem + 1); err = re_node_set_alloc (&eclosure, dfa->edests[node].nelem + 1);
if (BE (err != REG_NOERROR, 0)) if (BE (err != REG_NOERROR, 0))
return err; return err;
@ -1722,7 +1728,9 @@ calc_eclosure_iter (re_node_set *new_set, re_dfa_t *dfa, Idx node, bool root)
else else
eclosure_elem = dfa->eclosures[edest]; eclosure_elem = dfa->eclosures[edest];
/* Merge the epsilon closure of `edest'. */ /* Merge the epsilon closure of `edest'. */
re_node_set_merge (&eclosure, &eclosure_elem); err = re_node_set_merge (&eclosure, &eclosure_elem);
if (BE (err != REG_NOERROR, 0))
return err;
/* If the epsilon closure of `edest' is incomplete, /* If the epsilon closure of `edest' is incomplete,
the epsilon closure of this node is also incomplete. */ the epsilon closure of this node is also incomplete. */
if (dfa->eclosures[edest].nelem == 0) if (dfa->eclosures[edest].nelem == 0)
@ -1732,7 +1740,7 @@ calc_eclosure_iter (re_node_set *new_set, re_dfa_t *dfa, Idx node, bool root)
} }
} }
/* Epsilon closures include itself. */ /* An epsilon closure includes itself. */
ok = re_node_set_insert (&eclosure, node); ok = re_node_set_insert (&eclosure, node);
if (BE (! ok, 0)) if (BE (! ok, 0))
return REG_ESPACE; return REG_ESPACE;
@ -2319,7 +2327,7 @@ parse_expression (re_string_t *regexp, regex_t *preg, re_token_t *token,
&& dfa->word_ops_used == 0) && dfa->word_ops_used == 0)
init_word_char (dfa); init_word_char (dfa);
if (token->opr.ctx_type == WORD_DELIM if (token->opr.ctx_type == WORD_DELIM
|| token->opr.ctx_type == NOT_WORD_DELIM) || token->opr.ctx_type == NOT_WORD_DELIM)
{ {
bin_tree_t *tree_first, *tree_last; bin_tree_t *tree_first, *tree_last;
if (token->opr.ctx_type == WORD_DELIM) if (token->opr.ctx_type == WORD_DELIM)
@ -2327,13 +2335,13 @@ parse_expression (re_string_t *regexp, regex_t *preg, re_token_t *token,
token->opr.ctx_type = WORD_FIRST; token->opr.ctx_type = WORD_FIRST;
tree_first = create_token_tree (dfa, NULL, NULL, token); tree_first = create_token_tree (dfa, NULL, NULL, token);
token->opr.ctx_type = WORD_LAST; token->opr.ctx_type = WORD_LAST;
} }
else else
{ {
token->opr.ctx_type = INSIDE_WORD; token->opr.ctx_type = INSIDE_WORD;
tree_first = create_token_tree (dfa, NULL, NULL, token); tree_first = create_token_tree (dfa, NULL, NULL, token);
token->opr.ctx_type = INSIDE_NOTWORD; token->opr.ctx_type = INSIDE_NOTWORD;
} }
tree_last = create_token_tree (dfa, NULL, NULL, token); tree_last = create_token_tree (dfa, NULL, NULL, token);
tree = create_tree (dfa, tree_first, tree_last, OP_ALT); tree = create_tree (dfa, tree_first, tree_last, OP_ALT);
if (BE (tree_first == NULL || tree_last == NULL || tree == NULL, 0)) if (BE (tree_first == NULL || tree_last == NULL || tree == NULL, 0))
@ -2444,7 +2452,7 @@ parse_sub_exp (re_string_t *regexp, regex_t *preg, re_token_t *token,
{ {
tree = parse_reg_exp (regexp, preg, token, syntax, nest, err); tree = parse_reg_exp (regexp, preg, token, syntax, nest, err);
if (BE (*err == REG_NOERROR && token->type != OP_CLOSE_SUBEXP, 0)) if (BE (*err == REG_NOERROR && token->type != OP_CLOSE_SUBEXP, 0))
*err = REG_EPAREN; *err = REG_EPAREN;
if (BE (*err != REG_NOERROR, 0)) if (BE (*err != REG_NOERROR, 0))
return NULL; return NULL;
} }
@ -2515,7 +2523,8 @@ parse_dup_op (bin_tree_t *elem, re_string_t *regexp, re_dfa_t *dfa,
return elem; return elem;
} }
if (BE (end != REG_MISSING && start > end, 0)) if (BE ((end != REG_MISSING && start > end)
|| token->type != OP_CLOSE_DUP_NUM, 0))
{ {
/* First number greater than second. */ /* First number greater than second. */
*err = REG_BADBR; *err = REG_BADBR;
@ -2568,10 +2577,14 @@ parse_dup_op (bin_tree_t *elem, re_string_t *regexp, re_dfa_t *dfa,
if (BE (tree == NULL, 0)) if (BE (tree == NULL, 0))
goto parse_dup_op_espace; goto parse_dup_op_espace;
/* From gnulib's "intprops.h":
True if the arithmetic type T is signed. */
#define TYPE_SIGNED(t) (! ((t) 0 < (t) -1))
/* This loop is actually executed only when end != REG_MISSING, /* This loop is actually executed only when end != REG_MISSING,
to rewrite <re>{0,n} as (<re>(<re>...<re>?)?)?... We have to rewrite <re>{0,n} as (<re>(<re>...<re>?)?)?... We have
already created the start+1-th copy. */ already created the start+1-th copy. */
if ((Idx) -1 < 0 || end != REG_MISSING) if (TYPE_SIGNED (Idx) || end != REG_MISSING)
for (i = start + 2; i <= end; ++i) for (i = start + 2; i <= end; ++i)
{ {
elem = duplicate_tree (elem, dfa); elem = duplicate_tree (elem, dfa);
@ -2609,11 +2622,17 @@ parse_dup_op (bin_tree_t *elem, re_string_t *regexp, re_dfa_t *dfa,
static reg_errcode_t static reg_errcode_t
internal_function internal_function
# ifdef RE_ENABLE_I18N # ifdef RE_ENABLE_I18N
build_range_exp (bitset_t sbcset, re_charset_t *mbcset, Idx *range_alloc, build_range_exp (const reg_syntax_t syntax,
bracket_elem_t *start_elem, bracket_elem_t *end_elem) bitset_t sbcset,
re_charset_t *mbcset,
Idx *range_alloc,
const bracket_elem_t *start_elem,
const bracket_elem_t *end_elem)
# else /* not RE_ENABLE_I18N */ # else /* not RE_ENABLE_I18N */
build_range_exp (bitset_t sbcset, bracket_elem_t *start_elem, build_range_exp (const reg_syntax_t syntax,
bracket_elem_t *end_elem) bitset_t sbcset,
const bracket_elem_t *start_elem,
const bracket_elem_t *end_elem)
# endif /* not RE_ENABLE_I18N */ # endif /* not RE_ENABLE_I18N */
{ {
unsigned int start_ch, end_ch; unsigned int start_ch, end_ch;
@ -2652,7 +2671,9 @@ build_range_exp (bitset_t sbcset, bracket_elem_t *start_elem,
return REG_ECOLLATE; return REG_ECOLLATE;
cmp_buf[0] = start_wc; cmp_buf[0] = start_wc;
cmp_buf[4] = end_wc; cmp_buf[4] = end_wc;
if (wcscoll (cmp_buf, cmp_buf + 4) > 0)
if (BE ((syntax & RE_NO_EMPTY_RANGES)
&& wcscoll (cmp_buf, cmp_buf + 4) > 0, 0))
return REG_ERANGE; return REG_ERANGE;
/* Got valid collation sequence values, add them as a new entry. /* Got valid collation sequence values, add them as a new entry.
@ -2662,9 +2683,9 @@ build_range_exp (bitset_t sbcset, bracket_elem_t *start_elem,
no MBCSET if dfa->mb_cur_max == 1. */ no MBCSET if dfa->mb_cur_max == 1. */
if (mbcset) if (mbcset)
{ {
/* Check the space of the arrays. */ /* Check the space of the arrays. */
if (BE (*range_alloc == mbcset->nranges, 0)) if (BE (*range_alloc == mbcset->nranges, 0))
{ {
/* There is not enough space, need realloc. */ /* There is not enough space, need realloc. */
wchar_t *new_array_start, *new_array_end; wchar_t *new_array_start, *new_array_end;
Idx new_nranges; Idx new_nranges;
@ -2674,9 +2695,9 @@ build_range_exp (bitset_t sbcset, bracket_elem_t *start_elem,
/* Use realloc since mbcset->range_starts and mbcset->range_ends /* Use realloc since mbcset->range_starts and mbcset->range_ends
are NULL if *range_alloc == 0. */ are NULL if *range_alloc == 0. */
new_array_start = re_realloc (mbcset->range_starts, wchar_t, new_array_start = re_realloc (mbcset->range_starts, wchar_t,
new_nranges); new_nranges);
new_array_end = re_realloc (mbcset->range_ends, wchar_t, new_array_end = re_realloc (mbcset->range_ends, wchar_t,
new_nranges); new_nranges);
if (BE (new_array_start == NULL || new_array_end == NULL, 0)) if (BE (new_array_start == NULL || new_array_end == NULL, 0))
return REG_ESPACE; return REG_ESPACE;
@ -2684,10 +2705,10 @@ build_range_exp (bitset_t sbcset, bracket_elem_t *start_elem,
mbcset->range_starts = new_array_start; mbcset->range_starts = new_array_start;
mbcset->range_ends = new_array_end; mbcset->range_ends = new_array_end;
*range_alloc = new_nranges; *range_alloc = new_nranges;
} }
mbcset->range_starts[mbcset->nranges] = start_wc; mbcset->range_starts[mbcset->nranges] = start_wc;
mbcset->range_ends[mbcset->nranges++] = end_wc; mbcset->range_ends[mbcset->nranges++] = end_wc;
} }
/* Build the table for single byte characters. */ /* Build the table for single byte characters. */
@ -2799,7 +2820,7 @@ parse_bracket_exp (re_string_t *regexp, re_dfa_t *dfa, re_token_t *token,
return elem; return elem;
} }
/* Local function for parse_bracket_exp used in _LIBC environement. /* Local function for parse_bracket_exp used in _LIBC environment.
Look up the collation sequence value of BR_ELEM. Look up the collation sequence value of BR_ELEM.
Return the value if succeeded, UINT_MAX otherwise. */ Return the value if succeeded, UINT_MAX otherwise. */
@ -2823,7 +2844,8 @@ parse_bracket_exp (re_string_t *regexp, re_dfa_t *dfa, re_token_t *token,
} }
else if (br_elem->type == MB_CHAR) else if (br_elem->type == MB_CHAR)
{ {
return __collseq_table_lookup (collseqwc, br_elem->opr.wch); if (nrules != 0)
return __collseq_table_lookup (collseqwc, br_elem->opr.wch);
} }
else if (br_elem->type == COLL_SYM) else if (br_elem->type == COLL_SYM)
{ {
@ -2904,8 +2926,8 @@ parse_bracket_exp (re_string_t *regexp, re_dfa_t *dfa, re_token_t *token,
build below suffices. */ build below suffices. */
if (nrules > 0 || dfa->mb_cur_max > 1) if (nrules > 0 || dfa->mb_cur_max > 1)
{ {
/* Check the space of the arrays. */ /* Check the space of the arrays. */
if (BE (*range_alloc == mbcset->nranges, 0)) if (BE (*range_alloc == mbcset->nranges, 0))
{ {
/* There is not enough space, need realloc. */ /* There is not enough space, need realloc. */
uint32_t *new_array_start; uint32_t *new_array_start;
@ -2917,18 +2939,18 @@ parse_bracket_exp (re_string_t *regexp, re_dfa_t *dfa, re_token_t *token,
new_array_start = re_realloc (mbcset->range_starts, uint32_t, new_array_start = re_realloc (mbcset->range_starts, uint32_t,
new_nranges); new_nranges);
new_array_end = re_realloc (mbcset->range_ends, uint32_t, new_array_end = re_realloc (mbcset->range_ends, uint32_t,
new_nranges); new_nranges);
if (BE (new_array_start == NULL || new_array_end == NULL, 0)) if (BE (new_array_start == NULL || new_array_end == NULL, 0))
return REG_ESPACE; return REG_ESPACE;
mbcset->range_starts = new_array_start; mbcset->range_starts = new_array_start;
mbcset->range_ends = new_array_end; mbcset->range_ends = new_array_end;
*range_alloc = new_nranges; *range_alloc = new_nranges;
} }
mbcset->range_starts[mbcset->nranges] = start_collseq; mbcset->range_starts[mbcset->nranges] = start_collseq;
mbcset->range_ends[mbcset->nranges++] = end_collseq; mbcset->range_ends[mbcset->nranges++] = end_collseq;
} }
/* Build the table for single byte characters. */ /* Build the table for single byte characters. */
@ -3154,11 +3176,11 @@ parse_bracket_exp (re_string_t *regexp, re_dfa_t *dfa, re_token_t *token,
&start_elem, &end_elem); &start_elem, &end_elem);
#else #else
# ifdef RE_ENABLE_I18N # ifdef RE_ENABLE_I18N
*err = build_range_exp (sbcset, *err = build_range_exp (syntax, sbcset,
dfa->mb_cur_max > 1 ? mbcset : NULL, dfa->mb_cur_max > 1 ? mbcset : NULL,
&range_alloc, &start_elem, &end_elem); &range_alloc, &start_elem, &end_elem);
# else # else
*err = build_range_exp (sbcset, &start_elem, &end_elem); *err = build_range_exp (syntax, sbcset, &start_elem, &end_elem);
# endif # endif
#endif /* RE_ENABLE_I18N */ #endif /* RE_ENABLE_I18N */
if (BE (*err != REG_NOERROR, 0)) if (BE (*err != REG_NOERROR, 0))
@ -3262,17 +3284,17 @@ parse_bracket_exp (re_string_t *regexp, re_dfa_t *dfa, re_token_t *token,
of having both SIMPLE_BRACKET and COMPLEX_BRACKET. */ of having both SIMPLE_BRACKET and COMPLEX_BRACKET. */
if (sbc_idx < BITSET_WORDS) if (sbc_idx < BITSET_WORDS)
{ {
/* Build a tree for simple bracket. */ /* Build a tree for simple bracket. */
br_token.type = SIMPLE_BRACKET; br_token.type = SIMPLE_BRACKET;
br_token.opr.sbcset = sbcset; br_token.opr.sbcset = sbcset;
work_tree = create_token_tree (dfa, NULL, NULL, &br_token); work_tree = create_token_tree (dfa, NULL, NULL, &br_token);
if (BE (work_tree == NULL, 0)) if (BE (work_tree == NULL, 0))
goto parse_bracket_exp_espace; goto parse_bracket_exp_espace;
/* Then join them by ALT node. */ /* Then join them by ALT node. */
work_tree = create_tree (dfa, work_tree, mbc_tree, OP_ALT); work_tree = create_tree (dfa, work_tree, mbc_tree, OP_ALT);
if (BE (work_tree == NULL, 0)) if (BE (work_tree == NULL, 0))
goto parse_bracket_exp_espace; goto parse_bracket_exp_espace;
} }
else else
{ {
@ -3291,7 +3313,7 @@ parse_bracket_exp (re_string_t *regexp, re_dfa_t *dfa, re_token_t *token,
br_token.opr.sbcset = sbcset; br_token.opr.sbcset = sbcset;
work_tree = create_token_tree (dfa, NULL, NULL, &br_token); work_tree = create_token_tree (dfa, NULL, NULL, &br_token);
if (BE (work_tree == NULL, 0)) if (BE (work_tree == NULL, 0))
goto parse_bracket_exp_espace; goto parse_bracket_exp_espace;
} }
return work_tree; return work_tree;
@ -3430,7 +3452,7 @@ build_equiv_class (bitset_t sbcset, const unsigned char *name)
/* Build single byte matcing table for this equivalence class. */ /* Build single byte matcing table for this equivalence class. */
char_buf[1] = (unsigned char) '\0'; char_buf[1] = (unsigned char) '\0';
len = weights[idx1]; len = weights[idx1 & 0xffffff];
for (ch = 0; ch < SBC_MAX; ++ch) for (ch = 0; ch < SBC_MAX; ++ch)
{ {
char_buf[0] = ch; char_buf[0] = ch;
@ -3442,11 +3464,15 @@ build_equiv_class (bitset_t sbcset, const unsigned char *name)
if (idx2 == 0) if (idx2 == 0)
/* This isn't a valid character. */ /* This isn't a valid character. */
continue; continue;
if (len == weights[idx2]) /* Compare only if the length matches and the collation rule
index is the same. */
if (len == weights[idx2 & 0xffffff] && (idx1 >> 24) == (idx2 >> 24))
{ {
int cnt = 0; int cnt = 0;
while (cnt <= len && while (cnt <= len &&
weights[idx1 + 1 + cnt] == weights[idx2 + 1 + cnt]) weights[(idx1 & 0xffffff) + 1 + cnt]
== weights[(idx2 & 0xffffff) + 1 + cnt])
++cnt; ++cnt;
if (cnt > len) if (cnt > len)
@ -3842,7 +3868,7 @@ duplicate_tree (const bin_tree_t *root, re_dfa_t *dfa)
node = node->parent; node = node->parent;
dup_node = dup_node->parent; dup_node = dup_node->parent;
if (!node) if (!node)
return dup_root; return dup_root;
} }
node = node->right; node = node->right;
p_new = &dup_node->right; p_new = &dup_node->right;

50
gnulib/regex.c
View file

@ -1,5 +1,6 @@
/* Extended regular expression matching and search library. /* Extended regular expression matching and search library.
Copyright (C) 2002, 2003, 2005, 2006 Free Software Foundation, Inc. Copyright (C) 2002, 2003, 2005, 2006, 2009, 2010 Free Software Foundation,
Inc.
This file is part of the GNU C Library. This file is part of the GNU C Library.
Contributed by Isamu Hasegawa <isamu@yamato.ibm.com>. Contributed by Isamu Hasegawa <isamu@yamato.ibm.com>.
@ -17,10 +18,55 @@
with this program; if not, write to the Free Software Foundation, with this program; if not, write to the Free Software Foundation,
Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
#include <grub/regex.h> #include <config.h>
/* Make sure noone compiles this code with a C++ compiler. */
#if defined __cplusplus && defined _LIBC
# error "This is C code, use a C compiler"
#endif
#ifdef _LIBC
/* We have to keep the namespace clean. */
# define regfree(preg) __regfree (preg)
# define regexec(pr, st, nm, pm, ef) __regexec (pr, st, nm, pm, ef)
# define regcomp(preg, pattern, cflags) __regcomp (preg, pattern, cflags)
# define regerror(errcode, preg, errbuf, errbuf_size) \
__regerror(errcode, preg, errbuf, errbuf_size)
# define re_set_registers(bu, re, nu, st, en) \
__re_set_registers (bu, re, nu, st, en)
# define re_match_2(bufp, string1, size1, string2, size2, pos, regs, stop) \
__re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
# define re_match(bufp, string, size, pos, regs) \
__re_match (bufp, string, size, pos, regs)
# define re_search(bufp, string, size, startpos, range, regs) \
__re_search (bufp, string, size, startpos, range, regs)
# define re_compile_pattern(pattern, length, bufp) \
__re_compile_pattern (pattern, length, bufp)
# define re_set_syntax(syntax) __re_set_syntax (syntax)
# define re_search_2(bufp, st1, s1, st2, s2, startpos, range, regs, stop) \
__re_search_2 (bufp, st1, s1, st2, s2, startpos, range, regs, stop)
# define re_compile_fastmap(bufp) __re_compile_fastmap (bufp)
# include "../locale/localeinfo.h"
#endif
/* On some systems, limits.h sets RE_DUP_MAX to a lower value than
GNU regex allows. Include it before <regex.h>, which correctly
#undefs RE_DUP_MAX and sets it to the right value. */
#include <limits.h>
#include <regex.h>
#include "regex_internal.h" #include "regex_internal.h"
#include "regex_internal.c" #include "regex_internal.c"
#include "regcomp.c" #include "regcomp.c"
#include "regexec.c" #include "regexec.c"
/* Binary backward compatibility. */
#if _LIBC
# include <shlib-compat.h>
# if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_3)
link_warning (re_max_failures, "the 're_max_failures' variable is obsolete and will go away.")
int re_max_failures = 2000;
# endif
#endif

7
include/grub/regex.h → gnulib/regex.h
View file

@ -1,7 +1,8 @@
/* Definitions for data structures and routines for the regular /* Definitions for data structures and routines for the regular
expression library. expression library.
Copyright (C) 1985,1989-93,1995-98,2000,2001,2002,2003,2005,2006 Copyright (C) 1985, 1989, 1990, 1991, 1992, 1993, 1995, 1996, 1997, 1998,
Free Software Foundation, Inc. 2000, 2001, 2002, 2003, 2005, 2006, 2009, 2010 Free Software Foundation,
Inc.
This file is part of the GNU C Library. This file is part of the GNU C Library.
This program is free software; you can redistribute it and/or modify This program is free software; you can redistribute it and/or modify
@ -21,7 +22,7 @@
#ifndef _REGEX_H #ifndef _REGEX_H
#define _REGEX_H 1 #define _REGEX_H 1
#include <grub/gnulib-wrap.h> #include <sys/types.h>
/* Allow the use in C++ code. */ /* Allow the use in C++ code. */
#ifdef __cplusplus #ifdef __cplusplus

101
gnulib/regex_internal.c
View file

@ -1,6 +1,6 @@
/* Extended regular expression matching and search library. /* Extended regular expression matching and search library.
Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free
Free Software Foundation, Inc. Software Foundation, Inc.
This file is part of the GNU C Library. This file is part of the GNU C Library.
Contributed by Isamu Hasegawa <isamu@yamato.ibm.com>. Contributed by Isamu Hasegawa <isamu@yamato.ibm.com>.
@ -36,7 +36,7 @@ static re_dfastate_t *create_cd_newstate (const re_dfa_t *dfa,
re_string_reconstruct before using the object. */ re_string_reconstruct before using the object. */
static reg_errcode_t static reg_errcode_t
internal_function internal_function __attribute_warn_unused_result__
re_string_allocate (re_string_t *pstr, const char *str, Idx len, Idx init_len, re_string_allocate (re_string_t *pstr, const char *str, Idx len, Idx init_len,
RE_TRANSLATE_TYPE trans, bool icase, const re_dfa_t *dfa) RE_TRANSLATE_TYPE trans, bool icase, const re_dfa_t *dfa)
{ {
@ -64,7 +64,7 @@ re_string_allocate (re_string_t *pstr, const char *str, Idx len, Idx init_len,
/* This function allocate the buffers, and initialize them. */ /* This function allocate the buffers, and initialize them. */
static reg_errcode_t static reg_errcode_t
internal_function internal_function __attribute_warn_unused_result__
re_string_construct (re_string_t *pstr, const char *str, Idx len, re_string_construct (re_string_t *pstr, const char *str, Idx len,
RE_TRANSLATE_TYPE trans, bool icase, const re_dfa_t *dfa) RE_TRANSLATE_TYPE trans, bool icase, const re_dfa_t *dfa)
{ {
@ -127,7 +127,7 @@ re_string_construct (re_string_t *pstr, const char *str, Idx len,
/* Helper functions for re_string_allocate, and re_string_construct. */ /* Helper functions for re_string_allocate, and re_string_construct. */
static reg_errcode_t static reg_errcode_t
internal_function internal_function __attribute_warn_unused_result__
re_string_realloc_buffers (re_string_t *pstr, Idx new_buf_len) re_string_realloc_buffers (re_string_t *pstr, Idx new_buf_len)
{ {
#ifdef RE_ENABLE_I18N #ifdef RE_ENABLE_I18N
@ -267,7 +267,7 @@ build_wcs_buffer (re_string_t *pstr)
but for REG_ICASE. */ but for REG_ICASE. */
static reg_errcode_t static reg_errcode_t
internal_function internal_function __attribute_warn_unused_result__
build_wcs_upper_buffer (re_string_t *pstr) build_wcs_upper_buffer (re_string_t *pstr)
{ {
mbstate_t prev_st; mbstate_t prev_st;
@ -430,8 +430,8 @@ build_wcs_upper_buffer (re_string_t *pstr)
src_idx += mbclen; src_idx += mbclen;
continue; continue;
} }
else else
memcpy (pstr->mbs + byte_idx, p, mbclen); memcpy (pstr->mbs + byte_idx, p, mbclen);
} }
else else
memcpy (pstr->mbs + byte_idx, p, mbclen); memcpy (pstr->mbs + byte_idx, p, mbclen);
@ -569,7 +569,7 @@ re_string_translate_buffer (re_string_t *pstr)
convert to upper case in case of REG_ICASE, apply translation. */ convert to upper case in case of REG_ICASE, apply translation. */
static reg_errcode_t static reg_errcode_t
internal_function internal_function __attribute_warn_unused_result__
re_string_reconstruct (re_string_t *pstr, Idx idx, int eflags) re_string_reconstruct (re_string_t *pstr, Idx idx, int eflags)
{ {
Idx offset; Idx offset;
@ -964,7 +964,7 @@ re_string_context_at (const re_string_t *input, Idx idx, int eflags)
/* Functions for set operation. */ /* Functions for set operation. */
static reg_errcode_t static reg_errcode_t
internal_function internal_function __attribute_warn_unused_result__
re_node_set_alloc (re_node_set *set, Idx size) re_node_set_alloc (re_node_set *set, Idx size)
{ {
set->alloc = size; set->alloc = size;
@ -976,7 +976,7 @@ re_node_set_alloc (re_node_set *set, Idx size)
} }
static reg_errcode_t static reg_errcode_t
internal_function internal_function __attribute_warn_unused_result__
re_node_set_init_1 (re_node_set *set, Idx elem) re_node_set_init_1 (re_node_set *set, Idx elem)
{ {
set->alloc = 1; set->alloc = 1;
@ -992,7 +992,7 @@ re_node_set_init_1 (re_node_set *set, Idx elem)
} }
static reg_errcode_t static reg_errcode_t
internal_function internal_function __attribute_warn_unused_result__
re_node_set_init_2 (re_node_set *set, Idx elem1, Idx elem2) re_node_set_init_2 (re_node_set *set, Idx elem1, Idx elem2)
{ {
set->alloc = 2; set->alloc = 2;
@ -1022,7 +1022,7 @@ re_node_set_init_2 (re_node_set *set, Idx elem1, Idx elem2)
} }
static reg_errcode_t static reg_errcode_t
internal_function internal_function __attribute_warn_unused_result__
re_node_set_init_copy (re_node_set *dest, const re_node_set *src) re_node_set_init_copy (re_node_set *dest, const re_node_set *src)
{ {
dest->nelem = src->nelem; dest->nelem = src->nelem;
@ -1047,7 +1047,7 @@ re_node_set_init_copy (re_node_set *dest, const re_node_set *src)
Note: We assume dest->elems is NULL, when dest->alloc is 0. */ Note: We assume dest->elems is NULL, when dest->alloc is 0. */
static reg_errcode_t static reg_errcode_t
internal_function internal_function __attribute_warn_unused_result__
re_node_set_add_intersect (re_node_set *dest, const re_node_set *src1, re_node_set_add_intersect (re_node_set *dest, const re_node_set *src1,
const re_node_set *src2) const re_node_set *src2)
{ {
@ -1062,7 +1062,7 @@ re_node_set_add_intersect (re_node_set *dest, const re_node_set *src1,
Idx new_alloc = src1->nelem + src2->nelem + dest->alloc; Idx new_alloc = src1->nelem + src2->nelem + dest->alloc;
Idx *new_elems = re_realloc (dest->elems, Idx, new_alloc); Idx *new_elems = re_realloc (dest->elems, Idx, new_alloc);
if (BE (new_elems == NULL, 0)) if (BE (new_elems == NULL, 0))
return REG_ESPACE; return REG_ESPACE;
dest->elems = new_elems; dest->elems = new_elems;
dest->alloc = new_alloc; dest->alloc = new_alloc;
} }
@ -1112,20 +1112,20 @@ re_node_set_add_intersect (re_node_set *dest, const re_node_set *src1,
if (delta > 0 && REG_VALID_INDEX (id)) if (delta > 0 && REG_VALID_INDEX (id))
for (;;) for (;;)
{ {
if (dest->elems[is] > dest->elems[id]) if (dest->elems[is] > dest->elems[id])
{ {
/* Copy from the top. */ /* Copy from the top. */
dest->elems[id + delta--] = dest->elems[is--]; dest->elems[id + delta--] = dest->elems[is--];
if (delta == 0) if (delta == 0)
break; break;
} }
else else
{ {
/* Slide from the bottom. */ /* Slide from the bottom. */
dest->elems[id + delta] = dest->elems[id]; dest->elems[id + delta] = dest->elems[id];
if (! REG_VALID_INDEX (--id)) if (! REG_VALID_INDEX (--id))
break; break;
} }
} }
/* Copy remaining SRC elements. */ /* Copy remaining SRC elements. */
@ -1138,7 +1138,7 @@ re_node_set_add_intersect (re_node_set *dest, const re_node_set *src1,
DEST. Return value indicate the error code or REG_NOERROR if succeeded. */ DEST. Return value indicate the error code or REG_NOERROR if succeeded. */
static reg_errcode_t static reg_errcode_t
internal_function internal_function __attribute_warn_unused_result__
re_node_set_init_union (re_node_set *dest, const re_node_set *src1, re_node_set_init_union (re_node_set *dest, const re_node_set *src1,
const re_node_set *src2) const re_node_set *src2)
{ {
@ -1191,7 +1191,7 @@ re_node_set_init_union (re_node_set *dest, const re_node_set *src1,
DEST. Return value indicate the error code or REG_NOERROR if succeeded. */ DEST. Return value indicate the error code or REG_NOERROR if succeeded. */
static reg_errcode_t static reg_errcode_t
internal_function internal_function __attribute_warn_unused_result__
re_node_set_merge (re_node_set *dest, const re_node_set *src) re_node_set_merge (re_node_set *dest, const re_node_set *src)
{ {
Idx is, id, sbase, delta; Idx is, id, sbase, delta;
@ -1221,11 +1221,11 @@ re_node_set_merge (re_node_set *dest, const re_node_set *src)
REG_VALID_INDEX (is) && REG_VALID_INDEX (id); ) REG_VALID_INDEX (is) && REG_VALID_INDEX (id); )
{ {
if (dest->elems[id] == src->elems[is]) if (dest->elems[id] == src->elems[is])
is--, id--; is--, id--;
else if (dest->elems[id] < src->elems[is]) else if (dest->elems[id] < src->elems[is])
dest->elems[--sbase] = src->elems[is--]; dest->elems[--sbase] = src->elems[is--];
else /* if (dest->elems[id] > src->elems[is]) */ else /* if (dest->elems[id] > src->elems[is]) */
--id; --id;
} }
if (REG_VALID_INDEX (is)) if (REG_VALID_INDEX (is))
@ -1247,21 +1247,21 @@ re_node_set_merge (re_node_set *dest, const re_node_set *src)
for (;;) for (;;)
{ {
if (dest->elems[is] > dest->elems[id]) if (dest->elems[is] > dest->elems[id])
{ {
/* Copy from the top. */ /* Copy from the top. */
dest->elems[id + delta--] = dest->elems[is--]; dest->elems[id + delta--] = dest->elems[is--];
if (delta == 0) if (delta == 0)
break; break;
} }
else else
{ {
/* Slide from the bottom. */ /* Slide from the bottom. */
dest->elems[id + delta] = dest->elems[id]; dest->elems[id + delta] = dest->elems[id];
if (! REG_VALID_INDEX (--id)) if (! REG_VALID_INDEX (--id))
{ {
/* Copy remaining SRC elements. */ /* Copy remaining SRC elements. */
memcpy (dest->elems, dest->elems + sbase, memcpy (dest->elems, dest->elems + sbase,
delta * sizeof (Idx)); delta * sizeof (Idx));
break; break;
} }
} }
@ -1275,7 +1275,7 @@ re_node_set_merge (re_node_set *dest, const re_node_set *src)
Return true if successful. */ Return true if successful. */
static bool static bool
internal_function internal_function __attribute_warn_unused_result__
re_node_set_insert (re_node_set *set, Idx elem) re_node_set_insert (re_node_set *set, Idx elem)
{ {
Idx idx; Idx idx;
@ -1308,12 +1308,12 @@ re_node_set_insert (re_node_set *set, Idx elem)
{ {
idx = 0; idx = 0;
for (idx = set->nelem; idx > 0; idx--) for (idx = set->nelem; idx > 0; idx--)
set->elems[idx] = set->elems[idx - 1]; set->elems[idx] = set->elems[idx - 1];
} }
else else
{ {
for (idx = set->nelem; set->elems[idx - 1] > elem; idx--) for (idx = set->nelem; set->elems[idx - 1] > elem; idx--)
set->elems[idx] = set->elems[idx - 1]; set->elems[idx] = set->elems[idx - 1];
} }
/* Insert the new element. */ /* Insert the new element. */
@ -1327,7 +1327,7 @@ re_node_set_insert (re_node_set *set, Idx elem)
Return true if successful. */ Return true if successful. */
static bool static bool
internal_function internal_function __attribute_warn_unused_result__
re_node_set_insert_last (re_node_set *set, Idx elem) re_node_set_insert_last (re_node_set *set, Idx elem)
{ {
/* Realloc if we need. */ /* Realloc if we need. */
@ -1473,7 +1473,7 @@ calc_state_hash (const re_node_set *nodes, unsigned int context)
optimization. */ optimization. */
static re_dfastate_t * static re_dfastate_t *
internal_function internal_function __attribute_warn_unused_result__
re_acquire_state (reg_errcode_t *err, const re_dfa_t *dfa, re_acquire_state (reg_errcode_t *err, const re_dfa_t *dfa,
const re_node_set *nodes) const re_node_set *nodes)
{ {
@ -1521,7 +1521,7 @@ re_acquire_state (reg_errcode_t *err, const re_dfa_t *dfa,
optimization. */ optimization. */
static re_dfastate_t * static re_dfastate_t *
internal_function internal_function __attribute_warn_unused_result__
re_acquire_state_context (reg_errcode_t *err, const re_dfa_t *dfa, re_acquire_state_context (reg_errcode_t *err, const re_dfa_t *dfa,
const re_node_set *nodes, unsigned int context) const re_node_set *nodes, unsigned int context)
{ {
@ -1562,6 +1562,7 @@ re_acquire_state_context (reg_errcode_t *err, const re_dfa_t *dfa,
indicates the error code if failed. */ indicates the error code if failed. */
static reg_errcode_t static reg_errcode_t
__attribute_warn_unused_result__
register_state (const re_dfa_t *dfa, re_dfastate_t *newstate, register_state (const re_dfa_t *dfa, re_dfastate_t *newstate,
re_hashval_t hash) re_hashval_t hash)
{ {
@ -1616,7 +1617,7 @@ free_state (re_dfastate_t *state)
Return the new state if succeeded, otherwise return NULL. */ Return the new state if succeeded, otherwise return NULL. */
static re_dfastate_t * static re_dfastate_t *
internal_function internal_function __attribute_warn_unused_result__
create_ci_newstate (const re_dfa_t *dfa, const re_node_set *nodes, create_ci_newstate (const re_dfa_t *dfa, const re_node_set *nodes,
re_hashval_t hash) re_hashval_t hash)
{ {
@ -1666,7 +1667,7 @@ create_ci_newstate (const re_dfa_t *dfa, const re_node_set *nodes,
Return the new state if succeeded, otherwise return NULL. */ Return the new state if succeeded, otherwise return NULL. */
static re_dfastate_t * static re_dfastate_t *
internal_function internal_function __attribute_warn_unused_result__
create_cd_newstate (const re_dfa_t *dfa, const re_node_set *nodes, create_cd_newstate (const re_dfa_t *dfa, const re_node_set *nodes,
unsigned int context, re_hashval_t hash) unsigned int context, re_hashval_t hash)
{ {
@ -1715,7 +1716,9 @@ create_cd_newstate (const re_dfa_t *dfa, const re_node_set *nodes,
free_state (newstate); free_state (newstate);
return NULL; return NULL;
} }
re_node_set_init_copy (newstate->entrance_nodes, nodes); if (re_node_set_init_copy (newstate->entrance_nodes, nodes)
!= REG_NOERROR)
return NULL;
nctx_nodes = 0; nctx_nodes = 0;
newstate->has_constraint = 1; newstate->has_constraint = 1;
} }

49
gnulib/regex_internal.h
View file

@ -1,6 +1,6 @@
/* Extended regular expression matching and search library. /* Extended regular expression matching and search library.
Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free
Free Software Foundation, Inc. Software Foundation, Inc.
This file is part of the GNU C Library. This file is part of the GNU C Library.
Contributed by Isamu Hasegawa <isamu@yamato.ibm.com>. Contributed by Isamu Hasegawa <isamu@yamato.ibm.com>.
@ -21,6 +21,32 @@
#ifndef _REGEX_INTERNAL_H #ifndef _REGEX_INTERNAL_H
#define _REGEX_INTERNAL_H 1 #define _REGEX_INTERNAL_H 1
#include <assert.h>
#include <ctype.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <langinfo.h>
#ifndef _LIBC
# include "localcharset.h"
#endif
#if defined HAVE_LOCALE_H || defined _LIBC
# include <locale.h>
#endif
#include <wchar.h>
#include <wctype.h>
#include <stdint.h>
#if defined _LIBC
# include <bits/libc-lock.h>
#else
# define __libc_lock_init(NAME) do { } while (0)
# define __libc_lock_lock(NAME) do { } while (0)
# define __libc_lock_unlock(NAME) do { } while (0)
#endif
/* In case that the system doesn't have isblank(). */ /* In case that the system doesn't have isblank(). */
#if !defined _LIBC && ! (defined isblank || (HAVE_ISBLANK && HAVE_DECL_ISBLANK)) #if !defined _LIBC && ! (defined isblank || (HAVE_ISBLANK && HAVE_DECL_ISBLANK))
# define isblank(ch) ((ch) == ' ' || (ch) == '\t') # define isblank(ch) ((ch) == ' ' || (ch) == '\t')
@ -58,7 +84,7 @@
# define SIZE_MAX ((size_t) -1) # define SIZE_MAX ((size_t) -1)
#endif #endif
#if (defined MB_CUR_MAX && HAVE_LOCALE_H && HAVE_WCTYPE_H && HAVE_ISWCTYPE && HAVE_WCSCOLL) || defined (_LIBC) #if (defined MB_CUR_MAX && HAVE_LOCALE_H && HAVE_WCTYPE_H && HAVE_ISWCTYPE && HAVE_WCSCOLL) || _LIBC
# define RE_ENABLE_I18N # define RE_ENABLE_I18N
#endif #endif
@ -825,4 +851,21 @@ re_string_elem_size_at (const re_string_t *pstr, Idx idx)
} }
#endif /* RE_ENABLE_I18N */ #endif /* RE_ENABLE_I18N */
#ifndef __GNUC_PREREQ
# if defined __GNUC__ && defined __GNUC_MINOR__
# define __GNUC_PREREQ(maj, min) \
((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min))
# else
# define __GNUC_PREREQ(maj, min) 0
# endif
#endif
#if __GNUC_PREREQ (3,4)
# undef __attribute_warn_unused_result__
# define __attribute_warn_unused_result__ \
__attribute__ ((__warn_unused_result__))
#else
# define __attribute_warn_unused_result__ /* empty */
#endif
#endif /* _REGEX_INTERNAL_H */ #endif /* _REGEX_INTERNAL_H */

161
gnulib/regexec.c
View file

@ -1,6 +1,6 @@
/* Extended regular expression matching and search library. /* Extended regular expression matching and search library.
Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free
Free Software Foundation, Inc. Software Foundation, Inc.
This file is part of the GNU C Library. This file is part of the GNU C Library.
Contributed by Isamu Hasegawa <isamu@yamato.ibm.com>. Contributed by Isamu Hasegawa <isamu@yamato.ibm.com>.
@ -637,7 +637,7 @@ re_exec (s)
(0 <= LAST_START && LAST_START <= LENGTH) */ (0 <= LAST_START && LAST_START <= LENGTH) */
static reg_errcode_t static reg_errcode_t
internal_function internal_function __attribute_warn_unused_result__
re_search_internal (const regex_t *preg, re_search_internal (const regex_t *preg,
const char *string, Idx length, const char *string, Idx length,
Idx start, Idx last_start, Idx stop, Idx start, Idx last_start, Idx stop,
@ -833,10 +833,10 @@ re_search_internal (const regex_t *preg,
break; break;
match_first += incr; match_first += incr;
if (match_first < left_lim || match_first > right_lim) if (match_first < left_lim || match_first > right_lim)
{ {
err = REG_NOMATCH; err = REG_NOMATCH;
goto free_return; goto free_return;
} }
} }
break; break;
} }
@ -953,14 +953,14 @@ re_search_internal (const regex_t *preg,
} }
if (dfa->subexp_map) if (dfa->subexp_map)
for (reg_idx = 0; reg_idx + 1 < nmatch; reg_idx++) for (reg_idx = 0; reg_idx + 1 < nmatch; reg_idx++)
if (dfa->subexp_map[reg_idx] != reg_idx) if (dfa->subexp_map[reg_idx] != reg_idx)
{ {
pmatch[reg_idx + 1].rm_so pmatch[reg_idx + 1].rm_so
= pmatch[dfa->subexp_map[reg_idx] + 1].rm_so; = pmatch[dfa->subexp_map[reg_idx] + 1].rm_so;
pmatch[reg_idx + 1].rm_eo pmatch[reg_idx + 1].rm_eo
= pmatch[dfa->subexp_map[reg_idx] + 1].rm_eo; = pmatch[dfa->subexp_map[reg_idx] + 1].rm_eo;
} }
} }
free_return: free_return:
@ -972,7 +972,7 @@ re_search_internal (const regex_t *preg,
} }
static reg_errcode_t static reg_errcode_t
internal_function internal_function __attribute_warn_unused_result__
prune_impossible_nodes (re_match_context_t *mctx) prune_impossible_nodes (re_match_context_t *mctx)
{ {
const re_dfa_t *const dfa = mctx->dfa; const re_dfa_t *const dfa = mctx->dfa;
@ -1110,7 +1110,7 @@ acquire_init_state_context (reg_errcode_t *err, const re_match_context_t *mctx,
index of the buffer. */ index of the buffer. */
static Idx static Idx
internal_function internal_function __attribute_warn_unused_result__
check_matching (re_match_context_t *mctx, bool fl_longest_match, check_matching (re_match_context_t *mctx, bool fl_longest_match,
Idx *p_match_first) Idx *p_match_first)
{ {
@ -1149,7 +1149,7 @@ check_matching (re_match_context_t *mctx, bool fl_longest_match,
{ {
err = transit_state_bkref (mctx, &cur_state->nodes); err = transit_state_bkref (mctx, &cur_state->nodes);
if (BE (err != REG_NOERROR, 0)) if (BE (err != REG_NOERROR, 0))
return err; return err;
} }
} }
} }
@ -1176,16 +1176,16 @@ check_matching (re_match_context_t *mctx, bool fl_longest_match,
Idx next_char_idx = re_string_cur_idx (&mctx->input) + 1; Idx next_char_idx = re_string_cur_idx (&mctx->input) + 1;
if (BE (next_char_idx >= mctx->input.bufs_len, 0) if (BE (next_char_idx >= mctx->input.bufs_len, 0)
|| (BE (next_char_idx >= mctx->input.valid_len, 0) || (BE (next_char_idx >= mctx->input.valid_len, 0)
&& mctx->input.valid_len < mctx->input.len)) && mctx->input.valid_len < mctx->input.len))
{ {
err = extend_buffers (mctx); err = extend_buffers (mctx);
if (BE (err != REG_NOERROR, 0)) if (BE (err != REG_NOERROR, 0))
{ {
assert (err == REG_ESPACE); assert (err == REG_ESPACE);
return REG_ERROR; return REG_ERROR;
} }
} }
cur_state = transit_state (&err, mctx, cur_state); cur_state = transit_state (&err, mctx, cur_state);
if (mctx->state_log != NULL) if (mctx->state_log != NULL)
@ -1309,17 +1309,17 @@ proceed_next_node (const re_match_context_t *mctx, Idx nregs, regmatch_t *regs,
if (dest_node == REG_MISSING) if (dest_node == REG_MISSING)
dest_node = candidate; dest_node = candidate;
else else
{ {
/* In order to avoid infinite loop like "(a*)*", return the second /* In order to avoid infinite loop like "(a*)*", return the second
epsilon-transition if the first was already considered. */ epsilon-transition if the first was already considered. */
if (re_node_set_contains (eps_via_nodes, dest_node)) if (re_node_set_contains (eps_via_nodes, dest_node))
return candidate; return candidate;
/* Otherwise, push the second epsilon-transition on the fail stack. */ /* Otherwise, push the second epsilon-transition on the fail stack. */
else if (fs != NULL else if (fs != NULL
&& push_fail_stack (fs, *pidx, candidate, nregs, regs, && push_fail_stack (fs, *pidx, candidate, nregs, regs,
eps_via_nodes)) eps_via_nodes))
return REG_ERROR; return REG_ERROR;
/* We know we are going to exit. */ /* We know we are going to exit. */
@ -1385,7 +1385,7 @@ proceed_next_node (const re_match_context_t *mctx, Idx nregs, regmatch_t *regs,
} }
static reg_errcode_t static reg_errcode_t
internal_function internal_function __attribute_warn_unused_result__
push_fail_stack (struct re_fail_stack_t *fs, Idx str_idx, Idx dest_node, push_fail_stack (struct re_fail_stack_t *fs, Idx str_idx, Idx dest_node,
Idx nregs, regmatch_t *regs, re_node_set *eps_via_nodes) Idx nregs, regmatch_t *regs, re_node_set *eps_via_nodes)
{ {
@ -1432,7 +1432,7 @@ pop_fail_stack (struct re_fail_stack_t *fs, Idx *pidx, Idx nregs,
pmatch[i].rm_so == pmatch[i].rm_eo == -1 for 0 < i < nmatch. */ pmatch[i].rm_so == pmatch[i].rm_eo == -1 for 0 < i < nmatch. */
static reg_errcode_t static reg_errcode_t
internal_function internal_function __attribute_warn_unused_result__
set_regs (const regex_t *preg, const re_match_context_t *mctx, size_t nmatch, set_regs (const regex_t *preg, const re_match_context_t *mctx, size_t nmatch,
regmatch_t *pmatch, bool fl_backtrack) regmatch_t *pmatch, bool fl_backtrack)
{ {
@ -1667,7 +1667,7 @@ sift_states_backward (const re_match_context_t *mctx, re_sift_context_t *sctx)
if (mctx->state_log[str_idx]) if (mctx->state_log[str_idx])
{ {
err = build_sifted_states (mctx, sctx, str_idx, &cur_dest); err = build_sifted_states (mctx, sctx, str_idx, &cur_dest);
if (BE (err != REG_NOERROR, 0)) if (BE (err != REG_NOERROR, 0))
goto free_return; goto free_return;
} }
@ -1686,7 +1686,7 @@ sift_states_backward (const re_match_context_t *mctx, re_sift_context_t *sctx)
} }
static reg_errcode_t static reg_errcode_t
internal_function internal_function __attribute_warn_unused_result__
build_sifted_states (const re_match_context_t *mctx, re_sift_context_t *sctx, build_sifted_states (const re_match_context_t *mctx, re_sift_context_t *sctx,
Idx str_idx, re_node_set *cur_dest) Idx str_idx, re_node_set *cur_dest)
{ {
@ -1848,7 +1848,7 @@ update_cur_sifted_state (const re_match_context_t *mctx,
} }
static reg_errcode_t static reg_errcode_t
internal_function internal_function __attribute_warn_unused_result__
add_epsilon_src_nodes (const re_dfa_t *dfa, re_node_set *dest_nodes, add_epsilon_src_nodes (const re_dfa_t *dfa, re_node_set *dest_nodes,
const re_node_set *candidates) const re_node_set *candidates)
{ {
@ -1863,10 +1863,14 @@ add_epsilon_src_nodes (const re_dfa_t *dfa, re_node_set *dest_nodes,
{ {
err = re_node_set_alloc (&state->inveclosure, dest_nodes->nelem); err = re_node_set_alloc (&state->inveclosure, dest_nodes->nelem);
if (BE (err != REG_NOERROR, 0)) if (BE (err != REG_NOERROR, 0))
return REG_ESPACE; return REG_ESPACE;
for (i = 0; i < dest_nodes->nelem; i++) for (i = 0; i < dest_nodes->nelem; i++)
re_node_set_merge (&state->inveclosure, {
dfa->inveclosures + dest_nodes->elems[i]); err = re_node_set_merge (&state->inveclosure,
dfa->inveclosures + dest_nodes->elems[i]);
if (BE (err != REG_NOERROR, 0))
return REG_ESPACE;
}
} }
return re_node_set_add_intersect (dest_nodes, candidates, return re_node_set_add_intersect (dest_nodes, candidates,
&state->inveclosure); &state->inveclosure);
@ -1978,7 +1982,7 @@ check_dst_limits_calc_pos_1 (const re_match_context_t *mctx, int boundaries,
{ {
struct re_backref_cache_entry *ent = mctx->bkref_ents + bkref_idx; struct re_backref_cache_entry *ent = mctx->bkref_ents + bkref_idx;
do do
{ {
Idx dst; Idx dst;
int cpos; int cpos;
@ -2000,9 +2004,9 @@ check_dst_limits_calc_pos_1 (const re_match_context_t *mctx, int boundaries,
if (dst == from_node) if (dst == from_node)
{ {
if (boundaries & 1) if (boundaries & 1)
return -1; return -1;
else /* if (boundaries & 2) */ else /* if (boundaries & 2) */
return 0; return 0;
} }
cpos = cpos =
@ -2016,7 +2020,7 @@ check_dst_limits_calc_pos_1 (const re_match_context_t *mctx, int boundaries,
if (subexp_idx < BITSET_WORD_BITS) if (subexp_idx < BITSET_WORD_BITS)
ent->eps_reachable_subexps_map ent->eps_reachable_subexps_map
&= ~((bitset_word_t) 1 << subexp_idx); &= ~((bitset_word_t) 1 << subexp_idx);
} }
while (ent++->more); while (ent++->more);
} }
break; break;
@ -2158,7 +2162,7 @@ check_subexp_limits (const re_dfa_t *dfa, re_node_set *dest_nodes,
} }
static reg_errcode_t static reg_errcode_t
internal_function internal_function __attribute_warn_unused_result__
sift_states_bkref (const re_match_context_t *mctx, re_sift_context_t *sctx, sift_states_bkref (const re_match_context_t *mctx, re_sift_context_t *sctx,
Idx str_idx, const re_node_set *candidates) Idx str_idx, const re_node_set *candidates)
{ {
@ -2241,7 +2245,7 @@ sift_states_bkref (const re_match_context_t *mctx, re_sift_context_t *sctx,
re_node_set_remove (&local_sctx.limits, enabled_idx); re_node_set_remove (&local_sctx.limits, enabled_idx);
/* mctx->bkref_ents may have changed, reload the pointer. */ /* mctx->bkref_ents may have changed, reload the pointer. */
entry = mctx->bkref_ents + enabled_idx; entry = mctx->bkref_ents + enabled_idx;
} }
while (enabled_idx++, entry++->more); while (enabled_idx++, entry++->more);
} }
@ -2288,7 +2292,7 @@ sift_states_iter_mb (const re_match_context_t *mctx, re_sift_context_t *sctx,
update the destination of STATE_LOG. */ update the destination of STATE_LOG. */
static re_dfastate_t * static re_dfastate_t *
internal_function internal_function __attribute_warn_unused_result__
transit_state (reg_errcode_t *err, re_match_context_t *mctx, transit_state (reg_errcode_t *err, re_match_context_t *mctx,
re_dfastate_t *state) re_dfastate_t *state)
{ {
@ -2322,7 +2326,7 @@ transit_state (reg_errcode_t *err, re_match_context_t *mctx,
trtable = state->word_trtable; trtable = state->word_trtable;
if (BE (trtable != NULL, 1)) if (BE (trtable != NULL, 1))
{ {
unsigned int context; unsigned int context;
context context
= re_string_context_at (&mctx->input, = re_string_context_at (&mctx->input,
@ -2368,21 +2372,21 @@ merge_state_with_log (reg_errcode_t *err, re_match_context_t *mctx,
unsigned int context; unsigned int context;
re_node_set next_nodes, *log_nodes, *table_nodes = NULL; re_node_set next_nodes, *log_nodes, *table_nodes = NULL;
/* If (state_log[cur_idx] != 0), it implies that cur_idx is /* If (state_log[cur_idx] != 0), it implies that cur_idx is
the destination of a multibyte char/collating element/ the destination of a multibyte char/collating element/
back reference. Then the next state is the union set of back reference. Then the next state is the union set of
these destinations and the results of the transition table. */ these destinations and the results of the transition table. */
pstate = mctx->state_log[cur_idx]; pstate = mctx->state_log[cur_idx];
log_nodes = pstate->entrance_nodes; log_nodes = pstate->entrance_nodes;
if (next_state != NULL) if (next_state != NULL)
{ {
table_nodes = next_state->entrance_nodes; table_nodes = next_state->entrance_nodes;
*err = re_node_set_init_union (&next_nodes, table_nodes, *err = re_node_set_init_union (&next_nodes, table_nodes,
log_nodes); log_nodes);
if (BE (*err != REG_NOERROR, 0)) if (BE (*err != REG_NOERROR, 0))
return NULL; return NULL;
} }
else else
next_nodes = *log_nodes; next_nodes = *log_nodes;
/* Note: We already add the nodes of the initial state, /* Note: We already add the nodes of the initial state,
then we don't need to add them here. */ then we don't need to add them here. */
@ -2390,12 +2394,12 @@ merge_state_with_log (reg_errcode_t *err, re_match_context_t *mctx,
re_string_cur_idx (&mctx->input) - 1, re_string_cur_idx (&mctx->input) - 1,
mctx->eflags); mctx->eflags);
next_state = mctx->state_log[cur_idx] next_state = mctx->state_log[cur_idx]
= re_acquire_state_context (err, dfa, &next_nodes, context); = re_acquire_state_context (err, dfa, &next_nodes, context);
/* We don't need to check errors here, since the return value of /* We don't need to check errors here, since the return value of
this function is next_state and ERR is already set. */ this function is next_state and ERR is already set. */
if (table_nodes != NULL) if (table_nodes != NULL)
re_node_set_free (&next_nodes); re_node_set_free (&next_nodes);
} }
if (BE (dfa->nbackref, 0) && next_state != NULL) if (BE (dfa->nbackref, 0) && next_state != NULL)
@ -2436,9 +2440,9 @@ find_recover_state (reg_errcode_t *err, re_match_context_t *mctx)
do do
{ {
if (++cur_str_idx > max) if (++cur_str_idx > max)
return NULL; return NULL;
re_string_skip_bytes (&mctx->input, 1); re_string_skip_bytes (&mctx->input, 1);
} }
while (mctx->state_log[cur_str_idx] == NULL); while (mctx->state_log[cur_str_idx] == NULL);
@ -2546,7 +2550,7 @@ transit_state_mb (re_match_context_t *mctx, re_dfastate_t *pstate)
re_dfastate_t *dest_state; re_dfastate_t *dest_state;
if (!dfa->nodes[cur_node_idx].accept_mb) if (!dfa->nodes[cur_node_idx].accept_mb)
continue; continue;
if (dfa->nodes[cur_node_idx].constraint) if (dfa->nodes[cur_node_idx].constraint)
{ {
@ -2714,7 +2718,7 @@ transit_state_bkref (re_match_context_t *mctx, const re_node_set *nodes)
delay these checking for prune_impossible_nodes(). */ delay these checking for prune_impossible_nodes(). */
static reg_errcode_t static reg_errcode_t
internal_function internal_function __attribute_warn_unused_result__
get_subexp (re_match_context_t *mctx, Idx bkref_node, Idx bkref_str_idx) get_subexp (re_match_context_t *mctx, Idx bkref_node, Idx bkref_str_idx)
{ {
const re_dfa_t *const dfa = mctx->dfa; const re_dfa_t *const dfa = mctx->dfa;
@ -2727,7 +2731,7 @@ get_subexp (re_match_context_t *mctx, Idx bkref_node, Idx bkref_str_idx)
const struct re_backref_cache_entry *entry const struct re_backref_cache_entry *entry
= mctx->bkref_ents + cache_idx; = mctx->bkref_ents + cache_idx;
do do
if (entry->node == bkref_node) if (entry->node == bkref_node)
return REG_NOERROR; /* We already checked it. */ return REG_NOERROR; /* We already checked it. */
while (entry++->more); while (entry++->more);
} }
@ -2915,7 +2919,7 @@ find_subexp_node (const re_dfa_t *dfa, const re_node_set *nodes,
Return REG_NOERROR if it can arrive, or REG_NOMATCH otherwise. */ Return REG_NOERROR if it can arrive, or REG_NOMATCH otherwise. */
static reg_errcode_t static reg_errcode_t
internal_function internal_function __attribute_warn_unused_result__
check_arrival (re_match_context_t *mctx, state_array_t *path, Idx top_node, check_arrival (re_match_context_t *mctx, state_array_t *path, Idx top_node,
Idx top_str, Idx last_node, Idx last_str, int type) Idx top_str, Idx last_node, Idx last_str, int type)
{ {
@ -3077,7 +3081,7 @@ check_arrival (re_match_context_t *mctx, state_array_t *path, Idx top_node,
Can't we unify them? */ Can't we unify them? */
static reg_errcode_t static reg_errcode_t
internal_function internal_function __attribute_warn_unused_result__
check_arrival_add_next_nodes (re_match_context_t *mctx, Idx str_idx, check_arrival_add_next_nodes (re_match_context_t *mctx, Idx str_idx,
re_node_set *cur_nodes, re_node_set *next_nodes) re_node_set *cur_nodes, re_node_set *next_nodes)
{ {
@ -3211,7 +3215,7 @@ check_arrival_expand_ecl (const re_dfa_t *dfa, re_node_set *cur_nodes,
problematic append it to DST_NODES. */ problematic append it to DST_NODES. */
static reg_errcode_t static reg_errcode_t
internal_function internal_function __attribute_warn_unused_result__
check_arrival_expand_ecl_sub (const re_dfa_t *dfa, re_node_set *dst_nodes, check_arrival_expand_ecl_sub (const re_dfa_t *dfa, re_node_set *dst_nodes,
Idx target, Idx ex_subexp, int type) Idx target, Idx ex_subexp, int type)
{ {
@ -3256,7 +3260,7 @@ check_arrival_expand_ecl_sub (const re_dfa_t *dfa, re_node_set *dst_nodes,
in MCTX->BKREF_ENTS. */ in MCTX->BKREF_ENTS. */
static reg_errcode_t static reg_errcode_t
internal_function internal_function __attribute_warn_unused_result__
expand_bkref_cache (re_match_context_t *mctx, re_node_set *cur_nodes, expand_bkref_cache (re_match_context_t *mctx, re_node_set *cur_nodes,
Idx cur_str, Idx subexp_num, int type) Idx cur_str, Idx subexp_num, int type)
{ {
@ -3622,7 +3626,7 @@ group_nodes_into_DFAstates (const re_dfa_t *dfa, const re_dfastate_t *state,
} }
#ifdef RE_ENABLE_I18N #ifdef RE_ENABLE_I18N
else if (type == OP_UTF8_PERIOD) else if (type == OP_UTF8_PERIOD)
{ {
if (ASCII_CHARS % BITSET_WORD_BITS == 0) if (ASCII_CHARS % BITSET_WORD_BITS == 0)
memset (accepts, -1, ASCII_CHARS / CHAR_BIT); memset (accepts, -1, ASCII_CHARS / CHAR_BIT);
else else
@ -3631,7 +3635,7 @@ group_nodes_into_DFAstates (const re_dfa_t *dfa, const re_dfastate_t *state,
bitset_clear (accepts, '\n'); bitset_clear (accepts, '\n');
if (dfa->syntax & RE_DOT_NOT_NULL) if (dfa->syntax & RE_DOT_NOT_NULL)
bitset_clear (accepts, '\0'); bitset_clear (accepts, '\0');
} }
#endif #endif
else else
continue; continue;
@ -3836,7 +3840,7 @@ check_node_accept_bytes (const re_dfa_t *dfa, Idx node_idx,
if (node->type == OP_PERIOD) if (node->type == OP_PERIOD)
{ {
if (char_len <= 1) if (char_len <= 1)
return 0; return 0;
/* FIXME: I don't think this if is needed, as both '\n' /* FIXME: I don't think this if is needed, as both '\n'
and '\0' are char_len == 1. */ and '\0' are char_len == 1. */
/* '.' accepts any one character except the following two cases. */ /* '.' accepts any one character except the following two cases. */
@ -3949,15 +3953,20 @@ check_node_accept_bytes (const re_dfa_t *dfa, Idx node_idx,
_NL_CURRENT (LC_COLLATE, _NL_COLLATE_EXTRAMB); _NL_CURRENT (LC_COLLATE, _NL_COLLATE_EXTRAMB);
indirect = (const int32_t *) indirect = (const int32_t *)
_NL_CURRENT (LC_COLLATE, _NL_COLLATE_INDIRECTMB); _NL_CURRENT (LC_COLLATE, _NL_COLLATE_INDIRECTMB);
idx = findidx (&cp); int32_t idx = findidx (&cp);
if (idx > 0) if (idx > 0)
for (i = 0; i < cset->nequiv_classes; ++i) for (i = 0; i < cset->nequiv_classes; ++i)
{ {
int32_t equiv_class_idx = cset->equiv_classes[i]; int32_t equiv_class_idx = cset->equiv_classes[i];
size_t weight_len = weights[idx]; size_t weight_len = weights[idx & 0xffffff];
if (weight_len == weights[equiv_class_idx]) if (weight_len == weights[equiv_class_idx & 0xffffff]
&& (idx >> 24) == (equiv_class_idx >> 24))
{ {
Idx cnt = 0; Idx cnt = 0;
idx &= 0xffffff;
equiv_class_idx &= 0xffffff;
while (cnt <= weight_len while (cnt <= weight_len
&& (weights[equiv_class_idx + 1 + cnt] && (weights[equiv_class_idx + 1 + cnt]
== weights[idx + 1 + cnt])) == weights[idx + 1 + cnt]))
@ -4123,7 +4132,7 @@ check_node_accept (const re_match_context_t *mctx, const re_token_t *node,
/* Extend the buffers, if the buffers have run out. */ /* Extend the buffers, if the buffers have run out. */
static reg_errcode_t static reg_errcode_t
internal_function internal_function __attribute_warn_unused_result__
extend_buffers (re_match_context_t *mctx) extend_buffers (re_match_context_t *mctx)
{ {
reg_errcode_t ret; reg_errcode_t ret;
@ -4186,7 +4195,7 @@ extend_buffers (re_match_context_t *mctx)
/* Initialize MCTX. */ /* Initialize MCTX. */
static reg_errcode_t static reg_errcode_t
internal_function internal_function __attribute_warn_unused_result__
match_ctx_init (re_match_context_t *mctx, int eflags, Idx n) match_ctx_init (re_match_context_t *mctx, int eflags, Idx n)
{ {
mctx->eflags = eflags; mctx->eflags = eflags;
@ -4266,7 +4275,7 @@ match_ctx_free (re_match_context_t *mctx)
*/ */
static reg_errcode_t static reg_errcode_t
internal_function internal_function __attribute_warn_unused_result__
match_ctx_add_entry (re_match_context_t *mctx, Idx node, Idx str_idx, Idx from, match_ctx_add_entry (re_match_context_t *mctx, Idx node, Idx str_idx, Idx from,
Idx to) Idx to)
{ {
@ -4338,7 +4347,7 @@ search_cur_bkref_entry (const re_match_context_t *mctx, Idx str_idx)
at STR_IDX. */ at STR_IDX. */
static reg_errcode_t static reg_errcode_t
internal_function internal_function __attribute_warn_unused_result__
match_ctx_add_subtop (re_match_context_t *mctx, Idx node, Idx str_idx) match_ctx_add_subtop (re_match_context_t *mctx, Idx node, Idx str_idx)
{ {
#ifdef DEBUG #ifdef DEBUG

33
lib/posix_wrap/assert.h Normal file
View file

@ -0,0 +1,33 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2009, 2010 Free Software Foundation, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef GRUB_POSIX_ASSERT_H
#define GRUB_POSIX_ASSERT_H 1
#include <grub/misc.h>
#define assert(x) assert_real(__FILE__, __LINE__, x)
static inline void
assert_real (const char *file, int line, int cond)
{
if (!cond)
grub_fatal ("Assertion failed at %s:%d\n", file, line);
}
#endif

98
include/grub/gnulib-wrap.h → lib/posix_wrap/ctype.h
View file

@ -1,6 +1,6 @@
/* /*
* GRUB -- GRand Unified Bootloader * GRUB -- GRand Unified Bootloader
* Copyright (C) 2009 Free Software Foundation, Inc. * Copyright (C) 2009, 2010 Free Software Foundation, Inc.
* *
* GRUB is free software: you can redistribute it and/or modify * GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by
@ -16,48 +16,11 @@
* along with GRUB. If not, see <http://www.gnu.org/licenses/>. * along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/ */
#ifndef GRUB_GNULIB_WRAP_H #ifndef GRUB_POSIX_CTYPE_H
#define GRUB_GNULIB_WRAP_H 1 #define GRUB_POSIX_CTYPE_H 1
#include <grub/mm.h>
#include <grub/misc.h> #include <grub/misc.h>
#define HAVE_ISBLANK 0
#define HAVE_LIBINTL_H 0
#define HAVE_LOCALE_H 0
#define __STRICT_ANSI__ 0
#define DEBUG 0
#define _Restrict_ __restrict
#define _Restrict_arr_ __restrict
typedef grub_size_t size_t;
typedef int bool;
static const bool true = 1;
static const bool false = 0;
#define assert(x) assert_real(__FILE__, __LINE__, x)
static inline void
assert_real (const char *file, int line, int cond)
{
if (!cond)
grub_fatal ("Assertion failed at %s:%d\n", file, line);
}
static inline char *
locale_charset (void)
{
return "UTF-8";
}
#define MB_CUR_MAX 6
static inline void *
realloc (void *ptr, grub_size_t size)
{
return grub_realloc (ptr, size);
}
static inline int static inline int
toupper (int c) toupper (int c)
{ {
@ -137,59 +100,4 @@ tolower (int c)
return grub_tolower (c); return grub_tolower (c);
} }
static inline grub_size_t
strlen (const char *s)
{
return grub_strlen (s);
}
static inline int
strcmp (const char *s1, const char *s2)
{
return grub_strcmp (s1, s2);
}
static inline void
abort (void)
{
grub_abort ();
}
static inline void
free (void *ptr)
{
grub_free (ptr);
}
static inline void *
malloc (grub_size_t size)
{
return grub_malloc (size);
}
static inline void *
calloc (grub_size_t size, grub_size_t nelem)
{
return grub_zalloc (size * nelem);
}
static inline char *strncpy (char *dest, const char *src, int c)
{
return grub_strncpy (dest, src, c);
}
#define ULONG_MAX GRUB_ULONG_MAX
#define UCHAR_MAX 0xff
/* UCS-4. */
typedef grub_uint32_t wchar_t;
#undef __libc_lock_init
#define __libc_lock_init(x)
#undef __libc_lock_lock
#define __libc_lock_lock(x)
#undef __libc_lock_unlock
#define __libc_lock_unlock(x)
#endif #endif

38
lib/posix_wrap/langinfo.h Normal file
View file

@ -0,0 +1,38 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2009, 2010 Free Software Foundation, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef GRUB_POSIX_LANGINFO_H
#define GRUB_POSIX_LANGINFO_H 1
#include <localcharset.h>
typedef enum { CODESET } nl_item;
static inline char *
nl_langinfo (nl_item item)
{
switch (item)
{
case CODESET:
return locale_charset ();
default:
return "";
}
}
#endif

0
lib/posix_wrap/limits.h Normal file
View file

28
lib/posix_wrap/localcharset.h Normal file
View file

@ -0,0 +1,28 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2009, 2010 Free Software Foundation, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef GRUB_POSIX_LOCALCHARSET_H
#define GRUB_POSIX_LOCALCHARSET_H 1
static inline char *
locale_charset (void)
{
return "UTF-8";
}
#endif

1
lib/posix_wrap/stdint.h Normal file
View file

@ -0,0 +1 @@
#include <sys/types.h>

24
lib/posix_wrap/stdio.h Normal file
View file

@ -0,0 +1,24 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2009, 2010 Free Software Foundation, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef GRUB_POSIX_STDIO_H
#define GRUB_POSIX_STDIO_H 1
#include <grub/misc.h>
#endif

56
lib/posix_wrap/stdlib.h Normal file
View file

@ -0,0 +1,56 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2009, 2010 Free Software Foundation, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef GRUB_POSIX_STDLIB_H
#define GRUB_POSIX_STDLIB_H 1
#include <grub/mm.h>
static inline void
free (void *ptr)
{
grub_free (ptr);
}
static inline void *
malloc (grub_size_t size)
{
return grub_malloc (size);
}
static inline void *
calloc (grub_size_t size, grub_size_t nelem)
{
return grub_zalloc (size * nelem);
}
static inline void *
realloc (void *ptr, grub_size_t size)
{
return grub_realloc (ptr, size);
}
static inline void
abort (void)
{
grub_abort ();
}
#define MB_CUR_MAX 6
#endif

40
lib/posix_wrap/string.h Normal file
View file

@ -0,0 +1,40 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2009, 2010 Free Software Foundation, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef GRUB_POSIX_STRING_H
#define GRUB_POSIX_STRING_H 1
static inline grub_size_t
strlen (const char *s)
{
return grub_strlen (s);
}
static inline int
strcmp (const char *s1, const char *s2)
{
return grub_strcmp (s1, s2);
}
static inline int
strcasecmp (const char *s1, const char *s2)
{
return grub_strcasecmp (s1, s2);
}
#endif

32
lib/posix_wrap/sys/types.h Normal file
View file

@ -0,0 +1,32 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2009, 2010 Free Software Foundation, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef GRUB_POSIX_SYS_TYPES_H
#define GRUB_POSIX_SYS_TYPES_H 1
#include <grub/misc.h>
typedef grub_size_t size_t;
typedef int bool;
static const bool true = 1;
static const bool false = 0;
#define ULONG_MAX GRUB_ULONG_MAX
#define UCHAR_MAX 0xff
#endif

25
lib/posix_wrap/wchar.h Normal file
View file

@ -0,0 +1,25 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2009, 2010 Free Software Foundation, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef GRUB_POSIX_WCHAR_H
#define GRUB_POSIX_WCHAR_H 1
/* UCS-4. */
typedef grub_uint32_t wchar_t;
#endif

0
lib/posix_wrap/wctype.h Normal file
View file