--- a/nsprpub/TAG-INFO
+++ b/nsprpub/TAG-INFO
@@ -1,1 +1,1 @@
-NSPR_4_22_RTM
+NSPR_4_23_BETA1
\ No newline at end of file

--- a/nsprpub/config/libc_r.h
+++ b/nsprpub/config/libc_r.h
@@ -20,17 +20,17 @@
 #define _LIBC_R_H
 
 /************/
 /*  strtok  */
 /************/
 #define R_STRTOK_INIT_R() \
     char *r_strtok_r=NULL
 
-#define R_STRTOK_R(return,source,delim) \     
+#define R_STRTOK_R(return,source,delim) \
     return=strtok_r(source,delim,&r_strtok_r)
 
 #define R_STRTOK_NORET_R(source,delim) \
     strtok_r(source,delim,&r_strtok_r)
 
 /**************/
 /*  strerror  */
 /**************/
@@ -63,24 +63,24 @@
 #define R_GMTIME_R(time) \
     gmtime_r(time,&r_gmtime_r)
 
 #define R_LOCALTIME_INIT_R() \
    struct tm r_localtime_r
 
 #define R_LOCALTIME_R(val) \
    localtime_r(val,&r_localtime_r)
-    
+
 /***********/
 /*  crypt  */
 /***********/
 #include <crypt.h>
 #define R_CRYPT_INIT_R() \
     CRYPTD r_cryptd_r; \
-    bzero(&r_cryptd_r,sizeof(CRYPTD)) 
+    bzero(&r_cryptd_r,sizeof(CRYPTD))
 
 #define R_CRYPT_R(pass,salt) \
     crypt_r(pass,salt,&r_cryptd_r)
 
 /**************/
 /*  pw stuff  */
 /**************/
 #define R_MAX_PW_LEN_R 1024

--- a/nsprpub/config/nsinstall.c
+++ b/nsprpub/config/nsinstall.c
@@ -34,95 +34,102 @@
 /*
  * Does getcwd() take NULL as the first argument and malloc
  * the result buffer?
  */
 #if !defined(DARWIN)
 #define GETCWD_CAN_MALLOC
 #endif
 
-#if defined(LINUX) || defined(__GNU__) || defined(__GLIBC__) 
+#if defined(LINUX) || defined(__GNU__) || defined(__GLIBC__)
 #include <getopt.h>
 #endif
 
 #if defined(SCO) || defined(UNIXWARE)
 #if !defined(S_ISLNK) && defined(S_IFLNK)
-#define S_ISLNK(a)	(((a) & S_IFMT) == S_IFLNK)
+#define S_ISLNK(a)  (((a) & S_IFMT) == S_IFLNK)
 #endif
 #endif
 
 #ifdef QNX
 #define d_ino d_stat.st_ino
 #endif
 
 static void
 usage(void)
 {
     fprintf(stderr,
-	"usage: %s [-C cwd] [-L linkprefix] [-m mode] [-o owner] [-g group]\n"
-	"       %*s [-DdltR] file [file ...] directory\n",
-	program, (int)strlen(program), "");
+            "usage: %s [-C cwd] [-L linkprefix] [-m mode] [-o owner] [-g group]\n"
+            "       %*s [-DdltR] file [file ...] directory\n",
+            program, (int)strlen(program), "");
     exit(2);
 }
 
 static int
 mkdirs(char *path, mode_t mode)
 {
     char *cp;
     struct stat sb;
     int res;
-    
-    while (*path == '/' && path[1] == '/')
-	path++;
+
+    while (*path == '/' && path[1] == '/') {
+        path++;
+    }
     for (cp = strrchr(path, '/'); cp && cp != path && cp[-1] == '/'; cp--)
-	;
+        ;
     if (cp && cp != path) {
-	*cp = '\0';
-	if ((stat(path, &sb) < 0 || !S_ISDIR(sb.st_mode)) &&
-	    mkdirs(path, mode) < 0) {
-	    return -1;
-	}
-	*cp = '/';
+        *cp = '\0';
+        if ((stat(path, &sb) < 0 || !S_ISDIR(sb.st_mode)) &&
+            mkdirs(path, mode) < 0) {
+            return -1;
+        }
+        *cp = '/';
     }
     res = mkdir(path, mode);
-    if ((res != 0) && (errno == EEXIST))
-	return 0;
-     else
-	return res;
+    if ((res != 0) && (errno == EEXIST)) {
+        return 0;
+    }
+    else {
+        return res;
+    }
 }
 
 static uid_t
 touid(char *owner)
 {
     struct passwd *pw;
     uid_t uid;
     char *cp;
 
     pw = getpwnam(owner);
-    if (pw)
-	return pw->pw_uid;
+    if (pw) {
+        return pw->pw_uid;
+    }
     uid = strtol(owner, &cp, 0);
-    if (uid == 0 && cp == owner)
-	fail("cannot find uid for %s", owner);
+    if (uid == 0 && cp == owner) {
+        fail("cannot find uid for %s", owner);
+    }
     return uid;
 }
 
 static gid_t
 togid(char *group)
 {
     struct group *gr;
     gid_t gid;
     char *cp;
 
     gr = getgrnam(group);
-    if (gr)
-	return gr->gr_gid;
+    if (gr) {
+        return gr->gr_gid;
+    }
     gid = strtol(group, &cp, 0);
-    if (gid == 0 && cp == group)
-	fail("cannot find gid for %s", group);
+    if (gid == 0 && cp == group) {
+        fail("cannot find gid for %s", group);
+    }
     return gid;
 }
 
 int
 main(int argc, char **argv)
 {
     int onlydir, dodir, dolink, dorelsymlink, dotimes, opt, len, lplen, tdlen, bnlen, exists, fromfd, tofd, cc, wc;
     mode_t mode = 0755;
@@ -132,205 +139,222 @@ main(int argc, char **argv)
     struct stat sb, tosb;
     struct utimbuf utb;
 
     program = argv[0];
     cwd = linkname = linkprefix = owner = group = 0;
     onlydir = dodir = dolink = dorelsymlink = dotimes = lplen = 0;
 
     while ((opt = getopt(argc, argv, "C:DdlL:Rm:o:g:t")) != EOF) {
-	switch (opt) {
-	  case 'C':
-	    cwd = optarg;
-	    break;
-	  case 'D':
-	    onlydir = 1;
-	    break;
-	  case 'd':
-	    dodir = 1;
-	    break;
-	  case 'l':
-	    dolink = 1;
-	    break;
-	  case 'L':
-	    linkprefix = optarg;
-	    lplen = strlen(linkprefix);
-	    dolink = 1;
-	    break;
-	  case 'R':
-	    dolink = dorelsymlink = 1;
-	    break;
-	  case 'm':
-	    mode = strtoul(optarg, &cp, 8);
-	    if (mode == 0 && cp == optarg)
-		usage();
-	    break;
-	  case 'o':
-	    owner = optarg;
-	    break;
-	  case 'g':
-	    group = optarg;
-	    break;
-	  case 't':
-	    dotimes = 1;
-	    break;
-	  default:
-	    usage();
-	}
+        switch (opt) {
+            case 'C':
+                cwd = optarg;
+                break;
+            case 'D':
+                onlydir = 1;
+                break;
+            case 'd':
+                dodir = 1;
+                break;
+            case 'l':
+                dolink = 1;
+                break;
+            case 'L':
+                linkprefix = optarg;
+                lplen = strlen(linkprefix);
+                dolink = 1;
+                break;
+            case 'R':
+                dolink = dorelsymlink = 1;
+                break;
+            case 'm':
+                mode = strtoul(optarg, &cp, 8);
+                if (mode == 0 && cp == optarg) {
+                    usage();
+                }
+                break;
+            case 'o':
+                owner = optarg;
+                break;
+            case 'g':
+                group = optarg;
+                break;
+            case 't':
+                dotimes = 1;
+                break;
+            default:
+                usage();
+        }
     }
 
     argc -= optind;
     argv += optind;
-    if (argc < 2 - onlydir)
-	usage();
+    if (argc < 2 - onlydir) {
+        usage();
+    }
 
     todir = argv[argc-1];
     if ((stat(todir, &sb) < 0 || !S_ISDIR(sb.st_mode)) &&
-	mkdirs(todir, 0777) < 0) {
-	fail("cannot make directory %s", todir);
+        mkdirs(todir, 0777) < 0) {
+        fail("cannot make directory %s", todir);
     }
-    if (onlydir)
-	return 0;
+    if (onlydir) {
+        return 0;
+    }
 
     if (!cwd) {
 #ifdef GETCWD_CAN_MALLOC
-	cwd = getcwd(0, PATH_MAX);
+        cwd = getcwd(0, PATH_MAX);
 #else
-	cwd = malloc(PATH_MAX + 1);
-	cwd = getcwd(cwd, PATH_MAX);
+        cwd = malloc(PATH_MAX + 1);
+        cwd = getcwd(cwd, PATH_MAX);
 #endif
     }
     xchdir(todir);
 #ifdef GETCWD_CAN_MALLOC
     todir = getcwd(0, PATH_MAX);
 #else
     todir = malloc(PATH_MAX + 1);
     todir = getcwd(todir, PATH_MAX);
 #endif
     xchdir(cwd);
     tdlen = strlen(todir);
 
     uid = owner ? touid(owner) : -1;
     gid = group ? togid(group) : -1;
 
     while (--argc > 0) {
-	name = *argv++;
-	len = strlen(name);
-	base = xbasename(name);
-	bnlen = strlen(base);
-	toname = (char*)xmalloc(tdlen + 1 + bnlen + 1);
-	sprintf(toname, "%s/%s", todir, base);
-	exists = (lstat(toname, &tosb) == 0);
+        name = *argv++;
+        len = strlen(name);
+        base = xbasename(name);
+        bnlen = strlen(base);
+        toname = (char*)xmalloc(tdlen + 1 + bnlen + 1);
+        sprintf(toname, "%s/%s", todir, base);
+        exists = (lstat(toname, &tosb) == 0);
 
-	if (dodir) {
-	    /* -d means create a directory, always */
-	    if (exists && !S_ISDIR(tosb.st_mode)) {
-		(void) unlink(toname);
-		exists = 0;
-	    }
-	    if (!exists && mkdir(toname, mode) < 0)
-		fail("cannot make directory %s", toname);
-	    if ((owner || group) && chown(toname, uid, gid) < 0)
-		fail("cannot change owner of %s", toname);
-	} else if (dolink) {
-	    if (*name == '/') {
-		/* source is absolute pathname, link to it directly */
-		linkname = 0;
-	    } else {
-		if (linkprefix) {
-		    /* -L implies -l and prefixes names with a $cwd arg. */
-		    len += lplen + 1;
-		    linkname = (char*)xmalloc(len + 1);
-		    sprintf(linkname, "%s/%s", linkprefix, name);
-		} else if (dorelsymlink) {
-		    /* Symlink the relative path from todir to source name. */
-		    linkname = (char*)xmalloc(PATH_MAX);
+        if (dodir) {
+            /* -d means create a directory, always */
+            if (exists && !S_ISDIR(tosb.st_mode)) {
+                (void) unlink(toname);
+                exists = 0;
+            }
+            if (!exists && mkdir(toname, mode) < 0) {
+                fail("cannot make directory %s", toname);
+            }
+            if ((owner || group) && chown(toname, uid, gid) < 0) {
+                fail("cannot change owner of %s", toname);
+            }
+        } else if (dolink) {
+            if (*name == '/') {
+                /* source is absolute pathname, link to it directly */
+                linkname = 0;
+            } else {
+                if (linkprefix) {
+                    /* -L implies -l and prefixes names with a $cwd arg. */
+                    len += lplen + 1;
+                    linkname = (char*)xmalloc(len + 1);
+                    sprintf(linkname, "%s/%s", linkprefix, name);
+                } else if (dorelsymlink) {
+                    /* Symlink the relative path from todir to source name. */
+                    linkname = (char*)xmalloc(PATH_MAX);
 
-		    if (*todir == '/') {
-			/* todir is absolute: skip over common prefix. */
-			lplen = relatepaths(todir, cwd, linkname);
-			strcpy(linkname + lplen, name);
-		    } else {
-			/* todir is named by a relative path: reverse it. */
-			reversepath(todir, name, len, linkname);
-			xchdir(cwd);
-		    }
+                    if (*todir == '/') {
+                        /* todir is absolute: skip over common prefix. */
+                        lplen = relatepaths(todir, cwd, linkname);
+                        strcpy(linkname + lplen, name);
+                    } else {
+                        /* todir is named by a relative path: reverse it. */
+                        reversepath(todir, name, len, linkname);
+                        xchdir(cwd);
+                    }
+
+                    len = strlen(linkname);
+                }
+                name = linkname;
+            }
 
-		    len = strlen(linkname);
-		}
-		name = linkname;
-	    }
-
-	    /* Check for a pre-existing symlink with identical content. */
-	    if (exists &&
-		(!S_ISLNK(tosb.st_mode) ||
-		 readlink(toname, buf, sizeof buf) != len ||
-		 strncmp(buf, name, len) != 0)) {
-		(void) (S_ISDIR(tosb.st_mode) ? rmdir : unlink)(toname);
-		exists = 0;
-	    }
-	    if (!exists && symlink(name, toname) < 0)
-		fail("cannot make symbolic link %s", toname);
+            /* Check for a pre-existing symlink with identical content. */
+            if (exists &&
+                (!S_ISLNK(tosb.st_mode) ||
+                 readlink(toname, buf, sizeof buf) != len ||
+                 strncmp(buf, name, len) != 0)) {
+                (void) (S_ISDIR(tosb.st_mode) ? rmdir : unlink)(toname);
+                exists = 0;
+            }
+            if (!exists && symlink(name, toname) < 0) {
+                fail("cannot make symbolic link %s", toname);
+            }
 #ifdef HAVE_LCHOWN
-	    if ((owner || group) && lchown(toname, uid, gid) < 0)
-		fail("cannot change owner of %s", toname);
+            if ((owner || group) && lchown(toname, uid, gid) < 0) {
+                fail("cannot change owner of %s", toname);
+            }
 #endif
 
-	    if (linkname) {
-		free(linkname);
-		linkname = 0;
-	    }
-	} else {
-	    /* Copy from name to toname, which might be the same file. */
-	    fromfd = open(name, O_RDONLY);
-	    if (fromfd < 0 || fstat(fromfd, &sb) < 0)
-		fail("cannot access %s", name);
-	    if (exists && (!S_ISREG(tosb.st_mode) || access(toname, W_OK) < 0))
-		(void) (S_ISDIR(tosb.st_mode) ? rmdir : unlink)(toname);
-	    tofd = open(toname, O_CREAT | O_WRONLY, 0666);
-	    if (tofd < 0)
-		fail("cannot create %s", toname);
+            if (linkname) {
+                free(linkname);
+                linkname = 0;
+            }
+        } else {
+            /* Copy from name to toname, which might be the same file. */
+            fromfd = open(name, O_RDONLY);
+            if (fromfd < 0 || fstat(fromfd, &sb) < 0) {
+                fail("cannot access %s", name);
+            }
+            if (exists && (!S_ISREG(tosb.st_mode) || access(toname, W_OK) < 0)) {
+                (void) (S_ISDIR(tosb.st_mode) ? rmdir : unlink)(toname);
+            }
+            tofd = open(toname, O_CREAT | O_WRONLY, 0666);
+            if (tofd < 0) {
+                fail("cannot create %s", toname);
+            }
 
-	    bp = buf;
-	    while ((cc = read(fromfd, bp, sizeof buf)) > 0) {
-		while ((wc = write(tofd, bp, cc)) > 0) {
-		    if ((cc -= wc) == 0)
-			break;
-		    bp += wc;
-		}
-		if (wc < 0)
-		    fail("cannot write to %s", toname);
-	    }
-	    if (cc < 0)
-		fail("cannot read from %s", name);
+            bp = buf;
+            while ((cc = read(fromfd, bp, sizeof buf)) > 0) {
+                while ((wc = write(tofd, bp, cc)) > 0) {
+                    if ((cc -= wc) == 0) {
+                        break;
+                    }
+                    bp += wc;
+                }
+                if (wc < 0) {
+                    fail("cannot write to %s", toname);
+                }
+            }
+            if (cc < 0) {
+                fail("cannot read from %s", name);
+            }
 
-	    if (ftruncate(tofd, sb.st_size) < 0)
-		fail("cannot truncate %s", toname);
-	    if (dotimes) {
-		utb.actime = sb.st_atime;
-		utb.modtime = sb.st_mtime;
-		if (utime(toname, &utb) < 0)
-		    fail("cannot set times of %s", toname);
-	    }
+            if (ftruncate(tofd, sb.st_size) < 0) {
+                fail("cannot truncate %s", toname);
+            }
+            if (dotimes) {
+                utb.actime = sb.st_atime;
+                utb.modtime = sb.st_mtime;
+                if (utime(toname, &utb) < 0) {
+                    fail("cannot set times of %s", toname);
+                }
+            }
 #ifdef HAVE_FCHMOD
-	    if (fchmod(tofd, mode) < 0)
+            if (fchmod(tofd, mode) < 0)
 #else
-	    if (chmod(toname, mode) < 0)
+            if (chmod(toname, mode) < 0)
 #endif
-		fail("cannot change mode of %s", toname);
-	    if ((owner || group) && fchown(tofd, uid, gid) < 0)
-		fail("cannot change owner of %s", toname);
+                fail("cannot change mode of %s", toname);
+            if ((owner || group) && fchown(tofd, uid, gid) < 0) {
+                fail("cannot change owner of %s", toname);
+            }
 
-	    /* Must check for delayed (NFS) write errors on close. */
-	    if (close(tofd) < 0)
-		fail("cannot write to %s", toname);
-	    close(fromfd);
-	}
+            /* Must check for delayed (NFS) write errors on close. */
+            if (close(tofd) < 0) {
+                fail("cannot write to %s", toname);
+            }
+            close(fromfd);
+        }
 
-	free(toname);
+        free(toname);
     }
 
     free(cwd);
     free(todir);
     return 0;
 }
 
 /*
@@ -354,169 +378,183 @@ fail(char *format, ...)
     error = errno;
     fprintf(stderr, "%s: ", program);
     va_start(ap, format);
     vfprintf(stderr, format, ap);
     va_end(ap);
     if (error)
 
 #ifdef USE_REENTRANT_LIBC
-    R_STRERROR_R(errno);
-	fprintf(stderr, ": %s", r_strerror_r);
+        R_STRERROR_R(errno);
+    fprintf(stderr, ": %s", r_strerror_r);
 #else
-	fprintf(stderr, ": %s", strerror(errno));
+        fprintf(stderr, ": %s", strerror(errno));
 #endif
 
     putc('\n', stderr);
     exit(1);
 }
 
 char *
 getcomponent(char *path, char *name)
 {
-    if (*path == '\0')
-	return 0;
+    if (*path == '\0') {
+        return 0;
+    }
     if (*path == '/') {
-	*name++ = '/';
+        *name++ = '/';
     } else {
-	do {
-	    *name++ = *path++;
-	} while (*path != '/' && *path != '\0');
+        do {
+            *name++ = *path++;
+        } while (*path != '/' && *path != '\0');
     }
     *name = '\0';
-    while (*path == '/')
-	path++;
+    while (*path == '/') {
+        path++;
+    }
     return path;
 }
 
 #ifdef UNIXWARE_READDIR_BUFFER_TOO_SMALL
 /* Sigh.  The static buffer in Unixware's readdir is too small. */
 struct dirent * readdir(DIR *d)
 {
-        static struct dirent *buf = NULL;
+    static struct dirent *buf = NULL;
 #define MAX_PATH_LEN 1024
 
 
-        if(buf == NULL)
-                buf = (struct dirent *) malloc(sizeof(struct dirent) + MAX_PATH_LEN)
-;
-        return(readdir_r(d, buf));
+    if(buf == NULL)
+        buf = (struct dirent *) malloc(sizeof(struct dirent) + MAX_PATH_LEN)
+              ;
+    return(readdir_r(d, buf));
 }
 #endif
 
 char *
 ino2name(ino_t ino, char *dir)
 {
     DIR *dp;
     struct dirent *ep;
     char *name;
 
     dp = opendir("..");
-    if (!dp)
-	fail("cannot read parent directory");
+    if (!dp) {
+        fail("cannot read parent directory");
+    }
     for (;;) {
-	if (!(ep = readdir(dp)))
-	    fail("cannot find current directory");
-	if (ep->d_ino == ino)
-	    break;
+        if (!(ep = readdir(dp))) {
+            fail("cannot find current directory");
+        }
+        if (ep->d_ino == ino) {
+            break;
+        }
     }
     name = xstrdup(ep->d_name);
     closedir(dp);
     return name;
 }
 
 void *
 xmalloc(size_t size)
 {
     void *p = malloc(size);
-    if (!p)
-	fail("cannot allocate %u bytes", size);
+    if (!p) {
+        fail("cannot allocate %u bytes", size);
+    }
     return p;
 }
 
 char *
 xstrdup(char *s)
 {
     return strcpy((char*)xmalloc(strlen(s) + 1), s);
 }
 
 char *
 xbasename(char *path)
 {
     char *cp;
 
-    while ((cp = strrchr(path, '/')) && cp[1] == '\0')
-	*cp = '\0';
-    if (!cp) return path;
+    while ((cp = strrchr(path, '/')) && cp[1] == '\0') {
+        *cp = '\0';
+    }
+    if (!cp) {
+        return path;
+    }
     return cp + 1;
 }
 
 void
 xchdir(char *dir)
 {
-    if (chdir(dir) < 0)
-	fail("cannot change directory to %s", dir);
+    if (chdir(dir) < 0) {
+        fail("cannot change directory to %s", dir);
+    }
 }
 
 int
 relatepaths(char *from, char *to, char *outpath)
 {
     char *cp, *cp2;
     int len;
     char buf[NAME_MAX];
 
     assert(*from == '/' && *to == '/');
     for (cp = to, cp2 = from; *cp == *cp2; cp++, cp2++)
-	if (*cp == '\0')
-	    break;
-    while (cp[-1] != '/')
-	cp--, cp2--;
+        if (*cp == '\0') {
+            break;
+        }
+    while (cp[-1] != '/') {
+        cp--, cp2--;
+    }
     if (cp - 1 == to) {
-	/* closest common ancestor is /, so use full pathname */
-	len = strlen(strcpy(outpath, to));
-	if (outpath[len] != '/') {
-	    outpath[len++] = '/';
-	    outpath[len] = '\0';
-	}
+        /* closest common ancestor is /, so use full pathname */
+        len = strlen(strcpy(outpath, to));
+        if (outpath[len] != '/') {
+            outpath[len++] = '/';
+            outpath[len] = '\0';
+        }
     } else {
-	len = 0;
-	while ((cp2 = getcomponent(cp2, buf)) != 0) {
-	    strcpy(outpath + len, "../");
-	    len += 3;
-	}
-	while ((cp = getcomponent(cp, buf)) != 0) {
-	    sprintf(outpath + len, "%s/", buf);
-	    len += strlen(outpath + len);
-	}
+        len = 0;
+        while ((cp2 = getcomponent(cp2, buf)) != 0) {
+            strcpy(outpath + len, "../");
+            len += 3;
+        }
+        while ((cp = getcomponent(cp, buf)) != 0) {
+            sprintf(outpath + len, "%s/", buf);
+            len += strlen(outpath + len);
+        }
     }
     return len;
 }
 
 void
 reversepath(char *inpath, char *name, int len, char *outpath)
 {
     char *cp, *cp2;
     char buf[NAME_MAX];
     struct stat sb;
 
     cp = strcpy(outpath + PATH_MAX - (len + 1), name);
     cp2 = inpath;
     while ((cp2 = getcomponent(cp2, buf)) != 0) {
-	if (strcmp(buf, ".") == 0)
-	    continue;
-	if (strcmp(buf, "..") == 0) {
-	    if (stat(".", &sb) < 0)
-		fail("cannot stat current directory");
-	    name = ino2name(sb.st_ino, "..");
-	    len = strlen(name);
-	    cp -= len + 1;
-	    strcpy(cp, name);
-	    cp[len] = '/';
-	    free(name);
-	    xchdir("..");
-	} else {
-	    cp -= 3;
-	    memcpy(cp, "../", 3);
-	    xchdir(buf);
-	}
+        if (strcmp(buf, ".") == 0) {
+            continue;
+        }
+        if (strcmp(buf, "..") == 0) {
+            if (stat(".", &sb) < 0) {
+                fail("cannot stat current directory");
+            }
+            name = ino2name(sb.st_ino, "..");
+            len = strlen(name);
+            cp -= len + 1;
+            strcpy(cp, name);
+            cp[len] = '/';
+            free(name);
+            xchdir("..");
+        } else {
+            cp -= 3;
+            memcpy(cp, "../", 3);
+            xchdir(buf);
+        }
     }
     strcpy(outpath, cp);
 }

--- a/nsprpub/config/prdepend.h
+++ b/nsprpub/config/prdepend.h
@@ -5,9 +5,8 @@
 
 /*
  * A dummy header file that is a dependency for all the object files.
  * Used to force a full recompilation of NSPR in Mozilla's Tinderbox
  * depend builds.  See comments in rules.mk.
  */
 
 #error "Do not include this header file."
-

--- a/nsprpub/configure
+++ b/nsprpub/configure
@@ -2481,17 +2481,17 @@ case $target_os in *\ *) target_os=`echo
 # The aliases save the names the user supplied, while $host etc.
 # will get canonicalized.
 test -n "$target_alias" &&
   test "$program_prefix$program_suffix$program_transform_name" = \
     NONENONEs,x,x, &&
   program_prefix=${target_alias}-
 
 MOD_MAJOR_VERSION=4
-MOD_MINOR_VERSION=22
+MOD_MINOR_VERSION=23
 MOD_PATCH_VERSION=0
 NSPR_MODNAME=nspr20
 _HAVE_PTHREADS=
 USE_PTHREADS=
 USE_USER_PTHREADS=
 USE_NSPR_THREADS=
 USE_N32=
 USE_X32=

--- a/nsprpub/configure.in
+++ b/nsprpub/configure.in
@@ -10,17 +10,17 @@ AC_CONFIG_SRCDIR([pr/include/nspr.h])
 
 AC_CONFIG_AUX_DIR(${srcdir}/build/autoconf)
 AC_CANONICAL_TARGET
 
 dnl ========================================================
 dnl = Defaults
 dnl ========================================================
 MOD_MAJOR_VERSION=4
-MOD_MINOR_VERSION=22
+MOD_MINOR_VERSION=23
 MOD_PATCH_VERSION=0
 NSPR_MODNAME=nspr20
 _HAVE_PTHREADS=
 USE_PTHREADS=
 USE_USER_PTHREADS=
 USE_NSPR_THREADS=
 USE_N32=
 USE_X32=

--- a/nsprpub/lib/ds/plarena.c
+++ b/nsprpub/lib/ds/plarena.c
@@ -30,141 +30,151 @@ static PLArenaStats *arena_stats_list;
 PR_IMPLEMENT(void) PL_InitArenaPool(
     PLArenaPool *pool, const char *name, PRUint32 size, PRUint32 align)
 {
     /*
      * Look-up table of PR_BITMASK(PR_CeilingLog2(align)) values for
      * align = 1 to 32.
      */
     static const PRUint8 pmasks[33] = {
-         0,                                               /*  not used */
-         0, 1, 3, 3, 7, 7, 7, 7,15,15,15,15,15,15,15,15,  /*  1 ... 16 */
-        31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31}; /* 17 ... 32 */
+        0,                                               /*  not used */
+        0, 1, 3, 3, 7, 7, 7, 7,15,15,15,15,15,15,15,15,  /*  1 ... 16 */
+        31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31   /* 17 ... 32 */
+    };
 
-    if (align == 0)
+    if (align == 0) {
         align = PL_ARENA_DEFAULT_ALIGN;
+    }
 
-    if (align < sizeof(pmasks)/sizeof(pmasks[0]))
+    if (align < sizeof(pmasks)/sizeof(pmasks[0])) {
         pool->mask = pmasks[align];
-    else
+    }
+    else {
         pool->mask = PR_BITMASK(PR_CeilingLog2(align));
+    }
 
     pool->first.next = NULL;
     /* Set all three addresses in pool->first to the same dummy value.
      * These addresses are only compared with each other, but never
      * dereferenced. */
     pool->first.base = pool->first.avail = pool->first.limit =
-        (PRUword)PL_ARENA_ALIGN(pool, &pool->first + 1);
+            (PRUword)PL_ARENA_ALIGN(pool, &pool->first + 1);
     pool->current = &pool->first;
     /*
      * Compute the net size so that each arena's gross size is |size|.
      * sizeof(PLArena) + pool->mask is the header and alignment slop
      * that PL_ArenaAllocate adds to the net size.
      */
-    if (size > sizeof(PLArena) + pool->mask)
+    if (size > sizeof(PLArena) + pool->mask) {
         pool->arenasize = size - (sizeof(PLArena) + pool->mask);
-    else
+    }
+    else {
         pool->arenasize = size;
+    }
 #ifdef PL_ARENAMETER
     memset(&pool->stats, 0, sizeof pool->stats);
     pool->stats.name = strdup(name);
     pool->stats.next = arena_stats_list;
     arena_stats_list = &pool->stats;
 #endif
 }
 
 
 /*
 ** PL_ArenaAllocate() -- allocate space from an arena pool
-** 
+**
 ** Description: PL_ArenaAllocate() allocates space from an arena
-** pool. 
+** pool.
 **
 ** First, try to satisfy the request from arenas starting at
 ** pool->current. Then try to allocate a new arena from the heap.
 **
 ** Returns: pointer to allocated space or NULL
-** 
+**
 ** Notes: The original implementation had some difficult to
 ** solve bugs; the code was difficult to read. Sometimes it's
 ** just easier to rewrite it. I did that. larryh.
 **
 ** See also: bugzilla: 45343.
 **
 */
 
 PR_IMPLEMENT(void *) PL_ArenaAllocate(PLArenaPool *pool, PRUint32 nb)
 {
-    PLArena *a;   
+    PLArena *a;
     char *rp;     /* returned pointer */
     PRUint32 nbOld;
 
     PR_ASSERT((nb & pool->mask) == 0);
-    
+
     nbOld = nb;
     nb = (PRUword)PL_ARENA_ALIGN(pool, nb); /* force alignment */
-    if (nb < nbOld)
+    if (nb < nbOld) {
         return NULL;
+    }
 
     /* attempt to allocate from arenas at pool->current */
     {
         a = pool->current;
         do {
             if ( nb <= a->limit - a->avail )  {
                 pool->current = a;
                 rp = (char *)a->avail;
                 a->avail += nb;
                 return rp;
             }
         } while( NULL != (a = a->next) );
     }
 
-    /* attempt to allocate from the heap */ 
-    {  
+    /* attempt to allocate from the heap */
+    {
         PRUint32 sz = PR_MAX(pool->arenasize, nb);
         if (PR_UINT32_MAX - sz < sizeof *a + pool->mask) {
             a = NULL;
         } else {
             sz += sizeof *a + pool->mask;  /* header and alignment slop */
             a = (PLArena*)PR_MALLOC(sz);
         }
         if ( NULL != a )  {
             a->limit = (PRUword)a + sz;
             a->base = a->avail = (PRUword)PL_ARENA_ALIGN(pool, a + 1);
             PL_MAKE_MEM_NOACCESS((void*)a->avail, a->limit - a->avail);
             rp = (char *)a->avail;
             a->avail += nb;
             PR_ASSERT(a->avail <= a->limit);
-            /* the newly allocated arena is linked after pool->current 
+            /* the newly allocated arena is linked after pool->current
             *  and becomes pool->current */
             a->next = pool->current->next;
             pool->current->next = a;
             pool->current = a;
-            if ( NULL == pool->first.next )
+            if ( NULL == pool->first.next ) {
                 pool->first.next = a;
+            }
             PL_COUNT_ARENA(pool,++);
             COUNT(pool, nmallocs);
             return(rp);
         }
     }
 
     /* we got to here, and there's no memory to allocate */
     return(NULL);
 } /* --- end PL_ArenaAllocate() --- */
 
 PR_IMPLEMENT(void *) PL_ArenaGrow(
     PLArenaPool *pool, void *p, PRUint32 size, PRUint32 incr)
 {
     void *newp;
 
-    if (PR_UINT32_MAX - size < incr)
+    if (PR_UINT32_MAX - size < incr) {
         return NULL;
+    }
     PL_ARENA_ALLOCATE(newp, pool, size + incr);
-    if (newp)
+    if (newp) {
         memcpy(newp, p, size);
+    }
     return newp;
 }
 
 PR_IMPLEMENT(void) PL_ClearArenaPool(PLArenaPool *pool, PRInt32 pattern)
 {
     PLArena *a;
 
     for (a = pool->first.next; a; a = a->next) {
@@ -177,18 +187,19 @@ PR_IMPLEMENT(void) PL_ClearArenaPool(PLA
 
 /*
  * Free tail arenas linked after head, which may not be the true list head.
  * Reset pool->current to point to head in case it pointed at a tail arena.
  */
 static void FreeArenaList(PLArenaPool *pool, PLArena *head)
 {
     PLArena *a = head->next;
-    if (!a)
+    if (!a) {
         return;
+    }
 
     head->next = NULL;
 
     do {
         PLArena *tmp = a;
         a = a->next;
         PL_CLEAR_ARENA(tmp);
         PL_COUNT_ARENA(pool,--);
@@ -219,18 +230,19 @@ PR_IMPLEMENT(void) PL_FreeArenaPool(PLAr
 
 PR_IMPLEMENT(void) PL_FinishArenaPool(PLArenaPool *pool)
 {
     FreeArenaList(pool, &pool->first);
 #ifdef PL_ARENAMETER
     {
         PLArenaStats *stats, **statsp;
 
-        if (pool->stats.name)
+        if (pool->stats.name) {
             PR_DELETE(pool->stats.name);
+        }
         for (statsp = &arena_stats_list; (stats = *statsp) != 0;
              statsp = &stats->next) {
             if (stats == &pool->stats) {
                 *statsp = stats->next;
                 return;
             }
         }
     }
@@ -261,36 +273,38 @@ PR_IMPLEMENT(size_t) PL_SizeOfArenaPoolE
     return size;
 }
 
 #ifdef PL_ARENAMETER
 PR_IMPLEMENT(void) PL_ArenaCountAllocation(PLArenaPool *pool, PRUint32 nb)
 {
     pool->stats.nallocs++;
     pool->stats.nbytes += nb;
-    if (nb > pool->stats.maxalloc)
+    if (nb > pool->stats.maxalloc) {
         pool->stats.maxalloc = nb;
+    }
     pool->stats.variance += nb * nb;
 }
 
 PR_IMPLEMENT(void) PL_ArenaCountInplaceGrowth(
     PLArenaPool *pool, PRUint32 size, PRUint32 incr)
 {
     pool->stats.ninplace++;
 }
 
 PR_IMPLEMENT(void) PL_ArenaCountGrowth(
     PLArenaPool *pool, PRUint32 size, PRUint32 incr)
 {
     pool->stats.ngrows++;
     pool->stats.nbytes += incr;
     pool->stats.variance -= size * size;
     size += incr;
-    if (size > pool->stats.maxalloc)
+    if (size > pool->stats.maxalloc) {
         pool->stats.maxalloc = size;
+    }
     pool->stats.variance += size * size;
 }
 
 PR_IMPLEMENT(void) PL_ArenaCountRelease(PLArenaPool *pool, char *mark)
 {
     pool->stats.nreleases++;
 }
 

--- a/nsprpub/lib/ds/plhash.c
+++ b/nsprpub/lib/ds/plhash.c
@@ -46,18 +46,19 @@ static PLHashEntry * PR_CALLBACK
 DefaultAllocEntry(void *pool, const void *key)
 {
     return PR_NEW(PLHashEntry);
 }
 
 static void PR_CALLBACK
 DefaultFreeEntry(void *pool, PLHashEntry *he, PRUintn flag)
 {
-    if (flag == HT_FREE_ENTRY)
+    if (flag == HT_FREE_ENTRY) {
         PR_Free(he);
+    }
 }
 
 static PLHashAllocOps defaultHashAllocOps = {
     DefaultAllocTable, DefaultFreeTable,
     DefaultAllocEntry, DefaultFreeEntry
 };
 
 PR_IMPLEMENT(PLHashTable *)
@@ -67,25 +68,29 @@ PL_NewHashTable(PRUint32 n, PLHashFuncti
 {
     PLHashTable *ht;
     PRSize nb;
 
     if (n <= MINBUCKETS) {
         n = MINBUCKETSLOG2;
     } else {
         n = PR_CeilingLog2(n);
-        if ((PRInt32)n < 0)
+        if ((PRInt32)n < 0) {
             return 0;
+        }
     }
 
-    if (!allocOps) allocOps = &defaultHashAllocOps;
+    if (!allocOps) {
+        allocOps = &defaultHashAllocOps;
+    }
 
     ht = (PLHashTable*)((*allocOps->allocTable)(allocPriv, sizeof *ht));
-    if (!ht)
-	return 0;
+    if (!ht) {
+        return 0;
+    }
     memset(ht, 0, sizeof *ht);
     ht->shift = PL_HASH_BITS - n;
     n = 1 << n;
     nb = n * sizeof(PLHashEntry *);
     ht->buckets = (PLHashEntry**)((*allocOps->allocTable)(allocPriv, nb));
     if (!ht->buckets) {
         (*allocOps->freeTable)(allocPriv, ht);
         return 0;
@@ -197,17 +202,17 @@ PL_HashTableRawAdd(PLHashTable *ht, PLHa
     PRSize nb;
 
     /* Grow the table if it is overloaded */
     n = NBUCKETS(ht);
     if (ht->nentries >= OVERLOADED(n)) {
         oldbuckets = ht->buckets;
         nb = 2 * n * sizeof(PLHashEntry *);
         ht->buckets = (PLHashEntry**)
-            ((*ht->allocOps->allocTable)(ht->allocPriv, nb));
+                      ((*ht->allocOps->allocTable)(ht->allocPriv, nb));
         if (!ht->buckets) {
             ht->buckets = oldbuckets;
             return 0;
         }
         memset(ht->buckets, 0, nb);
 #ifdef HASHMETER
         ht->ngrows++;
 #endif
@@ -226,18 +231,19 @@ PL_HashTableRawAdd(PLHashTable *ht, PLHa
         memset(oldbuckets, 0xDB, n * sizeof oldbuckets[0]);
 #endif
         (*ht->allocOps->freeTable)(ht->allocPriv, oldbuckets);
         hep = PL_HashTableRawLookup(ht, keyHash, key);
     }
 
     /* Make a new key value entry */
     he = (*ht->allocOps->allocEntry)(ht->allocPriv, key);
-    if (!he)
-	return 0;
+    if (!he) {
+        return 0;
+    }
     he->keyHash = keyHash;
     he->key = key;
     he->value = value;
     he->next = *hep;
     *hep = he;
     ht->nentries++;
     return he;
 }
@@ -251,18 +257,19 @@ PL_HashTableAdd(PLHashTable *ht, const v
     keyHash = (*ht->keyHash)(key);
     hep = PL_HashTableRawLookup(ht, keyHash, key);
     if ((he = *hep) != 0) {
         /* Hit; see if values match */
         if ((*ht->valueCompare)(he->value, value)) {
             /* key,value pair is already present in table */
             return he;
         }
-        if (he->value)
+        if (he->value) {
             (*ht->allocOps->freeEntry)(ht->allocPriv, he, HT_FREE_VALUE);
+        }
         he->value = value;
         return he;
     }
     return PL_HashTableRawAdd(ht, hep, keyHash, key, value);
 }
 
 PR_IMPLEMENT(void)
 PL_HashTableRawRemove(PLHashTable *ht, PLHashEntry **hep, PLHashEntry *he)
@@ -275,17 +282,17 @@ PL_HashTableRawRemove(PLHashTable *ht, P
     (*ht->allocOps->freeEntry)(ht->allocPriv, he, HT_FREE_ENTRY);
 
     /* Shrink table if it's underloaded */
     n = NBUCKETS(ht);
     if (--ht->nentries < UNDERLOADED(n)) {
         oldbuckets = ht->buckets;
         nb = n * sizeof(PLHashEntry*) / 2;
         ht->buckets = (PLHashEntry**)(
-            (*ht->allocOps->allocTable)(ht->allocPriv, nb));
+                          (*ht->allocOps->allocTable)(ht->allocPriv, nb));
         if (!ht->buckets) {
             ht->buckets = oldbuckets;
             return;
         }
         memset(ht->buckets, 0, nb);
 #ifdef HASHMETER
         ht->nshrinks++;
 #endif
@@ -310,18 +317,19 @@ PL_HashTableRawRemove(PLHashTable *ht, P
 PR_IMPLEMENT(PRBool)
 PL_HashTableRemove(PLHashTable *ht, const void *key)
 {
     PLHashNumber keyHash;
     PLHashEntry *he, **hep;
 
     keyHash = (*ht->keyHash)(key);
     hep = PL_HashTableRawLookup(ht, keyHash, key);
-    if ((he = *hep) == 0)
+    if ((he = *hep) == 0) {
         return PR_FALSE;
+    }
 
     /* Hit; remove element */
     PL_HashTableRawRemove(ht, hep, he);
     return PR_TRUE;
 }
 
 PR_IMPLEMENT(void *)
 PL_HashTableLookup(PLHashTable *ht, const void *key)
@@ -409,45 +417,48 @@ PL_HashTableDumpMeter(PLHashTable *ht, P
     PLHashEntry *he;
 
     variance = 0;
     nchains = 0;
     maxChainLen = 0;
     nbuckets = NBUCKETS(ht);
     for (i = 0; i < nbuckets; i++) {
         he = ht->buckets[i];
-        if (!he)
+        if (!he) {
             continue;
+        }
         nchains++;
-        for (n = 0; he; he = he->next)
+        for (n = 0; he; he = he->next) {
             n++;
+        }
         variance += n * n;
         if (n > maxChainLen) {
             maxChainLen = n;
             maxChain = i;
         }
     }
     mean = (double)ht->nentries / nchains;
     variance = fabs(variance / nchains - mean * mean);
 
     fprintf(fp, "\nHash table statistics:\n");
     fprintf(fp, "     number of lookups: %u\n", ht->nlookups);
     fprintf(fp, "     number of entries: %u\n", ht->nentries);
     fprintf(fp, "       number of grows: %u\n", ht->ngrows);
     fprintf(fp, "     number of shrinks: %u\n", ht->nshrinks);
     fprintf(fp, "   mean steps per hash: %g\n", (double)ht->nsteps
-                                                / ht->nlookups);
+            / ht->nlookups);
     fprintf(fp, "mean hash chain length: %g\n", mean);
     fprintf(fp, "    standard deviation: %g\n", sqrt(variance));
     fprintf(fp, " max hash chain length: %u\n", maxChainLen);
     fprintf(fp, "        max hash chain: [%u]\n", maxChain);
 
     for (he = ht->buckets[maxChain], i = 0; he; he = he->next, i++)
-        if ((*dump)(he, i, fp) != HT_ENUMERATE_NEXT)
+        if ((*dump)(he, i, fp) != HT_ENUMERATE_NEXT) {
             break;
+        }
 }
 #endif /* HASHMETER */
 
 PR_IMPLEMENT(int)
 PL_HashTableDump(PLHashTable *ht, PLHashEnumerator dump, FILE *fp)
 {
     int count;
 
@@ -460,18 +471,19 @@ PL_HashTableDump(PLHashTable *ht, PLHash
 
 PR_IMPLEMENT(PLHashNumber)
 PL_HashString(const void *key)
 {
     PLHashNumber h;
     const PRUint8 *s;
 
     h = 0;
-    for (s = (const PRUint8*)key; *s; s++)
+    for (s = (const PRUint8*)key; *s; s++) {
         h = PR_ROTATE_LEFT32(h, 4) ^ *s;
+    }
     return h;
 }
 
 PR_IMPLEMENT(int)
 PL_CompareStrings(const void *v1, const void *v2)
 {
     return strcmp((const char*)v1, (const char*)v2) == 0;
 }

--- a/nsprpub/lib/ds/plvrsion.c
+++ b/nsprpub/lib/ds/plvrsion.c
@@ -63,35 +63,35 @@ PRVersionDescription VERSION_DESC_NAME =
 
 /*
  * Version information for the 'ident' and 'what commands
  *
  * NOTE: the first component of the concatenated rcsid string
  * must not end in a '$' to prevent rcs keyword substitution.
  */
 static char rcsid[] = "$Header: NSPR " PR_VERSION _DEBUG_STRING
-        "  " _BUILD_STRING " $";
+                      "  " _BUILD_STRING " $";
 static char sccsid[] = "@(#)NSPR " PR_VERSION _DEBUG_STRING
-        "  " _BUILD_STRING;
+                       "  " _BUILD_STRING;
 
 #endif /* XP_UNIX */
 
 #ifdef _PR_HAS_PRAGMA_DIAGNOSTIC
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wunused-but-set-variable"
 #endif
 PR_IMPLEMENT(const PRVersionDescription*) libVersionPoint()
 {
 #ifdef XP_UNIX
     /*
      * Add dummy references to rcsid and sccsid to prevent them
      * from being optimized away as unused variables.
      */
     const char *dummy;
-    
+
     dummy = rcsid;
     dummy = sccsid;
 #endif
     return &VERSION_DESC_NAME;
 }  /* versionEntryPointType */
 #ifdef _PR_HAS_PRAGMA_DIAGNOSTIC
 #pragma GCC diagnostic pop
 #endif

--- a/nsprpub/lib/libc/include/plbase64.h
+++ b/nsprpub/lib/libc/include/plbase64.h
@@ -14,21 +14,21 @@ PR_BEGIN_EXTERN_C
  * PL_Base64Encode
  *
  * This routine encodes the data pointed to by the "src" parameter using the
  * base64 algorithm, and returns a pointer to the result.  If the "srclen"
  * parameter is not zero, it specifies the length of the source data.  If it
  * is zero, the source data is assumed to be null-terminated, and PL_strlen
  * is used to determine the source length.  If the "dest" parameter is not
  * null, it is assumed to point to a buffer of sufficient size (which may be
- * calculated: ((srclen + 2)/3)*4) into which the encoded data is placed 
+ * calculated: ((srclen + 2)/3)*4) into which the encoded data is placed
  * (without any termination).  If the "dest" parameter is null, a buffer is
  * allocated from the heap to hold the encoded data, and the result *will*
- * be terminated with an extra null character.  It is the caller's 
- * responsibility to free the result when it is allocated.  A null is returned 
+ * be terminated with an extra null character.  It is the caller's
+ * responsibility to free the result when it is allocated.  A null is returned
  * if the allocation fails.
  *
  * NOTE: when calculating ((srclen + 2)/3)*4), first ensure that
  *     srclen <= (PR_UINT32_MAX/4) * 3
  * to avoid PRUint32 overflow.
  */
 
 PR_EXTERN(char *)
@@ -51,17 +51,17 @@ PL_Base64Encode
  * a buffer of sufficient size (which may be calculated: (srclen * 3)/4
  * when srclen includes the '=' characters) into which the decoded data
  * is placed (without any termination).  If the "dest" parameter is null,
  * a buffer is allocated from the heap to hold the decoded data, and the
  * result *will* be terminated with an extra null character.  It is the
  * caller's responsibility to free the result when it is allocated.  A null
  * is retuned if the allocation fails, or if the source is not well-coded.
  *
- * NOTE: when calculating (srclen * 3)/4, first ensure that 
+ * NOTE: when calculating (srclen * 3)/4, first ensure that
  *     srclen <= PR_UINT32_MAX/3
  * to avoid PRUint32 overflow.  Alternatively, calculate
  *     (srclen/4) * 3 + ((srclen%4) * 3)/4
  * which is equivalent but doesn't overflow for any value of srclen.
  */
 
 PR_EXTERN(char *)
 PL_Base64Decode

--- a/nsprpub/lib/libc/include/plgetopt.h
+++ b/nsprpub/lib/libc/include/plgetopt.h
@@ -11,112 +11,112 @@
 #if defined(PLGETOPT_H_)
 #else
 #define PLGETOPT_H_
 
 #include "prtypes.h"
 
 PR_BEGIN_EXTERN_C
 
-typedef struct PLOptionInternal PLOptionInternal; 
+typedef struct PLOptionInternal PLOptionInternal;
 
 typedef enum
 {
-        PL_OPT_OK,              /* all's well with the option */
-        PL_OPT_EOL,             /* end of options list */
-        PL_OPT_BAD              /* invalid option (and value) */
+    PL_OPT_OK,              /* all's well with the option */
+    PL_OPT_EOL,             /* end of options list */
+    PL_OPT_BAD              /* invalid option (and value) */
 } PLOptStatus;
 
 typedef struct PLLongOpt
 {
     const char * longOptName;   /* long option name string                  */
     PRIntn       longOption;    /* value put in PLOptState for this option. */
     PRBool       valueRequired; /* If option name not followed by '=',      */
-                                /* value is the next argument from argv.    */
+    /* value is the next argument from argv.    */
 } PLLongOpt;
 
 typedef struct PLOptState
 {
     char option;                /* the name of the option */
     const char *value;          /* the value of that option | NULL */
 
     PLOptionInternal *internal; /* private processing state */
 
     PRIntn   longOption;        /* value from PLLongOpt put here */
     PRIntn   longOptIndex;      /* index into caller's array of PLLongOpts */
 } PLOptState;
 
 /*
  * PL_CreateOptState
  *
- * The argument "options" points to a string of single-character option 
- * names.  Option names that may have an option argument value must be 
- * followed immediately by a ':' character.  
+ * The argument "options" points to a string of single-character option
+ * names.  Option names that may have an option argument value must be
+ * followed immediately by a ':' character.
  */
 PR_EXTERN(PLOptState*) PL_CreateOptState(
-        PRIntn argc, char **argv, const char *options);
+    PRIntn argc, char **argv, const char *options);
 
-/* 
+/*
  * PL_CreateLongOptState
  *
- * Alternative to PL_CreateOptState.  
- * Allows caller to specify BOTH a string of single-character option names, 
- * AND an array of structures describing "long" (keyword) option names.  
- * The array is terminated by a structure in which longOptName is NULL.  
+ * Alternative to PL_CreateOptState.
+ * Allows caller to specify BOTH a string of single-character option names,
+ * AND an array of structures describing "long" (keyword) option names.
+ * The array is terminated by a structure in which longOptName is NULL.
  * Long option values (arguments) may always be given as "--name=value".
- * If PLLongOpt.valueRequired is not PR_FALSE, and the option name was not 
- * followed by '=' then the next argument from argv is taken as the value.  
+ * If PLLongOpt.valueRequired is not PR_FALSE, and the option name was not
+ * followed by '=' then the next argument from argv is taken as the value.
  */
 PR_EXTERN(PLOptState*) PL_CreateLongOptState(
-        PRIntn argc, char **argv, const char *options, 
-        const PLLongOpt *longOpts);
+    PRIntn argc, char **argv, const char *options,
+    const PLLongOpt *longOpts);
 /*
  * PL_DestroyOptState
  *
  * Call this to destroy the PLOptState returned from PL_CreateOptState or
  * PL_CreateLongOptState.
  */
 PR_EXTERN(void) PL_DestroyOptState(PLOptState *opt);
 
 /*
  * PL_GetNextOpt
  *
- * When this function returns PL_OPT_OK, 
- * - opt->option will hold the single-character option name that was parsed, 
- *   or zero.  
- * When opt->option is zero, the token parsed was either a "long" (keyword) 
- *   option or a positional parameter.  
- * For a positional parameter, 
+ * When this function returns PL_OPT_OK,
+ * - opt->option will hold the single-character option name that was parsed,
+ *   or zero.
+ * When opt->option is zero, the token parsed was either a "long" (keyword)
+ *   option or a positional parameter.
+ * For a positional parameter,
  * - opt->longOptIndex will contain -1, and
  * - opt->value will point to the positional parameter string.
- * For a long option name, 
- * - opt->longOptIndex will contain the non-negative index of the 
- *   PLLongOpt structure in the caller's array of PLLongOpt structures 
- *   corresponding to the long option name, and 
- * For a single-character or long option, 
+ * For a long option name,
+ * - opt->longOptIndex will contain the non-negative index of the
+ *   PLLongOpt structure in the caller's array of PLLongOpt structures
+ *   corresponding to the long option name, and
+ * For a single-character or long option,
  * - opt->longOption will contain the value of the single-character option
  *   name, or the value of the longOption from the PLLongOpt structure
  *   for that long option.  See notes below.
  * - opt->value will point to the argument option string, or will
  *   be NULL if option does not require argument.  If option requires
  *   argument but it is not provided, PL_OPT_BAD is returned.
- * When opt->option is non-zero, 
+ * When opt->option is non-zero,
  * - opt->longOptIndex will be -1
  * When this function returns PL_OPT_EOL, or PL_OPT_BAD, the contents of
  *   opt are undefined.
  *
- * Notes: It is possible to ignore opt->option, and always look at 
+ * Notes: It is possible to ignore opt->option, and always look at
  *   opt->longOption instead.  opt->longOption will contain the same value
  *   as opt->option for single-character option names, and will contain the
  *   value of longOption from the PLLongOpt structure for long option names.
- * This means that it is possible to equivalence long option names to 
+ * This means that it is possible to equivalence long option names to
  *   single character names by giving the longOption in the PLLongOpt struct
- *   the same value as the single-character option name.  
+ *   the same value as the single-character option name.
  * For long options that are NOT intended to be equivalent to any single-
- *   character option, the longOption value should be chosen to not match 
+ *   character option, the longOption value should be chosen to not match
  *   any possible single character name.  It might be advisable to choose
  *   longOption values greater than 0xff for such long options.
  */
 PR_EXTERN(PLOptStatus) PL_GetNextOpt(PLOptState *opt);
 
 PR_END_EXTERN_C
 
 #endif /* defined(PLGETOPT_H_) */

--- a/nsprpub/lib/libc/include/plstr.h
+++ b/nsprpub/lib/libc/include/plstr.h
@@ -5,23 +5,23 @@
 
 #ifndef _plstr_h
 #define _plstr_h
 
 /*
  * plstr.h
  *
  * This header file exports the API to the NSPR portable library or string-
- * handling functions.  
- * 
- * This API was not designed as an "optimal" or "ideal" string library; it 
+ * handling functions.
+ *
+ * This API was not designed as an "optimal" or "ideal" string library; it
  * was based on the good ol' unix string.3 functions, and was written to
  *
- *  1) replace the libc functions, for cross-platform consistency, 
- *  2) complete the API on platforms lacking common functions (e.g., 
+ *  1) replace the libc functions, for cross-platform consistency,
+ *  2) complete the API on platforms lacking common functions (e.g.,
  *     strcase*), and
  *  3) to implement some obvious "closure" functions that I've seen
  *     people hacking around in our code.
  *
  * Point number three largely means that most functions have an "strn"
  * limited-length version, and all comparison routines have a non-case-
  * sensitive version available.
  */
@@ -71,23 +71,23 @@ PL_strcpy(char *dest, const char *src);
  */
 
 PR_EXTERN(char *)
 PL_strncpy(char *dest, const char *src, PRUint32 max);
 
 /*
  * PL_strncpyz
  *
- * Copies the source string into the destination buffer, up to and including 
- * the trailing '\0' or up but not including the max'th character, whichever 
+ * Copies the source string into the destination buffer, up to and including
+ * the trailing '\0' or up but not including the max'th character, whichever
  * comes first.  It does not (can not) verify that the destination buffer is
  * large enough.  The destination string is always terminated with a '\0',
  * unlike the traditional libc implementation.  It returns the "dest" argument.
  *
- * NOTE: If you call this with a source "abcdefg" and a max of 5, the 
+ * NOTE: If you call this with a source "abcdefg" and a max of 5, the
  * destination will end up with "abcd\0" (i.e., its strlen length will be 4)!
  *
  * This means you can do this:
  *
  *     char buffer[ SOME_SIZE ];
  *     PL_strncpyz(buffer, src, sizeof(buffer));
  *
  * and the result will be properly terminated.
@@ -147,17 +147,17 @@ PR_EXTERN(char *)
 PL_strcat(char *dst, const char *src);
 
 /*
  * PL_strncat
  *
  * Appends a copy of the string pointed to by the second argument, up to
  * the maximum size specified, to the end of the string pointed to by the
  * first.  The destination buffer is not (can not be) checked for sufficient
- * size.  A null destination argument returns null; otherwise, the first 
+ * size.  A null destination argument returns null; otherwise, the first
  * argument is returned.  If the maximum size limits the copy, then the
  * result will *not* be null-terminated (JLRU).  A null destination
  * returns null; otherwise, the destination argument is returned.
  */
 
 PR_EXTERN(char *)
 PL_strncat(char *dst, const char *src, PRUint32 max);
 
@@ -184,46 +184,46 @@ PL_strcatn(char *dst, PRUint32 max, cons
  * NSPR implementation is not i18n.
  */
 
 PR_EXTERN(PRIntn)
 PL_strcmp(const char *a, const char *b);
 
 /*
  * PL_strncmp
- * 
+ *
  * Returns an integer, the sign of which -- positive, zero, or negative --
  * reflects the lexical sorting order of the two strings indicated, up to
- * the maximum specified.  The result is positive if the first string comes 
+ * the maximum specified.  The result is positive if the first string comes
  * after the second.  The NSPR implementation is not i18n.  If the maximum
  * is zero, only the existance or non-existance (pointer is null) of the
  * strings is compared.
  */
 
 PR_EXTERN(PRIntn)
 PL_strncmp(const char *a, const char *b, PRUint32 max);
 
 /*
  * PL_strcasecmp
  *
  * Returns an integer, the sign of which -- positive, zero or negative --
  * reflects the case-insensitive lexical sorting order of the two strings
- * indicated.  The result is positive if the first string comes after the 
+ * indicated.  The result is positive if the first string comes after the
  * second.  The NSPR implementation is not i18n.
  */
 
 PR_EXTERN(PRIntn)
 PL_strcasecmp(const char *a, const char *b);
 
 /*
  * PL_strncasecmp
  *
  * Returns an integer, the sign of which -- positive, zero or negative --
  * reflects the case-insensitive lexical sorting order of the first n characters
- * of the two strings indicated.  The result is positive if the first string comes 
+ * of the two strings indicated.  The result is positive if the first string comes
  * after the second.  The NSPR implementation is not i18n.
  */
 
 PR_EXTERN(PRIntn)
 PL_strncasecmp(const char *a, const char *b, PRUint32 max);
 
 /*
  * PL_strchr
@@ -244,17 +244,17 @@ PL_strchr(const char *s, char c);
  * provided string is null.  The character may be the null character.
  */
 
 PR_EXTERN(char *)
 PL_strrchr(const char *s, char c);
 
 /*
  * PL_strnchr
- * 
+ *
  * Returns a pointer to the first instance of the specified character within the
  * first n characters of the provided string.  It returns null if the character
  * is not found, or if the provided string is null.  The character may be the
  * null character.
  */
 
 PR_EXTERN(char *)
 PL_strnchr(const char *s, char c, PRUint32 n);
@@ -381,17 +381,17 @@ PL_strcasestr(const char *big, const cha
 
 PR_EXTERN(char *)
 PL_strcaserstr(const char *big, const char *little);
 
 /*
  * PL_strncasestr
  *
  * Returns a pointer to the first instance of the little string within the first
- * n characters of the big one, ignoring case.  It returns null if either string is 
+ * n characters of the big one, ignoring case.  It returns null if either string is
  * null.  It returns null if the length of the little string is greater than n.
  */
 
 PR_EXTERN(char *)
 PL_strncasestr(const char *big, const char *little, PRUint32 max);
 
 /*
  * PL_strncaserstr

--- a/nsprpub/lib/libc/src/base64.c
+++ b/nsprpub/lib/libc/src/base64.c
@@ -95,18 +95,18 @@ encode
     }
 
     return;
 }
 
 /*
  * PL_Base64Encode
  *
- * If the destination argument is NULL, a return buffer is 
- * allocated, and the data therein will be null-terminated.  
+ * If the destination argument is NULL, a return buffer is
+ * allocated, and the data therein will be null-terminated.
  * If the destination argument is not NULL, it is assumed to
  * be of sufficient size, and the contents will not be null-
  * terminated by this routine.
  *
  * Returns null if the allocation fails.
  */
 
 PR_IMPLEMENT(char *)
@@ -336,18 +336,18 @@ decode
 /*
  * PL_Base64Decode
  *
  * If the destination argument is NULL, a return buffer is
  * allocated and the data therein will be null-terminated.
  * If the destination argument is not null, it is assumed
  * to be of sufficient size, and the data will not be null-
  * terminated by this routine.
- * 
- * Returns null if the allocation fails, or if the source string is 
+ *
+ * Returns null if the allocation fails, or if the source string is
  * not well-formed.
  */
 
 PR_IMPLEMENT(char *)
 PL_Base64Decode
 (
     const char *src,
     PRUint32    srclen,

--- a/nsprpub/lib/libc/src/plerror.c
+++ b/nsprpub/lib/libc/src/plerror.c
@@ -11,30 +11,34 @@
 
 #include "plerror.h"
 
 #include "prprf.h"
 #include "prerror.h"
 
 PR_IMPLEMENT(void) PL_FPrintError(PRFileDesc *fd, const char *msg)
 {
-PRErrorCode error = PR_GetError();
-PRInt32 oserror = PR_GetOSError();
-const char *name = PR_ErrorToName(error);
+    PRErrorCode error = PR_GetError();
+    PRInt32 oserror = PR_GetOSError();
+    const char *name = PR_ErrorToName(error);
 
-	if (NULL != msg) PR_fprintf(fd, "%s: ", msg);
+    if (NULL != msg) {
+        PR_fprintf(fd, "%s: ", msg);
+    }
     if (NULL == name)
         PR_fprintf(
-			fd, " (%d)OUT OF RANGE, oserror = %d\n", error, oserror);
+            fd, " (%d)OUT OF RANGE, oserror = %d\n", error, oserror);
     else
         PR_fprintf(
             fd, "%s(%d), oserror = %d\n",
             name, error, oserror);
 }  /* PL_FPrintError */
 
 PR_IMPLEMENT(void) PL_PrintError(const char *msg)
 {
-	static PRFileDesc *fd = NULL;
-	if (NULL == fd) fd = PR_GetSpecialFD(PR_StandardError);
-	PL_FPrintError(fd, msg);
+    static PRFileDesc *fd = NULL;
+    if (NULL == fd) {
+        fd = PR_GetSpecialFD(PR_StandardError);
+    }
+    PL_FPrintError(fd, msg);
 }  /* PL_PrintError */
 
 /* plerror.c */

--- a/nsprpub/lib/libc/src/plgetopt.c
+++ b/nsprpub/lib/libc/src/plgetopt.c
@@ -40,30 +40,30 @@ struct PLOptionInternal
 */
 PR_IMPLEMENT(PLOptState*) PL_CreateOptState(
     PRIntn argc, char **argv, const char *options)
 {
     return PL_CreateLongOptState( argc, argv, options, NULL);
 }  /* PL_CreateOptState */
 
 PR_IMPLEMENT(PLOptState*) PL_CreateLongOptState(
-    PRIntn argc, char **argv, const char *options, 
+    PRIntn argc, char **argv, const char *options,
     const PLLongOpt *longOpts)
 {
     PLOptState *opt = NULL;
     PLOptionInternal *internal;
 
-    if (NULL == options) 
+    if (NULL == options)
     {
         PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0);
         return opt;
     }
 
     opt = PR_NEWZAP(PLOptState);
-    if (NULL == opt) 
+    if (NULL == opt)
     {
         PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
         return opt;
     }
 
     internal = PR_NEW(PLOptionInternal);
     if (NULL == internal)
     {
@@ -119,61 +119,63 @@ PR_IMPLEMENT(PLOptStatus) PL_GetNextOpt(
         if (internal->xargc >= internal->argc)
         {
             opt->option = 0;
             opt->value = NULL;
             return PL_OPT_EOL;
         }
         internal->xargv = internal->argv[internal->xargc];
         internal->minus = 0;
-        if (!internal->endOfOpts && ('-' == *internal->xargv)) 
+        if (!internal->endOfOpts && ('-' == *internal->xargv))
         {
             internal->minus++;
             internal->xargv++;  /* and consume */
-            if ('-' == *internal->xargv && internal->longOpts) 
+            if ('-' == *internal->xargv && internal->longOpts)
             {
                 internal->minus++;
                 internal->xargv++;
-                if (0 == *internal->xargv) 
+                if (0 == *internal->xargv)
                 {
                     internal->endOfOpts = PR_TRUE;
                 }
             }
         }
     }
 
     /*
     ** If we already have a '-' or '--' in hand, xargv points to the next
     ** option. See if we can find a match in the list of possible
     ** options supplied.
     */
-    if (internal->minus == 2) 
+    if (internal->minus == 2)
     {
         char * foundEqual = strchr(internal->xargv,'=');
         PRIntn optNameLen = foundEqual ? (foundEqual - internal->xargv) :
                             strlen(internal->xargv);
         const PLLongOpt *longOpt = internal->longOpts;
         PLOptStatus result = PL_OPT_BAD;
 
         opt->option = 0;
         opt->value  = NULL;
 
-        for (; longOpt->longOptName; ++longOpt) 
+        for (; longOpt->longOptName; ++longOpt)
         {
-            if (strncmp(longOpt->longOptName, internal->xargv, optNameLen))
-                continue;  /* not a possible match */
-            if (strlen(longOpt->longOptName) != optNameLen)
-                continue;  /* not a match */
+            if (strncmp(longOpt->longOptName, internal->xargv, optNameLen)) {
+                continue;    /* not a possible match */
+            }
+            if (strlen(longOpt->longOptName) != optNameLen) {
+                continue;    /* not a match */
+            }
             /* option name match */
             opt->longOptIndex = longOpt - internal->longOpts;
             opt->longOption   = longOpt->longOption;
             /* value is part of the current argv[] element if = was found */
             /* note: this sets value even for long options that do not
              * require option if specified as --long=value */
-            if (foundEqual) 
+            if (foundEqual)
             {
                 opt->value = foundEqual + 1;
             }
             else if (longOpt->valueRequired)
             {
                 /* value is the next argv[] element, if any */
                 if (internal->xargc + 1 < internal->argc)
                 {
@@ -222,18 +224,19 @@ PR_IMPLEMENT(PLOptStatus) PL_GetNextOpt(
                     else
                     {
                         return PL_OPT_BAD;
                     }
 
                     internal->xargv = &static_Nul;
                     internal->minus = 0;
                 }
-                else 
-                    opt->value = NULL; 
+                else {
+                    opt->value = NULL;
+                }
                 return PL_OPT_OK;
             }
         }
         internal->xargv += 1;  /* consume that option */
         return PL_OPT_BAD;
     }
 
     /*