From e7fb7318fbe69d4850d9948a4194ded985b17c13 Mon Sep 17 00:00:00 2001 From: stephena Date: Sun, 26 Apr 2015 19:02:42 +0000 Subject: [PATCH] Bumped version #. Introduce namespace to class MD5, so the method call is now MD5::hash() instead of simply MD5(). Added C++11 '= delete' constructors to most classes, to more clearly indicate the intent of the class. Note that this isn't absolutely necessary, but is considered good form. I will be teaching a C++ class over the summer using Stella for examples, so it makes sense to follow the standard and the textbook recommendations :) git-svn-id: svn://svn.code.sf.net/p/stella/code/trunk@3164 8b62c5a3-ac7e-4cc8-8f21-d9a121418aba --- src/cheat/BankRomCheat.hxx | 8 ++++++ src/cheat/Cheat.hxx | 8 ++++++ src/cheat/CheatCodeDialog.hxx | 8 ++++++ src/cheat/CheatManager.hxx | 8 ++++++ src/cheat/CheetahCheat.hxx | 8 ++++++ src/cheat/RamCheat.hxx | 8 ++++++ src/common/Base.hxx | 11 +++++-- src/common/EventHandlerSDL2.hxx | 8 ++++++ src/common/FBSurfaceSDL2.hxx | 9 ++++-- src/common/FSNodeFactory.hxx | 8 ++++++ src/common/FrameBufferSDL2.hxx | 8 ++++++ src/common/MediaFactory.hxx | 8 ++++++ src/common/MouseControl.hxx | 8 ++++++ src/common/PNGLibrary.hxx | 7 +++++ src/common/SoundNull.hxx | 8 ++++++ src/common/SoundSDL2.hxx | 14 +++++++++ src/common/Stack.hxx | 9 +++++- src/common/StringParser.hxx | 8 ++++++ src/common/Version.hxx | 2 +- src/common/ZipHandler.hxx | 7 +++++ src/common/tv_filters/NTSCFilter.hxx | 7 +++++ src/debugger/CartDebug.hxx | 8 ++++++ src/debugger/CpuDebug.hxx | 8 ++++++ src/debugger/Debugger.hxx | 16 +++++++++++ src/debugger/DebuggerParser.hxx | 8 ++++++ src/debugger/DebuggerSystem.hxx | 8 ++++++ src/debugger/DiStella.hxx | 8 ++++++ src/debugger/Expression.hxx | 7 +++++ src/debugger/PackedBitArray.hxx | 11 ++++--- src/debugger/RiotDebug.hxx | 8 ++++++ src/debugger/TIADebug.hxx | 8 ++++++ src/debugger/gui/AtariVoxWidget.hxx | 8 ++++++ src/debugger/gui/AudioWidget.hxx | 8 ++++++ src/debugger/gui/BoosterWidget.hxx | 8 ++++++ src/debugger/gui/Cart0840Widget.hxx | 8 ++++++ src/debugger/gui/Cart2KWidget.hxx | 8 ++++++ src/debugger/gui/Cart3EWidget.hxx | 8 ++++++ src/debugger/gui/Cart3FWidget.hxx | 8 ++++++ src/debugger/gui/Cart4A50Widget.hxx | 8 ++++++ src/debugger/gui/Cart4KSCWidget.hxx | 8 ++++++ src/debugger/gui/Cart4KWidget.hxx | 8 ++++++ src/debugger/gui/CartARWidget.hxx | 8 ++++++ src/debugger/gui/CartBFSCWidget.hxx | 8 ++++++ src/debugger/gui/CartBFWidget.hxx | 8 ++++++ src/debugger/gui/CartCMWidget.hxx | 8 ++++++ src/debugger/gui/CartCTYWidget.hxx | 8 ++++++ src/debugger/gui/CartCVWidget.hxx | 9 +++++- src/debugger/gui/CartDASHWidget.hxx | 8 ++++++ src/debugger/gui/CartDFSCWidget.hxx | 8 ++++++ src/debugger/gui/CartDFWidget.hxx | 8 ++++++ src/debugger/gui/CartDPCPlusWidget.hxx | 8 ++++++ src/debugger/gui/CartDPCWidget.hxx | 8 ++++++ src/debugger/gui/CartDebugWidget.hxx | 8 ++++++ src/debugger/gui/CartE0Widget.hxx | 8 ++++++ src/debugger/gui/CartE7Widget.hxx | 8 ++++++ src/debugger/gui/CartEFSCWidget.hxx | 8 ++++++ src/debugger/gui/CartEFWidget.hxx | 8 ++++++ src/debugger/gui/CartF0Widget.hxx | 8 ++++++ src/debugger/gui/CartF4SCWidget.hxx | 8 ++++++ src/debugger/gui/CartF4Widget.hxx | 8 ++++++ src/debugger/gui/CartF6SCWidget.hxx | 9 ++++++ src/debugger/gui/CartF6Widget.hxx | 8 ++++++ src/debugger/gui/CartF8SCWidget.hxx | 8 ++++++ src/debugger/gui/CartF8Widget.hxx | 8 ++++++ src/debugger/gui/CartFA2Widget.hxx | 8 ++++++ src/debugger/gui/CartFAWidget.hxx | 8 ++++++ src/debugger/gui/CartFEWidget.hxx | 8 ++++++ src/debugger/gui/CartMCWidget.hxx | 8 ++++++ src/debugger/gui/CartMDMWidget.hxx | 8 ++++++ src/debugger/gui/CartRamWidget.hxx | 8 ++++++ src/debugger/gui/CartSBWidget.hxx | 8 ++++++ src/debugger/gui/CartUAWidget.hxx | 8 ++++++ src/debugger/gui/CartWDWidget.hxx | 8 ++++++ src/debugger/gui/CartX07Widget.hxx | 8 ++++++ src/debugger/gui/ColorWidget.hxx | 8 ++++++ src/debugger/gui/ControllerWidget.hxx | 8 ++++++ src/debugger/gui/CpuWidget.hxx | 8 ++++++ src/debugger/gui/DataGridOpsWidget.hxx | 8 ++++++ src/debugger/gui/DataGridWidget.hxx | 8 ++++++ src/debugger/gui/DebuggerDialog.hxx | 8 ++++++ src/debugger/gui/DrivingWidget.hxx | 8 ++++++ src/debugger/gui/GenesisWidget.hxx | 8 ++++++ src/debugger/gui/JoystickWidget.hxx | 8 ++++++ src/debugger/gui/KeyboardWidget.hxx | 8 ++++++ src/debugger/gui/NullControlWidget.hxx | 8 ++++++ src/debugger/gui/PaddleWidget.hxx | 8 ++++++ src/debugger/gui/PromptWidget.hxx | 8 ++++++ src/debugger/gui/RamWidget.hxx | 8 ++++++ src/debugger/gui/RiotWidget.hxx | 8 ++++++ src/debugger/gui/RomListSettings.hxx | 8 ++++++ src/debugger/gui/RomListWidget.hxx | 8 ++++++ src/debugger/gui/RomWidget.hxx | 8 ++++++ src/debugger/gui/SaveKeyWidget.hxx | 8 ++++++ src/debugger/gui/TiaInfoWidget.hxx | 8 ++++++ src/debugger/gui/TiaOutputWidget.hxx | 8 ++++++ src/debugger/gui/TiaWidget.hxx | 8 ++++++ src/debugger/gui/TiaZoomWidget.hxx | 8 ++++++ src/debugger/gui/ToggleBitWidget.hxx | 8 ++++++ src/debugger/gui/TogglePixelWidget.hxx | 8 ++++++ src/debugger/gui/ToggleWidget.hxx | 8 ++++++ src/emucore/AtariVox.hxx | 8 ++++++ src/emucore/Booster.hxx | 8 ++++++ src/emucore/Cart.cxx | 2 +- src/emucore/Cart.hxx | 9 ++++-- src/emucore/Cart0840.hxx | 8 ++++++ src/emucore/Cart2K.hxx | 8 ++++++ src/emucore/Cart3E.hxx | 8 ++++++ src/emucore/Cart3F.hxx | 8 ++++++ src/emucore/Cart4A50.hxx | 8 ++++++ src/emucore/Cart4K.hxx | 8 ++++++ src/emucore/Cart4KSC.hxx | 8 ++++++ src/emucore/CartAR.hxx | 8 ++++++ src/emucore/CartBF.hxx | 8 ++++++ src/emucore/CartBFSC.hxx | 8 ++++++ src/emucore/CartCM.hxx | 8 ++++++ src/emucore/CartCTY.hxx | 8 ++++++ src/emucore/CartCV.hxx | 8 ++++++ src/emucore/CartDASH.hxx | 8 ++++++ src/emucore/CartDF.hxx | 8 ++++++ src/emucore/CartDFSC.hxx | 8 ++++++ src/emucore/CartDPC.hxx | 8 ++++++ src/emucore/CartDPCPlus.hxx | 8 ++++++ src/emucore/CartE0.hxx | 8 ++++++ src/emucore/CartE7.hxx | 8 ++++++ src/emucore/CartEF.hxx | 8 ++++++ src/emucore/CartEFSC.hxx | 8 ++++++ src/emucore/CartF0.hxx | 8 ++++++ src/emucore/CartF4.hxx | 8 ++++++ src/emucore/CartF4SC.hxx | 8 ++++++ src/emucore/CartF6.hxx | 8 ++++++ src/emucore/CartF6SC.hxx | 8 ++++++ src/emucore/CartF8.hxx | 8 ++++++ src/emucore/CartF8SC.hxx | 8 ++++++ src/emucore/CartFA.hxx | 8 ++++++ src/emucore/CartFA2.hxx | 8 ++++++ src/emucore/CartFE.hxx | 8 ++++++ src/emucore/CartMC.hxx | 8 ++++++ src/emucore/CartMDM.hxx | 8 ++++++ src/emucore/CartSB.hxx | 8 ++++++ src/emucore/CartUA.hxx | 8 ++++++ src/emucore/CartWD.hxx | 8 ++++++ src/emucore/CartX07.hxx | 8 ++++++ src/emucore/CompuMate.hxx | 17 ++++++++++- src/emucore/Console.hxx | 12 +++++--- src/emucore/Control.hxx | 9 ++++-- src/emucore/Device.hxx | 7 +++++ src/emucore/Driving.hxx | 8 ++++++ src/emucore/Event.hxx | 7 +++++ src/emucore/EventHandler.hxx | 11 ++++--- src/emucore/FBSurface.hxx | 12 ++++---- src/emucore/FrameBuffer.hxx | 8 ++++++ src/emucore/Genesis.hxx | 8 ++++++ src/emucore/Joystick.hxx | 8 ++++++ src/emucore/Keyboard.hxx | 8 ++++++ src/emucore/KidVid.hxx | 8 ++++++ src/emucore/M6502.hxx | 8 ++++++ src/emucore/M6532.hxx | 9 ++++-- src/emucore/MD5.cxx | 10 +++++-- src/emucore/MD5.hxx | 8 ++++-- src/emucore/MT24LC256.hxx | 9 ++++-- src/emucore/MindLink.hxx | 8 ++++++ src/emucore/NullDev.hxx | 7 +++++ src/emucore/OSystem.cxx | 2 +- src/emucore/OSystem.hxx | 8 ++++-- src/emucore/Paddles.hxx | 8 ++++++ src/emucore/PropsSet.hxx | 8 ++++++ src/emucore/Random.hxx | 8 ++++++ src/emucore/SaveKey.hxx | 8 ++++++ src/emucore/SerialPort.hxx | 7 +++++ src/emucore/Serializable.hxx | 7 +++++ src/emucore/Serializer.cxx | 6 ++-- src/emucore/Serializer.hxx | 9 +++--- src/emucore/Settings.hxx | 13 +++++---- src/emucore/Sound.hxx | 8 ++++++ src/emucore/StateManager.hxx | 13 +++++---- src/emucore/Switches.hxx | 8 ++++++ src/emucore/System.hxx | 9 ++++-- src/emucore/TIA.hxx | 9 ++++-- src/emucore/TIASnd.hxx | 7 +++++ src/emucore/TIASurface.hxx | 8 ++++++ src/emucore/TIATables.hxx | 8 ++++++ src/emucore/Thumbulator.hxx | 8 ++++++ src/emucore/TrackBall.hxx | 8 ++++++ src/gui/AboutDialog.hxx | 8 ++++++ src/gui/AudioDialog.hxx | 8 ++++++ src/gui/BrowserDialog.hxx | 8 ++++++ src/gui/CheckListWidget.hxx | 8 ++++++ src/gui/ComboDialog.hxx | 8 ++++++ src/gui/CommandDialog.hxx | 8 ++++++ src/gui/CommandMenu.hxx | 8 ++++++ src/gui/ConfigPathDialog.hxx | 8 ++++++ src/gui/ContextMenu.hxx | 8 ++++++ src/gui/Dialog.hxx | 8 ++++++ src/gui/DialogContainer.hxx | 8 ++++++ src/gui/EditTextWidget.hxx | 8 ++++++ src/gui/EditableWidget.hxx | 8 ++++++ src/gui/EventMappingWidget.hxx | 8 ++++++ src/gui/FileListWidget.hxx | 8 ++++++ src/gui/Font.hxx | 8 ++++++ src/gui/GameInfoDialog.hxx | 8 ++++++ src/gui/GameList.hxx | 7 +++++ src/gui/GlobalPropsDialog.hxx | 8 ++++++ src/gui/GuiObject.hxx | 8 ++++++ src/gui/HelpDialog.hxx | 8 ++++++ src/gui/InputDialog.hxx | 8 ++++++ src/gui/InputTextDialog.hxx | 8 ++++++ src/gui/JoystickDialog.hxx | 8 ++++++ src/gui/Launcher.hxx | 8 ++++++ src/gui/LauncherDialog.cxx | 4 +-- src/gui/LauncherDialog.hxx | 8 ++++++ src/gui/LauncherFilterDialog.hxx | 8 ++++++ src/gui/ListWidget.hxx | 8 ++++++ src/gui/LoggerDialog.hxx | 8 ++++++ src/gui/Menu.hxx | 8 ++++++ src/gui/MessageBox.hxx | 8 ++++++ src/gui/OptionsDialog.hxx | 8 ++++++ src/gui/PopUpWidget.hxx | 8 ++++++ src/gui/ProgressDialog.hxx | 8 ++++++ src/gui/RomAuditDialog.cxx | 2 +- src/gui/RomAuditDialog.hxx | 8 ++++++ src/gui/RomInfoWidget.hxx | 8 ++++++ src/gui/ScrollBarWidget.hxx | 10 +++++-- src/gui/SnapshotDialog.hxx | 8 ++++++ src/gui/StringListWidget.hxx | 8 ++++++ src/gui/TabWidget.hxx | 10 ++++++- src/gui/UIDialog.hxx | 8 ++++++ src/gui/VideoDialog.hxx | 8 ++++++ src/gui/Widget.hxx | 40 ++++++++++++++++++++++++++ src/macosx/OSystemMACOSX.hxx | 7 +++++ src/macosx/SerialPortMACOSX.hxx | 7 +++++ src/macosx/SettingsMACOSX.hxx | 8 ++++++ src/unix/OSystemUNIX.hxx | 7 +++++ src/unix/SettingsUNIX.hxx | 8 ++++++ src/windows/HomeFinder.hxx | 16 +++++++---- src/windows/OSystemWINDOWS.hxx | 7 +++++ src/windows/SerialPortWINDOWS.hxx | 7 +++++ src/windows/SettingsWINDOWS.hxx | 8 ++++++ 237 files changed, 1873 insertions(+), 84 deletions(-) diff --git a/src/cheat/BankRomCheat.hxx b/src/cheat/BankRomCheat.hxx index 30ce58830..667b75782 100644 --- a/src/cheat/BankRomCheat.hxx +++ b/src/cheat/BankRomCheat.hxx @@ -38,6 +38,14 @@ class BankRomCheat : public Cheat uInt8 value; uInt8 count; int bank; + + private: + // Following constructors and assignment operators not supported + BankRomCheat() = delete; + BankRomCheat(const BankRomCheat&) = delete; + BankRomCheat(BankRomCheat&&) = delete; + BankRomCheat& operator=(const BankRomCheat&) = delete; + BankRomCheat& operator=(BankRomCheat&&) = delete; }; #endif diff --git a/src/cheat/Cheat.hxx b/src/cheat/Cheat.hxx index 952909677..5ca1a0915 100644 --- a/src/cheat/Cheat.hxx +++ b/src/cheat/Cheat.hxx @@ -70,6 +70,14 @@ class Cheat string myCode; bool myEnabled; + + private: + // Following constructors and assignment operators not supported + Cheat() = delete; + Cheat(const Cheat&) = delete; + Cheat(Cheat&&) = delete; + Cheat& operator=(const Cheat&) = delete; + Cheat& operator=(Cheat&&) = delete; }; #endif diff --git a/src/cheat/CheatCodeDialog.hxx b/src/cheat/CheatCodeDialog.hxx index 91e815f3e..1d475d1ba 100644 --- a/src/cheat/CheatCodeDialog.hxx +++ b/src/cheat/CheatCodeDialog.hxx @@ -67,6 +67,14 @@ class CheatCodeDialog : public Dialog kOneShotCheatAdded = 'CHoa', kRemCheatCmd = 'CHTr' }; + + private: + // Following constructors and assignment operators not supported + CheatCodeDialog() = delete; + CheatCodeDialog(const CheatCodeDialog&) = delete; + CheatCodeDialog(CheatCodeDialog&&) = delete; + CheatCodeDialog& operator=(const CheatCodeDialog&) = delete; + CheatCodeDialog& operator=(CheatCodeDialog&&) = delete; }; #endif diff --git a/src/cheat/CheatManager.hxx b/src/cheat/CheatManager.hxx index 19782615d..3ee6b4d6c 100644 --- a/src/cheat/CheatManager.hxx +++ b/src/cheat/CheatManager.hxx @@ -159,6 +159,14 @@ class CheatManager // Indicates that the list has been modified, and should be saved to disk bool myListIsDirty; + + private: + // Following constructors and assignment operators not supported + CheatManager() = delete; + CheatManager(const CheatManager&) = delete; + CheatManager(CheatManager&&) = delete; + CheatManager& operator=(const CheatManager&) = delete; + CheatManager& operator=(CheatManager&&) = delete; }; #endif diff --git a/src/cheat/CheetahCheat.hxx b/src/cheat/CheetahCheat.hxx index db7b6e897..4a6871c18 100644 --- a/src/cheat/CheetahCheat.hxx +++ b/src/cheat/CheetahCheat.hxx @@ -37,6 +37,14 @@ class CheetahCheat : public Cheat uInt16 address; uInt8 value; uInt8 count; + + private: + // Following constructors and assignment operators not supported + CheetahCheat() = delete; + CheetahCheat(const CheetahCheat&) = delete; + CheetahCheat(CheetahCheat&&) = delete; + CheetahCheat& operator=(const CheetahCheat&) = delete; + CheetahCheat& operator=(CheetahCheat&&) = delete; }; #endif diff --git a/src/cheat/RamCheat.hxx b/src/cheat/RamCheat.hxx index 4a34990ac..2473b81da 100644 --- a/src/cheat/RamCheat.hxx +++ b/src/cheat/RamCheat.hxx @@ -35,6 +35,14 @@ class RamCheat : public Cheat private: uInt16 address; uInt8 value; + + private: + // Following constructors and assignment operators not supported + RamCheat() = delete; + RamCheat(const RamCheat&) = delete; + RamCheat(RamCheat&&) = delete; + RamCheat& operator=(const RamCheat&) = delete; + RamCheat& operator=(RamCheat&&) = delete; }; #endif diff --git a/src/common/Base.hxx b/src/common/Base.hxx index 81cee4cf6..ac3d7c659 100644 --- a/src/common/Base.hxx +++ b/src/common/Base.hxx @@ -80,9 +80,6 @@ class Base static string toString(int value, Common::Base::Format outputBase = Common::Base::F_DEFAULT); - private: // Make sure this class is never instantiated - Base() { } - private: // Default format to use when none is specified static Format myDefaultBase; @@ -95,6 +92,14 @@ class Base static const char* myLowerFmt[4]; static const char* myUpperFmt[4]; static const char** myFmt; + + private: + // Following constructors and assignment operators not supported + Base() = delete; + Base(const Base&) = delete; + Base(Base&&) = delete; + Base& operator=(const Base&) = delete; + Base& operator=(Base&&) = delete; }; } // Namespace Common diff --git a/src/common/EventHandlerSDL2.hxx b/src/common/EventHandlerSDL2.hxx index 09429d20c..3a89a92e2 100644 --- a/src/common/EventHandlerSDL2.hxx +++ b/src/common/EventHandlerSDL2.hxx @@ -74,6 +74,14 @@ class EventHandlerSDL2 : public EventHandler private: SDL_Joystick* myStick; }; + + private: + // Following constructors and assignment operators not supported + EventHandlerSDL2() = delete; + EventHandlerSDL2(const EventHandlerSDL2&) = delete; + EventHandlerSDL2(EventHandlerSDL2&&) = delete; + EventHandlerSDL2& operator=(const EventHandlerSDL2&) = delete; + EventHandlerSDL2& operator=(EventHandlerSDL2&&) = delete; }; #endif diff --git a/src/common/FBSurfaceSDL2.hxx b/src/common/FBSurfaceSDL2.hxx index ea92c093e..e8654fa00 100644 --- a/src/common/FBSurfaceSDL2.hxx +++ b/src/common/FBSurfaceSDL2.hxx @@ -67,9 +67,12 @@ class FBSurfaceSDL2 : public FBSurface private: void createSurface(uInt32 width, uInt32 height, const uInt32* data); - // Copy constructor and assignment operator not supported - FBSurfaceSDL2(const FBSurfaceSDL2&); - FBSurfaceSDL2& operator = (const FBSurfaceSDL2&); + // Following constructors and assignment operators not supported + FBSurfaceSDL2() = delete; + FBSurfaceSDL2(const FBSurfaceSDL2&) = delete; + FBSurfaceSDL2(FBSurfaceSDL2&&) = delete; + FBSurfaceSDL2& operator=(const FBSurfaceSDL2&) = delete; + FBSurfaceSDL2& operator=(FBSurfaceSDL2&&) = delete; private: FrameBufferSDL2& myFB; diff --git a/src/common/FSNodeFactory.hxx b/src/common/FSNodeFactory.hxx index 63e7e5aff..5d45fe99e 100644 --- a/src/common/FSNodeFactory.hxx +++ b/src/common/FSNodeFactory.hxx @@ -59,6 +59,14 @@ class FilesystemNodeFactory } return 0; } + + private: + // Following constructors and assignment operators not supported + FilesystemNodeFactory() = delete; + FilesystemNodeFactory(const FilesystemNodeFactory&) = delete; + FilesystemNodeFactory(FilesystemNodeFactory&&) = delete; + FilesystemNodeFactory& operator=(const FilesystemNodeFactory&) = delete; + FilesystemNodeFactory& operator=(FilesystemNodeFactory&&) = delete; }; #endif diff --git a/src/common/FrameBufferSDL2.hxx b/src/common/FrameBufferSDL2.hxx index c9cdac7a6..b10402405 100644 --- a/src/common/FrameBufferSDL2.hxx +++ b/src/common/FrameBufferSDL2.hxx @@ -181,6 +181,14 @@ class FrameBufferSDL2 : public FrameBuffer // Indicates that the renderer has been modified, and should be redrawn bool myDirtyFlag; + + private: + // Following constructors and assignment operators not supported + FrameBufferSDL2() = delete; + FrameBufferSDL2(const FrameBufferSDL2&) = delete; + FrameBufferSDL2(FrameBufferSDL2&&) = delete; + FrameBufferSDL2& operator=(const FrameBufferSDL2&) = delete; + FrameBufferSDL2& operator=(FrameBufferSDL2&&) = delete; }; #endif diff --git a/src/common/MediaFactory.hxx b/src/common/MediaFactory.hxx index f5688422f..85b4238df 100644 --- a/src/common/MediaFactory.hxx +++ b/src/common/MediaFactory.hxx @@ -124,6 +124,14 @@ class MediaFactory { return make_ptr(osystem); } + + private: + // Following constructors and assignment operators not supported + MediaFactory() = delete; + MediaFactory(const MediaFactory&) = delete; + MediaFactory(MediaFactory&&) = delete; + MediaFactory& operator=(const MediaFactory&) = delete; + MediaFactory& operator=(MediaFactory&&) = delete; }; #endif diff --git a/src/common/MouseControl.hxx b/src/common/MouseControl.hxx index 60bd3c60c..b44d7b54d 100644 --- a/src/common/MouseControl.hxx +++ b/src/common/MouseControl.hxx @@ -108,6 +108,14 @@ class MouseControl int myCurrentModeNum; vector myModeList; + + private: + // Following constructors and assignment operators not supported + MouseControl() = delete; + MouseControl(const MouseControl&) = delete; + MouseControl(MouseControl&&) = delete; + MouseControl& operator=(const MouseControl&) = delete; + MouseControl& operator=(MouseControl&&) = delete; }; #endif diff --git a/src/common/PNGLibrary.hxx b/src/common/PNGLibrary.hxx index 91e61005e..3def9fab9 100644 --- a/src/common/PNGLibrary.hxx +++ b/src/common/PNGLibrary.hxx @@ -146,6 +146,13 @@ class PNGLibrary static void png_io_flush(png_structp ctx); static void png_user_warn(png_structp ctx, png_const_charp str); static void png_user_error(png_structp ctx, png_const_charp str); + + private: + // Following constructors and assignment operators not supported + PNGLibrary(const PNGLibrary&) = delete; + PNGLibrary(PNGLibrary&&) = delete; + PNGLibrary& operator=(const PNGLibrary&) = delete; + PNGLibrary& operator=(PNGLibrary&&) = delete; }; #endif diff --git a/src/common/SoundNull.hxx b/src/common/SoundNull.hxx index 931c12876..b5dab0685 100644 --- a/src/common/SoundNull.hxx +++ b/src/common/SoundNull.hxx @@ -179,6 +179,14 @@ class SoundNull : public Sound @return The name of the object */ string name() const { return "TIASound"; } + + private: + // Following constructors and assignment operators not supported + SoundNull() = delete; + SoundNull(const SoundNull&) = delete; + SoundNull(SoundNull&&) = delete; + SoundNull& operator=(const SoundNull&) = delete; + SoundNull& operator=(SoundNull&&) = delete; }; #endif diff --git a/src/common/SoundSDL2.hxx b/src/common/SoundSDL2.hxx index 430ad0cdc..ae4d68ad2 100644 --- a/src/common/SoundSDL2.hxx +++ b/src/common/SoundSDL2.hxx @@ -243,6 +243,13 @@ class SoundSDL2 : public Sound uInt32 mySize; uInt32 myHead; uInt32 myTail; + + private: + // Following constructors and assignment operators not supported + RegWriteQueue(const RegWriteQueue&) = delete; + RegWriteQueue(RegWriteQueue&&) = delete; + RegWriteQueue& operator=(const RegWriteQueue&) = delete; + RegWriteQueue& operator=(RegWriteQueue&&) = delete; }; private: @@ -285,6 +292,13 @@ class SoundSDL2 : public Sound private: // Callback function invoked by the SDL Audio library when it needs data static void callback(void* udata, uInt8* stream, int len); + + // Following constructors and assignment operators not supported + SoundSDL2() = delete; + SoundSDL2(const SoundSDL2&) = delete; + SoundSDL2(SoundSDL2&&) = delete; + SoundSDL2& operator=(const SoundSDL2&) = delete; + SoundSDL2& operator=(SoundSDL2&&) = delete; }; #endif diff --git a/src/common/Stack.hxx b/src/common/Stack.hxx index 271a4da58..b35d1529a 100644 --- a/src/common/Stack.hxx +++ b/src/common/Stack.hxx @@ -34,7 +34,7 @@ template class FixedStack { public: - FixedStack() : _size(0) {} + FixedStack() : _size(0) { } bool empty() const { return _size <= 0; } bool full() const { return _size >= MAX_SIZE; } @@ -66,6 +66,13 @@ class FixedStack protected: T _stack[MAX_SIZE]; int _size; + + private: + // Following constructors and assignment operators not supported + FixedStack(const FixedStack&) = delete; + FixedStack(FixedStack&&) = delete; + FixedStack& operator=(const FixedStack&) = delete; + FixedStack& operator=(FixedStack&&) = delete; }; } // Namespace Common diff --git a/src/common/StringParser.hxx b/src/common/StringParser.hxx index 149c83132..016ba5825 100644 --- a/src/common/StringParser.hxx +++ b/src/common/StringParser.hxx @@ -84,6 +84,14 @@ class StringParser private: StringList myStringList; + + private: + // Following constructors and assignment operators not supported + StringParser() = delete; + StringParser(const StringParser&) = delete; + StringParser(StringParser&&) = delete; + StringParser& operator=(const StringParser&) = delete; + StringParser& operator=(StringParser&&) = delete; }; #endif diff --git a/src/common/Version.hxx b/src/common/Version.hxx index ecd79fa6d..9a3870902 100644 --- a/src/common/Version.hxx +++ b/src/common/Version.hxx @@ -22,7 +22,7 @@ #include -#define STELLA_VERSION "4.6.1" +#define STELLA_VERSION "4.7_pre" #define STELLA_BUILD atoi("$Rev$" + 6) #endif diff --git a/src/common/ZipHandler.hxx b/src/common/ZipHandler.hxx index a7f7f5a16..417f364e9 100644 --- a/src/common/ZipHandler.hxx +++ b/src/common/ZipHandler.hxx @@ -268,6 +268,13 @@ class ZipHandler private: zip_file* myZip; zip_file* myZipCache[ZIP_CACHE_SIZE]; + + private: + // Following constructors and assignment operators not supported + ZipHandler(const ZipHandler&) = delete; + ZipHandler(ZipHandler&&) = delete; + ZipHandler& operator=(const ZipHandler&) = delete; + ZipHandler& operator=(ZipHandler&&) = delete; }; #endif /* ZIP_HANDLER_HXX */ diff --git a/src/common/tv_filters/NTSCFilter.hxx b/src/common/tv_filters/NTSCFilter.hxx index 5f87e03fd..22e27a27b 100644 --- a/src/common/tv_filters/NTSCFilter.hxx +++ b/src/common/tv_filters/NTSCFilter.hxx @@ -162,6 +162,13 @@ class NTSCFilter }; uInt32 myCurrentAdjustable; static const AdjustableTag ourCustomAdjustables[10]; + + private: + // Following constructors and assignment operators not supported + NTSCFilter(const NTSCFilter&) = delete; + NTSCFilter(NTSCFilter&&) = delete; + NTSCFilter& operator=(const NTSCFilter&) = delete; + NTSCFilter& operator=(NTSCFilter&&) = delete; }; #endif diff --git a/src/debugger/CartDebug.hxx b/src/debugger/CartDebug.hxx index 69995d12c..37c8ddbf0 100644 --- a/src/debugger/CartDebug.hxx +++ b/src/debugger/CartDebug.hxx @@ -388,6 +388,14 @@ class CartDebug : public DebuggerSystem static const char* ourTIAMnemonicW[64]; // write mode static const char* ourIOMnemonic[24]; static const char* ourZPMnemonic[128]; + + private: + // Following constructors and assignment operators not supported + CartDebug() = delete; + CartDebug(const CartDebug&) = delete; + CartDebug(CartDebug&&) = delete; + CartDebug& operator=(const CartDebug&) = delete; + CartDebug& operator=(CartDebug&&) = delete; }; #endif diff --git a/src/debugger/CpuDebug.hxx b/src/debugger/CpuDebug.hxx index ffb128a88..948f587b2 100644 --- a/src/debugger/CpuDebug.hxx +++ b/src/debugger/CpuDebug.hxx @@ -92,6 +92,14 @@ class CpuDebug : public DebuggerSystem CpuState myState; CpuState myOldState; + + private: + // Following constructors and assignment operators not supported + CpuDebug() = delete; + CpuDebug(const CpuDebug&) = delete; + CpuDebug(CpuDebug&&) = delete; + CpuDebug& operator=(const CpuDebug&) = delete; + CpuDebug& operator=(CpuDebug&&) = delete; }; #endif diff --git a/src/debugger/Debugger.hxx b/src/debugger/Debugger.hxx index ce95f8717..930e3535e 100644 --- a/src/debugger/Debugger.hxx +++ b/src/debugger/Debugger.hxx @@ -323,8 +323,24 @@ class Debugger : public DialogContainer ButtonWidget& myRewindButton; Serializer* myStateList[MAX_SIZE]; uInt32 mySize, myTop; + + private: + // Following constructors and assignment operators not supported + RewindManager() = delete; + RewindManager(const RewindManager&) = delete; + RewindManager(RewindManager&&) = delete; + RewindManager& operator=(const RewindManager&) = delete; + RewindManager& operator=(RewindManager&&) = delete; }; unique_ptr myRewindManager; + + private: + // Following constructors and assignment operators not supported + Debugger() = delete; + Debugger(const Debugger&) = delete; + Debugger(Debugger&&) = delete; + Debugger& operator=(const Debugger&) = delete; + Debugger& operator=(Debugger&&) = delete; }; #endif diff --git a/src/debugger/DebuggerParser.hxx b/src/debugger/DebuggerParser.hxx index 5c0959830..553f68c2d 100644 --- a/src/debugger/DebuggerParser.hxx +++ b/src/debugger/DebuggerParser.hxx @@ -193,6 +193,14 @@ class DebuggerParser // List of commands available static Command commands[kNumCommands]; + + private: + // Following constructors and assignment operators not supported + DebuggerParser() = delete; + DebuggerParser(const DebuggerParser&) = delete; + DebuggerParser(DebuggerParser&&) = delete; + DebuggerParser& operator=(const DebuggerParser&) = delete; + DebuggerParser& operator=(DebuggerParser&&) = delete; }; #endif diff --git a/src/debugger/DebuggerSystem.hxx b/src/debugger/DebuggerSystem.hxx index e4016bcbc..3fbafcb1f 100644 --- a/src/debugger/DebuggerSystem.hxx +++ b/src/debugger/DebuggerSystem.hxx @@ -58,6 +58,14 @@ class DebuggerSystem Debugger& myDebugger; Console& myConsole; System& mySystem; + + private: + // Following constructors and assignment operators not supported + DebuggerSystem() = delete; + DebuggerSystem(const DebuggerSystem&) = delete; + DebuggerSystem(DebuggerSystem&&) = delete; + DebuggerSystem& operator=(const DebuggerSystem&) = delete; + DebuggerSystem& operator=(DebuggerSystem&&) = delete; }; #endif diff --git a/src/debugger/DiStella.hxx b/src/debugger/DiStella.hxx index 2954bdda6..736a754d1 100644 --- a/src/debugger/DiStella.hxx +++ b/src/debugger/DiStella.hxx @@ -185,6 +185,14 @@ class DiStella uInt8 cycles; }; static const Instruction_tag ourLookup[256]; + + private: + // Following constructors and assignment operators not supported + DiStella() = delete; + DiStella(const DiStella&) = delete; + DiStella(DiStella&&) = delete; + DiStella& operator=(const DiStella&) = delete; + DiStella& operator=(DiStella&&) = delete; }; #endif diff --git a/src/debugger/Expression.hxx b/src/debugger/Expression.hxx index 625885522..47705a491 100644 --- a/src/debugger/Expression.hxx +++ b/src/debugger/Expression.hxx @@ -42,6 +42,13 @@ class Expression protected: unique_ptr myLHS, myRHS; + + private: + // Following constructors and assignment operators not supported + Expression(const Expression&) = delete; + Expression(Expression&&) = delete; + Expression& operator=(const Expression&) = delete; + Expression& operator=(Expression&&) = delete; }; static const Expression EmptyExpression; diff --git a/src/debugger/PackedBitArray.hxx b/src/debugger/PackedBitArray.hxx index bb92066ef..214a670f7 100644 --- a/src/debugger/PackedBitArray.hxx +++ b/src/debugger/PackedBitArray.hxx @@ -42,15 +42,18 @@ class PackedBitArray bool isInitialized() const { return myInitialized; } private: - // Copy constructor and assignment operator not supported - PackedBitArray(const PackedBitArray&); - PackedBitArray& operator = (const PackedBitArray&); - // The actual bits bitset<0x10000> myBits; // Indicates whether we should treat this bitset as initialized bool myInitialized; + + private: + // Following constructors and assignment operators not supported + PackedBitArray(const PackedBitArray&) = delete; + PackedBitArray(PackedBitArray&&) = delete; + PackedBitArray& operator=(const PackedBitArray&) = delete; + PackedBitArray& operator=(PackedBitArray&&) = delete; }; #endif diff --git a/src/debugger/RiotDebug.hxx b/src/debugger/RiotDebug.hxx index c7ac293b0..537f99ed1 100644 --- a/src/debugger/RiotDebug.hxx +++ b/src/debugger/RiotDebug.hxx @@ -99,6 +99,14 @@ class RiotDebug : public DebuggerSystem private: RiotState myState; RiotState myOldState; + + private: + // Following constructors and assignment operators not supported + RiotDebug() = delete; + RiotDebug(const RiotDebug&) = delete; + RiotDebug(RiotDebug&&) = delete; + RiotDebug& operator=(const RiotDebug&) = delete; + RiotDebug& operator=(RiotDebug&&) = delete; }; #endif diff --git a/src/debugger/TIADebug.hxx b/src/debugger/TIADebug.hxx index 672f81e5c..ecbc34c50 100644 --- a/src/debugger/TIADebug.hxx +++ b/src/debugger/TIADebug.hxx @@ -175,6 +175,14 @@ class TIADebug : public DebuggerSystem TIA& myTIA; string nusizStrings[8]; + + private: + // Following constructors and assignment operators not supported + TIADebug() = delete; + TIADebug(const TIADebug&) = delete; + TIADebug(TIADebug&&) = delete; + TIADebug& operator=(const TIADebug&) = delete; + TIADebug& operator=(TIADebug&&) = delete; }; #endif diff --git a/src/debugger/gui/AtariVoxWidget.hxx b/src/debugger/gui/AtariVoxWidget.hxx index f4ef3bf0d..c30c620d2 100644 --- a/src/debugger/gui/AtariVoxWidget.hxx +++ b/src/debugger/gui/AtariVoxWidget.hxx @@ -38,6 +38,14 @@ class AtariVoxWidget : public ControllerWidget private: ButtonWidget* myEEPROMErase; enum { kEEPROMErase = 'eeER' }; + + private: + // Following constructors and assignment operators not supported + AtariVoxWidget() = delete; + AtariVoxWidget(const AtariVoxWidget&) = delete; + AtariVoxWidget(AtariVoxWidget&&) = delete; + AtariVoxWidget& operator=(const AtariVoxWidget&) = delete; + AtariVoxWidget& operator=(AtariVoxWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/AudioWidget.hxx b/src/debugger/gui/AudioWidget.hxx index 1dda3c535..4ab8fa2e5 100644 --- a/src/debugger/gui/AudioWidget.hxx +++ b/src/debugger/gui/AudioWidget.hxx @@ -50,6 +50,14 @@ class AudioWidget : public Widget, public CommandSender DataGridWidget* myAudF; DataGridWidget* myAudC; DataGridWidget* myAudV; + + private: + // Following constructors and assignment operators not supported + AudioWidget() = delete; + AudioWidget(const AudioWidget&) = delete; + AudioWidget(AudioWidget&&) = delete; + AudioWidget& operator=(const AudioWidget&) = delete; + AudioWidget& operator=(AudioWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/BoosterWidget.hxx b/src/debugger/gui/BoosterWidget.hxx index 35a947b83..d6770515c 100644 --- a/src/debugger/gui/BoosterWidget.hxx +++ b/src/debugger/gui/BoosterWidget.hxx @@ -39,6 +39,14 @@ class BoosterWidget : public ControllerWidget CheckboxWidget* myPins[7]; static Controller::DigitalPin ourPinNo[5]; + + private: + // Following constructors and assignment operators not supported + BoosterWidget() = delete; + BoosterWidget(const BoosterWidget&) = delete; + BoosterWidget(BoosterWidget&&) = delete; + BoosterWidget& operator=(const BoosterWidget&) = delete; + BoosterWidget& operator=(BoosterWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/Cart0840Widget.hxx b/src/debugger/gui/Cart0840Widget.hxx index 9132eefa5..a01b72aa4 100644 --- a/src/debugger/gui/Cart0840Widget.hxx +++ b/src/debugger/gui/Cart0840Widget.hxx @@ -44,6 +44,14 @@ class Cartridge0840Widget : public CartDebugWidget PopUpWidget* myBank; enum { kBankChanged = 'bkCH' }; + + private: + // Following constructors and assignment operators not supported + Cartridge0840Widget() = delete; + Cartridge0840Widget(const Cartridge0840Widget&) = delete; + Cartridge0840Widget(Cartridge0840Widget&&) = delete; + Cartridge0840Widget& operator=(const Cartridge0840Widget&) = delete; + Cartridge0840Widget& operator=(Cartridge0840Widget&&) = delete; }; #endif diff --git a/src/debugger/gui/Cart2KWidget.hxx b/src/debugger/gui/Cart2KWidget.hxx index a13702883..b92277190 100644 --- a/src/debugger/gui/Cart2KWidget.hxx +++ b/src/debugger/gui/Cart2KWidget.hxx @@ -35,6 +35,14 @@ class Cartridge2KWidget : public CartDebugWidget // No implementation for non-bankswitched ROMs void loadConfig() { } void handleCommand(CommandSender* sender, int cmd, int data, int id) { } + + private: + // Following constructors and assignment operators not supported + Cartridge2KWidget() = delete; + Cartridge2KWidget(const Cartridge2KWidget&) = delete; + Cartridge2KWidget(Cartridge2KWidget&&) = delete; + Cartridge2KWidget& operator=(const Cartridge2KWidget&) = delete; + Cartridge2KWidget& operator=(Cartridge2KWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/Cart3EWidget.hxx b/src/debugger/gui/Cart3EWidget.hxx index 9538234e9..7b7e1042d 100644 --- a/src/debugger/gui/Cart3EWidget.hxx +++ b/src/debugger/gui/Cart3EWidget.hxx @@ -65,6 +65,14 @@ class Cartridge3EWidget : public CartDebugWidget kROMBankChanged = 'rmCH', kRAMBankChanged = 'raCH' }; + + private: + // Following constructors and assignment operators not supported + Cartridge3EWidget() = delete; + Cartridge3EWidget(const Cartridge3EWidget&) = delete; + Cartridge3EWidget(Cartridge3EWidget&&) = delete; + Cartridge3EWidget& operator=(const Cartridge3EWidget&) = delete; + Cartridge3EWidget& operator=(Cartridge3EWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/Cart3FWidget.hxx b/src/debugger/gui/Cart3FWidget.hxx index 2660384c2..5974a2a0a 100644 --- a/src/debugger/gui/Cart3FWidget.hxx +++ b/src/debugger/gui/Cart3FWidget.hxx @@ -44,6 +44,14 @@ class Cartridge3FWidget : public CartDebugWidget PopUpWidget* myBank; enum { kBankChanged = 'bkCH' }; + + private: + // Following constructors and assignment operators not supported + Cartridge3FWidget() = delete; + Cartridge3FWidget(const Cartridge3FWidget&) = delete; + Cartridge3FWidget(Cartridge3FWidget&&) = delete; + Cartridge3FWidget& operator=(const Cartridge3FWidget&) = delete; + Cartridge3FWidget& operator=(Cartridge3FWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/Cart4A50Widget.hxx b/src/debugger/gui/Cart4A50Widget.hxx index 110240c81..a1fedb397 100644 --- a/src/debugger/gui/Cart4A50Widget.hxx +++ b/src/debugger/gui/Cart4A50Widget.hxx @@ -53,6 +53,14 @@ class Cartridge4A50Widget : public CartDebugWidget kROMHighChanged = 'rmHI', kRAMHighChanged = 'raHI' }; + + private: + // Following constructors and assignment operators not supported + Cartridge4A50Widget() = delete; + Cartridge4A50Widget(const Cartridge4A50Widget&) = delete; + Cartridge4A50Widget(Cartridge4A50Widget&&) = delete; + Cartridge4A50Widget& operator=(const Cartridge4A50Widget&) = delete; + Cartridge4A50Widget& operator=(Cartridge4A50Widget&&) = delete; }; #endif diff --git a/src/debugger/gui/Cart4KSCWidget.hxx b/src/debugger/gui/Cart4KSCWidget.hxx index 68aa2f7c4..5479cd2ae 100644 --- a/src/debugger/gui/Cart4KSCWidget.hxx +++ b/src/debugger/gui/Cart4KSCWidget.hxx @@ -55,6 +55,14 @@ class Cartridge4KSCWidget : public CartDebugWidget ByteArray internalram; }; CartState myOldState; + + private: + // Following constructors and assignment operators not supported + Cartridge4KSCWidget() = delete; + Cartridge4KSCWidget(const Cartridge4KSCWidget&) = delete; + Cartridge4KSCWidget(Cartridge4KSCWidget&&) = delete; + Cartridge4KSCWidget& operator=(const Cartridge4KSCWidget&) = delete; + Cartridge4KSCWidget& operator=(Cartridge4KSCWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/Cart4KWidget.hxx b/src/debugger/gui/Cart4KWidget.hxx index db5a5c3b6..19a89a6f5 100644 --- a/src/debugger/gui/Cart4KWidget.hxx +++ b/src/debugger/gui/Cart4KWidget.hxx @@ -35,6 +35,14 @@ class Cartridge4KWidget : public CartDebugWidget // No implementation for non-bankswitched ROMs void loadConfig() { } void handleCommand(CommandSender* sender, int cmd, int data, int id) { } + + private: + // Following constructors and assignment operators not supported + Cartridge4KWidget() = delete; + Cartridge4KWidget(const Cartridge4KWidget&) = delete; + Cartridge4KWidget(Cartridge4KWidget&&) = delete; + Cartridge4KWidget& operator=(const Cartridge4KWidget&) = delete; + Cartridge4KWidget& operator=(Cartridge4KWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/CartARWidget.hxx b/src/debugger/gui/CartARWidget.hxx index 8dbf42fd1..18d53bcd7 100644 --- a/src/debugger/gui/CartARWidget.hxx +++ b/src/debugger/gui/CartARWidget.hxx @@ -44,6 +44,14 @@ class CartridgeARWidget : public CartDebugWidget PopUpWidget* myBank; enum { kBankChanged = 'bkCH' }; + + private: + // Following constructors and assignment operators not supported + CartridgeARWidget() = delete; + CartridgeARWidget(const CartridgeARWidget&) = delete; + CartridgeARWidget(CartridgeARWidget&&) = delete; + CartridgeARWidget& operator=(const CartridgeARWidget&) = delete; + CartridgeARWidget& operator=(CartridgeARWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/CartBFSCWidget.hxx b/src/debugger/gui/CartBFSCWidget.hxx index e013b0f8d..8143d2d7d 100644 --- a/src/debugger/gui/CartBFSCWidget.hxx +++ b/src/debugger/gui/CartBFSCWidget.hxx @@ -61,6 +61,14 @@ class CartridgeBFSCWidget : public CartDebugWidget CartState myOldState; enum { kBankChanged = 'bkCH' }; + + private: + // Following constructors and assignment operators not supported + CartridgeBFSCWidget() = delete; + CartridgeBFSCWidget(const CartridgeBFSCWidget&) = delete; + CartridgeBFSCWidget(CartridgeBFSCWidget&&) = delete; + CartridgeBFSCWidget& operator=(const CartridgeBFSCWidget&) = delete; + CartridgeBFSCWidget& operator=(CartridgeBFSCWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/CartBFWidget.hxx b/src/debugger/gui/CartBFWidget.hxx index 00173483b..ed6c0cb4d 100644 --- a/src/debugger/gui/CartBFWidget.hxx +++ b/src/debugger/gui/CartBFWidget.hxx @@ -44,6 +44,14 @@ class CartridgeBFWidget : public CartDebugWidget PopUpWidget* myBank; enum { kBankChanged = 'bkCH' }; + + private: + // Following constructors and assignment operators not supported + CartridgeBFWidget() = delete; + CartridgeBFWidget(const CartridgeBFWidget&) = delete; + CartridgeBFWidget(CartridgeBFWidget&&) = delete; + CartridgeBFWidget& operator=(const CartridgeBFWidget&) = delete; + CartridgeBFWidget& operator=(CartridgeBFWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/CartCMWidget.hxx b/src/debugger/gui/CartCMWidget.hxx index 87b9d307c..efaa6877f 100644 --- a/src/debugger/gui/CartCMWidget.hxx +++ b/src/debugger/gui/CartCMWidget.hxx @@ -77,6 +77,14 @@ class CartridgeCMWidget : public CartDebugWidget CartState myOldState; enum { kBankChanged = 'bkCH' }; + + private: + // Following constructors and assignment operators not supported + CartridgeCMWidget() = delete; + CartridgeCMWidget(const CartridgeCMWidget&) = delete; + CartridgeCMWidget(CartridgeCMWidget&&) = delete; + CartridgeCMWidget& operator=(const CartridgeCMWidget&) = delete; + CartridgeCMWidget& operator=(CartridgeCMWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/CartCTYWidget.hxx b/src/debugger/gui/CartCTYWidget.hxx index 810668755..adc4564a5 100644 --- a/src/debugger/gui/CartCTYWidget.hxx +++ b/src/debugger/gui/CartCTYWidget.hxx @@ -61,6 +61,14 @@ class CartridgeCTYWidget : public CartDebugWidget CartState myOldState; enum { kBankChanged = 'bkCH' }; + + private: + // Following constructors and assignment operators not supported + CartridgeCTYWidget() = delete; + CartridgeCTYWidget(const CartridgeCTYWidget&) = delete; + CartridgeCTYWidget(CartridgeCTYWidget&&) = delete; + CartridgeCTYWidget& operator=(const CartridgeCTYWidget&) = delete; + CartridgeCTYWidget& operator=(CartridgeCTYWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/CartCVWidget.hxx b/src/debugger/gui/CartCVWidget.hxx index 76a1233d2..4a3482ad0 100644 --- a/src/debugger/gui/CartCVWidget.hxx +++ b/src/debugger/gui/CartCVWidget.hxx @@ -55,7 +55,14 @@ class CartridgeCVWidget : public CartDebugWidget ByteArray internalram; }; CartState myOldState; - + + private: + // Following constructors and assignment operators not supported + CartridgeCVWidget() = delete; + CartridgeCVWidget(const CartridgeCVWidget&) = delete; + CartridgeCVWidget(CartridgeCVWidget&&) = delete; + CartridgeCVWidget& operator=(const CartridgeCVWidget&) = delete; + CartridgeCVWidget& operator=(CartridgeCVWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/CartDASHWidget.hxx b/src/debugger/gui/CartDASHWidget.hxx index c65bfa2da..9f4c1dd09 100644 --- a/src/debugger/gui/CartDASHWidget.hxx +++ b/src/debugger/gui/CartDASHWidget.hxx @@ -74,6 +74,14 @@ class CartridgeDASHWidget : public CartDebugWidget kBank3Changed = 'b3CH' }; static const BankID bankEnum[4]; + + private: + // Following constructors and assignment operators not supported + CartridgeDASHWidget() = delete; + CartridgeDASHWidget(const CartridgeDASHWidget&) = delete; + CartridgeDASHWidget(CartridgeDASHWidget&&) = delete; + CartridgeDASHWidget& operator=(const CartridgeDASHWidget&) = delete; + CartridgeDASHWidget& operator=(CartridgeDASHWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/CartDFSCWidget.hxx b/src/debugger/gui/CartDFSCWidget.hxx index 0a4bda117..2abdb6d44 100644 --- a/src/debugger/gui/CartDFSCWidget.hxx +++ b/src/debugger/gui/CartDFSCWidget.hxx @@ -61,6 +61,14 @@ class CartridgeDFSCWidget : public CartDebugWidget CartState myOldState; enum { kBankChanged = 'bkCH' }; + + private: + // Following constructors and assignment operators not supported + CartridgeDFSCWidget() = delete; + CartridgeDFSCWidget(const CartridgeDFSCWidget&) = delete; + CartridgeDFSCWidget(CartridgeDFSCWidget&&) = delete; + CartridgeDFSCWidget& operator=(const CartridgeDFSCWidget&) = delete; + CartridgeDFSCWidget& operator=(CartridgeDFSCWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/CartDFWidget.hxx b/src/debugger/gui/CartDFWidget.hxx index 02502adb7..ebe091829 100644 --- a/src/debugger/gui/CartDFWidget.hxx +++ b/src/debugger/gui/CartDFWidget.hxx @@ -44,6 +44,14 @@ class CartridgeDFWidget : public CartDebugWidget PopUpWidget* myBank; enum { kBankChanged = 'bkCH' }; + + private: + // Following constructors and assignment operators not supported + CartridgeDFWidget() = delete; + CartridgeDFWidget(const CartridgeDFWidget&) = delete; + CartridgeDFWidget(CartridgeDFWidget&&) = delete; + CartridgeDFWidget& operator=(const CartridgeDFWidget&) = delete; + CartridgeDFWidget& operator=(CartridgeDFWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/CartDPCPlusWidget.hxx b/src/debugger/gui/CartDPCPlusWidget.hxx index a917ca59e..a039337a9 100644 --- a/src/debugger/gui/CartDPCPlusWidget.hxx +++ b/src/debugger/gui/CartDPCPlusWidget.hxx @@ -88,6 +88,14 @@ class CartridgeDPCPlusWidget : public CartDebugWidget CartState myOldState; enum { kBankChanged = 'bkCH' }; + + private: + // Following constructors and assignment operators not supported + CartridgeDPCPlusWidget() = delete; + CartridgeDPCPlusWidget(const CartridgeDPCPlusWidget&) = delete; + CartridgeDPCPlusWidget(CartridgeDPCPlusWidget&&) = delete; + CartridgeDPCPlusWidget& operator=(const CartridgeDPCPlusWidget&) = delete; + CartridgeDPCPlusWidget& operator=(CartridgeDPCPlusWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/CartDPCWidget.hxx b/src/debugger/gui/CartDPCWidget.hxx index e049cef74..71c872d9e 100644 --- a/src/debugger/gui/CartDPCWidget.hxx +++ b/src/debugger/gui/CartDPCWidget.hxx @@ -77,6 +77,14 @@ class CartridgeDPCWidget : public CartDebugWidget CartState myOldState; enum { kBankChanged = 'bkCH' }; + + private: + // Following constructors and assignment operators not supported + CartridgeDPCWidget() = delete; + CartridgeDPCWidget(const CartridgeDPCWidget&) = delete; + CartridgeDPCWidget(CartridgeDPCWidget&&) = delete; + CartridgeDPCWidget& operator=(const CartridgeDPCWidget&) = delete; + CartridgeDPCWidget& operator=(CartridgeDPCWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/CartDebugWidget.hxx b/src/debugger/gui/CartDebugWidget.hxx index 8ebac3ee3..8186083f3 100644 --- a/src/debugger/gui/CartDebugWidget.hxx +++ b/src/debugger/gui/CartDebugWidget.hxx @@ -141,6 +141,14 @@ class CartDebugWidget : public Widget, public CommandSender private: StringListWidget* myDesc; ostringstream myBuffer; + + private: + // Following constructors and assignment operators not supported + CartDebugWidget() = delete; + CartDebugWidget(const CartDebugWidget&) = delete; + CartDebugWidget(CartDebugWidget&&) = delete; + CartDebugWidget& operator=(const CartDebugWidget&) = delete; + CartDebugWidget& operator=(CartDebugWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/CartE0Widget.hxx b/src/debugger/gui/CartE0Widget.hxx index 6cad64710..74d22e3a9 100644 --- a/src/debugger/gui/CartE0Widget.hxx +++ b/src/debugger/gui/CartE0Widget.hxx @@ -48,6 +48,14 @@ class CartridgeE0Widget : public CartDebugWidget kSlice1Changed = 's1CH', kSlice2Changed = 's2CH' }; + + private: + // Following constructors and assignment operators not supported + CartridgeE0Widget() = delete; + CartridgeE0Widget(const CartridgeE0Widget&) = delete; + CartridgeE0Widget(CartridgeE0Widget&&) = delete; + CartridgeE0Widget& operator=(const CartridgeE0Widget&) = delete; + CartridgeE0Widget& operator=(CartridgeE0Widget&&) = delete; }; #endif diff --git a/src/debugger/gui/CartE7Widget.hxx b/src/debugger/gui/CartE7Widget.hxx index 3fad13e48..728cc1175 100644 --- a/src/debugger/gui/CartE7Widget.hxx +++ b/src/debugger/gui/CartE7Widget.hxx @@ -63,6 +63,14 @@ class CartridgeE7Widget : public CartDebugWidget kLowerChanged = 'lwCH', kUpperChanged = 'upCH' }; + + private: + // Following constructors and assignment operators not supported + CartridgeE7Widget() = delete; + CartridgeE7Widget(const CartridgeE7Widget&) = delete; + CartridgeE7Widget(CartridgeE7Widget&&) = delete; + CartridgeE7Widget& operator=(const CartridgeE7Widget&) = delete; + CartridgeE7Widget& operator=(CartridgeE7Widget&&) = delete; }; #endif diff --git a/src/debugger/gui/CartEFSCWidget.hxx b/src/debugger/gui/CartEFSCWidget.hxx index 610433b7a..3ae95a7a9 100644 --- a/src/debugger/gui/CartEFSCWidget.hxx +++ b/src/debugger/gui/CartEFSCWidget.hxx @@ -61,6 +61,14 @@ class CartridgeEFSCWidget : public CartDebugWidget CartState myOldState; enum { kBankChanged = 'bkCH' }; + + private: + // Following constructors and assignment operators not supported + CartridgeEFSCWidget() = delete; + CartridgeEFSCWidget(const CartridgeEFSCWidget&) = delete; + CartridgeEFSCWidget(CartridgeEFSCWidget&&) = delete; + CartridgeEFSCWidget& operator=(const CartridgeEFSCWidget&) = delete; + CartridgeEFSCWidget& operator=(CartridgeEFSCWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/CartEFWidget.hxx b/src/debugger/gui/CartEFWidget.hxx index 333e04e47..19744c94b 100644 --- a/src/debugger/gui/CartEFWidget.hxx +++ b/src/debugger/gui/CartEFWidget.hxx @@ -44,6 +44,14 @@ class CartridgeEFWidget : public CartDebugWidget PopUpWidget* myBank; enum { kBankChanged = 'bkCH' }; + + private: + // Following constructors and assignment operators not supported + CartridgeEFWidget() = delete; + CartridgeEFWidget(const CartridgeEFWidget&) = delete; + CartridgeEFWidget(CartridgeEFWidget&&) = delete; + CartridgeEFWidget& operator=(const CartridgeEFWidget&) = delete; + CartridgeEFWidget& operator=(CartridgeEFWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/CartF0Widget.hxx b/src/debugger/gui/CartF0Widget.hxx index cfaddd531..521ab6db9 100644 --- a/src/debugger/gui/CartF0Widget.hxx +++ b/src/debugger/gui/CartF0Widget.hxx @@ -44,6 +44,14 @@ class CartridgeF0Widget : public CartDebugWidget PopUpWidget* myBank; enum { kBankChanged = 'bkCH' }; + + private: + // Following constructors and assignment operators not supported + CartridgeF0Widget() = delete; + CartridgeF0Widget(const CartridgeF0Widget&) = delete; + CartridgeF0Widget(CartridgeF0Widget&&) = delete; + CartridgeF0Widget& operator=(const CartridgeF0Widget&) = delete; + CartridgeF0Widget& operator=(CartridgeF0Widget&&) = delete; }; #endif diff --git a/src/debugger/gui/CartF4SCWidget.hxx b/src/debugger/gui/CartF4SCWidget.hxx index f9e24e6d4..c6758465a 100644 --- a/src/debugger/gui/CartF4SCWidget.hxx +++ b/src/debugger/gui/CartF4SCWidget.hxx @@ -62,6 +62,14 @@ class CartridgeF4SCWidget : public CartDebugWidget enum { kBankChanged = 'bkCH' }; + + private: + // Following constructors and assignment operators not supported + CartridgeF4SCWidget() = delete; + CartridgeF4SCWidget(const CartridgeF4SCWidget&) = delete; + CartridgeF4SCWidget(CartridgeF4SCWidget&&) = delete; + CartridgeF4SCWidget& operator=(const CartridgeF4SCWidget&) = delete; + CartridgeF4SCWidget& operator=(CartridgeF4SCWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/CartF4Widget.hxx b/src/debugger/gui/CartF4Widget.hxx index d198b121a..b3efb1482 100644 --- a/src/debugger/gui/CartF4Widget.hxx +++ b/src/debugger/gui/CartF4Widget.hxx @@ -44,6 +44,14 @@ class CartridgeF4Widget : public CartDebugWidget PopUpWidget* myBank; enum { kBankChanged = 'bkCH' }; + + private: + // Following constructors and assignment operators not supported + CartridgeF4Widget() = delete; + CartridgeF4Widget(const CartridgeF4Widget&) = delete; + CartridgeF4Widget(CartridgeF4Widget&&) = delete; + CartridgeF4Widget& operator=(const CartridgeF4Widget&) = delete; + CartridgeF4Widget& operator=(CartridgeF4Widget&&) = delete; }; #endif diff --git a/src/debugger/gui/CartF6SCWidget.hxx b/src/debugger/gui/CartF6SCWidget.hxx index cb8db4670..b3c03838e 100644 --- a/src/debugger/gui/CartF6SCWidget.hxx +++ b/src/debugger/gui/CartF6SCWidget.hxx @@ -58,7 +58,16 @@ class CartridgeF6SCWidget : public CartDebugWidget CartridgeF6SC& myCart; PopUpWidget* myBank; CartState myOldState; + enum { kBankChanged = 'bkCH' }; + + private: + // Following constructors and assignment operators not supported + CartridgeF6SCWidget() = delete; + CartridgeF6SCWidget(const CartridgeF6SCWidget&) = delete; + CartridgeF6SCWidget(CartridgeF6SCWidget&&) = delete; + CartridgeF6SCWidget& operator=(const CartridgeF6SCWidget&) = delete; + CartridgeF6SCWidget& operator=(CartridgeF6SCWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/CartF6Widget.hxx b/src/debugger/gui/CartF6Widget.hxx index 799d9e211..7b0b19fba 100644 --- a/src/debugger/gui/CartF6Widget.hxx +++ b/src/debugger/gui/CartF6Widget.hxx @@ -44,6 +44,14 @@ class CartridgeF6Widget : public CartDebugWidget PopUpWidget* myBank; enum { kBankChanged = 'bkCH' }; + + private: + // Following constructors and assignment operators not supported + CartridgeF6Widget() = delete; + CartridgeF6Widget(const CartridgeF6Widget&) = delete; + CartridgeF6Widget(CartridgeF6Widget&&) = delete; + CartridgeF6Widget& operator=(const CartridgeF6Widget&) = delete; + CartridgeF6Widget& operator=(CartridgeF6Widget&&) = delete; }; #endif diff --git a/src/debugger/gui/CartF8SCWidget.hxx b/src/debugger/gui/CartF8SCWidget.hxx index 5df6f8f05..33ad48f01 100644 --- a/src/debugger/gui/CartF8SCWidget.hxx +++ b/src/debugger/gui/CartF8SCWidget.hxx @@ -61,6 +61,14 @@ class CartridgeF8SCWidget : public CartDebugWidget CartState myOldState; enum { kBankChanged = 'bkCH' }; + + private: + // Following constructors and assignment operators not supported + CartridgeF8SCWidget() = delete; + CartridgeF8SCWidget(const CartridgeF8SCWidget&) = delete; + CartridgeF8SCWidget(CartridgeF8SCWidget&&) = delete; + CartridgeF8SCWidget& operator=(const CartridgeF8SCWidget&) = delete; + CartridgeF8SCWidget& operator=(CartridgeF8SCWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/CartF8Widget.hxx b/src/debugger/gui/CartF8Widget.hxx index 4560fc975..bc383b03e 100644 --- a/src/debugger/gui/CartF8Widget.hxx +++ b/src/debugger/gui/CartF8Widget.hxx @@ -44,6 +44,14 @@ class CartridgeF8Widget : public CartDebugWidget PopUpWidget* myBank; enum { kBankChanged = 'bkCH' }; + + private: + // Following constructors and assignment operators not supported + CartridgeF8Widget() = delete; + CartridgeF8Widget(const CartridgeF8Widget&) = delete; + CartridgeF8Widget(CartridgeF8Widget&&) = delete; + CartridgeF8Widget& operator=(const CartridgeF8Widget&) = delete; + CartridgeF8Widget& operator=(CartridgeF8Widget&&) = delete; }; #endif diff --git a/src/debugger/gui/CartFA2Widget.hxx b/src/debugger/gui/CartFA2Widget.hxx index 489e2d2a0..6acad3e4a 100644 --- a/src/debugger/gui/CartFA2Widget.hxx +++ b/src/debugger/gui/CartFA2Widget.hxx @@ -68,6 +68,14 @@ class CartridgeFA2Widget : public CartDebugWidget kFlashLoad = 'flLD', kFlashSave = 'flSV' }; + + private: + // Following constructors and assignment operators not supported + CartridgeFA2Widget() = delete; + CartridgeFA2Widget(const CartridgeFA2Widget&) = delete; + CartridgeFA2Widget(CartridgeFA2Widget&&) = delete; + CartridgeFA2Widget& operator=(const CartridgeFA2Widget&) = delete; + CartridgeFA2Widget& operator=(CartridgeFA2Widget&&) = delete; }; #endif diff --git a/src/debugger/gui/CartFAWidget.hxx b/src/debugger/gui/CartFAWidget.hxx index 675d1439b..d4c0de09b 100644 --- a/src/debugger/gui/CartFAWidget.hxx +++ b/src/debugger/gui/CartFAWidget.hxx @@ -61,6 +61,14 @@ class CartridgeFAWidget : public CartDebugWidget CartState myOldState; enum { kBankChanged = 'bkCH' }; + + private: + // Following constructors and assignment operators not supported + CartridgeFAWidget() = delete; + CartridgeFAWidget(const CartridgeFAWidget&) = delete; + CartridgeFAWidget(CartridgeFAWidget&&) = delete; + CartridgeFAWidget& operator=(const CartridgeFAWidget&) = delete; + CartridgeFAWidget& operator=(CartridgeFAWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/CartFEWidget.hxx b/src/debugger/gui/CartFEWidget.hxx index 24ad00683..90159f6c0 100644 --- a/src/debugger/gui/CartFEWidget.hxx +++ b/src/debugger/gui/CartFEWidget.hxx @@ -40,6 +40,14 @@ class CartridgeFEWidget : public CartDebugWidget private: CartridgeFE& myCart; + + private: + // Following constructors and assignment operators not supported + CartridgeFEWidget() = delete; + CartridgeFEWidget(const CartridgeFEWidget&) = delete; + CartridgeFEWidget(CartridgeFEWidget&&) = delete; + CartridgeFEWidget& operator=(const CartridgeFEWidget&) = delete; + CartridgeFEWidget& operator=(CartridgeFEWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/CartMCWidget.hxx b/src/debugger/gui/CartMCWidget.hxx index 92e5097a6..b9f977c06 100644 --- a/src/debugger/gui/CartMCWidget.hxx +++ b/src/debugger/gui/CartMCWidget.hxx @@ -49,6 +49,14 @@ class CartridgeMCWidget : public CartDebugWidget kSlice2Changed = 's2CH', kSlice3Changed = 's3CH' }; + + private: + // Following constructors and assignment operators not supported + CartridgeMCWidget() = delete; + CartridgeMCWidget(const CartridgeMCWidget&) = delete; + CartridgeMCWidget(CartridgeMCWidget&&) = delete; + CartridgeMCWidget& operator=(const CartridgeMCWidget&) = delete; + CartridgeMCWidget& operator=(CartridgeMCWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/CartMDMWidget.hxx b/src/debugger/gui/CartMDMWidget.hxx index a4b5286b3..88db1144a 100644 --- a/src/debugger/gui/CartMDMWidget.hxx +++ b/src/debugger/gui/CartMDMWidget.hxx @@ -46,6 +46,14 @@ class CartridgeMDMWidget : public CartDebugWidget CheckboxWidget* myBankDisabled; enum { kBankChanged = 'bkCH', kBankDisabled = 'bkDI' }; + + private: + // Following constructors and assignment operators not supported + CartridgeMDMWidget() = delete; + CartridgeMDMWidget(const CartridgeMDMWidget&) = delete; + CartridgeMDMWidget(CartridgeMDMWidget&&) = delete; + CartridgeMDMWidget& operator=(const CartridgeMDMWidget&) = delete; + CartridgeMDMWidget& operator=(CartridgeMDMWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/CartRamWidget.hxx b/src/debugger/gui/CartRamWidget.hxx index cc7c5c47d..de4585324 100644 --- a/src/debugger/gui/CartRamWidget.hxx +++ b/src/debugger/gui/CartRamWidget.hxx @@ -106,6 +106,14 @@ class CartRamWidget : public Widget, public CommandSender IntArray mySearchAddr; IntArray mySearchValue; BoolArray mySearchState; + + private: + // Following constructors and assignment operators not supported + CartRamWidget() = delete; + CartRamWidget(const CartRamWidget&) = delete; + CartRamWidget(CartRamWidget&&) = delete; + CartRamWidget& operator=(const CartRamWidget&) = delete; + CartRamWidget& operator=(CartRamWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/CartSBWidget.hxx b/src/debugger/gui/CartSBWidget.hxx index cb265ad65..9982a9980 100644 --- a/src/debugger/gui/CartSBWidget.hxx +++ b/src/debugger/gui/CartSBWidget.hxx @@ -44,6 +44,14 @@ class CartridgeSBWidget : public CartDebugWidget PopUpWidget* myBank; enum { kBankChanged = 'bkCH' }; + + private: + // Following constructors and assignment operators not supported + CartridgeSBWidget() = delete; + CartridgeSBWidget(const CartridgeSBWidget&) = delete; + CartridgeSBWidget(CartridgeSBWidget&&) = delete; + CartridgeSBWidget& operator=(const CartridgeSBWidget&) = delete; + CartridgeSBWidget& operator=(CartridgeSBWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/CartUAWidget.hxx b/src/debugger/gui/CartUAWidget.hxx index 473a34459..7b00d9f97 100644 --- a/src/debugger/gui/CartUAWidget.hxx +++ b/src/debugger/gui/CartUAWidget.hxx @@ -44,6 +44,14 @@ class CartridgeUAWidget : public CartDebugWidget PopUpWidget* myBank; enum { kBankChanged = 'bkCH' }; + + private: + // Following constructors and assignment operators not supported + CartridgeUAWidget() = delete; + CartridgeUAWidget(const CartridgeUAWidget&) = delete; + CartridgeUAWidget(CartridgeUAWidget&&) = delete; + CartridgeUAWidget& operator=(const CartridgeUAWidget&) = delete; + CartridgeUAWidget& operator=(CartridgeUAWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/CartWDWidget.hxx b/src/debugger/gui/CartWDWidget.hxx index 984d6bc1d..8c0aeaf49 100644 --- a/src/debugger/gui/CartWDWidget.hxx +++ b/src/debugger/gui/CartWDWidget.hxx @@ -61,6 +61,14 @@ class CartridgeWDWidget : public CartDebugWidget CartState myOldState; enum { kBankChanged = 'bkCH' }; + + private: + // Following constructors and assignment operators not supported + CartridgeWDWidget() = delete; + CartridgeWDWidget(const CartridgeWDWidget&) = delete; + CartridgeWDWidget(CartridgeWDWidget&&) = delete; + CartridgeWDWidget& operator=(const CartridgeWDWidget&) = delete; + CartridgeWDWidget& operator=(CartridgeWDWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/CartX07Widget.hxx b/src/debugger/gui/CartX07Widget.hxx index 09fd2c717..321b159ac 100644 --- a/src/debugger/gui/CartX07Widget.hxx +++ b/src/debugger/gui/CartX07Widget.hxx @@ -44,6 +44,14 @@ class CartridgeX07Widget : public CartDebugWidget PopUpWidget* myBank; enum { kBankChanged = 'bkCH' }; + + private: + // Following constructors and assignment operators not supported + CartridgeX07Widget() = delete; + CartridgeX07Widget(const CartridgeX07Widget&) = delete; + CartridgeX07Widget(CartridgeX07Widget&&) = delete; + CartridgeX07Widget& operator=(const CartridgeX07Widget&) = delete; + CartridgeX07Widget& operator=(CartridgeX07Widget&&) = delete; }; #endif diff --git a/src/debugger/gui/ColorWidget.hxx b/src/debugger/gui/ColorWidget.hxx index de1d217e5..ac301096f 100644 --- a/src/debugger/gui/ColorWidget.hxx +++ b/src/debugger/gui/ColorWidget.hxx @@ -51,6 +51,14 @@ class ColorWidget : public Widget, public CommandSender protected: int _color; int _cmd; + + private: + // Following constructors and assignment operators not supported + ColorWidget() = delete; + ColorWidget(const ColorWidget&) = delete; + ColorWidget(ColorWidget&&) = delete; + ColorWidget& operator=(const ColorWidget&) = delete; + ColorWidget& operator=(ColorWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/ControllerWidget.hxx b/src/debugger/gui/ControllerWidget.hxx index 420f9f8b3..c41ddf753 100644 --- a/src/debugger/gui/ControllerWidget.hxx +++ b/src/debugger/gui/ControllerWidget.hxx @@ -46,6 +46,14 @@ class ControllerWidget : public Widget, public CommandSender protected: Controller& myController; + + private: + // Following constructors and assignment operators not supported + ControllerWidget() = delete; + ControllerWidget(const ControllerWidget&) = delete; + ControllerWidget(ControllerWidget&&) = delete; + ControllerWidget& operator=(const ControllerWidget&) = delete; + ControllerWidget& operator=(ControllerWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/CpuWidget.hxx b/src/debugger/gui/CpuWidget.hxx index f98d963b7..4763d1941 100644 --- a/src/debugger/gui/CpuWidget.hxx +++ b/src/debugger/gui/CpuWidget.hxx @@ -76,6 +76,14 @@ class CpuWidget : public Widget, public CommandSender EditTextWidget* myCpuDataSrc[4]; ToggleBitWidget* myPSRegister; EditTextWidget* myPCLabel; + + private: + // Following constructors and assignment operators not supported + CpuWidget() = delete; + CpuWidget(const CpuWidget&) = delete; + CpuWidget(CpuWidget&&) = delete; + CpuWidget& operator=(const CpuWidget&) = delete; + CpuWidget& operator=(CpuWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/DataGridOpsWidget.hxx b/src/debugger/gui/DataGridOpsWidget.hxx index 42a19f520..6d27aef84 100644 --- a/src/debugger/gui/DataGridOpsWidget.hxx +++ b/src/debugger/gui/DataGridOpsWidget.hxx @@ -51,6 +51,14 @@ class DataGridOpsWidget : public Widget, public CommandSender ButtonWidget* _decButton; ButtonWidget* _shiftLeftButton; ButtonWidget* _shiftRightButton; + + private: + // Following constructors and assignment operators not supported + DataGridOpsWidget() = delete; + DataGridOpsWidget(const DataGridOpsWidget&) = delete; + DataGridOpsWidget(DataGridOpsWidget&&) = delete; + DataGridOpsWidget& operator=(const DataGridOpsWidget&) = delete; + DataGridOpsWidget& operator=(DataGridOpsWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/DataGridWidget.hxx b/src/debugger/gui/DataGridWidget.hxx index 20424dbb2..8190e9e13 100644 --- a/src/debugger/gui/DataGridWidget.hxx +++ b/src/debugger/gui/DataGridWidget.hxx @@ -140,6 +140,14 @@ class DataGridWidget : public EditableWidget void zeroCell(); void enableEditMode(bool state) { _editMode = state; } + + private: + // Following constructors and assignment operators not supported + DataGridWidget() = delete; + DataGridWidget(const DataGridWidget&) = delete; + DataGridWidget(DataGridWidget&&) = delete; + DataGridWidget& operator=(const DataGridWidget&) = delete; + DataGridWidget& operator=(DataGridWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/DebuggerDialog.hxx b/src/debugger/gui/DebuggerDialog.hxx index a435abf3a..8eb3be1c6 100644 --- a/src/debugger/gui/DebuggerDialog.hxx +++ b/src/debugger/gui/DebuggerDialog.hxx @@ -119,6 +119,14 @@ class DebuggerDialog : public Dialog unique_ptr myLFont; // used for labels unique_ptr myNFont; // used for normal text + + private: + // Following constructors and assignment operators not supported + DebuggerDialog() = delete; + DebuggerDialog(const DebuggerDialog&) = delete; + DebuggerDialog(DebuggerDialog&&) = delete; + DebuggerDialog& operator=(const DebuggerDialog&) = delete; + DebuggerDialog& operator=(DebuggerDialog&&) = delete; }; #endif diff --git a/src/debugger/gui/DrivingWidget.hxx b/src/debugger/gui/DrivingWidget.hxx index a6fa5cc6b..4b71b1aaa 100644 --- a/src/debugger/gui/DrivingWidget.hxx +++ b/src/debugger/gui/DrivingWidget.hxx @@ -51,6 +51,14 @@ class DrivingWidget : public ControllerWidget int myGreyIndex; static uInt8 ourGreyTable[4]; + + private: + // Following constructors and assignment operators not supported + DrivingWidget() = delete; + DrivingWidget(const DrivingWidget&) = delete; + DrivingWidget(DrivingWidget&&) = delete; + DrivingWidget& operator=(const DrivingWidget&) = delete; + DrivingWidget& operator=(DrivingWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/GenesisWidget.hxx b/src/debugger/gui/GenesisWidget.hxx index b57d26fc6..3fd04aaff 100644 --- a/src/debugger/gui/GenesisWidget.hxx +++ b/src/debugger/gui/GenesisWidget.hxx @@ -39,6 +39,14 @@ class GenesisWidget : public ControllerWidget CheckboxWidget* myPins[6]; static Controller::DigitalPin ourPinNo[5]; + + private: + // Following constructors and assignment operators not supported + GenesisWidget() = delete; + GenesisWidget(const GenesisWidget&) = delete; + GenesisWidget(GenesisWidget&&) = delete; + GenesisWidget& operator=(const GenesisWidget&) = delete; + GenesisWidget& operator=(GenesisWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/JoystickWidget.hxx b/src/debugger/gui/JoystickWidget.hxx index f33b6b068..ae6f41ba1 100644 --- a/src/debugger/gui/JoystickWidget.hxx +++ b/src/debugger/gui/JoystickWidget.hxx @@ -39,6 +39,14 @@ class JoystickWidget : public ControllerWidget CheckboxWidget* myPins[5]; static Controller::DigitalPin ourPinNo[5]; + + private: + // Following constructors and assignment operators not supported + JoystickWidget() = delete; + JoystickWidget(const JoystickWidget&) = delete; + JoystickWidget(JoystickWidget&&) = delete; + JoystickWidget& operator=(const JoystickWidget&) = delete; + JoystickWidget& operator=(JoystickWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/KeyboardWidget.hxx b/src/debugger/gui/KeyboardWidget.hxx index 6a10798ba..2bace4eff 100644 --- a/src/debugger/gui/KeyboardWidget.hxx +++ b/src/debugger/gui/KeyboardWidget.hxx @@ -39,6 +39,14 @@ class KeyboardWidget : public ControllerWidget Event::Type* myEvent; static Event::Type ourLeftEvents[12], ourRightEvents[12]; + + private: + // Following constructors and assignment operators not supported + KeyboardWidget() = delete; + KeyboardWidget(const KeyboardWidget&) = delete; + KeyboardWidget(KeyboardWidget&&) = delete; + KeyboardWidget& operator=(const KeyboardWidget&) = delete; + KeyboardWidget& operator=(KeyboardWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/NullControlWidget.hxx b/src/debugger/gui/NullControlWidget.hxx index 3b0963bb5..5f01939bc 100644 --- a/src/debugger/gui/NullControlWidget.hxx +++ b/src/debugger/gui/NullControlWidget.hxx @@ -49,6 +49,14 @@ class NullControlWidget : public ControllerWidget } virtual ~NullControlWidget() { }; + + private: + // Following constructors and assignment operators not supported + NullControlWidget() = delete; + NullControlWidget(const NullControlWidget&) = delete; + NullControlWidget(NullControlWidget&&) = delete; + NullControlWidget& operator=(const NullControlWidget&) = delete; + NullControlWidget& operator=(NullControlWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/PaddleWidget.hxx b/src/debugger/gui/PaddleWidget.hxx index e832c7e8b..7ca06eb3c 100644 --- a/src/debugger/gui/PaddleWidget.hxx +++ b/src/debugger/gui/PaddleWidget.hxx @@ -40,6 +40,14 @@ class PaddleWidget : public ControllerWidget SliderWidget *myP0Resistance, *myP1Resistance; CheckboxWidget *myP0Fire, *myP1Fire; + + private: + // Following constructors and assignment operators not supported + PaddleWidget() = delete; + PaddleWidget(const PaddleWidget&) = delete; + PaddleWidget(PaddleWidget&&) = delete; + PaddleWidget& operator=(const PaddleWidget&) = delete; + PaddleWidget& operator=(PaddleWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/PromptWidget.hxx b/src/debugger/gui/PromptWidget.hxx index e94c5dd3a..294946678 100644 --- a/src/debugger/gui/PromptWidget.hxx +++ b/src/debugger/gui/PromptWidget.hxx @@ -118,6 +118,14 @@ class PromptWidget : public Widget, public CommandSender bool _exitedEarly; // int compareHistory(const char *histLine); + + private: + // Following constructors and assignment operators not supported + PromptWidget() = delete; + PromptWidget(const PromptWidget&) = delete; + PromptWidget(PromptWidget&&) = delete; + PromptWidget& operator=(const PromptWidget&) = delete; + PromptWidget& operator=(PromptWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/RamWidget.hxx b/src/debugger/gui/RamWidget.hxx index 6de41c8d6..b8d27b9ee 100644 --- a/src/debugger/gui/RamWidget.hxx +++ b/src/debugger/gui/RamWidget.hxx @@ -86,6 +86,14 @@ class RamWidget : public Widget, public CommandSender IntArray mySearchAddr; IntArray mySearchValue; BoolArray mySearchState; + + private: + // Following constructors and assignment operators not supported + RamWidget() = delete; + RamWidget(const RamWidget&) = delete; + RamWidget(RamWidget&&) = delete; + RamWidget& operator=(const RamWidget&) = delete; + RamWidget& operator=(RamWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/RiotWidget.hxx b/src/debugger/gui/RiotWidget.hxx index d68eadc26..a16821c69 100644 --- a/src/debugger/gui/RiotWidget.hxx +++ b/src/debugger/gui/RiotWidget.hxx @@ -79,6 +79,14 @@ class RiotWidget : public Widget, public CommandSender kP0DiffChanged, kP1DiffChanged, kTVTypeChanged, kSelectID, kResetID, kRandCPUID, kRandRAMID }; + + private: + // Following constructors and assignment operators not supported + RiotWidget() = delete; + RiotWidget(const RiotWidget&) = delete; + RiotWidget(RiotWidget&&) = delete; + RiotWidget& operator=(const RiotWidget&) = delete; + RiotWidget& operator=(RiotWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/RomListSettings.hxx b/src/debugger/gui/RomListSettings.hxx index fd29d696d..5dc865c40 100644 --- a/src/debugger/gui/RomListSettings.hxx +++ b/src/debugger/gui/RomListSettings.hxx @@ -56,6 +56,14 @@ class RomListSettings : public Dialog, public CommandSender CheckboxWidget* myShowAddresses; CheckboxWidget* myShowGFXBinary; CheckboxWidget* myUseRelocation; + + private: + // Following constructors and assignment operators not supported + RomListSettings() = delete; + RomListSettings(const RomListSettings&) = delete; + RomListSettings(RomListSettings&&) = delete; + RomListSettings& operator=(const RomListSettings&) = delete; + RomListSettings& operator=(RomListSettings&&) = delete; }; #endif diff --git a/src/debugger/gui/RomListWidget.hxx b/src/debugger/gui/RomListWidget.hxx index feb3144d1..4a84f0b92 100644 --- a/src/debugger/gui/RomListWidget.hxx +++ b/src/debugger/gui/RomListWidget.hxx @@ -104,6 +104,14 @@ class RomListWidget : public EditableWidget const CartDebug::Disassembly* myDisasm; const PackedBitArray* myBPState; vector myCheckList; + + private: + // Following constructors and assignment operators not supported + RomListWidget() = delete; + RomListWidget(const RomListWidget&) = delete; + RomListWidget(RomListWidget&&) = delete; + RomListWidget& operator=(const RomListWidget&) = delete; + RomListWidget& operator=(RomListWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/RomWidget.hxx b/src/debugger/gui/RomWidget.hxx index 88932329b..3250aad7e 100644 --- a/src/debugger/gui/RomWidget.hxx +++ b/src/debugger/gui/RomWidget.hxx @@ -59,6 +59,14 @@ class RomWidget : public Widget, public CommandSender EditTextWidget* myBank; bool myListIsDirty; + + private: + // Following constructors and assignment operators not supported + RomWidget() = delete; + RomWidget(const RomWidget&) = delete; + RomWidget(RomWidget&&) = delete; + RomWidget& operator=(const RomWidget&) = delete; + RomWidget& operator=(RomWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/SaveKeyWidget.hxx b/src/debugger/gui/SaveKeyWidget.hxx index d8ba09f4f..c09feb322 100644 --- a/src/debugger/gui/SaveKeyWidget.hxx +++ b/src/debugger/gui/SaveKeyWidget.hxx @@ -38,6 +38,14 @@ class SaveKeyWidget : public ControllerWidget private: ButtonWidget* myEEPROMErase; enum { kEEPROMErase = 'eeER' }; + + private: + // Following constructors and assignment operators not supported + SaveKeyWidget() = delete; + SaveKeyWidget(const SaveKeyWidget&) = delete; + SaveKeyWidget(SaveKeyWidget&&) = delete; + SaveKeyWidget& operator=(const SaveKeyWidget&) = delete; + SaveKeyWidget& operator=(SaveKeyWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/TiaInfoWidget.hxx b/src/debugger/gui/TiaInfoWidget.hxx index 4ee48f9f6..db2cc2255 100644 --- a/src/debugger/gui/TiaInfoWidget.hxx +++ b/src/debugger/gui/TiaInfoWidget.hxx @@ -51,6 +51,14 @@ class TiaInfoWidget : public Widget, public CommandSender CheckboxWidget* myVSync; CheckboxWidget* myVBlank; + + private: + // Following constructors and assignment operators not supported + TiaInfoWidget() = delete; + TiaInfoWidget(const TiaInfoWidget&) = delete; + TiaInfoWidget(TiaInfoWidget&&) = delete; + TiaInfoWidget& operator=(const TiaInfoWidget&) = delete; + TiaInfoWidget& operator=(TiaInfoWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/TiaOutputWidget.hxx b/src/debugger/gui/TiaOutputWidget.hxx index f0580d2ce..0e23a9e86 100644 --- a/src/debugger/gui/TiaOutputWidget.hxx +++ b/src/debugger/gui/TiaOutputWidget.hxx @@ -67,6 +67,14 @@ class TiaOutputWidget : public Widget, public CommandSender // Create this buffer once, instead of allocating it each time the // TIA image is redrawn uInt32 myLineBuffer[320]; + + private: + // Following constructors and assignment operators not supported + TiaOutputWidget() = delete; + TiaOutputWidget(const TiaOutputWidget&) = delete; + TiaOutputWidget(TiaOutputWidget&&) = delete; + TiaOutputWidget& operator=(const TiaOutputWidget&) = delete; + TiaOutputWidget& operator=(TiaOutputWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/TiaWidget.hxx b/src/debugger/gui/TiaWidget.hxx index 6a19e01de..a7e0ff9f1 100644 --- a/src/debugger/gui/TiaWidget.hxx +++ b/src/debugger/gui/TiaWidget.hxx @@ -147,6 +147,14 @@ class TiaWidget : public Widget, public CommandSender kCOLUPFAddr, kCOLUBKAddr }; + + private: + // Following constructors and assignment operators not supported + TiaWidget() = delete; + TiaWidget(const TiaWidget&) = delete; + TiaWidget(TiaWidget&&) = delete; + TiaWidget& operator=(const TiaWidget&) = delete; + TiaWidget& operator=(TiaWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/TiaZoomWidget.hxx b/src/debugger/gui/TiaZoomWidget.hxx index 5f3b71524..15f1ffa42 100644 --- a/src/debugger/gui/TiaZoomWidget.hxx +++ b/src/debugger/gui/TiaZoomWidget.hxx @@ -62,6 +62,14 @@ class TiaZoomWidget : public Widget, public CommandSender bool myMouseMoving; int myXClick, myYClick; + + private: + // Following constructors and assignment operators not supported + TiaZoomWidget() = delete; + TiaZoomWidget(const TiaZoomWidget&) = delete; + TiaZoomWidget(TiaZoomWidget&&) = delete; + TiaZoomWidget& operator=(const TiaZoomWidget&) = delete; + TiaZoomWidget& operator=(TiaZoomWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/ToggleBitWidget.hxx b/src/debugger/gui/ToggleBitWidget.hxx index a7a2dd489..887da8cdb 100644 --- a/src/debugger/gui/ToggleBitWidget.hxx +++ b/src/debugger/gui/ToggleBitWidget.hxx @@ -39,6 +39,14 @@ class ToggleBitWidget : public ToggleWidget protected: StringList _offList; StringList _onList; + + private: + // Following constructors and assignment operators not supported + ToggleBitWidget() = delete; + ToggleBitWidget(const ToggleBitWidget&) = delete; + ToggleBitWidget(ToggleBitWidget&&) = delete; + ToggleBitWidget& operator=(const ToggleBitWidget&) = delete; + ToggleBitWidget& operator=(ToggleBitWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/TogglePixelWidget.hxx b/src/debugger/gui/TogglePixelWidget.hxx index 6997ec36e..1b77d01f2 100644 --- a/src/debugger/gui/TogglePixelWidget.hxx +++ b/src/debugger/gui/TogglePixelWidget.hxx @@ -47,6 +47,14 @@ class TogglePixelWidget : public ToggleWidget private: int _pixelColor, _backgroundColor; bool _swapBits; + + private: + // Following constructors and assignment operators not supported + TogglePixelWidget() = delete; + TogglePixelWidget(const TogglePixelWidget&) = delete; + TogglePixelWidget(TogglePixelWidget&&) = delete; + TogglePixelWidget& operator=(const TogglePixelWidget&) = delete; + TogglePixelWidget& operator=(TogglePixelWidget&&) = delete; }; #endif diff --git a/src/debugger/gui/ToggleWidget.hxx b/src/debugger/gui/ToggleWidget.hxx index 40206d90d..45ae87106 100644 --- a/src/debugger/gui/ToggleWidget.hxx +++ b/src/debugger/gui/ToggleWidget.hxx @@ -67,6 +67,14 @@ class ToggleWidget : public Widget, public CommandSender BoolArray _stateList; BoolArray _changedList; + + private: + // Following constructors and assignment operators not supported + ToggleWidget() = delete; + ToggleWidget(const ToggleWidget&) = delete; + ToggleWidget(ToggleWidget&&) = delete; + ToggleWidget& operator=(const ToggleWidget&) = delete; + ToggleWidget& operator=(ToggleWidget&&) = delete; }; #endif diff --git a/src/emucore/AtariVox.hxx b/src/emucore/AtariVox.hxx index e7ef2768b..99478f7a8 100644 --- a/src/emucore/AtariVox.hxx +++ b/src/emucore/AtariVox.hxx @@ -125,6 +125,14 @@ class AtariVox : public Controller // Holds information concerning serial port usage string myAboutString; + + private: + // Following constructors and assignment operators not supported + AtariVox() = delete; + AtariVox(const AtariVox&) = delete; + AtariVox(AtariVox&&) = delete; + AtariVox& operator=(const AtariVox&) = delete; + AtariVox& operator=(AtariVox&&) = delete; }; #endif diff --git a/src/emucore/Booster.hxx b/src/emucore/Booster.hxx index 8863fd6c7..62098bc91 100644 --- a/src/emucore/Booster.hxx +++ b/src/emucore/Booster.hxx @@ -83,6 +83,14 @@ class BoosterGrip : public Controller // Controller to emulate in normal mouse axis mode int myControlID; + + private: + // Following constructors and assignment operators not supported + BoosterGrip() = delete; + BoosterGrip(const BoosterGrip&) = delete; + BoosterGrip(BoosterGrip&&) = delete; + BoosterGrip& operator=(const BoosterGrip&) = delete; + BoosterGrip& operator=(BoosterGrip&&) = delete; }; #endif diff --git a/src/emucore/Cart.cxx b/src/emucore/Cart.cxx index f97745eab..63f596e69 100644 --- a/src/emucore/Cart.cxx +++ b/src/emucore/Cart.cxx @@ -286,7 +286,7 @@ string Cartridge::createFromMultiCart(const uInt8*& image, uInt32& size, image += i*size; // We need a new md5 and name - md5 = MD5(image, size); + md5 = MD5::hash(image, size); ostringstream buf; buf << " [G" << (i+1) << "]"; id = buf.str(); diff --git a/src/emucore/Cart.hxx b/src/emucore/Cart.hxx index bda5f4af6..0495fc3ff 100644 --- a/src/emucore/Cart.hxx +++ b/src/emucore/Cart.hxx @@ -413,9 +413,12 @@ class Cartridge : public Device // Contains info about this cartridge in string format static string myAboutString; - // Copy constructor and assignment operator not supported - Cartridge(const Cartridge&); - Cartridge& operator = (const Cartridge&); + // Following constructors and assignment operators not supported + Cartridge() = delete; + Cartridge(const Cartridge&) = delete; + Cartridge(Cartridge&&) = delete; + Cartridge& operator=(const Cartridge&) = delete; + Cartridge& operator=(Cartridge&&) = delete; }; #endif diff --git a/src/emucore/Cart0840.hxx b/src/emucore/Cart0840.hxx index d1b5cd998..19c685d43 100644 --- a/src/emucore/Cart0840.hxx +++ b/src/emucore/Cart0840.hxx @@ -161,6 +161,14 @@ class Cartridge0840 : public Cartridge // Previous Device's page access System::PageAccess myHotSpotPageAccess[8]; + + private: + // Following constructors and assignment operators not supported + Cartridge0840() = delete; + Cartridge0840(const Cartridge0840&) = delete; + Cartridge0840(Cartridge0840&&) = delete; + Cartridge0840& operator=(const Cartridge0840&) = delete; + Cartridge0840& operator=(Cartridge0840&&) = delete; }; #endif diff --git a/src/emucore/Cart2K.hxx b/src/emucore/Cart2K.hxx index d0e88a34e..a425cddeb 100644 --- a/src/emucore/Cart2K.hxx +++ b/src/emucore/Cart2K.hxx @@ -147,6 +147,14 @@ class Cartridge2K : public Cartridge // Mask to use for mirroring uInt32 myMask; + + private: + // Following constructors and assignment operators not supported + Cartridge2K() = delete; + Cartridge2K(const Cartridge2K&) = delete; + Cartridge2K(Cartridge2K&&) = delete; + Cartridge2K& operator=(const Cartridge2K&) = delete; + Cartridge2K& operator=(Cartridge2K&&) = delete; }; #endif diff --git a/src/emucore/Cart3E.hxx b/src/emucore/Cart3E.hxx index 8eca99a6e..c57c01a45 100644 --- a/src/emucore/Cart3E.hxx +++ b/src/emucore/Cart3E.hxx @@ -195,6 +195,14 @@ class Cartridge3E : public Cartridge // Size of the ROM image uInt32 mySize; + + private: + // Following constructors and assignment operators not supported + Cartridge3E() = delete; + Cartridge3E(const Cartridge3E&) = delete; + Cartridge3E(Cartridge3E&&) = delete; + Cartridge3E& operator=(const Cartridge3E&) = delete; + Cartridge3E& operator=(Cartridge3E&&) = delete; }; #endif diff --git a/src/emucore/Cart3F.hxx b/src/emucore/Cart3F.hxx index bd66321df..98a7085b3 100644 --- a/src/emucore/Cart3F.hxx +++ b/src/emucore/Cart3F.hxx @@ -169,6 +169,14 @@ class Cartridge3F : public Cartridge // Size of the ROM image uInt32 mySize; + + private: + // Following constructors and assignment operators not supported + Cartridge3F() = delete; + Cartridge3F(const Cartridge3F&) = delete; + Cartridge3F(Cartridge3F&&) = delete; + Cartridge3F& operator=(const Cartridge3F&) = delete; + Cartridge3F& operator=(Cartridge3F&&) = delete; }; #endif diff --git a/src/emucore/Cart4A50.hxx b/src/emucore/Cart4A50.hxx index f097c3e93..b3aa47eee 100644 --- a/src/emucore/Cart4A50.hxx +++ b/src/emucore/Cart4A50.hxx @@ -234,6 +234,14 @@ class Cartridge4A50 : public Cartridge // The previous address and data values (from peek and poke) uInt16 myLastAddress; uInt8 myLastData; + + private: + // Following constructors and assignment operators not supported + Cartridge4A50() = delete; + Cartridge4A50(const Cartridge4A50&) = delete; + Cartridge4A50(Cartridge4A50&&) = delete; + Cartridge4A50& operator=(const Cartridge4A50&) = delete; + Cartridge4A50& operator=(Cartridge4A50&&) = delete; }; #endif diff --git a/src/emucore/Cart4K.hxx b/src/emucore/Cart4K.hxx index a17f4493e..534744d96 100644 --- a/src/emucore/Cart4K.hxx +++ b/src/emucore/Cart4K.hxx @@ -140,6 +140,14 @@ class Cartridge4K : public Cartridge private: // The 4K ROM image for the cartridge uInt8 myImage[4096]; + + private: + // Following constructors and assignment operators not supported + Cartridge4K() = delete; + Cartridge4K(const Cartridge4K&) = delete; + Cartridge4K(Cartridge4K&&) = delete; + Cartridge4K& operator=(const Cartridge4K&) = delete; + Cartridge4K& operator=(Cartridge4K&&) = delete; }; #endif diff --git a/src/emucore/Cart4KSC.hxx b/src/emucore/Cart4KSC.hxx index d80c1a557..3ab54becc 100644 --- a/src/emucore/Cart4KSC.hxx +++ b/src/emucore/Cart4KSC.hxx @@ -144,6 +144,14 @@ class Cartridge4KSC : public Cartridge // The 128 bytes of RAM uInt8 myRAM[128]; + + private: + // Following constructors and assignment operators not supported + Cartridge4KSC() = delete; + Cartridge4KSC(const Cartridge4KSC&) = delete; + Cartridge4KSC(Cartridge4KSC&&) = delete; + Cartridge4KSC& operator=(const Cartridge4KSC&) = delete; + Cartridge4KSC& operator=(Cartridge4KSC&&) = delete; }; #endif diff --git a/src/emucore/CartAR.hxx b/src/emucore/CartAR.hxx index 97e00c63c..bbf6d1cb1 100644 --- a/src/emucore/CartAR.hxx +++ b/src/emucore/CartAR.hxx @@ -233,6 +233,14 @@ class CartridgeAR : public Cartridge // Default 256-byte header to use if one isn't included in the ROM // This data comes from z26 static const uInt8 ourDefaultHeader[256]; + + private: + // Following constructors and assignment operators not supported + CartridgeAR() = delete; + CartridgeAR(const CartridgeAR&) = delete; + CartridgeAR(CartridgeAR&&) = delete; + CartridgeAR& operator=(const CartridgeAR&) = delete; + CartridgeAR& operator=(CartridgeAR&&) = delete; }; #endif diff --git a/src/emucore/CartBF.hxx b/src/emucore/CartBF.hxx index 9fbb9f3c7..6d3595b47 100644 --- a/src/emucore/CartBF.hxx +++ b/src/emucore/CartBF.hxx @@ -161,6 +161,14 @@ class CartridgeBF : public Cartridge // The 256K ROM image of the cartridge uInt8 myImage[64 * 4096]; + + private: + // Following constructors and assignment operators not supported + CartridgeBF() = delete; + CartridgeBF(const CartridgeBF&) = delete; + CartridgeBF(CartridgeBF&&) = delete; + CartridgeBF& operator=(const CartridgeBF&) = delete; + CartridgeBF& operator=(CartridgeBF&&) = delete; }; #endif diff --git a/src/emucore/CartBFSC.hxx b/src/emucore/CartBFSC.hxx index d305cba51..cdb2c6ac3 100644 --- a/src/emucore/CartBFSC.hxx +++ b/src/emucore/CartBFSC.hxx @@ -163,6 +163,14 @@ class CartridgeBFSC : public Cartridge // The 128 bytes of RAM uInt8 myRAM[128]; + + private: + // Following constructors and assignment operators not supported + CartridgeBFSC() = delete; + CartridgeBFSC(const CartridgeBFSC&) = delete; + CartridgeBFSC(CartridgeBFSC&&) = delete; + CartridgeBFSC& operator=(const CartridgeBFSC&) = delete; + CartridgeBFSC& operator=(CartridgeBFSC&&) = delete; }; #endif diff --git a/src/emucore/CartCM.hxx b/src/emucore/CartCM.hxx index a61bc01af..a9c93781a 100644 --- a/src/emucore/CartCM.hxx +++ b/src/emucore/CartCM.hxx @@ -253,6 +253,14 @@ class CartridgeCM : public Cartridge // Current copy of SWCHA (controls ROM/RAM accesses) uInt8 mySWCHA; + + private: + // Following constructors and assignment operators not supported + CartridgeCM() = delete; + CartridgeCM(const CartridgeCM&) = delete; + CartridgeCM(CartridgeCM&&) = delete; + CartridgeCM& operator=(const CartridgeCM&) = delete; + CartridgeCM& operator=(CartridgeCM&&) = delete; }; #endif diff --git a/src/emucore/CartCTY.hxx b/src/emucore/CartCTY.hxx index 60740d51e..07145e153 100644 --- a/src/emucore/CartCTY.hxx +++ b/src/emucore/CartCTY.hxx @@ -312,6 +312,14 @@ class CartridgeCTY : public Cartridge // Fractional DPC music OSC clocks unused during the last update double myFractionalClocks; + + private: + // Following constructors and assignment operators not supported + CartridgeCTY() = delete; + CartridgeCTY(const CartridgeCTY&) = delete; + CartridgeCTY(CartridgeCTY&&) = delete; + CartridgeCTY& operator=(const CartridgeCTY&) = delete; + CartridgeCTY& operator=(CartridgeCTY&&) = delete; }; #endif diff --git a/src/emucore/CartCV.hxx b/src/emucore/CartCV.hxx index 112b12a5d..12a24e505 100644 --- a/src/emucore/CartCV.hxx +++ b/src/emucore/CartCV.hxx @@ -153,6 +153,14 @@ class CartridgeCV : public Cartridge // The 1024 bytes of RAM uInt8 myRAM[1024]; + + private: + // Following constructors and assignment operators not supported + CartridgeCV() = delete; + CartridgeCV(const CartridgeCV&) = delete; + CartridgeCV(CartridgeCV&&) = delete; + CartridgeCV& operator=(const CartridgeCV&) = delete; + CartridgeCV& operator=(CartridgeCV&&) = delete; }; #endif diff --git a/src/emucore/CartDASH.hxx b/src/emucore/CartDASH.hxx index 8d753edda..86655c48e 100644 --- a/src/emucore/CartDASH.hxx +++ b/src/emucore/CartDASH.hxx @@ -272,6 +272,14 @@ private: uInt32 mySize; // Size of the ROM image uInt8* myImage; // Pointer to a dynamically allocated ROM image of the cartridge uInt8 myRAM[RAM_TOTAL_SIZE]; + + private: + // Following constructors and assignment operators not supported + CartridgeDASH() = delete; + CartridgeDASH(const CartridgeDASH&) = delete; + CartridgeDASH(CartridgeDASH&&) = delete; + CartridgeDASH& operator=(const CartridgeDASH&) = delete; + CartridgeDASH& operator=(CartridgeDASH&&) = delete; }; #endif diff --git a/src/emucore/CartDF.hxx b/src/emucore/CartDF.hxx index a3d12a6c8..bcf236dd0 100644 --- a/src/emucore/CartDF.hxx +++ b/src/emucore/CartDF.hxx @@ -161,6 +161,14 @@ class CartridgeDF : public Cartridge // The 128K ROM image of the cartridge uInt8 myImage[32 * 4096]; + + private: + // Following constructors and assignment operators not supported + CartridgeDF() = delete; + CartridgeDF(const CartridgeDF&) = delete; + CartridgeDF(CartridgeDF&&) = delete; + CartridgeDF& operator=(const CartridgeDF&) = delete; + CartridgeDF& operator=(CartridgeDF&&) = delete; }; #endif diff --git a/src/emucore/CartDFSC.hxx b/src/emucore/CartDFSC.hxx index 44bd3bc91..ebe272239 100644 --- a/src/emucore/CartDFSC.hxx +++ b/src/emucore/CartDFSC.hxx @@ -163,6 +163,14 @@ class CartridgeDFSC : public Cartridge // The 128 bytes of RAM uInt8 myRAM[128]; + + private: + // Following constructors and assignment operators not supported + CartridgeDFSC() = delete; + CartridgeDFSC(const CartridgeDFSC&) = delete; + CartridgeDFSC(CartridgeDFSC&&) = delete; + CartridgeDFSC& operator=(const CartridgeDFSC&) = delete; + CartridgeDFSC& operator=(CartridgeDFSC&&) = delete; }; #endif diff --git a/src/emucore/CartDPC.hxx b/src/emucore/CartDPC.hxx index c9f735992..2ee3fc186 100644 --- a/src/emucore/CartDPC.hxx +++ b/src/emucore/CartDPC.hxx @@ -217,6 +217,14 @@ class CartridgeDPC : public Cartridge // Fractional DPC music OSC clocks unused during the last update double myFractionalClocks; + + private: + // Following constructors and assignment operators not supported + CartridgeDPC() = delete; + CartridgeDPC(const CartridgeDPC&) = delete; + CartridgeDPC(CartridgeDPC&&) = delete; + CartridgeDPC& operator=(const CartridgeDPC&) = delete; + CartridgeDPC& operator=(CartridgeDPC&&) = delete; }; #endif diff --git a/src/emucore/CartDPCPlus.hxx b/src/emucore/CartDPCPlus.hxx index b24fd2a94..9801dff4c 100644 --- a/src/emucore/CartDPCPlus.hxx +++ b/src/emucore/CartDPCPlus.hxx @@ -269,6 +269,14 @@ class CartridgeDPCPlus : public Cartridge // Fractional DPC music OSC clocks unused during the last update double myFractionalClocks; + + private: + // Following constructors and assignment operators not supported + CartridgeDPCPlus() = delete; + CartridgeDPCPlus(const CartridgeDPCPlus&) = delete; + CartridgeDPCPlus(CartridgeDPCPlus&&) = delete; + CartridgeDPCPlus& operator=(const CartridgeDPCPlus&) = delete; + CartridgeDPCPlus& operator=(CartridgeDPCPlus&&) = delete; }; #endif diff --git a/src/emucore/CartE0.hxx b/src/emucore/CartE0.hxx index eaa55fe74..692055e1a 100644 --- a/src/emucore/CartE0.hxx +++ b/src/emucore/CartE0.hxx @@ -174,6 +174,14 @@ class CartridgeE0 : public Cartridge // The 8K ROM image of the cartridge uInt8 myImage[8192]; + + private: + // Following constructors and assignment operators not supported + CartridgeE0() = delete; + CartridgeE0(const CartridgeE0&) = delete; + CartridgeE0(CartridgeE0&&) = delete; + CartridgeE0& operator=(const CartridgeE0&) = delete; + CartridgeE0& operator=(CartridgeE0&&) = delete; }; #endif diff --git a/src/emucore/CartE7.hxx b/src/emucore/CartE7.hxx index fc1ee5113..81c9dc7c0 100644 --- a/src/emucore/CartE7.hxx +++ b/src/emucore/CartE7.hxx @@ -200,6 +200,14 @@ class CartridgeE7 : public Cartridge // The 2048 bytes of RAM uInt8 myRAM[2048]; + + private: + // Following constructors and assignment operators not supported + CartridgeE7() = delete; + CartridgeE7(const CartridgeE7&) = delete; + CartridgeE7(CartridgeE7&&) = delete; + CartridgeE7& operator=(const CartridgeE7&) = delete; + CartridgeE7& operator=(CartridgeE7&&) = delete; }; #endif diff --git a/src/emucore/CartEF.hxx b/src/emucore/CartEF.hxx index c407d4154..180ffe3a6 100644 --- a/src/emucore/CartEF.hxx +++ b/src/emucore/CartEF.hxx @@ -164,6 +164,14 @@ class CartridgeEF : public Cartridge // The 64K ROM image of the cartridge uInt8 myImage[65536]; + + private: + // Following constructors and assignment operators not supported + CartridgeEF() = delete; + CartridgeEF(const CartridgeEF&) = delete; + CartridgeEF(CartridgeEF&&) = delete; + CartridgeEF& operator=(const CartridgeEF&) = delete; + CartridgeEF& operator=(CartridgeEF&&) = delete; }; #endif diff --git a/src/emucore/CartEFSC.hxx b/src/emucore/CartEFSC.hxx index 16b05824a..5eaa044da 100644 --- a/src/emucore/CartEFSC.hxx +++ b/src/emucore/CartEFSC.hxx @@ -167,6 +167,14 @@ class CartridgeEFSC : public Cartridge // The 128 bytes of RAM uInt8 myRAM[128]; + + private: + // Following constructors and assignment operators not supported + CartridgeEFSC() = delete; + CartridgeEFSC(const CartridgeEFSC&) = delete; + CartridgeEFSC(CartridgeEFSC&&) = delete; + CartridgeEFSC& operator=(const CartridgeEFSC&) = delete; + CartridgeEFSC& operator=(CartridgeEFSC&&) = delete; }; #endif diff --git a/src/emucore/CartF0.hxx b/src/emucore/CartF0.hxx index 4358851ec..8ab6bebc6 100644 --- a/src/emucore/CartF0.hxx +++ b/src/emucore/CartF0.hxx @@ -167,6 +167,14 @@ class CartridgeF0 : public Cartridge // The 64K ROM image of the cartridge uInt8 myImage[65536]; + + private: + // Following constructors and assignment operators not supported + CartridgeF0() = delete; + CartridgeF0(const CartridgeF0&) = delete; + CartridgeF0(CartridgeF0&&) = delete; + CartridgeF0& operator=(const CartridgeF0&) = delete; + CartridgeF0& operator=(CartridgeF0&&) = delete; }; #endif diff --git a/src/emucore/CartF4.hxx b/src/emucore/CartF4.hxx index 5cd24e3d4..e3e5fcced 100644 --- a/src/emucore/CartF4.hxx +++ b/src/emucore/CartF4.hxx @@ -160,6 +160,14 @@ class CartridgeF4 : public Cartridge // The 32K ROM image of the cartridge uInt8 myImage[32768]; + + private: + // Following constructors and assignment operators not supported + CartridgeF4() = delete; + CartridgeF4(const CartridgeF4&) = delete; + CartridgeF4(CartridgeF4&&) = delete; + CartridgeF4& operator=(const CartridgeF4&) = delete; + CartridgeF4& operator=(CartridgeF4&&) = delete; }; #endif diff --git a/src/emucore/CartF4SC.hxx b/src/emucore/CartF4SC.hxx index d1af205ac..64cf34587 100644 --- a/src/emucore/CartF4SC.hxx +++ b/src/emucore/CartF4SC.hxx @@ -163,6 +163,14 @@ class CartridgeF4SC : public Cartridge // The 128 bytes of RAM uInt8 myRAM[128]; + + private: + // Following constructors and assignment operators not supported + CartridgeF4SC() = delete; + CartridgeF4SC(const CartridgeF4SC&) = delete; + CartridgeF4SC(CartridgeF4SC&&) = delete; + CartridgeF4SC& operator=(const CartridgeF4SC&) = delete; + CartridgeF4SC& operator=(CartridgeF4SC&&) = delete; }; #endif diff --git a/src/emucore/CartF6.hxx b/src/emucore/CartF6.hxx index 0079097c2..478429e7f 100644 --- a/src/emucore/CartF6.hxx +++ b/src/emucore/CartF6.hxx @@ -160,6 +160,14 @@ class CartridgeF6 : public Cartridge // The 16K ROM image of the cartridge uInt8 myImage[16384]; + + private: + // Following constructors and assignment operators not supported + CartridgeF6() = delete; + CartridgeF6(const CartridgeF6&) = delete; + CartridgeF6(CartridgeF6&&) = delete; + CartridgeF6& operator=(const CartridgeF6&) = delete; + CartridgeF6& operator=(CartridgeF6&&) = delete; }; #endif diff --git a/src/emucore/CartF6SC.hxx b/src/emucore/CartF6SC.hxx index bbf78f1c9..6abbb59bf 100644 --- a/src/emucore/CartF6SC.hxx +++ b/src/emucore/CartF6SC.hxx @@ -163,6 +163,14 @@ class CartridgeF6SC : public Cartridge // The 128 bytes of RAM uInt8 myRAM[128]; + + private: + // Following constructors and assignment operators not supported + CartridgeF6SC() = delete; + CartridgeF6SC(const CartridgeF6SC&) = delete; + CartridgeF6SC(CartridgeF6SC&&) = delete; + CartridgeF6SC& operator=(const CartridgeF6SC&) = delete; + CartridgeF6SC& operator=(CartridgeF6SC&&) = delete; }; #endif diff --git a/src/emucore/CartF8.hxx b/src/emucore/CartF8.hxx index f4cef9ac2..0a83eaf2d 100644 --- a/src/emucore/CartF8.hxx +++ b/src/emucore/CartF8.hxx @@ -162,6 +162,14 @@ class CartridgeF8 : public Cartridge // The 8K ROM image of the cartridge uInt8 myImage[8192]; + + private: + // Following constructors and assignment operators not supported + CartridgeF8() = delete; + CartridgeF8(const CartridgeF8&) = delete; + CartridgeF8(CartridgeF8&&) = delete; + CartridgeF8& operator=(const CartridgeF8&) = delete; + CartridgeF8& operator=(CartridgeF8&&) = delete; }; #endif diff --git a/src/emucore/CartF8SC.hxx b/src/emucore/CartF8SC.hxx index 6aba49d99..11258555b 100644 --- a/src/emucore/CartF8SC.hxx +++ b/src/emucore/CartF8SC.hxx @@ -163,6 +163,14 @@ class CartridgeF8SC : public Cartridge // The 128 bytes of RAM uInt8 myRAM[128]; + + private: + // Following constructors and assignment operators not supported + CartridgeF8SC() = delete; + CartridgeF8SC(const CartridgeF8SC&) = delete; + CartridgeF8SC(CartridgeF8SC&&) = delete; + CartridgeF8SC& operator=(const CartridgeF8SC&) = delete; + CartridgeF8SC& operator=(CartridgeF8SC&&) = delete; }; #endif diff --git a/src/emucore/CartFA.hxx b/src/emucore/CartFA.hxx index f38cdf517..4623b3205 100644 --- a/src/emucore/CartFA.hxx +++ b/src/emucore/CartFA.hxx @@ -163,6 +163,14 @@ class CartridgeFA : public Cartridge // The 256 bytes of RAM on the cartridge uInt8 myRAM[256]; + + private: + // Following constructors and assignment operators not supported + CartridgeFA() = delete; + CartridgeFA(const CartridgeFA&) = delete; + CartridgeFA(CartridgeFA&&) = delete; + CartridgeFA& operator=(const CartridgeFA&) = delete; + CartridgeFA& operator=(CartridgeFA&&) = delete; }; #endif diff --git a/src/emucore/CartFA2.hxx b/src/emucore/CartFA2.hxx index 848c121d3..5a17a6e75 100644 --- a/src/emucore/CartFA2.hxx +++ b/src/emucore/CartFA2.hxx @@ -214,6 +214,14 @@ class CartridgeFA2 : public Cartridge // Size of the ROM image uInt32 mySize; + + private: + // Following constructors and assignment operators not supported + CartridgeFA2() = delete; + CartridgeFA2(const CartridgeFA2&) = delete; + CartridgeFA2(CartridgeFA2&&) = delete; + CartridgeFA2& operator=(const CartridgeFA2&) = delete; + CartridgeFA2& operator=(CartridgeFA2&&) = delete; }; #endif diff --git a/src/emucore/CartFE.hxx b/src/emucore/CartFE.hxx index d3a6e86c5..d136a2e79 100644 --- a/src/emucore/CartFE.hxx +++ b/src/emucore/CartFE.hxx @@ -189,6 +189,14 @@ class CartridgeFE : public Cartridge // Last two addresses have been modified by peek() bool myLastAddressChanged; + + private: + // Following constructors and assignment operators not supported + CartridgeFE() = delete; + CartridgeFE(const CartridgeFE&) = delete; + CartridgeFE(CartridgeFE&&) = delete; + CartridgeFE& operator=(const CartridgeFE&) = delete; + CartridgeFE& operator=(CartridgeFE&&) = delete; }; #endif diff --git a/src/emucore/CartMC.hxx b/src/emucore/CartMC.hxx index 5b8140f90..10e670b8e 100644 --- a/src/emucore/CartMC.hxx +++ b/src/emucore/CartMC.hxx @@ -265,6 +265,14 @@ class CartridgeMC : public Cartridge // Indicates if slot 3 is locked to block $FF or not bool mySlot3Locked; + + private: + // Following constructors and assignment operators not supported + CartridgeMC() = delete; + CartridgeMC(const CartridgeMC&) = delete; + CartridgeMC(CartridgeMC&&) = delete; + CartridgeMC& operator=(const CartridgeMC&) = delete; + CartridgeMC& operator=(CartridgeMC&&) = delete; }; #endif diff --git a/src/emucore/CartMDM.hxx b/src/emucore/CartMDM.hxx index 22b400d73..4daa7382a 100644 --- a/src/emucore/CartMDM.hxx +++ b/src/emucore/CartMDM.hxx @@ -181,6 +181,14 @@ class CartridgeMDM : public Cartridge // Indicates whether banking has been disabled due to a bankswitch // above bank 127 bool myBankingDisabled; + + private: + // Following constructors and assignment operators not supported + CartridgeMDM() = delete; + CartridgeMDM(const CartridgeMDM&) = delete; + CartridgeMDM(CartridgeMDM&&) = delete; + CartridgeMDM& operator=(const CartridgeMDM&) = delete; + CartridgeMDM& operator=(CartridgeMDM&&) = delete; }; #endif diff --git a/src/emucore/CartSB.hxx b/src/emucore/CartSB.hxx index ba6e59260..ab38ff513 100644 --- a/src/emucore/CartSB.hxx +++ b/src/emucore/CartSB.hxx @@ -164,6 +164,14 @@ class CartridgeSB : public Cartridge // Previous Device's page access System::PageAccess myHotSpotPageAccess[8]; + + private: + // Following constructors and assignment operators not supported + CartridgeSB() = delete; + CartridgeSB(const CartridgeSB&) = delete; + CartridgeSB(CartridgeSB&&) = delete; + CartridgeSB& operator=(const CartridgeSB&) = delete; + CartridgeSB& operator=(CartridgeSB&&) = delete; }; #endif diff --git a/src/emucore/CartUA.hxx b/src/emucore/CartUA.hxx index b9fde19bd..fb17ad07c 100644 --- a/src/emucore/CartUA.hxx +++ b/src/emucore/CartUA.hxx @@ -163,6 +163,14 @@ class CartridgeUA : public Cartridge // Previous Device's page access System::PageAccess myHotSpotPageAccess; + + private: + // Following constructors and assignment operators not supported + CartridgeUA() = delete; + CartridgeUA(const CartridgeUA&) = delete; + CartridgeUA(CartridgeUA&&) = delete; + CartridgeUA& operator=(const CartridgeUA&) = delete; + CartridgeUA& operator=(CartridgeUA&&) = delete; }; #endif diff --git a/src/emucore/CartWD.hxx b/src/emucore/CartWD.hxx index 4b3274d78..5b1cd53f0 100644 --- a/src/emucore/CartWD.hxx +++ b/src/emucore/CartWD.hxx @@ -244,6 +244,14 @@ class CartridgeWD : public Cartridge bool map3bytes; }; static BankOrg ourBankOrg[16]; + + private: + // Following constructors and assignment operators not supported + CartridgeWD() = delete; + CartridgeWD(const CartridgeWD&) = delete; + CartridgeWD(CartridgeWD&&) = delete; + CartridgeWD& operator=(const CartridgeWD&) = delete; + CartridgeWD& operator=(CartridgeWD&&) = delete; }; #endif diff --git a/src/emucore/CartX07.hxx b/src/emucore/CartX07.hxx index 0a5ce4e70..40b587497 100644 --- a/src/emucore/CartX07.hxx +++ b/src/emucore/CartX07.hxx @@ -170,6 +170,14 @@ class CartridgeX07 : public Cartridge // The 64K ROM image of the cartridge uInt8 myImage[65536]; + + private: + // Following constructors and assignment operators not supported + CartridgeX07() = delete; + CartridgeX07(const CartridgeX07&) = delete; + CartridgeX07(CartridgeX07&&) = delete; + CartridgeX07& operator=(const CartridgeX07&) = delete; + CartridgeX07& operator=(CartridgeX07&&) = delete; }; #endif diff --git a/src/emucore/CompuMate.hxx b/src/emucore/CompuMate.hxx index cd6b9ccb9..7424e1875 100644 --- a/src/emucore/CompuMate.hxx +++ b/src/emucore/CompuMate.hxx @@ -132,10 +132,17 @@ class CompuMate private: class CompuMate& myHandler; + + // Following constructors and assignment operators not supported + CMControl() = delete; + CMControl(const CMControl&) = delete; + CMControl(CMControl&&) = delete; + CMControl& operator=(const CMControl&) = delete; + CMControl& operator=(CMControl&&) = delete; }; private: - // Cart, Event and System objects + // Console and Event objects const Console& myConsole; const Event& myEvent; @@ -151,6 +158,14 @@ class CompuMate // Array of keyboard key states when in the debugger (the normal keyboard // keys are ignored in such a case) bool myInternalKeyTable[KBDK_LAST]; + + private: + // Following constructors and assignment operators not supported + CompuMate() = delete; + CompuMate(const CompuMate&) = delete; + CompuMate(CompuMate&&) = delete; + CompuMate& operator=(const CompuMate&) = delete; + CompuMate& operator=(CompuMate&&) = delete; }; #endif diff --git a/src/emucore/Console.hxx b/src/emucore/Console.hxx index ad052740e..4955646df 100644 --- a/src/emucore/Console.hxx +++ b/src/emucore/Console.hxx @@ -313,10 +313,6 @@ class Console : public Serializable void toggleTIABit(TIABit bit, const string& bitname, bool show = true) const; void toggleTIACollision(TIABit bit, const string& bitname, bool show = true) const; - // Copy constructor and assignment operator not supported - Console(const Console&); - Console& operator = (const Console&); - private: // Reference to the osystem object OSystem& myOSystem; @@ -382,6 +378,14 @@ class Console : public Serializable static uInt32 ourUserNTSCPalette[256]; static uInt32 ourUserPALPalette[256]; static uInt32 ourUserSECAMPalette[256]; + + private: + // Following constructors and assignment operators not supported + Console() = delete; + Console(const Console&) = delete; + Console(Console&&) = delete; + Console& operator=(const Console&) = delete; + Console& operator=(Console&&) = delete; }; #endif diff --git a/src/emucore/Control.hxx b/src/emucore/Control.hxx index 653907cf9..02b8a8fac 100644 --- a/src/emucore/Control.hxx +++ b/src/emucore/Control.hxx @@ -267,9 +267,12 @@ class Controller : public Serializable Int32 myAnalogPinValue[2]; private: - // Copy constructor and assignment operator not supported - Controller(const Controller&); - Controller& operator = (const Controller&); + // Following constructors and assignment operators not supported + Controller() = delete; + Controller(const Controller&) = delete; + Controller(Controller&&) = delete; + Controller& operator=(const Controller&) = delete; + Controller& operator=(Controller&&) = delete; }; #endif diff --git a/src/emucore/Device.hxx b/src/emucore/Device.hxx index f48e25241..78cd49793 100644 --- a/src/emucore/Device.hxx +++ b/src/emucore/Device.hxx @@ -123,6 +123,13 @@ class Device : public Serializable protected: /// Pointer to the system the device is installed in or the null pointer System* mySystem; + + private: + // Following constructors and assignment operators not supported + Device(const Device&) = delete; + Device(Device&&) = delete; + Device& operator=(const Device&) = delete; + Device& operator=(Device&&) = delete; }; #endif diff --git a/src/emucore/Driving.hxx b/src/emucore/Driving.hxx index 02473b010..6f7d26c5e 100644 --- a/src/emucore/Driving.hxx +++ b/src/emucore/Driving.hxx @@ -95,6 +95,14 @@ class Driving : public Controller // Controllers to emulate in 'specific' mouse axis mode int myControlIDX, myControlIDY; + + private: + // Following constructors and assignment operators not supported + Driving() = delete; + Driving(const Driving&) = delete; + Driving(Driving&&) = delete; + Driving& operator=(const Driving&) = delete; + Driving& operator=(Driving&&) = delete; }; #endif diff --git a/src/emucore/Event.hxx b/src/emucore/Event.hxx index f37c7d783..2d9b57d4a 100644 --- a/src/emucore/Event.hxx +++ b/src/emucore/Event.hxx @@ -127,6 +127,13 @@ class Event // Array of keyboard key states bool myKeyTable[KBDK_LAST]; + + private: + // Following constructors and assignment operators not supported + Event(const Event&) = delete; + Event(Event&&) = delete; + Event& operator=(const Event&) = delete; + Event& operator=(Event&&) = delete; }; #endif diff --git a/src/emucore/EventHandler.hxx b/src/emucore/EventHandler.hxx index 58fc5c3dd..98a759078 100644 --- a/src/emucore/EventHandler.hxx +++ b/src/emucore/EventHandler.hxx @@ -497,10 +497,6 @@ class EventHandler void removeJoystick(int index); private: - // Copy constructor and assignment operator not supported - EventHandler(const EventHandler&); - EventHandler& operator = (const EventHandler&); - enum { kComboSize = 16, kEventsPerCombo = 8, @@ -600,6 +596,13 @@ class EventHandler // Handler for all joystick addition/removal/mapping unique_ptr myJoyHandler; + + // Following constructors and assignment operators not supported + EventHandler() = delete; + EventHandler(const EventHandler&) = delete; + EventHandler(EventHandler&&) = delete; + EventHandler& operator=(const EventHandler&) = delete; + EventHandler& operator=(EventHandler&&) = delete; }; #endif diff --git a/src/emucore/FBSurface.hxx b/src/emucore/FBSurface.hxx index a86b64355..cd7e3eec6 100644 --- a/src/emucore/FBSurface.hxx +++ b/src/emucore/FBSurface.hxx @@ -320,17 +320,19 @@ class FBSurface static void setPalette(const uInt32* palette) { myPalette = palette; } - private: - // Copy constructor and assignment operator not supported - FBSurface(const FBSurface&); - FBSurface& operator = (const FBSurface&); - protected: static const uInt32* myPalette; uInt32* myPixels; uInt32 myPitch; Attributes myAttributes; + + private: + // Following constructors and assignment operators not supported + FBSurface(const FBSurface&) = delete; + FBSurface(FBSurface&&) = delete; + FBSurface& operator=(const FBSurface&) = delete; + FBSurface& operator=(FBSurface&&) = delete; }; #endif diff --git a/src/emucore/FrameBuffer.hxx b/src/emucore/FrameBuffer.hxx index 267ec4f7e..8bcacb706 100644 --- a/src/emucore/FrameBuffer.hxx +++ b/src/emucore/FrameBuffer.hxx @@ -554,6 +554,14 @@ class FrameBuffer // Holds UI palette data (standard and classic colours) static uInt32 ourGUIColors[2][kNumColors-256]; + + private: + // Following constructors and assignment operators not supported + FrameBuffer() = delete; + FrameBuffer(const FrameBuffer&) = delete; + FrameBuffer(FrameBuffer&&) = delete; + FrameBuffer& operator=(const FrameBuffer&) = delete; + FrameBuffer& operator=(FrameBuffer&&) = delete; }; #endif diff --git a/src/emucore/Genesis.hxx b/src/emucore/Genesis.hxx index 4ec6d362a..62a96d2db 100644 --- a/src/emucore/Genesis.hxx +++ b/src/emucore/Genesis.hxx @@ -83,6 +83,14 @@ class Genesis : public Controller // Controller to emulate in normal mouse axis mode int myControlID; + + private: + // Following constructors and assignment operators not supported + Genesis() = delete; + Genesis(const Genesis&) = delete; + Genesis(Genesis&&) = delete; + Genesis& operator=(const Genesis&) = delete; + Genesis& operator=(Genesis&&) = delete; }; #endif diff --git a/src/emucore/Joystick.hxx b/src/emucore/Joystick.hxx index e15f931b1..f2f7f3f0e 100644 --- a/src/emucore/Joystick.hxx +++ b/src/emucore/Joystick.hxx @@ -91,6 +91,14 @@ class Joystick : public Controller int myControlID; static int _DEAD_ZONE; + + private: + // Following constructors and assignment operators not supported + Joystick() = delete; + Joystick(const Joystick&) = delete; + Joystick(Joystick&&) = delete; + Joystick& operator=(const Joystick&) = delete; + Joystick& operator=(Joystick&&) = delete; }; #endif diff --git a/src/emucore/Keyboard.hxx b/src/emucore/Keyboard.hxx index 7cff3632c..8c43591e0 100644 --- a/src/emucore/Keyboard.hxx +++ b/src/emucore/Keyboard.hxx @@ -71,6 +71,14 @@ class Keyboard : public Controller myFourEvent, myFiveEvent, mySixEvent, mySevenEvent, myEightEvent, myNineEvent, myStarEvent, myZeroEvent, myPoundEvent; + + private: + // Following constructors and assignment operators not supported + Keyboard() = delete; + Keyboard(const Keyboard&) = delete; + Keyboard(Keyboard&&) = delete; + Keyboard& operator=(const Keyboard&) = delete; + Keyboard& operator=(Keyboard&&) = delete; }; #endif diff --git a/src/emucore/KidVid.hxx b/src/emucore/KidVid.hxx index 60fa4e563..ce5e6f261 100644 --- a/src/emucore/KidVid.hxx +++ b/src/emucore/KidVid.hxx @@ -109,6 +109,14 @@ class KidVid : public Controller static const uInt8 ourSongPositions[44+38+42+62+80+62]; static const uInt32 ourSongStart[104]; + + private: + // Following constructors and assignment operators not supported + KidVid() = delete; + KidVid(const KidVid&) = delete; + KidVid(KidVid&&) = delete; + KidVid& operator=(const KidVid&) = delete; + KidVid& operator=(KidVid&&) = delete; }; #endif diff --git a/src/emucore/M6502.hxx b/src/emucore/M6502.hxx index 9a8193a28..4aa899d13 100644 --- a/src/emucore/M6502.hxx +++ b/src/emucore/M6502.hxx @@ -361,6 +361,14 @@ class M6502 : public Serializable vector> myBreakConds; StringList myBreakCondNames; #endif // DEBUGGER_SUPPORT + + private: + // Following constructors and assignment operators not supported + M6502() = delete; + M6502(const M6502&) = delete; + M6502(M6502&&) = delete; + M6502& operator=(const M6502&) = delete; + M6502& operator=(M6502&&) = delete; }; #endif diff --git a/src/emucore/M6532.hxx b/src/emucore/M6532.hxx index f5e43a4eb..76efaa7f2 100644 --- a/src/emucore/M6532.hxx +++ b/src/emucore/M6532.hxx @@ -206,9 +206,12 @@ class M6532 : public Device uInt8 myOutTimer[4]; private: - // Copy constructor and assignment operator not supported - M6532(const M6532&); - M6532& operator = (const M6532&); + // Following constructors and assignment operators not supported + M6532() = delete; + M6532(const M6532&) = delete; + M6532(M6532&&) = delete; + M6532& operator=(const M6532&) = delete; + M6532& operator=(M6532&&) = delete; }; #endif diff --git a/src/emucore/MD5.cxx b/src/emucore/MD5.cxx index 64f28b21f..bc92d0cf5 100644 --- a/src/emucore/MD5.cxx +++ b/src/emucore/MD5.cxx @@ -45,6 +45,8 @@ documentation and/or software. */ +namespace MD5 { + // Setup the types used by the MD5 routines using POINTER = uInt8*; @@ -324,7 +326,7 @@ static void MD5_memset(POINTER output, int value, uInt32 len) } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -string MD5(const uInt8* buffer, uInt32 length) +string hash(const uInt8* buffer, uInt32 length) { char hex[] = "0123456789abcdef"; MD5_CTX context; @@ -345,7 +347,7 @@ string MD5(const uInt8* buffer, uInt32 length) } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -string MD5(const FilesystemNode& node) +string hash(const FilesystemNode& node) { uInt8* image = nullptr; uInt32 size = 0; @@ -358,7 +360,9 @@ string MD5(const FilesystemNode& node) return EmptyString; } - const string& md5 = MD5(image, size); + const string& md5 = hash(image, size); delete[] image; return md5; } + +} // Namespace MD5 diff --git a/src/emucore/MD5.hxx b/src/emucore/MD5.hxx index 09683a353..907fcf533 100644 --- a/src/emucore/MD5.hxx +++ b/src/emucore/MD5.hxx @@ -23,6 +23,8 @@ #include "FSNode.hxx" #include "bspf.hxx" +namespace MD5 { + /** Get the MD5 Message-Digest of the specified message with the given length. The digest consists of 32 hexadecimal digits. @@ -31,7 +33,7 @@ @param length The length of the message @return The message-digest */ -string MD5(const uInt8* buffer, uInt32 length); +string hash(const uInt8* buffer, uInt32 length); /** Get the MD5 Message-Digest of the file contained in 'node'. @@ -40,6 +42,8 @@ string MD5(const uInt8* buffer, uInt32 length); @param node The file node to compute the digest of @return The message-digest */ -string MD5(const FilesystemNode& node); +string hash(const FilesystemNode& node); + +} // Namespace MD5 #endif diff --git a/src/emucore/MT24LC256.hxx b/src/emucore/MT24LC256.hxx index ebb0c927f..4dcd75594 100644 --- a/src/emucore/MT24LC256.hxx +++ b/src/emucore/MT24LC256.hxx @@ -114,9 +114,12 @@ class MT24LC256 uInt8 jpee_packet[70]; private: - // Copy constructor and assignment operator not supported - MT24LC256(const MT24LC256&); - MT24LC256& operator = (const MT24LC256&); + // Following constructors and assignment operators not supported + MT24LC256() = delete; + MT24LC256(const MT24LC256&) = delete; + MT24LC256(MT24LC256&&) = delete; + MT24LC256& operator=(const MT24LC256&) = delete; + MT24LC256& operator=(MT24LC256&&) = delete; }; #endif diff --git a/src/emucore/MindLink.hxx b/src/emucore/MindLink.hxx index e191d2891..e43d4a1ab 100644 --- a/src/emucore/MindLink.hxx +++ b/src/emucore/MindLink.hxx @@ -113,6 +113,14 @@ class MindLink : public Controller // Whether to use the mouse to emulate this controller int myMouseEnabled; + + private: + // Following constructors and assignment operators not supported + MindLink() = delete; + MindLink(const MindLink&) = delete; + MindLink(MindLink&&) = delete; + MindLink& operator=(const MindLink&) = delete; + MindLink& operator=(MindLink&&) = delete; }; #endif diff --git a/src/emucore/NullDev.hxx b/src/emucore/NullDev.hxx index 4510f4b37..565c85b60 100644 --- a/src/emucore/NullDev.hxx +++ b/src/emucore/NullDev.hxx @@ -106,6 +106,13 @@ class NullDevice : public Device cerr << hex << "NullDevice: poke(" << address << "," << value << ")\n"; return false; } + + private: + // Following constructors and assignment operators not supported + NullDevice(const NullDevice&) = delete; + NullDevice(NullDevice&&) = delete; + NullDevice& operator=(const NullDevice&) = delete; + NullDevice& operator=(NullDevice&&) = delete; }; #endif diff --git a/src/emucore/OSystem.cxx b/src/emucore/OSystem.cxx index 6237fabbc..ce5421556 100644 --- a/src/emucore/OSystem.cxx +++ b/src/emucore/OSystem.cxx @@ -571,7 +571,7 @@ uInt8* OSystem::openROM(const FilesystemNode& rom, string& md5, uInt32& size) // Now we make sure that the file has a valid properties entry // To save time, only generate an MD5 if we really need one if(md5 == "") - md5 = MD5(image, size); + md5 = MD5::hash(image, size); // Some games may not have a name, since there may not // be an entry in stella.pro. In that case, we use the rom name diff --git a/src/emucore/OSystem.hxx b/src/emucore/OSystem.hxx index b202262a4..886602f91 100644 --- a/src/emucore/OSystem.hxx +++ b/src/emucore/OSystem.hxx @@ -589,9 +589,11 @@ class OSystem void validatePath(string& path, const string& setting, const string& defaultpath); - // Copy constructor and assignment operator not supported - OSystem(const OSystem&); - OSystem& operator = (const OSystem&); + // Following constructors and assignment operators not supported + OSystem(const OSystem&) = delete; + OSystem(OSystem&&) = delete; + OSystem& operator=(const OSystem&) = delete; + OSystem& operator=(OSystem&&) = delete; }; #endif diff --git a/src/emucore/Paddles.hxx b/src/emucore/Paddles.hxx index 6da7706eb..594ef9092 100644 --- a/src/emucore/Paddles.hxx +++ b/src/emucore/Paddles.hxx @@ -133,6 +133,14 @@ class Paddles : public Controller // Lookup table for associating paddle buttons with controller pins // Yes, this is hideously complex static const Controller::DigitalPin ourButtonPin[2]; + + private: + // Following constructors and assignment operators not supported + Paddles() = delete; + Paddles(const Paddles&) = delete; + Paddles(Paddles&&) = delete; + Paddles& operator=(const Paddles&) = delete; + Paddles& operator=(Paddles&&) = delete; }; #endif diff --git a/src/emucore/PropsSet.hxx b/src/emucore/PropsSet.hxx index e800f43a4..6fe5eab21 100644 --- a/src/emucore/PropsSet.hxx +++ b/src/emucore/PropsSet.hxx @@ -125,6 +125,14 @@ class PropertiesSet // The properties temporarily inserted by the program, which should // be discarded when the program ends PropsList myTempProps; + + private: + // Following constructors and assignment operators not supported + PropertiesSet() = delete; + PropertiesSet(const PropertiesSet&) = delete; + PropertiesSet(PropertiesSet&&) = delete; + PropertiesSet& operator=(const PropertiesSet&) = delete; + PropertiesSet& operator=(PropertiesSet&&) = delete; }; #endif diff --git a/src/emucore/Random.hxx b/src/emucore/Random.hxx index f65748eaf..c3941d3cb 100644 --- a/src/emucore/Random.hxx +++ b/src/emucore/Random.hxx @@ -66,6 +66,14 @@ class Random // Indicates the next random number uInt32 myValue; + + private: + // Following constructors and assignment operators not supported + Random() = delete; + Random(const Random&) = delete; + Random(Random&&) = delete; + Random& operator=(const Random&) = delete; + Random& operator=(Random&&) = delete; }; #endif diff --git a/src/emucore/SaveKey.hxx b/src/emucore/SaveKey.hxx index f88bf1fcb..545b49b9f 100644 --- a/src/emucore/SaveKey.hxx +++ b/src/emucore/SaveKey.hxx @@ -92,6 +92,14 @@ class SaveKey : public Controller private: // The EEPROM used in the SaveKey unique_ptr myEEPROM; + + private: + // Following constructors and assignment operators not supported + SaveKey() = delete; + SaveKey(const SaveKey&) = delete; + SaveKey(SaveKey&&) = delete; + SaveKey& operator=(const SaveKey&) = delete; + SaveKey& operator=(SaveKey&&) = delete; }; #endif diff --git a/src/emucore/SerialPort.hxx b/src/emucore/SerialPort.hxx index d4180ad7c..742a12700 100644 --- a/src/emucore/SerialPort.hxx +++ b/src/emucore/SerialPort.hxx @@ -65,6 +65,13 @@ class SerialPort Close a previously opened serial port. */ virtual void closePort() { } + + private: + // Following constructors and assignment operators not supported + SerialPort(const SerialPort&) = delete; + SerialPort(SerialPort&&) = delete; + SerialPort& operator=(const SerialPort&) = delete; + SerialPort& operator=(SerialPort&&) = delete; }; #endif diff --git a/src/emucore/Serializable.hxx b/src/emucore/Serializable.hxx index ef763558d..23c402274 100644 --- a/src/emucore/Serializable.hxx +++ b/src/emucore/Serializable.hxx @@ -58,6 +58,13 @@ class Serializable @return The name of the object */ virtual string name() const = 0; + + private: + // Following constructors and assignment operators not supported + Serializable(const Serializable&) = delete; + Serializable(Serializable&&) = delete; + Serializable& operator=(const Serializable&) = delete; + Serializable& operator=(Serializable&&) = delete; }; #endif diff --git a/src/emucore/Serializer.cxx b/src/emucore/Serializer.cxx index 47834081a..bf72996f9 100644 --- a/src/emucore/Serializer.cxx +++ b/src/emucore/Serializer.cxx @@ -25,8 +25,7 @@ // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Serializer::Serializer(const string& filename, bool readonly) - : myStream(nullptr), - myUseFilestream(true) + : myStream(nullptr) { if(readonly) { @@ -66,8 +65,7 @@ Serializer::Serializer(const string& filename, bool readonly) // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Serializer::Serializer() - : myStream(nullptr), - myUseFilestream(false) + : myStream(nullptr) { myStream = make_ptr(ios::in | ios::out | ios::binary); diff --git a/src/emucore/Serializer.hxx b/src/emucore/Serializer.hxx index 5c2442aae..e5696161e 100644 --- a/src/emucore/Serializer.hxx +++ b/src/emucore/Serializer.hxx @@ -189,7 +189,6 @@ class Serializer private: // The stream to send the serialized data to. unique_ptr myStream; - bool myUseFilestream; enum { TruePattern = 0xfe, @@ -197,9 +196,11 @@ class Serializer }; private: - // Copy constructor and assignment operator not supported - Serializer(const Serializer&); - Serializer& operator = (const Serializer&); + // Following constructors and assignment operators not supported + Serializer(const Serializer&) = delete; + Serializer(Serializer&&) = delete; + Serializer& operator=(const Serializer&) = delete; + Serializer& operator=(Serializer&&) = delete; }; #endif diff --git a/src/emucore/Settings.hxx b/src/emucore/Settings.hxx index dda2c20d3..ece42a194 100644 --- a/src/emucore/Settings.hxx +++ b/src/emucore/Settings.hxx @@ -104,11 +104,6 @@ class Settings */ virtual void saveConfig(); - private: - // Copy constructor and assignment operator not supported - Settings(const Settings&); - Settings& operator = (const Settings&); - // Trim leading and following whitespace from a string static string trim(string& str) { @@ -153,6 +148,14 @@ class Settings // Holds auxiliary key,value pairs that shouldn't be saved on // program exit. SettingsArray myExternalSettings; + + private: + // Following constructors and assignment operators not supported + Settings() = delete; + Settings(const Settings&) = delete; + Settings(Settings&&) = delete; + Settings& operator=(const Settings&) = delete; + Settings& operator=(Settings&&) = delete; }; #endif diff --git a/src/emucore/Sound.hxx b/src/emucore/Sound.hxx index b7a42af65..cf86af06e 100644 --- a/src/emucore/Sound.hxx +++ b/src/emucore/Sound.hxx @@ -130,6 +130,14 @@ class Sound : public Serializable protected: // The OSystem for this sound object OSystem& myOSystem; + + private: + // Following constructors and assignment operators not supported + Sound() = delete; + Sound(const Sound&) = delete; + Sound(Sound&&) = delete; + Sound& operator=(const Sound&) = delete; + Sound& operator=(Sound&&) = delete; }; #endif diff --git a/src/emucore/StateManager.hxx b/src/emucore/StateManager.hxx index 5f1dc5dbd..4afa6da80 100644 --- a/src/emucore/StateManager.hxx +++ b/src/emucore/StateManager.hxx @@ -98,11 +98,6 @@ class StateManager */ void reset(); - private: - // Copy constructor and assignment operator not supported - StateManager(const StateManager&); - StateManager& operator = (const StateManager&); - private: enum Mode { kOffMode, @@ -131,6 +126,14 @@ class StateManager // Serializer classes used to save/load the eventstream Serializer myMovieWriter; Serializer myMovieReader; + + private: + // Following constructors and assignment operators not supported + StateManager() = delete; + StateManager(const StateManager&) = delete; + StateManager(StateManager&&) = delete; + StateManager& operator=(const StateManager&) = delete; + StateManager& operator=(StateManager&&) = delete; }; #endif diff --git a/src/emucore/Switches.hxx b/src/emucore/Switches.hxx index 5597808c3..ffb114ea4 100644 --- a/src/emucore/Switches.hxx +++ b/src/emucore/Switches.hxx @@ -95,6 +95,14 @@ class Switches : public Serializable // State of the console switches uInt8 mySwitches; + + private: + // Following constructors and assignment operators not supported + Switches() = delete; + Switches(const Switches&) = delete; + Switches(Switches&&) = delete; + Switches& operator=(const Switches&) = delete; + Switches& operator=(Switches&&) = delete; }; #endif diff --git a/src/emucore/System.hxx b/src/emucore/System.hxx index e579137da..e4a38cc99 100644 --- a/src/emucore/System.hxx +++ b/src/emucore/System.hxx @@ -416,9 +416,12 @@ class System : public Serializable bool mySystemInAutodetect; private: - // Copy constructor and assignment operator not supported - System(const System&); - System& operator = (const System&); + // Following constructors and assignment operators not supported + System() = delete; + System(const System&) = delete; + System(System&&) = delete; + System& operator=(const System&) = delete; + System& operator=(System&&) = delete; }; #endif diff --git a/src/emucore/TIA.hxx b/src/emucore/TIA.hxx index e875a83cc..b99dede8a 100644 --- a/src/emucore/TIA.hxx +++ b/src/emucore/TIA.hxx @@ -617,9 +617,12 @@ class TIA : public Device bool myBitsEnabled, myCollisionsEnabled; private: - // Copy constructor and assignment operator not supported - TIA(const TIA&); - TIA& operator = (const TIA&); + // Following constructors and assignment operators not supported + TIA() = delete; + TIA(const TIA&) = delete; + TIA(TIA&&) = delete; + TIA& operator=(const TIA&) = delete; + TIA& operator=(TIA&&) = delete; }; #endif diff --git a/src/emucore/TIASnd.hxx b/src/emucore/TIASnd.hxx index 670c0ae1e..b71ea27c6 100644 --- a/src/emucore/TIASnd.hxx +++ b/src/emucore/TIASnd.hxx @@ -174,6 +174,13 @@ class TIASound implemented by using counters. */ static const uInt8 Div31[POLY5_SIZE]; + + private: + // Following constructors and assignment operators not supported + TIASound(const TIASound&) = delete; + TIASound(TIASound&&) = delete; + TIASound& operator=(const TIASound&) = delete; + TIASound& operator=(TIASound&&) = delete; }; #endif diff --git a/src/emucore/TIASurface.hxx b/src/emucore/TIASurface.hxx index 14e9f7012..9ecafa602 100644 --- a/src/emucore/TIASurface.hxx +++ b/src/emucore/TIASurface.hxx @@ -174,6 +174,14 @@ class TIASurface // Palette for phosphor rendering mode uInt32 myPhosphorPalette[256][256]; + + private: + // Following constructors and assignment operators not supported + TIASurface() = delete; + TIASurface(const TIASurface&) = delete; + TIASurface(TIASurface&&) = delete; + TIASurface& operator=(const TIASurface&) = delete; + TIASurface& operator=(TIASurface&&) = delete; }; #endif diff --git a/src/emucore/TIATables.hxx b/src/emucore/TIATables.hxx index 4ece1ab39..c9c4ff934 100644 --- a/src/emucore/TIATables.hxx +++ b/src/emucore/TIATables.hxx @@ -208,6 +208,14 @@ class TIATables // Compute the player position reset when table static void buildPxPosResetWhenTable(); + + private: + // Following constructors and assignment operators not supported + TIATables() = delete; + TIATables(const TIATables&) = delete; + TIATables(TIATables&&) = delete; + TIATables& operator=(const TIATables&) = delete; + TIATables& operator=(TIATables&&) = delete; }; #endif diff --git a/src/emucore/Thumbulator.hxx b/src/emucore/Thumbulator.hxx index 72de8ce99..68f71e33e 100644 --- a/src/emucore/Thumbulator.hxx +++ b/src/emucore/Thumbulator.hxx @@ -142,6 +142,14 @@ class Thumbulator ostringstream statusMsg; static bool trapOnFatal; + + private: + // Following constructors and assignment operators not supported + Thumbulator() = delete; + Thumbulator(const Thumbulator&) = delete; + Thumbulator(Thumbulator&&) = delete; + Thumbulator& operator=(const Thumbulator&) = delete; + Thumbulator& operator=(Thumbulator&&) = delete; }; #endif diff --git a/src/emucore/TrackBall.hxx b/src/emucore/TrackBall.hxx index 3c5c0b4d8..9ab1d348e 100644 --- a/src/emucore/TrackBall.hxx +++ b/src/emucore/TrackBall.hxx @@ -124,6 +124,14 @@ class TrackBall : public Controller // Amiga mouse static const uInt32 ourTrakBallTableAM_H[4]; static const uInt32 ourTrakBallTableAM_V[4]; + + private: + // Following constructors and assignment operators not supported + TrackBall() = delete; + TrackBall(const TrackBall&) = delete; + TrackBall(TrackBall&&) = delete; + TrackBall& operator=(const TrackBall&) = delete; + TrackBall& operator=(TrackBall&&) = delete; }; #endif diff --git a/src/gui/AboutDialog.hxx b/src/gui/AboutDialog.hxx index ce685a00b..5ce568d8d 100644 --- a/src/gui/AboutDialog.hxx +++ b/src/gui/AboutDialog.hxx @@ -52,6 +52,14 @@ class AboutDialog : public Dialog void displayInfo(); void loadConfig() { displayInfo(); } + + private: + // Following constructors and assignment operators not supported + AboutDialog() = delete; + AboutDialog(const AboutDialog&) = delete; + AboutDialog(AboutDialog&&) = delete; + AboutDialog& operator=(const AboutDialog&) = delete; + AboutDialog& operator=(AboutDialog&&) = delete; }; #endif diff --git a/src/gui/AudioDialog.hxx b/src/gui/AudioDialog.hxx index 231484274..2c8584d98 100644 --- a/src/gui/AudioDialog.hxx +++ b/src/gui/AudioDialog.hxx @@ -56,6 +56,14 @@ class AudioDialog : public Dialog kVolumeChanged = 'ADvc', kSoundEnableChanged = 'ADse' }; + + private: + // Following constructors and assignment operators not supported + AudioDialog() = delete; + AudioDialog(const AudioDialog&) = delete; + AudioDialog(AudioDialog&&) = delete; + AudioDialog& operator=(const AudioDialog&) = delete; + AudioDialog& operator=(AudioDialog&&) = delete; }; #endif diff --git a/src/gui/BrowserDialog.hxx b/src/gui/BrowserDialog.hxx index b1aa8b995..4d6f8e850 100644 --- a/src/gui/BrowserDialog.hxx +++ b/src/gui/BrowserDialog.hxx @@ -73,6 +73,14 @@ class BrowserDialog : public Dialog, public CommandSender ButtonWidget* _basedirButton; BrowserDialog::ListMode _mode; + + private: + // Following constructors and assignment operators not supported + BrowserDialog() = delete; + BrowserDialog(const BrowserDialog&) = delete; + BrowserDialog(BrowserDialog&&) = delete; + BrowserDialog& operator=(const BrowserDialog&) = delete; + BrowserDialog& operator=(BrowserDialog&&) = delete; }; #endif diff --git a/src/gui/CheckListWidget.hxx b/src/gui/CheckListWidget.hxx index 469067664..ebc0ac014 100644 --- a/src/gui/CheckListWidget.hxx +++ b/src/gui/CheckListWidget.hxx @@ -62,6 +62,14 @@ class CheckListWidget : public ListWidget protected: BoolArray _stateList; CheckboxArray _checkList; + + private: + // Following constructors and assignment operators not supported + CheckListWidget() = delete; + CheckListWidget(const CheckListWidget&) = delete; + CheckListWidget(CheckListWidget&&) = delete; + CheckListWidget& operator=(const CheckListWidget&) = delete; + CheckListWidget& operator=(CheckListWidget&&) = delete; }; #endif diff --git a/src/gui/ComboDialog.hxx b/src/gui/ComboDialog.hxx index c7755393d..b68b2176e 100644 --- a/src/gui/ComboDialog.hxx +++ b/src/gui/ComboDialog.hxx @@ -49,6 +49,14 @@ class ComboDialog : public Dialog StaticTextWidget* myComboName; PopUpWidget* myEvents[8]; + + private: + // Following constructors and assignment operators not supported + ComboDialog() = delete; + ComboDialog(const ComboDialog&) = delete; + ComboDialog(ComboDialog&&) = delete; + ComboDialog& operator=(const ComboDialog&) = delete; + ComboDialog& operator=(ComboDialog&&) = delete; }; #endif diff --git a/src/gui/CommandDialog.hxx b/src/gui/CommandDialog.hxx index 898a2613d..76fba227f 100644 --- a/src/gui/CommandDialog.hxx +++ b/src/gui/CommandDialog.hxx @@ -59,6 +59,14 @@ class CommandDialog : public Dialog kNumRows = 4, kNumCols = 4 }; + + private: + // Following constructors and assignment operators not supported + CommandDialog() = delete; + CommandDialog(const CommandDialog&) = delete; + CommandDialog(CommandDialog&&) = delete; + CommandDialog& operator=(const CommandDialog&) = delete; + CommandDialog& operator=(CommandDialog&&) = delete; }; #endif diff --git a/src/gui/CommandMenu.hxx b/src/gui/CommandMenu.hxx index 04f627625..d38b40a40 100644 --- a/src/gui/CommandMenu.hxx +++ b/src/gui/CommandMenu.hxx @@ -43,6 +43,14 @@ class CommandMenu : public DialogContainer Destructor */ virtual ~CommandMenu(); + + private: + // Following constructors and assignment operators not supported + CommandMenu() = delete; + CommandMenu(const CommandMenu&) = delete; + CommandMenu(CommandMenu&&) = delete; + CommandMenu& operator=(const CommandMenu&) = delete; + CommandMenu& operator=(CommandMenu&&) = delete; }; #endif diff --git a/src/gui/ConfigPathDialog.hxx b/src/gui/ConfigPathDialog.hxx index 236b03308..34e840c1e 100644 --- a/src/gui/ConfigPathDialog.hxx +++ b/src/gui/ConfigPathDialog.hxx @@ -75,6 +75,14 @@ class ConfigPathDialog : public Dialog, public CommandSender // Indicates if this dialog is used for global (vs. in-game) settings bool myIsGlobal; + + private: + // Following constructors and assignment operators not supported + ConfigPathDialog() = delete; + ConfigPathDialog(const ConfigPathDialog&) = delete; + ConfigPathDialog(ConfigPathDialog&&) = delete; + ConfigPathDialog& operator=(const ConfigPathDialog&) = delete; + ConfigPathDialog& operator=(ConfigPathDialog&&) = delete; }; #endif diff --git a/src/gui/ContextMenu.hxx b/src/gui/ContextMenu.hxx index d3ee25a60..b58b78ab0 100644 --- a/src/gui/ContextMenu.hxx +++ b/src/gui/ContextMenu.hxx @@ -127,6 +127,14 @@ class ContextMenu : public Dialog, public CommandSender int _cmd; uInt32 _xorig, _yorig; + + private: + // Following constructors and assignment operators not supported + ContextMenu() = delete; + ContextMenu(const ContextMenu&) = delete; + ContextMenu(ContextMenu&&) = delete; + ContextMenu& operator=(const ContextMenu&) = delete; + ContextMenu& operator=(ContextMenu&&) = delete; }; #endif diff --git a/src/gui/Dialog.hxx b/src/gui/Dialog.hxx index 0cc65a016..4d64bccf9 100644 --- a/src/gui/Dialog.hxx +++ b/src/gui/Dialog.hxx @@ -156,6 +156,14 @@ class Dialog : public GuiObject shared_ptr _surface; int _tabID; + + private: + // Following constructors and assignment operators not supported + Dialog() = delete; + Dialog(const Dialog&) = delete; + Dialog(Dialog&&) = delete; + Dialog& operator=(const Dialog&) = delete; + Dialog& operator=(Dialog&&) = delete; }; #endif diff --git a/src/gui/DialogContainer.hxx b/src/gui/DialogContainer.hxx index 461ddd0ea..c92cb17e8 100644 --- a/src/gui/DialogContainer.hxx +++ b/src/gui/DialogContainer.hxx @@ -212,6 +212,14 @@ class DialogContainer int count; // How often was it already pressed? uInt64 time; // Time } myLastClick; + + private: + // Following constructors and assignment operators not supported + DialogContainer() = delete; + DialogContainer(const DialogContainer&) = delete; + DialogContainer(DialogContainer&&) = delete; + DialogContainer& operator=(const DialogContainer&) = delete; + DialogContainer& operator=(DialogContainer&&) = delete; }; #endif diff --git a/src/gui/EditTextWidget.hxx b/src/gui/EditTextWidget.hxx index 900196f98..e4aef5773 100644 --- a/src/gui/EditTextWidget.hxx +++ b/src/gui/EditTextWidget.hxx @@ -48,6 +48,14 @@ class EditTextWidget : public EditableWidget protected: string _backupString; bool _changed; + + private: + // Following constructors and assignment operators not supported + EditTextWidget() = delete; + EditTextWidget(const EditTextWidget&) = delete; + EditTextWidget(EditTextWidget&&) = delete; + EditTextWidget& operator=(const EditTextWidget&) = delete; + EditTextWidget& operator=(EditTextWidget&&) = delete; }; #endif diff --git a/src/gui/EditableWidget.hxx b/src/gui/EditableWidget.hxx index c34f74e61..344e2c7b3 100644 --- a/src/gui/EditableWidget.hxx +++ b/src/gui/EditableWidget.hxx @@ -113,6 +113,14 @@ class EditableWidget : public Widget, public CommandSender private: TextFilter _filter; + + private: + // Following constructors and assignment operators not supported + EditableWidget() = delete; + EditableWidget(const EditableWidget&) = delete; + EditableWidget(EditableWidget&&) = delete; + EditableWidget& operator=(const EditableWidget&) = delete; + EditableWidget& operator=(EditableWidget&&) = delete; }; #endif diff --git a/src/gui/EventMappingWidget.hxx b/src/gui/EventMappingWidget.hxx index 28b7a6552..4d9b71ec2 100644 --- a/src/gui/EventMappingWidget.hxx +++ b/src/gui/EventMappingWidget.hxx @@ -106,6 +106,14 @@ class EventMappingWidget : public Widget, public CommandSender int myLastStick, myLastAxis, myLastHat, myLastValue; bool myFirstTime; + + private: + // Following constructors and assignment operators not supported + EventMappingWidget() = delete; + EventMappingWidget(const EventMappingWidget&) = delete; + EventMappingWidget(EventMappingWidget&&) = delete; + EventMappingWidget& operator=(const EventMappingWidget&) = delete; + EventMappingWidget& operator=(EventMappingWidget&&) = delete; }; #endif diff --git a/src/gui/FileListWidget.hxx b/src/gui/FileListWidget.hxx index 69970f581..8bda7d3ea 100644 --- a/src/gui/FileListWidget.hxx +++ b/src/gui/FileListWidget.hxx @@ -74,6 +74,14 @@ class FileListWidget : public StringListWidget string _extension; GameList _gameList; + + private: + // Following constructors and assignment operators not supported + FileListWidget() = delete; + FileListWidget(const FileListWidget&) = delete; + FileListWidget(FileListWidget&&) = delete; + FileListWidget& operator=(const FileListWidget&) = delete; + FileListWidget& operator=(FileListWidget&&) = delete; }; #endif diff --git a/src/gui/Font.hxx b/src/gui/Font.hxx index 84ee67e83..52beb01f5 100644 --- a/src/gui/Font.hxx +++ b/src/gui/Font.hxx @@ -71,6 +71,14 @@ class Font private: FontDesc myFontDesc; + + private: + // Following constructors and assignment operators not supported + Font() = delete; + Font(const Font&) = delete; + Font(Font&&) = delete; + Font& operator=(const Font&) = delete; + Font& operator=(Font&&) = delete; }; } // namespace GUI diff --git a/src/gui/GameInfoDialog.hxx b/src/gui/GameInfoDialog.hxx index bc4c7f278..b0e66afdc 100644 --- a/src/gui/GameInfoDialog.hxx +++ b/src/gui/GameInfoDialog.hxx @@ -100,6 +100,14 @@ class GameInfoDialog : public Dialog, public CommandSender // Indicates that the default properties have been loaded bool myDefaultsSelected; + + private: + // Following constructors and assignment operators not supported + GameInfoDialog() = delete; + GameInfoDialog(const GameInfoDialog&) = delete; + GameInfoDialog(GameInfoDialog&&) = delete; + GameInfoDialog& operator=(const GameInfoDialog&) = delete; + GameInfoDialog& operator=(GameInfoDialog&&) = delete; }; #endif diff --git a/src/gui/GameList.hxx b/src/gui/GameList.hxx index 0caff9652..7a9a1aa11 100644 --- a/src/gui/GameList.hxx +++ b/src/gui/GameList.hxx @@ -65,6 +65,13 @@ class GameList : _name(name), _path(path), _md5(md5), _isdir(isdir) { } }; vector myArray; + + private: + // Following constructors and assignment operators not supported + GameList(const GameList&) = delete; + GameList(GameList&&) = delete; + GameList& operator=(const GameList&) = delete; + GameList& operator=(GameList&&) = delete; }; #endif diff --git a/src/gui/GlobalPropsDialog.hxx b/src/gui/GlobalPropsDialog.hxx index 1138335e0..0822593ea 100644 --- a/src/gui/GlobalPropsDialog.hxx +++ b/src/gui/GlobalPropsDialog.hxx @@ -61,6 +61,14 @@ class GlobalPropsDialog : public Dialog, public CommandSender CheckboxWidget* myHoldReset; static const char* ourJoyState[10]; + + private: + // Following constructors and assignment operators not supported + GlobalPropsDialog() = delete; + GlobalPropsDialog(const GlobalPropsDialog&) = delete; + GlobalPropsDialog(GlobalPropsDialog&&) = delete; + GlobalPropsDialog& operator=(const GlobalPropsDialog&) = delete; + GlobalPropsDialog& operator=(GlobalPropsDialog&&) = delete; }; #endif diff --git a/src/gui/GuiObject.hxx b/src/gui/GuiObject.hxx index 953a79cf8..84fa090c2 100644 --- a/src/gui/GuiObject.hxx +++ b/src/gui/GuiObject.hxx @@ -111,6 +111,14 @@ class GuiObject : public CommandReceiver Widget* _firstWidget; WidgetArray _focusList; + + private: + // Following constructors and assignment operators not supported + GuiObject() = delete; + GuiObject(const GuiObject&) = delete; + GuiObject(GuiObject&&) = delete; + GuiObject& operator=(const GuiObject&) = delete; + GuiObject& operator=(GuiObject&&) = delete; }; #endif diff --git a/src/gui/HelpDialog.hxx b/src/gui/HelpDialog.hxx index c41e2af6a..95fc9c95f 100644 --- a/src/gui/HelpDialog.hxx +++ b/src/gui/HelpDialog.hxx @@ -54,6 +54,14 @@ class HelpDialog : public Dialog void updateStrings(uInt8 page, uInt8 lines, string& title); void displayInfo(); void loadConfig() { displayInfo(); } + + private: + // Following constructors and assignment operators not supported + HelpDialog() = delete; + HelpDialog(const HelpDialog&) = delete; + HelpDialog(HelpDialog&&) = delete; + HelpDialog& operator=(const HelpDialog&) = delete; + HelpDialog& operator=(HelpDialog&&) = delete; }; #endif diff --git a/src/gui/InputDialog.hxx b/src/gui/InputDialog.hxx index 08c18a349..9c08a96fd 100644 --- a/src/gui/InputDialog.hxx +++ b/src/gui/InputDialog.hxx @@ -88,6 +88,14 @@ class InputDialog : public Dialog // Show the list of joysticks that the eventhandler knows about unique_ptr myJoyDialog; + + private: + // Following constructors and assignment operators not supported + InputDialog() = delete; + InputDialog(const InputDialog&) = delete; + InputDialog(InputDialog&&) = delete; + InputDialog& operator=(const InputDialog&) = delete; + InputDialog& operator=(InputDialog&&) = delete; }; #endif diff --git a/src/gui/InputTextDialog.hxx b/src/gui/InputTextDialog.hxx index 7ecdcda64..ac05263dc 100644 --- a/src/gui/InputTextDialog.hxx +++ b/src/gui/InputTextDialog.hxx @@ -70,6 +70,14 @@ class InputTextDialog : public Dialog, public CommandSender int myCmd; uInt32 myXOrig, myYOrig; + + private: + // Following constructors and assignment operators not supported + InputTextDialog() = delete; + InputTextDialog(const InputTextDialog&) = delete; + InputTextDialog(InputTextDialog&&) = delete; + InputTextDialog& operator=(const InputTextDialog&) = delete; + InputTextDialog& operator=(InputTextDialog&&) = delete; }; #endif diff --git a/src/gui/JoystickDialog.hxx b/src/gui/JoystickDialog.hxx index 58a482729..143ca3cec 100644 --- a/src/gui/JoystickDialog.hxx +++ b/src/gui/JoystickDialog.hxx @@ -57,6 +57,14 @@ class JoystickDialog : public Dialog IntArray myJoyIDs; enum { kRemoveCmd = 'JDrm' }; + + private: + // Following constructors and assignment operators not supported + JoystickDialog() = delete; + JoystickDialog(const JoystickDialog&) = delete; + JoystickDialog(JoystickDialog&&) = delete; + JoystickDialog& operator=(const JoystickDialog&) = delete; + JoystickDialog& operator=(JoystickDialog&&) = delete; }; #endif diff --git a/src/gui/Launcher.hxx b/src/gui/Launcher.hxx index a5e43870d..31796175e 100644 --- a/src/gui/Launcher.hxx +++ b/src/gui/Launcher.hxx @@ -70,6 +70,14 @@ class Launcher : public DialogContainer // The width and height of this dialog uInt32 myWidth; uInt32 myHeight; + + private: + // Following constructors and assignment operators not supported + Launcher() = delete; + Launcher(const Launcher&) = delete; + Launcher(Launcher&&) = delete; + Launcher& operator=(const Launcher&) = delete; + Launcher& operator=(Launcher&&) = delete; }; #endif diff --git a/src/gui/LauncherDialog.cxx b/src/gui/LauncherDialog.cxx index f8189c239..cac466523 100644 --- a/src/gui/LauncherDialog.cxx +++ b/src/gui/LauncherDialog.cxx @@ -209,7 +209,7 @@ const string& LauncherDialog::selectedRomMD5() // Make sure we have a valid md5 for this ROM if(myGameList->md5(item) == "") - myGameList->setMd5(item, MD5(node)); + myGameList->setMd5(item, MD5::hash(node)); return myGameList->md5(item); } @@ -347,7 +347,7 @@ void LauncherDialog::loadRomInfo() { // Make sure we have a valid md5 for this ROM if(myGameList->md5(item) == "") - myGameList->setMd5(item, MD5(node)); + myGameList->setMd5(item, MD5::hash(node)); // Get the properties for this entry Properties props; diff --git a/src/gui/LauncherDialog.hxx b/src/gui/LauncherDialog.hxx index 6dc22740d..0ac74dfc4 100644 --- a/src/gui/LauncherDialog.hxx +++ b/src/gui/LauncherDialog.hxx @@ -129,6 +129,14 @@ class LauncherDialog : public Dialog kFirstRunMsgChosenCmd = 'frmc', kStartupRomDirChosenCmd = 'rmsc' }; + + private: + // Following constructors and assignment operators not supported + LauncherDialog() = delete; + LauncherDialog(const LauncherDialog&) = delete; + LauncherDialog(LauncherDialog&&) = delete; + LauncherDialog& operator=(const LauncherDialog&) = delete; + LauncherDialog& operator=(LauncherDialog&&) = delete; }; #endif diff --git a/src/gui/LauncherFilterDialog.hxx b/src/gui/LauncherFilterDialog.hxx index 3957122b2..001636b22 100644 --- a/src/gui/LauncherFilterDialog.hxx +++ b/src/gui/LauncherFilterDialog.hxx @@ -75,6 +75,14 @@ class LauncherFilterDialog : public Dialog, public CommandSender // Holds static strings representing ROM types static const char* ourRomTypes[2][5]; + + private: + // Following constructors and assignment operators not supported + LauncherFilterDialog() = delete; + LauncherFilterDialog(const LauncherFilterDialog&) = delete; + LauncherFilterDialog(LauncherFilterDialog&&) = delete; + LauncherFilterDialog& operator=(const LauncherFilterDialog&) = delete; + LauncherFilterDialog& operator=(LauncherFilterDialog&&) = delete; }; #endif diff --git a/src/gui/ListWidget.hxx b/src/gui/ListWidget.hxx index 5bcb3d838..ff98aed62 100644 --- a/src/gui/ListWidget.hxx +++ b/src/gui/ListWidget.hxx @@ -115,6 +115,14 @@ class ListWidget : public EditableWidget private: static uInt64 _QUICK_SELECT_DELAY; + + private: + // Following constructors and assignment operators not supported + ListWidget() = delete; + ListWidget(const ListWidget&) = delete; + ListWidget(ListWidget&&) = delete; + ListWidget& operator=(const ListWidget&) = delete; + ListWidget& operator=(ListWidget&&) = delete; }; #endif diff --git a/src/gui/LoggerDialog.hxx b/src/gui/LoggerDialog.hxx index 12aa6b35d..c278ba7ed 100644 --- a/src/gui/LoggerDialog.hxx +++ b/src/gui/LoggerDialog.hxx @@ -47,6 +47,14 @@ class LoggerDialog : public Dialog StringListWidget* myLogInfo; PopUpWidget* myLogLevel; CheckboxWidget* myLogToConsole; + + private: + // Following constructors and assignment operators not supported + LoggerDialog() = delete; + LoggerDialog(const LoggerDialog&) = delete; + LoggerDialog(LoggerDialog&&) = delete; + LoggerDialog& operator=(const LoggerDialog&) = delete; + LoggerDialog& operator=(LoggerDialog&&) = delete; }; #endif diff --git a/src/gui/Menu.hxx b/src/gui/Menu.hxx index 7f95a4b58..3f330123b 100644 --- a/src/gui/Menu.hxx +++ b/src/gui/Menu.hxx @@ -42,6 +42,14 @@ class Menu : public DialogContainer Destructor */ virtual ~Menu(); + + private: + // Following constructors and assignment operators not supported + Menu() = delete; + Menu(const Menu&) = delete; + Menu(Menu&&) = delete; + Menu& operator=(const Menu&) = delete; + Menu& operator=(Menu&&) = delete; }; #endif diff --git a/src/gui/MessageBox.hxx b/src/gui/MessageBox.hxx index 8fd0534d6..f2570a26a 100644 --- a/src/gui/MessageBox.hxx +++ b/src/gui/MessageBox.hxx @@ -54,6 +54,14 @@ class MessageBox : public Dialog, public CommandSender private: int myCmd; + + private: + // Following constructors and assignment operators not supported + MessageBox() = delete; + MessageBox(const MessageBox&) = delete; + MessageBox(MessageBox&&) = delete; + MessageBox& operator=(const MessageBox&) = delete; + MessageBox& operator=(MessageBox&&) = delete; }; } // namespace GUI diff --git a/src/gui/OptionsDialog.hxx b/src/gui/OptionsDialog.hxx index 732b069ac..b1e9acdb2 100644 --- a/src/gui/OptionsDialog.hxx +++ b/src/gui/OptionsDialog.hxx @@ -87,6 +87,14 @@ class OptionsDialog : public Dialog kAboutCmd = 'ABOU', kExitCmd = 'EXIM' }; + + private: + // Following constructors and assignment operators not supported + OptionsDialog() = delete; + OptionsDialog(const OptionsDialog&) = delete; + OptionsDialog(OptionsDialog&&) = delete; + OptionsDialog& operator=(const OptionsDialog&) = delete; + OptionsDialog& operator=(OptionsDialog&&) = delete; }; #endif diff --git a/src/gui/PopUpWidget.hxx b/src/gui/PopUpWidget.hxx index deb63ff9e..52620d917 100644 --- a/src/gui/PopUpWidget.hxx +++ b/src/gui/PopUpWidget.hxx @@ -76,6 +76,14 @@ class PopUpWidget : public Widget, public CommandSender string _label; int _labelWidth; + + private: + // Following constructors and assignment operators not supported + PopUpWidget() = delete; + PopUpWidget(const PopUpWidget&) = delete; + PopUpWidget(PopUpWidget&&) = delete; + PopUpWidget& operator=(const PopUpWidget&) = delete; + PopUpWidget& operator=(PopUpWidget&&) = delete; }; #endif diff --git a/src/gui/ProgressDialog.hxx b/src/gui/ProgressDialog.hxx index f421dafff..37851502c 100644 --- a/src/gui/ProgressDialog.hxx +++ b/src/gui/ProgressDialog.hxx @@ -42,6 +42,14 @@ class ProgressDialog : public Dialog SliderWidget* mySlider; int myStart, myFinish, myStep, myCurrentStep; + + private: + // Following constructors and assignment operators not supported + ProgressDialog() = delete; + ProgressDialog(const ProgressDialog&) = delete; + ProgressDialog(ProgressDialog&&) = delete; + ProgressDialog& operator=(const ProgressDialog&) = delete; + ProgressDialog& operator=(ProgressDialog&&) = delete; }; #endif diff --git a/src/gui/RomAuditDialog.cxx b/src/gui/RomAuditDialog.cxx index 8dc6a5fbc..d4c41234d 100644 --- a/src/gui/RomAuditDialog.cxx +++ b/src/gui/RomAuditDialog.cxx @@ -142,7 +142,7 @@ void RomAuditDialog::auditRoms() { // Calculate the MD5 so we can get the rest of the info // from the PropertiesSet (stella.pro) - const string& md5 = MD5(files[idx]); + const string& md5 = MD5::hash(files[idx]); instance().propSet().getMD5(md5, props); const string& name = props.get(Cartridge_Name); diff --git a/src/gui/RomAuditDialog.hxx b/src/gui/RomAuditDialog.hxx index 024b6eecd..7dd06b23b 100644 --- a/src/gui/RomAuditDialog.hxx +++ b/src/gui/RomAuditDialog.hxx @@ -68,6 +68,14 @@ class RomAuditDialog : public Dialog // Maximum width and height for this dialog int myMaxWidth, myMaxHeight; + + private: + // Following constructors and assignment operators not supported + RomAuditDialog() = delete; + RomAuditDialog(const RomAuditDialog&) = delete; + RomAuditDialog(RomAuditDialog&&) = delete; + RomAuditDialog& operator=(const RomAuditDialog&) = delete; + RomAuditDialog& operator=(RomAuditDialog&&) = delete; }; #endif diff --git a/src/gui/RomInfoWidget.hxx b/src/gui/RomInfoWidget.hxx index 32e22d47b..b7c458146 100644 --- a/src/gui/RomInfoWidget.hxx +++ b/src/gui/RomInfoWidget.hxx @@ -67,6 +67,14 @@ class RomInfoWidget : public Widget // How much space available for the PNG image GUI::Size myAvail; + + private: + // Following constructors and assignment operators not supported + RomInfoWidget() = delete; + RomInfoWidget(const RomInfoWidget&) = delete; + RomInfoWidget(RomInfoWidget&&) = delete; + RomInfoWidget& operator=(const RomInfoWidget&) = delete; + RomInfoWidget& operator=(RomInfoWidget&&) = delete; }; #endif diff --git a/src/gui/ScrollBarWidget.hxx b/src/gui/ScrollBarWidget.hxx index 6158c32e9..7f26e35c3 100644 --- a/src/gui/ScrollBarWidget.hxx +++ b/src/gui/ScrollBarWidget.hxx @@ -32,8 +32,6 @@ enum { class ScrollBarWidget : public Widget, public CommandSender { - protected: - public: ScrollBarWidget(GuiObject* boss, const GUI::Font& font, int x, int y, int w, int h); @@ -78,6 +76,14 @@ class ScrollBarWidget : public Widget, public CommandSender int _sliderDeltaMouseDownPos; static int _WHEEL_LINES; + + private: + // Following constructors and assignment operators not supported + ScrollBarWidget() = delete; + ScrollBarWidget(const ScrollBarWidget&) = delete; + ScrollBarWidget(ScrollBarWidget&&) = delete; + ScrollBarWidget& operator=(const ScrollBarWidget&) = delete; + ScrollBarWidget& operator=(ScrollBarWidget&&) = delete; }; #endif diff --git a/src/gui/SnapshotDialog.hxx b/src/gui/SnapshotDialog.hxx index 85659a0a9..7d2a30329 100644 --- a/src/gui/SnapshotDialog.hxx +++ b/src/gui/SnapshotDialog.hxx @@ -67,6 +67,14 @@ class SnapshotDialog : public Dialog CheckboxWidget* mySnapSingle; CheckboxWidget* mySnap1x; + + private: + // Following constructors and assignment operators not supported + SnapshotDialog() = delete; + SnapshotDialog(const SnapshotDialog&) = delete; + SnapshotDialog(SnapshotDialog&&) = delete; + SnapshotDialog& operator=(const SnapshotDialog&) = delete; + SnapshotDialog& operator=(SnapshotDialog&&) = delete; }; #endif diff --git a/src/gui/StringListWidget.hxx b/src/gui/StringListWidget.hxx index 9c7936248..be6b5142d 100644 --- a/src/gui/StringListWidget.hxx +++ b/src/gui/StringListWidget.hxx @@ -38,6 +38,14 @@ class StringListWidget : public ListWidget protected: bool _hilite; + + private: + // Following constructors and assignment operators not supported + StringListWidget() = delete; + StringListWidget(const StringListWidget&) = delete; + StringListWidget(StringListWidget&&) = delete; + StringListWidget& operator=(const StringListWidget&) = delete; + StringListWidget& operator=(StringListWidget&&) = delete; }; #endif diff --git a/src/gui/TabWidget.hxx b/src/gui/TabWidget.hxx index dcca3e8a3..55ff62957 100644 --- a/src/gui/TabWidget.hxx +++ b/src/gui/TabWidget.hxx @@ -29,7 +29,7 @@ class TabWidget : public Widget, public CommandSender { public: TabWidget(GuiObject* boss, const GUI::Font& font, int x, int y, int w, int h); - ~TabWidget(); + virtual ~TabWidget(); virtual int getChildY() const; @@ -95,6 +95,14 @@ class TabWidget : public Widget, public CommandSender uInt32 colorA, uInt32 colorB, bool omitBottom); void updateActiveTab(); + + private: + // Following constructors and assignment operators not supported + TabWidget() = delete; + TabWidget(const TabWidget&) = delete; + TabWidget(TabWidget&&) = delete; + TabWidget& operator=(const TabWidget&) = delete; + TabWidget& operator=(TabWidget&&) = delete; }; #endif diff --git a/src/gui/UIDialog.hxx b/src/gui/UIDialog.hxx index b5ceaefb2..0944cb2df 100644 --- a/src/gui/UIDialog.hxx +++ b/src/gui/UIDialog.hxx @@ -79,6 +79,14 @@ class UIDialog : public Dialog kDMediumSize = 'UIdm', kDLargeSize = 'UIdl' }; + + private: + // Following constructors and assignment operators not supported + UIDialog() = delete; + UIDialog(const UIDialog&) = delete; + UIDialog(UIDialog&&) = delete; + UIDialog& operator=(const UIDialog&) = delete; + UIDialog& operator=(UIDialog&&) = delete; }; #endif diff --git a/src/gui/VideoDialog.hxx b/src/gui/VideoDialog.hxx index 5b734d9cc..185bdabd1 100644 --- a/src/gui/VideoDialog.hxx +++ b/src/gui/VideoDialog.hxx @@ -133,6 +133,14 @@ class VideoDialog : public Dialog kCloneBadCmd = 'CLbd', kCloneCustomCmd = 'CLcu' }; + + private: + // Following constructors and assignment operators not supported + VideoDialog() = delete; + VideoDialog(const VideoDialog&) = delete; + VideoDialog(VideoDialog&&) = delete; + VideoDialog& operator=(const VideoDialog&) = delete; + VideoDialog& operator=(VideoDialog&&) = delete; }; #endif diff --git a/src/gui/Widget.hxx b/src/gui/Widget.hxx index f4f89ca76..c82bce6d6 100644 --- a/src/gui/Widget.hxx +++ b/src/gui/Widget.hxx @@ -157,6 +157,14 @@ class Widget : public GuiObject /** Sets all widgets in this chain to be dirty (must be redrawn) */ static void setDirtyInChain(Widget* start); + + private: + // Following constructors and assignment operators not supported + Widget() = delete; + Widget(const Widget&) = delete; + Widget(Widget&&) = delete; + Widget& operator=(const Widget&) = delete; + Widget& operator=(Widget&&) = delete; }; @@ -179,6 +187,14 @@ class StaticTextWidget : public Widget string _label; bool _editable; TextAlignment _align; + + private: + // Following constructors and assignment operators not supported + StaticTextWidget() = delete; + StaticTextWidget(const StaticTextWidget&) = delete; + StaticTextWidget(StaticTextWidget&&) = delete; + StaticTextWidget& operator=(const StaticTextWidget&) = delete; + StaticTextWidget& operator=(StaticTextWidget&&) = delete; }; @@ -203,6 +219,14 @@ class ButtonWidget : public StaticTextWidget, public CommandSender protected: int _cmd; + + private: + // Following constructors and assignment operators not supported + ButtonWidget() = delete; + ButtonWidget(const ButtonWidget&) = delete; + ButtonWidget(ButtonWidget&&) = delete; + ButtonWidget& operator=(const ButtonWidget&) = delete; + ButtonWidget& operator=(ButtonWidget&&) = delete; }; @@ -245,6 +269,14 @@ class CheckboxWidget : public ButtonWidget private: int _boxY; int _textY; + + private: + // Following constructors and assignment operators not supported + CheckboxWidget() = delete; + CheckboxWidget(const CheckboxWidget&) = delete; + CheckboxWidget(CheckboxWidget&&) = delete; + CheckboxWidget& operator=(const CheckboxWidget&) = delete; + CheckboxWidget& operator=(CheckboxWidget&&) = delete; }; @@ -283,6 +315,14 @@ class SliderWidget : public ButtonWidget int _valueMin, _valueMax; bool _isDragging; int _labelWidth; + + private: + // Following constructors and assignment operators not supported + SliderWidget() = delete; + SliderWidget(const SliderWidget&) = delete; + SliderWidget(SliderWidget&&) = delete; + SliderWidget& operator=(const SliderWidget&) = delete; + SliderWidget& operator=(SliderWidget&&) = delete; }; #endif diff --git a/src/macosx/OSystemMACOSX.hxx b/src/macosx/OSystemMACOSX.hxx index 9838d7e67..7cb08f3ac 100644 --- a/src/macosx/OSystemMACOSX.hxx +++ b/src/macosx/OSystemMACOSX.hxx @@ -46,6 +46,13 @@ class OSystemMACOSX : public OSystem */ string defaultSnapSaveDir(); string defaultSnapLoadDir(); + + private: + // Following constructors and assignment operators not supported + OSystemMACOSX(const OSystemMACOSX&) = delete; + OSystemMACOSX(OSystemMACOSX&&) = delete; + OSystemMACOSX& operator=(const OSystemMACOSX&) = delete; + OSystemMACOSX& operator=(OSystemMACOSX&&) = delete; }; #endif diff --git a/src/macosx/SerialPortMACOSX.hxx b/src/macosx/SerialPortMACOSX.hxx index 7221498f7..91f8b8547 100644 --- a/src/macosx/SerialPortMACOSX.hxx +++ b/src/macosx/SerialPortMACOSX.hxx @@ -59,6 +59,13 @@ class SerialPortMACOSX : public SerialPort private: // File descriptor for serial connection int myHandle; + + private: + // Following constructors and assignment operators not supported + SerialPortMACOSX(const SerialPortMACOSX&) = delete; + SerialPortMACOSX(SerialPortMACOSX&&) = delete; + SerialPortMACOSX& operator=(const SerialPortMACOSX&) = delete; + SerialPortMACOSX& operator=(SerialPortMACOSX&&) = delete; }; #endif diff --git a/src/macosx/SettingsMACOSX.hxx b/src/macosx/SettingsMACOSX.hxx index 0a6fe1c82..143c3e410 100644 --- a/src/macosx/SettingsMACOSX.hxx +++ b/src/macosx/SettingsMACOSX.hxx @@ -55,6 +55,14 @@ class SettingsMACOSX : public Settings standard Mac preferences. */ void saveConfig(); + + private: + // Following constructors and assignment operators not supported + SettingsMACOSX() = delete; + SettingsMACOSX(const SettingsMACOSX&) = delete; + SettingsMACOSX(SettingsMACOSX&&) = delete; + SettingsMACOSX& operator=(const SettingsMACOSX&) = delete; + SettingsMACOSX& operator=(SettingsMACOSX&&) = delete; }; #endif diff --git a/src/unix/OSystemUNIX.hxx b/src/unix/OSystemUNIX.hxx index ea26a1a05..a56c2c3cb 100644 --- a/src/unix/OSystemUNIX.hxx +++ b/src/unix/OSystemUNIX.hxx @@ -40,6 +40,13 @@ class OSystemUNIX : public OSystem Destructor */ virtual ~OSystemUNIX(); + + private: + // Following constructors and assignment operators not supported + OSystemUNIX(const OSystemUNIX&) = delete; + OSystemUNIX(OSystemUNIX&&) = delete; + OSystemUNIX& operator=(const OSystemUNIX&) = delete; + OSystemUNIX& operator=(OSystemUNIX&&) = delete; }; #endif diff --git a/src/unix/SettingsUNIX.hxx b/src/unix/SettingsUNIX.hxx index 5ca0e02b4..d84456483 100644 --- a/src/unix/SettingsUNIX.hxx +++ b/src/unix/SettingsUNIX.hxx @@ -42,6 +42,14 @@ class SettingsUNIX : public Settings Destructor */ virtual ~SettingsUNIX(); + + private: + // Following constructors and assignment operators not supported + SettingsUNIX() = delete; + SettingsUNIX(const SettingsUNIX&) = delete; + SettingsUNIX(SettingsUNIX&&) = delete; + SettingsUNIX& operator=(const SettingsUNIX&) = delete; + SettingsUNIX& operator=(SettingsUNIX&&) = delete; }; #endif diff --git a/src/windows/HomeFinder.hxx b/src/windows/HomeFinder.hxx index 7215ad674..89157f1d3 100644 --- a/src/windows/HomeFinder.hxx +++ b/src/windows/HomeFinder.hxx @@ -107,13 +107,19 @@ class HomeFinder return ourDesktopPath; } - private: - typedef HRESULT (__stdcall * function_pointer)(HWND, int, HANDLE, DWORD, LPCSTR); + private: + typedef HRESULT (__stdcall * function_pointer)(HWND, int, HANDLE, DWORD, LPCSTR); - HMODULE myFolderModule; - function_pointer myFolderPathFunc; + HMODULE myFolderModule; + function_pointer myFolderPathFunc; - static string ourHomePath, ourAppDataPath, ourDesktopPath; + static string ourHomePath, ourAppDataPath, ourDesktopPath; + + // Following constructors and assignment operators not supported + HomeFinder(const HomeFinder&) = delete; + HomeFinder(HomeFinder&&) = delete; + HomeFinder& operator=(const HomeFinder&) = delete; + HomeFinder& operator=(HomeFinder&&) = delete; }; __declspec(selectany) string HomeFinder::ourHomePath = ""; diff --git a/src/windows/OSystemWINDOWS.hxx b/src/windows/OSystemWINDOWS.hxx index 17510f6f7..f946aaf2b 100644 --- a/src/windows/OSystemWINDOWS.hxx +++ b/src/windows/OSystemWINDOWS.hxx @@ -47,6 +47,13 @@ class OSystemWINDOWS : public OSystem */ string defaultSnapSaveDir(); string defaultSnapLoadDir(); + + private: + // Following constructors and assignment operators not supported + OSystemWINDOWS(const OSystemWINDOWS&) = delete; + OSystemWINDOWS(OSystemWINDOWS&&) = delete; + OSystemWINDOWS& operator=(const OSystemWINDOWS&) = delete; + OSystemWINDOWS& operator=(OSystemWINDOWS&&) = delete; }; #endif diff --git a/src/windows/SerialPortWINDOWS.hxx b/src/windows/SerialPortWINDOWS.hxx index 15f5591f8..6b9910a78 100644 --- a/src/windows/SerialPortWINDOWS.hxx +++ b/src/windows/SerialPortWINDOWS.hxx @@ -60,6 +60,13 @@ class SerialPortWINDOWS : public SerialPort private: // Handle to serial port HANDLE myHandle; + + private: + // Following constructors and assignment operators not supported + SerialPortWINDOWS(const SerialPortWINDOWS&) = delete; + SerialPortWINDOWS(SerialPortWINDOWS&&) = delete; + SerialPortWINDOWS& operator=(const SerialPortWINDOWS&) = delete; + SerialPortWINDOWS& operator=(SerialPortWINDOWS&&) = delete; }; #endif diff --git a/src/windows/SettingsWINDOWS.hxx b/src/windows/SettingsWINDOWS.hxx index fad56bfcd..abd1f70e9 100644 --- a/src/windows/SettingsWINDOWS.hxx +++ b/src/windows/SettingsWINDOWS.hxx @@ -36,6 +36,14 @@ class SettingsWINDOWS : public Settings Destructor */ virtual ~SettingsWINDOWS(); + + private: + // Following constructors and assignment operators not supported + SettingsWINDOWS() = delete; + SettingsWINDOWS(const SettingsWINDOWS&) = delete; + SettingsWINDOWS(SettingsWINDOWS&&) = delete; + SettingsWINDOWS& operator=(const SettingsWINDOWS&) = delete; + SettingsWINDOWS& operator=(SettingsWINDOWS&&) = delete; }; #endif