"

 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 variableByteSubclass:#ByteArray

       instanceVariableNames:''

       classVariableNames:''

       poolDictionaries:''

       category:'Collections-Arrayed'

!

ByteArray comment:'

COPYRIGHT (c) 1989 by Claus Gittinger

	      All Rights Reserved

'!

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

"

!

version

"

"

!

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 dens & 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) in the goodies directory.

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

    and store C-structure fields.

"

! !

!ByteArray class methodsFor:'queries'!

isBuiltInClass

    "this class is known by the run-time-system"

    ^ self == ByteArray

! !

!ByteArray class methodsFor: 'binary storage'!

binaryDefinitionFrom: stream manager: manager

    "get a ByteArray from the binary stream.

     ByteArrays are stored as 4-byte size, followed by the bytes"

    "take care of subclasses ..."

    self == ByteArray ifTrue:[

	^ (stream next: (stream nextNumber: 4))

    ].

    ^ super binaryDefinitionFrom: stream manager: manager

! !

!ByteArray methodsFor: 'binary storage'!

storeBinaryDefinitionOn: stream manager: manager

    "append a binary representation of the receiver onto stream.

     Redefined since ByteArrays are stored with a special type code and

     in a more compact way."

    "not, if I have named instance variables"

    self class instSize ~~ 0 ifTrue:[

	^ super storeBinaryDefinitionOn: stream manager: manager

    ].

    manager putIdOf: self class on: stream.

    stream nextNumber: 4 put: self basicSize.

    stream nextPutAll: self asByteArray

! !

!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;

    extern OBJ new();

	nindexedinstvars = _intVal(anInteger);

	if (nindexedinstvars >= 0) {

		}

#else

#endif

		}

	    }

	}

    }

%}

.

    (anInteger isMemberOf:SmallInteger) ifTrue:[

	(anInteger < 0) ifTrue:[

	    ^ self error:'bad (negative) argument to new'

	].

	"

	 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 some.

	"

	^ ObjectMemory allocationFailureSignal raise.

    ].

    ^ self basicNew:anInteger

! !

!ByteArray methodsFor:'accessing'!

basicAt:index

    "return the indexed instance variable with index, anInteger

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

%{  /* NOCONTEXT */

    REGISTER int indx;

    int nIndex;

    OBJ cls;

	indx = _intVal(index);

	}

    }

%}

.

    ^ super basicAt:index

!

basicAt:index put:value

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

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

%{  /* NOCONTEXT */

    REGISTER int indx;

    int nIndex;

    int val;

    OBJ cls;

	val = _intVal(value);

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

	    indx = _intVal(index);

	    }

	}

    }

%}

.

    ^ super basicAt:index put:value

!

byteAt:index

!

!

wordAt:index

    "return the 2-bytes starting at index as an (unsigned) Integer.

     The value is retrieved LSB-first (i.e. low 8-bits at lower byte index).

     Question: should it be retrieve signed values ? (see ByteArray>>signedWordAt:)"

%{  /* NOCONTEXT */

    REGISTER int indx;

    int nIndex;

    int val;

	indx = _intVal(index);

	}

    }

%}

.

    ^ ((self at:index+1) * 256) + (self at:index)

!

wordAt:index put:value

    "set the 2-bytes starting at index from the (unsigned) Integer value.

     The stored value must be in the range 0 .. 16rFFFF. 

     The value is stored LSB-first - i.e. the low 8bits are stored at the

     lower address.

     Question: should it accept signed values ? (see ByteArray>>signedWordAt:put:)"

%{  /* NOCONTEXT */

    REGISTER int indx;

    int nIndex;

    int val;

	indx = _intVal(index);

	    }

	}

    }

%}

.

    (value < 0) ifTrue:[

	^ self elementBoundsError

    ].

    self at:index put:(value \\ 256).

    self at:index + 1 put:(value // 256).

    ^ value

    "

     |b|

     b := ByteArray new:4.

     b wordAt:1 put:16r0102.

     b wordAt:3 put:16r0304.

     b inspect  

    "

!

signedWordAt:index

    "return the 2-bytes starting at index as a signed Integer.

     The value is retrieved LSB-first (i.e. low 8-bits at lower byte index)"

    |w|

    w := self wordAt:index.

    (w > 16r7FFF) ifTrue:[

	^ w - 16r10000

    ].

    ^ w

    "

     |b|

     b := ByteArray new:2.

     b wordAt:1 put:16rFFFF.

     b signedWordAt:1

    "

!

signedWordAt:index put:value

    "set the 2-bytes starting at index from the signed Integer value.

     The stored value must be in the range -32768 .. +32676.

     The value is stored LSB-first (i.e. low 8-bits at lower byte index)"

    value > 0 ifTrue:[

	^ self wordAt:index put:value

    ].

    ^ self wordAt:index put:(16r10000 + value)

    "

     |b|

     b := ByteArray new:4.

     b signedWordAt:1 put:-1.

     b signedWordAt:3 put:-2.

     b inspect

    "

!

doubleWordAt:index

    "return the 4-bytes starting at index as an (unsigned) Integer.

     The value is retrieved LSB-first (i.e. low 8-bits at lowest byte-index).

     question: should it return a signed value ? (see ByteArray>>signedDoubleWordAt:)"

%{  /* NOCONTEXT */

    REGISTER int indx;

    int nIndex;

    int val;

	indx = _intVal(index);

	    }

	}

    }

    /*

     * fall through in case of any error

     * it will be handled in wordAt: finally

     */

%}

.

    ^ ((256 * 256) * (self wordAt:index+2)) + (self wordAt:index)

    "

     |b|

     b := ByteArray withAll:#(1 2 3 4).

     (b doubleWordAt:1) printStringRadix:16   

    "

!

doubleWordAt:index put:value

    "set the 4-bytes starting at index from the (unsigned) Integer value.

     The value must be in the range 0 to 16rFFFFFFFF.

     The value is stored LSB-first (i.e. low 8-bits at lowest byte-index).

     question: should it store signed values ? (see ByteArray signedDoubleWordAt:put:)"

    |t|

%{  /* NOCONTEXT */

    REGISTER int indx;

    int nIndex;

    int val;

	val = _intVal(value);

	if (val >= 0) {

	    indx = _intVal(index);