Got rid of all of jp's ////////////////////////////// lines (nearly 500 of them)!

Yes, I used a script :D

git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4169 8ced0084-cf51-0410-be5f-012b33b47a6e

Source/Core/Core/Src/Boot/Boot.cpp

@@ -137,7 +137,7 @@ bool CBoot::LoadMapFromFilename(const std::string &_rFilename, const char *_game
 }
 
 
-//////////////////////////////////////////////////////////////////////////////////////////
+
 // Load a GC or Wii BIOS file
 bool CBoot::Load_BIOS(const std::string& _rBiosFilename)
 {
@@ -150,7 +150,7 @@ bool CBoot::Load_BIOS(const std::string& _rBiosFilename)
     return true;
 }
 
-//////////////////////////////////////////////////////////////////////////////////////////
+
 // Third boot step after BootManager and Core. See Call schedule in BootManager.cpp
 bool CBoot::BootUp()
 {

Source/Core/Core/Src/Boot/ElfTypes.h

@@ -60,7 +60,7 @@ enum ElfMachine
 #define ELFDATA2MSB 2
 
 
-/////////////////////
+
 // Sections constants
 
 // Section indexes

Source/Core/Core/Src/CoreRerecording.cpp

@@ -20,7 +20,7 @@
 #ifdef RERECORDING
 
 
-//////////////////////////////////////////////////////////////////////////////////////////
+
 // Include
 // ¯¯¯¯¯¯¯¯¯¯¯¯¯¯
 #ifdef _WIN32
@@ -60,11 +60,11 @@
 #include "MemTools.h"
 #include "Host.h"
 #include "LogManager.h"
-////////////////////////////////////////
 
 
 
-///////////////////////////////////////////////////////////////////////////////////////////
+
+
 // File description: Rerecording Functions
 /* ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
 
@@ -83,16 +83,16 @@ namespace Core
 {
 
 
-///////////////////////////////////////////////////////////////////////////////////////////
+
 // Declarations and definitions
 // ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
 int g_FrameCounter = 0;
 bool g_FrameStep = false;
 Common::Timer ReRecTimer;
-////////////////////////////////////////
 
 
-///////////////////////////////////////////////////////////////////////////////////////////
+
+
 // Control Run, Pause, Stop and the Timer.
 // ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
 
@@ -160,10 +160,10 @@ void WindBack(int Counter)
 	// Logging
 	DEBUG_LOG(CONSOLE, "WindBack: %i %u\n", Counter, (u64)CurrentTimeSeconds);
 }
-////////////////////////////////////////
 
 
-///////////////////////////////////////////////////////////////////////////////////////////
+
+
 // Frame advance
 // ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
 void FrameAdvance()
@@ -202,10 +202,10 @@ void FrameStepOnOff()
 		Core::SetState(Core::CORE_RUN);
 	}
 }
-////////////////////////////////////////
 
 
-///////////////////////////////////////////////////////////////////////////////////////////
+
+
 // General functions
 // ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
 
@@ -240,7 +240,7 @@ void FrameUpdate()
 	// Count one frame
 	g_FrameCounter++;
 }
-////////////////////////////////////////
+
 
 
 } // Core

Source/Core/Core/Src/DolLoader.h

@@ -14,17 +14,17 @@
 
 // Official SVN repository and contact information can be found at
 // http://code.google.com/p/dolphin-emu/
-/////////////////////////////////////////////////////////////////////////////////////////////////////
-// M O D U L E  B E G I N ///////////////////////////////////////////////////////////////////////////
-/////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// M O D U L E  B E G I N 
+
 
 #pragma once
 
 #include "Common.h"
 
-/////////////////////////////////////////////////////////////////////////////////////////////////////
-// C L A S S/////////////////////////////////////////////////////////////////////////////////////////
-/////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// C L A S S
+
 
 class CDolLoader
 {

Source/Core/Core/Src/HW/EXI_Device.cpp

@@ -27,9 +27,9 @@
 #include "../Core.h"
 #include "../ConfigManager.h"
 
-//////////////////////////////////////////////////////////////////////////
+
 // --- interface IEXIDevice ---
-//////////////////////////////////////////////////////////////////////////
+
 void IEXIDevice::ImmWrite(u32 _uData,  u32 _uSize)
 {
 	while (_uSize--)
@@ -74,9 +74,9 @@ void IEXIDevice::DMARead(u32 _uAddr, u32 _uSize)
 	}
 };
 
-//////////////////////////////////////////////////////////////////////////
+
 // --- class CEXIDummy ---
-//////////////////////////////////////////////////////////////////////////
+
 // Just a dummy that logs reads and writes
 // to be used for EXI devices we haven't emulated
 class CEXIDummy : public IEXIDevice
@@ -99,9 +99,9 @@ public:
 	void DMARead (u32 addr, u32 size)	{INFO_LOG(EXPANSIONINTERFACE, "EXI DUMMY %s DMARead:  %08x bytes, from device to %08x", m_strName.c_str(), size, addr);}
 };
 
-//////////////////////////////////////////////////////////////////////////
-// F A C T O R Y /////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////
+
+// F A C T O R Y 
+
 
 IEXIDevice* EXIDevice_Create(TEXIDevices _EXIDevice)
 {

Source/Core/Core/Src/HW/EXI_DeviceMic.cpp

@@ -41,7 +41,7 @@ void CEXIMic::TransferByte(u8 &byte){}
 bool CEXIMic::IsInterruptSet(){return false;}
 
 #else
-//////////////////////////////////////////////////////////////////////////
+
 // We use PortAudio for cross-platform audio input.
 // It needs the headers and a lib file for the dll
 #include <portaudio.h>
@@ -95,9 +95,9 @@ int patestCallback( const void *inputBuffer, void *outputBuffer,
 	return paContinue;
 }
 
-//////////////////////////////////////////////////////////////////////////
+
 // EXI Mic Device
-//////////////////////////////////////////////////////////////////////////
+
 CEXIMic::CEXIMic(int _Index)
 {
 	Index = _Index;

Source/Core/Core/Src/HW/Memmap.cpp

@@ -47,10 +47,10 @@ may be redirected here (for example to Read_U32()).
 #include "WII_IPC.h"
 #include "../ConfigManager.h"
 #include "../Debugger/Debugger_SymbolMap.h"
-/////////////////////////////
 
 
-///////////////////////////////////////////////////////////////////////////////////
+
+
 // Declarations and definitions
 // ----------------
 namespace Memory
@@ -122,10 +122,10 @@ readFn32  hwReadWii32[NUMHWMEMFUN];
 readFn64  hwReadWii64[NUMHWMEMFUN];
 // ===============
 
-/////////////////////////////
 
 
-///////////////////////////////////////////////////////////////////////////////////
+
+
 // Default read and write functions
 // ----------------
 u32 CheckDTLB(u32 _Address, XCheckTLBFlag _Flag);
@@ -143,10 +143,10 @@ void HW_Default_Read(T _Data, const u32 _Address){	ERROR_LOG(MASTER_LOG, "Illega
 
 template <class T, u8* P> void HW_Read_Memory(T &_Data, const u32 _Address)	{	_Data = *(T*)&P[_Address & PAGE_MASK];	}
 template <class T, u8* P> void HW_Write_Memory(T _Data, const u32 _Address)	{	*(T*)&P[_Address & PAGE_MASK] = _Data;	}
-/////////////////////////////
 
 
-///////////////////////////////////////////////////////////////////////////////////
+
+
 /* Create shortcuts to the hardware devices' read and write functions. This can be seen
    as an alternative to a switch() or if() table. */
 // ----------------
@@ -327,11 +327,11 @@ writeFn32 GetHWWriteFun32(const u32 _Address)
 {
 	return hwWrite32[(_Address >> HWSHIFT) & (NUMHWMEMFUN-1)];
 }
-/////////////////////////////
 
 
 
-///////////////////////////////////////////////////////////////////////////////////
+
+
 // Init and Shutdown
 // ----------------
 bool IsInitialized()
@@ -537,7 +537,7 @@ u32 Read_Instruction(const u32 em_address)
 		return inst.hex;
 }
 
-//////////////////////////////////////////////////////////
+
 
 
 
@@ -677,7 +677,7 @@ void CheckForBadAddresses64(u32 Address, u64 Data, bool Read)
 
 
 
-///////////////////////////////////////////////////////////////////////////////////
+
 // Other functions
 // ----------------
 void WriteBigEData(const u8 *_pData, const u32 _Address, const u32 _iSize)
@@ -857,7 +857,7 @@ bool IsRAMAddress(const u32 addr, bool allow_locked_cache)
 		return false;
 	}
 }
-/////////////////////////////
+
 
 
 }  // namespace

Source/Core/Core/Src/HW/MemmapFunctions.cpp

@@ -84,7 +84,7 @@ inline u32 bswap(u32 val) {return Common::swap32(val);}
 inline u64 bswap(u64 val) {return Common::swap64(val);}
 // =================
 
-///////////////////////////////////////////////////////////////////////////////////
+
 // Read and write
 // ----------------
 // The read and write macros that direct us to the right functions
@@ -452,7 +452,7 @@ void WriteUnchecked_U32(const u32 _iValue, const u32 _Address)
 }
 // =====================
 
-//////////////////////////////////////////////////////////
+
 
 
 

Source/Core/Core/Src/HW/SI.cpp

@@ -275,9 +275,9 @@ void Read32(u32& _uReturnValue, const u32 _iAddress)
 	// registers
 	switch (_iAddress & 0x3FF)
 	{
-		//////////////////////////////////////////////////////////////////////////
+		
 		// Channel 0
-		//////////////////////////////////////////////////////////////////////////
+		
 	case SI_CHANNEL_0_OUT:		
 		_uReturnValue = g_Channel[0].m_Out.Hex;
 		return;
@@ -294,9 +294,9 @@ void Read32(u32& _uReturnValue, const u32 _iAddress)
 		_uReturnValue = g_Channel[0].m_InLo.Hex;
 		return;
 
-		//////////////////////////////////////////////////////////////////////////
+		
 		// Channel 1
-		//////////////////////////////////////////////////////////////////////////
+		
 	case SI_CHANNEL_1_OUT:		
 		_uReturnValue = g_Channel[1].m_Out.Hex;
 		return;
@@ -313,9 +313,9 @@ void Read32(u32& _uReturnValue, const u32 _iAddress)
 		_uReturnValue = g_Channel[1].m_InLo.Hex;
 		return;
 
-		//////////////////////////////////////////////////////////////////////////
+		
 		// Channel 2
-		//////////////////////////////////////////////////////////////////////////
+		
 	case SI_CHANNEL_2_OUT:		
 		_uReturnValue = g_Channel[2].m_Out.Hex;
 		return;
@@ -332,9 +332,9 @@ void Read32(u32& _uReturnValue, const u32 _iAddress)
 		_uReturnValue = g_Channel[2].m_InLo.Hex;
 		return;
 
-		//////////////////////////////////////////////////////////////////////////
+		
 		// Channel 3
-		//////////////////////////////////////////////////////////////////////////
+		
 	case SI_CHANNEL_3_OUT:		
 		_uReturnValue = g_Channel[3].m_Out.Hex;
 		return;

Source/Core/Core/Src/HW/SI_Device.cpp

@@ -19,9 +19,9 @@
 #include "SI_DeviceGCController.h"
 #include "SI_DeviceGBA.h"
 
-//////////////////////////////////////////////////////////////////////////
+
 // --- interface ISIDevice ---
-//////////////////////////////////////////////////////////////////////////
+
 int ISIDevice::RunBuffer(u8* _pBuffer, int _iLength)
 {
 #ifdef _DEBUG
@@ -47,9 +47,9 @@ int ISIDevice::RunBuffer(u8* _pBuffer, int _iLength)
 	return 0;
 };
 
-//////////////////////////////////////////////////////////////////////////
+
 // --- class CSIDummy ---
-//////////////////////////////////////////////////////////////////////////
+
 // Just a dummy that logs reads and writes
 // to be used for SI devices we haven't emulated
 // and hopefully as an "emtpy" device
@@ -75,9 +75,9 @@ public:
 	void SendCommand(u32 _Cmd, u8 _Poll){INFO_LOG(SERIALINTERFACE, "SI DUMMY %i SendCommand: %08x", this->m_iDeviceNumber, _Cmd);}
 };
 
-//////////////////////////////////////////////////////////////////////////
-// F A C T O R Y /////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////
+
+// F A C T O R Y 
+
 
 ISIDevice* SIDevice_Create(TSIDevices _SIDevice, int _iDeviceNumber)
 {

Source/Core/Core/Src/HW/SI_DeviceGBA.cpp

@@ -19,9 +19,9 @@
 #include "SI_DeviceGBA.h"
 #include "GBAPipe.h"
 
-//////////////////////////////////////////////////////////////////////////
+
 // --- GameBoy Advance ---
-//////////////////////////////////////////////////////////////////////////
+
 
 CSIDevice_GBA::CSIDevice_GBA(int _iDeviceNumber) :
 	ISIDevice(_iDeviceNumber)
@@ -130,9 +130,9 @@ int CSIDevice_GBA::RunBuffer(u8* _pBuffer, int _iLength)
 	return iPosition;
 }
 
-//////////////////////////////////////////////////////////////////////////
+
 // GetData
-//////////////////////////////////////////////////////////////////////////
+
 bool 
 CSIDevice_GBA::GetData(u32& _Hi, u32& _Low)
 {
@@ -141,9 +141,9 @@ CSIDevice_GBA::GetData(u32& _Hi, u32& _Low)
 	return true;
 }
 
-//////////////////////////////////////////////////////////////////////////
+
 // SendCommand
-//////////////////////////////////////////////////////////////////////////
+
 void
 CSIDevice_GBA::SendCommand(u32 _Cmd, u8 _Poll)
 {

Source/Core/Core/Src/HW/SI_DeviceGBA.h

@@ -18,9 +18,9 @@
 #ifndef _SI_DEVICEGBA_H
 #define _SI_DEVICEGBA_H
 
-//////////////////////////////////////////////////////////////////////////
+
 // GameBoy Advance
-//////////////////////////////////////////////////////////////////////////
+
 
 class CSIDevice_GBA : public ISIDevice
 {
@@ -51,9 +51,9 @@ private:
 		};
 	};
 	FAKE_JOYSTAT js;
-	//////////////////////////////////////////////////////////////////////////
+	
 	//0x4000158 - JOYSTAT - Receive Status Register (R/W) (ON THE GBA)
-	//////////////////////////////////////////////////////////////////////////
+	
 	// NOTE: there is a typo in GBATEK!
 	// in the JOY BUS command descriptions, SIOSTAT==JOYSTAT
 	//Bit   Expl.

Source/Core/Core/Src/HW/SI_DeviceGCController.cpp

@@ -27,9 +27,9 @@
 
 #include "../OnFrame.h"
 
-//////////////////////////////////////////////////////////////////////////
+
 // --- standard gamecube controller ---
-//////////////////////////////////////////////////////////////////////////
+
 
 CSIDevice_GCController::CSIDevice_GCController(int _iDeviceNumber) :
 	ISIDevice(_iDeviceNumber)
@@ -117,9 +117,9 @@ int CSIDevice_GCController::RunBuffer(u8* _pBuffer, int _iLength)
 	return iPosition;
 }
 
-//////////////////////////////////////////////////////////////////////////
+
 // GetData
-//////////////////////////////////////////////////////////////////////////
+
 // Return true on new data (max 7 Bytes and 6 bits ;)
 // [00?SYXBA] [1LRZUDRL] [x] [y] [cx] [cy] [l] [r]
 //  |\_ ERR_LATCH (error latched - check SISR)
@@ -219,9 +219,9 @@ CSIDevice_GCController::GetData(u32& _Hi, u32& _Low)
 	return true;
 }
 
-//////////////////////////////////////////////////////////////////////////
+
 // SendCommand
-//////////////////////////////////////////////////////////////////////////
+
 void
 CSIDevice_GCController::SendCommand(u32 _Cmd, u8 _Poll)
 {

Source/Core/Core/Src/HW/SI_DeviceGCController.h

@@ -21,9 +21,9 @@
 #include "../PluginManager.h"
 #include "SI_Device.h"
 
-//////////////////////////////////////////////////////////////////////////
+
 // standard gamecube controller
-//////////////////////////////////////////////////////////////////////////
+
 
 class CSIDevice_GCController : public ISIDevice
 {

Source/Core/Core/Src/HW/SystemTimers.cpp

@@ -16,7 +16,7 @@
 // http://code.google.com/p/dolphin-emu/
 
 
-/////////////////////////////////////////////////////////////////////////////
+
 // File description: This file controls all system timers
 /* -------------
    "Time" is measured in frames, not time: These update frequencies are determined by the passage
@@ -57,7 +57,7 @@
 //////////////////////////*/
 
 
-/////////////////////////////////////////////////////////////////////////////
+
 // Inlude
 // -------------
 #include "Common.h"
@@ -77,12 +77,12 @@
 #include "Thread.h"
 #include "Timer.h"
 
-/////////////////////////////
+
 
 namespace SystemTimers
 {
 
-/////////////////////////////////////////////////////////////////////////////
+
 // Declarations and definitions
 // -------------
 u32 CPU_CORE_CLOCK  = 486000000u;             // 486 mhz (its not 485, stop bugging me!)
@@ -131,7 +131,7 @@ int
 	// TODO: make it VI output frame rate compliant (30/60 and 25/50)
 	// Assuming game's frame-finish-watchdog wait more than 4 emulated frame-period before starting its mess.
 	FAKE_GP_WATCHDOG_PERIOD;
-///////////////////////////////////
+
 
 
 u32 GetTicksPerSecond()

Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_Device_usb.cpp

@@ -16,7 +16,7 @@
 // http://code.google.com/p/dolphin-emu/
 
 
-//////////////////////////////////////////////////////////////////////////
+
 // Include
 #include "../Core.h" // Local core functions
 #include "../Debugger/Debugger_SymbolMap.h"
@@ -30,7 +30,7 @@ int g_HCICount = 0;
 int g_GlobalHandle = 0;
 
 
-//////////////////////////////////////////////////////////////////////////
+
 // The device class
 CWII_IPC_HLE_Device_usb_oh1_57e_305::CWII_IPC_HLE_Device_usb_oh1_57e_305(u32 _DeviceID, const std::string& _rDeviceName)
 	: IWII_IPC_HLE_Device(_DeviceID, _rDeviceName)
@@ -436,13 +436,13 @@ u32 CWII_IPC_HLE_Device_usb_oh1_57e_305::Update()
 }
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////////
+
 // Events
 // -----------------
 // This is messages send from the Wiimote to the game, for example RequestConnection()
 // or ConnectionComplete().
 //
-////////////////////////////////////////////////////////////////////////////////////////////////////
+
 
 void CWII_IPC_HLE_Device_usb_oh1_57e_305::AddEventToQueue(const SQueuedEvent& _event)
 {
@@ -588,7 +588,7 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventRemoteNameReq(bdaddr_t _bd)
 }
 
 
-/////////////////////////////////////////////////////////////
+
 /* This is called from Update() after ScanEnable has been enabled. */
 // ØØØØØØØØØ
 bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventRequestConnection(CWII_IPC_HLE_WiiMote& _rWiiMote)
@@ -631,7 +631,7 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventRequestConnection(CWII_IPC_HL
 
 	return true;
 };
-//////////////////////////////
+
 
 
 bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventRequestLinkKey(bdaddr_t _bd)
@@ -991,13 +991,13 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventDisconnect(u16 _connectionHan
 }
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////////
+
 // Command dispacther
 // -----------------
 // This is called from the USB_IOCTL_HCI_COMMAND_MESSAGE Ioctlv
 //
 //
-////////////////////////////////////////////////////////////////////////////////////////////////////
+
 
 void CWII_IPC_HLE_Device_usb_oh1_57e_305::ExecuteHCICommandMessage(const SHCICommandMessage& _rHCICommandMessage)
 {
@@ -1182,13 +1182,13 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::ExecuteHCICommandMessage(const SHCICom
 	}
 }
 
-////////////////////////////////////////////////////////////////////////////////////////////////////
+
 //
 //
 // --- command helper
 //
 //
-////////////////////////////////////////////////////////////////////////////////////////////////////
+
 
 void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandReset(u8* _Input)
 {
@@ -1427,7 +1427,7 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWritePageTimeOut(u8* _Input)
 }
 
 
-/////////////////////////////////////////////////////////////
+
 /* This will enable ScanEnable so that Update() can start the Wiimote. */
 // ØØØØØØØØØ
 void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteScanEnable(u8* _Input)
@@ -1456,7 +1456,7 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteScanEnable(u8* _Input)
 
 	SendEventCommandComplete(HCI_CMD_WRITE_SCAN_ENABLE, &Reply, sizeof(hci_write_scan_enable_rp));
 }
-/////////////////////////////
+
 
 
 void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteInquiryMode(u8* _Input)
@@ -1907,13 +1907,13 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandLinkKeyRep(u8* _Input)
 
 
 
-////////////////////////////////////////////////////////////////////////////////////////////////////
+
 //
 //
 // --- helper
 //
 //
-////////////////////////////////////////////////////////////////////////////////////////////////////
+
 
 CWII_IPC_HLE_WiiMote* CWII_IPC_HLE_Device_usb_oh1_57e_305::AccessWiiMote(const bdaddr_t& _rAddr)
 {
@@ -1951,11 +1951,11 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::LOG_LinkKey(const u8* _pLinkKey)
 
 }
 
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
 //
 // CWII_IPC_HLE_Device_usb_oh0
 //
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
 
 
 CWII_IPC_HLE_Device_usb_oh0::CWII_IPC_HLE_Device_usb_oh0(u32 _DeviceID, const std::string& _rDeviceName)

Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_WiiMote.cpp

@@ -77,7 +77,7 @@ CWII_IPC_HLE_WiiMote::CWII_IPC_HLE_WiiMote(CWII_IPC_HLE_Device_usb_oh1_57e_305*
 	memset(m_LinkKey, 0xA0 + _Number, 16);
 }
 
-/////////////////////////////////////////////////////////////////////////////////////////////////
+
 //
 //
 //
@@ -88,7 +88,7 @@ CWII_IPC_HLE_WiiMote::CWII_IPC_HLE_WiiMote(CWII_IPC_HLE_Device_usb_oh1_57e_305*
 //
 //
 //
-/////////////////////////////////////////////////////////////////////////////////////////////////
+
 
 bool CWII_IPC_HLE_WiiMote::Update()
 {
@@ -149,7 +149,7 @@ bool CWII_IPC_HLE_WiiMote::Update()
 	return false;
 }
 
-/////////////////////////////////////////////////////////////////////////////////////////////////
+
 //
 //
 //
@@ -160,7 +160,7 @@ bool CWII_IPC_HLE_WiiMote::Update()
 //
 //
 //
-/////////////////////////////////////////////////////////////////////////////////////////////////
+
 
 void CWII_IPC_HLE_WiiMote::EventConnectionAccepted()
 {
@@ -197,7 +197,7 @@ void CWII_IPC_HLE_WiiMote::EventCommandWriteLinkPolicy()
 	m_HIDInterruptChannel_ConfigWait = false;
 }
 
-/////////////////////////////////////////////////////////////////////////////////////////////////
+
 //
 //
 //
@@ -208,7 +208,7 @@ void CWII_IPC_HLE_WiiMote::EventCommandWriteLinkPolicy()
 //
 //
 //
-/////////////////////////////////////////////////////////////////////////////////////////////////
+
 
 
 // ===================================================
@@ -390,7 +390,7 @@ void CWII_IPC_HLE_WiiMote::SignalChannel(u8* _pData, u32 _Size)
 	}
 }
 
-/////////////////////////////////////////////////////////////////////////////////////////////////
+
 //
 //
 //
@@ -401,7 +401,7 @@ void CWII_IPC_HLE_WiiMote::SignalChannel(u8* _pData, u32 _Size)
 //
 //
 //
-/////////////////////////////////////////////////////////////////////////////////////////////////
+
 
 
 void CWII_IPC_HLE_WiiMote::CommandConnectionReq(u8 _Ident, u8* _pData, u32 _Size)
@@ -576,7 +576,7 @@ void CWII_IPC_HLE_WiiMote::CommandDisconnectionReq(u8 _Ident, u8* _pData, u32 _S
 	SendCommandToACL(_Ident, L2CAP_DISCONN_RSP, sizeof(SL2CAP_CommandDisconnectionResponse), (u8*)&Rsp);
 }
 
-/////////////////////////////////////////////////////////////////////////////////////////////////
+
 //
 //
 //
@@ -587,7 +587,7 @@ void CWII_IPC_HLE_WiiMote::CommandDisconnectionReq(u8 _Ident, u8* _pData, u32 _S
 //
 //
 //
-/////////////////////////////////////////////////////////////////////////////////////////////////
+
 
 
 void CWII_IPC_HLE_WiiMote::SendConnectionRequest(u16 scid, u16 psm)
@@ -669,7 +669,7 @@ void CWII_IPC_HLE_WiiMote::SendConfigurationRequest(u16 scid, u16* MTU, u16* Flu
 	SendCommandToACL(L2CAP_CONF_REQ, L2CAP_CONF_REQ, Offset, Buffer);
 }
 
-/////////////////////////////////////////////////////////////////////////////////////////////////
+
 //
 //
 //
@@ -680,7 +680,7 @@ void CWII_IPC_HLE_WiiMote::SendConfigurationRequest(u16 scid, u16* MTU, u16* Flu
 //
 //
 //
-/////////////////////////////////////////////////////////////////////////////////////////////////
+
 
 #define SDP_UINT8  		0x08
 #define SDP_UINT16		0x09
@@ -855,7 +855,7 @@ void CWII_IPC_HLE_WiiMote::HandleSDP(u16 cid, u8* _pData, u32 _Size)
 	}
 }
 
-/////////////////////////////////////////////////////////////////////////////////////////////////
+
 //
 //
 //
@@ -866,7 +866,7 @@ void CWII_IPC_HLE_WiiMote::HandleSDP(u16 cid, u8* _pData, u32 _Size)
 //
 //
 //
-/////////////////////////////////////////////////////////////////////////////////////////////////
+
 
 
 void CWII_IPC_HLE_WiiMote::SendCommandToACL(u8 _Ident, u8 _Code, u8 _CommandLength, u8* _pCommandData)

Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_WiiMote.h

@@ -188,7 +188,7 @@ public:
 	virtual ~CWII_IPC_HLE_WiiMote()
 	{}
 
-	//////////////////////////////////////////////////////////////
+	
 	// ugly Host handling....
 	// we really have to clean all this code
 
@@ -292,7 +292,7 @@ private:
 	void CommandConfigurationResponse(u8 _Ident, u8* _pData, u32 _Size);
 
 
-	//////////////////
+	
 	// some new ugly stuff
 	//
 	// should be inside the plugin 

Source/Core/Core/Src/PluginManager.cpp

@@ -16,7 +16,7 @@
 // http://code.google.com/p/dolphin-emu/
 
 
-//////////////////////////////////////////////////////////////////////////////////////////
+
 // File description
 /* ¯¯¯¯¯¯¯¯¯¯¯¯
 
@@ -25,7 +25,7 @@
    created once when Dolphin starts and is closed when Dolphin is closed.
 
 */
-//////////////////////////////////////////////////////////////////////////////////////////
+
 // Include
 // ¯¯¯¯¯¯¯¯¯¯¯¯
 #include <string> // System
@@ -44,10 +44,10 @@
 
 // Create the plugin manager class
 CPluginManager CPluginManager::m_Instance;
-/////////////////////////////////////////
 
 
-//////////////////////////////////////////////////////////////////////////////////////////
+
+
 // The Plugin Manager Class
 // ¯¯¯¯¯¯¯¯¯¯¯¯
 
@@ -96,10 +96,10 @@ CPluginManager::~CPluginManager()
 
 	delete m_video;
 }
-//////////////////////////////////////////////
 
 
-//////////////////////////////////////////////////////////////////////////////////////////
+
+
 // Init and Shutdown Plugins 
 // ¯¯¯¯¯¯¯¯¯¯¯¯
 // Function: Point the m_pad[] and other variables to a certain plugin
@@ -200,7 +200,7 @@ void CPluginManager::ShutdownVideoPlugin()
 }
 
 
-////////////////////////////////////////////////////////////////////////////////
+
 // The PluginInfo class: Find Valid Plugins
 // ¯¯¯¯¯¯¯¯¯¯¯¯
 /* Function: This info is used in ScanForPlugins() to check for valid plugins and and in LoadPlugin() to
@@ -229,10 +229,10 @@ CPluginInfo::CPluginInfo(const char *_rFilename)
 		WARN_LOG(CONSOLE, "PluginInfo: %s is not a valid Dolphin plugin. Ignoring.", _rFilename);
 	}
 }
-///////////////////////////////////////////
 
 
-//////////////////////////////////////////////////////////////////////////////////////////
+
+
 // Supporting functions
 // ¯¯¯¯¯¯¯¯¯¯¯¯
 
@@ -369,10 +369,10 @@ void CPluginManager::ScanForPlugins()
 		}
 	}
 }
-/////////////////////////////////////////////////
 
 
-//////////////////////////////////////////////////////////////////////////////////////////
+
+
 /* Create or return the already created plugin pointers. This will be called
    often for the Pad and Wiimote from the SI_.cpp files. And often for the DSP
    from the DSP files.
@@ -469,10 +469,10 @@ void CPluginManager::FreeWiimote(u32 Wiimote)
 		m_wiimote[Wiimote] = NULL;	
 	}
 }
-///////////////////////////////////////////
 
 
-//////////////////////////////////////////////////////////////////////
+
+
 // Call DLL functions
 // ¯¯¯¯¯¯¯¯¯¯¯¯
 

Source/Core/Core/Src/PowerPC/Gekko.h

@@ -22,9 +22,9 @@
 
 #include "Common.h"
 
-/////////////////////////////////////////////////////////////////////////////////////////////////////
+
 // --- Gekko Instruction ---
-//////////////////////////////////////////////////////////////////////////////////////////////////////
+
 
 union UGeckoInstruction
 {
@@ -265,11 +265,11 @@ union UGeckoInstruction
 	};
 };
 
-/////////////////////////////////////////////////////////////////////////////////////////////////////
+
 //
 // --- Gekko Special Registers ---
 //
-//////////////////////////////////////////////////////////////////////////////////////////////////////
+
 
 // GQR Register
 union UGQR
@@ -531,11 +531,11 @@ union UReg_PTE
 	u32 Hex32[2];
 };
 
-/////////////////////////////////////////////////////////////////////////////////////////////////////
+
 //
 // --- Gekko Types and Defs ---
 //
-//////////////////////////////////////////////////////////////////////////////////////////////////////
+
 
 // quantize types
 enum EQuantizeType