C# BitAccess.ReadUInt8方法代码示例

    internal static PdbFunction[] LoadManagedFunctions(/*string module,*/
                                                       BitAccess bits, uint limit,
                                                       bool readStrings) {
      //string mod = StripNamespace(module);
      int begin = bits.Position;
      int count = 0;

      while (bits.Position < limit) {
        ushort siz;
        ushort rec;

        bits.ReadUInt16(out siz);
        int star = bits.Position;
        int stop = bits.Position + siz;
        bits.Position = star;
        bits.ReadUInt16(out rec);

        switch ((SYM)rec) {
          case SYM.S_GMANPROC:
          case SYM.S_LMANPROC:
            ManProcSym proc;
            bits.ReadUInt32(out proc.parent);
            bits.ReadUInt32(out proc.end);
            bits.Position = (int)proc.end;
            count++;
            break;

          case SYM.S_END:
            bits.Position = stop;
            break;

          default:
            //Console.WriteLine("{0,6}: {1:x2} {2}",
            //                  bits.Position, rec, (SYM)rec);
            bits.Position = stop;
            break;
        }
      }
      if (count == 0) {
        return null;
      }

      bits.Position = begin;
      PdbFunction[] funcs = new PdbFunction[count];
      int func = 0;

      while (bits.Position < limit) {
        ushort siz;
        ushort rec;

        bits.ReadUInt16(out siz);
        int star = bits.Position;
        int stop = bits.Position + siz;
        bits.ReadUInt16(out rec);

        switch ((SYM)rec) {

          case SYM.S_GMANPROC:
          case SYM.S_LMANPROC:
            ManProcSym proc;
            //int offset = bits.Position;

            bits.ReadUInt32(out proc.parent);
            bits.ReadUInt32(out proc.end);
            bits.ReadUInt32(out proc.next);
            bits.ReadUInt32(out proc.len);
            bits.ReadUInt32(out proc.dbgStart);
            bits.ReadUInt32(out proc.dbgEnd);
            bits.ReadUInt32(out proc.token);
            bits.ReadUInt32(out proc.off);
            bits.ReadUInt16(out proc.seg);
            bits.ReadUInt8(out proc.flags);
            bits.ReadUInt16(out proc.retReg);
            if (readStrings) {
              bits.ReadCString(out proc.name);
            } else {
              bits.SkipCString(out proc.name);
            }
            //Console.WriteLine("token={0:X8} [{1}::{2}]", proc.token, module, proc.name);

            bits.Position = stop;
            funcs[func++] = new PdbFunction(/*module,*/ proc, bits);
            break;

          default: {
              //throw new PdbDebugException("Unknown SYMREC {0}", (SYM)rec);
              bits.Position = stop;
              break;
            }
        }
      }
      return funcs;
    }

    internal PdbFunction(/*string module, */ManProcSym proc, BitAccess bits) {
      this.token = proc.token;
      //this.module = module;
      //this.name = proc.name;
      //this.flags = proc.flags;
      this.segment = proc.seg;
      this.address = proc.off;
      //this.length = proc.len;

      if (proc.seg != 1) {
        throw new PdbDebugException("Segment is {0}, not 1.", proc.seg);
      }
      if (proc.parent != 0 || proc.next != 0) {
        throw new PdbDebugException("Warning parent={0}, next={1}",
                                    proc.parent, proc.next);
      }
      //if (proc.dbgStart != 0 || proc.dbgEnd != 0) {
      //  throw new PdbDebugException("Warning DBG start={0}, end={1}",
      //                              proc.dbgStart, proc.dbgEnd);
      //}

      int constantCount;
      int scopeCount;
      int slotCount;
      int usedNamespacesCount;
      CountScopesAndSlots(bits, proc.end, out constantCount, out scopeCount, out slotCount, out usedNamespacesCount);
      int scope = constantCount > 0 || slotCount > 0 || usedNamespacesCount > 0 ? 1 : 0;
      int slot = 0;
      int constant = 0;
      int usedNs = 0;
      scopes = new PdbScope[scopeCount+scope];
      slots = new PdbSlot[slotCount];
      constants = new PdbConstant[constantCount];
      usedNamespaces = new string[usedNamespacesCount];

      if (scope > 0)
        scopes[0] = new PdbScope(this.address, proc.len, slots, constants, usedNamespaces);

      while (bits.Position < proc.end) {
        ushort siz;
        ushort rec;

        bits.ReadUInt16(out siz);
        int star = bits.Position;
        int stop = bits.Position + siz;
        bits.Position = star;
        bits.ReadUInt16(out rec);

        switch ((SYM)rec) {
          case SYM.S_OEM: {          // 0x0404
              OemSymbol oem;

              bits.ReadGuid(out oem.idOem);
              bits.ReadUInt32(out oem.typind);
              // internal byte[]   rgl;        // user data, force 4-byte alignment

              if (oem.idOem == msilMetaData) {
                string name = bits.ReadString();
                if (name == "MD2") {
                  byte version;
                  bits.ReadUInt8(out version);
                  if (version == 4) {
                    byte count;
                    bits.ReadUInt8(out count);
                    bits.Align(4);
                    while (count-- > 0)
                      this.ReadCustomMetadata(bits);
                  }
                } else if (name == "asyncMethodInfo") {
                  this.synchronizationInformation = new PdbSynchronizationInformation(bits);
                }
                bits.Position = stop;
                break;
              } else {
                throw new PdbDebugException("OEM section: guid={0} ti={1}",
                                            oem.idOem, oem.typind);
                // bits.Position = stop;
              }
            }

          case SYM.S_BLOCK32: {
              BlockSym32 block = new BlockSym32();

              bits.ReadUInt32(out block.parent);
              bits.ReadUInt32(out block.end);
              bits.ReadUInt32(out block.len);
              bits.ReadUInt32(out block.off);
              bits.ReadUInt16(out block.seg);
              bits.SkipCString(out block.name);
              bits.Position = stop;

              scopes[scope++] = new PdbScope(this.address, block, bits, out slotToken);
              bits.Position = (int)block.end;
              break;
            }

          case SYM.S_MANSLOT:
            slots[slot++] = new PdbSlot(bits);
            bits.Position = stop;
            break;
//.........这里部分代码省略.........

 private void ReadCustomMetadata(BitAccess bits) {
   int savedPosition = bits.Position;
   byte version;
   bits.ReadUInt8(out version);
   if (version != 4) {
     throw new PdbDebugException("Unknown custom metadata item version: {0}", version);
   }
   byte kind;
   bits.ReadUInt8(out kind);
   bits.Align(4);
   uint numberOfBytesInItem;
   bits.ReadUInt32(out numberOfBytesInItem);
   switch (kind) {
     case 0: this.ReadUsingInfo(bits); break;
     case 1: this.ReadForwardInfo(bits); break;
     case 2: break; // this.ReadForwardedToModuleInfo(bits); break;
     case 3: this.ReadIteratorLocals(bits); break;
     case 4: this.ReadForwardIterator(bits); break;
     // TODO: handle unknown custom metadata, 5 & 6 are new with roslyn, see https://roslyn.codeplex.com/workitem/54
   }
   bits.Position = savedPosition+(int)numberOfBytesInItem;
 }

 internal PdbConstant(BitAccess bits)
 {
   bits.ReadUInt32(out this.token);
   byte tag1;
   bits.ReadUInt8(out tag1);
   byte tag2;
   bits.ReadUInt8(out tag2);
   if (tag2 == 0)
   {
     this.value = tag1;
   }
   else if (tag2 == 0x80)
   {
     switch (tag1)
     {
       case 0x00: //sbyte
         sbyte sb;
         bits.ReadInt8(out sb);
         this.value = sb;
         break;
       case 0x01: //short
         short s;
         bits.ReadInt16(out s);
         this.value = s;
         break;
       case 0x02: //ushort
         ushort us;
         bits.ReadUInt16(out us);
         this.value = us;
         break;
       case 0x03: //int
         int i;
         bits.ReadInt32(out i);
         this.value = i;
         break;
       case 0x04: //uint
         uint ui;
         bits.ReadUInt32(out ui);
         this.value = ui;
         break;
       case 0x05: //float
         this.value = bits.ReadFloat();
         break;
       case 0x06: //double
         this.value = bits.ReadDouble();
         break;
       case 0x09: //long
         long sl;
         bits.ReadInt64(out sl);
         this.value = sl;
         break;
       case 0x0a: //ulong
         ulong ul;
         bits.ReadUInt64(out ul);
         this.value = ul;
         break;
       case 0x10: //string
         string str;
         bits.ReadBString(out str);
         this.value = str;
         break;
       case 0x19: //decimal
         this.value = bits.ReadDecimal();
         break;
       default:
         //TODO: error
         break;
     }
   }
   else
   {
     //TODO: error
   }
   bits.ReadCString(out name);
 }

    static void LoadManagedLines(PdbFunction[] funcs,
                                 IntHashTable names,
                                 BitAccess bits,
                                 MsfDirectory dir,
                                 Dictionary<string, int> nameIndex,
                                 PdbReader reader,
                                 uint limit) {
      Array.Sort(funcs, PdbFunction.byAddressAndToken);
      IntHashTable checks = new IntHashTable();

      // Read the files first
      int begin = bits.Position;
      while (bits.Position < limit) {
        int sig;
        int siz;
        bits.ReadInt32(out sig);
        bits.ReadInt32(out siz);
        int place = bits.Position;
        int endSym = bits.Position + siz;

        switch ((DEBUG_S_SUBSECTION)sig) {
          case DEBUG_S_SUBSECTION.FILECHKSMS:
            while (bits.Position < endSym) {
              CV_FileCheckSum chk;

              int ni = bits.Position - place;
              bits.ReadUInt32(out chk.name);
              bits.ReadUInt8(out chk.len);
              bits.ReadUInt8(out chk.type);

              string name = (string)names[(int)chk.name];
              int guidStream;
              Guid doctypeGuid = SymDocumentType.Text;
              Guid languageGuid = Guid.Empty;
              Guid vendorGuid = Guid.Empty;
              if (nameIndex.TryGetValue("/SRC/FILES/"+name.ToUpperInvariant(), out guidStream)) {
                var guidBits = new BitAccess(0x100);
                dir.streams[guidStream].Read(reader, guidBits);
                LoadGuidStream(guidBits, out doctypeGuid, out languageGuid, out vendorGuid);
              }

              PdbSource src = new PdbSource(/*(uint)ni,*/ name, doctypeGuid, languageGuid, vendorGuid);
              checks.Add(ni, src);
              bits.Position += chk.len;
              bits.Align(4);
            }
            bits.Position = endSym;
            break;

          default:
            bits.Position = endSym;
            break;
        }
      }

      // Read the lines next.
      bits.Position = begin;
      while (bits.Position < limit) {
        int sig;
        int siz;
        bits.ReadInt32(out sig);
        bits.ReadInt32(out siz);
        int endSym = bits.Position + siz;

        switch ((DEBUG_S_SUBSECTION)sig) {
          case DEBUG_S_SUBSECTION.LINES: {
              CV_LineSection sec;

              bits.ReadUInt32(out sec.off);
              bits.ReadUInt16(out sec.sec);
              bits.ReadUInt16(out sec.flags);
              bits.ReadUInt32(out sec.cod);
              int funcIndex = FindFunction(funcs, sec.sec, sec.off);
              if (funcIndex < 0) break;
              var func = funcs[funcIndex];
              if (func.lines == null) {
                while (funcIndex > 0) {
                  var f = funcs[funcIndex-1];
                  if (f.lines != null || f.segment != sec.sec || f.address != sec.off) break;
                  func = f;
                  funcIndex--;
                }
              } else {
                while (funcIndex < funcs.Length-1 && func.lines != null) {
                  var f = funcs[funcIndex+1];
                  if (f.segment != sec.sec || f.address != sec.off) break;
                  func = f;
                  funcIndex++;
                }
              }
              if (func.lines != null) break;

              // Count the line blocks.
              int begSym = bits.Position;
              int blocks = 0;
              while (bits.Position < endSym) {
                CV_SourceFile file;
                bits.ReadUInt32(out file.index);
                bits.ReadUInt32(out file.count);
                bits.ReadUInt32(out file.linsiz);   // Size of payload.
//.........这里部分代码省略.........

    private static IntHashTable ReadSourceFileInfo(BitAccess bits, uint limit, IntHashTable names, MsfDirectory dir,
      Dictionary<string, int> nameIndex, PdbReader reader) {
      IntHashTable checks = new IntHashTable();

      int begin = bits.Position;
      while (bits.Position < limit) {
        int sig;
        int siz;
        bits.ReadInt32(out sig);
        bits.ReadInt32(out siz);
        int place = bits.Position;
        int endSym = bits.Position + siz;

        switch ((DEBUG_S_SUBSECTION)sig) {
          case DEBUG_S_SUBSECTION.FILECHKSMS:
            while (bits.Position < endSym) {
              CV_FileCheckSum chk;

              int ni = bits.Position - place;
              bits.ReadUInt32(out chk.name);
              bits.ReadUInt8(out chk.len);
              bits.ReadUInt8(out chk.type);

              string name = (string)names[(int)chk.name];
              int guidStream;
              Guid doctypeGuid = SymDocumentType.Text;
              Guid languageGuid = Guid.Empty;
              Guid vendorGuid = Guid.Empty;
              if (nameIndex.TryGetValue("/SRC/FILES/"+name.ToUpperInvariant(), out guidStream)) {
                var guidBits = new BitAccess(0x100);
                dir.streams[guidStream].Read(reader, guidBits);
                LoadGuidStream(guidBits, out doctypeGuid, out languageGuid, out vendorGuid);
              }

              PdbSource src = new PdbSource(/*(uint)ni,*/ name, doctypeGuid, languageGuid, vendorGuid);
              checks.Add(ni, src);
              bits.Position += chk.len;
              bits.Align(4);
            }
            bits.Position = endSym;
            break;

          default:
            bits.Position = endSym;
            break;
        }
      }
      return checks;
    }

 private void ReadCustomMetadata(BitAccess bits)
 {
     int savedPosition = bits.Position;
       byte version;
       bits.ReadUInt8(out version);
       if (version != 4) {
     throw new PdbDebugException("Unknown custom metadata item version: {0}", version);
       }
       byte kind;
       bits.ReadUInt8(out kind);
       bits.Align(4);
       uint numberOfBytesInItem;
       bits.ReadUInt32(out numberOfBytesInItem);
       switch (kind) {
     case 0: this.ReadUsingInfo(bits); break;
     case 1: this.ReadForwardInfo(bits); break;
     case 2: this.ReadForwardedToModuleInfo(bits); break;
     case 3: this.ReadIteratorLocals(bits); break;
     case 4: this.ReadForwardIterator(bits); break;
     default: throw new PdbDebugException("Unknown custom metadata item kind: {0}", kind);
       }
       bits.Position = savedPosition+(int)numberOfBytesInItem;
 }

        internal PdbFunction(string module, ManProcSym proc, BitAccess bits)
        {
            this.Token = proc.token;
            this.Module = module;
            this.Name = proc.name;
            this.Flags = proc.flags;
            this.Segment = proc.seg;
            this.Address = proc.off;
            this.Length = proc.len;
            this.SlotToken = 0;

            if (proc.seg != 1)
            {
                throw new PdbDebugException("Segment is {0}, not 1.", proc.seg);
            }
            if (proc.parent != 0 || proc.next != 0)
            {
                throw new PdbDebugException("Warning parent={0}, next={1}",
                                            proc.parent, proc.next);
            }
            if (proc.dbgStart != 0 || proc.dbgEnd != 0)
            {
                throw new PdbDebugException("Warning DBG start={0}, end={1}",
                                            proc.dbgStart, proc.dbgEnd);
            }

            int constantCount;
            int scopeCount;
            int slotCount;
            int usedNamespacesCount;
            CountScopesAndSlots(bits, proc.end, out constantCount, out scopeCount, out slotCount, out usedNamespacesCount);
            this.Scopes = new PdbScope[scopeCount];
            const int scope = 0;

            while (bits.Position < proc.end)
            {
                ushort siz;
                ushort rec;

                bits.ReadUInt16(out siz);
                int star = bits.Position;
                int stop = bits.Position + siz;
                bits.Position = star;
                bits.ReadUInt16(out rec);

                switch ((SYM)rec)
                {
                    case SYM.S_OEM:
                        {          // 0x0404
                            OemSymbol oem;

                            bits.ReadGuid(out oem.idOem);
                            bits.ReadUInt32(out oem.typind);
                            // internal byte[] rgl; // user data, force 4-byte alignment

                            if (oem.idOem == MsilMetaData)
                            {
                                string name = bits.ReadString();
                                if (name == "MD2")
                                {
                                    byte version;
                                    bits.ReadUInt8(out version);
                                    if (version == 4)
                                    {
                                        byte count;
                                        bits.ReadUInt8(out count);
                                        bits.Align(4);
                                        while (count-- > 0)
                                            this.ReadCustomMetadata(bits);
                                    }
                                }
                                bits.Position = stop;
                                break;
                            }
                            throw new PdbDebugException("OEM section: guid={0} ti={1}",
                                                        oem.idOem, oem.typind);
                            // bits.Position = stop;
                        }

                    case SYM.S_BLOCK32:
                        {
                            BlockSym32 block = new BlockSym32();

                            bits.ReadUInt32(out block.parent);
                            bits.ReadUInt32(out block.end);
                            bits.ReadUInt32(out block.len);
                            bits.ReadUInt32(out this.Address);
                            bits.ReadUInt16(out block.seg);
                            bits.SkipCString(out block.name);
                            bits.Position = stop;

                            this.Scopes[scope] = new PdbScope(block, bits, out this.SlotToken);
                            bits.Position = (int)block.end;
                            break;
                        }

                    case SYM.S_UNAMESPACE:
                        bits.Position = stop;
                        break;

//.........这里部分代码省略.........

 internal PdbConstant(BitAccess bits)
 {
     bits.ReadUInt32(out this.Token);
     byte tag1;
     bits.ReadUInt8(out tag1);
     byte tag2;
     bits.ReadUInt8(out tag2);
     switch (tag2)
     {
         case 0:
             this.Value = tag1;
             break;
         case 0x80:
             switch (tag1)
             {
                 case 0x01: //short
                     short s;
                     bits.ReadInt16(out s);
                     this.Value = s;
                     break;
                 case 0x02: //ushort
                     ushort us;
                     bits.ReadUInt16(out us);
                     this.Value = us;
                     break;
                 case 0x03: //int
                     int i;
                     bits.ReadInt32(out i);
                     this.Value = i;
                     break;
                 case 0x04: //uint
                     uint ui;
                     bits.ReadUInt32(out ui);
                     this.Value = ui;
                     break;
                 case 0x05: //float
                     this.Value = bits.ReadFloat();
                     break;
                 case 0x06: //double
                     this.Value = bits.ReadDouble();
                     break;
                 case 0x09: //long
                     long sl;
                     bits.ReadInt64(out sl);
                     this.Value = sl;
                     break;
                 case 0x0a: //ulong
                     ulong ul;
                     bits.ReadUInt64(out ul);
                     this.Value = ul;
                     break;
                 case 0x10: //string
                     string str;
                     bits.ReadBString(out str);
                     this.Value = str;
                     break;
                 case 0x19: //decimal
                     this.Value = bits.ReadDecimal();
                     break;
             }
             break;
     }
     bits.ReadCString(out this.Name);
 }

 private void ReadCustomMetadata(BitAccess bits)
 {
   int savedPosition = bits.Position;
   byte version;
   bits.ReadUInt8(out version);
   byte kind;
   bits.ReadUInt8(out kind);
   bits.Align(4);
   uint numberOfBytesInItem;
   bits.ReadUInt32(out numberOfBytesInItem);
   if (version == 4)
   {
     switch (kind)
     {
       case 0: this.ReadUsingInfo(bits); break;
       case 1: this.ReadForwardInfo(bits); break;
       case 2: break; // this.ReadForwardedToModuleInfo(bits); break;
       case 3: this.ReadIteratorLocals(bits); break;
       case 4: this.ReadForwardIterator(bits); break;
     }
   }
   bits.Position = savedPosition + (int)numberOfBytesInItem;
 }

        private static IntHashTable ReadSourceFileInfo(BitAccess bits, uint limit, IntHashTable names, MsfDirectory dir,
      Dictionary<string, int> nameIndex, PdbReader reader)
        {
            IntHashTable checks = new IntHashTable();

              int begin = bits.Position;
              while (bits.Position < limit) {
            int sig;
            int siz;
            bits.ReadInt32(out sig);
            bits.ReadInt32(out siz);
            int place = bits.Position;
            int endSym = bits.Position + siz;

            switch ((DEBUG_S_SUBSECTION)sig) {
              case DEBUG_S_SUBSECTION.FILECHKSMS:
            while (bits.Position < endSym) {
              CV_FileCheckSum chk;

              int ni = bits.Position - place;
              bits.ReadUInt32(out chk.name);
              bits.ReadUInt8(out chk.len);
              bits.ReadUInt8(out chk.type);

              string name = (string)names[(int)chk.name];
              int guidStream;
            #if !NET_CORE
              Guid doctypeGuid = SymDocumentType.Text;
            #else
              // Note : netstandard1.6 doesn't support SymDocumentType.  Looks like it might be in netstandard2.0, but that
              // is not coming out for a few months still.  Looking at our mono, SymDocumentType.Text simply returns and empty Guid
              // so let's just go with that
              Guid doctypeGuid = Guid.Empty;
            #endif
              Guid languageGuid = Guid.Empty;
              Guid vendorGuid = Guid.Empty;
              if (nameIndex.TryGetValue("/SRC/FILES/"+name.ToUpperInvariant(), out guidStream)) {
                var guidBits = new BitAccess(0x100);
                dir.streams[guidStream].Read(reader, guidBits);
                LoadGuidStream(guidBits, out doctypeGuid, out languageGuid, out vendorGuid);
              }

              PdbSource src = new PdbSource(/*(uint)ni,*/ name, doctypeGuid, languageGuid, vendorGuid);
              checks.Add(ni, src);
              bits.Position += chk.len;
              bits.Align(4);
            }
            bits.Position = endSym;
            break;

              default:
            bits.Position = endSym;
            break;
            }
              }
              return checks;
        }

    private void ReadCustomMetadata(BitAccess bits)
    {
        int savedPosition = bits.Position;
        byte version;
        bits.ReadUInt8(out version);
        byte kind;
        bits.ReadUInt8(out kind);
        bits.Position += 2;   // 2-bytes padding
        uint numberOfBytesInItem;
        bits.ReadUInt32(out numberOfBytesInItem);
        if (version == 4)
        {
            switch (kind)
            {
                case 0: this.ReadUsingInfo(bits); break;
                case 1: this.ReadForwardInfo(bits); break;
                case 2: break; // this.ReadForwardedToModuleInfo(bits); break;
                case 3: this.ReadIteratorLocals(bits); break;
                case 4: this.ReadForwardIterator(bits); break;
                case 5: break; // dynamic locals - see http://index/#Microsoft.VisualStudio.LanguageServices/Shared/CustomDebugInfoReader.cs,a3031f7681d76e93
                case 6: break; // EnC data
                case 7: break; // EnC data for lambdas and closures
                // ignore any other unknown record types that may be added in future, instead of throwing an exception
                // see more details here: https://github.com/tmat/roslyn/blob/portable-pdb/docs/specs/PortablePdb-Metadata.md
                default: break; // throw new PdbDebugException("Unknown custom metadata item kind: {0}", kind);
            }
		}
        bits.Position = savedPosition + (int)numberOfBytesInItem;
    }