hg/stx-libbasic: comparison UIBytes.st

equal deleted inserted replaced

-:1228d4ba9518
+:a94725308432
 	instanceVariableNames:''
 	classVariableNames:'IsBigEndian'
 	poolDictionaries:''
 	category:'Collections-Abstract'
 !
+!UninterpretedBytes primitiveDefinitions!
+%{
+/*
+* Notice: I am abstract, and my subclasses may be anything.
+* Therefore, the code must always handle the fallback case
+* where the receiver is neither an ExternalBytes nor a ByteArray.
+* (which are, however, the most common)
+*
+* macro to fetch my byte address and size-in-bytes;
+* convenient for inline-C code.
+* (yes, C is bad ...)
+*/
+#define __fetchBytePointerAndSize__(o, pPtr, pSize) \
+{\
+if (__isNonNilObject(o)) { \
+if (__qClass(o) == ByteArray) { \
+	  *(pPtr) = (char *)__ByteArrayInstPtr(o)->ba_element; \
+	  *(pSize) = __byteArraySize(o); \
+	} else if (__qClass(o) == ExternalBytes) { \
+	  OBJ __sz__ = __externalBytesSize(o); \
+	  if (__isSmallInteger(__sz__)) { \
+	    *(pSize) = __intVal(__sz__); \
+	    *(pPtr) = (char *)(__externalBytesAddress(o)); \
+	  } else { \
+	    *(pPtr) = (char *)0; \
+	  } \
+	} else { \
+	    *(pPtr) = (char *)0; \
+	} \
+} else { \
+	*(pPtr) = (char *)0; \
+} \
+}
+%}
+! !
 !UninterpretedBytes class methodsFor:'documentation'!
 copyright
 "
 and
 	ExternalBytes (which store the bytes in the malloc-heap).
 UninterpretedBytes itself is abstract, so no instances of it can be created.
+[See also:]
+ByteArray String ExternalBytes
 [author:]
 Claus Gittinger
-[See also:]
+[Notice:]
-ByteArray String ExternalBytes
+	Notice the confusion due to multiple methods with the same
+functionality (i.e. 'xxxx:MSB:' vs. 'xxxx:bigEndian:').
-[author:]
+The reason is that at the time this class was written,
-Claus Gittinger
+ST80 sid not offer protocol to specify the byteOrder, and
+ST/X provided methods ending in 'MSB:' for this.
+In the meanwhile, VW added protocol ending in 'bigEndian:',
+	which has been added here for compatibility.
+	(certainly a point, where an ansi-standard will help)
 "
 ! !
 !UninterpretedBytes class methodsFor:'initialization'!
 %{  /* NOCONTEXT */
 /*
 * I dont like ifdefs - you always forget some ...
-* therefore we look into a structure at run-time
+* therefore we look into a structure at run-time.
+* (also, there are CPUs around [mips], where the byteorder
+*  is programmable, and which come in different flavours)
+*
+* NOTICE:
+*    both the JIT and stc may inline this to a
+*    constant for systems where this is known.
 */
 union {
 	unsigned int   u_l;
 	char           u_c[sizeof(int)];
 } u;
 u.u_l = 0x87654321;
 if (u.u_c[0] == 0x21) RETURN (false);
 RETURN (true);
 %}
-"UninterpretedBytes isBigEndian"
+"
+UninterpretedBytes isBigEndian
+"
 !
 isBuiltInClass
 "return true if this class is known by the run-time-system.
 Here, true is returned, since UninterpretedBytes is the superclass of
 ^ self subclassResponsibility
 !
 doubleAt:index
 "return the 8-bytes starting at index as a Float.
+The index is a smalltalk index (i.e. 1-based).
 Notice, that (currently) ST/X Floats are what Doubles are in ST-80.
 Notice also, that the bytes are expected to be in this machines
 float representation - if the bytearray originated from another
 machine, some conversion is usually needed."
 |newFloat|
+%{
+/*
+* handle the most common cases fast ...
+*/
+if (__isSmallInteger(index)) {
+	char *cp;
+	int sz;
+	__fetchBytePointerAndSize__(self, &cp, &sz);
+if (cp) {
+	    unsigned INT idx = ((unsigned INT)__intVal(index)) - 1;
+	    if ((idx+7) < sz) {
+		cp += idx;
+		/*
+		 * aligned
+		 */
+		if (((INT)cp & 7) == 0) {
+		    double dVal = ((double *)cp)[0];
+		    RETURN (__MKFLOAT(dVal));
+		}
+	    }
+	}
+}
+%}.
 newFloat := Float basicNew.
 1 to:8 do:[:destIndex|
 	newFloat basicAt:destIndex put:(self at:index - 1 + destIndex)
 ].
 ^ newFloat.
+"
+|b|
+b := ByteArray new:20.
+b doubleAt:1 put:(Float pi).
+Transcript showCR:b.
+Transcript showCR:(b doubleAt:1)
+"
 !
 doubleAt:index put:aFloat
 "store the value of the argument, aFloat into the receiver
 starting at index.
+The index is a smalltalk index (i.e. 1-based).
 Notice, that (currently) ST/X Floats are what Doubles are in ST-80.
 Notice also, that the bytes are expected to be in this machines
 float representation - if the bytearray originated from another
 machine, some conversion is usually needed."
 |flt|
 flt := aFloat asFloat.
+%{
+/*
+* handle the most common cases fast ...
+*/
+if (__isSmallInteger(index) && __isFloat(flt)) {
+char *cp;
+int sz;
+__fetchBytePointerAndSize__(self, &cp, &sz);
+if (cp) {
+unsigned INT idx = ((unsigned INT)__intVal(index)) - 1;
+if ((idx+7) < sz) {
+cp += idx;
+/*
+* aligned
+*/
+if (((INT)cp & 7) == 0) {
+((double *)cp)[0] = __floatVal(flt);
+RETURN (aFloat);
+}
+}
+}
+}
+%}.
 1 to:8 do:[:srcIndex|
 self at:index - 1 + srcIndex put:(flt basicAt:srcIndex)
 ].
 ^ aFloat
 !
 doubleWordAt:index
 "return the 4-bytes starting at index as an (unsigned) Integer.
+The index is a smalltalk index (i.e. 1-based).
 The value is retrieved in the machines natural byte order.
 Subclasses may redefine this for better performance."
 ^ self doubleWordAt:index MSB:IsBigEndian
 "Modified: / 5.3.1998 / 14:57:35 / stefan"
 !
 doubleWordAt:index MSB:msb
 "return the 4-bytes starting at index as an (unsigned) Integer.
+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.
 Subclasses may redefine this for better performance."
 |val
-ival "{ Class: SmallInteger }"
+ival "{ XXClass: SmallInteger }"
 i    "{ Class: SmallInteger }"
 b1   "{ Class: SmallInteger }"
 b2   "{ Class: SmallInteger }"
 b3   "{ Class: SmallInteger }"
 b4   "{ Class: SmallInteger }"|
 msb ifTrue:[
 ival := b1.
 ival := (ival bitShift:8) + b2.
 ival := (ival bitShift:8) + b3.
-val := (ival * 256) + b4.
+val := (ival bitShift:8) + b4.
 ] ifFalse:[
 ival := b4.
 ival := (ival bitShift:8) + b3.
 ival := (ival bitShift:8) + b2.
-val := (ival * 256) + b1.
+val := (ival bitShift:8) + b1.
 ].
 ^ val
 "
 |b|
 "Modified: / 21.1.1998 / 17:42:30 / cg"
 !
 doubleWordAt:index put:value
 "set the 4-bytes starting at index from the (unsigned) Integer value.
+The index is a smalltalk index (i.e. 1-based).
 The value should be in the range 0 to 16rFFFFFFFF
 (for negative values, the stored value is not defined).
 The value is stored in the machines natural byte order.
 Subclasses may redefine this for better performance."
 "Modified: / 5.3.1998 / 14:57:48 / stefan"
 !
 doubleWordAt:index put:aNumber MSB:msb
 "set the 4-bytes starting at index from the (unsigned) Integer value.
+The index is a smalltalk index (i.e. 1-based).
 The value must be in the range 0 to 16rFFFFFFFF.
 The value is stored MSB-first if msb is true; LSB-first otherwise.
 Subclasses may redefine this for better performance."
 |i "{ Class: SmallInteger }" |
 "Created: / 21.1.1998 / 17:44:19 / cg"
 !
 floatAt:index
 "return the 4-bytes starting at index as a Float.
+The index is a smalltalk index (i.e. 1-based).
 Notice, that (currently) ST/X Floats are what Doubles are in ST-80;
 therefore this method reads a 4-byte float from the byteArray and returns
 a float object which keeps an 8-byte double internally.
 Notice also, that the bytes are expected to be in this machines
 float representation and order - if the bytearray originated from another
 !
 floatAt:index put:aFloat
 "store the 4 bytes of value of the argument, aFloat into the receiver
 starting at index.
+The index is a smalltalk index (i.e. 1-based).
 Notice, that (currently) ST/X Floats are what Doubles are in ST-80.
 Notice also, that the bytes are expected to be in this machines
 float representation - if the bytearray originated from another
 machine, some conversion is usually needed."
 ^ aFloat
 !
 ieeeDoubleAt:index
 "retrieve the 8 bytes starting at index as a float.
+The index is a smalltalk index (i.e. 1-based).
 The 8 bytes are assumed to be in IEEE floating point single precision
 number format."
 "
 currently, we assume that the machines native number format is already
 IEEE format - we need some more code here whenever ST/X is ported
 to an IBM 370 or old VAX etc.
 To date, all supported systems use IEEE float numbers, so there should be
 no problem.
 "
+self isIEEEFormat ifFalse:[self error:'unsupported operation'].
 ^ self doubleAt:index
 "Created: / 5.3.1998 / 10:50:03 / stefan"
 !
 ieeeDoubleAt:index put:aFloat
 "store the value of the argument, aFloat into the receiver
+The index is a smalltalk index (i.e. 1-based).
 starting at index. Storage is in IEEE floating point double precision format.
 (i.e. 8 bytes are stored)."
 "
 currently, we assume that the machines native number format is already
 IEEE format - we need some more code here whenever ST/X is ported
 to an IBM 370 or old VAX etc.
 To date, all supported systems use IEEE float numbers, so there should be
 no problem.
 "
+self isIEEEFormat ifFalse:[self error:'unsupported operation'].
 ^ self doubleAt:index put:aFloat
 "Created: / 5.3.1998 / 10:50:26 / stefan"
 !
 ieeeFloatAt:index
 "retrieve the 4 bytes starting at index as a float.
+The index is a smalltalk index (i.e. 1-based).
 The 4 bytes are assumed to be in IEEE floating point single precision
 number format."
 "
 currently, we assume that the machines native number format is already
 IEEE format - we need some more code here whenever ST/X is ported
 to an IBM 370 or old VAX etc.
 To date, all supported systems use IEEE float numbers, so there should be
 no problem.
 "
+self isIEEEFormat ifFalse:[self error:'unsupported operation'].
 ^ self floatAt:index
 "Created: / 5.3.1998 / 10:50:45 / stefan"
 !
 ieeeFloatAt:index put:aFloat
 "store the value of the argument, aFloat into the receiver
-starting at index. Storage is in IEEE floating point single precision format.
+starting at index, which is a smalltalk index (i.e. 1-based).
+Storage is in IEEE floating point single precision format.
 (i.e. 4 bytes are stored). Since ST/X floats are really doubles, the low-
 order 4 bytes of the precision is lost."
 "
 currently, we assume that the machines native number format is already
 IEEE format - we need some more code here whenever ST/X is ported
 to an IBM 370 or old VAX etc.
 To date, all supported systems use IEEE float numbers, so there should be
 no problem.
 "
+self isIEEEFormat ifFalse:[self error:'unsupported operation'].
 ^ self floatAt:index put:aFloat
 "Created: / 5.3.1998 / 10:51:11 / stefan"
 !
 longAt:index
 "return the 4-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.
 This may be worth a primitive."
 |w|
 "Modified: / 5.3.1998 / 12:06:28 / stefan"
 !
 longAt:index bigEndian:msb
 "return the 4-bytes starting at index as a signed Integer.
+The index is a smalltalk index (i.e. 1-based).
 Depending on msb, the value is retrieved MSB-first or LSB-first.
 This may be worth a primitive."
 |w|
 "Created: / 5.3.1998 / 14:02:03 / stefan"
 !
 longAt:index put:value
 "set the 4-bytes starting at index from the signed Integer value.
+The index is a smalltalk index (i.e. 1-based).
 The value is stored in the machines natural byte order.
 This may be worth a primitive.
 This is the ST80 version of #signedDoubleWordAt:put:"
 "Created: / 5.3.1998 / 10:57:18 / stefan"
 !
 longLongAt:index
 "return the 4-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.
 This may be worth a primitive."
 |w|
 "Modified: / 5.3.1998 / 14:58:32 / stefan"
 !
 longLongAt:index bigEndian:msb
 "return the 4-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.
 This may be worth a primitive."
 |w|
 "Created: / 5.3.1998 / 14:40:54 / stefan"
 !
 longLongAt:byteIndex put:anInteger
 "store a signed longLong (64bit) integer.
+The index is a smalltalk index (i.e. 1-based).
 Same as #signedQuadWordAt:put: - for ST80 compatibility."
 ^ self signedQuadWordAt:byteIndex put:anInteger
 "Modified: / 3.4.1998 / 13:33:14 / cg"
 "Created: / 3.4.1998 / 13:34:22 / cg"
 !
 quadWordAt:index MSB:msb
 "return the 8-bytes starting at index as an (unsigned) Integer.
+The index is a smalltalk index (i.e. 1-based).
 Depending on msb, the value is retrieved MSB or LSB-first."
 |l
 bIdx  "{ Class: SmallInteger }"
 delta "{ Class: SmallInteger }"|
 "Modified: 5.11.1996 / 14:06:21 / cg"
 !
 quadWordAt:index put:anInteger MSB:msb
 "set the 8-bytes starting at index from the (unsigned) Integer value.
+The index is a smalltalk index (i.e. 1-based).
 The value must be in the range 0 to 16rFFFFFFFFFFFFFFFF.
 Depending on msb, the value is stored MSB-first or LSB-first."
 |bIdx  "{ Class: SmallInteger }"
 delta "{ Class: SmallInteger }"|
 "
 !
 shortAt:index
 "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.
 This may be worth a primitive.
 This is the ST80 equivalent of #signedWordAt:"
 ^ (self unsignedShortAt:index) signExtendedShortValue
 "Modified: / 5.3.1998 / 23:39:38 / stefan"
 !
 shortAt:index bigEndian: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 MSB-first, if the msb-arg is true;
 LSB-first otherwise.
 This is the ST80 equivalent of #signedWordAt:"
 ^ (self unsignedShortAt:index bigEndian:msb) signExtendedShortValue
 "Created: / 5.3.1998 / 23:41:21 / stefan"
 !
 shortAt:index put:value
 "set the 2-bytes starting at index from the signed Integer value.
+The index is a smalltalk index (i.e. 1-based).
 The stored value must be in the range -32768 .. +32676.
 The value is stored in the machines natural byteorder.
 This may be worth a primitive.
 This is the ST80 equivalent of #signedWordAt:put:"
 "Created: / 5.3.1998 / 11:02:05 / stefan"
 !
 signedByteAt:index
 "return the byte at index as a signed 8 bit value.
+The index is a smalltalk index (i.e. 1-based).
 This may be worth a primitive."
 ^ (self at:index) signExtendedByteValue
 "
 "Modified: 1.7.1996 / 21:13:53 / cg"
 !
 signedByteAt:index put:aSignedByteValue
 "return the byte at index as a signed 8 bit value.
+The index is a smalltalk index (i.e. 1-based).
 Return the signedByteValue argument.
 This may be worth a primitive."
 |b "{ Class: SmallInteger }"|
 "Modified: 1.7.1996 / 21:12:37 / cg"
 !
 signedDoubleWordAt:index
 "return the 4-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.
 This may be worth a primitive."
 |w|
 "Modified: 1.7.1996 / 21:11:28 / cg"
 !
 signedDoubleWordAt:index MSB:msb
 "return the 4-bytes starting at index as a signed Integer.
+The index is a smalltalk index (i.e. 1-based).
 Depending on msb, the value is retrieved MSB-first or LSB-first.
 This may be worth a primitive."
 |w|
 "Modified: 1.7.1996 / 21:11:33 / cg"
 !
 signedDoubleWordAt:index put:value
 "set the 4-bytes starting at index from the signed Integer value.
+The index is a smalltalk index (i.e. 1-based).
 The value is stored in the machines natural byte order.
 This may be worth a primitive."
 |v|
 "Modified: 1.7.1996 / 21:11:39 / cg"
 !
 signedDoubleWordAt:index put:value MSB:msb
 "set the 4-bytes starting at index from the signed Integer value.
+The index is a smalltalk index (i.e. 1-based).
 Depending on msb, the value is stored MSB-first or LSB-first.
 This may be worth a primitive."
 |v|
 "Modified: 1.7.1996 / 21:11:46 / cg"
 !
 signedWordAt:index
 "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.
 This may be worth a primitive."
 ^ (self wordAt:index) signExtendedShortValue
 "Modified: 1.7.1996 / 21:14:38 / cg"
 !
 signedWordAt:index 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 MSB-first if the msb-arg is true,
 LSB-first otherwise.
 This may be worth a primitive."
 ^ (self wordAt:index MSB:msb) signExtendedShortValue
 "Modified: 1.7.1996 / 21:15:57 / cg"
 !
 signedWordAt:index put:value
 "set the 2-bytes starting at index from the signed Integer value.
+The index is a smalltalk index (i.e. 1-based).
 The stored value must be in the range -32768 .. +32676.
 The value is stored in the machines natural byteorder.
 This may be worth a primitive.
 This is the ST80 equivalent of #signedWordAt:put:"
 "Modified: / 5.3.1998 / 11:01:30 / stefan"
 !
 signedWordAt:index put:value MSB:msb
 "set the 2-bytes starting at index from the signed Integer value.
+The index 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.
 This may be worth a primitive."
 "Modified: 1.7.1996 / 21:12:13 / cg"
 !
 stringAt:index
-"return a string starting at index up to the 0-byte"
+"return a string starting at index up to the 0-byte.
+The index is a smalltalk index (i.e. 1-based)."
 |stream i "{ Class: SmallInteger }" c|
 stream := WriteStream on:''.
 i := index.
 "Created: / 21.1.1998 / 17:44:50 / cg"
 !
 stringAt:index put:aString
 "copy aString to the externalBytes, starting at index up to
-(and including) the 0-byte"
+(and including) the 0-byte.
+The index is a smalltalk index (i.e. 1-based)."
 |i "{ Class: SmallInteger }"|
 i := index.
 aString do:[:aChar |
 "Created: / 21.1.1998 / 17:45:02 / cg"
 !
 stringAt:index size:maxSize
-"return a string starting at index up to maxSize, or a 0-byte"
+"return a string starting at index up to maxSize, or a 0-byte.
+The index is a smalltalk index (i.e. 1-based)."
 |stream c i "{ Class: SmallInteger }"|
 stream := WriteStream on:(String new:maxSize).
 i := index.
 "Modified: / 21.1.1998 / 17:45:23 / cg"
 !
 unsignedLongAt:index
 "return the 4-bytes starting at index as an (unsigned) Integer.
+The index is a smalltalk index (i.e. 1-based).
 The value is retrieved in the machines natural byte order.
 Subclasses may redefine this for better performance."
 ^ self unsignedLongAt:index bigEndian:IsBigEndian
 "Modified: / 5.3.1998 / 14:58:48 / stefan"
 !
 unsignedLongAt:index bigEndian:msb
 "return the 4-bytes starting at index as an (unsigned) Integer.
+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.
 Subclasses may redefine this for better performance."
 |val
 "Created: / 5.3.1998 / 11:46:05 / stefan"
 !
 unsignedLongAt:index put:value
 "set the 4-bytes starting at index from the (unsigned) Integer value.
+The index is a smalltalk index (i.e. 1-based).
 The value should be in the range 0 to 16rFFFFFFFF
 (for negative values, the stored value is not defined).
 The value is stored in the machines natural byte order.
 Subclasses may redefine this for better performance."
 "Modified: / 5.3.1998 / 14:58:59 / stefan"
 !
 unsignedLongAt:index put:aNumber bigEndian:msb
 "set the 4-bytes starting at index from the (unsigned) Integer value.
+The index is a smalltalk index (i.e. 1-based).
 The value must be in the range 0 to 16rFFFFFFFF.
 The value is stored MSB-first if msb is true; LSB-first otherwise.
 Subclasses may redefine this for better performance."
 |i "{ Class: SmallInteger }" |
 "Modified: / 5.3.1998 / 11:47:30 / stefan"
 !
 unsignedLongLongAt:index bigEndian:msb
 "return the 8-bytes starting at index as an (unsigned) Integer.
+The index is a smalltalk index (i.e. 1-based).
 Depending on msb, the value is retrieved MSB or LSB-first."
 |l
 bIdx  "{ Class: SmallInteger }"
 delta "{ Class: SmallInteger }"|
 "Modified: / 5.3.1998 / 14:04:44 / stefan"
 !
 unsignedLongLongAt:index put:anInteger
 "set the 8-bytes starting at index from the (unsigned) Integer value.
+The index is a smalltalk index (i.e. 1-based).
 The value must be in the range 0 to 16rFFFFFFFFFFFFFFFF.
 The value is stored in natural byte order."
 ^ self unsignedLongLongAt:index put:anInteger bigEndian:IsBigEndian
 "Modified: / 5.3.1998 / 15:02:32 / stefan"
 !
 unsignedLongLongAt:index put:anInteger bigEndian:msb
 "set the 8-bytes starting at index from the (unsigned) Integer value.
+The index is a smalltalk index (i.e. 1-based).
 The value must be in the range 0 to 16rFFFFFFFFFFFFFFFF.
 Depending on msb, the value is stored MSB-first or LSB-first."
 |bIdx  "{ Class: SmallInteger }"
 delta "{ Class: SmallInteger }"|
 "Created: / 5.3.1998 / 14:06:02 / stefan"
 !
 unsignedShortAt:index
 "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 in the machines natural byte order
 Subclasses may redefine this for better performance.
 This is the ST80 equivalent of #wordAt:"
 "Modified: / 5.3.1998 / 14:59:25 / stefan"
 !
 unsignedShortAt:index bigEndian: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-first (high 8 bits at lower index) if msb is true;
 LSB-first (i.e. low 8-bits at lower byte index) if its false)"
 |b1 "{ Class: SmallInteger }"
 b2 "{ Class: SmallInteger }"|
 "Created: / 5.3.1998 / 11:49:29 / stefan"
 !
 unsignedShortAt:index put:value
 "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 in the machines natural byteorder."
 ^ self unsignedShortAt:index put:value bigEndian:IsBigEndian
 "Modified: / 5.3.1998 / 14:59:38 / stefan"
 !
 unsignedShortAt:index put:value bigEndian: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
 "Modified: / 5.3.1998 / 11:52:28 / stefan"
 !
 wordAt:index
 "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 in the machines natural byte order
 Subclasses may redefine this for better performance."
 ^ self wordAt:index MSB:IsBigEndian
 "Modified: / 5.3.1998 / 14:59:51 / stefan"
 !
 wordAt:index 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.
 Question: should it be retrieve signed values ? (see ByteArray>>signedWordAt:)"
 |b1 "{ Class: SmallInteger }"
 "Modified: / 21.1.1998 / 17:46:07 / cg"
 !
 wordAt:index put:value
 "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 in the machines natural byteorder.
 Question: should it accept signed values ? (see ByteArray>>signedWordAt:put:)"
 ^ self wordAt:index put:value MSB:IsBigEndian
 "Modified: / 5.3.1998 / 15:00:03 / stefan"
 !
 wordAt:index put:value 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.
 Question: should it accept signed values ? (see ByteArray>>signedWordAt:put:)"
 "Created: / 21.1.1998 / 17:48:38 / cg"
 !
 zeroByteStringAt:index maximumSize:count
 "extract a zeroByte-delimited string, given initial index and
-maximum number of characters (bytes)"
+maximum number of characters (bytes).
+The index is a smalltalk index (i.e. 1-based)."
 |bytes idx|
 bytes := self copyFrom:index to:(index + count - 1).
 idx := bytes indexOf:0.
 ! !
 !UninterpretedBytes methodsFor:'misc'!
 swapLongAt:byteIndex
-"swap the byteOrder of a long."
+"swap the byteOrder of a long.
+The index is a smalltalk index (i.e. 1-based)."
 |t|
 t := self byteAt:byteIndex.
 self byteAt:byteIndex put:(self byteAt:(byteIndex + 3)).
 ! !
 !UninterpretedBytes class methodsFor:'documentation'!
 version
-^ '$Header: /cvs/stx/stx/libbasic/Attic/UIBytes.st,v 1.23 1998-04-25 21:33:11 cg Exp $'
+^ '$Header: /cvs/stx/stx/libbasic/Attic/UIBytes.st,v 1.24 1998-05-08 13:26:50 cg Exp $'
 ! !
 UninterpretedBytes initialize!

changeset 3433	a94725308432
parent 3410	93393f1c1022
child 3434	d04ff3256ebb