1 "

     3 "

     2  COPYRIGHT (c) 1989 by Claus Gittinger

     4  COPYRIGHT (c) 1989 by Claus Gittinger

     3 	      All Rights Reserved

     5 	      All Rights Reserved

     4 

     6 

     5  This software is furnished under a license and may be used

     7  This software is furnished under a license and may be used

   511     ^ super basicAt:index put:value

   513     ^ super basicAt:index put:value

   512 ! !

   514 ! !

   513 

   515 

   514 !ByteArray methodsFor:'accessing-longs'!

   516 !ByteArray methodsFor:'accessing-longs'!

   515 

   517 

   517     "set the 4-bytes starting at index from the (unsigned) Integer value.

   519     "set the 4-bytes starting at index from the (unsigned) Integer value.

   518      The value should be in the range 0 to 16rFFFFFFFF

   520      The value should be in the range 0 to 16rFFFFFFFF

   519      (for negative values, the stored value is not defined).

   521      (for negative values, the stored value is not defined).

   521      Q: should it store signed values ? (see ByteArray signedDoubleWordAt:put:)"

   523      Q: should it store signed values ? (see ByteArray signedDoubleWordAt:put:)"

   522 

   524 

   523     |t|

   525     |t|

   524 

   526 

   525 %{  /* NOCONTEXT */

   527 %{  /* NOCONTEXT */

   526 

   528 

   527     REGISTER int indx;

   529     REGISTER int indx;

   528     int nIndex;

   530     int nIndex;

   529     union {

   531     union {

   532     } val;

   534     } val;

   533     OBJ cls;

   535     OBJ cls;

   534     unsigned char *byteP;

   536     unsigned char *byteP;

   535 

   537 

   536     if (__isSmallInteger(index)) {

   538     if (__isSmallInteger(index)) {

   551 #if defined(__i386__) || defined(UNALIGNED_FETCH_OK)

   553 #if defined(__i386__) || defined(UNALIGNED_FETCH_OK)

   553 #else

   555 #else

   562 #endif

   564 #endif

   566     }

   568     }

   567   error: ;

   569   error: ;

   568 %}.

   570 %}.

   570 

   572 

   571     "

   573     "

   572      |b|

   574      |b|

   573      b := ByteArray new:4.

   575      b := ByteArray new:4.

   575      b inspect

   577      b inspect

   576     "

   578     "

   577 !

   579 !

   578 

   580 

   580     "set the 4-bytes starting at index from the (unsigned) Integer value.

   582     "set the 4-bytes starting at index from the (unsigned) Integer value.

   581      The value must be in the range 0 to 16rFFFFFFFF.

   583      The value must be in the range 0 to 16rFFFFFFFF.

   582      The value is stored MSB-first if msb is true; LSB-first otherwise.

   584      The value is stored MSB-first if msb is true; LSB-first otherwise.

   583      question: should it store signed values ? (see ByteArray signedDoubleWordAt:put:)"

   585      question: should it store signed values ? (see ByteArray signedDoubleWordAt:put:)"

   584 

   586 

   591     int val;

   593     int val;

   592     OBJ cls;

   594     OBJ cls;

   593     unsigned char *byteP;

   595     unsigned char *byteP;

   594 

   596 

   595     if (__isSmallInteger(index)) {

   597     if (__isSmallInteger(index)) {

   613 #if defined(__MSBFIRST__)

   615 #if defined(__MSBFIRST__)

   617 #endif

   619 #endif

   631 #if defined(__i386__) || (defined(__LSBFIRST__) && defined(UNALIGNED_FETCH_OK))

   633 #if defined(__i386__) || (defined(__LSBFIRST__) && defined(UNALIGNED_FETCH_OK))

   633 #else

   635 #else

   634 # if defined(__LSBFIRST__)

   636 # if defined(__LSBFIRST__)

   638 # endif

   640 # endif

   648 #endif

   650 #endif

   653     }

   655     }

   654   error: ;

   656   error: ;

   655 %}.

   657 %}.

   657 

   659 

   658     "

   660     "

   659      |b|

   661      |b|

   660      b := ByteArray new:8.

   662      b := ByteArray new:8.

   663      b inspect

   665      b inspect

   664     "

   666     "

   665 ! !

   667 ! !

   666 

   668 

   667 !ByteArray methodsFor:'accessing-shorts'!

   669 !ByteArray methodsFor:'accessing-shorts'!

   668 

   670 

   670     "return the 2-bytes starting at index as an (unsigned) Integer.

   672     "return the 2-bytes starting at index as an (unsigned) Integer.

   672      Notice: 

   674      Notice: 

   673         the index is a byte index; thus, this allows for unaligned access to

   675         the index is a byte index; thus, this allows for unaligned access to

   674         words on any boundary.

   676         words on any boundary.

   675      Question: should it be retrieve signed values ? (see ByteArray>>signedWordAt:)"

   677      Question: should it be retrieve signed values ? (see ByteArray>>signedWordAt:)"

   676 

   678 

   693             if ((indx+1) <= nIndex) {

   695             if ((indx+1) <= nIndex) {

   694                 byteP = (unsigned char *)(__ByteArrayInstPtr(self)->ba_element) + indx - 1;

   696                 byteP = (unsigned char *)(__ByteArrayInstPtr(self)->ba_element) + indx - 1;

   695 #if defined(__i386__) || defined(UNALIGNED_FETCH_OK)

   697 #if defined(__i386__) || defined(UNALIGNED_FETCH_OK)

   696                 val.u_ushort = ((unsigned short *)byteP)[0];

   698                 val.u_ushort = ((unsigned short *)byteP)[0];

   697 #else

   699 #else

   710 #endif

   702 #endif

   711                 RETURN ( __mkSmallInteger((val.u_ushort)) );

   703                 RETURN ( __mkSmallInteger((val.u_ushort)) );

   712             }

   704             }

   713         }

   705         }

   714     }

   706     }

   715 %}.

   707 %}.

   720     "return the 2-bytes starting at index as an (unsigned) Integer.

   712     "return the 2-bytes starting at index as an (unsigned) Integer.

   721      The value is retrieved MSB (high 8 bits at lower index) if msb is true;

   713      The value is retrieved MSB (high 8 bits at lower index) if msb is true;

   722      LSB-first (i.e. low 8-bits at lower byte index) if its false.

   714      LSB-first (i.e. low 8-bits at lower byte index) if its false.

   723      Notice: 

   715      Notice: 

   724         the index is a byte index; thus, this allows for unaligned access to

   716         the index is a byte index; thus, this allows for unaligned access to

   786                 RETURN ( __mkSmallInteger(val) );

   778                 RETURN ( __mkSmallInteger(val) );

   787             }

   779             }

   788         }

   780         }

   789     }

   781     }

   790 %}.

   782 %}.

   795     "set the 2-bytes starting at index from the (unsigned) Integer value.

   787     "set the 2-bytes starting at index from the (unsigned) Integer value.

   796      The stored value must be in the range 0 .. 16rFFFF.

   788      The stored value must be in the range 0 .. 16rFFFF.

   798      i.e. this method should only be used to fill byteArrays which are

   790      i.e. this method should only be used to fill byteArrays which are

   799      used internally (not passed to other machines).

   791      used internally (not passed to other machines).

   800      Notice: 

   792      Notice: 

   801         the index is a byte index; thus, this allows for unaligned access to

   793         the index is a byte index; thus, this allows for unaligned access to

   802         words on any boundary.

   794         words on any boundary.

   843                 }

   835                 }

   844             }

   836             }

   845         }

   837         }

   846     }

   838     }

   847 %}.

   839 %}.

   849 

   841 

   850     "

   842     "

   851      |b|

   843      |b|

   852      b := ByteArray new:4.

   844      b := ByteArray new:4.

   855      b inspect

   847      b inspect

   856     "

   848     "

   857 !

   849 !

   858 

   850 

   860     "set the 2-bytes starting at index from the (unsigned) Integer value.

   852     "set the 2-bytes starting at index from the (unsigned) Integer value.

   861      The stored value must be in the range 0 .. 16rFFFF.

   853      The stored value must be in the range 0 .. 16rFFFF.

   862      The value is stored LSB-first (i.e. the low 8bits are stored at the

   854      The value is stored LSB-first (i.e. the low 8bits are stored at the

   863      lower index) if msb is false, MSB-first otherwise.

   855      lower index) if msb is false, MSB-first otherwise.

   864      Notice: 

   856      Notice: 

   931                 }

   923                 }

   932             }

   924             }

   933         }

   925         }

   934     }

   926     }

   935 %}.

   927 %}.

   937 

   929 

   938     "

   930     "

   939      |b|

   931      |b|

   940      b := ByteArray new:8.

   932      b := ByteArray new:8.

   945      b inspect

   937      b inspect

   946     "

   938     "

   947 ! !

   939 ! !

   948 

   940 

   949 

   941 

  2989     "

  2981     "

  2990      #[1 2 3 1 2 3 1 2 3 1 2 3 4 5 6 4 5 6] usedValues

  2982      #[1 2 3 1 2 3 1 2 3 1 2 3 4 5 6 4 5 6] usedValues

  2991     "

  2983     "

  2992 ! !

  2984 ! !

  2993 

  2985 

  2995 !ByteArray methodsFor:'searching'!

  2986 !ByteArray methodsFor:'searching'!

  2996 

  2987 

  2997 indexOf:aByte startingAt:start

  2988 indexOf:aByte startingAt:start

  2998     "return the index of the first occurrence of the argument, aByte

  2989     "return the index of the first occurrence of the argument, aByte

  2999      in the receiver starting at start, anInteger; return 0 if not found.

  2990      in the receiver starting at start, anInteger; return 0 if not found.

  3055     "

  3046     "

  3056      #[1 2 3 4 5 6 7 8 9 0 1 2 3 4 5] indexOf:0 startingAt:1

  3047      #[1 2 3 4 5 6 7 8 9 0 1 2 3 4 5] indexOf:0 startingAt:1

  3057     "

  3048     "

  3058 ! !

  3049 ! !

  3059 

  3050 

  3061 !ByteArray methodsFor:'testing'!

  3051 !ByteArray methodsFor:'testing'!

  3062 

  3052 

  3063 isByteArray

  3053 isByteArray

  3064     "return true, if the receiver is some kind of bytearray;

  3054     "return true, if the receiver is some kind of bytearray;

  3065      true is returned here - the method is redefined from Object."

  3055      true is returned here - the method is redefined from Object."