hg/stx-libbasic: comparison UninterpretedBytes.st

equal deleted inserted replaced

-:2ef90564b9cc
+:8c80107973c7
 "
 COPYRIGHT (c) 1993 by Claus Gittinger
-	      All Rights Reserved
+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
 "{ Package: 'stx:libbasic' }"
 "{ NameSpace: Smalltalk }"
 ArrayedCollection subclass:#UninterpretedBytes
-	instanceVariableNames:''
+instanceVariableNames:''
-	classVariableNames:'IsBigEndian'
+classVariableNames:'IsBigEndian'
-	poolDictionaries:''
+poolDictionaries:''
-	category:'Collections-Abstract'
+category:'Collections-Abstract'
 !
 !UninterpretedBytes primitiveDefinitions!
 %{
 /*
 * (yes, C is bad ...)
 */
 #define __fetchBytePointerAndSize__(o, pPtr, pSize) \
 {\
 if (__isNonNilObject(o)) { \
-	if (__isByteArrayLike(o)) { \
+if (__isByteArrayLike(o)) { \
-	  *(pPtr) = (unsigned char *)__ByteArrayInstPtr(o)->ba_element; \
+*(pPtr) = (unsigned char *)__ByteArrayInstPtr(o)->ba_element; \
-	  *(pSize) = __byteArraySize(o); \
+*(pSize) = __byteArraySize(o); \
-	} else if (__qIsExternalBytesLike(o)) { \
+} else if (__qIsExternalBytesLike(o)) { \
-	  OBJ __sz__ = __externalBytesSize(o); \
+OBJ __sz__ = __externalBytesSize(o); \
-	  if (__isSmallInteger(__sz__)) { \
+if (__isSmallInteger(__sz__)) { \
-	    *(pSize) = __intVal(__sz__); \
+*(pSize) = __intVal(__sz__); \
-	    *(pPtr) = (unsigned char *)(__externalBytesAddress(o)); \
+*(pPtr) = (unsigned char *)(__externalBytesAddress(o)); \
-	  } else { \
+} else { \
-	    *(pSize) = 0; \
+*(pSize) = 0; \
-	    *(pPtr) = (unsigned char *)0; \
+*(pPtr) = (unsigned char *)0; \
-	  } \
+} \
-	} else { \
+} else { \
-	    *(pSize) /* nInstBytes */ = OHDR_SIZE + __OBJS2BYTES__(__intVal(__ClassInstPtr(__qClass(o))->c_ninstvars)); \
+*(pSize) /* nInstBytes */ = OHDR_SIZE + __OBJS2BYTES__(__intVal(__ClassInstPtr(__qClass(o))->c_ninstvars)); \
-	    *(pPtr) = (char *)(__InstPtr(self)) + *(pSize) /* nInstBytes */; \
+*(pPtr) = (char *)(__InstPtr(self)) + *(pSize) /* nInstBytes */; \
-	    *(pSize) = __qSize(self) - *(pSize) /* nInstBytes */; \
+*(pSize) = __qSize(self) - *(pSize) /* nInstBytes */; \
-	} \
+} \
 } else { \
-	*(pSize) = 0; \
+*(pSize) = 0; \
-	*(pPtr) = (unsigned char *)0; \
+*(pPtr) = (unsigned char *)0; \
 } \
 }
 %}
 ! !
 !UninterpretedBytes class methodsFor:'documentation'!
 copyright
 "
 COPYRIGHT (c) 1993 by Claus Gittinger
-	      All Rights Reserved
+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
 sz odd ifTrue:[ ConversionError raiseWith:aString errorString:'invalid hex string (odd size)' ].
 bytes := self new: sz // 2.
 s := aString readStream.
 1 to: sz // 2 do: [ :idx |
-	hi := s next digitValue.
+hi := s next digitValue.
-	lo := s next digitValue.
+lo := s next digitValue.
-	bytes at:idx put: ((hi bitShift:4) bitOr: lo)
+bytes at:idx put: ((hi bitShift:4) bitOr: lo)
 ].
 ^ bytes
 "
 ByteArray fromHexString:'1234FEFF'
 s := String streamContents:[:s | #[1 2 3] hexPrintOn:s].
 ByteArray fromHexString:s
 "
 "
 Time millisecondsToRun:[
-	1000000 timesRepeat:[ ByteArray fromHexString:'1234FEFF1234FEFF1234FEFF1234FEFF' ]
+1000000 timesRepeat:[ ByteArray fromHexString:'1234FEFF1234FEFF1234FEFF1234FEFF' ]
 ].
 "
 "Modified (comment): / 28-08-2013 / 20:40:04 / cg"
 !
 "read a bytearray from a printed string representation, where
 individual bytes are encoded as two hex digits, optionally separated by whiteSpace.
 See also fromHexString:, which does something similar, but does not allow for spaces"
 ^ self streamContents:[:outStream |
-	|inStream h|
+|inStream h|
-	inStream := aString readStream.
+inStream := aString readStream.
-	[
+[
-	    inStream skipSeparators.
+inStream skipSeparators.
-	    inStream atEnd
+inStream atEnd
-	] whileFalse:[
+] whileFalse:[
-	    h := inStream next:2.
+h := inStream next:2.
-	    outStream nextPut:(Integer readFrom:h base:16).
+outStream nextPut:(Integer readFrom:h base:16).
-	].
+].
 ].
 "
 ByteArray fromHexString:'1234FEFF'
 ByteArray fromHexStringWithSeparators:'   12  34 FE FF'
 "the size modulo 3 is encoded in the last character, if it is in the
 range 97 .. otherwise, its exact."
 last := aString last codePoint.
 last > 96 ifTrue:[
-	stop := stop - 3 + (last - 96)
+stop := stop - 3 + (last - 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.
-	"/ self assert:(aString at:index+1) codePoint >= 32.
+"/ self assert:(aString at:index+1) codePoint >= 32.
-	sixBits := (aString at:index+1) codePoint bitAnd:16r3F.
+sixBits := (aString at:index+1) codePoint bitAnd:16r3F.
-	n := (n bitShift:6) + sixBits.
+n := (n bitShift:6) + sixBits.
-	"/ self assert:(aString at:index+2) codePoint >= 32.
+"/ self assert:(aString at:index+2) codePoint >= 32.
-	sixBits := (aString at:index+2) codePoint bitAnd:16r3F.
+sixBits := (aString at:index+2) codePoint bitAnd:16r3F.
-	n := (n bitShift:6) + sixBits.
+n := (n bitShift:6) + sixBits.
-	"/ self assert:(aString at:index+3) codePoint >= 32.
+"/ self assert:(aString at:index+3) codePoint >= 32.
-	sixBits := (aString at:index+3) codePoint bitAnd:16r3F.
+sixBits := (aString at:index+3) codePoint 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:((ByteArray new:131) asPackedString)
 ByteArray fromPackedString:((ByteArray new:132) asPackedString)
 ByteArray fromPackedString:((ByteArray new:64) asPackedString)
 0 to:256 do:[:l |
-	|orig copy|
+|orig copy|
-	0 to:255 do:[:fill |
+0 to:255 do:[:fill |
-	    orig := ByteArray new:l withAll:fill.
+orig := ByteArray new:l withAll:fill.
-	    copy := ByteArray fromPackedString:(orig asPackedString).
+copy := ByteArray fromPackedString:(orig asPackedString).
-	    self assert:(orig = copy).
+self assert:(orig = copy).
-	 ]
+]
 ]
 "
 "Modified: / 6.3.1997 / 15:28:52 / cg"
 "Modified: / 18.12.1997 / 17:17:11 / stefan"
 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
 !
 "return true, if words/shorts store the most-significant
 byte first (MSB), false if least-sign.-first (LSB).
 I.e. false for vax, intel; true for m68k, sun.
 Notice: UninterpretedBytes isBigEndian
-	     this is inlined both by stc and the jit compiler"
+this is inlined both by stc and the jit compiler"
 %{  /* NOCONTEXT */
 #if defined(__MSBFIRST__)
 RETURN (true);
 * NOTICE:
 *    both the JIT and stc may inline this to a
 *    constant for systems where this is known.
 */
 union {
-	unsigned int   u_l;
+unsigned int   u_l;
-	char           u_c[sizeof(int)];
+char           u_c[sizeof(int)];
 } u;
 u.u_l = 0x87654321;
 if (u.u_c[0] == 0x21) RETURN (false);
 RETURN (true);
 "Modified: / 23.4.1996 / 15:56:25 / cg"
 "Modified: / 5.3.1998 / 14:56:22 / stefan"
 ! !
 !UninterpretedBytes methodsFor:'Compatibility'!
 doubleWordAt:index
 "return the 4-bytes starting at index as an (unsigned) Integer.
 The index is a smalltalk index (i.e. 1-based).
 The index is a smalltalk index (i.e. 1-based).
 The value is retrieved in the machines natural byte order.
 This may be worth a primitive.
 This is the ST80 equivalent of #signedWordAt:"
-^ (self unsignedInt16At:index MSB:IsBigEndian) signExtendedShortValue
+^ self signedInt16At:index MSB:IsBigEndian
 "
 |b|
 b := ByteArray new:2.
 b unsignedShortAt:1 put:16rFFFF.
 The index is a smalltalk index (i.e. 1-based).
 The value is retrieved MSB-first, if the msb-arg is true;
 LSB-first otherwise.
 This is the ST80 equivalent of #signedWordAt:"
-^ (self unsignedInt16At:index MSB:msb) signExtendedShortValue
+^ self signedInt16At:index MSB:msb
 "
 |b|
 b := ByteArray new:2.
 b unsignedShortAt:1 put:16rFFFF.
 "set the byte at index as bcd-value in the range 0..99.
 BCD treats nibbles (4-bit) as an encoded decimal number's digits
 (i.e. the value n is encoded as: ((n // 10) * 16) + (n \\ 10)"
 (aNumber between:0 and:99) ifFalse:[
-	self error:'invalid value for BCD encoding'
+self error:'invalid value for BCD encoding'
 ].
 ^ self byteAt:index put:aNumber encodeAsBCD
 "
 (((ByteArray new:1) bcdByteAt:1 put:55; yourself) at:1) hexPrintString
 The index is a smalltalk index (i.e. 1-based).
 Only aligned accesses are allowed."
 %{
 if (__isSmallInteger(index)) {
-	unsigned char *cp;
+unsigned char *cp;
-	INT sz;
+INT sz;
-	__fetchBytePointerAndSize__(self, &cp, &sz);
+__fetchBytePointerAndSize__(self, &cp, &sz);
-	if (cp) {
+if (cp) {
-	    unsigned INT idx = ((unsigned INT)__smallIntegerVal(index)) - 1;
+unsigned INT idx = ((unsigned INT)__smallIntegerVal(index)) - 1;
-	    char *pointer;
+char *pointer;
-	    if ((idx+(sizeof(pointer)-1)) < sz) {
+if ((idx+(sizeof(pointer)-1)) < sz) {
-		cp += idx;
+cp += idx;
-		/*
+/*
-		 * aligned
+* aligned
-		 */
+*/
-		if (((INT)cp & (sizeof(pointer)-1)) == 0) {
+if (((INT)cp & (sizeof(pointer)-1)) == 0) {
-		    pointer = ((char **)cp)[0];
+pointer = ((char **)cp)[0];
-		    RETURN (__MKEXTERNALADDRESS(pointer));
+RETURN (__MKEXTERNALADDRESS(pointer));
-		} else {
+} else {
 #if 0
-		    printf("cp UNALIGNED (%"_lx_")\n", (INT)cp);
+printf("cp UNALIGNED (%"_lx_")\n", (INT)cp);
 #endif
-		}
+}
-	    } else {
+} else {
 #if 0
-		printf("idx(%"_ld_")+(sizeof(pointer)-1) (%d) >= sz (%"_ld_")\n",
+printf("idx(%"_ld_")+(sizeof(pointer)-1) (%d) >= sz (%"_ld_")\n",
-			idx, (int)(sizeof(pointer)-1), sz);
+idx, (int)(sizeof(pointer)-1), sz);
 #endif
-	    }
+}
-	} else {
+} else {
 #if 0
-	    printf("cp is NULL\n");
+printf("cp is NULL\n");
 #endif
-	}
+}
 } else {
 #if 0
-	printf("bad index\n");
+printf("bad index\n");
 #endif
 }
 bad:;
 %}.
 %{
 OBJ *pointer;
 if (__isExternalAddressLike(value)) {
-	pointer = __externalAddressVal(value);
+pointer = __externalAddressVal(value);
 } else if (__isExternalBytesLike(value)) {
-	pointer = __externalBytesVal(value);
+pointer = __externalBytesVal(value);
-	if (pointer == (OBJ *)0)
+if (pointer == (OBJ *)0)
-	    pointer = 0;
+pointer = 0;
 } else if (value == nil) {
-	pointer = 0;
+pointer = 0;
 } else if (__isSmallInteger(value)) {
-	pointer = (OBJ *)__intVal(value);
+pointer = (OBJ *)__intVal(value);
 } else {
-	if ((pointer = (OBJ *)__unsignedLongIntVal(value)) == 0) {
+if ((pointer = (OBJ *)__unsignedLongIntVal(value)) == 0) {
-	    goto bad;
+goto bad;
-	}
+}
 }
 if (__isSmallInteger(index)) {
-	unsigned char *cp;
+unsigned char *cp;
-	INT sz;
+INT sz;
-	__fetchBytePointerAndSize__(self, &cp, &sz);
+__fetchBytePointerAndSize__(self, &cp, &sz);
-	if (cp) {
+if (cp) {
-	    unsigned INT idx = ((unsigned INT)__smallIntegerVal(index)) - 1;
+unsigned INT idx = ((unsigned INT)__smallIntegerVal(index)) - 1;
-	    if ((idx+(sizeof(pointer)-1)) < sz) {
+if ((idx+(sizeof(pointer)-1)) < sz) {
-		cp += idx;
+cp += idx;
-		/*
+/*
-		 * aligned
+* aligned
-		 */
+*/
-		if (((INT)cp & (sizeof(pointer)-1)) == 0) {
+if (((INT)cp & (sizeof(pointer)-1)) == 0) {
-		    ((char **)cp)[0] = (char *) pointer;
+((char **)cp)[0] = (char *) pointer;
-		    RETURN (value);
+RETURN (value);
-		}
+}
-	    }
+}
-	}
+}
 }
 bad:;
 %}.
 self primitiveFailed.
 !
 signedInt16At:byteIndex MSB:msb
 "return the 2-bytes starting at index as a signed Integer.
 The index is a smalltalk index (i.e. 1-based).
-The value is retrieved in the machines natural byte order.
+The value is retrieved MSB (high 8 bits at lower index) if msb is true;
-This may be worth a primitive."
+LSB-first (i.e. low 8-bits at lower byte index) if it's false.
+Notice:
-^ (self unsignedInt16At:byteIndex MSB:msb) signExtendedShortValue
+the index is a byte index; thus, this allows for unaligned access to
+words on any boundary."
-"
-|b|
+|b1 "{ Class: SmallInteger }"
-b := ByteArray new:2.
+b2 "{ Class: SmallInteger }"|
-b wordAt:1 put:16rFFFF.
-b signedWordAt:1
+%{
-"
+/*
+* handle the most common cases fast ...
-"Modified: 1.7.1996 / 21:14:38 / cg"
+*/
+if (__isSmallInteger(byteIndex)) {
+unsigned char *cp;
+INT sz;
+__fetchBytePointerAndSize__(self, &cp, &sz);
+if (cp) {
+unsigned INT idx = ((unsigned INT)__intVal(byteIndex)) - 1;
+if ((idx+(2-1)) < sz) {
+short sVal;
+cp += idx;
+if (msb == false) {
+#if defined(__i386__) || (defined(__LSBFIRST__) && defined(UNALIGNED_FETCH_OK))
+/*
+* aligned or not, we dont care (i386 can do both)
+*/
+sVal = ((short *)cp)[0];
+#else
+sVal = (cp[0] & 0xFF) | ((cp[1] & 0xFF) << 8);
+#endif
+} else {
+sVal = ((cp[0] & 0xFF) << 8) | (cp[1] & 0xFF);
+}
+RETURN (__mkSmallInteger(sVal));
+}
+}
+}
+%}.
+b1 := self byteAt:byteIndex.
+b2 := self byteAt:(byteIndex + 1).
+msb ifTrue:[
+^ ((b1 bitShift:8) + b2) signExtendedShortValue
+].
+^ ((b2 bitShift:8) + b1) signExtendedShortValue
 !
 signedInt16At:index put:anInteger
 "set the 2-bytes starting at index from the signed Integer value.
 The index is a smalltalk index (i.e. 1-based).
 "
 "Modified: 1.7.1996 / 21:12:13 / cg"
 !
-signedInt16At:index put:anInteger MSB:msb
+signedInt16At:byteIndex put:anInteger MSB:msb
-"set the 2-bytes starting at index from the signed Integer value.
+"set the 2-bytes starting at byteIndex from the signed integer value.
-The index is a smalltalk index (i.e. 1-based).
+The byteIndex is a smalltalk index (i.e. 1-based).
 The stored value must be in the range -32768 .. +32676.
 The value is stored MSB-first, if the msb-arg is true;
-LSB-first otherwise.
+LSB-first otherwise."
-This may be worth a primitive."
+%{  /* NOCONTEXT */
-|v|
+/*
+* handle the most common case fast ...
+*/
+if (__isSmallInteger(byteIndex)) {
+unsigned char *cp;
+INT sz;
+__fetchBytePointerAndSize__(self, &cp, &sz);
+if (cp) {
+unsigned INT idx = ((unsigned INT)__intVal(byteIndex)) - 1;
+if ((idx+1) < sz) {
+cp += idx;
+if (__isSmallInteger(anInteger)) {
+INT __v = __intVal(anInteger);
+if ((__v < -0x8000L) || (__v > 0x7FFF)) {
+goto badArg;
+}
+if (msb == false) {
+#if defined(__i386__) || (defined(__LSBFIRST__) && defined(UNALIGNED_FETCH_OK))
+((short *)cp)[0] = (short)__v;
+#else
+cp[0] = __v & 0xFF;
+cp[1] = (__v >> 8) & 0xFF;
+#endif
+} else {
+cp[0] = (__v >> 8) & 0xFF;
+cp[1] = __v & 0xFF;
+}
+RETURN (anInteger);
+}
+}
+}
+}
+badArg: ;
+%}.
 anInteger >= 0 ifTrue:[
-v := anInteger
+self unsignedInt16At:byteIndex put:anInteger MSB:msb.
 ] ifFalse:[
-v := 16r10000 + anInteger
+self unsignedInt16At:byteIndex put:(16r10000 + anInteger) MSB:msb.
 ].
-self unsignedInt16At:index put:v MSB:msb.
 ^ anInteger
 "
 |b|
 b := ByteArray new:4.
-b signedWordAt:1 put:-1.
+b signedInt16At:1 put:-1.
-b signedWordAt:3 put:-2.
+b signedInt16At:3 put:-2.
 b inspect
 "
 "Modified: 1.7.1996 / 21:12:13 / cg"
 !
 Subclasses may redefine this for better performance."
 ^ self unsignedInt16At:index MSB:IsBigEndian
 !
-unsignedInt16At:index MSB:msb
+unsignedInt16At:byteIndex MSB:msb
 "return the 2-bytes starting at index as an (unsigned) Integer.
 The index is a smalltalk index (i.e. 1-based).
 The value is retrieved MSB (high 8 bits at lower index) if msb is true;
-LSB-first (i.e. low 8-bits at lower byte index) if its false.
+LSB-first (i.e. low 8-bits at lower byte index) if it's false.
 Notice:
 the index is a byte index; thus, this allows for unaligned access to
 words on any boundary."
 |b1 "{ Class: SmallInteger }"
 b2 "{ Class: SmallInteger }"|
-b1 := self byteAt:index.
+%{
-b2 := self byteAt:(index + 1).
+/*
+* handle the most common cases fast ...
+*/
+if (__isSmallInteger(byteIndex)) {
+unsigned char *cp;
+INT sz;
+__fetchBytePointerAndSize__(self, &cp, &sz);
+if (cp) {
+unsigned INT idx = ((unsigned INT)__intVal(byteIndex)) - 1;
+if ((idx+(2-1)) < sz) {
+int iVal;
+cp += idx;
+if (msb == false) {
+#if defined(__i386__) || (defined(__LSBFIRST__) && defined(UNALIGNED_FETCH_OK))
+/*
+* aligned or not, we dont care (i386 can do both)
+*/
+iVal = ((unsigned short *)cp)[0];
+#else
+iVal = (cp[0] & 0xFF) | ((cp[1] & 0xFF) << 8);
+#endif
+} else {
+iVal = ((cp[0] & 0xFF) << 8) | (cp[1] & 0xFF);
+}
+RETURN (__mkSmallInteger(iVal));
+}
+}
+}
+%}.
+b1 := self byteAt:byteIndex.
+b2 := self byteAt:(byteIndex + 1).
 msb ifTrue:[
 ^ (b1 bitShift:8) + b2
 ].
 ^ (b2 bitShift:8) + b1
 !
 "Created: / 5.3.1998 / 11:54:52 / stefan"
 "Modified: / 5.3.1998 / 14:59:38 / stefan"
 !
-unsignedInt16At:index put:anInteger MSB:msb
+unsignedInt16At:byteIndex put:anInteger MSB:msb
 "set the 2-bytes starting at index from the (unsigned) Integer value.
 The index is a smalltalk index (i.e. 1-based).
 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"
 |b1 b2
 iVal "{ Class: SmallInteger }"|
+%{  /* NOCONTEXT */
+/*
+* handle the most common case fast ...
+*/
+if (__isSmallInteger(byteIndex)) {
+unsigned char *cp;
+INT sz;
+__fetchBytePointerAndSize__(self, &cp, &sz);
+printf("cp=%"_lx_"\n", (INT)cp);
+if (cp) {
+unsigned INT idx = ((unsigned INT)__intVal(byteIndex)) - 1;
+if ((idx+1) < sz) {
+cp += idx;
+if (__isSmallInteger(anInteger)) {
+INT __v = __intVal(anInteger);
+if (((unsigned INT)__v) > 0xFFFF) {
+goto badArg;
+}
+if (msb == false) {
+#if defined(__i386__) || (defined(__LSBFIRST__) && defined(UNALIGNED_FETCH_OK))
+((unsigned short *)cp)[0] = (unsigned short)__v;
+#else
+cp[0] = __v & 0xFF;
+cp[1] = (__v >> 8) & 0xFF;
+#endif
+} else {
+cp[0] = (__v >> 8) & 0xFF;
+cp[1] = __v & 0xFF;
+}
+RETURN (anInteger);
+}
+}
+}
+}
+badArg: ;
+%}.
 iVal := anInteger.
 ((iVal < 0) or:[iVal > 16rFFFF]) ifTrue:[
 ^ self elementBoundsError:iVal
 ].
 msb ifTrue:[
 b2 := (iVal bitAnd:16rFF).
 ] ifFalse:[
 b1 := (iVal bitAnd:16rFF).
 b2 := ((iVal bitShift:-8) bitAnd:16rFF).
 ].
-self byteAt:index   put:b1.
+self byteAt:byteIndex   put:b1.
-self byteAt:index+1 put:b2.
+self byteAt:byteIndex+1 put:b2.
 ^ anInteger
 "
 |b|
 b := ByteArray new:8.
-b unsignedShortAt:1 put:16r0102 bigEndian:false.
+b unsignedInt16At:1 put:16r0102 MSB:false.
-b unsignedShortAt:3 put:16r0304 bigEndian:false.
+b unsignedInt16At:3 put:16r0304 MSB:false.
-b unsignedShortAt:5 put:16r0102 bigEndian:true.
+b unsignedInt16At:5 put:16r0102 MSB:true.
-b unsignedShortAt:7 put:16r0304 bigEndian:true.
+b unsignedInt16At:7 put:16r0304 MSB:true.
 b inspect
 "
 "Modified: / 21.1.1998 / 17:48:15 / cg"
 "Modified: / 5.3.1998 / 11:52:28 / stefan"
 |stream i "{ Class: SmallInteger }" c|
 stream := WriteStream on:(String new:40).
 i := index.
 [(c := self byteAt:i) ~~ 0] whileTrue:[
-	stream nextPut:(Character value:c).
+stream nextPut:(Character value:c).
-	i := i + 1.
+i := i + 1.
 ].
 ^ stream contents
 "
 #[71 72 73 74 75 76 77 0] stringAt:1
 stream := WriteStream on:(String new:maxSize).
 start := index.
 max := start + maxSize - 1.
 start to:max do:[:eachIndex|
-	c := self byteAt:eachIndex.
+c := self byteAt:eachIndex.
-	c == 0 ifTrue:[
+c == 0 ifTrue:[
-	    ^ stream contents
+^ stream contents
-	].
+].
-	stream nextPut:(Character value:c).
+stream nextPut:(Character value:c).
 ].
 ^ stream contents
 "
 #[71 72 73 74 75 76 77] stringAt:1 size:7
 |size cls|
 cls := self class.
 (cls == ByteArray or:[cls == ImmutableByteArray or:[cls == ExternalBytes]]) 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.
 "
 #[16r41 16r42 16r43] asString
 "test:
 |utf8Encoding original readBack|
 1 to:16rFFFF do:[:ascii |
-	original := (Character value:ascii) asString.
+original := (Character value:ascii) asString.
-	utf8Encoding := original utf8Encoded.
+utf8Encoding := original utf8Encoded.
-	readBack := utf8Encoding utf8Decoded.
+readBack := utf8Encoding utf8Decoded.
-	readBack = original ifFalse:[
+readBack = original ifFalse:[
-	    self halt
+self halt
-	]
+]
 ]
 "
 !
 utf8DecodedWithTwoByteCharactersReplacedBy:replacementCharacter
 and replace them with replacementCharacter"
 |in out c|
 self containsNon7BitAscii ifFalse:[
-	^ self asSingleByteString
+^ self asSingleByteString
 ].
 out := WriteStream on:(String uninitializedNew:self size * 3 // 2).
 in := self readStream.
 [in atEnd] whileFalse:[
-	c := Character utf8DecodeFrom:in.
+c := Character utf8DecodeFrom:in.
-	c codePoint > 16rFF ifTrue:[
+c codePoint > 16rFF ifTrue:[
-	    c := replacementCharacter
+c := replacementCharacter
-	].
+].
-	out nextPut:c.
+out nextPut:c.
 ].
 ^ out contents
 "
 (Character value:16r220) utf8Encoded
-	utf8DecodedWithTwoByteCharactersReplacedBy:(Character space)
+utf8DecodedWithTwoByteCharactersReplacedBy:(Character space)
 (Character value:16r220) utf8Encoded asExternalBytes copyButLast
-	utf8DecodedWithTwoByteCharactersReplacedBy:(Character space)
+utf8DecodedWithTwoByteCharactersReplacedBy:(Character space)
 "
 ! !
 !UninterpretedBytes methodsFor:'filling & replacing'!
 #ifndef NO_PRIM_BYTEARR
 if ((__isBytes(aCollection) || __isExternalBytesLike(aCollection))
 && (__isBytes(self) || __isWords(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 {
-			if (__isStringLike(aCollection)) {
+if (__isStringLike(aCollection)) {
-			    repNIndex = __stringSize(aCollection);
+repNIndex = __stringSize(aCollection);
-			} 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 /* 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
 %}.
 "
 "
 self slowReplaceBytesFrom: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
 Notice: This operation modifies the receiver, NOT a copy;
 therefore the change may affect all others referencing the receiver."
 ^ self
-	replaceBytesFrom:startIndex
+replaceBytesFrom:startIndex
-	to:(startIndex + replacementCollection size - repStartIndex)
+to:(startIndex + replacementCollection size - repStartIndex)
-	with:replacementCollection
+with:replacementCollection
-	startingAt:repStartIndex
+startingAt:repStartIndex
 "
 args:    startIndex            : <integer>
-	      replacementCollection : <collection of <bytes> >
+replacementCollection : <collection of <bytes> >
-	      repStartIndex         : <integer>
+repStartIndex         : <integer>
 returns: self
 "
 "Created: / 27.7.1998 / 16:56:46 / cg"
 Notice: This operation modifies the receiver, NOT a copy;
 therefore the change may affect all others referencing the receiver."
 ^ self
-	replaceBytesFrom:1
+replaceBytesFrom:1
-	to:(replacementCollection size min:self size)
+to:(replacementCollection size min:self size)
-	with:replacementCollection
+with:replacementCollection
-	startingAt:1
+startingAt:1
 "
 (ByteArray new:10) replaceBytesWith:'hello'
 (ByteArray new:10) replaceBytesWith:'hello world bla bla bla'
 "
 Notice: This operation modifies the receiver, NOT a copy;
 therefore the change may affect all others referencing the receiver."
 self class isBytes ifTrue:[
-	((aCollection class == self class)
+((aCollection class == self class)
-	 or:[aCollection isByteCollection]) ifTrue:[
+or:[aCollection isByteCollection]) ifTrue:[
-	    ^ self replaceBytesFrom:startIndex to:stopIndex with:aCollection startingAt:repStartIndex
+^ self replaceBytesFrom:startIndex to:stopIndex with:aCollection startingAt:repStartIndex
-	].
+].
 ].
 ^ super replaceFrom:startIndex to:stopIndex with:aCollection startingAt:repStartIndex
 "
 args:    startIndex            : <integer>
-	      stopIndex             : <integer>
+stopIndex             : <integer>
-	      replacementCollection : <collection of <bytes> >
+replacementCollection : <collection of <bytes> >
-	      repStartIndex         : <integer>
+repStartIndex         : <integer>
 returns: self
 "
 "Modified: / 08-05-2012 / 13:23:27 / cg"
 "compute and answer the SmallInteger-Hash of the bytes
 from startIndex to endIndex.
 If endindex = 0 or endIndex > size, hash up the size.
 NOTE: startIndex and endIndex are only hints about what should be hashed.
-	   In fact, more bytes could be involved in hashing.
+In fact, more bytes could be involved in hashing.
-	   SO ARRAYS MUST BE EQUAL TO HASH TO THE SAME VALUE"
+SO ARRAYS MUST BE EQUAL TO HASH TO THE SAME VALUE"
 |w|
 %{
 if (__bothSmallInteger(startIndex, endIndex)) {
-	unsigned char *cp;
+unsigned char *cp;
-	INT sz;
+INT sz;
-	__fetchBytePointerAndSize__(self, &cp, &sz);
+__fetchBytePointerAndSize__(self, &cp, &sz);
-	if (cp) {
+if (cp) {
-	    INT sidx = ((unsigned INT)__smallIntegerVal(startIndex)) - 1;
+INT sidx = ((unsigned INT)__smallIntegerVal(startIndex)) - 1;
-	    INT eidx = ((unsigned INT)__smallIntegerVal(endIndex)) - 1;
+INT eidx = ((unsigned INT)__smallIntegerVal(endIndex)) - 1;
-	    unsigned char *ep;
+unsigned char *ep;
-	    unsigned INT hash = 0, hash2 = 0, carry;
+unsigned INT hash = 0, hash2 = 0, carry;
-	    int i;
+int i;
-	    if (eidx < 0 || eidx >= sz) eidx = sz - 1;
+if (eidx < 0 || eidx >= sz) eidx = sz - 1;
-	    if (sidx > eidx) sidx = eidx;
+if (sidx > eidx) sidx = eidx;
-	    if (sidx < 0) {
+if (sidx < 0) {
-		RETURN(__mkSmallInteger(0));
+RETURN(__mkSmallInteger(0));
-	    }
+}
-	    ep = cp + eidx;
+ep = cp + eidx;
-	    cp += sidx;
+cp += sidx;
 #if 0
-	    /*
+/*
-	     * On LSB-First (little endian) cpus,
+* On LSB-First (little endian) cpus,
-	     * this code does not produce the same result
+* this code does not produce the same result
-	     * if the same bytes are at different positions
+* if the same bytes are at different positions
-	     */
+*/
-	    if ((INT)cp & (sizeof(INT)-1)) {
+if ((INT)cp & (sizeof(INT)-1)) {
-		/* not aligned */
+/* not aligned */
-		for (i=0; cp <= ep; cp++) {
+for (i=0; cp <= ep; cp++) {
-		    hash2 = (hash2 << 8) | *cp;
+hash2 = (hash2 << 8) | *cp;
-		    if (++i == sizeof(INT)) {
+if (++i == sizeof(INT)) {
-			hash ^= hash2;
+hash ^= hash2;
-			i = hash2 = 0;
+i = hash2 = 0;
-		    }
+}
-		}
+}
-	    } else {
+} else {
-		/* aligned */
+/* aligned */
-		for (; cp+sizeof(INT) <= ep; cp += sizeof(INT)) {
+for (; cp+sizeof(INT) <= ep; cp += sizeof(INT)) {
-		    hash ^= *(unsigned INT *)cp;
+hash ^= *(unsigned INT *)cp;
-		}
+}
-		for (; cp <= ep; cp++) {
+for (; cp <= ep; cp++) {
-		    hash2 = (hash2 << 8) | *cp;
+hash2 = (hash2 << 8) | *cp;
-		}
+}
-	    }
+}
 #else
-	    for (i=0; cp <= ep-sizeof(INT); cp += sizeof(INT)) {
+for (i=0; cp <= ep-sizeof(INT); cp += sizeof(INT)) {
-		hash2 = cp[0];
+hash2 = cp[0];
-		hash2 = (hash2 << 8) | cp[1];
+hash2 = (hash2 << 8) | cp[1];
-		hash2 = (hash2 << 8) | cp[2];
+hash2 = (hash2 << 8) | cp[2];
-		hash2 = (hash2 << 8) | cp[3];
+hash2 = (hash2 << 8) | cp[3];
 #if __POINTER_SIZE__ == 8
-		hash2 = (hash2 << 8) | cp[4];
+hash2 = (hash2 << 8) | cp[4];
-		hash2 = (hash2 << 8) | cp[5];
+hash2 = (hash2 << 8) | cp[5];
-		hash2 = (hash2 << 8) | cp[6];
+hash2 = (hash2 << 8) | cp[6];
-		hash2 = (hash2 << 8) | cp[7];
+hash2 = (hash2 << 8) | cp[7];
 #endif
-		/*
+/*
-		 * multiply by large prime to scramble bits and
+* multiply by large prime to scramble bits and
-		 * to avoid a 0 result from
+* to avoid a 0 result from
-		 * #[1 2 3 4 1 2 3 4] computeXorHashFrom:1 to:8.
+* #[1 2 3 4 1 2 3 4] computeXorHashFrom:1 to:8.
-		 */
+*/
-		hash ^= (hash * 31415821) ^ hash2;
+hash ^= (hash * 31415821) ^ hash2;
-	    }
+}
-	    for (hash2 = 0; cp <= ep; cp++) {
+for (hash2 = 0; cp <= ep; cp++) {
-		hash2 = (hash2 << 8) | *cp;
+hash2 = (hash2 << 8) | *cp;
-	    }
+}
 #endif
-	    hash ^= (hash * 31415821) ^ hash2;
+hash ^= (hash * 31415821) ^ hash2;
-	    /*
+/*
-	     * fold the high bits not fitting into a SmallInteger
+* fold the high bits not fitting into a SmallInteger
-	     */
+*/
-	    carry = hash & ~_MAX_INT;
+carry = hash & ~_MAX_INT;
-	    if (carry) {
+if (carry) {
-		hash = (hash & _MAX_INT) ^ (carry >> 8);
+hash = (hash & _MAX_INT) ^ (carry >> 8);
-	    }
+}
-	    RETURN(__mkSmallInteger(hash));
+RETURN(__mkSmallInteger(hash));
-	}
+}
 }
 %}.
 ^ self primitiveFailed
 |first|
 first := true.
 1 to:self size do:[:idx |
-	aSeparatorStringOrCharacterOrNil notNil ifTrue:[
+aSeparatorStringOrCharacterOrNil notNil ifTrue:[
-	    first ifFalse:[
+first ifFalse:[
-		aSeparatorStringOrCharacterOrNil printOn:aStream
+aSeparatorStringOrCharacterOrNil printOn:aStream
-	    ] ifTrue:[
+] ifTrue:[
-		first := false.
+first := false.
-	    ].
+].
-	].
+].
-	(self byteAt:idx) printOn:aStream base:16 size:2 fill:$0.
+(self byteAt:idx) printOn:aStream base:16 size:2 fill:$0.
 ].
 "
 #[1 2 3 4 10 17] hexPrintOn:Transcript withSeparator:$:
 #[1 2 3 4 10 17] hexPrintOn:Transcript withSeparator:(Character space)
 hexPrintStringWithSeparator:aSeparatorStringOrCharacterOrNil
 "print as hex string, eg: 'FF:02:43'."
 ^ String
-	streamContents:[:s |
+streamContents:[:s |
-	    self hexPrintOn:s withSeparator:aSeparatorStringOrCharacterOrNil.
+self hexPrintOn:s withSeparator:aSeparatorStringOrCharacterOrNil.
-	]
+]
 "
 #[1 2 3 4 10 17] hexPrintStringWithSeparator:$:
 #[1 2 3 4 10 17] hexPrintStringWithSeparator:Character space
 #[1 2 3 4 10 17] hexPrintStringWithSeparator:' - '
 referencesAny:aCollection
 "redefined to speed up searching when many of my instances are present"
 %{ /* NOCONTEXT */
 if (__mkSmallInteger(0) == __ClassInstPtr(__qClass(self))->c_ninstvars) {
-	/* I am only bytes */
+/* I am only bytes */
-	RETURN(false)
+RETURN(false)
 }
 %}.
 ^ super referencesAny:aCollection
 "
-	'abc' referencesAny:#()
+'abc' referencesAny:#()
 "
 !
 sizeInBytes
 "return the number of 8-bit bytes in the receiver.

branch	jv
changeset 19408	8c80107973c7
parent 19354	ec77be1507a3
parent 19368	1811855e8abb
child 19412	1e842c25e51e