hg/stx-libbasic: comparison UnixOperatingSystem.st

equal deleted inserted replaced

-:3a744321aa74
+:082b7d32692a
 "{ Encoding: utf8 }"
 "
 COPYRIGHT (c) 1988 by Claus Gittinger
-All Rights Reserved
+	      All Rights Reserved
 This software is furnished under a license and may be used
 only in accordance with the terms of that license and with the
 inclusion of the above copyright notice.   This software may not
 be provided or otherwise made available to, or used by, any
 # ifdef __osx__
 #  include <time.h>
 #  define HAS_TIMEGM
 struct tm {
-int     tm_sec;         /* seconds after the minute [0-60] */
+	int     tm_sec;         /* seconds after the minute [0-60] */
-int     tm_min;         /* minutes after the hour [0-59] */
+	int     tm_min;         /* minutes after the hour [0-59] */
-int     tm_hour;        /* hours since midnight [0-23] */
+	int     tm_hour;        /* hours since midnight [0-23] */
-int     tm_mday;        /* day of the month [1-31] */
+	int     tm_mday;        /* day of the month [1-31] */
-int     tm_mon;         /* months since January [0-11] */
+	int     tm_mon;         /* months since January [0-11] */
-int     tm_year;        /* years since 1900 */
+	int     tm_year;        /* years since 1900 */
-int     tm_wday;        /* days since Sunday [0-6] */
+	int     tm_wday;        /* days since Sunday [0-6] */
-int     tm_yday;        /* days since January 1 [0-365] */
+	int     tm_yday;        /* days since January 1 [0-365] */
-int     tm_isdst;       /* Daylight Savings Time flag */
+	int     tm_isdst;       /* Daylight Savings Time flag */
-long    tm_gmtoff;      /* offset from CUT in seconds */
+	long    tm_gmtoff;      /* offset from CUT in seconds */
-char    *tm_zone;       /* timezone abbreviation */
+	char    *tm_zone;       /* timezone abbreviation */
 };
 #  include <crt_externs.h>
 #  include <net/if_dl.h>
 pid_t pid;
 struct sigaction sa, intr, quit;
 sigset_t block, omask;
 if (line == NULL)
-return -1;
+	return -1;
 sa.sa_handler = SIG_IGN;
 sa.sa_flags = 0;
 __sigemptyset (&sa.sa_mask);
 if (__sigaction (SIGINT, &sa, &intr) < 0) {
-DPRINTF(("1: errno=%d\n", errno));
+	DPRINTF(("1: errno=%d\n", errno));
-return -1;
+	return -1;
 }
 if (__sigaction (SIGQUIT, &sa, &quit) < 0) {
-save = errno;
+	save = errno;
-(void) __sigaction (SIGINT, &intr, (struct sigaction *) NULL);
+	(void) __sigaction (SIGINT, &intr, (struct sigaction *) NULL);
-errno = save;
+	errno = save;
-DPRINTF(("2: errno=%d\n", errno));
+	DPRINTF(("2: errno=%d\n", errno));
-return -1;
+	return -1;
 }
 __sigemptyset (&block);
 __sigaddset (&block, SIGCHLD);
 save = errno;
 if (__sigprocmask(SIG_BLOCK, &block, &omask) < 0) {
-if (errno == ENOSYS)
+	if (errno == ENOSYS)
-errno = save;
+	    errno = save;
-else {
+	else {
-save = errno;
+	    save = errno;
-(void) __sigaction(SIGINT, &intr, (struct sigaction *) NULL);
+	    (void) __sigaction(SIGINT, &intr, (struct sigaction *) NULL);
-(void) __sigaction (SIGQUIT, &quit, (struct sigaction *) NULL);
+	    (void) __sigaction (SIGQUIT, &quit, (struct sigaction *) NULL);
-errno = save;
+	    errno = save;
-DPRINTF(("3: errno=%d\n", errno));
+	    DPRINTF(("3: errno=%d\n", errno));
-return -1;
+	    return -1;
-}
+	}
 }
 pid = FORK ();
 if (pid == (pid_t) 0) {
-/* Child side.  */
+	/* Child side.  */
-CONST char *new_argv[4];
+	CONST char *new_argv[4];
-new_argv[0] = SHELL_NAME;
+	new_argv[0] = SHELL_NAME;
-new_argv[1] = "-c";
+	new_argv[1] = "-c";
-new_argv[2] = line;
+	new_argv[2] = line;
-new_argv[3] = NULL;
+	new_argv[3] = NULL;
-/* Restore the signals.  */
+	/* Restore the signals.  */
-(void) __sigaction (SIGINT, &intr, (struct sigaction *) NULL);
+	(void) __sigaction (SIGINT, &intr, (struct sigaction *) NULL);
-(void) __sigaction (SIGQUIT, &quit, (struct sigaction *) NULL);
+	(void) __sigaction (SIGQUIT, &quit, (struct sigaction *) NULL);
-(void) __sigprocmask (SIG_SETMASK, &omask, (sigset_t *) NULL);
+	(void) __sigprocmask (SIG_SETMASK, &omask, (sigset_t *) NULL);
-/* Exec the shell.  */
+	/* Exec the shell.  */
-(void) __execve (SHELL_PATH, (char *CONST *) new_argv, __environ);
+	(void) __execve (SHELL_PATH, (char *CONST *) new_argv, __environ);
-_exit (127);
+	_exit (127);
 } else {
-if (pid < (pid_t) 0) {
+	if (pid < (pid_t) 0) {
-/* The fork failed.  */
+	    /* The fork failed.  */
-DPRINTF(("4: errno=%d\n", errno));
+	    DPRINTF(("4: errno=%d\n", errno));
-status = -1;
+	    status = -1;
-} else {
+	} else {
-/* Parent side.  */
+	    /* Parent side.  */
 #ifdef  NO_WAITPID
-pid_t child;
+	    pid_t child;
-do {
+	    do {
-__BEGIN_INTERRUPTABLE__
+		__BEGIN_INTERRUPTABLE__
-child = __wait (&status);
+		child = __wait (&status);
-__END_INTERRUPTABLE__
+		__END_INTERRUPTABLE__
-if (child < 0 && errno != EINTR) {
+		if (child < 0 && errno != EINTR) {
-DPRINTF(("5: errno=%d\n", errno));
+		    DPRINTF(("5: errno=%d\n", errno));
-status = -1;
+		    status = -1;
-break;
+		    break;
-}
+		}
-} while (child != pid);
+	    } while (child != pid);
 #else
-pid_t child;
+	    pid_t child;
-/* claus: the original did not care for EINTR here ... */
+	    /* claus: the original did not care for EINTR here ... */
-do {
+	    do {
-__BEGIN_INTERRUPTABLE__
+		__BEGIN_INTERRUPTABLE__
-child = __waitpid (pid, &status, 0);
+		child = __waitpid (pid, &status, 0);
-__END_INTERRUPTABLE__
+		__END_INTERRUPTABLE__
-} while ((child != pid) && (errno == EINTR));
+	    } while ((child != pid) && (errno == EINTR));
-if (child != pid) {
+	    if (child != pid) {
-DPRINTF(("6: errno=%d\n", errno));
+		DPRINTF(("6: errno=%d\n", errno));
-status = -1;
+		status = -1;
-}
+	    }
 #endif /* NO_WAITPID */
-}
+	}
 }
 save = errno;
 if ((__sigaction (SIGINT, &intr, (struct sigaction *) NULL)
 | __sigaction (SIGQUIT, &quit, (struct sigaction *) NULL)
 | __sigprocmask (SIG_SETMASK, &omask, (sigset_t *) NULL)) != 0) {
-if (errno == ENOSYS) {
+	if (errno == ENOSYS) {
-errno = save;
+	    errno = save;
-} else {
+	} else {
-status = -1;
+	    status = -1;
-DPRINTF(("7: errno=%d\n", errno));
+	    DPRINTF(("7: errno=%d\n", errno));
-}
+	}
 }
 return status;
 }
 #else
 # endif
 static char *
 realpath(const char *path, char *resolved_path)
 {
-char copy_path[MAXPATHLEN];
+	char copy_path[MAXPATHLEN];
-char link_path[MAXPATHLEN];
+	char link_path[MAXPATHLEN];
-char *new_path, *max_path, *mallocedPath;
+	char *new_path, *max_path, *mallocedPath;
-int readlinks = 0;
+	int readlinks = 0;
-int n;
+	int n;
-if (resolved_path == NULL) {
+	if (resolved_path == NULL) {
-mallocedPath = resolved_path = malloc(MAXPATHLEN+1);
+	    mallocedPath = resolved_path = malloc(MAXPATHLEN+1);
-}
+	}
-new_path = resolved_path;
+	new_path = resolved_path;
-/* Make a copy of the source path since we may need to modify it. */
+	/* Make a copy of the source path since we may need to modify it. */
-strcpy(copy_path, path);
+	strcpy(copy_path, path);
-path = copy_path;
+	path = copy_path;
-max_path = copy_path + MAXPATHLEN - 2;
+	max_path = copy_path + MAXPATHLEN - 2;
-/* If it's a relative pathname use getwd for starters. */
+	/* If it's a relative pathname use getwd for starters. */
-if (*path != '/') {
+	if (*path != '/') {
 #ifdef HAS_GETCWD
-new_path = getcwd(new_path, MAXPATHLEN - 1);
+		new_path = getcwd(new_path, MAXPATHLEN - 1);
 #else
-new_path = getwd(new_path);
+		new_path = getwd(new_path);
 #endif
-if (new_path == NULL) {
+		if (new_path == NULL) {
-if (mallocedPath) free(mallocedPath);
+		    if (mallocedPath) free(mallocedPath);
-return(NULL);
+		    return(NULL);
-}
+		}
-new_path += strlen(new_path);
+		new_path += strlen(new_path);
-if (new_path[-1] != '/')
+		if (new_path[-1] != '/')
-*new_path++ = '/';
+			*new_path++ = '/';
-}
+	}
-else {
+	else {
-*new_path++ = '/';
+		*new_path++ = '/';
-path++;
+		path++;
-}
+	}
-/* Expand each slash-separated pathname component. */
+	/* Expand each slash-separated pathname component. */
-while (*path != '\0') {
+	while (*path != '\0') {
-/* Ignore stray "/". */
+		/* Ignore stray "/". */
-if (*path == '/') {
+		if (*path == '/') {
-path++;
+			path++;
-continue;
+			continue;
-}
+		}
-if (*path == '.') {
+		if (*path == '.') {
-/* Ignore ".". */
+			/* Ignore ".". */
-if (path[1] == '\0' || path[1] == '/') {
+			if (path[1] == '\0' || path[1] == '/') {
-path++;
+				path++;
-continue;
+				continue;
-}
+			}
-if (path[1] == '.') {
+			if (path[1] == '.') {
-if (path[2] == '\0' || path[2] == '/') {
+				if (path[2] == '\0' || path[2] == '/') {
-path += 2;
+					path += 2;
-/* Ignore ".." at root. */
+					/* Ignore ".." at root. */
-if (new_path == resolved_path + 1)
+					if (new_path == resolved_path + 1)
-continue;
+						continue;
-/* Handle ".." by backing up. */
+					/* Handle ".." by backing up. */
-while ((--new_path)[-1] != '/')
+					while ((--new_path)[-1] != '/')
-;
+						;
-continue;
+					continue;
-}
+				}
-}
+			}
-}
+		}
-/* Safely copy the next pathname component. */
+		/* Safely copy the next pathname component. */
-while (*path != '\0' && *path != '/') {
+		while (*path != '\0' && *path != '/') {
-if (path > max_path) {
+			if (path > max_path) {
-if (mallocedPath) free(mallocedPath);
+			    if (mallocedPath) free(mallocedPath);
-errno = ENAMETOOLONG;
+			    errno = ENAMETOOLONG;
-return NULL;
+			    return NULL;
-}
+			}
-*new_path++ = *path++;
+			*new_path++ = *path++;
-}
+		}
 #ifdef S_IFLNK
-/* Protect against infinite loops. */
+		/* Protect against infinite loops. */
-if (readlinks++ > MAX_READLINKS) {
+		if (readlinks++ > MAX_READLINKS) {
-if (mallocedPath) free(mallocedPath);
+		    if (mallocedPath) free(mallocedPath);
-errno = ELOOP;
+		    errno = ELOOP;
-return NULL;
+		    return NULL;
-}
+		}
-/* See if latest pathname component is a symlink. */
+		/* See if latest pathname component is a symlink. */
-*new_path = '\0';
+		*new_path = '\0';
-n = readlink(resolved_path, link_path, MAXPATHLEN - 1);
+		n = readlink(resolved_path, link_path, MAXPATHLEN - 1);
-if (n < 0) {
+		if (n < 0) {
-/* EINVAL means the file exists but isn't a symlink. */
+			/* EINVAL means the file exists but isn't a symlink. */
-if (errno != EINVAL) {
+			if (errno != EINVAL) {
-if (mallocedPath) free(mallocedPath);
+			    if (mallocedPath) free(mallocedPath);
-return NULL;
+			    return NULL;
-}
+			}
-}
+		}
-else {
+		else {
-/* Note: readlink doesn't add the null byte. */
+			/* Note: readlink doesn't add the null byte. */
-link_path[n] = '\0';
+			link_path[n] = '\0';
-if (*link_path == '/')
+			if (*link_path == '/')
-/* Start over for an absolute symlink. */
+				/* Start over for an absolute symlink. */
-new_path = resolved_path;
+				new_path = resolved_path;
-else
+			else
-/* Otherwise back up over this component. */
+				/* Otherwise back up over this component. */
-while (*(--new_path) != '/')
+				while (*(--new_path) != '/')
-;
+					;
-/* Safe sex check. */
+			/* Safe sex check. */
-if (strlen(path) + n >= MAXPATHLEN) {
+			if (strlen(path) + n >= MAXPATHLEN) {
-if (mallocedPath) free(mallocedPath);
+			    if (mallocedPath) free(mallocedPath);
-errno = ENAMETOOLONG;
+			    errno = ENAMETOOLONG;
-return NULL;
+			    return NULL;
-}
+			}
-/* Insert symlink contents into path. */
+			/* Insert symlink contents into path. */
-strcat(link_path, path);
+			strcat(link_path, path);
-strcpy(copy_path, link_path);
+			strcpy(copy_path, link_path);
-path = copy_path;
+			path = copy_path;
-}
+		}
 #endif /* S_IFLNK */
-*new_path++ = '/';
+		*new_path++ = '/';
-}
+	}
-/* Delete trailing slash but don't whomp a lone slash. */
+	/* Delete trailing slash but don't whomp a lone slash. */
-if (new_path != resolved_path + 1 && new_path[-1] == '/')
+	if (new_path != resolved_path + 1 && new_path[-1] == '/')
-new_path--;
+		new_path--;
-/* Make sure it's null terminated. */
+	/* Make sure it's null terminated. */
-*new_path = '\0';
+	*new_path = '\0';
-return resolved_path;
+	return resolved_path;
 }
 # define HAS_REALPATH
 #endif /* WANT_REALPATH && not HAS_REALPATH */
 %}
 !UnixOperatingSystem class methodsFor:'documentation'!
 copyright
 "
 COPYRIGHT (c) 1988 by Claus Gittinger
-All Rights Reserved
+	      All Rights Reserved
 This software is furnished under a license and may be used
 only in accordance with the terms of that license and with the
 inclusion of the above copyright notice.   This software may not
 be provided or otherwise made available to, or used by, any
 able to get down to a select or fork system call easily (at least on Unix systems).
 You decide - portability vs. functionality)
 [Class variables:]
-HostName        <String>        remembered hostname
+	HostName        <String>        remembered hostname
-DomainName      <String>        remembered domainname
+	DomainName      <String>        remembered domainname
-SlowFork        <Boolean>       if set, fork and popen are avoided;
+	SlowFork        <Boolean>       if set, fork and popen are avoided;
-(more or less obsolete now)
+					(more or less obsolete now)
-CurrentDirectory <String>       remembered currentDirectories path
+	CurrentDirectory <String>       remembered currentDirectories path
 [author:]
-Claus Gittinger
+	Claus Gittinger
 [see also:]
-OSProcessStatus
+	OSProcessStatus
-Filename Date Time
+	Filename Date Time
-ExternalStream FileStream PipeStream Socket
+	ExternalStream FileStream PipeStream Socket
 "
 !
 examples
 "
 various queries
-[exBegin]
+								[exBegin]
 Transcript
-showCR:'hello ' , (OperatingSystem getLoginName)
+	showCR:'hello ' , (OperatingSystem getLoginName)
-[exEnd]
+								[exEnd]
-[exBegin]
+								[exBegin]
 OperatingSystem isUNIXlike ifTrue:[
-Transcript showCR:'this is some UNIX-like OS'
+	Transcript showCR:'this is some UNIX-like OS'
 ] ifFalse:[
-Transcript showCR:'this OS is not UNIX-like'
+	Transcript showCR:'this OS is not UNIX-like'
 ]
-[exEnd]
+								[exEnd]
-[exBegin]
+								[exBegin]
 Transcript
-showCR:'this machine is called ' , OperatingSystem getHostName
+	showCR:'this machine is called ' , OperatingSystem getHostName
-[exEnd]
+								[exEnd]
-[exBegin]
+								[exBegin]
 Transcript
-showCR:('this machine is in the '
+	showCR:('this machine is in the '
-, OperatingSystem getDomainName
+	       , OperatingSystem getDomainName
-, ' domain')
+	       , ' domain')
-[exEnd]
+								[exEnd]
-[exBegin]
+								[exBegin]
 Transcript
-showCR:('this machine''s CPU is a '
+	showCR:('this machine''s CPU is a '
-, OperatingSystem getCPUType
+	       , OperatingSystem getCPUType
-)
+	       )
-[exEnd]
+								[exEnd]
-[exBegin]
+								[exBegin]
 Transcript showCR:'executing ls command ...'.
 OperatingSystem executeCommand:'ls'.
 Transcript showCR:'... done.'.
-[exEnd]
+								[exEnd]
 locking a file
 (should be executed on two running smalltalks - not in two threads):
-[exBegin]
+								[exBegin]
 |f|
 f := 'testFile' asFilename readWriteStream.
 10 timesRepeat:[
-'about to lock ...' printCR.
+	'about to lock ...' printCR.
-[
+	[
-OperatingSystem
+	  OperatingSystem
-lockFD:(f fileDescriptor)
+	    lockFD:(f fileDescriptor)
-shared:false
+	    shared:false
-blocking:false
+	    blocking:false
-] whileFalse:[
+	] whileFalse:[
-'process ' print. OperatingSystem getProcessId print. ' is waiting' printCR.
+	    'process ' print. OperatingSystem getProcessId print. ' is waiting' printCR.
-Delay waitForSeconds:1
+	    Delay waitForSeconds:1
-].
+	].
-'LOCKED ...' printCR.
+	'LOCKED ...' printCR.
-Delay waitForSeconds:10.
+	Delay waitForSeconds:10.
-'unlock ...' printCR.
+	'unlock ...' printCR.
-(OperatingSystem
+	(OperatingSystem
-unlockFD:(f fileDescriptor)) printCR.
+	    unlockFD:(f fileDescriptor)) printCR.
-Delay waitForSeconds:3.
+	Delay waitForSeconds:3.
 ]
-[exBegin]
+								[exBegin]
 "
 ! !
 !UnixOperatingSystem class methodsFor:'initialization'!
 initialize
 "initialize the class"
 "/ protect against double initialization
 Initialized isNil ifTrue:[
-ObjectMemory addDependent:self.
+	ObjectMemory addDependent:self.
-self initializeCachedData.
+	self initializeCachedData.
-Initialized := true.
+	Initialized := true.
 ].
 !
 initializeCachedData
 HostName := nil.
 char *__codeset;
 setlocale(LC_CTYPE, "");
 __codeset = nl_langinfo(CODESET);
 if (strlen(__codeset) > 0) {
-codeset = __MKSTRING(__codeset);
+	codeset = __MKSTRING(__codeset);
 }
 %}.
 codeset notNil ifTrue:[
-codeset := codeset asLowercase.
+	codeset := codeset asLowercase.
-codeset = 'utf-8' ifTrue:[
+	codeset = 'utf-8' ifTrue:[
-codeset := #utf8.
+	    codeset := #utf8.
-] ifFalse:[
+	] ifFalse:[
-codeset := codeset asSymbol.
+	    codeset := codeset asSymbol.
-].
+	].
 ].
 Codeset := codeset.
 ^ codeset.
 "
 update:something with:aParameter from:changedObject
 "catch image restart and flush some cached data"
 something == #earlyRestart ifTrue:[
-self initializeCachedData
+	self initializeCachedData
 ]
 "Created: / 15.6.1996 / 15:22:37 / cg"
 "Modified: / 7.1.1997 / 19:36:11 / stefan"
 "Modified: / 11.12.1998 / 16:22:48 / cg"
 therefore do not remember or hardcode those numbers in the application)"
 %{  /* NOCONTEXT */
 #ifdef SIGABRT
 if (signalName == @symbol(SIGABRT)) {
-RETURN ( __mkSmallInteger(SIGABRT) );
+	RETURN ( __mkSmallInteger(SIGABRT) );
 }
 #endif
 #ifdef SIGALRM
 if (signalName == @symbol(SIGALRM)) {
-RETURN ( __mkSmallInteger(SIGALRM) );
+	RETURN ( __mkSmallInteger(SIGALRM) );
 }
 #endif
 #ifdef SIGBREAK
 if (signalName == @symbol(SIGBREAK)) {
-RETURN ( __mkSmallInteger(SIGBREAK) );
+	RETURN ( __mkSmallInteger(SIGBREAK) );
 }
 #endif
 #ifdef SIGBUS
 if (signalName == @symbol(SIGBUS)) {
-RETURN ( __mkSmallInteger(SIGBUS) );
+	RETURN ( __mkSmallInteger(SIGBUS) );
 }
 #endif
 #ifdef SIGCHLD
 if ((signalName == @symbol(SIGCHLD))
 || (signalName == @symbol(SIGCLD)) ) {
-RETURN ( __mkSmallInteger(SIGCHLD) );
+	RETURN ( __mkSmallInteger(SIGCHLD) );
 }
 #else
 # if defined(SIGCLD)
 if ((signalName == @symbol(SIGCHLD))
 || (signalName == @symbol(SIGCLD)) ) {
-RETURN ( __mkSmallInteger(SIGCLD) );
+	RETURN ( __mkSmallInteger(SIGCLD) );
 }
 # endif
 #endif
 #ifdef SIGCONT
 if (signalName == @symbol(SIGCONT)) {
-RETURN ( __mkSmallInteger(SIGCONT) );
+	RETURN ( __mkSmallInteger(SIGCONT) );
 }
 #endif
 #ifdef SIGDANGER
 if (signalName == @symbol(SIGDANGER)) {
-RETURN ( __mkSmallInteger(SIGDANGER) );
+	RETURN ( __mkSmallInteger(SIGDANGER) );
 }
 #endif
 #ifdef SIGEMT
 if (signalName == @symbol(SIGEMT)) {
-RETURN ( __mkSmallInteger(SIGEMT) );
+	RETURN ( __mkSmallInteger(SIGEMT) );
 }
 #endif
 #ifdef SIGFPE
 if (signalName == @symbol(SIGFPE)) {
-RETURN ( __mkSmallInteger(SIGFPE) );
+	RETURN ( __mkSmallInteger(SIGFPE) );
 }
 #endif
 #ifdef SIGGRANT
 if (signalName == @symbol(SIGGRANT)) {
-RETURN ( __mkSmallInteger(SIGGRANT) );
+	RETURN ( __mkSmallInteger(SIGGRANT) );
 }
 #endif
 #ifdef SIGHUP
 if (signalName == @symbol(SIGHUP)) {
-RETURN ( __mkSmallInteger(SIGHUP) );
+	RETURN ( __mkSmallInteger(SIGHUP) );
 }
 #endif
 #ifdef SIGILL
 if (signalName == @symbol(SIGILL)) {
-RETURN ( __mkSmallInteger(SIGILL) );
+	RETURN ( __mkSmallInteger(SIGILL) );
 }
 #endif
 #ifdef SIGINT
 if (signalName == @symbol(SIGINT)) {
-RETURN ( __mkSmallInteger(SIGINT) );
+	RETURN ( __mkSmallInteger(SIGINT) );
 }
 #endif
 #ifdef SIGIO
 if (signalName == @symbol(SIGIO)) {
-RETURN ( __mkSmallInteger(SIGIO) );
+	RETURN ( __mkSmallInteger(SIGIO) );
 }
 #endif
 #ifdef SIGIOT
 if (signalName == @symbol(SIGIOT)) {
-RETURN ( __mkSmallInteger(SIGIOT) );
+	RETURN ( __mkSmallInteger(SIGIOT) );
 }
 #endif
 #ifdef SIGKILL
 if (signalName == @symbol(SIGKILL)) {
-RETURN ( __mkSmallInteger(SIGKILL) );
+	RETURN ( __mkSmallInteger(SIGKILL) );
 }
 #endif
 #ifdef SIGLOST
 if (signalName == @symbol(SIGLOST)) {
-RETURN ( __mkSmallInteger(SIGLOST) );
+	RETURN ( __mkSmallInteger(SIGLOST) );
 }
 #endif
 #ifdef SIGMIGRATE
 if (signalName == @symbol(SIGMIGRATE)) {
-RETURN ( __mkSmallInteger(SIGMIGRATE) );
+	RETURN ( __mkSmallInteger(SIGMIGRATE) );
 }
 #endif
 #ifdef SIGMSG
 if (signalName == @symbol(SIGMSG)) {
-RETURN ( __mkSmallInteger(SIGMSG) );
+	RETURN ( __mkSmallInteger(SIGMSG) );
 }
 #endif
 #ifdef SIGPIPE
 if (signalName == @symbol(SIGPIPE)) {
-RETURN ( __mkSmallInteger(SIGPIPE) );
+	RETURN ( __mkSmallInteger(SIGPIPE) );
 }
 #endif
 #ifdef SIGPOLL
 if (signalName == @symbol(SIGPOLL)) {
-RETURN ( __mkSmallInteger(SIGPOLL) );
+	RETURN ( __mkSmallInteger(SIGPOLL) );
 }
 #endif
 #ifdef SIGPRE
 if (signalName == @symbol(SIGPRE)) {
-RETURN ( __mkSmallInteger(SIGPRE) );
+	RETURN ( __mkSmallInteger(SIGPRE) );
 }
 #endif
 #ifdef SIGPROF
 if (signalName == @symbol(SIGPROF)) {
-RETURN ( __mkSmallInteger(SIGPROF) );
+	RETURN ( __mkSmallInteger(SIGPROF) );
 }
 #endif
 #ifdef SIGPWR
 if (signalName == @symbol(SIGPWR)) {
-RETURN ( __mkSmallInteger(SIGPWR) );
+	RETURN ( __mkSmallInteger(SIGPWR) );
 }
 #endif
 #ifdef SIGQUIT
 if (signalName == @symbol(SIGQUIT)) {
-RETURN ( __mkSmallInteger(SIGQUIT) );
+	RETURN ( __mkSmallInteger(SIGQUIT) );
 }
 #endif
 #ifdef SIGRETRACT
 if (signalName == @symbol(SIGRETRACT)) {
-RETURN ( __mkSmallInteger(SIGRETRACT) );
+	RETURN ( __mkSmallInteger(SIGRETRACT) );
 }
 #endif
 #ifdef SIGSAK
 if (signalName == @symbol(SIGSAK)) {
-RETURN ( __mkSmallInteger(SIGSAK) );
+	RETURN ( __mkSmallInteger(SIGSAK) );
 }
 #endif
 #ifdef SIGSEGV
 if (signalName == @symbol(SIGSEGV)) {
-RETURN ( __mkSmallInteger(SIGSEGV) );
+	RETURN ( __mkSmallInteger(SIGSEGV) );
 }
 #endif
 #ifdef SIGSOUND
 if (signalName == @symbol(SIGSOUND)) {
-RETURN ( __mkSmallInteger(SIGSOUND) );
+	RETURN ( __mkSmallInteger(SIGSOUND) );
 }
 #endif
 #ifdef SIGSTOP
 if (signalName == @symbol(SIGSTOP)) {
-RETURN ( __mkSmallInteger(SIGSTOP) );
+	RETURN ( __mkSmallInteger(SIGSTOP) );
 }
 #endif
 #ifdef SIGSYS
 if (signalName == @symbol(SIGSYS)) {
-RETURN ( __mkSmallInteger(SIGSYS) );
+	RETURN ( __mkSmallInteger(SIGSYS) );
 }
 #endif
 #ifdef SIGTERM
 if (signalName == @symbol(SIGTERM)) {
-RETURN ( __mkSmallInteger(SIGTERM) );
+	RETURN ( __mkSmallInteger(SIGTERM) );
 }
 #endif
 #ifdef SIGTRAP
 if (signalName == @symbol(SIGTRAP)) {
-RETURN ( __mkSmallInteger(SIGTRAP) );
+	RETURN ( __mkSmallInteger(SIGTRAP) );
 }
 #endif
 #ifdef SIGTSTP
 if (signalName == @symbol(SIGTSTP)) {
-RETURN ( __mkSmallInteger(SIGTSTP) );
+	RETURN ( __mkSmallInteger(SIGTSTP) );
 }
 #endif
 #ifdef SIGTTIN
 if (signalName == @symbol(SIGTTIN)) {
-RETURN ( __mkSmallInteger(SIGTTIN) );
+	RETURN ( __mkSmallInteger(SIGTTIN) );
 }
 #endif
 #ifdef SIGTTOU
 if (signalName == @symbol(SIGTTOU)) {
-RETURN ( __mkSmallInteger(SIGTTOU) );
+	RETURN ( __mkSmallInteger(SIGTTOU) );
 }
 #endif
 #ifdef SIGURG
 if (signalName == @symbol(SIGURG)) {
-RETURN ( __mkSmallInteger(SIGURG) );
+	RETURN ( __mkSmallInteger(SIGURG) );
 }
 #endif
 #ifdef SIGUSR1
 if (signalName == @symbol(SIGUSR1)) {
-RETURN ( __mkSmallInteger(SIGUSR1) );
+	RETURN ( __mkSmallInteger(SIGUSR1) );
 }
 #endif
 #ifdef SIGUSR2
 if (signalName == @symbol(SIGUSR2)) {
-RETURN ( __mkSmallInteger(SIGUSR2) );
+	RETURN ( __mkSmallInteger(SIGUSR2) );
 }
 #endif
 #ifdef SIGVTALRM
 if (signalName == @symbol(SIGVTALRM)) {
-RETURN ( __mkSmallInteger(SIGVTALRM) );
+	RETURN ( __mkSmallInteger(SIGVTALRM) );
 }
 #endif
 #ifdef SIGWINCH
 if (signalName == @symbol(SIGWINCH)) {
-RETURN ( __mkSmallInteger(SIGWINCH) );
+	RETURN ( __mkSmallInteger(SIGWINCH) );
 }
 #endif
 #ifdef SIGXCPU
 if (signalName == @symbol(SIGXCPU)) {
-RETURN ( __mkSmallInteger(SIGXCPU) );
+	RETURN ( __mkSmallInteger(SIGXCPU) );
 }
 #endif
 #ifdef SIGXFSZ
 if (signalName == @symbol(SIGXFSZ)) {
-RETURN ( __mkSmallInteger(SIGXFSZ) );
+	RETURN ( __mkSmallInteger(SIGXFSZ) );
 }
 #endif
 #ifdef SIGINFO
 if (signalName == @symbol(SIGINFO)) {
-RETURN ( __mkSmallInteger(SIGINFO) );
+	RETURN ( __mkSmallInteger(SIGINFO) );
 }
 #endif
 RETURN ( __mkSmallInteger(0) );
 %}
 "low level close of a directoryStream"
 %{
 #ifdef HAS_OPENDIR
 if (__isExternalAddressLike(dirPointer)) {
-closedir( (DIR *)(__FILEVal(dirPointer)) );
+	closedir( (DIR *)(__FILEVal(dirPointer)) );
 }
 #endif
 %}
 !
 DIR *d;
 DIRENT_STRUCT *dp;
 if ((dirPointer != nil)
 && __isExternalAddressLike(dirPointer)) {
-d = (DIR *)__FILEVal(dirPointer);
+	d = (DIR *)__FILEVal(dirPointer);
-__BEGIN_INTERRUPTABLE__
+	__BEGIN_INTERRUPTABLE__
-do {
+	do {
-do {
+	    do {
-__threadErrno = 0;
+		__threadErrno = 0;
-dp = readdir(d);
+		dp = readdir(d);
-/*
+		/*
-* for compatibility with ST-80,
+		 * for compatibility with ST-80,
-* skip entries for '.' and '..'.
+		 * skip entries for '.' and '..'.
-* If wanted, these must be added synthetically.
+		 * If wanted, these must be added synthetically.
-*/
+		 */
-} while (dp && ((strcmp(dp->d_name, ".")==0) || (strcmp(dp->d_name, "..")==0)));
+	    } while (dp && ((strcmp(dp->d_name, ".")==0) || (strcmp(dp->d_name, "..")==0)));
-} while ((dp == NULL) && (__threadErrno == EINTR));
+	} while ((dp == NULL) && (__threadErrno == EINTR));
-__END_INTERRUPTABLE__
+	__END_INTERRUPTABLE__
-if (dp != NULL) {
+	if (dp != NULL) {
-entry = __MKSTRING((char *)(dp->d_name));
+	    entry = __MKSTRING((char *)(dp->d_name));
-} else {
+	} else {
-if (__threadErrno) {
+	    if (__threadErrno) {
-error = __mkSmallInteger(__threadErrno);
+		error = __mkSmallInteger(__threadErrno);
-}
+	    }
 }
 }
 #endif /* HAS_OPENDIR */
 %}.
 error notNil ifTrue:[
-^ StreamIOError newException
+	^ StreamIOError newException
-errorCode:error;
+	    errorCode:error;
-osErrorHolder:(OperatingSystem errorHolderForNumber:error);
+	    osErrorHolder:(OperatingSystem errorHolderForNumber:error);
-parameter:aDirectoryStream;
+	    parameter:aDirectoryStream;
-raiseRequest
+	    raiseRequest
 ].
 entry notNil ifTrue:[
-^ FileStatusInfo new sourcePath:(self decodePath:entry).
+	^ FileStatusInfo new sourcePath:(self decodePath:entry).
 ].
 ^ aDirectoryStream pastEndRead
 ! !
 !UnixOperatingSystem class methodsFor:'dummy shell operations'!
 openApplicationForDocument:aFilenameOrString operation:operationSymbol mimeType:mimeTypeStringArgOrNil ifNone:exceptionBlock
 "open a windows-shell/mac finder/desktop application to present the document contained in aFilenameOrString.
 This is typically used to present help-files, html documents, pdf documents etc.
 operationSymbol is one of:
-open
+	open
-edit
+	edit
-explore
+	explore
 mimeTypeStringArgOrNil is e.g. 'text/html' or: 'application/pdf';
 if nil is passed in, the file's suffix is used to guess it.
 "
 | cmd |
 cmd := self openApplicationHelperCommand.
 cmd notNil ifTrue:[
-(cmd includesSubString:'%1') ifTrue:[
+	(cmd includesSubString:'%1') ifTrue:[
-cmd := cmd bindWith:aFilenameOrString asString.
+	    cmd := cmd bindWith:aFilenameOrString asString.
-] ifFalse:[
+	] ifFalse:[
-cmd := cmd, ' "', aFilenameOrString asString, '"'.
+	    cmd := cmd, ' "', aFilenameOrString asString, '"'.
-].
+	].
-(self
+	(self
-startProcess:cmd
+		startProcess:cmd
-inputFrom:nil outputTo:nil
+		inputFrom:nil outputTo:nil
-errorTo:nil auxFrom:nil
+		errorTo:nil auxFrom:nil
-environment: self getEnvironment inDirectory:nil) notNil ifTrue:[ ^ self ]
+		environment: self getEnvironment inDirectory:nil) notNil ifTrue:[ ^ self ]
 ].
 ^ super openApplicationForDocument:aFilenameOrString operation:operationSymbol mimeType:mimeTypeStringArgOrNil ifNone:exceptionBlock
 "
 | xdgCurrentDesktop |
 xdgCurrentDesktop := self getEnvironment: 'XDG_CURRENT_DESKTOP'.
 ((xdgCurrentDesktop = 'GNOME') and:[self canExecuteCommand: 'gnome-open']) ifTrue:[
-^ 'gnome-open'
+	^ 'gnome-open'
 ].
 "/ Guess...
 ((xdgCurrentDesktop = 'KDE') and:[self canExecuteCommand: 'kde-open']) ifTrue:[
-^ 'kde-open'
+	^ 'kde-open'
 ].
 (self canExecuteCommand: 'xdg-open') ifTrue:[
-^ 'xdg-open'
+	^ 'xdg-open'
 ].
 ^ nil
 "
 self openApplicationHelperCommand
 * I made this primitive code, since errnos are not
 * standard across unixes
 */
 if (__isSmallInteger(errNr)) {
-switch ( __intVal(errNr)) {
+	switch ( __intVal(errNr)) {
-/*
+	    /*
-* POSIX errnos - these should be defined
+	     * POSIX errnos - these should be defined
-*/
+	     */
 #ifdef EPERM
-case EPERM:
+	    case EPERM:
-sym = @symbol(EPERM);
+		sym = @symbol(EPERM);
-typ = @symbol(noPermissionsSignal);
+		typ = @symbol(noPermissionsSignal);
-break;
+		break;
 #endif
 #ifdef ENOENT
-case ENOENT:
+	    case ENOENT:
-sym = @symbol(ENOENT);
+		sym = @symbol(ENOENT);
-typ = @symbol(nonexistentSignal);
+		typ = @symbol(nonexistentSignal);
-break;
+		break;
 #endif
 #ifdef ESRCH
-case ESRCH:
+	    case ESRCH:
-sym = @symbol(ESRCH);
+		sym = @symbol(ESRCH);
-typ = @symbol(unavailableReferentSignal);
+		typ = @symbol(unavailableReferentSignal);
-break;
+		break;
 #endif
 #ifdef EINTR
-case EINTR:
+	    case EINTR:
-sym = @symbol(EINTR);
+		sym = @symbol(EINTR);
-typ = @symbol(transientErrorSignal);
+		typ = @symbol(transientErrorSignal);
-break;
+		break;
 #endif
 #ifdef EIO
-case EIO:
+	    case EIO:
-sym = @symbol(EIO);
+		sym = @symbol(EIO);
-typ = @symbol(transferFaultSignal);
+		typ = @symbol(transferFaultSignal);
-break;
+		break;
 #endif
 #ifdef ENXIO
-case ENXIO:
+	    case ENXIO:
-sym = @symbol(ENXIO);
+		sym = @symbol(ENXIO);
-typ = @symbol(unavailableReferentSignal);
+		typ = @symbol(unavailableReferentSignal);
-break;
+		break;
 #endif
 #ifdef E2BIG
-case E2BIG:
+	    case E2BIG:
-sym = @symbol(E2BIG);
+		sym = @symbol(E2BIG);
-typ = @symbol(invalidArgumentsSignal);
+		typ = @symbol(invalidArgumentsSignal);
-break;
+		break;
 #endif
 #ifdef ENOEXEC
-case ENOEXEC:
+	    case ENOEXEC:
-sym = @symbol(ENOEXEC);
+		sym = @symbol(ENOEXEC);
-typ = @symbol(inappropriateOperationSignal);
+		typ = @symbol(inappropriateOperationSignal);
-break;
+		break;
 #endif
 #ifdef EBADF
-case EBADF:
+	    case EBADF:
-sym = @symbol(EBADF);
+		sym = @symbol(EBADF);
-typ = @symbol(badAccessorSignal);
+		typ = @symbol(badAccessorSignal);
-break;
+		break;
 #endif
 #ifdef ECHILD
-case ECHILD:
+	    case ECHILD:
-sym = @symbol(ECHILD);
+		sym = @symbol(ECHILD);
-typ = @symbol(informationSignal);
+		typ = @symbol(informationSignal);
-break;
+		break;
 #endif
 #if !defined(EWOULDBLOCK) && defined(EAGAIN) && (EWOULDBLOCK != EAGAIN)
-case EAGAIN:
+	    case EAGAIN:
-sym = @symbol(EAGAIN);
+		sym = @symbol(EAGAIN);
-typ = @symbol(notReadySignal);
+		typ = @symbol(notReadySignal);
-break;
+		break;
 #endif
 #ifdef EOVERFLOW
-case EOVERFLOW:
+	    case EOVERFLOW:
-sym = @symbol(EOVERFLOW);
+		sym = @symbol(EOVERFLOW);
-typ = @symbol(rangeErrorSignal);
+		typ = @symbol(rangeErrorSignal);
-break;
+		break;
 #endif
 #ifdef ENOMEM
-case ENOMEM:
+	    case ENOMEM:
-sym = @symbol(ENOMEM);
+		sym = @symbol(ENOMEM);
-typ = @symbol(noMemorySignal);
+		typ = @symbol(noMemorySignal);
-break;
+		break;
 #endif
 #ifdef EACCES
-case EACCES:
+	    case EACCES:
-sym = @symbol(EACCES);
+		sym = @symbol(EACCES);
-typ = @symbol(noPermissionsSignal);
+		typ = @symbol(noPermissionsSignal);
-break;
+		break;
 #endif
 #ifdef EFAULT
-case EFAULT:
+	    case EFAULT:
-sym = @symbol(EFAULT);
+		sym = @symbol(EFAULT);
-typ = @symbol(invalidArgumentsSignal);
+		typ = @symbol(invalidArgumentsSignal);
-break;
+		break;
 #endif
 #ifdef EBUSY
-case EBUSY:
+	    case EBUSY:
-sym = @symbol(EBUSY);
+		sym = @symbol(EBUSY);
-typ = @symbol(unavailableReferentSignal);
+		typ = @symbol(unavailableReferentSignal);
-break;
+		break;
 #endif
 #ifdef EEXIST
-case EEXIST:
+	    case EEXIST:
-sym = @symbol(EEXIST);
+		sym = @symbol(EEXIST);
-typ = @symbol(existingReferentSignal);
+		typ = @symbol(existingReferentSignal);
-break;
+		break;
 #endif
 #ifdef EXDEV
-case EXDEV:
+	    case EXDEV:
-sym = @symbol(EXDEV);
+		sym = @symbol(EXDEV);
-typ = @symbol(inappropriateReferentSignal);
+		typ = @symbol(inappropriateReferentSignal);
-break;
+		break;
 #endif
 #ifdef ENODEV
-case ENODEV:
+	    case ENODEV:
-sym = @symbol(ENODEV);
+		sym = @symbol(ENODEV);
-typ = @symbol(inaccessibleSignal);
+		typ = @symbol(inaccessibleSignal);
-break;
+		break;
 #endif
 #ifdef ENOTDIR
-case ENOTDIR:
+	    case ENOTDIR:
-sym = @symbol(ENOTDIR);
+		sym = @symbol(ENOTDIR);
-typ = @symbol(inappropriateOperationSignal);
+		typ = @symbol(inappropriateOperationSignal);
-break;
+		break;
 #endif
 #ifdef EISDIR
-case EISDIR:
+	    case EISDIR:
-sym = @symbol(EISDIR);
+		sym = @symbol(EISDIR);
-typ = @symbol(inappropriateOperationSignal);
+		typ = @symbol(inappropriateOperationSignal);
-break;
+		break;
 #endif
 #ifdef EINVAL
-case EINVAL:
+	    case EINVAL:
-sym = @symbol(EINVAL);
+		sym = @symbol(EINVAL);
-typ = @symbol(invalidArgumentsSignal);
+		typ = @symbol(invalidArgumentsSignal);
-break;
+		break;
 #endif
 #ifdef ENFILE
-case ENFILE:
+	    case ENFILE:
-sym = @symbol(ENFILE);
+		sym = @symbol(ENFILE);
-typ = @symbol(noResourcesSignal);
+		typ = @symbol(noResourcesSignal);
-break;
+		break;
 #endif
 #ifdef EMFILE
-case EMFILE:
+	    case EMFILE:
-sym = @symbol(EMFILE);
+		sym = @symbol(EMFILE);
-typ = @symbol(noResourcesSignal);
+		typ = @symbol(noResourcesSignal);
-break;
+		break;
 #endif
 #ifdef ENOTTY
-case ENOTTY:
+	    case ENOTTY:
-sym = @symbol(ENOTTY);
+		sym = @symbol(ENOTTY);
-typ = @symbol(inappropriateOperationSignal);
+		typ = @symbol(inappropriateOperationSignal);
-break;
+		break;
 #endif
 #ifdef EFBIG
-case EFBIG:
+	    case EFBIG:
-sym = @symbol(EFBIG);
+		sym = @symbol(EFBIG);
-typ = @symbol(noResourcesSignal);
+		typ = @symbol(noResourcesSignal);
-break;
+		break;
 #endif
 #ifdef ENOSPC
-case ENOSPC:
+	    case ENOSPC:
-sym = @symbol(ENOSPC);
+		sym = @symbol(ENOSPC);
-typ = @symbol(noResourcesSignal);
+		typ = @symbol(noResourcesSignal);
-break;
+		break;
 #endif
 #ifdef ESPIPE
-case ESPIPE:
+	    case ESPIPE:
-sym = @symbol(ESPIPE);
+		sym = @symbol(ESPIPE);
-typ = @symbol(inappropriateOperationSignal);
+		typ = @symbol(inappropriateOperationSignal);
-break;
+		break;
 #endif
 #ifdef EROFS
-case EROFS:
+	    case EROFS:
-sym = @symbol(EROFS);
+		sym = @symbol(EROFS);
-typ = @symbol(inappropriateOperationSignal);
+		typ = @symbol(inappropriateOperationSignal);
-break;
+		break;
 #endif
 #ifdef EMLINK
-case EMLINK:
+	    case EMLINK:
-sym = @symbol(EMLINK);
+		sym = @symbol(EMLINK);
-typ = @symbol(rangeErrorSignal);
+		typ = @symbol(rangeErrorSignal);
-break;
+		break;
 #endif
 #ifdef EPIPE
-case EPIPE:
+	    case EPIPE:
-sym = @symbol(EPIPE);
+		sym = @symbol(EPIPE);
-typ = @symbol(peerFaultSignal);
+		typ = @symbol(peerFaultSignal);
-break;
+		break;
 #endif
 #ifdef EDOM
-case EDOM:
+	    case EDOM:
-sym = @symbol(EDOM);
+		sym = @symbol(EDOM);
-typ = @symbol(rangeErrorSignal);
+		typ = @symbol(rangeErrorSignal);
-break;
+		break;
 #endif
 #ifdef ERANGE
-case ERANGE:
+	    case ERANGE:
-sym = @symbol(ERANGE);
+		sym = @symbol(ERANGE);
-typ = @symbol(rangeErrorSignal);
+		typ = @symbol(rangeErrorSignal);
-break;
+		break;
 #endif
 #ifdef EDEADLK
 # if EDEADLK != EWOULDBLOCK
-case EDEADLK:
+	    case EDEADLK:
-sym = @symbol(EDEADLK);
+		sym = @symbol(EDEADLK);
-typ = @symbol(noResourcesSignal);
+		typ = @symbol(noResourcesSignal);
-break;
+		break;
 # endif
 #endif
 #ifdef ENAMETOOLONG
-case ENAMETOOLONG:
+	    case ENAMETOOLONG:
-sym = @symbol(ENAMETOOLONG);
+		sym = @symbol(ENAMETOOLONG);
-typ = @symbol(rangeErrorSignal);
+		typ = @symbol(rangeErrorSignal);
-break;
+		break;
 #endif
 #ifdef ENOLCK
-case ENOLCK:
+	    case ENOLCK:
-sym = @symbol(ENOLCK);
+		sym = @symbol(ENOLCK);
-typ = @symbol(inappropriateOperationSignal);
+		typ = @symbol(inappropriateOperationSignal);
-break;
+		break;
 #endif
 #ifdef ENOSYS
-case ENOSYS:
+	    case ENOSYS:
-sym = @symbol(ENOSYS);
+		sym = @symbol(ENOSYS);
-typ = @symbol(inappropriateOperationSignal);
+		typ = @symbol(inappropriateOperationSignal);
-break;
+		break;
 #endif
 #if defined(ENOTEMPTY) && (ENOTEMPTY != EEXIST)
-case ENOTEMPTY:
+	    case ENOTEMPTY:
-sym = @symbol(ENOTEMPTY);
+		sym = @symbol(ENOTEMPTY);
-typ = @symbol(inappropriateReferentSignal);
+		typ = @symbol(inappropriateReferentSignal);
-break;
+		break;
 #endif
 #ifdef EILSEQ
-case EILSEQ:
+	    case EILSEQ:
-sym = @symbol(EILSEQ);
+		sym = @symbol(EILSEQ);
-typ = @symbol(transferFaultSignal);
+		typ = @symbol(transferFaultSignal);
-break;
+		break;
 #endif
-/*
+	    /*
-* XPG3 errnos - defined on most systems
+	     * XPG3 errnos - defined on most systems
-*/
+	     */
 #ifdef ENOTBLK
-case ENOTBLK:
+	    case ENOTBLK:
-sym = @symbol(ENOTBLK);
+		sym = @symbol(ENOTBLK);
-typ = @symbol(inappropriateReferentSignal);
+		typ = @symbol(inappropriateReferentSignal);
-break;
+		break;
 #endif
 #ifdef ETXTBSY
-case ETXTBSY:
+	    case ETXTBSY:
-sym = @symbol(ETXTBSY);
+		sym = @symbol(ETXTBSY);
-typ = @symbol(inaccessibleSignal);
+		typ = @symbol(inaccessibleSignal);
-break;
+		break;
 #endif
-/*
+	    /*
-* some others
+	     * some others
-*/
+	     */
 #ifdef EWOULDBLOCK
-case EWOULDBLOCK:
+	    case EWOULDBLOCK:
-sym = @symbol(EWOULDBLOCK);
+		sym = @symbol(EWOULDBLOCK);
-typ = @symbol(notReadySignal);
+		typ = @symbol(notReadySignal);
-break;
+		break;
 #endif
 #ifdef ENOMSG
-case ENOMSG:
+	    case ENOMSG:
-sym = @symbol(ENOMSG);
+		sym = @symbol(ENOMSG);
-typ = @symbol(noDataSignal);
+		typ = @symbol(noDataSignal);
-break;
+		break;
 #endif
 #ifdef ELOOP
-case ELOOP:
+	    case ELOOP:
-sym = @symbol(ELOOP);
+		sym = @symbol(ELOOP);
-typ = @symbol(rangeErrorSignal);
+		typ = @symbol(rangeErrorSignal);
-break;
+		break;
 #endif
-/*
+	    /*
-* some stream errors
+	     * some stream errors
-*/
+	     */
 #ifdef ETIME
-case ETIME:
+	    case ETIME:
-sym = @symbol(ETIME);
+		sym = @symbol(ETIME);
-typ = @symbol(peerFaultSignal);
+		typ = @symbol(peerFaultSignal);
-break;
+		break;
 #endif
 #ifdef ENOSR
-case ENOSR:
+	    case ENOSR:
-sym = @symbol(ENOSR);
+		sym = @symbol(ENOSR);
-typ = @symbol(noResourcesSignal);
+		typ = @symbol(noResourcesSignal);
-break;
+		break;
 #endif
 #ifdef ENOSTR
-case ENOSTR:
+	    case ENOSTR:
-sym = @symbol(ENOSTR);
+		sym = @symbol(ENOSTR);
-typ = @symbol(inappropriateReferentSignal);
+		typ = @symbol(inappropriateReferentSignal);
-break;
+		break;
 #endif
 #ifdef ECOMM
-case ECOMM:
+	    case ECOMM:
-sym = @symbol(ECOMM);
+		sym = @symbol(ECOMM);
-typ = @symbol(transferFaultSignal);
+		typ = @symbol(transferFaultSignal);
-break;
+		break;
 #endif
 #ifdef EPROTO
-case EPROTO:
+	    case EPROTO:
-sym = @symbol(EPROTO);
+		sym = @symbol(EPROTO);
-typ = @symbol(inappropriateOperationSignal);
+		typ = @symbol(inappropriateOperationSignal);
-break;
+		break;
 #endif
-/*
+	    /*
-* nfs errors
+	     * nfs errors
-*/
+	     */
 #ifdef ESTALE
-case ESTALE:
+	    case ESTALE:
-sym = @symbol(ESTALE);
+		sym = @symbol(ESTALE);
-typ = @symbol(unavailableReferentSignal);
+		typ = @symbol(unavailableReferentSignal);
-break;
+		break;
 #endif
 #ifdef EREMOTE
-case EREMOTE:
+	    case EREMOTE:
-sym = @symbol(EREMOTE);
+		sym = @symbol(EREMOTE);
-typ = @symbol(rangeErrorSignal);
+		typ = @symbol(rangeErrorSignal);
-break;
+		break;
 #endif
-/*
+	    /*
-* some networking errors
+	     * some networking errors
-*/
+	     */
 #ifdef EINPROGRESS
-case EINPROGRESS:
+	    case EINPROGRESS:
-sym = @symbol(EINPROGRESS);
+		sym = @symbol(EINPROGRESS);
-typ = @symbol(operationStartedSignal);
+		typ = @symbol(operationStartedSignal);
-break;
+		break;
 #endif
 #ifdef EALREADY
-case EALREADY:
+	    case EALREADY:
-sym = @symbol(EALREADY);
+		sym = @symbol(EALREADY);
-typ = @symbol(operationStartedSignal);
+		typ = @symbol(operationStartedSignal);
-break;
+		break;
 #endif
 #ifdef ENOTSOCK
-case ENOTSOCK:
+	    case ENOTSOCK:
-sym = @symbol(ENOTSOCK);
+		sym = @symbol(ENOTSOCK);
-typ = @symbol(inappropriateOperationSignal);
+		typ = @symbol(inappropriateOperationSignal);
-break;
+		break;
 #endif
 #ifdef EDESTADDRREQ
-case EDESTADDRREQ:
+	    case EDESTADDRREQ:
-sym = @symbol(EDESTADDRREQ);
+		sym = @symbol(EDESTADDRREQ);
-typ = @symbol(underspecifiedSignal);
+		typ = @symbol(underspecifiedSignal);
-break;
+		break;
 #endif
 #ifdef EMSGSIZE
-case EMSGSIZE:
+	    case EMSGSIZE:
-sym = @symbol(EMSGSIZE);
+		sym = @symbol(EMSGSIZE);
-typ = @symbol(rangeErrorSignal);
+		typ = @symbol(rangeErrorSignal);
-break;
+		break;
 #endif
 #ifdef EPROTOTYPE
-case EPROTOTYPE:
+	    case EPROTOTYPE:
-sym = @symbol(EPROTOTYPE);
+		sym = @symbol(EPROTOTYPE);
-typ = @symbol(wrongSubtypeForOperationSignal);
+		typ = @symbol(wrongSubtypeForOperationSignal);
-break;
+		break;
 #endif
 #ifdef ENOPROTOOPT
-case ENOPROTOOPT:
+	    case ENOPROTOOPT:
-sym = @symbol(ENOPROTOOPT);
+		sym = @symbol(ENOPROTOOPT);
-typ = @symbol(unsupportedOperationSignal);
+		typ = @symbol(unsupportedOperationSignal);
-break;
+		break;
 #endif
 #ifdef EPROTONOSUPPORT
-case EPROTONOSUPPORT:
+	    case EPROTONOSUPPORT:
-sym = @symbol(EPROTONOSUPPORT);
+		sym = @symbol(EPROTONOSUPPORT);
-typ = @symbol(unsupportedOperationSignal);
+		typ = @symbol(unsupportedOperationSignal);
-break;
+		break;
 #endif
 #ifdef ESOCKTNOSUPPORT
-case ESOCKTNOSUPPORT:
+	    case ESOCKTNOSUPPORT:
-sym = @symbol(ESOCKTNOSUPPORT);
+		sym = @symbol(ESOCKTNOSUPPORT);
-typ = @symbol(unsupportedOperationSignal);
+		typ = @symbol(unsupportedOperationSignal);
-break;
+		break;
 #endif
 #ifdef EOPNOTSUPP
-case EOPNOTSUPP:
+	    case EOPNOTSUPP:
-sym = @symbol(EOPNOTSUPP);
+		sym = @symbol(EOPNOTSUPP);
-typ = @symbol(inappropriateOperationSignal);
+		typ = @symbol(inappropriateOperationSignal);
-break;
+		break;
 #endif
 #ifdef EPFNOSUPPORT
-case EPFNOSUPPORT:
+	    case EPFNOSUPPORT:
-sym = @symbol(EPFNOSUPPORT);
+		sym = @symbol(EPFNOSUPPORT);
-typ = @symbol(unsupportedOperationSignal);
+		typ = @symbol(unsupportedOperationSignal);
-break;
+		break;
 #endif
 #ifdef EAFNOSUPPORT
-case EAFNOSUPPORT:
+	    case EAFNOSUPPORT:
-sym = @symbol(EAFNOSUPPORT);
+		sym = @symbol(EAFNOSUPPORT);
-typ = @symbol(unsupportedOperationSignal);
+		typ = @symbol(unsupportedOperationSignal);
-break;
+		break;
 #endif
 #ifdef EADDRINUSE
-case EADDRINUSE:
+	    case EADDRINUSE:
-sym = @symbol(EADDRINUSE);
+		sym = @symbol(EADDRINUSE);
-typ = @symbol(existingReferentSignal);
+		typ = @symbol(existingReferentSignal);
-break;
+		break;
 #endif
 #ifdef EADDRNOTAVAIL
-case EADDRNOTAVAIL:
+	    case EADDRNOTAVAIL:
-sym = @symbol(EADDRNOTAVAIL);
+		sym = @symbol(EADDRNOTAVAIL);
-typ = @symbol(noPermissionsSignal);
+		typ = @symbol(noPermissionsSignal);
-break;
+		break;
 #endif
 #ifdef ETIMEDOUT
-case ETIMEDOUT:
+	    case ETIMEDOUT:
-sym = @symbol(ETIMEDOUT);
+		sym = @symbol(ETIMEDOUT);
-typ = @symbol(peerFaultSignal);
+		typ = @symbol(peerFaultSignal);
-break;
+		break;
 #endif
 #ifdef ECONNREFUSED
-case ECONNREFUSED:
+	    case ECONNREFUSED:
-sym = @symbol(ECONNREFUSED);
+		sym = @symbol(ECONNREFUSED);
-typ = @symbol(peerFaultSignal);
+		typ = @symbol(peerFaultSignal);
-break;
+		break;
 #endif
 #ifdef ENETDOWN
-case ENETDOWN:
+	    case ENETDOWN:
-sym = @symbol(ENETDOWN);
+		sym = @symbol(ENETDOWN);
-typ = @symbol(peerFaultSignal);
+		typ = @symbol(peerFaultSignal);
-break;
+		break;
 #endif
 #ifdef ENETUNREACH
-case ENETUNREACH:
+	    case ENETUNREACH:
-sym = @symbol(ENETUNREACH);
+		sym = @symbol(ENETUNREACH);
-typ = @symbol(peerFaultSignal);
+		typ = @symbol(peerFaultSignal);
-break;
+		break;
 #endif
 #ifdef ENETRESET
-case ENETRESET:
+	    case ENETRESET:
-sym = @symbol(ENETRESET);
+		sym = @symbol(ENETRESET);
-typ = @symbol(peerFaultSignal);
+		typ = @symbol(peerFaultSignal);
-break;
+		break;
 #endif
 #ifdef ECONNABORTED
-case ECONNABORTED:
+	    case ECONNABORTED:
-sym = @symbol(ECONNABORTED);
+		sym = @symbol(ECONNABORTED);
-typ = @symbol(peerFaultSignal);
+		typ = @symbol(peerFaultSignal);
-break;
+		break;
 #endif
 #ifdef ECONNRESET
-case ECONNRESET:
+	    case ECONNRESET:
-sym = @symbol(ECONNRESET);
+		sym = @symbol(ECONNRESET);
-typ = @symbol(peerFaultSignal);
+		typ = @symbol(peerFaultSignal);
-break;
+		break;
 #endif
 #ifdef EISCONN
-case EISCONN:
+	    case EISCONN:
-sym = @symbol(EISCONN);
+		sym = @symbol(EISCONN);
-typ = @symbol(unpreparedOperationSignal);
+		typ = @symbol(unpreparedOperationSignal);
-break;
+		break;
 #endif
 #ifdef ENOTCONN
-case ENOTCONN:
+	    case ENOTCONN:
-sym = @symbol(ENOTCONN);
+		sym = @symbol(ENOTCONN);
-typ = @symbol(unpreparedOperationSignal);
+		typ = @symbol(unpreparedOperationSignal);
-break;
+		break;
 #endif
 #ifdef ESHUTDOWN
-case ESHUTDOWN:
+	    case ESHUTDOWN:
-sym = @symbol(ESHUTDOWN);
+		sym = @symbol(ESHUTDOWN);
-typ = @symbol(unpreparedOperationSignal);
+		typ = @symbol(unpreparedOperationSignal);
-break;
+		break;
 #endif
 #ifdef EHOSTDOWN
-case EHOSTDOWN:
+	    case EHOSTDOWN:
-sym = @symbol(EHOSTDOWN);
+		sym = @symbol(EHOSTDOWN);
-typ = @symbol(peerFaultSignal);
+		typ = @symbol(peerFaultSignal);
-break;
+		break;
 #endif
 #ifdef EHOSTUNREACH
-case EHOSTUNREACH:
+	    case EHOSTUNREACH:
-sym = @symbol(EHOSTUNREACH);
+		sym = @symbol(EHOSTUNREACH);
-typ = @symbol(peerFaultSignal);
+		typ = @symbol(peerFaultSignal);
-break;
+		break;
 #endif
 #ifdef EDQUOT
-case EDQUOT:
+	    case EDQUOT:
-sym = @symbol(EDQUOT);
+		sym = @symbol(EDQUOT);
-typ = @symbol(noResourcesSignal);
+		typ = @symbol(noResourcesSignal);
-break;
+		break;
 #endif
 #ifdef ENOMEDIUM
-case ENOMEDIUM:
+	    case ENOMEDIUM:
-sym = @symbol(ENOMEDIUM);
+		sym = @symbol(ENOMEDIUM);
-typ = @symbol(noResourcesSignal);
+		typ = @symbol(noResourcesSignal);
-break;
+		break;
 #endif
 #ifdef EMEDIUMTYPE
-case EMEDIUMTYPE:
+	    case EMEDIUMTYPE:
-sym = @symbol(EMEDIUMTYPE);
+		sym = @symbol(EMEDIUMTYPE);
-typ = @symbol(noResourcesSignal);
+		typ = @symbol(noResourcesSignal);
-break;
+		break;
 #endif
-default:
+	    default:
-break;
+		break;
-}
+	}
 }
 %}.
 holder := OSErrorHolder new.
 sym isNil ifTrue:[
-sym := #ERROR_OTHER.
+	sym := #ERROR_OTHER.
-errNr notNil ifTrue:[
+	errNr notNil ifTrue:[
-"keep symbols as symbols"
+	    "keep symbols as symbols"
-holder parameter:(errNr isString ifTrue:[errNr] ifFalse:[errNr asString]).
+	    holder parameter:(errNr isString ifTrue:[errNr] ifFalse:[errNr asString]).
-].
+	].
 ].
 holder errorSymbol:sym errorCategory:(typ ? #defaultOsErrorSignal).
 ^ holder
 /*
 * POSIX errnos - these should be defined
 */
 #ifdef EPERM
 if (sym == @symbol(EPERM)) {
-RETURN ( __mkSmallInteger(EPERM) );
+	RETURN ( __mkSmallInteger(EPERM) );
 }
 #endif
 #ifdef ENOENT
 /* ERROR_FILE_NOT_FOUND is originally windows, but referd to in ExternalStream>>#openError: */
 if (sym == @symbol(ENOENT) || sym == @symbol(ERROR_FILE_NOT_FOUND)) {
-RETURN ( __mkSmallInteger(ENOENT) );
+	RETURN ( __mkSmallInteger(ENOENT) );
 }
 #endif
 #ifdef ESRCH
 if (sym == @symbol(ESRCH)) {
-RETURN ( __mkSmallInteger(ESRCH) );
+	RETURN ( __mkSmallInteger(ESRCH) );
 }
 #endif
 #ifdef EINTR
 if (sym == @symbol(EINTR)) {
-RETURN ( __mkSmallInteger(EINTR) );
+	RETURN ( __mkSmallInteger(EINTR) );
 }
 #endif
 #ifdef EIO
 if (sym == @symbol(EIO)) {
-RETURN ( __mkSmallInteger(EIO) );
+	RETURN ( __mkSmallInteger(EIO) );
 }
 #endif
 #ifdef ENXIO
 if (sym == @symbol(ENXIO)) {
-RETURN ( __mkSmallInteger(ENXIO) );
+	RETURN ( __mkSmallInteger(ENXIO) );
 }
 #endif
 #ifdef E2BIG
 if (sym == @symbol(E2BIG)) {
-RETURN ( __mkSmallInteger(E2BIG) );
+	RETURN ( __mkSmallInteger(E2BIG) );
 }
 #endif
 #ifdef ENOEXEC
 if (sym == @symbol(ENOEXEC)) {
-RETURN ( __mkSmallInteger(ENOEXEC) );
+	RETURN ( __mkSmallInteger(ENOEXEC) );
 }
 #endif
 #ifdef EBADF
 if (sym == @symbol(EBADF)) {
-RETURN ( __mkSmallInteger(EBADF) );
+	RETURN ( __mkSmallInteger(EBADF) );
 }
 #endif
 #ifdef ECHILD
 if (sym == @symbol(ECHILD)) {
-RETURN ( __mkSmallInteger(ECHILD) );
+	RETURN ( __mkSmallInteger(ECHILD) );
 }
 #endif
 #if defined(EAGAIN)
 if (sym == @symbol(EAGAIN)) {
-RETURN ( __mkSmallInteger(EAGAIN) );
+	RETURN ( __mkSmallInteger(EAGAIN) );
 }
 #endif
 #ifdef ENOMEM
 if (sym == @symbol(ENOMEM)) {
-RETURN ( __mkSmallInteger(ENOMEM) );
+	RETURN ( __mkSmallInteger(ENOMEM) );
 }
 #endif
 #ifdef EACCES
 if (sym == @symbol(EACCES)) {
-RETURN ( __mkSmallInteger(EACCES) );
+	RETURN ( __mkSmallInteger(EACCES) );
 }
 #endif
 #ifdef EFAULT
 if (sym == @symbol(EFAULT)) {
-RETURN ( __mkSmallInteger(EFAULT) );
+	RETURN ( __mkSmallInteger(EFAULT) );
 }
 #endif
 #ifdef EBUSY
 if (sym == @symbol(EBUSY)) {
-RETURN ( __mkSmallInteger(EBUSY) );
+	RETURN ( __mkSmallInteger(EBUSY) );
 }
 #endif
 #ifdef EXDEV
 if (sym == @symbol(EXDEV)) {
-RETURN ( __mkSmallInteger(EXDEV) );
+	RETURN ( __mkSmallInteger(EXDEV) );
 }
 #endif
 #ifdef ENODEV
 if (sym == @symbol(ENODEV)) {
-RETURN ( __mkSmallInteger(ENODEV) );
+	RETURN ( __mkSmallInteger(ENODEV) );
 }
 #endif
 #ifdef ENOTDIR
 if (sym == @symbol(ENOTDIR)) {
-RETURN ( __mkSmallInteger(ENOTDIR) );
+	RETURN ( __mkSmallInteger(ENOTDIR) );
 }
 #endif
 #ifdef EISDIR
 if (sym == @symbol(EISDIR)) {
-RETURN ( __mkSmallInteger(EISDIR) );
+	RETURN ( __mkSmallInteger(EISDIR) );
 }
 #endif
 #ifdef EINVAL
 if (sym == @symbol(EINVAL)) {
-RETURN ( __mkSmallInteger(EINVAL) );
+	RETURN ( __mkSmallInteger(EINVAL) );
 }
 #endif
 #ifdef ENFILE
 if (sym == @symbol(ENFILE)) {
-RETURN ( __mkSmallInteger(ENFILE) );
+	RETURN ( __mkSmallInteger(ENFILE) );
 }
 #endif
 #ifdef EMFILE
 if (sym == @symbol(EMFILE)) {
-RETURN ( __mkSmallInteger(EMFILE) );
+	RETURN ( __mkSmallInteger(EMFILE) );
 }
 #endif
 #ifdef ENOTTY
 if (sym == @symbol(ENOTTY)) {
-RETURN ( __mkSmallInteger(ENOTTY) );
+	RETURN ( __mkSmallInteger(ENOTTY) );
 }
 #endif
 #ifdef EFBIG
 if (sym == @symbol(EFBIG)) {
-RETURN ( __mkSmallInteger(EFBIG) );
+	RETURN ( __mkSmallInteger(EFBIG) );
 }
 #endif
 #ifdef ENOSPC
 if (sym == @symbol(ENOSPC)) {
-RETURN ( __mkSmallInteger(ENOSPC) );
+	RETURN ( __mkSmallInteger(ENOSPC) );
 }
 #endif
 #ifdef ESPIPE
 if (sym == @symbol(ESPIPE)) {
-RETURN ( __mkSmallInteger(ESPIPE) );
+	RETURN ( __mkSmallInteger(ESPIPE) );
 }
 #endif
 #ifdef EROFS
 if (sym == @symbol(EROFS)) {
-RETURN ( __mkSmallInteger(EROFS) );
+	RETURN ( __mkSmallInteger(EROFS) );
 }
 #endif
 #ifdef EMLINK
 if (sym == @symbol(EMLINK)) {
-RETURN ( __mkSmallInteger(EMLINK) );
+	RETURN ( __mkSmallInteger(EMLINK) );
 }
 #endif
 #ifdef EPIPE
 if (sym == @symbol(EPIPE)) {
-RETURN ( __mkSmallInteger(EPIPE) );
+	RETURN ( __mkSmallInteger(EPIPE) );
 }
 #endif
 #ifdef EDOM
 if (sym == @symbol(EDOM)) {
-RETURN ( __mkSmallInteger(EDOM) );
+	RETURN ( __mkSmallInteger(EDOM) );
 }
 #endif
 #ifdef ERANGE
 if (sym == @symbol(ERANGE)) {
-RETURN ( __mkSmallInteger(ERANGE) );
+	RETURN ( __mkSmallInteger(ERANGE) );
 }
 #endif
 #ifdef EDEADLK
 if (sym == @symbol(EDEADLK)) {
-RETURN ( __mkSmallInteger(EDEADLK) );
+	RETURN ( __mkSmallInteger(EDEADLK) );
 }
 #endif
 #ifdef ENAMETOOLONG
 if (sym == @symbol(ENAMETOOLONG)) {
-RETURN ( __mkSmallInteger(ENAMETOOLONG) );
+	RETURN ( __mkSmallInteger(ENAMETOOLONG) );
 }
 #endif
 #ifdef ENOLCK
 if (sym == @symbol(ENOLCK)) {
-RETURN ( __mkSmallInteger(ENOLCK) );
+	RETURN ( __mkSmallInteger(ENOLCK) );
 }
 #endif
 #ifdef ENOSYS
 if (sym == @symbol(ENOSYS)) {
-RETURN ( __mkSmallInteger(ENOSYS) );
+	RETURN ( __mkSmallInteger(ENOSYS) );
 }
 #endif
 #ifdef ENOTEMPTY
 if (sym == @symbol(ENOTEMPTY)) {
-RETURN ( __mkSmallInteger(ENOTEMPTY) );
+	RETURN ( __mkSmallInteger(ENOTEMPTY) );
 }
 #endif
 #ifdef EEXIST
 if (sym == @symbol(EEXIST)) {
-RETURN ( __mkSmallInteger(EEXIST) );
+	RETURN ( __mkSmallInteger(EEXIST) );
 }
 #endif
 #ifdef EILSEQ
 if (sym == @symbol(EILSEQ)) {
-RETURN ( __mkSmallInteger(EILSEQ) );
+	RETURN ( __mkSmallInteger(EILSEQ) );
 }
 #endif
 /*
 * XPG3 errnos - defined on most systems
 */
 #ifdef ENOTBLK
 if (sym == @symbol(ENOTBLK)) {
-RETURN ( __mkSmallInteger(ENOTBLK) );
+	RETURN ( __mkSmallInteger(ENOTBLK) );
 }
 #endif
 #ifdef ETXTBSY
 if (sym == @symbol(ETXTBSY)) {
-RETURN ( __mkSmallInteger(ETXTBSY) );
+	RETURN ( __mkSmallInteger(ETXTBSY) );
 }
 #endif
 /*
 * some others
 */
 #ifdef EWOULDBLOCK
 if (sym == @symbol(EWOULDBLOCK)) {
-RETURN ( __mkSmallInteger(EWOULDBLOCK) );
+	RETURN ( __mkSmallInteger(EWOULDBLOCK) );
 }
 #endif
 #ifdef EOVERFLOW
 if (sym == @symbol(EOVERFLOW)) {
-RETURN ( __mkSmallInteger(EOVERFLOW) );
+	RETURN ( __mkSmallInteger(EOVERFLOW) );
 }
 #endif
 #ifdef ENOMSG
 if (sym == @symbol(ENOMSG)) {
-RETURN ( __mkSmallInteger(ENOMSG) );
+	RETURN ( __mkSmallInteger(ENOMSG) );
 }
 #endif
 #ifdef ELOOP
 if (sym == @symbol(ELOOP)) {
-RETURN ( __mkSmallInteger(ELOOP) );
+	RETURN ( __mkSmallInteger(ELOOP) );
 }
 #endif
 /*
 * some stream errors
 */
 #ifdef ETIME
 if (sym == @symbol(ETIME)) {
-RETURN ( __mkSmallInteger(ETIME) );
+	RETURN ( __mkSmallInteger(ETIME) );
 }
 #endif
 #ifdef ENOSR
 if (sym == @symbol(ENOSR)) {
-RETURN ( __mkSmallInteger(ENOSR) );
+	RETURN ( __mkSmallInteger(ENOSR) );
 }
 #endif
 #ifdef ENOSTR
 if (sym == @symbol(ENOSTR)) {
-RETURN ( __mkSmallInteger(ENOSTR) );
+	RETURN ( __mkSmallInteger(ENOSTR) );
 }
 #endif
 #ifdef ECOMM
 if (sym == @symbol(ECOMM)) {
-RETURN ( __mkSmallInteger(ECOMM) );
+	RETURN ( __mkSmallInteger(ECOMM) );
 }
 #endif
 #ifdef EPROTO
 if (sym == @symbol(EPROTO)) {
-RETURN ( __mkSmallInteger(EPROTO) );
+	RETURN ( __mkSmallInteger(EPROTO) );
 }
 #endif
 /*
 * nfs errors
 */
 #ifdef ESTALE
 if (sym == @symbol(ESTALE)) {
-RETURN ( __mkSmallInteger(ESTALE) );
+	RETURN ( __mkSmallInteger(ESTALE) );
 }
 #endif
 #ifdef EREMOTE
 if (sym == @symbol(EREMOTE)) {
-RETURN ( __mkSmallInteger(EREMOTE) );
+	RETURN ( __mkSmallInteger(EREMOTE) );
 }
 #endif
 /*
 * some networking errors
 */
 #ifdef EINPROGRESS
 if (sym == @symbol(EINPROGRESS)) {
-RETURN ( __mkSmallInteger(EINPROGRESS) );
+	RETURN ( __mkSmallInteger(EINPROGRESS) );
 }
 #endif
 #ifdef EALREADY
 if (sym == @symbol(EALREADY)) {
-RETURN ( __mkSmallInteger(EALREADY) );
+	RETURN ( __mkSmallInteger(EALREADY) );
 }
 #endif
 #ifdef ENOTSOCK
 if (sym == @symbol(ENOTSOCK)) {
-RETURN ( __mkSmallInteger(ENOTSOCK) );
+	RETURN ( __mkSmallInteger(ENOTSOCK) );
 }
 #endif
 #ifdef EDESTADDRREQ
 if (sym == @symbol(EDESTADDRREQ)) {
-RETURN ( __mkSmallInteger(EDESTADDRREQ) );
+	RETURN ( __mkSmallInteger(EDESTADDRREQ) );
 }
 #endif
 #ifdef EMSGSIZE
 if (sym == @symbol(EMSGSIZE)) {
-RETURN ( __mkSmallInteger(EMSGSIZE) );
+	RETURN ( __mkSmallInteger(EMSGSIZE) );
 }
 #endif
 #ifdef EPROTOTYPE
 if (sym == @symbol(EPROTOTYPE)) {
-RETURN ( __mkSmallInteger(EPROTOTYPE) );
+	RETURN ( __mkSmallInteger(EPROTOTYPE) );
 }
 #endif
 #ifdef ENOPROTOOPT
 if (sym == @symbol(ENOPROTOOPT)) {
-RETURN ( __mkSmallInteger(ENOPROTOOPT) );
+	RETURN ( __mkSmallInteger(ENOPROTOOPT) );
 }
 #endif
 #ifdef EPROTONOSUPPORT
 if (sym == @symbol(EPROTONOSUPPORT)) {
-RETURN ( __mkSmallInteger(EPROTONOSUPPORT) );
+	RETURN ( __mkSmallInteger(EPROTONOSUPPORT) );
 }
 #endif
 #ifdef ESOCKTNOSUPPORT
 if (sym == @symbol(ESOCKTNOSUPPORT)) {
-RETURN ( __mkSmallInteger(ESOCKTNOSUPPORT) );
+	RETURN ( __mkSmallInteger(ESOCKTNOSUPPORT) );
 }
 #endif
 #ifdef EOPNOTSUPP
 if (sym == @symbol(EOPNOTSUPP)) {
-RETURN ( __mkSmallInteger(EOPNOTSUPP) );
+	RETURN ( __mkSmallInteger(EOPNOTSUPP) );
 }
 #endif
 #ifdef EPFNOSUPPORT
 if (sym == @symbol(EPFNOSUPPORT)) {
-RETURN ( __mkSmallInteger(EPFNOSUPPORT) );
+	RETURN ( __mkSmallInteger(EPFNOSUPPORT) );
 }
 #endif
 #ifdef EAFNOSUPPORT
 if (sym == @symbol(EAFNOSUPPORT)) {
-RETURN ( __mkSmallInteger(EAFNOSUPPORT) );
+	RETURN ( __mkSmallInteger(EAFNOSUPPORT) );
 }
 #endif
 #ifdef EADDRINUSE
 if (sym == @symbol(EADDRINUSE)) {
-RETURN ( __mkSmallInteger(EADDRINUSE) );
+	RETURN ( __mkSmallInteger(EADDRINUSE) );
 }
 #endif
 #ifdef EADDRNOTAVAIL
 if (sym == @symbol(EADDRNOTAVAIL)) {
-RETURN ( __mkSmallInteger(EADDRNOTAVAIL) );
+	RETURN ( __mkSmallInteger(EADDRNOTAVAIL) );
 }
 #endif
 #ifdef ETIMEDOUT
 if (sym == @symbol(ETIMEDOUT)) {
-RETURN ( __mkSmallInteger(ETIMEDOUT) );
+	RETURN ( __mkSmallInteger(ETIMEDOUT) );
 }
 #endif
 #ifdef ECONNREFUSED
 if (sym == @symbol(ECONNREFUSED)) {
-RETURN ( __mkSmallInteger(ECONNREFUSED) );
+	RETURN ( __mkSmallInteger(ECONNREFUSED) );
 }
 #endif
 #ifdef ENETDOWN
 if (sym == @symbol(ENETDOWN)) {
-RETURN ( __mkSmallInteger(ENETDOWN) );
+	RETURN ( __mkSmallInteger(ENETDOWN) );
 }
 #endif
 #ifdef ENETUNREACH
 if (sym == @symbol(ENETUNREACH)) {
-RETURN ( __mkSmallInteger(ENETUNREACH) );
+	RETURN ( __mkSmallInteger(ENETUNREACH) );
 }
 #endif
 #ifdef ENETRESET
 if (sym == @symbol(ENETRESET)) {
-RETURN ( __mkSmallInteger(ENETRESET) );
+	RETURN ( __mkSmallInteger(ENETRESET) );
 }
 #endif
 #ifdef ECONNABORTED
 if (sym == @symbol(ECONNABORTED)) {
-RETURN ( __mkSmallInteger(ECONNABORTED) );
+	RETURN ( __mkSmallInteger(ECONNABORTED) );
 }
 #endif
 #ifdef ECONNRESET
 if (sym == @symbol(ECONNRESET)) {
-RETURN ( __mkSmallInteger(ECONNRESET) );
+	RETURN ( __mkSmallInteger(ECONNRESET) );
 }
 #endif
 #ifdef EISCONN
 if (sym == @symbol(EISCONN)) {
-RETURN ( __mkSmallInteger(EISCONN) );
+	RETURN ( __mkSmallInteger(EISCONN) );
 }
 #endif
 #ifdef ENOTCONN
 if (sym == @symbol(ENOTCONN)) {
-RETURN ( __mkSmallInteger(ENOTCONN) );
+	RETURN ( __mkSmallInteger(ENOTCONN) );
 }
 #endif
 #ifdef ESHUTDOWN
 if (sym == @symbol(ESHUTDOWN)) {
-RETURN ( __mkSmallInteger(ESHUTDOWN) );
+	RETURN ( __mkSmallInteger(ESHUTDOWN) );
 }
 #endif
 #ifdef EHOSTDOWN
 if (sym == @symbol(EHOSTDOWN)) {
-RETURN ( __mkSmallInteger(EHOSTDOWN) );
+	RETURN ( __mkSmallInteger(EHOSTDOWN) );
 }
 #endif
 #ifdef EHOSTUNREACH
 if (sym == @symbol(EHOSTUNREACH)) {
-RETURN ( __mkSmallInteger(EHOSTUNREACH) );
+	RETURN ( __mkSmallInteger(EHOSTUNREACH) );
 }
 #endif
 #ifdef EREMOTEIO
 if (sym == @symbol(EREMOTEIO)) {
-RETURN ( __mkSmallInteger(EREMOTEIO) );
+	RETURN ( __mkSmallInteger(EREMOTEIO) );
 }
 #endif
 #ifdef EDQUOT
 if (sym == @symbol(EDQUOT)) {
-RETURN ( __mkSmallInteger(EDQUOT) );
+	RETURN ( __mkSmallInteger(EDQUOT) );
 }
 #endif
 #ifdef ENOMEDIUM
 if (sym == @symbol(ENOMEDIUM)) {
-RETURN ( __mkSmallInteger(ENOMEDIUM) );
+	RETURN ( __mkSmallInteger(ENOMEDIUM) );
 }
 #endif
 #ifdef EMEDIUMTYPE
 if (sym == @symbol(EMEDIUMTYPE)) {
-RETURN ( __mkSmallInteger(EMEDIUMTYPE) );
+	RETURN ( __mkSmallInteger(EMEDIUMTYPE) );
 }
 #endif
 %}.
 ^ -1
 fileDescriptors:fdColl fork:doFork newPgrp:newPgrp inDirectory:aDirectory
 "Internal lowLevel entry for combined fork & exec;
 If fork is false (chain a command):
-execute the OS command specified by the argument, aCommandPath, with
+	 execute the OS command specified by the argument, aCommandPath, with
-arguments in argArray (no arguments, if nil).
+	 arguments in argArray (no arguments, if nil).
-If successful, this method does not return and smalltalk is gone.
+	 If successful, this method does not return and smalltalk is gone.
-If not successful, it does return.
+	 If not successful, it does return.
-Normal use is with forkForCommand.
+	 Normal use is with forkForCommand.
 If fork is true (subprocess command execution):
-fork a child to do the above.
+	fork a child to do the above.
-The process id of the child process is returned; nil if the fork failed.
+	The process id of the child process is returned; nil if the fork failed.
 fdColl contains the filedescriptors, to be used for the child (if fork is true).
-fdArray[1] = 15 -> use fd 15 as stdin.
+	fdArray[1] = 15 -> use fd 15 as stdin.
-If an element of the array is set to nil, the corresponding filedescriptor
+	If an element of the array is set to nil, the corresponding filedescriptor
-will be closed for the child.
+	will be closed for the child.
-fdArray[1] == StdIn for child
+	fdArray[1] == StdIn for child
-fdArray[2] == StdOut for child
+	fdArray[2] == StdOut for child
-fdArray[3] == StdErr for child
+	fdArray[3] == StdErr for child
-on VMS, these must be channels as returned by createMailBox.
+	on VMS, these must be channels as returned by createMailBox.
-All filedescriptors not present in fdColl will be closed for the child.
+	All filedescriptors not present in fdColl will be closed for the child.
 If newPgrp is true, the subprocess will be established in a new process group.
-The processgroup will be equal to id.
+	The processgroup will be equal to id.
-newPgrp is not used on WIN32 and VMS systems.
+	newPgrp is not used on WIN32 and VMS systems.
 environmentDictionary specifies environment variables which are passed differently from
 the current environment. If non-nil, it must be a dictionary providing
 key-value pairs for changed/added environment variables.
 To pass a variable as empty (i.e. unset), pass a nil value.
 Notice: this used to be two separate ST-methods; however, in order to use
-vfork on some machines, it had to be merged into one, to avoid write
+	    vfork on some machines, it had to be merged into one, to avoid write
-accesses to ST/X memory from the vforked-child.
+	    accesses to ST/X memory from the vforked-child.
-The code below only does read accesses."
+	    The code below only does read accesses."
 |envArray argArray fdArray dirName cnt aCommandPath|
 environmentDictionary notEmptyOrNil ifTrue:[
-envArray := Array new:environmentDictionary size.
+	envArray := Array new:environmentDictionary size.
-cnt := 1.
+	cnt := 1.
-environmentDictionary keysAndValuesDo:[:key :val |
+	environmentDictionary keysAndValuesDo:[:key :val |
-val isNil ifTrue:[
+	    val isNil ifTrue:[
-envArray at:cnt put:((self encodePath:key), '=')
+		envArray at:cnt put:((self encodePath:key), '=')
-] ifFalse:[
+	    ] ifFalse:[
-envArray at:cnt put:((self encodePath:key), '=', (self encodePath:val))
+		envArray at:cnt put:((self encodePath:key), '=', (self encodePath:val))
-].
+	    ].
-cnt := cnt + 1.
+	    cnt := cnt + 1.
-].
+	].
 ].
 argColl notNil ifTrue:[
-argArray := argColl asArray collect:[:eachArg| self encodePath:eachArg].
+	argArray := argColl asArray collect:[:eachArg| self encodePath:eachArg].
 ].
 fdColl notNil ifTrue:[
-fdArray := fdColl asArray
+	fdArray := fdColl asArray
 ].
 aDirectory notNil ifTrue:[
-dirName := aDirectory asFilename osNameForFile.
+	dirName := aDirectory asFilename osNameForFile.
-dirName := self encodePath:dirName.
+	dirName := self encodePath:dirName.
 ].
 aCommandPath := self encodePath:aCommandPathArg.
 %{  /* STACK: 16000 */
 char **argv;
 extern char **environ;
 #endif
 char **_env, **_nEnv;
 if (__isStringLike(aCommandPath) &&
-((argArray == nil) || __isArrayLike(argArray)) &&
+	((argArray == nil) || __isArrayLike(argArray)) &&
-((fdArray == nil) || __isArrayLike(fdArray))
+	((fdArray == nil) || __isArrayLike(fdArray))
 ) {
-nargs = argArray == nil ? 0 : __arraySize(argArray);
+	nargs = argArray == nil ? 0 : __arraySize(argArray);
-argv = (char **) malloc(sizeof(char *) * (nargs + 1));
+	argv = (char **) malloc(sizeof(char *) * (nargs + 1));
-if (argv) {
+	if (argv) {
-int nOldEnv, nNewEnv;
+	    int nOldEnv, nNewEnv;
-for (i=0; i < nargs; i++) {
+	    for (i=0; i < nargs; i++) {
-arg = __ArrayInstPtr(argArray)->a_element[i];
+		arg = __ArrayInstPtr(argArray)->a_element[i];
-if (__isStringLike(arg)) {
+		if (__isStringLike(arg)) {
-argv[i] = (char *) __stringVal(arg);
+		    argv[i] = (char *) __stringVal(arg);
-} else {
+		} else {
-argv[i] = "";
+		    argv[i] = "";
-}
+		}
-}
+	    }
-argv[i] = NULL;
+	    argv[i] = NULL;
-/*
+	    /*
-* number of new items in environment ..
+	     * number of new items in environment ..
-*/
+	     */
-nNewEnv = 0;
+	    nNewEnv = 0;
-if ((envArray != nil) && __isArrayLike(envArray)) {
+	    if ((envArray != nil) && __isArrayLike(envArray)) {
-nNewEnv = __arraySize(envArray);
+		nNewEnv = __arraySize(envArray);
-}
+	    }
-if (nNewEnv == 0) {
+	    if (nNewEnv == 0) {
-_nEnv = environ;
+		_nEnv = environ;
-} else {
+	    } else {
-_env = environ;
+		_env = environ;
-/*
+		/*
-* get size of environment
+		 * get size of environment
-*/
+		 */
-nOldEnv = 0;
+		nOldEnv = 0;
-if (_env) {
+		if (_env) {
-while (*_env) {
+		    while (*_env) {
-nOldEnv++;
+			nOldEnv++;
-_env++;
+			_env++;
-}
+		    }
-}
+		}
-/*
+		/*
-* generate a new environment
+		 * generate a new environment
-* I have not found a spec which defines if
+		 * I have not found a spec which defines if
-* items at the end overwrite previous definitions,
+		 * items at the end overwrite previous definitions,
-* or if the first encountered definition is valid.
+		 * or if the first encountered definition is valid.
-* To be prepared for any case, simply add the new definitions
+		 * To be prepared for any case, simply add the new definitions
-* at both ends - that should do it in any case.
+		 * at both ends - that should do it in any case.
-* Someone with more know-how may want to fix this.
+		 * Someone with more know-how may want to fix this.
-* getenv() searches for the first entry.
+		 * getenv() searches for the first entry.
-* But maybe someone creates a Dictionary from the environment.
+		 * But maybe someone creates a Dictionary from the environment.
-* In this case the last entry would overwrite previous entries.
+		 * In this case the last entry would overwrite previous entries.
-*/
+		 */
-_nEnv = (char **)malloc(sizeof(char *) * (nNewEnv + nOldEnv + nNewEnv + 1));
+		_nEnv = (char **)malloc(sizeof(char *) * (nNewEnv + nOldEnv + nNewEnv + 1));
-if (_nEnv) {
+		if (_nEnv) {
-char **eO, **eN;
+		    char **eO, **eN;
-eN = _nEnv;
+		    eN = _nEnv;
-if (nNewEnv) {
+		    if (nNewEnv) {
-/*
+			/*
-* add new items at the front ...
+			 * add new items at the front ...
-*/
+			 */
-int i;
+			int i;
-OBJ *t;
+			OBJ *t;
-for (i=0, t = __arrayVal(envArray);
+			for (i=0, t = __arrayVal(envArray);
-i < __arraySize(envArray);
+			     i < __arraySize(envArray);
-i++, t++) {
+			     i++, t++) {
-if (__isStringLike(*t)) {
+			    if (__isStringLike(*t)) {
-*eN++ = (char *)__stringVal(*t);
+				*eN++ = (char *)__stringVal(*t);
-}
+			    }
-}
+			}
-}
+		    }
-if (nOldEnv) {
+		    if (nOldEnv) {
-/*
+			/*
-* append old environment
+			 * append old environment
-*/
+			 */
-for (eO = environ; *eO; *eN++ = *eO++)
+			for (eO = environ; *eO; *eN++ = *eO++)
-continue;
+			    continue;
-}
+		    }
-if (nNewEnv) {
+		    if (nNewEnv) {
-/*
+			/*
-* append new items again at the end
+			 * append new items again at the end
-*/
+			 */
-for (eO = _nEnv, i=0; i<nNewEnv; i++) {
+			for (eO = _nEnv, i=0; i<nNewEnv; i++) {
-*eN++ = *eO++;
+			    *eN++ = *eO++;
-}
+			}
-}
+		    }
-*eN = NULL;
+		    *eN = NULL;
-}
+		}
-}
+	    }
-if (doFork == true) {
+	    if (doFork == true) {
-/*
+		/*
-* fork a subprocess.
+		 * fork a subprocess.
-*/
+		 */
-int nfd;
+		int nfd;
-nfd = fdArray == nil ? 0 : __arraySize(fdArray);
+		nfd = fdArray == nil ? 0 : __arraySize(fdArray);
-id = FORK ();
+		id = FORK ();
-if (id == 0) {
+		if (id == 0) {
-/*
+		    /*
-** In child.
+		    ** In child.
-** first: dup filedescriptors.
+		    ** first: dup filedescriptors.
-*/
+		    */
-for (i = 0; i < nfd; i++) {
+		    for (i = 0; i < nfd; i++) {
-OBJ fd;
+			OBJ fd;
-int rslt;
+			int rslt;
-fd = __arrayVal(fdArray)[i];
+			fd = __arrayVal(fdArray)[i];
-if (__isSmallInteger(fd) && (__intVal(fd) != i)) {
+			if (__isSmallInteger(fd) && (__intVal(fd) != i)) {
-do {
+			    do {
-rslt = dup2(__intVal(fd), i);
+				rslt = dup2(__intVal(fd), i);
-} while ((rslt < 0) && (errno == EINTR));
+			    } while ((rslt < 0) && (errno == EINTR));
-}
+			}
-}
+		    }
-/*
+		    /*
-** Second: close descriptors
+		    ** Second: close descriptors
-**         marked as unwanted
+		    **         marked as unwanted
-** (extra loop to allow duping of low filedescriptor numbers to
+		    ** (extra loop to allow duping of low filedescriptor numbers to
-**  higher fd numbers)
+		    **  higher fd numbers)
-*/
+		    */
-for (i = 0; i < nfd; i++) {
+		    for (i = 0; i < nfd; i++) {
-if (__arrayVal(fdArray)[i] == nil) {
+			if (__arrayVal(fdArray)[i] == nil) {
-close(i);
+			    close(i);
-}
+			}
-}
+		    }
-/*
+		    /*
-** third: close all filedescriptors larger
+		    ** third: close all filedescriptors larger
-** then the explicitely closed or duped
+		    ** then the explicitely closed or duped
-** filedescriptors
+		    ** filedescriptors
-*/
+		    */
 #ifndef OPEN_MAX
 # define OPEN_MAX       256
 #endif
-for ( ;i < OPEN_MAX; i++) {
+		    for ( ;i < OPEN_MAX; i++) {
-close(i);
+			close(i);
-}
+		    }
-if (newPgrp == true) {
+		    if (newPgrp == true) {
 #ifndef NEXT
-setsid();
+			setsid();
 #endif
 #if defined(TIOCSCTTY)
-ioctl(0, TIOCSCTTY, 0) ;
+			ioctl(0, TIOCSCTTY, 0) ;
 #endif
 #if defined(TIOCSPGRP)
-{
+			{
-int pgrp = getpid();
+			    int pgrp = getpid();
-ioctl(0, TIOCSPGRP, (char *)&pgrp);
+			    ioctl(0, TIOCSPGRP, (char *)&pgrp);
-}
+			}
 #endif
 #if defined(_POSIX_JOB_CONTROL)
-(void) setpgid(0, 0);
+			(void) setpgid(0, 0);
 #else
 # if defined(BSD) || defined(LINUX)
-(void) setpgrp(0);
+			(void) setpgrp(0);
 # endif
 #endif
-}
+		    }
-if (dirName == nil || chdir((char *)__stringVal(dirName)) == 0) {
+		    if (dirName == nil || chdir((char *)__stringVal(dirName)) == 0) {
-execve((char *)__stringVal(aCommandPath), argv, _nEnv);
+			execve((char *)__stringVal(aCommandPath), argv, _nEnv);
-}
+		    }
-/* reached if chdir failed or aCommandPathh cannot be executed */
+		    /* reached if chdir failed or aCommandPathh cannot be executed */
-_exit(127);                 /* POSIX 2 compatible exit value */
+		    _exit(127);                 /* POSIX 2 compatible exit value */
-}
+		}
-} else {
+	    } else {
-/*
+		/*
-* no subprocess (i.e. transfer to another program)
+		 * no subprocess (i.e. transfer to another program)
-*/
+		 */
-if (dirName == nil || chdir((char *)__stringVal(dirName)) == 0) {
+		if (dirName == nil || chdir((char *)__stringVal(dirName)) == 0) {
-execve((char *)__stringVal(aCommandPath), argv, _nEnv);
+		    execve((char *)__stringVal(aCommandPath), argv, _nEnv);
-}
+		}
-/*
+		/*
-* reached if chdir failed or command-path cannot be executed
+		 * reached if chdir failed or command-path cannot be executed
-*/
+		 */
-id = -1;
+		id = -1;
-}
+	    }
-if (nNewEnv && (_nEnv != NULL)) {
+	    if (nNewEnv && (_nEnv != NULL)) {
-/*
+		/*
-* free new environment stuff
+		 * free new environment stuff
-*/
+		 */
-free(_nEnv);
+		free(_nEnv);
-}
+	    }
-free(argv);
+	    free(argv);
-/*
+	    /*
-* In parent: succes or failure
+	     * In parent: succes or failure
-*/
+	     */
-if (id == -1) {
+	    if (id == -1) {
-RETURN (nil);
+		RETURN (nil);
-} else {
+	    } else {
-RETURN (__mkSmallInteger(id));
+		RETURN (__mkSmallInteger(id));
-}
+	    }
-}
+	}
 }
 %}.
 "
 path-argument not string
 or argArray not an array/nil
 "
 |id|
 id := OperatingSystem fork.
 id == 0 ifTrue:[
-'I am the child'.
+	'I am the child'.
-OperatingSystem exec:'/bin/ls' withArguments:#('ls' '/tmp').
+	OperatingSystem exec:'/bin/ls' withArguments:#('ls' '/tmp').
-'not reached'.
+	'not reached'.
 ]
 "
 "
 |id|
 id := OperatingSystem fork.
 id == 0 ifTrue:[
-'I am the child'.
+	'I am the child'.
-OperatingSystem
+	OperatingSystem
-exec:'/bin/sh'
+	   exec:'/bin/sh'
-withArguments:#('sh' '-c' 'sleep 2;echo 1;sleep 2;echo 2').
+	   withArguments:#('sh' '-c' 'sleep 2;echo 1;sleep 2;echo 2').
-'not reached'.
+	'not reached'.
 ].
 id printNL.
 (Delay forSeconds:3.5) wait.
 'killing ...' printNL.
 OperatingSystem sendSignal:(OperatingSystem sigTERM) to:id.
 "
 |id|
 id := OperatingSystem fork.
 id == 0 ifTrue:[
-'I am the child process' printCR.
+	'I am the child process' printCR.
-OperatingSystem exit
+	OperatingSystem exit
 ]
 "
 !
 startProcess:aCommandString inputFrom:anExternalInStream outputTo:anExternalOutStream
 |nullStream in out err shellAndArgs rslt auxFd|
 aCommandString isNil ifTrue:[^ nil].
 (in := anExternalInStream) isNil ifTrue:[
-nullStream := Filename nullDevice readWriteStream.
+	nullStream := Filename nullDevice readWriteStream.
-in := nullStream.
+	in := nullStream.
 ].
 (out := anExternalOutStream) isNil ifTrue:[
-nullStream isNil ifTrue:[nullStream := Filename nullDevice writeStream].
+	nullStream isNil ifTrue:[nullStream := Filename nullDevice writeStream].
-out := nullStream.
+	out := nullStream.
 ].
 (err := anExternalErrStream) isNil ifTrue:[
-err := out
+	err := out
 ].
 anAuxiliaryStream notNil ifTrue:[
-auxFd := anAuxiliaryStream fileDescriptor
+	auxFd := anAuxiliaryStream fileDescriptor
 ].
 shellAndArgs := self commandAndArgsForOSCommand:aCommandString.
 rslt := self
-exec:(shellAndArgs at:1)
+	exec:(shellAndArgs at:1)
-withArguments:(shellAndArgs at:2)
+	withArguments:(shellAndArgs at:2)
-environment:anEvironmentDictionary
+	environment:anEvironmentDictionary
-fileDescriptors:(Array with:in fileDescriptor
+	fileDescriptors:(Array with:in fileDescriptor
-with:out fileDescriptor
+			       with:out fileDescriptor
-with:err fileDescriptor
+			       with:err fileDescriptor
-with:auxFd)
+			       with:auxFd)
-fork:true
+	fork:true
-newPgrp:true "/ false
+	newPgrp:true "/ false
-inDirectory:dir.
+	inDirectory:dir.
 nullStream notNil ifTrue:[
-nullStream close.
+	nullStream close.
 ].
 ^ rslt
 "blocking at current prio (i.e. only higher prio threads execute):
 pid := OperatingSystem startProcess:'sleep 10; grep drw' inputFrom:in outputTo:out errorTo:err.
 The following will no longer work. monitorPid has disappeared
 pid notNil ifTrue:[
-Processor monitorPid:pid action:[:OSstatus | sema signal ].
+	 Processor monitorPid:pid action:[:OSstatus | sema signal ].
 ].
 in close.
 out close.
 err close.
 sema wait.
 - see the description of 'sh -c' in your UNIX manual ('cmd.com' in your MSDOS manual).
 If aCommandString is an Array, the first element is the command to be executed,
 and the other elements are the arguments to the command. No shell is invoked in this case."
 aCommandStringOrArray isNonByteCollection ifTrue:[
-"if an array is passed, the command string has already been parsed an no shell is invoked"
+	"if an array is passed, the command string has already been parsed an no shell is invoked"
-^ Array with:aCommandStringOrArray first with:aCommandStringOrArray.
+	^ Array with:aCommandStringOrArray first with:aCommandStringOrArray.
 ].
 "/
 "/ '/bin/sh -c <command>'
 "/
 "shortcut - use the /proc filesystem (if present).
 Here we get an absolute path to the running executable."
 info := '/proc/self/exe' asFilename linkInfo.
 info notNil ifTrue:[
-path := info path.
+	path := info path.
-path notEmptyOrNil ifTrue:[
+	path notEmptyOrNil ifTrue:[
-^ path
+	    ^ path
-].
+	].
 ].
 "Fall back - do it the hard way"
 ^ super nameOfSTXExecutable
 |path f fExt commandFilename|
 commandFilename := aCommand asFilename.
 commandFilename isAbsolute ifTrue:[
-^ commandFilename pathName
+	^ commandFilename pathName
 ].
 commandFilename isExplicitRelative ifTrue:[
-^ commandFilename pathName
+	 ^ commandFilename pathName
 ].
 path := self getEnvironment:'PATH'.
 path notEmptyOrNil ifTrue:[
-(path asCollectionOfSubstringsSeparatedBy:self pathSeparator) do:[:eachPathComponent |
+	(path asCollectionOfSubstringsSeparatedBy:self pathSeparator) do:[:eachPathComponent |
-eachPathComponent isEmpty ifTrue:[
+	    eachPathComponent isEmpty ifTrue:[
-f := commandFilename
+		f := commandFilename
-] ifFalse:[
+	    ] ifFalse:[
-f := eachPathComponent asFilename construct:aCommand.
+		f := eachPathComponent asFilename construct:aCommand.
-].
+	    ].
-self executableFileExtensions do:[:eachExtension |
+	    self executableFileExtensions do:[:eachExtension |
-eachExtension notEmpty ifTrue:[
+		eachExtension notEmpty ifTrue:[
-fExt := f addSuffix:eachExtension.
+		    fExt := f addSuffix:eachExtension.
-] ifFalse:[
+		] ifFalse:[
-fExt := f.
+		    fExt := f.
-].
+		].
-fExt isExecutable ifTrue:[
+		fExt isExecutable ifTrue:[
-^ fExt pathName
+		    ^ fExt pathName
-].
+		].
-].
+	    ].
-].
+	].
 ].
 ^ nil
 "unix:
 closeFd:anInteger
 "low level close of a filedescriptor"
 %{
 if (__isSmallInteger(anInteger)) {
-if (@global(ExternalStream:FileOpenTrace) == true) {
+	if (@global(ExternalStream:FileOpenTrace) == true) {
-fprintf(stderr, "close [UnixOp] fd=%d\n", (int)__intVal(anInteger));
+	    fprintf(stderr, "close [UnixOp] fd=%d\n", (int)__intVal(anInteger));
-}
+	}
-close(__intVal(anInteger));
+	close(__intVal(anInteger));
-RETURN(self);
+	RETURN(self);
 }
 %}.
 ^ self primitiveFailed.
 "
 #if defined(HAS_SENDFILE)
 if (__isSmallInteger(inFd)
 && __isSmallInteger(outFd)
 && __isSmallInteger(startIdx)
 && __isSmallInteger(count)) {
-int nWritten;
+	int nWritten;
-nWritten = sendfile(__intVal(outFd), __intVal(inFd), __intVal(startIdx), __intVal(count));
+	nWritten = sendfile(__intVal(outFd), __intVal(inFd), __intVal(startIdx), __intVal(count));
-if (nWritten < 0) {
+	if (nWritten < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
-}
+	}
-RETURN (__mkSmallInteger(nWritten));
+	RETURN (__mkSmallInteger(nWritten));
 }
 #endif
 %}.
 ^ 0 "/ not supported
 !
 encodedPathName := self encodePath:aPathName.
 %{
 if (__isStringLike(encodedPathName) && __isSmallInteger(umask)) {
-if (mkdir(__stringVal(encodedPathName), __smallIntegerVal(umask)) >= 0) {
+	if (mkdir(__stringVal(encodedPathName), __smallIntegerVal(umask)) >= 0) {
-RETURN(true);
+	    RETURN(true);
-}
+	}
-@global(LastErrorNumber) = __mkSmallInteger(errno);
+	@global(LastErrorNumber) = __mkSmallInteger(errno);
 }
 %}.
 "/ could not create - if it already existed this is ok
 (self isDirectory:aPathName) ifTrue:[^ true].
 %{
 int ret;
 if (__isStringLike(encodedOldPathName) && __isStringLike(encodedNewPathName)) {
-__BEGIN_INTERRUPTABLE__
+	__BEGIN_INTERRUPTABLE__
-do {
+	do {
-ret = link((char *) __stringVal(encodedOldPathName), (char *) __stringVal(encodedNewPathName));
+	    ret = link((char *) __stringVal(encodedOldPathName), (char *) __stringVal(encodedNewPathName));
-} while (ret < 0 && errno == EINTR);
+	} while (ret < 0 && errno == EINTR);
-__END_INTERRUPTABLE__
+	__END_INTERRUPTABLE__
-if (ret < 0) {
+	if (ret < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
-RETURN ( false );
+	    RETURN ( false );
-}
+	}
-RETURN (true);
+	RETURN (true);
 }
 %}.
 "/
 "/ bad argument(s) given
 "/
 %{
 #ifdef S_IFLNK
 int ret;
 if (__isStringLike(encodedOldPathName) && __isStringLike(encodedNewPathName)) {
-__BEGIN_INTERRUPTABLE__
+	__BEGIN_INTERRUPTABLE__
-do {
+	do {
-ret = symlink((char *) __stringVal(encodedOldPathName), (char *) __stringVal(encodedNewPathName));
+	    ret = symlink((char *) __stringVal(encodedOldPathName), (char *) __stringVal(encodedNewPathName));
-} while (ret < 0 && errno == EINTR);
+	} while (ret < 0 && errno == EINTR);
-__END_INTERRUPTABLE__
+	__END_INTERRUPTABLE__
-if (ret >= 0) {
+	if (ret >= 0) {
-RETURN (true);
+	    RETURN (true);
-}
+	}
-@global(LastErrorNumber) = error = __mkSmallInteger(errno);
+	@global(LastErrorNumber) = error = __mkSmallInteger(errno);
 }
 #endif
 %}.
 (encodedOldPathName isString not or:[encodedNewPathName isString not]) ifTrue:[
-"/
+	"/
-"/ bad argument(s) given
+	"/ bad argument(s) given
-"/
+	"/
-^ self primitiveFailed
+	^ self primitiveFailed
 ].
 error notNil ifTrue:[
-(self errorHolderForNumber:error) reportError
+	(self errorHolderForNumber:error) reportError
 ].
 "/
 "/ this Unix does not seem to support symbolic links
 "/
 open:path attributes:attributes mode:modeInteger
 "open a file, return an os specific fileHandle.
 openmode is a symbol defining the way to open
 valid modes are:
-#O_RDONLY
+	#O_RDONLY
-#O_RDWR
+	#O_RDWR
-#O_WRONLY
+	#O_WRONLY
-#O_CREAT
+	#O_CREAT
-#O_APPEND
+	#O_APPEND
-#O_SYNC
+	#O_SYNC
-#O_LARGEFILE
+	#O_LARGEFILE
 This is a private entry, but maybe useful to open/create a file in a special mode,
 which is proprietrary to the operatingSystem."
 |error fileDescriptor encodedPathName|
 int fd;
 int mode, openFlags = 0;
 int n;
 if (!__isStringLike(encodedPathName)) {
-error = @symbol(badArgument1);
+	error = @symbol(badArgument1);
-goto err;
+	goto err;
 }
 if (!__isArrayLike(attributes)) {
-error = @symbol(badArgument2);
+	error = @symbol(badArgument2);
-goto err;
+	goto err;
 }
 if (modeInteger == nil) {
-mode = 0644;
+	mode = 0644;
 } else if (__isSmallInteger(modeInteger)) {
-mode = __intVal(modeInteger);
+	mode = __intVal(modeInteger);
 } else {
-error = @symbol(badArgument3);
+	error = @symbol(badArgument3);
-goto err;
+	goto err;
 }
 nAttributes = __arraySize(attributes);
 for (n = 0, ap = __arrayVal(attributes); n < nAttributes; n++) {
-OBJ attribute = ap[n];
+	OBJ attribute = ap[n];
-if (attribute == @symbol(O_RDONLY)) {
+	if (attribute == @symbol(O_RDONLY)) {
-openFlags |= O_RDONLY;
+	    openFlags |= O_RDONLY;
-} else if (attribute == @symbol(O_RDWR)) {
+	} else if (attribute == @symbol(O_RDWR)) {
-openFlags |= O_RDWR;
+	    openFlags |= O_RDWR;
-} else if (attribute == @symbol(O_WRONLY)) {
+	} else if (attribute == @symbol(O_WRONLY)) {
-openFlags |= O_WRONLY;
+	    openFlags |= O_WRONLY;
-} else if (attribute == @symbol(O_CREAT)) {
+	} else if (attribute == @symbol(O_CREAT)) {
-openFlags |= O_CREAT;
+	    openFlags |= O_CREAT;
-} else if (attribute == @symbol(O_APPEND)) {
+	} else if (attribute == @symbol(O_APPEND)) {
-openFlags |= O_APPEND;
+	    openFlags |= O_APPEND;
-} else if (attribute == @symbol(O_EXCL)) {
+	} else if (attribute == @symbol(O_EXCL)) {
-openFlags |= O_EXCL;
+	    openFlags |= O_EXCL;
-} else if (attribute == @symbol(O_TRUNC)) {
+	} else if (attribute == @symbol(O_TRUNC)) {
-openFlags |= O_TRUNC;
+	    openFlags |= O_TRUNC;
-} else if (attribute == @symbol(O_LARGEFILE)) {
+	} else if (attribute == @symbol(O_LARGEFILE)) {
 #ifdef O_LARGEFILE
-openFlags |= O_LARGEFILE;
+	    openFlags |= O_LARGEFILE;
 #else
-error = @symbol(badArgument2);
+	    error = @symbol(badArgument2);
-goto err;
+	    goto err;
 #endif
-} else if (attribute == @symbol(O_SYNC)) {
+	} else if (attribute == @symbol(O_SYNC)) {
 #ifdef O_SYNC
-openFlags |= O_SYNC;
+	    openFlags |= O_SYNC;
 #else
-error = @symbol(badArgument2);
+	    error = @symbol(badArgument2);
-goto err;
+	    goto err;
 #endif
-}
+	}
 }
 #if defined(O_NONBLOCK)
 openFlags |= O_NONBLOCK;
 #elif defined(O_NDELAY)
 #endif
 again:
 fd = open((char *) __stringVal(encodedPathName), openFlags, mode);
 if (fd < 0) {
-if (errno == EINTR) {
+	if (errno == EINTR) {
-__HANDLE_INTERRUPTS__;
+	    __HANDLE_INTERRUPTS__;
-goto again;
+	    goto again;
-} else {
+	} else {
-error = __mkSmallInteger(errno);
+	    error = __mkSmallInteger(errno);
-goto err;
+	    goto err;
-}
+	}
 }
 fileDescriptor = __mkSmallInteger(fd);
 err:;
 %}.
 ^ fileDescriptor notNil ifTrue:[
-FileDescriptorHandle for:fileDescriptor.
+	FileDescriptorHandle for:fileDescriptor.
 ] ifFalse:[
-(self errorHolderForNumber:error) reportError
+	(self errorHolderForNumber:error) reportError
 ].
 "
-self open:'/etc/hosts' attributes:#(O_RDONLY) mode:nil
+	self open:'/etc/hosts' attributes:#(O_RDONLY) mode:nil
-self open:'/tmp/xxzz' attributes:#(O_RDWR O_CREAT) mode:8r611
+	self open:'/tmp/xxzz' attributes:#(O_RDWR O_CREAT) mode:8r611
-self open:'/etc/passwd' attributes:#(O_RDWR) mode:nil
+	self open:'/etc/passwd' attributes:#(O_RDWR) mode:nil
-self open:'/no one knows this file' attributes:#(O_RDONLY) mode:nil
+	self open:'/no one knows this file' attributes:#(O_RDONLY) mode:nil
-self open:'foo/bar/baz' attributes:#(O_RDWR O_CREAT) mode:nil
+	self open:'foo/bar/baz' attributes:#(O_RDWR O_CREAT) mode:nil
 "
 !
 openFileForAppend:pathName
 Return true if successful."
 ^ self executeCommand:(Array with:'/bin/cp' with:'-af' with:sourcePathName with:destination)
 "
-self recursiveCopyDirectory:'packages' to:'foo'.
+	self recursiveCopyDirectory:'packages' to:'foo'.
-self recursiveRemoveDirectory:'foo'.
+	self recursiveRemoveDirectory:'foo'.
 "
 "Modified: / 5.6.1998 / 18:33:57 / cg"
 !
 encodedPathName := self encodePath:fullPathName.
 %{
 int ret;
 if (__isStringLike(encodedPathName)) {
-__BEGIN_INTERRUPTABLE__
+	__BEGIN_INTERRUPTABLE__
-do {
+	do {
-ret = rmdir((char *) __stringVal(encodedPathName));
+	    ret = rmdir((char *) __stringVal(encodedPathName));
-} while (ret < 0 && errno == EINTR);
+	} while (ret < 0 && errno == EINTR);
-__END_INTERRUPTABLE__
+	__END_INTERRUPTABLE__
-if (ret < 0) {
+	if (ret < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
-RETURN ( false );
+	    RETURN ( false );
-}
+	}
-RETURN (true);
+	RETURN (true);
 }
 %}.
 "/
 "/ either not a string argument,
 "/ or not supported by OS
 encodedPathName := self encodePath:fullPathName.
 %{
 int ret;
 if (__isStringLike(encodedPathName)) {
-__BEGIN_INTERRUPTABLE__
+	__BEGIN_INTERRUPTABLE__
-do {
+	do {
-ret = unlink((char *) __stringVal(encodedPathName));
+	    ret = unlink((char *) __stringVal(encodedPathName));
-} while (ret < 0 && errno == EINTR);
+	} while (ret < 0 && errno == EINTR);
-__END_INTERRUPTABLE__
+	__END_INTERRUPTABLE__
-if (ret < 0) {
+	if (ret < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
-RETURN ( false );
+	    RETURN ( false );
-}
+	}
-RETURN (true);
+	RETURN (true);
 }
 %}.
 ^ self primitiveFailed
 !
 %{
 int ret, eno;
 if (__isStringLike(encodedOldPathName) && __isStringLike(encodedNewPathName)) {
 #if defined(HAS_RENAME)
-__BEGIN_INTERRUPTABLE__
+	__BEGIN_INTERRUPTABLE__
-do {
+	do {
-ret = rename((char *) __stringVal(encodedOldPathName), (char *) __stringVal(encodedNewPathName));
+	    ret = rename((char *) __stringVal(encodedOldPathName), (char *) __stringVal(encodedNewPathName));
-} while (ret < 0 && errno == EINTR);
+	} while (ret < 0 && errno == EINTR);
-__END_INTERRUPTABLE__
+	__END_INTERRUPTABLE__
 #else
-ret = link((char *) __stringVal(encodedOldPathName), (char *) __stringVal(encodedNewPathName));
+	ret = link((char *) __stringVal(encodedOldPathName), (char *) __stringVal(encodedNewPathName));
-if (ret >= 0) {
+	if (ret >= 0) {
-ret = unlink((char *) __stringVal(encodedOldPathName));
+	    ret = unlink((char *) __stringVal(encodedOldPathName));
-if (ret < 0) {
+	    if (ret < 0) {
-eno = errno;
+		eno = errno;
-unlink((char *) __stringVal(encodedNewPathName));
+		unlink((char *) __stringVal(encodedNewPathName));
-errno = eno;
+		errno = eno;
-}
+	    }
-}
+	}
 #endif
-if (ret < 0) {
+	if (ret < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
-RETURN ( false );
+	    RETURN ( false );
-}
+	}
-RETURN (true);
+	RETURN (true);
 }
 %}.
 ^ self primitiveFailed
 "
 %{
 //cg must be nested ifdefs - macosx does not like it otherwise
 #if defined(LINUX)
 # if __GLIBC_PREREQ(2, 14)
 if (__isSmallInteger(handle)) {
-if (syncfs(__intVal(handle)) == 0) {
+	if (syncfs(__intVal(handle)) == 0) {
-RETURN(self);
+	    RETURN(self);
-}
+	}
 }
 # endif
 #endif
 %}.
 "fallback is to do a global sync"
 self sync.
 "
-'/etc/passwd' asFilename readStream syncFileSystem
+	'/etc/passwd' asFilename readStream syncFileSystem
 "
 !
 truncateFile:aPathName to:newSize
 "change a files size return true on success, false on failure.
 #if defined(HAS_TRUNCATE) || defined(HAS_FTRUNCATE)
 int ret;
 off_t truncateSize;
 if (!__isStringLike(encodedPathName))
-goto getOutOfHere;
+	goto getOutOfHere;
 if (__isSmallInteger(newSize)) {
-truncateSize = __intVal(newSize);
+	truncateSize = __intVal(newSize);
-if (truncateSize < 0) {
+	if (truncateSize < 0) {
-goto getOutOfHere;
+	    goto getOutOfHere;
-}
+	}
 } else {
-truncateSize = __signedLongIntVal(newSize);
+	truncateSize = __signedLongIntVal(newSize);
-if (truncateSize < 0) {
+	if (truncateSize < 0) {
-goto getOutOfHere;
+	    goto getOutOfHere;
-}
+	}
-if (truncateSize == 0) {
+	if (truncateSize == 0) {
-if (sizeof(truncateSize) == 8) {
+	    if (sizeof(truncateSize) == 8) {
-if (__signedLong64IntVal(newSize, &truncateSize) == 0 || truncateSize < 0) {
+		if (__signedLong64IntVal(newSize, &truncateSize) == 0 || truncateSize < 0) {
-goto getOutOfHere;
+		    goto getOutOfHere;
-}
+		}
-} else {
+	    } else {
-goto getOutOfHere;
+		goto getOutOfHere;
-}
+	    }
-}
+	}
 }
 #if defined(HAS_TRUNCATE)
-__BEGIN_INTERRUPTABLE__
+	__BEGIN_INTERRUPTABLE__
-do {
+	do {
-ret = truncate((char *) __stringVal(encodedPathName), truncateSize);
+	    ret = truncate((char *) __stringVal(encodedPathName), truncateSize);
-} while (ret < 0 && errno == EINTR);
+	} while (ret < 0 && errno == EINTR);
-__END_INTERRUPTABLE__
+	__END_INTERRUPTABLE__
 #else
 # ifdef HAS_FTRUNCATE
 {
-int fd;
+	int fd;
-do {
+	do {
-fd = open((char *) __stringVal(encodedPathName), 2);
+	    fd = open((char *) __stringVal(encodedPathName), 2);
-} while (fd < 0 && errno == EINTR);
+	} while (fd < 0 && errno == EINTR);
-if (fd < 0) {
+	if (fd < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
-RETURN ( false );
+	    RETURN ( false );
-}
+	}
-ret = ftruncate(fd, truncateSize);
+	ret = ftruncate(fd, truncateSize);
-close(fd);
+	close(fd);
 }
 # endif /* HAS_FTRUNCATE */
 #endif
 if (ret < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(errno);
+	@global(LastErrorNumber) = __mkSmallInteger(errno);
-RETURN ( false );
+	RETURN ( false );
 }
 RETURN (true);
 getOutOfHere:;
 #endif
 %}.
 #    define S_ISGID 02000
 #    define S_ISVTX 01000
 #   endif
 if (aSymbol == @symbol(readUser)) {
-RETURN ( __mkSmallInteger(S_IRUSR) );
+	RETURN ( __mkSmallInteger(S_IRUSR) );
 }
 if (aSymbol == @symbol(writeUser)) {
-RETURN ( __mkSmallInteger(S_IWUSR) );
+	RETURN ( __mkSmallInteger(S_IWUSR) );
 }
 if (aSymbol == @symbol(executeUser)) {
-RETURN ( __mkSmallInteger(S_IXUSR) );
+	RETURN ( __mkSmallInteger(S_IXUSR) );
 }
 if (aSymbol == @symbol(readGroup)) {
-RETURN ( __mkSmallInteger(S_IRGRP) );
+	RETURN ( __mkSmallInteger(S_IRGRP) );
 }
 if (aSymbol == @symbol(writeGroup)) {
-RETURN ( __mkSmallInteger(S_IWGRP) );
+	RETURN ( __mkSmallInteger(S_IWGRP) );
 }
 if (aSymbol == @symbol(executeGroup)) {
-RETURN ( __mkSmallInteger(S_IXGRP) );
+	RETURN ( __mkSmallInteger(S_IXGRP) );
 }
 if (aSymbol == @symbol(readOthers)) {
-RETURN ( __mkSmallInteger(S_IROTH) );
+	RETURN ( __mkSmallInteger(S_IROTH) );
 }
 if (aSymbol == @symbol(writeOthers)) {
-RETURN ( __mkSmallInteger(S_IWOTH) );
+	RETURN ( __mkSmallInteger(S_IWOTH) );
 }
 if (aSymbol == @symbol(executeOthers)) {
-RETURN ( __mkSmallInteger(S_IXOTH) );
+	RETURN ( __mkSmallInteger(S_IXOTH) );
 }
 if (aSymbol == @symbol(setUid)) {
-RETURN ( __mkSmallInteger(S_ISUID) );
+	RETURN ( __mkSmallInteger(S_ISUID) );
 }
 if (aSymbol == @symbol(setGid)) {
-RETURN ( __mkSmallInteger(S_ISGID) );
+	RETURN ( __mkSmallInteger(S_ISGID) );
 }
 if (aSymbol == @symbol(removeOnlyByOwner)) {
-RETURN ( __mkSmallInteger(S_ISVTX) );
+	RETURN ( __mkSmallInteger(S_ISVTX) );
 }
 %}.
 ^ self primitiveFailed
 "
 Notice that the returned number is OS dependent - use the
 modeMasks as returned by OperatingSystem>>accessMaskFor:"
 "
 this could have been implemented as:
-(self infoOf:aPathName) at:#mode
+	(self infoOf:aPathName) at:#mode
 but for huge directory searches the code below is faster
 "
 |encodedPathName|
 struct stat buf;
 int ret;
 if (__isStringLike(encodedPathName)) {
 # ifdef TRACE_STAT_CALLS
-printf("stat on '%s' for accessMode\n", __stringVal(encodedPathName));
+	printf("stat on '%s' for accessMode\n", __stringVal(encodedPathName));
 # endif
-__BEGIN_INTERRUPTABLE__
+	__BEGIN_INTERRUPTABLE__
-do {
+	do {
-ret = stat((char *) __stringVal(encodedPathName), &buf);
+	    ret = stat((char *) __stringVal(encodedPathName), &buf);
-} while ((ret < 0) && (errno == EINTR));
+	} while ((ret < 0) && (errno == EINTR));
-__END_INTERRUPTABLE__
+	__END_INTERRUPTABLE__
-if (ret < 0) {
+	if (ret < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
-RETURN ( nil );
+	    RETURN ( nil );
-}
+	}
-RETURN ( __mkSmallInteger(buf.st_mode & 0777) );
+	RETURN ( __mkSmallInteger(buf.st_mode & 0777) );
 }
 %}.
 ^ self primitiveFailed
 "
 struct stat buf;
 int ret;
 if (__isSmallInteger(aFileDescriptor)) {
 # ifdef TRACE_STAT_CALLS
-printf("fstat on '%d' for accessMode\n", __smallIntegerVal(aFileDescriptor));
+	printf("fstat on '%d' for accessMode\n", __smallIntegerVal(aFileDescriptor));
 # endif
-__BEGIN_INTERRUPTABLE__
+	__BEGIN_INTERRUPTABLE__
-do {
+	do {
-ret = fstat(__smallIntegerVal(aFileDescriptor), &buf);
+	    ret = fstat(__smallIntegerVal(aFileDescriptor), &buf);
-} while ((ret < 0) && (errno == EINTR));
+	} while ((ret < 0) && (errno == EINTR));
-__END_INTERRUPTABLE__
+	__END_INTERRUPTABLE__
-if (ret < 0) {
+	if (ret < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
-RETURN ( nil );
+	    RETURN ( nil );
-}
+	}
-RETURN ( __mkSmallInteger(buf.st_mode & 0777) );
+	RETURN ( __mkSmallInteger(buf.st_mode & 0777) );
 }
 %}.
 ^ self primitiveFailed
 "
 '/' asFilename readingFileDo:[:s|
-(OperatingSystem accessModeOfFd:s fileDescriptor) printStringRadix:8
+	(OperatingSystem accessModeOfFd:s fileDescriptor) printStringRadix:8
 ].
 "
 !
 changeAccessModeOf:aPathName to:modeBits
 encodedPathName := self encodePath:aPathName.
 %{
 int ret;
 if (__isStringLike(encodedPathName) && __isSmallInteger(modeBits)) {
-__BEGIN_INTERRUPTABLE__
+	__BEGIN_INTERRUPTABLE__
-do {
+	do {
-ret = chmod((char *)__stringVal(encodedPathName), __intVal(modeBits));
+	    ret = chmod((char *)__stringVal(encodedPathName), __intVal(modeBits));
-} while (ret < 0 && errno == EINTR);
+	} while (ret < 0 && errno == EINTR);
-__END_INTERRUPTABLE__
+	__END_INTERRUPTABLE__
-if (ret < 0) {
+	if (ret < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
-RETURN ( false );
+	    RETURN ( false );
-}
+	}
-RETURN ( true );
+	RETURN ( true );
 }
 %}.
 ^ self primitiveFailed
 !
 %{
 int ret;
 if (__isSmallInteger(aFileDescriptor) && __isSmallInteger(modeBits)) {
-__BEGIN_INTERRUPTABLE__
+	__BEGIN_INTERRUPTABLE__
-do {
+	do {
-ret = fchmod(__smallIntegerVal(aFileDescriptor), __intVal(modeBits));
+	    ret = fchmod(__smallIntegerVal(aFileDescriptor), __intVal(modeBits));
-} while (ret < 0 && errno == EINTR);
+	} while (ret < 0 && errno == EINTR);
-__END_INTERRUPTABLE__
+	__END_INTERRUPTABLE__
-if (ret < 0) {
+	if (ret < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
-RETURN ( false );
+	    RETURN ( false );
-}
+	}
-RETURN ( true );
+	RETURN ( true );
 }
 %}.
 ^ self primitiveFailed
 ! !
 This can (again: on some systems) be avoided by passing a false blockIfLocked
 argument."
 %{
 if (__isSmallInteger(aFileDescriptor)) {
-int fd = __intVal(aFileDescriptor);
+	int fd = __intVal(aFileDescriptor);
-int lockArg;
+	int lockArg;
-/*
+	/*
-* claus: sigh - each one has a different interface ...
+	 * claus: sigh - each one has a different interface ...
-*/
+	 */
 #if defined(F_SETLK)
-{
+	{
-/*
+	    /*
-* new fcntl(SETLK) interface;
+	     * new fcntl(SETLK) interface;
-* available on SYSV4 and Linux
+	     * available on SYSV4 and Linux
-*/
+	     */
-struct flock flock;
+	    struct flock flock;
-if (isSharedReadLock == true) {
+	    if (isSharedReadLock == true) {
-flock.l_type = F_RDLCK;
+		flock.l_type = F_RDLCK;
-} else {
+	    } else {
-flock.l_type = F_WRLCK;
+		flock.l_type = F_WRLCK;
-}
+	    }
-flock.l_whence = 0;
+	    flock.l_whence = 0;
-flock.l_start = 0;
+	    flock.l_start = 0;
-flock.l_len = 0;
+	    flock.l_len = 0;
-lockArg = F_SETLK;
+	    lockArg = F_SETLK;
 # if defined(F_SETLKW)
-if (blockIfLocked == true) {
+	    if (blockIfLocked == true) {
-lockArg = F_SETLKW;
+		lockArg = F_SETLKW;
-}
+	    }
 # endif
-if (fcntl(fd, lockArg, &flock) != -1) {
+	    if (fcntl(fd, lockArg, &flock) != -1) {
-RETURN (true);
+		RETURN (true);
-}
+	    }
-}
+	}
 #else /* no F_SETLK available */
 # if defined(LOCK_EX) && defined(LOCK_UN)
-/*
+	/*
-* BSD 4.3 advisory locks
+	 * BSD 4.3 advisory locks
-*/
+	 */
-lockArg = LOCK_EX;
+	lockArg = LOCK_EX;
 #  if defined(LOCK_SH)
-if (isSharedReadLock == true) {
+	if (isSharedReadLock == true) {
-lockArg = LOCK_SH
+	    lockArg = LOCK_SH
-}
+	}
 #  endif
 #  if defined(LOCK_NB)
-if (blockIfLocked == false) {
+	if (blockIfLocked == false) {
-lockArg |= LOCK_NB;
+	    lockArg |= LOCK_NB;
-}
+	}
 #  endif
-if (flock(fd, lockArg) != -1) {
+	if (flock(fd, lockArg) != -1) {
-RETURN (true);
+	    RETURN (true);
-}
+	}
 # else /* no flock available */
 #  if defined(F_LOCK) && defined(F_UNLOCK)
-/*
+	/*
-* SYSV3 advisory locks
+	 * SYSV3 advisory locks
-*/
+	 */
-if (lockf(fd, F_LOCK, 0) != -1) {
+	if (lockf(fd, F_LOCK, 0) != -1) {
-RETURN (true);
+	    RETURN (true);
-}
+	}
 #  endif
 # endif
 #endif
 }
 %}.
 Notice, that not all OS's support file locks;
 on some, this may simply be a no-op."
 %{
 if (__isSmallInteger(aFileDescriptor)) {
-int fd = __intVal(aFileDescriptor);
+	int fd = __intVal(aFileDescriptor);
-/*
+	/*
-* claus: sigh - each one has a different interface ...
+	 * claus: sigh - each one has a different interface ...
-*/
+	 */
 #if defined(F_SETLK)
-{
+	{
-/*
+	    /*
-* new fcntl(SETLK) interface;
+	     * new fcntl(SETLK) interface;
-* available on SYSV4 and Linux
+	     * available on SYSV4 and Linux
-*/
+	     */
-struct flock flock;
+	    struct flock flock;
-flock.l_type = F_UNLCK;
+	    flock.l_type = F_UNLCK;
-flock.l_whence = 0;
+	    flock.l_whence = 0;
-flock.l_start = 0;
+	    flock.l_start = 0;
-flock.l_len = 0;
+	    flock.l_len = 0;
-if (fcntl(fd, F_SETLK, &flock) != -1) {
+	    if (fcntl(fd, F_SETLK, &flock) != -1) {
-RETURN (true);
+		RETURN (true);
-}
+	    }
-}
+	}
 #else /* no F_SETLK available */
 # if defined(LOCK_EX) && defined(LOCK_UN)
-/*
+	/*
-* BSD 4.3 advisory locks
+	 * BSD 4.3 advisory locks
-*/
+	 */
-if (flock(fd, LOCK_UN) != -1) {
+	if (flock(fd, LOCK_UN) != -1) {
-RETURN (true);
+	    RETURN (true);
-}
+	}
 # else /* no flock available */
 #  if defined(F_LOCK) && defined(F_UNLOCK)
-/*
+	/*
-* SYSV3 advisory locks
+	 * SYSV3 advisory locks
-*/
+	 */
-if (lockf(fd, F_UNLOCK, 0) != -1) {
+	if (lockf(fd, F_UNLOCK, 0) != -1) {
-RETURN (true);
+	    RETURN (true);
-}
+	}
 #  endif
 # endif
 #endif
 }
 %}.
 if realPath and popen failed."
 |names n "{ Class: SmallInteger }" |
 names := pathName
-asCollectionOfSubstringsSeparatedBy:self fileSeparator.
+		asCollectionOfSubstringsSeparatedBy:self fileSeparator.
 names := names asOrderedCollection.
 "
 cut off initial double-slashes
 "
 [names startsWith:#('' '')] whileTrue:[
-names removeFirst.
+	names removeFirst.
 ].
 "
 cut off double-slashes at end
 "
 [names endsWith:#('')] whileTrue:[
-names removeLast.
+	names removeLast.
 ].
 "
 cut off current-dir at beginning
 "
 n := names size.
 [(n >= 2) and:[names startsWith:#('.')]] whileTrue:[
-names removeFirst.
+	names removeFirst.
-n := n - 1.
+	n := n - 1.
 ].
 "
 cut off parent-dirs at end
 "
 [(n > 2)
 and:[(names endsWith:#('..'))
 and:[((names at:(n - 1)) startsWith:'.') not ]]] whileTrue:[
-names removeLast; removeLast.
+	names removeLast; removeLast.
-n := n - 2.
+	n := n - 2.
 ].
 ^ names asStringWith:self fileSeparator
-from:1
+		    from:1
-to:n
+		    to:n
-compressTabs:false final:nil
+		    compressTabs:false final:nil
 "
 OperatingSystem compressPath:'./..'
 OperatingSystem compressPath:'/foo/bar/baz/..'
 OperatingSystem compressPath:'foo/bar/baz/..'
 CurrentDirectory := path.
 ^ path.
 "
-self getCurrentDirectory
+	self getCurrentDirectory
 "
 !
 getDiskInfoOf:aDirectoryPath
 "return some disk info.
 The amountof information returned depends upon the OS, and is
 not guaranteed to be consistent across architectures.
 On unix, the information returned is (at least):
-freeBytes
+	freeBytes
-totalBytes
+	totalBytes
 "
 |outputText keys values n info
 fileSystemIdx sizeIdx usedIdx availIdx capacityIdx mountIdx|
 info := IdentityDictionary new.
 n := Integer readFrom:(values at:capacityIdx) onError:nil.
 n notNil ifTrue:[
-info at:#percentUsed put:n
+	info at:#percentUsed put:n
 ].
 n := Integer readFrom:(values at:availIdx) onError:nil.
 n notNil ifTrue:[
-info at:#freeBytes put:(n * 1024)
+	info at:#freeBytes put:(n * 1024)
 ].
 n := Integer readFrom:(values at:usedIdx) onError:nil.
 n notNil ifTrue:[
-info at:#usedBytes put:(n * 1024)
+	info at:#usedBytes put:(n * 1024)
 ].
 n := Integer readFrom:(values at:sizeIdx) onError:nil.
 n notNil ifTrue:[
-info at:#totalBytes put:(n * 1024)
+	info at:#totalBytes put:(n * 1024)
 ].
 info at:#mountPoint put:(values at:mountIdx).
 info at:#fileSystem put:(values at:fileSystemIdx).
 "/
 "/ default: return array filled with
 "/ root, home and current directories.
 "/
 ^ Array
-with:'/'
+	with:'/'
-with:(self getHomeDirectory)
+	with:(self getHomeDirectory)
-with:(Filename currentDirectory pathName)
+	with:(Filename currentDirectory pathName)
 "Modified: / 5.6.1998 / 18:35:35 / cg"
 !
 getMountedVolumes
 "return info about mounted volumes.
 The amount of information returned depends upon the OS, and is
 not guaranteed to be consistent across architectures.
 On unix, the information returned is (at least):
-mountPoint - mount point
+	mountPoint - mount point
-fileSystem - device or NFS-remotePath
+	fileSystem - device or NFS-remotePath
 "
 |outputText keys values info infoEntry|
 outputText := PipeStream outputFromCommand:('df -k').
 "/ on some rude Unix versions ...
 info := OrderedCollection new.
 outputText from:2 do:[:line |
-values := line asCollectionOfWords.
+	values := line asCollectionOfWords.
-values size >= 2 ifTrue:[
+	values size >= 2 ifTrue:[
-infoEntry := IdentityDictionary new.
+	    infoEntry := IdentityDictionary new.
-infoEntry at:#mountPoint put:(values last).
+	    infoEntry at:#mountPoint put:(values last).
-infoEntry at:#fileSystem put:(values first).
+	    infoEntry at:#fileSystem put:(values first).
-info add:infoEntry.
+	    info add:infoEntry.
-]
+	]
 ].
 ^ info
 "
 OperatingSystem getMountedVolumes
 infoOf:aPathName
 "return some object filled with info for the file 'aPathName';
 the info (for which corresponding access methods are understood by
 the returned object) is:
-type            - a symbol giving the files type
+	 type            - a symbol giving the files type
-mode            - numeric access mode
+	 mode            - numeric access mode
-uid             - owners user id
+	 uid             - owners user id
-gid             - owners group id
+	 gid             - owners group id
-size            - files size
+	 size            - files size
-id              - files number (i.e. inode number)
+	 id              - files number (i.e. inode number)
-accessed        - last access time (as Timestamp)
+	 accessed        - last access time (as Timestamp)
-modified        - last modification time (as Timestamp)
+	 modified        - last modification time (as Timestamp)
-statusChanged   - last status change time (as Timestamp)
+	 statusChanged   - last status change time (as Timestamp)
-alternativeName     - (windows only:) the MSDOS name of the file
+	 alternativeName     - (windows only:) the MSDOS name of the file
-recordFormatNumeric - (VMS only:) numeric value of the recordFormat
+	 recordFormatNumeric - (VMS only:) numeric value of the recordFormat
-recordFormat        - (VMS only:) symbolic value of the recordFormat
+	 recordFormat        - (VMS only:) symbolic value of the recordFormat
-recordAttributes    - (VMS only:) recordAttributes
+	 recordAttributes    - (VMS only:) recordAttributes
-fixedHeaderSize     - (VMS only:) fixed header size in a variable record format
+	 fixedHeaderSize     - (VMS only:) fixed header size in a variable record format
-recordSize          - (VMS only:) record size.
+	 recordSize          - (VMS only:) record size.
 Some of the fields may be returned as nil on systems which do not provide
 all of the information.
 Return nil if such a file does not exist.
 For symbolic links (if supported by the OS),
 %{
 struct stat buf;
 int ret;
 if (!__isStringLike(encodedPathName)) {
-error = @symbol(badArgument);
+	error = @symbol(badArgument);
-goto out;
+	goto out;
 }
 # ifdef TRACE_STAT_CALLS
 printf("stat on '%s' for info\n", __stringVal(aPathName));
 # endif
 __BEGIN_INTERRUPTABLE__
 do {
-ret = stat((char *) __stringVal(encodedPathName), &buf);
+	ret = stat((char *) __stringVal(encodedPathName), &buf);
 } while ((ret < 0) && (errno == EINTR));
 __END_INTERRUPTABLE__
 if (ret < 0) {
-error = __mkSmallInteger(errno);
+	error = __mkSmallInteger(errno);
-@global(LastErrorNumber) = error;
+	@global(LastErrorNumber) = error;
-goto out;
+	goto out;
 }
 switch (buf.st_mode & S_IFMT) {
-case S_IFDIR:
+	case S_IFDIR:
-type = @symbol(directory);
+	    type = @symbol(directory);
-break;
+	    break;
-case S_IFREG:
+	case S_IFREG:
-type = @symbol(regular);
+	    type = @symbol(regular);
-break;
+	    break;
 # ifdef S_IFCHR
-case S_IFCHR:
+	case S_IFCHR:
-type = @symbol(characterSpecial);
+	    type = @symbol(characterSpecial);
-break;
+	    break;
 # endif
 # ifdef S_IFBLK
-case S_IFBLK:
+	case S_IFBLK:
-type = @symbol(blockSpecial);
+	    type = @symbol(blockSpecial);
-break;
+	    break;
 # endif
 # ifdef S_IFMPC
-case S_IFMPC:
+	case S_IFMPC:
-type = @symbol(multiplexedCharacterSpecial);
+	    type = @symbol(multiplexedCharacterSpecial);
-break;
+	    break;
 # endif
 # ifdef S_IFMPB
-case S_IFMPB:
+	case S_IFMPB:
-type = @symbol(multiplexedBlockSpecial);
+	    type = @symbol(multiplexedBlockSpecial);
-break;
+	    break;
 # endif
 # ifdef S_IFLNK
-case S_IFLNK:
+	case S_IFLNK:
-type = @symbol(symbolicLink);
+	    type = @symbol(symbolicLink);
-break;
+	    break;
 # endif
 # ifdef S_IFSOCK
-case S_IFSOCK:
+	case S_IFSOCK:
-type = @symbol(socket);
+	    type = @symbol(socket);
-break;
+	    break;
 # endif
 # ifdef S_IFIFO
-case S_IFIFO:
+	case S_IFIFO:
-type = @symbol(fifo);
+	    type = @symbol(fifo);
-break;
+	    break;
 # endif
-default:
+	default:
-type = @symbol(unknown);
+	    type = @symbol(unknown);
-break;
+	    break;
 }
 if (sizeof(buf.st_ino) == 8) {
-id = __MKUINT64(&buf.st_ino);
+	id = __MKUINT64(&buf.st_ino);
 } else {
-id = __MKUINT(buf.st_ino);
+	id = __MKUINT(buf.st_ino);
 }
 mode = __mkSmallInteger(buf.st_mode & 0777);
 uid = __mkSmallInteger(buf.st_uid);
 gid = __mkSmallInteger(buf.st_gid);
 nLink = __mkSmallInteger(buf.st_nlink);
 if (sizeof(buf.st_size) == 8) {
-size = __MKINT64(&buf.st_size);
+	size = __MKINT64(&buf.st_size);
 } else {
-size = __MKINT(buf.st_size);
+	size = __MKINT(buf.st_size);
 }
 aOStime = __MKUINT(buf.st_atime);
 mOStime = __MKUINT(buf.st_mtime);
 cOStime = __MKUINT(buf.st_ctime);
 out:;
 %}.
 mode notNil ifTrue:[
-"/ now done lazy in FileStatusInfo
+	"/ now done lazy in FileStatusInfo
-"/ atime := Timestamp fromOSTime:(aOStime * 1000).
+	"/ atime := Timestamp fromOSTime:(aOStime * 1000).
-"/ mtime := Timestamp fromOSTime:(mOStime * 1000).
+	"/ mtime := Timestamp fromOSTime:(mOStime * 1000).
-"/ ctime := Timestamp fromOSTime:(cOStime * 1000).
+	"/ ctime := Timestamp fromOSTime:(cOStime * 1000).
-^ FileStatusInfo
+	^ FileStatusInfo
-type:type
+		    type:type
-mode:mode
+		    mode:mode
-uid:uid
+		    uid:uid
-gid:gid
+		    gid:gid
-size:size
+		    size:size
-id:id
+		    id:id
-accessed:aOStime
+		    accessed:aOStime
-modified:mOStime
+		    modified:mOStime
-statusChanged:cOStime
+		    statusChanged:cOStime
-sourcePath:nil targetPath:nil
+		    sourcePath:nil targetPath:nil
-numLinks:nLink.
+		    numLinks:nLink.
 ].
 error notNil ifTrue:[
-^ nil.
+	^ nil.
 ].
 ^ self primitiveFailed
 "
 %{
 int ret;
 if (__isStringLike(encodedPathName)) {
-struct stat buf;
+	struct stat buf;
 # ifdef TRACE_STAT_CALLS
-printf("stat on '%s' for isDirectory\n", __stringVal(encodedPathName));
+	printf("stat on '%s' for isDirectory\n", __stringVal(encodedPathName));
 # endif
-__BEGIN_INTERRUPTABLE__
+	__BEGIN_INTERRUPTABLE__
-do {
+	do {
-ret = stat((char *) __stringVal(encodedPathName), &buf);
+	    ret = stat((char *) __stringVal(encodedPathName), &buf);
-} while ((ret < 0) && (errno == EINTR));
+	} while ((ret < 0) && (errno == EINTR));
-__END_INTERRUPTABLE__
+	__END_INTERRUPTABLE__
-if (ret < 0) {
+	if (ret < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
-RETURN ( false );
+	    RETURN ( false );
-}
+	}
-RETURN ( ((buf.st_mode & S_IFMT) == S_IFDIR) ? true : false);
+	RETURN ( ((buf.st_mode & S_IFMT) == S_IFDIR) ? true : false);
 }
 %}.
 ^ self primitiveFailed
 "an alternative implementation would be:
-^ (self infoOf:aPathName) type == #directory
+	^ (self infoOf:aPathName) type == #directory
 "
 !
 isExecutable:aPathName
 "return true, if the given file is executable.
 %{
 int ret;
 if (__isStringLike(encodedPathName)) {
 # ifdef TRACE_ACCESS_CALLS
-printf("access on '%s' for executable\n", __stringVal(encodedPathName));
+	printf("access on '%s' for executable\n", __stringVal(encodedPathName));
 # endif
-__BEGIN_INTERRUPTABLE__
+	__BEGIN_INTERRUPTABLE__
-do {
+	do {
-ret = access(__stringVal(encodedPathName), X_OK);
+	    ret = access(__stringVal(encodedPathName), X_OK);
-} while ((ret < 0) && (errno == EINTR));
+	} while ((ret < 0) && (errno == EINTR));
-__END_INTERRUPTABLE__
+	__END_INTERRUPTABLE__
-if (ret < 0) {
+	if (ret < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
-}
+	}
-RETURN ( ((ret == 0) ? true : false) );
+	RETURN ( ((ret == 0) ? true : false) );
 }
 %}.
 ^ self primitiveFailed
 !
 %{
 int ret;
 if (__isStringLike(encodedPathName)) {
 # ifdef TRACE_ACCESS_CALLS
-printf("access on '%s' for readable\n", __stringVal(encodedPathName));
+	printf("access on '%s' for readable\n", __stringVal(encodedPathName));
 # endif
-__BEGIN_INTERRUPTABLE__
+	__BEGIN_INTERRUPTABLE__
-do {
+	do {
-ret = access(__stringVal(encodedPathName), R_OK);
+	    ret = access(__stringVal(encodedPathName), R_OK);
-} while ((ret < 0) && (errno == EINTR));
+	} while ((ret < 0) && (errno == EINTR));
-__END_INTERRUPTABLE__
+	__END_INTERRUPTABLE__
-if (ret < 0) {
+	if (ret < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
-}
+	}
-RETURN ( ((ret == 0) ? true : false) );
+	RETURN ( ((ret == 0) ? true : false) );
 }
 %}.
 ^ self primitiveFailed
 !
 struct stat buf;
 int ret;
 if (__isStringLike(encodedPathName)) {
 # ifdef TRACE_STAT_CALLS
-printf("stat on '%s' for isValidPath\n", __stringVal(encodedPathName));
+	printf("stat on '%s' for isValidPath\n", __stringVal(encodedPathName));
 # endif
-__BEGIN_INTERRUPTABLE__
+	__BEGIN_INTERRUPTABLE__
-do {
+	do {
-ret = stat((char *) __stringVal(encodedPathName), &buf);
+	    ret = stat((char *) __stringVal(encodedPathName), &buf);
-} while ((ret < 0) && (errno == EINTR));
+	} while ((ret < 0) && (errno == EINTR));
-__END_INTERRUPTABLE__
+	__END_INTERRUPTABLE__
-if (ret < 0) {
+	if (ret < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
-RETURN (false);
+	    RETURN (false);
-}
+	}
-RETURN ( ret ? false : true );
+	RETURN ( ret ? false : true );
 }
 %}.
 ^ self primitiveFailed
 "/ alternative:
 %{
 int ret;
 if (__isStringLike(encodedPathName)) {
 # ifdef TRACE_ACCESS_CALLS
-printf("access on '%s' for writable\n", __stringVal(encodedPathName));
+	printf("access on '%s' for writable\n", __stringVal(encodedPathName));
 # endif
-__BEGIN_INTERRUPTABLE__
+	__BEGIN_INTERRUPTABLE__
-do {
+	do {
-ret = access(__stringVal(encodedPathName), W_OK);
+	    ret = access(__stringVal(encodedPathName), W_OK);
-} while ((ret < 0) && (errno == EINTR));
+	} while ((ret < 0) && (errno == EINTR));
-__END_INTERRUPTABLE__
+	__END_INTERRUPTABLE__
-if (ret < 0) {
+	if (ret < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
-}
+	}
-RETURN ( ((ret == 0) ? true : false) );
+	RETURN ( ((ret == 0) ? true : false) );
 }
 %}.
 ^ self primitiveFailed
 !
 linkInfoOf:aPathName
 "return some object filled with info for the file 'aPathName'.
 The info (for which corresponding access methods are understood by
 the returned object) is:
-type            - a symbol giving the files type
+	 type            - a symbol giving the files type
-mode            - numeric access mode
+	 mode            - numeric access mode
-uid             - owners user id
+	 uid             - owners user id
-gid             - owners group id
+	 gid             - owners group id
-size            - files size
+	 size            - files size
-id              - files number (i.e. inode number)
+	 id              - files number (i.e. inode number)
-accessed        - last access time (as Timestamp)
+	 accessed        - last access time (as Timestamp)
-modified        - last modification time (as Timestamp)
+	 modified        - last modification time (as Timestamp)
-statusChanged   - last status change time (as Timestamp)
+	 statusChanged   - last status change time (as Timestamp)
-alternativeName     - (windows only:) the MSDOS name of the file
+	 alternativeName     - (windows only:) the MSDOS name of the file
-recordFormatNumeric - (VMS only:) numeric value of the recordFormat
+	 recordFormatNumeric - (VMS only:) numeric value of the recordFormat
-recordFormat        - (VMS only:) symbolic value of the recordFormat
+	 recordFormat        - (VMS only:) symbolic value of the recordFormat
-recordAttributes    - (VMS only:) recordAttributes
+	 recordAttributes    - (VMS only:) recordAttributes
-fixedHeaderSize     - (VMS only:) fixed header size in a variable record format
+	 fixedHeaderSize     - (VMS only:) fixed header size in a variable record format
-recordSize          - (VMS only:) record size.
+	 recordSize          - (VMS only:) record size.
 Some of the fields may be returned as nil on systems which do not provide
 all of the information.
 If aPathName is invalid, nil is returned.
 struct stat buf;
 int ret;
 char pathBuffer[1024];
 if (__isStringLike(encodedPathName)) {
-__BEGIN_INTERRUPTABLE__
+	__BEGIN_INTERRUPTABLE__
-do {
+	do {
-ret = lstat((char *) __stringVal(encodedPathName), &buf);
+	    ret = lstat((char *) __stringVal(encodedPathName), &buf);
-} while ((ret < 0) && (errno == EINTR));
+	} while ((ret < 0) && (errno == EINTR));
-__END_INTERRUPTABLE__
+	__END_INTERRUPTABLE__
-if (ret < 0) {
+	if (ret < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
-RETURN ( nil );
+	    RETURN ( nil );
-}
+	}
-switch (buf.st_mode & S_IFMT) {
+	switch (buf.st_mode & S_IFMT) {
 # ifdef S_IFLNK
-case S_IFLNK:
+	    case S_IFLNK:
-type = @symbol(symbolicLink);
+		type = @symbol(symbolicLink);
-if ((ret = readlink((char *) __stringVal(encodedPathName), pathBuffer, sizeof(pathBuffer))) < 0) {
+		if ((ret = readlink((char *) __stringVal(encodedPathName), pathBuffer, sizeof(pathBuffer))) < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(errno);
+		    @global(LastErrorNumber) = __mkSmallInteger(errno);
-RETURN ( nil );
+		    RETURN ( nil );
-}
+		}
-pathBuffer[ret] = '\0';  /* readlink does not 0-terminate */
+		pathBuffer[ret] = '\0';  /* readlink does not 0-terminate */
-path = __MKSTRING(pathBuffer);
+		path = __MKSTRING(pathBuffer);
-break;
+		break;
 # endif
-case S_IFDIR:
+	    case S_IFDIR:
-type = @symbol(directory);
+		type = @symbol(directory);
-break;
+		break;
-case S_IFREG:
+	    case S_IFREG:
-type = @symbol(regular);
+		type = @symbol(regular);
-break;
+		break;
 # ifdef S_IFCHR
-case S_IFCHR:
+	    case S_IFCHR:
-type = @symbol(characterSpecial);
+		type = @symbol(characterSpecial);
-break;
+		break;
 # endif
 # ifdef S_IFBLK
-case S_IFBLK:
+	    case S_IFBLK:
-type = @symbol(blockSpecial);
+		type = @symbol(blockSpecial);
-break;
+		break;
 # endif
 # ifdef S_IFMPC
-case S_IFMPC:
+	    case S_IFMPC:
-type = @symbol(multiplexedCharacterSpecial);
+		type = @symbol(multiplexedCharacterSpecial);
-break;
+		break;
 # endif
 # ifdef S_IFMPB
-case S_IFMPB:
+	    case S_IFMPB:
-type = @symbol(multiplexedBlockSpecial);
+		type = @symbol(multiplexedBlockSpecial);
-break;
+		break;
 # endif
 # ifdef S_IFSOCK
-case S_IFSOCK:
+	    case S_IFSOCK:
-type = @symbol(socket);
+		type = @symbol(socket);
-break;
+		break;
 # endif
 # ifdef S_IFIFO
-case S_IFIFO:
+	    case S_IFIFO:
-type = @symbol(fifo);
+		type = @symbol(fifo);
-break;
+		break;
 # endif
-default:
+	    default:
-type = @symbol(unknown);
+		type = @symbol(unknown);
-break;
+		break;
-}
+	}
-if (sizeof(buf.st_ino) == 8) {
+	if (sizeof(buf.st_ino) == 8) {
-id = __MKUINT64(&buf.st_ino);
+	    id = __MKUINT64(&buf.st_ino);
-} else {
+	} else {
-id = __MKUINT(buf.st_ino);
+	    id = __MKUINT(buf.st_ino);
-}
+	}
-mode = __mkSmallInteger(buf.st_mode & 0777);
+	mode = __mkSmallInteger(buf.st_mode & 0777);
-uid = __mkSmallInteger(buf.st_uid);
+	uid = __mkSmallInteger(buf.st_uid);
-gid = __mkSmallInteger(buf.st_gid);
+	gid = __mkSmallInteger(buf.st_gid);
-nLink = __mkSmallInteger(buf.st_nlink);
+	nLink = __mkSmallInteger(buf.st_nlink);
-if (sizeof(buf.st_size) == 8) {
+	if (sizeof(buf.st_size) == 8) {
-size = __MKINT64(&buf.st_size);
+	    size = __MKINT64(&buf.st_size);
-} else {
+	} else {
-size = __MKINT(buf.st_size);
+	    size = __MKINT(buf.st_size);
-}
+	}
-aOStime = __MKUINT(buf.st_atime);
+	aOStime = __MKUINT(buf.st_atime);
-mOStime = __MKUINT(buf.st_mtime);
+	mOStime = __MKUINT(buf.st_mtime);
-cOStime = __MKUINT(buf.st_ctime);
+	cOStime = __MKUINT(buf.st_ctime);
 }
 #else
 RETURN ( nil );
 #endif
 %}.
 mode notNil ifTrue:[
-^ FileStatusInfo
+	^ FileStatusInfo
-type:type
+	    type:type
-mode:mode
+	    mode:mode
-uid:uid
+	    uid:uid
-gid:gid
+	    gid:gid
-size:size
+	    size:size
-id:id
+	    id:id
-accessed:aOStime
+	    accessed:aOStime
-modified:mOStime
+	    modified:mOStime
-statusChanged:cOStime
+	    statusChanged:cOStime
-sourcePath:aPathName targetPath:(self decodePath:path)
+	    sourcePath:aPathName targetPath:(self decodePath:path)
-numLinks:nLink.
+	    numLinks:nLink.
 ].
 ^ self primitiveFailed
 "
 OperatingSystem infoOf:'Make.proto'
 "return a collection of mountPoints (aka. topDirectories of mounted file systems).
 As this might be expensive on some systems,
 the info is cached for some time (5 minutes)"
 CacheMountPointsTimeStamp notNil ifTrue:[
-Timestamp now < (CacheMountPointsTimeStamp addSeconds:5*60) ifTrue:[
+	Timestamp now < (CacheMountPointsTimeStamp addSeconds:5*60) ifTrue:[
-^ CachedMountPoints
+	    ^ CachedMountPoints
-].
+	].
 ].
 '/proc/mounts' asFilename exists ifTrue:[
-CachedMountPoints := self mountPointsFromProcFS.
+	CachedMountPoints := self mountPointsFromProcFS.
-CacheMountPointsTimeStamp := Timestamp now.
+	CacheMountPointsTimeStamp := Timestamp now.
-^ CachedMountPoints
+	^ CachedMountPoints
 ].
 "/ TODO: add fallback code for other OS's (i.e. reading /etc/mtab)
 ^ #()
 from what you expect."
 |p path command|
 path = '.' ifTrue:[
-^ self getCurrentDirectory.
+	^ self getCurrentDirectory.
 ].
 "some systems have a convenient function for this ..."
 path := self primPathNameOf:(self encodePath:pathName).
 path notNil ifTrue:[
-path := self decodePath:path.
+	path := self decodePath:path.
 ] ifFalse:[
-(self isValidPath:pathName) ifFalse:[
+	(self isValidPath:pathName) ifFalse:[
-p := pathName.
+	    p := pathName.
-[(p size > 1)
+	    [(p size > 1)
-and:[p endsWith:(self fileSeparator)]
+	     and:[p endsWith:(self fileSeparator)]
-] whileTrue:[
+	    ] whileTrue:[
-p := p copyButLast.
+		p := p copyButLast.
-].
+	    ].
-^ p
+	    ^ p
-].
+	].
-(SlowFork==true or:[PipeFailed==true]) ifFalse:[
+	(SlowFork==true or:[PipeFailed==true]) ifFalse:[
-|directoryName fileBaseName|
+	    |directoryName fileBaseName|
-(self isDirectory:pathName) ifTrue:[
+	    (self isDirectory:pathName) ifTrue:[
-directoryName := pathName.
+		directoryName := pathName.
-fileBaseName := nil.
+		fileBaseName := nil.
-] ifFalse:[
+	    ] ifFalse:[
-|pathFilename|
+		|pathFilename|
-pathFilename := pathName asFilename.
+		pathFilename := pathName asFilename.
-directoryName := pathFilename directoryName.
+		directoryName := pathFilename directoryName.
-fileBaseName := pathFilename baseName.
+		fileBaseName := pathFilename baseName.
-].
+	    ].
-PipeStream openErrorSignal handle:[:ex |
+	    PipeStream openErrorSignal handle:[:ex |
-PipeFailed := true.
+		PipeFailed := true.
-'UnixOperatingSystem [warning]: cannot fork/popen' errorPrintCR.
+		'UnixOperatingSystem [warning]: cannot fork/popen' errorPrintCR.
-ex return.
+		ex return.
-] do:[
+	    ] do:[
-"have to fall back ..."
+		"have to fall back ..."
-command := 'cd "' , directoryName , '"; pwd'.
+		command := 'cd "' , directoryName , '"; pwd'.
-p := PipeStream readingFrom:command.
+		p := PipeStream readingFrom:command.
-].
+	    ].
-(p isNil or:[p atEnd]) ifTrue:[
+	    (p isNil or:[p atEnd]) ifTrue:[
-('UnixOperatingSystem [warning]: PipeStream for <' , command , '> failed') errorPrintCR.
+		('UnixOperatingSystem [warning]: PipeStream for <' , command , '> failed') errorPrintCR.
-] ifFalse:[
+	    ] ifFalse:[
-path := p nextLine.
+		path := p nextLine.
-p close.
+		p close.
-].
+	    ].
-fileBaseName notNil ifTrue:[
+	    fileBaseName notNil ifTrue:[
-path := path, '/', fileBaseName.
+		path := path, '/', fileBaseName.
-].
+	    ].
-].
+	].
-path isNil ifTrue:[
+	path isNil ifTrue:[
-"/
+	    "/
-"/ return the original - there is nothing else can we do
+	    "/ return the original - there is nothing else can we do
-"/
+	    "/
-path := pathName
+	    path := pathName
-].
+	].
-(SlowFork==true or:[ForkFailed==true]) ifTrue:[
+	(SlowFork==true or:[ForkFailed==true]) ifTrue:[
-path := self compressPath:path
+	    path := self compressPath:path
-]
+	]
 ].
 ^ path.
 "
 OperatingSystem pathNameOf:'.'
 "return the name of the current directory"
 |path|
 %{  /* UNLIMITEDSTACK */
-char nameBuffer[MAXPATHLEN + 1];
+	char nameBuffer[MAXPATHLEN + 1];
-if (getcwd(nameBuffer, MAXPATHLEN)) {
+	if (getcwd(nameBuffer, MAXPATHLEN)) {
-path = __MKSTRING(nameBuffer);
+	    path = __MKSTRING(nameBuffer);
-RETURN(path);
+	    RETURN(path);
-}
+	}
 %}.
 ^ self primitiveFailed.
 "
-self primGetCurrentDirectory
+	self primGetCurrentDirectory
 "
 !
 primIdOf:aPathName
 "the actual code to return the fileNumber (i.e. inode number) of a file."
 unsigned INT ino;
 OBJ retVal;
 if (__isStringLike(encodedPathName)) {
 # ifdef TRACE_STAT_CALLS
-printf("stat on '%s' for id\n", __stringVal(encodedPathName));
+	printf("stat on '%s' for id\n", __stringVal(encodedPathName));
 # endif
-__BEGIN_INTERRUPTABLE__
+	__BEGIN_INTERRUPTABLE__
-do {
+	do {
-ret = stat((char *) __stringVal(encodedPathName), &buf);
+	    ret = stat((char *) __stringVal(encodedPathName), &buf);
-} while (ret < 0 && errno == EINTR);
+	} while (ret < 0 && errno == EINTR);
-__END_INTERRUPTABLE__
+	__END_INTERRUPTABLE__
-if (ret >= 0) {
+	if (ret >= 0) {
-ino = buf.st_ino;
+	    ino = buf.st_ino;
-retVal = __MKUINT(ino);
+	    retVal = __MKUINT(ino);
-RETURN (retVal);
+	    RETURN (retVal);
-}
+	}
-@global(LastErrorNumber) = __mkSmallInteger(errno);
+	@global(LastErrorNumber) = __mkSmallInteger(errno);
-RETURN (nil);
+	RETURN (nil);
 }
 RETURN (nil);
 %}.
 !
 %{  /* UNLIMITEDSTACK */
 if (__isStringLike(pathName)) {
 #ifdef HAS_REALPATH
-extern char *realpath();
+	extern char *realpath();
-// POSIX-2008 says, that a NULL namebuffer causes realPath to malloc()
+	// POSIX-2008 says, that a NULL namebuffer causes realPath to malloc()
-// the required memory. But this does not work as of 2013-04
+	// the required memory. But this does not work as of 2013-04
-char nameBuffer[MAXPATHLEN+1];
+	char nameBuffer[MAXPATHLEN+1];
-char *nameP = realpath(__stringVal(pathName), nameBuffer);
+	char *nameP = realpath(__stringVal(pathName), nameBuffer);
-if (nameP) {
+	if (nameP) {
-OBJ ret = __MKSTRING(nameP);
+	    OBJ ret = __MKSTRING(nameP);
-// free(nameP);
+	    // free(nameP);
-RETURN ( ret );
+	    RETURN ( ret );
-}
+	}
-// fprintf(stderr, "stx[warning]: realpath(\"%s\") failed: %s\n", __stringVal(pathName), strerror(errno));
+	// fprintf(stderr, "stx[warning]: realpath(\"%s\") failed: %s\n", __stringVal(pathName), strerror(errno));
 #endif /* ! HAS_REALPATH */
 } else {
-error = @symbol(argument);     // argument is not a string
+	error = @symbol(argument);     // argument is not a string
 }
 %}.
 "/ Does not work as of 2013-04 (UNLIMITEDSTACK problem?)
 "/    error notNil ifTrue:[
 "/        ^ self primitiveFailed:error.
 "/    ].
 ^ nil
 "
-self primPathNameOf:'.'
+	self primPathNameOf:'.'
-self primPathNameOf:'/murks/quatsch/bla/.'
+	self primPathNameOf:'/murks/quatsch/bla/.'
-self primPathNameOf:5555
+	self primPathNameOf:5555
 "
 !
 timeOfLastAccess:aPathName
 "return the time, when the file was last accessed.
 For nonexistent files, nil is returned."
 "could be implemented as:
-(self infoOf:aPathName) accessed
+	(self infoOf:aPathName) accessed
 "
 |osSeconds i encodedPathName|
 encodedPathName := self encodePath:aPathName.
 time_t mtime;
 int ret;
 if (__isStringLike(encodedPathName)) {
 # ifdef TRACE_STAT_CALLS
-printf("stat on '%s' for timeOfLastAccess\n", __stringVal(encodedPathName));
+	printf("stat on '%s' for timeOfLastAccess\n", __stringVal(encodedPathName));
 # endif
-__BEGIN_INTERRUPTABLE__
+	__BEGIN_INTERRUPTABLE__
-do {
+	do {
-ret = stat((char *) __stringVal(encodedPathName), &buf);
+	    ret = stat((char *) __stringVal(encodedPathName), &buf);
-} while (ret < 0 && errno == EINTR);
+	} while (ret < 0 && errno == EINTR);
-__END_INTERRUPTABLE__
+	__END_INTERRUPTABLE__
-if (ret < 0) {
+	if (ret < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
-RETURN (nil);
+	    RETURN (nil);
-}
+	}
-osSeconds = __MKUINT(buf.st_atime);
+	osSeconds = __MKUINT(buf.st_atime);
 }
 %}.
 osSeconds notNil ifTrue:[^ Timestamp fromOSTime:(osSeconds * 1000)].
 i := self infoOf:aPathName.
 timeOfLastChange:aPathName
 "return the time, when the file was last changed.
 For nonexistent files, nil is returned."
 "could be implemented as:
-(self infoOf:aPathName) modified
+	(self infoOf:aPathName) modified
 "
 |osSeconds i encodedPathName|
 encodedPathName := self encodePath:aPathName.
 int ret;
 time_t mtime;
 if (__isStringLike(encodedPathName)) {
 # ifdef TRACE_STAT_CALLS
-printf("stat on '%s' for timeOfLastChange\n", __stringVal(encodedPathName));
+	printf("stat on '%s' for timeOfLastChange\n", __stringVal(encodedPathName));
 # endif
-__BEGIN_INTERRUPTABLE__
+	__BEGIN_INTERRUPTABLE__
-do {
+	do {
-ret = stat((char *) __stringVal(encodedPathName), &buf);
+	    ret = stat((char *) __stringVal(encodedPathName), &buf);
-} while (ret < 0 && errno == EINTR);
+	} while (ret < 0 && errno == EINTR);
-__END_INTERRUPTABLE__
+	__END_INTERRUPTABLE__
-if (ret < 0) {
+	if (ret < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
-RETURN ( nil );
+	    RETURN ( nil );
-}
+	}
-osSeconds = __MKUINT(buf.st_mtime);
+	osSeconds = __MKUINT(buf.st_mtime);
 }
 %}.
 osSeconds notNil ifTrue:[^ Timestamp fromOSTime:(osSeconds * 1000)].
 i := self infoOf:aPathName.
 encodedPathName := self encodePath:aPathName.
 "
 this could have been implemented as:
-(self infoOf:aPathName) type
+	(self infoOf:aPathName) type
 but for huge directory searches the code below is faster
 "
 %{
 struct stat buf;
 int ret;
 if (__isStringLike(encodedPathName)) {
 # ifdef TRACE_STAT_CALLS
-printf("stat on '%s' for type\n", __stringVal(encodedPathName));
+	printf("stat on '%s' for type\n", __stringVal(encodedPathName));
 # endif
-__BEGIN_INTERRUPTABLE__
+	__BEGIN_INTERRUPTABLE__
-do {
+	do {
-ret = stat((char *) __stringVal(encodedPathName), &buf);
+	    ret = stat((char *) __stringVal(encodedPathName), &buf);
-} while (ret < 0 && errno == EINTR);
+	} while (ret < 0 && errno == EINTR);
-__END_INTERRUPTABLE__
+	__END_INTERRUPTABLE__
-if (ret < 0) {
+	if (ret < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
-RETURN ( nil );
+	    RETURN ( nil );
-}
+	}
-switch (buf.st_mode & S_IFMT) {
+	switch (buf.st_mode & S_IFMT) {
-case S_IFDIR:
+	    case S_IFDIR:
-RETURN ( @symbol(directory) );
+		RETURN ( @symbol(directory) );
-case S_IFREG:
+	    case S_IFREG:
-RETURN ( @symbol(regular) );
+		RETURN ( @symbol(regular) );
 # ifdef S_IFCHR
-case S_IFCHR:
+	    case S_IFCHR:
-RETURN ( @symbol(characterSpecial) );
+		RETURN ( @symbol(characterSpecial) );
 # endif
 # ifdef S_IFBLK
-case S_IFBLK:
+	    case S_IFBLK:
-RETURN ( @symbol(blockSpecial) );
+		RETURN ( @symbol(blockSpecial) );
 # endif
 # ifdef S_IFLNK
-case S_IFLNK:
+	    case S_IFLNK:
-RETURN ( @symbol(symbolicLink) );
+		RETURN ( @symbol(symbolicLink) );
 # endif
 # ifdef S_IFSOCK
-case S_IFSOCK:
+	    case S_IFSOCK:
-RETURN ( @symbol(socket) );
+		RETURN ( @symbol(socket) );
 # endif
 # ifdef S_IFIFO
-case S_IFIFO:
+	    case S_IFIFO:
-RETURN ( @symbol(fifo) );
+		RETURN ( @symbol(fifo) );
 # endif
-default:
+	    default:
-RETURN ( @symbol(unknown) );
+		RETURN ( @symbol(unknown) );
-}
+	}
 }
 %}.
 i := self infoOf:aPathName.
 i notNil ifTrue:[^ i type].
 ^ nil.
 %{  /* NOCONTEXT */
 if (__isSmallInteger(signalNumber)) {
 #ifdef SIG_DFL
-signal(__intVal(signalNumber), SIG_DFL);
+	signal(__intVal(signalNumber), SIG_DFL);
-RETURN (self);
+	RETURN (self);
 #endif
 }
 %}.
 "
 this error is triggered on non-integer argument
 int ret, flags, f;
 #if (defined(F_GETFL) && defined(F_SETFL) && defined(FASYNC)) || defined(SYSV4)
 if (__isSmallInteger(fd)) {
-f = __intVal(fd);
+	f = __intVal(fd);
 # if defined(SYSV4)
-ret = ioctl(f, I_SETSIG, 0);
+	ret = ioctl(f, I_SETSIG, 0);
 # else /*! SYSV4*/
-flags = fcntl(f, F_GETFL, 0);
+	flags = fcntl(f, F_GETFL, 0);
-/*
+	/*
-* if already clear, there is no need for this syscall ...
+	 * if already clear, there is no need for this syscall ...
-*/
+	 */
-if (flags & FASYNC) {
+	if (flags & FASYNC) {
-ret = fcntl(f, F_SETFL, flags & ~FASYNC);
+	    ret = fcntl(f, F_SETFL, flags & ~FASYNC);
-if (ret >= 0) ret = flags;
+	    if (ret >= 0) ret = flags;
-} else {
+	} else {
-ret = flags;
+	    ret = flags;
-}
+	}
 # endif /* !SYSV4 */
-RETURN ( __mkSmallInteger(ret) );
+	RETURN ( __mkSmallInteger(ret) );
 }
 #endif
 %}.
 "
 this error is triggered on non-integer argument
 Use only for fully debugged stand alone applications."
 %{  /* NOCONTEXT */
 if (__isSmallInteger(signalNumber)) {
-int sigNo = __intVal(signalNumber);
+	int sigNo = __intVal(signalNumber);
-if (sigNo == 0) {
+	if (sigNo == 0) {
-RETURN (self);
+	    RETURN (self);
-}
+	}
 #ifdef SIG_IGN
-signal(sigNo, SIG_IGN);
+	signal(sigNo, SIG_IGN);
-RETURN (self);
+	RETURN (self);
 #endif
 }
 %}.
 "
 this error is triggered on non-integer argument
 !
 disableTimer
 "disable timer interrupts.
 WARNING:
-the system will not operate correctly with timer interrupts
+	the system will not operate correctly with timer interrupts
-disabled, because no scheduling or timeouts are possible."
+	disabled, because no scheduling or timeouts are possible."
 %{  /* NOCONTEXT */
 #if defined(ITIMER_REAL) && !defined(NO_SETITIMER)
 struct itimerval dt;
 #   endif
 #  endif
 # endif
 if (__isSmallInteger(fd)) {
-if (firstCall) {
+	if (firstCall) {
 # ifdef HAS_SIGACTION
-struct sigaction act;
+	    struct sigaction act;
-/*
+	    /*
-* Do not add SA_RESTART here. A signal can cause a
+	     * Do not add SA_RESTART here. A signal can cause a
-* thread switch, another thread can do a garbage collect
+	     * thread switch, another thread can do a garbage collect
-* and restarted system calls may write into old
+	     * and restarted system calls may write into old
-* (collected) addresses.
+	     * (collected) addresses.
-*/
+	     */
-act.sa_flags = SA_SIGINFO; /* <- if you add more, remember dummys at the top */
+	    act.sa_flags = SA_SIGINFO; /* <- if you add more, remember dummys at the top */
-sigemptyset(&act.sa_mask);
+	    sigemptyset(&act.sa_mask);
-act.sa_handler = __signalIoInterrupt;
+	    act.sa_handler = __signalIoInterrupt;
-sigaction(THESIGNAL, &act, 0);
+	    sigaction(THESIGNAL, &act, 0);
 # else
 #  ifdef HAS_SIGVEC
-struct sigvec vec;
+	    struct sigvec vec;
-vec.sv_flags = SV_INTERRUPT;
+	    vec.sv_flags = SV_INTERRUPT;
-sigemptyset(&vec.sv_mask);
+	    sigemptyset(&vec.sv_mask);
-vec.sv_handler = __signalIoInterrupt;
+	    vec.sv_handler = __signalIoInterrupt;
-sigvec(THESIGNAL, &vec, NULL);
+	    sigvec(THESIGNAL, &vec, NULL);
 #  else
-signal(THESIGNAL, __signalIoInterrupt);
+	    signal(THESIGNAL, __signalIoInterrupt);
 #  endif /* SIGVEC */
 # endif /* SIGACTION */
-firstCall = 0;
+	    firstCall = 0;
-}
+	}
 #undef THESIGNAL
-f = __intVal(fd);
+	f = __intVal(fd);
 # if defined(SYSV4)
-ret = ioctl(f, I_SETSIG, S_INPUT | S_HIPRI | S_ERROR | S_RDNORM | S_RDBAND | S_MSG | S_HANGUP);
+	ret = ioctl(f, I_SETSIG, S_INPUT | S_HIPRI | S_ERROR | S_RDNORM | S_RDBAND | S_MSG | S_HANGUP);
 # else /*! SYSV4*/
-flags = fcntl(f, F_GETFL, 0);
+	flags = fcntl(f, F_GETFL, 0);
-/*
+	/*
-* if already set, there is no need for this syscall ...
+	 * if already set, there is no need for this syscall ...
-*/
+	 */
-if (flags & FASYNC) {
+	if (flags & FASYNC) {
-ret = flags;
+	    ret = flags;
-} else {
+	} else {
-ret = fcntl(f, F_SETFL, flags | FASYNC);
+	    ret = fcntl(f, F_SETFL, flags | FASYNC);
-if (ret >= 0) ret = flags;
+	    if (ret >= 0) ret = flags;
-}
+	}
 # endif /*!SYSV4*/
 # if defined(F_SETOWN) || defined(FIOSETOWN)
-{
+	{
-int pid;
+	    int pid;
-int ok;
+	    int ok;
-pid = getpid();
+	    pid = getpid();
 #  if defined(F_SETOWN)
-ok = fcntl(f, F_SETOWN, pid);
+	    ok = fcntl(f, F_SETOWN, pid);
-/* printf("F_SETOWN returns %d (%d)\n", ret, errno); */
+	    /* printf("F_SETOWN returns %d (%d)\n", ret, errno); */
 #  else
-ok = ioctl(f, FIOSETOWN, &pid);
+	    ok = ioctl(f, FIOSETOWN, &pid);
-/* printf("FIOSETOWN returns %d (%d)\n", ret, errno); */
+	    /* printf("FIOSETOWN returns %d (%d)\n", ret, errno); */
 #  endif
-if (ok < 0) {
+	    if (ok < 0) {
-ret = ok;
+		ret = ok;
-}
+	    }
-}
+	}
 # endif
-RETURN ( __MKUINT(ret) );
+	RETURN ( __MKUINT(ret) );
 }
 #endif
 %}.
 "
 this error is triggered on non-integer argument
 && ((sigNr = __intVal(signalNumber)) >= 0)
 #ifdef SIG_LIMIT
 &&  (sigNr <= SIG_LIMIT)
 #endif
 ) {
-/*
+	/*
-* standard signals are forced into standard handlers
+	 * standard signals are forced into standard handlers
-* - all others go into general signalInterrupt
+	 * - all others go into general signalInterrupt
-*/
+	 */
 #if defined(SIGPOLL) && defined(SIGIO)
-if (sigNr == SIGPOLL)
+	if (sigNr == SIGPOLL)
-sigNr = SIGIO;
+	    sigNr = SIGIO;
 #endif
-switch (sigNr) {
+	switch (sigNr) {
-case 0:
+	    case 0:
-/* enabling a non-supported signal */
+		/* enabling a non-supported signal */
-RETURN (self);
+		RETURN (self);
 #ifdef SIGBREAK
-case SIGBREAK:
+	    case SIGBREAK:
 #endif
 #ifdef SIGINT
-case SIGINT:
+	    case SIGINT:
 #endif
 #ifdef SIGQUIT
-case SIGQUIT:
+	    case SIGQUIT:
 #endif
 #if defined(SIGINT) || defined(SIGQUIT) || defined(SIGBREAK)
-handler = __signalUserInterrupt;
+		handler = __signalUserInterrupt;
-break;
+		break;
 #endif
 #ifdef SIGFPE
-case SIGFPE:
+	    case SIGFPE:
-handler = __signalFpExceptionInterrupt;
+		handler = __signalFpExceptionInterrupt;
-break;
+		break;
 #endif
 #ifdef SIGPIPE
-case SIGPIPE:
+	    case SIGPIPE:
-handler = __signalPIPEInterrupt;
+		handler = __signalPIPEInterrupt;
-break;
+		break;
 #endif
 #ifdef SIGBUS
-case SIGBUS:
+	    case SIGBUS:
-handler = __signalBUSInterrupt;
+		handler = __signalBUSInterrupt;
-break;
+		break;
 #endif
 #ifdef SIGSEGV
-case SIGSEGV:
+	    case SIGSEGV:
-handler = __signalSEGVInterrupt;
+		handler = __signalSEGVInterrupt;
-break;
+		break;
 #endif
 #ifdef SIGABRT
-case SIGABRT:
+	    case SIGABRT:
-handler = __signalAbortInterrupt;
+		handler = __signalAbortInterrupt;
-break;
+		break;
 #endif
 #ifdef SIGILL
-case SIGILL:
+	    case SIGILL:
-handler = __signalTrapInterrupt;
+		handler = __signalTrapInterrupt;
-break;
+		break;
 #endif
 #ifdef SIGEMT
-case SIGEMT:
+	    case SIGEMT:
-handler = __signalTrapInterrupt;
+		handler = __signalTrapInterrupt;
-break;
+		break;
 #endif
 #ifdef SIGIO
-case SIGIO:
+	    case SIGIO:
-handler = __signalIoInterrupt;
+		handler = __signalIoInterrupt;
-break;
+		break;
 #endif
 #ifdef CHILD_SIGNAL
-case CHILD_SIGNAL:
+	    case CHILD_SIGNAL:
-handler = __signalChildInterrupt;
+		handler = __signalChildInterrupt;
-break;
+		break;
 #endif
 #ifdef SIGALRM
-case SIGALRM:
+	    case SIGALRM:
-handler = __signalTimerInterrupt;
+		handler = __signalTimerInterrupt;
-break;
+		break;
 #endif
-default:
+	    default:
-handler = __signalInterrupt;
+		handler = __signalInterrupt;
-break;
+		break;
-}
+	}
-{
+	{
 #ifdef HAS_SIGACTION
-struct sigaction act;
+	    struct sigaction act;
-/*
+	    /*
-* Do not add SA_RESTART here. A signal can cause a
+	     * Do not add SA_RESTART here. A signal can cause a
-* thread switch, another thread can do a garbage collect
+	     * thread switch, another thread can do a garbage collect
-* and restarted system calls may write into old
+	     * and restarted system calls may write into old
-* (collected) addresses.
+	     * (collected) addresses.
-*/
+	     */
-act.sa_flags = SA_SIGINFO; /* <- if you add more, remember dummys at the top */
+	    act.sa_flags = SA_SIGINFO; /* <- if you add more, remember dummys at the top */
-sigemptyset(&act.sa_mask);
+	    sigemptyset(&act.sa_mask);
-act.sa_handler = handler;
+	    act.sa_handler = handler;
-sigaction(sigNr, &act, 0);
+	    sigaction(sigNr, &act, 0);
 #else
 # ifdef HAS_SIGVEC
-struct sigvec vec;
+	    struct sigvec vec;
-vec.sv_flags = SV_INTERRUPT;
+	    vec.sv_flags = SV_INTERRUPT;
-sigemptyset(&vec.sv_mask);
+	    sigemptyset(&vec.sv_mask);
-vec.sv_handler = handler;
+	    vec.sv_handler = handler;
-sigvec(sigNr, &vec, NULL);
+	    sigvec(sigNr, &vec, NULL);
 # else
-(void) signal(sigNr, handler);
+	    (void) signal(sigNr, handler);
 # endif
 #endif
-}
+	}
-/*
+	/*
-* maybe, we should ret the old enable-status
+	 * maybe, we should ret the old enable-status
-* as boolean here ...
+	 * as boolean here ...
-*/
+	 */
-RETURN (self);
+	RETURN (self);
 }
 %}.
 "
 this error is triggered on non-integer argument, or
 millis = __intVal(milliSeconds);
 #ifdef SIGALRM
 {
-static int firstCall = 1;
+	static int firstCall = 1;
 # ifndef __signalTimerInterrupt
-extern void __signalTimerInterrupt(SIGHANDLER_ARG);
+	extern void __signalTimerInterrupt(SIGHANDLER_ARG);
 # endif
-if (firstCall) {
+	if (firstCall) {
 # ifdef HAS_SIGACTION
-struct sigaction act;
+	    struct sigaction act;
-act.sa_flags = SA_SIGINFO; /* <- if you add more, remember dummys at the top */
+	    act.sa_flags = SA_SIGINFO; /* <- if you add more, remember dummys at the top */
-sigemptyset(&act.sa_mask);
+	    sigemptyset(&act.sa_mask);
-act.sa_handler = __signalTimerInterrupt;
+	    act.sa_handler = __signalTimerInterrupt;
-sigaction(SIGALRM, &act, 0);
+	    sigaction(SIGALRM, &act, 0);
 # else
 #  ifdef HAS_SIGVEC
-struct sigvec vec;
+	    struct sigvec vec;
-vec.sv_flags = SV_INTERRUPT;
+	    vec.sv_flags = SV_INTERRUPT;
-sigemptyset(&vec.sv_mask);
+	    sigemptyset(&vec.sv_mask);
-vec.sv_handler = __signalTimerInterrupt;
+	    vec.sv_handler = __signalTimerInterrupt;
-sigvec(SIGALRM, &vec, NULL);
+	    sigvec(SIGALRM, &vec, NULL);
 #  else /* neither SIGACTION nor SIGVEC */
-signal(SIGALRM, __signalTimerInterrupt);
+	    signal(SIGALRM, __signalTimerInterrupt);
 #  endif /* stupid system  */
 # endif
-firstCall = 0;
+	    firstCall = 0;
-}
+	}
 }
 #endif /* SIGALRM */
 #if defined(ITIMER_REAL) && !defined(NO_SETITIMER)
 {
-struct itimerval dt;
+	struct itimerval dt;
-dt.it_interval.tv_sec = 0;
+	dt.it_interval.tv_sec = 0;
-dt.it_interval.tv_usec = 0;
+	dt.it_interval.tv_usec = 0;
-dt.it_value.tv_sec = millis / 1000;
+	dt.it_value.tv_sec = millis / 1000;
-dt.it_value.tv_usec = (millis % 1000) * 1000;
+	dt.it_value.tv_usec = (millis % 1000) * 1000;
-setitimer(ITIMER_REAL, &dt, 0);
+	setitimer(ITIMER_REAL, &dt, 0);
-RETURN (true);
+	RETURN (true);
 }
 #else /* no ITIMER_REAL */
 # ifdef USE_SLOW_ALARM
 {
-/*
+	/*
-* last fallback - use alarm (which only gives 1 second resolution).
+	 * last fallback - use alarm (which only gives 1 second resolution).
-* If the system does not support any of the above, you have to life
+	 * If the system does not support any of the above, you have to life
-* with this. The consequence is that pressing CTRL-C processing and
+	 * with this. The consequence is that pressing CTRL-C processing and
-* thread switching will take place much delayed.
+	 * thread switching will take place much delayed.
-*/
+	 */
-alarm(1);
+	alarm(1);
-RETURN(true);
+	RETURN(true);
 }
 # endif
 #endif /* ITIMER_REAL */
 %}.
 ^ false
 killProcess:processId
 "kill a unix process.
 The process has a no chance to do some cleanup.
 WARNING: in order to avoid zombie processes (on unix),
-you may have to fetch the processes exitstatus with
+	      you may have to fetch the processes exitstatus with
-OperatingSystem>>getStatusOfProcess:aProcessId."
+	      OperatingSystem>>getStatusOfProcess:aProcessId."
 self sendSignal:(self sigKILL) to:processId.
 "Modified: / 10.6.1998 / 11:59:12 / cg"
 !
 killProcessGroup:processGroupId
 "kill a unix process group.
 The process has a no chance to do some cleanup.
 WARNING: in order to avoid zombie processes (on unix),
-you may have to fetch the processes exitstatus with
+	      you may have to fetch the processes exitstatus with
-OperatingSystem>>getStatusOfProcess:aProcessId."
+	      OperatingSystem>>getStatusOfProcess:aProcessId."
 self sendSignal:(self sigKILL) to:(processGroupId negated).
 "Created: / 10.6.1998 / 11:59:29 / cg"
 !
 Returns false if any error occurred, true otherwise.
 Do not confuse UNIX signals with Smalltalk-Signals.
 WARNING: in order to avoid zombie processes (on unix),
-you may have to fetch the processes exitstatus with
+	      you may have to fetch the processes exitstatus with
-OperatingSystem>>getStatusOfProcess:aProcessId
+	      OperatingSystem>>getStatusOfProcess:aProcessId
-if the signal terminates that process."
+	      if the signal terminates that process."
 %{
 if (__bothSmallInteger(signalNumber, processId)) {
-if (kill(__intVal(processId), __intVal(signalNumber)) < 0) {
+	if (kill(__intVal(processId), __intVal(signalNumber)) < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
-RETURN ( false );
+	    RETURN ( false );
-}
+	}
-RETURN ( true );
+	RETURN ( true );
 }
 %}.
 "/
 "/ either invalid argument (non-integers)
 "/ or not supported by OS
 This is used by the old MessageTally for profiling.
 Should be changed to use real profiling timer if available.
 On systems, where no virtual timer is available, use the real timer
 (which is of course less correct).
 OBSOLETE: the new messageTally runs as a high prio process, not using
-spy interrupts."
+	       spy interrupts."
 %{  /* NOCONTEXT */
 #ifndef __spyInterrupt
 extern void __spyInterrupt();
 !
 stopSpyTimer
 "stop spy timing - disable spy timer.
 OBSOLETE: the new messageTally runs as a high prio process, not using
-spy interrupts."
+	       spy interrupts."
 %{  /* NOCONTEXT */
 #if defined(ITIMER_VIRTUAL) && !defined(NO_SETITIMER)
 struct itimerval dt;
 terminateProcess:processId
 "terminate a unix process.
 The process has a chance to do some cleanup.
 WARNING: in order to avoid zombie processes (on unix),
-you may have to fetch the processes exitstatus with
+	      you may have to fetch the processes exitstatus with
-OperatingSystem>>getStatusOfProcess:aProcessId."
+	      OperatingSystem>>getStatusOfProcess:aProcessId."
 self sendSignal:(self sigTERM) to:processId.
 "Modified: / 28.12.1995 / 15:05:37 / stefan"
 "Modified: / 27.1.1998 / 20:05:47 / cg"
 terminateProcessGroup:processGroupId
 "terminate a unix process group.
 The process has a chance to do some cleanup.
 WARNING: in order to avoid zombie processes (on unix),
-you may have to fetch the processes exitstatus with
+	      you may have to fetch the processes exitstatus with
-OperatingSystem>>getStatusOfProcess:aProcessId."
+	      OperatingSystem>>getStatusOfProcess:aProcessId."
 self sendSignal:(self sigTERM) to:(processGroupId negated).
 "Modified: / 28.12.1995 / 15:05:37 / stefan"
 "Created: / 23.4.1996 / 16:40:34 / stefan"
 %{
 #ifndef NO_SOCKET
 int fds[2];
 if (socketpair(AF_UNIX, SOCK_STREAM, 0, fds) == -1) {
-@global(LastErrorNumber) = __mkSmallInteger(errno);
+	@global(LastErrorNumber) = __mkSmallInteger(errno);
-RETURN ( nil );
+	RETURN ( nil );
 }
 fd1 = __mkSmallInteger(fds[0]);
 fd2 = __mkSmallInteger(fds[1]);
 #endif
 %}.
 fd1 notNil ifTrue:[
-^ Array with:fd1 with:fd2.
+	^ Array with:fd1 with:fd2.
 ].
 ^ nil
 !
 makePTY
 int _fdM, _fdS;
 char *slaveName;
 slaveName = _getpty(&_fdM, O_RDWR|O_NDELAY, 0600, 0);
 if ((slaveName != 0) && (_fdM >= 0)) {
-_fdS = open(slaveName, O_RDWR);
+	_fdS = open(slaveName, O_RDWR);
-if (_fdS < 0) {
+	if (_fdS < 0) {
-(void)close(_fdM);
+	    (void)close(_fdM);
-_fdS = _fdM = -1;
+	    _fdS = _fdM = -1;
-}
+	}
 } else {
-_fdM -1;
+	_fdM -1;
 }
 if ((_fdM >= 0) && (_fdS >= 0)) {
-fdM = __mkSmallInteger(_fdM);
+	fdM = __mkSmallInteger(_fdM);
-fdS = __mkSmallInteger(_fdS);
+	fdS = __mkSmallInteger(_fdS);
-ptyName = __MKSTRING(slaveName);
+	ptyName = __MKSTRING(slaveName);
 }
 #   define PTY_IS_IMPLEMENTED 1
 #endif /* IRIX5 */
 extern char *ptsname();     /* also in #include <stdlib.h> */
 _fdM = open("/dev/ptmx", O_RDWR | O_NOCTTY);
 if (_fdM >= 0) {
-/*
+	/*
-** grantpt() changes owner, group and mode of the pseudo-tty
+	** grantpt() changes owner, group and mode of the pseudo-tty
-*/
+	*/
-grantpt(_fdM);
+	grantpt(_fdM);
-unlockpt(_fdM);
+	unlockpt(_fdM);
-slaveName = ptsname(_fdM);
+	slaveName = ptsname(_fdM);
-if (slaveName != NULL) {
+	if (slaveName != NULL) {
-/* printf("slave is: %s\n", slaveName); */
+	    /* printf("slave is: %s\n", slaveName); */
-_fdS = open(slaveName, O_RDWR);
+	    _fdS = open(slaveName, O_RDWR);
-if (_fdS < 0) {
+	    if (_fdS < 0) {
-(void)close(_fdM);
+		(void)close(_fdM);
-_fdS = _fdM = -1;
+		_fdS = _fdM = -1;
-}
+	    }
 #if defined(UNIXWARE) || defined(solaris)
-else {
+	    else {
-/* push terminal modules on stream */
+		/* push terminal modules on stream */
-ioctl(_fdS, I_PUSH, "ptem");
+		ioctl(_fdS, I_PUSH, "ptem");
-ioctl(_fdS, I_PUSH, "ldterm");
+		ioctl(_fdS, I_PUSH, "ldterm");
-}
+	    }
 #endif
-} else {
+	} else {
-(void)close(_fdM);
+	    (void)close(_fdM);
-_fdS = _fdM = -1;
+	    _fdS = _fdM = -1;
-}
+	}
 }
 if ((_fdM >= 0) && (_fdS >= 0)) {
-fdM = __mkSmallInteger(_fdM);
+	fdM = __mkSmallInteger(_fdM);
-fdS = __mkSmallInteger(_fdS);
+	fdS = __mkSmallInteger(_fdS);
-ptyName = __MKSTRING(slaveName);
+	ptyName = __MKSTRING(slaveName);
 }
 #   define PTY_IS_IMPLEMENTED 1
 #endif /* HAS_UNIX98_PTY */
 #if !defined(PTY_IS_IMPLEMENTED)
 len = sizeof(PTY_TEMPL) - 1;
 strncpy(line, PTY_TEMPL, sizeof(PTY_TEMPL));
 if (ttygid == -2) {
-struct group *gr;
+	struct group *gr;
-if ((gr = getgrnam("tty")) != NULL)
+	if ((gr = getgrnam("tty")) != NULL)
-ttygid = gr->gr_gid;
+	    ttygid = gr->gr_gid;
-else
+	else
-ttygid = -1;
+	    ttygid = -1;
 }
 for (cp1 = PTY_1_CHARS; *cp1; cp1++) {
-line[len-2] = * cp1;
+	line[len-2] = * cp1;
-for( cp2 = PTY_2_CHARS; *cp2; cp2++ ) {
+	for( cp2 = PTY_2_CHARS; *cp2; cp2++ ) {
-line[PT_INDEX] = 'p';
+	    line[PT_INDEX] = 'p';
-line[len-1] = *cp2;
+	    line[len-1] = *cp2;
-if ((_fdM = open(line, O_RDWR, 0)) < 0) {
+	    if ((_fdM = open(line, O_RDWR, 0)) < 0) {
-if (errno == ENOENT) {
+		if (errno == ENOENT) {
-_fdM = _fdS = -1;
+		    _fdM = _fdS = -1;
-goto getOutOfHere; /* out of ptys */
+		    goto getOutOfHere; /* out of ptys */
-}
+		}
-} else {
+	    } else {
-line[PT_INDEX] = 't';
+		line[PT_INDEX] = 't';
-/*
+		/*
-* try to set owner and mode.
+		 * try to set owner and mode.
-* this works only if running under root
+		 * this works only if running under root
-*/
+		 */
-(void) chown( line, getuid(), ttygid );
+		(void) chown( line, getuid(), ttygid );
-(void) chmod( line, S_IRUSR | S_IWUSR | S_IWGRP );
+		(void) chmod( line, S_IRUSR | S_IWUSR | S_IWGRP );
-if( (_fdS = open(line, O_RDWR, 0)) >= 0 ) {
+		if( (_fdS = open(line, O_RDWR, 0)) >= 0 ) {
-slaveName = line;
+		    slaveName = line;
-goto getOutOfHere; /* success */
+		    goto getOutOfHere; /* success */
-}
+		}
-(void) close(_fdM );
+		(void) close(_fdM );
-}
+	    }
-}
+	}
 }
 getOutOfHere: ;
 if ((_fdM >= 0) && (_fdS >= 0)) {
-fdM = __mkSmallInteger(_fdM);
+	fdM = __mkSmallInteger(_fdM);
-fdS = __mkSmallInteger(_fdS);
+	fdS = __mkSmallInteger(_fdS);
-ptyName = __MKSTRING(slaveName);
+	ptyName = __MKSTRING(slaveName);
 }
 #endif /* ! defined(PTY_IS_IMPLEMENTED) */
 %}.
 fdM notNil ifTrue:[
-^ Array with:fdM with:fdS with:ptyName.
+	^ Array with:fdM with:fdS with:ptyName.
 ].
 ^ nil
 !
 %{
 int fds[2];
 if (pipe(fds) < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(errno);
+	@global(LastErrorNumber) = __mkSmallInteger(errno);
-RETURN ( nil );
+	RETURN ( nil );
 }
 fd1 = __mkSmallInteger(fds[0]);
 fd2 = __mkSmallInteger(fds[1]);
 %}.
 fd1 notNil ifTrue:[
-^ Array with:fd1 with:fd2.
+	^ Array with:fd1 with:fd2.
 ].
 ^ nil
 !
 resetTerminalInputOutputModes:fd
 %{
 struct termios switcher;
 printf("setMappingMaster fd:%d\n", (int)__intVal(fd));
 if (__isSmallInteger(fd)) {
-if (tcgetattr( __intVal(fd), &switcher) < 0) RETURN (false);
+	if (tcgetattr( __intVal(fd), &switcher) < 0) RETURN (false);
-switcher.c_iflag = 0;
+	switcher.c_iflag = 0;
-switcher.c_oflag = 0;
+	switcher.c_oflag = 0;
-if (tcsetattr( __intVal(fd), TCSANOW, &switcher) >= 0) {
+	if (tcsetattr( __intVal(fd), TCSANOW, &switcher) >= 0) {
-RETURN (true);
+	    RETURN (true);
-}
+	}
 }
 %}.
 ^ false
 !
 struct winsize wsize;
 if (__isSmallInteger(fd)
 && __isSmallInteger(w)
 && __isSmallInteger(h)) {
-wsize.ws_row = (unsigned short)__intVal(h);
+	wsize.ws_row = (unsigned short)__intVal(h);
-wsize.ws_col = (unsigned short)__intVal(w);
+	wsize.ws_col = (unsigned short)__intVal(w);
-if (ioctl(__intVal(fd), TIOCSWINSZ, (char *)&wsize) >= 0) {
+	if (ioctl(__intVal(fd), TIOCSWINSZ, (char *)&wsize) >= 0) {
-RETURN (true);
+	    RETURN (true);
-}
+	}
 }
 #endif
 %}.
 ^ false
 !
 we will send no more data to the pipe, i.e. EOF is reached"
 %{
 #ifndef NO_SOCKET
 if (__isSmallInteger(fileDescriptor)) {
-shutdown(__smallIntegerVal(fileDescriptor), 1);
+	shutdown(__smallIntegerVal(fileDescriptor), 1);
-RETURN(self);
+	RETURN(self);
 }
 #endif
 %}.
 self primitiveFailed
 ! !
 !UnixOperatingSystem class methodsFor:'misc'!
 closeLeftOverFiles
 "a bad bad kludge and workaround for a big bug in the linux
 getAddrInfo implementation:
-if it gets interrupted (via a timer, for example), its domain-name
+	if it gets interrupted (via a timer, for example), its domain-name
-socket remains open and is NEVER closed.
+	socket remains open and is NEVER closed.
-These open files collect up and lead to no-more-files eventually.
+	These open files collect up and lead to no-more-files eventually.
 Invoking this method helps in this situation."
 |p|
 p := PipeStream
-readingFrom:('lsof -p ' , (OperatingSystem getProcessId printString)).
+	    readingFrom:('lsof -p ' , (OperatingSystem getProcessId printString)).
 p linesDo:[:line |
-|words fd|
+	|words fd|
-words := line asCollectionOfWords.
+	words := line asCollectionOfWords.
-"/ COMMAND PID USER   FD   TYPE     DEVICE    SIZE    NODE NAME
+	"/ COMMAND PID USER   FD   TYPE     DEVICE    SIZE    NODE NAME
-words first = 'stx' ifTrue:[
+	words first = 'stx' ifTrue:[
-words second = (OperatingSystem getProcessId printString) ifTrue:[
+	    words second = (OperatingSystem getProcessId printString) ifTrue:[
-(words fourth endsWith:'u') ifTrue:[
+		(words fourth endsWith:'u') ifTrue:[
-(words fifth = 'IPv4') ifTrue:[
+		    (words fifth = 'IPv4') ifTrue:[
-(words seventh = 'UDP') ifTrue:[
+			(words seventh = 'UDP') ifTrue:[
-(words last endsWith:'domain') ifTrue:[
+			    (words last endsWith:'domain') ifTrue:[
-fd := Number readFrom:(words fourth copyButLast).
+				fd := Number readFrom:(words fourth copyButLast).
 Transcript showCR:line.
-OperatingSystem closeFd:fd.
+				OperatingSystem closeFd:fd.
-]
+			    ]
-]
+			]
-]
+		    ]
-]
+		]
-]
+	    ]
-]
+	]
 ].
 p close.
 "
 self closeLeftOverFiles
 %{
 int dupFd;
 if (__isSmallInteger(aFileDescriptor)) {
-dupFd = dup(__smallIntegerVal(aFileDescriptor));
+	dupFd = dup(__smallIntegerVal(aFileDescriptor));
-if (dupFd >= 0) {
+	if (dupFd >= 0) {
-RETURN(__mkSmallInteger(dupFd));
+	    RETURN(__mkSmallInteger(dupFd));
-}
+	}
 }
 %}.
 ^ self primitiveFailed.
 !
 !
 getDomainName
 "return the domain this host is in.
 Notice:
-not all systems support this; on some, #unknown is returned."
+	not all systems support this; on some, #unknown is returned."
 |domainName idx hostName primDomainName|
 "/ use cached value, if present
 (DomainName notNil and:[DomainName ~~ #unknown]) ifTrue:[
-^ DomainName
+	^ DomainName
 ].
 primDomainName := domainName := self primGetDomainName.
 domainName = '(none)' ifTrue:[
-domainName := nil.
+	domainName := nil.
 ].
 domainName isEmptyOrNil ifTrue:[
-"sometimes, we can extract the domainName from the hostName ..."
+	"sometimes, we can extract the domainName from the hostName ..."
-hostName := self primGetHostName.
+	hostName := self primGetHostName.
-hostName notNil ifTrue:[
+	hostName notNil ifTrue:[
-idx := hostName indexOf:$..
+	    idx := hostName indexOf:$..
-idx ~~ 0 ifTrue:[
+	    idx ~~ 0 ifTrue:[
-domainName := hostName copyFrom:idx+1.
+		domainName := hostName copyFrom:idx+1.
-]
+	    ]
-].
+	].
-domainName isEmptyOrNil ifTrue:[
+	domainName isEmptyOrNil ifTrue:[
-"/ fallBack
+	    "/ fallBack
-domainName := self getEnvironment:'DOMAIN'.
+	    domainName := self getEnvironment:'DOMAIN'.
-"if #primGetDomainName did work, /bin/domainname would return the same result"
+	    "if #primGetDomainName did work, /bin/domainname would return the same result"
-(domainName isNil and:[primDomainName isNil]) ifTrue:[
+	    (domainName isNil and:[primDomainName isNil]) ifTrue:[
-domainName := self getCommandOutputFrom:'/bin/domainname'.
+		domainName := self getCommandOutputFrom:'/bin/domainname'.
-(domainName isEmptyOrNil or:[ domainName = '(none)' ]) ifTrue:[
+		(domainName isEmptyOrNil or:[ domainName = '(none)' ]) ifTrue:[
-domainName := nil.
+		    domainName := nil.
-].
+		].
-].
+	    ].
-domainName isNil ifTrue:[
+	    domainName isNil ifTrue:[
-DomainName ~~ #unknown ifTrue:[
+		DomainName ~~ #unknown ifTrue:[
-"/ only warn once - the warning can be ignored, if you do not use the domain name
+		    "/ only warn once - the warning can be ignored, if you do not use the domain name
-ObjectMemory debugPrinting ifTrue:[
+		    ObjectMemory debugPrinting ifTrue:[
-'UnixOperatingSystem [info]: cannot find out domainname' infoPrintCR.
+			'UnixOperatingSystem [info]: cannot find out domainname' infoPrintCR.
-].
+		    ].
-].
+		].
-domainName := #unknown.
+		domainName := #unknown.
-].
+	    ].
-].
+	].
 ].
 "cache, because domainName fetching may be expensive;
 but if unknown, it will be tried again"
 DomainName := domainName.
 /*
 * get the size of the environment
 */
 if (environ) {
-for (env = environ; *env; env++) {
+	for (env = environ; *env; env++) {
-nEnv++;
+	    nEnv++;
-}
+	}
 }
 /*
 * allcate an array for keys and values
 */
 resultArray = __ARRAY_NEW_INT(nEnv * 2);
 if (resultArray == nil) {
-error = @symbol(allocationFailure);
+	error = @symbol(allocationFailure);
-goto bad;
+	goto bad;
 }
 if (environ) {
-int envIndex;
+	int envIndex;
-for (env = environ, envIndex = 0; *env; env++) {
+	for (env = environ, envIndex = 0; *env; env++) {
-OBJ t;
+	    OBJ t;
-char *separatorPtr;
+	    char *separatorPtr;
-separatorPtr = strchr(*env, '=');
+	    separatorPtr = strchr(*env, '=');
-t = __MKSTRING_L(*env, separatorPtr-*env);
+	    t = __MKSTRING_L(*env, separatorPtr-*env);
-__arrayVal(resultArray)[envIndex++] = t;
+	    __arrayVal(resultArray)[envIndex++] = t;
-__STORE(resultArray, t);
+	    __STORE(resultArray, t);
-if (separatorPtr == 0) {
+	    if (separatorPtr == 0) {
-t = nil;
+		t = nil;
-} else {
+	    } else {
-t = __MKSTRING(separatorPtr+1);
+		t = __MKSTRING(separatorPtr+1);
-}
+	    }
-__arrayVal(resultArray)[envIndex++] = t;
+	    __arrayVal(resultArray)[envIndex++] = t;
-__STORE(resultArray, t);
+	    __STORE(resultArray, t);
-}
+	}
 }
 bad:;
 %}.
 error notNil ifTrue:[
-^ self primitiveFailed:error.
+	^ self primitiveFailed:error.
 ].
 sz := resultArray size.
 dict := Dictionary new:(sz // 2).
 1 to:sz by:2 do:[:i |
-|key|
+	|key|
-key := resultArray at:i.
+	key := resultArray at:i.
-key notNil ifTrue:[
+	key notNil ifTrue:[
-"same behavior as getenv() - the first entry takes precedence"
+	    "same behavior as getenv() - the first entry takes precedence"
-(dict includesKey:key) ifFalse:[
+	    (dict includesKey:key) ifFalse:[
-dict at:key put:(resultArray at:i+1)
+		dict at:key put:(resultArray at:i+1)
-].
+	    ].
-].
+	].
 ].
 ^ dict
 "
 OperatingSystem getEnvironment
 %{  /* NOCONTEXT */
 extern char *getenv();
 if (__isStringLike(aStringOrSymbol)) {
-char *env =  getenv(__stringVal(aStringOrSymbol));
+	char *env =  getenv(__stringVal(aStringOrSymbol));
-if (env) {
+	if (env) {
-RETURN ( __MKSTRING(env) );
+	    RETURN ( __MKSTRING(env) );
-}
+	}
-RETURN ( nil );
+	RETURN ( nil );
 }
 %}.
 ^ self primitiveFailed
 "
 The host name returned is fully qualified - if returned so by the system."
 |hostName|
 (HostName notNil and:[HostName ~~ #unknown]) ifTrue:[
-^ HostName
+	^ HostName
 ].
 hostName := self primGetHostName.
 hostName isNil ifTrue:[
-"fallBack - in non-antique systes we never come here"
+	"fallBack - in non-antique systes we never come here"
-hostName := self getEnvironment:'HOST'.
+	hostName := self getEnvironment:'HOST'.
-hostName isNil ifTrue:[
+	hostName isNil ifTrue:[
-hostName := self getCommandOutputFrom:'/bin/hostname'
+	    hostName := self getCommandOutputFrom:'/bin/hostname'
-].
+	].
-hostName isNil ifTrue:[
+	hostName isNil ifTrue:[
-HostName ~~ #unknown ifTrue:[
+	    HostName ~~ #unknown ifTrue:[
-'UnixOperatingSystem [info]: cannot find out hostname' infoPrintCR.
+		'UnixOperatingSystem [info]: cannot find out hostname' infoPrintCR.
-hostName := #unknown.
+		hostName := #unknown.
-].
+	    ].
-].
+	].
 ].
 "cache, because hostname fetching may be expensive;
 but if unknown, it will be tried again"
 HostName := hostName.
 getLocaleInfo
 "return a dictionary filled with values from the locale information;
 Not all fields may be present, depending on the OS's setup and capabilities.
 Possible fields are:
-decimalPoint                    <String>
+	decimalPoint                    <String>
-thousandsSep                    <String>
+	thousandsSep                    <String>
-internationalCurrencySymbol     <String>
+	internationalCurrencySymbol     <String>
-currencySymbol                  <String>
+	currencySymbol                  <String>
-monetaryDecimalPoint            <String>
+	monetaryDecimalPoint            <String>
-monetaryThousandsSeparator      <String>
+	monetaryThousandsSeparator      <String>
-positiveSign                    <String>
+	positiveSign                    <String>
-negativeSign                    <String>
+	negativeSign                    <String>
-internationalFractionalDigits   <Integer>
+	internationalFractionalDigits   <Integer>
-fractionalDigits                <Integer>
+	fractionalDigits                <Integer>
-positiveSignPrecedesCurrencySymbol      <Boolean>
+	positiveSignPrecedesCurrencySymbol      <Boolean>
-negativeSignPrecedesCurrencySymbol      <Boolean>
+	negativeSignPrecedesCurrencySymbol      <Boolean>
-positiveSignSeparatedBySpaceFromCurrencySymbol  <Boolean>
+	positiveSignSeparatedBySpaceFromCurrencySymbol  <Boolean>
-negativeSignSeparatedBySpaceFromCurrencySymbol  <Boolean>
+	negativeSignSeparatedBySpaceFromCurrencySymbol  <Boolean>
-positiveSignPosition                            <Symbol>
+	positiveSignPosition                            <Symbol>
-one of: #parenthesesAround,
+							one of: #parenthesesAround,
-#signPrecedes,
+								#signPrecedes,
-#signSuceeds,
+								#signSuceeds,
-#signPrecedesCurrencySymbol,
+								#signPrecedesCurrencySymbol,
-#signSuceedsCurrencySymbol
+								#signSuceedsCurrencySymbol
-negativeSignPosition                            <like above>
+	negativeSignPosition                            <like above>
 it is up to the application to deal with undefined values.
 Notice, that (for now), the system does not use this information;
 it should be used by applications as required.
 "
 |info val|
 LocaleInfo notNil ifTrue:[
-"/ return the internal info; useful on systems which do not
+	"/ return the internal info; useful on systems which do not
-"/ support this.
+	"/ support this.
-^ LocaleInfo
+	^ LocaleInfo
 ].
 info := IdentityDictionary new.
 %{
 char *decimalPoint;         /* something like "." (US) or "," (german) */
 int   csNegPrecedes;        /* money: 1 if currency symbol precedes a negative value; 0 if it sceeds */
 int   csPosSepBySpace;      /* money: 1 if currency symbol should be separated by a space from a positive value; 0 if no space */
 int   csNegSepBySpace;      /* money: 1 if currency symbol should be separated by a space from a negative value; 0 if no space */
 int   csPosSignPosition;    /* money: 0: ()'s around the value & currency symbol */
 int   csNegSignPosition;    /*        1: sign precedes the value & currency symbol */
-/*        2: sign succeeds the value & currency symbol */
+				/*        2: sign succeeds the value & currency symbol */
-/*        3: sign immediately precedes the currency symbol */
+				/*        3: sign immediately precedes the currency symbol */
-/*        4: sign immediately suceeds the currency symbol */
+				/*        4: sign immediately suceeds the currency symbol */
 #if defined(HAS_LOCALECONV)
 struct lconv *conf;
 conf = localeconv();
 if (conf) {
-decimalPoint = conf->decimal_point;
+	decimalPoint = conf->decimal_point;
-thousandsSep = conf->thousands_sep;
+	thousandsSep = conf->thousands_sep;
-intCurrencySymbol = conf->int_curr_symbol;
+	intCurrencySymbol = conf->int_curr_symbol;
-currencySymbol = conf->currency_symbol;
+	currencySymbol = conf->currency_symbol;
-monDecimalPoint = conf->mon_decimal_point;
+	monDecimalPoint = conf->mon_decimal_point;
-monThousandsSep = conf->mon_thousands_sep;
+	monThousandsSep = conf->mon_thousands_sep;
-positiveSign = conf->positive_sign;
+	positiveSign = conf->positive_sign;
-negativeSign = conf->negative_sign;
+	negativeSign = conf->negative_sign;
-intFractDigits = conf->int_frac_digits;
+	intFractDigits = conf->int_frac_digits;
-fractDigits = conf->frac_digits;
+	fractDigits = conf->frac_digits;
-csPosPrecedes = conf->p_cs_precedes;
+	csPosPrecedes = conf->p_cs_precedes;
-csNegPrecedes = conf->n_cs_precedes;
+	csNegPrecedes = conf->n_cs_precedes;
-csPosSepBySpace = conf->p_sep_by_space;
+	csPosSepBySpace = conf->p_sep_by_space;
-csNegSepBySpace = conf->n_sep_by_space;
+	csNegSepBySpace = conf->n_sep_by_space;
-csPosSignPosition = conf->p_sign_posn;
+	csPosSignPosition = conf->p_sign_posn;
-csNegSignPosition = conf->n_sign_posn;
+	csNegSignPosition = conf->n_sign_posn;
 }
 #else
 decimalPoint = (char *)0;
 thousandsSep = (char *)0;
 intCurrencySymbol = (char *)0;
 csNegSepBySpace = -1;
 csPosSignPosition = -1;
 csNegSignPosition = -1;
 #endif
 if (decimalPoint) {
-val = __MKSTRING(decimalPoint);
+	val = __MKSTRING(decimalPoint);
-__AT_PUT_(info, @symbol(decimalPoint), val);
+	__AT_PUT_(info, @symbol(decimalPoint), val);
 }
 if (thousandsSep) {
-val = __MKSTRING(thousandsSep);
+	val = __MKSTRING(thousandsSep);
-__AT_PUT_(info, @symbol(thousandsSeparator), val);
+	__AT_PUT_(info, @symbol(thousandsSeparator), val);
 }
 if (intCurrencySymbol) {
-val = __MKSTRING(intCurrencySymbol);
+	val = __MKSTRING(intCurrencySymbol);
-__AT_PUT_(info, @symbol(internationCurrencySymbol), val);
+	__AT_PUT_(info, @symbol(internationCurrencySymbol), val);
 }
 if (currencySymbol) {
-val = __MKSTRING(currencySymbol);
+	val = __MKSTRING(currencySymbol);
-__AT_PUT_(info, @symbol(currencySymbol), val);
+	__AT_PUT_(info, @symbol(currencySymbol), val);
 }
 if (monDecimalPoint) {
-val = __MKSTRING(monDecimalPoint);
+	val = __MKSTRING(monDecimalPoint);
-__AT_PUT_(info, @symbol(monetaryDecimalPoint), val);
+	__AT_PUT_(info, @symbol(monetaryDecimalPoint), val);
 }
 if (monThousandsSep) {
-val = __MKSTRING(monThousandsSep);
+	val = __MKSTRING(monThousandsSep);
-__AT_PUT_(info, @symbol(monetaryThousandsSeparator), val);
+	__AT_PUT_(info, @symbol(monetaryThousandsSeparator), val);
 }
 if (positiveSign) {
-val = __MKSTRING(positiveSign);
+	val = __MKSTRING(positiveSign);
-__AT_PUT_(info, @symbol(positiveSign), val);
+	__AT_PUT_(info, @symbol(positiveSign), val);
 }
 if (negativeSign) {
-val = __MKSTRING(negativeSign);
+	val = __MKSTRING(negativeSign);
-__AT_PUT_(info, @symbol(negativeSign), val);
+	__AT_PUT_(info, @symbol(negativeSign), val);
 }
 if (intFractDigits >= 0) {
-__AT_PUT_(info, @symbol(internationalFractionalDigits),  __mkSmallInteger(intFractDigits));
+	__AT_PUT_(info, @symbol(internationalFractionalDigits),  __mkSmallInteger(intFractDigits));
 }
 if (fractDigits >= 0) {
-__AT_PUT_(info, @symbol(fractionalDigits),  __mkSmallInteger(fractDigits));
+	__AT_PUT_(info, @symbol(fractionalDigits),  __mkSmallInteger(fractDigits));
 }
 if (csPosPrecedes >= 0) {
-if (csPosPrecedes == 0) {
+	if (csPosPrecedes == 0) {
-val = false;
+	    val = false;
-} else {
+	} else {
-val = true;
+	    val = true;
-}
+	}
-__AT_PUT_(info, @symbol(positiveSignPrecedesCurrencySymbol), val );
+	__AT_PUT_(info, @symbol(positiveSignPrecedesCurrencySymbol), val );
 }
 if (csNegPrecedes >= 0) {
-if (csNegPrecedes == 0) {
+	if (csNegPrecedes == 0) {
-val = false;
+	    val = false;
-} else {
+	} else {
-val = true;
+	    val = true;
-}
+	}
-__AT_PUT_(info, @symbol(negativeSignPrecedesCurrencySymbol), val );
+	__AT_PUT_(info, @symbol(negativeSignPrecedesCurrencySymbol), val );
 }
 if (csPosSepBySpace >= 0) {
-if (csPosSepBySpace == 0) {
+	if (csPosSepBySpace == 0) {
-val = false;
+	    val = false;
-} else {
+	} else {
-val = true;
+	    val = true;
-}
+	}
-__AT_PUT_(info, @symbol(positiveSignSeparatedBySpaceFromCurrencySymbol), val);
+	__AT_PUT_(info, @symbol(positiveSignSeparatedBySpaceFromCurrencySymbol), val);
 }
 if (csNegSepBySpace >= 0) {
-if (csNegSepBySpace == 0) {
+	if (csNegSepBySpace == 0) {
-val = false;
+	    val = false;
-} else {
+	} else {
-val = true;
+	    val = true;
-}
+	}
-__AT_PUT_(info, @symbol(negativeSignSeparatedBySpaceFromCurrencySymbol), val);
+	__AT_PUT_(info, @symbol(negativeSignSeparatedBySpaceFromCurrencySymbol), val);
 }
 switch (csPosSignPosition) {
-case 0:
+	case 0:
-val = @symbol(parenthesesAround);
+	    val = @symbol(parenthesesAround);
-break;
+	    break;
-case 1:
+	case 1:
-val = @symbol(signPrecedes);
+	    val = @symbol(signPrecedes);
-break;
+	    break;
-case 2:
+	case 2:
-val = @symbol(signSuceeds);
+	    val = @symbol(signSuceeds);
-break;
+	    break;
-case 3:
+	case 3:
-val = @symbol(signPrecedesCurrencySymbol);
+	    val = @symbol(signPrecedesCurrencySymbol);
-break;
+	    break;
-case 4:
+	case 4:
-val = @symbol(signSuceedsCurrencySymbol);
+	    val = @symbol(signSuceedsCurrencySymbol);
-break;
+	    break;
-default:
+	default:
-val = nil;
+	    val = nil;
 }
 if (val != nil) {
-__AT_PUT_(info, @symbol(positiveSignPosition), val);
+	__AT_PUT_(info, @symbol(positiveSignPosition), val);
 }
 switch (csNegSignPosition) {
-case 0:
+	case 0:
-val = @symbol(parenthesesAround);
+	    val = @symbol(parenthesesAround);
-break;
+	    break;
-case 1:
+	case 1:
-val = @symbol(signPrecedes);
+	    val = @symbol(signPrecedes);
-break;
+	    break;
-case 2:
+	case 2:
-val = @symbol(signSuceeds);
+	    val = @symbol(signSuceeds);
-break;
+	    break;
-case 3:
+	case 3:
-val = @symbol(signPrecedesCurrencySymbol);
+	    val = @symbol(signPrecedesCurrencySymbol);
-break;
+	    break;
-case 4:
+	case 4:
-val = @symbol(signSuceedsCurrencySymbol);
+	    val = @symbol(signSuceedsCurrencySymbol);
-break;
+	    break;
-default:
+	default:
-val = nil;
+	    val = nil;
 }
 if (val != nil) {
-__AT_PUT_(info, @symbol(negativeSignPosition), val);
+	__AT_PUT_(info, @symbol(negativeSignPosition), val);
 }
 %}.
 ^ info
 "
 "Created: 23.12.1995 / 14:19:20 / cg"
 !
 getNetworkAddressInfo
 "return a Dictionary of network interface information.
-key -> name of interface
+	key -> name of interface
-value -> a Set of network address
+	value -> a Set of network address
-information for the interface - a dictionaries containing the
+		information for the interface - a dictionaries containing the
-information about the configuration of each interface in the system.
+		information about the configuration of each interface in the system.
-The dictionary keys are:
+		The dictionary keys are:
-#address
+		    #address
-#netmask
+		    #netmask
-#flags
+		    #flags
-#destAddress"
+		    #destAddress"
 |returnArray addressArray nameArray noOfIf retDictionary error retIndex|
 noOfIf := 0.
 int n_ifa = 0;
 int retI = 0;
 OBJ t;
 if (getifaddrs(&ifap) < 0) {
-error = __MKSTRING("getifaddrs() failed");
+	error = __MKSTRING("getifaddrs() failed");
-goto out;
+	goto out;
 }
 for (ifaLoop = ifap; ifaLoop != 0; ifaLoop = ifaLoop->ifa_next) n_ifa++;
 returnArray = __ARRAY_NEW_INT(n_ifa*5);
 if (returnArray == nil) {
-/* Creating a string wouldn't work here */
+	/* Creating a string wouldn't work here */
-error = @symbol(allocationFailure);
+	error = @symbol(allocationFailure);
-goto bad;
+	goto bad;
 }
 for (ifaLoop = ifap; ifaLoop != 0; ifaLoop = ifaLoop->ifa_next) {
-int family, len;
+	int family, len;
-if (ifaLoop->ifa_addr == 0)
+	if (ifaLoop->ifa_addr == 0)
-continue;
+	       continue;
-family = ifaLoop->ifa_addr->sa_family;
+	family = ifaLoop->ifa_addr->sa_family;
-switch (family) {
+	switch (family) {
-case AF_INET:
+	case AF_INET:
-len = sizeof(struct sockaddr_in);
+	    len = sizeof(struct sockaddr_in);
-break;
+	    break;
-case AF_INET6:
+	case AF_INET6:
-len = sizeof(struct sockaddr_in6);
+	    len = sizeof(struct sockaddr_in6);
-break;
+	    break;
 #if 0
-case AF_PACKET:
+	case AF_PACKET:
-len = sizeof(sockaddr_ll);
+	    len = sizeof(sockaddr_ll);
-break;
+	    break;
 #endif
-default:
+	default:
-/* skip */
+	    /* skip */
-continue;
+	    continue;
-};
+	};
-t = __MKSTRING(ifaLoop->ifa_name);
+	t = __MKSTRING(ifaLoop->ifa_name);
-__arrayVal(returnArray)[retI++] = t; __STORE(returnArray, t);
+	__arrayVal(returnArray)[retI++] = t; __STORE(returnArray, t);
-t = __MKUINT(ifaLoop->ifa_flags);
+	t = __MKUINT(ifaLoop->ifa_flags);
-__arrayVal(returnArray)[retI++] = t; __STORE(returnArray, t);
+	__arrayVal(returnArray)[retI++] = t; __STORE(returnArray, t);
-t = __MKBYTEARRAY((char *)ifaLoop->ifa_addr, len);
+	t = __MKBYTEARRAY((char *)ifaLoop->ifa_addr, len);
-__arrayVal(returnArray)[retI++] = t; __STORE(returnArray, t);
+	__arrayVal(returnArray)[retI++] = t; __STORE(returnArray, t);
-if (ifaLoop->ifa_netmask != 0) {
+	if (ifaLoop->ifa_netmask != 0) {
-t = __MKBYTEARRAY((char *)ifaLoop->ifa_netmask, len);
+	    t = __MKBYTEARRAY((char *)ifaLoop->ifa_netmask, len);
-__arrayVal(returnArray)[retI] = t; __STORE(returnArray, t);
+	    __arrayVal(returnArray)[retI] = t; __STORE(returnArray, t);
-}
+	}
-retI++;
+	retI++;
-if (ifaLoop->ifa_dstaddr != 0) {
+	if (ifaLoop->ifa_dstaddr != 0) {
-t = __MKBYTEARRAY((char *)ifaLoop->ifa_dstaddr, len);
+	    t = __MKBYTEARRAY((char *)ifaLoop->ifa_dstaddr, len);
-__arrayVal(returnArray)[retI] = t; __STORE(returnArray, t);
+	    __arrayVal(returnArray)[retI] = t; __STORE(returnArray, t);
-}
+	}
-retI++;
+	retI++;
 }
 noOfIf = __mkSmallInteger(n_ifa);
 bad:
 ** Open an INET socket
 */
 afinet_socket = socket(AF_INET, SOCK_DGRAM, 0);
 if (afinet_socket < 0) {
-goto bad;
+	goto bad;
 }
 /*
 ** Get the list of network interfaces
 */
 ifc.ifc_len = sizeof (buf);
 ifc.ifc_buf = (caddr_t) buf;
 if (ioctl (afinet_socket, SIOCGIFCONF, (caddr_t) &ifc) < 0) {
-close(afinet_socket);
+	close(afinet_socket);
-error = __MKSTRING("ioctl(SIOCGIFCONF) failed");
+	error = __MKSTRING("ioctl(SIOCGIFCONF) failed");
-goto bad;
+	goto bad;
 }
 n_ifs = ifc.ifc_len / sizeof (struct ifreq);
 nameArray    = __ARRAY_NEW_INT(n_ifs);
 addressArray = __ARRAY_NEW_INT(n_ifs);
 if (nameArray == nil || addressArray == nil) {
-/* Creating a string wouldn/t work here */
+	/* Creating a string wouldn/t work here */
-error = @symbol(allocationFailure);
+	error = @symbol(allocationFailure);
-goto bad;
+	goto bad;
 }
 /*
 ** Iterate of the list of the system's netif. Find all
 ** active interfaces and their ethernet addresses
 */
 countOfIf = 0;
 for (i=0, ifr = ifc.ifc_req; i < n_ifs; i++, ifr++) {
-/*
+	/*
-** Get address for this interface
+	** Get address for this interface
-*/
+	*/
-memset (&ifreq, 0, sizeof(ifreq));
+	memset (&ifreq, 0, sizeof(ifreq));
-memcpy (ifreq.ifr_name, ifr->ifr_name, sizeof(ifr->ifr_name));
+	memcpy (ifreq.ifr_name, ifr->ifr_name, sizeof(ifr->ifr_name));
-if (ioctl (afinet_socket, SIOCGIFADDR, &ifreq) >= 0) {
+	if (ioctl (afinet_socket, SIOCGIFADDR, &ifreq) >= 0) {
-t = __MKBYTEARRAY((char *)&ifreq.ifr_addr, sizeof(ifreq.ifr_addr));
+	    t = __MKBYTEARRAY((char *)&ifreq.ifr_addr, sizeof(ifreq.ifr_addr));
-__arrayVal(addressArray)[countOfIf] = t; __STORE(addressArray, t);
+	    __arrayVal(addressArray)[countOfIf] = t; __STORE(addressArray, t);
-t = __MKSTRING(&ifreq.ifr_name);
+	    t = __MKSTRING(&ifreq.ifr_name);
-__arrayVal(nameArray)[countOfIf] = t; __STORE(nameArray, t);
+	    __arrayVal(nameArray)[countOfIf] = t; __STORE(nameArray, t);
-countOfIf++;
+	    countOfIf++;
-} else {
+	} else {
-if (@global(InfoPrinting) == true) {
+	    if (@global(InfoPrinting) == true) {
-fprintf(stderr, "OS [warning]: SIOCGIFADDR failed: %d\n", errno);
+		fprintf(stderr, "OS [warning]: SIOCGIFADDR failed: %d\n", errno);
-}
+	    }
-}
+	}
-error = __MKSTRING("ioctl(SIOCGIFCONF) failed");
+	error = __MKSTRING("ioctl(SIOCGIFCONF) failed");
 }
 noOfIf = __mkSmallInteger(countOfIf);
 bad:
 if (afinet_socket >= 0)
-close(afinet_socket);
+	close(afinet_socket);
 #else
 error = @symbol(notSupported);
 #endif /* defined(SIOCGIFADDR) */
 out:;
 %}.
 retDictionary := Dictionary new:noOfIf.
 error notNil ifTrue:[
-self primitiveFailed:error.
+	self primitiveFailed:error.
-"return empty dictionary if proceeding from error"
+	"return empty dictionary if proceeding from error"
-^  retDictionary.
+	^  retDictionary.
 ].
 retIndex := 1.
 1 to:noOfIf do:[:cnt|
-|name addressBytes set dict|
+	|name addressBytes set dict|
-name := returnArray at:retIndex.
+	name := returnArray at:retIndex.
-addressBytes := returnArray at:retIndex+2.
+	addressBytes := returnArray at:retIndex+2.
-addressBytes notNil ifTrue:[
+	addressBytes notNil ifTrue:[
-set := retDictionary at:name ifAbsentPut:[Set new].
+	    set := retDictionary at:name ifAbsentPut:[Set new].
-dict := Dictionary new:5.
+	    dict := Dictionary new:5.
-dict at:#flags put:(returnArray at:retIndex+1).
+	    dict at:#flags put:(returnArray at:retIndex+1).
-dict at:#address put:(SocketAddress fromBytes:addressBytes).
+	    dict at:#address put:(SocketAddress fromBytes:addressBytes).
-addressBytes := returnArray at:retIndex+3.
+	    addressBytes := returnArray at:retIndex+3.
-addressBytes notNil ifTrue:[
+	    addressBytes notNil ifTrue:[
-dict at:#netMask put:(SocketAddress fromBytes:addressBytes).
+		dict at:#netMask put:(SocketAddress fromBytes:addressBytes).
-].
+	    ].
-addressBytes := returnArray at:retIndex+4.
+	    addressBytes := returnArray at:retIndex+4.
-addressBytes notNil ifTrue:[
+	    addressBytes notNil ifTrue:[
-dict at:#destAddress put:(SocketAddress fromBytes:addressBytes).
+		dict at:#destAddress put:(SocketAddress fromBytes:addressBytes).
-].
+	    ].
-set add:dict.
+	    set add:dict.
-].
+	].
-retIndex := retIndex + 5.
+	retIndex := retIndex + 5.
 ].
 ^ retDictionary
 "
 "
 !
 getNetworkAddresses
 "return a dictionary filled with
-key -> name of interface
+	key -> name of interface
-value -> the socket adress of the interface
+	value -> the socket adress of the interface
 for each interface"
 |addressArray nameArray noOfIf retDictionary error|
 noOfIf := 0.
 ** Open an INET socket
 */
 afinet_socket = socket(AF_INET, SOCK_DGRAM, 0);
 if (afinet_socket < 0) {
-error = __MKSTRING("Cannot open socket");
+	error = __MKSTRING("Cannot open socket");
-goto bad;
+	goto bad;
 }
 /*
 ** Get the list of network interfaces
 */
 ifc.ifc_len = sizeof (buf);
 ifc.ifc_buf = (caddr_t) buf;
 if (ioctl (afinet_socket, SIOCGIFCONF, (caddr_t) &ifc) < 0) {
-close(afinet_socket);
+	close(afinet_socket);
-error = __MKSTRING("ioctl(SIOCGIFCONF) failed");
+	error = __MKSTRING("ioctl(SIOCGIFCONF) failed");
-goto bad;
+	goto bad;
 }
 // get the number of interfaces in the returned structure
 // cg: sigh
 // see also 2nd loop below
 #ifndef __osx__
 n_ifs = ifc.ifc_len / sizeof (struct ifreq);
 #else
 {
-unsigned char *cp = buf;
+	unsigned char *cp = buf;
-char *limit = buf + ifc.ifc_len;
+	char *limit = buf + ifc.ifc_len;
-n_ifs = 0;
+	n_ifs = 0;
-while (cp < limit) {
+	while (cp < limit) {
-int sz;
+	    int sz;
-ifr = (struct ifreq *)cp;
+	    ifr = (struct ifreq *)cp;
-sz = IFNAMSIZ + ifr->ifr_addr.sa_len;
+	    sz = IFNAMSIZ + ifr->ifr_addr.sa_len;
-cp += sz;
+	    cp += sz;
-n_ifs++;
+	    n_ifs++;
-}
+	}
 }
 #endif
 nameArray    = __ARRAY_NEW_INT(n_ifs);
 addressArray = __ARRAY_NEW_INT(n_ifs);
 if (nameArray == nil || addressArray == nil) {
-/* Creating a string wouldn/t work here */
+	/* Creating a string wouldn/t work here */
-error = @symbol(allocationFailure);
+	error = @symbol(allocationFailure);
-goto bad;
+	goto bad;
 }
 /*
 ** Iterate of the list of the system's netif. Find all
 ** active interfaces and their ethernet addresses
 */
 countOfIf = 0;
 for (i=0, ifr = ifc.ifc_req; i < n_ifs; i++) {
-/*
+	/*
-** Get Flags for this interface
+	** Get Flags for this interface
-*/
+	*/
-memcpy(&ifreq, ifr, sizeof(ifreq));
+	memcpy(&ifreq, ifr, sizeof(ifreq));
-/*
+	/*
-** Get address for this interface
+	** Get address for this interface
-*/
+	*/
-memcpy(&ifreq, ifr, sizeof(ifreq));
+	memcpy(&ifreq, ifr, sizeof(ifreq));
-if (ioctl (afinet_socket, SIOCGIFADDR, &ifreq) >= 0) {
+	if (ioctl (afinet_socket, SIOCGIFADDR, &ifreq) >= 0) {
-t = __MKBYTEARRAY((char *)&ifreq.ifr_addr, sizeof(ifreq.ifr_addr));
+	    t = __MKBYTEARRAY((char *)&ifreq.ifr_addr, sizeof(ifreq.ifr_addr));
-__arrayVal(addressArray)[countOfIf] = t; __STORE(addressArray, t);
+	    __arrayVal(addressArray)[countOfIf] = t; __STORE(addressArray, t);
-t = __MKSTRING(&ifreq.ifr_name);
+	    t = __MKSTRING(&ifreq.ifr_name);
-__arrayVal(nameArray)[countOfIf] = t; __STORE(nameArray, t);
+	    __arrayVal(nameArray)[countOfIf] = t; __STORE(nameArray, t);
-countOfIf += 1;
+	    countOfIf += 1;
-}
+	}
-// see (sigh) comment above
+	// see (sigh) comment above
 #ifndef __osx__
-ifr++;
+	ifr++;
 #else
-{
+	{
-int sz = IFNAMSIZ + ifr->ifr_addr.sa_len;
+	    int sz = IFNAMSIZ + ifr->ifr_addr.sa_len;
-ifr = (struct ifreq *)( ((char *)ifr)+sz );
+	    ifr = (struct ifreq *)( ((char *)ifr)+sz );
-}
+	}
 #endif
 }
 noOfIf = __mkSmallInteger(countOfIf);
 bad:
 if (afinet_socket >= 0)
-close(afinet_socket);
+	close(afinet_socket);
 #else
 error = @symbol(notSupported);
 #endif /* defined(SIOCGIFADDR) */
 %}.
 retDictionary := Dictionary new:noOfIf.
 error notNil ifTrue:[
-self primitiveFailed:error.
+	self primitiveFailed:error.
-"return empty dictionary if proceed from error"
+	"return empty dictionary if proceed from error"
-^  retDictionary.
+	^  retDictionary.
 ].
 1 to:noOfIf do:[:cnt|
-"take the first address, if there is more than one!!"
+	"take the first address, if there is more than one!!"
-retDictionary at:(nameArray at:cnt) ifAbsentPut:(SocketAddress fromBytes:(addressArray at:cnt)).
+	retDictionary at:(nameArray at:cnt) ifAbsentPut:(SocketAddress fromBytes:(addressArray at:cnt)).
 ].
 ^ retDictionary
 "
 "
 !
 getNetworkMACAddresses
 "return a dictionary filled with
-key -> name of interface
+	key -> name of interface
-value -> the MAC adress (as ByteArray)
+	value -> the MAC adress (as ByteArray)
 for each interface"
 |addressArray nameArray noOfIf retDictionary error|
 noOfIf := 0.
 ** Open an INET socket
 */
 afinet_socket = socket(AF_INET, SOCK_DGRAM, 0);
 if (afinet_socket < 0) {
-error = __MKSTRING("Cannot open socket");
+	error = __MKSTRING("Cannot open socket");
-goto bad;
+	goto bad;
 }
 /*
 ** Get the list of network interfaces
 */
 ifc.ifc_len = sizeof (buf);
 ifc.ifc_buf = (caddr_t) buf;
 if (ioctl (afinet_socket, SIOCGIFCONF, (caddr_t) &ifc) < 0) {
-error = __MKSTRING("ioctl(SIOCGIFCONF) failed");
+	error = __MKSTRING("ioctl(SIOCGIFCONF) failed");
-goto bad;
+	goto bad;
 }
 // get the number of interfaces in the returned structure
 // cg: sigh
 // see also 2nd loop below
 #ifndef __osx__
 n_ifs = ifc.ifc_len / sizeof (struct ifreq);
 #else
 {
-unsigned char *cp = buf;
+	unsigned char *cp = buf;
-char *limit = buf + ifc.ifc_len;
+	char *limit = buf + ifc.ifc_len;
-n_ifs = 0;
+	n_ifs = 0;
-while (cp < limit) {
+	while (cp < limit) {
-int sz;
+	    int sz;
-ifr = (struct ifreq *)cp;
+	    ifr = (struct ifreq *)cp;
-sz = IFNAMSIZ + ifr->ifr_addr.sa_len;
+	    sz = IFNAMSIZ + ifr->ifr_addr.sa_len;
-cp += sz;
+	    cp += sz;
-n_ifs++;
+	    n_ifs++;
-}
+	}
 }
 #endif
 nameArray    = __ARRAY_NEW_INT(n_ifs);
 addressArray = __ARRAY_NEW_INT(n_ifs);
 if (nameArray == nil || addressArray == nil) {
-/* Creating a string wouldn/t work here */
+	/* Creating a string wouldn/t work here */
-error = @symbol(allocationFailure);
+	error = @symbol(allocationFailure);
-goto bad;
+	goto bad;
 }
 /*
 ** Iterate of the list of the system's netif. Find all
 ** active interfaces and their ethernet addresses
 */
 countOfIf = 0;
 for (i=0, ifr = ifc.ifc_req; i < n_ifs; i++) {
-/*
+	/*
-** Get Flags for this interface
+	** Get Flags for this interface
-*/
+	*/
 # ifndef __osx__ // SIOCGIFFLAGS fails on osx (Q@sv: what is this needed for anyway?)
-{
+	{
-struct ifreq ifreq;
+	    struct ifreq ifreq;
-memcpy(&ifreq, ifr, sizeof(ifreq));
+	    memcpy(&ifreq, ifr, sizeof(ifreq));
-if (ioctl (afinet_socket, SIOCGIFFLAGS, &ifreq) < 0) {
+	    if (ioctl (afinet_socket, SIOCGIFFLAGS, &ifreq) < 0) {
-if (@global(InfoPrinting) == true) {
+		if (@global(InfoPrinting) == true) {
-fprintf(stderr, "OS [warning]: ioctl(SIOCGIFFLAGS) failed");
+		    fprintf(stderr, "OS [warning]: ioctl(SIOCGIFFLAGS) failed");
-}
+		}
-}
+	    }
-}
+	}
 # endif
-{
+	{
 # ifdef SIOCGIFHWADDR
-/*
+	    /*
-** Get Hardware address for this interface
+	    ** Get Hardware address for this interface
-*/
+	    */
-{
+	    {
-struct ifreq ifreq;
+		struct ifreq ifreq;
-memcpy(&ifreq, ifr, sizeof(ifreq));
+		memcpy(&ifreq, ifr, sizeof(ifreq));
-if (ioctl (afinet_socket, SIOCGIFHWADDR, &ifreq) >= 0) {
+		if (ioctl (afinet_socket, SIOCGIFHWADDR, &ifreq) >= 0) {
-t = __MKBYTEARRAY(&ifreq.ifr_hwaddr.sa_data, IFHWADDRLEN);
+		    t = __MKBYTEARRAY(&ifreq.ifr_hwaddr.sa_data, IFHWADDRLEN);
-__arrayVal(addressArray)[countOfIf] = t; __STORE(addressArray, t);
+		    __arrayVal(addressArray)[countOfIf] = t; __STORE(addressArray, t);
-t = __MKSTRING(&ifreq.ifr_name);
+		    t = __MKSTRING(&ifreq.ifr_name);
-__arrayVal(nameArray)[countOfIf] = t; __STORE(nameArray, t);
+		    __arrayVal(nameArray)[countOfIf] = t; __STORE(nameArray, t);
-countOfIf += 1;
+		    countOfIf += 1;
-}
+		}
-}
+	    }
 #else
-// macosx has no SIOCGIFHWADDR
+	    // macosx has no SIOCGIFHWADDR
-// printf("family: %d\n", ifr->ifr_addr.sa_family);
+	    // printf("family: %d\n", ifr->ifr_addr.sa_family);
-// printf("name: %s\n", ifr->ifr_name);
+	    // printf("name: %s\n", ifr->ifr_name);
-if (ifr->ifr_addr.sa_family == AF_LINK) {
+	    if (ifr->ifr_addr.sa_family == AF_LINK) {
-struct sockaddr_dl *sdl;
+		struct sockaddr_dl *sdl;
-char *adr;
+		char *adr;
-extern char *ether_ntoa();
+		extern char *ether_ntoa();
-unsigned char mac[6];
+		unsigned char mac[6];
-int a,b,c,d,e,f;
+		int a,b,c,d,e,f;
-sdl = (struct sockaddr_dl *)&(ifr->ifr_addr);
+		sdl = (struct sockaddr_dl *)&(ifr->ifr_addr);
-adr = ether_ntoa(LLADDR(sdl));
+		adr = ether_ntoa(LLADDR(sdl));
-// printf("name: %s adr: %s\n", ifr->ifr_name, adr);
+		// printf("name: %s adr: %s\n", ifr->ifr_name, adr);
-sscanf(adr, "%x:%x:%x:%x:%x:%x", &a, &b, &c, &d, &e, &f);
+		sscanf(adr, "%x:%x:%x:%x:%x:%x", &a, &b, &c, &d, &e, &f);
-mac[0] = a;
+		mac[0] = a;
-mac[1] = b;
+		mac[1] = b;
-mac[2] = c;
+		mac[2] = c;
-mac[3] = d;
+		mac[3] = d;
-mac[4] = e;
+		mac[4] = e;
-mac[5] = f;
+		mac[5] = f;
-t = __MKBYTEARRAY(mac, 6);
+		t = __MKBYTEARRAY(mac, 6);
-__arrayVal(addressArray)[countOfIf] = t; __STORE(addressArray, t);
+		__arrayVal(addressArray)[countOfIf] = t; __STORE(addressArray, t);
-t = __MKSTRING(ifr->ifr_name);
+		t = __MKSTRING(ifr->ifr_name);
-__arrayVal(nameArray)[countOfIf] = t; __STORE(nameArray, t);
+		__arrayVal(nameArray)[countOfIf] = t; __STORE(nameArray, t);
-countOfIf += 1;
+		countOfIf += 1;
-}
+	    }
 #endif
-}
+	}
-// see (sigh) comment above
+	// see (sigh) comment above
 #ifndef __osx__
-ifr++;
+	ifr++;
 #else
-{
+	{
-int sz = IFNAMSIZ + ifr->ifr_addr.sa_len;
+	    int sz = IFNAMSIZ + ifr->ifr_addr.sa_len;
-ifr = (struct ifreq *)( ((char *)ifr)+sz );
+	    ifr = (struct ifreq *)( ((char *)ifr)+sz );
-}
+	}
 #endif
 }
 noOfIf = __mkSmallInteger(countOfIf);
 bad:
 if (afinet_socket >= 0)
-close(afinet_socket);
+	close(afinet_socket);
 #else
 error = @symbol(notSupported);
 #endif /* SIOCGIFHWADDR */
 %}.
 error notNil ifTrue:[
-self primitiveFailed:error.
+	self primitiveFailed:error.
-"return an empty dictionary if proceed from error"
+	"return an empty dictionary if proceed from error"
-^  Dictionary new.
+	^  Dictionary new.
 ].
 "we prefer OrderedDictionary here, because we want to keep the
 order as defined in the OS."
 retDictionary := OrderedDictionary new:noOfIf.
 1 to:noOfIf do:[:cnt|
-|macAddress|
+	|macAddress|
-macAddress := addressArray at:cnt.
+	macAddress := addressArray at:cnt.
-macAddress ~= #[0 0 0 0 0 0] ifTrue:[
+	macAddress ~= #[0 0 0 0 0 0] ifTrue:[
-retDictionary at:(nameArray at:cnt) put:macAddress.
+	    retDictionary at:(nameArray at:cnt) put:macAddress.
-].
+	].
 ].
 ^ retDictionary
 "
 getSystemID
 "if supported by the OS, return the systemID;
 a unique per machine identification.
 WARNING:
-not all systems support this; on some, #unknown is returned."
+	not all systems support this; on some, #unknown is returned."
 %{  /* NOCONTEXT */
 #if defined(HAS_SYSINFO) && defined(SI_HW_SERIAL)
 {
-char buffer[128];
+	char buffer[128];
-buffer[0] = 0;
+	buffer[0] = 0;
-if (sysinfo(SI_HW_SERIAL, buffer, sizeof(buffer))) {
+	if (sysinfo(SI_HW_SERIAL, buffer, sizeof(buffer))) {
-buffer[127] = 0;
+	    buffer[127] = 0;
-if (strlen(buffer) > 0) {
+	    if (strlen(buffer) > 0) {
-RETURN(__MKSTRING(buffer));
+		RETURN(__MKSTRING(buffer));
-}
+	    }
-}
+	}
 }
 #elif defined(HAS_GETHOSTID)
 int runningId;
 OBJ arr;
 char idBuffer[MAXSYSIDSIZE];
 int retVal;
 OBJ arr;
 if ((retVal = syssgi(SGI_SYSID, idBuffer)) == 0) {
-arr = __BYTEARRAY_UNINITIALIZED_NEW_INT(MAXSYSIDSIZE);
+	arr = __BYTEARRAY_UNINITIALIZED_NEW_INT(MAXSYSIDSIZE);
-bcopy(idBuffer, __byteArrayVal(arr), MAXSYSIDSIZE);
+	bcopy(idBuffer, __byteArrayVal(arr), MAXSYSIDSIZE);
-RETURN (arr);
+	RETURN (arr);
 }
 #endif
 %}.
 ^ #unknown
 OS, for example, linux returns 'ix86', while WIN32 returns 'x86'.
 This method is mainly provided to augment error reports with some system
 information.
 (in case of system/version specific OS errors, conditional workarounds and patches
-may be based upon this info).
+	may be based upon this info).
 Also, applications could enable/disable buffering or otherwise reduce
 their memory usage depending upon the amount of memory installed.
 Your application may make use of available information for tuning,
 but should NEVER DEPEND upon this in any way.
 The returned info may (or may not) contain:
-#system -> some operating system identification (irix, Linux, nt, win32s ...)
+	#system -> some operating system identification (irix, Linux, nt, win32s ...)
-#version -> OS version (some os version identification)
+	#version -> OS version (some os version identification)
-#release -> OS release (3.5, 1.2.1 ...)
+	#release -> OS release (3.5, 1.2.1 ...)
-#node   -> some host identification (hostname)
+	#node   -> some host identification (hostname)
-#domain  -> domain name (hosts domain)
+	#domain  -> domain name (hosts domain)
-#machine -> type of CPU (i586, mips ...)
+	#machine -> type of CPU (i586, mips ...)
 those are currently returned on some machines (no warranty)
 linux:
-#totalRam         -> total amount of memory available
+	#totalRam         -> total amount of memory available
-#sharedRam        -> amount of memory which is shared among processes
+	#sharedRam        -> amount of memory which is shared among processes
-(i.e. shared code)
+			     (i.e. shared code)
-#bufferRam        -> amount used for buffers
+	#bufferRam        -> amount used for buffers
-#swapSize         -> total size of swap space
+	#swapSize         -> total size of swap space
-#freeSwap         -> free amount in swapSpace
+	#freeSwap         -> free amount in swapSpace
-#numberOfCPUs     -> number of cpus in box
+	#numberOfCPUs     -> number of cpus in box
-#extendedInstructions -> extended instruction set info
+	#extendedInstructions -> extended instruction set info
 osf:
-#physicalRam      -> total amount of physical memory
+	#physicalRam      -> total amount of physical memory
-#cpuType          -> type of cpu (more detailed than machine)
+	#cpuType          -> type of cpu (more detailed than machine)
-#numberOfCPUs     -> number of cpus in box
+	#numberOfCPUs     -> number of cpus in box
 osx:
-#physicalRam      -> total amount of physical memory
+	#physicalRam      -> total amount of physical memory
 solaris:
-#physicalRam      -> total amount of physical memory
+	#physicalRam      -> total amount of physical memory
-#availableRam     -> total available amount of physical memory (i.e. unused ram)
+	#availableRam     -> total available amount of physical memory (i.e. unused ram)
-#freeRam          -> amount of free memory
+	#freeRam          -> amount of free memory
-#numberOfCPUs     -> number of cpus in box (online CPUS)
+	#numberOfCPUs     -> number of cpus in box (online CPUS)
-[#dCacheSize]     -> bytes in data cache (only available on some solaris versions)
+	[#dCacheSize]     -> bytes in data cache (only available on some solaris versions)
-[#iCacheSize]     -> bytes in data cache (only available on some solaris versions)
+	[#iCacheSize]     -> bytes in data cache (only available on some solaris versions)
-[#instructionSets]-> instruction sets available (only available on some solaris versions)
+	[#instructionSets]-> instruction sets available (only available on some solaris versions)
-[#platform]       -> platform name (only available on some solaris versions)
+	[#platform]       -> platform name (only available on some solaris versions)
 hpux:
-#physicalRam      -> total amount of physical memory in box
+	#physicalRam      -> total amount of physical memory in box
-#activeRealMemory -> ? - read pstat documentation
+	#activeRealMemory -> ? - read pstat documentation
-#activeVirtualRam -> ? - read pstat documentation
+	#activeVirtualRam -> ? - read pstat documentation
-#freeMemory       -> ? - read pstat documentation
+	#freeMemory       -> ? - read pstat documentation
-#realMemory       -> ? (amount of memory left to user programs)
+	#realMemory       -> ? (amount of memory left to user programs)
-#virtualRam       -> ? - read pstat documentation
+	#virtualRam       -> ? - read pstat documentation
 "
 |sys node rel ver mach dom mtyp brel info arch cpuType cpuSpeed
 physicalRam availableRam totalRam sharedRam bufferRam swapSize freeSwap
 numberOfCPUs numberOfPhysicalCPUs pageSize physicalPages availablePages dCacheSize iCacheSize
 * additional info available ...
 */
 struct sysinfo infoBuffer;
 if (sysinfo(&infoBuffer) >= 0) {
-totalRam   = __MKUINT(infoBuffer.totalram);
+	totalRam   = __MKUINT(infoBuffer.totalram);
-sharedRam = __MKUINT(infoBuffer.sharedram);
+	sharedRam = __MKUINT(infoBuffer.sharedram);
-bufferRam = __MKUINT(infoBuffer.bufferram);
+	bufferRam = __MKUINT(infoBuffer.bufferram);
-swapSize  = __MKUINT(infoBuffer.totalswap);
+	swapSize  = __MKUINT(infoBuffer.totalswap);
-freeSwap  = __MKUINT(infoBuffer.freeswap);
+	freeSwap  = __MKUINT(infoBuffer.freeswap);
 }
 # endif
 #endif /* LINUX */
 #if defined(hpux) && !defined(__GNUC__)
 freeMemory         = __MKUINT(dynam_buf.psd_free/256*1024*1024);
 #endif
 #if defined(HAS_UNAME)
 {
-struct utsname ubuff;
+	struct utsname ubuff;
-if (uname(&ubuff) >= 0) {
+	if (uname(&ubuff) >= 0) {
-sys  = __MKSTRING(ubuff.sysname);
+	    sys  = __MKSTRING(ubuff.sysname);
-node = __MKSTRING(ubuff.nodename);
+	    node = __MKSTRING(ubuff.nodename);
-rel  = __MKSTRING(ubuff.release);
+	    rel  = __MKSTRING(ubuff.release);
-ver  = __MKSTRING(ubuff.version);
+	    ver  = __MKSTRING(ubuff.version);
-mach = __MKSTRING(ubuff.machine);
+	    mach = __MKSTRING(ubuff.machine);
 # if defined(HAS_UTS_DOMAINNAME) || defined(_GNU_SOURCE)
-dom  = __MKSTRING(ubuff.domainname);
+	    dom  = __MKSTRING(ubuff.domainname);
 # endif /* no HAS_UTS_DOMAINNAME */
-}
+	}
 }
 #else /* no UNAME */
 /*
 #endif /* no UNAME */
 #if defined(HAS_SYSINFO)
 # if defined(SI_ARCHITECTURE)
 if (arch == nil) {
-char buffer[128];
+	char buffer[128];
-if (sysinfo(SI_ARCHITECTURE, buffer, sizeof(buffer))) {
+	if (sysinfo(SI_ARCHITECTURE, buffer, sizeof(buffer))) {
-arch = __MKSTRING(buffer);
+	    arch = __MKSTRING(buffer);
-}
+	}
 }
 # endif /* SI_ARCHITECTURE */
 # if defined(SI_ISALIST)
 {
-char buffer[128];
+	char buffer[128];
-if (sysinfo(SI_ISALIST, buffer, sizeof(buffer))) {
+	if (sysinfo(SI_ISALIST, buffer, sizeof(buffer))) {
-instructionSets = __MKSTRING(buffer);
+	    instructionSets = __MKSTRING(buffer);
-}
+	}
 }
 # endif /* SI_ISALIST */
 # if defined(SI_PLATFORM)
 {
-char buffer[128];
+	char buffer[128];
-if (sysinfo(SI_PLATFORM, buffer, sizeof(buffer))) {
+	if (sysinfo(SI_PLATFORM, buffer, sizeof(buffer))) {
-platform = __MKSTRING(buffer);
+	    platform = __MKSTRING(buffer);
-}
+	}
 }
 # endif /* SI_PLATFORM */
 # if defined(SI_RELEASE)
 {
-char buffer[128];
+	char buffer[128];
-if (sysinfo(SI_RELEASE, buffer, sizeof(buffer))) {
+	if (sysinfo(SI_RELEASE, buffer, sizeof(buffer))) {
-rel = __MKSTRING(buffer);
+	    rel = __MKSTRING(buffer);
-}
+	}
 }
 # endif /* SI_RELEASE */
 #endif /* HAS_SYSINFO */
 #if defined(HAS_SYSCONF)
 # ifdef _SC_NPROCESSORS_ONLN
 {
-long val;
+	long val;
-val = sysconf(_SC_NPROCESSORS_ONLN);
+	val = sysconf(_SC_NPROCESSORS_ONLN);
-if (val > 0) {
+	if (val > 0) {
-numberOfCPUs = __MKINT(val);
+	    numberOfCPUs = __MKINT(val);
-}
+	}
 }
 # endif
 # ifdef _SC_NPROCESSORS_CONF
 {
-long val;
+	long val;
-val = sysconf(_SC_NPROCESSORS_CONF);
+	val = sysconf(_SC_NPROCESSORS_CONF);
-if (val > 0) {
+	if (val > 0) {
-numberOfPhysicalCPUs = __MKINT(val);
+	    numberOfPhysicalCPUs = __MKINT(val);
-}
+	}
 }
 # endif
 # if defined(_SC_PAGESIZE)
 {
-long val;
+	long val;
-val = sysconf(_SC_PAGESIZE);
+	val = sysconf(_SC_PAGESIZE);
-if (val != -1) {
+	if (val != -1) {
-pageSize = __MKUINT(val);
+	    pageSize = __MKUINT(val);
-}
+	}
 }
 # endif
 # if defined(_SC_PHYS_PAGES)
 {
-long val;
+	long val;
-val = sysconf(_SC_PHYS_PAGES);
+	val = sysconf(_SC_PHYS_PAGES);
-if (val != -1) {
+	if (val != -1) {
-physicalPages = __MKUINT(val);
+	    physicalPages = __MKUINT(val);
-}
+	}
 }
 # endif
 # if defined(_SC_AVPHYS_PAGES)
 {
-long val;
+	long val;
-val = sysconf(_SC_AVPHYS_PAGES);
+	val = sysconf(_SC_AVPHYS_PAGES);
-if (val != -1) {
+	if (val != -1) {
-availablePages = __MKUINT(val);
+	    availablePages = __MKUINT(val);
-}
+	}
 }
 # endif
 # if defined(_SC_ICACHE_SZ)
 {
-long val;
+	long val;
-val = sysconf(_SC_ICACHE_SZ);
+	val = sysconf(_SC_ICACHE_SZ);
-if (val != -1) {
+	if (val != -1) {
-iCacheSize = __MKUINT(val);
+	    iCacheSize = __MKUINT(val);
-}
+	}
 }
 # endif
 # if defined(_SC_DCACHE_SZ)
 {
-long val;
+	long val;
-val = sysconf(_SC_DCACHE_SZ);
+	val = sysconf(_SC_DCACHE_SZ);
-if (val != -1) {
+	if (val != -1) {
-dCacheSize = __MKUINT(val);
+	    dCacheSize = __MKUINT(val);
-}
+	}
 }
 # endif
 #endif /* HAS_SYSCONF */
 #if defined(HAS_GETSYSINFO)
 {
-INT index;
+	INT index;
-int retInt32 = 0;
+	int retInt32 = 0;
 # if defined(GSI_CPU)
-index = 0;
+	index = 0;
-if (getsysinfo(GSI_CPU, &retInt32, sizeof(retInt32), &index, NULL) > 0) {
+	if (getsysinfo(GSI_CPU, &retInt32, sizeof(retInt32), &index, NULL) > 0) {
-switch (retInt32) {
+	    switch (retInt32) {
 #  ifdef VAX_780
-case VAX_780:
+		case VAX_780:
-cpuType = __MKSTRING("VAX_780");
+		    cpuType = __MKSTRING("VAX_780");
-break;
+		    break;
 #  endif
 #  ifdef VAX_750
-case VAX_750:
+		case VAX_750:
-cpuType = __MKSTRING("VAX_750");
+		    cpuType = __MKSTRING("VAX_750");
-break;
+		    break;
 #  endif
 #  ifdef VAX_730
-case VAX_730:
+		case VAX_730:
-cpuType = __MKSTRING("VAX_730");
+		    cpuType = __MKSTRING("VAX_730");
-break;
+		    break;
 #  endif
 #  ifdef VAX_8600
-case VAX_8600:
+		case VAX_8600:
-cpuType = __MKSTRING("VAX_8600");
+		    cpuType = __MKSTRING("VAX_8600");
-break;
+		    break;
 #  endif
 #  ifdef VAX_8200
-case VAX_8200:
+		case VAX_8200:
-cpuType = __MKSTRING("VAX_8200");
+		    cpuType = __MKSTRING("VAX_8200");
-break;
+		    break;
 #  endif
 #  ifdef VAX_8800
-case VAX_8800:
+		case VAX_8800:
-cpuType = __MKSTRING("VAX_8800");
+		    cpuType = __MKSTRING("VAX_8800");
-break;
+		    break;
 #  endif
 #  ifdef MVAX_I
-case MVAX_I:
+		case MVAX_I:
-cpuType = __MKSTRING("MVAX_I");
+		    cpuType = __MKSTRING("MVAX_I");
-break;
+		    break;
 #  endif
 #  ifdef MVAX_II
-case MVAX_II:
+		case MVAX_II:
-cpuType = __MKSTRING("MVAX_II");
+		    cpuType = __MKSTRING("MVAX_II");
-break;
+		    break;
 #  endif
 #  ifdef V_VAX
-case V_VAX:
+		case V_VAX:
-cpuType = __MKSTRING("V_VAX");
+		    cpuType = __MKSTRING("V_VAX");
-break;
+		    break;
 #  endif
 #  ifdef VAX_3600
-case VAX_3600:
+		case VAX_3600:
-cpuType = __MKSTRING("VAX_3600");
+		    cpuType = __MKSTRING("VAX_3600");
-break;
+		    break;
 #  endif
 #  ifdef VAX_6200
-case VAX_6200:
+		case VAX_6200:
-cpuType = __MKSTRING("VAX_6200");
+		    cpuType = __MKSTRING("VAX_6200");
-break;
+		    break;
 #  endif
 #  ifdef VAX_3400
-case VAX_3400:
+		case VAX_3400:
-cpuType = __MKSTRING("VAX_3400");
+		    cpuType = __MKSTRING("VAX_3400");
-break;
+		    break;
 #  endif
 #  ifdef C_VAXSTAR
-case C_VAXSTAR:
+		case C_VAXSTAR:
-cpuType = __MKSTRING("C_VAXSTAR");
+		    cpuType = __MKSTRING("C_VAXSTAR");
-break;
+		    break;
 #  endif
 #  ifdef VAX_60
-case VAX_60:
+		case VAX_60:
-cpuType = __MKSTRING("VAX_60");
+		    cpuType = __MKSTRING("VAX_60");
-break;
+		    break;
 #  endif
 #  ifdef VAX_3900
-case VAX_3900:
+		case VAX_3900:
-cpuType = __MKSTRING("VAX_3900");
+		    cpuType = __MKSTRING("VAX_3900");
-break;
+		    break;
 #  endif
 #  ifdef DS_3100
-case DS_3100:
+		case DS_3100:
-cpuType = __MKSTRING("DS_3100");
+		    cpuType = __MKSTRING("DS_3100");
-break;
+		    break;
 #  endif
 #  ifdef VAX_8820
-case VAX_8820:
+		case VAX_8820:
-cpuType = __MKSTRING("VAX_8820");
+		    cpuType = __MKSTRING("VAX_8820");
-break;
+		    break;
 #  endif
 #  ifdef DS_5400
-case DS_5400:
+		case DS_5400:
-cpuType = __MKSTRING("DS_5400");
+		    cpuType = __MKSTRING("DS_5400");
-break;
+		    break;
 #  endif
 #  ifdef DS_5800
-case DS_5800:
+		case DS_5800:
-cpuType = __MKSTRING("DS_5800");
+		    cpuType = __MKSTRING("DS_5800");
-break;
+		    break;
 #  endif
 #  ifdef DS_5000
-case DS_5000:
+		case DS_5000:
-cpuType = __MKSTRING("DS_5000");
+		    cpuType = __MKSTRING("DS_5000");
-break;
+		    break;
 #  endif
 #  ifdef DS_CMAX
-case DS_CMAX:
+		case DS_CMAX:
-cpuType = __MKSTRING("DS_CMAX");
+		    cpuType = __MKSTRING("DS_CMAX");
-break;
+		    break;
 #  endif
 #  ifdef VAX_6400
-case VAX_6400:
+		case VAX_6400:
-cpuType = __MKSTRING("VAX_6400");
+		    cpuType = __MKSTRING("VAX_6400");
-break;
+		    break;
 #  endif
 #  ifdef VAXSTAR
-case VAXSTAR:
+		case VAXSTAR:
-cpuType = __MKSTRING("VAXSTAR");
+		    cpuType = __MKSTRING("VAXSTAR");
-break;
+		    break;
 #  endif
 #  ifdef DS_5500
-case DS_5500:
+		case DS_5500:
-cpuType = __MKSTRING("DS_5500");
+		    cpuType = __MKSTRING("DS_5500");
-break;
+		    break;
 #  endif
 #  ifdef DS_5100
-case DS_5100:
+		case DS_5100:
-cpuType = __MKSTRING("DS_5100");
+		    cpuType = __MKSTRING("DS_5100");
-break;
+		    break;
 #  endif
 #  ifdef VAX_9000
-case VAX_9000:
+		case VAX_9000:
-cpuType = __MKSTRING("VAX_9000");
+		    cpuType = __MKSTRING("VAX_9000");
-break;
+		    break;
 #  endif
 #  ifdef DS_500_100
-case DS_500_100:
+		case DS_500_100:
-cpuType = __MKSTRING("DS_500_100");
+		    cpuType = __MKSTRING("DS_500_100");
-break;
+		    break;
 #  endif
 #  ifdef ALPHA_ADU
-case ALPHA_ADU:
+		case ALPHA_ADU:
-cpuType = __MKSTRING("ALPHA_ADU");
+		    cpuType = __MKSTRING("ALPHA_ADU");
-break;
+		    break;
 #  endif
 #  ifdef DEC_4000
-case DEC_4000:
+		case DEC_4000:
-cpuType = __MKSTRING("DEC_4000");
+		    cpuType = __MKSTRING("DEC_4000");
-break;
+		    break;
 #  endif
 #  ifdef DEC_3000_500
-case DEC_3000_500:
+		case DEC_3000_500:
-cpuType = __MKSTRING("DEC_3000_500");
+		    cpuType = __MKSTRING("DEC_3000_500");
-break;
+		    break;
 #  endif
 #  ifdef DEC_7000
-case DEC_7000:
+		case DEC_7000:
-cpuType = __MKSTRING("DEC_7000");
+		    cpuType = __MKSTRING("DEC_7000");
-break;
+		    break;
 #  endif
 #  ifdef DS_5000_300
-case DS_5000_300:
+		case DS_5000_300:
-cpuType = __MKSTRING("DS_5000_300");
+		    cpuType = __MKSTRING("DS_5000_300");
-break;
+		    break;
 #  endif
 #  ifdef DEC_3000_300
-case DEC_3000_300:
+		case DEC_3000_300:
-cpuType = __MKSTRING("DEC_3000_300");
+		    cpuType = __MKSTRING("DEC_3000_300");
-break;
+		    break;
 #  endif
 #  ifdef DEC_2000_300
-case DEC_2000_300:
+		case DEC_2000_300:
-cpuType = __MKSTRING("DEC_2000_300");
+		    cpuType = __MKSTRING("DEC_2000_300");
-break;
+		    break;
 #  endif
 #  ifdef DEC_2100_A500
-case DEC_2100_A500:
+		case DEC_2100_A500:
-cpuType = __MKSTRING("DEC_2100_A500");
+		    cpuType = __MKSTRING("DEC_2100_A500");
-break;
+		    break;
 #  endif
 #  ifdef DEC_2100_A50
-case DEC_2100_A50:
+		case DEC_2100_A50:
-cpuType = __MKSTRING("DEC_2100_A50");
+		    cpuType = __MKSTRING("DEC_2100_A50");
-break;
+		    break;
 #  endif
 #  ifdef ALPHA_KN20AA
-case ALPHA_KN20AA:
+		case ALPHA_KN20AA:
-cpuType = __MKSTRING("ALPHA_KN20AA");
+		    cpuType = __MKSTRING("ALPHA_KN20AA");
-break;
+		    break;
 #  endif
 #  ifdef DEC_21000
-case DEC_21000:
+		case DEC_21000:
-cpuType = __MKSTRING("DEC_21000");
+		    cpuType = __MKSTRING("DEC_21000");
-break;
+		    break;
 #  endif
 #  ifdef DEC_AXPVME_64
-case DEC_AXPVME_64:
+		case DEC_AXPVME_64:
-cpuType = __MKSTRING("DEC_AXPVME_64");
+		    cpuType = __MKSTRING("DEC_AXPVME_64");
-break;
+		    break;
 #  endif
 #  ifdef DEC_2100_C500
-case DEC_2100_C500:
+		case DEC_2100_C500:
-cpuType = __MKSTRING("DEC_2100_C500");
+		    cpuType = __MKSTRING("DEC_2100_C500");
-break;
+		    break;
 #  endif
 #  ifdef DEC_AXPPCI_33
-case DEC_AXPPCI_33:
+		case DEC_AXPPCI_33:
-cpuType = __MKSTRING("DEC_AXPPCI_33");
+		    cpuType = __MKSTRING("DEC_AXPPCI_33");
-break;
+		    break;
 #  endif
 #  ifdef DEC_1000
-case DEC_1000:
+		case DEC_1000:
-cpuType = __MKSTRING("DEC_1000");
+		    cpuType = __MKSTRING("DEC_1000");
-break;
+		    break;
 #  endif
 #  ifdef EB64_PLUS
-case EB64_PLUS:
+		case EB64_PLUS:
-cpuType = __MKSTRING("EB64_PLUS");
+		    cpuType = __MKSTRING("EB64_PLUS");
-break;
+		    break;
 #  endif
 #  ifdef LCA_EB66
-case LCA_EB66:
+		case LCA_EB66:
-cpuType = __MKSTRING("LCA_EB66");
+		    cpuType = __MKSTRING("LCA_EB66");
-break;
+		    break;
 #  endif
 #  ifdef ALPHA_EB164
-case ALPHA_EB164:
+		case ALPHA_EB164:
-cpuType = __MKSTRING("ALPHA_EB164");
+		    cpuType = __MKSTRING("ALPHA_EB164");
-break;
+		    break;
 #  endif
 #  ifdef DEC_EV45_PBP
-case DEC_EV45_PBP:
+		case DEC_EV45_PBP:
-cpuType = __MKSTRING("DEC_EV45_PBP");
+		    cpuType = __MKSTRING("DEC_EV45_PBP");
-break;
+		    break;
 #  endif
 #  ifdef DEC_1000A
-case DEC_1000A:
+		case DEC_1000A:
-cpuType = __MKSTRING("DEC_1000A");
+		    cpuType = __MKSTRING("DEC_1000A");
-break;
+		    break;
 #  endif
 #  ifdef DEC_4100
-case DEC_4100:
+		case DEC_4100:
-cpuType = __MKSTRING("DEC_4100");
+		    cpuType = __MKSTRING("DEC_4100");
-break;
+		    break;
 #  endif
 #  ifdef DEC_ALPHAVME_224
-case DEC_ALPHAVME_224:
+		case DEC_ALPHAVME_224:
-cpuType = __MKSTRING("DEC_ALPHAVME_224");
+		    cpuType = __MKSTRING("DEC_ALPHAVME_224");
-break;
+		    break;
 #  endif
 #  ifdef DEC_1000_5
-case DEC_1000_5:
+		case DEC_1000_5:
-cpuType = __MKSTRING("DEC_1000_5");
+		    cpuType = __MKSTRING("DEC_1000_5");
-break;
+		    break;
 #  endif
 #  ifdef DEC_1000A_5
-case DEC_1000A_5:
+		case DEC_1000A_5:
-cpuType = __MKSTRING("DEC_1000A_5");
+		    cpuType = __MKSTRING("DEC_1000A_5");
-break;
+		    break;
 #  endif
 #  ifdef DEC_EV56_PBP
-case DEC_EV56_PBP:
+		case DEC_EV56_PBP:
-cpuType = __MKSTRING("DEC_EV56_PBP");
+		    cpuType = __MKSTRING("DEC_EV56_PBP");
-break;
+		    break;
 #  endif
 #  ifdef ALPHABOOK
-case ALPHABOOK:
+		case ALPHABOOK:
-cpuType = __MKSTRING("ALPHABOOK");
+		    cpuType = __MKSTRING("ALPHABOOK");
-break;
+		    break;
 #  endif
 #  ifdef DEC_ALPHAVME_320
-case DEC_ALPHAVME_320:
+		case DEC_ALPHAVME_320:
-cpuType = __MKSTRING("DEC_ALPHAVME_320");
+		    cpuType = __MKSTRING("DEC_ALPHAVME_320");
-break;
+		    break;
 #  endif
 #  ifdef DEC_550
-case DEC_550:
+		case DEC_550:
-cpuType = __MKSTRING("DEC_550");
+		    cpuType = __MKSTRING("DEC_550");
-break;
+		    break;
 #  endif
 #  ifdef DEC_6600
-case DEC_6600:
+		case DEC_6600:
-cpuType = __MKSTRING("DEC_6600");
+		    cpuType = __MKSTRING("DEC_6600");
-break;
+		    break;
 #  endif
 #  ifdef UNKN_SYSTEM
-case UNKN_SYSTEM:
+		case UNKN_SYSTEM:
-cpuType = __MKSTRING("UNKN_SYSTEM");
+		    cpuType = __MKSTRING("UNKN_SYSTEM");
-break;
+		    break;
 #  endif
-default:
+		default:
-cpuType = __MKSTRING("OTHER_DEC_SYSTEM");
+		    cpuType = __MKSTRING("OTHER_DEC_SYSTEM");
-break;
+		    break;
-}
+	    }
-}
+	}
 # endif /* GSI_CPU */
 # if defined(GSI_CPU_INFO)
-/*
+	/*
-* stupid: OSF1 pre V4.0 has no mhz, but V4.0 has it.
+	 * stupid: OSF1 pre V4.0 has no mhz, but V4.0 has it.
-* use the GSI_PLATFORM_NAME as a hint - it is only defined in
+	 * use the GSI_PLATFORM_NAME as a hint - it is only defined in
-* V4.0 and higher ... (sigh)
+	 * V4.0 and higher ... (sigh)
-*/
+	 */
 #  if defined GSI_PLATFORM_NAME
-{
+	{
-struct cpu_info cpuInfo;
+	    struct cpu_info cpuInfo;
-index = 0;
+	    index = 0;
-if (getsysinfo(GSI_CPU_INFO, &cpuInfo, sizeof(cpuInfo), &index, NULL) > 0) {
+	    if (getsysinfo(GSI_CPU_INFO, &cpuInfo, sizeof(cpuInfo), &index, NULL) > 0) {
-cpuSpeed   = __MKUINT(cpuInfo.mhz);
+		cpuSpeed   = __MKUINT(cpuInfo.mhz);
-}
+	    }
-}
+	}
 #  endif
 # endif /* GSI_CPU_INFO */
 # if defined(GSI_CPUS_IN_BOX)
-index = 0;
+	index = 0;
-if (getsysinfo(GSI_CPUS_IN_BOX, &retInt32, sizeof(retInt32), &index, NULL) > 0) {
+	if (getsysinfo(GSI_CPUS_IN_BOX, &retInt32, sizeof(retInt32), &index, NULL) > 0) {
-numberOfCPUs   = __MKUINT(retInt32);
+	    numberOfCPUs   = __MKUINT(retInt32);
-}
+	}
 # endif /* GSI_CPUS_IN_BOX */
 # if defined(GSI_PHYSMEM)
-index = 0;
+	index = 0;
-if (getsysinfo(GSI_PHYSMEM, &retInt32, sizeof(retInt32), &index, NULL) > 0) {
+	if (getsysinfo(GSI_PHYSMEM, &retInt32, sizeof(retInt32), &index, NULL) > 0) {
-INT bytes = retInt32 * 1024;
+	    INT bytes = retInt32 * 1024;
-physicalRam   = __MKUINT(bytes);
+	    physicalRam   = __MKUINT(bytes);
-}
+	}
 # endif /* GSI_PHYSMEM */
 # if defined(GSI_PLATFORM_NAME) && (!defined(HAS_SYSINFO) || !defined(SI_PLATFORM))
 {
-char buffer[128];
+	char buffer[128];
-index = 0;
+	index = 0;
-if (getsysinfo(GSI_PLATFORM_NAME, buffer, sizeof(buffer), &index, NULL) > 0) {
+	if (getsysinfo(GSI_PLATFORM_NAME, buffer, sizeof(buffer), &index, NULL) > 0) {
-platform = __MKSTRING(buffer);
+	    platform = __MKSTRING(buffer);
-}
+	}
 }
 # endif /* GSI_PLATFORM_NAME */
 }
 #endif /* HAS_GETSYSINFO */
 cpuType = __MKSTRING("x86_64");
 #endif
 {
-extern OBJ __getInstructionSetInfo();
+	extern OBJ __getInstructionSetInfo();
-extendedInstructions = __getInstructionSetInfo();
+	extendedInstructions = __getInstructionSetInfo();
 }
 %}.
 sys isNil ifTrue:[
-sys := self getSystemType.
+	sys := self getSystemType.
 ].
 node isNil ifTrue:[
-node := self getHostName.
+	node := self getHostName.
 ].
 dom isNil ifTrue:[
-dom := self getDomainName.
+	dom := self getDomainName.
 ].
 mach isNil ifTrue:[
-mach := self getCPUType.
+	mach := self getCPUType.
 ].
 arch isNil ifTrue:[
-arch := sys.
+	arch := sys.
 ].
 info := IdentityDictionary new.
 info at:#system put:sys.
 info at:#node put:node.
 ver notNil ifTrue:[info at:#version put:ver].
 mach notNil ifTrue:[info at:#machine put:mach].
 arch notNil ifTrue:[info at:#architecture put:arch].
 dom notNil ifTrue:[info at:#domain put:dom].
 (pageSize notNil and:[physicalPages notNil]) ifTrue:[
-physicalRam := pageSize * physicalPages. "/ done here - could be largeInt.
+	physicalRam := pageSize * physicalPages. "/ done here - could be largeInt.
 ].
 physicalRam notNil ifTrue:[info at:#physicalRam put:physicalRam].
 (pageSize notNil and:[availablePages notNil]) ifTrue:[
-availableRam := pageSize * availablePages. "/ done here - could be largeInt.
+	availableRam := pageSize * availablePages. "/ done here - could be largeInt.
-availableRam notNil ifTrue:[info at:#availableRam put:availableRam].
+	availableRam notNil ifTrue:[info at:#availableRam put:availableRam].
 ].
 totalRam notNil ifTrue:[info at:#totalRam put:totalRam].
 sharedRam notNil ifTrue:[info at:#sharedRam put:sharedRam].
 bufferRam notNil ifTrue:[info at:#bufferRam put:bufferRam].
 virtualRam notNil ifTrue:[info at:#virtualRam put:virtualRam].
 #    undef SYS_SYMBOL
 #   endif
 %}.
 sys isNil ifTrue:[
-^ self getOSType
+	^ self getOSType
 ].
 ^ sys
 "
 OperatingSystem getSystemType
 "
 !
 isLinuxLike
 "return true, if the OS we're running on is a linux."
 %{  /* NOCONTEXT */
 #if defined(LINUX)
 RETURN ( true );
 #endif
 isProcessIdPresent:pid
 "answer true, if a process with process id pid is present, false if not"
 %{
 if (__isSmallInteger(pid)) {
-/* in UNIX, a kill(pid, 0) is a noop used to check if a pid exists */
+	/* in UNIX, a kill(pid, 0) is a noop used to check if a pid exists */
-if (kill(__smallIntegerVal(pid), 0) < 0 && errno != EPERM) {
+	if (kill(__smallIntegerVal(pid), 0) < 0 && errno != EPERM) {
-RETURN ( false );
+	    RETURN ( false );
-}
+	}
-RETURN ( true );
+	RETURN ( true );
 }
 %}.
 ^ self primitiveFailed:#invalidParameter
 !
 maxFileNameLength
 "return the max number of characters in a filename.
 CAVEAT:
-Actually, the following is somewhat wrong - some systems
+	 Actually, the following is somewhat wrong - some systems
-support different sizes, depending on the volume.
+	 support different sizes, depending on the volume.
-We return a somewhat conservative number here.
+	 We return a somewhat conservative number here.
-Another entry, to query for volume specific max
+	 Another entry, to query for volume specific max
-will be added in the future."
+	 will be added in the future."
 %{  /* NOCONTEXT */
 /*
 * TODO: new systems provide a query function for this ... use it
 %{
 long l;
 l = sysconf(_SC_OPEN_MAX);
 if (l >= 0) {
-RETURN(__mkSmallInteger(l));
+	 RETURN(__mkSmallInteger(l));
 }
 %}.
 self primitiveFailed
 "
 !
 primGetDomainName
 "return the domain this host is in.
 Notice:
-not all systems support this; on some, nil is returned."
+	not all systems support this; on some, nil is returned."
 %{  /* STACK: 2048 */
 #if defined(HAS_GETDOMAINNAME)
 char buffer[256];
 if (getdomainname(buffer, sizeof(buffer)) == 0) {
-RETURN (__MKSTRING(buffer));
+	RETURN (__MKSTRING(buffer));
 }
 #else
 # if defined(HAS_UNAME) && defined(HAS_UTS_DOMAINNAME)
 struct utsname ubuff;
 if (uname(&ubuff) >= 0) {
-RETURN (__MKSTRING(ubuff.domainname));
+	RETURN (__MKSTRING(ubuff.domainname));
 }
 # else
 #  if defined(HAS_SYSINFO) && defined(SI_SRPC_DOMAIN)
 char buffer[256];
 int ret;
 if ((ret = sysinfo(SI_SRPC_DOMAIN, buffer, sizeof(buffer))) >= 0 && ret <= sizeof(buffer)) {
-RETURN (__MKSTRING(buffer));
+	RETURN (__MKSTRING(buffer));
 }
 #  endif
 # endif
 #endif
 %}.
 primGetHostName
 "return the hostname we are running on - if there is
 a HOST environment variable, we are much faster here ...
 Notice:
-not all systems support this; on some, nil is returned."
+	not all systems support this; on some, nil is returned."
 %{  /* STACK: 100000 */
 /* sigh - with libc.so.6, gethostname needs huge amounts of stack
 * actually this is linux specific, but should not hurt others
 */
 #if defined(HAS_GETHOSTNAME)
 char buffer[256];
 if (gethostname(buffer, sizeof(buffer)) == 0) {
-RETURN (__MKSTRING(buffer));
+	RETURN (__MKSTRING(buffer));
 }
 #else
 # if defined(HAS_UNAME)
 struct utsname ubuff;
 if (uname(&ubuff) >= 0) {
-RETURN (__MKSTRING(ubuff.nodename));
+	RETURN (__MKSTRING(ubuff.nodename));
 }
 # else
 #  if defined(HAS_SYSINFO) && defined(SI_HOSTNAME)
 char buffer[256];
 int ret;
 if ((ret = sysinfo(SI_HOSTNAME, buffer, sizeof(buffer))) >= 0 && ret <= sizeof(buffer)) {
-RETURN (__MKSTRING(buffer));
+	RETURN (__MKSTRING(buffer));
 }
 #  endif
 # endif
 #endif
 %}.
 "
 !
 randomBytesInto:bufferOrInteger
 "If bufferOrInteger is a String or a ByteArray,
-fill a given buffer with random bytes from the RtlGenRandom function
+	fill a given buffer with random bytes from the RtlGenRandom function
-and answer the buffer.
+	and answer the buffer.
 If bufferOrInteger is a SmallInteger,
-return this many bytes (max 4) as a SmallInteger.
+	return this many bytes (max 4) as a SmallInteger.
 Return nil on error (may raise PrimitiveFailure, too).
 NOTE: This is a private interface, please use RandomGenerator!!"
 int wanted, cnt, gotSoFar = 0;
 char *buffer;
 if (__isSmallInteger(bufferOrInteger) && (wanted = __smallIntegerVal(bufferOrInteger) <= 4)) {
-int buf = 0;
+	int buf = 0;
-do {
+	do {
-cnt = getrandom(&buf + gotSoFar, wanted - gotSoFar, 0);
+	    cnt = getrandom(&buf + gotSoFar, wanted - gotSoFar, 0);
-if (cnt < 0) {
+	    if (cnt < 0) {
-if (errno != EINTR && errno != EAGAIN))
+		if (errno != EINTR && errno != EAGAIN))
-goto error;
+		    goto error;
-} else {
+	    } else {
-gotSoFar = gotSoFar + cnt;
+		gotSoFar = gotSoFar + cnt;
-}
+	    }
-} while (gotSoFar < wanted);
+	} while (gotSoFar < wanted);
-RETURN(__mkSmallInteger(buf));
+	RETURN(__mkSmallInteger(buf));
 } else if (__isByteArray(bufferOrinteger)) {
-wanted = __byteArraySize(bufferOrinteger);
+	wanted = __byteArraySize(bufferOrinteger);
-buffer = __byteArrayVal(bufferOrinteger);
+	buffer = __byteArrayVal(bufferOrinteger);
 } else if (__isString(bufferOrinteger)) {
-wanted = __stringSize(bufferOrinteger);
+	wanted = __stringSize(bufferOrinteger);
-buffer = __stringVal(bufferOrinteger);
+	buffer = __stringVal(bufferOrinteger);
 } else
-goto error;
+	goto error;
 do {
-cnt = getrandom(buffer + gotSoFar, wanted - gotSoFar, 0);
+	cnt = getrandom(buffer + gotSoFar, wanted - gotSoFar, 0);
-if (cnt < 0) {
+	if (cnt < 0) {
-if (errno != EINTR && errno != EAGAIN))
+	    if (errno != EINTR && errno != EAGAIN))
-goto error;
+		goto error;
-buffer = __isByteArray(bufferOrinteger) ?
+	    buffer = __isByteArray(bufferOrinteger) ?
-__byteArrayVal(bufferOrinteger) : __stringVal(bufferOrinteger);
+			__byteArrayVal(bufferOrinteger) : __stringVal(bufferOrinteger);
-} else {
+	} else {
-gotSoFar = gotSoFar + cnt;
+	    gotSoFar = gotSoFar + cnt;
-}
+	}
 } while (gotSoFar < wanted);
 RETURN(bufferOrinteger);
 # endif // linux
 #endif  // GRND_RANDOM
 %}.
 ^ self primitiveFailed.
 "
-self randomBytesInto:2.
+	self randomBytesInto:2.
-self randomBytesInto:(ByteArray new:16).
+	self randomBytesInto:(ByteArray new:16).
-self randomBytesInto:(String new:16).
+	self randomBytesInto:(String new:16).
 "
 !
 setEnvironment:aKeyStringOrSymbol to:aString
 "put a string to the environment.
 char *env;
 int valueSize;
 if (__isStringLike(aKeyStringOrSymbol)) {
-if (aString == nil) {
+	if (aString == nil) {
-/* env used only temporary for deregistration */
+	    /* env used only temporary for deregistration */
-valueSize = 0;
+	    valueSize = 0;
-env = __stringVal(aKeyStringOrSymbol);
+	    env = __stringVal(aKeyStringOrSymbol);
-} else if (__isStringLike(aString)) {
+	} else if (__isStringLike(aString)) {
-/* have to use stable memory for env */
+	    /* have to use stable memory for env */
-valueSize = __stringSize(aString);
+	    valueSize = __stringSize(aString);
-env = (char *)malloc(__stringSize(aKeyStringOrSymbol) + valueSize + 2);
+	    env = (char *)malloc(__stringSize(aKeyStringOrSymbol) + valueSize + 2);
-if (env == 0)
+	    if (env == 0)
-goto err;
+		goto err;
-strcpy(env, __stringVal(aKeyStringOrSymbol));
+	    strcpy(env, __stringVal(aKeyStringOrSymbol));
-strcat(env, "=");
+	    strcat(env, "=");
-strncat(env, __stringVal(aString), valueSize);
+	    strncat(env, __stringVal(aString), valueSize);
-} else
+	} else
-goto err;
+	    goto err;
-if (putenv(env) == 0) {
+	if (putenv(env) == 0) {
-RETURN(self);
+	    RETURN(self);
-}
+	}
-if (valueSize > 0) {
+	if (valueSize > 0) {
-/* could not register, free */
+	    /* could not register, free */
-free(env);
+	    free(env);
-}
+	}
 err:;
 }
 %}.
 ^ self primitiveFailed
 %{
 int __category;
 char *__locale, *ret;
 if (categorySymbol == @symbol(LC_ALL)) {
-__category = LC_ALL;
+	__category = LC_ALL;
 } else if (categorySymbol == @symbol(LC_COLLATE)) {
-__category = LC_COLLATE;
+	__category = LC_COLLATE;
 } else if (categorySymbol == @symbol(LC_CTYPE)) {
-__category = LC_CTYPE;
+	__category = LC_CTYPE;
 } else if (categorySymbol == @symbol(LC_MESSAGES)) {
-__category = LC_MESSAGES;
+	__category = LC_MESSAGES;
 } else if (categorySymbol == @symbol(LC_MONETARY)) {
-__category = LC_MONETARY;
+	__category = LC_MONETARY;
 } else if (categorySymbol == @symbol(LC_NUMERIC)) {
-__category = LC_NUMERIC;
+	__category = LC_NUMERIC;
 } else if (categorySymbol == @symbol(LC_TIME)) {
-__category = LC_TIME;
+	__category = LC_TIME;
 } else {
-error = @symbol(argument1);
+	error = @symbol(argument1);
-goto out;
+	goto out;
 }
 if (localeStringOrNil == nil) {
-__locale = 0;
+	__locale = 0;
 } else if (__isStringLike(localeStringOrNil)){
-__locale = __stringVal(localeStringOrNil);
+	__locale = __stringVal(localeStringOrNil);
 } else {
-error = @symbol(argument1);
+	error = @symbol(argument1);
-goto out;
+	goto out;
 }
 ret = setlocale(__category, __locale);
 if (ret) {
-locale = __MKSTRING(ret);
+	locale = __MKSTRING(ret);
 }
 out:;
 %}.
 locale notNil ifTrue:[
-^ locale.
+	^ locale.
 ].
 ^ self primitiveFailed:error.
 "
 OperatingSystem setLocale:#LC_ALL to:nil
 E.g. linux system calls return single byte strings only,
 so pathNames and command output comes UTF-8 encoded.
 (actually, on a mac, it comes utf8-mac encoded)."
 Codeset notNil ifTrue:[
-encodedPathNameOrOutputLine notNil ifTrue:[
+	encodedPathNameOrOutputLine notNil ifTrue:[
-[
+	    [
-"/ cg: I am not sure, why this shortcut.
+		"/ cg: I am not sure, why this shortcut.
-"/ calling the decoder directly should be much faster
+		"/ calling the decoder directly should be much faster
-Codeset == #utf8 ifTrue:[
+		Codeset == #utf8 ifTrue:[
-^ encodedPathNameOrOutputLine utf8Decoded.
+		    ^ encodedPathNameOrOutputLine utf8Decoded.
-].
+		].
-"/ Codeset encoder might not yet be initialized, sigh...
+		"/ Codeset encoder might not yet be initialized, sigh...
-CodesetEncoder isNil ifTrue:[
+		CodesetEncoder isNil ifTrue:[
-self getCodesetEncoder
+		    self getCodesetEncoder
-].
+		].
-CodesetEncoder notNil ifTrue:[
+		CodesetEncoder notNil ifTrue:[
-^ CodesetEncoder decodeString: encodedPathNameOrOutputLine
+		    ^ CodesetEncoder decodeString: encodedPathNameOrOutputLine
-].
+		].
-] on:InvalidEncodingError do:[:ex|
+	    ] on:InvalidEncodingError do:[:ex|
-"maybe there are old filenames in ISO8859-x,
+		"maybe there are old filenames in ISO8859-x,
-just keep them untranslated"
+		 just keep them untranslated"
-].
+	    ].
-].
+	].
 ].
 ^ encodedPathNameOrOutputLine
 "Modified: / 23-01-2013 / 10:02:05 / Jan Vrany <jan.vrany@fit.cvut.cz>"
 !
 minorVersionNr := Smalltalk minorVersionNr.
 vsnDirName := '%1.%2' bindWith:majorVersionNr with:minorVersionNr.
 sysPath := super defaultSystemPath.
 places :=
-#(
+	#(
-'/usr/local/lib/stx'
+	    '/usr/local/lib/stx'
-'/usr/local/lib/smalltalk'
+	    '/usr/local/lib/smalltalk'
-'/usr/local/lib/smalltalk-x'
+	    '/usr/local/lib/smalltalk-x'
-'/usr/lib/stx'
+	    '/usr/lib/stx'
-'/usr/lib/smalltalk'
+	    '/usr/lib/smalltalk'
-'/usr/lib/smalltalk-x'
+	    '/usr/lib/smalltalk-x'
-'/lib/stx'
+	    '/lib/stx'
-'/lib/smalltalk'
+	    '/lib/smalltalk'
-'/lib/smalltalk-x'
+	    '/lib/smalltalk-x'
-'/opt/stx'
+	    '/opt/stx'
-'/opt/smalltalk'
+	    '/opt/smalltalk'
-'/opt/smalltalk-x'
+	    '/opt/smalltalk-x'
-).
+	).
 self isOSXlike ifTrue:[
-places :=
+	places :=
-{
+	    {
-'/Library/Smalltalk-x' .
+		'/Library/Smalltalk-x' .
-(OperatingSystem pathOfSTXExecutable asFilename
+		(OperatingSystem pathOfSTXExecutable asFilename
-directory directory directory / 'Packages') name .
+		    directory directory directory / 'Packages') name .
 "/                (OperatingSystem pathOfSTXExecutable asFilename
 "/                    directory directory directory directory directory / 'Packages') name
-} , places.
+	    } , places.
 ].
 places do:[:dirName |
-|dir vsnDir|
+	|dir vsnDir|
-dir := dirName asFilename.
+	dir := dirName asFilename.
-(dir isDirectory) ifTrue:[
+	(dir isDirectory) ifTrue:[
-"/ try to guess a gnu-smalltalk; skip it
+	    "/ try to guess a gnu-smalltalk; skip it
-(dir construct:'initialize.st') exists ifFalse:[
+	    (dir construct:'initialize.st') exists ifFalse:[
-vsnDir := dir / vsnDirName.
+		vsnDir := dir / vsnDirName.
-vsnDir exists ifTrue:[
+		vsnDir exists ifTrue:[
-"/ new style: look for a major.minor directory there
+		    "/ new style: look for a major.minor directory there
-sysPath add:vsnDir.
+		    sysPath add:vsnDir.
-] ifFalse:[
+		] ifFalse:[
-"/ old style: look for a RELEASE file there and check if it matches
+		    "/ old style: look for a RELEASE file there and check if it matches
-releaseFile := dir construct:'RELEASE'.
+		    releaseFile := dir construct:'RELEASE'.
-releaseFile exists ifTrue:[
+		    releaseFile exists ifTrue:[
-s := releaseFile readStreamOrNil.
+			s := releaseFile readStreamOrNil.
-s notNil ifTrue:[
+			s notNil ifTrue:[
-v := Integer readFrom:s onError:-1.
+			    v := Integer readFrom:s onError:-1.
-s close.
+			    s close.
-v == majorVersionNr ifTrue:[
+			    v == majorVersionNr ifTrue:[
-sysPath add:dirName
+				sysPath add:dirName
-] ifFalse:[
+			    ] ifFalse:[
-('UnixOperatingSystem [info]: ignore files in ' , dir pathName , ' (RELEASE mismatch)') infoPrintCR.
+				('UnixOperatingSystem [info]: ignore files in ' , dir pathName , ' (RELEASE mismatch)') infoPrintCR.
-]
+			    ]
-] ifFalse:[
+			] ifFalse:[
-('UnixOperatingSystem [info]: ignore files in ' , dir pathName , ' (RELEASE missing)') infoPrintCR.
+			    ('UnixOperatingSystem [info]: ignore files in ' , dir pathName , ' (RELEASE missing)') infoPrintCR.
-]
+			]
-]
+		    ]
-]
+		]
-]
+	    ]
-]
+	]
 ].
 ^ sysPath
 "
 OperatingSystem defaultSystemPath
 E.g. linux system calls accept single byte strings only,
 so the pathName has been UTF-8 encoded, before using it in a system call
 (actually, on a mac, it has to be utf8-mac encoded)."
 Codeset notNil ifTrue:[
-pathName notNil ifTrue:[
+	pathName notNil ifTrue:[
-"/ cg: I am not sure, why this shortcut.
+	    "/ cg: I am not sure, why this shortcut.
-"/ calling the encoder directly should be much faster
+	    "/ calling the encoder directly should be much faster
-Codeset == #utf8 ifTrue:[
+	    Codeset == #utf8 ifTrue:[
-^ pathName utf8Encoded
+		^ pathName utf8Encoded
-].
+	    ].
-"/ Codeset encoder might not yet be initialized, sigh...
+	    "/ Codeset encoder might not yet be initialized, sigh...
-CodesetEncoder isNil ifTrue:[
+	    CodesetEncoder isNil ifTrue:[
-self getCodesetEncoder
+		self getCodesetEncoder
-].
+	    ].
-CodesetEncoder notNil ifTrue:[
+	    CodesetEncoder notNil ifTrue:[
-^ CodesetEncoder encodeString: pathName.
+		^ CodesetEncoder encodeString: pathName.
-].
+	    ].
-].
+	].
 ].
 ^ pathName
 "
 Codeset := #'utf8-mac'.
 |entries|
 entries := OrderedCollection new.
 ('/proc/mounts' asFilename) readingLinesDo:[:eachLine |
-|items mountInfo|
+	|items mountInfo|
-items := eachLine asCollectionOfWords.
+	items := eachLine asCollectionOfWords.
-mountInfo := (MountInfo new
+	mountInfo := (MountInfo new
-mountPointPath:(items at:2)
+	    mountPointPath:(items at:2)
-deviceOrRemotePath:(items at:1)
+	    deviceOrRemotePath:(items at:1)
-fsType:(items at:3)
+	    fsType:(items at:3)
-attributeString:(items at:4)).
+	    attributeString:(items at:4)).
-entries add:mountInfo
+	entries add:mountInfo
 ].
 ^ entries
 "
 OperatingSystem mountPointsFromProcFS
 void *address, *shmaddr;
 int shmflg, shmid;
 if (__isSmallInteger(addr)
 && __bothSmallInteger(flags, id)) {
-shmaddr = (void *) __intVal(addr);
+	shmaddr = (void *) __intVal(addr);
-shmflg = __intVal(flags);
+	shmflg = __intVal(flags);
-shmid = __intVal(id);
+	shmid = __intVal(id);
-address = shmat(shmid, shmaddr, shmflg);
+	address = shmat(shmid, shmaddr, shmflg);
-if (address != (void *)-1) {
+	if (address != (void *)-1) {
-RETURN (__MKEXTERNALBYTES(addr));
+	    RETURN (__MKEXTERNALBYTES(addr));
-}
+	}
-@global(LastErrorNumber) = __mkSmallInteger(errno);
+	@global(LastErrorNumber) = __mkSmallInteger(errno);
-RETURN (nil);
+	RETURN (nil);
 }
 #endif
 %}.
 ^ self primitiveFailed
 #ifdef WANT_SHM
 void *shmaddr;
 int rslt;
 if (__isSmallInteger(addr)) {
-shmaddr = (void *) __intVal(addr);
+	shmaddr = (void *) __intVal(addr);
-rslt = shmdt(shmaddr);
+	rslt = shmdt(shmaddr);
-if (rslt != -1) {
+	if (rslt != -1) {
-RETURN (true);
+	    RETURN (true);
-}
+	}
-@global(LastErrorNumber) = __mkSmallInteger(errno);
+	@global(LastErrorNumber) = __mkSmallInteger(errno);
-RETURN (false);
+	RETURN (false);
 }
 #endif
 %}.
 ^ self primitiveFailed
 %{  /* NOCONTEXT */
 #ifdef WANT_SHM
 if (__bothSmallInteger(key, size)
 && __isSmallInteger(flags)) {
-int rslt;
+	int rslt;
-rslt = shmget(__intVal(key), __intVal(size), __intVal(flags));
+	rslt = shmget(__intVal(key), __intVal(size), __intVal(flags));
-if (rslt != -1) {
+	if (rslt != -1) {
-RETURN (__mkSmallInteger(rslt));
+	    RETURN (__mkSmallInteger(rslt));
-}
+	}
-@global(LastErrorNumber) = __mkSmallInteger(errno);
+	@global(LastErrorNumber) = __mkSmallInteger(errno);
-RETURN (nil);
+	RETURN (nil);
 }
 #endif
 %}.
 ^ self primitiveFailed
 TIME_T t;
 if (__bothSmallInteger(y, m)
 && __bothSmallInteger(d, h)
 && __bothSmallInteger(min, s)) {
-tm.tm_hour = __intVal(h);
+	tm.tm_hour = __intVal(h);
-tm.tm_min = __intVal(min);
+	tm.tm_min = __intVal(min);
-tm.tm_sec = __intVal(s);
+	tm.tm_sec = __intVal(s);
-tm.tm_year = __intVal(y) - 1900;
+	tm.tm_year = __intVal(y) - 1900;
-tm.tm_mon = __intVal(m) - 1;
+	tm.tm_mon = __intVal(m) - 1;
-tm.tm_mday = __intVal(d);
+	tm.tm_mday = __intVal(d);
-tm.tm_isdst = -1;
+	tm.tm_isdst = -1;
 #ifndef HAS_MKTIME64
-if (__intVal(y) > 2038) goto outOfRange;
+	if (__intVal(y) > 2038) goto outOfRange;
-if (__intVal(y) == 2038) {
+	if (__intVal(y) == 2038) {
-if (__intVal(m) > 1) goto outOfRange;
+	    if (__intVal(m) > 1) goto outOfRange;
-if (__intVal(d) > 19) goto outOfRange;
+	    if (__intVal(d) > 19) goto outOfRange;
-if (__intVal(d) == 19) {
+	    if (__intVal(d) == 19) {
-if (__intVal(h) > 3) goto outOfRange;
+		if (__intVal(h) > 3) goto outOfRange;
-if (__intVal(h) == 3) {
+		if (__intVal(h) == 3) {
-if (__intVal(min) > 14) goto outOfRange;
+		    if (__intVal(min) > 14) goto outOfRange;
-if (__intVal(min) == 14) {
+		    if (__intVal(min) == 14) {
-if (__intVal(s) > 7) goto outOfRange;
+			if (__intVal(s) > 7) goto outOfRange;
-}
+		    }
-}
+		}
-}
+	    }
-}
+	}
 #endif
 #ifdef HAS_TIMEGM
-if (utcBoolean == true) {               /* convert to utc time */
+	if (utcBoolean == true) {               /* convert to utc time */
 # ifdef HAS_MKTIME64
-t = timegm64(&tm);                  /* timegm() interprets tm as utc time */
+	    t = timegm64(&tm);                  /* timegm() interprets tm as utc time */
 # else
-t = timegm(&tm);                    /* timegm() interprets tm as utc time */
+	    t = timegm(&tm);                    /* timegm() interprets tm as utc time */
 # endif
-} else
+	} else
 #endif
-{
+	{
 #ifdef HAS_MKTIME64
-t = mktime64(&tm);                  /* mktime() interprets tm as localtime */
+	    t = mktime64(&tm);                  /* mktime() interprets tm as localtime */
 #else
-t = mktime(&tm);                    /* mktime() interprets tm as localtime */
+	    t = mktime(&tm);                    /* mktime() interprets tm as localtime */
 #endif
-}
+	}
-if (t != (TIME_T)-1) {
+	if (t != (TIME_T)-1) {
 #ifndef HAS_TIMEGM
-if (utcBoolean == true) {           /* convert to utc time */
+	    if (utcBoolean == true) {           /* convert to utc time */
-// printf("tz=%d\n", TIMEZONE(&tm));
+		// printf("tz=%d\n", TIMEZONE(&tm));
-t = t - TIMEZONE(&tm);          /* TIMZONE = seconds westward from 0 */
+		t = t - TIMEZONE(&tm);          /* TIMZONE = seconds westward from 0 */
-}
+	    }
 #endif
 #ifdef HAS_MKTIME64
-osSeconds = __MKLARGEINT64(1, (t & 0xFFFFFFFF), (t>>32)& 0xFFFFFFFF);
+	    osSeconds = __MKLARGEINT64(1, (t & 0xFFFFFFFF), (t>>32)& 0xFFFFFFFF);
 #else
-/* be careful, t can be negative at the start of the epoch ! */
+	    /* be careful, t can be negative at the start of the epoch ! */
-osSeconds = __MKINT((INT)t);
+	    osSeconds = __MKINT((INT)t);
 #endif
-}
+	}
 }
 outOfRange: ;
 %}.
 osSeconds notNil ifTrue:[
-^ osSeconds * 1000 + millis
+	^ osSeconds * 1000 + millis
 ].
 ^ TimeConversionError raiseRequest.
 "
 OperatingSystem computeOSTimeFromYear:1970 month:1 day:1 hour:0 minute:0 second:0 millisecond:0 utc:true
 #if defined(_POSIX_MONOTONIC_CLOCK) && defined(CLOCK_MONOTONIC) && !defined(NO_CLOCK_GETTIME)
 struct timespec ts;
 static int has_clock_gettime = 1;
 if (has_clock_gettime) {
-if (clock_gettime(CLOCK_MONOTONIC, &ts) != -1) {
+	if (clock_gettime(CLOCK_MONOTONIC, &ts) != -1) {
-_secs = ts.tv_sec;
+	    _secs = ts.tv_sec;
-_micros  = ts.tv_nsec / 1000;
+	    _micros  = ts.tv_nsec / 1000;
-goto out;
+	    goto out;
-} else {
+	} else {
-/*
+	    /*
-* clock_gettime is not implemented in the kernel
+	     * clock_gettime is not implemented in the kernel
-* fall through to alternative implementation
+	     * fall through to alternative implementation
-*/
+	     */
-has_clock_gettime = 0;
+	    has_clock_gettime = 0;
-}
+	}
 }
 #endif
 #if defined(HAS_GETTIMEOFDAY)
 struct timeval tb;
 gettimeofday(&tb, NULL /* &tzb */);
 if (tb.tv_usec >= (1000000)) {
-error = @symbol(bad);
+	error = @symbol(bad);
-goto err;
+	goto err;
 }
 _secs = tb.tv_sec;
 _micros  = tb.tv_usec;
 #endif
 out:
 #if __POINTER_SIZE__ == 8
 {
-unsigned INT rslt;
+	unsigned INT rslt;
-rslt = (unsigned INT)_secs * 1000000 + _micros;
+	rslt = (unsigned INT)_secs * 1000000 + _micros;
-RETURN (__MKUINT(rslt));
+	RETURN (__MKUINT(rslt));
 }
 #else
 # ifdef HAS_LONGLONG
 {
-unsigned long long rslt;
+	unsigned long long rslt;
-rslt = (unsigned long long)_secs * 1000000 + _micros;
+	rslt = (unsigned long long)_secs * 1000000 + _micros;
-RETURN (__MKLARGEINT64(1, (unsigned INT)(rslt & 0xFFFFFFFF), (unsigned INT)(rslt >> 32)));
+	RETURN (__MKLARGEINT64(1, (unsigned INT)(rslt & 0xFFFFFFFF), (unsigned INT)(rslt >> 32)));
 }
 # else
 seconds = __MKUINT(_secs);
 micros = __MKUINT(_micros);
 # endif /* long long */
 #endif /* __POINTER_SIZE__ == 8 */
 err:;
 %}.
 seconds notNil ifTrue:[
-^ (seconds * 1000000) + micros
+	^ (seconds * 1000000) + micros
 ].
 error isNil ifTrue:[
-^ self getMillisecondTime * 1000
+	^ self getMillisecondTime * 1000
 ].
 self primitiveFailed:error.
 "
 Transcript showCR:(OperatingSystem getMicrosecondTime).
 Since this value is wrapping around in regular intervals, this can only be used for
 short relative time deltas.
 Use the XXXmillisecondTime:-methods to compare and add time deltas - these know about the wrap.
 BAD DESIGN:
-This should be changed to return some instance of RelativeTime,
+	This should be changed to return some instance of RelativeTime,
-and these computations moved there.
+	and these computations moved there.
 Don't use this method in application code since it is an internal (private)
 interface. For compatibility with ST-80, use Time millisecondClockValue.
 "
 #if defined(_POSIX_MONOTONIC_CLOCK) && defined(CLOCK_MONOTONIC) && !defined(NO_CLOCK_GETTIME)
 static has_clock_gettime = 1;
 struct timespec ts;
 if (has_clock_gettime) {
-if (clock_gettime(CLOCK_MONOTONIC, &ts) != -1) {
+	if (clock_gettime(CLOCK_MONOTONIC, &ts) != -1) {
-t = ts.tv_sec*1000 + ts.tv_nsec/1000000;
+	    t = ts.tv_sec*1000 + ts.tv_nsec/1000000;
-goto out;
+	    goto out;
-} else {
+	} else {
-/*
+	    /*
-* clock_gettime is not implemented in the kernel
+	     * clock_gettime is not implemented in the kernel
-* fall through to alternative implementation
+	     * fall through to alternative implementation
-*/
+	     */
-has_clock_gettime = 0;
+	    has_clock_gettime = 0;
-}
+	}
 }
 #endif /*  _POSIX_MONOTONIC_CLOCK */
 #if defined(_SC_CLK_TCK)
 /*
 static int millisecondsPerTick;
 clock_t ticks;
 struct tms tb;
 if (!millisecondsPerTick) {
-int ticksPerSecond = sysconf(_SC_CLK_TCK);
+	int ticksPerSecond = sysconf(_SC_CLK_TCK);
-if (ticksPerSecond <= 0)
+	if (ticksPerSecond <= 0)
-goto err;
+	    goto err;
-if (ticksPerSecond > 1000)
+	if (ticksPerSecond > 1000)
-goto err;
+	    goto err;
-millisecondsPerTick = 1000 / ticksPerSecond;
+	millisecondsPerTick = 1000 / ticksPerSecond;
 /*
 printf("milliSecondsPerTick: %d\n", millisecondsPerTick);
 */
 }
 ticks = times(&tb);
 if (ticks == -1)
-goto err;
+	goto err;
 t = ticks * millisecondsPerTick;
 #else /* !times */
 unsigned long _secs, _millis;
 #if !defined(HAS_GETTIMEOFDAY)
 # if defined(HAS_FTIME)
 {
-struct timeb timebuffer;
+	struct timeb timebuffer;
-ftime(&timebuffer);
+	ftime(&timebuffer);
-_secs = timebuffer.time;
+	_secs = timebuffer.time;
-_millis = timebuffer.millitm;
+	_millis = timebuffer.millitm;
 }
 #   define HAVE_TIME
 # endif /* HAS_FTIME */
 #endif /* no HAS_GETTIMEOFDAY */
 * use HAS_GETTIMEOFDAY even if HAS_GETTIMEOFDAY is undefined here.
 * Will result in a linkage error if not fixed and neither ftime() nor time() is used.
 */
 {
-/*
+	/*
-* bsd time
+	 * bsd time
-*/
+	 */
-struct timeval tb;
+	struct timeval tb;
-/* struct timezone tzb; */
+	/* struct timezone tzb; */
-gettimeofday(&tb, NULL /* &tzb */);
+	gettimeofday(&tb, NULL /* &tzb */);
-_secs = tb.tv_sec;
+	_secs = tb.tv_sec;
-_millis = tb.tv_usec / 1000;
+	_millis = tb.tv_usec / 1000;
 }
 #endif
 #if __POINTER_SIZE__ == 8
 {
-unsigned INT rslt;
+	unsigned INT rslt;
-rslt = (unsigned INT)_secs * 1000 + _millis;
+	rslt = (unsigned INT)_secs * 1000 + _millis;
-RETURN (__MKUINT(rslt));
+	RETURN (__MKUINT(rslt));
 }
 #else
 # ifdef HAS_LONGLONG
 {
-unsigned long long rslt;
+	unsigned long long rslt;
-rslt = (unsigned long long)_secs * 1000 + _millis;
+	rslt = (unsigned long long)_secs * 1000 + _millis;
-RETURN (__MKLARGEINT64(1, (unsigned INT)(rslt & 0xFFFFFFFF), (unsigned INT)(rslt >> 32)));
+	RETURN (__MKLARGEINT64(1, (unsigned INT)(rslt & 0xFFFFFFFF), (unsigned INT)(rslt >> 32)));
 }
 # else
 seconds = __MKUINT(_secs);
 millis = __MKUINT(_millis);
 # endif /* long long */
 #endif /* __POINTER_SIZE__ == 8 */
 %}.
 seconds notNil ifTrue:[
-^ (seconds * 1000) + millis
+	^ (seconds * 1000) + millis
 ].
 self primitiveFailed.
 only the calling thread sleep)."
 %{  /* NOCONTEXT */
 if (__isSmallInteger(numberOfSeconds)) {
-sleep(__intVal(numberOfSeconds));
+	sleep(__intVal(numberOfSeconds));
-RETURN ( self );
+	RETURN ( self );
 }
 %}.
 "
 argument not integer
 "
 %{
 struct tm tmValue, *result;
 time_t tt = __signedLongIntVal(osSeconds);
 if (tt == 0 && !__isSmallInteger(osSeconds))
-goto out;             // __singedLongIntVal() returns 0 on failure
+	goto out;             // __singedLongIntVal() returns 0 on failure
 /* try cache */
 {
-OBJ lastSeconds = @global(LastTimeInfoSeconds);
+	OBJ lastSeconds = @global(LastTimeInfoSeconds);
-if (__isInteger(lastSeconds)
+	if (__isInteger(lastSeconds)
-&& (__signedLongIntVal(lastSeconds) == tt)
+	     && (__signedLongIntVal(lastSeconds) == tt)
-&& (@global(LastTimeInfoIsLocal) == isLocalTime)
+	     && (@global(LastTimeInfoIsLocal) == isLocalTime)
-) {
+	) {
-OBJ lastTimeInfo = @global(LastTimeInfo);
+	    OBJ lastTimeInfo = @global(LastTimeInfo);
-if (lastTimeInfo != nil) {
+	    if (lastTimeInfo != nil) {
-info = lastTimeInfo;
+		info = lastTimeInfo;
-goto out;
+		goto out;
-}
+	    }
-}
+	}
 }
 result = (isLocalTime == true) ? localtime_r(&tt, &tmValue) :  gmtime_r(&tt, &tmValue);
 if (result != NULL) {
-hours = __mkSmallInteger(tmValue.tm_hour);
+	hours = __mkSmallInteger(tmValue.tm_hour);
-minutes = __mkSmallInteger(tmValue.tm_min);
+	minutes = __mkSmallInteger(tmValue.tm_min);
-seconds = __mkSmallInteger(tmValue.tm_sec);
+	seconds = __mkSmallInteger(tmValue.tm_sec);
-year = __mkSmallInteger(tmValue.tm_year + 1900);
+	year = __mkSmallInteger(tmValue.tm_year + 1900);
-month = __mkSmallInteger(tmValue.tm_mon + 1);
+	month = __mkSmallInteger(tmValue.tm_mon + 1);
-day = __mkSmallInteger(tmValue.tm_mday);
+	day = __mkSmallInteger(tmValue.tm_mday);
-yDay = __mkSmallInteger(tmValue.tm_yday+1);
+	yDay = __mkSmallInteger(tmValue.tm_yday+1);
-wDay = __mkSmallInteger(tmValue.tm_wday == 0 ? 7 : tmValue.tm_wday);
+	wDay = __mkSmallInteger(tmValue.tm_wday == 0 ? 7 : tmValue.tm_wday);
-utcOffset = __mkSmallInteger(TIMEZONE(&tmValue));
+	utcOffset = __mkSmallInteger(TIMEZONE(&tmValue));
-dst = (tmValue.tm_isdst == 0 ? false : true);
+	dst = (tmValue.tm_isdst == 0 ? false : true);
 }
 out:;
 %}.
 info notNil ifTrue:[
-"there is a matching cached value"
+	"there is a matching cached value"
-LastTimeInfoMilliseconds == osMilliseconds ifTrue:[
+	LastTimeInfoMilliseconds == osMilliseconds ifTrue:[
-^ info.
+	    ^ info.
-].
+	].
-info := info copy.
+	info := info copy.
-info milliseconds:osMilliseconds.
+	info milliseconds:osMilliseconds.
 ] ifFalse:[
-year isNil ifTrue:[
+	year isNil ifTrue:[
-TimeConversionError raiseErrorString:' - out of range'.
+	    TimeConversionError raiseErrorString:' - out of range'.
-].
+	].
-info := self timeInfoClass new.
+	info := self timeInfoClass new.
-info
+	info
-year:year
+	    year:year
-month:month
+	    month:month
-day:day
+	    day:day
-hours:hours
+	    hours:hours
-minutes:minutes
+	    minutes:minutes
-seconds:seconds
+	    seconds:seconds
-milliseconds:osMilliseconds
+	    milliseconds:osMilliseconds
-utcOffset:utcOffset
+	    utcOffset:utcOffset
-dst:dst
+	    dst:dst
-dayInYear:yDay
+	    dayInYear:yDay
-dayInWeek:wDay.
+	    dayInWeek:wDay.
 ].
 %{
 @global(LastTimeInfo) = info;                       __GSTORE(info);
 @global(LastTimeInfoSeconds) = osSeconds;           __GSTORE(osSeconds);
 |info gecos|
 info := self userInfoOf:userID.
 (info notNil
 and:[info includesKey:#gecos]) ifTrue:[
-gecos := info at:#gecos.
+	gecos := info at:#gecos.
-(gecos includes:$,) ifTrue:[
+	(gecos includes:$,) ifTrue:[
-^ gecos copyTo:(gecos indexOf:$,) - 1
+	    ^ gecos copyTo:(gecos indexOf:$,) - 1
-].
+	].
-^ gecos
+	^ gecos
 ].
 ^ self getUserNameFromID:userID
 "
 OperatingSystem getFullUserNameFromID:0
 %{  /* NOCONTEXT */
 struct group *g;
 if (__isSmallInteger(aNumber)) {
-g = getgrgid(__intVal(aNumber));
+	g = getgrgid(__intVal(aNumber));
-if (g) {
+	if (g) {
-RETURN ( __MKSTRING(g->gr_name) );
+	    RETURN ( __MKSTRING(g->gr_name) );
-}
+	}
 }
 %}.
 ^ '???'
 "
 |homeDir|
 homeDir := self getEnvironment:'HOME'.
 homeDir isNil ifTrue:[
-"/ mhmh - can only happen if started via some uncorrectly
+	"/ mhmh - can only happen if started via some uncorrectly
-"/ initialized subprocess...
+	"/ initialized subprocess...
-'UnixOperatingSystem [warning]: cannot figure out home directory' errorPrintCR.
+	'UnixOperatingSystem [warning]: cannot figure out home directory' errorPrintCR.
-homeDir := '/tmp'.
+	homeDir := '/tmp'.
 ].
 ^ self decodePath:homeDir
 "
 OperatingSystem getHomeDirectory
 extern char *getlogin();
 char *name = (char *)0;
 if (firstCall) {
-/*
+	/*
-* try a few common environment variables ...
+	 * try a few common environment variables ...
-*/
+	 */
-name = getenv("LOGNAME");
+	name = getenv("LOGNAME");
-if (! name || (name[0] == 0)) {
+	if (! name || (name[0] == 0)) {
-name = getlogin();
+	    name = getlogin();
-if (! name || (name[0] == 0) ) {
+	    if (! name || (name[0] == 0) ) {
-name = getenv("LOGIN");
+		name = getenv("LOGIN");
-if (! name || (name[0] == 0) ) {
+		if (! name || (name[0] == 0) ) {
-name = getenv("USER");
+		    name = getenv("USER");
-}
+		}
-}
+	    }
-}
+	}
-if (name && (strlen(name) < sizeof(cachedName))) {
+	if (name && (strlen(name) < sizeof(cachedName))) {
-strcpy(cachedName, name);
+	    strcpy(cachedName, name);
-firstCall = 0;
+	    firstCall = 0;
-}
+	}
 } else {
-name = cachedName;
+	name = cachedName;
 }
 /*
-* nope - I really font know who you are.
+* nope - I really dont know who you are.
 */
 if (! name || (name[0] == 0) ) {
-name = "you";
+	name = "you";
 }
 RETURN ( __MKSTRING(name) );
 %}.
 "
 # ifndef NO_PWD
 struct passwd *p;
 if (__isSmallInteger(aNumber)) {
-p = getpwuid(__intVal(aNumber));
+	p = getpwuid(__intVal(aNumber));
-if (p) {
+	if (p) {
-RETURN ( __MKSTRING(p->pw_name) );
+	    RETURN ( __MKSTRING(p->pw_name) );
-}
+	}
 }
 #endif /* unix-like */
 %}.
 aNumber == self getUserID ifTrue:[
-^ self getLoginName
+	^ self getLoginName
 ].
 ^ '? (' , aNumber printString , ')'
 "
 #if defined(_POSIX_SOURCE)
 char buf[4096];
 struct passwd pwd;
 if (__isStringLike(aNameOrID)) {
-getpwnam_r(__stringVal(aNameOrID), &pwd, buf, sizeof(buf), &result);
+	getpwnam_r(__stringVal(aNameOrID), &pwd, buf, sizeof(buf), &result);
 } else if (__isSmallInteger(aNameOrID)) {
-getpwuid_r(__intVal(aNameOrID), &pwd, buf, sizeof(buf), &result);
+	getpwuid_r(__intVal(aNameOrID), &pwd, buf, sizeof(buf), &result);
 }
 #else
 if (__isStringLike(aNameOrID)) {
-result = getpwnam(__stringVal(aNameOrID));
+	result = getpwnam(__stringVal(aNameOrID));
 } else if (__isSmallInteger(aNameOrID)) {
-result = getpwuid(__intVal(aNameOrID));
+	result = getpwuid(__intVal(aNameOrID));
 }
 #endif /* ! _POSIX_SOURCE */
 if (result) {
-returnArray = __ARRAY_NEW_INT(20);
+	returnArray = __ARRAY_NEW_INT(20);
-__PROTECT__(returnArray);
+	__PROTECT__(returnArray);
-tmp = __MKSTRING(result->pw_name);
+	tmp = __MKSTRING(result->pw_name);
-__UNPROTECT__(returnArray);
+	__UNPROTECT__(returnArray);
-__arrayVal(returnArray)[idx++] = @symbol(name);
+	__arrayVal(returnArray)[idx++] = @symbol(name);
-__arrayVal(returnArray)[idx++] = tmp; __STORE(returnArray, tmp);
+	__arrayVal(returnArray)[idx++] = tmp; __STORE(returnArray, tmp);
 #  ifndef NO_PWD_PASSWD
-__PROTECT__(returnArray);
+	__PROTECT__(returnArray);
-tmp = __MKSTRING(result->pw_passwd);
+	tmp = __MKSTRING(result->pw_passwd);
-__UNPROTECT__(returnArray);
+	__UNPROTECT__(returnArray);
-__arrayVal(returnArray)[idx++] = @symbol(passwd);
+	__arrayVal(returnArray)[idx++] = @symbol(passwd);
-__arrayVal(returnArray)[idx++] = tmp; __STORE(returnArray, tmp);
+	__arrayVal(returnArray)[idx++] = tmp; __STORE(returnArray, tmp);
 #  endif
 #  ifdef SYSV4
-__PROTECT__(returnArray);
+	__PROTECT__(returnArray);
-tmp = __MKSTRING(result->pw_age);
+	tmp = __MKSTRING(result->pw_age);
-__UNPROTECT__(returnArray);
+	__UNPROTECT__(returnArray);
-__arrayVal(returnArray)[idx++] = @symbol(age);
+	__arrayVal(returnArray)[idx++] = @symbol(age);
-__arrayVal(returnArray)[idx++] = tmp; __STORE(returnArray, tmp);
+	__arrayVal(returnArray)[idx++] = tmp; __STORE(returnArray, tmp);
-__PROTECT__(returnArray);
+	__PROTECT__(returnArray);
-tmp = __MKSTRING(result->pw_comment);
+	tmp = __MKSTRING(result->pw_comment);
-__UNPROTECT__(returnArray);
+	__UNPROTECT__(returnArray);
-__arrayVal(returnArray)[idx++] = @symbol(comment);
+	__arrayVal(returnArray)[idx++] = @symbol(comment);
-__arrayVal(returnArray)[idx++] = tmp; __STORE(returnArray, tmp);
+	__arrayVal(returnArray)[idx++] = tmp; __STORE(returnArray, tmp);
 #  endif
-__PROTECT__(returnArray);
+	__PROTECT__(returnArray);
-tmp = __MKSTRING(result->pw_dir);
+	tmp = __MKSTRING(result->pw_dir);
-__UNPROTECT__(returnArray);
+	__UNPROTECT__(returnArray);
-__arrayVal(returnArray)[idx++] = @symbol(dir);
+	__arrayVal(returnArray)[idx++] = @symbol(dir);
-__arrayVal(returnArray)[idx++] = tmp; __STORE(returnArray, tmp);
+	__arrayVal(returnArray)[idx++] = tmp; __STORE(returnArray, tmp);
 #  ifndef NO_PWD_GECOS
-__PROTECT__(returnArray);
+	__PROTECT__(returnArray);
-tmp = __MKSTRING(result->pw_gecos);
+	tmp = __MKSTRING(result->pw_gecos);
-__UNPROTECT__(returnArray);
+	__UNPROTECT__(returnArray);
-__arrayVal(returnArray)[idx++] = @symbol(gecos);
+	__arrayVal(returnArray)[idx++] = @symbol(gecos);
-__arrayVal(returnArray)[idx++] = tmp; __STORE(returnArray, tmp);
+	__arrayVal(returnArray)[idx++] = tmp; __STORE(returnArray, tmp);
 #  endif
-__PROTECT__(returnArray);
+	__PROTECT__(returnArray);
-tmp = __MKSTRING(result->pw_shell);
+	tmp = __MKSTRING(result->pw_shell);
-__UNPROTECT__(returnArray);
+	 __UNPROTECT__(returnArray);
-__arrayVal(returnArray)[idx++] = @symbol(shell);
+	__arrayVal(returnArray)[idx++] = @symbol(shell);
-__arrayVal(returnArray)[idx++] = tmp; __STORE(returnArray, tmp);
+	__arrayVal(returnArray)[idx++] = tmp; __STORE(returnArray, tmp);
-__arrayVal(returnArray)[idx++] = @symbol(uid);
+	__arrayVal(returnArray)[idx++] = @symbol(uid);
-__arrayVal(returnArray)[idx++] = __mkSmallInteger(result->pw_uid);
+	__arrayVal(returnArray)[idx++] = __mkSmallInteger(result->pw_uid);
-__arrayVal(returnArray)[idx++] = @symbol(gid);
+	__arrayVal(returnArray)[idx++] = @symbol(gid);
-__arrayVal(returnArray)[idx++] = __mkSmallInteger(result->pw_gid);
+	__arrayVal(returnArray)[idx++] = __mkSmallInteger(result->pw_gid);
-RETURN(returnArray);
+	RETURN(returnArray);
 }
 # endif /* ! NO_PWD */
 %}.
 ^ nil
 infoArray := self primUserInfoOf:aNameOrID.
 info := IdentityDictionary new.
 infoArray notNil ifTrue:[
-infoArray pairWiseDo:[:key :value|
+	infoArray pairWiseDo:[:key :value|
-key notNil ifTrue:[
+	    key notNil ifTrue:[
-info at:key put:value.
+		info at:key put:value.
-key == #name ifTrue:[name := value].
+		key == #name ifTrue:[name := value].
-key == #dir  ifTrue:[dir := value].
+		key == #dir  ifTrue:[dir := value].
-].
+	    ].
-].
+	].
 ].
 name isNil ifTrue:[
-info at:#name put:#unknown
+	info at:#name put:#unknown
 ].
 dir isNil ifTrue:[
-aNameOrID == self getUserID ifTrue:[
+	aNameOrID == self getUserID ifTrue:[
-info at:#dir put:self getHomeDirectory
+	    info at:#dir put:self getHomeDirectory
-]
+	]
 ].
 ^ info
 "
 int s;
 #   define __WAIT      wait(&s)
 #   define __BLOCKING_WAIT__ 1
 if (blocking != true) {
-/*
+	/*
-* We do not support nonBlocking waits, so signal an error
+	 * We do not support nonBlocking waits, so signal an error
-* Sorry about the goto, but with all these ifdefs ...
+	 * Sorry about the goto, but with all these ifdefs ...
-*/
+	 */
-goto done;
+	goto done;
 }
 # endif /*!HAS_WAIT3*/
 #endif  /*!HAS_WAITPID*/
 #if !defined(WIFEXITED)
 #if __BLOCKING_WAIT__
 __BEGIN_INTERRUPTABLE__
 #endif
 do {
-p = __WAIT;
+	p = __WAIT;
 } while (p == -1 && errno == EINTR);
 #if __BLOCKING_WAIT__
 __END_INTERRUPTABLE__
 #  undef __BLOCKING_WAIT__
 #endif
 #undef __WAIT
 if (p == 0)
-RETURN(nil)
+	RETURN(nil)
 if (p == -1) {
-if (errno == ECHILD)
+	if (errno == ECHILD)
-RETURN(nil);
+	    RETURN(nil);
 } else {
-pid = __mkSmallInteger(p);
+	pid = __mkSmallInteger(p);
-if (WIFEXITED(s)) {
+	if (WIFEXITED(s)) {
-status = @symbol(exit);
+	    status = @symbol(exit);
-code = __mkSmallInteger(WEXITSTATUS(s));
+	    code = __mkSmallInteger(WEXITSTATUS(s));
-core = WCOREDUMP(s) ? true : false;
+	    core = WCOREDUMP(s) ? true : false;
-} else if (WIFSIGNALED(s)) {
+	} else if (WIFSIGNALED(s)) {
-status = @symbol(signal);
+	    status = @symbol(signal);
-code = __mkSmallInteger(WTERMSIG(s));
+	    code = __mkSmallInteger(WTERMSIG(s));
-} else if (WIFSTOPPED(s)) {
+	} else if (WIFSTOPPED(s)) {
-status = @symbol(stop);
+	    status = @symbol(stop);
-code = __mkSmallInteger(WSTOPSIG(s));
+	    code = __mkSmallInteger(WSTOPSIG(s));
-}
+	}
 #if defined(WIFCONTINUED)
-else if (WIFCONTINUED(s)) {
+	else if (WIFCONTINUED(s)) {
-status = @symbol(continue);
+	    status = @symbol(continue);
-}
+	}
 #endif
 }
 done: ;
 %}.
 (status isNil or:[pid isNil]) ifTrue:[
-^ self primitiveFailed
+	^ self primitiveFailed
 ].
 "/ Transcript show:'pid: '; show:pid; show:' status: '; show:status;
 "/ show:' code: '; show:code; show:' core:'; showCR:core.
 # elif defined(FNDELAY)
 #  define DELAY_FLAG FNDELAY
 # endif
 # if defined(DELAY_FLAG)
 if (__isSmallInteger(fd)) {
-int f = __intVal(fd);
+	int f = __intVal(fd);
-flags = fcntl(f, F_GETFL, 0);
+	flags = fcntl(f, F_GETFL, 0);
-RETURN ((flags & DELAY_FLAG) ? false : true );
+	RETURN ((flags & DELAY_FLAG) ? false : true );
 }
 #  undef DELAY_FLAG
 # endif
 #endif
 %}.
 /*
 * if available, try FIONREAD first, which is usually done faster.
 */
 # if 0 && defined(FIONREAD)
 {
-int n;
+	int n;
-if (__isSmallInteger(fd)) {
+	if (__isSmallInteger(fd)) {
-if (ioctl(__intVal(fd), FIONREAD, &n) >= 0) {
+	    if (ioctl(__intVal(fd), FIONREAD, &n) >= 0) {
-RETURN (__MKINT(n));
+		RETURN (__MKINT(n));
-}
+	    }
-}
+	}
 }
 # endif /* FIONREAD */
 %}.
 ^ (self readCheck:fd) ifTrue:[1] ifFalse:[0]
 !
 /*
 * if available, try FIONREAD first, which is usually done faster.
 */
 #if 0 && defined(FIONREAD)
 if (__isSmallInteger(fd)) {
-int result = 0;
+	int result = 0;
-if (ioctl(__smallIntegerVal(fd), FIONREAD, &result) >= 0) {
+	if (ioctl(__smallIntegerVal(fd), FIONREAD, &result) >= 0) {
-RETURN(result > 0 ? true : false);
+	    RETURN(result > 0 ? true : false);
-}
+	}
 }
 #endif /* FIONREAD */
 %}.
 ^ super readCheck:fd
 !
 selectOnAnyReadable:readFdArray writable:writeFdArray exception:exceptFdArray
-readableInto:readableResultFdArray writableInto:writableResultFdArray
+	readableInto:readableResultFdArray writableInto:writableResultFdArray
-exceptionInto:exceptionResultFdArray
+	exceptionInto:exceptionResultFdArray
-withTimeOut:millis
+	withTimeOut:millis
 "wait for any fd in readFdArray (an Array of integers) to become ready for reading,
 writeFdArray to become ready for writing,
 or exceptFdArray to arrive exceptional data (i.e. out-of-band data).
 Timeout after t milliseconds or - if the timeout time is 0 - immediately.
 int *pcntR = &cntR, *pcntW = &cntW, *pcntE = &cntE;
 int resultSizeReadable = 0, resultSizeWritable = 0, resultSizeException = 0;
 int numFds = 0;
 if (readableResultFdArray != nil) {
-if (! __isArrayLike(readableResultFdArray)) {
+	if (! __isArrayLike(readableResultFdArray)) {
-goto fail;
+	    goto fail;
-}
+	}
-resultSizeReadable = __arraySize(readableResultFdArray);
+	resultSizeReadable = __arraySize(readableResultFdArray);
 }
 if (writableResultFdArray != nil) {
-if (! __isArrayLike(writableResultFdArray)) {
+	if (! __isArrayLike(writableResultFdArray)) {
-goto fail;
+	    goto fail;
-}
+	}
-resultSizeWritable = __arraySize(writableResultFdArray);
+	resultSizeWritable = __arraySize(writableResultFdArray);
-if (readableResultFdArray == writableResultFdArray) {
+	if (readableResultFdArray == writableResultFdArray) {
-// allow common result set for read/write/except
+	    // allow common result set for read/write/except
-pcntW = &cntR;
+	    pcntW = &cntR;
-}
+	}
 }
 if (exceptionResultFdArray != nil) {
-if (! __isArrayLike(exceptionResultFdArray)) {
+	if (! __isArrayLike(exceptionResultFdArray)) {
-goto fail;
+	    goto fail;
-}
+	}
-resultSizeException = __arraySize(exceptionResultFdArray);
+	resultSizeException = __arraySize(exceptionResultFdArray);
-if (exceptionResultFdArray == readableResultFdArray) {
+	if (exceptionResultFdArray == readableResultFdArray) {
-// allow common result set for read/write/except
+	    // allow common result set for read/write/except
-pcntE = &cntR;
+	    pcntE = &cntR;
-} else if (exceptionResultFdArray == writableResultFdArray) {
+	} else if (exceptionResultFdArray == writableResultFdArray) {
-pcntE = &cntW;
+	    pcntE = &cntW;
-}
+	}
 }
 FD_ZERO(&rset);
 FD_ZERO(&wset);
 FD_ZERO(&eset);
 maxF = -1;
 if (readFdArray != nil) {
-int i, count;
+	int i, count;
-if (! __isArrayLike(readFdArray)) {
+	if (! __isArrayLike(readFdArray)) {
-goto fail;
+	    goto fail;
-}
+	}
-count = __arraySize(readFdArray);
+	count = __arraySize(readFdArray);
-for (i=0; i<count;i++) {
+	for (i=0; i<count;i++) {
-OBJ fd;
+	    OBJ fd;
-fd = __arrayVal(readFdArray)[i];
+	    fd = __arrayVal(readFdArray)[i];
-if (fd != nil) {
+	    if (fd != nil) {
-if (! __isSmallInteger(fd)) {
+		if (! __isSmallInteger(fd)) {
-if (@global(InfoPrinting) == true) {
+		    if (@global(InfoPrinting) == true) {
-fprintf(stderr, "OS [warning]: funny read-fd (0x%lx) given to select\n", (unsigned long)fd);
+			fprintf(stderr, "OS [warning]: funny read-fd (0x%lx) given to select\n", (unsigned long)fd);
-}
+		    }
-} else {
+		} else {
-int f;
+		    int f;
-f = __intVal(fd);
+		    f = __intVal(fd);
-if ((unsigned)f < FD_SETSIZE) {
+		    if ((unsigned)f < FD_SETSIZE) {
-FD_SET(f, &rset);
+			FD_SET(f, &rset);
-if (f > maxF) maxF = f;
+			if (f > maxF) maxF = f;
-numFds++;
+			numFds++;
-} else {
+		    } else {
-if (@global(InfoPrinting) == true) {
+			if (@global(InfoPrinting) == true) {
-fprintf(stderr, "OS [warning]: huge read-fd (0x%lx) given to select\n", (unsigned long)fd);
+			    fprintf(stderr, "OS [warning]: huge read-fd (0x%lx) given to select\n", (unsigned long)fd);
-}
+			}
-}
+		    }
-}
+		}
-}
+	    }
-}
+	}
 }
 if (writeFdArray != nil) {
-int i, count;
+	int i, count;
-if (! __isArrayLike(writeFdArray)) {
+	if (! __isArrayLike(writeFdArray)) {
-goto fail;
+	    goto fail;
-}
+	}
-count = __arraySize(writeFdArray);
+	count = __arraySize(writeFdArray);
-for (i=0; i<count;i++) {
+	for (i=0; i<count;i++) {
-OBJ fd;
+	    OBJ fd;
-fd = __arrayVal(writeFdArray)[i];
+	    fd = __arrayVal(writeFdArray)[i];
-if (fd != nil) {
+	    if (fd != nil) {
-if (! __isSmallInteger(fd)) {
+		if (! __isSmallInteger(fd)) {
-if (@global(InfoPrinting) == true) {
+		    if (@global(InfoPrinting) == true) {
-fprintf(stderr, "OS [warning]: funny write-fd (0x%lx) given to select\n", (unsigned long)fd);
+			fprintf(stderr, "OS [warning]: funny write-fd (0x%lx) given to select\n", (unsigned long)fd);
-}
+		    }
-} else {
+		} else {
-int f;
+		    int f;
-f = __intVal(fd);
+		    f = __intVal(fd);
-if ((unsigned)f < FD_SETSIZE) {
+		    if ((unsigned)f < FD_SETSIZE) {
-FD_SET(f, &wset);
+			FD_SET(f, &wset);
-if (f > maxF) maxF = f;
+			if (f > maxF) maxF = f;
-numFds++;
+			numFds++;
-} else {
+		    } else {
-if (@global(InfoPrinting) == true) {
+			if (@global(InfoPrinting) == true) {
-fprintf(stderr, "OS [warning]: huge write-fd (0x%lx) given to select\n", (unsigned long)fd);
+			    fprintf(stderr, "OS [warning]: huge write-fd (0x%lx) given to select\n", (unsigned long)fd);
-}
+			}
-}
+		    }
-}
+		}
-}
+	    }
-}
+	}
 }
 if (exceptFdArray != nil) {
-int i, count;
+	int i, count;
-if (! __isArrayLike(exceptFdArray)) {
+	if (! __isArrayLike(exceptFdArray)) {
-goto fail;
+	    goto fail;
-}
+	}
-count = __arraySize(exceptFdArray);
+	count = __arraySize(exceptFdArray);
-for (i=0; i<count;i++) {
+	for (i=0; i<count;i++) {
-OBJ fd;
+	    OBJ fd;
-fd = __arrayVal(exceptFdArray)[i];
+	    fd = __arrayVal(exceptFdArray)[i];
-if (fd != nil) {
+	    if (fd != nil) {
-if (! __isSmallInteger(fd)) {
+		if (! __isSmallInteger(fd)) {
-if (@global(InfoPrinting) == true) {
+		    if (@global(InfoPrinting) == true) {
-fprintf(stderr, "OS [warning]: funny except-fd (0x%lx) given to select\n", (unsigned long)fd);
+			fprintf(stderr, "OS [warning]: funny except-fd (0x%lx) given to select\n", (unsigned long)fd);
-}
+		    }
-} else {
+		} else {
-int f;
+		    int f;
-f = __intVal(fd);
+		    f = __intVal(fd);
-if ((unsigned)f < FD_SETSIZE) {
+		    if ((unsigned)f < FD_SETSIZE) {
-FD_SET(f, &eset);
+			FD_SET(f, &eset);
-if (f > maxF) maxF = f;
+			if (f > maxF) maxF = f;
-numFds++;
+			numFds++;
-} else {
+		    } else {
-if (@global(InfoPrinting) == true) {
+			if (@global(InfoPrinting) == true) {
-fprintf(stderr, "OS [warning]: huge except-fd (0x%lx) given to select\n", (unsigned long)fd);
+			    fprintf(stderr, "OS [warning]: huge except-fd (0x%lx) given to select\n", (unsigned long)fd);
-}
+			}
-}
+		    }
-}
+		}
-}
+	    }
-}
+	}
 }
 if (millis == nil) {
-wtp = NULL;         // wait forever
+	wtp = NULL;         // wait forever
 } else if (__isSmallInteger(millis)) {
-__millis = __intVal(millis);
+	__millis = __intVal(millis);
-if (__millis > 0) {
+	if (__millis > 0) {
-wt.tv_sec = __millis / 1000;
+	    wt.tv_sec = __millis / 1000;
-wt.tv_usec = (__millis % 1000) * 1000;
+	    wt.tv_usec = (__millis % 1000) * 1000;
-} else {
+	} else {
-wt.tv_sec = wt.tv_usec = 0;
+	    wt.tv_sec = wt.tv_usec = 0;
-}
+	}
-wtp = &wt;
+	wtp = &wt;
 } else {
-goto fail;
+	goto fail;
 }
 /*
 * make certain, that interrupt gets us out of the select
 * However, we must then care for moved objects.
 */
 __BEGIN_INTERRUPTABLE__
 if (__millis == 0) {
-/*
+	/*
-* if there is no timeout time, we can stay here interruptable.
+	 * if there is no timeout time, we can stay here interruptable.
-*/
+	 */
-do {
+	do {
-ret = select(maxF+1, &rset, &wset, &eset, wtp);
+	    ret = select(maxF+1, &rset, &wset, &eset, wtp);
-} while ((ret < 0) && (errno == EINTR));
+	} while ((ret < 0) && (errno == EINTR));
 } else {
-do {
+	do {
-ret = select(maxF+1, &rset, &wset, &eset, wtp);
+	    ret = select(maxF+1, &rset, &wset, &eset, wtp);
-/*
+	    /*
-* for now: don't loop; if we did, we had to adjust the vt-timeval;
+	     * for now: don't loop; if we did, we had to adjust the vt-timeval;
-* could otherwise stay in this loop forever ...
+	     * could otherwise stay in this loop forever ...
-* Premature ret (before the time expired) must be handled by the caller.
+	     * Premature ret (before the time expired) must be handled by the caller.
-* A good solution is to update the wt-timeval and redo the select.
+	     * A good solution is to update the wt-timeval and redo the select.
-*/
+	     */
-} while (0 /* (ret < 0) && (errno == EINTR) */ );
+	} while (0 /* (ret < 0) && (errno == EINTR) */ );
 }
 __END_INTERRUPTABLE__
 if (ret > 0) {
-OBJ *__resultR = __arrayVal(readableResultFdArray);
+	OBJ *__resultR = __arrayVal(readableResultFdArray);
-OBJ *__resultW = __arrayVal(writableResultFdArray);
+	OBJ *__resultW = __arrayVal(writableResultFdArray);
-OBJ *__resultE = __arrayVal(exceptionResultFdArray);
+	OBJ *__resultE = __arrayVal(exceptionResultFdArray);
-int i;
+	int i;
-for (i=0; i <= maxF; i++) {
+	for (i=0; i <= maxF; i++) {
-if (FD_ISSET(i, &rset)) {
+	    if (FD_ISSET(i, &rset)) {
-if (*pcntR < resultSizeReadable) {
+		if (*pcntR < resultSizeReadable) {
-__resultR[*pcntR] = __mkSmallInteger(i);
+		    __resultR[*pcntR] = __mkSmallInteger(i);
-}
+		}
-(*pcntR)++; cntAll++;
+		(*pcntR)++; cntAll++;
-}
+	    }
-if (FD_ISSET(i, &wset)) {
+	    if (FD_ISSET(i, &wset)) {
-if (*pcntW < resultSizeWritable) {
+		if (*pcntW < resultSizeWritable) {
-__resultW[*pcntW] = __mkSmallInteger(i);
+		    __resultW[*pcntW] = __mkSmallInteger(i);
-}
+		}
-(*pcntW)++; cntAll++;
+		(*pcntW)++; cntAll++;
-}
+	    }
-if (FD_ISSET(i, &eset)) {
+	    if (FD_ISSET(i, &eset)) {
-if (*pcntE < resultSizeException) {
+		if (*pcntE < resultSizeException) {
-__resultE[*pcntE] = __mkSmallInteger(i);
+		    __resultE[*pcntE] = __mkSmallInteger(i);
-}
+		}
-(*pcntE)++;  cntAll++;
+		(*pcntE)++;  cntAll++;
-}
+	    }
-}
+	}
-/* add a delimiter */
+	/* add a delimiter */
-if (*pcntR < resultSizeReadable) {
+	if (*pcntR < resultSizeReadable) {
-__resultR[*pcntR] = nil;
+	    __resultR[*pcntR] = nil;
-}
+	}
-if (*pcntW < resultSizeWritable) {
+	if (*pcntW < resultSizeWritable) {
-__resultW[*pcntW] = nil;
+	    __resultW[*pcntW] = nil;
-}
+	}
-if (*pcntE < resultSizeException) {
+	if (*pcntE < resultSizeException) {
-__resultE[*pcntE] = nil;
+	    __resultE[*pcntE] = nil;
-}
+	}
-RETURN (__mkSmallInteger(cntAll));
+	RETURN (__mkSmallInteger(cntAll));
 } else if (ret < 0 && errno != EINTR) {
-/*
+	/*
-* Error: Return -1
+	 * Error: Return -1
-*/
+	 */
-if (@global(InfoPrinting) == true) {
+	if (@global(InfoPrinting) == true) {
-fprintf(stderr, "OS [info]: select errno = %d\n", errno);
+	    fprintf(stderr, "OS [info]: select errno = %d\n", errno);
-}
+	}
-@global(LastErrorNumber) = __mkSmallInteger(errno);
+	@global(LastErrorNumber) = __mkSmallInteger(errno);
-RETURN (__mkSmallInteger(-1));
+	RETURN (__mkSmallInteger(-1));
 }
 /*
 * Return 0 (no filedescriptor ready)
 */
 # elif defined(FNDELAY)
 #  define DELAY_FLAG FNDELAY
 # endif
 # if defined(DELAY_FLAG)
 if (__isSmallInteger(fd)) {
-int f = __intVal(fd);
+	int f = __intVal(fd);
-flags = fcntl(f, F_GETFL, 0);
+	flags = fcntl(f, F_GETFL, 0);
-if (aBoolean == true) {
+	if (aBoolean == true) {
-ret = fcntl(f, F_SETFL, flags & ~DELAY_FLAG);
+	    ret = fcntl(f, F_SETFL, flags & ~DELAY_FLAG);
-} else if (aBoolean == false) {
+	} else if (aBoolean == false) {
-ret = fcntl(f, F_SETFL, flags | DELAY_FLAG);
+	    ret = fcntl(f, F_SETFL, flags | DELAY_FLAG);
-}
+	}
-if (ret >= 0) {
+	if (ret >= 0) {
-RETURN ((flags & DELAY_FLAG) ? false : true );
+	    RETURN ((flags & DELAY_FLAG) ? false : true );
-}
+	}
 }
 #  undef DELAY_FLAG
 # endif
 #endif
 %}.
 update:aspect with:argument from:anObject
 "one of our registered handles has been collected"
 aspect == #ElementExpired ifTrue:[
-OpenFiles keysAndValuesDo:[:fd :handle |
+	OpenFiles keysAndValuesDo:[:fd :handle |
-handle == 0 ifTrue:[
+	    handle == 0 ifTrue:[
-"Have to close the file descriptor"
+		"Have to close the file descriptor"
-OperatingSystem closeFd:fd.
+		OperatingSystem closeFd:fd.
-OpenFiles at:fd put:nil.
+		OpenFiles at:fd put:nil.
-].
+	    ].
-].
+	].
 ].
 "Created: 30.9.1997 / 12:57:35 / stefan"
 ! !
 initialize
 OpenFiles := WeakArray new:10.
 OpenFiles addDependent:self.
 "
-self initialize
+	self initialize
 "
 "Created: 26.9.1997 / 17:15:50 / stefan"
 "Modified: 30.9.1997 / 12:40:55 / stefan"
 ! !
 error:anErrorSymbolOrErrno
 "got an error; arg is either a symbol specifying a primitive error
 or the error number as returned by the OperatingSystem"
 anErrorSymbolOrErrno isInteger ifTrue:[
-(UnixOperatingSystem errorHolderForNumber:anErrorSymbolOrErrno) reportError
+	(UnixOperatingSystem errorHolderForNumber:anErrorSymbolOrErrno) reportError
 ].
 self primitiveFailed:anErrorSymbolOrErrno.
 ! !
 !UnixOperatingSystem::FileDescriptorHandle methodsFor:'file access'!
 Spotted by Martin Kobetic."
 oldHandle := OpenFiles at:aFileDescriptor ifAbsent: [nil].
 "/ the 0 is possible, if an fd was open when saving a snapshot image,
 "/ and we come up in the new image with no one referring to it.
 (oldHandle notNil and:[oldHandle ~~ 0 and:[ oldHandle ~~ self]]) ifTrue:[
-oldHandle invalidate.
+	oldHandle invalidate.
 ].
 self register.
 "Created: 26.9.1997 / 17:14:40 / stefan"
 "Modified: 30.9.1997 / 12:41:43 / stefan"
 INT fd;
 INT cnt, offs;
 int nInstBytes, objSize;
 if (! __isSmallInteger(__INST(fd))) {
-error = @symbol(errorNotOpen);
+	error = @symbol(errorNotOpen);
-goto bad;
+	goto bad;
 }
 if (! __bothSmallInteger(count, firstIndex)) {
-error = @symbol(badArgument);
+	error = @symbol(badArgument);
-goto bad;
+	goto bad;
 }
 fd = __smallIntegerVal(__INST(fd));
 cnt = __smallIntegerVal(count);
 offs = __smallIntegerVal(firstIndex) - 1;
 if (fd < 0) {
-error = @symbol(internalError);
+	error = @symbol(internalError);
-goto bad;
+	goto bad;
 }
 if (__isExternalBytesLike(aByteBuffer)) {
-OBJ sz;
+	OBJ sz;
-nInstBytes = 0;
+	nInstBytes = 0;
-extPtr = (char *)(__externalBytesAddress(aByteBuffer));
+	extPtr = (char *)(__externalBytesAddress(aByteBuffer));
-if (extPtr == NULL) goto bad;
+	if (extPtr == NULL) goto bad;
-sz = __externalBytesSize(aByteBuffer);
+	sz = __externalBytesSize(aByteBuffer);
-if (__isSmallInteger(sz)) {
+	if (__isSmallInteger(sz)) {
-objSize = __smallIntegerVal(sz);
+	    objSize = __smallIntegerVal(sz);
-} else {
+	} else {
-objSize = -1; /* unknown */
+	    objSize = -1; /* unknown */
-}
+	}
 } else {
-OBJ oClass = __Class(aByteBuffer);
+	OBJ oClass = __Class(aByteBuffer);
-int nInstVars = __intVal(__ClassInstPtr(oClass)->c_ninstvars);
+	int nInstVars = __intVal(__ClassInstPtr(oClass)->c_ninstvars);
-nInstBytes = OHDR_SIZE + __OBJS2BYTES__(nInstVars);
+	nInstBytes = OHDR_SIZE + __OBJS2BYTES__(nInstVars);
-switch (__intVal(__ClassInstPtr(oClass)->c_flags) & ARRAYMASK) {
+	switch (__intVal(__ClassInstPtr(oClass)->c_flags) & ARRAYMASK) {
-case BYTEARRAY:
+	    case BYTEARRAY:
-case WORDARRAY:
+	    case WORDARRAY:
-case LONGARRAY:
+	    case LONGARRAY:
-case SWORDARRAY:
+	    case SWORDARRAY:
-case SLONGARRAY:
+	    case SLONGARRAY:
-case FLOATARRAY:
+	    case FLOATARRAY:
-break;
+		break;
-case DOUBLEARRAY:
+	    case DOUBLEARRAY:
 #ifdef __NEED_DOUBLE_ALIGN
-nInstBytes = (nInstBytes-1+__DOUBLE_ALIGN) &~ (__DOUBLE_ALIGN-1);
+		nInstBytes = (nInstBytes-1+__DOUBLE_ALIGN) &~ (__DOUBLE_ALIGN-1);
 #endif
-break;
+		break;
-case LONGLONGARRAY:
+	    case LONGLONGARRAY:
-case SLONGLONGARRAY:
+	    case SLONGLONGARRAY:
 #ifdef __NEED_LONGLONG_ALIGN
-nInstBytes = (nInstBytes-1+__LONGLONG_ALIGN) &~ (__LONGLONG_ALIGN-1);
+		nInstBytes = (nInstBytes-1+__LONGLONG_ALIGN) &~ (__LONGLONG_ALIGN-1);
 #endif
-break;
+		break;
-default:
+	    default:
-goto bad;
+		goto bad;
-}
+	}
-extPtr = (char *)0;
+	extPtr = (char *)0;
-objSize = __Size(aByteBuffer) - nInstBytes;
+	objSize = __Size(aByteBuffer) - nInstBytes;
 }
 if ((offs >= 0)
-&& (cnt >= 0)
+	&& (cnt >= 0)
-&& ((objSize == -1) || (objSize >= (cnt + offs)))) {
+	&& ((objSize == -1) || (objSize >= (cnt + offs)))) {
-nRead = 0;
+	nRead = 0;
-do {
+	do {
-int n;
+	    int n;
-if (extPtr) {
+	    if (extPtr) {
-n = read(fd, extPtr+offs, cnt);
+		n = read(fd, extPtr+offs, cnt);
-} else {
+	    } else {
-char *bp;
+		char *bp;
-/*
+		/*
-* on interrupt, anObject may be moved to another location.
+		 * on interrupt, anObject may be moved to another location.
-* So we recompute the byte-address here.
+		 * So we recompute the byte-address here.
-*/
+		 */
-bp = __byteArrayVal(aByteBuffer) + nInstBytes;
+		bp = __byteArrayVal(aByteBuffer) + nInstBytes;
-n = read(fd, bp + offs, cnt);
+		n = read(fd, bp + offs, cnt);
-}
+	    }
-if (n > 0) {
+	    if (n > 0) {
-cnt -= n;
+		cnt -= n;
-offs += n;
+		offs += n;
-nRead += n;
+		nRead += n;
-} else if (n == 0) {
+	    } else if (n == 0) {
-break;
+		break;
-} else if (n < 0) {
+	    } else if (n < 0) {
-if (0
+		if (0
 #ifdef EWOULDBLOCK
-|| errno == EWOULDBLOCK
+		    || errno == EWOULDBLOCK
 #endif
 #ifdef EAGAIN
-|| errno == EAGAIN
+		    || errno == EAGAIN
 #endif
-) {
+		) {
-RETURN(nil);
+		     RETURN(nil);
-}
+		}
-if (errno != EINTR) {
+		if (errno != EINTR) {
-error = __mkSmallInteger(errno);
+		     error = __mkSmallInteger(errno);
-goto bad;
+		     goto bad;
-}
+		}
-__HANDLE_INTERRUPTS__;
+		__HANDLE_INTERRUPTS__;
-}
+	    }
-} while (cnt > 0);
+	} while (cnt > 0);
-RETURN (__mkSmallInteger(nRead));
+	RETURN (__mkSmallInteger(nRead));
 }
 bad: ;
 %}.
 ^ self error:error.
 INT fd;
 INT cnt, offs;
 int nInstBytes, objSize;
 if (! __isSmallInteger(__INST(fd))) {
-error = @symbol(errorNotOpen);
+	error = @symbol(errorNotOpen);
-goto bad;
+	goto bad;
 }
 if (! __bothSmallInteger(count, firstIndex)) {
-error = @symbol(badArgument);
+	error = @symbol(badArgument);
-goto bad;
+	goto bad;
 }
 fd = __smallIntegerVal(__INST(fd));
 cnt = __smallIntegerVal(count);
 offs = __smallIntegerVal(firstIndex) - 1;
 if (fd < 0) {
-error = @symbol(internalError);
+	error = @symbol(internalError);
-goto bad;
+	goto bad;
 }
 if (__isExternalBytesLike(aByteBuffer)) {
-OBJ sz;
+	OBJ sz;
-nInstBytes = 0;
+	nInstBytes = 0;
-extPtr = (char *)(__externalBytesAddress(aByteBuffer));
+	extPtr = (char *)(__externalBytesAddress(aByteBuffer));
-if (extPtr == NULL) goto bad;
+	if (extPtr == NULL) goto bad;
-sz = __externalBytesSize(aByteBuffer);
+	sz = __externalBytesSize(aByteBuffer);
-if (__isSmallInteger(sz)) {
+	if (__isSmallInteger(sz)) {
-objSize = __smallIntegerVal(sz);
+	    objSize = __smallIntegerVal(sz);
-} else {
+	} else {
-objSize = -1; /* unknown */
+	    objSize = -1; /* unknown */
-}
+	}
 } else {
-OBJ oClass = __Class(aByteBuffer);
+	OBJ oClass = __Class(aByteBuffer);
-int nInstVars = __intVal(__ClassInstPtr(oClass)->c_ninstvars);
+	int nInstVars = __intVal(__ClassInstPtr(oClass)->c_ninstvars);
-nInstBytes = OHDR_SIZE + __OBJS2BYTES__(nInstVars);
+	nInstBytes = OHDR_SIZE + __OBJS2BYTES__(nInstVars);
-switch (__intVal(__ClassInstPtr(oClass)->c_flags) & ARRAYMASK) {
+	switch (__intVal(__ClassInstPtr(oClass)->c_flags) & ARRAYMASK) {
-case BYTEARRAY:
+	    case BYTEARRAY:
-case WORDARRAY:
+	    case WORDARRAY:
-case LONGARRAY:
+	    case LONGARRAY:
-case SWORDARRAY:
+	    case SWORDARRAY:
-case SLONGARRAY:
+	    case SLONGARRAY:
-case FLOATARRAY:
+	    case FLOATARRAY:
-break;
+		break;
-case DOUBLEARRAY:
+	    case DOUBLEARRAY:
 #ifdef __NEED_DOUBLE_ALIGN
-nInstBytes = (nInstBytes-1+__DOUBLE_ALIGN) &~ (__DOUBLE_ALIGN-1);
+		nInstBytes = (nInstBytes-1+__DOUBLE_ALIGN) &~ (__DOUBLE_ALIGN-1);
 #endif
-break;
+		break;
-case LONGLONGARRAY:
+	    case LONGLONGARRAY:
-case SLONGLONGARRAY:
+	    case SLONGLONGARRAY:
 #ifdef __NEED_LONGLONG_ALIGN
-nInstBytes = (nInstBytes-1+__LONGLONG_ALIGN) &~ (__LONGLONG_ALIGN-1);
+		nInstBytes = (nInstBytes-1+__LONGLONG_ALIGN) &~ (__LONGLONG_ALIGN-1);
 #endif
-break;
+		break;
-default:
+	    default:
-goto bad;
+		goto bad;
-}
+	}
-extPtr = (char *)0;
+	extPtr = (char *)0;
-objSize = __Size(aByteBuffer) - nInstBytes;
+	objSize = __Size(aByteBuffer) - nInstBytes;
 }
 if ((offs >= 0)
-&& (cnt >= 0)
+	&& (cnt >= 0)
-&& ((objSize == -1) || (objSize >= (cnt + offs)))) {
+	&& ((objSize == -1) || (objSize >= (cnt + offs)))) {
-nWritten = 0;
+	nWritten = 0;
-do {
+	do {
-int n;
+	    int n;
-if (extPtr) {
+	    if (extPtr) {
-n = write(fd, extPtr+offs, cnt);
+		n = write(fd, extPtr+offs, cnt);
-} else {
+	    } else {
-char *bp;
+		char *bp;
-/*
+		/*
-* on interrupt, anObject may be moved to another location.
+		 * on interrupt, anObject may be moved to another location.
-* So we recompute the byte-address here.
+		 * So we recompute the byte-address here.
-*/
+		 */
-bp = __byteArrayVal(aByteBuffer) + nInstBytes;
+		bp = __byteArrayVal(aByteBuffer) + nInstBytes;
-n = write(fd, bp + offs, cnt);
+		n = write(fd, bp + offs, cnt);
-}
+	    }
-if (n > 0) {
+	    if (n > 0) {
-cnt -= n;
+		cnt -= n;
-offs += n;
+		offs += n;
-nWritten += n;
+		nWritten += n;
-} else if (n == 0) {
+	    } else if (n == 0) {
-break;
+		break;
-} else if (n < 0) {
+	    } else if (n < 0) {
-if (0
+		if (0
 #ifdef EWOULDBLOCK
-|| errno == EWOULDBLOCK
+		    || errno == EWOULDBLOCK
 #endif
 #ifdef EAGAIN
-|| errno == EAGAIN
+		    || errno == EAGAIN
 #endif
-) {
+		) {
-RETURN(nil);
+		     RETURN(nil);
-}
+		}
-if (errno != EINTR) {
+		if (errno != EINTR) {
-error = __mkSmallInteger(errno);
+		     error = __mkSmallInteger(errno);
-goto bad;
+		     goto bad;
-}
+		}
-__HANDLE_INTERRUPTS__;
+		__HANDLE_INTERRUPTS__;
-}
+	    }
-} while (cnt > 0);
+	} while (cnt > 0);
-RETURN (__mkSmallInteger(nWritten));
+	RETURN (__mkSmallInteger(nWritten));
 }
 bad: ;
 %}.
 ^ self error:error
 INT __whence;
 off_t pos, ret;
 OBJ rslt;
 if (! __isSmallInteger(__INST(fd))) {
-error = @symbol(errorNotOpen);
+	error = @symbol(errorNotOpen);
-goto bad;
+	goto bad;
 }
 if (__isSmallInteger(newPosition)) {
-pos = __smallIntegerVal(newPosition);
+	pos = __smallIntegerVal(newPosition);
 } else {
-pos = __signedLongIntVal(newPosition);
+	pos = __signedLongIntVal(newPosition);
-if (pos < 0 && (sizeof(pos) < 8 || __signedLong64IntVal(newPosition, &pos) == 0)) {
+	if (pos < 0 && (sizeof(pos) < 8 || __signedLong64IntVal(newPosition, &pos) == 0)) {
-error = @symbol(badArgument1);
+	    error = @symbol(badArgument1);
-goto bad;
+	    goto bad;
-}
+	}
 }
 fd = __smallIntegerVal(__INST(fd));
 if (fd < 0) {
-error = @symbol(internalError);
+	error = @symbol(internalError);
-goto bad;
+	goto bad;
 }
 if (whence == @symbol(begin)) {
-__whence = SEEK_SET;
+	__whence = SEEK_SET;
 } else if (whence == @symbol(current)) {
-__whence = SEEK_CUR;
+	__whence = SEEK_CUR;
 } else if (whence == @symbol(end)) {
-__whence = SEEK_END;
+	__whence = SEEK_END;
 } else {
-error = @symbol(badArgument2);
+	error = @symbol(badArgument2);
-goto bad;
+	goto bad;
 }
 again:
 ret = lseek(fd, pos, __whence);
 if (ret < 0) {
-if (errno == EINTR) {
+	if (errno == EINTR) {
-__HANDLE_INTERRUPTS__;
+	    __HANDLE_INTERRUPTS__;
-goto again;
+	    goto again;
-}
+	}
-error = __mkSmallInteger(errno);
+	error = __mkSmallInteger(errno);
-goto bad;
+	goto bad;
 }
 if (sizeof(ret) == 8) {
-rslt = __MKINT64 (&ret);
+	rslt = __MKINT64 (&ret);
 } else {
-rslt = __MKINT(ret);
+	rslt = __MKINT(ret);
 }
 RETURN (rslt);
 bad: ;
 %}.
 With 0 as timeout argument, this can be used to check for availability
 of read-data.
 Experimental."
 ^ OperatingSystem selectOnAnyReadable:(Array with:fd)
-writable:(Array with:fd)
+		      writable:(Array with:fd)
-exception:nil
+		     exception:nil
-withTimeOut:millis
+		   withTimeOut:millis
 "Created: 1.10.1997 / 08:51:11 / stefan"
 !
 setBlocking:aBoolean
 #   define DELAY_FLAG FNDELAY
 #  endif
 # endif
 # if defined(DELAY_FLAG)
 if (__isSmallInteger(__INST(fd))) {
-int f = __intVal(__INST(fd));
+	int f = __intVal(__INST(fd));
-flags = fcntl(f, F_GETFL, 0);
+	flags = fcntl(f, F_GETFL, 0);
-if (aBoolean == true) {
+	if (aBoolean == true) {
-ret = fcntl(f, F_SETFL, flags & ~DELAY_FLAG);
+	    ret = fcntl(f, F_SETFL, flags & ~DELAY_FLAG);
-} else {
+	} else {
-ret = fcntl(f, F_SETFL, flags | DELAY_FLAG);
+	    ret = fcntl(f, F_SETFL, flags | DELAY_FLAG);
-}
+	}
-if (ret >= 0) {
+	if (ret >= 0) {
-RETURN(__mkSmallInteger(flags));
+	    RETURN(__mkSmallInteger(flags));
-} else {
+	} else {
-err = __mkSmallInteger(errno);
+	    err = __mkSmallInteger(errno);
-}
+	}
 }
 # undef DELAY_FLAG
 # endif /* DELAY_FLAG */
 #endif
 %}.
 err notNil ifTrue:[
-self error:err
+	self error:err
 ].
 "
 fd argument not integer
 "
 ^ self primitiveFailed
 %{
 OBJ handle = __externalAddressVal(self);
 if (__isSmallInteger(handle)) {
-RETURN (handle);
+	RETURN (handle);
 }
 %}.
 ^ nil
 !
 setFileDescriptor:anInteger
 %{
 if (__isSmallInteger(anInteger)) {
-__externalAddressVal(self) = (OBJ)(__smallIntegerVal(anInteger));
+	__externalAddressVal(self) = (OBJ)(__smallIntegerVal(anInteger));
 }
 %}
 ! !
 %{
 int fd;
 if (__isSmallInteger(__INST(fd))) {
-fd = __smallIntegerVal(__INST(fd));
+	fd = __smallIntegerVal(__INST(fd));
-/*
+	/*
-* if available, try FIONREAD first, which is usually done faster.
+	 * if available, try FIONREAD first, which is usually done faster.
-*/
+	 */
 # ifdef FIONREAD
-{
+	{
-int result = 0;
+	    int result = 0;
-if (ioctl(fd, FIONREAD, &result) >= 0) {
+	    if (ioctl(fd, FIONREAD, &result) >= 0) {
-RETURN(result > 0 ? true : false);
+		RETURN(result > 0 ? true : false);
-}
+	    }
-}
+	}
 # endif /* FIONREAD */
 }
 %}.
 OperatingSystem supportsSelect ifFalse:[
-"/ mhmh - what should we do then ?
+	"/ mhmh - what should we do then ?
-"/ For now, return true as if data was present,
+	"/ For now, return true as if data was present,
-"/ and let the thread fall into the read.
+	"/ and let the thread fall into the read.
-"/ It will then (hopefully) be desceduled there and
+	"/ It will then (hopefully) be desceduled there and
-"/ effectively polling for input.
+	"/ effectively polling for input.
-^ true
+	^ true
 ].
 ^ (OperatingSystem selectOnAnyReadable:(Array with:fd)
-writable:nil
+		       writable:nil
-exception:nil
+		       exception:nil
-withTimeOut:0) == fd
+		       withTimeOut:0) == fd
 "
 |h n|
 h := OperatingSystem openFileForRead:'/etc/hosts'.
 n := h canReadWithoutBlocking.
 canWriteWithoutBlocking
 "return true, if filedescriptor can be written without blocking"
 OperatingSystem supportsSelect ifFalse:[
-"/ mhmh - what should we do then ?
+	"/ mhmh - what should we do then ?
-"/ For now, return true as if data was present,
+	"/ For now, return true as if data was present,
-"/ and let the thread fall into the write.
+	"/ and let the thread fall into the write.
-"/ It will then (hopefully) be desceduled there and
+	"/ It will then (hopefully) be desceduled there and
-"/ effectively polling for output.
+	"/ effectively polling for output.
-^ true
+	^ true
 ].
 ^ (OperatingSystem selectOnAnyReadable:nil
-writable:(Array with:fd)
+		       writable:(Array with:fd)
-exception:nil
+		       exception:nil
-withTimeOut:0) == fd
+		       withTimeOut:0) == fd
 !
 isValid
 "answer true, if the handle is valid, i.e. connected to
 a file or some other OS object"
 /*
 * if available, try FIONREAD first, which is usually done faster.
 */
 # if defined(FIONREAD)
 {
-int n = 0;
+	int n = 0;
-if (__isSmallInteger(__INST(fd))) {
+	if (__isSmallInteger(__INST(fd))) {
-if (ioctl(__smallIntegerVal(__INST(fd)), FIONREAD, &n) >= 0) {
+	    if (ioctl(__smallIntegerVal(__INST(fd)), FIONREAD, &n) >= 0) {
-RETURN (__MKINT(n));
+		RETURN (__MKINT(n));
-}
+	    }
-}
+	}
 }
 # endif /* FIONREAD */
 %}.
 ^ self canReadWithoutBlocking ifTrue:[1] ifFalse:[0]
 |sz old|
 sz := OpenFiles size.
 fd > sz ifTrue:[
-"grow for more descriptors"
+	"grow for more descriptors"
-old := OpenFiles.
+	old := OpenFiles.
-"JV@2013-03-15: It may happen that OS returns a filedescriptor whose value
+	"JV@2013-03-15: It may happen that OS returns a filedescriptor whose value
-is larger than twice the lenght of the weakarray. Care for this.
+	 is larger than twice the lenght of the weakarray. Care for this.
-Spotted by Martin Kobetic."
+	 Spotted by Martin Kobetic."
-OpenFiles := WeakArray new:((sz * 2) max:fd).
+	OpenFiles := WeakArray new:((sz * 2) max:fd).
-old removeDependent:(self class).
+	old removeDependent:(self class).
-OpenFiles addDependent:(self class).
+	OpenFiles addDependent:(self class).
-old keysAndValuesDo:[:index :elem|
+	old keysAndValuesDo:[:index :elem|
-"be careful to not overwrite new entries in OpenFiles"
+	    "be careful to not overwrite new entries in OpenFiles"
-elem notNil ifTrue:[
+	    elem notNil ifTrue:[
-OpenFiles at:index put:elem.
+		OpenFiles at:index put:elem.
-].
+	    ].
-].
+	].
 ].
 OpenFiles at:fd put:self.
 "Created: 30.9.1997 / 12:51:48 / stefan"
 "Modified: 30.9.1997 / 12:58:37 / stefan"
 |inputSema hasData wasBlocked|
 fd isNil ifTrue:[^ self error:#errorNotOpen].
 self canReadWithoutBlocking ifTrue:[
-^ false.
+	^ false.
 ].
 wasBlocked := OperatingSystem blockInterrupts.
 inputSema := Semaphore new name:'readWait'.
 [
-timeout notNil ifTrue:[
+	timeout notNil ifTrue:[
-Processor signal:inputSema afterMilliseconds:timeout
+	    Processor signal:inputSema afterMilliseconds:timeout
-].
+	].
-Processor signal:inputSema onInput:fd.
+	Processor signal:inputSema onInput:fd.
-Processor activeProcess state:#ioWait.
+	Processor activeProcess state:#ioWait.
-inputSema wait.
+	inputSema wait.
-hasData := self canReadWithoutBlocking.
+	hasData := self canReadWithoutBlocking.
 ] ifCurtailed:[
-Processor disableSemaphore:inputSema.
+	Processor disableSemaphore:inputSema.
-wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
+	wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
 ].
 timeout notNil ifTrue:[
-Processor disableSemaphore:inputSema.
+	Processor disableSemaphore:inputSema.
 ].
 wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
 ^ hasData not
 !
 |outputSema canWrite wasBlocked|
 fd isNil ifTrue:[^ self error:#errorNotOpen].
 self canWriteWithoutBlocking ifTrue:[
-^ false.
+	^ false.
 ].
 wasBlocked := OperatingSystem blockInterrupts.
 outputSema := Semaphore new name:'writeWait'.
 [
-timeout notNil ifTrue:[
+	timeout notNil ifTrue:[
-Processor signal:outputSema afterMilliseconds:timeout
+	    Processor signal:outputSema afterMilliseconds:timeout
-].
+	].
-Processor signal:outputSema onOutput:fd.
+	Processor signal:outputSema onOutput:fd.
-Processor activeProcess state:#ioWait.
+	Processor activeProcess state:#ioWait.
-outputSema wait.
+	outputSema wait.
-canWrite := self canWriteWithoutBlocking.
+	canWrite := self canWriteWithoutBlocking.
 ] ifCurtailed:[
-Processor disableSemaphore:outputSema.
+	Processor disableSemaphore:outputSema.
-wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
+	wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
 ].
 timeout notNil ifTrue:[
-Processor disableSemaphore:outputSema.
+	Processor disableSemaphore:outputSema.
 ].
 wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
 ^ canWrite not
 ! !
 %{
 FILE *f = (FILE *)(__externalAddressVal(self));
 if (f) {
-__externalAddressVal(self) = NULL;
+	__externalAddressVal(self) = NULL;
-fclose(f);
+	fclose(f);
 }
 %}
 ! !
 !UnixOperatingSystem::FileStatusInfo class methodsFor:'instance creation'!
 type:t mode:m uid:u gid:g size:s id:i accessed:aT modified:mT statusChanged:sT path:lP numLinks:nL
 ^ self basicNew
-type:t mode:m uid:u gid:g size:s id:i accessed:aT modified:mT statusChanged:sT path:lP numLinks:nL
+	type:t mode:m uid:u gid:g size:s id:i accessed:aT modified:mT statusChanged:sT path:lP numLinks:nL
 !
 type:t mode:m uid:u gid:g size:s id:i accessed:aT modified:mT statusChanged:sT sourcePath:sP targetPath:tP numLinks:nL
 ^ self basicNew
-type:t mode:m uid:u gid:g size:s id:i accessed:aT modified:mT statusChanged:sT sourcePath:sP targetPath:tP numLinks:nL
+	type:t mode:m uid:u gid:g size:s id:i accessed:aT modified:mT statusChanged:sT sourcePath:sP targetPath:tP numLinks:nL
 ! !
 !UnixOperatingSystem::FileStatusInfo methodsFor:'accessing'!
 accessTime
 "return accessed"
 accessed isInteger ifTrue:[
-"/ lazy time conversion
+	"/ lazy time conversion
-accessed := Timestamp fromOSTime:(accessed * 1000).
+	accessed := Timestamp fromOSTime:(accessed * 1000).
 ].
 ^ accessed
 !
 alternativeName
 modificationTime
 "return modified"
 modified isInteger ifTrue:[
-"/ lazy time conversion
+	"/ lazy time conversion
-modified := Timestamp fromOSTime:(modified * 1000).
+	modified := Timestamp fromOSTime:(modified * 1000).
 ].
 ^ modified
 !
 numLinks
 ^ sourcePath
 !
 statusChangeTime
 statusChanged isInteger ifTrue:[
-"/ lazy time conversion
+	"/ lazy time conversion
-statusChanged := Timestamp fromOSTime:(statusChanged * 1000).
+	statusChanged := Timestamp fromOSTime:(statusChanged * 1000).
 ].
 ^ statusChanged
 !
 targetPath
 ^ type == #socket
 !
 isSpecialFile
 ^ (type ~~ #directory
-and:[type ~~ #remoteDirectory
+	and:[type ~~ #remoteDirectory
-and:[type ~~ #regular
+	and:[type ~~ #regular
-and:[type ~~ #symbolicLink
+	and:[type ~~ #symbolicLink
 ]]])
 !
 isSymbolicLink
 ^ type == #symbolicLink
 !UnixOperatingSystem::MountInfo methodsFor:'printing'!
 printOn:aStream
 aStream
-nextPutAll:'MountInfo for ';
+	nextPutAll:'MountInfo for ';
-nextPutAll:mountPointPath.
+	nextPutAll:mountPointPath.
 ! !
 !UnixOperatingSystem::MountInfo methodsFor:'queries'!
 isRemote
 This is an auxillary class, that holds information about status changes of
 operating system processes (these are no smalltalk processes!!).
 [Instance variables:]
-pid     <Integer>       OS-Process identifier
+	pid     <Integer>       OS-Process identifier
-status  <Symbol>        either #exit #signal #stop #continue
+	status  <Symbol>        either #exit #signal #stop #continue
-code    <Integer>       either exitcode or signalnumber
+	code    <Integer>       either exitcode or signalnumber
-core    <Boolean>       true if core has been dumped
+	core    <Boolean>       true if core has been dumped
 [author:]
-Stefan Vogel
+	Stefan Vogel
 [see also:]
-OperatingSystem
+	OperatingSystem
 "
 ! !
 !UnixOperatingSystem::OSProcessStatus class methodsFor:'instance creation'!
 |protocolCode protocolSymbol|
 %{
 if (__isSmallInteger(aNameOrNumber) || aNameOrNumber == nil) {
-RETURN(aNameOrNumber);
+	RETURN(aNameOrNumber);
 }
 %}.
 ProtocolCache notNil ifTrue:[
-protocolCode := ProtocolCache at:(aNameOrNumber asSymbol) ifAbsent:[].
+	protocolCode := ProtocolCache at:(aNameOrNumber asSymbol) ifAbsent:[].
-protocolCode notNil ifTrue:[
+	protocolCode notNil ifTrue:[
-^ protocolCode.
+	    ^ protocolCode.
-].
+	].
 ].
 %{
 #ifndef NO_SOCKET
 struct protoent *protoent = 0;
 if (__isStringLike(aNameOrNumber)) {
-protoent = getprotobyname((char *) __stringVal(aNameOrNumber));
+	protoent = getprotobyname((char *) __stringVal(aNameOrNumber));
-if (protoent) {
+	if (protoent) {
-protocolCode = __mkSmallInteger(protoent->p_proto);
+	    protocolCode = __mkSmallInteger(protoent->p_proto);
-protocolSymbol = __MKSYMBOL(protoent->p_name, 0);
+	    protocolSymbol = __MKSYMBOL(protoent->p_name, 0);
-}
+	}
 }
 #endif /*NO_SOCKET*/
 %}.
 protocolSymbol notNil ifTrue:[
-ProtocolCache isNil ifTrue:[
+	ProtocolCache isNil ifTrue:[
-ProtocolCache := IdentityDictionary new.
+	    ProtocolCache := IdentityDictionary new.
-].
+	].
-"beware of polluting the protocol cache with aliases"
+	"beware of polluting the protocol cache with aliases"
-ProtocolCache at:protocolSymbol put:protocolCode.
+	ProtocolCache at:protocolSymbol put:protocolCode.
 ].
 ^ protocolCode
 "
 self protocolCodeOf:#tcp
 "convert a numeric protocol code to a symbol"
 |protocolSymbol|
 ProtocolCache notNil ifTrue:[
-protocolSymbol := ProtocolCache keyAtIdentityValue:anInteger ifAbsent:[].
+	protocolSymbol := ProtocolCache keyAtIdentityValue:anInteger ifAbsent:[].
-protocolSymbol notNil ifTrue:[
+	protocolSymbol notNil ifTrue:[
-^ protocolSymbol.
+	    ^ protocolSymbol.
-].
+	].
 ].
 %{
 #ifndef NO_SOCKET
 struct protoent *protoent = 0;
 if (__isSmallInteger(anInteger)) {
-protoent = getprotobynumber(__intVal(anInteger));
+	protoent = getprotobynumber(__intVal(anInteger));
-if (protoent) {
+	if (protoent) {
-protocolSymbol = __MKSYMBOL(protoent->p_name, 0);
+	    protocolSymbol = __MKSYMBOL(protoent->p_name, 0);
-}
+	}
 }
 #endif /*NO_SOCKET*/
 %}.
 protocolSymbol notNil ifTrue:[
-ProtocolCache isNil ifTrue:[
+	ProtocolCache isNil ifTrue:[
-ProtocolCache := IdentityDictionary new.
+	    ProtocolCache := IdentityDictionary new.
-].
+	].
-ProtocolCache at:protocolSymbol put:anInteger.
+	ProtocolCache at:protocolSymbol put:anInteger.
 ].
 ^ protocolSymbol
 "
 domain := OperatingSystem domainCodeOf:domainArg.
 type := OperatingSystem socketTypeCodeOf:typeArg.
 proto := self protocolCodeOf:protoArg.
 serviceNameArg notNil ifTrue:[
-serviceName := serviceNameArg printString.      "convert integer port numbers"
+	serviceName := serviceNameArg printString.      "convert integer port numbers"
 ].
 hostName isNil ifTrue:[
-encodedHostName := nil.
+	encodedHostName := nil.
 ] ifFalse:[
-encodedHostName := hostName utf8Encoded.
+	encodedHostName := hostName utf8Encoded.
 ].
 (encodedHostName ~~ hostName and:[OperatingSystem getCodeset ~~ #utf8]) ifTrue:[
-"hostName is not plain ASCII - so this is an IDN domain name. Have to ensure, that the locale is UTF-8.
+	"hostName is not plain ASCII - so this is an IDN domain name. Have to ensure, that the locale is UTF-8.
-Block interrupt to not affect other ST/X processes while the locale is changed."
+	 Block interrupt to not affect other ST/X processes while the locale is changed."
-|interruptsBlocked oldLocale|
+	|interruptsBlocked oldLocale|
-interruptsBlocked := OperatingSystem blockInterrupts.
+	interruptsBlocked := OperatingSystem blockInterrupts.
-oldLocale := OperatingSystem setLocale:#'LC_CTYPE' to:nil.
+	oldLocale := OperatingSystem setLocale:#'LC_CTYPE' to:nil.
-OperatingSystem setLocale:#'LC_CTYPE' to:'en_US.UTF-8'.
+	OperatingSystem setLocale:#'LC_CTYPE' to:'en_US.UTF-8'.
-result := self primGetAddressInfo:encodedHostName serviceName:serviceName domainCode:domain socketTypeCode:type protocolCode:proto flags:flags.
+	result := self primGetAddressInfo:encodedHostName serviceName:serviceName domainCode:domain socketTypeCode:type protocolCode:proto flags:flags.
-OperatingSystem setLocale:#'LC_CTYPE' to:oldLocale.
+	OperatingSystem setLocale:#'LC_CTYPE' to:oldLocale.
-interruptsBlocked ifFalse:[
+	interruptsBlocked ifFalse:[
-OperatingSystem unblockInterrupts.
+	    OperatingSystem unblockInterrupts.
-].
+	].
 ] ifFalse:[
-result := self primGetAddressInfo:encodedHostName serviceName:serviceName domainCode:domain socketTypeCode:type protocolCode:proto flags:flags.
+	result := self primGetAddressInfo:encodedHostName serviceName:serviceName domainCode:domain socketTypeCode:type protocolCode:proto flags:flags.
 ].
 result isArray ifFalse:[
-|request|
+	|request|
-request := SocketAddressInfo new
+	request := SocketAddressInfo new
-domain:domainArg;
+	    domain:domainArg;
-type:typeArg;
+	    type:typeArg;
-protocol:protoArg;
+	    protocol:protoArg;
-canonicalName:hostName;
+	    canonicalName:hostName;
-serviceName:serviceName.
+	    serviceName:serviceName.
-^ (HostNameLookupError new
+	^ (HostNameLookupError new
-parameter:result;
+		parameter:result;
-messageText:' - ', (result printString);
+		messageText:' - ', (result printString);
-request:request) raiseRequest.
+		request:request) raiseRequest.
 ].
 1 to:result size do:[:i |
-|entry dom info|
+	|entry dom info|
-entry := result at:i.
+	entry := result at:i.
-info := SocketAddressInfo new.
+	info := SocketAddressInfo new.
-info
+	info
-flags:(entry at:1);
+	    flags:(entry at:1);
-domain:(dom := OperatingSystem domainSymbolOf:(entry at:2));
+	    domain:(dom := OperatingSystem domainSymbolOf:(entry at:2));
-type:(OperatingSystem socketTypeSymbolOf:(entry at:3));
+	    type:(OperatingSystem socketTypeSymbolOf:(entry at:3));
-protocol:(self protocolSymbolOf:(entry at:4));
+	    protocol:(self protocolSymbolOf:(entry at:4));
-socketAddress:((SocketAddress newDomain:dom) fromBytes:(entry at:5));
+	    socketAddress:((SocketAddress newDomain:dom) fromBytes:(entry at:5));
-canonicalName:(entry at:6).
+	    canonicalName:(entry at:6).
-result at:i put:info.
+	result at:i put:info.
 ].
 ^ result
 "
 self getAddressInfo:'localhost' serviceName:nil
-domain:nil type:nil protocol:nil flags:nil
+	    domain:nil type:nil protocol:nil flags:nil
 self getAddressInfo:'localhost' serviceName:nil
-domain:#inet type:#stream protocol:nil flags:nil
+	    domain:#inet type:#stream protocol:nil flags:nil
 self getAddressInfo:'localhost' serviceName:nil
-domain:#inet type:#stream protocol:#tcp flags:nil
+	    domain:#inet type:#stream protocol:#tcp flags:nil
 self getAddressInfo:'blurb.exept.de' serviceName:nil
-domain:#inet type:nil protocol:nil flags:nil
+	    domain:#inet type:nil protocol:nil flags:nil
 self getAddressInfo:'1.2.3.4' serviceName:'bla'
-domain:#inet type:nil protocol:nil flags:nil
+	    domain:#inet type:nil protocol:nil flags:nil
 self getAddressInfo:'localhost' serviceName:'echo'
-domain:#inet type:nil protocol:nil flags:nil
+	    domain:#inet type:nil protocol:nil flags:nil
 self getAddressInfo:nil serviceName:'echo'
-domain:#inet type:nil protocol:nil flags:nil
+	    domain:#inet type:nil protocol:nil flags:nil
 self getAddressInfo:nil serviceName:nil
-domain:#inet type:nil protocol:nil flags:nil
+	    domain:#inet type:nil protocol:nil flags:nil
 self getAddressInfo:'www.google.de' serviceName:nil
-domain:nil type:nil protocol:nil flags:nil
+	    domain:nil type:nil protocol:nil flags:nil
 self getAddressInfo:'www.exept.de' serviceName:nil
-domain:nil type:nil protocol:nil flags:nil
+	    domain:nil type:nil protocol:nil flags:nil
 self getAddressInfo:'www.exept.de' serviceName:nil
-domain:#'AF_INET' type:nil protocol:nil flags:nil
+	    domain:#'AF_INET' type:nil protocol:nil flags:nil
 self getAddressInfo:'www.exept.de' serviceName:nil
-domain:#'AF_INET6' type:nil protocol:nil flags:nil
+	    domain:#'AF_INET6' type:nil protocol:nil flags:nil
 self getAddressInfo:'www.baden-württemberg.de' serviceName:nil
-domain:#'AF_INET' type:#stream protocol:nil flags:nil
+	    domain:#'AF_INET' type:#stream protocol:nil flags:nil
 "
 !
 getNameInfo:socketAddress wantHostName:wantHostName wantServiceName:wantServiceName datagram:useDatagram flags:flags
 "answer an Array containing the hostName and serviceName
 int ret, __flags;
 char *bp;
 int nInstBytes, sockAddrSize;
 if (wantHostName == true) {
-hp = host;
+	hp = host;
-hsz = sizeof(host);
+	hsz = sizeof(host);
 }
 if (wantServiceName == true) {
-sp = service;
+	sp = service;
-ssz = sizeof(service);
+	ssz = sizeof(service);
 }
 if (hp == 0 && sp == 0) {
-error = @symbol(badArgument);
+	error = @symbol(badArgument);
-goto err;
+	goto err;
 }
 if (!__isBytes(socketAddress)) {
-error = @symbol(badArgument1);
+	error = @symbol(badArgument1);
-goto err;
+	goto err;
 }
 nInstBytes = __OBJS2BYTES__(__intVal(__ClassInstPtr(__qClass(socketAddress))->c_ninstvars));
 sockAddrSize = __byteArraySize(socketAddress);
 sockAddrSize -= nInstBytes;
 if (!__isSmallInteger(flags)) {
-error = @symbol(badArgument5);
+	error = @symbol(badArgument5);
-goto err;
+	goto err;
 }
 __flags = __intVal(flags);
 #if defined(NI_NUMERICHOST)
 if (useDatagram == true) {
-__flags |= NI_DGRAM;
+	__flags |= NI_DGRAM;
 }
 {
-bp = (char *)(__byteArrayVal(socketAddress));
+	bp = (char *)(__byteArrayVal(socketAddress));
-bp += nInstBytes;
+	bp += nInstBytes;
-__BEGIN_INTERRUPTABLE__
+	__BEGIN_INTERRUPTABLE__
-ret = getnameinfo((struct sockaddr *)bp, sockAddrSize,
+	ret = getnameinfo((struct sockaddr *)bp, sockAddrSize,
-hp, hsz, sp, ssz, __flags);
+			  hp, hsz, sp, ssz, __flags);
-__END_INTERRUPTABLE__
+	__END_INTERRUPTABLE__
 } while (ret == EAI_SYSTEM && errno == EINTR);
 if (ret != 0) {
-switch (ret) {
+	switch (ret) {
-case EAI_FAMILY:
+	case EAI_FAMILY:
-error = @symbol(badProtocol);
+	    error = @symbol(badProtocol);
-break;
+	    break;
-case EAI_SOCKTYPE:
+	case EAI_SOCKTYPE:
-error = @symbol(badSocketType);
+	    error = @symbol(badSocketType);
-break;
+	    break;
-case EAI_BADFLAGS:
+	case EAI_BADFLAGS:
-error = @symbol(badFlags);
+	    error = @symbol(badFlags);
-break;
+	    break;
-case EAI_NONAME:
+	case EAI_NONAME:
-error = @symbol(unknownHost);
+	    error = @symbol(unknownHost);
-break;
+	    break;
-case EAI_SERVICE:
+	case EAI_SERVICE:
-error = @symbol(unknownService);
+	    error = @symbol(unknownService);
-break;
+	    break;
 #ifdef EAI_ADDRFAMILY
-case EAI_ADDRFAMILY :
+	case EAI_ADDRFAMILY :
-error = @symbol(unknownHostForProtocol);
+	    error = @symbol(unknownHostForProtocol);
-break;
+	    break;
 #endif
 #ifdef EAI_NODATA
-case EAI_NODATA:
+	case EAI_NODATA:
-error = @symbol(noAddress);
+	    error = @symbol(noAddress);
-break;
+	    break;
 #endif
-case EAI_MEMORY:
+	case EAI_MEMORY:
-error = @symbol(allocationFailure);
+	    error = @symbol(allocationFailure);
-break;
+	    break;
-case EAI_FAIL:
+	case EAI_FAIL:
-error = @symbol(permanentFailure);
+	    error = @symbol(permanentFailure);
-break;
+	    break;
-case EAI_AGAIN:
+	case EAI_AGAIN:
-error = @symbol(tryAgain);
+	    error = @symbol(tryAgain);
-break;
+	    break;
-case EAI_SYSTEM:
+	case EAI_SYSTEM:
-error = @symbol(systemError);
+	    error = @symbol(systemError);
-break;
+	    break;
-default:
+	default:
-error = @symbol(unknownError);
+	    error = @symbol(unknownError);
-}
+	}
-errorString = __MKSTRING(gai_strerror(ret));
+	errorString = __MKSTRING(gai_strerror(ret));
-goto err;
+	goto err;
 }
 # else /* ! NI_NUMERICHOST */
 {
-/*
+	/*
-* Do it using gethostbyaddr()
+	 * Do it using gethostbyaddr()
-*/
+	 */
-struct sockaddr_in *sa;
+	struct sockaddr_in *sa;
-if (sockAddrSize < sizeof(*sa)) {
+	if (sockAddrSize < sizeof(*sa)) {
-error = @symbol(badArgument1);
+	    error = @symbol(badArgument1);
-goto err;
+	    goto err;
-}
+	}
-bp = (char *)(__byteArrayVal(socketAddress));
+	bp = (char *)(__byteArrayVal(socketAddress));
-bp += nInstBytes;
+	bp += nInstBytes;
-sa = (struct sockaddr_in *)bp;
+	sa = (struct sockaddr_in *)bp;
-if (sp) {
+	if (sp) {
-struct servent *servp;
+	    struct servent *servp;
-char *__proto = 0;
+	    char *__proto = 0;
-__proto = (useDatagram == true ? "udp" : "tcp");
+	    __proto = (useDatagram == true ? "udp" : "tcp");
-servp = getservbyport(sa->sin_port, __proto);
+	    servp = getservbyport(sa->sin_port, __proto);
-if (servp) {
+	    if (servp) {
-sp = servp->s_name;
+		sp = servp->s_name;
-}
+	    }
-}
+	}
-if (hp) {
+	if (hp) {
-struct hostent *hostp;
+	    struct hostent *hostp;
 #  ifdef USE_H_ERRNO
-do {
+	    do {
-bp = (char *)(__byteArrayVal(socketAddress));
+		bp = (char *)(__byteArrayVal(socketAddress));
-bp += nInstBytes;
+		bp += nInstBytes;
-sa = (struct sockaddr_in *)bp;
+		sa = (struct sockaddr_in *)bp;
-/* __BEGIN_INTERRUPTABLE__ is dangerous, because gethostbyname uses a static data area
+		/* __BEGIN_INTERRUPTABLE__ is dangerous, because gethostbyname uses a static data area
-*/
+		 */
-hostp = gethostbyaddr((char *)&sa->sin_addr, sockAddrSize, sa->sin_family);
+		hostp = gethostbyaddr((char *)&sa->sin_addr, sockAddrSize, sa->sin_family);
-/* __END_INTERRUPTABLE__ */
+		/* __END_INTERRUPTABLE__ */
-} while ((hostp == NULL)
+	    } while ((hostp == NULL)
-&& ((h_errno == TRY_AGAIN)
+		      && ((h_errno == TRY_AGAIN)
-|| errno == EINTR
+			  || errno == EINTR
 #   ifdef IRIX5_3
-|| (errno == ECONNREFUSED)
+			  || (errno == ECONNREFUSED)
 #   endif
-)
+			 )
-);
+	    );
-if (hostp == 0) {
+	    if (hostp == 0) {
-switch (h_errno) {
+		switch (h_errno) {
-case HOST_NOT_FOUND:
+		case HOST_NOT_FOUND:
-errorString = @symbol(unknownHost);
+		    errorString = @symbol(unknownHost);
-break;
+		    break;
-case NO_ADDRESS:
+		case NO_ADDRESS:
-errorString = @symbol(noAddress);
+		    errorString = @symbol(noAddress);
-break;
+		    break;
-case NO_RECOVERY:
+		case NO_RECOVERY:
-errorString = @symbol(permanentFailure);
+		    errorString = @symbol(permanentFailure);
-break;
+		    break;
-case TRY_AGAIN:
+		case TRY_AGAIN:
-errorString = @symbol(tryAgain);
+		    errorString = @symbol(tryAgain);
-break;
+		    break;
-default:
+		default:
-errorString = @symbol(unknownError);
+		    errorString = @symbol(unknownError);
-break;
+		    break;
-}
+		}
-error = __mkSmallInteger(h_errno);
+		error = __mkSmallInteger(h_errno);
-goto err;
+		goto err;
-}
+	    }
 #  else /* !USE_H_ERRNO */
-hostp = gethostbyaddr(sa->sin_addr, sockAddrSize, sa->sin_family);
+	    hostp = gethostbyaddr(sa->sin_addr, sockAddrSize, sa->sin_family);
-if (hostp == 0) {
+	    if (hostp == 0) {
-errorString = @symbol(unknownHost);
+		errorString = @symbol(unknownHost);
-error = __mkSmallInteger(-1);
+		error = __mkSmallInteger(-1);
-goto err;
+		goto err;
-}
+	    }
 #  endif /* !USE_H_ERRNO*/
-hp = hostp->h_name;
+	    hp = hostp->h_name;
-}
+	}
 }
 # endif /* ! NI_NUMERICHOST */
 if (hp)
-hostName = __MKSTRING(hp);
+	hostName = __MKSTRING(hp);
 if (sp)
-serviceName = __MKSTRING(sp);
+	serviceName = __MKSTRING(sp);
 err:;
 #else
 error = @symbol(notImplemented);
 #endif
 %}.
 error notNil ifTrue:[
-^ (HostAddressLookupError new
+	^ (HostAddressLookupError new
-parameter:error;
+		parameter:error;
-messageText:' - ', errorString;
+		messageText:' - ', errorString;
-request:thisContext message) raiseRequest.
+		request:thisContext message) raiseRequest.
 ].
 ^ Array with:hostName with:serviceName
 "
 self getNameInfo:
-(self getAddressInfo:'localhost' serviceName:'echo'
+	(self getAddressInfo:'localhost' serviceName:'echo'
-domain:#inet type:#stream protocol:nil flags:nil) first socketAddress
+		domain:#inet type:#stream protocol:nil flags:nil) first socketAddress
-wantHostName:true wantServiceName:true datagram:false flags:0
+	 wantHostName:true wantServiceName:true datagram:false flags:0
 self getNameInfo:
-(self getAddressInfo:'exept.de' serviceName:'echo'
+	(self getAddressInfo:'exept.de' serviceName:'echo'
-domain:#inet type:#stream protocol:nil flags:nil) first socketAddress
+		domain:#inet type:#stream protocol:nil flags:nil) first socketAddress
-wantHostName:true wantServiceName:true datagram:false flags:0
+	 wantHostName:true wantServiceName:true datagram:false flags:0
 self getNameInfo:
-(self getAddressInfo:'217.172.183.25' serviceName:'22'
+	(self getAddressInfo:'217.172.183.25' serviceName:'22'
-domain:#inet type:#stream protocol:nil flags:nil) first socketAddress
+		domain:#inet type:#stream protocol:nil flags:nil) first socketAddress
-wantHostName:true wantServiceName:true datagram:false flags:0
+	 wantHostName:true wantServiceName:true datagram:false flags:0
 self getNameInfo:
-(self getAddressInfo:'1.2.3.4' serviceName:'22'
+	(self getAddressInfo:'1.2.3.4' serviceName:'22'
-domain:#inet type:#stream protocol:nil flags:nil) first socketAddress
+		domain:#inet type:#stream protocol:nil flags:nil) first socketAddress
-wantHostName:true wantServiceName:true datagram:false flags:0
+	 wantHostName:true wantServiceName:true datagram:false flags:0
 "
 !
 primGetAddressInfo:hostName serviceName:serviceName domainCode:domain socketTypeCode:type protocolCode:proto flags:flags
 "answer an Array of socket addresses for serviceName on hostName
 #if !defined(NO_SOCKET)
 char *__hostName, *__serviceName;
 int ret, cnt = 0;
 if (hostName == nil) {
-__hostName = 0;
+	__hostName = 0;
 } else if (__isStringLike(hostName)) {
-__hostName = __stringVal(hostName);
+	__hostName = __stringVal(hostName);
 } else {
-error = @symbol(badArgument1);
+	error = @symbol(badArgument1);
-goto out;
+	goto out;
 }
 if (serviceName == nil) {
-__serviceName = 0;
+	__serviceName = 0;
 } else if (__isStringLike(serviceName)) {
-__serviceName = __stringVal(serviceName);
+	__serviceName = __stringVal(serviceName);
 } else {
-error = @symbol(badArgument2);
+	error = @symbol(badArgument2);
-goto out;
+	goto out;
 }
 if (__hostName == 0 && __serviceName == 0) {
-error = @symbol(badArgument);
+	error = @symbol(badArgument);
-goto out;
+	goto out;
 }
 {
 # if defined(AI_NUMERICHOST)
 /*
 #if defined(AI_IDN)
 hints.ai_flags = AI_IDN | AI_CANONIDN;      // map non-ascii domain names to IDN format
 #endif
 if (__isSmallInteger(domain))
-hints.ai_family = __intVal(domain);
+	hints.ai_family = __intVal(domain);
 if (__isSmallInteger(type))
-hints.ai_socktype = __intVal(type);
+	hints.ai_socktype = __intVal(type);
 if (__isSmallInteger(proto))
-hints.ai_protocol = __intVal(proto);
+	hints.ai_protocol = __intVal(proto);
 if (__isSmallInteger(flags))
-hints.ai_flags |= __intVal(flags);
+	hints.ai_flags |= __intVal(flags);
 do {
-/* reload */
+	/* reload */
-if (__hostName) {
+	if (__hostName) {
-__hostName = __stringVal(hostName);
+	    __hostName = __stringVal(hostName);
-}
+	}
-if (__serviceName) {
+	if (__serviceName) {
-__serviceName = __stringVal(serviceName);
+	    __serviceName = __stringVal(serviceName);
-}
+	}
 //        __BEGIN_INTERRUPTABLE__
-ret = getaddrinfo(__hostName, __serviceName, &hints, &info);
+	ret = getaddrinfo(__hostName, __serviceName, &hints, &info);
 //        __END_INTERRUPTABLE__
 } while (ret == EAI_SYSTEM && errno == EINTR);
 if (ret != 0) {
-switch (ret) {
+	switch (ret) {
-case EAI_FAMILY:
+	case EAI_FAMILY:
-error = @symbol(badProtocol);
+	    error = @symbol(badProtocol);
-break;
+	    break;
-case EAI_SOCKTYPE:
+	case EAI_SOCKTYPE:
-error = @symbol(badSocketType);
+	    error = @symbol(badSocketType);
-break;
+	    break;
-case EAI_BADFLAGS:
+	case EAI_BADFLAGS:
-error = @symbol(badFlags);
+	    error = @symbol(badFlags);
-break;
+	    break;
-case EAI_NONAME:
+	case EAI_NONAME:
-error = @symbol(unknownHost);
+	    error = @symbol(unknownHost);
-break;
+	    break;
-case EAI_SERVICE:
+	case EAI_SERVICE:
-error = @symbol(unknownService);
+	    error = @symbol(unknownService);
-break;
+	    break;
 #ifdef EAI_ADDRFAMILY
-case EAI_ADDRFAMILY :
+	case EAI_ADDRFAMILY :
-error = @symbol(unknownHostForProtocol);
+	    error = @symbol(unknownHostForProtocol);
-break;
+	    break;
 #endif
 #ifdef EAI_NODATA
-case EAI_NODATA:
+	case EAI_NODATA:
-error = @symbol(noAddress);
+	    error = @symbol(noAddress);
-break;
+	    break;
 #endif
-case EAI_MEMORY:
+	case EAI_MEMORY:
-error = @symbol(allocationFailure);
+	    error = @symbol(allocationFailure);
-break;
+	    break;
-case EAI_FAIL:
+	case EAI_FAIL:
-error = @symbol(permanentFailure);
+	    error = @symbol(permanentFailure);
-break;
+	    break;
-case EAI_AGAIN:
+	case EAI_AGAIN:
-error = @symbol(tryAgain);
+	    error = @symbol(tryAgain);
-break;
+	    break;
-case EAI_SYSTEM:
+	case EAI_SYSTEM:
-error = @symbol(systemError);
+	    error = @symbol(systemError);
-break;
+	    break;
-default:
+	default:
-error = @symbol(unknownError);
+	    error = @symbol(unknownError);
-}
+	}
-errorString = __MKSTRING(gai_strerror(ret));
+	errorString = __MKSTRING(gai_strerror(ret));
-goto err;
+	goto err;
 }
 for (cnt=0, infop=info; infop; infop=infop->ai_next)
-cnt++;
+	cnt++;
 result = __ARRAY_NEW_INT(cnt);
 if (result == nil) {
-error = @symbol(allocationFailure);
+	error = @symbol(allocationFailure);
-goto err;
+	goto err;
 }
 for (infop=info, cnt=0; infop; infop=infop->ai_next, cnt++) {
-OBJ o, resp;
+	OBJ o, resp;
-resp = __ARRAY_NEW_INT(6);
+	resp = __ARRAY_NEW_INT(6);
-if (resp == nil) {
+	if (resp == nil) {
-error = @symbol(allocationFailure);
+	    error = @symbol(allocationFailure);
-goto err;
+	    goto err;
-}
+	}
-__ArrayInstPtr(result)->a_element[cnt] = resp; __STORE(result, resp);
+	__ArrayInstPtr(result)->a_element[cnt] = resp; __STORE(result, resp);
-__ArrayInstPtr(resp)->a_element[0] = __mkSmallInteger(infop->ai_flags);
+	__ArrayInstPtr(resp)->a_element[0] = __mkSmallInteger(infop->ai_flags);
-__ArrayInstPtr(resp)->a_element[1] = __mkSmallInteger(infop->ai_family);
+	__ArrayInstPtr(resp)->a_element[1] = __mkSmallInteger(infop->ai_family);
-__ArrayInstPtr(resp)->a_element[2] = __mkSmallInteger(infop->ai_socktype);
+	__ArrayInstPtr(resp)->a_element[2] = __mkSmallInteger(infop->ai_socktype);
-__ArrayInstPtr(resp)->a_element[3] = __mkSmallInteger(infop->ai_protocol);
+	__ArrayInstPtr(resp)->a_element[3] = __mkSmallInteger(infop->ai_protocol);
-__PROTECT__(resp);
+	__PROTECT__(resp);
-o = __BYTEARRAY_NEW_INT(infop->ai_addrlen);
+	o = __BYTEARRAY_NEW_INT(infop->ai_addrlen);
-__UNPROTECT__(resp);
+	__UNPROTECT__(resp);
-if (o == nil) {
+	if (o == nil) {
-error = @symbol(allocationFailure);
+	    error = @symbol(allocationFailure);
-goto err;
+	    goto err;
-}
+	}
-memcpy(__byteArrayVal(o), infop->ai_addr, infop->ai_addrlen);
+	memcpy(__byteArrayVal(o), infop->ai_addr, infop->ai_addrlen);
 __ArrayInstPtr(resp)->a_element[4] = o; __STORE(resp, o);
-if (infop->ai_canonname) {
+	if (infop->ai_canonname) {
-__PROTECT__(resp);
+	    __PROTECT__(resp);
-o = __MKSTRING(infop->ai_canonname);
+	    o = __MKSTRING(infop->ai_canonname);
-__UNPROTECT__(resp);
+	    __UNPROTECT__(resp);
-if (o == nil) {
+	    if (o == nil) {
-error = @symbol(allocationFailure);
+		error = @symbol(allocationFailure);
-goto err;
+		goto err;
-}
+	    }
-__ArrayInstPtr(resp)->a_element[5] = o; __STORE(resp, o);
+	    __ArrayInstPtr(resp)->a_element[5] = o; __STORE(resp, o);
-}
+	}
 }
 err:
 if (info) freeaddrinfo(info);
 char **addrpp;
 int port = 0;
 int i;
 if (__serviceName) {
-struct servent *sp;
+	struct servent *sp;
-char *__proto = 0;
+	char *__proto = 0;
-if (__isStringLike(protoArg))
+	if (__isStringLike(protoArg))
-__proto = __stringVal(protoArg);
+	    __proto = __stringVal(protoArg);
-sp = getservbyname(__serviceName, __proto);
+	sp = getservbyname(__serviceName, __proto);
-if (sp == NULL) {
+	if (sp == NULL) {
-errorString = @symbol(unknownService);
+	    errorString = @symbol(unknownService);
-error = __mkSmallInteger(-3);
+	    error = __mkSmallInteger(-3);
-goto err;
+	    goto err;
-}
+	}
-port = sp->s_port;
+	port = sp->s_port;
 }
 if (__hostName) {
 #  ifdef USE_H_ERRNO
-do {
+	do {
-if (hostName == nil) {
+	    if (hostName == nil) {
-__hostName = 0;
+		__hostName = 0;
-} else if (__isStringLike(hostName)) {
+	    } else if (__isStringLike(hostName)) {
-__hostName = __stringVal(hostName);
+		__hostName = __stringVal(hostName);
-}
+	    }
-/* __BEGIN_INTERRUPTABLE__ is dangerous, because gethostbyname
+	    /* __BEGIN_INTERRUPTABLE__ is dangerous, because gethostbyname
-* uses a static data area
+	     * uses a static data area
-*/
+	     */
-__BEGIN_INTERRUPTABLE__
+	    __BEGIN_INTERRUPTABLE__
-hp = gethostbyname(__hostName);
+	    hp = gethostbyname(__hostName);
-__END_INTERRUPTABLE__
+	    __END_INTERRUPTABLE__
-} while ((hp == NULL)
+	} while ((hp == NULL)
-&& (
+		  && (
-(h_errno == TRY_AGAIN)
+			(h_errno == TRY_AGAIN)
-|| errno == EINTR
+		      || errno == EINTR
 #   ifdef IRIX5_3
-|| (errno == ECONNREFUSED)
+		      || (errno == ECONNREFUSED)
 #   endif
-)
+		     )
-);
+	);
-if (hp == 0) {
+	if (hp == 0) {
-switch (h_errno) {
+	    switch (h_errno) {
-case HOST_NOT_FOUND:
+	    case HOST_NOT_FOUND:
-errorString = @symbol(unknownHost);
+		errorString = @symbol(unknownHost);
-break;
+		break;
-case NO_ADDRESS:
+	    case NO_ADDRESS:
-errorString = @symbol(noAddress);
+		errorString = @symbol(noAddress);
-break;
+		break;
-case NO_RECOVERY:
+	    case NO_RECOVERY:
-errorString = @symbol(permanentFailure);
+		errorString = @symbol(permanentFailure);
-break;
+		break;
-case TRY_AGAIN:
+	    case TRY_AGAIN:
-errorString = @symbol(tryAgain);
+		errorString = @symbol(tryAgain);
-break;
+		break;
-default:
+	    default:
-errorString = @symbol(unknownError);
+		errorString = @symbol(unknownError);
-break;
+		break;
-}
+	    }
-error = __mkSmallInteger(h_errno);
+	    error = __mkSmallInteger(h_errno);
-goto err;
+	    goto err;
-}
+	}
 #  else /* !USE_H_ERRNO */
-hp = gethostbyname(__hostName);
+	hp = gethostbyname(__hostName);
-if (hp == 0) {
+	if (hp == 0) {
-errorString = @symbol(unknownHost);
+	    errorString = @symbol(unknownHost);
-error = __mkSmallInteger(-1);
+	    error = __mkSmallInteger(-1);
-goto err;
+	    goto err;
-}
+	}
 #  endif /* !USE_H_ERRNO*/
-if (__isSmallInteger(domain) && hp->h_addrtype != __smallIntegerVal(domain)) {
+	if (__isSmallInteger(domain) && hp->h_addrtype != __smallIntegerVal(domain)) {
-errorString = @symbol(unknownHost);
+	    errorString = @symbol(unknownHost);
-error = __mkSmallInteger(-2);
+	    error = __mkSmallInteger(-2);
-goto err;
+	    goto err;
-}
+	}
-for (cnt = 0, addrpp = hp->h_addr_list; *addrpp; addrpp++)
+	for (cnt = 0, addrpp = hp->h_addr_list; *addrpp; addrpp++)
-cnt++;
+	    cnt++;
-addrpp = hp->h_addr_list;
+	addrpp = hp->h_addr_list;
 } else {
-cnt = 1;
+	cnt = 1;
 }
 result = __ARRAY_NEW_INT(cnt);
 if (result == nil) {
-error = @symbol(allocationFailure);
+	error = @symbol(allocationFailure);
-goto err;
+	goto err;
 }
 for (i = 0; i < cnt; i++) {
-OBJ o, resp;
+	OBJ o, resp;
-struct sockaddr_in *sa;
+	struct sockaddr_in *sa;
-resp = __ARRAY_NEW_INT(6);
+	resp = __ARRAY_NEW_INT(6);
-if (resp == nil) {
+	if (resp == nil) {
-error = @symbol(allocationFailure);
+	    error = @symbol(allocationFailure);
-goto err;
+	    goto err;
-}
+	}
-__ArrayInstPtr(result)->a_element[i] = resp; __STORE(result, resp);
+	__ArrayInstPtr(result)->a_element[i] = resp; __STORE(result, resp);
-__ArrayInstPtr(resp)->a_element[0] = __mkSmallInteger(0);
+	__ArrayInstPtr(resp)->a_element[0] = __mkSmallInteger(0);
-__ArrayInstPtr(resp)->a_element[2] = type; __STORE(result, type);
+	__ArrayInstPtr(resp)->a_element[2] = type; __STORE(result, type);
-__ArrayInstPtr(resp)->a_element[3] = proto; __STORE(result, proto);
+	__ArrayInstPtr(resp)->a_element[3] = proto; __STORE(result, proto);
-__PROTECT__(resp);
+	__PROTECT__(resp);
-o = __BYTEARRAY_NEW_INT(sizeof(*sa));
+	o = __BYTEARRAY_NEW_INT(sizeof(*sa));
-__UNPROTECT__(resp);
+	__UNPROTECT__(resp);
-if (o == nil) {
+	if (o == nil) {
-error = @symbol(allocationFailure);
+	    error = @symbol(allocationFailure);
-goto err;
+	    goto err;
-}
+	}
-__ArrayInstPtr(resp)->a_element[4] = o; __STORE(resp, o);
+	__ArrayInstPtr(resp)->a_element[4] = o; __STORE(resp, o);
-sa = (struct sockaddr_in *)__byteArrayVal(o);
+	sa = (struct sockaddr_in *)__byteArrayVal(o);
-sa->sin_port = port;
+	sa->sin_port = port;
-if (__hostName) {
+	if (__hostName) {
-sa->sin_family = hp->h_addrtype;
+	    sa->sin_family = hp->h_addrtype;
-memcpy(&sa->sin_addr, *addrpp, hp->h_length);
+	    memcpy(&sa->sin_addr, *addrpp, hp->h_length);
-__ArrayInstPtr(resp)->a_element[1] = __mkSmallInteger(hp->h_addrtype);
+	    __ArrayInstPtr(resp)->a_element[1] = __mkSmallInteger(hp->h_addrtype);
-if (hp->h_name) {
+	    if (hp->h_name) {
-__PROTECT__(resp);
+		__PROTECT__(resp);
-o = __MKSTRING(hp->h_name);
+		o = __MKSTRING(hp->h_name);
-__UNPROTECT__(resp);
+		__UNPROTECT__(resp);
-if (o == nil) {
+		if (o == nil) {
-error = @symbol(allocationFailure);
+		    error = @symbol(allocationFailure);
-goto err;
+		    goto err;
-}
+		}
-__ArrayInstPtr(resp)->a_element[5] = o; __STORE(resp, o);
+		__ArrayInstPtr(resp)->a_element[5] = o; __STORE(resp, o);
-}
+	    }
-addrpp++;
+	    addrpp++;
-} else{
+	} else{
-__ArrayInstPtr(resp)->a_element[1] = domain; __STORE(resp, domain);
+	    __ArrayInstPtr(resp)->a_element[1] = domain; __STORE(resp, domain);
-}
+	}
 }
 err:;
 # endif /* ! AI_NUMERICHOST */
 }
 error = @symbol(notImplemented);
 #endif
 out:;
 %}.
 error notNil ifTrue:[
-errorString notNil ifTrue:[
+	errorString notNil ifTrue:[
-^ errorString.
+	    ^ errorString.
-].
+	].
-^ error.
+	^ error.
 ].
 ^ result.
 ! !
 !UnixOperatingSystem::SocketHandle methodsFor:'accepting'!
 int sock, newSock;
 struct sockaddr *sap;
 int alen;
 if (!__isSmallInteger(__INST(fd))) {
-error = @symbol(badFd);
+	error = @symbol(badFd);
-goto err;
+	goto err;
 }
 if (peerOrNil != nil &&
-(!__isNonNilObject(peerOrNil) ||
+	(!__isNonNilObject(peerOrNil) ||
-(__intVal(__ClassInstPtr(__qClass(peerOrNil))->c_flags) & ARRAYMASK) != BYTEARRAY)) {
+	 (__intVal(__ClassInstPtr(__qClass(peerOrNil))->c_flags) & ARRAYMASK) != BYTEARRAY)) {
-error = @symbol(badArgument2);
+	error = @symbol(badArgument2);
-goto err;
+	goto err;
 }
 sock = __smallIntegerVal(__INST(fd));
 again:
 if (peerOrNil == nil) {
-alen = 0;
+	alen = 0;
-sap = 0;
+	sap = 0;
 } else {
-alen =  __byteArraySize(peerOrNil);
+	alen =  __byteArraySize(peerOrNil);
-sap = (struct sockaddr *)__byteArrayVal(peerOrNil);
+	sap = (struct sockaddr *)__byteArrayVal(peerOrNil);
 }
 newSock = accept(sock, sap, &alen);
 if (newSock < 0) {
-switch (errno) {
+	switch (errno) {
-case EINTR:
+	case EINTR:
-__HANDLE_INTERRUPTS__;
+	    __HANDLE_INTERRUPTS__;
-goto again;
+	    goto again;
 #ifdef EWOULDBLOCK
-case EWOULDBLOCK:
+	case EWOULDBLOCK:
 # if defined(EAGAIN) && (EAGAIN != EWOULDBLOCK)
-case EAGAIN:
+	case EAGAIN:
 # endif
 #else
 # ifdef EAGAIN
-case EAGAIN:
+	case EAGAIN:
 # endif
 #endif
-RETURN(nil);
+	    RETURN(nil);
-default:
+	default:
-error = __mkSmallInteger(errno);
+	    error = __mkSmallInteger(errno);
-goto err;
+	    goto err;
-}
+	}
 }
 newFd = __mkSmallInteger(newSock);
 err:;
 #endif /* not NO_SOCKET */
 %}.
 error notNil ifTrue:[
-^ self error:error.
+	^ self error:error.
 ].
 ^ self class for:newFd
 ! !
 !UnixOperatingSystem::SocketHandle methodsFor:'binding'!
 int sock;
 int sockaddr_size;
 int ret;
 if (!__isSmallInteger(__INST(fd))) {
-error = @symbol(badFd);
+	error = @symbol(badFd);
-goto err;
+	goto err;
 }
 if (!__isNonNilObject(socketAddress) ||
-(__intVal(__ClassInstPtr(__qClass(socketAddress))->c_flags) & ARRAYMASK) != BYTEARRAY) {
+	(__intVal(__ClassInstPtr(__qClass(socketAddress))->c_flags) & ARRAYMASK) != BYTEARRAY) {
-error = @symbol(badArgument1);
+	error = @symbol(badArgument1);
-goto err;
+	goto err;
 }
 sockaddr_size = __byteArraySize(socketAddress);
 sock = __smallIntegerVal(__INST(fd));
 again:
 ret = bind(sock, (struct sockaddr *)__byteArrayVal(socketAddress), sockaddr_size);
 if (ret < 0) {
-if (errno == EINTR) {
+	if (errno == EINTR) {
-__HANDLE_INTERRUPTS__;
+	    __HANDLE_INTERRUPTS__;
-goto again;
+	    goto again;
-} else {
+	} else {
-error = __mkSmallInteger(errno);
+	    error = __mkSmallInteger(errno);
-goto err;
+	    goto err;
-}
+	}
 }
 err:;
 #endif /* NO_SOCKET */
 %}.
 error notNil ifTrue:[
-^ self error:error.
+	^ self error:error.
 ].
 ^ nil
 "
 (Socket domain:#inet type:#stream)
-bindTo:(IPSocketAddress hostAddress:IPSocketAddress anyAddress port:9999)
+	 bindTo:(IPSocketAddress hostAddress:IPSocketAddress anyAddress port:9999)
-reuseAddress:false ;
+	 reuseAddress:false ;
 yourself
 "
 ! !
 !UnixOperatingSystem::SocketHandle methodsFor:'connecting'!
 int sock;
 int ret;
 struct sockaddr sockaddr;
 if (!__isSmallInteger(__INST(fd))) {
-error = @symbol(badFd);
+	error = @symbol(badFd);
-goto err;
+	goto err;
 }
 sock = __smallIntegerVal(__INST(fd));
 /*
 * (dis-) connect by connecting to AF_UNSPEC socket
 again:
 sockaddr.sa_family = AF_UNSPEC;
 ret = connect(sock, &sockaddr, sizeof(sockaddr));
 if (ret < 0) {
 switch(errno) {
-case EINTR:
+	   case EINTR:
 # ifdef EAGAIN
-case EAGAIN:
+	    case EAGAIN:
 # endif
-__HANDLE_INTERRUPTS__;
+		__HANDLE_INTERRUPTS__;
-goto again;
+		goto again;
-default:
+	    default:
-error = __mkSmallInteger(errno);
+		error = __mkSmallInteger(errno);
-break;
+		break;
-}
+	}
 }
 err:;
 #endif /* NO_SOCKET */
 %}.
 error notNil ifTrue:[
-^ self error:error.
+	^ self error:error.
 ].
 !
 connectTo:socketAddress
 "low level connect; connect to a socket address.
 int sock;
 int ret;
 int sockaddr_size;
 if (!__isSmallInteger(__INST(fd))) {
-error = @symbol(badFd);
+	error = @symbol(badFd);
-goto err;
+	goto err;
 }
 if (!__isNonNilObject(socketAddress) ||
-(__intVal(__ClassInstPtr(__qClass(socketAddress))->c_flags) & ARRAYMASK) != BYTEARRAY) {
+	(__intVal(__ClassInstPtr(__qClass(socketAddress))->c_flags) & ARRAYMASK) != BYTEARRAY) {
-error = @symbol(badArgument1);
+	error = @symbol(badArgument1);
-goto err;
+	goto err;
 }
 sock = __smallIntegerVal(__INST(fd));
 sockaddr_size = __qSize(socketAddress);
 again:
 ret = connect(sock, (struct sockaddr *)__byteArrayVal(socketAddress), sockaddr_size);
 if (ret >= 0) {
-RETURN(true)
+	RETURN(true)
 }
 switch(errno) {
-case EINTR:
+	case EINTR:
 # ifdef EAGAIN
-case EAGAIN:
+	case EAGAIN:
 # endif
-__HANDLE_INTERRUPTS__;
+	    __HANDLE_INTERRUPTS__;
-goto again;
+	    goto again;
 # if defined(EINPROGRESS) || defined(EALREADY)
 #  ifdef EINPROGRESS
-case EINPROGRESS:
+	case EINPROGRESS:
 #  endif
 #  ifdef EALREADY
-case EALREADY:
+	case EALREADY:
 #  endif
-RETURN(false);
+	    RETURN(false);
 # endif
 default:
-error = __mkSmallInteger(errno);
+	error = __mkSmallInteger(errno);
-break;
+	break;
 }
 err:;
 #endif /* NO_SOCKET */
 %}.
 error notNil ifTrue:[
-^ self error:error.
+	 ^ self error:error.
 ].
 ^ true
 "
 Socket newTCP connectTo:(IPSocketAddress hostAddress:IPSocketAddress local port:7)
-withTimeout:nil.
+		   withTimeout:nil.
 Socket newTCP connectTo:(IPSocketAddress hostAddress:IPSocketAddress local port:5768)
-withTimeout:nil.
+		   withTimeout:nil.
 Socket newTCP connectTo:(IPSocketAddress hostAddress:#[1 2 3 4] port:7)
-withTimeout:nil.
+		   withTimeout:nil.
 "
 ! !
 !UnixOperatingSystem::SocketHandle methodsFor:'datagram transmission'!
 int n;
 char *cp;
 int __flags, __startIndex, __nBytes;
 if (!__isSmallInteger(__INST(fd))) {
-error = @symbol(badFd);
+	error = @symbol(badFd);
-goto err;
+	goto err;
 }
 if (!__isSmallInteger(startIndex) ||
-(__startIndex = __intVal(startIndex)-1) < 0) {
+	(__startIndex = __intVal(startIndex)-1) < 0) {
-if (startIndex == nil) {
+	if (startIndex == nil) {
-__startIndex = 0;
+	    __startIndex = 0;
-} else {
+	} else {
-error = @symbol(badArgument3);
+	    error = @symbol(badArgument3);
-goto err;
+	    goto err;
-}
+	}
 }
 if (__isSmallInteger(nBytes)) {
-__nBytes = __intVal(nBytes);
+	__nBytes = __intVal(nBytes);
 } else if (nBytes == nil) {
-__nBytes = -1;
+	__nBytes = -1;
 } else {
-error = @symbol(badArgument4);
+	error = @symbol(badArgument4);
-goto err;
+	goto err;
 }
 if (!__isInteger(flags)) {
-error = @symbol(badArgument5);
+	error = @symbol(badArgument5);
-goto err;
+	goto err;
 }
 __flags = __longIntVal(flags);
 sock = __smallIntegerVal(__INST(fd));
 oClass = __Class(aDataBuffer);
 switch (__intVal(__ClassInstPtr(oClass)->c_flags) & ARRAYMASK) {
-case BYTEARRAY:
+	case BYTEARRAY:
-case WORDARRAY:
+	case WORDARRAY:
-case SWORDARRAY:
+	case SWORDARRAY:
-case LONGARRAY:
+	case LONGARRAY:
-case SLONGARRAY:
+	case SLONGARRAY:
-case FLOATARRAY:
+	case FLOATARRAY:
-case DOUBLEARRAY:
+	case DOUBLEARRAY:
-break;
+	    break;
-default:
+	default:
-error = @symbol(badArgument2);
+	    error = @symbol(badArgument2);
-goto err;
+	    goto err;
 }
 nInstVars = __intVal(__ClassInstPtr(oClass)->c_ninstvars);
 nInstBytes = OHDR_SIZE + nInstVars * sizeof(OBJ);
 objSize = __qSize(aDataBuffer) - nInstBytes;
 nInstBytes += __startIndex;
 objSize -= __startIndex;
 if (__nBytes >= 0 &&__nBytes < objSize) {
-objSize = __nBytes;
+	objSize = __nBytes;
 }
 if (socketAddress == nil) {
-alen0 = 0;
+	alen0 = 0;
 } else {
-if (!__isNonNilObject(socketAddress) ||
+	if (!__isNonNilObject(socketAddress) ||
-(__intVal(__ClassInstPtr(__qClass(socketAddress))->c_flags) & ARRAYMASK) != BYTEARRAY) {
+	    (__intVal(__ClassInstPtr(__qClass(socketAddress))->c_flags) & ARRAYMASK) != BYTEARRAY) {
-error = @symbol(badArgument1);
+	    error = @symbol(badArgument1);
-goto err;
+	    goto err;
-}
+	}
-alen0 = __byteArraySize(socketAddress);
+	alen0 = __byteArraySize(socketAddress);
 }
 saPtr = (struct sockaddr *)0;
 again:
 alen = alen0;
 if (alen)
-saPtr = (struct sockaddr *)__byteArrayVal(socketAddress);
+	saPtr = (struct sockaddr *)__byteArrayVal(socketAddress);
 cp = (char *)__InstPtr(aDataBuffer) + nInstBytes;
 n = recvfrom(sock, cp, objSize, __flags, saPtr, &alen);
 if (n < 0) {
-if (errno == EINTR) {
+	if (errno == EINTR) {
-__HANDLE_INTERRUPTS__;
+	    __HANDLE_INTERRUPTS__;
-goto again;
+	    goto again;
-} else {
+	} else {
-error = __mkSmallInteger(errno);
+	    error = __mkSmallInteger(errno);
-goto err;
+	    goto err;
-}
+	}
 }
 RETURN (__mkSmallInteger(n));
 #endif
 err: ;
 %}.
 char *cp;
 int __flags;
 int offs, __startIndex, __maxBytes;
 if (!__isSmallInteger(__INST(fd))) {
-error = @symbol(badFd);
+	error = @symbol(badFd);
-goto err;
+	goto err;
 }
 if (!__isSmallInteger(startIndex) ||
-(__startIndex = __intVal(startIndex)-1) < 0) {
+	(__startIndex = __intVal(startIndex)-1) < 0) {
-if (startIndex == nil) {
+	if (startIndex == nil) {
-__startIndex = 0;
+	    __startIndex = 0;
-} else {
+	} else {
-error = @symbol(badArgument3);
+	    error = @symbol(badArgument3);
-goto err;
+	    goto err;
-}
+	}
 }
 if (__isSmallInteger(maxBytes)) {
-__maxBytes = __intVal(maxBytes);
+	__maxBytes = __intVal(maxBytes);
 } else if (maxBytes == nil) {
-__maxBytes = -1;
+	__maxBytes = -1;
 } else {
-error = @symbol(badArgument4);
+	error = @symbol(badArgument4);
-goto err;
+	goto err;
 }
 if (!__isInteger(flags)) {
-error = @symbol(badArgument5);
+	error = @symbol(badArgument5);
-goto err;
+	goto err;
 }
 __flags = __longIntVal(flags);
 sock = __smallIntegerVal(__INST(fd));
 oClass = __Class(aDataBuffer);
 switch (__intVal(__ClassInstPtr(oClass)->c_flags) & ARRAYMASK) {
-case BYTEARRAY:
+	case BYTEARRAY:
-offs = __startIndex;
+	    offs = __startIndex;
-break;
+	    break;
-case WORDARRAY:
+	case WORDARRAY:
-case SWORDARRAY:
+	case SWORDARRAY:
-offs = __startIndex * 2;
+	    offs = __startIndex * 2;
-break;
+	    break;
-case LONGARRAY:
+	case LONGARRAY:
-case SLONGARRAY:
+	case SLONGARRAY:
-offs = __startIndex * 4;
+	    offs = __startIndex * 4;
-break;
+	    break;
-case LONGLONGARRAY:
+	case LONGLONGARRAY:
-case SLONGLONGARRAY:
+	case SLONGLONGARRAY:
-offs = __startIndex * 8;
+	    offs = __startIndex * 8;
 # ifdef __NEED_LONGLONG_ALIGN
-offs += 4;
+	    offs += 4;
 # endif
-break;
+	    break;
-case FLOATARRAY:
+	case FLOATARRAY:
-offs = __startIndex * sizeof(float);
+	    offs = __startIndex * sizeof(float);
-break;
+	    break;
-case DOUBLEARRAY:
+	case DOUBLEARRAY:
-offs = __startIndex * sizeof(double);
+	    offs = __startIndex * sizeof(double);
 # ifdef __NEED_DOUBLE_ALIGN
-offs += 4;
+	    offs += 4;
 # endif
-break;
+	    break;
-default:
+	default:
-error = @symbol(badArgument2);
+	    error = @symbol(badArgument2);
-goto err;
+	    goto err;
 }
 nInstVars = __smallIntegerVal(__ClassInstPtr(oClass)->c_ninstvars);
 nInstBytes = OHDR_SIZE + nInstVars * sizeof(OBJ);
 objSize = __qSize(aDataBuffer) - nInstBytes - offs;
 if (__maxBytes >= 0 && __maxBytes < objSize) {
 # ifdef DGRAM_DEBUG
-printf("cut off ...\n");
+	printf("cut off ...\n");
 # endif
-objSize = __maxBytes;
+	objSize = __maxBytes;
 }
 if (socketAddress == nil) {
-alen = 0;
+	alen = 0;
 } else {
-if (! __isByteArrayLike(socketAddress)) {
+	if (! __isByteArrayLike(socketAddress)) {
-error = @symbol(badArgument1);
+	    error = @symbol(badArgument1);
-goto err;
+	    goto err;
-}
+	}
-alen = __byteArraySize(socketAddress);
+	alen = __byteArraySize(socketAddress);
 }
 saPtr = (struct sockaddr *)0;
 again:
 if (alen)
-saPtr = (struct sockaddr *)__byteArrayVal(socketAddress);
+	saPtr = (struct sockaddr *)__byteArrayVal(socketAddress);
 cp = (char *)__InstPtr(aDataBuffer) + nInstBytes + offs;
 n = sendto(sock, cp, objSize, __flags, saPtr, alen);
 if (n < 0) {
-if (errno == EINTR) {
+	if (errno == EINTR) {
-__HANDLE_INTERRUPTS__;
+	    __HANDLE_INTERRUPTS__;
-goto again;
+	    goto again;
-} else {
+	} else {
-error = __mkSmallInteger(errno);
+	    error = __mkSmallInteger(errno);
-goto err;
+	    goto err;
-}
+	}
 }
 RETURN (__mkSmallInteger(n));
 #endif
 err: ;
 %}.
 |error domainCode typeCode protocolNumber|
 domainCode := OperatingSystem domainCodeOf:domainArg.
 typeCode := OperatingSystem socketTypeCodeOf:typeArg.
 protocolArg notNil ifTrue:[
-protocolNumber := self class protocolCodeOf:protocolArg
+	protocolNumber := self class protocolCodeOf:protocolArg
 ].
 %{
 #if 0 && !defined(NO_SOCKET)
 int dom, typ, proto = 0, sock, ret;
 int on = 1;
 if (__INST(fd) != nil) {
-error = @symbol(internalError);
+	error = @symbol(internalError);
-goto err;
+	goto err;
 }
 if (! __isSmallInteger(domainCode)) {
-error = @symbol(badArgument1);
+	error = @symbol(badArgument1);
-goto err;
+	goto err;
 }
 if (! __isSmallInteger(typeArg)) {
-error = @symbol(badArgument2);
+	error = @symbol(badArgument2);
-goto err;
+	goto err;
 }
 if (protocolNumber != nil) {
-if (!__isSmallInteger(protocolNumber)) {
+	if (!__isSmallInteger(protocolNumber)) {
-error = @symbol(badArgument3);
+	    error = @symbol(badArgument3);
-goto err;
+	    goto err;
-}
+	}
-proto = __smallIntegerVal(protocolNumber);
+	proto = __smallIntegerVal(protocolNumber);
 }
 dom = __smallIntegerVal(domainCode);
 /*
 * get socket-type and protocol-type
 typ = __intVal(typeArg);
 againSocket:
 sock = socket(dom, typ, proto);
 if (sock < 0) {
-if (errno == EINTR) {
+	if (errno == EINTR) {
-__HANDLE_INTERRUPTS__;
+	    __HANDLE_INTERRUPTS__;
-goto againSocket;
+	    goto againSocket;
-} else
+	} else
 # if defined(EPROTONOSUPPORT) /* for SGI */
-if (errno == EPROTONOSUPPORT && proto != 0) {
+	if (errno == EPROTONOSUPPORT && proto != 0) {
-proto = 0;
+	    proto = 0;
-goto againSocket;
+	    goto againSocket;
-} else
+	} else
 # endif
-{
+	{
-error = __mkSmallInteger(errno);
+	    error = __mkSmallInteger(errno);
-goto err;
+	    goto err;
-}
+	}
 }
 __INST(fd) = __mkSmallInteger(sock);
 err:;
 # else /* NOSOCKET */
 error = @symbol(notImplemented);
 # endif /* NOSOCKET */
 %}.
 error notNil ifTrue:[
-^ self error:error.
+	^ self error:error.
 ].
 self register.
 "
 self new domain:#inet type:#stream protocol:nil
 int sock;
 int intval, sz;
 char *p;
 if (!__isSmallInteger(__INST(fd))) {
-error = @symbol(badFd);
+	error = @symbol(badFd);
-goto err;
+	goto err;
 }
 if (!__bothSmallInteger(level, name)) {
-error = @symbol(badArgument);
+	error = @symbol(badArgument);
-goto err;
+	goto err;
 }
 if (!__isByteArray(bytes)) {
-error = @symbol(internalError);
+	error = @symbol(internalError);
-goto err;
+	goto err;
 }
 p = __byteArrayVal(bytes);
 sz = __byteArraySize(bytes);
 sock = __smallIntegerVal(__INST(fd));
 if (getsockopt(sock, __smallIntegerVal(level), __smallIntegerVal(name), p, &sz) < 0) {
-error = __mkSmallInteger(errno);
+	error = __mkSmallInteger(errno);
 }
 size = __mkSmallInteger(sz);
 err:;
 #endif
 %}.
 error notNil ifTrue:[
-^ self error:error
+	^ self error:error
 ].
 ^ bytes copyTo:size
 !
 listenFor:aNumber
 %{
 #if 0 && !defined(NO_SOCKET)
 int sock, ret;
 if (!__isSmallInteger(__INST(fd))) {
-error = @symbol(badFd);
+	error = @symbol(badFd);
-goto err;
+	goto err;
 }
 if (!__isSmallInteger(aNumber)) {
-error = @symbol(badArgument1);
+	error = @symbol(badArgument1);
-goto err;
+	goto err;
 }
 sock = __smallIntegerVal(__INST(fd));
 again:
 ret = listen(sock, __smallIntegerVal(aNumber));
 if (ret < 0) {
-if (errno == EINTR) {
+	if (errno == EINTR) {
-__HANDLE_INTERRUPTS__;
+	    __HANDLE_INTERRUPTS__;
-goto again;
+	    goto again;
-} else {
+	} else {
-error = __mkSmallInteger(errno);
+	    error = __mkSmallInteger(errno);
-}
+	}
 }
 err:;
 #endif
 %}.
 error notNil ifTrue:[
-^ self error:error.
+	^ self error:error.
 ].
 ^ nil
 !
 setOptionsLevel:level name:name value:value
 int sock;
 int __level, __name, intval, sz;
 char *p;
 if (!__isSmallInteger(__INST(fd))) {
-error = @symbol(badFd);
+	error = @symbol(badFd);
-goto err;
+	goto err;
 }
 if (__isSmallInteger(level)) {
-__level = __smallIntegerVal(level);
+	__level = __smallIntegerVal(level);
 } else if (level == @symbol(SOL_SOCKET)) {
-__level = SOL_SOCKET;
+	__level = SOL_SOCKET;
 } else {
-error = @symbol(badArgument1);
+	error = @symbol(badArgument1);
-goto err;
+	goto err;
 }
 if (__isSmallInteger(name)) {
-__name = __smallIntegerVal(name);
+	__name = __smallIntegerVal(name);
 } else if (name == @symbol(SO_REUSEADDR)) {
-__name = SO_REUSEADDR;
+	__name = SO_REUSEADDR;
 } else {
-error = @symbol(badArgument2);
+	error = @symbol(badArgument2);
-goto err;
+	goto err;
 }
 if (__isSmallInteger(value)) {
-intval = __intVal(value);
+	intval = __intVal(value);
-p = (char *) &intval;
+	p = (char *) &intval;
-sz = sizeof(intval);
+	sz = sizeof(intval);
 } else if (__isByteArrayLike(value)) {
-p = __byteArrayVal(value);
+	p = __byteArrayVal(value);
-sz = __byteArraySize(value);
+	sz = __byteArraySize(value);
 } else {
-error = @symbol(badArgument3);
+	error = @symbol(badArgument3);
-goto err;
+	goto err;
 }
 sock = __smallIntegerVal(__INST(fd));
 if (setsockopt(sock, __level, __name, p, sz) < 0) {
-error = __mkSmallInteger(errno);
+	error = __mkSmallInteger(errno);
 }
 err:;
 #endif
 %}.
 error notNil ifTrue:[
-^ self error:error
+	^ self error:error
 ].
 ^ nil.
 !
 shutdown:anInteger
 "inform the socket that no more I/O will happen.
 anInteger == 0   no reads will be performed
 anInteger == 1   no writes will be performed
 anInteger == 2   neither reads nor writes will be performed.
-Pending data is discarded. This is faster tha
+		      Pending data is discarded. This is faster tha
-close, which may wait until pending (written)
+		      close, which may wait until pending (written)
-data has been read by the other side"
+		      data has been read by the other side"
 |error|
 %{
 #if 0 && !defined(NO_SOCKET)
 int ret;
 if (!__isSmallInteger(__INST(fd))) {
-error = @symbol(badFd);
+	error = @symbol(badFd);
-goto err;
+	goto err;
 }
 if (!__isSmallInteger(anInteger)) {
-error = @symbol(badArgument1);
+	error = @symbol(badArgument1);
-goto err;
+	goto err;
 }
 again:
 ret = shutdown(__smallIntegerVal(__INST(fd)), __smallIntegerVal(anInteger));
 if (ret < 0) {
-if (errno == EINTR) {
+	if (errno == EINTR) {
-__HANDLE_INTERRUPTS__;
+	    __HANDLE_INTERRUPTS__;
-goto again;
+	    goto again;
-} else {
+	} else {
-error = __mkSmallInteger(errno);
+	    error = __mkSmallInteger(errno);
-}
+	}
 }
 err:;
 #endif /*NO_SOCKET*/
 %}.
 error notNil ifTrue:[
-^ self error:error
+	^ self error:error
 ].
 ^ nil.
 ! !
 !UnixOperatingSystem::SocketHandle methodsFor:'queries'!
 int sock;
 int sockaddr_size;
 int ret;
 if (!__isSmallInteger(__INST(fd))) {
-error = @symbol(badFd);
+	error = @symbol(badFd);
-goto err;
+	goto err;
 }
 if (!__isNonNilObject(socketAddress) ||
-(__intVal(__ClassInstPtr(__qClass(socketAddress))->c_flags) & ARRAYMASK) != BYTEARRAY) {
+	(__intVal(__ClassInstPtr(__qClass(socketAddress))->c_flags) & ARRAYMASK) != BYTEARRAY) {
-error = @symbol(badArgument1);
+	error = @symbol(badArgument1);
-goto err;
+	goto err;
 }
 sockaddr_size = __byteArraySize(socketAddress);
 sock = __smallIntegerVal(__INST(fd));
 ret = getsockname(sock, (struct sockaddr *)__byteArrayVal(socketAddress), &sockaddr_size);
 if (ret < 0) {
-error = __mkSmallInteger(errno);
+	error = __mkSmallInteger(errno);
 }
 err:;
 #endif /* NO_SOCKET */
 %}.
 error notNil ifTrue:[
-^ self error:error
+	^ self error:error
 ].
 ^ nil.
 !
 getPeerInto:socketAddress
 int __sock;
 int __sockaddr_size;
 int __ret;
 if (!__isSmallInteger(__INST(fd))) {
-error = @symbol(badFd);
+	error = @symbol(badFd);
-goto err;
+	goto err;
 }
 if (!__isNonNilObject(socketAddress) ||
-(__intVal(__ClassInstPtr(__qClass(socketAddress))->c_flags) & ARRAYMASK) != BYTEARRAY) {
+	(__intVal(__ClassInstPtr(__qClass(socketAddress))->c_flags) & ARRAYMASK) != BYTEARRAY) {
-error = @symbol(badArgument1);
+	error = @symbol(badArgument1);
-goto err;
+	goto err;
 }
 __sockaddr_size = __byteArraySize(socketAddress);
 __sock = __smallIntegerVal(__INST(fd));
 __ret = getpeername(__sock, (struct sockaddr *)__byteArrayVal(socketAddress),
-&__sockaddr_size);
+				&__sockaddr_size);
 if (__ret < 0) {
-error = __mkSmallInteger(errno);
+	error = __mkSmallInteger(errno);
 }
 err:;
 #endif /* NO_SOCKET */
 %}.
 error notNil ifTrue:[
-^ self error:error
+	^ self error:error
 ].
 ^ nil
 ! !
 !UnixOperatingSystem class methodsFor:'documentation'!
 version
-^ '$Header: /cvs/stx/stx/libbasic/UnixOperatingSystem.st,v 1.422 2015-03-02 23:12:12 stefan Exp $'
+^ '$Header: /cvs/stx/stx/libbasic/UnixOperatingSystem.st,v 1.423 2015-03-09 17:46:04 cg Exp $'
 !
 version_CVS
-^ '$Header: /cvs/stx/stx/libbasic/UnixOperatingSystem.st,v 1.422 2015-03-02 23:12:12 stefan Exp $'
+^ '$Header: /cvs/stx/stx/libbasic/UnixOperatingSystem.st,v 1.423 2015-03-09 17:46:04 cg Exp $'
 ! !
 UnixOperatingSystem initialize!
 UnixOperatingSystem::FileDescriptorHandle initialize!

changeset 17596	082b7d32692a
parent 17579	4d70eacfd5d7
child 17631	0441ae93a3e4