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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
|
using System;
using System.Reflection.Emit;
using System.Reflection;
namespace go
{
public static class CompilerServices
{
public static void createDynHandler(string eventName,
object dstObj, Type handlerArgsType, string destProp, string src)
{
Type dstType = dstObj.GetType ();
Type[] args = {typeof(object), handlerArgsType};
DynamicMethod hello = new DynamicMethod("dynHandle",
typeof(void),
args,
dstType.Module);
MethodInfo dstMi = dstType.GetProperty (destProp).GetSetMethod ();
FieldInfo srcFi = typeof(go.Color).GetField (src, BindingFlags.Static|BindingFlags.Public);
ILGenerator il = hello.GetILGenerator(256);
il.Emit(OpCodes.Ldarg_0);
il.Emit (OpCodes.Ldsfld, srcFi);
il.Emit(OpCodes.Callvirt, dstMi);
il.Emit(OpCodes.Ret);
//hello.DefineParameter(1, ParameterAttributes.In, "instance");
//hello.DefineParameter(2, ParameterAttributes.In, "value");
FieldInfo fi = getEventHandlerField (dstType, eventName);
Delegate del = hello.CreateDelegate(fi.FieldType);
fi.SetValue(dstObj, del);
}
static int dynHandleCpt = 0;
public static void CompileEventSource(EventSource es)
{
Type srcType = es.Source.GetType ();
#region Retrieve EventHandler parameter type
EventInfo ei = srcType.GetEvent (es.EventName);
MethodInfo invoke = ei.EventHandlerType.GetMethod ("Invoke");
ParameterInfo[] pars = invoke.GetParameters ();
Type handlerArgsType = pars [1].ParameterType;
#endregion
Type[] args = {typeof(object), handlerArgsType};
DynamicMethod dm = new DynamicMethod("dynHandle_" + dynHandleCpt,
typeof(void),
args,
srcType.Module);
#region IL generation
ILGenerator il = dm.GetILGenerator(256);
string src = es.Handler.Trim();
if (! (src.StartsWith("{") || src.EndsWith ("}")))
throw new Exception (string.Format("GOML:Malformed {0} Event handler: {1}", es.EventName, es.Handler));
src = src.Substring (1, src.Length - 2);
string[] srcLines = src.Split (new char[] { ';' });
foreach (string srcLine in srcLines) {
string statement = srcLine.Trim ();
string[] operandes = statement.Split (new char[] { '=' });
if (operandes.Length < 2) //not an affectation
{
continue;
}
string lop = operandes [0].Trim ();
string rop = operandes [operandes.Length-1].Trim ();
#region LEFT OPERANDES
GraphicObject lopObj = es.Source; //default left operand base object is
//the first arg (object sender) of the event handler
string[] lopParts = lop.Split (new char[] { '.' });
if (lopParts.Length == 2) {//should search also for member of es.Source
lopObj = es.Source.FindByName (lopParts [0]);
if (lopObj==null)
throw new Exception (string.Format("GOML:Unknown name: {0}", lopParts[0]));
//TODO: should create private member holding ref of lopObj, and emit
//a call to FindByName(lopObjName) during #ctor or in a onLoad func or evt handler
throw new Exception (string.Format("GOML:obj tree ref not yet implemented", lopParts[0]));
}else
il.Emit(OpCodes.Ldarg_0); //load sender ref onto the stack
int i = lopParts.Length -1;
MemberInfo lopMbi = lopObj.GetType().GetMember (lopParts[i])[0];
OpCode lopSetOC;
dynamic lopSetMbi;
Type lopT = null;
switch (lopMbi.MemberType) {
case MemberTypes.Property:
PropertyInfo lopPi = srcType.GetProperty (lopParts[i]);
MethodInfo dstMi = lopPi.GetSetMethod ();
lopT = lopPi.PropertyType;
lopSetMbi = dstMi;
lopSetOC = OpCodes.Callvirt;
break;
case MemberTypes.Field:
FieldInfo dstFi = srcType.GetField(lopParts[i]);
lopT = dstFi.FieldType;
lopSetMbi = dstFi;
lopSetOC = OpCodes.Stfld;
break;
default:
throw new Exception (string.Format("GOML:member type not handle: {0}", lopParts[i]));
}
#endregion
#region RIGHT OPERANDES
if (rop.StartsWith("\'")){
if (!rop.EndsWith("\'"))
throw new Exception (string.Format
("GOML:malformed string constant in handler: {0}", rop));
string strcst = rop.Substring (1, rop.Length - 2);
il.Emit(OpCodes.Ldstr,strcst);
}else{
//search for a static field in left operand type named 'rop name'
FieldInfo ropFi = lopT.GetField (rop, BindingFlags.Static|BindingFlags.Public);
if (ropFi != null)
{
il.Emit (OpCodes.Ldsfld, ropFi);
}else{
//search if parsing methods are present
MethodInfo lopTryParseMi = lopT.GetMethod("TryParse");
}
}
#endregion
//emit left operand assignment
il.Emit(lopSetOC, lopSetMbi);
}
il.Emit(OpCodes.Ret);
#endregion
FieldInfo evtFi = getEventHandlerField (srcType, es.EventName);
Delegate del = dm.CreateDelegate(evtFi.FieldType);
evtFi.SetValue(es.Source, del);
}
public static FieldInfo getEventHandlerField(Type type, string eventName)
{
FieldInfo fi;
Type ty = type;
do {
fi = ty.GetField (eventName,
BindingFlags.NonPublic |
BindingFlags.Instance |
BindingFlags.GetField);
ty = ty.BaseType;
if (ty == null)
break;
} while(fi == null);
return fi;
}
}
}
|
