mcs/tools/cil-strip/Mono.Cecil.Metadata/MetadataTableReader.cs

   1 //
   2 // MetadataTableReader.cs
   3 //
   4 // Author:
   5 //   Jb Evain (jbevain@gmail.com)
   6 //
   7 // Generated by /CodeGen/cecil-gen.rb do not edit
   8 // Tue Jul 17 00:22:32 +0200 2007
   9 //
  10 // (C) 2005 Jb Evain
  11 //
  12 // Permission is hereby granted, free of charge, to any person obtaining
  13 // a copy of this software and associated documentation files (the
  14 // "Software"), to deal in the Software without restriction, including
  15 // without limitation the rights to use, copy, modify, merge, publish,
  16 // distribute, sublicense, and/or sell copies of the Software, and to
  17 // permit persons to whom the Software is furnished to do so, subject to
  18 // the following conditions:
  19 //
  20 // The above copyright notice and this permission notice shall be
  21 // included in all copies or substantial portions of the Software.
  22 //
  23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  27 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  28 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  29 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  30 //
  31
  32 namespace Mono.Cecil.Metadata {
  33
  34         using System;
  35         using System.Collections;
  36         using System.IO;
  37
  38         sealed class MetadataTableReader : BaseMetadataTableVisitor {
  39
  40                 MetadataRoot m_metadataRoot;
  41                 TablesHeap m_heap;
  42                 MetadataRowReader m_mrrv;
  43                 BinaryReader m_binaryReader;
  44
  45                 int [] m_rows = new int [TablesHeap.MaxTableCount];
  46
  47                 public MetadataTableReader (MetadataReader mrv)
  48                 {
  49                         m_metadataRoot = mrv.GetMetadataRoot ();
  50                         m_heap = m_metadataRoot.Streams.TablesHeap;
  51                         m_binaryReader = new BinaryReader (new MemoryStream (m_heap.Data));
  52                         m_binaryReader.BaseStream.Position = 24;
  53                         m_mrrv = new MetadataRowReader (this);
  54                 }
  55
  56                 public MetadataRoot GetMetadataRoot ()
  57                 {
  58                         return m_metadataRoot;
  59                 }
  60
  61                 public BinaryReader GetReader ()
  62                 {
  63                         return m_binaryReader;
  64                 }
  65
  66                 public override IMetadataRowVisitor GetRowVisitor ()
  67                 {
  68                         return m_mrrv;
  69                 }
  70
  71                 public int GetNumberOfRows (int rid)
  72                 {
  73                         return m_rows [rid];
  74                 }
  75
  76                 public AssemblyTable GetAssemblyTable ()
  77                 {
  78                         return (AssemblyTable) m_heap [AssemblyTable.RId];
  79                 }
  80
  81                 public AssemblyOSTable GetAssemblyOSTable ()
  82                 {
  83                         return (AssemblyOSTable) m_heap [AssemblyOSTable.RId];
  84                 }
  85
  86                 public AssemblyProcessorTable GetAssemblyProcessorTable ()
  87                 {
  88                         return (AssemblyProcessorTable) m_heap [AssemblyProcessorTable.RId];
  89                 }
  90
  91                 public AssemblyRefTable GetAssemblyRefTable ()
  92                 {
  93                         return (AssemblyRefTable) m_heap [AssemblyRefTable.RId];
  94                 }
  95
  96                 public AssemblyRefOSTable GetAssemblyRefOSTable ()
  97                 {
  98                         return (AssemblyRefOSTable) m_heap [AssemblyRefOSTable.RId];
  99                 }
 100
 101                 public AssemblyRefProcessorTable GetAssemblyRefProcessorTable ()
 102                 {
 103                         return (AssemblyRefProcessorTable) m_heap [AssemblyRefProcessorTable.RId];
 104                 }
 105
 106                 public ClassLayoutTable GetClassLayoutTable ()
 107                 {
 108                         return (ClassLayoutTable) m_heap [ClassLayoutTable.RId];
 109                 }
 110
 111                 public ConstantTable GetConstantTable ()
 112                 {
 113                         return (ConstantTable) m_heap [ConstantTable.RId];
 114                 }
 115
 116                 public CustomAttributeTable GetCustomAttributeTable ()
 117                 {
 118                         return (CustomAttributeTable) m_heap [CustomAttributeTable.RId];
 119                 }
 120
 121                 public DeclSecurityTable GetDeclSecurityTable ()
 122                 {
 123                         return (DeclSecurityTable) m_heap [DeclSecurityTable.RId];
 124                 }
 125
 126                 public EventTable GetEventTable ()
 127                 {
 128                         return (EventTable) m_heap [EventTable.RId];
 129                 }
 130
 131                 public EventMapTable GetEventMapTable ()
 132                 {
 133                         return (EventMapTable) m_heap [EventMapTable.RId];
 134                 }
 135
 136                 public EventPtrTable GetEventPtrTable ()
 137                 {
 138                         return (EventPtrTable) m_heap [EventPtrTable.RId];
 139                 }
 140
 141                 public ExportedTypeTable GetExportedTypeTable ()
 142                 {
 143                         return (ExportedTypeTable) m_heap [ExportedTypeTable.RId];
 144                 }
 145
 146                 public FieldTable GetFieldTable ()
 147                 {
 148                         return (FieldTable) m_heap [FieldTable.RId];
 149                 }
 150
 151                 public FieldLayoutTable GetFieldLayoutTable ()
 152                 {
 153                         return (FieldLayoutTable) m_heap [FieldLayoutTable.RId];
 154                 }
 155
 156                 public FieldMarshalTable GetFieldMarshalTable ()
 157                 {
 158                         return (FieldMarshalTable) m_heap [FieldMarshalTable.RId];
 159                 }
 160
 161                 public FieldPtrTable GetFieldPtrTable ()
 162                 {
 163                         return (FieldPtrTable) m_heap [FieldPtrTable.RId];
 164                 }
 165
 166                 public FieldRVATable GetFieldRVATable ()
 167                 {
 168                         return (FieldRVATable) m_heap [FieldRVATable.RId];
 169                 }
 170
 171                 public FileTable GetFileTable ()
 172                 {
 173                         return (FileTable) m_heap [FileTable.RId];
 174                 }
 175
 176                 public GenericParamTable GetGenericParamTable ()
 177                 {
 178                         return (GenericParamTable) m_heap [GenericParamTable.RId];
 179                 }
 180
 181                 public GenericParamConstraintTable GetGenericParamConstraintTable ()
 182                 {
 183                         return (GenericParamConstraintTable) m_heap [GenericParamConstraintTable.RId];
 184                 }
 185
 186                 public ImplMapTable GetImplMapTable ()
 187                 {
 188                         return (ImplMapTable) m_heap [ImplMapTable.RId];
 189                 }
 190
 191                 public InterfaceImplTable GetInterfaceImplTable ()
 192                 {
 193                         return (InterfaceImplTable) m_heap [InterfaceImplTable.RId];
 194                 }
 195
 196                 public ManifestResourceTable GetManifestResourceTable ()
 197                 {
 198                         return (ManifestResourceTable) m_heap [ManifestResourceTable.RId];
 199                 }
 200
 201                 public MemberRefTable GetMemberRefTable ()
 202                 {
 203                         return (MemberRefTable) m_heap [MemberRefTable.RId];
 204                 }
 205
 206                 public MethodTable GetMethodTable ()
 207                 {
 208                         return (MethodTable) m_heap [MethodTable.RId];
 209                 }
 210
 211                 public MethodImplTable GetMethodImplTable ()
 212                 {
 213                         return (MethodImplTable) m_heap [MethodImplTable.RId];
 214                 }
 215
 216                 public MethodPtrTable GetMethodPtrTable ()
 217                 {
 218                         return (MethodPtrTable) m_heap [MethodPtrTable.RId];
 219                 }
 220
 221                 public MethodSemanticsTable GetMethodSemanticsTable ()
 222                 {
 223                         return (MethodSemanticsTable) m_heap [MethodSemanticsTable.RId];
 224                 }
 225
 226                 public MethodSpecTable GetMethodSpecTable ()
 227                 {
 228                         return (MethodSpecTable) m_heap [MethodSpecTable.RId];
 229                 }
 230
 231                 public ModuleTable GetModuleTable ()
 232                 {
 233                         return (ModuleTable) m_heap [ModuleTable.RId];
 234                 }
 235
 236                 public ModuleRefTable GetModuleRefTable ()
 237                 {
 238                         return (ModuleRefTable) m_heap [ModuleRefTable.RId];
 239                 }
 240
 241                 public NestedClassTable GetNestedClassTable ()
 242                 {
 243                         return (NestedClassTable) m_heap [NestedClassTable.RId];
 244                 }
 245
 246                 public ParamTable GetParamTable ()
 247                 {
 248                         return (ParamTable) m_heap [ParamTable.RId];
 249                 }
 250
 251                 public ParamPtrTable GetParamPtrTable ()
 252                 {
 253                         return (ParamPtrTable) m_heap [ParamPtrTable.RId];
 254                 }
 255
 256                 public PropertyTable GetPropertyTable ()
 257                 {
 258                         return (PropertyTable) m_heap [PropertyTable.RId];
 259                 }
 260
 261                 public PropertyMapTable GetPropertyMapTable ()
 262                 {
 263                         return (PropertyMapTable) m_heap [PropertyMapTable.RId];
 264                 }
 265
 266                 public PropertyPtrTable GetPropertyPtrTable ()
 267                 {
 268                         return (PropertyPtrTable) m_heap [PropertyPtrTable.RId];
 269                 }
 270
 271                 public StandAloneSigTable GetStandAloneSigTable ()
 272                 {
 273                         return (StandAloneSigTable) m_heap [StandAloneSigTable.RId];
 274                 }
 275
 276                 public TypeDefTable GetTypeDefTable ()
 277                 {
 278                         return (TypeDefTable) m_heap [TypeDefTable.RId];
 279                 }
 280
 281                 public TypeRefTable GetTypeRefTable ()
 282                 {
 283                         return (TypeRefTable) m_heap [TypeRefTable.RId];
 284                 }
 285
 286                 public TypeSpecTable GetTypeSpecTable ()
 287                 {
 288                         return (TypeSpecTable) m_heap [TypeSpecTable.RId];
 289                 }
 290
 291                 public override void VisitTableCollection (TableCollection coll)
 292                 {
 293                         if (m_heap.HasTable (ModuleTable.RId)) {
 294                                 coll.Add (new ModuleTable ());
 295                                 m_rows [ModuleTable.RId] = m_binaryReader.ReadInt32 ();
 296                         }
 297                         if (m_heap.HasTable (TypeRefTable.RId)) {
 298                                 coll.Add (new TypeRefTable ());
 299                                 m_rows [TypeRefTable.RId] = m_binaryReader.ReadInt32 ();
 300                         }
 301                         if (m_heap.HasTable (TypeDefTable.RId)) {
 302                                 coll.Add (new TypeDefTable ());
 303                                 m_rows [TypeDefTable.RId] = m_binaryReader.ReadInt32 ();
 304                         }
 305                         if (m_heap.HasTable (FieldPtrTable.RId)) {
 306                                 coll.Add (new FieldPtrTable ());
 307                                 m_rows [FieldPtrTable.RId] = m_binaryReader.ReadInt32 ();
 308                         }
 309                         if (m_heap.HasTable (FieldTable.RId)) {
 310                                 coll.Add (new FieldTable ());
 311                                 m_rows [FieldTable.RId] = m_binaryReader.ReadInt32 ();
 312                         }
 313                         if (m_heap.HasTable (MethodPtrTable.RId)) {
 314                                 coll.Add (new MethodPtrTable ());
 315                                 m_rows [MethodPtrTable.RId] = m_binaryReader.ReadInt32 ();
 316                         }
 317                         if (m_heap.HasTable (MethodTable.RId)) {
 318                                 coll.Add (new MethodTable ());
 319                                 m_rows [MethodTable.RId] = m_binaryReader.ReadInt32 ();
 320                         }
 321                         if (m_heap.HasTable (ParamPtrTable.RId)) {
 322                                 coll.Add (new ParamPtrTable ());
 323                                 m_rows [ParamPtrTable.RId] = m_binaryReader.ReadInt32 ();
 324                         }
 325                         if (m_heap.HasTable (ParamTable.RId)) {
 326                                 coll.Add (new ParamTable ());
 327                                 m_rows [ParamTable.RId] = m_binaryReader.ReadInt32 ();
 328                         }
 329                         if (m_heap.HasTable (InterfaceImplTable.RId)) {
 330                                 coll.Add (new InterfaceImplTable ());
 331                                 m_rows [InterfaceImplTable.RId] = m_binaryReader.ReadInt32 ();
 332                         }
 333                         if (m_heap.HasTable (MemberRefTable.RId)) {
 334                                 coll.Add (new MemberRefTable ());
 335                                 m_rows [MemberRefTable.RId] = m_binaryReader.ReadInt32 ();
 336                         }
 337                         if (m_heap.HasTable (ConstantTable.RId)) {
 338                                 coll.Add (new ConstantTable ());
 339                                 m_rows [ConstantTable.RId] = m_binaryReader.ReadInt32 ();
 340                         }
 341                         if (m_heap.HasTable (CustomAttributeTable.RId)) {
 342                                 coll.Add (new CustomAttributeTable ());
 343                                 m_rows [CustomAttributeTable.RId] = m_binaryReader.ReadInt32 ();
 344                         }
 345                         if (m_heap.HasTable (FieldMarshalTable.RId)) {
 346                                 coll.Add (new FieldMarshalTable ());
 347                                 m_rows [FieldMarshalTable.RId] = m_binaryReader.ReadInt32 ();
 348                         }
 349                         if (m_heap.HasTable (DeclSecurityTable.RId)) {
 350                                 coll.Add (new DeclSecurityTable ());
 351                                 m_rows [DeclSecurityTable.RId] = m_binaryReader.ReadInt32 ();
 352                         }
 353                         if (m_heap.HasTable (ClassLayoutTable.RId)) {
 354                                 coll.Add (new ClassLayoutTable ());
 355                                 m_rows [ClassLayoutTable.RId] = m_binaryReader.ReadInt32 ();
 356                         }
 357                         if (m_heap.HasTable (FieldLayoutTable.RId)) {
 358                                 coll.Add (new FieldLayoutTable ());
 359                                 m_rows [FieldLayoutTable.RId] = m_binaryReader.ReadInt32 ();
 360                         }
 361                         if (m_heap.HasTable (StandAloneSigTable.RId)) {
 362                                 coll.Add (new StandAloneSigTable ());
 363                                 m_rows [StandAloneSigTable.RId] = m_binaryReader.ReadInt32 ();
 364                         }
 365                         if (m_heap.HasTable (EventMapTable.RId)) {
 366                                 coll.Add (new EventMapTable ());
 367                                 m_rows [EventMapTable.RId] = m_binaryReader.ReadInt32 ();
 368                         }
 369                         if (m_heap.HasTable (EventPtrTable.RId)) {
 370                                 coll.Add (new EventPtrTable ());
 371                                 m_rows [EventPtrTable.RId] = m_binaryReader.ReadInt32 ();
 372                         }
 373                         if (m_heap.HasTable (EventTable.RId)) {
 374                                 coll.Add (new EventTable ());
 375                                 m_rows [EventTable.RId] = m_binaryReader.ReadInt32 ();
 376                         }
 377                         if (m_heap.HasTable (PropertyMapTable.RId)) {
 378                                 coll.Add (new PropertyMapTable ());
 379                                 m_rows [PropertyMapTable.RId] = m_binaryReader.ReadInt32 ();
 380                         }
 381                         if (m_heap.HasTable (PropertyPtrTable.RId)) {
 382                                 coll.Add (new PropertyPtrTable ());
 383                                 m_rows [PropertyPtrTable.RId] = m_binaryReader.ReadInt32 ();
 384                         }
 385                         if (m_heap.HasTable (PropertyTable.RId)) {
 386                                 coll.Add (new PropertyTable ());
 387                                 m_rows [PropertyTable.RId] = m_binaryReader.ReadInt32 ();
 388                         }
 389                         if (m_heap.HasTable (MethodSemanticsTable.RId)) {
 390                                 coll.Add (new MethodSemanticsTable ());
 391                                 m_rows [MethodSemanticsTable.RId] = m_binaryReader.ReadInt32 ();
 392                         }
 393                         if (m_heap.HasTable (MethodImplTable.RId)) {
 394                                 coll.Add (new MethodImplTable ());
 395                                 m_rows [MethodImplTable.RId] = m_binaryReader.ReadInt32 ();
 396                         }
 397                         if (m_heap.HasTable (ModuleRefTable.RId)) {
 398                                 coll.Add (new ModuleRefTable ());
 399                                 m_rows [ModuleRefTable.RId] = m_binaryReader.ReadInt32 ();
 400                         }
 401                         if (m_heap.HasTable (TypeSpecTable.RId)) {
 402                                 coll.Add (new TypeSpecTable ());
 403                                 m_rows [TypeSpecTable.RId] = m_binaryReader.ReadInt32 ();
 404                         }
 405                         if (m_heap.HasTable (ImplMapTable.RId)) {
 406                                 coll.Add (new ImplMapTable ());
 407                                 m_rows [ImplMapTable.RId] = m_binaryReader.ReadInt32 ();
 408                         }
 409                         if (m_heap.HasTable (FieldRVATable.RId)) {
 410                                 coll.Add (new FieldRVATable ());
 411                                 m_rows [FieldRVATable.RId] = m_binaryReader.ReadInt32 ();
 412                         }
 413                         if (m_heap.HasTable (AssemblyTable.RId)) {
 414                                 coll.Add (new AssemblyTable ());
 415                                 m_rows [AssemblyTable.RId] = m_binaryReader.ReadInt32 ();
 416                         }
 417                         if (m_heap.HasTable (AssemblyProcessorTable.RId)) {
 418                                 coll.Add (new AssemblyProcessorTable ());
 419                                 m_rows [AssemblyProcessorTable.RId] = m_binaryReader.ReadInt32 ();
 420                         }
 421                         if (m_heap.HasTable (AssemblyOSTable.RId)) {
 422                                 coll.Add (new AssemblyOSTable ());
 423                                 m_rows [AssemblyOSTable.RId] = m_binaryReader.ReadInt32 ();
 424                         }
 425                         if (m_heap.HasTable (AssemblyRefTable.RId)) {
 426                                 coll.Add (new AssemblyRefTable ());
 427                                 m_rows [AssemblyRefTable.RId] = m_binaryReader.ReadInt32 ();
 428                         }
 429                         if (m_heap.HasTable (AssemblyRefProcessorTable.RId)) {
 430                                 coll.Add (new AssemblyRefProcessorTable ());
 431                                 m_rows [AssemblyRefProcessorTable.RId] = m_binaryReader.ReadInt32 ();
 432                         }
 433                         if (m_heap.HasTable (AssemblyRefOSTable.RId)) {
 434                                 coll.Add (new AssemblyRefOSTable ());
 435                                 m_rows [AssemblyRefOSTable.RId] = m_binaryReader.ReadInt32 ();
 436                         }
 437                         if (m_heap.HasTable (FileTable.RId)) {
 438                                 coll.Add (new FileTable ());
 439                                 m_rows [FileTable.RId] = m_binaryReader.ReadInt32 ();
 440                         }
 441                         if (m_heap.HasTable (ExportedTypeTable.RId)) {
 442                                 coll.Add (new ExportedTypeTable ());
 443                                 m_rows [ExportedTypeTable.RId] = m_binaryReader.ReadInt32 ();
 444                         }
 445                         if (m_heap.HasTable (ManifestResourceTable.RId)) {
 446                                 coll.Add (new ManifestResourceTable ());
 447                                 m_rows [ManifestResourceTable.RId] = m_binaryReader.ReadInt32 ();
 448                         }
 449                         if (m_heap.HasTable (NestedClassTable.RId)) {
 450                                 coll.Add (new NestedClassTable ());
 451                                 m_rows [NestedClassTable.RId] = m_binaryReader.ReadInt32 ();
 452                         }
 453                         if (m_heap.HasTable (GenericParamTable.RId)) {
 454                                 coll.Add (new GenericParamTable ());
 455                                 m_rows [GenericParamTable.RId] = m_binaryReader.ReadInt32 ();
 456                         }
 457                         if (m_heap.HasTable (MethodSpecTable.RId)) {
 458                                 coll.Add (new MethodSpecTable ());
 459                                 m_rows [MethodSpecTable.RId] = m_binaryReader.ReadInt32 ();
 460                         }
 461                         if (m_heap.HasTable (GenericParamConstraintTable.RId)) {
 462                                 coll.Add (new GenericParamConstraintTable ());
 463                                 m_rows [GenericParamConstraintTable.RId] = m_binaryReader.ReadInt32 ();
 464                         }
 465                 }
 466
 467                 public override void VisitAssemblyTable (AssemblyTable table)
 468                 {
 469                         int number = m_rows [AssemblyTable.RId];
 470                         table.Rows = new RowCollection (number);
 471                         for (int i = 0; i < number; i++)
 472                                 table.Rows.Add (new AssemblyRow ());
 473                 }
 474                 public override void VisitAssemblyOSTable (AssemblyOSTable table)
 475                 {
 476                         int number = m_rows [AssemblyOSTable.RId];
 477                         table.Rows = new RowCollection (number);
 478                         for (int i = 0; i < number; i++)
 479                                 table.Rows.Add (new AssemblyOSRow ());
 480                 }
 481                 public override void VisitAssemblyProcessorTable (AssemblyProcessorTable table)
 482                 {
 483                         int number = m_rows [AssemblyProcessorTable.RId];
 484                         table.Rows = new RowCollection (number);
 485                         for (int i = 0; i < number; i++)
 486                                 table.Rows.Add (new AssemblyProcessorRow ());
 487                 }
 488                 public override void VisitAssemblyRefTable (AssemblyRefTable table)
 489                 {
 490                         int number = m_rows [AssemblyRefTable.RId];
 491                         table.Rows = new RowCollection (number);
 492                         for (int i = 0; i < number; i++)
 493                                 table.Rows.Add (new AssemblyRefRow ());
 494                 }
 495                 public override void VisitAssemblyRefOSTable (AssemblyRefOSTable table)
 496                 {
 497                         int number = m_rows [AssemblyRefOSTable.RId];
 498                         table.Rows = new RowCollection (number);
 499                         for (int i = 0; i < number; i++)
 500                                 table.Rows.Add (new AssemblyRefOSRow ());
 501                 }
 502                 public override void VisitAssemblyRefProcessorTable (AssemblyRefProcessorTable table)
 503                 {
 504                         int number = m_rows [AssemblyRefProcessorTable.RId];
 505                         table.Rows = new RowCollection (number);
 506                         for (int i = 0; i < number; i++)
 507                                 table.Rows.Add (new AssemblyRefProcessorRow ());
 508                 }
 509                 public override void VisitClassLayoutTable (ClassLayoutTable table)
 510                 {
 511                         int number = m_rows [ClassLayoutTable.RId];
 512                         table.Rows = new RowCollection (number);
 513                         for (int i = 0; i < number; i++)
 514                                 table.Rows.Add (new ClassLayoutRow ());
 515                 }
 516                 public override void VisitConstantTable (ConstantTable table)
 517                 {
 518                         int number = m_rows [ConstantTable.RId];
 519                         table.Rows = new RowCollection (number);
 520                         for (int i = 0; i < number; i++)
 521                                 table.Rows.Add (new ConstantRow ());
 522                 }
 523                 public override void VisitCustomAttributeTable (CustomAttributeTable table)
 524                 {
 525                         int number = m_rows [CustomAttributeTable.RId];
 526                         table.Rows = new RowCollection (number);
 527                         for (int i = 0; i < number; i++)
 528                                 table.Rows.Add (new CustomAttributeRow ());
 529                 }
 530                 public override void VisitDeclSecurityTable (DeclSecurityTable table)
 531                 {
 532                         int number = m_rows [DeclSecurityTable.RId];
 533                         table.Rows = new RowCollection (number);
 534                         for (int i = 0; i < number; i++)
 535                                 table.Rows.Add (new DeclSecurityRow ());
 536                 }
 537                 public override void VisitEventTable (EventTable table)
 538                 {
 539                         int number = m_rows [EventTable.RId];
 540                         table.Rows = new RowCollection (number);
 541                         for (int i = 0; i < number; i++)
 542                                 table.Rows.Add (new EventRow ());
 543                 }
 544                 public override void VisitEventMapTable (EventMapTable table)
 545                 {
 546                         int number = m_rows [EventMapTable.RId];
 547                         table.Rows = new RowCollection (number);
 548                         for (int i = 0; i < number; i++)
 549                                 table.Rows.Add (new EventMapRow ());
 550                 }
 551                 public override void VisitEventPtrTable (EventPtrTable table)
 552                 {
 553                         int number = m_rows [EventPtrTable.RId];
 554                         table.Rows = new RowCollection (number);
 555                         for (int i = 0; i < number; i++)
 556                                 table.Rows.Add (new EventPtrRow ());
 557                 }
 558                 public override void VisitExportedTypeTable (ExportedTypeTable table)
 559                 {
 560                         int number = m_rows [ExportedTypeTable.RId];
 561                         table.Rows = new RowCollection (number);
 562                         for (int i = 0; i < number; i++)
 563                                 table.Rows.Add (new ExportedTypeRow ());
 564                 }
 565                 public override void VisitFieldTable (FieldTable table)
 566                 {
 567                         int number = m_rows [FieldTable.RId];
 568                         table.Rows = new RowCollection (number);
 569                         for (int i = 0; i < number; i++)
 570                                 table.Rows.Add (new FieldRow ());
 571                 }
 572                 public override void VisitFieldLayoutTable (FieldLayoutTable table)
 573                 {
 574                         int number = m_rows [FieldLayoutTable.RId];
 575                         table.Rows = new RowCollection (number);
 576                         for (int i = 0; i < number; i++)
 577                                 table.Rows.Add (new FieldLayoutRow ());
 578                 }
 579                 public override void VisitFieldMarshalTable (FieldMarshalTable table)
 580                 {
 581                         int number = m_rows [FieldMarshalTable.RId];
 582                         table.Rows = new RowCollection (number);
 583                         for (int i = 0; i < number; i++)
 584                                 table.Rows.Add (new FieldMarshalRow ());
 585                 }
 586                 public override void VisitFieldPtrTable (FieldPtrTable table)
 587                 {
 588                         int number = m_rows [FieldPtrTable.RId];
 589                         table.Rows = new RowCollection (number);
 590                         for (int i = 0; i < number; i++)
 591                                 table.Rows.Add (new FieldPtrRow ());
 592                 }
 593                 public override void VisitFieldRVATable (FieldRVATable table)
 594                 {
 595                         int number = m_rows [FieldRVATable.RId];
 596                         table.Rows = new RowCollection (number);
 597                         for (int i = 0; i < number; i++)
 598                                 table.Rows.Add (new FieldRVARow ());
 599                 }
 600                 public override void VisitFileTable (FileTable table)
 601                 {
 602                         int number = m_rows [FileTable.RId];
 603                         table.Rows = new RowCollection (number);
 604                         for (int i = 0; i < number; i++)
 605                                 table.Rows.Add (new FileRow ());
 606                 }
 607                 public override void VisitGenericParamTable (GenericParamTable table)
 608                 {
 609                         int number = m_rows [GenericParamTable.RId];
 610                         table.Rows = new RowCollection (number);
 611                         for (int i = 0; i < number; i++)
 612                                 table.Rows.Add (new GenericParamRow ());
 613                 }
 614                 public override void VisitGenericParamConstraintTable (GenericParamConstraintTable table)
 615                 {
 616                         int number = m_rows [GenericParamConstraintTable.RId];
 617                         table.Rows = new RowCollection (number);
 618                         for (int i = 0; i < number; i++)
 619                                 table.Rows.Add (new GenericParamConstraintRow ());
 620                 }
 621                 public override void VisitImplMapTable (ImplMapTable table)
 622                 {
 623                         int number = m_rows [ImplMapTable.RId];
 624                         table.Rows = new RowCollection (number);
 625                         for (int i = 0; i < number; i++)
 626                                 table.Rows.Add (new ImplMapRow ());
 627                 }
 628                 public override void VisitInterfaceImplTable (InterfaceImplTable table)
 629                 {
 630                         int number = m_rows [InterfaceImplTable.RId];
 631                         table.Rows = new RowCollection (number);
 632                         for (int i = 0; i < number; i++)
 633                                 table.Rows.Add (new InterfaceImplRow ());
 634                 }
 635                 public override void VisitManifestResourceTable (ManifestResourceTable table)
 636                 {
 637                         int number = m_rows [ManifestResourceTable.RId];
 638                         table.Rows = new RowCollection (number);
 639                         for (int i = 0; i < number; i++)
 640                                 table.Rows.Add (new ManifestResourceRow ());
 641                 }
 642                 public override void VisitMemberRefTable (MemberRefTable table)
 643                 {
 644                         int number = m_rows [MemberRefTable.RId];
 645                         table.Rows = new RowCollection (number);
 646                         for (int i = 0; i < number; i++)
 647                                 table.Rows.Add (new MemberRefRow ());
 648                 }
 649                 public override void VisitMethodTable (MethodTable table)
 650                 {
 651                         int number = m_rows [MethodTable.RId];
 652                         table.Rows = new RowCollection (number);
 653                         for (int i = 0; i < number; i++)
 654                                 table.Rows.Add (new MethodRow ());
 655                 }
 656                 public override void VisitMethodImplTable (MethodImplTable table)
 657                 {
 658                         int number = m_rows [MethodImplTable.RId];
 659                         table.Rows = new RowCollection (number);
 660                         for (int i = 0; i < number; i++)
 661                                 table.Rows.Add (new MethodImplRow ());
 662                 }
 663                 public override void VisitMethodPtrTable (MethodPtrTable table)
 664                 {
 665                         int number = m_rows [MethodPtrTable.RId];
 666                         table.Rows = new RowCollection (number);
 667                         for (int i = 0; i < number; i++)
 668                                 table.Rows.Add (new MethodPtrRow ());
 669                 }
 670                 public override void VisitMethodSemanticsTable (MethodSemanticsTable table)
 671                 {
 672                         int number = m_rows [MethodSemanticsTable.RId];
 673                         table.Rows = new RowCollection (number);
 674                         for (int i = 0; i < number; i++)
 675                                 table.Rows.Add (new MethodSemanticsRow ());
 676                 }
 677                 public override void VisitMethodSpecTable (MethodSpecTable table)
 678                 {
 679                         int number = m_rows [MethodSpecTable.RId];
 680                         table.Rows = new RowCollection (number);
 681                         for (int i = 0; i < number; i++)
 682                                 table.Rows.Add (new MethodSpecRow ());
 683                 }
 684                 public override void VisitModuleTable (ModuleTable table)
 685                 {
 686                         int number = m_rows [ModuleTable.RId];
 687                         table.Rows = new RowCollection (number);
 688                         for (int i = 0; i < number; i++)
 689                                 table.Rows.Add (new ModuleRow ());
 690                 }
 691                 public override void VisitModuleRefTable (ModuleRefTable table)
 692                 {
 693                         int number = m_rows [ModuleRefTable.RId];
 694                         table.Rows = new RowCollection (number);
 695                         for (int i = 0; i < number; i++)
 696                                 table.Rows.Add (new ModuleRefRow ());
 697                 }
 698                 public override void VisitNestedClassTable (NestedClassTable table)
 699                 {
 700                         int number = m_rows [NestedClassTable.RId];
 701                         table.Rows = new RowCollection (number);
 702                         for (int i = 0; i < number; i++)
 703                                 table.Rows.Add (new NestedClassRow ());
 704                 }
 705                 public override void VisitParamTable (ParamTable table)
 706                 {
 707                         int number = m_rows [ParamTable.RId];
 708                         table.Rows = new RowCollection (number);
 709                         for (int i = 0; i < number; i++)
 710                                 table.Rows.Add (new ParamRow ());
 711                 }
 712                 public override void VisitParamPtrTable (ParamPtrTable table)
 713                 {
 714                         int number = m_rows [ParamPtrTable.RId];
 715                         table.Rows = new RowCollection (number);
 716                         for (int i = 0; i < number; i++)
 717                                 table.Rows.Add (new ParamPtrRow ());
 718                 }
 719                 public override void VisitPropertyTable (PropertyTable table)
 720                 {
 721                         int number = m_rows [PropertyTable.RId];
 722                         table.Rows = new RowCollection (number);
 723                         for (int i = 0; i < number; i++)
 724                                 table.Rows.Add (new PropertyRow ());
 725                 }
 726                 public override void VisitPropertyMapTable (PropertyMapTable table)
 727                 {
 728                         int number = m_rows [PropertyMapTable.RId];
 729                         table.Rows = new RowCollection (number);
 730                         for (int i = 0; i < number; i++)
 731                                 table.Rows.Add (new PropertyMapRow ());
 732                 }
 733                 public override void VisitPropertyPtrTable (PropertyPtrTable table)
 734                 {
 735                         int number = m_rows [PropertyPtrTable.RId];
 736                         table.Rows = new RowCollection (number);
 737                         for (int i = 0; i < number; i++)
 738                                 table.Rows.Add (new PropertyPtrRow ());
 739                 }
 740                 public override void VisitStandAloneSigTable (StandAloneSigTable table)
 741                 {
 742                         int number = m_rows [StandAloneSigTable.RId];
 743                         table.Rows = new RowCollection (number);
 744                         for (int i = 0; i < number; i++)
 745                                 table.Rows.Add (new StandAloneSigRow ());
 746                 }
 747                 public override void VisitTypeDefTable (TypeDefTable table)
 748                 {
 749                         int number = m_rows [TypeDefTable.RId];
 750                         table.Rows = new RowCollection (number);
 751                         for (int i = 0; i < number; i++)
 752                                 table.Rows.Add (new TypeDefRow ());
 753                 }
 754                 public override void VisitTypeRefTable (TypeRefTable table)
 755                 {
 756                         int number = m_rows [TypeRefTable.RId];
 757                         table.Rows = new RowCollection (number);
 758                         for (int i = 0; i < number; i++)
 759                                 table.Rows.Add (new TypeRefRow ());
 760                 }
 761                 public override void VisitTypeSpecTable (TypeSpecTable table)
 762                 {
 763                         int number = m_rows [TypeSpecTable.RId];
 764                         table.Rows = new RowCollection (number);
 765                         for (int i = 0; i < number; i++)
 766                                 table.Rows.Add (new TypeSpecRow ());
 767                 }
 768         }
 769 }