return g_string_free (str, FALSE);
}
+/**
+ * mono_signature_get_desc:
+ */
char*
mono_signature_get_desc (MonoMethodSignature *sig, gboolean include_namespace)
{
* Creates a method description for \p name, which conforms to the following
* specification:
*
- * [namespace.]classname:methodname[(args...)]
+ * <code>[namespace.]classname:methodname[(args...)]</code>
*
* in all the loaded assemblies.
*
- * Both classname and methodname can contain '*' which matches anything.
+ * Both classname and methodname can contain <code>*</code> which matches anything.
*
* \returns a parsed representation of the method description.
*/
return result;
}
+/**
+ * mono_method_desc_from_method:
+ */
MonoMethodDesc*
mono_method_desc_from_method (MonoMethod *method)
{
/**
* mono_method_desc_free:
* \param desc method description to be released
- * Releases the MonoMethodDesc object \p desc.
+ * Releases the \c MonoMethodDesc object \p desc.
*/
void
mono_method_desc_free (MonoMethodDesc *desc)
}
/**
- * mono_method_descr_match:
+ * mono_method_desc_match:
* \param desc \c MonoMethoDescription
* \param method \c MonoMethod to test
*
return match_class (desc, pos, klass->nested_in);
}
+/**
+ * mono_method_desc_full_match:
+ */
gboolean
mono_method_desc_full_match (MonoMethodDesc *desc, MonoMethod *method)
{
return mono_method_desc_match (desc, method);
}
+/**
+ * mono_method_desc_search_in_class:
+ */
MonoMethod*
mono_method_desc_search_in_class (MonoMethodDesc *desc, MonoClass *klass)
{
return NULL;
}
+/**
+ * mono_method_desc_search_in_image:
+ */
MonoMethod*
mono_method_desc_search_in_image (MonoMethodDesc *desc, MonoImage *image)
{
return res;
}
+/**
+ * mono_method_full_name:
+ */
char *
mono_method_full_name (MonoMethod *method, gboolean signature)
{
return NULL;
}
-/*
- * token is the method_ref/def/spec token used in a call IL instruction.
- * @deprecated use the _checked variant
+/**
+ * mono_method_get_signature_full:
+ * \p token is the method ref/def/spec token used in a \c call IL instruction.
+ * \deprecated use the \c _checked variant
* Notes: runtime code MUST not use this function
*/
MonoMethodSignature*
return sig;
}
-/*
- * token is the method_ref/def/spec token used in a call IL instruction.
- * @deprecated use the _checked variant
+/**
+ * mono_method_get_signature:
+ * \p token is the method_ref/def/spec token used in a call IL instruction.
+ * \deprecated use the \c _checked variant
* Notes: runtime code MUST not use this function
*/
MonoMethodSignature*
return result;
}
+/**
+ * mono_get_method:
+ */
MonoMethod *
mono_get_method (MonoImage *image, guint32 token, MonoClass *klass)
{
return result;
}
+/**
+ * mono_get_method_full:
+ */
MonoMethod *
mono_get_method_full (MonoImage *image, guint32 token, MonoClass *klass,
MonoGenericContext *context)
}
}
+/**
+ * mono_method_get_param_names:
+ */
void
mono_method_get_param_names (MonoMethod *method, const char **names)
{
}
}
+/**
+ * mono_method_get_param_token:
+ */
guint32
mono_method_get_param_token (MonoMethod *method, int index)
{
return 0;
}
+/**
+ * mono_method_get_marshal_info:
+ */
void
mono_method_get_marshal_info (MonoMethod *method, MonoMarshalSpec **mspecs)
{
}
}
+/**
+ * mono_method_has_marshal_info:
+ */
gboolean
mono_method_has_marshal_info (MonoMethod *method)
{
return managed;
}
+/**
+ * mono_method_get_last_managed:
+ */
MonoMethod*
mono_method_get_last_managed (void)
{
/**
* mono_method_signature:
- *
- * Return the signature of the method M. On failure, returns NULL.
+ * \returns the signature of the method \p m. On failure, returns NULL.
*/
MonoMethodSignature*
mono_method_signature (MonoMethod *m)
return sig;
}
+/**
+ * mono_method_get_name:
+ */
const char*
mono_method_get_name (MonoMethod *method)
{
return method->name;
}
+/**
+ * mono_method_get_class:
+ */
MonoClass*
mono_method_get_class (MonoMethod *method)
{
return method->klass;
}
+/**
+ * mono_method_get_token:
+ */
guint32
mono_method_get_token (MonoMethod *method)
{
return mono_metadata_parse_mh_full (img, container, (const char *)loc, error);
}
+/**
+ * mono_method_get_header:
+ */
MonoMethodHeader*
mono_method_get_header (MonoMethod *method)
{
}
+/**
+ * mono_method_get_flags:
+ */
guint32
mono_method_get_flags (MonoMethod *method, guint32 *iflags)
{
return method->flags;
}
-/*
- * Find the method index in the metadata methodDef table.
+/**
+ * mono_method_get_index:
+ * Find the method index in the metadata \c MethodDef table.
*/
guint32
mono_method_get_index (MonoMethod *method)
}
}
-/*
+/**
* mono_method_header_get_code:
- * @header: a MonoMethodHeader pointer
- * @code_size: memory location for returning the code size
- * @max_stack: memory location for returning the max stack
+ * \param header a \c MonoMethodHeader pointer
+ * \param code_size memory location for returning the code size
+ * \param max_stack memory location for returning the max stack
*
* Method header accessor to retreive info about the IL code properties:
* a pointer to the IL code itself, the size of the code and the max number
* of stack slots used by the code.
*
- * Returns: pointer to the IL code represented by the method header.
+ * \returns pointer to the IL code represented by the method header.
*/
const unsigned char*
mono_method_header_get_code (MonoMethodHeader *header, guint32* code_size, guint32* max_stack)
return header->code;
}
-/*
+/**
* mono_method_header_get_locals:
- * @header: a MonoMethodHeader pointer
- * @num_locals: memory location for returning the number of local variables
- * @init_locals: memory location for returning the init_locals flag
+ * \param header a \c MonoMethodHeader pointer
+ * \param num_locals memory location for returning the number of local variables
+ * \param init_locals memory location for returning the init_locals flag
*
* Method header accessor to retreive info about the local variables:
* an array of local types, the number of locals and whether the locals
* are supposed to be initialized to 0 on method entry
*
- * Returns: pointer to an array of types of the local variables
+ * \returns pointer to an array of types of the local variables
*/
MonoType**
mono_method_header_get_locals (MonoMethodHeader *header, guint32* num_locals, gboolean *init_locals)
return header->num_clauses;
}
-/*
+/**
* mono_method_header_get_clauses:
- * @header: a MonoMethodHeader pointer
- * @method: MonoMethod the header belongs to
- * @iter: pointer to a iterator
- * @clause: pointer to a MonoExceptionClause structure which will be filled with the info
+ * \param header a \c MonoMethodHeader pointer
+ * \param method \c MonoMethod the header belongs to
+ * \param iter pointer to a iterator
+ * \param clause pointer to a \c MonoExceptionClause structure which will be filled with the info
*
- * Get the info about the exception clauses in the method. Set *iter to NULL to
+ * Get the info about the exception clauses in the method. Set \c *iter to NULL to
* initiate the iteration, then call the method repeatedly until it returns FALSE.
* At each iteration, the structure pointed to by clause if filled with the
* exception clause information.
*
- * Returns: TRUE if clause was filled with info, FALSE if there are no more exception
+ * \returns TRUE if clause was filled with info, FALSE if there are no more exception
* clauses.
*/
int
return r;
}
+/**
+ * mono_signature_hash:
+ */
guint
mono_signature_hash (MonoMethodSignature *sig)
{
* A \c void* pointer must be initialized to NULL to start the iteration
* and its address is passed to this function repeteadly until it returns
* NULL.
- * \returns: the next parameter type of the method signature \p sig,
+ * \returns the next parameter type of the method signature \p sig,
* NULL when finished.
*/
MonoType*
* pointers to the value type otherwise.
*
* From unmanaged code you'll usually use the
- * mono_runtime_invoke() variant.
+ * \c mono_runtime_invoke variant.
*
* Note that this function doesn't handle virtual methods for
* you, it will exec the exact method you pass: we still need to
* mono_method_get_unmanaged_thunk:
* \param method method to generate a thunk for.
*
- * Returns an unmanaged->managed thunk that can be used to call
+ * Returns an \c unmanaged->managed thunk that can be used to call
* a managed method directly from C.
*
* The thunk's C signature closely matches the managed signature:
*
- * C#: public bool Equals (object obj);
- * C: typedef MonoBoolean (*Equals)(MonoObject*,
- * MonoObject*, MonoException**);
+ * C#: <code>public bool Equals (object obj);</code>
+ *
+ * C: <code>typedef MonoBoolean (*Equals)(MonoObject*, MonoObject*, MonoException**);</code>
+ *
+ * The 1st (<code>this</code>) parameter must not be used with static methods:
*
- * The 1st ("this") parameter must not be used with static methods:
+ * C#: <code>public static bool ReferenceEquals (object a, object b);</code>
*
- * C#: public static bool ReferenceEquals (object a, object b);
- * C: typedef MonoBoolean (*ReferenceEquals)(MonoObject*, MonoObject*,
- * MonoException**);
+ * C: <code>typedef MonoBoolean (*ReferenceEquals)(MonoObject*, MonoObject*, MonoException**);</code>
*
- * The last argument must be a non-null pointer of a MonoException* pointer.
- * It has "out" semantics. After invoking the thunk, *ex will be NULL if no
+ * The last argument must be a non-null \c MonoException* pointer.
+ * It has "out" semantics. After invoking the thunk, \c *ex will be NULL if no
* exception has been thrown in managed code. Otherwise it will point
- * to the MonoException* caught by the thunk. In this case, the result of
+ * to the \c MonoException* caught by the thunk. In this case, the result of
* the thunk is undefined:
*
+ * <pre>
* MonoMethod *method = ... // MonoMethod* of System.Object.Equals
+ *
* MonoException *ex = NULL;
+ *
* Equals func = mono_method_get_unmanaged_thunk (method);
+ *
* MonoBoolean res = func (thisObj, objToCompare, &ex);
+ *
* if (ex) {
+ *
* // handle exception
+ *
* }
+ * </pre>
*
* The calling convention of the thunk matches the platform's default
* convention. This means that under Windows, C declarations must
- * contain the __stdcall attribute:
+ * contain the \c __stdcall attribute:
*
- * C: typedef MonoBoolean (__stdcall *Equals)(MonoObject*,
- * MonoObject*, MonoException**);
+ * C: <code>typedef MonoBoolean (__stdcall *Equals)(MonoObject*, MonoObject*, MonoException**);</code>
*
* LIMITATIONS
*
* Value type arguments and return values are treated as they were objects:
*
- * C#: public static Rectangle Intersect (Rectangle a, Rectangle b);
- * C: typedef MonoObject* (*Intersect)(MonoObject*, MonoObject*, MonoException**);
+ * C#: <code>public static Rectangle Intersect (Rectangle a, Rectangle b);</code>
+ * C: <code>typedef MonoObject* (*Intersect)(MonoObject*, MonoObject*, MonoException**);</code>
*
* Arguments must be properly boxed upon trunk's invocation, while return
* values must be unboxed.
return MONO_HANDLE_NEW (MonoReflectionType, mono_type_get_object_checked (domain, type, error));
}
-/*
+/**
* mono_method_get_object:
- * @domain: an app domain
- * @method: a method
- * @refclass: the reflected type (can be NULL)
- *
- * Return an System.Reflection.MonoMethod object representing the method @method.
+ * \param domain an app domain
+ * \param method a method
+ * \param refclass the reflected type (can be NULL)
+ * \returns A \c System.Reflection.MonoMethod object representing the method \p method.
*/
MonoReflectionMethod*
mono_method_get_object (MonoDomain *domain, MonoMethod *method, MonoClass *refclass)
return MONO_HANDLE_NEW (MonoArray, NULL_HANDLE);
}
+/**
+ * mono_param_get_objects:
+ */
MonoArray*
mono_param_get_objects (MonoDomain *domain, MonoMethod *method)
{
HANDLE_FUNCTION_RETURN_VAL (is_ok (error));
}
-/*
+/**
* mono_method_body_get_object:
- * @domain: an app domain
- * @method: a method
- *
- * Return an System.Reflection.MethodBody object representing the method @method.
+ * \param domain an app domain
+ * \param method a method
+ * \return A \c System.Reflection.MethodBody object representing the method \p method.
*/
MonoReflectionMethodBody*
mono_method_body_get_object (MonoDomain *domain, MonoMethod *method)
/*
* FIXME: need to distinguish between valid and verifiable.
* Need to keep track of types on the stack.
+ */
+
+/**
+ * mono_method_verify:
* Verify types for opcodes.
*/
GSList*
projects / mono.git / commitdiff