mcs/tools/pdb2mdb/BitAccess.cs

   1 //-----------------------------------------------------------------------------
   2 //
   3 // Copyright (C) Microsoft Corporation.  All Rights Reserved.
   4 //
   5 //-----------------------------------------------------------------------------
   6 using System;
   7 using System.IO;
   8 using System.Text;
   9
  10 namespace Microsoft.Cci.Pdb {
  11   internal class BitAccess {
  12
  13     internal BitAccess(int capacity) {
  14       this.buffer = new byte[capacity];
  15       this.offset = 0;
  16     }
  17
  18     internal byte[] Buffer {
  19       get { return buffer; }
  20     }
  21     private byte[] buffer;
  22
  23     internal void FillBuffer(Stream stream, int capacity) {
  24       MinCapacity(capacity);
  25       stream.Read(buffer, 0, capacity);
  26       offset = 0;
  27     }
  28
  29     internal int Position {
  30       get { return offset; }
  31       set { offset = value; }
  32     }
  33     private int offset;
  34
  35     internal void WriteBuffer(Stream stream, int count) {
  36       stream.Write(buffer, 0, count);
  37     }
  38
  39     internal void MinCapacity(int capacity) {
  40       if (buffer.Length < capacity) {
  41         buffer = new byte[capacity];
  42       }
  43       offset = 0;
  44     }
  45
  46     internal void Align(int alignment) {
  47       while ((offset % alignment) != 0) {
  48         offset++;
  49       }
  50     }
  51
  52     internal void WriteInt32(int value) {
  53       buffer[offset + 0] = (byte)value;
  54       buffer[offset + 1] = (byte)(value >> 8);
  55       buffer[offset + 2] = (byte)(value >> 16);
  56       buffer[offset + 3] = (byte)(value >> 24);
  57       offset += 4;
  58     }
  59
  60     internal void WriteInt32(int[] values) {
  61       for (int i = 0; i < values.Length; i++) {
  62         WriteInt32(values[i]);
  63       }
  64     }
  65
  66     internal void WriteBytes(byte[] bytes) {
  67       for (int i = 0; i < bytes.Length; i++) {
  68         buffer[offset++] = bytes[i];
  69       }
  70     }
  71
  72     internal void ReadInt16(out short value) {
  73       value = (short)((buffer[offset + 0] & 0xFF) |
  74                             (buffer[offset + 1] << 8));
  75       offset += 2;
  76     }
  77
  78     internal void ReadInt32(out int value) {
  79       value = (int)((buffer[offset + 0] & 0xFF) |
  80                           (buffer[offset + 1] << 8) |
  81                           (buffer[offset + 2] << 16) |
  82                           (buffer[offset + 3] << 24));
  83       offset += 4;
  84     }
  85
  86     internal void ReadInt64(out long value) {
  87       value = (long)((buffer[offset + 0] & 0xFF) |
  88                            (buffer[offset + 1] << 8) |
  89                            (buffer[offset + 2] << 16) |
  90                            (buffer[offset + 3] << 24) |
  91                            (buffer[offset + 4] << 32) |
  92                            (buffer[offset + 5] << 40) |
  93                            (buffer[offset + 6] << 48) |
  94                            (buffer[offset + 7] << 56));
  95       offset += 8;
  96     }
  97
  98     internal void ReadUInt16(out ushort value) {
  99       value = (ushort)((buffer[offset + 0] & 0xFF) |
 100                              (buffer[offset + 1] << 8));
 101       offset += 2;
 102     }
 103
 104     internal void ReadUInt8(out byte value) {
 105       value = (byte)((buffer[offset + 0] & 0xFF));
 106       offset += 1;
 107     }
 108
 109     internal void ReadUInt32(out uint value) {
 110       value = (uint)((buffer[offset + 0] & 0xFF) |
 111                            (buffer[offset + 1] << 8) |
 112                            (buffer[offset + 2] << 16) |
 113                            (buffer[offset + 3] << 24));
 114       offset += 4;
 115     }
 116
 117     internal void ReadUInt64(out ulong value) {
 118       value = (ulong)((buffer[offset + 0] & 0xFF) |
 119                            (buffer[offset + 1] << 8) |
 120                            (buffer[offset + 2] << 16) |
 121                            (buffer[offset + 3] << 24) |
 122                            (buffer[offset + 4] << 32) |
 123                            (buffer[offset + 5] << 40) |
 124                            (buffer[offset + 6] << 48) |
 125                            (buffer[offset + 7] << 56));
 126       offset += 8;
 127     }
 128
 129     internal void ReadInt32(int[] values) {
 130       for (int i = 0; i < values.Length; i++) {
 131         ReadInt32(out values[i]);
 132       }
 133     }
 134
 135     internal void ReadUInt32(uint[] values) {
 136       for (int i = 0; i < values.Length; i++) {
 137         ReadUInt32(out values[i]);
 138       }
 139     }
 140
 141     internal void ReadBytes(byte[] bytes) {
 142       for (int i = 0; i < bytes.Length; i++) {
 143         bytes[i] = buffer[offset++];
 144       }
 145     }
 146
 147     internal float ReadFloat() {
 148       float result = BitConverter.ToSingle(buffer, offset);
 149       offset += 4;
 150       return result;
 151     }
 152
 153     internal double ReadDouble() {
 154       double result = BitConverter.ToDouble(buffer, offset);
 155       offset += 8;
 156       return result;
 157     }
 158
 159     internal decimal ReadDecimal() {
 160       int[] bits = new int[4];
 161       this.ReadInt32 (bits);
 162       try {
 163         bool sign = (bits[3] & 0x80000000) != 0;
 164         byte scale = (byte)((bits[3] >> 16) & 0x7F);
 165         return new decimal (bits[0], bits[1], bits[2], sign, scale);
 166       } catch (ArgumentException) {
 167         return new decimal ();
 168       }
 169     }
 170
 171     internal void ReadBString(out string value) {
 172       ushort len;
 173       this.ReadUInt16(out len);
 174       value = Encoding.UTF8.GetString(buffer, offset, len);
 175       offset += len;
 176     }
 177
 178     internal void ReadCString(out string value) {
 179       int len = 0;
 180       while (offset + len < buffer.Length && buffer[offset + len] != 0) {
 181         len++;
 182       }
 183       value = Encoding.UTF8.GetString(buffer, offset, len);
 184       offset += len + 1;
 185     }
 186
 187     internal void SkipCString(out string value) {
 188       int len = 0;
 189       while (offset + len < buffer.Length && buffer[offset + len] != 0) {
 190         len++;
 191       }
 192       offset += len + 1;
 193       value= null;
 194     }
 195
 196     internal void ReadGuid(out Guid guid) {
 197       uint a;
 198       ushort b;
 199       ushort c;
 200       byte d;
 201       byte e;
 202       byte f;
 203       byte g;
 204       byte h;
 205       byte i;
 206       byte j;
 207       byte k;
 208
 209       ReadUInt32(out a);
 210       ReadUInt16(out b);
 211       ReadUInt16(out c);
 212       ReadUInt8(out d);
 213       ReadUInt8(out e);
 214       ReadUInt8(out f);
 215       ReadUInt8(out g);
 216       ReadUInt8(out h);
 217       ReadUInt8(out i);
 218       ReadUInt8(out j);
 219       ReadUInt8(out k);
 220
 221       guid = new Guid(a, b, c, d, e, f, g, h, i, j, k);
 222     }
 223
 224     internal string ReadString() {
 225       int len = 0;
 226       while (offset + len < buffer.Length && buffer[offset + len] != 0) {
 227         len+=2;
 228       }
 229       string result = Encoding.Unicode.GetString(buffer, offset, len);
 230       offset += len + 2;
 231       return result;
 232     }
 233
 234   }
 235 }