SI_DeviceKeyboard: Amend variable naming

2 files changed, 136 insertions, 136 deletions

diff --git a/Source/Core/Core/HW/SI/SI_DeviceKeyboard.cpp b/Source/Core/Core/HW/SI/SI_DeviceKeyboard.cpp
index 0d76a9178a..09fae7364c 100644
--- a/Source/Core/Core/HW/SI/SI_DeviceKeyboard.cpp
+++ b/Source/Core/Core/HW/SI/SI_DeviceKeyboard.cpp
@@ -11,36 +11,36 @@
 #include "InputCommon/KeyboardStatus.h"
 
 // --- GameCube keyboard ---
-CSIDevice_Keyboard::CSIDevice_Keyboard(SIDevices device, int _iDeviceNumber)
-    : ISIDevice(device, _iDeviceNumber)
+CSIDevice_Keyboard::CSIDevice_Keyboard(SIDevices device, int device_number)
+    : ISIDevice(device, device_number)
 {
 }
 
-int CSIDevice_Keyboard::RunBuffer(u8* _pBuffer, int _iLength)
+int CSIDevice_Keyboard::RunBuffer(u8* buffer, int length)
 {
   // For debug logging only
-  ISIDevice::RunBuffer(_pBuffer, _iLength);
+  ISIDevice::RunBuffer(buffer, length);
 
   // Read the command
-  EBufferCommands command = static_cast<EBufferCommands>(_pBuffer[3]);
+  EBufferCommands command = static_cast<EBufferCommands>(buffer[3]);
 
   // Handle it
   switch (command)
   {
   case CMD_RESET:
   case CMD_ID:
-    *(u32*)&_pBuffer[0] = SI_GC_KEYBOARD;
+    *(u32*)&buffer[0] = SI_GC_KEYBOARD;
     break;
 
   case CMD_DIRECT:
   {
-    INFO_LOG(SERIALINTERFACE, "Keyboard - Direct (Length: %d)", _iLength);
+    INFO_LOG(SERIALINTERFACE, "Keyboard - Direct (Length: %d)", length);
     u32 high, low;
     GetData(high, low);
-    for (int i = 0; i < (_iLength - 1) / 2; i++)
+    for (int i = 0; i < (length - 1) / 2; i++)
     {
-      _pBuffer[i + 0] = (high >> (i * 8)) & 0xff;
-      _pBuffer[i + 4] = (low >> (i * 8)) & 0xff;
+      buffer[i + 0] = (high >> (i * 8)) & 0xff;
+      buffer[i + 4] = (low >> (i * 8)) & 0xff;
     }
   }
   break;
@@ -52,7 +52,7 @@ int CSIDevice_Keyboard::RunBuffer(u8* _pBuffer, int _iLength)
   break;
   }
 
-  return _iLength;
+  return length;
 }
 
 KeyboardStatus CSIDevice_Keyboard::GetKeyboardStatus() const
@@ -60,37 +60,37 @@ KeyboardStatus CSIDevice_Keyboard::GetKeyboardStatus() const
   return Keyboard::GetStatus(m_device_number);
 }
 
-bool CSIDevice_Keyboard::GetData(u32& _Hi, u32& _Low)
+bool CSIDevice_Keyboard::GetData(u32& hi, u32& low)
 {
-  KeyboardStatus KeyStatus = GetKeyboardStatus();
+  KeyboardStatus key_status = GetKeyboardStatus();
   u8 key[3] = {0x00, 0x00, 0x00};
-  MapKeys(KeyStatus, key);
-  u8 checksum = key[0] ^ key[1] ^ key[2] ^ m_Counter;
+  MapKeys(key_status, key);
+  u8 checksum = key[0] ^ key[1] ^ key[2] ^ m_counter;
 
-  _Hi = m_Counter << 24;
-  _Low = key[0] << 24 | key[1] << 16 | key[2] << 8 | checksum;
+  hi = m_counter << 24;
+  low = key[0] << 24 | key[1] << 16 | key[2] << 8 | checksum;
 
   return true;
 }
 
-void CSIDevice_Keyboard::SendCommand(u32 _Cmd, u8 _Poll)
+void CSIDevice_Keyboard::SendCommand(u32 command, u8 poll)
 {
-  UCommand command(_Cmd);
+  UCommand keyboard_command(command);
 
-  switch (command.Command)
+  switch (keyboard_command.command)
   {
   case 0x00:
     break;
 
   case CMD_POLL:
   {
-    m_Counter++;
-    m_Counter &= 15;
+    m_counter++;
+    m_counter &= 15;
   }
   break;
   default:
   {
-    ERROR_LOG(SERIALINTERFACE, "Unknown direct command     (0x%x)", _Cmd);
+    ERROR_LOG(SERIALINTERFACE, "Unknown direct command     (0x%x)", command);
   }
   break;
   }
@@ -98,519 +98,519 @@ void CSIDevice_Keyboard::SendCommand(u32 _Cmd, u8 _Poll)
 
 void CSIDevice_Keyboard::DoState(PointerWrap& p)
 {
-  p.Do(m_Counter);
+  p.Do(m_counter);
 }
 
-void CSIDevice_Keyboard::MapKeys(const KeyboardStatus& KeyStatus, u8* key)
+void CSIDevice_Keyboard::MapKeys(const KeyboardStatus& key_status, u8* key)
 {
   u8 keys_held = 0;
   const u8 MAX_KEYS_HELD = 3;
 
-  if (KeyStatus.key0x & KEYMASK_HOME)
+  if (key_status.key0x & KEYMASK_HOME)
   {
     key[keys_held++] = KEY_HOME;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key0x & KEYMASK_END)
+  if (key_status.key0x & KEYMASK_END)
   {
     key[keys_held++] = KEY_END;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key0x & KEYMASK_PGUP)
+  if (key_status.key0x & KEYMASK_PGUP)
   {
     key[keys_held++] = KEY_PGUP;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key0x & KEYMASK_PGDN)
+  if (key_status.key0x & KEYMASK_PGDN)
   {
     key[keys_held++] = KEY_PGDN;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key0x & KEYMASK_SCROLLLOCK)
+  if (key_status.key0x & KEYMASK_SCROLLLOCK)
   {
     key[keys_held++] = KEY_SCROLLLOCK;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key0x & KEYMASK_A)
+  if (key_status.key0x & KEYMASK_A)
   {
     key[keys_held++] = KEY_A;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key0x & KEYMASK_B)
+  if (key_status.key0x & KEYMASK_B)
   {
     key[keys_held++] = KEY_B;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key0x & KEYMASK_C)
+  if (key_status.key0x & KEYMASK_C)
   {
     key[keys_held++] = KEY_C;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key0x & KEYMASK_D)
+  if (key_status.key0x & KEYMASK_D)
   {
     key[keys_held++] = KEY_D;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key0x & KEYMASK_E)
+  if (key_status.key0x & KEYMASK_E)
   {
     key[keys_held++] = KEY_E;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key0x & KEYMASK_F)
+  if (key_status.key0x & KEYMASK_F)
   {
     key[keys_held++] = KEY_F;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key0x & KEYMASK_G)
+  if (key_status.key0x & KEYMASK_G)
   {
     key[keys_held++] = KEY_G;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key0x & KEYMASK_H)
+  if (key_status.key0x & KEYMASK_H)
   {
     key[keys_held++] = KEY_H;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key0x & KEYMASK_I)
+  if (key_status.key0x & KEYMASK_I)
   {
     key[keys_held++] = KEY_I;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key0x & KEYMASK_J)
+  if (key_status.key0x & KEYMASK_J)
   {
     key[keys_held++] = KEY_J;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key0x & KEYMASK_K)
+  if (key_status.key0x & KEYMASK_K)
   {
     key[keys_held++] = KEY_K;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key1x & KEYMASK_L)
+  if (key_status.key1x & KEYMASK_L)
   {
     key[keys_held++] = KEY_L;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key1x & KEYMASK_M)
+  if (key_status.key1x & KEYMASK_M)
   {
     key[keys_held++] = KEY_M;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key1x & KEYMASK_N)
+  if (key_status.key1x & KEYMASK_N)
   {
     key[keys_held++] = KEY_N;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key1x & KEYMASK_O)
+  if (key_status.key1x & KEYMASK_O)
   {
     key[keys_held++] = KEY_O;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key1x & KEYMASK_P)
+  if (key_status.key1x & KEYMASK_P)
   {
     key[keys_held++] = KEY_P;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key1x & KEYMASK_Q)
+  if (key_status.key1x & KEYMASK_Q)
   {
     key[keys_held++] = KEY_Q;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key1x & KEYMASK_R)
+  if (key_status.key1x & KEYMASK_R)
   {
     key[keys_held++] = KEY_R;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key1x & KEYMASK_S)
+  if (key_status.key1x & KEYMASK_S)
   {
     key[keys_held++] = KEY_S;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key1x & KEYMASK_T)
+  if (key_status.key1x & KEYMASK_T)
   {
     key[keys_held++] = KEY_T;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key1x & KEYMASK_U)
+  if (key_status.key1x & KEYMASK_U)
   {
     key[keys_held++] = KEY_U;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key1x & KEYMASK_V)
+  if (key_status.key1x & KEYMASK_V)
   {
     key[keys_held++] = KEY_V;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key1x & KEYMASK_W)
+  if (key_status.key1x & KEYMASK_W)
   {
     key[keys_held++] = KEY_W;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key1x & KEYMASK_X)
+  if (key_status.key1x & KEYMASK_X)
   {
     key[keys_held++] = KEY_X;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key1x & KEYMASK_Y)
+  if (key_status.key1x & KEYMASK_Y)
   {
     key[keys_held++] = KEY_Y;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key1x & KEYMASK_Z)
+  if (key_status.key1x & KEYMASK_Z)
   {
     key[keys_held++] = KEY_Z;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key1x & KEYMASK_1)
+  if (key_status.key1x & KEYMASK_1)
   {
     key[keys_held++] = KEY_1;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key2x & KEYMASK_2)
+  if (key_status.key2x & KEYMASK_2)
   {
     key[keys_held++] = KEY_2;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key2x & KEYMASK_3)
+  if (key_status.key2x & KEYMASK_3)
   {
     key[keys_held++] = KEY_3;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key2x & KEYMASK_4)
+  if (key_status.key2x & KEYMASK_4)
   {
     key[keys_held++] = KEY_4;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key2x & KEYMASK_5)
+  if (key_status.key2x & KEYMASK_5)
   {
     key[keys_held++] = KEY_5;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key2x & KEYMASK_6)
+  if (key_status.key2x & KEYMASK_6)
   {
     key[keys_held++] = KEY_6;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key2x & KEYMASK_7)
+  if (key_status.key2x & KEYMASK_7)
   {
     key[keys_held++] = KEY_7;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key2x & KEYMASK_8)
+  if (key_status.key2x & KEYMASK_8)
   {
     key[keys_held++] = KEY_8;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key2x & KEYMASK_9)
+  if (key_status.key2x & KEYMASK_9)
   {
     key[keys_held++] = KEY_9;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key2x & KEYMASK_0)
+  if (key_status.key2x & KEYMASK_0)
   {
     key[keys_held++] = KEY_0;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key2x & KEYMASK_MINUS)
+  if (key_status.key2x & KEYMASK_MINUS)
   {
     key[keys_held++] = KEY_MINUS;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key2x & KEYMASK_PLUS)
+  if (key_status.key2x & KEYMASK_PLUS)
   {
     key[keys_held++] = KEY_PLUS;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key2x & KEYMASK_PRINTSCR)
+  if (key_status.key2x & KEYMASK_PRINTSCR)
   {
     key[keys_held++] = KEY_PRINTSCR;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key2x & KEYMASK_BRACE_OPEN)
+  if (key_status.key2x & KEYMASK_BRACE_OPEN)
   {
     key[keys_held++] = KEY_BRACE_OPEN;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key2x & KEYMASK_BRACE_CLOSE)
+  if (key_status.key2x & KEYMASK_BRACE_CLOSE)
   {
     key[keys_held++] = KEY_BRACE_CLOSE;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key2x & KEYMASK_COLON)
+  if (key_status.key2x & KEYMASK_COLON)
   {
     key[keys_held++] = KEY_COLON;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key2x & KEYMASK_QUOTE)
+  if (key_status.key2x & KEYMASK_QUOTE)
   {
     key[keys_held++] = KEY_QUOTE;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key3x & KEYMASK_HASH)
+  if (key_status.key3x & KEYMASK_HASH)
   {
     key[keys_held++] = KEY_HASH;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key3x & KEYMASK_COMMA)
+  if (key_status.key3x & KEYMASK_COMMA)
   {
     key[keys_held++] = KEY_COMMA;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key3x & KEYMASK_PERIOD)
+  if (key_status.key3x & KEYMASK_PERIOD)
   {
     key[keys_held++] = KEY_PERIOD;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key3x & KEYMASK_QUESTIONMARK)
+  if (key_status.key3x & KEYMASK_QUESTIONMARK)
   {
     key[keys_held++] = KEY_QUESTIONMARK;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key3x & KEYMASK_INTERNATIONAL1)
+  if (key_status.key3x & KEYMASK_INTERNATIONAL1)
   {
     key[keys_held++] = KEY_INTERNATIONAL1;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key3x & KEYMASK_F1)
+  if (key_status.key3x & KEYMASK_F1)
   {
     key[keys_held++] = KEY_F1;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key3x & KEYMASK_F2)
+  if (key_status.key3x & KEYMASK_F2)
   {
     key[keys_held++] = KEY_F2;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key3x & KEYMASK_F3)
+  if (key_status.key3x & KEYMASK_F3)
   {
     key[keys_held++] = KEY_F3;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key3x & KEYMASK_F4)
+  if (key_status.key3x & KEYMASK_F4)
   {
     key[keys_held++] = KEY_F4;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key3x & KEYMASK_F5)
+  if (key_status.key3x & KEYMASK_F5)
   {
     key[keys_held++] = KEY_F5;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key3x & KEYMASK_F6)
+  if (key_status.key3x & KEYMASK_F6)
   {
     key[keys_held++] = KEY_F6;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key3x & KEYMASK_F7)
+  if (key_status.key3x & KEYMASK_F7)
   {
     key[keys_held++] = KEY_F7;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key3x & KEYMASK_F8)
+  if (key_status.key3x & KEYMASK_F8)
   {
     key[keys_held++] = KEY_F8;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key3x & KEYMASK_F9)
+  if (key_status.key3x & KEYMASK_F9)
   {
     key[keys_held++] = KEY_F9;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key3x & KEYMASK_F10)
+  if (key_status.key3x & KEYMASK_F10)
   {
     key[keys_held++] = KEY_F10;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key3x & KEYMASK_F11)
+  if (key_status.key3x & KEYMASK_F11)
   {
     key[keys_held++] = KEY_F11;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key4x & KEYMASK_F12)
+  if (key_status.key4x & KEYMASK_F12)
   {
     key[keys_held++] = KEY_F12;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key4x & KEYMASK_ESC)
+  if (key_status.key4x & KEYMASK_ESC)
   {
     key[keys_held++] = KEY_ESC;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key4x & KEYMASK_INSERT)
+  if (key_status.key4x & KEYMASK_INSERT)
   {
     key[keys_held++] = KEY_INSERT;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key4x & KEYMASK_DELETE)
+  if (key_status.key4x & KEYMASK_DELETE)
   {
     key[keys_held++] = KEY_DELETE;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key4x & KEYMASK_TILDE)
+  if (key_status.key4x & KEYMASK_TILDE)
   {
     key[keys_held++] = KEY_TILDE;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key4x & KEYMASK_BACKSPACE)
+  if (key_status.key4x & KEYMASK_BACKSPACE)
   {
     key[keys_held++] = KEY_BACKSPACE;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key4x & KEYMASK_TAB)
+  if (key_status.key4x & KEYMASK_TAB)
   {
     key[keys_held++] = KEY_TAB;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key4x & KEYMASK_CAPSLOCK)
+  if (key_status.key4x & KEYMASK_CAPSLOCK)
   {
     key[keys_held++] = KEY_CAPSLOCK;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key4x & KEYMASK_LEFTSHIFT)
+  if (key_status.key4x & KEYMASK_LEFTSHIFT)
   {
     key[keys_held++] = KEY_LEFTSHIFT;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key4x & KEYMASK_RIGHTSHIFT)
+  if (key_status.key4x & KEYMASK_RIGHTSHIFT)
   {
     key[keys_held++] = KEY_RIGHTSHIFT;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key4x & KEYMASK_LEFTCONTROL)
+  if (key_status.key4x & KEYMASK_LEFTCONTROL)
   {
     key[keys_held++] = KEY_LEFTCONTROL;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key4x & KEYMASK_RIGHTALT)
+  if (key_status.key4x & KEYMASK_RIGHTALT)
   {
     key[keys_held++] = KEY_RIGHTALT;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key4x & KEYMASK_LEFTWINDOWS)
+  if (key_status.key4x & KEYMASK_LEFTWINDOWS)
   {
     key[keys_held++] = KEY_LEFTWINDOWS;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key4x & KEYMASK_SPACE)
+  if (key_status.key4x & KEYMASK_SPACE)
   {
     key[keys_held++] = KEY_SPACE;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key4x & KEYMASK_RIGHTWINDOWS)
+  if (key_status.key4x & KEYMASK_RIGHTWINDOWS)
   {
     key[keys_held++] = KEY_RIGHTWINDOWS;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key4x & KEYMASK_MENU)
+  if (key_status.key4x & KEYMASK_MENU)
   {
     key[keys_held++] = KEY_MENU;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key5x & KEYMASK_LEFTARROW)
+  if (key_status.key5x & KEYMASK_LEFTARROW)
   {
     key[keys_held++] = KEY_LEFTARROW;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key5x & KEYMASK_DOWNARROW)
+  if (key_status.key5x & KEYMASK_DOWNARROW)
   {
     key[keys_held++] = KEY_DOWNARROW;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key5x & KEYMASK_UPARROW)
+  if (key_status.key5x & KEYMASK_UPARROW)
   {
     key[keys_held++] = KEY_UPARROW;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key5x & KEYMASK_RIGHTARROW)
+  if (key_status.key5x & KEYMASK_RIGHTARROW)
   {
     key[keys_held++] = KEY_RIGHTARROW;
     if (keys_held >= MAX_KEYS_HELD)
       return;
   }
-  if (KeyStatus.key5x & KEYMASK_ENTER)
+  if (key_status.key5x & KEYMASK_ENTER)
   {
     key[keys_held++] = KEY_ENTER;
     if (keys_held >= MAX_KEYS_HELD)
diff --git a/Source/Core/Core/HW/SI/SI_DeviceKeyboard.h b/Source/Core/Core/HW/SI/SI_DeviceKeyboard.h
index 1eba042cdb..900997fc93 100644
--- a/Source/Core/Core/HW/SI/SI_DeviceKeyboard.h
+++ b/Source/Core/Core/HW/SI/SI_DeviceKeyboard.h
@@ -11,6 +11,25 @@ struct KeyboardStatus;
 
 class CSIDevice_Keyboard : public ISIDevice
 {
+public:
+  // Constructor
+  CSIDevice_Keyboard(SIDevices device, int device_number);
+
+  // Run the SI Buffer
+  int RunBuffer(u8* buffer, int length) override;
+
+  // Return true on new data
+  bool GetData(u32& hi, u32& low) override;
+
+  KeyboardStatus GetKeyboardStatus() const;
+  void MapKeys(const KeyboardStatus& key_status, u8* key);
+
+  // Send a command directly
+  void SendCommand(u32 command, u8 poll) override;
+
+  // Savestate support
+  void DoState(PointerWrap& p) override;
+
 protected:
   // Commands
   enum EBufferCommands
@@ -28,40 +47,21 @@ protected:
 
   union UCommand
   {
-    u32 Hex = 0;
+    u32 hex = 0;
     struct
     {
-      u32 Parameter1 : 8;
-      u32 Parameter2 : 8;
-      u32 Command : 8;
+      u32 parameter1 : 8;
+      u32 parameter2 : 8;
+      u32 command : 8;
       u32 : 8;
     };
     UCommand() = default;
-    UCommand(u32 value) : Hex{value} {}
+    UCommand(u32 value) : hex{value} {}
   };
 
   // PADAnalogMode
-  u8 m_Mode = 0;
+  u8 m_mode = 0;
 
   // Internal counter synchonizing GC and keyboard
-  u8 m_Counter = 0;
-
-public:
-  // Constructor
-  CSIDevice_Keyboard(SIDevices device, int _iDeviceNumber);
-
-  // Run the SI Buffer
-  int RunBuffer(u8* _pBuffer, int _iLength) override;
-
-  // Return true on new data
-  bool GetData(u32& _Hi, u32& _Low) override;
-
-  KeyboardStatus GetKeyboardStatus() const;
-  void MapKeys(const KeyboardStatus& KeyStatus, u8* key);
-
-  // Send a command directly
-  void SendCommand(u32 _Cmd, u8 _Poll) override;
-
-  // Savestate support
-  void DoState(PointerWrap& p) override;
+  u8 m_counter = 0;
 };