/symbols/pdb/Microsoft.Cci.Pdb/BitAccess.cs

http://github.com/jbevain/cecil · C# · 253 lines · 194 code · 37 blank · 22 comment · 16 complexity · d2e7e71e82b0a0f6026b6db546a5eacf MD5 · raw file

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