C# BitAccess.ReadUInt32方法代码示例

 internal DbiModuleInfo(BitAccess bits, bool readStrings) {
   bits.ReadInt32(out opened);
   section = new DbiSecCon(bits);
   bits.ReadUInt16(out flags);
   bits.ReadInt16(out stream);
   bits.ReadInt32(out cbSyms);
   bits.ReadInt32(out cbOldLines);
   bits.ReadInt32(out cbLines);
   bits.ReadInt16(out files);
   bits.ReadInt16(out pad1);
   bits.ReadUInt32(out offsets);
   bits.ReadInt32(out niSource);
   bits.ReadInt32(out niCompiler);
   if (readStrings) {
     bits.ReadCString(out moduleName);
     bits.ReadCString(out objectName);
   } else {
     bits.SkipCString(out moduleName);
     bits.SkipCString(out objectName);
   }
   bits.Align(4);
   //if (opened != 0 || pad1 != 0) {
   //  throw new PdbException("Invalid DBI module. "+
   //                                 "(opened={0}, pad={1})", opened, pad1);
   //}
 }

 internal DbiSecCon(BitAccess bits) {
   bits.ReadInt16(out section);
   bits.ReadInt16(out pad1);
   bits.ReadInt32(out offset);
   bits.ReadInt32(out size);
   bits.ReadUInt32(out flags);
   bits.ReadInt16(out module);
   bits.ReadInt16(out pad2);
   bits.ReadUInt32(out dataCrc);
   bits.ReadUInt32(out relocCrc);
   //if (pad1 != 0 || pad2 != 0) {
   //  throw new PdbException("Invalid DBI section. "+
   //                                 "(pad1={0}, pad2={1})",
   //                         pad1, pad2);
   //}
 }

    //internal uint segment;
    //internal uint address;

    internal PdbSlot(BitAccess bits) {
      AttrSlotSym slot;

      bits.ReadUInt32(out slot.index);
      bits.ReadUInt32(out slot.typind);
      bits.ReadUInt32(out slot.offCod);
      bits.ReadUInt16(out slot.segCod);
      bits.ReadUInt16(out slot.flags);
      bits.ReadCString(out slot.name);

      this.slot = slot.index;
      this.typeToken = slot.typind;
      this.name = slot.name;
      this.flags = slot.flags;
      //this.segment = slot.segCod;
      //this.address = slot.offCod;

    }

        internal PdbSlot(BitAccess bits, out uint typind)
        {
            AttrSlotSym slot;

            bits.ReadUInt32(out slot.index);
            bits.ReadUInt32(out slot.typind);
            bits.ReadUInt32(out slot.offCod);
            bits.ReadUInt16(out slot.segCod);
            bits.ReadUInt16(out slot.flags);
            bits.ReadCString(out slot.name);

            this.Slot = slot.index;
            this.Name = slot.name;
            this.Flags = slot.flags;
            this.Segment = slot.segCod;
            this.Address = slot.offCod;

            typind = slot.typind;
        }

        internal static PdbFunction[] LoadFunctions(Stream read, BitAccess bits, bool readAllStrings)
        {
            PdbFileHeader head = new PdbFileHeader(read, bits);
              PdbReader reader = new PdbReader(read, head.PageSize);
              MsfDirectory dir = new MsfDirectory(reader, head, bits);
              DbiModuleInfo[] modules;
              DbiDbgHdr header;

              dir.streams[1].Read(reader, bits);
              Dictionary<string, int> nameIndex = LoadNameIndex(bits);
              int nameStream;
              if (!nameIndex.TryGetValue("/names", out nameStream)) {
            throw new PdbException("No `name' stream");
              }

              dir.streams[nameStream].Read(reader, bits);
              IntHashTable names = LoadNameStream(bits);

              dir.streams[3].Read(reader, bits);
              LoadDbiStream(bits, out modules, out header, readAllStrings);

              ArrayList funcList = new ArrayList();

              if (modules != null) {
            for (int m = 0; m < modules.Length; m++) {
              if (modules[m].stream > 0) {
            dir.streams[modules[m].stream].Read(reader, bits);
            LoadFuncsFromDbiModule(bits, modules[m], names, funcList,
                                   readAllStrings, dir, nameIndex, reader);
              }
            }
              }

              PdbFunction[] funcs = (PdbFunction[])funcList.ToArray(typeof(PdbFunction));

              // After reading the functions, apply the token remapping table if it exists.
              if (header.snTokenRidMap != 0 && header.snTokenRidMap != 0xffff) {
            dir.streams[header.snTokenRidMap].Read(reader, bits);
            uint[] ridMap = new uint[dir.streams[header.snTokenRidMap].Length / 4];
            bits.ReadUInt32(ridMap);

            foreach (PdbFunction func in funcs) {
              func.Token = 0x06000000 | ridMap[func.Token & 0xffffff];
            }
              }

              //
              Array.Sort(funcs, PdbFunction.ByAddress);
              //Array.Sort(funcs, PdbFunction.byToken);
              return funcs;
        }

 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);
 }

        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;

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

    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 PdbSynchronizationPoint(BitAccess bits) {
   bits.ReadUInt32(out this.synchronizeOffset);
   bits.ReadUInt32(out this.continuationMethodToken);
   bits.ReadUInt32(out this.continuationOffset);
 }

    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;
    }

 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;
 }

    //private void ReadForwardedToModuleInfo(BitAccess bits) {
    //}

    private void ReadForwardInfo(BitAccess bits) {
      bits.ReadUInt32(out this.tokenOfMethodWhoseUsingInfoAppliesToThisMethod);
    }

    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.
//.........这里部分代码省略.........

    internal static void CountScopesAndSlots(BitAccess bits, uint limit,
                                             out int constants, out int scopes, out int slots, out int usedNamespaces) {
      int pos = bits.Position;
      BlockSym32 block;
      constants = 0;
      slots = 0;
      scopes = 0;
      usedNamespaces = 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_BLOCK32: {
              bits.ReadUInt32(out block.parent);
              bits.ReadUInt32(out block.end);

              scopes++;
              bits.Position = (int)block.end;
              break;
            }

          case SYM.S_MANSLOT:
            slots++;
            bits.Position = stop;
            break;

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

          case SYM.S_MANCONSTANT:
            constants++;
            bits.Position = stop;
            break;

          default:
            bits.Position = stop;
            break;
        }
      }
      bits.Position = pos;
    }