hg/stx-libbasic: comparison ProcessorScheduler.st

equal deleted inserted replaced

-:93705f0c6a54
+:d7d5b3f3cc88
 "
 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
 "{ Package: 'stx:libbasic' }"
 "{ NameSpace: Smalltalk }"
 Object subclass:#ProcessorScheduler
-	instanceVariableNames:'quiescentProcessLists scheduler zombie activeProcess
+instanceVariableNames:'quiescentProcessLists scheduler zombie activeProcess
-		activeProcessId currentPriority readFdArray readSemaphoreArray
+activeProcessId currentPriority readFdArray readSemaphoreArray
-		readCheckArray writeFdArray writeSemaphoreArray writeCheckArray
+readCheckArray writeFdArray writeSemaphoreArray writeCheckArray
-		timeoutArray timeoutActionArray timeoutProcessArray
+timeoutArray timeoutActionArray timeoutProcessArray
-		timeoutSemaphoreArray idleActions anyTimeouts dispatching
+timeoutSemaphoreArray idleActions anyTimeouts dispatching
-		interruptedProcess useIOInterrupts gotIOInterrupt
+interruptedProcess useIOInterrupts gotIOInterrupt
-		osChildExitActions gotChildSignalInterrupt
+osChildExitActions gotChildSignalInterrupt
-		exitWhenNoMoreUserProcesses suspendScheduler timeSliceProcess
+exitWhenNoMoreUserProcesses suspendScheduler timeSliceProcess
-		supportDynamicPriorities timeSliceNeededSemaphore
+supportDynamicPriorities timeSliceNeededSemaphore
-		scheduledProcesses preWaitActions timeoutHandlerProcess
+scheduledProcesses preWaitActions timeoutHandlerProcess
-		readableResultFdArray writableResultFdArray exceptFdArray
+readableResultFdArray writableResultFdArray exceptFdArray
-		exceptResultFdArray exceptSemaphoreArray interruptCounter
+exceptResultFdArray exceptSemaphoreArray interruptCounter
-		timedActionCounter'
+timedActionCounter'
-	classVariableNames:'KnownProcesses KnownProcessIds PureEventDriven
+classVariableNames:'KnownProcesses KnownProcessIds PureEventDriven
-		UserSchedulingPriority UserInterruptPriority TimingPriority
+UserSchedulingPriority UserInterruptPriority TimingPriority
-		HighestPriority SchedulingPriority MaxNumberOfProcesses
+HighestPriority SchedulingPriority MaxNumberOfProcesses
-		InvalidProcessSignal TimeSlicingPriorityLimit TimeSliceInterval
+InvalidProcessSignal TimeSlicingPriorityLimit TimeSliceInterval
-		EventPollingInterval MaxProcessId'
+EventPollingInterval MaxProcessId'
-	poolDictionaries:''
+poolDictionaries:''
-	category:'Kernel-Processes'
+category:'Kernel-Processes'
 !
 !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
 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"
-	Smalltalk at:#Processor put:(self basicNew initialize).
+Smalltalk at:#Processor put:(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
 "Modified: / 23-09-1996 / 14:24:50 / stefan"
 "Modified: / 10-01-1997 / 18:03:03 / cg"
 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) class == SmallInteger ifTrue:[
+(KnownProcesses at:index) class == SmallInteger 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"
 ! !
 (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 class ~~ SmallInteger]) ifTrue:[aBlock value:p]
+(p notNil and:[p class ~~ SmallInteger]) ifTrue:[aBlock value:p]
 ]
 "Created: / 26-10-2012 / 13:02:33 / 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].
 !
 |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
 "
 gotChildSignalInterrupt := false.
 interruptCounter := timedActionCounter := 0.
 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.
 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 class ~~ SmallInteger]) ifTrue:[
+(p notNil and:[p class ~~ SmallInteger]) 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"
 !
 what to do now."
 gotChildSignalInterrupt := true.
 interruptCounter := interruptCounter + 1 bitAnd:SmallInteger maxVal.
 activeProcess ~~ scheduler ifTrue:[
-	interruptCounter := interruptCounter + 1 bitAnd:SmallInteger maxVal.
+interruptCounter := interruptCounter + 1 bitAnd:SmallInteger maxVal.
-	interruptedProcess := activeProcess.
+interruptedProcess := activeProcess.
-	self threadSwitch:scheduler
+self threadSwitch:scheduler
 ]
 "Modified: 12.4.1996 / 10:12:18 / stefan"
 !
 blocking := OperatingSystem isChildProcessWaitBlocking.
 "/ 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"
 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"
 !
 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
 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
 "
 !
 processesWithGroupId:anInteger
 "answer a collection of processes with processGroupId, anInteger"
 "/ 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.
 |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"
 !
 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
 "
 |idx "{ Class: SmallInteger }"
 wasBlocked sema semaCollection|
 wasBlocked := OperatingSystem blockInterrupts.
 useIOInterrupts ifTrue:[
-	OperatingSystem disableIOInterruptsOn:aFileDescriptor.
+OperatingSystem disableIOInterruptsOn:aFileDescriptor.
 ].
 idx := readFdArray indexOf:aFileDescriptor startingAt:1.
 [idx ~~ 0] whileTrue:[
-	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.
-	    semaCollection isNil ifTrue:[semaCollection := Set new].
+semaCollection isNil ifTrue:[semaCollection := Set new].
-	    semaCollection add:sema.
+semaCollection add:sema.
-	].
+].
-	idx := readFdArray indexOf:aFileDescriptor startingAt:idx+1.
+idx := readFdArray indexOf:aFileDescriptor startingAt:idx+1.
 ].
 idx := writeFdArray indexOf:aFileDescriptor startingAt:1.
 [idx ~~ 0] whileTrue:[
-	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.
-	    semaCollection isNil ifTrue:[semaCollection := Set new].
+semaCollection isNil ifTrue:[semaCollection := Set new].
-	    semaCollection add:sema.
+semaCollection add:sema.
-	].
+].
-	idx := writeFdArray indexOf:aFileDescriptor startingAt:idx+1.
+idx := writeFdArray indexOf:aFileDescriptor startingAt:idx+1.
 ].
 idx := exceptFdArray indexOf:aFileDescriptor startingAt:1.
 [idx ~~ 0] whileTrue:[
-	exceptFdArray at:idx put:nil.
+exceptFdArray at:idx put:nil.
-	(sema := exceptSemaphoreArray at:idx) notNil ifTrue:[
+(sema := exceptSemaphoreArray at:idx) notNil ifTrue:[
-	    exceptSemaphoreArray at:idx put:nil.
+exceptSemaphoreArray at:idx put:nil.
-	    semaCollection isNil ifTrue:[semaCollection := Set new].
+semaCollection isNil ifTrue:[semaCollection := Set new].
-	    semaCollection add:sema.
+semaCollection add:sema.
-	].
+].
-	idx := exceptFdArray indexOf:aFileDescriptor startingAt:idx+1.
+idx := exceptFdArray indexOf:aFileDescriptor startingAt:idx+1.
 ].
 semaCollection isNil ifTrue:[
-	semaCollection := #().
+semaCollection := #().
 ] ifFalse:[
-	doSignal ifTrue:[
+doSignal ifTrue:[
-	    semaCollection do:[:eachSema|
+semaCollection do:[:eachSema|
-		eachSema signalForAll.
+eachSema signalForAll.
-		semaCollection := #().
+semaCollection := #().
-	    ].
+].
-	].
+].
 ].
 wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
 ^ semaCollection
 !
 wasBlocked := OperatingSystem blockInterrupts.
 idx := 0.
 [idx := readSemaphoreArray identityIndexOf:aSemaphore startingAt:idx+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 := 0.
 [idx := writeSemaphoreArray identityIndexOf:aSemaphore startingAt:idx+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 := 0.
 [idx := exceptSemaphoreArray identityIndexOf:aSemaphore startingAt:idx+1.
 idx ~~ 0] whileTrue:[
-	exceptFdArray at:idx put:nil.
+exceptFdArray at:idx put:nil.
-	exceptSemaphoreArray at:idx put:nil.
+exceptSemaphoreArray at:idx put:nil.
 ].
 self removeTimeoutForSemaphore:aSemaphore.
 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 := exceptSemaphoreArray identityIndexOf:aSemaphore or:nil.
+idx := exceptSemaphoreArray 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"
-	    exceptFdArray := exceptFdArray copyWith:nil.
+exceptFdArray := exceptFdArray copyWith:nil.
-	    exceptSemaphoreArray := exceptSemaphoreArray copyWith:aSemaphore.
+exceptSemaphoreArray := exceptSemaphoreArray copyWith:aSemaphore.
-	] ifFalse:[
+] ifFalse:[
-	    slot := exceptSemaphoreArray at:idx.
+slot := exceptSemaphoreArray at:idx.
-	    slot isNil ifTrue:[
+slot isNil ifTrue:[
-		exceptSemaphoreArray at:idx put:aSemaphore.
+exceptSemaphoreArray at:idx put:aSemaphore.
-	    ]
+]
-	]
+]
 ] ifFalse:[
-	idx := exceptFdArray identityIndexOf:aFileDescriptor or:nil.
+idx := exceptFdArray 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"
-	    exceptFdArray := exceptFdArray copyWith:aFileDescriptor.
+exceptFdArray := exceptFdArray copyWith:aFileDescriptor.
-	    exceptSemaphoreArray := exceptSemaphoreArray copyWith:aSemaphore.
+exceptSemaphoreArray := exceptSemaphoreArray copyWith:aSemaphore.
-	] ifFalse:[
+] ifFalse:[
-	    slot := exceptFdArray at:idx.
+slot := exceptFdArray at:idx.
-	    slot isNil ifTrue:[
+slot isNil ifTrue:[
-		exceptFdArray at:idx put:aFileDescriptor.
+exceptFdArray at:idx put:aFileDescriptor.
-		exceptSemaphoreArray at:idx put:aSemaphore.
+exceptSemaphoreArray at:idx put:aSemaphore.
-	    ].
+].
-	].
+].
 "/        (useIOInterrupts and:[slot isNil]) ifTrue:[
 "/            OperatingSystem enableIOInterruptsOn:aFileDescriptor
 "/        ].
 ].
 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"
 !
 "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"
 !
 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"
 ! !
 |sema now aTime block blocksAndProcessesToEvaluate
 firstBlockToEvaluate firstProcess
 n "{ Class: SmallInteger }"
 indexOfLastTimeout "{ Class: SmallInteger }"
-halfSize "{ Class: SmallInteger }"
+halfSize "{ Class: SmallInteger }" process wasBlocked|
-wasBlocked p|
+anyTimeouts ifFalse:[
-anyTimeouts ifFalse:[ ^ self].
+^ self
+].
 anyTimeouts := false.
 indexOfLastTimeout := 0.
 "have to collect the blocks first, then evaluate them.
 This avoids problems due to newly inserted blocks."
 "/ To avoid idle memory allocation, we avoid the allocation of the OrderedCollection in this case,
 "/ by remembering the first block+process in a variable until another block is found.
 "/ Thus firstBlockToEvaluate+firstProcess effectively cache the first slot of the lazy allocated collection.
 "/ looks ugly, but as this is called very often, reduces idle allocation by a lot.
+wasBlocked := OperatingSystem blockInterrupts.
 now := OperatingSystem getMillisecondTime.
 n := timeoutArray size.
 1 to:n do:[:index |
 aTime := timeoutArray at:index.
 aTime notNil ifTrue:[
 "this one should be triggered"
 sema := timeoutSemaphoreArray at:index.
 sema notNil ifTrue:[
 timeoutSemaphoreArray at:index put:nil.
-timedActionCounter := (timedActionCounter + 1 bitAnd:SmallInteger maxVal).
+timedActionCounter := (timedActionCounter + 1) bitAnd:SmallInteger maxVal.
 sema signalOnceWithoutReschedule.
 ] ifFalse:[
 "to support pure-events"
 block := timeoutActionArray at:index.
 block notNil ifTrue:[
 firstProcess := timeoutProcessArray at:index.
 ] ifFalse:[
 blocksAndProcessesToEvaluate isNil ifTrue:[
 blocksAndProcessesToEvaluate := OrderedCollection
 with:firstBlockToEvaluate
-with:firstProcess.
+with:firstProcess
+with:block
+with:(timeoutProcessArray at:index).
+] ifFalse:[
+blocksAndProcessesToEvaluate
+add:block;
+add:(timeoutProcessArray at:index).
 ].
-blocksAndProcessesToEvaluate add:block.
-blocksAndProcessesToEvaluate add:(timeoutProcessArray at:index).
 ].
 timeoutActionArray at:index put:nil.
 timeoutProcessArray at:index put:nil.
 ]
 ].
 "shrink the arrays, if they are 50% free"
 n > 20 ifTrue:[
 halfSize := n // 2.
 (indexOfLastTimeout ~~ 0 and:[indexOfLastTimeout < halfSize]) ifTrue:[
-wasBlocked := OperatingSystem blockInterrupts.
+timeoutArray := timeoutArray copyTo:halfSize.
-(timeoutArray at:indexOfLastTimeout+1) isNil ifTrue:[   "/ no new timeouts arrived
+timeoutSemaphoreArray := timeoutSemaphoreArray copyTo:halfSize.
-timeoutArray := timeoutArray copyTo:halfSize.
+timeoutActionArray := timeoutActionArray copyTo:halfSize.
-timeoutSemaphoreArray := timeoutSemaphoreArray copyTo:halfSize.
+timeoutProcessArray := timeoutProcessArray copyTo:halfSize.
-timeoutActionArray := timeoutActionArray copyTo:halfSize.
-timeoutProcessArray := timeoutProcessArray copyTo:halfSize.
-].
-wasBlocked ifFalse:[ OperatingSystem unblockInterrupts ].
 ].
 ].
 "/ usually (>99%), there is only one single timeout action to call;
 "/ above code avoided the creation of an OrderedCollection
 blocksAndProcessesToEvaluate isNil ifTrue:[
 firstBlockToEvaluate notNil ifTrue:[
-timedActionCounter := (timedActionCounter + 1 bitAnd:SmallInteger maxVal).
+timedActionCounter := (timedActionCounter + 1) bitAnd:SmallInteger maxVal.
 (firstProcess isNil or:[firstProcess == scheduler or:[PureEventDriven]]) ifTrue:[
 firstBlockToEvaluate value
 ] ifFalse:[
 firstProcess isDead ifTrue:[
 "/ a timedBlock for a process which has already terminated
 ].
 ] ifFalse:[
 n := blocksAndProcessesToEvaluate size.
 1 to:n by:2 do:[:index |
 block := blocksAndProcessesToEvaluate at:index.
-p := blocksAndProcessesToEvaluate at:index+1.
+process := blocksAndProcessesToEvaluate at:index+1.
-(p isNil or:[p == scheduler or:[PureEventDriven]]) ifTrue:[
+(process isNil or:[process == scheduler or:[PureEventDriven]]) ifTrue:[
 block value.
-timedActionCounter := (timedActionCounter + 1 bitAnd:SmallInteger maxVal).
+timedActionCounter := (timedActionCounter + 1) bitAnd:SmallInteger maxVal.
 ] ifFalse:[
-p isDead ifTrue:[
+process isDead ifTrue:[
 "/ a timedBlock for a process which has already terminated
 "/ issue a warning and do not execute it.
 "/ (executing here may be dangerous, since it would run at scheduler priority here,
 "/  and thereby could block the whole smalltalk system.
 "/  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 (', block displayString, ') for dead process: ''' , p name , '''') errorPrintCR.
+('ProcessorScheduler [warning]: cannot evaluate timedBlock (', block displayString, ') for dead process: ''' , process name , '''') errorPrintCR.
 "/      ].
 ] ifFalse:[
-timedActionCounter := (timedActionCounter + 1 bitAnd:SmallInteger maxVal).
+timedActionCounter := (timedActionCounter + 1) bitAnd:SmallInteger maxVal.
-p interruptWith:block
+process interruptWith:block
 ]
 ]
 ]
 ].
+wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
-"Modified: / 24-07-2017 / 16:15:36 / stefan"
+"Modified: / 25-07-2017 / 14:49:46 / stefan"
 "Modified: / 25-07-2017 / 11:27:00 / cg"
 !
 removeTimedBlock:aBlock
 "remove the argument, aBlock from the list of time-sceduled-blocks."
 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].
 !
 removeTimeoutForSemaphore:aSemaphore
 |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"
 !
 |index "{ Class: SmallInteger }"
 wasBlocked|
 index := anID.
 (anID notNil and:[index > 0]) ifTrue:[
-	wasBlocked := OperatingSystem blockInterrupts.
+wasBlocked := OperatingSystem blockInterrupts.
-	(aBlockOrSemaphore notNil
+(aBlockOrSemaphore notNil
-	  and:[(timeoutActionArray at:index ifAbsent:[]) ~~ aBlockOrSemaphore
+and:[(timeoutActionArray at:index ifAbsent:[]) ~~ aBlockOrSemaphore
-	  and:[(timeoutSemaphoreArray at:index ifAbsent:[]) ~~ aBlockOrSemaphore]]) ifTrue:[
+and:[(timeoutSemaphoreArray at:index ifAbsent:[]) ~~ aBlockOrSemaphore]]) ifTrue:[
-	    'Processor: trying to remove stale timeout id - ignored' errorPrintCR.
+'Processor: trying to remove stale timeout id - ignored' errorPrintCR.
-	] ifFalse:[
+] ifFalse:[
-	    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].
 ]
 !
 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"
 !
 |wasBlocked|
 wasBlocked := OperatingSystem blockInterrupts.
 preWaitActions isNil ifTrue:[
-	preWaitActions := OrderedCollection new
+preWaitActions := OrderedCollection new
 ].
 preWaitActions add:aBlock.
 wasBlocked ifFalse:[OperatingSystem unblockInterrupts].
 !
 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:[
-	interruptCounter := interruptCounter + 1 bitAnd:SmallInteger maxVal.
+interruptCounter := interruptCounter + 1 bitAnd:SmallInteger maxVal.
-	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: ' infoPrint. fd infoPrint. ' idx: 'infoPrint. idx infoPrintCR.
+'Processor [info]: removing invalid read-select fileDescriptor: ' infoPrint. fd infoPrint. ' idx: 'infoPrint. idx 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.
-		    self removeTimeoutForSemaphore:sema.
+self removeTimeoutForSemaphore:sema.
-		    sema signalForAll.
+sema signalForAll.
-		].
+].
-	    ]
+]
-	].
+].
 ].
 writeFdArray keysAndValuesDo:[:idx :fd |
-	|result sema|
+|result sema|
-	fd notNil ifTrue:[
+fd notNil ifTrue:[
-	    result := OperatingSystem
+result := OperatingSystem
-			selectOnAnyReadable:nil writable:(Array with:fd) exception:nil
+selectOnAnyReadable:nil writable:(Array with:fd) 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: ' infoPrint. fd infoPrint. ' idx: 'infoPrint. idx infoPrintCR.
+'Processor [info]: removing invalid write-select fileDescriptor: ' infoPrint. fd infoPrint. ' idx: 'infoPrint. idx 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.
-		    self removeTimeoutForSemaphore:sema.
+self removeTimeoutForSemaphore:sema.
-		    sema signalForAll.
+sema signalForAll.
-		].
+].
-	    ]
+]
-	]
+]
 ].
 exceptFdArray keysAndValuesDo:[:idx :fd |
-	|result sema|
+|result sema|
-	fd notNil ifTrue:[
+fd notNil ifTrue:[
-	    result := OperatingSystem
+result := OperatingSystem
-			selectOnAnyReadable:nil writable:nil exception:(Array with:fd)
+selectOnAnyReadable:nil writable:nil exception:(Array with:fd)
-			   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 exception-select fileDescriptor: ' infoPrint. fd infoPrint. ' idx: 'infoPrint. idx infoPrintCR.
+'Processor [info]: removing invalid exception-select fileDescriptor: ' infoPrint. fd infoPrint. ' idx: 'infoPrint. idx infoPrintCR.
-		exceptFdArray at:idx put:nil.
+exceptFdArray at:idx put:nil.
-		(sema := exceptSemaphoreArray at:idx) notNil ifTrue:[
+(sema := exceptSemaphoreArray at:idx) notNil ifTrue:[
-		    exceptSemaphoreArray at:idx put:nil.
+exceptSemaphoreArray at:idx put:nil.
-		    self removeTimeoutForSemaphore:sema.
+self removeTimeoutForSemaphore:sema.
-		    sema signalForAll.
+sema signalForAll.
-		].
+].
-	    ]
+]
-	]
+]
 ].
 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 exception-select pid: ' infoPrint. eachPid infoPrintCR.
+'Processor [info]: removing invalid exception-select pid: ' infoPrint. eachPid 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:[
-	interruptCounter := interruptCounter + 1 bitAnd:SmallInteger maxVal.
+interruptCounter := interruptCounter + 1 bitAnd:SmallInteger maxVal.
-	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:[
-	interruptCounter := interruptCounter + 1 bitAnd:SmallInteger maxVal.
+interruptCounter := interruptCounter + 1 bitAnd:SmallInteger maxVal.
-	interruptedProcess := activeProcess.
+interruptedProcess := activeProcess.
-	self threadSwitch:scheduler
+self threadSwitch:scheduler
 ]
 "Modified: 18.10.1996 / 20:35:54 / cg"
 !

changeset 22095	d7d5b3f3cc88
parent 22094	93705f0c6a54
child 22146	0a52bd3e639a