Changeset 1695

Timestamp:

Dec 3, 2004, 5:56:45 AM (20 years ago)

Author:

bird

Message:

FreeBSD 5.3 libc sources.

Location:

branches/FREEBSD/src/emx/src/lib/bsd

Files:

• db/btree/bt_split.c (modified) (3 diffs, 1 prop)
• db/mpool/mpool.c (modified) (3 diffs, 1 prop)
• gen/getgrent.c (modified) (3 diffs, 1 prop)
• gen/getnetgrent.c (modified) (10 diffs, 1 prop)
• gen/getpwent.c (modified) (13 diffs, 1 prop)
• gen/glob.c (modified) (14 diffs, 1 prop)
• gen/pw_scan.c (modified) (3 diffs, 1 prop)
• locale/collcmp.c (modified) (1 diff, 1 prop)
• net/nsdispatch.c (modified) (18 diffs, 1 prop)
• regex/engine.c (modified) (22 diffs, 1 prop)
• regex/regcomp.c (modified) (48 diffs, 1 prop)
• regex/regerror.c (modified) (3 diffs, 1 prop)
• regex/regex2.h (modified) (6 diffs, 1 prop)
• regex/regexec.c (modified) (7 diffs, 1 prop)
• regex/regfree.c (modified) (4 diffs, 1 prop)
• stdtime/difftime.c (modified) (2 diffs, 1 prop)
• stdtime/private.h (modified) (8 diffs, 1 prop)

branches/FREEBSD/src/emx/src/lib/bsd/db/btree/bt_split.c ¶

@@ -39 +39 @@
 #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>
@@ -727 +727 @@
          */
         if (skip <= off) {
-                skip = 0;
+                skip = MAX_PAGE_OFFSET;
                 rval = l;
         } else {
@@ -737 +737 @@
                 if (skip == nxt) {
                         ++off;
-                        skip = 0;
+                        skip = MAX_PAGE_OFFSET;
                 }
                 switch (h->flags & P_TYPE) {

branches/FREEBSD/src/emx/src/lib/bsd/db/mpool/mpool.c ¶

@@ -36 +36 @@
 #endif /* LIBC_SCCS and not lint */
 #include <sys/cdefs.h>
-__FBSDID("$FreeBSD: src/lib/libc/db/mpool/mpool.c,v 1.10 2002/03/22 21:52:01 obrien Exp $");
+__FBSDID("$FreeBSD: src/lib/libc/db/mpool/mpool.c,v 1.11 2004/01/20 00:40:35 das Exp $");
 
 #include "namespace.h"
@@ -208 +208 @@
 #endif
         off = mp->pagesize * pgno;
-        if (lseek(mp->fd, off, SEEK_SET) != off)
-                return (NULL);
-        if ((nr = _read(mp->fd, bp->page, mp->pagesize)) != mp->pagesize) {
+        nr = pread(mp->fd, bp->page, mp->pagesize, off);
+        if (nr != mp->pagesize) {
                 if (nr >= 0)
                         errno = EFTYPE;
@@ -382 +381 @@
 
         off = mp->pagesize * bp->pgno;
-        if (lseek(mp->fd, off, SEEK_SET) != off)
-                return (RET_ERROR);
-        if (_write(mp->fd, bp->page, mp->pagesize) != mp->pagesize)
+        if (pwrite(mp->fd, bp->page, mp->pagesize, off) != mp->pagesize)
                 return (RET_ERROR);
 

branches/FREEBSD/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"
@@ -308 +308 @@
                         if ((grp_storage_size << 1) > GRP_STORAGE_MAX) {
                                 grp_storage = NULL;
+                                errno = ERANGE;
                                 return (NULL);
                         }
@@ -316 +317 @@
                 }
         } while (res == NULL && rv == ERANGE);
+        if (rv != 0)
+                errno = rv;
         return (res);
 }

branches/FREEBSD/src/emx/src/lib/bsd/gen/getnetgrent.c ¶

@@ -39 +39 @@
 #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>
@@ -137 +137 @@
 };
 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 */
@@ -151 +154 @@
  */
 void
-setnetgrent(group)
-        char *group;
+setnetgrent(const char *group)
 {
 #ifdef YP
@@ -221 +223 @@
  */
 int
-getnetgrent(hostp, userp, domp)
-        char **hostp, **userp, **domp;
+getnetgrent(char **hostp, char **userp, char **domp)
 {
 #ifdef YP
@@ -242 +243 @@
  */
 void
-endnetgrent()
+endnetgrent(void)
 {
         struct linelist *lp, *olp;
@@ -279 +280 @@
 
 #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);
 
@@ -303 +304 @@
 }
 
-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)++;
@@ -328 +328 @@
  */
 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;
@@ -410 +409 @@
  */
 static int
-parse_netgrp(group)
-        char *group;
+parse_netgrp(const char *group)
 {
         char *spos, *epos;
@@ -521 +519 @@
  */
 static struct linelist *
-read_for_group(group)
-        char *group;
+read_for_group(const char *group)
 {
         char *pos, *spos, *linep, *olinep;

branches/FREEBSD/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"
@@ -380 +380 @@
                         if ((pwd_storage_size << 1) > PWD_STORAGE_MAX) {
                                 pwd_storage = NULL;
+                                errno = ERANGE;
                                 return (NULL);
                         }
@@ -388 +389 @@
                 }
         } while (res == NULL && rv == ERANGE);
+        if (rv != 0)
+                errno = rv;
         return (res);
 }
@@ -657 +660 @@
 
 static int
-pwdb_match_entry_v3(char *entry, size_t entrysize, enum nss_lookup_type how, 
+pwdb_match_entry_v3(char *entry, size_t entrysize, enum nss_lookup_type how,
     const char *name, uid_t uid)
 {
@@ -671 +674 @@
         if (how == nss_lt_all)
                 return (NS_SUCCESS);
-        if (how == nss_lt_name) 
+        if (how == nss_lt_name)
                 return (strcmp(name, entry) == 0 ? NS_SUCCESS : NS_NOTFOUND);
         for (p++; p < eom; p++)
@@ -727 +730 @@
 
 static int
-pwdb_match_entry_v4(char *entry, size_t entrysize, enum nss_lookup_type how, 
+pwdb_match_entry_v4(char *entry, size_t entrysize, enum nss_lookup_type how,
     const char *name, uid_t uid)
 {
@@ -741 +744 @@
         if (how == nss_lt_all)
                 return (NS_SUCCESS);
-        if (how == nss_lt_name) 
+        if (how == nss_lt_name)
                 return (strcmp(name, entry) == 0 ? NS_SUCCESS : NS_NOTFOUND);
         for (p++; p < eom; p++)
@@ -995 +998 @@
                 } else
                         rv = 1;
-        } 
+        }
         free(result);
         return (rv);
@@ -1029 +1032 @@
         enum nss_lookup_type how;
         int             *errnop, keylen, resultlen, rv, master;
-          
+
         name = NULL;
         uid = (uid_t)-1;
@@ -1123 +1126 @@
                             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)
@@ -1137 +1140 @@
                 if (retval != NULL)
                         *(struct passwd **)retval = pwd;
-        }
-        return (rv);    
+                rv = NS_SUCCESS;
+        }
+        return (rv);
 erange:
         *errnop = ERANGE;
@@ -1625 +1629 @@
                                 setnetgrent(&pw_name[2]);
                                 while (getnetgrent(&host, &user, &domain) !=
-                                    NULL) {
+                                    0) {
                                         if (user != NULL && user[0] != '\0')
                                                 compat_exclude(user,
@@ -1664 +1668 @@
                 st->db = NULL;
         }
-        if (rv == NS_SUCCESS) { 
+        if (rv == NS_SUCCESS) {
                 if (!from_compat) {
                         pwd->pw_fields &= ~_PWF_SOURCE;

branches/FREEBSD/src/emx/src/lib/bsd/gen/glob.c ¶

@@ -39 +39 @@
 #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 +66 @@
  */
 
+/*
+ * 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>
 #include <sys/stat.h>
@@ -73 +83 @@
 #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 +114 @@
 #ifndef DEBUG
 
-#define M_QUOTE         0x8000
-#define M_PROTECT       0x4000
-#define M_MASK          0xffff
-#define M_ASCII         0x00ff
-
-typedef u_short Char;
+#define M_QUOTE         0x8000000000ULL
+#define M_PROTECT       0x4000000000ULL
+#define M_MASK          0xffffffffffULL
+#define M_CHAR          0x00ffffffffULL
+
+typedef uint_fast64_t Char;
 
 #else
@@ -113 +126 @@
 #define M_PROTECT       0x40
 #define M_MASK          0xff
-#define M_ASCII         0x7f
+#define M_CHAR          0x7f
 
 typedef char Char;
@@ -120 +133 @@
 
 
-#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('*')
@@ -135 +148 @@
 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 *);
@@ -161 +174 @@
 {
         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;
@@ -183 +199 @@
         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;
@@ -376 +408 @@
                  * the password file
                  */
-                if (
-#ifndef __NETBSD_SYSCALLS
-                    issetugid() != 0 ||
-#endif
+                if (issetugid() != 0 ||
                     (h = getenv("HOME")) == NULL) {
                         if (((h = getlogin()) != NULL &&
@@ -640 +669 @@
                 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;
@@ -719 +761 @@
         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)) {
@@ -861 +903 @@
 g_strchr(str, ch)
         Char *str;
-        int ch;
+        wchar_t ch;
 {
         do {
@@ -876 +918 @@
         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);

branches/FREEBSD/src/emx/src/lib/bsd/gen/pw_scan.c ¶

@@ -36 +36 @@
 #endif /* LIBC_SCCS and not lint */
 #include <sys/cdefs.h>
-__FBSDID("$FreeBSD: src/lib/libc/gen/pw_scan.c,v 1.24 2002/10/11 11:35:30 maxim Exp $");
+__FBSDID("$FreeBSD: src/lib/libc/gen/pw_scan.c,v 1.25 2004/01/18 21:33:25 charnier Exp $");
 
 /*
@@ -181 +181 @@
 
         p = pw->pw_shell;
-        if (root && *p)                                 /* empty == /bin/sh */
+        if (root && *p) {                               /* empty == /bin/sh */
                 for (setusershell();;) {
                         if (!(sh = getusershell())) {
@@ -191 +191 @@
                                 break;
                 }
+                endusershell();
+        }
         if (p[0])
                 pw->pw_fields |= _PWF_SHELL;

branches/FREEBSD/src/emx/src/lib/bsd/locale/collcmp.c ¶

@@ -26 +26 @@
 
 #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));
 }

branches/FREEBSD/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"
@@ -142 +142 @@
 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);
 
 
@@ -185 +185 @@
 
 
-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);
 }
 
@@ -215 +214 @@
 
 
-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)
 {
@@ -223 +224 @@
 
         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;
 }
@@ -248 +248 @@
 {
       int     cmp;
-      
+
       cmp = strcmp(((const ns_mtab *)a)->name, ((const ns_mtab *)b)->name);
       if (cmp != 0)
@@ -267 +267 @@
         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),
@@ -306 +306 @@
 
 
-/* 
+/*
  * The first time nsdispatch is called (during a process's lifetime,
  * or after nsswitch.conf has been updated), nss_configure will
@@ -317 +317 @@
         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
@@ -332 +334 @@
         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();
@@ -354 +358 @@
         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);
 }
@@ -378 +386 @@
                 }
         }
-        vector_append(dbt, (void **)&_nsmap, &_nsmapsize, sizeof(*_nsmap));
+        _nsmap = vector_append(dbt, _nsmap, &_nsmapsize, sizeof(*_nsmap));
 }
 
@@ -434 +442 @@
         ns_mod           mod;
         nss_module_register_fn fn;
-        
+
         memset(&mod, 0, sizeof(mod));
         mod.name = strdup(source);
@@ -442 +450 @@
         }
         if (reg_fn != NULL) {
-                /* The placeholder is required, as a NULL handle 
+                /* The placeholder is required, as a NULL handle
                  * represents an invalid module.
                  */
@@ -484 +492 @@
                     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);
 }
@@ -511 +519 @@
 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);
 }
 
@@ -569 +582 @@
         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();
@@ -605 +621 @@
                 }
         }
-        (void)_pthread_rwlock_unlock(&nss_lock);
+        if (isthreaded)
+                (void)_pthread_rwlock_unlock(&nss_lock);
 fin:
         errno = serrno;

branches/FREEBSD/src/emx/src/lib/bsd/regex/engine.c ¶

@@ -39 +39 @@
 
 #include <sys/cdefs.h>
-__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 $");
 
 /*
@@ -70 +70 @@
 #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
 
 /* another structure passed up and down to avoid zillions of parameters */
@@ -86 +97 @@
         states tmp;             /* temporary */
         states empty;           /* empty set of states */
+        mbstate_t mbs;          /* multibyte conversion state */
 };
 
@@ -99 +111 @@
 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);
@@ -235 +246 @@
         SETUP(m->empty);
         CLEAR(m->empty);
+        ZAPSTATE(&m->mbs);
 
         /* Adjust start according to moffset, to speed things up */
@@ -258 +270 @@
                                 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)
@@ -317 +330 @@
                 /* 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);
         }
@@ -395 +410 @@
                         break;
                 case OCHAR:
-                        sp++;
+                        sp += XMBRTOWC(NULL, sp, stop - start, &m->mbs, 0);
                         break;
                 case OBOL:
@@ -404 +419 @@
                 case OANY:
                 case OANYOF:
-                        sp++;
+                        sp += XMBRTOWC(NULL, sp, stop - start, &m->mbs, 0);
                         break;
                 case OBACK_:
@@ -559 +574 @@
         regoff_t offsave;
         cset *cs;
+        wint_t wc;
 
         AT("back", start, stop, startst, stopst);
@@ -568 +584 @@
                 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;
@@ -574 +593 @@
                         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;
@@ -755 +779 @@
         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);
@@ -767 +792 @@
         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;
@@ -818 +856 @@
                 SP("aft", st, c);
                 assert(EQ(step(m->g, startst, stopst, st, NOTHING, st), st));
-                p++;
+                p += clen;
         }
 
@@ -824 +862 @@
         m->coldp = coldp;
         if (ISSET(st, stopst))
-                return(p+1);
+                return(p+XMBRTOWC(NULL, p, m->endp - p, &m->mbs, 0));
         else
                 return(NULL);
@@ -846 +884 @@
         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);
@@ -858 +897 @@
         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? */
@@ -909 +962 @@
                 SP("saft", st, c);
                 assert(EQ(step(m->g, startst, stopst, st, NOTHING, st), st));
-                p++;
+                p += clen;
         }
 
@@ -920 +973 @@
  == 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
@@ -936 +988 @@
 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 */
 {
@@ -954 +1006 @@
                 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;

branches/FREEBSD/src/emx/src/lib/bsd/regex/regcomp.c ¶

@@ -42 +42 @@
 #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>
@@ -51 +51 @@
 #include <stdlib.h>
 #include <regex.h>
+#include <wchar.h>
+#include <wctype.h>
 
 #include "collate.h"
@@ -57 +59 @@
 #include "regex2.h"
 
-#include "cclass.h"
 #include "cname.h"
 
@@ -84 +85 @@
 
 /* === 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);
@@ -94 +95 @@
 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);
@@ -104 +105 @@
 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);
@@ -125 +116 @@
 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
@@ -153 +145 @@
 #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))
@@ -217 +210 @@
 
         /* 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);
@@ -239 +231 @@
                 p->pend[i] = 0;
         }
-        g->csetsize = NC;
         g->sets = NULL;
-        g->setbits = NULL;
         g->ncsets = 0;
         g->cflags = cflags;
@@ -253 +243 @@
         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;
 
@@ -271 +258 @@
 
         /* tidy up loose ends and fill things in */
-        categorize(p, g);
         stripsnug(p, g);
         findmust(p, g);
@@ -357 +343 @@
 {
         char c;
+        wint_t wc;
         sopno pos;
         int count;
@@ -426 +413 @@
         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 */
@@ -433 +420 @@
                 /* FALLTHROUGH */
         default:
-                ordinary(p, c);
+                p->next--;
+                wc = WGETNEXT();
+                ordinary(p, wc);
                 break;
         }
@@ -507 +496 @@
         (void)REQUIRE(MORE(), REG_EMPTY);
         while (MORE())
-                ordinary(p, GETNEXT());
+                ordinary(p, WGETNEXT());
 }
 
@@ -517 +506 @@
  *
  * 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.
  */
@@ -565 +552 @@
         sopno pos;
         int i;
+        wint_t wc;
         sopno subno;
 #       define  BACKSL  (1<<CHAR_BIT)
@@ -636 +624 @@
                 /* FALLTHROUGH */
         default:
-                ordinary(p, (char)c);
+                p->next--;
+                wc = WGETNEXT();
+                ordinary(p, wc);
                 break;
         }
@@ -692 +682 @@
  - 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
@@ -700 +687 @@
 struct parse *p;
 {
-        cset *cs = allocset(p);
-        int invert = 0;
+        cset *cs;
+        wint_t ch;
 
         /* Dept of Truly Sickening Special-Case Kludges */
@@ -715 +702 @@
         }
 
+        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);
 
@@ -730 +722 @@
                 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));
 }
 
@@ -776 +742 @@
 {
         char c;
-        char start, finish;
-        int i;
+        wint_t start, finish;
+        wint_t i;
 
         /* classify what we've got */
@@ -813 +779 @@
                 break;
         default:                /* symbol, ordinary character, or range */
-/* xxx revision needed for multichar stuff */
                 start = p_b_symbol(p);
                 if (SEE('-') && MORE2() && PEEK2() != ']') {
@@ -825 +790 @@
                         finish = start;
                 if (start == finish)
-                        CHadd(cs, start);
+                        CHadd(p, cs, start);
                 else {
                         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 {
                                 (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);
                                 }
                         }
@@ -854 +818 @@
 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);
 }
 
@@ -950 +850 @@
 cset *cs;
 {
-        char c;
+        wint_t c;
 
         c = p_b_coll_elem(p, '=');
-        CHadd(cs, c);
+        CHadd(p, cs, c);
 }
 
@@ -960 +860 @@
  == 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 */
@@ -980 +880 @@
  == 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, ']'))
@@ -999 +902 @@
                 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);
 }
@@ -1009 +916 @@
  == 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);
@@ -1032 +938 @@
 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;
@@ -1058 +967 @@
 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));
         }
 }
@@ -1170 +1086 @@
 
 /*
+ - 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);
@@ -1193 +1134 @@
 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);
@@ -1249 +1157 @@
 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--;
@@ -1260 +1168 @@
 
 /*
- - 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;
 }
 
@@ -1697 +1447 @@
         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 */
@@ -1705 +1456 @@
                 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;
+        /*
+         * 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;
 
         /* find the longest OCHAR sequence in strip */
@@ -1720 +1474 @@
                 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 */
@@ -1730 +1489 @@
                 case OQUEST_:           /* things that must be skipped */
                 case OCH_:
-                        offset = altoffset(scan, offset, mccs);
+                        offset = altoffset(scan, offset);
                         scan--;
                         do {
@@ -1798 +1557 @@
                                 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
@@ -1838 +1593 @@
         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);
@@ -1850 +1607 @@
 /*
  - 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
@@ -1856 +1613 @@
  */
 static int
-altoffset(scan, offset, mccs)
+altoffset(scan, offset)
 sop *scan;
 int offset;
-int mccs;
 {
         int largest;
@@ -1881 +1637 @@
                 case OQUEST_:
                 case OCH_:
-                        try = altoffset(scan, try, mccs);
+                        try = altoffset(scan, try);
                         if (try == -1)
                                 return -1;
@@ -1898 +1654 @@
                         break;
                 case OANYOF:
-                        if (mccs)
-                                return -1;
                 case OCHAR:
                 case OANY:

branches/FREEBSD/src/emx/src/lib/bsd/regex/regerror.c ¶

@@ -42 +42 @@
 #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>
@@ -82 +82 @@
  = #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 (!)
@@ -106 +107 @@
         {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 ***"}
 };

branches/FREEBSD/src/emx/src/lib/bsd/regex/regex2.h ¶

@@ -36 +36 @@
  *
  *      @(#)regex2.h    8.4 (Berkeley) 3/20/94
- * $FreeBSD: src/lib/libc/regex/regex2.h,v 1.6 2002/03/22 23:41:56 obrien Exp $
+ * $FreeBSD: src/lib/libc/regex/regex2.h,v 1.8 2004/07/12 07:35:59 tjr Exp $
  */
 
@@ -88 +88 @@
 /*                                              (back, fwd are offsets) */
 #define OEND    (1L<<OPSHIFT)   /* endmarker    -                       */
-#define OCHAR   (2L<<OPSHIFT)   /* character    unsigned char           */
+#define OCHAR   (2L<<OPSHIFT)   /* character    wide character          */
 #define OBOL    (3L<<OPSHIFT)   /* left anchor  -                       */
 #define OEOL    (4L<<OPSHIFT)   /* right anchor -                       */
@@ -109 +109 @@
 
 /*
- * Structure for [] character-set representation.  Character sets are
- * done as bit vectors, grouped 8 to a byte vector for compactness.
- * The individual set therefore has both a pointer to the byte vector
- * and a mask to pick out the relevant bit of each byte.  A hash code
- * simplifies testing whether two sets could be identical.
- *
- * This will get trickier for multicharacter collating elements.  As
- * preliminary hooks for dealing with such things, we also carry along
- * a string of multi-character elements, and decide the size of the
- * vectors at run time.
+ * Structures for [] character-set representation.
  */
 typedef struct {
-        uch *ptr;               /* -> uch [csetsize] */
-        uch mask;               /* bit within array */
-        short hash;             /* hash code */
-        size_t smultis;
-        char *multis;           /* -> char[smulti]  ab\0cd\0ef\0\0 */
+        wint_t          min;
+        wint_t          max;
+} crange;
+typedef struct {
+        unsigned char   bmp[NC / 8];
+        wctype_t        *types;
+        int             ntypes;
+        wint_t          *wides;
+        int             nwides;
+        crange          *ranges;
+        int             nranges;
+        int             invert;
+        int             icase;
 } cset;
-/* note that CHadd and CHsub are unsafe, and CHIN doesn't yield 0/1 */
-#define CHadd(cs, c)    ((cs)->ptr[(uch)(c)] |= (cs)->mask, (cs)->hash += (uch)(c))
-#define CHsub(cs, c)    ((cs)->ptr[(uch)(c)] &= ~(cs)->mask, (cs)->hash -= (uch)(c))
-#define CHIN(cs, c)     ((cs)->ptr[(uch)(c)] & (cs)->mask)
-#define MCadd(p, cs, cp)        mcadd(p, cs, cp)        /* regcomp() internal fns */
-#define MCsub(p, cs, cp)        mcsub(p, cs, cp)
-#define MCin(p, cs, cp) mcin(p, cs, cp)
-
-/* stuff for character categories */
-typedef unsigned char cat_t;
+
+static int
+CHIN1(cs, ch)
+cset *cs;
+wint_t ch;
+{
+        int i;
+
+        assert(ch >= 0);
+        if (ch < NC)
+                return (((cs->bmp[ch >> 3] & (1 << (ch & 7))) != 0) ^
+                    cs->invert);
+        for (i = 0; i < cs->nwides; i++)
+                if (ch == cs->wides[i])
+                        return (!cs->invert);
+        for (i = 0; i < cs->nranges; i++)
+                if (cs->ranges[i].min <= ch && ch <= cs->ranges[i].max)
+                        return (!cs->invert);
+        for (i = 0; i < cs->ntypes; i++)
+                if (iswctype(ch, cs->types[i]))
+                        return (!cs->invert);
+        return (cs->invert);
+}
+
+static __inline int
+CHIN(cs, ch)
+cset *cs;
+wint_t ch;
+{
+
+        assert(ch >= 0);
+        if (ch < NC)
+                return (((cs->bmp[ch >> 3] & (1 << (ch & 7))) != 0) ^
+                    cs->invert);
+        else if (cs->icase)
+                return (CHIN1(cs, ch) || CHIN1(cs, towlower(ch)) ||
+                    CHIN1(cs, towupper(ch)));
+        else
+                return (CHIN1(cs, ch));
+}
 
 /*
@@ -145 +174 @@
 #               define  MAGIC2  ((('R'^0200)<<8)|'E')
         sop *strip;             /* malloced area for strip */
-        int csetsize;           /* number of bits in a cset vector */
         int ncsets;             /* number of csets in use */
         cset *sets;             /* -> cset [ncsets] */
-        uch *setbits;           /* -> uch[csetsize][ncsets/CHAR_BIT] */
         int cflags;             /* copy of regcomp() cflags argument */
         sopno nstates;          /* = number of sops */
@@ -159 +186 @@
         int nbol;               /* number of ^ used */
         int neol;               /* number of $ used */
-        int ncategories;        /* how many character categories */
-        cat_t *categories;      /* ->catspace[-CHAR_MIN] */
         char *must;             /* match must contain this string */
         int moffset;            /* latest point at which must may be located */
@@ -169 +194 @@
         int backrefs;           /* does it use back references? */
         sopno nplus;            /* how deep does it nest +s? */
-        /* catspace must be last */
-        cat_t catspace[1];      /* actually [NC] */
 };
 
 /* misc utilities */
-#define OUT     (CHAR_MAX+1)    /* a non-character value */
-#define ISWORD(c)       (isalnum((uch)(c)) || (c) == '_')
+#define OUT     (-2)    /* a non-character value */
+#define ISWORD(c)       (iswalnum((uch)(c)) || (c) == '_')

branches/FREEBSD/src/emx/src/lib/bsd/regex/regexec.c ¶

@@ -42 +42 @@
 #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>
@@ -58 +58 @@
 #include <ctype.h>
 #include <regex.h>
+#include <wchar.h>
+#include <wctype.h>
 
 #include "utils.h"
@@ -63 +65 @@
 
 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 */
@@ -86 +127 @@
 #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 */
@@ -111 +155 @@
 #undef  ISSETBACK
 #undef  SNAMES
+#undef  XMBRTOWC
+#undef  ZAPSTATE
 
 /* macros for manipulating states, large version */
@@ -135 +181 @@
 #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"
@@ -177 +236 @@
         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

branches/FREEBSD/src/emx/src/lib/bsd/regex/regfree.c ¶

@@ -42 +42 @@
 #endif /* LIBC_SCCS and not lint */
 #include <sys/cdefs.h>
-__FBSDID("$FreeBSD: src/lib/libc/regex/regfree.c,v 1.5 2002/03/22 21:52:47 obrien Exp $");
+__FBSDID("$FreeBSD: src/lib/libc/regex/regfree.c,v 1.6 2004/07/12 07:35:59 tjr Exp $");
 
 #include <sys/types.h>
@@ -49 +49 @@
 #include <limits.h>
 #include <regex.h>
+#include <wchar.h>
+#include <wctype.h>
 
 #include "utils.h"
@@ -62 +64 @@
 {
         struct re_guts *g;
+        int i;
 
         if (preg->re_magic != MAGIC1)   /* oops */
@@ -74 +77 @@
         if (g->strip != NULL)
                 free((char *)g->strip);
-        if (g->sets != NULL)
+        if (g->sets != NULL) {
+                for (i = 0; i < g->ncsets; i++) {
+                        free(g->sets[i].ranges);
+                        free(g->sets[i].wides);
+                        free(g->sets[i].types);
+                }
                 free((char *)g->sets);
-        if (g->setbits != NULL)
-                free((char *)g->setbits);
+        }
         if (g->must != NULL)
                 free(g->must);

branches/FREEBSD/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*/
@@ -37 +37 @@
         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);

branches/FREEBSD/src/emx/src/lib/bsd/stdtime/private.h ¶

@@ -2 +2 @@
 
 #define PRIVATE_H
+
 /*
 ** This file is in the public domain, so clarified as of
-** June 5, 1996 by Arthur David Olson (arthur_david_olson@nih.gov).
+** 1996-06-05 by Arthur David Olson (arthur_david_olson@nih.gov).
 **
-** $FreeBSD: src/lib/libc/stdtime/private.h,v 1.9 2002/05/28 16:59:40 alfred Exp $
+** $FreeBSD: src/lib/libc/stdtime/private.h,v 1.10 2004/06/14 10:31:52 stefanf Exp $
 */
 
@@ -37 +38 @@
 #ifndef NOID
 /*
-static char     privatehid[] = "@(#)private.h   7.43";
+static char     privatehid[] = "@(#)private.h   7.53";
 */
 #endif /* !defined NOID */
@@ -55 +56 @@
 #endif /* !defined HAVE_GETTEXT */
 
+#ifndef HAVE_INCOMPATIBLE_CTIME_R
+#define HAVE_INCOMPATIBLE_CTIME_R       0
+#endif /* !defined INCOMPATIBLE_CTIME_R */
+
 #ifndef HAVE_SETTIMEOFDAY
 #define HAVE_SETTIMEOFDAY       3
@@ -60 +65 @@
 
 #ifndef HAVE_STRERROR
-#define HAVE_STRERROR           0
+#define HAVE_STRERROR           1
 #endif /* !defined HAVE_STRERROR */
+
+#ifndef HAVE_SYMLINK
+#define HAVE_SYMLINK            1
+#endif /* !defined HAVE_SYMLINK */
+
+#ifndef HAVE_SYS_STAT_H
+#define HAVE_SYS_STAT_H         1
+#endif /* !defined HAVE_SYS_STAT_H */
+
+#ifndef HAVE_SYS_WAIT_H
+#define HAVE_SYS_WAIT_H         1
+#endif /* !defined HAVE_SYS_WAIT_H */
 
 #ifndef HAVE_UNISTD_H
@@ -74 +91 @@
 #define LOCALE_HOME             "/usr/lib/locale"
 #endif /* !defined LOCALE_HOME */
+
+#if HAVE_INCOMPATIBLE_CTIME_R
+#define asctime_r _incompatible_asctime_r
+#define ctime_r _incompatible_ctime_r
+#endif /* HAVE_INCOMPATIBLE_CTIME_R */
 
 /*
@@ -90 +112 @@
 #include "libintl.h"
 #endif /* HAVE_GETTEXT - 0 */
+
+#if HAVE_SYS_WAIT_H - 0
+#include <sys/wait.h>   /* for WIFEXITED and WEXITSTATUS */
+#endif /* HAVE_SYS_WAIT_H - 0 */
+
+#ifndef WIFEXITED
+#define WIFEXITED(status)       (((status) & 0xff) == 0)
+#endif /* !defined WIFEXITED */
+#ifndef WEXITSTATUS
+#define WEXITSTATUS(status)     (((status) >> 8) & 0xff)
+#endif /* !defined WEXITSTATUS */
 
 #if HAVE_UNISTD_H - 0
@@ -127 +160 @@
 
 #endif /* !defined FILENAME_MAX */
+
+/*
+** Private function declarations.
+*/
+char *  icalloc(int nelem, int elsize);
+char *  icatalloc(char * old, const char * new);
+char *  icpyalloc(const char * string);
+char *  imalloc(int n);
+void *  irealloc(void * pointer, int size);
+void    icfree(char * pointer);
+void    ifree(char * pointer);
+char *  scheck(const char *string, const char *format);
+
 
 /*
@@ -201 +247 @@
 #endif /* !defined TZ_DOMAIN */
 
-/*
-** UNIX was a registered trademark of UNIX System Laboratories in 1993.
+#if HAVE_INCOMPATIBLE_CTIME_R
+#undef asctime_r
+#undef ctime_r
+char *asctime_r(struct tm const *, char *);
+char *ctime_r(time_t const *, char *);
+#endif /* HAVE_INCOMPATIBLE_CTIME_R */
+
+/*
+** UNIX was a registered trademark of The Open Group in 2003.
 */