"

 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.

"

"{ Package: 'stx:libbasic' }"

"{ NameSpace: Smalltalk }"

UninterpretedBytes variableByteSubclass:#ByteArray

	instanceVariableNames:''

	classVariableNames:''

	poolDictionaries:''

	category:'Collections-Arrayed'

!

!ByteArray 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.

"

!

documentation

"

    ByteArrays store integers in the range 0..255.

    In contrast to normal arrays (which store pointers to their elements),

    byteArrays store the values in a dense & compact way. 

    ByteArrays can be used to hold the data for bitmaps, images and other bulk data.

    ByteArrays are also used to store the bytecode-instructions of an

    interpreted method and are used as superclass for Strings.

    ByteArrays can be used as literals i.e. you can enter ByteArray-constants

    as #[ element1 element2 .... elementN] and also use byteArray constants

    as elements in a constant array.

    As in: #( #[1 1 1] #[2 2 2] #[3 3 3])

    If you have to communicate structure-data (in the C-sense) with external

    programs/data-bases, see a companion class (Structure).

    It allows the definition of subclasses of ByteArray, which transparently fetch

    and store C-structure fields.

    [memory requirements:]

        OBJ-HEADER + size

    [warning:]

        read the warning about 'growing fixed size collection'

        in ArrayedCollection's documentation

    [author:]

        Claus Gittinger

    [See also:]

        Array CharacterArray String

"

! !

!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. However, any named instance variables are still nilled.

     For use, when contents will be set anyway shortly after - this

     is a bit faster than the regular basicNew:, which clears the bytes.

     Of course, it only makes a difference for very big ByteArrays, such

     as used for images/bitmaps.

     Notice: if you want to port code using uninitializedNew: to another

     smalltalk, you have to add an 'uninitializedNew: -> basicNew:'-calling

     method to the ByteArray class of the other smalltalk."

%{  /* NOCONTEXT */

    OBJ newobj;

    INT instsize, nInstVars, nindexedinstvars;

    REGISTER OBJ *op;

    if (__isSmallInteger(anInteger)) {

	nindexedinstvars = __intVal(anInteger);

	if (nindexedinstvars >= 0) {

	    if (self == ByteArray) {

		/*

		 * the most common case

		 */

		instsize = OHDR_SIZE + nindexedinstvars;

		if (__CanDoQuickNew(instsize)) {        /* OBJECT ALLOCATION */

		    __qCheckedNew(newobj, instsize);

		    __InstPtr(newobj)->o_class = self;

		    __qSTORE(newobj, self);

		    RETURN (newobj );

		}

	    } else {

		/*

		 * Take care for subclasses like TwoByteString

		 */

		switch (__smallIntegerVal(__ClassInstPtr(self)->c_flags) & ARRAYMASK) {

		case BYTEARRAY:

		    break;

		case WORDARRAY:

		case SWORDARRAY:

		    nindexedinstvars *= 2;

		    break;

		case LONGARRAY:

		case SLONGARRAY:

		    nindexedinstvars *= 4;

		    break;

		default:

		    /* don't know about this array type, delegate to super */

		    goto out;

		}

	    }

	    nInstVars = __intVal(__ClassInstPtr(self)->c_ninstvars);

	    instsize = OHDR_SIZE + __OBJS2BYTES__(nInstVars) + nindexedinstvars;

	    __PROTECT_CONTEXT__

	    __qNew(newobj, instsize);   /* OBJECT ALLOCATION */

	    __UNPROTECT_CONTEXT__

	    if (newobj != nil) {

		__InstPtr(newobj)->o_class = self;

		__qSTORE(newobj, self);

		if (nInstVars) {

		    /*

		     * still have to nil out named instvars ...

		     */

#if defined(memset4) && defined(FAST_OBJECT_MEMSET4)

		    memset4(__InstPtr(newobj)->i_instvars, nil, nInstVars);

#else

# 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

#endif

		}

		RETURN ( newobj );

	    }

	}

    }

out:;

%}.

    ^ self basicNew:anInteger

! !

!ByteArray class methodsFor:'queries'!

elementByteSize

    "for bit-like containers, return the number of bytes stored per element.

     Here, 1 is returned"

    ^ 1

    "Created: / 15-09-2011 / 14:12:53 / cg"

!

isBuiltInClass

    "return true if this class is known by the run-time-system.

     Here, true is returned for myself, false for subclasses."

    ^ self == ByteArray

    "Modified: 23.4.1996 / 15:56:25 / cg"

!

maxVal

    "the minimum value which can be stored in instances of me.

     For ByteArrays, this is 255"

    ^ 255

!

minVal

    "the minimum value which can be stored in instances of me.

     For ByteArrays, this is 0"

    ^ 0

! !

!ByteArray methodsFor:'Compatibility-Squeak'!

bitXor:aByteArray

    "return a new byteArray containing the bitWise-xor of the receiver's and the

     argument's bytes"

    |size size1|

    "size := self size min:aByteArray size"

    size := self size.

    size1 := aByteArray size.

    size1 < size ifTrue:[

        size := size1.

    ].

    ^ self copy

        bitXorBytesFrom:1 to:size with:aByteArray startingAt:1;

        yourself.

    "

     #[0 1 2 3 4] bitXor:#[0 1 2 3 4]

     #[0 1 2 3 4] bitXor:#[0 1 2 3]

    "

! !

!ByteArray methodsFor:'accessing'!

basicAt:index

    "return the indexed instance variable with index, anInteger

     - redefined here to be slighly faster than the default in Object.

     Q: is it worth the extra code ?"

%{  /* NOCONTEXT */

    REGISTER int indx;

    REGISTER OBJ slf;

    REGISTER OBJ cls;

    REGISTER int nIndex;

    if (__isSmallInteger(index)) {

	indx = __intVal(index) - 1;

	slf = self;

	if ((cls = __qClass(slf)) != @global(ByteArray)) {

	    if (((INT)__ClassInstPtr(cls)->c_flags & __MASKSMALLINT(ARRAYMASK))

		!= __MASKSMALLINT(BYTEARRAY)) {

		goto fail;

	    }

	    if (indx < 0) goto fail;

	    indx += __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));

	}

	nIndex = __byteArraySize(slf);

	if ((unsigned)indx < (unsigned)nIndex) {

	    RETURN ( __mkSmallInteger((__ByteArrayInstPtr(slf)->ba_element[indx])) );

	}

    }

  fail: ;

%}.

    ^ super basicAt:index

!

basicAt:index put:value

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

     Returns value (sigh).

     - redefined here to be slighly faster than the default in Object.

     Q: is it worth the extra code ?"

%{  /* NOCONTEXT */

    REGISTER int indx;

    int nIndex;

    int val;

    REGISTER OBJ slf;

    REGISTER OBJ cls;

    if (__bothSmallInteger(index, value)) {

	val = __intVal(value);

	if ((unsigned)(val) <= 0xFF /* i.e. (val >= 0) && (val <= 255) */) {

	    indx = __intVal(index) - 1;

	    slf = self;

	    if ((cls = __qClass(slf)) != @global(ByteArray)) {

		if (((INT)__ClassInstPtr(cls)->c_flags & __MASKSMALLINT(ARRAYMASK))

		    != __MASKSMALLINT(BYTEARRAY)) {

		    goto fail;

		}

		if (indx < 0) goto fail;

		indx += __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));

	    }

	    nIndex = __byteArraySize(slf);

	    if ((unsigned)indx < (unsigned)nIndex) {

		__ByteArrayInstPtr(slf)->ba_element[indx] = val;

		RETURN ( value );

	    }

	}

    }

  fail: ;

%}.

    ^ super basicAt:index put:value

    "Modified: 19.4.1996 / 11:14:40 / cg"

!

bitAt:index

    "return the bit at index (1 based index) as 0 or 1"

    |byteIndex bitIndex0 byte|

%{  /* NOCONTEXT */

    REGISTER int indx;

    REGISTER int byte;

    int nIndex;

    REGISTER OBJ slf;

    REGISTER OBJ cls;

    if (__isSmallInteger(index)) {

	indx = __intVal(index) - 1;

	slf = self;

	byte = indx / 8;

	indx = indx % 8;

	if ((cls = __qClass(slf)) != @global(ByteArray)) {

	    if (indx < 0) goto badIndex;

	    byte += __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));

	}

	nIndex = __byteArraySize(slf);

	if ((unsigned)byte < (unsigned)nIndex) {

	    RETURN ( __mkSmallInteger(((__ByteArrayInstPtr(slf)->ba_element[byte] & (1 << indx)) != 0)) );

	}

    }

badIndex: ;

%}.

    byteIndex := ((index-1) // 8) + 1.

    bitIndex0 := ((index-1) \\ 8).

    byte := self at:byteIndex.

    ^  byte bitTest:(1 bitShift:bitIndex0).

   "

     #[ 1 1 1 1 ] bitAt:9

     #[ 1 1 1 1 ] bitAt:11

     #[ 2 2 2 2 ] bitAt:10

   "

!

bitClearAt:index

    "clear the bit at index (index starts with 1)"

    |byteIndex bitIndex0 byte|

%{  /* NOCONTEXT */

    REGISTER int indx;

    REGISTER int byte;

    int nIndex;

    REGISTER OBJ slf;

    REGISTER OBJ cls;

    if (0 /* __isSmallInteger(index) */) {

	indx = __intVal(index) - 1;

	slf = self;

	byte = indx / 8;

	indx = indx % 8;

	if ((cls = __qClass(slf)) != @global(ByteArray)) {

	    if (indx < 0) goto badIndex;

	    byte += __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));

	}

	nIndex = __byteArraySize(slf);

	if ((unsigned)byte < (unsigned)nIndex) {

	    __ByteArrayInstPtr(slf)->ba_element[byte] &= ~(1 << indx);

	    RETURN (slf);

	}

    }

badIndex: ;

%}.

    byteIndex := ((index-1) // 8) + 1.

    bitIndex0 := ((index-1) \\ 8).

    byte := self at:byteIndex.

    byte := byte bitClear:(1 bitShift:bitIndex0).

    self at:byteIndex put:byte.

    "

     #[0 0 0 0] copy bitClearAt:1

     #[0 0 0 0] copy bitClearAt:7

     #[0 0 0 0] copy bitClearAt:8

     #[0 0 0 0] copy bitClearAt:9

    "

   "

     #[ 0 0 0 0 ] bitSetAt:1

     #[ 0 0 0 0 ] bitSetAt:4

     #[ 0 0 0 0 ] bitSetAt:8

     #[ 0 0 0 0 ] bitSetAt:9

     #[ 0 0 0 0 ] bitSetAt:10

     #[ 0 0 0 0 ] bitSetAt:11

   "

!

bitSetAt:index

    "set the bit at index (index starts with 1)"

    |byteIndex bitIndex0 byte|

%{  /* NOCONTEXT */

    if (__isSmallInteger(index)

     && (__qClass(self) == @global(ByteArray))) {

        int indx;

        indx = __intVal(index) - 1;

        if (indx >= 0) {

            int byteIndex;

            int bitIndex;

            int nIndex;

            byteIndex = indx / 8;

            bitIndex = indx % 8;

            nIndex = __byteArraySize(self);

            if ((unsigned)byteIndex < (unsigned)nIndex) {

                __ByteArrayInstPtr(self)->ba_element[byteIndex] |= (1 << bitIndex);

                RETURN (self);

            }

        }

    }

%}.

    byteIndex := ((index-1) // 8) + 1.

    bitIndex0 := ((index-1) \\ 8).

    byte := self at:byteIndex.

    byte := byte bitOr:(1 bitShift:bitIndex0).

    self at:byteIndex put:byte.

    "

     #[0 0 0 0] copy bitSetAt:1

     #[0 0 0 0] copy bitSetAt:7

     #[0 0 0 0] copy bitSetAt:8

     #[0 0 0 0] copy bitSetAt:9

     #[0 0 0 0] copy bitSetAt:32

     #[0 0 0 0] copy bitSetAt:33

     #[0 0 0 0] copy bitSetAt:0

    "

    "

     #[ 0 0 0 0 ] bitSetAt:1

     #[ 0 0 0 0 ] bitSetAt:4

     #[ 0 0 0 0 ] bitSetAt:8

     #[ 0 0 0 0 ] bitSetAt:9

     #[ 0 0 0 0 ] bitSetAt:10

     #[ 0 0 0 0 ] bitSetAt:11

   "

! !

!ByteArray methodsFor:'accessing-bytes'!

byteAt:index

    "return the byte at index.

     For ByteArray, this is the same as basicAt:;

     however, for strings or symbols, this returns a numeric byteValue

     instead of a character."

%{  /* NOCONTEXT */

    REGISTER int indx;

    int nIndex;

    REGISTER OBJ slf;

    REGISTER OBJ cls;

    if (__isSmallInteger(index)) {

	indx = __intVal(index) - 1;

	slf = self;

	if ((cls = __qClass(slf)) != @global(ByteArray)) {

	    if (indx < 0) goto badIndex;

	    indx += __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));

	}

	nIndex = __byteArraySize(slf);

	if ((unsigned)indx < (unsigned)nIndex) {

	    RETURN ( __mkSmallInteger((__ByteArrayInstPtr(slf)->ba_element[indx])) );

	}

    }

badIndex: ;

%}.

    ^ (super basicAt:index) asInteger

!

byteAt:index put:value