2002-07-15 Dietmar Maurer <dietmar@ximian.com>
[mono.git] / mono / metadata / object.h
1 #ifndef _MONO_CLI_OBJECT_H_
2 #define _MONO_CLI_OBJECT_H_
3
4 #include <mono/metadata/class.h>
5 #include <mono/metadata/threads-types.h>
6
7 #if 1
8 #define mono_assert(expr)                  G_STMT_START{                  \
9      if (!(expr))                                                         \
10        {                                                                  \
11                 MonoException *ex;                                        \
12                 char *msg = g_strdup_printf ("file %s: line %d (%s): "    \
13                 "assertion failed: (%s)", __FILE__, __LINE__,             \
14                 __PRETTY_FUNCTION__, #expr);                              \
15                 ex = mono_get_exception_execution_engine (msg);           \
16                 g_free (msg);                                             \
17                 mono_raise_exception (ex);                                \
18        };                               }G_STMT_END
19
20 #define mono_assert_not_reached()                 G_STMT_START{           \
21      MonoException *ex;                                                   \
22      char *msg = g_strdup_printf ("file %s: line %d (%s): "               \
23      "should not be reached", __FILE__, __LINE__, __PRETTY_FUNCTION__);   \
24      ex = mono_get_exception_execution_engine (msg);                      \
25      g_free (msg);                                                        \
26      mono_raise_exception (ex);                                           \
27 }G_STMT_END
28 #else
29 #define mono_assert(expr) g_assert(expr)
30 #define mono_assert_not_reached() g_assert_not_reached() 
31 #endif
32
33 #define MONO_CHECK_ARG(arg, expr)               G_STMT_START{             \
34      if (!(expr))                                                         \
35        {                                                                  \
36                 MonoException *ex;                                        \
37                 char *msg = g_strdup_printf ("assertion `%s' failed",     \
38                 #expr);                                                   \
39                 if (arg) {} /* check if the name exists */                \
40                 ex = mono_get_exception_argument (#arg, msg);             \
41                 g_free (msg);                                             \
42                 mono_raise_exception (ex);                                \
43        };                               }G_STMT_END
44
45 #define MONO_CHECK_ARG_NULL(arg)            G_STMT_START{                 \
46      if (arg == NULL)                                                     \
47        {                                                                  \
48                 MonoException *ex;                                        \
49                 if (arg) {} /* check if the name exists */                \
50                 ex = mono_get_exception_argument_null (#arg);             \
51                 mono_raise_exception (ex);                                \
52        };                               }G_STMT_END
53
54 typedef guchar MonoBoolean;
55
56 typedef struct _MonoReflectionMethod MonoReflectionMethod;
57 typedef struct _MonoDelegate MonoDelegate;
58
59 typedef struct {
60         MonoVTable *vtable;
61         MonoThreadsSync *synchronisation;
62 } MonoObject;
63
64 typedef struct {
65         guint32 length;
66         guint32 lower_bound;
67 } MonoArrayBounds;
68
69 typedef struct {
70         MonoObject obj;
71         /* bounds is NULL for szarrays */
72         MonoArrayBounds *bounds;
73         /* total number of elements of the array */
74         guint32 max_length; 
75         /* we use double to ensure proper alignment on platforms that need it */
76         double vector [MONO_ZERO_LEN_ARRAY];
77 } MonoArray;
78
79 typedef struct {
80         MonoObject object;
81         gint32 length;
82         gunichar2 chars [MONO_ZERO_LEN_ARRAY];
83 } MonoString;
84
85 typedef struct {
86         MonoObject object;
87         gint32 capacity;
88         gint32 length;
89         MonoArray *chars;
90 } MonoStringBuilder;
91
92 typedef struct {
93         MonoObject object;
94         MonoType  *type;
95 } MonoReflectionType;
96
97 typedef struct {
98         MonoObject object;
99         MonoArray  *trace_ips;
100         MonoObject *inner_ex;
101         MonoString *message;
102         MonoString *help_link;
103         MonoString *class_name;
104         MonoString *stack_trace;
105         MonoString *remote_stack_trace;
106         gint32     *remote_stack_index;
107         gint32      hresult;
108         MonoString *source;
109 } MonoException;
110
111 typedef struct {
112         MonoException base;
113 } MonoSystemException;
114
115 typedef struct {
116         MonoSystemException base;
117         MonoString *param_name;
118 } MonoArgumentException;
119
120 typedef struct {
121         MonoObject   object;
122         MonoObject  *async_state;
123         MonoObject  *handle;
124         MonoObject  *async_delegate;
125         gpointer     data;
126         MonoBoolean  sync_completed;
127         MonoBoolean  completed;
128         MonoBoolean  endinvoke_called;
129 } MonoAsyncResult;
130
131 typedef struct {
132         MonoObject   object;
133         gpointer     handle;
134         MonoBoolean  disposed;
135 } MonoWaitHandle;
136
137 typedef struct {
138         MonoObject  object;
139         MonoReflectionType *class_to_proxy;     
140 } MonoRealProxy;
141
142 typedef struct {
143         MonoObject     object;
144         MonoRealProxy *rp;      
145         MonoClass     *klass; 
146 } MonoTransparentProxy;
147
148 typedef struct {
149         MonoObject obj;
150         MonoReflectionMethod *method;
151         MonoArray  *args;               
152         MonoArray  *names;              
153         MonoArray  *arg_types;  
154         MonoObject *ctx;
155         MonoObject *rval;
156         MonoObject *exc;
157 } MonoMethodMessage;
158
159 typedef struct {
160         MonoObject obj;
161         gint32 il_offset;
162         gint32 native_offset;
163         MonoReflectionMethod *method;
164         MonoString *filename;
165         gint32 line;
166         gint32 column;
167 } MonoStackFrame;
168
169 typedef MonoObject* (*MonoInvokeFunc)        (MonoMethod *method, void *obj, void **params, MonoObject **exc);
170 typedef gpointer    (*MonoCompileFunc)       (MonoMethod *method);
171
172 #define mono_object_class(obj) (((MonoObject*)(obj))->vtable->klass)
173 #define mono_object_domain(obj) (((MonoObject*)(obj))->vtable->domain)
174
175 #define mono_array_length(array) ((array)->max_length)
176 #define mono_array_addr(array,type,index) ( ((char*)(array)->vector) + sizeof (type) * (index) )
177 #define mono_array_addr_with_size(array,size,index) ( ((char*)(array)->vector) + (size) * (index) )
178 #define mono_array_get(array,type,index) ( *(type*)mono_array_addr ((array), type, (index)) ) 
179 #define mono_array_set(array,type,index,value)  \
180         do {    \
181                 type *__p = (type *) mono_array_addr ((array), type, (index));  \
182                 *__p = (value); \
183         } while (0)
184
185 #define mono_string_chars(s) ((gunichar2*)(s)->chars)
186 #define mono_string_length(s) ((s)->length)
187
188 void *
189 mono_object_allocate        (size_t size);
190
191 MonoObject *
192 mono_object_new             (MonoDomain *domain, MonoClass *klass);
193
194 MonoObject *
195 mono_object_new_specific    (MonoVTable *vtable);
196
197 MonoObject *
198 mono_object_new_from_token  (MonoDomain *domain, MonoImage *image, guint32 token);
199
200 MonoArray*
201 mono_array_new              (MonoDomain *domain, MonoClass *eclass, guint32 n);
202
203 MonoArray*
204 mono_array_new_full         (MonoDomain *domain, MonoClass *array_class,
205                              guint32 *lengths, guint32 *lower_bounds);
206
207 MonoArray *
208 mono_array_new_specific     (MonoVTable *vtable, guint32 n);
209
210 MonoArray*
211 mono_array_clone            (MonoArray *array);
212
213 MonoString*
214 mono_string_new_utf16       (MonoDomain *domain, const guint16 *text, gint32 len);
215
216 MonoString*
217 mono_string_new_size            (MonoDomain *domain, gint32 len);
218
219 MonoString*
220 mono_ldstr                  (MonoDomain *domain, MonoImage *image, guint32 str_index);
221
222 MonoString*
223 mono_string_is_interned     (MonoString *str);
224
225 MonoString*
226 mono_string_intern          (MonoString *str);
227
228 MonoString*
229 mono_string_new             (MonoDomain *domain, const char *text);
230
231 MonoString*
232 mono_string_new_wrapper     (const char *text);
233
234 MonoString*
235 mono_string_new_len         (MonoDomain *domain, const char *text, guint length);
236
237 char *
238 mono_string_to_utf8         (MonoString *string_obj);
239
240 gunichar2 *
241 mono_string_to_utf16        (MonoString *string_obj);
242
243 void       
244 mono_object_free            (MonoObject *o);
245
246 MonoObject *
247 mono_value_box              (MonoDomain *domain, MonoClass *klass, gpointer val);
248                       
249 MonoObject *
250 mono_object_clone           (MonoObject *obj);
251
252 MonoObject *
253 mono_object_isinst          (MonoObject *obj, MonoClass *klass);
254
255 typedef void (*MonoExceptionFunc) (MonoException *ex);
256
257 void
258 mono_install_handler        (MonoExceptionFunc func);
259
260 void
261 mono_raise_exception        (MonoException *ex);
262
263 void
264 mono_runtime_object_init    (MonoObject *this);
265
266 void
267 mono_runtime_class_init     (MonoClass *klass);
268
269 void        
270 mono_install_runtime_invoke (MonoInvokeFunc func);
271
272 void        
273 mono_install_compile_method (MonoCompileFunc func);
274
275 MonoObject*
276 mono_runtime_invoke         (MonoMethod *method, void *obj, void **params,
277                              MonoObject **exc);
278
279 MonoMethod *
280 mono_get_delegate_invoke    (MonoClass *klass);
281
282 MonoObject*
283 mono_runtime_delegate_invoke (MonoObject *delegate, void **params, 
284                               MonoObject **exc);
285
286 MonoObject*
287 mono_runtime_invoke_array   (MonoMethod *method, void *obj, MonoArray *params,
288                              MonoObject **exc);
289
290 MonoArray*
291 mono_runtime_get_main_args  (void);
292
293 int
294 mono_runtime_run_main       (MonoMethod *method, int argc, char* argv[], 
295                              MonoObject **exc);
296
297 int
298 mono_runtime_exec_main      (MonoMethod *method, MonoArray *args,
299                              MonoObject **exc);
300
301 MonoAsyncResult *
302 mono_async_result_new       (MonoDomain *domain, HANDLE handle, 
303                              MonoObject *state, gpointer data);
304
305 MonoWaitHandle *
306 mono_wait_handle_new        (MonoDomain *domain, HANDLE handle);
307
308 void
309 mono_message_init           (MonoDomain *domain, MonoMethodMessage *this, 
310                              MonoReflectionMethod *method, MonoArray *out_args);
311
312 MonoObject *
313 mono_remoting_invoke        (MonoObject *real_proxy, MonoMethodMessage *msg, 
314                              MonoObject **exc, MonoArray **out_args);
315
316 MonoObject *
317 mono_message_invoke         (MonoObject *target, MonoMethodMessage *msg, 
318                              MonoObject **exc, MonoArray **out_args);
319
320 MonoMethodMessage *
321 mono_method_call_message_new (MonoMethod *method, gpointer *params, MonoMethod *invoke, 
322                               MonoDelegate **cb, MonoObject **state);
323
324 void
325 mono_method_return_message_restore (MonoMethod *method, gpointer *params, MonoArray *out_args);
326
327 void
328 mono_unhandled_exception    (MonoObject *exc);
329
330 void
331 mono_print_unhandled_exception (MonoObject *exc);
332
333 void
334 mono_delegate_ctor          (MonoObject *this, MonoObject *target, gpointer addr);
335
336 gpointer 
337 mono_compile_method        (MonoMethod *method);
338
339 #endif
340