hg/stx-libbasic: comparison Behavior.st

equal deleted inserted replaced

-:99d8ad133755
+:5023fe2f46ce
 "
 COPYRIGHT (c) 1988 by Claus Gittinger
-All Rights Reserved
+	      All Rights Reserved
 This software is furnished under a license and may be used
 only in accordance with the terms of that license and with the
 inclusion of the above copyright notice.   This software may not
 be provided or otherwise made available to, or used by, any
 hereby transferred.
 "
 "{ Package: 'stx:libbasic' }"
 Object subclass:#Behavior
-instanceVariableNames:'superclass flags methodDictionary lookupObject instSize'
+	instanceVariableNames:'superclass flags methodDictionary lookupObject instSize'
-classVariableNames:'SubclassInfo'
+	classVariableNames:'SubclassInfo'
-poolDictionaries:''
+	poolDictionaries:''
-category:'Kernel-Classes'
+	category:'Kernel-Classes'
 !
 !Behavior class methodsFor:'documentation'!
 copyright
 "
 COPYRIGHT (c) 1988 by Claus Gittinger
-All Rights Reserved
+	      All Rights Reserved
 This software is furnished under a license and may be used
 only in accordance with the terms of that license and with the
 inclusion of the above copyright notice.   This software may not
 be provided or otherwise made available to, or used by, any
 (lookup and search in these is seldom anyway, so the added benefit from using a
 hashed dictionary is almost void).
 [Instance variables:]
-superclass        <Class>            the receivers superclass
+	superclass        <Class>            the receivers superclass
-methodDictionary  <MethodDictionary> inst-selectors and methods
+	methodDictionary  <MethodDictionary> inst-selectors and methods
-instSize          <SmallInteger>     the number of instance variables
+	instSize          <SmallInteger>     the number of instance variables
-flags             <SmallInteger>     special flag bits coded in a number
+	flags             <SmallInteger>     special flag bits coded in a number
-not for application use
+					     not for application use
 flag bits (see stc.h):
 NOTICE: layout known by compiler and runtime system; be careful when changing
 [author:]
-Claus Gittinger
+	Claus Gittinger
 [see also:]
-Class ClassDescription Metaclass
+	Class ClassDescription Metaclass
-Method MethodDictionary
+	Method MethodDictionary
 "
 !
 virtualMachineRelationship
 "
 Expert info follows:
 --------------------
 NOTICE:
-the stuff described below may not be available on other
+	the stuff described below may not be available on other
-Smalltalk implementations; be aware that these error mechanisms
+	Smalltalk implementations; be aware that these error mechanisms
-are ST/X specials and applications using these (tricks) may
+	are ST/X specials and applications using these (tricks) may
-not be portable to other systems.
+	not be portable to other systems.
 WARNING:
-do not try the examples below on (some) other smalltalk systems;
+	do not try the examples below on (some) other smalltalk systems;
-it has been reported, that some crash badly when doing this .... ;-)
+	it has been reported, that some crash badly when doing this .... ;-)
 Instances of Behavior and subclasses (i.e. in sloppy words: classes)
 play a special role w.r.t. the VM. Only objects whose class-slot is marked
 as being behaviorLike (in the flag-instvar) are considered to be classLike
 and a message lookup will be done for it in the well known way.
 Be aware, that the VM trusts the isBehaviorLike flag - IF it is set for some
 object, the VM EXPECTS the object selector and methodDictionaries to be found
 at the instance positions as defined here.
 (i.e. instanceVariables with contents and semantic corresponding to
-superclass
+	superclass
-flags
+	flags
-methodDictionary
+	methodDictionary
 must be present and have the same instVar-index as here).
 The VM (and the system) may crash badly, if this is not the case.
 Since every class in the system derives from Behavior, the flag setting
 ST-programmer, though (and even most of those will never use these features).
 Examples (only of theoretical interest):
 ----------------------------------------
-take away the behaviorLike-flag from a class.
+	take away the behaviorLike-flag from a class.
--> The instances will not understand any messages, since the VM will
+	-> The instances will not understand any messages, since the VM will
-not recognize its class as being a class ...
+	   not recognize its class as being a class ...
-|newMeta notRecognizedAsClass someInstance|
+	|newMeta notRecognizedAsClass someInstance|
-newMeta := Metaclass new.
+	newMeta := Metaclass new.
-newMeta flags:0.
+	newMeta flags:0.
-notRecognizedAsClass := newMeta new.
+	notRecognizedAsClass := newMeta new.
-someInstance := notRecognizedAsClass new.
+	someInstance := notRecognizedAsClass new.
-someInstance perform:#isNil
+	someInstance perform:#isNil
 Of course, this is an exception which can be handled ...:
 Example:
-|newMeta notRecognizedAsClass someInstance|
+	|newMeta notRecognizedAsClass someInstance|
-newMeta := Metaclass new.
+	newMeta := Metaclass new.
-newMeta flags:0.
+	newMeta flags:0.
-notRecognizedAsClass := newMeta new.
+	notRecognizedAsClass := newMeta new.
-someInstance := notRecognizedAsClass new.
+	someInstance := notRecognizedAsClass new.
-Object errorSignal handle:[:ex |
+	Object errorSignal handle:[:ex |
-ex return
+	    ex return
-] do:[
+	] do:[
-someInstance perform:#isNil
+	    someInstance perform:#isNil
-]
+	]
 likewise, a doesNotUnderstand-notUnderstood can be handled:
 Example:
-|newMeta funnyClass someInstance|
+	|newMeta funnyClass someInstance|
-newMeta := Metaclass new.
+	newMeta := Metaclass new.
-funnyClass := newMeta new.
+	funnyClass := newMeta new.
-funnyClass setSuperclass:nil.
+	funnyClass setSuperclass:nil.
-someInstance := funnyClass new.
+	someInstance := funnyClass new.
-Object errorSignal handle:[:ex |
+	Object errorSignal handle:[:ex |
-ex return
+	     ex return
-] do:[
+	] do:[
-someInstance perform:#isNil
+	    someInstance perform:#isNil
-]
+	]
 more examples, which try to trick the VM ;-):
-badly playing around with a classes internals ...
+	badly playing around with a classes internals ...
-|newClass someInstance|
+	|newClass someInstance|
-newClass := Class new.
+	newClass := Class new.
-newClass setSuperclass:nil.
+	newClass setSuperclass:nil.
-someInstance := newClass new.
+	someInstance := newClass new.
-someInstance inspect
+	someInstance inspect
-|newClass someInstance|
+	|newClass someInstance|
-newClass := Class new.
+	newClass := Class new.
-newClass setSuperclass:newClass.
+	newClass setSuperclass:newClass.
-someInstance := newClass new.
+	someInstance := newClass new.
-someInstance inspect
+	someInstance inspect
-|newClass someInstance|
+	|newClass someInstance|
-newClass := Class new.
+	newClass := Class new.
-newClass setSuperclass:1.
+	newClass setSuperclass:1.
-someInstance := newClass new.
+	someInstance := newClass new.
-someInstance inspect
+	someInstance inspect
 Example:
-creating totally anonymous classes:
+	creating totally anonymous classes:
-|newClass someInstance|
+	|newClass someInstance|
-newClass := Class new.
+	newClass := Class new.
-someInstance := newClass new.
+	someInstance := newClass new.
-someInstance inspect
+	someInstance inspect
 Example:
-creating totally anonymous metaclasses:
+	creating totally anonymous metaclasses:
-|newMeta newClass someInstance|
+	|newMeta newClass someInstance|
-newMeta := Metaclass new.
+	newMeta := Metaclass new.
-newClass := newMeta new.
+	newClass := newMeta new.
-someInstance := newClass new.
+	someInstance := newClass new.
-someInstance inspect
+	someInstance inspect
 PS: if you experiment with new behaviorLike objects, you may want
-to turn off the VM's debugPrintouts
+	to turn off the VM's debugPrintouts
-with:
+	with:
-'Smalltalk debugPrinting:false'
+		'Smalltalk debugPrinting:false'
-and:
+	and:
-'Smalltalk infoPrinting:false'
+		'Smalltalk infoPrinting:false'
 Meta-Object-Protocol support:
 -----------------------------
 the above tricks do not affect the inline caches, and are therefore somewhat slow.
 Another hook is the lookupObject which, if non-nil, is consulted to do the lookup
 instead of the hardwired VM lookup algorithm, and provide a method as return value.
 This method (if non-nil) will be put into the inline-and polymorph caches for speedy
 call the next time. If non-nil, the lookup object is sent the:
-lookupMethodForSelector:aSelector
+	    lookupMethodForSelector:aSelector
-directedTo:searchClass
+	    directedTo:searchClass
-for:aReceiver
+	    for:aReceiver
-withArguments:argArrayOrNil
+	    withArguments:argArrayOrNil
-from:sendingContext
+	    from:sendingContext
 message.
 'searchClass' is the object class or any of its superclasses (for directed/super sends).
 You can return any arbitrary method there - for example to implement multiple inheritance,
 selector namespace tricks or multi-dispatch on argument types (double dispatch for a method).
 Be aware, that the returned method is cached, and the lookup is not consulted again for the
 |newClass|
 newClass := self basicNew.
 newClass
-setSuperclass:Object
+	setSuperclass:Object
-methodDictionary:(MethodDictionary new)
+	methodDictionary:(MethodDictionary new)
-instSize:0
+	instSize:0
-flags:(self flagBehavior).
+	flags:(self flagBehavior).
 ^ newClass
 "
 Behavior new               <- a new behavior
 Behavior new new           <- an instance of it
 |bit|
 bit := Class flagBehavior.
 ObjectMemory allObjectsDo:[:o|
 o isBehavior ifTrue:[
-(o class flags bitTest:bit) ifFalse:[
+	 (o class flags bitTest:bit) ifFalse:[
-self halt
+	     self halt
-].
+	 ].
 ] ifFalse:[
-(o class flags bitTest:bit) ifTrue:[
+	 (o class flags bitTest:bit) ifTrue:[
-self halt
+	     self halt
-].
+	 ].
 ].
 o class isBehavior ifFalse:[
-self halt
+	 self halt
 ] ifTrue:[
-(o class class flags bitTest:bit) ifFalse:[
+	 (o class class flags bitTest:bit) ifFalse:[
-self halt
+	     self halt
-]
+	 ]
 ]
 ]
 "
 !
 !
 flagForSymbolic:aSymbol
 "return the flag code for indexed instances with aSymbolic type.
 The argument may be one of
-#float, #double,
+	#float, #double,
-#word, #signedWord,
+	#word, #signedWord,
-#long, #signedLong
+	#long, #signedLong
-#longLong, #signedLongLong,
+	#longLong, #signedLongLong,
-#byte
+	#byte
-#weakObjects
+	#weakObjects
 For VW compatibility, also accept:
-#objects, #bytes, #weak.
+	#objects, #bytes, #weak.
 "
 %{   /* NOCONTEXT */
 if (aSymbol == @symbol(float)) {
-RETURN ( __mkSmallInteger(FLOATARRAY) );
+	RETURN ( __mkSmallInteger(FLOATARRAY) );
 }
 if (aSymbol == @symbol(double)) {
-RETURN ( __mkSmallInteger(DOUBLEARRAY) );
+	RETURN ( __mkSmallInteger(DOUBLEARRAY) );
 }
 if (aSymbol == @symbol(long)) {
-RETURN ( __mkSmallInteger(LONGARRAY) );
+	RETURN ( __mkSmallInteger(LONGARRAY) );
 }
 if (aSymbol == @symbol(longLong)) {
-RETURN ( __mkSmallInteger(LONGLONGARRAY) );
+	RETURN ( __mkSmallInteger(LONGLONGARRAY) );
 }
 if (aSymbol == @symbol(word)) {
-RETURN ( __mkSmallInteger(WORDARRAY) );
+	RETURN ( __mkSmallInteger(WORDARRAY) );
 }
 if (aSymbol == @symbol(signedWord)) {
-RETURN ( __mkSmallInteger(SWORDARRAY) );
+	RETURN ( __mkSmallInteger(SWORDARRAY) );
 }
 if (aSymbol == @symbol(signedLong)) {
-RETURN ( __mkSmallInteger(SLONGARRAY) );
+	RETURN ( __mkSmallInteger(SLONGARRAY) );
 }
 if (aSymbol == @symbol(signedLongLong)) {
-RETURN ( __mkSmallInteger(SLONGLONGARRAY) );
+	RETURN ( __mkSmallInteger(SLONGLONGARRAY) );
 }
 if ((aSymbol == @symbol(byte)) || (aSymbol == @symbol(bytes))) {
-RETURN ( __mkSmallInteger(BYTEARRAY) );
+	RETURN ( __mkSmallInteger(BYTEARRAY) );
 }
 if (aSymbol == @symbol(objects)) {
-RETURN ( __mkSmallInteger(POINTERARRAY) );
+	RETURN ( __mkSmallInteger(POINTERARRAY) );
 }
 if ((aSymbol == @symbol(weakObjects)) || (aSymbol == @symbol(weak))) {
-RETURN ( __mkSmallInteger(WKPOINTERARRAY) );
+	RETURN ( __mkSmallInteger(WKPOINTERARRAY) );
 }
 %}.
 ^ 0         "/ not indexed
 "Modified: / 07-06-2007 / 11:57:44 / cg"
 |remaining classesInLoadOrder|
 "private classes are not loaded directly, so ignore them"
 remaining := someClasses asIdentitySet reject:[:eachClass| eachClass isPrivate].
 "JV-2011-05-05: Sort the classes by name to get more stable order.
 This stabilizes order of classes in generated build files and
 makes text-based diffing/merging easier for both human beings
 and version control systems"
 remaining := remaining asOrderedCollection sort:[:a :b|a name < b name].
 classesInLoadOrder := OrderedCollection new:(remaining size).
 [remaining notEmpty] whileTrue:[
-|thoseWithOtherSuperclasses thoseWhichCanBeLoadedNow|
+	|thoseWithOtherSuperclasses thoseWhichCanBeLoadedNow|
-"find the next class(es) to be loaded.
+	"find the next class(es) to be loaded.
-Consider first:
+	 Consider first:
-all those, which do not have a superclass in the remaining set.
+	    all those, which do not have a superclass in the remaining set.
-and which do not use a shared pool defined in the remaining set"
+	    and which do not use a shared pool defined in the remaining set"
-thoseWithOtherSuperclasses :=
+	thoseWithOtherSuperclasses :=
-remaining
+	    remaining
-reject:[:eachClass |
+		reject:[:eachClass |
-(remaining includes:eachClass superclass)
+		    (remaining includes:eachClass superclass)
-or:[eachClass sharedPoolNames contains:[:eachPoolSymbol|
+		    or:[eachClass sharedPoolNames contains:[:eachPoolSymbol|
-remaining contains:[:eachRemainingClass| eachPoolSymbol = eachRemainingClass name]
+			    remaining contains:[:eachRemainingClass| eachPoolSymbol = eachRemainingClass name]
-]
+			]
-].
+		    ].
-].
+		].
-"second: the subset with all those having no private classes,
+	"second: the subset with all those having no private classes,
-or having private classes, whose superclasses are NOT in the remaining set"
+		 or having private classes, whose superclasses are NOT in the remaining set"
-thoseWhichCanBeLoadedNow :=
+	thoseWhichCanBeLoadedNow :=
-thoseWithOtherSuperclasses
+	    thoseWithOtherSuperclasses
-reject:[:eachClass |
+		reject:[:eachClass |
-eachClass allPrivateClasses contains:[:eachPrivateClass| |superClassesOwner|
+		    eachClass allPrivateClasses contains:[:eachPrivateClass| |superClassesOwner|
-superClassesOwner := eachPrivateClass superclass.
+			superClassesOwner := eachPrivateClass superclass.
-"take care of classes inheriting from nil or ProtoObject"
+			"take care of classes inheriting from nil or ProtoObject"
-superClassesOwner isBehavior ifTrue:[
+			superClassesOwner isBehavior ifTrue:[
-superClassesOwner := superClassesOwner owningClassOrYourself.
+			    superClassesOwner := superClassesOwner owningClassOrYourself.
-].
+			].
-superClassesOwner ~~ eachClass
+			superClassesOwner ~~ eachClass
-and:[remaining includes:superClassesOwner]
+			and:[remaining includes:superClassesOwner]
-].
+		    ].
-].
+		].
-thoseWhichCanBeLoadedNow isEmpty ifTrue:[
+	thoseWhichCanBeLoadedNow isEmpty ifTrue:[
-thoseWithOtherSuperclasses isEmpty ifTrue:[
+	    thoseWithOtherSuperclasses isEmpty ifTrue:[
-"this does not normally happen"
+		"this does not normally happen"
-self error:'superclass order is cyclic'.
+		self error:'superclass order is cyclic'.
-] ifFalse:[
+	    ] ifFalse:[
-"no class found, that may be loaded - maybe there is a cyclic
+		"no class found, that may be loaded - maybe there is a cyclic
-dependency involving private classes.
+		 dependency involving private classes.
-If you proceed here, private class dependencies are ignored
+		 If you proceed here, private class dependencies are ignored
-for this pass"
+		 for this pass"
-self error:'load order is cyclic (care for private classes)' mayProceed:true.
+		self error:'load order is cyclic (care for private classes)' mayProceed:true.
-thoseWhichCanBeLoadedNow := thoseWithOtherSuperclasses.
+		thoseWhichCanBeLoadedNow := thoseWithOtherSuperclasses.
-].
+	    ].
-].
+	].
-remaining removeAllFoundIn:thoseWhichCanBeLoadedNow.
+	remaining removeAllFoundIn:thoseWhichCanBeLoadedNow.
-classesInLoadOrder addAll:(thoseWhichCanBeLoadedNow asArray sort:[:a :b | a name < b name]).
+	classesInLoadOrder addAll:(thoseWhichCanBeLoadedNow asArray sort:[:a :b | a name < b name]).
 ].
 ^ classesInLoadOrder
 "
 Class classesSortedByLoadOrder:(Smalltalk allClassesInPackage:'stx:libbasic')
 A helper for the browser, some dialogs and some refactorings"
 |common|
 listOfClassesOrClassNames do:[:classOrClassName |
-|class|
+	|class|
-class := classOrClassName isBehavior
+	class := classOrClassName isBehavior
-ifTrue:[classOrClassName]
+			ifTrue:[classOrClassName]
-ifFalse:[Smalltalk classNamed:classOrClassName].
+			ifFalse:[Smalltalk classNamed:classOrClassName].
-common isNil ifTrue:[
+	common isNil ifTrue:[
-common := class
+	    common := class
-] ifFalse:[
+	] ifFalse:[
-(class isSubclassOf:common) ifTrue:[
+	    (class isSubclassOf:common) ifTrue:[
-"keep common"
+		"keep common"
-] ifFalse:[
+	    ] ifFalse:[
-(common isSubclassOf:class) ifTrue:[
+		(common isSubclassOf:class) ifTrue:[
-common := class
+		    common := class
-] ifFalse:[
+		] ifFalse:[
-common := common commonSuperclass:class.
+		    common := common commonSuperclass:class.
 "/                    "walk up, checking"
 "/                    found := false.
 "/
 "/                    common allSuperclassesDo:[:sup |
 "/                                common := sup.
 "/                                found := true.
 "/                            ]
 "/                        ].
 "/                    ].
-]
+		]
-].
+	    ].
-].
+	].
-(common isNil or:[common == Object]) ifTrue:[^ common].
+	(common isNil or:[common == Object]) ifTrue:[^ common].
 ].
 ^ common
 "
 Class commonSuperclassOf:#(Array OrderedCollection Set)
 definitionSelectorFirstParts
 "return a collection of partial class-definition selectors"
 ^ #( #'subclass:'
-#'variableSubclass:'
+	 #'variableSubclass:'
-#'variableByteSubclass:'
+	 #'variableByteSubclass:'
-#'variableWordSubclass:'
+	 #'variableWordSubclass:'
-#'variableLongSubclass:'
+	 #'variableLongSubclass:'
-#'variableSignedWordSubclass:'
+	 #'variableSignedWordSubclass:'
-#'variableSignedLongSubclass:'
+	 #'variableSignedLongSubclass:'
-#'variableLongLongSubclass:'
+	 #'variableLongLongSubclass:'
-#'variableSignedLongLongSubclass:'
+	 #'variableSignedLongLongSubclass:'
-#'variableFloatSubclass:'
+	 #'variableFloatSubclass:'
-#'variableDoubleSubclass:'
+	 #'variableDoubleSubclass:'
 )
 !
 definitionSelectors
 "return a collection class-definition selectors"
 ^ #(
-#'subclass:instanceVariableNames:classVariableNames:poolDictionaries:category:'
+	 #'subclass:instanceVariableNames:classVariableNames:poolDictionaries:category:'
-#'variableSubclass:instanceVariableNames:classVariableNames:poolDictionaries:category:'
+	 #'variableSubclass:instanceVariableNames:classVariableNames:poolDictionaries:category:'
-#'variableByteSubclass:instanceVariableNames:classVariableNames:poolDictionaries:category:'
+	 #'variableByteSubclass:instanceVariableNames:classVariableNames:poolDictionaries:category:'
-#'variableWordSubclass:instanceVariableNames:classVariableNames:poolDictionaries:category:'
+	 #'variableWordSubclass:instanceVariableNames:classVariableNames:poolDictionaries:category:'
-#'variableLongSubclass:instanceVariableNames:classVariableNames:poolDictionaries:category:'
+	 #'variableLongSubclass:instanceVariableNames:classVariableNames:poolDictionaries:category:'
-#'variableSignedWordSubclass:instanceVariableNames:classVariableNames:poolDictionaries:category:'
+	 #'variableSignedWordSubclass:instanceVariableNames:classVariableNames:poolDictionaries:category:'
-#'variableSignedLongSubclass:instanceVariableNames:classVariableNames:poolDictionaries:category:'
+	 #'variableSignedLongSubclass:instanceVariableNames:classVariableNames:poolDictionaries:category:'
-#'variableLongLongSubclass:instanceVariableNames:classVariableNames:poolDictionaries:category:'
+	 #'variableLongLongSubclass:instanceVariableNames:classVariableNames:poolDictionaries:category:'
-#'variableSignedLongLongSubclass:instanceVariableNames:classVariableNames:poolDictionaries:category:'
+	 #'variableSignedLongLongSubclass:instanceVariableNames:classVariableNames:poolDictionaries:category:'
-#'variableFloatSubclass:instanceVariableNames:classVariableNames:poolDictionaries:category:'
+	 #'variableFloatSubclass:instanceVariableNames:classVariableNames:poolDictionaries:category:'
-#'variableDoubleSubclass:instanceVariableNames:classVariableNames:poolDictionaries:category:'
+	 #'variableDoubleSubclass:instanceVariableNames:classVariableNames:poolDictionaries:category:'
-"/ ST/X private subclasses
+	"/ ST/X private subclasses
-#'subclass:instanceVariableNames:classVariableNames:poolDictionaries:privateIn:'
+	 #'subclass:instanceVariableNames:classVariableNames:poolDictionaries:privateIn:'
-#'variableSubclass:instanceVariableNames:classVariableNames:poolDictionaries:privateIn:'
+	 #'variableSubclass:instanceVariableNames:classVariableNames:poolDictionaries:privateIn:'
-#'variableByteSubclass:instanceVariableNames:classVariableNames:poolDictionaries:privateIn:'
+	 #'variableByteSubclass:instanceVariableNames:classVariableNames:poolDictionaries:privateIn:'
-#'variableWordSubclass:instanceVariableNames:classVariableNames:poolDictionaries:privateIn:'
+	 #'variableWordSubclass:instanceVariableNames:classVariableNames:poolDictionaries:privateIn:'
-#'variableLongSubclass:instanceVariableNames:classVariableNames:poolDictionaries:privateIn:'
+	 #'variableLongSubclass:instanceVariableNames:classVariableNames:poolDictionaries:privateIn:'
-#'variableSignedWordSubclass:instanceVariableNames:classVariableNames:poolDictionaries:privateIn:'
+	 #'variableSignedWordSubclass:instanceVariableNames:classVariableNames:poolDictionaries:privateIn:'
-#'variableSignedLongSubclass:instanceVariableNames:classVariableNames:poolDictionaries:privateIn:'
+	 #'variableSignedLongSubclass:instanceVariableNames:classVariableNames:poolDictionaries:privateIn:'
-#'variableLongLongSubclass:instanceVariableNames:classVariableNames:poolDictionaries:privateIn:'
+	 #'variableLongLongSubclass:instanceVariableNames:classVariableNames:poolDictionaries:privateIn:'
-#'variableSignedLongLongSubclass:instanceVariableNames:classVariableNames:poolDictionaries:privateIn:'
+	 #'variableSignedLongLongSubclass:instanceVariableNames:classVariableNames:poolDictionaries:privateIn:'
-#'variableFloatSubclass:instanceVariableNames:classVariableNames:poolDictionaries:privateIn:'
+	 #'variableFloatSubclass:instanceVariableNames:classVariableNames:poolDictionaries:privateIn:'
-#'variableDoubleSubclass:instanceVariableNames:classVariableNames:poolDictionaries:privateIn:'
+	 #'variableDoubleSubclass:instanceVariableNames:classVariableNames:poolDictionaries:privateIn:'
-"/ ST/V subclass messages
+	"/ ST/V subclass messages
-#'subclass:instanceVariableNames:classVariableNames:poolDictionaries:'
+	 #'subclass:instanceVariableNames:classVariableNames:poolDictionaries:'
-#'variableByteSubclass:classVariableNames:poolDictionaries:'
+	 #'variableByteSubclass:classVariableNames:poolDictionaries:'
-#'variableSubclass:instanceVariableNames:classVariableNames:poolDictionaries:'
+	 #'variableSubclass:instanceVariableNames:classVariableNames:poolDictionaries:'
-"/ Dolphin
+	"/ Dolphin
-#'subclass:instanceVariableNames:classVariableNames:poolDictionaries:classInstanceVariableNames:'
+	 #'subclass:instanceVariableNames:classVariableNames:poolDictionaries:classInstanceVariableNames:'
 )
 !
 isBuiltInClass
 "return true if this class is known by the run-time-system.
 selectorsWithArgs:numberOfArgs
 "Return all selectors defined in this class that take this number of arguments."
 ^ self selectors
-select:[:sel | sel numArgs == numberOfArgs]
+	select:[:sel | sel numArgs == numberOfArgs]
 "
 SmallInteger selectorsWithArgs:0
 SmallInteger selectorsWithArgs:2
 SmallInteger selectorsWithArgs:3
 1st argument to the methodDictionary. Flushes all caches."
 |oldMethod ns selector |
 (newSelector isMemberOf:Symbol) ifFalse:[
-self error:'invalid selector'.
+	self error:'invalid selector'.
 ].
 ns := newMethod nameSpace.
 selector := (ns isNil or:[ns == self programmingLanguage])
-ifTrue:[newSelector]
+		    ifTrue:[newSelector]
-ifFalse:[(':' , ns name , '::' , newSelector) asSymbol].
+		    ifFalse:[(':' , ns name , '::' , newSelector) asSymbol].
 oldMethod := self compiledMethodAt:selector.
 oldMethod notNil ifTrue:[
-newMethod restricted:(oldMethod isRestricted).
+	newMethod restricted:(oldMethod isRestricted).
-newMethod setPrivacy:(oldMethod privacy) flushCaches:false.
+	newMethod setPrivacy:(oldMethod privacy) flushCaches:false.
 ].
 (self primAddSelector:selector withMethod:newMethod) ifFalse:[^ false].
 selector isNameSpaceSelector ifTrue:
 data for myself ... (actually, in any case all that needs
 to be flushed is info for myself and all of my subclasses)
 "
 "
 problem: this is slower; since looking for all subclasses is (currently)
-a bit slow :-(
+	     a bit slow :-(
-We need the hasSubclasses-info bit in Behavior; now
+	     We need the hasSubclasses-info bit in Behavior; now
 self withAllSubclassesDo:[:aClass |
-ObjectMemory flushInlineCachesFor:aClass withArgs:nargs.
+	ObjectMemory flushInlineCachesFor:aClass withArgs:nargs.
-ObjectMemory flushMethodCacheFor:aClass
+	ObjectMemory flushMethodCacheFor:aClass
 ].
 "
 "/
 "/ pass the selector AND the old method as changeArg
 from the methodDictionary"
 |dict newDict|
 (Smalltalk
-changeRequest:#methodInClassRemoved
+	changeRequest:#methodInClassRemoved
-with:(Array with:self with:aSelector)) ifFalse:[
+	with:(Array with:self with:aSelector)
-^ false
+) ifFalse:[
+	^ false
 ].
 dict := self methodDictionary.
 newDict := dict removeKeyAndCompress:aSelector.
 newDict isNil ifTrue:[
 "return the lookupObject (Jan's MetaObjectProtocol support) or nil.
 If non-nil, no lookup is performed by the VM, instead the lookupObject
 has to provide a method object for message sends."
 | behavior lookup |
+Lookup isNil ifTrue:[^ nil].
 behavior := self.
-[ behavior notNil ] whileTrue:
+[ behavior notNil ] whileTrue:[
-[lookup := behavior getLookupObject.
+	lookup := behavior getLookupObject.
-lookup ifNotNil: [^lookup].
+	lookup notNil ifTrue: [^ lookup].
-behavior := behavior superclass].
+	behavior := behavior superclass
+].
-^Lookup builtin.
+^ Lookup builtin.
 "Modified: / 26-04-2010 / 21:05:56 / Jan Vrany <jan.vrany@fit.cvut.cz>"
 !
 lookupObject: anObject
 anObject isNil ifTrue:[^self setLookupObject: anObject].
 (anObject respondsTo: #lookupMethodForSelector:directedTo:for:withArguments:from:)
-ifFalse:
+ifFalse:[
-[self error:'Lookup object does not respond to #lookupMethodForSelector:directedTo:for:withArguments:from:'].
+	self error:'Lookup object does not respond to #lookupMethodForSelector:directedTo:for:withArguments:from:'
-(anObject respondsTo:#superLookupObject:)
+].
-ifTrue:
+(anObject respondsTo:#superLookupObject:)
-[anObject superLookupObject: self lookupObject].
+ifTrue:[
+	anObject superLookupObject: self lookupObject
+].
 self setLookupObject: anObject.
 "Created: / 26-04-2010 / 13:35:19 / Jan Vrany <jan.vrany@fit.cvut.cz>"
 "Modified: / 26-04-2010 / 21:05:39 / Jan Vrany <jan.vrany@fit.cvut.cz>"
 !
 methodDictionary
 "return the receivers method dictionary."
 methodDictionary:dict
 "set the receivers method dictionary and flush inline caches."
 dict isNil ifTrue:[
-self error:'attempt to set methodDictionary to nil.' mayProceed:true.
+	self error:'attempt to set methodDictionary to nil.' mayProceed:true.
-^ self
+	^ self
 ].
 self setMethodDictionary:dict.
 ObjectMemory flushCaches.
 "Created: 5.6.1996 / 11:29:36 / stefan"
 (should we return a Set ?)"
 |md|
 (md := self methodDictionary) isNil ifTrue:[
-'oops - nil methodDictionary' errorPrintCR.
+	'oops - nil methodDictionary' errorPrintCR.
-^ #()
+	^ #()
 ].
 ^ md keys
 "Modified: 7.6.1996 / 15:33:18 / stefan"
 "Modified: 12.11.1996 / 11:31:51 / cg"
 ^ self class compilerClass.
 !
 dllPath
 "if a class contains ExternalFunctions,
 return a collection of pathNames where to find the DLLs
 containing the external functions.
 Do not code absolute path names here - keep them in the system settings.
 Use this if the DLL location is kept in some registry entry."
 "compile code, aString for this class; on any error, notify
 requestor, anObject with the error reason.
 Returns the new method or nil (on failure)."
 ^ self compilerClass
-compile:code
+	compile:code
-forClass:self
+	forClass:self
-notifying:requestor
+	notifying:requestor
 "Modified: 13.12.1995 / 11:02:40 / cg"
 "Created: 1.4.1997 / 23:43:43 / stefan"
 ! !
 |newInst indexed|
 indexed := false.
 aPrototype class isVariable ifTrue:[
-self isVariable ifTrue:[
+	self isVariable ifTrue:[
-indexed := true.
+	    indexed := true.
-].
+	].
-"otherwise, these are lost ..."
+	"otherwise, these are lost ..."
 ].
 indexed ifTrue:[
-newInst := self basicNew:aPrototype basicSize
+	newInst := self basicNew:aPrototype basicSize
 ] ifFalse:[
-newInst := self basicNew
+	newInst := self basicNew
 ].
 newInst cloneInstanceVariablesFrom:aPrototype.
 ^ newInst
 "
 Class withoutUpdatingChangesDo:[
-Point subclass:#Point3D
+	 Point subclass:#Point3D
-instanceVariableNames:'z'
+	   instanceVariableNames:'z'
-classVariableNames:''
+	   classVariableNames:''
-poolDictionaries:''
+	   poolDictionaries:''
-category:'testing'.
+	   category:'testing'.
-(Point3D cloneFrom:1@2) inspect.
+	 (Point3D cloneFrom:1@2) inspect.
 ]
 "
 "
 Class withoutUpdatingChangesDo:[
-Point variableSubclass:#Point3D
+	 Point variableSubclass:#Point3D
-instanceVariableNames:'z'
+	   instanceVariableNames:'z'
-classVariableNames:''
+	   classVariableNames:''
-poolDictionaries:''
+	   poolDictionaries:''
-category:'testing'.
+	   category:'testing'.
-(Point3D cloneFrom:#(1 2 3)) inspect.
+	 (Point3D cloneFrom:#(1 2 3)) inspect.
 ]
 "
 "
 |someObject|
 Class withoutUpdatingChangesDo:[
-Object subclass:#TestClass1
+	 Object subclass:#TestClass1
-instanceVariableNames:'foo bar'
+	   instanceVariableNames:'foo bar'
-classVariableNames:''
+	   classVariableNames:''
-poolDictionaries:''
+	   poolDictionaries:''
-category:'testing'.
+	   category:'testing'.
-someObject := TestClass1 new.
+	 someObject := TestClass1 new.
-someObject instVarAt:1 put:'foo'; instVarAt:2 put:'bar'.
+	 someObject instVarAt:1 put:'foo'; instVarAt:2 put:'bar'.
-Object subclass:#TestClass2
+	 Object subclass:#TestClass2
-instanceVariableNames:'bar foo'
+	   instanceVariableNames:'bar foo'
-classVariableNames:''
+	   classVariableNames:''
-poolDictionaries:''
+	   poolDictionaries:''
-category:'testing'.
+	   category:'testing'.
-(TestClass2 cloneFrom:someObject) inspect.
+	 (TestClass2 cloneFrom:someObject) inspect.
 ]
 "
 !
 deepCopyUsing:aDictionary postCopySelector:postCopySelector
 allInstancesDo:aBlock
 "evaluate aBlock for all of my instances"
 ObjectMemory allInstancesOf:self do:[:anObject |
-aBlock value:anObject
+	aBlock value:anObject
 ]
 "
 StandardSystemView allInstancesDo:[:v | Transcript showCR:(v name)]
 "
 |owner|
 owner := self owningClass.
 [owner notNil] whileTrue:[
-aBlock value:owner.
+	aBlock value:owner.
-owner := owner owningClass.
+	owner := owner owningClass.
 ].
 "
 Method::MethodWhoInfo allOwningclassesDo:[:c | Transcript showCR:(c name)]
 "
 allSubInstancesDo:aBlock
 "evaluate aBlock for all of my instances and all instances of subclasses"
 ObjectMemory allObjectsDo:[:anObject |
-(anObject isKindOf:self) ifTrue:[
+	(anObject isKindOf:self) ifTrue:[
-aBlock value:anObject
+	    aBlock value:anObject
-]
+	]
 ]
 "
 StandardSystemView allSubInstancesDo:[:v | Transcript showCR:(v name)]
 "
 allSubclassesDo:aBlock
 "evaluate aBlock for all of my subclasses.
 There is no specific order, in which the entries are enumerated.
 Warning:
-This will only enumerate globally known classes - for anonymous
+	This will only enumerate globally known classes - for anonymous
-behaviors, you have to walk over all instances of Behavior."
+	behaviors, you have to walk over all instances of Behavior."
 self allSubclassesInOrderDo:aBlock
 "/    self isMeta ifTrue:[
 "/        "/ metaclasses are not found via Smalltalk allClassesDo:
 allSubclassesInOrderDo:aBlock
 "evaluate aBlock for all of my subclasses.
 There is no specific order, in which the entries are enumerated.
 Warning:
-This will only enumerate globally known classes - for anonymous
+	This will only enumerate globally known classes - for anonymous
-behaviors, you have to walk over all instances of Behavior."
+	behaviors, you have to walk over all instances of Behavior."
 |meta toDo cls|
 meta := self isMeta.
 toDo := OrderedCollection new.
 toDo addAll:self theNonMetaclass subclasses.
 [toDo notEmpty] whileTrue:[
-cls := toDo removeFirst.
+	cls := toDo removeFirst.
-toDo addAll:cls subclasses.
+	toDo addAll:cls subclasses.
-meta ifTrue:[
+	meta ifTrue:[
-aBlock value:cls class.
+	    aBlock value:cls class.
-] ifFalse:[
+	] ifFalse:[
-aBlock value:cls.
+	    aBlock value:cls.
-]
+	]
 ].
 "/    self isMeta ifTrue:[
 "/        "/ metaclasses are not found via Smalltalk allClassesDo:
 "/        "/ here, walk over classes and enumerate corresponding metas.
 |theClass|
 theClass := self superclass.
 [theClass notNil] whileTrue:[
-aBlock value:theClass.
+	aBlock value:theClass.
-theClass := theClass superclass
+	theClass := theClass superclass
 ]
 "
 String allSuperclassesDo:[:c | Transcript showCR:(c name)]
 "
 This will only enumerate globally known classes - for anonymous
 behaviors, you have to walk over all instances of Behavior."
 "Do it the hard way. Subclasses redefine this"
 Smalltalk allClassesDo:[:aClass |
-(aClass superclass == self) ifTrue:[
+	(aClass superclass == self) ifTrue:[
-aBlock value:aClass
+	    aBlock value:aClass
-]
+	]
 ]
 !
 whichClassSatisfies: aBlock
 "return the first class along the superclass-chain, which satisfies aBlock.
 |cls|
 cls := self.
 [cls notNil] whileTrue:[
-(aBlock value: cls) ifTrue: [^ cls].
+	(aBlock value: cls) ifTrue: [^ cls].
-cls := cls superclass.
+	cls := cls superclass.
 ].
 ^ nil
 "
 SimpleView whichClassSatisfies:[:cls | cls instanceVariableNames includes:'gc']
 withAllSubclassesDo:aBlock
 "evaluate aBlock for mySelf and all of my subclasses.
 There is no specific order, in which the entries are enumerated.
 Warning:
-This will only enumerate globally known classes - for anonymous
+	This will only enumerate globally known classes - for anonymous
-behaviors, you have to walk over all instances of Behavior."
+	behaviors, you have to walk over all instances of Behavior."
 aBlock value:self.
 self allSubclassesDo:aBlock
 "
 |theSuperClass|
 aBlock value:self.
 theSuperClass := self superclass.
 [theSuperClass notNil] whileTrue:[
-aBlock value:theSuperClass.
+	aBlock value:theSuperClass.
-theSuperClass := theSuperClass superclass
+	theSuperClass := theSuperClass superclass
 ].
 "
 String withAllSuperclassesDo:[:each| Transcript showCR:each]
 "
 This is sent to a class after it
 has been loaded into the system.
 Statically compiled classes are initialized by the VM"
 (self class includesSelector:#initialize) ifTrue:[
-self initialize.
+	self initialize.
 ].
 self privateClassesSorted do:[:aPrivateClass |
-aPrivateClass initializeWithAllPrivateClasses.
+	aPrivateClass initializeWithAllPrivateClasses.
 ].
 "Created: / 13.5.1998 / 23:33:16 / cg"
 "Modified: / 13.5.1998 / 23:34:06 / cg"
 !
 * dont argue about the goto and the arrangement below - it saves
 * an extra nil-compare and branch in the common case ...
 * (i.e. if no GC is needed, we fall through without a branch)
 */
 if (nextPtr < __newEndPtr) {
-_objPtr(newobj)->o_size = instsize;
+	_objPtr(newobj)->o_size = instsize;
-/* o_allFlags(newobj) = 0;              */
+	/* o_allFlags(newobj) = 0;              */
-/* _objPtr(newobj)->o_space = __newSpace; */
+	/* _objPtr(newobj)->o_space = __newSpace; */
-o_setAllFlags(newobj, __newSpace);
+	o_setAllFlags(newobj, __newSpace);
 #ifdef __HAS_ALIGN4__
-/*
+	/*
-* if the alignment is 4, we are already sat,
+	 * if the alignment is 4, we are already sat,
-* since a non-indexed object always has a word-aligned size.
+	 * since a non-indexed object always has a word-aligned size.
-*/
+	 */
-__newNextPtr = nextPtr;
+	__newNextPtr = nextPtr;
 #else
-if (instsize & (__ALIGN__-1)) {
+	if (instsize & (__ALIGN__-1)) {
-__newNextPtr = (char *)newobj + (instsize & ~(__ALIGN__-1)) + __ALIGN__;
+	    __newNextPtr = (char *)newobj + (instsize & ~(__ALIGN__-1)) + __ALIGN__;
-} else {
+	} else {
-__newNextPtr = nextPtr;
+	    __newNextPtr = nextPtr;
-}
+	}
 #endif
 ok:
-__InstPtr(newobj)->o_class = self;
+	__InstPtr(newobj)->o_class = self;
-__qSTORE(newobj, self);
+	__qSTORE(newobj, self);
-if (nInstVars) {
+	if (nInstVars) {
 #if defined(memset4) && defined(FAST_OBJECT_MEMSET4) || defined(FAST_MEMSET4)
-memset4(__InstPtr(newobj)->i_instvars, nil, nInstVars);
+	    memset4(__InstPtr(newobj)->i_instvars, nil, nInstVars);
 #else
-REGISTER OBJ *op;
+	    REGISTER OBJ *op;
-op = __InstPtr(newobj)->i_instvars;
+	    op = __InstPtr(newobj)->i_instvars;
-/*
+	    /*
-* knowing that nil is 0
+	     * knowing that nil is 0
-*/
+	     */
 # if defined(FAST_OBJECT_MEMSET_DOUBLES_UNROLLED)
-if (nInstVars > 8) {
+	    if (nInstVars > 8) {
-*op++ = nil;    /* for alignment */
+		*op++ = nil;    /* for alignment */
-nInstVars--;
+		nInstVars--;
-while (nInstVars >= 8) {
+		while (nInstVars >= 8) {
-*(double *)op = 0.0;
+		    *(double *)op = 0.0;
-((double *)op)[1] = 0.0;
+		    ((double *)op)[1] = 0.0;
-((double *)op)[2] = 0.0;
+		    ((double *)op)[2] = 0.0;
-((double *)op)[3] = 0.0;
+		    ((double *)op)[3] = 0.0;
-op += 8;
+		    op += 8;
-nInstVars -= 8;
+		    nInstVars -= 8;
-}
+		}
-}
+	    }
-while (nInstVars != 0) {
+	    while (nInstVars != 0) {
-*op++ = 0;
+		*op++ = 0;
-nInstVars--;
+		nInstVars--;
-}
+	    }
 # else
 #  if defined(FAST_OBJECT_MEMSET_LONGLONG_UNROLLED)
-if (nInstVars > 8) {
+	    if (nInstVars > 8) {
-*op++ = nil;    /* for alignment */
+		*op++ = nil;    /* for alignment */
-nInstVars--;
+		nInstVars--;
-while (nInstVars >= 8) {
+		while (nInstVars >= 8) {
-*(long long *)op = 0;
+		    *(long long *)op = 0;
-((long long *)op)[1] = 0;
+		    ((long long *)op)[1] = 0;
-((long long *)op)[2] = 0;
+		    ((long long *)op)[2] = 0;
-((long long *)op)[3] = 0;
+		    ((long long *)op)[3] = 0;
-op += 8;
+		    op += 8;
-nInstVars -= 8;
+		    nInstVars -= 8;
-}
+		}
-}
+	    }
-while (nInstVars != 0) {
+	    while (nInstVars != 0) {
-*op++ = 0;
+		*op++ = 0;
-nInstVars--;
+		nInstVars--;
-}
+	    }
 #  else
 #   if defined(FAST_OBJECT_MEMSET_WORDS_UNROLLED)
-while (nInstVars >= 8) {
+	    while (nInstVars >= 8) {
-*op = nil;
+		*op = nil;
-*(op+1) = nil;
+		*(op+1) = nil;
-*(op+2) = nil;
+		*(op+2) = nil;
-*(op+3) = nil;
+		*(op+3) = nil;
-*(op+4) = nil;
+		*(op+4) = nil;
-*(op+5) = nil;
+		*(op+5) = nil;
-*(op+6) = nil;
+		*(op+6) = nil;
-*(op+7) = nil;
+		*(op+7) = nil;
-op += 8;
+		op += 8;
-nInstVars -= 8;
+		nInstVars -= 8;
-}
+	    }
-while (nInstVars != 0) {
+	    while (nInstVars != 0) {
-*op++ = nil;
+		*op++ = nil;
-nInstVars--;
+		nInstVars--;
-}
+	    }
 #   else
 #    if defined(FAST_MEMSET)
-memset(__InstPtr(newobj)->i_instvars, 0, instsize-OHDR_SIZE);
+	    memset(__InstPtr(newobj)->i_instvars, 0, instsize-OHDR_SIZE);
 #    else
-do {
+	    do {
-*op++ = nil;
+		*op++ = nil;
-nInstVars--;
+		nInstVars--;
-} while (nInstVars != 0);
+	    } while (nInstVars != 0);
 #    endif
 #   endif
 #  endif
 # endif
 #endif
-}
+	}
-RETURN ( newobj );
+	RETURN ( newobj );
 }
 /*
 * the slow case - a GC will occur
 */
 REGISTER OBJ *op;
 float *fp;
 double *dp;
 if (__isSmallInteger(anInteger)) {
-nindexedinstvars = __intVal(anInteger);
+	nindexedinstvars = __intVal(anInteger);
-if (nindexedinstvars >= 0) {
+	if (nindexedinstvars >= 0) {
-nInstVars = __intVal(__INST(instSize));
+	    nInstVars = __intVal(__INST(instSize));
-flags = __intVal(__INST(flags)) & ARRAYMASK;
+	    flags = __intVal(__INST(flags)) & ARRAYMASK;
-switch (flags) {
+	    switch (flags) {
-case BYTEARRAY:
+		case BYTEARRAY:
-instsize = OHDR_SIZE + nindexedinstvars;
+		    instsize = OHDR_SIZE + nindexedinstvars;
-if (nInstVars == 0) {
+		    if (nInstVars == 0) {
-if (__CanDoQuickNew(instsize)) {        /* OBJECT ALLOCATION */
+			if (__CanDoQuickNew(instsize)) {        /* OBJECT ALLOCATION */
-/*
+			    /*
-* the most common case
+			     * the most common case
-*/
+			     */
-__qCheckedNew(newobj, instsize);
+			    __qCheckedNew(newobj, instsize);
-__InstPtr(newobj)->o_class = self;
+			    __InstPtr(newobj)->o_class = self;
-__qSTORE(newobj, self);
+			    __qSTORE(newobj, self);
 #if defined(memset4) && defined(FAST_ARRAY_MEMSET4) || defined(FAST_MEMSET4)
-nInstVars = nindexedinstvars >> 2;
+			    nInstVars = nindexedinstvars >> 2;
-if (nindexedinstvars & 3) nInstVars++;
+			    if (nindexedinstvars & 3) nInstVars++;
-memset4(__InstPtr(newobj)->i_instvars, 0, nInstVars);
+			    memset4(__InstPtr(newobj)->i_instvars, 0, nInstVars);
 #else
 # if defined(FAST_ARRAY_MEMSET)
-memset(__InstPtr(newobj)->i_instvars, 0, nindexedinstvars);
+			    memset(__InstPtr(newobj)->i_instvars, 0, nindexedinstvars);
 # else
-cp = (char *)__InstPtr(newobj)->i_instvars;
+			    cp = (char *)__InstPtr(newobj)->i_instvars;
-while (nindexedinstvars >= sizeof(long)) {
+			    while (nindexedinstvars >= sizeof(long)) {
-*(long *)cp = 0;
+				*(long *)cp = 0;
-cp += sizeof(long);
+				cp += sizeof(long);
-nindexedinstvars -= sizeof(long);
+				nindexedinstvars -= sizeof(long);
-}
+			    }
-while (nindexedinstvars--)
+			    while (nindexedinstvars--)
-*cp++ = '\0';
+				*cp++ = '\0';
 # endif
 #endif
-RETURN ( newobj );
+			    RETURN ( newobj );
-}
+			}
-} else {
+		    } else {
-instsize += __OBJS2BYTES__(nInstVars);
+			instsize += __OBJS2BYTES__(nInstVars);
-}
+		    }
-__PROTECT_CONTEXT__
+		    __PROTECT_CONTEXT__
-__qNew(newobj, instsize);   /* OBJECT ALLOCATION */
+		    __qNew(newobj, instsize);   /* OBJECT ALLOCATION */
-__UNPROTECT_CONTEXT__
+		    __UNPROTECT_CONTEXT__
-if (newobj == nil) {
+		    if (newobj == nil) {
-break;
+			break;
-}
+		    }
-__InstPtr(newobj)->o_class = self;
+		    __InstPtr(newobj)->o_class = self;
-__qSTORE(newobj, self);
+		    __qSTORE(newobj, self);
 #if defined(memset4) && defined(FAST_ARRAY_MEMSET4) || defined(FAST_MEMSET4)
-nInstVars = (instsize-OHDR_SIZE) >> 2;
+		    nInstVars = (instsize-OHDR_SIZE) >> 2;
-if (instsize & 3) nInstVars++;
+		    if (instsize & 3) nInstVars++;
-memset4(__InstPtr(newobj)->i_instvars, 0, nInstVars);
+		    memset4(__InstPtr(newobj)->i_instvars, 0, nInstVars);
 #else
 # if defined(FAST_ARRAY_MEMSET)
-/*
+		    /*
-* knowing that nil is 0
+		     * knowing that nil is 0
-*/
+		     */
-memset(__InstPtr(newobj)->i_instvars, 0, instsize-OHDR_SIZE);
+		    memset(__InstPtr(newobj)->i_instvars, 0, instsize-OHDR_SIZE);
 # else
-op = __InstPtr(newobj)->i_instvars;
+		    op = __InstPtr(newobj)->i_instvars;
-while (nInstVars--)
+		    while (nInstVars--)
-*op++ = nil;
+			*op++ = nil;
-cp = (char *)op;
+		    cp = (char *)op;
-while (nindexedinstvars >= sizeof(long)) {
+		    while (nindexedinstvars >= sizeof(long)) {
-*(long *)cp = 0;
+			*(long *)cp = 0;
-cp += sizeof(long);
+			cp += sizeof(long);
-nindexedinstvars -= sizeof(long);
+			nindexedinstvars -= sizeof(long);
-}
+		    }
-while (nindexedinstvars--)
+		    while (nindexedinstvars--)
-*cp++ = '\0';
+			*cp++ = '\0';
 # endif
 #endif
-RETURN ( newobj );
+		    RETURN ( newobj );
-break;
+		    break;
-case WORDARRAY:
+		case WORDARRAY:
-case SWORDARRAY:
+		case SWORDARRAY:
-instsize = OHDR_SIZE +
+		    instsize = OHDR_SIZE +
-__OBJS2BYTES__(nInstVars) +
+			       __OBJS2BYTES__(nInstVars) +
-nindexedinstvars * 2;
+			       nindexedinstvars * 2;
-__PROTECT_CONTEXT__
+		    __PROTECT_CONTEXT__
-__qNew(newobj, instsize);   /* OBJECT ALLOCATION */
+		    __qNew(newobj, instsize);   /* OBJECT ALLOCATION */
-__UNPROTECT_CONTEXT__
+		    __UNPROTECT_CONTEXT__
-if (newobj == nil) {
+		    if (newobj == nil) {
-break;
+			break;
-}
+		    }
-__InstPtr(newobj)->o_class = self;
+		    __InstPtr(newobj)->o_class = self;
-__qSTORE(newobj, self);
+		    __qSTORE(newobj, self);
 #if defined(FAST_ARRAY_MEMSET)
-/*
+		    /*
-* knowing that nil is 0
+		     * knowing that nil is 0
-*/
+		     */
-memset(__InstPtr(newobj)->i_instvars, 0, instsize - OHDR_SIZE);
+		    memset(__InstPtr(newobj)->i_instvars, 0, instsize - OHDR_SIZE);
 #else
-op = __InstPtr(newobj)->i_instvars;
+		    op = __InstPtr(newobj)->i_instvars;
-while (nInstVars--)
+		    while (nInstVars--)
-*op++ = nil;
+			*op++ = nil;
-sp = (short *)op;
+		    sp = (short *)op;
-while (nindexedinstvars--)
+		    while (nindexedinstvars--)
-*sp++ = 0;
+			*sp++ = 0;
 #endif
-RETURN ( newobj );
+		    RETURN ( newobj );
-break;
+		    break;
-case LONGARRAY:
+	       case LONGARRAY:
-case SLONGARRAY:
+	       case SLONGARRAY:
-instsize = OHDR_SIZE +
+		    instsize = OHDR_SIZE +
-__OBJS2BYTES__(nInstVars) +
+			       __OBJS2BYTES__(nInstVars) +
-nindexedinstvars * 4;
+			       nindexedinstvars * 4;
-__PROTECT_CONTEXT__
+		    __PROTECT_CONTEXT__
-__qAlignedNew(newobj, instsize);    /* OBJECT ALLOCATION */
+		    __qAlignedNew(newobj, instsize);    /* OBJECT ALLOCATION */
-__UNPROTECT_CONTEXT__
+		    __UNPROTECT_CONTEXT__
-if (newobj == nil) {
+		    if (newobj == nil) {
-break;
+			break;
-}
+		    }
-__InstPtr(newobj)->o_class = self;
+		    __InstPtr(newobj)->o_class = self;
-__qSTORE(newobj, self);
+		    __qSTORE(newobj, self);
 #if defined(memset4)
-/*
+		    /*
-* knowing that nil is 0
+		     * knowing that nil is 0
-*/
+		     */
-{
+		    {
-int n4 = nInstVars + nindexedinstvars;
+			int n4 = nInstVars + nindexedinstvars;
-memset4(__InstPtr(newobj)->i_instvars, 0, n4);
+			memset4(__InstPtr(newobj)->i_instvars, 0, n4);
-}
+		    }
 #else
 # if defined(FAST_ARRAY_MEMSET)
-/*
+		    /*
-* knowing that nil is 0
+		     * knowing that nil is 0
-*/
+		     */
-memset(__InstPtr(newobj)->i_instvars, 0, instsize - OHDR_SIZE);
+		    memset(__InstPtr(newobj)->i_instvars, 0, instsize - OHDR_SIZE);
 # else
-op = __InstPtr(newobj)->i_instvars;
+		    op = __InstPtr(newobj)->i_instvars;
-while (nInstVars--)
+		    while (nInstVars--)
-*op++ = nil;
+			*op++ = nil;
-lp = (long *)op;
+		    lp = (long *)op;
-while (nindexedinstvars--)
+		    while (nindexedinstvars--)
-*lp++ = 0;
+			*lp++ = 0;
 # endif
 #endif
-RETURN ( newobj );
+		    RETURN ( newobj );
-break;
+		    break;
-case LONGLONGARRAY:
+	       case LONGLONGARRAY:
-case SLONGLONGARRAY:
+	       case SLONGLONGARRAY:
-instsize = OHDR_SIZE + __OBJS2BYTES__(nInstVars);
+		    instsize = OHDR_SIZE + __OBJS2BYTES__(nInstVars);
 #ifdef __NEED_LONGLONG_ALIGN
-instsize = ((instsize-1) + __LONGLONG_ALIGN) & ~(__LONGLONG_ALIGN-1);
+		    instsize = ((instsize-1) + __LONGLONG_ALIGN) & ~(__LONGLONG_ALIGN-1);
 #endif
-instsize += nindexedinstvars * 8;
+		    instsize += nindexedinstvars * 8;
-__PROTECT_CONTEXT__
+		    __PROTECT_CONTEXT__
-__qAlignedNew(newobj, instsize);    /* OBJECT ALLOCATION */
+		    __qAlignedNew(newobj, instsize);    /* OBJECT ALLOCATION */
-__UNPROTECT_CONTEXT__
+		    __UNPROTECT_CONTEXT__
-if (newobj == nil) {
+		    if (newobj == nil) {
-break;
+			break;
-}
+		    }
-__InstPtr(newobj)->o_class = self;
+		    __InstPtr(newobj)->o_class = self;
-__qSTORE(newobj, self);
+		    __qSTORE(newobj, self);
 #if defined(memset4)
-{
+		    {
-int n4 = (instsize-OHDR_SIZE) / 4;
+			int n4 = (instsize-OHDR_SIZE) / 4;
-memset4(__InstPtr(newobj)->i_instvars, 0, n4);
+			memset4(__InstPtr(newobj)->i_instvars, 0, n4);
-}
+		    }
 #else
-memset(__InstPtr(newobj)->i_instvars, 0, instsize - OHDR_SIZE);
+		    memset(__InstPtr(newobj)->i_instvars, 0, instsize - OHDR_SIZE);
 #endif
-RETURN ( newobj );
+		    RETURN ( newobj );
-break;
+		    break;
-case FLOATARRAY:
+	       case FLOATARRAY:
-instsize = OHDR_SIZE + __OBJS2BYTES__(nInstVars);
+		    instsize = OHDR_SIZE + __OBJS2BYTES__(nInstVars);
-instsize += nindexedinstvars * sizeof(float);
+		    instsize += nindexedinstvars * sizeof(float);
-__PROTECT_CONTEXT__
+		    __PROTECT_CONTEXT__
-__qNew(newobj, instsize);   /* OBJECT ALLOCATION */
+		    __qNew(newobj, instsize);   /* OBJECT ALLOCATION */
-__UNPROTECT_CONTEXT__
+		    __UNPROTECT_CONTEXT__
-if (newobj == nil) {
+		    if (newobj == nil) {
-break;
+			break;
-}
+		    }
-__InstPtr(newobj)->o_class = self;
+		    __InstPtr(newobj)->o_class = self;
-__qSTORE(newobj, self);
+		    __qSTORE(newobj, self);
-op = __InstPtr(newobj)->i_instvars;
+		    op = __InstPtr(newobj)->i_instvars;
 #if defined(__FLOAT0_IS_INT0) /* knowin that float 0.0 is all-zeros */
 # if defined(memset4)
-{
+		    {
-int n4 = (instsize-OHDR_SIZE) / 4;
+			int n4 = (instsize-OHDR_SIZE) / 4;
-memset4(__InstPtr(newobj)->i_instvars, 0, n4);
+			memset4(__InstPtr(newobj)->i_instvars, 0, n4);
-}
+		    }
 # else
-memset(__InstPtr(newobj)->i_instvars, 0, instsize - OHDR_SIZE);
+		    memset(__InstPtr(newobj)->i_instvars, 0, instsize - OHDR_SIZE);
 # endif
 #else
-while (nInstVars--)
+		    while (nInstVars--)
-*op++ = nil;
+			*op++ = nil;
-fp = (float *)op;
+		    fp = (float *)op;
-while (nindexedinstvars--)
+		    while (nindexedinstvars--)
-*fp++ = 0.0;
+			*fp++ = 0.0;
 #endif
-RETURN ( newobj );
+		    RETURN ( newobj );
-break;
+		    break;
-case DOUBLEARRAY:
+	       case DOUBLEARRAY:
-instsize = OHDR_SIZE + __OBJS2BYTES__(nInstVars);
+		    instsize = OHDR_SIZE + __OBJS2BYTES__(nInstVars);
 #ifdef __NEED_DOUBLE_ALIGN
-instsize = ((instsize-1) + __DOUBLE_ALIGN) & ~(__DOUBLE_ALIGN-1);
+		    instsize = ((instsize-1) + __DOUBLE_ALIGN) & ~(__DOUBLE_ALIGN-1);
 #endif
-instsize += nindexedinstvars * sizeof(double);
+		    instsize += nindexedinstvars * sizeof(double);
-__PROTECT_CONTEXT__
+		    __PROTECT_CONTEXT__
-__qAlignedNew(newobj, instsize);    /* OBJECT ALLOCATION */
+		    __qAlignedNew(newobj, instsize);    /* OBJECT ALLOCATION */
-__UNPROTECT_CONTEXT__
+		    __UNPROTECT_CONTEXT__
-if (newobj == nil) {
+		    if (newobj == nil) {
-break;
+			break;
-}
+		    }
-__InstPtr(newobj)->o_class = self;
+		    __InstPtr(newobj)->o_class = self;
-__qSTORE(newobj, self);
+		    __qSTORE(newobj, self);
 #if defined(__DOUBLE0_IS_INT0) /* knowin that double 0.0 is all-zeros */
 # ifdef memset4
-{
+		    {
-int n4 = (instsize-OHDR_SIZE) / 4;
+			int n4 = (instsize-OHDR_SIZE) / 4;
-memset4(__InstPtr(newobj)->i_instvars, 0, n4);
+			memset4(__InstPtr(newobj)->i_instvars, 0, n4);
-}
+		    }
 # else
-memset(__InstPtr(newobj)->i_instvars, 0, instsize - OHDR_SIZE);
+		    memset(__InstPtr(newobj)->i_instvars, 0, instsize - OHDR_SIZE);
 # endif
 #else
-op = __InstPtr(newobj)->i_instvars;
+		    op = __InstPtr(newobj)->i_instvars;
-while (nInstVars--)
+		    while (nInstVars--)
-*op++ = nil;
+			*op++ = nil;
 # ifdef __NEED_DOUBLE_ALIGN
-/*
+		    /*
-* care for double alignment
+		     * care for double alignment
-* add filler.
+		     * add filler.
-*/
+		     */
-if ((INT)op & (__DOUBLE_ALIGN-1)) {
+		    if ((INT)op & (__DOUBLE_ALIGN-1)) {
-*op++ = nil;
+			*op++ = nil;
-}
+		    }
 # endif
-dp = (double *)op;
+		    dp = (double *)op;
-while (nindexedinstvars--)
+		    while (nindexedinstvars--)
-*dp++ = 0.0;
+			*dp++ = 0.0;
 #endif
-RETURN ( newobj );
+		    RETURN ( newobj );
-break;
+		    break;
-case WKPOINTERARRAY:
+		case WKPOINTERARRAY:
-case POINTERARRAY:
+		case POINTERARRAY:
-nInstVars += nindexedinstvars;
+		    nInstVars += nindexedinstvars;
-instsize = OHDR_SIZE + __OBJS2BYTES__(nInstVars);
+		    instsize = OHDR_SIZE + __OBJS2BYTES__(nInstVars);
-__PROTECT_CONTEXT__
+		    __PROTECT_CONTEXT__
-__qAlignedNew(newobj, instsize);    /* OBJECT ALLOCATION */
+		    __qAlignedNew(newobj, instsize);    /* OBJECT ALLOCATION */
-__UNPROTECT_CONTEXT__
+		    __UNPROTECT_CONTEXT__
-if (newobj == nil) {
+		    if (newobj == nil) {
-break;
+			break;
-}
+		    }
-__InstPtr(newobj)->o_class = self;
+		    __InstPtr(newobj)->o_class = self;
-__qSTORE(newobj, self);
+		    __qSTORE(newobj, self);
 #if defined(memset4) && defined(FAST_ARRAY_MEMSET4) || defined(FAST_MEMSET4)
-memset4(__InstPtr(newobj)->i_instvars, nil, nInstVars);
+		    memset4(__InstPtr(newobj)->i_instvars, nil, nInstVars);
 #else
-/*
+		    /*
-* knowing that nil is 0
+		     * knowing that nil is 0
-*/
+		     */
 # ifdef sparc
 #  define FAST_ARRAY_MEMSET_DOUBLES_UNROLLED
 # endif
 # if defined(FAST_ARRAY_MEMSET_DOUBLES_UNROLLED)
-op = __InstPtr(newobj)->i_instvars;
+		    op = __InstPtr(newobj)->i_instvars;
-if (nInstVars > 8) {
+		    if (nInstVars > 8) {
-*op++ = nil;    /* for alignment */
+			*op++ = nil;    /* for alignment */
-nInstVars--;
+			nInstVars--;
-while (nInstVars >= 8) {
+			while (nInstVars >= 8) {
-*(double *)op = 0.0;
+			    *(double *)op = 0.0;
-((double *)op)[1] = 0.0;
+			    ((double *)op)[1] = 0.0;
-((double *)op)[2] = 0.0;
+			    ((double *)op)[2] = 0.0;
-((double *)op)[3] = 0.0;
+			    ((double *)op)[3] = 0.0;
-op += 8;
+			    op += 8;
-nInstVars -= 8;
+			    nInstVars -= 8;
-}
+			}
-}
+		    }
-while (nInstVars) {
+		    while (nInstVars) {
-*op++ = 0;
+			*op++ = 0;
-nInstVars--;
+			nInstVars--;
-}
+		    }
 # else
 #  if defined(FAST_ARRAY_MEMSET_LONGLONG_UNROLLED)
-op = __InstPtr(newobj)->i_instvars;
+		    op = __InstPtr(newobj)->i_instvars;
-if (nInstVars > 8) {
+		    if (nInstVars > 8) {
-*op++ = nil;    /* for alignment */
+			*op++ = nil;    /* for alignment */
-nInstVars--;
+			nInstVars--;
-while (nInstVars >= 8) {
+			while (nInstVars >= 8) {
-*(long long *)op = 0;
+			    *(long long *)op = 0;
-((long long *)op)[1] = 0;
+			    ((long long *)op)[1] = 0;
-((long long *)op)[2] = 0;
+			    ((long long *)op)[2] = 0;
-((long long *)op)[3] = 0;
+			    ((long long *)op)[3] = 0;
-op += 8;
+			    op += 8;
-nInstVars -= 8;
+			    nInstVars -= 8;
-}
+			}
-}
+		    }
-while (nInstVars) {
+		    while (nInstVars) {
-*op++ = 0;
+			*op++ = 0;
-nInstVars--;
+			nInstVars--;
-}
+		    }
 #  else
 #   if defined(FAST_ARRAY_MEMSET)
-memset(__InstPtr(newobj)->i_instvars, 0, instsize - OHDR_SIZE);
+		    memset(__InstPtr(newobj)->i_instvars, 0, instsize - OHDR_SIZE);
 #   else
-op = __InstPtr(newobj)->i_instvars;
+		    op = __InstPtr(newobj)->i_instvars;
-while (nInstVars--)
+		    while (nInstVars--)
-*op++ = nil;
+			*op++ = nil;
 #   endif
 #  endif
 # endif
 #endif
-RETURN ( newobj );
+		    RETURN ( newobj );
-break;
+		    break;
-default:
+		default:
-/*
+		    /*
-* new:n for non-variable classes only allowed if
+		     * new:n for non-variable classes only allowed if
-* n == 0
+		     * n == 0
-*/
+		     */
-if (nindexedinstvars == 0) {
+		    if (nindexedinstvars == 0) {
-instsize = OHDR_SIZE + __OBJS2BYTES__(nInstVars);
+			instsize = OHDR_SIZE + __OBJS2BYTES__(nInstVars);
-__PROTECT_CONTEXT__
+			__PROTECT_CONTEXT__
-__qAlignedNew(newobj, instsize);        /* OBJECT ALLOCATION */
+			__qAlignedNew(newobj, instsize);        /* OBJECT ALLOCATION */
-__UNPROTECT_CONTEXT__
+			__UNPROTECT_CONTEXT__
-if (newobj == nil) {
+			if (newobj == nil) {
-break;
+			    break;
-}
+			}
-__InstPtr(newobj)->o_class = self;
+			__InstPtr(newobj)->o_class = self;
-__qSTORE(newobj, self);
+			__qSTORE(newobj, self);
-if (nInstVars) {
+			if (nInstVars) {
 #if defined(memset4) && defined(FAST_OBJECT_MEMSET4) || defined(FAST_MEMSET4)
-memset4(__InstPtr(newobj)->i_instvars, nil, nInstVars);
+			    memset4(__InstPtr(newobj)->i_instvars, nil, nInstVars);
 #else
 # if defined(FAST_MEMSET)
-/*
+			    /*
-* knowing that nil is 0
+			     * knowing that nil is 0
-*/
+			     */
-memset(__InstPtr(newobj)->i_instvars, 0, instsize - OHDR_SIZE);
+			    memset(__InstPtr(newobj)->i_instvars, 0, instsize - OHDR_SIZE);
 # else
-op = __InstPtr(newobj)->i_instvars;
+			    op = __InstPtr(newobj)->i_instvars;
-do {
+			    do {
-*op++ = nil;
+				*op++ = nil;
-} while (--nInstVars);
+			    } while (--nInstVars);
 # endif
 #endif
-}
+			}
-RETURN ( newobj );
+			RETURN ( newobj );
-}
+		    }
-break;
+		    break;
-}
+	    }
-}
+	}
 }
 %}.
 "
 arrive here if something went wrong ...
 figure out what it was
 "
 (anInteger isMemberOf:SmallInteger) ifFalse:[
-"
+	"
-the argument is either not an integer,
+	 the argument is either not an integer,
-or a LargeInteger (which means that its definitely too big)
+	 or a LargeInteger (which means that its definitely too big)
-"
+	"
-self error:'argument to new: must be Integer' mayProceed:true.
+	self error:'argument to new: must be Integer' mayProceed:true.
-^ nil
+	^ nil
 ].
 (anInteger < 0) ifTrue:[
-"
+	"
-the argument is negative,
+	 the argument is negative,
-"
+	"
-self error:'bad (negative) argument to new:'.
+	self error:'bad (negative) argument to new:'.
-^ nil
+	^ nil
 ].
 self isVariable ifFalse:[
-"
+	"
-this class does not have any indexed instance variables
+	 this class does not have any indexed instance variables
-"
+	"
-self error:'class has no indexed instvars - cannot create with new:'.
+	self error:'class has no indexed instvars - cannot create with new:'.
-^ nil
+	^ nil
 ].
 "
 memory allocation failed.
 When we arrive here, there was no memory, even after
 a garbage collect.
 ^ self new fromLiteralArrayEncoding:anArray.
 "
 Rectangle
-decodeFromLiteralArray:#(Rectangle 10 10 100 100)
+	decodeFromLiteralArray:#(Rectangle 10 10 100 100)
 "
 "Modified: / 28.1.1998 / 17:40:30 / cg"
 !
 |size|
 size := self sizeOfInst:anInteger.
 (ObjectMemory checkForFastNew:size) ifFalse:[
-"
+	"
-incrementally collect garbage
+	 incrementally collect garbage
-"
+	"
-ObjectMemory incrementalGC.
+	ObjectMemory incrementalGC.
 ].
 ^ self basicNew:anInteger
 !
 readFrom:aStream
 and return it.
 The read object must be a kind of myself if its not, an error is raised.
 This is the reverse operation to 'storeOn:'.
 WARNING: storeOn: does not handle circular references and multiple
-references to the same object.
+	      references to the same object.
-Use #storeBinary:/readBinaryFrom: for this."
+	      Use #storeBinary:/readBinaryFrom: for this."
 ^ self
-readFrom:aStream
+	readFrom:aStream
-onError:[ self conversionErrorSignal
+	onError:[ self conversionErrorSignal
-raiseErrorString:'conversion error for: ' , self name ]
+		    raiseErrorString:'conversion error for: ' , self name ]
 "
 |s|
 s := WriteStream on:String new.
 #(1 2 3 4) storeOn:s.
 To get any object, use 'Object readFrom:...',
 To get any number, use 'Number readFrom:...' and so on.
 This is the reverse operation to 'storeOn:'.
 WARNING: storeOn: does not handle circular references and multiple
-references to the same object.
+	      references to the same object.
-Use #storeBinary:/readBinaryFrom: for this."
+	      Use #storeBinary:/readBinaryFrom: for this."
 ^ [
-|newObject|
+	|newObject|
-newObject := self evaluatorClass evaluate:aStream ifFail:exceptionBlock.
+	newObject := self evaluatorClass evaluate:aStream ifFail:exceptionBlock.
-(newObject isKindOf:self) ifTrue:[newObject] ifFalse:[exceptionBlock value].
+	(newObject isKindOf:self) ifTrue:[newObject] ifFalse:[exceptionBlock value].
 ] on:Error do:exceptionBlock.
 "
 |s|
 s := WriteStream on:String new.
 #(1 2 3 4) storeOn:s.
 Transcript showCR:(
-Array readFrom:(ReadStream on:s contents) onError:'not an Array'
+	Array readFrom:(ReadStream on:s contents) onError:'not an Array'
 )
 "
 "
 |s|
 s := WriteStream on:String new.
 #[1 2 3 4] storeOn:s.
 Transcript showCR:(
-Array readFrom:(ReadStream on:s contents) onError:'not an Array'
+	 Array readFrom:(ReadStream on:s contents) onError:'not an Array'
 )
 "
 "
 Object readFrom:'illegal' onError:['bla']
 String readFrom:'illegal' onError:'bla'
 readable string here.
 See comments in Behavior>>readFromString:onError:,
 Behavior>>readFrom: and Behavior>>readFrom:onError:"
 ^ self
-readFromString:aString
+	readFromString:aString
-onError:[ self conversionErrorSignal
+	onError:[ self conversionErrorSignal
-raiseErrorString:'expected: ' , self name ]
+		    raiseErrorString:'expected: ' , self name ]
 "
 Integer readFromString:'12345678901234567890'
 Point readFromString:'1@2'
 Point readFromString:'1'
 |str val|
 str := ReadStream on:aString.
 val := self readFrom:str onError:[^ exceptionBlock value].
 str atEnd ifFalse:[
-str skipSeparators.
+	str skipSeparators.
-str atEnd ifFalse:[
+	str atEnd ifFalse:[
-^ exceptionBlock value
+	    ^ exceptionBlock value
-]
+	]
 ].
 ^ val
 "
 Integer readFromString:'12345678901234567890'
 iconInBrowserSymbol
 "can be redefined for a private icon in the browser (for me and my subclasses).
 The returned symbol must be a selector of the ToolbarIconLibrary."
 (self isBrowserStartable) ifTrue:[
-self isVisualStartable ifTrue:[
+	self isVisualStartable ifTrue:[
-^ #visualStartableClassBrowserIcon
+	    ^ #visualStartableClassBrowserIcon
-].
+	].
-^ #startableClassBrowserIcon
+	^ #startableClassBrowserIcon
 ].
 self isLoaded ifFalse:[
-^ #autoloadedClassBrowserIcon
+	^ #autoloadedClassBrowserIcon
 ].
 "/ give ruby and other special metaclasses a chance ot provide their orn icon...
 ^ self class iconInBrowserSymbol
 be executed out of the caches."
 |dict oldMethod|
 newMethod isNil ifTrue:[
-self error:'invalid method'.
+	self error:'invalid method'.
 ].
 (Smalltalk
-changeRequest:#methodInClass
+	    changeRequest:#methodInClass
-with:(Array with:self with:aSelector with:oldMethod)) ifFalse:[
+	    with:(Array with:self with:aSelector with:oldMethod)) ifFalse:[
-^ false
+	^ false
 ].
 "/ oldMethod := self compiledMethodAt:aSelector.
 dict := self methodDictionary.
 "/ oldMethod := dict at:aSelector ifAbsent:nil.
 "/ proper methodDictionaries (it cannot do another message send, to
 "/ find any methods ...), we convert it here if required.
 "/ No other classes instances are allowed.
 dict class ~~ MethodDictionary ifTrue:[
-methodDictionary := MethodDictionary withAll:dict.
+	methodDictionary := MethodDictionary withAll:dict.
-methodDictionary isNil ifTrue:[
+	methodDictionary isNil ifTrue:[
-"/ refuse to do this
+	    "/ refuse to do this
-"/ (can only happen in case of memory allocation trouble,
+	    "/ (can only happen in case of memory allocation trouble,
-"/  where the allocation failed and some exception handler returned
+	    "/  where the allocation failed and some exception handler returned
-"/  nil ...)
+	    "/  nil ...)
-self error:'cannot set methodDictionary to nil' mayProceed:true.
+	    self error:'cannot set methodDictionary to nil' mayProceed:true.
-^ self.
+	    ^ self.
-]
+	]
 ] ifFalse:[
-methodDictionary := dict.
+	methodDictionary := dict.
 ].
 ^ self.
 "Created: 5.6.1996 / 11:29:36 / stefan"
 "Modified: 12.6.1996 / 13:58:55 / stefan"
 |classvars superclass|
 superclass := self superclass.
 (superclass notNil) ifTrue:[
-superclass addAllClassVarNamesTo:aCollection
+	superclass addAllClassVarNamesTo:aCollection
 ].
 (classvars := self classVariableString) notNil ifTrue:[
-aCollection addAll:(classvars asCollectionOfWords).
+	aCollection addAll:(classvars asCollectionOfWords).
 ].
 ^ aCollection
 "Created: 16.4.1996 / 18:00:38 / cg"
 !
 |superclass|
 superclass := self superclass.
 (superclass notNil) ifTrue:[
-superclass addAllInstVarNamesTo:aCollection
+	superclass addAllInstVarNamesTo:aCollection
 ].
 aCollection addAll:self instVarNames.
 ^ aCollection
 "
 addAllPrivateClassesTo:aCollection
 "add all of my private classes to aCollection"
 self privateClassesDo:[:aPrivateClass |
-aCollection add:aPrivateClass.
+	aCollection add:aPrivateClass.
-aPrivateClass addAllPrivateClassesTo:aCollection
+	aPrivateClass addAllPrivateClassesTo:aCollection
 ].
 !
 getLookupObject
 "return the lookupObject (Jan's MetaObjectProtocol support) or nil.
 If non-nil, no lookup is performed by the VM, instead the lookupObject
 has to provide a method object for message sends."
-^lookupObject
+^ lookupObject
 "Created: / 26-04-2010 / 13:36:17 / Jan Vrany <jan.vrany@fit.cvut.cz>"
 !
 setLookupObject:aMethodLookupObject
 firstDefinitionSelectorPart
 "return the first part of the selector with which I was (can be) defined in my superclass"
 self isVariable ifFalse:[
-^ #'subclass:'
+	^ #'subclass:'
 ].
 self isBytes ifTrue:[
-^ #'variableByteSubclass:'
+	^ #'variableByteSubclass:'
 ].
 self isLongs ifTrue:[
-^ #'variableLongSubclass:'
+	^ #'variableLongSubclass:'
 ].
 self isFloats ifTrue:[
-^ #'variableFloatSubclass:'
+	^ #'variableFloatSubclass:'
 ].
 self isDoubles ifTrue:[
-^ #'variableDoubleSubclass:'
+	^ #'variableDoubleSubclass:'
 ].
 self isWords ifTrue:[
-^ #'variableWordSubclass:'
+	^ #'variableWordSubclass:'
 ].
 self isSignedWords ifTrue:[
-^ #'variableSignedWordSubclass:'
+	^ #'variableSignedWordSubclass:'
 ].
 self isSignedLongs ifTrue:[
-^ #'variableSignedLongSubclass:'
+	^ #'variableSignedLongSubclass:'
 ].
 self isSignedLongLongs ifTrue:[
-^ #'variableSignedLongLongSubclass:'
+	^ #'variableSignedLongLongSubclass:'
 ].
 self isLongLongs ifTrue:[
-^ #'variableLongLongSubclass:'
+	^ #'variableLongLongSubclass:'
 ].
 ^ #'variableSubclass:'
 !
 fullName
 |newColl|
 newColl := OrderedCollection new.
 self allSubclassesDo:[:aClass |
-(aClass isRealNameSpace) ifFalse:[
+	(aClass isRealNameSpace) ifFalse:[
-newColl add:aClass
+	    newColl add:aClass
-]
+	]
 ].
 ^ newColl
 "
 Collection allSubclasses
 |newColl|
 newColl := OrderedCollection new.
 self allSubclassesInOrderDo:[:aClass |
-(aClass isRealNameSpace) ifFalse:[
+	(aClass isRealNameSpace) ifFalse:[
-newColl add:aClass
+	    newColl add:aClass
-]
+	]
 ].
 ^ newColl
 "
 Collection allSubclassesInOrder
 |aCollection theSuperClass|
 theSuperClass := self superclass.
 theSuperClass isNil ifTrue:[
-^ #()
+	^ #()
 ].
 aCollection := OrderedCollection new.
 [theSuperClass notNil] whileTrue:[
-aCollection add:theSuperClass.
+	aCollection add:theSuperClass.
-theSuperClass := theSuperClass superclass
+	theSuperClass := theSuperClass superclass
 ].
 ^ aCollection
 "
 String allSuperclasses
 %{  /* NOCONTEXT */
 OBJ __theClass = __INST(superclass);
 while (__theClass != nil) {
-if (__theClass == aClass) {
+	if (__theClass == aClass) {
-RETURN(true);
+	    RETURN(true);
-}
+	}
-if (__isBehaviorLike(__theClass)) {
+	if (__isBehaviorLike(__theClass)) {
-__theClass = __ClassInstPtr(__theClass)->c_superclass;
+	    __theClass = __ClassInstPtr(__theClass)->c_superclass;
-} else {
+	} else {
-__theClass = nil;
+	    __theClass = nil;
-}
+	}
 }
 RETURN (false);
 %}.
 "/    |theClass|
 "/"/        theClass := theClass superclass.
 "/    ].
 "/    ^ false
 "
 String isSubclassOf:Collection
 LinkedList isSubclassOf:Array
 1 isSubclassOf:Number              <- will fail since 1 is no class
 Number isSubclassOf:1
 "
 !
 subclasses
 "return a collection of the direct subclasses of the receiver"
 |newColl|
 newColl := OrderedCollection new.
 self subclassesDo:[:aClass |
-newColl add:aClass
+	newColl add:aClass
 ].
 ^ newColl.
 !
 superclasses
 |aCollection|
 aCollection := OrderedCollection new.
 self withAllSuperclassesDo:[:cls |
-aCollection add:cls
+	aCollection add:cls
 ].
 ^ aCollection
 "
 String withAllSuperclasses
 |coll|
 coll := OrderedCollection new:100.
 self allInstancesDo:[:anObject |
-coll add:anObject
+	coll add:anObject
 ].
 ^ coll
 "
 ScrollBar allInstances
 |coll|
 coll := self allInstances.
 doWeakly ifTrue:[
-coll := WeakArray withAll:coll
+	coll := WeakArray withAll:coll
 ].
 ^ coll
 "Created: / 19.6.1998 / 02:17:20 / cg"
 !
 |coll|
 coll := OrderedCollection new:100.
 self allSubInstancesDo:[:anObject |
-(anObject isKindOf:self) ifTrue:[
+	(anObject isKindOf:self) ifTrue:[
-coll add:anObject
+	    coll add:anObject
-]
+	]
 ].
 ^ coll
 "
 View allSubInstances
 |count|
 count := 0.
 ObjectMemory allObjectsDo:[:anObject |
-(anObject isKindOf:self) ifTrue:[
+	(anObject isKindOf:self) ifTrue:[
-count := count + 1
+	    count := count + 1
-]
+	]
 ].
 ^ count
 "
 View derivedInstanceCount
 "Read the documentation on why there seem to be no
 instances of SmallInteger and UndefinedObject"
 ObjectMemory allObjectsDo:[:anObject |
-(anObject isKindOf:self) ifTrue:[
+	(anObject isKindOf:self) ifTrue:[
-^ true
+	    ^ true
-]
+	]
 ].
 ^ false
 "
 Object hasDerivedInstances         - certainly true
 "/            ^ true
 "/        ]
 "/    ].
 ObjectMemory allInstancesOf:self do:[:anObject |
-^ true
+	^ true
 ].
 ^ false
 "
 Object hasInstances
 "/            count := count + 1
 "/        ]
 "/    ].
 ObjectMemory allInstancesOf:self do:[:anObject |
-count := count + 1
+	count := count + 1
 ].
 ^ count
 "
 View instanceCount
 elementByteSize
 "for bit-like containers, return the number of bytes stored per
 element. For pointer indexed classes, 0 is returned"
 self isBitsExtended ifTrue:[
-self isBytes ifTrue:[^ 1].
+	self isBytes ifTrue:[^ 1].
-self isWords ifTrue:[^ 2].
+	self isWords ifTrue:[^ 2].
-self isSignedWords ifTrue:[^ 2].
+	self isSignedWords ifTrue:[^ 2].
-self isLongs ifTrue:[^ 4].
+	self isLongs ifTrue:[^ 4].
-self isSignedLongs ifTrue:[^ 4].
+	self isSignedLongs ifTrue:[^ 4].
-self isLongLongs ifTrue:[^ 8].
+	self isLongLongs ifTrue:[^ 8].
-self isSignedLongLongs ifTrue:[^ 8].
+	self isSignedLongLongs ifTrue:[^ 8].
 ].
 self isFloats ifTrue:[^ 4].
 self isDoubles ifTrue:[^ 8].
 ^ 0
 REGISTER int what;
 what = (INT)(__INST(flags)) & __MASKSMALLINT(ARRAYMASK);
 RETURN (( (what == __MASKSMALLINT(BYTEARRAY))
-|| (what == __MASKSMALLINT(WORDARRAY))) ? true : false );
+	     || (what == __MASKSMALLINT(WORDARRAY))) ? true : false );
 %}.
 ^ self isBytes or:[self isWords]
 !
 isBitsExtended
 REGISTER int what;
 what = (INT)(__INST(flags)) & __MASKSMALLINT(ARRAYMASK);
 RETURN (( (what == __MASKSMALLINT(BYTEARRAY))
-|| (what == __MASKSMALLINT(WORDARRAY))
+	     || (what == __MASKSMALLINT(WORDARRAY))
-|| (what == __MASKSMALLINT(SWORDARRAY))
+	     || (what == __MASKSMALLINT(SWORDARRAY))
-|| (what == __MASKSMALLINT(LONGARRAY))
+	     || (what == __MASKSMALLINT(LONGARRAY))
-|| (what == __MASKSMALLINT(SLONGARRAY))
+	     || (what == __MASKSMALLINT(SLONGARRAY))
-|| (what == __MASKSMALLINT(LONGLONGARRAY))
+	     || (what == __MASKSMALLINT(LONGLONGARRAY))
-|| (what == __MASKSMALLINT(SLONGLONGARRAY))) ? true : false );
+	     || (what == __MASKSMALLINT(SLONGLONGARRAY))) ? true : false );
 %}
 !
 isBytes
 "return true, if instances have indexed byte instance variables"
 "this could also be defined as:
-^ (flags bitAnd:(Behavior maskIndexType)) == Behavior flagBytes
+	^ (flags bitAnd:(Behavior maskIndexType)) == Behavior flagBytes
 "
 %{  /* NOCONTEXT */
 RETURN ( (((INT)(__INST(flags)) & __MASKSMALLINT(ARRAYMASK)) == __MASKSMALLINT(BYTEARRAY)) ? true : false );
 %}
 isDoubles
 "return true, if instances have indexed double instance variables"
 "this could also be defined as:
-^ (flags bitAnd:(Behavior maskIndexType)) == Behavior flagDoubles
+	^ (flags bitAnd:(Behavior maskIndexType)) == Behavior flagDoubles
 "
 %{  /* NOCONTEXT */
 RETURN ( (((INT)(__INST(flags)) & __MASKSMALLINT(ARRAYMASK)) == __MASKSMALLINT(DOUBLEARRAY)) ? true : false );
 %}
 isFixed
 "return true, if instances do not have indexed instance variables"
 "this could also be defined as:
-^ self isVariable not
+	^ self isVariable not
 "
 %{  /* NOCONTEXT */
 RETURN ( ((INT)(__INST(flags)) & __MASKSMALLINT(ARRAYMASK)) ? false : true );
 isFloats
 "return true, if instances have indexed float instance variables"
 "this could also be defined as:
-^ (flags bitAnd:(Behavior maskIndexType)) == Behavior flagFloats
+	^ (flags bitAnd:(Behavior maskIndexType)) == Behavior flagFloats
 "
 %{  /* NOCONTEXT */
 RETURN ( (((INT)(__INST(flags)) & __MASKSMALLINT(ARRAYMASK)) == __MASKSMALLINT(FLOATARRAY)) ? true : false );
 %}
 int what;
 what = (INT)(__INST(flags)) & __MASKSMALLINT(ARRAYMASK);
 RETURN (( (what == __MASKSMALLINT(FLOATARRAY))
-|| (what == __MASKSMALLINT(DOUBLEARRAY))) ? true : false );
+	     || (what == __MASKSMALLINT(DOUBLEARRAY))) ? true : false );
 %}.
 ^ self isFloats or:[self isDoubles]
 "
 (Object new) class isFloatsOrDoubles
 REGISTER int flags;
 flags = __intVal(__INST(flags)) & ARRAYMASK;
 switch (flags) {
-default:
+	default:
-/* normal objects */
+	    /* normal objects */
-RETURN ( true );
+	    RETURN ( true );
-case BYTEARRAY:
+	case BYTEARRAY:
-case WORDARRAY:
+	case WORDARRAY:
-case LONGARRAY:
+	case LONGARRAY:
-case SWORDARRAY:
+	case SWORDARRAY:
-case SLONGARRAY:
+	case SLONGARRAY:
-case SLONGLONGARRAY:
+	case SLONGLONGARRAY:
-case LONGLONGARRAY:
+	case LONGLONGARRAY:
-case FLOATARRAY:
+	case FLOATARRAY:
-case DOUBLEARRAY:
+	case DOUBLEARRAY:
-RETURN (false );
+	    RETURN (false );
-case WKPOINTERARRAY:
+	case WKPOINTERARRAY:
-/* what about those ? */
+	    /* what about those ? */
-RETURN (true );
+	    RETURN (true );
 }
 %}
 !
 isSignedLongLongs
 isVariable
 "return true, if instances have indexed instance variables"
 "this could also be defined as:
-^ (flags bitAnd:(Behavior maskIndexType)) ~~ 0
+	^ (flags bitAnd:(Behavior maskIndexType)) ~~ 0
 "
 %{  /* NOCONTEXT */
 RETURN ( ((INT)(__INST(flags)) & __MASKSMALLINT(ARRAYMASK)) ? true : false );
 REGISTER int flags;
 flags = __intVal(__INST(flags)) & ARRAYMASK;
 if (flags == WKPOINTERARRAY) {
-RETURN ( true );
+	RETURN ( true );
 }
 %}.
 ^ false
 !
 isWords
 "return true, if instances have indexed short instance variables"
 "this could also be defined as:
-^ (flags bitAnd:(Behavior maskIndexType)) == Behavior flagWords
+	^ (flags bitAnd:(Behavior maskIndexType)) == Behavior flagWords
 "
 %{  /* NOCONTEXT */
 RETURN ( (((INT)(__INST(flags)) & __MASKSMALLINT(ARRAYMASK)) == __MASKSMALLINT(WORDARRAY)) ? true : false );
 %}
 %{
 INT nBytes;
 nBytes = __intVal(nInstvars) * sizeof(OBJ) + OHDR_SIZE;
 if (__isSmallInteger(n)) {
-int nIndex;
+	int nIndex;
-nIndex = __intVal(n);
+	nIndex = __intVal(n);
-switch (__intVal(__INST(flags)) & ARRAYMASK) {
+	switch (__intVal(__INST(flags)) & ARRAYMASK) {
-case BYTEARRAY:
+	    case BYTEARRAY:
-nBytes += nIndex;
+		nBytes += nIndex;
-if (nBytes & (__ALIGN__ - 1)) {
+		if (nBytes & (__ALIGN__ - 1)) {
-nBytes = (nBytes & ~(__ALIGN__ - 1)) + __ALIGN__;
+		    nBytes = (nBytes & ~(__ALIGN__ - 1)) + __ALIGN__;
-}
+		}
-break;
+		break;
-case WORDARRAY:
+	    case WORDARRAY:
-case SWORDARRAY:
+	    case SWORDARRAY:
-nBytes += nIndex * 2;
+		nBytes += nIndex * 2;
-if (nBytes & (__ALIGN__ - 1)) {
+		if (nBytes & (__ALIGN__ - 1)) {
-nBytes = (nBytes & ~(__ALIGN__ - 1)) + __ALIGN__;
+		    nBytes = (nBytes & ~(__ALIGN__ - 1)) + __ALIGN__;
-}
+		}
-break;
+		break;
-case LONGARRAY:
+	    case LONGARRAY:
-case SLONGARRAY:
+	    case SLONGARRAY:
-nBytes += nIndex * 4;
+		nBytes += nIndex * 4;
-break;
+		break;
-case LONGLONGARRAY:
+	    case LONGLONGARRAY:
-case SLONGLONGARRAY:
+	    case SLONGLONGARRAY:
-nBytes += nIndex * 8;
+		nBytes += nIndex * 8;
-break;
+		break;
-case FLOATARRAY:
+	    case FLOATARRAY:
-nBytes += nIndex * sizeof(float);
+		nBytes += nIndex * sizeof(float);
-break;
+		break;
-case DOUBLEARRAY:
+	    case DOUBLEARRAY:
-nBytes += nIndex * sizeof(double);
+		nBytes += nIndex * sizeof(double);
-break;
+		break;
-default:
+	    default:
-nBytes += nIndex * sizeof(OBJ);
+		nBytes += nIndex * sizeof(OBJ);
-break;
+		break;
-}
+	}
 }
 RETURN (__mkSmallInteger(nBytes));
 %}
 ! !
 |superclass|
 superclass := self superclass.
 superclass notNil ifTrue:[
-^ superclass allSelectors addAll:(self selectors); yourself.
+	^ superclass allSelectors addAll:(self selectors); yourself.
 ].
 ^ self selectors asIdentitySet
 "
 Point allSelectors
 canUnderstand:aSelector
 "return true, if the receiver or one of its superclasses implements aSelector.
 (i.e. true if my instances understand aSelector)"
-"JV @ 2010-08-22: Rewritten to respect lookup object."
+|l|
-^ (self lookupObject
-lookupMethodForSelector:aSelector
+"JV @ 2010-08-22: Rewritten to respect lookup object."
-directedTo:self
+(l := self lookupObject) notNil ifTrue:[
-for: nil "Fake receiver"
+	^ (l
-withArguments: nil "Fake arguments"
+	    lookupMethodForSelector:aSelector
-from: thisContext sender) notNil
+	    directedTo:self
+	    for: nil "Fake receiver"
+		withArguments: nil "Fake arguments"
+		from: thisContext sender) notNil
+].
 "Original implementation"
-"
 ^ (self lookupMethodFor:aSelector) notNil
-"
 "
 True canUnderstand:#ifTrue:
 True canUnderstand:#==
 True canUnderstand:#do:
 |dict|
 dict := self methodDictionary.
 dict isNil ifTrue:[
-('Behavior [warning]: nil methodDictionary in ' , self name printString) errorPrintCR.
+	('Behavior [warning]: nil methodDictionary in ' , self name printString) errorPrintCR.
-^ exceptionValue value
+	^ exceptionValue value
 ].
 ^ dict at:aSelector ifAbsent:exceptionValue
 "
 "Warning: this method is here to support multiple languages.
 Do not use in code that works just with the smalltalk code.
 Use compiledMethodAt: selector instead"
 "Returns a method with given name of value of exceptionValue
 if not present. This differs from #compiledMethodAt:, since class
 may contain more methods with same name and different selectors.
 Only methods in the receiver - not in the superclass chain are tested."
 |dict mth|
 dict := self methodDictionary.
 dict isNil ifTrue:[
-('Behavior [warning]: nil methodDictionary in ' , self name printString) errorPrintCR.
+	('Behavior [warning]: nil methodDictionary in ' , self name printString) errorPrintCR.
-^ exceptionValue value
+	^ exceptionValue value
 ].
 "Quick check: look into method dictionary"
 mth := dict at: name asSymbol ifAbsent:nil.
 mth ifNotNil:[^mth].
 "Slow search..."
 dict do:
-[:each|
+	[:each|
-(each isSynthetic not and:[each name = name])
+	(each isSynthetic not and:[each name = name])
-ifTrue:[^each]].
+	    ifTrue:[^each]].
 ^exceptionValue value
 "
 Object compiledMethodNamed:#==
 (Object compiledMethodNamed:#==) category
 "
 "return true, if the receiver implements aSelector.
 (i.e. implemented in THIS class - NOT in a superclass).
 This is semantically equivalent to includesSelector: (which is ST/80/Squeak compatibility).
 Caveat:
-This simply checks for the selector being present in the classes
+	This simply checks for the selector being present in the classes
-selector table - therefore, it does not care for ignoredMethods.
+	selector table - therefore, it does not care for ignoredMethods.
-(but: you should not use this method for protocol-testing, anyway).
+	(but: you should not use this method for protocol-testing, anyway).
 Hint:
-Dont use this method to check if someone responds to a message -
+	Dont use this method to check if someone responds to a message -
-use #canUnderstand: on the class or #respondsTo: on the instance
+	use #canUnderstand: on the class or #respondsTo: on the instance
-to do this."
+	to do this."
 ^ self includesSelector:aSelector
 "
 notice: this is class protocol
 "return true, if the methodDictionary of THIS class includes a method for aSelector.
 (i.e. if aSelector is implemented in THIS class - NOT in a superclass).
 This is semantically equivalent to implements: (ST/80/Squeak compatibility).
 Hint:
-Dont use this method to check if someone responds to a message -
+	Dont use this method to check if someone responds to a message -
-use #canUnderstand: on the class or #respondsTo: on the instance
+	use #canUnderstand: on the class or #respondsTo: on the instance
-to do this.
+	to do this.
 Caveat:
-This simply checks for the selector being present in the classes
+	This simply checks for the selector being present in the classes
-selector table - therefore, it does not care for ignoredMethods.
+	selector table - therefore, it does not care for ignoredMethods.
-(but: you should not use this method for protocol-testing, anyway)."
+	(but: you should not use this method for protocol-testing, anyway)."
 ^ self methodDictionary includesIdenticalKey:aSelector
 "
 Object includesSelector:#==
 an instance of the receiver. I.e. the selector arrays of the receiver
 and all of its superclasses are searched for aSelector.
 Return the method, or nil if instances do not understand aSelector.
 EXPERIMENTAL: take care of multiple superclasses."
-"JV @ 2010-08-22: Rewritten to respect lookup object."
+|l m cls|
-^ (self lookupObject
-lookupMethodForSelector:aSelector
+"JV @ 2010-08-22: Rewritten to respect lookup object."
-directedTo:self
+(l := self lookupObject) notNil ifTrue:[
-for: nil "Fake receiver"
+	^ (l
-withArguments: nil "Fake arguments"
+	    lookupMethodForSelector:aSelector
-from: thisContext sender)
+	    directedTo:self
+	    for: nil "Fake receiver"
-"Original implementation"
+		withArguments: nil "Fake arguments"
-"
+		from: thisContext sender)
-|m cls|
+].
 cls := self.
 [cls notNil] whileTrue:[
-m := cls compiledMethodAt:aSelector.
+	m := cls compiledMethodAt:aSelector.
-m notNil ifTrue:[^ m].
+	m notNil ifTrue:[^ m].
-cls hasMultipleSuperclasses ifTrue:[
+	cls hasMultipleSuperclasses ifTrue:[
-cls superclasses do:[:aSuperClass |
+	    cls superclasses do:[:aSuperClass |
-m := aSuperClass lookupMethodFor:aSelector.
+		m := aSuperClass lookupMethodFor:aSelector.
-m notNil ifTrue:[^ m].
+		m notNil ifTrue:[^ m].
-].
+	    ].
-^ nil
+	    ^ nil
-] ifFalse:[
+	] ifFalse:[
-cls := cls superclass
+	    cls := cls superclass
-]
+	]
 ].
 ^ nil
-"
 !
 responseTo:aSelector
 "return the method (from here or the inheritance chain),
 which implements aSelector; return nil if none."
 |cls|
 cls := self whichClassIncludesSelector:aSelector.
 cls notNil ifTrue:[
-^ cls compiledMethodAt:aSelector
+	^ cls compiledMethodAt:aSelector
 ].
 ^ nil
 "
 String responseTo:#==
 |md|
 md := self methodDictionary.
 md isNil ifTrue:[
-'OOPS - nil methodDictionary' errorPrintCR.
+	'OOPS - nil methodDictionary' errorPrintCR.
-^ nil
+	^ nil
 ].
 ^ md keyAtValue:aMethod ifAbsent:failBlock.
 "
 |m|
 |cls|
 cls := self.
 [cls notNil] whileTrue:[
-(cls includesSelector:aSelector) ifTrue:[^ cls].
+	(cls includesSelector:aSelector) ifTrue:[^ cls].
-cls hasMultipleSuperclasses ifTrue:[
+	cls hasMultipleSuperclasses ifTrue:[
-cls superclasses do:[:aSuperClass |
+	    cls superclasses do:[:aSuperClass |
-|implementingClass|
+		|implementingClass|
-implementingClass := aSuperClass whichClassIncludesSelector:aSelector.
+		implementingClass := aSuperClass whichClassIncludesSelector:aSelector.
-implementingClass notNil ifTrue:[^ implementingClass].
+		implementingClass notNil ifTrue:[^ implementingClass].
-].
+	    ].
-^ nil
+	    ^ nil
-] ifFalse:[
+	] ifFalse:[
-cls := cls superclass
+	    cls := cls superclass
-]
+	]
 ].
 ^ nil
 "
 String whichClassIncludesSelector:#==
 |superclass superInsts|
 superclass := self superclass.
 superclass isNil ifTrue:[
-superInsts := 0
+	superInsts := 0
 ] ifFalse:[
-superInsts := superclass instSize
+	superInsts := superclass instSize
 ].
 ^ (superInsts+1 to:self instSize)
 collect:[:index | self instVarNameForIndex:index]
 "Modified: / 17-07-2006 / 00:28:40 / cg"
 |superclass s superInsts first n "{Class: SmallInteger }"|
 superclass := self superclass.
 s := ''.
 superclass isNil ifTrue:[
-superInsts := 0
+	superInsts := 0
 ] ifFalse:[
-superInsts := superclass instSize
+	superInsts := superclass instSize
 ].
 n := self instSize.
 first := true.
 superInsts+1 to:n do:[:i |
-first ifFalse:[s := s , ' '] ifTrue:[first := false].
+	first ifFalse:[s := s , ' '] ifTrue:[first := false].
-s := s , 'instvar' , i printString
+	s := s , 'instvar' , i printString
 ].
 ^ s
 "
 Behavior new instanceVariableString
 name := aStringOrText asString string.
 ^ self whichClassSatisfies:[:aClass | aClass classVarNames includes:name]
 "
 TextView whichClassDefinesClassVar:'CachedScales'
 TextView whichClassDefinesClassVar:'xxx'
 "
 !
 whichClassDefinesInstVar: aString
 ^ self whichClassSatisfies: [:aClass | aClass instVarNames includes: aString]
 !
 whichSelectorsAssign: instVarName
-"Answer a set of selectors whose methods write the argument, instVarName,
+	"Answer a set of selectors whose methods write the argument, instVarName,
-as a named instance variable."
+	as a named instance variable."
-^ self whichSelectorsWrite: instVarName
+	^ self whichSelectorsWrite: instVarName
 !
 whichSelectorsRead: instVarName
-"Answer a set of selectors whose methods read the argument, instVarName,
+	"Answer a set of selectors whose methods read the argument, instVarName,
-as a named instance variable."
+	as a named instance variable."
-| instVarIndex methodDict|
+	| instVarIndex methodDict|
-instVarIndex := self allInstVarNames indexOf: instVarName ifAbsent: [^Set new].
+	instVarIndex := self allInstVarNames indexOf: instVarName ifAbsent: [^Set new].
-methodDict := self methodDictionary.
+	methodDict := self methodDictionary.
-^methodDict keys select: [:sel | (methodDict at: sel)
+	^methodDict keys select: [:sel | (methodDict at: sel)
-readsField: instVarIndex]
+			readsField: instVarIndex]
 !
 whichSelectorsReferTo:someLiteralConstant
 "return a collection of selectors of methods which refer to the argument.
 Search the literal arrays of my methods to do this."
 |setOfSelectors|
 setOfSelectors := IdentitySet new.
 self methodDictionary keysAndValuesDo:[:sel :mthd |
-(mthd referencesLiteral:someLiteralConstant) ifTrue:[
+	(mthd referencesLiteral:someLiteralConstant) ifTrue:[
-setOfSelectors add:sel
+	    setOfSelectors add:sel
-].
+	].
 ].
 ^ setOfSelectors
 "
 "Modified: / 4.2.2000 / 00:41:10 / cg"
 !
 whichSelectorsWrite: instVarName
-"Answer a set of selectors whose methods write the argument, instVarName,
+	"Answer a set of selectors whose methods write the argument, instVarName,
-as a named instance variable."
+	as a named instance variable."
-| instVarIndex methodDict |
+	| instVarIndex methodDict |
-instVarIndex := self allInstVarNames indexOf: instVarName ifAbsent: [^Set new].
+	instVarIndex := self allInstVarNames indexOf: instVarName ifAbsent: [^Set new].
-methodDict := self methodDictionary.
+	methodDict := self methodDictionary.
-^methodDict keys select: [:sel | (methodDict at: sel)
+	^methodDict keys select: [:sel | (methodDict at: sel)
-writesField: instVarIndex]
+			writesField: instVarIndex]
 ! !
 !Behavior methodsFor:'snapshots'!
 postSnapshot
 !Behavior class methodsFor:'documentation'!
 version_CVS
-^ '$Header: /cvs/stx/stx/libbasic/Behavior.st,v 1.311 2011-06-28 12:41:18 vrany Exp $'
+^ '$Header: /cvs/stx/stx/libbasic/Behavior.st,v 1.312 2011-06-28 13:54:21 cg Exp $'
 !
 version_SVN
 ^ ' Id: Behavior.st 10643 2011-06-08 21:53:07Z vranyj1  '
 ! !

changeset 13419	5023fe2f46ce
parent 13414	a366c72d27f2
child 13460	3197ced2f512