hg/stx-libbasic: comparison Win32OperatingSystem.st

equal deleted inserted replaced

-:6eb4414e6a31
+:019bb9c842c5
 # ifndef WINDOWS_H_INCLUDED
 #  define WINDOWS_H_INCLUDED
 #  include <windows.h>
 # endif
+# ifndef TLHELP32_H_INCLUDE
+#  define TLHELP32_H_INCLUDE
+#  include <TLHELP32.h>         /* to get all processes in system */
+#endif
 # ifndef NO_GETADAPTERSINFO
 #  include <iphlpapi.h>
 # endif
 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;
 }
 "/ 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 process id of the child process is returned; nil if the fork failed.
+	The process id of the child process is returned; nil if the fork failed.
 fdArray contains the filedescriptors, to be used for the child (if fork is true).
-fdArray[1] = 15 -> use fd 15 as stdin.
+	fdArray[1] = 15 -> use fd 15 as stdin.
-If an element of the array is set to nil, the corresponding filedescriptor
+	If an element of the array is set to nil, the corresponding filedescriptor
-will be closed for the child.
+	will be closed for the child.
-fdArray[0] == StdIn for child
+	fdArray[0] == StdIn for child
-fdArray[1] == StdOut for child
+	fdArray[1] == StdOut for child
-fdArray[2] == StdErr for child
+	fdArray[2] == StdErr for child
-on VMS, these must be channels as returned by createMailBox.
+	on VMS, these must be channels as returned by createMailBox.
 NOTE that in WIN32 the fds are HANDLES.
 If newPgrp is true, the subprocess will be established in a new process group.
-The processgroup will be equal to id.
+	The processgroup will be equal to id.
-newPgrp is not used on WIN32 and VMS systems."
+	newPgrp is not used on WIN32 and VMS systems."
 |dirPath 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.
 PROCESS_INFORMATION lppiProcInfo;
 SECURITY_ATTRIBUTES sa;
 SECURITY_DESCRIPTOR sd;
 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(&sa, 0, sizeof (sa));
+	memset(&sa, 0, sizeof (sa));
-sa.nLength = sizeof( sa );
+	sa.nLength = sizeof( sa );
-sa.lpSecurityDescriptor = NULL;
+	sa.lpSecurityDescriptor = NULL;
-sa.bInheritHandle = TRUE;
+	sa.bInheritHandle = TRUE;
-InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION);
+	InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION);
-SetSecurityDescriptorDacl(&sd, -1, 0, 0);
+	SetSecurityDescriptorDacl(&sd, -1, 0, 0);
-sa.lpSecurityDescriptor = &sd;
+	sa.lpSecurityDescriptor = &sd;
-memset(&lppiProcInfo, 0, sizeof (lppiProcInfo));
+	memset(&lppiProcInfo, 0, sizeof (lppiProcInfo));
-memset(&lpsiStartInfo, 0, sizeof (lpsiStartInfo));
+	memset(&lpsiStartInfo, 0, sizeof (lpsiStartInfo));
-lpsiStartInfo.cb                = sizeof(lpsiStartInfo);
+	lpsiStartInfo.cb                = sizeof(lpsiStartInfo);
-lpsiStartInfo.lpReserved        = NULL;
+	lpsiStartInfo.lpReserved        = NULL;
-lpsiStartInfo.lpDesktop         = NULL;
+	lpsiStartInfo.lpDesktop         = NULL;
-lpsiStartInfo.lpTitle           = NULL;
+	lpsiStartInfo.lpTitle           = NULL;
-lpsiStartInfo.dwX               = 0;
+	lpsiStartInfo.dwX               = 0;
-lpsiStartInfo.dwY               = 0;
+	lpsiStartInfo.dwY               = 0;
-lpsiStartInfo.dwXSize           = 100;
+	lpsiStartInfo.dwXSize           = 100;
-lpsiStartInfo.dwYSize           = 100;
+	lpsiStartInfo.dwYSize           = 100;
-lpsiStartInfo.dwXCountChars     = 0;
+	lpsiStartInfo.dwXCountChars     = 0;
-lpsiStartInfo.dwYCountChars     = 0;
+	lpsiStartInfo.dwYCountChars     = 0;
-lpsiStartInfo.dwFillAttribute   = 0;
+	lpsiStartInfo.dwFillAttribute   = 0;
-if (0 /*__isWinNT*/) {
+	if (0 /*__isWinNT*/) {
-lpsiStartInfo.dwFlags           = STARTF_USESTDHANDLES;
+	    lpsiStartInfo.dwFlags           = STARTF_USESTDHANDLES;
-lpsiStartInfo.wShowWindow       = SW_SHOWDEFAULT;
+	    lpsiStartInfo.wShowWindow       = SW_SHOWDEFAULT;
-} else {
+	} else {
-lpsiStartInfo.dwFlags           = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES /*| STARTF_USEPOSITION*/;
+	    lpsiStartInfo.dwFlags           = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES /*| STARTF_USEPOSITION*/;
-lpsiStartInfo.wShowWindow       = SW_HIDE /*SW_SHOWDEFAULT*/;
+	    lpsiStartInfo.wShowWindow       = SW_HIDE /*SW_SHOWDEFAULT*/;
-}
+	}
-lpsiStartInfo.cbReserved2       = 0;
+	lpsiStartInfo.cbReserved2       = 0;
-lpsiStartInfo.lpReserved2       = NULL;
+	lpsiStartInfo.lpReserved2       = NULL;
-lpsiStartInfo.hStdInput         = NULL;
+	lpsiStartInfo.hStdInput         = NULL;
-lpsiStartInfo.hStdOutput        = NULL;
+	lpsiStartInfo.hStdOutput        = NULL;
-lpsiStartInfo.hStdError         = NULL;
+	lpsiStartInfo.hStdError         = NULL;
-/*
+	/*
-* set create process flags
+	 * set create process flags
-* if the flags arg is nil, use common defaults;
+	 * if the flags arg is nil, use common defaults;
-* if non-nil, it must be a positive integer containing the fdwCreate bits.
+	 * if non-nil, it must be a positive integer containing the fdwCreate bits.
-*/
+	 */
-if (flagsOrNil != nil) {
+	if (flagsOrNil != nil) {
-fdwCreate = __longIntVal(flagsOrNil);
+	    fdwCreate = __longIntVal(flagsOrNil);
-} else {
+	} else {
-if (0 /* __isWinNT */)
+	    if (0 /* __isWinNT */)
-fdwCreate = 0; //IDLE_PRIORITY_CLASS;
+		fdwCreate = 0; //IDLE_PRIORITY_CLASS;
-else
+	    else
-fdwCreate = CREATE_NEW_CONSOLE; //|IDLE_PRIORITY_CLASS; // DETACHED_PROCESS; // NORMAL_PRIORITY_CLASS ;
+		fdwCreate = CREATE_NEW_CONSOLE; //|IDLE_PRIORITY_CLASS; // DETACHED_PROCESS; // NORMAL_PRIORITY_CLASS ;
-if (newPgrp == true) {
+	    if (newPgrp == true) {
-fdwCreate |= CREATE_NEW_PROCESS_GROUP;
+		fdwCreate |= CREATE_NEW_PROCESS_GROUP;
-}
+	    }
-fdwCreate |= CREATE_DEFAULT_ERROR_MODE;
+	    fdwCreate |= CREATE_DEFAULT_ERROR_MODE;
-}
+	}
-if (fdArray == nil) {
+	if (fdArray == nil) {
-lpsiStartInfo.hStdInput  = (HANDLE) _get_osfhandle (0);
+	    lpsiStartInfo.hStdInput  = (HANDLE) _get_osfhandle (0);
-lpsiStartInfo.hStdOutput = (HANDLE) _get_osfhandle (1);
+	    lpsiStartInfo.hStdOutput = (HANDLE) _get_osfhandle (1);
-lpsiStartInfo.hStdError  = (HANDLE) _get_osfhandle (2);
+	    lpsiStartInfo.hStdError  = (HANDLE) _get_osfhandle (2);
-} else if (__isArrayLike(fdArray) && (__arraySize(fdArray) >= 3)) {
+	} else if (__isArrayLike(fdArray) && (__arraySize(fdArray) >= 3)) {
-if (__ArrayInstPtr(fdArray)->a_element[0] != nil) {
+	    if (__ArrayInstPtr(fdArray)->a_element[0] != nil) {
-if (__isExternalAddressLike(__ArrayInstPtr(fdArray)->a_element[0])) {
+		if (__isExternalAddressLike(__ArrayInstPtr(fdArray)->a_element[0])) {
-lpsiStartInfo.hStdInput = _HANDLEVal(__ArrayInstPtr(fdArray)->a_element[0]);
+		    lpsiStartInfo.hStdInput = _HANDLEVal(__ArrayInstPtr(fdArray)->a_element[0]);
-} else {
+		} else {
-lpsiStartInfo.hStdInput = (HANDLE) _get_osfhandle (__intVal(__ArrayInstPtr(fdArray)->a_element[0]));
+		    lpsiStartInfo.hStdInput = (HANDLE) _get_osfhandle (__intVal(__ArrayInstPtr(fdArray)->a_element[0]));
-}
+		}
-}
+	    }
-if (__ArrayInstPtr(fdArray)->a_element[1] != nil) {
+	    if (__ArrayInstPtr(fdArray)->a_element[1] != nil) {
-if (__isExternalAddressLike(__ArrayInstPtr(fdArray)->a_element[1])) {
+		if (__isExternalAddressLike(__ArrayInstPtr(fdArray)->a_element[1])) {
-lpsiStartInfo.hStdOutput = _HANDLEVal(__ArrayInstPtr(fdArray)->a_element[1]);
+		    lpsiStartInfo.hStdOutput = _HANDLEVal(__ArrayInstPtr(fdArray)->a_element[1]);
-} else {
+		} else {
-lpsiStartInfo.hStdOutput = (HANDLE) _get_osfhandle (__intVal(__ArrayInstPtr(fdArray)->a_element[1]));
+		    lpsiStartInfo.hStdOutput = (HANDLE) _get_osfhandle (__intVal(__ArrayInstPtr(fdArray)->a_element[1]));
-}
+		}
-}
+	    }
-if (__ArrayInstPtr(fdArray)->a_element[2] != nil) {
+	    if (__ArrayInstPtr(fdArray)->a_element[2] != nil) {
-if (__isExternalAddressLike(__ArrayInstPtr(fdArray)->a_element[2])) {
+		if (__isExternalAddressLike(__ArrayInstPtr(fdArray)->a_element[2])) {
-lpsiStartInfo.hStdError  = _HANDLEVal(__ArrayInstPtr(fdArray)->a_element[2]);
+		    lpsiStartInfo.hStdError  = _HANDLEVal(__ArrayInstPtr(fdArray)->a_element[2]);
-} else {
+		} else {
-lpsiStartInfo.hStdError = (HANDLE) _get_osfhandle (__intVal(__ArrayInstPtr(fdArray)->a_element[2]));
+		    lpsiStartInfo.hStdError = (HANDLE) _get_osfhandle (__intVal(__ArrayInstPtr(fdArray)->a_element[2]));
-}
+		}
-}
+	    }
 #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,
-&sa, NULL /* &sa */,           /* sec-attribs */
+				&sa, NULL /* &sa */,           /* sec-attribs */
-sa.bInheritHandle,  /* inherit handles */
+				sa.bInheritHandle,  /* inherit handles */
-fdwCreate,
+				fdwCreate,
-NULL,               /* env */
+				NULL,               /* env */
-dir,
+				dir,
-&lpsiStartInfo,
+				&lpsiStartInfo,
-&lppiProcInfo ))
+				&lppiProcInfo ))
-{
+	    {
-CloseHandle(lppiProcInfo.hThread);
+		CloseHandle(lppiProcInfo.hThread);
 #ifdef PROCESSDEBUGWIN32
-console_fprintf(stderr, "created process hProcess=%x\n", lppiProcInfo.hProcess);
+		console_fprintf(stderr, "created process hProcess=%x\n", lppiProcInfo.hProcess);
 #endif
-__externalAddressVal(handle) = lppiProcInfo.hProcess;
+		__externalAddressVal(handle) = lppiProcInfo.hProcess;
-((struct __Win32OperatingSystem__Win32ProcessHandle_struct *)(handle))->pid = __mkSmallInteger(lppiProcInfo.dwProcessId);
+		((struct __Win32OperatingSystem__Win32ProcessHandle_struct *)(handle))->pid = __mkSmallInteger(lppiProcInfo.dwProcessId);
-RETURN (handle);
+		RETURN (handle);
-}
+	    }
 #ifdef PROCESSDEBUGWIN32
-console_fprintf(stderr, "created process error %d\n", GetLastError());
+	    console_fprintf(stderr, "created process error %d\n", GetLastError());
 #endif
-RETURN (nil);
+	    RETURN (nil);
-} else {
+	} else {
-; /* should never be called that way */
+	    ; /* should never be called that way */
-}
+	}
 }
 %}.
 "
 path-argument not string
 or argArray not an array/nil
 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.
 %{
 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
 "
 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
 "
 ^ 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 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:;
 %}.
 ^ self primitiveFailed
 "
 self getLongPathName:'x:\'
 self getLongPathName:'c:\Dokumente und Einstellungen'
 self getShortPathName:'c:\Dokumente und Einstellungen'
 "
 !
 getNullDevice
 "get the name of the null-device."
 %{
 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:;
 %}.
 ^ self primitiveFailed
 "
 self getShortPathName:'x:\'
 self getShortPathName:'c:\Dokumente und Einstellungen'
 self getLongPathName:'c:\Dokumente und Einstellungen'
 "
 !
 getVolumeInformation: rootPath
 name: volumeNameBuffer
 %{
 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:;
 %}.
 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'
 %{
 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'
 "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
 "
 "/ or not supported by OS
 "/
 ^ self primitiveFailed
 !
-terminateProcess:processHandle
+terminateProcess:processHandleOrPid
 "terminate a process.
 The process has a chance to do some cleanup.
 WIN32:
 	 Under unix, we have terminateProcess, which does a soft
 	 terminate (giving the process a chance to cleanup) and
 	 Use it only in extreme circumstances. The state of
 	 global data maintained by dynamic-link libraries (DLLs)
 	 may be compromised if TerminateProcess is used.
 TODO: send it a WM_QUIT instead, to allow for proper shutdown."
-self terminateProcess:processHandle exitCode:0
+self terminateProcess:processHandleOrPid exitCode:0
 !
-terminateProcess:processHandle exitCode:exitCode
+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
 	 terminate (giving the process a chance to cleanup) and
 	 global data maintained by dynamic-link libraries (DLLs)
 	 may be compromised if TerminateProcess is used.
 TODO: send it a WM_QUIT instead, to allow for proper shutdown."
 %{
-if (__isExternalAddressLike(processHandle) ) {
+if (__isExternalAddressLike(processHandleOrPid) ) {
-	HANDLE hProcess = _HANDLEVal(processHandle);
+	HANDLE hProcess = _HANDLEVal(processHandleOrPid);
-#ifdef PROCESS1DEBUGWIN32
-	console_printf("TerminateProcess handle: %x\n", hProcess);
-#endif
 	if (hProcess != 0) {
-	    TerminateProcess(hProcess, __intVal(exitCode));
+	    TerminateProcess( hProcess, __intVal(exitCode) );
-	} else {
+	}
-	    console_fprintf(stderr, "Win32OS [warning]: wrong hProcess in TerminateProcess\n");
+	RETURN( true );
-	}
+} else if( __isSmallInteger(processHandleOrPid) ) {
-} else {
+	HANDLE hProcess = OpenProcess(PROCESS_TERMINATE, 0, __smallIntegerVal(processHandleOrPid));
-	console_fprintf(stderr, "Win32OS [warning]: wrong processHandle in TerminateProcess\n");
-}
+	if( hProcess != 0 ) {
-%}
+	    TerminateProcess( hProcess, __intVal(exitCode) );
+	    CloseHandle(hProcess);
+	}
+	RETURN( true );
+}
+%}.
+self primitiveFailed:#invalidParameter.
 "Modified: / 28.12.1995 / 15:05:37 / stefan"
 "Modified: / 27.1.1998 / 20:05:47 / cg"
 !
-terminateProcessGroup:processGroupHandle
+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
 	 using GenerateConsoleCtrlEvent."
-%{
+| pid list |
-if (__isExternalAddressLike(processGroupHandle) ) {
-	HANDLE hProcessGroup = _HANDLEVal(processGroupHandle);
+list := self getAllProcesses.
-	DWORD processGroupId;
+list size == 0 ifTrue:[^ self ].
-	if (hProcessGroup != (HANDLE)0) {
+processGroupHandleOrPid isInteger ifTrue:[
-	    processGroupId = __intVal( ((struct __Win32OperatingSystem__Win32ProcessHandle_struct *)(processGroupHandle))->pid );
+	pid := processGroupHandleOrPid
+] ifFalse:[
-#ifdef PROCESS1DEBUGWIN32
+	pid := processGroupHandleOrPid pid.
-	    console_printf("TerminateProcessGroup processGroupHandle: %x (%d)\n", hProcessGroup, processGroupId);
+].
-#endif
+list do:[:anOSProcess |
-	    GenerateConsoleCtrlEvent(CTRL_C_EVENT, processGroupId);
+	( anOSProcess parentPid == pid ) ifTrue:[
-	} else {
+	    self terminateProcess:( anOSProcess pid ).
-	    console_fprintf(stderr, "Win32OS [warning]: wrong hProcessGroup in TerminateProcessGroup \n");
+	].
-	}
+].
-} else {
-	console_fprintf(stderr, "Win32OS [warning]: wrong processGroupHandle in TerminateProcessGroup \n");
-}
-%}
 ! !
 !Win32OperatingSystem class methodsFor:'ipc support'!
 makePipe
 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
 ! !
 	^ nil
 ].
 ^ ExternalAddress newAddress:(spaceForTargetHandle value).
 "Created: / 18-09-2007 / 16:34:25 / cg"
+!
+getAllProcesses
+"answer a sequence of OSProcess, all processes running in system"
+|list st_perProc|
+list := OrderedCollection new.
+%{
+#ifdef TLHELP32_H_INCLUDE
+HANDLE hProcessSnap;
+PROCESSENTRY32 pe32;
+hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
+if( hProcessSnap != INVALID_HANDLE_VALUE ) {
+	pe32.dwSize = sizeof(PROCESSENTRY32);
+	Process32First( hProcessSnap, & pe32 );
+	do {
+	    st_perProc = __SSEND0(@global(OSProcess), @symbol(new), 0);
+	    __SSEND1(st_perProc, @symbol(commandLine:), 0, __MKSTRING(pe32.szExeFile) );
+	    __SSEND1(st_perProc, @symbol(pid:), 0, __mkSmallInteger(pe32.th32ProcessID) );
+	    __SSEND1(st_perProc, @symbol(parentPid:), 0, __mkSmallInteger(pe32.th32ParentProcessID) );
+	    __SSEND1(list, @symbol(add:), 0, st_perProc );
+	}
+	while(Process32Next(hProcessSnap,&pe32));
+}
+#endif  /* TLHELP32_H_INCLUDE */
+%}.
+^ list
 !
 getCurrentProcess
 <apicall: handle "GetCurrentProcess" ( ) module: "kernel32.dll" >
 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"
 !
 hasConsole
 "return true, if there is some kind of console available
 (i.e. for proper stdIn, stdOut and stdErr handling).
-This only returns false when running �nder windows, and
+This only returns false when running nder windows, and
 the system is running as a pure windows application.
 If false, the miniDebugger is useless and not used."
 %{  /* NOCONTEXT */
 extern int __getNoConsoleFlag();
 %{
 HANDLE processHandle;
 int err;
 if (__isSmallInteger(pid)) {
-// assume, that synchronize needs less privilege...
+	// assume, that synchronize needs less privilege...
-processHandle = OpenProcess(SYNCHRONIZE, FALSE, __smallIntegerVal(pid));
+	processHandle = OpenProcess(SYNCHRONIZE, FALSE, __smallIntegerVal(pid));
-if (processHandle) {
+	if (processHandle) {
-CloseHandle(processHandle);
+	    CloseHandle(processHandle);
-RETURN(true);
+	    RETURN(true);
-}
+	}
-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.
 "
 OperatingSystem primGetHostName
 "
 !
 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!!"
 %{
 //    BOOLEAN RtlGenRandom(
 //      __out  PVOID RandomBuffer,
 //      __in   ULONG RandomBufferLength
 //    );
 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
 "
 OperatingSystem getEnvironment:'PATH'
 OperatingSystem setEnvironment:'PATH' to:('c:\cygwin\bin;' , (OperatingSystem getEnvironment:'PATH'))
 "
 !
 setLocaleInfo:anInfoDictionary
 %{
 if (__bothSmallInteger(y, m)
 && __bothSmallInteger(d, h)
 && __bothSmallInteger(min, s)) {
-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 = 0;
+	sysTime.wMilliseconds = 0;
-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)) {
-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 = 0;
+	sysTime.wMilliseconds = 0;
-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.
 "
 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.
 |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.
 documentation
 "
 	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 zunchst enttuscht.
-	Die UAC UserAccessControl verhindern dies n�mlich (selbs f�r den admin).
+	Die UAC UserAccessControl verhindern dies nmlich (selbs fr den admin).
 	Um dies zu umgehen:
 	To turn off UAC
 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|
 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|
 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
 ! !
 !Win32OperatingSystem class methodsFor:'documentation'!
 version
-^ '$Id: Win32OperatingSystem.st 10517 2010-04-26 18:26:38Z vranyj1 $'
+^ '$Id: Win32OperatingSystem.st 10520 2010-05-04 11:50:05Z vranyj1 $'
 !
 version_CVS
-^ '�Header: /cvs/stx/stx/libbasic/Win32OperatingSystem.st,v 1.401 2010/04/06 08:17:14 stefan Exp §'
+^ 'Header: /cvs/stx/stx/libbasic/Win32OperatingSystem.st,v 1.403 2010/04/30 13:52:43 ca Exp §'
 !
 version_SVN
-^ '$Id: Win32OperatingSystem.st 10517 2010-04-26 18:26:38Z vranyj1 $'
+^ '$Id: Win32OperatingSystem.st 10520 2010-05-04 11:50:05Z vranyj1 $'
 ! !
 Win32OperatingSystem initialize!
 Win32OperatingSystem::PerformanceData initialize!
 Win32OperatingSystem::RegistryEntry initialize!

branch	jv
changeset 17763	019bb9c842c5
parent 17761	b0e5971141bc
child 17767	a4a32df3aa5e