hg/stx-libbasic: comparison ByteArray.st

equal deleted inserted replaced

-:035b338ef201
+:0929f428048d
 %}.
 ^ self basicNew:anInteger
 ! !
 !ByteArray class methodsFor:'queries'!
 elementByteSize
 "for bit-like containers, return the number of bytes stored per element.
 Here, 1 is returned"
 ^ self == ByteArray
 "Modified: 23.4.1996 / 15:56:25 / cg"
 ! !
 !ByteArray methodsFor:'Compatibility-Squeak'!
 bitXor:aByteArray
 "return a new byteArray containing the bitWise-xor of the receiver's and the
 !ByteArray methodsFor:'accessing-shorts'!
 wordAt:index
 "return the 2-bytes starting at index as an (unsigned) Integer.
 The value is retrieved in the machines natural byte order
+Notice:
+the index is a byte index; thus, this allows for unaligned access to
+words on any boundary.
 Question: should it be retrieve signed values ? (see ByteArray>>signedWordAt:)"
 %{  /* 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;
 unsigned char *byteP;
 if (__isSmallInteger(index)) {
-	indx = __intVal(index);
+indx = __intVal(index);
-	if (indx > 0) {
+if (indx > 0) {
-	    if (!__isByteArrayLike(self))
+if (!__isByteArrayLike(self))
-		indx += __OBJS2BYTES__(__intVal(__ClassInstPtr(__qClass(self))->c_ninstvars));
+indx += __OBJS2BYTES__(__intVal(__ClassInstPtr(__qClass(self))->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 ( __mkSmallInteger((val.u_ushort)) );
+RETURN ( __mkSmallInteger((val.u_ushort)) );
-	    }
+}
-	}
+}
 }
 %}.
 ^ super wordAt:index
 !
 wordAt:index MSB:msb
 "return the 2-bytes starting at index as an (unsigned) Integer.
 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.
+Notice:
+the index is a byte index; thus, this allows for unaligned access to
+words on any boundary.
 Question: should it be retrieve signed values ? (see ByteArray>>signedWordAt:)"
 %{  /* NOCONTEXT */
 REGISTER int indx;
 int nIndex;
 int val;
 unsigned char *byteP;
 if (__isSmallInteger(index)) {
-	indx = __intVal(index);
+indx = __intVal(index);
-	if (indx > 0) {
+if (indx > 0) {
-	    if (!__isByteArrayLike(self))
+if (!__isByteArrayLike(self))
-		indx += __OBJS2BYTES__(__intVal(__ClassInstPtr(__qClass(self))->c_ninstvars));
+indx += __OBJS2BYTES__(__intVal(__ClassInstPtr(__qClass(self))->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 ( __mkSmallInteger(val) );
+RETURN ( __mkSmallInteger(val) );
-	    }
+}
-	}
+}
 }
 %}.
 ^ super wordAt:index 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 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).
+Notice:
+the index is a byte index; thus, this allows for unaligned access to
+words on any boundary.
 Question: should it accept signed values ? (see ByteArray>>signedWordAt:put:)"
 %{  /* NOCONTEXT */
 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;
 unsigned char *byteP;
 if (__bothSmallInteger(index, value)) {
-	indx = __intVal(index);
+indx = __intVal(index);
-	if (indx > 0) {
+if (indx > 0) {
-	    if (!__isByteArrayLike(self))
+if (!__isByteArrayLike(self))
-		indx += __OBJS2BYTES__(__intVal(__ClassInstPtr(__qClass(self))->c_ninstvars));
+indx += __OBJS2BYTES__(__intVal(__ClassInstPtr(__qClass(self))->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
 "
 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.
+Notice:
+the index is a byte index; thus, this allows for unaligned access to
+words on any boundary.
 Question: should it accept signed values ? (see ByteArray>>signedWordAt:put:)"
 %{  /* NOCONTEXT */
 REGISTER int indx;
 int val;
 OBJ cls;
 unsigned char *byteP;
 if (__bothSmallInteger(index, value)) {
-	indx = __intVal(index);
+indx = __intVal(index);
-	if (indx > 0) {
+if (indx > 0) {
-	    if (!__isByteArrayLike(self))
+if (!__isByteArrayLike(self))
-		indx += __OBJS2BYTES__(__intVal(__ClassInstPtr(__qClass(self))->c_ninstvars));
+indx += __OBJS2BYTES__(__intVal(__ClassInstPtr(__qClass(self))->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
 "
 "
 #[1 2 3 1 2 3 1 2 3 1 2 3 4 5 6 4 5 6] usedValues
 "
 ! !
 !ByteArray methodsFor:'searching'!
 indexOf:aByte startingAt:start
 "return the index of the first occurrence of the argument, aByte
 in the receiver starting at start, anInteger; return 0 if not found.
 "
 #[1 2 3 4 5 6 7 8 9 0 1 2 3 4 5] indexOf:0 startingAt:1
 "
 ! !
 !ByteArray methodsFor:'testing'!
 isByteArray
 "return true, if the receiver is some kind of bytearray;
 true is returned here - the method is redefined from Object."

changeset 19048	0929f428048d
parent 18966	3bc73a4cdae6
child 19054	80cbbad08d0c
child 19134	eaa91cb0ef1b