hg/stx-libbasic: comparison Array.st

equal deleted inserted replaced

-:968d8b70d805
+:e71100d13b67
 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)
+	#( element1 element2 ... element-n)
 where each element must be itself a literal constant.
 Array, symbol and byteArray constants within an array can be written
 without the initial #-character.
 In addition, true, false and nil are also allowed as array-literal.
 #('foo' (1 2) foo)      -> same as above
 #(nil true #true)       -> 3 elements: nil, true and a symbol (watch out)
 #(two [3 3 3] (4 4 4))  -> 3 elements: a symbol, a byteArray and another array
 [memory requirements:]
-OBJ-HEADER + (size * ptr-size)
+	OBJ-HEADER + (size * ptr-size)
 [warning:]
-read the warning about 'growing fixed size collection'
+	read the warning about 'growing fixed size collection'
-in ArrayedCollection's documentation
+	in ArrayedCollection's documentation
 [author:]
-Claus Gittinger
+	Claus Gittinger
 [see also:]
-OrderedCollection
+	OrderedCollection
-ByteArray FloatArray DoubleArray
+	ByteArray FloatArray DoubleArray
-String
+	String
 "
 ! !
 !Array class methodsFor:'instance creation'!
 REGISTER OBJ slf;
 REGISTER unsigned int nIndex;
 REGISTER OBJ cls;
 if (__isSmallInteger(index)) {
-indx = __intVal(index) - 1;
+	indx = __intVal(index) - 1;
-slf = self;
+	slf = self;
-nIndex = __BYTES2OBJS__(__qSize(slf) - OHDR_SIZE);
+	nIndex = __BYTES2OBJS__(__qSize(slf) - OHDR_SIZE);
-if ((cls = __qClass(slf)) != Array)
+	if ((cls = __qClass(slf)) != Array)
-indx += __intVal(__ClassInstPtr(cls)->c_ninstvars);
+	    indx += __intVal(__ClassInstPtr(cls)->c_ninstvars);
-if ((unsigned)indx < (unsigned)nIndex) {
+	if ((unsigned)indx < (unsigned)nIndex) {
-RETURN ( __InstPtr(slf)->i_instvars[indx] );
+	    RETURN ( __InstPtr(slf)->i_instvars[indx] );
-}
+	}
 }
 %}.
 ^ super at:index
 !
 REGISTER OBJ slf;
 REGISTER unsigned int nIndex;
 REGISTER OBJ cls;
 if (__isSmallInteger(index)) {
-indx = __intVal(index) - 1;
+	indx = __intVal(index) - 1;
-slf = self;
+	slf = self;
-nIndex = __BYTES2OBJS__(__qSize(slf) - OHDR_SIZE);
+	nIndex = __BYTES2OBJS__(__qSize(slf) - OHDR_SIZE);
-if ((cls = __qClass(slf)) != Array)
+	if ((cls = __qClass(slf)) != Array)
-indx += __intVal(__ClassInstPtr(cls)->c_ninstvars);
+	    indx += __intVal(__ClassInstPtr(cls)->c_ninstvars);
-if ((unsigned)indx < (unsigned)nIndex) {
+	if ((unsigned)indx < (unsigned)nIndex) {
-__InstPtr(slf)->i_instvars[indx] = anObject;
+	    __InstPtr(slf)->i_instvars[indx] = anObject;
-__STORE(slf, anObject);
+	    __STORE(slf, anObject);
-RETURN ( anObject );
+	    RETURN ( anObject );
-}
+	}
 }
 %}.
 ^ super at:index put:anObject
 "Modified: 19.4.1996 / 11:16:42 / cg"
 REGISTER OBJ slf;
 REGISTER unsigned int nIndex;
 REGISTER OBJ cls;
 if (__isSmallInteger(index)) {
-indx = __intVal(index) - 1;
+	indx = __intVal(index) - 1;
-slf = self;
+	slf = self;
-nIndex = __BYTES2OBJS__(__qSize(slf) - OHDR_SIZE);
+	nIndex = __BYTES2OBJS__(__qSize(slf) - OHDR_SIZE);
-if ((cls = __qClass(slf)) != Array)
+	if ((cls = __qClass(slf)) != Array)
-indx += __intVal(__ClassInstPtr(cls)->c_ninstvars);
+	    indx += __intVal(__ClassInstPtr(cls)->c_ninstvars);
-if ((unsigned)indx < (unsigned)nIndex) {
+	if ((unsigned)indx < (unsigned)nIndex) {
-RETURN ( __InstPtr(slf)->i_instvars[indx] );
+	    RETURN ( __InstPtr(slf)->i_instvars[indx] );
-}
+	}
 }
 %}.
 ^ super basicAt:index
 !
 REGISTER OBJ slf;
 REGISTER unsigned int nIndex;
 REGISTER OBJ cls;
 if (__isSmallInteger(index)) {
-indx = __intVal(index) - 1;
+	indx = __intVal(index) - 1;
-slf = self;
+	slf = self;
-nIndex = __BYTES2OBJS__(__qSize(slf) - OHDR_SIZE);
+	nIndex = __BYTES2OBJS__(__qSize(slf) - OHDR_SIZE);
-if ((cls = __qClass(slf)) != Array)
+	if ((cls = __qClass(slf)) != Array)
-indx += __intVal(__ClassInstPtr(cls)->c_ninstvars);
+	    indx += __intVal(__ClassInstPtr(cls)->c_ninstvars);
-if ((unsigned)indx < (unsigned)nIndex) {
+	if ((unsigned)indx < (unsigned)nIndex) {
-__InstPtr(slf)->i_instvars[indx] = anObject;
+	    __InstPtr(slf)->i_instvars[indx] = anObject;
-__STORE(slf, anObject);
+	    __STORE(slf, anObject);
-RETURN ( anObject );
+	    RETURN ( anObject );
-}
+	}
 }
 %}.
 ^ super basicAt:index put:anObject
 "Modified: 19.4.1996 / 11:14:26 / cg"
 	    srcP = __ArrayInstPtr(self)->a_element;
 	    dstP = __ArrayInstPtr(nObj)->a_element;
 #ifdef UNROLL_LOOPS
 	    while (nIndex >= 4) {
 		OBJ element;
 		element = srcP[0];
 		dstP[0] = element;
 		__STORE_SPC(nObj, element, spc);
 		element = srcP[1];
 		dstP += 4;
 		nIndex -= 4;
 	    }
 #endif
 	    while (nIndex--) {
 		OBJ element;
 		element = *srcP++;
 		*dstP++ = element;
 		__STORE_SPC(nObj, element, spc);
 	    }
 	}
 	if (indexHigh <= nIndex) {
 	    OBJ __aBlock = aBlock;
 	    int n;
-	    index--;				/* 0-based */
+	    index--;                            /* 0-based */
 	    n = indexHigh - index;
 	    if (__isBlockLike(__aBlock)
 	     && (__BlockInstPtr(__aBlock)->b_nargs == __MKSMALLINT(1))) {
 		{
 		interrupt7:
 			    __interruptL(@line); el = __InstPtr(self)->i_instvars[index+7];
 			    goto continue7;
 # ifdef UNROLL_LOOPS2
-interrupt0b:
+		interrupt0b:
-__interruptL(@line); el = __InstPtr(self)->i_instvars[index];
+			    __interruptL(@line); el = __InstPtr(self)->i_instvars[index];
-goto continue0b;
+			    goto continue0b;
-interrupt1b:
+		interrupt1b:
-__interruptL(@line); el = __InstPtr(self)->i_instvars[index+1];
+			    __interruptL(@line); el = __InstPtr(self)->i_instvars[index+1];
-goto continue1b;
+			    goto continue1b;
-interrupt2b:
+		interrupt2b:
-__interruptL(@line); el = __InstPtr(self)->i_instvars[index+2];
+			    __interruptL(@line); el = __InstPtr(self)->i_instvars[index+2];
-goto continue2b;
+			    goto continue2b;
-interrupt3b:
+		interrupt3b:
-__interruptL(@line); el = __InstPtr(self)->i_instvars[index+3];
+			    __interruptL(@line); el = __InstPtr(self)->i_instvars[index+3];
-goto continue3b;
+			    goto continue3b;
-interrupt0c:
+		interrupt0c:
-__interruptL(@line); el = __InstPtr(self)->i_instvars[index];
+			    __interruptL(@line); el = __InstPtr(self)->i_instvars[index];
-goto continue0c;
+			    goto continue0c;
-interrupt1c:
+		interrupt1c:
-__interruptL(@line); el = __InstPtr(self)->i_instvars[index+1];
+			    __interruptL(@line); el = __InstPtr(self)->i_instvars[index+1];
-goto continue1c;
+			    goto continue1c;
 # endif /* UNROLL_LOOPS2 */
 #endif /* UNROLL_LOOPS */
 		interruptX:
 			    __interruptL(@line); el = __InstPtr(self)->i_instvars[index];
 			    goto continueX;
 REGISTER OBJ t;
 REGISTER int count;
 OBJ myClass;
 if (
-(__ClassInstPtr((myClass = __qClass(self)))->c_ninstvars == __MKSMALLINT(0))
+	(__ClassInstPtr((myClass = __qClass(self)))->c_ninstvars == __MKSMALLINT(0))
 && __isNonNilObject(aCollection)
 && (((t = __qClass(aCollection)) == Array) || (t == myClass))
 && __bothSmallInteger(start, stop)
 && __isSmallInteger(repStart)
 ) {
-startIndex = __intVal(start) - 1;
+	startIndex = __intVal(start) - 1;
-if (startIndex >= 0) {
+	if (startIndex >= 0) {
-nIndex = __BYTES2OBJS__(__qSize(self) - OHDR_SIZE);
+	    nIndex = __BYTES2OBJS__(__qSize(self) - OHDR_SIZE);
-stopIndex = __intVal(stop) - 1;
+	    stopIndex = __intVal(stop) - 1;
-count = stopIndex - startIndex + 1;
+	    count = stopIndex - startIndex + 1;
-if ((count > 0) && (stopIndex < nIndex)) {
+	    if ((count > 0) && (stopIndex < nIndex)) {
-repStartIndex = __intVal(repStart) - 1;
+		repStartIndex = __intVal(repStart) - 1;
-if (repStartIndex >= 0) {
+		if (repStartIndex >= 0) {
-repNIndex = __BYTES2OBJS__(__qSize(aCollection)-OHDR_SIZE);
+		    repNIndex = __BYTES2OBJS__(__qSize(aCollection)-OHDR_SIZE);
-repStopIndex = repStartIndex + (stopIndex - startIndex);
+		    repStopIndex = repStartIndex + (stopIndex - startIndex);
-if (repStopIndex < repNIndex) {
+		    if (repStopIndex < repNIndex) {
-src = &(__InstPtr(aCollection)->i_instvars[repStartIndex]);
+			src = &(__InstPtr(aCollection)->i_instvars[repStartIndex]);
-dst = &(__InstPtr(self)->i_instvars[startIndex]);
+			dst = &(__InstPtr(self)->i_instvars[startIndex]);
-if (aCollection == self) {
+			if (aCollection == self) {
-/*
+			    /*
-* no need to check stores if copying
+			     * no need to check stores if copying
-* from myself
+			     * from myself
-*/
+			     */
-/*
+			    /*
-* take care of overlapping copy
+			     * take care of overlapping copy
-* do not depend on memset being smart enough
+			     * do not depend on memset being smart enough
-* (some are not ;-)
+			     * (some are not ;-)
-*/
+			     */
-if (src < dst) {
+			    if (src < dst) {
-/* must do a reverse copy */
+				/* must do a reverse copy */
-src += count;
+				src += count;
-dst += count;
+				dst += count;
 #if defined(UNROLL_LOOPS)
-while (count > 8) {
+				while (count > 8) {
-dst[-1] = src[-1];
+				    dst[-1] = src[-1];
-dst[-2] = src[-2];
+				    dst[-2] = src[-2];
-dst[-3] = src[-3];
+				    dst[-3] = src[-3];
-dst[-4] = src[-4];
+				    dst[-4] = src[-4];
-dst[-5] = src[-5];
+				    dst[-5] = src[-5];
-dst[-6] = src[-6];
+				    dst[-6] = src[-6];
-dst[-7] = src[-7];
+				    dst[-7] = src[-7];
-dst[-8] = src[-8];
+				    dst[-8] = src[-8];
-dst -= 8; src -= 8;
+				    dst -= 8; src -= 8;
-count -= 8;
+				    count -= 8;
-}
+				}
 #endif
-while (count-- > 0) {
+				while (count-- > 0) {
-*--dst = *--src;
+				    *--dst = *--src;
-}
+				}
-RETURN ( self );
+				RETURN ( self );
-}
+			    }
 #ifdef SOFTWARE_PIPELINE
-{
+			    {
-OBJ t1;
+				OBJ t1;
-/*
+				/*
-* the loop below fetches one longWord behind
+				 * the loop below fetches one longWord behind
-* this should not be a problem
+				 * this should not be a problem
-*/
+				 */
-t1 = src[0];
+				t1 = src[0];
-count--;
+				count--;
-if (count) {
+				if (count) {
-dst++; src++;
+				    dst++; src++;
-do {
+				    do {
-dst[-1] = t1;
+					dst[-1] = t1;
-t1 = src[0];
+					t1 = src[0];
-src++;
+					src++;
-dst++;
+					dst++;
-} while (count--);
+				    } while (count--);
-} else {
+				} else {
-dst[0] = t1;
+				    dst[0] = t1;
-}
+				}
-}
+			    }
 #else
 # ifdef bcopy4
-bcopy4(src, dst, count);
+			    bcopy4(src, dst, count);
 # else
 #  ifdef FAST_MEMCPY
-bcopy(src, dst, __OBJS2BYTES__(count));
+			    bcopy(src, dst, __OBJS2BYTES__(count));
 #  else
 #   if defined(UNROLL_LOOPS)
-while (count >= 8) {
+			    while (count >= 8) {
-dst[0] = src[0];
+				dst[0] = src[0];
-dst[1] = src[1];
+				dst[1] = src[1];
-dst[2] = src[2];
+				dst[2] = src[2];
-dst[3] = src[3];
+				dst[3] = src[3];
-dst[4] = src[4];
+				dst[4] = src[4];
-dst[5] = src[5];
+				dst[5] = src[5];
-dst[6] = src[6];
+				dst[6] = src[6];
-dst[7] = src[7];
+				dst[7] = src[7];
-dst += 8; src += 8;
+				dst += 8; src += 8;
-count -= 8;
+				count -= 8;
-}
+			    }
 #   endif
-while (count--) {
+			    while (count--) {
-*dst++ = *src++;
+				*dst++ = *src++;
-}
+			    }
 #  endif
 # endif
 #endif
-} else {
+			} else {
-REGISTER int spc;
+			    REGISTER int spc;
-spc = __qSpace(self);
+			    spc = __qSpace(self);
 #if defined(UNROLL_LOOPS)
-while (count >= 8) {
+			    while (count >= 8) {
-t = src[0]; dst[0] = t; __STORE_SPC(self, t, spc);
+				t = src[0]; dst[0] = t; __STORE_SPC(self, t, spc);
-t = src[1]; dst[1] = t; __STORE_SPC(self, t, spc);
+				t = src[1]; dst[1] = t; __STORE_SPC(self, t, spc);
-t = src[2]; dst[2] = t; __STORE_SPC(self, t, spc);
+				t = src[2]; dst[2] = t; __STORE_SPC(self, t, spc);
-t = src[3]; dst[3] = t; __STORE_SPC(self, t, spc);
+				t = src[3]; dst[3] = t; __STORE_SPC(self, t, spc);
-t = src[4]; dst[4] = t; __STORE_SPC(self, t, spc);
+				t = src[4]; dst[4] = t; __STORE_SPC(self, t, spc);
-t = src[5]; dst[5] = t; __STORE_SPC(self, t, spc);
+				t = src[5]; dst[5] = t; __STORE_SPC(self, t, spc);
-t = src[6]; dst[6] = t; __STORE_SPC(self, t, spc);
+				t = src[6]; dst[6] = t; __STORE_SPC(self, t, spc);
-t = src[7]; dst[7] = t; __STORE_SPC(self, t, spc);
+				t = src[7]; dst[7] = t; __STORE_SPC(self, t, spc);
-count -= 8; src += 8; dst += 8;
+				count -= 8; src += 8; dst += 8;
-}
+			    }
 #endif
-while (count-- > 0) {
+			    while (count-- > 0) {
-t = *src++;
+				t = *src++;
-*dst++ = t;
+				*dst++ = t;
-__STORE_SPC(self, t, spc);
+				__STORE_SPC(self, t, spc);
-}
+			    }
-}
+			}
-RETURN ( self );
+			RETURN ( self );
-}
+		    }
-}
+		}
-}
+	    }
-if (count == 0) {
+	    if (count == 0) {
-RETURN ( self );
+		RETURN ( self );
-}
+	    }
-}
+	}
 }
 %}.
 ^ super replaceFrom:start to:stop with:aCollection startingAt:repStart
 "Modified: 13.4.1996 / 12:17:13 / cg"
 %{  /* NOCONTEXT */
 REGISTER OBJ slf = self;
 if (__qClass(slf) == Array) {
-RETURN ( (__arraySize(slf) == 0) ? true : false);
+	RETURN ( (__arraySize(slf) == 0) ? true : false);
 }
 %}.
 ^ self size == 0
 !
 %{  /* NOCONTEXT */
 REGISTER OBJ slf = self;
 if (__qClass(slf) == Array) {
-RETURN ( (__arraySize(slf) != 0) ? true : false);
+	RETURN ( (__arraySize(slf) != 0) ? true : false);
 }
 %}.
 ^ self size ~~ 0
 !
 		 * its better to exit the loops below with a goto,
 		 * since the generated code will then be:
 		 *   compare
 		 *   branch-on-equal found
 		 *
-		 * otherwise (with return as if-statement), we get:
+		 * otherwise (with ret as if-statement), we get:
 		 *   compare
 		 *   branch-on-not-equal skipLabel
-		 *   move-to-return-register true
+		 *   move-to-ret-register true
-		 *   goto return-label
+		 *   goto ret-label
 		 * skipLabel
 		 *
 		 * therefore, WITH the so-much-blamed goto, we only branch
 		 * when found; without the goto, we branch always.
 		 * Pipelined CPUs do usually not like taken branches.
 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 (__isString(e)) {
+		if (__isString(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 ( __MKSMALLINT(index - nInsts) );
+				RETURN ( __MKSMALLINT(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 ( __MKSMALLINT(index - nInsts) );
+				    RETURN ( __MKSMALLINT(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 ( __MKSMALLINT(index - nInsts) );
+				    RETURN ( __MKSMALLINT(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 (__MKSMALLINT(0));
+		    RETURN (__MKSMALLINT(0));
-}
+		}
 #endif
-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 ( __MKSMALLINT(index - nInsts) );
+			    RETURN ( __MKSMALLINT(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 ( __MKSMALLINT(index - nInsts) );
+				RETURN ( __MKSMALLINT(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 (__MKSMALLINT(0));
+		    RETURN (__MKSMALLINT(0));
-}
+		}
-while (index < nIndex) {
+		while (index < nIndex) {
-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 ( __MKSMALLINT(index - nInsts) );
+			    RETURN ( __MKSMALLINT(index - nInsts) );
-}
+			}
-}
+		    }
-}
+		}
-} else {
+	    } else {
-OBJ slf = self;
+		OBJ slf = self;
-/*
+		/*
-* search for nil - do an identity-search
+		 * search for nil - do an identity-search
-*/
+		 */
 #if defined(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 ( __MKSMALLINT(index - nInsts + 1) ); }
+			if (__InstPtr(slf)->i_instvars[index] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 1) ); }
-if (__InstPtr(slf)->i_instvars[index+1] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 2) ); }
+			if (__InstPtr(slf)->i_instvars[index+1] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 2) ); }
-if (__InstPtr(slf)->i_instvars[index+2] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 3) ); }
+			if (__InstPtr(slf)->i_instvars[index+2] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 3) ); }
-if (__InstPtr(slf)->i_instvars[index+3] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 4) ); }
+			if (__InstPtr(slf)->i_instvars[index+3] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 4) ); }
-if (__InstPtr(slf)->i_instvars[index+4] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 5) ); }
+			if (__InstPtr(slf)->i_instvars[index+4] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 5) ); }
-if (__InstPtr(slf)->i_instvars[index+5] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 6) ); }
+			if (__InstPtr(slf)->i_instvars[index+5] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 6) ); }
-if (__InstPtr(slf)->i_instvars[index+6] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 7) ); }
+			if (__InstPtr(slf)->i_instvars[index+6] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 7) ); }
-if (__InstPtr(slf)->i_instvars[index+7] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 8) ); }
+			if (__InstPtr(slf)->i_instvars[index+7] == nil) { RETURN ( __MKSMALLINT(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 ( __MKSMALLINT(index - nInsts) );
+			RETURN ( __MKSMALLINT(index - nInsts) );
-}
+		    }
-}
+		}
-}
+	    }
-}
+	}
-RETURN (__MKSMALLINT(0));
+	RETURN (__MKSMALLINT(0));
 }
 %}.
 ^ super indexOf:anElement startingAt:start
 !
 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 (__isString(e)) {
+		if (__isString(e)) {
-while (index < lastIndex) {
+		    while (index < lastIndex) {
-element = __InstPtr(self)->i_instvars[index++];
+			element = __InstPtr(self)->i_instvars[index++];
-if (__isNonNilObject(e)) {
+			if (__isNonNilObject(e)) {
-if (element == e) {
+			    if (element == e) {
-RETURN ( __MKSMALLINT(index - nInsts) );
+				RETURN ( __MKSMALLINT(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 ( __MKSMALLINT(index - nInsts) );
+				    RETURN ( __MKSMALLINT(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 ( __MKSMALLINT(index - nInsts) );
+				    RETURN ( __MKSMALLINT(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 (__MKSMALLINT(0));
+		    RETURN (__MKSMALLINT(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 ( __MKSMALLINT(index - nInsts) );
+			    RETURN ( __MKSMALLINT(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 ( __MKSMALLINT(index - nInsts) );
+				RETURN ( __MKSMALLINT(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 (__MKSMALLINT(0));
+		    RETURN (__MKSMALLINT(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 ( __MKSMALLINT(index - nInsts) );
+			    RETURN ( __MKSMALLINT(index - nInsts) );
-}
+			}
-}
+		    }
-}
+		}
-} else {
+	    } else {
-OBJ slf = self;
+		OBJ slf = self;
-/*
+		/*
-* search for nil - do an identity-search
+		 * search for nil - do an identity-search
-*/
+		 */
 #if defined(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 ( __MKSMALLINT(index - nInsts + 1) ); }
+			if (__InstPtr(slf)->i_instvars[index] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 1) ); }
-if (__InstPtr(slf)->i_instvars[index+1] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 2) ); }
+			if (__InstPtr(slf)->i_instvars[index+1] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 2) ); }
-if (__InstPtr(slf)->i_instvars[index+2] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 3) ); }
+			if (__InstPtr(slf)->i_instvars[index+2] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 3) ); }
-if (__InstPtr(slf)->i_instvars[index+3] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 4) ); }
+			if (__InstPtr(slf)->i_instvars[index+3] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 4) ); }
-if (__InstPtr(slf)->i_instvars[index+4] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 5) ); }
+			if (__InstPtr(slf)->i_instvars[index+4] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 5) ); }
-if (__InstPtr(slf)->i_instvars[index+5] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 6) ); }
+			if (__InstPtr(slf)->i_instvars[index+5] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 6) ); }
-if (__InstPtr(slf)->i_instvars[index+6] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 7) ); }
+			if (__InstPtr(slf)->i_instvars[index+6] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 7) ); }
-if (__InstPtr(slf)->i_instvars[index+7] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 8) ); }
+			if (__InstPtr(slf)->i_instvars[index+7] == nil) { RETURN ( __MKSMALLINT(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 ( __MKSMALLINT(index - nInsts) );
+			RETURN ( __MKSMALLINT(index - nInsts) );
-}
+		    }
-}
+		}
-}
+	    }
-}
+	}
-RETURN (__MKSMALLINT(0));
+	RETURN (__MKSMALLINT(0));
 }
 %}.
 ^ super indexOf:anElement startingAt:start endingAt:stop
 ! !
 ! !
 !Array class methodsFor:'documentation'!
 version
-^ '$Header: /cvs/stx/stx/libbasic/Array.st,v 1.114 1999-04-29 22:38:23 cg Exp $'
+^ '$Header: /cvs/stx/stx/libbasic/Array.st,v 1.115 1999-06-23 12:41:21 cg Exp $'
 ! !

changeset 4305	e71100d13b67
parent 4130	662554f2a37c
child 4309	7d8976a3abe3