"
COPYRIGHT (c) 1989 by Claus Gittinger
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
other person. No title to or ownership of the software is
hereby transferred.
"
ArrayedCollection variableSubclass:#Array
instanceVariableNames:''
classVariableNames:''
poolDictionaries:''
category:'Collections-Arrayed'
!
Array comment:'
COPYRIGHT (c) 1989 by Claus Gittinger
All Rights Reserved
$Header: /cvs/stx/stx/libbasic/Array.st,v 1.13 1994-10-10 00:22:24 claus Exp $
'!
!Array class methodsFor:'documentation'!
copyright
"
COPYRIGHT (c) 1989 by Claus Gittinger
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
other person. No title to or ownership of the software is
hereby transferred.
"
!
version
"
$Header: /cvs/stx/stx/libbasic/Array.st,v 1.13 1994-10-10 00:22:24 claus Exp $
"
!
documentation
"
Instances of Array store general objects; the arrays size is fixed,
therefore add:/remove: are not allowed.
Access to the individual elements is via an integer index.
Since Arrays are used very often in the system, some methods have been tuned by
reimplementing them as primitive.
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 its inheritance. Subclassing is allowed - of course.
Literal arrays (i.e. array-constants) are entered in source as:
#( element1 element2 ... element-n)
where each element must be itself a constant.
Examples:
#(1 2 3)
#('foo' 2 (1 2) 4)
#('foo' #(1 2))
"
! !
!Array class methodsFor:'queries'!
isBuiltInClass
"this class is known by the run-time-system"
^ self == Array
! !
!Array methodsFor:'accessing'!
basicSize
"return the number of indexed elements in the receiver"
%{ /* NOCONTEXT */
RETURN ( _MKSMALLINT(_arraySize(self) - _intVal(_ClassInstPtr(_qClass(self))->c_ninstvars) ));
%}
!
basicAt:index
"return the indexed instance variable with index, anInteger
- added here for speed"
%{ /* NOCONTEXT */
REGISTER int indx;
REGISTER unsigned int nIndex;
OBJ cls;
if (_isSmallInteger(index)) {
indx = _intVal(index) - 1;
if (indx >= 0) {
nIndex = __BYTES2OBJS__(_qSize(self) - OHDR_SIZE);
if ((cls = _qClass(self)) != Array)
indx += _intVal(_ClassInstPtr(cls)->c_ninstvars);
if (indx < nIndex) {
RETURN ( _InstPtr(self)->i_instvars[indx] );
}
}
}
%}
.
^ super basicAt:index
!
basicAt:index put:anObject
"store the 2nd arg, anObject as indexed instvar with index, anInteger.
- added here for speed"
%{ /* NOCONTEXT */
REGISTER int indx;
REGISTER unsigned int nIndex;
OBJ cls;
if (_isSmallInteger(index)) {
indx = _intVal(index) - 1;
if (indx >= 0) {
nIndex = __BYTES2OBJS__(_qSize(self) - OHDR_SIZE);
if ((cls = _qClass(self)) != Array)
indx += _intVal(_ClassInstPtr(cls)->c_ninstvars);
if (indx < nIndex) {
_InstPtr(self)->i_instvars[indx] = anObject;
__STORE(self, anObject);
RETURN ( anObject );
}
}
}
%}
.
^ super basicAt:index put:anObject
! !
!Array methodsFor:'converting'!
asArray
"return the receiver as an array"
"could be an instance of a subclass..."
self class == Array ifTrue:[
^ self
].
^ super asArray
! !
!Array methodsFor:'copying'!
copyWith:something
"reimplemented for speed if receiver is an Array"
%{
OBJ nObj, element;
unsigned int sz;
unsigned int nIndex;
REGISTER OBJ *srcP, *dstP;
if (_qClass(self) == Array) {
sz = _qSize(self) + sizeof(OBJ);
PROTECT(something);
_qAlignedNew(nObj, sz, __context);
UNPROTECT(something);
if (nObj) {
_InstPtr(nObj)->o_class = Array;
nIndex = __BYTES2OBJS__(sz - OHDR_SIZE - sizeof(OBJ));
/* sorry: must take care of stores ... */
srcP = _ArrayInstPtr(self)->a_element;
dstP = _ArrayInstPtr(nObj)->a_element;
while (nIndex--) {
element = *srcP++;
*dstP++ = element;
__STORE(nObj, element);
}
*dstP = something;
__STORE(nObj, something);
RETURN ( nObj );
}
}
%}
.
^ super copyWith:something
! !
!Array methodsFor:'filling & replacing'!
from:index1 to:index2 put:anObject
"reimplemented for speed if receiver is an Array"
%{ /* NOCONTEXT */
REGISTER int index;
unsigned int nIndex;
unsigned int endIndex;
REGISTER OBJ *dst;
if ((_qClass(self) == Array)
&& _isSmallInteger(index1)
&& _isSmallInteger(index2)) {
index = _intVal(index1) - 1;
if (index >= 0) {
nIndex = __BYTES2OBJS__(_qSize(self) - OHDR_SIZE);
endIndex = _intVal(index2) - 1;
if (endIndex < nIndex) {
dst = &(_InstPtr(self)->i_instvars[index]);
#ifdef memset4
memset4(dst, anObject, (endIndex-index+1));
__STORE(self, anObject);
#else
if ((INT)anObject == 0) {
memset(dst, 0, __OBJS2BYTES__(endIndex-index+1));
} else {
for (; index <= endIndex; index++) {
*dst++ = anObject;
}
__STORE(self, anObject);
}
#endif
RETURN ( self );
}
}
}
%}
.
^ super from:index1 to:index2 put:anObject
!
replaceFrom:start to:stop with:aCollection startingAt:repStart
"reimplemented for speed if both receiver and aCollection are Arrays"
%{ /* NOCONTEXT */
unsigned int nIndex;
unsigned int repNIndex;
int startIndex, stopIndex;
REGISTER OBJ *src;
REGISTER OBJ *dst;
int repStopIndex;
REGISTER int repStartIndex;
REGISTER OBJ t;
REGISTER int count;
if ((_qClass(self) == Array)
&& (_Class(aCollection) == Array)
&& _isSmallInteger(start)
&& _isSmallInteger(stop)
&& _isSmallInteger(repStart)) {
startIndex = _intVal(start) - 1;
if (startIndex >= 0) {
nIndex = __BYTES2OBJS__(_qSize(self) - OHDR_SIZE);
stopIndex = _intVal(stop) - 1;
count = stopIndex - startIndex + 1;
if (count == 0) {
RETURN ( self );
}
if ((count > 0) && (stopIndex < nIndex)) {
repStartIndex = _intVal(repStart) - 1;
if (repStartIndex >= 0) {
repNIndex = __BYTES2OBJS__(_qSize(aCollection)-OHDR_SIZE);
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 */
/* take care of overlapping copy */
if (src < dst) {
/* must do a reverse copy */
src += count;
dst += count;
while (count-- > 0) {
*--dst = *--src;
}
RETURN ( self );
}
#ifdef bcopy4
bcopy4(src, dst, count);
#else
# ifdef FAST_MEMCPY
bcopy(src, dst, __OBJS2BYTES__(count));
# else
while (count--) {
*dst++ = *src++;
}
# endif
#endif
} else {
while (count-- > 0) {
t = *src++;
*dst++ = t;
__STORE(self, t);
}
}
RETURN ( self );
}
}
}
}
}
%}
.
^ super replaceFrom:start to:stop with:aCollection startingAt:repStart
! !
!Array methodsFor:'testing'!
includes:anObject
"return true, if the argument, anObject is contained in the array
- reimplemented for speed"
|element|
%{ /* NOCONTEXT */
/*
* first, do a quick check using ==
* this does not need a context or method send.
* in many cases this will already find a match
*/
REGISTER int index;
REGISTER OBJ o;
unsigned int nIndex;
nIndex = __BYTES2OBJS__(_qSize(self) - OHDR_SIZE);
index = _intVal(_ClassInstPtr(_qClass(self))->c_ninstvars);
o = anObject;
while (index < nIndex) {
if (_InstPtr(self)->i_instvars[index++] == o) {
RETURN ( true );
}
}
if (o == nil) {
RETURN ( false );
}
%}
.
%{
/*
* then do a slow(er) check using =
*/
REGISTER int index;
unsigned int nIndex;
static struct inlineCache eq = _ILC1;
nIndex = __BYTES2OBJS__(_qSize(self) - OHDR_SIZE);
index = _intVal(_ClassInstPtr(_qClass(self))->c_ninstvars);
while (index < nIndex) {
element = _InstPtr(self)->i_instvars[index++];
if (element != nil) {
if ((*eq.ilc_func)(anObject,
@symbol(=),
CON_COMMA nil,&eq,
element)==true) {
RETURN ( true );
}
}
}
%}
.
^ false
!
indexOf:anElement startingAt:start
"search the array for anElement; return index if found, 0 otherwise
- reimplemented for speed"
|element|
%{
REGISTER int index;
unsigned int nIndex, nInsts;
static struct inlineCache eq = _ILC1;
if (_isSmallInteger(start)) {
index = _intVal(start) - 1;
if (index >= 0) {
nInsts = _intVal(_ClassInstPtr(_qClass(self))->c_ninstvars);
index += nInsts;
nIndex = __BYTES2OBJS__(_qSize(self) - OHDR_SIZE);
if (anElement != nil) {
while (index < nIndex) {
element = _InstPtr(self)->i_instvars[index++];
if (element != nil) {
if ((element == anElement)
|| ((*eq.ilc_func)(anElement,
@symbol(=),
CON_COMMA nil,&eq,
element) == true)) {
RETURN ( _MKSMALLINT(index - nInsts) );
}
}
}
} else {
/* search for nil */
while (index < nIndex) {
if (_InstPtr(self)->i_instvars[index++] == nil) {
RETURN ( _MKSMALLINT(index - nInsts) );
}
}
}
}
}
%}
.
^ 0
!
identityIndexOf:anElement startingAt:start
"search the array for anElement; return index if found, 0 otherwise
- reimplemented for speed"
%{ /* NOCONTEXT */
REGISTER int index;
REGISTER OBJ el;
REGISTER OBJ *op;
REGISTER unsigned int nIndex;
int nInsts;
if (_isSmallInteger(start)) {
index = _intVal(start) - 1;
if (index >= 0) {
nInsts = _intVal(_ClassInstPtr(_qClass(self))->c_ninstvars);
index += nInsts;
nIndex = __BYTES2OBJS__(_qSize(self) - OHDR_SIZE);
el = anElement;
op = & (_InstPtr(self)->i_instvars[index]);
while (index++ < nIndex) {
if (*op++ == el) {
RETURN ( _MKSMALLINT(index - nInsts) );
}
}
RETURN ( _MKSMALLINT(0) );
}
}
%}
.
^ super identityIndexOf:anElement startingAt:start
! !
!Array methodsFor:'printing & storing'!
isLiteral
"return true, if the receiver can be used as a literal
(i.e. can be used in constant arrays)"
thisContext isRecursive ifTrue:[^ false].
self do:[:element |
element isLiteral ifFalse:[^ false]
].
^ true
!
displayString
"return a printed representation of the receiver for displaying"
|s|
self isLiteral ifTrue:[
s := WriteStream on:String new.
s nextPutAll:'#('.
self do:[:element | s nextPutAll:element displayString. s space].
s nextPutAll:')'.
^ s contents
].
^ super displayString
!
storeOn:aStream
"append a printed representation of the receiver to aStream,
which allows reconstructing it via readFrom:.
Does not work for self referencing Objects"
self isLiteral ifTrue:[
aStream nextPutAll:'#('.
self do:[:element | element storeOn:aStream. aStream space].
aStream nextPutAll:')'
] ifFalse:[
super storeOn:aStream
]
! !
!Array methodsFor:'enumeration'!
do:aBlock
"evaluate the argument, aBlock for each element in the collection.
- reimplemented for speed"
|home element|
%{
REGISTER OBJFUNC codeVal;
REGISTER int index;
unsigned int nIndex;
extern OBJ Block;
static struct inlineCache val = _ILC1;
REGISTER OBJ rHome;
index = _intVal(_ClassInstPtr(_qClass(self))->c_ninstvars);
nIndex = __BYTES2OBJS__(_qSize(self) - OHDR_SIZE);
#ifdef OLD
if (__isBlock(aBlock)
#else
if (__isBlockLike(aBlock)
#endif
&& ((codeVal = _BlockInstPtr(aBlock)->b_code) != (OBJFUNC)nil)
&& (_BlockInstPtr(aBlock)->b_nargs == _MKSMALLINT(1))) {
#ifdef NEW_BLOCK_CALL
for (; index < nIndex; index++) {
if (InterruptPending != nil) interruptL(__LINE__ COMMA_CON);
(*codeVal)(aBlock, CON_COMMA _InstPtr(self)->i_instvars[index]);
}
#else
home = _BlockInstPtr(aBlock)->b_home;
rHome = home;
if ((rHome == nil) || (_qSpace(rHome) >= STACKSPACE)) {
/*
* home will not move - keep in a fast register
*/
for (; index < nIndex; index++) {
if (InterruptPending != nil) interruptL(__LINE__ COMMA_CON);
(*codeVal)(rHome, CON_COMMA _InstPtr(self)->i_instvars[index]);
}
} else {
for (; index < nIndex; index++) {
if (InterruptPending != nil) interruptL(__LINE__ COMMA_CON);
(*codeVal)(home, CON_COMMA _InstPtr(self)->i_instvars[index]);
}
}
#endif
} else {
for (; index < nIndex; index++) {
if (InterruptPending != nil) interruptL(__LINE__ COMMA_CON);
(*val.ilc_func)(aBlock,
@symbol(value:),
CON_COMMA nil, &val,
_InstPtr(self)->i_instvars[index]);
}
}
%}
.
^ self
!
reverseDo:aBlock
"evaluate the argument, aBlock for each element in the collection in reverse order.
- reimplemented for speed"
|home element|
%{
REGISTER OBJFUNC codeVal;
REGISTER int index;
unsigned int nIndex;
int endIndex;
extern OBJ Block;
static struct inlineCache val = _ILC1;
endIndex = _intVal(_ClassInstPtr(_qClass(self))->c_ninstvars);
nIndex = __BYTES2OBJS__(_qSize(self) - OHDR_SIZE);
#ifdef OLD
if (__isBlock(aBlock)
#else
if (__isBlockLike(aBlock)
#endif
&& ((codeVal = _BlockInstPtr(aBlock)->b_code) != (OBJFUNC)nil)
&& (_BlockInstPtr(aBlock)->b_nargs == _MKSMALLINT(1))) {
#ifdef NEW_BLOCK_CALL
for (index=nIndex-1; index >= endIndex; index--) {
if (InterruptPending != nil) interruptL(__LINE__ COMMA_CON);
(*codeVal)(aBlock, CON_COMMA _InstPtr(self)->i_instvars[index]);
}
#else
home = _BlockInstPtr(aBlock)->b_home;
for (index=nIndex-1; index >= endIndex; index--) {
if (InterruptPending != nil) interruptL(__LINE__ COMMA_CON);
(*codeVal)(home, CON_COMMA _InstPtr(self)->i_instvars[index]);
}
#endif
} else {
for (index=nIndex=1; index >= endIndex; index--) {
if (InterruptPending != nil) interruptL(__LINE__ COMMA_CON);
(*val.ilc_func)(aBlock,
@symbol(value:),
CON_COMMA nil, &val,
_InstPtr(self)->i_instvars[index]);
}
}
%}
.
^ self
!
from:start to:stop do:aBlock
"evaluate the argument, aBlock for the elements starting at index start
up to (and including) stop in the collection.
- reimplemented for speed"
|home element|
%{
REGISTER OBJFUNC codeVal;
REGISTER int index;
REGISTER OBJ rHome;
int nIndex, nInsts;
extern OBJ Block;
static struct inlineCache val = _ILC1;
int indexLow, indexHigh;
if (_isSmallInteger(start) && _isSmallInteger(stop)) {
indexLow = _intVal(start);
if (indexLow > 0) {
indexHigh = _intVal(stop);
if (_qClass(self) != Array) {
nInsts = _intVal(_ClassInstPtr(_qClass(self))->c_ninstvars);
indexLow += nInsts;
indexHigh += nInsts;
}
nIndex = __BYTES2OBJS__(_qSize(self) - OHDR_SIZE);
if (indexHigh <= nIndex) {
indexLow--;
indexHigh--;
#ifdef OLD
if (__isBlock(aBlock)
#else
if (__isBlockLike(aBlock)
#endif
&& ((codeVal = _BlockInstPtr(aBlock)->b_code) != (OBJFUNC)nil)
&& (_BlockInstPtr(aBlock)->b_nargs == _MKSMALLINT(1))) {
#ifdef NEW_BLOCK_CALL
for (index=indexLow; index <= indexHigh; index++) {
if (InterruptPending != nil) interruptL(__LINE__ COMMA_CON);
(*codeVal)(aBlock, CON_COMMA _InstPtr(self)->i_instvars[index]);
}
#else
home = _BlockInstPtr(aBlock)->b_home;
rHome = home;
if ((rHome == nil) || (_qSpace(rHome) >= STACKSPACE)) {
for (index=indexLow; index <= indexHigh; index++) {
if (InterruptPending != nil) interruptL(__LINE__ COMMA_CON);
(*codeVal)(rHome, CON_COMMA _InstPtr(self)->i_instvars[index]);
}
} else {
for (index=indexLow; index <= indexHigh; index++) {
if (InterruptPending != nil) interruptL(__LINE__ COMMA_CON);
(*codeVal)(home, CON_COMMA _InstPtr(self)->i_instvars[index]);
}
}
#endif
} else {
for (index=indexLow; index <= indexHigh; index++) {
if (InterruptPending != nil) interruptL(__LINE__ COMMA_CON);
element = _InstPtr(self)->i_instvars[index];
(*val.ilc_func) (aBlock,
@symbol(value:),
CON_COMMA nil, &val,
element);
}
}
}
RETURN ( self );
}
}
%}
.
^ super from:start to:stop do:aBlock
!
from:start to:stop reverseDo:aBlock
"evaluate the argument, aBlock for the elements starting at index start
up to (and including) stop in the collection. Step in reverse order.
- reimplemented for speed"
|home element|
%{
REGISTER OBJFUNC codeVal;
REGISTER int index;
REGISTER OBJ rHome;
int nIndex, nInsts;
extern OBJ Block;
static struct inlineCache val = _ILC1;
int indexLow, indexHigh;
if (_isSmallInteger(start) && _isSmallInteger(stop)) {
indexLow = _intVal(start);
if (indexLow > 0) {
indexHigh = _intVal(stop);
if (_qClass(self) != Array) {
nInsts = _intVal(_ClassInstPtr(_qClass(self))->c_ninstvars);
indexLow += nInsts;
indexHigh += nInsts;
}
nIndex = __BYTES2OBJS__(_qSize(self) - OHDR_SIZE);
if (indexHigh <= nIndex) {
indexLow--;
indexHigh--;
#ifdef OLD
if (__isBlock(aBlock)
#else
if (__isBlockLike(aBlock)
#endif
&& ((codeVal = _BlockInstPtr(aBlock)->b_code) != (OBJFUNC)nil)
&& (_BlockInstPtr(aBlock)->b_nargs == _MKSMALLINT(1))) {
#ifdef NEW_BLOCK_CALL
for (index=indexHigh; index >= indexLow; index--) {
if (InterruptPending != nil) interruptL(__LINE__ COMMA_CON);
(*codeVal)(aBlock, CON_COMMA _InstPtr(self)->i_instvars[index]);
}
#else
home = _BlockInstPtr(aBlock)->b_home;
rHome = home;
if ((rHome == nil) || (_qSpace(rHome) >= STACKSPACE)) {
for (index=indexHigh; index >= indexLow; index--) {
if (InterruptPending != nil) interruptL(__LINE__ COMMA_CON);
(*codeVal)(rHome, CON_COMMA _InstPtr(self)->i_instvars[index]);
}
} else {
for (index=indexHigh; index >= indexLow; index--) {
if (InterruptPending != nil) interruptL(__LINE__ COMMA_CON);
(*codeVal)(home, CON_COMMA _InstPtr(self)->i_instvars[index]);
}
}
#endif
} else {
for (index=indexHigh; index >= indexLow; index--) {
if (InterruptPending != nil) interruptL(__LINE__ COMMA_CON);
element = _InstPtr(self)->i_instvars[index];
(*val.ilc_func) (aBlock,
@symbol(value:),
CON_COMMA nil, &val,
element);
}
}
}
RETURN ( self );
}
}
%}
.
^ super from:start to:stop reverseDo:aBlock
!
nonNilElementsDo:aBlock
"evaluate the argument, aBlock for each non-nil element"
|home element|
%{
REGISTER OBJFUNC codeVal;
REGISTER int index;
int nIndex;
extern OBJ Block;
static struct inlineCache val = _ILC1;
index = _intVal(_ClassInstPtr(_qClass(self))->c_ninstvars);
nIndex = __BYTES2OBJS__(_qSize(self) - OHDR_SIZE);
#ifdef OLD
if (__isBlock(aBlock)
#else
if (__isBlockLike(aBlock)
#endif
&& ((codeVal = _BlockInstPtr(aBlock)->b_code) != (OBJFUNC)nil)
&& (_BlockInstPtr(aBlock)->b_nargs == _MKSMALLINT(1))) {
#ifdef NEW_BLOCK_CALL
for (; index < nIndex; index++) {
if (InterruptPending != nil) interrupt(CONARG);
element = _InstPtr(self)->i_instvars[index];
if (element != nil)
(*codeVal)(aBlock, CON_COMMA element);
}
#else
home = _BlockInstPtr(aBlock)->b_home;
for (; index < nIndex; index++) {
if (InterruptPending != nil) interrupt(CONARG);
element = _InstPtr(self)->i_instvars[index];
if (element != nil)
(*codeVal)(home, CON_COMMA element);
}
#endif
} else {
for (; index < nIndex; index++) {
if (InterruptPending != nil) interrupt(CONARG);
element = _InstPtr(self)->i_instvars[index];
if (element != nil)
(*val.ilc_func)(aBlock,
@symbol(value:),
CON_COMMA nil, &val,
element);
}
}
%}
.
^ self
!
addAllTo:aCollection
"add all elements of the receiver to aCollection.
return aCollection."
|stop "{ Class: SmallInteger }"|
stop := self size.
1 to:stop do:[:idx |
aCollection add:(self at:idx)
].
^ aCollection
! !