hg/stx-libbasic: comparison AbstractOperatingSystem.st

equal deleted inserted replaced

-:39723f691a0e
+:9287c054ac83
+"
+COPYRIGHT (c) 1988 by Claus Gittinger
+	      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:''
+	classVariableNames:'ConcreteClass LastErrorNumber LocaleInfo OSSignals PipeFailed
+		ErrorSignal AccessDeniedErrorSignal FileNotFoundErrorSignal
+		InvalidArgumentsSignal UnsupportedOperationSignal'
+	poolDictionaries:''
+	category:'System-Support'
+!
+!AbstractOperatingSystem primitiveDefinitions!
+%{
+#define UNIX_LIKE       /* assumption: a real operatingSystem */
+#if defined(MSWINDOWS) || defined(OS2) || defined(MSDOS) || defined(WIN32)
+# ifndef MSDOS_LIKE
+#  define MSDOS_LIKE
+# endif
+# undef UNIX_LIKE       /* oops - we were too optimistic - no OS */
+# ifdef i386
+#  ifndef _X86_
+#   define _X86_
+#  endif
+# endif
+#endif /* any MS-non-OS */
+#if defined(transputer)
+# undef MSDOS_LIKE
+# undef UNIX_LIKE       /* oops - we were too optimistic - no OS */
+#endif
+%}
+! !
+!AbstractOperatingSystem class methodsFor:'documentation'!
+copyright
+"
+COPYRIGHT (c) 1988 by Claus Gittinger
+	      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.
+"
+!
+documentation
+"
+this class realizes access to most (all ?) required operating system services;
+some of it is very specific for unix, so do not depend on
+things available here in your applications
+- some may not be found in other OS's or be slightly different ...
+(On the other hand: I do not want to hide all features
+from you - in some situations it MAY be interesting to be
+able to get down to a select or fork system call easily (at least on Unix systems).
+You decide - portability vs. functionality)
+[Class variables:]
+	HostName        <String>        remembered hostname
+	DomainName      <String>        remembered domainname
+	LastErrorNumber <Integer>       the last value of errno
+	OSSignals       <Array>         Array of signals to be raised for corresponding
+					OperatingSystem signals.
+PipeFailed      <Boolean>       set if a fork (or popen) has failed;
+ST/X will avoid doing more forks/popens
+if this flag is set, for a slightly
+smoother operation.
+	SlowFork        <Boolean>       if set, fork and popen are avoided;
+					(more or less obsolete now)
+	ErrorSignal     <Signal>        Parentsignal of all OS error signals.
+					not directly raised.
+	AccessDeniedErrorSignal
+	FileNotFoundErrorSignal
+	UnsupportedOperationSignal
+	LocaleInfo      <Dictionary>    if non nil, that is taken instead of the operating
+					systems locale definitions (allows for overwriting
+					these, or provide a compatible info on systems which do
+					not support locales)
+	CurrentDirectory <String>       remembered currentDirectories path
+[author:]
+	Claus Gittinger
+[see also:]
+	OSProcessStatus
+	Filename Date Time
+	ExternalStream FileStream PipeStream Socket
+"
+!
+examples
+"
+various queries
+								[exBegin]
+Transcript
+	showCR:'hello ' , (OperatingSystem getLoginName)
+								[exEnd]
+								[exBegin]
+OperatingSystem isUNIXlike ifTrue:[
+	Transcript showCR:'this is some UNIX-like OS'
+] ifFalse:[
+	Transcript showCR:'this OS is not UNIX-like'
+]
+								[exEnd]
+								[exBegin]
+Transcript
+	showCR:'this machine is called ' , OperatingSystem getHostName
+								[exEnd]
+								[exBegin]
+Transcript
+	showCR:('this machine is in the '
+	       , OperatingSystem getDomainName
+	       , ' domain')
+								[exEnd]
+								[exBegin]
+Transcript
+	showCR:('this machine''s CPU is a '
+	       , OperatingSystem getCPUType
+	       )
+								[exEnd]
+								[exBegin]
+Transcript showCR:'executing ls command ...'.
+OperatingSystem executeCommand:'ls'.
+Transcript showCR:'... done.'.
+								[exEnd]
+locking a file
+(should be executed on two running smalltalks - not in two threads):
+								[exBegin]
+|f|
+f := 'testFile' asFilename readWriteStream.
+10 timesRepeat:[
+	'about to lock ...' printCR.
+	[
+	  OperatingSystem
+	    lockFD:(f fileDescriptor)
+	    shared:false
+	    blocking:false
+	] whileFalse:[
+	    'process ' print. OperatingSystem getProcessId print. ' is waiting' printCR.
+	    Delay waitForSeconds:1
+	].
+	'LOCKED ...' printCR.
+	Delay waitForSeconds:10.
+	'unlock ...' printCR.
+	(OperatingSystem
+	    unlockFD:(f fileDescriptor)) printCR.
+	Delay waitForSeconds:3.
+]
+								[exBegin]
+"
+! !
+!AbstractOperatingSystem class methodsFor:'initialization'!
+initialize
+"initialize the class"
+self initializeConcreteClass.
+ErrorSignal isNil ifTrue:[
+ErrorSignal := Object errorSignal newSignalMayProceed:true.
+ErrorSignal nameClass:self message:#errorSignal.
+ErrorSignal notifierString:'OS error encountered'.
+AccessDeniedErrorSignal := ErrorSignal newSignalMayProceed:true.
+AccessDeniedErrorSignal nameClass:self message:#accessDeniedError.
+AccessDeniedErrorSignal notifierString:'OS access denied'.
+FileNotFoundErrorSignal := ErrorSignal newSignalMayProceed:true.
+FileNotFoundErrorSignal nameClass:self message:#fileNotFoundErrorSignal.
+FileNotFoundErrorSignal notifierString:'OS file not found'.
+InvalidArgumentsSignal := ErrorSignal newSignalMayProceed:true.
+InvalidArgumentsSignal nameClass:self message:#invalidArgumentsSignal.
+InvalidArgumentsSignal notifierString:'bad arg to OS call'.
+UnsupportedOperationSignal := ErrorSignal newSignalMayProceed:true.
+UnsupportedOperationSignal nameClass:self message:#unsupportedOperationSignal.
+UnsupportedOperationSignal notifierString:'operation not supported by OS'.
+]
+!
+initializeConcreteClass
+|osType cls|
+osType := self getSystemType.
+osType = 'win32' ifTrue:[
+	cls := Win32OperatingSystem
+] ifFalse:[
+osType = 'os2' ifTrue:[
+	    cls := OS2OperatingSystem
+	] ifFalse:[
+osType = 'macos' ifTrue:[
+		cls := MacOperatingSystem
+	    ] ifFalse:[
+((osType = 'VMS') or:[osType = 'openVMS']) ifTrue:[
+		    cls := OpenVMSOperatingSystem
+		] ifFalse:[
+		    cls := UnixOperatingSystem
+	        ]
+	    ]
+	]
+].
+OperatingSystem := ConcreteClass := cls.
+! !
+!AbstractOperatingSystem class methodsFor:'OS signal constants'!
+sigABRT
+"return the signal number for SIGABRT - 0 if not supported by OS
+(the numeric value is not the same across unix-systems)"
+^ 0
+!
+sigALRM
+"return the signal number for SIGALRM - 0 if not supported
+(the numeric value is not the same across unix-systems)"
+^ 0
+!
+sigBREAK
+"return the signal number for SIGBREAK - 0 if not supported.
+This is an MSDOS specific signal"
+^ 0
+!
+sigBUS
+"return the signal number for SIGBUS - 0 if not supported
+(the numeric value is not the same across unix-systems)"
+^ 0
+!
+sigCHLD
+"return the signal number for SIGCHLD - 0 if not supported
+(the numeric value is not the same across unix-systems)"
+^ 0
+!
+sigCONT
+"return the signal number for SIGCONT - 0 if not supported
+(the numeric value is not the same across unix-systems)"
+^ 0
+!
+sigDANGER
+"return the signal number for SIGDANGER - 0 if not supported
+(seems to be an AIX special)"
+^ 0
+!
+sigEMT
+"return the signal number for SIGEMT - 0 if not supported by OS
+(the numeric value is not the same across unix-systems)"
+^ 0
+!
+sigFP
+"return the signal number for SIGFP - 0 if not supported by OS
+(the numeric value is not the same across unix-systems)"
+^ 0
+!
+sigGRANT
+"return the signal number for SIGGRANT - 0 if not supported
+(seems to be an AIX special)"
+^ 0
+!
+sigHUP
+"return the signal number for SIGHUP
+(the numeric value is not the same across unix-systems)"
+^ 0
+!
+sigILL
+"return the signal number for SIGILL - 0 if not supported by OS
+(the numeric value is not the same across unix-systems)"
+^ 0
+!
+sigINT
+"return the signal number for SIGINT
+(the numeric value is not the same across unix-systems)"
+^ 0
+!
+sigIO
+"return the signal number for SIGIO - 0 if not supported
+(the numeric value is not the same across unix-systems)"
+^ 0
+!
+sigIOT
+"return the signal number for SIGIOT - 0 if not supported by OS
+(the numeric value is not the same across unix-systems)"
+^ 0
+!
+sigKILL
+"return the signal number for SIGKILL
+(the numeric value is not the same across unix-systems)"
+^ 0
+!
+sigLOST
+"return the signal number for SIGLOST - 0 if not supported
+(the numeric value is not the same across unix-systems)"
+^ 0
+!
+sigMIGRATE
+"return the signal number for SIGMIGRATE - 0 if not supported
+(seems to be an AIX special)"
+^ 0
+!
+sigMSG
+"return the signal number for SIGMSG - 0 if not supported
+(seems to be an AIX special)"
+^ 0
+!
+sigPIPE
+"return the signal number for SIGPIPE - 0 if not supported
+(the numeric value is not the same across unix-systems)"
+^ 0
+!
+sigPOLL
+"return the signal number for SIGPOLL - 0 if not supported
+(the numeric value is not the same across unix-systems)"
+^ 0
+!
+sigPRE
+"return the signal number for SIGPRE - 0 if not supported
+(seems to be an AIX special)"
+^ 0
+!
+sigPROF
+"return the signal number for SIGPROF - 0 if not supported
+(the numeric value is not the same across unix-systems)"
+^ 0
+!
+sigPWR
+"return the signal number for SIGPWR - 0 if not supported
+(not available on all systems)"
+^ 0
+!
+sigQUIT
+"return the signal number for SIGQUIT
+(the numeric value is not the same across unix-systems)"
+^ 0
+!
+sigRETRACT
+"return the signal number for SIGRETRACT - 0 if not supported
+(seems to be an AIX special)"
+^ 0
+!
+sigSAK
+"return the signal number for SIGSAK - 0 if not supported
+(seems to be an AIX special)"
+^ 0
+!
+sigSEGV
+"return the signal number for SIGSEGV - 0 if not supported
+(the numeric value is not the same across unix-systems)"
+^ 0
+!
+sigSOUND
+"return the signal number for SIGSOUND - 0 if not supported
+(seems to be an AIX special)"
+^ 0
+!
+sigSTOP
+"return the signal number for SIGSTOP - 0 if not supported
+(the numeric value is not the same across unix-systems)"
+^ 0
+!
+sigSYS
+"return the signal number for SIGSYS - 0 if not supported
+(the numeric value is not the same across unix-systems)"
+^ 0
+!
+sigTERM
+"return the signal number for SIGTERM - 0 if not supported
+(the numeric value is not the same across unix-systems)"
+^ 0
+!
+sigTRAP
+"return the signal number for SIGTRAP - 0 if not supported by OS
+(the numeric value is not the same across unix-systems)"
+^ 0
+!
+sigTSTP
+"return the signal number for SIGTSTP - 0 if not supported
+(the numeric value is not the same across unix-systems)"
+^ 0
+!
+sigTTIN
+"return the signal number for SIGTTIN - 0 if not supported
+(the numeric value is not the same across unix-systems)"
+^ 0
+!
+sigTTOU
+"return the signal number for SIGTTOU - 0 if not supported
+(the numeric value is not the same across unix-systems)"
+^ 0
+!
+sigURG
+"return the signal number for SIGURG - 0 if not supported
+(the numeric value is not the same across unix-systems)"
+^ 0
+!
+sigUSR1
+"return the signal number for SIGUSR1 - 0 if not supported
+(the numeric value is not the same across unix-systems)"
+^ 0
+!
+sigUSR2
+"return the signal number for SIGUSR2 - 0 if not supported
+(the numeric value is not the same across unix-systems)"
+^ 0
+!
+sigVTALRM
+"return the signal number for SIGVTALRM - 0 if not supported
+(the numeric value is not the same across unix-systems)"
+^ 0
+!
+sigWINCH
+"return the signal number for SIGWINCH - 0 if not supported
+(the numeric value is not the same across unix-systems)"
+^ 0
+!
+sigXCPU
+"return the signal number for SIGXCPU - 0 if not supported
+(the numeric value is not the same across unix-systems)"
+^ 0
+!
+sigXFSZ
+"return the signal number for SIGXFSZ - 0 if not supported
+(the numeric value is not the same across unix-systems)"
+^ 0
+! !
+!AbstractOperatingSystem class methodsFor:'Signal constants'!
+accessDeniedErrorSignal
+"return the signal raised when a (file-) access is denied."
+^ AccessDeniedErrorSignal
+!
+errorSignal
+"return the parent signal of all OS signals."
+^ ErrorSignal
+"Modified: 22.4.1996 / 13:11:31 / cg"
+!
+fileNotFoundErrorSignal
+"return the signal raised when a file was not found."
+^ FileNotFoundErrorSignal
+!
+invalidArgumentsSignal
+"return the signal which is raised for invalid arguments.
+Currently, this is never raised."
+^ InvalidArgumentsSignal
+"Created: 13.9.1997 / 10:46:47 / cg"
+"Modified: 13.9.1997 / 10:47:03 / cg"
+!
+unsupportedOperationSignal
+"return the signal which is raised when an operation
+is attempted, which is not supported by the OS.
+(For example, creating a link on VMS or MSDOS)"
+^ UnsupportedOperationSignal
+! !
+!AbstractOperatingSystem class methodsFor:'error messages'!
+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."
+LastErrorNumber := nil.
+"
+AbstractOperatingSystem clearLastErrorNumber
+"
+"Created: 12.4.1996 / 09:28:58 / stefan"
+"Modified: 12.4.1996 / 09:38:51 / stefan"
+!
+currentErrorNumber
+"returns the OS's last error nr (i.e. the value of errno).
+Notice, that the value of this flag is only valid immediately
+after the error occurred - it gets updated with every other
+request to the OS.
+Use lastErrorNumber - currentErrorNumber is invalidated by
+many, many internal calls."
+^ self lastErrorNumber
+"
+OperatingSystem currentErrorNumber
+"
+!
+errorNumberFor:aSymbol
+"given a symbolic error, return the numeric;
+(i.e. errorNumberFor:#EBADF returns EBADF's value).
+Use this, since error numbers are really not standard across unix systems."
+^ -1
+!
+errorSymbolAndTextForNumber:errNr
+"return an array consisting of symbol &  message string from a unix errorNumber
+(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:('ErrorNr: ' , errNr printString)
+"
+OperatingSystem errorSymbolAndTextForNumber:4
+"
+!
+errorSymbolForNumber:errNr
+"return a symbol for a unix errorNumber
+(as returned by a system call)."
+^ (self errorSymbolAndTextForNumber:errNr) at:1
+"
+OperatingSystem errorSymbolForNumber:4
+OperatingSystem errorSymbolForNumber:2
+"
+"Modified: 12.4.1996 / 09:16:29 / stefan"
+"Modified: 13.9.1996 / 16:23:35 / cg"
+!
+errorTextForNumber:errNr
+"return a message string from a unix errorNumber
+(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."
+^ (self errorSymbolAndTextForNumber:errNr) at:2
+"
+OperatingSystem errorTextForNumber: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."
+^ 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."
+LastErrorNumber isNil ifTrue:[^ nil].
+^ self errorTextForNumber:LastErrorNumber
+"
+OperatingSystem lastErrorString
+"
+!
+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."
+LastErrorNumber isNil ifTrue:[^ nil].
+^ self errorSymbolForNumber:LastErrorNumber
+"
+OperatingSystem lastErrorSymbol
+"
+! !
+!AbstractOperatingSystem class methodsFor:'executing OS commands'!
+canExecuteCommand:aCommandString
+"return true, if the OS can execute aCommand.
+For now, this only works with UNIX."
+|cmd|
+cmd := aCommandString asCollectionOfWords first.
+^ (self pathOfCommand:cmd) notNil
+"
+OperatingSystem canExecuteCommand:'fooBar'
+OperatingSystem canExecuteCommand:'ls'
+OperatingSystem canExecuteCommand:'cvs'
+"
+"Created: 4.11.1995 / 19:13:54 / cg"
+!
+commandAndArgsForOSCommand:aCommandString
+"get a shell and shell arguments for command execution"
+self subclassResponsibility
+!
+exec:aCommandPath withArguments:argArray
+"execute the unix command specified by the argument, aCommandPath, with
+arguments in argArray (no arguments, if nil).
+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 withArguments:argArray fork:false
+!
+exec:aCommandPath withArguments:argArray fork:doFork
+"execute an OS command without I/O redirection.
+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
+	   withArguments:argArray
+	   fileDescriptors:nil
+	   closeDescriptors:nil
+	   fork:doFork
+	   newPgrp:false
+"
+|id|
+id := OperatingSystem fork.
+id == 0 ifTrue:[
+	'I am the child'.
+	OperatingSystem
+	    exec:'/bin/ls'
+	    withArguments:#('ls' '/tmp')
+	    fork:false.
+	'not reached'.
+]
+"
+"
+|id|
+id := OperatingSystem fork.
+id == 0 ifTrue:[
+	'I am the child'.
+	OperatingSystem
+	    exec:'/bin/sh'
+	    withArguments:#('sh' '-c' 'sleep 2;echo 1;sleep 2;echo 2')
+	    fork:false.
+	'not reached'.
+].
+id printNL.
+(Delay forSeconds:3.5) wait.
+'killing ...' printNL.
+OperatingSystem sendSignal:(OperatingSystem sigTERM) to:id.
+OperatingSystem sendSignal:(OperatingSystem sigKILL) to:id
+"
+"Modified: 15.7.1997 / 15:54:32 / stefan"
+!
+exec:aCommandPath withArguments:argArray fork:doFork inDirectory:aDirectory
+"execute an OS command without I/O redirection.
+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
+	   withArguments:argArray
+	   fileDescriptors:nil
+	   closeDescriptors:nil
+	   fork:doFork
+	   newPgrp:false
+	   inDirectory:aDirectory
+"
+|id|
+id := OperatingSystem fork.
+id == 0 ifTrue:[
+	'I am the child'.
+	OperatingSystem
+	    exec:'/bin/ls'
+	    withArguments:#('ls' '/tmp')
+	    fork:false.
+	'not reached'.
+]
+"
+"
+|id|
+id := OperatingSystem fork.
+id == 0 ifTrue:[
+	'I am the child'.
+	OperatingSystem
+	    exec:'/bin/sh'
+	    withArguments:#('sh' '-c' 'sleep 2;echo 1;sleep 2;echo 2')
+	    fork:false.
+	'not reached'.
+].
+id printNL.
+(Delay forSeconds:3.5) wait.
+'killing ...' printNL.
+OperatingSystem sendSignal:(OperatingSystem sigTERM) to:id.
+OperatingSystem sendSignal:(OperatingSystem sigKILL) to:id
+"
+"Created: 28.1.1998 / 14:14:03 / md"
+"Modified: 28.1.1998 / 14:14:45 / md"
+!
+executableFileExtensions
+"return a collection of extensions for executable program files.
+Only req'd for msdos & vms like systems ..."
+^ #('')
+"Created: 2.5.1997 / 11:42:29 / cg"
+!
+executeCommand:aCommandString
+"execute the unix command specified by the argument, aCommandString.
+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
+	onError:[:status| false]
+"unix:
+OperatingSystem executeCommand:'sleep 30'.
+OperatingSystem executeCommand:'pwd'.
+OperatingSystem executeCommand:'ls -l'.
+OperatingSystem executeCommand:'invalidCommand'.
+OperatingSystem executeCommand:'rm /tmp/foofoofoofoo'.
+"
+"msdos:
+OperatingSystem executeCommand:'dir'
+OperatingSystem executeCommand:'dir /w'
+"
+"vms:
+OperatingSystem executeCommand:'dir'
+OperatingSystem executeCommand:'purge'
+OperatingSystem executeCommand:'cc foo.c'
+"
+"Modified: 7.1.1997 / 19:29:55 / stefan"
+"Modified: 2.5.1997 / 12:27:39 / cg"
+!
+executeCommand:aCommandString inputFrom:anExternalInStream outputTo:anExternalOutStream errorTo:anExternalErrStream onError:aBlock
+"execute the unix command specified by the argument, aCommandString.
+The commandString is passed to a shell for execution - see the description of
+'sh -c' in your UNIX manual.
+Return true if successful.
+If not successfull, aBlock is called with an OsProcessStatus
+(containing the exit status) as argument."
+|pid exitStatus sema|
+sema := Semaphore new name:'OS command wait'.
+pid := Processor
+monitor:[
+self
+startProcess:aCommandString
+inputFrom:anExternalInStream
+outputTo:anExternalOutStream
+errorTo:anExternalErrStream.
+]
+action:[:status |
+status stillAlive ifFalse:[
+exitStatus := status.
+self closePid:pid.
+sema signal
+].
+].
+pid notNil ifTrue:[
+sema wait.
+] ifFalse:[
+exitStatus := self osProcessStatusClass processCreationFailure.
+].
+exitStatus success ifFalse:[
+^ aBlock value:exitStatus
+].
+^ true.
+"Modified: / 25.3.1997 / 11:02:02 / stefan"
+"Modified: / 28.1.1998 / 14:46:36 / md"
+"Created: / 5.6.1998 / 19:01:57 / cg"
+"Modified: / 12.6.1998 / 16:30:08 / cg"
+!
+executeCommand:aCommandString onError:aBlock
+"execute the unix command specified by the argument, aCommandString.
+The commandString is passed to a shell for execution - see the description of
+'sh -c' in your UNIX manual.
+Return true if successful.
+If not successfull, aBlock is called with an OsProcessStatus
+(containing the exit status) as argument."
+|pid exitStatus sema|
+sema := Semaphore new name:'OS command wait'.
+pid := Processor
+monitor:[self startProcess:aCommandString]
+action:[:status |
+status stillAlive ifFalse:[
+exitStatus := status.
+self closePid:pid.
+sema signal
+].
+].
+pid notNil ifTrue:[
+sema wait.
+] ifFalse:[
+exitStatus := self osProcessStatusClass processCreationFailure.
+].
+exitStatus success ifFalse:[
+^ aBlock value:exitStatus
+].
+^ true.
+"
+UnixOperatingSystem executeCommand:'sleep 30' onError:[].
+UnixOperatingSystem executeCommand:'pwd' onError:[:status|status inspect].
+UnixOperatingSystem executeCommand:'ls -l' onError:[].
+UnixOperatingSystem executeCommand:'invalidCommand' onError:[:status| status inspect].
+UnixOperatingSystem executeCommand:'rm /tmp/foofoofoofoo'onError:[:status | status inspect].
+"
+"Modified: / 25.3.1997 / 11:06:43 / stefan"
+"Modified: / 28.1.1998 / 14:46:56 / md"
+"Created: / 5.6.1998 / 19:02:09 / cg"
+"Modified: / 12.6.1998 / 16:30:12 / cg"
+!
+executeCommand:aCommandString onError:aBlock inDirectory:aDirectory
+"execute the unix command specified by the argument, aCommandString.
+The commandString is passed to a shell for execution - see the description of
+'sh -c' in your UNIX manual.
+Return true if successful.
+If not successfull, aBlock is called with an OsProcessStatus
+(containing the exit status) as argument."
+|pid exitStatus sema|
+sema := Semaphore new name:'OS command wait'.
+pid := Processor
+monitor:[self startProcess:aCommandString inDirectory:aDirectory]
+action:[:status |
+status stillAlive ifFalse:[
+exitStatus := status.
+self closePid:pid.
+sema signal
+].
+].
+pid notNil ifTrue:[
+sema wait.
+] ifFalse:[
+exitStatus := self osProcessStatusClass processCreationFailure.
+].
+exitStatus success ifFalse:[
+^ aBlock value:exitStatus
+].
+^ true.
+"
+UnixOperatingSystem executeCommand:'sleep 30' onError:[].
+UnixOperatingSystem executeCommand:'pwd' onError:[:status|status inspect].
+UnixOperatingSystem executeCommand:'ls -l' onError:[].
+UnixOperatingSystem executeCommand:'invalidCommand' onError:[:status| status inspect].
+UnixOperatingSystem executeCommand:'rm /tmp/foofoofoofoo'onError:[:status | status inspect].
+"
+"Created: / 5.6.1998 / 19:02:22 / cg"
+"Modified: / 12.6.1998 / 16:30:14 / cg"
+!
+getCommandOutputFrom:aCommand
+"execute a simple command (such as hostname) and
+return the commands output as a string"
+|result|
+PipeFailed ifFalse:[
+PipeStream openErrorSignal handle:[:ex |
+	    PipeFailed := true.
+	    'OperatingSystem [warning]: cannot fork/popen' errorPrintCR.
+	    ex return.
+] do:[
+	    |p|
+	    p := PipeStream readingFrom:aCommand.
+	    p notNil ifTrue:[
+	        result := p nextLine.
+	        p close
+	    ].
+].
+].
+^ result
+"Modified: 10.1.1997 / 18:00:07 / cg"
+!
+getVMSSymbol:aSymbolString
+"get a symbols value, or nil if there is none"
+^ nil
+"Created: / 5.6.1998 / 19:02:50 / cg"
+"Modified: / 5.6.1998 / 19:03:15 / cg"
+!
+nameOfSTXExecutable
+"return the name of the running ST/X executable program.
+Usually, 'stx' is returned - but may be different for
+standAlone apps."
+%{
+extern char *__stxExecutableName__();
+RETURN (__MKSTRING(__stxExecutableName__()));
+%}
+"
+OperatingSystem nameOfSTXExecutable
+"
+!
+pathOfCommand:aCommand
+"find where aCommand's executable file is;
+return its full pathName if there is such a command, otherwise
+return nil."
+^ self subclassResponsibility
+!
+pathOfSTXExecutable
+"return the full path of the running ST/X executable program.
+Usually, '/../../stx' is returned - but may be different for
+standAlone apps."
+^ self pathOfCommand:(self nameOfSTXExecutable)
+"
+OperatingSystem pathOfSTXExecutable
+"
+!
+primExec:aCommandPath withArguments:argArray fileDescriptors:fdArray closeDescriptors:closeFdArray fork:doFork newPgrp:newPgrp inPath:dirName
+"Internal lowLevel entry for combined fork & exec"
+self subclassResponsibility
+!
+startProcess:aCommandString
+"start executing the OS command as specified by the argument, aCommandString
+as a separate process; do not wait for the command to finish.
+The commandString is passed to a shell for execution - see the description of
+'sh -c' in your UNIX manual.
+Return the processId if successful, nil otherwise.
+Use #waitForProcess: for synchronization and exec status return,
+or #killProcess: to stop it."
+|shellAndArgs|
+shellAndArgs := self commandAndArgsForOSCommand:aCommandString.
+^ self
+	exec:(shellAndArgs at:1)
+	withArguments:(shellAndArgs at:2)
+	fork:true.
+"
+|pid|
+pid := OperatingSystem startProcess:'sleep 2; echo 1; sleep 2; echo 2'.
+(Delay forSeconds:3) wait.
+OperatingSystem killProcess:pid.
+"
+"Modified: 21.3.1997 / 10:04:35 / dq"
+"Modified: 2.5.1997 / 11:55:44 / cg"
+!
+startProcess:aCommandString inDirectory:aDirectory
+"start executing the OS command as specified by the argument, aCommandString
+as a separate process; do not wait for the command to finish.
+The commandString is passed to a shell for execution - see the description of
+'sh -c' in your UNIX manual.
+Return the processId if successful, nil otherwise.
+Use #waitForProcess: for synchronization and exec status return,
+or #killProcess: to stop it."
+|shellAndArgs|
+shellAndArgs := self commandAndArgsForOSCommand:aCommandString.
+^ self
+	exec:(shellAndArgs at:1)
+	withArguments:(shellAndArgs at:2)
+	fork:true
+	inDirectory:aDirectory.
+"
+|pid|
+pid := OperatingSystem startProcess:'sleep 2; echo 1; sleep 2; echo 2'.
+(Delay forSeconds:3) wait.
+OperatingSystem killProcess:pid.
+"
+"Modified: 21.3.1997 / 10:04:35 / dq"
+"Modified: 2.5.1997 / 11:55:44 / cg"
+"Modified: 28.1.1998 / 14:13:33 / md"
+!
+startProcess:aCommandString inputFrom:anExternalInStream outputTo:anExternalOutStream errorTo:anExternalErrStream
+"start executing the OS command as specified by the argument, aCommandString
+as a separate process; do not wait for the command to finish.
+The commandString is passed to a shell for execution - see the description of
+'sh -c' in your UNIX manual ('cmd.com' in your MSDOS manual).
+The command gets stdIn, stdOut and stdErr assigned from the arguments;
+each may be nil.
+Return the processId if successful, nil otherwise.
+Use #monitorPid:action: for synchronization and exec status return,
+or #killProcess: to stop it."
+self subclassResponsibility
+! !
+!AbstractOperatingSystem class methodsFor:'file access'!
+closeFd:anInteger
+"low level close of a filedescriptor"
+self subclassResponsibility
+!
+createDirectory:aPathName
+"create a new directory with name 'aPathName', which may be an absolute
+path, or relative to the current directory.
+Return true if successful (or the directory existed already), false if failed.
+This is a low-level entry - use Filename protocol for compatibility."
+"/ if it already exists this is ok
+self subclassResponsibility
+!
+linkFile:oldPath to:newPath
+"link the file 'oldPath' to 'newPath'. The link will be a hard link.
+Return true if successful, false if not."
+self subclassResponsibility
+!
+recursiveCopyDirectory:sourcePathName to:destination
+"copy the directory named 'sourcePathName' and all contained files/directories to 'destination'.
+Return true if successful."
+self subclassResponsibility
+"Modified: 7.3.1996 / 15:26:30 / cg"
+!
+recursiveCreateDirectory:dirName
+"create a directory - with all parent dirs if needed.
+Return true if successful, false otherwise. If false
+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 createDirectory:dirName
+].
+^ true
+"
+OperatingSystem recursiveCreateDirectory:'foo/bar/baz'
+OperatingSystem recursiveRemoveDirectory:'foo'
+"
+"Modified: 7.3.1996 / 15:26:22 / cg"
+!
+recursiveRemoveDirectory:fullPathName
+"remove the directory named 'fullPathName' and all contained files/directories.
+Return true if successful."
+self subclassResponsibility
+"
+OperatingSystem recursiveCreateDirectory:'foo/bar/baz'
+OperatingSystem recursiveRemoveDirectory:'foo'
+"
+"Modified: 7.3.1996 / 15:26:30 / cg"
+!
+removeDirectory:fullPathName
+"remove the directory named 'fullPathName'.
+The directory must be empty and you must have appropriate access rights.
+Return true if successful, false if directory is not empty or no permission.
+This is a lowLevel entry - use Filename protocol for compatibility."
+self subclassResponsibility
+!
+removeFile:fullPathName
+"remove the file named 'fullPathName'; return true if successful.
+This is a lowLevel entry - use Filename protocol for compatibility."
+self subclassResponsibility
+!
+renameFile:oldPath to:newPath
+"rename the file 'oldPath' to 'newPath'.
+Someone else has to care for the names to be correct and
+correct for the OS used - therefore, this should not be called
+directlt. Instead, use Filename protocol to rename; this cares for
+any invalid names.
+Returns true if successful, false if not"
+self subclassResponsibility
+!
+truncateFile:aPathName to:newSize
+"change a files size return true on success, false on failure.
+This may not be supported on all architectures.
+This is a low-level entry - use Filename protocol."
+self subclassResponsibility
+! !
+!AbstractOperatingSystem class methodsFor:'file access rights'!
+accessMaskFor:aSymbol
+"return the access bits mask for numbers as returned by
+OperatingSystem>>accessModeOf:
+and expected by OperatingSystem>>changeAccessModeOf:to:.
+Since these numbers are OS dependent, always use the mask
+(never hardcode 8rxxx into your code)."
+self subclassResponsibility
+!
+accessModeOf:aPathName
+"return a number representing access rights rwxrwxrwx for owner,
+group and others. Return nil if such a file does not exist.
+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
+but for huge directory searches the code below is faster
+"
+^ (self infoOf:aPathName) at:#mode
+"
+(OperatingSystem accessModeOf:'/') printStringRadix:8
+"
+!
+changeAccessModeOf:aPathName to:modeBits
+"change the access rights of aPathName to the OS dependent modeBits.
+You should construct this mask using accessMaskFor, to be OS
+independent. Return true if changed,
+false if such a file does not exist or change was not allowd."
+self subclassResponsibility
+! !
+!AbstractOperatingSystem class methodsFor:'file locking'!
+lockFD:aFileDescriptor shared:isSharedReadLock blocking:blockIfLocked
+"set a lock on the file represented by aFileDescriptor.
+(such as returned by ExternalStream>>fileDescriptor).
+On some systems, only advisory locks are available -
+these depends on other accessors to also perform the locking operation.
+If they do not, they may still access the file
+(on some systems, locks are mandatory, on others, they are advisory).
+The isSharedReadLock argument (if true) specifies if multiple readers
+are to be allowed - if false, they are not.
+On some systems, all locks are non-exclusive locks.
+Returns true, if the lock was aquired, false otherwise.
+Notice, that not all OS's support these locks;
+on some, this may simply be a no-op.
+Also notice, that some systems block the process, to wait for the lock.
+This can (again: on some systems) be avoided by passing a false blockIfLocked
+argument."
+^ false
+!
+supportsFileLinks
+"return true, if the OS supports file links (hard links).
+Typically, only unix returns true here."
+^ false
+!
+supportsFileLocks
+"return true, if the OS supports file locking"
+^ false
+"
+OperatingSystem supportsFileLocks
+"
+!
+supportsNonBlockingFileLocks
+"return true, if the OS supports nonBlocking file locking
+(i.e. with immediate return instead of waiting for the lock)"
+^ false
+"
+OperatingSystem supportsNonBlockingFileLocks
+"
+!
+supportsSharedLocks
+"return true, if the OS supports shared (i.e. multiple reader)
+file locking."
+^ false
+"
+OperatingSystem supportsNonBlockingFileLocks
+"
+!
+supportsSymbolicLinks
+"return true, if the OS supports symbolic links on files/directories.
+Typically, only Unix returns true here"
+^ false
+!
+unlockFD:aFileDescriptor
+"clear a file lock on the file represented by aFileDescriptor,
+which was previously aquired by #lockFD:.
+Return false, if the unlock failed
+(which may happens when a wrong fd is passed,
+no lock was set previously, or the systsem does not support locks).
+Notice, that not all OS's support file locks;
+on some, this may simply be a no-op."
+self subclassResponsibility
+! !
+!AbstractOperatingSystem class methodsFor:'file queries'!
+baseNameOf:aPath
+self obsoleteMethodWarning:'use asFilename baseName'.
+^ aPath asFilename baseName
+!
+caseSensitiveFilenames
+"return true, if the OS has caseSensitive file naming.
+On MSDOS, this will return false;
+on a real OS, we return true."
+self subclassResponsibility
+!
+compressPath:pathName
+"return the pathName compressed - that is, remove all ..-entries
+and . entries. This does not always (in case of symbolic links)
+return the true pathName and is therefore used as a fallback
+if realPath and popen failed."
+self subclassResponsibility
+!
+directoryNameOf:aPath
+self obsoleteMethodWarning:'use asFilename directoryName'.
+^ aPath asFilename directoryName
+!
+fileSeparator
+"return the character used to separate names in a path.
+This character differs for MSDOS and other systems,
+(but those are currently not supported - so this is some
+preparation for the future)"
+self isMSDOSlike ifTrue:[
+	^ $\
+].
+^ $/
+!
+getDriveList
+"return a list of volumes in the system.
+On unix, no such thing like a volume exists
+- there, a syntetic list with root, home & current is returned.
+On MSDOS, a list of drive letters is (eventually) returned.
+On VMS, a list of volumes is (eventually) returned."
+"/
+"/ default: retrurn array filled with
+"/ root, home and current directories.
+"/
+^ Array
+	with:'/'
+	with:(self getHomeDirectory)
+	with:(Filename currentDirectory pathName)
+!
+idOf:aPathName
+"return the fileNumber (i.e. inode number) of a file.
+Not all operatingSystems may provide this - on those that do not,
+some dummy id will be returned.
+On unix, this information can be used to check for two files being
+physically identical, even if found in different directories
+(i.e. if they are hardLinked)."
+|i id|
+id := self primIdOf:aPathName.
+id notNil ifTrue:[^ id].
+i := self infoOf:aPathName.
+i notNil ifTrue:[^ i id].
+^ nil.
+"
+OperatingSystem idOf:'/'
+"
+!
+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
+	 mode            - numeric access mode
+	 uid             - owners user id
+	 gid             - owners group id
+	 size            - files size
+	 id              - files number (i.e. inode number)
+	 accessed        - last access time (as Timestamp)
+	 modified        - last modification time (as Timestamp)
+	 statusChanged   - last status change time (as Timestamp)
+	 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),
+the info of the pointed-to-file (i.e. the target) is returned;
+use #linkInfoOf: to get info about the link itself.
+"
+self subclassResponsibility
+!
+isDirectory:aPathName
+"return true, if 'aPathName' is a valid directory path name.
+(i.e. exists and is a directory).
+This also returns true for symbolic links pointing to a directory;
+if you need to check for this, use #linkInfo:."
+^ (self infoOf:aPathName) type == #directory
+!
+isExecutable:aPathName
+"return true, if the given file is executable.
+For symbolic links, the pointed-to-file is checked."
+self subclassResponsibility
+!
+isReadable:aPathName
+"return true, if the file/dir 'aPathName' is readable.
+For symbolic links, the pointed-to-file is checked."
+self subclassResponsibility
+!
+isSymbolicLink:aPathName
+"return true, if the given file is a symbolic link"
+^ (self linkInfoOf:aPathName) notNil
+"
+OperatingSystem isSymbolicLink:'Make.proto'
+OperatingSystem isSymbolicLink:'Makefile'
+"
+!
+isValidPath:aPathName
+"return true, if 'aPathName' is a valid path name
+(i.e. the file or directory exists)"
+self subclassResponsibility
+!
+isWritable:aPathName
+"return true, if the given file is writable.
+For symbolic links, the pointed-to-file is checked."
+self subclassResponsibility
+!
+linkInfoOf:aPathName
+"return a dictionary filled with info for the file 'aPathName',
+IFF aPathName is a symbolic link.
+If aPathName is invalid, or its NOT a symbolic link, nil is returned.
+(which means, that systems like VMS or MSDOS always return nil here.)
+The contents of the dictionary gives info about the link itself,
+on contrast to #infoOf:, which returns the info of the pointed to file
+in case of a symbolic link."
+self subclassResponsibility
+!
+parentDirectoryName
+"return the name used to refer to parent directories.
+In MSDOS, Unix and other systems this is '..', but maybe different
+for other systems.
+(but those are currently not supported - so this is some
+preparation for the future)"
+^ '..'
+!
+pathNameOf:pathName
+"return the pathName of the argument, aPathString,
+- thats the full pathname of the directory, starting at '/'.
+This method needs the path to be valid
+(i.e. all directories must exist, be readable and executable).
+Notice: if symbolic links are involved, the result may look different
+from what you expect."
+self subclassResponsibility
+!
+primIdOf:aPathName
+"the actual code to return the fileNumber (i.e. inode number) of a file."
+self subclassResponsibility
+!
+primPathNameOf:pathName
+"return the pathName of the argument, aPathString,
+- thats the full pathname of the directory, starting at '/'.
+This method here returns nil, if the OS does not provide a
+realPath library function.
+Notice: if symbolic links are involved, the result may look different
+from what you expect."
+self subclassResponsibility
+!
+timeOfLastAccess:aPathName
+"return the time, when the file was last accessed.
+For nonexistent files, nil is returned."
+^ (self infoOf:aPathName) accessed
+!
+timeOfLastChange:aPathName
+"return the time, when the file was last changed.
+For nonexistent files, nil is returned."
+^ (self infoOf:aPathName) modified
+!
+typeOf:aPathName
+"return the type of a file as a symbol; for nonexistent files,
+nil is returned.
+Notice: for symbolic links, the type of the pointed-to file is returned."
+^ (self infoOf:aPathName) type
+!
+volumeNameOf:aPathString
+"return the volumeName of the argument, aPath
+- thats the name of the volume where aPath is.
+Not all OperatingSystems support/use volumes; on unix,
+this always returns an empty string."
+^ ''
+! !
+!AbstractOperatingSystem class methodsFor:'interrupts & signals'!
+blockInterrupts
+"disable interrupt processing - if disabled, incoming
+interrupts will be registered and handled as soon as
+interrupts are reenabled by OperatingSystemclass>>unblockInterrupts.
+Returns the previous blocking status i.e. true if interrupts
+where already blocked. You need this information for proper
+unblocking, in case of nested block/unblock calls."
+%{  /* NOCONTEXT */
+RETURN ( __BLOCKINTERRUPTS() );
+%}
+!
+defaultSignal:signalNumber
+"revert to the default action on arrival of a (Unix-)signal.
+Dont confuse Unix signals with smalltalk signals.
+WARNING: for some signals, it is no good idea to revert to default;
+for example, the default for SIGINT (i.e. ^C) is to exit; while the
+default for SIGQUIT (^ \) is to dump core.
+Also, NOTICE that signal numbers are not portable between unix
+systems - use OperatingSystem sigXXX to get the numeric value for
+a signal."
+self subclassResponsibility
+!
+disableChildSignalInterrupts
+"disable childSignal interrupts
+(SIGCHLD, if the architecture supports it).
+We have to set the signal back to default, because ignoring
+SIGCHLD breaks wait & co"
+^ self defaultSignal:(self sigCHLD)
+"Created: 5.1.1996 / 15:45:28 / stefan"
+!
+disableIOInterruptsOn:fd
+"turn off IO interrupts for a filedescriptor"
+self subclassResponsibility
+!
+disableSignal:signalNumber
+"disable (Unix-) signal processing for signalNumber.
+Dont confuse Unix signals with smalltalk signals.
+WARNING: for some signals, it is no good idea to disable
+them; for example, disabling the SIGINT signal turns off ^C
+handling.
+Also, NOTICE that signal numbers are not portable between unix
+systems - use OperatingSystem sigXXX to get the numeric value for
+a signal.
+Use only for fully debugged stand alone applications."
+self subclassResponsibility
+!
+disableTimer
+"disable timer interrupts.
+WARNING:
+	the system will not operate correctly with timer interrupts
+	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
+	 no exit to the debugger is possible with user interrupts disabled.
+	 We recommend setting up a handler for the signal instead of disabling it."
+self disableSignal:(self sigBREAK).
+self disableSignal:(self sigINT).
+!
+enableAbortInterrupts
+"enable abort signalhandling, and make it a regular signalInterrupt.
+(the default will dump core and exit - which is not a good idea for
+end-user applications ...).
+This is especially useful, if linked-in C-libraries call abort() ..."
+self enableSignal:(self sigABRT)
+!
+enableChildSignalInterrupts
+"enable childSignal interrupts
+(SIGCHLD, if the architecture supports it).
+After enabling, these signals will send the message
+'childSignalInterrupt' to the ChildSignalInterruptHandler object."
+self enableSignal:(self sigCHLD)
+!
+enableFpExceptionInterrupts
+"enable floating point exception interrupts (if the
+architecture supports it).
+After enabling, fpu-exceptions will send the message
+'fpuExceptionInterrupt' to the FPUExceptionInterruptHandler object."
+self enableSignal:(self sigFP)
+!
+enableHardSignalInterrupts
+"enable hard signal exception interrupts (trap, buserror & segm. violation).
+After enabling, these exceptions will send the message
+'signalInterrupt' to the SignalInterruptHandler object."
+"/ leads to trouble ...
+"/    self enableSignal:(self sigPIPE).
+"/ ... better to ignore them, and let it be handled as a writeErrorSignal.
+self disableSignal:(self sigPIPE).
+self enableSignal:(self sigILL).
+self enableSignal:(self sigBUS).
+self enableSignal:(self sigSEGV).
+self enableSignal:(self sigFP).
+self enableSignal:(self sigEMT).
+!
+enableIOInterruptsOn:fd
+"turn on IO interrupts for a filedescriptor"
+self subclassResonsibility
+!
+enableQuitInterrupts
+"enable quitInterrupt (usually ^\) handling, and make it a userInterrupt.
+(the default will dump core and exit - which is not a good idea for
+end-user applications ...)"
+self enableSignal:(self sigQUIT)
+!
+enableSignal:signalNumber
+"enable (Unix-)signal processing for signalNumber.
+Dont confuse Unix signals with smalltalk signals.
+The signal will be delivered to one of the standard handlers
+(SIGINT, SIGQUIT, etc) or to a general handler, which
+sends #signalInterrupt:.
+NOTICE that signal numbers are not portable between unix
+systems - use OperatingSystem sigXXX to get the numeric value for
+a signal."
+self subclassResonsibility
+!
+enableTimer:milliSeconds
+"setup for a timerInterrupt, to be signalled after some (real) time."
+self subclassResonsibility
+!
+enableUserInterrupts
+"enable userInterrupt (^C) handling;
+when enabled, ^C in the terminal window will send the message
+'userInterrupt' to the UserInterruptHandler object."
+self enableSignal:(self sigINT).
+self enableSignal:(self sigBREAK).
+!
+interruptPending
+"return true, if an interrupt is pending. The returned value is
+invalid if interrupts are not currently blocked, since otherwise
+the interrupt is usually already handled before arriving here,
+or may be served while returning from here."
+%{  /* NOCONTEXT */
+extern OBJ __INTERRUPTPENDING();
+RETURN ( __INTERRUPTPENDING() );
+%}
+!
+interruptsBlocked
+"return true, if interrupt handling is currently disabled;
+false otherwise."
+%{  /* NOCONTEXT */
+extern OBJ __INTERRUPTS_BLOCKED();
+RETURN ( __INTERRUPTS_BLOCKED() );
+%}
+!
+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
+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
+OperatingSystem>>getStatusOfProcess:aProcessId."
+self subclassResponsibility
+"Created: / 10.6.1998 / 12:00:26 / cg"
+!
+nameForSignal:aSignalNumber
+"for a given Unix signalnumber, return a descriptive string"
+aSignalNumber == self sigHUP    ifTrue:[^ 'hangup'].
+aSignalNumber == self sigINT    ifTrue:[^ 'interrupt'].
+aSignalNumber == self sigKILL   ifTrue:[^ 'kill'].
+aSignalNumber == self sigQUIT   ifTrue:[^ 'quit'].
+aSignalNumber == self sigILL    ifTrue:[^ 'illegal instruction'].
+aSignalNumber == self sigTRAP   ifTrue:[^ 'trap'].
+aSignalNumber == self sigABRT   ifTrue:[^ 'abort'].
+aSignalNumber == self sigIOT    ifTrue:[^ 'iot trap'].
+aSignalNumber == self sigEMT    ifTrue:[^ 'emt trap'].
+aSignalNumber == self sigFP     ifTrue:[^ 'fp exception'].
+aSignalNumber == self sigBUS    ifTrue:[^ 'bus error'].
+aSignalNumber == self sigSEGV   ifTrue:[^ 'segmentation violation'].
+aSignalNumber == self sigSYS    ifTrue:[^ 'bad system call'].
+aSignalNumber == self sigPIPE   ifTrue:[^ 'broken pipe'].
+aSignalNumber == self sigALRM   ifTrue:[^ 'alarm timer'].
+aSignalNumber == self sigTERM   ifTrue:[^ 'termination'].
+aSignalNumber == self sigSTOP   ifTrue:[^ 'stop'].
+aSignalNumber == self sigTSTP   ifTrue:[^ 'tty stop'].
+aSignalNumber == self sigCONT   ifTrue:[^ 'continue'].
+aSignalNumber == self sigCHLD   ifTrue:[^ 'child death'].
+aSignalNumber == self sigTTIN   ifTrue:[^ 'background tty input'].
+aSignalNumber == self sigTTOU   ifTrue:[^ 'background tty output'].
+aSignalNumber == self sigIO     ifTrue:[^ 'io available'].
+aSignalNumber == self sigXCPU   ifTrue:[^ 'cpu time expired'].
+aSignalNumber == self sigXFSZ   ifTrue:[^ 'file size limit'].
+aSignalNumber == self sigVTALRM ifTrue:[^ 'virtual alarm timer'].
+aSignalNumber == self sigPROF   ifTrue:[^ 'profiling timer'].
+aSignalNumber == self sigWINCH  ifTrue:[^ 'winsize changed'].
+aSignalNumber == self sigLOST   ifTrue:[^ 'resource lost'].
+aSignalNumber == self sigUSR1   ifTrue:[^ 'user signal 1'].
+aSignalNumber == self sigUSR2   ifTrue:[^ 'user signal 2'].
+aSignalNumber == self sigMSG    ifTrue:[^ 'HFT message'].
+aSignalNumber == self sigPWR    ifTrue:[^ 'power-fail'].
+aSignalNumber == self sigPRE    ifTrue:[^ 'programming exception'].
+aSignalNumber == self sigGRANT  ifTrue:[^ 'HFT access wanted'].
+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"
+aSignalNumber == self sigPOLL   ifTrue:[^ 'io available'].
+aSignalNumber == self sigURG    ifTrue:[^ 'urgent'].
+^ 'unknown signal'
+"
+OperatingSystem nameForSignal:9
+OperatingSystem nameForSignal:(OperatingSystem sigPOLL)
+"
+!
+operatingSystemSignal:signalNumber
+"return the signal to be raised when an
+operatingSystem-signal occurs, or nil"
+OSSignals notNil ifTrue:[
+	^ 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 at:signalNumber put:aSignal
+!
+sendSignal:signalNumber to:processId
+"send a unix signal to some process (maybe myself).
+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
+	      OperatingSystem>>getStatusOfProcess:aProcessId
+	      if the signal terminates that process."
+self subclassResponsibility
+!
+startSpyTimer
+"trigger a spyInterrupt, to be signalled after some short (virtual) time.
+This is used by the old MessageTally for profiling.
+Should be changed to use real profiling timer if available.
+On systems, where no virtual timer is available, use the real timer
+(which is of course less correct).
+OBSOLETE: the new messageTally runs as a high prio process, not using
+	       spy interrupts."
+self subclassResponsibility
+!
+stopSpyTimer
+"stop spy timing - disable spy timer.
+OBSOLETE: the new messageTally runs as a high prio process, not using
+	       spy interrupts."
+self subclassResponsibility
+!
+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
+	      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
+	      OperatingSystem>>getStatusOfProcess:aProcessId."
+self subclassResponsibility
+!
+unblockInterrupts
+"enable interrupt processing - if any interrupts are pending,
+these will be handled immediately.
+When unblocking interrupts, take care of nested block/unblock
+calls - you must only unblock after a blockcall if they where
+really not blocked before. See OperatingSystemclass>>blockInterrupts."
+%{
+__UNBLOCKINTERRUPTS();
+RETURN (nil);
+%}
+! !
+!AbstractOperatingSystem class methodsFor:'misc'!
+closePid:pid
+"free pid resource"
+self subclassResponsibility
+!
+exit
+"shutdown smalltalk immediately - this method does not return.
+Return 'good'-status (0) to the parent unix process."
+%{  /* NOCONTEXT */
+__mainExit(0);
+%}
+"OperatingSystem exit - dont evaluate this"
+!
+exit:exitCode
+"shutdown smalltalk immediately -
+returning an exit-code to the parent unix process."
+%{  /* NOCONTEXT */
+int code = 1;
+if (__isSmallInteger(exitCode)) {
+	code = __intVal(exitCode);
+}
+__mainExit(code);
+%}
+"OperatingSystem exit:1 - dont evaluate this"
+!
+exitWithCoreDump
+"shutdown smalltalk immediately - dumping core.
+This always returns 'bad'-status to the parent unix process.
+Notice, that no cleanup is performed at all - you may have to
+manually remove any tempfiles.
+Use this only for debugging ST/X itself"
+%{  /* NOCONTEXT */
+abort();
+%}
+"
+OperatingSystem exitWithCoreDump - dont evaluate this
+"
+! !
+!AbstractOperatingSystem class methodsFor:'os queries'!
+getCPUDefine
+"return a string which was used to identify this CPU type when STX was
+compiled, and which should be passed down when compiling methods.
+For example, on linux, this may be '-Di386'; on a vax, this would be '-Dvax'.
+This is normally not of interest to 'normal' users; however, it is passed
+down to the c-compiler when methods are incrementally compiled to machine code."
+%{  /* NOCONTEXT */
+#   ifndef CPU_DEFINE
+#       define CPU_DEFINE "-DunknownCPU"
+#   endif
+RETURN ( __MKSTRING(CPU_DEFINE));
+%}
+"
+OperatingSystem getCPUDefine
+"
+!
+getCPUType
+"return a string giving the type of machine we're running on.
+Here, the machine for which ST/X was compiled is returned
+(i.e. for all x86's, the same i386 is returned).
+This may normally not be of any interest to you ..."
+|cpu|
+%{  /* NOCONTEXT */
+#   ifdef vax
+#    define CPU_STRING "vax"
+#   endif
+#   ifdef mips
+#    define CPU_STRING "mips"
+#   endif
+#   ifdef i386
+#    define CPU_STRING "i386"
+#   endif
+#   ifdef i860
+#    define CPU_STRING "i860"
+#   endif
+#   ifdef ns32k
+#    define CPU_STRING "ns32k"
+#   endif
+#   ifdef mc68k
+#    define CPU_STRING "mc68k"
+#   endif
+#   ifdef mc88k
+#    define CPU_STRING "mc88k"
+#   endif
+#   ifdef sparc
+#    define CPU_STRING "sparc"
+#   endif
+#   ifdef hppa
+#    define CPU_STRING "hppa"
+#   endif
+#   ifdef rs6000
+#    define CPU_STRING "rs6000"
+#   endif
+#   ifdef powerPC
+#    define CPU_STRING "powerPC"
+#   endif
+#   ifdef alpha
+#    define CPU_STRING "alpha"
+#   endif
+#   ifdef transputer
+#    define CPU_STRING "transputer"
+#   endif
+#   ifdef ibm370
+#    define CPU_STRING "ibm370"
+#   endif
+#   ifndef CPU_STRING
+#    define CPU_STRING "unknown"
+#   endif
+cpu = __MKSTRING(CPU_STRING);
+#   undef CPU_STRING
+%}.
+^ cpu
+"
+OperatingSystem getCPUType
+"
+"examples: are we running on a ss-10/solaris ?"
+"
+(OperatingSystem getCPUType = 'sparc')
+and:[OperatingSystem getOSType = 'solaris']
+"
+"or on a pc/solaris ?"
+"
+(OperatingSystem getCPUType = 'i386')
+and:[OperatingSystem getOSType = 'solaris']
+"
+!
+getDomainName
+"return the domain this host is in.
+Notice:
+	not all systems support this; on some, 'unknown' is returned."
+self subclassResponsibility
+!
+getEnvironment:aStringOrSymbol
+"get an environment string"
+self subclassResponsibility
+!
+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."
+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>
+	thousandsSep                    <String>
+	internationalCurrencySymbol     <String>
+	currencySymbol                  <String>
+	monetaryDecimalPoint            <String>
+	monetaryThousandsSeparator      <String>
+	positiveSign                    <String>
+	negativeSign                    <String>
+	internationalFractionalDigits   <Integer>
+	fractionalDigits                <Integer>
+	positiveSignPrecedesCurrencySymbol      <Boolean>
+	negativeSignPrecedesCurrencySymbol      <Boolean>
+	positiveSignSeparatedBySpaceFromCurrencySymbol  <Boolean>
+	negativeSignSeparatedBySpaceFromCurrencySymbol  <Boolean>
+	positiveSignPosition                            <Symbol>
+							one of: #parenthesesAround,
+								#signPrecedes,
+								#signSuceeds,
+								#signPrecedesCurrencySymbol,
+								#signSuceedsCurrencySymbol
+	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.
+"
+self subclassResponsibility
+!
+getOSDefine
+"return a string which was used to identify this machine when stx was
+compiled, and which should be passed down when compiling methods.
+For example, on linux, this is '-DLINUX'."
+%{  /* NOCONTEXT */
+#ifndef OS_DEFINE
+# ifdef WIN32
+#  define OS_DEFINE "-DWIN32"
+# endif
+# ifndef OS_DEFINE
+#  define OS_DEFINE "-DunknownOS"
+# endif
+#endif
+RETURN ( __MKSTRING(OS_DEFINE));
+#undef OS_DEFINE
+%}
+"
+OperatingSystem getOSDefine
+"
+!
+getOSType
+"return a string giving the type of OS we're running on.
+This can be used to adapt programs to certain environment
+differences (for example: mail-lock strategy ...)"
+|os|
+%{  /* NOCONTEXT */
+#   ifdef MSDOS
+#    define OS_STRING "msdos"
+#   endif
+#   ifdef WIN32
+#    define OS_STRING "win32"
+#   endif
+#   ifdef MSWINDOWS
+#    define OS_STRING "mswindows"
+#   endif
+#   ifdef VMS
+#    ifdef __openVMS__
+#     define OS_STRING "openVMS"
+#    else
+#     define OS_STRING "VMS"
+#    endif
+#   endif
+#   ifdef MVS /* ;-) */
+#    define OS_STRING "mvs"
+#   endif
+#   ifdef OS2
+#    define OS_STRING "os2"
+#   endif
+#   ifdef sinix
+#    define OS_STRING "sinix"
+#   endif
+#   ifdef ultrix
+#    define OS_STRING "ultrix"
+#   endif
+#   ifdef sco
+#    define OS_STRING "sco"
+#   endif
+#   ifdef hpux
+#    define OS_STRING "hpux"
+#   endif
+#   ifdef LINUX
+#    define OS_STRING "linux"
+#   endif
+#   ifdef sunos
+#    define OS_STRING "sunos"
+#   endif
+#   ifdef solaris
+#    define OS_STRING "solaris"
+#   endif
+#   ifdef IRIS
+#    define OS_STRING "irix"
+#   endif
+#   ifdef aix
+#    define OS_STRING "aix"
+#   endif
+#   ifdef realIX
+#    define OS_STRING "realIX"
+#   endif
+#   ifdef __osf__
+#    define OS_STRING "osf"
+#   endif
+/*
+* no concrete info; become somewhat vague ...
+*/
+#   ifndef OS_STRING
+#    ifdef MACH
+#     define OS_STRING "mach"
+#    endif
+#   endif
+#   ifndef OS_STRING
+#    ifdef BSD
+#     define OS_STRING "bsd"
+#    endif
+#    ifdef SYSV
+#     ifdef SYSV3
+#      define OS_STRING "sys5_3"
+#     else
+#      ifdef SYSV4
+#       define OS_STRING "sys5_4"
+#      else
+#       define OS_STRING "sys5"
+#      endif
+#     endif
+#    endif
+#   endif
+/*
+* become very vague ...
+*/
+#   ifndef OS_STRING
+#    ifdef POSIX
+#     define OS_STRING "posix"
+#    endif
+#   endif
+#   ifndef OS_STRING
+#    ifdef UNIX
+#     define OS_STRING "unix"
+#    endif
+#   endif
+#   ifndef OS_STRING
+#    define OS_STRING "unknown"
+#   endif
+os = __MKSTRING(OS_STRING);
+#   undef OS_STRING
+%}.
+^ os
+"
+OperatingSystem getOSType
+"
+!
+getProcessId
+"return the (unix-)processId"
+self subclassResponsibility
+!
+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."
+^ 'unknown'
+"
+OperatingSystem getSystemID
+"
+!
+getSystemInfo
+"return info on the system weare running on.
+If the system supports the uname system call, that info is returned;
+otherwise, some simulated info is returned.
+WARNING:
+Do not depend on the amount and contents of the returned information, some
+systems may return more/less than others. Also, the contents depends on the
+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).
+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 ...)
+	#version -> OS version (some os version identification)
+	#release -> OS release (3.5, 1.2.1 ...)
+	#node   -> some host identification (hostname)
+	#domain  -> domain name (hosts domain)
+	#machine -> type of machine (i586, mips ...)
+"
+|info|
+info := IdentityDictionary new.
+info at:#system put:(self getSystemType).
+info at:#node put:(self getHostName).
+info at:#machine put:(self getCPUType).
+info at:#architecture put:'unknown'.
+info at:#domain put:self getDomainName.
+info at:#osType put:(self getOSType).
+^ info
+"
+OperatingSystem getSystemInfo
+"
+!
+getSystemType
+"return a string giving the type of system we're running on.
+This is almost the same as getOSType, but the returned string
+is slightly different for some systems (i.e. iris vs. irix).
+Dont depend on this - use getOSType. I dont really see a point
+here ...
+(except for slight differences between next/mach and other machs)"
+^ self getOSType
+"
+OperatingSystem getSystemType
+"
+!
+getWindowsDirectory
+"internal interface - only for Windows based systems.
+Return the windows directory
+(which - depending on the system - may be \WINNT, \WINDOWS or whatever)
+On non-windows systems, nil is returned."
+^ nil
+"
+OperatingSystem getWindowsDirectory
+"
+!
+getWindowsSystemDirectory
+"internal interface - only for Windows based systems.
+Return the windows system directory
+(which - depending on the system - may be \WINNT\SYSTEM32,
+\WINDOWS\SYSTEM or whatever)
+On non-windows systems, nil is returned."
+^ nil
+"
+OperatingSystem getWindowsSystemDirectory
+"
+!
+isBSDlike
+"return true, if the OS we're running on is a 'real' unix."
+^ false
+!
+isMAClike
+"return true, if running on a macOS (but not on A/UX)"
+^ false
+!
+isMSDOSlike
+"return true, if the OS we're running on is msdos like
+(in contrast to unix-like).
+This returns true for any of msdos, win32s, win95,
+winNT and os/2."
+^ false
+!
+isMSWINDOWSlike
+"return true, if running on a MS-Windows like system.
+This returns true for any of win32s, win95 and winNT."
+^ false
+!
+isOS2like
+"return true, if the OS we're running on is OS2 like.
+Only returns true for a plain OS/2 system."
+^ false
+!
+isUNIXlike
+"return true, if the OS we're running on is a unix like."
+^ false
+!
+isVMSlike
+"return true, if the OS we're running in is VMS (or openVMS)."
+^ false
+!
+maxFileNameLength
+"return the max number of characters in a filename.
+CAVEAT:
+	 Actually, the following is somewhat wrong - some systems
+	 support different sizes, depending on the volume.
+	 We return a somewhat conservative number here.
+	 Another entry, to query for volume specific max
+	 will be added in the future."
+self subclassResponsibility
+!
+maxPathLength
+"return the max number of characters in a pathName."
+self subclassResponsibility
+!
+pathSeparator
+"return the character which separates items in the PATH variable"
+self subclassResponsibility
+!
+platformName
+"return a string describing the OS platform very we're running on.
+This returns #unix for all unix derivatives.
+I.e. it is much less specific than getOSType or getSystemType."
+|os|
+os := self getSystemType.
+os = 'win32' ifTrue:[ ^ #win32].
+os = 'os2' ifTrue:[ ^ #os2].
+os = 'macos' ifTrue:[ ^ #mac].
+os = 'VMS' ifTrue:[ ^ #vms].
+os = 'openVMS' ifTrue:[ ^ #vms].
+^ #unix
+"
+OperatingSystem platformName
+"
+"Modified: 20.6.1997 / 17:37:26 / cg"
+!
+setLocaleInfo:anInfoDictionary
+"set the locale information; if set, this oerrides the OS's settings.
+(internal in ST/X only - the OS's settings remain unaffected)
+See description of fields in #getLocaleInfo.
+Notice, that (for now), the system does not use this information;
+it should be used by applications as required."
+LocaleInfo := anInfoDictionary
+"
+|d|
+d := IdentityDictionary new.
+d at:#decimalPoint                 put:'.'         .
+d at:#thousandsSeparator           put:','         .
+d at:#currencySymbol               put:'USD'       .
+d at:#monetaryDecimalPoint         put:'.'         .
+d at:#monetaryThousandsSeparator   put:'.'         .
+d at:#fractionalDigits             put:2           .
+d at:#positiveSign                 put:'+'         .
+d at:#negativeSign                 put:'-'         .
+d at:#positiveSignPrecedesCurrencySymbol put:true          .
+d at:#negativeSignPrecedesCurrencySymbol put:false         .
+OperatingSystem setLocaleInfo:d
+"
+!
+supportsChildInterrupts
+"return true, if the OS supports childProcess termination signalling
+through interrupts (i.e. SIGCHILD)"
+^ false
+"
+OperatingSystem supportsChildInterrupts
+"
+!
+supportsIOInterrupts
+"return true, if the OS supports IO availability interrupts
+(i.e. SIGPOLL/SIGIO)."
+^ false
+"
+OperatingSystem supportsIOInterrupts
+"
+!
+supportsNonBlockingIO
+"return true, if the OS supports nonblocking IO."
+^ false
+"
+OperatingSystem supportsNonBlockingIO
+"
+!
+supportsSelect
+"return true, if the OS supports selecting on multiple
+filedescriptors via select.
+If false is returned, ProcessorScheduler will poll in 50ms
+intervals for I/O becoming ready."
+^ true
+"
+OperatingSystem supportsSelect
+"
+! !
+!AbstractOperatingSystem class methodsFor:'private'!
+osProcessStatusClass
+^ self subclassResponsibility
+"Created: / 12.6.1998 / 16:30:29 / cg"
+! !
+!AbstractOperatingSystem class methodsFor:'shared memory access'!
+shmAttach:id address:addr flags:flags
+"low level entry to shmat()-system call.
+Not supported on all operatingSystems"
+self subclassResponsibility
+"Modified: 22.4.1996 / 13:15:12 / cg"
+!
+shmDetach:addr
+"low level entry to shmdt()-system call.
+Not supported on all operatingSystems"
+self subclassResponsibility
+"Modified: 22.4.1996 / 13:15:03 / cg"
+!
+shmGet:key size:size flags:flags
+"low level entry to shmget()-system call.
+This is not for public use and not supported with all operatingSystems.
+- use the provided wrapper class SharedExternalBytes instead."
+self subclassResponsibility
+! !
+!AbstractOperatingSystem class methodsFor:'time and date'!
+computeDatePartsOf:osTime for:aBlock
+"compute year, month and day from the OS time, osTime
+and evaluate the argument, a 3-arg block with these.
+Conversion is to localtime including any daylight saving adjustments."
+self subclassResponsibility
+!
+computeOSTimeFromYear:y month:m day:d hour:h minute:min seconds:s millis:millis
+"return the OS-dependent time for the given time and day.
+The arguments are assumed to be in localtime including
+any daylight saving adjustings."
+self subclassResponsibility
+!
+computeTimeAndDateFrom:osTime
+"given an OS-dependent time in osTime, return an Array
+containing (full-) year, month, day, hour, minute and seconds,
+offset to UTC, daylight savings time flag, milliseconds,
+dayInYear (1..) and dayInWeek (1..).
+Conversion is to localtime including any daylight saving adjustments."
+self subclassResponsibility
+!
+computeTimePartsOf:osTime for:aBlock
+"compute hours, minutes, seconds and milliseconds from the osTime
+and evaluate the argument, a 4-arg block with these.
+Conversion is to localtime including any daylight saving adjustments."
+self subclassResponsibility
+!
+computeUTCTimeAndDateFrom:osTime
+"given an OS-dependent time in osTime, return an Array
+containing year, month, day, hour, minute and seconds,
+offset to UTC, daylight savings time flag, milliseconds,
+dayInYear (1..) and dayInWeek (1..).
+Conversion is to UTC."
+self subclassResponsibility
+!
+computeUTCTimePartsOf:osTime for:aBlock
+"compute hours, minutes, seconds and milliseconds from the osTime
+and evaluate the argument, a 4-arg block with these.
+Conversion is to UTC."
+self subclassResponsibility
+!
+getMillisecondTime
+"This returns the millisecond timers value.
+The range is limited to 0..1fffffff (i.e. the SmallInteger range) to avoid
+LargeInteger arithmetic when doing timeouts and delays.
+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,
+	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.
+"
+self subclassResponsibility
+!
+getOSTime
+"This returns the OS time.
+The base of the returned value is not consistent across
+different OS's - some return the number of millis since jan, 1st 1970;
+others since 1900. The Time classes are prepared for this, and
+converts as appropriate (by using my fromOSTime: conversion methods).
+Dont use this method in application code since it is an internal (private)
+interface. For compatibility with ST-80, use Time>>millisecondClockValue.
+or use instances of Time, Date or AbsoluteTime to work with.
+"
+self subclassResponsibility
+!
+maximumMillisecondTimeDelta
+"this returns the maximum delta supported by millisecondCounter
+based methods. The returned value is half the value at which the
+timer wraps."
+%{  /* NOCONTEXT */
+RETURN ( __MKSMALLINT(0x0FFFFFFF) );
+%}
+!
+millisecondDelay:millis
+"delay execution for millis milliseconds or until the next event
+arrives.
+All lower priority threads will also sleep for the duration,
+interrupts (and therefore, higher prio processes) are
+still handled.
+Better use a Delay, to only delay the calling thread.
+(however, a delay cannot be used in the event handler or scheduler)"
+|now then delta|
+now := self getMillisecondTime.
+then := self millisecondTimeAdd:now and:millis.
+[self millisecondTime:then isAfter:now] whileTrue:[
+	delta := self millisecondTimeDeltaBetween:then and:now.
+	self selectOnAnyReadable:nil writable:nil exception:nil withTimeOut:delta.
+	now := self getMillisecondTime.
+]
+"
+OperatingSystem millisecondDelay:2000
+"
+!
+millisecondTime:msTime1 isAfter:msTime2
+"return true if msTime1 is after msTime2, false if not.
+The two arguments are supposed to be millisecond times
+(such as returned getMillisecondTime) which wrap at 16r1FFFFFFF.
+This should really be moved to some RelativeTime class."
+(msTime1 > msTime2) ifTrue:[
+	((msTime1 - msTime2) >= 16r10000000) ifTrue:[
+	    ^ false
+	].
+	^ true
+].
+((msTime2 - msTime1) > 16r10000000) ifTrue:[
+	^ true
+].
+^ false
+!
+millisecondTimeAdd:msTime1 and:msTime2
+"Add two millisecond times (such as returned getMillisecondTime).
+The returned value is msTime1 + msTime2 where a wrap occurs at:16r1FFFFFFF.
+This should really be moved to some RelativeTime class."
+|sum|
+sum := msTime1 + msTime2.
+(sum > 16r1FFFFFFF) ifTrue:[^ sum - 16r20000000].
+(sum < 0) ifTrue:[^ sum + 16r20000000].
+^ sum
+!
+millisecondTimeDeltaBetween:msTime1 and:msTime2
+"subtract two millisecond times (such as returned getMillisecondTime)
+and return the difference. Since milli-times wrap (at 16r01FFFFFFF),
+some special handling is built-in here.
+The returned value is msTime1 - msTime2. The returned value is invalid
+if the delta is >= 0x10000000.
+This should really be moved to some RelativeTime class;
+better yet: create a subclass of Integer named LimitedRangeInteger."
+(msTime1 > msTime2) ifTrue:[
+	^ msTime1 - msTime2
+].
+^ msTime1 + 16r10000000 - msTime2
+"
+OperatingSystem millisecondTimeAdd:16r0FFFFFFF and:1
+OperatingSystem millisecondTimeAdd:16r0FFFFFFF and:(16 / 3)
+OperatingSystem millisecondTimeAdd:16r0FFFFFFF and:1000
+OperatingSystem millisecondTimeDeltaBetween:0 and:16r0FFFFFFF
+OperatingSystem millisecondTimeDeltaBetween:(13/3) and:16r0FFFFFFF
+OperatingSystem millisecondTimeDeltaBetween:999 and:16r0FFFFFFF
+OperatingSystem millisecondTime:0 isAfter:16r0FFFFFFF
+OperatingSystem millisecondTime:(13/3) isAfter:16r0FFFFFFF
+OperatingSystem millisecondTime:999 isAfter:16r0FFFFFFF
+OperatingSystem millisecondTime:0 isAfter:0
+OperatingSystem millisecondTime:(13/3) isAfter:0
+OperatingSystem millisecondTime:999 isAfter:0
+OperatingSystem millisecondTime:1 isAfter:0
+OperatingSystem millisecondTime:(13/3) isAfter:2
+OperatingSystem millisecondTime:999 isAfter:900
+|t1 t2|
+t1 := Time millisecondClockValue.
+(Delay forMilliseconds:1) wait.
+t2 := Time millisecondClockValue.
+OperatingSystem millisecondTimeDeltaBetween:t2 and:t1
+"
+!
+sleep:numberOfSeconds
+"{ Pragma: +optSpace }"
+"cease ANY action for some time. This suspends the whole smalltalk
+(unix-) process for some time.
+Not really useful since not even low-prio processes and interrupt
+handling will run during the sleep.
+Use either OperatingSystem>>millisecondDelay: (which makes all
+threads sleep, but handles interrupts) or use a Delay (which makes
+only the calling thread sleep)."
+self subclassResponsibility
+! !
+!AbstractOperatingSystem class methodsFor:'users & groups'!
+getEffectiveGroupID
+"{ Pragma: +optSpace }"
+"return the current users (thats you) effective numeric group id.
+This is only different from getGroupID, if you have ST/X running
+as a setuid program (of which you should think about twice)."
+^ self getGroupID
+"
+OperatingSystem getEffectiveGroupID
+"
+!
+getEffectiveUserID
+"{ Pragma: +optSpace }"
+"return the current users (thats you) effective numeric user id.
+This is only different from getUserID, if you have ST/X running
+as a setuid program (of which you should think about twice)."
+^ self getUserID
+"
+OperatingSystem getEffectiveUserID
+"
+!
+getFullUserName
+"{ Pragma: +optSpace }"
+"return a string with the users full name (thats you) - if available.
+If not, return the login name as a fallBack."
+^ self getFullUserNameFromID:(self getUserID)
+"
+OperatingSystem getFullUserName
+"
+"Modified: 24.1.1997 / 11:31:55 / cg"
+!
+getFullUserNameFromID:userID
+"{ Pragma: +optSpace }"
+"return a string with the users full name - if available.
+If not, return the login name as a fallBack."
+^ self getUserNameFromID:userID
+"
+OperatingSystem getFullUserNameFromID:0
+OperatingSystem getFullUserNameFromID:(OperatingSystem getUserID)
+OperatingSystem getUserNameFromID:(OperatingSystem getUserID)
+"
+"Modified: 15.7.1996 / 12:44:21 / cg"
+!
+getGroupID
+"{ Pragma: +optSpace }"
+"return the current users (thats you) numeric group id"
+^ 1 "/ just a dummy for systems which do not have userIDs
+"
+OperatingSystem getGroupID
+"
+!
+getGroupNameFromID:aNumber
+"{ Pragma: +optSpace }"
+"return the group-name-string for a given numeric group-id"
+^ '???' "/ just a dummy for systems which do not have groups
+"
+OperatingSystem getGroupNameFromID:0
+OperatingSystem getGroupNameFromID:10
+"
+!
+getHomeDirectory
+"{ Pragma: +optSpace }"
+"return the name of the users home directory
+(i.e. yours)"
+^ self getEnvironment:'HOME'
+"
+OperatingSystem getHomeDirectory
+"
+"Modified: 24.1.1997 / 11:32:13 / cg"
+!
+getLoginName
+"{ Pragma: +optSpace }"
+"return a string with the users login name (thats yours)"
+self subclassResponsibility
+!
+getUserID
+"{ Pragma: +optSpace }"
+"return the current users (thats you) numeric user id"
+^ 1 "just a dummy for systems which do not have userIDs"
+"
+OperatingSystem getUserID
+"
+!
+getUserNameFromID:aNumber
+"{ Pragma: +optSpace }"
+"return the user-name-string for a given numeric user-id.
+This is the login name, not the fullName."
+"/ fallBack dummy
+aNumber == self getUserID ifTrue:[
+	^ self getLoginName
+].
+^ '? (' , aNumber printString , ')'
+"
+OperatingSystem getUserNameFromID:0
+OperatingSystem getUserNameFromID:100
+OperatingSystem getUserNameFromID:9991
+"
+!
+userInfoOf:aNameOrID
+"{ Pragma: +optSpace }"
+"return a dictionary filled with userinfo. The argument can be either
+a string with the users name or its numeric id.
+Notice, that not all systems provide (all of) this info;
+DOS systems return nothing;
+non-SYSV4 systems have no age/comment.
+Portable applications may want to check the systemType and NOT depend
+on all keys to be present in the returned dictionary.
+Another notice: on some systems (SYSV4), the gecos field includes multiple
+entries (i.e. not just the name), separated by commas. You may want to
+extract any substring, up to the first comma to get the real life name."
+|info|
+"/ fallBack dummy
+info := IdentityDictionary new.
+info at:#name put:(self getLoginName).
+info at:#dir put:(self getHomeDirectory).
+^ info
+"
+OperatingSystem userInfoOf:'root'
+OperatingSystem userInfoOf:1
+OperatingSystem userInfoOf:'claus'
+OperatingSystem userInfoOf:'fooBar'
+OperatingSystem userInfoOf:(OperatingSystem getUserID)
+"
+! !
+!AbstractOperatingSystem class methodsFor:'waiting for events'!
+blockingChildProcessWait
+"return true, if childProcessWait: blocks, if no children are ready.
+On those systems, we must be somewhat careful when looking out for
+a subprocesses status (to avoid blocking)."
+^ true
+!
+childProcessWait:blocking pid:pidToWait
+"{ Pragma: +optSpace }"
+"get status changes from child processes.
+Return an OSProcessStatus or nil, if no process has terminated.
+If blocking is true, we wait until a process changed state,
+otherwise we return immediately.
+Note that win32 needs to know the HANDLE of the process on which
+it waits.  In case of an error, THIS ALWAYS WAITS and then times out."
+self subclassResponsibility
+!
+numAvailableForReadOn:fd
+"return the number of bytes available for reading, without blocking."
+"/ fallBack for systems which do not provide this info
+^ (self readCheck:fd) ifTrue:[1] ifFalse:[0]
+!
+readCheck:fd
+"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 ?
+	"/ For now, return true as if data was present,
+	"/ and let the thread fall into the read.
+	"/ It will then (hopefully) be desceduled there and
+	"/ effectively polling for input.
+	^ true
+].
+(self selectOnAnyReadable:(Array with:fd)
+		     writable:nil
+		    exception:nil
+		  withTimeOut:0) == fd
+	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 ?
+"/ For now, return true as if data was present,
+"/ and let the thread fall into the write.
+"/ It will then (hopefully) be desceduled there and
+"/ effectively polling for output.
+^ true
+].
+(self selectOnAnyReadable:(Array with:fd)
+writable:(Array with:fd)
+exception:nil
+withTimeOut:0) == fd
+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."
+^ self selectOnAnyReadable:(Array with:fd1 with:fd2)
+		      writable:(Array with:fd1 with:fd2)
+		     exception:nil
+		   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)
+		     exception:nil
+		   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
+		     exception:nil
+		   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
+		     exception:nil
+		   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
+arrive exceptional data (i.e. out-of-band data).
+Timeout after t milliseconds or, if the timeout time is 0, immediately..
+Empty fd-sets will always wait. Zero time can be used to poll file-
+descriptors (i.e. to check if I/O possible without blocking).
+Return first ready fd if I/O ok, nil if timed-out or interrupted."
+self subclassResponsibility
+!
+setBlocking:aBoolean on:fd
+"{ Pragma: +optSpace }"
+"set/clear the blocking attribute - if set (which is the default)
+a read on the fileDescriptor will block until data is available.
+If cleared, a read operation will immediately return with a value of
+nil."
+self subclassResponsibility
+!
+writeCheck:fd
+"return true, if filedescriptor can be written without blocking"
+self supportsSelect ifFalse:[
+	"/ mhmh - what should we do then ?
+	"/ For now, return true as if data was present,
+	"/ and let the thread fall into the write.
+	"/ It will then (hopefully) be desceduled there and
+	"/ effectively polling for output.
+	^ true
+].
+(self selectOnAnyReadable:nil
+		     writable:(Array with:fd)
+		    exception:nil
+		  withTimeOut:0) == fd
+	ifTrue:[^ true].
+^ false
+! !
+!AbstractOperatingSystem class methodsFor:'documentation'!
+version
+^ '$Header: /cvs/stx/stx/libbasic/AbstractOperatingSystem.st,v 1.1 1998-06-15 14:52:33 cg Exp $'
+! !
+AbstractOperatingSystem initialize!

changeset 3576	9287c054ac83
child 3689	f3351f92641e