Remove useless typedefs.

diff --git a/src/mc/ModelChecker.cpp b/src/mc/ModelChecker.cpp
index d657f2a..67eb84b 100644 (file)
--- a/src/mc/ModelChecker.cpp
+++ b/src/mc/ModelChecker.cpp
@@ -196,7 +196,7 @@ static void MC_report_assertion_error()
 
 bool ModelChecker::handle_message(char* buffer, ssize_t size)
 {
-  mc_message_t base_message;
+  s_mc_message_t base_message;
   if (size < (ssize_t) sizeof(base_message))
     xbt_die("Broken message");
   memcpy(&base_message, buffer, sizeof(base_message));
@@ -388,7 +388,7 @@ void ModelChecker::wait_for_requests()
 
 void ModelChecker::handle_simcall(Transition const& transition)
 {
-  s_mc_message_simcall_handle m;
+  s_mc_message_simcall_handle_t m;
   memset(&m, 0, sizeof(m));
   m.type  = MC_MESSAGE_SIMCALL_HANDLE;
   m.pid   = transition.pid;
@@ -404,7 +404,7 @@ bool ModelChecker::checkDeadlock()
   int res;
   if ((res = this->process().getChannel().send(MC_MESSAGE_DEADLOCK_CHECK)))
     xbt_die("Could not check deadlock state");
-  mc_message_int_t message;
+  s_mc_message_int_t message;
   ssize_t s = mc_model_checker->process().getChannel().receive(message);
   if (s == -1)
     xbt_die("Could not receive message");

diff --git a/src/mc/mc_checkpoint.cpp b/src/mc/mc_checkpoint.cpp
index 6538130..3295f91 100644 (file)
--- a/src/mc/mc_checkpoint.cpp
+++ b/src/mc/mc_checkpoint.cpp
@@ -585,7 +585,7 @@ void restore_snapshot_regions(simgrid::mc::Snapshot* snapshot)
 #if HAVE_SMPI
   if(snapshot->privatization_index >= 0) {
     // Fix the privatization mmap:
-    s_mc_message_restore message{MC_MESSAGE_RESTORE, snapshot->privatization_index};
+    s_mc_message_restore_t message{MC_MESSAGE_RESTORE, snapshot->privatization_index};
     mc_model_checker->process().getChannel().send(message);
   }
 #endif

diff --git a/src/mc/remote/Channel.hpp b/src/mc/remote/Channel.hpp
index c9de6d6..4553718 100644 (file)
--- a/src/mc/remote/Channel.hpp
+++ b/src/mc/remote/Channel.hpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2015-2016. The SimGrid Team.
+/* Copyright (c) 2015-2017. The SimGrid Team.
  * All rights reserved.                                                     */
 
 /* This program is free software; you can redistribute it and/or modify it
@@ -50,7 +50,7 @@ public:
   int send(const void* message, size_t size) const;
   int send(e_mc_message_type type) const
   {
-    s_mc_message message = {type};
+    s_mc_message_t message = {type};
     return this->send(&message, sizeof(message));
   }
   /** @brief Send a message; returns 0 on success or errno on failure */

diff --git a/src/mc/remote/Client.cpp b/src/mc/remote/Client.cpp
index 362a3cd..291d359 100644 (file)
--- a/src/mc/remote/Client.cpp
+++ b/src/mc/remote/Client.cpp
@@ -83,7 +83,7 @@ Client* Client::initialize()
   return instance_.get();
 }
 
-void Client::handleDeadlockCheck(mc_message_t* msg)
+void Client::handleDeadlockCheck(s_mc_message_t* msg)
 {
   bool deadlock = false;
   if (not simix_global->process_list.empty()) {
@@ -96,10 +96,10 @@ void Client::handleDeadlockCheck(mc_message_t* msg)
   }
 
   // Send result:
-  mc_message_int_t answer{MC_MESSAGE_DEADLOCK_CHECK_REPLY, deadlock};
+  s_mc_message_int_t answer{MC_MESSAGE_DEADLOCK_CHECK_REPLY, deadlock};
   xbt_assert(channel_.send(answer) == 0, "Could not send response");
 }
-void Client::handleContinue(mc_message_t* msg)
+void Client::handleContinue(s_mc_message_t* msg)
 {
   /* Nothing to do */
 }
@@ -121,7 +121,7 @@ void Client::handleRestore(s_mc_message_restore_t* message)
 void Client::handleActorEnabled(s_mc_message_actor_enabled_t* msg)
 {
   bool res = simgrid::mc::actor_is_enabled(SIMIX_process_from_PID(msg->aid));
-  s_mc_message_int answer{MC_MESSAGE_ACTOR_ENABLED_REPLY, res};
+  s_mc_message_int_t answer{MC_MESSAGE_ACTOR_ENABLED_REPLY, res};
   channel_.send(answer);
 }
 
@@ -136,18 +136,18 @@ void Client::handleMessages()
     if (received_size < 0)
       xbt_die("Could not receive commands from the model-checker");
 
-    mc_message_t* message = (mc_message_t*)message_buffer;
+    s_mc_message_t* message = (s_mc_message_t*)message_buffer;
     switch (message->type) {
 
       case MC_MESSAGE_DEADLOCK_CHECK:
-        xbt_assert(received_size == sizeof(mc_message_t), "Unexpected size for DEADLOCK_CHECK (%zd != %zu)",
-                   received_size, sizeof(mc_message_t));
+        xbt_assert(received_size == sizeof(s_mc_message_t), "Unexpected size for DEADLOCK_CHECK (%zd != %zu)",
+                   received_size, sizeof(s_mc_message_t));
         handleDeadlockCheck(message);
         break;
 
       case MC_MESSAGE_CONTINUE:
-        xbt_assert(received_size == sizeof(mc_message_t), "Unexpected size for MESSAGE_CONTINUE (%zd != %zu)",
-                   received_size, sizeof(mc_message_t));
+        xbt_assert(received_size == sizeof(s_mc_message_t), "Unexpected size for MESSAGE_CONTINUE (%zd != %zu)",
+                   received_size, sizeof(s_mc_message_t));
         handleContinue(message);
         return;
 
@@ -159,8 +159,8 @@ void Client::handleMessages()
         break;
 
       case MC_MESSAGE_RESTORE:
-        xbt_assert(received_size == sizeof(mc_message_t), "Unexpected size for MESSAGE_RESTORE (%zd != %zu)",
-                   received_size, sizeof(mc_message_t));
+        xbt_assert(received_size == sizeof(s_mc_message_t), "Unexpected size for MESSAGE_RESTORE (%zd != %zu)",
+                   received_size, sizeof(s_mc_message_t));
         handleRestore((s_mc_message_restore_t*)message_buffer);
         break;
 

diff --git a/src/mc/remote/Client.hpp b/src/mc/remote/Client.hpp
index 05a395a..dc10fd8 100644 (file)
--- a/src/mc/remote/Client.hpp
+++ b/src/mc/remote/Client.hpp
@@ -37,8 +37,8 @@ public:
   void handleMessages();
 
 private:
-  void handleDeadlockCheck(mc_message_t* msg);
-  void handleContinue(mc_message_t* msg);
+  void handleDeadlockCheck(s_mc_message_t* msg);
+  void handleContinue(s_mc_message_t* msg);
   void handleSimcall(s_mc_message_simcall_handle_t* message);
   void handleRestore(s_mc_message_restore_t* msg);
   void handleActorEnabled(s_mc_message_actor_enabled_t* msg);

diff --git a/src/mc/remote/RemoteClient.cpp b/src/mc/remote/RemoteClient.cpp
index 3e7d3e2..d24507b 100644 (file)
--- a/src/mc/remote/RemoteClient.cpp
+++ b/src/mc/remote/RemoteClient.cpp
@@ -650,12 +650,12 @@ void RemoteClient::dumpStack()
 
 bool RemoteClient::actor_is_enabled(aid_t pid)
 {
-  s_mc_message_actor_enabled msg{MC_MESSAGE_ACTOR_ENABLED, pid};
+  s_mc_message_actor_enabled_t msg{MC_MESSAGE_ACTOR_ENABLED, pid};
   process()->getChannel().send(msg);
   char buff[MC_MESSAGE_LENGTH];
   ssize_t received = process()->getChannel().receive(buff, MC_MESSAGE_LENGTH, true);
-  xbt_assert(received == sizeof(s_mc_message_int), "Unexpected size in answer to ACTOR_ENABLED");
-  return ((mc_message_int_t*)buff)->value;
+  xbt_assert(received == sizeof(s_mc_message_int_t), "Unexpected size in answer to ACTOR_ENABLED");
+  return ((s_mc_message_int_t*)buff)->value;
 }
 }
 }

diff --git a/src/mc/remote/mc_protocol.h b/src/mc/remote/mc_protocol.h
index 8a2a089..3aa610a 100644 (file)
--- a/src/mc/remote/mc_protocol.h
+++ b/src/mc/remote/mc_protocol.h
@@ -27,7 +27,7 @@ SG_BEGIN_DECL()
 
 // ***** Messages
 
-typedef enum {
+enum e_mc_message_type {
   MC_MESSAGE_NONE,
   MC_MESSAGE_CONTINUE,
   MC_MESSAGE_IGNORE_HEAP,
@@ -44,7 +44,7 @@ typedef enum {
   MC_MESSAGE_RESTORE,
   MC_MESSAGE_ACTOR_ENABLED,
   MC_MESSAGE_ACTOR_ENABLED_REPLY
-} e_mc_message_type;
+};
 
 #define MC_MESSAGE_LENGTH 512
 
@@ -59,69 +59,60 @@ typedef enum {
  */
 
 /* Basic structure: all message start with a message type */
-struct s_mc_message {
-  e_mc_message_type type;
+struct s_mc_message_t {
+  enum e_mc_message_type type;
 };
-typedef struct s_mc_message mc_message_t;
 
-struct s_mc_message_int {
-  e_mc_message_type type;
+struct s_mc_message_int_t {
+  enum e_mc_message_type type;
   uint64_t value;
 };
-typedef struct s_mc_message_int mc_message_int_t;
 
 /* Client->Server */
-struct s_mc_message_ignore_heap {
-  e_mc_message_type type;
+struct s_mc_message_ignore_heap_t {
+  enum e_mc_message_type type;
   int block;
   int fragment;
   void* address;
   size_t size;
 };
-typedef struct s_mc_message_ignore_heap s_mc_message_ignore_heap_t;
 
-struct s_mc_message_ignore_memory {
-  e_mc_message_type type;
+struct s_mc_message_ignore_memory_t {
+  enum e_mc_message_type type;
   uint64_t addr;
   size_t size;
 };
-typedef struct s_mc_message_ignore_memory s_mc_message_ignore_memory_t;
 
-struct s_mc_message_stack_region {
-  e_mc_message_type type;
+struct s_mc_message_stack_region_t {
+  enum e_mc_message_type type;
   s_stack_region_t stack_region;
 };
-typedef struct s_mc_message_stack_region s_mc_message_stack_region_t;
 
-struct s_mc_message_register_symbol {
-  e_mc_message_type type;
+struct s_mc_message_register_symbol_t {
+  enum e_mc_message_type type;
   char name[128];
   int (*callback)(void*);
   void* data;
 };
-typedef struct s_mc_message_register_symbol s_mc_message_register_symbol_t;
 
 /* Server -> client */
-struct s_mc_message_simcall_handle {
-  e_mc_message_type type;
+struct s_mc_message_simcall_handle_t {
+  enum e_mc_message_type type;
   unsigned long pid;
   int value;
 };
-typedef struct s_mc_message_simcall_handle s_mc_message_simcall_handle_t;
 
-struct s_mc_message_restore {
-  e_mc_message_type type;
+struct s_mc_message_restore_t {
+  enum e_mc_message_type type;
   int index;
 };
-typedef struct s_mc_message_restore s_mc_message_restore_t;
 
-struct s_mc_message_actor_enabled {
-  e_mc_message_type type;
+struct s_mc_message_actor_enabled_t {
+  enum e_mc_message_type type;
   aid_t aid; // actor ID
 };
-typedef struct s_mc_message_actor_enabled s_mc_message_actor_enabled_t;
 
-XBT_PRIVATE const char* MC_message_type_name(e_mc_message_type type);
+XBT_PRIVATE const char* MC_message_type_name(enum e_mc_message_type type);
 
 SG_END_DECL()