hg/stx-libbasic: comparison Object.st

equal deleted inserted replaced

-:af82888ceb72
+:1f5aa87f6170
 !Object class methodsFor:'queries'!
 isAbstract
 "Return if this class is an abstract class.
 True is returned for Object here; false for subclasses.
-Abstract subclasses must redefine again."
+Abstract subclasses must redefine this again."
 ^ self == Object
 !
 isBuiltInClass
 byteAt:index
 "return the byte at index.
 This is only allowed for non-pointer indexed objects
 (i.e. byteArrays, wordArrays, floatArrays etc.).
-The receivers indexed instvars are treated as an uninterpreted
+The receiver's indexed instvars are treated as an uninterpreted
 collection of bytes.
 Only useful with binary storage."
 %{  /* NOCONTEXT */
 int nIndex;
 REGISTER OBJ slf;
 REGISTER OBJ cls;
 if (__isSmallInteger(index)) {
-	slf = self;
+slf = self;
-	if (__isNonNilObject(slf)) {
+if (__isNonNilObject(slf)) {
-	    unsigned char *pFirst;
+unsigned char *pFirst;
-	    int nIndex;
+int nIndex;
-	    cls = __qClass(slf);
+cls = __qClass(slf);
-	    pFirst = __byteArrayVal(slf);
+pFirst = __byteArrayVal(slf);
-	    pFirst += __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));
+pFirst += __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));
-	    nIndex = __byteArraySize(slf);
+nIndex = __byteArraySize(slf);
-	    indx = __intVal(index) - 1;
+indx = __intVal(index) - 1;
-	    switch ((INT)(__ClassInstPtr(cls)->c_flags) & __MASKSMALLINT(ARRAYMASK)) {
+switch ((INT)(__ClassInstPtr(cls)->c_flags) & __MASKSMALLINT(ARRAYMASK)) {
-		case __MASKSMALLINT(DOUBLEARRAY):
+case __MASKSMALLINT(DOUBLEARRAY):
 #ifdef __NEED_DOUBLE_ALIGN
-		    if ((INT)pFirst & (__DOUBLE_ALIGN-1)) {
+if ((INT)pFirst & (__DOUBLE_ALIGN-1)) {
-			int delta = __DOUBLE_ALIGN - ((INT)pFirst & (__DOUBLE_ALIGN-1));
+int delta = __DOUBLE_ALIGN - ((INT)pFirst & (__DOUBLE_ALIGN-1));
-			pFirst += delta;
+pFirst += delta;
-			nIndex -= delta;
+nIndex -= delta;
-		    }
+}
 #endif
-		    /* fall into */
+/* fall into */
-		case __MASKSMALLINT(BYTEARRAY):
+case __MASKSMALLINT(BYTEARRAY):
-		case __MASKSMALLINT(WORDARRAY):
+case __MASKSMALLINT(WORDARRAY):
-		case __MASKSMALLINT(LONGARRAY):
+case __MASKSMALLINT(LONGARRAY):
-		case __MASKSMALLINT(SWORDARRAY):
+case __MASKSMALLINT(SWORDARRAY):
-		case __MASKSMALLINT(SLONGARRAY):
+case __MASKSMALLINT(SLONGARRAY):
-		case __MASKSMALLINT(FLOATARRAY):
+case __MASKSMALLINT(FLOATARRAY):
-		    if ((unsigned)indx < (unsigned)nIndex) {
+if ((unsigned)indx < (unsigned)nIndex) {
-			RETURN ( __mkSmallInteger( (INT)(pFirst[indx])) );
+RETURN ( __mkSmallInteger( (INT)(pFirst[indx])) );
-		    }
+}
-		    break;
+break;
-		case __MASKSMALLINT(LONGLONGARRAY):
+case __MASKSMALLINT(LONGLONGARRAY):
-		case __MASKSMALLINT(SLONGLONGARRAY):
+case __MASKSMALLINT(SLONGLONGARRAY):
 #ifdef __NEED_LONGLONG_ALIGN
-		    if ((INT)pFirst & (__LONGLONG_ALIGN-1)) {
+if ((INT)pFirst & (__LONGLONG_ALIGN-1)) {
-			int delta = __LONGLONG_ALIGN - ((INT)pFirst & (__LONGLONG_ALIGN-1));
+int delta = __LONGLONG_ALIGN - ((INT)pFirst & (__LONGLONG_ALIGN-1));
-			pFirst += delta;
+pFirst += delta;
-			nIndex -= delta;
+nIndex -= delta;
-		    }
+}
 #endif
-		    if ((unsigned)indx < (unsigned)nIndex) {
+if ((unsigned)indx < (unsigned)nIndex) {
-			RETURN ( __mkSmallInteger( (INT)(pFirst[indx])) );
+RETURN ( __mkSmallInteger( (INT)(pFirst[indx])) );
-		    }
+}
-		    break;
+break;
-	    }
+}
-	}
+}
 }
 %}.
 "/ index not integer or index out of range
 "/ or non-byte indexable receiver
 byteAt:index put:byteValue
 "set the byte at index.
 This is only allowed for non-pointer indexed objects
 (i.e. byteArrays, wordArrays, floatArrays etc.).
-The receivers indexed instvars are treated as an uninterpreted
+The receiver's indexed instvars are treated as an uninterpreted
 collection of bytes.
 Only useful with binary storage."
 %{  /* NOCONTEXT */
 int val, nIndex;
 REGISTER OBJ slf;
 REGISTER OBJ cls;
 if (__bothSmallInteger(index, byteValue)) {
-	val = __intVal(byteValue);
+val = __intVal(byteValue);
-	if ((unsigned)(val) <= 0xFF /* i.e. (val >= 0) && (val <= 255) */) {
+if ((unsigned)(val) <= 0xFF /* i.e. (val >= 0) && (val <= 255) */) {
-	    slf = self;
+slf = self;
-	    if (__isNonNilObject(slf)) {
+if (__isNonNilObject(slf)) {
-		cls = __qClass(slf);
+cls = __qClass(slf);
-		indx = __intVal(index) - 1;
+indx = __intVal(index) - 1;
-		switch ((INT)(__ClassInstPtr(cls)->c_flags) & __MASKSMALLINT(ARRAYMASK)) {
+switch ((INT)(__ClassInstPtr(cls)->c_flags) & __MASKSMALLINT(ARRAYMASK)) {
-		    case __MASKSMALLINT(BYTEARRAY):
+case __MASKSMALLINT(BYTEARRAY):
-		    case __MASKSMALLINT(WORDARRAY):
+case __MASKSMALLINT(WORDARRAY):
-		    case __MASKSMALLINT(LONGARRAY):
+case __MASKSMALLINT(LONGARRAY):
-		    case __MASKSMALLINT(SWORDARRAY):
+case __MASKSMALLINT(SWORDARRAY):
-		    case __MASKSMALLINT(SLONGARRAY):
+case __MASKSMALLINT(SLONGARRAY):
-		    case __MASKSMALLINT(LONGLONGARRAY):
+case __MASKSMALLINT(LONGLONGARRAY):
-		    case __MASKSMALLINT(SLONGLONGARRAY):
+case __MASKSMALLINT(SLONGLONGARRAY):
-		    case __MASKSMALLINT(FLOATARRAY):
+case __MASKSMALLINT(FLOATARRAY):
-		    case __MASKSMALLINT(DOUBLEARRAY):
+case __MASKSMALLINT(DOUBLEARRAY):
-			indx += __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));
+indx += __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));
-			nIndex = __byteArraySize(slf);
+nIndex = __byteArraySize(slf);
-			if ((unsigned)indx < (unsigned)nIndex) {
+if ((unsigned)indx < (unsigned)nIndex) {
-			    __ByteArrayInstPtr(slf)->ba_element[indx] = val;
+__ByteArrayInstPtr(slf)->ba_element[indx] = val;
-			    RETURN ( byteValue );
+RETURN ( byteValue );
-			}
+}
-			break;
+break;
-		}
+}
-	    }
+}
-	}
+}
 }
 %}.
 "/ index not integer or index out of range
 "/ or non-byte indexable receiver
 !
 deepCopy
 "return a copy of the object with all subobjects also copied.
 This method DOES handle cycles/self-refs and preserves object identity;
-however the receivers class is not copied (to avoid the 'total' copy).
+however the receiver's class is not copied (to avoid the 'total' copy).
 This deepCopy is a bit slower than the old (unsecure) one, since it
 keeps track of already copied objects. If you are sure, that your
 copied object does not include duplicates (or you do not care) and
 no cycles are involved, you can use the old simpleDeepCopy,
 !
 displayOn:aGc x:x y:y opaque:opaque
 "display the receiver in a graphicsContext - this method allows
 for any object to be displayed in a ListView - for example.
-The fallBack here shows the receivers displayString.
+The fallBack here shows the receiver's displayString.
 Notice, that the string is displayed on the baseLine;
 ask using #ascentOn: if required"
 |s yBaseline|
 s := self isString ifTrue:[self] ifFalse:[self displayString].
 yBaseline := y "+ aGc font ascent".
 opaque ifTrue:[
-	aGc displayOpaqueString:s x:x y:yBaseline.
+aGc displayOpaqueString:s x:x y:yBaseline.
 ] ifFalse:[
-	aGc displayString:s x:x y:yBaseline.
+aGc displayString:s x:x y:yBaseline.
 ].
 "Modified: 29.5.1996 / 16:29:38 / cg"
 !
 ! !
 !Object methodsFor:'printing & storing'!
 basicPrintOn:aStream
-"append the receivers className with an articel to the argument, aStream"
+"append the receiver's className with an article to the argument, aStream"
 aStream nextPutAll:self classNameWithArticle
 !
 basicStoreString
 printOn:aStream
 "append a user printed representation of the receiver to aStream.
 The format is suitable for a human - not meant to be read back.
-The default here is to output the receivers class name.
+The default here is to output the receiver's class name.
 BUT: this method is heavily redefined for objects which
 can print prettier."
 self basicPrintOn:aStream.
 ! !
 !Object methodsFor:'queries'!
 basicSize
-"return the number of the receivers indexed instance variables,
+"return the number of the receiver's indexed instance variables,
 0 if it has none.
 This method should NOT be redefined in any subclass (except with great care, for tuning)"
 %{  /* NOCONTEXT */
 myClass = __qClass(self);
 nbytes = __qSize(self);
 nInstBytes = OHDR_SIZE + __OBJS2BYTES__( __intVal(__ClassInstPtr(myClass)->c_ninstvars) );
 switch ((INT)(__ClassInstPtr(myClass)->c_flags) & __MASKSMALLINT(ARRAYMASK)) {
-	case __MASKSMALLINT(POINTERARRAY):
+case __MASKSMALLINT(POINTERARRAY):
-	case __MASKSMALLINT(WKPOINTERARRAY):
+case __MASKSMALLINT(WKPOINTERARRAY):
-	    nbytes -= nInstBytes;
+nbytes -= nInstBytes;
-	    RETURN ( __mkSmallInteger(__BYTES2OBJS__(nbytes)) );
+RETURN ( __mkSmallInteger(__BYTES2OBJS__(nbytes)) );
-	case __MASKSMALLINT(BYTEARRAY):
+case __MASKSMALLINT(BYTEARRAY):
-	    nbytes -= nInstBytes;
+nbytes -= nInstBytes;
-	    RETURN ( __mkSmallInteger(nbytes / sizeof(char)) );
+RETURN ( __mkSmallInteger(nbytes / sizeof(char)) );
-	case __MASKSMALLINT(FLOATARRAY):
+case __MASKSMALLINT(FLOATARRAY):
-	    nbytes -= nInstBytes;
+nbytes -= nInstBytes;
-	    RETURN ( __mkSmallInteger(nbytes / sizeof(float)) );
+RETURN ( __mkSmallInteger(nbytes / sizeof(float)) );
-	case __MASKSMALLINT(DOUBLEARRAY):
+case __MASKSMALLINT(DOUBLEARRAY):
 # ifdef __NEED_DOUBLE_ALIGN
-	    nInstBytes = (nInstBytes-1+__DOUBLE_ALIGN) &~ (__DOUBLE_ALIGN-1);
+nInstBytes = (nInstBytes-1+__DOUBLE_ALIGN) &~ (__DOUBLE_ALIGN-1);
 # endif
-	    nbytes -= nInstBytes;
+nbytes -= nInstBytes;
-	    RETURN ( __mkSmallInteger(nbytes / sizeof(double)) );
+RETURN ( __mkSmallInteger(nbytes / sizeof(double)) );
-	case __MASKSMALLINT(WORDARRAY):
+case __MASKSMALLINT(WORDARRAY):
-	case __MASKSMALLINT(SWORDARRAY):
+case __MASKSMALLINT(SWORDARRAY):
-	    nbytes -= nInstBytes;
+nbytes -= nInstBytes;
-	    RETURN ( __mkSmallInteger(nbytes>>1) ); /* notice the hardcoded 2 here - not sizeof(short) */
+RETURN ( __mkSmallInteger(nbytes>>1) ); /* notice the hardcoded 2 here - not sizeof(short) */
-	case __MASKSMALLINT(LONGARRAY):
+case __MASKSMALLINT(LONGARRAY):
-	case __MASKSMALLINT(SLONGARRAY):
+case __MASKSMALLINT(SLONGARRAY):
-	    nbytes -= nInstBytes;
+nbytes -= nInstBytes;
-	    RETURN ( __mkSmallInteger(nbytes>>2) ); /* notice the hardcoded 4 here - not sizeof(int) */
+RETURN ( __mkSmallInteger(nbytes>>2) ); /* notice the hardcoded 4 here - not sizeof(int) */
-	case __MASKSMALLINT(LONGLONGARRAY):
+case __MASKSMALLINT(LONGLONGARRAY):
-	case __MASKSMALLINT(SLONGLONGARRAY):
+case __MASKSMALLINT(SLONGLONGARRAY):
 # ifdef __NEED_LONGLONG_ALIGN
-	    nInstBytes = (nInstBytes-1+__LONGLONG_ALIGN) &~ (__LONGLONG_ALIGN-1);
+nInstBytes = (nInstBytes-1+__LONGLONG_ALIGN) &~ (__LONGLONG_ALIGN-1);
 # endif
-	    nbytes -= nInstBytes;
+nbytes -= nInstBytes;
-	    RETURN ( __mkSmallInteger(nbytes>>3) ); /* notice the hardcoded 8 here - not sizeof(long long) */
+RETURN ( __mkSmallInteger(nbytes>>3) ); /* notice the hardcoded 8 here - not sizeof(long long) */
 }
 #endif /* not __SCHTEAM__ */
 %}.
 ^ 0
 !
 byteSize
-"return the number of bytes in the receivers indexed instance variables,
+"return the number of bytes in the receiver's indexed instance variables,
 0 if it has none. This only returns non-zero for non-pointer indexed
 instvars i.e. byteArrays, wordArrays etc.
 Notice: for Strings the returned size may look strange.
 Only useful with binary storage."
 |myClass|
 myClass := self class.
 myClass isVariable ifTrue:[
-	myClass isPointers ifFalse:[
+myClass isPointers ifFalse:[
-	    myClass isBytes ifTrue:[
+myClass isBytes ifTrue:[
-		^ self basicSize.
+^ self basicSize.
-	    ].
+].
-	    myClass isWords ifTrue:[
+myClass isWords ifTrue:[
-		^ self basicSize * 2.
+^ self basicSize * 2.
-	    ].
+].
-	    myClass isSignedWords ifTrue:[
+myClass isSignedWords ifTrue:[
-		^ self basicSize * 2.
+^ self basicSize * 2.
-	    ].
+].
-	    myClass isLongs ifTrue:[
+myClass isLongs ifTrue:[
-		^ self basicSize * 4.
+^ self basicSize * 4.
-	    ].
+].
-	    myClass isSignedLongs ifTrue:[
+myClass isSignedLongs ifTrue:[
-		^ self basicSize * 4.
+^ self basicSize * 4.
-	    ].
+].
-	    myClass isLongLongs ifTrue:[
+myClass isLongLongs ifTrue:[
-		^ self basicSize * 8.
+^ self basicSize * 8.
-	    ].
+].
-	    myClass isSignedLongLongs ifTrue:[
+myClass isSignedLongLongs ifTrue:[
-		^ self basicSize * 8.
+^ self basicSize * 8.
-	    ].
+].
-	    myClass isFloats ifTrue:[
+myClass isFloats ifTrue:[
-		^ self basicSize * (ExternalBytes sizeofFloat)
+^ self basicSize * (ExternalBytes sizeofFloat)
-	    ].
+].
-	    myClass isDoubles ifTrue:[
+myClass isDoubles ifTrue:[
-		^ self basicSize * (ExternalBytes sizeofDouble)
+^ self basicSize * (ExternalBytes sizeofDouble)
-	    ].
+].
-	    self error:'unknown variable size class species'.
+self error:'unknown variable size class species'.
-	]
+]
 ].
 ^ 0
 "
 Point new byteSize
 !
 respondsTo:aSelector
 "return true, if the receiver implements a method with selector equal
 to aSelector; i.e. if there is a method for aSelector in either the
-receivers class or one of its superclasses.
+receiver's class or one of its superclasses.
 Notice, that this does not imply, that such a message can be sent without
 an error being raised. For example, an implementation could send
 #shouldNotImplement or #subclassResponsibility."
 For now, use the cache ...
 "
 %{  /* NOCONTEXT */
 if (__lookup(__Class(self), aSelector) == nil) {
-	RETURN ( false );
+RETURN ( false );
 }
 RETURN ( true );
 %}
 .
 ^ self class canUnderstand:aSelector
 ^ false
 !
 size
-"return the number of the receivers indexed instance variables;
+"return the number of the receiver's indexed instance variables;
 this method may be redefined in subclasses"
 ^ self basicSize
 !
 species
-"return a class which is similar to (or the same as) the receivers class.
+"return a class which is similar to (or the same as) the receiver's class.
 This is used to create an appropriate object when creating derived
 copies in the collection classes (sometimes redefined)."
 ^ self class
 !
 self primitiveFailed
 !
 changeClassTo:otherClass
 "changes the class of the receiver to the argument, otherClass.
-This is only allowed (possible), if the receivers class and the argument
+This is only allowed (possible), if the receiver's class and the argument
 have the same structure (i.e. number of named instance variables and
 type of indexed instance variables).
 If the structures do not match, or any of the original class or new class
 is UndefinedObject or a Smallinteger, a primitive error is triggered."
 "check for UndefinedObject/SmallInteger receiver or newClass"
 %{
 #ifdef __SCHTEAM__
 ok = (self.isSTInstance() && otherClass.isSTInstance())
-	    ? STObject.True : STObject.False;
+? STObject.True : STObject.False;
 #else
 {
-	OBJ other = otherClass;
+OBJ other = otherClass;
-	if (__isNonNilObject(self)
+if (__isNonNilObject(self)
-	 && __isNonNilObject(other)
+&& __isNonNilObject(other)
-	 && (other != UndefinedObject)
+&& (other != UndefinedObject)
-	 && (other != SmallInteger)) {
+&& (other != SmallInteger)) {
-	    ok = true;
+ok = true;
-	} else {
+} else {
-	    ok = false;
+ok = false;
-	}
+}
 }
 #endif /* not SCHTEAM */
 %}.
 ok == true ifTrue:[
-	ok := false.
+ok := false.
-	myClass := self class.
+myClass := self class.
-	myClass == otherClass ifTrue:[
+myClass == otherClass ifTrue:[
-	    "nothing to change"
+"nothing to change"
-	    ^ self.
+^ self.
-	].
+].
-	myClass flags == otherClass flags ifTrue:[
+myClass flags == otherClass flags ifTrue:[
-	    myClass instSize == otherClass instSize ifTrue:[
+myClass instSize == otherClass instSize ifTrue:[
-		"same instance layout and types: its ok to do it"
+"same instance layout and types: its ok to do it"
-		ok := true.
+ok := true.
-	    ] ifFalse:[
+] ifFalse:[
-		myClass isPointers ifTrue:[
+myClass isPointers ifTrue:[
-		    myClass isVariable ifTrue:[
+myClass isVariable ifTrue:[
-			ok := true
+ok := true
-		    ]
+]
-		]
+]
-	    ]
+]
-	] ifFalse:[
+] ifFalse:[
-	    myClass isPointers ifTrue:[
+myClass isPointers ifTrue:[
-		"if newClass is a variable class, with instSize <= my instsize,
+"if newClass is a variable class, with instSize <= my instsize,
-		 we can do it (effectively mapping additional instvars into the
+we can do it (effectively mapping additional instvars into the
-		 variable part) - usefulness is questionable, though"
+variable part) - usefulness is questionable, though"
-		otherClass isPointers ifTrue:[
+otherClass isPointers ifTrue:[
-		    otherClass isVariable ifTrue:[
+otherClass isVariable ifTrue:[
-			otherClass instSize <= (myClass instSize + self basicSize)
+otherClass instSize <= (myClass instSize + self basicSize)
-			ifTrue:[
+ifTrue:[
-			    ok := true
+ok := true
-			]
+]
-		    ] ifFalse:[
+] ifFalse:[
-			otherClass instSize == (myClass instSize + self basicSize)
+otherClass instSize == (myClass instSize + self basicSize)
-			ifTrue:[
+ifTrue:[
-			    ok := true
+ok := true
-			]
+]
-		    ]
+]
-		] ifFalse:[
+] ifFalse:[
-		    "it does not make sense to convert pointers to bytes ..."
+"it does not make sense to convert pointers to bytes ..."
-		]
+]
-	    ] ifFalse:[
+] ifFalse:[
-		"does it make sense, to convert bits ?"
+"does it make sense, to convert bits ?"
-		"could allow byteArray->wordArray->longArray->floatArray->doubleArray here ..."
+"could allow byteArray->wordArray->longArray->floatArray->doubleArray here ..."
-		(myClass isBitsExtended and:[otherClass isBitsExtended]) ifTrue:[
+(myClass isBitsExtended and:[otherClass isBitsExtended]) ifTrue:[
-		    ok := true
+ok := true
-		]
+]
-	    ]
+]
-	]
+]
 ].
 ok == true ifTrue:[
-	"now, change the receiver's class ..."
+"now, change the receiver's class ..."
 %{
 #ifdef __SCHTEAM__
-	((STInstance)self).clazz = (STClass)otherClass;
+((STInstance)self).clazz = (STClass)otherClass;
-	return __c__._RETURN(self);
+return __c__._RETURN(self);
 #else
-	{
+{
-	    OBJ me = self;
+OBJ me = self;
-	    // gcc4.4 does not like this:
+// gcc4.4 does not like this:
-	    // __qClass(me) = otherClass;
+// __qClass(me) = otherClass;
-	    __objPtr(me)->o_class = (CLASS_OBJ)otherClass;
+__objPtr(me)->o_class = (CLASS_OBJ)otherClass;
-	    __STORE(me, otherClass);
+__STORE(me, otherClass);
-	    RETURN (me);
+RETURN (me);
-	}
+}
 #endif /* not SCHTEAM */
 %}.
 ].
 "
 self primitiveFailed
 !
 changeClassToThatOf:anObject
 "changes the class of the receiver to that of the argument, anObject.
-This is only allowed (possible), if the receivers class and the arguments
+This is only allowed (possible), if the receiver's class and the arguments
 class have the same structure (i.e. number of named instance variables and
 type of indexed instance variables). If the structures do not match, or any
 of the objects is nil or a Smallinteger, a primitive error is triggered."
 self changeClassTo:(anObject class)
 ? defaultValue
 "a syntactic sugar-piece:
 if the receiver is nil, return the defaultValue;
 otherwise, return the receiver.
 This method is only redefined in UndefinedObject - therefore,
-the recevier is retuned here.
+the receiver is retuned here.
 Thus, if foo and bar are simple variables or constants,
-	  foo ? bar
+foo ? bar
 is the same as:
-	  (foo isNil ifTrue:[bar] ifFalse:[foo])
+(foo isNil ifTrue:[bar] ifFalse:[foo])
 if they are message sends, the equivalent code is:
-	  [
+[
-	      |t1 t2|
+|t1 t2|
-	      t1 := foo.
+t1 := foo.
-	      t2 := bar.
+t2 := bar.
-	      t1 isNil ifTrue:[t2] ifFalse:[t1]
+t1 isNil ifTrue:[t2] ifFalse:[t1]
-	  ] value
+] value
 Can be used to provide defaultValues to variables,
 as in:
-	  foo := arg ? #defaultValue
+foo := arg ? #defaultValue
 Note: this method should never be redefined in classes other than UndefinedObject.
 Notice:
-	 This method is open coded (inlined) by the compiler(s)
+This method is open coded (inlined) by the compiler(s)
-	 - redefining it may not work as expected."
+- redefining it may not work as expected."
 ^ self
 "
 1 ? #default

branch	jv
changeset 19478	1f5aa87f6170
parent 19431	3e697e4bcbf5
parent 19451	536333350448
child 19559	d35a89d5c0ec