when linking, ignore unknown .reloc section that appeared in gcc 3.4.5(?)
[ghc-hetmet.git] / rts / dotnet / Invoker.cpp
1 //
2 // (c) 2002-2003, sof.
3 //
4 // Dynamic invocation helper classes. The details of how
5 // to access the .NET object model via the Reflection API
6 // is taken care of by Invoker.{h,cpp}
7 //
8 #include "Invoker.h"
9
10 namespace DynInvoke {
11
12 static TypeName* ParseType(String* str) {
13     int curPos = 0;
14     int endPos;
15
16     //    Console::WriteLine("x{0}y", str);
17     TypeName* typeName = new TypeName();
18
19     if ( str->get_Chars(0) == '[' ) {
20       endPos = str->IndexOf(']');
21       curPos = endPos + 1;
22       typeName->m_assembly = str->Substring(1,endPos-1);
23       typeName->m_length = endPos+1;
24     }
25     String* delimStr = " ,()";
26     Char delims __gc [] = delimStr->ToCharArray();
27
28     endPos  = str->IndexOfAny(delims,curPos);
29     //    Console::WriteLine("{0} {1} x{2}x", __box(endPos), __box(curPos), str);
30     if ( endPos == -1 ) {
31       typeName->m_class = str->Substring(curPos);
32     } else {
33       typeName->m_class = str->Substring(curPos,endPos-curPos);
34     }
35
36     //    typeName->m_class = str->Substring(curPos,endPos-curPos);
37     typeName->m_length += endPos-curPos;
38
39     return typeName;
40 }
41
42 // Method: GetType(String* typeName);
43 // 
44 // Purpose: Assembly-savvy version of Type::GetType()
45 //
46 Type* InvokeBridge::GetType(String* typeName) {
47
48   try {
49     Type* t = Type::GetType(typeName);
50     if (t) return t;
51   } catch (Exception*) {
52     ;
53   }
54
55   for (int i=0;i < InvokeBridge::m_assemblies->Count; i++) {
56      try {
57        String* stuff = String::Format("{0},{1}",typeName,InvokeBridge::m_assemblies->get_Item(i)->ToString());
58        //       Console::WriteLine(stuff);
59        Type* t = Type::GetType(stuff);
60        if (t) {
61          return t;
62        }
63      } catch (Exception*) {
64        continue;
65      }
66   }
67   return 0;
68 }
69
70 //
71 // Method:  CreateInstance(String* typeName, Object* [])
72 //
73 // Purpose: Assembly-savvy invocation of Activator::CreateInstance
74 Object* InvokeBridge::CreateInstance(TypeName* typeName,
75                                      Object* args[]) {
76
77   Object* instance = 0;
78   Type*   t = InvokeBridge::GetType(typeName->toStdString());
79
80   //  Console::WriteLine("x{0} y{1}", typeName->toStdString(), t);
81   if (!t) {
82     try {
83       Assembly* localA = Assembly::LoadFrom(typeName->m_assembly);
84       t = localA->GetType(typeName->m_class);
85     } catch (Exception* e) {
86       ;
87     }
88   }
89   
90   if (!t) {
91     try {
92       AppDomain* currentDomain = AppDomain::CurrentDomain;
93       
94       //      Assembly* stuff[] = currentDomain->GetAssemblies();
95       //      for (int i=0;i < stuff.Length; i++) {
96       //        Console::WriteLine("x{0} y{1}", stuff[i]->ToString(), stuff[i]->FullName);
97       //      }
98       //      Console::WriteLine("x{0} y{1}", typeName->toStdString(), t);
99       Assembly* localA = Assembly::LoadWithPartialName("HugsAssembly");
100       t = localA->GetType(typeName->m_class);
101       //      Console::WriteLine("x{0} y{1}", typeName->toStdString(), t);
102     } catch (Exception*) {
103       ;
104     }
105   }
106
107   if (t) {
108     try {
109       Object* o =Activator::CreateInstance(t,(Object* [])args);
110       return o;
111     } catch (Exception* e) {
112       Console::WriteLine("Failure: {0}", e);
113       return 0;
114     }
115   }
116 }
117
118 //
119 // Method: CreateObject(String* objSpec, Object* args[])
120 //
121 // Purpose: Given a fully qualified name of a class/type, try
122 //          to create an instance of it.
123 //
124 Object* InvokeBridge::CreateObject(String* assemName,
125                                    String* objSpec,
126                                    Object* args[]) {
127  
128   Object* instance = 0;
129
130   // Unravel the name of the class/type.
131   TypeName* typeName = ParseType(objSpec);
132   
133   if (assemName != 0 && assemName->Length > 0) {
134     typeName->m_assembly = assemName;
135   }
136
137   // Try creating the instance..
138   try {
139     instance = InvokeBridge::CreateInstance(typeName,(Object* [])args);
140   } catch (Exception* e) {
141     Console::WriteLine("Unable to create instance \"{0}\" {1}", objSpec, e);
142     throw(e);
143   }
144   if (!instance) {
145     Console::WriteLine("Unable to create instance \"{0}\"", objSpec);
146   }
147   return instance;
148 }
149
150 //
151 // Method:  InvokeMethod
152 // 
153 // Purpose: Given a pointer to an already created object, look up
154 //          one of its method. If found, invoke the method passing it
155 //          'args' as arguments.
156 //
157 Object*
158 InvokeBridge::InvokeMethod(Object* obj, 
159                            String* methName,
160                            Object* args[]) {
161   // Get the methods from the type
162   MethodInfo* methods __gc[] = obj->GetType()->GetMethods();
163   MethodInfo* mInfo;
164
165   if (!methods) {
166     Console::WriteLine("InvokeMethod: No matching types found");
167     return 0;
168   }
169                         
170   System::Reflection::BindingFlags flgs 
171     = (System::Reflection::BindingFlags) // why do I need to cast?
172       (System::Reflection::BindingFlags::Public       |
173        System::Reflection::BindingFlags::NonPublic    |
174        System::Reflection::BindingFlags::Instance     |
175        System::Reflection::BindingFlags::Static       |
176        System::Reflection::BindingFlags::InvokeMethod);
177     
178   /* Caller is assumed to catch any exceptions raised. */
179   return obj->GetType()->InvokeMember(methName,
180                                       flgs,
181                                       0,
182                                       obj,
183                                       (Object __gc* [])args);
184 }
185
186 //
187 // Method:  InvokeStaticMethod
188 // 
189 // Purpose: Invoke a static method, given the fully qualified name
190 //          of the method (and its arguments). If found, invoke the
191 //          method passing it 'args' as arguments.
192 //
193 Object* InvokeBridge::InvokeStaticMethod(String* assemName,
194                                          String* typeAndMethName,
195                                          Object* args[]) {
196
197   // Get the methods from the type
198   MethodInfo* methods __gc[];
199   MethodInfo* mInfo;
200
201   int lastDot = typeAndMethName->LastIndexOf('.');
202   String* className = typeAndMethName->Substring(0,lastDot);
203   String* methName  = typeAndMethName->Substring(lastDot+1);
204
205   // Unravel the name of the class/type.
206   TypeName* typeName = ParseType(className);
207   Type* t;
208   
209   if (assemName != 0 && assemName->Length > 0) {
210     typeName->m_assembly = assemName;
211   }
212   
213   try {
214     t = InvokeBridge::GetType(typeName->toStdString());
215     
216     if (!t) {
217       try {
218         Assembly* localA = Assembly::LoadFrom(typeName->m_assembly);
219         t = localA->GetType(typeName->m_class);
220         //      Console::WriteLine("InvokeStaticMethod: Type {0} found", t);
221       } catch (Exception* e) {
222         ;
223       }
224     }
225
226     if (t) {
227       methods = t->GetMethods();
228     } else {
229       Console::WriteLine("InvokeStaticMethod: Type {0} not found", className);
230       return 0;
231     }
232   } catch (Exception *e) {
233       Console::WriteLine("InvokeStaticMethod: Type {0} not found", className);
234       throw(e);
235   }
236
237   System::Reflection::BindingFlags flgs 
238     = (System::Reflection::BindingFlags) // why do I need to cast?
239       (System::Reflection::BindingFlags::DeclaredOnly |
240        System::Reflection::BindingFlags::Public       |
241        System::Reflection::BindingFlags::NonPublic    |
242        System::Reflection::BindingFlags::Static       |
243        System::Reflection::BindingFlags::InvokeMethod);
244     
245   return t->InvokeMember(methName,
246                          flgs,
247                          0,
248                          0,
249                          (Object __gc* [])args);
250 }
251
252 //
253 // Method:  GetField
254 //
255 // Purpose: Fetch the (boxed) value of named field of a given object.
256 //
257 Object* InvokeBridge::GetField(Object* obj, System::String* fieldName) {
258
259   FieldInfo* fInfo = obj->GetType()->GetField(fieldName);
260   return fInfo->GetValue(obj);
261 }
262
263 //
264 // Method:  GetStaticField
265 //
266 // Purpose: Fetch the (boxed) value of named static field.
267 //
268 Object* InvokeBridge::GetStaticField(System::String* clsName,
269                                      System::String* fieldName) {
270
271   Type* ty = InvokeBridge::GetType(clsName);
272   System::Reflection::BindingFlags static_field_flgs 
273     = (System::Reflection::BindingFlags)
274     (System::Reflection::BindingFlags::Public       |
275      System::Reflection::BindingFlags::NonPublic    |
276      System::Reflection::BindingFlags::FlattenHierarchy |
277      System::Reflection::BindingFlags::Static);
278
279   FieldInfo* fInfo = ty->GetField(fieldName, static_field_flgs);
280   return fInfo->GetValue(0); // according to doc, ok to pass any val here.
281 }
282
283 //
284 // Method:  SetField
285 //
286 // Purpose: Replace the (boxed) value of named field of a given object.
287 //
288 void InvokeBridge::SetField(Object* obj, System::String* fieldName, Object* val) {
289
290   FieldInfo* fInfo = obj->GetType()->GetField(fieldName);
291   fInfo->SetValue(obj,val);
292   return;
293 }
294
295 //
296 // Method:  SetStaticField
297 //
298 // Purpose: Replace the (boxed) value of named static field.
299 //
300 void InvokeBridge::SetStaticField(System::String* clsName,
301                                   System::String* fieldName,
302                                   Object* val) {
303
304   Type* ty = InvokeBridge::GetType(clsName);
305   System::Reflection::BindingFlags static_field_flgs 
306     = (System::Reflection::BindingFlags)
307     (System::Reflection::BindingFlags::Public       |
308      System::Reflection::BindingFlags::NonPublic    |
309      System::Reflection::BindingFlags::FlattenHierarchy |
310      System::Reflection::BindingFlags::Static);
311   
312   FieldInfo* fInfo = ty->GetField(fieldName,static_field_flgs);
313   fInfo->SetValue(0,val);
314   return;
315 }
316
317 Object* InvokeBridge::NewString(System::String* s)
318 {
319   System::String* c = System::String::Copy(s);
320   return dynamic_cast<Object*>(c);
321 }
322
323 Array* InvokeBridge::NewArgArray(int sz)
324 {
325  return Array::CreateInstance(__typeof(Object), sz); 
326 }
327
328 void InvokeBridge::SetArg(Object* arr[], Object* val, int idx)
329 {
330  arr->SetValue(val,idx);
331 }
332
333 Object* InvokeBridge::GetArg(Object* arr[], int idx)
334 {
335  return arr->GetValue(idx);
336 }
337
338 } /* namespace */