hg/stx-libbasic: comparison AbstractOperatingSystem.st

equal deleted inserted replaced

-:ff6ecefce66f
+:ac51b47d8768
 "
 COPYRIGHT (c) 1988 by Claus Gittinger
-	      All Rights Reserved
+All Rights Reserved
 This software is furnished under a license and may be used
 only in accordance with the terms of that license and with the
 inclusion of the above copyright notice.   This software may not
 be provided or otherwise made available to, or used by, any
 other person.  No title to or ownership of the software is
 hereby transferred.
 "
 Object subclass:#AbstractOperatingSystem
-	instanceVariableNames:''
+instanceVariableNames:''
-	classVariableNames:'ConcreteClass LastErrorNumber LocaleInfo OSSignals PipeFailed
+classVariableNames:'ConcreteClass LastErrorNumber LocaleInfo OSSignals PipeFailed
-		ErrorSignal AccessDeniedErrorSignal FileNotFoundErrorSignal
+ErrorSignal AccessDeniedErrorSignal FileNotFoundErrorSignal
-		InvalidArgumentsSignal UnsupportedOperationSignal'
+InvalidArgumentsSignal UnsupportedOperationSignal'
-	poolDictionaries:''
+poolDictionaries:''
-	category:'System-Support'
+category:'System-Support'
 !
 !AbstractOperatingSystem class methodsFor:'documentation'!
 copyright
 "
 COPYRIGHT (c) 1988 by Claus Gittinger
-	      All Rights Reserved
+All Rights Reserved
 This software is furnished under a license and may be used
 only in accordance with the terms of that license and with the
 inclusion of the above copyright notice.   This software may not
 be provided or otherwise made available to, or used by, any
 typically, services which can be implemented based upon more primitive
 functions, or which can be implemented in a portable way (but probably
 less performant) are implemented here.
 [Class variables:]
-	ConcreteClass   <Class>         the real OS class
+ConcreteClass   <Class>         the real OS class
-	LocaleInfo      <Dictionary>    if non nil, that is taken instead of the operating
+LocaleInfo      <Dictionary>    if non nil, that is taken instead of the operating
-					systems locale definitions (allows for overwriting
+systems locale definitions (allows for overwriting
-					these, or provide a compatible info on systems which do
+these, or provide a compatible info on systems which do
-					not support locales)
+not support locales)
-	LastErrorNumber <Integer>       the last value of errno
+LastErrorNumber <Integer>       the last value of errno
-	OSSignals       <Array>         Array of signals to be raised for corresponding
+OSSignals       <Array>         Array of signals to be raised for corresponding
-					OperatingSystem signals.
+OperatingSystem signals.
-	PipeFailed      <Boolean>       set if a fork (or popen) has failed;
+PipeFailed      <Boolean>       set if a fork (or popen) has failed;
-					ST/X will avoid doing more forks/popens
+ST/X will avoid doing more forks/popens
-					if this flag is set, for a slightly
+if this flag is set, for a slightly
-					smoother operation.
+smoother operation.
-	ErrorSignal     <Signal>        Parentsignal of all OS error signals.
+ErrorSignal     <Signal>        Parentsignal of all OS error signals.
-					not directly raised.
+not directly raised.
-	AccessDeniedErrorSignal         misc concrete error reporting signals
+AccessDeniedErrorSignal         misc concrete error reporting signals
-	FileNotFoundErrorSignal
+FileNotFoundErrorSignal
-	UnsupportedOperationSignal
+UnsupportedOperationSignal
-	InvalidArgumentsSignal
+InvalidArgumentsSignal
 [author:]
-	Claus Gittinger
+Claus Gittinger
 [see also:]
-	OSProcessStatus
+OSProcessStatus
-	Filename Date Time
+Filename Date Time
-	ExternalStream FileStream PipeStream Socket
+ExternalStream FileStream PipeStream Socket
 "
 !
 examples
 "
 various queries
-								[exBegin]
+[exBegin]
 Transcript
-	showCR:'hello ' , (OperatingSystem getLoginName)
+showCR:'hello ' , (OperatingSystem getLoginName)
-								[exEnd]
+[exEnd]
-								[exBegin]
+[exBegin]
 OperatingSystem isUNIXlike ifTrue:[
-	Transcript showCR:'this is some UNIX-like OS'
+Transcript showCR:'this is some UNIX-like OS'
 ] ifFalse:[
-	Transcript showCR:'this OS is not UNIX-like'
+Transcript showCR:'this OS is not UNIX-like'
 ]
-								[exEnd]
+[exEnd]
-								[exBegin]
+[exBegin]
 Transcript
-	showCR:'this machine is called ' , OperatingSystem getHostName
+showCR:'this machine is called ' , OperatingSystem getHostName
-								[exEnd]
+[exEnd]
-								[exBegin]
+[exBegin]
 Transcript
-	showCR:('this machine is in the '
+showCR:('this machine is in the '
-	       , OperatingSystem getDomainName
+, OperatingSystem getDomainName
-	       , ' domain')
+, ' domain')
-								[exEnd]
+[exEnd]
-								[exBegin]
+[exBegin]
 Transcript
-	showCR:('this machine''s CPU is a '
+showCR:('this machine''s CPU is a '
-	       , OperatingSystem getCPUType
+, OperatingSystem getCPUType
-	       )
+)
-								[exEnd]
+[exEnd]
-								[exBegin]
+[exBegin]
 Transcript showCR:'executing ls command ...'.
 OperatingSystem executeCommand:'ls'.
 Transcript showCR:'... done.'.
-								[exEnd]
+[exEnd]
 locking a file
 (should be executed on two running smalltalks - not in two threads):
-								[exBegin]
+[exBegin]
 |f|
 f := 'testFile' asFilename readWriteStream.
 10 timesRepeat:[
-	'about to lock ...' printCR.
+'about to lock ...' printCR.
-	[
+[
-	  OperatingSystem
+OperatingSystem
-	    lockFD:(f fileDescriptor)
+lockFD:(f fileDescriptor)
-	    shared:false
+shared:false
-	    blocking:false
+blocking:false
-	] whileFalse:[
+] whileFalse:[
-	    'process ' print. OperatingSystem getProcessId print. ' is waiting' printCR.
+'process ' print. OperatingSystem getProcessId print. ' is waiting' printCR.
-	    Delay waitForSeconds:1
+Delay waitForSeconds:1
-	].
+].
-	'LOCKED ...' printCR.
+'LOCKED ...' printCR.
-	Delay waitForSeconds:10.
+Delay waitForSeconds:10.
-	'unlock ...' printCR.
+'unlock ...' printCR.
-	(OperatingSystem
+(OperatingSystem
-	    unlockFD:(f fileDescriptor)) printCR.
+unlockFD:(f fileDescriptor)) printCR.
-	Delay waitForSeconds:3.
+Delay waitForSeconds:3.
 ]
-								[exBegin]
+[exBegin]
 "
 ! !
 !AbstractOperatingSystem class methodsFor:'initialization'!
 "initialize the class"
 self initializeConcreteClass.
 ErrorSignal isNil ifTrue:[
-	ErrorSignal := Object errorSignal newSignalMayProceed:true.
+ErrorSignal := Object errorSignal newSignalMayProceed:true.
-	ErrorSignal nameClass:self message:#errorSignal.
+ErrorSignal nameClass:self message:#errorSignal.
-	ErrorSignal notifierString:'OS error encountered'.
+ErrorSignal notifierString:'OS error encountered'.
-	AccessDeniedErrorSignal := ErrorSignal newSignalMayProceed:true.
+AccessDeniedErrorSignal := ErrorSignal newSignalMayProceed:true.
-	AccessDeniedErrorSignal nameClass:self message:#accessDeniedError.
+AccessDeniedErrorSignal nameClass:self message:#accessDeniedError.
-	AccessDeniedErrorSignal notifierString:'OS access denied'.
+AccessDeniedErrorSignal notifierString:'OS access denied'.
-	FileNotFoundErrorSignal := ErrorSignal newSignalMayProceed:true.
+FileNotFoundErrorSignal := ErrorSignal newSignalMayProceed:true.
-	FileNotFoundErrorSignal nameClass:self message:#fileNotFoundErrorSignal.
+FileNotFoundErrorSignal nameClass:self message:#fileNotFoundErrorSignal.
-	FileNotFoundErrorSignal notifierString:'OS file not found'.
+FileNotFoundErrorSignal notifierString:'OS file not found'.
-	InvalidArgumentsSignal := ErrorSignal newSignalMayProceed:true.
+InvalidArgumentsSignal := ErrorSignal newSignalMayProceed:true.
-	InvalidArgumentsSignal nameClass:self message:#invalidArgumentsSignal.
+InvalidArgumentsSignal nameClass:self message:#invalidArgumentsSignal.
-	InvalidArgumentsSignal notifierString:'bad arg to OS call'.
+InvalidArgumentsSignal notifierString:'bad arg to OS call'.
-	UnsupportedOperationSignal := ErrorSignal newSignalMayProceed:true.
+UnsupportedOperationSignal := ErrorSignal newSignalMayProceed:true.
-	UnsupportedOperationSignal nameClass:self message:#unsupportedOperationSignal.
+UnsupportedOperationSignal nameClass:self message:#unsupportedOperationSignal.
-	UnsupportedOperationSignal notifierString:'operation not supported by this OS'.
+UnsupportedOperationSignal notifierString:'operation not supported by this OS'.
 ]
 "Modified: / 19.5.1999 / 14:21:28 / cg"
 !
 initializeConcreteClass
 |osType cls|
 osType := self getSystemType.
 osType = 'win32' ifTrue:[
-	cls := Win32OperatingSystem
+cls := Win32OperatingSystem
 ] ifFalse:[
-	osType = 'os2' ifTrue:[
+osType = 'os2' ifTrue:[
-	    cls := OS2OperatingSystem
+cls := OS2OperatingSystem
-	] ifFalse:[
+] ifFalse:[
-	    osType = 'macos' ifTrue:[
+osType = 'macos' ifTrue:[
-		cls := MacOperatingSystem
+cls := MacOperatingSystem
-	    ] ifFalse:[
+] ifFalse:[
-		((osType = 'VMS') or:[osType = 'openVMS']) ifTrue:[
+((osType = 'VMS') or:[osType = 'openVMS']) ifTrue:[
-		    cls := OpenVMSOperatingSystem
+cls := OpenVMSOperatingSystem
-		] ifFalse:[
+] ifFalse:[
-		    cls := UnixOperatingSystem
+cls := UnixOperatingSystem
-		]
+]
-	    ]
+]
-	]
+]
 ].
 OperatingSystem := ConcreteClass := cls.
 ! !
 !AbstractOperatingSystem class methodsFor:'OS signal constants'!
 clearLastErrorNumber
 "return the last errors number.
 See also: #lastErrorSymbol and #lastErrorString.
 Notice: having a single error number is a bad idea in a multithreaded
-	     environment - this interface will change."
+environment - this interface will change."
 LastErrorNumber := nil.
 "
 AbstractOperatingSystem clearLastErrorNumber
 (as returned by a system call).
 The returned message is in english (as found in /usr/include/errno.h)
 and should be replaced by a resource lookup before being presented to the user."
 ^ Array
-	with:#'ERROR_OTHER'
+with:#'ERROR_OTHER'
-	with:('ErrorNr: ' , errNr printString)
+with:('ErrorNr: ' , errNr printString)
 "
 OperatingSystem errorSymbolAndTextForNumber:4
 "
 !
 lastErrorNumber
 "return the last errors number.
 See also: #lastErrorSymbol and #lastErrorString.
 Notice: having a single error number is a bad idea in a multithreaded
-	     environment - this interface will change."
+environment - this interface will change."
 ^ LastErrorNumber
 "
 OperatingSystem lastErrorNumber
 lastErrorString
 "return a message string describing the last error.
 See also: #lastErrorNumber and #lastErrorSymbol.
 Notice: having a single error number is a bad idea in a multithreaded
-	     environment - this interface will change."
+environment - this interface will change."
 LastErrorNumber isNil ifTrue:[^ nil].
 ^ self errorTextForNumber:LastErrorNumber
 "
 lastErrorSymbol
 "return a symbol (such as #EBADF or #EACCESS) describing the last error.
 See also: #lastErrorNumber and #lastErrorString.
 Notice: having a single error number is a bad idea in a multithreaded
-	     environment - this interface will change."
+environment - this interface will change."
 LastErrorNumber isNil ifTrue:[^ nil].
 ^ self errorSymbolForNumber:LastErrorNumber
 "
 If successful, this method does NOT return and smalltalk is gone.
 If not successful, it does return.
 Can be used on UNIX with fork or on other systems to chain to another program."
 ^ self
-	exec:aCommandPath
+exec:aCommandPath
-	withArguments:argArray
+withArguments:argArray
-	environment:nil
+environment:nil
-	fileDescriptors:nil
+fileDescriptors:nil
-	closeDescriptors:nil
+closeDescriptors:nil
-	fork:false
+fork:false
-	newPgrp:false
+newPgrp:false
-	inDirectory:nil
+inDirectory:nil
 "/ never reached ...
 "Modified: / 12.11.1998 / 14:44:26 / cg"
 !
 exec:aCommandPath withArguments:argColl environment:env fileDescriptors:fdColl closeDescriptors:closeFdColl fork:doFork newPgrp:newPgrp
 "Internal lowLevel entry for combined fork & exec;
 If fork is false (chain a command):
-	 execute the OS command specified by the argument, aCommandPath, with
+execute the OS command specified by the argument, aCommandPath, with
-	 arguments in argArray (no arguments, if nil).
+arguments in argArray (no arguments, if nil).
-	 If successful, this method does not return and smalltalk is gone.
+If successful, this method does not return and smalltalk is gone.
-	 If not successful, it does return.
+If not successful, it does return.
-	 Normal use is with forkForCommand.
+Normal use is with forkForCommand.
 If fork is true (subprocess command execution):
-	fork a child to do the above.
+fork a child to do the above.
-	The process id of the child process is returned; nil if the fork failed.
+The process id of the child process is returned; nil if the fork failed.
 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.
 closeFdArray contains descriptors that will be closed in the subprocess.
-	closeDescriptors are ignored in the WIN32 & VMS versions.
+closeDescriptors are ignored in the WIN32 & VMS versions.
 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.
 env specifies environment variables which are passed differently from
 the current environment. If non-nil, it must be a dictionary providing
 key-value pairs for changed/added environment variables.
 To pass a variable as empty (i.e. unset), pass a nil value.
 Notice: this used to be two separate ST-methods; however, in order to use
-	    vfork on some machines, it had to be merged into one, to avoid write
+vfork on some machines, it had to be merged into one, to avoid write
-	    accesses to ST/X memory from the vforked-child.
+accesses to ST/X memory from the vforked-child.
-	    The code below only does read accesses."
+The code below only does read accesses."
 ^ self
-	exec:aCommandPath
+exec:aCommandPath
-	withArguments:argColl
+withArguments:argColl
-	environment:env
+environment:env
-	fileDescriptors:fdColl
+fileDescriptors:fdColl
-	closeDescriptors:closeFdColl
+closeDescriptors:closeFdColl
-	fork:doFork
+fork:doFork
-	newPgrp:newPgrp
+newPgrp:newPgrp
-	inDirectory:nil
+inDirectory:nil
 "
 |id|
 id := OperatingSystem fork.
 id == 0 ifTrue:[
-	'I am the child'.
+'I am the child'.
-	OperatingSystem exec:'/bin/ls' withArguments:#('ls' '/tmp').
+OperatingSystem exec:'/bin/ls' withArguments:#('ls' '/tmp').
-	'not reached'.
+'not reached'.
 ]
 "
 "
 |id|
 id := OperatingSystem fork.
 id == 0 ifTrue:[
-	'I am the child'.
+'I am the child'.
-	OperatingSystem
+OperatingSystem
-	   exec:'/bin/sh'
+exec:'/bin/sh'
-	   withArguments:#('sh' '-c' 'sleep 2;echo 1;sleep 2;echo 2').
+withArguments:#('sh' '-c' 'sleep 2;echo 1;sleep 2;echo 2').
-	'not reached'.
+'not reached'.
 ].
 id printNL.
 (Delay forSeconds:3.5) wait.
 'killing ...' printNL.
 OperatingSystem sendSignal:(OperatingSystem sigTERM) to:id.
 !
 exec:aCommandPath withArguments:argArray fileDescriptors:fdArray closeDescriptors:closeFdArray fork:doFork newPgrp:newPgrp
 "combined fork & exec;
 If fork is false (chain a command):
-	 execute the OS command specified by the argument, aCommandPath, with
+execute the OS command specified by the argument, aCommandPath, with
-	 arguments in argArray (no arguments, if nil).
+arguments in argArray (no arguments, if nil).
-	 If successful, this method does not return and smalltalk is gone.
+If successful, this method does not return and smalltalk is gone.
-	 If not successful, it does return.
+If not successful, it does return.
-	 Normal use is with forkForCommand.
+Normal use is with forkForCommand.
 If fork is true (subprocess command execution):
-	fork a child to do the above.
+fork a child to do the above.
-	The process id of the child process is returned; nil if the fork failed.
+The process id of the child process is returned; nil if the fork failed.
 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.
 closeFdArray contains descriptors that will be closed in the subprocess.
-	closeDescriptors are ignored in the WIN32 & VMS versions.
+closeDescriptors are ignored in the WIN32 & VMS versions.
 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.
 Notice: this used to be two separate ST-methods; however, in order to use
-	    vfork on some machines, it had to be merged into one, to avoid write
+vfork on some machines, it had to be merged into one, to avoid write
-	    accesses to ST/X memory from the vforked-child.
+accesses to ST/X memory from the vforked-child.
-	    The code below only does read accesses."
+The code below only does read accesses."
 ^ self
-	exec:aCommandPath
+exec:aCommandPath
-	withArguments:argArray
+withArguments:argArray
-	environment:nil
+environment:nil
-	fileDescriptors:fdArray
+fileDescriptors:fdArray
-	closeDescriptors:closeFdArray
+closeDescriptors:closeFdArray
-	fork:doFork
+fork:doFork
-	newPgrp:newPgrp
+newPgrp:newPgrp
-	inDirectory:nil
+inDirectory:nil
 "
 |id|
 id := OperatingSystem fork.
 id == 0 ifTrue:[
-	'I am the child'.
+'I am the child'.
-	OperatingSystem exec:'/bin/ls' withArguments:#('ls' '/tmp').
+OperatingSystem exec:'/bin/ls' withArguments:#('ls' '/tmp').
-	'not reached'.
+'not reached'.
 ]
 "
 "
 |id|
 id := OperatingSystem fork.
 id == 0 ifTrue:[
-	'I am the child'.
+'I am the child'.
-	OperatingSystem
+OperatingSystem
-	   exec:'/bin/sh'
+exec:'/bin/sh'
-	   withArguments:#('sh' '-c' 'sleep 2;echo 1;sleep 2;echo 2').
+withArguments:#('sh' '-c' 'sleep 2;echo 1;sleep 2;echo 2').
-	'not reached'.
+'not reached'.
 ].
 id printNL.
 (Delay forSeconds:3.5) wait.
 'killing ...' printNL.
 OperatingSystem sendSignal:(OperatingSystem sigTERM) to:id.
 exec:aCommandPath withArguments:argArray fileDescriptors:fdArray closeDescriptors:closeFdArray fork:doFork newPgrp:newPgrp inDirectory:aDirectory
 "Internal lowLevel entry for combined fork & exec for WIN32.
 Not needed with Unix"
 ^ self
-	exec:aCommandPath
+exec:aCommandPath
-	withArguments:argArray
+withArguments:argArray
-	environment:nil
+environment:nil
-	fileDescriptors:fdArray
+fileDescriptors:fdArray
-	closeDescriptors:closeFdArray
+closeDescriptors:closeFdArray
-	fork:doFork
+fork:doFork
-	newPgrp:newPgrp
+newPgrp:newPgrp
-	inDirectory:aDirectory
+inDirectory:aDirectory
 "Modified: / 12.11.1998 / 14:47:58 / cg"
 "Created: / 12.11.1998 / 14:49:18 / cg"
 !
 The command reads its input and writes its output
 from/to whatever terminal device ST/X was started
 (typically, the xterm window)"
 ^ self
-	exec:aCommandPath
+exec:aCommandPath
-	withArguments:argArray
+withArguments:argArray
-	environment:nil
+environment:nil
-	fileDescriptors:nil
+fileDescriptors:nil
-	closeDescriptors:nil
+closeDescriptors:nil
-	fork:doFork
+fork:doFork
-	newPgrp:false
+newPgrp:false
-	inDirectory:nil
+inDirectory:nil
 "
 |id|
 id := OperatingSystem fork.
 id == 0 ifTrue:[
-	'I am the child'.
+'I am the child'.
-	OperatingSystem
+OperatingSystem
-	    exec:'/bin/ls'
+exec:'/bin/ls'
-	    withArguments:#('ls' '/tmp')
+withArguments:#('ls' '/tmp')
-	    fork:false.
+fork:false.
-	'not reached'.
+'not reached'.
 ]
 "
 "
 |id|
 id := OperatingSystem fork.
 id == 0 ifTrue:[
-	'I am the child'.
+'I am the child'.
-	OperatingSystem
+OperatingSystem
-	    exec:'/bin/sh'
+exec:'/bin/sh'
-	    withArguments:#('sh' '-c' 'sleep 2;echo 1;sleep 2;echo 2')
+withArguments:#('sh' '-c' 'sleep 2;echo 1;sleep 2;echo 2')
-	    fork:false.
+fork:false.
-	'not reached'.
+'not reached'.
 ].
 id printNL.
 (Delay forSeconds:3.5) wait.
 'killing ...' printNL.
 OperatingSystem sendSignal:(OperatingSystem sigTERM) to:id.
 The command reads its input and writes its output
 from/to whatever terminal device ST/X was started
 (typically, the xterm window)"
 ^ self
-	exec:aCommandPath
+exec:aCommandPath
-	withArguments:argArray
+withArguments:argArray
-	environment:nil
+environment:nil
-	fileDescriptors:nil
+fileDescriptors:nil
-	closeDescriptors:nil
+closeDescriptors:nil
-	fork:doFork
+fork:doFork
-	newPgrp:false
+newPgrp:false
-	inDirectory:aDirectory
+inDirectory:aDirectory
 "
 |id|
 id := OperatingSystem fork.
 id == 0 ifTrue:[
-	'I am the child'.
+'I am the child'.
-	OperatingSystem
+OperatingSystem
-	    exec:'/bin/ls'
+exec:'/bin/ls'
-	    withArguments:#('ls' '/tmp')
+withArguments:#('ls' '/tmp')
-	    fork:false.
+fork:false.
-	'not reached'.
+'not reached'.
 ]
 "
 "
 |id|
 id := OperatingSystem fork.
 id == 0 ifTrue:[
-	'I am the child'.
+'I am the child'.
-	OperatingSystem
+OperatingSystem
-	    exec:'/bin/sh'
+exec:'/bin/sh'
-	    withArguments:#('sh' '-c' 'sleep 2;echo 1;sleep 2;echo 2')
+withArguments:#('sh' '-c' 'sleep 2;echo 1;sleep 2;echo 2')
-	    fork:false.
+fork:false.
-	'not reached'.
+'not reached'.
 ].
 id printNL.
 (Delay forSeconds:3.5) wait.
 'killing ...' printNL.
 OperatingSystem sendSignal:(OperatingSystem sigTERM) to:id.
 The commandString is passed to a shell for execution - see the description of
 'sh -c' in your UNIX manual.
 Return true if successful, false otherwise."
 ^ self
-	executeCommand:aCommandString
+executeCommand:aCommandString
-	inputFrom:nil
+inputFrom:nil
-	outputTo:nil
+outputTo:nil
-	errorTo:nil
+errorTo:nil
-	inDirectory:nil
+inDirectory:nil
-	onError:[:status| false]
+onError:[:status| false]
 "unix:
 OperatingSystem executeCommand:'sleep 30'.
 OperatingSystem executeCommand:'pwd'.
 Return true if successful.
 If not successfull, aBlock is called with an OsProcessStatus
 (containing the exit status) as argument."
 ^ self
-	executeCommand:aCommandString
+executeCommand:aCommandString
-	inputFrom:anExternalInStream
+inputFrom:anExternalInStream
-	outputTo:anExternalOutStream
+outputTo:anExternalOutStream
-	errorTo:anExternalErrStream
+errorTo:anExternalErrStream
-	inDirectory:nil
+inDirectory:nil
-	onError:aBlock
+onError:aBlock
 "
-	OperatingSystem
+OperatingSystem
-	    executeCommand:'dir'
+executeCommand:'dir'
-	    inputFrom:nil
+inputFrom:nil
-	    outputTo:nil
+outputTo:nil
-	    errorTo:nil
+errorTo:nil
-	    onError:[:status | Transcript flash]
+onError:[:status | Transcript flash]
-	OperatingSystem
+OperatingSystem
-	    executeCommand:'foo'
+executeCommand:'foo'
-	    inputFrom:nil
+inputFrom:nil
-	    outputTo:nil
+outputTo:nil
-	    errorTo:nil
+errorTo:nil
-	    onError:[:status | Transcript flash]
+onError:[:status | Transcript flash]
 "
 "Modified: / 10.11.1998 / 20:51:39 / cg"
 !
 Return true if successful.
 If not successfull, aBlock is called with an OsProcessStatus
 (containing the exit status) as argument."
 ^ self
-	executeCommand:aCommandString
+executeCommand:aCommandString
-	inputFrom:nil
+inputFrom:nil
-	outputTo:nil
+outputTo:nil
-	errorTo:nil
+errorTo:nil
-	inDirectory:nil
+inDirectory:nil
-	onError:aBlock
+onError:aBlock
 "unix:
 OperatingSystem executeCommand:'sleep 30' onError:[].
 OperatingSystem executeCommand:'pwd' onError:[:status|status inspect].
 if the command fails, nil is returned."
 |result|
 PipeFailed ~~ true ifTrue:[
-	PipeStream openErrorSignal handle:[:ex |
+PipeStream openErrorSignal handle:[:ex |
-	    PipeFailed := true.
+PipeFailed := true.
-	    'OperatingSystem [warning]: cannot fork/popen' errorPrintCR.
+'OperatingSystem [warning]: cannot fork/popen' errorPrintCR.
-	    ex return.
+ex return.
-	] do:[
+] do:[
-	    |p|
+|p|
-	    p := PipeStream
+p := PipeStream
-		    readingFrom:aCommand
+readingFrom:aCommand
-		    errorDisposition:#discard
+errorDisposition:#discard
-		    inDirectory:nil.
+inDirectory:nil.
-	    p notNil ifTrue:[
+p notNil ifTrue:[
-		p atEnd ifTrue:[
+p atEnd ifTrue:[
-		    result := ''
+result := ''
-		] ifFalse:[
+] ifFalse:[
-		    result := p nextLine.
+result := p nextLine.
-		].
+].
-		p close
+p close
-	    ].
+].
-	].
+].
 ].
 ^ result
 "
 OperatingSystem getCommandOutputFrom:'hostname'
 Return the processId if successful, nil otherwise.
 Use #waitForProcess: for synchronization and exec status return,
 or #killProcess: to stop it."
 ^ self
-	startProcess:aCommandString
+startProcess:aCommandString
-	inputFrom:nil
+inputFrom:nil
-	outputTo:nil
+outputTo:nil
-	errorTo:nil
+errorTo:nil
-	inDirectory:nil
+inDirectory:nil
 "
 |pid|
 pid := OperatingSystem startProcess:'sleep 2; echo 1; sleep 2; echo 2'.
 "
 "
 |pid|
 pid := OperatingSystem
-		startProcess:'dir/l'
+startProcess:'dir/l'
-		inputFrom:nil
+inputFrom:nil
-		outputTo:Stdout
+outputTo:Stdout
-		errorTo:nil
+errorTo:nil
-		inDirectory:nil.
+inDirectory:nil.
 (Delay forSeconds:2) wait.
 OperatingSystem killProcess:pid.
 "
 "Modified: / 21.3.1997 / 10:04:35 / dq"
 Return the processId if successful, nil otherwise.
 Use #waitForProcess: for synchronization and exec status return,
 or #killProcess: to stop it."
 ^ self
-	startProcess:aCommandString
+startProcess:aCommandString
-	inputFrom:nil
+inputFrom:nil
-	outputTo:nil
+outputTo:nil
-	errorTo:nil
+errorTo:nil
-	inDirectory:aDirectory
+inDirectory:aDirectory
 "
 |pid|
 pid := OperatingSystem startProcess:'sleep 2; echo 1; sleep 2; echo 2'.
 (Delay forSeconds:3) wait.
 Return the processId if successful, nil otherwise.
 Use #monitorPid:action: for synchronization and exec status return,
 or #killProcess: to stop it."
 ^ self
-	startProcess:aCommandString
+startProcess:aCommandString
-	inputFrom:anExternalInStream
+inputFrom:anExternalInStream
-	outputTo:anExternalOutStream
+outputTo:anExternalOutStream
-	errorTo:anExternalErrStream
+errorTo:anExternalErrStream
-	inDirectory:nil
+inDirectory:nil
 "Modified: / 10.11.1998 / 20:59:05 / cg"
 !
 startProcess:aCommandString inputFrom:anExternalInStream outputTo:anExternalOutStream errorTo:anExternalErrStream inDirectory:dir
 files/directories recursively to destinationPathName.
 Return true if successful.
 Here, false is returned and the caller should be prepared
 for a fallBack solution.
 Notice:
-	this is not a public interface; instead, it is used
+this is not a public interface; instead, it is used
-	internally by the Filename class, to try a fast copy
+internally by the Filename class, to try a fast copy
-	before doing things manually.
+before doing things manually.
-	Please use Filename recursiveCopyTo:"
+Please use Filename recursiveCopyTo:"
 ^ false
 "
 OperatingSystem recursiveCopyDirectory:'.' to:'/tmp/foo'
 is returned, a partial created tree may be left,
 which is not cleaned-up here."
 self createDirectory:dirName.
 (self isDirectory:dirName) ifFalse:[
-	(self recursiveCreateDirectory:(dirName asFilename directoryName)) ifFalse:[^ false].
+(self recursiveCreateDirectory:(dirName asFilename directoryName)) ifFalse:[^ false].
-	^ self createDirectory:dirName
+^ self createDirectory:dirName
 ].
 ^ true
 "
 OperatingSystem recursiveCreateDirectory:'foo/bar/baz'
 "remove the directory named 'fullPathName' and all contained files/directories.
 Return true if successful.
 Here, false is returned and the caller should be prepared
 for a fallBack solution.
 Notice:
-	this is not a public interface; instead, it is used
+this is not a public interface; instead, it is used
-	internally by the Filename class, to try a fast remove
+internally by the Filename class, to try a fast remove
-	before doing things manually.
+before doing things manually.
-	Please use Filename recursiveRemoveDirectory:"
+Please use Filename recursiveRemoveDirectory:"
 ^ false
 "
 OperatingSystem recursiveCreateDirectory:'foo/bar/baz'
 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
 "
 ^ (self infoOf:aPathName) at:#mode
 "/
 "/ default: return an array filled with
 "/ root, home and current directories.
 "/
 ^ Array
-	with:'/'
+with:'/'
-	with:(self getHomeDirectory)
+with:(self getHomeDirectory)
-	with:(Filename currentDirectory pathName)
+with:(Filename currentDirectory pathName)
 "Modified: / 5.5.1999 / 01:06:26 / cg"
+!
+getMountedVolumes
+"return info about mounted volumes.
+The amount of information returned depends upon the OS, and is
+not guaranteed to be consistent across architectures.
+On unix, the information returned is (at least):
+mountPoint - mount point
+fileSystem - device or NFS-remotePath
+"
+^ #()
+"
+OperatingSystem getMountedVolumes
+"
+"Modified: / 22.5.1999 / 00:36:06 / cg"
 !
 getNullDevice
 "get the name of the null-device. Nil is returned if not supported"
 infoOf:aPathName
 "return some object filled with info for the file 'aPathName';
 the info (for which corresponding access methods are understood by
 the returned object) is:
-	 type            - a symbol giving the files type
+type            - a symbol giving the files type
-	 mode            - numeric access mode
+mode            - numeric access mode
-	 uid             - owners user id
+uid             - owners user id
-	 gid             - owners group id
+gid             - owners group id
-	 size            - files size
+size            - files size
-	 id              - files number (i.e. inode number)
+id              - files number (i.e. inode number)
-	 accessed        - last access time (as Timestamp)
+accessed        - last access time (as Timestamp)
-	 modified        - last modification time (as Timestamp)
+modified        - last modification time (as Timestamp)
-	 statusChanged   - last status change time (as Timestamp)
+statusChanged   - last status change time (as Timestamp)
-	 alternativeName - (windows only: the MSDOS name of the file)
+alternativeName - (windows only: the MSDOS name of the file)
 Some of the fields may be returned as nil on systems which do not provide
 all of the information.
 Return nil if such a file does not exist.
 For symbolic links (if supported by the OS),
 !
 disableTimer
 "disable timer interrupts.
 WARNING:
-	the system will not operate correctly with timer interrupts
+the system will not operate correctly with timer interrupts
-	disabled, because no scheduling or timeouts are possible."
+disabled, because no scheduling or timeouts are possible."
 self subclassResponsibility
 !
 disableUserInterrupts
 "disable userInterrupt processing;
 when disabled, no ^C processing takes place.
 WARNING:
-	 If at all, use this only for debugged stand-alone applications, since
+If at all, use this only for debugged stand-alone applications, since
-	 no exit to the debugger is possible with user interrupts disabled.
+no exit to the debugger is possible with user interrupts disabled.
-	 We recommend setting up a handler for the signal instead of disabling it."
+We recommend setting up a handler for the signal instead of disabling it."
 self disableSignal:(self sigBREAK).
 self disableSignal:(self sigINT).
 !
 killProcess:processId
 "kill an OS process.
 The process has a no chance to do some cleanup.
 WARNING: in order to avoid zombie processes (on unix),
-	      you may have to fetch the processes exitstatus with
+you may have to fetch the processes exitstatus with
-	      OperatingSystem>>getStatusOfProcess:aProcessId."
+OperatingSystem>>getStatusOfProcess:aProcessId."
 self subclassResponsibility
 "Modified: / 10.6.1998 / 12:00:07 / cg"
 !
 killProcessGroup:processGroupId
 "kill an OS process group.
 The process has NO chance to do some cleanup.
 WARNING: in order to avoid zombie processes (on unix),
-	      you may have to fetch the processes exitstatus with
+you may have to fetch the processes exitstatus with
-	      OperatingSystem>>getStatusOfProcess:aProcessId."
+OperatingSystem>>getStatusOfProcess:aProcessId."
 self subclassResponsibility
 "Created: / 10.6.1998 / 12:00:26 / cg"
 !
 aSignalNumber == self sigRETRACT ifTrue:[^ 'HFT access relinquish'].
 aSignalNumber == self sigSOUND   ifTrue:[^ 'HFT sound complete'].
 aSignalNumber == self sigDANGER  ifTrue:[^ 'low on paging space'].
 "notice: many systems map SIGPOLL and/or SIGUSR onto SIGIO
-	     therefore, keep SIGIO always above the two below"
+therefore, keep SIGIO always above the two below"
 aSignalNumber == self sigPOLL   ifTrue:[^ 'io available'].
 aSignalNumber == self sigURG    ifTrue:[^ 'urgent'].
 ^ 'unknown signal'
 operatingSystemSignal:signalNumber
 "return the signal to be raised when an
 operatingSystem-signal occurs, or nil"
 OSSignals notNil ifTrue:[
-	^ OSSignals at:signalNumber ifAbsent:[nil]
+^ OSSignals at:signalNumber ifAbsent:[nil]
 ].
 ^ nil
 !
 operatingSystemSignal:signalNumber install:aSignal
 "install a signal to be raised when an operatingSystem-signal occurs"
 OSSignals isNil ifTrue:[
-	OSSignals := Array new:32
+OSSignals := Array new:32
 ].
 OSSignals at:signalNumber put:aSignal
 !
 sendSignal:signalNumber to:processId
 Returns false if any error occurred, true otherwise.
 Do not confuse UNIX signals with Smalltalk-Signals.
 WARNING: in order to avoid zombie processes (on unix),
-	      you may have to fetch the processes exitstatus with
+you may have to fetch the processes exitstatus with
-	      OperatingSystem>>getStatusOfProcess:aProcessId
+OperatingSystem>>getStatusOfProcess:aProcessId
-	      if the signal terminates that process."
+if the signal terminates that process."
 self subclassResponsibility
 !
 startSpyTimer
 Return true, if the spy-timerInterrupt was enabled.
 This was used by the old MessageTally for profiling.
 On systems, where no virtual timer is available, use the real timer
 (which is of course less correct).
 OBSOLETE: the new messageTally runs as a high prio process, not using
-	       spy interrupts."
+spy interrupts."
 ^ false
 !
 stopSpyTimer
 "stop spy timing - disable spy timer.
 OBSOLETE: the new messageTally runs as a high prio process, not using
-	       spy interrupts."
+spy interrupts."
 ^ false
 !
 terminateProcess:processId
 "terminate a unix process.
 The process has a chance to do some cleanup.
 WARNING: in order to avoid zombie processes (on unix),
-	      you may have to fetch the processes exitstatus with
+you may have to fetch the processes exitstatus with
-	      OperatingSystem>>getStatusOfProcess:aProcessId."
+OperatingSystem>>getStatusOfProcess:aProcessId."
 self subclassResponsibility
 !
 terminateProcessGroup:processGroupId
 "terminate a unix process group.
 The process has a chance to do some cleanup.
 WARNING: in order to avoid zombie processes (on unix),
-	      you may have to fetch the processes exitstatus with
+you may have to fetch the processes exitstatus with
-	      OperatingSystem>>getStatusOfProcess:aProcessId."
+OperatingSystem>>getStatusOfProcess:aProcessId."
 self subclassResponsibility
 !
 unblockInterrupts
 %{  /* NOCONTEXT */
 int code = 1;
 if (__isSmallInteger(exitCode)) {
-	code = __intVal(exitCode);
+code = __intVal(exitCode);
 }
 __mainExit(code);
 %}
 "OperatingSystem exit:1 - dont evaluate this"
 !
 !
 getDomainName
 "return the domain this host is in.
 Notice:
-	not all systems support this; on some, 'unknown' is returned."
+not all systems support this; on some, 'unknown' is returned."
 self subclassResponsibility
 !
 getEnvironment:aStringOrSymbol
 getHostName
 "return the hostname we are running on - if there is
 a HOST environment variable, we are much faster here ...
 Notice:
-	not all systems support this; on some, 'unknown' is returned."
+not all systems support this; on some, 'unknown' is returned."
 self subclassResponsibility
 !
 getLocaleInfo
 "return a dictionary filled with values from the locale information;
 Not all fields may be present, depending on the OS's setup and capabilities.
 Possible fields are:
-	decimalPoint                    <String>
+decimalPoint                    <String>
-	thousandsSep                    <String>
+thousandsSep                    <String>
-	internationalCurrencySymbol     <String>
+internationalCurrencySymbol     <String>
-	currencySymbol                  <String>
+currencySymbol                  <String>
-	monetaryDecimalPoint            <String>
+monetaryDecimalPoint            <String>
-	monetaryThousandsSeparator      <String>
+monetaryThousandsSeparator      <String>
-	positiveSign                    <String>
+positiveSign                    <String>
-	negativeSign                    <String>
+negativeSign                    <String>
-	internationalFractionalDigits   <Integer>
+internationalFractionalDigits   <Integer>
-	fractionalDigits                <Integer>
+fractionalDigits                <Integer>
-	positiveSignPrecedesCurrencySymbol      <Boolean>
+positiveSignPrecedesCurrencySymbol      <Boolean>
-	negativeSignPrecedesCurrencySymbol      <Boolean>
+negativeSignPrecedesCurrencySymbol      <Boolean>
-	positiveSignSeparatedBySpaceFromCurrencySymbol  <Boolean>
+positiveSignSeparatedBySpaceFromCurrencySymbol  <Boolean>
-	negativeSignSeparatedBySpaceFromCurrencySymbol  <Boolean>
+negativeSignSeparatedBySpaceFromCurrencySymbol  <Boolean>
-	positiveSignPosition                            <Symbol>
+positiveSignPosition                            <Symbol>
-							one of: #parenthesesAround,
+one of: #parenthesesAround,
-								#signPrecedes,
+#signPrecedes,
-								#signSuceeds,
+#signSuceeds,
-								#signPrecedesCurrencySymbol,
+#signPrecedesCurrencySymbol,
-								#signSuceedsCurrencySymbol
+#signSuceedsCurrencySymbol
-	negativeSignPosition                            <like above>
+negativeSignPosition                            <like above>
 it is up to the application to deal with undefined values.
 Notice, that (for now), the system does not use this information;
 it should be used by applications as required.
 getSystemID
 "if supported by the OS, return the systemID;
 a unique per machine identification.
 WARNING:
-	not all systems support this; on some, 'unknown' is returned."
+not all systems support this; on some, 'unknown' is returned."
 ^ 'unknown'
 "
 OperatingSystem getSystemID
 OS, for example, linux returns 'ix86', while WIN32 returns 'x86'.
 This method is mainly provided to augment error reports with some system
 information.
 (in case of system/version specific OS errors, conditional workarounds and patches
-	may be based upon this info).
+may be based upon this info).
 Your application should NOT depend upon this in any way.
 The returned info may (or may not) contain:
-	#system -> some operating system identification (irix, Linux, nt, win32s ...)
+#system -> some operating system identification (irix, Linux, nt, win32s ...)
-	#version -> OS version (some os version identification)
+#version -> OS version (some os version identification)
-	#release -> OS release (3.5, 1.2.1 ...)
+#release -> OS release (3.5, 1.2.1 ...)
-	#node   -> some host identification (hostname)
+#node   -> some host identification (hostname)
-	#domain  -> domain name (hosts domain)
+#domain  -> domain name (hosts domain)
-	#machine -> type of machine (i586, mips ...)
+#machine -> type of machine (i586, mips ...)
 "
 |info|
 info := IdentityDictionary new.
 !
 maxFileNameLength
 "return the max number of characters in a filename.
 CAVEAT:
-	 Actually, the following is somewhat wrong - some systems
+Actually, the following is somewhat wrong - some systems
-	 support different sizes, depending on the volume.
+support different sizes, depending on the volume.
-	 We return a somewhat conservative number here.
+We return a somewhat conservative number here.
-	 Another entry, to query for volume specific max
+Another entry, to query for volume specific max
-	 will be added in the future."
+will be added in the future."
 self subclassResponsibility
 !
 maxPathLength
 "/
 "/ the users home (login) directory
 "/
 homePath := OperatingSystem getHomeDirectory.
 homePath notNil ifTrue:[
-	sysPath add:homePath.
+sysPath add:homePath.
-	"/
+"/
-	"/ a users private smalltalk directory in its home (login) directory
+"/ a users private smalltalk directory in its home (login) directory
-	"/
+"/
-	OperatingSystem isUNIXlike ifTrue:[
+OperatingSystem isUNIXlike ifTrue:[
-	    priv := '.smalltalk'.
+priv := '.smalltalk'.
-	] ifFalse:[
+] ifFalse:[
-	    priv := 'smalltalk'.
+priv := 'smalltalk'.
-	].
+].
-	userPrivateSTXDir := homePath asFilename constructString:priv.
+userPrivateSTXDir := homePath asFilename constructString:priv.
-	(userPrivateSTXDir asFilename isDirectory) ifTrue:[
+(userPrivateSTXDir asFilename isDirectory) ifTrue:[
-	    sysPath add:userPrivateSTXDir
+sysPath add:userPrivateSTXDir
-	].
+].
 ].
 "/
 "/ SMALLTALK_LIBDIR and/or STX_LIBDIR from the environment
 "/
 p := OperatingSystem getEnvironment:'SMALLTALK_LIBDIR'.
 p notNil ifTrue:[
-	sysPath add:p
+sysPath add:p
 ].
 p := OperatingSystem getEnvironment:'STX_LIBDIR'.
 p notNil ifTrue:[
-	sysPath add:p
+sysPath add:p
 ].
 ^ sysPath
 ! !
 !AbstractOperatingSystem class methodsFor:'private'!
 Since this value is wrapping around in regular intervals, this can only be used for
 short relative time deltas.
 Use the millisecondTimeXXX:-methods to compare and add time deltas - these know about the wrap.
 BAD DESIGN:
-	This should be changed to return some instance of RelativeTime,
+This should be changed to return some instance of RelativeTime,
-	and these computations moved there.
+and these computations moved there.
 Dont use this method in application code since it is an internal (private)
 interface. For compatibility with ST-80, use Time millisecondClockValue.
 "
 now := self getMillisecondTime.
 then := self millisecondTimeAdd:now and:millis.
 [self millisecondTime:then isAfter:now] whileTrue:[
-	delta := self millisecondTimeDeltaBetween:then and:now.
+delta := self millisecondTimeDeltaBetween:then and:now.
-	self selectOnAnyReadable:nil writable:nil exception:nil withTimeOut:delta.
+self selectOnAnyReadable:nil writable:nil exception:nil withTimeOut:delta.
-	now := self getMillisecondTime.
+now := self getMillisecondTime.
 ]
 "
 OperatingSystem millisecondDelay:2000
 "
 (such as returned getMillisecondTime) which wrap at 16r1FFFFFFF.
 This should really be moved to some RelativeTime class."
 (msTime1 > msTime2) ifTrue:[
-	((msTime1 - msTime2) >= 16r10000000) ifTrue:[
+((msTime1 - msTime2) >= 16r10000000) ifTrue:[
-	    ^ false
+^ false
-	].
+].
-	^ true
+^ true
 ].
 ((msTime2 - msTime1) > 16r10000000) ifTrue:[
-	^ true
+^ true
 ].
 ^ false
 !
 millisecondTimeAdd:msTime1 and:msTime2
 This should really be moved to some RelativeTime class;
 better yet: create a subclass of Integer named LimitedRangeInteger."
 (msTime1 > msTime2) ifTrue:[
-	^ msTime1 - msTime2
+^ msTime1 - msTime2
 ].
 ^ msTime1 + 16r10000000 - msTime2
 "
 OperatingSystem millisecondTimeAdd:16r0FFFFFFF and:1
 This is the login name, not the fullName."
 "/ fallBack dummy
 aNumber == self getUserID ifTrue:[
-	^ self getLoginName
+^ self getLoginName
 ].
 ^ '? (' , aNumber printString , ')'
 "
 "return true, if data is available on a filedescriptor
 (i.e. read is possible without blocking).
 This depends on a working select or FIONREAD to be provided by the OS."
 self supportsSelect ifFalse:[
-	"/ mhmh - what should we do then ?
+"/ mhmh - what should we do then ?
-	"/ For now, return true as if data was present,
+"/ For now, return true as if data was present,
-	"/ and let the thread fall into the read.
+"/ and let the thread fall into the read.
-	"/ It will then (hopefully) be desceduled there and
+"/ It will then (hopefully) be desceduled there and
-	"/ effectively polling for input.
+"/ effectively polling for input.
-	^ true
+^ true
 ].
 (self selectOnAnyReadable:(Array with:fd)
-		     writable:nil
+writable:nil
-		    exception:nil
+exception:nil
-		  withTimeOut:0) == fd
+withTimeOut:0) == fd
-	ifTrue:[^ true].
+ifTrue:[^ true].
 ^ false
 !
 readWriteCheck:fd
 "return true, if filedescriptor can be read or written without blocking.
 This is actually only used with sockets, to wait for a connect to
 be finished."
 self supportsSelect ifFalse:[
-	"/ mhmh - what should we do then ?
+"/ mhmh - what should we do then ?
-	"/ For now, return true as if data was present,
+"/ For now, return true as if data was present,
-	"/ and let the thread fall into the write.
+"/ and let the thread fall into the write.
-	"/ It will then (hopefully) be desceduled there and
+"/ It will then (hopefully) be desceduled there and
-	"/ effectively polling for output.
+"/ effectively polling for output.
-	^ true
+^ true
 ].
 (self selectOnAnyReadable:(Array with:fd)
-		     writable:(Array with:fd)
+writable:(Array with:fd)
-		    exception:nil
+exception:nil
-		  withTimeOut:0) == fd
+withTimeOut:0) == fd
-	ifTrue:[^ true].
+ifTrue:[^ true].
 ^ false
 !
 selectOn:fd1 and:fd2 withTimeOut:millis
 "wait for any fd to become ready; timeout after t milliseconds.
 A zero timeout-time will immediately return (i.e. poll).
 Return fd if i/o ok, nil if timed-out or interrupted.
 Obsolete:
-	This is a leftover method and will vanish."
+This is a leftover method and will vanish."
 ^ self selectOnAnyReadable:(Array with:fd1 with:fd2)
-		      writable:(Array with:fd1 with:fd2)
+writable:(Array with:fd1 with:fd2)
-		     exception:nil
+exception:nil
-		   withTimeOut:millis
+withTimeOut:millis
 !
 selectOn:fd withTimeOut:millis
 "wait for aFileDesriptor to become ready; timeout after t milliseconds.
 Return true, if i/o ok, false if timed-out or interrupted.
 With 0 as timeout argument, this can be used to check for availability
 of read-data.
 Experimental."
 ^ self selectOnAnyReadable:(Array with:fd)
-		      writable:(Array with:fd)
+writable:(Array with:fd)
-		     exception:nil
+exception:nil
-		   withTimeOut:millis
+withTimeOut:millis
 !
 selectOnAny:fdArray withTimeOut:millis
 "wait for any fd in fdArray (an Array of integers) to become ready;
 timeout after t milliseconds. An empty set will always wait.
 Return first ready fd if i/o ok, nil if timed-out or interrupted.
 Experimental."
 ^ self selectOnAnyReadable:fdArray
-		      writable:fdArray
+writable:fdArray
-		     exception:nil
+exception:nil
-		   withTimeOut:millis
+withTimeOut:millis
 !
 selectOnAnyReadable:fdArray withTimeOut:millis
 "wait for any fd in fdArray (an Array of integers) to become ready for
 reading. Timeout after t milliseconds. An empty set will always wait.
 A zero timeout-time will immediately return (i.e. poll).
 Return first ready fd if i/o ok, nil if timed-out or interrupted.
 Experimental."
 ^ self selectOnAnyReadable:fdArray
-		      writable:nil
+writable:nil
-		     exception:nil
+exception:nil
-		   withTimeOut:millis
+withTimeOut:millis
 !
 selectOnAnyReadable:readFdArray writable:writeFdArray exception:exceptFdArray withTimeOut:millis
 "wait for any fd in readFdArray (an Array of integers) to become ready for
 reading, writeFdArray to become ready for writing, or exceptFdArray to
 writeCheck:fd
 "return true, if filedescriptor can be written without blocking"
 self supportsSelect ifFalse:[
-	"/ mhmh - what should we do then ?
+"/ mhmh - what should we do then ?
-	"/ For now, return true as if data was present,
+"/ For now, return true as if data was present,
-	"/ and let the thread fall into the write.
+"/ and let the thread fall into the write.
-	"/ It will then (hopefully) be desceduled there and
+"/ It will then (hopefully) be desceduled there and
-	"/ effectively polling for output.
+"/ effectively polling for output.
-	^ true
+^ true
 ].
 (self selectOnAnyReadable:nil
-		     writable:(Array with:fd)
+writable:(Array with:fd)
-		    exception:nil
+exception:nil
-		  withTimeOut:0) == fd
+withTimeOut:0) == fd
-	ifTrue:[^ true].
+ifTrue:[^ true].
 ^ false
 ! !
 !AbstractOperatingSystem class methodsFor:'documentation'!
 version
-^ '$Header: /cvs/stx/stx/libbasic/AbstractOperatingSystem.st,v 1.27 1999-10-06 12:10:22 cg Exp $'
+^ '$Header: /cvs/stx/stx/libbasic/AbstractOperatingSystem.st,v 1.28 1999-10-06 12:59:16 ca Exp $'
 ! !
 AbstractOperatingSystem initialize!

changeset 4852	ac51b47d8768
parent 4849	439d9f52ad93
child 5026	6406b4765e48