hg/stx-libbasic: comparison Array.st

equal deleted inserted replaced

-:501217c542a5
+:6fe0dc1d5377
 "
 !
 documentation
 "
 Instances of Array store general objects; the arrays size is fixed,
 therefore add:/remove: are not allowed.
 (actually, #add: is implemented for compatibility with smalltalks which
 provide it, but it is very slow and outputs an annoying warning message ...)
 Access to the individual elements is via an integer index,
 using the well-known access messages #at: and #at:put:.
 Since Arrays are used very often in the system (either directly or a data-container
 of more complex collection classes), some methods have been tuned by reimplementing
 them as primitives. Also, the compiler inline-codes some operations
 (especially: the above accessing messages).
 Notice that Array is a built-in class
 (i.e. the VM knows about its representation).
 Therefore it is NOT possible to add named instance variables or change
 Arrays inheritance.
 However, subclassing is allowed of course
 - even with added named instance variables.
 Literal arrays (i.e. array-constants) are entered in source as:
 	#( element1 element2 ... element-n)
 	^ nil
 ].
 "
 memory allocation failed.
 When we arrive here, there was no memory, even after
 a garbage collect.
 This means, that the VM wanted to get some more memory from the
 Operatingsystem, which was not kind enough to give it.
 Bad luck - you should increase the swap space on your machine.
 "
 ^ ObjectMemory allocationFailureSignal raise.
 !
 !Array methodsFor:'accessing'!
 at:index
 "return the indexed instance variable with index, anInteger.
 Reimplemented here to avoid the additional at:->basicAt: send
 (which we can do here, since when arriving here, #at: is obviously not
 redefined in a subclass).
 This method is the same as basicAt:."
 %{  /* NOCONTEXT */
 !Array methodsFor:'copying'!
 copyWith:something
 "return a new collection containing the receivers elements
 and the single new element, newElement.
 This is different from concatentation, which expects another collection
 as argument, but equivalent to copy-and-addLast.
 Reimplemented for speed if receiver is an Array.
 (since the inherited copyWith uses replaceFromTo:, which is also
 tuned, it is questionable, if we need this)"
 unsigned int nIndex;
 REGISTER OBJ *srcP, *dstP;
 REGISTER int spc;
 if (__qClass(self) == Array) {
-sz = __qSize(self) + sizeof(OBJ);
+	sz = __qSize(self) + sizeof(OBJ);
-__PROTECT2__(something, self);
+	__PROTECT2__(something, self);
-__qAlignedNew(nObj, sz);        /* OBJECT ALLOCATION */
+	__qAlignedNew(nObj, sz);        /* OBJECT ALLOCATION */
-__UNPROTECT2__(self, something);
+	__UNPROTECT2__(self, something);
-if (nObj) {
+	if (nObj) {
-__InstPtr(nObj)->o_class = Array;
+	    __InstPtr(nObj)->o_class = Array;
-__qSTORE(nObj, Array);
+	    __qSTORE(nObj, Array);
-nIndex = __BYTES2OBJS__(sz - OHDR_SIZE - sizeof(OBJ));
+	    nIndex = __BYTES2OBJS__(sz - OHDR_SIZE - sizeof(OBJ));
-/*
+	    /*
-* sorry:
+	     * sorry:
-*   cannot use bcopy, since we must take care of stores ...
+	     *   cannot use bcopy, since we must take care of stores ...
-*   could check for: notRemembered + inOld + notLifoRem
+	     *   could check for: notRemembered + inOld + notLifoRem
-*                  + not incrGCRunning
+	     *                  + not incrGCRunning
-* but: copyWith is not heavily used by real programmers ...
+	     * but: copyWith is not heavily used by real programmers ...
-*/
+	     */
-spc = __qSpace(nObj);
+	    spc = __qSpace(nObj);
-srcP = __arrayVal(self);
+	    srcP = __arrayVal(self);
-dstP = __arrayVal(nObj);
+	    dstP = __arrayVal(nObj);
 #ifdef __UNROLL_LOOPS__
-while (nIndex >= 4) {
+	    while (nIndex >= 4) {
-OBJ element;
+		OBJ element;
-element = srcP[0];
+		element = srcP[0];
-dstP[0] = element;
+		dstP[0] = element;
-__STORE_SPC(nObj, element, spc);
+		__STORE_SPC(nObj, element, spc);
-element = srcP[1];
+		element = srcP[1];
-dstP[1] = element;
+		dstP[1] = element;
-__STORE_SPC(nObj, element, spc);
+		__STORE_SPC(nObj, element, spc);
-element = srcP[2];
+		element = srcP[2];
-dstP[2] = element;
+		dstP[2] = element;
-__STORE_SPC(nObj, element, spc);
+		__STORE_SPC(nObj, element, spc);
-element = srcP[3];
+		element = srcP[3];
-dstP[3] = element;
+		dstP[3] = element;
-__STORE_SPC(nObj, element, spc);
+		__STORE_SPC(nObj, element, spc);
-srcP += 4;
+		srcP += 4;
-dstP += 4;
+		dstP += 4;
-nIndex -= 4;
+		nIndex -= 4;
-}
+	    }
 #endif
-while (nIndex--) {
+	    while (nIndex--) {
-OBJ element;
+		OBJ element;
-element = *srcP++;
+		element = *srcP++;
-*dstP++ = element;
+		*dstP++ = element;
-__STORE_SPC(nObj, element, spc);
+		__STORE_SPC(nObj, element, spc);
-}
+	    }
-*dstP = something;
+	    *dstP = something;
-__STORE_SPC(nObj, something, spc);
+	    __STORE_SPC(nObj, something, spc);
-RETURN ( nObj );
+	    RETURN ( nObj );
-}
+	}
 }
 %}.
 ^ super copyWith:something
 ! !
 |stop "{ Class: SmallInteger }"|
 stop := self size.
 1 to:stop do:[:idx |
-|each|
+	|each|
-each := self at:idx.
+	each := self at:idx.
-each notNil ifTrue:[
+	each notNil ifTrue:[
-aCollection add:each.
+	    aCollection add:each.
-].
+	].
 ].
 ^ aCollection
 "
 #(1 2 3 4 5 1 2 3 symbol 'string' nil) addAllNonNilElementsTo:Set new
 |stop "{ Class: SmallInteger }"|
 stop := self size.
 1 to:stop do:[:idx |
-aCollection add:(self at:idx)
+	aCollection add:(self at:idx)
 ].
 ^ aCollection
 !
 do:aBlock
 			__interpret(aBlock, 1, nil, IBLOCK_ARG, nil, nil, &(__InstPtr(self)->i_instvars[index]));
 #else
 			__interpret(aBlock, 1, nil, IBLOCK_ARG, nil, nil, __InstPtr(self)->i_instvars[index]);
 #endif
 		    } else {
 			(*val.ilc_func)(aBlock,
 					    @symbol(value:),
 					    nil, &val,
 					    __InstPtr(self)->i_instvars[index]);
 		    }
 		}
 	    }
 	/*
 	 * not a block - send it #value:
 	 */
 	for (; index < nIndex; index++) {
 	    if (InterruptPending != nil) __interruptL(@line);
-console_printf("el%d -> %lx\n", index, (long)(__InstPtr(self)->i_instvars[index]));
+	    // console_printf("el%d -> %"_lx_"\n", index, (long)(__InstPtr(self)->i_instvars[index]));
 	    (*val.ilc_func)(aBlock,
 				@symbol(value:),
 				nil, &val,
 				__InstPtr(self)->i_instvars[index]);
 	}
 	RETURN ( self );
 }
 /*
 * I am something, not handled here
 */
 %}.
 ^ super do:aBlock
 !
 			    __interpret(aBlock, 1, nil, IBLOCK_ARG, nil, nil, &el);
 #else
 			    __interpret(aBlock, 1, nil, IBLOCK_ARG, nil, nil, el);
 #endif
 			} else {
 			    (*val.ilc_func)(aBlock,
 					    @symbol(value:),
 					    nil, &val,
 					    el);
 			}
 		    }
 		    n--;
 		    index++;
 	     * not a block - send it #value:
 	     */
 	    while (n > 0) {
 		if (InterruptPending != nil) __interruptL(@line);
 		(*val.ilc_func)(aBlock,
 				@symbol(value:),
 				nil, &val,
 				__InstPtr(self)->i_instvars[index]);
 		n--;
 		index++;
 	    }
 	    RETURN ( self );
 			    __interpret(aBlock, 1, nil, IBLOCK_ARG, nil, nil, &(__InstPtr(self)->i_instvars[index]));
 #else
 			    __interpret(aBlock, 1, nil, IBLOCK_ARG, nil, nil, __InstPtr(self)->i_instvars[index]);
 #endif
 			} else {
 			    (*val.ilc_func)(aBlock,
 					    @symbol(value:),
 					    nil, &val,
 					    __InstPtr(self)->i_instvars[index]);
 			}
 		    }
 		}
 	     * not a block - send it #value:
 	     */
 	    for (index=indexHigh; index >= indexLow; index--) {
 		if (InterruptPending != nil) __interruptL(@line);
 		(*val.ilc_func)(aBlock,
 				@symbol(value:),
 				nil, &val,
 				__InstPtr(self)->i_instvars[index]);
 	    }
 	    RETURN ( self );
 	}
 }
 				(*codeVal)(BLOCK_ARG, __mkSmallInteger(index), el);
 			    }
 			    RETURN (self);
 		interruptX:
 			    __interruptL(@line);
 			    el = __InstPtr(self)->i_instvars[index];
 			    goto continueX;
 			}
 		    }
 		}
 			    }
 #else
 			    __interpret(aBlock, 2, nil, IBLOCK_ARG, nil, nil, __mkSmallInteger(index), el);
 #endif
 			} else {
 			    (*val2.ilc_func)(aBlock,
 						@symbol(value:value:),
 						nil, &val2,
 						__mkSmallInteger(index),
 						el);
 			}
 		    }
 		}
 		if (InterruptPending != nil) __interruptL(@line);
 		el = __InstPtr(self)->i_instvars[index];
 		index++;
 		(*val2.ilc_func)(aBlock,
 				    @symbol(value:value:),
 				    nil, &val2,
 				    __mkSmallInteger(index),
 				    el);
 	    }
 	    RETURN ( self );
 	}
 }
 %}.
 ^ super keysAndValuesDo:aBlock
 !
 modifyingTraverse:aBlock
 "Evaluate aBlock for every element that is not an Array,
 and recursively traverse Arrays.
 aBlock may return the original element or a new element.
 If a new element is returned, the element is changed to the new element."
 self
-keysAndValuesDo:[:eachIndex :eachElement |
+	keysAndValuesDo:[:eachIndex :eachElement |
-eachElement isArray ifTrue:[
+	    eachElement isArray ifTrue:[
-eachElement modifyingTraverse:aBlock
+		eachElement modifyingTraverse:aBlock
-] ifFalse:[
+	    ] ifFalse:[
-|newElement|
+		|newElement|
-newElement := aBlock value:eachElement.
+		newElement := aBlock value:eachElement.
-newElement ~~ eachElement ifTrue:[
+		newElement ~~ eachElement ifTrue:[
-self at:eachIndex put:newElement.
+		    self at:eachIndex put:newElement.
-].
+		].
-]
+	    ]
-].
+	].
 "
 example: replace all elements which are 10 with: 'changed'
 #(1 2 (3 (4 5 (6 7) 8) 9 10) 11 (12 (13)) 14) copy
-modifyingTraverse:[:el |
+	 modifyingTraverse:[:el |
-el = 10 ifTrue:['changed'] ifFalse:[el]
+	    el = 10 ifTrue:['changed'] ifFalse:[el]
-];
+	 ];
-inspect
+	 inspect
 "
 !
 reverseDo:aBlock
 "evaluate the argument, aBlock for each element in the collection in reverse order.
 			    __interpret(aBlock, 1, nil, IBLOCK_ARG, nil, nil, &(__InstPtr(self)->i_instvars[index]));
 #else
 			    __interpret(aBlock, 1, nil, IBLOCK_ARG, nil, nil, __InstPtr(self)->i_instvars[index]);
 #endif
 			} else {
 			    (*val.ilc_func)(aBlock,
 					    @symbol(value:),
 					    nil, &val,
 					    __InstPtr(self)->i_instvars[index]);
 			}
 		    }
 		}
 	     * not a block - send it #value:
 	     */
 	    for (index=nIndex-1; index >= endIndex; index--) {
 		if (InterruptPending != nil) __interruptL(@line);
 		(*val.ilc_func)(aBlock,
 				@symbol(value:),
 				nil, &val,
 				__InstPtr(self)->i_instvars[index]);
 	    }
 	    RETURN ( self );
 	}
 }
 %}.
 ^ super reverseDo:aBlock
 !
 traverse:aBlock
 "Evaluate aBlock for every element that is not an Array,
 and recursively traverse Arrays.
 Implemented here to support better search for selectors in
 literal arrays - might be a good idea to move it up in the collection
 hierarchy, since this may be a useful method for other collections
 as well."
 |s|
 s := WriteStream on:Array new.
 #(1 2 (3 (4 5 (6 7) 8) 9 10) 11 (12 (13)) 14) traverse:[:el | s nextPut:el].
 s contents
 "
 "
 example: deep search
 #(1 2 (3 (4 5 (6 7) 8) 9 10) 11 (12 (13)) 14) traverse:[:el |
 	el == 10 ifTrue:[Transcript showCR:'found']
 ]
 "
 "Modified: 26.3.1996 / 17:08:10 / cg"
 		}
 #else
 # ifdef FAST_MEMSET
 		if ((INT)anObject == 0) {
 		    memset(dst, 0, __OBJS2BYTES__(endIndex-index+1));
 		} else
 # endif
 		{
 # ifdef __UNROLL_LOOPS__
 		    {
 			int i8;
 int repStopIndex;
 REGISTER int repStartIndex;
 REGISTER OBJ t;
 REGISTER int count;
 OBJ myClass;
 if (
 	(__ClassInstPtr((myClass = __qClass(self)))->c_ninstvars == __mkSmallInteger(0))
 && __isNonNilObject(aCollection)
 && (((t = __qClass(aCollection)) == Array) || (t == myClass))
 && __bothSmallInteger(start, stop)
 		    repStopIndex = repStartIndex + (stopIndex - startIndex);
 		    if (repStopIndex < repNIndex) {
 			src = &(__InstPtr(aCollection)->i_instvars[repStartIndex]);
 			dst = &(__InstPtr(self)->i_instvars[startIndex]);
 			if (aCollection == self) {
 			    /*
 			     * no need to check stores if copying
 			     * from myself
 			     */
 			    /*
 			     * take care of overlapping copy
 			     * do not depend on memset being smart enough
 			     * (some are not ;-)
 			     */
 			    if (src < dst) {
 			    }
 #ifdef SOFTWARE_PIPELINE
 			    {
 				OBJ t1;
 				/*
 				 * the loop below fetches one longWord behind
 				 * this should not be a problem
 				 */
 				t1 = src[0];
 				count--;
 !Array methodsFor:'printing & storing'!
 displayStringName
 self class == Array ifTrue:[
-^ '#'
+	^ '#'
 ].
 ^ super displayStringName.
 !
 printOn:aStream
 "append a printed representation of the receiver to aStream"
 self isLiteral ifTrue:[
-|limit firstOne s|
+	|limit firstOne s|
-thisContext isRecursive ifTrue:[
+	thisContext isRecursive ifTrue:[
-'Array [error]: printOn: of self referencing collection.' errorPrintCR.
+	    'Array [error]: printOn: of self referencing collection.' errorPrintCR.
-aStream nextPutAll:'#("recursive")'.
+	    aStream nextPutAll:'#("recursive")'.
-^ self
+	    ^ self
-].
+	].
-aStream nextPutAll:'#('.
+	aStream nextPutAll:'#('.
-firstOne := true.
+	firstOne := true.
-"
+	"
-if aStream is not positionable, create an temporary positionable stream
+	 if aStream is not positionable, create an temporary positionable stream
-(needed for limit calculation)
+	 (needed for limit calculation)
-"
+	"
-aStream isPositionable ifTrue:[
+	aStream isPositionable ifTrue:[
-s := aStream.
+	    s := aStream.
-] ifFalse:[
+	] ifFalse:[
-s := WriteStream on:(String uninitializedNew:50).
+	    s := WriteStream on:(String uninitializedNew:50).
-].
+	].
-limit := s position1Based + self maxPrint.
+	limit := s position1Based + self maxPrint.
-self printElementsDo:[:element |
+	self printElementsDo:[:element |
-firstOne ifFalse:[
+	    firstOne ifFalse:[
-s space
+		s space
-] ifTrue:[
+	    ] ifTrue:[
-firstOne := false
+		firstOne := false
-].
+	    ].
-(s position1Based >= limit) ifTrue:[
+	    (s position1Based >= limit) ifTrue:[
-s ~~ aStream ifTrue:[
+		s ~~ aStream ifTrue:[
-aStream nextPutAll:(s contents).
+		    aStream nextPutAll:(s contents).
-].
+		].
-aStream nextPutAll:'...etc...)'.
+		aStream nextPutAll:'...etc...)'.
-^ self
+		^ self
-] ifFalse:[
+	    ] ifFalse:[
-element printOn:s.
+		element printOn:s.
-].
+	    ].
-].
+	].
-s ~~ aStream ifTrue:[
+	s ~~ aStream ifTrue:[
-aStream nextPutAll:(s contents).
+	    aStream nextPutAll:(s contents).
-].
+	].
-aStream nextPut:$)
+	aStream nextPut:$)
 ] ifFalse:[
-super printOn:aStream
+	super printOn:aStream
 ]
 "
 #(1 2 $a 'hello' sym kewordSymbol:with: #'funny symbol') printString
 #(1 2 $a [1 2 3] true false nil #true #false #nil) printString
 "
 "Created: 20.11.1995 / 11:16:58 / cg"
 !
 storeArrayElementOn:aStream
 "Store as element of an array. Omit the leading '#'"
 self isLiteral ifTrue:[
-aStream nextPut:$(.
+	aStream nextPut:$(.
-self
+	self
-do:[:element | element storeArrayElementOn:aStream]
+	    do:[:element | element storeArrayElementOn:aStream]
-separatedBy:[aStream space].
+	    separatedBy:[aStream space].
-aStream nextPut:$).
+	aStream nextPut:$).
-^ self.
+	^ self.
 ].
 super storeArrayElementOn:aStream
 "
 #(1 2 3 4 5) storeOn:Transcript
 #(1 2 3 4 5) storeArrayElementOn:Transcript
 "
 !
 storeOn:aStream
 "append a printed representation of the receiver to aStream,
 which allows reconstructing it via readFrom:.
 Redefined to output a somewhat more user friendly string."
 self isLiteral ifTrue:[
-aStream nextPutAll:'#('.
+	aStream nextPutAll:'#('.
-self do:[:element | element storeArrayElementOn:aStream]
+	self do:[:element | element storeArrayElementOn:aStream]
-separatedBy:[aStream space].
+	     separatedBy:[aStream space].
-aStream nextPut:$)
+	aStream nextPut:$)
 ] ifFalse:[
-super storeOn:aStream
+	super storeOn:aStream
 ]
 "
 #(1 2 $a 'hello' sym kewordSymbol:with: #'funny symbol') storeString
 #(1 2 $a [1 2 3] true false nil #true #false #nil) storeString
 "
 "Created: 20.11.1995 / 11:16:58 / cg"
 ! !
 refersToLiteral:aLiteral
 "return true if the receiver or recursively any array element in the
 receiver referes to aLiteral (i.e. a deep search)"
 self do: [ :el |
 	el == aLiteral ifTrue:[^true].
 	el class == Array ifTrue:[
 	    (el refersToLiteral: aLiteral) ifTrue: [^true]
 	]
 ].
 ^ false
 "
 #(1 2 3) refersToLiteral:#foo
 #(1 2 3 foo bar baz) refersToLiteral:#foo
 #(1 2 3 (((bar foo))) bar baz) refersToLiteral:#foo
 "
 "Modified: / 18.8.2000 / 21:18:14 / cg"
 !
 refersToLiteralMatching:aMatchPattern
 "return true if the receiver or recursively any array element in the
 receiver is symbolic and matches aMatchPattern (i.e. a deep search)"
 self do:[ :el |
-(el isSymbol and:[ aMatchPattern match: el]) ifTrue:[^true].
+	(el isSymbol and:[ aMatchPattern match: el]) ifTrue:[^true].
-el class == Array ifTrue:[
+	el class == Array ifTrue:[
-(el refersToLiteralMatching: aMatchPattern) ifTrue: [^true]
+	    (el refersToLiteralMatching: aMatchPattern) ifTrue: [^true]
-]
+	]
 ].
 ^ false
 "
 #(1 2 3) refersToLiteralMatching:#foo
 #(1 2 3 foo bar baz) refersToLiteralMatching:#foo
 #(1 2 3 (((bar foo))) bar baz) refersToLiteralMatching:#foo
 "
 "Modified: / 18-08-2000 / 21:18:14 / cg"
 "Created: / 26-07-2012 / 15:38:01 / cg"
 !
 %}
 ! !
 !Array methodsFor:'searching'!
 identityIndexOf:anElement or:alternative
 "search the array for anElement or alternative;
 return the index of anElement if found, or the index of anAlternative,
 if not found. If anAlternative is also not found, return 0.
 This is a special interface for high-speed searching in an array
 and at the same time searching for an empty slot.
 Do not use this method for your application classes, since it is
 index = 0;
 nInsts = __intVal(__ClassInstPtr(__qClass(self))->c_ninstvars);
 index += nInsts;
 nIndex = __BYTES2OBJS__(__qSize(self) - OHDR_SIZE);
 el1 = anElement; el2 = alternative;
 op = & (__InstPtr(self)->i_instvars[index]);
 while (index++ < nIndex) {
 	if ((o = *op++) == el1) {
 	    RETURN ( __mkSmallInteger(index - nInsts) );
 	}
 "
 #(1 2 3 4 5 6 7 8 9) identityIndexOf:3 or:5
 #(1 2 0 4 5 6 7 8 9) identityIndexOf:3 or:5
 #(1 2 0 4 5 6 7 3 9) identityIndexOf:3 or:5
 #(1 2 3 4 5 nil 7 3 9) identityIndexOf:3 or:nil
 #(1 2 nil 4 5 6 7 3 9) identityIndexOf:3 or:nil
 #(1 2 nil 4 5 6 7 8 9) identityIndexOf:3 or:nil
 #() identityIndexOf:3 or:nil
 #(1 2) identityIndexOf:3 or:nil
 "
 !
 identityIndexOf:anElement startingAt:start
 "search the array for anElement; return index if found, 0 otherwise
 		OBJ *p;
 		p = memsrch4(op, (INT)el, (nIndex - index));
 		if (p) {
 		    index += (p - op + 1);
 		    RETURN ( __mkSmallInteger(index) );
 		}
 	    }
 #else
 # ifdef __UNROLL_LOOPS__
 		 * when found; without the goto, we branch always.
 		 * Pipelined CPUs do usually not like taken branches.
 		 */
 		unsigned int i8;
 		while ((i8 = index + 8) < nIndex) {
 		    if (op[0] == el) goto found1;
 		    if (op[1] == el) goto found2;
 		    if (op[2] == el) goto found3;
 		    if (op[3] == el) goto found4;
 %}.
 ^ super identityIndexOf:anElement startingAt:start
 !
 identityIndexOf:anElement startingAt:start endingAt:stop
 "search the array for anElement in the range start..stop;
 return the index if found, 0 otherwise.
 - reimplemented for speed when searching in OrderedCollections"
 %{  /* NOCONTEXT */
 		OBJ *p;
 		p = memsrch4(op, (INT)el, (lastIndex - index));
 		if (p) {
 		    index += (p - op + 1);
 		    RETURN ( __mkSmallInteger(index) );
 		}
 	    }
 #else
 # ifdef __UNROLL_LOOPS__
 static struct inlineCache eq = _ILC1;
 OBJ myClass, e;
 myClass = __qClass(self);
 if ( __isSmallInteger(start) ) {
-index = __intVal(start) - 1;
+	index = __intVal(start) - 1;
-if (index >= 0) {
+	if (index >= 0) {
-nInsts = __intVal(__ClassInstPtr(myClass)->c_ninstvars);
+	    nInsts = __intVal(__ClassInstPtr(myClass)->c_ninstvars);
-index += nInsts;
+	    index += nInsts;
-nIndex = __BYTES2OBJS__(__qSize(self) - OHDR_SIZE);
+	    nIndex = __BYTES2OBJS__(__qSize(self) - OHDR_SIZE);
-e = anElement;
+	    e = anElement;
-if (e != nil) {
+	    if (e != nil) {
-/*
+		/*
-* special kludge to search for a string;
+		 * special kludge to search for a string;
-* this is so common, that its worth a special case
+		 * this is so common, that its worth a special case
-*/
+		 */
 #define SPECIAL_STRING_OPT
 #ifdef SPECIAL_STRING_OPT
-if (__isStringLike(e)) {
+		if (__isStringLike(e)) {
-while (index < nIndex) {
+		    while (index < nIndex) {
-element = __InstPtr(self)->i_instvars[index++];
+			element = __InstPtr(self)->i_instvars[index++];
-if (__isNonNilObject(element)) {
+			if (__isNonNilObject(element)) {
-if (element == e) {
+			    if (element == e) {
-RETURN ( __mkSmallInteger(index - nInsts) );
+				RETURN ( __mkSmallInteger(index - nInsts) );
-}
+			    }
-if (__qClass(element) == @global(String)) {
+			    if (__qClass(element) == @global(String)) {
-if (strcmp(__stringVal(e), __stringVal(element)) == 0) {
+				if (strcmp(__stringVal(e), __stringVal(element)) == 0) {
-RETURN ( __mkSmallInteger(index - nInsts) );
+				    RETURN ( __mkSmallInteger(index - nInsts) );
-}
+				}
-} else {
+			    } else {
-if ((*eq.ilc_func)(e, @symbol(=), nil,&eq, element) == true) {
+				if ((*eq.ilc_func)(e, @symbol(=), nil,&eq, element) == true) {
-RETURN ( __mkSmallInteger(index - nInsts) );
+				    RETURN ( __mkSmallInteger(index - nInsts) );
-}
+				}
-/*
+				/*
-* send of #= could have lead to a GC - refetch e
+				 * send of #= could have lead to a GC - refetch e
-*/
+				 */
-e = anElement;
+				e = anElement;
-}
+			    }
-}
+			}
-}
+		    }
-RETURN (__mkSmallInteger(0));
+		    RETURN (__mkSmallInteger(0));
-}
+		}
 #endif
 #ifdef MAKES_IT_SLOWER_BUT_WHY
-if (__isSmallInteger(e)) {
+		if (__isSmallInteger(e)) {
-/* search for a small number */
+		    /* search for a small number */
-while (index < nIndex) {
+		    while (index < nIndex) {
-element = __InstPtr(self)->i_instvars[index++];
+			element = __InstPtr(self)->i_instvars[index++];
-if (element == e) {
+			if (element == e) {
-RETURN ( __mkSmallInteger(index - nInsts) );
+			    RETURN ( __mkSmallInteger(index - nInsts) );
-}
+			}
-if (!__isSmallInteger(element)) {
+			if (!__isSmallInteger(element)) {
-if (element != nil) {
+			    if (element != nil) {
-if ((*eq.ilc_func)(e,
+				if ((*eq.ilc_func)(e,
-@symbol(=),
+						   @symbol(=),
-nil,&eq,
+						   nil,&eq,
-element) == true) {
+						   element) == true) {
-RETURN ( __mkSmallInteger(index - nInsts) );
+				    RETURN ( __mkSmallInteger(index - nInsts) );
-}
+				}
-/*
+				/*
-* send of #= could have lead to a GC - refetch e
+				 * send of #= could have lead to a GC - refetch e
-*/
+				 */
-e = anElement;
+				e = anElement;
-}
+			    }
-}
+			}
-}
+		    }
-RETURN (__mkSmallInteger(0));
+		    RETURN (__mkSmallInteger(0));
-}
+		}
 #endif /* MAKES_IT_SLOWER_BUT_WHY */
-while (index < nIndex) {
+		while (index < nIndex) {
-element = __InstPtr(self)->i_instvars[index++];
+		    element = __InstPtr(self)->i_instvars[index++];
-if (element != nil) {
+		    if (element != nil) {
-if ((element == e)
+			if ((element == e)
-|| ((*eq.ilc_func)(e,
+			 || ((*eq.ilc_func)(e,
-@symbol(=),
+					    @symbol(=),
-nil,&eq,
+					    nil,&eq,
-element) == true)) {
+					    element) == true)) {
-RETURN ( __mkSmallInteger(index - nInsts) );
+			    RETURN ( __mkSmallInteger(index - nInsts) );
-}
+			}
-/*
+			/*
-* send of #= could have lead to a GC - refetch e
+			 * send of #= could have lead to a GC - refetch e
-*/
+			 */
-e = anElement;
+			e = anElement;
-}
+		    }
-}
+		}
-} else {
+	    } else {
-OBJ slf = self;
+		OBJ slf = self;
-/*
+		/*
-* search for nil - do an identity-search
+		 * search for nil - do an identity-search
-*/
+		 */
 #ifdef __UNROLL_LOOPS__
-{
+		{
-unsigned int i8;
+		    unsigned int i8;
-while ((i8 = index + 8) < nIndex) {
+		    while ((i8 = index + 8) < nIndex) {
-if (__InstPtr(slf)->i_instvars[index] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 1) ); }
+			if (__InstPtr(slf)->i_instvars[index] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 1) ); }
-if (__InstPtr(slf)->i_instvars[index+1] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 2) ); }
+			if (__InstPtr(slf)->i_instvars[index+1] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 2) ); }
-if (__InstPtr(slf)->i_instvars[index+2] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 3) ); }
+			if (__InstPtr(slf)->i_instvars[index+2] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 3) ); }
-if (__InstPtr(slf)->i_instvars[index+3] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 4) ); }
+			if (__InstPtr(slf)->i_instvars[index+3] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 4) ); }
-if (__InstPtr(slf)->i_instvars[index+4] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 5) ); }
+			if (__InstPtr(slf)->i_instvars[index+4] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 5) ); }
-if (__InstPtr(slf)->i_instvars[index+5] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 6) ); }
+			if (__InstPtr(slf)->i_instvars[index+5] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 6) ); }
-if (__InstPtr(slf)->i_instvars[index+6] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 7) ); }
+			if (__InstPtr(slf)->i_instvars[index+6] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 7) ); }
-if (__InstPtr(slf)->i_instvars[index+7] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 8) ); }
+			if (__InstPtr(slf)->i_instvars[index+7] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 8) ); }
-index = i8;
+			index = i8;
-}
+		    }
-}
+		}
 #endif
-while (index < nIndex) {
+		while (index < nIndex) {
-if (__InstPtr(slf)->i_instvars[index++] == nil) {
+		    if (__InstPtr(slf)->i_instvars[index++] == nil) {
-RETURN ( __mkSmallInteger(index - nInsts) );
+			RETURN ( __mkSmallInteger(index - nInsts) );
-}
+		    }
-}
+		}
-}
+	    }
-}
+	}
-RETURN (__mkSmallInteger(0));
+	RETURN (__mkSmallInteger(0));
 }
 %}.
 ^ super indexOf:anElement startingAt:start
 !
 indexOf:anElement startingAt:start endingAt:stop
 "search the array for anElement in the range start..stop;
 Return the index if found, 0 otherwise.
 - reimplemented for speed when searching in OrderedCollections"
 |element|
 %{
 static struct inlineCache eq = _ILC1;
 OBJ myClass, e;
 myClass = __qClass(self);
 if ( __bothSmallInteger(start, stop) ) {
-index = __intVal(start) - 1;
+	index = __intVal(start) - 1;
-if (index >= 0) {
+	if (index >= 0) {
-nInsts = __intVal(__ClassInstPtr(myClass)->c_ninstvars);
+	    nInsts = __intVal(__ClassInstPtr(myClass)->c_ninstvars);
-index += nInsts;
+	    index += nInsts;
-lastIndex = nInsts + __intVal(stop);
+	    lastIndex = nInsts + __intVal(stop);
-nIndex = __BYTES2OBJS__(__qSize(self) - OHDR_SIZE);
+	    nIndex = __BYTES2OBJS__(__qSize(self) - OHDR_SIZE);
-if (nIndex < lastIndex) {
+	    if (nIndex < lastIndex) {
-lastIndex = nIndex;
+		lastIndex = nIndex;
-}
+	    }
-e = anElement;
+	    e = anElement;
-if (e != nil) {
+	    if (e != nil) {
-/*
+		/*
-* special kludge to search for a string;
+		 * special kludge to search for a string;
-* this is so common, that its worth a special case
+		 * this is so common, that its worth a special case
-*/
+		 */
 #define SPECIAL_STRING_OPT
 #ifdef SPECIAL_STRING_OPT
-if (__isStringLike(e)) {
+		if (__isStringLike(e)) {
-while (index < lastIndex) {
+		    while (index < lastIndex) {
-element = __InstPtr(self)->i_instvars[index++];
+			element = __InstPtr(self)->i_instvars[index++];
-if (__isNonNilObject(element)) {
+			if (__isNonNilObject(element)) {
-if (element == e) {
+			    if (element == e) {
-RETURN ( __mkSmallInteger(index - nInsts) );
+				RETURN ( __mkSmallInteger(index - nInsts) );
-}
+			    }
-if (__qClass(element) == @global(String)) {
+			    if (__qClass(element) == @global(String)) {
-if (strcmp(__stringVal(e), __stringVal(element)) == 0) {
+				if (strcmp(__stringVal(e), __stringVal(element)) == 0) {
-RETURN ( __mkSmallInteger(index - nInsts) );
+				    RETURN ( __mkSmallInteger(index - nInsts) );
-}
+				}
-} else {
+			    } else {
-if ((*eq.ilc_func)(e, @symbol(=), nil,&eq, element) == true) {
+				if ((*eq.ilc_func)(e, @symbol(=), nil,&eq, element) == true) {
-RETURN ( __mkSmallInteger(index - nInsts) );
+				    RETURN ( __mkSmallInteger(index - nInsts) );
-}
+				}
-/*
+				/*
-* send of #= could have lead to a GC - refetch e
+				 * send of #= could have lead to a GC - refetch e
-*/
+				 */
-e = anElement;
+				e = anElement;
-}
+			    }
-}
+			}
-}
+		    }
-RETURN (__mkSmallInteger(0));
+		    RETURN (__mkSmallInteger(0));
-}
+		}
 #endif
-if (__isSmallInteger(e)) {
+		if (__isSmallInteger(e)) {
-/* search for a small number */
+		    /* search for a small number */
-while (index < lastIndex) {
+		    while (index < lastIndex) {
-element = __InstPtr(self)->i_instvars[index++];
+			element = __InstPtr(self)->i_instvars[index++];
-if (element == e) {
+			if (element == e) {
-RETURN ( __mkSmallInteger(index - nInsts) );
+			    RETURN ( __mkSmallInteger(index - nInsts) );
-}
+			}
-if (!__isSmallInteger(element)) {
+			if (!__isSmallInteger(element)) {
-if ((*eq.ilc_func)(e,
+			    if ((*eq.ilc_func)(e,
-@symbol(=),
+						@symbol(=),
-nil,&eq,
+						nil,&eq,
-element) == true) {
+						element) == true) {
-RETURN ( __mkSmallInteger(index - nInsts) );
+				RETURN ( __mkSmallInteger(index - nInsts) );
-}
+			    }
-/*
+			    /*
-* send of #= could have lead to a GC - refetch e
+			     * send of #= could have lead to a GC - refetch e
-*/
+			     */
-e = anElement;
+			    e = anElement;
-}
+			}
-}
+		    }
-RETURN (__mkSmallInteger(0));
+		    RETURN (__mkSmallInteger(0));
-}
+		}
-while (index < lastIndex) {
+		while (index < lastIndex) {
-element = __InstPtr(self)->i_instvars[index++];
+		    element = __InstPtr(self)->i_instvars[index++];
-if (element != nil) {
+		    if (element != nil) {
-e = anElement;
+			e = anElement;
-if ((element == e)
+			if ((element == e)
-|| ((*eq.ilc_func)(e,
+			 || ((*eq.ilc_func)(e,
-@symbol(=),
+					    @symbol(=),
-nil,&eq,
+					    nil,&eq,
-element) == true)) {
+					    element) == true)) {
-RETURN ( __mkSmallInteger(index - nInsts) );
+			    RETURN ( __mkSmallInteger(index - nInsts) );
-}
+			}
-}
+		    }
-}
+		}
-} else {
+	    } else {
-OBJ slf = self;
+		OBJ slf = self;
-/*
+		/*
-* search for nil - do an identity-search
+		 * search for nil - do an identity-search
-*/
+		 */
 #ifdef __UNROLL_LOOPS__
-{
+		{
-unsigned int i8;
+		    unsigned int i8;
-while ((i8 = index + 8) < lastIndex) {
+		    while ((i8 = index + 8) < lastIndex) {
-if (__InstPtr(slf)->i_instvars[index] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 1) ); }
+			if (__InstPtr(slf)->i_instvars[index] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 1) ); }
-if (__InstPtr(slf)->i_instvars[index+1] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 2) ); }
+			if (__InstPtr(slf)->i_instvars[index+1] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 2) ); }
-if (__InstPtr(slf)->i_instvars[index+2] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 3) ); }
+			if (__InstPtr(slf)->i_instvars[index+2] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 3) ); }
-if (__InstPtr(slf)->i_instvars[index+3] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 4) ); }
+			if (__InstPtr(slf)->i_instvars[index+3] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 4) ); }
-if (__InstPtr(slf)->i_instvars[index+4] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 5) ); }
+			if (__InstPtr(slf)->i_instvars[index+4] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 5) ); }
-if (__InstPtr(slf)->i_instvars[index+5] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 6) ); }
+			if (__InstPtr(slf)->i_instvars[index+5] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 6) ); }
-if (__InstPtr(slf)->i_instvars[index+6] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 7) ); }
+			if (__InstPtr(slf)->i_instvars[index+6] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 7) ); }
-if (__InstPtr(slf)->i_instvars[index+7] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 8) ); }
+			if (__InstPtr(slf)->i_instvars[index+7] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 8) ); }
-index = i8;
+			index = i8;
-}
+		    }
-}
+		}
 #endif
-while (index < lastIndex) {
+		while (index < lastIndex) {
-if (__InstPtr(slf)->i_instvars[index++] == nil) {
+		    if (__InstPtr(slf)->i_instvars[index++] == nil) {
-RETURN ( __mkSmallInteger(index - nInsts) );
+			RETURN ( __mkSmallInteger(index - nInsts) );
-}
+		    }
-}
+		}
-}
+	    }
-}
+	}
-RETURN (__mkSmallInteger(0));
+	RETURN (__mkSmallInteger(0));
 }
 %}.
 ^ super indexOf:anElement startingAt:start endingAt:stop
 ! !
 - reimplemented for speed"
 |element|
 %{  /* NOCONTEXT */
 /*
 * first, do a quick check using ==
 * this does not need a context or message send.
 * In many cases this will already find a match.
 */
 REGISTER int index;
 REGISTER int index;
 REGISTER OBJ o;
 unsigned int nIndex;
 static struct inlineCache eq = _ILC1;
 /*
 * then do a slow(er) check using =
 */
 /*
 * sorry: cannot access the stuff from above ...
 */
 nIndex = __BYTES2OBJS__(__qSize(self) - OHDR_SIZE);
 index = __intVal(__ClassInstPtr(__qClass(self))->c_ninstvars);
 isLiteral
 "return true, if the receiver can be used as a literal constant in ST syntax
 (i.e. can be used in constant arrays)"
 "/ no, simply returning true here is a mistake:
 "/ it could be a subclass of Array
 "/ (of which the compiler does not know at all ...)
 self class == Array ifFalse:[^ false].
 "/
 ! !
 !Array class methodsFor:'documentation'!
 version
-^ '$Header: /cvs/stx/stx/libbasic/Array.st,v 1.153 2013-01-02 12:32:00 cg Exp $'
+^ '$Header: /cvs/stx/stx/libbasic/Array.st,v 1.154 2013-01-08 17:55:11 cg Exp $'
 !
 version_CVS
-^ '$Header: /cvs/stx/stx/libbasic/Array.st,v 1.153 2013-01-02 12:32:00 cg Exp $'
+^ '$Header: /cvs/stx/stx/libbasic/Array.st,v 1.154 2013-01-08 17:55:11 cg Exp $'
 ! !

changeset 14632	6fe0dc1d5377
parent 14623	c433536ae3ab
child 14657	6610eb2df25c