« back to all changes in this revision
Viewing changes to make_dnr.vb
- browse files at revision 12
- compare with another revision
- download diff
- download tarball
- view history from revision 12
- Committer: Dylan Borg
- Date: 2011-08-17 18:20:00 UTC
- Revision ID: git-v1:ddabc0e19632a6f1fa8302ceecc4661043ebc277
Committing latest DNR to GIT and BZR. Adding null refernce load support. Added system to help in popping method returns when these are not required(not called during an assignment or as a parameter or part of expression).
Signed-off-by: Dylan Borg <borgdylan@hotmail.com>
Signed-off-by: Dylan Borg <borgdylan@hotmail.com>
added
removed
make_dnr.vb
5501
5501
Dim EmitRetIL As ILGenerator = EmitRet.GetILGenerator()
5502
5502
EmitRetIL.MarkSequencePoint(doc3, 30, 1, 30, 100)
5503
5503
Dim locbldr2 As LocalBuilder = EmitRetIL.DeclareLocal(GetType(OpCode))
5504
locbldr2.SetLocalSymInfo("rop")
5504
locbldr2.SetLocalSymInfo("op")
5505
5505
Dim typ0(-1) As Type
5506
5506
EmitRetIL.Emit(OpCodes.Ldstr, "ret")
5507
5507
Typ = GetType(System.String)
5528
5528
End If
5529
5529
EmitRetIL.MarkSequencePoint(doc3, 32, 1, 32, 100)
5530
5530
EmitRetIL.Emit(OpCodes.Ret)
5531
Dim EmitPop As MethodBuilder = ILEmitter.DefineMethod("EmitPop", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), Type.EmptyTypes)
5532
Dim EmitPopIL As ILGenerator = EmitPop.GetILGenerator()
5533
EmitPopIL.MarkSequencePoint(doc3, 35, 1, 35, 100)
5534
Dim locbldr3 As LocalBuilder = EmitPopIL.DeclareLocal(GetType(OpCode))
5535
locbldr3.SetLocalSymInfo("op")
5531
5536
Dim typ2(-1) As Type
5537
EmitPopIL.Emit(OpCodes.Ldstr, "pop")
5538
Typ = GetType(System.String)
5532
5539
ReDim Preserve typ2(UBound(typ2) + 1)
5533
typ2(UBound(typ2)) = GetType(System.Int32)
5534
Dim EmitLdloc As MethodBuilder = ILEmitter.DefineMethod("EmitLdloc", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ2)
5540
typ2(UBound(typ2)) = Typ
5541
EmitPopIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ2))
5542
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ2).ReturnType
5543
EmitPopIL.Emit(OpCodes.Stloc, 0)
5544
EmitPopIL.MarkSequencePoint(doc3, 36, 1, 36, 100)
5545
Dim typ3(-1) As Type
5546
EmitPopIL.Emit(OpCodes.Ldsfld, ILGen)
5547
Typ = ILGen.FieldType
5548
Typ03 = Typ
5549
EmitPopIL.Emit(OpCodes.Ldloc, 0)
5550
Typ = GetType(OpCode)
5551
ReDim Preserve typ3(UBound(typ3) + 1)
5552
typ3(UBound(typ3)) = Typ
5553
EmitPopIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ3))
5554
Typ = Typ03.GetMethod("Emit", typ3).ReturnType
5555
If Typ.ToString() = GetType(System.Void).ToString() Then
5556
5557
Else
5558
EmitPopIL.Emit(OpCodes.Pop)
5559
End If
5560
EmitPopIL.MarkSequencePoint(doc3, 37, 1, 37, 100)
5561
EmitPopIL.Emit(OpCodes.Ret)
5562
Dim typ4(-1) As Type
5563
ReDim Preserve typ4(UBound(typ4) + 1)
5564
typ4(UBound(typ4)) = GetType(System.Int32)
5565
Dim EmitLdloc As MethodBuilder = ILEmitter.DefineMethod("EmitLdloc", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ4)
5535
5566
Dim EmitLdlocIL As ILGenerator = EmitLdloc.GetILGenerator()
5536
5567
Dim EmitLdlocparam01 As ParameterBuilder = EmitLdloc.DefineParameter(1, ParameterAttributes.None, "num")
5537
EmitLdlocIL.MarkSequencePoint(doc3, 35, 1, 35, 100)
5538
Dim locbldr3 As LocalBuilder = EmitLdlocIL.DeclareLocal(GetType(OpCode))
5539
locbldr3.SetLocalSymInfo("op")
5540
EmitLdlocIL.MarkSequencePoint(doc3, 36, 1, 36, 100)
5541
Dim locbldr4 As LocalBuilder = EmitLdlocIL.DeclareLocal(GetType(System.Boolean))
5542
locbldr4.SetLocalSymInfo("b1")
5543
EmitLdlocIL.Emit(OpCodes.Ldc_I4, 0)
5544
Typ = GetType(System.Boolean)
5545
EmitLdlocIL.Emit(OpCodes.Stloc, 1)
5546
EmitLdlocIL.MarkSequencePoint(doc3, 37, 1, 37, 100)
5568
EmitLdlocIL.MarkSequencePoint(doc3, 40, 1, 40, 100)
5569
Dim locbldr4 As LocalBuilder = EmitLdlocIL.DeclareLocal(GetType(OpCode))
5570
locbldr4.SetLocalSymInfo("op")
5571
EmitLdlocIL.MarkSequencePoint(doc3, 41, 1, 41, 100)
5547
5572
Dim locbldr5 As LocalBuilder = EmitLdlocIL.DeclareLocal(GetType(System.Boolean))
5548
locbldr5.SetLocalSymInfo("b2")
5573
locbldr5.SetLocalSymInfo("b1")
5574
EmitLdlocIL.Emit(OpCodes.Ldc_I4, 0)
5575
Typ = GetType(System.Boolean)
5576
EmitLdlocIL.Emit(OpCodes.Stloc, 1)
5577
EmitLdlocIL.MarkSequencePoint(doc3, 42, 1, 42, 100)
5578
Dim locbldr6 As LocalBuilder = EmitLdlocIL.DeclareLocal(GetType(System.Boolean))
5579
locbldr6.SetLocalSymInfo("b2")
5549
5580
EmitLdlocIL.Emit(OpCodes.Ldc_I4, 0)
5550
5581
Typ = GetType(System.Boolean)
5551
5582
EmitLdlocIL.Emit(OpCodes.Stloc, 2)
5552
EmitLdlocIL.MarkSequencePoint(doc3, 38, 1, 38, 100)
5553
Dim locbldr6 As LocalBuilder = EmitLdlocIL.DeclareLocal(GetType(System.Byte))
5554
locbldr6.SetLocalSymInfo("n8")
5555
EmitLdlocIL.MarkSequencePoint(doc3, 39, 1, 39, 100)
5556
Dim locbldr7 As LocalBuilder = EmitLdlocIL.DeclareLocal(GetType(System.Int16))
5557
locbldr7.SetLocalSymInfo("n16")
5558
EmitLdlocIL.MarkSequencePoint(doc3, 41, 1, 41, 100)
5583
EmitLdlocIL.MarkSequencePoint(doc3, 43, 1, 43, 100)
5584
Dim locbldr7 As LocalBuilder = EmitLdlocIL.DeclareLocal(GetType(System.Byte))
5585
locbldr7.SetLocalSymInfo("n8")
5586
EmitLdlocIL.MarkSequencePoint(doc3, 44, 1, 44, 100)
5587
Dim locbldr8 As LocalBuilder = EmitLdlocIL.DeclareLocal(GetType(System.Int16))
5588
locbldr8.SetLocalSymInfo("n16")
5589
EmitLdlocIL.MarkSequencePoint(doc3, 46, 1, 46, 100)
5559
5590
Dim label0 As System.Reflection.Emit.Label = EmitLdlocIL.DefineLabel()
5560
EmitLdlocIL.MarkSequencePoint(doc3, 43, 1, 43, 100)
5591
EmitLdlocIL.MarkSequencePoint(doc3, 48, 1, 48, 100)
5561
5592
EmitLdlocIL.Emit(OpCodes.Ldarg, 0)
5562
5593
Typ = GetType(System.Int32)
5563
5594
EmitLdlocIL.Emit(OpCodes.Ldc_I4, CInt(0))
5568
5599
EmitLdlocIL.Emit(OpCodes.Beq, tru157)
5569
5600
EmitLdlocIL.Emit(OpCodes.Br, fa157)
5570
5601
EmitLdlocIL.MarkLabel(tru157)
5571
EmitLdlocIL.MarkSequencePoint(doc3, 44, 1, 44, 100)
5572
Dim typ3(-1) As Type
5602
EmitLdlocIL.MarkSequencePoint(doc3, 49, 1, 49, 100)
5603
Dim typ5(-1) As Type
5573
5604
EmitLdlocIL.Emit(OpCodes.Ldstr, "ldloc.0")
5574
5605
Typ = GetType(System.String)
5575
ReDim Preserve typ3(UBound(typ3) + 1)
5576
typ3(UBound(typ3)) = Typ
5577
EmitLdlocIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ3))
5578
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ3).ReturnType
5606
ReDim Preserve typ5(UBound(typ5) + 1)
5607
typ5(UBound(typ5)) = Typ
5608
EmitLdlocIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ5))
5609
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ5).ReturnType
5579
5610
EmitLdlocIL.Emit(OpCodes.Stloc, 0)
5580
EmitLdlocIL.MarkSequencePoint(doc3, 45, 1, 45, 100)
5581
Dim typ4(-1) As Type
5611
EmitLdlocIL.MarkSequencePoint(doc3, 50, 1, 50, 100)
5612
Dim typ6(-1) As Type
5582
5613
EmitLdlocIL.Emit(OpCodes.Ldsfld, ILGen)
5583
5614
Typ = ILGen.FieldType
5584
5615
Typ03 = Typ
5585
5616
EmitLdlocIL.Emit(OpCodes.Ldloc, 0)
5586
5617
Typ = GetType(OpCode)
5587
ReDim Preserve typ4(UBound(typ4) + 1)
5588
typ4(UBound(typ4)) = Typ
5589
EmitLdlocIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ4))
5590
Typ = Typ03.GetMethod("Emit", typ4).ReturnType
5618
ReDim Preserve typ6(UBound(typ6) + 1)
5619
typ6(UBound(typ6)) = Typ
5620
EmitLdlocIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ6))
5621
Typ = Typ03.GetMethod("Emit", typ6).ReturnType
5591
5622
If Typ.ToString() = GetType(System.Void).ToString() Then
5592
5623
5593
5624
Else
5594
5625
EmitLdlocIL.Emit(OpCodes.Pop)
5595
5626
End If
5596
EmitLdlocIL.MarkSequencePoint(doc3, 46, 1, 46, 100)
5627
EmitLdlocIL.MarkSequencePoint(doc3, 51, 1, 51, 100)
5597
5628
EmitLdlocIL.Emit(OpCodes.Br, label0)
5598
EmitLdlocIL.MarkSequencePoint(doc3, 47, 1, 47, 100)
5629
EmitLdlocIL.MarkSequencePoint(doc3, 52, 1, 52, 100)
5599
5630
EmitLdlocIL.Emit(OpCodes.Br, cont157)
5600
5631
EmitLdlocIL.MarkLabel(fa157)
5601
5632
EmitLdlocIL.Emit(OpCodes.Br, cont157)
5602
5633
EmitLdlocIL.MarkLabel(cont157)
5603
EmitLdlocIL.MarkSequencePoint(doc3, 49, 1, 49, 100)
5634
EmitLdlocIL.MarkSequencePoint(doc3, 54, 1, 54, 100)
5604
5635
EmitLdlocIL.Emit(OpCodes.Ldarg, 0)
5605
5636
Typ = GetType(System.Int32)
5606
5637
EmitLdlocIL.Emit(OpCodes.Ldc_I4, CInt(1))
5611
5642
EmitLdlocIL.Emit(OpCodes.Beq, tru158)
5612
5643
EmitLdlocIL.Emit(OpCodes.Br, fa158)
5613
5644
EmitLdlocIL.MarkLabel(tru158)
5614
EmitLdlocIL.MarkSequencePoint(doc3, 50, 1, 50, 100)
5615
Dim typ5(-1) As Type
5645
EmitLdlocIL.MarkSequencePoint(doc3, 55, 1, 55, 100)
5646
Dim typ7(-1) As Type
5616
5647
EmitLdlocIL.Emit(OpCodes.Ldstr, "ldloc.1")
5617
5648
Typ = GetType(System.String)
5618
ReDim Preserve typ5(UBound(typ5) + 1)
5619
typ5(UBound(typ5)) = Typ
5620
EmitLdlocIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ5))
5621
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ5).ReturnType
5649
ReDim Preserve typ7(UBound(typ7) + 1)
5650
typ7(UBound(typ7)) = Typ
5651
EmitLdlocIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ7))
5652
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ7).ReturnType
5622
5653
EmitLdlocIL.Emit(OpCodes.Stloc, 0)
5623
EmitLdlocIL.MarkSequencePoint(doc3, 51, 1, 51, 100)
5624
Dim typ6(-1) As Type
5654
EmitLdlocIL.MarkSequencePoint(doc3, 56, 1, 56, 100)
5655
Dim typ8(-1) As Type
5625
5656
EmitLdlocIL.Emit(OpCodes.Ldsfld, ILGen)
5626
5657
Typ = ILGen.FieldType
5627
5658
Typ03 = Typ
5628
5659
EmitLdlocIL.Emit(OpCodes.Ldloc, 0)
5629
5660
Typ = GetType(OpCode)
5630
ReDim Preserve typ6(UBound(typ6) + 1)
5631
typ6(UBound(typ6)) = Typ
5632
EmitLdlocIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ6))
5633
Typ = Typ03.GetMethod("Emit", typ6).ReturnType
5661
ReDim Preserve typ8(UBound(typ8) + 1)
5662
typ8(UBound(typ8)) = Typ
5663
EmitLdlocIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ8))
5664
Typ = Typ03.GetMethod("Emit", typ8).ReturnType
5634
5665
If Typ.ToString() = GetType(System.Void).ToString() Then
5635
5666
5636
5667
Else
5637
5668
EmitLdlocIL.Emit(OpCodes.Pop)
5638
5669
End If
5639
EmitLdlocIL.MarkSequencePoint(doc3, 52, 1, 52, 100)
5670
EmitLdlocIL.MarkSequencePoint(doc3, 57, 1, 57, 100)
5640
5671
EmitLdlocIL.Emit(OpCodes.Br, label0)
5641
EmitLdlocIL.MarkSequencePoint(doc3, 53, 1, 53, 100)
5672
EmitLdlocIL.MarkSequencePoint(doc3, 58, 1, 58, 100)
5642
5673
EmitLdlocIL.Emit(OpCodes.Br, cont158)
5643
5674
EmitLdlocIL.MarkLabel(fa158)
5644
5675
EmitLdlocIL.Emit(OpCodes.Br, cont158)
5645
5676
EmitLdlocIL.MarkLabel(cont158)
5646
EmitLdlocIL.MarkSequencePoint(doc3, 55, 1, 55, 100)
5677
EmitLdlocIL.MarkSequencePoint(doc3, 60, 1, 60, 100)
5647
5678
EmitLdlocIL.Emit(OpCodes.Ldarg, 0)
5648
5679
Typ = GetType(System.Int32)
5649
5680
EmitLdlocIL.Emit(OpCodes.Ldc_I4, CInt(2))
5654
5685
EmitLdlocIL.Emit(OpCodes.Beq, tru159)
5655
5686
EmitLdlocIL.Emit(OpCodes.Br, fa159)
5656
5687
EmitLdlocIL.MarkLabel(tru159)
5657
EmitLdlocIL.MarkSequencePoint(doc3, 56, 1, 56, 100)
5658
Dim typ7(-1) As Type
5688
EmitLdlocIL.MarkSequencePoint(doc3, 61, 1, 61, 100)
5689
Dim typ9(-1) As Type
5659
5690
EmitLdlocIL.Emit(OpCodes.Ldstr, "ldloc.2")
5660
5691
Typ = GetType(System.String)
5661
ReDim Preserve typ7(UBound(typ7) + 1)
5662
typ7(UBound(typ7)) = Typ
5663
EmitLdlocIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ7))
5664
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ7).ReturnType
5692
ReDim Preserve typ9(UBound(typ9) + 1)
5693
typ9(UBound(typ9)) = Typ
5694
EmitLdlocIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ9))
5695
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ9).ReturnType
5665
5696
EmitLdlocIL.Emit(OpCodes.Stloc, 0)
5666
EmitLdlocIL.MarkSequencePoint(doc3, 57, 1, 57, 100)
5667
Dim typ8(-1) As Type
5697
EmitLdlocIL.MarkSequencePoint(doc3, 62, 1, 62, 100)
5698
Dim typ10(-1) As Type
5668
5699
EmitLdlocIL.Emit(OpCodes.Ldsfld, ILGen)
5669
5700
Typ = ILGen.FieldType
5670
5701
Typ03 = Typ
5671
5702
EmitLdlocIL.Emit(OpCodes.Ldloc, 0)
5672
5703
Typ = GetType(OpCode)
5673
ReDim Preserve typ8(UBound(typ8) + 1)
5674
typ8(UBound(typ8)) = Typ
5675
EmitLdlocIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ8))
5676
Typ = Typ03.GetMethod("Emit", typ8).ReturnType
5704
ReDim Preserve typ10(UBound(typ10) + 1)
5705
typ10(UBound(typ10)) = Typ
5706
EmitLdlocIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ10))
5707
Typ = Typ03.GetMethod("Emit", typ10).ReturnType
5677
5708
If Typ.ToString() = GetType(System.Void).ToString() Then
5678
5709
5679
5710
Else
5680
5711
EmitLdlocIL.Emit(OpCodes.Pop)
5681
5712
End If
5682
EmitLdlocIL.MarkSequencePoint(doc3, 58, 1, 58, 100)
5713
EmitLdlocIL.MarkSequencePoint(doc3, 63, 1, 63, 100)
5683
5714
EmitLdlocIL.Emit(OpCodes.Br, label0)
5684
EmitLdlocIL.MarkSequencePoint(doc3, 59, 1, 59, 100)
5715
EmitLdlocIL.MarkSequencePoint(doc3, 64, 1, 64, 100)
5685
5716
EmitLdlocIL.Emit(OpCodes.Br, cont159)
5686
5717
EmitLdlocIL.MarkLabel(fa159)
5687
5718
EmitLdlocIL.Emit(OpCodes.Br, cont159)
5688
5719
EmitLdlocIL.MarkLabel(cont159)
5689
EmitLdlocIL.MarkSequencePoint(doc3, 61, 1, 61, 100)
5720
EmitLdlocIL.MarkSequencePoint(doc3, 66, 1, 66, 100)
5690
5721
EmitLdlocIL.Emit(OpCodes.Ldarg, 0)
5691
5722
Typ = GetType(System.Int32)
5692
5723
EmitLdlocIL.Emit(OpCodes.Ldc_I4, CInt(3))
5697
5728
EmitLdlocIL.Emit(OpCodes.Beq, tru160)
5698
5729
EmitLdlocIL.Emit(OpCodes.Br, fa160)
5699
5730
EmitLdlocIL.MarkLabel(tru160)
5700
EmitLdlocIL.MarkSequencePoint(doc3, 62, 1, 62, 100)
5701
Dim typ9(-1) As Type
5731
EmitLdlocIL.MarkSequencePoint(doc3, 67, 1, 67, 100)
5732
Dim typ11(-1) As Type
5702
5733
EmitLdlocIL.Emit(OpCodes.Ldstr, "ldloc.3")
5703
5734
Typ = GetType(System.String)
5704
ReDim Preserve typ9(UBound(typ9) + 1)
5705
typ9(UBound(typ9)) = Typ
5706
EmitLdlocIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ9))
5707
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ9).ReturnType
5735
ReDim Preserve typ11(UBound(typ11) + 1)
5736
typ11(UBound(typ11)) = Typ
5737
EmitLdlocIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ11))
5738
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ11).ReturnType
5708
5739
EmitLdlocIL.Emit(OpCodes.Stloc, 0)
5709
EmitLdlocIL.MarkSequencePoint(doc3, 63, 1, 63, 100)
5710
Dim typ10(-1) As Type
5740
EmitLdlocIL.MarkSequencePoint(doc3, 68, 1, 68, 100)
5741
Dim typ12(-1) As Type
5711
5742
EmitLdlocIL.Emit(OpCodes.Ldsfld, ILGen)
5712
5743
Typ = ILGen.FieldType
5713
5744
Typ03 = Typ
5714
5745
EmitLdlocIL.Emit(OpCodes.Ldloc, 0)
5715
5746
Typ = GetType(OpCode)
5716
ReDim Preserve typ10(UBound(typ10) + 1)
5717
typ10(UBound(typ10)) = Typ
5718
EmitLdlocIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ10))
5719
Typ = Typ03.GetMethod("Emit", typ10).ReturnType
5747
ReDim Preserve typ12(UBound(typ12) + 1)
5748
typ12(UBound(typ12)) = Typ
5749
EmitLdlocIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ12))
5750
Typ = Typ03.GetMethod("Emit", typ12).ReturnType
5720
5751
If Typ.ToString() = GetType(System.Void).ToString() Then
5721
5752
5722
5753
Else
5723
5754
EmitLdlocIL.Emit(OpCodes.Pop)
5724
5755
End If
5725
EmitLdlocIL.MarkSequencePoint(doc3, 64, 1, 64, 100)
5756
EmitLdlocIL.MarkSequencePoint(doc3, 69, 1, 69, 100)
5726
5757
EmitLdlocIL.Emit(OpCodes.Br, label0)
5727
EmitLdlocIL.MarkSequencePoint(doc3, 65, 1, 65, 100)
5758
EmitLdlocIL.MarkSequencePoint(doc3, 70, 1, 70, 100)
5728
5759
EmitLdlocIL.Emit(OpCodes.Br, cont160)
5729
5760
EmitLdlocIL.MarkLabel(fa160)
5730
5761
EmitLdlocIL.Emit(OpCodes.Br, cont160)
5731
5762
EmitLdlocIL.MarkLabel(cont160)
5732
EmitLdlocIL.MarkSequencePoint(doc3, 67, 1, 67, 100)
5763
EmitLdlocIL.MarkSequencePoint(doc3, 72, 1, 72, 100)
5733
5764
EmitLdlocIL.Emit(OpCodes.Ldarg, 0)
5734
5765
Typ = GetType(System.Int32)
5735
5766
EmitLdlocIL.Emit(OpCodes.Ldc_I4, CInt(0))
5740
5771
EmitLdlocIL.Emit(OpCodes.Bge, tru161)
5741
5772
EmitLdlocIL.Emit(OpCodes.Br, fa161)
5742
5773
EmitLdlocIL.MarkLabel(tru161)
5743
EmitLdlocIL.MarkSequencePoint(doc3, 68, 1, 68, 100)
5774
EmitLdlocIL.MarkSequencePoint(doc3, 73, 1, 73, 100)
5744
5775
EmitLdlocIL.Emit(OpCodes.Ldc_I4, 1)
5745
5776
Typ = GetType(System.Boolean)
5746
5777
EmitLdlocIL.Emit(OpCodes.Stloc, 1)
5747
EmitLdlocIL.MarkSequencePoint(doc3, 69, 1, 69, 100)
5778
EmitLdlocIL.MarkSequencePoint(doc3, 74, 1, 74, 100)
5748
5779
EmitLdlocIL.Emit(OpCodes.Br, cont161)
5749
5780
EmitLdlocIL.MarkLabel(fa161)
5750
5781
EmitLdlocIL.Emit(OpCodes.Br, cont161)
5751
5782
EmitLdlocIL.MarkLabel(cont161)
5752
EmitLdlocIL.MarkSequencePoint(doc3, 70, 1, 70, 100)
5783
EmitLdlocIL.MarkSequencePoint(doc3, 75, 1, 75, 100)
5753
5784
EmitLdlocIL.Emit(OpCodes.Ldarg, 0)
5754
5785
Typ = GetType(System.Int32)
5755
5786
EmitLdlocIL.Emit(OpCodes.Ldc_I4, CInt(255))
5760
5791
EmitLdlocIL.Emit(OpCodes.Ble, tru162)
5761
5792
EmitLdlocIL.Emit(OpCodes.Br, fa162)
5762
5793
EmitLdlocIL.MarkLabel(tru162)
5763
EmitLdlocIL.MarkSequencePoint(doc3, 71, 1, 71, 100)
5794
EmitLdlocIL.MarkSequencePoint(doc3, 76, 1, 76, 100)
5764
5795
EmitLdlocIL.Emit(OpCodes.Ldc_I4, 1)
5765
5796
Typ = GetType(System.Boolean)
5766
5797
EmitLdlocIL.Emit(OpCodes.Stloc, 2)
5767
EmitLdlocIL.MarkSequencePoint(doc3, 72, 1, 72, 100)
5798
EmitLdlocIL.MarkSequencePoint(doc3, 77, 1, 77, 100)
5768
5799
EmitLdlocIL.Emit(OpCodes.Br, cont162)
5769
5800
EmitLdlocIL.MarkLabel(fa162)
5770
5801
EmitLdlocIL.Emit(OpCodes.Br, cont162)
5771
5802
EmitLdlocIL.MarkLabel(cont162)
5772
EmitLdlocIL.MarkSequencePoint(doc3, 73, 1, 73, 100)
5803
EmitLdlocIL.MarkSequencePoint(doc3, 78, 1, 78, 100)
5773
5804
EmitLdlocIL.Emit(OpCodes.Ldloc, 1)
5774
5805
Typ = GetType(System.Boolean)
5775
5806
EmitLdlocIL.Emit(OpCodes.Ldloc, 2)
5776
5807
Typ = GetType(System.Boolean)
5777
5808
EmitLdlocIL.Emit(OpCodes.And)
5778
5809
EmitLdlocIL.Emit(OpCodes.Stloc, 2)
5779
EmitLdlocIL.MarkSequencePoint(doc3, 75, 1, 75, 100)
5810
EmitLdlocIL.MarkSequencePoint(doc3, 80, 1, 80, 100)
5780
5811
EmitLdlocIL.Emit(OpCodes.Ldloc, 2)
5781
5812
Typ = GetType(System.Boolean)
5782
5813
EmitLdlocIL.Emit(OpCodes.Ldc_I4, 1)
5787
5818
EmitLdlocIL.Emit(OpCodes.Beq, tru163)
5788
5819
EmitLdlocIL.Emit(OpCodes.Br, fa163)
5789
5820
EmitLdlocIL.MarkLabel(tru163)
5790
EmitLdlocIL.MarkSequencePoint(doc3, 76, 1, 76, 100)
5791
Dim typ11(-1) As Type
5821
EmitLdlocIL.MarkSequencePoint(doc3, 81, 1, 81, 100)
5822
Dim typ13(-1) As Type
5792
5823
EmitLdlocIL.Emit(OpCodes.Ldstr, "ldloc.s")
5793
5824
Typ = GetType(System.String)
5794
ReDim Preserve typ11(UBound(typ11) + 1)
5795
typ11(UBound(typ11)) = Typ
5796
EmitLdlocIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ11))
5797
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ11).ReturnType
5825
ReDim Preserve typ13(UBound(typ13) + 1)
5826
typ13(UBound(typ13)) = Typ
5827
EmitLdlocIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ13))
5828
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ13).ReturnType
5798
5829
EmitLdlocIL.Emit(OpCodes.Stloc, 0)
5799
EmitLdlocIL.MarkSequencePoint(doc3, 77, 1, 77, 100)
5800
Dim typ12(-1) As Type
5830
EmitLdlocIL.MarkSequencePoint(doc3, 82, 1, 82, 100)
5831
Dim typ14(-1) As Type
5801
5832
EmitLdlocIL.Emit(OpCodes.Ldarg, 0)
5802
5833
Typ = GetType(System.Int32)
5803
ReDim Preserve typ12(UBound(typ12) + 1)
5804
typ12(UBound(typ12)) = Typ
5805
EmitLdlocIL.Emit(OpCodes.Call, GetType(Convert).GetMethod("ToByte", typ12))
5806
Typ = GetType(Convert).GetMethod("ToByte", typ12).ReturnType
5834
ReDim Preserve typ14(UBound(typ14) + 1)
5835
typ14(UBound(typ14)) = Typ
5836
EmitLdlocIL.Emit(OpCodes.Call, GetType(Convert).GetMethod("ToByte", typ14))
5837
Typ = GetType(Convert).GetMethod("ToByte", typ14).ReturnType
5807
5838
EmitLdlocIL.Emit(OpCodes.Stloc, 3)
5808
EmitLdlocIL.MarkSequencePoint(doc3, 78, 1, 78, 100)
5809
Dim typ13(-1) As Type
5839
EmitLdlocIL.MarkSequencePoint(doc3, 83, 1, 83, 100)
5840
Dim typ15(-1) As Type
5810
5841
EmitLdlocIL.Emit(OpCodes.Ldsfld, ILGen)
5811
5842
Typ = ILGen.FieldType
5812
5843
Typ03 = Typ
5813
5844
EmitLdlocIL.Emit(OpCodes.Ldloc, 0)
5814
5845
Typ = GetType(OpCode)
5815
ReDim Preserve typ13(UBound(typ13) + 1)
5816
typ13(UBound(typ13)) = Typ
5846
ReDim Preserve typ15(UBound(typ15) + 1)
5847
typ15(UBound(typ15)) = Typ
5817
5848
EmitLdlocIL.Emit(OpCodes.Ldloc, 3)
5818
5849
Typ = GetType(System.Byte)
5819
ReDim Preserve typ13(UBound(typ13) + 1)
5820
typ13(UBound(typ13)) = Typ
5821
EmitLdlocIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ13))
5822
Typ = Typ03.GetMethod("Emit", typ13).ReturnType
5850
ReDim Preserve typ15(UBound(typ15) + 1)
5851
typ15(UBound(typ15)) = Typ
5852
EmitLdlocIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ15))
5853
Typ = Typ03.GetMethod("Emit", typ15).ReturnType
5823
5854
If Typ.ToString() = GetType(System.Void).ToString() Then
5824
5855
5825
5856
Else
5826
5857
EmitLdlocIL.Emit(OpCodes.Pop)
5827
5858
End If
5828
EmitLdlocIL.MarkSequencePoint(doc3, 79, 1, 79, 100)
5859
EmitLdlocIL.MarkSequencePoint(doc3, 84, 1, 84, 100)
5829
5860
EmitLdlocIL.Emit(OpCodes.Br, label0)
5830
EmitLdlocIL.MarkSequencePoint(doc3, 80, 1, 80, 100)
5861
EmitLdlocIL.MarkSequencePoint(doc3, 85, 1, 85, 100)
5831
5862
EmitLdlocIL.Emit(OpCodes.Br, cont163)
5832
5863
EmitLdlocIL.MarkLabel(fa163)
5833
5864
EmitLdlocIL.Emit(OpCodes.Br, cont163)
5834
5865
EmitLdlocIL.MarkLabel(cont163)
5835
EmitLdlocIL.MarkSequencePoint(doc3, 82, 1, 82, 100)
5866
EmitLdlocIL.MarkSequencePoint(doc3, 87, 1, 87, 100)
5836
5867
EmitLdlocIL.Emit(OpCodes.Ldloc, 1)
5837
5868
Typ = GetType(System.Boolean)
5838
5869
EmitLdlocIL.Emit(OpCodes.Ldc_I4, 1)
5843
5874
EmitLdlocIL.Emit(OpCodes.Beq, tru164)
5844
5875
EmitLdlocIL.Emit(OpCodes.Br, fa164)
5845
5876
EmitLdlocIL.MarkLabel(tru164)
5846
EmitLdlocIL.MarkSequencePoint(doc3, 83, 1, 83, 100)
5847
Dim typ14(-1) As Type
5877
EmitLdlocIL.MarkSequencePoint(doc3, 88, 1, 88, 100)
5878
Dim typ16(-1) As Type
5848
5879
EmitLdlocIL.Emit(OpCodes.Ldstr, "ldloc")
5849
5880
Typ = GetType(System.String)
5850
ReDim Preserve typ14(UBound(typ14) + 1)
5851
typ14(UBound(typ14)) = Typ
5852
EmitLdlocIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ14))
5853
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ14).ReturnType
5881
ReDim Preserve typ16(UBound(typ16) + 1)
5882
typ16(UBound(typ16)) = Typ
5883
EmitLdlocIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ16))
5884
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ16).ReturnType
5854
5885
EmitLdlocIL.Emit(OpCodes.Stloc, 0)
5855
EmitLdlocIL.MarkSequencePoint(doc3, 84, 1, 84, 100)
5886
EmitLdlocIL.MarkSequencePoint(doc3, 89, 1, 89, 100)
5856
5887
EmitLdlocIL.Emit(OpCodes.Ldarg, 0)
5857
5888
Typ = GetType(System.Int32)
5858
Dim typ15 As Type() = {Typ}
5859
EmitLdlocIL.Emit(OpCodes.Call, GetType(System.Convert).GetMethod("ToInt16", typ15))
5860
Typ = GetType(System.Convert).GetMethod("ToInt16", typ15).ReturnType
5889
Dim typ17 As Type() = {Typ}
5890
EmitLdlocIL.Emit(OpCodes.Call, GetType(System.Convert).GetMethod("ToInt16", typ17))
5891
Typ = GetType(System.Convert).GetMethod("ToInt16", typ17).ReturnType
5861
5892
EmitLdlocIL.Emit(OpCodes.Stloc, 4)
5862
EmitLdlocIL.MarkSequencePoint(doc3, 85, 1, 85, 100)
5863
Dim typ16(-1) As Type
5893
EmitLdlocIL.MarkSequencePoint(doc3, 90, 1, 90, 100)
5894
Dim typ18(-1) As Type
5864
5895
EmitLdlocIL.Emit(OpCodes.Ldsfld, ILGen)
5865
5896
Typ = ILGen.FieldType
5866
5897
Typ03 = Typ
5867
5898
EmitLdlocIL.Emit(OpCodes.Ldloc, 0)
5868
5899
Typ = GetType(OpCode)
5869
ReDim Preserve typ16(UBound(typ16) + 1)
5870
typ16(UBound(typ16)) = Typ
5900
ReDim Preserve typ18(UBound(typ18) + 1)
5901
typ18(UBound(typ18)) = Typ
5871
5902
EmitLdlocIL.Emit(OpCodes.Ldloc, 4)
5872
5903
Typ = GetType(System.Int16)
5873
ReDim Preserve typ16(UBound(typ16) + 1)
5874
typ16(UBound(typ16)) = Typ
5875
EmitLdlocIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ16))
5876
Typ = Typ03.GetMethod("Emit", typ16).ReturnType
5904
ReDim Preserve typ18(UBound(typ18) + 1)
5905
typ18(UBound(typ18)) = Typ
5906
EmitLdlocIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ18))
5907
Typ = Typ03.GetMethod("Emit", typ18).ReturnType
5877
5908
If Typ.ToString() = GetType(System.Void).ToString() Then
5878
5909
5879
5910
Else
5880
5911
EmitLdlocIL.Emit(OpCodes.Pop)
5881
5912
End If
5882
EmitLdlocIL.MarkSequencePoint(doc3, 86, 1, 86, 100)
5913
EmitLdlocIL.MarkSequencePoint(doc3, 91, 1, 91, 100)
5883
5914
EmitLdlocIL.Emit(OpCodes.Br, label0)
5884
EmitLdlocIL.MarkSequencePoint(doc3, 87, 1, 87, 100)
5915
EmitLdlocIL.MarkSequencePoint(doc3, 92, 1, 92, 100)
5885
5916
EmitLdlocIL.Emit(OpCodes.Br, cont164)
5886
5917
EmitLdlocIL.MarkLabel(fa164)
5887
5918
EmitLdlocIL.Emit(OpCodes.Br, cont164)
5888
5919
EmitLdlocIL.MarkLabel(cont164)
5889
EmitLdlocIL.MarkSequencePoint(doc3, 89, 1, 89, 100)
5920
EmitLdlocIL.MarkSequencePoint(doc3, 94, 1, 94, 100)
5890
5921
EmitLdlocIL.MarkLabel(label0)
5891
EmitLdlocIL.MarkSequencePoint(doc3, 90, 1, 90, 100)
5922
EmitLdlocIL.MarkSequencePoint(doc3, 95, 1, 95, 100)
5892
5923
EmitLdlocIL.Emit(OpCodes.Ret)
5893
Dim typ17(-1) As Type
5894
ReDim Preserve typ17(UBound(typ17) + 1)
5895
typ17(UBound(typ17)) = GetType(System.Int32)
5896
Dim EmitStloc As MethodBuilder = ILEmitter.DefineMethod("EmitStloc", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ17)
5924
Dim typ19(-1) As Type
5925
ReDim Preserve typ19(UBound(typ19) + 1)
5926
typ19(UBound(typ19)) = GetType(System.Int32)
5927
Dim EmitStloc As MethodBuilder = ILEmitter.DefineMethod("EmitStloc", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ19)
5897
5928
Dim EmitStlocIL As ILGenerator = EmitStloc.GetILGenerator()
5898
5929
Dim EmitStlocparam01 As ParameterBuilder = EmitStloc.DefineParameter(1, ParameterAttributes.None, "num")
5899
EmitStlocIL.MarkSequencePoint(doc3, 93, 1, 93, 100)
5900
Dim locbldr8 As LocalBuilder = EmitStlocIL.DeclareLocal(GetType(OpCode))
5901
locbldr8.SetLocalSymInfo("op")
5902
EmitStlocIL.MarkSequencePoint(doc3, 94, 1, 94, 100)
5903
Dim locbldr9 As LocalBuilder = EmitStlocIL.DeclareLocal(GetType(System.Boolean))
5904
locbldr9.SetLocalSymInfo("b1")
5905
EmitStlocIL.Emit(OpCodes.Ldc_I4, 0)
5906
Typ = GetType(System.Boolean)
5907
EmitStlocIL.Emit(OpCodes.Stloc, 1)
5908
EmitStlocIL.MarkSequencePoint(doc3, 95, 1, 95, 100)
5930
EmitStlocIL.MarkSequencePoint(doc3, 98, 1, 98, 100)
5931
Dim locbldr9 As LocalBuilder = EmitStlocIL.DeclareLocal(GetType(OpCode))
5932
locbldr9.SetLocalSymInfo("op")
5933
EmitStlocIL.MarkSequencePoint(doc3, 99, 1, 99, 100)
5909
5934
Dim locbldr10 As LocalBuilder = EmitStlocIL.DeclareLocal(GetType(System.Boolean))
5910
locbldr10.SetLocalSymInfo("b2")
5935
locbldr10.SetLocalSymInfo("b1")
5936
EmitStlocIL.Emit(OpCodes.Ldc_I4, 0)
5937
Typ = GetType(System.Boolean)
5938
EmitStlocIL.Emit(OpCodes.Stloc, 1)
5939
EmitStlocIL.MarkSequencePoint(doc3, 100, 1, 100, 100)
5940
Dim locbldr11 As LocalBuilder = EmitStlocIL.DeclareLocal(GetType(System.Boolean))
5941
locbldr11.SetLocalSymInfo("b2")
5911
5942
EmitStlocIL.Emit(OpCodes.Ldc_I4, 0)
5912
5943
Typ = GetType(System.Boolean)
5913
5944
EmitStlocIL.Emit(OpCodes.Stloc, 2)
5914
EmitStlocIL.MarkSequencePoint(doc3, 96, 1, 96, 100)
5915
Dim locbldr11 As LocalBuilder = EmitStlocIL.DeclareLocal(GetType(System.Byte))
5916
locbldr11.SetLocalSymInfo("n8")
5917
EmitStlocIL.MarkSequencePoint(doc3, 97, 1, 97, 100)
5918
Dim locbldr12 As LocalBuilder = EmitStlocIL.DeclareLocal(GetType(System.Int16))
5919
locbldr12.SetLocalSymInfo("n16")
5920
EmitStlocIL.MarkSequencePoint(doc3, 99, 1, 99, 100)
5945
EmitStlocIL.MarkSequencePoint(doc3, 101, 1, 101, 100)
5946
Dim locbldr12 As LocalBuilder = EmitStlocIL.DeclareLocal(GetType(System.Byte))
5947
locbldr12.SetLocalSymInfo("n8")
5948
EmitStlocIL.MarkSequencePoint(doc3, 102, 1, 102, 100)
5949
Dim locbldr13 As LocalBuilder = EmitStlocIL.DeclareLocal(GetType(System.Int16))
5950
locbldr13.SetLocalSymInfo("n16")
5951
EmitStlocIL.MarkSequencePoint(doc3, 104, 1, 104, 100)
5921
5952
Dim label1 As System.Reflection.Emit.Label = EmitStlocIL.DefineLabel()
5922
EmitStlocIL.MarkSequencePoint(doc3, 101, 1, 101, 100)
5953
EmitStlocIL.MarkSequencePoint(doc3, 106, 1, 106, 100)
5923
5954
EmitStlocIL.Emit(OpCodes.Ldarg, 0)
5924
5955
Typ = GetType(System.Int32)
5925
5956
EmitStlocIL.Emit(OpCodes.Ldc_I4, CInt(0))
5930
5961
EmitStlocIL.Emit(OpCodes.Beq, tru165)
5931
5962
EmitStlocIL.Emit(OpCodes.Br, fa165)
5932
5963
EmitStlocIL.MarkLabel(tru165)
5933
EmitStlocIL.MarkSequencePoint(doc3, 102, 1, 102, 100)
5934
Dim typ18(-1) As Type
5964
EmitStlocIL.MarkSequencePoint(doc3, 107, 1, 107, 100)
5965
Dim typ20(-1) As Type
5935
5966
EmitStlocIL.Emit(OpCodes.Ldstr, "stloc.0")
5936
5967
Typ = GetType(System.String)
5937
ReDim Preserve typ18(UBound(typ18) + 1)
5938
typ18(UBound(typ18)) = Typ
5939
EmitStlocIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ18))
5940
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ18).ReturnType
5968
ReDim Preserve typ20(UBound(typ20) + 1)
5969
typ20(UBound(typ20)) = Typ
5970
EmitStlocIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ20))
5971
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ20).ReturnType
5941
5972
EmitStlocIL.Emit(OpCodes.Stloc, 0)
5942
EmitStlocIL.MarkSequencePoint(doc3, 103, 1, 103, 100)
5943
Dim typ19(-1) As Type
5973
EmitStlocIL.MarkSequencePoint(doc3, 108, 1, 108, 100)
5974
Dim typ21(-1) As Type
5944
5975
EmitStlocIL.Emit(OpCodes.Ldsfld, ILGen)
5945
5976
Typ = ILGen.FieldType
5946
5977
Typ03 = Typ
5947
5978
EmitStlocIL.Emit(OpCodes.Ldloc, 0)
5948
5979
Typ = GetType(OpCode)
5949
ReDim Preserve typ19(UBound(typ19) + 1)
5950
typ19(UBound(typ19)) = Typ
5951
EmitStlocIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ19))
5952
Typ = Typ03.GetMethod("Emit", typ19).ReturnType
5980
ReDim Preserve typ21(UBound(typ21) + 1)
5981
typ21(UBound(typ21)) = Typ
5982
EmitStlocIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ21))
5983
Typ = Typ03.GetMethod("Emit", typ21).ReturnType
5953
5984
If Typ.ToString() = GetType(System.Void).ToString() Then
5954
5985
5955
5986
Else
5956
5987
EmitStlocIL.Emit(OpCodes.Pop)
5957
5988
End If
5958
EmitStlocIL.MarkSequencePoint(doc3, 104, 1, 104, 100)
5989
EmitStlocIL.MarkSequencePoint(doc3, 109, 1, 109, 100)
5959
5990
EmitStlocIL.Emit(OpCodes.Br, label1)
5960
EmitStlocIL.MarkSequencePoint(doc3, 105, 1, 105, 100)
5991
EmitStlocIL.MarkSequencePoint(doc3, 110, 1, 110, 100)
5961
5992
EmitStlocIL.Emit(OpCodes.Br, cont165)
5962
5993
EmitStlocIL.MarkLabel(fa165)
5963
5994
EmitStlocIL.Emit(OpCodes.Br, cont165)
5964
5995
EmitStlocIL.MarkLabel(cont165)
5965
EmitStlocIL.MarkSequencePoint(doc3, 107, 1, 107, 100)
5996
EmitStlocIL.MarkSequencePoint(doc3, 112, 1, 112, 100)
5966
5997
EmitStlocIL.Emit(OpCodes.Ldarg, 0)
5967
5998
Typ = GetType(System.Int32)
5968
5999
EmitStlocIL.Emit(OpCodes.Ldc_I4, CInt(1))
5973
6004
EmitStlocIL.Emit(OpCodes.Beq, tru166)
5974
6005
EmitStlocIL.Emit(OpCodes.Br, fa166)
5975
6006
EmitStlocIL.MarkLabel(tru166)
5976
EmitStlocIL.MarkSequencePoint(doc3, 108, 1, 108, 100)
5977
Dim typ20(-1) As Type
6007
EmitStlocIL.MarkSequencePoint(doc3, 113, 1, 113, 100)
6008
Dim typ22(-1) As Type
5978
6009
EmitStlocIL.Emit(OpCodes.Ldstr, "stloc.1")
5979
6010
Typ = GetType(System.String)
5980
ReDim Preserve typ20(UBound(typ20) + 1)
5981
typ20(UBound(typ20)) = Typ
5982
EmitStlocIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ20))
5983
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ20).ReturnType
6011
ReDim Preserve typ22(UBound(typ22) + 1)
6012
typ22(UBound(typ22)) = Typ
6013
EmitStlocIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ22))
6014
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ22).ReturnType
5984
6015
EmitStlocIL.Emit(OpCodes.Stloc, 0)
5985
EmitStlocIL.MarkSequencePoint(doc3, 109, 1, 109, 100)
5986
Dim typ21(-1) As Type
6016
EmitStlocIL.MarkSequencePoint(doc3, 114, 1, 114, 100)
6017
Dim typ23(-1) As Type
5987
6018
EmitStlocIL.Emit(OpCodes.Ldsfld, ILGen)
5988
6019
Typ = ILGen.FieldType
5989
6020
Typ03 = Typ
5990
6021
EmitStlocIL.Emit(OpCodes.Ldloc, 0)
5991
6022
Typ = GetType(OpCode)
5992
ReDim Preserve typ21(UBound(typ21) + 1)
5993
typ21(UBound(typ21)) = Typ
5994
EmitStlocIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ21))
5995
Typ = Typ03.GetMethod("Emit", typ21).ReturnType
6023
ReDim Preserve typ23(UBound(typ23) + 1)
6024
typ23(UBound(typ23)) = Typ
6025
EmitStlocIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ23))
6026
Typ = Typ03.GetMethod("Emit", typ23).ReturnType
5996
6027
If Typ.ToString() = GetType(System.Void).ToString() Then
5997
6028
5998
6029
Else
5999
6030
EmitStlocIL.Emit(OpCodes.Pop)
6000
6031
End If
6001
EmitStlocIL.MarkSequencePoint(doc3, 110, 1, 110, 100)
6032
EmitStlocIL.MarkSequencePoint(doc3, 115, 1, 115, 100)
6002
6033
EmitStlocIL.Emit(OpCodes.Br, label1)
6003
EmitStlocIL.MarkSequencePoint(doc3, 111, 1, 111, 100)
6034
EmitStlocIL.MarkSequencePoint(doc3, 116, 1, 116, 100)
6004
6035
EmitStlocIL.Emit(OpCodes.Br, cont166)
6005
6036
EmitStlocIL.MarkLabel(fa166)
6006
6037
EmitStlocIL.Emit(OpCodes.Br, cont166)
6007
6038
EmitStlocIL.MarkLabel(cont166)
6008
EmitStlocIL.MarkSequencePoint(doc3, 113, 1, 113, 100)
6039
EmitStlocIL.MarkSequencePoint(doc3, 118, 1, 118, 100)
6009
6040
EmitStlocIL.Emit(OpCodes.Ldarg, 0)
6010
6041
Typ = GetType(System.Int32)
6011
6042
EmitStlocIL.Emit(OpCodes.Ldc_I4, CInt(2))
6016
6047
EmitStlocIL.Emit(OpCodes.Beq, tru167)
6017
6048
EmitStlocIL.Emit(OpCodes.Br, fa167)
6018
6049
EmitStlocIL.MarkLabel(tru167)
6019
EmitStlocIL.MarkSequencePoint(doc3, 114, 1, 114, 100)
6020
Dim typ22(-1) As Type
6050
EmitStlocIL.MarkSequencePoint(doc3, 119, 1, 119, 100)
6051
Dim typ24(-1) As Type
6021
6052
EmitStlocIL.Emit(OpCodes.Ldstr, "stloc.2")
6022
6053
Typ = GetType(System.String)
6023
ReDim Preserve typ22(UBound(typ22) + 1)
6024
typ22(UBound(typ22)) = Typ
6025
EmitStlocIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ22))
6026
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ22).ReturnType
6054
ReDim Preserve typ24(UBound(typ24) + 1)
6055
typ24(UBound(typ24)) = Typ
6056
EmitStlocIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ24))
6057
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ24).ReturnType
6027
6058
EmitStlocIL.Emit(OpCodes.Stloc, 0)
6028
EmitStlocIL.MarkSequencePoint(doc3, 115, 1, 115, 100)
6029
Dim typ23(-1) As Type
6059
EmitStlocIL.MarkSequencePoint(doc3, 120, 1, 120, 100)
6060
Dim typ25(-1) As Type
6030
6061
EmitStlocIL.Emit(OpCodes.Ldsfld, ILGen)
6031
6062
Typ = ILGen.FieldType
6032
6063
Typ03 = Typ
6033
6064
EmitStlocIL.Emit(OpCodes.Ldloc, 0)
6034
6065
Typ = GetType(OpCode)
6035
ReDim Preserve typ23(UBound(typ23) + 1)
6036
typ23(UBound(typ23)) = Typ
6037
EmitStlocIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ23))
6038
Typ = Typ03.GetMethod("Emit", typ23).ReturnType
6066
ReDim Preserve typ25(UBound(typ25) + 1)
6067
typ25(UBound(typ25)) = Typ
6068
EmitStlocIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ25))
6069
Typ = Typ03.GetMethod("Emit", typ25).ReturnType
6039
6070
If Typ.ToString() = GetType(System.Void).ToString() Then
6040
6071
6041
6072
Else
6042
6073
EmitStlocIL.Emit(OpCodes.Pop)
6043
6074
End If
6044
EmitStlocIL.MarkSequencePoint(doc3, 116, 1, 116, 100)
6075
EmitStlocIL.MarkSequencePoint(doc3, 121, 1, 121, 100)
6045
6076
EmitStlocIL.Emit(OpCodes.Br, label1)
6046
EmitStlocIL.MarkSequencePoint(doc3, 117, 1, 117, 100)
6077
EmitStlocIL.MarkSequencePoint(doc3, 122, 1, 122, 100)
6047
6078
EmitStlocIL.Emit(OpCodes.Br, cont167)
6048
6079
EmitStlocIL.MarkLabel(fa167)
6049
6080
EmitStlocIL.Emit(OpCodes.Br, cont167)
6050
6081
EmitStlocIL.MarkLabel(cont167)
6051
EmitStlocIL.MarkSequencePoint(doc3, 119, 1, 119, 100)
6082
EmitStlocIL.MarkSequencePoint(doc3, 124, 1, 124, 100)
6052
6083
EmitStlocIL.Emit(OpCodes.Ldarg, 0)
6053
6084
Typ = GetType(System.Int32)
6054
6085
EmitStlocIL.Emit(OpCodes.Ldc_I4, CInt(3))
6059
6090
EmitStlocIL.Emit(OpCodes.Beq, tru168)
6060
6091
EmitStlocIL.Emit(OpCodes.Br, fa168)
6061
6092
EmitStlocIL.MarkLabel(tru168)
6062
EmitStlocIL.MarkSequencePoint(doc3, 120, 1, 120, 100)
6063
Dim typ24(-1) As Type
6093
EmitStlocIL.MarkSequencePoint(doc3, 125, 1, 125, 100)
6094
Dim typ26(-1) As Type
6064
6095
EmitStlocIL.Emit(OpCodes.Ldstr, "stloc.3")
6065
6096
Typ = GetType(System.String)
6066
ReDim Preserve typ24(UBound(typ24) + 1)
6067
typ24(UBound(typ24)) = Typ
6068
EmitStlocIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ24))
6069
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ24).ReturnType
6097
ReDim Preserve typ26(UBound(typ26) + 1)
6098
typ26(UBound(typ26)) = Typ
6099
EmitStlocIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ26))
6100
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ26).ReturnType
6070
6101
EmitStlocIL.Emit(OpCodes.Stloc, 0)
6071
EmitStlocIL.MarkSequencePoint(doc3, 121, 1, 121, 100)
6072
Dim typ25(-1) As Type
6102
EmitStlocIL.MarkSequencePoint(doc3, 126, 1, 126, 100)
6103
Dim typ27(-1) As Type
6073
6104
EmitStlocIL.Emit(OpCodes.Ldsfld, ILGen)
6074
6105
Typ = ILGen.FieldType
6075
6106
Typ03 = Typ
6076
6107
EmitStlocIL.Emit(OpCodes.Ldloc, 0)
6077
6108
Typ = GetType(OpCode)
6078
ReDim Preserve typ25(UBound(typ25) + 1)
6079
typ25(UBound(typ25)) = Typ
6080
EmitStlocIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ25))
6081
Typ = Typ03.GetMethod("Emit", typ25).ReturnType
6109
ReDim Preserve typ27(UBound(typ27) + 1)
6110
typ27(UBound(typ27)) = Typ
6111
EmitStlocIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ27))
6112
Typ = Typ03.GetMethod("Emit", typ27).ReturnType
6082
6113
If Typ.ToString() = GetType(System.Void).ToString() Then
6083
6114
6084
6115
Else
6085
6116
EmitStlocIL.Emit(OpCodes.Pop)
6086
6117
End If
6087
EmitStlocIL.MarkSequencePoint(doc3, 122, 1, 122, 100)
6118
EmitStlocIL.MarkSequencePoint(doc3, 127, 1, 127, 100)
6088
6119
EmitStlocIL.Emit(OpCodes.Br, label1)
6089
EmitStlocIL.MarkSequencePoint(doc3, 123, 1, 123, 100)
6120
EmitStlocIL.MarkSequencePoint(doc3, 128, 1, 128, 100)
6090
6121
EmitStlocIL.Emit(OpCodes.Br, cont168)
6091
6122
EmitStlocIL.MarkLabel(fa168)
6092
6123
EmitStlocIL.Emit(OpCodes.Br, cont168)
6093
6124
EmitStlocIL.MarkLabel(cont168)
6094
EmitStlocIL.MarkSequencePoint(doc3, 125, 1, 125, 100)
6125
EmitStlocIL.MarkSequencePoint(doc3, 130, 1, 130, 100)
6095
6126
EmitStlocIL.Emit(OpCodes.Ldarg, 0)
6096
6127
Typ = GetType(System.Int32)
6097
6128
EmitStlocIL.Emit(OpCodes.Ldc_I4, CInt(0))
6102
6133
EmitStlocIL.Emit(OpCodes.Bge, tru169)
6103
6134
EmitStlocIL.Emit(OpCodes.Br, fa169)
6104
6135
EmitStlocIL.MarkLabel(tru169)
6105
EmitStlocIL.MarkSequencePoint(doc3, 126, 1, 126, 100)
6136
EmitStlocIL.MarkSequencePoint(doc3, 131, 1, 131, 100)
6106
6137
EmitStlocIL.Emit(OpCodes.Ldc_I4, 1)
6107
6138
Typ = GetType(System.Boolean)
6108
6139
EmitStlocIL.Emit(OpCodes.Stloc, 1)
6109
EmitStlocIL.MarkSequencePoint(doc3, 127, 1, 127, 100)
6140
EmitStlocIL.MarkSequencePoint(doc3, 132, 1, 132, 100)
6110
6141
EmitStlocIL.Emit(OpCodes.Br, cont169)
6111
6142
EmitStlocIL.MarkLabel(fa169)
6112
6143
EmitStlocIL.Emit(OpCodes.Br, cont169)
6113
6144
EmitStlocIL.MarkLabel(cont169)
6114
EmitStlocIL.MarkSequencePoint(doc3, 128, 1, 128, 100)
6145
EmitStlocIL.MarkSequencePoint(doc3, 133, 1, 133, 100)
6115
6146
EmitStlocIL.Emit(OpCodes.Ldarg, 0)
6116
6147
Typ = GetType(System.Int32)
6117
6148
EmitStlocIL.Emit(OpCodes.Ldc_I4, CInt(255))
6122
6153
EmitStlocIL.Emit(OpCodes.Ble, tru170)
6123
6154
EmitStlocIL.Emit(OpCodes.Br, fa170)
6124
6155
EmitStlocIL.MarkLabel(tru170)
6125
EmitStlocIL.MarkSequencePoint(doc3, 129, 1, 129, 100)
6156
EmitStlocIL.MarkSequencePoint(doc3, 134, 1, 134, 100)
6126
6157
EmitStlocIL.Emit(OpCodes.Ldc_I4, 1)
6127
6158
Typ = GetType(System.Boolean)
6128
6159
EmitStlocIL.Emit(OpCodes.Stloc, 2)
6129
EmitStlocIL.MarkSequencePoint(doc3, 130, 1, 130, 100)
6160
EmitStlocIL.MarkSequencePoint(doc3, 135, 1, 135, 100)
6130
6161
EmitStlocIL.Emit(OpCodes.Br, cont170)
6131
6162
EmitStlocIL.MarkLabel(fa170)
6132
6163
EmitStlocIL.Emit(OpCodes.Br, cont170)
6133
6164
EmitStlocIL.MarkLabel(cont170)
6134
EmitStlocIL.MarkSequencePoint(doc3, 131, 1, 131, 100)
6165
EmitStlocIL.MarkSequencePoint(doc3, 136, 1, 136, 100)
6135
6166
EmitStlocIL.Emit(OpCodes.Ldloc, 1)
6136
6167
Typ = GetType(System.Boolean)
6137
6168
EmitStlocIL.Emit(OpCodes.Ldloc, 2)
6138
6169
Typ = GetType(System.Boolean)
6139
6170
EmitStlocIL.Emit(OpCodes.And)
6140
6171
EmitStlocIL.Emit(OpCodes.Stloc, 2)
6141
EmitStlocIL.MarkSequencePoint(doc3, 133, 1, 133, 100)
6172
EmitStlocIL.MarkSequencePoint(doc3, 138, 1, 138, 100)
6142
6173
EmitStlocIL.Emit(OpCodes.Ldloc, 2)
6143
6174
Typ = GetType(System.Boolean)
6144
6175
EmitStlocIL.Emit(OpCodes.Ldc_I4, 1)
6149
6180
EmitStlocIL.Emit(OpCodes.Beq, tru171)
6150
6181
EmitStlocIL.Emit(OpCodes.Br, fa171)
6151
6182
EmitStlocIL.MarkLabel(tru171)
6152
EmitStlocIL.MarkSequencePoint(doc3, 134, 1, 134, 100)
6153
Dim typ26(-1) As Type
6183
EmitStlocIL.MarkSequencePoint(doc3, 139, 1, 139, 100)
6184
Dim typ28(-1) As Type
6154
6185
EmitStlocIL.Emit(OpCodes.Ldstr, "stloc.s")
6155
6186
Typ = GetType(System.String)
6156
ReDim Preserve typ26(UBound(typ26) + 1)
6157
typ26(UBound(typ26)) = Typ
6158
EmitStlocIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ26))
6159
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ26).ReturnType
6187
ReDim Preserve typ28(UBound(typ28) + 1)
6188
typ28(UBound(typ28)) = Typ
6189
EmitStlocIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ28))
6190
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ28).ReturnType
6160
6191
EmitStlocIL.Emit(OpCodes.Stloc, 0)
6161
EmitStlocIL.MarkSequencePoint(doc3, 135, 1, 135, 100)
6162
Dim typ27(-1) As Type
6192
EmitStlocIL.MarkSequencePoint(doc3, 140, 1, 140, 100)
6193
Dim typ29(-1) As Type
6163
6194
EmitStlocIL.Emit(OpCodes.Ldarg, 0)
6164
6195
Typ = GetType(System.Int32)
6165
ReDim Preserve typ27(UBound(typ27) + 1)
6166
typ27(UBound(typ27)) = Typ
6167
EmitStlocIL.Emit(OpCodes.Call, GetType(Convert).GetMethod("ToByte", typ27))
6168
Typ = GetType(Convert).GetMethod("ToByte", typ27).ReturnType
6196
ReDim Preserve typ29(UBound(typ29) + 1)
6197
typ29(UBound(typ29)) = Typ
6198
EmitStlocIL.Emit(OpCodes.Call, GetType(Convert).GetMethod("ToByte", typ29))
6199
Typ = GetType(Convert).GetMethod("ToByte", typ29).ReturnType
6169
6200
EmitStlocIL.Emit(OpCodes.Stloc, 3)
6170
EmitStlocIL.MarkSequencePoint(doc3, 136, 1, 136, 100)
6171
Dim typ28(-1) As Type
6201
EmitStlocIL.MarkSequencePoint(doc3, 141, 1, 141, 100)
6202
Dim typ30(-1) As Type
6172
6203
EmitStlocIL.Emit(OpCodes.Ldsfld, ILGen)
6173
6204
Typ = ILGen.FieldType
6174
6205
Typ03 = Typ
6175
6206
EmitStlocIL.Emit(OpCodes.Ldloc, 0)
6176
6207
Typ = GetType(OpCode)
6177
ReDim Preserve typ28(UBound(typ28) + 1)
6178
typ28(UBound(typ28)) = Typ
6208
ReDim Preserve typ30(UBound(typ30) + 1)
6209
typ30(UBound(typ30)) = Typ
6179
6210
EmitStlocIL.Emit(OpCodes.Ldloc, 3)
6180
6211
Typ = GetType(System.Byte)
6181
ReDim Preserve typ28(UBound(typ28) + 1)
6182
typ28(UBound(typ28)) = Typ
6183
EmitStlocIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ28))
6184
Typ = Typ03.GetMethod("Emit", typ28).ReturnType
6212
ReDim Preserve typ30(UBound(typ30) + 1)
6213
typ30(UBound(typ30)) = Typ
6214
EmitStlocIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ30))
6215
Typ = Typ03.GetMethod("Emit", typ30).ReturnType
6185
6216
If Typ.ToString() = GetType(System.Void).ToString() Then
6186
6217
6187
6218
Else
6188
6219
EmitStlocIL.Emit(OpCodes.Pop)
6189
6220
End If
6190
EmitStlocIL.MarkSequencePoint(doc3, 137, 1, 137, 100)
6221
EmitStlocIL.MarkSequencePoint(doc3, 142, 1, 142, 100)
6191
6222
EmitStlocIL.Emit(OpCodes.Br, label1)
6192
EmitStlocIL.MarkSequencePoint(doc3, 138, 1, 138, 100)
6223
EmitStlocIL.MarkSequencePoint(doc3, 143, 1, 143, 100)
6193
6224
EmitStlocIL.Emit(OpCodes.Br, cont171)
6194
6225
EmitStlocIL.MarkLabel(fa171)
6195
6226
EmitStlocIL.Emit(OpCodes.Br, cont171)
6196
6227
EmitStlocIL.MarkLabel(cont171)
6197
EmitStlocIL.MarkSequencePoint(doc3, 140, 1, 140, 100)
6228
EmitStlocIL.MarkSequencePoint(doc3, 145, 1, 145, 100)
6198
6229
EmitStlocIL.Emit(OpCodes.Ldloc, 1)
6199
6230
Typ = GetType(System.Boolean)
6200
6231
EmitStlocIL.Emit(OpCodes.Ldc_I4, 1)
6205
6236
EmitStlocIL.Emit(OpCodes.Beq, tru172)
6206
6237
EmitStlocIL.Emit(OpCodes.Br, fa172)
6207
6238
EmitStlocIL.MarkLabel(tru172)
6208
EmitStlocIL.MarkSequencePoint(doc3, 141, 1, 141, 100)
6209
Dim typ29(-1) As Type
6239
EmitStlocIL.MarkSequencePoint(doc3, 146, 1, 146, 100)
6240
Dim typ31(-1) As Type
6210
6241
EmitStlocIL.Emit(OpCodes.Ldstr, "stloc")
6211
6242
Typ = GetType(System.String)
6212
ReDim Preserve typ29(UBound(typ29) + 1)
6213
typ29(UBound(typ29)) = Typ
6214
EmitStlocIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ29))
6215
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ29).ReturnType
6243
ReDim Preserve typ31(UBound(typ31) + 1)
6244
typ31(UBound(typ31)) = Typ
6245
EmitStlocIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ31))
6246
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ31).ReturnType
6216
6247
EmitStlocIL.Emit(OpCodes.Stloc, 0)
6217
EmitStlocIL.MarkSequencePoint(doc3, 142, 1, 142, 100)
6248
EmitStlocIL.MarkSequencePoint(doc3, 147, 1, 147, 100)
6218
6249
EmitStlocIL.Emit(OpCodes.Ldarg, 0)
6219
6250
Typ = GetType(System.Int32)
6220
Dim typ30 As Type() = {Typ}
6221
EmitStlocIL.Emit(OpCodes.Call, GetType(System.Convert).GetMethod("ToInt16", typ30))
6222
Typ = GetType(System.Convert).GetMethod("ToInt16", typ30).ReturnType
6251
Dim typ32 As Type() = {Typ}
6252
EmitStlocIL.Emit(OpCodes.Call, GetType(System.Convert).GetMethod("ToInt16", typ32))
6253
Typ = GetType(System.Convert).GetMethod("ToInt16", typ32).ReturnType
6223
6254
EmitStlocIL.Emit(OpCodes.Stloc, 4)
6224
EmitStlocIL.MarkSequencePoint(doc3, 143, 1, 143, 100)
6225
Dim typ31(-1) As Type
6255
EmitStlocIL.MarkSequencePoint(doc3, 148, 1, 148, 100)
6256
Dim typ33(-1) As Type
6226
6257
EmitStlocIL.Emit(OpCodes.Ldsfld, ILGen)
6227
6258
Typ = ILGen.FieldType
6228
6259
Typ03 = Typ
6229
6260
EmitStlocIL.Emit(OpCodes.Ldloc, 0)
6230
6261
Typ = GetType(OpCode)
6231
ReDim Preserve typ31(UBound(typ31) + 1)
6232
typ31(UBound(typ31)) = Typ
6262
ReDim Preserve typ33(UBound(typ33) + 1)
6263
typ33(UBound(typ33)) = Typ
6233
6264
EmitStlocIL.Emit(OpCodes.Ldloc, 4)
6234
6265
Typ = GetType(System.Int16)
6235
ReDim Preserve typ31(UBound(typ31) + 1)
6236
typ31(UBound(typ31)) = Typ
6237
EmitStlocIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ31))
6238
Typ = Typ03.GetMethod("Emit", typ31).ReturnType
6266
ReDim Preserve typ33(UBound(typ33) + 1)
6267
typ33(UBound(typ33)) = Typ
6268
EmitStlocIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ33))
6269
Typ = Typ03.GetMethod("Emit", typ33).ReturnType
6239
6270
If Typ.ToString() = GetType(System.Void).ToString() Then
6240
6271
6241
6272
Else
6242
6273
EmitStlocIL.Emit(OpCodes.Pop)
6243
6274
End If
6244
EmitStlocIL.MarkSequencePoint(doc3, 144, 1, 144, 100)
6275
EmitStlocIL.MarkSequencePoint(doc3, 149, 1, 149, 100)
6245
6276
EmitStlocIL.Emit(OpCodes.Br, label1)
6246
EmitStlocIL.MarkSequencePoint(doc3, 145, 1, 145, 100)
6277
EmitStlocIL.MarkSequencePoint(doc3, 150, 1, 150, 100)
6247
6278
EmitStlocIL.Emit(OpCodes.Br, cont172)
6248
6279
EmitStlocIL.MarkLabel(fa172)
6249
6280
EmitStlocIL.Emit(OpCodes.Br, cont172)
6250
6281
EmitStlocIL.MarkLabel(cont172)
6251
EmitStlocIL.MarkSequencePoint(doc3, 147, 1, 147, 100)
6282
EmitStlocIL.MarkSequencePoint(doc3, 152, 1, 152, 100)
6252
6283
EmitStlocIL.MarkLabel(label1)
6253
EmitStlocIL.MarkSequencePoint(doc3, 148, 1, 148, 100)
6284
EmitStlocIL.MarkSequencePoint(doc3, 153, 1, 153, 100)
6254
6285
EmitStlocIL.Emit(OpCodes.Ret)
6255
Dim typ32(-1) As Type
6256
ReDim Preserve typ32(UBound(typ32) + 1)
6257
typ32(UBound(typ32)) = GetType(System.Int64)
6258
Dim EmitLdcI8 As MethodBuilder = ILEmitter.DefineMethod("EmitLdcI8", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ32)
6286
Dim typ34(-1) As Type
6287
ReDim Preserve typ34(UBound(typ34) + 1)
6288
typ34(UBound(typ34)) = GetType(System.Int64)
6289
Dim EmitLdcI8 As MethodBuilder = ILEmitter.DefineMethod("EmitLdcI8", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ34)
6259
6290
Dim EmitLdcI8IL As ILGenerator = EmitLdcI8.GetILGenerator()
6260
6291
Dim EmitLdcI8param01 As ParameterBuilder = EmitLdcI8.DefineParameter(1, ParameterAttributes.None, "n")
6261
EmitLdcI8IL.MarkSequencePoint(doc3, 151, 1, 151, 100)
6262
Dim locbldr13 As LocalBuilder = EmitLdcI8IL.DeclareLocal(GetType(OpCode))
6263
locbldr13.SetLocalSymInfo("op")
6264
EmitLdcI8IL.MarkSequencePoint(doc3, 152, 1, 152, 100)
6265
Dim locbldr14 As LocalBuilder = EmitLdcI8IL.DeclareLocal(GetType(System.Boolean))
6266
locbldr14.SetLocalSymInfo("b1")
6267
EmitLdcI8IL.Emit(OpCodes.Ldc_I4, 0)
6268
Typ = GetType(System.Boolean)
6269
EmitLdcI8IL.Emit(OpCodes.Stloc, 1)
6270
EmitLdcI8IL.MarkSequencePoint(doc3, 153, 1, 153, 100)
6292
EmitLdcI8IL.MarkSequencePoint(doc3, 156, 1, 156, 100)
6293
Dim locbldr14 As LocalBuilder = EmitLdcI8IL.DeclareLocal(GetType(OpCode))
6294
locbldr14.SetLocalSymInfo("op")
6295
EmitLdcI8IL.MarkSequencePoint(doc3, 157, 1, 157, 100)
6271
6296
Dim locbldr15 As LocalBuilder = EmitLdcI8IL.DeclareLocal(GetType(System.Boolean))
6272
locbldr15.SetLocalSymInfo("b2")
6297
locbldr15.SetLocalSymInfo("b1")
6298
EmitLdcI8IL.Emit(OpCodes.Ldc_I4, 0)
6299
Typ = GetType(System.Boolean)
6300
EmitLdcI8IL.Emit(OpCodes.Stloc, 1)
6301
EmitLdcI8IL.MarkSequencePoint(doc3, 158, 1, 158, 100)
6302
Dim locbldr16 As LocalBuilder = EmitLdcI8IL.DeclareLocal(GetType(System.Boolean))
6303
locbldr16.SetLocalSymInfo("b2")
6273
6304
EmitLdcI8IL.Emit(OpCodes.Ldc_I4, 0)
6274
6305
Typ = GetType(System.Boolean)
6275
6306
EmitLdcI8IL.Emit(OpCodes.Stloc, 2)
6276
EmitLdcI8IL.MarkSequencePoint(doc3, 157, 1, 157, 100)
6307
EmitLdcI8IL.MarkSequencePoint(doc3, 162, 1, 162, 100)
6277
6308
Dim label2 As System.Reflection.Emit.Label = EmitLdcI8IL.DefineLabel()
6278
EmitLdcI8IL.MarkSequencePoint(doc3, 159, 1, 159, 100)
6309
EmitLdcI8IL.MarkSequencePoint(doc3, 164, 1, 164, 100)
6279
6310
EmitLdcI8IL.Emit(OpCodes.Ldarg, 0)
6280
6311
Typ = GetType(System.Int64)
6281
6312
EmitLdcI8IL.Emit(OpCodes.Ldc_I8, CLng(-1))
6286
6317
EmitLdcI8IL.Emit(OpCodes.Beq, tru173)
6287
6318
EmitLdcI8IL.Emit(OpCodes.Br, fa173)
6288
6319
EmitLdcI8IL.MarkLabel(tru173)
6289
EmitLdcI8IL.MarkSequencePoint(doc3, 160, 1, 160, 100)
6290
Dim typ33(-1) As Type
6320
EmitLdcI8IL.MarkSequencePoint(doc3, 165, 1, 165, 100)
6321
Dim typ35(-1) As Type
6291
6322
EmitLdcI8IL.Emit(OpCodes.Ldstr, "ldc.i4.m1")
6292
6323
Typ = GetType(System.String)
6293
ReDim Preserve typ33(UBound(typ33) + 1)
6294
typ33(UBound(typ33)) = Typ
6295
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ33))
6296
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ33).ReturnType
6297
EmitLdcI8IL.Emit(OpCodes.Stloc, 0)
6298
EmitLdcI8IL.MarkSequencePoint(doc3, 161, 1, 161, 100)
6299
Dim typ34(-1) As Type
6300
EmitLdcI8IL.Emit(OpCodes.Ldsfld, ILGen)
6301
Typ = ILGen.FieldType
6302
Typ03 = Typ
6303
EmitLdcI8IL.Emit(OpCodes.Ldloc, 0)
6304
Typ = GetType(OpCode)
6305
ReDim Preserve typ34(UBound(typ34) + 1)
6306
typ34(UBound(typ34)) = Typ
6307
EmitLdcI8IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ34))
6308
Typ = Typ03.GetMethod("Emit", typ34).ReturnType
6309
If Typ.ToString() = GetType(System.Void).ToString() Then
6310
6311
Else
6312
EmitLdcI8IL.Emit(OpCodes.Pop)
6313
End If
6314
EmitLdcI8IL.MarkSequencePoint(doc3, 162, 1, 162, 100)
6315
Dim typ35(-1) As Type
6316
EmitLdcI8IL.Emit(OpCodes.Ldstr, "conv.i8")
6317
Typ = GetType(System.String)
6318
6324
ReDim Preserve typ35(UBound(typ35) + 1)
6319
6325
typ35(UBound(typ35)) = Typ
6320
6326
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ35))
6321
6327
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ35).ReturnType
6322
6328
EmitLdcI8IL.Emit(OpCodes.Stloc, 0)
6323
EmitLdcI8IL.MarkSequencePoint(doc3, 163, 1, 163, 100)
6329
EmitLdcI8IL.MarkSequencePoint(doc3, 166, 1, 166, 100)
6324
6330
Dim typ36(-1) As Type
6325
6331
EmitLdcI8IL.Emit(OpCodes.Ldsfld, ILGen)
6326
6332
Typ = ILGen.FieldType
6336
6342
Else
6337
6343
EmitLdcI8IL.Emit(OpCodes.Pop)
6338
6344
End If
6339
EmitLdcI8IL.MarkSequencePoint(doc3, 164, 1, 164, 100)
6345
EmitLdcI8IL.MarkSequencePoint(doc3, 167, 1, 167, 100)
6346
Dim typ37(-1) As Type
6347
EmitLdcI8IL.Emit(OpCodes.Ldstr, "conv.i8")
6348
Typ = GetType(System.String)
6349
ReDim Preserve typ37(UBound(typ37) + 1)
6350
typ37(UBound(typ37)) = Typ
6351
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ37))
6352
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ37).ReturnType
6353
EmitLdcI8IL.Emit(OpCodes.Stloc, 0)
6354
EmitLdcI8IL.MarkSequencePoint(doc3, 168, 1, 168, 100)
6355
Dim typ38(-1) As Type
6356
EmitLdcI8IL.Emit(OpCodes.Ldsfld, ILGen)
6357
Typ = ILGen.FieldType
6358
Typ03 = Typ
6359
EmitLdcI8IL.Emit(OpCodes.Ldloc, 0)
6360
Typ = GetType(OpCode)
6361
ReDim Preserve typ38(UBound(typ38) + 1)
6362
typ38(UBound(typ38)) = Typ
6363
EmitLdcI8IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ38))
6364
Typ = Typ03.GetMethod("Emit", typ38).ReturnType
6365
If Typ.ToString() = GetType(System.Void).ToString() Then
6366
6367
Else
6368
EmitLdcI8IL.Emit(OpCodes.Pop)
6369
End If
6370
EmitLdcI8IL.MarkSequencePoint(doc3, 169, 1, 169, 100)
6340
6371
EmitLdcI8IL.Emit(OpCodes.Br, label2)
6341
EmitLdcI8IL.MarkSequencePoint(doc3, 165, 1, 165, 100)
6372
EmitLdcI8IL.MarkSequencePoint(doc3, 170, 1, 170, 100)
6342
6373
EmitLdcI8IL.Emit(OpCodes.Br, cont173)
6343
6374
EmitLdcI8IL.MarkLabel(fa173)
6344
6375
EmitLdcI8IL.Emit(OpCodes.Br, cont173)
6345
6376
EmitLdcI8IL.MarkLabel(cont173)
6346
EmitLdcI8IL.MarkSequencePoint(doc3, 167, 1, 167, 100)
6377
EmitLdcI8IL.MarkSequencePoint(doc3, 172, 1, 172, 100)
6347
6378
EmitLdcI8IL.Emit(OpCodes.Ldarg, 0)
6348
6379
Typ = GetType(System.Int64)
6349
6380
EmitLdcI8IL.Emit(OpCodes.Ldc_I8, CLng(0))
6354
6385
EmitLdcI8IL.Emit(OpCodes.Beq, tru174)
6355
6386
EmitLdcI8IL.Emit(OpCodes.Br, fa174)
6356
6387
EmitLdcI8IL.MarkLabel(tru174)
6357
EmitLdcI8IL.MarkSequencePoint(doc3, 168, 1, 168, 100)
6358
Dim typ37(-1) As Type
6388
EmitLdcI8IL.MarkSequencePoint(doc3, 173, 1, 173, 100)
6389
Dim typ39(-1) As Type
6359
6390
EmitLdcI8IL.Emit(OpCodes.Ldstr, "ldc.i4.0")
6360
6391
Typ = GetType(System.String)
6361
ReDim Preserve typ37(UBound(typ37) + 1)
6362
typ37(UBound(typ37)) = Typ
6363
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ37))
6364
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ37).ReturnType
6365
EmitLdcI8IL.Emit(OpCodes.Stloc, 0)
6366
EmitLdcI8IL.MarkSequencePoint(doc3, 169, 1, 169, 100)
6367
Dim typ38(-1) As Type
6368
EmitLdcI8IL.Emit(OpCodes.Ldsfld, ILGen)
6369
Typ = ILGen.FieldType
6370
Typ03 = Typ
6371
EmitLdcI8IL.Emit(OpCodes.Ldloc, 0)
6372
Typ = GetType(OpCode)
6373
ReDim Preserve typ38(UBound(typ38) + 1)
6374
typ38(UBound(typ38)) = Typ
6375
EmitLdcI8IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ38))
6376
Typ = Typ03.GetMethod("Emit", typ38).ReturnType
6377
If Typ.ToString() = GetType(System.Void).ToString() Then
6378
6379
Else
6380
EmitLdcI8IL.Emit(OpCodes.Pop)
6381
End If
6382
EmitLdcI8IL.MarkSequencePoint(doc3, 170, 1, 170, 100)
6383
Dim typ39(-1) As Type
6384
EmitLdcI8IL.Emit(OpCodes.Ldstr, "conv.i8")
6385
Typ = GetType(System.String)
6386
6392
ReDim Preserve typ39(UBound(typ39) + 1)
6387
6393
typ39(UBound(typ39)) = Typ
6388
6394
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ39))
6389
6395
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ39).ReturnType
6390
6396
EmitLdcI8IL.Emit(OpCodes.Stloc, 0)
6391
EmitLdcI8IL.MarkSequencePoint(doc3, 171, 1, 171, 100)
6397
EmitLdcI8IL.MarkSequencePoint(doc3, 174, 1, 174, 100)
6392
6398
Dim typ40(-1) As Type
6393
6399
EmitLdcI8IL.Emit(OpCodes.Ldsfld, ILGen)
6394
6400
Typ = ILGen.FieldType
6404
6410
Else
6405
6411
EmitLdcI8IL.Emit(OpCodes.Pop)
6406
6412
End If
6407
EmitLdcI8IL.MarkSequencePoint(doc3, 172, 1, 172, 100)
6413
EmitLdcI8IL.MarkSequencePoint(doc3, 175, 1, 175, 100)
6414
Dim typ41(-1) As Type
6415
EmitLdcI8IL.Emit(OpCodes.Ldstr, "conv.i8")
6416
Typ = GetType(System.String)
6417
ReDim Preserve typ41(UBound(typ41) + 1)
6418
typ41(UBound(typ41)) = Typ
6419
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ41))
6420
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ41).ReturnType
6421
EmitLdcI8IL.Emit(OpCodes.Stloc, 0)
6422
EmitLdcI8IL.MarkSequencePoint(doc3, 176, 1, 176, 100)
6423
Dim typ42(-1) As Type
6424
EmitLdcI8IL.Emit(OpCodes.Ldsfld, ILGen)
6425
Typ = ILGen.FieldType
6426
Typ03 = Typ
6427
EmitLdcI8IL.Emit(OpCodes.Ldloc, 0)
6428
Typ = GetType(OpCode)
6429
ReDim Preserve typ42(UBound(typ42) + 1)
6430
typ42(UBound(typ42)) = Typ
6431
EmitLdcI8IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ42))
6432
Typ = Typ03.GetMethod("Emit", typ42).ReturnType
6433
If Typ.ToString() = GetType(System.Void).ToString() Then
6434
6435
Else
6436
EmitLdcI8IL.Emit(OpCodes.Pop)
6437
End If
6438
EmitLdcI8IL.MarkSequencePoint(doc3, 177, 1, 177, 100)
6408
6439
EmitLdcI8IL.Emit(OpCodes.Br, label2)
6409
EmitLdcI8IL.MarkSequencePoint(doc3, 173, 1, 173, 100)
6440
EmitLdcI8IL.MarkSequencePoint(doc3, 178, 1, 178, 100)
6410
6441
EmitLdcI8IL.Emit(OpCodes.Br, cont174)
6411
6442
EmitLdcI8IL.MarkLabel(fa174)
6412
6443
EmitLdcI8IL.Emit(OpCodes.Br, cont174)
6413
6444
EmitLdcI8IL.MarkLabel(cont174)
6414
EmitLdcI8IL.MarkSequencePoint(doc3, 175, 1, 175, 100)
6445
EmitLdcI8IL.MarkSequencePoint(doc3, 180, 1, 180, 100)
6415
6446
EmitLdcI8IL.Emit(OpCodes.Ldarg, 0)
6416
6447
Typ = GetType(System.Int64)
6417
6448
EmitLdcI8IL.Emit(OpCodes.Ldc_I8, CLng(1))
6422
6453
EmitLdcI8IL.Emit(OpCodes.Beq, tru175)
6423
6454
EmitLdcI8IL.Emit(OpCodes.Br, fa175)
6424
6455
EmitLdcI8IL.MarkLabel(tru175)
6425
EmitLdcI8IL.MarkSequencePoint(doc3, 176, 1, 176, 100)
6426
Dim typ41(-1) As Type
6456
EmitLdcI8IL.MarkSequencePoint(doc3, 181, 1, 181, 100)
6457
Dim typ43(-1) As Type
6427
6458
EmitLdcI8IL.Emit(OpCodes.Ldstr, "ldc.i4.1")
6428
6459
Typ = GetType(System.String)
6429
ReDim Preserve typ41(UBound(typ41) + 1)
6430
typ41(UBound(typ41)) = Typ
6431
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ41))
6432
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ41).ReturnType
6433
EmitLdcI8IL.Emit(OpCodes.Stloc, 0)
6434
EmitLdcI8IL.MarkSequencePoint(doc3, 177, 1, 177, 100)
6435
Dim typ42(-1) As Type
6436
EmitLdcI8IL.Emit(OpCodes.Ldsfld, ILGen)
6437
Typ = ILGen.FieldType
6438
Typ03 = Typ
6439
EmitLdcI8IL.Emit(OpCodes.Ldloc, 0)
6440
Typ = GetType(OpCode)
6441
ReDim Preserve typ42(UBound(typ42) + 1)
6442
typ42(UBound(typ42)) = Typ
6443
EmitLdcI8IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ42))
6444
Typ = Typ03.GetMethod("Emit", typ42).ReturnType
6445
If Typ.ToString() = GetType(System.Void).ToString() Then
6446
6447
Else
6448
EmitLdcI8IL.Emit(OpCodes.Pop)
6449
End If
6450
EmitLdcI8IL.MarkSequencePoint(doc3, 178, 1, 178, 100)
6451
Dim typ43(-1) As Type
6452
EmitLdcI8IL.Emit(OpCodes.Ldstr, "conv.i8")
6453
Typ = GetType(System.String)
6454
6460
ReDim Preserve typ43(UBound(typ43) + 1)
6455
6461
typ43(UBound(typ43)) = Typ
6456
6462
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ43))
6457
6463
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ43).ReturnType
6458
6464
EmitLdcI8IL.Emit(OpCodes.Stloc, 0)
6459
EmitLdcI8IL.MarkSequencePoint(doc3, 179, 1, 179, 100)
6465
EmitLdcI8IL.MarkSequencePoint(doc3, 182, 1, 182, 100)
6460
6466
Dim typ44(-1) As Type
6461
6467
EmitLdcI8IL.Emit(OpCodes.Ldsfld, ILGen)
6462
6468
Typ = ILGen.FieldType
6472
6478
Else
6473
6479
EmitLdcI8IL.Emit(OpCodes.Pop)
6474
6480
End If
6475
EmitLdcI8IL.MarkSequencePoint(doc3, 180, 1, 180, 100)
6481
EmitLdcI8IL.MarkSequencePoint(doc3, 183, 1, 183, 100)
6482
Dim typ45(-1) As Type
6483
EmitLdcI8IL.Emit(OpCodes.Ldstr, "conv.i8")
6484
Typ = GetType(System.String)
6485
ReDim Preserve typ45(UBound(typ45) + 1)
6486
typ45(UBound(typ45)) = Typ
6487
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ45))
6488
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ45).ReturnType
6489
EmitLdcI8IL.Emit(OpCodes.Stloc, 0)
6490
EmitLdcI8IL.MarkSequencePoint(doc3, 184, 1, 184, 100)
6491
Dim typ46(-1) As Type
6492
EmitLdcI8IL.Emit(OpCodes.Ldsfld, ILGen)
6493
Typ = ILGen.FieldType
6494
Typ03 = Typ
6495
EmitLdcI8IL.Emit(OpCodes.Ldloc, 0)
6496
Typ = GetType(OpCode)
6497
ReDim Preserve typ46(UBound(typ46) + 1)
6498
typ46(UBound(typ46)) = Typ
6499
EmitLdcI8IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ46))
6500
Typ = Typ03.GetMethod("Emit", typ46).ReturnType
6501
If Typ.ToString() = GetType(System.Void).ToString() Then
6502
6503
Else
6504
EmitLdcI8IL.Emit(OpCodes.Pop)
6505
End If
6506
EmitLdcI8IL.MarkSequencePoint(doc3, 185, 1, 185, 100)
6476
6507
EmitLdcI8IL.Emit(OpCodes.Br, label2)
6477
EmitLdcI8IL.MarkSequencePoint(doc3, 181, 1, 181, 100)
6508
EmitLdcI8IL.MarkSequencePoint(doc3, 186, 1, 186, 100)
6478
6509
EmitLdcI8IL.Emit(OpCodes.Br, cont175)
6479
6510
EmitLdcI8IL.MarkLabel(fa175)
6480
6511
EmitLdcI8IL.Emit(OpCodes.Br, cont175)
6481
6512
EmitLdcI8IL.MarkLabel(cont175)
6482
EmitLdcI8IL.MarkSequencePoint(doc3, 183, 1, 183, 100)
6513
EmitLdcI8IL.MarkSequencePoint(doc3, 188, 1, 188, 100)
6483
6514
EmitLdcI8IL.Emit(OpCodes.Ldarg, 0)
6484
6515
Typ = GetType(System.Int64)
6485
6516
EmitLdcI8IL.Emit(OpCodes.Ldc_I8, CLng(2))
6490
6521
EmitLdcI8IL.Emit(OpCodes.Beq, tru176)
6491
6522
EmitLdcI8IL.Emit(OpCodes.Br, fa176)
6492
6523
EmitLdcI8IL.MarkLabel(tru176)
6493
EmitLdcI8IL.MarkSequencePoint(doc3, 184, 1, 184, 100)
6494
Dim typ45(-1) As Type
6524
EmitLdcI8IL.MarkSequencePoint(doc3, 189, 1, 189, 100)
6525
Dim typ47(-1) As Type
6495
6526
EmitLdcI8IL.Emit(OpCodes.Ldstr, "ldc.i4.2")
6496
6527
Typ = GetType(System.String)
6497
ReDim Preserve typ45(UBound(typ45) + 1)
6498
typ45(UBound(typ45)) = Typ
6499
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ45))
6500
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ45).ReturnType
6501
EmitLdcI8IL.Emit(OpCodes.Stloc, 0)
6502
EmitLdcI8IL.MarkSequencePoint(doc3, 185, 1, 185, 100)
6503
Dim typ46(-1) As Type
6504
EmitLdcI8IL.Emit(OpCodes.Ldsfld, ILGen)
6505
Typ = ILGen.FieldType
6506
Typ03 = Typ
6507
EmitLdcI8IL.Emit(OpCodes.Ldloc, 0)
6508
Typ = GetType(OpCode)
6509
ReDim Preserve typ46(UBound(typ46) + 1)
6510
typ46(UBound(typ46)) = Typ
6511
EmitLdcI8IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ46))
6512
Typ = Typ03.GetMethod("Emit", typ46).ReturnType
6513
If Typ.ToString() = GetType(System.Void).ToString() Then
6514
6515
Else
6516
EmitLdcI8IL.Emit(OpCodes.Pop)
6517
End If
6518
EmitLdcI8IL.MarkSequencePoint(doc3, 186, 1, 186, 100)
6519
Dim typ47(-1) As Type
6520
EmitLdcI8IL.Emit(OpCodes.Ldstr, "conv.i8")
6521
Typ = GetType(System.String)
6522
6528
ReDim Preserve typ47(UBound(typ47) + 1)
6523
6529
typ47(UBound(typ47)) = Typ
6524
6530
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ47))
6525
6531
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ47).ReturnType
6526
6532
EmitLdcI8IL.Emit(OpCodes.Stloc, 0)
6527
EmitLdcI8IL.MarkSequencePoint(doc3, 187, 1, 187, 100)
6533
EmitLdcI8IL.MarkSequencePoint(doc3, 190, 1, 190, 100)
6528
6534
Dim typ48(-1) As Type
6529
6535
EmitLdcI8IL.Emit(OpCodes.Ldsfld, ILGen)
6530
6536
Typ = ILGen.FieldType
6540
6546
Else
6541
6547
EmitLdcI8IL.Emit(OpCodes.Pop)
6542
6548
End If
6543
EmitLdcI8IL.MarkSequencePoint(doc3, 188, 1, 188, 100)
6549
EmitLdcI8IL.MarkSequencePoint(doc3, 191, 1, 191, 100)
6550
Dim typ49(-1) As Type
6551
EmitLdcI8IL.Emit(OpCodes.Ldstr, "conv.i8")
6552
Typ = GetType(System.String)
6553
ReDim Preserve typ49(UBound(typ49) + 1)
6554
typ49(UBound(typ49)) = Typ
6555
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ49))
6556
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ49).ReturnType
6557
EmitLdcI8IL.Emit(OpCodes.Stloc, 0)
6558
EmitLdcI8IL.MarkSequencePoint(doc3, 192, 1, 192, 100)
6559
Dim typ50(-1) As Type
6560
EmitLdcI8IL.Emit(OpCodes.Ldsfld, ILGen)
6561
Typ = ILGen.FieldType
6562
Typ03 = Typ
6563
EmitLdcI8IL.Emit(OpCodes.Ldloc, 0)
6564
Typ = GetType(OpCode)
6565
ReDim Preserve typ50(UBound(typ50) + 1)
6566
typ50(UBound(typ50)) = Typ
6567
EmitLdcI8IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ50))
6568
Typ = Typ03.GetMethod("Emit", typ50).ReturnType
6569
If Typ.ToString() = GetType(System.Void).ToString() Then
6570
6571
Else
6572
EmitLdcI8IL.Emit(OpCodes.Pop)
6573
End If
6574
EmitLdcI8IL.MarkSequencePoint(doc3, 193, 1, 193, 100)
6544
6575
EmitLdcI8IL.Emit(OpCodes.Br, label2)
6545
EmitLdcI8IL.MarkSequencePoint(doc3, 189, 1, 189, 100)
6576
EmitLdcI8IL.MarkSequencePoint(doc3, 194, 1, 194, 100)
6546
6577
EmitLdcI8IL.Emit(OpCodes.Br, cont176)
6547
6578
EmitLdcI8IL.MarkLabel(fa176)
6548
6579
EmitLdcI8IL.Emit(OpCodes.Br, cont176)
6549
6580
EmitLdcI8IL.MarkLabel(cont176)
6550
EmitLdcI8IL.MarkSequencePoint(doc3, 191, 1, 191, 100)
6581
EmitLdcI8IL.MarkSequencePoint(doc3, 196, 1, 196, 100)
6551
6582
EmitLdcI8IL.Emit(OpCodes.Ldarg, 0)
6552
6583
Typ = GetType(System.Int64)
6553
6584
EmitLdcI8IL.Emit(OpCodes.Ldc_I8, CLng(3))
6558
6589
EmitLdcI8IL.Emit(OpCodes.Beq, tru177)
6559
6590
EmitLdcI8IL.Emit(OpCodes.Br, fa177)
6560
6591
EmitLdcI8IL.MarkLabel(tru177)
6561
EmitLdcI8IL.MarkSequencePoint(doc3, 192, 1, 192, 100)
6562
Dim typ49(-1) As Type
6592
EmitLdcI8IL.MarkSequencePoint(doc3, 197, 1, 197, 100)
6593
Dim typ51(-1) As Type
6563
6594
EmitLdcI8IL.Emit(OpCodes.Ldstr, "ldc.i4.3")
6564
6595
Typ = GetType(System.String)
6565
ReDim Preserve typ49(UBound(typ49) + 1)
6566
typ49(UBound(typ49)) = Typ
6567
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ49))
6568
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ49).ReturnType
6569
EmitLdcI8IL.Emit(OpCodes.Stloc, 0)
6570
EmitLdcI8IL.MarkSequencePoint(doc3, 193, 1, 193, 100)
6571
Dim typ50(-1) As Type
6572
EmitLdcI8IL.Emit(OpCodes.Ldsfld, ILGen)
6573
Typ = ILGen.FieldType
6574
Typ03 = Typ
6575
EmitLdcI8IL.Emit(OpCodes.Ldloc, 0)
6576
Typ = GetType(OpCode)
6577
ReDim Preserve typ50(UBound(typ50) + 1)
6578
typ50(UBound(typ50)) = Typ
6579
EmitLdcI8IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ50))
6580
Typ = Typ03.GetMethod("Emit", typ50).ReturnType
6581
If Typ.ToString() = GetType(System.Void).ToString() Then
6582
6583
Else
6584
EmitLdcI8IL.Emit(OpCodes.Pop)
6585
End If
6586
EmitLdcI8IL.MarkSequencePoint(doc3, 194, 1, 194, 100)
6587
Dim typ51(-1) As Type
6588
EmitLdcI8IL.Emit(OpCodes.Ldstr, "conv.i8")
6589
Typ = GetType(System.String)
6590
6596
ReDim Preserve typ51(UBound(typ51) + 1)
6591
6597
typ51(UBound(typ51)) = Typ
6592
6598
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ51))
6593
6599
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ51).ReturnType
6594
6600
EmitLdcI8IL.Emit(OpCodes.Stloc, 0)
6595
EmitLdcI8IL.MarkSequencePoint(doc3, 195, 1, 195, 100)
6601
EmitLdcI8IL.MarkSequencePoint(doc3, 198, 1, 198, 100)
6596
6602
Dim typ52(-1) As Type
6597
6603
EmitLdcI8IL.Emit(OpCodes.Ldsfld, ILGen)
6598
6604
Typ = ILGen.FieldType
6608
6614
Else
6609
6615
EmitLdcI8IL.Emit(OpCodes.Pop)
6610
6616
End If
6611
EmitLdcI8IL.MarkSequencePoint(doc3, 196, 1, 196, 100)
6617
EmitLdcI8IL.MarkSequencePoint(doc3, 199, 1, 199, 100)
6618
Dim typ53(-1) As Type
6619
EmitLdcI8IL.Emit(OpCodes.Ldstr, "conv.i8")
6620
Typ = GetType(System.String)
6621
ReDim Preserve typ53(UBound(typ53) + 1)
6622
typ53(UBound(typ53)) = Typ
6623
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ53))
6624
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ53).ReturnType
6625
EmitLdcI8IL.Emit(OpCodes.Stloc, 0)
6626
EmitLdcI8IL.MarkSequencePoint(doc3, 200, 1, 200, 100)
6627
Dim typ54(-1) As Type
6628
EmitLdcI8IL.Emit(OpCodes.Ldsfld, ILGen)
6629
Typ = ILGen.FieldType
6630
Typ03 = Typ
6631
EmitLdcI8IL.Emit(OpCodes.Ldloc, 0)
6632
Typ = GetType(OpCode)
6633
ReDim Preserve typ54(UBound(typ54) + 1)
6634
typ54(UBound(typ54)) = Typ
6635
EmitLdcI8IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ54))
6636
Typ = Typ03.GetMethod("Emit", typ54).ReturnType
6637
If Typ.ToString() = GetType(System.Void).ToString() Then
6638
6639
Else
6640
EmitLdcI8IL.Emit(OpCodes.Pop)
6641
End If
6642
EmitLdcI8IL.MarkSequencePoint(doc3, 201, 1, 201, 100)
6612
6643
EmitLdcI8IL.Emit(OpCodes.Br, label2)
6613
EmitLdcI8IL.MarkSequencePoint(doc3, 197, 1, 197, 100)
6644
EmitLdcI8IL.MarkSequencePoint(doc3, 202, 1, 202, 100)
6614
6645
EmitLdcI8IL.Emit(OpCodes.Br, cont177)
6615
6646
EmitLdcI8IL.MarkLabel(fa177)
6616
6647
EmitLdcI8IL.Emit(OpCodes.Br, cont177)
6617
6648
EmitLdcI8IL.MarkLabel(cont177)
6618
EmitLdcI8IL.MarkSequencePoint(doc3, 199, 1, 199, 100)
6649
EmitLdcI8IL.MarkSequencePoint(doc3, 204, 1, 204, 100)
6619
6650
EmitLdcI8IL.Emit(OpCodes.Ldarg, 0)
6620
6651
Typ = GetType(System.Int64)
6621
6652
EmitLdcI8IL.Emit(OpCodes.Ldc_I8, CLng(4))
6626
6657
EmitLdcI8IL.Emit(OpCodes.Beq, tru178)
6627
6658
EmitLdcI8IL.Emit(OpCodes.Br, fa178)
6628
6659
EmitLdcI8IL.MarkLabel(tru178)
6629
EmitLdcI8IL.MarkSequencePoint(doc3, 200, 1, 200, 100)
6630
Dim typ53(-1) As Type
6660
EmitLdcI8IL.MarkSequencePoint(doc3, 205, 1, 205, 100)
6661
Dim typ55(-1) As Type
6631
6662
EmitLdcI8IL.Emit(OpCodes.Ldstr, "ldc.i4.4")
6632
6663
Typ = GetType(System.String)
6633
ReDim Preserve typ53(UBound(typ53) + 1)
6634
typ53(UBound(typ53)) = Typ
6635
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ53))
6636
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ53).ReturnType
6637
EmitLdcI8IL.Emit(OpCodes.Stloc, 0)
6638
EmitLdcI8IL.MarkSequencePoint(doc3, 201, 1, 201, 100)
6639
Dim typ54(-1) As Type
6640
EmitLdcI8IL.Emit(OpCodes.Ldsfld, ILGen)
6641
Typ = ILGen.FieldType
6642
Typ03 = Typ
6643
EmitLdcI8IL.Emit(OpCodes.Ldloc, 0)
6644
Typ = GetType(OpCode)
6645
ReDim Preserve typ54(UBound(typ54) + 1)
6646
typ54(UBound(typ54)) = Typ
6647
EmitLdcI8IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ54))
6648
Typ = Typ03.GetMethod("Emit", typ54).ReturnType
6649
If Typ.ToString() = GetType(System.Void).ToString() Then
6650
6651
Else
6652
EmitLdcI8IL.Emit(OpCodes.Pop)
6653
End If
6654
EmitLdcI8IL.MarkSequencePoint(doc3, 202, 1, 202, 100)
6655
Dim typ55(-1) As Type
6656
EmitLdcI8IL.Emit(OpCodes.Ldstr, "conv.i8")
6657
Typ = GetType(System.String)
6658
6664
ReDim Preserve typ55(UBound(typ55) + 1)
6659
6665
typ55(UBound(typ55)) = Typ
6660
6666
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ55))
6661
6667
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ55).ReturnType
6662
6668
EmitLdcI8IL.Emit(OpCodes.Stloc, 0)
6663
EmitLdcI8IL.MarkSequencePoint(doc3, 203, 1, 203, 100)
6669
EmitLdcI8IL.MarkSequencePoint(doc3, 206, 1, 206, 100)
6664
6670
Dim typ56(-1) As Type
6665
6671
EmitLdcI8IL.Emit(OpCodes.Ldsfld, ILGen)
6666
6672
Typ = ILGen.FieldType
6676
6682
Else
6677
6683
EmitLdcI8IL.Emit(OpCodes.Pop)
6678
6684
End If
6679
EmitLdcI8IL.MarkSequencePoint(doc3, 204, 1, 204, 100)
6685
EmitLdcI8IL.MarkSequencePoint(doc3, 207, 1, 207, 100)
6686
Dim typ57(-1) As Type
6687
EmitLdcI8IL.Emit(OpCodes.Ldstr, "conv.i8")
6688
Typ = GetType(System.String)
6689
ReDim Preserve typ57(UBound(typ57) + 1)
6690
typ57(UBound(typ57)) = Typ
6691
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ57))
6692
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ57).ReturnType
6693
EmitLdcI8IL.Emit(OpCodes.Stloc, 0)
6694
EmitLdcI8IL.MarkSequencePoint(doc3, 208, 1, 208, 100)
6695
Dim typ58(-1) As Type
6696
EmitLdcI8IL.Emit(OpCodes.Ldsfld, ILGen)
6697
Typ = ILGen.FieldType
6698
Typ03 = Typ
6699
EmitLdcI8IL.Emit(OpCodes.Ldloc, 0)
6700
Typ = GetType(OpCode)
6701
ReDim Preserve typ58(UBound(typ58) + 1)
6702
typ58(UBound(typ58)) = Typ
6703
EmitLdcI8IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ58))
6704
Typ = Typ03.GetMethod("Emit", typ58).ReturnType
6705
If Typ.ToString() = GetType(System.Void).ToString() Then
6706
6707
Else
6708
EmitLdcI8IL.Emit(OpCodes.Pop)
6709
End If
6710
EmitLdcI8IL.MarkSequencePoint(doc3, 209, 1, 209, 100)
6680
6711
EmitLdcI8IL.Emit(OpCodes.Br, label2)
6681
EmitLdcI8IL.MarkSequencePoint(doc3, 205, 1, 205, 100)
6712
EmitLdcI8IL.MarkSequencePoint(doc3, 210, 1, 210, 100)
6682
6713
EmitLdcI8IL.Emit(OpCodes.Br, cont178)
6683
6714
EmitLdcI8IL.MarkLabel(fa178)
6684
6715
EmitLdcI8IL.Emit(OpCodes.Br, cont178)
6685
6716
EmitLdcI8IL.MarkLabel(cont178)
6686
EmitLdcI8IL.MarkSequencePoint(doc3, 207, 1, 207, 100)
6717
EmitLdcI8IL.MarkSequencePoint(doc3, 212, 1, 212, 100)
6687
6718
EmitLdcI8IL.Emit(OpCodes.Ldarg, 0)
6688
6719
Typ = GetType(System.Int64)
6689
6720
EmitLdcI8IL.Emit(OpCodes.Ldc_I8, CLng(5))
6694
6725
EmitLdcI8IL.Emit(OpCodes.Beq, tru179)
6695
6726
EmitLdcI8IL.Emit(OpCodes.Br, fa179)
6696
6727
EmitLdcI8IL.MarkLabel(tru179)
6697
EmitLdcI8IL.MarkSequencePoint(doc3, 208, 1, 208, 100)
6698
Dim typ57(-1) As Type
6728
EmitLdcI8IL.MarkSequencePoint(doc3, 213, 1, 213, 100)
6729
Dim typ59(-1) As Type
6699
6730
EmitLdcI8IL.Emit(OpCodes.Ldstr, "ldc.i4.5")
6700
6731
Typ = GetType(System.String)
6701
ReDim Preserve typ57(UBound(typ57) + 1)
6702
typ57(UBound(typ57)) = Typ
6703
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ57))
6704
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ57).ReturnType
6705
EmitLdcI8IL.Emit(OpCodes.Stloc, 0)
6706
EmitLdcI8IL.MarkSequencePoint(doc3, 209, 1, 209, 100)
6707
Dim typ58(-1) As Type
6708
EmitLdcI8IL.Emit(OpCodes.Ldsfld, ILGen)
6709
Typ = ILGen.FieldType
6710
Typ03 = Typ
6711
EmitLdcI8IL.Emit(OpCodes.Ldloc, 0)
6712
Typ = GetType(OpCode)
6713
ReDim Preserve typ58(UBound(typ58) + 1)
6714
typ58(UBound(typ58)) = Typ
6715
EmitLdcI8IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ58))
6716
Typ = Typ03.GetMethod("Emit", typ58).ReturnType
6717
If Typ.ToString() = GetType(System.Void).ToString() Then
6718
6719
Else
6720
EmitLdcI8IL.Emit(OpCodes.Pop)
6721
End If
6722
EmitLdcI8IL.MarkSequencePoint(doc3, 210, 1, 210, 100)
6723
Dim typ59(-1) As Type
6724
EmitLdcI8IL.Emit(OpCodes.Ldstr, "conv.i8")
6725
Typ = GetType(System.String)
6726
6732
ReDim Preserve typ59(UBound(typ59) + 1)
6727
6733
typ59(UBound(typ59)) = Typ
6728
6734
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ59))
6729
6735
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ59).ReturnType
6730
6736
EmitLdcI8IL.Emit(OpCodes.Stloc, 0)
6731
EmitLdcI8IL.MarkSequencePoint(doc3, 211, 1, 211, 100)
6737
EmitLdcI8IL.MarkSequencePoint(doc3, 214, 1, 214, 100)
6732
6738
Dim typ60(-1) As Type
6733
6739
EmitLdcI8IL.Emit(OpCodes.Ldsfld, ILGen)
6734
6740
Typ = ILGen.FieldType
6744
6750
Else
6745
6751
EmitLdcI8IL.Emit(OpCodes.Pop)
6746
6752
End If
6747
EmitLdcI8IL.MarkSequencePoint(doc3, 212, 1, 212, 100)
6753
EmitLdcI8IL.MarkSequencePoint(doc3, 215, 1, 215, 100)
6754
Dim typ61(-1) As Type
6755
EmitLdcI8IL.Emit(OpCodes.Ldstr, "conv.i8")
6756
Typ = GetType(System.String)
6757
ReDim Preserve typ61(UBound(typ61) + 1)
6758
typ61(UBound(typ61)) = Typ
6759
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ61))
6760
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ61).ReturnType
6761
EmitLdcI8IL.Emit(OpCodes.Stloc, 0)
6762
EmitLdcI8IL.MarkSequencePoint(doc3, 216, 1, 216, 100)
6763
Dim typ62(-1) As Type
6764
EmitLdcI8IL.Emit(OpCodes.Ldsfld, ILGen)
6765
Typ = ILGen.FieldType
6766
Typ03 = Typ
6767
EmitLdcI8IL.Emit(OpCodes.Ldloc, 0)
6768
Typ = GetType(OpCode)
6769
ReDim Preserve typ62(UBound(typ62) + 1)
6770
typ62(UBound(typ62)) = Typ
6771
EmitLdcI8IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ62))
6772
Typ = Typ03.GetMethod("Emit", typ62).ReturnType
6773
If Typ.ToString() = GetType(System.Void).ToString() Then
6774
6775
Else
6776
EmitLdcI8IL.Emit(OpCodes.Pop)
6777
End If
6778
EmitLdcI8IL.MarkSequencePoint(doc3, 217, 1, 217, 100)
6748
6779
EmitLdcI8IL.Emit(OpCodes.Br, label2)
6749
EmitLdcI8IL.MarkSequencePoint(doc3, 213, 1, 213, 100)
6780
EmitLdcI8IL.MarkSequencePoint(doc3, 218, 1, 218, 100)
6750
6781
EmitLdcI8IL.Emit(OpCodes.Br, cont179)
6751
6782
EmitLdcI8IL.MarkLabel(fa179)
6752
6783
EmitLdcI8IL.Emit(OpCodes.Br, cont179)
6753
6784
EmitLdcI8IL.MarkLabel(cont179)
6754
EmitLdcI8IL.MarkSequencePoint(doc3, 215, 1, 215, 100)
6785
EmitLdcI8IL.MarkSequencePoint(doc3, 220, 1, 220, 100)
6755
6786
EmitLdcI8IL.Emit(OpCodes.Ldarg, 0)
6756
6787
Typ = GetType(System.Int64)
6757
6788
EmitLdcI8IL.Emit(OpCodes.Ldc_I8, CLng(6))
6762
6793
EmitLdcI8IL.Emit(OpCodes.Beq, tru180)
6763
6794
EmitLdcI8IL.Emit(OpCodes.Br, fa180)
6764
6795
EmitLdcI8IL.MarkLabel(tru180)
6765
EmitLdcI8IL.MarkSequencePoint(doc3, 216, 1, 216, 100)
6766
Dim typ61(-1) As Type
6796
EmitLdcI8IL.MarkSequencePoint(doc3, 221, 1, 221, 100)
6797
Dim typ63(-1) As Type
6767
6798
EmitLdcI8IL.Emit(OpCodes.Ldstr, "ldc.i4.6")
6768
6799
Typ = GetType(System.String)
6769
ReDim Preserve typ61(UBound(typ61) + 1)
6770
typ61(UBound(typ61)) = Typ
6771
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ61))
6772
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ61).ReturnType
6773
EmitLdcI8IL.Emit(OpCodes.Stloc, 0)
6774
EmitLdcI8IL.MarkSequencePoint(doc3, 217, 1, 217, 100)
6775
Dim typ62(-1) As Type
6776
EmitLdcI8IL.Emit(OpCodes.Ldsfld, ILGen)
6777
Typ = ILGen.FieldType
6778
Typ03 = Typ
6779
EmitLdcI8IL.Emit(OpCodes.Ldloc, 0)
6780
Typ = GetType(OpCode)
6781
ReDim Preserve typ62(UBound(typ62) + 1)
6782
typ62(UBound(typ62)) = Typ
6783
EmitLdcI8IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ62))
6784
Typ = Typ03.GetMethod("Emit", typ62).ReturnType
6785
If Typ.ToString() = GetType(System.Void).ToString() Then
6786
6787
Else
6788
EmitLdcI8IL.Emit(OpCodes.Pop)
6789
End If
6790
EmitLdcI8IL.MarkSequencePoint(doc3, 218, 1, 218, 100)
6791
Dim typ63(-1) As Type
6792
EmitLdcI8IL.Emit(OpCodes.Ldstr, "conv.i8")
6793
Typ = GetType(System.String)
6794
6800
ReDim Preserve typ63(UBound(typ63) + 1)
6795
6801
typ63(UBound(typ63)) = Typ
6796
6802
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ63))
6797
6803
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ63).ReturnType
6798
6804
EmitLdcI8IL.Emit(OpCodes.Stloc, 0)
6799
EmitLdcI8IL.MarkSequencePoint(doc3, 219, 1, 219, 100)
6805
EmitLdcI8IL.MarkSequencePoint(doc3, 222, 1, 222, 100)
6800
6806
Dim typ64(-1) As Type
6801
6807
EmitLdcI8IL.Emit(OpCodes.Ldsfld, ILGen)
6802
6808
Typ = ILGen.FieldType
6812
6818
Else
6813
6819
EmitLdcI8IL.Emit(OpCodes.Pop)
6814
6820
End If
6815
EmitLdcI8IL.MarkSequencePoint(doc3, 220, 1, 220, 100)
6821
EmitLdcI8IL.MarkSequencePoint(doc3, 223, 1, 223, 100)
6822
Dim typ65(-1) As Type
6823
EmitLdcI8IL.Emit(OpCodes.Ldstr, "conv.i8")
6824
Typ = GetType(System.String)
6825
ReDim Preserve typ65(UBound(typ65) + 1)
6826
typ65(UBound(typ65)) = Typ
6827
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ65))
6828
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ65).ReturnType
6829
EmitLdcI8IL.Emit(OpCodes.Stloc, 0)
6830
EmitLdcI8IL.MarkSequencePoint(doc3, 224, 1, 224, 100)
6831
Dim typ66(-1) As Type
6832
EmitLdcI8IL.Emit(OpCodes.Ldsfld, ILGen)
6833
Typ = ILGen.FieldType
6834
Typ03 = Typ
6835
EmitLdcI8IL.Emit(OpCodes.Ldloc, 0)
6836
Typ = GetType(OpCode)
6837
ReDim Preserve typ66(UBound(typ66) + 1)
6838
typ66(UBound(typ66)) = Typ
6839
EmitLdcI8IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ66))
6840
Typ = Typ03.GetMethod("Emit", typ66).ReturnType
6841
If Typ.ToString() = GetType(System.Void).ToString() Then
6842
6843
Else
6844
EmitLdcI8IL.Emit(OpCodes.Pop)
6845
End If
6846
EmitLdcI8IL.MarkSequencePoint(doc3, 225, 1, 225, 100)
6816
6847
EmitLdcI8IL.Emit(OpCodes.Br, label2)
6817
EmitLdcI8IL.MarkSequencePoint(doc3, 221, 1, 221, 100)
6848
EmitLdcI8IL.MarkSequencePoint(doc3, 226, 1, 226, 100)
6818
6849
EmitLdcI8IL.Emit(OpCodes.Br, cont180)
6819
6850
EmitLdcI8IL.MarkLabel(fa180)
6820
6851
EmitLdcI8IL.Emit(OpCodes.Br, cont180)
6821
6852
EmitLdcI8IL.MarkLabel(cont180)
6822
EmitLdcI8IL.MarkSequencePoint(doc3, 223, 1, 223, 100)
6853
EmitLdcI8IL.MarkSequencePoint(doc3, 228, 1, 228, 100)
6823
6854
EmitLdcI8IL.Emit(OpCodes.Ldarg, 0)
6824
6855
Typ = GetType(System.Int64)
6825
6856
EmitLdcI8IL.Emit(OpCodes.Ldc_I8, CLng(7))
6830
6861
EmitLdcI8IL.Emit(OpCodes.Beq, tru181)
6831
6862
EmitLdcI8IL.Emit(OpCodes.Br, fa181)
6832
6863
EmitLdcI8IL.MarkLabel(tru181)
6833
EmitLdcI8IL.MarkSequencePoint(doc3, 224, 1, 224, 100)
6834
Dim typ65(-1) As Type
6864
EmitLdcI8IL.MarkSequencePoint(doc3, 229, 1, 229, 100)
6865
Dim typ67(-1) As Type
6835
6866
EmitLdcI8IL.Emit(OpCodes.Ldstr, "ldc.i4.7")
6836
6867
Typ = GetType(System.String)
6837
ReDim Preserve typ65(UBound(typ65) + 1)
6838
typ65(UBound(typ65)) = Typ
6839
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ65))
6840
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ65).ReturnType
6841
EmitLdcI8IL.Emit(OpCodes.Stloc, 0)
6842
EmitLdcI8IL.MarkSequencePoint(doc3, 225, 1, 225, 100)
6843
Dim typ66(-1) As Type
6844
EmitLdcI8IL.Emit(OpCodes.Ldsfld, ILGen)
6845
Typ = ILGen.FieldType
6846
Typ03 = Typ
6847
EmitLdcI8IL.Emit(OpCodes.Ldloc, 0)
6848
Typ = GetType(OpCode)
6849
ReDim Preserve typ66(UBound(typ66) + 1)
6850
typ66(UBound(typ66)) = Typ
6851
EmitLdcI8IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ66))
6852
Typ = Typ03.GetMethod("Emit", typ66).ReturnType
6853
If Typ.ToString() = GetType(System.Void).ToString() Then
6854
6855
Else
6856
EmitLdcI8IL.Emit(OpCodes.Pop)
6857
End If
6858
EmitLdcI8IL.MarkSequencePoint(doc3, 226, 1, 226, 100)
6859
Dim typ67(-1) As Type
6860
EmitLdcI8IL.Emit(OpCodes.Ldstr, "conv.i8")
6861
Typ = GetType(System.String)
6862
6868
ReDim Preserve typ67(UBound(typ67) + 1)
6863
6869
typ67(UBound(typ67)) = Typ
6864
6870
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ67))
6865
6871
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ67).ReturnType
6866
6872
EmitLdcI8IL.Emit(OpCodes.Stloc, 0)
6867
EmitLdcI8IL.MarkSequencePoint(doc3, 227, 1, 227, 100)
6873
EmitLdcI8IL.MarkSequencePoint(doc3, 230, 1, 230, 100)
6868
6874
Dim typ68(-1) As Type
6869
6875
EmitLdcI8IL.Emit(OpCodes.Ldsfld, ILGen)
6870
6876
Typ = ILGen.FieldType
6880
6886
Else
6881
6887
EmitLdcI8IL.Emit(OpCodes.Pop)
6882
6888
End If
6883
EmitLdcI8IL.MarkSequencePoint(doc3, 228, 1, 228, 100)
6889
EmitLdcI8IL.MarkSequencePoint(doc3, 231, 1, 231, 100)
6890
Dim typ69(-1) As Type
6891
EmitLdcI8IL.Emit(OpCodes.Ldstr, "conv.i8")
6892
Typ = GetType(System.String)
6893
ReDim Preserve typ69(UBound(typ69) + 1)
6894
typ69(UBound(typ69)) = Typ
6895
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ69))
6896
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ69).ReturnType
6897
EmitLdcI8IL.Emit(OpCodes.Stloc, 0)
6898
EmitLdcI8IL.MarkSequencePoint(doc3, 232, 1, 232, 100)
6899
Dim typ70(-1) As Type
6900
EmitLdcI8IL.Emit(OpCodes.Ldsfld, ILGen)
6901
Typ = ILGen.FieldType
6902
Typ03 = Typ
6903
EmitLdcI8IL.Emit(OpCodes.Ldloc, 0)
6904
Typ = GetType(OpCode)
6905
ReDim Preserve typ70(UBound(typ70) + 1)
6906
typ70(UBound(typ70)) = Typ
6907
EmitLdcI8IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ70))
6908
Typ = Typ03.GetMethod("Emit", typ70).ReturnType
6909
If Typ.ToString() = GetType(System.Void).ToString() Then
6910
6911
Else
6912
EmitLdcI8IL.Emit(OpCodes.Pop)
6913
End If
6914
EmitLdcI8IL.MarkSequencePoint(doc3, 233, 1, 233, 100)
6884
6915
EmitLdcI8IL.Emit(OpCodes.Br, label2)
6885
EmitLdcI8IL.MarkSequencePoint(doc3, 229, 1, 229, 100)
6916
EmitLdcI8IL.MarkSequencePoint(doc3, 234, 1, 234, 100)
6886
6917
EmitLdcI8IL.Emit(OpCodes.Br, cont181)
6887
6918
EmitLdcI8IL.MarkLabel(fa181)
6888
6919
EmitLdcI8IL.Emit(OpCodes.Br, cont181)
6889
6920
EmitLdcI8IL.MarkLabel(cont181)
6890
EmitLdcI8IL.MarkSequencePoint(doc3, 231, 1, 231, 100)
6921
EmitLdcI8IL.MarkSequencePoint(doc3, 236, 1, 236, 100)
6891
6922
EmitLdcI8IL.Emit(OpCodes.Ldarg, 0)
6892
6923
Typ = GetType(System.Int64)
6893
6924
EmitLdcI8IL.Emit(OpCodes.Ldc_I8, CLng(8))
6898
6929
EmitLdcI8IL.Emit(OpCodes.Beq, tru182)
6899
6930
EmitLdcI8IL.Emit(OpCodes.Br, fa182)
6900
6931
EmitLdcI8IL.MarkLabel(tru182)
6901
EmitLdcI8IL.MarkSequencePoint(doc3, 232, 1, 232, 100)
6902
Dim typ69(-1) As Type
6932
EmitLdcI8IL.MarkSequencePoint(doc3, 237, 1, 237, 100)
6933
Dim typ71(-1) As Type
6903
6934
EmitLdcI8IL.Emit(OpCodes.Ldstr, "ldc.i4.8")
6904
6935
Typ = GetType(System.String)
6905
ReDim Preserve typ69(UBound(typ69) + 1)
6906
typ69(UBound(typ69)) = Typ
6907
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ69))
6908
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ69).ReturnType
6909
EmitLdcI8IL.Emit(OpCodes.Stloc, 0)
6910
EmitLdcI8IL.MarkSequencePoint(doc3, 233, 1, 233, 100)
6911
Dim typ70(-1) As Type
6912
EmitLdcI8IL.Emit(OpCodes.Ldsfld, ILGen)
6913
Typ = ILGen.FieldType
6914
Typ03 = Typ
6915
EmitLdcI8IL.Emit(OpCodes.Ldloc, 0)
6916
Typ = GetType(OpCode)
6917
ReDim Preserve typ70(UBound(typ70) + 1)
6918
typ70(UBound(typ70)) = Typ
6919
EmitLdcI8IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ70))
6920
Typ = Typ03.GetMethod("Emit", typ70).ReturnType
6921
If Typ.ToString() = GetType(System.Void).ToString() Then
6922
6923
Else
6924
EmitLdcI8IL.Emit(OpCodes.Pop)
6925
End If
6926
EmitLdcI8IL.MarkSequencePoint(doc3, 234, 1, 234, 100)
6927
Dim typ71(-1) As Type
6928
EmitLdcI8IL.Emit(OpCodes.Ldstr, "conv.i8")
6929
Typ = GetType(System.String)
6930
6936
ReDim Preserve typ71(UBound(typ71) + 1)
6931
6937
typ71(UBound(typ71)) = Typ
6932
6938
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ71))
6933
6939
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ71).ReturnType
6934
6940
EmitLdcI8IL.Emit(OpCodes.Stloc, 0)
6935
EmitLdcI8IL.MarkSequencePoint(doc3, 235, 1, 235, 100)
6941
EmitLdcI8IL.MarkSequencePoint(doc3, 238, 1, 238, 100)
6936
6942
Dim typ72(-1) As Type
6937
6943
EmitLdcI8IL.Emit(OpCodes.Ldsfld, ILGen)
6938
6944
Typ = ILGen.FieldType
6948
6954
Else
6949
6955
EmitLdcI8IL.Emit(OpCodes.Pop)
6950
6956
End If
6951
EmitLdcI8IL.MarkSequencePoint(doc3, 236, 1, 236, 100)
6957
EmitLdcI8IL.MarkSequencePoint(doc3, 239, 1, 239, 100)
6958
Dim typ73(-1) As Type
6959
EmitLdcI8IL.Emit(OpCodes.Ldstr, "conv.i8")
6960
Typ = GetType(System.String)
6961
ReDim Preserve typ73(UBound(typ73) + 1)
6962
typ73(UBound(typ73)) = Typ
6963
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ73))
6964
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ73).ReturnType
6965
EmitLdcI8IL.Emit(OpCodes.Stloc, 0)
6966
EmitLdcI8IL.MarkSequencePoint(doc3, 240, 1, 240, 100)
6967
Dim typ74(-1) As Type
6968
EmitLdcI8IL.Emit(OpCodes.Ldsfld, ILGen)
6969
Typ = ILGen.FieldType
6970
Typ03 = Typ
6971
EmitLdcI8IL.Emit(OpCodes.Ldloc, 0)
6972
Typ = GetType(OpCode)
6973
ReDim Preserve typ74(UBound(typ74) + 1)
6974
typ74(UBound(typ74)) = Typ
6975
EmitLdcI8IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ74))
6976
Typ = Typ03.GetMethod("Emit", typ74).ReturnType
6977
If Typ.ToString() = GetType(System.Void).ToString() Then
6978
6979
Else
6980
EmitLdcI8IL.Emit(OpCodes.Pop)
6981
End If
6982
EmitLdcI8IL.MarkSequencePoint(doc3, 241, 1, 241, 100)
6952
6983
EmitLdcI8IL.Emit(OpCodes.Br, label2)
6953
EmitLdcI8IL.MarkSequencePoint(doc3, 237, 1, 237, 100)
6984
EmitLdcI8IL.MarkSequencePoint(doc3, 242, 1, 242, 100)
6954
6985
EmitLdcI8IL.Emit(OpCodes.Br, cont182)
6955
6986
EmitLdcI8IL.MarkLabel(fa182)
6956
6987
EmitLdcI8IL.Emit(OpCodes.Br, cont182)
6957
6988
EmitLdcI8IL.MarkLabel(cont182)
6958
EmitLdcI8IL.MarkSequencePoint(doc3, 239, 1, 239, 100)
6989
EmitLdcI8IL.MarkSequencePoint(doc3, 244, 1, 244, 100)
6959
6990
EmitLdcI8IL.Emit(OpCodes.Ldarg, 0)
6960
6991
Typ = GetType(System.Int64)
6961
6992
EmitLdcI8IL.Emit(OpCodes.Ldc_I8, CLng(-2147483648))
6966
6997
EmitLdcI8IL.Emit(OpCodes.Bge, tru183)
6967
6998
EmitLdcI8IL.Emit(OpCodes.Br, fa183)
6968
6999
EmitLdcI8IL.MarkLabel(tru183)
6969
EmitLdcI8IL.MarkSequencePoint(doc3, 240, 1, 240, 100)
7000
EmitLdcI8IL.MarkSequencePoint(doc3, 245, 1, 245, 100)
6970
7001
EmitLdcI8IL.Emit(OpCodes.Ldc_I4, 1)
6971
7002
Typ = GetType(System.Boolean)
6972
7003
EmitLdcI8IL.Emit(OpCodes.Stloc, 1)
6973
EmitLdcI8IL.MarkSequencePoint(doc3, 241, 1, 241, 100)
7004
EmitLdcI8IL.MarkSequencePoint(doc3, 246, 1, 246, 100)
6974
7005
EmitLdcI8IL.Emit(OpCodes.Br, cont183)
6975
7006
EmitLdcI8IL.MarkLabel(fa183)
6976
7007
EmitLdcI8IL.Emit(OpCodes.Br, cont183)
6977
7008
EmitLdcI8IL.MarkLabel(cont183)
6978
EmitLdcI8IL.MarkSequencePoint(doc3, 242, 1, 242, 100)
7009
EmitLdcI8IL.MarkSequencePoint(doc3, 247, 1, 247, 100)
6979
7010
EmitLdcI8IL.Emit(OpCodes.Ldarg, 0)
6980
7011
Typ = GetType(System.Int64)
6981
7012
EmitLdcI8IL.Emit(OpCodes.Ldc_I8, CLng(2147483647))
6986
7017
EmitLdcI8IL.Emit(OpCodes.Ble, tru184)
6987
7018
EmitLdcI8IL.Emit(OpCodes.Br, fa184)
6988
7019
EmitLdcI8IL.MarkLabel(tru184)
6989
EmitLdcI8IL.MarkSequencePoint(doc3, 243, 1, 243, 100)
7020
EmitLdcI8IL.MarkSequencePoint(doc3, 248, 1, 248, 100)
6990
7021
EmitLdcI8IL.Emit(OpCodes.Ldc_I4, 1)
6991
7022
Typ = GetType(System.Boolean)
6992
7023
EmitLdcI8IL.Emit(OpCodes.Stloc, 2)
6993
EmitLdcI8IL.MarkSequencePoint(doc3, 244, 1, 244, 100)
7024
EmitLdcI8IL.MarkSequencePoint(doc3, 249, 1, 249, 100)
6994
7025
EmitLdcI8IL.Emit(OpCodes.Br, cont184)
6995
7026
EmitLdcI8IL.MarkLabel(fa184)
6996
7027
EmitLdcI8IL.Emit(OpCodes.Br, cont184)
6997
7028
EmitLdcI8IL.MarkLabel(cont184)
6998
EmitLdcI8IL.MarkSequencePoint(doc3, 245, 1, 245, 100)
7029
EmitLdcI8IL.MarkSequencePoint(doc3, 250, 1, 250, 100)
6999
7030
EmitLdcI8IL.Emit(OpCodes.Ldloc, 1)
7000
7031
Typ = GetType(System.Boolean)
7001
7032
EmitLdcI8IL.Emit(OpCodes.Ldloc, 2)
7002
7033
Typ = GetType(System.Boolean)
7003
7034
EmitLdcI8IL.Emit(OpCodes.And)
7004
7035
EmitLdcI8IL.Emit(OpCodes.Stloc, 2)
7005
EmitLdcI8IL.MarkSequencePoint(doc3, 247, 1, 247, 100)
7036
EmitLdcI8IL.MarkSequencePoint(doc3, 252, 1, 252, 100)
7006
7037
EmitLdcI8IL.Emit(OpCodes.Ldloc, 2)
7007
7038
Typ = GetType(System.Boolean)
7008
7039
EmitLdcI8IL.Emit(OpCodes.Ldc_I4, 1)
7013
7044
EmitLdcI8IL.Emit(OpCodes.Beq, tru185)
7014
7045
EmitLdcI8IL.Emit(OpCodes.Br, fa185)
7015
7046
EmitLdcI8IL.MarkLabel(tru185)
7016
EmitLdcI8IL.MarkSequencePoint(doc3, 248, 1, 248, 100)
7017
Dim typ73(-1) As Type
7047
EmitLdcI8IL.MarkSequencePoint(doc3, 253, 1, 253, 100)
7048
Dim typ75(-1) As Type
7018
7049
EmitLdcI8IL.Emit(OpCodes.Ldstr, "ldc.i4")
7019
7050
Typ = GetType(System.String)
7020
ReDim Preserve typ73(UBound(typ73) + 1)
7021
typ73(UBound(typ73)) = Typ
7022
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ73))
7023
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ73).ReturnType
7051
ReDim Preserve typ75(UBound(typ75) + 1)
7052
typ75(UBound(typ75)) = Typ
7053
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ75))
7054
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ75).ReturnType
7024
7055
EmitLdcI8IL.Emit(OpCodes.Stloc, 0)
7025
EmitLdcI8IL.MarkSequencePoint(doc3, 249, 1, 249, 100)
7026
Dim locbldr16 As LocalBuilder = EmitLdcI8IL.DeclareLocal(GetType(System.Int32))
7027
locbldr16.SetLocalSymInfo("num")
7056
EmitLdcI8IL.MarkSequencePoint(doc3, 254, 1, 254, 100)
7057
Dim locbldr17 As LocalBuilder = EmitLdcI8IL.DeclareLocal(GetType(System.Int32))
7058
locbldr17.SetLocalSymInfo("num")
7028
7059
EmitLdcI8IL.Emit(OpCodes.Ldarg, 0)
7029
7060
Typ = GetType(System.Int64)
7030
Dim typ74 As Type() = {Typ}
7031
EmitLdcI8IL.Emit(OpCodes.Call, GetType(System.Convert).GetMethod("ToInt32", typ74))
7032
Typ = GetType(System.Convert).GetMethod("ToInt32", typ74).ReturnType
7061
Dim typ76 As Type() = {Typ}
7062
EmitLdcI8IL.Emit(OpCodes.Call, GetType(System.Convert).GetMethod("ToInt32", typ76))
7063
Typ = GetType(System.Convert).GetMethod("ToInt32", typ76).ReturnType
7033
7064
EmitLdcI8IL.Emit(OpCodes.Stloc, 3)
7034
EmitLdcI8IL.MarkSequencePoint(doc3, 250, 1, 250, 100)
7035
Dim typ75(-1) As Type
7065
EmitLdcI8IL.MarkSequencePoint(doc3, 255, 1, 255, 100)
7066
Dim typ77(-1) As Type
7036
7067
EmitLdcI8IL.Emit(OpCodes.Ldsfld, ILGen)
7037
7068
Typ = ILGen.FieldType
7038
7069
Typ03 = Typ
7039
7070
EmitLdcI8IL.Emit(OpCodes.Ldloc, 0)
7040
7071
Typ = GetType(OpCode)
7041
ReDim Preserve typ75(UBound(typ75) + 1)
7042
typ75(UBound(typ75)) = Typ
7072
ReDim Preserve typ77(UBound(typ77) + 1)
7073
typ77(UBound(typ77)) = Typ
7043
7074
EmitLdcI8IL.Emit(OpCodes.Ldloc, 3)
7044
7075
Typ = GetType(System.Int32)
7045
ReDim Preserve typ75(UBound(typ75) + 1)
7046
typ75(UBound(typ75)) = Typ
7047
EmitLdcI8IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ75))
7048
Typ = Typ03.GetMethod("Emit", typ75).ReturnType
7049
If Typ.ToString() = GetType(System.Void).ToString() Then
7050
7051
Else
7052
EmitLdcI8IL.Emit(OpCodes.Pop)
7053
End If
7054
EmitLdcI8IL.MarkSequencePoint(doc3, 251, 1, 251, 100)
7055
Dim typ76(-1) As Type
7056
EmitLdcI8IL.Emit(OpCodes.Ldstr, "conv.i8")
7057
Typ = GetType(System.String)
7058
ReDim Preserve typ76(UBound(typ76) + 1)
7059
typ76(UBound(typ76)) = Typ
7060
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ76))
7061
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ76).ReturnType
7062
EmitLdcI8IL.Emit(OpCodes.Stloc, 0)
7063
EmitLdcI8IL.MarkSequencePoint(doc3, 252, 1, 252, 100)
7064
Dim typ77(-1) As Type
7065
EmitLdcI8IL.Emit(OpCodes.Ldsfld, ILGen)
7066
Typ = ILGen.FieldType
7067
Typ03 = Typ
7068
EmitLdcI8IL.Emit(OpCodes.Ldloc, 0)
7069
Typ = GetType(OpCode)
7070
7076
ReDim Preserve typ77(UBound(typ77) + 1)
7071
7077
typ77(UBound(typ77)) = Typ
7072
7078
EmitLdcI8IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ77))
7076
7082
Else
7077
7083
EmitLdcI8IL.Emit(OpCodes.Pop)
7078
7084
End If
7079
EmitLdcI8IL.MarkSequencePoint(doc3, 254, 1, 254, 100)
7080
EmitLdcI8IL.Emit(OpCodes.Br, label2)
7081
EmitLdcI8IL.MarkSequencePoint(doc3, 255, 1, 255, 100)
7082
EmitLdcI8IL.Emit(OpCodes.Br, cont185)
7083
EmitLdcI8IL.MarkLabel(fa185)
7084
EmitLdcI8IL.Emit(OpCodes.Br, cont185)
7085
EmitLdcI8IL.MarkLabel(cont185)
7086
EmitLdcI8IL.MarkSequencePoint(doc3, 258, 1, 258, 100)
7085
EmitLdcI8IL.MarkSequencePoint(doc3, 256, 1, 256, 100)
7087
7086
Dim typ78(-1) As Type
7088
EmitLdcI8IL.Emit(OpCodes.Ldstr, "ldc.i8")
7087
EmitLdcI8IL.Emit(OpCodes.Ldstr, "conv.i8")
7089
7088
Typ = GetType(System.String)
7090
7089
ReDim Preserve typ78(UBound(typ78) + 1)
7091
7090
typ78(UBound(typ78)) = Typ
7092
7091
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ78))
7093
7092
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ78).ReturnType
7094
7093
EmitLdcI8IL.Emit(OpCodes.Stloc, 0)
7095
EmitLdcI8IL.MarkSequencePoint(doc3, 260, 1, 260, 100)
7094
EmitLdcI8IL.MarkSequencePoint(doc3, 257, 1, 257, 100)
7096
7095
Dim typ79(-1) As Type
7097
7096
EmitLdcI8IL.Emit(OpCodes.Ldsfld, ILGen)
7098
7097
Typ = ILGen.FieldType
7101
7100
Typ = GetType(OpCode)
7102
7101
ReDim Preserve typ79(UBound(typ79) + 1)
7103
7102
typ79(UBound(typ79)) = Typ
7104
EmitLdcI8IL.Emit(OpCodes.Ldarg, 0)
7105
Typ = GetType(System.Int64)
7106
ReDim Preserve typ79(UBound(typ79) + 1)
7107
typ79(UBound(typ79)) = Typ
7108
7103
EmitLdcI8IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ79))
7109
7104
Typ = Typ03.GetMethod("Emit", typ79).ReturnType
7110
7105
If Typ.ToString() = GetType(System.Void).ToString() Then
7112
7107
Else
7113
7108
EmitLdcI8IL.Emit(OpCodes.Pop)
7114
7109
End If
7115
EmitLdcI8IL.MarkSequencePoint(doc3, 261, 1, 261, 100)
7116
EmitLdcI8IL.Emit(OpCodes.Br, label2)
7117
EmitLdcI8IL.MarkSequencePoint(doc3, 264, 1, 264, 100)
7110
EmitLdcI8IL.MarkSequencePoint(doc3, 259, 1, 259, 100)
7111
EmitLdcI8IL.Emit(OpCodes.Br, label2)
7112
EmitLdcI8IL.MarkSequencePoint(doc3, 260, 1, 260, 100)
7113
EmitLdcI8IL.Emit(OpCodes.Br, cont185)
7114
EmitLdcI8IL.MarkLabel(fa185)
7115
EmitLdcI8IL.Emit(OpCodes.Br, cont185)
7116
EmitLdcI8IL.MarkLabel(cont185)
7117
EmitLdcI8IL.MarkSequencePoint(doc3, 263, 1, 263, 100)
7118
Dim typ80(-1) As Type
7119
EmitLdcI8IL.Emit(OpCodes.Ldstr, "ldc.i8")
7120
Typ = GetType(System.String)
7121
ReDim Preserve typ80(UBound(typ80) + 1)
7122
typ80(UBound(typ80)) = Typ
7123
EmitLdcI8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ80))
7124
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ80).ReturnType
7125
EmitLdcI8IL.Emit(OpCodes.Stloc, 0)
7126
EmitLdcI8IL.MarkSequencePoint(doc3, 265, 1, 265, 100)
7127
Dim typ81(-1) As Type
7128
EmitLdcI8IL.Emit(OpCodes.Ldsfld, ILGen)
7129
Typ = ILGen.FieldType
7130
Typ03 = Typ
7131
EmitLdcI8IL.Emit(OpCodes.Ldloc, 0)
7132
Typ = GetType(OpCode)
7133
ReDim Preserve typ81(UBound(typ81) + 1)
7134
typ81(UBound(typ81)) = Typ
7135
EmitLdcI8IL.Emit(OpCodes.Ldarg, 0)
7136
Typ = GetType(System.Int64)
7137
ReDim Preserve typ81(UBound(typ81) + 1)
7138
typ81(UBound(typ81)) = Typ
7139
EmitLdcI8IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ81))
7140
Typ = Typ03.GetMethod("Emit", typ81).ReturnType
7141
If Typ.ToString() = GetType(System.Void).ToString() Then
7142
7143
Else
7144
EmitLdcI8IL.Emit(OpCodes.Pop)
7145
End If
7146
EmitLdcI8IL.MarkSequencePoint(doc3, 266, 1, 266, 100)
7147
EmitLdcI8IL.Emit(OpCodes.Br, label2)
7148
EmitLdcI8IL.MarkSequencePoint(doc3, 269, 1, 269, 100)
7118
7149
EmitLdcI8IL.MarkLabel(label2)
7119
EmitLdcI8IL.MarkSequencePoint(doc3, 265, 1, 265, 100)
7150
EmitLdcI8IL.MarkSequencePoint(doc3, 270, 1, 270, 100)
7120
7151
EmitLdcI8IL.Emit(OpCodes.Ret)
7121
Dim typ80(-1) As Type
7122
ReDim Preserve typ80(UBound(typ80) + 1)
7123
typ80(UBound(typ80)) = GetType(System.Int32)
7124
Dim EmitLdcI4 As MethodBuilder = ILEmitter.DefineMethod("EmitLdcI4", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ80)
7152
Dim typ82(-1) As Type
7153
ReDim Preserve typ82(UBound(typ82) + 1)
7154
typ82(UBound(typ82)) = GetType(System.Int32)
7155
Dim EmitLdcI4 As MethodBuilder = ILEmitter.DefineMethod("EmitLdcI4", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ82)
7125
7156
Dim EmitLdcI4IL As ILGenerator = EmitLdcI4.GetILGenerator()
7126
7157
Dim EmitLdcI4param01 As ParameterBuilder = EmitLdcI4.DefineParameter(1, ParameterAttributes.None, "num")
7127
EmitLdcI4IL.MarkSequencePoint(doc3, 268, 1, 268, 100)
7128
Dim locbldr17 As LocalBuilder = EmitLdcI4IL.DeclareLocal(GetType(OpCode))
7129
locbldr17.SetLocalSymInfo("op")
7130
EmitLdcI4IL.MarkSequencePoint(doc3, 274, 1, 274, 100)
7158
EmitLdcI4IL.MarkSequencePoint(doc3, 273, 1, 273, 100)
7159
Dim locbldr18 As LocalBuilder = EmitLdcI4IL.DeclareLocal(GetType(OpCode))
7160
locbldr18.SetLocalSymInfo("op")
7161
EmitLdcI4IL.MarkSequencePoint(doc3, 279, 1, 279, 100)
7131
7162
Dim label3 As System.Reflection.Emit.Label = EmitLdcI4IL.DefineLabel()
7132
EmitLdcI4IL.MarkSequencePoint(doc3, 276, 1, 276, 100)
7163
EmitLdcI4IL.MarkSequencePoint(doc3, 281, 1, 281, 100)
7133
7164
EmitLdcI4IL.Emit(OpCodes.Ldarg, 0)
7134
7165
Typ = GetType(System.Int32)
7135
7166
EmitLdcI4IL.Emit(OpCodes.Ldc_I4, CInt(-1))
7140
7171
EmitLdcI4IL.Emit(OpCodes.Beq, tru186)
7141
7172
EmitLdcI4IL.Emit(OpCodes.Br, fa186)
7142
7173
EmitLdcI4IL.MarkLabel(tru186)
7143
EmitLdcI4IL.MarkSequencePoint(doc3, 277, 1, 277, 100)
7144
Dim typ81(-1) As Type
7174
EmitLdcI4IL.MarkSequencePoint(doc3, 282, 1, 282, 100)
7175
Dim typ83(-1) As Type
7145
7176
EmitLdcI4IL.Emit(OpCodes.Ldstr, "ldc.i4.m1")
7146
7177
Typ = GetType(System.String)
7147
ReDim Preserve typ81(UBound(typ81) + 1)
7148
typ81(UBound(typ81)) = Typ
7149
EmitLdcI4IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ81))
7150
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ81).ReturnType
7178
ReDim Preserve typ83(UBound(typ83) + 1)
7179
typ83(UBound(typ83)) = Typ
7180
EmitLdcI4IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ83))
7181
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ83).ReturnType
7151
7182
EmitLdcI4IL.Emit(OpCodes.Stloc, 0)
7152
EmitLdcI4IL.MarkSequencePoint(doc3, 278, 1, 278, 100)
7153
Dim typ82(-1) As Type
7183
EmitLdcI4IL.MarkSequencePoint(doc3, 283, 1, 283, 100)
7184
Dim typ84(-1) As Type
7154
7185
EmitLdcI4IL.Emit(OpCodes.Ldsfld, ILGen)
7155
7186
Typ = ILGen.FieldType
7156
7187
Typ03 = Typ
7157
7188
EmitLdcI4IL.Emit(OpCodes.Ldloc, 0)
7158
7189
Typ = GetType(OpCode)
7159
ReDim Preserve typ82(UBound(typ82) + 1)
7160
typ82(UBound(typ82)) = Typ
7161
EmitLdcI4IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ82))
7162
Typ = Typ03.GetMethod("Emit", typ82).ReturnType
7190
ReDim Preserve typ84(UBound(typ84) + 1)
7191
typ84(UBound(typ84)) = Typ
7192
EmitLdcI4IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ84))
7193
Typ = Typ03.GetMethod("Emit", typ84).ReturnType
7163
7194
If Typ.ToString() = GetType(System.Void).ToString() Then
7164
7195
7165
7196
Else
7166
7197
EmitLdcI4IL.Emit(OpCodes.Pop)
7167
7198
End If
7168
EmitLdcI4IL.MarkSequencePoint(doc3, 279, 1, 279, 100)
7199
EmitLdcI4IL.MarkSequencePoint(doc3, 284, 1, 284, 100)
7169
7200
EmitLdcI4IL.Emit(OpCodes.Br, label3)
7170
EmitLdcI4IL.MarkSequencePoint(doc3, 280, 1, 280, 100)
7201
EmitLdcI4IL.MarkSequencePoint(doc3, 285, 1, 285, 100)
7171
7202
EmitLdcI4IL.Emit(OpCodes.Br, cont186)
7172
7203
EmitLdcI4IL.MarkLabel(fa186)
7173
7204
EmitLdcI4IL.Emit(OpCodes.Br, cont186)
7174
7205
EmitLdcI4IL.MarkLabel(cont186)
7175
EmitLdcI4IL.MarkSequencePoint(doc3, 282, 1, 282, 100)
7206
EmitLdcI4IL.MarkSequencePoint(doc3, 287, 1, 287, 100)
7176
7207
EmitLdcI4IL.Emit(OpCodes.Ldarg, 0)
7177
7208
Typ = GetType(System.Int32)
7178
7209
EmitLdcI4IL.Emit(OpCodes.Ldc_I4, CInt(0))
7183
7214
EmitLdcI4IL.Emit(OpCodes.Beq, tru187)
7184
7215
EmitLdcI4IL.Emit(OpCodes.Br, fa187)
7185
7216
EmitLdcI4IL.MarkLabel(tru187)
7186
EmitLdcI4IL.MarkSequencePoint(doc3, 283, 1, 283, 100)
7187
Dim typ83(-1) As Type
7217
EmitLdcI4IL.MarkSequencePoint(doc3, 288, 1, 288, 100)
7218
Dim typ85(-1) As Type
7188
7219
EmitLdcI4IL.Emit(OpCodes.Ldstr, "ldc.i4.0")
7189
7220
Typ = GetType(System.String)
7190
ReDim Preserve typ83(UBound(typ83) + 1)
7191
typ83(UBound(typ83)) = Typ
7192
EmitLdcI4IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ83))
7193
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ83).ReturnType
7221
ReDim Preserve typ85(UBound(typ85) + 1)
7222
typ85(UBound(typ85)) = Typ
7223
EmitLdcI4IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ85))
7224
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ85).ReturnType
7194
7225
EmitLdcI4IL.Emit(OpCodes.Stloc, 0)
7195
EmitLdcI4IL.MarkSequencePoint(doc3, 284, 1, 284, 100)
7196
Dim typ84(-1) As Type
7226
EmitLdcI4IL.MarkSequencePoint(doc3, 289, 1, 289, 100)
7227
Dim typ86(-1) As Type
7197
7228
EmitLdcI4IL.Emit(OpCodes.Ldsfld, ILGen)
7198
7229
Typ = ILGen.FieldType
7199
7230
Typ03 = Typ
7200
7231
EmitLdcI4IL.Emit(OpCodes.Ldloc, 0)
7201
7232
Typ = GetType(OpCode)
7202
ReDim Preserve typ84(UBound(typ84) + 1)
7203
typ84(UBound(typ84)) = Typ
7204
EmitLdcI4IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ84))
7205
Typ = Typ03.GetMethod("Emit", typ84).ReturnType
7233
ReDim Preserve typ86(UBound(typ86) + 1)
7234
typ86(UBound(typ86)) = Typ
7235
EmitLdcI4IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ86))
7236
Typ = Typ03.GetMethod("Emit", typ86).ReturnType
7206
7237
If Typ.ToString() = GetType(System.Void).ToString() Then
7207
7238
7208
7239
Else
7209
7240
EmitLdcI4IL.Emit(OpCodes.Pop)
7210
7241
End If
7211
EmitLdcI4IL.MarkSequencePoint(doc3, 285, 1, 285, 100)
7242
EmitLdcI4IL.MarkSequencePoint(doc3, 290, 1, 290, 100)
7212
7243
EmitLdcI4IL.Emit(OpCodes.Br, label3)
7213
EmitLdcI4IL.MarkSequencePoint(doc3, 286, 1, 286, 100)
7244
EmitLdcI4IL.MarkSequencePoint(doc3, 291, 1, 291, 100)
7214
7245
EmitLdcI4IL.Emit(OpCodes.Br, cont187)
7215
7246
EmitLdcI4IL.MarkLabel(fa187)
7216
7247
EmitLdcI4IL.Emit(OpCodes.Br, cont187)
7217
7248
EmitLdcI4IL.MarkLabel(cont187)
7218
EmitLdcI4IL.MarkSequencePoint(doc3, 288, 1, 288, 100)
7249
EmitLdcI4IL.MarkSequencePoint(doc3, 293, 1, 293, 100)
7219
7250
EmitLdcI4IL.Emit(OpCodes.Ldarg, 0)
7220
7251
Typ = GetType(System.Int32)
7221
7252
EmitLdcI4IL.Emit(OpCodes.Ldc_I4, CInt(1))
7226
7257
EmitLdcI4IL.Emit(OpCodes.Beq, tru188)
7227
7258
EmitLdcI4IL.Emit(OpCodes.Br, fa188)
7228
7259
EmitLdcI4IL.MarkLabel(tru188)
7229
EmitLdcI4IL.MarkSequencePoint(doc3, 289, 1, 289, 100)
7230
Dim typ85(-1) As Type
7260
EmitLdcI4IL.MarkSequencePoint(doc3, 294, 1, 294, 100)
7261
Dim typ87(-1) As Type
7231
7262
EmitLdcI4IL.Emit(OpCodes.Ldstr, "ldc.i4.1")
7232
7263
Typ = GetType(System.String)
7233
ReDim Preserve typ85(UBound(typ85) + 1)
7234
typ85(UBound(typ85)) = Typ
7235
EmitLdcI4IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ85))
7236
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ85).ReturnType
7264
ReDim Preserve typ87(UBound(typ87) + 1)
7265
typ87(UBound(typ87)) = Typ
7266
EmitLdcI4IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ87))
7267
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ87).ReturnType
7237
7268
EmitLdcI4IL.Emit(OpCodes.Stloc, 0)
7238
EmitLdcI4IL.MarkSequencePoint(doc3, 290, 1, 290, 100)
7239
Dim typ86(-1) As Type
7269
EmitLdcI4IL.MarkSequencePoint(doc3, 295, 1, 295, 100)
7270
Dim typ88(-1) As Type
7240
7271
EmitLdcI4IL.Emit(OpCodes.Ldsfld, ILGen)
7241
7272
Typ = ILGen.FieldType
7242
7273
Typ03 = Typ
7243
7274
EmitLdcI4IL.Emit(OpCodes.Ldloc, 0)
7244
7275
Typ = GetType(OpCode)
7245
ReDim Preserve typ86(UBound(typ86) + 1)
7246
typ86(UBound(typ86)) = Typ
7247
EmitLdcI4IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ86))
7248
Typ = Typ03.GetMethod("Emit", typ86).ReturnType
7276
ReDim Preserve typ88(UBound(typ88) + 1)
7277
typ88(UBound(typ88)) = Typ
7278
EmitLdcI4IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ88))
7279
Typ = Typ03.GetMethod("Emit", typ88).ReturnType
7249
7280
If Typ.ToString() = GetType(System.Void).ToString() Then
7250
7281
7251
7282
Else
7252
7283
EmitLdcI4IL.Emit(OpCodes.Pop)
7253
7284
End If
7254
EmitLdcI4IL.MarkSequencePoint(doc3, 291, 1, 291, 100)
7285
EmitLdcI4IL.MarkSequencePoint(doc3, 296, 1, 296, 100)
7255
7286
EmitLdcI4IL.Emit(OpCodes.Br, label3)
7256
EmitLdcI4IL.MarkSequencePoint(doc3, 292, 1, 292, 100)
7287
EmitLdcI4IL.MarkSequencePoint(doc3, 297, 1, 297, 100)
7257
7288
EmitLdcI4IL.Emit(OpCodes.Br, cont188)
7258
7289
EmitLdcI4IL.MarkLabel(fa188)
7259
7290
EmitLdcI4IL.Emit(OpCodes.Br, cont188)
7260
7291
EmitLdcI4IL.MarkLabel(cont188)
7261
EmitLdcI4IL.MarkSequencePoint(doc3, 294, 1, 294, 100)
7292
EmitLdcI4IL.MarkSequencePoint(doc3, 299, 1, 299, 100)
7262
7293
EmitLdcI4IL.Emit(OpCodes.Ldarg, 0)
7263
7294
Typ = GetType(System.Int32)
7264
7295
EmitLdcI4IL.Emit(OpCodes.Ldc_I4, CInt(2))
7269
7300
EmitLdcI4IL.Emit(OpCodes.Beq, tru189)
7270
7301
EmitLdcI4IL.Emit(OpCodes.Br, fa189)
7271
7302
EmitLdcI4IL.MarkLabel(tru189)
7272
EmitLdcI4IL.MarkSequencePoint(doc3, 295, 1, 295, 100)
7273
Dim typ87(-1) As Type
7303
EmitLdcI4IL.MarkSequencePoint(doc3, 300, 1, 300, 100)
7304
Dim typ89(-1) As Type
7274
7305
EmitLdcI4IL.Emit(OpCodes.Ldstr, "ldc.i4.2")
7275
7306
Typ = GetType(System.String)
7276
ReDim Preserve typ87(UBound(typ87) + 1)
7277
typ87(UBound(typ87)) = Typ
7278
EmitLdcI4IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ87))
7279
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ87).ReturnType
7307
ReDim Preserve typ89(UBound(typ89) + 1)
7308
typ89(UBound(typ89)) = Typ
7309
EmitLdcI4IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ89))
7310
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ89).ReturnType
7280
7311
EmitLdcI4IL.Emit(OpCodes.Stloc, 0)
7281
EmitLdcI4IL.MarkSequencePoint(doc3, 296, 1, 296, 100)
7282
Dim typ88(-1) As Type
7312
EmitLdcI4IL.MarkSequencePoint(doc3, 301, 1, 301, 100)
7313
Dim typ90(-1) As Type
7283
7314
EmitLdcI4IL.Emit(OpCodes.Ldsfld, ILGen)
7284
7315
Typ = ILGen.FieldType
7285
7316
Typ03 = Typ
7286
7317
EmitLdcI4IL.Emit(OpCodes.Ldloc, 0)
7287
7318
Typ = GetType(OpCode)
7288
ReDim Preserve typ88(UBound(typ88) + 1)
7289
typ88(UBound(typ88)) = Typ
7290
EmitLdcI4IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ88))
7291
Typ = Typ03.GetMethod("Emit", typ88).ReturnType
7319
ReDim Preserve typ90(UBound(typ90) + 1)
7320
typ90(UBound(typ90)) = Typ
7321
EmitLdcI4IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ90))
7322
Typ = Typ03.GetMethod("Emit", typ90).ReturnType
7292
7323
If Typ.ToString() = GetType(System.Void).ToString() Then
7293
7324
7294
7325
Else
7295
7326
EmitLdcI4IL.Emit(OpCodes.Pop)
7296
7327
End If
7297
EmitLdcI4IL.MarkSequencePoint(doc3, 297, 1, 297, 100)
7328
EmitLdcI4IL.MarkSequencePoint(doc3, 302, 1, 302, 100)
7298
7329
EmitLdcI4IL.Emit(OpCodes.Br, label3)
7299
EmitLdcI4IL.MarkSequencePoint(doc3, 298, 1, 298, 100)
7330
EmitLdcI4IL.MarkSequencePoint(doc3, 303, 1, 303, 100)
7300
7331
EmitLdcI4IL.Emit(OpCodes.Br, cont189)
7301
7332
EmitLdcI4IL.MarkLabel(fa189)
7302
7333
EmitLdcI4IL.Emit(OpCodes.Br, cont189)
7303
7334
EmitLdcI4IL.MarkLabel(cont189)
7304
EmitLdcI4IL.MarkSequencePoint(doc3, 300, 1, 300, 100)
7335
EmitLdcI4IL.MarkSequencePoint(doc3, 305, 1, 305, 100)
7305
7336
EmitLdcI4IL.Emit(OpCodes.Ldarg, 0)
7306
7337
Typ = GetType(System.Int32)
7307
7338
EmitLdcI4IL.Emit(OpCodes.Ldc_I4, CInt(3))
7312
7343
EmitLdcI4IL.Emit(OpCodes.Beq, tru190)
7313
7344
EmitLdcI4IL.Emit(OpCodes.Br, fa190)
7314
7345
EmitLdcI4IL.MarkLabel(tru190)
7315
EmitLdcI4IL.MarkSequencePoint(doc3, 301, 1, 301, 100)
7316
Dim typ89(-1) As Type
7346
EmitLdcI4IL.MarkSequencePoint(doc3, 306, 1, 306, 100)
7347
Dim typ91(-1) As Type
7317
7348
EmitLdcI4IL.Emit(OpCodes.Ldstr, "ldc.i4.3")
7318
7349
Typ = GetType(System.String)
7319
ReDim Preserve typ89(UBound(typ89) + 1)
7320
typ89(UBound(typ89)) = Typ
7321
EmitLdcI4IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ89))
7322
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ89).ReturnType
7350
ReDim Preserve typ91(UBound(typ91) + 1)
7351
typ91(UBound(typ91)) = Typ
7352
EmitLdcI4IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ91))
7353
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ91).ReturnType
7323
7354
EmitLdcI4IL.Emit(OpCodes.Stloc, 0)
7324
EmitLdcI4IL.MarkSequencePoint(doc3, 302, 1, 302, 100)
7325
Dim typ90(-1) As Type
7355
EmitLdcI4IL.MarkSequencePoint(doc3, 307, 1, 307, 100)
7356
Dim typ92(-1) As Type
7326
7357
EmitLdcI4IL.Emit(OpCodes.Ldsfld, ILGen)
7327
7358
Typ = ILGen.FieldType
7328
7359
Typ03 = Typ
7329
7360
EmitLdcI4IL.Emit(OpCodes.Ldloc, 0)
7330
7361
Typ = GetType(OpCode)
7331
ReDim Preserve typ90(UBound(typ90) + 1)
7332
typ90(UBound(typ90)) = Typ
7333
EmitLdcI4IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ90))
7334
Typ = Typ03.GetMethod("Emit", typ90).ReturnType
7362
ReDim Preserve typ92(UBound(typ92) + 1)
7363
typ92(UBound(typ92)) = Typ
7364
EmitLdcI4IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ92))
7365
Typ = Typ03.GetMethod("Emit", typ92).ReturnType
7335
7366
If Typ.ToString() = GetType(System.Void).ToString() Then
7336
7367
7337
7368
Else
7338
7369
EmitLdcI4IL.Emit(OpCodes.Pop)
7339
7370
End If
7340
EmitLdcI4IL.MarkSequencePoint(doc3, 303, 1, 303, 100)
7371
EmitLdcI4IL.MarkSequencePoint(doc3, 308, 1, 308, 100)
7341
7372
EmitLdcI4IL.Emit(OpCodes.Br, label3)
7342
EmitLdcI4IL.MarkSequencePoint(doc3, 304, 1, 304, 100)
7373
EmitLdcI4IL.MarkSequencePoint(doc3, 309, 1, 309, 100)
7343
7374
EmitLdcI4IL.Emit(OpCodes.Br, cont190)
7344
7375
EmitLdcI4IL.MarkLabel(fa190)
7345
7376
EmitLdcI4IL.Emit(OpCodes.Br, cont190)
7346
7377
EmitLdcI4IL.MarkLabel(cont190)
7347
EmitLdcI4IL.MarkSequencePoint(doc3, 306, 1, 306, 100)
7378
EmitLdcI4IL.MarkSequencePoint(doc3, 311, 1, 311, 100)
7348
7379
EmitLdcI4IL.Emit(OpCodes.Ldarg, 0)
7349
7380
Typ = GetType(System.Int32)
7350
7381
EmitLdcI4IL.Emit(OpCodes.Ldc_I4, CInt(4))
7355
7386
EmitLdcI4IL.Emit(OpCodes.Beq, tru191)
7356
7387
EmitLdcI4IL.Emit(OpCodes.Br, fa191)
7357
7388
EmitLdcI4IL.MarkLabel(tru191)
7358
EmitLdcI4IL.MarkSequencePoint(doc3, 307, 1, 307, 100)
7359
Dim typ91(-1) As Type
7389
EmitLdcI4IL.MarkSequencePoint(doc3, 312, 1, 312, 100)
7390
Dim typ93(-1) As Type
7360
7391
EmitLdcI4IL.Emit(OpCodes.Ldstr, "ldc.i4.4")
7361
7392
Typ = GetType(System.String)
7362
ReDim Preserve typ91(UBound(typ91) + 1)
7363
typ91(UBound(typ91)) = Typ
7364
EmitLdcI4IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ91))
7365
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ91).ReturnType
7393
ReDim Preserve typ93(UBound(typ93) + 1)
7394
typ93(UBound(typ93)) = Typ
7395
EmitLdcI4IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ93))
7396
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ93).ReturnType
7366
7397
EmitLdcI4IL.Emit(OpCodes.Stloc, 0)
7367
EmitLdcI4IL.MarkSequencePoint(doc3, 308, 1, 308, 100)
7368
Dim typ92(-1) As Type
7398
EmitLdcI4IL.MarkSequencePoint(doc3, 313, 1, 313, 100)
7399
Dim typ94(-1) As Type
7369
7400
EmitLdcI4IL.Emit(OpCodes.Ldsfld, ILGen)
7370
7401
Typ = ILGen.FieldType
7371
7402
Typ03 = Typ
7372
7403
EmitLdcI4IL.Emit(OpCodes.Ldloc, 0)
7373
7404
Typ = GetType(OpCode)
7374
ReDim Preserve typ92(UBound(typ92) + 1)
7375
typ92(UBound(typ92)) = Typ
7376
EmitLdcI4IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ92))
7377
Typ = Typ03.GetMethod("Emit", typ92).ReturnType
7405
ReDim Preserve typ94(UBound(typ94) + 1)
7406
typ94(UBound(typ94)) = Typ
7407
EmitLdcI4IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ94))
7408
Typ = Typ03.GetMethod("Emit", typ94).ReturnType
7378
7409
If Typ.ToString() = GetType(System.Void).ToString() Then
7379
7410
7380
7411
Else
7381
7412
EmitLdcI4IL.Emit(OpCodes.Pop)
7382
7413
End If
7383
EmitLdcI4IL.MarkSequencePoint(doc3, 309, 1, 309, 100)
7414
EmitLdcI4IL.MarkSequencePoint(doc3, 314, 1, 314, 100)
7384
7415
EmitLdcI4IL.Emit(OpCodes.Br, label3)
7385
EmitLdcI4IL.MarkSequencePoint(doc3, 310, 1, 310, 100)
7416
EmitLdcI4IL.MarkSequencePoint(doc3, 315, 1, 315, 100)
7386
7417
EmitLdcI4IL.Emit(OpCodes.Br, cont191)
7387
7418
EmitLdcI4IL.MarkLabel(fa191)
7388
7419
EmitLdcI4IL.Emit(OpCodes.Br, cont191)
7389
7420
EmitLdcI4IL.MarkLabel(cont191)
7390
EmitLdcI4IL.MarkSequencePoint(doc3, 312, 1, 312, 100)
7421
EmitLdcI4IL.MarkSequencePoint(doc3, 317, 1, 317, 100)
7391
7422
EmitLdcI4IL.Emit(OpCodes.Ldarg, 0)
7392
7423
Typ = GetType(System.Int32)
7393
7424
EmitLdcI4IL.Emit(OpCodes.Ldc_I4, CInt(5))
7398
7429
EmitLdcI4IL.Emit(OpCodes.Beq, tru192)
7399
7430
EmitLdcI4IL.Emit(OpCodes.Br, fa192)
7400
7431
EmitLdcI4IL.MarkLabel(tru192)
7401
EmitLdcI4IL.MarkSequencePoint(doc3, 313, 1, 313, 100)
7402
Dim typ93(-1) As Type
7432
EmitLdcI4IL.MarkSequencePoint(doc3, 318, 1, 318, 100)
7433
Dim typ95(-1) As Type
7403
7434
EmitLdcI4IL.Emit(OpCodes.Ldstr, "ldc.i4.5")
7404
7435
Typ = GetType(System.String)
7405
ReDim Preserve typ93(UBound(typ93) + 1)
7406
typ93(UBound(typ93)) = Typ
7407
EmitLdcI4IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ93))
7408
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ93).ReturnType
7436
ReDim Preserve typ95(UBound(typ95) + 1)
7437
typ95(UBound(typ95)) = Typ
7438
EmitLdcI4IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ95))
7439
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ95).ReturnType
7409
7440
EmitLdcI4IL.Emit(OpCodes.Stloc, 0)
7410
EmitLdcI4IL.MarkSequencePoint(doc3, 314, 1, 314, 100)
7411
Dim typ94(-1) As Type
7441
EmitLdcI4IL.MarkSequencePoint(doc3, 319, 1, 319, 100)
7442
Dim typ96(-1) As Type
7412
7443
EmitLdcI4IL.Emit(OpCodes.Ldsfld, ILGen)
7413
7444
Typ = ILGen.FieldType
7414
7445
Typ03 = Typ
7415
7446
EmitLdcI4IL.Emit(OpCodes.Ldloc, 0)
7416
7447
Typ = GetType(OpCode)
7417
ReDim Preserve typ94(UBound(typ94) + 1)
7418
typ94(UBound(typ94)) = Typ
7419
EmitLdcI4IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ94))
7420
Typ = Typ03.GetMethod("Emit", typ94).ReturnType
7448
ReDim Preserve typ96(UBound(typ96) + 1)
7449
typ96(UBound(typ96)) = Typ
7450
EmitLdcI4IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ96))
7451
Typ = Typ03.GetMethod("Emit", typ96).ReturnType
7421
7452
If Typ.ToString() = GetType(System.Void).ToString() Then
7422
7453
7423
7454
Else
7424
7455
EmitLdcI4IL.Emit(OpCodes.Pop)
7425
7456
End If
7426
EmitLdcI4IL.MarkSequencePoint(doc3, 315, 1, 315, 100)
7457
EmitLdcI4IL.MarkSequencePoint(doc3, 320, 1, 320, 100)
7427
7458
EmitLdcI4IL.Emit(OpCodes.Br, label3)
7428
EmitLdcI4IL.MarkSequencePoint(doc3, 316, 1, 316, 100)
7459
EmitLdcI4IL.MarkSequencePoint(doc3, 321, 1, 321, 100)
7429
7460
EmitLdcI4IL.Emit(OpCodes.Br, cont192)
7430
7461
EmitLdcI4IL.MarkLabel(fa192)
7431
7462
EmitLdcI4IL.Emit(OpCodes.Br, cont192)
7432
7463
EmitLdcI4IL.MarkLabel(cont192)
7433
EmitLdcI4IL.MarkSequencePoint(doc3, 318, 1, 318, 100)
7464
EmitLdcI4IL.MarkSequencePoint(doc3, 323, 1, 323, 100)
7434
7465
EmitLdcI4IL.Emit(OpCodes.Ldarg, 0)
7435
7466
Typ = GetType(System.Int32)
7436
7467
EmitLdcI4IL.Emit(OpCodes.Ldc_I4, CInt(6))
7441
7472
EmitLdcI4IL.Emit(OpCodes.Beq, tru193)
7442
7473
EmitLdcI4IL.Emit(OpCodes.Br, fa193)
7443
7474
EmitLdcI4IL.MarkLabel(tru193)
7444
EmitLdcI4IL.MarkSequencePoint(doc3, 319, 1, 319, 100)
7445
Dim typ95(-1) As Type
7475
EmitLdcI4IL.MarkSequencePoint(doc3, 324, 1, 324, 100)
7476
Dim typ97(-1) As Type
7446
7477
EmitLdcI4IL.Emit(OpCodes.Ldstr, "ldc.i4.6")
7447
7478
Typ = GetType(System.String)
7448
ReDim Preserve typ95(UBound(typ95) + 1)
7449
typ95(UBound(typ95)) = Typ
7450
EmitLdcI4IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ95))
7451
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ95).ReturnType
7479
ReDim Preserve typ97(UBound(typ97) + 1)
7480
typ97(UBound(typ97)) = Typ
7481
EmitLdcI4IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ97))
7482
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ97).ReturnType
7452
7483
EmitLdcI4IL.Emit(OpCodes.Stloc, 0)
7453
EmitLdcI4IL.MarkSequencePoint(doc3, 320, 1, 320, 100)
7454
Dim typ96(-1) As Type
7484
EmitLdcI4IL.MarkSequencePoint(doc3, 325, 1, 325, 100)
7485
Dim typ98(-1) As Type
7455
7486
EmitLdcI4IL.Emit(OpCodes.Ldsfld, ILGen)
7456
7487
Typ = ILGen.FieldType
7457
7488
Typ03 = Typ
7458
7489
EmitLdcI4IL.Emit(OpCodes.Ldloc, 0)
7459
7490
Typ = GetType(OpCode)
7460
ReDim Preserve typ96(UBound(typ96) + 1)
7461
typ96(UBound(typ96)) = Typ
7462
EmitLdcI4IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ96))
7463
Typ = Typ03.GetMethod("Emit", typ96).ReturnType
7491
ReDim Preserve typ98(UBound(typ98) + 1)
7492
typ98(UBound(typ98)) = Typ
7493
EmitLdcI4IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ98))
7494
Typ = Typ03.GetMethod("Emit", typ98).ReturnType
7464
7495
If Typ.ToString() = GetType(System.Void).ToString() Then
7465
7496
7466
7497
Else
7467
7498
EmitLdcI4IL.Emit(OpCodes.Pop)
7468
7499
End If
7469
EmitLdcI4IL.MarkSequencePoint(doc3, 321, 1, 321, 100)
7500
EmitLdcI4IL.MarkSequencePoint(doc3, 326, 1, 326, 100)
7470
7501
EmitLdcI4IL.Emit(OpCodes.Br, label3)
7471
EmitLdcI4IL.MarkSequencePoint(doc3, 322, 1, 322, 100)
7502
EmitLdcI4IL.MarkSequencePoint(doc3, 327, 1, 327, 100)
7472
7503
EmitLdcI4IL.Emit(OpCodes.Br, cont193)
7473
7504
EmitLdcI4IL.MarkLabel(fa193)
7474
7505
EmitLdcI4IL.Emit(OpCodes.Br, cont193)
7475
7506
EmitLdcI4IL.MarkLabel(cont193)
7476
EmitLdcI4IL.MarkSequencePoint(doc3, 324, 1, 324, 100)
7507
EmitLdcI4IL.MarkSequencePoint(doc3, 329, 1, 329, 100)
7477
7508
EmitLdcI4IL.Emit(OpCodes.Ldarg, 0)
7478
7509
Typ = GetType(System.Int32)
7479
7510
EmitLdcI4IL.Emit(OpCodes.Ldc_I4, CInt(7))
7484
7515
EmitLdcI4IL.Emit(OpCodes.Beq, tru194)
7485
7516
EmitLdcI4IL.Emit(OpCodes.Br, fa194)
7486
7517
EmitLdcI4IL.MarkLabel(tru194)
7487
EmitLdcI4IL.MarkSequencePoint(doc3, 325, 1, 325, 100)
7488
Dim typ97(-1) As Type
7518
EmitLdcI4IL.MarkSequencePoint(doc3, 330, 1, 330, 100)
7519
Dim typ99(-1) As Type
7489
7520
EmitLdcI4IL.Emit(OpCodes.Ldstr, "ldc.i4.7")
7490
7521
Typ = GetType(System.String)
7491
ReDim Preserve typ97(UBound(typ97) + 1)
7492
typ97(UBound(typ97)) = Typ
7493
EmitLdcI4IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ97))
7494
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ97).ReturnType
7522
ReDim Preserve typ99(UBound(typ99) + 1)
7523
typ99(UBound(typ99)) = Typ
7524
EmitLdcI4IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ99))
7525
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ99).ReturnType
7495
7526
EmitLdcI4IL.Emit(OpCodes.Stloc, 0)
7496
EmitLdcI4IL.MarkSequencePoint(doc3, 326, 1, 326, 100)
7497
Dim typ98(-1) As Type
7527
EmitLdcI4IL.MarkSequencePoint(doc3, 331, 1, 331, 100)
7528
Dim typ100(-1) As Type
7498
7529
EmitLdcI4IL.Emit(OpCodes.Ldsfld, ILGen)
7499
7530
Typ = ILGen.FieldType
7500
7531
Typ03 = Typ
7501
7532
EmitLdcI4IL.Emit(OpCodes.Ldloc, 0)
7502
7533
Typ = GetType(OpCode)
7503
ReDim Preserve typ98(UBound(typ98) + 1)
7504
typ98(UBound(typ98)) = Typ
7505
EmitLdcI4IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ98))
7506
Typ = Typ03.GetMethod("Emit", typ98).ReturnType
7534
ReDim Preserve typ100(UBound(typ100) + 1)
7535
typ100(UBound(typ100)) = Typ
7536
EmitLdcI4IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ100))
7537
Typ = Typ03.GetMethod("Emit", typ100).ReturnType
7507
7538
If Typ.ToString() = GetType(System.Void).ToString() Then
7508
7539
7509
7540
Else
7510
7541
EmitLdcI4IL.Emit(OpCodes.Pop)
7511
7542
End If
7512
EmitLdcI4IL.MarkSequencePoint(doc3, 327, 1, 327, 100)
7543
EmitLdcI4IL.MarkSequencePoint(doc3, 332, 1, 332, 100)
7513
7544
EmitLdcI4IL.Emit(OpCodes.Br, label3)
7514
EmitLdcI4IL.MarkSequencePoint(doc3, 328, 1, 328, 100)
7545
EmitLdcI4IL.MarkSequencePoint(doc3, 333, 1, 333, 100)
7515
7546
EmitLdcI4IL.Emit(OpCodes.Br, cont194)
7516
7547
EmitLdcI4IL.MarkLabel(fa194)
7517
7548
EmitLdcI4IL.Emit(OpCodes.Br, cont194)
7518
7549
EmitLdcI4IL.MarkLabel(cont194)
7519
EmitLdcI4IL.MarkSequencePoint(doc3, 330, 1, 330, 100)
7550
EmitLdcI4IL.MarkSequencePoint(doc3, 335, 1, 335, 100)
7520
7551
EmitLdcI4IL.Emit(OpCodes.Ldarg, 0)
7521
7552
Typ = GetType(System.Int32)
7522
7553
EmitLdcI4IL.Emit(OpCodes.Ldc_I4, CInt(8))
7527
7558
EmitLdcI4IL.Emit(OpCodes.Beq, tru195)
7528
7559
EmitLdcI4IL.Emit(OpCodes.Br, fa195)
7529
7560
EmitLdcI4IL.MarkLabel(tru195)
7530
EmitLdcI4IL.MarkSequencePoint(doc3, 331, 1, 331, 100)
7531
Dim typ99(-1) As Type
7561
EmitLdcI4IL.MarkSequencePoint(doc3, 336, 1, 336, 100)
7562
Dim typ101(-1) As Type
7532
7563
EmitLdcI4IL.Emit(OpCodes.Ldstr, "ldc.i4.8")
7533
7564
Typ = GetType(System.String)
7534
ReDim Preserve typ99(UBound(typ99) + 1)
7535
typ99(UBound(typ99)) = Typ
7536
EmitLdcI4IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ99))
7537
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ99).ReturnType
7538
EmitLdcI4IL.Emit(OpCodes.Stloc, 0)
7539
EmitLdcI4IL.MarkSequencePoint(doc3, 332, 1, 332, 100)
7540
Dim typ100(-1) As Type
7541
EmitLdcI4IL.Emit(OpCodes.Ldsfld, ILGen)
7542
Typ = ILGen.FieldType
7543
Typ03 = Typ
7544
EmitLdcI4IL.Emit(OpCodes.Ldloc, 0)
7545
Typ = GetType(OpCode)
7546
ReDim Preserve typ100(UBound(typ100) + 1)
7547
typ100(UBound(typ100)) = Typ
7548
EmitLdcI4IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ100))
7549
Typ = Typ03.GetMethod("Emit", typ100).ReturnType
7550
If Typ.ToString() = GetType(System.Void).ToString() Then
7551
7552
Else
7553
EmitLdcI4IL.Emit(OpCodes.Pop)
7554
End If
7555
EmitLdcI4IL.MarkSequencePoint(doc3, 333, 1, 333, 100)
7556
EmitLdcI4IL.Emit(OpCodes.Br, label3)
7557
EmitLdcI4IL.MarkSequencePoint(doc3, 334, 1, 334, 100)
7558
EmitLdcI4IL.Emit(OpCodes.Br, cont195)
7559
EmitLdcI4IL.MarkLabel(fa195)
7560
EmitLdcI4IL.Emit(OpCodes.Br, cont195)
7561
EmitLdcI4IL.MarkLabel(cont195)
7562
EmitLdcI4IL.MarkSequencePoint(doc3, 352, 1, 352, 100)
7563
Dim typ101(-1) As Type
7564
EmitLdcI4IL.Emit(OpCodes.Ldstr, "ldc.i4")
7565
Typ = GetType(System.String)
7566
7565
ReDim Preserve typ101(UBound(typ101) + 1)
7567
7566
typ101(UBound(typ101)) = Typ
7568
7567
EmitLdcI4IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ101))
7569
7568
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ101).ReturnType
7570
7569
EmitLdcI4IL.Emit(OpCodes.Stloc, 0)
7571
EmitLdcI4IL.MarkSequencePoint(doc3, 354, 1, 354, 100)
7570
EmitLdcI4IL.MarkSequencePoint(doc3, 337, 1, 337, 100)
7572
7571
Dim typ102(-1) As Type
7573
7572
EmitLdcI4IL.Emit(OpCodes.Ldsfld, ILGen)
7574
7573
Typ = ILGen.FieldType
7577
7576
Typ = GetType(OpCode)
7578
7577
ReDim Preserve typ102(UBound(typ102) + 1)
7579
7578
typ102(UBound(typ102)) = Typ
7580
EmitLdcI4IL.Emit(OpCodes.Ldarg, 0)
7581
Typ = GetType(System.Int32)
7582
ReDim Preserve typ102(UBound(typ102) + 1)
7583
typ102(UBound(typ102)) = Typ
7584
7579
EmitLdcI4IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ102))
7585
7580
Typ = Typ03.GetMethod("Emit", typ102).ReturnType
7586
7581
If Typ.ToString() = GetType(System.Void).ToString() Then
7588
7583
Else
7589
7584
EmitLdcI4IL.Emit(OpCodes.Pop)
7590
7585
End If
7591
EmitLdcI4IL.MarkSequencePoint(doc3, 355, 1, 355, 100)
7592
EmitLdcI4IL.Emit(OpCodes.Br, label3)
7593
EmitLdcI4IL.MarkSequencePoint(doc3, 358, 1, 358, 100)
7586
EmitLdcI4IL.MarkSequencePoint(doc3, 338, 1, 338, 100)
7587
EmitLdcI4IL.Emit(OpCodes.Br, label3)
7588
EmitLdcI4IL.MarkSequencePoint(doc3, 339, 1, 339, 100)
7589
EmitLdcI4IL.Emit(OpCodes.Br, cont195)
7590
EmitLdcI4IL.MarkLabel(fa195)
7591
EmitLdcI4IL.Emit(OpCodes.Br, cont195)
7592
EmitLdcI4IL.MarkLabel(cont195)
7593
EmitLdcI4IL.MarkSequencePoint(doc3, 357, 1, 357, 100)
7594
Dim typ103(-1) As Type
7595
EmitLdcI4IL.Emit(OpCodes.Ldstr, "ldc.i4")
7596
Typ = GetType(System.String)
7597
ReDim Preserve typ103(UBound(typ103) + 1)
7598
typ103(UBound(typ103)) = Typ
7599
EmitLdcI4IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ103))
7600
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ103).ReturnType
7601
EmitLdcI4IL.Emit(OpCodes.Stloc, 0)
7602
EmitLdcI4IL.MarkSequencePoint(doc3, 359, 1, 359, 100)
7603
Dim typ104(-1) As Type
7604
EmitLdcI4IL.Emit(OpCodes.Ldsfld, ILGen)
7605
Typ = ILGen.FieldType
7606
Typ03 = Typ
7607
EmitLdcI4IL.Emit(OpCodes.Ldloc, 0)
7608
Typ = GetType(OpCode)
7609
ReDim Preserve typ104(UBound(typ104) + 1)
7610
typ104(UBound(typ104)) = Typ
7611
EmitLdcI4IL.Emit(OpCodes.Ldarg, 0)
7612
Typ = GetType(System.Int32)
7613
ReDim Preserve typ104(UBound(typ104) + 1)
7614
typ104(UBound(typ104)) = Typ
7615
EmitLdcI4IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ104))
7616
Typ = Typ03.GetMethod("Emit", typ104).ReturnType
7617
If Typ.ToString() = GetType(System.Void).ToString() Then
7618
7619
Else
7620
EmitLdcI4IL.Emit(OpCodes.Pop)
7621
End If
7622
EmitLdcI4IL.MarkSequencePoint(doc3, 360, 1, 360, 100)
7623
EmitLdcI4IL.Emit(OpCodes.Br, label3)
7624
EmitLdcI4IL.MarkSequencePoint(doc3, 363, 1, 363, 100)
7594
7625
EmitLdcI4IL.MarkLabel(label3)
7595
EmitLdcI4IL.MarkSequencePoint(doc3, 359, 1, 359, 100)
7626
EmitLdcI4IL.MarkSequencePoint(doc3, 364, 1, 364, 100)
7596
7627
EmitLdcI4IL.Emit(OpCodes.Ret)
7597
Dim typ103(-1) As Type
7598
ReDim Preserve typ103(UBound(typ103) + 1)
7599
typ103(UBound(typ103)) = GetType(System.Int16)
7600
Dim EmitLdcI2 As MethodBuilder = ILEmitter.DefineMethod("EmitLdcI2", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ103)
7628
Dim typ105(-1) As Type
7629
ReDim Preserve typ105(UBound(typ105) + 1)
7630
typ105(UBound(typ105)) = GetType(System.Int16)
7631
Dim EmitLdcI2 As MethodBuilder = ILEmitter.DefineMethod("EmitLdcI2", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ105)
7601
7632
Dim EmitLdcI2IL As ILGenerator = EmitLdcI2.GetILGenerator()
7602
7633
Dim EmitLdcI2param01 As ParameterBuilder = EmitLdcI2.DefineParameter(1, ParameterAttributes.None, "n")
7603
EmitLdcI2IL.MarkSequencePoint(doc3, 362, 1, 362, 100)
7604
Dim locbldr18 As LocalBuilder = EmitLdcI2IL.DeclareLocal(GetType(OpCode))
7605
locbldr18.SetLocalSymInfo("op")
7606
EmitLdcI2IL.MarkSequencePoint(doc3, 363, 1, 363, 100)
7607
Dim locbldr19 As LocalBuilder = EmitLdcI2IL.DeclareLocal(GetType(System.Int32))
7608
locbldr19.SetLocalSymInfo("num")
7634
EmitLdcI2IL.MarkSequencePoint(doc3, 367, 1, 367, 100)
7635
Dim locbldr19 As LocalBuilder = EmitLdcI2IL.DeclareLocal(GetType(OpCode))
7636
locbldr19.SetLocalSymInfo("op")
7637
EmitLdcI2IL.MarkSequencePoint(doc3, 368, 1, 368, 100)
7638
Dim locbldr20 As LocalBuilder = EmitLdcI2IL.DeclareLocal(GetType(System.Int32))
7639
locbldr20.SetLocalSymInfo("num")
7609
7640
EmitLdcI2IL.Emit(OpCodes.Ldarg, 0)
7610
7641
Typ = GetType(System.Int16)
7611
Dim typ104 As Type() = {Typ}
7612
EmitLdcI2IL.Emit(OpCodes.Call, GetType(System.Convert).GetMethod("ToInt32", typ104))
7613
Typ = GetType(System.Convert).GetMethod("ToInt32", typ104).ReturnType
7642
Dim typ106 As Type() = {Typ}
7643
EmitLdcI2IL.Emit(OpCodes.Call, GetType(System.Convert).GetMethod("ToInt32", typ106))
7644
Typ = GetType(System.Convert).GetMethod("ToInt32", typ106).ReturnType
7614
7645
EmitLdcI2IL.Emit(OpCodes.Stloc, 1)
7615
EmitLdcI2IL.MarkSequencePoint(doc3, 369, 1, 369, 100)
7646
EmitLdcI2IL.MarkSequencePoint(doc3, 374, 1, 374, 100)
7616
7647
Dim label4 As System.Reflection.Emit.Label = EmitLdcI2IL.DefineLabel()
7617
EmitLdcI2IL.MarkSequencePoint(doc3, 371, 1, 371, 100)
7648
EmitLdcI2IL.MarkSequencePoint(doc3, 376, 1, 376, 100)
7618
7649
EmitLdcI2IL.Emit(OpCodes.Ldloc, 1)
7619
7650
Typ = GetType(System.Int32)
7620
7651
EmitLdcI2IL.Emit(OpCodes.Ldc_I4, CInt(-1))
7625
7656
EmitLdcI2IL.Emit(OpCodes.Beq, tru196)
7626
7657
EmitLdcI2IL.Emit(OpCodes.Br, fa196)
7627
7658
EmitLdcI2IL.MarkLabel(tru196)
7628
EmitLdcI2IL.MarkSequencePoint(doc3, 372, 1, 372, 100)
7629
Dim typ105(-1) As Type
7659
EmitLdcI2IL.MarkSequencePoint(doc3, 377, 1, 377, 100)
7660
Dim typ107(-1) As Type
7630
7661
EmitLdcI2IL.Emit(OpCodes.Ldstr, "ldc.i4.m1")
7631
7662
Typ = GetType(System.String)
7632
ReDim Preserve typ105(UBound(typ105) + 1)
7633
typ105(UBound(typ105)) = Typ
7634
EmitLdcI2IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ105))
7635
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ105).ReturnType
7636
EmitLdcI2IL.Emit(OpCodes.Stloc, 0)
7637
EmitLdcI2IL.MarkSequencePoint(doc3, 373, 1, 373, 100)
7638
Dim typ106(-1) As Type
7639
EmitLdcI2IL.Emit(OpCodes.Ldsfld, ILGen)
7640
Typ = ILGen.FieldType
7641
Typ03 = Typ
7642
EmitLdcI2IL.Emit(OpCodes.Ldloc, 0)
7643
Typ = GetType(OpCode)
7644
ReDim Preserve typ106(UBound(typ106) + 1)
7645
typ106(UBound(typ106)) = Typ
7646
EmitLdcI2IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ106))
7647
Typ = Typ03.GetMethod("Emit", typ106).ReturnType
7648
If Typ.ToString() = GetType(System.Void).ToString() Then
7649
7650
Else
7651
EmitLdcI2IL.Emit(OpCodes.Pop)
7652
End If
7653
EmitLdcI2IL.MarkSequencePoint(doc3, 374, 1, 374, 100)
7654
Dim typ107(-1) As Type
7655
EmitLdcI2IL.Emit(OpCodes.Ldstr, "conv.i2")
7656
Typ = GetType(System.String)
7657
7663
ReDim Preserve typ107(UBound(typ107) + 1)
7658
7664
typ107(UBound(typ107)) = Typ
7659
7665
EmitLdcI2IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ107))
7660
7666
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ107).ReturnType
7661
7667
EmitLdcI2IL.Emit(OpCodes.Stloc, 0)
7662
EmitLdcI2IL.MarkSequencePoint(doc3, 375, 1, 375, 100)
7668
EmitLdcI2IL.MarkSequencePoint(doc3, 378, 1, 378, 100)
7663
7669
Dim typ108(-1) As Type
7664
7670
EmitLdcI2IL.Emit(OpCodes.Ldsfld, ILGen)
7665
7671
Typ = ILGen.FieldType
7675
7681
Else
7676
7682
EmitLdcI2IL.Emit(OpCodes.Pop)
7677
7683
End If
7678
EmitLdcI2IL.MarkSequencePoint(doc3, 376, 1, 376, 100)
7684
EmitLdcI2IL.MarkSequencePoint(doc3, 379, 1, 379, 100)
7685
Dim typ109(-1) As Type
7686
EmitLdcI2IL.Emit(OpCodes.Ldstr, "conv.i2")
7687
Typ = GetType(System.String)
7688
ReDim Preserve typ109(UBound(typ109) + 1)
7689
typ109(UBound(typ109)) = Typ
7690
EmitLdcI2IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ109))
7691
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ109).ReturnType
7692
EmitLdcI2IL.Emit(OpCodes.Stloc, 0)
7693
EmitLdcI2IL.MarkSequencePoint(doc3, 380, 1, 380, 100)
7694
Dim typ110(-1) As Type
7695
EmitLdcI2IL.Emit(OpCodes.Ldsfld, ILGen)
7696
Typ = ILGen.FieldType
7697
Typ03 = Typ
7698
EmitLdcI2IL.Emit(OpCodes.Ldloc, 0)
7699
Typ = GetType(OpCode)
7700
ReDim Preserve typ110(UBound(typ110) + 1)
7701
typ110(UBound(typ110)) = Typ
7702
EmitLdcI2IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ110))
7703
Typ = Typ03.GetMethod("Emit", typ110).ReturnType
7704
If Typ.ToString() = GetType(System.Void).ToString() Then
7705
7706
Else
7707
EmitLdcI2IL.Emit(OpCodes.Pop)
7708
End If
7709
EmitLdcI2IL.MarkSequencePoint(doc3, 381, 1, 381, 100)
7679
7710
EmitLdcI2IL.Emit(OpCodes.Br, label4)
7680
EmitLdcI2IL.MarkSequencePoint(doc3, 377, 1, 377, 100)
7711
EmitLdcI2IL.MarkSequencePoint(doc3, 382, 1, 382, 100)
7681
7712
EmitLdcI2IL.Emit(OpCodes.Br, cont196)
7682
7713
EmitLdcI2IL.MarkLabel(fa196)
7683
7714
EmitLdcI2IL.Emit(OpCodes.Br, cont196)
7684
7715
EmitLdcI2IL.MarkLabel(cont196)
7685
EmitLdcI2IL.MarkSequencePoint(doc3, 379, 1, 379, 100)
7716
EmitLdcI2IL.MarkSequencePoint(doc3, 384, 1, 384, 100)
7686
7717
EmitLdcI2IL.Emit(OpCodes.Ldloc, 1)
7687
7718
Typ = GetType(System.Int32)
7688
7719
EmitLdcI2IL.Emit(OpCodes.Ldc_I4, CInt(0))
7693
7724
EmitLdcI2IL.Emit(OpCodes.Beq, tru197)
7694
7725
EmitLdcI2IL.Emit(OpCodes.Br, fa197)
7695
7726
EmitLdcI2IL.MarkLabel(tru197)
7696
EmitLdcI2IL.MarkSequencePoint(doc3, 380, 1, 380, 100)
7697
Dim typ109(-1) As Type
7727
EmitLdcI2IL.MarkSequencePoint(doc3, 385, 1, 385, 100)
7728
Dim typ111(-1) As Type
7698
7729
EmitLdcI2IL.Emit(OpCodes.Ldstr, "ldc.i4.0")
7699
7730
Typ = GetType(System.String)
7700
ReDim Preserve typ109(UBound(typ109) + 1)
7701
typ109(UBound(typ109)) = Typ
7702
EmitLdcI2IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ109))
7703
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ109).ReturnType
7704
EmitLdcI2IL.Emit(OpCodes.Stloc, 0)
7705
EmitLdcI2IL.MarkSequencePoint(doc3, 381, 1, 381, 100)
7706
Dim typ110(-1) As Type
7707
EmitLdcI2IL.Emit(OpCodes.Ldsfld, ILGen)
7708
Typ = ILGen.FieldType
7709
Typ03 = Typ
7710
EmitLdcI2IL.Emit(OpCodes.Ldloc, 0)
7711
Typ = GetType(OpCode)
7712
ReDim Preserve typ110(UBound(typ110) + 1)
7713
typ110(UBound(typ110)) = Typ
7714
EmitLdcI2IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ110))
7715
Typ = Typ03.GetMethod("Emit", typ110).ReturnType
7716
If Typ.ToString() = GetType(System.Void).ToString() Then
7717
7718
Else
7719
EmitLdcI2IL.Emit(OpCodes.Pop)
7720
End If
7721
EmitLdcI2IL.MarkSequencePoint(doc3, 382, 1, 382, 100)
7722
Dim typ111(-1) As Type
7723
EmitLdcI2IL.Emit(OpCodes.Ldstr, "conv.i2")
7724
Typ = GetType(System.String)
7725
7731
ReDim Preserve typ111(UBound(typ111) + 1)
7726
7732
typ111(UBound(typ111)) = Typ
7727
7733
EmitLdcI2IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ111))
7728
7734
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ111).ReturnType
7729
7735
EmitLdcI2IL.Emit(OpCodes.Stloc, 0)
7730
EmitLdcI2IL.MarkSequencePoint(doc3, 383, 1, 383, 100)
7736
EmitLdcI2IL.MarkSequencePoint(doc3, 386, 1, 386, 100)
7731
7737
Dim typ112(-1) As Type
7732
7738
EmitLdcI2IL.Emit(OpCodes.Ldsfld, ILGen)
7733
7739
Typ = ILGen.FieldType
7743
7749
Else
7744
7750
EmitLdcI2IL.Emit(OpCodes.Pop)
7745
7751
End If
7746
EmitLdcI2IL.MarkSequencePoint(doc3, 384, 1, 384, 100)
7752
EmitLdcI2IL.MarkSequencePoint(doc3, 387, 1, 387, 100)
7753
Dim typ113(-1) As Type
7754
EmitLdcI2IL.Emit(OpCodes.Ldstr, "conv.i2")
7755
Typ = GetType(System.String)
7756
ReDim Preserve typ113(UBound(typ113) + 1)
7757
typ113(UBound(typ113)) = Typ
7758
EmitLdcI2IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ113))
7759
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ113).ReturnType
7760
EmitLdcI2IL.Emit(OpCodes.Stloc, 0)
7761
EmitLdcI2IL.MarkSequencePoint(doc3, 388, 1, 388, 100)
7762
Dim typ114(-1) As Type
7763
EmitLdcI2IL.Emit(OpCodes.Ldsfld, ILGen)
7764
Typ = ILGen.FieldType
7765
Typ03 = Typ
7766
EmitLdcI2IL.Emit(OpCodes.Ldloc, 0)
7767
Typ = GetType(OpCode)
7768
ReDim Preserve typ114(UBound(typ114) + 1)
7769
typ114(UBound(typ114)) = Typ
7770
EmitLdcI2IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ114))
7771
Typ = Typ03.GetMethod("Emit", typ114).ReturnType
7772
If Typ.ToString() = GetType(System.Void).ToString() Then
7773
7774
Else
7775
EmitLdcI2IL.Emit(OpCodes.Pop)
7776
End If
7777
EmitLdcI2IL.MarkSequencePoint(doc3, 389, 1, 389, 100)
7747
7778
EmitLdcI2IL.Emit(OpCodes.Br, label4)
7748
EmitLdcI2IL.MarkSequencePoint(doc3, 385, 1, 385, 100)
7779
EmitLdcI2IL.MarkSequencePoint(doc3, 390, 1, 390, 100)
7749
7780
EmitLdcI2IL.Emit(OpCodes.Br, cont197)
7750
7781
EmitLdcI2IL.MarkLabel(fa197)
7751
7782
EmitLdcI2IL.Emit(OpCodes.Br, cont197)
7752
7783
EmitLdcI2IL.MarkLabel(cont197)
7753
EmitLdcI2IL.MarkSequencePoint(doc3, 387, 1, 387, 100)
7784
EmitLdcI2IL.MarkSequencePoint(doc3, 392, 1, 392, 100)
7754
7785
EmitLdcI2IL.Emit(OpCodes.Ldloc, 1)
7755
7786
Typ = GetType(System.Int32)
7756
7787
EmitLdcI2IL.Emit(OpCodes.Ldc_I4, CInt(1))
7761
7792
EmitLdcI2IL.Emit(OpCodes.Beq, tru198)
7762
7793
EmitLdcI2IL.Emit(OpCodes.Br, fa198)
7763
7794
EmitLdcI2IL.MarkLabel(tru198)
7764
EmitLdcI2IL.MarkSequencePoint(doc3, 388, 1, 388, 100)
7765
Dim typ113(-1) As Type
7795
EmitLdcI2IL.MarkSequencePoint(doc3, 393, 1, 393, 100)
7796
Dim typ115(-1) As Type
7766
7797
EmitLdcI2IL.Emit(OpCodes.Ldstr, "ldc.i4.1")
7767
7798
Typ = GetType(System.String)
7768
ReDim Preserve typ113(UBound(typ113) + 1)
7769
typ113(UBound(typ113)) = Typ
7770
EmitLdcI2IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ113))
7771
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ113).ReturnType
7772
EmitLdcI2IL.Emit(OpCodes.Stloc, 0)
7773
EmitLdcI2IL.MarkSequencePoint(doc3, 389, 1, 389, 100)
7774
Dim typ114(-1) As Type
7775
EmitLdcI2IL.Emit(OpCodes.Ldsfld, ILGen)
7776
Typ = ILGen.FieldType
7777
Typ03 = Typ
7778
EmitLdcI2IL.Emit(OpCodes.Ldloc, 0)
7779
Typ = GetType(OpCode)
7780
ReDim Preserve typ114(UBound(typ114) + 1)
7781
typ114(UBound(typ114)) = Typ
7782
EmitLdcI2IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ114))
7783
Typ = Typ03.GetMethod("Emit", typ114).ReturnType
7784
If Typ.ToString() = GetType(System.Void).ToString() Then
7785
7786
Else
7787
EmitLdcI2IL.Emit(OpCodes.Pop)
7788
End If
7789
EmitLdcI2IL.MarkSequencePoint(doc3, 390, 1, 390, 100)
7790
Dim typ115(-1) As Type
7791
EmitLdcI2IL.Emit(OpCodes.Ldstr, "conv.i2")
7792
Typ = GetType(System.String)
7793
7799
ReDim Preserve typ115(UBound(typ115) + 1)
7794
7800
typ115(UBound(typ115)) = Typ
7795
7801
EmitLdcI2IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ115))
7796
7802
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ115).ReturnType
7797
7803
EmitLdcI2IL.Emit(OpCodes.Stloc, 0)
7798
EmitLdcI2IL.MarkSequencePoint(doc3, 391, 1, 391, 100)
7804
EmitLdcI2IL.MarkSequencePoint(doc3, 394, 1, 394, 100)
7799
7805
Dim typ116(-1) As Type
7800
7806
EmitLdcI2IL.Emit(OpCodes.Ldsfld, ILGen)
7801
7807
Typ = ILGen.FieldType
7811
7817
Else
7812
7818
EmitLdcI2IL.Emit(OpCodes.Pop)
7813
7819
End If
7814
EmitLdcI2IL.MarkSequencePoint(doc3, 392, 1, 392, 100)
7820
EmitLdcI2IL.MarkSequencePoint(doc3, 395, 1, 395, 100)
7821
Dim typ117(-1) As Type
7822
EmitLdcI2IL.Emit(OpCodes.Ldstr, "conv.i2")
7823
Typ = GetType(System.String)
7824
ReDim Preserve typ117(UBound(typ117) + 1)
7825
typ117(UBound(typ117)) = Typ
7826
EmitLdcI2IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ117))
7827
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ117).ReturnType
7828
EmitLdcI2IL.Emit(OpCodes.Stloc, 0)
7829
EmitLdcI2IL.MarkSequencePoint(doc3, 396, 1, 396, 100)
7830
Dim typ118(-1) As Type
7831
EmitLdcI2IL.Emit(OpCodes.Ldsfld, ILGen)
7832
Typ = ILGen.FieldType
7833
Typ03 = Typ
7834
EmitLdcI2IL.Emit(OpCodes.Ldloc, 0)
7835
Typ = GetType(OpCode)
7836
ReDim Preserve typ118(UBound(typ118) + 1)
7837
typ118(UBound(typ118)) = Typ
7838
EmitLdcI2IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ118))
7839
Typ = Typ03.GetMethod("Emit", typ118).ReturnType
7840
If Typ.ToString() = GetType(System.Void).ToString() Then
7841
7842
Else
7843
EmitLdcI2IL.Emit(OpCodes.Pop)
7844
End If
7845
EmitLdcI2IL.MarkSequencePoint(doc3, 397, 1, 397, 100)
7815
7846
EmitLdcI2IL.Emit(OpCodes.Br, label4)
7816
EmitLdcI2IL.MarkSequencePoint(doc3, 393, 1, 393, 100)
7847
EmitLdcI2IL.MarkSequencePoint(doc3, 398, 1, 398, 100)
7817
7848
EmitLdcI2IL.Emit(OpCodes.Br, cont198)
7818
7849
EmitLdcI2IL.MarkLabel(fa198)
7819
7850
EmitLdcI2IL.Emit(OpCodes.Br, cont198)
7820
7851
EmitLdcI2IL.MarkLabel(cont198)
7821
EmitLdcI2IL.MarkSequencePoint(doc3, 395, 1, 395, 100)
7852
EmitLdcI2IL.MarkSequencePoint(doc3, 400, 1, 400, 100)
7822
7853
EmitLdcI2IL.Emit(OpCodes.Ldloc, 1)
7823
7854
Typ = GetType(System.Int32)
7824
7855
EmitLdcI2IL.Emit(OpCodes.Ldc_I4, CInt(2))
7829
7860
EmitLdcI2IL.Emit(OpCodes.Beq, tru199)
7830
7861
EmitLdcI2IL.Emit(OpCodes.Br, fa199)
7831
7862
EmitLdcI2IL.MarkLabel(tru199)
7832
EmitLdcI2IL.MarkSequencePoint(doc3, 396, 1, 396, 100)
7833
Dim typ117(-1) As Type
7863
EmitLdcI2IL.MarkSequencePoint(doc3, 401, 1, 401, 100)
7864
Dim typ119(-1) As Type
7834
7865
EmitLdcI2IL.Emit(OpCodes.Ldstr, "ldc.i4.2")
7835
7866
Typ = GetType(System.String)
7836
ReDim Preserve typ117(UBound(typ117) + 1)
7837
typ117(UBound(typ117)) = Typ
7838
EmitLdcI2IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ117))
7839
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ117).ReturnType
7840
EmitLdcI2IL.Emit(OpCodes.Stloc, 0)
7841
EmitLdcI2IL.MarkSequencePoint(doc3, 397, 1, 397, 100)
7842
Dim typ118(-1) As Type
7843
EmitLdcI2IL.Emit(OpCodes.Ldsfld, ILGen)
7844
Typ = ILGen.FieldType
7845
Typ03 = Typ
7846
EmitLdcI2IL.Emit(OpCodes.Ldloc, 0)
7847
Typ = GetType(OpCode)
7848
ReDim Preserve typ118(UBound(typ118) + 1)
7849
typ118(UBound(typ118)) = Typ
7850
EmitLdcI2IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ118))
7851
Typ = Typ03.GetMethod("Emit", typ118).ReturnType
7852
If Typ.ToString() = GetType(System.Void).ToString() Then
7853
7854
Else
7855
EmitLdcI2IL.Emit(OpCodes.Pop)
7856
End If
7857
EmitLdcI2IL.MarkSequencePoint(doc3, 398, 1, 398, 100)
7858
Dim typ119(-1) As Type
7859
EmitLdcI2IL.Emit(OpCodes.Ldstr, "conv.i2")
7860
Typ = GetType(System.String)
7861
7867
ReDim Preserve typ119(UBound(typ119) + 1)
7862
7868
typ119(UBound(typ119)) = Typ
7863
7869
EmitLdcI2IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ119))
7864
7870
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ119).ReturnType
7865
7871
EmitLdcI2IL.Emit(OpCodes.Stloc, 0)
7866
EmitLdcI2IL.MarkSequencePoint(doc3, 399, 1, 399, 100)
7872
EmitLdcI2IL.MarkSequencePoint(doc3, 402, 1, 402, 100)
7867
7873
Dim typ120(-1) As Type
7868
7874
EmitLdcI2IL.Emit(OpCodes.Ldsfld, ILGen)
7869
7875
Typ = ILGen.FieldType
7879
7885
Else
7880
7886
EmitLdcI2IL.Emit(OpCodes.Pop)
7881
7887
End If
7882
EmitLdcI2IL.MarkSequencePoint(doc3, 400, 1, 400, 100)
7888
EmitLdcI2IL.MarkSequencePoint(doc3, 403, 1, 403, 100)
7889
Dim typ121(-1) As Type
7890
EmitLdcI2IL.Emit(OpCodes.Ldstr, "conv.i2")
7891
Typ = GetType(System.String)
7892
ReDim Preserve typ121(UBound(typ121) + 1)
7893
typ121(UBound(typ121)) = Typ
7894
EmitLdcI2IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ121))
7895
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ121).ReturnType
7896
EmitLdcI2IL.Emit(OpCodes.Stloc, 0)
7897
EmitLdcI2IL.MarkSequencePoint(doc3, 404, 1, 404, 100)
7898
Dim typ122(-1) As Type
7899
EmitLdcI2IL.Emit(OpCodes.Ldsfld, ILGen)
7900
Typ = ILGen.FieldType
7901
Typ03 = Typ
7902
EmitLdcI2IL.Emit(OpCodes.Ldloc, 0)
7903
Typ = GetType(OpCode)
7904
ReDim Preserve typ122(UBound(typ122) + 1)
7905
typ122(UBound(typ122)) = Typ
7906
EmitLdcI2IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ122))
7907
Typ = Typ03.GetMethod("Emit", typ122).ReturnType
7908
If Typ.ToString() = GetType(System.Void).ToString() Then
7909
7910
Else
7911
EmitLdcI2IL.Emit(OpCodes.Pop)
7912
End If
7913
EmitLdcI2IL.MarkSequencePoint(doc3, 405, 1, 405, 100)
7883
7914
EmitLdcI2IL.Emit(OpCodes.Br, label4)
7884
EmitLdcI2IL.MarkSequencePoint(doc3, 401, 1, 401, 100)
7915
EmitLdcI2IL.MarkSequencePoint(doc3, 406, 1, 406, 100)
7885
7916
EmitLdcI2IL.Emit(OpCodes.Br, cont199)
7886
7917
EmitLdcI2IL.MarkLabel(fa199)
7887
7918
EmitLdcI2IL.Emit(OpCodes.Br, cont199)
7888
7919
EmitLdcI2IL.MarkLabel(cont199)
7889
EmitLdcI2IL.MarkSequencePoint(doc3, 403, 1, 403, 100)
7920
EmitLdcI2IL.MarkSequencePoint(doc3, 408, 1, 408, 100)
7890
7921
EmitLdcI2IL.Emit(OpCodes.Ldloc, 1)
7891
7922
Typ = GetType(System.Int32)
7892
7923
EmitLdcI2IL.Emit(OpCodes.Ldc_I4, CInt(3))
7897
7928
EmitLdcI2IL.Emit(OpCodes.Beq, tru200)
7898
7929
EmitLdcI2IL.Emit(OpCodes.Br, fa200)
7899
7930
EmitLdcI2IL.MarkLabel(tru200)
7900
EmitLdcI2IL.MarkSequencePoint(doc3, 404, 1, 404, 100)
7901
Dim typ121(-1) As Type
7931
EmitLdcI2IL.MarkSequencePoint(doc3, 409, 1, 409, 100)
7932
Dim typ123(-1) As Type
7902
7933
EmitLdcI2IL.Emit(OpCodes.Ldstr, "ldc.i4.3")
7903
7934
Typ = GetType(System.String)
7904
ReDim Preserve typ121(UBound(typ121) + 1)
7905
typ121(UBound(typ121)) = Typ
7906
EmitLdcI2IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ121))
7907
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ121).ReturnType
7908
EmitLdcI2IL.Emit(OpCodes.Stloc, 0)
7909
EmitLdcI2IL.MarkSequencePoint(doc3, 405, 1, 405, 100)
7910
Dim typ122(-1) As Type
7911
EmitLdcI2IL.Emit(OpCodes.Ldsfld, ILGen)
7912
Typ = ILGen.FieldType
7913
Typ03 = Typ
7914
EmitLdcI2IL.Emit(OpCodes.Ldloc, 0)
7915
Typ = GetType(OpCode)
7916
ReDim Preserve typ122(UBound(typ122) + 1)
7917
typ122(UBound(typ122)) = Typ
7918
EmitLdcI2IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ122))
7919
Typ = Typ03.GetMethod("Emit", typ122).ReturnType
7920
If Typ.ToString() = GetType(System.Void).ToString() Then
7921
7922
Else
7923
EmitLdcI2IL.Emit(OpCodes.Pop)
7924
End If
7925
EmitLdcI2IL.MarkSequencePoint(doc3, 406, 1, 406, 100)
7926
Dim typ123(-1) As Type
7927
EmitLdcI2IL.Emit(OpCodes.Ldstr, "conv.i2")
7928
Typ = GetType(System.String)
7929
7935
ReDim Preserve typ123(UBound(typ123) + 1)
7930
7936
typ123(UBound(typ123)) = Typ
7931
7937
EmitLdcI2IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ123))
7932
7938
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ123).ReturnType
7933
7939
EmitLdcI2IL.Emit(OpCodes.Stloc, 0)
7934
EmitLdcI2IL.MarkSequencePoint(doc3, 407, 1, 407, 100)
7940
EmitLdcI2IL.MarkSequencePoint(doc3, 410, 1, 410, 100)
7935
7941
Dim typ124(-1) As Type
7936
7942
EmitLdcI2IL.Emit(OpCodes.Ldsfld, ILGen)
7937
7943
Typ = ILGen.FieldType
7947
7953
Else
7948
7954
EmitLdcI2IL.Emit(OpCodes.Pop)
7949
7955
End If
7950
EmitLdcI2IL.MarkSequencePoint(doc3, 408, 1, 408, 100)
7956
EmitLdcI2IL.MarkSequencePoint(doc3, 411, 1, 411, 100)
7957
Dim typ125(-1) As Type
7958
EmitLdcI2IL.Emit(OpCodes.Ldstr, "conv.i2")
7959
Typ = GetType(System.String)
7960
ReDim Preserve typ125(UBound(typ125) + 1)
7961
typ125(UBound(typ125)) = Typ
7962
EmitLdcI2IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ125))
7963
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ125).ReturnType
7964
EmitLdcI2IL.Emit(OpCodes.Stloc, 0)
7965
EmitLdcI2IL.MarkSequencePoint(doc3, 412, 1, 412, 100)
7966
Dim typ126(-1) As Type
7967
EmitLdcI2IL.Emit(OpCodes.Ldsfld, ILGen)
7968
Typ = ILGen.FieldType
7969
Typ03 = Typ
7970
EmitLdcI2IL.Emit(OpCodes.Ldloc, 0)
7971
Typ = GetType(OpCode)
7972
ReDim Preserve typ126(UBound(typ126) + 1)
7973
typ126(UBound(typ126)) = Typ
7974
EmitLdcI2IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ126))
7975
Typ = Typ03.GetMethod("Emit", typ126).ReturnType
7976
If Typ.ToString() = GetType(System.Void).ToString() Then
7977
7978
Else
7979
EmitLdcI2IL.Emit(OpCodes.Pop)
7980
End If
7981
EmitLdcI2IL.MarkSequencePoint(doc3, 413, 1, 413, 100)
7951
7982
EmitLdcI2IL.Emit(OpCodes.Br, label4)
7952
EmitLdcI2IL.MarkSequencePoint(doc3, 409, 1, 409, 100)
7983
EmitLdcI2IL.MarkSequencePoint(doc3, 414, 1, 414, 100)
7953
7984
EmitLdcI2IL.Emit(OpCodes.Br, cont200)
7954
7985
EmitLdcI2IL.MarkLabel(fa200)
7955
7986
EmitLdcI2IL.Emit(OpCodes.Br, cont200)
7956
7987
EmitLdcI2IL.MarkLabel(cont200)
7957
EmitLdcI2IL.MarkSequencePoint(doc3, 411, 1, 411, 100)
7988
EmitLdcI2IL.MarkSequencePoint(doc3, 416, 1, 416, 100)
7958
7989
EmitLdcI2IL.Emit(OpCodes.Ldloc, 1)
7959
7990
Typ = GetType(System.Int32)
7960
7991
EmitLdcI2IL.Emit(OpCodes.Ldc_I4, CInt(4))
7965
7996
EmitLdcI2IL.Emit(OpCodes.Beq, tru201)
7966
7997
EmitLdcI2IL.Emit(OpCodes.Br, fa201)
7967
7998
EmitLdcI2IL.MarkLabel(tru201)
7968
EmitLdcI2IL.MarkSequencePoint(doc3, 412, 1, 412, 100)
7969
Dim typ125(-1) As Type
7999
EmitLdcI2IL.MarkSequencePoint(doc3, 417, 1, 417, 100)
8000
Dim typ127(-1) As Type
7970
8001
EmitLdcI2IL.Emit(OpCodes.Ldstr, "ldc.i4.4")
7971
8002
Typ = GetType(System.String)
7972
ReDim Preserve typ125(UBound(typ125) + 1)
7973
typ125(UBound(typ125)) = Typ
7974
EmitLdcI2IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ125))
7975
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ125).ReturnType
7976
EmitLdcI2IL.Emit(OpCodes.Stloc, 0)
7977
EmitLdcI2IL.MarkSequencePoint(doc3, 413, 1, 413, 100)
7978
Dim typ126(-1) As Type
7979
EmitLdcI2IL.Emit(OpCodes.Ldsfld, ILGen)
7980
Typ = ILGen.FieldType
7981
Typ03 = Typ
7982
EmitLdcI2IL.Emit(OpCodes.Ldloc, 0)
7983
Typ = GetType(OpCode)
7984
ReDim Preserve typ126(UBound(typ126) + 1)
7985
typ126(UBound(typ126)) = Typ
7986
EmitLdcI2IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ126))
7987
Typ = Typ03.GetMethod("Emit", typ126).ReturnType
7988
If Typ.ToString() = GetType(System.Void).ToString() Then
7989
7990
Else
7991
EmitLdcI2IL.Emit(OpCodes.Pop)
7992
End If
7993
EmitLdcI2IL.MarkSequencePoint(doc3, 414, 1, 414, 100)
7994
Dim typ127(-1) As Type
7995
EmitLdcI2IL.Emit(OpCodes.Ldstr, "conv.i2")
7996
Typ = GetType(System.String)
7997
8003
ReDim Preserve typ127(UBound(typ127) + 1)
7998
8004
typ127(UBound(typ127)) = Typ
7999
8005
EmitLdcI2IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ127))
8000
8006
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ127).ReturnType
8001
8007
EmitLdcI2IL.Emit(OpCodes.Stloc, 0)
8002
EmitLdcI2IL.MarkSequencePoint(doc3, 415, 1, 415, 100)
8008
EmitLdcI2IL.MarkSequencePoint(doc3, 418, 1, 418, 100)
8003
8009
Dim typ128(-1) As Type
8004
8010
EmitLdcI2IL.Emit(OpCodes.Ldsfld, ILGen)
8005
8011
Typ = ILGen.FieldType
8015
8021
Else
8016
8022
EmitLdcI2IL.Emit(OpCodes.Pop)
8017
8023
End If
8018
EmitLdcI2IL.MarkSequencePoint(doc3, 416, 1, 416, 100)
8024
EmitLdcI2IL.MarkSequencePoint(doc3, 419, 1, 419, 100)
8025
Dim typ129(-1) As Type
8026
EmitLdcI2IL.Emit(OpCodes.Ldstr, "conv.i2")
8027
Typ = GetType(System.String)
8028
ReDim Preserve typ129(UBound(typ129) + 1)
8029
typ129(UBound(typ129)) = Typ
8030
EmitLdcI2IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ129))
8031
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ129).ReturnType
8032
EmitLdcI2IL.Emit(OpCodes.Stloc, 0)
8033
EmitLdcI2IL.MarkSequencePoint(doc3, 420, 1, 420, 100)
8034
Dim typ130(-1) As Type
8035
EmitLdcI2IL.Emit(OpCodes.Ldsfld, ILGen)
8036
Typ = ILGen.FieldType
8037
Typ03 = Typ
8038
EmitLdcI2IL.Emit(OpCodes.Ldloc, 0)
8039
Typ = GetType(OpCode)
8040
ReDim Preserve typ130(UBound(typ130) + 1)
8041
typ130(UBound(typ130)) = Typ
8042
EmitLdcI2IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ130))
8043
Typ = Typ03.GetMethod("Emit", typ130).ReturnType
8044
If Typ.ToString() = GetType(System.Void).ToString() Then
8045
8046
Else
8047
EmitLdcI2IL.Emit(OpCodes.Pop)
8048
End If
8049
EmitLdcI2IL.MarkSequencePoint(doc3, 421, 1, 421, 100)
8019
8050
EmitLdcI2IL.Emit(OpCodes.Br, label4)
8020
EmitLdcI2IL.MarkSequencePoint(doc3, 417, 1, 417, 100)
8051
EmitLdcI2IL.MarkSequencePoint(doc3, 422, 1, 422, 100)
8021
8052
EmitLdcI2IL.Emit(OpCodes.Br, cont201)
8022
8053
EmitLdcI2IL.MarkLabel(fa201)
8023
8054
EmitLdcI2IL.Emit(OpCodes.Br, cont201)
8024
8055
EmitLdcI2IL.MarkLabel(cont201)
8025
EmitLdcI2IL.MarkSequencePoint(doc3, 419, 1, 419, 100)
8056
EmitLdcI2IL.MarkSequencePoint(doc3, 424, 1, 424, 100)
8026
8057
EmitLdcI2IL.Emit(OpCodes.Ldloc, 1)
8027
8058
Typ = GetType(System.Int32)
8028
8059
EmitLdcI2IL.Emit(OpCodes.Ldc_I4, CInt(5))
8033
8064
EmitLdcI2IL.Emit(OpCodes.Beq, tru202)
8034
8065
EmitLdcI2IL.Emit(OpCodes.Br, fa202)
8035
8066
EmitLdcI2IL.MarkLabel(tru202)
8036
EmitLdcI2IL.MarkSequencePoint(doc3, 420, 1, 420, 100)
8037
Dim typ129(-1) As Type
8067
EmitLdcI2IL.MarkSequencePoint(doc3, 425, 1, 425, 100)
8068
Dim typ131(-1) As Type
8038
8069
EmitLdcI2IL.Emit(OpCodes.Ldstr, "ldc.i4.5")
8039
8070
Typ = GetType(System.String)
8040
ReDim Preserve typ129(UBound(typ129) + 1)
8041
typ129(UBound(typ129)) = Typ
8042
EmitLdcI2IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ129))
8043
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ129).ReturnType
8044
EmitLdcI2IL.Emit(OpCodes.Stloc, 0)
8045
EmitLdcI2IL.MarkSequencePoint(doc3, 421, 1, 421, 100)
8046
Dim typ130(-1) As Type
8047
EmitLdcI2IL.Emit(OpCodes.Ldsfld, ILGen)
8048
Typ = ILGen.FieldType
8049
Typ03 = Typ
8050
EmitLdcI2IL.Emit(OpCodes.Ldloc, 0)
8051
Typ = GetType(OpCode)
8052
ReDim Preserve typ130(UBound(typ130) + 1)
8053
typ130(UBound(typ130)) = Typ
8054
EmitLdcI2IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ130))
8055
Typ = Typ03.GetMethod("Emit", typ130).ReturnType
8056
If Typ.ToString() = GetType(System.Void).ToString() Then
8057
8058
Else
8059
EmitLdcI2IL.Emit(OpCodes.Pop)
8060
End If
8061
EmitLdcI2IL.MarkSequencePoint(doc3, 422, 1, 422, 100)
8062
Dim typ131(-1) As Type
8063
EmitLdcI2IL.Emit(OpCodes.Ldstr, "conv.i2")
8064
Typ = GetType(System.String)
8065
8071
ReDim Preserve typ131(UBound(typ131) + 1)
8066
8072
typ131(UBound(typ131)) = Typ
8067
8073
EmitLdcI2IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ131))
8068
8074
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ131).ReturnType
8069
8075
EmitLdcI2IL.Emit(OpCodes.Stloc, 0)
8070
EmitLdcI2IL.MarkSequencePoint(doc3, 423, 1, 423, 100)
8076
EmitLdcI2IL.MarkSequencePoint(doc3, 426, 1, 426, 100)
8071
8077
Dim typ132(-1) As Type
8072
8078
EmitLdcI2IL.Emit(OpCodes.Ldsfld, ILGen)
8073
8079
Typ = ILGen.FieldType
8083
8089
Else
8084
8090
EmitLdcI2IL.Emit(OpCodes.Pop)
8085
8091
End If
8086
EmitLdcI2IL.MarkSequencePoint(doc3, 424, 1, 424, 100)
8092
EmitLdcI2IL.MarkSequencePoint(doc3, 427, 1, 427, 100)
8093
Dim typ133(-1) As Type
8094
EmitLdcI2IL.Emit(OpCodes.Ldstr, "conv.i2")
8095
Typ = GetType(System.String)
8096
ReDim Preserve typ133(UBound(typ133) + 1)
8097
typ133(UBound(typ133)) = Typ
8098
EmitLdcI2IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ133))
8099
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ133).ReturnType
8100
EmitLdcI2IL.Emit(OpCodes.Stloc, 0)
8101
EmitLdcI2IL.MarkSequencePoint(doc3, 428, 1, 428, 100)
8102
Dim typ134(-1) As Type
8103
EmitLdcI2IL.Emit(OpCodes.Ldsfld, ILGen)
8104
Typ = ILGen.FieldType
8105
Typ03 = Typ
8106
EmitLdcI2IL.Emit(OpCodes.Ldloc, 0)
8107
Typ = GetType(OpCode)
8108
ReDim Preserve typ134(UBound(typ134) + 1)
8109
typ134(UBound(typ134)) = Typ
8110
EmitLdcI2IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ134))
8111
Typ = Typ03.GetMethod("Emit", typ134).ReturnType
8112
If Typ.ToString() = GetType(System.Void).ToString() Then
8113
8114
Else
8115
EmitLdcI2IL.Emit(OpCodes.Pop)
8116
End If
8117
EmitLdcI2IL.MarkSequencePoint(doc3, 429, 1, 429, 100)
8087
8118
EmitLdcI2IL.Emit(OpCodes.Br, label4)
8088
EmitLdcI2IL.MarkSequencePoint(doc3, 425, 1, 425, 100)
8119
EmitLdcI2IL.MarkSequencePoint(doc3, 430, 1, 430, 100)
8089
8120
EmitLdcI2IL.Emit(OpCodes.Br, cont202)
8090
8121
EmitLdcI2IL.MarkLabel(fa202)
8091
8122
EmitLdcI2IL.Emit(OpCodes.Br, cont202)
8092
8123
EmitLdcI2IL.MarkLabel(cont202)
8093
EmitLdcI2IL.MarkSequencePoint(doc3, 427, 1, 427, 100)
8124
EmitLdcI2IL.MarkSequencePoint(doc3, 432, 1, 432, 100)
8094
8125
EmitLdcI2IL.Emit(OpCodes.Ldloc, 1)
8095
8126
Typ = GetType(System.Int32)
8096
8127
EmitLdcI2IL.Emit(OpCodes.Ldc_I4, CInt(6))
8101
8132
EmitLdcI2IL.Emit(OpCodes.Beq, tru203)
8102
8133
EmitLdcI2IL.Emit(OpCodes.Br, fa203)
8103
8134
EmitLdcI2IL.MarkLabel(tru203)
8104
EmitLdcI2IL.MarkSequencePoint(doc3, 428, 1, 428, 100)
8105
Dim typ133(-1) As Type
8135
EmitLdcI2IL.MarkSequencePoint(doc3, 433, 1, 433, 100)
8136
Dim typ135(-1) As Type
8106
8137
EmitLdcI2IL.Emit(OpCodes.Ldstr, "ldc.i4.6")
8107
8138
Typ = GetType(System.String)
8108
ReDim Preserve typ133(UBound(typ133) + 1)
8109
typ133(UBound(typ133)) = Typ
8110
EmitLdcI2IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ133))
8111
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ133).ReturnType
8112
EmitLdcI2IL.Emit(OpCodes.Stloc, 0)
8113
EmitLdcI2IL.MarkSequencePoint(doc3, 429, 1, 429, 100)
8114
Dim typ134(-1) As Type
8115
EmitLdcI2IL.Emit(OpCodes.Ldsfld, ILGen)
8116
Typ = ILGen.FieldType
8117
Typ03 = Typ
8118
EmitLdcI2IL.Emit(OpCodes.Ldloc, 0)
8119
Typ = GetType(OpCode)
8120
ReDim Preserve typ134(UBound(typ134) + 1)
8121
typ134(UBound(typ134)) = Typ
8122
EmitLdcI2IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ134))
8123
Typ = Typ03.GetMethod("Emit", typ134).ReturnType
8124
If Typ.ToString() = GetType(System.Void).ToString() Then
8125
8126
Else
8127
EmitLdcI2IL.Emit(OpCodes.Pop)
8128
End If
8129
EmitLdcI2IL.MarkSequencePoint(doc3, 430, 1, 430, 100)
8130
Dim typ135(-1) As Type
8131
EmitLdcI2IL.Emit(OpCodes.Ldstr, "conv.i2")
8132
Typ = GetType(System.String)
8133
8139
ReDim Preserve typ135(UBound(typ135) + 1)
8134
8140
typ135(UBound(typ135)) = Typ
8135
8141
EmitLdcI2IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ135))
8136
8142
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ135).ReturnType
8137
8143
EmitLdcI2IL.Emit(OpCodes.Stloc, 0)
8138
EmitLdcI2IL.MarkSequencePoint(doc3, 431, 1, 431, 100)
8144
EmitLdcI2IL.MarkSequencePoint(doc3, 434, 1, 434, 100)
8139
8145
Dim typ136(-1) As Type
8140
8146
EmitLdcI2IL.Emit(OpCodes.Ldsfld, ILGen)
8141
8147
Typ = ILGen.FieldType
8151
8157
Else
8152
8158
EmitLdcI2IL.Emit(OpCodes.Pop)
8153
8159
End If
8154
EmitLdcI2IL.MarkSequencePoint(doc3, 432, 1, 432, 100)
8160
EmitLdcI2IL.MarkSequencePoint(doc3, 435, 1, 435, 100)
8161
Dim typ137(-1) As Type
8162
EmitLdcI2IL.Emit(OpCodes.Ldstr, "conv.i2")
8163
Typ = GetType(System.String)
8164
ReDim Preserve typ137(UBound(typ137) + 1)
8165
typ137(UBound(typ137)) = Typ
8166
EmitLdcI2IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ137))
8167
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ137).ReturnType
8168
EmitLdcI2IL.Emit(OpCodes.Stloc, 0)
8169
EmitLdcI2IL.MarkSequencePoint(doc3, 436, 1, 436, 100)
8170
Dim typ138(-1) As Type
8171
EmitLdcI2IL.Emit(OpCodes.Ldsfld, ILGen)
8172
Typ = ILGen.FieldType
8173
Typ03 = Typ
8174
EmitLdcI2IL.Emit(OpCodes.Ldloc, 0)
8175
Typ = GetType(OpCode)
8176
ReDim Preserve typ138(UBound(typ138) + 1)
8177
typ138(UBound(typ138)) = Typ
8178
EmitLdcI2IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ138))
8179
Typ = Typ03.GetMethod("Emit", typ138).ReturnType
8180
If Typ.ToString() = GetType(System.Void).ToString() Then
8181
8182
Else
8183
EmitLdcI2IL.Emit(OpCodes.Pop)
8184
End If
8185
EmitLdcI2IL.MarkSequencePoint(doc3, 437, 1, 437, 100)
8155
8186
EmitLdcI2IL.Emit(OpCodes.Br, label4)
8156
EmitLdcI2IL.MarkSequencePoint(doc3, 433, 1, 433, 100)
8187
EmitLdcI2IL.MarkSequencePoint(doc3, 438, 1, 438, 100)
8157
8188
EmitLdcI2IL.Emit(OpCodes.Br, cont203)
8158
8189
EmitLdcI2IL.MarkLabel(fa203)
8159
8190
EmitLdcI2IL.Emit(OpCodes.Br, cont203)
8160
8191
EmitLdcI2IL.MarkLabel(cont203)
8161
EmitLdcI2IL.MarkSequencePoint(doc3, 435, 1, 435, 100)
8192
EmitLdcI2IL.MarkSequencePoint(doc3, 440, 1, 440, 100)
8162
8193
EmitLdcI2IL.Emit(OpCodes.Ldloc, 1)
8163
8194
Typ = GetType(System.Int32)
8164
8195
EmitLdcI2IL.Emit(OpCodes.Ldc_I4, CInt(7))
8169
8200
EmitLdcI2IL.Emit(OpCodes.Beq, tru204)
8170
8201
EmitLdcI2IL.Emit(OpCodes.Br, fa204)
8171
8202
EmitLdcI2IL.MarkLabel(tru204)
8172
EmitLdcI2IL.MarkSequencePoint(doc3, 436, 1, 436, 100)
8173
Dim typ137(-1) As Type
8203
EmitLdcI2IL.MarkSequencePoint(doc3, 441, 1, 441, 100)
8204
Dim typ139(-1) As Type
8174
8205
EmitLdcI2IL.Emit(OpCodes.Ldstr, "ldc.i4.7")
8175
8206
Typ = GetType(System.String)
8176
ReDim Preserve typ137(UBound(typ137) + 1)
8177
typ137(UBound(typ137)) = Typ
8178
EmitLdcI2IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ137))
8179
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ137).ReturnType
8180
EmitLdcI2IL.Emit(OpCodes.Stloc, 0)
8181
EmitLdcI2IL.MarkSequencePoint(doc3, 437, 1, 437, 100)
8182
Dim typ138(-1) As Type
8183
EmitLdcI2IL.Emit(OpCodes.Ldsfld, ILGen)
8184
Typ = ILGen.FieldType
8185
Typ03 = Typ
8186
EmitLdcI2IL.Emit(OpCodes.Ldloc, 0)
8187
Typ = GetType(OpCode)
8188
ReDim Preserve typ138(UBound(typ138) + 1)
8189
typ138(UBound(typ138)) = Typ
8190
EmitLdcI2IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ138))
8191
Typ = Typ03.GetMethod("Emit", typ138).ReturnType
8192
If Typ.ToString() = GetType(System.Void).ToString() Then
8193
8194
Else
8195
EmitLdcI2IL.Emit(OpCodes.Pop)
8196
End If
8197
EmitLdcI2IL.MarkSequencePoint(doc3, 438, 1, 438, 100)
8198
Dim typ139(-1) As Type
8199
EmitLdcI2IL.Emit(OpCodes.Ldstr, "conv.i2")
8200
Typ = GetType(System.String)
8201
8207
ReDim Preserve typ139(UBound(typ139) + 1)
8202
8208
typ139(UBound(typ139)) = Typ
8203
8209
EmitLdcI2IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ139))
8204
8210
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ139).ReturnType
8205
8211
EmitLdcI2IL.Emit(OpCodes.Stloc, 0)
8206
EmitLdcI2IL.MarkSequencePoint(doc3, 439, 1, 439, 100)
8212
EmitLdcI2IL.MarkSequencePoint(doc3, 442, 1, 442, 100)
8207
8213
Dim typ140(-1) As Type
8208
8214
EmitLdcI2IL.Emit(OpCodes.Ldsfld, ILGen)
8209
8215
Typ = ILGen.FieldType
8219
8225
Else
8220
8226
EmitLdcI2IL.Emit(OpCodes.Pop)
8221
8227
End If
8222
EmitLdcI2IL.MarkSequencePoint(doc3, 440, 1, 440, 100)
8228
EmitLdcI2IL.MarkSequencePoint(doc3, 443, 1, 443, 100)
8229
Dim typ141(-1) As Type
8230
EmitLdcI2IL.Emit(OpCodes.Ldstr, "conv.i2")
8231
Typ = GetType(System.String)
8232
ReDim Preserve typ141(UBound(typ141) + 1)
8233
typ141(UBound(typ141)) = Typ
8234
EmitLdcI2IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ141))
8235
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ141).ReturnType
8236
EmitLdcI2IL.Emit(OpCodes.Stloc, 0)
8237
EmitLdcI2IL.MarkSequencePoint(doc3, 444, 1, 444, 100)
8238
Dim typ142(-1) As Type
8239
EmitLdcI2IL.Emit(OpCodes.Ldsfld, ILGen)
8240
Typ = ILGen.FieldType
8241
Typ03 = Typ
8242
EmitLdcI2IL.Emit(OpCodes.Ldloc, 0)
8243
Typ = GetType(OpCode)
8244
ReDim Preserve typ142(UBound(typ142) + 1)
8245
typ142(UBound(typ142)) = Typ
8246
EmitLdcI2IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ142))
8247
Typ = Typ03.GetMethod("Emit", typ142).ReturnType
8248
If Typ.ToString() = GetType(System.Void).ToString() Then
8249
8250
Else
8251
EmitLdcI2IL.Emit(OpCodes.Pop)
8252
End If
8253
EmitLdcI2IL.MarkSequencePoint(doc3, 445, 1, 445, 100)
8223
8254
EmitLdcI2IL.Emit(OpCodes.Br, label4)
8224
EmitLdcI2IL.MarkSequencePoint(doc3, 441, 1, 441, 100)
8255
EmitLdcI2IL.MarkSequencePoint(doc3, 446, 1, 446, 100)
8225
8256
EmitLdcI2IL.Emit(OpCodes.Br, cont204)
8226
8257
EmitLdcI2IL.MarkLabel(fa204)
8227
8258
EmitLdcI2IL.Emit(OpCodes.Br, cont204)
8228
8259
EmitLdcI2IL.MarkLabel(cont204)
8229
EmitLdcI2IL.MarkSequencePoint(doc3, 443, 1, 443, 100)
8260
EmitLdcI2IL.MarkSequencePoint(doc3, 448, 1, 448, 100)
8230
8261
EmitLdcI2IL.Emit(OpCodes.Ldloc, 1)
8231
8262
Typ = GetType(System.Int32)
8232
8263
EmitLdcI2IL.Emit(OpCodes.Ldc_I4, CInt(8))
8237
8268
EmitLdcI2IL.Emit(OpCodes.Beq, tru205)
8238
8269
EmitLdcI2IL.Emit(OpCodes.Br, fa205)
8239
8270
EmitLdcI2IL.MarkLabel(tru205)
8240
EmitLdcI2IL.MarkSequencePoint(doc3, 444, 1, 444, 100)
8241
Dim typ141(-1) As Type
8271
EmitLdcI2IL.MarkSequencePoint(doc3, 449, 1, 449, 100)
8272
Dim typ143(-1) As Type
8242
8273
EmitLdcI2IL.Emit(OpCodes.Ldstr, "ldc.i4.8")
8243
8274
Typ = GetType(System.String)
8244
ReDim Preserve typ141(UBound(typ141) + 1)
8245
typ141(UBound(typ141)) = Typ
8246
EmitLdcI2IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ141))
8247
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ141).ReturnType
8248
EmitLdcI2IL.Emit(OpCodes.Stloc, 0)
8249
EmitLdcI2IL.MarkSequencePoint(doc3, 445, 1, 445, 100)
8250
Dim typ142(-1) As Type
8251
EmitLdcI2IL.Emit(OpCodes.Ldsfld, ILGen)
8252
Typ = ILGen.FieldType
8253
Typ03 = Typ
8254
EmitLdcI2IL.Emit(OpCodes.Ldloc, 0)
8255
Typ = GetType(OpCode)
8256
ReDim Preserve typ142(UBound(typ142) + 1)
8257
typ142(UBound(typ142)) = Typ
8258
EmitLdcI2IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ142))
8259
Typ = Typ03.GetMethod("Emit", typ142).ReturnType
8260
If Typ.ToString() = GetType(System.Void).ToString() Then
8261
8262
Else
8263
EmitLdcI2IL.Emit(OpCodes.Pop)
8264
End If
8265
EmitLdcI2IL.MarkSequencePoint(doc3, 446, 1, 446, 100)
8266
Dim typ143(-1) As Type
8267
EmitLdcI2IL.Emit(OpCodes.Ldstr, "conv.i2")
8268
Typ = GetType(System.String)
8269
8275
ReDim Preserve typ143(UBound(typ143) + 1)
8270
8276
typ143(UBound(typ143)) = Typ
8271
8277
EmitLdcI2IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ143))
8272
8278
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ143).ReturnType
8273
8279
EmitLdcI2IL.Emit(OpCodes.Stloc, 0)
8274
EmitLdcI2IL.MarkSequencePoint(doc3, 447, 1, 447, 100)
8280
EmitLdcI2IL.MarkSequencePoint(doc3, 450, 1, 450, 100)
8275
8281
Dim typ144(-1) As Type
8276
8282
EmitLdcI2IL.Emit(OpCodes.Ldsfld, ILGen)
8277
8283
Typ = ILGen.FieldType
8287
8293
Else
8288
8294
EmitLdcI2IL.Emit(OpCodes.Pop)
8289
8295
End If
8290
EmitLdcI2IL.MarkSequencePoint(doc3, 448, 1, 448, 100)
8291
EmitLdcI2IL.Emit(OpCodes.Br, label4)
8292
EmitLdcI2IL.MarkSequencePoint(doc3, 449, 1, 449, 100)
8293
EmitLdcI2IL.Emit(OpCodes.Br, cont205)
8294
EmitLdcI2IL.MarkLabel(fa205)
8295
EmitLdcI2IL.Emit(OpCodes.Br, cont205)
8296
EmitLdcI2IL.MarkLabel(cont205)
8297
EmitLdcI2IL.MarkSequencePoint(doc3, 467, 1, 467, 100)
8296
EmitLdcI2IL.MarkSequencePoint(doc3, 451, 1, 451, 100)
8298
8297
Dim typ145(-1) As Type
8299
EmitLdcI2IL.Emit(OpCodes.Ldstr, "ldc.i4")
8298
EmitLdcI2IL.Emit(OpCodes.Ldstr, "conv.i2")
8300
8299
Typ = GetType(System.String)
8301
8300
ReDim Preserve typ145(UBound(typ145) + 1)
8302
8301
typ145(UBound(typ145)) = Typ
8303
8302
EmitLdcI2IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ145))
8304
8303
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ145).ReturnType
8305
8304
EmitLdcI2IL.Emit(OpCodes.Stloc, 0)
8306
EmitLdcI2IL.MarkSequencePoint(doc3, 469, 1, 469, 100)
8305
EmitLdcI2IL.MarkSequencePoint(doc3, 452, 1, 452, 100)
8307
8306
Dim typ146(-1) As Type
8308
8307
EmitLdcI2IL.Emit(OpCodes.Ldsfld, ILGen)
8309
8308
Typ = ILGen.FieldType
8312
8311
Typ = GetType(OpCode)
8313
8312
ReDim Preserve typ146(UBound(typ146) + 1)
8314
8313
typ146(UBound(typ146)) = Typ
8315
EmitLdcI2IL.Emit(OpCodes.Ldloc, 1)
8316
Typ = GetType(System.Int32)
8317
ReDim Preserve typ146(UBound(typ146) + 1)
8318
typ146(UBound(typ146)) = Typ
8319
8314
EmitLdcI2IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ146))
8320
8315
Typ = Typ03.GetMethod("Emit", typ146).ReturnType
8321
8316
If Typ.ToString() = GetType(System.Void).ToString() Then
8323
8318
Else
8324
8319
EmitLdcI2IL.Emit(OpCodes.Pop)
8325
8320
End If
8326
EmitLdcI2IL.MarkSequencePoint(doc3, 470, 1, 470, 100)
8321
EmitLdcI2IL.MarkSequencePoint(doc3, 453, 1, 453, 100)
8322
EmitLdcI2IL.Emit(OpCodes.Br, label4)
8323
EmitLdcI2IL.MarkSequencePoint(doc3, 454, 1, 454, 100)
8324
EmitLdcI2IL.Emit(OpCodes.Br, cont205)
8325
EmitLdcI2IL.MarkLabel(fa205)
8326
EmitLdcI2IL.Emit(OpCodes.Br, cont205)
8327
EmitLdcI2IL.MarkLabel(cont205)
8328
EmitLdcI2IL.MarkSequencePoint(doc3, 472, 1, 472, 100)
8327
8329
Dim typ147(-1) As Type
8328
EmitLdcI2IL.Emit(OpCodes.Ldstr, "conv.i2")
8330
EmitLdcI2IL.Emit(OpCodes.Ldstr, "ldc.i4")
8329
8331
Typ = GetType(System.String)
8330
8332
ReDim Preserve typ147(UBound(typ147) + 1)
8331
8333
typ147(UBound(typ147)) = Typ
8332
8334
EmitLdcI2IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ147))
8333
8335
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ147).ReturnType
8334
8336
EmitLdcI2IL.Emit(OpCodes.Stloc, 0)
8335
EmitLdcI2IL.MarkSequencePoint(doc3, 471, 1, 471, 100)
8337
EmitLdcI2IL.MarkSequencePoint(doc3, 474, 1, 474, 100)
8336
8338
Dim typ148(-1) As Type
8337
8339
EmitLdcI2IL.Emit(OpCodes.Ldsfld, ILGen)
8338
8340
Typ = ILGen.FieldType
8341
8343
Typ = GetType(OpCode)
8342
8344
ReDim Preserve typ148(UBound(typ148) + 1)
8343
8345
typ148(UBound(typ148)) = Typ
8346
EmitLdcI2IL.Emit(OpCodes.Ldloc, 1)
8347
Typ = GetType(System.Int32)
8348
ReDim Preserve typ148(UBound(typ148) + 1)
8349
typ148(UBound(typ148)) = Typ
8344
8350
EmitLdcI2IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ148))
8345
8351
Typ = Typ03.GetMethod("Emit", typ148).ReturnType
8346
8352
If Typ.ToString() = GetType(System.Void).ToString() Then
8348
8354
Else
8349
8355
EmitLdcI2IL.Emit(OpCodes.Pop)
8350
8356
End If
8351
EmitLdcI2IL.MarkSequencePoint(doc3, 472, 1, 472, 100)
8352
EmitLdcI2IL.Emit(OpCodes.Br, label4)
8353
8357
EmitLdcI2IL.MarkSequencePoint(doc3, 475, 1, 475, 100)
8358
Dim typ149(-1) As Type
8359
EmitLdcI2IL.Emit(OpCodes.Ldstr, "conv.i2")
8360
Typ = GetType(System.String)
8361
ReDim Preserve typ149(UBound(typ149) + 1)
8362
typ149(UBound(typ149)) = Typ
8363
EmitLdcI2IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ149))
8364
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ149).ReturnType
8365
EmitLdcI2IL.Emit(OpCodes.Stloc, 0)
8366
EmitLdcI2IL.MarkSequencePoint(doc3, 476, 1, 476, 100)
8367
Dim typ150(-1) As Type
8368
EmitLdcI2IL.Emit(OpCodes.Ldsfld, ILGen)
8369
Typ = ILGen.FieldType
8370
Typ03 = Typ
8371
EmitLdcI2IL.Emit(OpCodes.Ldloc, 0)
8372
Typ = GetType(OpCode)
8373
ReDim Preserve typ150(UBound(typ150) + 1)
8374
typ150(UBound(typ150)) = Typ
8375
EmitLdcI2IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ150))
8376
Typ = Typ03.GetMethod("Emit", typ150).ReturnType
8377
If Typ.ToString() = GetType(System.Void).ToString() Then
8378
8379
Else
8380
EmitLdcI2IL.Emit(OpCodes.Pop)
8381
End If
8382
EmitLdcI2IL.MarkSequencePoint(doc3, 477, 1, 477, 100)
8383
EmitLdcI2IL.Emit(OpCodes.Br, label4)
8384
EmitLdcI2IL.MarkSequencePoint(doc3, 480, 1, 480, 100)
8354
8385
EmitLdcI2IL.MarkLabel(label4)
8355
EmitLdcI2IL.MarkSequencePoint(doc3, 476, 1, 476, 100)
8386
EmitLdcI2IL.MarkSequencePoint(doc3, 481, 1, 481, 100)
8356
8387
EmitLdcI2IL.Emit(OpCodes.Ret)
8357
Dim typ149(-1) As Type
8358
ReDim Preserve typ149(UBound(typ149) + 1)
8359
typ149(UBound(typ149)) = GetType(System.SByte)
8360
Dim EmitLdcI1 As MethodBuilder = ILEmitter.DefineMethod("EmitLdcI1", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ149)
8388
Dim typ151(-1) As Type
8389
ReDim Preserve typ151(UBound(typ151) + 1)
8390
typ151(UBound(typ151)) = GetType(System.SByte)
8391
Dim EmitLdcI1 As MethodBuilder = ILEmitter.DefineMethod("EmitLdcI1", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ151)
8361
8392
Dim EmitLdcI1IL As ILGenerator = EmitLdcI1.GetILGenerator()
8362
8393
Dim EmitLdcI1param01 As ParameterBuilder = EmitLdcI1.DefineParameter(1, ParameterAttributes.None, "n")
8363
EmitLdcI1IL.MarkSequencePoint(doc3, 479, 1, 479, 100)
8364
Dim locbldr20 As LocalBuilder = EmitLdcI1IL.DeclareLocal(GetType(OpCode))
8365
locbldr20.SetLocalSymInfo("op")
8366
EmitLdcI1IL.MarkSequencePoint(doc3, 480, 1, 480, 100)
8367
Dim locbldr21 As LocalBuilder = EmitLdcI1IL.DeclareLocal(GetType(System.Int32))
8368
locbldr21.SetLocalSymInfo("num")
8394
EmitLdcI1IL.MarkSequencePoint(doc3, 484, 1, 484, 100)
8395
Dim locbldr21 As LocalBuilder = EmitLdcI1IL.DeclareLocal(GetType(OpCode))
8396
locbldr21.SetLocalSymInfo("op")
8397
EmitLdcI1IL.MarkSequencePoint(doc3, 485, 1, 485, 100)
8398
Dim locbldr22 As LocalBuilder = EmitLdcI1IL.DeclareLocal(GetType(System.Int32))
8399
locbldr22.SetLocalSymInfo("num")
8369
8400
EmitLdcI1IL.Emit(OpCodes.Ldarg, 0)
8370
8401
Typ = GetType(System.SByte)
8371
Dim typ150 As Type() = {Typ}
8372
EmitLdcI1IL.Emit(OpCodes.Call, GetType(System.Convert).GetMethod("ToInt32", typ150))
8373
Typ = GetType(System.Convert).GetMethod("ToInt32", typ150).ReturnType
8402
Dim typ152 As Type() = {Typ}
8403
EmitLdcI1IL.Emit(OpCodes.Call, GetType(System.Convert).GetMethod("ToInt32", typ152))
8404
Typ = GetType(System.Convert).GetMethod("ToInt32", typ152).ReturnType
8374
8405
EmitLdcI1IL.Emit(OpCodes.Stloc, 1)
8375
EmitLdcI1IL.MarkSequencePoint(doc3, 486, 1, 486, 100)
8406
EmitLdcI1IL.MarkSequencePoint(doc3, 491, 1, 491, 100)
8376
8407
Dim label5 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8377
EmitLdcI1IL.MarkSequencePoint(doc3, 488, 1, 488, 100)
8408
EmitLdcI1IL.MarkSequencePoint(doc3, 493, 1, 493, 100)
8378
8409
EmitLdcI1IL.Emit(OpCodes.Ldloc, 1)
8379
8410
Typ = GetType(System.Int32)
8380
8411
EmitLdcI1IL.Emit(OpCodes.Ldc_I4, CInt(-1))
8385
8416
EmitLdcI1IL.Emit(OpCodes.Beq, tru206)
8386
8417
EmitLdcI1IL.Emit(OpCodes.Br, fa206)
8387
8418
EmitLdcI1IL.MarkLabel(tru206)
8388
EmitLdcI1IL.MarkSequencePoint(doc3, 489, 1, 489, 100)
8389
Dim typ151(-1) As Type
8419
EmitLdcI1IL.MarkSequencePoint(doc3, 494, 1, 494, 100)
8420
Dim typ153(-1) As Type
8390
8421
EmitLdcI1IL.Emit(OpCodes.Ldstr, "ldc.i4.m1")
8391
8422
Typ = GetType(System.String)
8392
ReDim Preserve typ151(UBound(typ151) + 1)
8393
typ151(UBound(typ151)) = Typ
8394
EmitLdcI1IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ151))
8395
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ151).ReturnType
8396
EmitLdcI1IL.Emit(OpCodes.Stloc, 0)
8397
EmitLdcI1IL.MarkSequencePoint(doc3, 490, 1, 490, 100)
8398
Dim typ152(-1) As Type
8399
EmitLdcI1IL.Emit(OpCodes.Ldsfld, ILGen)
8400
Typ = ILGen.FieldType
8401
Typ03 = Typ
8402
EmitLdcI1IL.Emit(OpCodes.Ldloc, 0)
8403
Typ = GetType(OpCode)
8404
ReDim Preserve typ152(UBound(typ152) + 1)
8405
typ152(UBound(typ152)) = Typ
8406
EmitLdcI1IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ152))
8407
Typ = Typ03.GetMethod("Emit", typ152).ReturnType
8408
If Typ.ToString() = GetType(System.Void).ToString() Then
8409
8410
Else
8411
EmitLdcI1IL.Emit(OpCodes.Pop)
8412
End If
8413
EmitLdcI1IL.MarkSequencePoint(doc3, 491, 1, 491, 100)
8414
Dim typ153(-1) As Type
8415
EmitLdcI1IL.Emit(OpCodes.Ldstr, "conv.i1")
8416
Typ = GetType(System.String)
8417
8423
ReDim Preserve typ153(UBound(typ153) + 1)
8418
8424
typ153(UBound(typ153)) = Typ
8419
8425
EmitLdcI1IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ153))
8420
8426
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ153).ReturnType
8421
8427
EmitLdcI1IL.Emit(OpCodes.Stloc, 0)
8422
EmitLdcI1IL.MarkSequencePoint(doc3, 492, 1, 492, 100)
8428
EmitLdcI1IL.MarkSequencePoint(doc3, 495, 1, 495, 100)
8423
8429
Dim typ154(-1) As Type
8424
8430
EmitLdcI1IL.Emit(OpCodes.Ldsfld, ILGen)
8425
8431
Typ = ILGen.FieldType
8435
8441
Else
8436
8442
EmitLdcI1IL.Emit(OpCodes.Pop)
8437
8443
End If
8438
EmitLdcI1IL.MarkSequencePoint(doc3, 493, 1, 493, 100)
8444
EmitLdcI1IL.MarkSequencePoint(doc3, 496, 1, 496, 100)
8445
Dim typ155(-1) As Type
8446
EmitLdcI1IL.Emit(OpCodes.Ldstr, "conv.i1")
8447
Typ = GetType(System.String)
8448
ReDim Preserve typ155(UBound(typ155) + 1)
8449
typ155(UBound(typ155)) = Typ
8450
EmitLdcI1IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ155))
8451
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ155).ReturnType
8452
EmitLdcI1IL.Emit(OpCodes.Stloc, 0)
8453
EmitLdcI1IL.MarkSequencePoint(doc3, 497, 1, 497, 100)
8454
Dim typ156(-1) As Type
8455
EmitLdcI1IL.Emit(OpCodes.Ldsfld, ILGen)
8456
Typ = ILGen.FieldType
8457
Typ03 = Typ
8458
EmitLdcI1IL.Emit(OpCodes.Ldloc, 0)
8459
Typ = GetType(OpCode)
8460
ReDim Preserve typ156(UBound(typ156) + 1)
8461
typ156(UBound(typ156)) = Typ
8462
EmitLdcI1IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ156))
8463
Typ = Typ03.GetMethod("Emit", typ156).ReturnType
8464
If Typ.ToString() = GetType(System.Void).ToString() Then
8465
8466
Else
8467
EmitLdcI1IL.Emit(OpCodes.Pop)
8468
End If
8469
EmitLdcI1IL.MarkSequencePoint(doc3, 498, 1, 498, 100)
8439
8470
EmitLdcI1IL.Emit(OpCodes.Br, label5)
8440
EmitLdcI1IL.MarkSequencePoint(doc3, 494, 1, 494, 100)
8471
EmitLdcI1IL.MarkSequencePoint(doc3, 499, 1, 499, 100)
8441
8472
EmitLdcI1IL.Emit(OpCodes.Br, cont206)
8442
8473
EmitLdcI1IL.MarkLabel(fa206)
8443
8474
EmitLdcI1IL.Emit(OpCodes.Br, cont206)
8444
8475
EmitLdcI1IL.MarkLabel(cont206)
8445
EmitLdcI1IL.MarkSequencePoint(doc3, 496, 1, 496, 100)
8476
EmitLdcI1IL.MarkSequencePoint(doc3, 501, 1, 501, 100)
8446
8477
EmitLdcI1IL.Emit(OpCodes.Ldloc, 1)
8447
8478
Typ = GetType(System.Int32)
8448
8479
EmitLdcI1IL.Emit(OpCodes.Ldc_I4, CInt(0))
8453
8484
EmitLdcI1IL.Emit(OpCodes.Beq, tru207)
8454
8485
EmitLdcI1IL.Emit(OpCodes.Br, fa207)
8455
8486
EmitLdcI1IL.MarkLabel(tru207)
8456
EmitLdcI1IL.MarkSequencePoint(doc3, 497, 1, 497, 100)
8457
Dim typ155(-1) As Type
8487
EmitLdcI1IL.MarkSequencePoint(doc3, 502, 1, 502, 100)
8488
Dim typ157(-1) As Type
8458
8489
EmitLdcI1IL.Emit(OpCodes.Ldstr, "ldc.i4.0")
8459
8490
Typ = GetType(System.String)
8460
ReDim Preserve typ155(UBound(typ155) + 1)
8461
typ155(UBound(typ155)) = Typ
8462
EmitLdcI1IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ155))
8463
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ155).ReturnType
8464
EmitLdcI1IL.Emit(OpCodes.Stloc, 0)
8465
EmitLdcI1IL.MarkSequencePoint(doc3, 498, 1, 498, 100)
8466
Dim typ156(-1) As Type
8467
EmitLdcI1IL.Emit(OpCodes.Ldsfld, ILGen)
8468
Typ = ILGen.FieldType
8469
Typ03 = Typ
8470
EmitLdcI1IL.Emit(OpCodes.Ldloc, 0)
8471
Typ = GetType(OpCode)
8472
ReDim Preserve typ156(UBound(typ156) + 1)
8473
typ156(UBound(typ156)) = Typ
8474
EmitLdcI1IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ156))
8475
Typ = Typ03.GetMethod("Emit", typ156).ReturnType
8476
If Typ.ToString() = GetType(System.Void).ToString() Then
8477
8478
Else
8479
EmitLdcI1IL.Emit(OpCodes.Pop)
8480
End If
8481
EmitLdcI1IL.MarkSequencePoint(doc3, 499, 1, 499, 100)
8482
Dim typ157(-1) As Type
8483
EmitLdcI1IL.Emit(OpCodes.Ldstr, "conv.i1")
8484
Typ = GetType(System.String)
8485
8491
ReDim Preserve typ157(UBound(typ157) + 1)
8486
8492
typ157(UBound(typ157)) = Typ
8487
8493
EmitLdcI1IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ157))
8488
8494
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ157).ReturnType
8489
8495
EmitLdcI1IL.Emit(OpCodes.Stloc, 0)
8490
EmitLdcI1IL.MarkSequencePoint(doc3, 500, 1, 500, 100)
8496
EmitLdcI1IL.MarkSequencePoint(doc3, 503, 1, 503, 100)
8491
8497
Dim typ158(-1) As Type
8492
8498
EmitLdcI1IL.Emit(OpCodes.Ldsfld, ILGen)
8493
8499
Typ = ILGen.FieldType
8503
8509
Else
8504
8510
EmitLdcI1IL.Emit(OpCodes.Pop)
8505
8511
End If
8506
EmitLdcI1IL.MarkSequencePoint(doc3, 501, 1, 501, 100)
8507
EmitLdcI1IL.Emit(OpCodes.Br, label5)
8508
EmitLdcI1IL.MarkSequencePoint(doc3, 502, 1, 502, 100)
8509
EmitLdcI1IL.Emit(OpCodes.Br, cont207)
8510
EmitLdcI1IL.MarkLabel(fa207)
8511
EmitLdcI1IL.Emit(OpCodes.Br, cont207)
8512
EmitLdcI1IL.MarkLabel(cont207)
8513
8512
EmitLdcI1IL.MarkSequencePoint(doc3, 504, 1, 504, 100)
8514
EmitLdcI1IL.Emit(OpCodes.Ldloc, 1)
8515
Typ = GetType(System.Int32)
8516
EmitLdcI1IL.Emit(OpCodes.Ldc_I4, CInt(1))
8517
Typ = GetType(System.Int32)
8518
Dim fa208 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8519
Dim tru208 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8520
Dim cont208 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8521
EmitLdcI1IL.Emit(OpCodes.Beq, tru208)
8522
EmitLdcI1IL.Emit(OpCodes.Br, fa208)
8523
EmitLdcI1IL.MarkLabel(tru208)
8524
EmitLdcI1IL.MarkSequencePoint(doc3, 505, 1, 505, 100)
8525
8513
Dim typ159(-1) As Type
8526
EmitLdcI1IL.Emit(OpCodes.Ldstr, "ldc.i4.1")
8514
EmitLdcI1IL.Emit(OpCodes.Ldstr, "conv.i1")
8527
8515
Typ = GetType(System.String)
8528
8516
ReDim Preserve typ159(UBound(typ159) + 1)
8529
8517
typ159(UBound(typ159)) = Typ
8530
8518
EmitLdcI1IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ159))
8531
8519
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ159).ReturnType
8532
8520
EmitLdcI1IL.Emit(OpCodes.Stloc, 0)
8533
EmitLdcI1IL.MarkSequencePoint(doc3, 506, 1, 506, 100)
8521
EmitLdcI1IL.MarkSequencePoint(doc3, 505, 1, 505, 100)
8534
8522
Dim typ160(-1) As Type
8535
8523
EmitLdcI1IL.Emit(OpCodes.Ldsfld, ILGen)
8536
8524
Typ = ILGen.FieldType
8546
8534
Else
8547
8535
EmitLdcI1IL.Emit(OpCodes.Pop)
8548
8536
End If
8537
EmitLdcI1IL.MarkSequencePoint(doc3, 506, 1, 506, 100)
8538
EmitLdcI1IL.Emit(OpCodes.Br, label5)
8549
8539
EmitLdcI1IL.MarkSequencePoint(doc3, 507, 1, 507, 100)
8540
EmitLdcI1IL.Emit(OpCodes.Br, cont207)
8541
EmitLdcI1IL.MarkLabel(fa207)
8542
EmitLdcI1IL.Emit(OpCodes.Br, cont207)
8543
EmitLdcI1IL.MarkLabel(cont207)
8544
EmitLdcI1IL.MarkSequencePoint(doc3, 509, 1, 509, 100)
8545
EmitLdcI1IL.Emit(OpCodes.Ldloc, 1)
8546
Typ = GetType(System.Int32)
8547
EmitLdcI1IL.Emit(OpCodes.Ldc_I4, CInt(1))
8548
Typ = GetType(System.Int32)
8549
Dim fa208 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8550
Dim tru208 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8551
Dim cont208 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8552
EmitLdcI1IL.Emit(OpCodes.Beq, tru208)
8553
EmitLdcI1IL.Emit(OpCodes.Br, fa208)
8554
EmitLdcI1IL.MarkLabel(tru208)
8555
EmitLdcI1IL.MarkSequencePoint(doc3, 510, 1, 510, 100)
8550
8556
Dim typ161(-1) As Type
8551
EmitLdcI1IL.Emit(OpCodes.Ldstr, "conv.i1")
8557
EmitLdcI1IL.Emit(OpCodes.Ldstr, "ldc.i4.1")
8552
8558
Typ = GetType(System.String)
8553
8559
ReDim Preserve typ161(UBound(typ161) + 1)
8554
8560
typ161(UBound(typ161)) = Typ
8555
8561
EmitLdcI1IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ161))
8556
8562
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ161).ReturnType
8557
8563
EmitLdcI1IL.Emit(OpCodes.Stloc, 0)
8558
EmitLdcI1IL.MarkSequencePoint(doc3, 508, 1, 508, 100)
8564
EmitLdcI1IL.MarkSequencePoint(doc3, 511, 1, 511, 100)
8559
8565
Dim typ162(-1) As Type
8560
8566
EmitLdcI1IL.Emit(OpCodes.Ldsfld, ILGen)
8561
8567
Typ = ILGen.FieldType
8571
8577
Else
8572
8578
EmitLdcI1IL.Emit(OpCodes.Pop)
8573
8579
End If
8574
EmitLdcI1IL.MarkSequencePoint(doc3, 509, 1, 509, 100)
8575
EmitLdcI1IL.Emit(OpCodes.Br, label5)
8576
EmitLdcI1IL.MarkSequencePoint(doc3, 510, 1, 510, 100)
8577
EmitLdcI1IL.Emit(OpCodes.Br, cont208)
8578
EmitLdcI1IL.MarkLabel(fa208)
8579
EmitLdcI1IL.Emit(OpCodes.Br, cont208)
8580
EmitLdcI1IL.MarkLabel(cont208)
8581
8580
EmitLdcI1IL.MarkSequencePoint(doc3, 512, 1, 512, 100)
8582
EmitLdcI1IL.Emit(OpCodes.Ldloc, 1)
8583
Typ = GetType(System.Int32)
8584
EmitLdcI1IL.Emit(OpCodes.Ldc_I4, CInt(2))
8585
Typ = GetType(System.Int32)
8586
Dim fa209 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8587
Dim tru209 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8588
Dim cont209 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8589
EmitLdcI1IL.Emit(OpCodes.Beq, tru209)
8590
EmitLdcI1IL.Emit(OpCodes.Br, fa209)
8591
EmitLdcI1IL.MarkLabel(tru209)
8592
EmitLdcI1IL.MarkSequencePoint(doc3, 513, 1, 513, 100)
8593
8581
Dim typ163(-1) As Type
8594
EmitLdcI1IL.Emit(OpCodes.Ldstr, "ldc.i4.2")
8582
EmitLdcI1IL.Emit(OpCodes.Ldstr, "conv.i1")
8595
8583
Typ = GetType(System.String)
8596
8584
ReDim Preserve typ163(UBound(typ163) + 1)
8597
8585
typ163(UBound(typ163)) = Typ
8598
8586
EmitLdcI1IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ163))
8599
8587
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ163).ReturnType
8600
8588
EmitLdcI1IL.Emit(OpCodes.Stloc, 0)
8601
EmitLdcI1IL.MarkSequencePoint(doc3, 514, 1, 514, 100)
8589
EmitLdcI1IL.MarkSequencePoint(doc3, 513, 1, 513, 100)
8602
8590
Dim typ164(-1) As Type
8603
8591
EmitLdcI1IL.Emit(OpCodes.Ldsfld, ILGen)
8604
8592
Typ = ILGen.FieldType
8614
8602
Else
8615
8603
EmitLdcI1IL.Emit(OpCodes.Pop)
8616
8604
End If
8605
EmitLdcI1IL.MarkSequencePoint(doc3, 514, 1, 514, 100)
8606
EmitLdcI1IL.Emit(OpCodes.Br, label5)
8617
8607
EmitLdcI1IL.MarkSequencePoint(doc3, 515, 1, 515, 100)
8608
EmitLdcI1IL.Emit(OpCodes.Br, cont208)
8609
EmitLdcI1IL.MarkLabel(fa208)
8610
EmitLdcI1IL.Emit(OpCodes.Br, cont208)
8611
EmitLdcI1IL.MarkLabel(cont208)
8612
EmitLdcI1IL.MarkSequencePoint(doc3, 517, 1, 517, 100)
8613
EmitLdcI1IL.Emit(OpCodes.Ldloc, 1)
8614
Typ = GetType(System.Int32)
8615
EmitLdcI1IL.Emit(OpCodes.Ldc_I4, CInt(2))
8616
Typ = GetType(System.Int32)
8617
Dim fa209 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8618
Dim tru209 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8619
Dim cont209 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8620
EmitLdcI1IL.Emit(OpCodes.Beq, tru209)
8621
EmitLdcI1IL.Emit(OpCodes.Br, fa209)
8622
EmitLdcI1IL.MarkLabel(tru209)
8623
EmitLdcI1IL.MarkSequencePoint(doc3, 518, 1, 518, 100)
8618
8624
Dim typ165(-1) As Type
8619
EmitLdcI1IL.Emit(OpCodes.Ldstr, "conv.i1")
8625
EmitLdcI1IL.Emit(OpCodes.Ldstr, "ldc.i4.2")
8620
8626
Typ = GetType(System.String)
8621
8627
ReDim Preserve typ165(UBound(typ165) + 1)
8622
8628
typ165(UBound(typ165)) = Typ
8623
8629
EmitLdcI1IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ165))
8624
8630
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ165).ReturnType
8625
8631
EmitLdcI1IL.Emit(OpCodes.Stloc, 0)
8626
EmitLdcI1IL.MarkSequencePoint(doc3, 516, 1, 516, 100)
8632
EmitLdcI1IL.MarkSequencePoint(doc3, 519, 1, 519, 100)
8627
8633
Dim typ166(-1) As Type
8628
8634
EmitLdcI1IL.Emit(OpCodes.Ldsfld, ILGen)
8629
8635
Typ = ILGen.FieldType
8639
8645
Else
8640
8646
EmitLdcI1IL.Emit(OpCodes.Pop)
8641
8647
End If
8642
EmitLdcI1IL.MarkSequencePoint(doc3, 517, 1, 517, 100)
8643
EmitLdcI1IL.Emit(OpCodes.Br, label5)
8644
EmitLdcI1IL.MarkSequencePoint(doc3, 518, 1, 518, 100)
8645
EmitLdcI1IL.Emit(OpCodes.Br, cont209)
8646
EmitLdcI1IL.MarkLabel(fa209)
8647
EmitLdcI1IL.Emit(OpCodes.Br, cont209)
8648
EmitLdcI1IL.MarkLabel(cont209)
8649
8648
EmitLdcI1IL.MarkSequencePoint(doc3, 520, 1, 520, 100)
8650
EmitLdcI1IL.Emit(OpCodes.Ldloc, 1)
8651
Typ = GetType(System.Int32)
8652
EmitLdcI1IL.Emit(OpCodes.Ldc_I4, CInt(3))
8653
Typ = GetType(System.Int32)
8654
Dim fa210 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8655
Dim tru210 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8656
Dim cont210 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8657
EmitLdcI1IL.Emit(OpCodes.Beq, tru210)
8658
EmitLdcI1IL.Emit(OpCodes.Br, fa210)
8659
EmitLdcI1IL.MarkLabel(tru210)
8660
EmitLdcI1IL.MarkSequencePoint(doc3, 521, 1, 521, 100)
8661
8649
Dim typ167(-1) As Type
8662
EmitLdcI1IL.Emit(OpCodes.Ldstr, "ldc.i4.3")
8650
EmitLdcI1IL.Emit(OpCodes.Ldstr, "conv.i1")
8663
8651
Typ = GetType(System.String)
8664
8652
ReDim Preserve typ167(UBound(typ167) + 1)
8665
8653
typ167(UBound(typ167)) = Typ
8666
8654
EmitLdcI1IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ167))
8667
8655
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ167).ReturnType
8668
8656
EmitLdcI1IL.Emit(OpCodes.Stloc, 0)
8669
EmitLdcI1IL.MarkSequencePoint(doc3, 522, 1, 522, 100)
8657
EmitLdcI1IL.MarkSequencePoint(doc3, 521, 1, 521, 100)
8670
8658
Dim typ168(-1) As Type
8671
8659
EmitLdcI1IL.Emit(OpCodes.Ldsfld, ILGen)
8672
8660
Typ = ILGen.FieldType
8682
8670
Else
8683
8671
EmitLdcI1IL.Emit(OpCodes.Pop)
8684
8672
End If
8673
EmitLdcI1IL.MarkSequencePoint(doc3, 522, 1, 522, 100)
8674
EmitLdcI1IL.Emit(OpCodes.Br, label5)
8685
8675
EmitLdcI1IL.MarkSequencePoint(doc3, 523, 1, 523, 100)
8676
EmitLdcI1IL.Emit(OpCodes.Br, cont209)
8677
EmitLdcI1IL.MarkLabel(fa209)
8678
EmitLdcI1IL.Emit(OpCodes.Br, cont209)
8679
EmitLdcI1IL.MarkLabel(cont209)
8680
EmitLdcI1IL.MarkSequencePoint(doc3, 525, 1, 525, 100)
8681
EmitLdcI1IL.Emit(OpCodes.Ldloc, 1)
8682
Typ = GetType(System.Int32)
8683
EmitLdcI1IL.Emit(OpCodes.Ldc_I4, CInt(3))
8684
Typ = GetType(System.Int32)
8685
Dim fa210 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8686
Dim tru210 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8687
Dim cont210 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8688
EmitLdcI1IL.Emit(OpCodes.Beq, tru210)
8689
EmitLdcI1IL.Emit(OpCodes.Br, fa210)
8690
EmitLdcI1IL.MarkLabel(tru210)
8691
EmitLdcI1IL.MarkSequencePoint(doc3, 526, 1, 526, 100)
8686
8692
Dim typ169(-1) As Type
8687
EmitLdcI1IL.Emit(OpCodes.Ldstr, "conv.i1")
8693
EmitLdcI1IL.Emit(OpCodes.Ldstr, "ldc.i4.3")
8688
8694
Typ = GetType(System.String)
8689
8695
ReDim Preserve typ169(UBound(typ169) + 1)
8690
8696
typ169(UBound(typ169)) = Typ
8691
8697
EmitLdcI1IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ169))
8692
8698
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ169).ReturnType
8693
8699
EmitLdcI1IL.Emit(OpCodes.Stloc, 0)
8694
EmitLdcI1IL.MarkSequencePoint(doc3, 524, 1, 524, 100)
8700
EmitLdcI1IL.MarkSequencePoint(doc3, 527, 1, 527, 100)
8695
8701
Dim typ170(-1) As Type
8696
8702
EmitLdcI1IL.Emit(OpCodes.Ldsfld, ILGen)
8697
8703
Typ = ILGen.FieldType
8707
8713
Else
8708
8714
EmitLdcI1IL.Emit(OpCodes.Pop)
8709
8715
End If
8710
EmitLdcI1IL.MarkSequencePoint(doc3, 525, 1, 525, 100)
8711
EmitLdcI1IL.Emit(OpCodes.Br, label5)
8712
EmitLdcI1IL.MarkSequencePoint(doc3, 526, 1, 526, 100)
8713
EmitLdcI1IL.Emit(OpCodes.Br, cont210)
8714
EmitLdcI1IL.MarkLabel(fa210)
8715
EmitLdcI1IL.Emit(OpCodes.Br, cont210)
8716
EmitLdcI1IL.MarkLabel(cont210)
8717
8716
EmitLdcI1IL.MarkSequencePoint(doc3, 528, 1, 528, 100)
8718
EmitLdcI1IL.Emit(OpCodes.Ldloc, 1)
8719
Typ = GetType(System.Int32)
8720
EmitLdcI1IL.Emit(OpCodes.Ldc_I4, CInt(4))
8721
Typ = GetType(System.Int32)
8722
Dim fa211 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8723
Dim tru211 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8724
Dim cont211 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8725
EmitLdcI1IL.Emit(OpCodes.Beq, tru211)
8726
EmitLdcI1IL.Emit(OpCodes.Br, fa211)
8727
EmitLdcI1IL.MarkLabel(tru211)
8728
EmitLdcI1IL.MarkSequencePoint(doc3, 529, 1, 529, 100)
8729
8717
Dim typ171(-1) As Type
8730
EmitLdcI1IL.Emit(OpCodes.Ldstr, "ldc.i4.4")
8718
EmitLdcI1IL.Emit(OpCodes.Ldstr, "conv.i1")
8731
8719
Typ = GetType(System.String)
8732
8720
ReDim Preserve typ171(UBound(typ171) + 1)
8733
8721
typ171(UBound(typ171)) = Typ
8734
8722
EmitLdcI1IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ171))
8735
8723
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ171).ReturnType
8736
8724
EmitLdcI1IL.Emit(OpCodes.Stloc, 0)
8737
EmitLdcI1IL.MarkSequencePoint(doc3, 530, 1, 530, 100)
8725
EmitLdcI1IL.MarkSequencePoint(doc3, 529, 1, 529, 100)
8738
8726
Dim typ172(-1) As Type
8739
8727
EmitLdcI1IL.Emit(OpCodes.Ldsfld, ILGen)
8740
8728
Typ = ILGen.FieldType
8750
8738
Else
8751
8739
EmitLdcI1IL.Emit(OpCodes.Pop)
8752
8740
End If
8741
EmitLdcI1IL.MarkSequencePoint(doc3, 530, 1, 530, 100)
8742
EmitLdcI1IL.Emit(OpCodes.Br, label5)
8753
8743
EmitLdcI1IL.MarkSequencePoint(doc3, 531, 1, 531, 100)
8744
EmitLdcI1IL.Emit(OpCodes.Br, cont210)
8745
EmitLdcI1IL.MarkLabel(fa210)
8746
EmitLdcI1IL.Emit(OpCodes.Br, cont210)
8747
EmitLdcI1IL.MarkLabel(cont210)
8748
EmitLdcI1IL.MarkSequencePoint(doc3, 533, 1, 533, 100)
8749
EmitLdcI1IL.Emit(OpCodes.Ldloc, 1)
8750
Typ = GetType(System.Int32)
8751
EmitLdcI1IL.Emit(OpCodes.Ldc_I4, CInt(4))
8752
Typ = GetType(System.Int32)
8753
Dim fa211 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8754
Dim tru211 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8755
Dim cont211 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8756
EmitLdcI1IL.Emit(OpCodes.Beq, tru211)
8757
EmitLdcI1IL.Emit(OpCodes.Br, fa211)
8758
EmitLdcI1IL.MarkLabel(tru211)
8759
EmitLdcI1IL.MarkSequencePoint(doc3, 534, 1, 534, 100)
8754
8760
Dim typ173(-1) As Type
8755
EmitLdcI1IL.Emit(OpCodes.Ldstr, "conv.i1")
8761
EmitLdcI1IL.Emit(OpCodes.Ldstr, "ldc.i4.4")
8756
8762
Typ = GetType(System.String)
8757
8763
ReDim Preserve typ173(UBound(typ173) + 1)
8758
8764
typ173(UBound(typ173)) = Typ
8759
8765
EmitLdcI1IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ173))
8760
8766
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ173).ReturnType
8761
8767
EmitLdcI1IL.Emit(OpCodes.Stloc, 0)
8762
EmitLdcI1IL.MarkSequencePoint(doc3, 532, 1, 532, 100)
8768
EmitLdcI1IL.MarkSequencePoint(doc3, 535, 1, 535, 100)
8763
8769
Dim typ174(-1) As Type
8764
8770
EmitLdcI1IL.Emit(OpCodes.Ldsfld, ILGen)
8765
8771
Typ = ILGen.FieldType
8775
8781
Else
8776
8782
EmitLdcI1IL.Emit(OpCodes.Pop)
8777
8783
End If
8778
EmitLdcI1IL.MarkSequencePoint(doc3, 533, 1, 533, 100)
8779
EmitLdcI1IL.Emit(OpCodes.Br, label5)
8780
EmitLdcI1IL.MarkSequencePoint(doc3, 534, 1, 534, 100)
8781
EmitLdcI1IL.Emit(OpCodes.Br, cont211)
8782
EmitLdcI1IL.MarkLabel(fa211)
8783
EmitLdcI1IL.Emit(OpCodes.Br, cont211)
8784
EmitLdcI1IL.MarkLabel(cont211)
8785
8784
EmitLdcI1IL.MarkSequencePoint(doc3, 536, 1, 536, 100)
8786
EmitLdcI1IL.Emit(OpCodes.Ldloc, 1)
8787
Typ = GetType(System.Int32)
8788
EmitLdcI1IL.Emit(OpCodes.Ldc_I4, CInt(5))
8789
Typ = GetType(System.Int32)
8790
Dim fa212 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8791
Dim tru212 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8792
Dim cont212 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8793
EmitLdcI1IL.Emit(OpCodes.Beq, tru212)
8794
EmitLdcI1IL.Emit(OpCodes.Br, fa212)
8795
EmitLdcI1IL.MarkLabel(tru212)
8796
EmitLdcI1IL.MarkSequencePoint(doc3, 537, 1, 537, 100)
8797
8785
Dim typ175(-1) As Type
8798
EmitLdcI1IL.Emit(OpCodes.Ldstr, "ldc.i4.5")
8786
EmitLdcI1IL.Emit(OpCodes.Ldstr, "conv.i1")
8799
8787
Typ = GetType(System.String)
8800
8788
ReDim Preserve typ175(UBound(typ175) + 1)
8801
8789
typ175(UBound(typ175)) = Typ
8802
8790
EmitLdcI1IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ175))
8803
8791
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ175).ReturnType
8804
8792
EmitLdcI1IL.Emit(OpCodes.Stloc, 0)
8805
EmitLdcI1IL.MarkSequencePoint(doc3, 538, 1, 538, 100)
8793
EmitLdcI1IL.MarkSequencePoint(doc3, 537, 1, 537, 100)
8806
8794
Dim typ176(-1) As Type
8807
8795
EmitLdcI1IL.Emit(OpCodes.Ldsfld, ILGen)
8808
8796
Typ = ILGen.FieldType
8818
8806
Else
8819
8807
EmitLdcI1IL.Emit(OpCodes.Pop)
8820
8808
End If
8809
EmitLdcI1IL.MarkSequencePoint(doc3, 538, 1, 538, 100)
8810
EmitLdcI1IL.Emit(OpCodes.Br, label5)
8821
8811
EmitLdcI1IL.MarkSequencePoint(doc3, 539, 1, 539, 100)
8812
EmitLdcI1IL.Emit(OpCodes.Br, cont211)
8813
EmitLdcI1IL.MarkLabel(fa211)
8814
EmitLdcI1IL.Emit(OpCodes.Br, cont211)
8815
EmitLdcI1IL.MarkLabel(cont211)
8816
EmitLdcI1IL.MarkSequencePoint(doc3, 541, 1, 541, 100)
8817
EmitLdcI1IL.Emit(OpCodes.Ldloc, 1)
8818
Typ = GetType(System.Int32)
8819
EmitLdcI1IL.Emit(OpCodes.Ldc_I4, CInt(5))
8820
Typ = GetType(System.Int32)
8821
Dim fa212 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8822
Dim tru212 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8823
Dim cont212 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8824
EmitLdcI1IL.Emit(OpCodes.Beq, tru212)
8825
EmitLdcI1IL.Emit(OpCodes.Br, fa212)
8826
EmitLdcI1IL.MarkLabel(tru212)
8827
EmitLdcI1IL.MarkSequencePoint(doc3, 542, 1, 542, 100)
8822
8828
Dim typ177(-1) As Type
8823
EmitLdcI1IL.Emit(OpCodes.Ldstr, "conv.i1")
8829
EmitLdcI1IL.Emit(OpCodes.Ldstr, "ldc.i4.5")
8824
8830
Typ = GetType(System.String)
8825
8831
ReDim Preserve typ177(UBound(typ177) + 1)
8826
8832
typ177(UBound(typ177)) = Typ
8827
8833
EmitLdcI1IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ177))
8828
8834
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ177).ReturnType
8829
8835
EmitLdcI1IL.Emit(OpCodes.Stloc, 0)
8830
EmitLdcI1IL.MarkSequencePoint(doc3, 540, 1, 540, 100)
8836
EmitLdcI1IL.MarkSequencePoint(doc3, 543, 1, 543, 100)
8831
8837
Dim typ178(-1) As Type
8832
8838
EmitLdcI1IL.Emit(OpCodes.Ldsfld, ILGen)
8833
8839
Typ = ILGen.FieldType
8843
8849
Else
8844
8850
EmitLdcI1IL.Emit(OpCodes.Pop)
8845
8851
End If
8846
EmitLdcI1IL.MarkSequencePoint(doc3, 541, 1, 541, 100)
8847
EmitLdcI1IL.Emit(OpCodes.Br, label5)
8848
EmitLdcI1IL.MarkSequencePoint(doc3, 542, 1, 542, 100)
8849
EmitLdcI1IL.Emit(OpCodes.Br, cont212)
8850
EmitLdcI1IL.MarkLabel(fa212)
8851
EmitLdcI1IL.Emit(OpCodes.Br, cont212)
8852
EmitLdcI1IL.MarkLabel(cont212)
8853
8852
EmitLdcI1IL.MarkSequencePoint(doc3, 544, 1, 544, 100)
8854
EmitLdcI1IL.Emit(OpCodes.Ldloc, 1)
8855
Typ = GetType(System.Int32)
8856
EmitLdcI1IL.Emit(OpCodes.Ldc_I4, CInt(6))
8857
Typ = GetType(System.Int32)
8858
Dim fa213 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8859
Dim tru213 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8860
Dim cont213 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8861
EmitLdcI1IL.Emit(OpCodes.Beq, tru213)
8862
EmitLdcI1IL.Emit(OpCodes.Br, fa213)
8863
EmitLdcI1IL.MarkLabel(tru213)
8864
EmitLdcI1IL.MarkSequencePoint(doc3, 545, 1, 545, 100)
8865
8853
Dim typ179(-1) As Type
8866
EmitLdcI1IL.Emit(OpCodes.Ldstr, "ldc.i4.6")
8854
EmitLdcI1IL.Emit(OpCodes.Ldstr, "conv.i1")
8867
8855
Typ = GetType(System.String)
8868
8856
ReDim Preserve typ179(UBound(typ179) + 1)
8869
8857
typ179(UBound(typ179)) = Typ
8870
8858
EmitLdcI1IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ179))
8871
8859
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ179).ReturnType
8872
8860
EmitLdcI1IL.Emit(OpCodes.Stloc, 0)
8873
EmitLdcI1IL.MarkSequencePoint(doc3, 546, 1, 546, 100)
8861
EmitLdcI1IL.MarkSequencePoint(doc3, 545, 1, 545, 100)
8874
8862
Dim typ180(-1) As Type
8875
8863
EmitLdcI1IL.Emit(OpCodes.Ldsfld, ILGen)
8876
8864
Typ = ILGen.FieldType
8886
8874
Else
8887
8875
EmitLdcI1IL.Emit(OpCodes.Pop)
8888
8876
End If
8877
EmitLdcI1IL.MarkSequencePoint(doc3, 546, 1, 546, 100)
8878
EmitLdcI1IL.Emit(OpCodes.Br, label5)
8889
8879
EmitLdcI1IL.MarkSequencePoint(doc3, 547, 1, 547, 100)
8880
EmitLdcI1IL.Emit(OpCodes.Br, cont212)
8881
EmitLdcI1IL.MarkLabel(fa212)
8882
EmitLdcI1IL.Emit(OpCodes.Br, cont212)
8883
EmitLdcI1IL.MarkLabel(cont212)
8884
EmitLdcI1IL.MarkSequencePoint(doc3, 549, 1, 549, 100)
8885
EmitLdcI1IL.Emit(OpCodes.Ldloc, 1)
8886
Typ = GetType(System.Int32)
8887
EmitLdcI1IL.Emit(OpCodes.Ldc_I4, CInt(6))
8888
Typ = GetType(System.Int32)
8889
Dim fa213 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8890
Dim tru213 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8891
Dim cont213 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8892
EmitLdcI1IL.Emit(OpCodes.Beq, tru213)
8893
EmitLdcI1IL.Emit(OpCodes.Br, fa213)
8894
EmitLdcI1IL.MarkLabel(tru213)
8895
EmitLdcI1IL.MarkSequencePoint(doc3, 550, 1, 550, 100)
8890
8896
Dim typ181(-1) As Type
8891
EmitLdcI1IL.Emit(OpCodes.Ldstr, "conv.i1")
8897
EmitLdcI1IL.Emit(OpCodes.Ldstr, "ldc.i4.6")
8892
8898
Typ = GetType(System.String)
8893
8899
ReDim Preserve typ181(UBound(typ181) + 1)
8894
8900
typ181(UBound(typ181)) = Typ
8895
8901
EmitLdcI1IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ181))
8896
8902
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ181).ReturnType
8897
8903
EmitLdcI1IL.Emit(OpCodes.Stloc, 0)
8898
EmitLdcI1IL.MarkSequencePoint(doc3, 548, 1, 548, 100)
8904
EmitLdcI1IL.MarkSequencePoint(doc3, 551, 1, 551, 100)
8899
8905
Dim typ182(-1) As Type
8900
8906
EmitLdcI1IL.Emit(OpCodes.Ldsfld, ILGen)
8901
8907
Typ = ILGen.FieldType
8911
8917
Else
8912
8918
EmitLdcI1IL.Emit(OpCodes.Pop)
8913
8919
End If
8914
EmitLdcI1IL.MarkSequencePoint(doc3, 549, 1, 549, 100)
8915
EmitLdcI1IL.Emit(OpCodes.Br, label5)
8916
EmitLdcI1IL.MarkSequencePoint(doc3, 550, 1, 550, 100)
8917
EmitLdcI1IL.Emit(OpCodes.Br, cont213)
8918
EmitLdcI1IL.MarkLabel(fa213)
8919
EmitLdcI1IL.Emit(OpCodes.Br, cont213)
8920
EmitLdcI1IL.MarkLabel(cont213)
8921
8920
EmitLdcI1IL.MarkSequencePoint(doc3, 552, 1, 552, 100)
8922
EmitLdcI1IL.Emit(OpCodes.Ldloc, 1)
8923
Typ = GetType(System.Int32)
8924
EmitLdcI1IL.Emit(OpCodes.Ldc_I4, CInt(7))
8925
Typ = GetType(System.Int32)
8926
Dim fa214 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8927
Dim tru214 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8928
Dim cont214 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8929
EmitLdcI1IL.Emit(OpCodes.Beq, tru214)
8930
EmitLdcI1IL.Emit(OpCodes.Br, fa214)
8931
EmitLdcI1IL.MarkLabel(tru214)
8932
EmitLdcI1IL.MarkSequencePoint(doc3, 553, 1, 553, 100)
8933
8921
Dim typ183(-1) As Type
8934
EmitLdcI1IL.Emit(OpCodes.Ldstr, "ldc.i4.7")
8922
EmitLdcI1IL.Emit(OpCodes.Ldstr, "conv.i1")
8935
8923
Typ = GetType(System.String)
8936
8924
ReDim Preserve typ183(UBound(typ183) + 1)
8937
8925
typ183(UBound(typ183)) = Typ
8938
8926
EmitLdcI1IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ183))
8939
8927
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ183).ReturnType
8940
8928
EmitLdcI1IL.Emit(OpCodes.Stloc, 0)
8941
EmitLdcI1IL.MarkSequencePoint(doc3, 554, 1, 554, 100)
8929
EmitLdcI1IL.MarkSequencePoint(doc3, 553, 1, 553, 100)
8942
8930
Dim typ184(-1) As Type
8943
8931
EmitLdcI1IL.Emit(OpCodes.Ldsfld, ILGen)
8944
8932
Typ = ILGen.FieldType
8954
8942
Else
8955
8943
EmitLdcI1IL.Emit(OpCodes.Pop)
8956
8944
End If
8945
EmitLdcI1IL.MarkSequencePoint(doc3, 554, 1, 554, 100)
8946
EmitLdcI1IL.Emit(OpCodes.Br, label5)
8957
8947
EmitLdcI1IL.MarkSequencePoint(doc3, 555, 1, 555, 100)
8948
EmitLdcI1IL.Emit(OpCodes.Br, cont213)
8949
EmitLdcI1IL.MarkLabel(fa213)
8950
EmitLdcI1IL.Emit(OpCodes.Br, cont213)
8951
EmitLdcI1IL.MarkLabel(cont213)
8952
EmitLdcI1IL.MarkSequencePoint(doc3, 557, 1, 557, 100)
8953
EmitLdcI1IL.Emit(OpCodes.Ldloc, 1)
8954
Typ = GetType(System.Int32)
8955
EmitLdcI1IL.Emit(OpCodes.Ldc_I4, CInt(7))
8956
Typ = GetType(System.Int32)
8957
Dim fa214 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8958
Dim tru214 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8959
Dim cont214 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8960
EmitLdcI1IL.Emit(OpCodes.Beq, tru214)
8961
EmitLdcI1IL.Emit(OpCodes.Br, fa214)
8962
EmitLdcI1IL.MarkLabel(tru214)
8963
EmitLdcI1IL.MarkSequencePoint(doc3, 558, 1, 558, 100)
8958
8964
Dim typ185(-1) As Type
8959
EmitLdcI1IL.Emit(OpCodes.Ldstr, "conv.i1")
8965
EmitLdcI1IL.Emit(OpCodes.Ldstr, "ldc.i4.7")
8960
8966
Typ = GetType(System.String)
8961
8967
ReDim Preserve typ185(UBound(typ185) + 1)
8962
8968
typ185(UBound(typ185)) = Typ
8963
8969
EmitLdcI1IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ185))
8964
8970
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ185).ReturnType
8965
8971
EmitLdcI1IL.Emit(OpCodes.Stloc, 0)
8966
EmitLdcI1IL.MarkSequencePoint(doc3, 556, 1, 556, 100)
8972
EmitLdcI1IL.MarkSequencePoint(doc3, 559, 1, 559, 100)
8967
8973
Dim typ186(-1) As Type
8968
8974
EmitLdcI1IL.Emit(OpCodes.Ldsfld, ILGen)
8969
8975
Typ = ILGen.FieldType
8979
8985
Else
8980
8986
EmitLdcI1IL.Emit(OpCodes.Pop)
8981
8987
End If
8982
EmitLdcI1IL.MarkSequencePoint(doc3, 557, 1, 557, 100)
8983
EmitLdcI1IL.Emit(OpCodes.Br, label5)
8984
EmitLdcI1IL.MarkSequencePoint(doc3, 558, 1, 558, 100)
8985
EmitLdcI1IL.Emit(OpCodes.Br, cont214)
8986
EmitLdcI1IL.MarkLabel(fa214)
8987
EmitLdcI1IL.Emit(OpCodes.Br, cont214)
8988
EmitLdcI1IL.MarkLabel(cont214)
8989
8988
EmitLdcI1IL.MarkSequencePoint(doc3, 560, 1, 560, 100)
8990
EmitLdcI1IL.Emit(OpCodes.Ldloc, 1)
8991
Typ = GetType(System.Int32)
8992
EmitLdcI1IL.Emit(OpCodes.Ldc_I4, CInt(8))
8993
Typ = GetType(System.Int32)
8994
Dim fa215 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8995
Dim tru215 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8996
Dim cont215 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
8997
EmitLdcI1IL.Emit(OpCodes.Beq, tru215)
8998
EmitLdcI1IL.Emit(OpCodes.Br, fa215)
8999
EmitLdcI1IL.MarkLabel(tru215)
9000
EmitLdcI1IL.MarkSequencePoint(doc3, 561, 1, 561, 100)
9001
8989
Dim typ187(-1) As Type
9002
EmitLdcI1IL.Emit(OpCodes.Ldstr, "ldc.i4.8")
8990
EmitLdcI1IL.Emit(OpCodes.Ldstr, "conv.i1")
9003
8991
Typ = GetType(System.String)
9004
8992
ReDim Preserve typ187(UBound(typ187) + 1)
9005
8993
typ187(UBound(typ187)) = Typ
9006
8994
EmitLdcI1IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ187))
9007
8995
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ187).ReturnType
9008
8996
EmitLdcI1IL.Emit(OpCodes.Stloc, 0)
9009
EmitLdcI1IL.MarkSequencePoint(doc3, 562, 1, 562, 100)
8997
EmitLdcI1IL.MarkSequencePoint(doc3, 561, 1, 561, 100)
9010
8998
Dim typ188(-1) As Type
9011
8999
EmitLdcI1IL.Emit(OpCodes.Ldsfld, ILGen)
9012
9000
Typ = ILGen.FieldType
9022
9010
Else
9023
9011
EmitLdcI1IL.Emit(OpCodes.Pop)
9024
9012
End If
9013
EmitLdcI1IL.MarkSequencePoint(doc3, 562, 1, 562, 100)
9014
EmitLdcI1IL.Emit(OpCodes.Br, label5)
9025
9015
EmitLdcI1IL.MarkSequencePoint(doc3, 563, 1, 563, 100)
9016
EmitLdcI1IL.Emit(OpCodes.Br, cont214)
9017
EmitLdcI1IL.MarkLabel(fa214)
9018
EmitLdcI1IL.Emit(OpCodes.Br, cont214)
9019
EmitLdcI1IL.MarkLabel(cont214)
9020
EmitLdcI1IL.MarkSequencePoint(doc3, 565, 1, 565, 100)
9021
EmitLdcI1IL.Emit(OpCodes.Ldloc, 1)
9022
Typ = GetType(System.Int32)
9023
EmitLdcI1IL.Emit(OpCodes.Ldc_I4, CInt(8))
9024
Typ = GetType(System.Int32)
9025
Dim fa215 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
9026
Dim tru215 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
9027
Dim cont215 As System.Reflection.Emit.Label = EmitLdcI1IL.DefineLabel()
9028
EmitLdcI1IL.Emit(OpCodes.Beq, tru215)
9029
EmitLdcI1IL.Emit(OpCodes.Br, fa215)
9030
EmitLdcI1IL.MarkLabel(tru215)
9031
EmitLdcI1IL.MarkSequencePoint(doc3, 566, 1, 566, 100)
9026
9032
Dim typ189(-1) As Type
9027
EmitLdcI1IL.Emit(OpCodes.Ldstr, "conv.i1")
9033
EmitLdcI1IL.Emit(OpCodes.Ldstr, "ldc.i4.8")
9028
9034
Typ = GetType(System.String)
9029
9035
ReDim Preserve typ189(UBound(typ189) + 1)
9030
9036
typ189(UBound(typ189)) = Typ
9031
9037
EmitLdcI1IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ189))
9032
9038
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ189).ReturnType
9033
9039
EmitLdcI1IL.Emit(OpCodes.Stloc, 0)
9034
EmitLdcI1IL.MarkSequencePoint(doc3, 564, 1, 564, 100)
9040
EmitLdcI1IL.MarkSequencePoint(doc3, 567, 1, 567, 100)
9035
9041
Dim typ190(-1) As Type
9036
9042
EmitLdcI1IL.Emit(OpCodes.Ldsfld, ILGen)
9037
9043
Typ = ILGen.FieldType
9047
9053
Else
9048
9054
EmitLdcI1IL.Emit(OpCodes.Pop)
9049
9055
End If
9050
EmitLdcI1IL.MarkSequencePoint(doc3, 565, 1, 565, 100)
9051
EmitLdcI1IL.Emit(OpCodes.Br, label5)
9052
EmitLdcI1IL.MarkSequencePoint(doc3, 566, 1, 566, 100)
9053
EmitLdcI1IL.Emit(OpCodes.Br, cont215)
9054
EmitLdcI1IL.MarkLabel(fa215)
9055
EmitLdcI1IL.Emit(OpCodes.Br, cont215)
9056
EmitLdcI1IL.MarkLabel(cont215)
9057
EmitLdcI1IL.MarkSequencePoint(doc3, 584, 1, 584, 100)
9056
EmitLdcI1IL.MarkSequencePoint(doc3, 568, 1, 568, 100)
9058
9057
Dim typ191(-1) As Type
9059
EmitLdcI1IL.Emit(OpCodes.Ldstr, "ldc.i4")
9058
EmitLdcI1IL.Emit(OpCodes.Ldstr, "conv.i1")
9060
9059
Typ = GetType(System.String)
9061
9060
ReDim Preserve typ191(UBound(typ191) + 1)
9062
9061
typ191(UBound(typ191)) = Typ
9063
9062
EmitLdcI1IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ191))
9064
9063
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ191).ReturnType
9065
9064
EmitLdcI1IL.Emit(OpCodes.Stloc, 0)
9066
EmitLdcI1IL.MarkSequencePoint(doc3, 586, 1, 586, 100)
9065
EmitLdcI1IL.MarkSequencePoint(doc3, 569, 1, 569, 100)
9067
9066
Dim typ192(-1) As Type
9068
9067
EmitLdcI1IL.Emit(OpCodes.Ldsfld, ILGen)
9069
9068
Typ = ILGen.FieldType
9072
9071
Typ = GetType(OpCode)
9073
9072
ReDim Preserve typ192(UBound(typ192) + 1)
9074
9073
typ192(UBound(typ192)) = Typ
9075
EmitLdcI1IL.Emit(OpCodes.Ldloc, 1)
9076
Typ = GetType(System.Int32)
9077
ReDim Preserve typ192(UBound(typ192) + 1)
9078
typ192(UBound(typ192)) = Typ
9079
9074
EmitLdcI1IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ192))
9080
9075
Typ = Typ03.GetMethod("Emit", typ192).ReturnType
9081
9076
If Typ.ToString() = GetType(System.Void).ToString() Then
9083
9078
Else
9084
9079
EmitLdcI1IL.Emit(OpCodes.Pop)
9085
9080
End If
9086
EmitLdcI1IL.MarkSequencePoint(doc3, 587, 1, 587, 100)
9081
EmitLdcI1IL.MarkSequencePoint(doc3, 570, 1, 570, 100)
9082
EmitLdcI1IL.Emit(OpCodes.Br, label5)
9083
EmitLdcI1IL.MarkSequencePoint(doc3, 571, 1, 571, 100)
9084
EmitLdcI1IL.Emit(OpCodes.Br, cont215)
9085
EmitLdcI1IL.MarkLabel(fa215)
9086
EmitLdcI1IL.Emit(OpCodes.Br, cont215)
9087
EmitLdcI1IL.MarkLabel(cont215)
9088
EmitLdcI1IL.MarkSequencePoint(doc3, 589, 1, 589, 100)
9087
9089
Dim typ193(-1) As Type
9088
EmitLdcI1IL.Emit(OpCodes.Ldstr, "conv.i1")
9090
EmitLdcI1IL.Emit(OpCodes.Ldstr, "ldc.i4")
9089
9091
Typ = GetType(System.String)
9090
9092
ReDim Preserve typ193(UBound(typ193) + 1)
9091
9093
typ193(UBound(typ193)) = Typ
9092
9094
EmitLdcI1IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ193))
9093
9095
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ193).ReturnType
9094
9096
EmitLdcI1IL.Emit(OpCodes.Stloc, 0)
9095
EmitLdcI1IL.MarkSequencePoint(doc3, 588, 1, 588, 100)
9097
EmitLdcI1IL.MarkSequencePoint(doc3, 591, 1, 591, 100)
9096
9098
Dim typ194(-1) As Type
9097
9099
EmitLdcI1IL.Emit(OpCodes.Ldsfld, ILGen)
9098
9100
Typ = ILGen.FieldType
9101
9103
Typ = GetType(OpCode)
9102
9104
ReDim Preserve typ194(UBound(typ194) + 1)
9103
9105
typ194(UBound(typ194)) = Typ
9106
EmitLdcI1IL.Emit(OpCodes.Ldloc, 1)
9107
Typ = GetType(System.Int32)
9108
ReDim Preserve typ194(UBound(typ194) + 1)
9109
typ194(UBound(typ194)) = Typ
9104
9110
EmitLdcI1IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ194))
9105
9111
Typ = Typ03.GetMethod("Emit", typ194).ReturnType
9106
9112
If Typ.ToString() = GetType(System.Void).ToString() Then
9108
9114
Else
9109
9115
EmitLdcI1IL.Emit(OpCodes.Pop)
9110
9116
End If
9111
EmitLdcI1IL.MarkSequencePoint(doc3, 589, 1, 589, 100)
9112
EmitLdcI1IL.Emit(OpCodes.Br, label5)
9113
9117
EmitLdcI1IL.MarkSequencePoint(doc3, 592, 1, 592, 100)
9118
Dim typ195(-1) As Type
9119
EmitLdcI1IL.Emit(OpCodes.Ldstr, "conv.i1")
9120
Typ = GetType(System.String)
9121
ReDim Preserve typ195(UBound(typ195) + 1)
9122
typ195(UBound(typ195)) = Typ
9123
EmitLdcI1IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ195))
9124
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ195).ReturnType
9125
EmitLdcI1IL.Emit(OpCodes.Stloc, 0)
9126
EmitLdcI1IL.MarkSequencePoint(doc3, 593, 1, 593, 100)
9127
Dim typ196(-1) As Type
9128
EmitLdcI1IL.Emit(OpCodes.Ldsfld, ILGen)
9129
Typ = ILGen.FieldType
9130
Typ03 = Typ
9131
EmitLdcI1IL.Emit(OpCodes.Ldloc, 0)
9132
Typ = GetType(OpCode)
9133
ReDim Preserve typ196(UBound(typ196) + 1)
9134
typ196(UBound(typ196)) = Typ
9135
EmitLdcI1IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ196))
9136
Typ = Typ03.GetMethod("Emit", typ196).ReturnType
9137
If Typ.ToString() = GetType(System.Void).ToString() Then
9138
9139
Else
9140
EmitLdcI1IL.Emit(OpCodes.Pop)
9141
End If
9142
EmitLdcI1IL.MarkSequencePoint(doc3, 594, 1, 594, 100)
9143
EmitLdcI1IL.Emit(OpCodes.Br, label5)
9144
EmitLdcI1IL.MarkSequencePoint(doc3, 597, 1, 597, 100)
9114
9145
EmitLdcI1IL.MarkLabel(label5)
9115
EmitLdcI1IL.MarkSequencePoint(doc3, 593, 1, 593, 100)
9146
EmitLdcI1IL.MarkSequencePoint(doc3, 598, 1, 598, 100)
9116
9147
EmitLdcI1IL.Emit(OpCodes.Ret)
9117
Dim typ195(-1) As Type
9118
ReDim Preserve typ195(UBound(typ195) + 1)
9119
typ195(UBound(typ195)) = GetType(MethodInfo)
9120
Dim EmitCallvirt As MethodBuilder = ILEmitter.DefineMethod("EmitCallvirt", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ195)
9148
Dim typ197(-1) As Type
9149
ReDim Preserve typ197(UBound(typ197) + 1)
9150
typ197(UBound(typ197)) = GetType(MethodInfo)
9151
Dim EmitCallvirt As MethodBuilder = ILEmitter.DefineMethod("EmitCallvirt", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ197)
9121
9152
Dim EmitCallvirtIL As ILGenerator = EmitCallvirt.GetILGenerator()
9122
9153
Dim EmitCallvirtparam01 As ParameterBuilder = EmitCallvirt.DefineParameter(1, ParameterAttributes.None, "met")
9123
EmitCallvirtIL.MarkSequencePoint(doc3, 596, 1, 596, 100)
9124
Dim locbldr22 As LocalBuilder = EmitCallvirtIL.DeclareLocal(GetType(OpCode))
9125
locbldr22.SetLocalSymInfo("cvop")
9126
Dim typ196(-1) As Type
9154
EmitCallvirtIL.MarkSequencePoint(doc3, 601, 1, 601, 100)
9155
Dim locbldr23 As LocalBuilder = EmitCallvirtIL.DeclareLocal(GetType(OpCode))
9156
locbldr23.SetLocalSymInfo("cvop")
9157
Dim typ198(-1) As Type
9127
9158
EmitCallvirtIL.Emit(OpCodes.Ldstr, "callvirt")
9128
9159
Typ = GetType(System.String)
9129
ReDim Preserve typ196(UBound(typ196) + 1)
9130
typ196(UBound(typ196)) = Typ
9131
EmitCallvirtIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ196))
9132
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ196).ReturnType
9160
ReDim Preserve typ198(UBound(typ198) + 1)
9161
typ198(UBound(typ198)) = Typ
9162
EmitCallvirtIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ198))
9163
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ198).ReturnType
9133
9164
EmitCallvirtIL.Emit(OpCodes.Stloc, 0)
9134
EmitCallvirtIL.MarkSequencePoint(doc3, 597, 1, 597, 100)
9135
Dim typ197(-1) As Type
9165
EmitCallvirtIL.MarkSequencePoint(doc3, 602, 1, 602, 100)
9166
Dim typ199(-1) As Type
9136
9167
EmitCallvirtIL.Emit(OpCodes.Ldsfld, ILGen)
9137
9168
Typ = ILGen.FieldType
9138
9169
Typ03 = Typ
9139
9170
EmitCallvirtIL.Emit(OpCodes.Ldloc, 0)
9140
9171
Typ = GetType(OpCode)
9141
ReDim Preserve typ197(UBound(typ197) + 1)
9142
typ197(UBound(typ197)) = Typ
9172
ReDim Preserve typ199(UBound(typ199) + 1)
9173
typ199(UBound(typ199)) = Typ
9143
9174
EmitCallvirtIL.Emit(OpCodes.Ldarg, 0)
9144
9175
Typ = GetType(MethodInfo)
9145
ReDim Preserve typ197(UBound(typ197) + 1)
9146
typ197(UBound(typ197)) = Typ
9147
EmitCallvirtIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ197))
9148
Typ = Typ03.GetMethod("Emit", typ197).ReturnType
9176
ReDim Preserve typ199(UBound(typ199) + 1)
9177
typ199(UBound(typ199)) = Typ
9178
EmitCallvirtIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ199))
9179
Typ = Typ03.GetMethod("Emit", typ199).ReturnType
9149
9180
If Typ.ToString() = GetType(System.Void).ToString() Then
9150
9181
9151
9182
Else
9152
9183
EmitCallvirtIL.Emit(OpCodes.Pop)
9153
9184
End If
9154
EmitCallvirtIL.MarkSequencePoint(doc3, 598, 1, 598, 100)
9185
EmitCallvirtIL.MarkSequencePoint(doc3, 603, 1, 603, 100)
9155
9186
EmitCallvirtIL.Emit(OpCodes.Ret)
9156
Dim typ198(-1) As Type
9157
ReDim Preserve typ198(UBound(typ198) + 1)
9158
typ198(UBound(typ198)) = GetType(MethodInfo)
9159
Dim EmitCall As MethodBuilder = ILEmitter.DefineMethod("EmitCall", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ198)
9187
Dim typ200(-1) As Type
9188
ReDim Preserve typ200(UBound(typ200) + 1)
9189
typ200(UBound(typ200)) = GetType(MethodInfo)
9190
Dim EmitCall As MethodBuilder = ILEmitter.DefineMethod("EmitCall", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ200)
9160
9191
Dim EmitCallIL As ILGenerator = EmitCall.GetILGenerator()
9161
9192
Dim EmitCallparam01 As ParameterBuilder = EmitCall.DefineParameter(1, ParameterAttributes.None, "met")
9162
EmitCallIL.MarkSequencePoint(doc3, 601, 1, 601, 100)
9163
Dim locbldr23 As LocalBuilder = EmitCallIL.DeclareLocal(GetType(OpCode))
9164
locbldr23.SetLocalSymInfo("cop")
9165
Dim typ199(-1) As Type
9193
EmitCallIL.MarkSequencePoint(doc3, 606, 1, 606, 100)
9194
Dim locbldr24 As LocalBuilder = EmitCallIL.DeclareLocal(GetType(OpCode))
9195
locbldr24.SetLocalSymInfo("cop")
9196
Dim typ201(-1) As Type
9166
9197
EmitCallIL.Emit(OpCodes.Ldstr, "call")
9167
9198
Typ = GetType(System.String)
9168
ReDim Preserve typ199(UBound(typ199) + 1)
9169
typ199(UBound(typ199)) = Typ
9170
EmitCallIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ199))
9171
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ199).ReturnType
9199
ReDim Preserve typ201(UBound(typ201) + 1)
9200
typ201(UBound(typ201)) = Typ
9201
EmitCallIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ201))
9202
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ201).ReturnType
9172
9203
EmitCallIL.Emit(OpCodes.Stloc, 0)
9173
EmitCallIL.MarkSequencePoint(doc3, 602, 1, 602, 100)
9174
Dim typ200(-1) As Type
9204
EmitCallIL.MarkSequencePoint(doc3, 607, 1, 607, 100)
9205
Dim typ202(-1) As Type
9175
9206
EmitCallIL.Emit(OpCodes.Ldsfld, ILGen)
9176
9207
Typ = ILGen.FieldType
9177
9208
Typ03 = Typ
9178
9209
EmitCallIL.Emit(OpCodes.Ldloc, 0)
9179
9210
Typ = GetType(OpCode)
9180
ReDim Preserve typ200(UBound(typ200) + 1)
9181
typ200(UBound(typ200)) = Typ
9211
ReDim Preserve typ202(UBound(typ202) + 1)
9212
typ202(UBound(typ202)) = Typ
9182
9213
EmitCallIL.Emit(OpCodes.Ldarg, 0)
9183
9214
Typ = GetType(MethodInfo)
9184
ReDim Preserve typ200(UBound(typ200) + 1)
9185
typ200(UBound(typ200)) = Typ
9186
EmitCallIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ200))
9187
Typ = Typ03.GetMethod("Emit", typ200).ReturnType
9215
ReDim Preserve typ202(UBound(typ202) + 1)
9216
typ202(UBound(typ202)) = Typ
9217
EmitCallIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ202))
9218
Typ = Typ03.GetMethod("Emit", typ202).ReturnType
9188
9219
If Typ.ToString() = GetType(System.Void).ToString() Then
9189
9220
9190
9221
Else
9191
9222
EmitCallIL.Emit(OpCodes.Pop)
9192
9223
End If
9193
EmitCallIL.MarkSequencePoint(doc3, 603, 1, 603, 100)
9224
EmitCallIL.MarkSequencePoint(doc3, 608, 1, 608, 100)
9194
9225
EmitCallIL.Emit(OpCodes.Ret)
9195
Dim typ201(-1) As Type
9196
ReDim Preserve typ201(UBound(typ201) + 1)
9197
typ201(UBound(typ201)) = GetType(System.String)
9198
Dim EmitLdstr As MethodBuilder = ILEmitter.DefineMethod("EmitLdstr", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ201)
9226
Dim typ203(-1) As Type
9227
ReDim Preserve typ203(UBound(typ203) + 1)
9228
typ203(UBound(typ203)) = GetType(System.String)
9229
Dim EmitLdstr As MethodBuilder = ILEmitter.DefineMethod("EmitLdstr", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ203)
9199
9230
Dim EmitLdstrIL As ILGenerator = EmitLdstr.GetILGenerator()
9200
9231
Dim EmitLdstrparam01 As ParameterBuilder = EmitLdstr.DefineParameter(1, ParameterAttributes.None, "str")
9201
EmitLdstrIL.MarkSequencePoint(doc3, 606, 1, 606, 100)
9202
Dim locbldr24 As LocalBuilder = EmitLdstrIL.DeclareLocal(GetType(OpCode))
9203
locbldr24.SetLocalSymInfo("lsop")
9204
Dim typ202(-1) As Type
9232
EmitLdstrIL.MarkSequencePoint(doc3, 611, 1, 611, 100)
9233
Dim locbldr25 As LocalBuilder = EmitLdstrIL.DeclareLocal(GetType(OpCode))
9234
locbldr25.SetLocalSymInfo("lsop")
9235
Dim typ204(-1) As Type
9205
9236
EmitLdstrIL.Emit(OpCodes.Ldstr, "ldstr")
9206
9237
Typ = GetType(System.String)
9207
ReDim Preserve typ202(UBound(typ202) + 1)
9208
typ202(UBound(typ202)) = Typ
9209
EmitLdstrIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ202))
9210
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ202).ReturnType
9238
ReDim Preserve typ204(UBound(typ204) + 1)
9239
typ204(UBound(typ204)) = Typ
9240
EmitLdstrIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ204))
9241
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ204).ReturnType
9211
9242
EmitLdstrIL.Emit(OpCodes.Stloc, 0)
9212
EmitLdstrIL.MarkSequencePoint(doc3, 607, 1, 607, 100)
9213
Dim typ203(-1) As Type
9243
EmitLdstrIL.MarkSequencePoint(doc3, 612, 1, 612, 100)
9244
Dim typ205(-1) As Type
9214
9245
EmitLdstrIL.Emit(OpCodes.Ldsfld, ILGen)
9215
9246
Typ = ILGen.FieldType
9216
9247
Typ03 = Typ
9217
9248
EmitLdstrIL.Emit(OpCodes.Ldloc, 0)
9218
9249
Typ = GetType(OpCode)
9219
ReDim Preserve typ203(UBound(typ203) + 1)
9220
typ203(UBound(typ203)) = Typ
9250
ReDim Preserve typ205(UBound(typ205) + 1)
9251
typ205(UBound(typ205)) = Typ
9221
9252
EmitLdstrIL.Emit(OpCodes.Ldarg, 0)
9222
9253
Typ = GetType(System.String)
9223
ReDim Preserve typ203(UBound(typ203) + 1)
9224
typ203(UBound(typ203)) = Typ
9225
EmitLdstrIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ203))
9226
Typ = Typ03.GetMethod("Emit", typ203).ReturnType
9254
ReDim Preserve typ205(UBound(typ205) + 1)
9255
typ205(UBound(typ205)) = Typ
9256
EmitLdstrIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ205))
9257
Typ = Typ03.GetMethod("Emit", typ205).ReturnType
9227
9258
If Typ.ToString() = GetType(System.Void).ToString() Then
9228
9259
9229
9260
Else
9230
9261
EmitLdstrIL.Emit(OpCodes.Pop)
9231
9262
End If
9232
EmitLdstrIL.MarkSequencePoint(doc3, 608, 1, 608, 100)
9263
EmitLdstrIL.MarkSequencePoint(doc3, 613, 1, 613, 100)
9233
9264
EmitLdstrIL.Emit(OpCodes.Ret)
9234
Dim typ204(-1) As Type
9235
ReDim Preserve typ204(UBound(typ204) + 1)
9236
typ204(UBound(typ204)) = GetType(System.Boolean)
9237
Dim EmitAdd As MethodBuilder = ILEmitter.DefineMethod("EmitAdd", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ204)
9265
Dim typ206(-1) As Type
9266
ReDim Preserve typ206(UBound(typ206) + 1)
9267
typ206(UBound(typ206)) = GetType(System.Boolean)
9268
Dim EmitAdd As MethodBuilder = ILEmitter.DefineMethod("EmitAdd", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ206)
9238
9269
Dim EmitAddIL As ILGenerator = EmitAdd.GetILGenerator()
9239
9270
Dim EmitAddparam01 As ParameterBuilder = EmitAdd.DefineParameter(1, ParameterAttributes.None, "s")
9240
EmitAddIL.MarkSequencePoint(doc3, 611, 1, 611, 100)
9241
Dim locbldr25 As LocalBuilder = EmitAddIL.DeclareLocal(GetType(OpCode))
9242
locbldr25.SetLocalSymInfo("op")
9243
EmitAddIL.MarkSequencePoint(doc3, 612, 1, 612, 100)
9271
EmitAddIL.MarkSequencePoint(doc3, 616, 1, 616, 100)
9272
Dim locbldr26 As LocalBuilder = EmitAddIL.DeclareLocal(GetType(OpCode))
9273
locbldr26.SetLocalSymInfo("op")
9274
EmitAddIL.MarkSequencePoint(doc3, 617, 1, 617, 100)
9244
9275
EmitAddIL.Emit(OpCodes.Ldarg, 0)
9245
9276
Typ = GetType(System.Boolean)
9246
9277
EmitAddIL.Emit(OpCodes.Ldc_I4, 1)
9251
9282
EmitAddIL.Emit(OpCodes.Beq, tru216)
9252
9283
EmitAddIL.Emit(OpCodes.Br, fa216)
9253
9284
EmitAddIL.MarkLabel(tru216)
9254
EmitAddIL.MarkSequencePoint(doc3, 613, 1, 613, 100)
9255
Dim typ205(-1) As Type
9285
EmitAddIL.MarkSequencePoint(doc3, 618, 1, 618, 100)
9286
Dim typ207(-1) As Type
9256
9287
EmitAddIL.Emit(OpCodes.Ldstr, "add")
9257
9288
Typ = GetType(System.String)
9258
ReDim Preserve typ205(UBound(typ205) + 1)
9259
typ205(UBound(typ205)) = Typ
9260
EmitAddIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ205))
9261
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ205).ReturnType
9262
EmitAddIL.Emit(OpCodes.Stloc, 0)
9263
EmitAddIL.MarkSequencePoint(doc3, 614, 1, 614, 100)
9264
Dim typ206(-1) As Type
9265
EmitAddIL.Emit(OpCodes.Ldsfld, ILGen)
9266
Typ = ILGen.FieldType
9267
Typ03 = Typ
9268
EmitAddIL.Emit(OpCodes.Ldloc, 0)
9269
Typ = GetType(OpCode)
9270
ReDim Preserve typ206(UBound(typ206) + 1)
9271
typ206(UBound(typ206)) = Typ
9272
EmitAddIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ206))
9273
Typ = Typ03.GetMethod("Emit", typ206).ReturnType
9274
If Typ.ToString() = GetType(System.Void).ToString() Then
9275
9276
Else
9277
EmitAddIL.Emit(OpCodes.Pop)
9278
End If
9279
EmitAddIL.MarkSequencePoint(doc3, 615, 1, 615, 100)
9280
EmitAddIL.Emit(OpCodes.Br, cont216)
9281
EmitAddIL.MarkLabel(fa216)
9282
EmitAddIL.MarkSequencePoint(doc3, 616, 1, 616, 100)
9283
Dim typ207(-1) As Type
9284
EmitAddIL.Emit(OpCodes.Ldstr, "add.ovf.un")
9285
Typ = GetType(System.String)
9286
9289
ReDim Preserve typ207(UBound(typ207) + 1)
9287
9290
typ207(UBound(typ207)) = Typ
9288
9291
EmitAddIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ207))
9289
9292
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ207).ReturnType
9290
9293
EmitAddIL.Emit(OpCodes.Stloc, 0)
9291
EmitAddIL.MarkSequencePoint(doc3, 617, 1, 617, 100)
9294
EmitAddIL.MarkSequencePoint(doc3, 619, 1, 619, 100)
9292
9295
Dim typ208(-1) As Type
9293
9296
EmitAddIL.Emit(OpCodes.Ldsfld, ILGen)
9294
9297
Typ = ILGen.FieldType
9304
9307
Else
9305
9308
EmitAddIL.Emit(OpCodes.Pop)
9306
9309
End If
9307
EmitAddIL.MarkSequencePoint(doc3, 618, 1, 618, 100)
9310
EmitAddIL.MarkSequencePoint(doc3, 620, 1, 620, 100)
9311
EmitAddIL.Emit(OpCodes.Br, cont216)
9312
EmitAddIL.MarkLabel(fa216)
9313
EmitAddIL.MarkSequencePoint(doc3, 621, 1, 621, 100)
9314
Dim typ209(-1) As Type
9315
EmitAddIL.Emit(OpCodes.Ldstr, "add.ovf.un")
9316
Typ = GetType(System.String)
9317
ReDim Preserve typ209(UBound(typ209) + 1)
9318
typ209(UBound(typ209)) = Typ
9319
EmitAddIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ209))
9320
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ209).ReturnType
9321
EmitAddIL.Emit(OpCodes.Stloc, 0)
9322
EmitAddIL.MarkSequencePoint(doc3, 622, 1, 622, 100)
9323
Dim typ210(-1) As Type
9324
EmitAddIL.Emit(OpCodes.Ldsfld, ILGen)
9325
Typ = ILGen.FieldType
9326
Typ03 = Typ
9327
EmitAddIL.Emit(OpCodes.Ldloc, 0)
9328
Typ = GetType(OpCode)
9329
ReDim Preserve typ210(UBound(typ210) + 1)
9330
typ210(UBound(typ210)) = Typ
9331
EmitAddIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ210))
9332
Typ = Typ03.GetMethod("Emit", typ210).ReturnType
9333
If Typ.ToString() = GetType(System.Void).ToString() Then
9334
9335
Else
9336
EmitAddIL.Emit(OpCodes.Pop)
9337
End If
9338
EmitAddIL.MarkSequencePoint(doc3, 623, 1, 623, 100)
9308
9339
EmitAddIL.Emit(OpCodes.Br, cont216)
9309
9340
EmitAddIL.MarkLabel(cont216)
9310
EmitAddIL.MarkSequencePoint(doc3, 619, 1, 619, 100)
9341
EmitAddIL.MarkSequencePoint(doc3, 624, 1, 624, 100)
9311
9342
EmitAddIL.Emit(OpCodes.Ret)
9312
Dim typ209(-1) As Type
9313
ReDim Preserve typ209(UBound(typ209) + 1)
9314
typ209(UBound(typ209)) = GetType(System.Boolean)
9315
Dim EmitDiv As MethodBuilder = ILEmitter.DefineMethod("EmitDiv", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ209)
9343
Dim typ211(-1) As Type
9344
ReDim Preserve typ211(UBound(typ211) + 1)
9345
typ211(UBound(typ211)) = GetType(System.Boolean)
9346
Dim EmitDiv As MethodBuilder = ILEmitter.DefineMethod("EmitDiv", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ211)
9316
9347
Dim EmitDivIL As ILGenerator = EmitDiv.GetILGenerator()
9317
9348
Dim EmitDivparam01 As ParameterBuilder = EmitDiv.DefineParameter(1, ParameterAttributes.None, "s")
9318
EmitDivIL.MarkSequencePoint(doc3, 622, 1, 622, 100)
9319
Dim locbldr26 As LocalBuilder = EmitDivIL.DeclareLocal(GetType(OpCode))
9320
locbldr26.SetLocalSymInfo("op")
9321
EmitDivIL.MarkSequencePoint(doc3, 623, 1, 623, 100)
9349
EmitDivIL.MarkSequencePoint(doc3, 627, 1, 627, 100)
9350
Dim locbldr27 As LocalBuilder = EmitDivIL.DeclareLocal(GetType(OpCode))
9351
locbldr27.SetLocalSymInfo("op")
9352
EmitDivIL.MarkSequencePoint(doc3, 628, 1, 628, 100)
9322
9353
EmitDivIL.Emit(OpCodes.Ldarg, 0)
9323
9354
Typ = GetType(System.Boolean)
9324
9355
EmitDivIL.Emit(OpCodes.Ldc_I4, 1)
9329
9360
EmitDivIL.Emit(OpCodes.Beq, tru217)
9330
9361
EmitDivIL.Emit(OpCodes.Br, fa217)
9331
9362
EmitDivIL.MarkLabel(tru217)
9332
EmitDivIL.MarkSequencePoint(doc3, 624, 1, 624, 100)
9333
Dim typ210(-1) As Type
9363
EmitDivIL.MarkSequencePoint(doc3, 629, 1, 629, 100)
9364
Dim typ212(-1) As Type
9334
9365
EmitDivIL.Emit(OpCodes.Ldstr, "div")
9335
9366
Typ = GetType(System.String)
9336
ReDim Preserve typ210(UBound(typ210) + 1)
9337
typ210(UBound(typ210)) = Typ
9338
EmitDivIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ210))
9339
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ210).ReturnType
9340
EmitDivIL.Emit(OpCodes.Stloc, 0)
9341
EmitDivIL.MarkSequencePoint(doc3, 625, 1, 625, 100)
9342
Dim typ211(-1) As Type
9343
EmitDivIL.Emit(OpCodes.Ldsfld, ILGen)
9344
Typ = ILGen.FieldType
9345
Typ03 = Typ
9346
EmitDivIL.Emit(OpCodes.Ldloc, 0)
9347
Typ = GetType(OpCode)
9348
ReDim Preserve typ211(UBound(typ211) + 1)
9349
typ211(UBound(typ211)) = Typ
9350
EmitDivIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ211))
9351
Typ = Typ03.GetMethod("Emit", typ211).ReturnType
9352
If Typ.ToString() = GetType(System.Void).ToString() Then
9353
9354
Else
9355
EmitDivIL.Emit(OpCodes.Pop)
9356
End If
9357
EmitDivIL.MarkSequencePoint(doc3, 626, 1, 626, 100)
9358
EmitDivIL.Emit(OpCodes.Br, cont217)
9359
EmitDivIL.MarkLabel(fa217)
9360
EmitDivIL.MarkSequencePoint(doc3, 627, 1, 627, 100)
9361
Dim typ212(-1) As Type
9362
EmitDivIL.Emit(OpCodes.Ldstr, "div.un")
9363
Typ = GetType(System.String)
9364
9367
ReDim Preserve typ212(UBound(typ212) + 1)
9365
9368
typ212(UBound(typ212)) = Typ
9366
9369
EmitDivIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ212))
9367
9370
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ212).ReturnType
9368
9371
EmitDivIL.Emit(OpCodes.Stloc, 0)
9369
EmitDivIL.MarkSequencePoint(doc3, 628, 1, 628, 100)
9372
EmitDivIL.MarkSequencePoint(doc3, 630, 1, 630, 100)
9370
9373
Dim typ213(-1) As Type
9371
9374
EmitDivIL.Emit(OpCodes.Ldsfld, ILGen)
9372
9375
Typ = ILGen.FieldType
9382
9385
Else
9383
9386
EmitDivIL.Emit(OpCodes.Pop)
9384
9387
End If
9385
EmitDivIL.MarkSequencePoint(doc3, 629, 1, 629, 100)
9388
EmitDivIL.MarkSequencePoint(doc3, 631, 1, 631, 100)
9389
EmitDivIL.Emit(OpCodes.Br, cont217)
9390
EmitDivIL.MarkLabel(fa217)
9391
EmitDivIL.MarkSequencePoint(doc3, 632, 1, 632, 100)
9392
Dim typ214(-1) As Type
9393
EmitDivIL.Emit(OpCodes.Ldstr, "div.un")
9394
Typ = GetType(System.String)
9395
ReDim Preserve typ214(UBound(typ214) + 1)
9396
typ214(UBound(typ214)) = Typ
9397
EmitDivIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ214))
9398
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ214).ReturnType
9399
EmitDivIL.Emit(OpCodes.Stloc, 0)
9400
EmitDivIL.MarkSequencePoint(doc3, 633, 1, 633, 100)
9401
Dim typ215(-1) As Type
9402
EmitDivIL.Emit(OpCodes.Ldsfld, ILGen)
9403
Typ = ILGen.FieldType
9404
Typ03 = Typ
9405
EmitDivIL.Emit(OpCodes.Ldloc, 0)
9406
Typ = GetType(OpCode)
9407
ReDim Preserve typ215(UBound(typ215) + 1)
9408
typ215(UBound(typ215)) = Typ
9409
EmitDivIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ215))
9410
Typ = Typ03.GetMethod("Emit", typ215).ReturnType
9411
If Typ.ToString() = GetType(System.Void).ToString() Then
9412
9413
Else
9414
EmitDivIL.Emit(OpCodes.Pop)
9415
End If
9416
EmitDivIL.MarkSequencePoint(doc3, 634, 1, 634, 100)
9386
9417
EmitDivIL.Emit(OpCodes.Br, cont217)
9387
9418
EmitDivIL.MarkLabel(cont217)
9388
EmitDivIL.MarkSequencePoint(doc3, 630, 1, 630, 100)
9419
EmitDivIL.MarkSequencePoint(doc3, 635, 1, 635, 100)
9389
9420
EmitDivIL.Emit(OpCodes.Ret)
9390
Dim typ214(-1) As Type
9391
ReDim Preserve typ214(UBound(typ214) + 1)
9392
typ214(UBound(typ214)) = GetType(System.Boolean)
9393
Dim EmitMul As MethodBuilder = ILEmitter.DefineMethod("EmitMul", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ214)
9421
Dim typ216(-1) As Type
9422
ReDim Preserve typ216(UBound(typ216) + 1)
9423
typ216(UBound(typ216)) = GetType(System.Boolean)
9424
Dim EmitMul As MethodBuilder = ILEmitter.DefineMethod("EmitMul", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ216)
9394
9425
Dim EmitMulIL As ILGenerator = EmitMul.GetILGenerator()
9395
9426
Dim EmitMulparam01 As ParameterBuilder = EmitMul.DefineParameter(1, ParameterAttributes.None, "s")
9396
EmitMulIL.MarkSequencePoint(doc3, 633, 1, 633, 100)
9397
Dim locbldr27 As LocalBuilder = EmitMulIL.DeclareLocal(GetType(OpCode))
9398
locbldr27.SetLocalSymInfo("op")
9399
EmitMulIL.MarkSequencePoint(doc3, 634, 1, 634, 100)
9427
EmitMulIL.MarkSequencePoint(doc3, 638, 1, 638, 100)
9428
Dim locbldr28 As LocalBuilder = EmitMulIL.DeclareLocal(GetType(OpCode))
9429
locbldr28.SetLocalSymInfo("op")
9430
EmitMulIL.MarkSequencePoint(doc3, 639, 1, 639, 100)
9400
9431
EmitMulIL.Emit(OpCodes.Ldarg, 0)
9401
9432
Typ = GetType(System.Boolean)
9402
9433
EmitMulIL.Emit(OpCodes.Ldc_I4, 1)
9407
9438
EmitMulIL.Emit(OpCodes.Beq, tru218)
9408
9439
EmitMulIL.Emit(OpCodes.Br, fa218)
9409
9440
EmitMulIL.MarkLabel(tru218)
9410
EmitMulIL.MarkSequencePoint(doc3, 635, 1, 635, 100)
9411
Dim typ215(-1) As Type
9441
EmitMulIL.MarkSequencePoint(doc3, 640, 1, 640, 100)
9442
Dim typ217(-1) As Type
9412
9443
EmitMulIL.Emit(OpCodes.Ldstr, "mul")
9413
9444
Typ = GetType(System.String)
9414
ReDim Preserve typ215(UBound(typ215) + 1)
9415
typ215(UBound(typ215)) = Typ
9416
EmitMulIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ215))
9417
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ215).ReturnType
9418
EmitMulIL.Emit(OpCodes.Stloc, 0)
9419
EmitMulIL.MarkSequencePoint(doc3, 636, 1, 636, 100)
9420
Dim typ216(-1) As Type
9421
EmitMulIL.Emit(OpCodes.Ldsfld, ILGen)
9422
Typ = ILGen.FieldType
9423
Typ03 = Typ
9424
EmitMulIL.Emit(OpCodes.Ldloc, 0)
9425
Typ = GetType(OpCode)
9426
ReDim Preserve typ216(UBound(typ216) + 1)
9427
typ216(UBound(typ216)) = Typ
9428
EmitMulIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ216))
9429
Typ = Typ03.GetMethod("Emit", typ216).ReturnType
9430
If Typ.ToString() = GetType(System.Void).ToString() Then
9431
9432
Else
9433
EmitMulIL.Emit(OpCodes.Pop)
9434
End If
9435
EmitMulIL.MarkSequencePoint(doc3, 637, 1, 637, 100)
9436
EmitMulIL.Emit(OpCodes.Br, cont218)
9437
EmitMulIL.MarkLabel(fa218)
9438
EmitMulIL.MarkSequencePoint(doc3, 638, 1, 638, 100)
9439
Dim typ217(-1) As Type
9440
EmitMulIL.Emit(OpCodes.Ldstr, "mul.ovf.un")
9441
Typ = GetType(System.String)
9442
9445
ReDim Preserve typ217(UBound(typ217) + 1)
9443
9446
typ217(UBound(typ217)) = Typ
9444
9447
EmitMulIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ217))
9445
9448
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ217).ReturnType
9446
9449
EmitMulIL.Emit(OpCodes.Stloc, 0)
9447
EmitMulIL.MarkSequencePoint(doc3, 639, 1, 639, 100)
9450
EmitMulIL.MarkSequencePoint(doc3, 641, 1, 641, 100)
9448
9451
Dim typ218(-1) As Type
9449
9452
EmitMulIL.Emit(OpCodes.Ldsfld, ILGen)
9450
9453
Typ = ILGen.FieldType
9460
9463
Else
9461
9464
EmitMulIL.Emit(OpCodes.Pop)
9462
9465
End If
9463
EmitMulIL.MarkSequencePoint(doc3, 640, 1, 640, 100)
9466
EmitMulIL.MarkSequencePoint(doc3, 642, 1, 642, 100)
9467
EmitMulIL.Emit(OpCodes.Br, cont218)
9468
EmitMulIL.MarkLabel(fa218)
9469
EmitMulIL.MarkSequencePoint(doc3, 643, 1, 643, 100)
9470
Dim typ219(-1) As Type
9471
EmitMulIL.Emit(OpCodes.Ldstr, "mul.ovf.un")
9472
Typ = GetType(System.String)
9473
ReDim Preserve typ219(UBound(typ219) + 1)
9474
typ219(UBound(typ219)) = Typ
9475
EmitMulIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ219))
9476
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ219).ReturnType
9477
EmitMulIL.Emit(OpCodes.Stloc, 0)
9478
EmitMulIL.MarkSequencePoint(doc3, 644, 1, 644, 100)
9479
Dim typ220(-1) As Type
9480
EmitMulIL.Emit(OpCodes.Ldsfld, ILGen)
9481
Typ = ILGen.FieldType
9482
Typ03 = Typ
9483
EmitMulIL.Emit(OpCodes.Ldloc, 0)
9484
Typ = GetType(OpCode)
9485
ReDim Preserve typ220(UBound(typ220) + 1)
9486
typ220(UBound(typ220)) = Typ
9487
EmitMulIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ220))
9488
Typ = Typ03.GetMethod("Emit", typ220).ReturnType
9489
If Typ.ToString() = GetType(System.Void).ToString() Then
9490
9491
Else
9492
EmitMulIL.Emit(OpCodes.Pop)
9493
End If
9494
EmitMulIL.MarkSequencePoint(doc3, 645, 1, 645, 100)
9464
9495
EmitMulIL.Emit(OpCodes.Br, cont218)
9465
9496
EmitMulIL.MarkLabel(cont218)
9466
EmitMulIL.MarkSequencePoint(doc3, 641, 1, 641, 100)
9497
EmitMulIL.MarkSequencePoint(doc3, 646, 1, 646, 100)
9467
9498
EmitMulIL.Emit(OpCodes.Ret)
9468
Dim typ219(-1) As Type
9469
ReDim Preserve typ219(UBound(typ219) + 1)
9470
typ219(UBound(typ219)) = GetType(System.Boolean)
9471
Dim EmitSub As MethodBuilder = ILEmitter.DefineMethod("EmitSub", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ219)
9499
Dim typ221(-1) As Type
9500
ReDim Preserve typ221(UBound(typ221) + 1)
9501
typ221(UBound(typ221)) = GetType(System.Boolean)
9502
Dim EmitSub As MethodBuilder = ILEmitter.DefineMethod("EmitSub", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ221)
9472
9503
Dim EmitSubIL As ILGenerator = EmitSub.GetILGenerator()
9473
9504
Dim EmitSubparam01 As ParameterBuilder = EmitSub.DefineParameter(1, ParameterAttributes.None, "s")
9474
EmitSubIL.MarkSequencePoint(doc3, 644, 1, 644, 100)
9475
Dim locbldr28 As LocalBuilder = EmitSubIL.DeclareLocal(GetType(OpCode))
9476
locbldr28.SetLocalSymInfo("op")
9477
EmitSubIL.MarkSequencePoint(doc3, 645, 1, 645, 100)
9505
EmitSubIL.MarkSequencePoint(doc3, 649, 1, 649, 100)
9506
Dim locbldr29 As LocalBuilder = EmitSubIL.DeclareLocal(GetType(OpCode))
9507
locbldr29.SetLocalSymInfo("op")
9508
EmitSubIL.MarkSequencePoint(doc3, 650, 1, 650, 100)
9478
9509
EmitSubIL.Emit(OpCodes.Ldarg, 0)
9479
9510
Typ = GetType(System.Boolean)
9480
9511
EmitSubIL.Emit(OpCodes.Ldc_I4, 1)
9485
9516
EmitSubIL.Emit(OpCodes.Beq, tru219)
9486
9517
EmitSubIL.Emit(OpCodes.Br, fa219)
9487
9518
EmitSubIL.MarkLabel(tru219)
9488
EmitSubIL.MarkSequencePoint(doc3, 646, 1, 646, 100)
9489
Dim typ220(-1) As Type
9519
EmitSubIL.MarkSequencePoint(doc3, 651, 1, 651, 100)
9520
Dim typ222(-1) As Type
9490
9521
EmitSubIL.Emit(OpCodes.Ldstr, "sub")
9491
9522
Typ = GetType(System.String)
9492
ReDim Preserve typ220(UBound(typ220) + 1)
9493
typ220(UBound(typ220)) = Typ
9494
EmitSubIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ220))
9495
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ220).ReturnType
9496
EmitSubIL.Emit(OpCodes.Stloc, 0)
9497
EmitSubIL.MarkSequencePoint(doc3, 647, 1, 647, 100)
9498
Dim typ221(-1) As Type
9499
EmitSubIL.Emit(OpCodes.Ldsfld, ILGen)
9500
Typ = ILGen.FieldType
9501
Typ03 = Typ
9502
EmitSubIL.Emit(OpCodes.Ldloc, 0)
9503
Typ = GetType(OpCode)
9504
ReDim Preserve typ221(UBound(typ221) + 1)
9505
typ221(UBound(typ221)) = Typ
9506
EmitSubIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ221))
9507
Typ = Typ03.GetMethod("Emit", typ221).ReturnType
9508
If Typ.ToString() = GetType(System.Void).ToString() Then
9509
9510
Else
9511
EmitSubIL.Emit(OpCodes.Pop)
9512
End If
9513
EmitSubIL.MarkSequencePoint(doc3, 648, 1, 648, 100)
9514
EmitSubIL.Emit(OpCodes.Br, cont219)
9515
EmitSubIL.MarkLabel(fa219)
9516
EmitSubIL.MarkSequencePoint(doc3, 649, 1, 649, 100)
9517
Dim typ222(-1) As Type
9518
EmitSubIL.Emit(OpCodes.Ldstr, "sub.ovf.un")
9519
Typ = GetType(System.String)
9520
9523
ReDim Preserve typ222(UBound(typ222) + 1)
9521
9524
typ222(UBound(typ222)) = Typ
9522
9525
EmitSubIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ222))
9523
9526
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ222).ReturnType
9524
9527
EmitSubIL.Emit(OpCodes.Stloc, 0)
9525
EmitSubIL.MarkSequencePoint(doc3, 650, 1, 650, 100)
9528
EmitSubIL.MarkSequencePoint(doc3, 652, 1, 652, 100)
9526
9529
Dim typ223(-1) As Type
9527
9530
EmitSubIL.Emit(OpCodes.Ldsfld, ILGen)
9528
9531
Typ = ILGen.FieldType
9538
9541
Else
9539
9542
EmitSubIL.Emit(OpCodes.Pop)
9540
9543
End If
9541
EmitSubIL.MarkSequencePoint(doc3, 651, 1, 651, 100)
9544
EmitSubIL.MarkSequencePoint(doc3, 653, 1, 653, 100)
9545
EmitSubIL.Emit(OpCodes.Br, cont219)
9546
EmitSubIL.MarkLabel(fa219)
9547
EmitSubIL.MarkSequencePoint(doc3, 654, 1, 654, 100)
9548
Dim typ224(-1) As Type
9549
EmitSubIL.Emit(OpCodes.Ldstr, "sub.ovf.un")
9550
Typ = GetType(System.String)
9551
ReDim Preserve typ224(UBound(typ224) + 1)
9552
typ224(UBound(typ224)) = Typ
9553
EmitSubIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ224))
9554
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ224).ReturnType
9555
EmitSubIL.Emit(OpCodes.Stloc, 0)
9556
EmitSubIL.MarkSequencePoint(doc3, 655, 1, 655, 100)
9557
Dim typ225(-1) As Type
9558
EmitSubIL.Emit(OpCodes.Ldsfld, ILGen)
9559
Typ = ILGen.FieldType
9560
Typ03 = Typ
9561
EmitSubIL.Emit(OpCodes.Ldloc, 0)
9562
Typ = GetType(OpCode)
9563
ReDim Preserve typ225(UBound(typ225) + 1)
9564
typ225(UBound(typ225)) = Typ
9565
EmitSubIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ225))
9566
Typ = Typ03.GetMethod("Emit", typ225).ReturnType
9567
If Typ.ToString() = GetType(System.Void).ToString() Then
9568
9569
Else
9570
EmitSubIL.Emit(OpCodes.Pop)
9571
End If
9572
EmitSubIL.MarkSequencePoint(doc3, 656, 1, 656, 100)
9542
9573
EmitSubIL.Emit(OpCodes.Br, cont219)
9543
9574
EmitSubIL.MarkLabel(cont219)
9544
EmitSubIL.MarkSequencePoint(doc3, 652, 1, 652, 100)
9575
EmitSubIL.MarkSequencePoint(doc3, 657, 1, 657, 100)
9545
9576
EmitSubIL.Emit(OpCodes.Ret)
9546
9577
Dim EmitShl As MethodBuilder = ILEmitter.DefineMethod("EmitShl", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), Type.EmptyTypes)
9547
9578
Dim EmitShlIL As ILGenerator = EmitShl.GetILGenerator()
9548
EmitShlIL.MarkSequencePoint(doc3, 655, 1, 655, 100)
9549
Dim locbldr29 As LocalBuilder = EmitShlIL.DeclareLocal(GetType(OpCode))
9550
locbldr29.SetLocalSymInfo("op")
9551
EmitShlIL.MarkSequencePoint(doc3, 656, 1, 656, 100)
9552
Dim typ224(-1) As Type
9579
EmitShlIL.MarkSequencePoint(doc3, 660, 1, 660, 100)
9580
Dim locbldr30 As LocalBuilder = EmitShlIL.DeclareLocal(GetType(OpCode))
9581
locbldr30.SetLocalSymInfo("op")
9582
EmitShlIL.MarkSequencePoint(doc3, 661, 1, 661, 100)
9583
Dim typ226(-1) As Type
9553
9584
EmitShlIL.Emit(OpCodes.Ldstr, "shl")
9554
9585
Typ = GetType(System.String)
9555
ReDim Preserve typ224(UBound(typ224) + 1)
9556
typ224(UBound(typ224)) = Typ
9557
EmitShlIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ224))
9558
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ224).ReturnType
9586
ReDim Preserve typ226(UBound(typ226) + 1)
9587
typ226(UBound(typ226)) = Typ
9588
EmitShlIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ226))
9589
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ226).ReturnType
9559
9590
EmitShlIL.Emit(OpCodes.Stloc, 0)
9560
EmitShlIL.MarkSequencePoint(doc3, 657, 1, 657, 100)
9561
Dim typ225(-1) As Type
9591
EmitShlIL.MarkSequencePoint(doc3, 662, 1, 662, 100)
9592
Dim typ227(-1) As Type
9562
9593
EmitShlIL.Emit(OpCodes.Ldsfld, ILGen)
9563
9594
Typ = ILGen.FieldType
9564
9595
Typ03 = Typ
9565
9596
EmitShlIL.Emit(OpCodes.Ldloc, 0)
9566
9597
Typ = GetType(OpCode)
9567
ReDim Preserve typ225(UBound(typ225) + 1)
9568
typ225(UBound(typ225)) = Typ
9569
EmitShlIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ225))
9570
Typ = Typ03.GetMethod("Emit", typ225).ReturnType
9598
ReDim Preserve typ227(UBound(typ227) + 1)
9599
typ227(UBound(typ227)) = Typ
9600
EmitShlIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ227))
9601
Typ = Typ03.GetMethod("Emit", typ227).ReturnType
9571
9602
If Typ.ToString() = GetType(System.Void).ToString() Then
9572
9603
9573
9604
Else
9574
9605
EmitShlIL.Emit(OpCodes.Pop)
9575
9606
End If
9576
EmitShlIL.MarkSequencePoint(doc3, 658, 1, 658, 100)
9607
EmitShlIL.MarkSequencePoint(doc3, 663, 1, 663, 100)
9577
9608
EmitShlIL.Emit(OpCodes.Ret)
9578
Dim typ226(-1) As Type
9579
ReDim Preserve typ226(UBound(typ226) + 1)
9580
typ226(UBound(typ226)) = GetType(System.Boolean)
9581
Dim EmitShr As MethodBuilder = ILEmitter.DefineMethod("EmitShr", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ226)
9609
Dim typ228(-1) As Type
9610
ReDim Preserve typ228(UBound(typ228) + 1)
9611
typ228(UBound(typ228)) = GetType(System.Boolean)
9612
Dim EmitShr As MethodBuilder = ILEmitter.DefineMethod("EmitShr", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ228)
9582
9613
Dim EmitShrIL As ILGenerator = EmitShr.GetILGenerator()
9583
9614
Dim EmitShrparam01 As ParameterBuilder = EmitShr.DefineParameter(1, ParameterAttributes.None, "s")
9584
EmitShrIL.MarkSequencePoint(doc3, 661, 1, 661, 100)
9585
Dim locbldr30 As LocalBuilder = EmitShrIL.DeclareLocal(GetType(OpCode))
9586
locbldr30.SetLocalSymInfo("op")
9587
EmitShrIL.MarkSequencePoint(doc3, 662, 1, 662, 100)
9615
EmitShrIL.MarkSequencePoint(doc3, 666, 1, 666, 100)
9616
Dim locbldr31 As LocalBuilder = EmitShrIL.DeclareLocal(GetType(OpCode))
9617
locbldr31.SetLocalSymInfo("op")
9618
EmitShrIL.MarkSequencePoint(doc3, 667, 1, 667, 100)
9588
9619
EmitShrIL.Emit(OpCodes.Ldarg, 0)
9589
9620
Typ = GetType(System.Boolean)
9590
9621
EmitShrIL.Emit(OpCodes.Ldc_I4, 1)
9595
9626
EmitShrIL.Emit(OpCodes.Beq, tru220)
9596
9627
EmitShrIL.Emit(OpCodes.Br, fa220)
9597
9628
EmitShrIL.MarkLabel(tru220)
9598
EmitShrIL.MarkSequencePoint(doc3, 663, 1, 663, 100)
9599
Dim typ227(-1) As Type
9629
EmitShrIL.MarkSequencePoint(doc3, 668, 1, 668, 100)
9630
Dim typ229(-1) As Type
9600
9631
EmitShrIL.Emit(OpCodes.Ldstr, "shr")
9601
9632
Typ = GetType(System.String)
9602
ReDim Preserve typ227(UBound(typ227) + 1)
9603
typ227(UBound(typ227)) = Typ
9604
EmitShrIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ227))
9605
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ227).ReturnType
9606
EmitShrIL.Emit(OpCodes.Stloc, 0)
9607
EmitShrIL.MarkSequencePoint(doc3, 664, 1, 664, 100)
9608
Dim typ228(-1) As Type
9609
EmitShrIL.Emit(OpCodes.Ldsfld, ILGen)
9610
Typ = ILGen.FieldType
9611
Typ03 = Typ
9612
EmitShrIL.Emit(OpCodes.Ldloc, 0)
9613
Typ = GetType(OpCode)
9614
ReDim Preserve typ228(UBound(typ228) + 1)
9615
typ228(UBound(typ228)) = Typ
9616
EmitShrIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ228))
9617
Typ = Typ03.GetMethod("Emit", typ228).ReturnType
9618
If Typ.ToString() = GetType(System.Void).ToString() Then
9619
9620
Else
9621
EmitShrIL.Emit(OpCodes.Pop)
9622
End If
9623
EmitShrIL.MarkSequencePoint(doc3, 665, 1, 665, 100)
9624
EmitShrIL.Emit(OpCodes.Br, cont220)
9625
EmitShrIL.MarkLabel(fa220)
9626
EmitShrIL.MarkSequencePoint(doc3, 666, 1, 666, 100)
9627
Dim typ229(-1) As Type
9628
EmitShrIL.Emit(OpCodes.Ldstr, "shr.un")
9629
Typ = GetType(System.String)
9630
9633
ReDim Preserve typ229(UBound(typ229) + 1)
9631
9634
typ229(UBound(typ229)) = Typ
9632
9635
EmitShrIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ229))
9633
9636
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ229).ReturnType
9634
9637
EmitShrIL.Emit(OpCodes.Stloc, 0)
9635
EmitShrIL.MarkSequencePoint(doc3, 667, 1, 667, 100)
9638
EmitShrIL.MarkSequencePoint(doc3, 669, 1, 669, 100)
9636
9639
Dim typ230(-1) As Type
9637
9640
EmitShrIL.Emit(OpCodes.Ldsfld, ILGen)
9638
9641
Typ = ILGen.FieldType
9648
9651
Else
9649
9652
EmitShrIL.Emit(OpCodes.Pop)
9650
9653
End If
9651
EmitShrIL.MarkSequencePoint(doc3, 668, 1, 668, 100)
9654
EmitShrIL.MarkSequencePoint(doc3, 670, 1, 670, 100)
9652
9655
EmitShrIL.Emit(OpCodes.Br, cont220)
9653
EmitShrIL.MarkLabel(cont220)
9654
EmitShrIL.MarkSequencePoint(doc3, 669, 1, 669, 100)
9655
EmitShrIL.Emit(OpCodes.Ret)
9656
Dim EmitAnd As MethodBuilder = ILEmitter.DefineMethod("EmitAnd", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), Type.EmptyTypes)
9657
Dim EmitAndIL As ILGenerator = EmitAnd.GetILGenerator()
9658
EmitAndIL.MarkSequencePoint(doc3, 672, 1, 672, 100)
9659
Dim locbldr31 As LocalBuilder = EmitAndIL.DeclareLocal(GetType(OpCode))
9660
locbldr31.SetLocalSymInfo("op")
9661
EmitAndIL.MarkSequencePoint(doc3, 673, 1, 673, 100)
9656
EmitShrIL.MarkLabel(fa220)
9657
EmitShrIL.MarkSequencePoint(doc3, 671, 1, 671, 100)
9662
9658
Dim typ231(-1) As Type
9663
EmitAndIL.Emit(OpCodes.Ldstr, "and")
9659
EmitShrIL.Emit(OpCodes.Ldstr, "shr.un")
9664
9660
Typ = GetType(System.String)
9665
9661
ReDim Preserve typ231(UBound(typ231) + 1)
9666
9662
typ231(UBound(typ231)) = Typ
9667
EmitAndIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ231))
9663
EmitShrIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ231))
9668
9664
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ231).ReturnType
9669
EmitAndIL.Emit(OpCodes.Stloc, 0)
9670
EmitAndIL.MarkSequencePoint(doc3, 674, 1, 674, 100)
9665
EmitShrIL.Emit(OpCodes.Stloc, 0)
9666
EmitShrIL.MarkSequencePoint(doc3, 672, 1, 672, 100)
9671
9667
Dim typ232(-1) As Type
9672
EmitAndIL.Emit(OpCodes.Ldsfld, ILGen)
9668
EmitShrIL.Emit(OpCodes.Ldsfld, ILGen)
9673
9669
Typ = ILGen.FieldType
9674
9670
Typ03 = Typ
9675
EmitAndIL.Emit(OpCodes.Ldloc, 0)
9671
EmitShrIL.Emit(OpCodes.Ldloc, 0)
9676
9672
Typ = GetType(OpCode)
9677
9673
ReDim Preserve typ232(UBound(typ232) + 1)
9678
9674
typ232(UBound(typ232)) = Typ
9679
EmitAndIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ232))
9675
EmitShrIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ232))
9680
9676
Typ = Typ03.GetMethod("Emit", typ232).ReturnType
9681
9677
If Typ.ToString() = GetType(System.Void).ToString() Then
9682
9678
9683
9679
Else
9684
EmitAndIL.Emit(OpCodes.Pop)
9680
EmitShrIL.Emit(OpCodes.Pop)
9685
9681
End If
9686
EmitAndIL.MarkSequencePoint(doc3, 675, 1, 675, 100)
9687
EmitAndIL.Emit(OpCodes.Ret)
9688
Dim EmitOr As MethodBuilder = ILEmitter.DefineMethod("EmitOr", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), Type.EmptyTypes)
9689
Dim EmitOrIL As ILGenerator = EmitOr.GetILGenerator()
9690
EmitOrIL.MarkSequencePoint(doc3, 678, 1, 678, 100)
9691
Dim locbldr32 As LocalBuilder = EmitOrIL.DeclareLocal(GetType(OpCode))
9682
EmitShrIL.MarkSequencePoint(doc3, 673, 1, 673, 100)
9683
EmitShrIL.Emit(OpCodes.Br, cont220)
9684
EmitShrIL.MarkLabel(cont220)
9685
EmitShrIL.MarkSequencePoint(doc3, 674, 1, 674, 100)
9686
EmitShrIL.Emit(OpCodes.Ret)
9687
Dim EmitAnd As MethodBuilder = ILEmitter.DefineMethod("EmitAnd", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), Type.EmptyTypes)
9688
Dim EmitAndIL As ILGenerator = EmitAnd.GetILGenerator()
9689
EmitAndIL.MarkSequencePoint(doc3, 677, 1, 677, 100)
9690
Dim locbldr32 As LocalBuilder = EmitAndIL.DeclareLocal(GetType(OpCode))
9692
9691
locbldr32.SetLocalSymInfo("op")
9693
EmitOrIL.MarkSequencePoint(doc3, 679, 1, 679, 100)
9692
EmitAndIL.MarkSequencePoint(doc3, 678, 1, 678, 100)
9694
9693
Dim typ233(-1) As Type
9695
EmitOrIL.Emit(OpCodes.Ldstr, "or")
9694
EmitAndIL.Emit(OpCodes.Ldstr, "and")
9696
9695
Typ = GetType(System.String)
9697
9696
ReDim Preserve typ233(UBound(typ233) + 1)
9698
9697
typ233(UBound(typ233)) = Typ
9699
EmitOrIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ233))
9698
EmitAndIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ233))
9700
9699
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ233).ReturnType
9701
EmitOrIL.Emit(OpCodes.Stloc, 0)
9702
EmitOrIL.MarkSequencePoint(doc3, 680, 1, 680, 100)
9700
EmitAndIL.Emit(OpCodes.Stloc, 0)
9701
EmitAndIL.MarkSequencePoint(doc3, 679, 1, 679, 100)
9703
9702
Dim typ234(-1) As Type
9704
EmitOrIL.Emit(OpCodes.Ldsfld, ILGen)
9703
EmitAndIL.Emit(OpCodes.Ldsfld, ILGen)
9705
9704
Typ = ILGen.FieldType
9706
9705
Typ03 = Typ
9707
EmitOrIL.Emit(OpCodes.Ldloc, 0)
9706
EmitAndIL.Emit(OpCodes.Ldloc, 0)
9708
9707
Typ = GetType(OpCode)
9709
9708
ReDim Preserve typ234(UBound(typ234) + 1)
9710
9709
typ234(UBound(typ234)) = Typ
9711
EmitOrIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ234))
9710
EmitAndIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ234))
9712
9711
Typ = Typ03.GetMethod("Emit", typ234).ReturnType
9713
9712
If Typ.ToString() = GetType(System.Void).ToString() Then
9714
9713
9715
9714
Else
9716
EmitOrIL.Emit(OpCodes.Pop)
9715
EmitAndIL.Emit(OpCodes.Pop)
9717
9716
End If
9718
EmitOrIL.MarkSequencePoint(doc3, 681, 1, 681, 100)
9719
EmitOrIL.Emit(OpCodes.Ret)
9720
Dim EmitXor As MethodBuilder = ILEmitter.DefineMethod("EmitXor", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), Type.EmptyTypes)
9721
Dim EmitXorIL As ILGenerator = EmitXor.GetILGenerator()
9722
EmitXorIL.MarkSequencePoint(doc3, 684, 1, 684, 100)
9723
Dim locbldr33 As LocalBuilder = EmitXorIL.DeclareLocal(GetType(OpCode))
9717
EmitAndIL.MarkSequencePoint(doc3, 680, 1, 680, 100)
9718
EmitAndIL.Emit(OpCodes.Ret)
9719
Dim EmitOr As MethodBuilder = ILEmitter.DefineMethod("EmitOr", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), Type.EmptyTypes)
9720
Dim EmitOrIL As ILGenerator = EmitOr.GetILGenerator()
9721
EmitOrIL.MarkSequencePoint(doc3, 683, 1, 683, 100)
9722
Dim locbldr33 As LocalBuilder = EmitOrIL.DeclareLocal(GetType(OpCode))
9724
9723
locbldr33.SetLocalSymInfo("op")
9725
EmitXorIL.MarkSequencePoint(doc3, 685, 1, 685, 100)
9724
EmitOrIL.MarkSequencePoint(doc3, 684, 1, 684, 100)
9726
9725
Dim typ235(-1) As Type
9727
EmitXorIL.Emit(OpCodes.Ldstr, "xor")
9726
EmitOrIL.Emit(OpCodes.Ldstr, "or")
9728
9727
Typ = GetType(System.String)
9729
9728
ReDim Preserve typ235(UBound(typ235) + 1)
9730
9729
typ235(UBound(typ235)) = Typ
9731
EmitXorIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ235))
9730
EmitOrIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ235))
9732
9731
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ235).ReturnType
9733
EmitXorIL.Emit(OpCodes.Stloc, 0)
9734
EmitXorIL.MarkSequencePoint(doc3, 686, 1, 686, 100)
9732
EmitOrIL.Emit(OpCodes.Stloc, 0)
9733
EmitOrIL.MarkSequencePoint(doc3, 685, 1, 685, 100)
9735
9734
Dim typ236(-1) As Type
9736
EmitXorIL.Emit(OpCodes.Ldsfld, ILGen)
9735
EmitOrIL.Emit(OpCodes.Ldsfld, ILGen)
9737
9736
Typ = ILGen.FieldType
9738
9737
Typ03 = Typ
9739
EmitXorIL.Emit(OpCodes.Ldloc, 0)
9738
EmitOrIL.Emit(OpCodes.Ldloc, 0)
9740
9739
Typ = GetType(OpCode)
9741
9740
ReDim Preserve typ236(UBound(typ236) + 1)
9742
9741
typ236(UBound(typ236)) = Typ
9743
EmitXorIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ236))
9742
EmitOrIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ236))
9744
9743
Typ = Typ03.GetMethod("Emit", typ236).ReturnType
9745
9744
If Typ.ToString() = GetType(System.Void).ToString() Then
9746
9745
9747
9746
Else
9748
EmitXorIL.Emit(OpCodes.Pop)
9747
EmitOrIL.Emit(OpCodes.Pop)
9749
9748
End If
9750
EmitXorIL.MarkSequencePoint(doc3, 687, 1, 687, 100)
9751
EmitXorIL.Emit(OpCodes.Ret)
9752
Dim EmitNot As MethodBuilder = ILEmitter.DefineMethod("EmitNot", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), Type.EmptyTypes)
9753
Dim EmitNotIL As ILGenerator = EmitNot.GetILGenerator()
9754
EmitNotIL.MarkSequencePoint(doc3, 690, 1, 690, 100)
9755
Dim locbldr34 As LocalBuilder = EmitNotIL.DeclareLocal(GetType(OpCode))
9749
EmitOrIL.MarkSequencePoint(doc3, 686, 1, 686, 100)
9750
EmitOrIL.Emit(OpCodes.Ret)
9751
Dim EmitXor As MethodBuilder = ILEmitter.DefineMethod("EmitXor", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), Type.EmptyTypes)
9752
Dim EmitXorIL As ILGenerator = EmitXor.GetILGenerator()
9753
EmitXorIL.MarkSequencePoint(doc3, 689, 1, 689, 100)
9754
Dim locbldr34 As LocalBuilder = EmitXorIL.DeclareLocal(GetType(OpCode))
9756
9755
locbldr34.SetLocalSymInfo("op")
9757
EmitNotIL.MarkSequencePoint(doc3, 691, 1, 691, 100)
9756
EmitXorIL.MarkSequencePoint(doc3, 690, 1, 690, 100)
9758
9757
Dim typ237(-1) As Type
9759
EmitNotIL.Emit(OpCodes.Ldstr, "not")
9758
EmitXorIL.Emit(OpCodes.Ldstr, "xor")
9760
9759
Typ = GetType(System.String)
9761
9760
ReDim Preserve typ237(UBound(typ237) + 1)
9762
9761
typ237(UBound(typ237)) = Typ
9763
EmitNotIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ237))
9762
EmitXorIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ237))
9764
9763
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ237).ReturnType
9765
EmitNotIL.Emit(OpCodes.Stloc, 0)
9766
EmitNotIL.MarkSequencePoint(doc3, 692, 1, 692, 100)
9764
EmitXorIL.Emit(OpCodes.Stloc, 0)
9765
EmitXorIL.MarkSequencePoint(doc3, 691, 1, 691, 100)
9767
9766
Dim typ238(-1) As Type
9768
EmitNotIL.Emit(OpCodes.Ldsfld, ILGen)
9767
EmitXorIL.Emit(OpCodes.Ldsfld, ILGen)
9769
9768
Typ = ILGen.FieldType
9770
9769
Typ03 = Typ
9771
EmitNotIL.Emit(OpCodes.Ldloc, 0)
9770
EmitXorIL.Emit(OpCodes.Ldloc, 0)
9772
9771
Typ = GetType(OpCode)
9773
9772
ReDim Preserve typ238(UBound(typ238) + 1)
9774
9773
typ238(UBound(typ238)) = Typ
9775
EmitNotIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ238))
9774
EmitXorIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ238))
9776
9775
Typ = Typ03.GetMethod("Emit", typ238).ReturnType
9777
9776
If Typ.ToString() = GetType(System.Void).ToString() Then
9778
9777
9779
9778
Else
9780
EmitNotIL.Emit(OpCodes.Pop)
9779
EmitXorIL.Emit(OpCodes.Pop)
9781
9780
End If
9782
EmitNotIL.MarkSequencePoint(doc3, 693, 1, 693, 100)
9783
EmitNotIL.Emit(OpCodes.Ret)
9784
Dim EmitNeg As MethodBuilder = ILEmitter.DefineMethod("EmitNeg", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), Type.EmptyTypes)
9785
Dim EmitNegIL As ILGenerator = EmitNeg.GetILGenerator()
9786
EmitNegIL.MarkSequencePoint(doc3, 696, 1, 696, 100)
9787
Dim locbldr35 As LocalBuilder = EmitNegIL.DeclareLocal(GetType(OpCode))
9781
EmitXorIL.MarkSequencePoint(doc3, 692, 1, 692, 100)
9782
EmitXorIL.Emit(OpCodes.Ret)
9783
Dim EmitNot As MethodBuilder = ILEmitter.DefineMethod("EmitNot", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), Type.EmptyTypes)
9784
Dim EmitNotIL As ILGenerator = EmitNot.GetILGenerator()
9785
EmitNotIL.MarkSequencePoint(doc3, 695, 1, 695, 100)
9786
Dim locbldr35 As LocalBuilder = EmitNotIL.DeclareLocal(GetType(OpCode))
9788
9787
locbldr35.SetLocalSymInfo("op")
9789
EmitNegIL.MarkSequencePoint(doc3, 697, 1, 697, 100)
9788
EmitNotIL.MarkSequencePoint(doc3, 696, 1, 696, 100)
9790
9789
Dim typ239(-1) As Type
9791
EmitNegIL.Emit(OpCodes.Ldstr, "neg")
9790
EmitNotIL.Emit(OpCodes.Ldstr, "ldc.i4.0")
9792
9791
Typ = GetType(System.String)
9793
9792
ReDim Preserve typ239(UBound(typ239) + 1)
9794
9793
typ239(UBound(typ239)) = Typ
9795
EmitNegIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ239))
9794
EmitNotIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ239))
9796
9795
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ239).ReturnType
9797
EmitNegIL.Emit(OpCodes.Stloc, 0)
9798
EmitNegIL.MarkSequencePoint(doc3, 698, 1, 698, 100)
9796
EmitNotIL.Emit(OpCodes.Stloc, 0)
9797
EmitNotIL.MarkSequencePoint(doc3, 697, 1, 697, 100)
9799
9798
Dim typ240(-1) As Type
9800
EmitNegIL.Emit(OpCodes.Ldsfld, ILGen)
9799
EmitNotIL.Emit(OpCodes.Ldsfld, ILGen)
9801
9800
Typ = ILGen.FieldType
9802
9801
Typ03 = Typ
9803
EmitNegIL.Emit(OpCodes.Ldloc, 0)
9802
EmitNotIL.Emit(OpCodes.Ldloc, 0)
9804
9803
Typ = GetType(OpCode)
9805
9804
ReDim Preserve typ240(UBound(typ240) + 1)
9806
9805
typ240(UBound(typ240)) = Typ
9807
EmitNegIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ240))
9806
EmitNotIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ240))
9808
9807
Typ = Typ03.GetMethod("Emit", typ240).ReturnType
9809
9808
If Typ.ToString() = GetType(System.Void).ToString() Then
9810
9809
9811
9810
Else
9812
EmitNegIL.Emit(OpCodes.Pop)
9811
EmitNotIL.Emit(OpCodes.Pop)
9813
9812
End If
9814
EmitNegIL.MarkSequencePoint(doc3, 699, 1, 699, 100)
9815
EmitNegIL.Emit(OpCodes.Ret)
9816
Dim EmitNand As MethodBuilder = ILEmitter.DefineMethod("EmitNand", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), Type.EmptyTypes)
9817
Dim EmitNandIL As ILGenerator = EmitNand.GetILGenerator()
9818
EmitNandIL.MarkSequencePoint(doc3, 702, 1, 702, 100)
9819
Dim locbldr36 As LocalBuilder = EmitNandIL.DeclareLocal(GetType(OpCode))
9820
locbldr36.SetLocalSymInfo("op")
9821
EmitNandIL.MarkSequencePoint(doc3, 703, 1, 703, 100)
9813
EmitNotIL.MarkSequencePoint(doc3, 698, 1, 698, 100)
9822
9814
Dim typ241(-1) As Type
9823
EmitNandIL.Emit(OpCodes.Ldstr, "and")
9815
EmitNotIL.Emit(OpCodes.Ldstr, "ceq")
9824
9816
Typ = GetType(System.String)
9825
9817
ReDim Preserve typ241(UBound(typ241) + 1)
9826
9818
typ241(UBound(typ241)) = Typ
9827
EmitNandIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ241))
9819
EmitNotIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ241))
9828
9820
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ241).ReturnType
9829
EmitNandIL.Emit(OpCodes.Stloc, 0)
9830
EmitNandIL.MarkSequencePoint(doc3, 704, 1, 704, 100)
9821
EmitNotIL.Emit(OpCodes.Stloc, 0)
9822
EmitNotIL.MarkSequencePoint(doc3, 699, 1, 699, 100)
9831
9823
Dim typ242(-1) As Type
9832
EmitNandIL.Emit(OpCodes.Ldsfld, ILGen)
9824
EmitNotIL.Emit(OpCodes.Ldsfld, ILGen)
9833
9825
Typ = ILGen.FieldType
9834
9826
Typ03 = Typ
9835
EmitNandIL.Emit(OpCodes.Ldloc, 0)
9827
EmitNotIL.Emit(OpCodes.Ldloc, 0)
9836
9828
Typ = GetType(OpCode)
9837
9829
ReDim Preserve typ242(UBound(typ242) + 1)
9838
9830
typ242(UBound(typ242)) = Typ
9839
EmitNandIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ242))
9831
EmitNotIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ242))
9840
9832
Typ = Typ03.GetMethod("Emit", typ242).ReturnType
9841
9833
If Typ.ToString() = GetType(System.Void).ToString() Then
9842
9834
9843
9835
Else
9844
EmitNandIL.Emit(OpCodes.Pop)
9836
EmitNotIL.Emit(OpCodes.Pop)
9845
9837
End If
9846
EmitNandIL.MarkSequencePoint(doc3, 705, 1, 705, 100)
9838
EmitNotIL.MarkSequencePoint(doc3, 700, 1, 700, 100)
9839
EmitNotIL.Emit(OpCodes.Ret)
9840
Dim EmitNeg As MethodBuilder = ILEmitter.DefineMethod("EmitNeg", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), Type.EmptyTypes)
9841
Dim EmitNegIL As ILGenerator = EmitNeg.GetILGenerator()
9842
EmitNegIL.MarkSequencePoint(doc3, 703, 1, 703, 100)
9843
Dim locbldr36 As LocalBuilder = EmitNegIL.DeclareLocal(GetType(OpCode))
9844
locbldr36.SetLocalSymInfo("op")
9845
EmitNegIL.MarkSequencePoint(doc3, 704, 1, 704, 100)
9847
9846
Dim typ243(-1) As Type
9848
EmitNandIL.Emit(OpCodes.Ldstr, "not")
9847
EmitNegIL.Emit(OpCodes.Ldstr, "neg")
9849
9848
Typ = GetType(System.String)
9850
9849
ReDim Preserve typ243(UBound(typ243) + 1)
9851
9850
typ243(UBound(typ243)) = Typ
9852
EmitNandIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ243))
9851
EmitNegIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ243))
9853
9852
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ243).ReturnType
9854
EmitNandIL.Emit(OpCodes.Stloc, 0)
9855
EmitNandIL.MarkSequencePoint(doc3, 706, 1, 706, 100)
9853
EmitNegIL.Emit(OpCodes.Stloc, 0)
9854
EmitNegIL.MarkSequencePoint(doc3, 705, 1, 705, 100)
9856
9855
Dim typ244(-1) As Type
9857
EmitNandIL.Emit(OpCodes.Ldsfld, ILGen)
9856
EmitNegIL.Emit(OpCodes.Ldsfld, ILGen)
9858
9857
Typ = ILGen.FieldType
9859
9858
Typ03 = Typ
9860
EmitNandIL.Emit(OpCodes.Ldloc, 0)
9859
EmitNegIL.Emit(OpCodes.Ldloc, 0)
9861
9860
Typ = GetType(OpCode)
9862
9861
ReDim Preserve typ244(UBound(typ244) + 1)
9863
9862
typ244(UBound(typ244)) = Typ
9864
EmitNandIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ244))
9863
EmitNegIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ244))
9865
9864
Typ = Typ03.GetMethod("Emit", typ244).ReturnType
9866
9865
If Typ.ToString() = GetType(System.Void).ToString() Then
9867
9866
9868
9867
Else
9869
EmitNandIL.Emit(OpCodes.Pop)
9868
EmitNegIL.Emit(OpCodes.Pop)
9870
9869
End If
9871
EmitNandIL.MarkSequencePoint(doc3, 707, 1, 707, 100)
9872
EmitNandIL.Emit(OpCodes.Ret)
9873
Dim EmitNor As MethodBuilder = ILEmitter.DefineMethod("EmitNor", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), Type.EmptyTypes)
9874
Dim EmitNorIL As ILGenerator = EmitNor.GetILGenerator()
9875
EmitNorIL.MarkSequencePoint(doc3, 710, 1, 710, 100)
9876
Dim locbldr37 As LocalBuilder = EmitNorIL.DeclareLocal(GetType(OpCode))
9870
EmitNegIL.MarkSequencePoint(doc3, 706, 1, 706, 100)
9871
EmitNegIL.Emit(OpCodes.Ret)
9872
Dim EmitNand As MethodBuilder = ILEmitter.DefineMethod("EmitNand", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), Type.EmptyTypes)
9873
Dim EmitNandIL As ILGenerator = EmitNand.GetILGenerator()
9874
EmitNandIL.MarkSequencePoint(doc3, 709, 1, 709, 100)
9875
Dim locbldr37 As LocalBuilder = EmitNandIL.DeclareLocal(GetType(OpCode))
9877
9876
locbldr37.SetLocalSymInfo("op")
9878
EmitNorIL.MarkSequencePoint(doc3, 711, 1, 711, 100)
9877
EmitNandIL.MarkSequencePoint(doc3, 710, 1, 710, 100)
9879
9878
Dim typ245(-1) As Type
9880
EmitNorIL.Emit(OpCodes.Ldstr, "or")
9879
EmitNandIL.Emit(OpCodes.Ldstr, "and")
9881
9880
Typ = GetType(System.String)
9882
9881
ReDim Preserve typ245(UBound(typ245) + 1)
9883
9882
typ245(UBound(typ245)) = Typ
9884
EmitNorIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ245))
9883
EmitNandIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ245))
9885
9884
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ245).ReturnType
9886
EmitNorIL.Emit(OpCodes.Stloc, 0)
9887
EmitNorIL.MarkSequencePoint(doc3, 712, 1, 712, 100)
9885
EmitNandIL.Emit(OpCodes.Stloc, 0)
9886
EmitNandIL.MarkSequencePoint(doc3, 711, 1, 711, 100)
9888
9887
Dim typ246(-1) As Type
9889
EmitNorIL.Emit(OpCodes.Ldsfld, ILGen)
9888
EmitNandIL.Emit(OpCodes.Ldsfld, ILGen)
9890
9889
Typ = ILGen.FieldType
9891
9890
Typ03 = Typ
9892
EmitNorIL.Emit(OpCodes.Ldloc, 0)
9891
EmitNandIL.Emit(OpCodes.Ldloc, 0)
9893
9892
Typ = GetType(OpCode)
9894
9893
ReDim Preserve typ246(UBound(typ246) + 1)
9895
9894
typ246(UBound(typ246)) = Typ
9896
EmitNorIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ246))
9895
EmitNandIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ246))
9897
9896
Typ = Typ03.GetMethod("Emit", typ246).ReturnType
9898
9897
If Typ.ToString() = GetType(System.Void).ToString() Then
9899
9898
9900
9899
Else
9901
EmitNorIL.Emit(OpCodes.Pop)
9900
EmitNandIL.Emit(OpCodes.Pop)
9902
9901
End If
9903
EmitNorIL.MarkSequencePoint(doc3, 713, 1, 713, 100)
9902
EmitNandIL.MarkSequencePoint(doc3, 712, 1, 712, 100)
9904
9903
Dim typ247(-1) As Type
9905
EmitNorIL.Emit(OpCodes.Ldstr, "not")
9904
EmitNandIL.Emit(OpCodes.Ldstr, "ldc.i4.0")
9906
9905
Typ = GetType(System.String)
9907
9906
ReDim Preserve typ247(UBound(typ247) + 1)
9908
9907
typ247(UBound(typ247)) = Typ
9909
EmitNorIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ247))
9908
EmitNandIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ247))
9910
9909
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ247).ReturnType
9911
EmitNorIL.Emit(OpCodes.Stloc, 0)
9912
EmitNorIL.MarkSequencePoint(doc3, 714, 1, 714, 100)
9910
EmitNandIL.Emit(OpCodes.Stloc, 0)
9911
EmitNandIL.MarkSequencePoint(doc3, 713, 1, 713, 100)
9913
9912
Dim typ248(-1) As Type
9914
EmitNorIL.Emit(OpCodes.Ldsfld, ILGen)
9913
EmitNandIL.Emit(OpCodes.Ldsfld, ILGen)
9915
9914
Typ = ILGen.FieldType
9916
9915
Typ03 = Typ
9917
EmitNorIL.Emit(OpCodes.Ldloc, 0)
9916
EmitNandIL.Emit(OpCodes.Ldloc, 0)
9918
9917
Typ = GetType(OpCode)
9919
9918
ReDim Preserve typ248(UBound(typ248) + 1)
9920
9919
typ248(UBound(typ248)) = Typ
9921
EmitNorIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ248))
9920
EmitNandIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ248))
9922
9921
Typ = Typ03.GetMethod("Emit", typ248).ReturnType
9923
9922
If Typ.ToString() = GetType(System.Void).ToString() Then
9924
9923
9925
9924
Else
9926
EmitNorIL.Emit(OpCodes.Pop)
9925
EmitNandIL.Emit(OpCodes.Pop)
9927
9926
End If
9928
EmitNorIL.MarkSequencePoint(doc3, 715, 1, 715, 100)
9929
EmitNorIL.Emit(OpCodes.Ret)
9930
Dim EmitXnor As MethodBuilder = ILEmitter.DefineMethod("EmitXnor", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), Type.EmptyTypes)
9931
Dim EmitXnorIL As ILGenerator = EmitXnor.GetILGenerator()
9932
EmitXnorIL.MarkSequencePoint(doc3, 718, 1, 718, 100)
9933
Dim locbldr38 As LocalBuilder = EmitXnorIL.DeclareLocal(GetType(OpCode))
9934
locbldr38.SetLocalSymInfo("op")
9935
EmitXnorIL.MarkSequencePoint(doc3, 719, 1, 719, 100)
9927
EmitNandIL.MarkSequencePoint(doc3, 714, 1, 714, 100)
9936
9928
Dim typ249(-1) As Type
9937
EmitXnorIL.Emit(OpCodes.Ldstr, "xor")
9929
EmitNandIL.Emit(OpCodes.Ldstr, "ceq")
9938
9930
Typ = GetType(System.String)
9939
9931
ReDim Preserve typ249(UBound(typ249) + 1)
9940
9932
typ249(UBound(typ249)) = Typ
9941
EmitXnorIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ249))
9933
EmitNandIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ249))
9942
9934
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ249).ReturnType
9943
EmitXnorIL.Emit(OpCodes.Stloc, 0)
9944
EmitXnorIL.MarkSequencePoint(doc3, 720, 1, 720, 100)
9935
EmitNandIL.Emit(OpCodes.Stloc, 0)
9936
EmitNandIL.MarkSequencePoint(doc3, 715, 1, 715, 100)
9945
9937
Dim typ250(-1) As Type
9946
EmitXnorIL.Emit(OpCodes.Ldsfld, ILGen)
9938
EmitNandIL.Emit(OpCodes.Ldsfld, ILGen)
9947
9939
Typ = ILGen.FieldType
9948
9940
Typ03 = Typ
9949
EmitXnorIL.Emit(OpCodes.Ldloc, 0)
9941
EmitNandIL.Emit(OpCodes.Ldloc, 0)
9950
9942
Typ = GetType(OpCode)
9951
9943
ReDim Preserve typ250(UBound(typ250) + 1)
9952
9944
typ250(UBound(typ250)) = Typ
9953
EmitXnorIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ250))
9945
EmitNandIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ250))
9954
9946
Typ = Typ03.GetMethod("Emit", typ250).ReturnType
9955
9947
If Typ.ToString() = GetType(System.Void).ToString() Then
9956
9948
9957
9949
Else
9958
EmitXnorIL.Emit(OpCodes.Pop)
9950
EmitNandIL.Emit(OpCodes.Pop)
9959
9951
End If
9960
EmitXnorIL.MarkSequencePoint(doc3, 721, 1, 721, 100)
9952
EmitNandIL.MarkSequencePoint(doc3, 716, 1, 716, 100)
9953
EmitNandIL.Emit(OpCodes.Ret)
9954
Dim EmitNor As MethodBuilder = ILEmitter.DefineMethod("EmitNor", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), Type.EmptyTypes)
9955
Dim EmitNorIL As ILGenerator = EmitNor.GetILGenerator()
9956
EmitNorIL.MarkSequencePoint(doc3, 719, 1, 719, 100)
9957
Dim locbldr38 As LocalBuilder = EmitNorIL.DeclareLocal(GetType(OpCode))
9958
locbldr38.SetLocalSymInfo("op")
9959
EmitNorIL.MarkSequencePoint(doc3, 720, 1, 720, 100)
9961
9960
Dim typ251(-1) As Type
9962
EmitXnorIL.Emit(OpCodes.Ldstr, "not")
9961
EmitNorIL.Emit(OpCodes.Ldstr, "or")
9963
9962
Typ = GetType(System.String)
9964
9963
ReDim Preserve typ251(UBound(typ251) + 1)
9965
9964
typ251(UBound(typ251)) = Typ
9966
EmitXnorIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ251))
9965
EmitNorIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ251))
9967
9966
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ251).ReturnType
9968
EmitXnorIL.Emit(OpCodes.Stloc, 0)
9969
EmitXnorIL.MarkSequencePoint(doc3, 722, 1, 722, 100)
9967
EmitNorIL.Emit(OpCodes.Stloc, 0)
9968
EmitNorIL.MarkSequencePoint(doc3, 721, 1, 721, 100)
9970
9969
Dim typ252(-1) As Type
9971
EmitXnorIL.Emit(OpCodes.Ldsfld, ILGen)
9970
EmitNorIL.Emit(OpCodes.Ldsfld, ILGen)
9972
9971
Typ = ILGen.FieldType
9973
9972
Typ03 = Typ
9974
EmitXnorIL.Emit(OpCodes.Ldloc, 0)
9973
EmitNorIL.Emit(OpCodes.Ldloc, 0)
9975
9974
Typ = GetType(OpCode)
9976
9975
ReDim Preserve typ252(UBound(typ252) + 1)
9977
9976
typ252(UBound(typ252)) = Typ
9978
EmitXnorIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ252))
9977
EmitNorIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ252))
9979
9978
Typ = Typ03.GetMethod("Emit", typ252).ReturnType
9980
9979
If Typ.ToString() = GetType(System.Void).ToString() Then
9981
9980
9982
9981
Else
9983
EmitXnorIL.Emit(OpCodes.Pop)
9982
EmitNorIL.Emit(OpCodes.Pop)
9984
9983
End If
9985
EmitXnorIL.MarkSequencePoint(doc3, 723, 1, 723, 100)
9986
EmitXnorIL.Emit(OpCodes.Ret)
9987
Dim EmitCeq As MethodBuilder = ILEmitter.DefineMethod("EmitCeq", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), Type.EmptyTypes)
9988
Dim EmitCeqIL As ILGenerator = EmitCeq.GetILGenerator()
9989
EmitCeqIL.MarkSequencePoint(doc3, 726, 1, 726, 100)
9990
Dim locbldr39 As LocalBuilder = EmitCeqIL.DeclareLocal(GetType(OpCode))
9991
locbldr39.SetLocalSymInfo("op")
9992
EmitCeqIL.MarkSequencePoint(doc3, 727, 1, 727, 100)
9984
EmitNorIL.MarkSequencePoint(doc3, 722, 1, 722, 100)
9993
9985
Dim typ253(-1) As Type
9994
EmitCeqIL.Emit(OpCodes.Ldstr, "ceq")
9986
EmitNorIL.Emit(OpCodes.Ldstr, "ldc.i4.0")
9995
9987
Typ = GetType(System.String)
9996
9988
ReDim Preserve typ253(UBound(typ253) + 1)
9997
9989
typ253(UBound(typ253)) = Typ
9998
EmitCeqIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ253))
9990
EmitNorIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ253))
9999
9991
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ253).ReturnType
10000
EmitCeqIL.Emit(OpCodes.Stloc, 0)
10001
EmitCeqIL.MarkSequencePoint(doc3, 728, 1, 728, 100)
9992
EmitNorIL.Emit(OpCodes.Stloc, 0)
9993
EmitNorIL.MarkSequencePoint(doc3, 723, 1, 723, 100)
10002
9994
Dim typ254(-1) As Type
10003
EmitCeqIL.Emit(OpCodes.Ldsfld, ILGen)
9995
EmitNorIL.Emit(OpCodes.Ldsfld, ILGen)
10004
9996
Typ = ILGen.FieldType
10005
9997
Typ03 = Typ
10006
EmitCeqIL.Emit(OpCodes.Ldloc, 0)
9998
EmitNorIL.Emit(OpCodes.Ldloc, 0)
10007
9999
Typ = GetType(OpCode)
10008
10000
ReDim Preserve typ254(UBound(typ254) + 1)
10009
10001
typ254(UBound(typ254)) = Typ
10010
EmitCeqIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ254))
10002
EmitNorIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ254))
10011
10003
Typ = Typ03.GetMethod("Emit", typ254).ReturnType
10012
10004
If Typ.ToString() = GetType(System.Void).ToString() Then
10013
10005
10014
10006
Else
10015
EmitCeqIL.Emit(OpCodes.Pop)
10007
EmitNorIL.Emit(OpCodes.Pop)
10016
10008
End If
10017
EmitCeqIL.MarkSequencePoint(doc3, 729, 1, 729, 100)
10018
EmitCeqIL.Emit(OpCodes.Ret)
10019
Dim EmitCneq As MethodBuilder = ILEmitter.DefineMethod("EmitCneq", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), Type.EmptyTypes)
10020
Dim EmitCneqIL As ILGenerator = EmitCneq.GetILGenerator()
10021
EmitCneqIL.MarkSequencePoint(doc3, 732, 1, 732, 100)
10022
Dim locbldr40 As LocalBuilder = EmitCneqIL.DeclareLocal(GetType(OpCode))
10023
locbldr40.SetLocalSymInfo("op")
10024
EmitCneqIL.MarkSequencePoint(doc3, 733, 1, 733, 100)
10009
EmitNorIL.MarkSequencePoint(doc3, 724, 1, 724, 100)
10025
10010
Dim typ255(-1) As Type
10026
EmitCneqIL.Emit(OpCodes.Ldstr, "ceq")
10011
EmitNorIL.Emit(OpCodes.Ldstr, "ceq")
10027
10012
Typ = GetType(System.String)
10028
10013
ReDim Preserve typ255(UBound(typ255) + 1)
10029
10014
typ255(UBound(typ255)) = Typ
10030
EmitCneqIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ255))
10015
EmitNorIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ255))
10031
10016
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ255).ReturnType
10032
EmitCneqIL.Emit(OpCodes.Stloc, 0)
10033
EmitCneqIL.MarkSequencePoint(doc3, 734, 1, 734, 100)
10017
EmitNorIL.Emit(OpCodes.Stloc, 0)
10018
EmitNorIL.MarkSequencePoint(doc3, 725, 1, 725, 100)
10034
10019
Dim typ256(-1) As Type
10035
EmitCneqIL.Emit(OpCodes.Ldsfld, ILGen)
10020
EmitNorIL.Emit(OpCodes.Ldsfld, ILGen)
10036
10021
Typ = ILGen.FieldType
10037
10022
Typ03 = Typ
10038
EmitCneqIL.Emit(OpCodes.Ldloc, 0)
10023
EmitNorIL.Emit(OpCodes.Ldloc, 0)
10039
10024
Typ = GetType(OpCode)
10040
10025
ReDim Preserve typ256(UBound(typ256) + 1)
10041
10026
typ256(UBound(typ256)) = Typ
10042
EmitCneqIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ256))
10027
EmitNorIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ256))
10043
10028
Typ = Typ03.GetMethod("Emit", typ256).ReturnType
10044
10029
If Typ.ToString() = GetType(System.Void).ToString() Then
10045
10030
10046
10031
Else
10047
EmitCneqIL.Emit(OpCodes.Pop)
10032
EmitNorIL.Emit(OpCodes.Pop)
10048
10033
End If
10049
EmitCneqIL.MarkSequencePoint(doc3, 735, 1, 735, 100)
10034
EmitNorIL.MarkSequencePoint(doc3, 726, 1, 726, 100)
10035
EmitNorIL.Emit(OpCodes.Ret)
10036
Dim EmitXnor As MethodBuilder = ILEmitter.DefineMethod("EmitXnor", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), Type.EmptyTypes)
10037
Dim EmitXnorIL As ILGenerator = EmitXnor.GetILGenerator()
10038
EmitXnorIL.MarkSequencePoint(doc3, 729, 1, 729, 100)
10039
Dim locbldr39 As LocalBuilder = EmitXnorIL.DeclareLocal(GetType(OpCode))
10040
locbldr39.SetLocalSymInfo("op")
10041
EmitXnorIL.MarkSequencePoint(doc3, 730, 1, 730, 100)
10050
10042
Dim typ257(-1) As Type
10051
EmitCneqIL.Emit(OpCodes.Ldstr, "not")
10043
EmitXnorIL.Emit(OpCodes.Ldstr, "xor")
10052
10044
Typ = GetType(System.String)
10053
10045
ReDim Preserve typ257(UBound(typ257) + 1)
10054
10046
typ257(UBound(typ257)) = Typ
10055
EmitCneqIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ257))
10047
EmitXnorIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ257))
10056
10048
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ257).ReturnType
10057
EmitCneqIL.Emit(OpCodes.Stloc, 0)
10058
EmitCneqIL.MarkSequencePoint(doc3, 736, 1, 736, 100)
10049
EmitXnorIL.Emit(OpCodes.Stloc, 0)
10050
EmitXnorIL.MarkSequencePoint(doc3, 731, 1, 731, 100)
10059
10051
Dim typ258(-1) As Type
10060
EmitCneqIL.Emit(OpCodes.Ldsfld, ILGen)
10052
EmitXnorIL.Emit(OpCodes.Ldsfld, ILGen)
10061
10053
Typ = ILGen.FieldType
10062
10054
Typ03 = Typ
10063
EmitCneqIL.Emit(OpCodes.Ldloc, 0)
10055
EmitXnorIL.Emit(OpCodes.Ldloc, 0)
10064
10056
Typ = GetType(OpCode)
10065
10057
ReDim Preserve typ258(UBound(typ258) + 1)
10066
10058
typ258(UBound(typ258)) = Typ
10067
EmitCneqIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ258))
10059
EmitXnorIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ258))
10068
10060
Typ = Typ03.GetMethod("Emit", typ258).ReturnType
10069
10061
If Typ.ToString() = GetType(System.Void).ToString() Then
10070
10062
10071
10063
Else
10072
EmitCneqIL.Emit(OpCodes.Pop)
10064
EmitXnorIL.Emit(OpCodes.Pop)
10073
10065
End If
10074
EmitCneqIL.MarkSequencePoint(doc3, 737, 1, 737, 100)
10075
EmitCneqIL.Emit(OpCodes.Ret)
10066
EmitXnorIL.MarkSequencePoint(doc3, 732, 1, 732, 100)
10076
10067
Dim typ259(-1) As Type
10068
EmitXnorIL.Emit(OpCodes.Ldstr, "not")
10069
Typ = GetType(System.String)
10077
10070
ReDim Preserve typ259(UBound(typ259) + 1)
10078
typ259(UBound(typ259)) = GetType(System.Boolean)
10079
Dim EmitCgt As MethodBuilder = ILEmitter.DefineMethod("EmitCgt", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ259)
10080
Dim EmitCgtIL As ILGenerator = EmitCgt.GetILGenerator()
10081
Dim EmitCgtparam01 As ParameterBuilder = EmitCgt.DefineParameter(1, ParameterAttributes.None, "s")
10082
EmitCgtIL.MarkSequencePoint(doc3, 740, 1, 740, 100)
10083
Dim locbldr41 As LocalBuilder = EmitCgtIL.DeclareLocal(GetType(OpCode))
10084
locbldr41.SetLocalSymInfo("op")
10085
EmitCgtIL.MarkSequencePoint(doc3, 741, 1, 741, 100)
10086
EmitCgtIL.Emit(OpCodes.Ldarg, 0)
10087
Typ = GetType(System.Boolean)
10088
EmitCgtIL.Emit(OpCodes.Ldc_I4, 1)
10089
Typ = GetType(System.Boolean)
10090
Dim fa221 As System.Reflection.Emit.Label = EmitCgtIL.DefineLabel()
10091
Dim tru221 As System.Reflection.Emit.Label = EmitCgtIL.DefineLabel()
10092
Dim cont221 As System.Reflection.Emit.Label = EmitCgtIL.DefineLabel()
10093
EmitCgtIL.Emit(OpCodes.Beq, tru221)
10094
EmitCgtIL.Emit(OpCodes.Br, fa221)
10095
EmitCgtIL.MarkLabel(tru221)
10096
EmitCgtIL.MarkSequencePoint(doc3, 742, 1, 742, 100)
10071
typ259(UBound(typ259)) = Typ
10072
EmitXnorIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ259))
10073
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ259).ReturnType
10074
EmitXnorIL.Emit(OpCodes.Stloc, 0)
10075
EmitXnorIL.MarkSequencePoint(doc3, 733, 1, 733, 100)
10097
10076
Dim typ260(-1) As Type
10098
EmitCgtIL.Emit(OpCodes.Ldstr, "cgt")
10099
Typ = GetType(System.String)
10077
EmitXnorIL.Emit(OpCodes.Ldsfld, ILGen)
10078
Typ = ILGen.FieldType
10079
Typ03 = Typ
10080
EmitXnorIL.Emit(OpCodes.Ldloc, 0)
10081
Typ = GetType(OpCode)
10100
10082
ReDim Preserve typ260(UBound(typ260) + 1)
10101
10083
typ260(UBound(typ260)) = Typ
10102
EmitCgtIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ260))
10103
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ260).ReturnType
10104
EmitCgtIL.Emit(OpCodes.Stloc, 0)
10105
EmitCgtIL.MarkSequencePoint(doc3, 743, 1, 743, 100)
10084
EmitXnorIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ260))
10085
Typ = Typ03.GetMethod("Emit", typ260).ReturnType
10086
If Typ.ToString() = GetType(System.Void).ToString() Then
10087
10088
Else
10089
EmitXnorIL.Emit(OpCodes.Pop)
10090
End If
10091
EmitXnorIL.MarkSequencePoint(doc3, 734, 1, 734, 100)
10092
EmitXnorIL.Emit(OpCodes.Ret)
10093
Dim EmitCeq As MethodBuilder = ILEmitter.DefineMethod("EmitCeq", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), Type.EmptyTypes)
10094
Dim EmitCeqIL As ILGenerator = EmitCeq.GetILGenerator()
10095
EmitCeqIL.MarkSequencePoint(doc3, 737, 1, 737, 100)
10096
Dim locbldr40 As LocalBuilder = EmitCeqIL.DeclareLocal(GetType(OpCode))
10097
locbldr40.SetLocalSymInfo("op")
10098
EmitCeqIL.MarkSequencePoint(doc3, 738, 1, 738, 100)
10106
10099
Dim typ261(-1) As Type
10107
EmitCgtIL.Emit(OpCodes.Ldsfld, ILGen)
10108
Typ = ILGen.FieldType
10109
Typ03 = Typ
10110
EmitCgtIL.Emit(OpCodes.Ldloc, 0)
10111
Typ = GetType(OpCode)
10100
EmitCeqIL.Emit(OpCodes.Ldstr, "ceq")
10101
Typ = GetType(System.String)
10112
10102
ReDim Preserve typ261(UBound(typ261) + 1)
10113
10103
typ261(UBound(typ261)) = Typ
10114
EmitCgtIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ261))
10115
Typ = Typ03.GetMethod("Emit", typ261).ReturnType
10116
If Typ.ToString() = GetType(System.Void).ToString() Then
10117
10118
Else
10119
EmitCgtIL.Emit(OpCodes.Pop)
10120
End If
10121
EmitCgtIL.MarkSequencePoint(doc3, 744, 1, 744, 100)
10122
EmitCgtIL.Emit(OpCodes.Br, cont221)
10123
EmitCgtIL.MarkLabel(fa221)
10124
EmitCgtIL.MarkSequencePoint(doc3, 745, 1, 745, 100)
10104
EmitCeqIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ261))
10105
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ261).ReturnType
10106
EmitCeqIL.Emit(OpCodes.Stloc, 0)
10107
EmitCeqIL.MarkSequencePoint(doc3, 739, 1, 739, 100)
10125
10108
Dim typ262(-1) As Type
10126
EmitCgtIL.Emit(OpCodes.Ldstr, "cgt.un")
10127
Typ = GetType(System.String)
10109
EmitCeqIL.Emit(OpCodes.Ldsfld, ILGen)
10110
Typ = ILGen.FieldType
10111
Typ03 = Typ
10112
EmitCeqIL.Emit(OpCodes.Ldloc, 0)
10113
Typ = GetType(OpCode)
10128
10114
ReDim Preserve typ262(UBound(typ262) + 1)
10129
10115
typ262(UBound(typ262)) = Typ
10130
EmitCgtIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ262))
10131
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ262).ReturnType
10132
EmitCgtIL.Emit(OpCodes.Stloc, 0)
10133
EmitCgtIL.MarkSequencePoint(doc3, 746, 1, 746, 100)
10116
EmitCeqIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ262))
10117
Typ = Typ03.GetMethod("Emit", typ262).ReturnType
10118
If Typ.ToString() = GetType(System.Void).ToString() Then
10119
10120
Else
10121
EmitCeqIL.Emit(OpCodes.Pop)
10122
End If
10123
EmitCeqIL.MarkSequencePoint(doc3, 740, 1, 740, 100)
10124
EmitCeqIL.Emit(OpCodes.Ret)
10125
Dim EmitCneq As MethodBuilder = ILEmitter.DefineMethod("EmitCneq", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), Type.EmptyTypes)
10126
Dim EmitCneqIL As ILGenerator = EmitCneq.GetILGenerator()
10127
EmitCneqIL.MarkSequencePoint(doc3, 743, 1, 743, 100)
10128
Dim locbldr41 As LocalBuilder = EmitCneqIL.DeclareLocal(GetType(OpCode))
10129
locbldr41.SetLocalSymInfo("op")
10130
EmitCneqIL.MarkSequencePoint(doc3, 744, 1, 744, 100)
10134
10131
Dim typ263(-1) As Type
10135
EmitCgtIL.Emit(OpCodes.Ldsfld, ILGen)
10136
Typ = ILGen.FieldType
10137
Typ03 = Typ
10138
EmitCgtIL.Emit(OpCodes.Ldloc, 0)
10139
Typ = GetType(OpCode)
10132
EmitCneqIL.Emit(OpCodes.Ldstr, "ceq")
10133
Typ = GetType(System.String)
10140
10134
ReDim Preserve typ263(UBound(typ263) + 1)
10141
10135
typ263(UBound(typ263)) = Typ
10142
EmitCgtIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ263))
10143
Typ = Typ03.GetMethod("Emit", typ263).ReturnType
10144
If Typ.ToString() = GetType(System.Void).ToString() Then
10145
10146
Else
10147
EmitCgtIL.Emit(OpCodes.Pop)
10148
End If
10149
EmitCgtIL.MarkSequencePoint(doc3, 747, 1, 747, 100)
10150
EmitCgtIL.Emit(OpCodes.Br, cont221)
10151
EmitCgtIL.MarkLabel(cont221)
10152
EmitCgtIL.MarkSequencePoint(doc3, 748, 1, 748, 100)
10153
EmitCgtIL.Emit(OpCodes.Ret)
10136
EmitCneqIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ263))
10137
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ263).ReturnType
10138
EmitCneqIL.Emit(OpCodes.Stloc, 0)
10139
EmitCneqIL.MarkSequencePoint(doc3, 745, 1, 745, 100)
10154
10140
Dim typ264(-1) As Type
10141
EmitCneqIL.Emit(OpCodes.Ldsfld, ILGen)
10142
Typ = ILGen.FieldType
10143
Typ03 = Typ
10144
EmitCneqIL.Emit(OpCodes.Ldloc, 0)
10145
Typ = GetType(OpCode)
10155
10146
ReDim Preserve typ264(UBound(typ264) + 1)
10156
typ264(UBound(typ264)) = GetType(System.Boolean)
10157
Dim EmitClt As MethodBuilder = ILEmitter.DefineMethod("EmitClt", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ264)
10158
Dim EmitCltIL As ILGenerator = EmitClt.GetILGenerator()
10159
Dim EmitCltparam01 As ParameterBuilder = EmitClt.DefineParameter(1, ParameterAttributes.None, "s")
10160
EmitCltIL.MarkSequencePoint(doc3, 751, 1, 751, 100)
10161
Dim locbldr42 As LocalBuilder = EmitCltIL.DeclareLocal(GetType(OpCode))
10162
locbldr42.SetLocalSymInfo("op")
10163
EmitCltIL.MarkSequencePoint(doc3, 752, 1, 752, 100)
10164
EmitCltIL.Emit(OpCodes.Ldarg, 0)
10165
Typ = GetType(System.Boolean)
10166
EmitCltIL.Emit(OpCodes.Ldc_I4, 1)
10167
Typ = GetType(System.Boolean)
10168
Dim fa222 As System.Reflection.Emit.Label = EmitCltIL.DefineLabel()
10169
Dim tru222 As System.Reflection.Emit.Label = EmitCltIL.DefineLabel()
10170
Dim cont222 As System.Reflection.Emit.Label = EmitCltIL.DefineLabel()
10171
EmitCltIL.Emit(OpCodes.Beq, tru222)
10172
EmitCltIL.Emit(OpCodes.Br, fa222)
10173
EmitCltIL.MarkLabel(tru222)
10174
EmitCltIL.MarkSequencePoint(doc3, 753, 1, 753, 100)
10147
typ264(UBound(typ264)) = Typ
10148
EmitCneqIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ264))
10149
Typ = Typ03.GetMethod("Emit", typ264).ReturnType
10150
If Typ.ToString() = GetType(System.Void).ToString() Then
10151
10152
Else
10153
EmitCneqIL.Emit(OpCodes.Pop)
10154
End If
10155
EmitCneqIL.MarkSequencePoint(doc3, 746, 1, 746, 100)
10175
10156
Dim typ265(-1) As Type
10176
EmitCltIL.Emit(OpCodes.Ldstr, "clt")
10157
EmitCneqIL.Emit(OpCodes.Ldstr, "ldc.i4.0")
10177
10158
Typ = GetType(System.String)
10178
10159
ReDim Preserve typ265(UBound(typ265) + 1)
10179
10160
typ265(UBound(typ265)) = Typ
10180
EmitCltIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ265))
10161
EmitCneqIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ265))
10181
10162
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ265).ReturnType
10182
EmitCltIL.Emit(OpCodes.Stloc, 0)
10183
EmitCltIL.MarkSequencePoint(doc3, 754, 1, 754, 100)
10163
EmitCneqIL.Emit(OpCodes.Stloc, 0)
10164
EmitCneqIL.MarkSequencePoint(doc3, 747, 1, 747, 100)
10184
10165
Dim typ266(-1) As Type
10185
EmitCltIL.Emit(OpCodes.Ldsfld, ILGen)
10166
EmitCneqIL.Emit(OpCodes.Ldsfld, ILGen)
10186
10167
Typ = ILGen.FieldType
10187
10168
Typ03 = Typ
10188
EmitCltIL.Emit(OpCodes.Ldloc, 0)
10169
EmitCneqIL.Emit(OpCodes.Ldloc, 0)
10189
10170
Typ = GetType(OpCode)
10190
10171
ReDim Preserve typ266(UBound(typ266) + 1)
10191
10172
typ266(UBound(typ266)) = Typ
10192
EmitCltIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ266))
10173
EmitCneqIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ266))
10193
10174
Typ = Typ03.GetMethod("Emit", typ266).ReturnType
10194
10175
If Typ.ToString() = GetType(System.Void).ToString() Then
10195
10176
10196
10177
Else
10197
EmitCltIL.Emit(OpCodes.Pop)
10178
EmitCneqIL.Emit(OpCodes.Pop)
10198
10179
End If
10199
EmitCltIL.MarkSequencePoint(doc3, 755, 1, 755, 100)
10200
EmitCltIL.Emit(OpCodes.Br, cont222)
10201
EmitCltIL.MarkLabel(fa222)
10202
EmitCltIL.MarkSequencePoint(doc3, 756, 1, 756, 100)
10180
EmitCneqIL.MarkSequencePoint(doc3, 748, 1, 748, 100)
10203
10181
Dim typ267(-1) As Type
10204
EmitCltIL.Emit(OpCodes.Ldstr, "clt.un")
10182
EmitCneqIL.Emit(OpCodes.Ldstr, "ceq")
10205
10183
Typ = GetType(System.String)
10206
10184
ReDim Preserve typ267(UBound(typ267) + 1)
10207
10185
typ267(UBound(typ267)) = Typ
10208
EmitCltIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ267))
10186
EmitCneqIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ267))
10209
10187
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ267).ReturnType
10210
EmitCltIL.Emit(OpCodes.Stloc, 0)
10211
EmitCltIL.MarkSequencePoint(doc3, 757, 1, 757, 100)
10188
EmitCneqIL.Emit(OpCodes.Stloc, 0)
10189
EmitCneqIL.MarkSequencePoint(doc3, 749, 1, 749, 100)
10212
10190
Dim typ268(-1) As Type
10213
EmitCltIL.Emit(OpCodes.Ldsfld, ILGen)
10191
EmitCneqIL.Emit(OpCodes.Ldsfld, ILGen)
10214
10192
Typ = ILGen.FieldType
10215
10193
Typ03 = Typ
10216
EmitCltIL.Emit(OpCodes.Ldloc, 0)
10194
EmitCneqIL.Emit(OpCodes.Ldloc, 0)
10217
10195
Typ = GetType(OpCode)
10218
10196
ReDim Preserve typ268(UBound(typ268) + 1)
10219
10197
typ268(UBound(typ268)) = Typ
10220
EmitCltIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ268))
10198
EmitCneqIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ268))
10221
10199
Typ = Typ03.GetMethod("Emit", typ268).ReturnType
10222
10200
If Typ.ToString() = GetType(System.Void).ToString() Then
10223
10201
10224
10202
Else
10225
EmitCltIL.Emit(OpCodes.Pop)
10203
EmitCneqIL.Emit(OpCodes.Pop)
10226
10204
End If
10227
EmitCltIL.MarkSequencePoint(doc3, 758, 1, 758, 100)
10228
EmitCltIL.Emit(OpCodes.Br, cont222)
10229
EmitCltIL.MarkLabel(cont222)
10230
EmitCltIL.MarkSequencePoint(doc3, 759, 1, 759, 100)
10231
EmitCltIL.Emit(OpCodes.Ret)
10205
EmitCneqIL.MarkSequencePoint(doc3, 750, 1, 750, 100)
10206
EmitCneqIL.Emit(OpCodes.Ret)
10232
10207
Dim typ269(-1) As Type
10233
10208
ReDim Preserve typ269(UBound(typ269) + 1)
10234
10209
typ269(UBound(typ269)) = GetType(System.Boolean)
10235
Dim EmitCle As MethodBuilder = ILEmitter.DefineMethod("EmitCle", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ269)
10236
Dim EmitCleIL As ILGenerator = EmitCle.GetILGenerator()
10237
Dim EmitCleparam01 As ParameterBuilder = EmitCle.DefineParameter(1, ParameterAttributes.None, "s")
10238
EmitCleIL.MarkSequencePoint(doc3, 762, 1, 762, 100)
10239
Dim locbldr43 As LocalBuilder = EmitCleIL.DeclareLocal(GetType(OpCode))
10240
locbldr43.SetLocalSymInfo("op")
10241
EmitCleIL.MarkSequencePoint(doc3, 763, 1, 763, 100)
10242
EmitCleIL.Emit(OpCodes.Ldarg, 0)
10243
Typ = GetType(System.Boolean)
10244
EmitCleIL.Emit(OpCodes.Ldc_I4, 1)
10245
Typ = GetType(System.Boolean)
10246
Dim fa223 As System.Reflection.Emit.Label = EmitCleIL.DefineLabel()
10247
Dim tru223 As System.Reflection.Emit.Label = EmitCleIL.DefineLabel()
10248
Dim cont223 As System.Reflection.Emit.Label = EmitCleIL.DefineLabel()
10249
EmitCleIL.Emit(OpCodes.Beq, tru223)
10250
EmitCleIL.Emit(OpCodes.Br, fa223)
10251
EmitCleIL.MarkLabel(tru223)
10252
EmitCleIL.MarkSequencePoint(doc3, 764, 1, 764, 100)
10210
Dim EmitCgt As MethodBuilder = ILEmitter.DefineMethod("EmitCgt", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ269)
10211
Dim EmitCgtIL As ILGenerator = EmitCgt.GetILGenerator()
10212
Dim EmitCgtparam01 As ParameterBuilder = EmitCgt.DefineParameter(1, ParameterAttributes.None, "s")
10213
EmitCgtIL.MarkSequencePoint(doc3, 753, 1, 753, 100)
10214
Dim locbldr42 As LocalBuilder = EmitCgtIL.DeclareLocal(GetType(OpCode))
10215
locbldr42.SetLocalSymInfo("op")
10216
EmitCgtIL.MarkSequencePoint(doc3, 754, 1, 754, 100)
10217
EmitCgtIL.Emit(OpCodes.Ldarg, 0)
10218
Typ = GetType(System.Boolean)
10219
EmitCgtIL.Emit(OpCodes.Ldc_I4, 1)
10220
Typ = GetType(System.Boolean)
10221
Dim fa221 As System.Reflection.Emit.Label = EmitCgtIL.DefineLabel()
10222
Dim tru221 As System.Reflection.Emit.Label = EmitCgtIL.DefineLabel()
10223
Dim cont221 As System.Reflection.Emit.Label = EmitCgtIL.DefineLabel()
10224
EmitCgtIL.Emit(OpCodes.Beq, tru221)
10225
EmitCgtIL.Emit(OpCodes.Br, fa221)
10226
EmitCgtIL.MarkLabel(tru221)
10227
EmitCgtIL.MarkSequencePoint(doc3, 755, 1, 755, 100)
10253
10228
Dim typ270(-1) As Type
10254
EmitCleIL.Emit(OpCodes.Ldstr, "cgt")
10229
EmitCgtIL.Emit(OpCodes.Ldstr, "cgt")
10255
10230
Typ = GetType(System.String)
10256
10231
ReDim Preserve typ270(UBound(typ270) + 1)
10257
10232
typ270(UBound(typ270)) = Typ
10258
EmitCleIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ270))
10233
EmitCgtIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ270))
10259
10234
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ270).ReturnType
10260
EmitCleIL.Emit(OpCodes.Stloc, 0)
10261
EmitCleIL.MarkSequencePoint(doc3, 765, 1, 765, 100)
10235
EmitCgtIL.Emit(OpCodes.Stloc, 0)
10236
EmitCgtIL.MarkSequencePoint(doc3, 756, 1, 756, 100)
10262
10237
Dim typ271(-1) As Type
10263
EmitCleIL.Emit(OpCodes.Ldsfld, ILGen)
10238
EmitCgtIL.Emit(OpCodes.Ldsfld, ILGen)
10264
10239
Typ = ILGen.FieldType
10265
10240
Typ03 = Typ
10266
EmitCleIL.Emit(OpCodes.Ldloc, 0)
10241
EmitCgtIL.Emit(OpCodes.Ldloc, 0)
10267
10242
Typ = GetType(OpCode)
10268
10243
ReDim Preserve typ271(UBound(typ271) + 1)
10269
10244
typ271(UBound(typ271)) = Typ
10270
EmitCleIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ271))
10245
EmitCgtIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ271))
10271
10246
Typ = Typ03.GetMethod("Emit", typ271).ReturnType
10272
10247
If Typ.ToString() = GetType(System.Void).ToString() Then
10273
10248
10274
10249
Else
10275
EmitCleIL.Emit(OpCodes.Pop)
10250
EmitCgtIL.Emit(OpCodes.Pop)
10276
10251
End If
10277
EmitCleIL.MarkSequencePoint(doc3, 766, 1, 766, 100)
10278
EmitCleIL.Emit(OpCodes.Br, cont223)
10279
EmitCleIL.MarkLabel(fa223)
10280
EmitCleIL.MarkSequencePoint(doc3, 767, 1, 767, 100)
10252
EmitCgtIL.MarkSequencePoint(doc3, 757, 1, 757, 100)
10253
EmitCgtIL.Emit(OpCodes.Br, cont221)
10254
EmitCgtIL.MarkLabel(fa221)
10255
EmitCgtIL.MarkSequencePoint(doc3, 758, 1, 758, 100)
10281
10256
Dim typ272(-1) As Type
10282
EmitCleIL.Emit(OpCodes.Ldstr, "cgt.un")
10257
EmitCgtIL.Emit(OpCodes.Ldstr, "cgt.un")
10283
10258
Typ = GetType(System.String)
10284
10259
ReDim Preserve typ272(UBound(typ272) + 1)
10285
10260
typ272(UBound(typ272)) = Typ
10286
EmitCleIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ272))
10261
EmitCgtIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ272))
10287
10262
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ272).ReturnType
10288
EmitCleIL.Emit(OpCodes.Stloc, 0)
10289
EmitCleIL.MarkSequencePoint(doc3, 768, 1, 768, 100)
10263
EmitCgtIL.Emit(OpCodes.Stloc, 0)
10264
EmitCgtIL.MarkSequencePoint(doc3, 759, 1, 759, 100)
10290
10265
Dim typ273(-1) As Type
10291
EmitCleIL.Emit(OpCodes.Ldsfld, ILGen)
10266
EmitCgtIL.Emit(OpCodes.Ldsfld, ILGen)
10292
10267
Typ = ILGen.FieldType
10293
10268
Typ03 = Typ
10294
EmitCleIL.Emit(OpCodes.Ldloc, 0)
10269
EmitCgtIL.Emit(OpCodes.Ldloc, 0)
10295
10270
Typ = GetType(OpCode)
10296
10271
ReDim Preserve typ273(UBound(typ273) + 1)
10297
10272
typ273(UBound(typ273)) = Typ
10298
EmitCleIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ273))
10273
EmitCgtIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ273))
10299
10274
Typ = Typ03.GetMethod("Emit", typ273).ReturnType
10300
10275
If Typ.ToString() = GetType(System.Void).ToString() Then
10301
10276
10302
10277
Else
10303
EmitCleIL.Emit(OpCodes.Pop)
10278
EmitCgtIL.Emit(OpCodes.Pop)
10304
10279
End If
10305
EmitCleIL.MarkSequencePoint(doc3, 769, 1, 769, 100)
10306
EmitCleIL.Emit(OpCodes.Br, cont223)
10307
EmitCleIL.MarkLabel(cont223)
10308
EmitCleIL.MarkSequencePoint(doc3, 770, 1, 770, 100)
10280
EmitCgtIL.MarkSequencePoint(doc3, 760, 1, 760, 100)
10281
EmitCgtIL.Emit(OpCodes.Br, cont221)
10282
EmitCgtIL.MarkLabel(cont221)
10283
EmitCgtIL.MarkSequencePoint(doc3, 761, 1, 761, 100)
10284
EmitCgtIL.Emit(OpCodes.Ret)
10309
10285
Dim typ274(-1) As Type
10310
EmitCleIL.Emit(OpCodes.Ldstr, "not")
10311
Typ = GetType(System.String)
10312
10286
ReDim Preserve typ274(UBound(typ274) + 1)
10313
typ274(UBound(typ274)) = Typ
10314
EmitCleIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ274))
10315
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ274).ReturnType
10316
EmitCleIL.Emit(OpCodes.Stloc, 0)
10317
EmitCleIL.MarkSequencePoint(doc3, 771, 1, 771, 100)
10287
typ274(UBound(typ274)) = GetType(System.Boolean)
10288
Dim EmitClt As MethodBuilder = ILEmitter.DefineMethod("EmitClt", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ274)
10289
Dim EmitCltIL As ILGenerator = EmitClt.GetILGenerator()
10290
Dim EmitCltparam01 As ParameterBuilder = EmitClt.DefineParameter(1, ParameterAttributes.None, "s")
10291
EmitCltIL.MarkSequencePoint(doc3, 764, 1, 764, 100)
10292
Dim locbldr43 As LocalBuilder = EmitCltIL.DeclareLocal(GetType(OpCode))
10293
locbldr43.SetLocalSymInfo("op")
10294
EmitCltIL.MarkSequencePoint(doc3, 765, 1, 765, 100)
10295
EmitCltIL.Emit(OpCodes.Ldarg, 0)
10296
Typ = GetType(System.Boolean)
10297
EmitCltIL.Emit(OpCodes.Ldc_I4, 1)
10298
Typ = GetType(System.Boolean)
10299
Dim fa222 As System.Reflection.Emit.Label = EmitCltIL.DefineLabel()
10300
Dim tru222 As System.Reflection.Emit.Label = EmitCltIL.DefineLabel()
10301
Dim cont222 As System.Reflection.Emit.Label = EmitCltIL.DefineLabel()
10302
EmitCltIL.Emit(OpCodes.Beq, tru222)
10303
EmitCltIL.Emit(OpCodes.Br, fa222)
10304
EmitCltIL.MarkLabel(tru222)
10305
EmitCltIL.MarkSequencePoint(doc3, 766, 1, 766, 100)
10318
10306
Dim typ275(-1) As Type
10319
EmitCleIL.Emit(OpCodes.Ldsfld, ILGen)
10320
Typ = ILGen.FieldType
10321
Typ03 = Typ
10322
EmitCleIL.Emit(OpCodes.Ldloc, 0)
10323
Typ = GetType(OpCode)
10307
EmitCltIL.Emit(OpCodes.Ldstr, "clt")
10308
Typ = GetType(System.String)
10324
10309
ReDim Preserve typ275(UBound(typ275) + 1)
10325
10310
typ275(UBound(typ275)) = Typ
10326
EmitCleIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ275))
10327
Typ = Typ03.GetMethod("Emit", typ275).ReturnType
10328
If Typ.ToString() = GetType(System.Void).ToString() Then
10329
10330
Else
10331
EmitCleIL.Emit(OpCodes.Pop)
10332
End If
10333
EmitCleIL.MarkSequencePoint(doc3, 772, 1, 772, 100)
10334
EmitCleIL.Emit(OpCodes.Ret)
10311
EmitCltIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ275))
10312
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ275).ReturnType
10313
EmitCltIL.Emit(OpCodes.Stloc, 0)
10314
EmitCltIL.MarkSequencePoint(doc3, 767, 1, 767, 100)
10335
10315
Dim typ276(-1) As Type
10316
EmitCltIL.Emit(OpCodes.Ldsfld, ILGen)
10317
Typ = ILGen.FieldType
10318
Typ03 = Typ
10319
EmitCltIL.Emit(OpCodes.Ldloc, 0)
10320
Typ = GetType(OpCode)
10336
10321
ReDim Preserve typ276(UBound(typ276) + 1)
10337
typ276(UBound(typ276)) = GetType(System.Boolean)
10338
Dim EmitCge As MethodBuilder = ILEmitter.DefineMethod("EmitCge", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ276)
10339
Dim EmitCgeIL As ILGenerator = EmitCge.GetILGenerator()
10340
Dim EmitCgeparam01 As ParameterBuilder = EmitCge.DefineParameter(1, ParameterAttributes.None, "s")
10341
EmitCgeIL.MarkSequencePoint(doc3, 775, 1, 775, 100)
10342
Dim locbldr44 As LocalBuilder = EmitCgeIL.DeclareLocal(GetType(OpCode))
10343
locbldr44.SetLocalSymInfo("op")
10344
EmitCgeIL.MarkSequencePoint(doc3, 776, 1, 776, 100)
10345
EmitCgeIL.Emit(OpCodes.Ldarg, 0)
10346
Typ = GetType(System.Boolean)
10347
EmitCgeIL.Emit(OpCodes.Ldc_I4, 1)
10348
Typ = GetType(System.Boolean)
10349
Dim fa224 As System.Reflection.Emit.Label = EmitCgeIL.DefineLabel()
10350
Dim tru224 As System.Reflection.Emit.Label = EmitCgeIL.DefineLabel()
10351
Dim cont224 As System.Reflection.Emit.Label = EmitCgeIL.DefineLabel()
10352
EmitCgeIL.Emit(OpCodes.Beq, tru224)
10353
EmitCgeIL.Emit(OpCodes.Br, fa224)
10354
EmitCgeIL.MarkLabel(tru224)
10355
EmitCgeIL.MarkSequencePoint(doc3, 777, 1, 777, 100)
10322
typ276(UBound(typ276)) = Typ
10323
EmitCltIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ276))
10324
Typ = Typ03.GetMethod("Emit", typ276).ReturnType
10325
If Typ.ToString() = GetType(System.Void).ToString() Then
10326
10327
Else
10328
EmitCltIL.Emit(OpCodes.Pop)
10329
End If
10330
EmitCltIL.MarkSequencePoint(doc3, 768, 1, 768, 100)
10331
EmitCltIL.Emit(OpCodes.Br, cont222)
10332
EmitCltIL.MarkLabel(fa222)
10333
EmitCltIL.MarkSequencePoint(doc3, 769, 1, 769, 100)
10356
10334
Dim typ277(-1) As Type
10357
EmitCgeIL.Emit(OpCodes.Ldstr, "clt")
10335
EmitCltIL.Emit(OpCodes.Ldstr, "clt.un")
10358
10336
Typ = GetType(System.String)
10359
10337
ReDim Preserve typ277(UBound(typ277) + 1)
10360
10338
typ277(UBound(typ277)) = Typ
10361
EmitCgeIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ277))
10339
EmitCltIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ277))
10362
10340
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ277).ReturnType
10363
EmitCgeIL.Emit(OpCodes.Stloc, 0)
10364
EmitCgeIL.MarkSequencePoint(doc3, 778, 1, 778, 100)
10341
EmitCltIL.Emit(OpCodes.Stloc, 0)
10342
EmitCltIL.MarkSequencePoint(doc3, 770, 1, 770, 100)
10365
10343
Dim typ278(-1) As Type
10366
EmitCgeIL.Emit(OpCodes.Ldsfld, ILGen)
10344
EmitCltIL.Emit(OpCodes.Ldsfld, ILGen)
10367
10345
Typ = ILGen.FieldType
10368
10346
Typ03 = Typ
10369
EmitCgeIL.Emit(OpCodes.Ldloc, 0)
10347
EmitCltIL.Emit(OpCodes.Ldloc, 0)
10370
10348
Typ = GetType(OpCode)
10371
10349
ReDim Preserve typ278(UBound(typ278) + 1)
10372
10350
typ278(UBound(typ278)) = Typ
10373
EmitCgeIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ278))
10351
EmitCltIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ278))
10374
10352
Typ = Typ03.GetMethod("Emit", typ278).ReturnType
10375
10353
If Typ.ToString() = GetType(System.Void).ToString() Then
10376
10354
10377
10355
Else
10378
EmitCgeIL.Emit(OpCodes.Pop)
10356
EmitCltIL.Emit(OpCodes.Pop)
10379
10357
End If
10380
EmitCgeIL.MarkSequencePoint(doc3, 779, 1, 779, 100)
10381
EmitCgeIL.Emit(OpCodes.Br, cont224)
10382
EmitCgeIL.MarkLabel(fa224)
10383
EmitCgeIL.MarkSequencePoint(doc3, 780, 1, 780, 100)
10358
EmitCltIL.MarkSequencePoint(doc3, 771, 1, 771, 100)
10359
EmitCltIL.Emit(OpCodes.Br, cont222)
10360
EmitCltIL.MarkLabel(cont222)
10361
EmitCltIL.MarkSequencePoint(doc3, 772, 1, 772, 100)
10362
EmitCltIL.Emit(OpCodes.Ret)
10384
10363
Dim typ279(-1) As Type
10385
EmitCgeIL.Emit(OpCodes.Ldstr, "clt.un")
10386
Typ = GetType(System.String)
10387
10364
ReDim Preserve typ279(UBound(typ279) + 1)
10388
typ279(UBound(typ279)) = Typ
10389
EmitCgeIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ279))
10390
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ279).ReturnType
10391
EmitCgeIL.Emit(OpCodes.Stloc, 0)
10392
EmitCgeIL.MarkSequencePoint(doc3, 781, 1, 781, 100)
10365
typ279(UBound(typ279)) = GetType(System.Boolean)
10366
Dim EmitCle As MethodBuilder = ILEmitter.DefineMethod("EmitCle", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ279)
10367
Dim EmitCleIL As ILGenerator = EmitCle.GetILGenerator()
10368
Dim EmitCleparam01 As ParameterBuilder = EmitCle.DefineParameter(1, ParameterAttributes.None, "s")
10369
EmitCleIL.MarkSequencePoint(doc3, 775, 1, 775, 100)
10370
Dim locbldr44 As LocalBuilder = EmitCleIL.DeclareLocal(GetType(OpCode))
10371
locbldr44.SetLocalSymInfo("op")
10372
EmitCleIL.MarkSequencePoint(doc3, 776, 1, 776, 100)
10373
EmitCleIL.Emit(OpCodes.Ldarg, 0)
10374
Typ = GetType(System.Boolean)
10375
EmitCleIL.Emit(OpCodes.Ldc_I4, 1)
10376
Typ = GetType(System.Boolean)
10377
Dim fa223 As System.Reflection.Emit.Label = EmitCleIL.DefineLabel()
10378
Dim tru223 As System.Reflection.Emit.Label = EmitCleIL.DefineLabel()
10379
Dim cont223 As System.Reflection.Emit.Label = EmitCleIL.DefineLabel()
10380
EmitCleIL.Emit(OpCodes.Beq, tru223)
10381
EmitCleIL.Emit(OpCodes.Br, fa223)
10382
EmitCleIL.MarkLabel(tru223)
10383
EmitCleIL.MarkSequencePoint(doc3, 777, 1, 777, 100)
10393
10384
Dim typ280(-1) As Type
10394
EmitCgeIL.Emit(OpCodes.Ldsfld, ILGen)
10395
Typ = ILGen.FieldType
10396
Typ03 = Typ
10397
EmitCgeIL.Emit(OpCodes.Ldloc, 0)
10398
Typ = GetType(OpCode)
10385
EmitCleIL.Emit(OpCodes.Ldstr, "cgt")
10386
Typ = GetType(System.String)
10399
10387
ReDim Preserve typ280(UBound(typ280) + 1)
10400
10388
typ280(UBound(typ280)) = Typ
10401
EmitCgeIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ280))
10402
Typ = Typ03.GetMethod("Emit", typ280).ReturnType
10403
If Typ.ToString() = GetType(System.Void).ToString() Then
10404
10405
Else
10406
EmitCgeIL.Emit(OpCodes.Pop)
10407
End If
10408
EmitCgeIL.MarkSequencePoint(doc3, 782, 1, 782, 100)
10409
EmitCgeIL.Emit(OpCodes.Br, cont224)
10410
EmitCgeIL.MarkLabel(cont224)
10411
EmitCgeIL.MarkSequencePoint(doc3, 783, 1, 783, 100)
10389
EmitCleIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ280))
10390
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ280).ReturnType
10391
EmitCleIL.Emit(OpCodes.Stloc, 0)
10392
EmitCleIL.MarkSequencePoint(doc3, 778, 1, 778, 100)
10412
10393
Dim typ281(-1) As Type
10413
EmitCgeIL.Emit(OpCodes.Ldstr, "not")
10414
Typ = GetType(System.String)
10394
EmitCleIL.Emit(OpCodes.Ldsfld, ILGen)
10395
Typ = ILGen.FieldType
10396
Typ03 = Typ
10397
EmitCleIL.Emit(OpCodes.Ldloc, 0)
10398
Typ = GetType(OpCode)
10415
10399
ReDim Preserve typ281(UBound(typ281) + 1)
10416
10400
typ281(UBound(typ281)) = Typ
10417
EmitCgeIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ281))
10418
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ281).ReturnType
10419
EmitCgeIL.Emit(OpCodes.Stloc, 0)
10420
EmitCgeIL.MarkSequencePoint(doc3, 784, 1, 784, 100)
10401
EmitCleIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ281))
10402
Typ = Typ03.GetMethod("Emit", typ281).ReturnType
10403
If Typ.ToString() = GetType(System.Void).ToString() Then
10404
10405
Else
10406
EmitCleIL.Emit(OpCodes.Pop)
10407
End If
10408
EmitCleIL.MarkSequencePoint(doc3, 779, 1, 779, 100)
10409
EmitCleIL.Emit(OpCodes.Br, cont223)
10410
EmitCleIL.MarkLabel(fa223)
10411
EmitCleIL.MarkSequencePoint(doc3, 780, 1, 780, 100)
10421
10412
Dim typ282(-1) As Type
10422
EmitCgeIL.Emit(OpCodes.Ldsfld, ILGen)
10423
Typ = ILGen.FieldType
10424
Typ03 = Typ
10425
EmitCgeIL.Emit(OpCodes.Ldloc, 0)
10426
Typ = GetType(OpCode)
10413
EmitCleIL.Emit(OpCodes.Ldstr, "cgt.un")
10414
Typ = GetType(System.String)
10427
10415
ReDim Preserve typ282(UBound(typ282) + 1)
10428
10416
typ282(UBound(typ282)) = Typ
10429
EmitCgeIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ282))
10430
Typ = Typ03.GetMethod("Emit", typ282).ReturnType
10431
If Typ.ToString() = GetType(System.Void).ToString() Then
10432
10433
Else
10434
EmitCgeIL.Emit(OpCodes.Pop)
10435
End If
10436
EmitCgeIL.MarkSequencePoint(doc3, 785, 1, 785, 100)
10417
EmitCleIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ282))
10418
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ282).ReturnType
10419
EmitCleIL.Emit(OpCodes.Stloc, 0)
10420
EmitCleIL.MarkSequencePoint(doc3, 781, 1, 781, 100)
10421
Dim typ283(-1) As Type
10422
EmitCleIL.Emit(OpCodes.Ldsfld, ILGen)
10423
Typ = ILGen.FieldType
10424
Typ03 = Typ
10425
EmitCleIL.Emit(OpCodes.Ldloc, 0)
10426
Typ = GetType(OpCode)
10427
ReDim Preserve typ283(UBound(typ283) + 1)
10428
typ283(UBound(typ283)) = Typ
10429
EmitCleIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ283))
10430
Typ = Typ03.GetMethod("Emit", typ283).ReturnType
10431
If Typ.ToString() = GetType(System.Void).ToString() Then
10432
10433
Else
10434
EmitCleIL.Emit(OpCodes.Pop)
10435
End If
10436
EmitCleIL.MarkSequencePoint(doc3, 782, 1, 782, 100)
10437
EmitCleIL.Emit(OpCodes.Br, cont223)
10438
EmitCleIL.MarkLabel(cont223)
10439
EmitCleIL.MarkSequencePoint(doc3, 783, 1, 783, 100)
10440
Dim typ284(-1) As Type
10441
EmitCleIL.Emit(OpCodes.Ldstr, "ldc.i4.0")
10442
Typ = GetType(System.String)
10443
ReDim Preserve typ284(UBound(typ284) + 1)
10444
typ284(UBound(typ284)) = Typ
10445
EmitCleIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ284))
10446
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ284).ReturnType
10447
EmitCleIL.Emit(OpCodes.Stloc, 0)
10448
EmitCleIL.MarkSequencePoint(doc3, 784, 1, 784, 100)
10449
Dim typ285(-1) As Type
10450
EmitCleIL.Emit(OpCodes.Ldsfld, ILGen)
10451
Typ = ILGen.FieldType
10452
Typ03 = Typ
10453
EmitCleIL.Emit(OpCodes.Ldloc, 0)
10454
Typ = GetType(OpCode)
10455
ReDim Preserve typ285(UBound(typ285) + 1)
10456
typ285(UBound(typ285)) = Typ
10457
EmitCleIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ285))
10458
Typ = Typ03.GetMethod("Emit", typ285).ReturnType
10459
If Typ.ToString() = GetType(System.Void).ToString() Then
10460
10461
Else
10462
EmitCleIL.Emit(OpCodes.Pop)
10463
End If
10464
EmitCleIL.MarkSequencePoint(doc3, 785, 1, 785, 100)
10465
Dim typ286(-1) As Type
10466
EmitCleIL.Emit(OpCodes.Ldstr, "ceq")
10467
Typ = GetType(System.String)
10468
ReDim Preserve typ286(UBound(typ286) + 1)
10469
typ286(UBound(typ286)) = Typ
10470
EmitCleIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ286))
10471
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ286).ReturnType
10472
EmitCleIL.Emit(OpCodes.Stloc, 0)
10473
EmitCleIL.MarkSequencePoint(doc3, 786, 1, 786, 100)
10474
Dim typ287(-1) As Type
10475
EmitCleIL.Emit(OpCodes.Ldsfld, ILGen)
10476
Typ = ILGen.FieldType
10477
Typ03 = Typ
10478
EmitCleIL.Emit(OpCodes.Ldloc, 0)
10479
Typ = GetType(OpCode)
10480
ReDim Preserve typ287(UBound(typ287) + 1)
10481
typ287(UBound(typ287)) = Typ
10482
EmitCleIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ287))
10483
Typ = Typ03.GetMethod("Emit", typ287).ReturnType
10484
If Typ.ToString() = GetType(System.Void).ToString() Then
10485
10486
Else
10487
EmitCleIL.Emit(OpCodes.Pop)
10488
End If
10489
EmitCleIL.MarkSequencePoint(doc3, 787, 1, 787, 100)
10490
EmitCleIL.Emit(OpCodes.Ret)
10491
Dim typ288(-1) As Type
10492
ReDim Preserve typ288(UBound(typ288) + 1)
10493
typ288(UBound(typ288)) = GetType(System.Boolean)
10494
Dim EmitCge As MethodBuilder = ILEmitter.DefineMethod("EmitCge", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ288)
10495
Dim EmitCgeIL As ILGenerator = EmitCge.GetILGenerator()
10496
Dim EmitCgeparam01 As ParameterBuilder = EmitCge.DefineParameter(1, ParameterAttributes.None, "s")
10497
EmitCgeIL.MarkSequencePoint(doc3, 790, 1, 790, 100)
10498
Dim locbldr45 As LocalBuilder = EmitCgeIL.DeclareLocal(GetType(OpCode))
10499
locbldr45.SetLocalSymInfo("op")
10500
EmitCgeIL.MarkSequencePoint(doc3, 791, 1, 791, 100)
10501
EmitCgeIL.Emit(OpCodes.Ldarg, 0)
10502
Typ = GetType(System.Boolean)
10503
EmitCgeIL.Emit(OpCodes.Ldc_I4, 1)
10504
Typ = GetType(System.Boolean)
10505
Dim fa224 As System.Reflection.Emit.Label = EmitCgeIL.DefineLabel()
10506
Dim tru224 As System.Reflection.Emit.Label = EmitCgeIL.DefineLabel()
10507
Dim cont224 As System.Reflection.Emit.Label = EmitCgeIL.DefineLabel()
10508
EmitCgeIL.Emit(OpCodes.Beq, tru224)
10509
EmitCgeIL.Emit(OpCodes.Br, fa224)
10510
EmitCgeIL.MarkLabel(tru224)
10511
EmitCgeIL.MarkSequencePoint(doc3, 792, 1, 792, 100)
10512
Dim typ289(-1) As Type
10513
EmitCgeIL.Emit(OpCodes.Ldstr, "clt")
10514
Typ = GetType(System.String)
10515
ReDim Preserve typ289(UBound(typ289) + 1)
10516
typ289(UBound(typ289)) = Typ
10517
EmitCgeIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ289))
10518
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ289).ReturnType
10519
EmitCgeIL.Emit(OpCodes.Stloc, 0)
10520
EmitCgeIL.MarkSequencePoint(doc3, 793, 1, 793, 100)
10521
Dim typ290(-1) As Type
10522
EmitCgeIL.Emit(OpCodes.Ldsfld, ILGen)
10523
Typ = ILGen.FieldType
10524
Typ03 = Typ
10525
EmitCgeIL.Emit(OpCodes.Ldloc, 0)
10526
Typ = GetType(OpCode)
10527
ReDim Preserve typ290(UBound(typ290) + 1)
10528
typ290(UBound(typ290)) = Typ
10529
EmitCgeIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ290))
10530
Typ = Typ03.GetMethod("Emit", typ290).ReturnType
10531
If Typ.ToString() = GetType(System.Void).ToString() Then
10532
10533
Else
10534
EmitCgeIL.Emit(OpCodes.Pop)
10535
End If
10536
EmitCgeIL.MarkSequencePoint(doc3, 794, 1, 794, 100)
10537
EmitCgeIL.Emit(OpCodes.Br, cont224)
10538
EmitCgeIL.MarkLabel(fa224)
10539
EmitCgeIL.MarkSequencePoint(doc3, 795, 1, 795, 100)
10540
Dim typ291(-1) As Type
10541
EmitCgeIL.Emit(OpCodes.Ldstr, "clt.un")
10542
Typ = GetType(System.String)
10543
ReDim Preserve typ291(UBound(typ291) + 1)
10544
typ291(UBound(typ291)) = Typ
10545
EmitCgeIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ291))
10546
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ291).ReturnType
10547
EmitCgeIL.Emit(OpCodes.Stloc, 0)
10548
EmitCgeIL.MarkSequencePoint(doc3, 796, 1, 796, 100)
10549
Dim typ292(-1) As Type
10550
EmitCgeIL.Emit(OpCodes.Ldsfld, ILGen)
10551
Typ = ILGen.FieldType
10552
Typ03 = Typ
10553
EmitCgeIL.Emit(OpCodes.Ldloc, 0)
10554
Typ = GetType(OpCode)
10555
ReDim Preserve typ292(UBound(typ292) + 1)
10556
typ292(UBound(typ292)) = Typ
10557
EmitCgeIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ292))
10558
Typ = Typ03.GetMethod("Emit", typ292).ReturnType
10559
If Typ.ToString() = GetType(System.Void).ToString() Then
10560
10561
Else
10562
EmitCgeIL.Emit(OpCodes.Pop)
10563
End If
10564
EmitCgeIL.MarkSequencePoint(doc3, 797, 1, 797, 100)
10565
EmitCgeIL.Emit(OpCodes.Br, cont224)
10566
EmitCgeIL.MarkLabel(cont224)
10567
EmitCgeIL.MarkSequencePoint(doc3, 798, 1, 798, 100)
10568
Dim typ293(-1) As Type
10569
EmitCgeIL.Emit(OpCodes.Ldstr, "ldc.i4.0")
10570
Typ = GetType(System.String)
10571
ReDim Preserve typ293(UBound(typ293) + 1)
10572
typ293(UBound(typ293)) = Typ
10573
EmitCgeIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ293))
10574
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ293).ReturnType
10575
EmitCgeIL.Emit(OpCodes.Stloc, 0)
10576
EmitCgeIL.MarkSequencePoint(doc3, 799, 1, 799, 100)
10577
Dim typ294(-1) As Type
10578
EmitCgeIL.Emit(OpCodes.Ldsfld, ILGen)
10579
Typ = ILGen.FieldType
10580
Typ03 = Typ
10581
EmitCgeIL.Emit(OpCodes.Ldloc, 0)
10582
Typ = GetType(OpCode)
10583
ReDim Preserve typ294(UBound(typ294) + 1)
10584
typ294(UBound(typ294)) = Typ
10585
EmitCgeIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ294))
10586
Typ = Typ03.GetMethod("Emit", typ294).ReturnType
10587
If Typ.ToString() = GetType(System.Void).ToString() Then
10588
10589
Else
10590
EmitCgeIL.Emit(OpCodes.Pop)
10591
End If
10592
EmitCgeIL.MarkSequencePoint(doc3, 800, 1, 800, 100)
10593
Dim typ295(-1) As Type
10594
EmitCgeIL.Emit(OpCodes.Ldstr, "ceq")
10595
Typ = GetType(System.String)
10596
ReDim Preserve typ295(UBound(typ295) + 1)
10597
typ295(UBound(typ295)) = Typ
10598
EmitCgeIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ295))
10599
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ295).ReturnType
10600
EmitCgeIL.Emit(OpCodes.Stloc, 0)
10601
EmitCgeIL.MarkSequencePoint(doc3, 801, 1, 801, 100)
10602
Dim typ296(-1) As Type
10603
EmitCgeIL.Emit(OpCodes.Ldsfld, ILGen)
10604
Typ = ILGen.FieldType
10605
Typ03 = Typ
10606
EmitCgeIL.Emit(OpCodes.Ldloc, 0)
10607
Typ = GetType(OpCode)
10608
ReDim Preserve typ296(UBound(typ296) + 1)
10609
typ296(UBound(typ296)) = Typ
10610
EmitCgeIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ296))
10611
Typ = Typ03.GetMethod("Emit", typ296).ReturnType
10612
If Typ.ToString() = GetType(System.Void).ToString() Then
10613
10614
Else
10615
EmitCgeIL.Emit(OpCodes.Pop)
10616
End If
10617
EmitCgeIL.MarkSequencePoint(doc3, 802, 1, 802, 100)
10437
10618
EmitCgeIL.Emit(OpCodes.Ret)
10438
10619
Dim EmitLike As MethodBuilder = ILEmitter.DefineMethod("EmitLike", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), Type.EmptyTypes)
10439
10620
Dim EmitLikeIL As ILGenerator = EmitLike.GetILGenerator()
10440
EmitLikeIL.MarkSequencePoint(doc3, 788, 1, 788, 100)
10441
Dim locbldr45 As LocalBuilder = EmitLikeIL.DeclareLocal(GetType(OpCode))
10442
locbldr45.SetLocalSymInfo("op")
10443
EmitLikeIL.MarkSequencePoint(doc3, 789, 1, 789, 100)
10444
Dim locbldr46 As LocalBuilder = EmitLikeIL.DeclareLocal(GetType(System.Type))
10445
locbldr46.SetLocalSymInfo("lotyp")
10621
EmitLikeIL.MarkSequencePoint(doc3, 805, 1, 805, 100)
10622
Dim locbldr46 As LocalBuilder = EmitLikeIL.DeclareLocal(GetType(OpCode))
10623
locbldr46.SetLocalSymInfo("op")
10624
EmitLikeIL.MarkSequencePoint(doc3, 806, 1, 806, 100)
10625
Dim locbldr47 As LocalBuilder = EmitLikeIL.DeclareLocal(GetType(System.Type))
10626
locbldr47.SetLocalSymInfo("lotyp")
10446
10627
EmitLikeIL.Emit(OpCodes.Ldtoken, GetType(LikeOperator))
10447
Dim typ283 As Type() = {GetType(System.RuntimeTypeHandle)}
10448
EmitLikeIL.Emit(OpCodes.Call, GetType(System.Type).GetMethod("GetTypeFromHandle", typ283))
10449
Typ = GetType(System.Type).GetMethod("GetTypeFromHandle", typ283).ReturnType
10628
Dim typ297 As Type() = {GetType(System.RuntimeTypeHandle)}
10629
EmitLikeIL.Emit(OpCodes.Call, GetType(System.Type).GetMethod("GetTypeFromHandle", typ297))
10630
Typ = GetType(System.Type).GetMethod("GetTypeFromHandle", typ297).ReturnType
10450
10631
EmitLikeIL.Emit(OpCodes.Stloc, 1)
10451
EmitLikeIL.MarkSequencePoint(doc3, 790, 1, 790, 100)
10452
Dim locbldr47 As LocalBuilder = EmitLikeIL.DeclareLocal(GetType(system.Type).MakeArrayType())
10453
locbldr47.SetLocalSymInfo("params")
10632
EmitLikeIL.MarkSequencePoint(doc3, 807, 1, 807, 100)
10633
Dim locbldr48 As LocalBuilder = EmitLikeIL.DeclareLocal(GetType(system.Type).MakeArrayType())
10634
locbldr48.SetLocalSymInfo("params")
10454
10635
EmitLikeIL.Emit(OpCodes.Ldc_I4, CInt(3))
10455
10636
Typ = GetType(System.Int32)
10456
10637
EmitLikeIL.Emit(OpCodes.Conv_U)
10457
10638
EmitLikeIL.Emit(OpCodes.Newarr, GetType(System.Type))
10458
10639
EmitLikeIL.Emit(OpCodes.Stloc, 2)
10459
EmitLikeIL.MarkSequencePoint(doc3, 791, 1, 791, 100)
10640
EmitLikeIL.MarkSequencePoint(doc3, 808, 1, 808, 100)
10460
10641
EmitLikeIL.Emit(OpCodes.Ldloc, 2)
10461
10642
Typ = GetType(system.Type).MakeArrayType()
10462
10643
Typ02 = Typ
10465
10646
EmitLikeIL.Emit(OpCodes.Conv_U)
10466
10647
Typ = Typ02
10467
10648
EmitLikeIL.Emit(OpCodes.Ldtoken, GetType(System.String))
10468
Dim typ284 As Type() = {GetType(System.RuntimeTypeHandle)}
10469
EmitLikeIL.Emit(OpCodes.Call, GetType(System.Type).GetMethod("GetTypeFromHandle", typ284))
10470
Typ = GetType(System.Type).GetMethod("GetTypeFromHandle", typ284).ReturnType
10649
Dim typ298 As Type() = {GetType(System.RuntimeTypeHandle)}
10650
EmitLikeIL.Emit(OpCodes.Call, GetType(System.Type).GetMethod("GetTypeFromHandle", typ298))
10651
Typ = GetType(System.Type).GetMethod("GetTypeFromHandle", typ298).ReturnType
10471
10652
EmitLikeIL.Emit(OpCodes.Stelem, GetType(system.Type).MakeArrayType().GetElementType())
10472
EmitLikeIL.MarkSequencePoint(doc3, 792, 1, 792, 100)
10653
EmitLikeIL.MarkSequencePoint(doc3, 809, 1, 809, 100)
10473
10654
EmitLikeIL.Emit(OpCodes.Ldloc, 2)
10474
10655
Typ = GetType(system.Type).MakeArrayType()
10475
10656
Typ02 = Typ
10478
10659
EmitLikeIL.Emit(OpCodes.Conv_U)
10479
10660
Typ = Typ02
10480
10661
EmitLikeIL.Emit(OpCodes.Ldtoken, GetType(System.String))
10481
Dim typ285 As Type() = {GetType(System.RuntimeTypeHandle)}
10482
EmitLikeIL.Emit(OpCodes.Call, GetType(System.Type).GetMethod("GetTypeFromHandle", typ285))
10483
Typ = GetType(System.Type).GetMethod("GetTypeFromHandle", typ285).ReturnType
10662
Dim typ299 As Type() = {GetType(System.RuntimeTypeHandle)}
10663
EmitLikeIL.Emit(OpCodes.Call, GetType(System.Type).GetMethod("GetTypeFromHandle", typ299))
10664
Typ = GetType(System.Type).GetMethod("GetTypeFromHandle", typ299).ReturnType
10484
10665
EmitLikeIL.Emit(OpCodes.Stelem, GetType(system.Type).MakeArrayType().GetElementType())
10485
EmitLikeIL.MarkSequencePoint(doc3, 793, 1, 793, 100)
10666
EmitLikeIL.MarkSequencePoint(doc3, 810, 1, 810, 100)
10486
10667
EmitLikeIL.Emit(OpCodes.Ldloc, 2)
10487
10668
Typ = GetType(system.Type).MakeArrayType()
10488
10669
Typ02 = Typ
10491
10672
EmitLikeIL.Emit(OpCodes.Conv_U)
10492
10673
Typ = Typ02
10493
10674
EmitLikeIL.Emit(OpCodes.Ldtoken, GetType(CompareMethod))
10494
Dim typ286 As Type() = {GetType(System.RuntimeTypeHandle)}
10495
EmitLikeIL.Emit(OpCodes.Call, GetType(System.Type).GetMethod("GetTypeFromHandle", typ286))
10496
Typ = GetType(System.Type).GetMethod("GetTypeFromHandle", typ286).ReturnType
10675
Dim typ300 As Type() = {GetType(System.RuntimeTypeHandle)}
10676
EmitLikeIL.Emit(OpCodes.Call, GetType(System.Type).GetMethod("GetTypeFromHandle", typ300))
10677
Typ = GetType(System.Type).GetMethod("GetTypeFromHandle", typ300).ReturnType
10497
10678
EmitLikeIL.Emit(OpCodes.Stelem, GetType(system.Type).MakeArrayType().GetElementType())
10498
EmitLikeIL.MarkSequencePoint(doc3, 794, 1, 794, 100)
10499
Dim locbldr48 As LocalBuilder = EmitLikeIL.DeclareLocal(GetType(MethodInfo))
10500
locbldr48.SetLocalSymInfo("lomet")
10501
Dim typ287(-1) As Type
10679
EmitLikeIL.MarkSequencePoint(doc3, 811, 1, 811, 100)
10680
Dim locbldr49 As LocalBuilder = EmitLikeIL.DeclareLocal(GetType(MethodInfo))
10681
locbldr49.SetLocalSymInfo("lomet")
10682
Dim typ301(-1) As Type
10502
10683
EmitLikeIL.Emit(OpCodes.Ldloc, 1)
10503
10684
Typ = GetType(System.Type)
10504
10685
Typ03 = Typ
10505
10686
EmitLikeIL.Emit(OpCodes.Ldstr, "LikeString")
10506
10687
Typ = GetType(System.String)
10507
ReDim Preserve typ287(UBound(typ287) + 1)
10508
typ287(UBound(typ287)) = Typ
10688
ReDim Preserve typ301(UBound(typ301) + 1)
10689
typ301(UBound(typ301)) = Typ
10509
10690
EmitLikeIL.Emit(OpCodes.Ldloc, 2)
10510
10691
Typ = GetType(system.Type).MakeArrayType()
10511
ReDim Preserve typ287(UBound(typ287) + 1)
10512
typ287(UBound(typ287)) = Typ
10513
EmitLikeIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("GetMethod", typ287))
10514
Typ = Typ03.GetMethod("GetMethod", typ287).ReturnType
10692
ReDim Preserve typ301(UBound(typ301) + 1)
10693
typ301(UBound(typ301)) = Typ
10694
EmitLikeIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("GetMethod", typ301))
10695
Typ = Typ03.GetMethod("GetMethod", typ301).ReturnType
10515
10696
EmitLikeIL.Emit(OpCodes.Stloc, 3)
10516
EmitLikeIL.MarkSequencePoint(doc3, 795, 1, 795, 100)
10517
Dim typ288(-1) As Type
10697
EmitLikeIL.MarkSequencePoint(doc3, 812, 1, 812, 100)
10698
Dim typ302(-1) As Type
10518
10699
EmitLikeIL.Emit(OpCodes.Ldstr, "ldc.i4.0")
10519
10700
Typ = GetType(System.String)
10520
ReDim Preserve typ288(UBound(typ288) + 1)
10521
typ288(UBound(typ288)) = Typ
10522
EmitLikeIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ288))
10523
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ288).ReturnType
10701
ReDim Preserve typ302(UBound(typ302) + 1)
10702
typ302(UBound(typ302)) = Typ
10703
EmitLikeIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ302))
10704
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ302).ReturnType
10524
10705
EmitLikeIL.Emit(OpCodes.Stloc, 0)
10525
EmitLikeIL.MarkSequencePoint(doc3, 796, 1, 796, 100)
10526
Dim typ289(-1) As Type
10706
EmitLikeIL.MarkSequencePoint(doc3, 813, 1, 813, 100)
10707
Dim typ303(-1) As Type
10527
10708
EmitLikeIL.Emit(OpCodes.Ldsfld, ILGen)
10528
10709
Typ = ILGen.FieldType
10529
10710
Typ03 = Typ
10530
10711
EmitLikeIL.Emit(OpCodes.Ldloc, 0)
10531
10712
Typ = GetType(OpCode)
10532
ReDim Preserve typ289(UBound(typ289) + 1)
10533
typ289(UBound(typ289)) = Typ
10534
EmitLikeIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ289))
10535
Typ = Typ03.GetMethod("Emit", typ289).ReturnType
10713
ReDim Preserve typ303(UBound(typ303) + 1)
10714
typ303(UBound(typ303)) = Typ
10715
EmitLikeIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ303))
10716
Typ = Typ03.GetMethod("Emit", typ303).ReturnType
10536
10717
If Typ.ToString() = GetType(System.Void).ToString() Then
10537
10718
10538
10719
Else
10539
10720
EmitLikeIL.Emit(OpCodes.Pop)
10540
10721
End If
10541
EmitLikeIL.MarkSequencePoint(doc3, 797, 1, 797, 100)
10542
Dim typ290(-1) As Type
10722
EmitLikeIL.MarkSequencePoint(doc3, 814, 1, 814, 100)
10723
Dim typ304(-1) As Type
10543
10724
EmitLikeIL.Emit(OpCodes.Ldstr, "call")
10544
10725
Typ = GetType(System.String)
10545
ReDim Preserve typ290(UBound(typ290) + 1)
10546
typ290(UBound(typ290)) = Typ
10547
EmitLikeIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ290))
10548
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ290).ReturnType
10726
ReDim Preserve typ304(UBound(typ304) + 1)
10727
typ304(UBound(typ304)) = Typ
10728
EmitLikeIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ304))
10729
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ304).ReturnType
10549
10730
EmitLikeIL.Emit(OpCodes.Stloc, 0)
10550
EmitLikeIL.MarkSequencePoint(doc3, 798, 1, 798, 100)
10551
Dim typ291(-1) As Type
10731
EmitLikeIL.MarkSequencePoint(doc3, 815, 1, 815, 100)
10732
Dim typ305(-1) As Type
10552
10733
EmitLikeIL.Emit(OpCodes.Ldsfld, ILGen)
10553
10734
Typ = ILGen.FieldType
10554
10735
Typ03 = Typ
10555
10736
EmitLikeIL.Emit(OpCodes.Ldloc, 0)
10556
10737
Typ = GetType(OpCode)
10557
ReDim Preserve typ291(UBound(typ291) + 1)
10558
typ291(UBound(typ291)) = Typ
10738
ReDim Preserve typ305(UBound(typ305) + 1)
10739
typ305(UBound(typ305)) = Typ
10559
10740
EmitLikeIL.Emit(OpCodes.Ldloc, 3)
10560
10741
Typ = GetType(MethodInfo)
10561
ReDim Preserve typ291(UBound(typ291) + 1)
10562
typ291(UBound(typ291)) = Typ
10563
EmitLikeIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ291))
10564
Typ = Typ03.GetMethod("Emit", typ291).ReturnType
10742
ReDim Preserve typ305(UBound(typ305) + 1)
10743
typ305(UBound(typ305)) = Typ
10744
EmitLikeIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ305))
10745
Typ = Typ03.GetMethod("Emit", typ305).ReturnType
10565
10746
If Typ.ToString() = GetType(System.Void).ToString() Then
10566
10747
10567
10748
Else
10568
10749
EmitLikeIL.Emit(OpCodes.Pop)
10569
10750
End If
10570
EmitLikeIL.MarkSequencePoint(doc3, 799, 1, 799, 100)
10751
EmitLikeIL.MarkSequencePoint(doc3, 816, 1, 816, 100)
10571
10752
EmitLikeIL.Emit(OpCodes.Ret)
10572
10753
Dim EmitNLike As MethodBuilder = ILEmitter.DefineMethod("EmitNLike", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), Type.EmptyTypes)
10573
10754
Dim EmitNLikeIL As ILGenerator = EmitNLike.GetILGenerator()
10574
EmitNLikeIL.MarkSequencePoint(doc3, 802, 1, 802, 100)
10575
Dim locbldr49 As LocalBuilder = EmitNLikeIL.DeclareLocal(GetType(OpCode))
10576
locbldr49.SetLocalSymInfo("op")
10577
EmitNLikeIL.MarkSequencePoint(doc3, 803, 1, 803, 100)
10578
Dim locbldr50 As LocalBuilder = EmitNLikeIL.DeclareLocal(GetType(System.Type))
10579
locbldr50.SetLocalSymInfo("lotyp")
10755
EmitNLikeIL.MarkSequencePoint(doc3, 819, 1, 819, 100)
10756
Dim locbldr50 As LocalBuilder = EmitNLikeIL.DeclareLocal(GetType(OpCode))
10757
locbldr50.SetLocalSymInfo("op")
10758
EmitNLikeIL.MarkSequencePoint(doc3, 820, 1, 820, 100)
10759
Dim locbldr51 As LocalBuilder = EmitNLikeIL.DeclareLocal(GetType(System.Type))
10760
locbldr51.SetLocalSymInfo("lotyp")
10580
10761
EmitNLikeIL.Emit(OpCodes.Ldtoken, GetType(LikeOperator))
10581
Dim typ292 As Type() = {GetType(System.RuntimeTypeHandle)}
10582
EmitNLikeIL.Emit(OpCodes.Call, GetType(System.Type).GetMethod("GetTypeFromHandle", typ292))
10583
Typ = GetType(System.Type).GetMethod("GetTypeFromHandle", typ292).ReturnType
10762
Dim typ306 As Type() = {GetType(System.RuntimeTypeHandle)}
10763
EmitNLikeIL.Emit(OpCodes.Call, GetType(System.Type).GetMethod("GetTypeFromHandle", typ306))
10764
Typ = GetType(System.Type).GetMethod("GetTypeFromHandle", typ306).ReturnType
10584
10765
EmitNLikeIL.Emit(OpCodes.Stloc, 1)
10585
EmitNLikeIL.MarkSequencePoint(doc3, 804, 1, 804, 100)
10586
Dim locbldr51 As LocalBuilder = EmitNLikeIL.DeclareLocal(GetType(system.Type).MakeArrayType())
10587
locbldr51.SetLocalSymInfo("params")
10766
EmitNLikeIL.MarkSequencePoint(doc3, 821, 1, 821, 100)
10767
Dim locbldr52 As LocalBuilder = EmitNLikeIL.DeclareLocal(GetType(system.Type).MakeArrayType())
10768
locbldr52.SetLocalSymInfo("params")
10588
10769
EmitNLikeIL.Emit(OpCodes.Ldc_I4, CInt(3))
10589
10770
Typ = GetType(System.Int32)
10590
10771
EmitNLikeIL.Emit(OpCodes.Conv_U)
10591
10772
EmitNLikeIL.Emit(OpCodes.Newarr, GetType(System.Type))
10592
10773
EmitNLikeIL.Emit(OpCodes.Stloc, 2)
10593
EmitNLikeIL.MarkSequencePoint(doc3, 805, 1, 805, 100)
10774
EmitNLikeIL.MarkSequencePoint(doc3, 822, 1, 822, 100)
10594
10775
EmitNLikeIL.Emit(OpCodes.Ldloc, 2)
10595
10776
Typ = GetType(system.Type).MakeArrayType()
10596
10777
Typ02 = Typ
10599
10780
EmitNLikeIL.Emit(OpCodes.Conv_U)
10600
10781
Typ = Typ02
10601
10782
EmitNLikeIL.Emit(OpCodes.Ldtoken, GetType(System.String))
10602
Dim typ293 As Type() = {GetType(System.RuntimeTypeHandle)}
10603
EmitNLikeIL.Emit(OpCodes.Call, GetType(System.Type).GetMethod("GetTypeFromHandle", typ293))
10604
Typ = GetType(System.Type).GetMethod("GetTypeFromHandle", typ293).ReturnType
10783
Dim typ307 As Type() = {GetType(System.RuntimeTypeHandle)}
10784
EmitNLikeIL.Emit(OpCodes.Call, GetType(System.Type).GetMethod("GetTypeFromHandle", typ307))
10785
Typ = GetType(System.Type).GetMethod("GetTypeFromHandle", typ307).ReturnType
10605
10786
EmitNLikeIL.Emit(OpCodes.Stelem, GetType(system.Type).MakeArrayType().GetElementType())
10606
EmitNLikeIL.MarkSequencePoint(doc3, 806, 1, 806, 100)
10787
EmitNLikeIL.MarkSequencePoint(doc3, 823, 1, 823, 100)
10607
10788
EmitNLikeIL.Emit(OpCodes.Ldloc, 2)
10608
10789
Typ = GetType(system.Type).MakeArrayType()
10609
10790
Typ02 = Typ
10612
10793
EmitNLikeIL.Emit(OpCodes.Conv_U)
10613
10794
Typ = Typ02
10614
10795
EmitNLikeIL.Emit(OpCodes.Ldtoken, GetType(System.String))
10615
Dim typ294 As Type() = {GetType(System.RuntimeTypeHandle)}
10616
EmitNLikeIL.Emit(OpCodes.Call, GetType(System.Type).GetMethod("GetTypeFromHandle", typ294))
10617
Typ = GetType(System.Type).GetMethod("GetTypeFromHandle", typ294).ReturnType
10796
Dim typ308 As Type() = {GetType(System.RuntimeTypeHandle)}
10797
EmitNLikeIL.Emit(OpCodes.Call, GetType(System.Type).GetMethod("GetTypeFromHandle", typ308))
10798
Typ = GetType(System.Type).GetMethod("GetTypeFromHandle", typ308).ReturnType
10618
10799
EmitNLikeIL.Emit(OpCodes.Stelem, GetType(system.Type).MakeArrayType().GetElementType())
10619
EmitNLikeIL.MarkSequencePoint(doc3, 807, 1, 807, 100)
10800
EmitNLikeIL.MarkSequencePoint(doc3, 824, 1, 824, 100)
10620
10801
EmitNLikeIL.Emit(OpCodes.Ldloc, 2)
10621
10802
Typ = GetType(system.Type).MakeArrayType()
10622
10803
Typ02 = Typ
10625
10806
EmitNLikeIL.Emit(OpCodes.Conv_U)
10626
10807
Typ = Typ02
10627
10808
EmitNLikeIL.Emit(OpCodes.Ldtoken, GetType(CompareMethod))
10628
Dim typ295 As Type() = {GetType(System.RuntimeTypeHandle)}
10629
EmitNLikeIL.Emit(OpCodes.Call, GetType(System.Type).GetMethod("GetTypeFromHandle", typ295))
10630
Typ = GetType(System.Type).GetMethod("GetTypeFromHandle", typ295).ReturnType
10809
Dim typ309 As Type() = {GetType(System.RuntimeTypeHandle)}
10810
EmitNLikeIL.Emit(OpCodes.Call, GetType(System.Type).GetMethod("GetTypeFromHandle", typ309))
10811
Typ = GetType(System.Type).GetMethod("GetTypeFromHandle", typ309).ReturnType
10631
10812
EmitNLikeIL.Emit(OpCodes.Stelem, GetType(system.Type).MakeArrayType().GetElementType())
10632
EmitNLikeIL.MarkSequencePoint(doc3, 808, 1, 808, 100)
10633
Dim locbldr52 As LocalBuilder = EmitNLikeIL.DeclareLocal(GetType(MethodInfo))
10634
locbldr52.SetLocalSymInfo("lomet")
10635
Dim typ296(-1) As Type
10813
EmitNLikeIL.MarkSequencePoint(doc3, 825, 1, 825, 100)
10814
Dim locbldr53 As LocalBuilder = EmitNLikeIL.DeclareLocal(GetType(MethodInfo))
10815
locbldr53.SetLocalSymInfo("lomet")
10816
Dim typ310(-1) As Type
10636
10817
EmitNLikeIL.Emit(OpCodes.Ldloc, 1)
10637
10818
Typ = GetType(System.Type)
10638
10819
Typ03 = Typ
10639
10820
EmitNLikeIL.Emit(OpCodes.Ldstr, "LikeString")
10640
10821
Typ = GetType(System.String)
10641
ReDim Preserve typ296(UBound(typ296) + 1)
10642
typ296(UBound(typ296)) = Typ
10822
ReDim Preserve typ310(UBound(typ310) + 1)
10823
typ310(UBound(typ310)) = Typ
10643
10824
EmitNLikeIL.Emit(OpCodes.Ldloc, 2)
10644
10825
Typ = GetType(system.Type).MakeArrayType()
10645
ReDim Preserve typ296(UBound(typ296) + 1)
10646
typ296(UBound(typ296)) = Typ
10647
EmitNLikeIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("GetMethod", typ296))
10648
Typ = Typ03.GetMethod("GetMethod", typ296).ReturnType
10826
ReDim Preserve typ310(UBound(typ310) + 1)
10827
typ310(UBound(typ310)) = Typ
10828
EmitNLikeIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("GetMethod", typ310))
10829
Typ = Typ03.GetMethod("GetMethod", typ310).ReturnType
10649
10830
EmitNLikeIL.Emit(OpCodes.Stloc, 3)
10650
EmitNLikeIL.MarkSequencePoint(doc3, 809, 1, 809, 100)
10651
Dim typ297(-1) As Type
10831
EmitNLikeIL.MarkSequencePoint(doc3, 826, 1, 826, 100)
10832
Dim typ311(-1) As Type
10652
10833
EmitNLikeIL.Emit(OpCodes.Ldstr, "ldc.i4.0")
10653
10834
Typ = GetType(System.String)
10654
ReDim Preserve typ297(UBound(typ297) + 1)
10655
typ297(UBound(typ297)) = Typ
10656
EmitNLikeIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ297))
10657
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ297).ReturnType
10835
ReDim Preserve typ311(UBound(typ311) + 1)
10836
typ311(UBound(typ311)) = Typ
10837
EmitNLikeIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ311))
10838
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ311).ReturnType
10658
10839
EmitNLikeIL.Emit(OpCodes.Stloc, 0)
10659
EmitNLikeIL.MarkSequencePoint(doc3, 810, 1, 810, 100)
10660
Dim typ298(-1) As Type
10840
EmitNLikeIL.MarkSequencePoint(doc3, 827, 1, 827, 100)
10841
Dim typ312(-1) As Type
10661
10842
EmitNLikeIL.Emit(OpCodes.Ldsfld, ILGen)
10662
10843
Typ = ILGen.FieldType
10663
10844
Typ03 = Typ
10664
10845
EmitNLikeIL.Emit(OpCodes.Ldloc, 0)
10665
10846
Typ = GetType(OpCode)
10666
ReDim Preserve typ298(UBound(typ298) + 1)
10667
typ298(UBound(typ298)) = Typ
10668
EmitNLikeIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ298))
10669
Typ = Typ03.GetMethod("Emit", typ298).ReturnType
10847
ReDim Preserve typ312(UBound(typ312) + 1)
10848
typ312(UBound(typ312)) = Typ
10849
EmitNLikeIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ312))
10850
Typ = Typ03.GetMethod("Emit", typ312).ReturnType
10670
10851
If Typ.ToString() = GetType(System.Void).ToString() Then
10671
10852
10672
10853
Else
10673
10854
EmitNLikeIL.Emit(OpCodes.Pop)
10674
10855
End If
10675
EmitNLikeIL.MarkSequencePoint(doc3, 811, 1, 811, 100)
10676
Dim typ299(-1) As Type
10856
EmitNLikeIL.MarkSequencePoint(doc3, 828, 1, 828, 100)
10857
Dim typ313(-1) As Type
10677
10858
EmitNLikeIL.Emit(OpCodes.Ldstr, "call")
10678
10859
Typ = GetType(System.String)
10679
ReDim Preserve typ299(UBound(typ299) + 1)
10680
typ299(UBound(typ299)) = Typ
10681
EmitNLikeIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ299))
10682
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ299).ReturnType
10860
ReDim Preserve typ313(UBound(typ313) + 1)
10861
typ313(UBound(typ313)) = Typ
10862
EmitNLikeIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ313))
10863
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ313).ReturnType
10683
10864
EmitNLikeIL.Emit(OpCodes.Stloc, 0)
10684
EmitNLikeIL.MarkSequencePoint(doc3, 812, 1, 812, 100)
10685
Dim typ300(-1) As Type
10865
EmitNLikeIL.MarkSequencePoint(doc3, 829, 1, 829, 100)
10866
Dim typ314(-1) As Type
10686
10867
EmitNLikeIL.Emit(OpCodes.Ldsfld, ILGen)
10687
10868
Typ = ILGen.FieldType
10688
10869
Typ03 = Typ
10689
10870
EmitNLikeIL.Emit(OpCodes.Ldloc, 0)
10690
10871
Typ = GetType(OpCode)
10691
ReDim Preserve typ300(UBound(typ300) + 1)
10692
typ300(UBound(typ300)) = Typ
10872
ReDim Preserve typ314(UBound(typ314) + 1)
10873
typ314(UBound(typ314)) = Typ
10693
10874
EmitNLikeIL.Emit(OpCodes.Ldloc, 3)
10694
10875
Typ = GetType(MethodInfo)
10695
ReDim Preserve typ300(UBound(typ300) + 1)
10696
typ300(UBound(typ300)) = Typ
10697
EmitNLikeIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ300))
10698
Typ = Typ03.GetMethod("Emit", typ300).ReturnType
10876
ReDim Preserve typ314(UBound(typ314) + 1)
10877
typ314(UBound(typ314)) = Typ
10878
EmitNLikeIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ314))
10879
Typ = Typ03.GetMethod("Emit", typ314).ReturnType
10699
10880
If Typ.ToString() = GetType(System.Void).ToString() Then
10700
10881
10701
10882
Else
10702
10883
EmitNLikeIL.Emit(OpCodes.Pop)
10703
10884
End If
10704
EmitNLikeIL.MarkSequencePoint(doc3, 813, 1, 813, 100)
10705
Dim typ301(-1) As Type
10885
EmitNLikeIL.MarkSequencePoint(doc3, 830, 1, 830, 100)
10886
Dim typ315(-1) As Type
10706
10887
EmitNLikeIL.Emit(OpCodes.Ldstr, "not")
10707
10888
Typ = GetType(System.String)
10708
ReDim Preserve typ301(UBound(typ301) + 1)
10709
typ301(UBound(typ301)) = Typ
10710
EmitNLikeIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ301))
10711
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ301).ReturnType
10889
ReDim Preserve typ315(UBound(typ315) + 1)
10890
typ315(UBound(typ315)) = Typ
10891
EmitNLikeIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ315))
10892
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ315).ReturnType
10712
10893
EmitNLikeIL.Emit(OpCodes.Stloc, 0)
10713
EmitNLikeIL.MarkSequencePoint(doc3, 814, 1, 814, 100)
10714
Dim typ302(-1) As Type
10894
EmitNLikeIL.MarkSequencePoint(doc3, 831, 1, 831, 100)
10895
Dim typ316(-1) As Type
10715
10896
EmitNLikeIL.Emit(OpCodes.Ldsfld, ILGen)
10716
10897
Typ = ILGen.FieldType
10717
10898
Typ03 = Typ
10718
10899
EmitNLikeIL.Emit(OpCodes.Ldloc, 0)
10719
10900
Typ = GetType(OpCode)
10720
ReDim Preserve typ302(UBound(typ302) + 1)
10721
typ302(UBound(typ302)) = Typ
10722
EmitNLikeIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ302))
10723
Typ = Typ03.GetMethod("Emit", typ302).ReturnType
10901
ReDim Preserve typ316(UBound(typ316) + 1)
10902
typ316(UBound(typ316)) = Typ
10903
EmitNLikeIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ316))
10904
Typ = Typ03.GetMethod("Emit", typ316).ReturnType
10724
10905
If Typ.ToString() = GetType(System.Void).ToString() Then
10725
10906
10726
10907
Else
10727
10908
EmitNLikeIL.Emit(OpCodes.Pop)
10728
10909
End If
10729
EmitNLikeIL.MarkSequencePoint(doc3, 815, 1, 815, 100)
10910
EmitNLikeIL.MarkSequencePoint(doc3, 832, 1, 832, 100)
10730
10911
EmitNLikeIL.Emit(OpCodes.Ret)
10731
10912
Dim EmitStrCeq As MethodBuilder = ILEmitter.DefineMethod("EmitStrCeq", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), Type.EmptyTypes)
10732
10913
Dim EmitStrCeqIL As ILGenerator = EmitStrCeq.GetILGenerator()
10733
EmitStrCeqIL.MarkSequencePoint(doc3, 818, 1, 818, 100)
10734
Dim locbldr53 As LocalBuilder = EmitStrCeqIL.DeclareLocal(GetType(OpCode))
10735
locbldr53.SetLocalSymInfo("op")
10736
EmitStrCeqIL.MarkSequencePoint(doc3, 819, 1, 819, 100)
10737
Dim locbldr54 As LocalBuilder = EmitStrCeqIL.DeclareLocal(GetType(System.Type))
10738
locbldr54.SetLocalSymInfo("strtyp")
10914
EmitStrCeqIL.MarkSequencePoint(doc3, 835, 1, 835, 100)
10915
Dim locbldr54 As LocalBuilder = EmitStrCeqIL.DeclareLocal(GetType(OpCode))
10916
locbldr54.SetLocalSymInfo("op")
10917
EmitStrCeqIL.MarkSequencePoint(doc3, 836, 1, 836, 100)
10918
Dim locbldr55 As LocalBuilder = EmitStrCeqIL.DeclareLocal(GetType(System.Type))
10919
locbldr55.SetLocalSymInfo("strtyp")
10739
10920
EmitStrCeqIL.Emit(OpCodes.Ldtoken, GetType(System.String))
10740
Dim typ303 As Type() = {GetType(System.RuntimeTypeHandle)}
10741
EmitStrCeqIL.Emit(OpCodes.Call, GetType(System.Type).GetMethod("GetTypeFromHandle", typ303))
10742
Typ = GetType(System.Type).GetMethod("GetTypeFromHandle", typ303).ReturnType
10921
Dim typ317 As Type() = {GetType(System.RuntimeTypeHandle)}
10922
EmitStrCeqIL.Emit(OpCodes.Call, GetType(System.Type).GetMethod("GetTypeFromHandle", typ317))
10923
Typ = GetType(System.Type).GetMethod("GetTypeFromHandle", typ317).ReturnType
10743
10924
EmitStrCeqIL.Emit(OpCodes.Stloc, 1)
10744
EmitStrCeqIL.MarkSequencePoint(doc3, 820, 1, 820, 100)
10745
Dim locbldr55 As LocalBuilder = EmitStrCeqIL.DeclareLocal(GetType(system.Type).MakeArrayType())
10746
locbldr55.SetLocalSymInfo("params")
10925
EmitStrCeqIL.MarkSequencePoint(doc3, 837, 1, 837, 100)
10926
Dim locbldr56 As LocalBuilder = EmitStrCeqIL.DeclareLocal(GetType(system.Type).MakeArrayType())
10927
locbldr56.SetLocalSymInfo("params")
10747
10928
EmitStrCeqIL.Emit(OpCodes.Ldc_I4, CInt(2))
10748
10929
Typ = GetType(System.Int32)
10749
10930
EmitStrCeqIL.Emit(OpCodes.Conv_U)
10750
10931
EmitStrCeqIL.Emit(OpCodes.Newarr, GetType(System.Type))
10751
10932
EmitStrCeqIL.Emit(OpCodes.Stloc, 2)
10752
EmitStrCeqIL.MarkSequencePoint(doc3, 821, 1, 821, 100)
10933
EmitStrCeqIL.MarkSequencePoint(doc3, 838, 1, 838, 100)
10753
10934
EmitStrCeqIL.Emit(OpCodes.Ldloc, 2)
10754
10935
Typ = GetType(system.Type).MakeArrayType()
10755
10936
Typ02 = Typ
10758
10939
EmitStrCeqIL.Emit(OpCodes.Conv_U)
10759
10940
Typ = Typ02
10760
10941
EmitStrCeqIL.Emit(OpCodes.Ldtoken, GetType(System.String))
10761
Dim typ304 As Type() = {GetType(System.RuntimeTypeHandle)}
10762
EmitStrCeqIL.Emit(OpCodes.Call, GetType(System.Type).GetMethod("GetTypeFromHandle", typ304))
10763
Typ = GetType(System.Type).GetMethod("GetTypeFromHandle", typ304).ReturnType
10942
Dim typ318 As Type() = {GetType(System.RuntimeTypeHandle)}
10943
EmitStrCeqIL.Emit(OpCodes.Call, GetType(System.Type).GetMethod("GetTypeFromHandle", typ318))
10944
Typ = GetType(System.Type).GetMethod("GetTypeFromHandle", typ318).ReturnType
10764
10945
EmitStrCeqIL.Emit(OpCodes.Stelem, GetType(system.Type).MakeArrayType().GetElementType())
10765
EmitStrCeqIL.MarkSequencePoint(doc3, 822, 1, 822, 100)
10946
EmitStrCeqIL.MarkSequencePoint(doc3, 839, 1, 839, 100)
10766
10947
EmitStrCeqIL.Emit(OpCodes.Ldloc, 2)
10767
10948
Typ = GetType(system.Type).MakeArrayType()
10768
10949
Typ02 = Typ
10771
10952
EmitStrCeqIL.Emit(OpCodes.Conv_U)
10772
10953
Typ = Typ02
10773
10954
EmitStrCeqIL.Emit(OpCodes.Ldtoken, GetType(System.String))
10774
Dim typ305 As Type() = {GetType(System.RuntimeTypeHandle)}
10775
EmitStrCeqIL.Emit(OpCodes.Call, GetType(System.Type).GetMethod("GetTypeFromHandle", typ305))
10776
Typ = GetType(System.Type).GetMethod("GetTypeFromHandle", typ305).ReturnType
10955
Dim typ319 As Type() = {GetType(System.RuntimeTypeHandle)}
10956
EmitStrCeqIL.Emit(OpCodes.Call, GetType(System.Type).GetMethod("GetTypeFromHandle", typ319))
10957
Typ = GetType(System.Type).GetMethod("GetTypeFromHandle", typ319).ReturnType
10777
10958
EmitStrCeqIL.Emit(OpCodes.Stelem, GetType(system.Type).MakeArrayType().GetElementType())
10778
EmitStrCeqIL.MarkSequencePoint(doc3, 823, 1, 823, 100)
10779
Dim locbldr56 As LocalBuilder = EmitStrCeqIL.DeclareLocal(GetType(MethodInfo))
10780
locbldr56.SetLocalSymInfo("met")
10781
Dim typ306(-1) As Type
10959
EmitStrCeqIL.MarkSequencePoint(doc3, 840, 1, 840, 100)
10960
Dim locbldr57 As LocalBuilder = EmitStrCeqIL.DeclareLocal(GetType(MethodInfo))
10961
locbldr57.SetLocalSymInfo("met")
10962
Dim typ320(-1) As Type
10782
10963
EmitStrCeqIL.Emit(OpCodes.Ldloc, 1)
10783
10964
Typ = GetType(System.Type)
10784
10965
Typ03 = Typ
10785
10966
EmitStrCeqIL.Emit(OpCodes.Ldstr, "Compare")
10786
10967
Typ = GetType(System.String)
10787
ReDim Preserve typ306(UBound(typ306) + 1)
10788
typ306(UBound(typ306)) = Typ
10968
ReDim Preserve typ320(UBound(typ320) + 1)
10969
typ320(UBound(typ320)) = Typ
10789
10970
EmitStrCeqIL.Emit(OpCodes.Ldloc, 2)
10790
10971
Typ = GetType(system.Type).MakeArrayType()
10791
ReDim Preserve typ306(UBound(typ306) + 1)
10792
typ306(UBound(typ306)) = Typ
10793
EmitStrCeqIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("GetMethod", typ306))
10794
Typ = Typ03.GetMethod("GetMethod", typ306).ReturnType
10972
ReDim Preserve typ320(UBound(typ320) + 1)
10973
typ320(UBound(typ320)) = Typ
10974
EmitStrCeqIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("GetMethod", typ320))
10975
Typ = Typ03.GetMethod("GetMethod", typ320).ReturnType
10795
10976
EmitStrCeqIL.Emit(OpCodes.Stloc, 3)
10796
EmitStrCeqIL.MarkSequencePoint(doc3, 824, 1, 824, 100)
10797
Dim typ307(-1) As Type
10977
EmitStrCeqIL.MarkSequencePoint(doc3, 841, 1, 841, 100)
10978
Dim typ321(-1) As Type
10798
10979
EmitStrCeqIL.Emit(OpCodes.Ldstr, "call")
10799
10980
Typ = GetType(System.String)
10800
ReDim Preserve typ307(UBound(typ307) + 1)
10801
typ307(UBound(typ307)) = Typ
10802
EmitStrCeqIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ307))
10803
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ307).ReturnType
10981
ReDim Preserve typ321(UBound(typ321) + 1)
10982
typ321(UBound(typ321)) = Typ
10983
EmitStrCeqIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ321))
10984
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ321).ReturnType
10804
10985
EmitStrCeqIL.Emit(OpCodes.Stloc, 0)
10805
EmitStrCeqIL.MarkSequencePoint(doc3, 825, 1, 825, 100)
10806
Dim typ308(-1) As Type
10986
EmitStrCeqIL.MarkSequencePoint(doc3, 842, 1, 842, 100)
10987
Dim typ322(-1) As Type
10807
10988
EmitStrCeqIL.Emit(OpCodes.Ldsfld, ILGen)
10808
10989
Typ = ILGen.FieldType
10809
10990
Typ03 = Typ
10810
10991
EmitStrCeqIL.Emit(OpCodes.Ldloc, 0)
10811
10992
Typ = GetType(OpCode)
10812
ReDim Preserve typ308(UBound(typ308) + 1)
10813
typ308(UBound(typ308)) = Typ
10993
ReDim Preserve typ322(UBound(typ322) + 1)
10994
typ322(UBound(typ322)) = Typ
10814
10995
EmitStrCeqIL.Emit(OpCodes.Ldloc, 3)
10815
10996
Typ = GetType(MethodInfo)
10816
ReDim Preserve typ308(UBound(typ308) + 1)
10817
typ308(UBound(typ308)) = Typ
10818
EmitStrCeqIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ308))
10819
Typ = Typ03.GetMethod("Emit", typ308).ReturnType
10997
ReDim Preserve typ322(UBound(typ322) + 1)
10998
typ322(UBound(typ322)) = Typ
10999
EmitStrCeqIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ322))
11000
Typ = Typ03.GetMethod("Emit", typ322).ReturnType
10820
11001
If Typ.ToString() = GetType(System.Void).ToString() Then
10821
11002
10822
11003
Else
10823
11004
EmitStrCeqIL.Emit(OpCodes.Pop)
10824
11005
End If
10825
EmitStrCeqIL.MarkSequencePoint(doc3, 826, 1, 826, 100)
10826
Dim typ309(-1) As Type
11006
EmitStrCeqIL.MarkSequencePoint(doc3, 843, 1, 843, 100)
11007
Dim typ323(-1) As Type
10827
11008
EmitStrCeqIL.Emit(OpCodes.Ldstr, "ldc.i4.0")
10828
11009
Typ = GetType(System.String)
10829
ReDim Preserve typ309(UBound(typ309) + 1)
10830
typ309(UBound(typ309)) = Typ
10831
EmitStrCeqIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ309))
10832
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ309).ReturnType
11010
ReDim Preserve typ323(UBound(typ323) + 1)
11011
typ323(UBound(typ323)) = Typ
11012
EmitStrCeqIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ323))
11013
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ323).ReturnType
10833
11014
EmitStrCeqIL.Emit(OpCodes.Stloc, 0)
10834
EmitStrCeqIL.MarkSequencePoint(doc3, 827, 1, 827, 100)
10835
Dim typ310(-1) As Type
11015
EmitStrCeqIL.MarkSequencePoint(doc3, 844, 1, 844, 100)
11016
Dim typ324(-1) As Type
10836
11017
EmitStrCeqIL.Emit(OpCodes.Ldsfld, ILGen)
10837
11018
Typ = ILGen.FieldType
10838
11019
Typ03 = Typ
10839
11020
EmitStrCeqIL.Emit(OpCodes.Ldloc, 0)
10840
11021
Typ = GetType(OpCode)
10841
ReDim Preserve typ310(UBound(typ310) + 1)
10842
typ310(UBound(typ310)) = Typ
10843
EmitStrCeqIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ310))
10844
Typ = Typ03.GetMethod("Emit", typ310).ReturnType
11022
ReDim Preserve typ324(UBound(typ324) + 1)
11023
typ324(UBound(typ324)) = Typ
11024
EmitStrCeqIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ324))
11025
Typ = Typ03.GetMethod("Emit", typ324).ReturnType
10845
11026
If Typ.ToString() = GetType(System.Void).ToString() Then
10846
11027
10847
11028
Else
10848
11029
EmitStrCeqIL.Emit(OpCodes.Pop)
10849
11030
End If
10850
EmitStrCeqIL.MarkSequencePoint(doc3, 828, 1, 828, 100)
10851
Dim typ311(-1) As Type
11031
EmitStrCeqIL.MarkSequencePoint(doc3, 845, 1, 845, 100)
11032
Dim typ325(-1) As Type
10852
11033
EmitStrCeqIL.Emit(OpCodes.Ldstr, "ceq")
10853
11034
Typ = GetType(System.String)
10854
ReDim Preserve typ311(UBound(typ311) + 1)
10855
typ311(UBound(typ311)) = Typ
10856
EmitStrCeqIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ311))
10857
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ311).ReturnType
11035
ReDim Preserve typ325(UBound(typ325) + 1)
11036
typ325(UBound(typ325)) = Typ
11037
EmitStrCeqIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ325))
11038
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ325).ReturnType
10858
11039
EmitStrCeqIL.Emit(OpCodes.Stloc, 0)
10859
EmitStrCeqIL.MarkSequencePoint(doc3, 829, 1, 829, 100)
10860
Dim typ312(-1) As Type
11040
EmitStrCeqIL.MarkSequencePoint(doc3, 846, 1, 846, 100)
11041
Dim typ326(-1) As Type
10861
11042
EmitStrCeqIL.Emit(OpCodes.Ldsfld, ILGen)
10862
11043
Typ = ILGen.FieldType
10863
11044
Typ03 = Typ
10864
11045
EmitStrCeqIL.Emit(OpCodes.Ldloc, 0)
10865
11046
Typ = GetType(OpCode)
10866
ReDim Preserve typ312(UBound(typ312) + 1)
10867
typ312(UBound(typ312)) = Typ
10868
EmitStrCeqIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ312))
10869
Typ = Typ03.GetMethod("Emit", typ312).ReturnType
11047
ReDim Preserve typ326(UBound(typ326) + 1)
11048
typ326(UBound(typ326)) = Typ
11049
EmitStrCeqIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ326))
11050
Typ = Typ03.GetMethod("Emit", typ326).ReturnType
10870
11051
If Typ.ToString() = GetType(System.Void).ToString() Then
10871
11052
10872
11053
Else
10873
11054
EmitStrCeqIL.Emit(OpCodes.Pop)
10874
11055
End If
10875
EmitStrCeqIL.MarkSequencePoint(doc3, 830, 1, 830, 100)
11056
EmitStrCeqIL.MarkSequencePoint(doc3, 847, 1, 847, 100)
10876
11057
EmitStrCeqIL.Emit(OpCodes.Ret)
10877
11058
Dim EmitStrCneq As MethodBuilder = ILEmitter.DefineMethod("EmitStrCneq", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), Type.EmptyTypes)
10878
11059
Dim EmitStrCneqIL As ILGenerator = EmitStrCneq.GetILGenerator()
10879
EmitStrCneqIL.MarkSequencePoint(doc3, 833, 1, 833, 100)
10880
Dim locbldr57 As LocalBuilder = EmitStrCneqIL.DeclareLocal(GetType(OpCode))
10881
locbldr57.SetLocalSymInfo("op")
10882
EmitStrCneqIL.MarkSequencePoint(doc3, 834, 1, 834, 100)
10883
Dim locbldr58 As LocalBuilder = EmitStrCneqIL.DeclareLocal(GetType(System.Type))
10884
locbldr58.SetLocalSymInfo("strtyp")
11060
EmitStrCneqIL.MarkSequencePoint(doc3, 850, 1, 850, 100)
11061
Dim locbldr58 As LocalBuilder = EmitStrCneqIL.DeclareLocal(GetType(OpCode))
11062
locbldr58.SetLocalSymInfo("op")
11063
EmitStrCneqIL.MarkSequencePoint(doc3, 851, 1, 851, 100)
11064
Dim locbldr59 As LocalBuilder = EmitStrCneqIL.DeclareLocal(GetType(System.Type))
11065
locbldr59.SetLocalSymInfo("strtyp")
10885
11066
EmitStrCneqIL.Emit(OpCodes.Ldtoken, GetType(System.String))
10886
Dim typ313 As Type() = {GetType(System.RuntimeTypeHandle)}
10887
EmitStrCneqIL.Emit(OpCodes.Call, GetType(System.Type).GetMethod("GetTypeFromHandle", typ313))
10888
Typ = GetType(System.Type).GetMethod("GetTypeFromHandle", typ313).ReturnType
11067
Dim typ327 As Type() = {GetType(System.RuntimeTypeHandle)}
11068
EmitStrCneqIL.Emit(OpCodes.Call, GetType(System.Type).GetMethod("GetTypeFromHandle", typ327))
11069
Typ = GetType(System.Type).GetMethod("GetTypeFromHandle", typ327).ReturnType
10889
11070
EmitStrCneqIL.Emit(OpCodes.Stloc, 1)
10890
EmitStrCneqIL.MarkSequencePoint(doc3, 835, 1, 835, 100)
10891
Dim locbldr59 As LocalBuilder = EmitStrCneqIL.DeclareLocal(GetType(system.Type).MakeArrayType())
10892
locbldr59.SetLocalSymInfo("params")
11071
EmitStrCneqIL.MarkSequencePoint(doc3, 852, 1, 852, 100)
11072
Dim locbldr60 As LocalBuilder = EmitStrCneqIL.DeclareLocal(GetType(system.Type).MakeArrayType())
11073
locbldr60.SetLocalSymInfo("params")
10893
11074
EmitStrCneqIL.Emit(OpCodes.Ldc_I4, CInt(2))
10894
11075
Typ = GetType(System.Int32)
10895
11076
EmitStrCneqIL.Emit(OpCodes.Conv_U)
10896
11077
EmitStrCneqIL.Emit(OpCodes.Newarr, GetType(System.Type))
10897
11078
EmitStrCneqIL.Emit(OpCodes.Stloc, 2)
10898
EmitStrCneqIL.MarkSequencePoint(doc3, 836, 1, 836, 100)
11079
EmitStrCneqIL.MarkSequencePoint(doc3, 853, 1, 853, 100)
10899
11080
EmitStrCneqIL.Emit(OpCodes.Ldloc, 2)
10900
11081
Typ = GetType(system.Type).MakeArrayType()
10901
11082
Typ02 = Typ
10904
11085
EmitStrCneqIL.Emit(OpCodes.Conv_U)
10905
11086
Typ = Typ02
10906
11087
EmitStrCneqIL.Emit(OpCodes.Ldtoken, GetType(System.String))
10907
Dim typ314 As Type() = {GetType(System.RuntimeTypeHandle)}
10908
EmitStrCneqIL.Emit(OpCodes.Call, GetType(System.Type).GetMethod("GetTypeFromHandle", typ314))
10909
Typ = GetType(System.Type).GetMethod("GetTypeFromHandle", typ314).ReturnType
11088
Dim typ328 As Type() = {GetType(System.RuntimeTypeHandle)}
11089
EmitStrCneqIL.Emit(OpCodes.Call, GetType(System.Type).GetMethod("GetTypeFromHandle", typ328))
11090
Typ = GetType(System.Type).GetMethod("GetTypeFromHandle", typ328).ReturnType
10910
11091
EmitStrCneqIL.Emit(OpCodes.Stelem, GetType(system.Type).MakeArrayType().GetElementType())
10911
EmitStrCneqIL.MarkSequencePoint(doc3, 837, 1, 837, 100)
11092
EmitStrCneqIL.MarkSequencePoint(doc3, 854, 1, 854, 100)
10912
11093
EmitStrCneqIL.Emit(OpCodes.Ldloc, 2)
10913
11094
Typ = GetType(system.Type).MakeArrayType()
10914
11095
Typ02 = Typ
10917
11098
EmitStrCneqIL.Emit(OpCodes.Conv_U)
10918
11099
Typ = Typ02
10919
11100
EmitStrCneqIL.Emit(OpCodes.Ldtoken, GetType(System.String))
10920
Dim typ315 As Type() = {GetType(System.RuntimeTypeHandle)}
10921
EmitStrCneqIL.Emit(OpCodes.Call, GetType(System.Type).GetMethod("GetTypeFromHandle", typ315))
10922
Typ = GetType(System.Type).GetMethod("GetTypeFromHandle", typ315).ReturnType
11101
Dim typ329 As Type() = {GetType(System.RuntimeTypeHandle)}
11102
EmitStrCneqIL.Emit(OpCodes.Call, GetType(System.Type).GetMethod("GetTypeFromHandle", typ329))
11103
Typ = GetType(System.Type).GetMethod("GetTypeFromHandle", typ329).ReturnType
10923
11104
EmitStrCneqIL.Emit(OpCodes.Stelem, GetType(system.Type).MakeArrayType().GetElementType())
10924
EmitStrCneqIL.MarkSequencePoint(doc3, 838, 1, 838, 100)
10925
Dim locbldr60 As LocalBuilder = EmitStrCneqIL.DeclareLocal(GetType(MethodInfo))
10926
locbldr60.SetLocalSymInfo("met")
10927
Dim typ316(-1) As Type
11105
EmitStrCneqIL.MarkSequencePoint(doc3, 855, 1, 855, 100)
11106
Dim locbldr61 As LocalBuilder = EmitStrCneqIL.DeclareLocal(GetType(MethodInfo))
11107
locbldr61.SetLocalSymInfo("met")
11108
Dim typ330(-1) As Type
10928
11109
EmitStrCneqIL.Emit(OpCodes.Ldloc, 1)
10929
11110
Typ = GetType(System.Type)
10930
11111
Typ03 = Typ
10931
11112
EmitStrCneqIL.Emit(OpCodes.Ldstr, "Compare")
10932
11113
Typ = GetType(System.String)
10933
ReDim Preserve typ316(UBound(typ316) + 1)
10934
typ316(UBound(typ316)) = Typ
11114
ReDim Preserve typ330(UBound(typ330) + 1)
11115
typ330(UBound(typ330)) = Typ
10935
11116
EmitStrCneqIL.Emit(OpCodes.Ldloc, 2)
10936
11117
Typ = GetType(system.Type).MakeArrayType()
10937
ReDim Preserve typ316(UBound(typ316) + 1)
10938
typ316(UBound(typ316)) = Typ
10939
EmitStrCneqIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("GetMethod", typ316))
10940
Typ = Typ03.GetMethod("GetMethod", typ316).ReturnType
11118
ReDim Preserve typ330(UBound(typ330) + 1)
11119
typ330(UBound(typ330)) = Typ
11120
EmitStrCneqIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("GetMethod", typ330))
11121
Typ = Typ03.GetMethod("GetMethod", typ330).ReturnType
10941
11122
EmitStrCneqIL.Emit(OpCodes.Stloc, 3)
10942
EmitStrCneqIL.MarkSequencePoint(doc3, 839, 1, 839, 100)
10943
Dim typ317(-1) As Type
11123
EmitStrCneqIL.MarkSequencePoint(doc3, 856, 1, 856, 100)
11124
Dim typ331(-1) As Type
10944
11125
EmitStrCneqIL.Emit(OpCodes.Ldstr, "call")
10945
11126
Typ = GetType(System.String)
10946
ReDim Preserve typ317(UBound(typ317) + 1)
10947
typ317(UBound(typ317)) = Typ
10948
EmitStrCneqIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ317))
10949
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ317).ReturnType
11127
ReDim Preserve typ331(UBound(typ331) + 1)
11128
typ331(UBound(typ331)) = Typ
11129
EmitStrCneqIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ331))
11130
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ331).ReturnType
10950
11131
EmitStrCneqIL.Emit(OpCodes.Stloc, 0)
10951
EmitStrCneqIL.MarkSequencePoint(doc3, 840, 1, 840, 100)
10952
Dim typ318(-1) As Type
11132
EmitStrCneqIL.MarkSequencePoint(doc3, 857, 1, 857, 100)
11133
Dim typ332(-1) As Type
10953
11134
EmitStrCneqIL.Emit(OpCodes.Ldsfld, ILGen)
10954
11135
Typ = ILGen.FieldType
10955
11136
Typ03 = Typ
10956
11137
EmitStrCneqIL.Emit(OpCodes.Ldloc, 0)
10957
11138
Typ = GetType(OpCode)
10958
ReDim Preserve typ318(UBound(typ318) + 1)
10959
typ318(UBound(typ318)) = Typ
11139
ReDim Preserve typ332(UBound(typ332) + 1)
11140
typ332(UBound(typ332)) = Typ
10960
11141
EmitStrCneqIL.Emit(OpCodes.Ldloc, 3)
10961
11142
Typ = GetType(MethodInfo)
10962
ReDim Preserve typ318(UBound(typ318) + 1)
10963
typ318(UBound(typ318)) = Typ
10964
EmitStrCneqIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ318))
10965
Typ = Typ03.GetMethod("Emit", typ318).ReturnType
10966
If Typ.ToString() = GetType(System.Void).ToString() Then
10967
10968
Else
10969
EmitStrCneqIL.Emit(OpCodes.Pop)
10970
End If
10971
EmitStrCneqIL.MarkSequencePoint(doc3, 841, 1, 841, 100)
10972
Dim typ319(-1) As Type
10973
EmitStrCneqIL.Emit(OpCodes.Ldstr, "ldc.i4.0")
10974
Typ = GetType(System.String)
10975
ReDim Preserve typ319(UBound(typ319) + 1)
10976
typ319(UBound(typ319)) = Typ
10977
EmitStrCneqIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ319))
10978
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ319).ReturnType
10979
EmitStrCneqIL.Emit(OpCodes.Stloc, 0)
10980
EmitStrCneqIL.MarkSequencePoint(doc3, 842, 1, 842, 100)
10981
Dim typ320(-1) As Type
10982
EmitStrCneqIL.Emit(OpCodes.Ldsfld, ILGen)
10983
Typ = ILGen.FieldType
10984
Typ03 = Typ
10985
EmitStrCneqIL.Emit(OpCodes.Ldloc, 0)
10986
Typ = GetType(OpCode)
10987
ReDim Preserve typ320(UBound(typ320) + 1)
10988
typ320(UBound(typ320)) = Typ
10989
EmitStrCneqIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ320))
10990
Typ = Typ03.GetMethod("Emit", typ320).ReturnType
10991
If Typ.ToString() = GetType(System.Void).ToString() Then
10992
10993
Else
10994
EmitStrCneqIL.Emit(OpCodes.Pop)
10995
End If
10996
EmitStrCneqIL.MarkSequencePoint(doc3, 843, 1, 843, 100)
10997
Dim typ321(-1) As Type
10998
EmitStrCneqIL.Emit(OpCodes.Ldstr, "ceq")
10999
Typ = GetType(System.String)
11000
ReDim Preserve typ321(UBound(typ321) + 1)
11001
typ321(UBound(typ321)) = Typ
11002
EmitStrCneqIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ321))
11003
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ321).ReturnType
11004
EmitStrCneqIL.Emit(OpCodes.Stloc, 0)
11005
EmitStrCneqIL.MarkSequencePoint(doc3, 844, 1, 844, 100)
11006
Dim typ322(-1) As Type
11007
EmitStrCneqIL.Emit(OpCodes.Ldsfld, ILGen)
11008
Typ = ILGen.FieldType
11009
Typ03 = Typ
11010
EmitStrCneqIL.Emit(OpCodes.Ldloc, 0)
11011
Typ = GetType(OpCode)
11012
ReDim Preserve typ322(UBound(typ322) + 1)
11013
typ322(UBound(typ322)) = Typ
11014
EmitStrCneqIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ322))
11015
Typ = Typ03.GetMethod("Emit", typ322).ReturnType
11016
If Typ.ToString() = GetType(System.Void).ToString() Then
11017
11018
Else
11019
EmitStrCneqIL.Emit(OpCodes.Pop)
11020
End If
11021
EmitStrCneqIL.MarkSequencePoint(doc3, 845, 1, 845, 100)
11022
Dim typ323(-1) As Type
11023
EmitStrCneqIL.Emit(OpCodes.Ldstr, "not")
11024
Typ = GetType(System.String)
11025
ReDim Preserve typ323(UBound(typ323) + 1)
11026
typ323(UBound(typ323)) = Typ
11027
EmitStrCneqIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ323))
11028
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ323).ReturnType
11029
EmitStrCneqIL.Emit(OpCodes.Stloc, 0)
11030
EmitStrCneqIL.MarkSequencePoint(doc3, 846, 1, 846, 100)
11031
Dim typ324(-1) As Type
11032
EmitStrCneqIL.Emit(OpCodes.Ldsfld, ILGen)
11033
Typ = ILGen.FieldType
11034
Typ03 = Typ
11035
EmitStrCneqIL.Emit(OpCodes.Ldloc, 0)
11036
Typ = GetType(OpCode)
11037
ReDim Preserve typ324(UBound(typ324) + 1)
11038
typ324(UBound(typ324)) = Typ
11039
EmitStrCneqIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ324))
11040
Typ = Typ03.GetMethod("Emit", typ324).ReturnType
11041
If Typ.ToString() = GetType(System.Void).ToString() Then
11042
11043
Else
11044
EmitStrCneqIL.Emit(OpCodes.Pop)
11045
End If
11046
EmitStrCneqIL.MarkSequencePoint(doc3, 847, 1, 847, 100)
11143
ReDim Preserve typ332(UBound(typ332) + 1)
11144
typ332(UBound(typ332)) = Typ
11145
EmitStrCneqIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ332))
11146
Typ = Typ03.GetMethod("Emit", typ332).ReturnType
11147
If Typ.ToString() = GetType(System.Void).ToString() Then
11148
11149
Else
11150
EmitStrCneqIL.Emit(OpCodes.Pop)
11151
End If
11152
EmitStrCneqIL.MarkSequencePoint(doc3, 858, 1, 858, 100)
11153
Dim typ333(-1) As Type
11154
EmitStrCneqIL.Emit(OpCodes.Ldstr, "ldc.i4.0")
11155
Typ = GetType(System.String)
11156
ReDim Preserve typ333(UBound(typ333) + 1)
11157
typ333(UBound(typ333)) = Typ
11158
EmitStrCneqIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ333))
11159
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ333).ReturnType
11160
EmitStrCneqIL.Emit(OpCodes.Stloc, 0)
11161
EmitStrCneqIL.MarkSequencePoint(doc3, 859, 1, 859, 100)
11162
Dim typ334(-1) As Type
11163
EmitStrCneqIL.Emit(OpCodes.Ldsfld, ILGen)
11164
Typ = ILGen.FieldType
11165
Typ03 = Typ
11166
EmitStrCneqIL.Emit(OpCodes.Ldloc, 0)
11167
Typ = GetType(OpCode)
11168
ReDim Preserve typ334(UBound(typ334) + 1)
11169
typ334(UBound(typ334)) = Typ
11170
EmitStrCneqIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ334))
11171
Typ = Typ03.GetMethod("Emit", typ334).ReturnType
11172
If Typ.ToString() = GetType(System.Void).ToString() Then
11173
11174
Else
11175
EmitStrCneqIL.Emit(OpCodes.Pop)
11176
End If
11177
EmitStrCneqIL.MarkSequencePoint(doc3, 860, 1, 860, 100)
11178
Dim typ335(-1) As Type
11179
EmitStrCneqIL.Emit(OpCodes.Ldstr, "ceq")
11180
Typ = GetType(System.String)
11181
ReDim Preserve typ335(UBound(typ335) + 1)
11182
typ335(UBound(typ335)) = Typ
11183
EmitStrCneqIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ335))
11184
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ335).ReturnType
11185
EmitStrCneqIL.Emit(OpCodes.Stloc, 0)
11186
EmitStrCneqIL.MarkSequencePoint(doc3, 861, 1, 861, 100)
11187
Dim typ336(-1) As Type
11188
EmitStrCneqIL.Emit(OpCodes.Ldsfld, ILGen)
11189
Typ = ILGen.FieldType
11190
Typ03 = Typ
11191
EmitStrCneqIL.Emit(OpCodes.Ldloc, 0)
11192
Typ = GetType(OpCode)
11193
ReDim Preserve typ336(UBound(typ336) + 1)
11194
typ336(UBound(typ336)) = Typ
11195
EmitStrCneqIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ336))
11196
Typ = Typ03.GetMethod("Emit", typ336).ReturnType
11197
If Typ.ToString() = GetType(System.Void).ToString() Then
11198
11199
Else
11200
EmitStrCneqIL.Emit(OpCodes.Pop)
11201
End If
11202
EmitStrCneqIL.MarkSequencePoint(doc3, 862, 1, 862, 100)
11203
Dim typ337(-1) As Type
11204
EmitStrCneqIL.Emit(OpCodes.Ldstr, "ldc.i4.0")
11205
Typ = GetType(System.String)
11206
ReDim Preserve typ337(UBound(typ337) + 1)
11207
typ337(UBound(typ337)) = Typ
11208
EmitStrCneqIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ337))
11209
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ337).ReturnType
11210
EmitStrCneqIL.Emit(OpCodes.Stloc, 0)
11211
EmitStrCneqIL.MarkSequencePoint(doc3, 863, 1, 863, 100)
11212
Dim typ338(-1) As Type
11213
EmitStrCneqIL.Emit(OpCodes.Ldsfld, ILGen)
11214
Typ = ILGen.FieldType
11215
Typ03 = Typ
11216
EmitStrCneqIL.Emit(OpCodes.Ldloc, 0)
11217
Typ = GetType(OpCode)
11218
ReDim Preserve typ338(UBound(typ338) + 1)
11219
typ338(UBound(typ338)) = Typ
11220
EmitStrCneqIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ338))
11221
Typ = Typ03.GetMethod("Emit", typ338).ReturnType
11222
If Typ.ToString() = GetType(System.Void).ToString() Then
11223
11224
Else
11225
EmitStrCneqIL.Emit(OpCodes.Pop)
11226
End If
11227
EmitStrCneqIL.MarkSequencePoint(doc3, 864, 1, 864, 100)
11228
Dim typ339(-1) As Type
11229
EmitStrCneqIL.Emit(OpCodes.Ldstr, "ceq")
11230
Typ = GetType(System.String)
11231
ReDim Preserve typ339(UBound(typ339) + 1)
11232
typ339(UBound(typ339)) = Typ
11233
EmitStrCneqIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ339))
11234
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ339).ReturnType
11235
EmitStrCneqIL.Emit(OpCodes.Stloc, 0)
11236
EmitStrCneqIL.MarkSequencePoint(doc3, 865, 1, 865, 100)
11237
Dim typ340(-1) As Type
11238
EmitStrCneqIL.Emit(OpCodes.Ldsfld, ILGen)
11239
Typ = ILGen.FieldType
11240
Typ03 = Typ
11241
EmitStrCneqIL.Emit(OpCodes.Ldloc, 0)
11242
Typ = GetType(OpCode)
11243
ReDim Preserve typ340(UBound(typ340) + 1)
11244
typ340(UBound(typ340)) = Typ
11245
EmitStrCneqIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ340))
11246
Typ = Typ03.GetMethod("Emit", typ340).ReturnType
11247
If Typ.ToString() = GetType(System.Void).ToString() Then
11248
11249
Else
11250
EmitStrCneqIL.Emit(OpCodes.Pop)
11251
End If
11252
EmitStrCneqIL.MarkSequencePoint(doc3, 866, 1, 866, 100)
11047
11253
EmitStrCneqIL.Emit(OpCodes.Ret)
11048
11254
Dim EmitStrAdd As MethodBuilder = ILEmitter.DefineMethod("EmitStrAdd", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), Type.EmptyTypes)
11049
11255
Dim EmitStrAddIL As ILGenerator = EmitStrAdd.GetILGenerator()
11050
EmitStrAddIL.MarkSequencePoint(doc3, 850, 1, 850, 100)
11051
Dim locbldr61 As LocalBuilder = EmitStrAddIL.DeclareLocal(GetType(OpCode))
11052
locbldr61.SetLocalSymInfo("op")
11053
EmitStrAddIL.MarkSequencePoint(doc3, 851, 1, 851, 100)
11054
Dim locbldr62 As LocalBuilder = EmitStrAddIL.DeclareLocal(GetType(System.Type))
11055
locbldr62.SetLocalSymInfo("strtyp")
11256
EmitStrAddIL.MarkSequencePoint(doc3, 869, 1, 869, 100)
11257
Dim locbldr62 As LocalBuilder = EmitStrAddIL.DeclareLocal(GetType(OpCode))
11258
locbldr62.SetLocalSymInfo("op")
11259
EmitStrAddIL.MarkSequencePoint(doc3, 870, 1, 870, 100)
11260
Dim locbldr63 As LocalBuilder = EmitStrAddIL.DeclareLocal(GetType(System.Type))
11261
locbldr63.SetLocalSymInfo("strtyp")
11056
11262
EmitStrAddIL.Emit(OpCodes.Ldtoken, GetType(System.String))
11057
Dim typ325 As Type() = {GetType(System.RuntimeTypeHandle)}
11058
EmitStrAddIL.Emit(OpCodes.Call, GetType(System.Type).GetMethod("GetTypeFromHandle", typ325))
11059
Typ = GetType(System.Type).GetMethod("GetTypeFromHandle", typ325).ReturnType
11263
Dim typ341 As Type() = {GetType(System.RuntimeTypeHandle)}
11264
EmitStrAddIL.Emit(OpCodes.Call, GetType(System.Type).GetMethod("GetTypeFromHandle", typ341))
11265
Typ = GetType(System.Type).GetMethod("GetTypeFromHandle", typ341).ReturnType
11060
11266
EmitStrAddIL.Emit(OpCodes.Stloc, 1)
11061
EmitStrAddIL.MarkSequencePoint(doc3, 852, 1, 852, 100)
11062
Dim locbldr63 As LocalBuilder = EmitStrAddIL.DeclareLocal(GetType(system.Type).MakeArrayType())
11063
locbldr63.SetLocalSymInfo("params")
11267
EmitStrAddIL.MarkSequencePoint(doc3, 871, 1, 871, 100)
11268
Dim locbldr64 As LocalBuilder = EmitStrAddIL.DeclareLocal(GetType(system.Type).MakeArrayType())
11269
locbldr64.SetLocalSymInfo("params")
11064
11270
EmitStrAddIL.Emit(OpCodes.Ldc_I4, CInt(2))
11065
11271
Typ = GetType(System.Int32)
11066
11272
EmitStrAddIL.Emit(OpCodes.Conv_U)
11067
11273
EmitStrAddIL.Emit(OpCodes.Newarr, GetType(System.Type))
11068
11274
EmitStrAddIL.Emit(OpCodes.Stloc, 2)
11069
EmitStrAddIL.MarkSequencePoint(doc3, 853, 1, 853, 100)
11275
EmitStrAddIL.MarkSequencePoint(doc3, 872, 1, 872, 100)
11070
11276
EmitStrAddIL.Emit(OpCodes.Ldloc, 2)
11071
11277
Typ = GetType(system.Type).MakeArrayType()
11072
11278
Typ02 = Typ
11075
11281
EmitStrAddIL.Emit(OpCodes.Conv_U)
11076
11282
Typ = Typ02
11077
11283
EmitStrAddIL.Emit(OpCodes.Ldtoken, GetType(System.String))
11078
Dim typ326 As Type() = {GetType(System.RuntimeTypeHandle)}
11079
EmitStrAddIL.Emit(OpCodes.Call, GetType(System.Type).GetMethod("GetTypeFromHandle", typ326))
11080
Typ = GetType(System.Type).GetMethod("GetTypeFromHandle", typ326).ReturnType
11284
Dim typ342 As Type() = {GetType(System.RuntimeTypeHandle)}
11285
EmitStrAddIL.Emit(OpCodes.Call, GetType(System.Type).GetMethod("GetTypeFromHandle", typ342))
11286
Typ = GetType(System.Type).GetMethod("GetTypeFromHandle", typ342).ReturnType
11081
11287
EmitStrAddIL.Emit(OpCodes.Stelem, GetType(system.Type).MakeArrayType().GetElementType())
11082
EmitStrAddIL.MarkSequencePoint(doc3, 854, 1, 854, 100)
11288
EmitStrAddIL.MarkSequencePoint(doc3, 873, 1, 873, 100)
11083
11289
EmitStrAddIL.Emit(OpCodes.Ldloc, 2)
11084
11290
Typ = GetType(system.Type).MakeArrayType()
11085
11291
Typ02 = Typ
11088
11294
EmitStrAddIL.Emit(OpCodes.Conv_U)
11089
11295
Typ = Typ02
11090
11296
EmitStrAddIL.Emit(OpCodes.Ldtoken, GetType(System.String))
11091
Dim typ327 As Type() = {GetType(System.RuntimeTypeHandle)}
11092
EmitStrAddIL.Emit(OpCodes.Call, GetType(System.Type).GetMethod("GetTypeFromHandle", typ327))
11093
Typ = GetType(System.Type).GetMethod("GetTypeFromHandle", typ327).ReturnType
11297
Dim typ343 As Type() = {GetType(System.RuntimeTypeHandle)}
11298
EmitStrAddIL.Emit(OpCodes.Call, GetType(System.Type).GetMethod("GetTypeFromHandle", typ343))
11299
Typ = GetType(System.Type).GetMethod("GetTypeFromHandle", typ343).ReturnType
11094
11300
EmitStrAddIL.Emit(OpCodes.Stelem, GetType(system.Type).MakeArrayType().GetElementType())
11095
EmitStrAddIL.MarkSequencePoint(doc3, 855, 1, 855, 100)
11096
Dim locbldr64 As LocalBuilder = EmitStrAddIL.DeclareLocal(GetType(MethodInfo))
11097
locbldr64.SetLocalSymInfo("met")
11098
Dim typ328(-1) As Type
11301
EmitStrAddIL.MarkSequencePoint(doc3, 874, 1, 874, 100)
11302
Dim locbldr65 As LocalBuilder = EmitStrAddIL.DeclareLocal(GetType(MethodInfo))
11303
locbldr65.SetLocalSymInfo("met")
11304
Dim typ344(-1) As Type
11099
11305
EmitStrAddIL.Emit(OpCodes.Ldloc, 1)
11100
11306
Typ = GetType(System.Type)
11101
11307
Typ03 = Typ
11102
11308
EmitStrAddIL.Emit(OpCodes.Ldstr, "Concat")
11103
11309
Typ = GetType(System.String)
11104
ReDim Preserve typ328(UBound(typ328) + 1)
11105
typ328(UBound(typ328)) = Typ
11310
ReDim Preserve typ344(UBound(typ344) + 1)
11311
typ344(UBound(typ344)) = Typ
11106
11312
EmitStrAddIL.Emit(OpCodes.Ldloc, 2)
11107
11313
Typ = GetType(system.Type).MakeArrayType()
11108
ReDim Preserve typ328(UBound(typ328) + 1)
11109
typ328(UBound(typ328)) = Typ
11110
EmitStrAddIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("GetMethod", typ328))
11111
Typ = Typ03.GetMethod("GetMethod", typ328).ReturnType
11314
ReDim Preserve typ344(UBound(typ344) + 1)
11315
typ344(UBound(typ344)) = Typ
11316
EmitStrAddIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("GetMethod", typ344))
11317
Typ = Typ03.GetMethod("GetMethod", typ344).ReturnType
11112
11318
EmitStrAddIL.Emit(OpCodes.Stloc, 3)
11113
EmitStrAddIL.MarkSequencePoint(doc3, 856, 1, 856, 100)
11114
Dim typ329(-1) As Type
11319
EmitStrAddIL.MarkSequencePoint(doc3, 875, 1, 875, 100)
11320
Dim typ345(-1) As Type
11115
11321
EmitStrAddIL.Emit(OpCodes.Ldstr, "call")
11116
11322
Typ = GetType(System.String)
11117
ReDim Preserve typ329(UBound(typ329) + 1)
11118
typ329(UBound(typ329)) = Typ
11119
EmitStrAddIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ329))
11120
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ329).ReturnType
11323
ReDim Preserve typ345(UBound(typ345) + 1)
11324
typ345(UBound(typ345)) = Typ
11325
EmitStrAddIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ345))
11326
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ345).ReturnType
11121
11327
EmitStrAddIL.Emit(OpCodes.Stloc, 0)
11122
EmitStrAddIL.MarkSequencePoint(doc3, 857, 1, 857, 100)
11123
Dim typ330(-1) As Type
11328
EmitStrAddIL.MarkSequencePoint(doc3, 876, 1, 876, 100)
11329
Dim typ346(-1) As Type
11124
11330
EmitStrAddIL.Emit(OpCodes.Ldsfld, ILGen)
11125
11331
Typ = ILGen.FieldType
11126
11332
Typ03 = Typ
11127
11333
EmitStrAddIL.Emit(OpCodes.Ldloc, 0)
11128
11334
Typ = GetType(OpCode)
11129
ReDim Preserve typ330(UBound(typ330) + 1)
11130
typ330(UBound(typ330)) = Typ
11335
ReDim Preserve typ346(UBound(typ346) + 1)
11336
typ346(UBound(typ346)) = Typ
11131
11337
EmitStrAddIL.Emit(OpCodes.Ldloc, 3)
11132
11338
Typ = GetType(MethodInfo)
11133
ReDim Preserve typ330(UBound(typ330) + 1)
11134
typ330(UBound(typ330)) = Typ
11135
EmitStrAddIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ330))
11136
Typ = Typ03.GetMethod("Emit", typ330).ReturnType
11339
ReDim Preserve typ346(UBound(typ346) + 1)
11340
typ346(UBound(typ346)) = Typ
11341
EmitStrAddIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ346))
11342
Typ = Typ03.GetMethod("Emit", typ346).ReturnType
11137
11343
If Typ.ToString() = GetType(System.Void).ToString() Then
11138
11344
11139
11345
Else
11140
11346
EmitStrAddIL.Emit(OpCodes.Pop)
11141
11347
End If
11142
EmitStrAddIL.MarkSequencePoint(doc3, 858, 1, 858, 100)
11348
EmitStrAddIL.MarkSequencePoint(doc3, 877, 1, 877, 100)
11143
11349
EmitStrAddIL.Emit(OpCodes.Ret)
11144
Dim typ331(-1) As Type
11145
ReDim Preserve typ331(UBound(typ331) + 1)
11146
typ331(UBound(typ331)) = GetType(System.Single)
11147
Dim EmitLdcR4 As MethodBuilder = ILEmitter.DefineMethod("EmitLdcR4", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ331)
11350
Dim typ347(-1) As Type
11351
ReDim Preserve typ347(UBound(typ347) + 1)
11352
typ347(UBound(typ347)) = GetType(System.Single)
11353
Dim EmitLdcR4 As MethodBuilder = ILEmitter.DefineMethod("EmitLdcR4", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ347)
11148
11354
Dim EmitLdcR4IL As ILGenerator = EmitLdcR4.GetILGenerator()
11149
11355
Dim EmitLdcR4param01 As ParameterBuilder = EmitLdcR4.DefineParameter(1, ParameterAttributes.None, "num")
11150
EmitLdcR4IL.MarkSequencePoint(doc3, 861, 1, 861, 100)
11151
Dim locbldr65 As LocalBuilder = EmitLdcR4IL.DeclareLocal(GetType(OpCode))
11152
locbldr65.SetLocalSymInfo("op")
11153
EmitLdcR4IL.MarkSequencePoint(doc3, 862, 1, 862, 100)
11154
Dim typ332(-1) As Type
11356
EmitLdcR4IL.MarkSequencePoint(doc3, 880, 1, 880, 100)
11357
Dim locbldr66 As LocalBuilder = EmitLdcR4IL.DeclareLocal(GetType(OpCode))
11358
locbldr66.SetLocalSymInfo("op")
11359
EmitLdcR4IL.MarkSequencePoint(doc3, 881, 1, 881, 100)
11360
Dim typ348(-1) As Type
11155
11361
EmitLdcR4IL.Emit(OpCodes.Ldstr, "ldc.r4")
11156
11362
Typ = GetType(System.String)
11157
ReDim Preserve typ332(UBound(typ332) + 1)
11158
typ332(UBound(typ332)) = Typ
11159
EmitLdcR4IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ332))
11160
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ332).ReturnType
11363
ReDim Preserve typ348(UBound(typ348) + 1)
11364
typ348(UBound(typ348)) = Typ
11365
EmitLdcR4IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ348))
11366
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ348).ReturnType
11161
11367
EmitLdcR4IL.Emit(OpCodes.Stloc, 0)
11162
EmitLdcR4IL.MarkSequencePoint(doc3, 863, 1, 863, 100)
11163
Dim typ333(-1) As Type
11368
EmitLdcR4IL.MarkSequencePoint(doc3, 882, 1, 882, 100)
11369
Dim typ349(-1) As Type
11164
11370
EmitLdcR4IL.Emit(OpCodes.Ldsfld, ILGen)
11165
11371
Typ = ILGen.FieldType
11166
11372
Typ03 = Typ
11167
11373
EmitLdcR4IL.Emit(OpCodes.Ldloc, 0)
11168
11374
Typ = GetType(OpCode)
11169
ReDim Preserve typ333(UBound(typ333) + 1)
11170
typ333(UBound(typ333)) = Typ
11375
ReDim Preserve typ349(UBound(typ349) + 1)
11376
typ349(UBound(typ349)) = Typ
11171
11377
EmitLdcR4IL.Emit(OpCodes.Ldarg, 0)
11172
11378
Typ = GetType(System.Single)
11173
ReDim Preserve typ333(UBound(typ333) + 1)
11174
typ333(UBound(typ333)) = Typ
11175
EmitLdcR4IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ333))
11176
Typ = Typ03.GetMethod("Emit", typ333).ReturnType
11379
ReDim Preserve typ349(UBound(typ349) + 1)
11380
typ349(UBound(typ349)) = Typ
11381
EmitLdcR4IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ349))
11382
Typ = Typ03.GetMethod("Emit", typ349).ReturnType
11177
11383
If Typ.ToString() = GetType(System.Void).ToString() Then
11178
11384
11179
11385
Else
11180
11386
EmitLdcR4IL.Emit(OpCodes.Pop)
11181
11387
End If
11182
EmitLdcR4IL.MarkSequencePoint(doc3, 864, 1, 864, 100)
11388
EmitLdcR4IL.MarkSequencePoint(doc3, 883, 1, 883, 100)
11183
11389
EmitLdcR4IL.Emit(OpCodes.Ret)
11184
Dim typ334(-1) As Type
11185
ReDim Preserve typ334(UBound(typ334) + 1)
11186
typ334(UBound(typ334)) = GetType(System.Double)
11187
Dim EmitLdcR8 As MethodBuilder = ILEmitter.DefineMethod("EmitLdcR8", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ334)
11390
Dim typ350(-1) As Type
11391
ReDim Preserve typ350(UBound(typ350) + 1)
11392
typ350(UBound(typ350)) = GetType(System.Double)
11393
Dim EmitLdcR8 As MethodBuilder = ILEmitter.DefineMethod("EmitLdcR8", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ350)
11188
11394
Dim EmitLdcR8IL As ILGenerator = EmitLdcR8.GetILGenerator()
11189
11395
Dim EmitLdcR8param01 As ParameterBuilder = EmitLdcR8.DefineParameter(1, ParameterAttributes.None, "num")
11190
EmitLdcR8IL.MarkSequencePoint(doc3, 867, 1, 867, 100)
11191
Dim locbldr66 As LocalBuilder = EmitLdcR8IL.DeclareLocal(GetType(OpCode))
11192
locbldr66.SetLocalSymInfo("op")
11193
EmitLdcR8IL.MarkSequencePoint(doc3, 868, 1, 868, 100)
11194
Dim typ335(-1) As Type
11396
EmitLdcR8IL.MarkSequencePoint(doc3, 886, 1, 886, 100)
11397
Dim locbldr67 As LocalBuilder = EmitLdcR8IL.DeclareLocal(GetType(OpCode))
11398
locbldr67.SetLocalSymInfo("op")
11399
EmitLdcR8IL.MarkSequencePoint(doc3, 887, 1, 887, 100)
11400
Dim typ351(-1) As Type
11195
11401
EmitLdcR8IL.Emit(OpCodes.Ldstr, "ldc.r8")
11196
11402
Typ = GetType(System.String)
11197
ReDim Preserve typ335(UBound(typ335) + 1)
11198
typ335(UBound(typ335)) = Typ
11199
EmitLdcR8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ335))
11200
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ335).ReturnType
11403
ReDim Preserve typ351(UBound(typ351) + 1)
11404
typ351(UBound(typ351)) = Typ
11405
EmitLdcR8IL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ351))
11406
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ351).ReturnType
11201
11407
EmitLdcR8IL.Emit(OpCodes.Stloc, 0)
11202
EmitLdcR8IL.MarkSequencePoint(doc3, 869, 1, 869, 100)
11203
Dim typ336(-1) As Type
11408
EmitLdcR8IL.MarkSequencePoint(doc3, 888, 1, 888, 100)
11409
Dim typ352(-1) As Type
11204
11410
EmitLdcR8IL.Emit(OpCodes.Ldsfld, ILGen)
11205
11411
Typ = ILGen.FieldType
11206
11412
Typ03 = Typ
11207
11413
EmitLdcR8IL.Emit(OpCodes.Ldloc, 0)
11208
11414
Typ = GetType(OpCode)
11209
ReDim Preserve typ336(UBound(typ336) + 1)
11210
typ336(UBound(typ336)) = Typ
11415
ReDim Preserve typ352(UBound(typ352) + 1)
11416
typ352(UBound(typ352)) = Typ
11211
11417
EmitLdcR8IL.Emit(OpCodes.Ldarg, 0)
11212
11418
Typ = GetType(System.Double)
11213
ReDim Preserve typ336(UBound(typ336) + 1)
11214
typ336(UBound(typ336)) = Typ
11215
EmitLdcR8IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ336))
11216
Typ = Typ03.GetMethod("Emit", typ336).ReturnType
11419
ReDim Preserve typ352(UBound(typ352) + 1)
11420
typ352(UBound(typ352)) = Typ
11421
EmitLdcR8IL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ352))
11422
Typ = Typ03.GetMethod("Emit", typ352).ReturnType
11217
11423
If Typ.ToString() = GetType(System.Void).ToString() Then
11218
11424
11219
11425
Else
11220
11426
EmitLdcR8IL.Emit(OpCodes.Pop)
11221
11427
End If
11222
EmitLdcR8IL.MarkSequencePoint(doc3, 870, 1, 870, 100)
11428
EmitLdcR8IL.MarkSequencePoint(doc3, 889, 1, 889, 100)
11223
11429
EmitLdcR8IL.Emit(OpCodes.Ret)
11224
Dim typ337(-1) As Type
11225
ReDim Preserve typ337(UBound(typ337) + 1)
11226
typ337(UBound(typ337)) = GetType(System.Boolean)
11227
Dim EmitLdcBool As MethodBuilder = ILEmitter.DefineMethod("EmitLdcBool", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ337)
11430
Dim typ353(-1) As Type
11431
ReDim Preserve typ353(UBound(typ353) + 1)
11432
typ353(UBound(typ353)) = GetType(System.Boolean)
11433
Dim EmitLdcBool As MethodBuilder = ILEmitter.DefineMethod("EmitLdcBool", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ353)
11228
11434
Dim EmitLdcBoolIL As ILGenerator = EmitLdcBool.GetILGenerator()
11229
11435
Dim EmitLdcBoolparam01 As ParameterBuilder = EmitLdcBool.DefineParameter(1, ParameterAttributes.None, "b")
11230
EmitLdcBoolIL.MarkSequencePoint(doc3, 873, 1, 873, 100)
11231
Dim locbldr67 As LocalBuilder = EmitLdcBoolIL.DeclareLocal(GetType(OpCode))
11232
locbldr67.SetLocalSymInfo("op")
11233
EmitLdcBoolIL.MarkSequencePoint(doc3, 874, 1, 874, 100)
11436
EmitLdcBoolIL.MarkSequencePoint(doc3, 892, 1, 892, 100)
11437
Dim locbldr68 As LocalBuilder = EmitLdcBoolIL.DeclareLocal(GetType(OpCode))
11438
locbldr68.SetLocalSymInfo("op")
11439
EmitLdcBoolIL.MarkSequencePoint(doc3, 893, 1, 893, 100)
11234
11440
EmitLdcBoolIL.Emit(OpCodes.Ldarg, 0)
11235
11441
Typ = GetType(System.Boolean)
11236
11442
EmitLdcBoolIL.Emit(OpCodes.Ldc_I4, 1)
11241
11447
EmitLdcBoolIL.Emit(OpCodes.Beq, tru225)
11242
11448
EmitLdcBoolIL.Emit(OpCodes.Br, fa225)
11243
11449
EmitLdcBoolIL.MarkLabel(tru225)
11244
EmitLdcBoolIL.MarkSequencePoint(doc3, 875, 1, 875, 100)
11245
Dim typ338(-1) As Type
11450
EmitLdcBoolIL.MarkSequencePoint(doc3, 894, 1, 894, 100)
11451
Dim typ354(-1) As Type
11246
11452
EmitLdcBoolIL.Emit(OpCodes.Ldstr, "ldc.i4.1")
11247
11453
Typ = GetType(System.String)
11248
ReDim Preserve typ338(UBound(typ338) + 1)
11249
typ338(UBound(typ338)) = Typ
11250
EmitLdcBoolIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ338))
11251
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ338).ReturnType
11454
ReDim Preserve typ354(UBound(typ354) + 1)
11455
typ354(UBound(typ354)) = Typ
11456
EmitLdcBoolIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ354))
11457
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ354).ReturnType
11252
11458
EmitLdcBoolIL.Emit(OpCodes.Stloc, 0)
11253
EmitLdcBoolIL.MarkSequencePoint(doc3, 876, 1, 876, 100)
11254
Dim typ339(-1) As Type
11459
EmitLdcBoolIL.MarkSequencePoint(doc3, 895, 1, 895, 100)
11460
Dim typ355(-1) As Type
11255
11461
EmitLdcBoolIL.Emit(OpCodes.Ldsfld, ILGen)
11256
11462
Typ = ILGen.FieldType
11257
11463
Typ03 = Typ
11258
11464
EmitLdcBoolIL.Emit(OpCodes.Ldloc, 0)
11259
11465
Typ = GetType(OpCode)
11260
ReDim Preserve typ339(UBound(typ339) + 1)
11261
typ339(UBound(typ339)) = Typ
11262
EmitLdcBoolIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ339))
11263
Typ = Typ03.GetMethod("Emit", typ339).ReturnType
11466
ReDim Preserve typ355(UBound(typ355) + 1)
11467
typ355(UBound(typ355)) = Typ
11468
EmitLdcBoolIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ355))
11469
Typ = Typ03.GetMethod("Emit", typ355).ReturnType
11264
11470
If Typ.ToString() = GetType(System.Void).ToString() Then
11265
11471
11266
11472
Else
11267
11473
EmitLdcBoolIL.Emit(OpCodes.Pop)
11268
11474
End If
11269
EmitLdcBoolIL.MarkSequencePoint(doc3, 877, 1, 877, 100)
11475
EmitLdcBoolIL.MarkSequencePoint(doc3, 896, 1, 896, 100)
11270
11476
EmitLdcBoolIL.Emit(OpCodes.Br, cont225)
11271
11477
EmitLdcBoolIL.MarkLabel(fa225)
11272
EmitLdcBoolIL.MarkSequencePoint(doc3, 878, 1, 878, 100)
11273
Dim typ340(-1) As Type
11478
EmitLdcBoolIL.MarkSequencePoint(doc3, 897, 1, 897, 100)
11479
Dim typ356(-1) As Type
11274
11480
EmitLdcBoolIL.Emit(OpCodes.Ldstr, "ldc.i4.0")
11275
11481
Typ = GetType(System.String)
11276
ReDim Preserve typ340(UBound(typ340) + 1)
11277
typ340(UBound(typ340)) = Typ
11278
EmitLdcBoolIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ340))
11279
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ340).ReturnType
11482
ReDim Preserve typ356(UBound(typ356) + 1)
11483
typ356(UBound(typ356)) = Typ
11484
EmitLdcBoolIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ356))
11485
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ356).ReturnType
11280
11486
EmitLdcBoolIL.Emit(OpCodes.Stloc, 0)
11281
EmitLdcBoolIL.MarkSequencePoint(doc3, 879, 1, 879, 100)
11282
Dim typ341(-1) As Type
11487
EmitLdcBoolIL.MarkSequencePoint(doc3, 898, 1, 898, 100)
11488
Dim typ357(-1) As Type
11283
11489
EmitLdcBoolIL.Emit(OpCodes.Ldsfld, ILGen)
11284
11490
Typ = ILGen.FieldType
11285
11491
Typ03 = Typ
11286
11492
EmitLdcBoolIL.Emit(OpCodes.Ldloc, 0)
11287
11493
Typ = GetType(OpCode)
11288
ReDim Preserve typ341(UBound(typ341) + 1)
11289
typ341(UBound(typ341)) = Typ
11290
EmitLdcBoolIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ341))
11291
Typ = Typ03.GetMethod("Emit", typ341).ReturnType
11494
ReDim Preserve typ357(UBound(typ357) + 1)
11495
typ357(UBound(typ357)) = Typ
11496
EmitLdcBoolIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ357))
11497
Typ = Typ03.GetMethod("Emit", typ357).ReturnType
11292
11498
If Typ.ToString() = GetType(System.Void).ToString() Then
11293
11499
11294
11500
Else
11295
11501
EmitLdcBoolIL.Emit(OpCodes.Pop)
11296
11502
End If
11297
EmitLdcBoolIL.MarkSequencePoint(doc3, 880, 1, 880, 100)
11503
EmitLdcBoolIL.MarkSequencePoint(doc3, 899, 1, 899, 100)
11298
11504
EmitLdcBoolIL.Emit(OpCodes.Br, cont225)
11299
11505
EmitLdcBoolIL.MarkLabel(cont225)
11300
EmitLdcBoolIL.MarkSequencePoint(doc3, 881, 1, 881, 100)
11506
EmitLdcBoolIL.MarkSequencePoint(doc3, 900, 1, 900, 100)
11301
11507
EmitLdcBoolIL.Emit(OpCodes.Ret)
11302
Dim typ342(-1) As Type
11303
ReDim Preserve typ342(UBound(typ342) + 1)
11304
typ342(UBound(typ342)) = GetType(System.Char)
11305
Dim EmitLdcChar As MethodBuilder = ILEmitter.DefineMethod("EmitLdcChar", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ342)
11508
Dim typ358(-1) As Type
11509
ReDim Preserve typ358(UBound(typ358) + 1)
11510
typ358(UBound(typ358)) = GetType(System.Char)
11511
Dim EmitLdcChar As MethodBuilder = ILEmitter.DefineMethod("EmitLdcChar", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ358)
11306
11512
Dim EmitLdcCharIL As ILGenerator = EmitLdcChar.GetILGenerator()
11307
11513
Dim EmitLdcCharparam01 As ParameterBuilder = EmitLdcChar.DefineParameter(1, ParameterAttributes.None, "c")
11308
EmitLdcCharIL.MarkSequencePoint(doc3, 884, 1, 884, 100)
11309
Dim locbldr68 As LocalBuilder = EmitLdcCharIL.DeclareLocal(GetType(OpCode))
11310
locbldr68.SetLocalSymInfo("op")
11311
EmitLdcCharIL.MarkSequencePoint(doc3, 885, 1, 885, 100)
11312
Dim typ343(-1) As Type
11514
EmitLdcCharIL.MarkSequencePoint(doc3, 903, 1, 903, 100)
11515
Dim locbldr69 As LocalBuilder = EmitLdcCharIL.DeclareLocal(GetType(OpCode))
11516
locbldr69.SetLocalSymInfo("op")
11517
EmitLdcCharIL.MarkSequencePoint(doc3, 904, 1, 904, 100)
11518
Dim typ359(-1) As Type
11313
11519
EmitLdcCharIL.Emit(OpCodes.Ldstr, "ldc.i4")
11314
11520
Typ = GetType(System.String)
11315
ReDim Preserve typ343(UBound(typ343) + 1)
11316
typ343(UBound(typ343)) = Typ
11317
EmitLdcCharIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ343))
11318
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ343).ReturnType
11521
ReDim Preserve typ359(UBound(typ359) + 1)
11522
typ359(UBound(typ359)) = Typ
11523
EmitLdcCharIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ359))
11524
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ359).ReturnType
11319
11525
EmitLdcCharIL.Emit(OpCodes.Stloc, 0)
11320
EmitLdcCharIL.MarkSequencePoint(doc3, 886, 1, 886, 100)
11321
Dim typ344(-1) As Type
11526
EmitLdcCharIL.MarkSequencePoint(doc3, 905, 1, 905, 100)
11527
Dim typ360(-1) As Type
11322
11528
EmitLdcCharIL.Emit(OpCodes.Ldsfld, ILGen)
11323
11529
Typ = ILGen.FieldType
11324
11530
Typ03 = Typ
11325
11531
EmitLdcCharIL.Emit(OpCodes.Ldloc, 0)
11326
11532
Typ = GetType(OpCode)
11327
ReDim Preserve typ344(UBound(typ344) + 1)
11328
typ344(UBound(typ344)) = Typ
11533
ReDim Preserve typ360(UBound(typ360) + 1)
11534
typ360(UBound(typ360)) = Typ
11329
11535
EmitLdcCharIL.Emit(OpCodes.Ldarg, 0)
11330
11536
Typ = GetType(System.Char)
11331
Dim typ345 As Type() = {Typ}
11332
EmitLdcCharIL.Emit(OpCodes.Call, GetType(System.Convert).GetMethod("ToInt32", typ345))
11333
Typ = GetType(System.Convert).GetMethod("ToInt32", typ345).ReturnType
11334
ReDim Preserve typ344(UBound(typ344) + 1)
11335
typ344(UBound(typ344)) = Typ
11336
EmitLdcCharIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ344))
11337
Typ = Typ03.GetMethod("Emit", typ344).ReturnType
11537
Dim typ361 As Type() = {Typ}
11538
EmitLdcCharIL.Emit(OpCodes.Call, GetType(System.Convert).GetMethod("ToInt32", typ361))
11539
Typ = GetType(System.Convert).GetMethod("ToInt32", typ361).ReturnType
11540
ReDim Preserve typ360(UBound(typ360) + 1)
11541
typ360(UBound(typ360)) = Typ
11542
EmitLdcCharIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ360))
11543
Typ = Typ03.GetMethod("Emit", typ360).ReturnType
11338
11544
If Typ.ToString() = GetType(System.Void).ToString() Then
11339
11545
11340
11546
Else
11341
11547
EmitLdcCharIL.Emit(OpCodes.Pop)
11342
11548
End If
11343
EmitLdcCharIL.MarkSequencePoint(doc3, 887, 1, 887, 100)
11549
EmitLdcCharIL.MarkSequencePoint(doc3, 906, 1, 906, 100)
11344
11550
EmitLdcCharIL.Emit(OpCodes.Ret)
11345
Dim typ346(-1) As Type
11346
ReDim Preserve typ346(UBound(typ346) + 1)
11347
typ346(UBound(typ346)) = GetType(ConstructorInfo)
11348
Dim EmitNewobj As MethodBuilder = ILEmitter.DefineMethod("EmitNewobj", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ346)
11551
Dim EmitLdnull As MethodBuilder = ILEmitter.DefineMethod("EmitLdnull", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), Type.EmptyTypes)
11552
Dim EmitLdnullIL As ILGenerator = EmitLdnull.GetILGenerator()
11553
EmitLdnullIL.MarkSequencePoint(doc3, 909, 1, 909, 100)
11554
Dim locbldr70 As LocalBuilder = EmitLdnullIL.DeclareLocal(GetType(OpCode))
11555
locbldr70.SetLocalSymInfo("op")
11556
EmitLdnullIL.MarkSequencePoint(doc3, 910, 1, 910, 100)
11557
Dim typ362(-1) As Type
11558
EmitLdnullIL.Emit(OpCodes.Ldstr, "ldnull")
11559
Typ = GetType(System.String)
11560
ReDim Preserve typ362(UBound(typ362) + 1)
11561
typ362(UBound(typ362)) = Typ
11562
EmitLdnullIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ362))
11563
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ362).ReturnType
11564
EmitLdnullIL.Emit(OpCodes.Stloc, 0)
11565
EmitLdnullIL.MarkSequencePoint(doc3, 911, 1, 911, 100)
11566
Dim typ363(-1) As Type
11567
EmitLdnullIL.Emit(OpCodes.Ldsfld, ILGen)
11568
Typ = ILGen.FieldType
11569
Typ03 = Typ
11570
EmitLdnullIL.Emit(OpCodes.Ldloc, 0)
11571
Typ = GetType(OpCode)
11572
ReDim Preserve typ363(UBound(typ363) + 1)
11573
typ363(UBound(typ363)) = Typ
11574
EmitLdnullIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ363))
11575
Typ = Typ03.GetMethod("Emit", typ363).ReturnType
11576
If Typ.ToString() = GetType(System.Void).ToString() Then
11577
11578
Else
11579
EmitLdnullIL.Emit(OpCodes.Pop)
11580
End If
11581
EmitLdnullIL.MarkSequencePoint(doc3, 912, 1, 912, 100)
11582
EmitLdnullIL.Emit(OpCodes.Ret)
11583
Dim typ364(-1) As Type
11584
ReDim Preserve typ364(UBound(typ364) + 1)
11585
typ364(UBound(typ364)) = GetType(ConstructorInfo)
11586
Dim EmitNewobj As MethodBuilder = ILEmitter.DefineMethod("EmitNewobj", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ364)
11349
11587
Dim EmitNewobjIL As ILGenerator = EmitNewobj.GetILGenerator()
11350
11588
Dim EmitNewobjparam01 As ParameterBuilder = EmitNewobj.DefineParameter(1, ParameterAttributes.None, "c")
11351
EmitNewobjIL.MarkSequencePoint(doc3, 890, 1, 890, 100)
11352
Dim locbldr69 As LocalBuilder = EmitNewobjIL.DeclareLocal(GetType(OpCode))
11353
locbldr69.SetLocalSymInfo("op")
11354
EmitNewobjIL.MarkSequencePoint(doc3, 891, 1, 891, 100)
11355
Dim typ347(-1) As Type
11589
EmitNewobjIL.MarkSequencePoint(doc3, 915, 1, 915, 100)
11590
Dim locbldr71 As LocalBuilder = EmitNewobjIL.DeclareLocal(GetType(OpCode))
11591
locbldr71.SetLocalSymInfo("op")
11592
EmitNewobjIL.MarkSequencePoint(doc3, 916, 1, 916, 100)
11593
Dim typ365(-1) As Type
11356
11594
EmitNewobjIL.Emit(OpCodes.Ldstr, "newobj")
11357
11595
Typ = GetType(System.String)
11358
ReDim Preserve typ347(UBound(typ347) + 1)
11359
typ347(UBound(typ347)) = Typ
11360
EmitNewobjIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ347))
11361
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ347).ReturnType
11596
ReDim Preserve typ365(UBound(typ365) + 1)
11597
typ365(UBound(typ365)) = Typ
11598
EmitNewobjIL.Emit(OpCodes.Call, asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ365))
11599
Typ = asm.GetType("dylan.NET.Reflection.InstructionHelper").GetMethod("getOPCode", typ365).ReturnType
11362
11600
EmitNewobjIL.Emit(OpCodes.Stloc, 0)
11363
EmitNewobjIL.MarkSequencePoint(doc3, 892, 1, 892, 100)
11364
Dim typ348(-1) As Type
11601
EmitNewobjIL.MarkSequencePoint(doc3, 917, 1, 917, 100)
11602
Dim typ366(-1) As Type
11365
11603
EmitNewobjIL.Emit(OpCodes.Ldsfld, ILGen)
11366
11604
Typ = ILGen.FieldType
11367
11605
Typ03 = Typ
11368
11606
EmitNewobjIL.Emit(OpCodes.Ldloc, 0)
11369
11607
Typ = GetType(OpCode)
11370
ReDim Preserve typ348(UBound(typ348) + 1)
11371
typ348(UBound(typ348)) = Typ
11608
ReDim Preserve typ366(UBound(typ366) + 1)
11609
typ366(UBound(typ366)) = Typ
11372
11610
EmitNewobjIL.Emit(OpCodes.Ldarg, 0)
11373
11611
Typ = GetType(ConstructorInfo)
11374
ReDim Preserve typ348(UBound(typ348) + 1)
11375
typ348(UBound(typ348)) = Typ
11376
EmitNewobjIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ348))
11377
Typ = Typ03.GetMethod("Emit", typ348).ReturnType
11612
ReDim Preserve typ366(UBound(typ366) + 1)
11613
typ366(UBound(typ366)) = Typ
11614
EmitNewobjIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Emit", typ366))
11615
Typ = Typ03.GetMethod("Emit", typ366).ReturnType
11378
11616
If Typ.ToString() = GetType(System.Void).ToString() Then
11379
11617
11380
11618
Else
11381
11619
EmitNewobjIL.Emit(OpCodes.Pop)
11382
11620
End If
11383
EmitNewobjIL.MarkSequencePoint(doc3, 893, 1, 893, 100)
11621
EmitNewobjIL.MarkSequencePoint(doc3, 918, 1, 918, 100)
11384
11622
EmitNewobjIL.Emit(OpCodes.Ret)
11385
Dim typ349(-1) As Type
11386
ReDim Preserve typ349(UBound(typ349) + 1)
11387
typ349(UBound(typ349)) = GetType(System.String)
11388
ReDim Preserve typ349(UBound(typ349) + 1)
11389
typ349(UBound(typ349)) = GetType(System.Type)
11390
Dim DeclVar As MethodBuilder = ILEmitter.DefineMethod("DeclVar", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ349)
11623
Dim typ367(-1) As Type
11624
ReDim Preserve typ367(UBound(typ367) + 1)
11625
typ367(UBound(typ367)) = GetType(System.String)
11626
ReDim Preserve typ367(UBound(typ367) + 1)
11627
typ367(UBound(typ367)) = GetType(System.Type)
11628
Dim DeclVar As MethodBuilder = ILEmitter.DefineMethod("DeclVar", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ367)
11391
11629
Dim DeclVarIL As ILGenerator = DeclVar.GetILGenerator()
11392
11630
Dim DeclVarparam01 As ParameterBuilder = DeclVar.DefineParameter(1, ParameterAttributes.None, "name")
11393
11631
Dim DeclVarparam02 As ParameterBuilder = DeclVar.DefineParameter(2, ParameterAttributes.None, "typ")
11394
DeclVarIL.MarkSequencePoint(doc3, 896, 1, 896, 100)
11395
Dim locbldr70 As LocalBuilder = DeclVarIL.DeclareLocal(GetType(LocalBuilder))
11396
locbldr70.SetLocalSymInfo("lb")
11397
Dim typ350(-1) As Type
11632
DeclVarIL.MarkSequencePoint(doc3, 921, 1, 921, 100)
11633
Dim locbldr72 As LocalBuilder = DeclVarIL.DeclareLocal(GetType(LocalBuilder))
11634
locbldr72.SetLocalSymInfo("lb")
11635
Dim typ368(-1) As Type
11398
11636
DeclVarIL.Emit(OpCodes.Ldsfld, ILGen)
11399
11637
Typ = ILGen.FieldType
11400
11638
Typ03 = Typ
11401
11639
DeclVarIL.Emit(OpCodes.Ldarg, 1)
11402
11640
Typ = GetType(System.Type)
11403
ReDim Preserve typ350(UBound(typ350) + 1)
11404
typ350(UBound(typ350)) = Typ
11405
DeclVarIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("DeclareLocal", typ350))
11406
Typ = Typ03.GetMethod("DeclareLocal", typ350).ReturnType
11641
ReDim Preserve typ368(UBound(typ368) + 1)
11642
typ368(UBound(typ368)) = Typ
11643
DeclVarIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("DeclareLocal", typ368))
11644
Typ = Typ03.GetMethod("DeclareLocal", typ368).ReturnType
11407
11645
DeclVarIL.Emit(OpCodes.Stloc, 0)
11408
DeclVarIL.MarkSequencePoint(doc3, 897, 1, 897, 100)
11646
DeclVarIL.MarkSequencePoint(doc3, 922, 1, 922, 100)
11409
11647
DeclVarIL.Emit(OpCodes.Ldsfld, DebugFlg)
11410
11648
Typ = DebugFlg.FieldType
11411
11649
DeclVarIL.Emit(OpCodes.Ldc_I4, 1)
11416
11654
DeclVarIL.Emit(OpCodes.Beq, tru226)
11417
11655
DeclVarIL.Emit(OpCodes.Br, fa226)
11418
11656
DeclVarIL.MarkLabel(tru226)
11419
DeclVarIL.MarkSequencePoint(doc3, 898, 1, 898, 100)
11420
Dim typ351(-1) As Type
11657
DeclVarIL.MarkSequencePoint(doc3, 923, 1, 923, 100)
11658
Dim typ369(-1) As Type
11421
11659
DeclVarIL.Emit(OpCodes.Ldloc, 0)
11422
11660
Typ = GetType(LocalBuilder)
11423
11661
Typ03 = Typ
11424
11662
DeclVarIL.Emit(OpCodes.Ldarg, 0)
11425
11663
Typ = GetType(System.String)
11426
ReDim Preserve typ351(UBound(typ351) + 1)
11427
typ351(UBound(typ351)) = Typ
11428
DeclVarIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("SetLocalSymInfo", typ351))
11429
Typ = Typ03.GetMethod("SetLocalSymInfo", typ351).ReturnType
11664
ReDim Preserve typ369(UBound(typ369) + 1)
11665
typ369(UBound(typ369)) = Typ
11666
DeclVarIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("SetLocalSymInfo", typ369))
11667
Typ = Typ03.GetMethod("SetLocalSymInfo", typ369).ReturnType
11430
11668
If Typ.ToString() = GetType(System.Void).ToString() Then
11431
11669
11432
11670
Else
11433
11671
DeclVarIL.Emit(OpCodes.Pop)
11434
11672
End If
11435
DeclVarIL.MarkSequencePoint(doc3, 899, 1, 899, 100)
11673
DeclVarIL.MarkSequencePoint(doc3, 924, 1, 924, 100)
11436
11674
DeclVarIL.Emit(OpCodes.Br, cont226)
11437
11675
DeclVarIL.MarkLabel(fa226)
11438
11676
DeclVarIL.Emit(OpCodes.Br, cont226)
11439
11677
DeclVarIL.MarkLabel(cont226)
11440
DeclVarIL.MarkSequencePoint(doc3, 900, 1, 900, 100)
11678
DeclVarIL.MarkSequencePoint(doc3, 925, 1, 925, 100)
11441
11679
DeclVarIL.Emit(OpCodes.Ret)
11442
11680
ILEmitter.CreateType()
11443
11681
End Sub
11450
11688
Dim DebugFlg As FieldBuilder = AsmFactory.DefineField("DebugFlg", GetType(System.Boolean), FieldAttributes.Public Or FieldAttributes.Static)
11451
11689
Dim InMethodFlg As FieldBuilder = AsmFactory.DefineField("InMethodFlg", GetType(System.Boolean), FieldAttributes.Public Or FieldAttributes.Static)
11452
11690
Dim ChainFlg As FieldBuilder = AsmFactory.DefineField("ChainFlg", GetType(System.Boolean), FieldAttributes.Public Or FieldAttributes.Static)
11691
Dim PopFlg As FieldBuilder = AsmFactory.DefineField("PopFlg", GetType(System.Boolean), FieldAttributes.Public Or FieldAttributes.Static)
11453
11692
Dim AsmNameStr As FieldBuilder = AsmFactory.DefineField("AsmNameStr", GetType(AssemblyName), FieldAttributes.Public Or FieldAttributes.Static)
11454
11693
Dim AsmB As FieldBuilder = AsmFactory.DefineField("AsmB", GetType(AssemblyBuilder), FieldAttributes.Public Or FieldAttributes.Static)
11455
11694
Dim Type01 As FieldBuilder = AsmFactory.DefineField("Type01", GetType(System.Type), FieldAttributes.Public Or FieldAttributes.Static)
11477
11716
Dim GenParamTyps As FieldBuilder = AsmFactory.DefineField("GenParamTyps", GetType(GenericTypeParameterBuilder).MakeArrayType(), FieldAttributes.Public Or FieldAttributes.Static)
11478
11717
Dim ctor0 As ConstructorBuilder = AsmFactory.DefineConstructor(MethodAttributes.Public Or MethodAttributes.Static,CallingConventions.Standard , Type.EmptyTypes)
11479
11718
Dim ctor0IL As ILGenerator = ctor0.GetILGenerator()
11480
ctor0IL.MarkSequencePoint(doc4, 41, 1, 41, 100)
11481
ctor0IL.Emit(OpCodes.Ldc_I4, 0)
11482
Typ = GetType(System.Boolean)
11483
ctor0IL.Emit(OpCodes.Stsfld, DebugFlg)
11484
11719
ctor0IL.MarkSequencePoint(doc4, 42, 1, 42, 100)
11485
11720
ctor0IL.Emit(OpCodes.Ldc_I4, 0)
11486
11721
Typ = GetType(System.Boolean)
11722
ctor0IL.Emit(OpCodes.Stsfld, DebugFlg)
11723
ctor0IL.MarkSequencePoint(doc4, 43, 1, 43, 100)
11724
ctor0IL.Emit(OpCodes.Ldc_I4, 0)
11725
Typ = GetType(System.Boolean)
11487
11726
ctor0IL.Emit(OpCodes.Stsfld, ChainFlg)
11488
ctor0IL.MarkSequencePoint(doc4, 43, 1, 43, 100)
11727
ctor0IL.MarkSequencePoint(doc4, 44, 1, 44, 100)
11728
ctor0IL.Emit(OpCodes.Ldc_I4, 0)
11729
Typ = GetType(System.Boolean)
11730
ctor0IL.Emit(OpCodes.Stsfld, PopFlg)
11731
ctor0IL.MarkSequencePoint(doc4, 45, 1, 45, 100)
11489
11732
ctor0IL.Emit(OpCodes.Ldc_I4, 0)
11490
11733
Typ = GetType(System.Boolean)
11491
11734
ctor0IL.Emit(OpCodes.Stsfld, InMethodFlg)
11492
ctor0IL.MarkSequencePoint(doc4, 44, 1, 44, 100)
11735
ctor0IL.MarkSequencePoint(doc4, 46, 1, 46, 100)
11493
11736
ctor0IL.Emit(OpCodes.Ldstr, "")
11494
11737
Typ = GetType(System.String)
11495
11738
ctor0IL.Emit(OpCodes.Stsfld, CurnNS)
11496
ctor0IL.MarkSequencePoint(doc4, 45, 1, 45, 100)
11739
ctor0IL.MarkSequencePoint(doc4, 47, 1, 47, 100)
11497
11740
ctor0IL.Emit(OpCodes.Ldstr, "")
11498
11741
Typ = GetType(System.String)
11499
11742
ctor0IL.Emit(OpCodes.Stsfld, DfltNS)
11500
ctor0IL.MarkSequencePoint(doc4, 46, 1, 46, 100)
11743
ctor0IL.MarkSequencePoint(doc4, 48, 1, 48, 100)
11501
11744
ctor0IL.Emit(OpCodes.Ldstr, "")
11502
11745
Typ = GetType(System.String)
11503
11746
ctor0IL.Emit(OpCodes.Stsfld, AsmMode)
11504
ctor0IL.MarkSequencePoint(doc4, 47, 1, 47, 100)
11747
ctor0IL.MarkSequencePoint(doc4, 49, 1, 49, 100)
11505
11748
ctor0IL.Emit(OpCodes.Ldstr, "")
11506
11749
Typ = GetType(System.String)
11507
11750
ctor0IL.Emit(OpCodes.Stsfld, AsmFile)
11508
ctor0IL.MarkSequencePoint(doc4, 48, 1, 48, 100)
11751
ctor0IL.MarkSequencePoint(doc4, 50, 1, 50, 100)
11509
11752
ctor0IL.Emit(OpCodes.Ldc_I4, CInt(0))
11510
11753
Typ = GetType(System.Int32)
11511
11754
ctor0IL.Emit(OpCodes.Conv_U)
11512
11755
ctor0IL.Emit(OpCodes.Newarr, GetType(TypeBuilder))
11513
11756
ctor0IL.Emit(OpCodes.Stsfld, CurnTypList)
11514
ctor0IL.MarkSequencePoint(doc4, 49, 1, 49, 100)
11757
ctor0IL.MarkSequencePoint(doc4, 51, 1, 51, 100)
11515
11758
ctor0IL.Emit(OpCodes.Ldc_I4, CInt(0))
11516
11759
Typ = GetType(System.Int32)
11517
11760
ctor0IL.Emit(OpCodes.Conv_U)
11518
11761
ctor0IL.Emit(OpCodes.Newarr, GetType(System.Type))
11519
11762
ctor0IL.Emit(OpCodes.Stsfld, TypArr)
11520
ctor0IL.MarkSequencePoint(doc4, 50, 1, 50, 100)
11763
ctor0IL.MarkSequencePoint(doc4, 52, 1, 52, 100)
11521
11764
ctor0IL.Emit(OpCodes.Ldc_I4, CInt(0))
11522
11765
Typ = GetType(System.Int32)
11523
11766
ctor0IL.Emit(OpCodes.Conv_U)
11524
11767
ctor0IL.Emit(OpCodes.Newarr, GetType(System.String))
11525
11768
ctor0IL.Emit(OpCodes.Stsfld, GenParamNames)
11526
ctor0IL.MarkSequencePoint(doc4, 51, 1, 51, 100)
11769
ctor0IL.MarkSequencePoint(doc4, 53, 1, 53, 100)
11527
11770
ctor0IL.Emit(OpCodes.Ldc_I4, CInt(0))
11528
11771
Typ = GetType(System.Int32)
11529
11772
ctor0IL.Emit(OpCodes.Conv_U)
11530
11773
ctor0IL.Emit(OpCodes.Newarr, GetType(System.Type))
11531
11774
ctor0IL.Emit(OpCodes.Stsfld, GenParamTyps)
11532
ctor0IL.MarkSequencePoint(doc4, 52, 1, 52, 100)
11775
ctor0IL.MarkSequencePoint(doc4, 54, 1, 54, 100)
11533
11776
ctor0IL.Emit(OpCodes.Ldc_I4, 0)
11534
11777
Typ = GetType(System.Boolean)
11535
11778
ctor0IL.Emit(OpCodes.Stsfld, isNested)
11536
ctor0IL.MarkSequencePoint(doc4, 53, 1, 53, 100)
11779
ctor0IL.MarkSequencePoint(doc4, 55, 1, 55, 100)
11537
11780
ctor0IL.Emit(OpCodes.Ldc_I4, 0)
11538
11781
Typ = GetType(System.Boolean)
11539
11782
ctor0IL.Emit(OpCodes.Stsfld, inClass)
11540
ctor0IL.MarkSequencePoint(doc4, 54, 1, 54, 100)
11783
ctor0IL.MarkSequencePoint(doc4, 56, 1, 56, 100)
11541
11784
ctor0IL.Emit(OpCodes.Ret)
11542
11785
Dim CreateTyp As MethodBuilder = AsmFactory.DefineMethod("CreateTyp", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), Type.EmptyTypes)
11543
11786
Dim CreateTypIL As ILGenerator = CreateTyp.GetILGenerator()
11544
CreateTypIL.MarkSequencePoint(doc4, 57, 1, 57, 100)
11787
CreateTypIL.MarkSequencePoint(doc4, 59, 1, 59, 100)
11545
11788
CreateTypIL.Emit(OpCodes.Ldsfld, CurnTypB)
11546
11789
Typ = CurnTypB.FieldType
11547
11790
Typ03 = Typ
11552
11795
Else
11553
11796
CreateTypIL.Emit(OpCodes.Pop)
11554
11797
End If
11555
CreateTypIL.MarkSequencePoint(doc4, 58, 1, 58, 100)
11798
CreateTypIL.MarkSequencePoint(doc4, 60, 1, 60, 100)
11556
11799
CreateTypIL.Emit(OpCodes.Ret)
11557
11800
Dim InitMtd As MethodBuilder = AsmFactory.DefineMethod("InitMtd", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), Type.EmptyTypes)
11558
11801
Dim InitMtdIL As ILGenerator = InitMtd.GetILGenerator()
11559
InitMtdIL.MarkSequencePoint(doc4, 61, 1, 61, 100)
11560
Dim locbldr71 As LocalBuilder = InitMtdIL.DeclareLocal(GetType(ParameterAttributes))
11561
locbldr71.SetLocalSymInfo("rv")
11802
InitMtdIL.MarkSequencePoint(doc4, 63, 1, 63, 100)
11803
Dim locbldr73 As LocalBuilder = InitMtdIL.DeclareLocal(GetType(ParameterAttributes))
11804
locbldr73.SetLocalSymInfo("rv")
11562
11805
InitMtdIL.Emit(OpCodes.Ldc_I4, CInt(8))
11563
11806
Typ = GetType(System.Int32)
11564
11807
InitMtdIL.Emit(OpCodes.Stloc, 0)
11565
InitMtdIL.MarkSequencePoint(doc4, 62, 1, 62, 100)
11808
InitMtdIL.MarkSequencePoint(doc4, 64, 1, 64, 100)
11566
11809
Dim typ1(-1) As Type
11567
11810
InitMtdIL.Emit(OpCodes.Ldsfld, CurnMetB)
11568
11811
Typ = CurnMetB.FieldType
11586
11829
Else
11587
11830
InitMtdIL.Emit(OpCodes.Pop)
11588
11831
End If
11589
InitMtdIL.MarkSequencePoint(doc4, 63, 1, 63, 100)
11832
InitMtdIL.MarkSequencePoint(doc4, 65, 1, 65, 100)
11590
11833
InitMtdIL.Emit(OpCodes.Ldsfld, CurnMetB)
11591
11834
Typ = CurnMetB.FieldType
11592
11835
Typ03 = Typ
11593
11836
InitMtdIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("GetILGenerator", Type.EmptyTypes))
11594
11837
Typ = Typ03.GetMethod("GetILGenerator", Type.EmptyTypes).ReturnType
11595
11838
InitMtdIL.Emit(OpCodes.Stsfld, CurnILGen)
11596
InitMtdIL.MarkSequencePoint(doc4, 64, 1, 64, 100)
11839
InitMtdIL.MarkSequencePoint(doc4, 66, 1, 66, 100)
11597
11840
InitMtdIL.Emit(OpCodes.Ldsfld, CurnMetB)
11598
11841
Typ = CurnMetB.FieldType
11599
11842
InitMtdIL.Emit(OpCodes.Stsfld, asm.GetType("dylan.NET.Reflection.ILEmitter").GetField("Met"))
11600
InitMtdIL.MarkSequencePoint(doc4, 65, 1, 65, 100)
11843
InitMtdIL.MarkSequencePoint(doc4, 67, 1, 67, 100)
11601
11844
InitMtdIL.Emit(OpCodes.Ldsfld, CurnILGen)
11602
11845
Typ = CurnILGen.FieldType
11603
11846
InitMtdIL.Emit(OpCodes.Stsfld, asm.GetType("dylan.NET.Reflection.ILEmitter").GetField("ILGen"))
11604
InitMtdIL.MarkSequencePoint(doc4, 66, 1, 66, 100)
11847
InitMtdIL.MarkSequencePoint(doc4, 68, 1, 68, 100)
11605
11848
InitMtdIL.Emit(OpCodes.Ldsfld, DebugFlg)
11606
11849
Typ = DebugFlg.FieldType
11607
11850
InitMtdIL.Emit(OpCodes.Stsfld, asm.GetType("dylan.NET.Reflection.ILEmitter").GetField("DebugFlg"))
11608
InitMtdIL.MarkSequencePoint(doc4, 67, 1, 67, 100)
11851
InitMtdIL.MarkSequencePoint(doc4, 69, 1, 69, 100)
11609
11852
InitMtdIL.Emit(OpCodes.Ldc_I4, CInt(-1))
11610
11853
Typ = GetType(System.Int32)
11611
11854
InitMtdIL.Emit(OpCodes.Stsfld, asm.GetType("dylan.NET.Reflection.ILEmitter").GetField("LocInd"))
11612
InitMtdIL.MarkSequencePoint(doc4, 68, 1, 68, 100)
11855
InitMtdIL.MarkSequencePoint(doc4, 70, 1, 70, 100)
11613
11856
InitMtdIL.Emit(OpCodes.Ldsfld, asm.GetType("dylan.NET.Reflection.ILEmitter").GetField("StaticFlg"))
11614
11857
Typ = asm.GetType("dylan.NET.Reflection.ILEmitter").GetField("StaticFlg").FieldType
11615
11858
InitMtdIL.Emit(OpCodes.Ldc_I4, 1)
11620
11863
InitMtdIL.Emit(OpCodes.Beq, tru227)
11621
11864
InitMtdIL.Emit(OpCodes.Br, fa227)
11622
11865
InitMtdIL.MarkLabel(tru227)
11623
InitMtdIL.MarkSequencePoint(doc4, 69, 1, 69, 100)
11624
InitMtdIL.Emit(OpCodes.Ldc_I4, CInt(-1))
11625
Typ = GetType(System.Int32)
11626
InitMtdIL.Emit(OpCodes.Stsfld, asm.GetType("dylan.NET.Reflection.ILEmitter").GetField("ArgInd"))
11627
InitMtdIL.MarkSequencePoint(doc4, 70, 1, 70, 100)
11628
InitMtdIL.Emit(OpCodes.Br, cont227)
11629
InitMtdIL.MarkLabel(fa227)
11630
11866
InitMtdIL.MarkSequencePoint(doc4, 71, 1, 71, 100)
11631
InitMtdIL.Emit(OpCodes.Ldc_I4, CInt(0))
11867
InitMtdIL.Emit(OpCodes.Ldc_I4, CInt(-1))
11632
11868
Typ = GetType(System.Int32)
11633
11869
InitMtdIL.Emit(OpCodes.Stsfld, asm.GetType("dylan.NET.Reflection.ILEmitter").GetField("ArgInd"))
11634
11870
InitMtdIL.MarkSequencePoint(doc4, 72, 1, 72, 100)
11635
11871
InitMtdIL.Emit(OpCodes.Br, cont227)
11872
InitMtdIL.MarkLabel(fa227)
11873
InitMtdIL.MarkSequencePoint(doc4, 73, 1, 73, 100)
11874
InitMtdIL.Emit(OpCodes.Ldc_I4, CInt(0))
11875
Typ = GetType(System.Int32)
11876
InitMtdIL.Emit(OpCodes.Stsfld, asm.GetType("dylan.NET.Reflection.ILEmitter").GetField("ArgInd"))
11877
InitMtdIL.MarkSequencePoint(doc4, 74, 1, 74, 100)
11878
InitMtdIL.Emit(OpCodes.Br, cont227)
11636
11879
InitMtdIL.MarkLabel(cont227)
11637
InitMtdIL.MarkSequencePoint(doc4, 73, 1, 73, 100)
11880
InitMtdIL.MarkSequencePoint(doc4, 75, 1, 75, 100)
11638
11881
InitMtdIL.Emit(OpCodes.Ret)
11639
11882
Dim InitConstr As MethodBuilder = AsmFactory.DefineMethod("InitConstr", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), Type.EmptyTypes)
11640
11883
Dim InitConstrIL As ILGenerator = InitConstr.GetILGenerator()
11641
InitConstrIL.MarkSequencePoint(doc4, 76, 1, 76, 100)
11884
InitConstrIL.MarkSequencePoint(doc4, 78, 1, 78, 100)
11642
11885
InitConstrIL.Emit(OpCodes.Ldsfld, CurnConB)
11643
11886
Typ = CurnConB.FieldType
11644
11887
Typ03 = Typ
11645
11888
InitConstrIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("GetILGenerator", Type.EmptyTypes))
11646
11889
Typ = Typ03.GetMethod("GetILGenerator", Type.EmptyTypes).ReturnType
11647
11890
InitConstrIL.Emit(OpCodes.Stsfld, CurnILGen)
11648
InitConstrIL.MarkSequencePoint(doc4, 77, 1, 77, 100)
11891
InitConstrIL.MarkSequencePoint(doc4, 79, 1, 79, 100)
11649
11892
InitConstrIL.Emit(OpCodes.Ldsfld, CurnConB)
11650
11893
Typ = CurnConB.FieldType
11651
11894
InitConstrIL.Emit(OpCodes.Stsfld, asm.GetType("dylan.NET.Reflection.ILEmitter").GetField("Constr"))
11652
InitConstrIL.MarkSequencePoint(doc4, 78, 1, 78, 100)
11895
InitConstrIL.MarkSequencePoint(doc4, 80, 1, 80, 100)
11653
11896
InitConstrIL.Emit(OpCodes.Ldsfld, CurnILGen)
11654
11897
Typ = CurnILGen.FieldType
11655
11898
InitConstrIL.Emit(OpCodes.Stsfld, asm.GetType("dylan.NET.Reflection.ILEmitter").GetField("ILGen"))
11656
InitConstrIL.MarkSequencePoint(doc4, 79, 1, 79, 100)
11899
InitConstrIL.MarkSequencePoint(doc4, 81, 1, 81, 100)
11657
11900
InitConstrIL.Emit(OpCodes.Ldsfld, DebugFlg)
11658
11901
Typ = DebugFlg.FieldType
11659
11902
InitConstrIL.Emit(OpCodes.Stsfld, asm.GetType("dylan.NET.Reflection.ILEmitter").GetField("DebugFlg"))
11660
InitConstrIL.MarkSequencePoint(doc4, 80, 1, 80, 100)
11903
InitConstrIL.MarkSequencePoint(doc4, 82, 1, 82, 100)
11661
11904
InitConstrIL.Emit(OpCodes.Ldc_I4, CInt(-1))
11662
11905
Typ = GetType(System.Int32)
11663
11906
InitConstrIL.Emit(OpCodes.Stsfld, asm.GetType("dylan.NET.Reflection.ILEmitter").GetField("LocInd"))
11664
InitConstrIL.MarkSequencePoint(doc4, 81, 1, 81, 100)
11907
InitConstrIL.MarkSequencePoint(doc4, 83, 1, 83, 100)
11665
11908
InitConstrIL.Emit(OpCodes.Ldsfld, asm.GetType("dylan.NET.Reflection.ILEmitter").GetField("StaticFlg"))
11666
11909
Typ = asm.GetType("dylan.NET.Reflection.ILEmitter").GetField("StaticFlg").FieldType
11667
11910
InitConstrIL.Emit(OpCodes.Ldc_I4, 1)
11672
11915
InitConstrIL.Emit(OpCodes.Beq, tru228)
11673
11916
InitConstrIL.Emit(OpCodes.Br, fa228)
11674
11917
InitConstrIL.MarkLabel(tru228)
11675
InitConstrIL.MarkSequencePoint(doc4, 82, 1, 82, 100)
11918
InitConstrIL.MarkSequencePoint(doc4, 84, 1, 84, 100)
11676
11919
InitConstrIL.Emit(OpCodes.Ldc_I4, CInt(-1))
11677
11920
Typ = GetType(System.Int32)
11678
11921
InitConstrIL.Emit(OpCodes.Stsfld, asm.GetType("dylan.NET.Reflection.ILEmitter").GetField("ArgInd"))
11679
InitConstrIL.MarkSequencePoint(doc4, 83, 1, 83, 100)
11922
InitConstrIL.MarkSequencePoint(doc4, 85, 1, 85, 100)
11680
11923
InitConstrIL.Emit(OpCodes.Br, cont228)
11681
11924
InitConstrIL.MarkLabel(fa228)
11682
InitConstrIL.MarkSequencePoint(doc4, 84, 1, 84, 100)
11925
InitConstrIL.MarkSequencePoint(doc4, 86, 1, 86, 100)
11683
11926
InitConstrIL.Emit(OpCodes.Ldc_I4, CInt(0))
11684
11927
Typ = GetType(System.Int32)
11685
11928
InitConstrIL.Emit(OpCodes.Stsfld, asm.GetType("dylan.NET.Reflection.ILEmitter").GetField("ArgInd"))
11686
InitConstrIL.MarkSequencePoint(doc4, 85, 1, 85, 100)
11929
InitConstrIL.MarkSequencePoint(doc4, 87, 1, 87, 100)
11687
11930
InitConstrIL.Emit(OpCodes.Br, cont228)
11688
11931
InitConstrIL.MarkLabel(cont228)
11689
InitConstrIL.MarkSequencePoint(doc4, 86, 1, 86, 100)
11932
InitConstrIL.MarkSequencePoint(doc4, 88, 1, 88, 100)
11690
11933
InitConstrIL.Emit(OpCodes.Ret)
11691
11934
Dim typ4(-1) As Type
11692
11935
ReDim Preserve typ4(UBound(typ4) + 1)
11694
11937
Dim AddTypB As MethodBuilder = AsmFactory.DefineMethod("AddTypB", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ4)
11695
11938
Dim AddTypBIL As ILGenerator = AddTypB.GetILGenerator()
11696
11939
Dim AddTypBparam01 As ParameterBuilder = AddTypB.DefineParameter(1, ParameterAttributes.None, "typ")
11697
AddTypBIL.MarkSequencePoint(doc4, 91, 1, 91, 100)
11698
Dim locbldr72 As LocalBuilder = AddTypBIL.DeclareLocal(GetType(System.Int32))
11699
locbldr72.SetLocalSymInfo("len")
11940
AddTypBIL.MarkSequencePoint(doc4, 93, 1, 93, 100)
11941
Dim locbldr74 As LocalBuilder = AddTypBIL.DeclareLocal(GetType(System.Int32))
11942
locbldr74.SetLocalSymInfo("len")
11700
11943
AddTypBIL.Emit(OpCodes.Ldsfld, CurnTypList)
11701
11944
Typ = CurnTypList.FieldType
11702
11945
AddTypBIL.Emit(OpCodes.Ldlen)
11703
11946
AddTypBIL.Emit(OpCodes.Conv_I4)
11704
11947
Typ = GetType(System.Int32)
11705
11948
AddTypBIL.Emit(OpCodes.Stloc, 0)
11706
AddTypBIL.MarkSequencePoint(doc4, 92, 1, 92, 100)
11707
Dim locbldr73 As LocalBuilder = AddTypBIL.DeclareLocal(GetType(System.Int32))
11708
locbldr73.SetLocalSymInfo("destl")
11949
AddTypBIL.MarkSequencePoint(doc4, 94, 1, 94, 100)
11950
Dim locbldr75 As LocalBuilder = AddTypBIL.DeclareLocal(GetType(System.Int32))
11951
locbldr75.SetLocalSymInfo("destl")
11709
11952
AddTypBIL.Emit(OpCodes.Ldloc, 0)
11710
11953
Typ = GetType(System.Int32)
11711
11954
AddTypBIL.Emit(OpCodes.Ldc_I4, CInt(1))
11712
11955
Typ = GetType(System.Int32)
11713
11956
AddTypBIL.Emit(OpCodes.Add)
11714
11957
AddTypBIL.Emit(OpCodes.Stloc, 1)
11715
AddTypBIL.MarkSequencePoint(doc4, 93, 1, 93, 100)
11716
Dim locbldr74 As LocalBuilder = AddTypBIL.DeclareLocal(GetType(System.Int32))
11717
locbldr74.SetLocalSymInfo("stopel")
11958
AddTypBIL.MarkSequencePoint(doc4, 95, 1, 95, 100)
11959
Dim locbldr76 As LocalBuilder = AddTypBIL.DeclareLocal(GetType(System.Int32))
11960
locbldr76.SetLocalSymInfo("stopel")
11718
11961
AddTypBIL.Emit(OpCodes.Ldloc, 0)
11719
11962
Typ = GetType(System.Int32)
11720
11963
AddTypBIL.Emit(OpCodes.Ldc_I4, CInt(1))
11721
11964
Typ = GetType(System.Int32)
11722
11965
AddTypBIL.Emit(OpCodes.Sub)
11723
11966
AddTypBIL.Emit(OpCodes.Stloc, 2)
11724
AddTypBIL.MarkSequencePoint(doc4, 94, 1, 94, 100)
11725
Dim locbldr75 As LocalBuilder = AddTypBIL.DeclareLocal(GetType(System.Int32))
11726
locbldr75.SetLocalSymInfo("i")
11727
AddTypBIL.Emit(OpCodes.Ldc_I4, CInt(-1))
11728
Typ = GetType(System.Int32)
11729
AddTypBIL.Emit(OpCodes.Stloc, 3)
11730
11967
AddTypBIL.MarkSequencePoint(doc4, 96, 1, 96, 100)
11731
Dim locbldr76 As LocalBuilder = AddTypBIL.DeclareLocal(GetType(TypeBuilder).MakeArrayType())
11732
locbldr76.SetLocalSymInfo("destarr")
11968
Dim locbldr77 As LocalBuilder = AddTypBIL.DeclareLocal(GetType(System.Int32))
11969
locbldr77.SetLocalSymInfo("i")
11970
AddTypBIL.Emit(OpCodes.Ldc_I4, CInt(-1))
11971
Typ = GetType(System.Int32)
11972
AddTypBIL.Emit(OpCodes.Stloc, 3)
11973
AddTypBIL.MarkSequencePoint(doc4, 98, 1, 98, 100)
11974
Dim locbldr78 As LocalBuilder = AddTypBIL.DeclareLocal(GetType(TypeBuilder).MakeArrayType())
11975
locbldr78.SetLocalSymInfo("destarr")
11733
11976
AddTypBIL.Emit(OpCodes.Ldloc, 1)
11734
11977
Typ = GetType(System.Int32)
11735
11978
AddTypBIL.Emit(OpCodes.Conv_U)
11736
11979
AddTypBIL.Emit(OpCodes.Newarr, GetType(TypeBuilder))
11737
11980
AddTypBIL.Emit(OpCodes.Stloc, 4)
11738
AddTypBIL.MarkSequencePoint(doc4, 98, 1, 98, 100)
11981
AddTypBIL.MarkSequencePoint(doc4, 100, 1, 100, 100)
11739
11982
Dim label0 As System.Reflection.Emit.Label = AddTypBIL.DefineLabel()
11740
AddTypBIL.MarkSequencePoint(doc4, 99, 1, 99, 100)
11983
AddTypBIL.MarkSequencePoint(doc4, 101, 1, 101, 100)
11741
11984
Dim label1 As System.Reflection.Emit.Label = AddTypBIL.DefineLabel()
11742
AddTypBIL.MarkSequencePoint(doc4, 101, 1, 101, 100)
11985
AddTypBIL.MarkSequencePoint(doc4, 103, 1, 103, 100)
11743
11986
AddTypBIL.MarkLabel(label0)
11744
AddTypBIL.MarkSequencePoint(doc4, 103, 1, 103, 100)
11745
AddTypBIL.Emit(OpCodes.Ldloc, 3)
11746
Typ = GetType(System.Int32)
11747
AddTypBIL.Emit(OpCodes.Ldc_I4, CInt(1))
11748
Typ = GetType(System.Int32)
11749
AddTypBIL.Emit(OpCodes.Add)
11750
AddTypBIL.Emit(OpCodes.Stloc, 3)
11751
11987
AddTypBIL.MarkSequencePoint(doc4, 105, 1, 105, 100)
11988
AddTypBIL.Emit(OpCodes.Ldloc, 3)
11989
Typ = GetType(System.Int32)
11990
AddTypBIL.Emit(OpCodes.Ldc_I4, CInt(1))
11991
Typ = GetType(System.Int32)
11992
AddTypBIL.Emit(OpCodes.Add)
11993
AddTypBIL.Emit(OpCodes.Stloc, 3)
11994
AddTypBIL.MarkSequencePoint(doc4, 107, 1, 107, 100)
11752
11995
AddTypBIL.Emit(OpCodes.Ldloc, 0)
11753
11996
Typ = GetType(System.Int32)
11754
11997
AddTypBIL.Emit(OpCodes.Ldc_I4, CInt(0))
11759
12002
AddTypBIL.Emit(OpCodes.Bgt, tru229)
11760
12003
AddTypBIL.Emit(OpCodes.Br, fa229)
11761
12004
AddTypBIL.MarkLabel(tru229)
11762
AddTypBIL.MarkSequencePoint(doc4, 107, 1, 107, 100)
12005
AddTypBIL.MarkSequencePoint(doc4, 109, 1, 109, 100)
11763
12006
AddTypBIL.Emit(OpCodes.Ldloc, 4)
11764
12007
Typ = GetType(TypeBuilder).MakeArrayType()
11765
12008
Typ02 = Typ
11777
12020
AddTypBIL.Emit(OpCodes.Ldelem, Typ.GetElementType())
11778
12021
Typ = Typ.GetElementType()
11779
12022
AddTypBIL.Emit(OpCodes.Stelem, GetType(TypeBuilder).MakeArrayType().GetElementType())
11780
AddTypBIL.MarkSequencePoint(doc4, 109, 1, 109, 100)
12023
AddTypBIL.MarkSequencePoint(doc4, 111, 1, 111, 100)
11781
12024
AddTypBIL.Emit(OpCodes.Br, cont229)
11782
12025
AddTypBIL.MarkLabel(fa229)
11783
12026
AddTypBIL.Emit(OpCodes.Br, cont229)
11784
12027
AddTypBIL.MarkLabel(cont229)
11785
AddTypBIL.MarkSequencePoint(doc4, 111, 1, 111, 100)
12028
AddTypBIL.MarkSequencePoint(doc4, 113, 1, 113, 100)
11786
12029
AddTypBIL.Emit(OpCodes.Ldloc, 3)
11787
12030
Typ = GetType(System.Int32)
11788
12031
AddTypBIL.Emit(OpCodes.Ldloc, 2)
11793
12036
AddTypBIL.Emit(OpCodes.Beq, tru230)
11794
12037
AddTypBIL.Emit(OpCodes.Br, fa230)
11795
12038
AddTypBIL.MarkLabel(tru230)
11796
AddTypBIL.MarkSequencePoint(doc4, 112, 1, 112, 100)
12039
AddTypBIL.MarkSequencePoint(doc4, 114, 1, 114, 100)
11797
12040
AddTypBIL.Emit(OpCodes.Br, label1)
11798
AddTypBIL.MarkSequencePoint(doc4, 113, 1, 113, 100)
12041
AddTypBIL.MarkSequencePoint(doc4, 115, 1, 115, 100)
11799
12042
AddTypBIL.Emit(OpCodes.Br, cont230)
11800
12043
AddTypBIL.MarkLabel(fa230)
11801
AddTypBIL.MarkSequencePoint(doc4, 114, 1, 114, 100)
12044
AddTypBIL.MarkSequencePoint(doc4, 116, 1, 116, 100)
11802
12045
AddTypBIL.Emit(OpCodes.Ldloc, 2)
11803
12046
Typ = GetType(System.Int32)
11804
12047
AddTypBIL.Emit(OpCodes.Ldc_I4, CInt(-1))
11809
12052
AddTypBIL.Emit(OpCodes.Beq, fa231)
11810
12053
AddTypBIL.Emit(OpCodes.Br, tru231)
11811
12054
AddTypBIL.MarkLabel(tru231)
11812
AddTypBIL.MarkSequencePoint(doc4, 115, 1, 115, 100)
12055
AddTypBIL.MarkSequencePoint(doc4, 117, 1, 117, 100)
11813
12056
AddTypBIL.Emit(OpCodes.Br, label0)
11814
AddTypBIL.MarkSequencePoint(doc4, 116, 1, 116, 100)
12057
AddTypBIL.MarkSequencePoint(doc4, 118, 1, 118, 100)
11815
12058
AddTypBIL.Emit(OpCodes.Br, cont231)
11816
12059
AddTypBIL.MarkLabel(fa231)
11817
AddTypBIL.MarkSequencePoint(doc4, 117, 1, 117, 100)
12060
AddTypBIL.MarkSequencePoint(doc4, 119, 1, 119, 100)
11818
12061
AddTypBIL.Emit(OpCodes.Br, label1)
11819
AddTypBIL.MarkSequencePoint(doc4, 118, 1, 118, 100)
12062
AddTypBIL.MarkSequencePoint(doc4, 120, 1, 120, 100)
11820
12063
AddTypBIL.Emit(OpCodes.Br, cont231)
11821
12064
AddTypBIL.MarkLabel(cont231)
11822
AddTypBIL.MarkSequencePoint(doc4, 119, 1, 119, 100)
12065
AddTypBIL.MarkSequencePoint(doc4, 121, 1, 121, 100)
11823
12066
AddTypBIL.Emit(OpCodes.Br, cont230)
11824
12067
AddTypBIL.MarkLabel(cont230)
11825
AddTypBIL.MarkSequencePoint(doc4, 121, 1, 121, 100)
12068
AddTypBIL.MarkSequencePoint(doc4, 123, 1, 123, 100)
11826
12069
AddTypBIL.MarkLabel(label1)
11827
AddTypBIL.MarkSequencePoint(doc4, 123, 1, 123, 100)
12070
AddTypBIL.MarkSequencePoint(doc4, 125, 1, 125, 100)
11828
12071
AddTypBIL.Emit(OpCodes.Ldloc, 4)
11829
12072
Typ = GetType(TypeBuilder).MakeArrayType()
11830
12073
Typ02 = Typ
11835
12078
AddTypBIL.Emit(OpCodes.Ldarg, 0)
11836
12079
Typ = GetType(TypeBuilder)
11837
12080
AddTypBIL.Emit(OpCodes.Stelem, GetType(TypeBuilder).MakeArrayType().GetElementType())
11838
AddTypBIL.MarkSequencePoint(doc4, 125, 1, 125, 100)
12081
AddTypBIL.MarkSequencePoint(doc4, 127, 1, 127, 100)
11839
12082
AddTypBIL.Emit(OpCodes.Ldloc, 4)
11840
12083
Typ = GetType(TypeBuilder).MakeArrayType()
11841
12084
AddTypBIL.Emit(OpCodes.Stsfld, CurnTypList)
11842
AddTypBIL.MarkSequencePoint(doc4, 127, 1, 127, 100)
12085
AddTypBIL.MarkSequencePoint(doc4, 129, 1, 129, 100)
11843
12086
AddTypBIL.Emit(OpCodes.Ret)
11844
12087
Dim typ5(-1) As Type
11845
12088
ReDim Preserve typ5(UBound(typ5) + 1)
11847
12090
Dim AddTyp As MethodBuilder = AsmFactory.DefineMethod("AddTyp", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ5)
11848
12091
Dim AddTypIL As ILGenerator = AddTyp.GetILGenerator()
11849
12092
Dim AddTypparam01 As ParameterBuilder = AddTyp.DefineParameter(1, ParameterAttributes.None, "typ")
11850
AddTypIL.MarkSequencePoint(doc4, 131, 1, 131, 100)
11851
Dim locbldr77 As LocalBuilder = AddTypIL.DeclareLocal(GetType(System.Int32))
11852
locbldr77.SetLocalSymInfo("len")
12093
AddTypIL.MarkSequencePoint(doc4, 133, 1, 133, 100)
12094
Dim locbldr79 As LocalBuilder = AddTypIL.DeclareLocal(GetType(System.Int32))
12095
locbldr79.SetLocalSymInfo("len")
11853
12096
AddTypIL.Emit(OpCodes.Ldsfld, TypArr)
11854
12097
Typ = TypArr.FieldType
11855
12098
AddTypIL.Emit(OpCodes.Ldlen)
11856
12099
AddTypIL.Emit(OpCodes.Conv_I4)
11857
12100
Typ = GetType(System.Int32)
11858
12101
AddTypIL.Emit(OpCodes.Stloc, 0)
11859
AddTypIL.MarkSequencePoint(doc4, 132, 1, 132, 100)
11860
Dim locbldr78 As LocalBuilder = AddTypIL.DeclareLocal(GetType(System.Int32))
11861
locbldr78.SetLocalSymInfo("destl")
12102
AddTypIL.MarkSequencePoint(doc4, 134, 1, 134, 100)
12103
Dim locbldr80 As LocalBuilder = AddTypIL.DeclareLocal(GetType(System.Int32))
12104
locbldr80.SetLocalSymInfo("destl")
11862
12105
AddTypIL.Emit(OpCodes.Ldloc, 0)
11863
12106
Typ = GetType(System.Int32)
11864
12107
AddTypIL.Emit(OpCodes.Ldc_I4, CInt(1))
11865
12108
Typ = GetType(System.Int32)
11866
12109
AddTypIL.Emit(OpCodes.Add)
11867
12110
AddTypIL.Emit(OpCodes.Stloc, 1)
11868
AddTypIL.MarkSequencePoint(doc4, 133, 1, 133, 100)
11869
Dim locbldr79 As LocalBuilder = AddTypIL.DeclareLocal(GetType(System.Int32))
11870
locbldr79.SetLocalSymInfo("stopel")
12111
AddTypIL.MarkSequencePoint(doc4, 135, 1, 135, 100)
12112
Dim locbldr81 As LocalBuilder = AddTypIL.DeclareLocal(GetType(System.Int32))
12113
locbldr81.SetLocalSymInfo("stopel")
11871
12114
AddTypIL.Emit(OpCodes.Ldloc, 0)
11872
12115
Typ = GetType(System.Int32)
11873
12116
AddTypIL.Emit(OpCodes.Ldc_I4, CInt(1))
11874
12117
Typ = GetType(System.Int32)
11875
12118
AddTypIL.Emit(OpCodes.Sub)
11876
12119
AddTypIL.Emit(OpCodes.Stloc, 2)
11877
AddTypIL.MarkSequencePoint(doc4, 134, 1, 134, 100)
11878
Dim locbldr80 As LocalBuilder = AddTypIL.DeclareLocal(GetType(System.Int32))
11879
locbldr80.SetLocalSymInfo("i")
11880
AddTypIL.Emit(OpCodes.Ldc_I4, CInt(-1))
11881
Typ = GetType(System.Int32)
11882
AddTypIL.Emit(OpCodes.Stloc, 3)
11883
12120
AddTypIL.MarkSequencePoint(doc4, 136, 1, 136, 100)
11884
Dim locbldr81 As LocalBuilder = AddTypIL.DeclareLocal(GetType(System.Type).MakeArrayType())
11885
locbldr81.SetLocalSymInfo("destarr")
12121
Dim locbldr82 As LocalBuilder = AddTypIL.DeclareLocal(GetType(System.Int32))
12122
locbldr82.SetLocalSymInfo("i")
12123
AddTypIL.Emit(OpCodes.Ldc_I4, CInt(-1))
12124
Typ = GetType(System.Int32)
12125
AddTypIL.Emit(OpCodes.Stloc, 3)
12126
AddTypIL.MarkSequencePoint(doc4, 138, 1, 138, 100)
12127
Dim locbldr83 As LocalBuilder = AddTypIL.DeclareLocal(GetType(System.Type).MakeArrayType())
12128
locbldr83.SetLocalSymInfo("destarr")
11886
12129
AddTypIL.Emit(OpCodes.Ldloc, 1)
11887
12130
Typ = GetType(System.Int32)
11888
12131
AddTypIL.Emit(OpCodes.Conv_U)
11889
12132
AddTypIL.Emit(OpCodes.Newarr, GetType(System.Type))
11890
12133
AddTypIL.Emit(OpCodes.Stloc, 4)
11891
AddTypIL.MarkSequencePoint(doc4, 138, 1, 138, 100)
12134
AddTypIL.MarkSequencePoint(doc4, 140, 1, 140, 100)
11892
12135
Dim label2 As System.Reflection.Emit.Label = AddTypIL.DefineLabel()
11893
AddTypIL.MarkSequencePoint(doc4, 139, 1, 139, 100)
12136
AddTypIL.MarkSequencePoint(doc4, 141, 1, 141, 100)
11894
12137
Dim label3 As System.Reflection.Emit.Label = AddTypIL.DefineLabel()
11895
AddTypIL.MarkSequencePoint(doc4, 141, 1, 141, 100)
12138
AddTypIL.MarkSequencePoint(doc4, 143, 1, 143, 100)
11896
12139
AddTypIL.MarkLabel(label2)
11897
AddTypIL.MarkSequencePoint(doc4, 143, 1, 143, 100)
11898
AddTypIL.Emit(OpCodes.Ldloc, 3)
11899
Typ = GetType(System.Int32)
11900
AddTypIL.Emit(OpCodes.Ldc_I4, CInt(1))
11901
Typ = GetType(System.Int32)
11902
AddTypIL.Emit(OpCodes.Add)
11903
AddTypIL.Emit(OpCodes.Stloc, 3)
11904
12140
AddTypIL.MarkSequencePoint(doc4, 145, 1, 145, 100)
12141
AddTypIL.Emit(OpCodes.Ldloc, 3)
12142
Typ = GetType(System.Int32)
12143
AddTypIL.Emit(OpCodes.Ldc_I4, CInt(1))
12144
Typ = GetType(System.Int32)
12145
AddTypIL.Emit(OpCodes.Add)
12146
AddTypIL.Emit(OpCodes.Stloc, 3)
12147
AddTypIL.MarkSequencePoint(doc4, 147, 1, 147, 100)
11905
12148
AddTypIL.Emit(OpCodes.Ldloc, 0)
11906
12149
Typ = GetType(System.Int32)
11907
12150
AddTypIL.Emit(OpCodes.Ldc_I4, CInt(0))
11912
12155
AddTypIL.Emit(OpCodes.Bgt, tru232)
11913
12156
AddTypIL.Emit(OpCodes.Br, fa232)
11914
12157
AddTypIL.MarkLabel(tru232)
11915
AddTypIL.MarkSequencePoint(doc4, 147, 1, 147, 100)
12158
AddTypIL.MarkSequencePoint(doc4, 149, 1, 149, 100)
11916
12159
AddTypIL.Emit(OpCodes.Ldloc, 4)
11917
12160
Typ = GetType(System.Type).MakeArrayType()
11918
12161
Typ02 = Typ
11930
12173
AddTypIL.Emit(OpCodes.Ldelem, Typ.GetElementType())
11931
12174
Typ = Typ.GetElementType()
11932
12175
AddTypIL.Emit(OpCodes.Stelem, GetType(System.Type).MakeArrayType().GetElementType())
11933
AddTypIL.MarkSequencePoint(doc4, 149, 1, 149, 100)
12176
AddTypIL.MarkSequencePoint(doc4, 151, 1, 151, 100)
11934
12177
AddTypIL.Emit(OpCodes.Br, cont232)
11935
12178
AddTypIL.MarkLabel(fa232)
11936
12179
AddTypIL.Emit(OpCodes.Br, cont232)
11937
12180
AddTypIL.MarkLabel(cont232)
11938
AddTypIL.MarkSequencePoint(doc4, 151, 1, 151, 100)
12181
AddTypIL.MarkSequencePoint(doc4, 153, 1, 153, 100)
11939
12182
AddTypIL.Emit(OpCodes.Ldloc, 3)
11940
12183
Typ = GetType(System.Int32)
11941
12184
AddTypIL.Emit(OpCodes.Ldloc, 2)
11946
12189
AddTypIL.Emit(OpCodes.Beq, tru233)
11947
12190
AddTypIL.Emit(OpCodes.Br, fa233)
11948
12191
AddTypIL.MarkLabel(tru233)
11949
AddTypIL.MarkSequencePoint(doc4, 152, 1, 152, 100)
12192
AddTypIL.MarkSequencePoint(doc4, 154, 1, 154, 100)
11950
12193
AddTypIL.Emit(OpCodes.Br, label3)
11951
AddTypIL.MarkSequencePoint(doc4, 153, 1, 153, 100)
12194
AddTypIL.MarkSequencePoint(doc4, 155, 1, 155, 100)
11952
12195
AddTypIL.Emit(OpCodes.Br, cont233)
11953
12196
AddTypIL.MarkLabel(fa233)
11954
AddTypIL.MarkSequencePoint(doc4, 154, 1, 154, 100)
12197
AddTypIL.MarkSequencePoint(doc4, 156, 1, 156, 100)
11955
12198
AddTypIL.Emit(OpCodes.Ldloc, 2)
11956
12199
Typ = GetType(System.Int32)
11957
12200
AddTypIL.Emit(OpCodes.Ldc_I4, CInt(-1))
11962
12205
AddTypIL.Emit(OpCodes.Beq, fa234)
11963
12206
AddTypIL.Emit(OpCodes.Br, tru234)
11964
12207
AddTypIL.MarkLabel(tru234)
11965
AddTypIL.MarkSequencePoint(doc4, 155, 1, 155, 100)
12208
AddTypIL.MarkSequencePoint(doc4, 157, 1, 157, 100)
11966
12209
AddTypIL.Emit(OpCodes.Br, label2)
11967
AddTypIL.MarkSequencePoint(doc4, 156, 1, 156, 100)
12210
AddTypIL.MarkSequencePoint(doc4, 158, 1, 158, 100)
11968
12211
AddTypIL.Emit(OpCodes.Br, cont234)
11969
12212
AddTypIL.MarkLabel(fa234)
11970
AddTypIL.MarkSequencePoint(doc4, 157, 1, 157, 100)
12213
AddTypIL.MarkSequencePoint(doc4, 159, 1, 159, 100)
11971
12214
AddTypIL.Emit(OpCodes.Br, label3)
11972
AddTypIL.MarkSequencePoint(doc4, 158, 1, 158, 100)
12215
AddTypIL.MarkSequencePoint(doc4, 160, 1, 160, 100)
11973
12216
AddTypIL.Emit(OpCodes.Br, cont234)
11974
12217
AddTypIL.MarkLabel(cont234)
11975
AddTypIL.MarkSequencePoint(doc4, 159, 1, 159, 100)
12218
AddTypIL.MarkSequencePoint(doc4, 161, 1, 161, 100)
11976
12219
AddTypIL.Emit(OpCodes.Br, cont233)
11977
12220
AddTypIL.MarkLabel(cont233)
11978
AddTypIL.MarkSequencePoint(doc4, 161, 1, 161, 100)
12221
AddTypIL.MarkSequencePoint(doc4, 163, 1, 163, 100)
11979
12222
AddTypIL.MarkLabel(label3)
11980
AddTypIL.MarkSequencePoint(doc4, 163, 1, 163, 100)
12223
AddTypIL.MarkSequencePoint(doc4, 165, 1, 165, 100)
11981
12224
AddTypIL.Emit(OpCodes.Ldloc, 4)
11982
12225
Typ = GetType(System.Type).MakeArrayType()
11983
12226
Typ02 = Typ
11988
12231
AddTypIL.Emit(OpCodes.Ldarg, 0)
11989
12232
Typ = GetType(System.Type)
11990
12233
AddTypIL.Emit(OpCodes.Stelem, GetType(System.Type).MakeArrayType().GetElementType())
11991
AddTypIL.MarkSequencePoint(doc4, 165, 1, 165, 100)
12234
AddTypIL.MarkSequencePoint(doc4, 167, 1, 167, 100)
11992
12235
AddTypIL.Emit(OpCodes.Ldloc, 4)
11993
12236
Typ = GetType(System.Type).MakeArrayType()
11994
12237
AddTypIL.Emit(OpCodes.Stsfld, TypArr)
11995
AddTypIL.MarkSequencePoint(doc4, 167, 1, 167, 100)
12238
AddTypIL.MarkSequencePoint(doc4, 169, 1, 169, 100)
11996
12239
AddTypIL.Emit(OpCodes.Ret)
11997
12240
Dim typ6(-1) As Type
11998
12241
ReDim Preserve typ6(UBound(typ6) + 1)
12000
12243
Dim AddGenParamName As MethodBuilder = AsmFactory.DefineMethod("AddGenParamName", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), typ6)
12001
12244
Dim AddGenParamNameIL As ILGenerator = AddGenParamName.GetILGenerator()
12002
12245
Dim AddGenParamNameparam01 As ParameterBuilder = AddGenParamName.DefineParameter(1, ParameterAttributes.None, "nam")
12003
AddGenParamNameIL.MarkSequencePoint(doc4, 171, 1, 171, 100)
12004
Dim locbldr82 As LocalBuilder = AddGenParamNameIL.DeclareLocal(GetType(System.Int32))
12005
locbldr82.SetLocalSymInfo("len")
12246
AddGenParamNameIL.MarkSequencePoint(doc4, 173, 1, 173, 100)
12247
Dim locbldr84 As LocalBuilder = AddGenParamNameIL.DeclareLocal(GetType(System.Int32))
12248
locbldr84.SetLocalSymInfo("len")
12006
12249
AddGenParamNameIL.Emit(OpCodes.Ldsfld, GenParamNames)
12007
12250
Typ = GenParamNames.FieldType
12008
12251
AddGenParamNameIL.Emit(OpCodes.Ldlen)
12009
12252
AddGenParamNameIL.Emit(OpCodes.Conv_I4)
12010
12253
Typ = GetType(System.Int32)
12011
12254
AddGenParamNameIL.Emit(OpCodes.Stloc, 0)
12012
AddGenParamNameIL.MarkSequencePoint(doc4, 172, 1, 172, 100)
12013
Dim locbldr83 As LocalBuilder = AddGenParamNameIL.DeclareLocal(GetType(System.Int32))
12014
locbldr83.SetLocalSymInfo("destl")
12255
AddGenParamNameIL.MarkSequencePoint(doc4, 174, 1, 174, 100)
12256
Dim locbldr85 As LocalBuilder = AddGenParamNameIL.DeclareLocal(GetType(System.Int32))
12257
locbldr85.SetLocalSymInfo("destl")
12015
12258
AddGenParamNameIL.Emit(OpCodes.Ldloc, 0)
12016
12259
Typ = GetType(System.Int32)
12017
12260
AddGenParamNameIL.Emit(OpCodes.Ldc_I4, CInt(1))
12018
12261
Typ = GetType(System.Int32)
12019
12262
AddGenParamNameIL.Emit(OpCodes.Add)
12020
12263
AddGenParamNameIL.Emit(OpCodes.Stloc, 1)
12021
AddGenParamNameIL.MarkSequencePoint(doc4, 173, 1, 173, 100)
12022
Dim locbldr84 As LocalBuilder = AddGenParamNameIL.DeclareLocal(GetType(System.Int32))
12023
locbldr84.SetLocalSymInfo("stopel")
12264
AddGenParamNameIL.MarkSequencePoint(doc4, 175, 1, 175, 100)
12265
Dim locbldr86 As LocalBuilder = AddGenParamNameIL.DeclareLocal(GetType(System.Int32))
12266
locbldr86.SetLocalSymInfo("stopel")
12024
12267
AddGenParamNameIL.Emit(OpCodes.Ldloc, 0)
12025
12268
Typ = GetType(System.Int32)
12026
12269
AddGenParamNameIL.Emit(OpCodes.Ldc_I4, CInt(1))
12027
12270
Typ = GetType(System.Int32)
12028
12271
AddGenParamNameIL.Emit(OpCodes.Sub)
12029
12272
AddGenParamNameIL.Emit(OpCodes.Stloc, 2)
12030
AddGenParamNameIL.MarkSequencePoint(doc4, 174, 1, 174, 100)
12031
Dim locbldr85 As LocalBuilder = AddGenParamNameIL.DeclareLocal(GetType(System.Int32))
12032
locbldr85.SetLocalSymInfo("i")
12033
AddGenParamNameIL.Emit(OpCodes.Ldc_I4, CInt(-1))
12034
Typ = GetType(System.Int32)
12035
AddGenParamNameIL.Emit(OpCodes.Stloc, 3)
12036
12273
AddGenParamNameIL.MarkSequencePoint(doc4, 176, 1, 176, 100)
12037
Dim locbldr86 As LocalBuilder = AddGenParamNameIL.DeclareLocal(GetType(System.String).MakeArrayType())
12038
locbldr86.SetLocalSymInfo("destarr")
12274
Dim locbldr87 As LocalBuilder = AddGenParamNameIL.DeclareLocal(GetType(System.Int32))
12275
locbldr87.SetLocalSymInfo("i")
12276
AddGenParamNameIL.Emit(OpCodes.Ldc_I4, CInt(-1))
12277
Typ = GetType(System.Int32)
12278
AddGenParamNameIL.Emit(OpCodes.Stloc, 3)
12279
AddGenParamNameIL.MarkSequencePoint(doc4, 178, 1, 178, 100)
12280
Dim locbldr88 As LocalBuilder = AddGenParamNameIL.DeclareLocal(GetType(System.String).MakeArrayType())
12281
locbldr88.SetLocalSymInfo("destarr")
12039
12282
AddGenParamNameIL.Emit(OpCodes.Ldloc, 1)
12040
12283
Typ = GetType(System.Int32)
12041
12284
AddGenParamNameIL.Emit(OpCodes.Conv_U)
12042
12285
AddGenParamNameIL.Emit(OpCodes.Newarr, GetType(System.String))
12043
12286
AddGenParamNameIL.Emit(OpCodes.Stloc, 4)
12044
AddGenParamNameIL.MarkSequencePoint(doc4, 178, 1, 178, 100)
12287
AddGenParamNameIL.MarkSequencePoint(doc4, 180, 1, 180, 100)
12045
12288
Dim label4 As System.Reflection.Emit.Label = AddGenParamNameIL.DefineLabel()
12046
AddGenParamNameIL.MarkSequencePoint(doc4, 179, 1, 179, 100)
12289
AddGenParamNameIL.MarkSequencePoint(doc4, 181, 1, 181, 100)
12047
12290
Dim label5 As System.Reflection.Emit.Label = AddGenParamNameIL.DefineLabel()
12048
AddGenParamNameIL.MarkSequencePoint(doc4, 181, 1, 181, 100)
12291
AddGenParamNameIL.MarkSequencePoint(doc4, 183, 1, 183, 100)
12049
12292
AddGenParamNameIL.MarkLabel(label4)
12050
AddGenParamNameIL.MarkSequencePoint(doc4, 183, 1, 183, 100)
12051
AddGenParamNameIL.Emit(OpCodes.Ldloc, 3)
12052
Typ = GetType(System.Int32)
12053
AddGenParamNameIL.Emit(OpCodes.Ldc_I4, CInt(1))
12054
Typ = GetType(System.Int32)
12055
AddGenParamNameIL.Emit(OpCodes.Add)
12056
AddGenParamNameIL.Emit(OpCodes.Stloc, 3)
12057
12293
AddGenParamNameIL.MarkSequencePoint(doc4, 185, 1, 185, 100)
12294
AddGenParamNameIL.Emit(OpCodes.Ldloc, 3)
12295
Typ = GetType(System.Int32)
12296
AddGenParamNameIL.Emit(OpCodes.Ldc_I4, CInt(1))
12297
Typ = GetType(System.Int32)
12298
AddGenParamNameIL.Emit(OpCodes.Add)
12299
AddGenParamNameIL.Emit(OpCodes.Stloc, 3)
12300
AddGenParamNameIL.MarkSequencePoint(doc4, 187, 1, 187, 100)
12058
12301
AddGenParamNameIL.Emit(OpCodes.Ldloc, 0)
12059
12302
Typ = GetType(System.Int32)
12060
12303
AddGenParamNameIL.Emit(OpCodes.Ldc_I4, CInt(0))
12065
12308
AddGenParamNameIL.Emit(OpCodes.Bgt, tru235)
12066
12309
AddGenParamNameIL.Emit(OpCodes.Br, fa235)
12067
12310
AddGenParamNameIL.MarkLabel(tru235)
12068
AddGenParamNameIL.MarkSequencePoint(doc4, 187, 1, 187, 100)
12311
AddGenParamNameIL.MarkSequencePoint(doc4, 189, 1, 189, 100)
12069
12312
AddGenParamNameIL.Emit(OpCodes.Ldloc, 4)
12070
12313
Typ = GetType(System.String).MakeArrayType()
12071
12314
Typ02 = Typ
12083
12326
AddGenParamNameIL.Emit(OpCodes.Ldelem, Typ.GetElementType())
12084
12327
Typ = Typ.GetElementType()
12085
12328
AddGenParamNameIL.Emit(OpCodes.Stelem, GetType(System.String).MakeArrayType().GetElementType())
12086
AddGenParamNameIL.MarkSequencePoint(doc4, 189, 1, 189, 100)
12329
AddGenParamNameIL.MarkSequencePoint(doc4, 191, 1, 191, 100)
12087
12330
AddGenParamNameIL.Emit(OpCodes.Br, cont235)
12088
12331
AddGenParamNameIL.MarkLabel(fa235)
12089
12332
AddGenParamNameIL.Emit(OpCodes.Br, cont235)
12090
12333
AddGenParamNameIL.MarkLabel(cont235)
12091
AddGenParamNameIL.MarkSequencePoint(doc4, 191, 1, 191, 100)
12334
AddGenParamNameIL.MarkSequencePoint(doc4, 193, 1, 193, 100)
12092
12335
AddGenParamNameIL.Emit(OpCodes.Ldloc, 3)
12093
12336
Typ = GetType(System.Int32)
12094
12337
AddGenParamNameIL.Emit(OpCodes.Ldloc, 2)
12099
12342
AddGenParamNameIL.Emit(OpCodes.Beq, tru236)
12100
12343
AddGenParamNameIL.Emit(OpCodes.Br, fa236)
12101
12344
AddGenParamNameIL.MarkLabel(tru236)
12102
AddGenParamNameIL.MarkSequencePoint(doc4, 192, 1, 192, 100)
12345
AddGenParamNameIL.MarkSequencePoint(doc4, 194, 1, 194, 100)
12103
12346
AddGenParamNameIL.Emit(OpCodes.Br, label5)
12104
AddGenParamNameIL.MarkSequencePoint(doc4, 193, 1, 193, 100)
12347
AddGenParamNameIL.MarkSequencePoint(doc4, 195, 1, 195, 100)
12105
12348
AddGenParamNameIL.Emit(OpCodes.Br, cont236)
12106
12349
AddGenParamNameIL.MarkLabel(fa236)
12107
AddGenParamNameIL.MarkSequencePoint(doc4, 194, 1, 194, 100)
12350
AddGenParamNameIL.MarkSequencePoint(doc4, 196, 1, 196, 100)
12108
12351
AddGenParamNameIL.Emit(OpCodes.Ldloc, 2)
12109
12352
Typ = GetType(System.Int32)
12110
12353
AddGenParamNameIL.Emit(OpCodes.Ldc_I4, CInt(-1))
12115
12358
AddGenParamNameIL.Emit(OpCodes.Beq, fa237)
12116
12359
AddGenParamNameIL.Emit(OpCodes.Br, tru237)
12117
12360
AddGenParamNameIL.MarkLabel(tru237)
12118
AddGenParamNameIL.MarkSequencePoint(doc4, 195, 1, 195, 100)
12361
AddGenParamNameIL.MarkSequencePoint(doc4, 197, 1, 197, 100)
12119
12362
AddGenParamNameIL.Emit(OpCodes.Br, label4)
12120
AddGenParamNameIL.MarkSequencePoint(doc4, 196, 1, 196, 100)
12363
AddGenParamNameIL.MarkSequencePoint(doc4, 198, 1, 198, 100)
12121
12364
AddGenParamNameIL.Emit(OpCodes.Br, cont237)
12122
12365
AddGenParamNameIL.MarkLabel(fa237)
12123
AddGenParamNameIL.MarkSequencePoint(doc4, 197, 1, 197, 100)
12366
AddGenParamNameIL.MarkSequencePoint(doc4, 199, 1, 199, 100)
12124
12367
AddGenParamNameIL.Emit(OpCodes.Br, label5)
12125
AddGenParamNameIL.MarkSequencePoint(doc4, 198, 1, 198, 100)
12368
AddGenParamNameIL.MarkSequencePoint(doc4, 200, 1, 200, 100)
12126
12369
AddGenParamNameIL.Emit(OpCodes.Br, cont237)
12127
12370
AddGenParamNameIL.MarkLabel(cont237)
12128
AddGenParamNameIL.MarkSequencePoint(doc4, 199, 1, 199, 100)
12371
AddGenParamNameIL.MarkSequencePoint(doc4, 201, 1, 201, 100)
12129
12372
AddGenParamNameIL.Emit(OpCodes.Br, cont236)
12130
12373
AddGenParamNameIL.MarkLabel(cont236)
12131
AddGenParamNameIL.MarkSequencePoint(doc4, 201, 1, 201, 100)
12374
AddGenParamNameIL.MarkSequencePoint(doc4, 203, 1, 203, 100)
12132
12375
AddGenParamNameIL.MarkLabel(label5)
12133
AddGenParamNameIL.MarkSequencePoint(doc4, 203, 1, 203, 100)
12376
AddGenParamNameIL.MarkSequencePoint(doc4, 205, 1, 205, 100)
12134
12377
AddGenParamNameIL.Emit(OpCodes.Ldloc, 4)
12135
12378
Typ = GetType(System.String).MakeArrayType()
12136
12379
Typ02 = Typ
12141
12384
AddGenParamNameIL.Emit(OpCodes.Ldarg, 0)
12142
12385
Typ = GetType(System.String)
12143
12386
AddGenParamNameIL.Emit(OpCodes.Stelem, GetType(System.String).MakeArrayType().GetElementType())
12144
AddGenParamNameIL.MarkSequencePoint(doc4, 205, 1, 205, 100)
12387
AddGenParamNameIL.MarkSequencePoint(doc4, 207, 1, 207, 100)
12145
12388
AddGenParamNameIL.Emit(OpCodes.Ldloc, 4)
12146
12389
Typ = GetType(System.String).MakeArrayType()
12147
12390
AddGenParamNameIL.Emit(OpCodes.Stsfld, GenParamNames)
12148
AddGenParamNameIL.MarkSequencePoint(doc4, 207, 1, 207, 100)
12391
AddGenParamNameIL.MarkSequencePoint(doc4, 209, 1, 209, 100)
12149
12392
AddGenParamNameIL.Emit(OpCodes.Ret)
12150
12393
AsmFactory.CreateType()
12151
12394
End Sub
12181
12424
Dim AddAsmIL As ILGenerator = AddAsm.GetILGenerator()
12182
12425
Dim AddAsmparam01 As ParameterBuilder = AddAsm.DefineParameter(1, ParameterAttributes.None, "asm")
12183
12426
AddAsmIL.MarkSequencePoint(doc5, 23, 1, 23, 100)
12184
Dim locbldr87 As LocalBuilder = AddAsmIL.DeclareLocal(GetType(System.Int32))
12185
locbldr87.SetLocalSymInfo("len")
12427
Dim locbldr89 As LocalBuilder = AddAsmIL.DeclareLocal(GetType(System.Int32))
12428
locbldr89.SetLocalSymInfo("len")
12186
12429
AddAsmIL.Emit(OpCodes.Ldsfld, Asms)
12187
12430
Typ = Asms.FieldType
12188
12431
AddAsmIL.Emit(OpCodes.Ldlen)
12190
12433
Typ = GetType(System.Int32)
12191
12434
AddAsmIL.Emit(OpCodes.Stloc, 0)
12192
12435
AddAsmIL.MarkSequencePoint(doc5, 24, 1, 24, 100)
12193
Dim locbldr88 As LocalBuilder = AddAsmIL.DeclareLocal(GetType(System.Int32))
12194
locbldr88.SetLocalSymInfo("destl")
12436
Dim locbldr90 As LocalBuilder = AddAsmIL.DeclareLocal(GetType(System.Int32))
12437
locbldr90.SetLocalSymInfo("destl")
12195
12438
AddAsmIL.Emit(OpCodes.Ldloc, 0)
12196
12439
Typ = GetType(System.Int32)
12197
12440
AddAsmIL.Emit(OpCodes.Ldc_I4, CInt(1))
12199
12442
AddAsmIL.Emit(OpCodes.Add)
12200
12443
AddAsmIL.Emit(OpCodes.Stloc, 1)
12201
12444
AddAsmIL.MarkSequencePoint(doc5, 25, 1, 25, 100)
12202
Dim locbldr89 As LocalBuilder = AddAsmIL.DeclareLocal(GetType(System.Int32))
12203
locbldr89.SetLocalSymInfo("stopel")
12445
Dim locbldr91 As LocalBuilder = AddAsmIL.DeclareLocal(GetType(System.Int32))
12446
locbldr91.SetLocalSymInfo("stopel")
12204
12447
AddAsmIL.Emit(OpCodes.Ldloc, 0)
12205
12448
Typ = GetType(System.Int32)
12206
12449
AddAsmIL.Emit(OpCodes.Ldc_I4, CInt(1))
12208
12451
AddAsmIL.Emit(OpCodes.Sub)
12209
12452
AddAsmIL.Emit(OpCodes.Stloc, 2)
12210
12453
AddAsmIL.MarkSequencePoint(doc5, 26, 1, 26, 100)
12211
Dim locbldr90 As LocalBuilder = AddAsmIL.DeclareLocal(GetType(System.Int32))
12212
locbldr90.SetLocalSymInfo("i")
12454
Dim locbldr92 As LocalBuilder = AddAsmIL.DeclareLocal(GetType(System.Int32))
12455
locbldr92.SetLocalSymInfo("i")
12213
12456
AddAsmIL.Emit(OpCodes.Ldc_I4, CInt(-1))
12214
12457
Typ = GetType(System.Int32)
12215
12458
AddAsmIL.Emit(OpCodes.Stloc, 3)
12216
12459
AddAsmIL.MarkSequencePoint(doc5, 28, 1, 28, 100)
12217
Dim locbldr91 As LocalBuilder = AddAsmIL.DeclareLocal(GetType(Assembly).MakeArrayType())
12218
locbldr91.SetLocalSymInfo("destarr")
12460
Dim locbldr93 As LocalBuilder = AddAsmIL.DeclareLocal(GetType(Assembly).MakeArrayType())
12461
locbldr93.SetLocalSymInfo("destarr")
12219
12462
AddAsmIL.Emit(OpCodes.Ldloc, 1)
12220
12463
Typ = GetType(System.Int32)
12221
12464
AddAsmIL.Emit(OpCodes.Conv_U)
12337
12580
Dim addelemparam01 As ParameterBuilder = addelem.DefineParameter(1, ParameterAttributes.None, "srcarr")
12338
12581
Dim addelemparam02 As ParameterBuilder = addelem.DefineParameter(2, ParameterAttributes.None, "eltoadd")
12339
12582
addelemIL.MarkSequencePoint(doc5, 63, 1, 63, 100)
12340
Dim locbldr92 As LocalBuilder = addelemIL.DeclareLocal(GetType(System.Int32))
12341
locbldr92.SetLocalSymInfo("len")
12583
Dim locbldr94 As LocalBuilder = addelemIL.DeclareLocal(GetType(System.Int32))
12584
locbldr94.SetLocalSymInfo("len")
12342
12585
addelemIL.Emit(OpCodes.Ldarg, 0)
12343
12586
Typ = GetType(System.String).MakeArrayType()
12344
12587
addelemIL.Emit(OpCodes.Ldlen)
12346
12589
Typ = GetType(System.Int32)
12347
12590
addelemIL.Emit(OpCodes.Stloc, 0)
12348
12591
addelemIL.MarkSequencePoint(doc5, 64, 1, 64, 100)
12349
Dim locbldr93 As LocalBuilder = addelemIL.DeclareLocal(GetType(System.Int32))
12350
locbldr93.SetLocalSymInfo("destl")
12592
Dim locbldr95 As LocalBuilder = addelemIL.DeclareLocal(GetType(System.Int32))
12593
locbldr95.SetLocalSymInfo("destl")
12351
12594
addelemIL.Emit(OpCodes.Ldloc, 0)
12352
12595
Typ = GetType(System.Int32)
12353
12596
addelemIL.Emit(OpCodes.Ldc_I4, CInt(1))
12355
12598
addelemIL.Emit(OpCodes.Add)
12356
12599
addelemIL.Emit(OpCodes.Stloc, 1)
12357
12600
addelemIL.MarkSequencePoint(doc5, 65, 1, 65, 100)
12358
Dim locbldr94 As LocalBuilder = addelemIL.DeclareLocal(GetType(System.Int32))
12359
locbldr94.SetLocalSymInfo("stopel")
12601
Dim locbldr96 As LocalBuilder = addelemIL.DeclareLocal(GetType(System.Int32))
12602
locbldr96.SetLocalSymInfo("stopel")
12360
12603
addelemIL.Emit(OpCodes.Ldloc, 0)
12361
12604
Typ = GetType(System.Int32)
12362
12605
addelemIL.Emit(OpCodes.Ldc_I4, CInt(1))
12364
12607
addelemIL.Emit(OpCodes.Sub)
12365
12608
addelemIL.Emit(OpCodes.Stloc, 2)
12366
12609
addelemIL.MarkSequencePoint(doc5, 66, 1, 66, 100)
12367
Dim locbldr95 As LocalBuilder = addelemIL.DeclareLocal(GetType(System.Int32))
12368
locbldr95.SetLocalSymInfo("i")
12610
Dim locbldr97 As LocalBuilder = addelemIL.DeclareLocal(GetType(System.Int32))
12611
locbldr97.SetLocalSymInfo("i")
12369
12612
addelemIL.Emit(OpCodes.Ldc_I4, CInt(-1))
12370
12613
Typ = GetType(System.Int32)
12371
12614
addelemIL.Emit(OpCodes.Stloc, 3)
12372
12615
addelemIL.MarkSequencePoint(doc5, 68, 1, 68, 100)
12373
Dim locbldr96 As LocalBuilder = addelemIL.DeclareLocal(GetType(System.String).MakeArrayType())
12374
locbldr96.SetLocalSymInfo("destarr")
12616
Dim locbldr98 As LocalBuilder = addelemIL.DeclareLocal(GetType(System.String).MakeArrayType())
12617
locbldr98.SetLocalSymInfo("destarr")
12375
12618
addelemIL.Emit(OpCodes.Ldloc, 1)
12376
12619
Typ = GetType(System.Int32)
12377
12620
addelemIL.Emit(OpCodes.Conv_U)
12576
12819
Dim LoadClassIL As ILGenerator = LoadClass.GetILGenerator()
12577
12820
Dim LoadClassparam01 As ParameterBuilder = LoadClass.DefineParameter(1, ParameterAttributes.None, "name")
12578
12821
LoadClassIL.MarkSequencePoint(doc6, 32, 1, 32, 100)
12579
Dim locbldr97 As LocalBuilder = LoadClassIL.DeclareLocal(GetType(System.Type))
12580
locbldr97.SetLocalSymInfo("typ")
12822
Dim locbldr99 As LocalBuilder = LoadClassIL.DeclareLocal(GetType(System.Type))
12823
locbldr99.SetLocalSymInfo("typ")
12581
12824
LoadClassIL.Emit(OpCodes.Ldnull)
12582
12825
LoadClassIL.Emit(OpCodes.Stloc, 0)
12583
12826
LoadClassIL.MarkSequencePoint(doc6, 33, 1, 33, 100)
12584
Dim locbldr98 As LocalBuilder = LoadClassIL.DeclareLocal(GetType(System.Int32))
12585
locbldr98.SetLocalSymInfo("i")
12827
Dim locbldr100 As LocalBuilder = LoadClassIL.DeclareLocal(GetType(System.Int32))
12828
locbldr100.SetLocalSymInfo("i")
12586
12829
LoadClassIL.Emit(OpCodes.Ldc_I4, CInt(-1))
12587
12830
Typ = GetType(System.Int32)
12588
12831
LoadClassIL.Emit(OpCodes.Stloc, 1)
12589
12832
LoadClassIL.MarkSequencePoint(doc6, 34, 1, 34, 100)
12590
Dim locbldr99 As LocalBuilder = LoadClassIL.DeclareLocal(GetType(System.Int32))
12591
locbldr99.SetLocalSymInfo("len")
12833
Dim locbldr101 As LocalBuilder = LoadClassIL.DeclareLocal(GetType(System.Int32))
12834
locbldr101.SetLocalSymInfo("len")
12592
12835
LoadClassIL.Emit(OpCodes.Ldsfld, asm.GetType("dylan.NET.Reflection.Importer").GetField("Asms"))
12593
12836
Typ = asm.GetType("dylan.NET.Reflection.Importer").GetField("Asms").FieldType
12594
12837
LoadClassIL.Emit(OpCodes.Ldlen)
12599
12842
LoadClassIL.Emit(OpCodes.Sub)
12600
12843
LoadClassIL.Emit(OpCodes.Stloc, 2)
12601
12844
LoadClassIL.MarkSequencePoint(doc6, 35, 1, 35, 100)
12602
Dim locbldr100 As LocalBuilder = LoadClassIL.DeclareLocal(GetType(Assembly))
12603
locbldr100.SetLocalSymInfo("curasm")
12845
Dim locbldr102 As LocalBuilder = LoadClassIL.DeclareLocal(GetType(Assembly))
12846
locbldr102.SetLocalSymInfo("curasm")
12604
12847
LoadClassIL.Emit(OpCodes.Ldnull)
12605
12848
LoadClassIL.Emit(OpCodes.Stloc, 3)
12606
12849
LoadClassIL.MarkSequencePoint(doc6, 36, 1, 36, 100)
12607
Dim locbldr101 As LocalBuilder = LoadClassIL.DeclareLocal(GetType(System.Int32))
12608
locbldr101.SetLocalSymInfo("j")
12850
Dim locbldr103 As LocalBuilder = LoadClassIL.DeclareLocal(GetType(System.Int32))
12851
locbldr103.SetLocalSymInfo("j")
12609
12852
LoadClassIL.Emit(OpCodes.Ldc_I4, CInt(-1))
12610
12853
Typ = GetType(System.Int32)
12611
12854
LoadClassIL.Emit(OpCodes.Stloc, 4)
12612
12855
LoadClassIL.MarkSequencePoint(doc6, 37, 1, 37, 100)
12613
Dim locbldr102 As LocalBuilder = LoadClassIL.DeclareLocal(GetType(System.Int32))
12614
locbldr102.SetLocalSymInfo("len2")
12856
Dim locbldr104 As LocalBuilder = LoadClassIL.DeclareLocal(GetType(System.Int32))
12857
locbldr104.SetLocalSymInfo("len2")
12615
12858
LoadClassIL.Emit(OpCodes.Ldsfld, asm.GetType("dylan.NET.Reflection.Importer").GetField("Imps"))
12616
12859
Typ = asm.GetType("dylan.NET.Reflection.Importer").GetField("Imps").FieldType
12617
12860
LoadClassIL.Emit(OpCodes.Ldlen)
12622
12865
LoadClassIL.Emit(OpCodes.Sub)
12623
12866
LoadClassIL.Emit(OpCodes.Stloc, 5)
12624
12867
LoadClassIL.MarkSequencePoint(doc6, 38, 1, 38, 100)
12625
Dim locbldr103 As LocalBuilder = LoadClassIL.DeclareLocal(GetType(System.String))
12626
locbldr103.SetLocalSymInfo("curns")
12868
Dim locbldr105 As LocalBuilder = LoadClassIL.DeclareLocal(GetType(System.String))
12869
locbldr105.SetLocalSymInfo("curns")
12627
12870
LoadClassIL.Emit(OpCodes.Ldstr, "")
12628
12871
Typ = GetType(System.String)
12629
12872
LoadClassIL.Emit(OpCodes.Stloc, 6)
12630
12873
LoadClassIL.MarkSequencePoint(doc6, 39, 1, 39, 100)
12631
Dim locbldr104 As LocalBuilder = LoadClassIL.DeclareLocal(GetType(System.String))
12632
locbldr104.SetLocalSymInfo("tmpstr")
12874
Dim locbldr106 As LocalBuilder = LoadClassIL.DeclareLocal(GetType(System.String))
12875
locbldr106.SetLocalSymInfo("tmpstr")
12633
12876
LoadClassIL.Emit(OpCodes.Ldstr, "")
12634
12877
Typ = GetType(System.String)
12635
12878
LoadClassIL.Emit(OpCodes.Stloc, 7)
12636
12879
LoadClassIL.MarkSequencePoint(doc6, 40, 1, 40, 100)
12637
Dim locbldr105 As LocalBuilder = LoadClassIL.DeclareLocal(GetType(System.Boolean))
12638
locbldr105.SetLocalSymInfo("nest")
12880
Dim locbldr107 As LocalBuilder = LoadClassIL.DeclareLocal(GetType(System.Boolean))
12881
locbldr107.SetLocalSymInfo("nest")
12639
12882
LoadClassIL.Emit(OpCodes.Ldc_I4, 0)
12640
12883
Typ = GetType(System.Boolean)
12641
12884
LoadClassIL.Emit(OpCodes.Stloc, 8)
12650
12893
LoadClassIL.MarkSequencePoint(doc6, 46, 1, 46, 100)
12651
12894
Dim label4 As System.Reflection.Emit.Label = LoadClassIL.DefineLabel()
12652
12895
LoadClassIL.MarkSequencePoint(doc6, 48, 1, 48, 100)
12653
Dim locbldr106 As LocalBuilder = LoadClassIL.DeclareLocal(GetType(System.String).MakeArrayType())
12654
locbldr106.SetLocalSymInfo("na")
12896
Dim locbldr108 As LocalBuilder = LoadClassIL.DeclareLocal(GetType(System.String).MakeArrayType())
12897
locbldr108.SetLocalSymInfo("na")
12655
12898
Dim typ1(-1) As Type
12656
12899
LoadClassIL.Emit(OpCodes.Ldarg, 0)
12657
12900
Typ = GetType(System.String)
13110
13353
Dim LoadMethodparam02 As ParameterBuilder = LoadMethod.DefineParameter(2, ParameterAttributes.None, "name")
13111
13354
Dim LoadMethodparam03 As ParameterBuilder = LoadMethod.DefineParameter(3, ParameterAttributes.None, "typs")
13112
13355
LoadMethodIL.MarkSequencePoint(doc6, 137, 1, 137, 100)
13113
Dim locbldr107 As LocalBuilder = LoadMethodIL.DeclareLocal(GetType(System.Type))
13114
locbldr107.SetLocalSymInfo("temptyp")
13356
Dim locbldr109 As LocalBuilder = LoadMethodIL.DeclareLocal(GetType(System.Type))
13357
locbldr109.SetLocalSymInfo("temptyp")
13115
13358
LoadMethodIL.Emit(OpCodes.Ldnull)
13116
13359
LoadMethodIL.Emit(OpCodes.Stloc, 0)
13117
13360
LoadMethodIL.MarkSequencePoint(doc6, 138, 1, 138, 100)
13118
Dim locbldr108 As LocalBuilder = LoadMethodIL.DeclareLocal(GetType(System.Type).MakeArrayType())
13119
locbldr108.SetLocalSymInfo("ints")
13361
Dim locbldr110 As LocalBuilder = LoadMethodIL.DeclareLocal(GetType(System.Type).MakeArrayType())
13362
locbldr110.SetLocalSymInfo("ints")
13120
13363
LoadMethodIL.Emit(OpCodes.Ldnull)
13121
13364
LoadMethodIL.Emit(OpCodes.Stloc, 1)
13122
13365
LoadMethodIL.MarkSequencePoint(doc6, 139, 1, 139, 100)
13123
Dim locbldr109 As LocalBuilder = LoadMethodIL.DeclareLocal(GetType(System.Int32))
13124
locbldr109.SetLocalSymInfo("i")
13366
Dim locbldr111 As LocalBuilder = LoadMethodIL.DeclareLocal(GetType(System.Int32))
13367
locbldr111.SetLocalSymInfo("i")
13125
13368
LoadMethodIL.Emit(OpCodes.Ldc_I4, CInt(-1))
13126
13369
Typ = GetType(System.Int32)
13127
13370
LoadMethodIL.Emit(OpCodes.Stloc, 2)
13128
13371
LoadMethodIL.MarkSequencePoint(doc6, 140, 1, 140, 100)
13129
Dim locbldr110 As LocalBuilder = LoadMethodIL.DeclareLocal(GetType(System.Int32))
13130
locbldr110.SetLocalSymInfo("len")
13372
Dim locbldr112 As LocalBuilder = LoadMethodIL.DeclareLocal(GetType(System.Int32))
13373
locbldr112.SetLocalSymInfo("len")
13131
13374
LoadMethodIL.Emit(OpCodes.Ldc_I4, CInt(0))
13132
13375
Typ = GetType(System.Int32)
13133
13376
LoadMethodIL.Emit(OpCodes.Stloc, 3)
13134
13377
LoadMethodIL.MarkSequencePoint(doc6, 141, 1, 141, 100)
13135
Dim locbldr111 As LocalBuilder = LoadMethodIL.DeclareLocal(GetType(MethodInfo))
13136
locbldr111.SetLocalSymInfo("mtdinfo")
13378
Dim locbldr113 As LocalBuilder = LoadMethodIL.DeclareLocal(GetType(MethodInfo))
13379
locbldr113.SetLocalSymInfo("mtdinfo")
13137
13380
LoadMethodIL.Emit(OpCodes.Ldnull)
13138
13381
LoadMethodIL.Emit(OpCodes.Stloc, 4)
13139
13382
LoadMethodIL.MarkSequencePoint(doc6, 143, 1, 143, 100)
13306
13549
Dim LoadFieldparam01 As ParameterBuilder = LoadField.DefineParameter(1, ParameterAttributes.None, "typ")
13307
13550
Dim LoadFieldparam02 As ParameterBuilder = LoadField.DefineParameter(2, ParameterAttributes.None, "name")
13308
13551
LoadFieldIL.MarkSequencePoint(doc6, 186, 1, 186, 100)
13309
Dim locbldr112 As LocalBuilder = LoadFieldIL.DeclareLocal(GetType(System.Type))
13310
locbldr112.SetLocalSymInfo("temptyp")
13552
Dim locbldr114 As LocalBuilder = LoadFieldIL.DeclareLocal(GetType(System.Type))
13553
locbldr114.SetLocalSymInfo("temptyp")
13311
13554
LoadFieldIL.Emit(OpCodes.Ldnull)
13312
13555
LoadFieldIL.Emit(OpCodes.Stloc, 0)
13313
13556
LoadFieldIL.MarkSequencePoint(doc6, 187, 1, 187, 100)
13314
Dim locbldr113 As LocalBuilder = LoadFieldIL.DeclareLocal(GetType(FIeldInfo))
13315
locbldr113.SetLocalSymInfo("fldinfo")
13557
Dim locbldr115 As LocalBuilder = LoadFieldIL.DeclareLocal(GetType(FIeldInfo))
13558
locbldr115.SetLocalSymInfo("fldinfo")
13316
13559
LoadFieldIL.Emit(OpCodes.Ldnull)
13317
13560
LoadFieldIL.Emit(OpCodes.Stloc, 1)
13318
13561
LoadFieldIL.MarkSequencePoint(doc6, 189, 1, 189, 100)
13359
13602
Typ = Typ03.GetMethod("get_IsEnum", Type.EmptyTypes).ReturnType
13360
13603
LoadFieldIL.Emit(OpCodes.Stsfld, EnumLitFlag)
13361
13604
LoadFieldIL.MarkSequencePoint(doc6, 195, 1, 195, 100)
13362
Dim locbldr114 As LocalBuilder = LoadFieldIL.DeclareLocal(GetType(System.Object))
13363
locbldr114.SetLocalSymInfo("nullref")
13605
Dim locbldr116 As LocalBuilder = LoadFieldIL.DeclareLocal(GetType(System.Object))
13606
locbldr116.SetLocalSymInfo("nullref")
13364
13607
LoadFieldIL.Emit(OpCodes.Ldnull)
13365
13608
LoadFieldIL.Emit(OpCodes.Stloc, 2)
13366
13609
LoadFieldIL.MarkSequencePoint(doc6, 196, 1, 196, 100)
13376
13619
Typ = Typ03.GetMethod("GetValue", typ22).ReturnType
13377
13620
LoadFieldIL.Emit(OpCodes.Stsfld, FldLitVal)
13378
13621
LoadFieldIL.MarkSequencePoint(doc6, 197, 1, 197, 100)
13379
Dim locbldr115 As LocalBuilder = LoadFieldIL.DeclareLocal(GetType(System.Object))
13380
locbldr115.SetLocalSymInfo("obj")
13622
Dim locbldr117 As LocalBuilder = LoadFieldIL.DeclareLocal(GetType(System.Object))
13623
locbldr117.SetLocalSymInfo("obj")
13381
13624
LoadFieldIL.Emit(OpCodes.Ldsfld, FldLitVal)
13382
13625
Typ = FldLitVal.FieldType
13383
13626
LoadFieldIL.Emit(OpCodes.Stloc, 3)
13442
13685
Dim PrintString As MethodBuilder = ConsolePrinter.DefineMethod("PrintString", MethodAttributes.Public Or MethodAttributes.Static, GetType(System.Void), Type.EmptyTypes)
13443
13686
Dim PrintStringIL As ILGenerator = PrintString.GetILGenerator()
13444
13687
PrintStringIL.MarkSequencePoint(doc7, 18, 1, 18, 100)
13445
Dim locbldr116 As LocalBuilder = PrintStringIL.DeclareLocal(GetType(System.String))
13446
locbldr116.SetLocalSymInfo("str")
13688
Dim locbldr118 As LocalBuilder = PrintStringIL.DeclareLocal(GetType(System.String))
13689
locbldr118.SetLocalSymInfo("str")
13447
13690
PrintStringIL.Emit(OpCodes.Ldsfld, SW)
13448
13691
Typ = SW.FieldType
13449
13692
Typ03 = Typ
13475
13718
WriteClassIL.Emit(OpCodes.Newobj, GetType(StringWriter).GetConstructor(Type.EmptyTypes))
13476
13719
WriteClassIL.Emit(OpCodes.Stsfld, SW)
13477
13720
WriteClassIL.MarkSequencePoint(doc7, 26, 1, 26, 100)
13478
Dim locbldr117 As LocalBuilder = WriteClassIL.DeclareLocal(GetType(System.Boolean))
13479
locbldr117.SetLocalSymInfo("isAbstract")
13721
Dim locbldr119 As LocalBuilder = WriteClassIL.DeclareLocal(GetType(System.Boolean))
13722
locbldr119.SetLocalSymInfo("isAbstract")
13480
13723
WriteClassIL.Emit(OpCodes.Ldarg, 0)
13481
13724
Typ = GetType(System.Type)
13482
13725
Typ03 = Typ
13484
13727
Typ = Typ03.GetMethod("get_IsAbstract", Type.EmptyTypes).ReturnType
13485
13728
WriteClassIL.Emit(OpCodes.Stloc, 0)
13486
13729
WriteClassIL.MarkSequencePoint(doc7, 27, 1, 27, 100)
13487
Dim locbldr118 As LocalBuilder = WriteClassIL.DeclareLocal(GetType(System.Boolean))
13488
locbldr118.SetLocalSymInfo("isAnsi")
13730
Dim locbldr120 As LocalBuilder = WriteClassIL.DeclareLocal(GetType(System.Boolean))
13731
locbldr120.SetLocalSymInfo("isAnsi")
13489
13732
WriteClassIL.Emit(OpCodes.Ldarg, 0)
13490
13733
Typ = GetType(System.Type)
13491
13734
Typ03 = Typ
13493
13736
Typ = Typ03.GetMethod("get_IsAnsiClass", Type.EmptyTypes).ReturnType
13494
13737
WriteClassIL.Emit(OpCodes.Stloc, 1)
13495
13738
WriteClassIL.MarkSequencePoint(doc7, 28, 1, 28, 100)
13496
Dim locbldr119 As LocalBuilder = WriteClassIL.DeclareLocal(GetType(System.Boolean))
13497
locbldr119.SetLocalSymInfo("isAutoChar")
13739
Dim locbldr121 As LocalBuilder = WriteClassIL.DeclareLocal(GetType(System.Boolean))
13740
locbldr121.SetLocalSymInfo("isAutoChar")
13498
13741
WriteClassIL.Emit(OpCodes.Ldarg, 0)
13499
13742
Typ = GetType(System.Type)
13500
13743
Typ03 = Typ
13502
13745
Typ = Typ03.GetMethod("get_IsAutoClass", Type.EmptyTypes).ReturnType
13503
13746
WriteClassIL.Emit(OpCodes.Stloc, 2)
13504
13747
WriteClassIL.MarkSequencePoint(doc7, 29, 1, 29, 100)
13505
Dim locbldr120 As LocalBuilder = WriteClassIL.DeclareLocal(GetType(System.Boolean))
13506
locbldr120.SetLocalSymInfo("isAuto")
13748
Dim locbldr122 As LocalBuilder = WriteClassIL.DeclareLocal(GetType(System.Boolean))
13749
locbldr122.SetLocalSymInfo("isAuto")
13507
13750
WriteClassIL.Emit(OpCodes.Ldarg, 0)
13508
13751
Typ = GetType(System.Type)
13509
13752
Typ03 = Typ
13511
13754
Typ = Typ03.GetMethod("get_IsAutoLayout", Type.EmptyTypes).ReturnType
13512
13755
WriteClassIL.Emit(OpCodes.Stloc, 3)
13513
13756
WriteClassIL.MarkSequencePoint(doc7, 30, 1, 30, 100)
13514
Dim locbldr121 As LocalBuilder = WriteClassIL.DeclareLocal(GetType(System.Boolean))
13515
locbldr121.SetLocalSymInfo("isEnum")
13757
Dim locbldr123 As LocalBuilder = WriteClassIL.DeclareLocal(GetType(System.Boolean))
13758
locbldr123.SetLocalSymInfo("isEnum")
13516
13759
WriteClassIL.Emit(OpCodes.Ldarg, 0)
13517
13760
Typ = GetType(System.Type)
13518
13761
Typ03 = Typ
13520
13763
Typ = Typ03.GetMethod("get_IsEnum", Type.EmptyTypes).ReturnType
13521
13764
WriteClassIL.Emit(OpCodes.Stloc, 4)
13522
13765
WriteClassIL.MarkSequencePoint(doc7, 31, 1, 31, 100)
13523
Dim locbldr122 As LocalBuilder = WriteClassIL.DeclareLocal(GetType(System.Boolean))
13524
locbldr122.SetLocalSymInfo("isInterface")
13766
Dim locbldr124 As LocalBuilder = WriteClassIL.DeclareLocal(GetType(System.Boolean))
13767
locbldr124.SetLocalSymInfo("isInterface")
13525
13768
WriteClassIL.Emit(OpCodes.Ldarg, 0)
13526
13769
Typ = GetType(System.Type)
13527
13770
Typ03 = Typ
13529
13772
Typ = Typ03.GetMethod("get_IsInterface", Type.EmptyTypes).ReturnType
13530
13773
WriteClassIL.Emit(OpCodes.Stloc, 5)
13531
13774
WriteClassIL.MarkSequencePoint(doc7, 32, 1, 32, 100)
13532
Dim locbldr123 As LocalBuilder = WriteClassIL.DeclareLocal(GetType(System.Boolean))
13533
locbldr123.SetLocalSymInfo("isNestedPrivate")
13775
Dim locbldr125 As LocalBuilder = WriteClassIL.DeclareLocal(GetType(System.Boolean))
13776
locbldr125.SetLocalSymInfo("isNestedPrivate")
13534
13777
WriteClassIL.Emit(OpCodes.Ldarg, 0)
13535
13778
Typ = GetType(System.Type)
13536
13779
Typ03 = Typ
13538
13781
Typ = Typ03.GetMethod("get_IsNestedPrivate", Type.EmptyTypes).ReturnType
13539
13782
WriteClassIL.Emit(OpCodes.Stloc, 6)
13540
13783
WriteClassIL.MarkSequencePoint(doc7, 33, 1, 33, 100)
13541
Dim locbldr124 As LocalBuilder = WriteClassIL.DeclareLocal(GetType(System.Boolean))
13542
locbldr124.SetLocalSymInfo("isNestedPublic")
13784
Dim locbldr126 As LocalBuilder = WriteClassIL.DeclareLocal(GetType(System.Boolean))
13785
locbldr126.SetLocalSymInfo("isNestedPublic")
13543
13786
WriteClassIL.Emit(OpCodes.Ldarg, 0)
13544
13787
Typ = GetType(System.Type)
13545
13788
Typ03 = Typ
13547
13790
Typ = Typ03.GetMethod("get_IsNestedPublic", Type.EmptyTypes).ReturnType
13548
13791
WriteClassIL.Emit(OpCodes.Stloc, 7)
13549
13792
WriteClassIL.MarkSequencePoint(doc7, 34, 1, 34, 100)
13550
Dim locbldr125 As LocalBuilder = WriteClassIL.DeclareLocal(GetType(System.Boolean))
13551
locbldr125.SetLocalSymInfo("isPrivate")
13793
Dim locbldr127 As LocalBuilder = WriteClassIL.DeclareLocal(GetType(System.Boolean))
13794
locbldr127.SetLocalSymInfo("isPrivate")
13552
13795
WriteClassIL.Emit(OpCodes.Ldarg, 0)
13553
13796
Typ = GetType(System.Type)
13554
13797
Typ03 = Typ
13556
13799
Typ = Typ03.GetMethod("get_IsNotPublic", Type.EmptyTypes).ReturnType
13557
13800
WriteClassIL.Emit(OpCodes.Stloc, 8)
13558
13801
WriteClassIL.MarkSequencePoint(doc7, 35, 1, 35, 100)
13559
Dim locbldr126 As LocalBuilder = WriteClassIL.DeclareLocal(GetType(System.Boolean))
13560
locbldr126.SetLocalSymInfo("isPublic")
13802
Dim locbldr128 As LocalBuilder = WriteClassIL.DeclareLocal(GetType(System.Boolean))
13803
locbldr128.SetLocalSymInfo("isPublic")
13561
13804
WriteClassIL.Emit(OpCodes.Ldarg, 0)
13562
13805
Typ = GetType(System.Type)
13563
13806
Typ03 = Typ
13565
13808
Typ = Typ03.GetMethod("get_IsPublic", Type.EmptyTypes).ReturnType
13566
13809
WriteClassIL.Emit(OpCodes.Stloc, 9)
13567
13810
WriteClassIL.MarkSequencePoint(doc7, 36, 1, 36, 100)
13568
Dim locbldr127 As LocalBuilder = WriteClassIL.DeclareLocal(GetType(System.String))
13569
locbldr127.SetLocalSymInfo("name")
13811
Dim locbldr129 As LocalBuilder = WriteClassIL.DeclareLocal(GetType(System.String))
13812
locbldr129.SetLocalSymInfo("name")
13570
13813
WriteClassIL.Emit(OpCodes.Ldarg, 0)
13571
13814
Typ = GetType(System.Type)
13572
13815
Typ03 = Typ
13574
13817
Typ = Typ03.GetMethod("get_Name", Type.EmptyTypes).ReturnType
13575
13818
WriteClassIL.Emit(OpCodes.Stloc, 10)
13576
13819
WriteClassIL.MarkSequencePoint(doc7, 37, 1, 37, 100)
13577
Dim locbldr128 As LocalBuilder = WriteClassIL.DeclareLocal(GetType(System.Type))
13578
locbldr128.SetLocalSymInfo("bt")
13820
Dim locbldr130 As LocalBuilder = WriteClassIL.DeclareLocal(GetType(System.Type))
13821
locbldr130.SetLocalSymInfo("bt")
13579
13822
WriteClassIL.Emit(OpCodes.Ldarg, 0)
13580
13823
Typ = GetType(System.Type)
13581
13824
Typ03 = Typ
13583
13826
Typ = Typ03.GetMethod("get_BaseType", Type.EmptyTypes).ReturnType
13584
13827
WriteClassIL.Emit(OpCodes.Stloc, 11)
13585
13828
WriteClassIL.MarkSequencePoint(doc7, 38, 1, 38, 100)
13586
Dim locbldr129 As LocalBuilder = WriteClassIL.DeclareLocal(GetType(System.String))
13587
locbldr129.SetLocalSymInfo("btstr")
13829
Dim locbldr131 As LocalBuilder = WriteClassIL.DeclareLocal(GetType(System.String))
13830
locbldr131.SetLocalSymInfo("btstr")
13588
13831
WriteClassIL.Emit(OpCodes.Ldloc, 11)
13589
13832
Typ = GetType(System.Type)
13590
13833
Typ03 = Typ
14016
14259
Sub Main()
14017
14260
14018
14261
asmName = New AssemblyName("dnr")
14019
asmName.Version = New System.Version(11, 2, 7, 3)
14262
asmName.Version = New System.Version(11, 2, 7, 4)
14020
14263
asm = AppDomain.CurrentDomain.DefineDynamicAssembly(asmName, AssemblyBuilderAccess.Save, CStr("E:\Code\dylannet\dnr\"))
14021
14264
mdl = asm.DefineDynamicModule(asmName.Name & ".dll" , asmName.Name & ".dll", True)
14022
14265
resw = mdl.DefineResource("dnr.resources" , "Description")
14043
14286
ConsolePrinter()
14044
14287
Dim vaType As Type = GetType(AssemblyFileVersionAttribute)
14045
14288
Dim vaCtor As ConstructorInfo = vaType.GetConstructor(New Type() { GetType(String) })
14046
Dim vaBuilder As CustomAttributeBuilder = New CustomAttributeBuilder(vaCtor, New Object() {"11.2.7.3"})
14289
Dim vaBuilder As CustomAttributeBuilder = New CustomAttributeBuilder(vaCtor, New Object() {"11.2.7.4"})
14047
14290
asm.SetCustomAttribute(vaBuilder)
14048
14291
14049
14292
Dim paType As Type = GetType(AssemblyProductAttribute)
Loggerhead is a web-based interface for Breezy
Version: 2.0.1