mcs/class/Mono.PEToolkit/metadata/TabsDecoder.cs

   1 // Auto-generated file - DO NOT EDIT!
   2 // Please edit md-schema.xml or tabs-decoder.xsl if you want to make changes.
   3
   4 using System;
   5
   6 namespace Mono.PEToolkit.Metadata {
   7
   8
   9         /// <summary>
  10         /// </summary>
  11         /// <remarks>
  12         /// </remarks>
  13         public sealed class TabsDecoder {
  14
  15                 private TabsDecoder()
  16                 {
  17                 }
  18
  19
  20                 /// <summary>
  21                 /// </summary>
  22                 /// <remarks>
  23                 /// </remarks>
  24                 public static MDToken DecodeToken(CodedTokenId id, int data)
  25                 {
  26                         MDToken res = new MDToken();
  27                         int tag;
  28                         int rid;
  29                         TokenType tok;
  30
  31                         switch (id) {
  32
  33                                 case CodedTokenId.TypeDefOrRef :
  34                                         tag = data & 0x03;
  35                                         rid = (int) ((uint) data >> 2);
  36                                         switch (tag) {
  37
  38                                                 case 0 :
  39                                                         tok = TokenType.TypeDef;
  40                                                         break;
  41
  42                                                 case 1 :
  43                                                         tok = TokenType.TypeRef;
  44                                                         break;
  45
  46                                                 case 2 :
  47                                                         tok = TokenType.TypeSpec;
  48                                                         break;
  49
  50                                                 default :
  51                                                         throw new BadMetaDataException("Invalid coded token for TypeDefOrRef, unknown table tag - " + tag);
  52                                         }
  53                                         res = new MDToken(tok, rid);
  54                                         break;
  55
  56                                 case CodedTokenId.HasConstant :
  57                                         tag = data & 0x03;
  58                                         rid = (int) ((uint) data >> 2);
  59                                         switch (tag) {
  60
  61                                                 case 0 :
  62                                                         tok = TokenType.FieldDef;
  63                                                         break;
  64
  65                                                 case 1 :
  66                                                         tok = TokenType.ParamDef;
  67                                                         break;
  68
  69                                                 case 2 :
  70                                                         tok = TokenType.Property;
  71                                                         break;
  72
  73                                                 default :
  74                                                         throw new BadMetaDataException("Invalid coded token for HasConstant, unknown table tag - " + tag);
  75                                         }
  76                                         res = new MDToken(tok, rid);
  77                                         break;
  78
  79                                 case CodedTokenId.HasCustomAttribute :
  80                                         tag = data & 0x1F;
  81                                         rid = (int) ((uint) data >> 5);
  82                                         switch (tag) {
  83
  84                                                 case 0 :
  85                                                         tok = TokenType.MethodDef;
  86                                                         break;
  87
  88                                                 case 1 :
  89                                                         tok = TokenType.FieldDef;
  90                                                         break;
  91
  92                                                 case 2 :
  93                                                         tok = TokenType.TypeRef;
  94                                                         break;
  95
  96                                                 case 3 :
  97                                                         tok = TokenType.TypeDef;
  98                                                         break;
  99
 100                                                 case 4 :
 101                                                         tok = TokenType.ParamDef;
 102                                                         break;
 103
 104                                                 case 5 :
 105                                                         tok = TokenType.InterfaceImpl;
 106                                                         break;
 107
 108                                                 case 6 :
 109                                                         tok = TokenType.MemberRef;
 110                                                         break;
 111
 112                                                 case 7 :
 113                                                         tok = TokenType.Module;
 114                                                         break;
 115
 116                                                 case 8 :
 117                                                         tok = TokenType.Permission;
 118                                                         break;
 119
 120                                                 case 9 :
 121                                                         tok = TokenType.Property;
 122                                                         break;
 123
 124                                                 case 10 :
 125                                                         tok = TokenType.Event;
 126                                                         break;
 127
 128                                                 case 11 :
 129                                                         tok = TokenType.Signature;
 130                                                         break;
 131
 132                                                 case 12 :
 133                                                         tok = TokenType.ModuleRef;
 134                                                         break;
 135
 136                                                 case 13 :
 137                                                         tok = TokenType.TypeSpec;
 138                                                         break;
 139
 140                                                 case 14 :
 141                                                         tok = TokenType.Assembly;
 142                                                         break;
 143
 144                                                 case 15 :
 145                                                         tok = TokenType.AssemblyRef;
 146                                                         break;
 147
 148                                                 case 16 :
 149                                                         tok = TokenType.File;
 150                                                         break;
 151
 152                                                 case 17 :
 153                                                         tok = TokenType.ExportedType;
 154                                                         break;
 155
 156                                                 case 18 :
 157                                                         tok = TokenType.ManifestResource;
 158                                                         break;
 159
 160                                                 default :
 161                                                         throw new BadMetaDataException("Invalid coded token for HasCustomAttribute, unknown table tag - " + tag);
 162                                         }
 163                                         res = new MDToken(tok, rid);
 164                                         break;
 165
 166                                 case CodedTokenId.HasFieldMarshal :
 167                                         tag = data & 0x01;
 168                                         rid = (int) ((uint) data >> 1);
 169                                         switch (tag) {
 170
 171                                                 case 0 :
 172                                                         tok = TokenType.FieldDef;
 173                                                         break;
 174
 175                                                 case 1 :
 176                                                         tok = TokenType.ParamDef;
 177                                                         break;
 178
 179                                                 default :
 180                                                         throw new BadMetaDataException("Invalid coded token for HasFieldMarshal, unknown table tag - " + tag);
 181                                         }
 182                                         res = new MDToken(tok, rid);
 183                                         break;
 184
 185                                 case CodedTokenId.HasDeclSecurity :
 186                                         tag = data & 0x03;
 187                                         rid = (int) ((uint) data >> 2);
 188                                         switch (tag) {
 189
 190                                                 case 0 :
 191                                                         tok = TokenType.TypeDef;
 192                                                         break;
 193
 194                                                 case 1 :
 195                                                         tok = TokenType.MethodDef;
 196                                                         break;
 197
 198                                                 case 2 :
 199                                                         tok = TokenType.Assembly;
 200                                                         break;
 201
 202                                                 default :
 203                                                         throw new BadMetaDataException("Invalid coded token for HasDeclSecurity, unknown table tag - " + tag);
 204                                         }
 205                                         res = new MDToken(tok, rid);
 206                                         break;
 207
 208                                 case CodedTokenId.MemberRefParent :
 209                                         tag = data & 0x07;
 210                                         rid = (int) ((uint) data >> 3);
 211                                         switch (tag) {
 212
 213                                                 case 0 :
 214                                                         tok = TokenType.TypeDef;
 215                                                         break;
 216
 217                                                 case 1 :
 218                                                         tok = TokenType.TypeRef;
 219                                                         break;
 220
 221                                                 case 2 :
 222                                                         tok = TokenType.ModuleRef;
 223                                                         break;
 224
 225                                                 case 3 :
 226                                                         tok = TokenType.MethodDef;
 227                                                         break;
 228
 229                                                 case 4 :
 230                                                         tok = TokenType.TypeSpec;
 231                                                         break;
 232
 233                                                 default :
 234                                                         throw new BadMetaDataException("Invalid coded token for MemberRefParent, unknown table tag - " + tag);
 235                                         }
 236                                         res = new MDToken(tok, rid);
 237                                         break;
 238
 239                                 case CodedTokenId.HasSemantics :
 240                                         tag = data & 0x01;
 241                                         rid = (int) ((uint) data >> 1);
 242                                         switch (tag) {
 243
 244                                                 case 0 :
 245                                                         tok = TokenType.Event;
 246                                                         break;
 247
 248                                                 case 1 :
 249                                                         tok = TokenType.Property;
 250                                                         break;
 251
 252                                                 default :
 253                                                         throw new BadMetaDataException("Invalid coded token for HasSemantics, unknown table tag - " + tag);
 254                                         }
 255                                         res = new MDToken(tok, rid);
 256                                         break;
 257
 258                                 case CodedTokenId.MethodDefOrRef :
 259                                         tag = data & 0x01;
 260                                         rid = (int) ((uint) data >> 1);
 261                                         switch (tag) {
 262
 263                                                 case 0 :
 264                                                         tok = TokenType.MethodDef;
 265                                                         break;
 266
 267                                                 case 1 :
 268                                                         tok = TokenType.MemberRef;
 269                                                         break;
 270
 271                                                 default :
 272                                                         throw new BadMetaDataException("Invalid coded token for MethodDefOrRef, unknown table tag - " + tag);
 273                                         }
 274                                         res = new MDToken(tok, rid);
 275                                         break;
 276
 277                                 case CodedTokenId.MemberForwarded :
 278                                         tag = data & 0x01;
 279                                         rid = (int) ((uint) data >> 1);
 280                                         switch (tag) {
 281
 282                                                 case 0 :
 283                                                         tok = TokenType.FieldDef;
 284                                                         break;
 285
 286                                                 case 1 :
 287                                                         tok = TokenType.MethodDef;
 288                                                         break;
 289
 290                                                 default :
 291                                                         throw new BadMetaDataException("Invalid coded token for MemberForwarded, unknown table tag - " + tag);
 292                                         }
 293                                         res = new MDToken(tok, rid);
 294                                         break;
 295
 296                                 case CodedTokenId.Implementation :
 297                                         tag = data & 0x03;
 298                                         rid = (int) ((uint) data >> 2);
 299                                         switch (tag) {
 300
 301                                                 case 0 :
 302                                                         tok = TokenType.File;
 303                                                         break;
 304
 305                                                 case 1 :
 306                                                         tok = TokenType.AssemblyRef;
 307                                                         break;
 308
 309                                                 case 2 :
 310                                                         tok = TokenType.ExportedType;
 311                                                         break;
 312
 313                                                 default :
 314                                                         throw new BadMetaDataException("Invalid coded token for Implementation, unknown table tag - " + tag);
 315                                         }
 316                                         res = new MDToken(tok, rid);
 317                                         break;
 318
 319                                 case CodedTokenId.CustomAttributeType :
 320                                         tag = data & 0x07;
 321                                         rid = (int) ((uint) data >> 3);
 322                                         switch (tag) {
 323
 324                                                 case 0 :
 325                                                         tok = TokenType.TypeRef;
 326                                                         break;
 327
 328                                                 case 1 :
 329                                                         tok = TokenType.TypeDef;
 330                                                         break;
 331
 332                                                 case 2 :
 333                                                         tok = TokenType.MethodDef;
 334                                                         break;
 335
 336                                                 case 3 :
 337                                                         tok = TokenType.MemberRef;
 338                                                         break;
 339
 340                                                 case 4 :
 341                                                         tok = TokenType.String;
 342                                                         break;
 343
 344                                                 default :
 345                                                         throw new BadMetaDataException("Invalid coded token for CustomAttributeType, unknown table tag - " + tag);
 346                                         }
 347                                         res = new MDToken(tok, rid);
 348                                         break;
 349
 350                                 case CodedTokenId.ResolutionScope :
 351                                         tag = data & 0x03;
 352                                         rid = (int) ((uint) data >> 2);
 353                                         switch (tag) {
 354
 355                                                 case 0 :
 356                                                         tok = TokenType.Module;
 357                                                         break;
 358
 359                                                 case 1 :
 360                                                         tok = TokenType.ModuleRef;
 361                                                         break;
 362
 363                                                 case 2 :
 364                                                         tok = TokenType.AssemblyRef;
 365                                                         break;
 366
 367                                                 case 3 :
 368                                                         tok = TokenType.TypeRef;
 369                                                         break;
 370
 371                                                 default :
 372                                                         throw new BadMetaDataException("Invalid coded token for ResolutionScope, unknown table tag - " + tag);
 373                                         }
 374                                         res = new MDToken(tok, rid);
 375                                         break;
 376
 377                                 default:
 378                                         break;
 379                         }
 380                         return res;
 381                 }
 382
 383
 384                 private static int GetCodedIndexSize(TablesHeap heap, CodedTokenId id, int [] rows)
 385                 {
 386                         int res = 0;
 387
 388                         switch (id) {
 389
 390                                 case CodedTokenId.TypeDefOrRef :
 391                                         res = MDUtils.Max(rows [(int) TableId.TypeDef], rows [(int) TableId.TypeRef], rows [(int) TableId.TypeSpec]);
 392                                         res = res < (1 << (16 - 2)) ? 2 : 4;
 393                                         break;
 394
 395                                 case CodedTokenId.HasConstant :
 396                                         res = MDUtils.Max(rows [(int) TableId.Field], rows [(int) TableId.Param], rows [(int) TableId.Property]);
 397                                         res = res < (1 << (16 - 2)) ? 2 : 4;
 398                                         break;
 399
 400                                 case CodedTokenId.HasCustomAttribute :
 401                                         res = MDUtils.Max(rows [(int) TableId.Method], rows [(int) TableId.Field], rows [(int) TableId.TypeRef], rows [(int) TableId.TypeDef], rows [(int) TableId.Param], rows [(int) TableId.InterfaceImpl], rows [(int) TableId.MemberRef], rows [(int) TableId.Module], rows [(int) TableId.DeclSecurity], rows [(int) TableId.Property], rows [(int) TableId.Event], rows [(int) TableId.StandAloneSig], rows [(int) TableId.ModuleRef], rows [(int) TableId.TypeSpec], rows [(int) TableId.Assembly], rows [(int) TableId.AssemblyRef], rows [(int) TableId.File], rows [(int) TableId.ExportedType], rows [(int) TableId.ManifestResource]);
 402                                         res = res < (1 << (16 - 5)) ? 2 : 4;
 403                                         break;
 404
 405                                 case CodedTokenId.HasFieldMarshal :
 406                                         res = MDUtils.Max(rows [(int) TableId.Field], rows [(int) TableId.Param]);
 407                                         res = res < (1 << (16 - 1)) ? 2 : 4;
 408                                         break;
 409
 410                                 case CodedTokenId.HasDeclSecurity :
 411                                         res = MDUtils.Max(rows [(int) TableId.TypeDef], rows [(int) TableId.Method], rows [(int) TableId.Assembly]);
 412                                         res = res < (1 << (16 - 2)) ? 2 : 4;
 413                                         break;
 414
 415                                 case CodedTokenId.MemberRefParent :
 416                                         res = MDUtils.Max(rows [(int) TableId.TypeDef], rows [(int) TableId.TypeRef], rows [(int) TableId.ModuleRef], rows [(int) TableId.Method], rows [(int) TableId.TypeSpec]);
 417                                         res = res < (1 << (16 - 3)) ? 2 : 4;
 418                                         break;
 419
 420                                 case CodedTokenId.HasSemantics :
 421                                         res = MDUtils.Max(rows [(int) TableId.Event], rows [(int) TableId.Property]);
 422                                         res = res < (1 << (16 - 1)) ? 2 : 4;
 423                                         break;
 424
 425                                 case CodedTokenId.MethodDefOrRef :
 426                                         res = MDUtils.Max(rows [(int) TableId.Method], rows [(int) TableId.MemberRef]);
 427                                         res = res < (1 << (16 - 1)) ? 2 : 4;
 428                                         break;
 429
 430                                 case CodedTokenId.MemberForwarded :
 431                                         res = MDUtils.Max(rows [(int) TableId.Field], rows [(int) TableId.Method]);
 432                                         res = res < (1 << (16 - 1)) ? 2 : 4;
 433                                         break;
 434
 435                                 case CodedTokenId.Implementation :
 436                                         res = MDUtils.Max(rows [(int) TableId.File], rows [(int) TableId.AssemblyRef], rows [(int) TableId.ExportedType]);
 437                                         res = res < (1 << (16 - 2)) ? 2 : 4;
 438                                         break;
 439
 440                                 case CodedTokenId.CustomAttributeType :
 441                                         res = MDUtils.Max(rows [(int) TableId.TypeRef], rows [(int) TableId.TypeDef], rows [(int) TableId.Method], rows [(int) TableId.MemberRef], (heap.StringsIndexSize > 2 ? 1 << 17 : 1));
 442                                         res = res < (1 << (16 - 3)) ? 2 : 4;
 443                                         break;
 444
 445                                 case CodedTokenId.ResolutionScope :
 446                                         res = MDUtils.Max(rows [(int) TableId.Module], rows [(int) TableId.ModuleRef], rows [(int) TableId.AssemblyRef], rows [(int) TableId.TypeRef]);
 447                                         res = res < (1 << (16 - 2)) ? 2 : 4;
 448                                         break;
 449
 450                                 default:
 451                                         break;
 452                         }
 453
 454                         return res;
 455                 }
 456
 457
 458                 private static int GetIndexSize(TableId tab, int [] rows)
 459                 {
 460                         // Index is 2 bytes wide if table has less than 2^16 rows
 461                         // otherwise it's 4 bytes wide.
 462                         return ((uint) rows [(int) tab]) < (1 << 16) ? 2 : 4;
 463                 }
 464
 465
 466                 private static void AllocBuff(ref byte [] buff, int size)
 467                 {
 468                         if (buff == null || buff.Length < size) {
 469                                 buff = new byte [(size + 4) & ~3];
 470                         }
 471                         Array.Clear(buff, 0, size);
 472                 }
 473
 474
 475                 /// <summary>
 476                 /// </summary>
 477                 unsafe public static int DecodePhysicalTables(TablesHeap heap, byte [] data, int offs, int [] rows)
 478                 {
 479                         int rowSize; // expanded row size (all indices are dwords)
 480                         int fldSize; // physical field size
 481                         int dest;
 482                         int nRows;
 483                         byte [] buff = null;
 484                         int si = heap.StringsIndexSize;
 485                         int gi = heap.GUIDIndexSize;
 486                         int bi = heap.BlobIndexSize;
 487
 488                         if (heap.HasModule) {
 489                                 rowSize = sizeof (ushort) + 4 + 4 + 4 + 4;
 490                                 nRows = rows [(int) TableId.Module];
 491                                 AllocBuff(ref buff, rowSize * nRows);
 492                                 dest = 0;
 493
 494                                 MDTable tab = new ModuleTable(heap);
 495
 496                                 for (int i = nRows; --i >= 0;) {
 497
 498                                         // Generation, ushort
 499                                         fldSize = sizeof (ushort);
 500                                         Array.Copy(data, offs, buff, dest, fldSize);
 501                                         offs += fldSize;
 502                                         dest += sizeof (ushort);
 503
 504                                         // Name, index(#Strings)
 505                                         fldSize = si;
 506                                         Array.Copy(data, offs, buff, dest, fldSize);
 507                                         offs += fldSize;
 508                                         dest += 4;
 509
 510                                         // Mvid, index(#GUID)
 511                                         fldSize = gi;
 512                                         Array.Copy(data, offs, buff, dest, fldSize);
 513                                         offs += fldSize;
 514                                         dest += 4;
 515
 516                                         // EncId, index(#GUID)
 517                                         fldSize = gi;
 518                                         Array.Copy(data, offs, buff, dest, fldSize);
 519                                         offs += fldSize;
 520                                         dest += 4;
 521
 522                                         // EncBaseId, index(#GUID)
 523                                         fldSize = gi;
 524                                         Array.Copy(data, offs, buff, dest, fldSize);
 525                                         offs += fldSize;
 526                                         dest += 4;
 527
 528                                 }
 529
 530                                 tab.FromRawData(buff, 0, nRows);
 531                         }
 532
 533                         if (heap.HasTypeRef) {
 534                                 rowSize = 4 + 4 + 4;
 535                                 nRows = rows [(int) TableId.TypeRef];
 536                                 AllocBuff(ref buff, rowSize * nRows);
 537                                 dest = 0;
 538
 539                                 MDTable tab = new TypeRefTable(heap);
 540
 541                                 for (int i = nRows; --i >= 0;) {
 542
 543                                         // ResolutionScope, coded-index(ResolutionScope)
 544                                         fldSize = GetCodedIndexSize(heap, CodedTokenId.ResolutionScope, rows);
 545                                         Array.Copy(data, offs, buff, dest, fldSize);
 546                                         offs += fldSize;
 547                                         dest += 4;
 548
 549                                         // Name, index(#Strings)
 550                                         fldSize = si;
 551                                         Array.Copy(data, offs, buff, dest, fldSize);
 552                                         offs += fldSize;
 553                                         dest += 4;
 554
 555                                         // Namespace, index(#Strings)
 556                                         fldSize = si;
 557                                         Array.Copy(data, offs, buff, dest, fldSize);
 558                                         offs += fldSize;
 559                                         dest += 4;
 560
 561                                 }
 562
 563                                 tab.FromRawData(buff, 0, nRows);
 564                         }
 565
 566                         if (heap.HasTypeDef) {
 567                                 rowSize = sizeof (uint) + 4 + 4 + 4 + 4 + 4;
 568                                 nRows = rows [(int) TableId.TypeDef];
 569                                 AllocBuff(ref buff, rowSize * nRows);
 570                                 dest = 0;
 571
 572                                 MDTable tab = new TypeDefTable(heap);
 573
 574                                 for (int i = nRows; --i >= 0;) {
 575
 576                                         // Flags, uint
 577                                         fldSize = sizeof (uint);
 578                                         Array.Copy(data, offs, buff, dest, fldSize);
 579                                         offs += fldSize;
 580                                         dest += sizeof (uint);
 581
 582                                         // Name, index(#Strings)
 583                                         fldSize = si;
 584                                         Array.Copy(data, offs, buff, dest, fldSize);
 585                                         offs += fldSize;
 586                                         dest += 4;
 587
 588                                         // Namespace, index(#Strings)
 589                                         fldSize = si;
 590                                         Array.Copy(data, offs, buff, dest, fldSize);
 591                                         offs += fldSize;
 592                                         dest += 4;
 593
 594                                         // Extends, coded-index(TypeDefOrRef)
 595                                         fldSize = GetCodedIndexSize(heap, CodedTokenId.TypeDefOrRef, rows);
 596                                         Array.Copy(data, offs, buff, dest, fldSize);
 597                                         offs += fldSize;
 598                                         dest += 4;
 599
 600                                         // FieldList, index(Field)
 601                                         fldSize = GetIndexSize(TableId.Field, rows);
 602                                         Array.Copy(data, offs, buff, dest, fldSize);
 603                                         offs += fldSize;
 604                                         dest += 4;
 605
 606                                         // MethodList, index(Method)
 607                                         fldSize = GetIndexSize(TableId.Method, rows);
 608                                         Array.Copy(data, offs, buff, dest, fldSize);
 609                                         offs += fldSize;
 610                                         dest += 4;
 611
 612                                 }
 613
 614                                 tab.FromRawData(buff, 0, nRows);
 615                         }
 616
 617                         if (heap.HasFieldPtr) {
 618                                 rowSize = 4;
 619                                 nRows = rows [(int) TableId.FieldPtr];
 620                                 AllocBuff(ref buff, rowSize * nRows);
 621                                 dest = 0;
 622
 623                                 MDTable tab = new FieldPtrTable(heap);
 624
 625                                 for (int i = nRows; --i >= 0;) {
 626
 627                                         // Field, index(Field)
 628                                         fldSize = GetIndexSize(TableId.Field, rows);
 629                                         Array.Copy(data, offs, buff, dest, fldSize);
 630                                         offs += fldSize;
 631                                         dest += 4;
 632
 633                                 }
 634
 635                                 tab.FromRawData(buff, 0, nRows);
 636                         }
 637
 638                         if (heap.HasField) {
 639                                 rowSize = sizeof (ushort) + 4 + 4;
 640                                 nRows = rows [(int) TableId.Field];
 641                                 AllocBuff(ref buff, rowSize * nRows);
 642                                 dest = 0;
 643
 644                                 MDTable tab = new FieldTable(heap);
 645
 646                                 for (int i = nRows; --i >= 0;) {
 647
 648                                         // Flags, ushort
 649                                         fldSize = sizeof (ushort);
 650                                         Array.Copy(data, offs, buff, dest, fldSize);
 651                                         offs += fldSize;
 652                                         dest += sizeof (ushort);
 653
 654                                         // Name, index(#Strings)
 655                                         fldSize = si;
 656                                         Array.Copy(data, offs, buff, dest, fldSize);
 657                                         offs += fldSize;
 658                                         dest += 4;
 659
 660                                         // Signature, index(#Blob)
 661                                         fldSize = bi;
 662                                         Array.Copy(data, offs, buff, dest, fldSize);
 663                                         offs += fldSize;
 664                                         dest += 4;
 665
 666                                 }
 667
 668                                 tab.FromRawData(buff, 0, nRows);
 669                         }
 670
 671                         if (heap.HasMethodPtr) {
 672                                 rowSize = 4;
 673                                 nRows = rows [(int) TableId.MethodPtr];
 674                                 AllocBuff(ref buff, rowSize * nRows);
 675                                 dest = 0;
 676
 677                                 MDTable tab = new MethodPtrTable(heap);
 678
 679                                 for (int i = nRows; --i >= 0;) {
 680
 681                                         // Method, index(Method)
 682                                         fldSize = GetIndexSize(TableId.Method, rows);
 683                                         Array.Copy(data, offs, buff, dest, fldSize);
 684                                         offs += fldSize;
 685                                         dest += 4;
 686
 687                                 }
 688
 689                                 tab.FromRawData(buff, 0, nRows);
 690                         }
 691
 692                         if (heap.HasMethod) {
 693                                 rowSize = RVA.Size + sizeof (ushort) + sizeof (ushort) + 4 + 4 + 4;
 694                                 nRows = rows [(int) TableId.Method];
 695                                 AllocBuff(ref buff, rowSize * nRows);
 696                                 dest = 0;
 697
 698                                 MDTable tab = new MethodTable(heap);
 699
 700                                 for (int i = nRows; --i >= 0;) {
 701
 702                                         // RVA, RVA
 703                                         fldSize = RVA.Size;
 704                                         Array.Copy(data, offs, buff, dest, fldSize);
 705                                         offs += fldSize;
 706                                         dest += RVA.Size;
 707
 708                                         // ImplFlags, ushort
 709                                         fldSize = sizeof (ushort);
 710                                         Array.Copy(data, offs, buff, dest, fldSize);
 711                                         offs += fldSize;
 712                                         dest += sizeof (ushort);
 713
 714                                         // Flags, ushort
 715                                         fldSize = sizeof (ushort);
 716                                         Array.Copy(data, offs, buff, dest, fldSize);
 717                                         offs += fldSize;
 718                                         dest += sizeof (ushort);
 719
 720                                         // Name, index(#Strings)
 721                                         fldSize = si;
 722                                         Array.Copy(data, offs, buff, dest, fldSize);
 723                                         offs += fldSize;
 724                                         dest += 4;
 725
 726                                         // Signature, index(#Blob)
 727                                         fldSize = bi;
 728                                         Array.Copy(data, offs, buff, dest, fldSize);
 729                                         offs += fldSize;
 730                                         dest += 4;
 731
 732                                         // ParamList, index(Param)
 733                                         fldSize = GetIndexSize(TableId.Param, rows);
 734                                         Array.Copy(data, offs, buff, dest, fldSize);
 735                                         offs += fldSize;
 736                                         dest += 4;
 737
 738                                 }
 739
 740                                 tab.FromRawData(buff, 0, nRows);
 741                         }
 742
 743                         if (heap.HasParamPtr) {
 744                                 rowSize = 4;
 745                                 nRows = rows [(int) TableId.ParamPtr];
 746                                 AllocBuff(ref buff, rowSize * nRows);
 747                                 dest = 0;
 748
 749                                 MDTable tab = new ParamPtrTable(heap);
 750
 751                                 for (int i = nRows; --i >= 0;) {
 752
 753                                         // Param, index(Param)
 754                                         fldSize = GetIndexSize(TableId.Param, rows);
 755                                         Array.Copy(data, offs, buff, dest, fldSize);
 756                                         offs += fldSize;
 757                                         dest += 4;
 758
 759                                 }
 760
 761                                 tab.FromRawData(buff, 0, nRows);
 762                         }
 763
 764                         if (heap.HasParam) {
 765                                 rowSize = sizeof (ushort) + sizeof (ushort) + 4;
 766                                 nRows = rows [(int) TableId.Param];
 767                                 AllocBuff(ref buff, rowSize * nRows);
 768                                 dest = 0;
 769
 770                                 MDTable tab = new ParamTable(heap);
 771
 772                                 for (int i = nRows; --i >= 0;) {
 773
 774                                         // Flags, ushort
 775                                         fldSize = sizeof (ushort);
 776                                         Array.Copy(data, offs, buff, dest, fldSize);
 777                                         offs += fldSize;
 778                                         dest += sizeof (ushort);
 779
 780                                         // Sequence, ushort
 781                                         fldSize = sizeof (ushort);
 782                                         Array.Copy(data, offs, buff, dest, fldSize);
 783                                         offs += fldSize;
 784                                         dest += sizeof (ushort);
 785
 786                                         // Name, index(#Strings)
 787                                         fldSize = si;
 788                                         Array.Copy(data, offs, buff, dest, fldSize);
 789                                         offs += fldSize;
 790                                         dest += 4;
 791
 792                                 }
 793
 794                                 tab.FromRawData(buff, 0, nRows);
 795                         }
 796
 797                         if (heap.HasInterfaceImpl) {
 798                                 rowSize = 4 + 4;
 799                                 nRows = rows [(int) TableId.InterfaceImpl];
 800                                 AllocBuff(ref buff, rowSize * nRows);
 801                                 dest = 0;
 802
 803                                 MDTable tab = new InterfaceImplTable(heap);
 804
 805                                 for (int i = nRows; --i >= 0;) {
 806
 807                                         // Class, index(TypeDef)
 808                                         fldSize = GetIndexSize(TableId.TypeDef, rows);
 809                                         Array.Copy(data, offs, buff, dest, fldSize);
 810                                         offs += fldSize;
 811                                         dest += 4;
 812
 813                                         // Interface, coded-index(TypeDefOrRef)
 814                                         fldSize = GetCodedIndexSize(heap, CodedTokenId.TypeDefOrRef, rows);
 815                                         Array.Copy(data, offs, buff, dest, fldSize);
 816                                         offs += fldSize;
 817                                         dest += 4;
 818
 819                                 }
 820
 821                                 tab.FromRawData(buff, 0, nRows);
 822                         }
 823
 824                         if (heap.HasMemberRef) {
 825                                 rowSize = 4 + 4 + 4;
 826                                 nRows = rows [(int) TableId.MemberRef];
 827                                 AllocBuff(ref buff, rowSize * nRows);
 828                                 dest = 0;
 829
 830                                 MDTable tab = new MemberRefTable(heap);
 831
 832                                 for (int i = nRows; --i >= 0;) {
 833
 834                                         // Class, coded-index(MemberRefParent)
 835                                         fldSize = GetCodedIndexSize(heap, CodedTokenId.MemberRefParent, rows);
 836                                         Array.Copy(data, offs, buff, dest, fldSize);
 837                                         offs += fldSize;
 838                                         dest += 4;
 839
 840                                         // Name, index(#Strings)
 841                                         fldSize = si;
 842                                         Array.Copy(data, offs, buff, dest, fldSize);
 843                                         offs += fldSize;
 844                                         dest += 4;
 845
 846                                         // Signature, index(#Blob)
 847                                         fldSize = bi;
 848                                         Array.Copy(data, offs, buff, dest, fldSize);
 849                                         offs += fldSize;
 850                                         dest += 4;
 851
 852                                 }
 853
 854                                 tab.FromRawData(buff, 0, nRows);
 855                         }
 856
 857                         if (heap.HasConstant) {
 858                                 rowSize = sizeof (short) + 4 + 4;
 859                                 nRows = rows [(int) TableId.Constant];
 860                                 AllocBuff(ref buff, rowSize * nRows);
 861                                 dest = 0;
 862
 863                                 MDTable tab = new ConstantTable(heap);
 864
 865                                 for (int i = nRows; --i >= 0;) {
 866
 867                                         // Type, short
 868                                         fldSize = sizeof (short);
 869                                         Array.Copy(data, offs, buff, dest, fldSize);
 870                                         offs += fldSize;
 871                                         dest += sizeof (short);
 872
 873                                         // Parent, coded-index(HasConstant)
 874                                         fldSize = GetCodedIndexSize(heap, CodedTokenId.HasConstant, rows);
 875                                         Array.Copy(data, offs, buff, dest, fldSize);
 876                                         offs += fldSize;
 877                                         dest += 4;
 878
 879                                         // Value, index(#Blob)
 880                                         fldSize = bi;
 881                                         Array.Copy(data, offs, buff, dest, fldSize);
 882                                         offs += fldSize;
 883                                         dest += 4;
 884
 885                                 }
 886
 887                                 tab.FromRawData(buff, 0, nRows);
 888                         }
 889
 890                         if (heap.HasCustomAttribute) {
 891                                 rowSize = 4 + 4 + 4;
 892                                 nRows = rows [(int) TableId.CustomAttribute];
 893                                 AllocBuff(ref buff, rowSize * nRows);
 894                                 dest = 0;
 895
 896                                 MDTable tab = new CustomAttributeTable(heap);
 897
 898                                 for (int i = nRows; --i >= 0;) {
 899
 900                                         // Parent, coded-index(HasCustomAttribute)
 901                                         fldSize = GetCodedIndexSize(heap, CodedTokenId.HasCustomAttribute, rows);
 902                                         Array.Copy(data, offs, buff, dest, fldSize);
 903                                         offs += fldSize;
 904                                         dest += 4;
 905
 906                                         // Type, coded-index(CustomAttributeType)
 907                                         fldSize = GetCodedIndexSize(heap, CodedTokenId.CustomAttributeType, rows);
 908                                         Array.Copy(data, offs, buff, dest, fldSize);
 909                                         offs += fldSize;
 910                                         dest += 4;
 911
 912                                         // Value, index(#Blob)
 913                                         fldSize = bi;
 914                                         Array.Copy(data, offs, buff, dest, fldSize);
 915                                         offs += fldSize;
 916                                         dest += 4;
 917
 918                                 }
 919
 920                                 tab.FromRawData(buff, 0, nRows);
 921                         }
 922
 923                         if (heap.HasFieldMarshal) {
 924                                 rowSize = 4 + 4;
 925                                 nRows = rows [(int) TableId.FieldMarshal];
 926                                 AllocBuff(ref buff, rowSize * nRows);
 927                                 dest = 0;
 928
 929                                 MDTable tab = new FieldMarshalTable(heap);
 930
 931                                 for (int i = nRows; --i >= 0;) {
 932
 933                                         // Parent, coded-index(HasFieldMarshal)
 934                                         fldSize = GetCodedIndexSize(heap, CodedTokenId.HasFieldMarshal, rows);
 935                                         Array.Copy(data, offs, buff, dest, fldSize);
 936                                         offs += fldSize;
 937                                         dest += 4;
 938
 939                                         // NativeType, index(#Blob)
 940                                         fldSize = bi;
 941                                         Array.Copy(data, offs, buff, dest, fldSize);
 942                                         offs += fldSize;
 943                                         dest += 4;
 944
 945                                 }
 946
 947                                 tab.FromRawData(buff, 0, nRows);
 948                         }
 949
 950                         if (heap.HasDeclSecurity) {
 951                                 rowSize = sizeof (short) + 4 + 4;
 952                                 nRows = rows [(int) TableId.DeclSecurity];
 953                                 AllocBuff(ref buff, rowSize * nRows);
 954                                 dest = 0;
 955
 956                                 MDTable tab = new DeclSecurityTable(heap);
 957
 958                                 for (int i = nRows; --i >= 0;) {
 959
 960                                         // Action, short
 961                                         fldSize = sizeof (short);
 962                                         Array.Copy(data, offs, buff, dest, fldSize);
 963                                         offs += fldSize;
 964                                         dest += sizeof (short);
 965
 966                                         // Parent, coded-index(HasDeclSecurity)
 967                                         fldSize = GetCodedIndexSize(heap, CodedTokenId.HasDeclSecurity, rows);
 968                                         Array.Copy(data, offs, buff, dest, fldSize);
 969                                         offs += fldSize;
 970                                         dest += 4;
 971
 972                                         // PermissionSet, index(#Blob)
 973                                         fldSize = bi;
 974                                         Array.Copy(data, offs, buff, dest, fldSize);
 975                                         offs += fldSize;
 976                                         dest += 4;
 977
 978                                 }
 979
 980                                 tab.FromRawData(buff, 0, nRows);
 981                         }
 982
 983                         if (heap.HasClassLayout) {
 984                                 rowSize = sizeof (short) + sizeof (int) + 4;
 985                                 nRows = rows [(int) TableId.ClassLayout];
 986                                 AllocBuff(ref buff, rowSize * nRows);
 987                                 dest = 0;
 988
 989                                 MDTable tab = new ClassLayoutTable(heap);
 990
 991                                 for (int i = nRows; --i >= 0;) {
 992
 993                                         // PackingSize, short
 994                                         fldSize = sizeof (short);
 995                                         Array.Copy(data, offs, buff, dest, fldSize);
 996                                         offs += fldSize;
 997                                         dest += sizeof (short);
 998
 999                                         // ClassSize, int
1000                                         fldSize = sizeof (int);
1001                                         Array.Copy(data, offs, buff, dest, fldSize);
1002                                         offs += fldSize;
1003                                         dest += sizeof (int);
1004
1005                                         // Parent, index(TypeDef)
1006                                         fldSize = GetIndexSize(TableId.TypeDef, rows);
1007                                         Array.Copy(data, offs, buff, dest, fldSize);
1008                                         offs += fldSize;
1009                                         dest += 4;
1010
1011                                 }
1012
1013                                 tab.FromRawData(buff, 0, nRows);
1014                         }
1015
1016                         if (heap.HasFieldLayout) {
1017                                 rowSize = sizeof (int) + 4;
1018                                 nRows = rows [(int) TableId.FieldLayout];
1019                                 AllocBuff(ref buff, rowSize * nRows);
1020                                 dest = 0;
1021
1022                                 MDTable tab = new FieldLayoutTable(heap);
1023
1024                                 for (int i = nRows; --i >= 0;) {
1025
1026                                         // Offset, int
1027                                         fldSize = sizeof (int);
1028                                         Array.Copy(data, offs, buff, dest, fldSize);
1029                                         offs += fldSize;
1030                                         dest += sizeof (int);
1031
1032                                         // Field, index(Field)
1033                                         fldSize = GetIndexSize(TableId.Field, rows);
1034                                         Array.Copy(data, offs, buff, dest, fldSize);
1035                                         offs += fldSize;
1036                                         dest += 4;
1037
1038                                 }
1039
1040                                 tab.FromRawData(buff, 0, nRows);
1041                         }
1042
1043                         if (heap.HasStandAloneSig) {
1044                                 rowSize = 4;
1045                                 nRows = rows [(int) TableId.StandAloneSig];
1046                                 AllocBuff(ref buff, rowSize * nRows);
1047                                 dest = 0;
1048
1049                                 MDTable tab = new StandAloneSigTable(heap);
1050
1051                                 for (int i = nRows; --i >= 0;) {
1052
1053                                         // Signature, index(#Blob)
1054                                         fldSize = bi;
1055                                         Array.Copy(data, offs, buff, dest, fldSize);
1056                                         offs += fldSize;
1057                                         dest += 4;
1058
1059                                 }
1060
1061                                 tab.FromRawData(buff, 0, nRows);
1062                         }
1063
1064                         if (heap.HasEventMap) {
1065                                 rowSize = 4 + 4;
1066                                 nRows = rows [(int) TableId.EventMap];
1067                                 AllocBuff(ref buff, rowSize * nRows);
1068                                 dest = 0;
1069
1070                                 MDTable tab = new EventMapTable(heap);
1071
1072                                 for (int i = nRows; --i >= 0;) {
1073
1074                                         // Parent, index(TypeDef)
1075                                         fldSize = GetIndexSize(TableId.TypeDef, rows);
1076                                         Array.Copy(data, offs, buff, dest, fldSize);
1077                                         offs += fldSize;
1078                                         dest += 4;
1079
1080                                         // EventList, index(Event)
1081                                         fldSize = GetIndexSize(TableId.Event, rows);
1082                                         Array.Copy(data, offs, buff, dest, fldSize);
1083                                         offs += fldSize;
1084                                         dest += 4;
1085
1086                                 }
1087
1088                                 tab.FromRawData(buff, 0, nRows);
1089                         }
1090
1091                         if (heap.HasEventPtr) {
1092                                 rowSize = 4;
1093                                 nRows = rows [(int) TableId.EventPtr];
1094                                 AllocBuff(ref buff, rowSize * nRows);
1095                                 dest = 0;
1096
1097                                 MDTable tab = new EventPtrTable(heap);
1098
1099                                 for (int i = nRows; --i >= 0;) {
1100
1101                                         // Event, index(Event)
1102                                         fldSize = GetIndexSize(TableId.Event, rows);
1103                                         Array.Copy(data, offs, buff, dest, fldSize);
1104                                         offs += fldSize;
1105                                         dest += 4;
1106
1107                                 }
1108
1109                                 tab.FromRawData(buff, 0, nRows);
1110                         }
1111
1112                         if (heap.HasEvent) {
1113                                 rowSize = sizeof (short) + 4 + 4;
1114                                 nRows = rows [(int) TableId.Event];
1115                                 AllocBuff(ref buff, rowSize * nRows);
1116                                 dest = 0;
1117
1118                                 MDTable tab = new EventTable(heap);
1119
1120                                 for (int i = nRows; --i >= 0;) {
1121
1122                                         // EventFlags, short
1123                                         fldSize = sizeof (short);
1124                                         Array.Copy(data, offs, buff, dest, fldSize);
1125                                         offs += fldSize;
1126                                         dest += sizeof (short);
1127
1128                                         // Name, index(#Strings)
1129                                         fldSize = si;
1130                                         Array.Copy(data, offs, buff, dest, fldSize);
1131                                         offs += fldSize;
1132                                         dest += 4;
1133
1134                                         // EventType, coded-index(TypeDefOrRef)
1135                                         fldSize = GetCodedIndexSize(heap, CodedTokenId.TypeDefOrRef, rows);
1136                                         Array.Copy(data, offs, buff, dest, fldSize);
1137                                         offs += fldSize;
1138                                         dest += 4;
1139
1140                                 }
1141
1142                                 tab.FromRawData(buff, 0, nRows);
1143                         }
1144
1145                         if (heap.HasPropertyMap) {
1146                                 rowSize = 4 + 4;
1147                                 nRows = rows [(int) TableId.PropertyMap];
1148                                 AllocBuff(ref buff, rowSize * nRows);
1149                                 dest = 0;
1150
1151                                 MDTable tab = new PropertyMapTable(heap);
1152
1153                                 for (int i = nRows; --i >= 0;) {
1154
1155                                         // Parent, index(TypeDef)
1156                                         fldSize = GetIndexSize(TableId.TypeDef, rows);
1157                                         Array.Copy(data, offs, buff, dest, fldSize);
1158                                         offs += fldSize;
1159                                         dest += 4;
1160
1161                                         // PropertyList, index(Property)
1162                                         fldSize = GetIndexSize(TableId.Property, rows);
1163                                         Array.Copy(data, offs, buff, dest, fldSize);
1164                                         offs += fldSize;
1165                                         dest += 4;
1166
1167                                 }
1168
1169                                 tab.FromRawData(buff, 0, nRows);
1170                         }
1171
1172                         if (heap.HasPropertyPtr) {
1173                                 rowSize = 4;
1174                                 nRows = rows [(int) TableId.PropertyPtr];
1175                                 AllocBuff(ref buff, rowSize * nRows);
1176                                 dest = 0;
1177
1178                                 MDTable tab = new PropertyPtrTable(heap);
1179
1180                                 for (int i = nRows; --i >= 0;) {
1181
1182                                         // Property, index(Property)
1183                                         fldSize = GetIndexSize(TableId.Property, rows);
1184                                         Array.Copy(data, offs, buff, dest, fldSize);
1185                                         offs += fldSize;
1186                                         dest += 4;
1187
1188                                 }
1189
1190                                 tab.FromRawData(buff, 0, nRows);
1191                         }
1192
1193                         if (heap.HasProperty) {
1194                                 rowSize = sizeof (ushort) + 4 + 4;
1195                                 nRows = rows [(int) TableId.Property];
1196                                 AllocBuff(ref buff, rowSize * nRows);
1197                                 dest = 0;
1198
1199                                 MDTable tab = new PropertyTable(heap);
1200
1201                                 for (int i = nRows; --i >= 0;) {
1202
1203                                         // Flags, ushort
1204                                         fldSize = sizeof (ushort);
1205                                         Array.Copy(data, offs, buff, dest, fldSize);
1206                                         offs += fldSize;
1207                                         dest += sizeof (ushort);
1208
1209                                         // Name, index(#Strings)
1210                                         fldSize = si;
1211                                         Array.Copy(data, offs, buff, dest, fldSize);
1212                                         offs += fldSize;
1213                                         dest += 4;
1214
1215                                         // Type, index(#Blob)
1216                                         fldSize = bi;
1217                                         Array.Copy(data, offs, buff, dest, fldSize);
1218                                         offs += fldSize;
1219                                         dest += 4;
1220
1221                                 }
1222
1223                                 tab.FromRawData(buff, 0, nRows);
1224                         }
1225
1226                         if (heap.HasMethodSemantics) {
1227                                 rowSize = sizeof (ushort) + 4 + 4;
1228                                 nRows = rows [(int) TableId.MethodSemantics];
1229                                 AllocBuff(ref buff, rowSize * nRows);
1230                                 dest = 0;
1231
1232                                 MDTable tab = new MethodSemanticsTable(heap);
1233
1234                                 for (int i = nRows; --i >= 0;) {
1235
1236                                         // Semantics, ushort
1237                                         fldSize = sizeof (ushort);
1238                                         Array.Copy(data, offs, buff, dest, fldSize);
1239                                         offs += fldSize;
1240                                         dest += sizeof (ushort);
1241
1242                                         // Method, index(Method)
1243                                         fldSize = GetIndexSize(TableId.Method, rows);
1244                                         Array.Copy(data, offs, buff, dest, fldSize);
1245                                         offs += fldSize;
1246                                         dest += 4;
1247
1248                                         // Association, coded-index(HasSemantics)
1249                                         fldSize = GetCodedIndexSize(heap, CodedTokenId.HasSemantics, rows);
1250                                         Array.Copy(data, offs, buff, dest, fldSize);
1251                                         offs += fldSize;
1252                                         dest += 4;
1253
1254                                 }
1255
1256                                 tab.FromRawData(buff, 0, nRows);
1257                         }
1258
1259                         if (heap.HasMethodImpl) {
1260                                 rowSize = 4 + 4 + 4;
1261                                 nRows = rows [(int) TableId.MethodImpl];
1262                                 AllocBuff(ref buff, rowSize * nRows);
1263                                 dest = 0;
1264
1265                                 MDTable tab = new MethodImplTable(heap);
1266
1267                                 for (int i = nRows; --i >= 0;) {
1268
1269                                         // Class, index(TypeDef)
1270                                         fldSize = GetIndexSize(TableId.TypeDef, rows);
1271                                         Array.Copy(data, offs, buff, dest, fldSize);
1272                                         offs += fldSize;
1273                                         dest += 4;
1274
1275                                         // MethodBody, coded-index(MethodDefOrRef)
1276                                         fldSize = GetCodedIndexSize(heap, CodedTokenId.MethodDefOrRef, rows);
1277                                         Array.Copy(data, offs, buff, dest, fldSize);
1278                                         offs += fldSize;
1279                                         dest += 4;
1280
1281                                         // MethodDeclaration, coded-index(MethodDefOrRef)
1282                                         fldSize = GetCodedIndexSize(heap, CodedTokenId.MethodDefOrRef, rows);
1283                                         Array.Copy(data, offs, buff, dest, fldSize);
1284                                         offs += fldSize;
1285                                         dest += 4;
1286
1287                                 }
1288
1289                                 tab.FromRawData(buff, 0, nRows);
1290                         }
1291
1292                         if (heap.HasModuleRef) {
1293                                 rowSize = 4;
1294                                 nRows = rows [(int) TableId.ModuleRef];
1295                                 AllocBuff(ref buff, rowSize * nRows);
1296                                 dest = 0;
1297
1298                                 MDTable tab = new ModuleRefTable(heap);
1299
1300                                 for (int i = nRows; --i >= 0;) {
1301
1302                                         // Name, index(#Strings)
1303                                         fldSize = si;
1304                                         Array.Copy(data, offs, buff, dest, fldSize);
1305                                         offs += fldSize;
1306                                         dest += 4;
1307
1308                                 }
1309
1310                                 tab.FromRawData(buff, 0, nRows);
1311                         }
1312
1313                         if (heap.HasTypeSpec) {
1314                                 rowSize = 4;
1315                                 nRows = rows [(int) TableId.TypeSpec];
1316                                 AllocBuff(ref buff, rowSize * nRows);
1317                                 dest = 0;
1318
1319                                 MDTable tab = new TypeSpecTable(heap);
1320
1321                                 for (int i = nRows; --i >= 0;) {
1322
1323                                         // Signature, index(#Blob)
1324                                         fldSize = bi;
1325                                         Array.Copy(data, offs, buff, dest, fldSize);
1326                                         offs += fldSize;
1327                                         dest += 4;
1328
1329                                 }
1330
1331                                 tab.FromRawData(buff, 0, nRows);
1332                         }
1333
1334                         if (heap.HasImplMap) {
1335                                 rowSize = sizeof (ushort) + 4 + 4 + 4;
1336                                 nRows = rows [(int) TableId.ImplMap];
1337                                 AllocBuff(ref buff, rowSize * nRows);
1338                                 dest = 0;
1339
1340                                 MDTable tab = new ImplMapTable(heap);
1341
1342                                 for (int i = nRows; --i >= 0;) {
1343
1344                                         // MappingFlags, ushort
1345                                         fldSize = sizeof (ushort);
1346                                         Array.Copy(data, offs, buff, dest, fldSize);
1347                                         offs += fldSize;
1348                                         dest += sizeof (ushort);
1349
1350                                         // MemberForwarded, coded-index(MemberForwarded)
1351                                         fldSize = GetCodedIndexSize(heap, CodedTokenId.MemberForwarded, rows);
1352                                         Array.Copy(data, offs, buff, dest, fldSize);
1353                                         offs += fldSize;
1354                                         dest += 4;
1355
1356                                         // ImportName, index(#Strings)
1357                                         fldSize = si;
1358                                         Array.Copy(data, offs, buff, dest, fldSize);
1359                                         offs += fldSize;
1360                                         dest += 4;
1361
1362                                         // ImportScope, index(ModuleRef)
1363                                         fldSize = GetIndexSize(TableId.ModuleRef, rows);
1364                                         Array.Copy(data, offs, buff, dest, fldSize);
1365                                         offs += fldSize;
1366                                         dest += 4;
1367
1368                                 }
1369
1370                                 tab.FromRawData(buff, 0, nRows);
1371                         }
1372
1373                         if (heap.HasFieldRVA) {
1374                                 rowSize = RVA.Size + 4;
1375                                 nRows = rows [(int) TableId.FieldRVA];
1376                                 AllocBuff(ref buff, rowSize * nRows);
1377                                 dest = 0;
1378
1379                                 MDTable tab = new FieldRVATable(heap);
1380
1381                                 for (int i = nRows; --i >= 0;) {
1382
1383                                         // RVA, RVA
1384                                         fldSize = RVA.Size;
1385                                         Array.Copy(data, offs, buff, dest, fldSize);
1386                                         offs += fldSize;
1387                                         dest += RVA.Size;
1388
1389                                         // Field, index(Field)
1390                                         fldSize = GetIndexSize(TableId.Field, rows);
1391                                         Array.Copy(data, offs, buff, dest, fldSize);
1392                                         offs += fldSize;
1393                                         dest += 4;
1394
1395                                 }
1396
1397                                 tab.FromRawData(buff, 0, nRows);
1398                         }
1399
1400                         if (heap.HasENCLog) {
1401                                 rowSize = sizeof (uint) + sizeof (uint);
1402                                 nRows = rows [(int) TableId.ENCLog];
1403                                 AllocBuff(ref buff, rowSize * nRows);
1404                                 dest = 0;
1405
1406                                 MDTable tab = new ENCLogTable(heap);
1407
1408                                 for (int i = nRows; --i >= 0;) {
1409
1410                                         // Token, uint
1411                                         fldSize = sizeof (uint);
1412                                         Array.Copy(data, offs, buff, dest, fldSize);
1413                                         offs += fldSize;
1414                                         dest += sizeof (uint);
1415
1416                                         // FuncCode, uint
1417                                         fldSize = sizeof (uint);
1418                                         Array.Copy(data, offs, buff, dest, fldSize);
1419                                         offs += fldSize;
1420                                         dest += sizeof (uint);
1421
1422                                 }
1423
1424                                 tab.FromRawData(buff, 0, nRows);
1425                         }
1426
1427                         if (heap.HasENCMap) {
1428                                 rowSize = sizeof (uint);
1429                                 nRows = rows [(int) TableId.ENCMap];
1430                                 AllocBuff(ref buff, rowSize * nRows);
1431                                 dest = 0;
1432
1433                                 MDTable tab = new ENCMapTable(heap);
1434
1435                                 for (int i = nRows; --i >= 0;) {
1436
1437                                         // Token, uint
1438                                         fldSize = sizeof (uint);
1439                                         Array.Copy(data, offs, buff, dest, fldSize);
1440                                         offs += fldSize;
1441                                         dest += sizeof (uint);
1442
1443                                 }
1444
1445                                 tab.FromRawData(buff, 0, nRows);
1446                         }
1447
1448                         if (heap.HasAssembly) {
1449                                 rowSize = sizeof (int) + sizeof (short) + sizeof (short) + sizeof (short) + sizeof (short) + sizeof (uint) + 4 + 4 + 4;
1450                                 nRows = rows [(int) TableId.Assembly];
1451                                 AllocBuff(ref buff, rowSize * nRows);
1452                                 dest = 0;
1453
1454                                 MDTable tab = new AssemblyTable(heap);
1455
1456                                 for (int i = nRows; --i >= 0;) {
1457
1458                                         // HashAlgId, int
1459                                         fldSize = sizeof (int);
1460                                         Array.Copy(data, offs, buff, dest, fldSize);
1461                                         offs += fldSize;
1462                                         dest += sizeof (int);
1463
1464                                         // MajorVersion, short
1465                                         fldSize = sizeof (short);
1466                                         Array.Copy(data, offs, buff, dest, fldSize);
1467                                         offs += fldSize;
1468                                         dest += sizeof (short);
1469
1470                                         // MinorVersion, short
1471                                         fldSize = sizeof (short);
1472                                         Array.Copy(data, offs, buff, dest, fldSize);
1473                                         offs += fldSize;
1474                                         dest += sizeof (short);
1475
1476                                         // BuildNumber, short
1477                                         fldSize = sizeof (short);
1478                                         Array.Copy(data, offs, buff, dest, fldSize);
1479                                         offs += fldSize;
1480                                         dest += sizeof (short);
1481
1482                                         // RevisionNumber, short
1483                                         fldSize = sizeof (short);
1484                                         Array.Copy(data, offs, buff, dest, fldSize);
1485                                         offs += fldSize;
1486                                         dest += sizeof (short);
1487
1488                                         // Flags, uint
1489                                         fldSize = sizeof (uint);
1490                                         Array.Copy(data, offs, buff, dest, fldSize);
1491                                         offs += fldSize;
1492                                         dest += sizeof (uint);
1493
1494                                         // PublicKey, index(#Blob)
1495                                         fldSize = bi;
1496                                         Array.Copy(data, offs, buff, dest, fldSize);
1497                                         offs += fldSize;
1498                                         dest += 4;
1499
1500                                         // Name, index(#Strings)
1501                                         fldSize = si;
1502                                         Array.Copy(data, offs, buff, dest, fldSize);
1503                                         offs += fldSize;
1504                                         dest += 4;
1505
1506                                         // Culture, index(#Strings)
1507                                         fldSize = si;
1508                                         Array.Copy(data, offs, buff, dest, fldSize);
1509                                         offs += fldSize;
1510                                         dest += 4;
1511
1512                                 }
1513
1514                                 tab.FromRawData(buff, 0, nRows);
1515                         }
1516
1517                         if (heap.HasAssemblyProcessor) {
1518                                 rowSize = sizeof (int);
1519                                 nRows = rows [(int) TableId.AssemblyProcessor];
1520                                 AllocBuff(ref buff, rowSize * nRows);
1521                                 dest = 0;
1522
1523                                 MDTable tab = new AssemblyProcessorTable(heap);
1524
1525                                 for (int i = nRows; --i >= 0;) {
1526
1527                                         // Processor, int
1528                                         fldSize = sizeof (int);
1529                                         Array.Copy(data, offs, buff, dest, fldSize);
1530                                         offs += fldSize;
1531                                         dest += sizeof (int);
1532
1533                                 }
1534
1535                                 tab.FromRawData(buff, 0, nRows);
1536                         }
1537
1538                         if (heap.HasAssemblyOS) {
1539                                 rowSize = sizeof (int) + sizeof (int) + sizeof (int);
1540                                 nRows = rows [(int) TableId.AssemblyOS];
1541                                 AllocBuff(ref buff, rowSize * nRows);
1542                                 dest = 0;
1543
1544                                 MDTable tab = new AssemblyOSTable(heap);
1545
1546                                 for (int i = nRows; --i >= 0;) {
1547
1548                                         // OSPlatformID, int
1549                                         fldSize = sizeof (int);
1550                                         Array.Copy(data, offs, buff, dest, fldSize);
1551                                         offs += fldSize;
1552                                         dest += sizeof (int);
1553
1554                                         // OSMajorVersion, int
1555                                         fldSize = sizeof (int);
1556                                         Array.Copy(data, offs, buff, dest, fldSize);
1557                                         offs += fldSize;
1558                                         dest += sizeof (int);
1559
1560                                         // OSMinorVersion, int
1561                                         fldSize = sizeof (int);
1562                                         Array.Copy(data, offs, buff, dest, fldSize);
1563                                         offs += fldSize;
1564                                         dest += sizeof (int);
1565
1566                                 }
1567
1568                                 tab.FromRawData(buff, 0, nRows);
1569                         }
1570
1571                         if (heap.HasAssemblyRef) {
1572                                 rowSize = sizeof (short) + sizeof (short) + sizeof (short) + sizeof (short) + sizeof (uint) + 4 + 4 + 4 + 4;
1573                                 nRows = rows [(int) TableId.AssemblyRef];
1574                                 AllocBuff(ref buff, rowSize * nRows);
1575                                 dest = 0;
1576
1577                                 MDTable tab = new AssemblyRefTable(heap);
1578
1579                                 for (int i = nRows; --i >= 0;) {
1580
1581                                         // MajorVersion, short
1582                                         fldSize = sizeof (short);
1583                                         Array.Copy(data, offs, buff, dest, fldSize);
1584                                         offs += fldSize;
1585                                         dest += sizeof (short);
1586
1587                                         // MinorVersion, short
1588                                         fldSize = sizeof (short);
1589                                         Array.Copy(data, offs, buff, dest, fldSize);
1590                                         offs += fldSize;
1591                                         dest += sizeof (short);
1592
1593                                         // BuildNumber, short
1594                                         fldSize = sizeof (short);
1595                                         Array.Copy(data, offs, buff, dest, fldSize);
1596                                         offs += fldSize;
1597                                         dest += sizeof (short);
1598
1599                                         // RevisionNumber, short
1600                                         fldSize = sizeof (short);
1601                                         Array.Copy(data, offs, buff, dest, fldSize);
1602                                         offs += fldSize;
1603                                         dest += sizeof (short);
1604
1605                                         // Flags, uint
1606                                         fldSize = sizeof (uint);
1607                                         Array.Copy(data, offs, buff, dest, fldSize);
1608                                         offs += fldSize;
1609                                         dest += sizeof (uint);
1610
1611                                         // PublicKeyOrToken, index(#Blob)
1612                                         fldSize = bi;
1613                                         Array.Copy(data, offs, buff, dest, fldSize);
1614                                         offs += fldSize;
1615                                         dest += 4;
1616
1617                                         // Name, index(#Strings)
1618                                         fldSize = si;
1619                                         Array.Copy(data, offs, buff, dest, fldSize);
1620                                         offs += fldSize;
1621                                         dest += 4;
1622
1623                                         // Culture, index(#Strings)
1624                                         fldSize = si;
1625                                         Array.Copy(data, offs, buff, dest, fldSize);
1626                                         offs += fldSize;
1627                                         dest += 4;
1628
1629                                         // HashValue, index(#Blob)
1630                                         fldSize = bi;
1631                                         Array.Copy(data, offs, buff, dest, fldSize);
1632                                         offs += fldSize;
1633                                         dest += 4;
1634
1635                                 }
1636
1637                                 tab.FromRawData(buff, 0, nRows);
1638                         }
1639
1640                         if (heap.HasAssemblyRefProcessor) {
1641                                 rowSize = sizeof (int) + 4;
1642                                 nRows = rows [(int) TableId.AssemblyRefProcessor];
1643                                 AllocBuff(ref buff, rowSize * nRows);
1644                                 dest = 0;
1645
1646                                 MDTable tab = new AssemblyRefProcessorTable(heap);
1647
1648                                 for (int i = nRows; --i >= 0;) {
1649
1650                                         // Processor, int
1651                                         fldSize = sizeof (int);
1652                                         Array.Copy(data, offs, buff, dest, fldSize);
1653                                         offs += fldSize;
1654                                         dest += sizeof (int);
1655
1656                                         // AssemblyRef, index(AssemblyRef)
1657                                         fldSize = GetIndexSize(TableId.AssemblyRef, rows);
1658                                         Array.Copy(data, offs, buff, dest, fldSize);
1659                                         offs += fldSize;
1660                                         dest += 4;
1661
1662                                 }
1663
1664                                 tab.FromRawData(buff, 0, nRows);
1665                         }
1666
1667                         if (heap.HasAssemblyRefOS) {
1668                                 rowSize = sizeof (int) + sizeof (int) + sizeof (int) + 4;
1669                                 nRows = rows [(int) TableId.AssemblyRefOS];
1670                                 AllocBuff(ref buff, rowSize * nRows);
1671                                 dest = 0;
1672
1673                                 MDTable tab = new AssemblyRefOSTable(heap);
1674
1675                                 for (int i = nRows; --i >= 0;) {
1676
1677                                         // OSPlatformID, int
1678                                         fldSize = sizeof (int);
1679                                         Array.Copy(data, offs, buff, dest, fldSize);
1680                                         offs += fldSize;
1681                                         dest += sizeof (int);
1682
1683                                         // OSMajorVersion, int
1684                                         fldSize = sizeof (int);
1685                                         Array.Copy(data, offs, buff, dest, fldSize);
1686                                         offs += fldSize;
1687                                         dest += sizeof (int);
1688
1689                                         // OSMinorVersion, int
1690                                         fldSize = sizeof (int);
1691                                         Array.Copy(data, offs, buff, dest, fldSize);
1692                                         offs += fldSize;
1693                                         dest += sizeof (int);
1694
1695                                         // AssemblyRef, index(AssemblyRef)
1696                                         fldSize = GetIndexSize(TableId.AssemblyRef, rows);
1697                                         Array.Copy(data, offs, buff, dest, fldSize);
1698                                         offs += fldSize;
1699                                         dest += 4;
1700
1701                                 }
1702
1703                                 tab.FromRawData(buff, 0, nRows);
1704                         }
1705
1706                         if (heap.HasFile) {
1707                                 rowSize = sizeof (uint) + 4 + 4;
1708                                 nRows = rows [(int) TableId.File];
1709                                 AllocBuff(ref buff, rowSize * nRows);
1710                                 dest = 0;
1711
1712                                 MDTable tab = new FileTable(heap);
1713
1714                                 for (int i = nRows; --i >= 0;) {
1715
1716                                         // Flags, uint
1717                                         fldSize = sizeof (uint);
1718                                         Array.Copy(data, offs, buff, dest, fldSize);
1719                                         offs += fldSize;
1720                                         dest += sizeof (uint);
1721
1722                                         // Name, index(#Strings)
1723                                         fldSize = si;
1724                                         Array.Copy(data, offs, buff, dest, fldSize);
1725                                         offs += fldSize;
1726                                         dest += 4;
1727
1728                                         // HashValue, index(#Blob)
1729                                         fldSize = bi;
1730                                         Array.Copy(data, offs, buff, dest, fldSize);
1731                                         offs += fldSize;
1732                                         dest += 4;
1733
1734                                 }
1735
1736                                 tab.FromRawData(buff, 0, nRows);
1737                         }
1738
1739                         if (heap.HasExportedType) {
1740                                 rowSize = sizeof (uint) + 4 + 4 + 4 + 4;
1741                                 nRows = rows [(int) TableId.ExportedType];
1742                                 AllocBuff(ref buff, rowSize * nRows);
1743                                 dest = 0;
1744
1745                                 MDTable tab = new ExportedTypeTable(heap);
1746
1747                                 for (int i = nRows; --i >= 0;) {
1748
1749                                         // Flags, uint
1750                                         fldSize = sizeof (uint);
1751                                         Array.Copy(data, offs, buff, dest, fldSize);
1752                                         offs += fldSize;
1753                                         dest += sizeof (uint);
1754
1755                                         // TypeDefId, index(TypeDef)
1756                                         fldSize = GetIndexSize(TableId.TypeDef, rows);
1757                                         Array.Copy(data, offs, buff, dest, fldSize);
1758                                         offs += fldSize;
1759                                         dest += 4;
1760
1761                                         // TypeName, index(#Strings)
1762                                         fldSize = si;
1763                                         Array.Copy(data, offs, buff, dest, fldSize);
1764                                         offs += fldSize;
1765                                         dest += 4;
1766
1767                                         // TypeNamespace, index(#Strings)
1768                                         fldSize = si;
1769                                         Array.Copy(data, offs, buff, dest, fldSize);
1770                                         offs += fldSize;
1771                                         dest += 4;
1772
1773                                         // Implementation, coded-index(Implementation)
1774                                         fldSize = GetCodedIndexSize(heap, CodedTokenId.Implementation, rows);
1775                                         Array.Copy(data, offs, buff, dest, fldSize);
1776                                         offs += fldSize;
1777                                         dest += 4;
1778
1779                                 }
1780
1781                                 tab.FromRawData(buff, 0, nRows);
1782                         }
1783
1784                         if (heap.HasManifestResource) {
1785                                 rowSize = sizeof (int) + sizeof (uint) + 4 + 4;
1786                                 nRows = rows [(int) TableId.ManifestResource];
1787                                 AllocBuff(ref buff, rowSize * nRows);
1788                                 dest = 0;
1789
1790                                 MDTable tab = new ManifestResourceTable(heap);
1791
1792                                 for (int i = nRows; --i >= 0;) {
1793
1794                                         // Offset, int
1795                                         fldSize = sizeof (int);
1796                                         Array.Copy(data, offs, buff, dest, fldSize);
1797                                         offs += fldSize;
1798                                         dest += sizeof (int);
1799
1800                                         // Flags, uint
1801                                         fldSize = sizeof (uint);
1802                                         Array.Copy(data, offs, buff, dest, fldSize);
1803                                         offs += fldSize;
1804                                         dest += sizeof (uint);
1805
1806                                         // Name, index(#Strings)
1807                                         fldSize = si;
1808                                         Array.Copy(data, offs, buff, dest, fldSize);
1809                                         offs += fldSize;
1810                                         dest += 4;
1811
1812                                         // Implementation, coded-index(Implementation)
1813                                         fldSize = GetCodedIndexSize(heap, CodedTokenId.Implementation, rows);
1814                                         Array.Copy(data, offs, buff, dest, fldSize);
1815                                         offs += fldSize;
1816                                         dest += 4;
1817
1818                                 }
1819
1820                                 tab.FromRawData(buff, 0, nRows);
1821                         }
1822
1823                         if (heap.HasNestedClass) {
1824                                 rowSize = 4 + 4;
1825                                 nRows = rows [(int) TableId.NestedClass];
1826                                 AllocBuff(ref buff, rowSize * nRows);
1827                                 dest = 0;
1828
1829                                 MDTable tab = new NestedClassTable(heap);
1830
1831                                 for (int i = nRows; --i >= 0;) {
1832
1833                                         // NestedClass, index(TypeDef)
1834                                         fldSize = GetIndexSize(TableId.TypeDef, rows);
1835                                         Array.Copy(data, offs, buff, dest, fldSize);
1836                                         offs += fldSize;
1837                                         dest += 4;
1838
1839                                         // EnclosingClass, index(TypeDef)
1840                                         fldSize = GetIndexSize(TableId.TypeDef, rows);
1841                                         Array.Copy(data, offs, buff, dest, fldSize);
1842                                         offs += fldSize;
1843                                         dest += 4;
1844
1845                                 }
1846
1847                                 tab.FromRawData(buff, 0, nRows);
1848                         }
1849
1850                         if (heap.HasTypeTyPar) {
1851                                 rowSize = sizeof (ushort) + 4 + 4 + 4;
1852                                 nRows = rows [(int) TableId.TypeTyPar];
1853                                 AllocBuff(ref buff, rowSize * nRows);
1854                                 dest = 0;
1855
1856                                 MDTable tab = new TypeTyParTable(heap);
1857
1858                                 for (int i = nRows; --i >= 0;) {
1859
1860                                         // Number, ushort
1861                                         fldSize = sizeof (ushort);
1862                                         Array.Copy(data, offs, buff, dest, fldSize);
1863                                         offs += fldSize;
1864                                         dest += sizeof (ushort);
1865
1866                                         // Class, index(TypeDef)
1867                                         fldSize = GetIndexSize(TableId.TypeDef, rows);
1868                                         Array.Copy(data, offs, buff, dest, fldSize);
1869                                         offs += fldSize;
1870                                         dest += 4;
1871
1872                                         // Bound, coded-index(TypeDefOrRef)
1873                                         fldSize = GetCodedIndexSize(heap, CodedTokenId.TypeDefOrRef, rows);
1874                                         Array.Copy(data, offs, buff, dest, fldSize);
1875                                         offs += fldSize;
1876                                         dest += 4;
1877
1878                                         // Name, index(#Strings)
1879                                         fldSize = si;
1880                                         Array.Copy(data, offs, buff, dest, fldSize);
1881                                         offs += fldSize;
1882                                         dest += 4;
1883
1884                                 }
1885
1886                                 tab.FromRawData(buff, 0, nRows);
1887                         }
1888
1889                         if (heap.HasMethodTyPar) {
1890                                 rowSize = sizeof (ushort) + 4 + 4 + 4;
1891                                 nRows = rows [(int) TableId.MethodTyPar];
1892                                 AllocBuff(ref buff, rowSize * nRows);
1893                                 dest = 0;
1894
1895                                 MDTable tab = new MethodTyParTable(heap);
1896
1897                                 for (int i = nRows; --i >= 0;) {
1898
1899                                         // Number, ushort
1900                                         fldSize = sizeof (ushort);
1901                                         Array.Copy(data, offs, buff, dest, fldSize);
1902                                         offs += fldSize;
1903                                         dest += sizeof (ushort);
1904
1905                                         // Method, index(Method)
1906                                         fldSize = GetIndexSize(TableId.Method, rows);
1907                                         Array.Copy(data, offs, buff, dest, fldSize);
1908                                         offs += fldSize;
1909                                         dest += 4;
1910
1911                                         // Bound, coded-index(TypeDefOrRef)
1912                                         fldSize = GetCodedIndexSize(heap, CodedTokenId.TypeDefOrRef, rows);
1913                                         Array.Copy(data, offs, buff, dest, fldSize);
1914                                         offs += fldSize;
1915                                         dest += 4;
1916
1917                                         // Name, index(#Strings)
1918                                         fldSize = si;
1919                                         Array.Copy(data, offs, buff, dest, fldSize);
1920                                         offs += fldSize;
1921                                         dest += 4;
1922
1923                                 }
1924
1925                                 tab.FromRawData(buff, 0, nRows);
1926                         }
1927
1928                         return offs;
1929                 }
1930
1931         } // end class
1932 } // end namespace
1933