Getting more systematic about style

1 files changed, 381 insertions, 377 deletions

diff --git a/generic/tclPosixStr.c b/generic/tclPosixStr.c
index a3aedf5..7cb2bdb 100644
--- a/generic/tclPosixStr.c
+++ b/generic/tclPosixStr.c
@@ -1,9 +1,8 @@
 /* 
  * tclPosixStr.c --
  *
- *	This file contains procedures that generate strings
- *	corresponding to various POSIX-related codes, such
- *	as errno and signals.
+ *	This file contains procedures that generate strings corresponding to
+ *	various POSIX-related codes, such as errno and signals.
  *
  * Copyright (c) 1991-1994 The Regents of the University of California.
  * Copyright (c) 1994-1996 Sun Microsystems, Inc.
@@ -11,7 +10,7 @@
  * See the file "license.terms" for information on usage and redistribution
  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclPosixStr.c,v 1.10 2004/04/06 22:25:54 dgp Exp $
+ * RCS: @(#) $Id: tclPosixStr.c,v 1.11 2005/07/19 22:45:35 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -24,9 +23,9 @@
  *	Return a textual identifier for the current errno value.
  *
  * Results:
- *	This procedure returns a machine-readable textual identifier
- *	that corresponds to the current errno value (e.g. "EPERM").
- *	The identifier is the same as the #define name in errno.h.
+ *	This procedure returns a machine-readable textual identifier that
+ *	corresponds to the current errno value (e.g. "EPERM"). The identifier
+ *	is the same as the #define name in errno.h.
  *
  * Side effects:
  *	None.
@@ -39,421 +38,421 @@ Tcl_ErrnoId()
 {
     switch (errno) {
 #ifdef E2BIG
-	case E2BIG: return "E2BIG";
+    case E2BIG: return "E2BIG";
 #endif
 #ifdef EACCES
-	case EACCES: return "EACCES";
+    case EACCES: return "EACCES";
 #endif
 #ifdef EADDRINUSE
-	case EADDRINUSE: return "EADDRINUSE";
+    case EADDRINUSE: return "EADDRINUSE";
 #endif
 #ifdef EADDRNOTAVAIL
-	case EADDRNOTAVAIL: return "EADDRNOTAVAIL";
+    case EADDRNOTAVAIL: return "EADDRNOTAVAIL";
 #endif
 #ifdef EADV
-	case EADV: return "EADV";
+    case EADV: return "EADV";
 #endif
 #ifdef EAFNOSUPPORT
-	case EAFNOSUPPORT: return "EAFNOSUPPORT";
+    case EAFNOSUPPORT: return "EAFNOSUPPORT";
 #endif
 #ifdef EAGAIN
-	case EAGAIN: return "EAGAIN";
+    case EAGAIN: return "EAGAIN";
 #endif
 #ifdef EALIGN
-	case EALIGN: return "EALIGN";
+    case EALIGN: return "EALIGN";
 #endif
 #if defined(EALREADY) && (!defined(EBUSY) || (EALREADY != EBUSY ))
-	case EALREADY: return "EALREADY";
+    case EALREADY: return "EALREADY";
 #endif
 #ifdef EBADE
-	case EBADE: return "EBADE";
+    case EBADE: return "EBADE";
 #endif
 #ifdef EBADF
-	case EBADF: return "EBADF";
+    case EBADF: return "EBADF";
 #endif
 #ifdef EBADFD
-	case EBADFD: return "EBADFD";
+    case EBADFD: return "EBADFD";
 #endif
 #ifdef EBADMSG
-	case EBADMSG: return "EBADMSG";
+    case EBADMSG: return "EBADMSG";
 #endif
 #ifdef EBADR
-	case EBADR: return "EBADR";
+    case EBADR: return "EBADR";
 #endif
 #ifdef EBADRPC
-	case EBADRPC: return "EBADRPC";
+    case EBADRPC: return "EBADRPC";
 #endif
 #ifdef EBADRQC
-	case EBADRQC: return "EBADRQC";
+    case EBADRQC: return "EBADRQC";
 #endif
 #ifdef EBADSLT
-	case EBADSLT: return "EBADSLT";
+    case EBADSLT: return "EBADSLT";
 #endif
 #ifdef EBFONT
-	case EBFONT: return "EBFONT";
+    case EBFONT: return "EBFONT";
 #endif
 #ifdef EBUSY
-	case EBUSY: return "EBUSY";
+    case EBUSY: return "EBUSY";
 #endif
 #ifdef ECHILD
-	case ECHILD: return "ECHILD";
+    case ECHILD: return "ECHILD";
 #endif
 #ifdef ECHRNG
-	case ECHRNG: return "ECHRNG";
+    case ECHRNG: return "ECHRNG";
 #endif
 #ifdef ECOMM
-	case ECOMM: return "ECOMM";
+    case ECOMM: return "ECOMM";
 #endif
 #ifdef ECONNABORTED
-	case ECONNABORTED: return "ECONNABORTED";
+    case ECONNABORTED: return "ECONNABORTED";
 #endif
 #ifdef ECONNREFUSED
-	case ECONNREFUSED: return "ECONNREFUSED";
+    case ECONNREFUSED: return "ECONNREFUSED";
 #endif
 #ifdef ECONNRESET
-	case ECONNRESET: return "ECONNRESET";
+    case ECONNRESET: return "ECONNRESET";
 #endif
 #if defined(EDEADLK) && (!defined(EWOULDBLOCK) || (EDEADLK != EWOULDBLOCK))
-	case EDEADLK: return "EDEADLK";
+    case EDEADLK: return "EDEADLK";
 #endif
 #if defined(EDEADLOCK) && (!defined(EDEADLK) || (EDEADLOCK != EDEADLK))
-	case EDEADLOCK: return "EDEADLOCK";
+    case EDEADLOCK: return "EDEADLOCK";
 #endif
 #ifdef EDESTADDRREQ
-	case EDESTADDRREQ: return "EDESTADDRREQ";
+    case EDESTADDRREQ: return "EDESTADDRREQ";
 #endif
 #ifdef EDIRTY
-	case EDIRTY: return "EDIRTY";
+    case EDIRTY: return "EDIRTY";
 #endif
 #ifdef EDOM
-	case EDOM: return "EDOM";
+    case EDOM: return "EDOM";
 #endif
 #ifdef EDOTDOT
-	case EDOTDOT: return "EDOTDOT";
+    case EDOTDOT: return "EDOTDOT";
 #endif
 #ifdef EDQUOT
-	case EDQUOT: return "EDQUOT";
+    case EDQUOT: return "EDQUOT";
 #endif
 #ifdef EDUPPKG
-	case EDUPPKG: return "EDUPPKG";
+    case EDUPPKG: return "EDUPPKG";
 #endif
 #ifdef EEXIST
-	case EEXIST: return "EEXIST";
+    case EEXIST: return "EEXIST";
 #endif
 #ifdef EFAULT
-	case EFAULT: return "EFAULT";
+    case EFAULT: return "EFAULT";
 #endif
 #ifdef EFBIG
-	case EFBIG: return "EFBIG";
+    case EFBIG: return "EFBIG";
 #endif
 #ifdef EHOSTDOWN
-	case EHOSTDOWN: return "EHOSTDOWN";
+    case EHOSTDOWN: return "EHOSTDOWN";
 #endif
 #ifdef EHOSTUNREACH
-	case EHOSTUNREACH: return "EHOSTUNREACH";
+    case EHOSTUNREACH: return "EHOSTUNREACH";
 #endif
 #if defined(EIDRM) && (!defined(EINPROGRESS) || (EIDRM != EINPROGRESS))
-	case EIDRM: return "EIDRM";
+    case EIDRM: return "EIDRM";
 #endif
 #ifdef EINIT
-	case EINIT: return "EINIT";
+    case EINIT: return "EINIT";
 #endif
 #ifdef EINPROGRESS
-	case EINPROGRESS: return "EINPROGRESS";
+    case EINPROGRESS: return "EINPROGRESS";
 #endif
 #ifdef EINTR
-	case EINTR: return "EINTR";
+    case EINTR: return "EINTR";
 #endif
 #ifdef EINVAL
-	case EINVAL: return "EINVAL";
+    case EINVAL: return "EINVAL";
 #endif
 #ifdef EIO
-	case EIO: return "EIO";
+    case EIO: return "EIO";
 #endif
 #ifdef EISCONN
-	case EISCONN: return "EISCONN";
+    case EISCONN: return "EISCONN";
 #endif
 #ifdef EISDIR
-	case EISDIR: return "EISDIR";
+    case EISDIR: return "EISDIR";
 #endif
 #ifdef EISNAME
-	case EISNAM: return "EISNAM";
+    case EISNAM: return "EISNAM";
 #endif
 #ifdef ELBIN
-	case ELBIN: return "ELBIN";
+    case ELBIN: return "ELBIN";
 #endif
 #ifdef EL2HLT
-	case EL2HLT: return "EL2HLT";
+    case EL2HLT: return "EL2HLT";
 #endif
 #ifdef EL2NSYNC
-	case EL2NSYNC: return "EL2NSYNC";
+    case EL2NSYNC: return "EL2NSYNC";
 #endif
 #ifdef EL3HLT
-	case EL3HLT: return "EL3HLT";
+    case EL3HLT: return "EL3HLT";
 #endif
 #ifdef EL3RST
-	case EL3RST: return "EL3RST";
+    case EL3RST: return "EL3RST";
 #endif
 #ifdef ELIBACC
-	case ELIBACC: return "ELIBACC";
+    case ELIBACC: return "ELIBACC";
 #endif
 #ifdef ELIBBAD
-	case ELIBBAD: return "ELIBBAD";
+    case ELIBBAD: return "ELIBBAD";
 #endif
 #ifdef ELIBEXEC
-	case ELIBEXEC: return "ELIBEXEC";
+    case ELIBEXEC: return "ELIBEXEC";
 #endif
 #ifdef ELIBMAX
-	case ELIBMAX: return "ELIBMAX";
+    case ELIBMAX: return "ELIBMAX";
 #endif
 #ifdef ELIBSCN
-	case ELIBSCN: return "ELIBSCN";
+    case ELIBSCN: return "ELIBSCN";
 #endif
 #ifdef ELNRNG
-	case ELNRNG: return "ELNRNG";
+    case ELNRNG: return "ELNRNG";
 #endif
 #if defined(ELOOP) && (!defined(ENOENT) || (ELOOP != ENOENT))
-	case ELOOP: return "ELOOP";
+    case ELOOP: return "ELOOP";
 #endif
 #ifdef EMFILE
-	case EMFILE: return "EMFILE";
+    case EMFILE: return "EMFILE";
 #endif
 #ifdef EMLINK
-	case EMLINK: return "EMLINK";
+    case EMLINK: return "EMLINK";
 #endif
 #ifdef EMSGSIZE
-	case EMSGSIZE: return "EMSGSIZE";
+    case EMSGSIZE: return "EMSGSIZE";
 #endif
 #ifdef EMULTIHOP
-	case EMULTIHOP: return "EMULTIHOP";
+    case EMULTIHOP: return "EMULTIHOP";
 #endif
 #ifdef ENAMETOOLONG
-	case ENAMETOOLONG: return "ENAMETOOLONG";
+    case ENAMETOOLONG: return "ENAMETOOLONG";
 #endif
 #ifdef ENAVAIL
-	case ENAVAIL: return "ENAVAIL";
+    case ENAVAIL: return "ENAVAIL";
 #endif
 #ifdef ENET
-	case ENET: return "ENET";
+    case ENET: return "ENET";
 #endif
 #ifdef ENETDOWN
-	case ENETDOWN: return "ENETDOWN";
+    case ENETDOWN: return "ENETDOWN";
 #endif
 #ifdef ENETRESET
-	case ENETRESET: return "ENETRESET";
+    case ENETRESET: return "ENETRESET";
 #endif
 #ifdef ENETUNREACH
-	case ENETUNREACH: return "ENETUNREACH";
+    case ENETUNREACH: return "ENETUNREACH";
 #endif
 #ifdef ENFILE
-	case ENFILE: return "ENFILE";
+    case ENFILE: return "ENFILE";
 #endif
 #ifdef ENOANO
-	case ENOANO: return "ENOANO";
+    case ENOANO: return "ENOANO";
 #endif
 #if defined(ENOBUFS) && (!defined(ENOSR) || (ENOBUFS != ENOSR))
-	case ENOBUFS: return "ENOBUFS";
+    case ENOBUFS: return "ENOBUFS";
 #endif
 #ifdef ENOCSI
-	case ENOCSI: return "ENOCSI";
+    case ENOCSI: return "ENOCSI";
 #endif
 #if defined(ENODATA) && (!defined(ECONNREFUSED) || (ENODATA != ECONNREFUSED))
-	case ENODATA: return "ENODATA";
+    case ENODATA: return "ENODATA";
 #endif
 #ifdef ENODEV
-	case ENODEV: return "ENODEV";
+    case ENODEV: return "ENODEV";
 #endif
 #ifdef ENOENT
-	case ENOENT: return "ENOENT";
+    case ENOENT: return "ENOENT";
 #endif
 #ifdef ENOEXEC
-	case ENOEXEC: return "ENOEXEC";
+    case ENOEXEC: return "ENOEXEC";
 #endif
 #ifdef ENOLCK
-	case ENOLCK: return "ENOLCK";
+    case ENOLCK: return "ENOLCK";
 #endif
 #ifdef ENOLINK
-	case ENOLINK: return "ENOLINK";
+    case ENOLINK: return "ENOLINK";
 #endif
 #ifdef ENOMEM
-	case ENOMEM: return "ENOMEM";
+    case ENOMEM: return "ENOMEM";
 #endif
 #ifdef ENOMSG
-	case ENOMSG: return "ENOMSG";
+    case ENOMSG: return "ENOMSG";
 #endif
 #ifdef ENONET
-	case ENONET: return "ENONET";
+    case ENONET: return "ENONET";
 #endif
 #ifdef ENOPKG
-	case ENOPKG: return "ENOPKG";
+    case ENOPKG: return "ENOPKG";
 #endif
 #ifdef ENOPROTOOPT
-	case ENOPROTOOPT: return "ENOPROTOOPT";
+    case ENOPROTOOPT: return "ENOPROTOOPT";
 #endif
 #ifdef ENOSPC
-	case ENOSPC: return "ENOSPC";
+    case ENOSPC: return "ENOSPC";
 #endif
 #if defined(ENOSR) && (!defined(ENAMETOOLONG) || (ENAMETOOLONG != ENOSR))
-	case ENOSR: return "ENOSR";
+    case ENOSR: return "ENOSR";
 #endif
 #if defined(ENOSTR) && (!defined(ENOTTY) || (ENOTTY != ENOSTR))
-	case ENOSTR: return "ENOSTR";
+    case ENOSTR: return "ENOSTR";
 #endif
 #ifdef ENOSYM
-	case ENOSYM: return "ENOSYM";
+    case ENOSYM: return "ENOSYM";
 #endif
 #ifdef ENOSYS
-	case ENOSYS: return "ENOSYS";
+    case ENOSYS: return "ENOSYS";
 #endif
 #ifdef ENOTBLK
-	case ENOTBLK: return "ENOTBLK";
+    case ENOTBLK: return "ENOTBLK";
 #endif
 #ifdef ENOTCONN
-	case ENOTCONN: return "ENOTCONN";
+    case ENOTCONN: return "ENOTCONN";
 #endif
 #ifdef ENOTDIR
-	case ENOTDIR: return "ENOTDIR";
+    case ENOTDIR: return "ENOTDIR";
 #endif
 #if defined(ENOTEMPTY) && (!defined(EEXIST) || (ENOTEMPTY != EEXIST))
-	case ENOTEMPTY: return "ENOTEMPTY";
+    case ENOTEMPTY: return "ENOTEMPTY";
 #endif
 #ifdef ENOTNAM
-	case ENOTNAM: return "ENOTNAM";
+    case ENOTNAM: return "ENOTNAM";
 #endif
 #ifdef ENOTSOCK
-	case ENOTSOCK: return "ENOTSOCK";
+    case ENOTSOCK: return "ENOTSOCK";
 #endif
 #ifdef ENOTSUP
-	case ENOTSUP: return "ENOTSUP";
+    case ENOTSUP: return "ENOTSUP";
 #endif
 #ifdef ENOTTY
-	case ENOTTY: return "ENOTTY";
+    case ENOTTY: return "ENOTTY";
 #endif
 #ifdef ENOTUNIQ
-	case ENOTUNIQ: return "ENOTUNIQ";
+    case ENOTUNIQ: return "ENOTUNIQ";
 #endif
 #ifdef ENXIO
-	case ENXIO: return "ENXIO";
+    case ENXIO: return "ENXIO";
 #endif
 #if defined(EOPNOTSUPP) &&  (!defined(ENOTSUP) || (ENOTSUP != EOPNOTSUPP))
-	case EOPNOTSUPP: return "EOPNOTSUPP";
+    case EOPNOTSUPP: return "EOPNOTSUPP";
 #endif
 #if defined(EOVERFLOW) && ( !defined(EFBIG) || (EOVERFLOW != EFBIG) ) && ( !defined(EINVAL) || (EOVERFLOW != EINVAL) )
-        case EOVERFLOW: return "EOVERFLOW";
+    case EOVERFLOW: return "EOVERFLOW";
 #endif
 #ifdef EPERM
-	case EPERM: return "EPERM";
+    case EPERM: return "EPERM";
 #endif
 #if defined(EPFNOSUPPORT) && (!defined(ENOLCK) || (ENOLCK != EPFNOSUPPORT))
-	case EPFNOSUPPORT: return "EPFNOSUPPORT";
+    case EPFNOSUPPORT: return "EPFNOSUPPORT";
 #endif
 #ifdef EPIPE
-	case EPIPE: return "EPIPE";
+    case EPIPE: return "EPIPE";
 #endif
 #ifdef EPROCLIM
-	case EPROCLIM: return "EPROCLIM";
+    case EPROCLIM: return "EPROCLIM";
 #endif
 #ifdef EPROCUNAVAIL
-	case EPROCUNAVAIL: return "EPROCUNAVAIL";
+    case EPROCUNAVAIL: return "EPROCUNAVAIL";
 #endif
 #ifdef EPROGMISMATCH
-	case EPROGMISMATCH: return "EPROGMISMATCH";
+    case EPROGMISMATCH: return "EPROGMISMATCH";
 #endif
 #ifdef EPROGUNAVAIL
-	case EPROGUNAVAIL: return "EPROGUNAVAIL";
+    case EPROGUNAVAIL: return "EPROGUNAVAIL";
 #endif
 #ifdef EPROTO
-	case EPROTO: return "EPROTO";
+    case EPROTO: return "EPROTO";
 #endif
 #ifdef EPROTONOSUPPORT
-	case EPROTONOSUPPORT: return "EPROTONOSUPPORT";
+    case EPROTONOSUPPORT: return "EPROTONOSUPPORT";
 #endif
 #ifdef EPROTOTYPE
-	case EPROTOTYPE: return "EPROTOTYPE";
+    case EPROTOTYPE: return "EPROTOTYPE";
 #endif
 #ifdef ERANGE
-	case ERANGE: return "ERANGE";
+    case ERANGE: return "ERANGE";
 #endif
 #if defined(EREFUSED) && (!defined(ECONNREFUSED) || (EREFUSED != ECONNREFUSED))
-	case EREFUSED: return "EREFUSED";
+    case EREFUSED: return "EREFUSED";
 #endif
 #ifdef EREMCHG
-	case EREMCHG: return "EREMCHG";
+    case EREMCHG: return "EREMCHG";
 #endif
 #ifdef EREMDEV
-	case EREMDEV: return "EREMDEV";
+    case EREMDEV: return "EREMDEV";
 #endif
 #ifdef EREMOTE
-	case EREMOTE: return "EREMOTE";
+    case EREMOTE: return "EREMOTE";
 #endif
 #ifdef EREMOTEIO
-	case EREMOTEIO: return "EREMOTEIO";
+    case EREMOTEIO: return "EREMOTEIO";
 #endif
 #ifdef EREMOTERELEASE
-	case EREMOTERELEASE: return "EREMOTERELEASE";
+    case EREMOTERELEASE: return "EREMOTERELEASE";
 #endif
 #ifdef EROFS
-	case EROFS: return "EROFS";
+    case EROFS: return "EROFS";
 #endif
 #ifdef ERPCMISMATCH
-	case ERPCMISMATCH: return "ERPCMISMATCH";
+    case ERPCMISMATCH: return "ERPCMISMATCH";
 #endif
 #ifdef ERREMOTE
-	case ERREMOTE: return "ERREMOTE";
+    case ERREMOTE: return "ERREMOTE";
 #endif
 #ifdef ESHUTDOWN
-	case ESHUTDOWN: return "ESHUTDOWN";
+    case ESHUTDOWN: return "ESHUTDOWN";
 #endif
 #ifdef ESOCKTNOSUPPORT
-	case ESOCKTNOSUPPORT: return "ESOCKTNOSUPPORT";
+    case ESOCKTNOSUPPORT: return "ESOCKTNOSUPPORT";
 #endif
 #ifdef ESPIPE
-	case ESPIPE: return "ESPIPE";
+    case ESPIPE: return "ESPIPE";
 #endif
 #ifdef ESRCH
-	case ESRCH: return "ESRCH";
+    case ESRCH: return "ESRCH";
 #endif
 #ifdef ESRMNT
-	case ESRMNT: return "ESRMNT";
+    case ESRMNT: return "ESRMNT";
 #endif
 #ifdef ESTALE
-	case ESTALE: return "ESTALE";
+    case ESTALE: return "ESTALE";
 #endif
 #ifdef ESUCCESS
-	case ESUCCESS: return "ESUCCESS";
+    case ESUCCESS: return "ESUCCESS";
 #endif
 #if defined(ETIME) && (!defined(ELOOP) || (ETIME != ELOOP))
-	case ETIME: return "ETIME";
+    case ETIME: return "ETIME";
 #endif
 #if defined(ETIMEDOUT) && (!defined(ENOSTR) || (ETIMEDOUT != ENOSTR))
-	case ETIMEDOUT: return "ETIMEDOUT";
+    case ETIMEDOUT: return "ETIMEDOUT";
 #endif
 #ifdef ETOOMANYREFS
-	case ETOOMANYREFS: return "ETOOMANYREFS";
+    case ETOOMANYREFS: return "ETOOMANYREFS";
 #endif
 #ifdef ETXTBSY
-	case ETXTBSY: return "ETXTBSY";
+    case ETXTBSY: return "ETXTBSY";
 #endif
 #ifdef EUCLEAN
-	case EUCLEAN: return "EUCLEAN";
+    case EUCLEAN: return "EUCLEAN";
 #endif
 #ifdef EUNATCH
-	case EUNATCH: return "EUNATCH";
+    case EUNATCH: return "EUNATCH";
 #endif
 #ifdef EUSERS
-	case EUSERS: return "EUSERS";
+    case EUSERS: return "EUSERS";
 #endif
 #ifdef EVERSION
-	case EVERSION: return "EVERSION";
+    case EVERSION: return "EVERSION";
 #endif
 #if defined(EWOULDBLOCK) && (!defined(EAGAIN) || (EWOULDBLOCK != EAGAIN))
-	case EWOULDBLOCK: return "EWOULDBLOCK";
+    case EWOULDBLOCK: return "EWOULDBLOCK";
 #endif
 #ifdef EXDEV
-	case EXDEV: return "EXDEV";
+    case EXDEV: return "EXDEV";
 #endif
 #ifdef EXFULL
-	case EXFULL: return "EXFULL";
+    case EXFULL: return "EXFULL";
 #endif
     }
     return "unknown error";
@@ -464,17 +463,15 @@ Tcl_ErrnoId()
  *
  * Tcl_ErrnoMsg --
  *
- *	Return a human-readable message corresponding to a given
- *	errno value.
+ *	Return a human-readable message corresponding to a given errno value.
  *
  * Results:
- *	The return value is the standard POSIX error message for
- *	errno.  This procedure is used instead of strerror because
- *	strerror returns slightly different values on different
- *	machines (e.g. different capitalizations), which cause
- *	problems for things such as regression tests.  This procedure
- *	provides messages for most standard errors, then it calls
- *	strerror for things it doesn't understand.
+ *	The return value is the standard POSIX error message for errno.  This
+ *	procedure is used instead of strerror because strerror returns
+ *	slightly different values on different machines (e.g. different
+ *	capitalizations), which cause problems for things such as regression
+ *	tests. This procedure provides messages for most standard errors, then
+ *	it calls strerror for things it doesn't understand.
  *
  * Side effects:
  *	None.
@@ -484,432 +481,432 @@ Tcl_ErrnoId()
 
 CONST char *
 Tcl_ErrnoMsg(err)
-    int err;			/* Error number (such as in errno variable). */
+     int err;			/* Error number (such as in errno variable). */
 {
     switch (err) {
 #ifdef E2BIG
-	case E2BIG: return "argument list too long";
+    case E2BIG: return "argument list too long";
 #endif
 #ifdef EACCES
-	case EACCES: return "permission denied";
+    case EACCES: return "permission denied";
 #endif
 #ifdef EADDRINUSE
-	case EADDRINUSE: return "address already in use";
+    case EADDRINUSE: return "address already in use";
 #endif
 #ifdef EADDRNOTAVAIL
-	case EADDRNOTAVAIL: return "can't assign requested address";
+    case EADDRNOTAVAIL: return "can't assign requested address";
 #endif
 #ifdef EADV
-	case EADV: return "advertise error";
+    case EADV: return "advertise error";
 #endif
 #ifdef EAFNOSUPPORT
-	case EAFNOSUPPORT: return "address family not supported by protocol family";
+    case EAFNOSUPPORT: return "address family not supported by protocol family";
 #endif
 #ifdef EAGAIN
-	case EAGAIN: return "resource temporarily unavailable";
+    case EAGAIN: return "resource temporarily unavailable";
 #endif
 #ifdef EALIGN
-	case EALIGN: return "EALIGN";
+    case EALIGN: return "EALIGN";
 #endif
 #if defined(EALREADY) && (!defined(EBUSY) || (EALREADY != EBUSY ))
-	case EALREADY: return "operation already in progress";
+    case EALREADY: return "operation already in progress";
 #endif
 #ifdef EBADE
-	case EBADE: return "bad exchange descriptor";
+    case EBADE: return "bad exchange descriptor";
 #endif
 #ifdef EBADF
-	case EBADF: return "bad file number";
+    case EBADF: return "bad file number";
 #endif
 #ifdef EBADFD
-	case EBADFD: return "file descriptor in bad state";
+    case EBADFD: return "file descriptor in bad state";
 #endif
 #ifdef EBADMSG
-	case EBADMSG: return "not a data message";
+    case EBADMSG: return "not a data message";
 #endif
 #ifdef EBADR
-	case EBADR: return "bad request descriptor";
+    case EBADR: return "bad request descriptor";
 #endif
 #ifdef EBADRPC
-	case EBADRPC: return "RPC structure is bad";
+    case EBADRPC: return "RPC structure is bad";
 #endif
 #ifdef EBADRQC
-	case EBADRQC: return "bad request code";
+    case EBADRQC: return "bad request code";
 #endif
 #ifdef EBADSLT
-	case EBADSLT: return "invalid slot";
+    case EBADSLT: return "invalid slot";
 #endif
 #ifdef EBFONT
-	case EBFONT: return "bad font file format";
+    case EBFONT: return "bad font file format";
 #endif
 #ifdef EBUSY
-	case EBUSY: return "file busy";
+    case EBUSY: return "file busy";
 #endif
 #ifdef ECHILD
-	case ECHILD: return "no children";
+    case ECHILD: return "no children";
 #endif
 #ifdef ECHRNG
-	case ECHRNG: return "channel number out of range";
+    case ECHRNG: return "channel number out of range";
 #endif
 #ifdef ECOMM
-	case ECOMM: return "communication error on send";
+    case ECOMM: return "communication error on send";
 #endif
 #ifdef ECONNABORTED
-	case ECONNABORTED: return "software caused connection abort";
+    case ECONNABORTED: return "software caused connection abort";
 #endif
 #ifdef ECONNREFUSED
-	case ECONNREFUSED: return "connection refused";
+    case ECONNREFUSED: return "connection refused";
 #endif
 #ifdef ECONNRESET
-	case ECONNRESET: return "connection reset by peer";
+    case ECONNRESET: return "connection reset by peer";
 #endif
 #if defined(EDEADLK) && (!defined(EWOULDBLOCK) || (EDEADLK != EWOULDBLOCK))
-	case EDEADLK: return "resource deadlock avoided";
+    case EDEADLK: return "resource deadlock avoided";
 #endif
 #if defined(EDEADLOCK) && (!defined(EDEADLK) || (EDEADLOCK != EDEADLK))
-	case EDEADLOCK: return "resource deadlock avoided";
+    case EDEADLOCK: return "resource deadlock avoided";
 #endif
 #ifdef EDESTADDRREQ
-	case EDESTADDRREQ: return "destination address required";
+    case EDESTADDRREQ: return "destination address required";
 #endif
 #ifdef EDIRTY
-	case EDIRTY: return "mounting a dirty fs w/o force";
+    case EDIRTY: return "mounting a dirty fs w/o force";
 #endif
 #ifdef EDOM
-	case EDOM: return "math argument out of range";
+    case EDOM: return "math argument out of range";
 #endif
 #ifdef EDOTDOT
-	case EDOTDOT: return "cross mount point";
+    case EDOTDOT: return "cross mount point";
 #endif
 #ifdef EDQUOT
-	case EDQUOT: return "disk quota exceeded";
+    case EDQUOT: return "disk quota exceeded";
 #endif
 #ifdef EDUPPKG
-	case EDUPPKG: return "duplicate package name";
+    case EDUPPKG: return "duplicate package name";
 #endif
 #ifdef EEXIST
-	case EEXIST: return "file already exists";
+    case EEXIST: return "file already exists";
 #endif
 #ifdef EFAULT
-	case EFAULT: return "bad address in system call argument";
+    case EFAULT: return "bad address in system call argument";
 #endif
 #ifdef EFBIG
-	case EFBIG: return "file too large";
+    case EFBIG: return "file too large";
 #endif
 #ifdef EHOSTDOWN
-	case EHOSTDOWN: return "host is down";
+    case EHOSTDOWN: return "host is down";
 #endif
 #ifdef EHOSTUNREACH
-	case EHOSTUNREACH: return "host is unreachable";
+    case EHOSTUNREACH: return "host is unreachable";
 #endif
 #if defined(EIDRM) && (!defined(EINPROGRESS) || (EIDRM != EINPROGRESS))
-	case EIDRM: return "identifier removed";
+    case EIDRM: return "identifier removed";
 #endif
 #ifdef EINIT
-	case EINIT: return "initialization error";
+    case EINIT: return "initialization error";
 #endif
 #ifdef EINPROGRESS
-	case EINPROGRESS: return "operation now in progress";
+    case EINPROGRESS: return "operation now in progress";
 #endif
 #ifdef EINTR
-	case EINTR: return "interrupted system call";
+    case EINTR: return "interrupted system call";
 #endif
 #ifdef EINVAL
-	case EINVAL: return "invalid argument";
+    case EINVAL: return "invalid argument";
 #endif
 #ifdef EIO
-	case EIO: return "I/O error";
+    case EIO: return "I/O error";
 #endif
 #ifdef EISCONN
-	case EISCONN: return "socket is already connected";
+    case EISCONN: return "socket is already connected";
 #endif
 #ifdef EISDIR
-	case EISDIR: return "illegal operation on a directory";
+    case EISDIR: return "illegal operation on a directory";
 #endif
 #ifdef EISNAME
-	case EISNAM: return "is a name file";
+    case EISNAM: return "is a name file";
 #endif
 #ifdef ELBIN
-	case ELBIN: return "ELBIN";
+    case ELBIN: return "ELBIN";
 #endif
 #ifdef EL2HLT
-	case EL2HLT: return "level 2 halted";
+    case EL2HLT: return "level 2 halted";
 #endif
 #ifdef EL2NSYNC
-	case EL2NSYNC: return "level 2 not synchronized";
+    case EL2NSYNC: return "level 2 not synchronized";
 #endif
 #ifdef EL3HLT
-	case EL3HLT: return "level 3 halted";
+    case EL3HLT: return "level 3 halted";
 #endif
 #ifdef EL3RST
-	case EL3RST: return "level 3 reset";
+    case EL3RST: return "level 3 reset";
 #endif
 #ifdef ELIBACC
-	case ELIBACC: return "can not access a needed shared library";
+    case ELIBACC: return "can not access a needed shared library";
 #endif
 #ifdef ELIBBAD
-	case ELIBBAD: return "accessing a corrupted shared library";
+    case ELIBBAD: return "accessing a corrupted shared library";
 #endif
 #ifdef ELIBEXEC
-	case ELIBEXEC: return "can not exec a shared library directly";
+    case ELIBEXEC: return "can not exec a shared library directly";
 #endif
 #ifdef ELIBMAX
-	case ELIBMAX: return
-		"attempting to link in more shared libraries than system limit";
+    case ELIBMAX: return
+		      "attempting to link in more shared libraries than system limit";
 #endif
 #ifdef ELIBSCN
-	case ELIBSCN: return ".lib section in a.out corrupted";
+    case ELIBSCN: return ".lib section in a.out corrupted";
 #endif
 #ifdef ELNRNG
-	case ELNRNG: return "link number out of range";
+    case ELNRNG: return "link number out of range";
 #endif
 #if defined(ELOOP) && (!defined(ENOENT) || (ELOOP != ENOENT))
-	case ELOOP: return "too many levels of symbolic links";
+    case ELOOP: return "too many levels of symbolic links";
 #endif
 #ifdef EMFILE
-	case EMFILE: return "too many open files";
+    case EMFILE: return "too many open files";
 #endif
 #ifdef EMLINK
-	case EMLINK: return "too many links";
+    case EMLINK: return "too many links";
 #endif
 #ifdef EMSGSIZE
-	case EMSGSIZE: return "message too long";
+    case EMSGSIZE: return "message too long";
 #endif
 #ifdef EMULTIHOP
-	case EMULTIHOP: return "multihop attempted";
+    case EMULTIHOP: return "multihop attempted";
 #endif
 #ifdef ENAMETOOLONG
-	case ENAMETOOLONG: return "file name too long";
+    case ENAMETOOLONG: return "file name too long";
 #endif
 #ifdef ENAVAIL
-	case ENAVAIL: return "not available";
+    case ENAVAIL: return "not available";
 #endif
 #ifdef ENET
-	case ENET: return "ENET";
+    case ENET: return "ENET";
 #endif
 #ifdef ENETDOWN
-	case ENETDOWN: return "network is down";
+    case ENETDOWN: return "network is down";
 #endif
 #ifdef ENETRESET
-	case ENETRESET: return "network dropped connection on reset";
+    case ENETRESET: return "network dropped connection on reset";
 #endif
 #ifdef ENETUNREACH
-	case ENETUNREACH: return "network is unreachable";
+    case ENETUNREACH: return "network is unreachable";
 #endif
 #ifdef ENFILE
-	case ENFILE: return "file table overflow";
+    case ENFILE: return "file table overflow";
 #endif
 #ifdef ENOANO
-	case ENOANO: return "anode table overflow";
+    case ENOANO: return "anode table overflow";
 #endif
 #if defined(ENOBUFS) && (!defined(ENOSR) || (ENOBUFS != ENOSR))
-	case ENOBUFS: return "no buffer space available";
+    case ENOBUFS: return "no buffer space available";
 #endif
 #ifdef ENOCSI
-	case ENOCSI: return "no CSI structure available";
+    case ENOCSI: return "no CSI structure available";
 #endif
 #if defined(ENODATA) && (!defined(ECONNREFUSED) || (ENODATA != ECONNREFUSED))
-	case ENODATA: return "no data available";
+    case ENODATA: return "no data available";
 #endif
 #ifdef ENODEV
-	case ENODEV: return "no such device";
+    case ENODEV: return "no such device";
 #endif
 #ifdef ENOENT
-	case ENOENT: return "no such file or directory";
+    case ENOENT: return "no such file or directory";
 #endif
 #ifdef ENOEXEC
-	case ENOEXEC: return "exec format error";
+    case ENOEXEC: return "exec format error";
 #endif
 #ifdef ENOLCK
-	case ENOLCK: return "no locks available";
+    case ENOLCK: return "no locks available";
 #endif
 #ifdef ENOLINK
-	case ENOLINK: return "link has be severed";
+    case ENOLINK: return "link has be severed";
 #endif
 #ifdef ENOMEM
-	case ENOMEM: return "not enough memory";
+    case ENOMEM: return "not enough memory";
 #endif
 #ifdef ENOMSG
-	case ENOMSG: return "no message of desired type";
+    case ENOMSG: return "no message of desired type";
 #endif
 #ifdef ENONET
-	case ENONET: return "machine is not on the network";
+    case ENONET: return "machine is not on the network";
 #endif
 #ifdef ENOPKG
-	case ENOPKG: return "package not installed";
+    case ENOPKG: return "package not installed";
 #endif
 #ifdef ENOPROTOOPT
-	case ENOPROTOOPT: return "bad protocol option";
+    case ENOPROTOOPT: return "bad protocol option";
 #endif
 #ifdef ENOSPC
-	case ENOSPC: return "no space left on device";
+    case ENOSPC: return "no space left on device";
 #endif
 #if defined(ENOSR) && (!defined(ENAMETOOLONG) || (ENAMETOOLONG != ENOSR))
-	case ENOSR: return "out of stream resources";
+    case ENOSR: return "out of stream resources";
 #endif
 #if defined(ENOSTR) && (!defined(ENOTTY) || (ENOTTY != ENOSTR))
-	case ENOSTR: return "not a stream device";
+    case ENOSTR: return "not a stream device";
 #endif
 #ifdef ENOSYM
-	case ENOSYM: return "unresolved symbol name";
+    case ENOSYM: return "unresolved symbol name";
 #endif
 #ifdef ENOSYS
-	case ENOSYS: return "function not implemented";
+    case ENOSYS: return "function not implemented";
 #endif
 #ifdef ENOTBLK
-	case ENOTBLK: return "block device required";
+    case ENOTBLK: return "block device required";
 #endif
 #ifdef ENOTCONN
-	case ENOTCONN: return "socket is not connected";
+    case ENOTCONN: return "socket is not connected";
 #endif
 #ifdef ENOTDIR
-	case ENOTDIR: return "not a directory";
+    case ENOTDIR: return "not a directory";
 #endif
 #if defined(ENOTEMPTY) && (!defined(EEXIST) || (ENOTEMPTY != EEXIST))
-	case ENOTEMPTY: return "directory not empty";
+    case ENOTEMPTY: return "directory not empty";
 #endif
 #ifdef ENOTNAM
-	case ENOTNAM: return "not a name file";
+    case ENOTNAM: return "not a name file";
 #endif
 #ifdef ENOTSOCK
-	case ENOTSOCK: return "socket operation on non-socket";
+    case ENOTSOCK: return "socket operation on non-socket";
 #endif
 #ifdef ENOTSUP
-	case ENOTSUP: return "operation not supported";
+    case ENOTSUP: return "operation not supported";
 #endif
 #ifdef ENOTTY
-	case ENOTTY: return "inappropriate device for ioctl";
+    case ENOTTY: return "inappropriate device for ioctl";
 #endif
 #ifdef ENOTUNIQ
-	case ENOTUNIQ: return "name not unique on network";
+    case ENOTUNIQ: return "name not unique on network";
 #endif
 #ifdef ENXIO
-	case ENXIO: return "no such device or address";
+    case ENXIO: return "no such device or address";
 #endif
 #if defined(EOPNOTSUPP) &&  (!defined(ENOTSUP) || (ENOTSUP != EOPNOTSUPP))
-	case EOPNOTSUPP: return "operation not supported on socket";
+    case EOPNOTSUPP: return "operation not supported on socket";
 #endif
 #if defined(EOVERFLOW) && ( !defined(EFBIG) || (EOVERFLOW != EFBIG) ) && ( !defined(EINVAL) || (EOVERFLOW != EINVAL) )
-        case EOVERFLOW: return "file too big";
+    case EOVERFLOW: return "file too big";
 #endif
 #ifdef EPERM
-	case EPERM: return "not owner";
+    case EPERM: return "not owner";
 #endif
 #if defined(EPFNOSUPPORT) && (!defined(ENOLCK) || (ENOLCK != EPFNOSUPPORT))
-	case EPFNOSUPPORT: return "protocol family not supported";
+    case EPFNOSUPPORT: return "protocol family not supported";
 #endif
 #ifdef EPIPE
-	case EPIPE: return "broken pipe";
+    case EPIPE: return "broken pipe";
 #endif
 #ifdef EPROCLIM
-	case EPROCLIM: return "too many processes";
+    case EPROCLIM: return "too many processes";
 #endif
 #ifdef EPROCUNAVAIL
-	case EPROCUNAVAIL: return "bad procedure for program";
+    case EPROCUNAVAIL: return "bad procedure for program";
 #endif
 #ifdef EPROGMISMATCH
-	case EPROGMISMATCH: return "program version wrong";
+    case EPROGMISMATCH: return "program version wrong";
 #endif
 #ifdef EPROGUNAVAIL
-	case EPROGUNAVAIL: return "RPC program not available";
+    case EPROGUNAVAIL: return "RPC program not available";
 #endif
 #ifdef EPROTO
-	case EPROTO: return "protocol error";
+    case EPROTO: return "protocol error";
 #endif
 #ifdef EPROTONOSUPPORT
-	case EPROTONOSUPPORT: return "protocol not suppored";
+    case EPROTONOSUPPORT: return "protocol not suppored";
 #endif
 #ifdef EPROTOTYPE
-	case EPROTOTYPE: return "protocol wrong type for socket";
+    case EPROTOTYPE: return "protocol wrong type for socket";
 #endif
 #ifdef ERANGE
-	case ERANGE: return "math result unrepresentable";
+    case ERANGE: return "math result unrepresentable";
 #endif
 #if defined(EREFUSED) && (!defined(ECONNREFUSED) || (EREFUSED != ECONNREFUSED))
-	case EREFUSED: return "EREFUSED";
+    case EREFUSED: return "EREFUSED";
 #endif
 #ifdef EREMCHG
-	case EREMCHG: return "remote address changed";
+    case EREMCHG: return "remote address changed";
 #endif
 #ifdef EREMDEV
-	case EREMDEV: return "remote device";
+    case EREMDEV: return "remote device";
 #endif
 #ifdef EREMOTE
-	case EREMOTE: return "pathname hit remote file system";
+    case EREMOTE: return "pathname hit remote file system";
 #endif
 #ifdef EREMOTEIO
-	case EREMOTEIO: return "remote i/o error";
+    case EREMOTEIO: return "remote i/o error";
 #endif
 #ifdef EREMOTERELEASE
-	case EREMOTERELEASE: return "EREMOTERELEASE";
+    case EREMOTERELEASE: return "EREMOTERELEASE";
 #endif
 #ifdef EROFS
-	case EROFS: return "read-only file system";
+    case EROFS: return "read-only file system";
 #endif
 #ifdef ERPCMISMATCH
-	case ERPCMISMATCH: return "RPC version is wrong";
+    case ERPCMISMATCH: return "RPC version is wrong";
 #endif
 #ifdef ERREMOTE
-	case ERREMOTE: return "object is remote";
+    case ERREMOTE: return "object is remote";
 #endif
 #ifdef ESHUTDOWN
-	case ESHUTDOWN: return "can't send afer socket shutdown";
+    case ESHUTDOWN: return "can't send afer socket shutdown";
 #endif
 #ifdef ESOCKTNOSUPPORT
-	case ESOCKTNOSUPPORT: return "socket type not supported";
+    case ESOCKTNOSUPPORT: return "socket type not supported";
 #endif
 #ifdef ESPIPE
-	case ESPIPE: return "invalid seek";
+    case ESPIPE: return "invalid seek";
 #endif
 #ifdef ESRCH
-	case ESRCH: return "no such process";
+    case ESRCH: return "no such process";
 #endif
 #ifdef ESRMNT
-	case ESRMNT: return "srmount error";
+    case ESRMNT: return "srmount error";
 #endif
 #ifdef ESTALE
-	case ESTALE: return "stale remote file handle";
+    case ESTALE: return "stale remote file handle";
 #endif
 #ifdef ESUCCESS
-	case ESUCCESS: return "Error 0";
+    case ESUCCESS: return "Error 0";
 #endif
 #if defined(ETIME) && (!defined(ELOOP) || (ETIME != ELOOP))
-	case ETIME: return "timer expired";
+    case ETIME: return "timer expired";
 #endif
 #if defined(ETIMEDOUT) && (!defined(ENOSTR) || (ETIMEDOUT != ENOSTR))
-	case ETIMEDOUT: return "connection timed out";
+    case ETIMEDOUT: return "connection timed out";
 #endif
 #ifdef ETOOMANYREFS
-	case ETOOMANYREFS: return "too many references: can't splice";
+    case ETOOMANYREFS: return "too many references: can't splice";
 #endif
 #ifdef ETXTBSY
-	case ETXTBSY: return "text file or pseudo-device busy";
+    case ETXTBSY: return "text file or pseudo-device busy";
 #endif
 #ifdef EUCLEAN
-	case EUCLEAN: return "structure needs cleaning";
+    case EUCLEAN: return "structure needs cleaning";
 #endif
 #ifdef EUNATCH
-	case EUNATCH: return "protocol driver not attached";
+    case EUNATCH: return "protocol driver not attached";
 #endif
 #ifdef EUSERS
-	case EUSERS: return "too many users";
+    case EUSERS: return "too many users";
 #endif
 #ifdef EVERSION
-	case EVERSION: return "version mismatch";
+    case EVERSION: return "version mismatch";
 #endif
 #if defined(EWOULDBLOCK) && (!defined(EAGAIN) || (EWOULDBLOCK != EAGAIN))
-	case EWOULDBLOCK: return "operation would block";
+    case EWOULDBLOCK: return "operation would block";
 #endif
 #ifdef EXDEV
-	case EXDEV: return "cross-domain link";
+    case EXDEV: return "cross-domain link";
 #endif
 #ifdef EXFULL
-	case EXFULL: return "message tables full";
+    case EXFULL: return "message tables full";
 #endif
-	default:
+    default:
 #ifdef NO_STRERROR
-	    return "unknown POSIX error";
+	return "unknown POSIX error";
 #else
-	    return strerror(errno);
+	return strerror(errno);
 #endif
     }
 }
@@ -922,9 +919,9 @@ Tcl_ErrnoMsg(err)
  *	Return a textual identifier for a signal number.
  *
  * Results:
- *	This procedure returns a machine-readable textual identifier
- *	that corresponds to sig.  The identifier is the same as the
- *	#define name in signal.h.
+ *	This procedure returns a machine-readable textual identifier that
+ *	corresponds to sig.  The identifier is the same as the #define name in
+ *	signal.h.
  *
  * Side effects:
  *	None.
@@ -934,113 +931,113 @@ Tcl_ErrnoMsg(err)
 
 CONST char *
 Tcl_SignalId(sig)
-    int sig;			/* Number of signal. */
+     int sig;			/* Number of signal. */
 {
     switch (sig) {
 #ifdef SIGABRT
-	case SIGABRT: return "SIGABRT";
+    case SIGABRT: return "SIGABRT";
 #endif
 #ifdef SIGALRM
-	case SIGALRM: return "SIGALRM";
+    case SIGALRM: return "SIGALRM";
 #endif
 #ifdef SIGBUS
-	case SIGBUS: return "SIGBUS";
+    case SIGBUS: return "SIGBUS";
 #endif
 #ifdef SIGCHLD
-	case SIGCHLD: return "SIGCHLD";
+    case SIGCHLD: return "SIGCHLD";
 #endif
 #if defined(SIGCLD) && (!defined(SIGCHLD) || (SIGCLD != SIGCHLD))
-	case SIGCLD: return "SIGCLD";
+    case SIGCLD: return "SIGCLD";
 #endif
 #ifdef SIGCONT
-	case SIGCONT: return "SIGCONT";
+    case SIGCONT: return "SIGCONT";
 #endif
 #if defined(SIGEMT) && (!defined(SIGXCPU) || (SIGEMT != SIGXCPU))
-	case SIGEMT: return "SIGEMT";
+    case SIGEMT: return "SIGEMT";
 #endif
 #ifdef SIGFPE
-	case SIGFPE: return "SIGFPE";
+    case SIGFPE: return "SIGFPE";
 #endif
 #ifdef SIGHUP
-	case SIGHUP: return "SIGHUP";
+    case SIGHUP: return "SIGHUP";
 #endif
 #ifdef SIGILL
-	case SIGILL: return "SIGILL";
+    case SIGILL: return "SIGILL";
 #endif
 #ifdef SIGINT
-	case SIGINT: return "SIGINT";
+    case SIGINT: return "SIGINT";
 #endif
 #ifdef SIGIO
-	case SIGIO: return "SIGIO";
+    case SIGIO: return "SIGIO";
 #endif
 #if defined(SIGIOT) && (!defined(SIGABRT) || (SIGIOT != SIGABRT))
-	case SIGIOT: return "SIGIOT";
+    case SIGIOT: return "SIGIOT";
 #endif
 #ifdef SIGKILL
-	case SIGKILL: return "SIGKILL";
+    case SIGKILL: return "SIGKILL";
 #endif
 #if defined(SIGLOST) && (!defined(SIGIOT) || (SIGLOST != SIGIOT)) && (!defined(SIGURG) || (SIGLOST != SIGURG)) && (!defined(SIGPROF) || (SIGLOST != SIGPROF)) && (!defined(SIGIO) || (SIGLOST != SIGIO))
-	case SIGLOST: return "SIGLOST";
+    case SIGLOST: return "SIGLOST";
 #endif
 #ifdef SIGPIPE
-	case SIGPIPE: return "SIGPIPE";
+    case SIGPIPE: return "SIGPIPE";
 #endif
 #if defined(SIGPOLL) && (!defined(SIGIO) || (SIGPOLL != SIGIO))
-	case SIGPOLL: return "SIGPOLL";
+    case SIGPOLL: return "SIGPOLL";
 #endif
 #ifdef SIGPROF
-	case SIGPROF: return "SIGPROF";
+    case SIGPROF: return "SIGPROF";
 #endif
 #if defined(SIGPWR) && (!defined(SIGXFSZ) || (SIGPWR != SIGXFSZ)) && (!defined(SIGLOST) || (SIGPWR != SIGLOST))
-	case SIGPWR: return "SIGPWR";
+    case SIGPWR: return "SIGPWR";
 #endif
 #ifdef SIGQUIT
-	case SIGQUIT: return "SIGQUIT";
+    case SIGQUIT: return "SIGQUIT";
 #endif
 #ifdef SIGSEGV
-	case SIGSEGV: return "SIGSEGV";
+    case SIGSEGV: return "SIGSEGV";
 #endif
 #ifdef SIGSTOP
-	case SIGSTOP: return "SIGSTOP";
+    case SIGSTOP: return "SIGSTOP";
 #endif
 #ifdef SIGSYS
-	case SIGSYS: return "SIGSYS";
+    case SIGSYS: return "SIGSYS";
 #endif
 #ifdef SIGTERM
-	case SIGTERM: return "SIGTERM";
+    case SIGTERM: return "SIGTERM";
 #endif
 #ifdef SIGTRAP
-	case SIGTRAP: return "SIGTRAP";
+    case SIGTRAP: return "SIGTRAP";
 #endif
 #ifdef SIGTSTP
-	case SIGTSTP: return "SIGTSTP";
+    case SIGTSTP: return "SIGTSTP";
 #endif
 #ifdef SIGTTIN
-	case SIGTTIN: return "SIGTTIN";
+    case SIGTTIN: return "SIGTTIN";
 #endif
 #ifdef SIGTTOU
-	case SIGTTOU: return "SIGTTOU";
+    case SIGTTOU: return "SIGTTOU";
 #endif
 #if defined(SIGURG) && (!defined(SIGIO) || (SIGURG != SIGIO))
-	case SIGURG: return "SIGURG";
+    case SIGURG: return "SIGURG";
 #endif
 #if defined(SIGUSR1) && (!defined(SIGIO) || (SIGUSR1 != SIGIO))
-	case SIGUSR1: return "SIGUSR1";
+    case SIGUSR1: return "SIGUSR1";
 #endif
 #if defined(SIGUSR2) && (!defined(SIGURG) || (SIGUSR2 != SIGURG))
-	case SIGUSR2: return "SIGUSR2";
+    case SIGUSR2: return "SIGUSR2";
 #endif
 #ifdef SIGVTALRM
-	case SIGVTALRM: return "SIGVTALRM";
+    case SIGVTALRM: return "SIGVTALRM";
 #endif
 #ifdef SIGWINCH
-	case SIGWINCH: return "SIGWINCH";
+    case SIGWINCH: return "SIGWINCH";
 #endif
 #ifdef SIGXCPU
-	case SIGXCPU: return "SIGXCPU";
+    case SIGXCPU: return "SIGXCPU";
 #endif
 #ifdef SIGXFSZ
-	case SIGXFSZ: return "SIGXFSZ";
+    case SIGXFSZ: return "SIGXFSZ";
 #endif
     }
     return "unknown signal";
@@ -1054,9 +1051,8 @@ Tcl_SignalId(sig)
  *	Return a human-readable message describing a signal.
  *
  * Results:
- *	This procedure returns a string describing sig that should
- *	make sense to a human.  It may not be easy for a machine
- *	to parse.
+ *	This procedure returns a string describing sig that should make sense
+ *	to a human.  It may not be easy for a machine to parse.
  *
  * Side effects:
  *	None.
@@ -1066,114 +1062,122 @@ Tcl_SignalId(sig)
 
 CONST char *
 Tcl_SignalMsg(sig)
-    int sig;			/* Number of signal. */
+     int sig;			/* Number of signal. */
 {
     switch (sig) {
 #ifdef SIGABRT
-	case SIGABRT: return "SIGABRT";
+    case SIGABRT: return "SIGABRT";
 #endif
 #ifdef SIGALRM
-	case SIGALRM: return "alarm clock";
+    case SIGALRM: return "alarm clock";
 #endif
 #ifdef SIGBUS
-	case SIGBUS: return "bus error";
+    case SIGBUS: return "bus error";
 #endif
 #ifdef SIGCHLD
-	case SIGCHLD: return "child status changed";
+    case SIGCHLD: return "child status changed";
 #endif
 #if defined(SIGCLD) && (!defined(SIGCHLD) || (SIGCLD != SIGCHLD))
-	case SIGCLD: return "child status changed";
+    case SIGCLD: return "child status changed";
 #endif
 #ifdef SIGCONT
-	case SIGCONT: return "continue after stop";
+    case SIGCONT: return "continue after stop";
 #endif
 #if defined(SIGEMT) && (!defined(SIGXCPU) || (SIGEMT != SIGXCPU))
-	case SIGEMT: return "EMT instruction";
+    case SIGEMT: return "EMT instruction";
 #endif
 #ifdef SIGFPE
-	case SIGFPE: return "floating-point exception";
+    case SIGFPE: return "floating-point exception";
 #endif
 #ifdef SIGHUP
-	case SIGHUP: return "hangup";
+    case SIGHUP: return "hangup";
 #endif
 #ifdef SIGILL
-	case SIGILL: return "illegal instruction";
+    case SIGILL: return "illegal instruction";
 #endif
 #ifdef SIGINT
-	case SIGINT: return "interrupt";
+    case SIGINT: return "interrupt";
 #endif
 #ifdef SIGIO
-	case SIGIO: return "input/output possible on file";
+    case SIGIO: return "input/output possible on file";
 #endif
 #if defined(SIGIOT) && (!defined(SIGABRT) || (SIGABRT != SIGIOT))
-	case SIGIOT: return "IOT instruction";
+    case SIGIOT: return "IOT instruction";
 #endif
 #ifdef SIGKILL
-	case SIGKILL: return "kill signal";
+    case SIGKILL: return "kill signal";
 #endif
 #if defined(SIGLOST) && (!defined(SIGIOT) || (SIGLOST != SIGIOT)) && (!defined(SIGURG) || (SIGLOST != SIGURG)) && (!defined(SIGPROF) || (SIGLOST != SIGPROF)) && (!defined(SIGIO) || (SIGLOST != SIGIO))
-	case SIGLOST: return "resource lost";
+    case SIGLOST: return "resource lost";
 #endif
 #ifdef SIGPIPE
-	case SIGPIPE: return "write on pipe with no readers";
+    case SIGPIPE: return "write on pipe with no readers";
 #endif
 #if defined(SIGPOLL) && (!defined(SIGIO) || (SIGPOLL != SIGIO))
-	case SIGPOLL: return "input/output possible on file";
+    case SIGPOLL: return "input/output possible on file";
 #endif
 #ifdef SIGPROF
-	case SIGPROF: return "profiling alarm";
+    case SIGPROF: return "profiling alarm";
 #endif
 #if defined(SIGPWR) && (!defined(SIGXFSZ) || (SIGPWR != SIGXFSZ)) && (!defined(SIGLOST) || (SIGPWR != SIGLOST))
-	case SIGPWR: return "power-fail restart";
+    case SIGPWR: return "power-fail restart";
 #endif
 #ifdef SIGQUIT
-	case SIGQUIT: return "quit signal";
+    case SIGQUIT: return "quit signal";
 #endif
 #ifdef SIGSEGV
-	case SIGSEGV: return "segmentation violation";
+    case SIGSEGV: return "segmentation violation";
 #endif
 #ifdef SIGSTOP
-	case SIGSTOP: return "stop";
+    case SIGSTOP: return "stop";
 #endif
 #ifdef SIGSYS
-	case SIGSYS: return "bad argument to system call";
+    case SIGSYS: return "bad argument to system call";
 #endif
 #ifdef SIGTERM
-	case SIGTERM: return "software termination signal";
+    case SIGTERM: return "software termination signal";
 #endif
 #ifdef SIGTRAP
-	case SIGTRAP: return "trace trap";
+    case SIGTRAP: return "trace trap";
 #endif
 #ifdef SIGTSTP
-	case SIGTSTP: return "stop signal from tty";
+    case SIGTSTP: return "stop signal from tty";
 #endif
 #ifdef SIGTTIN
-	case SIGTTIN: return "background tty read";
+    case SIGTTIN: return "background tty read";
 #endif
 #ifdef SIGTTOU
-	case SIGTTOU: return "background tty write";
+    case SIGTTOU: return "background tty write";
 #endif
 #if defined(SIGURG) && (!defined(SIGIO) || (SIGURG != SIGIO))
-	case SIGURG: return "urgent I/O condition";
+    case SIGURG: return "urgent I/O condition";
 #endif
 #if defined(SIGUSR1) && (!defined(SIGIO) || (SIGUSR1 != SIGIO))
-	case SIGUSR1: return "user-defined signal 1";
+    case SIGUSR1: return "user-defined signal 1";
 #endif
 #if defined(SIGUSR2) && (!defined(SIGURG) || (SIGUSR2 != SIGURG))
-	case SIGUSR2: return "user-defined signal 2";
+    case SIGUSR2: return "user-defined signal 2";
 #endif
 #ifdef SIGVTALRM
-	case SIGVTALRM: return "virtual time alarm";
+    case SIGVTALRM: return "virtual time alarm";
 #endif
 #ifdef SIGWINCH
-	case SIGWINCH: return "window changed";
+    case SIGWINCH: return "window changed";
 #endif
 #ifdef SIGXCPU
-	case SIGXCPU: return "exceeded CPU time limit";
+    case SIGXCPU: return "exceeded CPU time limit";
 #endif
 #ifdef SIGXFSZ
-	case SIGXFSZ: return "exceeded file size limit";
+    case SIGXFSZ: return "exceeded file size limit";
 #endif
     }
     return "unknown signal";
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */