SI_DeviceGBA: Amend variable naming

Source/Core/Core/HW/SI/SI_DeviceGBA.cpp

@@ -20,16 +20,15 @@
 #include "Core/HW/SI/SI_Device.h"
 #include "Core/HW/SystemTimers.h"
 
-static std::thread connectionThread;
-static std::queue<std::unique_ptr<sf::TcpSocket>> waiting_socks;
-static std::queue<std::unique_ptr<sf::TcpSocket>> waiting_clocks;
-static std::mutex cs_gba;
-static std::mutex cs_gba_clk;
-static u8 num_connected;
-
 namespace
 {
-Common::Flag server_running;
+std::thread s_connection_thread;
+std::queue<std::unique_ptr<sf::TcpSocket>> s_waiting_socks;
+std::queue<std::unique_ptr<sf::TcpSocket>> s_waiting_clocks;
+std::mutex s_cs_gba;
+std::mutex s_cs_gba_clk;
+u8 s_num_connected;
+Common::Flag s_server_running;
 }
 
 enum EJoybusCmds
@@ -45,7 +44,7 @@ const u64 BYTES_PER_SECOND = BITS_PER_SECOND / 8;
 
 u8 GetNumConnected()
 {
-  int num_ports_connected = num_connected;
+  int num_ports_connected = s_num_connected;
   if (num_ports_connected == 0)
     num_ports_connected = 1;
 
@@ -88,7 +87,7 @@ int GetTransferTime(u8 cmd)
 
 static void GBAConnectionWaiter()
 {
-  server_running.Set();
+  s_server_running.Set();
 
   Common::SetCurrentThreadName("GBA Connection Waiter");
 
@@ -107,19 +106,19 @@ static void GBAConnectionWaiter()
   clock_server.setBlocking(false);
 
   auto new_client = std::make_unique<sf::TcpSocket>();
-  while (server_running.IsSet())
+  while (s_server_running.IsSet())
   {
     if (server.accept(*new_client) == sf::Socket::Done)
     {
-      std::lock_guard<std::mutex> lk(cs_gba);
+      std::lock_guard<std::mutex> lk(s_cs_gba);
-      waiting_socks.push(std::move(new_client));
+      s_waiting_socks.push(std::move(new_client));
 
       new_client = std::make_unique<sf::TcpSocket>();
     }
     if (clock_server.accept(*new_client) == sf::Socket::Done)
     {
-      std::lock_guard<std::mutex> lk(cs_gba_clk);
+      std::lock_guard<std::mutex> lk(s_cs_gba_clk);
-      waiting_clocks.push(std::move(new_client));
+      s_waiting_clocks.push(std::move(new_client));
 
       new_client = std::make_unique<sf::TcpSocket>();
     }
@@ -130,21 +129,21 @@ static void GBAConnectionWaiter()
 
 void GBAConnectionWaiter_Shutdown()
 {
-  server_running.Clear();
+  s_server_running.Clear();
-  if (connectionThread.joinable())
+  if (s_connection_thread.joinable())
-    connectionThread.join();
+    s_connection_thread.join();
 }
 
 static bool GetAvailableSock(std::unique_ptr<sf::TcpSocket>& sock_to_fill)
 {
   bool sock_filled = false;
 
-  std::lock_guard<std::mutex> lk(cs_gba);
+  std::lock_guard<std::mutex> lk(s_cs_gba);
 
-  if (!waiting_socks.empty())
+  if (!s_waiting_socks.empty())
   {
-    sock_to_fill = std::move(waiting_socks.front());
+    sock_to_fill = std::move(s_waiting_socks.front());
-    waiting_socks.pop();
+    s_waiting_socks.pop();
     sock_filled = true;
   }
 
@@ -155,24 +154,24 @@ static bool GetNextClock(std::unique_ptr<sf::TcpSocket>& sock_to_fill)
 {
   bool sock_filled = false;
 
-  std::lock_guard<std::mutex> lk(cs_gba_clk);
+  std::lock_guard<std::mutex> lk(s_cs_gba_clk);
 
-  if (!waiting_clocks.empty())
+  if (!s_waiting_clocks.empty())
   {
-    sock_to_fill = std::move(waiting_clocks.front());
+    sock_to_fill = std::move(s_waiting_clocks.front());
-    waiting_clocks.pop();
+    s_waiting_clocks.pop();
     sock_filled = true;
   }
 
   return sock_filled;
 }
 
-GBASockServer::GBASockServer(int _iDeviceNumber) : device_number{_iDeviceNumber}
+GBASockServer::GBASockServer(int device_number) : m_device_number{device_number}
 {
-  if (!connectionThread.joinable())
+  if (!s_connection_thread.joinable())
-    connectionThread = std::thread(GBAConnectionWaiter);
+    s_connection_thread = std::thread(GBAConnectionWaiter);
 
-  num_connected = 0;
+  s_num_connected = 0;
 }
 
 GBASockServer::~GBASockServer()
@@ -182,108 +181,110 @@ GBASockServer::~GBASockServer()
 
 void GBASockServer::Disconnect()
 {
-  if (client)
+  if (m_client)
   {
-    num_connected--;
+    s_num_connected--;
-    client->disconnect();
+    m_client->disconnect();
-    client = nullptr;
+    m_client = nullptr;
   }
-  if (clock_sync)
+  if (m_clock_sync)
   {
-    clock_sync->disconnect();
+    m_clock_sync->disconnect();
-    clock_sync = nullptr;
+    m_clock_sync = nullptr;
   }
-  last_time_slice = 0;
+  m_last_time_slice = 0;
-  booted = false;
+  m_booted = false;
 }
 
 void GBASockServer::ClockSync()
 {
-  if (!clock_sync)
+  if (!m_clock_sync)
-    if (!GetNextClock(clock_sync))
+    if (!GetNextClock(m_clock_sync))
       return;
 
   u32 time_slice = 0;
 
-  if (last_time_slice == 0)
+  if (m_last_time_slice == 0)
   {
-    num_connected++;
+    s_num_connected++;
-    last_time_slice = CoreTiming::GetTicks();
+    m_last_time_slice = CoreTiming::GetTicks();
     time_slice = (u32)(SystemTimers::GetTicksPerSecond() / 60);
   }
   else
   {
-    time_slice = (u32)(CoreTiming::GetTicks() - last_time_slice);
+    time_slice = (u32)(CoreTiming::GetTicks() - m_last_time_slice);
   }
 
   time_slice = (u32)((u64)time_slice * 16777216 / SystemTimers::GetTicksPerSecond());
-  last_time_slice = CoreTiming::GetTicks();
+  m_last_time_slice = CoreTiming::GetTicks();
   char bytes[4] = {0, 0, 0, 0};
   bytes[0] = (time_slice >> 24) & 0xff;
   bytes[1] = (time_slice >> 16) & 0xff;
   bytes[2] = (time_slice >> 8) & 0xff;
   bytes[3] = time_slice & 0xff;
 
-  sf::Socket::Status status = clock_sync->send(bytes, 4);
+  sf::Socket::Status status = m_clock_sync->send(bytes, 4);
   if (status == sf::Socket::Disconnected)
   {
-    clock_sync->disconnect();
+    m_clock_sync->disconnect();
-    clock_sync = nullptr;
+    m_clock_sync = nullptr;
   }
 }
 
 void GBASockServer::Send(const u8* si_buffer)
 {
-  if (!client)
+  if (!m_client)
-    if (!GetAvailableSock(client))
+    if (!GetAvailableSock(m_client))
       return;
 
-  for (size_t i = 0; i < send_data.size(); i++)
+  for (size_t i = 0; i < m_send_data.size(); i++)
-    send_data[i] = si_buffer[i ^ 3];
+    m_send_data[i] = si_buffer[i ^ 3];
 
-  cmd = (u8)send_data[0];
+  m_cmd = (u8)m_send_data[0];
 
 #ifdef _DEBUG
-  NOTICE_LOG(SERIALINTERFACE, "%01d cmd %02x [> %02x%02x%02x%02x]", device_number, (u8)send_data[0],
+  NOTICE_LOG(SERIALINTERFACE, "%01d cmd %02x [> %02x%02x%02x%02x]", m_device_number,
-             (u8)send_data[1], (u8)send_data[2], (u8)send_data[3], (u8)send_data[4]);
+             (u8)m_send_data[0], (u8)m_send_data[1], (u8)m_send_data[2], (u8)m_send_data[3],
+             (u8)m_send_data[4]);
 #endif
 
-  client->setBlocking(false);
+  m_client->setBlocking(false);
   sf::Socket::Status status;
-  if (cmd == CMD_WRITE)
+  if (m_cmd == CMD_WRITE)
-    status = client->send(send_data.data(), send_data.size());
+    status = m_client->send(m_send_data.data(), m_send_data.size());
   else
-    status = client->send(send_data.data(), 1);
+    status = m_client->send(m_send_data.data(), 1);
 
-  if (cmd != CMD_STATUS)
+  if (m_cmd != CMD_STATUS)
-    booted = true;
+    m_booted = true;
 
   if (status == sf::Socket::Disconnected)
     Disconnect();
 
-  time_cmd_sent = CoreTiming::GetTicks();
+  m_time_cmd_sent = CoreTiming::GetTicks();
 }
 
 int GBASockServer::Receive(u8* si_buffer)
 {
-  if (!client)
+  if (!m_client)
-    if (!GetAvailableSock(client))
+    if (!GetAvailableSock(m_client))
       return 5;
 
   size_t num_received = 0;
-  u64 transferTime = GetTransferTime((u8)send_data[0]);
+  u64 transfer_time = GetTransferTime((u8)m_send_data[0]);
-  bool block = (CoreTiming::GetTicks() - time_cmd_sent) > transferTime;
+  bool block = (CoreTiming::GetTicks() - m_time_cmd_sent) > transfer_time;
-  if (cmd == CMD_STATUS && !booted)
+  if (m_cmd == CMD_STATUS && !m_booted)
     block = false;
 
   if (block)
   {
-    sf::SocketSelector Selector;
+    sf::SocketSelector selector;
-    Selector.add(*client);
+    selector.add(*m_client);
-    Selector.wait(sf::milliseconds(1000));
+    selector.wait(sf::milliseconds(1000));
   }
 
-  sf::Socket::Status recv_stat = client->receive(recv_data.data(), recv_data.size(), num_received);
+  sf::Socket::Status recv_stat =
+      m_client->receive(m_recv_data.data(), m_recv_data.size(), num_received);
   if (recv_stat == sf::Socket::Disconnected)
   {
     Disconnect();
@@ -293,35 +294,35 @@ int GBASockServer::Receive(u8* si_buffer)
   if (recv_stat == sf::Socket::NotReady)
     num_received = 0;
 
-  if (num_received > recv_data.size())
+  if (num_received > m_recv_data.size())
-    num_received = recv_data.size();
+    num_received = m_recv_data.size();
 
   if (num_received > 0)
   {
 #ifdef _DEBUG
-    if ((u8)send_data[0] == 0x00 || (u8)send_data[0] == 0xff)
+    if ((u8)m_send_data[0] == 0x00 || (u8)m_send_data[0] == 0xff)
     {
       WARN_LOG(SERIALINTERFACE, "%01d                              [< %02x%02x%02x%02x%02x] (%lu)",
-               device_number, (u8)recv_data[0], (u8)recv_data[1], (u8)recv_data[2],
+               m_device_number, (u8)m_recv_data[0], (u8)m_recv_data[1], (u8)m_recv_data[2],
-               (u8)recv_data[3], (u8)recv_data[4], num_received);
+               (u8)m_recv_data[3], (u8)m_recv_data[4], num_received);
     }
     else
     {
       ERROR_LOG(SERIALINTERFACE, "%01d                              [< %02x%02x%02x%02x%02x] (%lu)",
-                device_number, (u8)recv_data[0], (u8)recv_data[1], (u8)recv_data[2],
+                m_device_number, (u8)m_recv_data[0], (u8)m_recv_data[1], (u8)m_recv_data[2],
-                (u8)recv_data[3], (u8)recv_data[4], num_received);
+                (u8)m_recv_data[3], (u8)m_recv_data[4], num_received);
     }
 #endif
 
-    for (size_t i = 0; i < recv_data.size(); i++)
+    for (size_t i = 0; i < m_recv_data.size(); i++)
-      si_buffer[i ^ 3] = recv_data[i];
+      si_buffer[i ^ 3] = m_recv_data[i];
   }
 
   return (int)num_received;
 }
 
-CSIDevice_GBA::CSIDevice_GBA(SIDevices _device, int _iDeviceNumber)
+CSIDevice_GBA::CSIDevice_GBA(SIDevices device, int device_number)
-    : ISIDevice(_device, _iDeviceNumber), GBASockServer(_iDeviceNumber)
+    : ISIDevice(device, device_number), GBASockServer(device_number)
 {
 }
 
@@ -330,40 +331,40 @@ CSIDevice_GBA::~CSIDevice_GBA()
   GBASockServer::Disconnect();
 }
 
-int CSIDevice_GBA::RunBuffer(u8* _pBuffer, int _iLength)
+int CSIDevice_GBA::RunBuffer(u8* buffer, int length)
 {
-  if (!waiting_for_response)
+  if (!m_waiting_for_response)
   {
-    for (size_t i = 0; i < send_data.size(); i++)
+    for (size_t i = 0; i < m_send_data.size(); i++)
-      send_data[i] = _pBuffer[i ^ 3];
+      m_send_data[i] = buffer[i ^ 3];
 
-    num_data_received = 0;
+    m_num_data_received = 0;
     ClockSync();
-    Send(_pBuffer);
+    Send(buffer);
-    timestamp_sent = CoreTiming::GetTicks();
+    m_timestamp_sent = CoreTiming::GetTicks();
-    waiting_for_response = true;
+    m_waiting_for_response = true;
   }
 
-  if (waiting_for_response && num_data_received == 0)
+  if (m_waiting_for_response && m_num_data_received == 0)
   {
-    num_data_received = Receive(_pBuffer);
+    m_num_data_received = Receive(buffer);
   }
 
-  if ((GetTransferTime(send_data[0])) > (int)(CoreTiming::GetTicks() - timestamp_sent))
+  if ((GetTransferTime(m_send_data[0])) > (int)(CoreTiming::GetTicks() - m_timestamp_sent))
   {
     return 0;
   }
   else
   {
-    if (num_data_received != 0)
+    if (m_num_data_received != 0)
-      waiting_for_response = false;
+      m_waiting_for_response = false;
-    return num_data_received;
+    return m_num_data_received;
   }
 }
 
 int CSIDevice_GBA::TransferInterval()
 {
-  return GetTransferTime(send_data[0]);
+  return GetTransferTime(m_send_data[0]);
 }
 
 bool CSIDevice_GBA::GetData(u32& hi, u32& low)

Source/Core/Core/HW/SI/SI_DeviceGBA.h

@@ -21,7 +21,7 @@ void GBAConnectionWaiter_Shutdown();
 class GBASockServer
 {
 public:
-  explicit GBASockServer(int _iDeviceNumber);
+  explicit GBASockServer(int device_number);
   ~GBASockServer();
 
   void Disconnect();
@@ -32,32 +32,32 @@ public:
   int Receive(u8* si_buffer);
 
 private:
-  std::unique_ptr<sf::TcpSocket> client;
+  std::unique_ptr<sf::TcpSocket> m_client;
-  std::unique_ptr<sf::TcpSocket> clock_sync;
+  std::unique_ptr<sf::TcpSocket> m_clock_sync;
-  std::array<char, 5> send_data{};
+  std::array<char, 5> m_send_data{};
-  std::array<char, 5> recv_data{};
+  std::array<char, 5> m_recv_data{};
 
-  u64 time_cmd_sent = 0;
+  u64 m_time_cmd_sent = 0;
-  u64 last_time_slice = 0;
+  u64 m_last_time_slice = 0;
-  int device_number;
+  int m_device_number;
-  u8 cmd = 0;
+  u8 m_cmd = 0;
-  bool booted = false;
+  bool m_booted = false;
 };
 
 class CSIDevice_GBA : public ISIDevice, private GBASockServer
 {
 public:
-  CSIDevice_GBA(SIDevices device, int _iDeviceNumber);
+  CSIDevice_GBA(SIDevices device, int device_number);
   ~CSIDevice_GBA();
 
-  int RunBuffer(u8* _pBuffer, int _iLength) override;
+  int RunBuffer(u8* buffer, int length) override;
   int TransferInterval() override;
-  bool GetData(u32& _Hi, u32& _Low) override;
+  bool GetData(u32& hi, u32& low) override;
-  void SendCommand(u32 _Cmd, u8 _Poll) override;
+  void SendCommand(u32 command, u8 poll) override;
 
 private:
-  std::array<u8, 5> send_data{};
+  std::array<u8, 5> m_send_data{};
-  int num_data_received = 0;
+  int m_num_data_received = 0;
-  u64 timestamp_sent = 0;
+  u64 m_timestamp_sent = 0;
-  bool waiting_for_response = false;
+  bool m_waiting_for_response = false;
 };