hg/stx-libbasic: comparison Win32OperatingSystem.st

equal deleted inserted replaced

-:cc55df8d23dc
+:cfb6a76de348
 "
 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
 hereby transferred.
 "
 "{ Package: 'stx:libbasic' }"
 AbstractOperatingSystem subclass:#Win32OperatingSystem
-instanceVariableNames:''
+	instanceVariableNames:''
-classVariableNames:'Initialized HostName DomainName CurrentDirectory'
+	classVariableNames:'Initialized HostName DomainName CurrentDirectory'
-poolDictionaries:'Win32Constants'
+	poolDictionaries:'Win32Constants'
-category:'OS-Windows'
+	category:'OS-Windows'
 !
 ByteArray variableByteSubclass:#DevModeStructure
-instanceVariableNames:''
+	instanceVariableNames:''
-classVariableNames:''
+	classVariableNames:''
-poolDictionaries:''
+	poolDictionaries:''
-privateIn:Win32OperatingSystem
+	privateIn:Win32OperatingSystem
 !
 ByteArray variableByteSubclass:#DocInfoStructure
-instanceVariableNames:''
+	instanceVariableNames:''
-classVariableNames:''
+	classVariableNames:''
-poolDictionaries:''
+	poolDictionaries:''
-privateIn:Win32OperatingSystem
+	privateIn:Win32OperatingSystem
 !
 Object subclass:#FileStatusInfo
-instanceVariableNames:'type mode uid gid size id accessed modified created statusChanged
+	instanceVariableNames:'type mode uid gid size id accessed modified created statusChanged
-sourcePath linkTargetPath fullPathName alternativePathName'
+		sourcePath linkTargetPath fullPathName alternativePathName'
-classVariableNames:''
+	classVariableNames:''
-poolDictionaries:''
+	poolDictionaries:''
-privateIn:Win32OperatingSystem
+	privateIn:Win32OperatingSystem
 !
 Object subclass:#OSProcessStatus
-instanceVariableNames:'pid status code core'
+	instanceVariableNames:'pid status code core'
-classVariableNames:''
+	classVariableNames:''
-poolDictionaries:''
+	poolDictionaries:''
-privateIn:Win32OperatingSystem
+	privateIn:Win32OperatingSystem
 !
 Object subclass:#PerformanceData
-instanceVariableNames:'objectArray perfTime perfFreq perfTime100nSec'
+	instanceVariableNames:'objectArray perfTime perfFreq perfTime100nSec'
-classVariableNames:'PerformanceText CounterIndexTextDictionary
+	classVariableNames:'PerformanceText CounterIndexTextDictionary
-HelpIndexTextDictionary'
+		HelpIndexTextDictionary'
-poolDictionaries:''
+	poolDictionaries:''
-privateIn:Win32OperatingSystem
+	privateIn:Win32OperatingSystem
 !
 Object subclass:#Abstract
-instanceVariableNames:'lastData lastTimestamp cachedResults'
+	instanceVariableNames:'lastData lastTimestamp cachedResults'
-classVariableNames:''
+	classVariableNames:''
-poolDictionaries:''
+	poolDictionaries:''
-privateIn:Win32OperatingSystem::PerformanceData
+	privateIn:Win32OperatingSystem::PerformanceData
 !
 Win32OperatingSystem::PerformanceData::Abstract subclass:#DiskIO
-instanceVariableNames:''
+	instanceVariableNames:''
-classVariableNames:'TheOneAndOnlyInstance'
+	classVariableNames:'TheOneAndOnlyInstance'
-poolDictionaries:''
+	poolDictionaries:''
-privateIn:Win32OperatingSystem::PerformanceData
+	privateIn:Win32OperatingSystem::PerformanceData
 !
 Win32OperatingSystem::PerformanceData::Abstract subclass:#Global
-instanceVariableNames:''
+	instanceVariableNames:''
-classVariableNames:'TheOneAndOnlyInstance'
+	classVariableNames:'TheOneAndOnlyInstance'
-poolDictionaries:''
+	poolDictionaries:''
-privateIn:Win32OperatingSystem::PerformanceData
+	privateIn:Win32OperatingSystem::PerformanceData
 !
 Win32OperatingSystem::PerformanceData::Abstract subclass:#Memory
-instanceVariableNames:''
+	instanceVariableNames:''
-classVariableNames:'TheOneAndOnlyInstance'
+	classVariableNames:'TheOneAndOnlyInstance'
-poolDictionaries:''
+	poolDictionaries:''
-privateIn:Win32OperatingSystem::PerformanceData
+	privateIn:Win32OperatingSystem::PerformanceData
 !
 Win32OperatingSystem::PerformanceData::Abstract subclass:#Network
-instanceVariableNames:''
+	instanceVariableNames:''
-classVariableNames:'TheOneAndOnlyInstance'
+	classVariableNames:'TheOneAndOnlyInstance'
-poolDictionaries:''
+	poolDictionaries:''
-privateIn:Win32OperatingSystem::PerformanceData
+	privateIn:Win32OperatingSystem::PerformanceData
 !
 Win32OperatingSystem::PerformanceData::Abstract subclass:#Process
-instanceVariableNames:''
+	instanceVariableNames:''
-classVariableNames:'TheOneAndOnlyInstance'
+	classVariableNames:'TheOneAndOnlyInstance'
-poolDictionaries:''
+	poolDictionaries:''
-privateIn:Win32OperatingSystem::PerformanceData
+	privateIn:Win32OperatingSystem::PerformanceData
 !
 Win32OperatingSystem::PerformanceData::Abstract subclass:#Processor
-instanceVariableNames:''
+	instanceVariableNames:''
-classVariableNames:'TheOneAndOnlyInstance'
+	classVariableNames:'TheOneAndOnlyInstance'
-poolDictionaries:''
+	poolDictionaries:''
-privateIn:Win32OperatingSystem::PerformanceData
+	privateIn:Win32OperatingSystem::PerformanceData
 !
 ByteArray variableByteSubclass:#PrinterInfo2Structure
-instanceVariableNames:''
+	instanceVariableNames:''
-classVariableNames:''
+	classVariableNames:''
-poolDictionaries:''
+	poolDictionaries:''
-privateIn:Win32OperatingSystem
+	privateIn:Win32OperatingSystem
 !
 Object subclass:#RegistryEntry
-instanceVariableNames:'path handle'
+	instanceVariableNames:'path handle'
-classVariableNames:'Lobby HKEY_CLASSES_ROOT HKEY_CURRENT_USER HKEY_LOCAL_MACHINE
+	classVariableNames:'Lobby HKEY_CLASSES_ROOT HKEY_CURRENT_USER HKEY_LOCAL_MACHINE
-HKEY_USERS HKEY_PERFORMANCE_DATA HKEY_CURRENT_CONFIG
+		HKEY_USERS HKEY_PERFORMANCE_DATA HKEY_CURRENT_CONFIG
-HKEY_DYN_DATA HKEY_PERFORMANCE_TEXT HKEY_PERFORMANCE_NLSTEXT'
+		HKEY_DYN_DATA HKEY_PERFORMANCE_TEXT HKEY_PERFORMANCE_NLSTEXT'
-poolDictionaries:''
+	poolDictionaries:''
-privateIn:Win32OperatingSystem
+	privateIn:Win32OperatingSystem
 !
 ByteArray variableByteSubclass:#TextMetricsStructure
-instanceVariableNames:''
+	instanceVariableNames:''
-classVariableNames:''
+	classVariableNames:''
-poolDictionaries:''
+	poolDictionaries:''
-privateIn:Win32OperatingSystem
+	privateIn:Win32OperatingSystem
 !
 OSHandle subclass:#Win32IOHandle
-instanceVariableNames:''
+	instanceVariableNames:''
-classVariableNames:'Lobby'
+	classVariableNames:'Lobby'
-poolDictionaries:''
+	poolDictionaries:''
-privateIn:Win32OperatingSystem
+	privateIn:Win32OperatingSystem
 !
 Win32Handle subclass:#Win32PrinterHandle
-instanceVariableNames:''
+	instanceVariableNames:''
-classVariableNames:''
+	classVariableNames:''
-poolDictionaries:''
+	poolDictionaries:''
-privateIn:Win32OperatingSystem
+	privateIn:Win32OperatingSystem
 !
 Win32Handle subclass:#Win32ProcessHandle
-instanceVariableNames:'pid'
+	instanceVariableNames:'pid'
-classVariableNames:''
+	classVariableNames:''
-poolDictionaries:''
+	poolDictionaries:''
-privateIn:Win32OperatingSystem
+	privateIn:Win32OperatingSystem
 !
 Win32OperatingSystem::Win32IOHandle subclass:#Win32SerialPortHandle
-instanceVariableNames:''
+	instanceVariableNames:''
-classVariableNames:''
+	classVariableNames:''
-poolDictionaries:''
+	poolDictionaries:''
-privateIn:Win32OperatingSystem
+	privateIn:Win32OperatingSystem
 !
 Win32OperatingSystem::Win32IOHandle subclass:#Win32SocketHandle
-instanceVariableNames:''
+	instanceVariableNames:''
-classVariableNames:''
+	classVariableNames:''
-poolDictionaries:''
+	poolDictionaries:''
-privateIn:Win32OperatingSystem
+	privateIn:Win32OperatingSystem
 !
 ByteArray variableByteSubclass:#WinPointStructure
-instanceVariableNames:''
+	instanceVariableNames:''
-classVariableNames:''
+	classVariableNames:''
-poolDictionaries:''
+	poolDictionaries:''
-privateIn:Win32OperatingSystem
+	privateIn:Win32OperatingSystem
 !
 !Win32OperatingSystem primitiveDefinitions!
 %{
 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);
 }
 __get_functionAddress(HINSTANCE *pLibHandle, char *libraryName, char *functionName)
 {
 FARPROC entry;
 if (*pLibHandle == NULL) {
-*pLibHandle = LoadLibrary(libraryName);
+	*pLibHandle = LoadLibrary(libraryName);
 }
 entry = GetProcAddress(*pLibHandle, 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'!
 %{
 HRESULT hres;
 if( ! coInitialized ) {
 #ifdef NO_NT4_0_COMPATIBILITY
-FARPROC CoInitializeEx_entry = (FARPROC) CoInitializeEx;
+	FARPROC CoInitializeEx_entry = (FARPROC) CoInitializeEx;
 #else
-FARPROC CoInitializeEx_entry = __get_ole32_functionAddress("CoInitializeEx");
+	FARPROC CoInitializeEx_entry = __get_ole32_functionAddress("CoInitializeEx");
 #endif /* NO_NT4_0_COMPATIBILITY */
-hres = (*CoInitializeEx_entry)(NULL, COINIT_MULTITHREADED);
+	hres = (*CoInitializeEx_entry)(NULL, COINIT_MULTITHREADED);
-if (! SUCCEEDED(hres)) {
+	if (! SUCCEEDED(hres)) {
-console_fprintf(stderr, "OperatingSystem [info]: Could not open the COM library hres = %08x\n", hres );
+	    console_fprintf(stderr, "OperatingSystem [info]: Could not open the COM library hres = %08x\n", hres );
-goto error;
+	    goto error;
-}
+	}
-coInitialized = 1;
+	coInitialized = 1;
 #ifdef COM_DEBUG
-console_fprintf(stderr, "OperatingSystem [info]: COM initialized\n" );
+	console_fprintf(stderr, "OperatingSystem [info]: COM initialized\n" );
 #endif
 }
 RETURN (self );
 error: ;
 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
 "initialize the class"
 "/ attention: must be ok to be called twice during startup.
 Initialized == nil ifTrue:[
-Initialized := true.
+	Initialized := true.
-ObjectMemory addDependent:self.
+	ObjectMemory addDependent:self.
-HostName := nil.
+	HostName := nil.
-DomainName := nil.
+	DomainName := nil.
-LastErrorNumber := nil.
+	LastErrorNumber := nil.
-PipeFailed := false.
+	PipeFailed := false.
-self initOSType.
+	self initOSType.
-self coInitialize.
+	self coInitialize.
 ].
 "Modified: 13.9.1997 / 10:47:32 / cg"
 !
 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.
-self coInitialize.
+	self coInitialize.
 ]
 "Modified: 22.4.1996 / 13:10:43 / cg"
 "Created: 15.6.1996 / 15:22:37 / cg"
 "Modified: 7.1.1997 / 19:36:11 / stefan"
 extern char *__win32_getLogFilename();
 char *lp;
 lp = __win32_getLogFilename();
 if (lp) {
-ret = __MKSTRING(lp);
+	ret = __MKSTRING(lp);
 }
 %}.
 ^ ret
 "
 which write their log info into a file named xxx_log_xxx.log"
 |logFilePath|
 aFilenameOrNil notNil ifTrue:[
-logFilePath := aFilenameOrNil asFilename pathName
+	logFilePath := aFilenameOrNil asFilename pathName
 ].
 %{
 extern void __win32_setLogFile();
 if (__isStringLike(logFilePath)) {
-__win32_setLogFile(__stringVal(logFilePath));
+	__win32_setLogFile(__stringVal(logFilePath));
 } else {
-__win32_setLogFile( NULL );
+	__win32_setLogFile( NULL );
 }
 %}
 "
 Win32OperatingSystem win32LogFile:'myLog.log'
 ! !
 !Win32OperatingSystem class methodsFor:'clipboard'!
 clipboardContainsBitmap
-"Answer whether the clipboard contains a bitmap."
+	"Answer whether the clipboard contains a bitmap."
 ^self clipboardContainsFormat: 2 "CfBitmap"
 !
 clipboardContainsFormat: aCfConstant
-"Answer true if the clipboard contains data in
+	"Answer true if the clipboard contains data in
-the format described by aCfConstant.  "
+	 the format described by aCfConstant.  "
 ^self primIsClipboardFormatAvailable: aCfConstant
 !
 closeClipboard
 result ifFalse: [ ^self error].
 ^result
 !
 emptyClipboard
-"Private - empty the clipboard. Note: it must be opened first."
+	"Private - empty the clipboard. Note: it must be opened first."
 | result |
 result := self primEmptyClipboard.
 result ifFalse: [ ^self error].
 ^result
 !
 <apicall: ulongReturn "SetClipboardData" (ulong ulong) module: "user32.dll" >
 ^self primitiveFailed
 !
 setBitmapToClipboard: aBitmap
-"Copy aBitmap to the clipboard."
+	"Copy aBitmap to the clipboard."
 | handle |
 aBitmap isNil ifTrue:[ ^nil ].
 aBitmap id isNil ifTrue:[aBitmap onDevice: Screen current].
 handle := aBitmap id.
 handle isNil ifTrue: [ ^nil ].
 self emptyClipboard.
 self setClipboardData: 2 "CfBitmap" hMem: handle.
 self closeClipboard
 "
-self setBitmapToClipboard: Image fromUser
+	self setBitmapToClipboard: Image fromUser
 "
 !
 setClipboardData: aCfConstant hMem: aMemHandle
 |result|
 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_NO_SYSTEM_RESOURCES:
-sym = @symbol(ERROR_INVALID_ACCESS);
+		sym = @symbol(ERROR_NO_SYSTEM_RESOURCES);
-typ = @symbol(inappropriateOperationSignal);
+		typ = @symbol(noResourcesSignal);
-break;
+		break;
-case ERROR_INVALID_DATA:
+	    case ERROR_NONPAGED_SYSTEM_RESOURCES:
-sym = @symbol(ERROR_INVALID_DATA);
+		sym = @symbol(ERROR_NONPAGED_SYSTEM_RESOURCES);
-typ = @symbol(invalidArgumentsSignal);
+		typ = @symbol(noResourcesSignal);
-break;
+		break;
-case ERROR_INVALID_NAME:
+	    case ERROR_PAGED_SYSTEM_RESOURCES:
-sym = @symbol(ERROR_INVALID_NAME);
+		sym = @symbol(ERROR_PAGED_SYSTEM_RESOURCES);
-typ = @symbol(invalidArgumentsSignal);
+		typ = @symbol(noResourcesSignal);
-break;
+		break;
-case ERROR_ARENA_TRASHED:
+	    case ERROR_INVALID_ACCESS:
-sym = @symbol(ERROR_ARENA_TRASHED);
+		sym = @symbol(ERROR_INVALID_ACCESS);
-typ = @symbol(noResourcesSignal);
+		typ = @symbol(inappropriateOperationSignal);
-break;
+		break;
-case ERROR_OUTOFMEMORY:
+	    case ERROR_INVALID_DATA:
-sym = @symbol(ERROR_OUTOFMEMORY);
+		sym = @symbol(ERROR_INVALID_DATA);
-typ = @symbol(noResourcesSignal);
+		typ = @symbol(invalidArgumentsSignal);
-break;
+		break;
-case ERROR_BROKEN_PIPE:
+	    case ERROR_INVALID_NAME:
-sym = @symbol(ERROR_BROKEN_PIPE);
+		sym = @symbol(ERROR_INVALID_NAME);
-typ = @symbol(peerFaultSignal);
+		typ = @symbol(invalidArgumentsSignal);
-break;
+		break;
-case ERROR_GEN_FAILURE:
+	    case ERROR_ARENA_TRASHED:
-sym = @symbol(ERROR_GEN_FAILURE);
+		sym = @symbol(ERROR_ARENA_TRASHED);
-break;
+		typ = @symbol(noResourcesSignal);
+		break;
-case ERROR_WRITE_PROTECT:
-sym = @symbol(ERROR_WRITE_PROTECT);
+	    case ERROR_OUTOFMEMORY:
-typ = @symbol(inappropriateOperationSignal);
+		sym = @symbol(ERROR_OUTOFMEMORY);
-break;
+		typ = @symbol(noResourcesSignal);
+		break;
-case ERROR_WRITE_FAULT:
-sym = @symbol(ERROR_WRITE_FAULT);
+	    case ERROR_BROKEN_PIPE:
-typ = @symbol(transferFaultSignal);
+		sym = @symbol(ERROR_BROKEN_PIPE);
-break;
+		typ = @symbol(peerFaultSignal);
+		break;
-case ERROR_READ_FAULT:
-sym = @symbol(ERROR_READ_FAULT);
+	    case ERROR_GEN_FAILURE:
-typ = @symbol(transferFaultSignal);
+		sym = @symbol(ERROR_GEN_FAILURE);
-break;
+		break;
-case ERROR_HANDLE_DISK_FULL:
+	    case ERROR_WRITE_PROTECT:
-sym = @symbol(ERROR_HANDLE_DISK_FULL);
+		sym = @symbol(ERROR_WRITE_PROTECT);
-typ = @symbol(volumeFullSignal);
+		typ = @symbol(inappropriateOperationSignal);
-break;
+		break;
-case ERROR_DISK_FULL:
+	    case ERROR_WRITE_FAULT:
-sym = @symbol(ERROR_DISK_FULL);
+		sym = @symbol(ERROR_WRITE_FAULT);
-typ = @symbol(volumeFullSignal);
+		typ = @symbol(transferFaultSignal);
-break;
+		break;
-case ERROR_SHARING_VIOLATION:
+	    case ERROR_READ_FAULT:
-sym = @symbol(ERROR_SHARING_VIOLATION);
+		sym = @symbol(ERROR_READ_FAULT);
-typ = @symbol(noPermissionsSignal);
+		typ = @symbol(transferFaultSignal);
-break;
+		break;
-case ERROR_LOCK_VIOLATION:
+	    case ERROR_HANDLE_DISK_FULL:
-sym = @symbol(ERROR_LOCK_VIOLATION);
+		sym = @symbol(ERROR_HANDLE_DISK_FULL);
-typ = @symbol(noPermissionsSignal);
+		typ = @symbol(volumeFullSignal);
-break;
+		break;
-case ERROR_INVALID_PARAMETER:
+	    case ERROR_DISK_FULL:
-sym = @symbol(ERROR_INVALID_PARAMETER);
+		sym = @symbol(ERROR_DISK_FULL);
-typ = @symbol(invalidArgumentsSignal);
+		typ = @symbol(volumeFullSignal);
-break;
+		break;
-case ERROR_NET_WRITE_FAULT:
+	    case ERROR_SHARING_VIOLATION:
-sym = @symbol(ERROR_NET_WRITE_FAULT);
+		sym = @symbol(ERROR_SHARING_VIOLATION);
-typ = @symbol(transferFaultSignal);
+		typ = @symbol(noPermissionsSignal);
-break;
+		break;
-case ERROR_NOT_SUPPORTED:
+	    case ERROR_LOCK_VIOLATION:
-sym = @symbol(ERROR_NOT_SUPPORTED);
+		sym = @symbol(ERROR_LOCK_VIOLATION);
-typ = @symbol(inappropriateOperationSignal);
+		typ = @symbol(noPermissionsSignal);
-break;
+		break;
-case ERROR_REM_NOT_LIST:
+	    case ERROR_INVALID_PARAMETER:
-sym = @symbol(ERROR_REM_NOT_LIST);
+		sym = @symbol(ERROR_INVALID_PARAMETER);
-typ = @symbol(noResourcesSignal);
+		typ = @symbol(invalidArgumentsSignal);
-break;
+		break;
-case ERROR_NETWORK_ACCESS_DENIED:
+	    case ERROR_NET_WRITE_FAULT:
-sym = @symbol(ERROR_NETWORK_ACCESS_DENIED);
+		sym = @symbol(ERROR_NET_WRITE_FAULT);
-typ = @symbol(noPermissionsSignal);
+		typ = @symbol(transferFaultSignal);
-break;
+		break;
-case ERROR_DUP_NAME:
+	    case ERROR_NOT_SUPPORTED:
-sym = @symbol(ERROR_DUP_NAME);
+		sym = @symbol(ERROR_NOT_SUPPORTED);
-typ = @symbol(noResourcesSignal);
+		typ = @symbol(inappropriateOperationSignal);
-break;
+		break;
-case ERROR_BAD_NETPATH:
+	    case ERROR_REM_NOT_LIST:
-sym = @symbol(ERROR_BAD_NETPATH);
+		sym = @symbol(ERROR_REM_NOT_LIST);
-typ = @symbol(noResourcesSignal);
+		typ = @symbol(noResourcesSignal);
-break;
+		break;
-case ERROR_NETWORK_BUSY:
+	    case ERROR_NETWORK_ACCESS_DENIED:
-sym = @symbol(ERROR_NETWORK_BUSY);
+		sym = @symbol(ERROR_NETWORK_ACCESS_DENIED);
-typ = @symbol(noResourcesSignal);
+		typ = @symbol(noPermissionsSignal);
-break;
+		break;
-case ERROR_DRIVE_LOCKED:
+	    case ERROR_DUP_NAME:
-sym = @symbol(ERROR_DRIVE_LOCKED);
+		sym = @symbol(ERROR_DUP_NAME);
-typ = @symbol(inappropriateOperationSignal);
+		typ = @symbol(noResourcesSignal);
-break;
+		break;
-case ERROR_INVALID_DRIVE:
+	    case ERROR_BAD_NETPATH:
-sym = @symbol(ERROR_INVALID_DRIVE);
+		sym = @symbol(ERROR_BAD_NETPATH);
-typ = @symbol(invalidArgumentsSignal);
+		typ = @symbol(noResourcesSignal);
-break;
+		break;
-case ERROR_WRONG_DISK:
+	    case ERROR_NETWORK_BUSY:
-sym = @symbol(ERROR_WRONG_DISK);
+		sym = @symbol(ERROR_NETWORK_BUSY);
-typ = @symbol(noResourcesSignal);
+		typ = @symbol(noResourcesSignal);
-break;
+		break;
-case ERROR_CURRENT_DIRECTORY:
+	    case ERROR_DRIVE_LOCKED:
-sym = @symbol(ERROR_CURRENT_DIRECTORY);
+		sym = @symbol(ERROR_DRIVE_LOCKED);
-typ = @symbol(invalidArgumentsSignal);
+		typ = @symbol(inappropriateOperationSignal);
-break;
+		break;
-/*
+	    case ERROR_INVALID_DRIVE:
-* what a nice errorCode - thats the most "useful" one I ever
+		sym = @symbol(ERROR_INVALID_DRIVE);
-* encountered ... (... those stupid micro-softies ...)
+		typ = @symbol(invalidArgumentsSignal);
-*/
+		break;
-case ERROR_CANNOT_MAKE:
-sym = @symbol(ERROR_CANNOT_MAKE);
+	    case ERROR_WRONG_DISK:
-typ = @symbol(inappropriateOperationSignal);
+		sym = @symbol(ERROR_WRONG_DISK);
-break;
+		typ = @symbol(noResourcesSignal);
+		break;
-case ERROR_NO_MORE_FILES:
-sym = @symbol(ERROR_NO_MORE_FILES);
+	    case ERROR_CURRENT_DIRECTORY:
-typ = @symbol(noResourcesSignal);
+		sym = @symbol(ERROR_CURRENT_DIRECTORY);
-break;
+		typ = @symbol(invalidArgumentsSignal);
+		break;
-case ERROR_NOT_READY:
-sym = @symbol(ERROR_NOT_READY);
+	    /*
-typ = @symbol(noResourcesSignal);
+	     * what a nice errorCode - thats the most "useful" one I ever
-break;
+	     * encountered ... (... those stupid micro-softies ...)
+	     */
-case ERROR_NOT_DOS_DISK:
+	    case ERROR_CANNOT_MAKE:
-sym = @symbol(ERROR_NOT_DOS_DISK);
+		sym = @symbol(ERROR_CANNOT_MAKE);
-typ = @symbol(invalidArgumentsSignal);
+		typ = @symbol(inappropriateOperationSignal);
-break;
+		break;
-case ERROR_OUT_OF_PAPER:
+	    case ERROR_NO_MORE_FILES:
-sym = @symbol(ERROR_OUT_OF_PAPER);
+		sym = @symbol(ERROR_NO_MORE_FILES);
-typ = @symbol(noResourcesSignal);
+		typ = @symbol(noResourcesSignal);
-break;
+		break;
-case ERROR_PRINTQ_FULL:
+	    case ERROR_NOT_READY:
-sym = @symbol(ERROR_PRINTQ_FULL);
+		sym = @symbol(ERROR_NOT_READY);
-typ = @symbol(noResourcesSignal);
+		typ = @symbol(noResourcesSignal);
-break;
+		break;
-default:
+	    case ERROR_NOT_DOS_DISK:
-sym = nil;
+		sym = @symbol(ERROR_NOT_DOS_DISK);
-break;
+		typ = @symbol(invalidArgumentsSignal);
-}
+		break;
+	    case ERROR_OUT_OF_PAPER:
+		sym = @symbol(ERROR_OUT_OF_PAPER);
+		typ = @symbol(noResourcesSignal);
+		break;
+	    case ERROR_PRINTQ_FULL:
+		sym = @symbol(ERROR_PRINTQ_FULL);
+		typ = @symbol(noResourcesSignal);
+		break;
+	    default:
+		sym = nil;
+		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_NO_SYSTEM_RESOURCES
+if (sym == @symbol(ERROR_NO_SYSTEM_RESOURCES)) {
+	RETURN ( __mkSmallInteger(ERROR_NO_SYSTEM_RESOURCES) );
 }
 #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
 "/ command.com command-line parsing here (sigh).
 hasRedirection := (aCommandString isNil or:[aCommandString includesAny:'<>|']).
 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:[
-args := cmdName copyFrom:(index+1).
+		args := cmdName copyFrom:(index+1).
-cmdName := cmdName copyFrom:1 to:(index-1).
+		cmdName := cmdName copyFrom:1 to:(index-1).
-] ifFalse:[
+	    ] ifFalse:[
-args := ''.
+		args := ''.
-].
+	    ].
-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' or:[suffix = 'com']]) ifTrue:[
+	    (file exists and:[suffix = 'exe' or:[suffix = 'com']]) ifTrue:[
-"/ is an executable, no shell required
+		"/ is an executable, no shell required
-path := file fullAlternativePathName.
+		path := file fullAlternativePathName.
-^ Array with:path with:aCommandString.
+		^ Array with:path with:aCommandString.
 "/                ^ Array with:path with:(path, ' ', args).
-].
+	    ].
-path := self pathOfCommand:cmdName.
+	    path := self pathOfCommand:cmdName.
-path notNil ifTrue:[
+	    path notNil ifTrue:[
-"/ is an executable, no shell required
+		"/ is an executable, no shell required
-^ Array with:path with:aCommandString.
+		^ Array with:path with:aCommandString.
 "/                ^ Array with:path with:(path, ' ', args).
-].
+	    ].
-].
+	].
 ].
 shell := self getEnvironment:'COMSPEC'.
 shell isNil ifTrue:[
-wDir := self getWindowsSystemDirectory asFilename.
+	wDir := self getWindowsSystemDirectory asFilename.
-shell := #('cmd.exe' 'command.com') detect:[:eachCommand|
+	shell := #('cmd.exe' 'command.com') detect:[:eachCommand|
-(wDir / eachCommand) isExecutable
+			(wDir / eachCommand) isExecutable
-] ifNone:[
+		    ] ifNone:[
-self error:'no cmd.exe available'.
+			self error:'no cmd.exe available'.
-].
+		    ].
-shell := (wDir / shell) pathName.
+	shell := (wDir / shell) pathName.
 ].
 aCommandString isEmptyOrNil ifTrue:[
-^ Array with:shell with:nil
+	^ Array with:shell with:nil
 ].
 ^ Array with:shell with:(' /c "' , aCommandString, '"')
 "
 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 Win32ProcessHandle of the child process is returned; nil if the fork failed.
+	The Win32ProcessHandle 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 rslt|
 aDirectory notNil ifTrue:[
-dirPath := aDirectory asFilename asAbsoluteFilename osNameForDirectory.
+	dirPath := aDirectory asFilename asAbsoluteFilename osNameForDirectory.
-(dirPath endsWith:':') ifTrue:[
+	(dirPath endsWith:':') ifTrue:[
-dirPath := dirPath , '\'.
+	    dirPath := dirPath , '\'.
-].
+	].
 ].
 rslt := self
-primExec:aCommandPath
+	primExec:aCommandPath
-commandLine:argString
+	commandLine:argString
-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"
 or #killProcess: to stop it."
 |nullStream in out err rslt auxFd|
 (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
 ].
 rslt := self
-exec:commandString
+	exec:commandString
-withArguments:argString
+	withArguments:argString
-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.
 %{
 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 rentry rpath 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'.
 (rentry := self registryEntry key: 'HKEY_CURRENT_USER\Environment') notNil ifTrue:[
-rpath := rentry valueNamed: 'PATH'.
+	rpath := rentry valueNamed: 'PATH'.
-rpath notNil ifTrue:[
+	rpath notNil ifTrue:[
-path := path , ';' , rpath
+	    path := path , ';' , rpath
-].
+	].
 ].
 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 securityAttributes;
 SECURITY_DESCRIPTOR securityDescriptor;
 if ((__isStringLike(commandPath) || (commandPath == nil)) && __isStringLike(commandLine)) {
-if (commandPath != nil) {
+	if (commandPath != nil) {
-cmdPath = __stringVal(commandPath);
+	    cmdPath = __stringVal(commandPath);
-}
+	}
-cmdLine = __stringVal(commandLine);
+	cmdLine = __stringVal(commandLine);
-if (__isStringLike(dirName)) {
+	if (__isStringLike(dirName)) {
-dir = __stringVal(dirName);
+	    dir = __stringVal(dirName);
-}
+	}
-/*
+	/*
-* create descriptors as req'd
+	 * create descriptors as req'd
-*/
+	 */
-memset(&securityAttributes, 0, sizeof(securityAttributes));
+	memset(&securityAttributes, 0, sizeof(securityAttributes));
-securityAttributes.nLength = sizeof(securityAttributes);
+	securityAttributes.nLength = sizeof(securityAttributes);
-securityAttributes.bInheritHandle = TRUE;
+	securityAttributes.bInheritHandle = TRUE;
-InitializeSecurityDescriptor(&securityDescriptor, SECURITY_DESCRIPTOR_REVISION);
+	InitializeSecurityDescriptor(&securityDescriptor, SECURITY_DESCRIPTOR_REVISION);
-SetSecurityDescriptorDacl(&securityDescriptor, -1, 0, 0);
+	SetSecurityDescriptorDacl(&securityDescriptor, -1, 0, 0);
-securityAttributes.lpSecurityDescriptor = &securityDescriptor;
+	securityAttributes.lpSecurityDescriptor = &securityDescriptor;
-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]));
-}
+		}
-}
+	    }
 #if defined(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,
-&securityAttributes, NULL /* &securityAttributes */,
+				&securityAttributes, NULL /* &securityAttributes */,
-securityAttributes.bInheritHandle,      /* inherit handles */
+				securityAttributes.bInheritHandle,      /* inherit handles */
-fdwCreate | CREATE_SUSPENDED,           /* resume after setting affinity */
+				fdwCreate | CREATE_SUSPENDED,           /* resume after setting affinity */
-NULL,                                   /* env */
+				NULL,                                   /* env */
-dir,
+				dir,
-&lpsiStartInfo,
+				&lpsiStartInfo,
-&lppiProcInfo ))
+				&lppiProcInfo ))
-{
+	    {
-DWORD processAffinityMask, systemAffinityMask;
+		DWORD processAffinityMask, systemAffinityMask;
-/*
+		/*
-* Process was created suspended, now set the affinity mask
+		 * Process was created suspended, now set the affinity mask
-* to any processor, and resume the processes main thread.
+		 * to any processor, and resume the processes main thread.
-* (librun/process.s limited the affinity to a single processor).
+		 * (librun/process.s limited the affinity to a single processor).
-*/
+		 */
-GetProcessAffinityMask(lppiProcInfo.hProcess, &processAffinityMask, &systemAffinityMask);
+		GetProcessAffinityMask(lppiProcInfo.hProcess, &processAffinityMask, &systemAffinityMask);
-SetProcessAffinityMask(lppiProcInfo.hProcess, systemAffinityMask);
+		SetProcessAffinityMask(lppiProcInfo.hProcess, systemAffinityMask);
-if ((fdwCreate & CREATE_SUSPENDED) == 0) {
+		if ((fdwCreate & CREATE_SUSPENDED) == 0) {
-ResumeThread(lppiProcInfo.hThread);
+		    ResumeThread(lppiProcInfo.hThread);
-}
+		}
-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
 %{
 SHELLEXECUTEINFO shExecInfo = {0};
 shExecInfo.cbSize = sizeof(shExecInfo);
 if (__isSmallInteger(nShowCmd)) {
-shExecInfo.nShow = __intVal(nShowCmd);
+	shExecInfo.nShow = __intVal(nShowCmd);
 } else {
-if (nShowCmd == @symbol(SW_SHOW)) {
+	if (nShowCmd == @symbol(SW_SHOW)) {
-shExecInfo.nShow = SW_SHOW;
+	    shExecInfo.nShow = SW_SHOW;
-} else if (nShowCmd == @symbol(SW_SHOWNORMAL)) {
+	} else if (nShowCmd == @symbol(SW_SHOWNORMAL)) {
-shExecInfo.nShow = SW_SHOWNORMAL;
+	    shExecInfo.nShow = SW_SHOWNORMAL;
-} else if (nShowCmd == @symbol(SW_SHOWDEFAULT)) {
+	} else if (nShowCmd == @symbol(SW_SHOWDEFAULT)) {
-shExecInfo.nShow = SW_SHOWDEFAULT;
+	    shExecInfo.nShow = SW_SHOWDEFAULT;
-} else if (nShowCmd == @symbol(SW_SHOWMAXIMIZED)) {
+	} else if (nShowCmd == @symbol(SW_SHOWMAXIMIZED)) {
-shExecInfo.nShow = SW_SHOWMAXIMIZED;
+	    shExecInfo.nShow = SW_SHOWMAXIMIZED;
-} else if (nShowCmd == @symbol(SW_SHOWMINIMIZED)) {
+	} else if (nShowCmd == @symbol(SW_SHOWMINIMIZED)) {
-shExecInfo.nShow = SW_SHOWMINIMIZED;
+	    shExecInfo.nShow = SW_SHOWMINIMIZED;
-} else if (nShowCmd == @symbol(SW_SHOWMINNOACTIVE)) {
+	} else if (nShowCmd == @symbol(SW_SHOWMINNOACTIVE)) {
-shExecInfo.nShow = SW_SHOWMINNOACTIVE;
+	    shExecInfo.nShow = SW_SHOWMINNOACTIVE;
-} else if (nShowCmd == @symbol(SW_SHOWNA)) {
+	} else if (nShowCmd == @symbol(SW_SHOWNA)) {
-shExecInfo.nShow = SW_SHOWNA;
+	    shExecInfo.nShow = SW_SHOWNA;
-} else if (nShowCmd == @symbol(SW_SHOWNOACTIVATE)) {
+	} else if (nShowCmd == @symbol(SW_SHOWNOACTIVATE)) {
-shExecInfo.nShow = SW_SHOWNOACTIVATE;
+	    shExecInfo.nShow = SW_SHOWNOACTIVATE;
-} else if (nShowCmd == @symbol(SW_MAXIMIZE)) {
+	} else if (nShowCmd == @symbol(SW_MAXIMIZE)) {
-shExecInfo.nShow = SW_MAXIMIZE;
+	    shExecInfo.nShow = SW_MAXIMIZE;
-} else if (nShowCmd == @symbol(SW_RESTORE)) {
+	} else if (nShowCmd == @symbol(SW_RESTORE)) {
-shExecInfo.nShow = SW_RESTORE;
+	    shExecInfo.nShow = SW_RESTORE;
-} else {
+	} else {
-goto badArgument;
+	    goto badArgument;
-}
+	}
 }
 if (((lpOperation == nil) || __isStringLike(lpOperation))
 && ((lpFile == nil) || __isStringLike(lpFile))
 && ((lpParameters == nil) || __isStringLike(lpParameters))
 && ((lpDirectory == nil) || __isStringLike(lpDirectory))
 ) {
-// hProcess member receives the process handle
+	// hProcess member receives the process handle
-shExecInfo.fMask = SEE_MASK_NOCLOSEPROCESS;
+	shExecInfo.fMask = SEE_MASK_NOCLOSEPROCESS;
-shExecInfo.hwnd = 0;
+	shExecInfo.hwnd = 0;
-shExecInfo.lpVerb        = (lpOperation != nil) ? __stringVal(lpOperation) : NULL;
+	shExecInfo.lpVerb        = (lpOperation != nil) ? __stringVal(lpOperation) : NULL;
-shExecInfo.lpFile        = (lpFile != nil) ? __stringVal(lpFile) : NULL;
+	shExecInfo.lpFile        = (lpFile != nil) ? __stringVal(lpFile) : NULL;
-shExecInfo.lpParameters  = (lpParameters != nil) ? __stringVal(lpParameters) : NULL;
+	shExecInfo.lpParameters  = (lpParameters != nil) ? __stringVal(lpParameters) : NULL;
-shExecInfo.lpDirectory   = (lpDirectory != nil) ? __stringVal(lpDirectory) : NULL;
+	shExecInfo.lpDirectory   = (lpDirectory != nil) ? __stringVal(lpDirectory) : NULL;
-if (hwnd != nil) {
+	if (hwnd != nil) {
-if (__isExternalAddressLike(hwnd)) {
+	    if (__isExternalAddressLike(hwnd)) {
-shExecInfo.hwnd = (HANDLE)(__externalAddressVal(hwnd));
+		shExecInfo.hwnd = (HANDLE)(__externalAddressVal(hwnd));
-} else
+	    } else
-goto badArgument;
+		goto badArgument;
-}
+	}
-if (ShellExecuteEx(&shExecInfo)) {
+	if (ShellExecuteEx(&shExecInfo)) {
-if (shExecInfo.hProcess) {
+	    if (shExecInfo.hProcess) {
-DWORD processAffinityMask, systemAffinityMask;
+		DWORD processAffinityMask, systemAffinityMask;
-/*
+		/*
-* Set the affinity mask
+		 * Set the affinity mask
-* to any processor, and resume the processes main thread.
+		 * to any processor, and resume the processes main thread.
-* (librun/process.s limited the affinity to a single processor).
+		 * (librun/process.s limited the affinity to a single processor).
-*/
+		 */
-GetProcessAffinityMask(shExecInfo.hProcess, &processAffinityMask, &systemAffinityMask);
+		GetProcessAffinityMask(shExecInfo.hProcess, &processAffinityMask, &systemAffinityMask);
-SetProcessAffinityMask(shExecInfo.hProcess, systemAffinityMask);
+		SetProcessAffinityMask(shExecInfo.hProcess, systemAffinityMask);
-// new (does not work, yet):
+		// new (does not work, yet):
-// __externalAddressVal(handle) = shExecInfo.hProcess;
+		// __externalAddressVal(handle) = shExecInfo.hProcess;
-// RETURN (handle);
+		// RETURN (handle);
-// old:
+		// old:
-CloseHandle(shExecInfo.hProcess);
+		CloseHandle(shExecInfo.hProcess);
-RETURN (self); /* OK */
+		RETURN (self); /* OK */
-} else {
+	    } else {
-RETURN (self); /* OK */
+		RETURN (self); /* OK */
-}
+	    }
-} else {
+	} else {
-/* error */
+	    /* error */
-errorNumber = __mkSmallInteger(__WIN32_ERR(GetLastError()));
+	    errorNumber = __mkSmallInteger(__WIN32_ERR(GetLastError()));
-}
+	}
 }
 badArgument: ;
 %}.
 errorNumber isNil ifTrue:[
-self primitiveFailed:'invalid argument(s)'.
+	self primitiveFailed:'invalid argument(s)'.
 ] ifFalse:[
-(OperatingSystem errorHolderForNumber:errorNumber)
+	(OperatingSystem errorHolderForNumber:errorNumber)
-parameter:lpFile;
+	    parameter:lpFile;
-reportError
+	    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
 "
 !
 startProcess:aCommandString inputFrom:anExternalInStream outputTo:anExternalOutStream
 errorTo:anExternalErrStream auxFrom:anAuxiliaryStream
 aCommandString isNil ifTrue:[^ nil].
 shellAndArgs := self commandAndArgsForOSCommand:aCommandString.
 ^ self
-exec:(shellAndArgs at:1) withArguments:(shellAndArgs at:2)
+	exec:(shellAndArgs at:1) withArguments:(shellAndArgs at:2)
-inputFrom:anExternalInStream outputTo:anExternalOutStream
+	inputFrom:anExternalInStream outputTo:anExternalOutStream
-errorTo:anExternalErrStream auxFrom:anAuxiliaryStream
+	errorTo:anExternalErrStream auxFrom:anAuxiliaryStream
-environment:anEvironmentDictionary inDirectory:dir
+	environment:anEvironmentDictionary inDirectory:dir
 "blocking at current prio (i.e. only higher prio threads execute):
 OperatingSystem executeCommand:'ls -l > out'.
 "
 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.
 closeFd:anIntegerOrHandle
 "low level close of a filedescriptor"
 %{
 if (__isSmallInteger(anIntegerOrHandle)) {
-close(__intVal(anIntegerOrHandle));
+	close(__intVal(anIntegerOrHandle));
-RETURN(self);
+	RETURN(self);
 }
 if (__isExternalAddressLike(anIntegerOrHandle)) {
 if (!CloseHandle( __externalAddressVal(anIntegerOrHandle))) {
-console_fprintf( stderr, "Win32OS [warning]: Could not close handle : %x\n", __externalAddressVal(anIntegerOrHandle));
+	   console_fprintf( stderr, "Win32OS [warning]: Could not close handle : %x\n", __externalAddressVal(anIntegerOrHandle));
 }
 RETURN(self);
 }
 %}.
 ^ self primitiveFailed.
 (self isDirectory:aPathName) ifTrue:[^ true].
 %{
 if (__isStringLike(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 = CreateDirectoryA(__stringVal(aPathName), &sa);
+	ret = CreateDirectoryA(__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);
 }
 if (__isUnicode16String(aPathName)) {
-int ret;
+	int ret;
-SECURITY_ATTRIBUTES sa;
+	SECURITY_ATTRIBUTES sa;
-wchar_t _wPathName[MAXPATHLEN+1];
+	wchar_t _wPathName[MAXPATHLEN+1];
-int i, l;
+	int i, l;
-l = __unicode16StringSize(aPathName);
+	l = __unicode16StringSize(aPathName);
-if (l > MAXPATHLEN) l = MAXPATHLEN;
+	if (l > MAXPATHLEN) l = MAXPATHLEN;
-for (i=0; i<l; i++) {
+	for (i=0; i<l; i++) {
-_wPathName[i] = __unicode16StringVal(aPathName)[i];
+	    _wPathName[i] = __unicode16StringVal(aPathName)[i];
-}
+	}
-_wPathName[i] = 0;
+	_wPathName[i] = 0;
-sa.nLength = sizeof( sa );
+	sa.nLength = sizeof( sa );
-sa.lpSecurityDescriptor = NULL;
+	sa.lpSecurityDescriptor = NULL;
-sa.bInheritHandle = TRUE;
+	sa.bInheritHandle = TRUE;
-ret = CreateDirectoryW(_wPathName, &sa);
+	ret = CreateDirectoryW(_wPathName, &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;
 WORD wsz[MAX_PATH];
 char szGotPath[MAX_PATH];
 if (! __isStringLike(aPathName)) {
-console_fprintf(stderr, "OperatingSystem [info]: invalid argument\n");
+	console_fprintf(stderr, "OperatingSystem [info]: invalid argument\n");
-goto error;
+	goto error;
 }
 if( ! coInitialized ) {
-console_fprintf(stderr, "OperatingSystem [info]: com not initialized\n");
+	console_fprintf(stderr, "OperatingSystem [info]: com not initialized\n");
-goto error;
+	goto error;
 }
 if ( ipShellLink == NULL ) {
-hres = CoCreateInstance(&CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
+	hres = CoCreateInstance(&CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
-&IID_IShellLink, (LPVOID *)&ipShellLink);
+				&IID_IShellLink, (LPVOID *)&ipShellLink);
-if (! SUCCEEDED(hres)) {
+	if (! SUCCEEDED(hres)) {
-console_fprintf(stderr, "OperatingSystem [info]: CoCreateInstance Error - hres = %08x\n", hres);
+	    console_fprintf(stderr, "OperatingSystem [info]: CoCreateInstance Error - hres = %08x\n", hres);
-ipShellLink = NULL;
+	    ipShellLink = NULL;
-goto error;
+	    goto error;
-}
+	}
-hres = ipShellLink->lpVtbl->QueryInterface( ipShellLink, &IID_IPersistFile, & ipPersistFile );
+	hres = ipShellLink->lpVtbl->QueryInterface( ipShellLink, &IID_IPersistFile, & ipPersistFile );
-if (! SUCCEEDED(hres)) {
+	if (! SUCCEEDED(hres)) {
-console_fprintf(stderr, "OperatingSystem [info]: QueryInterface Error - hres = %08x\n", hres);
+	    console_fprintf(stderr, "OperatingSystem [info]: QueryInterface Error - hres = %08x\n", hres);
-ipShellLink->lpVtbl->Release(ipShellLink);
+	    ipShellLink->lpVtbl->Release(ipShellLink);
-ipShellLink   = NULL;
+	    ipShellLink   = NULL;
-ipPersistFile = NULL;
+	    ipPersistFile = NULL;
-goto error;
+	    goto error;
-}
+	}
 }
 MultiByteToWideChar(CP_ACP, 0, __stringVal(aPathName), -1, wsz, MAX_PATH);
 hres = ipPersistFile->lpVtbl->Load(ipPersistFile, wsz, STGM_READ);
 if (SUCCEEDED(hres)) {
-hres = ipShellLink->lpVtbl->GetPath(ipShellLink, szGotPath, MAX_PATH,
+	hres = ipShellLink->lpVtbl->GetPath(ipShellLink, szGotPath, MAX_PATH,
-(WIN32_FIND_DATA *)&wfd, 0 /* SLGP_SHORTPATH */ );
+		    (WIN32_FIND_DATA *)&wfd, 0 /* SLGP_SHORTPATH */ );
-if (SUCCEEDED(hres)) {
+	if (SUCCEEDED(hres)) {
-resolvedPath = __MKSTRING(szGotPath);
+	    resolvedPath = __MKSTRING(szGotPath);
-} else {
+	} else {
 #ifdef COM_DEBUG
-console_fprintf(stderr, "OperatingSystem [info]: GetPath failed - hres = %08x\n", hres );
+	    console_fprintf(stderr, "OperatingSystem [info]: GetPath failed - hres = %08x\n", hres );
 #endif
-}
+	}
 } else {
 #ifdef COM_DEBUG
-console_fprintf(stderr, "OperatingSystem [info]: Load failed - hres = %08x\n", hres );
+	console_fprintf(stderr, "OperatingSystem [info]: Load failed - hres = %08x\n", hres );
 #endif
 }
 /* ipPersistFile->lpVtbl->Release(ipPersistFile);  */
 error: ;
 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
 ].
 ^ self createHardLinkFrom:oldPath to:newPath
 "
 int numAttrib;
 int i, l;
 DWORD access, share, create, attr;
 if (__isStringLike(pathName)) {
-name = __stringVal(pathName);
+	name = __stringVal(pathName);
 } else if (__isUnicode16String(pathName)) {
-l = __unicode16StringSize(pathName);
+	l = __unicode16StringSize(pathName);
-if (l > MAXPATHLEN) l = MAXPATHLEN;
+	if (l > MAXPATHLEN) l = MAXPATHLEN;
-for (i=0; i<l; i++) {
+	for (i=0; i<l; i++) {
-_wPathName[i] = __unicode16StringVal(pathName)[i];
+	    _wPathName[i] = __unicode16StringVal(pathName)[i];
-}
+	}
-_wPathName[i] = 0;
+	_wPathName[i] = 0;
 } else {
-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;
 }
 ap = __ArrayInstPtr(attributeSpec)->a_element;
 numAttrib = __arraySize(attributeSpec);
 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
 if (__isStringLike(pathName)) {
-h = CreateFileA(name, access, share, 0 /* sa */, create, attr, 0 /* hTempl */);
+	h = CreateFileA(name, access, share, 0 /* sa */, create, attr, 0 /* hTempl */);
 } else {
-h = CreateFileW(_wPathName, access, share, 0 /* sa */, create, attr, 0 /* hTempl */);
+	h = CreateFileW(_wPathName, 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 (__isStringLike(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_NOINT_CALL1( "RemoveDirectoryA", RemoveDirectoryA, _aPathName);
+		ret = STX_API_NOINT_CALL1( "RemoveDirectoryA", RemoveDirectoryA, _aPathName);
-} while ((ret < 0) && (__threadErrno == EINTR));
+	    } while ((ret < 0) && (__threadErrno == EINTR));
-}
+	}
 #else
-ret = RemoveDirectoryA((char *)__stringVal(fullPathName));
+	ret = RemoveDirectoryA((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);
 }
 if (__isUnicode16String(fullPathName)) {
 #ifdef DO_WRAP_CALLS
-{
+	{
-wchar_t _wPathName[MAXPATHLEN+1];
+	    wchar_t _wPathName[MAXPATHLEN+1];
-int i, l;
+	    int i, l;
-l = __unicode16StringSize(fullPathName);
+	    l = __unicode16StringSize(fullPathName);
-if (l > MAXPATHLEN) l = MAXPATHLEN;
+	    if (l > MAXPATHLEN) l = MAXPATHLEN;
-for (i=0; i<l; i++) {
+	    for (i=0; i<l; i++) {
-_wPathName[i] = __unicode16StringVal(fullPathName)[i];
+		_wPathName[i] = __unicode16StringVal(fullPathName)[i];
-}
+	    }
-_wPathName[i] = 0;
+	    _wPathName[i] = 0;
-do {
+	    do {
-__threadErrno = 0;
+		__threadErrno = 0;
-ret = STX_API_NOINT_CALL1( "RemoveDirectoryW", RemoveDirectoryW, _wPathName);
+		ret = STX_API_NOINT_CALL1( "RemoveDirectoryW", RemoveDirectoryW, _wPathName);
-} while ((ret < 0) && (__threadErrno == EINTR));
+	    } while ((ret < 0) && (__threadErrno == EINTR));
-}
+	}
 #else
-ret = RemoveDirectoryW((char *)__stringVal(fullPathName));
+	ret = RemoveDirectoryW((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 (__isStringLike(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_NOINT_CALL1( "DeleteFileA", DeleteFileA, _aPathName);
+		ret = STX_API_NOINT_CALL1( "DeleteFileA", DeleteFileA, _aPathName);
-} while ((ret < 0) && (__threadErrno == EINTR));
+	    } while ((ret < 0) && (__threadErrno == EINTR));
-}
+	}
 #else
-ret = DeleteFileA((char *)__stringVal(fullPathName));
+	ret = DeleteFileA((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);
 }
 if (__isUnicode16String(fullPathName)) {
 #ifdef DO_WRAP_CALLS
-{
+	{
-wchar_t _wPathName[MAXPATHLEN+1];
+	    wchar_t _wPathName[MAXPATHLEN+1];
-int i, l;
+	    int i, l;
-l = __unicode16StringSize(fullPathName);
+	    l = __unicode16StringSize(fullPathName);
-if (l > MAXPATHLEN) l = MAXPATHLEN;
+	    if (l > MAXPATHLEN) l = MAXPATHLEN;
-for (i=0; i<l; i++) {
+	    for (i=0; i<l; i++) {
-_wPathName[i] = __unicode16StringVal(fullPathName)[i];
+		_wPathName[i] = __unicode16StringVal(fullPathName)[i];
-}
+	    }
-_wPathName[i] = 0;
+	    _wPathName[i] = 0;
-do {
+	    do {
-__threadErrno = 0;
+		__threadErrno = 0;
-ret = STX_API_NOINT_CALL1( "DeleteFileW", DeleteFileW, _wPathName);
+		ret = STX_API_NOINT_CALL1( "DeleteFileW", DeleteFileW, _wPathName);
-} while ((ret < 0) && (__threadErrno == EINTR));
+	    } while ((ret < 0) && (__threadErrno == EINTR));
-}
+	}
 #else
-ret = DeleteFileW((char *)__stringVal(fullPathName));
+	ret = DeleteFileW((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 (__isStringLike(oldPath) && __isStringLike(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_NOINT_CALL2( "rename", rename, _oldPath, _newPath);
+	    ret = STX_C_NOINT_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) );
 }
 // These are not defined for Win32 - simply ignore them
 // (but handle them for UNIX compatibility
 if (aSymbol == @symbol(setUid)) {
-RETURN ( __mkSmallInteger(0) );
+	RETURN ( __mkSmallInteger(0) );
 }
 if (aSymbol == @symbol(setGid)) {
-RETURN ( __mkSmallInteger(0) );
+	RETURN ( __mkSmallInteger(0) );
 }
 if (aSymbol == @symbol(removeOnlyByOwner)) {
-RETURN ( __mkSmallInteger(0) );
+	RETURN ( __mkSmallInteger(0) );
 }
 %}.
 ^ 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 (__isStringLike(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_NOINT_CALL2( "stat", stat, _aPathName, &buf);
+	    ret = STX_C_NOINT_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 (__isStringLike(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_NOINT_CALL2( "chmod", chmod, _aPathName, __intVal(modeBits));
+	    ret = STX_C_NOINT_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
 "
 __address = __intVal(openFilenameStructureExternalAddress);
 __rslt = __STX_API_CALL1( "GetOpenFileName", (void *)GetOpenFileName, (void *)(__address));
 if (__rslt == TRUE) {
-rslt = true;
+	rslt = true;
 } else {
-rslt = false;
+	rslt = false;
 }
 %}.
 ^ rslt
 !
 __address = __intVal(openFilenameStructureExternalAddress);
 __rslt = __STX_API_CALL1( "GetSaveFileName", (void *)GetSaveFileName, (void *)(__address));
 if (__rslt == TRUE) {
-rslt = true;
+	rslt = true;
 } else {
-rslt = false;
+	rslt = false;
 }
 %}.
 ^ rslt
 ! !
 |attr|
 attr := self primGetFileAttributes:aPathName.
 (attr bitTest:FILE_ATTRIBUTE_HIDDEN ) ifTrue:[
-^ self primSetFileAttributes:aPathName to:(attr bitClear:2).
+	^ self primSetFileAttributes:aPathName to:(attr bitClear:2).
 ].
 ^ true
 "Created: / 29-07-2010 / 11:31:55 / sr"
 !
 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 (__isStringLike(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:\'
 ^ list
 !
 getDriveType:aPathName
 "returns:
-0 -> Unknown
+	0 -> Unknown
-1 -> Invalid
+	1 -> Invalid
-2 -> removable
+	2 -> removable
-3 -> fixed
+	3 -> fixed
-4 -> remote
+	4 -> remote
-5 -> cdrom
+	5 -> cdrom
-6 -> ramdisk.
+	6 -> ramdisk.
 This is a stupid interface - do not use."
 %{
 int ret;
 if (__isStringLike(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_NOINT_CALL1( "GetDriveType", GetDriveType, _aPathName);
+	    ret = STX_API_NOINT_CALL1( "GetDriveType", GetDriveType, _aPathName);
-} while ((ret < 0) && (__threadErrno == EINTR));
+	} while ((ret < 0) && (__threadErrno == EINTR));
 #else
-ret = GetDriveType((char *) __stringVal(aPathName));
+	ret = GetDriveType((char *) __stringVal(aPathName));
-if (ret < 0) {
+	if (ret < 0) {
-__threadErrno = __WIN32_ERR(GetLastError());
+	    __threadErrno = __WIN32_ERR(GetLastError());
-}
+	}
 #endif
-RETURN (__MKSMALLINT(ret));
+	RETURN (__MKSMALLINT(ret));
 }
 %}.
 ^ self primitiveFailed
 "
 %{
 int sz;
 DWORD dummy;
 if (__isStringLike(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
 %{
 int ret;
 wchar_t _aPathName[MAX_PATH+1];
 if (__isStringLike(aPathName)) {
-int i;
+	int i;
-int l = __stringSize(aPathName);
+	int l = __stringSize(aPathName);
-if (l > MAX_PATH) l = MAX_PATH;
+	if (l > MAX_PATH) l = MAX_PATH;
-for (i=0; i<l; i++) {
+	for (i=0; i<l; i++) {
-_aPathName[i] = __stringVal(aPathName)[i];
+	    _aPathName[i] = __stringVal(aPathName)[i];
-}
+	}
-_aPathName[i] = 0;
+	_aPathName[i] = 0;
 } else if (__isUnicode16String(aPathName)) {
-int i;
+	int i;
-int l = __unicode16StringSize(aPathName);
+	int l = __unicode16StringSize(aPathName);
-if (l > MAX_PATH) l = MAX_PATH;
+	if (l > MAX_PATH) l = MAX_PATH;
-for (i=0; i<l; i++) {
+	for (i=0; i<l; i++) {
-_aPathName[i] = __unicode16StringVal(aPathName)[i];
+	    _aPathName[i] = __unicode16StringVal(aPathName)[i];
-}
+	}
-_aPathName[i] = 0;
+	_aPathName[i] = 0;
 } else
-goto badArgument;
+	goto badArgument;
 #ifdef DO_WRAP_CALLS
 do {
-__threadErrno = 0;
+	 __threadErrno = 0;
-ret = STX_API_NOINT_CALL3( "GetLongPathNameW", GetLongPathNameW, _aPathName, _aPathName, MAX_PATH+1);
+	 ret = STX_API_NOINT_CALL3( "GetLongPathNameW", GetLongPathNameW, _aPathName, _aPathName, MAX_PATH+1);
 } while ((ret == 0) && (__threadErrno == EINTR));
 #else
 ret = GetLongPathNameW(_aPathName, _aPathName, MAX_PATH+1);
 if (ret == 0) {
-__threadErrno = __WIN32_ERR(GetLastError());
+	 __threadErrno = __WIN32_ERR(GetLastError());
 }
 #endif
 RETURN ( __MKU16STRING(_aPathName));
 badArgument:;
 %{
 int ret;
 wchar_t _aPathName[MAX_PATH+1];
 if (__isStringLike(aPathName)) {
-int i;
+	int i;
-int l = __stringSize(aPathName);
+	int l = __stringSize(aPathName);
-if (l > MAX_PATH) l = MAX_PATH;
+	if (l > MAX_PATH) l = MAX_PATH;
-for (i=0; i<l; i++) {
+	for (i=0; i<l; i++) {
-_aPathName[i] = __stringVal(aPathName)[i];
+	    _aPathName[i] = __stringVal(aPathName)[i];
-}
+	}
-_aPathName[i] = 0;
+	_aPathName[i] = 0;
 } else if (__isUnicode16String(aPathName)) {
-int i;
+	int i;
-int l = __unicode16StringSize(aPathName);
+	int l = __unicode16StringSize(aPathName);
-if (l > MAX_PATH) l = MAX_PATH;
+	if (l > MAX_PATH) l = MAX_PATH;
-for (i=0; i<l; i++) {
+	for (i=0; i<l; i++) {
-_aPathName[i] = __unicode16StringVal(aPathName)[i];
+	    _aPathName[i] = __unicode16StringVal(aPathName)[i];
-}
+	}
-_aPathName[i] = 0;
+	_aPathName[i] = 0;
 } else
-goto badArgument;
+	goto badArgument;
 #ifdef DO_WRAP_CALLS
 do {
-__threadErrno = 0;
+	 __threadErrno = 0;
-ret = STX_API_NOINT_CALL3( "GetShortPathNameW", GetShortPathNameW, _aPathName, _aPathName, MAX_PATH+1);
+	 ret = STX_API_NOINT_CALL3( "GetShortPathNameW", GetShortPathNameW, _aPathName, _aPathName, MAX_PATH+1);
 } while ((ret == 0) && (__threadErrno == EINTR));
 #else
 ret = GetShortPathNameW(_aPathName, _aPathName, MAX_PATH+1);
 if (ret == 0) {
-__threadErrno = __WIN32_ERR(GetLastError());
+	 __threadErrno = __WIN32_ERR(GetLastError());
 }
 #endif
 RETURN ( __MKU16STRING(_aPathName));
 badArgument:;
 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'
 %{
 int ret;
 if (__isStringLike(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_NOINT_CALL1( "GetFileAttributesA", GetFileAttributesA, _aPathName);
+	    ret = STX_API_NOINT_CALL1( "GetFileAttributesA", GetFileAttributesA, _aPathName);
-} while ((ret == -1) && (__threadErrno == EINTR));
+	} while ((ret == -1) && (__threadErrno == EINTR));
 #else
-ret = GetFileAttributesA((char *) __stringVal(aPathName));
+	ret = GetFileAttributesA((char *) __stringVal(aPathName));
-if (ret == -1) {
+	if (ret == -1) {
-__threadErrno = __WIN32_ERR(GetLastError());
+	    __threadErrno = __WIN32_ERR(GetLastError());
-}
+	}
 #endif
 } else if (__isUnicode16String(aPathName)) {
-wchar_t _wPathName[MAXPATHLEN+1];
+	wchar_t _wPathName[MAXPATHLEN+1];
-int i, l;
+	int i, l;
-l = __unicode16StringSize(aPathName);
+	l = __unicode16StringSize(aPathName);
-if (l > MAXPATHLEN) l = MAXPATHLEN;
+	if (l > MAXPATHLEN) l = MAXPATHLEN;
-for (i=0; i<l; i++) {
+	for (i=0; i<l; i++) {
-_wPathName[i] = __unicode16StringVal(aPathName)[i];
+	    _wPathName[i] = __unicode16StringVal(aPathName)[i];
-}
+	}
-_wPathName[i] = 0;
+	_wPathName[i] = 0;
 #ifdef DO_WRAP_CALLS
-do {
+	do {
-__threadErrno = 0;
+	    __threadErrno = 0;
-ret = STX_API_NOINT_CALL1( "GetFileAttributesW", GetFileAttributesW, _wPathName);
+	    ret = STX_API_NOINT_CALL1( "GetFileAttributesW", GetFileAttributesW, _wPathName);
-} while ((ret == -1) && (__threadErrno == EINTR));
+	} while ((ret == -1) && (__threadErrno == EINTR));
 #else
-ret = GetFileAttributesW(_wPathName);
+	ret = GetFileAttributesW(_wPathName);
-if (ret == -1) {
+	if (ret == -1) {
-__threadErrno = __WIN32_ERR(GetLastError());
+	    __threadErrno = __WIN32_ERR(GetLastError());
-}
+	}
 #endif
 } else
-goto err;
+	goto err;
 if (ret < 0) {
-@global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
+	@global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
-RETURN ( false );
+	RETURN ( false );
 }
 RETURN ( (ret & FILE_ATTRIBUTE_DIRECTORY) ? true : false);
 err:;
 %}.
 ^ self primitiveFailed
 "an alternative implementation would be:
-^ (self infoOf:aPathName) type == #directory
+	^ (self infoOf:aPathName) type == #directory
 "
 "
 self isDirectory:'.'
 self isDirectory:'.' asUnicode16String
 "
 "return true, if the file/dir 'aPathName' is readable.
 For symbolic links, the pointed-to-file is checked."
 %{
 if (__isStringLike(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_NOINT_CALL1( "GetFileAttributesA", GetFileAttributesA, _aPathName);
+	    ret = STX_API_NOINT_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);
 }
 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.
-*/
+	 */
-wchar_t _wPathName[MAXPATHLEN+1];
+	wchar_t _wPathName[MAXPATHLEN+1];
-int i, l;
+	int i, l;
-l = __unicode16StringSize(aPathName);
+	l = __unicode16StringSize(aPathName);
-if (l > MAXPATHLEN) l = MAXPATHLEN;
+	if (l > MAXPATHLEN) l = MAXPATHLEN;
-for (i=0; i<l; i++) {
+	for (i=0; i<l; i++) {
-_wPathName[i] = __unicode16StringVal(aPathName)[i];
+	    _wPathName[i] = __unicode16StringVal(aPathName)[i];
-}
+	}
-_wPathName[i] = 0;
+	_wPathName[i] = 0;
 #ifdef DO_WRAP_CALLS
-do {
+	do {
-__threadErrno = 0;
+	    __threadErrno = 0;
-ret = STX_API_NOINT_CALL1( "GetFileAttributesW", GetFileAttributesW, _wPathName);
+	    ret = STX_API_NOINT_CALL1( "GetFileAttributesW", GetFileAttributesW, _wPathName);
-} while ((ret < 0) && (__threadErrno == EINTR));
+	} while ((ret < 0) && (__threadErrno == EINTR));
 #else
-ret = GetFileAttributesW(_wPathName);
+	ret = GetFileAttributesW(_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);
 }
 %}.
 ^ self primitiveFailed
 "
 %{
 int ret;
 if (__isStringLike(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_NOINT_CALL1( "GetFileAttributesA", GetFileAttributesA, _aPathName);
+	    ret = STX_API_NOINT_CALL1( "GetFileAttributesA", GetFileAttributesA, _aPathName);
-} while ((ret == -1) && (__threadErrno == EINTR));
+	} while ((ret == -1) && (__threadErrno == EINTR));
 #else
-ret = GetFileAttributesA((char *) __stringVal(aPathName));
+	ret = GetFileAttributesA((char *) __stringVal(aPathName));
-if (ret == -1) {
+	if (ret == -1) {
-__threadErrno = __WIN32_ERR(GetLastError());
+	    __threadErrno = __WIN32_ERR(GetLastError());
-}
+	}
 #endif
 } else  if (__isUnicode16String(aPathName)) {
-wchar_t _wPathName[MAXPATHLEN+1];
+	wchar_t _wPathName[MAXPATHLEN+1];
-int i, l;
+	int i, l;
-l = __unicode16StringSize(aPathName);
+	l = __unicode16StringSize(aPathName);
-if (l > MAXPATHLEN) l = MAXPATHLEN;
+	if (l > MAXPATHLEN) l = MAXPATHLEN;
-for (i=0; i<l; i++) {
+	for (i=0; i<l; i++) {
-_wPathName[i] = __unicode16StringVal(aPathName)[i];
+	    _wPathName[i] = __unicode16StringVal(aPathName)[i];
-}
+	}
-_wPathName[i] = 0;
+	_wPathName[i] = 0;
 #ifdef DO_WRAP_CALLS
-do {
+	do {
-__threadErrno = 0;
+	    __threadErrno = 0;
-ret = STX_API_NOINT_CALL1( "GetFileAttributesW", GetFileAttributesW, _wPathName);
+	    ret = STX_API_NOINT_CALL1( "GetFileAttributesW", GetFileAttributesW, _wPathName);
-} while ((ret == -1) && (__threadErrno == EINTR));
+	} while ((ret == -1) && (__threadErrno == EINTR));
 #else
-ret = GetFileAttributesW(_wPathName);
+	ret = GetFileAttributesW(_wPathName);
-if (ret == -1) {
+	if (ret == -1) {
-__threadErrno = __WIN32_ERR(GetLastError());
+	    __threadErrno = __WIN32_ERR(GetLastError());
-}
+	}
 #endif
 } else
-goto err;
+	goto err;
 if (ret == -1) {
-@global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
+	@global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
-RETURN ( false );
+	RETURN ( false );
 }
 RETURN (true);
 err:;
 %}.
 |attr|
 attr := self primGetFileAttributes:aPathName.
 attr notNil ifTrue:[
-^ (attr bitAnd: (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_READONLY ))
+	^ (attr bitAnd: (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_READONLY ))
-~~ FILE_ATTRIBUTE_READONLY
+	    ~~ FILE_ATTRIBUTE_READONLY
 ].
 ^ false
 "
 self isWritable:'.'
 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),
 WIN32_FILE_ATTRIBUTE_DATA fileAttributeData;
 unsigned INT ino;
 wchar_t _aPathName[MAX_PATH+1];
 if (__isStringLike(aPathName)) {
-int i;
+	int i;
-int l = __stringSize(aPathName);
+	int l = __stringSize(aPathName);
-if (l > MAX_PATH) l = MAX_PATH;
+	if (l > MAX_PATH) l = MAX_PATH;
-for (i=0; i<l; i++) {
+	for (i=0; i<l; i++) {
-_aPathName[i] = __stringVal(aPathName)[i];
+	    _aPathName[i] = __stringVal(aPathName)[i];
-}
+	}
-_aPathName[i] = 0;
+	_aPathName[i] = 0;
 } else if (__isUnicode16String(aPathName)) {
-int i;
+	int i;
-int l = __unicode16StringSize(aPathName);
+	int l = __unicode16StringSize(aPathName);
-if (l > MAX_PATH) l = MAX_PATH;
+	if (l > MAX_PATH) l = MAX_PATH;
-for (i=0; i<l; i++) {
+	for (i=0; i<l; i++) {
-_aPathName[i] = __unicode16StringVal(aPathName)[i];
+	    _aPathName[i] = __unicode16StringVal(aPathName)[i];
-}
+	}
-_aPathName[i] = 0;
+	_aPathName[i] = 0;
 } else
-goto badArgument;
+	goto badArgument;
 #ifdef DO_WRAP_CALLS
 {
-do {
+	do {
-__threadErrno = 0;
+	    __threadErrno = 0;
-result = STX_API_NOINT_CALL3( "GetFileAttributesExW", GetFileAttributesExW, _aPathName, GetFileExInfoStandard, &fileAttributeData);
+	    result = STX_API_NOINT_CALL3( "GetFileAttributesExW", GetFileAttributesExW, _aPathName, GetFileExInfoStandard, &fileAttributeData);
-} while (!result && (__threadErrno == EINTR));
+	} while (!result && (__threadErrno == EINTR));
 }
 #else
 result = GetFileAttributesExW(_aPathName, GetFileExInfoStandard, &fileAttributeData);
 if (!result) {
-__threadErrno = __WIN32_ERR(GetLastError());
+	__threadErrno = __WIN32_ERR(GetLastError());
 }
 #endif
 if (!result) {
-@global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
+	@global(LastErrorNumber) = __mkSmallInteger(__threadErrno);
 } else {
-id = __mkSmallInteger(0);   /* could get it by opening ... */
+	id = __mkSmallInteger(0);   /* could get it by opening ... */
-size = __MKLARGEINT64(1, fileAttributeData.nFileSizeLow, fileAttributeData.nFileSizeHigh);
+	size = __MKLARGEINT64(1, fileAttributeData.nFileSizeLow, fileAttributeData.nFileSizeHigh);
 //        if (fileAttributeData.cFileName[0] != '\0') {
 //            bcopy(fileAttributeData.cFileName, fileNameBuffer, MAX_PATH*sizeof(wchar_t));
 //            fileNameBuffer[MAX_PATH] = '\0';
 //            fileName = __MKU16STRING(fileNameBuffer);             /* FULL name */
 //            bcopy(fileAttributeData.cAlternateFileName, alternativeFileNameBuffer, 14*sizeof(wchar_t));
 //            alternativeFileNameBuffer[14] = '\0';
 //            alternativeName = __MKU16STRING(alternativeFileNameBuffer); /* DOS name */
 //        }
-/*
+	/*
-* simulate access bits
+	 * simulate access bits
-*/
+	 */
-if (fileAttributeData.dwFileAttributes & FILE_ATTRIBUTE_READONLY) {
+	if (fileAttributeData.dwFileAttributes & FILE_ATTRIBUTE_READONLY) {
-modeBits = 0444;
+	    modeBits = 0444;
-} else {
+	} else {
-modeBits = 0666;
+	    modeBits = 0666;
-}
+	}
-if (fileAttributeData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
+	if (fileAttributeData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
-type = @symbol(directory);
+	    type = @symbol(directory);
-modeBits = 0777;   /* executable and WRITABLE - refer to comment in #isWritable: */
+	    modeBits = 0777;   /* executable and WRITABLE - refer to comment in #isWritable: */
-} else if (fileAttributeData.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) {
+	} else if (fileAttributeData.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) {
-type = @symbol(symbolicLink);
+	    type = @symbol(symbolicLink);
-modeBits = 0777;   /* even in UNIX symlinks have 0777 */
+	    modeBits = 0777;   /* even in UNIX symlinks have 0777 */
-} else {
+	} else {
-type = @symbol(regular);
+	    type = @symbol(regular);
-}
+	}
-mode = __mkSmallInteger(modeBits);
+	mode = __mkSmallInteger(modeBits);
-cOsTime = FileTimeToOsTime(&fileAttributeData.ftCreationTime);
+	cOsTime = FileTimeToOsTime(&fileAttributeData.ftCreationTime);
-aOsTime = FileTimeToOsTime(&fileAttributeData.ftLastAccessTime);
+	aOsTime = FileTimeToOsTime(&fileAttributeData.ftLastAccessTime);
-mOsTime = FileTimeToOsTime(&fileAttributeData.ftLastWriteTime);
+	mOsTime = FileTimeToOsTime(&fileAttributeData.ftLastWriteTime);
 }
 badArgument: ;
 %}.
 (aPathName endsWith:'.lnk') ifTrue:[
-type := #symbolicLink.
+	type := #symbolicLink.
-"/ 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 here
+	    "/ simulate here
-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 new fromOSTime:aOsTime.
+	    atime := Timestamp new fromOSTime:aOsTime.
-].
+	].
-mtime isNil ifTrue:[
+	mtime isNil ifTrue:[
-mtime := Timestamp new fromOSTime:mOsTime.
+	    mtime := Timestamp new fromOSTime:mOsTime.
-].
+	].
-ctime isNil ifTrue:[
+	ctime isNil ifTrue:[
-ctime := Timestamp new fromOSTime:cOsTime.
+	    ctime := Timestamp new fromOSTime:cOsTime.
-].
+	].
-fileName notNil ifTrue:[
+	fileName notNil ifTrue:[
-fileName := fileName asSingleByteStringIfPossible
+	    fileName := fileName asSingleByteStringIfPossible
-].
+	].
-alternativeName notNil ifTrue:[
+	alternativeName notNil ifTrue:[
-alternativeName := alternativeName asSingleByteStringIfPossible
+	    alternativeName := alternativeName asSingleByteStringIfPossible
-].
+	].
-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
-sourcePath:aPathName
+		    sourcePath:aPathName
-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:'.'
 %{
 int ret;
 if (__isStringLike(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_NOINT_CALL1( "GetFileAttributesA", GetFileAttributesA, _aPathName);
+	    ret = STX_API_NOINT_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) {
-RETURN ( __mkSmallInteger(ret) );
+	    RETURN ( __mkSmallInteger(ret) );
-}
+	}
-__threadErrno = __WIN32_ERR(GetLastError());
+	__threadErrno = __WIN32_ERR(GetLastError());
-RETURN (nil);
+	RETURN (nil);
 }
 if (__isUnicode16String(aPathName)) {
-wchar_t _wPathName[MAXPATHLEN+1];
+	wchar_t _wPathName[MAXPATHLEN+1];
-int i, l;
+	int i, l;
-l = __unicode16StringSize(aPathName);
+	l = __unicode16StringSize(aPathName);
-if (l > MAXPATHLEN) l = MAXPATHLEN;
+	if (l > MAXPATHLEN) l = MAXPATHLEN;
-for (i=0; i<l; i++) {
+	for (i=0; i<l; i++) {
-_wPathName[i] = __unicode16StringVal(aPathName)[i];
+	    _wPathName[i] = __unicode16StringVal(aPathName)[i];
-}
+	}
-_wPathName[i] = 0;
+	_wPathName[i] = 0;
 #ifdef DO_WRAP_CALLS
-do {
+	do {
-__threadErrno = 0;
+	    __threadErrno = 0;
-ret = STX_API_NOINT_CALL1( "GetFileAttributesW", GetFileAttributesW, _wPathName);
+	    ret = STX_API_NOINT_CALL1( "GetFileAttributesW", GetFileAttributesW, _wPathName);
-} while ((ret < 0) && (__threadErrno == EINTR));
+	} while ((ret < 0) && (__threadErrno == EINTR));
 #else
-ret = GetFileAttributesW(_wPathName);
+	ret = GetFileAttributesW(_wPathName);
-if (ret < 0) {
+	if (ret < 0) {
-__threadErrno = __WIN32_ERR(GetLastError());
+	    __threadErrno = __WIN32_ERR(GetLastError());
-}
+	}
 #endif
-if (ret >= 0) {
+	if (ret >= 0) {
-RETURN ( __mkSmallInteger(ret) );
+	    RETURN ( __mkSmallInteger(ret) );
-}
+	}
-__threadErrno = __WIN32_ERR(GetLastError());
+	__threadErrno = __WIN32_ERR(GetLastError());
-RETURN (nil);
+	RETURN (nil);
 }
 %}.
 ^ self primitiveFailed
 "
 Notice: if symbolic links are involved, the result may look different
 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_NOINT_CALL4( "GetFullPathName", GetFullPathName, _aPathName, sizeof(nameBuffer), nameBuffer, &pFinal);
+	    rslt = STX_API_NOINT_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 GetLongPathName_entry = NULL;
+	    static FARPROC GetLongPathName_entry = NULL;
 #ifdef NO_NT4_0_COMPATIBILITY
-GetLongPathName_entry = (FARPROC) GetLongPathName;
+	    GetLongPathName_entry = (FARPROC) GetLongPathName;
 #else
-if (GetLongPathName_entry == NULL) {
+	    if (GetLongPathName_entry == NULL) {
-GetLongPathName_entry = __get_kernel32_functionAddress("GetLongPathNameA");
+		GetLongPathName_entry = __get_kernel32_functionAddress("GetLongPathNameA");
-}
+	    }
 #endif /* NO_NT4_0_COMPATIBILITY */
-if (GetLongPathName_entry) {
+	    if (GetLongPathName_entry) {
 #ifdef DO_WRAP_CALLS
-do {
+		do {
-__threadErrno = 0;
+		    __threadErrno = 0;
-rslt = STX_API_NOINT_CALL3( "GetLongPathName", GetLongPathName_entry, nameBuffer, nameBuffer, sizeof(nameBuffer));
+		    rslt = STX_API_NOINT_CALL3( "GetLongPathName", GetLongPathName_entry, nameBuffer, nameBuffer, sizeof(nameBuffer));
-} while ((rslt < 0) && (__threadErrno == EINTR));
+		} while ((rslt < 0) && (__threadErrno == EINTR));
 #else
-rslt = (*GetLongPathName_entry)(nameBuffer, nameBuffer, sizeof(nameBuffer));
+		rslt = (*GetLongPathName_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());
-RETURN (nil);
+	RETURN (nil);
 }
 if (__isUnicode16String(aPathName)) {
-wchar_t nameBuffer[MAXPATHLEN + 1 + MAXPATHLEN + 1];
+	wchar_t nameBuffer[MAXPATHLEN + 1 + MAXPATHLEN + 1];
-char *pFinal;
+	char *pFinal;
-int rslt;
+	int rslt;
-wchar_t _aPathName[MAXPATHLEN+1];
+	wchar_t _aPathName[MAXPATHLEN+1];
-int i, l;
+	int i, l;
-l = __unicode16StringSize(aPathName);
+	l = __unicode16StringSize(aPathName);
-if (l > MAXPATHLEN) l = MAXPATHLEN;
+	if (l > MAXPATHLEN) l = MAXPATHLEN;
-for (i=0; i<l; i++) {
+	for (i=0; i<l; i++) {
-_aPathName[i] = __unicode16StringVal(aPathName)[i];
+	    _aPathName[i] = __unicode16StringVal(aPathName)[i];
-}
+	}
-_aPathName[i] = 0;
+	_aPathName[i] = 0;
 #ifdef DO_WRAP_CALLS
-do {
+	do {
-__threadErrno = 0;
+	    __threadErrno = 0;
-rslt = STX_API_NOINT_CALL4( "GetFullPathNameW", GetFullPathNameW, _aPathName, MAXPATHLEN, nameBuffer, &pFinal);
+	    rslt = STX_API_NOINT_CALL4( "GetFullPathNameW", GetFullPathNameW, _aPathName, MAXPATHLEN, nameBuffer, &pFinal);
-} while ((rslt < 0) && (__threadErrno == EINTR));
+	} while ((rslt < 0) && (__threadErrno == EINTR));
 #else
-rslt = GetFullPathName(_aPathName, MAXPATHLEN, nameBuffer, &pFinal);
+	rslt = GetFullPathName(_aPathName, MAXPATHLEN, 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 GetLongPathNameW_entry = NULL;
+	    static FARPROC GetLongPathNameW_entry = NULL;
 #ifdef NO_NT4_0_COMPATIBILITY
-GetLongPathNameW_entry = (FARPROC) GetLongPathNameW;
+	    GetLongPathNameW_entry = (FARPROC) GetLongPathNameW;
 #else
-if (GetLongPathNameW_entry == NULL) {
+	    if (GetLongPathNameW_entry == NULL) {
-GetLongPathNameW_entry = __get_kernel32_functionAddress("GetLongPathNameW");
+		GetLongPathNameW_entry = __get_kernel32_functionAddress("GetLongPathNameW");
-}
+	    }
 #endif /* NO_NT4_0_COMPATIBILITY */
-if (GetLongPathNameW_entry) {
+	    if (GetLongPathNameW_entry) {
 #ifdef DO_WRAP_CALLS
-do {
+		do {
-__threadErrno = 0;
+		    __threadErrno = 0;
-rslt = STX_API_NOINT_CALL3( "GetLongPathNameW", GetLongPathNameW_entry, nameBuffer, nameBuffer, MAXPATHLEN);
+		    rslt = STX_API_NOINT_CALL3( "GetLongPathNameW", GetLongPathNameW_entry, nameBuffer, nameBuffer, MAXPATHLEN);
-} while ((rslt < 0) && (__threadErrno == EINTR));
+		} while ((rslt < 0) && (__threadErrno == EINTR));
 #else
-rslt = (*GetLongPathNameW_entry)(nameBuffer, nameBuffer, MAXPATHLEN);
+		rslt = (*GetLongPathNameW_entry)(nameBuffer, nameBuffer, MAXPATHLEN);
 #endif
-}
+	    }
-}
+	}
-if (rslt > 0) {
+	if (rslt > 0) {
-RETURN ( __MKU16STRING(nameBuffer) );
+	    RETURN ( __MKU16STRING(nameBuffer) );
-}
+	}
-__threadErrno = __WIN32_ERR(GetLastError());
+	__threadErrno = __WIN32_ERR(GetLastError());
 }
 %}.
 ^ nil
 "
 %{
 int ret;
 if (__isSmallInteger(anInteger)) {
-if (__isStringLike(aPathName)) {
+	if (__isStringLike(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_NOINT_CALL2( "SetFileAttributesA", SetFileAttributesA, _aPathName, __intVal(anInteger) );
+		ret = STX_API_NOINT_CALL2( "SetFileAttributesA", SetFileAttributesA, _aPathName, __intVal(anInteger) );
-} while ((ret < 0) && (__threadErrno == EINTR));
+	    } while ((ret < 0) && (__threadErrno == EINTR));
 #else
-ret = SetFileAttributesA((char *) __stringVal(aPathName), __intVal(anInteger));
+	    ret = SetFileAttributesA((char *) __stringVal(aPathName), __intVal(anInteger));
-if (ret < 0) {
+	    if (ret < 0) {
-__threadErrno = __WIN32_ERR(GetLastError());
+		__threadErrno = __WIN32_ERR(GetLastError());
-}
+	    }
 #endif
-if (ret >= 0) {
+	    if (ret >= 0) {
-RETURN ( true );
+		RETURN ( true );
-}
+	    }
-__threadErrno = __WIN32_ERR(GetLastError());
+	    __threadErrno = __WIN32_ERR(GetLastError());
-RETURN (false);
+	    RETURN (false);
-}
+	}
-if (__isUnicode16String(aPathName)) {
+	if (__isUnicode16String(aPathName)) {
-wchar_t _wPathName[MAXPATHLEN+1];
+	    wchar_t _wPathName[MAXPATHLEN+1];
-int i, l;
+	    int i, l;
-l = __unicode16StringSize(aPathName);
+	    l = __unicode16StringSize(aPathName);
-if (l > MAXPATHLEN) l = MAXPATHLEN;
+	    if (l > MAXPATHLEN) l = MAXPATHLEN;
-for (i=0; i<l; i++) {
+	    for (i=0; i<l; i++) {
-_wPathName[i] = __unicode16StringVal(aPathName)[i];
+		_wPathName[i] = __unicode16StringVal(aPathName)[i];
-}
+	    }
-_wPathName[i] = 0;
+	    _wPathName[i] = 0;
 #ifdef DO_WRAP_CALLS
-do {
+	    do {
-__threadErrno = 0;
+		__threadErrno = 0;
-ret = STX_API_NOINT_CALL2( "SetFileAttributesW", SetFileAttributesW, _wPathName, __intVal(anInteger) );
+		ret = STX_API_NOINT_CALL2( "SetFileAttributesW", SetFileAttributesW, _wPathName, __intVal(anInteger) );
-} while ((ret < 0) && (__threadErrno == EINTR));
+	    } while ((ret < 0) && (__threadErrno == EINTR));
 #else
-ret = SetFileAttributesW(_wPathName, __intVal(anInteger));
+	    ret = SetFileAttributesW(_wPathName, __intVal(anInteger));
-if (ret < 0) {
+	    if (ret < 0) {
-__threadErrno = __WIN32_ERR(GetLastError());
+		__threadErrno = __WIN32_ERR(GetLastError());
-}
+	    }
 #endif
-if (ret >= 0) {
+	    if (ret >= 0) {
-RETURN ( true );
+		RETURN ( true );
-}
+	    }
-__threadErrno = __WIN32_ERR(GetLastError());
+	    __threadErrno = __WIN32_ERR(GetLastError());
-RETURN (false);
+	    RETURN (false);
-}
+	}
 }
 %}.
 ^ self primitiveFailed
 !
 setCurrentDirectory:pathName
 pathName bitsPerCharacter == 16 ifTrue:[
-self primSetCurrentDirectoryW:(pathName copyWith:(Character value:0))
+	self primSetCurrentDirectoryW:(pathName copyWith:(Character value:0))
 ] ifFalse:[
-self primSetCurrentDirectoryA:pathName
+	self primSetCurrentDirectoryA:pathName
 ].
 "
 self getCurrentDirectory
 self setCurrentDirectory:'C:\Users\cg\work\stx\projects'
 |attr|
 attr := self primGetFileAttributes:aPathName.
 (attr bitTest:FILE_ATTRIBUTE_HIDDEN ) ifFalse:[
-^ self primSetFileAttributes:aPathName to:(attr bitOr:2).
+	^ self primSetFileAttributes:aPathName to:(attr bitOr:2).
 ].
 ^ true  "/ aready set
 "Modified: / 29-07-2010 / 11:32:26 / sr"
 !
 |attr|
 attr := self primGetFileAttributes:aPathName.
 (attr bitTest:FILE_ATTRIBUTE_NORMAL ) ifFalse:[
-^ self primSetFileAttributes:aPathName to:(attr bitOr:2).
+	^ self primSetFileAttributes:aPathName to:(attr bitOr:2).
 ].
 ^ true  "/ aready set
 !
 setTemporary:aPathName
 |attr|
 attr := self primGetFileAttributes:aPathName.
 (attr bitTest:FILE_ATTRIBUTE_TEMPORARY ) ifFalse:[
-^ self primSetFileAttributes:aPathName to:(attr bitOr:2).
+	^ self primSetFileAttributes:aPathName to:(attr bitOr:2).
 ].
 ^ true  "/ aready set
 !
 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.
 "
 !
 volumeLabelOf: aFilenameOrString
-"Answer the volume label of the disk containing aFilenameOrString."
+	"Answer the volume label of the disk containing aFilenameOrString."
 | volName |
 volName := String new: 255.
 ( self
-getVolumeInformation: aFilenameOrString asFilename volume, '\'
+	getVolumeInformation: aFilenameOrString asFilename volume, '\'
-name: volName
+	name: volName
-nameSize: volName size
+	nameSize: volName size
-serialNumber: nil
+	serialNumber: nil
-maximumComponentLength: nil
+	maximumComponentLength: nil
-fileSystemFlags: nil
+	fileSystemFlags: nil
-fileSystemName: nil
+	fileSystemName: nil
-fileSystemNameSize: 0 )
+	fileSystemNameSize: 0 )
-ifFalse: [
+	    ifFalse: [
-Transcript showCR:'GetVolumeInformation error'.
+		Transcript showCR:'GetVolumeInformation error'.
-^ ''
+		^ ''
-].
+	].
 ^ volName copyUpTo: Character null
 "
-self volumeLabelOf: 'C:\pepe.pep'
+	self volumeLabelOf: 'C:\pepe.pep'
-self volumeLabelOf: 'C:'
+	self volumeLabelOf: 'C:'
-self volumeLabelOf: 'C:\\'
+	self volumeLabelOf: 'C:\\'
-self volumeLabelOf: 'C:\'
+	self volumeLabelOf: 'C:\'
 "
 !
 volumeNameOf:aPathString
 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'!
 "open a windows-shell application to present the document contained in aFilenameOrString.
 This looks for the files extension, and is typically used to present help-files,
 html documents, pdf documents etc."
 Error
-handle:[:ex |
+	handle:[:ex |
-Dialog warn:'Shell execution failed'
+	    Dialog warn:'Shell execution failed'
-] do:[
+	] do:[
-self openApplicationForDocument:aFilenameOrString operation:#open
+	    self openApplicationForDocument:aFilenameOrString operation:#open
-]
+	]
 "
 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 single 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
 "
 %{
 int ret;
 do {
-ret = STX_API_NOINT_CALL1("Sleep", Sleep, 60000);
+	ret = STX_API_NOINT_CALL1("Sleep", Sleep, 60000);
 } while (ret < 0 && __threadErrno == EINTR);
 %}.
 "
 OperatingSystem blockingTest3
 "
 %{
 int ret;
 do {
-ret = STX_API_CALL1("Sleep", Sleep, 60000);
+	ret = STX_API_CALL1("Sleep", Sleep, 60000);
 } while (ret < 0 && __threadErrno == EINTR);
 %}.
 "
 OperatingSystem blockingTest4
 "
 %{  /* 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:processHandleOrPid
 "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:processHandleOrPid exitCode:0
 !
 terminateProcess:processHandleOrPid 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(processHandleOrPid) ) {
-HANDLE hProcess = _HANDLEVal(processHandleOrPid);
+	HANDLE hProcess = _HANDLEVal(processHandleOrPid);
-if (hProcess != 0) {
+	if (hProcess != 0) {
-TerminateProcess( hProcess, __intVal(exitCode) );
+	    TerminateProcess( hProcess, __intVal(exitCode) );
-}
+	}
-RETURN( true );
+	RETURN( true );
 } else if( __isSmallInteger(processHandleOrPid) ) {
-HANDLE hProcess = OpenProcess(PROCESS_TERMINATE, 0, __smallIntegerVal(processHandleOrPid));
+	HANDLE hProcess = OpenProcess(PROCESS_TERMINATE, 0, __smallIntegerVal(processHandleOrPid));
-if( hProcess != 0 ) {
+	if( hProcess != 0 ) {
-TerminateProcess( hProcess, __intVal(exitCode) );
+	    TerminateProcess( hProcess, __intVal(exitCode) );
-CloseHandle(hProcess);
+	    CloseHandle(hProcess);
-}
+	}
-RETURN( true );
+	RETURN( true );
 }
 %}.
 self primitiveFailed:#invalidParameter.
 terminateProcessGroup:processGroupHandleOrPid
 "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."
 | pid list |
 list := self getAllProcesses.
 list size == 0 ifTrue:[^ self ].
 processGroupHandleOrPid isInteger ifTrue:[
-pid := processGroupHandleOrPid
+	pid := processGroupHandleOrPid
 ] ifFalse:[
-pid := processGroupHandleOrPid pid.
+	pid := processGroupHandleOrPid pid.
 ].
 list do:[:anOSProcess |
-( anOSProcess parentPid == pid ) ifTrue:[
+	( anOSProcess parentPid == pid ) ifTrue:[
-self terminateProcess:( anOSProcess pid ).
+	    self terminateProcess:( anOSProcess pid ).
-].
+	].
 ].
 ! !
 !Win32OperatingSystem class methodsFor:'ipc support'!
 sa.nLength = sizeof(SECURITY_ATTRIBUTES);
 sa.lpSecurityDescriptor = NULL;
 sa.bInheritHandle = TRUE;
 if( ! CreatePipe( &pipeRead, &pipeWrite, &sa, 0 ) ) {
-@global(LastErrorNumber) = error = __mkSmallInteger( __WIN32_ERR(GetLastError()) );
+	@global(LastErrorNumber) = error = __mkSmallInteger( __WIN32_ERR(GetLastError()) );
-goto out;
+	goto out;
 }
 #if 1
 fd1 = __MKEXTERNALADDRESS(pipeRead);
 fd2 = __MKEXTERNALADDRESS(pipeWrite);
 fd2 = __mkSmallInteger(_open_osfhandle(pipeWrite, O_BINARY));
 #endif
 out:;
 %}.
 (fd1 notNil and:[fd2 notNil]) ifTrue:[
-(fd1 ~~ -1 and:[fd2 ~~ -1]) ifTrue:[
+	(fd1 ~~ -1 and:[fd2 ~~ -1]) ifTrue:[
-^ Array with:fd1 with:fd2.
+	    ^ Array with:fd1 with:fd2.
-].
+	].
 ].
 ^ nil
 ! !
 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"
 |hMe spaceForTargetHandle rslt|
 spaceForTargetHandle := ExternalLong new.
 hMe := self getCurrentProcess.
 rslt := self
-primDuplicateHandle_hSourcProcessHandle:hMe
+		primDuplicateHandle_hSourcProcessHandle:hMe
-hSourceHandle:aHandle
+		hSourceHandle:aHandle
-hTargetProcesshandle:targetProcessHandle
+		hTargetProcesshandle:targetProcessHandle
-lpTargetHandle:spaceForTargetHandle
+		lpTargetHandle:spaceForTargetHandle
-dwDesiredAccess:0
+		dwDesiredAccess:0
-bInheritHandle:false
+		bInheritHandle:false
-dwOptions:2 "DUPLICATE_SAME_ACCESS".
+		dwOptions:2 "DUPLICATE_SAME_ACCESS".
 rslt ifFalse:[
-self primitiveFailed.
+	self primitiveFailed.
-^ nil
+	^ nil
 ].
 ^ ExternalAddress newAddress:(spaceForTargetHandle value).
 "Created: / 18-09-2007 / 16:34:25 / cg"
 !
 HANDLE hProcessSnap;
 PROCESSENTRY32 pe32;
 hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
 if( hProcessSnap != INVALID_HANDLE_VALUE ) {
-pe32.dwSize = sizeof(PROCESSENTRY32);
+	pe32.dwSize = sizeof(PROCESSENTRY32);
-Process32First( hProcessSnap, & pe32 );
+	Process32First( hProcessSnap, & pe32 );
-do {
+	do {
-st_perProc = __SSEND0(@global(OSProcess), @symbol(new), 0);
+	    st_perProc = __SSEND0(@global(OSProcess), @symbol(new), 0);
-__SSEND1(st_perProc, @symbol(commandLine:), 0, __MKSTRING(pe32.szExeFile) );
+	    __SSEND1(st_perProc, @symbol(commandLine:), 0, __MKSTRING(pe32.szExeFile) );
-__SSEND1(st_perProc, @symbol(pid:), 0, __mkSmallInteger(pe32.th32ProcessID) );
+	    __SSEND1(st_perProc, @symbol(pid:), 0, __mkSmallInteger(pe32.th32ProcessID) );
-__SSEND1(st_perProc, @symbol(parentPid:), 0, __mkSmallInteger(pe32.th32ParentProcessID) );
+	    __SSEND1(st_perProc, @symbol(parentPid:), 0, __mkSmallInteger(pe32.th32ParentProcessID) );
-__SSEND1(list, @symbol(add:), 0, st_perProc );
+	    __SSEND1(list, @symbol(add:), 0, st_perProc );
-}
+	}
-while(Process32Next(hProcessSnap,&pe32));
+	while(Process32Next(hProcessSnap,&pe32));
-CloseHandle( hProcessSnap );
+	CloseHandle( hProcessSnap );
 }
 #endif  /* TLHELP32_H_INCLUDE */
 %}.
 "Created: / 18-09-2007 / 16:32:22 / cg"
 !
 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 (__isStringLike(appNameString)) {
-__appNameString = __stringVal(appNameString);
+	__appNameString = __stringVal(appNameString);
 } else if (appNameString != nil)
-goto primitiveFail;
+	goto primitiveFail;
 if (__isStringLike(keyNameString)) {
-__keyNameString = __stringVal(keyNameString);
+	__keyNameString = __stringVal(keyNameString);
 } else if (keyNameString != nil)
-goto primitiveFail;
+	goto primitiveFail;
 if (__isStringLike(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 (__isStringLike(appNameString)) {
-__appNameString = __stringVal(appNameString);
+	__appNameString = __stringVal(appNameString);
 } else if (appNameString != nil)
-goto primitiveFail;
+	goto primitiveFail;
 if (__isStringLike(keyNameString)) {
-__keyNameString = __stringVal(keyNameString);
+	__keyNameString = __stringVal(keyNameString);
 } else if (keyNameString != nil)
-goto primitiveFail;
+	goto primitiveFail;
 if (__isStringLike(defaultString)) {
-__defaultString = __stringVal(defaultString);
+	__defaultString = __stringVal(defaultString);
 } else if (defaultString != nil)
-goto primitiveFail;
+	goto primitiveFail;
 if (private == true) {
-if (! __isStringLike(fileName)) goto primitiveFail;
+	if (! __isStringLike(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: ;
 %}.
 multiByteToWideCharCp: cp flags: flags lpstr: lpstr cchstr: cchstr lpwstr: lpwstr cchwstr: cchwstr
 "Convert the multi-byte string encoding in <lpstr> to a Unicode encoding in <lpwstr>."
 " int MultiByteToWideChar(
-UINT  CodePage,    // code page
+	UINT  CodePage,    // code page
-DWORD  dwFlags,    // character-type options
+	DWORD  dwFlags,    // character-type options
-LPCSTR  lpMultiByteStr,    // address of string to map
+	LPCSTR  lpMultiByteStr,    // address of string to map
-int  cchMultiByte,    // number of characters in string
+	int  cchMultiByte,    // number of characters in string
-LPWSTR  lpWideCharStr,    // address of wide-character buffer
+	LPWSTR  lpWideCharStr,    // address of wide-character buffer
-int  cchWideChar     // size of buffer
+	int  cchWideChar     // size of buffer
-);"
+	);"
 <apicall: ulongReturn "MultiByteToWideChar" ( uint32 uint32 structIn int32 structOut int32) module: "kernel32.dll" >
 ^self primitiveFailed
 "Modified (comment): / 12-08-2011 / 16:37:06 / cg"
 "/#define SND_LOOP            0x0008  /* loop the sound until next sndPlaySound */
 "/#define SND_NOSTOP          0x0010  /* don't stop any currently playing sound */
 "
 self
-playSound:'C:\Dokumente und Einstellungen\cg\work\exept\expecco\resources\sounds\start.wav'
+	playSound:'C:\Dokumente und Einstellungen\cg\work\exept\expecco\resources\sounds\start.wav'
 "
 "Created: / 06-11-2007 / 00:46:57 / cg"
 !
 "/#define SND_LOOP            0x0008  /* loop the sound until next sndPlaySound */
 "/#define SND_NOSTOP          0x0010  /* don't stop any currently playing sound */
 "
 self
-playSound:'C:\Dokumente und Einstellungen\cg\work\exept\expecco\resources\sounds\start.wav'
+	playSound:'C:\Dokumente und Einstellungen\cg\work\exept\expecco\resources\sounds\start.wav'
-mode:1
+	mode:1
 "
 "Modified: / 06-11-2007 / 00:46:27 / cg"
 !
 primGetLastError
 <apicall: dword "GetLastError" () module: "kernel32.dll" >
 "
-self primGetLastError
+	self primGetLastError
 "
 !
 primSetLastError: int
 <apicall: void "SetLastError" (dword) module: "kernel32.dll" >
 "
-self primSetLastError: 0
+	self primSetLastError: 0
 "
 !
 primWritePrivateProfileString: appName keyName: keyName profileString: profString fileName: aString
 defaultUsed: defaultUsed
 "Convert the Unicode encoding in <lpWideCharStr> to a multi-byte string encoding in <lpstr>."
 "int WideCharToMultiByte(
-UINT  CodePage,    // code page
+	UINT  CodePage,    // code page
-DWORD  dwFlags,    // performance and mapping flags
+	DWORD  dwFlags,    // performance and mapping flags
-LPCWSTR  lpWideCharStr,    // address of wide-character string
+	LPCWSTR  lpWideCharStr,    // address of wide-character string
-int  cchWideChar,    // number of characters in string
+	int  cchWideChar,    // number of characters in string
-LPSTR  lpMultiByteStr,    // address of buffer for new string
+	LPSTR  lpMultiByteStr,    // address of buffer for new string
-int  cchMultiByte,    // size of buffer
+	int  cchMultiByte,    // size of buffer
-LPCSTR  lpDefaultChar,    // address of default for unmappable characters
+	LPCSTR  lpDefaultChar,    // address of default for unmappable characters
-LPBOOL  lpUsedDefaultChar     // address of flag set when default char. used
+	LPBOOL  lpUsedDefaultChar     // address of flag set when default char. used
-);"
+	);"
 <apicall: ulongReturn "MultiByteToWideChar" ( uint32 uint32 structIn int32 structOut int32 structIn structOut) module: "kernel32.dll" >
 ^self primitiveFailed
 "Modified (comment): / 12-08-2011 / 16:37:14 / cg"
 "/    self assert: lastErrorCode == 0.
 "/    lastErrorCode == 5 "ERROR_ACCESS_DENIED" ifTrue:[Transcript showCR: 'Mutex not accesible (GetLastError = ERROR_ACCESS_DENIED)'.].
 "/    lastErrorCode == 183 "ERROR_ALREADY_EXISTS" ifTrue:[Transcript showCR: 'Mutex already exists (GetLastError = ERROR_ALREADY_EXISTS)'.].
 (handle isNil or:[handle address ~~ 0]) ifFalse:[
-Transcript showCR: 'CreateMutexNamed: "', name printString, '" failed'.
+	Transcript showCR: 'CreateMutexNamed: "', name printString, '" failed'.
-handle := nil.
+	handle := nil.
 ].
 ^ Array with: handle with: lastErrorCode
 "
 self createMutexNamed: '8906f5e0-54ed-11dd-9da4-001558137da0'
 handleAndLastErrorCode := self createMutexNamed: name.
 handle := handleAndLastErrorCode first.
 lastErrorCode := handleAndLastErrorCode second.
 "/    self assert: lastErrorCode == 0.
 ^ handle isNil
-or:[lastErrorCode == 183 "ERROR_ALREADY_EXISTS"
+	or:[lastErrorCode == 183 "ERROR_ALREADY_EXISTS"
-or:[ lastErrorCode == 5 "ERROR_ACCESS_DENIED"]]
+	    or:[ lastErrorCode == 5 "ERROR_ACCESS_DENIED"]]
 "Modified: / 03-08-2010 / 16:59:41 / cg"
 !
 openMutexNamed: name
 handle := self primOpenMutex:nil initialOwner: true name: name.
 "/    lastErrorCode := self primGetLastError.
 "/    lastErrorCode = 2 ifTrue:[Transcript showCR: 'Mutex does not exist (GetLastError = ERROR_FILE_NOT_FOUND)'.].
 "/    lastErrorCode = 5 ifTrue:[Transcript showCR: 'Mutex not accesible (GetLastError = ERROR_ACCESS_DENIED)'.].
 (handle isNil or:[handle address ~~ 0]) ifFalse:[
-Transcript showCR: 'OpenMutexNamed: "', name printString, '" failed'.
+	Transcript showCR: 'OpenMutexNamed: "', name printString, '" failed'.
-^ nil.
+	^ nil.
 ].
 ^ handle
 "Returns true if the Mutex was released. Otherwise, returns false."
 | released|
 hMutex isNil ifTrue:[
-Transcript showCR: 'hMutex is nil - cannot release'.
+	Transcript showCR: 'hMutex is nil - cannot release'.
-^ false
+	^ false
 ].
 released := self primReleaseMutex: hMutex.
 released ifFalse:[Transcript showCR: 'Release Mutex failed'.].
 ^ released
 | hMutex |
 hMutex := self openMutexNamed: name.
 hMutex isNil ifTrue:[
-Transcript showCR: 'Cannot release Mutex named: "', name printString,'"'.
+	Transcript showCR: 'Cannot release Mutex named: "', name printString,'"'.
-^ false
+	^ false
 ].
 ^ self releaseMutex: hMutex.
 "Modified: / 03-08-2010 / 16:58:25 / cg"
 !
 !
 getDomainName
 "return the DNS domain this host is in.
 Notice:
-not all systems support this; on some, 'unknown' is returned."
+	not all systems support this; on some, 'unknown' is returned."
 |domainName idx hostName k|
 DomainName notNil ifTrue:[
-^ DomainName
+	^ DomainName
 ].
 "/ sometimes, we can extract the domainName from the hostName ...
 hostName := self getHostName.
 hostName notEmptyOrNil ifTrue:[
-idx := hostName indexOf:$..
+	idx := hostName indexOf:$..
-idx ~~ 0 ifTrue:[
+	idx ~~ 0 ifTrue:[
-domainName := hostName copyFrom:idx+1.
+	    domainName := hostName copyFrom:idx+1.
-]
+	]
 ].
 domainName isNil ifTrue:[
-domainName := self getEnvironment:'DOMAIN'.
+	domainName := self getEnvironment:'DOMAIN'.
-domainName isNil ifTrue:[
+	domainName isNil ifTrue:[
-domainName := self getEnvironment:'DOMAINNAME'.
+	    domainName := self getEnvironment:'DOMAINNAME'.
-].
+	].
-domainName isNil ifTrue:[
+	domainName isNil ifTrue:[
-"/ ok, search the registry ...
+	    "/ ok, search the registry ...
-"/ under NT and later, it is found there ...
+	    "/ under NT and later, it is found there ...
-k := RegistryEntry key:'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters'.
+	    k := RegistryEntry key:'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters'.
-k notNil ifTrue:[
+	    k notNil ifTrue:[
-domainName := k valueNamed:'Domain'.
+		domainName := k valueNamed:'Domain'.
-k close.
+		k close.
-].
+	    ].
-].
+	].
-domainName isNil ifTrue:[
+	domainName 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:[
-domainName := k valueNamed:'Domain'.
+		domainName := k valueNamed:'Domain'.
-k close.
+		k close.
-]
+	    ]
-].
+	].
-domainName isNil ifTrue:[
+	domainName isNil ifTrue:[
-'Win32OperatingSystem [warning]: cannot find out domainName' errorPrintCR.
+	    'Win32OperatingSystem [warning]: cannot find out domainName' errorPrintCR.
-domainName := 'unknown'.
+	    domainName := 'unknown'.
-].
+	].
-DomainName := domainName.     "cache only, if it is fixed"
+	DomainName := domainName.     "cache only, if it is fixed"
 ].
 ^ domainName
 "
 DomainName := nil.
 %{  /* NOCONTEXT */
 char *env;
 if (__isStringLike(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
 %{  /* STACK: 2048 */
 char buffer[512];
 DWORD buffSize = sizeof(buffer);
 if (GetComputerNameEx(ComputerNameDnsFullyQualified, buffer, &buffSize) == TRUE) {
-hostName = __MKSTRING(buffer);
+	hostName = __MKSTRING(buffer);
 }
 %}.
 ^ hostName
 "
 |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
 GetAdaptersInfo_entry = (FARPROC) GetAdaptersInfo;
 #else
 if (GetAdaptersInfo_entry == NULL) {
-GetAdaptersInfo_entry = __get_iphlpapi_functionAddress("GetAdaptersInfo");
+	GetAdaptersInfo_entry = __get_iphlpapi_functionAddress("GetAdaptersInfo");
 }
 #endif /* NO_NT4_0_COMPATIBILITY */
 if (GetAdaptersInfo_entry) {
-dwStatus = (*GetAdaptersInfo_entry)(
+	dwStatus = (*GetAdaptersInfo_entry)(
-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
 getNumberOfProcessors
 "answer the number of physical processors in the system"
 %{
-SYSTEM_INFO sInfo;
+	SYSTEM_INFO sInfo;
-GetSystemInfo(&sInfo);
+	GetSystemInfo(&sInfo);
-return __mkSmallInteger(sInfo.dwNumberOfProcessors);
+	return __mkSmallInteger(sInfo.dwNumberOfProcessors);
 %}.
 "
-self getNumberOfProcessors
+	self getNumberOfProcessors
 "
 !
 getProcessId
 "return the (unix-)processId"
 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 minorVer majorVer mach dom info arch
 physicalRam freeRam swapSize freeSwap
 virtualRam freeVirtual memoryLoad numberOfCPUs|
 minorVer = __mkSmallInteger(verMinor);
 majorVer = __mkSmallInteger(verMajor);
 if (HIWORD(vsn) & 0x8000) {
-sys = @symbol(win95);
+	sys = @symbol(win95);
 } else {
-if ((verMajor > 5)
+	if ((verMajor > 5)
-|| ((verMajor == 5) && (verMinor >= 1))) {
+	 || ((verMajor == 5) && (verMinor >= 1))) {
-sys = @symbol(xp);
+	    sys = @symbol(xp);
-if (verMajor >= 6) {
+	    if (verMajor >= 6) {
-sys = @symbol(vista);
+		sys = @symbol(vista);
-if (verMinor >= 1) {
+		if (verMinor >= 1) {
-sys = @symbol(win7);
+		    sys = @symbol(win7);
-}
+		}
-}
+	    }
-} else {
+	} else {
-sys = @symbol(nt);
+	    sys = @symbol(nt);
-}
+	}
 }
 len = snprintf(vsnBuffer, sizeof(vsnBuffer), "%d.%d", verMajor, verMinor);
 rel = __MKSTRING_L(vsnBuffer, len);
 GetSystemInfo(&sysInfo);
 /* MSC, BorlandC4 ... */
 switch (sysInfo.wProcessorArchitecture)
 #endif
 {
 #ifdef PROCESSOR_ARCHITECTURE_INTEL
-case PROCESSOR_ARCHITECTURE_INTEL:
+	case PROCESSOR_ARCHITECTURE_INTEL:
-arch = @symbol(intel);
+	    arch = @symbol(intel);
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_ARCHITECTURE_AMD64
-case PROCESSOR_ARCHITECTURE_AMD64:
+	case PROCESSOR_ARCHITECTURE_AMD64:
-arch = @symbol(x64);
+	    arch = @symbol(x64);
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_ARCHITECTURE_MIPS
-case PROCESSOR_ARCHITECTURE_MIPS:
+	case PROCESSOR_ARCHITECTURE_MIPS:
-arch = @symbol(mips);
+	    arch = @symbol(mips);
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_ARCHITECTURE_ALPHA
-case PROCESSOR_ARCHITECTURE_ALPHA:
+	case PROCESSOR_ARCHITECTURE_ALPHA:
-arch = @symbol(alpha);
+	    arch = @symbol(alpha);
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_ARCHITECTURE_ALPHA64
-case PROCESSOR_ARCHITECTURE_ALPHA64:
+	case PROCESSOR_ARCHITECTURE_ALPHA64:
-arch = @symbol(alpha64);
+	    arch = @symbol(alpha64);
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_ARCHITECTURE_PPC
-case PROCESSOR_ARCHITECTURE_PPC:
+	case PROCESSOR_ARCHITECTURE_PPC:
-arch = @symbol(ppc);
+	    arch = @symbol(ppc);
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_ARCHITECTURE_ARM
-case PROCESSOR_ARCHITECTURE_ARM:
+	case PROCESSOR_ARCHITECTURE_ARM:
-arch = @symbol(arm);
+	    arch = @symbol(arm);
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_ARCHITECTURE_SHX
-case PROCESSOR_ARCHITECTURE_SHX:
+	case PROCESSOR_ARCHITECTURE_SHX:
-arch = @symbol(shx);
+	    arch = @symbol(shx);
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_ARCHITECTURE_IA64
-case PROCESSOR_ARCHITECTURE_IA64:
+	case PROCESSOR_ARCHITECTURE_IA64:
-arch = @symbol(ia64);
+	    arch = @symbol(ia64);
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_ARCHITECTURE_MSIL
-case PROCESSOR_ARCHITECTURE_MSIL:
+	case PROCESSOR_ARCHITECTURE_MSIL:
-arch = @symbol(msil);
+	    arch = @symbol(msil);
-break;
+	    break;
 #endif
-default:
+	default:
-arch = @symbol(unknown);
+	    arch = @symbol(unknown);
-break;
+	    break;
 }
 switch (sysInfo.dwProcessorType) {
 #ifdef PROCESSOR_INTEL_386
-case PROCESSOR_INTEL_386:
+	case PROCESSOR_INTEL_386:
-mach = @symbol(i386);
+	    mach = @symbol(i386);
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_INTEL_486
-case PROCESSOR_INTEL_486:
+	case PROCESSOR_INTEL_486:
-mach = @symbol(i486);
+	    mach = @symbol(i486);
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_INTEL_PENTIUM
-case PROCESSOR_INTEL_PENTIUM:
+	case PROCESSOR_INTEL_PENTIUM:
-mach = @symbol(i586);
+	    mach = @symbol(i586);
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_INTEL_860
-case PROCESSOR_INTEL_860:
+	case PROCESSOR_INTEL_860:
-mach = @symbol(i860);
+	    mach = @symbol(i860);
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_INTEL_IA64
-case PROCESSOR_INTEL_IA64:
+	case PROCESSOR_INTEL_IA64:
-mach = @symbol(ia64);
+	    mach = @symbol(ia64);
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_MIPS_R2000
-case PROCESSOR_MIPS_R2000:
+	case PROCESSOR_MIPS_R2000:
-mach = @symbol(r2000);
+	    mach = @symbol(r2000);
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_MIPS_R3000
-case PROCESSOR_MIPS_R3000:
+	case PROCESSOR_MIPS_R3000:
-mach = @symbol(r3000);
+	    mach = @symbol(r3000);
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_MIPS_R4000
-case PROCESSOR_MIPS_R4000:
+	case PROCESSOR_MIPS_R4000:
-mach = @symbol(r4000);
+	    mach = @symbol(r4000);
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_ALPHA_21064
-case PROCESSOR_ALPHA_21064:
+	case PROCESSOR_ALPHA_21064:
-mach = @symbol(alpha21064);
+	    mach = @symbol(alpha21064);
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_ARM720
-case PROCESSOR_ARM720:
+	case PROCESSOR_ARM720:
-mach = @symbol(arm720);
+	    mach = @symbol(arm720);
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_ARM820
-case PROCESSOR_ARM820:
+	case PROCESSOR_ARM820:
-mach = @symbol(arm820);
+	    mach = @symbol(arm820);
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_ARM920
-case PROCESSOR_ARM920:
+	case PROCESSOR_ARM920:
-mach = @symbol(arm920);
+	    mach = @symbol(arm920);
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_ARM_7TDMI
-case PROCESSOR_ARM_7TDMI:
+	case PROCESSOR_ARM_7TDMI:
-mach = @symbol(arm70001);
+	    mach = @symbol(arm70001);
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_PPC_601
-case PROCESSOR_PPC_601:
+	case PROCESSOR_PPC_601:
-mach = @symbol(ppc601);
+	    mach = @symbol(ppc601);
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_PPC_603
-case PROCESSOR_PPC_603:
+	case PROCESSOR_PPC_603:
-mach = @symbol(ppc603);
+	    mach = @symbol(ppc603);
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_PPC_604
-case PROCESSOR_PPC_604:
+	case PROCESSOR_PPC_604:
-mach = @symbol(ppc604);
+	    mach = @symbol(ppc604);
-break;
+	    break;
 #endif
 #ifdef PROCESSOR_PPC_620
-case PROCESSOR_PPC_620:
+	case PROCESSOR_PPC_620:
-mach = @symbol(ppc620);
+	    mach = @symbol(ppc620);
-break;
+	    break;
 #endif
-default:
+	default:
-sprintf(vsnBuffer, "%d", sysInfo.dwProcessorType);
+	    sprintf(vsnBuffer, "%d", sysInfo.dwProcessorType);
-mach =  __MKSTRING(vsnBuffer);
+	    mach =  __MKSTRING(vsnBuffer);
-break;
+	    break;
 }
 numberOfCPUs = __MKUINT(sysInfo.dwNumberOfProcessors);
 %}.
 node isNil ifTrue:[
-node := self getHostName.
+	node := self getHostName.
 ].
 dom isNil ifTrue:[
-dom := self getDomainName.
+	dom := self getDomainName.
 ].
 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
 %{
 HANDLE processHandle;
 int err;
 if (__isExternalAddressLike(processHandleOrPid) ) {
-DWORD exitCode;
+	DWORD exitCode;
-processHandle = _HANDLEVal(processHandleOrPid);
+	processHandle = _HANDLEVal(processHandleOrPid);
-if (processHandle == 0) {
+	if (processHandle == 0) {
-error = @symbol(invalidParameter);
+	    error = @symbol(invalidParameter);
-} else {
+	} else {
-/* check if the handle still refers to a running process */
+	    /* check if the handle still refers to a running process */
-if (GetExitCodeProcess(processHandle, &exitCode) != 0) {
+	    if (GetExitCodeProcess(processHandle, &exitCode) != 0) {
-if (exitCode == STILL_ACTIVE) {
+		if (exitCode == STILL_ACTIVE) {
-RETURN(true);
+		    RETURN(true);
-} else {
+		} else {
-RETURN(false);
+		    RETURN(false);
-}
+		}
-} else {
+	    } else {
-goto checkError;
+		goto checkError;
-}
+	    }
 }
 } else if( __isSmallInteger(processHandleOrPid) ) {
-// assume, that synchronize needs less privilege...
+	// assume, that synchronize needs less privilege...
-processHandle = OpenProcess(SYNCHRONIZE, FALSE, __smallIntegerVal(processHandleOrPid));
+	processHandle = OpenProcess(SYNCHRONIZE, FALSE, __smallIntegerVal(processHandleOrPid));
-if (processHandle) {
+	if (processHandle) {
-CloseHandle(processHandle);
+	    CloseHandle(processHandle);
-RETURN(true);
+	    RETURN(true);
-}
+	}
 checkError:
-err = GetLastError();
+	err = GetLastError();
-// we do not have access to the process (so pid does exist ;-))
+	// we do not have access to the process (so pid does exist ;-))
-if (err == ERROR_ACCESS_DENIED) {
+	if (err == ERROR_ACCESS_DENIED) {
-RETURN(true);
+	    RETURN(true);
-}
+	}
-// pid does not exist
+	// pid does not exist
-if (err == ERROR_INVALID_PARAMETER) {
+	if (err == ERROR_INVALID_PARAMETER) {
-RETURN(false);
+	    RETURN(false);
-}
+	}
-// any other error - raise signal
+	// any other error - raise signal
-__threadErrno = __WIN32_ERR(err);
+	__threadErrno = __WIN32_ERR(err);
-error = __mkSmallInteger(__threadErrno);
+	error = __mkSmallInteger(__threadErrno);
 } else {
-error = @symbol(invalidParameter);
+	error = @symbol(invalidParameter);
 }
 %}.
 self primitiveFailed:error.
 !
 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
 osName
 |osVersion|
 osVersion := OperatingSystem osVersion.
 ^ 'Windows ',
-(#('NT' '2000' 'XP' 'VISTA' '7')
+	(#('NT' '2000' 'XP' 'VISTA' '7')
-at: (#('4.1' '5.0' '5.1' '6.0' '6.1') indexOf:osVersion)
+	    at: (#('4.1' '5.0' '5.1' '6.0' '6.1') indexOf:osVersion)
-ifAbsent:osVersion).
+	    ifAbsent:osVersion).
 "
 self osName
 "
 "Modified (comment): / 30-07-2011 / 17:00:50 / cg"
 !
 "Modified: 20.6.1997 / 17:37:26 / cg"
 !
 randomBytesInto:bufferOrInteger
 "If bufferOrInteger is a String or a ByteArray,
-fill a given buffer with random bytes from the RtlGenRandom function
+	fill a given buffer with random bytes from the RtlGenRandom function
-and nswer the buffer.
+	and nswer the buffer.
 If bufferOrInteger is a SmallInteger,
-return this many bytes (max 4) as a SmallInteger.
+	return this many bytes (max 4) as a SmallInteger.
 Return nil on error (and raise PrimitiveFailure).
 NOTE: This is a private interface, please use RandomGenerator!!"
 int __bufferSize;
 int __useLocalBuffer = 0;
 unsigned int __localBuffer = 0;
 if (__isSmallInteger(bufferOrInteger)) {
-__useLocalBuffer = 1;
+	__useLocalBuffer = 1;
-__buffer = (unsigned char *)&__localBuffer;
+	__buffer = (unsigned char *)&__localBuffer;
-__bufferSize = __smallIntegerVal(bufferOrInteger);
+	__bufferSize = __smallIntegerVal(bufferOrInteger);
-if (__bufferSize > sizeof(INT))
+	if (__bufferSize > sizeof(INT))
-__bufferSize = sizeof(INT);
+	    __bufferSize = sizeof(INT);
 } else if (__isString(bufferOrInteger)) {
-__buffer = __stringVal(bufferOrInteger);
+	__buffer = __stringVal(bufferOrInteger);
-__bufferSize = __stringSize(bufferOrInteger);
+	__bufferSize = __stringSize(bufferOrInteger);
 } else if (__isByteArray(bufferOrInteger)) {
-__buffer = __byteArrayVal(bufferOrInteger);
+	__buffer = __byteArrayVal(bufferOrInteger);
-__bufferSize = __byteArraySize(bufferOrInteger);
+	__bufferSize = __byteArraySize(bufferOrInteger);
 } else {
-goto error;
+	goto error;
 }
 if (P_RtlGenRandom == 0) {
-HINSTANCE hAdvapi32 = LoadLibrary("advapi32.dll");
+	HINSTANCE hAdvapi32 = LoadLibrary("advapi32.dll");
-// console_printf("hAdvapi32: %x\n", hAdvapi32);
+	// console_printf("hAdvapi32: %x\n", hAdvapi32);
-if (hAdvapi32) {
+	if (hAdvapi32) {
-P_RtlGenRandom = (BOOL (__stdcall *)(PVOID , ULONG))
+	    P_RtlGenRandom = (BOOL (__stdcall *)(PVOID , ULONG))
-GetProcAddress(hAdvapi32, "SystemFunction036");
+				GetProcAddress(hAdvapi32, "SystemFunction036");
-// console_printf("P_RtlGenRandom: %x\n", P_RtlGenRandom);
+	    // console_printf("P_RtlGenRandom: %x\n", P_RtlGenRandom);
-if (P_RtlGenRandom == 0) {
+	    if (P_RtlGenRandom == 0) {
-goto error;
+		goto error;
-}
+	    }
-}
+	}
 }
 if ((*P_RtlGenRandom)(__buffer, __bufferSize)) {
-if (__useLocalBuffer) {
+	if (__useLocalBuffer) {
-RETURN(__mkSmallInteger(__localBuffer & _MAX_INT));
+	    RETURN(__mkSmallInteger(__localBuffer & _MAX_INT));
-}
+	}
-RETURN (bufferOrInteger);
+	RETURN (bufferOrInteger);
 }
 error: ;
 %}.
 self primitiveFailed.
 ^ nil
 %{  /* NOCONTEXT */
 char *env;
 if (__isStringLike(aStringOrSymbol)
 && __isStringLike(newValueString) ) {
-if (SetEnvironmentVariable(__stringVal(aStringOrSymbol), __stringVal(newValueString)) != 0) {
+	if (SetEnvironmentVariable(__stringVal(aStringOrSymbol), __stringVal(newValueString)) != 0) {
-RETURN(self);
+	    RETURN(self);
-}
+	}
 }
 %}.
 self primitiveFailed
 "
 |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'
 "/            '\programme\smalltalk'
 "/            '\programme\eXept\smalltalk'
 ].
 "/ 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'
 "/        '\programme\eXept\smalltalk'
 "/        '\programs\smalltalk'
 |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.
 ! !
 !Win32OperatingSystem class methodsFor:'regional settings'!
 country
-"Answer the current system value for country."
+	"Answer the current system value for country."
 ^self queryNationalProfileString: 'iCountry' default: 0
 "
-self country
+	self country
 "
 "Modified: / 22-12-2006 / 16:45:32 / User"
 !
 countryName
-"Answer the current system value for country name."
+	"Answer the current system value for country name."
 ^self queryNationalProfileString: 'sCountry' default: 'Deutschland'
 "
-self countryName
+	self countryName
 "
 "Modified: / 22-12-2006 / 16:45:32 / User"
 !
 dateFormat
 "Answer the current system value for date format.
 Answer DfMDY = Month-Day-Year
-DfDMY = Day-Month-Year
+	    DfDMY = Day-Month-Year
-DfYMD = Year-Month-Day."
+	    DfYMD = Year-Month-Day."
 |separatorString code|
 separatorString := self dateSeparator.
 "Modified: / 22-12-2006 / 16:43:30 / User"
 "Modified: / 28-03-2011 / 17:10:01 / cg"
 !
 dateFormatCode
-"Answer the current system value for date format.
+	"Answer the current system value for date format.
-Answer DfMDY = Month-Day-Year = 0
+	 Answer DfMDY = Month-Day-Year = 0
-DfDMY = Day-Month-Year = 1
+		DfDMY = Day-Month-Year = 1
-DfYMD = Year-Month-Day = 2"
+		DfYMD = Year-Month-Day = 2"
 ^self queryNationalProfileInt: 'iDate' default: 0
 "
-self dateFormatCode
+	self dateFormatCode
 "
 "Modified: / 22-12-2006 / 16:45:53 / User"
 !
 dateSeparator
-"Answer the current system value for date separator."
+	"Answer the current system value for date separator."
 ^self queryNationalProfileString: 'sDate' default: '/'
 "
-self dateSeparator
+	self dateSeparator
 "
 "Modified: / 22-12-2006 / 16:45:32 / User"
 !
 decimalSeparator
-"Answer the current system value for decimal separator."
+	"Answer the current system value for decimal separator."
 ^self queryNationalProfileString: 'sDecimal' default: '.'
 "
-self decimalSeparator
+	self decimalSeparator
 "
 "Created: / 22-12-2006 / 16:45:11 / User"
 !
 isDateFormatDMY
-"Answer the current system value for date format.
+	"Answer the current system value for date format.
-Answer DfMDY = Month-Day-Year
+	 Answer DfMDY = Month-Day-Year
-DfDMY = Day-Month-Year
+		DfDMY = Day-Month-Year
-DfYMD = Year-Month-Day."
+		DfYMD = Year-Month-Day."
 ^self dateFormatCode = 1
 "Created: / 18-01-2007 / 14:56:23 / User"
 !
 isDateFormatMDY
-"Answer the current system value for date format.
+	"Answer the current system value for date format.
-Answer DfMDY = Month-Day-Year
+	 Answer DfMDY = Month-Day-Year
-DfDMY = Day-Month-Year
+		DfDMY = Day-Month-Year
-DfYMD = Year-Month-Day."
+		DfYMD = Year-Month-Day."
 ^self dateFormatCode = 0
 "Created: / 18-01-2007 / 14:56:07 / User"
 !
 isDateFormatYMD
-"Answer the current system value for date format.
+	"Answer the current system value for date format.
-Answer DfMDY = Month-Day-Year
+	 Answer DfMDY = Month-Day-Year
-DfDMY = Day-Month-Year
+		DfDMY = Day-Month-Year
-DfYMD = Year-Month-Day."
+		DfYMD = Year-Month-Day."
 ^self dateFormatCode = 2
 "Created: / 18-01-2007 / 14:56:30 / User"
 !
 isTimeFormat12Hour
-"Answer whether the current system time format is 12-hour."
+	"Answer whether the current system time format is 12-hour."
 ^self timeFormat = 0
 "Created: / 22-12-2006 / 16:48:17 / User"
 !
 queryNationalProfileInt: aKeyName default: defaultValue
 | answer |
 answer := self primGetProfileInt: 'Intl'
-keyName: aKeyName
+	keyName: aKeyName
-default: -1 asUnsigned32.
+	default: -1 asUnsigned32.
 ^answer = -1 asUnsigned32
-ifTrue: [ defaultValue ]
+	ifTrue: [ defaultValue ]
-ifFalse: [ answer ]
+	ifFalse: [ answer ]
 "
 self queryNationalProfileInt: 'iDate' default: 0
 "
 "Modified: / 22-12-2006 / 16:23:05 / User"
 !
 queryNationalProfileString: aKeyName default: defaultValue
-"Answer the string value of key aKeyName in
+	"Answer the string value of key aKeyName in
-the [Intl] application section of the WIN.INI profile file.
+	the [Intl] application section of the WIN.INI profile file.
-Answer defaultValue if aKeyName cannot be found."
+	Answer defaultValue if aKeyName cannot be found."
 | extString result |
 extString := String new: 80.
 result := self primGetProfileString: 'Intl'
-keyName: aKeyName
+	keyName: aKeyName
-default: ''
+	default: ''
-returnedString: extString
+	returnedString: extString
-size: extString size.
+	size: extString size.
 ^result > 0
-ifTrue: [extString copyFrom: 1 to: result]
+	ifTrue: [extString copyFrom: 1 to: result]
-ifFalse: [ defaultValue ]
+	ifFalse: [ defaultValue ]
 "Created: / 22-12-2006 / 16:13:01 / User"
 !
 thousandsSeparator
-"Answer the current system value
+	"Answer the current system value
-for the thousands separator."
+	for the thousands separator."
 ^self queryNationalProfileString: 'sThousand' default: ','
 "
-self thousandsSeparator
+	self thousandsSeparator
 "
 "Created: / 22-12-2006 / 16:46:50 / User"
 !
 timeFormat
-"Answer the current system value for time format."
+	"Answer the current system value for time format."
 ^self queryNationalProfileInt: 'iTime' default: 0
 "
-self timeFormat
+	self timeFormat
 "
 "Created: / 22-12-2006 / 16:48:27 / User"
 ! !
 openApplicationForDocument:aFilenameOrString operation:operationSymbol
 "open a windows-shell application to present the document contained in aFilenameOrString.
 This looks for the files extension, and is typically used to present help-files,
 html documents, pdf documents etc.
 operationSymbol is one of:
-open
+	open
-edit
+	edit
-explore
+	explore
-print
+	print
 "
 |result filename|
 filename := aFilenameOrString asFilename.
 result := self
-shellExecute:nil
+	shellExecute:nil
-lpOperation:operationSymbol
+	lpOperation:operationSymbol
-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 openApplicationForDocument: Filename currentDirectory operation:#open
 self openApplicationForDocument: '..\..\doc\books\ArtOfSmalltalk\artMissing186187Fix1.pdf' asFilename operation:#open
 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);
 %}
 ! !
 %{
 if (__bothSmallInteger(y, m)
 && __bothSmallInteger(d, h)
 && __bothSmallInteger(min, s)
 && __isSmallInteger(millis)) {
-SYSTEMTIME sysTime;
+	SYSTEMTIME sysTime;
-FILETIME fileTime;
+	FILETIME fileTime;
-sysTime.wHour = __intVal(h);
+	sysTime.wHour = __intVal(h);
-sysTime.wMinute = __intVal(min);
+	sysTime.wMinute = __intVal(min);
-sysTime.wSecond = __intVal(s);
+	sysTime.wSecond = __intVal(s);
-sysTime.wMilliseconds = __intVal(millis);
+	sysTime.wMilliseconds = __intVal(millis);
-sysTime.wYear = __intVal(y);
+	sysTime.wYear = __intVal(y);
-sysTime.wMonth = __intVal(m);
+	sysTime.wMonth = __intVal(m);
-sysTime.wDay = __intVal(d);
+	sysTime.wDay = __intVal(d);
-if (SystemTimeToFileTime(&sysTime, &fileTime) == 0)
+	if (SystemTimeToFileTime(&sysTime, &fileTime) == 0)
-goto error;
+	    goto error;
-RETURN(FileTimeToOsTime(&fileTime));
+	RETURN(FileTimeToOsTime(&fileTime));
 }
 error:;
 %}.
 "Error, some invalid date ot time"
 ^ TimeConversionError raiseRequest
 %{
 if (__bothSmallInteger(y, m)
 && __bothSmallInteger(d, h)
 && __bothSmallInteger(min, s)
 && __isSmallInteger(millis)) {
-SYSTEMTIME sysTime;
+	SYSTEMTIME sysTime;
-FILETIME fileTime;
+	FILETIME fileTime;
-sysTime.wHour = __intVal(h);
+	sysTime.wHour = __intVal(h);
-sysTime.wMinute = __intVal(min);
+	sysTime.wMinute = __intVal(min);
-sysTime.wSecond = __intVal(s);
+	sysTime.wSecond = __intVal(s);
-sysTime.wMilliseconds = __intVal(millis);
+	sysTime.wMilliseconds = __intVal(millis);
-sysTime.wYear = __intVal(y);
+	sysTime.wYear = __intVal(y);
-sysTime.wMonth = __intVal(m);
+	sysTime.wMonth = __intVal(m);
-sysTime.wDay = __intVal(d);
+	sysTime.wDay = __intVal(d);
 #if 0
-/* Sorry, but this function is not supported in Win2000
+	/* Sorry, but this function is not supported in Win2000
-- we use LocalFileTimeToFileTime */
+	   - we use LocalFileTimeToFileTime */
-if (TzSpecificLocalTimeToSystemTime(0, &sysTime, &sysTime) == 0)
+	if (TzSpecificLocalTimeToSystemTime(0, &sysTime, &sysTime) == 0)
-goto error;
+	    goto error;
 #endif
-if (SystemTimeToFileTime(&sysTime, &fileTime) == 0)
+	if (SystemTimeToFileTime(&sysTime, &fileTime) == 0)
-goto error;
+	    goto error;
-if (LocalFileTimeToFileTime(&fileTime, &fileTime) == 0)
+	if (LocalFileTimeToFileTime(&fileTime, &fileTime) == 0)
-goto error;
+	    goto error;
-RETURN(FileTimeToOsTime(&fileTime));
+	RETURN(FileTimeToOsTime(&fileTime));
 }
 error:;
 %}.
 "Error, some invalid date ot time"
 ^ TimeConversionError raiseRequest
 static LONGLONG divisor;
 LONGLONG tick;     // A point in time
 LONGLONG micros;
 if (! frequencyKnown) {
-// get the high resolution counter's accuracy
+	// get the high resolution counter's accuracy
-QueryPerformanceFrequency(&ticksPerSecond);
+	QueryPerformanceFrequency(&ticksPerSecond);
-frequencyKnown = 1;
+	frequencyKnown = 1;
-divisor = ticksPerSecond / (LONGLONG)1000000;
+	divisor = ticksPerSecond / (LONGLONG)1000000;
 }
 // what time is it?
 QueryPerformanceCounter(&tick);
 Since this value is wrapping around in regular intervals (approx. every 6.21 days),
 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.
 Don't use this method in application code since it is an internal (private)
 interface. For compatibility with ST-80, use Time millisecondClockValue.
 "
 DWORD retVal;
 WCHAR nm[33];
 retVal = GetTimeZoneInformation(&tzInfo);
 switch (retVal) {
-case TIME_ZONE_ID_INVALID:
+	case TIME_ZONE_ID_INVALID:
-error = __mkSmallInteger(__WIN32_ERR(GetLastError()));
+	    error = __mkSmallInteger(__WIN32_ERR(GetLastError()));
-break;
+	    break;
-case TIME_ZONE_ID_UNKNOWN:
+	case TIME_ZONE_ID_UNKNOWN:
-case TIME_ZONE_ID_STANDARD:
+	case TIME_ZONE_ID_STANDARD:
-case TIME_ZONE_ID_DAYLIGHT:
+	case TIME_ZONE_ID_DAYLIGHT:
-default:
+	default:
-bias = __mkSmallInteger(tzInfo.Bias);
+	    bias = __mkSmallInteger(tzInfo.Bias);
-memmove(nm, tzInfo.StandardName, 32*sizeof(WCHAR));
+	    memmove(nm, tzInfo.StandardName, 32*sizeof(WCHAR));
-nm[32] = 0;
+	    nm[32] = 0;
-standardName = __MKU16STRING(nm);
+	    standardName = __MKU16STRING(nm);
-standardDate_y = __mkSmallInteger(tzInfo.StandardDate.wYear);
+	    standardDate_y = __mkSmallInteger(tzInfo.StandardDate.wYear);
-standardDate_m = __mkSmallInteger(tzInfo.StandardDate.wMonth);
+	    standardDate_m = __mkSmallInteger(tzInfo.StandardDate.wMonth);
-standardDate_d = __mkSmallInteger(tzInfo.StandardDate.wDay);
+	    standardDate_d = __mkSmallInteger(tzInfo.StandardDate.wDay);
-standardDate_wd = __mkSmallInteger(tzInfo.StandardDate.wDayOfWeek);
+	    standardDate_wd = __mkSmallInteger(tzInfo.StandardDate.wDayOfWeek);
-standardDate_h = __mkSmallInteger(tzInfo.StandardDate.wHour);
+	    standardDate_h = __mkSmallInteger(tzInfo.StandardDate.wHour);
-standardDate_min = __mkSmallInteger(tzInfo.StandardDate.wMinute);
+	    standardDate_min = __mkSmallInteger(tzInfo.StandardDate.wMinute);
-standardDate_s = __mkSmallInteger(tzInfo.StandardDate.wSecond);
+	    standardDate_s = __mkSmallInteger(tzInfo.StandardDate.wSecond);
-standardBias =  __mkSmallInteger(tzInfo.StandardBias);
+	    standardBias =  __mkSmallInteger(tzInfo.StandardBias);
-memmove(nm, tzInfo.DaylightName, 32*sizeof(WCHAR));
+	    memmove(nm, tzInfo.DaylightName, 32*sizeof(WCHAR));
-nm[32] = 0;
+	    nm[32] = 0;
-daylightName = __MKU16STRING(nm);
+	    daylightName = __MKU16STRING(nm);
-daylightDate_y = __mkSmallInteger(tzInfo.DaylightDate.wYear);
+	    daylightDate_y = __mkSmallInteger(tzInfo.DaylightDate.wYear);
-daylightDate_m = __mkSmallInteger(tzInfo.DaylightDate.wMonth);
+	    daylightDate_m = __mkSmallInteger(tzInfo.DaylightDate.wMonth);
-daylightDate_d = __mkSmallInteger(tzInfo.DaylightDate.wDay);
+	    daylightDate_d = __mkSmallInteger(tzInfo.DaylightDate.wDay);
-daylightDate_wd = __mkSmallInteger(tzInfo.DaylightDate.wDayOfWeek);
+	    daylightDate_wd = __mkSmallInteger(tzInfo.DaylightDate.wDayOfWeek);
-daylightDate_h = __mkSmallInteger(tzInfo.DaylightDate.wHour);
+	    daylightDate_h = __mkSmallInteger(tzInfo.DaylightDate.wHour);
-daylightDate_min = __mkSmallInteger(tzInfo.DaylightDate.wMinute);
+	    daylightDate_min = __mkSmallInteger(tzInfo.DaylightDate.wMinute);
-daylightDate_s = __mkSmallInteger(tzInfo.DaylightDate.wSecond);
+	    daylightDate_s = __mkSmallInteger(tzInfo.DaylightDate.wSecond);
-daylightBias =  __mkSmallInteger(tzInfo.DaylightBias);
+	    daylightBias =  __mkSmallInteger(tzInfo.DaylightBias);
-break;
+	    break;
 }
 %}.
 error notNil ifTrue:[
-self primitiveFailed.
+	self primitiveFailed.
 ].
 info := AbstractOperatingSystem::TimeZoneInfo new.
 info
-bias:bias
+	bias:bias
-name:standardName standardBias:standardBias
+	name:standardName standardBias:standardBias
-daylightName:daylightName daylightBias:daylightBias.
+	daylightName:daylightName daylightBias:daylightBias.
 standardDate_m ~~ 0 ifTrue:[
-info standardYear:standardDate_y standardMonth:standardDate_m standardDay:standardDate_d
+	info standardYear:standardDate_y standardMonth:standardDate_m standardDay:standardDate_d
-standardWeekDay:standardDate_wd standardHour:standardDate_h standardMinute:standardDate_min.
+	     standardWeekDay:standardDate_wd standardHour:standardDate_h standardMinute:standardDate_min.
 ].
 daylightDate_m ~~ 0 ifTrue:[
-info daylightYear:daylightDate_y daylightMonth:daylightDate_m daylightDay:daylightDate_d
+	info daylightYear:daylightDate_y daylightMonth:daylightDate_m daylightDay:daylightDate_d
-daylightWeekDay:daylightDate_wd daylightHour:daylightDate_h daylightMinute:daylightDate_min.
+	     daylightWeekDay:daylightDate_wd daylightHour:daylightDate_h daylightMinute:daylightDate_min.
 ].
 ^ info
 "
 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);
-}
+	    }
-}
+	}
 }
 TimetToFileTime((time_t)t, &fileTime);
 if (isLocalTime == true) {
-TIME_ZONE_INFORMATION tzInfo;
+	TIME_ZONE_INFORMATION tzInfo;
-int tzState;
+	int tzState;
-LONGLONG longTime;
+	LONGLONG longTime;
-FileTimeToLocalFileTime(&fileTime, &localFileTime);
+	FileTimeToLocalFileTime(&fileTime, &localFileTime);
-FileTimeToSystemTime(&localFileTime, &sysTime);
+	FileTimeToSystemTime(&localFileTime, &sysTime);
-longTime = ((LONGLONG)fileTime.dwHighDateTime << 32) + fileTime.dwLowDateTime;
+	longTime = ((LONGLONG)fileTime.dwHighDateTime << 32) + fileTime.dwLowDateTime;
-longTime -= ((LONGLONG)localFileTime.dwHighDateTime << 32) + localFileTime.dwLowDateTime;
+	longTime -= ((LONGLONG)localFileTime.dwHighDateTime << 32) + localFileTime.dwLowDateTime;
-utcOffset = __mkSmallInteger((INT)(longTime / 10000000));
+	utcOffset = __mkSmallInteger((INT)(longTime / 10000000));
-if ((tzState = GetTimeZoneInformation(&tzInfo)) < 0) {
+	if ((tzState = GetTimeZoneInformation(&tzInfo)) < 0) {
-reason = @symbol(getTimeZoneFailed);
+	    reason = @symbol(getTimeZoneFailed);
-goto error;
+	    goto error;
-}
+	}
-dstOffset = __mkSmallInteger((tzInfo.Bias + tzInfo.DaylightBias) * 60);
+	dstOffset = __mkSmallInteger((tzInfo.Bias + tzInfo.DaylightBias) * 60);
 } else {
-FileTimeToSystemTime(&fileTime, &sysTime);
+	FileTimeToSystemTime(&fileTime, &sysTime);
-utcOffset = __mkSmallInteger(0);
+	utcOffset = __mkSmallInteger(0);
 }
 hours = __mkSmallInteger(sysTime.wHour);
 minutes = __mkSmallInteger(sysTime.wMinute);
 seconds = __mkSmallInteger(sysTime.wSecond);
 weekDay = __mkSmallInteger(sysTime.wDayOfWeek == 0 ? 7 : sysTime.wDayOfWeek);
 error:;
 %}.
 year 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:(utcOffset = dstOffset)
+	dst:(utcOffset = dstOffset)
-dayInYear:yDay
+	dayInYear:yDay
-dayInWeek:weekDay.
+	dayInWeek:weekDay.
 LastTimeInfo := info.
 LastTimeInfoSeconds := osSeconds.
 LastTimeInfoMilliseconds := osMilliseconds.
 LastTimeInfoIsLocal := isLocalTime.
 |appDataDirFromEnv appDataDirFromRegistry|
 appDataDirFromEnv := self getEnvironment:'APPDATA'.
 appDataDirFromEnv notNil ifTrue:[
-^ appDataDirFromEnv , '\' , appName
+	^ appDataDirFromEnv , '\' , appName
 ].
 appDataDirFromRegistry :=
-(self registryEntry key:'HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders')
+	(self registryEntry key:'HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders')
-valueNamed:'AppData'.
+	    valueNamed:'AppData'.
 appDataDirFromRegistry notNil ifTrue:[
-^ appDataDirFromRegistry , '\' , appName
+	^ appDataDirFromRegistry , '\' , appName
 ].
 ^ super getApplicationDataDirectoryFor:appName
 "
 OperatingSystem getApplicationDataDirectoryFor:'expecco'
 "{ Pragma: +optSpace }"
 |dir path|
 path := (self registryEntry
-key:'HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders')
+		key:'HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders')
-valueNamed:'Desktop'.
+	    valueNamed:'Desktop'.
 path isNil ifTrue:[
-"Fallback"
+	"Fallback"
-dir := self getHomeDirectory.
+	dir := self getHomeDirectory.
-dir isNil ifTrue:[ ^ nil ].
+	dir isNil ifTrue:[ ^ nil ].
-path := dir , '\Desktop'.
+	path := dir , '\Desktop'.
 ].
 (self isValidPath:path) ifFalse:[ ^ nil ].
 ^ path
 "{ Pragma: +optSpace }"
 |dir|
 dir := (self registryEntry
-key:'HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders')
+		key:'HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders')
-valueNamed:'Personal'.
+	    valueNamed:'Personal'.
 dir isNil ifTrue:[
-dir := self getHomeDirectory.
+	dir := self getHomeDirectory.
 ].
 ^ dir.
 "
 |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|
 dir := self getEnvironment:'USERPROFILE'.
 dir isNil ifTrue:[
-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
-if (t == 0) {
+	if (t == 0) {
-/* no need for WRAP-call; does not block */
+	    /* no need for WRAP-call; does not block */
-endStatus = WaitForSingleObject(__pidToWait, t);
+	    endStatus = WaitForSingleObject(__pidToWait, t);
-if (endStatus < 0) {
+	    if (endStatus < 0) {
-__threadErrno = __WIN32_ERR(GetLastError());
+		__threadErrno = __WIN32_ERR(GetLastError());
-}
+	    }
-} else {
+	} else {
-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) {
-DWORD exitCode;
+		DWORD exitCode;
-if (GetExitCodeProcess(__pidToWait, &exitCode)) {
+		if (GetExitCodeProcess(__pidToWait, &exitCode)) {
 #ifdef PROCESSDEBUG_CHILDPROCESSWAIT
-console_printf("exitCode: %d\n", exitCode);
+		    console_printf("exitCode: %d\n", exitCode);
 #endif
-if (exitCode == STILL_ACTIVE) {
+		    if (exitCode == STILL_ACTIVE) {
-RETURN(nil);
+			RETURN(nil);
-}
+		    }
 #ifdef PROCESSDEBUG_CHILDPROCESSWAIT
-console_printf("exit %d\n", exitCode);
+		    console_printf("exit %d\n", exitCode);
 #endif
-code = __mkSmallInteger(exitCode);
+		    code = __mkSmallInteger(exitCode);
-} else {
+		} else {
 #ifdef PROCESSDEBUG_CHILDPROCESSWAIT
-console_printf("GetExitCodeProcess failed\n");
+		    console_printf("GetExitCodeProcess failed\n");
 #endif
-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 ( @symbol(error) );
+			RETURN ( @symbol(error) );
-}
+		    }
-}
+		}
-}
+	    }
-}
+	}
 }
 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 ( @symbol(error) );
+			RETURN ( @symbol(error) );
-}
+		    }
-}
+		}
-}
+	    }
-}
+	}
 }
 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 ( @symbol(error) );
+		RETURN ( @symbol(error) );
-}
+	    }
-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 ( @symbol(error) );
+			    RETURN ( @symbol(error) );
-}
+			}
-}
+		    }
-}
+		}
-}
+	    }
-}
+	}
-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 ( @symbol(error) );
+			    RETURN ( @symbol(error) );
-}
+			}
-}
+		    }
-}
+		}
-}
+	    }
-}
+	}
-@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 sourcePath: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
-sourcePath:lP
+	sourcePath:lP
-fullName:fullName
+	fullName:fullName
-alternativeName:name2
+	alternativeName:name2
 ! !
 !Win32OperatingSystem::FileStatusInfo methodsFor:'accessing'!
 accessTime
 |path idx|
 path := self alternativePathName.
 path notNil ifTrue:[
-idx := path lastIndexOf:$\ startingAt:path size-1.
+	idx := path lastIndexOf:$\ startingAt:path size-1.
-idx ~~ 0 ifTrue:[
+	idx ~~ 0 ifTrue:[
-path := path copyFrom:(idx+1).
+	    path := path copyFrom:(idx+1).
-].
+	].
 ].
 ^ path
 "
-'C:\' asFilename info alternativeName
+	'C:\' asFilename info alternativeName
-'C:\Dokumente und Einstellungen\' asFilename info alternativeName
+	'C:\Dokumente und Einstellungen\' asFilename info alternativeName
-'C:\Dokumente und Einstellungen' asFilename info alternativeName
+	'C:\Dokumente und Einstellungen' asFilename info alternativeName
 "
 !
 alternativePathName
 "return the files real name (non-DOS name on windows).
 Nil if there is no other name"
 "/ access lazily...
 alternativePathName isNil ifTrue:[
-alternativePathName := (OperatingSystem getShortPathName:sourcePath) asSingleByteString.
+	alternativePathName := (OperatingSystem getShortPathName:sourcePath) asSingleByteString.
 ].
 ^ alternativePathName
 "
-'C:\' asFilename info alternativePathName
+	'C:\' asFilename info alternativePathName
-'C:\Dokumente und Einstellungen' asFilename info alternativePathName
+	'C:\Dokumente und Einstellungen' asFilename info alternativePathName
 "
 !
 creationTime
 ^ created
 |path idx|
 path := self fullPathName.
 path notNil ifTrue:[
-idx := path lastIndexOf:$\ startingAt:path size-1.
+	idx := path lastIndexOf:$\ startingAt:path size-1.
-idx ~~ 0 ifTrue:[
+	idx ~~ 0 ifTrue:[
-path := path copyFrom:(idx+1).
+	    path := path copyFrom:(idx+1).
-].
+	].
 ].
 ^ path
 "
-'\' asFilename info fullName
+	'\' asFilename info fullName
-'C:\' asFilename info fullName
+	'C:\' asFilename info fullName
-'C:\Dokumente und Einstellungen' asFilename info fullName
+	'C:\Dokumente und Einstellungen' asFilename info fullName
 "
 !
 fullPathName
 "return the files real name (non-DOS name on windows).
 Nil if there is no other name"
 "/ access lazily...
 fullPathName isNil ifTrue:[
-fullPathName := (OperatingSystem getLongPathName:sourcePath) asSingleByteStringIfPossible.
+	fullPathName := (OperatingSystem getLongPathName:sourcePath) asSingleByteStringIfPossible.
 ].
 ^ fullPathName
 "
-'C:\' asFilename info fullPathName
+	'C:\' asFilename info fullPathName
-'C:\Dokumente und Einstellungen' asFilename info fullPathName
+	'C:\Dokumente und Einstellungen' asFilename info fullPathName
 "
 !
 gid
 "return gid"
 linkTargetPath
 "for symbolic links only: return the path where the symbolic link points to"
 "/ access lazily...
 linkTargetPath isNil ifTrue:[
-type == #symbolicLink ifTrue:[
+	type == #symbolicLink ifTrue:[
-linkTargetPath := OperatingSystem getLinkTarget:sourcePath.
+	    linkTargetPath := OperatingSystem getLinkTarget:sourcePath.
-]
+	]
 ].
 ^ linkTargetPath
 "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'!
 !Win32OperatingSystem::PerformanceData class methodsFor:'accessing'!
 counterIndexTextDictionary
 "
-self counterIndexTextDictionary
+	self counterIndexTextDictionary
 "
 CounterIndexTextDictionary isNil ifTrue:[
-self synchronized:[
+	self synchronized:[
-CounterIndexTextDictionary isNil ifTrue:[
+	    CounterIndexTextDictionary isNil ifTrue:[
-|performanceText counterIndexTextDictionary|
+		|performanceText counterIndexTextDictionary|
-performanceText := self getPerformanceText valueNamed:'Counter'.
+		performanceText := self getPerformanceText valueNamed:'Counter'.
-counterIndexTextDictionary := IdentityDictionary new.
+		counterIndexTextDictionary := IdentityDictionary new.
-1 to:performanceText size by:2 do:[:index|
+		1 to:performanceText size by:2 do:[:index|
-counterIndexTextDictionary at:(performanceText at:index) asInteger put:(performanceText at:index + 1).
+		    counterIndexTextDictionary at:(performanceText at:index) asInteger put:(performanceText at:index + 1).
-].
+		].
-CounterIndexTextDictionary := counterIndexTextDictionary.
+		CounterIndexTextDictionary := counterIndexTextDictionary.
-].
+	    ].
-].
+	].
 ].
 ^ CounterIndexTextDictionary
 !
 helpIndexTextDictionary
 "
-self helpIndexTextDictionary
+	self helpIndexTextDictionary
 "
 HelpIndexTextDictionary isNil ifTrue:[
-self synchronized:[
+	self synchronized:[
-HelpIndexTextDictionary isNil ifTrue:[
+	    HelpIndexTextDictionary isNil ifTrue:[
-|performanceText helpIndexTextDictionary|
+		|performanceText helpIndexTextDictionary|
-performanceText := self getPerformanceText valueNamed:'Help'.
+		performanceText := self getPerformanceText valueNamed:'Help'.
-helpIndexTextDictionary := IdentityDictionary new.
+		helpIndexTextDictionary := IdentityDictionary new.
-1 to:performanceText size by:2 do:[:index|
+		1 to:performanceText size by:2 do:[:index|
-helpIndexTextDictionary at:(performanceText at:index) asInteger put:(performanceText at:index + 1).
+		    helpIndexTextDictionary at:(performanceText at:index) asInteger put:(performanceText at:index + 1).
-].
+		].
-HelpIndexTextDictionary := helpIndexTextDictionary.
+		HelpIndexTextDictionary := helpIndexTextDictionary.
-].
+	    ].
-].
+	].
 ].
 ^ HelpIndexTextDictionary
 ! !
 !Win32OperatingSystem::PerformanceData class methodsFor:'documentation'!
 documentation
 "
-VISTA:
+	VISTA:
-Wer versucht unter Vista die Registy HKEY_PERFORMANCE_DATA abzufragen wird zun�chst entt�uscht.
+	Wer versucht unter Vista die Registy HKEY_PERFORMANCE_DATA abzufragen wird zun�chst entt�uscht.
-Die UAC UserAccessControl verhindern dies n�mlich (selbs f�r den admin).
+	Die UAC UserAccessControl verhindern dies n�mlich (selbs f�r den admin).
-Um dies zu umgehen:
+	Um dies zu umgehen:
-To turn off UAC
+	To turn off UAC
-1. Click Start, and then click Control Panel.
+	1. Click Start, and then click Control Panel.
-2. In Control Panel, click User Accounts.
+	2. In Control Panel, click User Accounts.
-3. In the User Accounts window, click User Accounts.
+	3. In the User Accounts window, click User Accounts.
-4. In the User Accounts tasks window, click Turn User Account Control on or off.
+	4. In the User Accounts tasks window, click Turn User Account Control on or off.
-5. If UAC is currently configured in Admin Approval Mode, the User Account Control message appears. Click Continue.
+	5. If UAC is currently configured in Admin Approval Mode, the User Account Control message appears. Click Continue.
-6. Clear the Use User Account Control (UAC) to help protect your computer check box, and then click OK.
+	6. Clear the Use User Account Control (UAC) to help protect your computer check box, and then click OK.
-7. Click Restart Now to apply the change right away, or click Restart Later and close the User Accounts tasks window.
+	7. Click Restart Now to apply the change right away, or click Restart Later and close the User Accounts tasks window.
 "
 !
 examples
 "
-######################################### PRIMITIVE
+	######################################### PRIMITIVE
-self getUsedMemoryInPercentage.
+	self getUsedMemoryInPercentage.
-self getPhysicalMemoryInKB.
+	self getPhysicalMemoryInKB.
-self getPhysicalMemoryInMB.
+	self getPhysicalMemoryInMB.
-self getFreePhysicalMemoryInKB.
+	self getFreePhysicalMemoryInKB.
-self getFreePhysicalMemoryInMB.
+	self getFreePhysicalMemoryInMB.
-self getPageFileSizeInKB.
+	self getPageFileSizeInKB.
-self getPageFileSizeInMB.
+	self getPageFileSizeInMB.
-self getFreePageFileSizeInKB.
+	self getFreePageFileSizeInKB.
-self getFreePageFileSizeInMB.
+	self getFreePageFileSizeInMB.
-self getVirtualMemoryInKB.
+	self getVirtualMemoryInKB.
-self getVirtualMemoryInMB.
+	self getVirtualMemoryInMB.
-######################################### REGISTRY
+	######################################### REGISTRY
-self helpIndexTextDictionary
+	self helpIndexTextDictionary
-self counterIndexTextDictionary
+	self counterIndexTextDictionary
-self global getCounterNameIndexArray.
+	self global getCounterNameIndexArray.
-self global getObjectNameIndexArray.
+	self global getObjectNameIndexArray.
-self processor getCounterNameIndexArray.
+	self processor getCounterNameIndexArray.
-self processor processorUsage.
+	self processor processorUsage.
-self processor processorUsageFromLast.
+	self processor processorUsageFromLast.
-self processor interruptsPerSecond.
+	self processor interruptsPerSecond.
-self processor interruptsPerSecondFromLast.
+	self processor interruptsPerSecondFromLast.
-self process getCounterNameIndexArray.
+	self process getCounterNameIndexArray.
-self process processUsage.
+	self process processUsage.
-self process processUsageFromLast.
+	self process processUsageFromLast.
-self process runningProcesses.
+	self process runningProcesses.
-self process runningProcessNameList.
+	self process runningProcessNameList.
-self network getCounterNameIndexArray.
+	self network getCounterNameIndexArray.
-self network kBytesReceivedPerSecond.
+	self network kBytesReceivedPerSecond.
-self network kBytesReceivedPerSecondFromLast.
+	self network kBytesReceivedPerSecondFromLast.
-self network kBytesSentPerSecond.
+	self network kBytesSentPerSecond.
-self network kBytesSentPerSecondFromLast.
+	self network kBytesSentPerSecondFromLast.
-self memory getCounterNameIndexArray.
+	self memory getCounterNameIndexArray.
-self memory availableMBytes.
+	self memory availableMBytes.
-self memory availableKBytes.
+	self memory availableKBytes.
-self diskIO getCounterNameIndexArray.
+	self diskIO getCounterNameIndexArray.
-self diskIO diskSpaceFreeInMegaByte.
+	self diskIO diskSpaceFreeInMegaByte.
-self diskIO diskQueueLength.
+	self diskIO diskQueueLength.
-self diskIO diskTransfersPerSecond.
+	self diskIO diskTransfersPerSecond.
-self diskIO diskTransfersPerSecondFromlast.
+	self diskIO diskTransfersPerSecondFromlast.
-self diskIO diskReadsPerSecond.
+	self diskIO diskReadsPerSecond.
-self diskIO diskReadsPerSecondFromLast.
+	self diskIO diskReadsPerSecondFromLast.
-self diskIO diskWritesPerSecond.
+	self diskIO diskWritesPerSecond.
-self diskIO diskWritesPerSecondFromLast.
+	self diskIO diskWritesPerSecondFromLast.
-self diskIO diskBytesPerSecond.
+	self diskIO diskBytesPerSecond.
-self diskIO diskBytesPerSecondFromLast.
+	self diskIO diskBytesPerSecondFromLast.
 "
 ! !
 !Win32OperatingSystem::PerformanceData class methodsFor:'initialization'!
 initialize
 "
-self initialize
+	self initialize
 "
 PerformanceText := CounterIndexTextDictionary := HelpIndexTextDictionary := nil.
 ! !
 !Win32OperatingSystem::PerformanceData class methodsFor:'private'!
 getPerformanceText
 PerformanceText isNil ifTrue:[
-PerformanceText := Win32OperatingSystem registryEntry key:'HKEY_PERFORMANCE_TEXT'.
+	PerformanceText := Win32OperatingSystem registryEntry key:'HKEY_PERFORMANCE_TEXT'.
 ].
 ^ PerformanceText
 ! !
 getFreePageFileSizeInKB
 |ret|
 %{
-MEMORYSTATUS mState;
+	MEMORYSTATUS mState;
-GlobalMemoryStatus (&mState);
+	GlobalMemoryStatus (&mState);
-ret = __mkSmallInteger(mState.dwAvailPageFile / 1024);
+	ret = __mkSmallInteger(mState.dwAvailPageFile / 1024);
 %}.
 ^ ret
 "
-self getFreePageFileSizeInKB
+	self getFreePageFileSizeInKB
 "
 !
 getFreePageFileSizeInMB
 ^ (self getFreePageFileSizeInKB / 1024) asInteger
 "
-self getFreePageFileSizeInMB
+	self getFreePageFileSizeInMB
 "
 !
 getFreePhysicalMemoryInKB
 |ret|
 %{
-MEMORYSTATUS mState;
+	MEMORYSTATUS mState;
-GlobalMemoryStatus (&mState);
+	GlobalMemoryStatus (&mState);
-ret = __mkSmallInteger(mState.dwAvailPhys / 1024);
+	ret = __mkSmallInteger(mState.dwAvailPhys / 1024);
 %}.
 ^ ret
 "
-self getFreePhysicalMemoryInKB
+	self getFreePhysicalMemoryInKB
 "
 !
 getFreePhysicalMemoryInMB
 ^ (self getFreePhysicalMemoryInKB / 1024) asInteger
 "
-self getFreePhysicalMemoryInMB
+	self getFreePhysicalMemoryInMB
 "
 !
 getPageFileSizeInKB
 ^ self getPageFileSizeInMB * 1024
 "
-self getPageFileSizeInKB
+	self getPageFileSizeInKB
 "
 !
 getPageFileSizeInMB
 |ret|
 %{
-SYSTEM_INFO sInfo;
+	SYSTEM_INFO sInfo;
-GetSystemInfo(&sInfo);
+	GetSystemInfo(&sInfo);
-ret = __mkSmallInteger(sInfo.dwPageSize);
+	ret = __mkSmallInteger(sInfo.dwPageSize);
 %}.
 ^ ret
 "
-self getPageFileSizeInMB
+	self getPageFileSizeInMB
 "
 !
 getPhysicalMemoryInKB
 |ret|
 %{
-MEMORYSTATUS mState;
+	MEMORYSTATUS mState;
-GlobalMemoryStatus (&mState);
+	GlobalMemoryStatus (&mState);
-ret = __mkSmallInteger(mState.dwTotalPhys / 1024);
+	ret = __mkSmallInteger(mState.dwTotalPhys / 1024);
 %}.
 ^ ret
 "
-self getPhysicalMemoryInKB
+	self getPhysicalMemoryInKB
 "
 !
 getPhysicalMemoryInMB
 ^ (self getPhysicalMemoryInKB / 1024) asInteger
 "
-self getPhysicalMemoryInMB
+	self getPhysicalMemoryInMB
 "
 !
 getUsedMemoryInPercentage
 |ret|
 %{
-MEMORYSTATUS mState;
+	MEMORYSTATUS mState;
-GlobalMemoryStatus (&mState);
+	GlobalMemoryStatus (&mState);
-ret = __mkSmallInteger(mState.dwMemoryLoad);
+	ret = __mkSmallInteger(mState.dwMemoryLoad);
 %}.
 ^ ret
 "
-self getUsedMemoryInPercentage
+	self getUsedMemoryInPercentage
 "
 !
 getVirtualMemoryInKB
 |ret|
 %{
-MEMORYSTATUS mState;
+	MEMORYSTATUS mState;
-GlobalMemoryStatus (&mState);
+	GlobalMemoryStatus (&mState);
-ret = __mkSmallInteger(mState.dwTotalVirtual / 1024);
+	ret = __mkSmallInteger(mState.dwTotalVirtual / 1024);
 %}.
 ^ ret
 "
-self getVirtualMemoryInKB
+	self getVirtualMemoryInKB
 "
 !
 getVirtualMemoryInMB
 ^ (self getVirtualMemoryInKB / 1024) asInteger
 "
-self getVirtualMemoryInMB
+	self getVirtualMemoryInMB
 "
 ! !
 !Win32OperatingSystem::PerformanceData methodsFor:'accessing'!
 st_objectArray = __ARRAY_NEW_INT(numObjectTypes);
 perfObjectPtr = (PERF_OBJECT_TYPE *)((char *)perfData + perfData->HeaderLength);
 //iterate all following objetcs
 for (objectIterator=0; objectIterator<numObjectTypes; objectIterator++) {
-//add the st_perObject dictionary to st_objectArray
+	//add the st_perObject dictionary to st_objectArray
-st_perObject = __SSEND0(@global(Dictionary), @symbol(new), 0);
+	st_perObject = __SSEND0(@global(Dictionary), @symbol(new), 0);
-__AT_PUT_(st_objectArray, __mkSmallInteger(objectIterator+1), st_perObject);
+	__AT_PUT_(st_objectArray, __mkSmallInteger(objectIterator+1), st_perObject);
-//get the object data
+	//get the object data
-__AT_PUT_(st_perObject, @symbol(ObjectNameTitleIndex), __mkSmallInteger(perfObjectPtr->ObjectNameTitleIndex));
+	__AT_PUT_(st_perObject, @symbol(ObjectNameTitleIndex), __mkSmallInteger(perfObjectPtr->ObjectNameTitleIndex));
-__AT_PUT_(st_perObject, @symbol(DetailLevel), __mkSmallInteger(perfObjectPtr->DetailLevel));
+	__AT_PUT_(st_perObject, @symbol(DetailLevel), __mkSmallInteger(perfObjectPtr->DetailLevel));
-__AT_PUT_(st_perObject, @symbol(NumCounters), __mkSmallInteger(perfObjectPtr->NumCounters));
+	__AT_PUT_(st_perObject, @symbol(NumCounters), __mkSmallInteger(perfObjectPtr->NumCounters));
-__AT_PUT_(st_perObject, @symbol(NumInstances), __mkSmallInteger(perfObjectPtr->NumInstances));
+	__AT_PUT_(st_perObject, @symbol(NumInstances), __mkSmallInteger(perfObjectPtr->NumInstances));
-//setup counter array and initialize its pointer
+	//setup counter array and initialize its pointer
-st_counterArray = __ARRAY_NEW_INT(perfObjectPtr->NumCounters);
+	st_counterArray = __ARRAY_NEW_INT(perfObjectPtr->NumCounters);
-perfCounterPtr = (PERF_COUNTER_DEFINITION *)((char *)perfObjectPtr + perfObjectPtr->HeaderLength);
+	perfCounterPtr = (PERF_COUNTER_DEFINITION *)((char *)perfObjectPtr + perfObjectPtr->HeaderLength);
-//add the st_counterArray to st_perObject dictionary
+	//add the st_counterArray to st_perObject dictionary
-__AT_PUT_(st_perObject, @symbol(Counters), st_counterArray);
+	__AT_PUT_(st_perObject, @symbol(Counters), st_counterArray);
-//iterate all following counter definition
+	//iterate all following counter definition
-for (counterIterator=0; counterIterator<perfObjectPtr->NumCounters; counterIterator++) {
+	for (counterIterator=0; counterIterator<perfObjectPtr->NumCounters; counterIterator++) {
-//add the st_perCounter dictionary to st_counterArray
+	    //add the st_perCounter dictionary to st_counterArray
-st_perCounter = __SSEND0(@global(Dictionary), @symbol(new), 0);
+	    st_perCounter = __SSEND0(@global(Dictionary), @symbol(new), 0);
-__AT_PUT_(st_counterArray, __mkSmallInteger(counterIterator+1), st_perCounter);
+	    __AT_PUT_(st_counterArray, __mkSmallInteger(counterIterator+1), st_perCounter);
-//get the counter data
+	    //get the counter data
-__AT_PUT_(st_perCounter, @symbol(CounterNameTitleIndex), __mkSmallInteger(perfCounterPtr->CounterNameTitleIndex));
+	    __AT_PUT_(st_perCounter, @symbol(CounterNameTitleIndex), __mkSmallInteger(perfCounterPtr->CounterNameTitleIndex));
-__AT_PUT_(st_perCounter, @symbol(CounterTypeBits), __mkSmallInteger(perfCounterPtr->CounterType));
+	    __AT_PUT_(st_perCounter, @symbol(CounterTypeBits), __mkSmallInteger(perfCounterPtr->CounterType));
-__AT_PUT_(st_perCounter, @symbol(CounterSize), __mkSmallInteger(perfCounterPtr->CounterSize));
+	    __AT_PUT_(st_perCounter, @symbol(CounterSize), __mkSmallInteger(perfCounterPtr->CounterSize));
-__AT_PUT_(st_perCounter, @symbol(CounterOffset), __mkSmallInteger(perfCounterPtr->CounterOffset));
+	    __AT_PUT_(st_perCounter, @symbol(CounterOffset), __mkSmallInteger(perfCounterPtr->CounterOffset));
-//put the counter type size
+	    //put the counter type size
-switch (perfCounterPtr->CounterType & PERF_SIZE_MASK) {
+	    switch (perfCounterPtr->CounterType & PERF_SIZE_MASK) {
-case PERF_SIZE_DWORD:
+		case PERF_SIZE_DWORD:
-__AT_PUT_(st_perCounter, @symbol(SIZE),@symbol(DWORD));
+		    __AT_PUT_(st_perCounter, @symbol(SIZE),@symbol(DWORD));
-break;
+		    break;
-case PERF_SIZE_LARGE:
+		case PERF_SIZE_LARGE:
-__AT_PUT_(st_perCounter, @symbol(SIZE),@symbol(LARGE));
+		    __AT_PUT_(st_perCounter, @symbol(SIZE),@symbol(LARGE));
-break;
+		    break;
-case PERF_SIZE_ZERO:
+		case PERF_SIZE_ZERO:
-__AT_PUT_(st_perCounter, @symbol(SIZE),@symbol(ZERO));
+		    __AT_PUT_(st_perCounter, @symbol(SIZE),@symbol(ZERO));
-break;
+		    break;
-case PERF_SIZE_VARIABLE_LEN:
+		case PERF_SIZE_VARIABLE_LEN:
-__AT_PUT_(st_perCounter, @symbol(SIZE),@symbol(VARIABLE_LEN));
+		    __AT_PUT_(st_perCounter, @symbol(SIZE),@symbol(VARIABLE_LEN));
-break;
+		    break;
-}
+	    }
-switch (perfCounterPtr->CounterType & PERF_TYPE_MASK) {
+	    switch (perfCounterPtr->CounterType & PERF_TYPE_MASK) {
-case PERF_TYPE_NUMBER:
+		case PERF_TYPE_NUMBER:
-__AT_PUT_(st_perCounter, @symbol(TYPE),@symbol(NUMBER));
+		    __AT_PUT_(st_perCounter, @symbol(TYPE),@symbol(NUMBER));
-switch (perfCounterPtr->CounterType & PERF_NUMBERTYPE_MASK) {
+		    switch (perfCounterPtr->CounterType & PERF_NUMBERTYPE_MASK) {
-case PERF_NUMBER_HEX:
+			case PERF_NUMBER_HEX:
-__AT_PUT_(st_perCounter, @symbol(NUMBER),@symbol(HEX));
+			    __AT_PUT_(st_perCounter, @symbol(NUMBER),@symbol(HEX));
-break;
+			    break;
-case PERF_NUMBER_DECIMAL:
+			case PERF_NUMBER_DECIMAL:
-__AT_PUT_(st_perCounter, @symbol(NUMBER),@symbol(DECIMAL));
+			    __AT_PUT_(st_perCounter, @symbol(NUMBER),@symbol(DECIMAL));
-break;
+			    break;
-case PERF_NUMBER_DEC_1000:
+			case PERF_NUMBER_DEC_1000:
-__AT_PUT_(st_perCounter, @symbol(NUMBER),@symbol(DEC_1000));
+			    __AT_PUT_(st_perCounter, @symbol(NUMBER),@symbol(DEC_1000));
-break;
+			    break;
-}
+		    }
-break;
+		    break;
-case PERF_TYPE_COUNTER:
+		case PERF_TYPE_COUNTER:
-__AT_PUT_(st_perCounter, @symbol(TYPE),@symbol(COUNTER));
+		    __AT_PUT_(st_perCounter, @symbol(TYPE),@symbol(COUNTER));
-switch (perfCounterPtr->CounterType & PERF_COUNTERTYPE_MASK) {
+		    switch (perfCounterPtr->CounterType & PERF_COUNTERTYPE_MASK) {
-case PERF_COUNTER_VALUE:
+			case PERF_COUNTER_VALUE:
-__AT_PUT_(st_perCounter, @symbol(COUNTER),@symbol(VALUE));
+			    __AT_PUT_(st_perCounter, @symbol(COUNTER),@symbol(VALUE));
-break;
+			    break;
-case PERF_COUNTER_RATE:
+			case PERF_COUNTER_RATE:
-__AT_PUT_(st_perCounter, @symbol(COUNTER),@symbol(RATE));
+			    __AT_PUT_(st_perCounter, @symbol(COUNTER),@symbol(RATE));
-break;
+			    break;
-case PERF_COUNTER_FRACTION:
+			case PERF_COUNTER_FRACTION:
-__AT_PUT_(st_perCounter, @symbol(COUNTER),@symbol(FRACTION));
+			    __AT_PUT_(st_perCounter, @symbol(COUNTER),@symbol(FRACTION));
-break;
+			    break;
-case PERF_COUNTER_BASE:
+			case PERF_COUNTER_BASE:
-__AT_PUT_(st_perCounter, @symbol(COUNTER),@symbol(BASE));
+			    __AT_PUT_(st_perCounter, @symbol(COUNTER),@symbol(BASE));
-break;
+			    break;
-case PERF_COUNTER_ELAPSED:
+			case PERF_COUNTER_ELAPSED:
-__AT_PUT_(st_perCounter, @symbol(COUNTER),@symbol(ELAPSED));
+			    __AT_PUT_(st_perCounter, @symbol(COUNTER),@symbol(ELAPSED));
-break;
+			    break;
-case PERF_COUNTER_QUEUELEN:
+			case PERF_COUNTER_QUEUELEN:
-__AT_PUT_(st_perCounter, @symbol(COUNTER),@symbol(QUEUELEN));
+			    __AT_PUT_(st_perCounter, @symbol(COUNTER),@symbol(QUEUELEN));
-break;
+			    break;
-case PERF_COUNTER_HISTOGRAM:
+			case PERF_COUNTER_HISTOGRAM:
-__AT_PUT_(st_perCounter, @symbol(COUNTER),@symbol(HISTOGRAM));
+			    __AT_PUT_(st_perCounter, @symbol(COUNTER),@symbol(HISTOGRAM));
-break;
+			    break;
-case PERF_COUNTER_PRECISION:
+			case PERF_COUNTER_PRECISION:
-__AT_PUT_(st_perCounter, @symbol(COUNTER),@symbol(PRECISION));
+			    __AT_PUT_(st_perCounter, @symbol(COUNTER),@symbol(PRECISION));
-break;
+			    break;
-}
+		    }
-break;
+		    break;
-case PERF_TYPE_TEXT:
+		case PERF_TYPE_TEXT:
-__AT_PUT_(st_perCounter, @symbol(TYPE),@symbol(TEXT));
+		    __AT_PUT_(st_perCounter, @symbol(TYPE),@symbol(TEXT));
-switch (perfCounterPtr->CounterType & PERF_TEXTTYPE_MASK) {
+		    switch (perfCounterPtr->CounterType & PERF_TEXTTYPE_MASK) {
-case PERF_TEXT_UNICODE:
+			case PERF_TEXT_UNICODE:
-__AT_PUT_(st_perCounter, @symbol(TEXT),@symbol(UNICODE));
+			    __AT_PUT_(st_perCounter, @symbol(TEXT),@symbol(UNICODE));
-break;
+			    break;
-case PERF_TEXT_ASCII:
+			case PERF_TEXT_ASCII:
-__AT_PUT_(st_perCounter, @symbol(TEXT),@symbol(ASCII));
+			    __AT_PUT_(st_perCounter, @symbol(TEXT),@symbol(ASCII));
-break;
+			    break;
-}
+		    }
-break;
+		    break;
-case PERF_TYPE_ZERO:
+		case PERF_TYPE_ZERO:
-__AT_PUT_(st_perCounter, @symbol(TYPE),@symbol(ZERO));
+		    __AT_PUT_(st_perCounter, @symbol(TYPE),@symbol(ZERO));
-break;
+		    break;
-}
+	    }
-//setup the counter pointer to the next counter definition
+	    //setup the counter pointer to the next counter definition
-perfCounterPtr = (PERF_COUNTER_DEFINITION *)((char *)perfCounterPtr + perfCounterPtr->ByteLength);
+	    perfCounterPtr = (PERF_COUNTER_DEFINITION *)((char *)perfCounterPtr + perfCounterPtr->ByteLength);
-}
+	}
-//goon dependent on the count of instances
+	//goon dependent on the count of instances
-if (perfObjectPtr->NumInstances < 1) {
+	if (perfObjectPtr->NumInstances < 1) {
-perfCounterBlockPtr = (PERF_COUNTER_BLOCK *)(perfCounterPtr);
+	    perfCounterBlockPtr = (PERF_COUNTER_BLOCK *)(perfCounterPtr);
-__AT_PUT_(st_perObject, @symbol(RawData), __MKBYTEARRAY(perfCounterBlockPtr, perfCounterBlockPtr->ByteLength));
+	    __AT_PUT_(st_perObject, @symbol(RawData), __MKBYTEARRAY(perfCounterBlockPtr, perfCounterBlockPtr->ByteLength));
-} else {
+	} else {
-//setup the instance pointer to the end of all counters
+	    //setup the instance pointer to the end of all counters
-perfInstancePtr = (PERF_INSTANCE_DEFINITION *)(perfCounterPtr);
+	    perfInstancePtr = (PERF_INSTANCE_DEFINITION *)(perfCounterPtr);
-//setup st_instanceArray and add it to st_perObject
+	    //setup st_instanceArray and add it to st_perObject
-st_instanceArray = __ARRAY_NEW_INT(perfObjectPtr->NumInstances);
+	    st_instanceArray = __ARRAY_NEW_INT(perfObjectPtr->NumInstances);
-__AT_PUT_(st_perObject, @symbol(Instances), st_instanceArray);
+	    __AT_PUT_(st_perObject, @symbol(Instances), st_instanceArray);
-//iterate the instances
+	    //iterate the instances
-for (instanceIterator=0; instanceIterator<perfObjectPtr->NumInstances; instanceIterator++) {
+	    for (instanceIterator=0; instanceIterator<perfObjectPtr->NumInstances; instanceIterator++) {
-//setup st_perInstance and add it to st_instanceArray
+		//setup st_perInstance and add it to st_instanceArray
-st_perInstance = __SSEND0(@global(Dictionary), @symbol(new), 0);
+		st_perInstance = __SSEND0(@global(Dictionary), @symbol(new), 0);
-__AT_PUT_(st_instanceArray, __mkSmallInteger(instanceIterator+1), st_perInstance);
+		__AT_PUT_(st_instanceArray, __mkSmallInteger(instanceIterator+1), st_perInstance);
-//get the instance data
+		//get the instance data
-__AT_PUT_(st_perInstance, @symbol(Name), __MKBYTEARRAY((wchar_t *)((BYTE *)perfInstancePtr + perfInstancePtr->NameOffset),perfInstancePtr->NameLength));
+		__AT_PUT_(st_perInstance, @symbol(Name), __MKBYTEARRAY((wchar_t *)((BYTE *)perfInstancePtr + perfInstancePtr->NameOffset),perfInstancePtr->NameLength));
-__AT_PUT_(st_perInstance, @symbol(ParentObjectTitleIndex), __mkSmallInteger(perfInstancePtr->ParentObjectTitleIndex));
+		__AT_PUT_(st_perInstance, @symbol(ParentObjectTitleIndex), __mkSmallInteger(perfInstancePtr->ParentObjectTitleIndex));
-__AT_PUT_(st_perInstance, @symbol(ParentObjectInstance), __mkSmallInteger(perfInstancePtr->ParentObjectInstance));
+		__AT_PUT_(st_perInstance, @symbol(ParentObjectInstance), __mkSmallInteger(perfInstancePtr->ParentObjectInstance));
-__AT_PUT_(st_perInstance, @symbol(NameOffset), __mkSmallInteger(perfInstancePtr->NameOffset));
+		__AT_PUT_(st_perInstance, @symbol(NameOffset), __mkSmallInteger(perfInstancePtr->NameOffset));
-__AT_PUT_(st_perInstance, @symbol(NameLength), __mkSmallInteger(perfInstancePtr->NameLength));
+		__AT_PUT_(st_perInstance, @symbol(NameLength), __mkSmallInteger(perfInstancePtr->NameLength));
-//setup the instance pointer to the its end
+		//setup the instance pointer to the its end
-perfInstancePtr = (PERF_INSTANCE_DEFINITION *)((char *)perfInstancePtr + perfInstancePtr->ByteLength);
+		perfInstancePtr = (PERF_INSTANCE_DEFINITION *)((char *)perfInstancePtr + perfInstancePtr->ByteLength);
-//setup the counter block pointer
+		//setup the counter block pointer
-perfCounterBlockPtr = (PERF_COUNTER_BLOCK *)(perfInstancePtr);
+		perfCounterBlockPtr = (PERF_COUNTER_BLOCK *)(perfInstancePtr);
-//get the instance raw data
+		//get the instance raw data
-__AT_PUT_(st_perInstance, @symbol(RawData), __MKBYTEARRAY(perfCounterBlockPtr, perfCounterBlockPtr->ByteLength));
+		__AT_PUT_(st_perInstance, @symbol(RawData), __MKBYTEARRAY(perfCounterBlockPtr, perfCounterBlockPtr->ByteLength));
-//setup the instance pointer to the next instance
+		//setup the instance pointer to the next instance
-perfInstancePtr = (PERF_INSTANCE_DEFINITION *)((char *)perfCounterBlockPtr + perfCounterBlockPtr->ByteLength);
+		perfInstancePtr = (PERF_INSTANCE_DEFINITION *)((char *)perfCounterBlockPtr + perfCounterBlockPtr->ByteLength);
-}
+	    }
-}
+	}
-//setup the object pointer to the next object
+	//setup the object pointer to the next object
-perfObjectPtr = (PERF_OBJECT_TYPE *)((char *)perfObjectPtr + perfObjectPtr->TotalByteLength);
+	perfObjectPtr = (PERF_OBJECT_TYPE *)((char *)perfObjectPtr + perfObjectPtr->TotalByteLength);
 }
 %}.
 objectArray := st_objectArray.
 perfTime := st_perfTime.
 perfFreq := st_perfFreq.
 perfTime100nSec := st_perfTime100nSec.
 getNameBlock := [:i|
-self class counterIndexTextDictionary at:i ifAbsent:['<<no name>>'].
+	self class counterIndexTextDictionary at:i ifAbsent:['<<no name>>'].
 ].
 getCounterValueBlock := [:counter :rawData|
-|offset counterValue|
+	|offset counterValue|
-offset := counter at:#CounterOffset.
+	offset := counter at:#CounterOffset.
-offset >= rawData size ifTrue:[
+	offset >= rawData size ifTrue:[
-counterValue := nil.
+	    counterValue := nil.
-] ifFalse:[
+	] ifFalse:[
-(counter at:#SIZE) == #LARGE ifTrue:[
+	    (counter at:#SIZE) == #LARGE ifTrue:[
-counterValue := rawData unsignedLongLongAt:offset + 1 bigEndian:false.
+		counterValue := rawData unsignedLongLongAt:offset + 1 bigEndian:false.
-] ifFalse:[
+	    ] ifFalse:[
-(counter at:#SIZE) == #DWORD ifTrue:[
+		(counter at:#SIZE) == #DWORD ifTrue:[
-counterValue := rawData unsignedLongAt:offset + 1 bigEndian:false.
+		    counterValue := rawData unsignedLongAt:offset + 1 bigEndian:false.
-] ifFalse:[
+		] ifFalse:[
-self halt.
+		    self halt.
-].
+		].
-].
+	    ].
-].
+	].
-counterValue
+	counterValue
 ].
 objectArray do:[:anObject|
-"setup the object name"
+	"setup the object name"
-anObject at:#ObjectNameTitle put:(getNameBlock value:(anObject at:#ObjectNameTitleIndex)).
+	anObject at:#ObjectNameTitle put:(getNameBlock value:(anObject at:#ObjectNameTitleIndex)).
-"setup the name and a counter value array to each counter"
+	"setup the name and a counter value array to each counter"
-(anObject at:#Counters) do:[:aCounter|
+	(anObject at:#Counters) do:[:aCounter|
-aCounter at:#CounterNameTitle put:(getNameBlock value:(aCounter at:#CounterNameTitleIndex)).
+	    aCounter at:#CounterNameTitle put:(getNameBlock value:(aCounter at:#CounterNameTitleIndex)).
-aCounter at:#CounterValueArray put:OrderedCollection new.
+	    aCounter at:#CounterValueArray put:OrderedCollection new.
-].
+	].
-(anObject at:#NumInstances) < 1 ifTrue:[
+	(anObject at:#NumInstances) < 1 ifTrue:[
-|rawData|
+	    |rawData|
-rawData := anObject at:#RawData.
+	    rawData := anObject at:#RawData.
-(anObject at:#Counters) do:[:aCounter|
+	    (anObject at:#Counters) do:[:aCounter|
-(aCounter at:#CounterValueArray) add:(getCounterValueBlock value:aCounter value:rawData).
+		(aCounter at:#CounterValueArray) add:(getCounterValueBlock value:aCounter value:rawData).
-].
+	    ].
-] ifFalse:[
+	] ifFalse:[
-(anObject at:#Instances) do:[:anInstance|
+	    (anObject at:#Instances) do:[:anInstance|
-|rawData|
+		|rawData|
-rawData := anInstance at:#RawData.
+		rawData := anInstance at:#RawData.
-anInstance at:#Name put:((Unicode16String fromBytes:(anInstance at:#Name) copy swapBytes) copyWithoutLast:1).
+		anInstance at:#Name put:((Unicode16String fromBytes:(anInstance at:#Name) copy swapBytes) copyWithoutLast:1).
-(anObject at:#Counters) do:[:aCounter|
+		(anObject at:#Counters) do:[:aCounter|
-(aCounter at:#CounterValueArray) add:(getCounterValueBlock value:aCounter value:rawData).
+		    (aCounter at:#CounterValueArray) add:(getCounterValueBlock value:aCounter value:rawData).
-].
+		].
-].
+	    ].
-].
+	].
 ].
 ^ self
 ! !
 !Win32OperatingSystem::PerformanceData::Abstract methodsFor:'accessing'!
 cachedResults
 cachedResults isNil ifTrue:[
-cachedResults := IdentityDictionary new.
+	cachedResults := IdentityDictionary new.
 ].
 ^ cachedResults
 !
 !Win32OperatingSystem::PerformanceData::Abstract methodsFor:'definitions'!
 aliveTime
 "
-returns the time a data stays alive, in milliseconds
+	returns the time a data stays alive, in milliseconds
-before we push a new call and overwrite the data
+	before we push a new call and overwrite the data
 "
 ^ self subclassResponsibility
 !
 !Win32OperatingSystem::PerformanceData::Abstract methodsFor:'private'!
 data
 self synchronized:[
-|lastTS|
+	|lastTS|
-lastTS := self lastTimestamp.
+	lastTS := self lastTimestamp.
-lastTS isNil ifTrue:[
+	lastTS isNil ifTrue:[
-^ self dataBasic
+	    ^ self dataBasic
-] ifFalse:[
+	] ifFalse:[
-Timestamp now asMilliseconds - lastTS >= self aliveTime ifTrue:[
+	    Timestamp now asMilliseconds - lastTS >= self aliveTime ifTrue:[
-^ self dataBasic
+		^ self dataBasic
-] ifFalse:[
+	    ] ifFalse:[
-^ self lastData
+		^ self lastData
-].
+	    ].
-].
+	].
 ].
 !
 dataBasic
 |regEntry|
 |data object debugBlock|
 data := self data.
 self indexedNameNumbered == 0 ifTrue:[
-object := data objectArray at:1 ifAbsent:[debugBlock value:(object at:#ObjectNameTitle)].
+	object := data objectArray at:1 ifAbsent:[debugBlock value:(object at:#ObjectNameTitle)].
 ] ifFalse:[
-object := data objectArray detect:[:el|(el at:#ObjectNameTitleIndex) == self indexedNameNumbered] ifNone:[self error:'counter not found'].
+	object := data objectArray detect:[:el|(el at:#ObjectNameTitleIndex) == self indexedNameNumbered] ifNone:[self error:'counter not found'].
 ].
 ^ (object at:#Counters) collect:[:el|Array with:(el at:#CounterNameTitle) with:(el at:#CounterNameTitleIndex)].
 ! !
 getPerSecondFromLast:aSelector
 |cachedResult return|
 cachedResult := self cachedResults at:aSelector ifAbsent:nil.
 cachedResult notNil ifTrue:[
-|currentResult|
+	|currentResult|
-currentResult := self perform:aSelector.
+	currentResult := self perform:aSelector.
-return := self getPerSecondViaResult1:cachedResult result2:currentResult.
+	return := self getPerSecondViaResult1:cachedResult result2:currentResult.
-self cachedResults at:aSelector put:currentResult.
+	self cachedResults at:aSelector put:currentResult.
 ] ifFalse:[
-self cachedResults at:aSelector put:(self perform:aSelector).
+	self cachedResults at:aSelector put:(self perform:aSelector).
 ].
 ^ return
 !
 values2 := result2 at:#values.
 globalResult := Dictionary new.
 values2 keysDo:[:key|
-|difference|
+	|difference|
-difference := (values2 at:key) - (values1 at:key).
+	difference := (values2 at:key) - (values1 at:key).
-runTimeInS = 0 ifTrue:[
+	runTimeInS = 0 ifTrue:[
-globalResult at:key put:0.
+	    globalResult at:key put:0.
-] ifFalse:[
+	] ifFalse:[
-globalResult at:key put:(difference / runTimeInS) asFloat.
+	    globalResult at:key put:(difference / runTimeInS) asFloat.
-].
+	].
 ].
 ^ globalResult
 !
 values2 := result2 at:#values.
 globalResult := Dictionary new.
 values2 keysDo:[:key|
-|difference|
+	|difference|
-difference := (values2 at:key) - (values1 at:key).
+	difference := (values2 at:key) - (values1 at:key).
-runTimeInS = 0 ifTrue:[
+	runTimeInS = 0 ifTrue:[
-globalResult at:key put:0.
+	    globalResult at:key put:0.
-] ifFalse:[
+	] ifFalse:[
-globalResult at:key put:(difference / runTimeInS) asFloat.
+	    globalResult at:key put:(difference / runTimeInS) asFloat.
-].
+	].
 ].
 ^ globalResult
 !
 getUsageFromLast:aSelector
 |cachedResult return|
 cachedResult := self cachedResults at:aSelector ifAbsent:nil.
 cachedResult notNil ifTrue:[
-|currentResult|
+	|currentResult|
-currentResult := self perform:aSelector.
+	currentResult := self perform:aSelector.
-return := self getUsageViaResult1:cachedResult result2:currentResult.
+	return := self getUsageViaResult1:cachedResult result2:currentResult.
-self cachedResults at:aSelector put:currentResult.
+	self cachedResults at:aSelector put:currentResult.
 ] ifFalse:[
-self cachedResults at:aSelector put:(self perform:aSelector).
+	self cachedResults at:aSelector put:(self perform:aSelector).
 ].
 ^ return
 !
 value1 := result1 at:#values.
 value2 := result2 at:#values.
 value1 keysDo:[:key|
-|diff dPerSecond load1024 res|
+	|diff dPerSecond load1024 res|
-diff := (value2 at:key) - (value1 at:key).
+	diff := (value2 at:key) - (value1 at:key).
-diff := diff bitShift:10.
+	diff := diff bitShift:10.
-deltaTIn100Ns = 0 ifTrue:[
+	deltaTIn100Ns = 0 ifTrue:[
-dPerSecond := 0.
+	    dPerSecond := 0.
-] ifFalse:[
+	] ifFalse:[
-dPerSecond := (diff / deltaTIn100Ns) asFloat.
+	    dPerSecond := (diff / deltaTIn100Ns) asFloat.
-].
+	].
-load1024 := 1024 - dPerSecond.
+	load1024 := 1024 - dPerSecond.
-res := (load1024 / 1024 * 100) asFloat.
+	res := (load1024 / 1024 * 100) asFloat.
-res < 0 ifTrue:[res := 0].
+	res < 0 ifTrue:[res := 0].
-globalResult at:key put:res.
+	globalResult at:key put:res.
 ].
 ^ globalResult
 !
 value1 := result1 at:#values.
 value2 := result2 at:#values.
 value1 keysDo:[:key|
-|diff dPerSecond load1024 res|
+	|diff dPerSecond load1024 res|
-diff := (value2 at:key) - (value1 at:key).
+	diff := (value2 at:key) - (value1 at:key).
-diff := diff bitShift:10.
+	diff := diff bitShift:10.
-deltaTIn100Ns = 0 ifTrue:[
+	deltaTIn100Ns = 0 ifTrue:[
-dPerSecond := 0.
+	    dPerSecond := 0.
-] ifFalse:[
+	] ifFalse:[
-dPerSecond := (diff / deltaTIn100Ns) asFloat.
+	    dPerSecond := (diff / deltaTIn100Ns) asFloat.
-].
+	].
-load1024 := 1024 - dPerSecond.
+	load1024 := 1024 - dPerSecond.
-res := (load1024 / 1024 * 100) asFloat.
+	res := (load1024 / 1024 * 100) asFloat.
-res < 0 ifTrue:[res := 0].
+	res < 0 ifTrue:[res := 0].
-globalResult at:key put:res.
+	globalResult at:key put:res.
 ].
 ^ globalResult
 ! !
 getBasicValuesByObject:objectIndex counter:counterIndex timed:boolean
 |data object counter values debugBlock numInstances|
 debugBlock := [:obj|
-^ 'obj:', obj , ' this:', self printString , ' idx:', self indexedName
+	^ 'obj:', obj , ' this:', self printString , ' idx:', self indexedName
 ].
 data := self dataBasic.
 objectIndex == 0 ifTrue:[
-object := data objectArray at:1 ifAbsent:[debugBlock value:(object at:#ObjectNameTitle)].
+	object := data objectArray at:1 ifAbsent:[debugBlock value:(object at:#ObjectNameTitle)].
 ] ifFalse:[
-object := data objectArray detect:[:el|(el at:#ObjectNameTitleIndex) == objectIndex] ifNone:[debugBlock value:(object at:#ObjectNameTitle)].
+	object := data objectArray detect:[:el|(el at:#ObjectNameTitleIndex) == objectIndex] ifNone:[debugBlock value:(object at:#ObjectNameTitle)].
 ].
 counter := (object at:#Counters) detect:[:aCounter|(aCounter at:#CounterNameTitleIndex) == counterIndex] ifNone:[debugBlock value:(object at:#ObjectNameTitle)].
 values := Dictionary new.
 numInstances := object at:#NumInstances.
 numInstances > 0 ifTrue:[
-1 to:numInstances do:[:idx|
+	1 to:numInstances do:[:idx|
-|value instanceName|
+	    |value instanceName|
-value := (counter at:#CounterValueArray) at:idx.
+	    value := (counter at:#CounterValueArray) at:idx.
-instanceName := ((object at:#Instances) at:idx) at:#Name.
+	    instanceName := ((object at:#Instances) at:idx) at:#Name.
-values at:instanceName put:value.
+	    values at:instanceName put:value.
-].
+	].
 ] ifFalse:[
-values at:'<<singleton>>' put:(counter at:#CounterValueArray) first.
+	values at:'<<singleton>>' put:(counter at:#CounterValueArray) first.
 ].
 boolean ifTrue:[
-|return|
+	|return|
-return := IdentityDictionary new.
+	return := IdentityDictionary new.
-return at:#time put:data perfTime.
+	return at:#time put:data perfTime.
-return at:#frequence put:data perfFreq.
+	return at:#frequence put:data perfFreq.
-return at:#time100nSec put:data perfTime100nSec.
+	return at:#time100nSec put:data perfTime100nSec.
-return at:#values put:values.
+	return at:#values put:values.
-^ return
+	^ return
 ].
 ^ values
 !
 getValuesByObject:objectIndex counter:counterIndex timed:boolean
 |data object counter values debugBlock numInstances|
 debugBlock := [:obj|
-^ 'obj:', obj , ' this:', self printString , ' idx:', self indexedName
+	^ 'obj:', obj , ' this:', self printString , ' idx:', self indexedName
 ].
 data := self data.
 objectIndex == 0 ifTrue:[
-object := data objectArray at:1 ifAbsent:[debugBlock value:(object at:#ObjectNameTitle)].
+	object := data objectArray at:1 ifAbsent:[debugBlock value:(object at:#ObjectNameTitle)].
 ] ifFalse:[
-object := data objectArray detect:[:el|(el at:#ObjectNameTitleIndex) == objectIndex] ifNone:[debugBlock value:(object at:#ObjectNameTitle)].
+	object := data objectArray detect:[:el|(el at:#ObjectNameTitleIndex) == objectIndex] ifNone:[debugBlock value:(object at:#ObjectNameTitle)].
 ].
 counter := (object at:#Counters) detect:[:aCounter|(aCounter at:#CounterNameTitleIndex) == counterIndex] ifNone:[debugBlock value:(object at:#ObjectNameTitle)].
 values := Dictionary new.
 numInstances := object at:#NumInstances.
 numInstances > 0 ifTrue:[
-1 to:numInstances do:[:idx|
+	1 to:numInstances do:[:idx|
-|value instanceName|
+	    |value instanceName|
-value := (counter at:#CounterValueArray) at:idx.
+	    value := (counter at:#CounterValueArray) at:idx.
-instanceName := ((object at:#Instances) at:idx) at:#Name.
+	    instanceName := ((object at:#Instances) at:idx) at:#Name.
-values at:instanceName put:value.
+	    values at:instanceName put:value.
-].
+	].
 ] ifFalse:[
-values at:'<<singleton>>' put:(counter at:#CounterValueArray) first.
+	values at:'<<singleton>>' put:(counter at:#CounterValueArray) first.
 ].
 boolean ifTrue:[
-|return|
+	|return|
-return := IdentityDictionary new.
+	return := IdentityDictionary new.
-return at:#time put:data perfTime.
+	return at:#time put:data perfTime.
-return at:#frequence put:data perfFreq.
+	return at:#frequence put:data perfFreq.
-return at:#time100nSec put:data perfTime100nSec.
+	return at:#time100nSec put:data perfTime100nSec.
-return at:#values put:values.
+	return at:#values put:values.
-^ return
+	^ return
 ].
 ^ values
 ! !
 !Win32OperatingSystem::PerformanceData::DiskIO class methodsFor:'accessing'!
 current
 TheOneAndOnlyInstance isNil ifTrue:[
-TheOneAndOnlyInstance := self new.
+	TheOneAndOnlyInstance := self new.
 ].
 ^ TheOneAndOnlyInstance
 ! !
 diskBytes
 ^ self getValuesByCounter:218 timed:true
 "
-self current diskBytes
+	self current diskBytes
 "
 !
 diskBytesBasic
 ^ self getBasicValuesByCounter:218 timed:true
 "
-self current diskBytesBasic
+	self current diskBytesBasic
 "
 !
 diskBytesPerSecond
 ^ self getPerSecondViaPerformBlock:[self diskBytes]
 "
-self current diskBytesPerSecond
+	self current diskBytesPerSecond
 "
 !
 diskBytesPerSecondFromLast
 ^ self getPerSecondFromLast:#diskBytesBasic
 "
-self current diskBytesPerSecondFromLast
+	self current diskBytesPerSecondFromLast
 "
 !
 diskQueueLength
 ^ self getValuesByCounter:198
 "
-self current diskQueueLength
+	self current diskQueueLength
 "
 !
 diskRead
 ^ self getValuesByCounter:214 timed:true
 "
-self current diskRead
+	self current diskRead
 "
 !
 diskReadBasic
 ^ self getBasicValuesByCounter:214 timed:true
 "
-self current diskReadBasic
+	self current diskReadBasic
 "
 !
 diskReadsPerSecond
 ^ self getPerSecondViaPerformBlock:[self diskRead]
 "
-self current diskReadsPerSecond
+	self current diskReadsPerSecond
 "
 !
 diskReadsPerSecondFromLast
 ^ self getPerSecondFromLast:#diskReadBasic
 "
-self current diskReadsPerSecondFromLast
+	self current diskReadsPerSecondFromLast
 "
 !
 diskSpaceFreeInMegaByte
 ^ self getValuesByCounter:408
 "
-self current diskSpaceFreeInMegaByte
+	self current diskSpaceFreeInMegaByte
 "
 !
 diskTransfers
 ^ self getValuesByCounter:212 timed:true
 "
-self current diskTransfers
+	self current diskTransfers
 "
 !
 diskTransfersBasic
 ^ self getBasicValuesByCounter:212 timed:true
 "
-self current diskTransfersBasic
+	self current diskTransfersBasic
 "
 !
 diskTransfersPerSecond
 ^ self getPerSecondViaPerformBlock:[self diskTransfers]
 "
-self current diskTransfersPerSecond
+	self current diskTransfersPerSecond
 "
 !
 diskTransfersPerSecondFromLast
 ^ self getPerSecondFromLast:#diskTransfersBasic
 "
-self current diskTransfersPerSecondFromlast
+	self current diskTransfersPerSecondFromlast
 "
 !
 diskWrite
 ^ self getValuesByCounter:216 timed:true
 "
-self current diskWrite
+	self current diskWrite
 "
 !
 diskWriteBasic
 ^ self getBasicValuesByCounter:216 timed:true
 "
-self current diskWriteBasic
+	self current diskWriteBasic
 "
 !
 diskWritesPerSecond
 ^ self getPerSecondViaPerformBlock:[self diskWrite]
 "
-self current diskWritesPerSecond
+	self current diskWritesPerSecond
 "
 !
 diskWritesPerSecondFromLast
 ^ self getPerSecondFromLast:#diskWriteBasic
 "
-self current diskWritesPerSecondFromLast
+	self current diskWritesPerSecondFromLast
 "
 ! !
 !Win32OperatingSystem::PerformanceData::Global class methodsFor:'accessing'!
 current
 TheOneAndOnlyInstance isNil ifTrue:[
-TheOneAndOnlyInstance := self new.
+	TheOneAndOnlyInstance := self new.
 ].
 ^ TheOneAndOnlyInstance
 ! !
 data := self data.
 indexNameArray := OrderedCollection new.
 data objectArray do:[:anObject|
-|index name|
+	|index name|
-index := anObject at:#ObjectNameTitleIndex.
+	index := anObject at:#ObjectNameTitleIndex.
-name := Win32OperatingSystem::PerformanceData counterIndexTextDictionary at:index.
+	name := Win32OperatingSystem::PerformanceData counterIndexTextDictionary at:index.
-indexNameArray add:(Array with:name with:index).
+	indexNameArray add:(Array with:name with:index).
 ].
 ^ indexNameArray
 ! !
 !Win32OperatingSystem::PerformanceData::Memory class methodsFor:'accessing'!
 current
 TheOneAndOnlyInstance isNil ifTrue:[
-TheOneAndOnlyInstance := self new.
+	TheOneAndOnlyInstance := self new.
 ].
 ^ TheOneAndOnlyInstance
 ! !
 availableKBytes
 ^ self getValuesByCounter:1380
 "
-self current availableKBytes
+	self current availableKBytes
 "
 !
 availableMBytes
 ^ self getValuesByCounter:1382
 "
-self current availableMBytes
+	self current availableMBytes
 "
 ! !
 !Win32OperatingSystem::PerformanceData::Network class methodsFor:'accessing'!
 current
 TheOneAndOnlyInstance isNil ifTrue:[
-TheOneAndOnlyInstance := self new.
+	TheOneAndOnlyInstance := self new.
 ].
 ^ TheOneAndOnlyInstance
 ! !
 bytesReceived
 ^ self getValuesByCounter:264 timed:true
 "
-self current bytesReceived
+	self current bytesReceived
 "
 !
 bytesReceivedBasic
 ^ self getBasicValuesByCounter:264 timed:true
 "
-self current bytesReceivedBasic
+	self current bytesReceivedBasic
 "
 !
 bytesReceivedPerSecond
 ^ self getPerSecondViaPerformBlock:[self bytesReceived]
 "
-self current bytesReceivedPerSecond
+	self current bytesReceivedPerSecond
 "
 !
 bytesReceivedPerSecondFromlast
 ^ self getPerSecondFromLast:#bytesReceivedBasic
 "
-self current bytesReceivedPerSecondFromlast
+	self current bytesReceivedPerSecondFromlast
 "
 !
 bytesSent
 ^ self getValuesByCounter:506 timed:true
 "
-self current bytesSent
+	self current bytesSent
 "
 !
 bytesSentBasic
 ^ self getBasicValuesByCounter:506 timed:true
 "
-self current bytesSentBasic
+	self current bytesSentBasic
 "
 !
 bytesSentPerSecond
 ^ self getPerSecondViaPerformBlock:[self bytesSent]
 "
-self current bytesSentPerSecond
+	self current bytesSentPerSecond
 "
 !
 bytesSentPerSecondFromlast
 ^ self getPerSecondFromLast:#bytesSentBasic
 "
-self current bytesSentPerSecondFromlast
+	self current bytesSentPerSecondFromlast
 "
 !
 kBytesReceivedPerSecond
 |modifiedDictionary|
 modifiedDictionary := Dictionary new.
 (self getPerSecondViaPerformBlock:[self bytesReceived]) keysAndValuesDo:[:key :value|
-modifiedDictionary at:key put:(value / 1024).
+	modifiedDictionary at:key put:(value / 1024).
 ].
 ^ modifiedDictionary
 "
-self current kBytesReceivedPerSecond
+	self current kBytesReceivedPerSecond
 "
 !
 kBytesReceivedPerSecondFromLast
 |return modifiedDictionary|
 return isNil ifTrue:[^ nil].
 modifiedDictionary := Dictionary new.
 return keysAndValuesDo:[:key :value|
-modifiedDictionary at:key put:(value / 1024).
+	modifiedDictionary at:key put:(value / 1024).
 ].
 ^ modifiedDictionary
 "
-self current kBytesReceivedPerSecondFromLast
+	self current kBytesReceivedPerSecondFromLast
 "
 !
 kBytesSentPerSecond
 |modifiedDictionary|
 modifiedDictionary := Dictionary new.
 (self getPerSecondViaPerformBlock:[self bytesSent]) keysAndValuesDo:[:key :value|
-modifiedDictionary at:key put:(value / 1024).
+	modifiedDictionary at:key put:(value / 1024).
 ].
 ^ modifiedDictionary
 "
-self current kBytesSentPerSecond
+	self current kBytesSentPerSecond
 "
 !
 kBytesSentPerSecondFromLast
 |return modifiedDictionary|
 return isNil ifTrue:[^ nil].
 modifiedDictionary := Dictionary new.
 return keysAndValuesDo:[:key :value|
-modifiedDictionary at:key put:(value / 1024).
+	modifiedDictionary at:key put:(value / 1024).
 ].
 ^ modifiedDictionary
 "
-self current kBytesSentPerSecondFromLast
+	self current kBytesSentPerSecondFromLast
 "
 ! !
 !Win32OperatingSystem::PerformanceData::Process class methodsFor:'accessing'!
 current
 TheOneAndOnlyInstance isNil ifTrue:[
-TheOneAndOnlyInstance := self new.
+	TheOneAndOnlyInstance := self new.
 ].
 ^ TheOneAndOnlyInstance
 ! !
 processTime
 ^ self getValuesByCounter:6 timed:true
 "
-self current processTime
+	self current processTime
 "
 !
 processTimeBasic
 ^ self getBasicValuesByCounter:6 timed:true
 "
-self current processTimeBasic
+	self current processTimeBasic
 "
 !
 processUsage
 |modifiedDictionary|
 modifiedDictionary := Dictionary new.
 (self getUsageViaPerformBlock:[self processTime]) keysAndValuesDo:[:key :value|
-modifiedDictionary at:key put:(100 - value).
+	modifiedDictionary at:key put:(100 - value).
 ].
 ^ modifiedDictionary
 "
-self current processUsage
+	self current processUsage
 "
 !
 processUsageFromLast
 |return modifiedDictionary|
 return isNil ifTrue:[^ nil].
 modifiedDictionary := Dictionary new.
 return keysAndValuesDo:[:key :value|
-modifiedDictionary at:key put:(100 - value).
+	modifiedDictionary at:key put:(100 - value).
 ].
 ^ modifiedDictionary
 "
-self current processUsageFromLast
+	self current processUsageFromLast
 "
 !
 runningProcessNameList
 "_Total ~ pseudo process; Idle ~ pseudo process represents the free resources"
 ^ (self data objectArray first at:#Instances) collect:[:el|el at:#Name]
 "
-self current runningProcessNameList
+	self current runningProcessNameList
 "
 !
 runningProcesses
 "_Total ~ pseudo process; Idle ~ pseudo process represents the free resources"
 ^ (self data objectArray first at:#NumInstances)
 "
-self current runningProcesses
+	self current runningProcesses
 "
 ! !
 !Win32OperatingSystem::PerformanceData::Processor class methodsFor:'accessing'!
 current
 TheOneAndOnlyInstance isNil ifTrue:[
-TheOneAndOnlyInstance := self new.
+	TheOneAndOnlyInstance := self new.
 ].
 ^ TheOneAndOnlyInstance
 ! !
 interrupts
 ^ self getValuesByCounter:148 timed:true
 "
-self current interrupts
+	self current interrupts
 "
 !
 interruptsBasic
 ^ self getBasicValuesByCounter:148 timed:true
 "
-self current interruptsBasic
+	self current interruptsBasic
 "
 !
 interruptsPerSecond
 ^ self getPerSecondViaPerformBlock:[self interrupts]
 "
-self current interruptsPerSecond
+	self current interruptsPerSecond
 "
 !
 interruptsPerSecondFromLast
 ^ self getPerSecondFromLast:#interruptsBasic
 "
-self current interruptsPerSecondFromLast
+	self current interruptsPerSecondFromLast
 "
 !
 processorTime
 ^ self getValuesByCounter:6 timed:true
 "
-self current processorTime
+	self current processorTime
 "
 !
 processorTimeBasic
 ^ self getBasicValuesByCounter:6 timed:true
 "
-self current processorTimeBasic
+	self current processorTimeBasic
 "
 !
 processorUsage
 ^ self getUsageViaPerformBlock:[self processorTime]
 "
-self current processorUsage
+	self current processorUsage
 "
 !
 processorUsageFromLast
 ^ self getUsageFromLast:#processorTimeBasic
 "
-self current processorUsageFromLast
+	self current processorUsageFromLast
 "
 ! !
 !Win32OperatingSystem::PrinterInfo2Structure methodsFor:'accessing'!
 defaultPriority
 |defaultPriority|
 Error handle:[:ex |
-Transcript showCR: 'PrinterInfo2 error getting defaultPriority - ', ex description.
+	Transcript showCR: 'PrinterInfo2 error getting defaultPriority - ', ex description.
-defaultPriority := 0.
+	defaultPriority := 0.
 ] do:[
-defaultPriority := self unsignedLongAt:(60 + 1)
+	defaultPriority := self unsignedLongAt:(60 + 1)
 ].
 ^ defaultPriority
 "Created: / 01-08-2006 / 12:46:50 / fm"
 "Modified: / 16-04-2007 / 13:08:33 / cg"
 pComment
 |pComment|
 Error handle:[:ex |
-Transcript showCR: 'PrinterInfo2 error getting pComment - ', ex description.
+	Transcript showCR: 'PrinterInfo2 error getting pComment - ', ex description.
-pComment := 0.
+	pComment := 0.
 ] do:[
-pComment := self unsignedLongAt:(20 + 1).
+	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"
 !
 pDriverName
 |pName|
 Error handle:[:ex |
-Transcript showCR: 'PrinterInfo2 error getting pDriverName - ', ex description.
+	Transcript showCR: 'PrinterInfo2 error getting pDriverName - ', ex description.
-pName := 0.
+	pName := 0.
 ] do:[
-pName := self unsignedLongAt:(16 + 1).
+	pName := self unsignedLongAt:(16 + 1).
 ].
 pName == 0 ifTrue:[^ ''].
 ^ (ExternalBytes address:pName) stringAt:1
 "Created: / 01-08-2006 / 14:05:18 / fm"
 pLocation
 |pLocation externalBytes|
 Error handle:[:ex |
-Transcript showCR: 'PrinterInfo2 error getting pLocation - ', ex description.
+	Transcript showCR: 'PrinterInfo2 error getting pLocation - ', ex description.
-pLocation := 0.
+	pLocation := 0.
 ] do:[
-pLocation := self unsignedLongAt:(24 + 1).
+	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"
 !
 priority
 |priority|
 Error handle:[:ex |
-Transcript showCR: 'PrinterInfo2 error getting priority - ', ex description.
+	Transcript showCR: 'PrinterInfo2 error getting priority - ', ex description.
-priority := 0.
+	priority := 0.
 ] do:[
-priority := self unsignedLongAt: 56 + 1
+	priority := self unsignedLongAt: 56 + 1
 ].
 ^ priority
 "Created: / 01-08-2006 / 14:40:08 / fm"
 "Modified: / 16-04-2007 / 13:09:02 / cg"
 status
 |status|
 Error handle:[:ex |
-Transcript showCR: 'PrinterInfo2 error getting status - ', ex description.
+	Transcript showCR: 'PrinterInfo2 error getting status - ', ex description.
-status := -1.
+	status := -1.
 ] do:[
-status := self unsignedLongAt: 72 + 1
+	status := self unsignedLongAt: 72 + 1
 ].
 ^ status
 "Created: / 31-07-2006 / 11:08:05 / fm"
 "Modified: / 16-04-2007 / 13:08:59 / 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]
 "
 ! !
 (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.
 ].
 specialKeyStringOrSymbol = #'HKEY_PERFORMANCE_TEXT' ifTrue:[
-^ HKEY_PERFORMANCE_TEXT.
+	^ HKEY_PERFORMANCE_TEXT.
 ].
 specialKeyStringOrSymbol = #'HKEY_PERFORMANCE_NLSTEXT' ifTrue:[
-^ HKEY_PERFORMANCE_NLSTEXT.
+	^ HKEY_PERFORMANCE_NLSTEXT.
 ].
 ^ 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
 ].
 Error handle:[:ex |
-^ nil
+	^ nil
 ] do:[
-^ root subKeyNamed:rest createIfAbsent:createIfAbsent.
+	^ root subKeyNamed:rest createIfAbsent:createIfAbsent.
 ].
 "
 self key:'HKEY_LOCAL_MACHINE'
 self key:'HKEY_LOCAL_MACHINE\Software'
 |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;
 int _retVal;
 if (__isExternalAddressLike(__INST(handle))
 && __isStringLike(subKeyString)) {
-myKey = (HKEY)__externalAddressVal(__INST(handle));
+	myKey = (HKEY)__externalAddressVal(__INST(handle));
-if ((_retVal = RegCreateKey(myKey, __stringVal(subKeyString), &subKey)) == ERROR_SUCCESS) {
+	if ((_retVal = RegCreateKey(myKey, __stringVal(subKeyString), &subKey)) == ERROR_SUCCESS) {
-subHandle = __MKEXTERNALADDRESS(subKey);
+	    subHandle = __MKEXTERNALADDRESS(subKey);
-} else {
+	} else {
-if ((_retVal != ERROR_PATH_NOT_FOUND)
+	    if ((_retVal != ERROR_PATH_NOT_FOUND)
-&& (_retVal != ERROR_FILE_NOT_FOUND)) {
+	     && (_retVal != ERROR_FILE_NOT_FOUND)) {
-errorNumber = __MKSMALLINT(_retVal);
+		errorNumber = __MKSMALLINT(_retVal);
-}
+	    }
-}
+	}
 }
 %}.
 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.
 ].
 errorNumber notNil ifTrue:[
-(OperatingSystem errorHolderForNumber:errorNumber) reportError.
+	(OperatingSystem errorHolderForNumber:errorNumber) reportError.
 ].
 ^ nil
 "
 |top sub|
 HKEY myKey;
 int _retVal;
 if (__isExternalAddressLike(__INST(handle))
 && __isStringLike(subKeyString)) {
-myKey = (HKEY)__externalAddressVal(__INST(handle));
+	myKey = (HKEY)__externalAddressVal(__INST(handle));
-if ((_retVal = RegDeleteKey(myKey, __stringVal(subKeyString))) == ERROR_SUCCESS) {
+	if ((_retVal = RegDeleteKey(myKey, __stringVal(subKeyString))) == ERROR_SUCCESS) {
-RETURN (true);
+	    RETURN (true);
-}
+	}
-if ((_retVal != ERROR_PATH_NOT_FOUND)
+	if ((_retVal != ERROR_PATH_NOT_FOUND)
-&& (_retVal != ERROR_FILE_NOT_FOUND)) {
+	 && (_retVal != ERROR_FILE_NOT_FOUND)) {
-errorNumber = __MKSMALLINT(_retVal);
+	    errorNumber = __MKSMALLINT(_retVal);
-}
+	}
 }
 %}.
 errorNumber notNil ifTrue:[
-(OperatingSystem errorHolderForNumber:errorNumber) reportError.
+	(OperatingSystem errorHolderForNumber:errorNumber) reportError.
 ].
 ^ false
 "
 |top sub|
 %{
 HKEY myKey, remoteKey = 0;
 int _retVal;
 if (__isExternalAddressLike(__INST(handle)) && __isStringLike(hostName)) {
-myKey = (HKEY)__externalAddressVal(__INST(handle));
+	myKey = (HKEY)__externalAddressVal(__INST(handle));
-if ((_retVal = RegConnectRegistryA(__stringVal(hostName), myKey, &remoteKey)) == ERROR_SUCCESS) {
+	if ((_retVal = RegConnectRegistryA(__stringVal(hostName), myKey, &remoteKey)) == ERROR_SUCCESS) {
-remoteHandle = __MKEXTERNALADDRESS(remoteKey);
+	    remoteHandle = __MKEXTERNALADDRESS(remoteKey);
-} else {
+	} else {
-if ((_retVal != ERROR_PATH_NOT_FOUND)
+	    if ((_retVal != ERROR_PATH_NOT_FOUND)
-&& (_retVal != ERROR_FILE_NOT_FOUND)) {
+	     && (_retVal != ERROR_FILE_NOT_FOUND)) {
-errorNumber = __MKSMALLINT(_retVal);
+		errorNumber = __MKSMALLINT(_retVal);
-}
+	    }
-}
+	}
 }
 %}.
 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.
 ].
 errorNumber notNil ifTrue:[
-(OperatingSystem errorHolderForNumber:errorNumber) reportError.
+	(OperatingSystem errorHolderForNumber:errorNumber) reportError.
 ].
 ^ nil
 "
 |top remote|
 FILETIME modificationTime;
 int _retVal;
 if (__isExternalAddressLike(__INST(handle))
 && __isSmallInteger(subKeyIndex)) {
-myKey = (HKEY)__externalAddressVal(__INST(handle));
+	myKey = (HKEY)__externalAddressVal(__INST(handle));
-if ((_retVal = RegEnumKeyExA(myKey, __intVal(subKeyIndex),
+	if ((_retVal = RegEnumKeyExA(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 {
-if ((_retVal != ERROR_PATH_NOT_FOUND)
+	    if ((_retVal != ERROR_PATH_NOT_FOUND)
-&& (_retVal != ERROR_FILE_NOT_FOUND)
+	     && (_retVal != ERROR_FILE_NOT_FOUND)
-&& (_retVal != ERROR_NO_MORE_ITEMS)) {
+	     && (_retVal != ERROR_NO_MORE_ITEMS)) {
-errorNumber = __MKSMALLINT(_retVal);
+		errorNumber = __MKSMALLINT(_retVal);
-}
+	    }
-}
+	}
 }
 %}.
 subKeyName notNil ifTrue:[
-^ self subKeyNamed:subKeyName.
+	^ self subKeyNamed:subKeyName.
 ].
 errorNumber notNil ifTrue:[
-(OperatingSystem errorHolderForNumber:errorNumber) reportError.
+	(OperatingSystem errorHolderForNumber:errorNumber) reportError.
 ].
 ^ nil
 "
 |top sub|
 HKEY myKey, subKey = 0;
 int _retVal;
 if (__isExternalAddressLike(__INST(handle))
 && __isStringLike(subKeyString)) {
-myKey = (HKEY)__externalAddressVal(__INST(handle));
+	myKey = (HKEY)__externalAddressVal(__INST(handle));
-_retVal = RegOpenKey(myKey, __stringVal(subKeyString), &subKey);
+	_retVal = RegOpenKey(myKey, __stringVal(subKeyString), &subKey);
-if (_retVal == ERROR_SUCCESS) {
+	if (_retVal == ERROR_SUCCESS) {
-subHandle = __MKEXTERNALADDRESS(subKey);
+	    subHandle = __MKEXTERNALADDRESS(subKey);
-} else {
+	} else {
-if ((_retVal != ERROR_PATH_NOT_FOUND)
+	    if ((_retVal != ERROR_PATH_NOT_FOUND)
-&& (_retVal != ERROR_FILE_NOT_FOUND)) {
+	     && (_retVal != ERROR_FILE_NOT_FOUND)) {
-errorNumber = __MKSMALLINT(_retVal);
+		errorNumber = __MKSMALLINT(_retVal);
-}
+	    }
-}
+	}
 }
 %}.
 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.
 ].
 errorNumber notNil ifTrue:[
-(OperatingSystem errorHolderForNumber:errorNumber) reportError.
+	(OperatingSystem errorHolderForNumber:errorNumber) reportError.
 ].
 ^ nil
 "
 |top sub|
 Otherwise, nil is returned"
 |k|
 (k := self subKeyNamed:subKeyString) isNil ifTrue:[
-createIfAbsent ifTrue:[
+	createIfAbsent ifTrue:[
-^ self createSubKeyNamed:subKeyString
+	    ^ self createSubKeyNamed:subKeyString
-].
+	].
 ].
 ^ k
 "Created: / 19-01-2011 / 15:58:45 / cg"
 ! !
 "
 !
 defaultValue: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
 "
 ^ self valueNamed:'' put:datum
 "
 HKEY myKey;
 int _retVal;
 if (__isExternalAddressLike(__INST(handle))
 && __isStringLike(aValueName)) {
-myKey = (HKEY)__externalAddressVal(__INST(handle));
+	myKey = (HKEY)__externalAddressVal(__INST(handle));
-if ((_retVal = RegDeleteValue(myKey, __stringVal(aValueName))) == ERROR_SUCCESS) {
+	if ((_retVal = RegDeleteValue(myKey, __stringVal(aValueName))) == ERROR_SUCCESS) {
-RETURN (true);
+	    RETURN (true);
-}
+	}
-if ((_retVal != ERROR_PATH_NOT_FOUND)
+	if ((_retVal != ERROR_PATH_NOT_FOUND)
-&& (_retVal != ERROR_FILE_NOT_FOUND)) {
+	 && (_retVal != ERROR_FILE_NOT_FOUND)) {
-errorNumber = __MKSMALLINT(_retVal);
+	    errorNumber = __MKSMALLINT(_retVal);
-}
+	}
 }
 %}.
 errorNumber notNil ifTrue:[
-(OperatingSystem errorHolderForNumber:errorNumber) reportError.
+	(OperatingSystem errorHolderForNumber:errorNumber) reportError.
 ].
 ^ false
 !
 valueNameAtIndex:valueIndex
 DWORD valueType;
 int _retVal;
 if (__isExternalAddressLike(__INST(handle))
 && __isSmallInteger(valueIndex)) {
-myKey = (HKEY)__externalAddressVal(__INST(handle));
+	myKey = (HKEY)__externalAddressVal(__INST(handle));
-if ((_retVal = RegEnumValueA(myKey, __intVal(valueIndex),
+	if ((_retVal = RegEnumValueA(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);
-} else {
+	} else {
-if ((_retVal != ERROR_PATH_NOT_FOUND)
+	    if ((_retVal != ERROR_PATH_NOT_FOUND)
-&& (_retVal != ERROR_FILE_NOT_FOUND)) {
+	     && (_retVal != ERROR_FILE_NOT_FOUND)) {
-errorNumber = __MKSMALLINT(_retVal);
+		errorNumber = __MKSMALLINT(_retVal);
-}
+	    }
-}
+	}
 }
 %}.
 errorNumber notNil ifTrue:[
-(OperatingSystem errorHolderForNumber:errorNumber) reportError.
+	(OperatingSystem errorHolderForNumber:errorNumber) reportError.
 ].
 ^ valueName
 "
 |top sub|
 "
 !
 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
 "
 |stringArray retVal errorNumber|
 %{
 HKEY myKey;
 DWORD valueType;
 union {
-DWORD dWord;
+	DWORD dWord;
-unsigned char dWordBytes[4];
+	unsigned char dWordBytes[4];
-unsigned char smallDataBuffer[1024*128];
+	unsigned char smallDataBuffer[1024*128];
 } quickData;
 int val;
 DWORD dataSize = sizeof(quickData);
 unsigned char *dataBuffer = NULL;
 #define xxUSE_UNICODE
 # define CHAR             char
 #endif
 if (__isExternalAddressLike(__INST(handle))
 && __isStringLike(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 0
-console_printf("dataSize=%d\n", dataSize);
+	console_printf("dataSize=%d\n", dataSize);
 #endif
-while (ret == ERROR_MORE_DATA) {
+	while (ret == ERROR_MORE_DATA) {
 #if 0
-console_printf("ERROR_MORE_DATA dataSize=%d\n", dataSize);
+	    console_printf("ERROR_MORE_DATA dataSize=%d\n", dataSize);
-console_printf("valueType=%d\n", valueType);
+	    console_printf("valueType=%d\n", valueType);
 #endif
-/*
+	    /*
-* nope - need another one ...
+	     * nope - need another one ...
-*/
+	     */
-if (myKey = HKEY_PERFORMANCE_DATA) {
+	    if (myKey = HKEY_PERFORMANCE_DATA) {
-dataSize = dataSize * 2;
+		dataSize = dataSize * 2;
-}
+	    }
-switch (valueType) {
+	    switch (valueType) {
-case REG_BINARY:
+		case REG_BINARY:
-case REG_MULTI_SZ:
+		case REG_MULTI_SZ:
-dataBuffer = malloc(dataSize);;
+		    dataBuffer = malloc(dataSize);;
-break;
+		    break;
-case REG_SZ:
+		case REG_SZ:
-dataBuffer = malloc(dataSize);
+		    dataBuffer = malloc(dataSize);
-break;
+		    break;
-default:
+		default:
-console_printf("RegistryEntry [warning]: unhandled valueType: %d\n", valueType);
+		    console_printf("RegistryEntry [warning]: unhandled valueType: %d\n", valueType);
-break;
+		    break;
-}
+	    }
-if (dataBuffer) {
+	    if (dataBuffer) {
-ret = RegQueryValueEx(myKey, __stringVal(aValueName),
+		ret = RegQueryValueEx(myKey, __stringVal(aValueName),
-NULL,
+				 NULL,
-&valueType,
+				 &valueType,
-dataBuffer,
+				 dataBuffer,
-&dataSize);
+				 &dataSize);
-} else {
+	    } else {
-break;
+		break;
-}
+	    }
-if (myKey != HKEY_PERFORMANCE_DATA) {
+	    if (myKey != HKEY_PERFORMANCE_DATA) {
-if (ret != ERROR_SUCCESS) break;
+		if (ret != ERROR_SUCCESS) break;
-}
+	    }
-}
+	}
-if (ret == ERROR_SUCCESS) {
+	if (ret == ERROR_SUCCESS) {
 #if 0
-console_printf("ERROR_SUCCESS dataSize=%d\n", dataSize);
+	    console_printf("ERROR_SUCCESS dataSize=%d\n", dataSize);
-console_printf("valueType=%d\n", valueType);
+	    console_printf("valueType=%d\n", valueType);
 #endif
-switch (valueType) {
+	    switch (valueType) {
-case REG_NONE:
+		case REG_NONE:
-/* RETURN (@symbol(none));  */
+		    /* RETURN (@symbol(none));  */
-retVal = nil;
+		    retVal = nil;
-break;
+		    break;
-case REG_BINARY:
+		case REG_BINARY:
-retVal = __MKBYTEARRAY(dataBuffer ? dataBuffer : quickData.smallDataBuffer, dataSize);
+		    retVal = __MKBYTEARRAY(dataBuffer ? dataBuffer : quickData.smallDataBuffer, dataSize);
-break;
+		    break;
-case REG_SZ:
+		case REG_SZ:
-case REG_EXPAND_SZ:
+		case REG_EXPAND_SZ:
 #ifdef USE_UNICODE
-retVal = __MKU16STRING(dataBuffer ? dataBuffer : quickData.smallDataBuffer);
+		    retVal = __MKU16STRING(dataBuffer ? dataBuffer : quickData.smallDataBuffer);
 #else
-retVal = __MKSTRING(dataBuffer ? dataBuffer : quickData.smallDataBuffer);
+		    retVal = __MKSTRING(dataBuffer ? dataBuffer : quickData.smallDataBuffer);
 #endif
-break;
+		    break;
 #if 0
-case REG_DWORD:
+		case REG_DWORD:
-/* int in native format */
+		    /* int in native format */
-retVal = __MKUINT(quickData.dWord);
+		    retVal = __MKUINT(quickData.dWord);
-break;
+		    break;
 #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];
-retVal = __MKUINT(val);
+		    retVal = __MKUINT(val);
-break;
+		    break;
-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];
-retVal = __MKUINT(val);
+		    retVal = __MKUINT(val);
-break;
+		    break;
-case REG_MULTI_SZ:
+		case REG_MULTI_SZ:
-{
+		    {
-CHAR *cp, *cp0;
+			CHAR *cp, *cp0;
-int ns, i;
+			int ns, i;
-cp0 = dataBuffer ? dataBuffer : quickData.smallDataBuffer;
+			cp0 = dataBuffer ? dataBuffer : quickData.smallDataBuffer;
 #if 0
-console_printf("**************\n");
+			console_printf("**************\n");
-for (i=0;i<50;i++) {
+			for (i=0;i<50;i++) {
-console_printf("%x ", cp0[i]);
+			  console_printf("%x ", cp0[i]);
-}
+			}
-console_printf("\n");
+			console_printf("\n");
-for (i=0;i<50;i++) {
+			for (i=0;i<50;i++) {
-if (cp0[i] == 0)
+			  if (cp0[i] == 0)
-console_printf("\n");
+			    console_printf("\n");
-else
+			  else
-console_printf("%c", cp0[i]);
+			    console_printf("%c", cp0[i]);
-}
+			}
-console_printf("\n");
+			console_printf("\n");
-console_printf("**************\n");
+			console_printf("**************\n");
 #endif
-cp = cp0;
+			cp = cp0;
-ns = 0;
+			ns = 0;
-while (*cp) {
+			while (*cp) {
-while (*cp++) ;;
+			    while (*cp++) ;;
-ns++;
+			    ns++;
-}
+			}
-stringArray = __ARRAY_NEW_INT(ns);
+			stringArray = __ARRAY_NEW_INT(ns);
-i = 0;
+			i = 0;
-while (*cp0) {
+			while (*cp0) {
-OBJ s;
+			    OBJ s;
-CHAR *cp;
+			    CHAR *cp;
-cp = cp0;
+			    cp = cp0;
-while (*cp++) ;;
+			    while (*cp++) ;;
 #ifdef USE_UNICODE
-s = __MKU16STRING(cp0); __ArrayInstPtr(stringArray)->a_element[i] = s; __STORE(stringArray, s);
+			    s = __MKU16STRING(cp0); __ArrayInstPtr(stringArray)->a_element[i] = s; __STORE(stringArray, s);
 #else
-s = __MKSTRING(cp0); __ArrayInstPtr(stringArray)->a_element[i] = s; __STORE(stringArray, s);
+			    s = __MKSTRING(cp0); __ArrayInstPtr(stringArray)->a_element[i] = s; __STORE(stringArray, s);
 #endif
-cp0 = cp;
+			    cp0 = cp;
-i++;
+			    i++;
-}
+			}
-retVal = stringArray;
+			retVal = stringArray;
-break;
+			break;
-}
+		    }
-default:
+		default:
-console_printf("RegistryEntry [warning]: unhandled valueType: %d\n", valueType);
+		    console_printf("RegistryEntry [warning]: unhandled valueType: %d\n", valueType);
-break;
+		    break;
-}
+	    }
-} else {
+	} else {
-if ((ret != ERROR_PATH_NOT_FOUND)
+	    if ((ret != ERROR_PATH_NOT_FOUND)
-&& (ret != ERROR_FILE_NOT_FOUND)) {
+	     && (ret != ERROR_FILE_NOT_FOUND)) {
-errorNumber = __MKSMALLINT(ret);
+		errorNumber = __MKSMALLINT(ret);
-}
+	    }
-}
+	}
 }
 if (dataBuffer) free(dataBuffer);
 %}.
 errorNumber notNil ifTrue:[
-(OperatingSystem errorHolderForNumber:errorNumber) reportError.
+	(OperatingSystem errorHolderForNumber:errorNumber) reportError.
 ].
 ^ retVal
 "
 "
 !
 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 errorNumber|
 %{
 HKEY myKey;
 unsigned char *dataPointer = NULL;
 int datumOk = 1, mustFreeData = 0;
 if (__isExternalAddressLike(__INST(handle))
 && __isStringLike(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 (__isStringLike(datum)) {
+	} else if (__isStringLike(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 (__isStringLike(s)) {
+		if (__isStringLike(s)) {
-totalSize += __stringSize(s) + 1;
+		    totalSize += __stringSize(s) + 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(s);
+		    cp += __stringSize(s);
-*cp++ = '\0';
+		    *cp++ = '\0';
-}
+		}
-*cp++ = '\0';
+		*cp++ = '\0';
-dataSize = totalSize;
+		dataSize = totalSize;
-}
+	    }
-} else {
+	} else {
-datumOk = 0;
+	    datumOk = 0;
-}
+	}
-if (datumOk) {
+	if (datumOk) {
-ret = RegSetValueExA(myKey, __stringVal(aValueName),
+	    ret = RegSetValueExA(myKey, __stringVal(aValueName),
-0, valueType,
+				0, valueType,
-dataPointer, dataSize);
+				dataPointer, dataSize);
-if (mustFreeData) {
+	    if (mustFreeData) {
-free(dataPointer);
+		free(dataPointer);
-}
+	    }
-if (ret == ERROR_SUCCESS) {
+	    if (ret == ERROR_SUCCESS) {
-RETURN (true);
+		RETURN (true);
-}
+	    }
-if ((ret != ERROR_PATH_NOT_FOUND)
+	    if ((ret != ERROR_PATH_NOT_FOUND)
-&& (ret != ERROR_FILE_NOT_FOUND)) {
+	     && (ret != ERROR_FILE_NOT_FOUND)) {
-errorNumber = __MKSMALLINT(ret);
+		errorNumber = __MKSMALLINT(ret);
-}
+	    }
-}
+	}
 }
 %}.
 errorNumber notNil ifTrue:[
-(OperatingSystem errorHolderForNumber:errorNumber) reportError.
+	(OperatingSystem errorHolderForNumber:errorNumber) reportError.
 ].
 ^ false
 "
 |key|
 |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
 ]
 "
 !
 valueNames
 "evaluate aBlock for all value names"
 ^ Array streamContents:[:s |
-self valueNamesDo:[:nm | s nextPut:nm]
+	self valueNamesDo:[:nm | s nextPut:nm]
 ].
 "Created: / 18-01-2011 / 20:24:52 / cg"
 !
 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"
 ! !
 !Win32OperatingSystem::RegistryEntry methodsFor:'printing & storing'!
 printOn:aStream
 aStream
-nextPutAll:self className;
+	nextPutAll:self className;
-nextPut:$(;
+	nextPut:$(;
-nextPutAll:path;
+	nextPutAll:path;
-nextPut:$).
+	nextPut:$).
 ! !
 !Win32OperatingSystem::RegistryEntry methodsFor:'private'!
 setHandle:aHandle path:aPathString
 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)) {  // not isStringLike here !
+	} else if (__isString(aByteBuffer)) {  // not isStringLike here !
-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_NOINT_CALL5( "ReadFile", ReadFile, hFile, extPtr, cntWanted, &cntRead, 0 /* lpOverlapped */);
+	ok = STX_API_NOINT_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 (__isStringLike(aByteBuffer)) {
+	} else if (__isStringLike(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_NOINT_CALL5( "WriteFile", WriteFile, hFile, extPtr, cntWanted, &cntWritten, 0 /* lpOverlapped */);
+	ok = STX_API_NOINT_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 (__isStringLike(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.
 ! !
 domain := OperatingSystem domainCodeOf:domainArg.
 type := OperatingSystem socketTypeCodeOf:typeArg.
 proto := self protocolCodeOf:protoArg.
 serviceNameArg notNil ifTrue:[
-serviceName := serviceNameArg printString.      "convert integer port numbers"
+	serviceName := serviceNameArg printString.      "convert integer port numbers"
-serviceNameArg isInteger ifTrue:[
+	serviceNameArg isInteger ifTrue:[
-port := serviceNameArg.
+	    port := serviceNameArg.
-].
+	].
 ]. "ifFalse:[serviceName := nil]"
 %{ /* STACK:32000 */
 #if !defined(NO_SOCKET)
 char *__hostName, *__serviceName;
 int ret, cnt = 0;
 if (hostName == nil) {
-__hostName = 0;
+	__hostName = 0;
 } else if (__isStringLike(hostName)) {
-__hostName = __stringVal(hostName);
+	__hostName = __stringVal(hostName);
 } else {
-error = @symbol(badArgument1);
+	error = @symbol(badArgument1);
-goto exitPrim;
+	goto exitPrim;
 }
 if (serviceName == nil) {
-__serviceName = 0;
+	__serviceName = 0;
 } else if (__isStringLike(serviceName)) {
-__serviceName = __stringVal(serviceName);
+	__serviceName = __stringVal(serviceName);
 } else {
-error = @symbol(badArgument2);
+	error = @symbol(badArgument2);
-goto exitPrim;
+	goto exitPrim;
 }
 if (__hostName == 0 && __serviceName == 0) {
-error = @symbol(badArgument);
+	error = @symbol(badArgument);
-goto exitPrim;
+	goto exitPrim;
 }
 {
 # 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 (__isStringLike(hostName)) {
+	} else if (__isStringLike(hostName)) {
-__hostName = __stringVal(hostName);
+	    __hostName = __stringVal(hostName);
-}
+	}
-if (serviceName == nil) {
+	if (serviceName == nil) {
-__serviceName = 0;
+	    __serviceName = 0;
-} else if (__isStringLike(serviceName)) {
+	} else if (__isStringLike(serviceName)) {
-__serviceName = __stringVal(serviceName);
+	    __serviceName = __stringVal(serviceName);
-}
+	}
 # ifdef DO_WRAP_CALLS
-do {
+	do {
-__threadErrno = 0;
+	    __threadErrno = 0;
-res = STX_WSA_NOINT_CALL4( "getaddrinfo", getaddrinfo, __hostName, __serviceName, &hints, &info);
+	    res = STX_WSA_NOINT_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 (__isSmallInteger(port)) {
-__port = htons(__smallIntegerVal(port));
+	__port = htons(__smallIntegerVal(port));
 } else if (__serviceName) {
-struct servent *sp;
+	struct servent *sp;
-char *__proto = 0;
+	char *__proto = 0;
-if (__isStringLike(protoArg))
+	if (__isStringLike(protoArg))
-__proto = __stringVal(protoArg);
+	    __proto = __stringVal(protoArg);
-sp = getservbyname(__serviceName, __proto);
+	sp = getservbyname(__serviceName, __proto);
-if (sp == NULL) {
+	if (sp == NULL) {
-__port = atoi(__serviceName);
+	    __port = atoi(__serviceName);
-if (__port <= 0) {
+	    if (__port <= 0) {
-errorString = @symbol(unknownService);
+		errorString = @symbol(unknownService);
-error = __mkSmallInteger(-3);
+		error = __mkSmallInteger(-3);
-goto err;
+		goto err;
-}
+	    }
-__port = htons(__port);
+	    __port = htons(__port);
-} else
+	} else
-__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 (__isStringLike(hostName)) {
+	    } else if (__isStringLike(hostName)) {
-__hostName = __stringVal(hostName);
+		__hostName = __stringVal(hostName);
-}
+	    }
 # ifdef DO_WRAP_CALLS
-hp = STX_WSA_NOINT_CALL1("gethostbyname", gethostbyname, __hostName);
+	    hp = STX_WSA_NOINT_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 */
 }
 error = @symbol(notImplemented);
 #endif
 exitPrim:;
 %}.
 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 ? error printString);
+		messageText:' - ', (errorString ? error printString);
-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:'localhost' serviceName:10
-domain:#inet type:#stream protocol:#tcp flags:nil
+	    domain:#inet type:#stream protocol:#tcp flags:nil
 self getAddressInfo:'localhost' serviceName:'10'
-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.426 2011-08-24 13:44:54 vrany Exp $'
+^ '$Header: /cvs/stx/stx/libbasic/Win32OperatingSystem.st,v 1.427 2011-09-29 11:18:57 cg Exp $'
 !
 version_CVS
-^ '$Header: /cvs/stx/stx/libbasic/Win32OperatingSystem.st,v 1.426 2011-08-24 13:44:54 vrany Exp $'
+^ '$Header: /cvs/stx/stx/libbasic/Win32OperatingSystem.st,v 1.427 2011-09-29 11:18:57 cg Exp $'
 !
 version_SVN
 ^ '�Id�'

changeset 13742	cfb6a76de348
parent 13618	9af72c855037
child 13778	8e34483d10dd