lib-src/contain/bytearry.cc

   1 //////////////////////////////////////////////////////////////////////////////
   2 // NOTICE:
   3 //
   4 // ADLib, Prop and their related set of tools and documentation are in the
   5 // public domain.   The author(s) of this software reserve no copyrights on
   6 // the source code and any code generated using the tools.  You are encouraged
   7 // to use ADLib and Prop to develop software, in both academic and commercial
   8 // settings, and are free to incorporate any part of ADLib and Prop into
   9 // your programs.
  10 //
  11 // Although you are under no obligation to do so, we strongly recommend that
  12 // you give away all software developed using our tools.
  13 //
  14 // We also ask that credit be given to us when ADLib and/or Prop are used in
  15 // your programs, and that this notice be preserved intact in all the source
  16 // code.
  17 //
  18 // This software is still under development and we welcome any suggestions
  19 // and help from the users.
  20 //
  21 // Allen Leung
  22 // 1994
  23 //////////////////////////////////////////////////////////////////////////////
  24
  25 #include <string.h>
  26 #include <AD/contain/bytearry.h>
  27
  28 ByteArray::ByteArray(int length)
  29 {  size  = length;
  30    units = (length + sizeof(LongWord) - 1) / sizeof(LongWord);
  31    array = new LongWord [units];
  32 }
  33
  34 ByteArray::ByteArray(const Byte A[], int len)
  35 {  size  = len;
  36    units = (len + sizeof(LongWord) - 1) / sizeof(LongWord);
  37    array = new LongWord [units];
  38    memcpy(array,A,len);
  39 }
  40
  41 ByteArray::ByteArray(const char string[])
  42 {  size  = strlen(string) + 1;
  43    units = (size + sizeof(LongWord) - 1) / sizeof(LongWord);
  44    array = new LongWord [units];
  45    memcpy(array,string,size);
  46 }
  47
  48 ByteArray::ByteArray(const ByteArray& A) : array(0)
  49 {  *this = A; }
  50
  51 void ByteArray :: operator = (const ByteArray& A)
  52 {  if (this != &A) {
  53       delete [] array;
  54       size  = A.size;
  55       units = A.units;
  56       array = new LongWord [units];
  57       memcpy(array,A.array,units);
  58    }
  59 }
  60
  61    // Concatenation between two byte arrays
  62
  63 ByteArray ByteArray :: operator || (const ByteArray&) const
  64 {
  65    return *this;
  66 }
  67
  68    // Destructive arithmetic and logical operations
  69
  70 void ByteArray :: operator <<= (int shift)
  71 {
  72    if (shift == 0) return;
  73    else if (shift < 0) *this >>= -shift;
  74 }
  75
  76 void ByteArray :: operator >>= (int shift)
  77 {
  78    if (shift == 0) return;
  79    else if (shift < 0) *this <<= -shift;
  80 }
  81
  82 void ByteArray :: operator |= (const ByteArray&)
  83 {
  84 }
  85
  86 void ByteArray :: operator &= (const ByteArray&)
  87 {
  88 }
  89
  90 void ByteArray :: operator ^= (const ByteArray&)
  91 {  }
  92
  93 void ByteArray :: operator += (const ByteArray&)
  94 {  }
  95
  96 void ByteArray :: operator -= (const ByteArray&)
  97 {   }
  98
  99 void ByteArray :: onesComplement()
 100 {  register int i;
 101    for (i = units - 1; i >= 0; i--) array[i] ^= 0xffffffff;
 102 }
 103
 104 void ByteArray :: twosComplement()
 105 {   }
 106
 107 Bool ByteArray :: operator ! ()
 108 {  return false; }  // is it all zeros??
 109
 110    // Arithmetic and logical operations
 111
 112
 113 Bool operator == (const ByteArray&, const ByteArray&)
 114 {   return false;   }
 115
 116 Bool operator >= (const ByteArray&, const ByteArray&)
 117 {   return false;   }
 118
 119 Bool operator <= (const ByteArray&, const ByteArray&)
 120 {   return false;   }