[runtime] Make some headers c++ clean.

diff --git a/mono/metadata/debug-helpers.c b/mono/metadata/debug-helpers.c
index 4991d86b5a1336ceec0e72094a486ead4254acc8..e8acbe99d1cfc46f07fdd46247b42c996ca15d57 100644 (file)
--- a/mono/metadata/debug-helpers.c
+++ b/mono/metadata/debug-helpers.c
@@ -19,7 +19,7 @@
 #include "mono/metadata/appdomain.h"
 
 struct MonoMethodDesc {
-       char *namespace;
+       char *name_space;
        char *klass;
        char *name;
        char *args;
@@ -344,7 +344,7 @@ mono_method_desc_new (const char *name, gboolean include_namespace)
        result->include_namespace = include_namespace;
        result->name = method_name;
        result->klass = class_name;
-       result->namespace = use_namespace? class_nspace: NULL;
+       result->name_space = use_namespace? class_nspace: NULL;
        result->args = use_args? use_args: NULL;
        if (strstr (result->name, "*"))
                result->name_glob = TRUE;
@@ -373,7 +373,7 @@ mono_method_desc_from_method (MonoMethod *method)
        result->include_namespace = TRUE;
        result->name = g_strdup (method->name);
        result->klass = g_strdup (method->klass->name);
-       result->namespace = g_strdup (method->klass->name_space);
+       result->name_space = g_strdup (method->klass->name_space);
 
        return result;
 }
@@ -387,8 +387,8 @@ mono_method_desc_from_method (MonoMethod *method)
 void
 mono_method_desc_free (MonoMethodDesc *desc)
 {
-       if (desc->namespace)
-               g_free (desc->namespace);
+       if (desc->name_space)
+               g_free (desc->name_space);
        else if (desc->klass)
                g_free (desc->klass);
        g_free (desc);
@@ -454,7 +454,7 @@ match_class (MonoMethodDesc *desc, int pos, MonoClass *klass)
        if (!p) {
                if (strncmp (desc->klass, klass->name, pos))
                        return FALSE;
-               if (desc->namespace && strcmp (desc->namespace, klass->name_space))
+               if (desc->name_space && strcmp (desc->name_space, klass->name_space))
                        return FALSE;
                return TRUE;
        }
@@ -499,14 +499,14 @@ mono_method_desc_search_in_image (MonoMethodDesc *desc, MonoImage *image)
        int i;
 
        /* Handle short names for system classes */
-       if (!desc->namespace && image == mono_defaults.corlib) {
+       if (!desc->name_space && image == mono_defaults.corlib) {
                klass = find_system_class (desc->klass);
                if (klass)
                        return mono_method_desc_search_in_class (desc, klass);
        }
 
-       if (desc->namespace && desc->klass) {
-               klass = mono_class_from_name (image, desc->namespace, desc->klass);
+       if (desc->name_space && desc->klass) {
+               klass = mono_class_from_name (image, desc->name_space, desc->klass);
                if (!klass)
                        return NULL;
                return mono_method_desc_search_in_class (desc, klass);

diff --git a/mono/metadata/object-internals.h b/mono/metadata/object-internals.h
index 428b77ab6f5ce833473f57727fa8bf3f5b437d0f..027d3e1b8a675b4d07ae1c5967789ffe0827ba0d 100644 (file)
--- a/mono/metadata/object-internals.h
+++ b/mono/metadata/object-internals.h
@@ -637,7 +637,7 @@ MonoObject *
 mono_async_result_invoke    (MonoAsyncResult *ares, MonoObject **exc);
 
 MonoObject *
-ves_icall_System_Runtime_Remoting_Messaging_AsyncResult_Invoke (MonoAsyncResult *this);
+ves_icall_System_Runtime_Remoting_Messaging_AsyncResult_Invoke (MonoAsyncResult *this_obj);
 
 MonoWaitHandle *
 mono_wait_handle_new       (MonoDomain *domain, HANDLE handle);

diff --git a/mono/metadata/object.c b/mono/metadata/object.c
index 3103c2096abb156fdff6b7736f7879a3eea13faf..4c0792dcb56544d7fc96971100dcbd59a21a97a2 100644 (file)
--- a/mono/metadata/object.c
+++ b/mono/metadata/object.c
@@ -5827,10 +5827,10 @@ mono_async_result_invoke (MonoAsyncResult *ares, MonoObject **exc)
 }
 
 MonoObject *
-ves_icall_System_Runtime_Remoting_Messaging_AsyncResult_Invoke (MonoAsyncResult *this)
+ves_icall_System_Runtime_Remoting_Messaging_AsyncResult_Invoke (MonoAsyncResult *this_obj)
 {
        MonoObject *exc = NULL;
-       MonoObject *res = mono_async_result_invoke (this, &exc);
+       MonoObject *res = mono_async_result_invoke (this_obj, &exc);
        if (exc)
                mono_raise_exception ((MonoException*) exc);
        return res;

diff --git a/mono/metadata/threads-types.h b/mono/metadata/threads-types.h
index 0b469b1795dda6a69f0924d6701ea621987b73a2..5ffafe61b78e1c8eb1d04385ce7f2ebbb2fc55ee 100644 (file)
--- a/mono/metadata/threads-types.h
+++ b/mono/metadata/threads-types.h
@@ -72,13 +72,13 @@ void ves_icall_System_Threading_Thread_ConstructInternalThread (MonoThread *this
 HANDLE ves_icall_System_Threading_Thread_Thread_internal(MonoThread *this_obj, MonoObject *start);
 void ves_icall_System_Threading_InternalThread_Thread_free_internal(MonoInternalThread *this_obj, HANDLE thread);
 void ves_icall_System_Threading_Thread_Sleep_internal(gint32 ms);
-gboolean ves_icall_System_Threading_Thread_Join_internal(MonoThread *this, int ms);
+gboolean ves_icall_System_Threading_Thread_Join_internal(MonoThread *this_obj, int ms);
 gint32 ves_icall_System_Threading_Thread_GetDomainID (void);
 gboolean ves_icall_System_Threading_Thread_Yield (void);
 MonoString* ves_icall_System_Threading_Thread_GetName_internal (MonoInternalThread *this_obj);
 void ves_icall_System_Threading_Thread_SetName_internal (MonoInternalThread *this_obj, MonoString *name);
-int ves_icall_System_Threading_Thread_GetPriority (MonoThread *this);
-void ves_icall_System_Threading_Thread_SetPriority (MonoThread *this, int priority);
+int ves_icall_System_Threading_Thread_GetPriority (MonoThread *this_obj);
+void ves_icall_System_Threading_Thread_SetPriority (MonoThread *this_obj, int priority);
 MonoObject* ves_icall_System_Threading_Thread_GetCachedCurrentCulture (MonoInternalThread *this_obj);
 void ves_icall_System_Threading_Thread_SetCachedCurrentCulture (MonoThread *this_obj, MonoObject *culture);
 MonoObject* ves_icall_System_Threading_Thread_GetCachedCurrentUICulture (MonoInternalThread *this_obj);
@@ -136,9 +136,9 @@ gint32 ves_icall_System_Threading_Interlocked_Decrement_Int(gint32 *location);
 gint64 ves_icall_System_Threading_Interlocked_Decrement_Long(gint64 * location);
 
 void ves_icall_System_Threading_Thread_Abort (MonoInternalThread *thread, MonoObject *state);
-void ves_icall_System_Threading_Thread_ResetAbort (MonoThread *this);
+void ves_icall_System_Threading_Thread_ResetAbort (MonoThread *this_obj);
 MonoObject* ves_icall_System_Threading_Thread_GetAbortExceptionState (MonoThread *thread);
-void ves_icall_System_Threading_Thread_Suspend (MonoThread *this);
+void ves_icall_System_Threading_Thread_Suspend (MonoThread *this_obj);
 void ves_icall_System_Threading_Thread_Resume (MonoThread *thread);
 void ves_icall_System_Threading_Thread_ClrState (MonoInternalThread *thread, guint32 state);
 void ves_icall_System_Threading_Thread_SetState (MonoInternalThread *thread, guint32 state);
@@ -181,7 +181,7 @@ void ves_icall_System_Threading_Volatile_WriteDouble (void *ptr, double);
 void ves_icall_System_Threading_Volatile_Write_T (void *ptr, MonoObject *value);
 
 void ves_icall_System_Threading_Thread_MemoryBarrier (void);
-void ves_icall_System_Threading_Thread_Interrupt_internal (MonoThread *this);
+void ves_icall_System_Threading_Thread_Interrupt_internal (MonoThread *this_obj);
 void ves_icall_System_Threading_Thread_SpinWait_nop (void);
 
 void ves_icall_System_Runtime_Remoting_Contexts_Context_RegisterContext (MonoAppContext *ctx);

diff --git a/mono/metadata/threads.c b/mono/metadata/threads.c
index ded97fdf404c15e31bc2115269e041b7b740f854..10757da64566b4b90499a7c586c5f4d186d63400 100644 (file)
--- a/mono/metadata/threads.c
+++ b/mono/metadata/threads.c
@@ -1094,28 +1094,28 @@ mono_thread_exit ()
 }
 
 void
-ves_icall_System_Threading_Thread_ConstructInternalThread (MonoThread *this)
+ves_icall_System_Threading_Thread_ConstructInternalThread (MonoThread *this_obj)
 {
        MonoInternalThread *internal = create_internal_thread ();
 
        internal->state = ThreadState_Unstarted;
 
-       InterlockedCompareExchangePointer ((gpointer)&this->internal_thread, internal, NULL);
+       InterlockedCompareExchangePointer ((gpointer)&this_obj->internal_thread, internal, NULL);
 }
 
 HANDLE
-ves_icall_System_Threading_Thread_Thread_internal (MonoThread *this,
+ves_icall_System_Threading_Thread_Thread_internal (MonoThread *this_obj,
                                                                                                   MonoObject *start)
 {
        StartInfo *start_info;
        MonoInternalThread *internal;
        gboolean res;
 
-       THREAD_DEBUG (g_message("%s: Trying to start a new thread: this (%p) start (%p)", __func__, this, start));
+       THREAD_DEBUG (g_message("%s: Trying to start a new thread: this (%p) start (%p)", __func__, this_obj, start));
 
-       if (!this->internal_thread)
-               ves_icall_System_Threading_Thread_ConstructInternalThread (this);
-       internal = this->internal_thread;
+       if (!this_obj->internal_thread)
+               ves_icall_System_Threading_Thread_ConstructInternalThread (this_obj);
+       internal = this_obj->internal_thread;
 
        LOCK_THREAD (internal);
 
@@ -1127,17 +1127,17 @@ ves_icall_System_Threading_Thread_Thread_internal (MonoThread *this,
 
        if ((internal->state & ThreadState_Aborted) != 0) {
                UNLOCK_THREAD (internal);
-               return this;
+               return this_obj;
        }
        /* This is freed in start_wrapper */
        start_info = g_new0 (StartInfo, 1);
        start_info->func = NULL;
-       start_info->start_arg = this->start_obj; /* FIXME: GC object stored in unmanaged memory */
+       start_info->start_arg = this_obj->start_obj; /* FIXME: GC object stored in unmanaged memory */
        start_info->delegate = start;
-       start_info->obj = this;
-       g_assert (this->obj.vtable->domain == mono_domain_get ());
+       start_info->obj = this_obj;
+       g_assert (this_obj->obj.vtable->domain == mono_domain_get ());
 
-       res = create_thread (this, internal, start_info, FALSE, 0, FALSE);
+       res = create_thread (this_obj, internal, start_info, FALSE, 0, FALSE);
        if (!res) {
                UNLOCK_THREAD (internal);
                return NULL;
@@ -1155,7 +1155,7 @@ ves_icall_System_Threading_Thread_Thread_internal (MonoThread *this,
  * This is called from the finalizer of the internal thread object.
  */
 void
-ves_icall_System_Threading_InternalThread_Thread_free_internal (MonoInternalThread *this, HANDLE thread)
+ves_icall_System_Threading_InternalThread_Thread_free_internal (MonoInternalThread *this_obj, HANDLE thread)
 {
        THREAD_DEBUG (g_message ("%s: Closing thread %p, handle %p", __func__, this, thread));
 
@@ -1167,16 +1167,16 @@ ves_icall_System_Threading_InternalThread_Thread_free_internal (MonoInternalThre
        if (thread)
                CloseHandle (thread);
 
-       if (this->synch_cs) {
-               mono_mutex_t *synch_cs = this->synch_cs;
-               this->synch_cs = NULL;
+       if (this_obj->synch_cs) {
+               mono_mutex_t *synch_cs = this_obj->synch_cs;
+               this_obj->synch_cs = NULL;
                mono_mutex_destroy (synch_cs);
                g_free (synch_cs);
        }
 
-       if (this->name) {
-               void *name = this->name;
-               this->name = NULL;
+       if (this_obj->name) {
+               void *name = this_obj->name;
+               this_obj->name = NULL;
                g_free (name);
        }
 }
@@ -2022,23 +2022,23 @@ ves_icall_System_Threading_Thread_GetState (MonoInternalThread* this)
        return state;
 }
 
-void ves_icall_System_Threading_Thread_Interrupt_internal (MonoThread *this)
+void ves_icall_System_Threading_Thread_Interrupt_internal (MonoThread *this_obj)
 {
        MonoInternalThread *current;
        gboolean throw;
-       MonoInternalThread *this_obj = this->internal_thread;
+       MonoInternalThread *thread = this_obj->internal_thread;
 
-       LOCK_THREAD (this_obj);
+       LOCK_THREAD (thread);
 
        current = mono_thread_internal_current ();
 
-       this_obj->thread_interrupt_requested = TRUE;
-       throw = current != this_obj && (this_obj->state & ThreadState_WaitSleepJoin);
+       thread->thread_interrupt_requested = TRUE;
+       throw = current != thread && (thread->state & ThreadState_WaitSleepJoin);
 
-       UNLOCK_THREAD (this_obj);
+       UNLOCK_THREAD (thread);
        
        if (throw) {
-               abort_thread_internal (this_obj, TRUE, FALSE);
+               abort_thread_internal (thread, TRUE, FALSE);
        }
 }
 
@@ -2104,7 +2104,7 @@ ves_icall_System_Threading_Thread_Abort (MonoInternalThread *thread, MonoObject
 }
 
 void
-ves_icall_System_Threading_Thread_ResetAbort (MonoThread *this)
+ves_icall_System_Threading_Thread_ResetAbort (MonoThread *this_obj)
 {
        MonoInternalThread *thread = mono_thread_internal_current ();
        gboolean was_aborting;
@@ -2208,9 +2208,9 @@ mono_thread_suspend (MonoInternalThread *thread)
 }
 
 void
-ves_icall_System_Threading_Thread_Suspend (MonoThread *this)
+ves_icall_System_Threading_Thread_Suspend (MonoThread *this_obj)
 {
-       if (!mono_thread_suspend (this->internal_thread)) {
+       if (!mono_thread_suspend (this_obj->internal_thread)) {
                mono_set_pending_exception (mono_get_exception_thread_state ("Thread has not been started, or is dead."));
                return;
        }