hg/stx-libbasic: comparison Win32OperatingSystem.st

equal deleted inserted replaced

-:e6ce341ac09b
+:bef737d1b8a7
 "
 COPYRIGHT (c) 1988 by Claus Gittinger
 COPYRIGHT (c) 1998-2004 by eXept Software AG
-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
 tv.tv_sec  = 0;
 tv.tv_usec = 0;
 if (readMode) {
-n = select (sock + 1, & fds, NULL, NULL, & tv);
+	n = select (sock + 1, & fds, NULL, NULL, & tv);
 } else {
-n = select (sock + 1, NULL, & fds, NULL, & tv);
+	n = select (sock + 1, NULL, & fds, NULL, & tv);
 }
 if (n == 0) {
-return (0);
+	return (0);
 }
 if (n > 0) {
-return ((FD_ISSET (sock, & fds)) ? 1 : 0);
+	return ((FD_ISSET (sock, & fds)) ? 1 : 0);
 }
 winErrNo = WSAGetLastError();
 switch (winErrNo) {
-case WSAENOTSOCK:
+	case WSAENOTSOCK:
-if (readMode) {
+	    if (readMode) {
-DWORD  w = 0;
+		DWORD  w = 0;
-HANDLE h = (HANDLE) _get_osfhandle (aFD);
+		HANDLE h = (HANDLE) _get_osfhandle (aFD);
-if (PeekNamedPipe (h, 0, 0, 0, & w, 0)) {
+		if (PeekNamedPipe (h, 0, 0, 0, & w, 0)) {
-if( !__isWinNT || w > 0 )
+		    if( !__isWinNT || w > 0 )
-return (1);
+			return (1);
-return (0);
+		    return (0);
-}
+		}
 #if 0
-console_fprintf(stderr, "_canAccessIOWithoutBlocking non Socket\n");
+		console_fprintf(stderr, "_canAccessIOWithoutBlocking non Socket\n");
 #endif
-return (-1);
+		return (-1);
-}
+	    }
-/* in writeMode we return allways true for none-sockets */
+	    /* in writeMode we return allways true for none-sockets */
-return (1);
+	    return (1);
-case WSAEINPROGRESS:
+	case WSAEINPROGRESS:
-case WSAEWOULDBLOCK:
+	case WSAEWOULDBLOCK:
-return (0);
+	    return (0);
-default:
+	default:
-console_fprintf(stderr, "_canAccessIOWithoutBlocking -> %d (0x%x)\n", winErrNo, winErrNo);
+	    console_fprintf(stderr, "_canAccessIOWithoutBlocking -> %d (0x%x)\n", winErrNo, winErrNo);
-return (-1);
+	    return (-1);
 }
 /* not reached */
 return (0);
 }
 */
 FARPROC entry;
 static HINSTANCE handle = NULL;
 if (handle == NULL) {
-handle = LoadLibrary("KERNEL32.DLL");
+	handle = LoadLibrary("KERNEL32.DLL");
 }
 entry = GetProcAddress(handle, functionName);
 return entry;
 }
 */
 FARPROC entry;
 static HINSTANCE handle2 = NULL;
 if (handle2 == NULL) {
-handle2 = LoadLibrary("iphlpapi.DLL");
+	handle2 = LoadLibrary("iphlpapi.DLL");
 }
 entry = GetProcAddress(handle2, functionName);
 return entry;
 }
 copyright
 "
 COPYRIGHT (c) 1988 by Claus Gittinger
 COPYRIGHT (c) 1998-2004 by eXept Software AG
-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
-CurrentDirectory <String>       remembered currentDirectories path
+	CurrentDirectory <String>       remembered currentDirectories path
 [author:]
-Claus Gittinger (initial version & cleanup)
+	Claus Gittinger (initial version & cleanup)
-Manfred Dierolf (many features)
+	Manfred Dierolf (many features)
 [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]
 "
 ! !
 !Win32OperatingSystem class methodsFor:'initialization'!
 memset(&osvi, 0, sizeof(OSVERSIONINFO));
 osvi.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
 GetVersionEx (&osvi);
 if (osvi.dwPlatformId == VER_PLATFORM_WIN32_NT) {
-__isWinNT = 1;
+	__isWinNT = 1;
 } else {
-__isWinNT = 0;
+	__isWinNT = 0;
 }
 %}.
 !
 initialize
 update:something with:aParameter from:changedObject
 "catch image restart and flush some cached data"
 something == #earlyRestart ifTrue:[
-"
+	"
-flush cached data
+	 flush cached data
-"
+	"
-HostName := nil.
+	HostName := nil.
-DomainName := nil.
+	DomainName := nil.
-LastErrorNumber := nil.
+	LastErrorNumber := nil.
-PipeFailed := false.
+	PipeFailed := false.
-self initOSType
+	self initOSType
 ]
 "Modified: 22.4.1996 / 13:10:43 / cg"
 "Created: 15.6.1996 / 15:22:37 / cg"
 "Modified: 7.1.1997 / 19:36:11 / stefan"
 "change the file, into which log info is written"
 |logFilePath|
 aFilenameOrNil notNil ifTrue:[
-logFilePath := aFilenameOrNil asFilename pathName
+	logFilePath := aFilenameOrNil asFilename pathName
 ].
 %{
 extern void __win32_setLogFile();
 if (__isString(logFilePath)) {
-__win32_setLogFile(__stringVal(logFilePath));
+	__win32_setLogFile(__stringVal(logFilePath));
 } else {
-__win32_setLogFile( NULL );
+	__win32_setLogFile( NULL );
 }
 %}
 "
 Win32OperatingSystem win32LogFile:'myLog.log'
 if (__isSmallInteger(errNr) || (__unsignedLongIntVal(errNr) > 0)) {
 int __eno = __unsignedLongIntVal(errNr);
 if (__isWIN32Error(__eno)) {
-switch (__eno & 0xFFFF) {
+	switch (__eno & 0xFFFF) {
-/*
+	    /*
-* WIN32 GetLastError returns
+	     * WIN32 GetLastError returns
-*/
+	     */
-case ERROR_INVALID_FUNCTION:
+	    case ERROR_INVALID_FUNCTION:
-sym = @symbol(ERROR_INVALID_FUNCTION);
+		sym = @symbol(ERROR_INVALID_FUNCTION);
-typ = @symbol(illegalOperationSignal);
+		typ = @symbol(illegalOperationSignal);
-break;
+		break;
-case ERROR_BAD_FORMAT:
+	    case ERROR_BAD_FORMAT:
-sym = @symbol(ERROR_BAD_FORMAT);
+		sym = @symbol(ERROR_BAD_FORMAT);
-typ = @symbol(invalidArgumentsSignal);
+		typ = @symbol(invalidArgumentsSignal);
-break;
+		break;
-case ERROR_FILE_NOT_FOUND:
+	    case ERROR_FILE_NOT_FOUND:
-sym = @symbol(ERROR_FILE_NOT_FOUND);
+		sym = @symbol(ERROR_FILE_NOT_FOUND);
-typ = @symbol(nonexistentSignal);
+		typ = @symbol(nonexistentSignal);
-break;
+		break;
-case ERROR_PATH_NOT_FOUND:
+	    case ERROR_PATH_NOT_FOUND:
-sym = @symbol(ERROR_PATH_NOT_FOUND);
+		sym = @symbol(ERROR_PATH_NOT_FOUND);
-typ = @symbol(nonexistentSignal);
+		typ = @symbol(nonexistentSignal);
-break;
+		break;
-case ERROR_TOO_MANY_OPEN_FILES:
+	    case ERROR_TOO_MANY_OPEN_FILES:
-sym = @symbol(ERROR_TOO_MANY_OPEN_FILES);
+		sym = @symbol(ERROR_TOO_MANY_OPEN_FILES);
-typ = @symbol(noResourcesSignal);
+		typ = @symbol(noResourcesSignal);
-break;
+		break;
-/*
+	    /*
-* what a nice errorCode - thats the most "useful" one I ever
+	     * what a nice errorCode - thats the most "useful" one I ever
-* encountered ... (... those stupid micro-softies ...)
+	     * encountered ... (... those stupid micro-softies ...)
-*/
+	     */
-case ERROR_OPEN_FAILED:
+	    case ERROR_OPEN_FAILED:
-sym = @symbol(ERROR_OPEN_FAILED);
+		sym = @symbol(ERROR_OPEN_FAILED);
-typ = @symbol(noResourcesSignal);
+		typ = @symbol(noResourcesSignal);
-break;
+		break;
-case ERROR_ACCESS_DENIED:
+	    case ERROR_ACCESS_DENIED:
-sym = @symbol(ERROR_ACCESS_DENIED);
+		sym = @symbol(ERROR_ACCESS_DENIED);
-typ = @symbol(noPermissionsSignal);
+		typ = @symbol(noPermissionsSignal);
-break;
+		break;
-case ERROR_INVALID_HANDLE:
+	    case ERROR_INVALID_HANDLE:
-sym = @symbol(ERROR_INVALID_HANDLE);
+		sym = @symbol(ERROR_INVALID_HANDLE);
-typ = @symbol(invalidArgumentsSignal);
+		typ = @symbol(invalidArgumentsSignal);
-break;
+		break;
-case ERROR_NOT_ENOUGH_MEMORY:
+	    case ERROR_NOT_ENOUGH_MEMORY:
-sym = @symbol(ERROR_NOT_ENOUGH_MEMORY);
+		sym = @symbol(ERROR_NOT_ENOUGH_MEMORY);
-typ = @symbol(noResourcesSignal);
+		typ = @symbol(noResourcesSignal);
-break;
+		break;
-case ERROR_INVALID_ACCESS:
+	    case ERROR_INVALID_ACCESS:
-sym = @symbol(ERROR_INVALID_ACCESS);
+		sym = @symbol(ERROR_INVALID_ACCESS);
-typ = @symbol(inappropriateOperationSignal);
+		typ = @symbol(inappropriateOperationSignal);
-break;
+		break;
-case ERROR_INVALID_DATA:
+	    case ERROR_INVALID_DATA:
-sym = @symbol(ERROR_INVALID_DATA);
+		sym = @symbol(ERROR_INVALID_DATA);
-typ = @symbol(invalidArgumentsSignal);
+		typ = @symbol(invalidArgumentsSignal);
-break;
+		break;
-case ERROR_INVALID_NAME:
+	    case ERROR_INVALID_NAME:
-sym = @symbol(ERROR_INVALID_NAME);
+		sym = @symbol(ERROR_INVALID_NAME);
-typ = @symbol(invalidArgumentsSignal);
+		typ = @symbol(invalidArgumentsSignal);
-break;
+		break;
-case ERROR_ARENA_TRASHED:
+	    case ERROR_ARENA_TRASHED:
-sym = @symbol(ERROR_ARENA_TRASHED);
+		sym = @symbol(ERROR_ARENA_TRASHED);
-typ = @symbol(noResourcesSignal);
+		typ = @symbol(noResourcesSignal);
-break;
+		break;
-case ERROR_OUTOFMEMORY:
+	    case ERROR_OUTOFMEMORY:
-sym = @symbol(ERROR_OUTOFMEMORY);
+		sym = @symbol(ERROR_OUTOFMEMORY);
-typ = @symbol(noResourcesSignal);
+		typ = @symbol(noResourcesSignal);
-break;
+		break;
-case ERROR_BROKEN_PIPE:
+	    case ERROR_BROKEN_PIPE:
-sym = @symbol(ERROR_BROKEN_PIPE);
+		sym = @symbol(ERROR_BROKEN_PIPE);
-typ = @symbol(peerFaultSignal);
+		typ = @symbol(peerFaultSignal);
-break;
+		break;
-case ERROR_GEN_FAILURE:
+	    case ERROR_GEN_FAILURE:
-sym = @symbol(ERROR_GEN_FAILURE);
+		sym = @symbol(ERROR_GEN_FAILURE);
-break;
+		break;
-case ERROR_WRITE_PROTECT:
+	    case ERROR_WRITE_PROTECT:
-sym = @symbol(ERROR_WRITE_PROTECT);
+		sym = @symbol(ERROR_WRITE_PROTECT);
-typ = @symbol(inappropriateOperationSignal);
+		typ = @symbol(inappropriateOperationSignal);
-break;
+		break;
-case ERROR_WRITE_FAULT:
+	    case ERROR_WRITE_FAULT:
-sym = @symbol(ERROR_WRITE_FAULT);
+		sym = @symbol(ERROR_WRITE_FAULT);
-typ = @symbol(transferFaultSignal);
+		typ = @symbol(transferFaultSignal);
-break;
+		break;
-case ERROR_READ_FAULT:
+	    case ERROR_READ_FAULT:
-sym = @symbol(ERROR_READ_FAULT);
+		sym = @symbol(ERROR_READ_FAULT);
-typ = @symbol(transferFaultSignal);
+		typ = @symbol(transferFaultSignal);
-break;
+		break;
-case ERROR_HANDLE_DISK_FULL:
+	    case ERROR_HANDLE_DISK_FULL:
-sym = @symbol(ERROR_HANDLE_DISK_FULL);
+		sym = @symbol(ERROR_HANDLE_DISK_FULL);
-typ = @symbol(volumeFullSignal);
+		typ = @symbol(volumeFullSignal);
-break;
+		break;
-case ERROR_DISK_FULL:
+	    case ERROR_DISK_FULL:
-sym = @symbol(ERROR_DISK_FULL);
+		sym = @symbol(ERROR_DISK_FULL);
-typ = @symbol(volumeFullSignal);
+		typ = @symbol(volumeFullSignal);
-break;
+		break;
-case ERROR_SHARING_VIOLATION:
+	    case ERROR_SHARING_VIOLATION:
-sym = @symbol(ERROR_SHARING_VIOLATION);
+		sym = @symbol(ERROR_SHARING_VIOLATION);
-typ = @symbol(noPermissionsSignal);
+		typ = @symbol(noPermissionsSignal);
-break;
+		break;
-case ERROR_LOCK_VIOLATION:
+	    case ERROR_LOCK_VIOLATION:
-sym = @symbol(ERROR_LOCK_VIOLATION);
+		sym = @symbol(ERROR_LOCK_VIOLATION);
-typ = @symbol(noPermissionsSignal);
+		typ = @symbol(noPermissionsSignal);
-break;
+		break;
-case ERROR_INVALID_PARAMETER:
+	    case ERROR_INVALID_PARAMETER:
-sym = @symbol(ERROR_INVALID_PARAMETER);
+		sym = @symbol(ERROR_INVALID_PARAMETER);
-typ = @symbol(invalidArgumentsSignal);
+		typ = @symbol(invalidArgumentsSignal);
-break;
+		break;
-case ERROR_NET_WRITE_FAULT:
+	    case ERROR_NET_WRITE_FAULT:
-sym = @symbol(ERROR_NET_WRITE_FAULT);
+		sym = @symbol(ERROR_NET_WRITE_FAULT);
-typ = @symbol(transferFaultSignal);
+		typ = @symbol(transferFaultSignal);
-break;
+		break;
-case ERROR_NOT_SUPPORTED:
+	    case ERROR_NOT_SUPPORTED:
-sym = @symbol(ERROR_NOT_SUPPORTED);
+		sym = @symbol(ERROR_NOT_SUPPORTED);
-typ = @symbol(inappropriateOperationSignal);
+		typ = @symbol(inappropriateOperationSignal);
-break;
+		break;
-case ERROR_REM_NOT_LIST:
+	    case ERROR_REM_NOT_LIST:
-sym = @symbol(ERROR_REM_NOT_LIST);
+		sym = @symbol(ERROR_REM_NOT_LIST);
-typ = @symbol(noResourcesSignal);
+		typ = @symbol(noResourcesSignal);
-break;
+		break;
-case ERROR_NETWORK_ACCESS_DENIED:
+	    case ERROR_NETWORK_ACCESS_DENIED:
-sym = @symbol(ERROR_NETWORK_ACCESS_DENIED);
+		sym = @symbol(ERROR_NETWORK_ACCESS_DENIED);
-typ = @symbol(noPermissionsSignal);
+		typ = @symbol(noPermissionsSignal);
-break;
+		break;
-case ERROR_DUP_NAME:
+	    case ERROR_DUP_NAME:
-sym = @symbol(ERROR_DUP_NAME);
+		sym = @symbol(ERROR_DUP_NAME);
-typ = @symbol(noResourcesSignal);
+		typ = @symbol(noResourcesSignal);
-break;
+		break;
-case ERROR_BAD_NETPATH:
+	    case ERROR_BAD_NETPATH:
-sym = @symbol(ERROR_BAD_NETPATH);
+		sym = @symbol(ERROR_BAD_NETPATH);
-typ = @symbol(noResourcesSignal);
+		typ = @symbol(noResourcesSignal);
-break;
+		break;
-case ERROR_NETWORK_BUSY:
+	    case ERROR_NETWORK_BUSY:
-sym = @symbol(ERROR_NETWORK_BUSY);
+		sym = @symbol(ERROR_NETWORK_BUSY);
-typ = @symbol(noResourcesSignal);
+		typ = @symbol(noResourcesSignal);
-break;
+		break;
-case ERROR_DRIVE_LOCKED:
+	    case ERROR_DRIVE_LOCKED:
-sym = @symbol(ERROR_DRIVE_LOCKED);
+		sym = @symbol(ERROR_DRIVE_LOCKED);
-typ = @symbol(inappropriateOperationSignal);
+		typ = @symbol(inappropriateOperationSignal);
-break;
+		break;
-case ERROR_INVALID_DRIVE:
+	    case ERROR_INVALID_DRIVE:
-sym = @symbol(ERROR_INVALID_DRIVE);
+		sym = @symbol(ERROR_INVALID_DRIVE);
-typ = @symbol(invalidArgumentsSignal);
+		typ = @symbol(invalidArgumentsSignal);
-break;
+		break;
-case ERROR_WRONG_DISK:
+	    case ERROR_WRONG_DISK:
-sym = @symbol(ERROR_WRONG_DISK);
+		sym = @symbol(ERROR_WRONG_DISK);
-typ = @symbol(noResourcesSignal);
+		typ = @symbol(noResourcesSignal);
-break;
+		break;
-case ERROR_CURRENT_DIRECTORY:
+	    case ERROR_CURRENT_DIRECTORY:
-sym = @symbol(ERROR_CURRENT_DIRECTORY);
+		sym = @symbol(ERROR_CURRENT_DIRECTORY);
-typ = @symbol(invalidArgumentsSignal);
+		typ = @symbol(invalidArgumentsSignal);
-break;
+		break;
-/*
+	    /*
-* what a nice errorCode - thats the most "useful" one I ever
+	     * what a nice errorCode - thats the most "useful" one I ever
-* encountered ... (... those stupid micro-softies ...)
+	     * encountered ... (... those stupid micro-softies ...)
-*/
+	     */
-case ERROR_CANNOT_MAKE:
+	    case ERROR_CANNOT_MAKE:
-sym = @symbol(ERROR_CANNOT_MAKE);
+		sym = @symbol(ERROR_CANNOT_MAKE);
-typ = @symbol(inappropriateOperationSignal);
+		typ = @symbol(inappropriateOperationSignal);
-break;
+		break;
-case ERROR_NO_MORE_FILES:
+	    case ERROR_NO_MORE_FILES:
-sym = @symbol(ERROR_NO_MORE_FILES);
+		sym = @symbol(ERROR_NO_MORE_FILES);
-typ = @symbol(noResourcesSignal);
+		typ = @symbol(noResourcesSignal);
-break;
+		break;
-case ERROR_NOT_READY:
+	    case ERROR_NOT_READY:
-sym = @symbol(ERROR_NOT_READY);
+		sym = @symbol(ERROR_NOT_READY);
-typ = @symbol(noResourcesSignal);
+		typ = @symbol(noResourcesSignal);
-break;
+		break;
-case ERROR_NOT_DOS_DISK:
+	    case ERROR_NOT_DOS_DISK:
-sym = @symbol(ERROR_NOT_DOS_DISK);
+		sym = @symbol(ERROR_NOT_DOS_DISK);
-typ = @symbol(invalidArgumentsSignal);
+		typ = @symbol(invalidArgumentsSignal);
-break;
+		break;
-case ERROR_OUT_OF_PAPER:
+	    case ERROR_OUT_OF_PAPER:
-sym = @symbol(ERROR_OUT_OF_PAPER);
+		sym = @symbol(ERROR_OUT_OF_PAPER);
-typ = @symbol(noResourcesSignal);
+		typ = @symbol(noResourcesSignal);
-break;
+		break;
-case ERROR_PRINTQ_FULL:
+	    case ERROR_PRINTQ_FULL:
-sym = @symbol(ERROR_PRINTQ_FULL);
+		sym = @symbol(ERROR_PRINTQ_FULL);
-typ = @symbol(noResourcesSignal);
+		typ = @symbol(noResourcesSignal);
-break;
+		break;
-default:
+	    default:
-sym = nil;
+		sym = nil;
-break;
+		break;
-}
+	}
 } else {
-switch (__eno) {
+	switch (__eno) {
-/*
+	    /*
-* 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 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 WSAEFAULT
-case WSAEFAULT:
+	    case WSAEFAULT:
-sym = @symbol(WSAEFAULT);
+		sym = @symbol(WSAEFAULT);
-typ = @symbol(invalidArgumentsSignal);
+		typ = @symbol(invalidArgumentsSignal);
-break;
+		break;
 #endif
 #ifdef WSAEINTR
-case WSAEINTR:
+	    case WSAEINTR:
-sym = @symbol(WSAEINTR);
+		sym = @symbol(WSAEINTR);
-typ = @symbol(transientErrorSignal);
+		typ = @symbol(transientErrorSignal);
-break;
+		break;
 #endif
 #ifdef WSAEBADF
-case WSAEBADF:
+	    case WSAEBADF:
-sym = @symbol(WSAEBADF);
+		sym = @symbol(WSAEBADF);
-typ = @symbol(badAccessorSignal);
+		typ = @symbol(badAccessorSignal);
-break;
+		break;
 #endif
 #ifdef WSAEACCESS
-case WSAEACCESS:
+	    case WSAEACCESS:
-sym = @symbol(WSAEACCESS);
+		sym = @symbol(WSAEACCESS);
-typ = @symbol(badAccessorSignal);
+		typ = @symbol(badAccessorSignal);
-break;
+		break;
 #endif
 #ifdef WSAEINVAL
-case WSAEINVAL:
+	    case WSAEINVAL:
-sym = @symbol(WSAEINVAL);
+		sym = @symbol(WSAEINVAL);
-typ = @symbol(invalidArgumentsSignal);
+		typ = @symbol(invalidArgumentsSignal);
-break;
+		break;
 #endif
 #ifdef WSAEMFILE
-case WSAEMFILE:
+	    case WSAEMFILE:
-sym = @symbol(WSAEMFILE);
+		sym = @symbol(WSAEMFILE);
-typ = @symbol(noResourcesSignal);
+		typ = @symbol(noResourcesSignal);
-break;
+		break;
 #endif
 #ifdef WSAEWOULDBLOCK
-case WSAEWOULDBLOCK:
+	    case WSAEWOULDBLOCK:
-sym = @symbol(WSAEWOULDBLOCK);
+		sym = @symbol(WSAEWOULDBLOCK);
-typ = @symbol(notReadySignal);
+		typ = @symbol(notReadySignal);
-break;
+		break;
 #endif
 #ifdef WSAEINPROGRESS
-case WSAEINPROGRESS:
+	    case WSAEINPROGRESS:
-sym = @symbol(WSAEINPROGRESS);
+		sym = @symbol(WSAEINPROGRESS);
-typ = @symbol(operationStartedSignal);
+		typ = @symbol(operationStartedSignal);
-break;
+		break;
 #endif
 #ifdef WSAEALREADY
-case WSAEALREADY:
+	    case WSAEALREADY:
-sym = @symbol(WSAEALREADY);
+		sym = @symbol(WSAEALREADY);
-typ = @symbol(operationStartedSignal);
+		typ = @symbol(operationStartedSignal);
-break;
+		break;
 #endif
 #ifdef WSAENOTSOCK
-case WSAENOTSOCK:
+	    case WSAENOTSOCK:
-sym = @symbol(WSAENOTSOCK);
+		sym = @symbol(WSAENOTSOCK);
-typ = @symbol(inappropriateOperationSignal);
+		typ = @symbol(inappropriateOperationSignal);
-break;
+		break;
 #endif
 #ifdef WSAEPROTONOSUPPORT
-case WSAEPROTONOSUPPORT:
+	    case WSAEPROTONOSUPPORT:
-sym = @symbol(WSAEPROTONOSUPPORT);
+		sym = @symbol(WSAEPROTONOSUPPORT);
-typ = @symbol(unsupportedOperationSignal);
+		typ = @symbol(unsupportedOperationSignal);
-break;
+		break;
 #endif
 #ifdef WSAESOCKTNOSUPPORT
-case WSAESOCKTNOSUPPORT:
+	    case WSAESOCKTNOSUPPORT:
-sym = @symbol(WSAESOCKTNOSUPPORT);
+		sym = @symbol(WSAESOCKTNOSUPPORT);
-typ = @symbol(unsupportedOperationSignal);
+		typ = @symbol(unsupportedOperationSignal);
-break;
+		break;
 #endif
 #ifdef E_NOINTERFACE
-case E_NOINTERFACE:
+	    case E_NOINTERFACE:
-sym = @symbol(E_NOINTERFACE);
+		sym = @symbol(E_NOINTERFACE);
-typ = @symbol(noInterfaceSignal);
+		typ = @symbol(noInterfaceSignal);
-break;
+		break;
 #endif
 #ifdef CO_E_NOTINITIALIZED
-case CO_E_NOTINITIALIZED:
+	    case CO_E_NOTINITIALIZED:
-sym = @symbol(CO_E_NOTINITIALIZED);
+		sym = @symbol(CO_E_NOTINITIALIZED);
-typ = @symbol(coNotInitializedSignal);
+		typ = @symbol(coNotInitializedSignal);
-break;
+		break;
 #endif
 #ifdef REGDB_E_CLASSNOTREG
-case REGDB_E_CLASSNOTREG:
+	    case REGDB_E_CLASSNOTREG:
-sym = @symbol(REGDB_E_CLASSNOTREG);
+		sym = @symbol(REGDB_E_CLASSNOTREG);
-typ = @symbol(classNotRegisteredSignal);
+		typ = @symbol(classNotRegisteredSignal);
-break;
+		break;
 #endif
 #ifdef CLASS_E_NOAGGREGATION
-case CLASS_E_NOAGGREGATION:
+	    case CLASS_E_NOAGGREGATION:
-sym = @symbol(CLASS_E_NOAGGREGATION);
+		sym = @symbol(CLASS_E_NOAGGREGATION);
-typ = @symbol(noAggregationSignal);
+		typ = @symbol(noAggregationSignal);
-break;
+		break;
 #endif
 #ifdef DISP_E_UNKNOWNNAME
-case DISP_E_UNKNOWNNAME:
+	    case DISP_E_UNKNOWNNAME:
-sym = @symbol(DISP_E_UNKNOWNNAME);
+		sym = @symbol(DISP_E_UNKNOWNNAME);
-typ = @symbol(unknownNameSignal);
+		typ = @symbol(unknownNameSignal);
-break;
+		break;
 #endif
 #ifdef OLEOBJ_E_NOVERBS
-case OLEOBJ_E_NOVERBS:
+	    case OLEOBJ_E_NOVERBS:
-sym = @symbol(OLEOBJ_E_NOVERBS);
+		sym = @symbol(OLEOBJ_E_NOVERBS);
-typ = @symbol(noVerbsSignal);
+		typ = @symbol(noVerbsSignal);
-break;
+		break;
 #endif
-default:
+	    default:
-break;
+		break;
-}
+	}
 }
 }
 %}.
 holder := OSErrorHolder new.
 holder errorSymbol:sym errorCategory:typ.
 /*
 * WIN32 GetLastError returns
 */
 #ifdef ERROR_INVALID_FUNCTION
 if (sym == @symbol(ERROR_INVALID_FUNCTION)) {
-RETURN ( __mkSmallInteger(ERROR_INVALID_FUNCTION) );
+	RETURN ( __mkSmallInteger(ERROR_INVALID_FUNCTION) );
 }
 #endif
 #ifdef ERROR_BAD_FORMAT
 if (sym == @symbol(ERROR_BAD_FORMAT)) {
-RETURN ( __mkSmallInteger(ERROR_BAD_FORMAT) );
+	RETURN ( __mkSmallInteger(ERROR_BAD_FORMAT) );
 }
 #endif
 #ifdef ERROR_FILE_NOT_FOUND
 if (sym == @symbol(ERROR_FILE_NOT_FOUND)) {
-RETURN ( __mkSmallInteger(ERROR_FILE_NOT_FOUND) );
+	RETURN ( __mkSmallInteger(ERROR_FILE_NOT_FOUND) );
 }
 #endif
 #ifdef ERROR_PATH_NOT_FOUND
 if (sym == @symbol(ERROR_PATH_NOT_FOUND)) {
-RETURN ( __mkSmallInteger(ERROR_PATH_NOT_FOUND) );
+	RETURN ( __mkSmallInteger(ERROR_PATH_NOT_FOUND) );
 }
 #endif
 #ifdef ERROR_TOO_MANY_OPEN_FILES
 if (sym == @symbol(ERROR_TOO_MANY_OPEN_FILES)) {
-RETURN ( __mkSmallInteger(ERROR_TOO_MANY_OPEN_FILES) );
+	RETURN ( __mkSmallInteger(ERROR_TOO_MANY_OPEN_FILES) );
 }
 #endif
 #ifdef ERROR_OPEN_FAILED
 if (sym == @symbol(ERROR_OPEN_FAILED)) {
-RETURN ( __mkSmallInteger(ERROR_OPEN_FAILED) );
+	RETURN ( __mkSmallInteger(ERROR_OPEN_FAILED) );
 }
 #endif
 #ifdef ERROR_ACCESS_DENIED
 if (sym == @symbol(ERROR_ACCESS_DENIED)) {
-RETURN ( __mkSmallInteger(ERROR_ACCESS_DENIED) );
+	RETURN ( __mkSmallInteger(ERROR_ACCESS_DENIED) );
 }
 #endif
 #ifdef ERROR_INVALID_HANDLE
 if (sym == @symbol(ERROR_INVALID_HANDLE)) {
-RETURN ( __mkSmallInteger(ERROR_INVALID_HANDLE) );
+	RETURN ( __mkSmallInteger(ERROR_INVALID_HANDLE) );
 }
 #endif
 #ifdef ERROR_NOT_ENOUGH_MEMORY
 if (sym == @symbol(ERROR_NOT_ENOUGH_MEMORY)) {
-RETURN ( __mkSmallInteger(ERROR_NOT_ENOUGH_MEMORY) );
+	RETURN ( __mkSmallInteger(ERROR_NOT_ENOUGH_MEMORY) );
 }
 #endif
 #ifdef ERROR_INVALID_ACCESS
 if (sym == @symbol(ERROR_INVALID_ACCESS)) {
-RETURN ( __mkSmallInteger(ERROR_INVALID_ACCESS) );
+	RETURN ( __mkSmallInteger(ERROR_INVALID_ACCESS) );
 }
 #endif
 #ifdef ERROR_INVALID_DATA
 if (sym == @symbol(ERROR_INVALID_DATA)) {
-RETURN ( __mkSmallInteger(ERROR_INVALID_DATA) );
+	RETURN ( __mkSmallInteger(ERROR_INVALID_DATA) );
 }
 #endif
 #ifdef ERROR_INVALID_NAME
 if (sym == @symbol(ERROR_INVALID_NAME)) {
-RETURN ( __mkSmallInteger(ERROR_INVALID_NAME) );
+	RETURN ( __mkSmallInteger(ERROR_INVALID_NAME) );
 }
 #endif
 #ifdef ERROR_ARENA_TRASHED
 if (sym == @symbol(ERROR_ARENA_TRASHED)) {
-RETURN ( __mkSmallInteger(ERROR_ARENA_TRASHED) );
+	RETURN ( __mkSmallInteger(ERROR_ARENA_TRASHED) );
 }
 #endif
 #ifdef ERROR_OUTOFMEMORY
 if (sym == @symbol(ERROR_OUTOFMEMORY)) {
-RETURN ( __mkSmallInteger(ERROR_OUTOFMEMORY) );
+	RETURN ( __mkSmallInteger(ERROR_OUTOFMEMORY) );
 }
 #endif
 #ifdef ERROR_BROKEN_PIPE
 if (sym == @symbol(ERROR_BROKEN_PIPE)) {
-RETURN ( __mkSmallInteger(ERROR_BROKEN_PIPE) );
+	RETURN ( __mkSmallInteger(ERROR_BROKEN_PIPE) );
 }
 #endif
 #ifdef ERROR_GEN_FAILURE
 if (sym == @symbol(ERROR_GEN_FAILURE)) {
-RETURN ( __mkSmallInteger(ERROR_GEN_FAILURE) );
+	RETURN ( __mkSmallInteger(ERROR_GEN_FAILURE) );
 }
 #endif
 #ifdef ERROR_WRITE_PROTECT
 if (sym == @symbol(ERROR_WRITE_PROTECT)) {
-RETURN ( __mkSmallInteger(ERROR_WRITE_PROTECT) );
+	RETURN ( __mkSmallInteger(ERROR_WRITE_PROTECT) );
 }
 #endif
 #ifdef ERROR_WRITE_FAULT
 if (sym == @symbol(ERROR_WRITE_FAULT)) {
-RETURN ( __mkSmallInteger(ERROR_WRITE_FAULT) );
+	RETURN ( __mkSmallInteger(ERROR_WRITE_FAULT) );
 }
 #endif
 #ifdef ERROR_READ_FAULT
 if (sym == @symbol(ERROR_READ_FAULT)) {
-RETURN ( __mkSmallInteger(ERROR_READ_FAULT) );
+	RETURN ( __mkSmallInteger(ERROR_READ_FAULT) );
 }
 #endif
 #ifdef ERROR_HANDLE_DISK_FULL
 if (sym == @symbol(ERROR_HANDLE_DISK_FULL)) {
-RETURN ( __mkSmallInteger(ERROR_HANDLE_DISK_FULL) );
+	RETURN ( __mkSmallInteger(ERROR_HANDLE_DISK_FULL) );
 }
 #endif
 #ifdef ERROR_DISK_FULL
 if (sym == @symbol(ERROR_DISK_FULL)) {
-RETURN ( __mkSmallInteger(ERROR_DISK_FULL) );
+	RETURN ( __mkSmallInteger(ERROR_DISK_FULL) );
 }
 #endif
 #ifdef ERROR_ERROR_SHARING_VIOLATION
 if (sym == @symbol(ERROR_ERROR_SHARING_VIOLATION)) {
-RETURN ( __mkSmallInteger(ERROR_ERROR_SHARING_VIOLATION) );
+	RETURN ( __mkSmallInteger(ERROR_ERROR_SHARING_VIOLATION) );
 }
 #endif
 #ifdef ERROR_LOCK_VIOLATION
 if (sym == @symbol(ERROR_LOCK_VIOLATION)) {
-RETURN ( __mkSmallInteger(ERROR_LOCK_VIOLATION) );
+	RETURN ( __mkSmallInteger(ERROR_LOCK_VIOLATION) );
 }
 #endif
 #ifdef ERROR_INVALID_PARAMETER
 if (sym == @symbol(ERROR_INVALID_PARAMETER)) {
-RETURN ( __mkSmallInteger(ERROR_INVALID_PARAMETER) );
+	RETURN ( __mkSmallInteger(ERROR_INVALID_PARAMETER) );
 }
 #endif
 #ifdef ERROR_NET_WRITE_FAULT
 if (sym == @symbol(ERROR_NET_WRITE_FAULT)) {
-RETURN ( __mkSmallInteger(ERROR_NET_WRITE_FAULT) );
+	RETURN ( __mkSmallInteger(ERROR_NET_WRITE_FAULT) );
 }
 #endif
 #ifdef ERROR_NOT_SUPPORTED
 if (sym == @symbol(ERROR_NOT_SUPPORTED)) {
-RETURN ( __mkSmallInteger(ERROR_NOT_SUPPORTED) );
+	RETURN ( __mkSmallInteger(ERROR_NOT_SUPPORTED) );
 }
 #endif
 #ifdef ERROR_REM_NOT_LIST
 if (sym == @symbol(ERROR_REM_NOT_LIST)) {
-RETURN ( __mkSmallInteger(ERROR_REM_NOT_LIST) );
+	RETURN ( __mkSmallInteger(ERROR_REM_NOT_LIST) );
 }
 #endif
 #ifdef ERROR_NETWORK_ACCESS_DENIED
 if (sym == @symbol(ERROR_NETWORK_ACCESS_DENIED)) {
-RETURN ( __mkSmallInteger(ERROR_NETWORK_ACCESS_DENIED) );
+	RETURN ( __mkSmallInteger(ERROR_NETWORK_ACCESS_DENIED) );
 }
 #endif
 #ifdef ERROR_DUP_NAME
 if (sym == @symbol(ERROR_DUP_NAME)) {
-RETURN ( __mkSmallInteger(ERROR_DUP_NAME) );
+	RETURN ( __mkSmallInteger(ERROR_DUP_NAME) );
 }
 #endif
 #ifdef ERROR_BAD_NETPATH
 if (sym == @symbol(ERROR_BAD_NETPATH)) {
-RETURN ( __mkSmallInteger(ERROR_BAD_NETPATH) );
+	RETURN ( __mkSmallInteger(ERROR_BAD_NETPATH) );
 }
 #endif
 #ifdef ERROR_NETWORK_BUSY
 if (sym == @symbol(ERROR_NETWORK_BUSY)) {
-RETURN ( __mkSmallInteger(ERROR_NETWORK_BUSY) );
+	RETURN ( __mkSmallInteger(ERROR_NETWORK_BUSY) );
 }
 #endif
 #ifdef ERROR_DRIVE_LOCKED
 if (sym == @symbol(ERROR_DRIVE_LOCKED)) {
-RETURN ( __mkSmallInteger(ERROR_DRIVE_LOCKED) );
+	RETURN ( __mkSmallInteger(ERROR_DRIVE_LOCKED) );
 }
 #endif
 #ifdef ERROR_INVALID_DRIVE
 if (sym == @symbol(ERROR_INVALID_DRIVE)) {
-RETURN ( __mkSmallInteger(ERROR_INVALID_DRIVE) );
+	RETURN ( __mkSmallInteger(ERROR_INVALID_DRIVE) );
 }
 #endif
 #ifdef ERROR_WRONG_DISK
 if (sym == @symbol(ERROR_WRONG_DISK)) {
-RETURN ( __mkSmallInteger(ERROR_WRONG_DISK) );
+	RETURN ( __mkSmallInteger(ERROR_WRONG_DISK) );
 }
 #endif
 #ifdef ERROR_CURRENT_DIRECTORY
 if (sym == @symbol(ERROR_CURRENT_DIRECTORY)) {
-RETURN ( __mkSmallInteger(ERROR_CURRENT_DIRECTORY) );
+	RETURN ( __mkSmallInteger(ERROR_CURRENT_DIRECTORY) );
 }
 #endif
 #ifdef ERROR_CANNOT_MAKE
 if (sym == @symbol(ERROR_CANNOT_MAKE)) {
-RETURN ( __mkSmallInteger(ERROR_CANNOT_MAKE) );
+	RETURN ( __mkSmallInteger(ERROR_CANNOT_MAKE) );
 }
 #endif
 #ifdef ERROR_NO_MORE_FILES
 if (sym == @symbol(ERROR_NO_MORE_FILES)) {
-RETURN ( __mkSmallInteger(ERROR_NO_MORE_FILES) );
+	RETURN ( __mkSmallInteger(ERROR_NO_MORE_FILES) );
 }
 #endif
 #ifdef ERROR_NOT_READY
 if (sym == @symbol(ERROR_NOT_READY)) {
-RETURN ( __mkSmallInteger(ERROR_NOT_READY) );
+	RETURN ( __mkSmallInteger(ERROR_NOT_READY) );
 }
 #endif
 #ifdef ERROR_NOT_DOS_DISK
 if (sym == @symbol(ERROR_NOT_DOS_DISK)) {
-RETURN ( __mkSmallInteger(ERROR_NOT_DOS_DISK) );
+	RETURN ( __mkSmallInteger(ERROR_NOT_DOS_DISK) );
 }
 #endif
 #ifdef ERROR_OUT_OF_PAPER
 if (sym == @symbol(ERROR_OUT_OF_PAPER)) {
-RETURN ( __mkSmallInteger(ERROR_OUT_OF_PAPER) );
+	RETURN ( __mkSmallInteger(ERROR_OUT_OF_PAPER) );
 }
 #endif
 #ifdef ERROR_PRINTQ_FULL
 if (sym == @symbol(ERROR_PRINTQ_FULL)) {
-RETURN ( __mkSmallInteger(ERROR_PRINTQ_FULL) );
+	RETURN ( __mkSmallInteger(ERROR_PRINTQ_FULL) );
 }
 #endif
 /*
 * POSIX errnos - these should be defined
 */
 #ifdef EPERM
 if (sym == @symbol(EPERM)) {
-RETURN ( __mkSmallInteger(EPERM) );
+	RETURN ( __mkSmallInteger(EPERM) );
 }
 #endif
 #ifdef ENOENT
 if (sym == @symbol(ENOENT)) {
-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 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
 /*
 * windows socket errors
 */
 #ifdef WSAEINTR
 if (sym == @symbol(WSAEINTR)) {
-RETURN ( __mkSmallInteger(WSAEINTR) );
+	RETURN ( __mkSmallInteger(WSAEINTR) );
 }
 #endif
 #ifdef WSAEBADF
 if (sym == @symbol(WSAEBADF)) {
-RETURN ( __mkSmallInteger(WSAEBADF) );
+	RETURN ( __mkSmallInteger(WSAEBADF) );
 }
 #endif
 #ifdef WSAEACCESS
 if (sym == @symbol(WSAEACCESS)) {
-RETURN ( __mkSmallInteger(WSAEACCESS) );
+	RETURN ( __mkSmallInteger(WSAEACCESS) );
 }
 #endif
 #ifdef WSAEFAULT
 if (sym == @symbol(WSAEFAULT)) {
-RETURN ( __mkSmallInteger(WSAEFAULT) );
+	RETURN ( __mkSmallInteger(WSAEFAULT) );
 }
 #endif
 #ifdef WSAEINVAL
 if (sym == @symbol(WSAEINVAL)) {
-RETURN ( __mkSmallInteger(WSAEINVAL) );
+	RETURN ( __mkSmallInteger(WSAEINVAL) );
 }
 #endif
 #ifdef WSAEMFILE
 if (sym == @symbol(WSAEMFILE)) {
-RETURN ( __mkSmallInteger(WSAEMFILE) );
+	RETURN ( __mkSmallInteger(WSAEMFILE) );
 }
 #endif
 #ifdef WSAEWOULDBLOCK
 if (sym == @symbol(WSAEWOULDBLOCK)) {
-RETURN ( __mkSmallInteger(WSAEWOULDBLOCK) );
+	RETURN ( __mkSmallInteger(WSAEWOULDBLOCK) );
 }
 #endif
 #ifdef WSAEINPROGRESS
 if (sym == @symbol(WSAEINPROGRESS)) {
-RETURN ( __mkSmallInteger(WSAEINPROGRESS) );
+	RETURN ( __mkSmallInteger(WSAEINPROGRESS) );
 }
 #endif
 #ifdef WSAEALREADY
 if (sym == @symbol(WSAEALREADY)) {
-RETURN ( __mkSmallInteger(WSAEALREADY) );
+	RETURN ( __mkSmallInteger(WSAEALREADY) );
 }
 #endif
 #ifdef WSAENOTSOCK
 if (sym == @symbol(WSAENOTSOCK)) {
-RETURN ( __mkSmallInteger(WSAENOTSOCK) );
+	RETURN ( __mkSmallInteger(WSAENOTSOCK) );
 }
 #endif
 #ifdef WSAEPROTONOSUPPORT
 if (sym == @symbol(WSAEPROTONOSUPPORT)) {
-RETURN ( __mkSmallInteger(WSAEPROTONOSUPPORT) );
+	RETURN ( __mkSmallInteger(WSAEPROTONOSUPPORT) );
 }
 #endif
 #ifdef WSAESOCKTNOSUPPORT
 if (sym == @symbol(WSAESOCKTNOSUPPORT)) {
-RETURN ( __mkSmallInteger(WSAESOCKTNOSUPPORT) );
+	RETURN ( __mkSmallInteger(WSAESOCKTNOSUPPORT) );
 }
 #endif
 #ifdef E_NOINTERFACE
 if (sym == @symbol(E_NOINTERFACE)) {
-RETURN ( __MKUINT(E_NOINTERFACE) );
+	RETURN ( __MKUINT(E_NOINTERFACE) );
 }
 #endif
 #ifdef CO_E_NOTINITIALIZED
 if (sym == @symbol(CO_E_NOTINITIALIZED)) {
-RETURN ( __MKUINT(CO_E_NOTINITIALIZED) );
+	RETURN ( __MKUINT(CO_E_NOTINITIALIZED) );
 }
 #endif
 #ifdef REGDB_E_CLASSNOTREG
 if (sym == @symbol(REGDB_E_CLASSNOTREG)) {
-RETURN ( __MKUINT(REGDB_E_CLASSNOTREG) );
+	RETURN ( __MKUINT(REGDB_E_CLASSNOTREG) );
 }
 #endif
 #ifdef CLASS_E_NOAGGREGATION
 if (sym == @symbol(CLASS_E_NOAGGREGATION)) {
-RETURN ( __MKUINT(CLASS_E_NOAGGREGATION) );
+	RETURN ( __MKUINT(CLASS_E_NOAGGREGATION) );
 }
 #endif
 #ifdef DISP_E_UNKNOWNNAME
 if (sym == @symbol(DISP_E_UNKNOWNNAME)) {
-RETURN ( __MKUINT(DISP_E_UNKNOWNNAME) );
+	RETURN ( __MKUINT(DISP_E_UNKNOWNNAME) );
 }
 #endif
 #ifdef OLEOBJ_E_NOVERBS
 if (sym == @symbol(OLEOBJ_E_NOVERBS)) {
-RETURN ( __MKUINT(OLEOBJ_E_NOVERBS) );
+	RETURN ( __MKUINT(OLEOBJ_E_NOVERBS) );
 }
 #endif
 %}.
 ^ -1
 "/ I know: this is a kludge but should work for now...
 "/ ...this will change in an upcoming version to include
 "/ command.com command-line parsing here (sigh).
 hasRedirection := false.
 (aCommandString isNil or:[aCommandString includesAny:'<>|']) ifTrue:[
-hasRedirection := true
+	hasRedirection := true
 ].
 self isMSWINDOWSNTlike ifTrue:[
-hasRedirection ifFalse:[
+	hasRedirection ifFalse:[
-"/ test whether the commandString is an executable;
+	    "/ test whether the commandString is an executable;
-"/ then, no shell is required
+	    "/ then, no shell is required
-cmdName := aCommandString withoutSeparators.
+	    cmdName := aCommandString withoutSeparators.
-(cmdName notEmpty and:[(cmdName startsWith:$") not]) ifTrue:[
+	    (cmdName notEmpty and:[(cmdName startsWith:$") not]) ifTrue:[
-|index file suffix|
+		|index file suffix|
-index := cmdName indexOfSeparatorStartingAt:1.
+		index := cmdName indexOfSeparatorStartingAt:1.
-index ~~ 0 ifTrue:[
+		index ~~ 0 ifTrue:[
-cmdName := cmdName copyFrom:1 to:(index -1).
+		    cmdName := cmdName copyFrom:1 to:(index -1).
-].
+		].
-file   := cmdName asFilename.
+		file   := cmdName asFilename.
-suffix := file suffix.
+		suffix := file suffix.
-suffix isEmptyOrNil ifTrue:[
+		suffix isEmptyOrNil ifTrue:[
-suffix := 'exe'.
+		    suffix := 'exe'.
-file := file withSuffix:suffix.
+		    file := file withSuffix:suffix.
-].
+		].
-(file exists and:[suffix = 'exe']) ifTrue:[
+		(file exists and:[suffix = 'exe']) ifTrue:[
-"/ is an executable, no shell required
+		    "/ is an executable, no shell required
-^ Array with:nil with:aCommandString.
+		    ^ Array with:nil with:aCommandString.
-].
+		].
-(self pathOfCommand:cmdName) notNil ifTrue:[
+		(self pathOfCommand:cmdName) notNil ifTrue:[
-"/ is an executable, no shell required
+		    "/ is an executable, no shell required
-^ Array with:nil with:aCommandString.
+		    ^ Array with:nil with:aCommandString.
-].
+		].
-].
+	    ].
-].
+	].
-shell := self getEnvironment:'COMSPEC'.
+	shell := self getEnvironment:'COMSPEC'.
-shell isNil ifTrue:[
+	shell isNil ifTrue:[
-wDir := self getWindowsSystemDirectory asFilename.
+	    wDir := self getWindowsSystemDirectory asFilename.
-shell := (wDir construct:'cmd.exe').
+	    shell := (wDir construct:'cmd.exe').
-shell exists ifFalse:[
+	    shell exists ifFalse:[
-shell := (wDir construct:'command.com').
+		shell := (wDir construct:'command.com').
-shell exists ifFalse:[
+		shell exists ifFalse:[
-self error:'no command.com available'.
+		    self error:'no command.com available'.
-]
+		]
-].
+	    ].
-shell := shell pathName.
+	    shell := shell pathName.
-].
+	].
-aCommandString isNil ifTrue:[
+	aCommandString isNil ifTrue:[
-^ Array with:nil with:shell
+	    ^ Array with:nil with:shell
-].
+	].
-^ Array with:nil with:(shell , ' /c ' , '"' , aCommandString , '"' )
+	^ Array with:nil with:(shell , ' /c ' , '"' , aCommandString , '"' )
 ].
 "/ I/O redirection is not yet handled directly
 "/ fallBack to command.com (below) to do it.
 hasRedirection ifFalse:[
-words := aCommandString asCollectionOfSubstringsSeparatedBy:Character space.
+	words := aCommandString asCollectionOfSubstringsSeparatedBy:Character space.
-args := ' '.
+	args := ' '.
-words from:2 to:(words size) do:[:s |
+	words from:2 to:(words size) do:[:s |
-args := args , (s , ' ').
+	    args := args , (s , ' ').
-].
+	].
-path := self pathOfCommand:(words at:1).
+	path := self pathOfCommand:(words at:1).
-path notNil ifTrue:[
+	path notNil ifTrue:[
-"/ execute the command directly -
+	    "/ execute the command directly -
-"/ without going through command.com
+	    "/ without going through command.com
-self isMSWINDOWSNTlike ifTrue:[
+	    self isMSWINDOWSNTlike ifTrue:[
-args := path , args.
+		args := path , args.
-].
+	    ].
-^ Array with:path with:args
+	    ^ Array with:path with:args
-].
+	].
 ].
 "/ I/O redirection or no executable was found
 shell := self getEnvironment:'COMSPEC'.
 shell isNil ifTrue:[
-wDir := self getWindowsSystemDirectory asFilename.
+	wDir := self getWindowsSystemDirectory asFilename.
-shell := (wDir construct:'cmd.exe').
+	shell := (wDir construct:'cmd.exe').
-shell exists ifFalse:[
+	shell exists ifFalse:[
-shell := (wDir construct:'command.com').
+	    shell := (wDir construct:'command.com').
-shell exists ifFalse:[
+	    shell exists ifFalse:[
-self error:'no command.com available'.
+		self error:'no command.com available'.
-]
+	    ]
-].
+	].
-shell := shell pathName.
+	shell := shell pathName.
 ].
 aCommandString isNil ifTrue:[
-^ Array with:shell with:shell
+	^ Array with:shell with:shell
 ].
 ^ Array with:shell with:(shell , ' /c ' , aCommandString)
 "Modified: / 20-01-1998 / 16:57:19 / md"
 "Modified: / 11-02-2007 / 20:51:08 / cg"
 exec:aCommandPath withArguments:argString environment:environment fileDescriptors:fdArray fork:doFork newPgrp:newPgrp inDirectory:aDirectory
 "Internal lowLevel entry for combined fork & exec for WIN32
 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.
 fdArray 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[0] == StdIn for child
+	fdArray[0] == StdIn for child
-fdArray[1] == StdOut for child
+	fdArray[1] == StdOut for child
-fdArray[2] == StdErr for child
+	fdArray[2] == StdErr for child
-on VMS, these must be channels as returned by createMailBox.
+	on VMS, these must be channels as returned by createMailBox.
 NOTE that in WIN32 the fds are HANDLES.
 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."
 |dirPath cmdPath cmdLine rslt|
 aDirectory notNil ifTrue:[
-dirPath := aDirectory asFilename asAbsoluteFilename osNameForDirectory.
+	dirPath := aDirectory asFilename asAbsoluteFilename osNameForDirectory.
-(dirPath endsWith:':') ifTrue:[
+	(dirPath endsWith:':') ifTrue:[
-dirPath := dirPath , '\'.
+	    dirPath := dirPath , '\'.
-].
+	].
 ].
 self isMSWINDOWSNTlike ifTrue:[
-cmdPath := aCommandPath.
+	cmdPath := aCommandPath.
-cmdLine := argString
+	cmdLine := argString
 ] ifFalse:[
-cmdPath := 'stxspawn.exe'.
+	cmdPath := 'stxspawn.exe'.
-cmdLine := 'stxspawn.exe ' , aCommandPath , ' ' , argString
+	cmdLine := 'stxspawn.exe ' , aCommandPath , ' ' , argString
 ].
 rslt := self
-primExec:cmdPath
+	primExec:cmdPath
-commandLine:cmdLine
+	commandLine:cmdLine
-fileDescriptors:fdArray
+	fileDescriptors:fdArray
-fork:doFork
+	fork:doFork
-newPgrp:newPgrp
+	newPgrp:newPgrp
-inPath:dirPath
+	inPath:dirPath
-createFlags:nil.
+	createFlags:nil.
 "/ 'created ' print. cmdLine print. ' -> ' print. rslt printCR.
 ^ rslt
 "Modified: / 31.1.1998 / 10:54:24 / md"
 %{
 DWORD endStatus;
 int status = -1;
 if (__isExternalAddressLike(aProcessId)) {
-HANDLE handle = _HANDLEVal(aProcessId);
+	HANDLE handle = _HANDLEVal(aProcessId);
-if (handle) {
+	if (handle) {
 #ifdef DO_WRAP_CALLS
-do {
+	    do {
-__threadErrno = 0;
+		__threadErrno = 0;
-endStatus = STX_API_CALL2( "WaitForSingleObject", WaitForSingleObject, handle, INFINITE);
+		endStatus = STX_API_CALL2( "WaitForSingleObject", WaitForSingleObject, handle, INFINITE);
-} while ((endStatus < 0) && (__threadErrno == EINTR));
+	    } while ((endStatus < 0) && (__threadErrno == EINTR));
 #else
-endStatus = WaitForSingleObject(handle , INFINITE);
+	    endStatus = WaitForSingleObject(handle , INFINITE);
 #endif
-if (endStatus != WAIT_FAILED) {
+	    if (endStatus != WAIT_FAILED) {
-if (GetExitCodeProcess(handle,&endStatus)) {
+		if (GetExitCodeProcess(handle,&endStatus)) {
-status = endStatus;
+		    status = endStatus;
 #ifdef PROCESSDEBUGWIN32
-console_fprintf(stderr, "getexitcode status = %d\n",status);
+		    console_fprintf(stderr, "getexitcode status = %d\n",status);
-} else {
+		} else {
-console_fprintf(stderr, "getexitcode failed.\n");
+		    console_fprintf(stderr, "getexitcode failed.\n");
 #endif
-}
+		}
-}
+	    }
-}
+	}
-RETURN ( __mkSmallInteger(status));
+	RETURN ( __mkSmallInteger(status));
 }
 %}.
 self primitiveFailed
 !
 return nil."
 |path f fExt|
 aCommand asFilename isAbsolute ifTrue:[
-aCommand asFilename exists ifTrue:[
+	aCommand asFilename exists ifTrue:[
-^ aCommand
+	    ^ aCommand
-].
+	].
-^ nil
+	^ nil
 ].
 (aCommand includes:Filename separator) ifTrue:[
-path := Filename currentDirectory construct:aCommand.
+	path := Filename currentDirectory construct:aCommand.
-(path exists
+	(path exists
-or:[(path withSuffix:'exe') exists]) ifTrue:[
+	or:[(path withSuffix:'exe') exists]) ifTrue:[
-^ path pathName
+	    ^ path pathName
-].
+	].
 ].
 path := self getEnvironment:'PATH'.
 path notNil ifTrue:[
-(path asCollectionOfSubstringsSeparatedBy:(self pathSeparator)) do:[:path |
+	(path asCollectionOfSubstringsSeparatedBy:(self pathSeparator)) do:[:path |
-path isEmpty ifTrue:[
+	    path isEmpty ifTrue:[
-f := aCommand asFilename
+		f := aCommand asFilename
-] ifFalse:[
+	    ] ifFalse:[
-f := path asFilename construct:aCommand.
+		f := path asFilename construct:aCommand.
-].
+	    ].
-f suffix isEmpty ifTrue:[
+	    f suffix isEmpty ifTrue:[
-self executableFileExtensions do:[:ext |
+		self executableFileExtensions do:[:ext |
-ext notEmpty ifTrue:[
+		    ext notEmpty ifTrue:[
-fExt := (f pathName , '.' , ext) asFilename.
+			fExt := (f pathName , '.' , ext) asFilename.
-] ifFalse:[
+		    ] ifFalse:[
-fExt := f.
+			fExt := f.
-].
+		    ].
-fExt isExecutable ifTrue:[
+		    fExt isExecutable ifTrue:[
-^ fExt pathName
+			^ fExt pathName
-].
+		    ].
-].
+		].
-] ifFalse:[
+	    ] ifFalse:[
-f isExecutable ifTrue:[
+		f isExecutable ifTrue:[
-^ f pathName
+		    ^ f pathName
-].
+		].
-].
+	    ].
-].
+	].
 ].
 ^ nil
 "windows:
 PROCESS_INFORMATION lppiProcInfo;
 SECURITY_ATTRIBUTES sa;
 SECURITY_DESCRIPTOR sd;
 if (__isString(dirName)) {
-dir = __stringVal(dirName);
+	dir = __stringVal(dirName);
 }
 if ((__isString(commandPath) || (commandPath == nil))
 && __isString(commandLine)) {
 #if 0
-/*
+	/*
-* generate command line (cmd plus args)
+	 * generate command line (cmd plus args)
-*/
+	 */
-if (__isWinNT) {
+	if (__isWinNT) {
-char *d;
+	    char *d;
-strcpy(fullCmdPath, __stringVal(aCommandPath));
+	    strcpy(fullCmdPath, __stringVal(aCommandPath));
-d = strchr(fullCmdPath,' ');
+	    d = strchr(fullCmdPath,' ');
-if (d) {
+	    if (d) {
-*d++ = 0;
+		*d++ = 0;
-strcpy(fullCmdLine, d);
+		strcpy(fullCmdLine, d);
-} else {
+	    } else {
-fullCmdLine[0] = '\0';
+		fullCmdLine[0] = '\0';
-}
+	    }
-} else {
+	} else {
-//fullCmdPath = 0;
+	    //fullCmdPath = 0;
-strcpy(fullCmdPath,"stxspawn.exe");
+	    strcpy(fullCmdPath,"stxspawn.exe");
-strcpy(fullCmdLine,"stxspawn.exe ");
+	    strcpy(fullCmdLine,"stxspawn.exe ");
-strcat(fullCmdLine, __stringVal(aCommandPath));
+	    strcat(fullCmdLine, __stringVal(aCommandPath));
-}
+	}
-if (__isString(argArray)) {
+	if (__isString(argArray)) {
-if (strlen(fullCmdLine) > 0) {
+	    if (strlen(fullCmdLine) > 0) {
-strcat(fullCmdLine, " ");
+		strcat(fullCmdLine, " ");
-}
+	    }
-strcat(fullCmdLine, __stringVal(argArray));
+	    strcat(fullCmdLine, __stringVal(argArray));
-} else {
+	} else {
-int i;
+	    int i;
-for (i=0; i<__arraySize(argArray); i++) {
+	    for (i=0; i<__arraySize(argArray); i++) {
-OBJ arg = __ArrayInstPtr(argArray)->a_element[i];
+		OBJ arg = __ArrayInstPtr(argArray)->a_element[i];
-if (__isString(arg)) {
+		if (__isString(arg)) {
-strcat(fullCmdLine, " ");
+		    strcat(fullCmdLine, " ");
-strcat(fullCmdLine, __stringVal(arg));
+		    strcat(fullCmdLine, __stringVal(arg));
-} else {
+		} else {
-/* ignore */
+		    /* ignore */
-console_fprintf(stderr, "bad (non-string) arg\n");
+		    console_fprintf(stderr, "bad (non-string) arg\n");
-}
+		}
-}
+	    }
-}
+	}
 #endif
-if (commandPath != nil) {
+	if (commandPath != nil) {
-cmdPath = __stringVal(commandPath);
+	    cmdPath = __stringVal(commandPath);
-}
+	}
-cmdLine = __stringVal(commandLine);
+	cmdLine = __stringVal(commandLine);
-/*
+	/*
-* create descriptors as req'd
+	 * create descriptors as req'd
-*/
+	 */
-memset(&sa, 0, sizeof (sa));
+	memset(&sa, 0, sizeof (sa));
-sa.nLength = sizeof( sa );
+	sa.nLength = sizeof( sa );
-sa.lpSecurityDescriptor = NULL;
+	sa.lpSecurityDescriptor = NULL;
-sa.bInheritHandle = TRUE;
+	sa.bInheritHandle = TRUE;
-if (__isWinNT) {
+	if (__isWinNT) {
-InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION);
+	    InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION);
-SetSecurityDescriptorDacl(&sd, -1, 0, 0);
+	    SetSecurityDescriptorDacl(&sd, -1, 0, 0);
-sa.lpSecurityDescriptor = &sd;
+	    sa.lpSecurityDescriptor = &sd;
-}
+	}
-memset(&lppiProcInfo, 0, sizeof (lppiProcInfo));
+	memset(&lppiProcInfo, 0, sizeof (lppiProcInfo));
-memset(&lpsiStartInfo, 0, sizeof (lpsiStartInfo));
+	memset(&lpsiStartInfo, 0, sizeof (lpsiStartInfo));
-lpsiStartInfo.cb                = sizeof(lpsiStartInfo);
+	lpsiStartInfo.cb                = sizeof(lpsiStartInfo);
-lpsiStartInfo.lpReserved        = NULL;
+	lpsiStartInfo.lpReserved        = NULL;
-lpsiStartInfo.lpDesktop         = NULL;
+	lpsiStartInfo.lpDesktop         = NULL;
-lpsiStartInfo.lpTitle           = NULL;
+	lpsiStartInfo.lpTitle           = NULL;
-lpsiStartInfo.dwX               = 0;
+	lpsiStartInfo.dwX               = 0;
-lpsiStartInfo.dwY               = 0;
+	lpsiStartInfo.dwY               = 0;
-lpsiStartInfo.dwXSize           = 100;
+	lpsiStartInfo.dwXSize           = 100;
-lpsiStartInfo.dwYSize           = 100;
+	lpsiStartInfo.dwYSize           = 100;
-lpsiStartInfo.dwXCountChars     = 0;
+	lpsiStartInfo.dwXCountChars     = 0;
-lpsiStartInfo.dwYCountChars     = 0;
+	lpsiStartInfo.dwYCountChars     = 0;
-lpsiStartInfo.dwFillAttribute   = 0;
+	lpsiStartInfo.dwFillAttribute   = 0;
-if (0 /*__isWinNT*/) {
+	if (0 /*__isWinNT*/) {
-lpsiStartInfo.dwFlags           = STARTF_USESTDHANDLES;
+	    lpsiStartInfo.dwFlags           = STARTF_USESTDHANDLES;
-lpsiStartInfo.wShowWindow       = SW_SHOWDEFAULT;
+	    lpsiStartInfo.wShowWindow       = SW_SHOWDEFAULT;
-} else {
+	} else {
-lpsiStartInfo.dwFlags           = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES /*| STARTF_USEPOSITION*/;
+	    lpsiStartInfo.dwFlags           = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES /*| STARTF_USEPOSITION*/;
-lpsiStartInfo.wShowWindow       = SW_HIDE /*SW_SHOWDEFAULT*/;
+	    lpsiStartInfo.wShowWindow       = SW_HIDE /*SW_SHOWDEFAULT*/;
-}
+	}
-lpsiStartInfo.cbReserved2       = 0;
+	lpsiStartInfo.cbReserved2       = 0;
-lpsiStartInfo.lpReserved2       = NULL;
+	lpsiStartInfo.lpReserved2       = NULL;
-lpsiStartInfo.hStdInput         = NULL;
+	lpsiStartInfo.hStdInput         = NULL;
-lpsiStartInfo.hStdOutput        = NULL;
+	lpsiStartInfo.hStdOutput        = NULL;
-lpsiStartInfo.hStdError         = NULL;
+	lpsiStartInfo.hStdError         = NULL;
-/*
+	/*
-* set create process flags
+	 * set create process flags
-* if the flags arg is nil, use common defaults;
+	 * if the flags arg is nil, use common defaults;
-* if non-nil, it must be a positive integer containing the fdwCreate bits.
+	 * if non-nil, it must be a positive integer containing the fdwCreate bits.
-*/
+	 */
-if (flagsOrNil != nil) {
+	if (flagsOrNil != nil) {
-fdwCreate = __longIntVal(flagsOrNil);
+	    fdwCreate = __longIntVal(flagsOrNil);
-} else {
+	} else {
-if (0 /* __isWinNT */)
+	    if (0 /* __isWinNT */)
-fdwCreate = 0; //IDLE_PRIORITY_CLASS;
+		fdwCreate = 0; //IDLE_PRIORITY_CLASS;
-else
+	    else
-fdwCreate = CREATE_NEW_CONSOLE; //|IDLE_PRIORITY_CLASS; // DETACHED_PROCESS; // NORMAL_PRIORITY_CLASS ;
+		fdwCreate = CREATE_NEW_CONSOLE; //|IDLE_PRIORITY_CLASS; // DETACHED_PROCESS; // NORMAL_PRIORITY_CLASS ;
-if (newPgrp == true) {
+	    if (newPgrp == true) {
-fdwCreate |= CREATE_NEW_PROCESS_GROUP;
+		fdwCreate |= CREATE_NEW_PROCESS_GROUP;
-}
+	    }
-fdwCreate |= CREATE_DEFAULT_ERROR_MODE;
+	    fdwCreate |= CREATE_DEFAULT_ERROR_MODE;
-}
+	}
-if (fdArray == nil) {
+	if (fdArray == nil) {
-lpsiStartInfo.hStdInput  = (HANDLE) _get_osfhandle (0);
+	    lpsiStartInfo.hStdInput  = (HANDLE) _get_osfhandle (0);
-lpsiStartInfo.hStdOutput = (HANDLE) _get_osfhandle (1);
+	    lpsiStartInfo.hStdOutput = (HANDLE) _get_osfhandle (1);
-lpsiStartInfo.hStdError  = (HANDLE) _get_osfhandle (2);
+	    lpsiStartInfo.hStdError  = (HANDLE) _get_osfhandle (2);
-} else if (__isArrayLike(fdArray) && (__arraySize(fdArray) >= 3)) {
+	} else if (__isArrayLike(fdArray) && (__arraySize(fdArray) >= 3)) {
-if (__ArrayInstPtr(fdArray)->a_element[0] != nil) {
+	    if (__ArrayInstPtr(fdArray)->a_element[0] != nil) {
-if (__isExternalAddressLike(__ArrayInstPtr(fdArray)->a_element[0])) {
+		if (__isExternalAddressLike(__ArrayInstPtr(fdArray)->a_element[0])) {
-lpsiStartInfo.hStdInput = _HANDLEVal(__ArrayInstPtr(fdArray)->a_element[0]);
+		    lpsiStartInfo.hStdInput = _HANDLEVal(__ArrayInstPtr(fdArray)->a_element[0]);
-} else {
+		} else {
-lpsiStartInfo.hStdInput = (HANDLE) _get_osfhandle (__intVal(__ArrayInstPtr(fdArray)->a_element[0]));
+		    lpsiStartInfo.hStdInput = (HANDLE) _get_osfhandle (__intVal(__ArrayInstPtr(fdArray)->a_element[0]));
-}
+		}
-}
+	    }
-if (__ArrayInstPtr(fdArray)->a_element[1] != nil) {
+	    if (__ArrayInstPtr(fdArray)->a_element[1] != nil) {
-if (__isExternalAddressLike(__ArrayInstPtr(fdArray)->a_element[1])) {
+		if (__isExternalAddressLike(__ArrayInstPtr(fdArray)->a_element[1])) {
-lpsiStartInfo.hStdOutput = _HANDLEVal(__ArrayInstPtr(fdArray)->a_element[1]);
+		    lpsiStartInfo.hStdOutput = _HANDLEVal(__ArrayInstPtr(fdArray)->a_element[1]);
-} else {
+		} else {
-lpsiStartInfo.hStdOutput = (HANDLE) _get_osfhandle (__intVal(__ArrayInstPtr(fdArray)->a_element[1]));
+		    lpsiStartInfo.hStdOutput = (HANDLE) _get_osfhandle (__intVal(__ArrayInstPtr(fdArray)->a_element[1]));
-}
+		}
-}
+	    }
-if (__ArrayInstPtr(fdArray)->a_element[2] != nil) {
+	    if (__ArrayInstPtr(fdArray)->a_element[2] != nil) {
-if (__isExternalAddressLike(__ArrayInstPtr(fdArray)->a_element[2])) {
+		if (__isExternalAddressLike(__ArrayInstPtr(fdArray)->a_element[2])) {
-lpsiStartInfo.hStdError  = _HANDLEVal(__ArrayInstPtr(fdArray)->a_element[2]);
+		    lpsiStartInfo.hStdError  = _HANDLEVal(__ArrayInstPtr(fdArray)->a_element[2]);
-} else {
+		} else {
-lpsiStartInfo.hStdError = (HANDLE) _get_osfhandle (__intVal(__ArrayInstPtr(fdArray)->a_element[2]));
+		    lpsiStartInfo.hStdError = (HANDLE) _get_osfhandle (__intVal(__ArrayInstPtr(fdArray)->a_element[2]));
-}
+		}
-}
+	    }
 #ifdef PROCESSDEBUGWIN32
-console_fprintf(stderr, "stdin %x\n", lpsiStartInfo.hStdInput);
+	    console_fprintf(stderr, "stdin %x\n", lpsiStartInfo.hStdInput);
-console_fprintf(stderr, "stdout %x\n",lpsiStartInfo.hStdOutput);
+	    console_fprintf(stderr, "stdout %x\n",lpsiStartInfo.hStdOutput);
-console_fprintf(stderr, "stderr %x\n",lpsiStartInfo.hStdError);
+	    console_fprintf(stderr, "stderr %x\n",lpsiStartInfo.hStdError);
 #endif
-} else {
+	} else {
-console_fprintf(stderr, "Win32OS [warning]: bad fd arg in createProcess\n");
+	    console_fprintf(stderr, "Win32OS [warning]: bad fd arg in createProcess\n");
-}
+	}
-if (doFork == true) {
+	if (doFork == true) {
 #ifdef PROCESSDEBUGWIN32
-console_fprintf(stderr, "create process cmdPath:<%s> cmdLine:<%s> in <%s>\n", cmdPath, cmdLine, dir);
+	    console_fprintf(stderr, "create process cmdPath:<%s> cmdLine:<%s> in <%s>\n", cmdPath, cmdLine, dir);
 #endif
-if (CreateProcess(  cmdPath,
+	    if (CreateProcess(  cmdPath,
-cmdLine,
+				cmdLine,
-&sa, NULL /* &sa */,           /* sec-attribs */
+				&sa, NULL /* &sa */,           /* sec-attribs */
-sa.bInheritHandle,  /* inherit handles */
+				sa.bInheritHandle,  /* inherit handles */
-fdwCreate,
+				fdwCreate,
-NULL,               /* env */
+				NULL,               /* env */
-dir,
+				dir,
-&lpsiStartInfo,
+				&lpsiStartInfo,
-&lppiProcInfo ))
+				&lppiProcInfo ))
-{
+	    {
-CloseHandle(lppiProcInfo.hThread);
+		CloseHandle(lppiProcInfo.hThread);
 #ifdef PROCESSDEBUGWIN32
-console_fprintf(stderr, "created process hProcess=%x\n", lppiProcInfo.hProcess);
+		console_fprintf(stderr, "created process hProcess=%x\n", lppiProcInfo.hProcess);
 #endif
-__externalAddressVal(handle) = lppiProcInfo.hProcess;
+		__externalAddressVal(handle) = lppiProcInfo.hProcess;
-((struct __Win32OperatingSystem__Win32ProcessHandle_struct *)(handle))->pid = __mkSmallInteger(lppiProcInfo.dwProcessId);
+		((struct __Win32OperatingSystem__Win32ProcessHandle_struct *)(handle))->pid = __mkSmallInteger(lppiProcInfo.dwProcessId);
-RETURN (handle);
+		RETURN (handle);
-}
+	    }
 #ifdef PROCESSDEBUGWIN32
-console_fprintf(stderr, "created process error %d\n", GetLastError());
+	    console_fprintf(stderr, "created process error %d\n", GetLastError());
 #endif
-RETURN (nil);
+	    RETURN (nil);
-} else {
+	} else {
-; /* should never be called that way */
+	    ; /* should never be called that way */
-}
+	}
 }
 %}.
 "
 path-argument not string
 or argArray not an array/nil
 |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.
 "low level close of a filedescriptor"
 %{
 if (__isExternalAddressLike(anIntegerOrHandle) ) {
 if( !CloseHandle( anIntegerOrHandle ) ) {
-console_fprintf( stderr, "Win32OS [warning]: Could not close handle : %x\n", anIntegerOrHandle);
+	   console_fprintf( stderr, "Win32OS [warning]: Could not close handle : %x\n", anIntegerOrHandle);
 }
 RETURN(self);
 }
 if (__isSmallInteger(anIntegerOrHandle)) {
-close(__intVal(anIntegerOrHandle));
+	close(__intVal(anIntegerOrHandle));
-RETURN(self);
+	RETURN(self);
 }
 %}.
 ^ self primitiveFailed.
 !
 (self isDirectory:aPathName) ifTrue:[^ true].
 %{
 if (__isString(aPathName)) {
-int ret;
+	int ret;
-SECURITY_ATTRIBUTES sa;
+	SECURITY_ATTRIBUTES sa;
-sa.nLength = sizeof( sa );
+	sa.nLength = sizeof( sa );
-sa.lpSecurityDescriptor = NULL;
+	sa.lpSecurityDescriptor = NULL;
-sa.bInheritHandle = TRUE;
+	sa.bInheritHandle = TRUE;
-ret = CreateDirectory(__stringVal(aPathName), &sa);
+	ret = CreateDirectory(__stringVal(aPathName), &sa);
-if (ret != TRUE) {
+	if (ret != TRUE) {
-__threadErrno = __WIN32_ERR(GetLastError());
+	    __threadErrno = __WIN32_ERR(GetLastError());
-@global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
+	    @global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
-RETURN (false);
+	    RETURN (false);
-}
+	}
-RETURN (true);
+	RETURN (true);
 }
 %}.
 self primitiveFailed
 "
 WIN32_FIND_DATA wfd;
 char szGotPath[MAX_PATH];
 IPersistFile *ppf;
 if (! __isString(aPathName)) {
-console_fprintf(stderr, "invalid argument\n");
+	console_fprintf(stderr, "invalid argument\n");
-goto error;
+	goto error;
 }
 hres = CoInitialize(NULL);
 if (! SUCCEEDED(hres)) {
-console_fprintf(stderr, "Could not open the COM library\n");
+	console_fprintf(stderr, "Could not open the COM library\n");
-goto error;
+	goto error;
 }
 hres = CoCreateInstance(&CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
-&IID_IShellLink, (LPVOID *)&psl);
+			    &IID_IShellLink, (LPVOID *)&psl);
 if (SUCCEEDED(hres)) {
-hres = psl->lpVtbl->QueryInterface(psl, &IID_IPersistFile, &ppf);
+	hres = psl->lpVtbl->QueryInterface(psl, &IID_IPersistFile, &ppf);
-if (SUCCEEDED(hres)) {
+	if (SUCCEEDED(hres)) {
-WORD wsz[MAX_PATH];
+	    WORD wsz[MAX_PATH];
-MultiByteToWideChar(CP_ACP, 0, __stringVal(aPathName), -1, wsz, MAX_PATH);
+	    MultiByteToWideChar(CP_ACP, 0, __stringVal(aPathName), -1, wsz, MAX_PATH);
-hres = ppf->lpVtbl->Load(ppf, wsz, STGM_READ);
+	    hres = ppf->lpVtbl->Load(ppf, wsz, STGM_READ);
-if (SUCCEEDED(hres)) {
+	    if (SUCCEEDED(hres)) {
 #if 0
-hres = psl->lpVtbl->Resolve(psl, 0, SLR_ANY_MATCH|SLR_NO_UI);
+		hres = psl->lpVtbl->Resolve(psl, 0, SLR_ANY_MATCH|SLR_NO_UI);
 #endif
-if (SUCCEEDED(hres)) {
+		if (SUCCEEDED(hres)) {
-hres = psl->lpVtbl->GetPath(psl, szGotPath, MAX_PATH,
+		    hres = psl->lpVtbl->GetPath(psl, szGotPath, MAX_PATH,
-(WIN32_FIND_DATA *)&wfd, 0 /* SLGP_SHORTPATH */ );
+				(WIN32_FIND_DATA *)&wfd, 0 /* SLGP_SHORTPATH */ );
-if (!SUCCEEDED(hres)) {
+		    if (!SUCCEEDED(hres)) {
-console_fprintf(stderr, "GetPath failed!\n");
+			console_fprintf(stderr, "GetPath failed!\n");
-} else {
+		    } else {
 #if 0
-console_printf("This points to %s\n", wfd.cFileName); console_fflush(stdout);
+			console_printf("This points to %s\n", wfd.cFileName); console_fflush(stdout);
-console_printf("Path is %s\n", szGotPath); console_fflush(stdout);
+			console_printf("Path is %s\n", szGotPath); console_fflush(stdout);
-if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
+			if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
-console_printf("This is a directory\n"); console_fflush(stdout);
+			    console_printf("This is a directory\n"); console_fflush(stdout);
-}
+			}
 #endif
-resolvedPath = __MKSTRING(szGotPath);
+			resolvedPath = __MKSTRING(szGotPath);
 #if 0
-hres = psl->lpVtbl->GetWorkingDirectory(psl, szGotPath, MAX_PATH);
+			hres = psl->lpVtbl->GetWorkingDirectory(psl, szGotPath, MAX_PATH);
-if (!SUCCEEDED(hres)) {
+			if (!SUCCEEDED(hres)) {
-console_fprintf(stderr, "GetWorkingDirectory failed!\n");
+			    console_fprintf(stderr, "GetWorkingDirectory failed!\n");
-} else {
+			} else {
-console_printf("In Directory %s\n", szGotPath);
+			    console_printf("In Directory %s\n", szGotPath);
-}
+			}
 #endif
-}
+		    }
-}
+		}
-} else {
+	    } else {
-console_fprintf(stderr, "IPersistFile Load Error\n");
+	       console_fprintf(stderr, "IPersistFile Load Error\n");
-}
+	    }
-ppf->lpVtbl->Release(ppf);
+	    ppf->lpVtbl->Release(ppf);
-} else {
+	} else {
-console_fprintf(stderr, "QueryInterface Error\n");
+	    console_fprintf(stderr, "QueryInterface Error\n");
-}
+	}
-psl->lpVtbl->Release(psl);
+	psl->lpVtbl->Release(psl);
 } else {
-console_fprintf(stderr, "CoCreateInstance Error - hres = %08x\n", hres);
+	console_fprintf(stderr, "CoCreateInstance Error - hres = %08x\n", hres);
 }
 error: ;
 %}.
 resolvedPath notNil ifTrue:[^ resolvedPath ].
 linkFile:oldPath to:newPath
 "link the file 'oldPath' to 'newPath'. The link will be a hard link.
 Return true if successful, false if not."
 (oldPath isString not or:[newPath isString not]) ifTrue:[
-"/
+	"/
-"/ bad argument(s) given
+	"/ bad argument(s) given
-"/
+	"/
-^ self primitiveFailed
+	^ self primitiveFailed
 ].
 "/
 "/ this OperatingSystem does not support links
 "/
 int numAttrib = __arraySize(attributeSpec);
 int i;
 DWORD access, share, create, attr;
 if (! __isString(pathName)) {
-fileHandle = nil;
+	fileHandle = nil;
-argumentError = @symbol(badPathName);
+	argumentError = @symbol(badPathName);
-goto badArgument;
+	goto badArgument;
 }
 if (! __isArrayLike(attributeSpec)) {
-fileHandle = nil;
+	fileHandle = nil;
-argumentError = @symbol(badAttributeSpec);
+	argumentError = @symbol(badAttributeSpec);
-goto badArgument;
+	goto badArgument;
 }
 name = __stringVal(pathName);
 share = 0;
 access = 0;
 create = 0;
 attr = 0;
 for (i=0; i<numAttrib;i++) {
-OBJ attrSym = ap[i];
+	OBJ attrSym = ap[i];
-if (attrSym == @symbol(FILE_SHARE_READ)) {
+	if (attrSym == @symbol(FILE_SHARE_READ)) {
-share |= FILE_SHARE_READ;
+	    share |= FILE_SHARE_READ;
-} else if (attrSym == @symbol(FILE_SHARE_WRITE)) {
+	} else if (attrSym == @symbol(FILE_SHARE_WRITE)) {
-share |= FILE_SHARE_WRITE;
+	    share |= FILE_SHARE_WRITE;
-} else if (attrSym == @symbol(GENERIC_READ)) {
+	} else if (attrSym == @symbol(GENERIC_READ)) {
-access |= GENERIC_READ;
+	    access |= GENERIC_READ;
-} else if (attrSym == @symbol(GENERIC_WRITE)) {
+	} else if (attrSym == @symbol(GENERIC_WRITE)) {
-access |= GENERIC_WRITE;
+	    access |= GENERIC_WRITE;
-} else if (attrSym == @symbol(CREATE_NEW)) {
+	} else if (attrSym == @symbol(CREATE_NEW)) {
-create |= CREATE_NEW;
+	    create |= CREATE_NEW;
-} else if (attrSym == @symbol(CREATE_ALWAYS)) {
+	} else if (attrSym == @symbol(CREATE_ALWAYS)) {
-create |= CREATE_ALWAYS;
+	    create |= CREATE_ALWAYS;
-} else if (attrSym == @symbol(OPEN_EXISTING)) {
+	} else if (attrSym == @symbol(OPEN_EXISTING)) {
-create |= OPEN_EXISTING;
+	    create |= OPEN_EXISTING;
-} else if (attrSym == @symbol(OPEN_ALWAYS)) {
+	} else if (attrSym == @symbol(OPEN_ALWAYS)) {
-create |= OPEN_ALWAYS;
+	    create |= OPEN_ALWAYS;
-} else if (attrSym == @symbol(TRUNCATE_EXISTING)) {
+	} else if (attrSym == @symbol(TRUNCATE_EXISTING)) {
-create |= TRUNCATE_EXISTING;
+	    create |= TRUNCATE_EXISTING;
-} else if (attrSym == @symbol(FILE_ATTRIBUTE_HIDDEN)) {
+	} else if (attrSym == @symbol(FILE_ATTRIBUTE_HIDDEN)) {
-attr |= FILE_ATTRIBUTE_HIDDEN;
+	    attr |= FILE_ATTRIBUTE_HIDDEN;
-} else if (attrSym == @symbol(FILE_ATTRIBUTE_READONLY)) {
+	} else if (attrSym == @symbol(FILE_ATTRIBUTE_READONLY)) {
-attr |= FILE_ATTRIBUTE_READONLY;
+	    attr |= FILE_ATTRIBUTE_READONLY;
-} else if (attrSym == @symbol(FILE_ATTRIBUTE_READONLY)) {
+	} else if (attrSym == @symbol(FILE_ATTRIBUTE_READONLY)) {
-attr |= FILE_ATTRIBUTE_READONLY;
+	    attr |= FILE_ATTRIBUTE_READONLY;
-} else if (attrSym == @symbol(FILE_FLAG_WRITE_THROUGH)) {
+	} else if (attrSym == @symbol(FILE_FLAG_WRITE_THROUGH)) {
-attr |= FILE_FLAG_WRITE_THROUGH;
+	    attr |= FILE_FLAG_WRITE_THROUGH;
-} else if (attrSym == @symbol(FILE_FLAG_SEQUENTIAL_SCAN)) {
+	} else if (attrSym == @symbol(FILE_FLAG_SEQUENTIAL_SCAN)) {
-attr |= FILE_FLAG_SEQUENTIAL_SCAN;
+	    attr |= FILE_FLAG_SEQUENTIAL_SCAN;
-} else if (attrSym == @symbol(FILE_FLAG_DELETE_ON_CLOSE)) {
+	} else if (attrSym == @symbol(FILE_FLAG_DELETE_ON_CLOSE)) {
-attr |= FILE_FLAG_DELETE_ON_CLOSE;
+	    attr |= FILE_FLAG_DELETE_ON_CLOSE;
-} else {
+	} else {
-console_fprintf(stderr, "Win32OS [warning]: unsupported open mode\n");
+	    console_fprintf(stderr, "Win32OS [warning]: unsupported open mode\n");
-}
+	}
 }
 if (create == 0) {
-fileHandle = nil;
+	fileHandle = nil;
-argumentError = @symbol(missingCreateMode);
+	argumentError = @symbol(missingCreateMode);
-goto badArgument;
+	goto badArgument;
 }
 #ifdef PROCESSDEBUGWIN32
 console_fprintf(stderr, "name:<%s> access:%x share:%x create:%x attr:%x\n",
-name, access, share, create, attr);
+		name, access, share, create, attr);
 #endif
 h = CreateFile(name, access, share, 0 /* sa */, create, attr, 0 /* hTempl */);
 if (h != INVALID_HANDLE_VALUE) {
-__externalAddressVal(fileHandle) = (void *)h;
+	__externalAddressVal(fileHandle) = (void *)h;
 } else {
-fileHandle = nil;
+	fileHandle = nil;
-errorNumber = __mkSmallInteger( __WIN32_ERR(GetLastError()) );
+	errorNumber = __mkSmallInteger( __WIN32_ERR(GetLastError()) );
 }
 badArgument: ;
 %}.
 fileHandle notNil ifTrue:[
-fileHandle registerForFinalization.
+	fileHandle registerForFinalization.
-^ fileHandle.
+	^ fileHandle.
 ].
 errorNumber isNil ifTrue:[
-self error:'invalid argument(s): ', argumentError.
+	self error:'invalid argument(s): ', argumentError.
 ] ifFalse:[
-(self errorHolderForNumber:errorNumber) reportError
+	(self errorHolderForNumber:errorNumber) reportError
 ].
 !
 openFileForAppend:pathName
 "noone sends this message yet"
 %{
 int ret;
 if (__isString(fullPathName)) {
 #ifdef DO_WRAP_CALLS
-{
+	{
-char _aPathName[MAXPATHLEN];
+	    char _aPathName[MAXPATHLEN];
-strncpy(_aPathName, __stringVal(fullPathName), MAXPATHLEN-1); _aPathName[MAXPATHLEN-1] = '\0';
+	    strncpy(_aPathName, __stringVal(fullPathName), MAXPATHLEN-1); _aPathName[MAXPATHLEN-1] = '\0';
-do {
+	    do {
-__threadErrno = 0;
+		__threadErrno = 0;
-ret = STX_API_CALL1( "RemoveDirectory", RemoveDirectory, _aPathName);
+		ret = STX_API_CALL1( "RemoveDirectory", RemoveDirectory, _aPathName);
-} while ((ret < 0) && (__threadErrno == EINTR));
+	    } while ((ret < 0) && (__threadErrno == EINTR));
-}
+	}
 #else
-ret = RemoveDirectory((char *)__stringVal(fullPathName));
+	ret = RemoveDirectory((char *)__stringVal(fullPathName));
-__threadErrno = __WIN32_ERR(GetLastError());
+	__threadErrno = __WIN32_ERR(GetLastError());
 #endif
-if (ret != TRUE) {
+	if (ret != TRUE) {
-@global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
+	    @global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
-RETURN (false);
+	    RETURN (false);
-}
+	}
-RETURN (true);
+	RETURN (true);
 }
 %}.
 "/
 "/ either not a string argument,
 "/ or not supported by OS
 %{
 int ret;
 if (__isString(fullPathName)) {
 #ifdef DO_WRAP_CALLS
-{
+	{
-char _aPathName[MAXPATHLEN];
+	    char _aPathName[MAXPATHLEN];
-strncpy(_aPathName, __stringVal(fullPathName), MAXPATHLEN-1); _aPathName[MAXPATHLEN-1] = '\0';
+	    strncpy(_aPathName, __stringVal(fullPathName), MAXPATHLEN-1); _aPathName[MAXPATHLEN-1] = '\0';
-do {
+	    do {
-__threadErrno = 0;
+		__threadErrno = 0;
-ret = STX_API_CALL1( "DeleteFile", DeleteFile, _aPathName);
+		ret = STX_API_CALL1( "DeleteFile", DeleteFile, _aPathName);
-} while ((ret < 0) && (__threadErrno == EINTR));
+	    } while ((ret < 0) && (__threadErrno == EINTR));
-}
+	}
 #else
-ret = DeleteFile((char *)__stringVal(fullPathName));
+	ret = DeleteFile((char *)__stringVal(fullPathName));
-__threadErrno = __WIN32_ERR(GetLastError());
+	__threadErrno = __WIN32_ERR(GetLastError());
 #endif
-if (ret != TRUE) {
+	if (ret != TRUE) {
-@global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
+	    @global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
-RETURN (false);
+	    RETURN (false);
-}
+	}
-RETURN (true);
+	RETURN (true);
 }
 %}.
 ^ self primitiveFailed
 !
 %{
 int ret, eno;
 if (__isString(oldPath) && __isString(newPath)) {
 #ifdef DO_WRAP_CALLS
-char _oldPath[MAXPATHLEN], _newPath[MAXPATHLEN];
+	char _oldPath[MAXPATHLEN], _newPath[MAXPATHLEN];
-strncpy(_oldPath, __stringVal(oldPath), MAXPATHLEN-1); _oldPath[MAXPATHLEN-1] = '\0';
+	strncpy(_oldPath, __stringVal(oldPath), MAXPATHLEN-1); _oldPath[MAXPATHLEN-1] = '\0';
-strncpy(_newPath, __stringVal(newPath), MAXPATHLEN-1); _newPath[MAXPATHLEN-1] = '\0';
+	strncpy(_newPath, __stringVal(newPath), MAXPATHLEN-1); _newPath[MAXPATHLEN-1] = '\0';
-do {
+	do {
-__threadErrno = 0;
+	    __threadErrno = 0;
-ret = STX_C_CALL2( "rename", rename, _oldPath, _newPath);
+	    ret = STX_C_CALL2( "rename", rename, _oldPath, _newPath);
-} while ((ret < 0) && (__threadErrno == EINTR));
+	} while ((ret < 0) && (__threadErrno == EINTR));
 #else
-__BEGIN_INTERRUPTABLE__
+	__BEGIN_INTERRUPTABLE__
-do {
+	do {
-__threadErrno = 0;
+	    __threadErrno = 0;
-ret = rename((char *) __stringVal(oldPath), (char *) __stringVal(newPath));
+	    ret = rename((char *) __stringVal(oldPath), (char *) __stringVal(newPath));
-} while ((ret < 0) && (__threadErrno == EINTR));
+	} while ((ret < 0) && (__threadErrno == EINTR));
-__END_INTERRUPTABLE__
+	__END_INTERRUPTABLE__
-if (ret < 0) {
+	if (ret < 0) {
-__threadErrno = __WIN32_ERR(GetLastError());
+	    __threadErrno = __WIN32_ERR(GetLastError());
-}
+	}
 #endif
-if (ret < 0) {
+	if (ret < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
+	    @global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
-RETURN (false);
+	    RETURN (false);
-}
+	}
-RETURN (true);
+	RETURN (true);
 }
 %}.
 ^ self primitiveFailed
 "
 #   ifndef S_IXOTH
 #    define S_IXOTH 0001
 #   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) );
 }
 %}.
 ^ 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
 "
 %{
 struct stat buf;
 int ret;
 if (__isString(aPathName)) {
 #ifdef DO_WRAP_CALLS
-char _aPathName[MAXPATHLEN];
+	char _aPathName[MAXPATHLEN];
-strncpy(_aPathName, __stringVal(aPathName), MAXPATHLEN-1); _aPathName[MAXPATHLEN-1] = '\0';
+	strncpy(_aPathName, __stringVal(aPathName), MAXPATHLEN-1); _aPathName[MAXPATHLEN-1] = '\0';
-do {
+	do {
-__threadErrno = 0;
+	    __threadErrno = 0;
-ret = STX_C_CALL2( "stat", stat, _aPathName, &buf);
+	    ret = STX_C_CALL2( "stat", stat, _aPathName, &buf);
-} while ((ret < 0) && (__threadErrno == EINTR));
+	} while ((ret < 0) && (__threadErrno == EINTR));
 #else
-__BEGIN_INTERRUPTABLE__
+	__BEGIN_INTERRUPTABLE__
-do {
+	do {
-__threadErrno = 0;
+	    __threadErrno = 0;
-ret = stat( (char *)__stringVal(aPathName), &buf);
+	    ret = stat( (char *)__stringVal(aPathName), &buf);
-} while ((ret < 0) && (__threadErrno == EINTR));
+	} while ((ret < 0) && (__threadErrno == EINTR));
-__END_INTERRUPTABLE__
+	__END_INTERRUPTABLE__
-if (ret < 0) {
+	if (ret < 0) {
-__threadErrno = __WIN32_ERR(GetLastError());
+	    __threadErrno = __WIN32_ERR(GetLastError());
-}
+	}
 #endif
-if (ret < 0) {
+	if (ret < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
+	    @global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
-RETURN ( nil );
+	    RETURN ( nil );
-}
+	}
-RETURN ( __mkSmallInteger(buf.st_mode & 0777) );
+	RETURN ( __mkSmallInteger(buf.st_mode & 0777) );
 }
 %}.
 ^ self primitiveFailed
 "
 %{
 int ret;
 if (__isString(aPathName) && __isSmallInteger(modeBits)) {
 #ifdef DO_WRAP_CALLS
-int chmod();
+	int chmod();
-char _aPathName[MAXPATHLEN];
+	char _aPathName[MAXPATHLEN];
-strncpy(_aPathName, __stringVal(aPathName), MAXPATHLEN-1); _aPathName[MAXPATHLEN-1] = '\0';
+	strncpy(_aPathName, __stringVal(aPathName), MAXPATHLEN-1); _aPathName[MAXPATHLEN-1] = '\0';
-do {
+	do {
-__threadErrno = 0;
+	    __threadErrno = 0;
-ret = STX_C_CALL2( "chmod", chmod, _aPathName, __intVal(modeBits));
+	    ret = STX_C_CALL2( "chmod", chmod, _aPathName, __intVal(modeBits));
-} while ((ret < 0) && (__threadErrno == EINTR));
+	} while ((ret < 0) && (__threadErrno == EINTR));
 #else
-__BEGIN_INTERRUPTABLE__
+	__BEGIN_INTERRUPTABLE__
-do {
+	do {
-__threadErrno = 0;
+	    __threadErrno = 0;
-ret = chmod((char *)__stringVal(aPathName), __intVal(modeBits));
+	    ret = chmod((char *)__stringVal(aPathName), __intVal(modeBits));
-} while ((ret < 0) && (__threadErrno == EINTR));
+	} while ((ret < 0) && (__threadErrno == EINTR));
-__END_INTERRUPTABLE__
+	__END_INTERRUPTABLE__
-if (ret < 0) {
+	if (ret < 0) {
-__threadErrno = __WIN32_ERR(GetLastError());
+	    __threadErrno = __WIN32_ERR(GetLastError());
-}
+	}
 #endif
-if (ret < 0) {
+	if (ret < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
+	    @global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
-RETURN ( false );
+	    RETURN ( false );
-}
+	}
-RETURN ( true );
+	RETURN ( true );
 }
 %}.
 ^ self primitiveFailed
 "
 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\..'
 ^ $\
 !
 getDiskInfoOf:volumeNameArg
 "returns a dictionary filled with any of:
-freeBytes
+	freeBytes
-totalBytes
+	totalBytes
 and possibly additional (OS-specific) information"
 |volumeName info ok sectorsPerCluster bytesPerSector freeClusters totalClusters
 type freeBytesForUsersQuota freeBytes totalBytes |
 volumeName := volumeNameArg.
 (volumeName endsWith:$\) ifFalse:[
-volumeName := volumeName , '\'
+	volumeName := volumeName , '\'
 ].
 %{
 typedef BOOL (WINAPI *P_GDFSE)(LPCTSTR, PULARGE_INTEGER,
-PULARGE_INTEGER, PULARGE_INTEGER);
+				   PULARGE_INTEGER, PULARGE_INTEGER);
 P_GDFSE pGetDiskFreeSpaceEx = NULL;
 DWORD __sectorsPerCluster, __bytesPerSector, __freeClusters, __totalClusters;
 BOOL  fResult = 0;
 unsigned __int64 i64FreeBytesForUsersQuota, i64TotalBytes, i64FreeBytes;
 if (__isString(volumeName) || __isSymbol(volumeName)) {
-/*
+	 /*
-*  Use GetDiskFreeSpaceEx if available; otherwise, use GetDiskFreeSpace.
+	  *  Use GetDiskFreeSpaceEx if available; otherwise, use GetDiskFreeSpace.
-*  Notice that GetDiskFreeSpace does not work correctly under win2k,
+	  *  Notice that GetDiskFreeSpace does not work correctly under win2k,
-*  and GetDiskFreeSpaceEx is not avail. for all win versions (can microsoft ever do something right ?).
+	  *  and GetDiskFreeSpaceEx is not avail. for all win versions (can microsoft ever do something right ?).
-*/
+	  */
-pGetDiskFreeSpaceEx = (P_GDFSE)GetProcAddress (
+	pGetDiskFreeSpaceEx = (P_GDFSE)GetProcAddress (
-GetModuleHandle ("kernel32.dll"),
+					    GetModuleHandle ("kernel32.dll"),
-"GetDiskFreeSpaceExA");
+							     "GetDiskFreeSpaceExA");
-if (pGetDiskFreeSpaceEx) {
+	if (pGetDiskFreeSpaceEx) {
-fResult = pGetDiskFreeSpaceEx (__stringVal(volumeName),
+	    fResult = pGetDiskFreeSpaceEx (__stringVal(volumeName),
-(PULARGE_INTEGER)&i64FreeBytesForUsersQuota,
+				 (PULARGE_INTEGER)&i64FreeBytesForUsersQuota,
-(PULARGE_INTEGER)&i64TotalBytes,
+				 (PULARGE_INTEGER)&i64TotalBytes,
-(PULARGE_INTEGER)&i64FreeBytes);
+				 (PULARGE_INTEGER)&i64FreeBytes);
-if (fResult) {
+	    if (fResult) {
-freeBytesForUsersQuota = __MKUINT64(&i64FreeBytesForUsersQuota);
+		freeBytesForUsersQuota = __MKUINT64(&i64FreeBytesForUsersQuota);
-totalBytes = __MKUINT64(&i64TotalBytes);
+		totalBytes = __MKUINT64(&i64TotalBytes);
-freeBytes = __MKUINT64(&i64FreeBytes);
+		freeBytes = __MKUINT64(&i64FreeBytes);
-}
+	    }
-}
+	}
-fResult = GetDiskFreeSpace(__stringVal(volumeName),
+	fResult = GetDiskFreeSpace(__stringVal(volumeName),
-&__sectorsPerCluster,
+			     &__sectorsPerCluster,
-&__bytesPerSector,
+			     &__bytesPerSector,
-&__freeClusters,
+			     &__freeClusters,
-&__totalClusters);
+			     &__totalClusters);
-if (fResult) {
+	if (fResult) {
-sectorsPerCluster = __MKUINT(__sectorsPerCluster);
+	    sectorsPerCluster = __MKUINT(__sectorsPerCluster);
-bytesPerSector = __MKUINT(__bytesPerSector);
+	    bytesPerSector = __MKUINT(__bytesPerSector);
-freeClusters = __MKUINT(__freeClusters);
+	    freeClusters = __MKUINT(__freeClusters);
-totalClusters = __MKUINT(__totalClusters);
+	    totalClusters = __MKUINT(__totalClusters);
-}
+	}
-switch (GetDriveType(__stringVal(volumeName))) {
+	switch (GetDriveType(__stringVal(volumeName))) {
-case DRIVE_REMOVABLE:
+	    case DRIVE_REMOVABLE:
-type = @symbol(removable); break;
+		type = @symbol(removable); break;
-case DRIVE_FIXED:
+	    case DRIVE_FIXED:
-type = @symbol(fixed); break;
+		type = @symbol(fixed); break;
-case DRIVE_REMOTE:
+	    case DRIVE_REMOTE:
-type = @symbol(network); break;
+		type = @symbol(network); break;
-case DRIVE_CDROM:
+	    case DRIVE_CDROM:
-type = @symbol(cdrom); break;
+		type = @symbol(cdrom); break;
-case DRIVE_RAMDISK:
+	    case DRIVE_RAMDISK:
-type = @symbol(ramdisk); break;
+		type = @symbol(ramdisk); break;
-case DRIVE_UNKNOWN:
+	    case DRIVE_UNKNOWN:
-default:
+	    default:
-break;
+		break;
-}
+	}
-if (fResult) {
+	if (fResult) {
-ok = true;
+	    ok = true;
-} else {
+	} else {
-__threadErrno = __WIN32_ERR(GetLastError());
+	    __threadErrno = __WIN32_ERR(GetLastError());
-@global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
+	    @global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
-}
+	}
 }
 %}.
 ok == true ifFalse:[
-self primitiveFailed.
+	self primitiveFailed.
-^ self
+	^ self
 ].
 info := IdentityDictionary new.
 info at:#sectorsPerCluster put:sectorsPerCluster.
 info at:#bytesPerSector put:bytesPerSector.
 info at:#freeClusters put:freeClusters.
 info at:#totalClusters put:totalClusters.
 info at:#freeBytes put:(freeBytes notNil
-ifTrue:[freeBytes]
+				ifTrue:[freeBytes]
-ifFalse:[freeClusters * sectorsPerCluster * bytesPerSector]).
+				ifFalse:[freeClusters * sectorsPerCluster * bytesPerSector]).
 info at:#totalBytes put:(totalBytes notNil
-ifTrue:[totalBytes]
+				ifTrue:[totalBytes]
-ifFalse:[totalClusters * sectorsPerCluster * bytesPerSector]).
+				ifFalse:[totalClusters * sectorsPerCluster * bytesPerSector]).
 info at:#freeBytesForUsersQuota put:freeBytesForUsersQuota.
 type notNil ifTrue:[
-info at:#type put:type
+	info at:#type put:type
 ].
 ^ info
 "
 self getDiskInfoOf:'c:\'
 %{
 int sz;
 DWORD dummy;
 if (__isString(aPathName)) {
-sz = GetFileVersionInfoSizeA(__stringVal(aPathName), &dummy);
+	sz = GetFileVersionInfoSizeA(__stringVal(aPathName), &dummy);
 } else if (__isUnicode16String(aPathName)) {
-sz = GetFileVersionInfoSizeW(__unicode16StringVal(aPathName), &dummy);
+	sz = GetFileVersionInfoSizeW(__unicode16StringVal(aPathName), &dummy);
 } else {
-goto badArgument;
+	goto badArgument;
 }
 if (sz > 0) {
-OBJ versionData;
+	OBJ versionData;
-versionData = __BYTEARRAY_UNINITIALIZED_NEW_INT(sz);
+	versionData = __BYTEARRAY_UNINITIALIZED_NEW_INT(sz);
-if (versionData == nil) {
+	if (versionData == nil) {
-RETURN (nil);
+	    RETURN (nil);
-}
+	}
-if (GetFileVersionInfo(__stringVal(aPathName), 0, sz, __ByteArrayInstPtr(versionData)->ba_element) == FALSE) {
+	if (GetFileVersionInfo(__stringVal(aPathName), 0, sz, __ByteArrayInstPtr(versionData)->ba_element) == FALSE) {
-RETURN (nil);
+	    RETURN (nil);
-}
+	}
-RETURN (versionData);
+	RETURN (versionData);
 }
 RETURN (nil);
 badArgument: ;
 %}.
 self primitiveFailed
 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
 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),
 |info target|
 info := self linkInfoOf:aPathName.
 (info notNil and:[info isSymbolicLink]) ifTrue:[
-target := info path.
+	target := info path.
-target notNil ifTrue:[
+	target notNil ifTrue:[
-^ self linkInfoOf:target.
+	    ^ self linkInfoOf:target.
-]
+	]
 ].
 ^ info
 "
 OperatingSystem infoOf:'c:\windows'
 This also returns true for symbolic links pointing to a directory;
 if you need to check for this, use #linkInfo:."
 %{
 if (__isString(aPathName)) {
-int ret;
+	int ret;
 #ifdef DO_WRAP_CALLS
-char _aPathName[MAXPATHLEN];
+	char _aPathName[MAXPATHLEN];
-strncpy(_aPathName, __stringVal(aPathName), MAXPATHLEN-1); _aPathName[MAXPATHLEN-1] = '\0';
+	strncpy(_aPathName, __stringVal(aPathName), MAXPATHLEN-1); _aPathName[MAXPATHLEN-1] = '\0';
-do {
+	do {
-__threadErrno = 0;
+	    __threadErrno = 0;
-ret = STX_API_CALL1( "GetFileAttributesA", GetFileAttributesA, _aPathName);
+	    ret = STX_API_CALL1( "GetFileAttributesA", GetFileAttributesA, _aPathName);
-} while ((ret < 0) && (__threadErrno == EINTR));
+	} while ((ret < 0) && (__threadErrno == EINTR));
 #else
-ret = GetFileAttributesA((char *) __stringVal(aPathName));
+	ret = GetFileAttributesA((char *) __stringVal(aPathName));
-if (ret < 0) {
+	if (ret < 0) {
-__threadErrno = __WIN32_ERR(GetLastError());
+	    __threadErrno = __WIN32_ERR(GetLastError());
-}
+	}
 #endif
-if (ret < 0) {
+	if (ret < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
+	    @global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
-RETURN ( false );
+	    RETURN ( false );
-}
+	}
-RETURN ( (ret & FILE_ATTRIBUTE_DIRECTORY) ? true : false);
+	RETURN ( (ret & FILE_ATTRIBUTE_DIRECTORY) ? true : false);
 }
 #ifdef SUPPORT_WIDE_CHAR_FILENAMES
 if (__isUnicode16String(aPathName)) {
-int ret;
+	int ret;
 #ifdef DO_WRAP_CALLS
-unsigned char _wPathName[MAXPATHLEN];
+	unsigned char _wPathName[MAXPATHLEN];
-int i;
+	int i;
 # if 1
-for (i=0; i<MAXPATHLEN; i++) {
+	for (i=0; i<MAXPATHLEN; i++) {
-_wPathName[i] = __unicode16StringVal(aPathName)[i];
+	    _wPathName[i] = __unicode16StringVal(aPathName)[i];
-if (_wPathName[i] == 0) break;
+	    if (_wPathName[i] == 0) break;
-}
+	}
 # else
-wstrncpy(_wPathName, __unicode16StringVal(aPathName), MAXPATHLEN-1); _wPathName[MAXPATHLEN-1] = '\0';
+	wstrncpy(_wPathName, __unicode16StringVal(aPathName), MAXPATHLEN-1); _wPathName[MAXPATHLEN-1] = '\0';
 # endif
-do {
+	do {
-__threadErrno = 0;
+	    __threadErrno = 0;
-ret = STX_API_CALL1( "GetFileAttributesW", GetFileAttributesW, _wPathName);
+	    ret = STX_API_CALL1( "GetFileAttributesW", GetFileAttributesW, _wPathName);
-} while ((ret < 0) && (__threadErrno == EINTR));
+	} while ((ret < 0) && (__threadErrno == EINTR));
 #else
-ret = GetFileAttributesW(__unicode16StringVal(wPathName));
+	ret = GetFileAttributesW(__unicode16StringVal(wPathName));
-if (ret < 0) {
+	if (ret < 0) {
-__threadErrno = __WIN32_ERR(GetLastError());
+	    __threadErrno = __WIN32_ERR(GetLastError());
-}
+	}
 #endif
-if (ret < 0) {
+	if (ret < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
+	    @global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
-RETURN ( false );
+	    RETURN ( false );
-}
+	}
-RETURN ( (ret & FILE_ATTRIBUTE_DIRECTORY) ? true : false);
+	RETURN ( (ret & FILE_ATTRIBUTE_DIRECTORY) ? true : false);
 }
 #endif /* SUPPORT_WIDE_CHAR_FILENAMES */
 %}.
 ^ self primitiveFailed
 "an alternative implementation would be:
-^ (self infoOf:aPathName) type == #directory
+	^ (self infoOf:aPathName) type == #directory
 "
 "Modified: / 05-07-2006 / 17:23:42 / cg"
 !
 %{
 int ret;
 if (__isString(aPathName)) {
 #ifdef DO_WRAP_CALLS
-char _aPathName[MAXPATHLEN];
+	char _aPathName[MAXPATHLEN];
-strncpy(_aPathName, __stringVal(aPathName), MAXPATHLEN-1); _aPathName[MAXPATHLEN-1] = '\0';
+	strncpy(_aPathName, __stringVal(aPathName), MAXPATHLEN-1); _aPathName[MAXPATHLEN-1] = '\0';
-do {
+	do {
-__threadErrno = 0;
+	    __threadErrno = 0;
-ret = STX_API_CALL1( "GetFileAttributes", GetFileAttributes, _aPathName);
+	    ret = STX_API_CALL1( "GetFileAttributes", GetFileAttributes, _aPathName);
-} while ((ret < 0) && (__threadErrno == EINTR));
+	} while ((ret < 0) && (__threadErrno == EINTR));
 #else
-ret = GetFileAttributes((char *) __stringVal(aPathName));
+	ret = GetFileAttributes((char *) __stringVal(aPathName));
-if (ret < 0) {
+	if (ret < 0) {
-__threadErrno = __WIN32_ERR(GetLastError());
+	    __threadErrno = __WIN32_ERR(GetLastError());
-}
+	}
 #endif
-if (ret < 0) {
+	if (ret < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
+	    @global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
-RETURN ( false );
+	    RETURN ( false );
-}
+	}
-RETURN ( (ret & FILE_ATTRIBUTE_HIDDEN) ? true : false);
+	RETURN ( (ret & FILE_ATTRIBUTE_HIDDEN) ? true : false);
 }
 %}.
 ^ self primitiveFailed
 !
 "return true, if the file/dir 'aPathName' is readable.
 For symbolic links, the pointed-to-file is checked."
 %{
 if (__isString(aPathName)) {
-int ret;
+	int ret;
-/*
+	/*
-* under windows, all files are readable ...
+	 * under windows, all files are readable ...
-* so, only check for the files existence here.
+	 * so, only check for the files existence here.
-*/
+	 */
 #ifdef DO_WRAP_CALLS
-char _aPathName[MAXPATHLEN];
+	char _aPathName[MAXPATHLEN];
-strncpy(_aPathName, __stringVal(aPathName), MAXPATHLEN-1); _aPathName[MAXPATHLEN-1] = '\0';
+	strncpy(_aPathName, __stringVal(aPathName), MAXPATHLEN-1); _aPathName[MAXPATHLEN-1] = '\0';
-do {
+	do {
-__threadErrno = 0;
+	    __threadErrno = 0;
-ret = STX_API_CALL1( "GetFileAttributesA", GetFileAttributesA, _aPathName);
+	    ret = STX_API_CALL1( "GetFileAttributesA", GetFileAttributesA, _aPathName);
-} while ((ret < 0) && (__threadErrno == EINTR));
+	} while ((ret < 0) && (__threadErrno == EINTR));
 #else
-ret = GetFileAttributesA((char *) __stringVal(aPathName));
+	ret = GetFileAttributesA((char *) __stringVal(aPathName));
-if (ret < 0) {
+	if (ret < 0) {
-__threadErrno = __WIN32_ERR(GetLastError());
+	    __threadErrno = __WIN32_ERR(GetLastError());
-}
+	}
 #endif
-if (ret < 0) {
+	if (ret < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
+	    @global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
-RETURN (false);
+	    RETURN (false);
-}
+	}
-RETURN (true);
+	RETURN (true);
 }
 #ifdef SUPPORT_WIDE_CHAR_FILENAMES
 if (__isUnicode16String(aPathName)) {
-int ret;
+	int ret;
-/*
+	/*
-* under windows, all files are readable ...
+	 * under windows, all files are readable ...
-* so, only check for the files existence here.
+	 * so, only check for the files existence here.
-*/
+	 */
 #ifdef DO_WRAP_CALLS
-unsigned short _wPathName[MAXPATHLEN];
+	unsigned short _wPathName[MAXPATHLEN];
 # if 1
-int i;
+	int i;
-for (i=0; i<MAXPATHLEN; i++) {
+	for (i=0; i<MAXPATHLEN; i++) {
-_wPathName[i] = __unicode16StringVal(aPathName)[i];
+	    _wPathName[i] = __unicode16StringVal(aPathName)[i];
-if (_wPathName[i] == 0) break;
+	    if (_wPathName[i] == 0) break;
-}
+	}
 # else
-wstrncpy(_wPathName, __unicode16StringVal(aPathName), MAXPATHLEN-1); _wPathName[MAXPATHLEN-1] = '\0';
+	wstrncpy(_wPathName, __unicode16StringVal(aPathName), MAXPATHLEN-1); _wPathName[MAXPATHLEN-1] = '\0';
 # endif
-do {
+	do {
-__threadErrno = 0;
+	    __threadErrno = 0;
-ret = STX_API_CALL1( "GetFileAttributesW", GetFileAttributesW, _wPathName);
+	    ret = STX_API_CALL1( "GetFileAttributesW", GetFileAttributesW, _wPathName);
-} while ((ret < 0) && (__threadErrno == EINTR));
+	} while ((ret < 0) && (__threadErrno == EINTR));
 #else
-ret = GetFileAttributesW(__unicode16StringVal(aPathName));
+	ret = GetFileAttributesW(__unicode16StringVal(aPathName));
-if (ret < 0) {
+	if (ret < 0) {
-__threadErrno = __WIN32_ERR(GetLastError());
+	    __threadErrno = __WIN32_ERR(GetLastError());
-}
+	}
 #endif
-if (ret < 0) {
+	if (ret < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
+	    @global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
-RETURN (false);
+	    RETURN (false);
-}
+	}
-RETURN (true);
+	RETURN (true);
 }
 #endif /* SUPPORT_WIDE_CHAR_FILENAMES */
 %}.
 ^ self primitiveFailed
 %{
 int ret;
 if (__isString(aPathName) || __isSymbol(aPathName)) {
 #ifdef DO_WRAP_CALLS
-char _aPathName[MAXPATHLEN];
+	char _aPathName[MAXPATHLEN];
-strncpy(_aPathName, __stringVal(aPathName), MAXPATHLEN-1); _aPathName[MAXPATHLEN-1] = '\0';
+	strncpy(_aPathName, __stringVal(aPathName), MAXPATHLEN-1); _aPathName[MAXPATHLEN-1] = '\0';
-do {
+	do {
-__threadErrno = 0;
+	    __threadErrno = 0;
-ret = STX_API_CALL1( "GetFileAttributesA", GetFileAttributesA, _aPathName);
+	    ret = STX_API_CALL1( "GetFileAttributesA", GetFileAttributesA, _aPathName);
-} while ((ret < 0) && (__threadErrno == EINTR));
+	} while ((ret < 0) && (__threadErrno == EINTR));
 #else
-ret = GetFileAttributesA((char *) __stringVal(aPathName));
+	ret = GetFileAttributesA((char *) __stringVal(aPathName));
-if (ret < 0) {
+	if (ret < 0) {
-__threadErrno = __WIN32_ERR(GetLastError());
+	    __threadErrno = __WIN32_ERR(GetLastError());
-}
+	}
 #endif
-if (ret < 0) {
+	if (ret < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
+	    @global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
-RETURN ( false );
+	    RETURN ( false );
-}
+	}
-RETURN (true);
+	RETURN (true);
 }
 #ifdef SUPPORT_WIDE_CHAR_FILENAMES
 if (__isUnicode16String(aPathName)) {
 #ifdef DO_WRAP_CALLS
-unsigned short _wPathName[MAXPATHLEN];
+	unsigned short _wPathName[MAXPATHLEN];
 # if 1
-int i;
+	int i;
-for (i=0; i<MAXPATHLEN; i++) {
+	for (i=0; i<MAXPATHLEN; i++) {
-_wPathName[i] = __unicode16StringVal(aPathName)[i];
+	    _wPathName[i] = __unicode16StringVal(aPathName)[i];
-if (_wPathName[i] == 0) break;
+	    if (_wPathName[i] == 0) break;
-}
+	}
 # else
-wstrncpy(_wPathName, __unicode16StringVal(aPathName), MAXPATHLEN-1); _wPathName[MAXPATHLEN-1] = '\0';
+	wstrncpy(_wPathName, __unicode16StringVal(aPathName), MAXPATHLEN-1); _wPathName[MAXPATHLEN-1] = '\0';
 # endif
-do {
+	do {
-__threadErrno = 0;
+	    __threadErrno = 0;
-ret = STX_API_CALL1( "GetFileAttributesW", GetFileAttributesW, _wPathName);
+	    ret = STX_API_CALL1( "GetFileAttributesW", GetFileAttributesW, _wPathName);
-} while ((ret < 0) && (__threadErrno == EINTR));
+	} while ((ret < 0) && (__threadErrno == EINTR));
 #else
-ret = GetFileAttributesW(__unicode16StringVal(wPathName));
+	ret = GetFileAttributesW(__unicode16StringVal(wPathName));
-if (ret < 0) {
+	if (ret < 0) {
-__threadErrno = __WIN32_ERR(GetLastError());
+	    __threadErrno = __WIN32_ERR(GetLastError());
-}
+	}
 #endif
-if (ret < 0) {
+	if (ret < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
+	    @global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
-RETURN ( false );
+	    RETURN ( false );
-}
+	}
-RETURN (true);
+	RETURN (true);
 }
 #endif /* SUPPORT_WIDE_CHAR_FILENAMES */
 %}.
 ^ self primitiveFailed
 %{
 int ret;
 if (__isString(aPathName)) {
 #ifdef DO_WRAP_CALLS
-char _aPathName[MAXPATHLEN];
+	char _aPathName[MAXPATHLEN];
-strncpy(_aPathName, __stringVal(aPathName), MAXPATHLEN-1); _aPathName[MAXPATHLEN-1] = '\0';
+	strncpy(_aPathName, __stringVal(aPathName), MAXPATHLEN-1); _aPathName[MAXPATHLEN-1] = '\0';
-do {
+	do {
-__threadErrno = 0;
+	    __threadErrno = 0;
-ret = STX_API_CALL1( "GetFileAttributes", GetFileAttributes, _aPathName);
+	    ret = STX_API_CALL1( "GetFileAttributes", GetFileAttributes, _aPathName);
-} while ((ret < 0) && (__threadErrno == EINTR));
+	} while ((ret < 0) && (__threadErrno == EINTR));
 #else
-ret = GetFileAttributes((char *) __stringVal(aPathName));
+	ret = GetFileAttributes((char *) __stringVal(aPathName));
-if (ret < 0) {
+	if (ret < 0) {
-__threadErrno = __WIN32_ERR(GetLastError());
+	    __threadErrno = __WIN32_ERR(GetLastError());
-}
+	}
 #endif
-if (ret < 0) {
+	if (ret < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
+	    @global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
-RETURN ( false );
+	    RETURN ( false );
-}
+	}
-RETURN ( (ret & FILE_ATTRIBUTE_READONLY) ? false : true);
+	RETURN ( (ret & FILE_ATTRIBUTE_READONLY) ? false : true);
 }
 %}.
 ^ 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
 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),
 char fileNameBuffer[MAX_PATH+1];
 unsigned INT ino;
 if (__isString(aPathName)) {
-HANDLE hFile;
+	HANDLE hFile;
-FILETIME tempFileTime;
+	FILETIME tempFileTime;
-SYSTEMTIME creationTime;
+	SYSTEMTIME creationTime;
-SYSTEMTIME accessTime;
+	SYSTEMTIME accessTime;
-SYSTEMTIME modificationTime;
+	SYSTEMTIME modificationTime;
-int modeBits = 0;
+	int modeBits = 0;
-WIN32_FIND_DATA findStruct;
+	WIN32_FIND_DATA findStruct;
 #ifdef DO_WRAP_CALLS
-{
+	{
-char _aPathName[MAXPATHLEN];
+	    char _aPathName[MAXPATHLEN];
-strncpy(_aPathName, __stringVal(aPathName), MAXPATHLEN-1); _aPathName[MAXPATHLEN-1] = '\0';
+	    strncpy(_aPathName, __stringVal(aPathName), MAXPATHLEN-1); _aPathName[MAXPATHLEN-1] = '\0';
-do {
+	    do {
-__threadErrno = 0;
+		__threadErrno = 0;
-hFile = STX_API_CALL2( "FindFirstFile", FindFirstFile, _aPathName, &findStruct);
+		hFile = STX_API_CALL2( "FindFirstFile", FindFirstFile, _aPathName, &findStruct);
-} while ((hFile < 0) && (__threadErrno == EINTR));
+	    } while ((hFile < 0) && (__threadErrno == EINTR));
-}
+	}
 #else
-hFile = FindFirstFile(__stringVal(aPathName), &findStruct);
+	hFile = FindFirstFile(__stringVal(aPathName), &findStruct);
-if (hFile < 0) {
+	if (hFile < 0) {
-__threadErrno = __WIN32_ERR(GetLastError());
+	    __threadErrno = __WIN32_ERR(GetLastError());
-}
+	}
 #endif
-if (! hFile || (hFile == (HANDLE)(-1)) || (hFile == INVALID_HANDLE_VALUE)) {
+	if (! hFile || (hFile == (HANDLE)(-1)) || (hFile == INVALID_HANDLE_VALUE)) {
-@global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
+	    @global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
-} else {
+	} else {
-FindClose(hFile);
+	    FindClose(hFile);
-id = __mkSmallInteger(0);   /* could get it by opening ... */
+	    id = __mkSmallInteger(0);   /* could get it by opening ... */
-size = __MKLARGEINT64(1, findStruct.nFileSizeLow, findStruct.nFileSizeHigh);
+	    size = __MKLARGEINT64(1, findStruct.nFileSizeLow, findStruct.nFileSizeHigh);
-if (findStruct.cFileName[0] != '\0') {
+	    if (findStruct.cFileName[0] != '\0') {
-bcopy(findStruct.cFileName, fileNameBuffer, MAX_PATH);
+		bcopy(findStruct.cFileName, fileNameBuffer, MAX_PATH);
-fileNameBuffer[MAX_PATH] = '\0';
+		fileNameBuffer[MAX_PATH] = '\0';
-fileName = __MKSTRING(fileNameBuffer);             /* FULL name */
+		fileName = __MKSTRING(fileNameBuffer);             /* FULL name */
-}
+	    }
-if (findStruct.cAlternateFileName[0] != '\0') {
+	    if (findStruct.cAlternateFileName[0] != '\0') {
-bcopy(findStruct.cAlternateFileName, alternativeFileNameBuffer, 14);
+		bcopy(findStruct.cAlternateFileName, alternativeFileNameBuffer, 14);
-alternativeFileNameBuffer[14] = '\0';
+		alternativeFileNameBuffer[14] = '\0';
-alternativeName = __MKSTRING(alternativeFileNameBuffer); /* DOS name */
+		alternativeName = __MKSTRING(alternativeFileNameBuffer); /* DOS name */
-}
+	    }
-/*
+	    /*
-* simulate access bits
+	     * simulate access bits
-*/
+	     */
-if (findStruct.dwFileAttributes & FILE_ATTRIBUTE_READONLY) {
+	    if (findStruct.dwFileAttributes & FILE_ATTRIBUTE_READONLY) {
-modeBits = 0444;
+		modeBits = 0444;
-} else {
+	    } else {
-modeBits = 0666;
+		modeBits = 0666;
-}
+	    }
-if (findStruct.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
+	    if (findStruct.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
-type = @symbol(directory);
+		type = @symbol(directory);
-modeBits |= 0111;   /* executable */
+		modeBits |= 0111;   /* executable */
-} else {
+	    } else {
-type = @symbol(regular);
+		type = @symbol(regular);
-}
+	    }
-mode = __mkSmallInteger(modeBits);
+	    mode = __mkSmallInteger(modeBits);
-/*
+	    /*
-* sigh - convert from stupid time to useful time
+	     * sigh - convert from stupid time to useful time
-*/
+	     */
-FileTimeToLocalFileTime(&findStruct.ftCreationTime, &tempFileTime);
+	    FileTimeToLocalFileTime(&findStruct.ftCreationTime, &tempFileTime);
-FileTimeToSystemTime(&tempFileTime, &creationTime);
+	    FileTimeToSystemTime(&tempFileTime, &creationTime);
-FileTimeToLocalFileTime(&findStruct.ftLastAccessTime, &tempFileTime);
+	    FileTimeToLocalFileTime(&findStruct.ftLastAccessTime, &tempFileTime);
-FileTimeToSystemTime(&tempFileTime, &accessTime);
+	    FileTimeToSystemTime(&tempFileTime, &accessTime);
-FileTimeToLocalFileTime(&findStruct.ftLastWriteTime, &tempFileTime);
+	    FileTimeToLocalFileTime(&findStruct.ftLastWriteTime, &tempFileTime);
-FileTimeToSystemTime(&tempFileTime, &modificationTime);
+	    FileTimeToSystemTime(&tempFileTime, &modificationTime);
-aYr  = __mkSmallInteger(accessTime.wYear);
+	    aYr  = __mkSmallInteger(accessTime.wYear);
-aMon = __mkSmallInteger(accessTime.wMonth);
+	    aMon = __mkSmallInteger(accessTime.wMonth);
-aDay = __mkSmallInteger(accessTime.wDay);
+	    aDay = __mkSmallInteger(accessTime.wDay);
-aHr  = __mkSmallInteger(accessTime.wHour);
+	    aHr  = __mkSmallInteger(accessTime.wHour);
-aMin = __mkSmallInteger(accessTime.wMinute);
+	    aMin = __mkSmallInteger(accessTime.wMinute);
-aSec = __mkSmallInteger(accessTime.wSecond);
+	    aSec = __mkSmallInteger(accessTime.wSecond);
-aMS  = __mkSmallInteger(accessTime.wMilliseconds);
+	    aMS  = __mkSmallInteger(accessTime.wMilliseconds);
-mYr  = __mkSmallInteger(modificationTime.wYear);
+	    mYr  = __mkSmallInteger(modificationTime.wYear);
-mMon = __mkSmallInteger(modificationTime.wMonth);
+	    mMon = __mkSmallInteger(modificationTime.wMonth);
-mDay = __mkSmallInteger(modificationTime.wDay);
+	    mDay = __mkSmallInteger(modificationTime.wDay);
-mHr  = __mkSmallInteger(modificationTime.wHour);
+	    mHr  = __mkSmallInteger(modificationTime.wHour);
-mMin = __mkSmallInteger(modificationTime.wMinute);
+	    mMin = __mkSmallInteger(modificationTime.wMinute);
-mSec = __mkSmallInteger(modificationTime.wSecond);
+	    mSec = __mkSmallInteger(modificationTime.wSecond);
-mMS  = __mkSmallInteger(modificationTime.wMilliseconds);
+	    mMS  = __mkSmallInteger(modificationTime.wMilliseconds);
-cYr  = __mkSmallInteger(creationTime.wYear);
+	    cYr  = __mkSmallInteger(creationTime.wYear);
-cMon = __mkSmallInteger(creationTime.wMonth);
+	    cMon = __mkSmallInteger(creationTime.wMonth);
-cDay = __mkSmallInteger(creationTime.wDay);
+	    cDay = __mkSmallInteger(creationTime.wDay);
-cHr  = __mkSmallInteger(creationTime.wHour);
+	    cHr  = __mkSmallInteger(creationTime.wHour);
-cMin = __mkSmallInteger(creationTime.wMinute);
+	    cMin = __mkSmallInteger(creationTime.wMinute);
-cSec = __mkSmallInteger(creationTime.wSecond);
+	    cSec = __mkSmallInteger(creationTime.wSecond);
-cMS  = __mkSmallInteger(creationTime.wMilliseconds);
+	    cMS  = __mkSmallInteger(creationTime.wMilliseconds);
-}
+	}
 }
 %}.
 (aPathName endsWith:'.lnk') ifTrue:[
-type := #symbolicLink.
+	type := #symbolicLink.
-path := nil.
+	path := nil.
-"/ now done lazyly in FileStatusInfo, when the path is accessed
+	"/ now done lazyly in FileStatusInfo, when the path is accessed
-"/ path := self getLinkTarget:aPathName.
+	"/ path := self getLinkTarget:aPathName.
 ].
 mode isNil ifTrue:[
-(self isDirectory:aPathName) ifTrue:[
+	(self isDirectory:aPathName) ifTrue:[
-"/ the code above fails for root directories (these do not exist).
+	    "/ the code above fails for root directories (these do not exist).
-"/ simulate
+	    "/ simulate
-mode := 8r777.
+	    mode := 8r777.
-type := #directory.
+	    type := #directory.
-uid := gid := 0.
+	    uid := gid := 0.
-size := 0.
+	    size := 0.
-id := 0.
+	    id := 0.
-atime := mtime := ctime := Timestamp now.
+	    atime := mtime := ctime := Timestamp now.
-].
+	].
 ].
 mode notNil ifTrue:[
-atime isNil ifTrue:[
+	atime isNil ifTrue:[
-atime := Timestamp day:aDay month:aMon year:aYr hour:aHr minutes:aMin seconds:aSec milliseconds:aMS.
+	    atime := Timestamp day:aDay month:aMon year:aYr hour:aHr minutes:aMin seconds:aSec milliseconds:aMS.
-].
+	].
-mtime isNil ifTrue:[
+	mtime isNil ifTrue:[
-mtime := Timestamp day:mDay month:mMon year:mYr hour:mHr minutes:mMin seconds:mSec milliseconds:mMS.
+	    mtime := Timestamp day:mDay month:mMon year:mYr hour:mHr minutes:mMin seconds:mSec milliseconds:mMS.
-].
+	].
-ctime isNil ifTrue:[
+	ctime isNil ifTrue:[
-ctime := Timestamp day:cDay month:cMon year:cYr hour:cHr minutes:cMin seconds:cSec milliseconds:cMS.
+	    ctime := Timestamp day:cDay month:cMon year:cYr hour:cHr minutes:cMin seconds:cSec milliseconds:cMS.
-].
+	].
-info := FileStatusInfo
+	info := 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:atime
+		    accessed:atime
-modified:mtime
+		    modified:mtime
-created:ctime
+		    created:ctime
-path:path
+		    path:path
-fullName:fileName
+		    fullName:fileName
-alternativeName:alternativeName.
+		    alternativeName:alternativeName.
-^ info
+	^ info
 ].
 ^ nil
 "
 OperatingSystem linkInfoOf:'c:\windows'
 "given a file suffix, return a corresponding mimeType.
 Here, the Registry is consulted.
 Returns nil if no mimeType for the given suffix is known."
 ^ RegistryEntry
-stringValueFor:'Content Type'
+	stringValueFor:'Content Type'
-atKey:('HKEY_CLASSES_ROOT\.' , aFileSuffix)
+	atKey:('HKEY_CLASSES_ROOT\.' , aFileSuffix)
 "
 self mimeTypeForSuffix:'au'
 self mimeTypeForSuffix:'st'
 self mimeTypeForSuffix:'dll'
 "some systems have a convenient function for this ..."
 path := self primPathNameOf:pathName.
 path isNil ifTrue:[
-(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 copyWithoutLast:1.
+		p := p copyWithoutLast:1.
-].
+	    ].
-^ p
+	    ^ p
-].
+	].
-"/
+	"/
-"/ return the original - there is nothing else can we do
+	"/ return the original - there is nothing else can we do
-"/
+	"/
-path := self compressPath:pathName
+	path := self compressPath:pathName
 ].
 ^ path.
 "
 OperatingSystem pathNameOf:'.'
 from what you expect."
 %{  /* xxSTACK: 16000 */
 if (__isStringLike(aPathName)) {
-char nameBuffer[MAXPATHLEN + 1 + MAXPATHLEN + 1];
+	char nameBuffer[MAXPATHLEN + 1 + MAXPATHLEN + 1];
-char *pFinal;
+	char *pFinal;
-int rslt;
+	int rslt;
 #ifdef DO_WRAP_CALLS
-char _aPathName[MAXPATHLEN];
+	char _aPathName[MAXPATHLEN];
-strncpy(_aPathName, __stringVal(aPathName), MAXPATHLEN-1); _aPathName[MAXPATHLEN-1] = '\0';
+	strncpy(_aPathName, __stringVal(aPathName), MAXPATHLEN-1); _aPathName[MAXPATHLEN-1] = '\0';
-do {
+	do {
-__threadErrno = 0;
+	    __threadErrno = 0;
-rslt = STX_API_CALL4( "GetFullPathName", GetFullPathName, _aPathName, sizeof(nameBuffer), nameBuffer, &pFinal);
+	    rslt = STX_API_CALL4( "GetFullPathName", GetFullPathName, _aPathName, sizeof(nameBuffer), nameBuffer, &pFinal);
-} while ((rslt < 0) && (__threadErrno == EINTR));
+	} while ((rslt < 0) && (__threadErrno == EINTR));
 #else
-rslt = GetFullPathName(__stringVal(aPathName), sizeof(nameBuffer), nameBuffer, &pFinal);
+	rslt = GetFullPathName(__stringVal(aPathName), sizeof(nameBuffer), nameBuffer, &pFinal);
 #endif
-if (rslt > 0) {
+	if (rslt > 0) {
-/*
+	    /*
-* Attention: GetLongPathName is not available on old NT4.0/W95/W98
+	     * Attention: GetLongPathName is not available on old NT4.0/W95/W98
-*/
+	     */
-static FARPROC entry = NULL;
+	    static FARPROC entry = NULL;
 #ifdef NO_NT4_0_COMPATIBILITY
-entry = (FARPROC) GetLongPathName;
+	    entry = (FARPROC) GetLongPathName;
 #else
-if (entry == NULL) {
+	    if (entry == NULL) {
-entry = __get_KERNEL32_functionAddress("GetLongPathNameA");
+		entry = __get_KERNEL32_functionAddress("GetLongPathNameA");
-}
+	    }
 #endif /* NO_NT4_0_COMPATIBILITY */
-if (entry) {
+	    if (entry) {
 #ifdef DO_WRAP_CALLS
-do {
+		do {
-__threadErrno = 0;
+		    __threadErrno = 0;
-rslt = STX_API_CALL3( "GetLongPathName", entry, nameBuffer, nameBuffer, sizeof(nameBuffer));
+		    rslt = STX_API_CALL3( "GetLongPathName", entry, nameBuffer, nameBuffer, sizeof(nameBuffer));
-} while ((rslt < 0) && (__threadErrno == EINTR));
+		} while ((rslt < 0) && (__threadErrno == EINTR));
 #else
-rslt = (*entry)(nameBuffer, nameBuffer, sizeof(nameBuffer));
+		rslt = (*entry)(nameBuffer, nameBuffer, sizeof(nameBuffer));
 #endif
-}
+	    }
-}
+	}
-if (rslt > 0) {
+	if (rslt > 0) {
-RETURN ( __MKSTRING(nameBuffer) );
+	    RETURN ( __MKSTRING(nameBuffer) );
-}
+	}
-__threadErrno = __WIN32_ERR(GetLastError());
+	__threadErrno = __WIN32_ERR(GetLastError());
 }
 %}.
 ^ nil
 "
 self primPathNameOf:'.'
 %{
 int ret;
 if (__isString(aPathName)) {
-char _aPathName[MAXPATHLEN];
+	char _aPathName[MAXPATHLEN];
-strncpy(_aPathName, __stringVal(aPathName), MAXPATHLEN-1); _aPathName[MAXPATHLEN-1] = '\0';
+	strncpy(_aPathName, __stringVal(aPathName), MAXPATHLEN-1); _aPathName[MAXPATHLEN-1] = '\0';
-ret = STX_API_CALL2( "SetFileAttributes", SetFileAttributes, _aPathName, FILE_ATTRIBUTE_HIDDEN );
+	ret = STX_API_CALL2( "SetFileAttributes", SetFileAttributes, _aPathName, FILE_ATTRIBUTE_HIDDEN );
-if (ret != 0) {
+	if (ret != 0) {
-__threadErrno = __WIN32_ERR(GetLastError());
+	    __threadErrno = __WIN32_ERR(GetLastError());
-}
+	}
-RETURN (true);
+	RETURN (true);
 }
 %}.
 ^ self primitiveFailed
 !
 %{
 int ret;
 if (__isString(aPathName)) {
-char _aPathName[MAXPATHLEN];
+	char _aPathName[MAXPATHLEN];
-strncpy(_aPathName, __stringVal(aPathName), MAXPATHLEN-1); _aPathName[MAXPATHLEN-1] = '\0';
+	strncpy(_aPathName, __stringVal(aPathName), MAXPATHLEN-1); _aPathName[MAXPATHLEN-1] = '\0';
-ret = STX_API_CALL2( "SetFileAttributes", SetFileAttributes, _aPathName, FILE_ATTRIBUTE_NORMAL );
+	ret = STX_API_CALL2( "SetFileAttributes", SetFileAttributes, _aPathName, FILE_ATTRIBUTE_NORMAL );
-if (ret != 0) {
+	if (ret != 0) {
-__threadErrno = __WIN32_ERR(GetLastError());
+	    __threadErrno = __WIN32_ERR(GetLastError());
-}
+	}
-RETURN (true);
+	RETURN (true);
 }
 %}.
 ^ self primitiveFailed
 !
 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
 "
 | i|
 i := self infoOf:aPathName.
 i notNil ifTrue:[^ i accessTime].
 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
 "
 | i|
 i := self infoOf:aPathName.
 |i|
 "
 this could have been implemented as:
-(self infoOf:aPathName) type
+	(self infoOf:aPathName) type
 "
 i := self infoOf:aPathName.
 i notNil ifTrue:[^ i type].
 ^ nil.
 Not all OperatingSystem support/use volumes; on unix,
 this always returns an empty string."
 aPathString size < 2 ifTrue:[^ ''].
 (aPathString at:2) == $: ifTrue:[
-^ (aPathString at:1) asString.
+	^ (aPathString at:1) asString.
 ].
 ^ ''
 ! !
 !Win32OperatingSystem class methodsFor:'help support'!
 html documents, pdf documents etc."
 |result|
 Error
-handle:[:ex |
+	handle:[:ex |
-self halt
+	    self halt
-] do:[
+	] do:[
-|filename|
+	    |filename|
-filename := aFilenameOrString asFilename.
+	    filename := aFilenameOrString asFilename.
-result := self
+	    result := self
-shellExecute:nil
+		shellExecute:nil
-lpOperation:'open'
+		lpOperation:'open'
-lpFile:filename pathName
+		lpFile:filename pathName
-lpParameters:nil
+		lpParameters:nil
-lpDirectory:filename directory pathName
+		lpDirectory:filename directory pathName
-nShowCmd:#SW_SHOWNORMAL.
+		nShowCmd:#SW_SHOWNORMAL.
-^ self.
+	    ^ self.
-]
+	]
 "
 self openDocumentationFilename: 'C:\WINDOWS\Help\clipbrd.chm' asFilename
 self openDocumentationFilename: Filename currentDirectory
 "
 "this is a test method;
 For testing double CTRL-C in blocking primitives"
 %{
 while(1) {
-console_printf("blocking...");
+	console_printf("blocking...");
-Sleep(50);
+	Sleep(50);
 }
 %}.
 "
 OperatingSystem blockingTest
 "
 "this is a test method;
 For testing double CTRL-C in blocking primitives"
 %{
 while(1) {
-console_printf("blocking...");
+	console_printf("blocking...");
-STX_API_CALL1("Sleep", Sleep, 50);
+	STX_API_CALL1("Sleep", Sleep, 50);
 }
 %}.
 "
 OperatingSystem blockingTest2
 "
 %{  /* 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
 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 */
 extern void __win32ClearTimer();
 && ((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
 #ifdef SIGNALDEBUGWIN32
-console_printf("ConsoleSignal %d\n",sigNr);
+		console_printf("ConsoleSignal %d\n",sigNr);
 #endif
-SetConsoleCtrlHandler((PHANDLER_ROUTINE)__signalUserInterruptWIN32,TRUE);
+		SetConsoleCtrlHandler((PHANDLER_ROUTINE)__signalUserInterruptWIN32,TRUE);
-RETURN (self);
+		RETURN (self);
 #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 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
-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
 #  ifdef WIN32
 #   ifdef SIGNALDEBUGWIN32
-console_printf("signal %d can't change handler\n",sigNr);
+	    console_printf("signal %d can't change handler\n",sigNr);
 #   endif
 #  else
-(void) signal(sigNr, handler);
+	    (void) signal(sigNr, handler);
 #  endif
 # endif
 #endif
-}
+	}
-/*
+	/*
-* maybe, we should Return the old enable-status
+	 * maybe, we should Return the old enable-status
-* as boolean here ...
+	 * as boolean here ...
-*/
+	 */
-RETURN (self);
+	RETURN (self);
 }
 %}.
 "
 this error is triggered on non-integer argument, or
 %{  /* NOCONTEXT */
 extern void __win32SetTimer();
 if (__isSmallInteger(milliSeconds)) {
-__win32SetTimer( __intVal(milliSeconds) );
+	__win32SetTimer( __intVal(milliSeconds) );
-RETURN (true);
+	RETURN (true);
 }
 %}.
 ^ false
 !
 killProcess:processId
 "kill a process.
 The process terminates immediately and has no chance to perform any cleanup actions.
 WARNING: in order to avoid zombie processes (on unix),
-you have to fetch the processes exitstatus with
+	      you have to fetch the processes exitstatus with
-OperatingSystem>>getStatusOfProcess:aProcessId."
+	      OperatingSystem>>getStatusOfProcess:aProcessId."
 self terminateProcess:processId
 !
 sendSignal:signalNumber to:processId
 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."
 "/
 "/ either invalid argument (non-integers)
 "/ or not supported by OS
 "/
 terminateProcess:processHandle
 "terminate a process.
 The process has a chance to do some cleanup.
 WIN32:
-Under unix, we have terminateProcess, which does a soft
+	 Under unix, we have terminateProcess, which does a soft
-terminate (giving the process a chance to cleanup) and
+	 terminate (giving the process a chance to cleanup) and
-killProcess, which does a hard terminate.
+	 killProcess, which does a hard terminate.
-Under WIN32, both (currently) use the TerminateProcess
+	 Under WIN32, both (currently) use the TerminateProcess
-function, which unconditionally causes a process to exit.
+	 function, which unconditionally causes a process to exit.
-I.e. under WIN32, the process has no chance to perform cleanup.
+	 I.e. under WIN32, the process has no chance to perform cleanup.
-Use it only in extreme circumstances. The state of
+	 Use it only in extreme circumstances. The state of
-global data maintained by dynamic-link libraries (DLLs)
+	 global data maintained by dynamic-link libraries (DLLs)
-may be compromised if TerminateProcess is used.
+	 may be compromised if TerminateProcess is used.
 TODO: send it a WM_QUIT instead, to allow for proper shutdown."
 self terminateProcess:processHandle exitCode:0
 !
 terminateProcess:processHandle exitCode:exitCode
 "terminate a process.
 The process should have a chance to do some cleanup.
 WIN32:
-Under unix, we have terminateProcess, which does a soft
+	 Under unix, we have terminateProcess, which does a soft
-terminate (giving the process a chance to cleanup) and
+	 terminate (giving the process a chance to cleanup) and
-killProcess, which does a hard terminate.
+	 killProcess, which does a hard terminate.
-Under WIN32, both (currently) use the TerminateProcess
+	 Under WIN32, both (currently) use the TerminateProcess
-function, which unconditionally causes a process to exit.
+	 function, which unconditionally causes a process to exit.
-I.e. under WIN32, the process has no chance to perform cleanup.
+	 I.e. under WIN32, the process has no chance to perform cleanup.
-Use it only in extreme circumstances. The state of
+	 Use it only in extreme circumstances. The state of
-global data maintained by dynamic-link libraries (DLLs)
+	 global data maintained by dynamic-link libraries (DLLs)
-may be compromised if TerminateProcess is used.
+	 may be compromised if TerminateProcess is used.
 TODO: send it a WM_QUIT instead, to allow for proper shutdown."
 %{
 if (__isExternalAddressLike(processHandle) ) {
-HANDLE hProcess = _HANDLEVal(processHandle);
+	HANDLE hProcess = _HANDLEVal(processHandle);
 #ifdef PROCESS1DEBUGWIN32
-console_printf("TerminateProcess handle: %x\n", hProcess);
+	console_printf("TerminateProcess handle: %x\n", hProcess);
 #endif
-if (hProcess != 0) {
+	if (hProcess != 0) {
-TerminateProcess(hProcess, __intVal(exitCode));
+	    TerminateProcess(hProcess, __intVal(exitCode));
-} else {
+	} else {
-console_fprintf(stderr, "Win32OS [warning]: wrong hProcess in TerminateProcess\n");
+	    console_fprintf(stderr, "Win32OS [warning]: wrong hProcess in TerminateProcess\n");
-}
+	}
 } else {
-console_fprintf(stderr, "Win32OS [warning]: wrong processHandle in TerminateProcess\n");
+	console_fprintf(stderr, "Win32OS [warning]: wrong processHandle in TerminateProcess\n");
 }
 %}
 "Modified: / 28.12.1995 / 15:05:37 / stefan"
 "Modified: / 27.1.1998 / 20:05:47 / cg"
 terminateProcessGroup:processGroupHandle
 "terminate a process group.
 The processes should have a chance to do some cleanup.
 WIN32:
-The processGroup is terminated by sending it a CTRL-C
+	 The processGroup is terminated by sending it a CTRL-C
-using GenerateConsoleCtrlEvent."
+	 using GenerateConsoleCtrlEvent."
 %{
 if (__isExternalAddressLike(processGroupHandle) ) {
-HANDLE hProcessGroup = _HANDLEVal(processGroupHandle);
+	HANDLE hProcessGroup = _HANDLEVal(processGroupHandle);
-DWORD processGroupId;
+	DWORD processGroupId;
-if (hProcessGroup != (HANDLE)0) {
+	if (hProcessGroup != (HANDLE)0) {
-processGroupId = __intVal( ((struct __Win32OperatingSystem__Win32ProcessHandle_struct *)(processGroupHandle))->pid );
+	    processGroupId = __intVal( ((struct __Win32OperatingSystem__Win32ProcessHandle_struct *)(processGroupHandle))->pid );
 #ifdef PROCESS1DEBUGWIN32
-console_printf("TerminateProcessGroup processGroupHandle: %x (%d)\n", hProcessGroup, processGroupId);
+	    console_printf("TerminateProcessGroup processGroupHandle: %x (%d)\n", hProcessGroup, processGroupId);
 #endif
-GenerateConsoleCtrlEvent(CTRL_C_EVENT, processGroupId);
+	    GenerateConsoleCtrlEvent(CTRL_C_EVENT, processGroupId);
-} else {
+	} else {
-console_fprintf(stderr, "Win32OS [warning]: wrong hProcessGroup in TerminateProcessGroup \n");
+	    console_fprintf(stderr, "Win32OS [warning]: wrong hProcessGroup in TerminateProcessGroup \n");
-}
+	}
 } else {
-console_fprintf(stderr, "Win32OS [warning]: wrong processGroupHandle in TerminateProcessGroup \n");
+	console_fprintf(stderr, "Win32OS [warning]: wrong processGroupHandle in TerminateProcessGroup \n");
 }
 %}
 ! !
 !Win32OperatingSystem class methodsFor:'ipc support'!
 sa.nLength = sizeof(SECURITY_ATTRIBUTES);
 sa.lpSecurityDescriptor = NULL;
 sa.bInheritHandle = TRUE;
 if( ! CreatePipe( &pipeRead, &pipeWrite, &sa, 0 ) ) {
-@global(LastErrorNumber) = __mkSmallInteger( __WIN32_ERR(GetLastError()) );
+	@global(LastErrorNumber) = __mkSmallInteger( __WIN32_ERR(GetLastError()) );
-RETURN ( nil );
+	RETURN ( nil );
 }
 #ifdef USE_HANDLES
 fd1 = __MKEXTERNALADDRESS(pipeRead);
 fd2 = __MKEXTERNALADDRESS(pipeWrite);
 # endif
 fd1 = __mkSmallInteger(_open_osfhandle(pipeRead, O_BINARY));
 fd2 = __mkSmallInteger(_open_osfhandle(pipeWrite, O_BINARY));
 #endif
 %}.
-fd1 notNil ifTrue:[
+(fd1 notNil and:[fd2 notNil]) ifTrue:[
-^ Array with:fd1 with:fd2.
+	(fd1 ~~ -1 and:[fd2 ~~ -1]) ifTrue:[
+	    ^ Array with:fd1 with:fd2.
+	].
 ].
 ^ nil
 ! !
 !Win32OperatingSystem class methodsFor:'misc'!
 closePid:pid
 "free pid resource"
 %{
 if (__isExternalAddressLike(pid) ) {
-HANDLE __pid = _HANDLEVal(pid);
+	HANDLE __pid = _HANDLEVal(pid);
-if (__pid != 0) {
+	if (__pid != 0) {
 #ifdef PROCESSDEBUGWIN32
-console_printf("Close ProcessHandle %x\n", __pid);
+	    console_printf("Close ProcessHandle %x\n", __pid);
 #endif
-CloseHandle(__pid);
+	    CloseHandle(__pid);
-_HANDLEVal(pid) = 0;
+	    _HANDLEVal(pid) = 0;
-}
+	}
 }
 %}.
 ^ true.
 "Created: 28.1.1998 / 14:23:04 / md"
 "Modified: 28.1.1998 / 14:27:18 / md"
 !
 getPrivateProfileString:appNameString key:keyNameString default:defaultString fileName:fileName
 ^ self
-getProfileString:appNameString key:keyNameString default:defaultString
+	getProfileString:appNameString key:keyNameString default:defaultString
-fileName:fileName private:true
+	fileName:fileName private:true
 "Modified: / 27-07-2006 / 11:57:03 / fm"
 !
 getProfileString:appNameString key:keyNameString default:defaultString
 int bufferSize = sizeof(quickBuffer);
 int nChars;
 OBJ retVal;
 if (__isString(appNameString)) {
-__appNameString = __stringVal(appNameString);
+	__appNameString = __stringVal(appNameString);
 } else if (appNameString != nil)
-goto primitiveFail;
+	goto primitiveFail;
 if (__isString(keyNameString)) {
-__keyNameString = __stringVal(keyNameString);
+	__keyNameString = __stringVal(keyNameString);
 } else if (keyNameString != nil)
-goto primitiveFail;
+	goto primitiveFail;
 if (__isString(defaultString)) {
-__defaultString = __stringVal(defaultString);
+	__defaultString = __stringVal(defaultString);
 } else if (defaultString != nil)
-goto primitiveFail;
+	goto primitiveFail;
 do {
-nChars = GetProfileString(__appNameString, __keyNameString, __defaultString, usedBuffer, bufferSize);
+	nChars = GetProfileString(__appNameString, __keyNameString, __defaultString, usedBuffer, bufferSize);
-if (nChars >= 0) {
+	if (nChars >= 0) {
-if (nChars != bufferSize-1) {
+	    if (nChars != bufferSize-1) {
-retVal = __MKSTRING_L(usedBuffer, nChars);
+		retVal = __MKSTRING_L(usedBuffer, nChars);
-if (usedBuffer != quickBuffer) free(usedBuffer);
+		if (usedBuffer != quickBuffer) free(usedBuffer);
-RETURN (retVal);
+		RETURN (retVal);
-}
+	    }
-{
+	    {
-/* use a bigger buffer */
+		/* use a bigger buffer */
-char *newBuffer;
+		char *newBuffer;
-int newBufferSize = bufferSize * 2;
+		int newBufferSize = bufferSize * 2;
-newBuffer = (char *)malloc( newBufferSize );
+		newBuffer = (char *)malloc( newBufferSize );
-if (usedBuffer != quickBuffer) free(usedBuffer);
+		if (usedBuffer != quickBuffer) free(usedBuffer);
-usedBuffer = newBuffer;
+		usedBuffer = newBuffer;
-bufferSize = newBufferSize;
+		bufferSize = newBufferSize;
-}
+	    }
-}
+	}
 } while (nChars > 0);
 RETURN (nil);
 primitiveFail: ;
 %}.
 int bufferSize = sizeof(quickBuffer);
 int nChars;
 OBJ retVal;
 if (__isString(appNameString)) {
-__appNameString = __stringVal(appNameString);
+	__appNameString = __stringVal(appNameString);
 } else if (appNameString != nil)
-goto primitiveFail;
+	goto primitiveFail;
 if (__isString(keyNameString)) {
-__keyNameString = __stringVal(keyNameString);
+	__keyNameString = __stringVal(keyNameString);
 } else if (keyNameString != nil)
-goto primitiveFail;
+	goto primitiveFail;
 if (__isString(defaultString)) {
-__defaultString = __stringVal(defaultString);
+	__defaultString = __stringVal(defaultString);
 } else if (defaultString != nil)
-goto primitiveFail;
+	goto primitiveFail;
 if (private == true) {
-if (! __isString(fileName)) goto primitiveFail;
+	if (! __isString(fileName)) goto primitiveFail;
-__fileName = __stringVal(fileName);
+	__fileName = __stringVal(fileName);
 }
 do {
-if (private == true) {
+	if (private == true) {
-nChars = GetPrivateProfileString(__appNameString, __keyNameString, __defaultString, usedBuffer, bufferSize, __fileName);
+	    nChars = GetPrivateProfileString(__appNameString, __keyNameString, __defaultString, usedBuffer, bufferSize, __fileName);
-} else {
+	} else {
-nChars = GetProfileString(__appNameString, __keyNameString, __defaultString, usedBuffer, bufferSize);
+	    nChars = GetProfileString(__appNameString, __keyNameString, __defaultString, usedBuffer, bufferSize);
-}
+	}
-if (nChars >= 0) {
+	if (nChars >= 0) {
-if (nChars != bufferSize-1) {
+	    if (nChars != bufferSize-1) {
-retVal = __MKSTRING_L(usedBuffer, nChars);
+		retVal = __MKSTRING_L(usedBuffer, nChars);
-if (usedBuffer != quickBuffer) free(usedBuffer);
+		if (usedBuffer != quickBuffer) free(usedBuffer);
-RETURN (retVal);
+		RETURN (retVal);
-}
+	    }
-{
+	    {
-/* use a bigger buffer */
+		/* use a bigger buffer */
-char *newBuffer;
+		char *newBuffer;
-int newBufferSize = bufferSize * 2;
+		int newBufferSize = bufferSize * 2;
-newBuffer = (char *)malloc( newBufferSize );
+		newBuffer = (char *)malloc( newBufferSize );
-if (usedBuffer != quickBuffer) free(usedBuffer);
+		if (usedBuffer != quickBuffer) free(usedBuffer);
-usedBuffer = newBuffer;
+		usedBuffer = newBuffer;
-bufferSize = newBufferSize;
+		bufferSize = newBufferSize;
-}
+	    }
-}
+	}
 } while (nChars > 0);
 RETURN (nil);
 primitiveFail: ;
 %}.
 writePrivateProfileString: appName keyName: keyName profileString: profString fileName: aString
 ^self primWritePrivateProfileString: appName keyName: keyName profileString: profString fileName: aString
 "
 |profileStringToWrite recoveredProfileString|
 profileStringToWrite :=  'c:\vsw311'.
 self writePrivateProfileString: 'PAV-Editor' keyName: 'ExportPath' profileString: profileStringToWrite fileName: 'C:\vsw311\dapas.ini'.
 recoveredProfileString := self getProfileString:'PAV-Editor' key:'ExportPath' default:'@@@nil@@@' fileName:'C:\vsw311\dapas.ini' private:true.
 self assert: (profileStringToWrite = recoveredProfileString).
 !
 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."
 |name idx hostName k|
 DomainName notNil ifTrue:[
-^ DomainName
+	^ DomainName
 ].
 name := self getEnvironment:'DOMAIN'.
 name isNil ifTrue:[
-name := self getEnvironment:'DOMAINNAME'.
+	name := self getEnvironment:'DOMAINNAME'.
 ].
 name isNil 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:[
-name := hostName copyFrom:idx+1.
+		name := hostName copyFrom:idx+1.
-]
+	    ]
-].
+	].
-name isNil ifTrue:[
+	name isNil ifTrue:[
-"/ ok, search the registry ...
+	    "/ ok, search the registry ...
-"/ under NT, it is found there ...
+	    "/ under NT, it is found there ...
-k := RegistryEntry key:'HKEY_LOCAL_MACHINE\System'.
+	    k := RegistryEntry key:'HKEY_LOCAL_MACHINE\System'.
-k notNil ifTrue:[
+	    k notNil ifTrue:[
-k subKeysDo:[:subKey |
+		k subKeysDo:[:subKey |
-subKey subKeysDo:[:subSubKey |
+		    subKey subKeysDo:[:subSubKey |
-|tcp params|
+			|tcp params|
-(subSubKey path asLowercase endsWith:'services') ifTrue:[
+			(subSubKey path asLowercase endsWith:'services') ifTrue:[
-tcp := subSubKey subKeyNamed:'tcpip'.
+			    tcp := subSubKey subKeyNamed:'tcpip'.
-tcp notNil ifTrue:[
+			    tcp notNil ifTrue:[
-params := tcp subKeyNamed:'parameters'.
+				params := tcp subKeyNamed:'parameters'.
-params notNil ifTrue:[
+				params notNil ifTrue:[
-name := params valueNamed:'Domain'.
+				    name := params valueNamed:'Domain'.
-params close.
+				    params close.
-].
+				].
-tcp close.
+				tcp close.
-]
+			    ]
-]
+			]
-]
+		    ]
-]
+		]
-].
+	    ].
-].
+	].
-name isNil ifTrue:[
+	name isNil ifTrue:[
-"/ under Win95/Win98, it is found there ...
+	    "/ under Win95/Win98, it is found there ...
-k := RegistryEntry key:'HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\VxD\MSTCP'.
+	    k := RegistryEntry key:'HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\VxD\MSTCP'.
-k notNil ifTrue:[
+	    k notNil ifTrue:[
-name := k valueNamed:'Domain'.
+		name := k valueNamed:'Domain'.
-k close.
+		k close.
-]
+	    ]
-].
+	].
-name isNil ifTrue:[
+	name isNil ifTrue:[
-'Win32OperatingSystem [warning]: cannot find out domainname' errorPrintCR.
+	    'Win32OperatingSystem [warning]: cannot find out domainname' errorPrintCR.
-name := 'unknown'.
+	    name := 'unknown'.
-]
+	]
 ].
 DomainName := name.
 ^ name
 "
 %{  /* NOCONTEXT */
 char *env;
 if (__isString(aStringOrSymbol) || __isSymbol(aStringOrSymbol)) {
-char buff[1024];
+	char buff[1024];
-int nNeeded;
+	int nNeeded;
-OBJ ret = nil;
+	OBJ ret = nil;
-nNeeded = GetEnvironmentVariable(__stringVal(aStringOrSymbol),
+	nNeeded = GetEnvironmentVariable(__stringVal(aStringOrSymbol),
-buff,
+				   buff,
-sizeof(buff));
+				   sizeof(buff));
-if (nNeeded > sizeof(buff)) {
+	if (nNeeded > sizeof(buff)) {
-char *buff2;
+	    char *buff2;
-buff2 = (char *)malloc(nNeeded);
+	    buff2 = (char *)malloc(nNeeded);
-GetEnvironmentVariable(__stringVal(aStringOrSymbol),
+	    GetEnvironmentVariable(__stringVal(aStringOrSymbol),
-buff2,
+				   buff2,
-nNeeded);
+				   nNeeded);
-ret = __MKSTRING(buff2);
+	    ret = __MKSTRING(buff2);
-free(buff2);
+	    free(buff2);
-} else {
+	} else {
-if (nNeeded > 0) {
+	    if (nNeeded > 0) {
-ret = __MKSTRING(buff);
+		ret = __MKSTRING(buff);
-}
+	    }
-}
+	}
-RETURN (ret);
+	RETURN (ret);
 }
 %}
 .
 ^ nil
 getHostName
 "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, 'unknown' is returned."
+	not all systems support this; on some, 'unknown' is returned."
 |name idx|
 HostName notNil ifTrue:[
-^ HostName
+	^ HostName
 ].
 name := self primGetHostName.
 "/ on some systems, the hostname already contains the domain.
 "/ decompose it here.
 idx := name indexOf:$..
 idx ~~ 0 ifTrue:[
-DomainName := name copyFrom:(idx+1).
+	DomainName := name copyFrom:(idx+1).
-name := name copyTo:(idx-1).
+	name := name copyTo:(idx-1).
 ].
 HostName := name.
 ^ name
 "
 |lang|
 lang := self getEnvironment:'LANG'.
 (lang isNil or:[lang = 'default']) ifTrue:[
-"/ ok, search the registry ...
+	"/ ok, search the registry ...
-"/ under XP, it is found there ...
+	"/ under XP, it is found there ...
-lang := RegistryEntry
+	lang := RegistryEntry
-stringValueFor:'sLanguage'
+		    stringValueFor:'sLanguage'
-atKey:'HKEY_CURRENT_USER\Control Panel\International'.
+		    atKey:'HKEY_CURRENT_USER\Control Panel\International'.
-lang notNil ifTrue:[
+	lang notNil ifTrue:[
-lang := self mapLanguage:lang.
+	    lang := self mapLanguage:lang.
-].
+	].
 ].
 ^ lang
 "
 OperatingSystem getLanguage
 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"
 !
 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
 "
 |info nAdapters rawData entry
 name description macAddress ipAddress ipAddressMask|
 */
 #ifdef NO_NT4_0_COMPATIBILITY
 entry2 = (FARPROC) GetAdaptersInfo;
 #else
 if (entry2 == NULL) {
-entry2 = __get_iphlpapi_functionAddress("GetAdaptersInfo");
+	entry2 = __get_iphlpapi_functionAddress("GetAdaptersInfo");
 }
 #endif /* NO_NT4_0_COMPATIBILITY */
 if (entry2) {
-dwStatus = (*entry2)(
+	dwStatus = (*entry2)(
-AdapterInfo,                 // [out] buffer to receive data
+				AdapterInfo,                 // [out] buffer to receive data
-&dwBufLen);                  // [in] size of receive data buffer
+				&dwBufLen);                  // [in] size of receive data buffer
-if (dwStatus == ERROR_SUCCESS) {
+	if (dwStatus == ERROR_SUCCESS) {
-PIP_ADAPTER_INFO pAdapterInfo = AdapterInfo;
+	    PIP_ADAPTER_INFO pAdapterInfo = AdapterInfo;
-unsigned char *bP;
+	    unsigned char *bP;
-int nA = 0;
+	    int nA = 0;
-bP = __byteArrayVal(rawData);
+	    bP = __byteArrayVal(rawData);
-do {
+	    do {
-name = __MKSTRING(pAdapterInfo->AdapterName);
+		name = __MKSTRING(pAdapterInfo->AdapterName);
-description = __MKSTRING(pAdapterInfo->Description);
+		description = __MKSTRING(pAdapterInfo->Description);
-macAddress = __MKBYTEARRAY(pAdapterInfo->Address, 6);
+		macAddress = __MKBYTEARRAY(pAdapterInfo->Address, 6);
-ipAddress = __MKSTRING(pAdapterInfo->IpAddressList.IpAddress.String);
+		ipAddress = __MKSTRING(pAdapterInfo->IpAddressList.IpAddress.String);
-ipAddressMask = __MKSTRING(pAdapterInfo->IpAddressList.IpMask.String);
+		ipAddressMask = __MKSTRING(pAdapterInfo->IpAddressList.IpMask.String);
-entry = __ARRAY_NEW_INT(5);
+		entry = __ARRAY_NEW_INT(5);
 /*
 * back to ST/X's String definition
 */
 # ifdef __DEF_String
 #  define String __DEF_String
 # endif
 # ifdef __DEF_String
 #  define Context __DEF_Context
 # endif
-__ArrayInstPtr(entry)->a_element[0] = name; __STORE(entry, name);
+		__ArrayInstPtr(entry)->a_element[0] = name; __STORE(entry, name);
-__ArrayInstPtr(entry)->a_element[1] = description; __STORE(entry, description);
+		__ArrayInstPtr(entry)->a_element[1] = description; __STORE(entry, description);
-__ArrayInstPtr(entry)->a_element[2] = macAddress; __STORE(entry, macAddress);
+		__ArrayInstPtr(entry)->a_element[2] = macAddress; __STORE(entry, macAddress);
-__ArrayInstPtr(entry)->a_element[3] = ipAddress; __STORE(entry, ipAddress);
+		__ArrayInstPtr(entry)->a_element[3] = ipAddress; __STORE(entry, ipAddress);
-__ArrayInstPtr(entry)->a_element[4] = ipAddressMask; __STORE(entry, ipAddressMask);
+		__ArrayInstPtr(entry)->a_element[4] = ipAddressMask; __STORE(entry, ipAddressMask);
-__ArrayInstPtr(rawData)->a_element[nA] = entry; __STORE(rawData, entry);
+		__ArrayInstPtr(rawData)->a_element[nA] = entry; __STORE(rawData, entry);
-nA++;
+		nA++;
-pAdapterInfo = pAdapterInfo->Next;
+		pAdapterInfo = pAdapterInfo->Next;
-} while(pAdapterInfo);
+	    } while(pAdapterInfo);
-nAdapters = __mkSmallInteger(nA);
+	    nAdapters = __mkSmallInteger(nA);
-}
+	}
 }
 #endif /* NO_GETADAPTERSINFO */
 %}.
 info := Dictionary new.
 nAdapters notNil ifTrue:[
-1 to:nAdapters do:[:i |
+	1 to:nAdapters do:[:i |
-|entry name description macAddr ipAddr|
+	    |entry name description macAddr ipAddr|
-entry := rawData at:i.
+	    entry := rawData at:i.
-name := entry at:1.
+	    name := entry at:1.
-"/ description := entry at:2.
+	    "/ description := entry at:2.
-macAddr := entry at:3.
+	    macAddr := entry at:3.
-"/ ipAddr := entry at:4.
+	    "/ ipAddr := entry at:4.
-info at:name put:macAddr.
+	    info at:name put:macAddr.
-].
+	].
 ].
 ^ info
 "
 OperatingSystem getNetworkMACAddresses
 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."
 %{  /* NO_CONTEXT */
 #if defined(HAS_GETHOSTID)
 int runningId;
 OBJ arr;
 *(int *)(__ByteArrayInstPtr(arr)->ba_element) = runningId;
 RETURN (arr);
 #endif
 #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));
-}
+	    }
-}
+	}
 }
 #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).
 Your application should NOT 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 machine (i586, mips ...)
+	#machine -> type of machine (i586, mips ...)
 win32:
-#physicalRam -> total amount of physical memory
+	#physicalRam -> total amount of physical memory
-#freeRam -> amount of free memory
+	#freeRam -> amount of free memory
-#swapSize -> size of swapSpace (page file)
+	#swapSize -> size of swapSpace (page file)
-#freeSwap -> free bytes in swapSpace
+	#freeSwap -> free bytes in swapSpace
-#virtualRam -> total amount of virtual memory
+	#virtualRam -> total amount of virtual memory
-#freeVirtual -> amount of free virtual memory
+	#freeVirtual -> amount of free virtual memory
-#memoryLoad -> percentage of memory usage (useless)
+	#memoryLoad -> percentage of memory usage (useless)
 "
 |sys node rel ver mach dom info arch
 physicalRam freeRam swapSize freeSwap
 virtualRam freeVirtual memoryLoad numberOfCPUs|
 winVer = LOWORD(vsn);
 verMinor = HIBYTE(winVer);
 verMajor = LOBYTE(winVer);
 if (HIWORD(vsn) & 0x8000) {
-s = "win95";
+	s = "win95";
 } else {
-if ((verMajor > 5)
+	if ((verMajor > 5)
-|| ((verMajor == 5) && (verMinor >= 1))) {
+	 || ((verMajor == 5) && (verMinor >= 1))) {
-s = "xp";
+	    s = "xp";
-} else {
+	} else {
-s = "nt";
+	    s = "nt";
-}
+	}
 }
 sys = __MKSTRING(s);
 len = snprintf(vsnBuffer, sizeof(vsnBuffer), "%d.%d", verMajor, verMinor);
 rel = __MKSTRING_L(vsnBuffer, len);
 /* MSC, BorlandC4 ... */
 switch (sysInfo.wProcessorArchitecture)
 #endif
 {
 #ifdef PROCESSOR_ARCHITECTURE_INTEL
-case PROCESSOR_ARCHITECTURE_INTEL:
+	case PROCESSOR_ARCHITECTURE_INTEL:
-s = "intel";
+	    s = "intel";
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_ARCHITECTURE_MIPS
-case PROCESSOR_ARCHITECTURE_MIPS:
+	case PROCESSOR_ARCHITECTURE_MIPS:
-s = "mips";
+	    s = "mips";
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_ARCHITECTURE_ALPHA
-case PROCESSOR_ARCHITECTURE_ALPHA:
+	case PROCESSOR_ARCHITECTURE_ALPHA:
-s = "alpha";
+	    s = "alpha";
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_ARCHITECTURE_ALPHA64
-case PROCESSOR_ARCHITECTURE_ALPHA64:
+	case PROCESSOR_ARCHITECTURE_ALPHA64:
-s = "alpha64";
+	    s = "alpha64";
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_ARCHITECTURE_PPC
-case PROCESSOR_ARCHITECTURE_PPC:
+	case PROCESSOR_ARCHITECTURE_PPC:
-s = "ppc";
+	    s = "ppc";
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_ARCHITECTURE_ARM
-case PROCESSOR_ARCHITECTURE_ARM:
+	case PROCESSOR_ARCHITECTURE_ARM:
-s = "arm";
+	    s = "arm";
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_ARCHITECTURE_SHX
-case PROCESSOR_ARCHITECTURE_SHX:
+	case PROCESSOR_ARCHITECTURE_SHX:
-s = "shx";
+	    s = "shx";
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_ARCHITECTURE_IA64
-case PROCESSOR_ARCHITECTURE_IA64:
+	case PROCESSOR_ARCHITECTURE_IA64:
-s = "ia64";
+	    s = "ia64";
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_ARCHITECTURE_MSIL
-case PROCESSOR_ARCHITECTURE_MSIL:
+	case PROCESSOR_ARCHITECTURE_MSIL:
-s = "msil";
+	    s = "msil";
-break;
+	    break;
 #endif
-default:
+	default:
-s = "unknown";
+	    s = "unknown";
-break;
+	    break;
 }
 arch = __MKSTRING(s);
 switch (sysInfo.dwProcessorType) {
 #ifdef PROCESSOR_INTEL_386
-case PROCESSOR_INTEL_386:
+	case PROCESSOR_INTEL_386:
-s = "i386";
+	    s = "i386";
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_INTEL_486
-case PROCESSOR_INTEL_486:
+	case PROCESSOR_INTEL_486:
-s = "i486";
+	    s = "i486";
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_INTEL_PENTIUM
-case PROCESSOR_INTEL_PENTIUM:
+	case PROCESSOR_INTEL_PENTIUM:
-s = "i586";
+	    s = "i586";
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_INTEL_860
-case PROCESSOR_INTEL_860:
+	case PROCESSOR_INTEL_860:
-s = "i860";
+	    s = "i860";
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_INTEL_IA64
-case PROCESSOR_INTEL_IA64:
+	case PROCESSOR_INTEL_IA64:
-s = "ia64";
+	    s = "ia64";
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_MIPS_R2000
-case PROCESSOR_MIPS_R2000:
+	case PROCESSOR_MIPS_R2000:
-s = "r2000";
+	    s = "r2000";
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_MIPS_R3000
-case PROCESSOR_MIPS_R3000:
+	case PROCESSOR_MIPS_R3000:
-s = "r3000";
+	    s = "r3000";
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_MIPS_R4000
-case PROCESSOR_MIPS_R4000:
+	case PROCESSOR_MIPS_R4000:
-s = "r4000";
+	    s = "r4000";
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_ALPHA_21064
-case PROCESSOR_ALPHA_21064:
+	case PROCESSOR_ALPHA_21064:
-s = "alpha21064";
+	    s = "alpha21064";
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_ARM720
-case PROCESSOR_ARM720:
+	case PROCESSOR_ARM720:
-s = "arm720";
+	    s = "arm720";
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_ARM820
-case PROCESSOR_ARM820:
+	case PROCESSOR_ARM820:
-s = "arm820";
+	    s = "arm820";
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_ARM920
-case PROCESSOR_ARM920:
+	case PROCESSOR_ARM920:
-s = "arm920";
+	    s = "arm920";
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_ARM_7TDMI
-case PROCESSOR_ARM_7TDMI:
+	case PROCESSOR_ARM_7TDMI:
-s = "arm70001";
+	    s = "arm70001";
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_PPC_601
-case PROCESSOR_PPC_601:
+	case PROCESSOR_PPC_601:
-s = "ppc601";
+	    s = "ppc601";
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_PPC_603
-case PROCESSOR_PPC_603:
+	case PROCESSOR_PPC_603:
-s = "ppc603";
+	    s = "ppc603";
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_PPC_604
-case PROCESSOR_PPC_604:
+	case PROCESSOR_PPC_604:
-s = "ppc604";
+	    s = "ppc604";
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_PPC_620
-case PROCESSOR_PPC_620:
+	case PROCESSOR_PPC_620:
-s = "ppc620";
+	    s = "ppc620";
-break;
+	    break;
 #endif
-default:
+	default:
-sprintf(vsnBuffer, "%d", sysInfo.dwProcessorType);
+	    sprintf(vsnBuffer, "%d", sysInfo.dwProcessorType);
-s = vsnBuffer;
+	    s = vsnBuffer;
-break;
+	    break;
 }
 mach = __MKSTRING(s);
 numberOfCPUs = __MKUINT(sysInfo.dwNumberOfProcessors);
 %}.
 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 := 'unknown'.
+	arch := 'unknown'.
 ].
 info := IdentityDictionary new.
 info at:#system put:sys.
 info at:#node put:node.
 %{
 char buffer[MAXPATHLEN];
 if (GetWindowsDirectory(buffer, MAXPATHLEN)) {
-RETURN (__MKSTRING(buffer));
+	RETURN (__MKSTRING(buffer));
 }
 %}.
 ^ nil
 "
 %{
 char buffer[MAXPATHLEN];
 if (GetSystemDirectory(buffer, MAXPATHLEN)) {
-RETURN (__MKSTRING(buffer));
+	RETURN (__MKSTRING(buffer));
 }
 %}.
 ^ nil
 "
 isMSWINDOWSNTlike
 "This returns true if running in a Windows-NT system."
 %{   /* NOCONTEXT */
 if (__isWinNT)
-RETURN(true);
+	RETURN(true);
 %}.
 ^ false.
 !
 isMSWINDOWSlike
 !
 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: newer systems provide a query function for this ... use it
 HINSTANCE hNetApi32 = LoadLibrary("netapi32.dll");
 DWORD (__stdcall *pfnNetApiBufferFree)(LPVOID Buffer);
 DWORD (__stdcall *pfnNetWkstaGetInfo)(LPWSTR servername, DWORD level, void *bufptr);
 if (hNetApi32) {
-pfnNetApiBufferFree = (DWORD (__stdcall *)(void *)) GetProcAddress(hNetApi32, "NetApiBufferFree");
+	pfnNetApiBufferFree = (DWORD (__stdcall *)(void *)) GetProcAddress(hNetApi32, "NetApiBufferFree");
-pfnNetWkstaGetInfo = (DWORD (__stdcall *)(LPWSTR, DWORD, void *)) GetProcAddress(hNetApi32, "NetWkstaGetInfo");
+	pfnNetWkstaGetInfo = (DWORD (__stdcall *)(LPWSTR, DWORD, void *)) GetProcAddress(hNetApi32, "NetWkstaGetInfo");
 }
 if (hNetApi32 && pfnNetWkstaGetInfo && pfnNetApiBufferFree) {
-/* this way is more reliable, in case user has a local account. */
+	/* this way is more reliable, in case user has a local account. */
-char dname[256];
+	char dname[256];
-DWORD dnamelen = sizeof(dname);
+	DWORD dnamelen = sizeof(dname);
-struct {
+	struct {
-DWORD   wki100_platform_id;
+	    DWORD   wki100_platform_id;
-LPWSTR  wki100_computername;
+	    LPWSTR  wki100_computername;
-LPWSTR  wki100_langroup;
+	    LPWSTR  wki100_langroup;
-DWORD   wki100_ver_major;
+	    DWORD   wki100_ver_major;
-DWORD   wki100_ver_minor;
+	    DWORD   wki100_ver_minor;
-} *pwi;
+	} *pwi;
-/* NERR_Success *is* 0*/
+	/* NERR_Success *is* 0*/
-if (0 == pfnNetWkstaGetInfo(NULL, 100, &pwi)) {
+	if (0 == pfnNetWkstaGetInfo(NULL, 100, &pwi)) {
-if (pwi->wki100_langroup && *(pwi->wki100_langroup)) {
+	    if (pwi->wki100_langroup && *(pwi->wki100_langroup)) {
-WideCharToMultiByte(CP_ACP, NULL, pwi->wki100_langroup,
+		WideCharToMultiByte(CP_ACP, NULL, pwi->wki100_langroup,
--1, (LPSTR)dname, dnamelen, NULL, NULL);
+				    -1, (LPSTR)dname, dnamelen, NULL, NULL);
-}
+	    }
-else {
+	    else {
-WideCharToMultiByte(CP_ACP, NULL, pwi->wki100_computername,
+		WideCharToMultiByte(CP_ACP, NULL, pwi->wki100_computername,
--1, (LPSTR)dname, dnamelen, NULL, NULL);
+				    -1, (LPSTR)dname, dnamelen, NULL, NULL);
-}
+	    }
-pfnNetApiBufferFree(pwi);
+	    pfnNetApiBufferFree(pwi);
-FreeLibrary(hNetApi32);
+	    FreeLibrary(hNetApi32);
-RETURN (__MKSTRING(dname));
+	    RETURN (__MKSTRING(dname));
-}
+	}
-FreeLibrary(hNetApi32);
+	FreeLibrary(hNetApi32);
 } else {
-/* Win95 doesn't have NetWksta*(), so do it the old way */
+	/* Win95 doesn't have NetWksta*(), so do it the old way */
-char name[256];
+	char name[256];
-DWORD size = sizeof(name);
+	DWORD size = sizeof(name);
-if (hNetApi32)
+	if (hNetApi32)
-FreeLibrary(hNetApi32);
+	    FreeLibrary(hNetApi32);
-if (GetUserName(name,&size)) {
+	if (GetUserName(name,&size)) {
-char sid[1024];
+	    char sid[1024];
-DWORD sidlen = sizeof(sid);
+	    DWORD sidlen = sizeof(sid);
-char dname[256];
+	    char dname[256];
-DWORD dnamelen = sizeof(dname);
+	    DWORD dnamelen = sizeof(dname);
-SID_NAME_USE snu;
+	    SID_NAME_USE snu;
-if (LookupAccountName(NULL, name, (PSID)&sid, &sidlen,
+	    if (LookupAccountName(NULL, name, (PSID)&sid, &sidlen,
-dname, &dnamelen, &snu)) {
+				  dname, &dnamelen, &snu)) {
-RETURN (__MKSTRING(dname));             /* all that for this */
+		RETURN (__MKSTRING(dname));             /* all that for this */
-}
+	    }
-}
+	}
 }
 #endif /* not needed */
 %}.
 ^ nil
 !
 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, 'unknown' is returned."
+	not all systems support this; on some, 'unknown' is returned."
 |name|
 %{  /* STACK: 2048 */
 #if defined(HAS_GETHOSTNAME)
 char buffer[256];
 if (gethostname(buffer, sizeof(buffer)) == 0) {
-name = __MKSTRING(buffer);
+	name = __MKSTRING(buffer);
 }
 #else
 char buffer[128];
 DWORD buffSize = sizeof(buffer);
 if (GetComputerName(buffer, &buffSize) == TRUE) {
-name = __MKSTRING(buffer);
+	name = __MKSTRING(buffer);
 }
 #endif
 %}.
 name isNil ifTrue:[
-name := self getEnvironment:'HOST'.
+	name := self getEnvironment:'HOST'.
-name isNil ifTrue:[
+	name isNil ifTrue:[
-name := self getEnvironment:'HOSTNAME'.
+	    name := self getEnvironment:'HOSTNAME'.
-name isNil ifTrue:[
+	    name isNil ifTrue:[
-name := self getEnvironment:'COMPUTERNAME'.
+		name := self getEnvironment:'COMPUTERNAME'.
-name isNil ifTrue:[
+		name isNil ifTrue:[
-'Win32OperatingSystem [warning]: cannot find out hostname' errorPrintCR.
+		    'Win32OperatingSystem [warning]: cannot find out hostname' errorPrintCR.
-name := 'unknown'.
+		    name := 'unknown'.
-]
+		]
-]
+	    ]
-]
+	]
 ].
 ^ name
 "
 OperatingSystem primGetHostName
 |pPath pkgDirPath dirs p|
 pPath := super defaultPackagePath.
 pkgDirPath := self stxPackageDirPath.
 pkgDirPath notNil ifTrue:[
-"/ and also add the packageDirPath from the registry ...
+	"/ and also add the packageDirPath from the registry ...
-dirs := pkgDirPath asCollectionOfSubstringsSeparatedBy:$;.
+	dirs := pkgDirPath asCollectionOfSubstringsSeparatedBy:$;.
-dirs do:[:aDir |
+	dirs do:[:aDir |
-(pPath includes:aDir) ifFalse:[
+	    (pPath includes:aDir) ifFalse:[
-pPath add:aDir.
+		pPath add:aDir.
-]
+	    ]
-]
+	]
 ] ifFalse:[
-#(
+	#(
-'\smalltalk'
+	    '\smalltalk'
-'\programme\smalltalk'
+	    '\programme\smalltalk'
-'\programme\eXept\smalltalk'
+	    '\programme\eXept\smalltalk'
-'\programs\smalltalk'
+	    '\programs\smalltalk'
-'\programs\eXept\smalltalk'
+	    '\programs\eXept\smalltalk'
-) do:[:d | |dd|
+	) do:[:d | |dd|
-dd := d asFilename constructString:'packages'.
+	    dd := d asFilename constructString:'packages'.
-(pPath includes:dd) ifFalse:[
+	    (pPath includes:dd) ifFalse:[
-pPath add:dd.
+		pPath add:dd.
-].
+	    ].
-dd := (d asFilename construct:Smalltalk versionString) constructString:'packages'.
+	    dd := (d asFilename construct:Smalltalk versionString) constructString:'packages'.
-(pPath includes:dd) ifFalse:[
+	    (pPath includes:dd) ifFalse:[
-pPath add:dd.
+		pPath add:dd.
-].
+	    ].
-].
+	].
 ].
 "/ under windows, the commandName includes the path - good.
 p := Smalltalk commandName.
 p notNil ifTrue:[
-p := p asFilename directory constructString:'packages'.
+	p := p asFilename directory constructString:'packages'.
-(pPath includes:p) ifFalse:[
+	(pPath includes:p) ifFalse:[
-pPath add:p.
+	    pPath add:p.
-]
+	]
 ].
 pPath := pPath select:[:p | p asFilename exists].
 ^ pPath
 "
 sysPath := super defaultSystemPath.
 libDirPath := self stxLibDirPath.
 libDirPath notNil ifTrue:[
-"/ and also add the libDirPath from the registry ...
+	"/ and also add the libDirPath from the registry ...
-(sysPath includes:libDirPath) ifFalse:[
+	(sysPath includes:libDirPath) ifFalse:[
-sysPath add:libDirPath
+	    sysPath add:libDirPath
-].
+	].
 ].
 #(
-'\programs\eXept\smalltalk'
+	'\programs\eXept\smalltalk'
-'\programme\eXept\smalltalk'
+	'\programme\eXept\smalltalk'
-'\programs\smalltalk'
+	'\programs\smalltalk'
-'\programme\smalltalk'
+	'\programme\smalltalk'
-'\smalltalk'
+	'\smalltalk'
 ) do:[:dir |
-|vsnDir|
+	|vsnDir|
-(dir asFilename isDirectory) ifTrue:[
+	(dir asFilename isDirectory) ifTrue:[
-vsnDir := dir , '\' , Smalltalk versionString.
+	    vsnDir := dir , '\' , Smalltalk versionString.
-(vsnDir asFilename isDirectory) ifTrue:[
+	    (vsnDir asFilename isDirectory) ifTrue:[
-(sysPath includes:vsnDir) ifFalse:[
+		(sysPath includes:vsnDir) ifFalse:[
-sysPath add:vsnDir.
+		    sysPath add:vsnDir.
-]
+		]
-].
+	    ].
-(sysPath includes:dir) ifFalse:[
+	    (sysPath includes:dir) ifFalse:[
-sysPath add:dir.
+		sysPath add:dir.
-].
+	    ].
-]
+	]
 ].
 ^ sysPath
 "Modified: / 24.12.1999 / 00:29:18 / cg"
 |k p|
 k := RegistryEntry key:'HKEY_LOCAL_MACHINE\SOFTWARE\eXept\Smalltalk/X\' , Smalltalk versionString.
 k notNil ifTrue:[
-p := k valueNamed:'BinDir'.
+	p := k valueNamed:'BinDir'.
 ].
 ^ p
 "
 OperatingSystem stxBinDirPath
 stxLibDirPath
 "ask the registry for the lib directory"
 (Array
-with:('HKEY_LOCAL_MACHINE\SOFTWARE\eXept\Smalltalk/X\' , Smalltalk versionString)
+	with:('HKEY_LOCAL_MACHINE\SOFTWARE\eXept\Smalltalk/X\' , Smalltalk versionString)
-with:('HKEY_LOCAL_MACHINE\SOFTWARE\eXept\Smalltalk/X'))
+	with:('HKEY_LOCAL_MACHINE\SOFTWARE\eXept\Smalltalk/X'))
 do:[:eachKeyToTry |
-|k p|
+	|k p|
-k := RegistryEntry key:eachKeyToTry.
+	k := RegistryEntry key:eachKeyToTry.
-k notNil ifTrue:[
+	k notNil ifTrue:[
-p := k valueNamed:'LibDir'.
+	    p := k valueNamed:'LibDir'.
-k closeKey.
+	    k closeKey.
-^ p
+	    ^ p
-].
+	].
 ].
 ^ nil
 "
 OperatingSystem stxLibDirPath
 |k p|
 k := RegistryEntry key:'HKEY_LOCAL_MACHINE\SOFTWARE\eXept\Smalltalk/X\' , Smalltalk versionString.
 k notNil ifTrue:[
-p := k valueNamed:'PackageDirPath'.
+	p := k valueNamed:'PackageDirPath'.
 ].
 ^ p
 "
 OperatingSystem stxPackageDirPath
 #define DM_IN_PROMPT        DM_PROMPT
 #define DM_OUT_BUFFER       DM_COPY
 #define DM_OUT_DEFAULT      DM_UPDATE
 "
 nBytesNeeded := self
-primDocumentProperties:nil
+	   primDocumentProperties:nil
-hPrinter:hPrinter
+	   hPrinter:hPrinter
-pDeviceName: deviceName
+	   pDeviceName: deviceName
-pDevModeOutput:nil
+	   pDevModeOutput:nil
-pDevModeInput:nil
+	   pDevModeInput:nil
-fMode:0.
+	   fMode:0.
 devModeOutput := DevModeStructure new:(nBytesNeeded * 2 "never trust MS !!").
 rslt := self
-primDocumentProperties:nil
+	   primDocumentProperties:nil
-hPrinter:hPrinter
+	   hPrinter:hPrinter
-pDeviceName: deviceName
+	   pDeviceName: deviceName
-pDevModeOutput:devModeOutput
+	   pDevModeOutput:devModeOutput
-pDevModeInput:pDevModeInputOrNil
+	   pDevModeInput:pDevModeInputOrNil
-fMode:4+2.
+	   fMode:4+2.
 ^ devModeOutput
 "
 |h|
 #define DM_IN_PROMPT        DM_PROMPT
 #define DM_OUT_BUFFER       DM_COPY
 #define DM_OUT_DEFAULT      DM_UPDATE
 "
 nBytesNeeded := self
-primDocumentProperties:nil
+	   primDocumentProperties:nil
-hPrinter:hPrinter
+	   hPrinter:hPrinter
-pDeviceName: deviceName
+	   pDeviceName: deviceName
-pDevModeOutput:nil
+	   pDevModeOutput:nil
-pDevModeInput:nil
+	   pDevModeInput:nil
-fMode:0.
+	   fMode:0.
 nBytesNeeded < 0 ifTrue:[^nil].
 devModeOutput := DevModeStructure new:(nBytesNeeded * 2 "never trust MS !!").
 rslt := self
-primDocumentProperties:nil
+	   primDocumentProperties:nil
-hPrinter:hPrinter
+	   hPrinter:hPrinter
-pDeviceName: deviceName
+	   pDeviceName: deviceName
-pDevModeOutput:devModeOutput
+	   pDevModeOutput:devModeOutput
-pDevModeInput:nil
+	   pDevModeInput:nil
-fMode:2.
+	   fMode:2.
 ^ devModeOutput
 "
 |h|
 hPrinter := self openPrinter: printerName .
 sizeBytesArray := ByteArray new:4.
 bytesNeeded := self
-primGetPrinter:hPrinter
+		primGetPrinter:hPrinter
-level:2
+		level:2
-informationBuffer: nil
+		informationBuffer: nil
-bufferSize: 0
+		bufferSize: 0
-bufferNeededSize:sizeBytesArray.
+		bufferNeededSize:sizeBytesArray.
 bytesNeeded := sizeBytesArray longAt:1.
 informationBuffer := PrinterInfo2Structure new: bytesNeeded.
 rslt := self
-primGetPrinter:hPrinter
+		primGetPrinter:hPrinter
-level:2
+		level:2
-informationBuffer:informationBuffer
+		informationBuffer:informationBuffer
-bufferSize: bytesNeeded
+		bufferSize: bytesNeeded
-bufferNeededSize:sizeBytesArray.
+		bufferNeededSize:sizeBytesArray.
 self closePrinter: printerName.
 ^informationBuffer
 "
 OperatingSystem getPrinterInfo2:(OperatingSystem getDefaultPrinterName)
 |printerNames collectedInfo|
 printerNames := self getPrintersNames.
 collectedInfo := OrderedCollection new.
 printerNames do:[:eachName |
-|fn vol attributes nm deviceInfo infoFields driverName|
+	|fn vol attributes nm deviceInfo infoFields driverName|
-attributes := Dictionary new.
+	attributes := Dictionary new.
-fn := eachName asFilename.
+	fn := eachName asFilename.
-vol := fn volume.
+	vol := fn volume.
-vol notEmptyOrNil ifTrue:[
+	vol notEmptyOrNil ifTrue:[
-(vol startsWith:'\\') ifTrue:[
+	    (vol startsWith:'\\') ifTrue:[
-"/ a remote printer
+		"/ a remote printer
-attributes at:#isRemotePrinter put:true.
+		attributes at:#isRemotePrinter put:true.
-attributes at:#remotePrinterName put:(fn baseName).
+		attributes at:#remotePrinterName put:(fn baseName).
-attributes at:#remotePrinterHost put:(fn directoryName copyFrom:3).
+		attributes at:#remotePrinterHost put:(fn directoryName copyFrom:3).
-] ifFalse:[
+	    ] ifFalse:[
-"/ some other printer
+		"/ some other printer
-].
+	    ].
-] ifFalse:[
+	] ifFalse:[
-"/ some other printer
+	    "/ some other printer
-].
+	].
-deviceInfo := self getProfileString:'PrinterPorts' key:eachName default:''.
+	deviceInfo := self getProfileString:'PrinterPorts' key:eachName default:''.
-"gives us smething like 'winspool,Ne00:,15,45',
+	"gives us smething like 'winspool,Ne00:,15,45',
-which is: driverName, deviceName, ? , ?"
+	 which is: driverName, deviceName, ? , ?"
-infoFields := deviceInfo asCollectionOfSubstringsSeparatedBy:$,.
+	infoFields := deviceInfo asCollectionOfSubstringsSeparatedBy:$,.
-driverName := infoFields at:1.
+	driverName := infoFields at:1.
-2 to: infoFields size by:3 do:[:i |
+	2 to: infoFields size by:3 do:[:i |
-|medium longName|
+	    |medium longName|
-medium := infoFields at:i.
+	    medium := infoFields at:i.
-longName := eachName ,',' , driverName , ',' , medium.
+	    longName := eachName ,',' , driverName , ',' , medium.
-attributes at:#driverName put:driverName.
+	    attributes at:#driverName put:driverName.
-attributes at:#longName put:longName.
+	    attributes at:#longName put:longName.
-attributes at:#medium put:medium.
+	    attributes at:#medium put:medium.
-collectedInfo add:
+	    collectedInfo add:
-(AbstractOperatingSystem::PrinterInfo new
+		(AbstractOperatingSystem::PrinterInfo new
-printerName:eachName
+		    printerName:eachName
-attributes:attributes;
+		    attributes:attributes;
-setDocumentProperties;
+		    setDocumentProperties;
-yourself)
+		    yourself)
-].
+	].
 ].
 ^ collectedInfo
 "
 OperatingSystem getPrinters
 "return a collection of Printer names"
 |printerNames|
 printerNames := (self getProfileString:'PrinterPorts' key:nil default:'')
-asCollectionOfSubstringsSeparatedBy:(Character value:0).
+		       asCollectionOfSubstringsSeparatedBy:(Character value:0).
 printerNames := printerNames reject:[:nm | nm isEmpty].
 ^printerNames
 "
 OperatingSystem getPrintersNames
 "
 |hPrinter rslt|
 hPrinter := self openPrinter:'\\http://exept.exept.de:631\lj4' .
 rslt := self
-primDocumentProperties:nil
+	    primDocumentProperties:nil
-hPrinter:hPrinter
+	    hPrinter:hPrinter
-pDeviceName: '\\http://exept.exept.de:631\lj4'
+	    pDeviceName: '\\http://exept.exept.de:631\lj4'
-pDevModeOutput:nil
+	    pDevModeOutput:nil
-pDevModeInput:nil
+	    pDevModeInput:nil
-fMode:0.
+	    fMode:0.
 self halt.
 "
 "Created: / 27-07-2006 / 15:02:14 / fm"
 "
 |hPrinter rslt|
 hPrinter := self openPrinter:'\\http://exept.exept.de:631\lj4' .
 rslt := self
-primDocumentProperties:nil
+	    primDocumentProperties:nil
-hPrinter:hPrinter
+	    hPrinter:hPrinter
-pDeviceName: '\\http://exept.exept.de:631\lj4'
+	    pDeviceName: '\\http://exept.exept.de:631\lj4'
-pDevModeOutput:nil
+	    pDevModeOutput:nil
-pDevModeInput:nil
+	    pDevModeInput:nil
-fMode:0.
+	    fMode:0.
 self halt.
 "
 "Created: / 27-07-2006 / 19:31:31 / fm"
 "
 |hPrinter rslt|
 hPrinter := self openPrinter:'\\http://exept.exept.de:631\lj4' .
 rslt := self
-primDocumentProperties:nil
+	    primDocumentProperties:nil
-hPrinter:hPrinter
+	    hPrinter:hPrinter
-pDeviceName: '\\http://exept.exept.de:631\lj4'
+	    pDeviceName: '\\http://exept.exept.de:631\lj4'
-pDevModeOutput:nil
+	    pDevModeOutput:nil
-pDevModeInput:nil
+	    pDevModeInput:nil
-fMode:0.
+	    fMode:0.
 self halt.
 "
 "Created: / 27-07-2006 / 19:30:50 / fm"
 printerName := '\\http://exept.exept.de:631\lj4'.
 hPrinter := self openPrinter: printerName .
 sizeBytesArray := ByteArray new:4.
 ok := self
-primGetPrinter:hPrinter
+		primGetPrinter:hPrinter
-level:2
+		level:2
-informationBuffer: nil
+		informationBuffer: nil
-bufferSize: 0
+		bufferSize: 0
-bufferNeededSize:sizeBytesArray.
+		bufferNeededSize:sizeBytesArray.
 bytesNeeded := sizeBytesArray longAt:1.
 informationBuffer := PrinterInfo2Structure new: bytesNeeded.
 rslt := self
-primGetPrinter:hPrinter
+		primGetPrinter:hPrinter
-level:2
+		level:2
-informationBuffer:informationBuffer
+		informationBuffer:informationBuffer
-bufferSize: bytesNeeded
+		bufferSize: bytesNeeded
-bufferNeededSize:sizeBytesArray.
+		bufferNeededSize:sizeBytesArray.
 self assert: rslt.
 informationBuffer inspect.
 self closePrinter: printerName.
 "
 'CSY'     'cs_CS'
 'ELL'     'el_EL'
 'NON'     'no_NO'
 'NOR'     'no_NO'
 ) pairWiseDo:[:key :mappedValue|
-key = windowsLanguageString ifTrue:[
+	key = windowsLanguageString ifTrue:[
-^ mappedValue
+	    ^ mappedValue
-]
+	]
 ].
 "no mapping"
 ^ windowsLanguageString.
 |errorNumber|
 "
 HINSTANCE ShellExecute(
-HWND hwnd,                      // handle to parent window
+	     HWND hwnd,                      // handle to parent window
-LPCTSTR lpOperation,    // pointer to string that specifies operation to perform
+	     LPCTSTR lpOperation,    // pointer to string that specifies operation to perform
-LPCTSTR lpFile,         // pointer to filename or folder name string
+	     LPCTSTR lpFile,         // pointer to filename or folder name string
-LPCTSTR lpParameters,   // pointer to string that specifies executable-file parameters
+	     LPCTSTR lpParameters,   // pointer to string that specifies executable-file parameters
-LPCTSTR lpDirectory,    // pointer to string that specifies default directory
+	     LPCTSTR lpDirectory,    // pointer to string that specifies default directory
-INT nShowCmd                    // whether file is shown when opened
+	     INT nShowCmd                    // whether file is shown when opened
 );
 "
 "/  <apicall: long 'ShellExecuteA' (long char* char* char* char* ulong) module:'shell32.dll'>
 %{
 unsigned long __nShowCmd = 0;
 if (__isSmallInteger(nShowCmd)) {
-__nShowCmd = __intVal(nShowCmd);
+	__nShowCmd = __intVal(nShowCmd);
 } else {
-if (nShowCmd == @symbol(SW_SHOW)) {
+	if (nShowCmd == @symbol(SW_SHOW)) {
-__nShowCmd = SW_SHOW;
+	    __nShowCmd = SW_SHOW;
-} else if (nShowCmd == @symbol(SW_SHOWNORMAL)) {
+	} else if (nShowCmd == @symbol(SW_SHOWNORMAL)) {
-__nShowCmd = SW_SHOWNORMAL;
+	    __nShowCmd = SW_SHOWNORMAL;
-} else if (nShowCmd == @symbol(SW_SHOWDEFAULT)) {
+	} else if (nShowCmd == @symbol(SW_SHOWDEFAULT)) {
-__nShowCmd = SW_SHOWDEFAULT;
+	    __nShowCmd = SW_SHOWDEFAULT;
-} else if (nShowCmd == @symbol(SW_SHOWMAXIMIZED)) {
+	} else if (nShowCmd == @symbol(SW_SHOWMAXIMIZED)) {
-__nShowCmd = SW_SHOWMAXIMIZED;
+	    __nShowCmd = SW_SHOWMAXIMIZED;
-} else if (nShowCmd == @symbol(SW_SHOWMINIMIZED)) {
+	} else if (nShowCmd == @symbol(SW_SHOWMINIMIZED)) {
-__nShowCmd = SW_SHOWMINIMIZED;
+	    __nShowCmd = SW_SHOWMINIMIZED;
-} else if (nShowCmd == @symbol(SW_SHOWMINNOACTIVE)) {
+	} else if (nShowCmd == @symbol(SW_SHOWMINNOACTIVE)) {
-__nShowCmd = SW_SHOWMINNOACTIVE;
+	    __nShowCmd = SW_SHOWMINNOACTIVE;
-} else if (nShowCmd == @symbol(SW_SHOWNA)) {
+	} else if (nShowCmd == @symbol(SW_SHOWNA)) {
-__nShowCmd = SW_SHOWNA;
+	    __nShowCmd = SW_SHOWNA;
-} else if (nShowCmd == @symbol(SW_SHOWNOACTIVATE)) {
+	} else if (nShowCmd == @symbol(SW_SHOWNOACTIVATE)) {
-__nShowCmd = SW_SHOWNOACTIVATE;
+	    __nShowCmd = SW_SHOWNOACTIVATE;
-} else if (nShowCmd == @symbol(SW_MAXIMIZE)) {
+	} else if (nShowCmd == @symbol(SW_MAXIMIZE)) {
-__nShowCmd = SW_MAXIMIZE;
+	    __nShowCmd = SW_MAXIMIZE;
-} else if (nShowCmd == @symbol(SW_RESTORE)) {
+	} else if (nShowCmd == @symbol(SW_RESTORE)) {
-__nShowCmd = SW_RESTORE;
+	    __nShowCmd = SW_RESTORE;
-} else {
+	} else {
-goto badArgument;
+	    goto badArgument;
-}
+	}
 }
 if (((lpOperation == nil) || __isString(lpOperation))
 && ((lpFile == nil) || __isString(lpFile))
 && ((lpParameters == nil) || __isString(lpParameters))
 && ((lpDirectory == nil) || __isString(lpDirectory))
 ) {
-HANDLE __hwnd = 0;
+	HANDLE __hwnd = 0;
-char *__lpOperation   = (lpOperation != nil) ? __stringVal(lpOperation) : NULL;
+	char *__lpOperation   = (lpOperation != nil) ? __stringVal(lpOperation) : NULL;
-char *__lpFile        = (lpFile != nil) ? __stringVal(lpFile) : NULL;
+	char *__lpFile        = (lpFile != nil) ? __stringVal(lpFile) : NULL;
-char *__lpParameters  = (lpParameters != nil) ? __stringVal(lpParameters) : NULL;
+	char *__lpParameters  = (lpParameters != nil) ? __stringVal(lpParameters) : NULL;
-char *__lpDirectory   = (lpDirectory != nil) ? __stringVal(lpDirectory) : NULL;
+	char *__lpDirectory   = (lpDirectory != nil) ? __stringVal(lpDirectory) : NULL;
-long result;
+	long result;
-if (hwnd != nil) {
+	if (hwnd != nil) {
-if (__isExternalAddressLike(hwnd)) {
+	    if (__isExternalAddressLike(hwnd)) {
-__hwnd = (HANDLE)(__externalAddressVal(hwnd));
+		__hwnd = (HANDLE)(__externalAddressVal(hwnd));
-} else
+	    } else
-goto badArgument;
+		goto badArgument;
-}
+	}
-result = ShellExecuteA(__hwnd, __lpOperation, __lpFile, __lpParameters, __lpDirectory, __nShowCmd);
+	result = ShellExecuteA(__hwnd, __lpOperation, __lpFile, __lpParameters, __lpDirectory, __nShowCmd);
-/* MS programmers are brain damaged - here's the proof... */
+	/* MS programmers are brain damaged - here's the proof... */
-if (result > 32) {
+	if (result > 32) {
-RETURN ( self ); /* OK */
+	    RETURN ( self ); /* OK */
-}
+	}
-switch (result) {
+	switch (result) {
-case 0:
+	    case 0:
-case SE_ERR_OOM:
+	    case SE_ERR_OOM:
-result = ERROR_NOT_ENOUGH_MEMORY;
+		result = ERROR_NOT_ENOUGH_MEMORY;
-break;
+		break;
-case SE_ERR_ACCESSDENIED:
+	    case SE_ERR_ACCESSDENIED:
-result = ERROR_ACCESS_DENIED;
+		result = ERROR_ACCESS_DENIED;
-break;
+		break;
-case SE_ERR_FNF:
+	    case SE_ERR_FNF:
-result = ERROR_FILE_NOT_FOUND;
+		result = ERROR_FILE_NOT_FOUND;
-break;
+		break;
-case SE_ERR_PNF:
+	    case SE_ERR_PNF:
-result = ERROR_PATH_NOT_FOUND;
+		result = ERROR_PATH_NOT_FOUND;
-break;
+		break;
-default:
+	    default:
-result = ERROR_INVALID_FUNCTION;
+		result = ERROR_INVALID_FUNCTION;
-break;
+		break;
-}
+	}
-errorNumber = __MKUINT( result );
+	errorNumber = __MKUINT( result );
 }
 badArgument: ;
 %}.
 errorNumber isNil ifTrue:[
-self error:'invalid argument(s)'.
+	self error:'invalid argument(s)'.
 ] ifFalse:[
-(OperatingSystem errorHolderForNumber:errorNumber) reportError
+	(OperatingSystem errorHolderForNumber:errorNumber) reportError
 ].
 "
 self
-shellExecute:nil
+	shellExecute:nil
-lpOperation:'open'
+	lpOperation:'open'
-lpFile:(Filename currentDirectory pathName)
+	lpFile:(Filename currentDirectory pathName)
-lpParameters:nil
+	lpParameters:nil
-lpDirectory:(Filename currentDirectory pathName)
+	lpDirectory:(Filename currentDirectory pathName)
-nShowCmd:#SW_SHOWNORMAL
+	nShowCmd:#SW_SHOWNORMAL
 self
-shellExecute:nil
+	shellExecute:nil
-lpOperation:'explore'
+	lpOperation:'explore'
-lpFile:(Filename currentDirectory pathName)
+	lpFile:(Filename currentDirectory pathName)
-lpParameters:nil
+	lpParameters:nil
-lpDirectory:(Filename currentDirectory pathName)
+	lpDirectory:(Filename currentDirectory pathName)
-nShowCmd:#SW_SHOWNORMAL
+	nShowCmd:#SW_SHOWNORMAL
 "
 "Modified: / 26-01-2007 / 14:29:21 / cg"
 ! !
 since my windows system menu crashes so often
 (even CTRL-ALT-DEL does no longer function, but ST/X is still alive),
 I added this in order to be able to shutdown w95 cleanly"
 confirmationMessageOrNil notNil ifTrue:[
-(Dialog confirm:confirmationMessageOrNil) ifFalse:[
+	(Dialog confirm:confirmationMessageOrNil) ifFalse:[
-^ false
+	    ^ false
-].
+	].
 ].
 %{
 int flag;
 if (how == @symbol(shutdown)) {
-flag = EWX_SHUTDOWN;
+	flag = EWX_SHUTDOWN;
 } else if (how == @symbol(reboot)) {
-flag = EWX_REBOOT;
+	flag = EWX_REBOOT;
 } else if (how == @symbol(logoff)) {
-flag = EWX_LOGOFF;
+	flag = EWX_LOGOFF;
 } else if (how == @symbol(forceShutdown)) {
-flag = EWX_SHUTDOWN | EWX_FORCE;
+	flag = EWX_SHUTDOWN | EWX_FORCE;
 } else if (how == @symbol(forceReboot)) {
-flag = EWX_REBOOT | EWX_FORCE;
+	flag = EWX_REBOOT | EWX_FORCE;
 } else if (how == @symbol(forceLogoff)) {
-flag = EWX_LOGOFF | EWX_FORCE;
+	flag = EWX_LOGOFF | EWX_FORCE;
 } else {
-RETURN (false);
+	RETURN (false);
 }
 RETURN ((ExitWindowsEx(flag, 0) == TRUE) ? true : false);
 %}
 ! !
 #ifdef __BORLANDC__
 tmPtr = localtime(&tt);
 #else
 /* be thread safe */
 if (localtime_s(&tmValue, &tt) == 0)
-tmPtr = &tmValue;
+	tmPtr = &tmValue;
 else
-tmPtr = NULL;
+	tmPtr = NULL;
 #endif
 if (tmPtr != NULL) {
-year = __mkSmallInteger(tmPtr->tm_year + 1900);
+	year = __mkSmallInteger(tmPtr->tm_year + 1900);
-month = __mkSmallInteger(tmPtr->tm_mon + 1);
+	month = __mkSmallInteger(tmPtr->tm_mon + 1);
-day = __mkSmallInteger(tmPtr->tm_mday);
+	day = __mkSmallInteger(tmPtr->tm_mday);
 }
 %}.
 year isNil ifTrue:[
-self primitiveFailed
+	self primitiveFailed
 ].
 aBlock value:year value:month value:day
 "
 OperatingSystem computeDatePartsOf:0 for:[:y :m :d |
-y printCR. m printCR. d printCR
+	y printCR. m printCR. d printCR
 ]
 "
 "Modified: / 06-07-2006 / 18:18:04 / cg"
 !
 struct tm tm;
 if (__bothSmallInteger(y, m)
 && __bothSmallInteger(d, h)
 && __bothSmallInteger(min, s)) {
-time_t t;
+	time_t t;
-TIME_ZONE_INFORMATION tzInfo;
+	TIME_ZONE_INFORMATION tzInfo;
-int gmtoffMinutes;
+	int gmtoffMinutes;
-if (GetTimeZoneInformation(&tzInfo) < 0) goto error;
+	if (GetTimeZoneInformation(&tzInfo) < 0) goto error;
-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;
-t = mktime(&tm);
+	t = mktime(&tm);
-gmtoffMinutes = tzInfo.Bias;
+	gmtoffMinutes = tzInfo.Bias;
-if (tm.tm_isdst) {
+	if (tm.tm_isdst) {
-gmtoffMinutes += tzInfo.DaylightBias;
+	    gmtoffMinutes += tzInfo.DaylightBias;
-} else {
+	} else {
-gmtoffMinutes += tzInfo.StandardBias;
+	    gmtoffMinutes += tzInfo.StandardBias;
-}
+	}
-t = t - gmtoffMinutes*60;
+	t = t - gmtoffMinutes*60;
-osSeconds = __MKUINT((INT)t);
+	osSeconds = __MKUINT((INT)t);
 }
 error:;
 %}.
 osSeconds notNil ifTrue:[
-^ osSeconds * 1000 + millis
+	^ osSeconds * 1000 + millis
 ].
 ^ self primitiveFailed
 "
 OperatingSystem computeOSTimeFromUTCYear:1970 month:1 day:1 hour:0 minute:0 second:0 millisecond:0
 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;
-t = mktime(&tm);
+	t = mktime(&tm);
-osSeconds = __MKUINT((INT)t);
+	osSeconds = __MKUINT((INT)t);
 }
 %}.
 osSeconds notNil ifTrue:[
-^ osSeconds * 1000 + millis
+	^ osSeconds * 1000 + millis
 ].
 ^ self primitiveFailed
 "
 OperatingSystem computeOSTimeFromYear:1970 month:1 day:1 hour:0 minute:0 seconds:0 millis:0
 #ifdef __BORLANDC__
 tmPtr = localtime(&tt);
 #else
 /* be thread safe */
 if (localtime_s(&tmValue, &tt) == 0)
-tmPtr = &tmValue;
+	tmPtr = &tmValue;
 else
-tmPtr = NULL;
+	tmPtr = NULL;
 #endif
 if (tmPtr != NULL) {
-hours = __mkSmallInteger(tmPtr->tm_hour);
+	hours = __mkSmallInteger(tmPtr->tm_hour);
-minutes = __mkSmallInteger(tmPtr->tm_min);
+	minutes = __mkSmallInteger(tmPtr->tm_min);
-seconds = __mkSmallInteger(tmPtr->tm_sec);
+	seconds = __mkSmallInteger(tmPtr->tm_sec);
 }
 %}.
 hours isNil ifTrue:[
-self primitiveFailed
+	self primitiveFailed
 ].
 aBlock value:hours value:minutes value:seconds value:millis
 "
 OperatingSystem computeTimePartsOf:100 for:[:h :m :s :milli |
-h printCR. m printCR. s printCR. millis printCR
+	h printCR. m printCR. s printCR. millis printCR
 ]
 "
 "Modified: / 06-07-2006 / 18:18:39 / cg"
 !
 #ifdef WINDOWS_IS_POSIX_CONFORM_WHICH_IT_IS_NOT
 utcOffset = __MKINT(tmPtr->tm_gmtoff);
 #else
 {
-TIME_ZONE_INFORMATION tzInfo;
+	TIME_ZONE_INFORMATION tzInfo;
-int gmtoffMinutes = 0;
+	int gmtoffMinutes = 0;
-if (GetTimeZoneInformation(&tzInfo) < 0) goto error;
+	if (GetTimeZoneInformation(&tzInfo) < 0) goto error;
-gmtoffMinutes = tzInfo.Bias;
+	gmtoffMinutes = tzInfo.Bias;
-if (tmPtr->tm_isdst) {
+	if (tmPtr->tm_isdst) {
-gmtoffMinutes += tzInfo.DaylightBias;
+	    gmtoffMinutes += tzInfo.DaylightBias;
-} else {
+	} else {
-gmtoffMinutes += tzInfo.StandardBias;
+	    gmtoffMinutes += tzInfo.StandardBias;
-}
+	}
-utcOffset = __MKINT(gmtoffMinutes*60);
+	utcOffset = __MKINT(gmtoffMinutes*60);
 }
 #endif
 error:;
 %}.
 "I would love to have SELF-like inline objects ..."
 Since this value is wrapping around in regular intervals, this can only be used for
 short relative time deltas.
 Use the millisecondTimeXXX:-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.
 Dont use this method in application code since it is an internal (private)
 interface. For compatibility with ST-80, use Time millisecondClockValue.
 "
 only the calling thread sleep)."
 %{  /* NOCONTEXT */
 if (__isSmallInteger(numberOfSeconds)) {
-sleep(__intVal(numberOfSeconds));
+	sleep(__intVal(numberOfSeconds));
-RETURN ( self );
+	RETURN ( self );
 }
 %}.
 "
 argument not integer
 "
 t = __longIntVal(osSeconds);
 /* try cache */
 {
-OBJ lastSeconds, lastTimeInfo;
+	OBJ lastSeconds, lastTimeInfo;
-lastSeconds = @global(LastTimeInfoSeconds);
+	lastSeconds = @global(LastTimeInfoSeconds);
-if (lastSeconds
+	if (lastSeconds
-&& (__longIntVal(lastSeconds) == t)
+	 && (__longIntVal(lastSeconds) == t)
-&& (@global(LastTimeInfoMilliseconds) == osMilliseconds)
+	 && (@global(LastTimeInfoMilliseconds) == osMilliseconds)
-&& (@global(LastTimeInfoIsLocal) == isLocalTime)
+	 && (@global(LastTimeInfoIsLocal) == isLocalTime)
-) {
+	) {
-lastTimeInfo = @global(LastTimeInfo);
+	    lastTimeInfo = @global(LastTimeInfo);
-if (lastTimeInfo != nil) {
+	    if (lastTimeInfo != nil) {
-RETURN (lastTimeInfo);
+		RETURN (lastTimeInfo);
-}
+	    }
-}
+	}
 }
 tt = (time_t)t;
 if (isLocalTime == true) {
 #ifdef __BORLANDC__
-tmPtr = localtime(&tt);
+	tmPtr = localtime(&tt);
 #else
-/* be thread safe */
+	/* be thread safe */
-if (localtime_s(&tmValue, &tt) == 0)
+	if (localtime_s(&tmValue, &tt) == 0)
-tmPtr = &tmValue;
+	    tmPtr = &tmValue;
-else
+	else
-tmPtr = NULL;
+	    tmPtr = NULL;
 #endif
-if (tmPtr == NULL) goto error;
+	if (tmPtr == NULL) goto error;
 #ifdef WINDOWS_IS_POSIX_CONFORM_WHICH_IT_IS_NOT
-utcOffset = __MKINT(tmPtr->tm_gmtoff);
+	utcOffset = __MKINT(tmPtr->tm_gmtoff);
 #else
-{
+	{
-TIME_ZONE_INFORMATION tzInfo;
+	    TIME_ZONE_INFORMATION tzInfo;
-int gmtoffMinutes = 0;
+	    int gmtoffMinutes = 0;
-if (GetTimeZoneInformation(&tzInfo) < 0) goto error;
+	    if (GetTimeZoneInformation(&tzInfo) < 0) goto error;
-gmtoffMinutes = tzInfo.Bias;
+	    gmtoffMinutes = tzInfo.Bias;
-if (tmPtr->tm_isdst) {
+	    if (tmPtr->tm_isdst) {
-gmtoffMinutes += tzInfo.DaylightBias;
+		gmtoffMinutes += tzInfo.DaylightBias;
-} else {
+	    } else {
-gmtoffMinutes += tzInfo.StandardBias;
+		gmtoffMinutes += tzInfo.StandardBias;
-}
+	    }
-utcOffset = __MKINT(gmtoffMinutes*60);
+	    utcOffset = __MKINT(gmtoffMinutes*60);
-}
+	}
 #endif
 } else {
 #ifdef __BORLANDC__
-tmPtr = gmtime(&tt);
+	tmPtr = gmtime(&tt);
 #else
-/* be thread safe */
+	/* be thread safe */
-if (gmtime_s(&tmValue, &tt) == 0)
+	if (gmtime_s(&tmValue, &tt) == 0)
-tmPtr = &tmValue;
+	    tmPtr = &tmValue;
-else
+	else
-tmPtr = NULL;
+	    tmPtr = NULL;
 #endif
-if (tmPtr == NULL) goto error;
+	if (tmPtr == NULL) goto error;
-utcOffset = __mkSmallInteger(0);
+	utcOffset = __mkSmallInteger(0);
 }
 hours = __mkSmallInteger(tmPtr->tm_hour);
 minutes = __mkSmallInteger(tmPtr->tm_min);
 seconds = __mkSmallInteger(tmPtr->tm_sec);
 dst = (tmPtr->tm_isdst == 0) ? false : true;
 error:;
 %}.
 dst isNil ifTrue:[
-^ self primitiveFailed
+	^ self primitiveFailed
 ].
 info := self timeInfoClass new.
 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.
 LastTimeInfo := info.
 LastTimeInfoSeconds := osSeconds.
 LastTimeInfoMilliseconds := osMilliseconds.
 LastTimeInfoIsLocal := isLocalTime.
 dir := self getHomeDirectory.
 dir isNil ifTrue:[ ^ nil ].
 path := dir , '\Desktop'.
 (self isValidPath:path) ifFalse:[ ^ nil ].
 ^ path
 "
 OperatingSystem getDesktopDirectory
 "
 |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
 |dir drv path|
 dir := self getEnvironment:'HOME'.
 dir isNil ifTrue:[
-"for NT/WIN2K/XP users:
+	"for NT/WIN2K/XP users:
-if HOME is nil, try first HOMEHSARE and then HOMEDRIVE and HOMEPATH"
+	 if HOME is nil, try first HOMEHSARE and then HOMEDRIVE and HOMEPATH"
-dir := self getEnvironment:'HOMESHARE'.
+	dir := self getEnvironment:'HOMESHARE'.
-dir isNil ifTrue:[
+	dir isNil ifTrue:[
-((drv := self getEnvironment:'HOMEDRIVE') notNil
+	    ((drv := self getEnvironment:'HOMEDRIVE') notNil
-and:[(path := self getEnvironment:'HOMEPATH') notNil]) ifTrue:[
+	     and:[(path := self getEnvironment:'HOMEPATH') notNil]) ifTrue:[
-dir := drv , path
+		dir := drv , path
-] ifFalse:[
+	    ] ifFalse:[
-dir := '.'.
+		dir := '.'.
-].
+	    ].
-].
+	].
 ].
 ^ dir
 "
 OperatingSystem getHomeDirectory
 extern char *getenv();
 #endif
 char *name = (char *)0;
 if (firstCall) {
-DWORD nameSize = sizeof(cachedName);
+	DWORD nameSize = sizeof(cachedName);
-if (GetUserName(cachedName, &nameSize) == TRUE) {
+	if (GetUserName(cachedName, &nameSize) == TRUE) {
-name = cachedName;
+	    name = cachedName;
-firstCall = 0;
+	    firstCall = 0;
-}
+	}
 } else {
-name = cachedName;
+	name = cachedName;
 }
 /*
 * try a few common environment variables ...
 */
 if (! name || (name[0] == 0) ) {
-name = getenv("LOGIN");
+	name = getenv("LOGIN");
-if (! name || (name[0] == 0) ) {
+	if (! name || (name[0] == 0) ) {
-name = getenv("LOGNAME");
+	    name = getenv("LOGNAME");
-if (! name || (name[0] == 0) ) {
+	    if (! name || (name[0] == 0) ) {
-name = getenv("USER");
+		name = getenv("USER");
-}
+	    }
-}
+	}
 }
 /*
 * nope - I really font know who you are.
 */
 if (! name || (name[0] == 0) ) {
-name = "you";
+	name = "you";
 }
 RETURN ( __MKSTRING(name) );
 %}.
 "
 "return the user-name-string for a given numeric user-id.
 This is the login name, not the fullName."
 aNumber == self getUserID ifTrue:[
-^ self getLoginName
+	^ self getLoginName
 ].
 ^ '? (' , aNumber printString , ')'
 "
 |info name "uid gid" dir|
 info := IdentityDictionary new.
 name isNil ifTrue:[
-aNameOrID == self getUserID ifTrue:[
+	aNameOrID == self getUserID ifTrue:[
-name := self getLoginName
+	    name := self getLoginName
-].
+	].
 ].
 name notNil ifTrue:[
-info at:#name put:name.
+	info at:#name put:name.
 ] ifFalse:[
-info at:#name put:'unknown'
+	info at:#name put:'unknown'
 ].
 dir isNil ifTrue:[
-aNameOrID == self getUserID ifTrue:[
+	aNameOrID == self getUserID ifTrue:[
-dir := self getHomeDirectory
+	    dir := self getHomeDirectory
-]
+	]
 ].
 dir notNil ifTrue:[info at:#dir put:dir].
 "/ uid notNil ifTrue:[info at:#uid put:uid].
 "/ gid  notNil ifTrue:[info at:#gid put:gid].
 ^ info
 |pid status code core|
 %{
 DWORD endStatus;
 if (__isExternalAddressLike(pidToWait) ) {
-HANDLE __pidToWait = _HANDLEVal(pidToWait);
+	HANDLE __pidToWait = _HANDLEVal(pidToWait);
-int t;
+	int t;
 #ifdef PROCESSDEBUG_CHILDPROCESSWAIT
-console_printf("childProcessWait %x b %d\n",__pidToWait,blocking==true);
+	console_printf("childProcessWait %x b %d\n",__pidToWait,blocking==true);
 #endif
-t = blocking==true ? INFINITE : 0;
+	t = blocking==true ? INFINITE : 0;
 #ifdef DO_WRAP_CALLS
-do {
+	do {
-__threadErrno = 0;
+	    __threadErrno = 0;
-endStatus = STX_API_CALL2( "WaitForSingleObject", WaitForSingleObject, __pidToWait, t);
+	    endStatus = STX_API_CALL2( "WaitForSingleObject", WaitForSingleObject, __pidToWait, t);
-} while ((endStatus < 0) && (__threadErrno == EINTR));
+	} while ((endStatus < 0) && (__threadErrno == EINTR));
 #else
-endStatus = WaitForSingleObject(__pidToWait, t);
+	endStatus = WaitForSingleObject(__pidToWait, t);
-if (endStatus < 0) {
+	if (endStatus < 0) {
-__threadErrno = __WIN32_ERR(GetLastError());
+	    __threadErrno = __WIN32_ERR(GetLastError());
-}
+	}
 #endif
-if ( endStatus == WAIT_TIMEOUT ) {
+	if ( endStatus == WAIT_TIMEOUT ) {
-if (blocking==true)
+	    if (blocking==true)
-status = @symbol(timeout);
+		status = @symbol(timeout);
-else {
+	    else {
-status = @symbol(continue);
+		status = @symbol(continue);
 #ifdef PROCESSDEBUG_CHILDPROCESSWAIT
-console_printf("ret nil\n");
+		console_printf("ret nil\n");
 #endif
-RETURN(nil);
+		RETURN(nil);
-}
+	    }
-} else {
+	} else {
-status = @symbol(exit);
+	    status = @symbol(exit);
 #ifdef PROCESSDEBUG_CHILDPROCESSWAIT
-console_printf("exit\n");
+	    console_printf("exit\n");
 #endif
-if (endStatus == WAIT_OBJECT_0) {
+	    if (endStatus == WAIT_OBJECT_0) {
-if (GetExitCodeProcess(__pidToWait, &endStatus)) {
+		if (GetExitCodeProcess(__pidToWait, &endStatus)) {
-if (endStatus == STILL_ACTIVE) {
+		    if (endStatus == STILL_ACTIVE) {
-RETURN(nil);
+			RETURN(nil);
-}
+		    }
 #ifdef PROCESSDEBUG_CHILDPROCESSWAIT
-console_printf("exit %d\n",endStatus);
+		    console_printf("exit %d\n",endStatus);
 #endif
-code = __mkSmallInteger(endStatus);
+		    code = __mkSmallInteger(endStatus);
-} else {
+		} else {
-code = __mkSmallInteger(GetLastError());
+		    code = __mkSmallInteger(GetLastError());
-}
+		}
-} else {
+	    } else {
-code = __mkSmallInteger(-1);
+		code = __mkSmallInteger(-1);
-}
+	    }
-}
+	}
-core = false;
+	core = false;
-pid = pidToWait;
+	pid = pidToWait;
 }
 %}.
 (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.
 int    readCount;
 int    writeCount;
 int    exceptCount;
 if (__isNonNilObject(readFdArray)) {
-if (! __isArrayLike(readFdArray)) goto fail;
+	if (! __isArrayLike(readFdArray)) goto fail;
-readCount = __arraySize(readFdArray);
+	readCount = __arraySize(readFdArray);
 } else {
-readCount = 0;
+	readCount = 0;
 }
 if (__isNonNilObject(writeFdArray)) {
-if (! __isArrayLike(writeFdArray)) goto fail;
+	if (! __isArrayLike(writeFdArray)) goto fail;
-writeCount = __arraySize(writeFdArray);
+	writeCount = __arraySize(writeFdArray);
 } else {
-writeCount = 0;
+	writeCount = 0;
 }
 if (__isNonNilObject(exceptFdArray)) {
-if (! __isArrayLike(exceptFdArray)) goto fail;
+	if (! __isArrayLike(exceptFdArray)) goto fail;
-exceptCount = __arraySize(exceptFdArray);
+	exceptCount = __arraySize(exceptFdArray);
 } else {
-exceptCount = 0;
+	exceptCount = 0;
 }
 for (i = 0; (i < readCount) && (numHandles < MAXHANDLE);i++) {
-fd = __ArrayInstPtr(readFdArray)->a_element[i];
+	fd = __ArrayInstPtr(readFdArray)->a_element[i];
-if (fd != nil) {
+	if (fd != nil) {
-if (__isExternalAddressLike(fd)) {
+	    if (__isExternalAddressLike(fd)) {
-hArray  [numHandles] = _HANDLEVal(fd);
+		hArray  [numHandles] = _HANDLEVal(fd);
-retArray[numHandles] = i;
+		retArray[numHandles] = i;
-++numHandles;
+		++numHandles;
-} else {
+	    } else {
-int canRead = _canReadWithoutBlocking (__intVal(fd) );
+		int canRead = _canReadWithoutBlocking (__intVal(fd) );
-if (canRead > 0 ) {
+		if (canRead > 0 ) {
-RETURN (fd);
+		    RETURN (fd);
-} else {
+		} else {
-if (canRead < 0 ) {
+		    if (canRead < 0 ) {
-@global(LastErrorNumber) = __mkSmallInteger(EBADF);
+			@global(LastErrorNumber) = __mkSmallInteger(EBADF);
-RETURN (nil);
+			RETURN (nil);
-}
+		    }
-}
+		}
-}
+	    }
-}
+	}
 }
 for (i = 0; (i < writeCount) && (numHandles < MAXHANDLE);i++) {
-fd = __ArrayInstPtr(writeFdArray)->a_element[i];
+	fd = __ArrayInstPtr(writeFdArray)->a_element[i];
-if (fd != nil) {
+	if (fd != nil) {
-if (__isExternalAddressLike(fd)) {
+	    if (__isExternalAddressLike(fd)) {
-hArray  [numHandles] = _HANDLEVal(fd);
+		hArray  [numHandles] = _HANDLEVal(fd);
-retArray[numHandles] = i + 10000;
+		retArray[numHandles] = i + 10000;
-++numHandles;
+		++numHandles;
-} else {
+	    } else {
-int canWrite = _canWriteWithoutBlocking (__intVal(fd) );
+		int canWrite = _canWriteWithoutBlocking (__intVal(fd) );
-if (canWrite > 0 ) {
+		if (canWrite > 0 ) {
-RETURN (fd);
+		    RETURN (fd);
-} else {
+		} else {
-if (canWrite < 0 ) {
+		    if (canWrite < 0 ) {
-@global(LastErrorNumber) = __mkSmallInteger(EBADF);
+			@global(LastErrorNumber) = __mkSmallInteger(EBADF);
-RETURN (nil);
+			RETURN (nil);
-}
+		    }
-}
+		}
-}
+	    }
-}
+	}
 }
 for (i = 0; (i < exceptCount) && (numHandles < MAXHANDLE);i++) {
-fd = __ArrayInstPtr(exceptFdArray)->a_element[i];
+	fd = __ArrayInstPtr(exceptFdArray)->a_element[i];
-if (fd != nil) {
+	if (fd != nil) {
-if (__isExternalAddressLike(fd)) {
+	    if (__isExternalAddressLike(fd)) {
-hArray  [numHandles] = _HANDLEVal(fd);
+		hArray  [numHandles] = _HANDLEVal(fd);
-retArray[numHandles] = i + 20000;
+		retArray[numHandles] = i + 20000;
-++numHandles;
+		++numHandles;
-}
+	    }
-}
+	}
 }
 if (__isSmallInteger(millis)) {
-t = __intVal(millis);
+	t = __intVal(millis);
-if (t <= 0 && numHandles == 0) {
+	if (t <= 0 && numHandles == 0) {
-RETURN (nil);
+	    RETURN (nil);
-}
+	}
 } else {
-t = INFINITE;
+	t = INFINITE;
 }
 #ifdef SELECT3DEBUGWIN32
 console_printf("wait Handles = %d timeout = %d\n",numHandles, t);
 #endif
 res = __vmWait (numHandles, hArray, MAXHANDLE, t);
 if (numHandles) {
-if (res == WAIT_FAILED) {
+	if (res == WAIT_FAILED) {
 #ifdef SELECT2DEBUGWIN32
-console_printf("- error %d; ret nil\n",GetLastError());
+	    console_printf("- error %d; ret nil\n",GetLastError());
 #endif
-if (__threadErrno == EINTR) {
+	    if (__threadErrno == EINTR) {
-__threadErrno = 0;
+		__threadErrno = 0;
-@global(LastErrorNumber) = nil;
+		@global(LastErrorNumber) = nil;
-} else {
+	    } else {
-__threadErrno = EBADF;
+		__threadErrno = EBADF;
-if (@global(InfoPrinting) == true) {
+		if (@global(InfoPrinting) == true) {
-console_fprintf(stderr, "Win32OS [info]: select errno = %d\n", __threadErrno);
+		    console_fprintf(stderr, "Win32OS [info]: select errno = %d\n", __threadErrno);
-}
+		}
-@global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
+		@global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
-}
+	    }
-RETURN ( nil );
+	    RETURN ( nil );
-}
+	}
-if (res == WAIT_TIMEOUT) {
+	if (res == WAIT_TIMEOUT) {
 #ifdef SELECT3DEBUGWIN32
-console_printf("- timeOut; ret nil\n" );
+	    console_printf("- timeOut; ret nil\n" );
 #endif
-goto polling;
+	    goto polling;
-}
+	}
-if (res == numHandles) {
+	if (res == numHandles) {
-if (1 /* @global(InfoPrinting) == true */) {
+	    if (1 /* @global(InfoPrinting) == true */) {
-console_fprintf(stderr, "Win32OS [info]: plugIn event has been handled\n");
+		console_fprintf(stderr, "Win32OS [info]: plugIn event has been handled\n");
-}
+	    }
-__threadErrno = 0;
+	    __threadErrno = 0;
-@global(LastErrorNumber) = nil;
+	    @global(LastErrorNumber) = nil;
-RETURN ( nil );
+	    RETURN ( nil );
-}
+	}
-if ((res < 0) || (res > numHandles)) {
+	if ((res < 0) || (res > numHandles)) {
 #ifdef SELECTDEBUGWIN32
-console_printf("- res=%d error1 %d\n", res, GetLastError());
+	    console_printf("- res=%d error1 %d\n", res, GetLastError());
 #endif
-__threadErrno = 0;
+	    __threadErrno = 0;
-@global(LastErrorNumber) = nil;
+	    @global(LastErrorNumber) = nil;
-RETURN ( nil );
+	    RETURN ( nil );
-}
+	}
-ret = res;
+	ret = res;
-if (ret < numHandles) {
+	if (ret < numHandles) {
-int fd = retArray[ret];
+	    int fd = retArray[ret];
-@global(LastErrorNumber) = nil;
+	    @global(LastErrorNumber) = nil;
 #ifdef SELECTDEBUGWIN32
-if (ret) console_printf("wait Handles %d %d ret\n", ret, fd);
+	    if (ret) console_printf("wait Handles %d %d ret\n", ret, fd);
 #endif
-if (fd < 10000) {
+	    if (fd < 10000) {
-RETURN ( __ArrayInstPtr(readFdArray)->a_element[fd] );
+		RETURN ( __ArrayInstPtr(readFdArray)->a_element[fd] );
-}
+	    }
-if (fd < 20000) {
+	    if (fd < 20000) {
-RETURN ( __ArrayInstPtr(writeFdArray)->a_element[fd-10000] );
+		RETURN ( __ArrayInstPtr(writeFdArray)->a_element[fd-10000] );
-}
+	    }
-RETURN ( __ArrayInstPtr(exceptFdArray)->a_element[fd-20000] );
+	    RETURN ( __ArrayInstPtr(exceptFdArray)->a_element[fd-20000] );
-}
+	}
-console_fprintf(stderr, "Win32OS [info]: wait Handles ret = %d error2 %d\n", ret, GetLastError());
+	console_fprintf(stderr, "Win32OS [info]: wait Handles ret = %d error2 %d\n", ret, GetLastError());
-goto fail;
+	goto fail;
 } else {
 polling:
-for (i=0; i < readCount;i++) {
+	for (i=0; i < readCount;i++) {
-fd = __ArrayInstPtr(readFdArray)->a_element[i];
+	    fd = __ArrayInstPtr(readFdArray)->a_element[i];
-if (fd != nil) {
+	    if (fd != nil) {
-if (! __isExternalAddressLike(fd)) {
+		if (! __isExternalAddressLike(fd)) {
-int canRead = _canReadWithoutBlocking (__intVal(fd));
+		    int canRead = _canReadWithoutBlocking (__intVal(fd));
-if (canRead > 0 ) {
+		    if (canRead > 0 ) {
-RETURN (fd);
+			RETURN (fd);
-} else {
+		    } else {
-if (canRead < 0 ) {
+			if (canRead < 0 ) {
-@global(LastErrorNumber) = __mkSmallInteger(EBADF);
+			    @global(LastErrorNumber) = __mkSmallInteger(EBADF);
-RETURN (nil);
+			    RETURN (nil);
-}
+			}
-}
+		    }
-}
+		}
-}
+	    }
-}
+	}
-for (i=0; i < writeCount;i++) {
+	for (i=0; i < writeCount;i++) {
-fd = __ArrayInstPtr(writeFdArray)->a_element[i];
+	    fd = __ArrayInstPtr(writeFdArray)->a_element[i];
-if (fd != nil) {
+	    if (fd != nil) {
-if (! __isExternalAddressLike(fd)) {
+		if (! __isExternalAddressLike(fd)) {
-int canWrite = _canWriteWithoutBlocking (__intVal(fd));
+		    int canWrite = _canWriteWithoutBlocking (__intVal(fd));
-if (canWrite > 0 ) {
+		    if (canWrite > 0 ) {
-RETURN (fd);
+			RETURN (fd);
-} else {
+		    } else {
-if (canWrite < 0 ) {
+			if (canWrite < 0 ) {
-@global(LastErrorNumber) = __mkSmallInteger(EBADF);
+			    @global(LastErrorNumber) = __mkSmallInteger(EBADF);
-RETURN (nil);
+			    RETURN (nil);
-}
+			}
-}
+		    }
-}
+		}
-}
+	    }
-}
+	}
-@global(LastErrorNumber) = nil;
+	@global(LastErrorNumber) = nil;
-RETURN ( nil );
+	RETURN ( nil );
 }
 fail: ;
 %}.
 "
 DWORD res;
 HANDLE hArray[MAXHANDLE];
 INT i, count;
 if (! __isArrayLike(fdOrHandleArray)) {
-goto fail;
+	goto fail;
 }
 count = __arraySize(fdOrHandleArray);
 for (i=0; i<count; i++) {
-OBJ fdOrHandle = __ArrayInstPtr(fdOrHandleArray)->a_element[i];
+	OBJ fdOrHandle = __ArrayInstPtr(fdOrHandleArray)->a_element[i];
-HANDLE h;
+	HANDLE h;
-if (__isExternalAddressLike(fdOrHandle)) {
+	if (__isExternalAddressLike(fdOrHandle)) {
-h = _HANDLEVal(fdOrHandle);
+	    h = _HANDLEVal(fdOrHandle);
-} else {
+	} else {
-if (__isSmallInteger(fdOrHandle)) {
+	    if (__isSmallInteger(fdOrHandle)) {
-h = (HANDLE) _get_osfhandle (__intVal(fdOrHandle));
+		h = (HANDLE) _get_osfhandle (__intVal(fdOrHandle));
-} else {
+	    } else {
-goto fail;
+		goto fail;
-}
+	    }
-}
+	}
-hArray[i] = h;
+	hArray[i] = h;
 }
 if (__isSmallInteger(millis)) {
-t = __intVal(millis);
+	t = __intVal(millis);
 } else {
-t = INFINITE;
+	t = INFINITE;
 }
 #ifdef DO_WRAP_CALLS
 do {
-__threadErrno = 0;
+	__threadErrno = 0;
-res = STX_API_CALL4( "WaitForMultipleObjects", WaitForMultipleObjects, count, hArray, FALSE, t);
+	res = STX_API_CALL4( "WaitForMultipleObjects", WaitForMultipleObjects, count, hArray, FALSE, t);
 } while ((res < 0) && (__threadErrno == EINTR));
 #else
 res = WaitForMultipleObjects(count, hArray, FALSE, t);
 if (res < 0) {
-__threadErrno = __WIN32_ERR(GetLastError());
+	__threadErrno = __WIN32_ERR(GetLastError());
 }
 #endif
 if (res == WAIT_FAILED) {
-RETURN (nil);
+	RETURN (nil);
 }
 if (res == WAIT_TIMEOUT) {
-RETURN (nil);
+	RETURN (nil);
 }
 if ((res >= WAIT_OBJECT_0) && (res < (WAIT_OBJECT_0+count))) {
-RETURN (__ArrayInstPtr(fdOrHandleArray)->a_element[res-WAIT_OBJECT_0]);
+	RETURN (__ArrayInstPtr(fdOrHandleArray)->a_element[res-WAIT_OBJECT_0]);
 }
 RETURN (nil);
 fail: ;
 %}.
 INT t;
 DWORD res;
 HANDLE h = NULL;
 if (__isExternalAddressLike(fdOrHandle)) {
-h = _HANDLEVal(fdOrHandle);
+	h = _HANDLEVal(fdOrHandle);
 } else {
-if (__isSmallInteger(fdOrHandle)) {
+	if (__isSmallInteger(fdOrHandle)) {
-h = (HANDLE) _get_osfhandle (__intVal(fdOrHandle));
+	    h = (HANDLE) _get_osfhandle (__intVal(fdOrHandle));
-} else {
+	} else {
-goto fail;
+	    goto fail;
-}
+	}
 }
 if (__isSmallInteger(millis)) {
-t = __intVal(millis);
+	t = __intVal(millis);
 } else {
-t = INFINITE;
+	t = INFINITE;
 }
 #ifdef DO_WRAP_CALLS
 do {
-__threadErrno = 0;
+	__threadErrno = 0;
-res = STX_API_CALL2( "WaitForSingleObject", WaitForSingleObject, h,  t);
+	res = STX_API_CALL2( "WaitForSingleObject", WaitForSingleObject, h,  t);
 } while ((res < 0) && (__threadErrno == EINTR));
 #else
 res = WaitForSingleObject(h, t);
 if (res < 0) {
-__threadErrno = __WIN32_ERR(GetLastError());
+	__threadErrno = __WIN32_ERR(GetLastError());
 }
 #endif
 if (res == WAIT_FAILED) {
-RETURN (nil);
+	RETURN (nil);
 }
 if (res == WAIT_TIMEOUT) {
-RETURN (nil);
+	RETURN (nil);
 }
 RETURN (fdOrHandle);
 fail: ;
 %}.
 !Win32OperatingSystem::FileStatusInfo class methodsFor:'instance creation'!
 type:t mode:m uid:u gid:g size:s id:i accessed:aT modified:mT created:cT path:lP alternativeName:name2
 ^ self basicNew
-type:t mode:m uid:u gid:g size:s
+	type:t mode:m uid:u gid:g size:s
-id:i accessed:aT modified:mT created:cT
+	id:i accessed:aT modified:mT created:cT
-path:lP alternativeName:name2
+	path:lP alternativeName:name2
 !
 type:t mode:m uid:u gid:g size:s id:i accessed:aT modified:mT created:cT path:lP fullName:fullName alternativeName:name2
 ^ self basicNew
-type:t mode:m uid:u gid:g size:s
+	type:t mode:m uid:u gid:g size:s
-id:i accessed:aT modified:mT created:cT
+	id:i accessed:aT modified:mT created:cT
-path:lP
+	path:lP
-fullName:fullName
+	fullName:fullName
-alternativeName:name2
+	alternativeName:name2
 ! !
 !Win32OperatingSystem::FileStatusInfo methodsFor:'accessing'!
 accessTime
 path
 "for symbolic links only: return the path where the symbolic link points to"
 "/ access lazily...
 path isNil ifTrue:[
-type == #symbolicLink ifTrue:[
+	type == #symbolicLink ifTrue:[
-path := OperatingSystem getLinkTarget:fullName.
+	    path := OperatingSystem getLinkTarget:fullName.
-]
+	]
 ].
 ^ path
 "Modified: / 07-02-2007 / 10:31:56 / cg"
 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
 "
 ! !
 !Win32OperatingSystem::OSProcessStatus class methodsFor:'instance creation'!
 pComment
 |pComment|
 pComment := self unsignedLongAt:(20 + 1).
 ^ pComment == 0
-ifTrue:''
+	ifTrue:''
-ifFalse:[ (ExternalBytes address:pComment) stringAt:1 ]
+	ifFalse:[ (ExternalBytes address:pComment) stringAt:1 ]
 "Created: / 01-08-2006 / 14:02:55 / fm"
 "Modified: / 16-04-2007 / 13:08:39 / cg"
 !
 pLocation := self unsignedLongAt:(24 + 1).
 pLocation == 0 ifTrue:[^ nil].
 externalBytes := ExternalBytes address:pLocation.
 ^ externalBytes isEmpty
-ifTrue:[ nil ]
+	ifTrue:[ nil ]
-ifFalse:[ externalBytes stringAt:1 ]
+	ifFalse:[ externalBytes stringAt:1 ]
 "Created: / 01-08-2006 / 14:03:21 / fm"
 "Modified: / 18-10-2006 / 12:06:45 / User"
 "Modified: / 16-04-2007 / 13:08:27 / cg"
 !
 rootKeyNames
 "returns a collection of root keyNames"
 ^ #(
-'HKEY_CLASSES_ROOT'
+	'HKEY_CLASSES_ROOT'
-'HKEY_CURRENT_USER'
+	'HKEY_CURRENT_USER'
-'HKEY_LOCAL_MACHINE'
+	'HKEY_LOCAL_MACHINE'
-'HKEY_USERS'
+	'HKEY_USERS'
-'HKEY_PERFORMANCE_DATA'
+	'HKEY_PERFORMANCE_DATA'
-'HKEY_CURRENT_CONFIG'
+	'HKEY_CURRENT_CONFIG'
-'HKEY_DYN_DATA'
+	'HKEY_DYN_DATA'
 )
 !
 separator
 "returns the registry-key-path separator character"
 documentation
 "
 Interface to a WIN32 registry.
 As this is a private class, access it via
-Win32OperatingSystem registryEntry
+	Win32OperatingSystem registryEntry
 [author:]
-Claus Gittinger (initial version & cleanup)
+	Claus Gittinger (initial version & cleanup)
 "
 !
 examples
 "
 retrieve an existing entry by key:
-[exBegin]
+									[exBegin]
-|k|
+	|k|
-k := Win32OperatingSystem registryEntry key:'HKEY_LOCAL_MACHINE\Software\eXept\Smalltalk/X'
+	k := Win32OperatingSystem registryEntry key:'HKEY_LOCAL_MACHINE\Software\eXept\Smalltalk/X'
-[exEnd]
+									[exEnd]
 retrieve a non-existing entry by key:
-[exBegin]
+									[exBegin]
-|k|
+	|k|
-k := Win32OperatingSystem registryEntry key:'HKEY_LOCAL_MACHINE\Software\xxx'
+	k := Win32OperatingSystem registryEntry key:'HKEY_LOCAL_MACHINE\Software\xxx'
-[exEnd]
+									[exEnd]
 ask a keys value:
-[exBegin]
+									[exBegin]
-|k|
+	|k|
-k := Win32OperatingSystem registryEntry key:'HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion'.
+	k := Win32OperatingSystem registryEntry key:'HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion'.
-Transcript show:'Windows serial NR:'; showCR:(k valueNamed:'ProductId').
+	Transcript show:'Windows serial NR:'; showCR:(k valueNamed:'ProductId').
-k := Win32OperatingSystem registryEntry key:'HKEY_LOCAL_MACHINE\Software\eXept\Smalltalk/X'.
+	k := Win32OperatingSystem registryEntry key:'HKEY_LOCAL_MACHINE\Software\eXept\Smalltalk/X'.
-Transcript showCR:(k valueNamed:'CurrentVersion').
+	Transcript showCR:(k valueNamed:'CurrentVersion').
-[exEnd]
+									[exEnd]
 create a sub-key (if not already present):
-[exBegin]
+									[exBegin]
-|k subKey|
+	|k subKey|
-k := Win32OperatingSystem registryEntry key:'HKEY_LOCAL_MACHINE\Software\eXept\Smalltalk/X'.
+	k := Win32OperatingSystem registryEntry key:'HKEY_LOCAL_MACHINE\Software\eXept\Smalltalk/X'.
-subKey := k createSubKeyNamed:'RegistryDemo'
+	subKey := k createSubKeyNamed:'RegistryDemo'
-[exEnd]
+									[exEnd]
 change a keys value:
-[exBegin]
+									[exBegin]
-|k|
+	|k|
-k := Win32OperatingSystem registryEntry key:'HKEY_LOCAL_MACHINE\Software\eXept\Smalltalk/X\RegistryDemo'.
+	k := Win32OperatingSystem registryEntry key:'HKEY_LOCAL_MACHINE\Software\eXept\Smalltalk/X\RegistryDemo'.
-k valueNamed:'FooBarBaz' put:'a foo bar baz string'.
+	k valueNamed:'FooBarBaz' put:'a foo bar baz string'.
-[exEnd]
+									[exEnd]
 delete a value:
-[exBegin]
+									[exBegin]
-|k|
+	|k|
-k := Win32OperatingSystem registryEntry key:'HKEY_LOCAL_MACHINE\Software\eXept\Smalltalk/X\RegistryDemo'.
+	k := Win32OperatingSystem registryEntry key:'HKEY_LOCAL_MACHINE\Software\eXept\Smalltalk/X\RegistryDemo'.
-k deleteValueNamed:'FooBarBaz'.
+	k deleteValueNamed:'FooBarBaz'.
-[exEnd]
+									[exEnd]
 delete a key:
-[exBegin]
+									[exBegin]
-|k|
+	|k|
-k := Win32OperatingSystem registryEntry key:'HKEY_LOCAL_MACHINE\Software\eXept\Smalltalk/X'.
+	k := Win32OperatingSystem registryEntry key:'HKEY_LOCAL_MACHINE\Software\eXept\Smalltalk/X'.
-k deleteSubKeyNamed:'RegistryDemo'.
+	k deleteSubKeyNamed:'RegistryDemo'.
-[exEnd]
+									[exEnd]
 enumerate keys:
-[exBegin]
+									[exBegin]
-|k|
+	|k|
-k := Win32OperatingSystem registryEntry key:'HKEY_LOCAL_MACHINE\Software'.
+	k := Win32OperatingSystem registryEntry key:'HKEY_LOCAL_MACHINE\Software'.
-k subKeysDo:[:subKey |
+	k subKeysDo:[:subKey |
-Transcript showCR:subKey path
+	    Transcript showCR:subKey path
-]
+	]
-[exEnd]
+									[exEnd]
 enumerate all keys (recursive):
-[exBegin]
+									[exBegin]
-|k|
+	|k|
-k := Win32OperatingSystem registryEntry key:'HKEY_LOCAL_MACHINE\Software'.
+	k := Win32OperatingSystem registryEntry key:'HKEY_LOCAL_MACHINE\Software'.
-k allSubKeysDo:[:subKey |
+	k allSubKeysDo:[:subKey |
-Transcript showCR:subKey path
+	    Transcript showCR:subKey path
-]
+	]
-[exEnd]
+									[exEnd]
 fetch value by index:
-[exBegin]
+									[exBegin]
-|k|
+	|k|
-k := Win32OperatingSystem registryEntry key:'HKEY_LOCAL_MACHINE\SOFTWARE\eXept\Smalltalk/X'.
+	k := Win32OperatingSystem registryEntry key:'HKEY_LOCAL_MACHINE\SOFTWARE\eXept\Smalltalk/X'.
-Transcript showCR:(k valueNameAtIndex:0)
+	Transcript showCR:(k valueNameAtIndex:0)
-[exEnd]
+									[exEnd]
 enumerate value names:
-[exBegin]
+									[exBegin]
-|k|
+	|k|
-k := Win32OperatingSystem registryEntry key:'HKEY_LOCAL_MACHINE\SOFTWARE\eXept\Smalltalk/X'.
+	k := Win32OperatingSystem registryEntry key:'HKEY_LOCAL_MACHINE\SOFTWARE\eXept\Smalltalk/X'.
-k valueNamesDo:[:nm  |
+	k valueNamesDo:[:nm  |
-Transcript showCR:nm.
+	   Transcript showCR:nm.
-]
+	]
-[exEnd]
+									[exEnd]
 enumerate values:
-[exBegin]
+									[exBegin]
-|k|
+	|k|
-k := Win32OperatingSystem registryEntry key:'HKEY_LOCAL_MACHINE\SOFTWARE\eXept\Smalltalk/X'.
+	k := Win32OperatingSystem registryEntry key:'HKEY_LOCAL_MACHINE\SOFTWARE\eXept\Smalltalk/X'.
-k valueNamesAndValuesDo:[:nm :val |
+	k valueNamesAndValuesDo:[:nm :val |
-Transcript showCR:(nm , ' -> ' , val storeString).
+	    Transcript showCR:(nm , ' -> ' , val storeString).
-]
+	]
-[exEnd]
+									[exEnd]
 search for a value (where does NT store the domain ?):
-[exBegin]
+									[exBegin]
-|k|
+	|k|
-k := Win32OperatingSystem registryEntry key:'HKEY_LOCAL_MACHINE\System'.
+	k := Win32OperatingSystem registryEntry key:'HKEY_LOCAL_MACHINE\System'.
-k subKeysDo:[:subKey |
+	k subKeysDo:[:subKey |
-subKey subKeysDo:[:subSubKey |
+	    subKey subKeysDo:[:subSubKey |
-|tcp params|
+		|tcp params|
-(subSubKey path asLowercase endsWith:'services') ifTrue:[
+		(subSubKey path asLowercase endsWith:'services') ifTrue:[
-tcp := subSubKey subKeyNamed:'tcpip'.
+		    tcp := subSubKey subKeyNamed:'tcpip'.
-tcp notNil ifTrue:[
+		    tcp notNil ifTrue:[
-params := tcp subKeyNamed:'parameters'.
+			params := tcp subKeyNamed:'parameters'.
-params notNil ifTrue:[
+			params notNil ifTrue:[
-Transcript showCR:'Domain is found in ' , params path ,
+			    Transcript showCR:'Domain is found in ' , params path ,
-' value: ' , (params valueNamed:'Domain').
+					' value: ' , (params valueNamed:'Domain').
-params close.
+			    params close.
-].
+			].
-tcp close.
+			tcp close.
-]
+		    ]
-]
+		]
-]
+	    ]
-]
+	]
-[exEnd]
+									[exEnd]
 "
 ! !
 HKEY_PERFORMANCE_DATA := %{ __MKEXTERNALADDRESS(HKEY_PERFORMANCE_DATA) %}.
 HKEY_CURRENT_CONFIG   := %{ __MKEXTERNALADDRESS(HKEY_CURRENT_CONFIG) %}.
 HKEY_DYN_DATA         := %{ __MKEXTERNALADDRESS(HKEY_DYN_DATA) %}.
 "
-self initialize
+	self initialize
 "
 "Created: / 19.5.1999 / 21:39:57 / cg"
 "Modified: / 19.5.1999 / 22:45:31 / cg"
 !
 (these are shared and not finalized, as opposed to all other keys)"
 HKEY_CLASSES_ROOT isNil ifTrue:[self initialize].
 specialKeyStringOrSymbol = #'HKEY_CLASSES_ROOT' ifTrue:[
-^ HKEY_CLASSES_ROOT.
+	^ HKEY_CLASSES_ROOT.
 ].
 specialKeyStringOrSymbol = #'HKEY_CURRENT_USER' ifTrue:[
-^ HKEY_CURRENT_USER.
+	^ HKEY_CURRENT_USER.
 ].
 specialKeyStringOrSymbol = #'HKEY_LOCAL_MACHINE' ifTrue:[
-^ HKEY_LOCAL_MACHINE.
+	^ HKEY_LOCAL_MACHINE.
 ].
 specialKeyStringOrSymbol = #'HKEY_USERS' ifTrue:[
-^ HKEY_USERS.
+	^ HKEY_USERS.
 ].
 specialKeyStringOrSymbol = #'HKEY_PERFORMANCE_DATA' ifTrue:[
-^ HKEY_PERFORMANCE_DATA.
+	^ HKEY_PERFORMANCE_DATA.
 ].
 specialKeyStringOrSymbol = #'HKEY_CURRENT_CONFIG' ifTrue:[
-^ HKEY_CURRENT_CONFIG.
+	^ HKEY_CURRENT_CONFIG.
 ].
 specialKeyStringOrSymbol = #'HKEY_DYN_DATA' ifTrue:[
-^ HKEY_DYN_DATA.
+	^ HKEY_DYN_DATA.
 ].
 ^ nil
 "Created: / 19.5.1999 / 21:40:30 / cg"
 update:something with:aParameter from:changedObject
 "handle image restarts and refetch registry handles"
 (something == #returnFromSnapshot) ifTrue:[
-self initialize
+	self initialize
 ]
 "Created: 15.6.1996 / 15:14:03 / cg"
 "Modified: 24.2.1997 / 22:08:05 / cg"
 ! !
 immediateHandle:aHandleValue
 |h newEntry|
 aHandleValue isInteger ifTrue:[
-h := ExternalAddress newAddress:aHandleValue
+	h := ExternalAddress newAddress:aHandleValue
 ] ifFalse:[
-h := aHandleValue
+	h := aHandleValue
 ].
 "/ rootKeys are not registered for RegClose ...
 newEntry := self basicNew setHandle:h path:nil.
 newEntry registerForFinalization.
 HKEY_CLASSES_ROOT isNil ifTrue:[self initialize].
 idx := aKeyNamePath indexOf:(self separator).
 idx == 0 ifTrue:[
-first := aKeyNamePath.
+	first := aKeyNamePath.
-rest := nil.
+	rest := nil.
 ] ifFalse:[
-first := aKeyNamePath copyTo:idx-1.
+	first := aKeyNamePath copyTo:idx-1.
-rest := aKeyNamePath copyFrom:idx+1
+	rest := aKeyNamePath copyFrom:idx+1
 ].
 first := first asUppercase.
 "/ the first is a pseudo name
 root := self rootKey:first.
 root isNil ifTrue:[
-^ nil
+	^ nil
 ].
 rest size == 0 ifTrue:[
-^ root
+	^ root
 ].
 ^ root subKeyNamed:rest.
 "
 |k suffix|
 k := self key:'HKEY_CLASSES_ROOT\MIME\Database\Content Type\',mimeType.
 k notNil ifTrue:[
-suffix := k valueNamed:'extension'.
+	suffix := k valueNamed:'extension'.
 ].
 ^ suffix
 !
 shellCommandTemplateFor:operation onSuffix:suffixArg
 suffix := suffixArg.
 suffix isNil ifTrue:[^ nil].
 (suffix startsWith:'.') ifTrue:[
-suffix := suffix copyFrom:2
+	suffix := suffix copyFrom:2
 ].
 k := self key:'HKEY_CLASSES_ROOT\.',suffix.
 k notNil ifTrue:[
-fkey := (k valueNamed:'').
+	fkey := (k valueNamed:'').
 ].
 fkey isNil ifTrue:[
-fkey := suffix,'_auto_file'
+	fkey := suffix,'_auto_file'
 ].
 fkey notEmptyOrNil ifTrue:[
-redirect := nil.
+	redirect := nil.
-k := Win32OperatingSystem::RegistryEntry key:('HKEY_CLASSES_ROOT\' , fkey , '\CurVer').
+	k := Win32OperatingSystem::RegistryEntry key:('HKEY_CLASSES_ROOT\' , fkey , '\CurVer').
-k notNil ifTrue:[
+	k notNil ifTrue:[
-redirect := k defaultValue
+	    redirect := k defaultValue
-].
+	].
-redirect isNil ifTrue:[
+	redirect isNil ifTrue:[
-k := Win32OperatingSystem::RegistryEntry key:('HKEY_CLASSES_ROOT\' , (fkey) , '\shell\',operation,'\command').
+	     k := Win32OperatingSystem::RegistryEntry key:('HKEY_CLASSES_ROOT\' , (fkey) , '\shell\',operation,'\command').
-] ifFalse:[
+	] ifFalse:[
-k := Win32OperatingSystem::RegistryEntry key:('HKEY_CLASSES_ROOT\' , (redirect) , '\shell\',operation,'\command').
+	     k := Win32OperatingSystem::RegistryEntry key:('HKEY_CLASSES_ROOT\' , (redirect) , '\shell\',operation,'\command').
-].
+	].
-k notNil ifTrue:[
+	k notNil ifTrue:[
-cmd := k defaultValue
+	    cmd := k defaultValue
-].
+	].
 ].
 ^ cmd
 ! !
 v isString ifFalse:[^ nil].
 ^ v
 "
 self
-stringValueFor:'Content Type'
+	stringValueFor:'Content Type'
-atKey:'HKEY_CLASSES_ROOT\.au'
+	atKey:'HKEY_CLASSES_ROOT\.au'
 "
 ! !
 !Win32OperatingSystem::RegistryEntry methodsFor:'accessing'!
 %{
 HKEY myKey, subKey = 0;
 if (__isExternalAddressLike(__INST(handle))
 && (__isString(subKeyString) || __isSymbol(subKeyString))) {
-myKey = (HKEY)__externalAddressVal(__INST(handle));
+	myKey = (HKEY)__externalAddressVal(__INST(handle));
-if (RegCreateKey(myKey, __stringVal(subKeyString), &subKey) == ERROR_SUCCESS) {
+	if (RegCreateKey(myKey, __stringVal(subKeyString), &subKey) == ERROR_SUCCESS) {
-subHandle = __MKEXTERNALADDRESS(subKey);
+	    subHandle = __MKEXTERNALADDRESS(subKey);
-}
+	}
 }
 %}.
 subHandle notNil ifTrue:[
-newEntry := self class basicNew
+	newEntry := self class basicNew
-setHandle:subHandle
+			setHandle:subHandle
-path:(path , self class separator asString , subKeyString).
+			path:(path , self class separator asString , subKeyString).
-newEntry registerForFinalization.
+	newEntry registerForFinalization.
-^ newEntry.
+	^ newEntry.
 ].
 ^ nil
 "
 |top sub|
 %{
 HKEY myKey;
 if (__isExternalAddressLike(__INST(handle))
 && (__isString(subKeyString) || __isSymbol(subKeyString))) {
-myKey = (HKEY)__externalAddressVal(__INST(handle));
+	myKey = (HKEY)__externalAddressVal(__INST(handle));
-if (RegDeleteKey(myKey, __stringVal(subKeyString)) == ERROR_SUCCESS) {
+	if (RegDeleteKey(myKey, __stringVal(subKeyString)) == ERROR_SUCCESS) {
-RETURN (true);
+	    RETURN (true);
-}
+	}
 }
 %}.
 ^ false
 "
 %{
 HKEY myKey, remoteKey = 0;
 if (__isExternalAddressLike(__INST(handle)) && __isString(hostName)) {
-myKey = (HKEY)__externalAddressVal(__INST(handle));
+	myKey = (HKEY)__externalAddressVal(__INST(handle));
-if (RegConnectRegistry(__stringVal(hostName), myKey, &remoteKey) == ERROR_SUCCESS) {
+	if (RegConnectRegistry(__stringVal(hostName), myKey, &remoteKey) == ERROR_SUCCESS) {
-remoteHandle = __MKEXTERNALADDRESS(remoteKey);
+	    remoteHandle = __MKEXTERNALADDRESS(remoteKey);
-}
+	}
 }
 %}.
 remoteHandle notNil ifTrue:[
-newEntry := self class basicNew setHandle:remoteHandle path:path.
+	newEntry := self class basicNew setHandle:remoteHandle path:path.
-newEntry registerForFinalization.
+	newEntry registerForFinalization.
-^ newEntry.
+	^ newEntry.
 ].
 ^ nil
 "
 |top remote|
 DWORD classNameSize = sizeof(classNameBuffer) - 1;
 FILETIME modificationTime;
 if (__isExternalAddressLike(__INST(handle))
 && __isSmallInteger(subKeyIndex)) {
-myKey = (HKEY)__externalAddressVal(__INST(handle));
+	myKey = (HKEY)__externalAddressVal(__INST(handle));
-if (RegEnumKeyEx(myKey, __intVal(subKeyIndex),
+	if (RegEnumKeyEx(myKey, __intVal(subKeyIndex),
-nameBuffer, &nameSize,
+			 nameBuffer, &nameSize,
-NULL,
+			 NULL,
-classNameBuffer, &classNameSize,
+			 classNameBuffer, &classNameSize,
-&modificationTime) == ERROR_SUCCESS) {
+			 &modificationTime) == ERROR_SUCCESS) {
-nameBuffer[nameSize] = '\0';
+	    nameBuffer[nameSize] = '\0';
-classNameBuffer[classNameSize] = '\0';
+	    classNameBuffer[classNameSize] = '\0';
-subKeyName = __MKSTRING(nameBuffer);
+	    subKeyName = __MKSTRING(nameBuffer);
-subKeyClassName = __MKSTRING(classNameBuffer);
+	    subKeyClassName = __MKSTRING(classNameBuffer);
-} else {
+	} else {
-}
+	}
 }
 %}.
 subKeyName isNil ifTrue:[^ nil].
 ^ self subKeyNamed:subKeyName.
 %{
 HKEY myKey, subKey = 0;
 if (__isExternalAddressLike(__INST(handle))
 && (__isString(subKeyString) || __isSymbol(subKeyString))) {
-myKey = (HKEY)__externalAddressVal(__INST(handle));
+	myKey = (HKEY)__externalAddressVal(__INST(handle));
-if (RegOpenKey(myKey, __stringVal(subKeyString), &subKey) == ERROR_SUCCESS) {
+	if (RegOpenKey(myKey, __stringVal(subKeyString), &subKey) == ERROR_SUCCESS) {
-subHandle = __MKEXTERNALADDRESS(subKey);
+	    subHandle = __MKEXTERNALADDRESS(subKey);
-}
+	}
 }
 %}.
 subHandle notNil ifTrue:[
-newEntry := self class basicNew
+	newEntry := self class basicNew
-setHandle:subHandle
+			setHandle:subHandle
-path:((path ? '?') , self class separator asString , subKeyString).
+			path:((path ? '?') , self class separator asString , subKeyString).
-newEntry registerForFinalization.
+	newEntry registerForFinalization.
-^ newEntry.
+	^ newEntry.
 ].
 ^ nil
 "
 |top sub|
 %{
 HKEY myKey;
 if (__isExternalAddressLike(__INST(handle))
 && (__isString(aValueName) || __isSymbol(aValueName))) {
-myKey = (HKEY)__externalAddressVal(__INST(handle));
+	myKey = (HKEY)__externalAddressVal(__INST(handle));
-if (RegDeleteValue(myKey, __stringVal(aValueName)) == ERROR_SUCCESS) {
+	if (RegDeleteValue(myKey, __stringVal(aValueName)) == ERROR_SUCCESS) {
-RETURN (true);
+	    RETURN (true);
-}
+	}
 }
 %}.
 ^ false
 !
 DWORD nameSize = sizeof(nameBuffer) - 1;
 DWORD valueType;
 if (__isExternalAddressLike(__INST(handle))
 && __isSmallInteger(valueIndex)) {
-myKey = (HKEY)__externalAddressVal(__INST(handle));
+	myKey = (HKEY)__externalAddressVal(__INST(handle));
-if (RegEnumValue(myKey, __intVal(valueIndex),
+	if (RegEnumValue(myKey, __intVal(valueIndex),
-nameBuffer, &nameSize,
+			 nameBuffer, &nameSize,
-NULL,
+			 NULL,
-&valueType,
+			 &valueType,
-NULL, NULL) == ERROR_SUCCESS) {
+			 NULL, NULL) == ERROR_SUCCESS) {
-nameBuffer[nameSize] = '\0';
+	    nameBuffer[nameSize] = '\0';
-valueName = __MKSTRING(nameBuffer);
+	    valueName = __MKSTRING(nameBuffer);
-}
+	}
 }
 %}.
 ^ valueName
 "
 "
 !
 valueNamed:aValueName
 "retrieve a value; the returned object depends upon the type:
-REG_BINARY      -> ByteArray
+	REG_BINARY      -> ByteArray
-REG_SZ          -> String
+	REG_SZ          -> String
-REG_MULTI_SZ    -> Array of strings
+	REG_MULTI_SZ    -> Array of strings
-REG_DWORD       -> Integer
+	REG_DWORD       -> Integer
-REG_NONE        -> nil
+	REG_NONE        -> nil
 "
 |data stringArray|
 %{
 HKEY myKey;
 DWORD valueType;
 union {
-DWORD dWord;
+	DWORD dWord;
-unsigned char dWordBytes[4];
+	unsigned char dWordBytes[4];
-unsigned char smallDataBuffer[256];
+	unsigned char smallDataBuffer[256];
 } quickData;
 int val;
 DWORD dataSize = sizeof(quickData);
 unsigned char *dataBuffer = NULL;
 if (__isExternalAddressLike(__INST(handle))
 && (__isString(aValueName) || __isSymbol(aValueName))) {
-int ret;
+	int ret;
-myKey = (HKEY)__externalAddressVal(__INST(handle));
+	myKey = (HKEY)__externalAddressVal(__INST(handle));
-/*
+	/*
-* try to get it with one call ...
+	 * try to get it with one call ...
-*/
+	 */
-ret = RegQueryValueEx(myKey, __stringVal(aValueName),
+	ret = RegQueryValueEx(myKey, __stringVal(aValueName),
-NULL,
+			 NULL,
-&valueType,
+			 &valueType,
-(char *)&quickData,
+			 (char *)&quickData,
-&dataSize);
+			 &dataSize);
-if (ret == ERROR_MORE_DATA) {
+	if (ret == ERROR_MORE_DATA) {
-/*
+	    /*
-* nope - need another one ...
+	     * nope - need another one ...
-*/
+	     */
-switch (valueType) {
+	    switch (valueType) {
-case REG_BINARY:
+		case REG_BINARY:
-case REG_MULTI_SZ:
+		case REG_MULTI_SZ:
-data = __BYTEARRAY_UNINITIALIZED_NEW_INT(dataSize);
+		    data = __BYTEARRAY_UNINITIALIZED_NEW_INT(dataSize);
-dataBuffer = __ByteArrayInstPtr(data)->ba_element;
+		    dataBuffer = __ByteArrayInstPtr(data)->ba_element;
-break;
+		    break;
-case REG_SZ:
+		case REG_SZ:
-data = __MKEMPTYSTRING(dataSize-1);
+		    data = __MKEMPTYSTRING(dataSize-1);
-dataBuffer = __stringVal(data);
+		    dataBuffer = __stringVal(data);
-break;
+		    break;
-}
+	    }
-if (dataBuffer) {
+	    if (dataBuffer) {
-ret = RegQueryValueEx(myKey, __stringVal(aValueName),
+		ret = RegQueryValueEx(myKey, __stringVal(aValueName),
-NULL,
+				 NULL,
-&valueType,
+				 &valueType,
-dataBuffer, &dataSize);
+				 dataBuffer, &dataSize);
-}
+	    }
-}
+	}
-if (ret == ERROR_SUCCESS) {
+	if (ret == ERROR_SUCCESS) {
-switch (valueType) {
+	    switch (valueType) {
-case REG_NONE:
+		case REG_NONE:
-/* RETURN (@symbol(none));  */
+		    /* RETURN (@symbol(none));  */
-RETURN (nil);
+		    RETURN (nil);
-case REG_BINARY:
+		case REG_BINARY:
-/*
+		    /*
-* did we get it with the first call ?
+		     * did we get it with the first call ?
-*/
+		     */
-if (! dataBuffer) {
+		    if (! dataBuffer) {
-data = __MKBYTEARRAY(quickData.smallDataBuffer, dataSize);
+			data = __MKBYTEARRAY(quickData.smallDataBuffer, dataSize);
-}
+		    }
-RETURN (data);
+		    RETURN (data);
-case REG_SZ:
+		case REG_SZ:
-case REG_EXPAND_SZ:
+		case REG_EXPAND_SZ:
-/*
+		    /*
-* did we get it with the first call ?
+		     * did we get it with the first call ?
-*/
+		     */
-if (! dataBuffer) {
+		    if (! dataBuffer) {
-data = __MKSTRING_L(quickData.smallDataBuffer, dataSize-1);
+			data = __MKSTRING_L(quickData.smallDataBuffer, dataSize-1);
-}
+		    }
-RETURN (data);
+		    RETURN (data);
 #if 0
-case REG_DWORD:
+		case REG_DWORD:
-/* int in native format */
+		    /* int in native format */
-RETURN (__MKUINT(quickData.dWord));
+		    RETURN (__MKUINT(quickData.dWord));
 #endif
-case REG_DWORD_LITTLE_ENDIAN:
+		case REG_DWORD_LITTLE_ENDIAN:
-val = quickData.dWordBytes[3];
+		    val = quickData.dWordBytes[3];
-val = (val << 8) | quickData.dWordBytes[2];
+		    val = (val << 8) | quickData.dWordBytes[2];
-val = (val << 8) | quickData.dWordBytes[1];
+		    val = (val << 8) | quickData.dWordBytes[1];
-val = (val << 8) | quickData.dWordBytes[0];
+		    val = (val << 8) | quickData.dWordBytes[0];
-RETURN (__MKUINT(val));
+		    RETURN (__MKUINT(val));
-case REG_DWORD_BIG_ENDIAN:
+		case REG_DWORD_BIG_ENDIAN:
-val = quickData.dWordBytes[0];
+		    val = quickData.dWordBytes[0];
-val = (val << 8) | quickData.dWordBytes[1];
+		    val = (val << 8) | quickData.dWordBytes[1];
-val = (val << 8) | quickData.dWordBytes[2];
+		    val = (val << 8) | quickData.dWordBytes[2];
-val = (val << 8) | quickData.dWordBytes[3];
+		    val = (val << 8) | quickData.dWordBytes[3];
-RETURN (__MKUINT(val));
+		    RETURN (__MKUINT(val));
-case REG_MULTI_SZ:
+		case REG_MULTI_SZ:
-{
+		    {
-char *cp, *cp0;
+			char *cp, *cp0;
-int ns = 0, i;
+			int ns = 0, i;
-cp0 = dataBuffer ? dataBuffer : quickData.smallDataBuffer;
+			cp0 = dataBuffer ? dataBuffer : quickData.smallDataBuffer;
-cp = cp0;
+			cp = cp0;
-while (*cp) {
+			while (*cp) {
-while (*cp++) ;;
+			    while (*cp++) ;;
-ns++;
+			    ns++;
-cp++;
+			    cp++;
-}
+			}
-stringArray = __ARRAY_NEW_INT(ns);
+			stringArray = __ARRAY_NEW_INT(ns);
-i = 0;
+			i = 0;
-while (*cp0) {
+			while (*cp0) {
-OBJ s;
+			    OBJ s;
-cp = cp0;
+			    cp = cp0;
-while (*cp++) ;;
+			    while (*cp++) ;;
-s = __MKSTRING(cp0); __ArrayInstPtr(stringArray)->a_element[i] = s; __STORE(stringArray, s);
+			    s = __MKSTRING(cp0); __ArrayInstPtr(stringArray)->a_element[i] = s; __STORE(stringArray, s);
-cp++;
+			    cp++;
-cp0 = cp;
+			    cp0 = cp;
-i++;
+			    i++;
-}
+			}
-RETURN (stringArray);
+			RETURN (stringArray);
-}
+		    }
-}
+	    }
-}
+	}
 }
 %}.
 ^ nil
 "
 "
 !
 valueNamed:aValueName put:datum
 "store a value; the value type depends upon the stored value:
-ByteArray       -> REG_BINARY
+	ByteArray       -> REG_BINARY
-String          -> REG_SZ
+	String          -> REG_SZ
-Array of string -> REG_MULTI_SZ
+	Array of string -> REG_MULTI_SZ
-Integer         -> REG_DWORD
+	Integer         -> REG_DWORD
-nil             -> REG_NONE
+	nil             -> REG_NONE
 "
 |data stringArray|
 %{
 HKEY myKey;
 unsigned char *dataPointer = NULL;
 int datumOk = 1, mustFreeData = 0;
 if (__isExternalAddressLike(__INST(handle))
 && (__isString(aValueName) || __isSymbol(aValueName))) {
-int ret;
+	int ret;
-OBJ cls;
+	OBJ cls;
-myKey = (HKEY)__externalAddressVal(__INST(handle));
+	myKey = (HKEY)__externalAddressVal(__INST(handle));
-if (datum == nil) {
+	if (datum == nil) {
-valueType = REG_NONE;
+	    valueType = REG_NONE;
-dataSize = 0;
+	    dataSize = 0;
-} else if (__isSmallInteger(datum)) {
+	} else if (__isSmallInteger(datum)) {
-valueType = REG_DWORD;
+	    valueType = REG_DWORD;
-val = __intVal(datum);
+	    val = __intVal(datum);
-dataPointer = (unsigned char *)(&val);
+	    dataPointer = (unsigned char *)(&val);
-dataSize = sizeof(val);
+	    dataSize = sizeof(val);
-} else if (__isString(datum) || __isSymbol(datum)) {
+	} else if (__isString(datum) || __isSymbol(datum)) {
-valueType = REG_SZ;
+	    valueType = REG_SZ;
-dataPointer = __stringVal(datum);
+	    dataPointer = __stringVal(datum);
-dataSize = __stringSize(datum) + 1;
+	    dataSize = __stringSize(datum) + 1;
-} else if (__Class(datum) == ByteArray) {
+	} else if (__Class(datum) == ByteArray) {
-valueType = REG_BINARY;
+	    valueType = REG_BINARY;
-dataPointer = __ByteArrayInstPtr(datum)->ba_element;
+	    dataPointer = __ByteArrayInstPtr(datum)->ba_element;
-dataSize = __byteArraySize(datum);
+	    dataSize = __byteArraySize(datum);
-} else if (__Class(datum) == LargeInteger) {
+	} else if (__Class(datum) == LargeInteger) {
-valueType = REG_DWORD;
+	    valueType = REG_DWORD;
-val = __longIntVal(datum);
+	    val = __longIntVal(datum);
-if (val) {
+	    if (val) {
-dataPointer = (unsigned char *)(&val);
+		dataPointer = (unsigned char *)(&val);
-dataSize = sizeof(val);
+		dataSize = sizeof(val);
-} else {
+	    } else {
-datumOk = 0;
+		datumOk = 0;
-}
+	    }
-} else if (__Class(datum) == Array) {
+	} else if (__Class(datum) == Array) {
-int i = 0, ns = 0, totalSize = 0;
+	    int i = 0, ns = 0, totalSize = 0;
-valueType = REG_MULTI_SZ;
+	    valueType = REG_MULTI_SZ;
-/*
+	    /*
-* must allocate a local buffer
+	     * must allocate a local buffer
-* find size ...
+	     * find size ...
-*/
+	     */
-for (i=0; i<__arraySize(datum); i++) {
+	    for (i=0; i<__arraySize(datum); i++) {
-OBJ s = __ArrayInstPtr(datum)->a_element[i];
+		OBJ s = __ArrayInstPtr(datum)->a_element[i];
-if (__isString(datum) || __isSymbol(datum)) {
+		if (__isString(datum) || __isSymbol(datum)) {
-totalSize += __stringSize(datum) + 1;
+		    totalSize += __stringSize(datum) + 1;
-} else {
+		} else {
-datumOk = 0;
+		    datumOk = 0;
-break;
+		    break;
-}
+		}
-ns++;
+		ns++;
-}
+	    }
-if (datumOk) {
+	    if (datumOk) {
-char *cp;
+		char *cp;
-/*
+		/*
-* allocate and fill...
+		 * allocate and fill...
-*/
+		 */
-totalSize ++;
+		totalSize ++;
-dataPointer = (char *)(malloc(totalSize));
+		dataPointer = (char *)(malloc(totalSize));
-mustFreeData = 1;
+		mustFreeData = 1;
-cp = dataPointer;
+		cp = dataPointer;
-for (i=0; i<__arraySize(datum); i++) {
+		for (i=0; i<__arraySize(datum); i++) {
-OBJ s = __ArrayInstPtr(datum)->a_element[i];
+		    OBJ s = __ArrayInstPtr(datum)->a_element[i];
-strcpy(cp, __stringVal(s));
+		    strcpy(cp, __stringVal(s));
-cp += __stringSize(datum);
+		    cp += __stringSize(datum);
-*cp++ = '\0';
+		    *cp++ = '\0';
-}
+		}
-*cp++ = '\0';
+		*cp++ = '\0';
-dataSize = totalSize;
+		dataSize = totalSize;
-}
+	    }
-} else {
+	} else {
-datumOk = 0;
+	    datumOk = 0;
-}
+	}
-if (datumOk) {
+	if (datumOk) {
-ret = RegSetValueEx(myKey, __stringVal(aValueName),
+	    ret = RegSetValueEx(myKey, __stringVal(aValueName),
-0, valueType,
+				0, valueType,
-dataPointer, dataSize);
+				dataPointer, dataSize);
-if (mustFreeData) {
+	    if (mustFreeData) {
-free(dataPointer);
+		free(dataPointer);
-}
+	    }
-RETURN ((ret == ERROR_SUCCESS) ? true : false);
+	    RETURN ((ret == ERROR_SUCCESS) ? true : false);
-}
+	}
 }
 %}.
 ^ false
 "
 |idx subEntry|
 idx := 0.
 [true] whileTrue:[
-subEntry := self subKeyAtIndex:idx.
+	subEntry := self subKeyAtIndex:idx.
-subEntry isNil ifTrue:[
+	subEntry isNil ifTrue:[
-^self
+	    ^self
-].
+	].
-aBlock value:subEntry.
+	aBlock value:subEntry.
-subEntry allSubKeysDo:aBlock.
+	subEntry allSubKeysDo:aBlock.
-subEntry close.
+	subEntry close.
-idx := idx + 1.
+	idx := idx + 1.
 ]
 "
 |top sub|
 top := self key:'HKEY_LOCAL_MACHINE'.
 top allSubKeysDo:[:subEntry |
-Transcript showCR:subEntry path
+	Transcript showCR:subEntry path
 ]
 "
 !
 subKeys
 |idx subEntry|
 idx := 0.
 [true] whileTrue:[
-subEntry := self subKeyAtIndex:idx.
+	subEntry := self subKeyAtIndex:idx.
-subEntry isNil ifTrue:[
+	subEntry isNil ifTrue:[
-^self
+	    ^self
-].
+	].
-aBlock value:subEntry.
+	aBlock value:subEntry.
-subEntry close.
+	subEntry close.
-idx := idx + 1.
+	idx := idx + 1.
 ]
 "
 |top sub|
 top := self key:'HKEY_LOCAL_MACHINE'.
 top subKeysDo:[:subEntry |
-Transcript showCR:subEntry path
+	Transcript showCR:subEntry path
 ]
 "
 !
 valueNamesAndValuesDo:aBlock
 "evaluate aBlock for all value names"
 self valueNamesDo:[:nm |
-aBlock value:nm value:(self valueNamed:nm)
+	aBlock value:nm value:(self valueNamed:nm)
 ]
 "
 |key|
 key := self key:'HKEY_LOCAL_MACHINE\SOFTWARE\eXept\Smalltalk/X'.
 key valueNamesAndValuesDo:[:nm :val |
-Transcript showCR:(nm , ' -> ' , val storeString).
+	Transcript showCR:(nm , ' -> ' , val storeString).
 ]
 "
 !
 valueNamesDo:aBlock
 |idx valueName|
 idx := 0.
 [true] whileTrue:[
-valueName := self valueNameAtIndex:idx.
+	valueName := self valueNameAtIndex:idx.
-valueName isNil ifTrue:[
+	valueName isNil ifTrue:[
-^self
+	    ^self
-].
+	].
-aBlock value:valueName.
+	aBlock value:valueName.
-idx := idx + 1.
+	idx := idx + 1.
 ]
 ! !
 !Win32OperatingSystem::RegistryEntry methodsFor:'instance release'!
 %{
 HKEY myKey;
 if (__isExternalAddressLike(__INST(handle))) {
-myKey = (HKEY)(__externalAddressVal(__INST(handle)));
+	myKey = (HKEY)(__externalAddressVal(__INST(handle)));
-__INST(handle) = nil;
+	__INST(handle) = nil;
-RegCloseKey(myKey);
+	RegCloseKey(myKey);
 }
 %}
 !
 finalizationLobby
 finalize
 "some entry has been collected - close it"
 handle notNil ifTrue:[
-self closeKey.
+	self closeKey.
 ]
 "Created: / 19.5.1999 / 22:39:52 / cg"
 "Modified: / 19.5.1999 / 22:44:50 / cg"
 ! !
 HKEY key;
 OBJ t;
 key = __longIntVal(integerHandleValue);
 if (! key) {
-RETURN (nil);
+	RETURN (nil);
 }
 t = __MKEXTERNALADDRESS(key); __INST(handle) = t; __STORE(self, t);
 %}.
 int bufferSize;
 char miniBuffer[32];
 BOOL ok;
 if ((hFile == 0) || (hFile == INVALID_HANDLE_VALUE)) {
-errSym = @symbol(errorNotOpen);
+	errSym = @symbol(errorNotOpen);
-goto bad;
+	goto bad;
 }
 if (! __bothSmallInteger(count, firstIndex)) {
-errSym = @symbol(badArgument);
+	errSym = @symbol(badArgument);
-goto bad;
+	goto bad;
 }
 cntWanted = __smallIntegerVal(count);
 if (cntWanted <= 0) {
-errSym = @symbol(badCount);
+	errSym = @symbol(badCount);
-goto bad;
+	goto bad;
 }
 offs = __smallIntegerVal(firstIndex) - 1;
 if (offs < 0) {
-errSym = @symbol(badOffset);
+	errSym = @symbol(badOffset);
-goto bad;
+	goto bad;
 }
 bufferIsExternalBytes = __isExternalBytesLike(aByteBuffer);
 if (! bufferIsExternalBytes) {
-if (__isByteArray(aByteBuffer)) {
+	if (__isByteArray(aByteBuffer)) {
-bufferSize = __byteArraySize(aByteBuffer);
+	    bufferSize = __byteArraySize(aByteBuffer);
-} else if (__isString(aByteBuffer)) {
+	} else if (__isString(aByteBuffer)) {
-bufferSize = __stringSize(aByteBuffer);
+	    bufferSize = __stringSize(aByteBuffer);
-} else {
+	} else {
-errSym = @symbol(badBuffer);
+	    errSym = @symbol(badBuffer);
-goto bad;
+	    goto bad;
-}
+	}
-if (bufferSize < (cntWanted + offs)) {
+	if (bufferSize < (cntWanted + offs)) {
-errSym = @symbol(badBufferSize);
+	    errSym = @symbol(badBufferSize);
-goto bad;
+	    goto bad;
-}
+	}
-if (cntWanted <= sizeof(miniBuffer)) {
+	if (cntWanted <= sizeof(miniBuffer)) {
-extPtr = miniBuffer;
+	    extPtr = miniBuffer;
-} else {
+	} else {
-extPtr = malloc(cntWanted);
+	    extPtr = malloc(cntWanted);
-mustFreeBuffer = 1;
+	    mustFreeBuffer = 1;
-}
+	}
 } else {
-OBJ sz;
+	OBJ sz;
-extPtr = (char *)(__externalBytesAddress(aByteBuffer));
+	extPtr = (char *)(__externalBytesAddress(aByteBuffer));
-sz = __externalBytesSize(aByteBuffer);
+	sz = __externalBytesSize(aByteBuffer);
-if (! __isSmallInteger(sz)) {
+	if (! __isSmallInteger(sz)) {
-errSym = @symbol(badBufferSize);
+	    errSym = @symbol(badBufferSize);
-goto bad;
+	    goto bad;
-}
+	}
-bufferSize = __smallIntegerVal(sz);
+	bufferSize = __smallIntegerVal(sz);
-if (bufferSize < (cntWanted + offs)) {
+	if (bufferSize < (cntWanted + offs)) {
-errSym = @symbol(badBufferSize);
+	    errSym = @symbol(badBufferSize);
-goto bad;
+	    goto bad;
-}
+	}
-extPtr = extPtr + offs;
+	extPtr = extPtr + offs;
 }
 do {
-__threadErrno = 0;
+	__threadErrno = 0;
-ok = STX_API_CALL5( "ReadFile", ReadFile, hFile, extPtr, cntWanted, &cntRead, 0 /* lpOverlapped */);
+	ok = STX_API_CALL5( "ReadFile", ReadFile, hFile, extPtr, cntWanted, &cntRead, 0 /* lpOverlapped */);
 } while(__threadErrno == EINTR);
 if (ok == TRUE) {
-if (! bufferIsExternalBytes) {
+	if (! bufferIsExternalBytes) {
-/* copy over */
+	    /* copy over */
-memcpy(__byteArrayVal(aByteBuffer)+offs, extPtr, cntRead);
+	    memcpy(__byteArrayVal(aByteBuffer)+offs, extPtr, cntRead);
-if (mustFreeBuffer) {
+	    if (mustFreeBuffer) {
-free(extPtr);
+		free(extPtr);
-}
+	    }
-}
+	}
-RETURN (__mkSmallInteger(cntRead));
+	RETURN (__mkSmallInteger(cntRead));
 }
 errorNumber = __mkSmallInteger( __WIN32_ERR(GetLastError()) );
 bad: ;
 if (mustFreeBuffer) {
-free(extPtr);
+	free(extPtr);
 }
 %}.
 errorNumber isNil ifTrue:[
-self error:'invalid argument(s): ', errSym.
+	self error:'invalid argument(s): ', errSym.
 ] ifFalse:[
-(OperatingSystem errorHolderForNumber:errorNumber) reportError
+	(OperatingSystem errorHolderForNumber:errorNumber) reportError
 ].
 "
 |h buff n|
 HANDLE hFile = (HANDLE)(__externalAddressVal(self));
 DWORD res;
 INT t;
 if ((hFile == 0) || (hFile == INVALID_HANDLE_VALUE)) {
-errSym = @symbol(errorNotOpen);
+	errSym = @symbol(errorNotOpen);
-goto bad;
+	goto bad;
 }
 #if 0
 if (ioctlsocket((SOCKET)hFile, FIONREAD, &res)==0) {
-/* its a socket */
+	/* its a socket */
-if (res > 0) {
+	if (res > 0) {
-RETURN ( false );
+	    RETURN ( false );
-}
+	}
 }
 if (PeekNamedPipe(hFile, 0, 0, 0, &res, 0)) {
-/* its a namedPipe */
+	/* its a namedPipe */
-if (res > 0) {
+	if (res > 0) {
-RETURN ( false );
+	    RETURN ( false );
-}
+	}
 }
 #endif
 if (__isSmallInteger(millis)) {
-t = __intVal(millis);
+	t = __intVal(millis);
 } else {
-t = INFINITE;
+	t = INFINITE;
 }
 do {
-__threadErrno = 0;
+	__threadErrno = 0;
-res = WaitForSingleObject(hFile, t);
+	res = WaitForSingleObject(hFile, t);
 } while (__threadErrno == EINTR);
 switch (res) {
-case WAIT_OBJECT_0:
+	case WAIT_OBJECT_0:
-/* signalled */
+	    /* signalled */
-RETURN ( false );
+	    RETURN ( false );
-case WAIT_TIMEOUT:
+	case WAIT_TIMEOUT:
-/* signalled */
+	    /* signalled */
-RETURN ( true );
+	    RETURN ( true );
-default:
+	default:
-case WAIT_ABANDONED:
+	case WAIT_ABANDONED:
-errorNumber = __mkSmallInteger( __WIN32_ERR(GetLastError()) );
+	    errorNumber = __mkSmallInteger( __WIN32_ERR(GetLastError()) );
-goto bad;
+	    goto bad;
 }
 bad: ;
 %}.
 "
 ^ self primitiveFailed
 !
 seekTo:newPosition from:whence
 "whence is one of:
-#begin
+	#begin
-#current
+	#current
-#end
+	#end
 "
 |errSym errorNumber|
 %{
 DWORD moveHow;
 LONG posLo, posHi = 0;
 __uint64__ pos64, newPos64;
 if ((hFile == 0) || (hFile == INVALID_HANDLE_VALUE)) {
-errSym = @symbol(errorNotOpen);
+	errSym = @symbol(errorNotOpen);
-goto bad;
+	goto bad;
 }
 if (whence == @symbol(begin)) {
-moveHow = FILE_BEGIN;
+	moveHow = FILE_BEGIN;
 } else if (whence == @symbol(current)) {
-moveHow = FILE_CURRENT;
+	moveHow = FILE_CURRENT;
 } else if (whence == @symbol(end)) {
-moveHow = FILE_END;
+	moveHow = FILE_END;
 } else {
-errSym = @symbol(badArgument2);
+	errSym = @symbol(badArgument2);
-goto bad;
+	goto bad;
 }
 if (__signedLong64IntVal(newPosition, &pos64) == 0) {
-errSym = @symbol(badArgument);
+	errSym = @symbol(badArgument);
-goto bad;
+	goto bad;
 }
 posLo = pos64.lo;
 posHi = pos64.hi;
 posLo = SetFilePointer(hFile, posLo, &posHi, moveHow);
 if (posLo == 0xFFFFFFFF) {
-int lastError;
+	int lastError;
-/* can be either an error, or a valid low-word */
+	/* can be either an error, or a valid low-word */
-lastError = GetLastError();
+	lastError = GetLastError();
-if (lastError != NO_ERROR) {
+	if (lastError != NO_ERROR) {
-errorNumber = __mkSmallInteger( __WIN32_ERR(lastError) );
+	    errorNumber = __mkSmallInteger( __WIN32_ERR(lastError) );
-goto bad;
+	    goto bad;
-}
+	}
 }
 if (posHi == 0) {
-RETURN (__MKUINT( posLo ));
+	RETURN (__MKUINT( posLo ));
 }
 newPos64.lo = posLo;
 newPos64.hi = posHi;
 RETURN ( __MKUINT64(&newPos64) );
 bad: ;
 %}.
 errorNumber isNil ifTrue:[
-self error:'invalid argument(s): ', errSym.
+	self error:'invalid argument(s): ', errSym.
 ] ifFalse:[
-(OperatingSystem errorHolderForNumber:errorNumber) reportError
+	(OperatingSystem errorHolderForNumber:errorNumber) reportError
 ].
 !
 writeBytes:count from:aByteBuffer startingAt:firstIndex
 "write count bytes from a byte-buffer;
 int bufferSize;
 char miniBuffer[32];
 BOOL ok;
 if ((hFile == 0) || (hFile == INVALID_HANDLE_VALUE)) {
-errSym = @symbol(errorNotOpen);
+	errSym = @symbol(errorNotOpen);
-goto bad;
+	goto bad;
 }
 if (! __bothSmallInteger(count, firstIndex)) {
-errSym = @symbol(badArgument);
+	errSym = @symbol(badArgument);
-goto bad;
+	goto bad;
 }
 cntWanted = __smallIntegerVal(count);
 if (cntWanted <= 0) {
-errSym = @symbol(badCount);
+	errSym = @symbol(badCount);
-goto bad;
+	goto bad;
 }
 offs = __smallIntegerVal(firstIndex) - 1;
 if (offs < 0) {
-errSym = @symbol(badOffset);
+	errSym = @symbol(badOffset);
-goto bad;
+	goto bad;
 }
 bufferIsExternalBytes = __isExternalBytesLike(aByteBuffer);
 if (! bufferIsExternalBytes) {
-if (__isByteArray(aByteBuffer)) {
+	if (__isByteArray(aByteBuffer)) {
-bufferSize = __byteArraySize(aByteBuffer);
+	    bufferSize = __byteArraySize(aByteBuffer);
-} else if (__isString(aByteBuffer)) {
+	} else if (__isString(aByteBuffer)) {
-bufferSize = __stringSize(aByteBuffer);
+	    bufferSize = __stringSize(aByteBuffer);
-} else {
+	} else {
-errSym = @symbol(badBuffer);
+	    errSym = @symbol(badBuffer);
-goto bad;
+	    goto bad;
-}
+	}
-if (bufferSize < (cntWanted + offs)) {
+	if (bufferSize < (cntWanted + offs)) {
-errSym = @symbol(badBufferSize);
+	    errSym = @symbol(badBufferSize);
-goto bad;
+	    goto bad;
-}
+	}
-if (cntWanted <= sizeof(miniBuffer)) {
+	if (cntWanted <= sizeof(miniBuffer)) {
-extPtr = miniBuffer;
+	    extPtr = miniBuffer;
-} else {
+	} else {
-extPtr = malloc(cntWanted);
+	    extPtr = malloc(cntWanted);
-mustFreeBuffer = 1;
+	    mustFreeBuffer = 1;
-}
+	}
-memcpy(extPtr, __byteArrayVal(aByteBuffer)+offs, cntWanted);
+	memcpy(extPtr, __byteArrayVal(aByteBuffer)+offs, cntWanted);
 } else {
-extPtr = (char *)(__externalBytesAddress(aByteBuffer));
+	extPtr = (char *)(__externalBytesAddress(aByteBuffer));
-bufferSize = __externalBytesSize(aByteBuffer);
+	bufferSize = __externalBytesSize(aByteBuffer);
-if (! __isSmallInteger(bufferSize)) {
+	if (! __isSmallInteger(bufferSize)) {
-errSym = @symbol(badBufferSize);
+	    errSym = @symbol(badBufferSize);
-goto bad;
+	    goto bad;
-}
+	}
-bufferSize = __smallIntegerVal(bufferSize);
+	bufferSize = __smallIntegerVal(bufferSize);
-if (bufferSize < (cntWanted + offs)) {
+	if (bufferSize < (cntWanted + offs)) {
-errSym = @symbol(badBufferSize);
+	    errSym = @symbol(badBufferSize);
-goto bad;
+	    goto bad;
-}
+	}
-extPtr = extPtr + offs;
+	extPtr = extPtr + offs;
 }
 do {
-__threadErrno = 0;
+	__threadErrno = 0;
-ok = STX_API_CALL5( "WriteFile", WriteFile, hFile, extPtr, cntWanted, &cntWritten, 0 /* lpOverlapped */);
+	ok = STX_API_CALL5( "WriteFile", WriteFile, hFile, extPtr, cntWanted, &cntWritten, 0 /* lpOverlapped */);
 } while(__threadErrno == EINTR);
 if (ok == TRUE) {
-if (mustFreeBuffer) {
+	if (mustFreeBuffer) {
-free(extPtr);
+	    free(extPtr);
-}
+	}
-RETURN (__mkSmallInteger(cntWritten));
+	RETURN (__mkSmallInteger(cntWritten));
 }
 errorNumber = __mkSmallInteger( __WIN32_ERR(GetLastError()) );
 bad: ;
 if (mustFreeBuffer) {
-free(extPtr);
+	free(extPtr);
 }
 %}.
 errorNumber isNil ifTrue:[
-self error:'invalid argument(s): ', errSym.
+	self error:'invalid argument(s): ', errSym.
 ] ifFalse:[
-(OperatingSystem errorHolderForNumber:errorNumber) reportError
+	(OperatingSystem errorHolderForNumber:errorNumber) reportError
 ].
 "
 |h buff n|
 %{
 HANDLE h = (HANDLE)(__externalAddressVal(self));
 if (h) {
-__externalAddressVal(self) = (HANDLE)0;
+	__externalAddressVal(self) = (HANDLE)0;
-CloseHandle(h);
+	CloseHandle(h);
 }
 %}.
 ! !
 !Win32OperatingSystem::Win32PrinterHandle methodsFor:'release'!
 closeHandle
 self address ~~ 0 ifTrue:[
-OperatingSystem primClosePrinter:self.
+	OperatingSystem primClosePrinter:self.
 ]
 "Created: / 27-07-2006 / 14:48:37 / fm"
 ! !
 ! !
 !Win32OperatingSystem::Win32SerialPortHandle methodsFor:'opening'!
 open:portName baudRate:baudRate stopBitsType:stopBitsType
-parityType:parityType dataBits:dataBits
+		    parityType:parityType dataBits:dataBits
-inFlowCtrl:inFlowCtrlType outFlowCtrl:outFlowCtrlType
+		    inFlowCtrl:inFlowCtrlType outFlowCtrl:outFlowCtrlType
-xOnChar:xOnChar xOffChar:xOffChar
+		    xOnChar:xOnChar xOffChar:xOffChar
 "portName: COM%d
 baudRate: Integer
 stopBitsType: #stop1, #stop2 or #stop1_5
 parityType: #odd, #even or #none
 dataBits: #integer
 HANDLE port;
 COMMTIMEOUTS timeouts;
 DCB dcb;
 char *__portName;
 int __setBaudRate = 1,
-__setDataBits = 1,
+	__setDataBits = 1,
-__setXOnChar = 1,
+	__setXOnChar = 1,
-__setXOffChar = 1,
+	__setXOffChar = 1,
-__setInFlowCtrl = 1,
+	__setInFlowCtrl = 1,
-__setOutFlowCtrl = 1,
+	__setOutFlowCtrl = 1,
-__setStopBits = 1,
+	__setStopBits = 1,
-__setParityType = 1;
+	__setParityType = 1;
 int __baudRate, __dataBits;
 int __xOnChar, __xOffChar;
 int __inFlowCtrl, __outFlowCtrl;
 int __stopBits, __parityType;
 #   define XONOFF       1
 #   define ODD       1
 #   define EVEN      2
 #   define NONE      3
 if (__isString(portName)) {
-__portName = __stringVal(portName);
+	__portName = __stringVal(portName);
 } else {
-goto failure;
+	goto failure;
 }
 if (__isSmallInteger(baudRate)) {
-__baudRate = __intVal(baudRate);
+	__baudRate = __intVal(baudRate);
 } else if (baudRate == nil) {
-__setBaudRate = 0;
+	__setBaudRate = 0;
 } else {
-goto failure;
+	goto failure;
 }
 if (__isSmallInteger(dataBits)) {
-__dataBits = __intVal(dataBits);
+	__dataBits = __intVal(dataBits);
 } else if (dataBits == nil) {
-__setDataBits = 0;
+	__setDataBits = 0;
 } else {
-goto failure;
+	goto failure;
 }
 if (__isSmallInteger(xOnChar)) {
-__xOnChar = __intVal(xOnChar);
+	__xOnChar = __intVal(xOnChar);
 } else if (__isCharacter(xOnChar)) {
-__xOnChar = __intVal(_characterVal(xOnChar));
+	__xOnChar = __intVal(_characterVal(xOnChar));
 } else if (xOnChar == nil) {
-__setXOnChar = 0;
+	__setXOnChar = 0;
 } else {
-goto failure;
+	goto failure;
 }
 if (__isSmallInteger(xOffChar)) {
-__xOffChar = __intVal(xOffChar);
+	__xOffChar = __intVal(xOffChar);
 } else if (__isCharacter(xOffChar)) {
-__xOffChar = __intVal(_characterVal(xOffChar));
+	__xOffChar = __intVal(_characterVal(xOffChar));
 } else if (xOffChar == nil) {
-__setXOffChar = 0;
+	__setXOffChar = 0;
 } else {
-goto failure;
+	goto failure;
 }
 if (inFlowCtrlType == @symbol(xOnOff)) {
-__inFlowCtrl = XONOFF;
+	__inFlowCtrl = XONOFF;
 } else if (inFlowCtrlType == @symbol(hardware)) {
-__inFlowCtrl = HARDWARE;
+	__inFlowCtrl = HARDWARE;
 } else if (inFlowCtrlType == nil) {
-__setInFlowCtrl = 0;
+	__setInFlowCtrl = 0;
 } else {
-goto failure;
+	goto failure;
 }
 if (outFlowCtrlType == @symbol(xOnOff)) {
-__outFlowCtrl = XONOFF;
+	__outFlowCtrl = XONOFF;
 } else if (outFlowCtrlType == @symbol(hardware)) {
-__outFlowCtrl = HARDWARE;
+	__outFlowCtrl = HARDWARE;
 } else if (outFlowCtrlType == nil) {
-__setOutFlowCtrl = 0;
+	__setOutFlowCtrl = 0;
 } else {
-goto failure;
+	goto failure;
 }
 if (stopBitsType == @symbol(stop1)) {
-__stopBits = STOP1;
+	__stopBits = STOP1;
 } else if (stopBitsType == @symbol(stop2)) {
-__stopBits = STOP2;
+	__stopBits = STOP2;
 } else if (stopBitsType == @symbol(stop1_5)) {
-__stopBits = STOP1_5;
+	__stopBits = STOP1_5;
 } else if (stopBitsType == nil) {
-__setStopBits = 0;
+	__setStopBits = 0;
 } else {
-goto failure;
+	goto failure;
 }
 port = CreateFile(__portName,
-GENERIC_READ | GENERIC_WRITE,
+	      GENERIC_READ | GENERIC_WRITE,
-0,             /* comm devices must be opened with exclusive access */
+	      0,             /* comm devices must be opened with exclusive access */
-NULL,          /* no security attrs */
+	      NULL,          /* no security attrs */
-OPEN_EXISTING, /* comm devices must use OPEN_EXISTING */
+	      OPEN_EXISTING, /* comm devices must use OPEN_EXISTING */
-0,             /* no overlapped I/O */
+	      0,             /* no overlapped I/O */
-NULL           /* hTemplate must be NULL for comm devices */
+	      NULL           /* hTemplate must be NULL for comm devices */
-);
+	   );
 if (port == INVALID_HANDLE_VALUE) {
-console_fprintf(stderr, "Win32OS [info]: serial port open failed\n");
+	console_fprintf(stderr, "Win32OS [info]: serial port open failed\n");
-errorNumber = __mkSmallInteger( __WIN32_ERR(GetLastError()) );
+	errorNumber = __mkSmallInteger( __WIN32_ERR(GetLastError()) );
-goto failure;
+	goto failure;
 }
 /* Flush the driver */
 PurgeComm( port, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR );
 /* Set driver buffer sizes */
 if (__setDataBits) dcb.ByteSize = __dataBits;
 if (__setXOnChar)  dcb.XonChar = __xOnChar;
 if (__setXOffChar) dcb.XoffChar = __xOffChar;
 if (__setStopBits) {
-/* set stop bits */
+	/* set stop bits */
-switch(__stopBits) {
+	switch(__stopBits) {
-case STOP1_5: dcb.StopBits = 1; break; /* 1.5 stop bits */
+	    case STOP1_5: dcb.StopBits = 1; break; /* 1.5 stop bits */
-case STOP1: dcb.StopBits = 0; break; /* 1 stop bit */
+	    case STOP1: dcb.StopBits = 0; break; /* 1 stop bit */
-case STOP2: dcb.StopBits = 2; break; /* 2 stop bits */
+	    case STOP2: dcb.StopBits = 2; break; /* 2 stop bits */
-default: goto errExit;
+	    default: goto errExit;
-}
+	}
 }
 if (__setParityType) {
-/* set parity */
+	/* set parity */
-switch(__parityType) {
+	switch(__parityType) {
-case NONE: dcb.Parity = NOPARITY; break;
+	    case NONE: dcb.Parity = NOPARITY; break;
-case ODD: dcb.Parity = ODDPARITY; break;
+	    case ODD: dcb.Parity = ODDPARITY; break;
-case EVEN: dcb.Parity = EVENPARITY; break;
+	    case EVEN: dcb.Parity = EVENPARITY; break;
-default: goto errExit;
+	    default: goto errExit;
-}
+	}
 }
 if (__setInFlowCtrl) {
-/* set control flow */
+	/* set control flow */
-dcb.fInX = FALSE;
+	dcb.fInX = FALSE;
-dcb.fDtrControl = FALSE;
+	dcb.fDtrControl = FALSE;
-if (__inFlowCtrl == XONOFF) dcb.fInX = TRUE;  /* XOn/XOff handshaking */
+	if (__inFlowCtrl == XONOFF) dcb.fInX = TRUE;  /* XOn/XOff handshaking */
-if (__inFlowCtrl == HARDWARE) dcb.fDtrControl = TRUE;  /* hardware handshaking */
+	if (__inFlowCtrl == HARDWARE) dcb.fDtrControl = TRUE;  /* hardware handshaking */
 }
 if (__setOutFlowCtrl) {
-dcb.fOutX = FALSE;
+	dcb.fOutX = FALSE;
-dcb.fOutxCtsFlow = FALSE;
+	dcb.fOutxCtsFlow = FALSE;
-if (__outFlowCtrl == XONOFF) dcb.fOutX = TRUE;  /* XOn/XOff handshaking */
+	if (__outFlowCtrl == XONOFF) dcb.fOutX = TRUE;  /* XOn/XOff handshaking */
-if (__outFlowCtrl == HARDWARE) dcb.fOutxCtsFlow = TRUE;  /* hardware handshaking */
+	if (__outFlowCtrl == HARDWARE) dcb.fOutxCtsFlow = TRUE;  /* hardware handshaking */
 }
 if (SetCommState(port, &dcb)) {
-RETURN( true );
+	RETURN( true );
 }
 console_fprintf(stderr, "Win32OS [info]: serial port comm-setup failed\n");
 errorNumber = __mkSmallInteger( __WIN32_ERR(GetLastError()) );
 /* fall into */
 #   undef ODD
 #   undef EVEN
 #   undef NONE
 %}.
 errorNumber isNil ifTrue:[
-self error:'invalid argument(s)'.
+	self error:'invalid argument(s)'.
 ] ifFalse:[
-(OperatingSystem errorHolderForNumber:errorNumber) reportError
+	(OperatingSystem errorHolderForNumber:errorNumber) reportError
 ].
 ! !
 !Win32OperatingSystem::Win32SerialPortHandle methodsFor:'release'!
 %{
 HANDLE port = (HANDLE)(__externalAddressVal(self));
 if (port) {
-__externalAddressVal(self) = (HANDLE)0;
+	__externalAddressVal(self) = (HANDLE)0;
-PurgeComm( port, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR );
+	PurgeComm( port, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR );
-CloseHandle(port);
+	CloseHandle(port);
 }
 %}.
 ! !
 !Win32OperatingSystem::Win32SerialPortHandle methodsFor:'setup'!
 %{
 HANDLE port = (HANDLE)(__externalAddressVal(self));
 if (port
 && __isSmallInteger(newRate)) {
-DCB dcb;
+	DCB dcb;
-ZeroMemory(&dcb, sizeof(dcb));
+	ZeroMemory(&dcb, sizeof(dcb));
-dcb.DCBlength = sizeof(dcb);
+	dcb.DCBlength = sizeof(dcb);
-GetCommState(port, &dcb);
+	GetCommState(port, &dcb);
-dcb.BaudRate = __intVal(newRate);
+	dcb.BaudRate = __intVal(newRate);
-if (! SetCommState(port, &dcb)) {
+	if (! SetCommState(port, &dcb)) {
-RETURN(false);
+	    RETURN(false);
-}
+	}
-RETURN(true);
+	RETURN(true);
 }
 %}.
 self primitiveFailed.
 !
 %{
 HANDLE port = (HANDLE)(__externalAddressVal(self));
 if (port
 && __isSmallInteger(newNumberOfBits)) {
-DCB dcb;
+	DCB dcb;
-ZeroMemory(&dcb, sizeof(dcb));
+	ZeroMemory(&dcb, sizeof(dcb));
-dcb.DCBlength = sizeof(dcb);
+	dcb.DCBlength = sizeof(dcb);
-GetCommState(port, &dcb);
+	GetCommState(port, &dcb);
-dcb.ByteSize = __intVal(newNumberOfBits);
+	dcb.ByteSize = __intVal(newNumberOfBits);
-if (! SetCommState(port, &dcb)) {
+	if (! SetCommState(port, &dcb)) {
-RETURN(false);
+	    RETURN(false);
-}
+	}
-RETURN(true);
+	RETURN(true);
 }
 %}.
 self primitiveFailed.
 !
 %{
 HANDLE port = (HANDLE)(__externalAddressVal(self));
 if (port) {
-DCB dcb;
+	DCB dcb;
-ZeroMemory(&dcb, sizeof(dcb));
+	ZeroMemory(&dcb, sizeof(dcb));
-dcb.DCBlength = sizeof(dcb);
+	dcb.DCBlength = sizeof(dcb);
-GetCommState(port, &dcb);
+	GetCommState(port, &dcb);
-if ((newParityTypeSymbol == nil) || (newParityTypeSymbol == @symbol(none))) {
+	if ((newParityTypeSymbol == nil) || (newParityTypeSymbol == @symbol(none))) {
-dcb.Parity = NOPARITY;
+	    dcb.Parity = NOPARITY;
-} else if (newParityTypeSymbol == @symbol(odd)) {
+	} else if (newParityTypeSymbol == @symbol(odd)) {
-dcb.Parity = ODDPARITY;
+	    dcb.Parity = ODDPARITY;
-} else if (newParityTypeSymbol == @symbol(even)) {
+	} else if (newParityTypeSymbol == @symbol(even)) {
-dcb.Parity = EVENPARITY;
+	    dcb.Parity = EVENPARITY;
-} else {
+	} else {
-goto failure;
+	    goto failure;
-}
+	}
-if (! SetCommState(port, &dcb)) {
+	if (! SetCommState(port, &dcb)) {
-RETURN(false);
+	    RETURN(false);
-}
+	}
-RETURN(true);
+	RETURN(true);
 }
 failure: ;
 %}.
 self primitiveFailed.
 !
 "newParityTypeSymbol must be one of #stop1, #stop2 or #stop1_5"
 %{
 HANDLE port = (HANDLE)(__externalAddressVal(self));
 if (port) {
-DCB dcb;
+	DCB dcb;
-ZeroMemory(&dcb, sizeof(dcb));
+	ZeroMemory(&dcb, sizeof(dcb));
-dcb.DCBlength = sizeof(dcb);
+	dcb.DCBlength = sizeof(dcb);
-GetCommState(port, &dcb);
+	GetCommState(port, &dcb);
-if (newStopBitsSymbol == @symbol(stop1)) {
+	if (newStopBitsSymbol == @symbol(stop1)) {
-dcb.Parity = 0 /* STOP1 */;
+	    dcb.Parity = 0 /* STOP1 */;
-} else if (newStopBitsSymbol == @symbol(stop2)) {
+	} else if (newStopBitsSymbol == @symbol(stop2)) {
-dcb.Parity = 2 /* STOP2 */;
+	    dcb.Parity = 2 /* STOP2 */;
-} else if (newStopBitsSymbol == @symbol(stop1_5)) {
+	} else if (newStopBitsSymbol == @symbol(stop1_5)) {
-dcb.Parity = 1 /* STOP1_5 */;
+	    dcb.Parity = 1 /* STOP1_5 */;
-} else {
+	} else {
-goto failure;
+	    goto failure;
-}
+	}
-if (! SetCommState(port, &dcb)) {
+	if (! SetCommState(port, &dcb)) {
-RETURN(false);
+	    RETURN(false);
-}
+	}
-RETURN(true);
+	RETURN(true);
 }
 failure: ;
 %}.
 self primitiveFailed.
 ! !
 #if !defined(NO_SOCKET)
 char *__hostName, *__serviceName;
 int ret, cnt = 0;
 if (hostName == nil) {
-__hostName = 0;
+	__hostName = 0;
 } else if (__isString(hostName) || __isSymbol(hostName)) {
-__hostName = __stringVal(hostName);
+	__hostName = __stringVal(hostName);
 } else {
-error = @symbol(badArgument1);
+	error = @symbol(badArgument1);
-goto err;
+	goto err;
 }
 if (serviceName == nil) {
-__serviceName = 0;
+	__serviceName = 0;
 } else if (__isString(serviceName) || __isSymbol(serviceName)) {
-__serviceName = __stringVal(serviceName);
+	__serviceName = __stringVal(serviceName);
 } else {
-error = @symbol(badArgument2);
+	error = @symbol(badArgument2);
-goto err;
+	goto err;
 }
 if (__hostName == 0 && __serviceName == 0) {
-error = @symbol(badArgument);
+	error = @symbol(badArgument);
-goto err;
+	goto err;
 }
 {
 # if defined(AI_NUMERICHOST)
 /*
 struct addrinfo hints;
 struct addrinfo *info = NULL, *infop;
 memset(&hints, 0, sizeof(hints));
 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);
 do {
-/* must refetch in loop */
+	/* must refetch in loop */
-if (hostName == nil) {
+	if (hostName == nil) {
-__hostName = 0;
+	    __hostName = 0;
-} else if (__isString(hostName) || __isSymbol(hostName)) {
+	} else if (__isString(hostName) || __isSymbol(hostName)) {
-__hostName = __stringVal(hostName);
+	    __hostName = __stringVal(hostName);
-}
+	}
-if (serviceName == nil) {
+	if (serviceName == nil) {
-__serviceName = 0;
+	    __serviceName = 0;
-} else if (__isString(serviceName) || __isSymbol(serviceName)) {
+	} else if (__isString(serviceName) || __isSymbol(serviceName)) {
-__serviceName = __stringVal(serviceName);
+	    __serviceName = __stringVal(serviceName);
-}
+	}
 # ifdef DO_WRAP_CALLS
-do {
+	do {
-__threadErrno = 0;
+	    __threadErrno = 0;
-res = STX_WSA_CALL4( "getaddrinfo", getaddrinfo, __hostName, __serviceName, &hints, &info);
+	    res = STX_WSA_CALL4( "getaddrinfo", getaddrinfo, __hostName, __serviceName, &hints, &info);
-} while ((res < 0) && (__threadErrno == EINTR));
+	} while ((res < 0) && (__threadErrno == EINTR));
 # else
-__BEGIN_INTERRUPTABLE__
+	__BEGIN_INTERRUPTABLE__
-ret = getaddrinfo(__hostName, __serviceName, &hints, &info);
+	ret = getaddrinfo(__hostName, __serviceName, &hints, &info);
-__END_INTERRUPTABLE__
+	__END_INTERRUPTABLE__
 # endif
 } 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;
-case EAI_ADDRFAMILY :
+	case EAI_ADDRFAMILY :
-error = @symbol(unknownHostForProtocol);
+	    error = @symbol(unknownHostForProtocol);
-break;
+	    break;
-case EAI_NODATA:
+	case EAI_NODATA:
-error = @symbol(noAddress);
+	    error = @symbol(noAddress);
-break;
+	    break;
-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 (__isString(protoArg) || __isSymbol(protoArg))
+	if (__isString(protoArg) || __isSymbol(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 {
-/* must refetch in loop */
+	    /* must refetch in loop */
-if (hostName == nil) {
+	    if (hostName == nil) {
-__hostName = 0;
+		__hostName = 0;
-} else if (__isString(hostName) || __isSymbol(hostName)) {
+	    } else if (__isString(hostName) || __isSymbol(hostName)) {
-__hostName = __stringVal(hostName);
+		__hostName = __stringVal(hostName);
-}
+	    }
 # ifdef DO_WRAP_CALLS
-hp = STX_WSA_CALL1("gethostbyname", gethostbyname, __hostName);
+	    hp = STX_WSA_CALL1("gethostbyname", gethostbyname, __hostName);
-if ((INT)hp < 0) hp = NULL;
+	    if ((INT)hp < 0) hp = NULL;
 # else
-/* __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__
 #endif
-} 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 */
 }
 #else /* ! HAS_SOCKET */
 error = @symbol(notImplemented);
 #endif
 %}.
 error notNil ifTrue:[
-|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:error;
+		parameter:error;
-messageText:' - ', errorString;
+		messageText:' - ', errorString;
-request:request) raiseRequest.
+		request:request) raiseRequest.
 ].
 1 to:result size do:[:i |
-|entry dom info|
+	|entry dom info|
-info := SocketAddressInfo new.
+	info := SocketAddressInfo new.
-entry := result at:i.
+	entry := result at:i.
-info flags:(entry at:1).
+	info flags:(entry at:1).
-info domain:(dom := OperatingSystem domainSymbolOf:(entry at:2)).
+	info domain:(dom := OperatingSystem domainSymbolOf:(entry at:2)).
-info type:(OperatingSystem socketTypeSymbolOf:(entry at:3)).
+	info type:(OperatingSystem socketTypeSymbolOf:(entry at:3)).
-info protocol:(self protocolSymbolOf:(entry at:4)).
+	info protocol:(self protocolSymbolOf:(entry at:4)).
-info socketAddress:((SocketAddress newDomain:dom) fromBytes:(entry at:5)).
+	info socketAddress:((SocketAddress newDomain:dom) fromBytes:(entry at:5)).
-info canonicalName:(entry at:6).
+	info 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:'smc1' serviceName:nil
-domain:nil type:nil protocol:nil flags:nil
+	    domain:nil type:nil 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;
-case EAI_ADDRFAMILY :
+	case EAI_ADDRFAMILY :
-error = @symbol(unknownHostForProtocol);
+	    error = @symbol(unknownHostForProtocol);
-break;
+	    break;
-case EAI_NODATA:
+	case EAI_NODATA:
-error = @symbol(noAddress);
+	    error = @symbol(noAddress);
-break;
+	    break;
-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 {
-/* must refetch in loop */
+		/* must refetch in loop */
-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((char *)&sa->sin_addr, sockAddrSize, sa->sin_family);
+	    hostp = gethostbyaddr((char *)&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.exept.de' serviceName:'echo'
+	(self getAddressInfo:'exept.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:#[1 2 3 4]
-wantHostName:true wantServiceName:true datagram:false flags:0
+	 wantHostName:true wantServiceName:true datagram:false flags:0
 "
 ! !
 !Win32OperatingSystem::WinPointStructure class methodsFor:'instance creation'!
 ! !
 !Win32OperatingSystem::WinPointStructure methodsFor:'accessing'!
 asPoint
-"Private - Answer the receiver as a Point."
+	"Private - Answer the receiver as a Point."
 ^self x @ self y
 "Created: / 03-08-2006 / 10:45:55 / fm"
 !
 x
-"Private - Answer the x coordinate of the point."
+	"Private - Answer the x coordinate of the point."
 ^self longAt: 0 + 1
 "Created: / 03-08-2006 / 10:46:11 / fm"
 !
 x: anInteger
-"Private - Set the x coordinate of the point."
+	"Private - Set the x coordinate of the point."
 self longAt: 0 + 1 put: anInteger
 "Created: / 03-08-2006 / 10:46:41 / fm"
 !
 y
-"Private - Answer the y coordinate of the point."
+	"Private - Answer the y coordinate of the point."
 ^self longAt: 4 + 1
 "Created: / 03-08-2006 / 10:46:26 / fm"
 !
 y: anInteger
-"Private - Set the y coordinate of the point."
+	"Private - Set the y coordinate of the point."
 self longAt: 4 + 1 put: anInteger
 "Created: / 03-08-2006 / 10:46:56 / fm"
 ! !
 !Win32OperatingSystem::WinPointStructure methodsFor:'printing'!
 printOn: aStream
-"Append a textual representation of the receiver to aStream."
+	"Append a textual representation of the receiver to aStream."
 aStream nextPutAll: self class name, ' { ', self asPoint printString, ' } '
 "Created: / 03-08-2006 / 10:45:40 / fm"
 ! !
 !Win32OperatingSystem class methodsFor:'documentation'!
 version
-^ '$Header: /cvs/stx/stx/libbasic/Win32OperatingSystem.st,v 1.282 2007-06-27 12:05:00 sr Exp $'
+^ '$Header: /cvs/stx/stx/libbasic/Win32OperatingSystem.st,v 1.283 2007-07-04 15:07:44 cg Exp $'
 ! !
 Win32OperatingSystem initialize!
 Win32OperatingSystem::RegistryEntry initialize!

changeset 10627	bef737d1b8a7
parent 10622	87a51cae9161
child 10664	1b41c869040a