hg/stx-libbasic: comparison ByteArray.st

equal deleted inserted replaced

-:9575741eeda7
+:68017b13590b
 "Created: / 5.3.1998 / 15:57:52 / stefan"
 !
 fromHexString:aString
 "Dolphin compatibility:
 decode a byteArray from a hex string (as generated by hexPrintOn:)"
 |sz       "{ Class: SmallInteger }"
 chars s bytes|
 sz odd ifTrue:[self error:'invalid hex string (odd size)'.].
 bytes := self new:(sz // 2).
 s := aString readStream.
 1 to:sz // 2 do:[:idx |
-chars := s next:2.
+	chars := s next:2.
-bytes at:idx put:(Integer readFrom:chars radix:16).
+	bytes at:idx put:(Integer readFrom:chars radix:16).
 ].
 ^ bytes
 "
 ByteArray fromHexString:'1234FEFF'
 "
 "
 |s|
 s := String streamContents:[:s | #[1 2 3] hexPrintOn:s].
 ByteArray fromHexString:s
 "
 "Modified: / 6.3.1997 / 15:28:52 / cg"
 !
 fromPackedString:aString
 "ST-80 compatibility: decode a byteArray from a packed string in which
 6bits are encoded per character. The argument, aString must be a multiple
 of 4 in size (since 24 is the lcm of 6 and 8). This is somewhat like
 the radix-encoding used in good old PDP11 times ;-)
 ST-80 uses this encoding for Images ...
 This is very similar (but not equal) to the algorithm used in RFC1421.
 PS: It took a while to figure that one out ... I dont like it ;-)"
 "the size modulo 3 is encoded in the last character, if its in the
 range 97 .. otherwise, its exact."
 lastCharacter := aString last.
 lastCharacter codePoint > 96 ifTrue:[
-stop := stop - 3 + lastCharacter codePoint - 96
+	stop := stop - 3 + lastCharacter codePoint - 96
 ].
 bytes := self new:stop.
 index := 1. dstIndex := 1.
 [dstIndex <= stop] whileTrue:[
-"/ take 4 characters ...
+	"/ take 4 characters ...
-"/ allow a line break before each group of 4
+	"/ allow a line break before each group of 4
-sixBits := (aString at:index) codePoint.
+	sixBits := (aString at:index) codePoint.
-[sixBits < 32] whileTrue:[
+	[sixBits < 32] whileTrue:[
-index := index + 1.
+	    index := index + 1.
-sixBits := (aString at:index) codePoint.
+	    sixBits := (aString at:index) codePoint.
-].
+	].
-sixBits := sixBits bitAnd:16r3F.
+	sixBits := sixBits bitAnd:16r3F.
-n := sixBits.
+	n := sixBits.
-sixBits := (aString at:index+1) codePoint.
+	sixBits := (aString at:index+1) codePoint.
-sixBits := sixBits bitAnd:16r3F.
+	sixBits := sixBits bitAnd:16r3F.
-n := (n bitShift:6) + sixBits.
+	n := (n bitShift:6) + sixBits.
-sixBits := (aString at:index+2) codePoint.
+	sixBits := (aString at:index+2) codePoint.
-sixBits := sixBits bitAnd:16r3F.
+	sixBits := sixBits bitAnd:16r3F.
-n := (n bitShift:6) + sixBits.
+	n := (n bitShift:6) + sixBits.
-sixBits := (aString at:index+3) codePoint.
+	sixBits := (aString at:index+3) codePoint.
-sixBits := sixBits bitAnd:16r3F.
+	sixBits := sixBits bitAnd:16r3F.
-n := (n bitShift:6) + sixBits.
+	n := (n bitShift:6) + sixBits.
-index := index + 4.
+	index := index + 4.
-"/ now have 24 bits in n
+	"/ now have 24 bits in n
-bytes at:dstIndex put:(n bitShift:-16).
+	bytes at:dstIndex put:(n bitShift:-16).
-dstIndex < stop ifTrue:[
+	dstIndex < stop ifTrue:[
-bytes at:dstIndex+1 put:((n bitShift:-8) bitAnd:16rFF).
+	    bytes at:dstIndex+1 put:((n bitShift:-8) bitAnd:16rFF).
-dstIndex+2 <= stop ifTrue:[
+	    dstIndex+2 <= stop ifTrue:[
-bytes at:dstIndex+2 put:(n bitAnd:16rFF).
+		bytes at:dstIndex+2 put:(n bitAnd:16rFF).
-]
+	    ]
-].
+	].
-dstIndex := dstIndex + 3.
+	dstIndex := dstIndex + 3.
 ].
 ^ bytes
 "
 ByteArray fromPackedString:(#[1 1 1 1] asPackedString)
 ByteArray fromPackedString:(#[1 1 1 1 1] asPackedString)
 ByteArray fromPackedString:(#[1 1 1 1 1 1] asPackedString)
 ByteArray fromPackedString:(#[1 1 1 1 1 1 1] asPackedString)
 ByteArray fromPackedString:(#[1 1 1 1 1 1 1 1] asPackedString)
 "
 "Modified: / 6.3.1997 / 15:28:52 / cg"
 "Modified: / 18.12.1997 / 17:17:11 / stefan"
 !
 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);
+	nindexedinstvars = __intVal(anInteger);
-if (nindexedinstvars >= 0) {
+	if (nindexedinstvars >= 0) {
-if (self == ByteArray) {
+	    if (self == ByteArray) {
-/*
+		/*
-* the most common case
+		 * the most common case
-*/
+		 */
-instsize = OHDR_SIZE + nindexedinstvars;
+		instsize = OHDR_SIZE + nindexedinstvars;
-if (__CanDoQuickNew(instsize)) {        /* OBJECT ALLOCATION */
+		if (__CanDoQuickNew(instsize)) {        /* OBJECT ALLOCATION */
-__qCheckedNew(newobj, instsize);
+		    __qCheckedNew(newobj, instsize);
-__InstPtr(newobj)->o_class = self;
+		    __InstPtr(newobj)->o_class = self;
-__qSTORE(newobj, self);
+		    __qSTORE(newobj, self);
-RETURN (newobj );
+		    RETURN (newobj );
-}
+		}
-} else {
+	    } else {
-/*
+		/*
-* Take care for subclasses like TwoByteString
+		 * Take care for subclasses like TwoByteString
-*/
+		 */
-switch (__smallIntegerVal(__ClassInstPtr(self)->c_flags) & ARRAYMASK) {
+		switch (__smallIntegerVal(__ClassInstPtr(self)->c_flags) & ARRAYMASK) {
-case BYTEARRAY:
+		case BYTEARRAY:
-break;
+		    break;
-case WORDARRAY:
+		case WORDARRAY:
-case SWORDARRAY:
+		case SWORDARRAY:
-nindexedinstvars *= 2;
+		    nindexedinstvars *= 2;
-break;
+		    break;
-case LONGARRAY:
+		case LONGARRAY:
-case SLONGARRAY:
+		case SLONGARRAY:
-nindexedinstvars *= 4;
+		    nindexedinstvars *= 4;
-break;
+		    break;
-default:
+		default:
-/* don't know about this array type, delegate to super */
+		    /* don't know about this array type, delegate to super */
-goto out;
+		    goto out;
-}
+		}
-}
+	    }
-nInstVars = __intVal(__ClassInstPtr(self)->c_ninstvars);
+	    nInstVars = __intVal(__ClassInstPtr(self)->c_ninstvars);
-instsize = OHDR_SIZE + __OBJS2BYTES__(nInstVars) + nindexedinstvars;
+	    instsize = OHDR_SIZE + __OBJS2BYTES__(nInstVars) + nindexedinstvars;
-__PROTECT_CONTEXT__
+	    __PROTECT_CONTEXT__
-__qNew(newobj, instsize);   /* OBJECT ALLOCATION */
+	    __qNew(newobj, instsize);   /* OBJECT ALLOCATION */
-__UNPROTECT_CONTEXT__
+	    __UNPROTECT_CONTEXT__
-if (newobj != nil) {
+	    if (newobj != nil) {
-__InstPtr(newobj)->o_class = self;
+		__InstPtr(newobj)->o_class = self;
-__qSTORE(newobj, self);
+		__qSTORE(newobj, self);
-if (nInstVars) {
+		if (nInstVars) {
-/*
+		    /*
-* still have to nil out named instvars ...
+		     * still have to nil out named instvars ...
-*/
+		     */
 #if defined(memset4) && defined(FAST_OBJECT_MEMSET4)
-memset4(__InstPtr(newobj)->i_instvars, nil, nInstVars);
+		    memset4(__InstPtr(newobj)->i_instvars, nil, nInstVars);
 #else
 # if defined(FAST_MEMSET) && !defined(NEGATIVE_ADDRESSES)
-/*
+		    /*
-* knowing that nil is 0
+		     * knowing that nil is 0
-*/
+		     */
-memset(__InstPtr(newobj)->i_instvars, 0, instsize - OHDR_SIZE);
+		    memset(__InstPtr(newobj)->i_instvars, 0, instsize - OHDR_SIZE);
 # else
-op = __InstPtr(newobj)->i_instvars;
+		    op = __InstPtr(newobj)->i_instvars;
-while (nInstVars--)
+		    while (nInstVars--)
-*op++ = nil;
+			*op++ = nil;
 # endif
 #endif
-}
+		}
-RETURN ( newobj );
+		RETURN ( newobj );
-}
+	    }
-}
+	}
 }
 out:;
 %}.
 ^ self basicNew:anInteger
 !
 !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.
 This is only invoked for long bytearrays.
 Short ones are stored with 1byte length."
 |b len|
 "take care of subclasses ..."
 "Modified: 19.4.1996 / 11:14:40 / cg"
 !
 bitAt:index
 "return the bit at index (1 based index)"
 |byteIndex bitIndex0 byte|
 %{  /* NOCONTEXT */
 int nIndex;
 REGISTER OBJ slf;
 REGISTER OBJ cls;
 if (__isSmallInteger(index)) {
-indx = __intVal(index) - 1;
+	indx = __intVal(index) - 1;
-slf = self;
+	slf = self;
-byte = indx / 8;
+	byte = indx / 8;
-indx = indx % 8;
+	indx = indx % 8;
-if ((cls = __qClass(slf)) != @global(ByteArray)) {
+	if ((cls = __qClass(slf)) != @global(ByteArray)) {
-if (indx < 0) goto badIndex;
+	    if (indx < 0) goto badIndex;
-byte += __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));
+	    byte += __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));
-}
+	}
-nIndex = __byteArraySize(slf);
+	nIndex = __byteArraySize(slf);
-if ((unsigned)byte < (unsigned)nIndex) {
+	if ((unsigned)byte < (unsigned)nIndex) {
-RETURN ( __MKSMALLINT((__ByteArrayInstPtr(slf)->ba_element[byte] & (1 << indx)) != 0) );
+	    RETURN ( __MKSMALLINT((__ByteArrayInstPtr(slf)->ba_element[byte] & (1 << indx)) != 0) );
-}
+	}
 }
 badIndex: ;
 %}.
 byteIndex := ((index-1) // 8) + 1.
 bitIndex0 := ((index-1) \\ 8).
 !
 bitClearAt:index
 "clear the bit at index (index starts with 1)"
 |byteIndex bitIndex0 byte|
 %{  /* NOCONTEXT */
 int nIndex;
 REGISTER OBJ slf;
 REGISTER OBJ cls;
 if (0 /* __isSmallInteger(index) */) {
-indx = __intVal(index) - 1;
+	indx = __intVal(index) - 1;
-slf = self;
+	slf = self;
-byte = indx / 8;
+	byte = indx / 8;
-indx = indx % 8;
+	indx = indx % 8;
-if ((cls = __qClass(slf)) != @global(ByteArray)) {
+	if ((cls = __qClass(slf)) != @global(ByteArray)) {
-if (indx < 0) goto badIndex;
+	    if (indx < 0) goto badIndex;
-byte += __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));
+	    byte += __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));
-}
+	}
-nIndex = __byteArraySize(slf);
+	nIndex = __byteArraySize(slf);
-if ((unsigned)byte < (unsigned)nIndex) {
+	if ((unsigned)byte < (unsigned)nIndex) {
-__ByteArrayInstPtr(slf)->ba_element[byte] &= ~(1 << indx);
+	    __ByteArrayInstPtr(slf)->ba_element[byte] &= ~(1 << indx);
-RETURN (slf);
+	    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 */
 int nIndex;
 REGISTER OBJ slf;
 REGISTER OBJ cls;
 if (0 /* __isSmallInteger(index) */) {
-indx = __intVal(index) - 1;
+	indx = __intVal(index) - 1;
-slf = self;
+	slf = self;
-byte = indx / 8;
+	byte = indx / 8;
-indx = indx % 8;
+	indx = indx % 8;
-if ((cls = __qClass(slf)) != @global(ByteArray)) {
+	if ((cls = __qClass(slf)) != @global(ByteArray)) {
-if (indx < 0) goto badIndex;
+	    if (indx < 0) goto badIndex;
-byte += __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));
+	    byte += __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));
-}
+	}
-nIndex = __byteArraySize(slf);
+	nIndex = __byteArraySize(slf);
-if ((unsigned)byte < (unsigned)nIndex) {
+	if ((unsigned)byte < (unsigned)nIndex) {
-__ByteArrayInstPtr(slf)->ba_element[byte] |= (1 << indx);
+	    __ByteArrayInstPtr(slf)->ba_element[byte] |= (1 << indx);
-RETURN (slf);
+	    RETURN (slf);
-}
+	}
 }
 badIndex: ;
 %}.
 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 ] 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 */
 %{  /* NOCONTEXT */
 REGISTER int indx;
 int nIndex;
 union {
-unsigned char u_char[4];
+	unsigned char u_char[4];
-unsigned int u_uint;
+	unsigned int u_uint;
 } val;
 OBJ cls;
 unsigned char *byteP;
 if (__isSmallInteger(index)) {
-if (__isSmallInteger(value)) {
+	if (__isSmallInteger(value)) {
-val.u_uint = __intVal(value);
+	    val.u_uint = __intVal(value);
-} else {
+	} else {
-val.u_uint = __longIntVal(value);
+	    val.u_uint = __longIntVal(value);
-if (val.u_uint == 0) goto error;
+	    if (val.u_uint == 0) goto error;
-}
+	}
-indx = __intVal(index);
+	indx = __intVal(index);
-if (indx > 0) {
+	if (indx > 0) {
-if ((cls = __qClass(self)) != @global(ByteArray))
+	    if ((cls = __qClass(self)) != @global(ByteArray))
-indx += __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));
+		indx += __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));
-nIndex = __qSize(self) - OHDR_SIZE;
+	    nIndex = __qSize(self) - OHDR_SIZE;
-if ((indx+3) <= nIndex) {
+	    if ((indx+3) <= nIndex) {
-byteP = (unsigned char *)(__ByteArrayInstPtr(self)->ba_element) + indx - 1;
+		byteP = (unsigned char *)(__ByteArrayInstPtr(self)->ba_element) + indx - 1;
 #if defined(__i386__) || defined(UNALIGNED_FETCH_OK)
-((unsigned int *)byteP)[0] = val.u_uint;
+		((unsigned int *)byteP)[0] = val.u_uint;
 #else
-if (((unsigned INT)byteP & 3) == 0) {
+		if (((unsigned INT)byteP & 3) == 0) {
-((unsigned int *)byteP)[0] = val.u_uint;
+		    ((unsigned int *)byteP)[0] = val.u_uint;
-} else {
+		} else {
-byteP[0] = val.u_char[0];
+		    byteP[0] = val.u_char[0];
-byteP[1] = val.u_char[1];
+		    byteP[1] = val.u_char[1];
-byteP[2] = val.u_char[2];
+		    byteP[2] = val.u_char[2];
-byteP[3] = val.u_char[3];
+		    byteP[3] = val.u_char[3];
-}
+		}
 #endif
-RETURN ( value );
+		RETURN ( value );
-}
+	    }
-}
+	}
 }
 error: ;
 %}.
 ^ super doubleWordAt:index put:value.
 int val;
 OBJ cls;
 unsigned char *byteP;
 if (__isSmallInteger(index)) {
-if (__isSmallInteger(value)) {
+	if (__isSmallInteger(value)) {
-val = __intVal(value);
+	    val = __intVal(value);
-} else {
+	} else {
-val = __longIntVal(value);
+	    val = __longIntVal(value);
-if (val == 0) goto error;
+	    if (val == 0) goto error;
-}
+	}
-indx = __intVal(index);
+	indx = __intVal(index);
-if (indx > 0) {
+	if (indx > 0) {
-if ((cls = __qClass(self)) != @global(ByteArray))
+	    if ((cls = __qClass(self)) != @global(ByteArray))
-indx += __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));
+		indx += __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));
-nIndex = __qSize(self) - OHDR_SIZE;
+	    nIndex = __qSize(self) - OHDR_SIZE;
-if ((indx+3) <= nIndex) {
+	    if ((indx+3) <= nIndex) {
-byteP = (unsigned char *)(__ByteArrayInstPtr(self)->ba_element) + indx - 1;
+		byteP = (unsigned char *)(__ByteArrayInstPtr(self)->ba_element) + indx - 1;
-if (msb == true) {
+		if (msb == true) {
-/*
+		    /*
-* most significant byte first (i.e sparc order)
+		     * most significant byte first (i.e sparc order)
-*/
+		     */
 #if defined(__MSBFIRST__)
-if (((INT)byteP & 3) == 0) {
+		    if (((INT)byteP & 3) == 0) {
-((int *)byteP)[0] = val;
+			((int *)byteP)[0] = val;
-} else
+		    } else
 #endif
-{
+		    {
-byteP[3] = val & 0xFF;
+			byteP[3] = val & 0xFF;
-val >>= 8;
+			val >>= 8;
-byteP[2] = val & 0xFF;
+			byteP[2] = val & 0xFF;
-val >>= 8;
+			val >>= 8;
-byteP[1] = val & 0xFF;
+			byteP[1] = val & 0xFF;
-val >>= 8;
+			val >>= 8;
-byteP[0] = val & 0xFF;
+			byteP[0] = val & 0xFF;
-}
+		    }
-} else {
+		} else {
-/*
+		    /*
-* least significant byte first (i.e i386/alpha order)
+		     * least significant byte first (i.e i386/alpha order)
-*/
+		     */
 #if defined(__i386__) || (defined(__LSBFIRST__) && defined(UNALIGNED_FETCH_OK))
-((int *)byteP)[0] = val;
+		    ((int *)byteP)[0] = val;
 #else
 # if defined(__LSBFIRST__)
-if (((unsigned INT)byteP & 3) == 0) {
+		    if (((unsigned INT)byteP & 3) == 0) {
-((int *)byteP)[0] = val;
+			((int *)byteP)[0] = val;
-} else
+		    } else
 # endif
-{
+		    {
-byteP[0] = val & 0xFF;
+			byteP[0] = val & 0xFF;
-val >>= 8;
+			val >>= 8;
-byteP[1] = val & 0xFF;
+			byteP[1] = val & 0xFF;
-val >>= 8;
+			val >>= 8;
-byteP[2] = val & 0xFF;
+			byteP[2] = val & 0xFF;
-val >>= 8;
+			val >>= 8;
-byteP[3] = val & 0xFF;
+			byteP[3] = val & 0xFF;
-}
+		    }
 #endif
-}
+		}
-RETURN ( value );
+		RETURN ( value );
-}
+	    }
-}
+	}
 }
 error: ;
 %}.
 ^ super doubleWordAt:index put:value MSB:msb
 %{  /* NOCONTEXT */
 REGISTER int indx;
 int nIndex;
 union {
-unsigned char u_char[2];
+	unsigned char u_char[2];
-unsigned short u_ushort;
+	unsigned short u_ushort;
 } val;
 OBJ cls;
 unsigned char *byteP;
 if (__isSmallInteger(index)) {
-indx = __intVal(index);
+	indx = __intVal(index);
-if (indx > 0) {
+	if (indx > 0) {
-if ((cls = __qClass(self)) != @global(ByteArray))
+	    if ((cls = __qClass(self)) != @global(ByteArray))
-indx += __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));
+		indx += __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));
-nIndex = __byteArraySize(self);
+	    nIndex = __byteArraySize(self);
-if ((indx+1) <= nIndex) {
+	    if ((indx+1) <= nIndex) {
-byteP = (unsigned char *)(__ByteArrayInstPtr(self)->ba_element) + indx - 1;
+		byteP = (unsigned char *)(__ByteArrayInstPtr(self)->ba_element) + indx - 1;
 #if defined(__i386__) || defined(UNALIGNED_FETCH_OK)
-val.u_ushort = ((unsigned short *)byteP)[0];
+		val.u_ushort = ((unsigned short *)byteP)[0];
 #else
-/*
+		/*
-* mhmh to be measured:
+		 * mhmh to be measured:
-*   the if may hurt more than the additional
+		 *   the if may hurt more than the additional
-*   memory cycles on some machines ...
+		 *   memory cycles on some machines ...
-*/
+		 */
-if (((INT)byteP & 1) == 0) {
+		if (((INT)byteP & 1) == 0) {
-/* aligned */
+		    /* aligned */
-val.u_ushort = ((unsigned short *)byteP)[0];
+		    val.u_ushort = ((unsigned short *)byteP)[0];
-} else {
+		} else {
-val.u_char[0] = byteP[0];
+		    val.u_char[0] = byteP[0];
-val.u_char[1] = byteP[1];
+		    val.u_char[1] = byteP[1];
-}
+		}
 #endif
-RETURN ( __MKSMALLINT(val.u_ushort) );
+		RETURN ( __MKSMALLINT(val.u_ushort) );
-}
+	    }
-}
+	}
 }
 %}.
 ^ super wordAt:index
 !
 int val;
 OBJ cls;
 unsigned char *byteP;
 if (__isSmallInteger(index)) {
-indx = __intVal(index);
+	indx = __intVal(index);
-if (indx > 0) {
+	if (indx > 0) {
-if ((cls = __qClass(self)) != @global(ByteArray))
+	    if ((cls = __qClass(self)) != @global(ByteArray))
-indx += __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));
+		indx += __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));
-nIndex = __byteArraySize(self);
+	    nIndex = __byteArraySize(self);
-if ((indx+1) <= nIndex) {
+	    if ((indx+1) <= nIndex) {
-byteP = (unsigned char *)(__ByteArrayInstPtr(self)->ba_element) + indx - 1;
+		byteP = (unsigned char *)(__ByteArrayInstPtr(self)->ba_element) + indx - 1;
-if (msb == true) {
+		if (msb == true) {
-/*
+		    /*
-* most significant byte first (i.e sparc order)
+		     * most significant byte first (i.e sparc order)
-*/
+		     */
 #if defined(__MSBFIRST__)
-/*
+		    /*
-* mhmh to be measured:
+		     * mhmh to be measured:
-*   the if may hurt more than the additional
+		     *   the if may hurt more than the additional
-*   memory cycles on some machines ...
+		     *   memory cycles on some machines ...
-*/
+		     */
-if (((INT)byteP & 1) == 0) {
+		    if (((INT)byteP & 1) == 0) {
-/* aligned */
+			/* aligned */
-val = ((unsigned short *)byteP)[0];
+			val = ((unsigned short *)byteP)[0];
-} else
+		    } else
 #endif
-{
+		    {
-val = byteP[0];
+			val = byteP[0];
-val = (val << 8) + byteP[1];
+			val = (val << 8) + byteP[1];
-}
+		    }
-} else {
+		} else {
-/*
+		    /*
-* least significant byte first (i.e i386/alpha order)
+		     * least significant byte first (i.e i386/alpha order)
-*/
+		     */
 #if defined(__i386__) || (defined(__LSBFIRST__) && defined(UNALIGNED_FETCH_OK))
-val = ((unsigned short *)byteP)[0];
+		    val = ((unsigned short *)byteP)[0];
 #else
 # if defined(__LSBFIRST__)
-/*
+		    /*
-* mhmh to be measured:
+		     * mhmh to be measured:
-*   the if may hurt more than the additional
+		     *   the if may hurt more than the additional
-*   memory cycles on some machines ...
+		     *   memory cycles on some machines ...
-*/
+		     */
-if (((INT)byteP & 1) == 0) {
+		    if (((INT)byteP & 1) == 0) {
-/* aligned */
+			/* aligned */
-val = ((unsigned short *)byteP)[0];
+			val = ((unsigned short *)byteP)[0];
-} else
+		    } else
 # endif
-{
+		    {
-val = byteP[1];
+			val = byteP[1];
-val = (val << 8) + byteP[0];
+			val = (val << 8) + byteP[0];
-}
+		    }
 #endif
-}
+		}
-RETURN ( __MKSMALLINT(val) );
+		RETURN ( __MKSMALLINT(val) );
-}
+	    }
-}
+	}
 }
 %}.
 ^ super wordAt:index MSB:msb
 !
 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 in the machines natural byteorder,
 i.e. this method should only be used to fill byteArrays which are
 used internally (not passed to other machines).
 Question: should it accept signed values ? (see ByteArray>>signedWordAt:put:)"
 REGISTER int indx;
 int nIndex;
 int v;
 union {
-unsigned char u_char[2];
+	unsigned char u_char[2];
-unsigned short u_ushort;
+	unsigned short u_ushort;
 } val;
 OBJ cls;
 unsigned char *byteP;
 if (__bothSmallInteger(index, value)) {
-indx = __intVal(index);
+	indx = __intVal(index);
-if (indx > 0) {
+	if (indx > 0) {
-if ((cls = __qClass(self)) != @global(ByteArray))
+	    if ((cls = __qClass(self)) != @global(ByteArray))
-indx += __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));
+		indx += __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));
-nIndex = __byteArraySize(self);
+	    nIndex = __byteArraySize(self);
-if ((indx+1) <= nIndex) {
+	    if ((indx+1) <= nIndex) {
-val.u_ushort = v = __intVal(value);
+		val.u_ushort = v = __intVal(value);
-if ((v & ~0xFFFF) == 0 /* i.e. (val >= 0) && (val <= 0xFFFF) */) {
+		if ((v & ~0xFFFF) == 0 /* i.e. (val >= 0) && (val <= 0xFFFF) */) {
-byteP = (unsigned char *)(__ByteArrayInstPtr(self)->ba_element) + indx - 1;
+		    byteP = (unsigned char *)(__ByteArrayInstPtr(self)->ba_element) + indx - 1;
 #if defined(__i386__) || defined(UNALIGNED_FETCH_OK)
-((unsigned short *)byteP)[0] = val.u_ushort;
+		    ((unsigned short *)byteP)[0] = val.u_ushort;
 #else
-/*
+		    /*
-* mhmh to be measured:
+		     * mhmh to be measured:
-*   the if may hurt more than the additional
+		     *   the if may hurt more than the additional
-*   memory cycles on some machines ...
+		     *   memory cycles on some machines ...
-*/
+		     */
-if (((INT)byteP & 1) == 0) {
+		    if (((INT)byteP & 1) == 0) {
-/* aligned */
+			/* aligned */
-((unsigned short *)byteP)[0] = val.u_ushort;
+			((unsigned short *)byteP)[0] = val.u_ushort;
-} else {
+		    } else {
-byteP[0] = val.u_char[0];
+			byteP[0] = val.u_char[0];
-byteP[1] = val.u_char[1];
+			byteP[1] = val.u_char[1];
-}
+		    }
 #endif
-RETURN ( value );
+		    RETURN ( value );
-}
+		}
-}
+	    }
-}
+	}
 }
 %}.
 ^ super wordAt:index put:value
 "
 |b|
 b := ByteArray new:4.
 b wordAt:1 put:16r0102.
 b wordAt:3 put:16r0304.
 b inspect
 "
 !
 wordAt:index put:value MSB:msb
 "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 index) if msb is false, MSB-first otherwise.
 Question: should it accept signed values ? (see ByteArray>>signedWordAt:put:)"
 %{  /* NOCONTEXT */
 int val;
 OBJ cls;
 unsigned char *byteP;
 if (__bothSmallInteger(index, value)) {
-indx = __intVal(index);
+	indx = __intVal(index);
-if (indx > 0) {
+	if (indx > 0) {
-if ((cls = __qClass(self)) != @global(ByteArray))
+	    if ((cls = __qClass(self)) != @global(ByteArray))
-indx += __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));
+		indx += __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));
-nIndex = __byteArraySize(self);
+	    nIndex = __byteArraySize(self);
-if ((indx+1) <= nIndex) {
+	    if ((indx+1) <= nIndex) {
-val = __intVal(value);
+		val = __intVal(value);
-if ((val & ~0xFFFF) == 0 /* i.e. (val >= 0) && (val <= 0xFFFF) */) {
+		if ((val & ~0xFFFF) == 0 /* i.e. (val >= 0) && (val <= 0xFFFF) */) {
-byteP = (unsigned char *)(__ByteArrayInstPtr(self)->ba_element) + indx - 1;
+		    byteP = (unsigned char *)(__ByteArrayInstPtr(self)->ba_element) + indx - 1;
-if (msb == true) {
+		    if (msb == true) {
-/*
+			/*
-* most significant byte first (i.e sparc order)
+			 * most significant byte first (i.e sparc order)
-*/
+			 */
 #if defined(__MSBFIRST__)
-/*
+			/*
-* mhmh to be measured:
+			 * mhmh to be measured:
-*   the if may hurt more than the additional
+			 *   the if may hurt more than the additional
-*   memory cycles on some machines ...
+			 *   memory cycles on some machines ...
-*/
+			 */
-if (((INT)byteP & 1) == 0) {
+			if (((INT)byteP & 1) == 0) {
-/* aligned */
+			    /* aligned */
-((unsigned short *)byteP)[0] = val;
+			    ((unsigned short *)byteP)[0] = val;
-} else
+			} else
 #endif
-{
+			{
-byteP[1] = val & 0xFF;
+			    byteP[1] = val & 0xFF;
-byteP[0] = (val>>8) & 0xFF;
+			    byteP[0] = (val>>8) & 0xFF;
-}
+			}
-} else {
+		    } else {
-/*
+			/*
-* least significant byte first (i.e i386/alpha order)
+			 * least significant byte first (i.e i386/alpha order)
-*/
+			 */
 #if defined(__i386__) || (defined(__LSBFIRST__) && defined(UNALIGNED_FETCH_OK))
-((unsigned short *)byteP)[0] = val;
+			((unsigned short *)byteP)[0] = val;
 #else
 # if defined(__LSBFIRST__)
-/*
+			/*
-* mhmh to be measured:
+			 * mhmh to be measured:
-*   the if may hurt more than the additional
+			 *   the if may hurt more than the additional
-*   memory cycles on some machines ...
+			 *   memory cycles on some machines ...
-*/
+			 */
-if (((INT)byteP & 1) == 0) {
+			if (((INT)byteP & 1) == 0) {
-/* aligned */
+			    /* aligned */
-((unsigned short *)byteP)[0] = val;
+			    ((unsigned short *)byteP)[0] = val;
-} else
+			} else
 # endif
-{
+			{
-byteP[0] = val & 0xFF;
+			    byteP[0] = val & 0xFF;
-byteP[1] = (val>>8) & 0xFF;
+			    byteP[1] = (val>>8) & 0xFF;
-}
+			}
 #endif
-}
+		    }
-RETURN ( value );
+		    RETURN ( value );
-}
+		}
-}
+	    }
-}
+	}
 }
 %}.
 ^ super wordAt:index put:value MSB:msb
 "
 b := ByteArray new:8.
 b wordAt:1 put:16r0102 MSB:false.
 b wordAt:3 put:16r0304 MSB:false.
 b wordAt:5 put:16r0102 MSB:true.
 b wordAt:7 put:16r0304 MSB:true.
 b inspect
 "
 ! !
 !ByteArray methodsFor:'binary storage'!
 |myClass myBasicSize|
 "not, if I have named instance variables"
 (myClass := self class) instSize ~~ 0 ifTrue:[
-^ super storeBinaryDefinitionOn:stream manager:manager
+	^ super storeBinaryDefinitionOn:stream manager:manager
 ].
 myBasicSize := self basicSize.
 "/ can use a more compact representation;
 "/ but not for subclasses ...
 ((myClass == ByteArray)
 and:[myBasicSize <= 255]) ifTrue:[
-"/ special encoding: <codeForByteArray> <len> <bytes> ...
+	"/ special encoding: <codeForByteArray> <len> <bytes> ...
-stream nextPut:(manager codeForByteArray); nextPut:myBasicSize.
+	stream nextPut:(manager codeForByteArray); nextPut:myBasicSize.
 ] ifFalse:[
-manager putIdOfClass:myClass on:stream.
+	manager putIdOfClass:myClass on:stream.
-stream nextNumber:4 put:myBasicSize.
+	stream nextNumber:4 put:myBasicSize.
 ].
 self storeBinaryElementsOn:stream.
 "Modified: / 2.11.1997 / 15:28:45 / cg"
 !
 	^ self
 ].
 ^ super asByteArray
 "
 'hello world' asByteArray
 #(1 2 3 4 5 6 7) asByteArray
 #(1 2 256 4 5 6 7) asByteArray
 "
 !
 asPackedString
 "ST-80 compatibility: encode the receiver into an ascii String
 encoded in the last character.
 ST-80 uses this encoding for Images ...
 This is very similar (but not equal) to the algorithm used in RFC1421.
 PS: I dont like it ;-)"
 |outStream
 index     "{ Class:SmallInteger}"
 nextIndex "{ Class:SmallInteger}"
 stop      "{ Class:SmallInteger}"
 n         "{ Class:SmallInteger}"
 mod       "{ Class:SmallInteger}"
 cpl|
 outStream := WriteStream on:String new.
 index := 1.
 stop := self size.
 stop > 100 ifTrue:[
-"/ cg:
+	"/ cg:
-"/ initial lineBreak
+	"/ initial lineBreak
-outStream cr.
+	outStream cr.
 ].
 cpl := 0.
 [index <= stop] whileTrue:[
-"take 3 source bytes"
+	"take 3 source bytes"
-n := (self at:index) bitShift:16.
+	n := (self at:index) bitShift:16.
-(index < stop) ifTrue:[
+	(index < stop) ifTrue:[
-nextIndex := index + 1.
+	    nextIndex := index + 1.
-n := n bitOr:((self at:nextIndex) bitShift:8).
+	    n := n bitOr:((self at:nextIndex) bitShift:8).
-(nextIndex < stop) ifTrue:[
+	    (nextIndex < stop) ifTrue:[
-n := n bitOr:(self at:(index + 2)).
+		n := n bitOr:(self at:(index + 2)).
-].
+	    ].
-].
+	].
-"took me a while to find that one out ..."
+	"took me a while to find that one out ..."
-n := n bitXor:16r820820.
+	n := n bitXor:16r820820.
-outStream nextPut:(Character value:(n bitShift:-18) + 32).
+	outStream nextPut:(Character value:(n bitShift:-18) + 32).
-outStream nextPut:(Character value:((n bitShift:-12) bitAnd:16r3F) + 32).
+	outStream nextPut:(Character value:((n bitShift:-12) bitAnd:16r3F) + 32).
-outStream nextPut:(Character value:((n bitShift:-6) bitAnd:16r3F) + 32).
+	outStream nextPut:(Character value:((n bitShift:-6) bitAnd:16r3F) + 32).
-outStream nextPut:(Character value:(n bitAnd:16r3F) + 32).
+	outStream nextPut:(Character value:(n bitAnd:16r3F) + 32).
-index := index + 3.
+	index := index + 3.
-"/ cg:
+	"/ cg:
-"/ lineBreak after every 120 characters
+	"/ lineBreak after every 120 characters
-"/ fromPackedString will ignore those
+	"/ fromPackedString will ignore those
-cpl := cpl + 4.
+	cpl := cpl + 4.
-cpl >= 120 ifTrue:[
+	cpl >= 120 ifTrue:[
-outStream cr.
+	    outStream cr.
-cpl := 0.
+	    cpl := 0.
-].
+	].
 ].
 (mod := stop \\ 3) ~~ 0 ifTrue:[
-outStream backStep.
+	outStream backStep.
-outStream nextPut:(Character value:(mod + 96)).
+	outStream nextPut:(Character value:(mod + 96)).
 ].
 ^ outStream contents
 "Modified: 12.11.1996 / 15:45:02 / cg"
 !
 "speed up string conversions"
 |size|
 self class == ByteArray ifTrue:[
-size := self size.
+	size := self size.
-^ (String uninitializedNew:size) replaceBytesFrom:1 to:size with:self startingAt:1.
+	^ (String uninitializedNew:size) replaceBytesFrom:1 to:size with:self startingAt:1.
 ].
 ^ super asString
 "
 #[60 61 62 63] asString
 can be reconstructed with #decodeAsLiteralArray."
 ^ self
 "
 #[1 2 3] literalArrayEncoding
 "
 ! !
 copy
 "redefined for a bit more speed"
 self class == ByteArray ifTrue:[
-^ self copyFrom:1 to:(self size)
+	^ self copyFrom:1 to:(self size)
 ].
 ^ super copy
 !
 copyFrom:start to:stop
 int len, index1, index2, sz;
 OBJ newByteArray;
 if (__isByteArray(self)
 && __bothSmallInteger(start, stop)) {
-len = __byteArraySize(self);
+	len = __byteArraySize(self);
-index1 = __intVal(start);
+	index1 = __intVal(start);
-index2 = __intVal(stop);
+	index2 = __intVal(stop);
-if ((index1 <= index2) && (index1 > 0)) {
+	if ((index1 <= index2) && (index1 > 0)) {
-if (index2 <= len) {
+	    if (index2 <= len) {
-count = index2 - index1 + 1;
+		count = index2 - index1 + 1;
-__PROTECT_CONTEXT__
+		__PROTECT_CONTEXT__
-sz = OHDR_SIZE + count;
+		sz = OHDR_SIZE + count;
-__qNew(newByteArray, sz);       /* OBJECT ALLOCATION */
+		__qNew(newByteArray, sz);       /* OBJECT ALLOCATION */
-__UNPROTECT_CONTEXT__
+		__UNPROTECT_CONTEXT__
-if (newByteArray != nil) {
+		if (newByteArray != nil) {
-__InstPtr(newByteArray)->o_class = ByteArray;
+		    __InstPtr(newByteArray)->o_class = ByteArray;
-__qSTORE(newByteArray, ByteArray);
+		    __qSTORE(newByteArray, ByteArray);
-dstp = __ByteArrayInstPtr(newByteArray)->ba_element;
+		    dstp = __ByteArrayInstPtr(newByteArray)->ba_element;
-srcp = __ByteArrayInstPtr(self)->ba_element + index1 - 1;
+		    srcp = __ByteArrayInstPtr(self)->ba_element + index1 - 1;
 #ifdef bcopy4
-if (((unsigned INT)srcp & 3) == ((unsigned INT)dstp & 3)) {
+		    if (((unsigned INT)srcp & 3) == ((unsigned INT)dstp & 3)) {
-int nW;
+			int nW;
-/* copy unaligned part */
+			/* copy unaligned part */
-while (count && (((unsigned INT)srcp & 3) != 0)) {
+			while (count && (((unsigned INT)srcp & 3) != 0)) {
-*dstp++ = *srcp++;
+			    *dstp++ = *srcp++;
-count--;
+			    count--;
-}
+			}
-if (count) {
+			if (count) {
-/* copy aligned part */
+			    /* copy aligned part */
-nW = count >> 2;
+			    nW = count >> 2;
-if (count & 3) {
+			    if (count & 3) {
-nW++;
+				nW++;
-}
+			    }
-bcopy4(srcp, dstp, nW);
+			    bcopy4(srcp, dstp, nW);
-}
+			}
-RETURN ( newByteArray );
+			RETURN ( newByteArray );
-}
+		    }
 #endif /* bcopy4 */
 #if __POINTER_SIZE__ == 8
-if (((unsigned INT)srcp & 7) == ((unsigned INT)dstp & 7)) {
+		    if (((unsigned INT)srcp & 7) == ((unsigned INT)dstp & 7)) {
-int nW;
+			int nW;
-/* copy unaligned part */
+			/* copy unaligned part */
-while (count && (((unsigned INT)srcp & 7) != 0)) {
+			while (count && (((unsigned INT)srcp & 7) != 0)) {
-*dstp++ = *srcp++;
+			    *dstp++ = *srcp++;
-count--;
+			    count--;
-}
+			}
-/* copy aligned part */
+			/* copy aligned part */
-while (count >= 8) {
+			while (count >= 8) {
-((unsigned INT *)dstp)[0] = ((unsigned INT *)srcp)[0];
+			    ((unsigned INT *)dstp)[0] = ((unsigned INT *)srcp)[0];
-dstp += 8;
+			    dstp += 8;
-srcp += 8;
+			    srcp += 8;
-count -= 8;
+			    count -= 8;
-}
+			}
-/* copy remaining part */
+			/* copy remaining part */
-while (count) {
+			while (count) {
-*dstp++ = *srcp++;
+			    *dstp++ = *srcp++;
-count--;
+			    count--;
-}
+			}
-RETURN ( newByteArray );
+			RETURN ( newByteArray );
-}
+		    }
 #endif /* bcopy4 */
 #ifdef FAST_MEMCPY
-bcopy(srcp, dstp, count);
+		    bcopy(srcp, dstp, count);
 #else
-while (count--) {
+		    while (count--) {
-*dstp++ = *srcp++;
+			*dstp++ = *srcp++;
-}
+		    }
 #endif
-RETURN ( newByteArray );
+		    RETURN ( newByteArray );
-}
+		}
-}
+	    }
-}
+	}
 }
 %}.
 "
 fall back in case of non-integer index or out-of-bound index;
 will eventually lead to an out-of-bound signal raise
 "
 ^ super copyFrom:start to:stop
 "
 #[1 2 3 4 5 6 7 8 9 10] copyFrom:1 to:10
 #[1 2 3 4 5 6 7 8 9 10] copyFrom:5 to:7
 #[1 2 3 4 5 6 7 8 9 10] copyFrom:5 to:11
 #[1 2 3 4 5 6 7 8 9 10] copyFrom:0 to:10
 #[1 2 3 4 5 6 7 8 9 10] copyFrom:0 to:9
 "
 !
 shallowCopy
 "redefined for a bit more speed"
 self class == ByteArray ifTrue:[
-^ self copyFrom:1 to:(self size)
+	^ self copyFrom:1 to:(self size)
 ].
 ^ super shallowCopy
 !
 symbolFrom:start to:stop
 "make a symbol from the characters of the subcollection starting
 at index start, anInteger and ending at stop, anInteger.
 This saves us garbage and character copying."
 |sym|
 	    len -= nInst;
 	}
 	value = __intVal(aNumber);
 	if (((unsigned)value <= 0xFF) /* i.e. (value >= 0) && (value <= 255) */
 	 && (index1 <= index2)
 	 && (index1 > 0)) {
 	    if (index2 <= len) {
 		count = index2 - index1 + 1;
 #ifdef memset4
 		    }
 		    RETURN (self);
 		}
 #endif /* memset4 */
-#if __POINTER_SIZE__ == 8
+#if (__POINTER_SIZE__ == 8)
 		{
 		    INT v8;
 		    v8 = (value << 8) | value;
 		    v8 = (v8 << 16) | v8;
 		    if (count) {
 			*dstp = value;
 		    }
 		    RETURN (self);
 		}
-#endif /* alpha64 */
+#endif /* 64bit */
 #ifdef FAST_MEMSET
 		memset(dstp, value, count);
 #else
 # ifdef UNROLL_LOOPS
 will eventually lead to an out-of-bound signal raise
 "
 ^ super from:start to:stop put:aNumber
 "
 (ByteArray new:10) from:1 to:10 put:1
 (ByteArray new:20) from:10 to:20 put:1
 (ByteArray new:20) from:1 to:10 put:1
 "
 !
 replaceBytesFrom:start to:stop with:aCollection startingAt:repStart
 "replace elements from another collection, which must be a ByteArray-
 #ifndef NO_PRIM_BYTEARR
 if ((__isBytes(aCollection) || __isExternalBytesLike(aCollection))
 && __isBytes(self)
 && __bothSmallInteger(start, stop)
 && __isSmallInteger(repStart)) {
-startIndex = __intVal(start) - 1;
+	startIndex = __intVal(start) - 1;
-if (startIndex >= 0) {
+	if (startIndex >= 0) {
-dst = (__ByteArrayInstPtr(self)->ba_element) + startIndex;
+	    dst = (__ByteArrayInstPtr(self)->ba_element) + startIndex;
-nIndex = __byteArraySize(self);
+	    nIndex = __byteArraySize(self);
-if ((cls = __qClass(self)) != @global(ByteArray)) {
+	    if ((cls = __qClass(self)) != @global(ByteArray)) {
-int nInst;
+		int nInst;
-nInst = __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));
+		nInst = __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));
-dst += nInst;
+		dst += nInst;
-nIndex -= nInst;
+		nIndex -= nInst;
-}
+	    }
-stopIndex = __intVal(stop) - 1;
+	    stopIndex = __intVal(stop) - 1;
-count = stopIndex - startIndex + 1;
+	    count = stopIndex - startIndex + 1;
-if (count == 0) {
+	    if (count == 0) {
-RETURN ( self );
+		RETURN ( self );
-}
+	    }
-if ((count > 0) && (stopIndex < nIndex)) {
+	    if ((count > 0) && (stopIndex < nIndex)) {
-repStartIndex = __intVal(repStart) - 1;
+		repStartIndex = __intVal(repStart) - 1;
-if (repStartIndex >= 0) {
+		if (repStartIndex >= 0) {
-if (__isExternalBytesLike(aCollection)) {
+		    if (__isExternalBytesLike(aCollection)) {
-OBJ sz;
+			OBJ sz;
-src = __externalAddressVal(aCollection);
+			src = __externalAddressVal(aCollection);
-if (src == 0) goto fallBack;
+			if (src == 0) goto fallBack;
-sz = __externalBytesSize(aCollection);
+			sz = __externalBytesSize(aCollection);
-if (__isSmallInteger(sz)) {
+			if (__isSmallInteger(sz)) {
-repNIndex = __smallIntegerVal(sz);
+			    repNIndex = __smallIntegerVal(sz);
-} else {
+			} else {
-repNIndex = repStopIndex+1; /* always enough */
+			    repNIndex = repStopIndex+1; /* always enough */
-}
+			}
-src = src + repStartIndex;
+			src = src + repStartIndex;
-} else {
+		    } else {
-repNIndex = __qSize(aCollection) - OHDR_SIZE;
+			repNIndex = __qSize(aCollection) - OHDR_SIZE;
-src = (__ByteArrayInstPtr(aCollection)->ba_element) + repStartIndex;
+			src = (__ByteArrayInstPtr(aCollection)->ba_element) + repStartIndex;
-if ((cls = __qClass(aCollection)) != @global(ByteArray)) {
+			if ((cls = __qClass(aCollection)) != @global(ByteArray)) {
-int nInst;
+			    int nInst;
-nInst = __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));
+			    nInst = __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));
-src += nInst;
+			    src += nInst;
-repNIndex -= nInst;
+			    repNIndex -= nInst;
-}
+			}
-}
+		    }
-repStopIndex = repStartIndex + (stopIndex - startIndex);
+		    repStopIndex = repStartIndex + (stopIndex - startIndex);
-if (repStopIndex < repNIndex) {
+		    if (repStopIndex < repNIndex) {
-if (aCollection == self) {
+			if (aCollection == self) {
-/* take care of overlapping copy */
+			    /* take care of overlapping copy */
-if (src < dst) {
+			    if (src < dst) {
-/* must do a reverse copy */
+				/* must do a reverse copy */
-src += count;
+				src += count;
-dst += count;
+				dst += count;
-while (count-- > 0) {
+				while (count-- > 0) {
-*--dst = *--src;
+				    *--dst = *--src;
-}
+				}
-RETURN ( self );
+				RETURN ( self );
-}
+			    }
-}
+			}
 # ifdef bcopy4
-if (((unsigned INT)src & 3) == ((unsigned INT)dst & 3)) {
+			if (((unsigned INT)src & 3) == ((unsigned INT)dst & 3)) {
-int nW;
+			    int nW;
-/* copy unaligned part */
+			    /* copy unaligned part */
-while (count && ((unsigned INT)src & 3)) {
+			    while (count && ((unsigned INT)src & 3)) {
-*dst++ = *src++;
+				*dst++ = *src++;
-count--;
+				count--;
-}
+			    }
-if (count > 0) {
+			    if (count > 0) {
-/* copy aligned part */
+				/* copy aligned part */
-nW = count >> 2;
+				nW = count >> 2;
-bcopy4(src, dst, nW);
+				bcopy4(src, dst, nW);
-if ((count = count & 3) != 0) {
+				if ((count = count & 3) != 0) {
-/* copy any remaining part */
+				    /* copy any remaining part */
-src += (nW<<2);
+				    src += (nW<<2);
-dst += (nW<<2);
+				    dst += (nW<<2);
-while (count--) {
+				    while (count--) {
-*dst++ = *src++;
+					*dst++ = *src++;
-}
+				    }
-}
+				}
-}
+			    }
-RETURN ( self );
+			    RETURN ( self );
-}
+			}
 # else
 #  if __POINTER_SIZE__ == 8
-if (((unsigned INT)src & 7) == ((unsigned INT)dst & 7)) {
+			if (((unsigned INT)src & 7) == ((unsigned INT)dst & 7)) {
-/* copy unaligned part */
+			    /* copy unaligned part */
-while (count && ((unsigned INT)src & 7)) {
+			    while (count && ((unsigned INT)src & 7)) {
-*dst++ = *src++;
+				*dst++ = *src++;
-count--;
+				count--;
-}
+			    }
-/* copy aligned part */
+			    /* copy aligned part */
-while (count >= 8) {
+			    while (count >= 8) {
-((unsigned INT *)dst)[0] = ((unsigned INT *)src)[0];
+				((unsigned INT *)dst)[0] = ((unsigned INT *)src)[0];
-dst += 8;
+				dst += 8;
-src += 8;
+				src += 8;
-count -= 8;
+				count -= 8;
-}
+			    }
-while (count--) {
+			    while (count--) {
-*dst++ = *src++;
+				*dst++ = *src++;
-}
+			    }
-RETURN ( self );
+			    RETURN ( self );
-}
+			}
-#  endif /* alpha64 */
+#  endif /* 64bit */
 # endif /* bcopy4 */
 # ifdef FAST_MEMCPY
-bcopy(src, dst, count);
+			bcopy(src, dst, count);
 # else
 #  ifdef UNROLL_LOOPS
-while (count >= 8) {
+			while (count >= 8) {
-dst[0] = src[0]; dst[1] = src[1];
+			    dst[0] = src[0]; dst[1] = src[1];
-dst[2] = src[2]; dst[3] = src[3];
+			    dst[2] = src[2]; dst[3] = src[3];
-dst[4] = src[4]; dst[5] = src[5];
+			    dst[4] = src[4]; dst[5] = src[5];
-dst[6] = src[6]; dst[7] = src[7];
+			    dst[6] = src[6]; dst[7] = src[7];
-dst += 8; src += 8;
+			    dst += 8; src += 8;
-count -= 8;
+			    count -= 8;
-}
+			}
 #  endif /* UNROLL_LOOPS */
-while (count-- > 0) {
+			while (count-- > 0) {
-*dst++ = *src++;
+			    *dst++ = *src++;
-}
+			}
 # endif
-RETURN ( self );
+			RETURN ( self );
-}
+		    }
-}
+		}
-}
+	    }
-}
+	}
 }
 fallBack: ;
 #endif
 %}.
 "
 "
 ^ super replaceBytesFrom:start to:stop with:aCollection startingAt:repStart
 "
 #[1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16]
-copy
+	copy
-replaceFrom:1 to:8
+	    replaceFrom:1 to:8
-with:#[10 20 30 40 50 60 70 80 90 100 110 120 130 140 150 160]
+	    with:#[10 20 30 40 50 60 70 80 90 100 110 120 130 140 150 160]
-startingAt:1
+	    startingAt:1
 #[1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16]
-copy
+	copy
-replaceFrom:3 to:10
+	    replaceFrom:3 to:10
-with:#[10 20 30 40 50 60 70 80 90 100 110 120 130 140 150 160]
+	    with:#[10 20 30 40 50 60 70 80 90 100 110 120 130 140 150 160]
-startingAt:1
+	    startingAt:1
 #[1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16]
-copy
+	copy
-replaceFrom:3 to:4
+	    replaceFrom:3 to:4
-with:#[10 20 30 40 50 60 70 80 90 100 110 120 130 140 150 160]
+	    with:#[10 20 30 40 50 60 70 80 90 100 110 120 130 140 150 160]
-startingAt:1
+	    startingAt:1
 #[1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16]
-copy
+	copy
-replaceFrom:0 to:9
+	    replaceFrom:0 to:9
-with:#[10 20 30 40 50 60 70 80 90 100 110 120 130 140 150 160]
+	    with:#[10 20 30 40 50 60 70 80 90 100 110 120 130 140 150 160]
-startingAt:1
+	    startingAt:1
 #[1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16]
-copy
+	copy
-replaceFrom:1 to:10
+	    replaceFrom:1 to:10
-with:#[10 20 30 40 50 60 70 80 90 100 110 120 130 140 150 160]
+	    with:#[10 20 30 40 50 60 70 80 90 100 110 120 130 140 150 160]
-startingAt:0
+	    startingAt:0
 "
 !
 replaceBytesFrom:startIndex with:replacementCollection startingAt:repStartIndex
 "replace elements from another collection, which must be
 byte-array-like.
 Notice: This operation modifies the receiver, NOT a copy;
 therefore the change may affect all others referencing the receiver."
 ^ self
 	replaceBytesFrom:startIndex
 	to:(startIndex + replacementCollection size - repStartIndex)
 	with:replacementCollection
 	startingAt:repStartIndex
 "
 Return the receiver.
 Notice: This operation modifies the receiver, NOT a copy;
 therefore the change may affect all others referencing the receiver."
 ((aCollection class == self class)
 or:[aCollection class isBytes]) ifTrue:[
 	^ self replaceBytesFrom:startIndex to:stopIndex with:aCollection startingAt:repStartIndex
 ].
 ^ super replaceFrom:startIndex to:stopIndex with:aCollection startingAt:repStartIndex
 "Modified: / 27.7.1998 / 16:58:33 / cg"
 ! !
 !ByteArray methodsFor:'image manipulation support'!
 bitAndBytesFrom:dstStart to:dstEnd with:sourceBytes startingAt:sourceStart
 "replace bytes in the receiver with the result of a bitAnd operation.
 Warning: this is a destructive operation - elements in the receiver are overwritten."
 ^ self bitBlitBytesFrom:dstStart to:dstEnd with:sourceBytes startingAt:sourceStart rule:#bitAnd:
 "
 #[1 2 3 4 5 6 7 8]
 	bitAndBytesFrom:1 to:8 with:#[1 2 3 4 5 6 7 8] startingAt:1
 #[1 2 3 4 5 6 7 8]
 	bitAndBytesFrom:1 to:8 with:#[1 1 1 1 1 1 1 1] startingAt:1
 "
 !
 bitBlitBytesFrom:dstStart to:dstEnd with:sourceBytes startingAt:sourceStart rule:ruleSymbol
 "perform a special case of an aligned bitBlit operation.
 Bytes in the receiver from dstStart to dstEnd are destructively replaced by the result
 of some logical operation, as specified by the ruleSymbol.
 SourceBytes are fetched starting at sourceOffset.
 Valid rule symbols are:
-#copy    - trivial;  same as replaceBytesFrom:to:with:startingAt:
+	#copy    - trivial;  same as replaceBytesFrom:to:with:startingAt:
-#bitXor: - xoring;   byte[dI] = byte[dI] bitXor:(srcByte[sI])
+	#bitXor: - xoring;   byte[dI] = byte[dI] bitXor:(srcByte[sI])
-#bitAnd: - anding;   byte[dI] = byte[dI] bitAnd:(srcByte[sI])
+	#bitAnd: - anding;   byte[dI] = byte[dI] bitAnd:(srcByte[sI])
-#bitOr:  - oring;    byte[dI] = byte[dI] bitOr:(srcByte[sI])
+	#bitOr:  - oring;    byte[dI] = byte[dI] bitOr:(srcByte[sI])
-#+       - adding;   byte[dI] = (byte[dI] + (srcByte[sI])) mod: 256
+	#+       - adding;   byte[dI] = (byte[dI] + (srcByte[sI])) mod: 256
-#-       - subtract; byte[dI] = (byte[dI] - (srcByte[sI])) mod: 256
+	#-       - subtract; byte[dI] = (byte[dI] - (srcByte[sI])) mod: 256
 Warning: this is a destructive operation - elements in the receiver are overwritten.
 "
 |srcIdx|
 %{
 if ((__isByteArray(sourceBytes))
 && (__qClass(self) == ByteArray)
 && __isSmallInteger(dstStart)
 && __isSmallInteger(dstEnd)
 && __isSmallInteger(sourceStart)) {
-unsigned char *srcP = __ByteArrayInstPtr(sourceBytes)->ba_element;
+	unsigned char *srcP = __ByteArrayInstPtr(sourceBytes)->ba_element;
-unsigned char *dstP = __ByteArrayInstPtr(self)->ba_element;
+	unsigned char *dstP = __ByteArrayInstPtr(self)->ba_element;
-int srcLen = __byteArraySize(sourceBytes);
+	int srcLen = __byteArraySize(sourceBytes);
-int dstLen = __byteArraySize(self);
+	int dstLen = __byteArraySize(self);
-int __srcStart = __intVal(sourceStart);
+	int __srcStart = __intVal(sourceStart);
-int __dstStart = __intVal(dstStart);
+	int __dstStart = __intVal(dstStart);
-int count = __intVal(dstEnd) - __dstStart + 1;
+	int count = __intVal(dstEnd) - __dstStart + 1;
-if ((__dstStart >= 1)
+	if ((__dstStart >= 1)
-&& (__srcStart >= 1)
+	 && (__srcStart >= 1)
-&& ((__dstStart + count - 1) <= dstLen)
+	 && ((__dstStart + count - 1) <= dstLen)
-&& ((__srcStart + count - 1) <= srcLen)) {
+	 && ((__srcStart + count - 1) <= srcLen)) {
-srcP += __srcStart - 1;
+	    srcP += __srcStart - 1;
-dstP += __dstStart - 1;
+	    dstP += __dstStart - 1;
 #define OP_LOOP_BYTES(OP) \
 while (count > 0) {                                              \
-*dstP OP (*srcP);                                            \
+	*dstP OP (*srcP);                                            \
-srcP++;                                                      \
+	srcP++;                                                      \
-dstP++;                                                      \
+	dstP++;                                                      \
-count--;                                                     \
+	count--;                                                     \
 }
 #define OP_LOOP(OP) \
 while (count >= 16) {                                            \
-((unsigned int *)dstP)[0] OP (((unsigned int *)srcP)[0]);    \
+	((unsigned int *)dstP)[0] OP (((unsigned int *)srcP)[0]);    \
-((unsigned int *)dstP)[1] OP (((unsigned int *)srcP)[1]);    \
+	((unsigned int *)dstP)[1] OP (((unsigned int *)srcP)[1]);    \
-((unsigned int *)dstP)[2] OP (((unsigned int *)srcP)[2]);    \
+	((unsigned int *)dstP)[2] OP (((unsigned int *)srcP)[2]);    \
-((unsigned int *)dstP)[3] OP (((unsigned int *)srcP)[3]);    \
+	((unsigned int *)dstP)[3] OP (((unsigned int *)srcP)[3]);    \
-srcP += 16;                                                  \
+	srcP += 16;                                                  \
-dstP += 16;                                                  \
+	dstP += 16;                                                  \
-count -= 16;                                                 \
+	count -= 16;                                                 \
 }                                                                \
 while (count >= 4) {                                             \
-((unsigned int *)dstP)[0] OP (((unsigned int *)srcP)[0]);    \
+	((unsigned int *)dstP)[0] OP (((unsigned int *)srcP)[0]);    \
-srcP += 4;                                                   \
+	srcP += 4;                                                   \
-dstP += 4;                                                   \
+	dstP += 4;                                                   \
-count -= 4;                                                  \
+	count -= 4;                                                  \
 }                                                                \
 while (count > 0) {                                              \
-*dstP OP (*srcP);                                            \
+	*dstP OP (*srcP);                                            \
-srcP++;                                                      \
+	srcP++;                                                      \
-dstP++;                                                      \
+	dstP++;                                                      \
-count--;                                                     \
+	count--;                                                     \
 }
-if (ruleSymbol == @symbol(bitXor:)) {
+	    if (ruleSymbol == @symbol(bitXor:)) {
-OP_LOOP( ^= )
+		OP_LOOP( ^= )
-RETURN (self);
+		RETURN (self);
-}
+	    }
-if (ruleSymbol == @symbol(bitXorNot:)) {
+	    if (ruleSymbol == @symbol(bitXorNot:)) {
-OP_LOOP( ^=~ )
+		OP_LOOP( ^=~ )
-RETURN (self);
+		RETURN (self);
-}
+	    }
-if (ruleSymbol == @symbol(bitAnd:)) {
+	    if (ruleSymbol == @symbol(bitAnd:)) {
-OP_LOOP( &= )
+		OP_LOOP( &= )
-RETURN (self);
+		RETURN (self);
-}
+	    }
-if (ruleSymbol == @symbol(bitAndNot:)) {
+	    if (ruleSymbol == @symbol(bitAndNot:)) {
-OP_LOOP( &=~ )
+		OP_LOOP( &=~ )
-RETURN (self);
+		RETURN (self);
-}
+	    }
-if (ruleSymbol == @symbol(bitOr:)) {
+	    if (ruleSymbol == @symbol(bitOr:)) {
-OP_LOOP( |= )
+		OP_LOOP( |= )
-RETURN (self);
+		RETURN (self);
-}
+	    }
-if (ruleSymbol == @symbol(bitOrNot:)) {
+	    if (ruleSymbol == @symbol(bitOrNot:)) {
-OP_LOOP( |=~ )
+		OP_LOOP( |=~ )
-RETURN (self);
+		RETURN (self);
-}
+	    }
-if (ruleSymbol == @symbol(copy)) {
+	    if (ruleSymbol == @symbol(copy)) {
-OP_LOOP( = )
+		OP_LOOP( = )
-RETURN (self);
+		RETURN (self);
-}
+	    }
-if (ruleSymbol == @symbol(copyNot)) {
+	    if (ruleSymbol == @symbol(copyNot)) {
-OP_LOOP( =~ )
+		OP_LOOP( =~ )
-RETURN (self);
+		RETURN (self);
-}
+	    }
-if (ruleSymbol == @symbol(+)) {
+	    if (ruleSymbol == @symbol(+)) {
-OP_LOOP_BYTES( += )
+		OP_LOOP_BYTES( += )
-RETURN (self);
+		RETURN (self);
-}
+	    }
-if (ruleSymbol == @symbol(-)) {
+	    if (ruleSymbol == @symbol(-)) {
-OP_LOOP_BYTES( -= )
+		OP_LOOP_BYTES( -= )
-RETURN (self);
+		RETURN (self);
-}
+	    }
-}
+	}
 }
 #undef OP_LOOP_BYTES
 #undef OP_LOOP
 %}.
 ruleSymbol == #copy ifTrue:[
-self replaceFrom:dstStart to:dstEnd with:sourceBytes startingAt:sourceStart.
+	self replaceFrom:dstStart to:dstEnd with:sourceBytes startingAt:sourceStart.
-^ self
+	^ self
 ].
 srcIdx := sourceStart.
 dstStart to:dstEnd do:[:dstIdx |
-self at:dstIdx put:((self at:dstIdx) perform:ruleSymbol with:(sourceBytes at:srcIdx)).
+	self at:dstIdx put:((self at:dstIdx) perform:ruleSymbol with:(sourceBytes at:srcIdx)).
-srcIdx := srcIdx + 1.
+	srcIdx := srcIdx + 1.
 ].
 "
 #[1 2 3 4 5 6 7 8]
-bitBlitBytesFrom:1 to:3 with:#[1 2 3 4 5 6 7 8] startingAt:1 rule:#bitXor:
+	bitBlitBytesFrom:1 to:3 with:#[1 2 3 4 5 6 7 8] startingAt:1 rule:#bitXor:
 #[1 2 3 4 5 6 7 8]
-bitBlitBytesFrom:1 to:8 with:#[1 2 3 4 5 6 7 8] startingAt:1 rule:#bitXor:
+	bitBlitBytesFrom:1 to:8 with:#[1 2 3 4 5 6 7 8] startingAt:1 rule:#bitXor:
 #[1 2 3 4 5 6 7 8]
-bitBlitBytesFrom:1 to:8 with:#[1 1 1 1 1 1 1 1] startingAt:1 rule:#bitAnd:
+	bitBlitBytesFrom:1 to:8 with:#[1 1 1 1 1 1 1 1] startingAt:1 rule:#bitAnd:
 #[1 2 3 4 5 6 7 8]
-bitBlitBytesFrom:1 to:8 with:#[1 2 3 4 5 6 7 8] startingAt:1 rule:#+
+	bitBlitBytesFrom:1 to:8 with:#[1 2 3 4 5 6 7 8] startingAt:1 rule:#+
 #[255 0 0 0 0 0 0 0]
-bitBlitBytesFrom:1 to:8 with:#[1 2 3 4 5 6 7 8] startingAt:1 rule:#+
+	bitBlitBytesFrom:1 to:8 with:#[1 2 3 4 5 6 7 8] startingAt:1 rule:#+
 #[1 2 3 4 5 6 7 8]
-bitBlitBytesFrom:1 to:4 with:#[1 1 1 1 1 1 1 1] startingAt:1 rule:#+
+	bitBlitBytesFrom:1 to:4 with:#[1 1 1 1 1 1 1 1] startingAt:1 rule:#+
 #[1 2 3 4 5 6 7 8]
-bitBlitBytesFrom:1 to:4 with:#[1 1 1 1 2 2 2 2] startingAt:5 rule:#+
+	bitBlitBytesFrom:1 to:4 with:#[1 1 1 1 2 2 2 2] startingAt:5 rule:#+
 #[1 2 3 4 5 6 7 8]
-bitBlitBytesFrom:1 to:4 with:#[1 1 1 1 2 2 2 2] startingAt:5 rule:#copyNot
+	bitBlitBytesFrom:1 to:4 with:#[1 1 1 1 2 2 2 2] startingAt:5 rule:#copyNot
 #[1 2 3 4 5 6 7 8]
-bitBlitBytesFrom:1 to:8 with:(1 to:8) startingAt:1 rule:#+
+	bitBlitBytesFrom:1 to:8 with:(1 to:8) startingAt:1 rule:#+
 "
 !
 bitBlitBytesFrom:dstStart to:dstEnd withConstant:sourceByte rule:ruleSymbol
 "perform a special case of an aligned bitBlit operation.
 Bytes in the receiver from dstStart to dstEnd are destructively replaced by the result
 of some logical operation, as specified by the ruleSymbol.
 Valid rule symbols are:
-#copy    - trivial;  same as from:to:put:
+	#copy    - trivial;  same as from:to:put:
-#bitXor: - xoring;   byte[dI] = byte[dI] bitXor:sourceConst
+	#bitXor: - xoring;   byte[dI] = byte[dI] bitXor:sourceConst
-#bitAnd: - anding;   byte[dI] = byte[dI] bitAnd:sourceConst
+	#bitAnd: - anding;   byte[dI] = byte[dI] bitAnd:sourceConst
-#bitOr:  - oring;    byte[dI] = byte[dI] bitOr:sourceConst
+	#bitOr:  - oring;    byte[dI] = byte[dI] bitOr:sourceConst
-#+       - adding;   byte[dI] = (byte[dI] + sourceConst) mod: 256
+	#+       - adding;   byte[dI] = (byte[dI] + sourceConst) mod: 256
-#-       - subtract; byte[dI] = (byte[dI] - sourceConst) mod: 256
+	#-       - subtract; byte[dI] = (byte[dI] - sourceConst) mod: 256
 Warning: this is a destructive operation - elements in the receiver are overwritten.
 "
 |srcIdx|
 %{
 if ((__qClass(self) == ByteArray)
 && __isSmallInteger(dstStart)
 && __isSmallInteger(dstEnd)
 && __isSmallInteger(sourceByte)) {
-unsigned char srcByte = __intVal(sourceByte);
+	unsigned char srcByte = __intVal(sourceByte);
-unsigned srcWord;
+	unsigned srcWord;
-unsigned char *dstP = __ByteArrayInstPtr(self)->ba_element;
+	unsigned char *dstP = __ByteArrayInstPtr(self)->ba_element;
-int dstLen = __byteArraySize(self);
+	int dstLen = __byteArraySize(self);
-int __dstStart = __intVal(dstStart);
+	int __dstStart = __intVal(dstStart);
-int count = __intVal(dstEnd) - __dstStart + 1;
+	int count = __intVal(dstEnd) - __dstStart + 1;
-srcWord = (srcByte << 8) | srcByte;
+	srcWord = (srcByte << 8) | srcByte;
-srcWord = (srcWord << 16) | srcWord;
+	srcWord = (srcWord << 16) | srcWord;
-if ((__dstStart >= 1)
+	if ((__dstStart >= 1)
-&& ((__dstStart + count - 1) <= dstLen)) {
+	 && ((__dstStart + count - 1) <= dstLen)) {
-dstP += __dstStart - 1;
+	    dstP += __dstStart - 1;
 #define OP_LOOP_BYTES(OP) \
 while (count > 0) {                          \
-*dstP OP srcByte;                        \
+	*dstP OP srcByte;                        \
-dstP++;                                  \
+	dstP++;                                  \
-count--;                                 \
+	count--;                                 \
 }
 #define OP_LOOP(OP) \
 while (count >= 16) {                        \
-((unsigned int *)dstP)[0] OP srcWord;    \
+	((unsigned int *)dstP)[0] OP srcWord;    \
-((unsigned int *)dstP)[1] OP srcWord;    \
+	((unsigned int *)dstP)[1] OP srcWord;    \
-((unsigned int *)dstP)[2] OP srcWord;    \
+	((unsigned int *)dstP)[2] OP srcWord;    \
-((unsigned int *)dstP)[3] OP srcWord;    \
+	((unsigned int *)dstP)[3] OP srcWord;    \
-dstP += 16;                              \
+	dstP += 16;                              \
-count -= 16;                             \
+	count -= 16;                             \
 }                                            \
 while (count >= 4) {                         \
-((unsigned int *)dstP)[0] OP srcWord;    \
+	((unsigned int *)dstP)[0] OP srcWord;    \
-dstP += 4;                               \
+	dstP += 4;                               \
-count -= 4;                              \
+	count -= 4;                              \
 }                                            \
 while (count > 0) {                          \
-*dstP OP srcByte;                        \
+	*dstP OP srcByte;                        \
-dstP++;                                  \
+	dstP++;                                  \
-count--;                                 \
+	count--;                                 \
 }
-if (ruleSymbol == @symbol(bitXor:)) {
+	    if (ruleSymbol == @symbol(bitXor:)) {
-OP_LOOP( ^= )
+		OP_LOOP( ^= )
-RETURN (self);
+		RETURN (self);
-}
+	    }
-if (ruleSymbol == @symbol(bitXorNot:)) {
+	    if (ruleSymbol == @symbol(bitXorNot:)) {
-OP_LOOP( ^=~ )
+		OP_LOOP( ^=~ )
-RETURN (self);
+		RETURN (self);
-}
+	    }
-if (ruleSymbol == @symbol(bitAnd:)) {
+	    if (ruleSymbol == @symbol(bitAnd:)) {
-OP_LOOP( &= )
+		OP_LOOP( &= )
-RETURN (self);
+		RETURN (self);
-}
+	    }
-if (ruleSymbol == @symbol(bitAndNot:)) {
+	    if (ruleSymbol == @symbol(bitAndNot:)) {
-OP_LOOP( &=~ )
+		OP_LOOP( &=~ )
-RETURN (self);
+		RETURN (self);
-}
+	    }
-if (ruleSymbol == @symbol(bitOr:)) {
+	    if (ruleSymbol == @symbol(bitOr:)) {
-OP_LOOP( |= )
+		OP_LOOP( |= )
-RETURN (self);
+		RETURN (self);
-}
+	    }
-if (ruleSymbol == @symbol(bitOrNot:)) {
+	    if (ruleSymbol == @symbol(bitOrNot:)) {
-OP_LOOP( |=~ )
+		OP_LOOP( |=~ )
-RETURN (self);
+		RETURN (self);
-}
+	    }
-if (ruleSymbol == @symbol(copy)) {
+	    if (ruleSymbol == @symbol(copy)) {
-OP_LOOP( = )
+		OP_LOOP( = )
-RETURN (self);
+		RETURN (self);
-}
+	    }
-if (ruleSymbol == @symbol(copyNot)) {
+	    if (ruleSymbol == @symbol(copyNot)) {
-OP_LOOP( =~ )
+		OP_LOOP( =~ )
-RETURN (self);
+		RETURN (self);
-}
+	    }
-if (ruleSymbol == @symbol(+)) {
+	    if (ruleSymbol == @symbol(+)) {
-OP_LOOP_BYTES( += )
+		OP_LOOP_BYTES( += )
-RETURN (self);
+		RETURN (self);
-}
+	    }
-if (ruleSymbol == @symbol(-)) {
+	    if (ruleSymbol == @symbol(-)) {
-OP_LOOP_BYTES( -= )
+		OP_LOOP_BYTES( -= )
-RETURN (self);
+		RETURN (self);
-}
+	    }
-}
+	}
 }
 #undef OP_LOOP_BYTES
 #undef OP_LOOP
 %}.
 ruleSymbol == #copy ifTrue:[
-self from:dstStart to:dstEnd put:sourceByte.
+	self from:dstStart to:dstEnd put:sourceByte.
-^ self
+	^ self
 ].
 dstStart to:dstEnd do:[:dstIdx |
-self at:dstIdx put:((self at:dstIdx) perform:ruleSymbol with:sourceByte).
+	self at:dstIdx put:((self at:dstIdx) perform:ruleSymbol with:sourceByte).
 ].
 "
 #[1 2 3 4 5 6 7 8]
-bitBlitBytesFrom:1 to:3 withConstant:1 rule:#bitXor:
+	bitBlitBytesFrom:1 to:3 withConstant:1 rule:#bitXor:
 #[1 2 3 4 5 6 7 8]
-bitBlitBytesFrom:1 to:8 withConstant:1 rule:#bitXor:
+	bitBlitBytesFrom:1 to:8 withConstant:1 rule:#bitXor:
 #[1 2 3 4 5 6 7 8]
-bitBlitBytesFrom:1 to:8 withConstant:1 rule:#bitAnd:
+	bitBlitBytesFrom:1 to:8 withConstant:1 rule:#bitAnd:
 #[1 2 3 4 5 6 7 8]
-bitBlitBytesFrom:1 to:8 withConstant:1 rule:#+
+	bitBlitBytesFrom:1 to:8 withConstant:1 rule:#+
 #[255 0 0 0 0 0 0 0]
-bitBlitBytesFrom:1 to:8 withConstant:1 rule:#+
+	bitBlitBytesFrom:1 to:8 withConstant:1 rule:#+
 #[1 2 3 4 5 6 7 8]
-bitBlitBytesFrom:1 to:4 withConstant:1 rule:#+
+	bitBlitBytesFrom:1 to:4 withConstant:1 rule:#+
 #[1 2 3 4 5 6 7 8]
-bitBlitBytesFrom:1 to:4 withConstant:1 rule:#-
+	bitBlitBytesFrom:1 to:4 withConstant:1 rule:#-
 #[1 2 3 4 5 6 7 8]
-bitBlitBytesFrom:1 to:4 withConstant:1 rule:#copyNot
+	bitBlitBytesFrom:1 to:4 withConstant:1 rule:#copyNot
 #[1 2 3 4 5 6 7 8]
-bitBlitBytesFrom:1 to:8 withConstant:1 rule:#+
+	bitBlitBytesFrom:1 to:8 withConstant:1 rule:#+
 "
 !
 bitOrBytesFrom:dstStart to:dstEnd with:sourceBytes startingAt:sourceStart
 "replace bytes in the receiver with the result of a bitOr operation.
 Warning: this is a destructive operation - elements in the receiver are overwritten."
 ^ self bitBlitBytesFrom:dstStart to:dstEnd with:sourceBytes startingAt:sourceStart rule:#bitOr:
 "
 #[1 2 3 4 5 6 7 8]
 	bitOrBytesFrom:1 to:8 with:#[1 2 3 4 5 6 7 8] startingAt:1
 #[1 2 3 4 5 6 7 8]
 	bitOrBytesFrom:1 to:8 with:#[1 1 1 1 1 1 1 1] startingAt:1
 "
 !
 bitXorBytesFrom:dstStart to:dstEnd with:sourceBytes startingAt:sourceStart
 "replace bytes in the receiver with the result of an bitXor operation.
 Warning: this is a destructive operation - elements in the receiver are overwritten."
 ^ self bitBlitBytesFrom:dstStart to:dstEnd with:sourceBytes startingAt:sourceStart rule:#bitXor:
 "
 #[1 2 3 4 5 6 7 8]
 	bitXorBytesFrom:1 to:3 with:#[1 2 3 4 5 6 7 8] startingAt:1
 #[1 2 3 4 5 6 7 8]
 	bitXorBytesFrom:1 to:8 with:#[1 2 3 4 5 6 7 8] startingAt:1
 #[1 2 3 4 5 6 7 8]
 	bitXorBytesFrom:1 to:8 with:#[1 1 1 1 1 1 1 1] startingAt:1
 "
 !
 using aMapByteArray (if non-nil).
 Notice that smalltalk indexing begins at 1; thus the map-index for a byte
 value of n is found in map at:(n + 1).
 Output bits are filled left-to right, i.e. the first byte in the input
 corresponds to the high bit(s) if the first byte in the input.
 This method can be used to convert 8-bit image data to mono, 2-bit and 4-bit
 bitmaps.
 It can also be used to compress byte-arrays into bitArrays."
 %{  /* NOCONTEXT */
 int bitsPerPixel;
 int bits;
 int ncells;
 unsigned char *map;
 if ((__qClass(self) == @global(ByteArray))
 && (__qClass(aByteArray) == @global(ByteArray))
 && __isSmallInteger(nBitsPerPixel)
 && __bothSmallInteger(height, width)) {
 	if ((aMapByteArray != nil)
 	 && (__Class(aMapByteArray) == @global(ByteArray))) {
 inBits := #[176 176 176 176 99 99 99 99 176 176 99 99 176 99 176 99].
 map := ByteArray new:256.
 map at:176+1 put:1.
 outBits := ByteArray new:2.
 inBits compressPixels:1 width:16 height:1
 		    into:outBits mapping:map.
 outBits inspect
 "
 "Example3:
 inBits := #[176 176 176 176 99 99 99 99 176 176 99 99 176 99 176 99].
 map := ByteArray new:256.
 map atAll:(128+1 to:255+1) put:1.
 outBits := ByteArray new:2.
 inBits compressPixels:1 width:16 height:1
 		    into:outBits mapping:map.
 outBits inspect
 "
 !
 int bitsPerPixel;
 int bits;
 int ncells;
 unsigned char *map;
 if ((__qClass(self) == @global(ByteArray))
 && (__qClass(aByteArray) == @global(ByteArray))
 && __isSmallInteger(nBitsPerPixel)
 && __bothSmallInteger(height, width)) {
-if ((aMapByteArray != nil)
+	if ((aMapByteArray != nil)
-&& (__Class(aMapByteArray) == @global(ByteArray))) {
+	 && (__Class(aMapByteArray) == @global(ByteArray))) {
-map = __ByteArrayInstPtr(aMapByteArray)->ba_element;
+	    map = __ByteArrayInstPtr(aMapByteArray)->ba_element;
-} else {
+	} else {
-map = (unsigned char *)0;
+	    map = (unsigned char *)0;
-}
+	}
-bitsPerPixel = __intVal(nBitsPerPixel);
+	bitsPerPixel = __intVal(nBitsPerPixel);
-w = __intVal(width);
+	w = __intVal(width);
-h = __intVal(height);
+	h = __intVal(height);
-src = __ByteArrayInstPtr(self)->ba_element;
+	src = __ByteArrayInstPtr(self)->ba_element;
-dst = __ByteArrayInstPtr(aByteArray)->ba_element;
+	dst = __ByteArrayInstPtr(aByteArray)->ba_element;
-switch (bitsPerPixel) {
+	switch (bitsPerPixel) {
-case 1:
+	    case 1:
-mask = 0x01;
+		mask = 0x01;
-break;
+		break;
-case 2:
+	    case 2:
-mask = 0x03;
+		mask = 0x03;
-break;
+		break;
-case 4:
+	    case 4:
-mask = 0x0F;
+		mask = 0x0F;
-break;
+		break;
-case 8:
+	    case 8:
-mask = 0xFF;
+		mask = 0xFF;
-break;
+		break;
-default:
+	    default:
-printf("invalid depth in expandPixels\n");
+		printf("invalid depth in expandPixels\n");
-goto fail;
+		goto fail;
-}
+	}
-ncells = mask + 1;
+	ncells = mask + 1;
-if (map) {
+	if (map) {
-/*
+	    /*
-* if a map is present, it must have the correct size
+	     * if a map is present, it must have the correct size
-* (i.e. 2 raisedTo:nBitsPerPixel)
+	     * (i.e. 2 raisedTo:nBitsPerPixel)
-*/
+	     */
-if ((__qSize(aMapByteArray) - OHDR_SIZE) < ncells) {
+	    if ((__qSize(aMapByteArray) - OHDR_SIZE) < ncells) {
-printf("invalid map in expandPixels\n");
+		printf("invalid map in expandPixels\n");
-goto fail;
+		goto fail;
-}
+	    }
-}
+	}
-bytesPerRow = (w * bitsPerPixel + 7) / 8;
+	bytesPerRow = (w * bitsPerPixel + 7) / 8;
-shift0 = 8 - bitsPerPixel;
+	shift0 = 8 - bitsPerPixel;
-srcBytes = bytesPerRow * h;
+	srcBytes = bytesPerRow * h;
-dstBytes = w * h;
+	dstBytes = w * h;
-if ((__byteArraySize(self) >= srcBytes)
+	if ((__byteArraySize(self) >= srcBytes)
-&& (__byteArraySize(aByteArray) >= dstBytes)) {
+	 && (__byteArraySize(aByteArray) >= dstBytes)) {
-for (hrun=h; hrun; hrun--) {
+	    for (hrun=h; hrun; hrun--) {
-srcNext = src + bytesPerRow;
+		srcNext = src + bytesPerRow;
-shift = shift0;
+		shift = shift0;
-if (map) {
+		if (map) {
-if (shift0 == 0) {
+		    if (shift0 == 0) {
-/* translate only */
+			/* translate only */
-for (wrun=w; wrun; wrun--) {
+			for (wrun=w; wrun; wrun--) {
-bits = *src++;
+			    bits = *src++;
-*dst++ = map[bits];
+			    *dst++ = map[bits];
-}
+			}
-} else {
+		    } else {
-for (wrun=w; wrun; wrun--) {
+			for (wrun=w; wrun; wrun--) {
-if (shift == shift0) {
+			    if (shift == shift0) {
-bits = *src++;
+				bits = *src++;
-}
+			    }
-*dst++ = map[(bits >> shift) & mask];
+			    *dst++ = map[(bits >> shift) & mask];
-shift -= bitsPerPixel;
+			    shift -= bitsPerPixel;
-if (shift < 0) {
+			    if (shift < 0) {
-shift = shift0;
+				shift = shift0;
-}
+			    }
-}
+			}
-}
+		    }
-} else {
+		} else {
-for (wrun=w; wrun; wrun--) {
+		    for (wrun=w; wrun; wrun--) {
-if (shift == shift0) {
+			if (shift == shift0) {
-bits = *src++;
+			    bits = *src++;
-}
+			}
-*dst++ = (bits >> shift) & mask;
+			*dst++ = (bits >> shift) & mask;
-shift -= bitsPerPixel;
+			shift -= bitsPerPixel;
-if (shift < 0) {
+			if (shift < 0) {
-shift = shift0;
+			    shift = shift0;
-}
+			}
-}
+		    }
-}
+		}
-src = srcNext;
+		src = srcNext;
-}
+	    }
-RETURN ( self );
+	    RETURN ( self );
-}
+	}
-printf("buffer size: self:%d expect at least:%d\n",
+	printf("buffer size: self:%d expect at least:%d\n",
-__byteArraySize(self), srcBytes);
+		__byteArraySize(self), srcBytes);
-printf("buffer size: arg:%d expect at least:%d\n",
+	printf("buffer size: arg:%d expect at least:%d\n",
-__byteArraySize(aByteArray), dstBytes);
+		__byteArraySize(aByteArray), dstBytes);
 }
 printf("invalid args\n");
 fail: ;
 %}.
 expand 1-bit-per-pixel bitmap into a 1byte-per-pixel byteArray
 "
 "
 |inBits outBits|
 inBits := #[2r11110000
-2r11001100
+		 2r11001100
-2r01010101
+		 2r01010101
-2r00001111].
+		 2r00001111].
 outBits := ByteArray new:(8*4).
 inBits expandPixels:1 width:8 height:4
-into:outBits mapping:nil.
+		    into:outBits mapping:nil.
 outBits inspect
 "
 "Example2:
 expand bit-array into a byteArray, translating 0-bits to 99,
 "
 |inBits outBits|
 inBits := #[2r11110000 2r11001100].
 outBits := ByteArray new:16.
 inBits expandPixels:1 width:16 height:1
-into:outBits mapping:#[99 176].
+		    into:outBits mapping:#[99 176].
 outBits inspect
 "
 "This Can also be used to extract nibbles ..."
 "
 |inBits outBits|
 inBits := #[ 16r12 16r34 16r56 16r78 16r9A 16rBC 16rDE 16rF0 ].
 outBits := ByteArray new:(inBits size * 2).
 inBits expandPixels:4 width:outBits size height:1 into:outBits mapping:nil.
 outBits inspect
 "
 REGISTER unsigned char *dst;
 REGISTER unsigned long *ldst;
 REGISTER int cnt;
 if (__qClass(self) == @global(ByteArray)) {
-cnt = __byteArraySize(self);
+	cnt = __byteArraySize(self);
-dst = __ByteArrayInstPtr(self)->ba_element;
+	dst = __ByteArrayInstPtr(self)->ba_element;
-if (! ((INT)dst & (sizeof(long)-1))) {
+	if (! ((INT)dst & (sizeof(long)-1))) {
-ldst = (unsigned long *)dst;
+	    ldst = (unsigned long *)dst;
-while (cnt >= (sizeof(long))*4) {
+	    while (cnt >= (sizeof(long))*4) {
-ldst[0] = ~(ldst[0]);
+		ldst[0] = ~(ldst[0]);
-ldst[1] = ~(ldst[1]);
+		ldst[1] = ~(ldst[1]);
-ldst[2] = ~(ldst[2]);
+		ldst[2] = ~(ldst[2]);
-ldst[3] = ~(ldst[3]);
+		ldst[3] = ~(ldst[3]);
-ldst += 4;
+		ldst += 4;
-cnt -= (sizeof(long))*4;
+		cnt -= (sizeof(long))*4;
-}
+	    }
-while (cnt >= sizeof(long)) {
+	    while (cnt >= sizeof(long)) {
-*ldst = ~(*ldst);
+		*ldst = ~(*ldst);
-ldst++;
+		ldst++;
-cnt -= sizeof(long);
+		cnt -= sizeof(long);
-}
+	    }
-dst = (unsigned char *)ldst;
+	    dst = (unsigned char *)ldst;
-}
+	}
-while (cnt--) {
+	while (cnt--) {
-*dst = ~(*dst);
+	    *dst = ~(*dst);
-dst++;
+	    dst++;
-}
+	}
-RETURN ( self );
+	RETURN ( self );
 }
 %}.
 self bitBlitBytesFrom:1 to:self size withConstant:16rFF rule:#bitXor:
 "
 #[1 2 3 4 5 6 7 8 9 10] copy invert
 #[1 2 3 4 5 6 7 8 9 10] copy
-bitBlitBytesFrom:1 to:10 withConstant:16rFF rule:#bitXor:
+	bitBlitBytesFrom:1 to:10 withConstant:16rFF rule:#bitXor:
 "
 !
 reverse
 "reverse the order of my elements inplace -
 WARNING: this is a destructive operation, which modifies the receiver.
 Written as a primitive for speed on image manipulations (mirror)"
 %{  /* NOCONTEXT */
 REGISTER int cnt;
 REGISTER unsigned t;
 OBJ cls;
 if (__qClass(self) == @global(ByteArray)) {
-cnt = __byteArraySize(self);
+	cnt = __byteArraySize(self);
-p1 = __ByteArrayInstPtr(self)->ba_element;
+	p1 = __ByteArrayInstPtr(self)->ba_element;
-p2 = p1 + cnt - 1;
+	p2 = p1 + cnt - 1;
 #if defined(__BSWAP)
-/*
+	/*
-* can we use the bswap instruction ?
+	 * can we use the bswap instruction ?
-* notice - not all CPUs have it (the HAS_BSWAP checks this).
+	 * notice - not all CPUs have it (the HAS_BSWAP checks this).
-*/
+	 */
-if (__HAS_BSWAP()
+	if (__HAS_BSWAP()
-&& ((cnt & 3) == 0)) {
+	 && ((cnt & 3) == 0)) {
-unsigned int *ip1, *ip2;
+	    unsigned int *ip1, *ip2;
-ip1 = (unsigned int *)p1;
+	    ip1 = (unsigned int *)p1;
-ip2 = (unsigned int *)(p2 - 3);
+	    ip2 = (unsigned int *)(p2 - 3);
-ip2 -= 7;
+	    ip2 -= 7;
-while (ip1 <= ip2) {
+	    while (ip1 <= ip2) {
-int t1, t2;
+		int t1, t2;
-t1 = ip1[0];
+		t1 = ip1[0];
-t2 = ip2[7];
+		t2 = ip2[7];
-ip2[7] = __BSWAP(t1);
+		ip2[7] = __BSWAP(t1);
-ip1[0] = __BSWAP(t2);
+		ip1[0] = __BSWAP(t2);
-t1 = ip1[1];
+		t1 = ip1[1];
-t2 = ip2[6];
+		t2 = ip2[6];
-ip2[6] = __BSWAP(t1);
+		ip2[6] = __BSWAP(t1);
-ip1[1] = __BSWAP(t2);
+		ip1[1] = __BSWAP(t2);
-t1 = ip1[2];
+		t1 = ip1[2];
-t2 = ip2[5];
+		t2 = ip2[5];
-ip2[5] = __BSWAP(t1);
+		ip2[5] = __BSWAP(t1);
-ip1[2] = __BSWAP(t2);
+		ip1[2] = __BSWAP(t2);
-t1 = ip1[3];
+		t1 = ip1[3];
-t2 = ip2[4];
+		t2 = ip2[4];
-ip2[4] = __BSWAP(t1);
+		ip2[4] = __BSWAP(t1);
-ip1[3] = __BSWAP(t2);
+		ip1[3] = __BSWAP(t2);
-ip1 += 4;
+		ip1 += 4;
-ip2 -= 4;
+		ip2 -= 4;
-}
+	    }
-ip2 += 7;
+	    ip2 += 7;
-while (ip1 < ip2) {
+	    while (ip1 < ip2) {
-int t;
+		int t;
-t = __BSWAP(*ip1);
+		t = __BSWAP(*ip1);
-*ip1++ = __BSWAP(*ip2);
+		*ip1++ = __BSWAP(*ip2);
-*ip2-- = t;
+		*ip2-- = t;
-}
+	    }
-if (ip1 == ip2) {
+	    if (ip1 == ip2) {
-int t;
+		int t;
-t = *ip1;
+		t = *ip1;
-t = __BSWAP(t);
+		t = __BSWAP(t);
-*ip1 = t;
+		*ip1 = t;
-}
+	    }
-RETURN ( self );
+	    RETURN ( self );
-}
+	}
 #endif /* __i386__ && __GNUC__ */
-p2 -= 7;
+	p2 -= 7;
-while (p1 <= p2) {
+	while (p1 <= p2) {
-t = p1[0];
+	    t = p1[0];
-p1[0] = p2[7];
+	    p1[0] = p2[7];
-p2[7] = t;
+	    p2[7] = t;
-t = p1[1];
+	    t = p1[1];
-p1[1] = p2[6];
+	    p1[1] = p2[6];
-p2[6] = t;
+	    p2[6] = t;
-t = p1[2];
+	    t = p1[2];
-p1[2] = p2[5];
+	    p1[2] = p2[5];
-p2[5] = t;
+	    p2[5] = t;
-t = p1[3];
+	    t = p1[3];
-p1[3] = p2[4];
+	    p1[3] = p2[4];
-p2[4] = t;
+	    p2[4] = t;
-p1 += 4;
+	    p1 += 4;
-p2 -= 4;
+	    p2 -= 4;
-}
+	}
-p2 += 7;
+	p2 += 7;
-while (p1 < p2) {
+	while (p1 < p2) {
-t = *p1;
+	    t = *p1;
-*p1++ = *p2;
+	    *p1++ = *p2;
-*p2-- = t;
+	    *p2-- = t;
-}
+	}
-RETURN ( self );
+	RETURN ( self );
 }
 %}.
 ^ super reverse
 "
 #[1 2 3 4 5] reverse
 #[1 2 3 4] reverse
 #[1 2 3 4 5] reverse
 #[1 2 3 4 5 6] reverse
 #[1 2 3 4 5 6 7] reverse
 #[1 2 3 4 5 6 7 8] reverse
 #[1 2 3 4 5 6 7 8 9] reverse
 #[1 2 3 4 5 6 7 8 9 10] reverse
 #[1 2 3 4 5 6 7 8 9 10 11 12] reverse
 #[1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16] reverse
 #[1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20] reverse
 (1 to:255) asByteArray reverse
 1 to:1024 do:[:i|
-|bytes test rBytes|
+	|bytes test rBytes|
-bytes := ((1 to:i) asArray collect:[:i | i bitAnd:255]) asByteArray.
+	bytes := ((1 to:i) asArray collect:[:i | i bitAnd:255]) asByteArray.
-test := ((i to:1 by:-1) asArray collect:[:i | i bitAnd:255]) asByteArray.
+	test := ((i to:1 by:-1) asArray collect:[:i | i bitAnd:255]) asByteArray.
-rBytes := bytes copy.
+	rBytes := bytes copy.
-rBytes reverse ~= test ifTrue:[
+	rBytes reverse ~= test ifTrue:[
-self halt
+	    self halt
-].
+	].
-rBytes := bytes copy.
+	rBytes := bytes copy.
-rBytes reverse reverse ~= bytes ifTrue:[
+	rBytes reverse reverse ~= bytes ifTrue:[
-self halt
+	    self halt
-]
+	]
 ].
 Time millisecondsToRun:[
-10000000 timesRepeat:[
+	10000000 timesRepeat:[
-#[1 2 3 4 5 6 7 8] reverse
+	    #[1 2 3 4 5 6 7 8] reverse
-]
+	]
 ]
 |b|
 b := (0 to:255) asByteArray.
 Time millisecondsToRun:[
-10000000 timesRepeat:[
+	10000000 timesRepeat:[
-b reverse
+	    b reverse
-]
+	]
 ]
 "
 !
 swapBytes
 "swap bytes inplace -
 written as a primitive for speed on image grabbing (if display order is different)"
 %{  /* NOCONTEXT */
 REGISTER unsigned char *p;
 }
 %}.
 ^ super swapBytes "/ rubbish - there is no one currenly
 "
 #[1 2 3 4 5 6 7 8 9 10] copy swapBytes
 #[1 2 3 4 5 6 7 8 9 10 11] copy swapBytes
 "
 !
 swapIndex:i1 and:i2
 "spap the bytes with i1 and i2"
 unsigned int __i1, __i2;
 int cnt;
 unsigned int t;
 if (__qClass(self) == @global(ByteArray) && __bothSmallInteger(i1, i2)) {
-__i1 = __intVal(i1) - 1;
+	__i1 = __intVal(i1) - 1;
-__i2 = __intVal(i2) - 1;
+	__i2 = __intVal(i2) - 1;
-cnt = __byteArraySize(self);
+	cnt = __byteArraySize(self);
-p = __ByteArrayInstPtr(self)->ba_element;
+	p = __ByteArrayInstPtr(self)->ba_element;
-if (__i1 < cnt && __i2 < cnt) {
+	if (__i1 < cnt && __i2 < cnt) {
-t = p[__i1];
+	    t = p[__i1];
-p[__i1] = p[__i2];
+	    p[__i1] = p[__i2];
-p[__i2] = t;
+	    p[__i2] = t;
-}
+	}
-RETURN ( self );
+	RETURN ( self );
 }
 %}.
 ^ super swapIndex:i1 and:i2 "/ rubbish - there is no one currenl
 "
 #[1 2 3 4 5 6 7 8 9 10] copy swapIndex:1 and:10
 #[1 2 3 4 5 6 7 8 9 10 11] copy swapIndex:5 and:6
 "
 !
 swapLongs
 "swap long bytes inplace
 - any partial longs at the end are not swapped."
 self swapLongsFrom:1 to:self size
 "
 #[1 2 3 4 5 6 7 8 9] copy swapLongs
 #[1 2 3 4 5 6 7 8 9 10] copy swapLongs
 #[1 2 3 4 5 6 7 8 9 10 11] copy swapLongs
 #[1 2 3 4 5 6 7 8 9 10 11 12] copy swapLongs
 "
 !
 swapLongsFrom:startIndex to:endIndex
 "swap longs inplace
 - any partial longs at the end are not swapped.
 Swapping is from startIndex to (exclusiv) endIndex;
 indexing starts at 1."
 %{  /* NOCONTEXT */
 }
 %}.
 ^ super swapLongsFrom:startIndex to:endIndex "/ rubbish - there is no one currenly
 "
 #[1 2 3 4 5 6 7 8 9] copy swapLongsFrom:1 to:3
 #[1 2 3 4 5 6 7 8 9] copy swapLongsFrom:1 to:4
 #[1 2 3 4 5 6 7 8 9] copy swapLongsFrom:1 to:5
 #[1 2 3 4 5 6 7 8 9] copy swapLongsFrom:1 to:6
 #[1 2 3 4 5 6 7 8 9] copy swapLongsFrom:1 to:7
 #[1 2 3 4 5 6 7 8 9] copy swapLongsFrom:1 to:8
 #[1 2 3 4 5 6 7 8 9 10] copy swapLongsFrom:1 to:11
 #[1 2 3 4 5 6 7 8 9 10 11] copy swapLongsFrom:1 to:12
 #[1 2 3 4 5 6 7 8 9 10 11 12] copy swapLongsFrom:1 to:13
 #[1 2 3 4 5 6 7 8 9] copy swapLongsFrom:5 to:10
 "
 ! !
 !ByteArray methodsFor:'printing & storing'!
 displayString
 "return a printed representation of the receiver for displaying"
 self class == ByteArray ifTrue:[
-^ self storeString
+	^ self storeString
 ].
 ^ super displayString
 "Created: 25.10.1995 / 13:33:26 / cg"
 "Modified: 22.4.1996 / 12:54:06 / cg"
 hexPrintOn:aStream
 "print as hex string, eg: 'FF0243'.
 This string can be used in #fromHexString: to recreate the byteArray"
 self do:[:byte|
-byte printOn:aStream base:16 size:2 fill:$0.
+	byte printOn:aStream base:16 size:2 fill:$0.
 ].
 "
 #[1 2 3 4 10 17] hexPrintOn:Transcript
 "
 "
 |s|
 s := String streamContents:[:s | #[1 2 3 4 10 17] hexPrintOn:s].
 ByteArray fromHexString:s
 "
 !
 printOn:aStream
 "append a printed representation to aStream"
 self class == ByteArray ifTrue:[    "/ care for subclasses
-aStream nextPutAll:'#['.
+	aStream nextPutAll:'#['.
-self
+	self
-do:[:byte | byte printOn:aStream]
+	    do:[:byte | byte printOn:aStream]
-separatedBy:[aStream space].
+	    separatedBy:[aStream space].
-aStream nextPut:$].
+	aStream nextPut:$].
-^ self
+	^ self
 ].
 ^ super printOn:aStream
 "
 #[1 2 3 4 5] printOn:Transcript
 #[1 2 3 4 5] storeString
 #[1 2 3 4 5] displayString
 #[1 2 3 4 5] printString
 "
 "Modified: / 12.9.1997 / 22:11:33 / cg"
 "Modified: / 17.3.1999 / 17:01:31 / stefan"
 !
 "
 #[1 2 3 4 5] printOn:Transcript base:2
 'Hello World' printOn:Transcript base:2
 #[1 2 3 4 5] storeString
 #[1 2 3 4 5] displayString
 #[1 2 3 4 5] printString
 "
 "Modified: / 17.3.1999 / 17:01:31 / stefan"
 "Modified: / 31.10.2001 / 09:43:56 / cg"
 !
 printOn:aStream base:radix showRadix:showRadix
 "append a printed representation to aStream in the given number base."
 self class == ByteArray ifTrue:[    "/ care for subclasses
-aStream nextPutAll:'#['.
+	aStream nextPutAll:'#['.
-self
+	self
-do:[:byte | byte printOn:aStream base:radix showRadix:showRadix]
+	    do:[:byte | byte printOn:aStream base:radix showRadix:showRadix]
-separatedBy:[aStream space].
+	    separatedBy:[aStream space].
-aStream nextPut:$].
+	aStream nextPut:$].
-^ self
+	^ self
 ].
 ^ self printOn:aStream
 "
 #[1 2 3 4 5] printOn:Transcript base:2
 'Hello World' printOn:Transcript base:2
 #[1 2 3 4 5] storeString
 #[1 2 3 4 5] displayString
 #[1 2 3 4 5] printString
 "
 "Modified: / 12.9.1997 / 22:11:33 / cg"
 "Modified: / 17.3.1999 / 17:01:31 / stefan"
 "Created: / 31.10.2001 / 09:43:41 / cg"
 storeArrayElementOn:aStream
 "Store as element of an array. Omit the leading '#'"
 self class == ByteArray ifTrue:[    "/ care for subclasses
-aStream nextPut:$[.
+	aStream nextPut:$[.
-self
+	self
-do:[:byte | byte storeOn:aStream]
+	    do:[:byte | byte storeOn:aStream]
-separatedBy:[aStream space].
+	    separatedBy:[aStream space].
-aStream nextPut:$].
+	aStream nextPut:$].
-^ self
+	^ self
 ].
 super storeArrayElementOn:aStream
 "
 #[1 2 3 4 5] storeOn:Transcript
 #[1 2 3 4 5] storeArrayElementOn:Transcript
 #[1 2 3 4 5] storeString
 #[1 2 3 4 5] displayString
 #[1 2 3 4 5] printString
 "
 "Modified: 12.9.1997 / 22:11:33 / cg"
 !
 "append a printed representation from which the receiver can be
 reconstructed to aStream. (reimplemented to make it look better)"
 self class == ByteArray ifTrue:[    "/ care for subclasses
 	aStream nextPutAll:'#['.
 	self
 	    do:[:byte | byte storeOn:aStream]
 	    separatedBy:[aStream space].
 	aStream nextPutAll:']'.
 	^ self
 ].
 ^ super storeOn:aStream
 "
 #[1 2 3 4 5] storeOn:Transcript
 #[1 2 3 4 5] storeString
 #[1 2 3 4 5] displayString
 #[1 2 3 4 5] printString
 "
 "Modified: 12.9.1997 / 22:11:33 / cg"
 ! !
 !ByteArray methodsFor:'queries'!
 max
 "return the maximum value in the receiver -
 redefined to speedup image processing and sound-player
 (which need a fast method for this on byteArrays)"
 %{  /* NOCONTEXT */
 REGISTER unsigned char *cp;
 }
 %}.
 ^ super max
 "
 #[1 2 3 1 2 3 1 2 19] max
 "
 !
 usageCounts
 "return an array filled with value-counts -
 %}
 .
 self primitiveFailed
 "
 #[1 2 3 1 2 3 1 2 250 251 250 251 255] usageCounts
 "
 !
 usedValues
 "return a new ByteArray with all used values (actually a kind of Set);
 This is needed specially in the bitmap/Imageclasses to find used colors
 of an image."
 %{  /* STACK: 400 */
 REGISTER unsigned char *cp;
 	/* create ByteArray of used values */
 	result = __BYTEARRAY_UNINITIALIZED_NEW_INT(len);
 	if (result) {
 	    cp = __ByteArrayInstPtr(result)->ba_element;
 	    for (len=0; len < 256; len++) {
 		if (f.flags[len])
 		    *cp++ = len;
 	    }
 	    RETURN ( result );
 	}
 }
 %}.
 ^ self asIdentitySet asByteArray
 "
 #[1 2 3 1 2 3 1 2 3 1 2 3 4 5 6 4 5 6] usedValues
 "
 ! !
 !ByteArray methodsFor:'searching'!
 }
 %}.
 ^ super indexOf:aByte startingAt:start
 "
 #[1 2 3 4 5 6 7 8 9 0 1 2 3 4 5] indexOf:0
 "
 ! !
 !ByteArray methodsFor:'testing'!
 isLiteral
 "return true, if the receiver can be used as a literal constant in ST syntax
 (i.e. can be used in constant arrays)"
 "/ no, simply returning true here is a mistake:
 "/ it could be a subclass of ByteArray
 "/ (of which the compiler does not know at all ...)
 ^ self class == ByteArray
 "Modified: 22.4.1996 / 12:55:30 / cg"
 ! !
 !ByteArray class methodsFor:'documentation'!
 version
-^ '$Header: /cvs/stx/stx/libbasic/ByteArray.st,v 1.168 2005-07-07 15:01:51 cg Exp $'
+^ '$Header: /cvs/stx/stx/libbasic/ByteArray.st,v 1.169 2005-07-08 14:00:04 cg Exp $'
 ! !

changeset 8908	68017b13590b
parent 8901	824a89d0b5c7
child 8913	b9498d27a554