"

 COPYRIGHT (c) 1989-92 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.

"

IntegerArray subclass:#ByteArray

       instanceVariableNames:''

       classVariableNames:''

       poolDictionaries:''

       category:'Collections-Indexed'

!

ByteArray comment:'

COPYRIGHT (c) 1989-92 by Claus Gittinger

              All Rights Reserved

ByteArrays store integers in the range 0..255

unlike Smalltalk/80, my ByteArrays have fixed size - may change

%W% %E%

written spring 89 by claus

'!

!ByteArray class methodsFor:'instance creation'!

uninitializedNew:anInteger

    "return a new instance of the receiver with uninitialized

     (i.e. undefined) contents. The indexed elements have any random

     value. use, when contents will be set anyway shortly after."

%{  /* NOCONTEXT */

    OBJ newobj;

    INT instsize, nInstVars, nindexedinstvars;

    REGISTER OBJ *op;

    extern OBJ new();

    if (_isSmallInteger(anInteger)) {

        nindexedinstvars = _intVal(anInteger);

        if (nindexedinstvars >= 0) {

            nInstVars = _intVal(_ClassInstPtr(self)->c_ninstvars);

            if ((_intVal(_ClassInstPtr(self)->c_flags) & ARRAYMASK) == BYTEARRAY) {

                instsize = OHDR_SIZE + nInstVars * sizeof(OBJ) + nindexedinstvars * sizeof(char);

		PROTECT(self);

                _qNew(newobj, instsize, SENDER);

		UNPROTECT(self);

                _InstPtr(newobj)->o_class = self;

#if defined(FAST_MEMSET) && ! defined(NEGATIVE_ADDRESSES)

                /*

                 * knowing that nil is 0

                 */

                memset(_InstPtr(newobj)->i_instvars, 0, instsize - OHDR_SIZE);

#else

                op = _InstPtr(newobj)->i_instvars;

                while (nInstVars--)

                    *op++ = nil;

#endif

                RETURN ( newobj );

	    }

	}

    }

%}

.

    ^ self basicNew:anInteger

! !

!ByteArray methodsFor:'accessing'!

basicAt:index

    "return the indexed instance variable with index, anInteger

%{  /* NOCONTEXT */

    REGISTER int indx;

    int nIndex;

        indx = _intVal(index);

        nIndex = _qSize(self) - OHDR_SIZE;

        if ((indx > 0) && (indx <= nIndex)) {

            RETURN ( _MKSMALLINT(_ByteArrayInstPtr(self)->ba_element[indx - 1]) );

        }

    }

%}

.

    ^ super basicAt:index

!

basicAt:index put:value

    "set the indexed instance variable with index, anInteger to value

%{  /* NOCONTEXT */

    REGISTER int indx;

    int nIndex;

    int val;

        val = _intVal(value);

        if ((val >= 0) && (val <= 255)) {

            indx = _intVal(index);

            nIndex = _qSize(self) - OHDR_SIZE;

            if ((indx > 0) && (indx <= nIndex)) {

                _ByteArrayInstPtr(self)->ba_element[indx - 1] = val;

                RETURN ( value );

            }

        }

    }

%}

.

    ^ super basicAt:index put:value

! !

!ByteArray methodsFor:'queries'!

indexOf:aByte startingAt:start

    "return the index of the first occurrence of the argument, aByte

     in the receiver starting at start, anInteger; return 0 if not found.

     - reimplemented here for speed"

%{  /* NOCONTEXT */

    REGISTER unsigned char *cp;

    REGISTER int index, byteValue;

    REGISTER int len;

    if (! _isSmallInteger(aByte)) {

        RETURN ( _MKSMALLINT(0) );

    }

    byteValue = _intVal(aByte);

    if ((byteValue < 0) || (byteValue > 255)) {

        RETURN ( _MKSMALLINT(0) );

    }

        index = _intVal(start);

        len = _qSize(self) - OHDR_SIZE;

        cp = &(_ByteArrayInstPtr(self)->ba_element[0]);

        cp += index - 1;

        while (index <= len) {

            if (*cp == byteValue) {

                RETURN ( _MKSMALLINT(index) );

            }

            index++;

            cp++;

        }

        RETURN ( _MKSMALLINT(0) );

    }

%}

.

    ^ super indexOf:aByte startingAt:start

!

usedValues

    "return a new ByteArray with all used values (actually a kind of Set);

     needed specially for Image class."

    |result l|

%{

    REGISTER unsigned char *cp;

    REGISTER int len;

    unsigned char flags[256];

    static struct inlineCache nw = _ILC1;

    extern OBJ ByteArray, _new_;

    if (_qClass(self) == ByteArray) {

        memset(flags, 0, sizeof(flags));

        len = _qSize(self) - OHDR_SIZE;

        cp = &(_ByteArrayInstPtr(self)->ba_element[0]);

        /* for each used byte, set flag */

        while (len > 0) {

            flags[*cp] = 1;

            cp++;

            len--;

        }

        /* count 1's */

        len = 0;

            if (*cp) len++;

        /* create ByteArray of used values */

#ifdef PASS_ARG_REF

        l = _MKSMALLINT(len);

        result = (*nw.ilc_func)(ByteArray, _new_, CON_COMMA nil, &nw, &l);

#else

        result = (*nw.ilc_func)(ByteArray, _new_, CON_COMMA nil, &nw, _MKSMALLINT(len));

#endif

        if (_Class(result) == ByteArray) {

            cp = &(_ByteArrayInstPtr(result)->ba_element[0]);

            for (len=0; len < 256; len++) {

                if (flags[len]) 

                    *cp++ = len;

            }

        }

        RETURN ( result );

    }

%}

.

    self primitiveFailed

!

usageCounts

    "return an array filled with value-counts -

     added for Image handling"

    |counts|

    counts := Array new:256.

%{

    REGISTER unsigned char *cp;

    REGISTER int nByte;

    REGISTER int index;

    int icounts[256];

    if ((_qClass(self) == ByteArray) && _isArray(counts)) {

        /*

         * zero counts

         */

        for (index=0; index<256; index++) {

            icounts[index] = 0;

        }

        /*

         * count

         */

        nByte = _qSize(self) - OHDR_SIZE;

        cp = &(_ByteArrayInstPtr(self)->ba_element[0]);

        while (nByte--) {

            icounts[*cp++]++;

        }

        /*

         * make it real counts

         */

        for (index=0; index<256; index++) {

            _ArrayInstPtr(counts)->a_element[index] = _MKSMALLINT(icounts[index]);

        }

        RETURN ( counts );

    }

%}

.

    self primitiveFailed

!

maximumValue

    "return the maximum value in the receiver -

     added for sound-player (which needs a fast method for this)"

%{  /* NOCONTEXT */

    REGISTER unsigned char *cp;

    REGISTER int index, max;

    int len;

    if (_qClass(self) == ByteArray) {

        max = 0;

        index = 0;

        len = _qSize(self) - OHDR_SIZE;

        cp = &(_ByteArrayInstPtr(self)->ba_element[0]);

        while (++index <= len) {

            if (*cp > max) max = *cp;

            cp++;

        }

        RETURN ( _MKSMALLINT(max) );

    }

%}

.

    self primitiveFailed

! !

!ByteArray methodsFor:'filling and replacing'!

replaceFrom:start to:stop with:aCollection startingAt:repStart

    "reimplemented for speed"

%{      /* NOCONTEXT */

        int nIndex, repNIndex;

        int startIndex, stopIndex;

        REGISTER unsigned char *src;

        REGISTER int repStartIndex;

        int repStopIndex, count;

        REGISTER unsigned char *dst;

        if ((_qClass(self) == ByteArray)

         && (_Class(aCollection) == ByteArray)

         && _isSmallInteger(start)

         && _isSmallInteger(stop)

         && _isSmallInteger(repStart)) {

            startIndex = _intVal(start) - 1;

            if (startIndex >= 0) {

              nIndex = _qSize(self) - OHDR_SIZE;

              stopIndex = _intVal(stop) - 1;

              count = stopIndex - startIndex + 1;

              if ((count > 0) && (stopIndex < nIndex)) {

                repStartIndex = _intVal(repStart) - 1;

                if (repStartIndex >= 0) {

                  repNIndex = _qSize(aCollection) - OHDR_SIZE;

                  repStopIndex = repStartIndex + (stopIndex - startIndex);

                  if (repStopIndex < repNIndex) {

                    src = &(_ByteArrayInstPtr(aCollection)->ba_element[repStartIndex]);

                    dst = &(_ByteArrayInstPtr(self)->ba_element[startIndex]);

                    if (aCollection == self) {

                        /* 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 FAST_MEMCPY

                    bcopy(src, dst, count);

#else

                    while (count-- > 0) {

                        *dst++ = *src++;

                    }

#endif

                    RETURN ( self );

                  }

                }

              }

            }

        }

%}

.

    ^ super replaceFrom:start to:stop with:aCollection startingAt:repStart

! !

!ByteArray methodsFor:'image manipulation'!

invert

    "invert all bytes - used with image manipulations

     written as a primitive for speed"