552 !

   553 

   554 floatAt:index

   555     "return the 4-bytes starting at index as a ShortFloat.

   556      The index is a smalltalk index (i.e. 1-based).

   557      Notice, that (currently) ST/X Floats are what Doubles are in ST-80;

   558      therefore this method reads a 4-byte float from the byteArray and returns

   559      a float object which keeps an 8-byte double internally.

   560      Notice also, that the bytes are expected to be in this machines

   561      float representation and order - if the bytearray originated from another

   562      machine, some conversion is usually needed."

   563 

   564     |newFloat|

   565 

   566 %{

   567     /*

   568      * handle the most common cases fast ...

   569      */

   570     if (__isSmallInteger(index)) {

   571         char *cp;

   572         int sz;

   573 

   574         __fetchBytePointerAndSize__(self, &cp, &sz);

   575         if (cp) {

   576             unsigned INT idx = ((unsigned INT)__intVal(index)) - 1;

   577 

   578             if ((idx+(sizeof(float)-1)) < sz) {

   579                 cp += idx;

   580                 /*

   581                  * aligned

   582                  */

   583                 if (((INT)cp & (sizeof(float)-1)) == 0) {

   584                     float fVal = ((float *)cp)[0];

   585 		    OBJ f;

   586 

   587 		    __qMKSFLOAT(f, fVal);

   588                     RETURN (f);

   589                 }

   590             }

   591         }

   592     }

   593 %}.

   594 

   595     newFloat := ShortFloat basicNew.

   596     1 to:4 do:[:destIndex|

   597         newFloat basicAt:destIndex put:(self at:index - 1 + destIndex)

   598     ].

   599     ^ newFloat.

   600 !

   601 

   602 floatAt:index MSB:msb

   603     "return the 4-bytes starting at index as a ShortFloat.

   604      The index is a smalltalk index (i.e. 1-based).

   605      Notice, that (currently) ST/X Floats are what Doubles are in ST-80;

   606      therefore this method reads a 4-byte float from the byteArray and returns

   607      a float object which keeps an 8-byte double internally.

   608      Notice also, that the bytes are expected to be in this machines

   609      float representation and order - if the bytearray originated from another

   610      machine, some conversion is usually needed."

   611 

   612     |newFloat|

   613 

   614     msb == UninterpretedBytes isBigEndian ifTrue:[

   615         ^ self floatAt:index

   616     ].

   617 

   618     newFloat := ShortFloat basicNew.

   619     1 to:4 do:[:destIndex|

   620         newFloat basicAt:(5-destIndex) put:(self at:index - 1 + destIndex)

   621     ].

   622     ^ newFloat.

   623 

   624     "Modified: / 15.5.1998 / 17:20:19 / cg"

   625     "Created: / 15.5.1998 / 17:20:35 / cg"

   626 !

   627 

   628 floatAt:index put:aFloat

   629     "store the 4 bytes of value of the argument, aFloat into the receiver

   630      starting at index.

   631      The index is a smalltalk index (i.e. 1-based).

   632      Notice, that (currently) ST/X Floats are what Doubles are in ST-80.

   633      Notice also, that the bytes are expected to be in this machines

   634      float representation - if the bytearray originated from another

   635      machine, some conversion is usually needed."

   636 

   637     |sflt|

   638 

   639     sflt := aFloat asShortFloat.

   640 %{

   641     /*

   642      * handle the most common cases fast ...

   643      */

   644     if (__isSmallInteger(index) && __isShortFloat(sflt)) {

   645         char *cp;

   646         int sz;

   647 

   648         __fetchBytePointerAndSize__(self, &cp, &sz);

   649         if (cp) {

   650             unsigned INT idx = ((unsigned INT)__intVal(index)) - 1;

   651 

   652             if ((idx+(sizeof(float)-1)) < sz) {

   653                 cp += idx;

   654                 /*

   655                  * aligned

   656                  */

   657                 if (((INT)cp & (sizeof(float)-1)) == 0) {

   658                     ((float *)cp)[0] = __shortFloatVal(sflt);

   659 

   660                     RETURN (aFloat);

   661                 }

   662             }

   663         }

   664     }

   665 %}.

   666 

   667     1 to:4 do:[:srcIndex|

   668         self at:index - 1 + srcIndex put:(sflt basicAt:srcIndex)

   669     ].

   670     ^ aFloat

   671 !

   672 

   673 floatAt:index put:aFloat MSB:msb

   674     "store the 4 bytes of value of the argument, aFloat into the receiver

   675      starting at index.

   676      The index is a smalltalk index (i.e. 1-based).

   677      Notice, that (currently) ST/X Floats are what Doubles are in ST-80.

   678      Notice also, that the bytes are expected to be in this machines

   679      float representation - if the bytearray originated from another

   680      machine, some conversion is usually needed."

   681 

   682     |sflt|

   683 

   684     msb == UninterpretedBytes isBigEndian ifTrue:[

   685         ^ self floatAt:index put:aFloat

   686     ].

   687 

   688     sflt := aFloat asShortFloat.

   689     1 to:4 do:[:srcIndex|

   690         self at:index - 1 + srcIndex put:(sflt basicAt:(5-srcIndex))

   691     ].

   692     ^ aFloat

   693 

   694     "Created: / 15.5.1998 / 17:20:41 / cg"

   695 !

   696 

   697 ieeeDoubleAt:index

   698     "retrieve the 8 bytes starting at index as a float.

   699      The index is a smalltalk index (i.e. 1-based).

   700      The 8 bytes are assumed to be in IEEE floating point single precision

   701      number format."

   702 

   703     "

   704      currently, we assume that the machines native number format is already

   705      IEEE format - we need some more code here whenever ST/X is ported

   706      to an IBM 370 or old VAX etc.

   707      To date, all supported systems use IEEE float numbers, so there should be

   708      no problem.

   709     "

   710     self isIEEEFormat ifFalse:[self error:'unsupported operation'].

   711 

   712     ^ self doubleAt:index

   713 

   714     "Created: / 5.3.1998 / 10:50:03 / stefan"

   715 !

   716 

   717 ieeeDoubleAt:index put:aFloat

   718     "store the value of the argument, aFloat into the receiver

   719      The index is a smalltalk index (i.e. 1-based).

   720      starting at index. Storage is in IEEE floating point double precision format.

   721      (i.e. 8 bytes are stored)."

   722 

   723     "

   724      currently, we assume that the machines native number format is already

   725      IEEE format - we need some more code here whenever ST/X is ported

   726      to an IBM 370 or old VAX etc.

   727      To date, all supported systems use IEEE float numbers, so there should be

   728      no problem.

   729     "

   730     self isIEEEFormat ifFalse:[self error:'unsupported operation'].

   731 

   732     ^ self doubleAt:index put:aFloat

   733 

   734     "Created: / 5.3.1998 / 10:50:26 / stefan"

   735 !

   736 

   737 ieeeFloatAt:index

   738     "retrieve the 4 bytes starting at index as a float.

   739      The index is a smalltalk index (i.e. 1-based).

   740      The 4 bytes are assumed to be in IEEE floating point single precision

   741      number format."

   742 

   743     "

   744      currently, we assume that the machines native number format is already

   745      IEEE format - we need some more code here whenever ST/X is ported

   746      to an IBM 370 or old VAX etc.

   747      To date, all supported systems use IEEE float numbers, so there should be

   748      no problem.

   749     "

   750     self isIEEEFormat ifFalse:[self error:'unsupported operation'].

   751 

   752     ^ self floatAt:index

   753 

   754     "Created: / 5.3.1998 / 10:50:45 / stefan"

   755 !

   756 

   757 ieeeFloatAt:index put:aFloat

   758     "store the value of the argument, aFloat into the receiver

   759      starting at index, which is a smalltalk index (i.e. 1-based). 

   760      Storage is in IEEE floating point single precision format.

   761      (i.e. 4 bytes are stored). Since ST/X floats are really doubles, the low-

   762      order 4 bytes of the precision is lost."

   763 

   764     "

   765      currently, we assume that the machines native number format is already

   766      IEEE format - we need some more code here whenever ST/X is ported

   767      to an IBM 370 or old VAX etc.

   768      To date, all supported systems use IEEE float numbers, so there should be

   769      no problem.

   770     "

   771     self isIEEEFormat ifFalse:[self error:'unsupported operation'].

   772 

   773     ^ self floatAt:index put:aFloat

   774 

   775     "Created: / 5.3.1998 / 10:51:11 / stefan"

   935 longLongAt:index

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

   937      The index is a smalltalk index (i.e. 1-based).

   938      The value is retrieved in the machines natural byte order.

   939      This may be worth a primitive."

   940 

   941     |w|

   942 

   943     w := self unsignedLongLongAt:index bigEndian:IsBigEndian.

   944     (w > (16r7FFFFFFFFFFFFFFF)) ifTrue:[

   945         ^ w - (16r10000000000000000)

   946     ].

   947     ^ w

   948 

   949     "

   950      |b|

   951      b := ByteArray new:4.

   952      b unsignedLongLongAt:1 put:16rFFFFFFFFFFFFFFFF.

   953      (b longLongAt:1)    

   954     "

   955 

   956     "Modified: / 1.7.1996 / 21:11:28 / cg"

   957     "Created: / 5.3.1998 / 14:40:05 / stefan"

   958     "Modified: / 5.3.1998 / 14:58:32 / stefan"

   959 !

   960 

   961 longLongAt:index bigEndian:msb

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

   963      The index is a smalltalk index (i.e. 1-based).

   964      The value is retrieved in the given byte order.

   965      This may be worth a primitive."

   966 

   967     |w|

   968 

   969     w := self unsignedLongLongAt:index bigEndian:msb.

   970     (w > (16r7FFFFFFFFFFFFFFF)) ifTrue:[

   971         ^ w - (16r10000000000000000)

   972     ].

   973     ^ w

   974 

   975     "

   976      |b|

   977      b := ByteArray new:4.

   978      b unsignedLongLongAt:1 put:16rFFFFFFFFFFFFFFFF.

   979      (b longLongAt:1 msb:true)    

   980     "

   981 

   982     "Modified: / 5.3.1998 / 12:06:28 / stefan"

   983     "Created: / 5.3.1998 / 14:40:54 / stefan"

   984     "Modified: / 9.5.1998 / 01:10:59 / cg"

   985 !

   986 

   987 longLongAt:byteIndex put:anInteger

   988     "store a signed longLong (64bit) integer.

   989      The index is a smalltalk index (i.e. 1-based).

   990      Same as #signedQuadWordAt:put: - for ST80 compatibility."

   991 

   992     ^ self signedQuadWordAt:byteIndex put:anInteger

   993 

   994     "Modified: / 3.4.1998 / 13:33:14 / cg"

   995     "Created: / 3.4.1998 / 13:34:22 / cg"

   996 !

   997 

   998 longLongAt:byteIndex put:anInteger bigEndian:msb

   999     "store a signed longLong (64bit) integer.

  1000      The index is a smalltalk index (i.e. 1-based).

  1001      Same as #signedQuadWordAt:put: - for ST80 compatibility."

  1002 

  1003     |v|

  1004 

  1005     v := anInteger.

  1006     anInteger < 0 ifTrue:[

  1007         v := v + 16r10000000000000000

  1008     ].

  1009     ^ self unsignedLongLongAt:byteIndex put:v bigEndian:msb

  1010 

  1011     "Created: / 9.5.1998 / 01:10:24 / cg"

  1012     "Modified: / 9.5.1998 / 01:13:34 / cg"

  1013 !

  1014 

  1015 quadWordAt:index MSB:msb

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

  1017      The index is a smalltalk index (i.e. 1-based).

  1018      Depending on msb, the value is retrieved MSB or LSB-first."

  1019 

  1020     |l 

  1021      bIdx  "{ Class: SmallInteger }"

  1022      delta "{ Class: SmallInteger }"|

  1023 

  1024     l := LargeInteger basicNew numberOfDigits:8.

  1025     msb ifTrue:[

  1026 	bIdx := index + 7.

  1027 	delta := -1

  1028     ] ifFalse:[

  1029 	bIdx := index.

  1030 	delta := 1

  1031     ].

  1032     1 to:8 do:[:i |

  1033 	l digitAt:i put:(self basicAt:bIdx).

  1034 	bIdx := bIdx + delta

  1035     ].

  1036     ^ l compressed

  1037 

  1038     "

  1039      |b|

  1040 

  1041      b := ByteArray withAll:#(1 2 3 4 5 6 7 8).

  1042      (b quadWordAt:1 MSB:false) printStringRadix:16  

  1043     "

  1044 

  1045     "Modified: 5.11.1996 / 14:06:21 / cg"

  1046 !

  1047 

  1048 quadWordAt:index put:anInteger MSB:msb

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

  1050      The index is a smalltalk index (i.e. 1-based).

  1051      The value must be in the range 0 to 16rFFFFFFFFFFFFFFFF.

  1052      Depending on msb, the value is stored MSB-first or LSB-first."

  1053 

  1054     |bIdx  "{ Class: SmallInteger }"

  1055      delta "{ Class: SmallInteger }"|

  1056 

  1057     ((anInteger < 0) or:[anInteger > 16rFFFFFFFFFFFFFFFF]) ifTrue:[

  1058 	^ self elementBoundsError

  1059     ].

  1060 

  1061     msb ifTrue:[

  1062 	bIdx := index + 7.

  1063 	delta := -1

  1064     ] ifFalse:[

  1065 	bIdx := index.

  1066 	delta := 1

  1067     ].

  1068     1 to:8 do:[:i |

  1069 	self basicAt:bIdx put:(anInteger digitAt:i).

  1070 	bIdx := bIdx + delta.

  1071     ].

  1072     ^ anInteger

  1073 

  1074     "

  1075      |b|

  1076      b := ByteArray new:8.

  1077      b quadWordAtIndex:1 put:16r0807060504030201 MSB:false.

  1078      b inspect

  1079     "

  1080 !

  1081 

  1082 shortAt:index

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

  1084      The index is a smalltalk index (i.e. 1-based).

  1085      The value is retrieved in the machines natural byte order.

  1086      This may be worth a primitive.

  1087      This is the ST80 equivalent of #signedWordAt:"

  1088 

  1089     ^ (self unsignedShortAt:index) signExtendedShortValue

  1090 

  1091     "

  1092      |b|

  1093      b := ByteArray new:2.

  1094      b unsignedShortAt:1 put:16rFFFF.

  1095      b shortAt:1  

  1096     "

  1097 

  1098     "Modified: / 1.7.1996 / 21:14:38 / cg"

  1099     "Created: / 5.3.1998 / 10:59:57 / stefan"

  1100     "Modified: / 5.3.1998 / 23:39:38 / stefan"

  1101 !

  1102 

  1103 shortAt:index bigEndian:msb

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

  1105      The index is a smalltalk index (i.e. 1-based).

  1106      The value is retrieved MSB-first, if the msb-arg is true;

  1107      LSB-first otherwise.

  1108      This is the ST80 equivalent of #signedWordAt:"

  1109 

  1110     ^ (self unsignedShortAt:index bigEndian:msb) signExtendedShortValue

  1111 

  1112     "

  1113      |b|

  1114      b := ByteArray new:2.

  1115      b unsignedShortAt:1 put:16rFFFF.

  1116      b shortAt:1  

  1117     "

  1118 

  1119     "Modified: / 1.7.1996 / 21:14:38 / cg"

  1120     "Created: / 5.3.1998 / 23:41:21 / stefan"

  1121 !

  1122 

  1123 shortAt:index put:value

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

  1125      The index is a smalltalk index (i.e. 1-based).

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

  1127      The value is stored in the machines natural byteorder.

  1128      This may be worth a primitive.

  1129      This is the ST80 equivalent of #signedWordAt:put:"

  1130 

  1131 

  1132     |v|

  1133 

  1134     value >= 0 ifTrue:[

  1135         v := value

  1136     ] ifFalse:[

  1137         v := 16r10000 + value

  1138     ].

  1139     self unsignedShortAt:index put:v.

  1140     ^ value

  1141 

  1142     "

  1143      |b|

  1144      b := ByteArray new:6.

  1145      b shortAt:1 put:-1.

  1146      b shortAt:3 put:-2.

  1147      b shortAt:5 put:0.

  1148      b inspect

  1149     "

  1150 

  1151     "Modified: / 1.7.1996 / 21:12:07 / cg"

  1152     "Created: / 5.3.1998 / 11:02:05 / stefan"

  1153 !

  1154 

  1155 signedByteAt:index

  1156     "return the byte at index as a signed 8 bit value.

  1157      The index is a smalltalk index (i.e. 1-based).

  1158      This may be worth a primitive."

  1159 

  1160     ^ (self at:index) signExtendedByteValue

  1161 

  1162     "

  1163      |b|

  1164      b := ByteArray new:2.

  1165      b at:1 put:16rFF.

  1166      b at:2 put:16r7F.

  1167      b signedByteAt:1  

  1168     "

  1169 

  1170     "Modified: 1.7.1996 / 21:13:53 / cg"

  1171 !

  1172 

  1173 signedByteAt:index put:aSignedByteValue

  1174     "return the byte at index as a signed 8 bit value.

  1175      The index is a smalltalk index (i.e. 1-based).

  1176      Return the signedByteValue argument.

  1177      This may be worth a primitive."

  1178 

  1179     |b "{ Class: SmallInteger }"|

  1180 

  1181     aSignedByteValue >= 0 ifTrue:[

  1182 	b := aSignedByteValue

  1183     ] ifFalse:[

  1184 	b := 16r100 + aSignedByteValue

  1185     ].

  1186     self at:index put:b.

  1187     ^ aSignedByteValue

  1188 

  1189     "

  1190      |b|

  1191      b := ByteArray new:2.

  1192      b signedByteAt:1 put:-1.

  1193      b at:1   

  1194     "

  1195 

  1196     "Modified: 1.7.1996 / 21:12:37 / cg"

  1197 !

  1198 

  1297 !

  1298 

  1299 signedWordAt:index

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

  1301      The index is a smalltalk index (i.e. 1-based).

  1302      The value is retrieved in the machines natural byte order.

  1303      This may be worth a primitive."

  1304 

  1305     ^ (self wordAt:index) signExtendedShortValue

  1306 

  1307     "

  1308      |b|

  1309      b := ByteArray new:2.

  1310      b wordAt:1 put:16rFFFF.

  1311      b signedWordAt:1  

  1312     "

  1313 

  1314     "Modified: 1.7.1996 / 21:14:38 / cg"

  1315 !

  1316 

  1317 signedWordAt:index MSB:msb

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

  1319      The index is a smalltalk index (i.e. 1-based).

  1320      The value is retrieved MSB-first if the msb-arg is true,

  1321      LSB-first otherwise.

  1322      This may be worth a primitive."

  1323 

  1324     ^ (self wordAt:index MSB:msb) signExtendedShortValue

  1325 

  1326     "

  1327      |b|

  1328      b := ByteArray new:2.

  1329      b wordAt:1 put:16r0080.

  1330      b signedWordAt:1 MSB:true.  

  1331      b signedWordAt:1 MSB:false.  

  1332     "

  1333 

  1334     "Modified: 1.7.1996 / 21:15:57 / cg"

  1335 !

  1336 

  1337 signedWordAt:index put:value

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

  1339      The index is a smalltalk index (i.e. 1-based).

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

  1341      The value is stored in the machines natural byteorder.

  1342      This may be worth a primitive.

  1343      This is the ST80 equivalent of #signedWordAt:put:"

  1344 

  1345 

  1346     |v|

  1347 

  1348     value >= 0 ifTrue:[

  1349         v := value

  1350     ] ifFalse:[

  1351         v := 16r10000 + value

  1352     ].

  1353     self unsignedShortAt:index put:v.

  1354     ^ value

  1355 

  1356     "

  1357      |b|

  1358      b := ByteArray new:6.

  1359      b shortAt:1 put:-1.

  1360      b shortAt:3 put:-2.

  1361      b shortAt:5 put:0.

  1362      b inspect

  1363     "

  1364 

  1365     "Modified: / 1.7.1996 / 21:12:07 / cg"

  1366     "Modified: / 5.3.1998 / 11:01:30 / stefan"

  1367 !

  1368 

  1369 signedWordAt:index put:value MSB:msb

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

  1371      The index is a smalltalk index (i.e. 1-based).

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

  1373      The value is stored MSB-first, if the msb-arg is true;

  1374      LSB-first otherwise.

  1375      This may be worth a primitive."

  1376 

  1377     |v|

  1378 

  1379     value >= 0 ifTrue:[

  1380 	v := value

  1381     ] ifFalse:[

  1382 	v := 16r10000 + value

  1383     ].