Changeset 1697

Timestamp:

Dec 3, 2004, 8:00:05 AM (21 years ago)

Author:

bird

Message:

imported FreeBSD 5.3 code and broke stuff.

Location:

trunk/src/emx

Files:

• include/ctype.h (modified) (2 diffs, 1 prop)
• include/dlfcn.h (modified) (3 diffs, 1 prop)
• include/regex.h (modified) (5 diffs, 1 prop)
• include/sys/_types.h (modified) (1 diff, 1 prop)
• include/unidef.h (modified) (1 diff, 1 prop)
• include/unistd.h (modified) (2 diffs, 1 prop)
• include/wchar.h (added)
• include/wctype.h (added)
• src/lib/bsd/db/btree/bt_split.c (modified) (3 diffs, 1 prop)
• src/lib/bsd/gen/getgrent.c (modified) (4 diffs, 1 prop)
• src/lib/bsd/gen/getnetgrent.c (modified) (11 diffs, 1 prop)
• src/lib/bsd/gen/getpwent.c (modified) (8 diffs, 1 prop)
• src/lib/bsd/gen/glob.c (modified) (17 diffs, 1 prop)
• src/lib/bsd/locale/collcmp.c (modified) (1 diff, 1 prop)
• src/lib/bsd/net/nsdispatch.c (modified) (19 diffs, 1 prop)
• src/lib/bsd/regex/engine.c (modified) (22 diffs, 1 prop)
• src/lib/bsd/regex/regcomp.c (modified) (48 diffs, 1 prop)
• src/lib/bsd/regex/regerror.c (modified) (3 diffs, 1 prop)
• src/lib/bsd/regex/regexec.c (modified) (7 diffs, 1 prop)
• src/lib/bsd/stdlib/radixsort.c (modified) (1 diff, 1 prop)
• src/lib/bsd/stdtime/difftime.c (modified) (3 diffs, 1 prop)
• src/lib/io/pread.c (added)
• src/lib/io/pwrite.c (added)
• src/lib/libc.def (modified) (1 diff, 1 prop)
• src/lib/misc/dlsym.c (modified) (1 diff, 1 prop)
• src/lib/misc/issetugid.c (added)

trunk/src/emx/include/ctype.h

@@ -27 +27 @@
 
 #include <sys/cdefs.h>
-
-#if !defined(__InnoTekLIBC_locale_h__)
-__BEGIN_DECLS
-/**
- * Simplified Ctype structure for inline functions.
- */
-extern struct
-{
-    /** All uppercased characters. */
-    unsigned char   auchUpper[256];
-    /** All lowercased characters. */
-    unsigned char   auchLower[256];
-    /** Bit flags for every character (for isXXX() function series). */
-    unsigned short  ausfType[256];
-} __libc_GLocaleCtype;
-
-/**
- * Simplified Default Ctype structure for inline functions.
- */
-extern const struct
-{
-    /** Bit flags for every character (for isXXX() function series). */
-    unsigned short  ausfType[256];
-} __libc_GLocaleCtypeDefault;
-__END_DECLS
-#endif /* !__InnoTekLIBC_locale_h__ */
-
-
-/** Bit masks for the ausfType member of __libc_GLocaleCtype
- *  and __libc_GLocaleCtypeDefault
- *
- * @remark These have identical values to the CT_* to speed up setlocale().
- * @{
- */
-#define __UPPER     0x0001      /** Upper case alphabetic character. */
-#define __LOWER     0x0002      /** Lower case alphabetic character. */
-#define __DIGIT     0x0004      /** Digits 0-9. */
-#define __SPACE     0x0008      /** White space and line ends. */
-#define __PUNCT     0x0010      /** Punctuation marks. */
-#define __CNTRL     0x0020      /** Control and format characters. */
-#define __BLANK     0x0040      /** Space and tab. */
-#define __XDIGIT    0x0080      /** Hex digits. */
-#define __ALPHA     0x0100      /** Letters and linguistic marks. */
-#define __ALNUM     0x0200      /** Alphanumeric. */
-#define __GRAPH     0x0400      /** All except controls and space. */
-#define __PRINT     0x0800      /** Everything except controls. */
-#define __NUMBER    0x1000      /** Integral number. */
-#define __SYMBOL    0x2000      /** Symbol. */
-#define __ASCII     0x8000      /** In standard ASCII set. */
-/** @} */
+#include <_ctype.h>
 
 
@@ -146 +97 @@
 #endif
 
-
-#if !defined(_DONT_USE_CTYPE_INLINE_) && \
-    (defined(_USE_CTYPE_INLINE_) || defined(__GNUC__) || defined(__cplusplus))
-
-__BEGIN_DECLS
-static inline int __istype(int _c, unsigned _f)
-{ return (__libc_GLocaleCtype.ausfType[_c & 0xff] & (_f)) != 0; }
-static inline int __isctype(int _c, unsigned _f)
-{ return (__libc_GLocaleCtypeDefault.ausfType[_c & 0xff] & (_f)) != 0; }
-static inline int __toupper(int _c)
-{ return __libc_GLocaleCtype.auchUpper[_c & 0xff]; }
-static inline int __tolower(int _c)
-{ return __libc_GLocaleCtype.auchLower[_c & 0xff]; }
-__END_DECLS
-
-#else
-
-__BEGIN_DECLS
-int __istype(int, unsigned);
-int __isctype(int, unsigned);
-int __toupper(int);
-int __tolower(int);
-__END_DECLS
-
 #endif
-
-#endif

trunk/src/emx/include/dlfcn.h

@@ -24 +24 @@
 #define _DLFCN_H_
 
+#include <sys/cdefs.h>
 
-/*******************************************************************************
-*   Defined Constants And Macros                                               *
-*******************************************************************************/
+
 /** @name dlopen flags
  * @{ */
@@ -44 +43 @@
 /** @} */
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+__BEGIN_DECLS
 
 void *          dlopen(const char * pszLibrary, int flFlags);
@@ -53 +50 @@
 int             dlclose(void *pvHandle);
 
-#ifdef __cplusplus
-}
+#if __BSD_VISIBLE
+struct __dlfunc_arg
+{
+    int         __dlfunc_dummy;
+};
+typedef void (*dlfunc_t)(struct __dlfunc_arg);
+dlfunc_t        dlfunc(void * __restrict, const char * __restrict);
 #endif
+
+__END_DECLS
 
 #endif

trunk/src/emx/include/regex.h

@@ -1 +1 @@
 /* regex.h,v 1.2 2004/09/14 22:27:35 bird Exp */
 /** @file
- * FreeBSD 5.1
+ * FreeBSD 5.3
  */
 /*-
@@ -40 +40 @@
  *
  *      @(#)regex.h     8.2 (Berkeley) 1/3/94
- * $FreeBSD: src/include/regex.h,v 1.6 2002/10/03 18:12:03 mike Exp $
+ * $FreeBSD: src/include/regex.h,v 1.11 2004/07/12 06:07:26 tjr Exp $
  */
 
@@ -52 +52 @@
 typedef __off_t         regoff_t;
 
-#ifndef _SIZE_T_DECLARED
+#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
 
@@ -80 +81 @@
 
 /* regerror() flags */
+#define REG_ENOSYS      (-1)
 #define REG_NOMATCH      1
 #define REG_BADPAT       2
@@ -96 +98 @@
 #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 (!) */

trunk/src/emx/include/sys/_types.h

@@ -97 +97 @@
  * character set plus one extra value (WEOF), and must be at least 16 bits.
  */
-#if 0                                   /* bird */
 typedef int             __ct_rune_t;
-#else                                   /* bird */
-typedef unsigned short  __ct_rune_t;
-#endif                                  /* bird */
 typedef __ct_rune_t     __rune_t;
+#if 0 /* bird: wchar_t is usually 2 bytes on OS/2. (might change this later!) */
 typedef __ct_rune_t     __wchar_t;
+#else /* bird */
+typedef unsigned short  __wchar_t;
+#endif /* bird */
 typedef __ct_rune_t     __wint_t;
 

trunk/src/emx/include/unidef.h

@@ -124 +124 @@
 #define C3_VOWELMARK        0x0004      /** Vowel mark. */
 #define C3_NSVOWEL          0x0005
-#define C3_SYMBOL           0x0008      /** Symbol (see CT_SYMBOL)*/
+#define C3_SYMBOL           0x0008      /** Symbol (see CT_SYMBOL). */
 #define C3_KATAKANA         0x0010      /** Katakana character (jap). */
 #define C3_HIRAGANA         0x0020      /** Hiragana character (jap). */

trunk/src/emx/include/unistd.h

@@ -449 +449 @@
 int      lockf(int, int, off_t);
 /** @todo int    nice(int); */
-/** @todo ssize_t        pread(int, void *, size_t, off_t); */
-/** @todo ssize_t        pwrite(int, const void *, size_t, off_t); */
+ssize_t  pread(int, void *, size_t, off_t);
+ssize_t  pwrite(int, const void *, size_t, off_t);
 /** @todo int    setpgrp(pid_t _pid, pid_t _pgrp); */ /* obsoleted by setpgid() */
 int      setregid(gid_t, gid_t);
@@ -500 +500 @@
 /** @todo int    iruserok(unsigned long, int, const char *, const char *); */
 /** @todo int    iruserok_sa(const void *, int, int, const char *, const char *); */
-/** @todo int    issetugid(void); */
+int      issetugid(void);
 /** @todo char  *mkdtemp(char *); */
 int      mknod(const char *, mode_t, dev_t);

trunk/src/emx/src/lib/bsd/db/btree/bt_split.c

@@ -40 +40 @@
 #endif /* LIBC_SCCS and not lint */
 #include <sys/cdefs.h>
-__FBSDID("$FreeBSD: src/lib/libc/db/btree/bt_split.c,v 1.5 2003/02/16 17:29:09 nectar Exp $");
+__FBSDID("$FreeBSD: src/lib/libc/db/btree/bt_split.c,v 1.5.6.1 2004/09/18 03:57:38 kuriyama Exp $");
 
 #include <sys/types.h>
@@ -728 +728 @@
          */
         if (skip <= off) {
-                skip = 0;
+                skip = MAX_PAGE_OFFSET;
                 rval = l;
         } else {
@@ -738 +738 @@
                 if (skip == nxt) {
                         ++off;
-                        skip = 0;
+                        skip = MAX_PAGE_OFFSET;
                 }
                 switch (h->flags & P_TYPE) {

trunk/src/emx/src/lib/bsd/gen/getgrent.c

@@ -32 +32 @@
  */
 #include <sys/cdefs.h>
-__FBSDID("$FreeBSD: src/lib/libc/gen/getgrent.c,v 1.31 2003/05/01 19:03:13 nectar Exp $");
+__FBSDID("$FreeBSD: src/lib/libc/gen/getgrent.c,v 1.32 2004/05/17 22:15:49 kientzle Exp $");
 
 #include "namespace.h"
@@ -48 +48 @@
 #include <grp.h>
 #include <nsswitch.h>
-#if 0
+#ifndef __EMX__
 #include <pthread.h>
 #include <pthread_np.h>
-#else
 #endif
 #include <stdio.h>
@@ -311 +310 @@
                         if ((grp_storage_size << 1) > GRP_STORAGE_MAX) {
                                 grp_storage = NULL;
+                                errno = ERANGE;
                                 return (NULL);
                         }
@@ -319 +319 @@
                 }
         } while (res == NULL && rv == ERANGE);
+        if (rv != 0)
+                errno = rv;
         return (res);
 }

trunk/src/emx/src/lib/bsd/gen/getnetgrent.c

@@ -40 +40 @@
 #endif /* LIBC_SCCS and not lint */
 #include <sys/cdefs.h>
-__FBSDID("$FreeBSD: src/lib/libc/gen/getnetgrent.c,v 1.30 2003/01/03 23:55:58 tjr Exp $");
+__FBSDID("$FreeBSD: src/lib/libc/gen/getnetgrent.c,v 1.31 2004/07/28 11:56:03 des Exp $");
 
 #include <ctype.h>
@@ -141 +141 @@
 };
 static FILE *netf = (FILE *)0;
-static int parse_netgrp();
-static struct linelist *read_for_group();
-void setnetgrent(), endnetgrent();
-int getnetgrent(), innetgr();
+
+static int parse_netgrp(const char *);
+static struct linelist *read_for_group(const char *);
+void setnetgrent(const char *);
+void endnetgrent(void);
+int getnetgrent(char **, char **, char **);
+int innetgr(const char *, const char *, const char *, const char *);
 
 #define LINSIZ  1024    /* Length of netgroup file line */
@@ -155 +158 @@
  */
 void
-setnetgrent(group)
-        const char *group;              /* bird: added const to match prototype.. */
+setnetgrent(const char *group)
 {
 #ifdef YP
@@ -205 +207 @@
                         }
 #else
-                if ((netf = fopen(_PATH_NETGROUP, "r"))) {
+                if ((netf = fopen(_PATH_NETGROUP, "r"))) { /* bird: shutting up GCC */
 #endif
                         if (parse_netgrp(group))
@@ -225 +227 @@
  */
 int
-getnetgrent(hostp, userp, domp)
-        char **hostp, **userp, **domp;
+getnetgrent(char **hostp, char **userp, char **domp)
 {
 #ifdef YP
@@ -246 +247 @@
  */
 void
-endnetgrent()
+endnetgrent(void)
 {
         struct linelist *lp, *olp;
@@ -283 +284 @@
 
 #ifdef YP
-static int _listmatch(list, group, len)
-        char *list, *group;
-        int len;
-{
-        char *ptr = list, *cptr;
+static int
+_listmatch(const char *list, const char *group, int len)
+{
+        const char *ptr = list;
+        const char *cptr;
         int glen = strlen(group);
 
@@ -307 +308 @@
 }
 
-static int _buildkey(key, str, dom, rotation)
-char *key, *str, *dom;
-int *rotation;
+static int
+_buildkey(char *key, const char *str, const char *dom, int *rotation)
 {
         (*rotation)++;
@@ -332 +332 @@
  */
 int
-innetgr(group, host, user, dom)
-        const char *group, *host, *user, *dom;
+innetgr(const char *group, const char *host, const char *user, const char *dom)
 {
         char *hst, *usr, *dm;
@@ -414 +413 @@
  */
 static int
-parse_netgrp(group)
-        char *group;
+parse_netgrp(const char *group)
 {
         char *spos, *epos;
@@ -525 +523 @@
  */
 static struct linelist *
-read_for_group(group)
-        char *group;
+read_for_group(const char *group)
 {
         char *pos, *spos, *linep = NULL, *olinep = NULL; /* bird: shutting up GCC. */

trunk/src/emx/src/lib/bsd/gen/getpwent.c

@@ -32 +32 @@
  */
 #include <sys/cdefs.h>
-__FBSDID("$FreeBSD: src/lib/libc/gen/getpwent.c,v 1.83 2003/07/18 23:51:15 wpaul Exp $");
+__FBSDID("$FreeBSD: src/lib/libc/gen/getpwent.c,v 1.89 2004/05/17 18:27:05 kientzle Exp $");
 
 #include "namespace.h"
@@ -52 +52 @@
 #include <pthread.h>
 #include <pthread_np.h>
-#else
-
 #endif
 #include <pwd.h>
@@ -384 +382 @@
                         if ((pwd_storage_size << 1) > PWD_STORAGE_MAX) {
                                 pwd_storage = NULL;
+                                errno = ERANGE;
                                 return (NULL);
                         }
@@ -392 +391 @@
                 }
         } while (res == NULL && rv == ERANGE);
+        if (rv != 0)
+                errno = rv;
         return (res);
 }
@@ -1035 +1036 @@
         enum nss_lookup_type how;
         int             *errnop, keylen, resultlen, rv, master;
-        
+
         name = NULL;
         uid = (uid_t)-1;
@@ -1129 +1130 @@
                             errnop);
         } while (how == nss_lt_all && !(rv & NS_TERMINATE));
-fin:    
+fin:
         if (rv == NS_SUCCESS) {
                 if (strstr(pwd->pw_passwd, "##") != NULL) {
-                        rv = nis_adjunct(st->domain, name,
+                        rv = nis_adjunct(st->domain, pwd->pw_name,
                             &buffer[resultlen+1], bufsize-resultlen-1);
                         if (rv < 0)
@@ -1143 +1144 @@
                 if (retval != NULL)
                         *(struct passwd **)retval = pwd;
-        }
-        return (rv);    
+                rv = NS_SUCCESS;
+        }
+        return (rv);
 erange:
         *errnop = ERANGE;
@@ -1637 +1639 @@
                                 setnetgrent(&pw_name[2]);
                                 while (getnetgrent(&host, &user, &domain) !=
-                                    0) { /* bird: getnetgrent returns int not pointer. */
+                                    0) {
                                         if (user != NULL && user[0] != '\0')
                                                 compat_exclude(user,

trunk/src/emx/src/lib/bsd/gen/glob.c

@@ -35 +35 @@
  */
 
+#include "namespace.h" /* bird */
 #if defined(LIBC_SCCS) && !defined(lint)
 static char sccsid[] = "@(#)glob.c      8.3 (Berkeley) 10/13/93";
 #endif /* LIBC_SCCS and not lint */
 #include <sys/cdefs.h>
-__FBSDID("$FreeBSD: src/lib/libc/gen/glob.c,v 1.20 2002/07/17 04:58:09 mikeh Exp $");
+__FBSDID("$FreeBSD: src/lib/libc/gen/glob.c,v 1.22 2004/07/29 03:48:52 tjr Exp $");
 
 /*
@@ -66 +67 @@
  */
 
-#include "libc-alias.h"
+/*
+ * Some notes on multibyte character support:
+ * 1. Patterns with illegal byte sequences match nothing - even if
+ *    GLOB_NOCHECK is specified.
+ * 2. Illegal byte sequences in filenames are handled by treating them as
+ *    single-byte characters with a value of the first byte of the sequence
+ *    cast to wchar_t.
+ * 3. State-dependent encodings are not currently supported.
+ */
 
 #include <sys/param.h>
@@ -75 +84 @@
 #include <errno.h>
 #include <glob.h>
+#include <limits.h>
 #include <pwd.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
+#include <wchar.h>
 
 #include "collate.h"
@@ -101 +113 @@
 #define COMMA           ','
 
-#ifndef BSD_DEBUG
-
-#define M_QUOTE         0x8000
-#define M_PROTECT       0x4000
-#define M_MASK          0xffff
-#define M_ASCII         0x00ff
-
-typedef u_short Char;
+#ifndef BSD_DEBUG /* bird prefixed with BSD */
+
+#define M_QUOTE         0x8000000000ULL
+#define M_PROTECT       0x4000000000ULL
+#define M_MASK          0xffffffffffULL
+#define M_CHAR          0x00ffffffffULL
+
+typedef uint_fast64_t Char;
 
 #else
@@ -115 +127 @@
 #define M_PROTECT       0x40
 #define M_MASK          0xff
-#define M_ASCII         0x7f
+#define M_CHAR          0x7f
 
 typedef char Char;
@@ -122 +134 @@
 
 
-#define CHAR(c)         ((Char)((c)&M_ASCII))
+#define CHAR(c)         ((Char)((c)&M_CHAR))
 #define META(c)         ((Char)((c)|M_QUOTE))
 #define M_ALL           META('*')
@@ -137 +149 @@
 static int       g_lstat(Char *, struct stat *, glob_t *);
 static DIR      *g_opendir(Char *, glob_t *);
-static Char     *g_strchr(Char *, int);
+static Char     *g_strchr(Char *, wchar_t);
 #ifdef notdef
 static Char     *g_strcat(Char *, const Char *);
@@ -152 +164 @@
 static int       globexp2(const Char *, const Char *, glob_t *, int *, int *);
 static int       match(Char *, Char *, Char *);
-#ifdef BSD_DEBUG
+#ifdef BSD_DEBUG /* bird prefixed with BSD */
 static void      qprintf(const char *, Char *);
 #endif
@@ -163 +175 @@
 {
         const u_char *patnext;
-        int c, limit;
-        Char *bufnext, *bufend, patbuf[MAXPATHLEN];
+        int limit;
+        Char *bufnext, *bufend, patbuf[MAXPATHLEN], prot;
+        mbstate_t mbs;
+        wchar_t wc;
+        size_t clen;
 
         patnext = (u_char *) pattern;
@@ -185 +200 @@
         bufnext = patbuf;
         bufend = bufnext + MAXPATHLEN - 1;
-        if (flags & GLOB_NOESCAPE)
-            while (bufnext < bufend && (c = *patnext++) != EOS)
-                    *bufnext++ = c;
-        else {
+        if (flags & GLOB_NOESCAPE) {
+                memset(&mbs, 0, sizeof(mbs));
+                while (bufend - bufnext >= MB_CUR_MAX) {
+                        clen = mbrtowc(&wc, patnext, MB_LEN_MAX, &mbs);
+                        if (clen == (size_t)-1 || clen == (size_t)-2)
+                                return (GLOB_NOMATCH);
+                        else if (clen == 0)
+                                break;
+                        *bufnext++ = wc;
+                        patnext += clen;
+                }
+        } else {
                 /* Protect the quoted characters. */
-                while (bufnext < bufend && (c = *patnext++) != EOS)
-                        if (c == QUOTE) {
-                                if ((c = *patnext++) == EOS) {
-                                        c = QUOTE;
-                                        --patnext;
+                memset(&mbs, 0, sizeof(mbs));
+                while (bufend - bufnext >= MB_CUR_MAX) {
+                        if (*patnext == QUOTE) {
+                                if (*++patnext == EOS) {
+                                        *bufnext++ = QUOTE | M_PROTECT;
+                                        continue;
                                 }
-                                *bufnext++ = c | M_PROTECT;
-                        }
-                        else
-                                *bufnext++ = c;
+                                prot = M_PROTECT;
+                        } else
+                                prot = 0;
+                        clen = mbrtowc(&wc, patnext, MB_LEN_MAX, &mbs);
+                        if (clen == (size_t)-1 || clen == (size_t)-2)
+                                return (GLOB_NOMATCH);
+                        else if (clen == 0)
+                                break;
+                        *bufnext++ = wc | prot;
+                        patnext += clen;
+                }
         }
         *bufnext = EOS;
@@ -325 +356 @@
 
                                 /* Expand the current pattern */
-#ifdef BSD_DEBUG
+#ifdef BSD_DEBUG /* bird prefixed with BSD */
                                 qprintf("globexp2:", patbuf);
 #endif
@@ -378 +409 @@
                  * the password file
                  */
-                if (
-#if !defined(__NETBSD_SYSCALLS)
-                    issetugid() != 0 ||
-#endif
+                if (issetugid() != 0 ||
                     (h = getenv("HOME")) == NULL) {
                         if (((h = getlogin()) != NULL &&
@@ -482 +510 @@
         }
         *bufnext = EOS;
-#ifdef BSD_DEBUG
+#ifdef BSD_DEBUG /* bird prefixed with BSD */
         qprintf("glob0:", patbuf);
 #endif
@@ -642 +670 @@
                 u_char *sc;
                 Char *dc;
+                wchar_t wc;
+                size_t clen;
+                mbstate_t mbs;
 
                 /* Initial DOT must be matched literally. */
                 if (dp->d_name[0] == DOT && *pattern != DOT)
                         continue;
+                memset(&mbs, 0, sizeof(mbs));
                 dc = pathend;
                 sc = (u_char *) dp->d_name;
-                while (dc < pathend_last && (*dc++ = *sc++) != EOS)
-                        ;
+                while (dc < pathend_last) {
+                        clen = mbrtowc(&wc, sc, MB_LEN_MAX, &mbs);
+                        if (clen == (size_t)-1 || clen == (size_t)-2) {
+                                wc = *sc;
+                                clen = 1;
+                                memset(&mbs, 0, sizeof(mbs));
+                        }
+                        if ((*dc++ = wc) == EOS)
+                                break;
+                        sc += clen;
+                }
                 if (!match(pathend, pattern, restpattern)) {
                         *pathend = EOS;
@@ -721 +762 @@
         for (p = path; *p++;)
                 continue;
-        len = (size_t)(p - path);
+        len = MB_CUR_MAX * (size_t)(p - path);  /* XXX overallocation */
         if ((copy = malloc(len)) != NULL) {
                 if (g_Ctoc(path, copy, len)) {
@@ -868 +909 @@
 g_strchr(str, ch)
         Char *str;
-        int ch;
+        wchar_t ch;
 {
         do {
@@ -883 +924 @@
         u_int len;
 {
-
-        while (len--) {
-                if ((*buf++ = *str++) == '\0')
+        mbstate_t mbs;
+        size_t clen;
+
+        memset(&mbs, 0, sizeof(mbs));
+        while (len >= MB_CUR_MAX) {
+                clen = wcrtomb(buf, *str, &mbs);
+                if (clen == (size_t)-1)
+                        return (1);
+                if (*str == L'\0')
                         return (0);
+                str++;
+                buf += clen;
+                len -= clen;
         }
         return (1);
 }
 
-#ifdef BSD_DEBUG
+#ifdef BSD_DEBUG /* bird prefixed with BSD */
 static void
 qprintf(str, s)

trunk/src/emx/src/lib/bsd/locale/collcmp.c

@@ -25 +25 @@
  */
 
-#include "libc-alias.h"
+#include "namespace.h" /* bird */
 #include <sys/cdefs.h>
-__FBSDID("$FreeBSD: src/lib/libc/locale/collcmp.c,v 1.14 2002/03/22 21:52:18 obrien Exp $");
-
-#define ASCII_COMPATIBLE_COLLATE        /* see share/colldef */
+__FBSDID("$FreeBSD: src/lib/libc/locale/collcmp.c,v 1.17 2003/08/03 19:28:23 ache Exp $");
 
 #include <string.h>
 #include "collate.h"
-#ifndef ASCII_COMPATIBLE_COLLATE
-#include <ctype.h>
-#endif
 
 /*
- * Compare two characters converting collate information
- * into ASCII-compatible range, it allows to handle
- * "[a-z]"-type ranges with national characters.
+ * Compare two characters using collate
  */
 
-int __collate_range_cmp (c1, c2)
+int __collate_range_cmp(c1, c2)
         int c1, c2;
 {
         static char s1[2], s2[2];
-        int ret;
-#ifndef ASCII_COMPATIBLE_COLLATE
-        int as1, as2, al1, al2;
-#endif
 
-        c1 &= UCHAR_MAX;
-        c2 &= UCHAR_MAX;
-        if (c1 == c2)
-                return (0);
-
-#ifndef ASCII_COMPATIBLE_COLLATE
-        as1 = isascii(c1);
-        as2 = isascii(c2);
-        al1 = isalpha(c1);
-        al2 = isalpha(c2);
-
-        if (as1 || as2 || al1 || al2) {
-                if ((as1 && as2) || (!al1 && !al2))
-                        return (c1 - c2);
-                if (al1 && !al2) {
-                        if (isupper(c1))
-                                return ('A' - c2);
-                        else
-                                return ('a' - c2);
-                } else if (al2 && !al1) {
-                        if (isupper(c2))
-                                return (c1 - 'A');
-                        else
-                                return (c1 - 'a');
-                }
-        }
-#endif
         s1[0] = c1;
         s2[0] = c2;
-        if ((ret = strcoll(s1, s2)) != 0)
-                return (ret);
-        return (c1 - c2);
+        return (strcoll(s1, s2));
 }

trunk/src/emx/src/lib/bsd/net/nsdispatch.c

@@ -69 +69 @@
  */
 #include <sys/cdefs.h>
-__FBSDID("$FreeBSD: src/lib/libc/net/nsdispatch.c,v 1.8 2003/04/24 19:57:31 nectar Exp $");
+__FBSDID("$FreeBSD: src/lib/libc/net/nsdispatch.c,v 1.12 2004/04/01 19:12:45 nectar Exp $");
 
 #include "namespace.h"
@@ -92 +92 @@
 #define pthread_mutex_t                 unsigned
 #define PTHREAD_MUTEX_INITIALIZER       0
+#define  __isthreaded 1
 #endif
 #include <stdio.h>
@@ -158 +159 @@
 static  void      vector_sort(void *, unsigned int, size_t,
                     vector_comparison);
-static  void      vector_free(void **, unsigned int *, size_t,
+static  void      vector_free(void *, unsigned int *, size_t,
                     vector_free_elem);
 static  void     *vector_ref(unsigned int, void *, unsigned int, size_t);
 static  void     *vector_search(const void *, void *, unsigned int, size_t,
                     vector_comparison);
-static  int       vector_append(const void *, void **, unsigned int *, size_t);
+static  void     *vector_append(const void *, void *, unsigned int *, size_t);
 
 
@@ -201 +202 @@
 
 
-static int
-vector_append(const void *elem, void **vec, unsigned int *count, size_t esize)
+static void *
+vector_append(const void *elem, void *vec, unsigned int *count, size_t esize)
 {
         void    *p;
 
         if ((*count % ELEMSPERCHUNK) == 0) {
-                p = realloc(*vec, (*count + ELEMSPERCHUNK) * esize);
+                p = realloc(vec, (*count + ELEMSPERCHUNK) * esize);
                 if (p == NULL) {
                         nss_log_simple(LOG_ERR, "memory allocation failure");
-                        return (0);
-                } else
-                        *vec = p;
-        }
-        memmove((void *)(((uintptr_t)*vec) + (*count * esize)),
-            elem, esize);
+                        return (vec);
+                }
+                vec = p;
+        }
+        memmove((void *)(((uintptr_t)vec) + (*count * esize)), elem, esize);
         (*count)++;
-        return (1);
+        return (vec);
 }
 
@@ -231 +231 @@
 
 
-static void
-vector_free(void **vec, unsigned int *count, size_t esize,
+#define VECTOR_FREE(v, c, s, f) \
+        do { vector_free(v, c, s, f); v = NULL; } while (0)
+static void
+vector_free(void *vec, unsigned int *count, size_t esize,
     vector_free_elem free_elem)
 {
@@ -239 +241 @@
 
         for (i = 0; i < *count; i++) {
-                elem = vector_ref(i, *vec, *count, esize);
+                elem = vector_ref(i, vec, *count, esize);
                 if (elem != NULL)
                         free_elem(elem);
         }
-        free(*vec);
-        *vec = NULL;
+        free(vec);
         *count = 0;
 }
@@ -283 +284 @@
         const ns_mod    *modp;
 
-        vector_append(src, (void **)&dbt->srclist, &dbt->srclistsize,
+        dbt->srclist = vector_append(src, dbt->srclist, &dbt->srclistsize,
             sizeof(*src));
         modp = vector_search(&src->name, _nsmod, _nsmodsize, sizeof(*_nsmod),
@@ -333 +334 @@
         static time_t    confmod;
         struct stat      statbuf;
-        int              result;
+        int              result, isthreaded;
         const char      *path;
 
+        result = 0;
+        isthreaded = __isthreaded;
 #if defined(_NSS_DEBUG) && defined(_NSS_SHOOT_FOOT)
         /* NOTE WELL:  THIS IS A SECURITY HOLE. This must only be built
@@ -348 +351 @@
         if (statbuf.st_mtime <= confmod)
                 return (0);
-        result = _pthread_mutex_trylock(&conf_lock);
-        if (result != 0)
-                return (0);
-        (void)_pthread_rwlock_unlock(&nss_lock);
-        result = _pthread_rwlock_wrlock(&nss_lock);
-        if (result != 0)
-                goto fin2;
+        if (isthreaded) {
+            result = _pthread_mutex_trylock(&conf_lock);
+            if (result != 0)
+                    return (0);
+            (void)_pthread_rwlock_unlock(&nss_lock);
+            result = _pthread_rwlock_wrlock(&nss_lock);
+            if (result != 0)
+                    goto fin2;
+        }
         _nsyyin = fopen(path, "r");
         if (_nsyyin == NULL)
                 goto fin;
-        vector_free((void **)&_nsmap, &_nsmapsize, sizeof(*_nsmap),
+        VECTOR_FREE(_nsmap, &_nsmapsize, sizeof(*_nsmap),
             (vector_free_elem)ns_dbt_free);
-        vector_free((void **)&_nsmod, &_nsmodsize, sizeof(*_nsmod),
+        VECTOR_FREE(_nsmod, &_nsmodsize, sizeof(*_nsmod),
             (vector_free_elem)ns_mod_free);
         nss_load_builtin_modules();
@@ -370 +375 @@
         confmod = statbuf.st_mtime;
 fin:
-        (void)_pthread_rwlock_unlock(&nss_lock);
-        result = _pthread_rwlock_rdlock(&nss_lock);
+        if (isthreaded) {
+            (void)_pthread_rwlock_unlock(&nss_lock);
+            if (result == 0)
+                    result = _pthread_rwlock_rdlock(&nss_lock);
+        }
 fin2:
-        (void)_pthread_mutex_unlock(&conf_lock);
+        if (isthreaded)
+                (void)_pthread_mutex_unlock(&conf_lock);
         return (result);
 }
@@ -394 +403 @@
                 }
         }
-        vector_append(dbt, (void **)&_nsmap, &_nsmapsize, sizeof(*_nsmap));
+        _nsmap = vector_append(dbt, _nsmap, &_nsmapsize, sizeof(*_nsmap));
 }
 
@@ -450 +459 @@
         ns_mod           mod;
         nss_module_register_fn fn;
-        
+
         memset(&mod, 0, sizeof(mod));
         mod.name = strdup(source);
@@ -469 +478 @@
                 if (snprintf(buf, sizeof(buf), "nss_%s.so.%d", mod.name,
                     NSS_MODULE_INTERFACE_VERSION) >= (int)sizeof(buf))
+#else
+                if (snprintf(buf, sizeof(buf), "nss%.5s.dll", mod.name) >= (int)sizeof(buf))
+#endif
                         goto fin;
                 mod.handle = dlopen(buf, RTLD_LOCAL|RTLD_LAZY);
@@ -488 +500 @@
                         goto fin;
                 }
-#else /* bird: dlfcn.h stuff later. */
-                buf[0] = '\0';
-                nss_log(LOG_ERR, "%s, dynamic loading not implemented in the LIBC port yet.", mod.name);
-                goto fin;
-#endif
         }
         mod.mtab = fn(mod.name, &mod.mtabsize, &mod.unregister);
         if (mod.mtab == NULL || mod.mtabsize == 0) {
-#ifndef __EMX__
                 if (mod.handle != nss_builtin_handle)
                         (void)dlclose(mod.handle);
-#endif
                 mod.handle = NULL;
                 nss_log(LOG_ERR, "%s, registration failed", mod.name);
@@ -508 +513 @@
                     mtab_compare);
 fin:
-        vector_append(&mod, (void **)&_nsmod, &_nsmodsize, sizeof(*_nsmod));
+        _nsmod = vector_append(&mod, _nsmod, &_nsmodsize, sizeof(*_nsmod));
         vector_sort(_nsmod, _nsmodsize, sizeof(*_nsmod), string_compare);
 }
@@ -523 +528 @@
         if (mod->unregister != NULL)
                 mod->unregister(mod->mtab, mod->mtabsize);
-#ifndef __EMX__
         if (mod->handle != nss_builtin_handle)
                 (void)dlclose(mod->handle);
-#endif
 }
 
@@ -537 +540 @@
 nss_atexit(void)
 {
-        (void)_pthread_rwlock_wrlock(&nss_lock);
-        vector_free((void **)&_nsmap, &_nsmapsize, sizeof(*_nsmap),
+        int isthreaded;
+
+        isthreaded = __isthreaded;
+        if (isthreaded)
+                (void)_pthread_rwlock_wrlock(&nss_lock);
+        VECTOR_FREE(_nsmap, &_nsmapsize, sizeof(*_nsmap),
             (vector_free_elem)ns_dbt_free);
-        vector_free((void **)&_nsmod, &_nsmodsize, sizeof(*_nsmod),
+        VECTOR_FREE(_nsmod, &_nsmodsize, sizeof(*_nsmod),
             (vector_free_elem)ns_mod_free);
-        (void)_pthread_rwlock_unlock(&nss_lock);
+        if (isthreaded)
+                (void)_pthread_rwlock_unlock(&nss_lock);
 }
 
@@ -595 +603 @@
         nss_method       method;
         void            *mdata;
-        int              serrno, i, result, srclistsize;
-
+        int              isthreaded, serrno, i, result, srclistsize;
+
+        isthreaded = __isthreaded;
         serrno = errno;
-        result = _pthread_rwlock_rdlock(&nss_lock);
-        if (result != 0) {
-                result = NS_UNAVAIL;
-                goto fin;
+        if (isthreaded) {
+                result = _pthread_rwlock_rdlock(&nss_lock);
+                if (result != 0) {
+                        result = NS_UNAVAIL;
+                        goto fin;
+                }
         }
         result = nss_configure();
@@ -631 +642 @@
                 }
         }
-        (void)_pthread_rwlock_unlock(&nss_lock);
+        if (isthreaded)
+                (void)_pthread_rwlock_unlock(&nss_lock);
 fin:
         errno = serrno;

trunk/src/emx/src/lib/bsd/regex/engine.c

@@ -40 +40 @@
 #include <sys/cdefs.h>
 #ifndef __EMX__ /* doesn't work for a.out */
-__FBSDID("$FreeBSD: src/lib/libc/regex/engine.c,v 1.13 2003/02/16 17:29:10 nectar Exp $");
+__FBSDID("$FreeBSD: src/lib/libc/regex/engine.c,v 1.14 2004/07/12 07:35:59 tjr Exp $");
 #endif
 
@@ -71 +71 @@
 #define at      lat
 #define match   lmat
+#endif
+#ifdef MNAMES
+#define matcher mmatcher
+#define fast    mfast
+#define slow    mslow
+#define dissect mdissect
+#define backref mbackref
+#define step    mstep
+#define print   mprint
+#define at      mat
+#define match   mmat
 #endif
 
@@ -88 +99 @@
         states tmp;             /* temporary */
         states empty;           /* empty set of states */
+        mbstate_t mbs;          /* multibyte conversion state */
 };
 
@@ -101 +113 @@
 static char *fast(struct match *m, char *start, char *stop, sopno startst, sopno stopst);
 static char *slow(struct match *m, char *start, char *stop, sopno startst, sopno stopst);
-static states step(struct re_guts *g, sopno start, sopno stop, states bef, int ch, states aft);
-#define BOL     (OUT+1)
-#define EOL     (BOL+1)
-#define BOLEOL  (BOL+2)
-#define NOTHING (BOL+3)
-#define BOW     (BOL+4)
-#define EOW     (BOL+5)
-#define CODEMAX (BOL+5)         /* highest code used */
-#define NONCHAR(c)      ((c) > CHAR_MAX)
-#define NNONCHAR        (CODEMAX-CHAR_MAX)
+static states step(struct re_guts *g, sopno start, sopno stop, states bef, wint_t ch, states aft);
+#define BOL     (OUT-1)
+#define EOL     (BOL-1)
+#define BOLEOL  (BOL-2)
+#define NOTHING (BOL-3)
+#define BOW     (BOL-4)
+#define EOW     (BOL-5)
+#define BADCHAR (BOL-6)
+#define NONCHAR(c)      ((c) <= OUT)
 #ifdef REDEBUG
 static void print(struct match *m, char *caption, states st, int ch, FILE *d);
@@ -237 +248 @@
         SETUP(m->empty);
         CLEAR(m->empty);
+        ZAPSTATE(&m->mbs);
 
         /* Adjust start according to moffset, to speed things up */
@@ -260 +272 @@
                                 break;
                         assert(m->coldp < m->endp);
-                        m->coldp++;
+                        m->coldp += XMBRTOWC(NULL, m->coldp,
+                            m->endp - m->coldp, &m->mbs, 0);
                 }
                 if (nmatch == 1 && !g->backrefs)
@@ -319 +332 @@
                 /* despite initial appearances, there is no match here */
                 NOTE("false alarm");
-                start = m->coldp + 1;   /* recycle starting later */
+                /* recycle starting later */
+                start = m->coldp + XMBRTOWC(NULL, m->coldp,
+                    m->endp - m->coldp, &m->mbs, 0);
                 assert(start <= stop);
         }
@@ -397 +412 @@
                         break;
                 case OCHAR:
-                        sp++;
+                        sp += XMBRTOWC(NULL, sp, stop - start, &m->mbs, 0);
                         break;
                 case OBOL:
@@ -406 +421 @@
                 case OANY:
                 case OANYOF:
-                        sp++;
+                        sp += XMBRTOWC(NULL, sp, stop - start, &m->mbs, 0);
                         break;
                 case OBACK_:
@@ -561 +576 @@
         regoff_t offsave;
         cset *cs;
+        wint_t wc;
 
         AT("back", start, stop, startst, stopst);
@@ -570 +586 @@
                 switch (OP(s = m->g->strip[ss])) {
                 case OCHAR:
-                        if (sp == stop || *sp++ != (char)OPND(s))
+                        if (sp == stop)
+                                return(NULL);
+                        sp += XMBRTOWC(&wc, sp, stop - sp, &m->mbs, BADCHAR);
+                        if (wc != OPND(s))
                                 return(NULL);
                         break;
@@ -576 +595 @@
                         if (sp == stop)
                                 return(NULL);
-                        sp++;
+                        sp += XMBRTOWC(&wc, sp, stop - sp, &m->mbs, BADCHAR);
+                        if (wc == BADCHAR)
+                                return (NULL);
                         break;
                 case OANYOF:
+                        if (sp == stop)
+                                return (NULL);
                         cs = &m->g->sets[OPND(s)];
-                        if (sp == stop || !CHIN(cs, *sp++))
+                        sp += XMBRTOWC(&wc, sp, stop - sp, &m->mbs, BADCHAR);
+                        if (wc == BADCHAR || !CHIN(cs, wc))
                                 return(NULL);
                         break;
@@ -757 +781 @@
         states tmp = m->tmp;
         char *p = start;
-        int c = (start == m->beginp) ? OUT : *(start-1);
-        int lastc;              /* previous c */
-        int flagch;
+        wint_t c;
+        wint_t lastc;           /* previous c */
+        wint_t flagch;
         int i;
         char *coldp;            /* last p after which no match was underway */
+        size_t clen;
 
         CLEAR(st);
@@ -769 +794 @@
         SP("start", st, *p);
         coldp = NULL;
+        if (start == m->beginp)
+                c = OUT;
+        else {
+                /*
+                 * XXX Wrong if the previous character was multi-byte.
+                 * Newline never is (in encodings supported by FreeBSD),
+                 * so this only breaks the ISWORD tests below.
+                 */
+                c = (uch)*(start - 1);
+        }
         for (;;) {
                 /* next character */
                 lastc = c;
-                c = (p == m->endp) ? OUT : *p;
+                if (p == m->endp)
+                        c = OUT;
+                else
+                        clen = XMBRTOWC(&c, p, m->endp - p, &m->mbs, BADCHAR);
                 if (EQ(st, fresh))
                         coldp = p;
@@ -820 +858 @@
                 SP("aft", st, c);
                 assert(EQ(step(m->g, startst, stopst, st, NOTHING, st), st));
-                p++;
+                p += clen;
         }
 
@@ -826 +864 @@
         m->coldp = coldp;
         if (ISSET(st, stopst))
-                return(p+1);
+                return(p+XMBRTOWC(NULL, p, m->endp - p, &m->mbs, 0));
         else
                 return(NULL);
@@ -848 +886 @@
         states tmp = m->tmp;
         char *p = start;
-        int c = (start == m->beginp) ? OUT : *(start-1);
-        int lastc;              /* previous c */
-        int flagch;
+        wint_t c;
+        wint_t lastc;           /* previous c */
+        wint_t flagch;
         int i;
         char *matchp;           /* last p at which a match ended */
+        size_t clen;
 
         AT("slow", start, stop, startst, stopst);
@@ -860 +899 @@
         st = step(m->g, startst, stopst, st, NOTHING, st);
         matchp = NULL;
+        if (start == m->beginp)
+                c = OUT;
+        else {
+                /*
+                 * XXX Wrong if the previous character was multi-byte.
+                 * Newline never is (in encodings supported by FreeBSD),
+                 * so this only breaks the ISWORD tests below.
+                 */
+                c = (uch)*(start - 1);
+        }
         for (;;) {
                 /* next character */
                 lastc = c;
-                c = (p == m->endp) ? OUT : *p;
+                if (p == m->endp) {
+                        c = OUT;
+                        clen = 0;
+                } else
+                        clen = XMBRTOWC(&c, p, m->endp - p, &m->mbs, BADCHAR);
 
                 /* is there an EOL and/or BOL between lastc and c? */
@@ -911 +964 @@
                 SP("saft", st, c);
                 assert(EQ(step(m->g, startst, stopst, st, NOTHING, st), st));
-                p++;
+                p += clen;
         }
 
@@ -922 +975 @@
  == static states step(struct re_guts *g, sopno start, sopno stop, \
  ==     states bef, int ch, states aft);
- == #define     BOL     (OUT+1)
- == #define     EOL     (BOL+1)
- == #define     BOLEOL  (BOL+2)
- == #define     NOTHING (BOL+3)
- == #define     BOW     (BOL+4)
- == #define     EOW     (BOL+5)
- == #define     CODEMAX (BOL+5)         // highest code used
- == #define     NONCHAR(c)      ((c) > CHAR_MAX)
- == #define     NNONCHAR        (CODEMAX-CHAR_MAX)
+ == #define     BOL     (OUT-1)
+ == #define     EOL     (BOL-1)
+ == #define     BOLEOL  (BOL-2)
+ == #define     NOTHING (BOL-3)
+ == #define     BOW     (BOL-4)
+ == #define     EOW     (BOL-5)
+ == #define     BADCHAR (BOL-6)
+ == #define     NONCHAR(c)      ((c) <= OUT)
  */
 static states
@@ -938 +990 @@
 sopno stop;                     /* state after stop state within strip */
 states bef;                     /* states reachable before */
-int ch;                         /* character or NONCHAR code */
+wint_t ch;                      /* character or NONCHAR code */
 states aft;                     /* states already known reachable after */
 {
@@ -956 +1008 @@
                 case OCHAR:
                         /* only characters can match */
-                        assert(!NONCHAR(ch) || ch != (char)OPND(s));
-                        if (ch == (char)OPND(s))
+                        assert(!NONCHAR(ch) || ch != OPND(s));
+                        if (ch == OPND(s))
                                 FWD(aft, bef, 1);
                         break;

trunk/src/emx/src/lib/bsd/regex/regcomp.c

@@ -38 +38 @@
  */
 
-#include "libc-alias.h"
+#include "namespace.h" /* bird */
 #if defined(LIBC_SCCS) && !defined(lint)
 static char sccsid[] = "@(#)regcomp.c   8.5 (Berkeley) 3/20/94";
 #endif /* LIBC_SCCS and not lint */
 #include <sys/cdefs.h>
-__FBSDID("$FreeBSD: src/lib/libc/regex/regcomp.c,v 1.30 2003/02/16 17:29:10 nectar Exp $");
+__FBSDID("$FreeBSD: src/lib/libc/regex/regcomp.c,v 1.32.2.1 2004/09/08 04:42:46 tjr Exp $");
 
 #include <sys/types.h>
@@ -52 +52 @@
 #include <stdlib.h>
 #include <regex.h>
-
-#include "collate.h"
+#include <wchar.h>
+#include <wctype.h>
+
+#include "../locale/collate.h"
 
 #include "utils.h"
 #include "regex2.h"
 
-#include "cclass.h"
 #include "cname.h"
 
@@ -85 +86 @@
 
 /* === regcomp.c === */
-static void p_ere(struct parse *p, int stop);
+static void p_ere(struct parse *p, wint_t stop);
 static void p_ere_exp(struct parse *p);
 static void p_str(struct parse *p);
-static void p_bre(struct parse *p, int end1, int end2);
+static void p_bre(struct parse *p, wint_t end1, wint_t end2);
 static int p_simp_re(struct parse *p, int starordinary);
 static int p_count(struct parse *p);
@@ -95 +96 @@
 static void p_b_cclass(struct parse *p, cset *cs);
 static void p_b_eclass(struct parse *p, cset *cs);
-static char p_b_symbol(struct parse *p);
-static char p_b_coll_elem(struct parse *p, int endc);
-static char othercase(int ch);
-static void bothcases(struct parse *p, int ch);
-static void ordinary(struct parse *p, int ch);
+static wint_t p_b_symbol(struct parse *p);
+static wint_t p_b_coll_elem(struct parse *p, wint_t endc);
+static wint_t othercase(wint_t ch);
+static void bothcases(struct parse *p, wint_t ch);
+static void ordinary(struct parse *p, wint_t ch);
 static void nonnewline(struct parse *p);
 static void repeat(struct parse *p, sopno start, int from, int to);
@@ -105 +106 @@
 static cset *allocset(struct parse *p);
 static void freeset(struct parse *p, cset *cs);
-static int freezeset(struct parse *p, cset *cs);
-static int firstch(struct parse *p, cset *cs);
-static int nch(struct parse *p, cset *cs);
-static void mcadd(struct parse *p, cset *cs, char *cp) __unused;
-#if used
-static void mcsub(cset *cs, char *cp);
-static int mcin(cset *cs, char *cp);
-static char *mcfind(cset *cs, char *cp);
-#endif
-static void mcinvert(struct parse *p, cset *cs);
-static void mccase(struct parse *p, cset *cs);
-static int isinsets(struct re_guts *g, int c);
-static int samesets(struct re_guts *g, int c1, int c2);
-static void categorize(struct parse *p, struct re_guts *g);
+static void CHadd(struct parse *p, cset *cs, wint_t ch);
+static void CHaddrange(struct parse *p, cset *cs, wint_t min, wint_t max);
+static void CHaddtype(struct parse *p, cset *cs, wctype_t wct);
+static wint_t singleton(cset *cs);
 static sopno dupl(struct parse *p, sopno start, sopno finish);
 static void doemit(struct parse *p, sop op, size_t opnd);
@@ -126 +117 @@
 static void stripsnug(struct parse *p, struct re_guts *g);
 static void findmust(struct parse *p, struct re_guts *g);
-static int altoffset(sop *scan, int offset, int mccs);
+static int altoffset(sop *scan, int offset);
 static void computejumps(struct parse *p, struct re_guts *g);
 static void computematchjumps(struct parse *p, struct re_guts *g);
 static sopno pluscount(struct parse *p, struct re_guts *g);
+static wint_t wgetnext(struct parse *p);
 
 #ifdef __cplusplus
@@ -154 +146 @@
 #define NEXTn(n)        (p->next += (n))
 #define GETNEXT()       (*p->next++)
+#define WGETNEXT()      wgetnext(p)
 #define SETERROR(e)     seterr(p, (e))
 #define REQUIRE(co, e)  ((co) || SETERROR(e))
@@ -218 +211 @@
 
         /* do the mallocs early so failure handling is easy */
-        g = (struct re_guts *)malloc(sizeof(struct re_guts) +
-                                                        (NC-1)*sizeof(cat_t));
+        g = (struct re_guts *)malloc(sizeof(struct re_guts));
         if (g == NULL)
                 return(REG_ESPACE);
@@ -240 +232 @@
                 p->pend[i] = 0;
         }
-        g->csetsize = NC;
         g->sets = NULL;
-        g->setbits = NULL;
         g->ncsets = 0;
         g->cflags = cflags;
@@ -254 +244 @@
         g->mlen = 0;
         g->nsub = 0;
-        g->ncategories = 1;     /* category 0 is "everything else" */
-        g->categories = &g->catspace[-(CHAR_MIN)];
-        (void) memset((char *)g->catspace, 0, NC*sizeof(cat_t));
         g->backrefs = 0;
 
@@ -272 +259 @@
 
         /* tidy up loose ends and fill things in */
-        categorize(p, g);
         stripsnug(p, g);
         findmust(p, g);
@@ -313 +299 @@
 {
         char c;
-        sopno prevback;
-        sopno prevfwd;
+        sopno prevback = 0;             /* bird: GCC warnings. */
+        sopno prevfwd = 0;              /* bird: GCC warnings. */
         sopno conc;
         int first = 1;          /* is this the first alternative? */
@@ -358 +344 @@
 {
         char c;
+        wint_t wc;
         sopno pos;
         int count;
@@ -427 +414 @@
         case '\\':
                 (void)REQUIRE(MORE(), REG_EESCAPE);
-                c = GETNEXT();
-                ordinary(p, c);
+                wc = WGETNEXT();
+                ordinary(p, wc);
                 break;
         case '{':               /* okay as ordinary except if digit follows */
@@ -434 +421 @@
                 /* FALLTHROUGH */
         default:
-                ordinary(p, c);
+                p->next--;
+                wc = WGETNEXT();
+                ordinary(p, wc);
                 break;
         }
@@ -508 +497 @@
         (void)REQUIRE(MORE(), REG_EMPTY);
         while (MORE())
-                ordinary(p, GETNEXT());
+                ordinary(p, WGETNEXT());
 }
 
@@ -518 +507 @@
  *
  * This implementation is a bit of a kludge, in that a trailing $ is first
- * taken as an ordinary character and then revised to be an anchor.  The
- * only undesirable side effect is that '$' gets included as a character
- * category in such cases.  This is fairly harmless; not worth fixing.
+ * taken as an ordinary character and then revised to be an anchor.
  * The amount of lookahead needed to avoid this kludge is excessive.
  */
@@ -566 +553 @@
         sopno pos;
         int i;
+        wint_t wc;
         sopno subno;
 #       define  BACKSL  (1<<CHAR_BIT)
@@ -637 +625 @@
                 /* FALLTHROUGH */
         default:
-                ordinary(p, (char)c);
+                p->next--;
+                wc = WGETNEXT();
+                ordinary(p, wc);
                 break;
         }
@@ -693 +683 @@
  - p_bracket - parse a bracketed character list
  == static void p_bracket(struct parse *p);
- *
- * Note a significant property of this code:  if the allocset() did SETERROR,
- * no set operations are done.
  */
 static void
@@ -701 +688 @@
 struct parse *p;
 {
-        cset *cs = allocset(p);
-        int invert = 0;
+        cset *cs;
+        wint_t ch;
 
         /* Dept of Truly Sickening Special-Case Kludges */
@@ -716 +703 @@
         }
 
+        if ((cs = allocset(p)) == NULL)
+                return;
+
+        if (p->g->cflags&REG_ICASE)
+                cs->icase = 1;
         if (EAT('^'))
-                invert++;       /* make note to invert set at end */
+                cs->invert = 1;
         if (EAT(']'))
-                CHadd(cs, ']');
+                CHadd(p, cs, ']');
         else if (EAT('-'))
-                CHadd(cs, '-');
+                CHadd(p, cs, '-');
         while (MORE() && PEEK() != ']' && !SEETWO('-', ']'))
                 p_b_term(p, cs);
         if (EAT('-'))
-                CHadd(cs, '-');
+                CHadd(p, cs, '-');
         (void)MUSTEAT(']', REG_EBRACK);
 
@@ -731 +723 @@
                 return;
 
-        if (p->g->cflags&REG_ICASE) {
-                int i;
-                int ci;
-
-                for (i = p->g->csetsize - 1; i >= 0; i--)
-                        if (CHIN(cs, i) && isalpha(i)) {
-                                ci = othercase(i);
-                                if (ci != i)
-                                        CHadd(cs, ci);
-                        }
-                if (cs->multis != NULL)
-                        mccase(p, cs);
-        }
-        if (invert) {
-                int i;
-
-                for (i = p->g->csetsize - 1; i >= 0; i--)
-                        if (CHIN(cs, i))
-                                CHsub(cs, i);
-                        else
-                                CHadd(cs, i);
-                if (p->g->cflags&REG_NEWLINE)
-                        CHsub(cs, '\n');
-                if (cs->multis != NULL)
-                        mcinvert(p, cs);
-        }
-
-        assert(cs->multis == NULL);             /* xxx */
-
-        if (nch(p, cs) == 1) {          /* optimize singleton sets */
-                ordinary(p, firstch(p, cs));
+        if (cs->invert && p->g->cflags&REG_NEWLINE)
+                cs->bmp['\n' >> 3] |= 1 << ('\n' & 7);
+
+        if ((ch = singleton(cs)) != OUT) {      /* optimize singleton sets */
+                ordinary(p, ch);
                 freeset(p, cs);
         } else
-                EMIT(OANYOF, freezeset(p, cs));
+                EMIT(OANYOF, (int)(cs - p->g->sets));
 }
 
@@ -777 +743 @@
 {
         char c;
-        char start, finish;
-        int i;
+        wint_t start, finish;
+        wint_t i;
 
         /* classify what we've got */
@@ -814 +780 @@
                 break;
         default:                /* symbol, ordinary character, or range */
-/* xxx revision needed for multichar stuff */
                 start = p_b_symbol(p);
                 if (SEE('-') && MORE2() && PEEK2() != ']') {
@@ -826 +791 @@
                         finish = start;
                 if (start == finish)
-                        CHadd(cs, start);
+                        CHadd(p, cs, start);
                 else {
 #ifndef __EMX__
                         if (__collate_load_error) {
                                 (void)REQUIRE((uch)start <= (uch)finish, REG_ERANGE);
-                                for (i = (uch)start; i <= (uch)finish; i++)
-                                        CHadd(cs, i);
+                                CHaddrange(p, cs, start, finish);
                         } else {
 #endif
                                 (void)REQUIRE(__collate_range_cmp(start, finish) <= 0, REG_ERANGE);
-                                for (i = CHAR_MIN; i <= CHAR_MAX; i++) {
+                                for (i = 0; i <= UCHAR_MAX; i++) {
                                         if (   __collate_range_cmp(start, i) <= 0
                                             && __collate_range_cmp(i, finish) <= 0
                                            )
-                                                CHadd(cs, i);
+                                                CHadd(p, cs, i);
                                 }
 #ifndef __EMX__
@@ -859 +823 @@
 cset *cs;
 {
-        int c;
         char *sp = p->next;
-        struct cclass *cp;
         size_t len;
+        wctype_t wct;
+        char clname[16];
 
         while (MORE() && isalpha((uch)PEEK()))
                 NEXT();
         len = p->next - sp;
-        for (cp = cclasses; cp->name != NULL; cp++)
-                if (strncmp(cp->name, sp, len) == 0 && cp->name[len] == '\0')
-                        break;
-        if (cp->name == NULL) {
-                /* oops, didn't find it */
+        if (len >= sizeof(clname) - 1) {
                 SETERROR(REG_ECTYPE);
                 return;
         }
-
-        switch (cp->fidx) {
-        case CALNUM:
-                for (c = CHAR_MIN; c <= CHAR_MAX; c++)
-                        if (isalnum((uch)c))
-                                CHadd(cs, c);
-                break;
-        case CALPHA:
-                for (c = CHAR_MIN; c <= CHAR_MAX; c++)
-                        if (isalpha((uch)c))
-                                CHadd(cs, c);
-                break;
-        case CBLANK:
-                for (c = CHAR_MIN; c <= CHAR_MAX; c++)
-                        if (isblank((uch)c))
-                                CHadd(cs, c);
-                break;
-        case CCNTRL:
-                for (c = CHAR_MIN; c <= CHAR_MAX; c++)
-                        if (iscntrl((uch)c))
-                                CHadd(cs, c);
-                break;
-        case CDIGIT:
-                for (c = CHAR_MIN; c <= CHAR_MAX; c++)
-                        if (isdigit((uch)c))
-                                CHadd(cs, c);
-                break;
-        case CGRAPH:
-                for (c = CHAR_MIN; c <= CHAR_MAX; c++)
-                        if (isgraph((uch)c))
-                                CHadd(cs, c);
-                break;
-        case CLOWER:
-                for (c = CHAR_MIN; c <= CHAR_MAX; c++)
-                        if (islower((uch)c))
-                                CHadd(cs, c);
-                break;
-        case CPRINT:
-                for (c = CHAR_MIN; c <= CHAR_MAX; c++)
-                        if (isprint((uch)c))
-                                CHadd(cs, c);
-                break;
-        case CPUNCT:
-                for (c = CHAR_MIN; c <= CHAR_MAX; c++)
-                        if (ispunct((uch)c))
-                                CHadd(cs, c);
-                break;
-        case CSPACE:
-                for (c = CHAR_MIN; c <= CHAR_MAX; c++)
-                        if (isspace((uch)c))
-                                CHadd(cs, c);
-                break;
-        case CUPPER:
-                for (c = CHAR_MIN; c <= CHAR_MAX; c++)
-                        if (isupper((uch)c))
-                                CHadd(cs, c);
-                break;
-        case CXDIGIT:
-                for (c = CHAR_MIN; c <= CHAR_MAX; c++)
-                        if (isxdigit((uch)c))
-                                CHadd(cs, c);
-                break;
-        }
-#if 0
-        for (u = cp->multis; *u != '\0'; u += strlen(u) + 1)
-                MCadd(p, cs, u);
-#endif
+        memcpy(clname, sp, len);
+        clname[len] = '\0';
+        if ((wct = wctype(clname)) == 0) {
+                SETERROR(REG_ECTYPE);
+                return;
+        }
+        CHaddtype(p, cs, wct);
 }
 
@@ -955 +855 @@
 cset *cs;
 {
-        char c;
+        wint_t c;
 
         c = p_b_coll_elem(p, '=');
-        CHadd(cs, c);
+        CHadd(p, cs, c);
 }
 
@@ -965 +865 @@
  == static char p_b_symbol(struct parse *p);
  */
-static char                     /* value of symbol */
+static wint_t                   /* value of symbol */
 p_b_symbol(p)
 struct parse *p;
 {
-        char value;
+        wint_t value;
 
         (void)REQUIRE(MORE(), REG_EBRACK);
         if (!EATTWO('[', '.'))
-                return(GETNEXT());
+                return(WGETNEXT());
 
         /* collating symbol */
@@ -985 +885 @@
  == static char p_b_coll_elem(struct parse *p, int endc);
  */
-static char                     /* value of collating element */
+static wint_t                   /* value of collating element */
 p_b_coll_elem(p, endc)
 struct parse *p;
-int endc;                       /* name ended by endc,']' */
+wint_t endc;                    /* name ended by endc,']' */
 {
         char *sp = p->next;
         struct cname *cp;
         int len;
+        mbstate_t mbs;
+        wchar_t wc;
+        size_t clen;
 
         while (MORE() && !SEETWO(endc, ']'))
@@ -1004 +907 @@
                 if (strncmp(cp->name, sp, len) == 0 && cp->name[len] == '\0')
                         return(cp->code);       /* known name */
-        if (len == 1)
-                return(*sp);    /* single character */
-        SETERROR(REG_ECOLLATE);                 /* neither */
+        memset(&mbs, 0, sizeof(mbs));
+        if ((clen = mbrtowc(&wc, sp, len, &mbs)) == len)
+                return (wc);                    /* single character */
+        else if (clen == (size_t)-1 || clen == (size_t)-2)
+                SETERROR(REG_ILLSEQ);
+        else
+                SETERROR(REG_ECOLLATE);         /* neither */
         return(0);
 }
@@ -1014 +921 @@
  == static char othercase(int ch);
  */
-static char                     /* if no counterpart, return ch */
+static wint_t                   /* if no counterpart, return ch */
 othercase(ch)
-int ch;
-{
-        ch = (uch)ch;
-        assert(isalpha(ch));
-        if (isupper(ch))
-                return(tolower(ch));
-        else if (islower(ch))
-                return(toupper(ch));
+wint_t ch;
+{
+        assert(iswalpha(ch));
+        if (iswupper(ch))
+                return(towlower(ch));
+        else if (iswlower(ch))
+                return(towupper(ch));
         else                    /* peculiar, but could happen */
                 return(ch);
@@ -1037 +943 @@
 bothcases(p, ch)
 struct parse *p;
-int ch;
+wint_t ch;
 {
         char *oldnext = p->next;
         char *oldend = p->end;
-        char bracket[3];
-
-        ch = (uch)ch;
+        char bracket[3 + MB_LEN_MAX];
+        size_t n;
+        mbstate_t mbs;
+
         assert(othercase(ch) != ch);    /* p_bracket() would recurse */
         p->next = bracket;
-        p->end = bracket+2;
-        bracket[0] = ch;
-        bracket[1] = ']';
-        bracket[2] = '\0';
+        memset(&mbs, 0, sizeof(mbs));
+        n = wcrtomb(bracket, ch, &mbs);
+        assert(n != (size_t)-1);
+        bracket[n] = ']';
+        bracket[n + 1] = '\0';
+        p->end = bracket+n+1;
         p_bracket(p);
-        assert(p->next == bracket+2);
+        assert(p->next == p->end);
         p->next = oldnext;
         p->end = oldend;
@@ -1063 +972 @@
 ordinary(p, ch)
 struct parse *p;
-int ch;
-{
-        cat_t *cap = p->g->categories;
-
-        if ((p->g->cflags&REG_ICASE) && isalpha((uch)ch) && othercase(ch) != ch)
+wint_t ch;
+{
+        cset *cs;
+
+        if ((p->g->cflags&REG_ICASE) && iswalpha(ch) && othercase(ch) != ch)
                 bothcases(p, ch);
+        else if ((ch & OPDMASK) == ch)
+                EMIT(OCHAR, ch);
         else {
-                EMIT(OCHAR, (uch)ch);
-                if (cap[ch] == 0)
-                        cap[ch] = p->g->ncategories++;
+                /*
+                 * Kludge: character is too big to fit into an OCHAR operand.
+                 * Emit a singleton set.
+                 */
+                if ((cs = allocset(p)) == NULL)
+                        return;
+                CHadd(p, cs, ch);
+                EMIT(OANYOF, (int)(cs - p->g->sets));
         }
 }
@@ -1175 +1091 @@
 
 /*
+ - wgetnext - helper function for WGETNEXT() macro. Gets the next wide
+ - character from the parse struct, signals a REG_ILLSEQ error if the
+ - character can't be converted. Returns the number of bytes consumed.
+ */
+static wint_t
+wgetnext(p)
+struct parse *p;
+{
+        mbstate_t mbs;
+        wchar_t wc;
+        size_t n;
+
+        memset(&mbs, 0, sizeof(mbs));
+        n = mbrtowc(&wc, p->next, p->end - p->next, &mbs);
+        if (n == (size_t)-1 || n == (size_t)-2) {
+                SETERROR(REG_ILLSEQ);
+                return (0);
+        }
+        if (n == 0)
+                n = 1;
+        p->next += n;
+        return (wc);
+}
+
+/*
  - seterr - set an error condition
  == static int seterr(struct parse *p, int e);
@@ -1198 +1139 @@
 struct parse *p;
 {
-        int no = p->g->ncsets++;
-        size_t nc;
-        size_t nbytes;
-        cset *cs;
-        size_t css = (size_t)p->g->csetsize;
-        int i;
-
-        if (no >= p->ncsalloc) {        /* need another column of space */
-                p->ncsalloc += CHAR_BIT;
-                nc = p->ncsalloc;
-                assert(nc % CHAR_BIT == 0);
-                nbytes = nc / CHAR_BIT * css;
-                if (p->g->sets == NULL)
-                        p->g->sets = (cset *)malloc(nc * sizeof(cset));
-                else
-                        p->g->sets = (cset *)reallocf((char *)p->g->sets,
-                                                        nc * sizeof(cset));
-                if (p->g->setbits == NULL)
-                        p->g->setbits = (uch *)malloc(nbytes);
-                else {
-                        p->g->setbits = (uch *)reallocf((char *)p->g->setbits,
-                                                                nbytes);
-                        /* xxx this isn't right if setbits is now NULL */
-                        for (i = 0; i < no; i++)
-                                p->g->sets[i].ptr = p->g->setbits + css*(i/CHAR_BIT);
-                }
-                if (p->g->sets != NULL && p->g->setbits != NULL)
-                        (void) memset((char *)p->g->setbits + (nbytes - css),
-                                                                0, css);
-                else {
-                        no = 0;
-                        SETERROR(REG_ESPACE);
-                        /* caller's responsibility not to do set ops */
-                }
-        }
-
-        assert(p->g->sets != NULL);     /* xxx */
-        cs = &p->g->sets[no];
-        cs->ptr = p->g->setbits + css*((no)/CHAR_BIT);
-        cs->mask = 1 << ((no) % CHAR_BIT);
-        cs->hash = 0;
-        cs->smultis = 0;
-        cs->multis = NULL;
+        cset *cs, *ncs;
+
+        ncs = realloc(p->g->sets, (p->g->ncsets + 1) * sizeof(*ncs));
+        if (ncs == NULL) {
+                SETERROR(REG_ESPACE);
+                return (NULL);
+        }
+        p->g->sets = ncs;
+        cs = &p->g->sets[p->g->ncsets++];
+        memset(cs, 0, sizeof(*cs));
 
         return(cs);
@@ -1254 +1162 @@
 cset *cs;
 {
-        int i;
         cset *top = &p->g->sets[p->g->ncsets];
-        size_t css = (size_t)p->g->csetsize;
-
-        for (i = 0; i < css; i++)
-                CHsub(cs, i);
+
+        free(cs->wides);
+        free(cs->ranges);
+        free(cs->types);
+        memset(cs, 0, sizeof(*cs));
         if (cs == top-1)        /* recover only the easy case */
                 p->g->ncsets--;
@@ -1265 +1173 @@
 
 /*
- - freezeset - final processing on a set of characters
- == static int freezeset(struct parse *p, cset *cs);
- *
- * The main task here is merging identical sets.  This is usually a waste
- * of time (although the hash code minimizes the overhead), but can win
- * big if REG_ICASE is being used.  REG_ICASE, by the way, is why the hash
- * is done using addition rather than xor -- all ASCII [aA] sets xor to
- * the same value!
- */
-static int                      /* set number */
-freezeset(p, cs)
-struct parse *p;
+ - singleton - Determine whether a set contains only one character,
+ - returning it if so, otherwise returning OUT.
+ */
+static wint_t
+singleton(cs)
 cset *cs;
 {
-        short h = cs->hash;
-        int i;
-        cset *top = &p->g->sets[p->g->ncsets];
-        cset *cs2;
-        size_t css = (size_t)p->g->csetsize;
-
-        /* look for an earlier one which is the same */
-        for (cs2 = &p->g->sets[0]; cs2 < top; cs2++)
-                if (cs2->hash == h && cs2 != cs) {
-                        /* maybe */
-                        for (i = 0; i < css; i++)
-                                if (!!CHIN(cs2, i) != !!CHIN(cs, i))
-                                        break;          /* no */
-                        if (i == css)
-                                break;                  /* yes */
+        wint_t i, s, n;
+
+        for (i = n = 0; i < NC; i++)
+                if (CHIN(cs, i)) {
+                        n++;
+                        s = i;
                 }
-
-        if (cs2 < top) {        /* found one */
-                freeset(p, cs);
-                cs = cs2;
-        }
-
-        return((int)(cs - p->g->sets));
-}
-
-/*
- - firstch - return first character in a set (which must have at least one)
- == static int firstch(struct parse *p, cset *cs);
- */
-static int                      /* character; there is no "none" value */
-firstch(p, cs)
+        if (n == 1)
+                return (s);
+        if (cs->nwides == 1 && cs->nranges == 0 && cs->ntypes == 0 &&
+            cs->icase == 0)
+                return (cs->wides[0]);
+        /* Don't bother handling the other cases. */
+        return (OUT);
+}
+
+/*
+ - CHadd - add character to character set.
+ */
+static void
+CHadd(p, cs, ch)
 struct parse *p;
 cset *cs;
-{
-        int i;
-        size_t css = (size_t)p->g->csetsize;
-
-        for (i = 0; i < css; i++)
-                if (CHIN(cs, i))
-                        return((char)i);
-        assert(never);
-        return(0);              /* arbitrary */
-}
-
-/*
- - nch - number of characters in a set
- == static int nch(struct parse *p, cset *cs);
- */
-static int
-nch(p, cs)
+wint_t ch;
+{
+        wint_t nch, *newwides;
+        assert(ch >= 0);
+        if (ch < NC)
+                cs->bmp[ch >> 3] |= 1 << (ch & 7);
+        else {
+                newwides = realloc(cs->wides, (cs->nwides + 1) *
+                    sizeof(*cs->wides));
+                if (newwides == NULL) {
+                        SETERROR(REG_ESPACE);
+                        return;
+                }
+                cs->wides = newwides;
+                cs->wides[cs->nwides++] = ch;
+        }
+        if (cs->icase) {
+                if ((nch = towlower(ch)) < NC)
+                        cs->bmp[nch >> 3] |= 1 << (nch & 7);
+                if ((nch = towupper(ch)) < NC)
+                        cs->bmp[nch >> 3] |= 1 << (nch & 7);
+        }
+}
+
+/*
+ - CHaddrange - add all characters in the range [min,max] to a character set.
+ */
+static void
+CHaddrange(p, cs, min, max)
 struct parse *p;
 cset *cs;
-{
-        int i;
-        size_t css = (size_t)p->g->csetsize;
-        int n = 0;
-
-        for (i = 0; i < css; i++)
-                if (CHIN(cs, i))
-                        n++;
-        return(n);
-}
-
-/*
- - mcadd - add a collating element to a cset
- == static void mcadd(struct parse *p, cset *cs, \
- ==     char *cp);
- */
-static void
-mcadd(p, cs, cp)
+wint_t min, max;
+{
+        crange *newranges;
+
+        for (; min < NC && min <= max; min++)
+                CHadd(p, cs, min);
+        if (min >= max)
+                return;
+        newranges = realloc(cs->ranges, (cs->nranges + 1) *
+            sizeof(*cs->ranges));
+        if (newranges == NULL) {
+                SETERROR(REG_ESPACE);
+                return;
+        }
+        cs->ranges = newranges;
+        cs->ranges[cs->nranges].min = min;
+        cs->ranges[cs->nranges].min = max;
+        cs->nranges++;
+}
+
+/*
+ - CHaddtype - add all characters of a certain type to a character set.
+ */
+static void
+CHaddtype(p, cs, wct)
 struct parse *p;
 cset *cs;
-char *cp;
-{
-        size_t oldend = cs->smultis;
-
-        cs->smultis += strlen(cp) + 1;
-        if (cs->multis == NULL)
-                cs->multis = malloc(cs->smultis);
-        else
-                cs->multis = reallocf(cs->multis, cs->smultis);
-        if (cs->multis == NULL) {
+wctype_t wct;
+{
+        wint_t i;
+        wctype_t *newtypes;
+
+        for (i = 0; i < NC; i++)
+                if (iswctype(i, wct))
+                        CHadd(p, cs, i);
+        newtypes = realloc(cs->types, (cs->ntypes + 1) *
+            sizeof(*cs->types));
+        if (newtypes == NULL) {
                 SETERROR(REG_ESPACE);
                 return;
         }
-
-        (void) strcpy(cs->multis + oldend - 1, cp);
-        cs->multis[cs->smultis - 1] = '\0';
-}
-
-#if used
-/*
- - mcsub - subtract a collating element from a cset
- == static void mcsub(cset *cs, char *cp);
- */
-static void
-mcsub(cs, cp)
-cset *cs;
-char *cp;
-{
-        char *fp = mcfind(cs, cp);
-        size_t len = strlen(fp);
-
-        assert(fp != NULL);
-        (void) memmove(fp, fp + len + 1,
-                                cs->smultis - (fp + len + 1 - cs->multis));
-        cs->smultis -= len;
-
-        if (cs->smultis == 0) {
-                free(cs->multis);
-                cs->multis = NULL;
-                return;
-        }
-
-        cs->multis = reallocf(cs->multis, cs->smultis);
-        assert(cs->multis != NULL);
-}
-
-/*
- - mcin - is a collating element in a cset?
- == static int mcin(cset *cs, char *cp);
- */
-static int
-mcin(cs, cp)
-cset *cs;
-char *cp;
-{
-        return(mcfind(cs, cp) != NULL);
-}
-
-/*
- - mcfind - find a collating element in a cset
- == static char *mcfind(cset *cs, char *cp);
- */
-static char *
-mcfind(cs, cp)
-cset *cs;
-char *cp;
-{
-        char *p;
-
-        if (cs->multis == NULL)
-                return(NULL);
-        for (p = cs->multis; *p != '\0'; p += strlen(p) + 1)
-                if (strcmp(cp, p) == 0)
-                        return(p);
-        return(NULL);
-}
-#endif
-
-/*
- - mcinvert - invert the list of collating elements in a cset
- == static void mcinvert(struct parse *p, cset *cs);
- *
- * This would have to know the set of possibilities.  Implementation
- * is deferred.
- */
-static void
-mcinvert(p, cs)
-struct parse *p;
-cset *cs;
-{
-        assert(cs->multis == NULL);     /* xxx */
-}
-
-/*
- - mccase - add case counterparts of the list of collating elements in a cset
- == static void mccase(struct parse *p, cset *cs);
- *
- * This would have to know the set of possibilities.  Implementation
- * is deferred.
- */
-static void
-mccase(p, cs)
-struct parse *p;
-cset *cs;
-{
-        assert(cs->multis == NULL);     /* xxx */
-}
-
-/*
- - isinsets - is this character in any sets?
- == static int isinsets(struct re_guts *g, int c);
- */
-static int                      /* predicate */
-isinsets(g, c)
-struct re_guts *g;
-int c;
-{
-        uch *col;
-        int i;
-        int ncols = (g->ncsets+(CHAR_BIT-1)) / CHAR_BIT;
-        unsigned uc = (uch)c;
-
-        for (i = 0, col = g->setbits; i < ncols; i++, col += g->csetsize)
-                if (col[uc] != 0)
-                        return(1);
-        return(0);
-}
-
-/*
- - samesets - are these two characters in exactly the same sets?
- == static int samesets(struct re_guts *g, int c1, int c2);
- */
-static int                      /* predicate */
-samesets(g, c1, c2)
-struct re_guts *g;
-int c1;
-int c2;
-{
-        uch *col;
-        int i;
-        int ncols = (g->ncsets+(CHAR_BIT-1)) / CHAR_BIT;
-        unsigned uc1 = (uch)c1;
-        unsigned uc2 = (uch)c2;
-
-        for (i = 0, col = g->setbits; i < ncols; i++, col += g->csetsize)
-                if (col[uc1] != col[uc2])
-                        return(0);
-        return(1);
-}
-
-/*
- - categorize - sort out character categories
- == static void categorize(struct parse *p, struct re_guts *g);
- */
-static void
-categorize(p, g)
-struct parse *p;
-struct re_guts *g;
-{
-        cat_t *cats = g->categories;
-        int c;
-        int c2;
-        cat_t cat;
-
-        /* avoid making error situations worse */
-        if (p->error != 0)
-                return;
-
-        for (c = CHAR_MIN; c <= CHAR_MAX; c++)
-                if (cats[c] == 0 && isinsets(g, c)) {
-                        cat = g->ncategories++;
-                        cats[c] = cat;
-                        for (c2 = c+1; c2 <= CHAR_MAX; c2++)
-                                if (cats[c2] == 0 && samesets(g, c, c2))
-                                        cats[c2] = cat;
-                }
+        cs->types = newtypes;
+        cs->types[cs->ntypes++] = wct;
 }
 
@@ -1702 +1452 @@
         sop s;
         char *cp;
-        sopno i;
         int offset;
-        int cs, mccs;
+        char buf[MB_LEN_MAX];
+        size_t clen;
+        mbstate_t mbs;
 
         /* avoid making error situations worse */
@@ -1710 +1461 @@
                 return;
 
-        /* Find out if we can handle OANYOF or not */
-        mccs = 0;
-        for (cs = 0; cs < g->ncsets; cs++)
-                if (g->sets[cs].multis != NULL)
-                        mccs = 1;
+#ifndef __EMX__ /** @todo fixme */
+        /*
+         * It's not generally safe to do a ``char'' substring search on
+         * multibyte character strings, but it's safe for at least
+         * UTF-8 (see RFC 3629).
+         */
+        if (MB_CUR_MAX > 1 &&
+            strcmp(_CurrentRuneLocale->__encoding, "UTF-8") != 0)
+                return;
+#endif
 
         /* find the longest OCHAR sequence in strip */
@@ -1725 +1481 @@
                 switch (OP(s)) {
                 case OCHAR:             /* sequence member */
-                        if (newlen == 0)                /* new sequence */
+                        if (newlen == 0) {              /* new sequence */
+                                memset(&mbs, 0, sizeof(mbs));
                                 newstart = scan - 1;
-                        newlen++;
+                        }
+                        clen = wcrtomb(buf, OPND(s), &mbs);
+                        if (clen == (size_t)-1)
+                                goto toohard;
+                        newlen += clen;
                         break;
                 case OPLUS_:            /* things that don't break one */
@@ -1735 +1496 @@
                 case OQUEST_:           /* things that must be skipped */
                 case OCH_:
-                        offset = altoffset(scan, offset, mccs);
+                        offset = altoffset(scan, offset);
                         scan--;
                         do {
@@ -1803 +1564 @@
                                 offset++;
                         newlen = 0;
-                        /* And, now, if we found out we can't deal with
-                         * it, make offset = -1.
-                         */
-                        if (mccs)
-                                offset = -1;
                         break;
+                toohard:
                 default:
                         /* Anything here makes it impossible or too hard
@@ -1843 +1600 @@
         cp = g->must;
         scan = start;
-        for (i = g->mlen; i > 0; i--) {
+        memset(&mbs, 0, sizeof(mbs));
+        while (cp < g->must + g->mlen) {
                 while (OP(s = *scan++) != OCHAR)
                         continue;
-                assert(cp < g->must + g->mlen);
-                *cp++ = (char)OPND(s);
+                clen = wcrtomb(cp, OPND(s), &mbs);
+                assert(clen != (size_t)-1);
+                cp += clen;
         }
         assert(cp == g->must + g->mlen);
@@ -1855 +1614 @@
 /*
  - altoffset - choose biggest offset among multiple choices
- == static int altoffset(sop *scan, int offset, int mccs);
+ == static int altoffset(sop *scan, int offset);
  *
  * Compute, recursively if necessary, the largest offset among multiple
@@ -1861 +1620 @@
  */
 static int
-altoffset(scan, offset, mccs)
+altoffset(scan, offset)
 sop *scan;
 int offset;
-int mccs;
 {
         int largest;
@@ -1886 +1644 @@
                 case OQUEST_:
                 case OCH_:
-                        try = altoffset(scan, try, mccs);
+                        try = altoffset(scan, try);
                         if (try == -1)
                                 return -1;
@@ -1903 +1661 @@
                         break;
                 case OANYOF:
-                        if (mccs)
-                                return -1;
                 case OCHAR:
                 case OANY:

trunk/src/emx/src/lib/bsd/regex/regerror.c

@@ -38 +38 @@
  */
 
-#include "libc-alias.h"
+#include "namespace.h" /* bird */
 #if defined(LIBC_SCCS) && !defined(lint)
 static char sccsid[] = "@(#)regerror.c  8.4 (Berkeley) 3/20/94";
 #endif /* LIBC_SCCS and not lint */
 #include <sys/cdefs.h>
-__FBSDID("$FreeBSD: src/lib/libc/regex/regerror.c,v 1.8 2002/10/02 07:49:35 mike Exp $");
+__FBSDID("$FreeBSD: src/lib/libc/regex/regerror.c,v 1.9 2004/07/12 06:07:26 tjr Exp $");
 
 #include <sys/types.h>
@@ -83 +83 @@
  = #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 (!)
@@ -107 +108 @@
         {REG_ASSERT,    "REG_ASSERT",   "\"can't happen\" -- you found a bug"},
         {REG_INVARG,    "REG_INVARG",   "invalid argument to regex routine"},
+        {REG_ILLSEQ,    "REG_ILLSEQ",   "illegal byte sequence"},
         {0,             "",             "*** unknown regexp error code ***"}
 };

trunk/src/emx/src/lib/bsd/regex/regexec.c

@@ -38 +38 @@
  */
 
-#include "libc-alias.h"
+#include "namespace.h" /* bird */
 #if defined(LIBC_SCCS) && !defined(lint)
 static char sccsid[] = "@(#)regexec.c   8.3 (Berkeley) 3/20/94";
 #endif /* LIBC_SCCS and not lint */
 #include <sys/cdefs.h>
-__FBSDID("$FreeBSD: src/lib/libc/regex/regexec.c,v 1.5 2003/02/16 17:29:10 nectar Exp $");
+__FBSDID("$FreeBSD: src/lib/libc/regex/regexec.c,v 1.6 2004/07/12 07:35:59 tjr Exp $");
 
 /*
  * the outer shell of regexec()
  *
- * This file includes engine.c *twice*, after muchos fiddling with the
+ * This file includes engine.c three times, after muchos fiddling with the
  * macros that code uses.  This lets the same code operate on two different
- * representations for state sets.
+ * representations for state sets and characters.
  */
 #include <sys/types.h>
@@ -59 +59 @@
 #include <ctype.h>
 #include <regex.h>
+#include <wchar.h>
+#include <wctype.h>
 
 #include "utils.h"
@@ -64 +66 @@
 
 static int nope __unused = 0;   /* for use in asserts; shuts lint up */
+
+static __inline size_t
+xmbrtowc(wi, s, n, mbs, dummy)
+wint_t *wi;
+const char *s;
+size_t n;
+mbstate_t *mbs;
+wint_t dummy;
+{
+        size_t nr;
+        wchar_t wc;
+
+        nr = mbrtowc(&wc, s, n, mbs);
+        if (wi != NULL)
+                *wi = wc;
+        if (nr == 0)
+                return (1);
+        else if (nr == (size_t)-1 || nr == (size_t)-2) {
+                memset(mbs, 0, sizeof(*mbs));
+                if (wi != NULL)
+                        *wi = dummy;
+                return (1);
+        } else
+                return (nr);
+}
+
+static __inline size_t
+xmbrtowc_dummy(wi, s, n, mbs, dummy)
+wint_t *wi;
+const char *s;
+size_t n __unused;
+mbstate_t *mbs __unused;
+wint_t dummy __unused;
+{
+
+        if (wi != NULL)
+                *wi = (unsigned char)*s;
+        return (1);
+}
 
 /* macros for manipulating states, small version */
@@ -87 +128 @@
 #define BACK(dst, src, n)       ((dst) |= ((unsigned long)(src)&(here)) >> (n))
 #define ISSETBACK(v, n) (((v) & ((unsigned long)here >> (n))) != 0)
+/* no multibyte support */
+#define XMBRTOWC        xmbrtowc_dummy
+#define ZAPSTATE(mbs)   ((void)(mbs))
 /* function names */
 #define SNAMES                  /* engine.c looks after details */
@@ -112 +156 @@
 #undef  ISSETBACK
 #undef  SNAMES
+#undef  XMBRTOWC
+#undef  ZAPSTATE
 
 /* macros for manipulating states, large version */
@@ -136 +182 @@
 #define BACK(dst, src, n)       ((dst)[here-(n)] |= (src)[here])
 #define ISSETBACK(v, n) ((v)[here - (n)])
+/* no multibyte support */
+#define XMBRTOWC        xmbrtowc_dummy
+#define ZAPSTATE(mbs)   ((void)(mbs))
 /* function names */
 #define LNAMES                  /* flag */
+
+#include "engine.c"
+
+/* multibyte character & large states version */
+#undef  LNAMES
+#undef  XMBRTOWC
+#undef  ZAPSTATE
+#define XMBRTOWC        xmbrtowc
+#define ZAPSTATE(mbs)   memset((mbs), 0, sizeof(*(mbs)))
+#define MNAMES
 
 #include "engine.c"
@@ -178 +237 @@
         eflags = GOODFLAGS(eflags);
 
-        if (g->nstates <= CHAR_BIT*sizeof(states1) && !(eflags&REG_LARGE))
+        if (MB_CUR_MAX > 1)
+                return(mmatcher(g, (char *)string, nmatch, pmatch, eflags));
+        else if (g->nstates <= CHAR_BIT*sizeof(states1) && !(eflags&REG_LARGE))
                 return(smatcher(g, (char *)string, nmatch, pmatch, eflags));
         else

trunk/src/emx/src/lib/bsd/stdlib/radixsort.c

@@ -35 +35 @@
  */
 
+#include "namespace.h" /* bird */
 #if defined(LIBC_SCCS) && !defined(lint)
 static char sccsid[] = "@(#)radixsort.c 8.2 (Berkeley) 4/28/95";
 #endif /* LIBC_SCCS and not lint */
-#include "libc-alias.h" /* bird: Get the right mapping of libc functions. */
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD: src/lib/libc/stdlib/radixsort.c,v 1.7 2003/11/11 04:59:23 kientzle Exp $");

trunk/src/emx/src/lib/bsd/stdtime/difftime.c

@@ -7 +7 @@
 #ifndef lint
 #ifndef NOID
-static char     elsieid[] __unused = "@(#)difftime.c    7.7";
+static char     elsieid[] __unused = "@(#)difftime.c    7.9";
 #endif /* !defined NOID */
 #endif /* !defined lint */
-__FBSDID("$FreeBSD: src/lib/libc/stdtime/difftime.c,v 1.7 2003/02/16 17:29:11 nectar Exp $");
+__FBSDID("$FreeBSD: src/lib/libc/stdtime/difftime.c,v 1.8 2004/06/14 10:31:52 stefanf Exp $");
 
 /*LINTLIBRARY*/
@@ -27 +27 @@
 #ifndef HAVE_LONG_DOUBLE
 #define long_double     double
-#error "we have long double, why isn't it defined?"
+#error "we have long double, why isn't it defined?" /* bird */
 #endif /* !defined HAVE_LONG_DOUBLE */
 
@@ -38 +38 @@
         time_t  hibit;
 
-        if (sizeof(time_t) < sizeof(double))
-                return (double) time1 - (double) time0;
-        if (sizeof(time_t) < sizeof(long_double))
-                return (long_double) time1 - (long_double) time0;
+        {
+                time_t          tt;
+                double          d;
+                long_double     ld;
+
+                if (sizeof tt < sizeof d)
+                        return (double) time1 - (double) time0;
+                if (sizeof tt < sizeof ld)
+                        return (long_double) time1 - (long_double) time0;
+        }
         if (time1 < time0)
                 return -difftime(time0, time1);

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

@@ -1282 +1282 @@
     "__std_llabs" @1299
     "__std_lldiv" @1300
+    "_dlfunc" @1301
+    "_issetugid" @1302

trunk/src/emx/src/lib/misc/dlsym.c

@@ -54 +54 @@
 }
 
+/**
+ * BSD convenience.
+ * Exactly the same as dlsym, only that it's return type is a function pointer.
+ *
+ * @returns Address of symbol.
+ *          NULL if not found.
+ * @param   pvHandle    Module handle returned by dlopen.
+ * @param   pszSymbol   Name of the symbol.
+ *                      This can be an ordinal on OS/2.
+ */
+dlfunc_t dlfunc(void * __restrict pvHandle, const char * __restrict pszSymbol)
+{
+    return (dlfunc_t)dlsym(pvHandle, pszSymbol);
+}
+