1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
//
// Mono.ILASM.GenericTypeInst
//
// Author(s):
// Jackson Harper (Jackson@LatitudeGeo.com)
// Ankit Jain (JAnkit@novell.com)
//
// (C) 2003 Latitude Geographics Group, All rights reserved
// (C) 2005 Novell, Inc (http://www.novell.com)
//
using System;
using System.Collections;
namespace Mono.ILASM {
public class GenericTypeInst : BaseGenericTypeRef {
private BaseClassRef class_ref;
private PEAPI.GenericTypeInst p_gen_inst;
private bool is_valuetypeinst;
private GenericArguments gen_args;
private bool is_added; /* Added to PEFile (to TypeSpec table) ? */
/* Note: Using static hashtable here as GenericTypeInsts is not cached */
private static Hashtable s_method_table = new Hashtable ();
private static Hashtable s_field_table = new Hashtable ();
public GenericTypeInst (BaseClassRef class_ref, GenericArguments gen_args, bool is_valuetypeinst)
: this (class_ref, gen_args, is_valuetypeinst, null, null)
{
}
public GenericTypeInst (BaseClassRef class_ref, GenericArguments gen_args, bool is_valuetypeinst,
string sig_mod, ArrayList conv_list)
: base ("", is_valuetypeinst, conv_list, sig_mod)
{
if (class_ref is GenericTypeInst)
throw new InternalErrorException ("Cannot create nested GenericInst, '" +
class_ref.FullName + "' '" + gen_args.ToString () + "'");
this.class_ref = class_ref;
this.gen_args = gen_args;
is_added = false;
}
public override string FullName {
get { return class_ref.FullName + gen_args.ToString () + SigMod; }
}
public override BaseClassRef Clone ()
{
//Clone'd instance shares the class_ref and gen_args,
//as its basically used to create modified types (arrays etc)
return new GenericTypeInst (class_ref, gen_args, is_valuetypeinst, sig_mod,
(ArrayList) ConversionList.Clone () );
}
public override void MakeValueClass ()
{
class_ref.MakeValueClass ();
}
public override void ResolveNoTypeSpec (CodeGen code_gen)
{
if (is_resolved)
return;
class_ref.Resolve (code_gen);
p_gen_inst = (PEAPI.GenericTypeInst) class_ref.ResolveInstance (code_gen, gen_args);
type = Modify (code_gen, p_gen_inst);
is_resolved = true;
}
public override void Resolve (CodeGen code_gen)
{
ResolveNoTypeSpec (code_gen);
if (is_added)
return;
code_gen.PEFile.AddGenericClass ((PEAPI.GenericTypeInst) p_gen_inst);
is_added = true;
}
public override void Resolve (GenericParameters type_gen_params, GenericParameters method_gen_params)
{
gen_args.Resolve (type_gen_params, method_gen_params);
}
protected override BaseMethodRef CreateMethodRef (BaseTypeRef ret_type,
PEAPI.CallConv call_conv, string name, BaseTypeRef[] param, int gen_param_count)
{
throw new InternalErrorException ("Should not be called");
}
public override BaseMethodRef GetMethodRef (BaseTypeRef ret_type, PEAPI.CallConv call_conv,
string meth_name, BaseTypeRef[] param, int gen_param_count)
{
/* Note: Using FullName here as we are caching in a static hashtable */
string key = FullName + MethodDef.CreateSignature (ret_type, meth_name, param, gen_param_count);
TypeSpecMethodRef mr = s_method_table [key] as TypeSpecMethodRef;
if (mr == null) {
mr = new TypeSpecMethodRef (this, call_conv, ret_type, meth_name, param, gen_param_count);
s_method_table [key] = mr;
}
return mr;
}
protected override IFieldRef CreateFieldRef (BaseTypeRef ret_type, string field_name)
{
/* Note: Using FullName here as we are caching in a static hashtable */
string key = FullName + ret_type.FullName + field_name;
IFieldRef fr = (IFieldRef) s_field_table [key];
if (fr == null) {
fr = new TypeSpecFieldRef (this, ret_type, field_name);
s_field_table [key] = fr;
}
return fr;
}
}
}
|
