Changeset 2240

Timestamp:

Jul 10, 2005, 11:12:06 AM (20 years ago)

Author:

bird

Message:

Replaced BSD regex with the new GLIBC implementation.

Location:

trunk/src

Files:

• emx/ChangeLog.LIBC (modified) (1 diff, 1 prop)
• emx/include/limits.h (modified) (2 diffs, 1 prop)
• emx/include/regex.h (modified) (1 diff, 1 prop)
• emx/include/xregex.h (deleted)
• emx/include/xregex2.h (deleted)
• emx/src/lib/bsd/regex (deleted)
• emx/src/lib/lgpl/include/config.h (modified) (1 diff, 1 prop)
• emx/src/lib/lgpl/include/libc-alias-glibc.h (modified) (1 diff, 1 prop)
• emx/src/lib/lgpl/posix/posix.smak (modified) (1 diff, 1 prop)
• emx/src/lib/lgpl/posix/regcomp.c (modified) (17 diffs, 1 prop)
• emx/src/lib/lgpl/posix/regex.c (modified) (2 diffs, 1 prop)
• emx/src/lib/lgpl/posix/regex_internal.c (modified) (2 diffs, 1 prop)
• emx/src/lib/lgpl/posix/regex_internal.h (modified) (4 diffs, 1 prop)
• emx/src/lib/lgpl/posix/regexec.c (modified) (11 diffs, 1 prop)
• emx/src/lib/lgpl/sysdeps/os2/bits (added)
• emx/src/lib/lgpl/sysdeps/os2/bits/libc-lock.h (added)
• emx/src/lib/libc.def (modified) (3 diffs, 1 prop)
• emx/src/lib/libc.smak (modified) (1 diff, 1 prop)
• emx/src/lib/libc06b4.def (modified) (1 diff, 1 prop)
• emx/src/lib/libc06b5.def (modified) (1 diff, 1 prop)
• emx/src/lib/locale/__convcp.c (modified) (1 diff, 1 prop)
• emx/src/lib/locale/setlocale.c (modified) (1 diff, 1 prop)
• libctests/glibc/Makefile (modified) (7 diffs, 1 prop)
• libctests/glibc/posix/bug-regex18.c (modified) (1 diff, 1 prop)

trunk/src/emx/ChangeLog.LIBC

@@ -2 +2 @@
 
 TODO: open replace on RAMFS fails with error 32!
+
+2005-07-10: knut st. osmundsen <bird-gccos2-spam@anduin.net>
+    - libc:
+        o Replaced BSD regex with the new GLIBC implementation.
 
 2005-07-06: knut st. osmundsen <bird-gccos2-spam@anduin.net>

trunk/src/emx/include/limits.h

@@ -1 @@
-/* limits.h,v 1.3 2004/09/14 22:27:34 bird Exp */
+/* limits.h,v 1.4 2005/07/10 09:09:53 bird Exp */
 /** @file
  * FreeBSD 5.1
@@ -73 +73 @@
 #define EXPR_NEST_MAX              32   /* max expressions nested in expr(1) */
 #define LINE_MAX                 2048   /* max bytes in an input line */
-#define RE_DUP_MAX                255   /* max RE's in interval notation */
+#define RE_DUP_MAX               0x7fff /* max RE's in interval notation */ /* bird: was 255, glibc regexp. */
 
 #define _POSIX2_BC_BASE_MAX     99

trunk/src/emx/include/regex.h

@@ -1 @@
-/* regex.h,v 1.2 2004/09/14 22:27:35 bird Exp */
-/** @file
- * FreeBSD 5.3
- * @changed bird: Added REG_NOMATCH.
+/* Definitions for data structures and routines for the regular
+   expression library.
+   Copyright (C) 1985,1989-93,1995-98,2000,2001,2002,2003
+   Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#ifndef _REGEX_H
+#define _REGEX_H 1
+
+#include <sys/types.h>
+
+/* Allow the use in C++ code.  */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* POSIX says that <sys/types.h> must be included (by the caller) before
+   <regex.h>.  */
+
+#if !defined _POSIX_C_SOURCE && !defined _POSIX_SOURCE && defined VMS
+/* VMS doesn't have `size_t' in <sys/types.h>, even though POSIX says it
+   should be there.  */
+# include <stddef.h>
+#endif
+
+/* The following two types have to be signed and unsigned integer type
+   wide enough to hold a value of a pointer.  For most ANSI compilers
+   ptrdiff_t and size_t should be likely OK.  Still size of these two
+   types is 2 for Microsoft C.  Ugh... */
+typedef long int s_reg_t;
+typedef unsigned long int active_reg_t;
+
+/* The following bits are used to determine the regexp syntax we
+   recognize.  The set/not-set meanings are chosen so that Emacs syntax
+   remains the value 0.  The bits are given in alphabetical order, and
+   the definitions shifted by one from the previous bit; thus, when we
+   add or remove a bit, only one other definition need change.  */
+typedef unsigned long int reg_syntax_t;
+
+/* If this bit is not set, then \ inside a bracket expression is literal.
+   If set, then such a \ quotes the following character.  */
+#define RE_BACKSLASH_ESCAPE_IN_LISTS ((unsigned long int) 1)
+
+/* If this bit is not set, then + and ? are operators, and \+ and \? are
+     literals.
+   If set, then \+ and \? are operators and + and ? are literals.  */
+#define RE_BK_PLUS_QM (RE_BACKSLASH_ESCAPE_IN_LISTS << 1)
+
+/* If this bit is set, then character classes are supported.  They are:
+     [:alpha:], [:upper:], [:lower:],  [:digit:], [:alnum:], [:xdigit:],
+     [:space:], [:print:], [:punct:], [:graph:], and [:cntrl:].
+   If not set, then character classes are not supported.  */
+#define RE_CHAR_CLASSES (RE_BK_PLUS_QM << 1)
+
+/* If this bit is set, then ^ and $ are always anchors (outside bracket
+     expressions, of course).
+   If this bit is not set, then it depends:
+        ^  is an anchor if it is at the beginning of a regular
+           expression or after an open-group or an alternation operator;
+        $  is an anchor if it is at the end of a regular expression, or
+           before a close-group or an alternation operator.
+
+   This bit could be (re)combined with RE_CONTEXT_INDEP_OPS, because
+   POSIX draft 11.2 says that * etc. in leading positions is undefined.
+   We already implemented a previous draft which made those constructs
+   invalid, though, so we haven't changed the code back.  */
+#define RE_CONTEXT_INDEP_ANCHORS (RE_CHAR_CLASSES << 1)
+
+/* If this bit is set, then special characters are always special
+     regardless of where they are in the pattern.
+   If this bit is not set, then special characters are special only in
+     some contexts; otherwise they are ordinary.  Specifically,
+     * + ? and intervals are only special when not after the beginning,
+     open-group, or alternation operator.  */
+#define RE_CONTEXT_INDEP_OPS (RE_CONTEXT_INDEP_ANCHORS << 1)
+
+/* If this bit is set, then *, +, ?, and { cannot be first in an re or
+     immediately after an alternation or begin-group operator.  */
+#define RE_CONTEXT_INVALID_OPS (RE_CONTEXT_INDEP_OPS << 1)
+
+/* If this bit is set, then . matches newline.
+   If not set, then it doesn't.  */
+#define RE_DOT_NEWLINE (RE_CONTEXT_INVALID_OPS << 1)
+
+/* If this bit is set, then . doesn't match NUL.
+   If not set, then it does.  */
+#define RE_DOT_NOT_NULL (RE_DOT_NEWLINE << 1)
+
+/* If this bit is set, nonmatching lists [^...] do not match newline.
+   If not set, they do.  */
+#define RE_HAT_LISTS_NOT_NEWLINE (RE_DOT_NOT_NULL << 1)
+
+/* If this bit is set, either \{...\} or {...} defines an
+     interval, depending on RE_NO_BK_BRACES.
+   If not set, \{, \}, {, and } are literals.  */
+#define RE_INTERVALS (RE_HAT_LISTS_NOT_NEWLINE << 1)
+
+/* If this bit is set, +, ? and | aren't recognized as operators.
+   If not set, they are.  */
+#define RE_LIMITED_OPS (RE_INTERVALS << 1)
+
+/* If this bit is set, newline is an alternation operator.
+   If not set, newline is literal.  */
+#define RE_NEWLINE_ALT (RE_LIMITED_OPS << 1)
+
+/* If this bit is set, then `{...}' defines an interval, and \{ and \}
+     are literals.
+  If not set, then `\{...\}' defines an interval.  */
+#define RE_NO_BK_BRACES (RE_NEWLINE_ALT << 1)
+
+/* If this bit is set, (...) defines a group, and \( and \) are literals.
+   If not set, \(...\) defines a group, and ( and ) are literals.  */
+#define RE_NO_BK_PARENS (RE_NO_BK_BRACES << 1)
+
+/* If this bit is set, then \<digit> matches <digit>.
+   If not set, then \<digit> is a back-reference.  */
+#define RE_NO_BK_REFS (RE_NO_BK_PARENS << 1)
+
+/* If this bit is set, then | is an alternation operator, and \| is literal.
+   If not set, then \| is an alternation operator, and | is literal.  */
+#define RE_NO_BK_VBAR (RE_NO_BK_REFS << 1)
+
+/* If this bit is set, then an ending range point collating higher
+     than the starting range point, as in [z-a], is invalid.
+   If not set, then when ending range point collates higher than the
+     starting range point, the range is ignored.  */
+#define RE_NO_EMPTY_RANGES (RE_NO_BK_VBAR << 1)
+
+/* If this bit is set, then an unmatched ) is ordinary.
+   If not set, then an unmatched ) is invalid.  */
+#define RE_UNMATCHED_RIGHT_PAREN_ORD (RE_NO_EMPTY_RANGES << 1)
+
+/* If this bit is set, succeed as soon as we match the whole pattern,
+   without further backtracking.  */
+#define RE_NO_POSIX_BACKTRACKING (RE_UNMATCHED_RIGHT_PAREN_ORD << 1)
+
+/* If this bit is set, do not process the GNU regex operators.
+   If not set, then the GNU regex operators are recognized. */
+#define RE_NO_GNU_OPS (RE_NO_POSIX_BACKTRACKING << 1)
+
+/* If this bit is set, turn on internal regex debugging.
+   If not set, and debugging was on, turn it off.
+   This only works if regex.c is compiled -DDEBUG.
+   We define this bit always, so that all that's needed to turn on
+   debugging is to recompile regex.c; the calling code can always have
+   this bit set, and it won't affect anything in the normal case. */
+#define RE_DEBUG (RE_NO_GNU_OPS << 1)
+
+/* If this bit is set, a syntactically invalid interval is treated as
+   a string of ordinary characters.  For example, the ERE 'a{1' is
+   treated as 'a\{1'.  */
+#define RE_INVALID_INTERVAL_ORD (RE_DEBUG << 1)
+
+/* If this bit is set, then ignore case when matching.
+   If not set, then case is significant.  */
+#define RE_ICASE (RE_INVALID_INTERVAL_ORD << 1)
+
+/* This bit is used internally like RE_CONTEXT_INDEP_ANCHORS but only
+   for ^, because it is difficult to scan the regex backwards to find
+   whether ^ should be special.  */
+#define RE_CARET_ANCHORS_HERE (RE_ICASE << 1)
+
+/* If this bit is set, then \{ cannot be first in an bre or
+   immediately after an alternation or begin-group operator.  */
+#define RE_CONTEXT_INVALID_DUP (RE_CARET_ANCHORS_HERE << 1)
+
+/* If this bit is set, then no_sub will be set to 1 during
+   re_compile_pattern.  */
+#define RE_NO_SUB (RE_CONTEXT_INVALID_DUP << 1)
+
+/* This global variable defines the particular regexp syntax to use (for
+   some interfaces).  When a regexp is compiled, the syntax used is
+   stored in the pattern buffer, so changing this does not affect
+   already-compiled regexps.  */
+extern reg_syntax_t re_syntax_options;
+
+
+/* Define combinations of the above bits for the standard possibilities.
+   (The [[[ comments delimit what gets put into the Texinfo file, so
+   don't delete them!)  */
+/* [[[begin syntaxes]]] */
+#define RE_SYNTAX_EMACS 0
+
+#define RE_SYNTAX_AWK                                                   \
+  (RE_BACKSLASH_ESCAPE_IN_LISTS   | RE_DOT_NOT_NULL                     \
+   | RE_NO_BK_PARENS              | RE_NO_BK_REFS                       \
+   | RE_NO_BK_VBAR                | RE_NO_EMPTY_RANGES                  \
+   | RE_DOT_NEWLINE               | RE_CONTEXT_INDEP_ANCHORS            \
+   | RE_UNMATCHED_RIGHT_PAREN_ORD | RE_NO_GNU_OPS)
+
+#define RE_SYNTAX_GNU_AWK                                               \
+  ((RE_SYNTAX_POSIX_EXTENDED | RE_BACKSLASH_ESCAPE_IN_LISTS | RE_DEBUG) \
+   & ~(RE_DOT_NOT_NULL | RE_INTERVALS | RE_CONTEXT_INDEP_OPS            \
+       | RE_CONTEXT_INVALID_OPS ))
+
+#define RE_SYNTAX_POSIX_AWK                                             \
+  (RE_SYNTAX_POSIX_EXTENDED | RE_BACKSLASH_ESCAPE_IN_LISTS              \
+   | RE_INTERVALS           | RE_NO_GNU_OPS)
+
+#define RE_SYNTAX_GREP                                                  \
+  (RE_BK_PLUS_QM              | RE_CHAR_CLASSES                         \
+   | RE_HAT_LISTS_NOT_NEWLINE | RE_INTERVALS                            \
+   | RE_NEWLINE_ALT)
+
+#define RE_SYNTAX_EGREP                                                 \
+  (RE_CHAR_CLASSES        | RE_CONTEXT_INDEP_ANCHORS                    \
+   | RE_CONTEXT_INDEP_OPS | RE_HAT_LISTS_NOT_NEWLINE                    \
+   | RE_NEWLINE_ALT       | RE_NO_BK_PARENS                             \
+   | RE_NO_BK_VBAR)
+
+#define RE_SYNTAX_POSIX_EGREP                                           \
+  (RE_SYNTAX_EGREP | RE_INTERVALS | RE_NO_BK_BRACES                     \
+   | RE_INVALID_INTERVAL_ORD)
+
+/* P1003.2/D11.2, section 4.20.7.1, lines 5078ff.  */
+#define RE_SYNTAX_ED RE_SYNTAX_POSIX_BASIC
+
+#define RE_SYNTAX_SED RE_SYNTAX_POSIX_BASIC
+
+/* Syntax bits common to both basic and extended POSIX regex syntax.  */
+#define _RE_SYNTAX_POSIX_COMMON                                         \
+  (RE_CHAR_CLASSES | RE_DOT_NEWLINE      | RE_DOT_NOT_NULL              \
+   | RE_INTERVALS  | RE_NO_EMPTY_RANGES)
+
+#define RE_SYNTAX_POSIX_BASIC                                           \
+  (_RE_SYNTAX_POSIX_COMMON | RE_BK_PLUS_QM | RE_CONTEXT_INVALID_DUP)
+
+/* Differs from ..._POSIX_BASIC only in that RE_BK_PLUS_QM becomes
+   RE_LIMITED_OPS, i.e., \? \+ \| are not recognized.  Actually, this
+   isn't minimal, since other operators, such as \`, aren't disabled.  */
+#define RE_SYNTAX_POSIX_MINIMAL_BASIC                                   \
+  (_RE_SYNTAX_POSIX_COMMON | RE_LIMITED_OPS)
+
+#define RE_SYNTAX_POSIX_EXTENDED                                        \
+  (_RE_SYNTAX_POSIX_COMMON  | RE_CONTEXT_INDEP_ANCHORS                  \
+   | RE_CONTEXT_INDEP_OPS   | RE_NO_BK_BRACES                           \
+   | RE_NO_BK_PARENS        | RE_NO_BK_VBAR                             \
+   | RE_CONTEXT_INVALID_OPS | RE_UNMATCHED_RIGHT_PAREN_ORD)
+
+/* Differs from ..._POSIX_EXTENDED in that RE_CONTEXT_INDEP_OPS is
+   removed and RE_NO_BK_REFS is added.  */
+#define RE_SYNTAX_POSIX_MINIMAL_EXTENDED                                \
+  (_RE_SYNTAX_POSIX_COMMON  | RE_CONTEXT_INDEP_ANCHORS                  \
+   | RE_CONTEXT_INVALID_OPS | RE_NO_BK_BRACES                           \
+   | RE_NO_BK_PARENS        | RE_NO_BK_REFS                             \
+   | RE_NO_BK_VBAR          | RE_UNMATCHED_RIGHT_PAREN_ORD)
+/* [[[end syntaxes]]] */
+
+
+/* Maximum number of duplicates an interval can allow.  Some systems
+   (erroneously) define this in other header files, but we want our
+   value, so remove any previous define.  */
+#ifdef RE_DUP_MAX
+# undef RE_DUP_MAX
+#endif
+/* If sizeof(int) == 2, then ((1 << 15) - 1) overflows.  */
+#define RE_DUP_MAX (0x7fff)
+
+
+/* POSIX `cflags' bits (i.e., information for `regcomp').  */
+
+/* If this bit is set, then use extended regular expression syntax.
+   If not set, then use basic regular expression syntax.  */
+#define REG_EXTENDED 1
+
+/* If this bit is set, then ignore case when matching.
+   If not set, then case is significant.  */
+#define REG_ICASE (REG_EXTENDED << 1)
+
+/* If this bit is set, then anchors do not match at newline
+     characters in the string.
+   If not set, then anchors do match at newlines.  */
+#define REG_NEWLINE (REG_ICASE << 1)
+
+/* If this bit is set, then report only success or fail in regexec.
+   If not set, then returns differ between not matching and errors.  */
+#define REG_NOSUB (REG_NEWLINE << 1)
+
+
+/* POSIX `eflags' bits (i.e., information for regexec).  */
+
+/* If this bit is set, then the beginning-of-line operator doesn't match
+     the beginning of the string (presumably because it's not the
+     beginning of a line).
+   If not set, then the beginning-of-line operator does match the
+     beginning of the string.  */
+#define REG_NOTBOL 1
+
+/* Like REG_NOTBOL, except for the end-of-line.  */
+#define REG_NOTEOL (1 << 1)
+
+/* Use PMATCH[0] to delimit the start and end of the search in the
+   buffer.  */
+#define REG_STARTEND (1 << 2)
+
+
+/* If any error codes are removed, changed, or added, update the
+   `re_error_msg' table in regex.c.  */
+typedef enum
+{
+#ifdef _XOPEN_SOURCE
+  REG_ENOSYS = -1,      /* This will never happen for this implementation.  */
+#endif
+
+  REG_NOERROR = 0,      /* Success.  */
+  REG_NOMATCH,          /* Didn't find a match (for regexec).  */
+
+  /* POSIX regcomp return error codes.  (In the order listed in the
+     standard.)  */
+  REG_BADPAT,           /* Invalid pattern.  */
+  REG_ECOLLATE,         /* Inalid collating element.  */
+  REG_ECTYPE,           /* Invalid character class name.  */
+  REG_EESCAPE,          /* Trailing backslash.  */
+  REG_ESUBREG,          /* Invalid back reference.  */
+  REG_EBRACK,           /* Unmatched left bracket.  */
+  REG_EPAREN,           /* Parenthesis imbalance.  */
+  REG_EBRACE,           /* Unmatched \{.  */
+  REG_BADBR,            /* Invalid contents of \{\}.  */
+  REG_ERANGE,           /* Invalid range end.  */
+  REG_ESPACE,           /* Ran out of memory.  */
+  REG_BADRPT,           /* No preceding re for repetition op.  */
+
+  /* Error codes we've added.  */
+  REG_EEND,             /* Premature end.  */
+  REG_ESIZE,            /* Compiled pattern bigger than 2^16 bytes.  */
+  REG_ERPAREN           /* Unmatched ) or \); not returned from regcomp.  */
+} reg_errcode_t;
+
+
+/* This data structure represents a compiled pattern.  Before calling
+   the pattern compiler, the fields `buffer', `allocated', `fastmap',
+   `translate', and `no_sub' can be set.  After the pattern has been
+   compiled, the `re_nsub' field is available.  All other fields are
+   private to the regex routines.  */
+
+#ifndef RE_TRANSLATE_TYPE
+# define RE_TRANSLATE_TYPE char *
+#endif
+
+struct re_pattern_buffer
+{
+/* [[[begin pattern_buffer]]] */
+        /* Space that holds the compiled pattern.  It is declared as
+          `unsigned char *' because its elements are
+           sometimes used as array indexes.  */
+  unsigned char *buffer;
+
+        /* Number of bytes to which `buffer' points.  */
+  unsigned long int allocated;
+
+        /* Number of bytes actually used in `buffer'.  */
+  unsigned long int used;
+
+        /* Syntax setting with which the pattern was compiled.  */
+  reg_syntax_t syntax;
+
+        /* Pointer to a fastmap, if any, otherwise zero.  re_search uses
+           the fastmap, if there is one, to skip over impossible
+           starting points for matches.  */
+  char *fastmap;
+
+        /* Either a translate table to apply to all characters before
+           comparing them, or zero for no translation.  The translation
+           is applied to a pattern when it is compiled and to a string
+           when it is matched.  */
+  RE_TRANSLATE_TYPE translate;
+
+        /* Number of subexpressions found by the compiler.  */
+  size_t re_nsub;
+
+        /* Zero if this pattern cannot match the empty string, one else.
+           Well, in truth it's used only in `re_search_2', to see
+           whether or not we should use the fastmap, so we don't set
+           this absolutely perfectly; see `re_compile_fastmap' (the
+           `duplicate' case).  */
+  unsigned can_be_null : 1;
+
+        /* If REGS_UNALLOCATED, allocate space in the `regs' structure
+             for `max (RE_NREGS, re_nsub + 1)' groups.
+           If REGS_REALLOCATE, reallocate space if necessary.
+           If REGS_FIXED, use what's there.  */
+#define REGS_UNALLOCATED 0
+#define REGS_REALLOCATE 1
+#define REGS_FIXED 2
+  unsigned regs_allocated : 2;
+
+        /* Set to zero when `regex_compile' compiles a pattern; set to one
+           by `re_compile_fastmap' if it updates the fastmap.  */
+  unsigned fastmap_accurate : 1;
+
+        /* If set, `re_match_2' does not return information about
+           subexpressions.  */
+  unsigned no_sub : 1;
+
+        /* If set, a beginning-of-line anchor doesn't match at the
+           beginning of the string.  */
+  unsigned not_bol : 1;
+
+        /* Similarly for an end-of-line anchor.  */
+  unsigned not_eol : 1;
+
+        /* If true, an anchor at a newline matches.  */
+  unsigned newline_anchor : 1;
+
+/* [[[end pattern_buffer]]] */
+};
+
+typedef struct re_pattern_buffer regex_t;
+
+
+/* Type for byte offsets within the string.  POSIX mandates this.  */
+typedef int regoff_t;
+
+
+/* This is the structure we store register match data in.  See
+   regex.texinfo for a full description of what registers match.  */
+struct re_registers
+{
+  unsigned num_regs;
+  regoff_t *start;
+  regoff_t *end;
+};
+
+
+/* If `regs_allocated' is REGS_UNALLOCATED in the pattern buffer,
+   `re_match_2' returns information about at least this many registers
+   the first time a `regs' structure is passed.  */
+#ifndef RE_NREGS
+# define RE_NREGS 30
+#endif
+
+
+/* POSIX specification for registers.  Aside from the different names than
+   `re_registers', POSIX uses an array of structures, instead of a
+   structure of arrays.  */
+typedef struct
+{
+  regoff_t rm_so;  /* Byte offset from string's start to substring's start.  */
+  regoff_t rm_eo;  /* Byte offset from string's start to substring's end.  */
+} regmatch_t;
+
+
+/* Declarations for routines.  */
+
+/* To avoid duplicating every routine declaration -- once with a
+   prototype (if we are ANSI), and once without (if we aren't) -- we
+   use the following macro to declare argument types.  This
+   unfortunately clutters up the declarations a bit, but I think it's
+   worth it.  */
+
+#if __STDC__
+
+# define _RE_ARGS(args) args
+
+#else /* not __STDC__ */
+
+# define _RE_ARGS(args) ()
+#error "asdf"
+
+#endif /* not __STDC__ */
+
+/* Sets the current default syntax to SYNTAX, and return the old syntax.
+   You can also simply assign to the `re_syntax_options' variable.  */
+extern reg_syntax_t re_set_syntax _RE_ARGS ((reg_syntax_t syntax));
+
+/* Compile the regular expression PATTERN, with length LENGTH
+   and syntax given by the global `re_syntax_options', into the buffer
+   BUFFER.  Return NULL if successful, and an error string if not.  */
+extern const char *re_compile_pattern
+  _RE_ARGS ((const char *pattern, size_t length,
+             struct re_pattern_buffer *buffer));
+
+
+/* Compile a fastmap for the compiled pattern in BUFFER; used to
+   accelerate searches.  Return 0 if successful and -2 if was an
+   internal error.  */
+extern int re_compile_fastmap _RE_ARGS ((struct re_pattern_buffer *buffer));
+
+
+/* Search in the string STRING (with length LENGTH) for the pattern
+   compiled into BUFFER.  Start searching at position START, for RANGE
+   characters.  Return the starting position of the match, -1 for no
+   match, or -2 for an internal error.  Also return register
+   information in REGS (if REGS and BUFFER->no_sub are nonzero).  */
+extern int re_search
+  _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string,
+            int length, int start, int range, struct re_registers *regs));
+
+
+/* Like `re_search', but search in the concatenation of STRING1 and
+   STRING2.  Also, stop searching at index START + STOP.  */
+extern int re_search_2
+  _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1,
+             int length1, const char *string2, int length2,
+             int start, int range, struct re_registers *regs, int stop));
+
+
+/* Like `re_search', but return how many characters in STRING the regexp
+   in BUFFER matched, starting at position START.  */
+extern int re_match
+  _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string,
+             int length, int start, struct re_registers *regs));
+
+
+/* Relates to `re_match' as `re_search_2' relates to `re_search'.  */
+extern int re_match_2
+  _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1,
+             int length1, const char *string2, int length2,
+             int start, struct re_registers *regs, int stop));
+
+
+/* Set REGS to hold NUM_REGS registers, storing them in STARTS and
+   ENDS.  Subsequent matches using BUFFER and REGS will use this memory
+   for recording register information.  STARTS and ENDS must be
+   allocated with malloc, and must each be at least `NUM_REGS * sizeof
+   (regoff_t)' bytes long.
+
+   If NUM_REGS == 0, then subsequent matches should allocate their own
+   register data.
+
+   Unless this function is called, the first search or match using
+   PATTERN_BUFFER will allocate its own register data, without
+   freeing the old data.  */
+extern void re_set_registers
+  _RE_ARGS ((struct re_pattern_buffer *buffer, struct re_registers *regs,
+             unsigned num_regs, regoff_t *starts, regoff_t *ends));
+
+#if defined _REGEX_RE_COMP || defined _LIBC
+# ifndef _CRAY
+/* 4.2 bsd compatibility.  */
+extern char *re_comp _RE_ARGS ((const char *));
+extern int re_exec _RE_ARGS ((const char *));
+# endif
+#endif
+
+/* GCC 2.95 and later have "__restrict"; C99 compilers have
+   "restrict", and "configure" may have defined "restrict".  */
+#ifndef __restrict
+# if ! (2 < __GNUC__ || (2 == __GNUC__ && 95 <= __GNUC_MINOR__))
+#  if defined restrict || 199901L <= __STDC_VERSION__
+#   define __restrict restrict
+#  else
+#   define __restrict
+#  endif
+# endif
+#endif
+/* gcc 3.1 and up support the [restrict] syntax.  */
+#ifndef __restrict_arr
+# if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1)
+#  define __restrict_arr __restrict
+# else
+#  define __restrict_arr
+# endif
+#endif
+
+/* POSIX compatibility.  */
+extern int regcomp _RE_ARGS ((regex_t *__restrict __preg,
+                              const char *__restrict __pattern,
+                              int __cflags));
+
+extern int regexec _RE_ARGS ((const regex_t *__restrict __preg,
+                              const char *__restrict __string, size_t __nmatch,
+                              regmatch_t __pmatch[__restrict_arr],
+                              int __eflags));
+
+extern size_t regerror _RE_ARGS ((int __errcode, const regex_t *__preg,
+                                  char *__errbuf, size_t __errbuf_size));
+
+extern void regfree _RE_ARGS ((regex_t *__preg));
+
+
+#ifdef __cplusplus
+}
+#endif  /* C++ */
+
+#endif /* regex.h */
+
+
+/*
+Local variables:
+make-backup-files: t
+version-control: t
+trim-versions-without-asking: nil
+End:
  */
-/*-
- * Copyright (c) 1992 Henry Spencer.
- * Copyright (c) 1992, 1993
- *      The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Henry Spencer of the University of Toronto.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *      This product includes software developed by the University of
- *      California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *      @(#)regex.h     8.2 (Berkeley) 1/3/94
- * $FreeBSD: src/include/regex.h,v 1.11 2004/07/12 06:07:26 tjr Exp $
- */
-
-#ifndef _REGEX_H_
-#define _REGEX_H_
-
-#include <sys/cdefs.h>
-#include <sys/_types.h>
-
-/* types */
-typedef __off_t         regoff_t;
-
-#if !defined(_SIZE_T_DECLARED) && !defined(_SIZE_T) /* bird: emx */
-typedef __size_t        size_t;
-#define _SIZE_T_DECLARED
-#define _SIZE_T                         /* bird: emx */
-#endif
-
-typedef struct {
-        int re_magic;
-        size_t re_nsub;         /* number of parenthesized subexpressions */
-        __const char *re_endp;  /* end pointer for REG_PEND */
-        struct re_guts *re_g;   /* none of your business :-) */
-} regex_t;
-
-typedef struct {
-        regoff_t rm_so;         /* start of match */
-        regoff_t rm_eo;         /* end of match */
-} regmatch_t;
-
-/* regcomp() flags */
-#define REG_BASIC       0000
-#define REG_EXTENDED    0001
-#define REG_ICASE       0002
-#define REG_NOSUB       0004
-#define REG_NEWLINE     0010
-#define REG_NOSPEC      0020
-#define REG_PEND        0040
-#define REG_DUMP        0200
-
-/* regerror() flags */
-#define REG_ENOSYS      (-1)
-#if !defined(REG_NOMATCH) && __USE_GNU  /* bird */
-#define REG_NOERROR      0              /* bird */
-#endif                                  /* bird */
-#define REG_NOMATCH      1
-#define REG_BADPAT       2
-#define REG_ECOLLATE     3
-#define REG_ECTYPE       4
-#define REG_EESCAPE      5
-#define REG_ESUBREG      6
-#define REG_EBRACK       7
-#define REG_EPAREN       8
-#define REG_EBRACE       9
-#define REG_BADBR       10
-#define REG_ERANGE      11
-#define REG_ESPACE      12
-#define REG_BADRPT      13
-#define REG_EMPTY       14
-#define REG_ASSERT      15
-#define REG_INVARG      16
-#define REG_ILLSEQ      17
-#define REG_ATOI        255     /* convert name to number (!) */
-#define REG_ITOA        0400    /* convert number to name (!) */
-
-/* regexec() flags */
-#define REG_NOTBOL      00001
-#define REG_NOTEOL      00002
-#define REG_STARTEND    00004
-#define REG_TRACE       00400   /* tracing of execution */
-#define REG_LARGE       01000   /* force large representation */
-#define REG_BACKR       02000   /* force use of backref code */
-
-__BEGIN_DECLS
-int     regcomp(regex_t * __restrict, const char * __restrict, int);
-size_t  regerror(int, const regex_t * __restrict, char * __restrict, size_t);
-/*
- * XXX forth parameter should be `regmatch_t [__restrict]', but isn't because
- * of a bug in GCC 3.2 (when -std=c99 is specified) which perceives this as a
- * syntax error.
- */
-int     regexec(const regex_t * __restrict, const char * __restrict, size_t,
-            regmatch_t * __restrict, int);
-void    regfree(regex_t *);
-__END_DECLS
-
-#endif /* !_REGEX_H_ */

trunk/src/emx/src/lib/lgpl/include/config.h

@@ -63 +63 @@
 #define HAVE_LANGINFO_CODESET 1
 #define HAVE_SETLOCALE 1
+#define HAVE_LOCALE_H 1
 #define HAVE_LC_MESSAGES 1
 #define HAVE_LOCALE_NULL 1
+#define HAVE_WCHAR_H 1
+#define HAVE_WCTYPE_H 1
+#define HAVE_ISBLANK 1
+#define HAVE_WCRTOMB 1
+#define HAVE_MBRTOWC 1
+#define HAVE_WCSCOLL 0
 
 #define STRERROR_R_CHAR_P 0

trunk/src/emx/src/lib/lgpl/include/libc-alias-glibc.h

@@ -571 +571 @@
 #define __lgamma_r  _STD(lgamma_r)
 
+#define mempcpy     __mempcpy
 #endif

trunk/src/emx/src/lib/lgpl/posix/posix.smak

@@ -1 @@
-libc.TSRC += $(wildcard src/lib/lgpl/posix/*.c)
+libc.TSRC += $(filter-out $(addprefix src/lib/lgpl/posix/,regcomp.c regexec.c regex_internal.c), \
+        $(wildcard src/lib/lgpl/posix/*.c))

trunk/src/emx/src/lib/lgpl/posix/regcomp.c

@@ -242 +242 @@
 
 const char *
-re_compile_pattern (pattern, length, bufp)
+_STD(re_compile_pattern) (pattern, length, bufp)
     const char *pattern;
     size_t length;
@@ -264 +264 @@
 }
 #ifdef _LIBC
-weak_alias (__re_compile_pattern, re_compile_pattern)
+/* w e a k _alias (__re_compile_pattern, re_compile_pattern)*/
 #endif
 
@@ -272 +272 @@
 /* This has no initializer because initialized variables in Emacs
    become read-only after dumping.  */
-reg_syntax_t re_syntax_options;
+reg_syntax_t _STD(re_syntax_options);
 
 
@@ -283 +283 @@
 
 reg_syntax_t
-re_set_syntax (syntax)
+_STD(re_set_syntax) (syntax)
     reg_syntax_t syntax;
 {
@@ -292 +292 @@
 }
 #ifdef _LIBC
-weak_alias (__re_set_syntax, re_set_syntax)
+/*  w e a k _ a l i a s (__re_set_syntax, re_set_syntax) */
 #endif
 
 int
-re_compile_fastmap (bufp)
+_STD(re_compile_fastmap) (bufp)
     struct re_pattern_buffer *bufp;
 {
@@ -314 +314 @@
 }
 #ifdef _LIBC
-weak_alias (__re_compile_fastmap, re_compile_fastmap)
+/* w e a k _ a l i a s (__re_compile_fastmap, re_compile_fastmap) */
 #endif
 
@@ -419 +419 @@
                   if (__wcrtomb (buf, towlower (cset->mbchars[i]), &state)
                       != (size_t) -1)
-                    re_set_fastmap (fastmap, 0, *(unsigned char *) buf);
+                  re_set_fastmap (fastmap, 0, *(unsigned char *) buf);
                 }
             }
@@ -476 +476 @@
 
 int
-regcomp (preg, pattern, cflags)
+_STD(regcomp) (preg, pattern, cflags)
     regex_t *__restrict preg;
     const char *__restrict pattern;
@@ -531 +531 @@
 }
 #ifdef _LIBC
-weak_alias (__regcomp, regcomp)
+/* w e a k _ a l i a s (__regcomp, regcomp) */
 #endif
 
@@ -538 +538 @@
 
 size_t
-regerror (errcode, preg, errbuf, errbuf_size)
+_STD(regerror) (errcode, preg, errbuf, errbuf_size)
     int errcode;
     const regex_t *preg;
@@ -578 +578 @@
 }
 #ifdef _LIBC
-weak_alias (__regerror, regerror)
+/* w e a k _ a l i a s (__regerror, regerror) */
 #endif
 
@@ -650 +650 @@
 
 void
-regfree (preg)
+_STD(regfree) (preg)
     regex_t *preg;
 {
@@ -666 +666 @@
 }
 #ifdef _LIBC
-weak_alias (__regfree, regfree)
+/* w e a k_alias (__regfree, regfree) */
 #endif
 
@@ -673 +673 @@
    them unless specifically requested.  */
 
-#if defined _REGEX_RE_COMP || defined _LIBC
+#if defined _REGEX_RE_COMP || defined _LIBC || defined __INNOTEK_LIBC__
 
 /* BSD has one and only one pattern buffer.  */
@@ -685 +685 @@
 weak_function
 # endif
-re_comp (s)
+_STD(re_comp) (s)
      const char *s;
 {
@@ -924 +924 @@
             for (j = 0; j < UINT_BITS; ++j, ++ch)
               {
-                wchar_t wch = __btowc (ch);
+                wint_t wch = __btowc (ch);
                 if (wch != WEOF)
                   dfa->sb_char[i] |= 1 << j;
-# ifndef _LIBC
+# ifndef _LIBC && !defined __INNOTEK_LIBC__
                 if (isascii (ch) && wch != (wchar_t) ch)
                   dfa->map_notascii = 1;
@@ -2693 +2693 @@
 # ifdef RE_ENABLE_I18N
   {
-    wchar_t wc, start_wc, end_wc;
+    wint_t wc, start_wc, end_wc;
     wchar_t cmp_buf[6] = {L'\0', L'\0', L'\0', L'\0', L'\0', L'\0'};
 

trunk/src/emx/src/lib/lgpl/posix/regex.c

@@ -22 +22 @@
 #include "config.h"
 #endif
+
+#define RE_ENABLE_I18N 1
+
+/* BSD 4.2, not delcared in the header */
+char * re_comp (const char *);
+int re_exec (const char *);
+
 
 #ifdef _AIX
@@ -89 +96 @@
 
 /* Binary backward compatibility.  */
-#if _LIBC
+#if defined _LIBC && _LIBC
 # include <shlib-compat.h>
 # if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_3)

trunk/src/emx/src/lib/lgpl/posix/regex_internal.c

@@ -625 +625 @@
           pstr->valid_len -= offset;
           pstr->valid_raw_len -= offset;
-#if DEBUG
+#ifdef DEBUG //bird
           assert (pstr->valid_len > 0);
 #endif
@@ -1346 +1346 @@
      re_token_t token;
 {
+#ifdef RE_ENABLE_I18N //bird
   int type = token.type;
+#endif
   if (BE (dfa->nodes_len >= dfa->nodes_alloc, 0))
     {

trunk/src/emx/src/lib/lgpl/posix/regex_internal.h

@@ -40 +40 @@
 # include <wctype.h>
 #endif /* HAVE_WCTYPE_H || _LIBC */
-#if defined _LIBC
+#if defined _LIBC || defined __INNOTEK_LIBC__
 # include <bits/libc-lock.h>
 #else
@@ -64 +64 @@
 
 /* This is for other GNU distributions with internationalized messages.  */
-#if (HAVE_LIBINTL_H && ENABLE_NLS) || defined _LIBC
+#if !defined(__INNOTEK_LIBC__) && (HAVE_LIBINTL_H && ENABLE_NLS) || defined _LIBC
 # include <libintl.h>
 # ifdef _LIBC
@@ -81 +81 @@
 #endif
 
+#ifndef __INNOTEK_LIBC__
 #if (defined MB_CUR_MAX && HAVE_LOCALE_H && HAVE_WCTYPE_H && HAVE_WCHAR_H && HAVE_WCRTOMB && HAVE_MBRTOWC && HAVE_WCSCOLL) || _LIBC
 # define RE_ENABLE_I18N
+#endif
 #endif
 
@@ -368 +370 @@
 
 #ifndef _LIBC
-# ifdef __i386__
+# if defined __i386__ && !defined __INNOTEK_LIBC__
 #  define internal_function   __attribute ((regparm (3), stdcall))
 # else

trunk/src/emx/src/lib/lgpl/posix/regexec.c

@@ -212 +212 @@
 
 int
-regexec (preg, string, nmatch, pmatch, eflags)
+_STD(regexec) (preg, string, nmatch, pmatch, eflags)
     const regex_t *__restrict preg;
     const char *__restrict string;
@@ -298 +298 @@
 
 int
-re_match (bufp, string, length, start, regs)
+_STD(re_match) (bufp, string, length, start, regs)
     struct re_pattern_buffer *bufp;
     const char *string;
@@ -307 +307 @@
 }
 #ifdef _LIBC
-weak_alias (__re_match, re_match)
+/* w e a k _alias (__re_match, re_match) */
 #endif
 
 int
-re_search (bufp, string, length, start, range, regs)
+_STD(re_search) (bufp, string, length, start, range, regs)
     struct re_pattern_buffer *bufp;
     const char *string;
@@ -320 +320 @@
 }
 #ifdef _LIBC
-weak_alias (__re_search, re_search)
+/* w e a k _alias (__re_search, re_search) */
 #endif
 
 int
-re_match_2 (bufp, string1, length1, string2, length2, start, regs, stop)
+_STD(re_match_2) (bufp, string1, length1, string2, length2, start, regs, stop)
     struct re_pattern_buffer *bufp;
     const char *string1, *string2;
@@ -334 +334 @@
 }
 #ifdef _LIBC
-weak_alias (__re_match_2, re_match_2)
+/*  w e a k _alias (__re_match_2, re_match_2)*/
 #endif
 
 int
-re_search_2 (bufp, string1, length1, string2, length2, start, range, regs, stop)
+_STD(re_search_2) (bufp, string1, length1, string2, length2, start, range, regs, stop)
     struct re_pattern_buffer *bufp;
     const char *string1, *string2;
@@ -348 +348 @@
 }
 #ifdef _LIBC
-weak_alias (__re_search_2, re_search_2)
+/* w e a k _alias (__re_search_2, re_search_2) */
 #endif
 
@@ -556 +556 @@
 
 void
-re_set_registers (bufp, regs, num_regs, starts, ends)
+_STD(re_set_registers) (bufp, regs, num_regs, starts, ends)
     struct re_pattern_buffer *bufp;
     struct re_registers *regs;
@@ -577 +577 @@
 }
 #ifdef _LIBC
-weak_alias (__re_set_registers, re_set_registers)
+/* w e a k_alias (__re_set_registers, re_set_registers) */
 #endif
 
@@ -584 +584 @@
    them unless specifically requested.  */
 
-#if defined _REGEX_RE_COMP || defined _LIBC
+#if defined _REGEX_RE_COMP || defined _LIBC || __INNOTEK_LIBC__
 int
 # ifdef _LIBC
 weak_function
 # endif
-re_exec (s)
+_STD(re_exec) (s)
      const char *s;
 {
@@ -2292 +2292 @@
 
 /* Update the state_log if we need */
-re_dfastate_t *
+static re_dfastate_t *
 merge_state_with_log (err, mctx, next_state)
      reg_errcode_t *err;
@@ -3034 +3034 @@
   int result;
   int cur_idx;
+#ifdef RE_ENABLE_I18N
   reg_errcode_t err;
+#endif
   re_node_set union_set;
   re_node_set_init_empty (&union_set);

trunk/src/emx/src/lib/libc.def

@@ -75 +75 @@
     "__nl_msg_cat_cntr" @53
     "__nl_domain_bindings" @54
-
+    "__std_re_syntax_options" @55
 
     "__mcount" @99 ; this is a stub in all but the profiling build.
@@ -1239 +1239 @@
     "__std_random" @1252
     "_reallocf" @1253
-    "_regcomp" @1254
-    "_regerror" @1255
-    "_regexec" @1256
-    "_regfree" @1257
+    "__std_regcomp" @1254
+    "__std_regerror" @1255
+    "__std_regexec" @1256
+    "__std_regfree" @1257
     "_setgrent" @1258
     "_setgroupent" @1259
@@ -1928 +1928 @@
     "__std_getsid" @1927
     "__std_setlinebuf" @1928
-
+    ; regex (glibc)
+    "___re_error_msgid" @1929
+    "___re_error_msgid_idx" @1930
+    "__std_re_comp" @1931
+    "__std_re_compile_fastmap" @1932
+    "__std_re_compile_pattern" @1933
+    "__std_re_exec" @1934
+    "__std_re_match" @1935
+    "__std_re_match_2" @1936
+    "__std_re_search" @1937
+    "__std_re_search_2" @1938
+    "__std_re_set_registers" @1939
+    "__std_re_set_syntax" @1940

trunk/src/emx/src/lib/libc.smak

@@ -467 +467 @@
 # libc06b5                                              
 $.omf/libc06b5.dll: src/lib/libc06b5.def $.omf/fwdstub.obj $.omf/libc_dll.lib
-        gcc -Zomf -o $@ -nostdlib -Zdll $^
+        gcc -Zomf -o $@ -nostdlib -Zdll  $^
 $(INS)lib/libc06b5.dll: $.omf/libc06b5.dll
         $(call CP,$<,$@)

trunk/src/emx/src/lib/libc06b4.def

@@ -1237 +1237 @@
     "__std_random" @1252
     "_reallocf" @1253
-    "_regcomp" @1254
-    "_regerror" @1255
-    "_regexec" @1256
-    "_regfree" @1257
+    "__std_regcomp" @1254
+    "__std_regerror" @1255
+    "__std_regexec" @1256
+    "__std_regfree" @1257
     "_setgrent" @1258
     "_setgroupent" @1259

trunk/src/emx/src/lib/libc06b5.def

@@ -1240 +1240 @@
     "__std_random" @1252
     "_reallocf" @1253
-    "_regcomp" @1254
-    "_regerror" @1255
-    "_regexec" @1256
-    "_regfree" @1257
+    "__std_regcomp" @1254
+    "__std_regerror" @1255
+    "__std_regexec" @1256
+    "__std_regfree" @1257
     "_setgrent" @1258
     "_setgroupent" @1259

trunk/src/emx/src/lib/locale/__convcp.c

@@ -53 +53 @@
         { "CP367",              "IBM-367"},
         { "UTF-8",              "IBM-1208"},
+        { "UTF8",               "IBM-1208"},
         { "UCS-2",              "IBM-1200"},
+        { "UCS2",               "IBM-1200"},
         { "UCS-2BE",            "IBM-1200@endian=big"},
         { "UCS-2LE",            "IBM-1200@endian=little"},

trunk/src/emx/src/lib/locale/setlocale.c

@@ -535 +535 @@
      * Set codeset and query encoding.
      */
-    strncpy(pCtype->szCodeSet, pszCodeset, sizeof(pCtype->szCodeSet));
-    pCtype->szCodeSet[sizeof(pCtype->szCodeSet) - 1] = '\0';
+    if (!strstr(pszCodeset,
+                "ibm-1208" "Ibm-1208" "IBm-1208" "IBM-1208" "IbM-1208" "iBm-1208" "iBM-1208" "ibM-1208"
+                "utf-8" "Utf-8" "UTf-8" "UTF-8" "UtF-8" "uTf-8" "uTF-8" "utF-8"
+                "utf8" "Utf8" "UTf8" "UTF8" "UtF8" "uTf8" "uTF8" "utF8"))
+        memcpy(pCtype->szCodeSet, "UTF-8", sizeof("UTF-8"));
+    else if (!strstr(pszCodeset,
+                     "ibm-1200" "Ibm-1200" "IBm-1200" "IBM-1200" "IbM-1200" "iBm-1200" "iBM-1200" "ibM-1200"
+                     "ucs-2" "Ucs-2" "UCs-2" "UCS-2" "UcS-2" "uCs-2" "uCS-2" "ucS-2"
+                     "ucs2" "Ucs2" "UCs2" "UCS2" "UcS2" "uCs2" "uCS2" "ucS2"))
+        memcpy(pCtype->szCodeSet, "UCS-2", sizeof("UCS-2"));
+    else
+    {
+        strncpy(pCtype->szCodeSet, pszCodeset, sizeof(pCtype->szCodeSet));
+        pCtype->szCodeSet[sizeof(pCtype->szCodeSet) - 1] = '\0';
+    }
 
     uconv_attribute_t   attr;

trunk/src/libctests/glibc/Makefile

@@ -105 +105 @@
         posix/bug-ga1.c \
         posix/bug-ga2.c \
-        posix/bug-regex1.c \
-        posix/bug-regex10.c \
-        posix/bug-regex13.c \
-        posix/bug-regex14.c \
-        posix/bug-regex16.c \
-        posix/bug-regex17.c \
-        posix/bug-regex19.c \
-        posix/bug-regex20.c \
-        posix/bug-regex22.c \
-        posix/bug-regex4.c \
-        posix/bug-regex7.c \
-        posix/bug-regex8.c \
-        posix/runtests.c \
         posix/test-vfork.c \
         posix/tst-boost.c \
@@ -132 +119 @@
         posix/tst-mmap.c \
         posix/tst-preadwrite64.c \
-        posix/tst-rxspencer.c \
         posix/tst-truncate64.c \
         posix/tst-vfork1.c \
@@ -182 +168 @@
         posix/bug-glob1.c \
         posix/bug-glob2.c \
-        posix/bug-regex11.c \
-        posix/bug-regex15.c \
         posix/bug-regex18.c \
-        posix/bug-regex9.c \
+        posix/bug-regex22.c \
         posix/testfnm.c \
         posix/tst-chmod.c \
@@ -191 +175 @@
         posix/tst-fnmatch.c     \
         posix/tst-pcre.c \
+        posix/tst-rxspencer.c \
         misc/tst-tsearch.c  \
         misc/tst-dirname.c \
@@ -231 +216 @@
 _TARGET_OK := ok
 
-posix/runptests.c_ARGS = 15             # expect 15 errors
+posix/runptests.c_ARGS = 0              # expect 0 errors ?
 math/test-float.c_ARGS = -e 273         # expect 273 errors
 math/test-ifloat.c_ARGS = -e 217        # expect 217 errors
@@ -580 +565 @@
 posix/tst-dir.c_ARGS = `pwd` `pwd`/$(OUTDIR)/posix `pwd`/$(OUTDIR) `pwd`/$(OUTDIR)/tst-dir.exe
 posix/tst-chmod.c_ARGS = `pwd`/posix
-posix/tst-rxspencer.c_ARGS = --utf8 posix/rxspencer/tests
+posix/tst-rxspencer.c_ARGS = --utf8 $(CURDIR)/posix/rxspencer/tests
 posix/tst-pcre.c_ARGS = $(CURDIR)/posix/PCRE.tests
 posix/tst-boost.c_ARGS = $(CURDIR)/posix/BOOST.tests
@@ -830 +815 @@
                 if ( $(_EXEC) )$(if $($(1)_INPUT), < $($(1)_INPUT)); then \
                         echo OK > $$@; \
-                        printf "########## %-26s - SUCCESS\n" "$1"; \
+                        printf "########## %-26s - SUCCESS $(if $(filter $1,$(EXPECTED)),!Used to fail!)\n" "$1"; \
                 else \
                         echo "##  rc=$$$$?"; \

trunk/src/libctests/glibc/posix/bug-regex18.c

@@ -61 +61 @@
   int n, ret = 0;
 
-  setlocale (LC_ALL, "tr_TR.UTF-8");
+  if (!setlocale (LC_ALL, "tr_TR.UTF-8"))
+    {
+      printf ("bug-regex18: setlocale for tr_TR.UTF-8 failed, SKIPPING the test.\n");
+      return 0;
+    }
+
   for (i = 0; i < sizeof (tests) / sizeof (tests[0]); ++i)
     {