hg/stx-libbasic: comparison ProcessorScheduler.st

equal deleted inserted replaced

-:5c7b472ab445
+:17324d5bb9cc
 "
 COPYRIGHT (c) 1993 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
 !ProcessorScheduler class methodsFor:'documentation'!
 copyright
 "
 COPYRIGHT (c) 1993 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
 This pure-event mode may not be supported in the future
 (actually, it is no longer maintained, so dont run the system without Processes).
 [instance variables:]
-quiescentProcessLists           - list of waiting processes
+	quiescentProcessLists           - list of waiting processes
-scheduler                       - the scheduler process itself
+	scheduler                       - the scheduler process itself
-zombie                          - internal temporary (recently died process)
+	zombie                          - internal temporary (recently died process)
-activeProcess                   - the current process
+	activeProcess                   - the current process
-activeProcessId                 - the current processes id
+	activeProcessId                 - the current processes id
-currentPriority                 - the current processes priority
+	currentPriority                 - the current processes priority
-readFdArray                     - fd-sema-checkBlock triple-association
+	readFdArray                     - fd-sema-checkBlock triple-association
-readSemaphoreArray                (stupid historic 3-separate arrays for hi-speed-optimization reasons)
+	readSemaphoreArray                (stupid historic 3-separate arrays for hi-speed-optimization reasons)
-readCheckArray
+	readCheckArray
-writeFdArray                    - fd-sema-checkBlock triple-association
+	writeFdArray                    - fd-sema-checkBlock triple-association
-writeSemaphoreArray               (stupid historic 3-separate arrays for hi-speed-optimization reasons)
+	writeSemaphoreArray               (stupid historic 3-separate arrays for hi-speed-optimization reasons)
-writeCheckArray
+	writeCheckArray
-timeoutArray                    - time-action-process-sema quadruple-association
+	timeoutArray                    - time-action-process-sema quadruple-association
-timeoutActionArray                (stupid historic 3-separate arrays for hi-speed-optimization reasons)
+	timeoutActionArray                (stupid historic 3-separate arrays for hi-speed-optimization reasons)
-timeoutProcessArray
+	timeoutProcessArray
-timeoutSemaphoreArray
+	timeoutSemaphoreArray
-idleActions                     - actions to be executed when idle
+	idleActions                     - actions to be executed when idle
-preWaitActions                  - actions to be executed BEFORE going into an OS-wait
+	preWaitActions                  - actions to be executed BEFORE going into an OS-wait
-anyTimeouts                     - flag if any timeouts are pending
+	anyTimeouts                     - flag if any timeouts are pending
-dispatching                     - flag if dispatch process is running (i.e. NOT initializing)
+	dispatching                     - flag if dispatch process is running (i.e. NOT initializing)
-interruptedProcess              - the currently interrupted process.
+	interruptedProcess              - the currently interrupted process.
-useIOInterrupts                 - flag if the OS supports I/O interrupts and if they are used (to get me out of an OS wait)
+	useIOInterrupts                 - flag if the OS supports I/O interrupts and if they are used (to get me out of an OS wait)
-gotIOInterrupt                  - flag if I came out of a wait due to an I/O interrupt
+	gotIOInterrupt                  - flag if I came out of a wait due to an I/O interrupt
-osChildExitActions              - OS chid process actions
+	osChildExitActions              - OS chid process actions
-gotChildSignalInterrupt         - flag if I came out of a wait due to an OS child interrupt
+	gotChildSignalInterrupt         - flag if I came out of a wait due to an OS child interrupt
-exitWhenNoMoreUserProcesses     - flag which controls if ST/X should exit when the last process dies (for standalone apps)
+	exitWhenNoMoreUserProcesses     - flag which controls if ST/X should exit when the last process dies (for standalone apps)
-suspendScheduler                - internal use
+	suspendScheduler                - internal use
-timeSliceProcess                - the timeSlicer process
+	timeSliceProcess                - the timeSlicer process
-supportDynamicPriorities        - flag if dynamic priorities should be supported by the timeSlicer
+	supportDynamicPriorities        - flag if dynamic priorities should be supported by the timeSlicer
-scheduledProcesses              - list of scheduled processes for the timeSlicers dynamic prio handling
+	scheduledProcesses              - list of scheduled processes for the timeSlicers dynamic prio handling
 [class variables:]
-KnownProcesses          <WeakArray>     all known processes
+	KnownProcesses          <WeakArray>     all known processes
-KnownProcessIds         <Collection>    and their IDs
+	KnownProcessIds         <Collection>    and their IDs
-PureEventDriven         <Boolean>       true, if no process support
+	PureEventDriven         <Boolean>       true, if no process support
-is available
+						is available
-UserSchedulingPriority  <Integer>       the priority at which normal
+	UserSchedulingPriority  <Integer>       the priority at which normal
-user interfaces run
+						user interfaces run
-UserInterruptPriority                   the priority at which user-
+	UserInterruptPriority                   the priority at which user-
-interrupts (Cntl-C) processing
+						interrupts (Cntl-C) processing
-takes place. Processes with
+						takes place. Processes with
-a greater or equal priority are
+						a greater or equal priority are
-not interruptable.
+						not interruptable.
-TimingPriority                          the priority used for timing.
+	TimingPriority                          the priority used for timing.
-Processes with a greater or
+						Processes with a greater or
-equal priority are not interrupted
+						equal priority are not interrupted
-by timers.
+						by timers.
-HighestPriority                         The highest allowed prio for processes
+	HighestPriority                         The highest allowed prio for processes
-SchedulingPriority                      The priority of the scheduler (must
+	SchedulingPriority                      The priority of the scheduler (must
-me higher than any other).
+						me higher than any other).
-MaxNumberOfProcesses                    if non-nil, no more than this
+	MaxNumberOfProcesses                    if non-nil, no more than this
-number of processes are allowed
+						number of processes are allowed
-(for debugging)
+						(for debugging)
-TimeSliceInterval                       for preemptive priority scheduling only:
+	TimeSliceInterval                       for preemptive priority scheduling only:
-the time interval in millis, at which processes
+						the time interval in millis, at which processes
-are timesliced
+						are timesliced
-TimeSlicingPriorityLimit                for preemptive priority scheduling only:
+	TimeSlicingPriorityLimit                for preemptive priority scheduling only:
-processes are only timesliced, if running
+						processes are only timesliced, if running
-at or below this priority.
+						at or below this priority.
-EventPollingInterval                    for systems which do not support select on
+	EventPollingInterval                    for systems which do not support select on
-a fileDescriptor: the polling interval in millis.
+						a fileDescriptor: the polling interval in millis.
 most interesting methods:
-Processor>>suspend:                  (see also Process>>suspend)
+	Processor>>suspend:                  (see also Process>>suspend)
-Processor>>resume:                   (see also Process>>resume)
+	Processor>>resume:                   (see also Process>>resume)
-Processor>>terminate:                (see also Process>>terminate)
+	Processor>>terminate:                (see also Process>>terminate)
-Processor>>yield
+	Processor>>yield
-Processor>>changePriority:for:       (see also Process>>priority:
+	Processor>>changePriority:for:       (see also Process>>priority:
-Processor>>signal:afterSeconds:      (see also Delay>>forSeconds:)
+	Processor>>signal:afterSeconds:      (see also Delay>>forSeconds:)
-Processor>>signal:afterMilliseconds: (see also Delay>>forMilliseconds:)
+	Processor>>signal:afterMilliseconds: (see also Delay>>forMilliseconds:)
-Processor>>signal:onInput:           (see also ExternalStream>>readWait)
+	Processor>>signal:onInput:           (see also ExternalStream>>readWait)
-Processor>>signal:onOutput:          (see also ExternalStream>>writeWait)
+	Processor>>signal:onOutput:          (see also ExternalStream>>writeWait)
-Processor>>disableSemaphore:
+	Processor>>disableSemaphore:
 [see also:]
-Process
+	Process
-Delay Semaphore SemaphoreSet SharedQueue
+	Delay Semaphore SemaphoreSet SharedQueue
-WindowGroup
+	WindowGroup
-(``Working with processes'': programming/processes.html)
+	(``Working with processes'': programming/processes.html)
 [author:]
-Claus Gittinger
+	Claus Gittinger
 "
 !
 scheduling
 "
 event.
 Timeslicing will not be done for processes running above TimeSlicingPriorityLimit, which
 allows for critical processes to run unaffected to completion.
 WARNING:
-timesliced priority scheduling is an experimental feature. There is no warranty,
+	timesliced priority scheduling is an experimental feature. There is no warranty,
-(at the moment), that the system runs reliable in this mode.
+	(at the moment), that the system runs reliable in this mode.
-The problem is, that shared collections may now be easily modified by other
+	The problem is, that shared collections may now be easily modified by other
-processes, running at the same time.
+	processes, running at the same time.
-The class library has being investigated for such possible trouble spots
+	The class library has being investigated for such possible trouble spots
-(we have eliminated many weak spots, and added critical regions at many places,
+	(we have eliminated many weak spots, and added critical regions at many places,
-but cannot guarantee that all of them have been found so far ...)
+	 but cannot guarantee that all of them have been found so far ...)
-We found that many existing public domain programs are not prepared for
+	We found that many existing public domain programs are not prepared for
-being interrupted by a same-prio process and therefore may corrupt their
+	being interrupted by a same-prio process and therefore may corrupt their
-data. If in doubt, disable this fefature.
+	data. If in doubt, disable this fefature.
 We think, that the timeSlicer is a useful add-on and that the system is fit enough
 for it to be evaluated, therefore, its included.
 However, use it at your own risk.
 To demonstrate the effect of timeSlicing, do the following:
-- disable timeSlicing (in the launchers misc-settings menu)
+	- disable timeSlicing (in the launchers misc-settings menu)
-- open a workSpace
+	- open a workSpace
-- in the workspace, evaluate:
+	- in the workspace, evaluate:
-[true] whileTrue:[1000 factorial]
+		[true] whileTrue:[1000 factorial]
 now, (since the workSpace runs at the same prio as other window-processes),
 other views do no longer react - all CPU is used up by the workSpace.
 However, CTRL-C in the workspace is still possible to stop the endless loop,
 since that is handled by the (higher prio) event dispatcher process.
 TimeSlicingPriorityLimit := 26.
 HighestPriority := 30.
 SchedulingPriority := 31.
 InvalidProcessSignal isNil ifTrue:[
-InvalidProcessSignal := Error newSignalMayProceed:true.
+	InvalidProcessSignal := Error newSignalMayProceed:true.
-InvalidProcessSignal nameClass:self message:#invalidProcessSignal.
+	InvalidProcessSignal nameClass:self message:#invalidProcessSignal.
-InvalidProcessSignal notifierString:'invalid process'.
+	InvalidProcessSignal notifierString:'invalid process'.
 ].
 Processor isNil ifTrue:[
-"create the one and only processor"
+	"create the one and only processor"
-Processor := self basicNew initialize.
+	Processor := self basicNew initialize.
 ].
 "
 allow configurations without processes
 (but such configurations are no longer distributed)
 "
 PureEventDriven := self threadsAvailable not.
 PureEventDriven ifTrue:[
-'Processor [error]: no process support - running event driven' errorPrintCR
+	'Processor [error]: no process support - running event driven' errorPrintCR
 ].
+self initializeVMMaxProcessId
-%{
-#ifndef MAX_PROCESS_ID
-# define MAX_PROCESS_ID _MAX_INT
-#endif
-@global(ProcessorScheduler:MaxProcessId) = __MKSMALLINT(MAX_PROCESS_ID);
-%}
 "Modified: / 23-09-1996 / 14:24:50 / stefan"
 "Modified: / 10-01-1997 / 18:03:03 / cg"
 "Modified: / 19-09-2014 / 12:47:51 / Jan Vrany <jan.vrany@fit.cvut.cz>"
+!
+initializeVMMaxProcessId
+"/ for java locks, the VM may reserve some bits
+"/ and reduce the maximum processID to be able to
+"/ encode the id in an object's header field.
+%{
+#ifndef __SCHTEAM__
+# ifndef MAX_PROCESS_ID
+#  define MAX_PROCESS_ID _MAX_INT
+# endif
+@global(ProcessorScheduler:MaxProcessId) = __MKSMALLINT(MAX_PROCESS_ID);
+RETURN (self);
+#endif /* not SCHTEAM */
+%}.
+MaxProcessId := SmallInteger maxVal.
 ! !
 !ProcessorScheduler class methodsFor:'instance creation'!
 new
 by sending #terminate."
 |id sz "{ Class: SmallInteger }"|
 something == #ElementExpired ifTrue:[
-sz := KnownProcessIds size.
+	sz := KnownProcessIds size.
-1 to:sz do:[:index |
+	1 to:sz do:[:index |
-"/ (KnownProcesses at:index) isNil ifTrue:[
+	    "/ (KnownProcesses at:index) isNil ifTrue:[
-(KnownProcesses at:index) == 0 ifTrue:[
+	    (KnownProcesses at:index) == 0 ifTrue:[
-id := KnownProcessIds at:index.
+		id := KnownProcessIds at:index.
-id notNil ifTrue:[
+		id notNil ifTrue:[
-'Processor [warning]: terminating thread ' errorPrint.
+		    'Processor [warning]: terminating thread ' errorPrint.
-id errorPrint.
+		    id errorPrint.
-' (no longer refd)' errorPrintCR.
+		    ' (no longer refd)' errorPrintCR.
-self threadDestroy:id.
+		    self threadDestroy:id.
-KnownProcessIds at:index put:nil.
+		    KnownProcessIds at:index put:nil.
-].
+		].
-KnownProcesses at:index put:nil.
+		KnownProcesses at:index put:nil.
-]
+	    ]
-]
+	]
 ]
 "Created: 7.1.1997 / 16:45:42 / stefan"
 "Modified: 10.1.1997 / 19:10:48 / cg"
 ! !
 "physical creation of a process.
 (warning: low level entry, no administration done).
 This may raise an exception, if a VM process could not be created."
 MaxNumberOfProcesses notNil ifTrue:[
-KnownProcessIds size >= MaxNumberOfProcesses ifTrue:[
+	KnownProcessIds size >= MaxNumberOfProcesses ifTrue:[
-(KnownProcessIds count:[:el | el notNil]) >= MaxNumberOfProcesses ifTrue:[
+	    (KnownProcessIds count:[:el | el notNil]) >= MaxNumberOfProcesses ifTrue:[
-"
+		"
-the number of processes has reached the (soft) limit.
+		 the number of processes has reached the (soft) limit.
-This limit prevents runaway programs from creating too many
+		 This limit prevents runaway programs from creating too many
-processes. If you continue in the debugger, the process will be
+		 processes. If you continue in the debugger, the process will be
-created as usual. If you dont want this, abort or terminate.
+		 created as usual. If you dont want this, abort or terminate.
-"
+		"
-self error:'too many processes'.
+		self error:'too many processes'.
-]
+	    ]
-]
+	]
 ].
 %{
 int tid;
 extern int __threadCreate();
 tid = __threadCreate(aProcess,
-0   /* stackSize: no longer needed */,
+			 0   /* stackSize: no longer needed */,
-__isSmallInteger(id) ? __intVal(id)     /* assign id */
+			 __isSmallInteger(id) ? __intVal(id)     /* assign id */
-: -1              /* let VM assign one */  );
+					      : -1              /* let VM assign one */  );
 if (tid) {
-RETURN ( __mkSmallInteger(tid));
+	RETURN ( __mkSmallInteger(tid));
 }
 %}
 .
 "
 arrive here, if creation of process in VM failed.
 (warning: low level entry, no administration done)"
 %{  /* NOCONTEXT */
 if (__isSmallInteger(id)) {
-__threadDestroy(__intVal(id));
+	__threadDestroy(__intVal(id));
 }
 %}
 !
 threadInterrupt:id
 interrupt (currently, it looks for interruptBlocks to evaluate)."
 %{  /* NOCONTEXT */
 if (__isSmallInteger(id)) {
-__threadInterrupt(__intVal(id));
+	__threadInterrupt(__intVal(id));
 }
 %}
 !
 threadsAvailable
 knownProcessesDo:aBlock
 "evaluate aBlock for each (living) processes in the system"
 KnownProcesses do:[:p |
-(p notNil and:[p ~~ 0]) ifTrue:[aBlock value:p]
+	(p notNil and:[p ~~ 0]) ifTrue:[aBlock value:p]
 ]
 "Created: / 26-10-2012 / 13:02:33 / cg"
 !
 |idx "{Class: SmallInteger }"
 wasBlocked|
 wasBlocked := OperatingSystem blockInterrupts.
 useIOInterrupts ifTrue:[
-OperatingSystem disableIOInterruptsOn:aFileDescriptor
+	OperatingSystem disableIOInterruptsOn:aFileDescriptor
 ].
 idx := readFdArray identityIndexOf:aFileDescriptor startingAt:1.
 idx ~~ 0 ifTrue:[
-readFdArray at:idx put:nil.
+	readFdArray at:idx put:nil.
-readCheckArray at:idx put:nil.
+	readCheckArray at:idx put:nil.
-readSemaphoreArray at:idx put:nil
+	readSemaphoreArray at:idx put:nil
 ].
 idx := writeFdArray identityIndexOf:aFileDescriptor startingAt:1.
 idx ~~ 0 ifTrue:[
-writeFdArray at:idx put:nil.
+	writeFdArray at:idx put:nil.
-writeCheckArray at:idx put:nil.
+	writeCheckArray at:idx put:nil.
-writeSemaphoreArray at:idx put:nil
+	writeSemaphoreArray at:idx put:nil
 ].
 wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
 "Modified: 4.8.1997 / 15:16:00 / cg"
 !
 |idx "{Class: SmallInteger }"
 wasBlocked|
 aFileDescriptor < 0 ifTrue:[
-'Processor [warning]: ignored invalid fd for IO action.' errorPrintCR.
+	'Processor [warning]: ignored invalid fd for IO action.' errorPrintCR.
-thisContext fullPrintAll.
+	thisContext fullPrintAll.
-^ self
+	^ self
 ].
 wasBlocked := OperatingSystem blockInterrupts.
 (readFdArray identityIndexOf:aFileDescriptor startingAt:1) == 0 ifTrue:[
-idx := readFdArray identityIndexOf:nil startingAt:1.
+	idx := readFdArray identityIndexOf:nil startingAt:1.
-idx ~~ 0 ifTrue:[
+	idx ~~ 0 ifTrue:[
-readFdArray at:idx put:aFileDescriptor.
+	    readFdArray at:idx put:aFileDescriptor.
-readCheckArray at:idx put:aBlock.
+	    readCheckArray at:idx put:aBlock.
-readSemaphoreArray at:idx put:nil
+	    readSemaphoreArray at:idx put:nil
-] ifFalse:[
+	] ifFalse:[
-readFdArray := readFdArray copyWith:aFileDescriptor.
+	    readFdArray := readFdArray copyWith:aFileDescriptor.
-readCheckArray := readCheckArray copyWith:aBlock.
+	    readCheckArray := readCheckArray copyWith:aBlock.
-readSemaphoreArray := readSemaphoreArray copyWith:nil.
+	    readSemaphoreArray := readSemaphoreArray copyWith:nil.
-].
+	].
-useIOInterrupts ifTrue:[
+	useIOInterrupts ifTrue:[
-OperatingSystem enableIOInterruptsOn:aFileDescriptor
+	    OperatingSystem enableIOInterruptsOn:aFileDescriptor
-].
+	].
 ].
 wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
 "Modified: 4.8.1997 / 15:17:28 / cg"
 |wasBlocked|
 wasBlocked := OperatingSystem blockInterrupts.
 idleActions isNil ifTrue:[
-idleActions := OrderedCollection new
+	idleActions := OrderedCollection new
 ].
 idleActions add:aBlock.
 wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
 !
 "
 handle all timeout actions
 "
 anyTimeouts ifTrue:[
-self evaluateTimeouts
+	self evaluateTimeouts
 ].
 "first do a quick check for semaphores using checkActions - this is needed for
 devices like the X-connection, where some events might be in the event
 queue but the sockets input queue is empty.
 sockets and pipes (sigh)
 "
 any := false.
 nActions := readCheckArray size.
 1 to:nActions do:[:index |
-checkBlock := readCheckArray at:index.
+	checkBlock := readCheckArray at:index.
-(checkBlock notNil and:[checkBlock value]) ifTrue:[
+	(checkBlock notNil and:[checkBlock value]) ifTrue:[
-sema := readSemaphoreArray at:index.
+	    sema := readSemaphoreArray at:index.
-sema notNil ifTrue:[
+	    sema notNil ifTrue:[
-sema signalOnce.
+		sema signalOnce.
-].
+	    ].
-any := true.
+	    any := true.
-]
+	]
 ].
 nActions := writeCheckArray size.
 1 to:nActions do:[:index |
-checkBlock := writeCheckArray at:index.
+	checkBlock := writeCheckArray at:index.
-(checkBlock notNil and:[checkBlock value]) ifTrue:[
+	(checkBlock notNil and:[checkBlock value]) ifTrue:[
-sema := writeSemaphoreArray at:index.
+	    sema := writeSemaphoreArray at:index.
-sema notNil ifTrue:[
+	    sema notNil ifTrue:[
-sema signalOnce.
+		sema signalOnce.
-].
+	    ].
-any := true.
+	    any := true.
-]
+	]
 ].
 "now, someone might be runnable ..."
 p := self highestPriorityRunnableProcess.
 p isNil ifTrue:[
-"/ no one runnable, hard wait for event or timeout
+	"/ no one runnable, hard wait for event or timeout
-"/ Trace ifTrue:['w' printCR.].
+	"/ Trace ifTrue:['w' printCR.].
-self waitForEventOrTimeout.
+	self waitForEventOrTimeout.
-"/ check for OS process termination
+	"/ check for OS process termination
-gotChildSignalInterrupt ifTrue:[
+	gotChildSignalInterrupt ifTrue:[
-gotChildSignalInterrupt := false.
+	    gotChildSignalInterrupt := false.
-self handleChildSignalInterrupt
+	    self handleChildSignalInterrupt
-].
+	].
-wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
+	wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
-^ self
+	^ self
 ].
 pri := p priority.
 "
 (a future version will have a process running to handle a timeout queue)
 "
 "
 pri < TimingPriority ifTrue:[
-anyTimeouts ifTrue:[
+	anyTimeouts ifTrue:[
-millis := self timeToNextTimeout.
+	    millis := self timeToNextTimeout.
-millis == 0 ifTrue:[
+	    millis == 0 ifTrue:[
-wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
+		wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
-^ self
+		^ self
-]
+	    ]
-]
+	]
 ].
 "
 "
 if the process to run has a lower than UserInterruptPriority,
 or by installing a poll-interrupt after 50ms (if the OS does not).
 "
 pri < UserInterruptPriority ifTrue:[
 "comment out this if above is uncommented"
-anyTimeouts ifTrue:[
+	anyTimeouts ifTrue:[
-millis := self timeToNextTimeout.
+	    millis := self timeToNextTimeout.
-millis == 0 ifTrue:[
+	    millis == 0 ifTrue:[
-wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
+		wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
-^ self
+		^ self
-].
+	    ].
-].
+	].
 "---"
-useIOInterrupts ifTrue:[
+	useIOInterrupts ifTrue:[
 "/            readFdArray do:[:fd |
 "/                (fd notNil and:[fd >= 0]) ifTrue:[
 "/                    OperatingSystem enableIOInterruptsOn:fd
 "/                ].
 "/            ].
-] ifFalse:[
+	] ifFalse:[
-millis notNil ifTrue:[
+	    millis notNil ifTrue:[
-millis := millis min:EventPollingInterval
+		millis := millis min:EventPollingInterval
-] ifFalse:[
+	    ] ifFalse:[
-millis := EventPollingInterval
+		millis := EventPollingInterval
-]
+	    ]
-]
+	]
 ].
 millis notNil ifTrue:[
-"/ Trace ifTrue:['C' print. millis printCR.].
+	"/ Trace ifTrue:['C' print. millis printCR.].
-"schedule a clock interrupt after millis milliseconds"
+	"schedule a clock interrupt after millis milliseconds"
-OperatingSystem enableTimer:millis rounded.
+	OperatingSystem enableTimer:millis rounded.
 ].
 scheduledProcesses notNil ifTrue:[
-scheduledProcesses add:p
+	scheduledProcesses add:p
 ].
 "
 now let the process run - will come back here by reschedule
 from ioInterrupt, scheduler or timerInterrupt ... (running at max+1)
 "/ Trace ifTrue:['->' print. p printCR.].
 self threadSwitch:p.
 "/ Trace ifTrue:['<-' printCR.].
 "... when we arrive here, we are back on stage.
-Either by an ALARM or IO signal, or by a suspend of another process
+	 Either by an ALARM or IO signal, or by a suspend of another process
 "
 millis notNil ifTrue:[
-OperatingSystem disableTimer.
+	OperatingSystem disableTimer.
 ].
 "/ check for OS process termination
 gotChildSignalInterrupt ifTrue:[
-gotChildSignalInterrupt := false.
+	gotChildSignalInterrupt := false.
-self handleChildSignalInterrupt
+	self handleChildSignalInterrupt
 ].
 "/ check for new input
 OperatingSystem unblockInterrupts.
 (gotIOInterrupt or:[useIOInterrupts not]) ifTrue:[
-gotIOInterrupt := false.
+	gotIOInterrupt := false.
-self checkForIOWithTimeout:0.
+	self checkForIOWithTimeout:0.
 ].
 wasBlocked ifTrue:[OperatingSystem blockInterrupts].
 "Modified: / 12.4.1996 / 10:14:18 / stefan"
 |dispatchAction handlerAction ignoredSignals|
 "avoid confusion if entered twice"
 dispatching == true ifTrue:[
-'Processor [info]: already in dispatch' infoPrintCR.
+	'Processor [info]: already in dispatch' infoPrintCR.
-^ self
+	^ self
 ].
 dispatching := true.
 "/ create the relevant blocks & signalSet outside of the
 "/ while-loop
 "/  this safes a bit of memory allocation in the scheduler)
 dispatchAction := [ [dispatching] whileTrue:[ self dispatch ] ].
 handlerAction := [:ex |
-(HaltInterrupt accepts:ex creator) ifTrue:[
+			(HaltInterrupt accepts:ex creator) ifTrue:[
-"/ in a standalone application, we do not want those
+			    "/ in a standalone application, we do not want those
-Smalltalk isStandAloneApp ifTrue:[
+			    Smalltalk isStandAloneApp ifTrue:[
-Smalltalk isStandAloneDebug ifFalse:[
+				Smalltalk isStandAloneDebug ifFalse:[
-('Processor [info]: ignored (', ex creator printString, ')') infoPrintCR.
+				    ('Processor [info]: ignored (', ex creator printString, ')') infoPrintCR.
-ex proceed.
+				    ex proceed.
-]
+				]
-].
+			    ].
-].
+			].
-('Processor [info]: caught (and ignored) signal (', ex creator printString, ')') infoPrintCR.
+			('Processor [info]: caught (and ignored) signal (', ex creator printString, ')') infoPrintCR.
-ex return
+			ex return
-].
+		     ].
 ignoredSignals := SignalSet
-with:HaltInterrupt
+			with:HaltInterrupt
-with:TerminateProcessRequest
+			with:TerminateProcessRequest
-with:RecursionError
+			with:RecursionError
-with:AbortAllOperationRequest.
+			with:AbortAllOperationRequest.
 "/
 "/ I made this an extra call to dispatch; this allows recompilation
 "/  of the dispatch-handling code in the running system.
 "/
 [dispatching] whileTrue:[
-ignoredSignals handle:handlerAction do:dispatchAction
+	ignoredSignals handle:handlerAction do:dispatchAction
 ].
 "/ we arrive here in standalone Apps,
 "/ when the last process at or above UserSchedulingPriority process died.
 "/ regular ST/X stays in above loop forever
 |nPrios "{ Class: SmallInteger }"
 p l|
 KnownProcesses isNil ifTrue:[
-KnownProcesses := WeakArray new:30.
+	KnownProcesses := WeakArray new:30.
-KnownProcesses addDependent:self class.
+	KnownProcesses addDependent:self class.
-KnownProcessIds := OrderedCollection new:30.
+	KnownProcessIds := OrderedCollection new:30.
 ].
 "
 create a collection with process lists; accessed using the priority as key
 "
 osChildExitActions := Dictionary new.
 gotChildSignalInterrupt := false.
 supportDynamicPriorities := false.
 exitWhenNoMoreUserProcesses isNil ifTrue:[
-exitWhenNoMoreUserProcesses := false. "/ mhmh - how about true ?
+	exitWhenNoMoreUserProcesses := false. "/ mhmh - how about true ?
 ].
 "
 handcraft the first (dispatcher-) process - this one will never
 block, but go into a select if there is nothing to do.
 Also, it has a prio of max+1 - thus, it comes first when looking
 for a runnable process.
 "
 currentPriority := SchedulingPriority.
 p := Process basicNew.
 p
-setId:0 state:#run;
+	setId:0 state:#run;
-setPriority:currentPriority;
+	setPriority:currentPriority;
-name:'scheduler';
+	name:'scheduler';
-beSystemProcess.
+	beSystemProcess.
 scheduler := activeProcess := p.
 activeProcessId := 0.
 quiescentProcessLists at:currentPriority put:(l := LinkedList new).
 "
 let me handle IO and timer interrupts
 "
 useIOInterrupts ifTrue:[ObjectMemory ioInterruptHandler:self].
 ObjectMemory
-timerInterruptHandler:self;
+	timerInterruptHandler:self;
-childSignalInterruptHandler:self.
+	childSignalInterruptHandler:self.
 "Modified: / 7.1.1997 / 16:48:26 / stefan"
 "Modified: / 4.2.1999 / 13:08:39 / cg"
 !
 "
 lay all processes to rest, collect restartable ones
 "
 processesToRestart := OrderedCollection new.
 KnownProcesses do:[:p |
-(p notNil and:[p ~~ 0]) ifTrue:[
+	(p notNil and:[p ~~ 0]) ifTrue:[
-"how, exactly should this be done ?"
+	    "how, exactly should this be done ?"
-p isRestartable == true ifTrue:[
+	    p isRestartable == true ifTrue:[
-p nextLink:nil.
+		p nextLink:nil.
-processesToRestart add:p
+		processesToRestart add:p
-] ifFalse:[
+	    ] ifFalse:[
-p setId:nil state:#dead
+		p setId:nil state:#dead
-]
+	    ]
-].
+	].
 ].
 scheduler setId:nil state:#dead.
 "
 now, start from scratch
 "
 KnownProcesses := nil.
 self initialize.
 processesToRestart do:[:p |
-p imageRestart
+	p imageRestart
 ]
 "Modified: / 7.6.1998 / 02:23:56 / cg"
 ! !
 <context: #return>
 |index pri aProcess l|
 OperatingSystem interruptsBlocked ifFalse:[
-MiniDebugger
+	MiniDebugger
-enterWithMessage:'vmResumeInterrupt with no interruptsBlocked'
+	    enterWithMessage:'vmResumeInterrupt with no interruptsBlocked'
-mayProceed:true.
+	    mayProceed:true.
 ].
 index := KnownProcessIds identityIndexOf:id.
 index ~~ 0 ifTrue:[
-aProcess := KnownProcesses at:index.
+	aProcess := KnownProcesses at:index.
-pri := aProcess priority.
+	pri := aProcess priority.
-l := quiescentProcessLists at:pri.
+	l := quiescentProcessLists at:pri.
-l notNil ifTrue:[
+	l notNil ifTrue:[
-(l includesIdentical:aProcess) ifTrue:[
+	    (l includesIdentical:aProcess) ifTrue:[
-"/ aProcess is on a run queue.
+		"/ aProcess is on a run queue.
-"/ CG: this situation may happen, if the wrapCall
+		"/ CG: this situation may happen, if the wrapCall
-"/ finishes before the process was layed to sleep
+		"/ finishes before the process was layed to sleep
-"/ (i.e. schedulerIRQ arrives before the threadSwitch was finished).
+		"/ (i.e. schedulerIRQ arrives before the threadSwitch was finished).
-"/ In that case, simply resume it and everything is OK.
+		"/ In that case, simply resume it and everything is OK.
-"/ If the process is state running, ignore.
+		"/ If the process is state running, ignore.
-|state|
+		|state|
-state := aProcess state.
+		state := aProcess state.
-(state == #wrapWait or:[state == #osWait] or:[state == #stopped]) ifTrue:[
+		(state == #wrapWait or:[state == #osWait] or:[state == #stopped]) ifTrue:[
-aProcess state:#run.
+		    aProcess state:#run.
-].
+		].
-'ProcSched [info]: resumeIRQ ignored for process: ' infoPrint.
+		'ProcSched [info]: resumeIRQ ignored for process: ' infoPrint.
-aProcess id infoPrint. ' in state: ' infoPrint. state infoPrintCR.
+		aProcess id infoPrint. ' in state: ' infoPrint. state infoPrintCR.
-^ self
+		^ self
-]
+	    ]
-] ifFalse:[
+	] ifFalse:[
-l := LinkedList new.
+	    l := LinkedList new.
-quiescentProcessLists at:pri put:l.
+	    quiescentProcessLists at:pri put:l.
-].
+	].
-l addLast:aProcess.
+	l addLast:aProcess.
-aProcess state:#run.
+	aProcess state:#run.
 ] ifFalse:[
-'ProcSched [info]: resumeIRQ for unknown process: ' infoPrint.
+	'ProcSched [info]: resumeIRQ for unknown process: ' infoPrint.
-id infoPrintCR.
+	id infoPrintCR.
 ]
 "Modified: / 28.9.1998 / 11:36:53 / cg"
 !
 <context: #return>
 |pri l newState|
 OperatingSystem interruptsBlocked ifFalse:[
-MiniDebugger
+	MiniDebugger
-enterWithMessage:'immediateInterrupt with no interruptsBlocked'
+	    enterWithMessage:'immediateInterrupt with no interruptsBlocked'
-mayProceed:true.
+	    mayProceed:true.
 ].
 (whyCode == 2) ifTrue:[
-newState := #wrapWait.
+	 newState := #wrapWait.
 ] ifFalse:[
-(whyCode == 3) ifTrue:[
+	(whyCode == 3) ifTrue:[
-newState := #osWait.
+	    newState := #osWait.
-] ifFalse:[
+	] ifFalse:[
-newState := #stopped.
+	    newState := #stopped.
-].
+	].
 ].
 activeProcess setStateTo:newState if:#active.
 pri := activeProcess priority.
 l := quiescentProcessLists at:pri.
 "notice: this is slightly faster than putting the if-code into
 the ifAbsent block, because [] is a shared cheap block, created at compile time
 "
 (l isNil or:[(l removeIdentical:activeProcess ifAbsent:nil) isNil]) ifTrue:[
-"/ 'Processor [warning]: bad vmSuspendInterrupt: not on run list' errorPrintCR.
+	"/ 'Processor [warning]: bad vmSuspendInterrupt: not on run list' errorPrintCR.
-MiniDebugger enterWithMessage:'bad vmSuspendInterrupt: not on run list' mayProceed:true.
+	MiniDebugger enterWithMessage:'bad vmSuspendInterrupt: not on run list' mayProceed:true.
-^ self
+	^ self
 ].
 ! !
 !ProcessorScheduler methodsFor:'os process handling'!
 "child changed state - switch to scheduler process which will decide
 what to do now."
 gotChildSignalInterrupt := true.
 activeProcess ~~ scheduler ifTrue:[
-interruptedProcess := activeProcess.
+	interruptedProcess := activeProcess.
-self threadSwitch:scheduler
+	self threadSwitch:scheduler
 ]
 "Modified: 12.4.1996 / 10:12:18 / stefan"
 !
 blocking := OperatingSystem blockingChildProcessWait.
 "/ no interrupt processing, to avoid races with monitorPid
 wasBlocked := OperatingSystem blockInterrupts.
 [
-[
+	[
-osProcessStatus := OperatingSystem childProcessWait:blocking pid:nil.
+	    osProcessStatus := OperatingSystem childProcessWait:blocking pid:nil.
-osProcessStatus notNil ifTrue:[
+	    osProcessStatus notNil ifTrue:[
-|pid action|
+		|pid action|
-pid := osProcessStatus pid.
+		pid := osProcessStatus pid.
-osProcessStatus stillAlive ifTrue:[
+		osProcessStatus stillAlive ifTrue:[
-action := osChildExitActions at:pid ifAbsent:nil.
+		    action := osChildExitActions at:pid ifAbsent:nil.
-] ifFalse:[
+		] ifFalse:[
-action := osChildExitActions removeKey:pid ifAbsent:nil.
+		    action := osChildExitActions removeKey:pid ifAbsent:nil.
-].
+		].
-action notNil ifTrue:[
+		action notNil ifTrue:[
-action value:osProcessStatus
+		    action value:osProcessStatus
-].
+		].
-].
+	    ].
-"/ if pollChildProcesses does block, poll only one status change.
+	    "/ if pollChildProcesses does block, poll only one status change.
-"/ we will get another SIGCHLD for other status changes.
+	    "/ we will get another SIGCHLD for other status changes.
-osProcessStatus notNil and:[blocking not]
+	    osProcessStatus notNil and:[blocking not]
-] whileTrue.
+	] whileTrue.
-"/ if there are no more waiters, disable SIGCHILD handler.
+	"/ if there are no more waiters, disable SIGCHILD handler.
-"/ this helps us with synchronous waiters (e.g. pclose),
+	"/ this helps us with synchronous waiters (e.g. pclose),
-"/ But they should block SIGCHLD anyway.
+	"/ But they should block SIGCHLD anyway.
-osChildExitActions isEmpty ifTrue:[
+	osChildExitActions isEmpty ifTrue:[
-OperatingSystem disableChildSignalInterrupts.
+	    OperatingSystem disableChildSignalInterrupts.
-].
+	].
 ] ensure:[
-wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
+	wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
 ]
 "Modified: 5.1.1996 / 16:56:11 / stefan"
 "Modified: 28.2.1996 / 21:36:31 / cg"
 "Created: 12.4.1996 / 10:08:21 / stefan"
 OperatingSystem enableChildSignalInterrupts.        "/ no-op in windows
 wasBlocked := OperatingSystem blockInterrupts.
 "/ start the OS-Process
 pid := aBlockReturningPid value.
 pid notNil ifTrue:[
-osChildExitActions at:pid put:actionBlock.
+	osChildExitActions at:pid put:actionBlock.
 ].
 wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
 ^ pid
 "Created: / 25.3.1997 / 10:54:56 / stefan"
 scheduleForInterrupt:aProcess
 "make aProcess evaluate its pushed interrupt block(s)"
 self scheduleInterruptActionsOf:aProcess.
 aProcess state ~~ #stopped ifTrue:[
-"
+	"
-make the process runnable
+	 make the process runnable
-"
+	"
-self resume:aProcess
+	self resume:aProcess
 ]
 "Modified: / 24.8.1998 / 18:31:32 / cg"
 !
 "/    ok := self threadSwitchFrom:oldProcess to:aProcess id:id singleStep:singleStep.
 %{
 extern OBJ ___threadSwitch();
 if (__isSmallInteger(id)) {
-ok = ___threadSwitch(__context, __intVal(id), (singleStep == true) ? 1 : 0, 0);
+	ok = ___threadSwitch(__context, __intVal(id), (singleStep == true) ? 1 : 0, 0);
 } else {
-ok = false;
+	ok = false;
 }
 %}.
 "time passes spent in some other process ...
 ... here again"
 activeProcess := oldProcess.
 activeProcessId := oldId.
 currentPriority := oldProcess priority.
 ok == true ifFalse:[
-"
+	"
-switch failed for some reason -
+	 switch failed for some reason -
-destroy (hard-terminate) the bad process.
+	 destroy (hard-terminate) the bad process.
-This happens when:
+	 This happens when:
-- the stack went above the absolute limit
+	 - the stack went above the absolute limit
-(VM switches back to scheduler)
+	   (VM switches back to scheduler)
-- a halted process cannot execute its interrupt
+	 - a halted process cannot execute its interrupt
-actions (win32 only)
+	   actions (win32 only)
-"
+	"
-(id := p id) ~~ 0 ifTrue:[
+	(id := p id) ~~ 0 ifTrue:[
-id notNil ifTrue:[
+	    id notNil ifTrue:[
-'Processor [warning]: problem with process ' errorPrint.
+		'Processor [warning]: problem with process ' errorPrint.
-id errorPrint.
+		id errorPrint.
-(nm := p name) notNil ifTrue:[
+		(nm := p name) notNil ifTrue:[
-' (' errorPrint. nm errorPrint. ')' errorPrint.
+		    ' (' errorPrint. nm errorPrint. ')' errorPrint.
-].
+		].
-ok == #halted ifTrue:[
+		ok == #halted ifTrue:[
-"/ that process was halted (win32 only)
+		    "/ that process was halted (win32 only)
-p state:#halted.
+		    p state:#halted.
-'; stopped it.' errorPrintCR.
+		   '; stopped it.' errorPrintCR.
-self suspend:p.
+		   self suspend:p.
-] ifFalse:[
+		] ifFalse:[
-'; hard-terminate it.' errorPrintCR.
+		   '; hard-terminate it.' errorPrintCR.
-'Processor [info]: cleanup may take a while if stack is huge' infoPrintCR.
+		   'Processor [info]: cleanup may take a while if stack is huge' infoPrintCR.
-p state:#cleanup.
+		   p state:#cleanup.
-self terminateNoSignal:p.
+		   self terminateNoSignal:p.
-]
+		]
-]
+	    ]
-]
+	]
 ].
 zombie notNil ifTrue:[
-self class threadDestroy:zombie.
+	self class threadDestroy:zombie.
-zombie := nil
+	zombie := nil
 ].
 wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
 "Modified: / 23-07-2010 / 10:32:11 / cg"
 ! !
 wasBlocked := OperatingSystem blockInterrupts.
 index := 1.
 sz := KnownProcessIds size.
 [index <= sz] whileTrue:[
-(KnownProcesses at:index) isNil ifTrue:[
+	(KnownProcesses at:index) isNil ifTrue:[
-oldId := KnownProcessIds at:index.
+	    oldId := KnownProcessIds at:index.
-oldId notNil ifTrue:[
+	    oldId notNil ifTrue:[
-self class threadDestroy:oldId.
+		self class threadDestroy:oldId.
-].
+	    ].
-KnownProcesses at:index put:aProcess.
+	    KnownProcesses at:index put:aProcess.
-KnownProcessIds at:index put:aProcess id.
+	    KnownProcessIds at:index put:aProcess id.
-wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
+	    wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
-^ self
+	    ^ self
-].
+	].
-index := index + 1
+	index := index + 1
 ].
 KnownProcessIds grow:index.
 KnownProcessIds at:index put:aProcess id.
 oldSize := KnownProcesses size.
 (index > oldSize) ifTrue:[
-newShadow := WeakArray new:(oldSize * 2).
+	newShadow := WeakArray new:(oldSize * 2).
-newShadow addDependent:self class.
+	newShadow addDependent:self class.
-newShadow replaceFrom:1 with:KnownProcesses.
+	newShadow replaceFrom:1 with:KnownProcesses.
-KnownProcesses := newShadow
+	KnownProcesses := newShadow
 ].
 KnownProcesses at:index put:aProcess.
 wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
 "Modified: 7.1.1997 / 16:48:39 / stefan"
 |index wasBlocked|
 wasBlocked := OperatingSystem blockInterrupts.
 index := KnownProcesses identityIndexOf:aProcess.
 index ~~ 0 ifTrue:[
-KnownProcessIds at:index put:nil.
+	KnownProcessIds at:index put:nil.
-KnownProcesses at:index put:nil.
+	KnownProcesses at:index put:nil.
 ].
 wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
 ! !
 !ProcessorScheduler methodsFor:'process creation'!
 newProcessFor:aProcess withId:idWant
 "private entry for Process restart - do not use in your program"
 idWant isNil ifTrue:[
-self newProcessFor:aProcess.
+	self newProcessFor:aProcess.
-^ true.
+	^ true.
 ].
 (self class threadCreate:aProcess withId:idWant) ~~ idWant ifTrue:[
-^ false
+	^ false
 ].
 aProcess state:#light.   "meaning: has no stack yet"
 self remember:aProcess.
 ^ true
 wasBlocked := OperatingSystem blockInterrupts.
 listArray := quiescentProcessLists.
 [prio >= 1] whileTrue:[
-l := listArray at:prio.
+	l := listArray at:prio.
-l notNil ifTrue:[
+	l notNil ifTrue:[
-l linksDo:[:aProcess |
+	    l linksDo:[:aProcess |
-aProcess isUserProcess ifTrue:[
+		aProcess isUserProcess ifTrue:[
-wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
+		    wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
-^ true.
+		    ^ true.
-]
+		]
-]
+	    ]
-].
+	].
-prio := prio - 1
+	prio := prio - 1
 ].
 wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
 ^ false
 "
 prio := HighestPriority.
 wasBlocked := OperatingSystem blockInterrupts.
 listArray := quiescentProcessLists.
 [prio >= 1] whileTrue:[
-l := listArray at:prio.
+	l := listArray at:prio.
-l notNil ifTrue:[
+	l notNil ifTrue:[
-l notEmpty ifTrue:[
+	    l notEmpty ifTrue:[
-p := l firstLink.
+		p := l firstLink.
-"
+		"
-if it got corrupted somehow ...
+		 if it got corrupted somehow ...
-"
+		"
-p isDead ifTrue:[
+		p isDead ifTrue:[
-'Processor [warning]: dead process removed' errorPrintCR.
+		    'Processor [warning]: dead process removed' errorPrintCR.
-l removeFirst.
+		    l removeFirst.
-p := nil.
+		    p := nil.
-].
+		].
-wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
+		wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
-^ p
+		^ p
-]
+	    ]
-].
+	].
-prio := prio - 1
+	prio := prio - 1
 ].
 wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
 ^ nil
 "Modified: 12.2.1997 / 12:41:49 / cg"
 wasBlocked := OperatingSystem blockInterrupts.
 slot := KnownProcessIds indexOf:anInteger.
 slot ~~ 0 ifTrue:[
-process := KnownProcesses at:slot ifAbsent:[].
+	process := KnownProcesses at:slot ifAbsent:[].
 ].
 wasBlocked ifFalse:[
-OperatingSystem unblockInterrupts.
+	OperatingSystem unblockInterrupts.
 ].
 "Take care, the process may already have been collected"
 process == 0 ifTrue:[
-^ nil.
+	^ nil.
 ].
 ^ process.
 "
-Processor processWithId:4
+	Processor processWithId:4
-Processor processWithId:4711
+	Processor processWithId:4711
 "
 ! !
 !ProcessorScheduler methodsFor:'scheduling'!
 "
 check for valid argument
 "
 newPrio := prio.
 newPrio < 1 ifTrue:[
-newPrio := 1.
+	newPrio := 1.
 ] ifFalse:[
-newPrio > HighestPriority ifTrue:[
+	newPrio > HighestPriority ifTrue:[
-newPrio := HighestPriority
+	    newPrio := HighestPriority
-]
+	]
 ].
 [
-wasBlocked := OperatingSystem blockInterrupts.
+	wasBlocked := OperatingSystem blockInterrupts.
-aProcess setPriority:newPrio.
+	aProcess setPriority:newPrio.
-oldList := quiescentProcessLists at:oldPrio.
+	oldList := quiescentProcessLists at:oldPrio.
-oldList notNil ifTrue:[
+	oldList notNil ifTrue:[
-(oldList removeIdentical:aProcess ifAbsent:nil) notNil ifTrue:[
+	    (oldList removeIdentical:aProcess ifAbsent:nil) notNil ifTrue:[
-newList := quiescentProcessLists at:newPrio.
+		newList := quiescentProcessLists at:newPrio.
-newList isNil ifTrue:[
+		newList isNil ifTrue:[
-quiescentProcessLists at:newPrio put:(newList := LinkedList new).
+		    quiescentProcessLists at:newPrio put:(newList := LinkedList new).
-].
+		].
-newList addLast:aProcess.
+		newList addLast:aProcess.
-"if its the current process lowering its prio
+		"if its the current process lowering its prio
-or another one raising, we have to reschedule"
+		 or another one raising, we have to reschedule"
-aProcess == activeProcess ifTrue:[
+		aProcess == activeProcess ifTrue:[
-currentPriority := newPrio.
+		    currentPriority := newPrio.
-newPrio < oldPrio ifTrue:[
+		    newPrio < oldPrio ifTrue:[
-self threadSwitch:scheduler.
+			self threadSwitch:scheduler.
-]
+		    ]
-] ifFalse:[
+		] ifFalse:[
-newPrio > currentPriority ifTrue:[
+		    newPrio > currentPriority ifTrue:[
-self threadSwitch:aProcess.
+			self threadSwitch:aProcess.
-]
+		    ]
-].
+		].
-timeSliceNeededSemaphore notNil ifTrue:[
+		timeSliceNeededSemaphore notNil ifTrue:[
-"/ tell timeslicer, that some work might be needed...
+		    "/ tell timeslicer, that some work might be needed...
-timeSliceNeededSemaphore signalIf.
+		    timeSliceNeededSemaphore signalIf.
-]
+		]
-]
+	    ]
-]
+	]
 ] ensure:[
-wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
+	wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
 ]
 "Modified: / 4.8.1998 / 00:08:54 / cg"
 !
 "/ the interrupt block should think it was called right
 "/ from the originally interrupted context
 s := thisContext sender.
 s selector == #threadSwitchFrom:to:id:singleStep: ifTrue:[
-s := s sender.
+	s := s sender.
-s selector == #threadSwitch: ifTrue:[
+	s selector == #threadSwitch: ifTrue:[
-s := s sender.
+	    s := s sender.
-s selector == #timerInterrupt ifTrue:[
+	    s selector == #timerInterrupt ifTrue:[
-s := s sender
+		s := s sender
-]
+	    ]
-]
+	]
 ].
 "/ the returned value here has a subtle effect:
 "/ if false, the interrupt is assumed to be not taken,
 "/ and will be redelivered.
 "ignore, if process is already dead"
 (aProcess isNil or:[aProcess isDead]) ifTrue:[^ false].
 s := aProcess state.
 s == #osWait ifTrue:[
-'Processor [warning]: bad resume: #osWait' errorPrintCR.
+	'Processor [warning]: bad resume: #osWait' errorPrintCR.
-"/ MiniDebugger enterWithMessage:'bad resume: state osWait'.
+	"/ MiniDebugger enterWithMessage:'bad resume: state osWait'.
-^ false.
+	^ false.
 ].
 s == #stopped ifTrue:[
-"by definition, stopped processes cannot be resumed"
+	"by definition, stopped processes cannot be resumed"
-^ false.
+	^ false.
 ].
 aProcess == activeProcess ifTrue:[
-"special handling for waiting schedulers"
+	"special handling for waiting schedulers"
-aProcess == scheduler ifTrue:[
+	aProcess == scheduler ifTrue:[
-suspendScheduler := false.
+	    suspendScheduler := false.
-].
+	].
-^ false
+	^ false
 ].
 wasBlocked := OperatingSystem blockInterrupts.
 pri := aProcess priority.
 l := quiescentProcessLists at:pri.
 "if already running, ignore"
 l notNil ifTrue:[
-(l identityIndexOf:aProcess) ~~ 0 ifTrue:[
+	(l identityIndexOf:aProcess) ~~ 0 ifTrue:[
-wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
+	    wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
-^ false
+	    ^ false
-]
+	]
 ] ifFalse:[
-l := LinkedList new.
+	l := LinkedList new.
-quiescentProcessLists at:pri put:l.
+	quiescentProcessLists at:pri put:l.
 ].
 l addLast:aProcess.
 aProcess state:#run.
 wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
 pri > currentPriority ifTrue:[
-"must reschedule"
+	"must reschedule"
-^ true.
+	^ true.
 ].
 timeSliceNeededSemaphore notNil ifTrue:[
-"/ tell timeslicer, that some work might be needed...
+	"/ tell timeslicer, that some work might be needed...
-timeSliceNeededSemaphore signalIf.
+	timeSliceNeededSemaphore signalIf.
 ].
 ^ false.
 "Modified: / 29.7.1996 / 12:07:37 / cg"
 "Created: / 4.2.1998 / 20:58:28 / cg"
 resume:aProcess
 "set aProcess runnable -
 if its prio is higher than the currently running prio, switch to it."
 (self makeRunnable:aProcess) ifTrue:[
-"aProcess prio is higher; immediately transfer control to it"
+	"aProcess prio is higher; immediately transfer control to it"
-self threadSwitch:aProcess.
+	self threadSwitch:aProcess.
 ].
 !
 resumeForSingleSend:aProcess
 "like resume, but let the process execute a single send only.
 suspend:aProcess
 "remove the argument, aProcess from the list of runnable processes.
 If the process is the current one, reschedule.
 Notice:
-This method should only be called by Process>>suspend or
+	 This method should only be called by Process>>suspend or
-Process>>suspendWithState:"
+	 Process>>suspendWithState:"
 |pri l p wasBlocked|
 "
 some debugging stuff
 "
 aProcess isNil ifTrue:[
-InvalidProcessSignal raiseRequestWith:aProcess errorString:'nil suspend'.
+	InvalidProcessSignal raiseRequestWith:aProcess errorString:'nil suspend'.
-^ self
+	^ self
 ].
 aProcess isDead ifTrue:[
-InvalidProcessSignal raiseRequestWith:aProcess errorString:'bad suspend: already dead'.
+	InvalidProcessSignal raiseRequestWith:aProcess errorString:'bad suspend: already dead'.
-self threadSwitch:scheduler.
+	self threadSwitch:scheduler.
-^ self
+	^ self
 ].
 aProcess == scheduler ifTrue:[
-"only the scheduler may suspend itself"
+	"only the scheduler may suspend itself"
-activeProcess == scheduler ifTrue:[
+	activeProcess == scheduler ifTrue:[
-suspendScheduler := true.
+	    suspendScheduler := true.
-[suspendScheduler] whileTrue:[
+	    [suspendScheduler] whileTrue:[
-self dispatch.
+		self dispatch.
-].
+	    ].
-^ self
+	    ^ self
-].
+	].
-InvalidProcessSignal raiseRequestWith:aProcess errorString:'attempt to suspend scheduler'.
+	InvalidProcessSignal raiseRequestWith:aProcess errorString:'attempt to suspend scheduler'.
-^ self
+	^ self
 ].
 aProcess hasInterruptActions ifTrue:[
-aProcess interrupt.
+	aProcess interrupt.
 ].
 wasBlocked := OperatingSystem blockInterrupts.
 pri := aProcess priority.
 "notice: this is slightly faster than putting the if-code into
 the ifAbsent block, because [] is a shared cheap block, created at compile time
 "
 (l isNil or:[(l removeIdentical:aProcess ifAbsent:nil) isNil]) ifTrue:[
-"/ 'Processor [warning]: bad suspend: process is not running' errorPrintCR.
+	"/ 'Processor [warning]: bad suspend: process is not running' errorPrintCR.
-"/ MiniDebugger enterWithMessage:'bad suspend: process is not running'.
+	"/ MiniDebugger enterWithMessage:'bad suspend: process is not running'.
-aProcess == activeProcess ifTrue:[
+	aProcess == activeProcess ifTrue:[
-self threadSwitch:scheduler.
+	    self threadSwitch:scheduler.
-].
+	].
-wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
+	wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
-^ self
+	^ self
 ].
 (aProcess == activeProcess) ifTrue:[
-"we can immediately switch sometimes"
+	"we can immediately switch sometimes"
-l isEmpty ifTrue:[
+	l isEmpty ifTrue:[
-p := scheduler
+	    p := scheduler
-] ifFalse:[
+	] ifFalse:[
-p := l firstLink
+	    p := l firstLink
-].
+	].
-self threadSwitch:p
+	self threadSwitch:p
 ].
 wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
 "Modified: / 23.9.1996 / 13:49:24 / stefan"
 |pri id l wasBlocked|
 aProcess isNil ifTrue:[^ self].
 aProcess == scheduler ifTrue:[
-InvalidProcessSignal raiseWith:aProcess errorString:'attempt to terminate scheduler'.
+	InvalidProcessSignal raiseWith:aProcess errorString:'attempt to terminate scheduler'.
-^ self
+	^ self
 ].
 wasBlocked := OperatingSystem blockInterrupts.
 id := aProcess id.
 id isNil ifTrue:[   "already dead"
-wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
+	wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
-^ self
+	^ self
 ].
 aProcess setId:nil state:#dead.
 "remove the process from the runnable list"
 pri := aProcess priority.
 l := quiescentProcessLists at:pri.
 l notNil ifTrue:[
-(l removeIdentical:aProcess ifAbsent:nil) "notNil ifTrue:[
+	(l removeIdentical:aProcess ifAbsent:nil) "notNil ifTrue:[
-l isEmpty ifTrue:[
+	    l isEmpty ifTrue:[
-quiescentProcessLists at:pri put:nil
+		quiescentProcessLists at:pri put:nil
-]
+	    ]
-]."
+	]."
 ].
 aProcess == activeProcess ifTrue:[
-"
+	"
-hard case - it's the currently running process
+	 hard case - it's the currently running process
-we must have the next active process destroy this one
+	 we must have the next active process destroy this one
-(we cannot destroy the chair we are sitting on ... :-)
+	 (we cannot destroy the chair we are sitting on ... :-)
-"
+	"
-zombie notNil ifTrue:[
+	zombie notNil ifTrue:[
-self error:'active process is zombie' mayProceed:true.
+	    self error:'active process is zombie' mayProceed:true.
-self class threadDestroy:zombie.
+	    self class threadDestroy:zombie.
-].
+	].
-self unRemember:aProcess.
+	self unRemember:aProcess.
-zombie := id.
+	zombie := id.
-wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
+	wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
-self threadSwitch:scheduler.
+	self threadSwitch:scheduler.
-"not reached"
+	"not reached"
-^ self
+	^ self
 ].
 self unRemember:aProcess.
 self class threadDestroy:id.
 |l sz wasBlocked|
 wasBlocked := OperatingSystem blockInterrupts.
 activeProcess == scheduler ifTrue:[
-'Processor [warning]: scheduler tries to yield' errorPrintCR.
+	'Processor [warning]: scheduler tries to yield' errorPrintCR.
-^ self
+	^ self
 ].
 "
 debugging consistency check - will be removed later
 "
 activeProcess priority ~~ currentPriority ifTrue:[
-'Processor [warning]: process changed its priority' errorPrintCR.
+	'Processor [warning]: process changed its priority' errorPrintCR.
-currentPriority := activeProcess priority.
+	currentPriority := activeProcess priority.
 ].
 l := quiescentProcessLists at:currentPriority.
 sz := l size.
 "
 debugging consistency checks - will be removed later
 "
 sz == 0 ifTrue:[
-wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
+	wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
-'Processor [warning]: empty runnable list' errorPrintCR.
+	'Processor [warning]: empty runnable list' errorPrintCR.
-^ self
+	^ self
 ].
 "
 check if the running process is not the only one
 "
 sz ~~ 1 ifTrue:[
-"
+	"
-bring running process to the end
+	 bring running process to the end
-"
+	"
-l removeFirst.
+	l removeFirst.
-l addLast:activeProcess.
+	l addLast:activeProcess.
-"
+	"
-and switch to first in the list
+	 and switch to first in the list
-"
+	"
-self threadSwitch:(l firstLink).
+	self threadSwitch:(l firstLink).
 ].
 wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
 "Modified: / 02-08-2010 / 13:36:25 / cg"
 ! !
 "recompute dynamic priorities."
 |processesToDecrease processesToIncrease|
 scheduledProcesses notNil ifTrue:[
-"/ this is written a bit cryptic - to avoid creation
+	"/ this is written a bit cryptic - to avoid creation
-"/ of garbage objects (Id'sets) if possible.
+	"/ of garbage objects (Id'sets) if possible.
-"/ since this runs 50 times a second and most of the
+	"/ since this runs 50 times a second and most of the
-"/ time, no rescheduling is req'd
+	"/ time, no rescheduling is req'd
-scheduledProcesses do:[:aProcess |
+	scheduledProcesses do:[:aProcess |
-|range|
+	    |range|
-"/ decrease priority of processes that did run
+	    "/ decrease priority of processes that did run
-(range := aProcess priorityRange) notNil ifTrue:[
+	    (range := aProcess priorityRange) notNil ifTrue:[
-aProcess priority > range start ifTrue:[
+		aProcess priority > range start ifTrue:[
-processesToDecrease isNil ifTrue:[
+		    processesToDecrease isNil ifTrue:[
-processesToDecrease := IdentitySet new.
+			processesToDecrease := IdentitySet new.
-].
+		    ].
-processesToDecrease add:aProcess.
+		    processesToDecrease add:aProcess.
-]
+		]
-]
+	    ]
-].
+	].
-processesToDecrease notNil ifTrue:[
+	processesToDecrease notNil ifTrue:[
-processesToDecrease do:[:aProcess |
+	    processesToDecrease do:[:aProcess |
-|newPri|
+		|newPri|
-"/ newPri := aProcess priority - 1.
+		"/ newPri := aProcess priority - 1.
-newPri := aProcess priorityRange start.
+		newPri := aProcess priorityRange start.
-self changePriority:newPri for:aProcess.
+		self changePriority:newPri for:aProcess.
-].
+	    ].
-].
+	].
-"/ and increase all prios of those that did not run, but are runnable
+	"/ and increase all prios of those that did not run, but are runnable
-TimeSlicingPriorityLimit to:1 by:-1 do:[:i |
+	TimeSlicingPriorityLimit to:1 by:-1 do:[:i |
-|list|
+	    |list|
-(list := quiescentProcessLists at:i) size > 0 ifTrue:[
+	    (list := quiescentProcessLists at:i) size > 0 ifTrue:[
-list linksDo:[:aProcess |
+		list linksDo:[:aProcess |
-|range prio|
+		    |range prio|
-(range := aProcess priorityRange) notNil ifTrue:[
+		    (range := aProcess priorityRange) notNil ifTrue:[
-(processesToDecrease isNil
+			(processesToDecrease isNil
-or:[(processesToDecrease includes:aProcess) not]) ifTrue:[
+			or:[(processesToDecrease includes:aProcess) not]) ifTrue:[
-aProcess priority < range stop ifTrue:[
+			    aProcess priority < range stop ifTrue:[
-processesToIncrease isNil ifTrue:[
+				processesToIncrease isNil ifTrue:[
-processesToIncrease := OrderedCollection new.
+				    processesToIncrease := OrderedCollection new.
-].
+				].
-processesToIncrease add:aProcess
+				processesToIncrease add:aProcess
-]
+			    ]
-]
+			]
-]
+		    ]
-]
+		]
-]
+	    ]
-].
+	].
-processesToIncrease notNil ifTrue:[
+	processesToIncrease notNil ifTrue:[
-processesToIncrease do:[:aProcess |
+	    processesToIncrease do:[:aProcess |
-self changePriority:(aProcess priority + 1) for:aProcess.
+		self changePriority:(aProcess priority + 1) for:aProcess.
-].
+	    ].
-].
+	].
 ].
 "Modified: / 30-07-2013 / 19:33:14 / cg"
 !
 wasBlocked := OperatingSystem blockInterrupts.
 i := TimeSlicingPriorityLimit.
 [(i > 0) and:[(list := quiescentProcessLists at:i) size <= 1]] whileTrue: [i := i - 1].
 i ~~ 0 ifTrue: [
-"/ shuffle that list
+	"/ shuffle that list
-list addLast:(list removeFirst).
+	list addLast:(list removeFirst).
-anyShuffle := true.
+	anyShuffle := true.
 ].
 wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
 anyShuffle ifFalse:[
-"/ wait for the scheduler to make some process runnable...
+	"/ wait for the scheduler to make some process runnable...
-timeSliceNeededSemaphore wait.
+	timeSliceNeededSemaphore wait.
 ].
 "Modified: / 4.8.1998 / 00:13:32 / cg"
 !
 timeSliceProcess notNil ifTrue: [^ self].
 timeSliceNeededSemaphore := Semaphore new name:'timeSlice needed'.
 timeSliceProcess := [
-[
+	[
-self timeSlicingLoop.
+	    self timeSlicingLoop.
-] ifCurtailed:[
+	] ifCurtailed:[
-timeSliceProcess := nil.
+	    timeSliceProcess := nil.
-'Processor [info]: timeslicer finished' infoPrintCR.
+	    'Processor [info]: timeslicer finished' infoPrintCR.
-]
+	]
 ] newProcess.
 timeSliceProcess
-priority:HighestPriority;
+	priority:HighestPriority;
-name:'time slicer';
+	name:'time slicer';
-restartable:true;
+	restartable:true;
-beSystemProcess;
+	beSystemProcess;
-resume.
+	resume.
 "
 Processor stopTimeSlicing.
 Processor startTimeSlicing.
 "
 stopTimeSlicing
 "stop preemptive scheduling (timeSlicing)"
 timeSliceProcess notNil ifTrue: [
-timeSliceProcess terminate.
+	timeSliceProcess terminate.
-timeSliceProcess := nil.
+	timeSliceProcess := nil.
-scheduledProcesses := nil.
+	scheduledProcesses := nil.
-timeSliceNeededSemaphore := nil.
+	timeSliceNeededSemaphore := nil.
 ]
 "
 Processor stopTimeSlicing
 "
 myDelay := Delay forMilliseconds:(t := TimeSliceInterval).
 flipFlop := true.
 'Processor [info]: timeslicer started' infoPrintCR.
 [
-t ~~ TimeSliceInterval ifTrue:[
+	t ~~ TimeSliceInterval ifTrue:[
-"/ interval changed -> need a new delay
+	    "/ interval changed -> need a new delay
-myDelay delay:(t := TimeSliceInterval).
+	    myDelay delay:(t := TimeSliceInterval).
-].
+	].
-myDelay wait.
+	myDelay wait.
-self slice.
+	self slice.
-"/ every other tick, recompute priorities.
+	"/ every other tick, recompute priorities.
-flipFlop := flipFlop not.
+	flipFlop := flipFlop not.
-flipFlop ifTrue:[
+	flipFlop ifTrue:[
-scheduledProcesses notNil ifTrue:[
+	    scheduledProcesses notNil ifTrue:[
-supportDynamicPriorities ifTrue:[
+		supportDynamicPriorities ifTrue:[
-self recomputeDynamicPriorities.
+		    self recomputeDynamicPriorities.
-].
+		].
-scheduledProcesses clearContents.
+		scheduledProcesses clearContents.
-] ifFalse:[
+	    ] ifFalse:[
-scheduledProcesses := IdentitySet new.
+		scheduledProcesses := IdentitySet new.
-].
+	    ].
-].
+	].
 ] loop.
 ! !
 !ProcessorScheduler methodsFor:'semaphore signalling'!
 wasBlocked fd|
 wasBlocked := OperatingSystem blockInterrupts.
 idx := readSemaphoreArray identityIndexOf:aSemaphore startingAt:1.
 [idx ~~ 0] whileTrue:[
-useIOInterrupts ifTrue:[
+	useIOInterrupts ifTrue:[
-fd := readFdArray at:idx.
+	    fd := readFdArray at:idx.
-fd notNil ifTrue:[
+	    fd notNil ifTrue:[
-OperatingSystem disableIOInterruptsOn:fd
+		OperatingSystem disableIOInterruptsOn:fd
-].
+	    ].
-].
+	].
-readFdArray at:idx put:nil.
+	readFdArray at:idx put:nil.
-readSemaphoreArray at:idx put:nil.
+	readSemaphoreArray at:idx put:nil.
-readCheckArray at:idx put:nil.
+	readCheckArray at:idx put:nil.
-idx := readSemaphoreArray identityIndexOf:aSemaphore startingAt:idx+1.
+	idx := readSemaphoreArray identityIndexOf:aSemaphore startingAt:idx+1.
 ].
 idx := writeSemaphoreArray identityIndexOf:aSemaphore startingAt:1.
 [idx ~~ 0] whileTrue:[
-useIOInterrupts ifTrue:[
+	useIOInterrupts ifTrue:[
-fd := writeFdArray at:idx.
+	    fd := writeFdArray at:idx.
-fd notNil ifTrue:[
+	    fd notNil ifTrue:[
-OperatingSystem disableIOInterruptsOn:fd
+		OperatingSystem disableIOInterruptsOn:fd
-].
+	    ].
-].
+	].
-writeFdArray at:idx put:nil.
+	writeFdArray at:idx put:nil.
-writeSemaphoreArray at:idx put:nil.
+	writeSemaphoreArray at:idx put:nil.
-writeCheckArray at:idx put:nil.
+	writeCheckArray at:idx put:nil.
-idx := writeSemaphoreArray identityIndexOf:aSemaphore startingAt:idx+1.
+	idx := writeSemaphoreArray identityIndexOf:aSemaphore startingAt:idx+1.
 ].
 idx := timeoutSemaphoreArray identityIndexOf:aSemaphore startingAt:1.
 [idx ~~ 0] whileTrue:[
-timeoutArray at:idx put:nil.
+	timeoutArray at:idx put:nil.
-timeoutSemaphoreArray at:idx put:nil.
+	timeoutSemaphoreArray at:idx put:nil.
-timeoutActionArray at:idx put:nil.
+	timeoutActionArray at:idx put:nil.
-timeoutProcessArray at:idx put:nil.
+	timeoutProcessArray at:idx put:nil.
-idx := timeoutSemaphoreArray identityIndexOf:aSemaphore startingAt:idx+1.
+	idx := timeoutSemaphoreArray identityIndexOf:aSemaphore startingAt:idx+1.
 ].
 wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
 "Modified: 4.8.1997 / 15:19:33 / cg"
 !
 wasBlocked|
 wasBlocked := OperatingSystem blockInterrupts.
 index := timeoutSemaphoreArray identityIndexOf:aSemaphore startingAt:1.
 index ~~ 0 ifTrue:[
-timeoutArray at:index put:aMillisecondTime
+	timeoutArray at:index put:aMillisecondTime
 ] ifFalse:[
-index := timeoutArray identityIndexOf:nil startingAt:1.
+	index := timeoutArray identityIndexOf:nil startingAt:1.
-index ~~ 0 ifTrue:[
+	index ~~ 0 ifTrue:[
-timeoutSemaphoreArray at:index put:aSemaphore.
+	    timeoutSemaphoreArray at:index put:aSemaphore.
-timeoutArray at:index put:aMillisecondTime.
+	    timeoutArray at:index put:aMillisecondTime.
-timeoutActionArray at:index put:nil.
+	    timeoutActionArray at:index put:nil.
-timeoutProcessArray at:index put:nil
+	    timeoutProcessArray at:index put:nil
-] ifFalse:[
+	] ifFalse:[
-timeoutSemaphoreArray := timeoutSemaphoreArray copyWith:aSemaphore.
+	    timeoutSemaphoreArray := timeoutSemaphoreArray copyWith:aSemaphore.
-timeoutArray := timeoutArray copyWith:aMillisecondTime.
+	    timeoutArray := timeoutArray copyWith:aMillisecondTime.
-timeoutActionArray := timeoutActionArray copyWith:nil.
+	    timeoutActionArray := timeoutActionArray copyWith:nil.
-timeoutProcessArray := timeoutProcessArray copyWith:nil
+	    timeoutProcessArray := timeoutProcessArray copyWith:nil
-].
+	].
 ].
 anyTimeouts := true.
 wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
 !
 "Here we assume, that for every triple (aSemaphore, aFileDescriptor, aBlock)
 aSemphore is never nil, but one of aFileDescriptor, aBlock may be nil"
 aFileDescriptor isNil ifTrue:[
-idx := readSemaphoreArray identityIndexOf:aSemaphore or:nil.
+	idx := readSemaphoreArray identityIndexOf:aSemaphore or:nil.
-idx == 0 ifTrue:[
+	idx == 0 ifTrue:[
-"aSemaphore is not registered yet, have to create a new slot"
+	    "aSemaphore is not registered yet, have to create a new slot"
-readFdArray := readFdArray copyWith:nil.
+	    readFdArray := readFdArray copyWith:nil.
-readSemaphoreArray := readSemaphoreArray copyWith:aSemaphore.
+	    readSemaphoreArray := readSemaphoreArray copyWith:aSemaphore.
-readCheckArray := readCheckArray copyWith:aBlock.
+	    readCheckArray := readCheckArray copyWith:aBlock.
-] ifFalse:[
+	] ifFalse:[
-slot := readSemaphoreArray at:idx.
+	    slot := readSemaphoreArray at:idx.
-slot isNil ifTrue:[
+	    slot isNil ifTrue:[
-readSemaphoreArray at:idx put:aSemaphore.
+		readSemaphoreArray at:idx put:aSemaphore.
-readCheckArray at:idx put:aBlock
+		readCheckArray at:idx put:aBlock
-] ifFalse:[
+	    ] ifFalse:[
-"/ someone has already registered aSemaphore.
+		"/ someone has already registered aSemaphore.
-"/ Check if it is the block changes...
+		"/ Check if it is the block changes...
-(readCheckArray at:idx) notNil ifTrue:[
+		(readCheckArray at:idx) notNil ifTrue:[
-(readCheckArray at:idx) ~~ aBlock ifTrue:[
+		    (readCheckArray at:idx) ~~ aBlock ifTrue:[
-'Processor [info]: checkblock changed for read-check' infoPrintCR.
+			'Processor [info]: checkblock changed for read-check' infoPrintCR.
-readCheckArray at:idx put:aBlock.
+			readCheckArray at:idx put:aBlock.
-].
+		    ].
-].
+		].
-].
+	    ].
-]
+	]
 ] ifFalse:[
-idx := readFdArray identityIndexOf:aFileDescriptor or:nil.
+	idx := readFdArray identityIndexOf:aFileDescriptor or:nil.
-idx == 0 ifTrue:[
+	idx == 0 ifTrue:[
-"aFileDescriptor is not registered yet, have to create a new slot"
+	    "aFileDescriptor is not registered yet, have to create a new slot"
-readFdArray := readFdArray copyWith:aFileDescriptor.
+	    readFdArray := readFdArray copyWith:aFileDescriptor.
-readSemaphoreArray := readSemaphoreArray copyWith:aSemaphore.
+	    readSemaphoreArray := readSemaphoreArray copyWith:aSemaphore.
-readCheckArray := readCheckArray copyWith:aBlock.
+	    readCheckArray := readCheckArray copyWith:aBlock.
-] ifFalse:[
+	] ifFalse:[
-slot := readFdArray at:idx.
+	    slot := readFdArray at:idx.
-slot isNil ifTrue:[
+	    slot isNil ifTrue:[
-readFdArray at:idx put:aFileDescriptor.
+		readFdArray at:idx put:aFileDescriptor.
-readSemaphoreArray at:idx put:aSemaphore.
+		readSemaphoreArray at:idx put:aSemaphore.
-readCheckArray at:idx put:aBlock
+		readCheckArray at:idx put:aBlock
-] ifFalse:[
+	    ] ifFalse:[
-"/ someone has already registered aFileDescriptor.
+		"/ someone has already registered aFileDescriptor.
-"/ Check if it is the semaphore or block changes...
+		"/ Check if it is the semaphore or block changes...
-(readSemaphoreArray at:idx) ~~ aSemaphore ifTrue:[
+		(readSemaphoreArray at:idx) ~~ aSemaphore ifTrue:[
-'Processor [info]: sema changed for read-check' infoPrintCR.
+		    'Processor [info]: sema changed for read-check' infoPrintCR.
-readSemaphoreArray at:idx put:aSemaphore.
+		    readSemaphoreArray at:idx put:aSemaphore.
-].
+		].
-(readCheckArray at:idx) ~~ aBlock ifTrue:[
+		(readCheckArray at:idx) ~~ aBlock ifTrue:[
-'Processor [info]: checkblock changed for read-check' infoPrintCR.
+		    'Processor [info]: checkblock changed for read-check' infoPrintCR.
-readCheckArray at:idx put:aBlock.
+		    readCheckArray at:idx put:aBlock.
-].
+		].
-].
+	    ].
-].
+	].
-(useIOInterrupts and:[slot isNil]) ifTrue:[
+	(useIOInterrupts and:[slot isNil]) ifTrue:[
-OperatingSystem enableIOInterruptsOn:aFileDescriptor
+	    OperatingSystem enableIOInterruptsOn:aFileDescriptor
-].
+	].
 ].
 wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
 "Modified: 4.8.1997 / 15:20:45 / cg"
 !
 "arrange for a semaphore to be triggered when input on aStream arrives.
 This will do a select, if the OS supports selecting on that filedescriptor,
 otherwise, it will be polled every few milliseconds (MSDOS)."
 aStream canBeSelected ifTrue:[
-"/ can this stream be selected on ?
+	"/ can this stream be selected on ?
-self signal:aSemaphore onInput:aStream fileDescriptor orCheck:nil
+	self signal:aSemaphore onInput:aStream fileDescriptor orCheck:nil
 ] ifFalse:[
-"/ nope - must poll ...
+	"/ nope - must poll ...
-self signal:aSemaphore onInput:nil orCheck:[aStream canReadWithoutBlocking]
+	self signal:aSemaphore onInput:nil orCheck:[aStream canReadWithoutBlocking]
 ]
 "Modified: / 14.12.1999 / 23:58:50 / cg"
 !
 "Here we assume, that for every triple (aSemaphore, aFileDescriptor, aBlock)
 aSemphore is never nil, but one of aFileDescriptor, aBlock may be nil"
 aFileDescriptor isNil ifTrue:[
-idx := writeSemaphoreArray identityIndexOf:aSemaphore or:nil.
+	idx := writeSemaphoreArray identityIndexOf:aSemaphore or:nil.
-idx == 0 ifTrue:[
+	idx == 0 ifTrue:[
-"aSemaphore is not registered yet, have to create a new slot"
+	    "aSemaphore is not registered yet, have to create a new slot"
-writeFdArray := writeFdArray copyWith:nil.
+	    writeFdArray := writeFdArray copyWith:nil.
-writeSemaphoreArray := writeSemaphoreArray copyWith:aSemaphore.
+	    writeSemaphoreArray := writeSemaphoreArray copyWith:aSemaphore.
-writeCheckArray := writeCheckArray copyWith:aBlock.
+	    writeCheckArray := writeCheckArray copyWith:aBlock.
-] ifFalse:[
+	] ifFalse:[
-slot := writeSemaphoreArray at:idx.
+	    slot := writeSemaphoreArray at:idx.
-slot isNil ifTrue:[
+	    slot isNil ifTrue:[
-writeSemaphoreArray at:idx put:aSemaphore.
+		writeSemaphoreArray at:idx put:aSemaphore.
-writeCheckArray at:idx put:aBlock
+		writeCheckArray at:idx put:aBlock
-] ifFalse:[
+	    ] ifFalse:[
-"/ someone has already registered aSemaphore.
+		"/ someone has already registered aSemaphore.
-"/ Check if it is the block changes...
+		"/ Check if it is the block changes...
-(writeCheckArray at:idx) notNil ifTrue:[
+		(writeCheckArray at:idx) notNil ifTrue:[
-(writeCheckArray at:idx) ~~ aBlock ifTrue:[
+		    (writeCheckArray at:idx) ~~ aBlock ifTrue:[
-'Processor [info]: checkblock changed for write-check' infoPrintCR.
+			'Processor [info]: checkblock changed for write-check' infoPrintCR.
-writeCheckArray at:idx put:aBlock.
+			writeCheckArray at:idx put:aBlock.
-].
+		    ].
-].
+		].
-].
+	    ].
-]
+	]
 ] ifFalse:[
-idx := writeFdArray identityIndexOf:aFileDescriptor or:nil.
+	idx := writeFdArray identityIndexOf:aFileDescriptor or:nil.
-idx == 0 ifTrue:[
+	idx == 0 ifTrue:[
-"aFileDescriptor is not registered yet, have to create a new slot"
+	    "aFileDescriptor is not registered yet, have to create a new slot"
-writeFdArray := writeFdArray copyWith:aFileDescriptor.
+	    writeFdArray := writeFdArray copyWith:aFileDescriptor.
-writeSemaphoreArray := writeSemaphoreArray copyWith:aSemaphore.
+	    writeSemaphoreArray := writeSemaphoreArray copyWith:aSemaphore.
-writeCheckArray := writeCheckArray copyWith:aBlock.
+	    writeCheckArray := writeCheckArray copyWith:aBlock.
-] ifFalse:[
+	] ifFalse:[
-slot := writeFdArray at:idx.
+	    slot := writeFdArray at:idx.
-slot isNil ifTrue:[
+	    slot isNil ifTrue:[
-writeFdArray at:idx put:aFileDescriptor.
+		writeFdArray at:idx put:aFileDescriptor.
-writeSemaphoreArray at:idx put:aSemaphore.
+		writeSemaphoreArray at:idx put:aSemaphore.
-writeCheckArray at:idx put:aBlock
+		writeCheckArray at:idx put:aBlock
-] ifFalse:[
+	    ] ifFalse:[
-"/ someone has already registered aFileDescriptor.
+		"/ someone has already registered aFileDescriptor.
-"/ Check if it is the semaphore or block changes...
+		"/ Check if it is the semaphore or block changes...
-(writeSemaphoreArray at:idx) ~~ aSemaphore ifTrue:[
+		(writeSemaphoreArray at:idx) ~~ aSemaphore ifTrue:[
-'Processor [info]: sema changed for write-check' infoPrintCR.
+		    'Processor [info]: sema changed for write-check' infoPrintCR.
-writeSemaphoreArray at:idx put:aSemaphore.
+		    writeSemaphoreArray at:idx put:aSemaphore.
-].
+		].
-(writeCheckArray at:idx) ~~ aBlock ifTrue:[
+		(writeCheckArray at:idx) ~~ aBlock ifTrue:[
-'Processor [info]: checkblock changed for write-check' infoPrintCR.
+		    'Processor [info]: checkblock changed for write-check' infoPrintCR.
-writeCheckArray at:idx put:aBlock.
+		    writeCheckArray at:idx put:aBlock.
-].
+		].
-].
+	    ].
-].
+	].
-(useIOInterrupts and:[slot isNil]) ifTrue:[
+	(useIOInterrupts and:[slot isNil]) ifTrue:[
-OperatingSystem enableIOInterruptsOn:aFileDescriptor
+	    OperatingSystem enableIOInterruptsOn:aFileDescriptor
-].
+	].
 ].
 wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
 "Modified: 4.8.1997 / 15:21:49 / cg"
 !
 "arrange for a semaphore to be triggered when output on aStream is possible.
 This will do a select, if the OS supports selecting on that filedescriptor,
 otherwise, it will be polled every few milliseconds (MSDOS)."
 aStream canBeSelected ifTrue:[
-"/ can this stream be selected on ?
+	"/ can this stream be selected on ?
-self signal:aSemaphore onOutput:aStream fileDescriptor orCheck:nil
+	self signal:aSemaphore onOutput:aStream fileDescriptor orCheck:nil
 ] ifFalse:[
-"/ nope - must poll ...
+	"/ nope - must poll ...
-self signal:aSemaphore onOutput:nil orCheck:[aStream canWriteWithoutBlocking]
+	self signal:aSemaphore onOutput:nil orCheck:[aStream canWriteWithoutBlocking]
 ]
 "Modified: / 14.12.1999 / 23:59:19 / cg"
 ! !
 If enabled, arrangements are made for data-availability to trigger an
 interrupt.
 Using IO interrupts reduces the idle CPU usage of ST/X by some percent
 (typically 2-7%).
 Notice:
-some systems do not support IO-interrupts (or have a broken stdio-lib),
+	some systems do not support IO-interrupts (or have a broken stdio-lib),
-and this feature is always disabled;
+	and this feature is always disabled;
 Also notice:
-we found that in some Xlib-implementations, interrupted reads are not
+	we found that in some Xlib-implementations, interrupted reads are not
-handled correctly (especially in multi-headed applications), and this
+	handled correctly (especially in multi-headed applications), and this
-feature should be disabled to avoid a blocking XPending.
+	feature should be disabled to avoid a blocking XPending.
 If this method is used to disable IO interrupts in multi-headed apps,
 it should be invoked BEFORE the display event dispatcher processes are started."
 OperatingSystem supportsIOInterrupts ifTrue:[
-useIOInterrupts := aBoolean
+	useIOInterrupts := aBoolean
 ].
 "Created: / 15.7.1998 / 13:32:29 / cg"
 ! !
 wasBlocked|
 wasBlocked := OperatingSystem blockInterrupts.
 index := timeoutActionArray identityIndexOf:aBlock startingAt:1.
 index ~~ 0 ifTrue:[
-timeoutArray at:index put:aMillisecondTime
+	timeoutArray at:index put:aMillisecondTime
 ] ifFalse:[
-index := timeoutArray indexOf:nil.
+	index := timeoutArray indexOf:nil.
-index ~~ 0 ifTrue:[
+	index ~~ 0 ifTrue:[
-timeoutArray at:index put:aMillisecondTime.
+	    timeoutArray at:index put:aMillisecondTime.
-timeoutActionArray at:index put:aBlock.
+	    timeoutActionArray at:index put:aBlock.
-timeoutSemaphoreArray at:index put:nil.
+	    timeoutSemaphoreArray at:index put:nil.
-timeoutProcessArray at:index put:aProcess
+	    timeoutProcessArray at:index put:aProcess
-] ifFalse:[
+	] ifFalse:[
-timeoutArray := timeoutArray copyWith:aMillisecondTime.
+	    timeoutArray := timeoutArray copyWith:aMillisecondTime.
-timeoutActionArray := timeoutActionArray copyWith:aBlock.
+	    timeoutActionArray := timeoutActionArray copyWith:aBlock.
-timeoutSemaphoreArray := timeoutSemaphoreArray copyWith:nil.
+	    timeoutSemaphoreArray := timeoutSemaphoreArray copyWith:nil.
-timeoutProcessArray := timeoutProcessArray copyWith:aProcess.
+	    timeoutProcessArray := timeoutProcessArray copyWith:aProcess.
-index := timeoutArray size.
+	    index := timeoutArray size.
-].
+	].
 ].
 anyTimeouts := true.
 wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
 ^ index
 wasBlocked := OperatingSystem blockInterrupts.
 now := OperatingSystem getMillisecondTime.
 then := OperatingSystem millisecondTimeAdd:now and:delta.
 id := self
-addTimeoutFunctionCall:anExternalFunction
+	addTimeoutFunctionCall:anExternalFunction
-for:aProcess
+	for:aProcess
-atMilliseconds:then
+	atMilliseconds:then
-with:argument.
+	with:argument.
 wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
 ^ id
 "Created: 23.9.1996 / 14:28:27 / cg"
 |action|
 action := [anExternalFunction callWith:argument].
 ^ self
-addTimedBlock:action
+	addTimedBlock:action
-for:aProcess
+	for:aProcess
-atMilliseconds:milliTime.
+	atMilliseconds:milliTime.
 "Created: 23.9.1996 / 14:29:30 / cg"
 "Modified: 23.9.1996 / 14:34:57 / cg"
 !
 evaluateTimeouts
 "walk through timeouts and evaluate blocks or signal semas that need to be .."
 |sema now aTime block blocksAndProcessesToEvaluate
 firstBlockToEvaluate firstProcess
 n "{ Class: SmallInteger }"
 indexOfLastTimeout "{ Class: SmallInteger }"
 halfSize "{ Class: SmallInteger }"
 wasBlocked p|
 anyTimeouts ifFalse:[ ^ self].
 anyTimeouts := false.
 "have to collect the blocks first, then evaluate them.
 This avoids problems due to newly inserted blocks."
 "/ notice: the code looks uglier than seems to be required;
 "/ the observation is that in almost all cases, only a single block (or no block at all)
 "/ is found in the loops below.
 "/ looks ugly, but as this is called very often, reduces idle allocation by a lot.
 now := OperatingSystem getMillisecondTime.
 n := timeoutArray size.
 1 to:n do:[:index |
-aTime := timeoutArray at:index.
+	aTime := timeoutArray at:index.
-aTime notNil ifTrue:[
+	aTime notNil ifTrue:[
-(OperatingSystem millisecondTime:now isAfter:aTime) ifTrue:[
+	    (OperatingSystem millisecondTime:now isAfter:aTime) ifTrue:[
-"this one should be triggered"
+		"this one should be triggered"
-sema := timeoutSemaphoreArray at:index.
+		sema := timeoutSemaphoreArray at:index.
-sema notNil ifTrue:[
+		sema notNil ifTrue:[
-timeoutSemaphoreArray at:index put:nil.
+		    timeoutSemaphoreArray at:index put:nil.
-sema signalOnce.
+		    sema signalOnce.
-] ifFalse:[
+		] ifFalse:[
-"to support pure-events"
+		    "to support pure-events"
-block := timeoutActionArray at:index.
+		    block := timeoutActionArray at:index.
-block notNil ifTrue:[
+		    block notNil ifTrue:[
-firstBlockToEvaluate isNil ifTrue:[
+			firstBlockToEvaluate isNil ifTrue:[
-firstBlockToEvaluate := block.
+			    firstBlockToEvaluate := block.
-firstProcess := timeoutProcessArray at:index.
+			    firstProcess := timeoutProcessArray at:index.
-] ifFalse:[
+			] ifFalse:[
-blocksAndProcessesToEvaluate isNil ifTrue:[
+			    blocksAndProcessesToEvaluate isNil ifTrue:[
-blocksAndProcessesToEvaluate := OrderedCollection
+				blocksAndProcessesToEvaluate := OrderedCollection
-with:firstBlockToEvaluate
+								    with:firstBlockToEvaluate
-with:firstProcess.
+								    with:firstProcess.
-].
+			    ].
-blocksAndProcessesToEvaluate add:block.
+			    blocksAndProcessesToEvaluate add:block.
-blocksAndProcessesToEvaluate add:(timeoutProcessArray at:index).
+			    blocksAndProcessesToEvaluate add:(timeoutProcessArray at:index).
-].
+			].
-timeoutActionArray at:index put:nil.
+			timeoutActionArray at:index put:nil.
-timeoutProcessArray at:index put:nil.
+			timeoutProcessArray at:index put:nil.
-]
+		    ]
-].
+		].
-timeoutArray at:index put:nil.
+		timeoutArray at:index put:nil.
-] ifFalse:[
+	    ] ifFalse:[
-"there are still pending timeouts"
+		"there are still pending timeouts"
-anyTimeouts := true.
+		anyTimeouts := true.
-indexOfLastTimeout := index.
+		indexOfLastTimeout := index.
-]
+	    ]
-]
+	]
 ].
 "shrink the arrays, if they are 50% free"
 n > 20 ifTrue:[
-halfSize := n // 2.
+	halfSize := n // 2.
-indexOfLastTimeout < halfSize ifTrue:[
+	indexOfLastTimeout < halfSize ifTrue:[
-wasBlocked := OperatingSystem blockInterrupts.
+	    wasBlocked := OperatingSystem blockInterrupts.
-(timeoutArray at:indexOfLastTimeout+1) isNil ifTrue:[   "/ no new timeouts arrived
+	    (timeoutArray at:indexOfLastTimeout+1) isNil ifTrue:[   "/ no new timeouts arrived
-timeoutArray := timeoutArray copyTo:halfSize.
+		timeoutArray := timeoutArray copyTo:halfSize.
-timeoutSemaphoreArray := timeoutSemaphoreArray copyTo:halfSize.
+		timeoutSemaphoreArray := timeoutSemaphoreArray copyTo:halfSize.
-timeoutActionArray := timeoutActionArray copyTo:halfSize.
+		timeoutActionArray := timeoutActionArray copyTo:halfSize.
-timeoutProcessArray := timeoutProcessArray copyTo:halfSize.
+		timeoutProcessArray := timeoutProcessArray copyTo:halfSize.
-].
+	    ].
-wasBlocked ifFalse:[ OperatingSystem unblockInterrupts ].
+	    wasBlocked ifFalse:[ OperatingSystem unblockInterrupts ].
-].
+	].
 ].
 blocksAndProcessesToEvaluate isNil ifTrue:[
-firstBlockToEvaluate notNil ifTrue:[
+	firstBlockToEvaluate notNil ifTrue:[
-(firstProcess isNil or:[firstProcess == scheduler or:[PureEventDriven]]) ifTrue:[
+	    (firstProcess isNil or:[firstProcess == scheduler or:[PureEventDriven]]) ifTrue:[
-firstBlockToEvaluate value
+		firstBlockToEvaluate value
-] ifFalse:[
+	    ] ifFalse:[
-firstProcess isDead ifTrue:[
+		firstProcess isDead ifTrue:[
-"/ a timedBlock for a process which has already terminated
+		    "/ a timedBlock for a process which has already terminated
-"/ issue a warning and do not execute it.
+		    "/ issue a warning and do not execute it.
-"/ (exeuting here may be dangerous, since it would run at scheduler priority here,
+		    "/ (exeuting here may be dangerous, since it would run at scheduler priority here,
-"/  and thereby could block the whole smalltalk system.
+		    "/  and thereby could block the whole smalltalk system.
-"/  For this reason is it IGNORED here.)
+		    "/  For this reason is it IGNORED here.)
 "/ Could handle it in timeoutProcess, but we don't,
 "/ because otherwise timeouts might be reissued forever...
 "/                    (timeoutHandlerProcess notNil and:[timeoutHandlerProcess isDead not]) ifTrue:[
 "/                        timeoutHandlerProcess interruptWith:block.
 "/                    ] ifFalse:[
-('ProcessorScheduler [warning]: cannot evaluate timedBlock for dead process: ''' , firstProcess name , '''') infoPrintCR.
+			('ProcessorScheduler [warning]: cannot evaluate timedBlock for dead process: ''' , firstProcess name , '''') infoPrintCR.
-('ProcessorScheduler [warning]: the timedBlock is: ' , firstBlockToEvaluate displayString) infoPrintCR.
+			('ProcessorScheduler [warning]: the timedBlock is: ' , firstBlockToEvaluate displayString) infoPrintCR.
 "/                    ].
-] ifFalse:[
+		] ifFalse:[
-firstProcess interruptWith:firstBlockToEvaluate
+		    firstProcess interruptWith:firstBlockToEvaluate
-]
+		]
-]
+	    ]
-].
+	].
 ] ifFalse:[
-n := blocksAndProcessesToEvaluate size.
+	n := blocksAndProcessesToEvaluate size.
-1 to:n by:2 do:[:index |
+	1 to:n by:2 do:[:index |
-block := blocksAndProcessesToEvaluate at:index.
+	    block := blocksAndProcessesToEvaluate at:index.
-p := blocksAndProcessesToEvaluate at:index+1.
+	    p := blocksAndProcessesToEvaluate at:index+1.
-(p isNil or:[p == scheduler or:[PureEventDriven]]) ifTrue:[
+	    (p isNil or:[p == scheduler or:[PureEventDriven]]) ifTrue:[
-block value
+		block value
-] ifFalse:[
+	    ] ifFalse:[
-p isDead ifTrue:[
+		p isDead ifTrue:[
-"/ a timedBlock for a process which has already terminated
+		    "/ a timedBlock for a process which has already terminated
-"/ issue a warning and do not execute it.
+		    "/ issue a warning and do not execute it.
-"/ (exeuting here may be dangerous, since it would run at scheduler priority here,
+		    "/ (exeuting here may be dangerous, since it would run at scheduler priority here,
-"/  and thereby could block the whole smalltalk system.
+		    "/  and thereby could block the whole smalltalk system.
-"/  For this reason is it IGNORED here.)
+		    "/  For this reason is it IGNORED here.)
 "/ Could handle it in timeoutProcess, but we don't,
 "/ because otherwise timeouts might be reissued forever...
 "/                    (timeoutHandlerProcess notNil and:[timeoutHandlerProcess isDead not]) ifTrue:[
 "/                        timeoutHandlerProcess interruptWith:block.
 "/                    ] ifFalse:[
-('ProcessorScheduler [warning]: cannot evaluate timedBlock for dead process: ''' , p name , '''') infoPrintCR.
+			('ProcessorScheduler [warning]: cannot evaluate timedBlock for dead process: ''' , p name , '''') infoPrintCR.
-('ProcessorScheduler [warning]: the timedBlock is: ' , block displayString) infoPrintCR.
+			('ProcessorScheduler [warning]: the timedBlock is: ' , block displayString) infoPrintCR.
 "/                    ].
-] ifFalse:[
+		] ifFalse:[
-p interruptWith:block
+		    p interruptWith:block
-]
+		]
-]
+	    ]
-]
+	]
 ].
 "Modified: / 30-07-2013 / 19:33:24 / cg"
 !
 aBlock isNil ifTrue:[^ self].
 wasBlocked := OperatingSystem blockInterrupts.
 index := timeoutActionArray identityIndexOf:aBlock startingAt:1.
 (index ~~ 0) ifTrue:[
-timeoutArray at:index put:nil.
+	timeoutArray at:index put:nil.
-timeoutActionArray at:index put:nil.
+	timeoutActionArray at:index put:nil.
-timeoutSemaphoreArray at:index put:nil.
+	timeoutSemaphoreArray at:index put:nil.
-timeoutProcessArray at:index put:nil.
+	timeoutProcessArray at:index put:nil.
 ].
 wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
 !
 removeTimeoutWithID:anID
 |index "{ Class: SmallInteger }"
 wasBlocked|
 index := anID.
 (index > 0) ifTrue:[
-wasBlocked := OperatingSystem blockInterrupts.
+	wasBlocked := OperatingSystem blockInterrupts.
-timeoutArray at:index put:nil.
+	timeoutArray at:index put:nil.
-timeoutActionArray at:index put:nil.
+	timeoutActionArray at:index put:nil.
-timeoutSemaphoreArray at:index put:nil.
+	timeoutSemaphoreArray at:index put:nil.
-timeoutProcessArray at:index put:nil.
+	timeoutProcessArray at:index put:nil.
-wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
+	wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
 ]
 "Created: 23.9.1996 / 14:32:33 / cg"
 "Modified: 23.9.1996 / 14:35:09 / cg"
 !
 timeoutHandlerProcess
 (timeoutHandlerProcess isNil or:[timeoutHandlerProcess isDead]) ifTrue:[
-timeoutHandlerProcess :=
+	timeoutHandlerProcess :=
-[
+		[
-[
+		    [
-self timeoutHandlerProcessLoop.
+			self timeoutHandlerProcessLoop.
-] ensure:[
+		    ] ensure:[
-timeoutHandlerProcess := nil
+			timeoutHandlerProcess := nil
-].
+		    ].
-] newProcess.
+		] newProcess.
-timeoutHandlerProcess
+	timeoutHandlerProcess
-priority:TimingPriority;
+	    priority:TimingPriority;
-name:'timeout handler';
+	    name:'timeout handler';
-beSystemProcess;
+	    beSystemProcess;
-resume.
+	    resume.
 ].
 ^ timeoutHandlerProcess.
 "Modified: / 20-07-2006 / 09:52:27 / cg"
 !
 timeoutHandlerProcessLoop
 "The timeoutHandlerProcess does nothing but wait.
 It exists only, so that timeout blocks may be executed in its context."
 [
-[
+	[
-(Semaphore new name:'timeoutHandler') wait.
+	    (Semaphore new name:'timeoutHandler') wait.
-] on:Exception do:[:ex|
+	] on:Exception do:[:ex|
-"ignore errors, but tell the user"
+	    "ignore errors, but tell the user"
-InfoPrinting == true ifTrue:[
+	    InfoPrinting == true ifTrue:[
-('ProcessorScheduler [warning]: error while handling timeouts in TimeoutHandlerProcess: ''' , ex description , '''') infoPrintCR.
+		('ProcessorScheduler [warning]: error while handling timeouts in TimeoutHandlerProcess: ''' , ex description , '''') infoPrintCR.
-thisContext fullPrintAll.
+		thisContext fullPrintAll.
-].
+	    ].
-].
+	].
 ] loop.
 ! !
 !ProcessorScheduler methodsFor:'wait hooks'!
 |wasBlocked|
 wasBlocked := OperatingSystem blockInterrupts.
 preWaitActions isNil ifTrue:[
-preWaitActions := OrderedCollection new
+	preWaitActions := OrderedCollection new
 ].
 preWaitActions add:aBlock.
 wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
 !
 wasBlocked := OperatingSystem unblockInterrupts.
 newProcessMaybeReady := false.
 readableResultFdArray size < readFdArray size ifTrue:[
-readableResultFdArray := Array new:(40 max:readFdArray size).
+	readableResultFdArray := Array new:(40 max:readFdArray size).
 ].
 writableResultFdArray size < writeFdArray size ifTrue:[
-writableResultFdArray := Array new:(40 max:writeFdArray size).
+	writableResultFdArray := Array new:(40 max:writeFdArray size).
 ].
 OperatingSystem isMSWINDOWSlike ifTrue:[
-"/
+	"/
-"/ win32 does a WaitForMultipleObjects in select...
+	"/ win32 does a WaitForMultipleObjects in select...
-"/ unix waits for SIGCHLD
+	"/ unix waits for SIGCHLD
-"/
+	"/
-osChildExitActions keysDo:[:eachPid|
+	osChildExitActions keysDo:[:eachPid|
-eachPid address = 0 ifTrue:[
+	    eachPid address = 0 ifTrue:[
-'Processor: remove 0 handle pid: ' infoPrint. eachPid infoPrintCR.
+		'Processor: remove 0 handle pid: ' infoPrint. eachPid infoPrintCR.
-osChildExitActions safeRemoveKey:eachPid.
+		osChildExitActions safeRemoveKey:eachPid.
-] ifFalse:[
+	    ] ifFalse:[
-pidsFinished isNil ifTrue:[
+		pidsFinished isNil ifTrue:[
-exceptArray := osChildExitActions keyArray.
+		    exceptArray := osChildExitActions keyArray.
-pidsFinished := Array new:osChildExitActions size.
+		    pidsFinished := Array new:osChildExitActions size.
-].
+		].
-].
+	    ].
-].
+	].
 ].
 nReady := OperatingSystem
-selectOnAnyReadable:readFdArray
+		selectOnAnyReadable:readFdArray
-writable:writeFdArray
+		writable:writeFdArray
-exception:exceptArray
+		exception:exceptArray
-readableInto:readableResultFdArray
+		readableInto:readableResultFdArray
-writableInto:writableResultFdArray
+		writableInto:writableResultFdArray
-exceptionInto:pidsFinished
+		exceptionInto:pidsFinished
-withTimeOut:millis.
+		withTimeOut:millis.
 wasBlocked ifTrue:[
-OperatingSystem blockInterrupts.
+	OperatingSystem blockInterrupts.
 ].
 nReady <= 0 ifTrue:[
-"/ either still nothing to do,
+	"/ either still nothing to do,
-"/ or error (which should not happen)
+	"/ or error (which should not happen)
-(nReady < 0 and:[(err := OperatingSystem lastErrorSymbol) notNil]) ifTrue:[
+	(nReady < 0 and:[(err := OperatingSystem lastErrorSymbol) notNil]) ifTrue:[
-err == #EBADF ifTrue:[
+	    err == #EBADF ifTrue:[
-"/ mhmh - one of the fd's given to me is corrupt.
+		"/ mhmh - one of the fd's given to me is corrupt.
-"/ find out which one .... and remove it
+		"/ find out which one .... and remove it
-self removeCorruptedFds
+		self removeCorruptedFds
-] ifFalse:[
+	    ] ifFalse:[
-err == #ENOENT ifTrue:[
+		err == #ENOENT ifTrue:[
-'Processor [warning]: ENOENT in select; rd=' infoPrint.
+		    'Processor [warning]: ENOENT in select; rd=' infoPrint.
-readFdArray infoPrint.
+		    readFdArray infoPrint.
-' wr=' infoPrint.
+		    ' wr=' infoPrint.
-writeFdArray infoPrintCR.
+		    writeFdArray infoPrintCR.
-] ifFalse:[
+		] ifFalse:[
-'Processor [warning]: error in select: ' infoPrint. err infoPrintCR.
+		    'Processor [warning]: error in select: ' infoPrint. err infoPrintCR.
-]
+		]
-].
+	    ].
-]
+	]
 ] ifFalse:[
-readyIndex := 1.
+	readyIndex := 1.
-[nReady > 0
+	[nReady > 0
-and:[ readyIndex <= readableResultFdArray size
+	     and:[ readyIndex <= readableResultFdArray size
-and:[ (fd := readableResultFdArray at:readyIndex) notNil ]]]
+	     and:[ (fd := readableResultFdArray at:readyIndex) notNil ]]]
-whileTrue:[
+	whileTrue:[
-index := readFdArray identityIndexOf:fd.
+	    index := readFdArray identityIndexOf:fd.
-index ~~ 0 ifTrue:[
+	    index ~~ 0 ifTrue:[
-action := readCheckArray at:index.
+		action := readCheckArray at:index.
-sema := readSemaphoreArray at:index.
+		sema := readSemaphoreArray at:index.
-sema notNil ifTrue:[
+		sema notNil ifTrue:[
-sema signalOnce.
+		    sema signalOnce.
-newProcessMaybeReady := true.
+		    newProcessMaybeReady := true.
-action isNil ifTrue:[
+		    action isNil ifTrue:[
-"before May 2014 we disabled the sema in the caller after wakeup.
+			"before May 2014 we disabled the sema in the caller after wakeup.
-This caused ST/X to consume 100% cpu, when the caller didn't read
+			 This caused ST/X to consume 100% cpu, when the caller didn't read
-the data (e.g. because his process was stopped)."
+			 the data (e.g. because his process was stopped)."
-useIOInterrupts ifTrue:[
+			useIOInterrupts ifTrue:[
-OperatingSystem disableIOInterruptsOn:fd
+			    OperatingSystem disableIOInterruptsOn:fd
-].
+			].
-readFdArray at:index put:nil.
+			readFdArray at:index put:nil.
-readSemaphoreArray at:index put:nil.
+			readSemaphoreArray at:index put:nil.
-"disable possible write side and timeouts as well"
+			"disable possible write side and timeouts as well"
-self disableSemaphore:sema.
+			self disableSemaphore:sema.
-].
+		    ].
-].
+		].
-action notNil ifTrue:[
+		action notNil ifTrue:[
-action value.
+		    action value.
-newProcessMaybeReady := true
+		    newProcessMaybeReady := true
-].
+		].
-].
+	    ].
-nReady := nReady - 1.
+	    nReady := nReady - 1.
-readyIndex := readyIndex + 1.
+	    readyIndex := readyIndex + 1.
-].
+	].
-readyIndex := 1.
+	readyIndex := 1.
-[nReady > 0
+	[nReady > 0
-and:[ readyIndex <= writableResultFdArray size
+	     and:[ readyIndex <= writableResultFdArray size
-and:[ (fd := writableResultFdArray at:readyIndex) notNil ]]]
+	     and:[ (fd := writableResultFdArray at:readyIndex) notNil ]]]
-whileTrue:[
+	whileTrue:[
-index := writeFdArray identityIndexOf:fd.
+	    index := writeFdArray identityIndexOf:fd.
-index ~~ 0 ifTrue:[
+	    index ~~ 0 ifTrue:[
-action := writeCheckArray at:index.
+		action := writeCheckArray at:index.
-sema := writeSemaphoreArray at:index.
+		sema := writeSemaphoreArray at:index.
-sema notNil ifTrue:[
+		sema notNil ifTrue:[
-sema signalOnce.
+		    sema signalOnce.
-newProcessMaybeReady := true.
+		    newProcessMaybeReady := true.
-action isNil ifTrue:[
+		    action isNil ifTrue:[
-"now this is a one shot operation - see the input above"
+			"now this is a one shot operation - see the input above"
-useIOInterrupts ifTrue:[
+			useIOInterrupts ifTrue:[
-OperatingSystem disableIOInterruptsOn:fd
+			    OperatingSystem disableIOInterruptsOn:fd
-].
+			].
-writeFdArray at:index put:nil.
+			writeFdArray at:index put:nil.
-writeSemaphoreArray at:index put:nil.
+			writeSemaphoreArray at:index put:nil.
-"disable possible read side and timeouts as well"
+			"disable possible read side and timeouts as well"
-self disableSemaphore:sema.
+			self disableSemaphore:sema.
-].
+		    ].
-].
+		].
-action notNil ifTrue:[
+		action notNil ifTrue:[
-action value.
+		    action value.
-newProcessMaybeReady := true
+		    newProcessMaybeReady := true
-]
+		]
-].
+	    ].
-nReady := nReady - 1.
+	    nReady := nReady - 1.
-readyIndex := readyIndex + 1.
+	    readyIndex := readyIndex + 1.
-].
+	].
-exceptArray notNil ifTrue:[
+	exceptArray notNil ifTrue:[
-"/ only for win32
+	    "/ only for win32
-readyIndex := 1.
+	    readyIndex := 1.
-[nReady > 0
+	    [nReady > 0
-and:[ readyIndex <= pidsFinished size
+		 and:[ readyIndex <= pidsFinished size
-and:[ (pid := pidsFinished at:readyIndex) notNil ]]]
+		 and:[ (pid := pidsFinished at:readyIndex) notNil ]]]
-whileTrue:[
+	    whileTrue:[
-|osProcessStatus actionBlock|
+		|osProcessStatus actionBlock|
 "/'pid signaled: ' infoPrint. pid infoPrintCR.
-actionBlock := osChildExitActions removeKey:pid ifAbsent:nil.
+		actionBlock := osChildExitActions removeKey:pid ifAbsent:nil.
-osProcessStatus := OperatingSystem childProcessWait:false pid:pid.
+		osProcessStatus := OperatingSystem childProcessWait:false pid:pid.
-osProcessStatus notNil ifTrue:[
+		osProcessStatus notNil ifTrue:[
-(osProcessStatus pid = pid) ifTrue:[
+		    (osProcessStatus pid = pid) ifTrue:[
-actionBlock notNil ifTrue:[
+			actionBlock notNil ifTrue:[
-actionBlock value:osProcessStatus.
+			    actionBlock value:osProcessStatus.
-newProcessMaybeReady := true
+			    newProcessMaybeReady := true
-].
+			].
-].
+		    ].
-].
+		].
-nReady := nReady - 1.
+		nReady := nReady - 1.
-readyIndex := readyIndex + 1.
+		readyIndex := readyIndex + 1.
-].
+	    ].
-].
+	].
 ].
 ^ newProcessMaybeReady
 "Modified: / 12-04-1996 / 09:31:22 / stefan"
 "Modified: / 07-12-2006 / 19:48:17 / cg"
 Notice, that at the time of the message, we are still in the context
 of whichever process is currently running."
 gotIOInterrupt := true.
 activeProcess ~~ scheduler ifTrue:[
-interruptedProcess := activeProcess.
+	interruptedProcess := activeProcess.
-self threadSwitch:scheduler
+	self threadSwitch:scheduler
 ]
 "Modified: 21.12.1995 / 16:17:40 / stefan"
 "Modified: 4.8.1997 / 14:23:08 / cg"
 !
 an #EBADF error, leading to high-frequency polling and a locked up system.
 (you could still fix things by interrupting on the console and fixing the
 readFdArray/writeFdArray in the debugger)"
 readFdArray keysAndValuesDo:[:idx :fd |
-|result sema|
+	|result sema|
-fd notNil ifTrue:[
+	fd notNil ifTrue:[
-result := OperatingSystem
+	    result := OperatingSystem
-selectOnAnyReadable:(Array with:fd) writable:nil exception:nil
+			selectOnAnyReadable:(Array with:fd) writable:nil exception:nil
-readableInto:nil writableInto:nil exceptionInto:nil
+			   readableInto:nil writableInto:nil exceptionInto:nil
-withTimeOut:0.
+			   withTimeOut:0.
-result < 0 ifTrue:[
+	    result < 0 ifTrue:[
-('Processor [info]: removing invalid read-select fileDescriptor: ' , fd printString) infoPrintCR.
+		('Processor [info]: removing invalid read-select fileDescriptor: ' , fd printString) infoPrintCR.
-readFdArray at:idx put:nil.
+		readFdArray at:idx put:nil.
-readCheckArray at:idx put:nil.
+		readCheckArray at:idx put:nil.
-(sema := readSemaphoreArray at:idx) notNil ifTrue:[
+		(sema := readSemaphoreArray at:idx) notNil ifTrue:[
-readSemaphoreArray at:idx put:nil.
+		    readSemaphoreArray at:idx put:nil.
-sema signalOnce.
+		    sema signalOnce.
-].
+		].
-]
+	    ]
-].
+	].
 ].
 writeFdArray keysAndValuesDo:[:idx :fd |
-|result sema|
+	|result sema|
-fd notNil ifTrue:[
+	fd notNil ifTrue:[
-result := OperatingSystem
+	    result := OperatingSystem
-selectOnAnyReadable:(Array with:fd) writable:nil exception:nil
+			selectOnAnyReadable:(Array with:fd) writable:nil exception:nil
-readableInto:nil writableInto:nil exceptionInto:nil
+			   readableInto:nil writableInto:nil exceptionInto:nil
-withTimeOut:0.
+			   withTimeOut:0.
-result < 0 ifTrue:[
+	    result < 0 ifTrue:[
-('Processor [info]: removing invalid write-select fileDescriptor: ' , fd printString) infoPrintCR.
+		('Processor [info]: removing invalid write-select fileDescriptor: ' , fd printString) infoPrintCR.
-writeFdArray at:idx put:nil.
+		writeFdArray at:idx put:nil.
-writeCheckArray at:idx put:nil.
+		writeCheckArray at:idx put:nil.
-(sema := writeSemaphoreArray at:idx) notNil ifTrue:[
+		(sema := writeSemaphoreArray at:idx) notNil ifTrue:[
-writeSemaphoreArray at:idx put:nil.
+		    writeSemaphoreArray at:idx put:nil.
-sema signalOnce.
+		    sema signalOnce.
-].
+		].
-]
+	    ]
-]
+	]
 ].
 OperatingSystem isMSWINDOWSlike ifTrue:[
-"/
+	"/
-"/ win32 does a WaitForMultipleObjects in select...
+	"/ win32 does a WaitForMultipleObjects in select...
-"/ unix waits for SIGCHLD
+	"/ unix waits for SIGCHLD
-"/
+	"/
-osChildExitActions keysDo:[:eachPid |
+	osChildExitActions keysDo:[:eachPid |
-|result sema|
+	    |result sema|
-eachPid notNil ifTrue:[
+	    eachPid notNil ifTrue:[
-result := OperatingSystem
+		result := OperatingSystem
-selectOnAnyReadable:nil writable:nil exception:(Array with:eachPid)
+			    selectOnAnyReadable:nil writable:nil exception:(Array with:eachPid)
-readableInto:nil writableInto:nil exceptionInto:nil
+			       readableInto:nil writableInto:nil exceptionInto:nil
-withTimeOut:0.
+			       withTimeOut:0.
-result < 0 ifTrue:[
+		result < 0 ifTrue:[
-('Processor [info]: removing invalid except-select pid: ' , eachPid printString) infoPrintCR.
+		    ('Processor [info]: removing invalid except-select pid: ' , eachPid printString) infoPrintCR.
-osChildExitActions safeRemoveKey:eachPid.
+		    osChildExitActions safeRemoveKey:eachPid.
-]
+		]
-]
+	    ]
-].
+	].
 ].
 "Modified: 12.4.1996 / 09:32:58 / stefan"
 "Modified: 27.1.1997 / 20:09:27 / cg"
 !
 schedulerInterrupt
 "forced reschedule - switch to scheduler process which will decide
 what to do now."
 activeProcess ~~ scheduler ifTrue:[
-interruptedProcess := activeProcess.
+	interruptedProcess := activeProcess.
-self threadSwitch:scheduler
+	self threadSwitch:scheduler
 ]
 !
 timeToNextTimeout
 "return the delta-T (in millis) to next timeout, or nil if
 If there were many, the list should be kept sorted ... keeping deltas
 to next (as in Unix kernel)"
 n := timeoutArray size.
 1 to:n do:[:index |
-aTime := timeoutArray at:index.
+	aTime := timeoutArray at:index.
-aTime notNil ifTrue:[
+	aTime notNil ifTrue:[
-now isNil ifTrue:[
+	    now isNil ifTrue:[
-now := OperatingSystem getMillisecondTime.
+		now := OperatingSystem getMillisecondTime.
-].
+	    ].
-delta := OperatingSystem millisecondTimeDeltaBetween:aTime and:now.
+	    delta := OperatingSystem millisecondTimeDeltaBetween:aTime and:now.
-delta <= 0 ifTrue:[
+	    delta <= 0 ifTrue:[
-^ 0.
+		^ 0.
-].
+	    ].
-minDelta isNil ifTrue:[
+	    minDelta isNil ifTrue:[
-minDelta := delta
+		minDelta := delta
-] ifFalse:[
+	    ] ifFalse:[
-minDelta := minDelta min:delta
+		minDelta := minDelta min:delta
-]
+	    ]
-]
+	]
 ].
 minDelta isNil ifTrue:[
-"this is safe, since always called with interruptsBlocked"
+	"this is safe, since always called with interruptsBlocked"
-anyTimeouts := false.
+	anyTimeouts := false.
 ].
 ^ minDelta
 !
 This method is called by the VM' interrupt handling mechanism.
 Notice, that at the time of the message, we are still in the context
 of whichever process is currently running."
 activeProcess ~~ scheduler ifTrue:[
-interruptedProcess := activeProcess.
+	interruptedProcess := activeProcess.
-self threadSwitch:scheduler
+	self threadSwitch:scheduler
 ]
 "Modified: 18.10.1996 / 20:35:54 / cg"
 !
 |millis doingGC anySema dT|
 doingGC := true.
 [doingGC] whileTrue:[
-anyTimeouts ifTrue:[
+	anyTimeouts ifTrue:[
-millis := self timeToNextTimeout.
+	    millis := self timeToNextTimeout.
-(millis notNil and:[millis <= 0]) ifTrue:[
+	    (millis notNil and:[millis <= 0]) ifTrue:[
-^ self    "oops - hurry up checking"
+		^ self    "oops - hurry up checking"
-].
+	    ].
-].
+	].
-"
+	"
-if its worth doing, collect a bit of garbage;
+	 if its worth doing, collect a bit of garbage;
-but not, if a backgroundCollector is active
+	 but not, if a backgroundCollector is active
-"
+	"
-ObjectMemory backgroundCollectorRunning ifTrue:[
+	ObjectMemory backgroundCollectorRunning ifTrue:[
-doingGC := false
+	    doingGC := false
-] ifFalse:[
+	] ifFalse:[
-doingGC := ObjectMemory gcStepIfUseful.
+	    doingGC := ObjectMemory gcStepIfUseful.
-].
+	].
-"then do idle actions"
+	"then do idle actions"
-(idleActions notNil and:[idleActions size ~~ 0]) ifTrue:[
+	(idleActions notNil and:[idleActions size ~~ 0]) ifTrue:[
-idleActions do:[:aBlock |
+	    idleActions do:[:aBlock |
-aBlock value.
+		aBlock value.
-].
+	    ].
-^ self   "go back checking"
+	    ^ self   "go back checking"
-].
+	].
-doingGC ifTrue:[
+	doingGC ifTrue:[
-(self checkForIOWithTimeout:0) ifTrue:[
+	    (self checkForIOWithTimeout:0) ifTrue:[
-^ self  "go back checking"
+		^ self  "go back checking"
-]
+	    ]
-]
+	]
 ].
 exitWhenNoMoreUserProcesses ifTrue:[
-"/ check if there are any processes at all
+	"/ check if there are any processes at all
-"/ stop dispatching if there is none
+	"/ stop dispatching if there is none
-"/ (and anyTimeouts is false, which means that no timeout blocks are present)
+	"/ (and anyTimeouts is false, which means that no timeout blocks are present)
-"/ and no readSemaphores are present (which means that noone is waiting for input)
+	"/ and no readSemaphores are present (which means that noone is waiting for input)
-"/ and no writeSemaphores are present
+	"/ and no writeSemaphores are present
-anyTimeouts ifFalse:[
+	anyTimeouts ifFalse:[
-anySema := (readSemaphoreArray findFirst:[:sema | sema notNil]) ~~ 0.
+	    anySema := (readSemaphoreArray findFirst:[:sema | sema notNil]) ~~ 0.
-anySema ifFalse:[
+	    anySema ifFalse:[
-anySema := (writeSemaphoreArray findFirst:[:sema | sema notNil]) ~~ 0.
+		anySema := (writeSemaphoreArray findFirst:[:sema | sema notNil]) ~~ 0.
-anySema ifFalse:[
+		anySema ifFalse:[
-self anyUserProcessAtAll ifFalse:[
+		    self anyUserProcessAtAll ifFalse:[
-dispatching := false.
+			dispatching := false.
-^ self
+			^ self
-]
+		    ]
-].
+		].
-].
+	    ].
-].
+	].
 ].
 preWaitActions notNil ifTrue:[
-preWaitActions do:[:action | action value].
+	preWaitActions do:[:action | action value].
 ].
 "/
 "/ absolutely nothing to do - simply wait
 "/
 OperatingSystem supportsSelect ifFalse:[
-"SCO instant ShitStation has a bug here,
+	"SCO instant ShitStation has a bug here,
-waiting always 1 sec in the select - therefore we delay a bit and
+	 waiting always 1 sec in the select - therefore we delay a bit and
-return - effectively polling in 50ms cycles
+	 return - effectively polling in 50ms cycles
-"
+	"
-(self checkForIOWithTimeout:0) ifTrue:[
+	(self checkForIOWithTimeout:0) ifTrue:[
-^ self  "go back checking"
+	    ^ self  "go back checking"
-].
+	].
-OperatingSystem millisecondDelay:EventPollingInterval.
+	OperatingSystem millisecondDelay:EventPollingInterval.
-^ self
+	^ self
 ].
 useIOInterrupts ifTrue:[
-dT := 999999
+	dT := 999999
 ] ifFalse:[
-dT := EventPollingInterval
+	dT := EventPollingInterval
 ].
 millis isNil ifTrue:[
-millis := dT.
+	millis := dT.
 ] ifFalse:[
-millis := millis rounded min:dT.
+	millis := millis rounded min:dT.
 ].
 self checkForIOWithTimeout:millis
 "Modified: 14.12.1995 / 13:37:46 / stefan"
 ! !
 !ProcessorScheduler class methodsFor:'documentation'!
 version
-^ '$Header: /cvs/stx/stx/libbasic/ProcessorScheduler.st,v 1.302 2015-02-04 20:08:53 stefan Exp $'
+^ '$Header: /cvs/stx/stx/libbasic/ProcessorScheduler.st,v 1.303 2015-04-27 17:04:46 cg Exp $'
 !
 version_CVS
-^ '$Header: /cvs/stx/stx/libbasic/ProcessorScheduler.st,v 1.302 2015-02-04 20:08:53 stefan Exp $'
+^ '$Header: /cvs/stx/stx/libbasic/ProcessorScheduler.st,v 1.303 2015-04-27 17:04:46 cg Exp $'
 ! !
 ProcessorScheduler initialize!

changeset 18295	17324d5bb9cc
parent 17412	ef9b82b8ce77
child 18301	d0a478542bbf
child 18620	b4e9f25d6ce6