ShuriZma
/
stella
mirror of https://github.com/stella-emu/stella.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Move to C++14, now that all the minimum required compilers support it. 

Clang 3.8, gcc 5, Visual Studio 2017 and Xcode 8 are now the minimum
supported compilers, and they all support C++14, so we may as well use it.

 - Change all make_ptr to make_unique
 - Change iterator begin(), end(), etc to const versions where appropriate
 - Remove UniquePtr, since C++14 supports it natively
This commit is contained in:
Stephen Anthony 2017-07-21 21:10:13 -02:30
parent 5c114e69d2
commit cd689941b6
55 changed files with 220 additions and 289 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@ -51,7 +51,7 @@ else
endif
CXXFLAGS+= -Wall -Wextra -Wno-unused-parameter -Wno-ignored-qualifiers
ifdef HAVE_GCC
CXXFLAGS+= -Wno-multichar -Wunused -fno-rtti -Woverloaded-virtual -Wnon-virtual-dtor -std=c++11
CXXFLAGS+= -Wno-multichar -Wunused -fno-rtti -Woverloaded-virtual -Wnon-virtual-dtor -std=c++14
endif
ifdef PROFILE

2
configure vendored
View File

@ -360,7 +360,7 @@ else
fi
for compiler in $compilers; do
if test_compiler "$compiler -std=c++11"; then
if test_compiler "$compiler -std=c++14"; then
CXX=$compiler
echo $CXX
break

2
src/cheat/CheatCodeDialog.cxx
View File

@ -81,7 +81,7 @@ CheatCodeDialog::CheatCodeDialog(OSystem& osystem, DialogContainer& parent,
StringList labels;
labels.push_back("Name ");
labels.push_back("Code (hex) ");
myCheatInput = make_ptr<InputTextDialog>(this, font, labels);
myCheatInput = make_unique<InputTextDialog>(this, font, labels);
myCheatInput->setTarget(this);
// Add filtering for each textfield

2
src/common/FSNodeZIP.cxx
View File

@ -207,4 +207,4 @@ AbstractFSNode* FilesystemNodeZIP::getParent() const
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
unique_ptr<ZipHandler> FilesystemNodeZIP::myZipHandler = make_ptr<ZipHandler>();
unique_ptr<ZipHandler> FilesystemNodeZIP::myZipHandler = make_unique<ZipHandler>();

2
src/common/FrameBufferSDL2.cxx
View File

@ -287,7 +287,7 @@ void FrameBufferSDL2::setWindowIcon()
unique_ptr<FBSurface> FrameBufferSDL2::createSurface(uInt32 w, uInt32 h,
const uInt32* data) const
{
return make_ptr<FBSurfaceSDL2>(const_cast<FrameBufferSDL2&>(*this), w, h, data);
return make_unique<FBSurfaceSDL2>(const_cast<FrameBufferSDL2&>(*this), w, h, data);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

28
src/common/MediaFactory.hxx
View File

@ -67,11 +67,11 @@ class MediaFactory
static unique_ptr<OSystem> createOSystem()
{
#if defined(BSPF_UNIX)
return make_ptr<OSystemUNIX>();
return make_unique<OSystemUNIX>();
#elif defined(BSPF_WINDOWS)
return make_ptr<OSystemWINDOWS>();
return make_unique<OSystemWINDOWS>();
#elif defined(BSPF_MAC_OSX)
return make_ptr<OSystemMACOSX>();
return make_unique<OSystemMACOSX>();
#else
#error Unsupported platform for OSystem!
#endif
@ -80,11 +80,11 @@ class MediaFactory
static unique_ptr<Settings> createSettings(OSystem& osystem)
{
#if defined(BSPF_UNIX)
return make_ptr<SettingsUNIX>(osystem);
return make_unique<SettingsUNIX>(osystem);
#elif defined(BSPF_WINDOWS)
return make_ptr<SettingsWINDOWS>(osystem);
return make_unique<SettingsWINDOWS>(osystem);
#elif defined(BSPF_MAC_OSX)
return make_ptr<SettingsMACOSX>(osystem);
return make_unique<SettingsMACOSX>(osystem);
#else
#error Unsupported platform for Settings!
#endif
@ -93,33 +93,33 @@ class MediaFactory
static unique_ptr<SerialPort> createSerialPort()
{
#if defined(BSPF_UNIX)
return make_ptr<SerialPortUNIX>();
return make_unique<SerialPortUNIX>();
#elif defined(BSPF_WINDOWS)
return make_ptr<SerialPortWINDOWS>();
return make_unique<SerialPortWINDOWS>();
#elif defined(BSPF_MAC_OSX)
return make_ptr<SerialPortMACOSX>();
return make_unique<SerialPortMACOSX>();
#else
return make_ptr<SerialPort>();
return make_unique<SerialPort>();
#endif
}
static unique_ptr<FrameBuffer> createVideo(OSystem& osystem)
{
return make_ptr<FrameBufferSDL2>(osystem);
return make_unique<FrameBufferSDL2>(osystem);
}
static unique_ptr<Sound> createAudio(OSystem& osystem)
{
#ifdef SOUND_SUPPORT
return make_ptr<SoundSDL2>(osystem);
return make_unique<SoundSDL2>(osystem);
#else
return make_ptr<SoundNull>(osystem);
return make_unique<SoundNull>(osystem);
#endif
}
static unique_ptr<EventHandler> createEventHandler(OSystem& osystem)
{
return make_ptr<EventHandlerSDL2>(osystem);
return make_unique<EventHandlerSDL2>(osystem);
}
private:

14
src/common/PNGLibrary.cxx
View File

@ -125,11 +125,11 @@ void PNGLibrary::saveImage(const string& filename, const VariantList& comments)
png_uint_32 width = rect.width(), height = rect.height();
// Get framebuffer pixel data (we get ABGR format)
unique_ptr<png_byte[]> buffer = make_ptr<png_byte[]>(width * height * 4);
unique_ptr<png_byte[]> buffer = make_unique<png_byte[]>(width * height * 4);
myFB.readPixels(buffer.get(), width*4, rect);
// Set up pointers into "buffer" byte array
unique_ptr<png_bytep[]> rows = make_ptr<png_bytep[]>(height);
unique_ptr<png_bytep[]> rows = make_unique<png_bytep[]>(height);
for(png_uint_32 k = 0; k < height; ++k)
rows[k] = png_bytep(buffer.get() + k*width*4);
@ -154,11 +154,11 @@ void PNGLibrary::saveImage(const string& filename, const FBSurface& surface,
}
// Get the surface pixel data (we get ABGR format)
unique_ptr<png_byte[]> buffer = make_ptr<png_byte[]>(width * height * 4);
unique_ptr<png_byte[]> buffer = make_unique<png_byte[]>(width * height * 4);
surface.readPixels(buffer.get(), width, rect);
// Set up pointers into "buffer" byte array
unique_ptr<png_bytep[]> rows = make_ptr<png_bytep[]>(height);
unique_ptr<png_bytep[]> rows = make_unique<png_bytep[]>(height);
for(png_uint_32 k = 0; k < height; ++k)
rows[k] = png_bytep(buffer.get() + k*width*4);
@ -234,7 +234,7 @@ bool PNGLibrary::allocateStorage(png_uint_32 w, png_uint_32 h)
uInt32 req_buffer_size = w * h * 3;
if(req_buffer_size > ReadInfo.buffer_size)
{
ReadInfo.buffer = make_ptr<png_byte[]>(req_buffer_size);
ReadInfo.buffer = make_unique<png_byte[]>(req_buffer_size);
if(ReadInfo.buffer == nullptr)
return false;
@ -243,7 +243,7 @@ bool PNGLibrary::allocateStorage(png_uint_32 w, png_uint_32 h)
uInt32 req_row_size = h;
if(req_row_size > ReadInfo.row_size)
{
ReadInfo.row_pointers = make_ptr<png_bytep[]>(req_row_size);
ReadInfo.row_pointers = make_unique<png_bytep[]>(req_row_size);
if(ReadInfo.row_pointers == nullptr)
return false;
@ -293,7 +293,7 @@ void PNGLibrary::writeComments(png_structp png_ptr, png_infop info_ptr,
if(numComments == 0)
return;
unique_ptr<png_text[]> text_ptr = make_ptr<png_text[]>(numComments);
unique_ptr<png_text[]> text_ptr = make_unique<png_text[]>(numComments);
for(uInt32 i = 0; i < numComments; ++i)
{
text_ptr[i].key = const_cast<char*>(comments[i].first.c_str());

4
src/common/SoundSDL2.cxx
View File

@ -440,7 +440,7 @@ bool SoundSDL2::load(Serializer& in)
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SoundSDL2::RegWriteQueue::RegWriteQueue(uInt32 capacity)
: myBuffer(make_ptr<RegWrite[]>(capacity)),
: myBuffer(make_unique<RegWrite[]>(capacity)),
myCapacity(capacity),
mySize(0),
myHead(0),
@ -504,7 +504,7 @@ uInt32 SoundSDL2::RegWriteQueue::size() const
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void SoundSDL2::RegWriteQueue::grow()
{
unique_ptr<RegWrite[]> buffer = make_ptr<RegWrite[]>(myCapacity*2);
unique_ptr<RegWrite[]> buffer = make_unique<RegWrite[]>(myCapacity*2);
for(uInt32 i = 0; i < mySize; ++i)
buffer[i] = myBuffer[(myHead + i) % myCapacity];

65
src/common/UniquePtr.hxx
View File

@ -1,65 +0,0 @@
//============================================================================
//
// SSSS tt lll lll
// SS SS tt ll ll
// SS tttttt eeee ll ll aaaa
// SSSS tt ee ee ll ll aa
// SS tt eeeeee ll ll aaaaa -- "An Atari 2600 VCS Emulator"
// SS SS tt ee ll ll aa aa
// SSSS ttt eeeee llll llll aaaaa
//
// Copyright (c) 1995-2017 by Bradford W. Mott, Stephen Anthony
// and the Stella Team
//
// See the file "License.txt" for information on usage and redistribution of
// this file, and for a DISCLAIMER OF ALL WARRANTIES.
//============================================================================
#ifndef UNIQUE_PTR_HXX
#define UNIQUE_PTR_HXX
#include <cstddef>
#include <memory>
#include <type_traits>
#include <utility>
/**
The following templates implement 'make_unique' from C++14, which is
named 'make_ptr' here. Eventually, when compilers are updated, this code
can be removed.
@author Stephen Anthony, based on a C++14 proposal by Stephan T. Lavavej.
*/
namespace std {
template<class T> struct _Unique_if {
typedef unique_ptr<T> _Single_object;
};
template<class T> struct _Unique_if<T[]> {
typedef unique_ptr<T[]> _Unknown_bound;
};
template<class T, size_t N> struct _Unique_if<T[N]> {
typedef void _Known_bound;
};
template<class T, class... Args>
typename _Unique_if<T>::_Single_object
make_ptr(Args&&... args) {
return unique_ptr<T>(new T(std::forward<Args>(args)...));
}
template<class T>
typename _Unique_if<T>::_Unknown_bound
make_ptr(size_t n) {
typedef typename remove_extent<T>::type U;
return unique_ptr<T>(new U[n]());
}
template<class T, class... Args>
typename _Unique_if<T>::_Known_bound
make_ptr(Args&&...) = delete;
}
#endif

6
src/common/Vec.hxx
View File

@ -25,19 +25,19 @@ namespace Vec {
template<class T>
void append(vector<T>& dst, const vector<T>& src)
{
dst.insert(dst.end(), src.begin(), src.end());
dst.insert(dst.cend(), src.cbegin(), src.cend());
}
template<class T>
void insertAt(vector<T>& dst, uInt32 idx, const T& element)
{
dst.insert(dst.begin()+idx, element);
dst.insert(dst.cbegin()+idx, element);
}
template<class T>
void removeAt(vector<T>& dst, uInt32 idx)
{
dst.erase(dst.begin()+idx);
dst.erase(dst.cbegin()+idx);
}
} // Namespace Vec

2
src/common/ZipHandler.cxx
View File

@ -102,7 +102,7 @@ uInt32 ZipHandler::decompress(BytePtr& image)
if(myZip)
{
uInt32 length = myZip->header.uncompressed_length;
image = make_ptr<uInt8[]>(length);
image = make_unique<uInt8[]>(length);
ZipHandler::zip_error err = zip_file_decompress(myZip, image.get(), length);
if(err == ZIPERR_NONE)

9
src/common/bspf.hxx
View File

@ -49,7 +49,6 @@ using uInt64 = uint64_t;
#include <cstdio>
#include <utility>
#include <vector>
#include "UniquePtr.hxx" // only until C++14 compilers are more common
using std::cin;
using std::cout;
@ -67,7 +66,7 @@ using std::istringstream;
using std::stringstream;
using std::unique_ptr;
using std::shared_ptr;
using std::make_ptr;
using std::make_unique;
using std::make_shared;
using std::array;
using std::vector;
@ -163,11 +162,11 @@ namespace BSPF
// starting from 'startpos' in the first string
inline size_t findIgnoreCase(const string& s1, const string& s2, int startpos = 0)
{
auto pos = std::search(s1.begin()+startpos, s1.end(),
s2.begin(), s2.end(), [](char ch1, char ch2) {
auto pos = std::search(s1.cbegin()+startpos, s1.cend(),
s2.cbegin(), s2.cend(), [](char ch1, char ch2) {
return toupper(uInt8(ch1)) == toupper(uInt8(ch2));
});
return pos == s1.end() ? string::npos : size_t(pos - (s1.begin()+startpos));
return pos == s1.cend() ? string::npos : size_t(pos - (s1.cbegin()+startpos));
}
// Test whether the first string ends with the second one (case insensitive)

4
src/debugger/CartDebug.cxx
View File

@ -266,8 +266,8 @@ bool CartDebug::disassemble(bool force)
// Distella expects the addresses to be unique and in sorted order
if(bankChanged || !pcfound)
{
AddressList::iterator i; // TODO - change to C++11 const when available
for(i = addresses.begin(); i != addresses.end(); ++i)
AddressList::const_iterator i;
for(i = addresses.cbegin(); i != addresses.cend(); ++i)
{
if(PC < *i)
{

12
src/debugger/Debugger.cxx
View File

@ -117,13 +117,13 @@ Debugger::Debugger(OSystem& osystem, Console& console)
myHeight(DebuggerDialog::kSmallFontMinH)
{
// Init parser
myParser = make_ptr<DebuggerParser>(*this, osystem.settings());
myParser = make_unique<DebuggerParser>(*this, osystem.settings());
// Create debugger subsystems
myCpuDebug = make_ptr<CpuDebug>(*this, myConsole);
myCartDebug = make_ptr<CartDebug>(*this, myConsole, osystem);
myRiotDebug = make_ptr<RiotDebug>(*this, myConsole);
myTiaDebug = make_ptr<TIADebug>(*this, myConsole);
myCpuDebug = make_unique<CpuDebug>(*this, myConsole);
myCartDebug = make_unique<CartDebug>(*this, myConsole, osystem);
myRiotDebug = make_unique<RiotDebug>(*this, myConsole);
myTiaDebug = make_unique<TIADebug>(*this, myConsole);
// Allow access to this object from any class
// Technically this violates pure OO programming, but since I know
@ -152,7 +152,7 @@ void Debugger::initialize()
myDialog = new DebuggerDialog(myOSystem, *this, 0, 0, myWidth, myHeight);
myBaseDialog = myDialog;
myRewindManager = make_ptr<RewindManager>(myOSystem, myDialog->rewindButton());
myRewindManager = make_unique<RewindManager>(myOSystem, myDialog->rewindButton());
myCartDebug->setDebugWidget(&(myDialog->cartDebug()));
}

2
src/debugger/DiStella.cxx
View File

@ -42,7 +42,7 @@ DiStella::DiStella(const CartDebug& dbg, CartDebug::DisassemblyList& list,
bool resolve_code = mySettings.resolve_code;
CartDebug::AddressList::iterator it = addresses.begin();
auto it = addresses.cbegin();
uInt16 start = *it++;
myOffset = info.offset;

38
src/debugger/gui/DebuggerDialog.cxx
View File

@ -210,53 +210,53 @@ void DebuggerDialog::createFont()
if(_w >= kLargeFontMinW && _h >= kLargeFontMinH)
{
// Large font doesn't use fontstyle at all
myLFont = make_ptr<GUI::Font>(GUI::stellaMediumDesc);
myNFont = make_ptr<GUI::Font>(GUI::stellaMediumDesc);
myLFont = make_unique<GUI::Font>(GUI::stellaMediumDesc);
myNFont = make_unique<GUI::Font>(GUI::stellaMediumDesc);
}
else if(_w >= kMediumFontMinW && _h >= kMediumFontMinH)
{
if(fontstyle == 1)
{
myLFont = make_ptr<GUI::Font>(GUI::consoleMediumBDesc);
myNFont = make_ptr<GUI::Font>(GUI::consoleMediumDesc);
myLFont = make_unique<GUI::Font>(GUI::consoleMediumBDesc);
myNFont = make_unique<GUI::Font>(GUI::consoleMediumDesc);
}
else if(fontstyle == 2)
{
myLFont = make_ptr<GUI::Font>(GUI::consoleMediumDesc);
myNFont = make_ptr<GUI::Font>(GUI::consoleMediumBDesc);
myLFont = make_unique<GUI::Font>(GUI::consoleMediumDesc);
myNFont = make_unique<GUI::Font>(GUI::consoleMediumBDesc);
}
else if(fontstyle == 3)
{
myLFont = make_ptr<GUI::Font>(GUI::consoleMediumBDesc);
myNFont = make_ptr<GUI::Font>(GUI::consoleMediumBDesc);
myLFont = make_unique<GUI::Font>(GUI::consoleMediumBDesc);
myNFont = make_unique<GUI::Font>(GUI::consoleMediumBDesc);
}
else // default to zero
{
myLFont = make_ptr<GUI::Font>(GUI::consoleMediumDesc);
myNFont = make_ptr<GUI::Font>(GUI::consoleMediumDesc);
myLFont = make_unique<GUI::Font>(GUI::consoleMediumDesc);
myNFont = make_unique<GUI::Font>(GUI::consoleMediumDesc);
}
}
else
{
if(fontstyle == 1)
{
myLFont = make_ptr<GUI::Font>(GUI::consoleBDesc);
myNFont = make_ptr<GUI::Font>(GUI::consoleDesc);
myLFont = make_unique<GUI::Font>(GUI::consoleBDesc);
myNFont = make_unique<GUI::Font>(GUI::consoleDesc);
}
else if(fontstyle == 2)
{
myLFont = make_ptr<GUI::Font>(GUI::consoleDesc);
myNFont = make_ptr<GUI::Font>(GUI::consoleBDesc);
myLFont = make_unique<GUI::Font>(GUI::consoleDesc);
myNFont = make_unique<GUI::Font>(GUI::consoleBDesc);
}
else if(fontstyle == 3)
{
myLFont = make_ptr<GUI::Font>(GUI::consoleBDesc);
myNFont = make_ptr<GUI::Font>(GUI::consoleBDesc);
myLFont = make_unique<GUI::Font>(GUI::consoleBDesc);
myNFont = make_unique<GUI::Font>(GUI::consoleBDesc);
}
else // default to zero
{
myLFont = make_ptr<GUI::Font>(GUI::consoleDesc);
myNFont = make_ptr<GUI::Font>(GUI::consoleDesc);
myLFont = make_unique<GUI::Font>(GUI::consoleDesc);
myNFont = make_unique<GUI::Font>(GUI::consoleDesc);
}
}
}
@ -264,7 +264,7 @@ void DebuggerDialog::createFont()
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void DebuggerDialog::showFatalMessage(const string& msg)
{
myFatalError = make_ptr<GUI::MessageBox>(this, *myLFont, msg, _w/2, _h/2,
myFatalError = make_unique<GUI::MessageBox>(this, *myLFont, msg, _w/2, _h/2,
kDDExitFatalCmd, "Exit ROM", "Continue");
myFatalError->show();
}

2
src/debugger/gui/RamWidget.cxx
View File

@ -146,7 +146,7 @@ RamWidget::RamWidget(GuiObject* boss, const GUI::Font& lfont, const GUI::Font& n
// Inputbox which will pop up when searching RAM
StringList labels = { "Search " };
myInputBox = make_ptr<InputTextDialog>(boss, lfont, nfont, labels);
myInputBox = make_unique<InputTextDialog>(boss, lfont, nfont, labels);
myInputBox->setTarget(this);
// Start with these buttons disabled

2
src/debugger/gui/RomListWidget.cxx
View File

@ -58,7 +58,7 @@ RomListWidget::RomListWidget(GuiObject* boss, const GUI::Font& lfont,
myScrollBar->setTarget(this);
// Add settings menu
myMenu = make_ptr<RomListSettings>(this, lfont);
myMenu = make_unique<RomListSettings>(this, lfont);
// Take advantage of a wide debugger window when possible
const int fontWidth = lfont.getMaxCharWidth(),

2
src/debugger/gui/TiaOutputWidget.cxx
View File

@ -46,7 +46,7 @@ TiaOutputWidget::TiaOutputWidget(GuiObject* boss, const GUI::Font& font,
VarList::push_back(l, "Set breakpoint", "bp");
VarList::push_back(l, "Set zoom position", "zoom");
VarList::push_back(l, "Save snapshot", "snap");
myMenu = make_ptr<ContextMenu>(this, font, l);
myMenu = make_unique<ContextMenu>(this, font, l);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

2
src/debugger/gui/TiaZoomWidget.cxx
View File

@ -55,7 +55,7 @@ TiaZoomWidget::TiaZoomWidget(GuiObject* boss, const GUI::Font& font,
VarList::push_back(l, "2x zoom", "2");
VarList::push_back(l, "4x zoom", "4");
VarList::push_back(l, "8x zoom", "8");
myMenu = make_ptr<ContextMenu>(this, font, l);
myMenu = make_unique<ContextMenu>(this, font, l);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

2
src/emucore/AtariVox.cxx
View File

@ -35,7 +35,7 @@ AtariVox::AtariVox(Jack jack, const Event& event, const System& system,
else
myAboutString = " (invalid serial port \'" + portname + "\')";
myEEPROM = make_ptr<MT24LC256>(eepromfile, system);
myEEPROM = make_unique<MT24LC256>(eepromfile, system);
myDigitalPinState[One] = myDigitalPinState[Two] =
myDigitalPinState[Three] = myDigitalPinState[Four] = true;

2
src/emucore/Cart.cxx
View File

@ -80,7 +80,7 @@ void Cartridge::triggerReadFromWritePort(uInt16 address)
void Cartridge::createCodeAccessBase(uInt32 size)
{
#ifdef DEBUGGER_SUPPORT
myCodeAccessBase = make_ptr<uInt8[]>(size);
myCodeAccessBase = make_unique<uInt8[]>(size);
memset(myCodeAccessBase.get(), CartDebug::ROW, size);
#else
myCodeAccessBase = nullptr;

2
src/emucore/Cart2K.cxx
View File

@ -38,7 +38,7 @@ Cartridge2K::Cartridge2K(const BytePtr& image, uInt32 size,
mySize = 64;
// Initialize ROM with illegal 6502 opcode that causes a real 6502 to jam
myImage = make_ptr<uInt8[]>(mySize);
myImage = make_unique<uInt8[]>(mySize);
memset(myImage.get(), 0x02, mySize);
// Copy the ROM image into my buffer

2
src/emucore/Cart3E.cxx
View File

@ -27,7 +27,7 @@ Cartridge3E::Cartridge3E(const BytePtr& image, uInt32 size,
myCurrentBank(0)
{
// Allocate array for the ROM image
myImage = make_ptr<uInt8[]>(mySize);
myImage = make_unique<uInt8[]>(mySize);
// Copy the ROM image into my buffer
memcpy(myImage.get(), image.get(), mySize);

2
src/emucore/Cart3EPlus.cxx
View File

@ -26,7 +26,7 @@ Cartridge3EPlus::Cartridge3EPlus(const BytePtr& image, uInt32 size,
mySize(size)
{
// Allocate array for the ROM image
myImage = make_ptr<uInt8[]>(mySize);
myImage = make_unique<uInt8[]>(mySize);
// Copy the ROM image into my buffer
memcpy(myImage.get(), image.get(), mySize);

2
src/emucore/Cart3F.cxx
View File

@ -27,7 +27,7 @@ Cartridge3F::Cartridge3F(const BytePtr& image, uInt32 size,
myCurrentBank(0)
{
// Allocate array for the ROM image
myImage = make_ptr<uInt8[]>(mySize);
myImage = make_unique<uInt8[]>(mySize);
// Copy the ROM image into my buffer
memcpy(myImage.get(), image.get(), mySize);

2
src/emucore/CartAR.cxx
View File

@ -33,7 +33,7 @@ CartridgeAR::CartridgeAR(const BytePtr& image, uInt32 size,
myCurrentBank(0)
{
// Create a load image buffer and copy the given image
myLoadImages = make_ptr<uInt8[]>(mySize);
myLoadImages = make_unique<uInt8[]>(mySize);
myNumberOfLoadImages = mySize / 8448;
memcpy(myLoadImages.get(), image.get(), size);

2
src/emucore/CartBUS.cxx
View File

@ -65,7 +65,7 @@ CartridgeBUS::CartridgeBUS(const BytePtr& image, uInt32 size,
#ifdef THUMB_SUPPORT
// Create Thumbulator ARM emulator
myThumbEmulator = make_ptr<Thumbulator>((uInt16*)myImage, (uInt16*)myBUSRAM,
myThumbEmulator = make_unique<Thumbulator>((uInt16*)myImage, (uInt16*)myBUSRAM,
settings.getBool("thumb.trapfatal"), Thumbulator::ConfigureFor::BUS, this);
#endif
setInitialState();

2
src/emucore/CartCDF.cxx
View File

@ -64,7 +64,7 @@ CartridgeCDF::CartridgeCDF(const BytePtr& image, uInt32 size,
myDisplayImage = myCDFRAM + DSRAM;
#ifdef THUMB_SUPPORT
// Create Thumbulator ARM emulator
myThumbEmulator = make_ptr<Thumbulator>((uInt16*)myImage, (uInt16*)myCDFRAM,
myThumbEmulator = make_unique<Thumbulator>((uInt16*)myImage, (uInt16*)myCDFRAM,
settings.getBool("thumb.trapfatal"), Thumbulator::ConfigureFor::CDF, this);
#endif
setInitialState();

2
src/emucore/CartCV.cxx
View File

@ -38,7 +38,7 @@ CartridgeCV::CartridgeCV(const BytePtr& image, uInt32 size,
memcpy(myImage, image.get() + 2048, 2048);
// Copy the RAM image into a buffer for use in reset()
myInitialRAM = make_ptr<uInt8[]>(1024);
myInitialRAM = make_unique<uInt8[]>(1024);
memcpy(myInitialRAM.get(), image.get(), 1024);
}
createCodeAccessBase(2048+1024);

2
src/emucore/CartCVPlus.cxx
View File

@ -27,7 +27,7 @@ CartridgeCVPlus::CartridgeCVPlus(const BytePtr& image, uInt32 size,
myCurrentBank(0)
{
// Allocate array for the ROM image
myImage = make_ptr<uInt8[]>(mySize);
myImage = make_unique<uInt8[]>(mySize);
// Copy the ROM image into my buffer
memcpy(myImage.get(), image.get(), mySize);

2
src/emucore/CartDASH.cxx
View File

@ -26,7 +26,7 @@ CartridgeDASH::CartridgeDASH(const BytePtr& image, uInt32 size,
mySize(size)
{
// Allocate array for the ROM image
myImage = make_ptr<uInt8[]>(mySize);
myImage = make_unique<uInt8[]>(mySize);
// Copy the ROM image into my buffer
memcpy(myImage.get(), image.get(), mySize);

2
src/emucore/CartDPCPlus.cxx
View File

@ -54,7 +54,7 @@ CartridgeDPCPlus::CartridgeDPCPlus(const BytePtr& image, uInt32 size,
#ifdef THUMB_SUPPORT
// Create Thumbulator ARM emulator
myThumbEmulator = make_ptr<Thumbulator>
myThumbEmulator = make_unique<Thumbulator>
(reinterpret_cast<uInt16*>(myImage),
reinterpret_cast<uInt16*>(myDPCRAM),
settings.getBool("thumb.trapfatal"),

86
src/emucore/CartDetector.cxx
View File

@ -210,7 +210,7 @@ CartDetector::createFromMultiCart(const BytePtr& image, uInt32& size,
// Get a piece of the larger image
uInt32 i = osystem.settings().getInt("romloadcount");
size /= numroms;
BytePtr slice = make_ptr<uInt8[]>(size);
BytePtr slice = make_unique<uInt8[]>(size);
memcpy(slice.get(), image.get()+i*size, size);
// We need a new md5 and name
@ -239,89 +239,89 @@ CartDetector::createFromImage(const BytePtr& image, uInt32 size, BSType type,
switch(type)
{
case BSType::_0840:
return make_ptr<Cartridge0840>(image, size, osystem.settings());
return make_unique<Cartridge0840>(image, size, osystem.settings());
case BSType::_2K:
return make_ptr<Cartridge2K>(image, size, osystem.settings());
return make_unique<Cartridge2K>(image, size, osystem.settings());
case BSType::_3E:
return make_ptr<Cartridge3E>(image, size, osystem.settings());
return make_unique<Cartridge3E>(image, size, osystem.settings());
case BSType::_3EP:
return make_ptr<Cartridge3EPlus>(image, size, osystem.settings());
return make_unique<Cartridge3EPlus>(image, size, osystem.settings());
case BSType::_3F:
return make_ptr<Cartridge3F>(image, size, osystem.settings());
return make_unique<Cartridge3F>(image, size, osystem.settings());
case BSType::_4A50:
return make_ptr<Cartridge4A50>(image, size, osystem.settings());
return make_unique<Cartridge4A50>(image, size, osystem.settings());
case BSType::_4K:
return make_ptr<Cartridge4K>(image, size, osystem.settings());
return make_unique<Cartridge4K>(image, size, osystem.settings());
case BSType::_4KSC:
return make_ptr<Cartridge4KSC>(image, size, osystem.settings());
return make_unique<Cartridge4KSC>(image, size, osystem.settings());
case BSType::_AR:
return make_ptr<CartridgeAR>(image, size, osystem.settings());
return make_unique<CartridgeAR>(image, size, osystem.settings());
case BSType::_BUS:
return make_ptr<CartridgeBUS>(image, size, osystem.settings());
return make_unique<CartridgeBUS>(image, size, osystem.settings());
case BSType::_CDF:
return make_ptr<CartridgeCDF>(image, size, osystem.settings());
return make_unique<CartridgeCDF>(image, size, osystem.settings());
case BSType::_CM:
return make_ptr<CartridgeCM>(image, size, osystem.settings());
return make_unique<CartridgeCM>(image, size, osystem.settings());
case BSType::_CTY:
return make_ptr<CartridgeCTY>(image, size, osystem);
return make_unique<CartridgeCTY>(image, size, osystem);
case BSType::_CV:
return make_ptr<CartridgeCV>(image, size, osystem.settings());
return make_unique<CartridgeCV>(image, size, osystem.settings());
case BSType::_CVP:
return make_ptr<CartridgeCVPlus>(image, size, osystem.settings());
return make_unique<CartridgeCVPlus>(image, size, osystem.settings());
case BSType::_DASH:
return make_ptr<CartridgeDASH>(image, size, osystem.settings());
return make_unique<CartridgeDASH>(image, size, osystem.settings());
case BSType::_DPC:
return make_ptr<CartridgeDPC>(image, size, osystem.settings());
return make_unique<CartridgeDPC>(image, size, osystem.settings());
case BSType::_DPCP:
return make_ptr<CartridgeDPCPlus>(image, size, osystem.settings());
return make_unique<CartridgeDPCPlus>(image, size, osystem.settings());
case BSType::_E0:
return make_ptr<CartridgeE0>(image, size, osystem.settings());
return make_unique<CartridgeE0>(image, size, osystem.settings());
case BSType::_E7:
return make_ptr<CartridgeE7>(image, size, osystem.settings());
return make_unique<CartridgeE7>(image, size, osystem.settings());
case BSType::_EF:
return make_ptr<CartridgeEF>(image, size, osystem.settings());
return make_unique<CartridgeEF>(image, size, osystem.settings());
case BSType::_EFSC:
return make_ptr<CartridgeEFSC>(image, size, osystem.settings());
return make_unique<CartridgeEFSC>(image, size, osystem.settings());
case BSType::_BF:
return make_ptr<CartridgeBF>(image, size, osystem.settings());
return make_unique<CartridgeBF>(image, size, osystem.settings());
case BSType::_BFSC:
return make_ptr<CartridgeBFSC>(image, size, osystem.settings());
return make_unique<CartridgeBFSC>(image, size, osystem.settings());
case BSType::_DF:
return make_ptr<CartridgeDF>(image, size, osystem.settings());
return make_unique<CartridgeDF>(image, size, osystem.settings());
case BSType::_DFSC:
return make_ptr<CartridgeDFSC>(image, size, osystem.settings());
return make_unique<CartridgeDFSC>(image, size, osystem.settings());
case BSType::_F0:
return make_ptr<CartridgeF0>(image, size, osystem.settings());
return make_unique<CartridgeF0>(image, size, osystem.settings());
case BSType::_F4:
return make_ptr<CartridgeF4>(image, size, osystem.settings());
return make_unique<CartridgeF4>(image, size, osystem.settings());
case BSType::_F4SC:
return make_ptr<CartridgeF4SC>(image, size, osystem.settings());
return make_unique<CartridgeF4SC>(image, size, osystem.settings());
case BSType::_F6:
return make_ptr<CartridgeF6>(image, size, osystem.settings());
return make_unique<CartridgeF6>(image, size, osystem.settings());
case BSType::_F6SC:
return make_ptr<CartridgeF6SC>(image, size, osystem.settings());
return make_unique<CartridgeF6SC>(image, size, osystem.settings());
case BSType::_F8:
return make_ptr<CartridgeF8>(image, size, md5, osystem.settings());
return make_unique<CartridgeF8>(image, size, md5, osystem.settings());
case BSType::_F8SC:
return make_ptr<CartridgeF8SC>(image, size, osystem.settings());
return make_unique<CartridgeF8SC>(image, size, osystem.settings());
case BSType::_FA:
return make_ptr<CartridgeFA>(image, size, osystem.settings());
return make_unique<CartridgeFA>(image, size, osystem.settings());
case BSType::_FA2:
return make_ptr<CartridgeFA2>(image, size, osystem);
return make_unique<CartridgeFA2>(image, size, osystem);
case BSType::_FE:
return make_ptr<CartridgeFE>(image, size, osystem.settings());
return make_unique<CartridgeFE>(image, size, osystem.settings());
case BSType::_MC:
return make_ptr<CartridgeMC>(image, size, osystem.settings());
return make_unique<CartridgeMC>(image, size, osystem.settings());
case BSType::_MDM:
return make_ptr<CartridgeMDM>(image, size, osystem.settings());
return make_unique<CartridgeMDM>(image, size, osystem.settings());
case BSType::_UA:
return make_ptr<CartridgeUA>(image, size, osystem.settings());
return make_unique<CartridgeUA>(image, size, osystem.settings());
case BSType::_SB:
return make_ptr<CartridgeSB>(image, size, osystem.settings());
return make_unique<CartridgeSB>(image, size, osystem.settings());
case BSType::_WD:
return make_ptr<CartridgeWD>(image, size, osystem.settings());
return make_unique<CartridgeWD>(image, size, osystem.settings());
case BSType::_X07:
return make_ptr<CartridgeX07>(image, size, osystem.settings());
return make_unique<CartridgeX07>(image, size, osystem.settings());
default:
return nullptr; // The remaining types have already been handled
}

2
src/emucore/CartMDM.cxx
View File

@ -27,7 +27,7 @@ CartridgeMDM::CartridgeMDM(const BytePtr& image, uInt32 size,
myBankingDisabled(false)
{
// Allocate array for the ROM image
myImage = make_ptr<uInt8[]>(mySize);
myImage = make_unique<uInt8[]>(mySize);
// Copy the ROM image into my buffer
memcpy(myImage.get(), image.get(), mySize);

2
src/emucore/CartSB.cxx
View File

@ -26,7 +26,7 @@ CartridgeSB::CartridgeSB(const BytePtr& image, uInt32 size,
myCurrentBank(0)
{
// Allocate array for the ROM image
myImage = make_ptr<uInt8[]>(mySize);
myImage = make_unique<uInt8[]>(mySize);
// Copy the ROM image into my buffer
memcpy(myImage.get(), image.get(), mySize);

4
src/emucore/CompuMate.cxx
View File

@ -29,8 +29,8 @@ CompuMate::CompuMate(const Console& console, const Event& event,
{
// These controller pointers will be retrieved by the Console, which will
// also take ownership of them
myLeftController = make_ptr<CMControl>(*this, Controller::Left, event, system);
myRightController = make_ptr<CMControl>(*this, Controller::Right, event, system);
myLeftController = make_unique<CMControl>(*this, Controller::Left, event, system);
myRightController = make_unique<CMControl>(*this, Controller::Right, event, system);
myLeftController->updateAnalogPin(Controller::Nine, Controller::maximumResistance);
myLeftController->updateAnalogPin(Controller::Five, Controller::minimumResistance);

60
src/emucore/Console.cxx
View File

@ -85,20 +85,20 @@ Console::Console(OSystem& osystem, unique_ptr<Cartridge>& cart,
loadUserPalette();
// Create subsystems for the console
my6502 = make_ptr<M6502>(myOSystem.settings());
myRiot = make_ptr<M6532>(*this, myOSystem.settings());
myTIA = make_ptr<TIA>(*this, myOSystem.sound(), myOSystem.settings());
mySwitches = make_ptr<Switches>(myEvent, myProperties);
my6502 = make_unique<M6502>(myOSystem.settings());
myRiot = make_unique<M6532>(*this, myOSystem.settings());
myTIA = make_unique<TIA>(*this, myOSystem.sound(), myOSystem.settings());
mySwitches = make_unique<Switches>(myEvent, myProperties);
// Construct the system and components
mySystem = make_ptr<System>(osystem, *my6502, *myRiot, *myTIA, *myCart);
mySystem = make_unique<System>(osystem, *my6502, *myRiot, *myTIA, *myCart);
// The real controllers for this console will be added later
// For now, we just add dummy joystick controllers, since autodetection
// runs the emulation for a while, and this may interfere with 'smart'
// controllers such as the AVox and SaveKey
myLeftControl = make_ptr<Joystick>(Controller::Left, myEvent, *mySystem);
myRightControl = make_ptr<Joystick>(Controller::Right, myEvent, *mySystem);
myLeftControl = make_unique<Joystick>(Controller::Left, myEvent, *mySystem);
myRightControl = make_unique<Joystick>(Controller::Right, myEvent, *mySystem);
// We can only initialize after all the devices/components have been created
mySystem->initialize();
@ -727,19 +727,19 @@ void Console::setControllers(const string& rommd5)
// Already created in c'tor
// We save some time by not looking at all the other types
if(!leftC)
leftC = make_ptr<Joystick>(Controller::Left, myEvent, *mySystem);
leftC = make_unique<Joystick>(Controller::Left, myEvent, *mySystem);
}
else if(left == "BOOSTERGRIP")
{
leftC = make_ptr<BoosterGrip>(Controller::Left, myEvent, *mySystem);
leftC = make_unique<BoosterGrip>(Controller::Left, myEvent, *mySystem);
}
else if(left == "DRIVING")
{
leftC = make_ptr<Driving>(Controller::Left, myEvent, *mySystem);
leftC = make_unique<Driving>(Controller::Left, myEvent, *mySystem);
}
else if((left == "KEYBOARD") || (left == "KEYPAD"))
{
leftC = make_ptr<Keyboard>(Controller::Left, myEvent, *mySystem);
leftC = make_unique<Keyboard>(Controller::Left, myEvent, *mySystem);
}
else if(BSPF::startsWithIgnoreCase(left, "PADDLES"))
{
@ -750,28 +750,28 @@ void Console::setControllers(const string& rommd5)
swapDir = true;
else if(left == "PADDLES_IAXDR")
swapAxis = swapDir = true;
leftC = make_ptr<Paddles>(Controller::Left, myEvent, *mySystem,
leftC = make_unique<Paddles>(Controller::Left, myEvent, *mySystem,
swapPaddles, swapAxis, swapDir);
}
else if(left == "AMIGAMOUSE")
{
leftC = make_ptr<AmigaMouse>(Controller::Left, myEvent, *mySystem);
leftC = make_unique<AmigaMouse>(Controller::Left, myEvent, *mySystem);
}
else if(left == "ATARIMOUSE")
{
leftC = make_ptr<AtariMouse>(Controller::Left, myEvent, *mySystem);
leftC = make_unique<AtariMouse>(Controller::Left, myEvent, *mySystem);
}
else if(left == "TRAKBALL")
{
leftC = make_ptr<TrakBall>(Controller::Left, myEvent, *mySystem);
leftC = make_unique<TrakBall>(Controller::Left, myEvent, *mySystem);
}
else if(left == "GENESIS")
{
leftC = make_ptr<Genesis>(Controller::Left, myEvent, *mySystem);
leftC = make_unique<Genesis>(Controller::Left, myEvent, *mySystem);
}
else if(left == "MINDLINK")
{
leftC = make_ptr<MindLink>(Controller::Left, myEvent, *mySystem);
leftC = make_unique<MindLink>(Controller::Left, myEvent, *mySystem);
}
// Construct right controller
@ -780,19 +780,19 @@ void Console::setControllers(const string& rommd5)
// Already created in c'tor
// We save some time by not looking at all the other types
if(!rightC)
rightC = make_ptr<Joystick>(Controller::Right, myEvent, *mySystem);
rightC = make_unique<Joystick>(Controller::Right, myEvent, *mySystem);
}
else if(right == "BOOSTERGRIP")
{
rightC = make_ptr<BoosterGrip>(Controller::Right, myEvent, *mySystem);
rightC = make_unique<BoosterGrip>(Controller::Right, myEvent, *mySystem);
}
else if(right == "DRIVING")
{
rightC = make_ptr<Driving>(Controller::Right, myEvent, *mySystem);
rightC = make_unique<Driving>(Controller::Right, myEvent, *mySystem);
}
else if((right == "KEYBOARD") || (right == "KEYPAD"))
{
rightC = make_ptr<Keyboard>(Controller::Right, myEvent, *mySystem);
rightC = make_unique<Keyboard>(Controller::Right, myEvent, *mySystem);
}
else if(BSPF::startsWithIgnoreCase(right, "PADDLES"))
{
@ -803,45 +803,45 @@ void Console::setControllers(const string& rommd5)
swapDir = true;
else if(right == "PADDLES_IAXDR")
swapAxis = swapDir = true;
rightC = make_ptr<Paddles>(Controller::Right, myEvent, *mySystem,
rightC = make_unique<Paddles>(Controller::Right, myEvent, *mySystem,
swapPaddles, swapAxis, swapDir);
}
else if(left == "AMIGAMOUSE")
{
rightC = make_ptr<AmigaMouse>(Controller::Left, myEvent, *mySystem);
rightC = make_unique<AmigaMouse>(Controller::Left, myEvent, *mySystem);
}
else if(left == "ATARIMOUSE")
{
rightC = make_ptr<AtariMouse>(Controller::Left, myEvent, *mySystem);
rightC = make_unique<AtariMouse>(Controller::Left, myEvent, *mySystem);
}
else if(left == "TRAKBALL")
{
rightC = make_ptr<TrakBall>(Controller::Left, myEvent, *mySystem);
rightC = make_unique<TrakBall>(Controller::Left, myEvent, *mySystem);
}
else if(right == "ATARIVOX")
{
const string& nvramfile = myOSystem.nvramDir() + "atarivox_eeprom.dat";
rightC = make_ptr<AtariVox>(Controller::Right, myEvent,
rightC = make_unique<AtariVox>(Controller::Right, myEvent,
*mySystem, myOSystem.serialPort(),
myOSystem.settings().getString("avoxport"), nvramfile);
}
else if(right == "SAVEKEY")
{
const string& nvramfile = myOSystem.nvramDir() + "savekey_eeprom.dat";
rightC = make_ptr<SaveKey>(Controller::Right, myEvent, *mySystem,
rightC = make_unique<SaveKey>(Controller::Right, myEvent, *mySystem,
nvramfile);
}
else if(right == "GENESIS")
{
rightC = make_ptr<Genesis>(Controller::Right, myEvent, *mySystem);
rightC = make_unique<Genesis>(Controller::Right, myEvent, *mySystem);
}
else if(right == "KIDVID")
{
rightC = make_ptr<KidVid>(Controller::Right, myEvent, *mySystem, rommd5);
rightC = make_unique<KidVid>(Controller::Right, myEvent, *mySystem, rommd5);
}
else if(right == "MINDLINK")
{
rightC = make_ptr<MindLink>(Controller::Right, myEvent, *mySystem);
rightC = make_unique<MindLink>(Controller::Right, myEvent, *mySystem);
}
// Swap the ports if necessary

6
src/emucore/EventHandler.cxx
View File

@ -76,7 +76,7 @@ EventHandler::EventHandler(OSystem& osystem)
myComboTable[i][j] = Event::NoType;
// Create joystick handler (to handle all joystick functionality)
myJoyHandler = make_ptr<JoystickHandler>(osystem);
myJoyHandler = make_unique<JoystickHandler>(osystem);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -1283,7 +1283,7 @@ void EventHandler::setKeymap()
if(event == Event::LastType && map.size() == KBDK_LAST * kNumModes)
{
// Fill the keymap table with events
auto e = map.begin();
auto e = map.cbegin();
for(int mode = 0; mode < kNumModes; ++mode)
for(int i = 0; i < KBDK_LAST; ++i)
myKeyTable[i][mode] = Event::Type(*e++);
@ -1920,7 +1920,7 @@ void EventHandler::setMouseControllerMode(const string& enable)
const string& control = usemouse ?
myOSystem.console().properties().get(Controller_MouseAxis) : "none";
myMouseControl = make_ptr<MouseControl>(myOSystem.console(), control);
myMouseControl = make_unique<MouseControl>(myOSystem.console(), control);
myMouseControl->next(); // set first available mode
}
}

6
src/emucore/EventJoyHandler.cxx
View File

@ -138,7 +138,7 @@ bool EventHandler::StellaJoystick::setMap(const string& mapString)
if(int(map.size()) == numAxes * 2 * kNumModes)
{
// Fill the axes table with events
auto event = map.begin();
auto event = map.cbegin();
for(int m = 0; m < kNumModes; ++m)
for(int a = 0; a < numAxes; ++a)
for(int k = 0; k < 2; ++k)
@ -147,7 +147,7 @@ bool EventHandler::StellaJoystick::setMap(const string& mapString)
getValues(items[2], map);
if(int(map.size()) == numButtons * kNumModes)
{
auto event = map.begin();
auto event = map.cbegin();
for(int m = 0; m < kNumModes; ++m)
for(int b = 0; b < numButtons; ++b)
btnTable[b][m] = Event::Type(*event++);
@ -155,7 +155,7 @@ bool EventHandler::StellaJoystick::setMap(const string& mapString)
getValues(items[3], map);
if(int(map.size()) == numHats * 4 * kNumModes)
{
auto event = map.begin();
auto event = map.cbegin();
for(int m = 0; m < kNumModes; ++m)
for(int h = 0; h < numHats; ++h)
for(int k = 0; k < 4; ++k)

2
src/emucore/FSNode.cxx
View File

@ -189,7 +189,7 @@ uInt32 FilesystemNode::read(BytePtr& image) const
gzFile f = gzopen(getPath().c_str(), "rb");
if(f)
{
image = make_ptr<uInt8[]>(512 * 1024);
image = make_unique<uInt8[]>(512 * 1024);
size = gzread(f, image.get(), 512 * 1024);
gzclose(f);

16
src/emucore/FrameBuffer.cxx
View File

@ -88,15 +88,15 @@ bool FrameBuffer::initialize()
// This font is used in a variety of situations when a really small
// font is needed; we let the specific widget/dialog decide when to
// use it
mySmallFont = make_ptr<GUI::Font>(GUI::stellaDesc);
mySmallFont = make_unique<GUI::Font>(GUI::stellaDesc);
// The general font used in all UI elements
// This is determined by the size of the framebuffer
myFont = make_ptr<GUI::Font>(smallScreen ? GUI::stellaDesc : GUI::stellaMediumDesc);
myFont = make_unique<GUI::Font>(smallScreen ? GUI::stellaDesc : GUI::stellaMediumDesc);
// The info font used in all UI elements
// This is determined by the size of the framebuffer
myInfoFont = make_ptr<GUI::Font>(smallScreen ? GUI::stellaDesc : GUI::consoleDesc);
myInfoFont = make_unique<GUI::Font>(smallScreen ? GUI::stellaDesc : GUI::consoleDesc);
// The font used by the ROM launcher
// Normally, this is configurable by the user, except in the case of
@ -105,14 +105,14 @@ bool FrameBuffer::initialize()
{
const string& lf = myOSystem.settings().getString("launcherfont");
if(lf == "small")
myLauncherFont = make_ptr<GUI::Font>(GUI::consoleDesc);
myLauncherFont = make_unique<GUI::Font>(GUI::consoleDesc);
else if(lf == "medium")
myLauncherFont = make_ptr<GUI::Font>(GUI::stellaMediumDesc);
myLauncherFont = make_unique<GUI::Font>(GUI::stellaMediumDesc);
else
myLauncherFont = make_ptr<GUI::Font>(GUI::stellaLargeDesc);
myLauncherFont = make_unique<GUI::Font>(GUI::stellaLargeDesc);
}
else
myLauncherFont = make_ptr<GUI::Font>(GUI::stellaDesc);
myLauncherFont = make_unique<GUI::Font>(GUI::stellaDesc);
// Determine possible TIA windowed zoom levels
uInt32 maxZoom = maxWindowSizeForScreen(uInt32(kTIAMinW), uInt32(kTIAMinH),
@ -141,7 +141,7 @@ bool FrameBuffer::initialize()
FBSurface::setPalette(myPalette);
// Create a TIA surface; we need it for rendering TIA images
myTIASurface = make_ptr<TIASurface>(myOSystem);
myTIASurface = make_unique<TIASurface>(myOSystem);
return true;
}

20
src/emucore/OSystem.cxx
View File

@ -89,7 +89,7 @@ OSystem::OSystem()
myBuildInfo = info.str();
mySettings = MediaFactory::createSettings(*this);
myRandom = make_ptr<Random>(*this);
myRandom = make_unique<Random>(*this);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -128,18 +128,18 @@ bool OSystem::create()
myEventHandler->initialize();
// Create a properties set for us to use and set it up
myPropSet = make_ptr<PropertiesSet>(propertiesFile());
myPropSet = make_unique<PropertiesSet>(propertiesFile());
#ifdef CHEATCODE_SUPPORT
myCheatManager = make_ptr<CheatManager>(*this);
myCheatManager = make_unique<CheatManager>(*this);
myCheatManager->loadCheatDatabase();
#endif
// Create menu and launcher GUI objects
myMenu = make_ptr<Menu>(*this);
myCommandMenu = make_ptr<CommandMenu>(*this);
myLauncher = make_ptr<Launcher>(*this);
myStateManager = make_ptr<StateManager>(*this);
myMenu = make_unique<Menu>(*this);
myCommandMenu = make_unique<CommandMenu>(*this);
myLauncher = make_unique<Launcher>(*this);
myStateManager = make_unique<StateManager>(*this);
// Create the sound object; the sound subsystem isn't actually
// opened until needed, so this is non-blocking (on those systems
@ -155,7 +155,7 @@ bool OSystem::create()
myRandom->initSeed();
// Create PNG handler
myPNGLib = make_ptr<PNGLibrary>(*myFrameBuffer);
myPNGLib = make_unique<PNGLibrary>(*myFrameBuffer);
return true;
}
@ -323,7 +323,7 @@ string OSystem::createConsole(const FilesystemNode& rom, const string& md5sum,
if(myConsole)
{
#ifdef DEBUGGER_SUPPORT
myDebugger = make_ptr<Debugger>(*this, *myConsole);
myDebugger = make_unique<Debugger>(*this, *myConsole);
myDebugger->initialize();
myConsole->attachDebugger(*myDebugger);
#endif
@ -536,7 +536,7 @@ OSystem::openConsole(const FilesystemNode& romfile, string& md5)
// Finally, create the cart with the correct properties
if(cart)
console = make_ptr<Console>(*this, cart, props);
console = make_unique<Console>(*this, cart, props);
}
return console;

2
src/emucore/SaveKey.cxx
View File

@ -24,7 +24,7 @@ SaveKey::SaveKey(Jack jack, const Event& event, const System& system,
const string& eepromfile)
: Controller(jack, event, system, Controller::SaveKey)
{
myEEPROM = make_ptr<MT24LC256>(eepromfile, system);
myEEPROM = make_unique<MT24LC256>(eepromfile, system);
myDigitalPinState[One] = myDigitalPinState[Two] = true;
}

6
src/emucore/Serializer.cxx
View File

@ -33,7 +33,7 @@ Serializer::Serializer(const string& filename, bool readonly)
FilesystemNode node(filename);
if(node.isFile() && node.isReadable())
{
unique_ptr<fstream> str = make_ptr<fstream>(filename, ios::in | ios::binary);
unique_ptr<fstream> str = make_unique<fstream>(filename, ios::in | ios::binary);
if(str && str->is_open())
{
myStream = std::move(str);
@ -54,7 +54,7 @@ Serializer::Serializer(const string& filename, bool readonly)
fstream temp(filename, ios::out | ios::app);
temp.close();
unique_ptr<fstream> str = make_ptr<fstream>(filename, ios::in | ios::out | ios::binary);
unique_ptr<fstream> str = make_unique<fstream>(filename, ios::in | ios::out | ios::binary);
if(str && str->is_open())
{
myStream = std::move(str);
@ -68,7 +68,7 @@ Serializer::Serializer(const string& filename, bool readonly)
Serializer::Serializer()
: myStream(nullptr)
{
myStream = make_ptr<stringstream>(ios::in | ios::out | ios::binary);
myStream = make_unique<stringstream>(ios::in | ios::out | ios::binary);
// For some reason, Windows and possibly OSX needs to store something in
// the stream before it is used for the first time

2
src/gui/ConfigPathDialog.cxx
View File

@ -293,5 +293,5 @@ void ConfigPathDialog::createBrowser()
// Create file browser dialog
if(!myBrowser || uInt32(myBrowser->getWidth()) != w ||
uInt32(myBrowser->getHeight()) != h)
myBrowser = make_ptr<BrowserDialog>(this, myFont, w, h);
myBrowser = make_unique<BrowserDialog>(this, myFont, w, h);
}

6
src/gui/GameList.cxx
View File

@ -31,11 +31,11 @@ void GameList::sortByName()
auto cmp = [](const Entry& a, const Entry& b)
{
auto it1 = a._name.begin(), it2 = b._name.begin();
auto it1 = a._name.cbegin(), it2 = b._name.cbegin();
// Account for ending ']' character in directory entries
auto end1 = a._isdir ? a._name.end() - 1 : a._name.end();
auto end2 = b._isdir ? b._name.end() - 1 : b._name.end();
auto end1 = a._isdir ? a._name.cend() - 1 : a._name.cend();
auto end2 = b._isdir ? b._name.cend() - 1 : b._name.cend();
// Stop when either string's end has been reached
while((it1 != end1) && (it2 != end2))

2
src/gui/InputDialog.cxx
View File

@ -435,7 +435,7 @@ void InputDialog::handleCommand(CommandSender* sender, int cmd,
case kDBButtonPressed:
if(!myJoyDialog)
myJoyDialog = make_ptr<JoystickDialog>
myJoyDialog = make_unique<JoystickDialog>
(this, instance().frameBuffer().font(), _w-60, _h-60);
myJoyDialog->show();
break;

14
src/gui/LauncherDialog.cxx
View File

@ -163,12 +163,12 @@ LauncherDialog::LauncherDialog(OSystem& osystem, DialogContainer& parent,
mySelectedItem = 0; // Highlight 'Rom Listing'
// Create an options dialog, similar to the in-game one
myOptions = make_ptr<OptionsDialog>(osystem, parent, this,
myOptions = make_unique<OptionsDialog>(osystem, parent, this,
int(w * 0.8), int(h * 0.8), true);
// Create a game list, which contains all the information about a ROM that
// the launcher needs
myGameList = make_ptr<GameList>();
myGameList = make_unique<GameList>();
addToFocusList(wid);
@ -177,14 +177,14 @@ LauncherDialog::LauncherDialog(OSystem& osystem, DialogContainer& parent,
VarList::push_back(l, "Power-on options", "override");
VarList::push_back(l, "Filter listing", "filter");
VarList::push_back(l, "Reload listing", "reload");
myMenu = make_ptr<ContextMenu>(this, osystem.frameBuffer().font(), l);
myMenu = make_unique<ContextMenu>(this, osystem.frameBuffer().font(), l);
// Create global props dialog, which is used to temporarily overrride
// ROM properties
myGlobalProps = make_ptr<GlobalPropsDialog>(this, osystem.frameBuffer().font());
myGlobalProps = make_unique<GlobalPropsDialog>(this, osystem.frameBuffer().font());
// Create dialog whereby the files shown in the ROM listing can be customized
myFilters = make_ptr<LauncherFilterDialog>(this, osystem.frameBuffer().font());
myFilters = make_unique<LauncherFilterDialog>(this, osystem.frameBuffer().font());
// Figure out which filters are needed for the ROM listing
setListFilters();
@ -229,7 +229,7 @@ void LauncherDialog::loadConfig()
msg.push_back("");
msg.push_back("Click 'OK' to select a default ROM directory,");
msg.push_back("or 'Cancel' to browse the filesystem manually.");
myFirstRunMsg = make_ptr<GUI::MessageBox>
myFirstRunMsg = make_unique<GUI::MessageBox>
(this, instance().frameBuffer().font(),
msg, _w, _h, kFirstRunMsgChosenCmd);
}
@ -514,7 +514,7 @@ void LauncherDialog::handleCommand(CommandSender* sender, int cmd,
case kFirstRunMsgChosenCmd:
// Show a file browser, starting from the users' home directory
if(!myRomDir)
myRomDir = make_ptr<BrowserDialog>(this, instance().frameBuffer().font(), _w, _h);
myRomDir = make_unique<BrowserDialog>(this, instance().frameBuffer().font(), _w, _h);
myRomDir->show("Select ROM directory", "~",
BrowserDialog::Directories, kStartupRomDirChosenCmd);

26
src/gui/OptionsDialog.cxx
View File

@ -116,20 +116,20 @@ OptionsDialog::OptionsDialog(OSystem& osystem, DialogContainer& parent,
addCancelWidget(b);
// Now create all the dialogs attached to each menu button
myVideoDialog = make_ptr<VideoDialog>(osystem, parent, font, max_w, max_h, myIsGlobal);
myAudioDialog = make_ptr<AudioDialog>(osystem, parent, font);
myInputDialog = make_ptr<InputDialog>(osystem, parent, font, max_w, max_h);
myUIDialog = make_ptr<UIDialog>(osystem, parent, font);
mySnapshotDialog = make_ptr<SnapshotDialog>(osystem, parent, font);
myConfigPathDialog = make_ptr<ConfigPathDialog>(osystem, parent, font, boss);
myRomAuditDialog = make_ptr<RomAuditDialog>(osystem, parent, font, max_w, max_h);
myGameInfoDialog = make_ptr<GameInfoDialog>(osystem, parent, font, this);
myVideoDialog = make_unique<VideoDialog>(osystem, parent, font, max_w, max_h, myIsGlobal);
myAudioDialog = make_unique<AudioDialog>(osystem, parent, font);
myInputDialog = make_unique<InputDialog>(osystem, parent, font, max_w, max_h);
myUIDialog = make_unique<UIDialog>(osystem, parent, font);
mySnapshotDialog = make_unique<SnapshotDialog>(osystem, parent, font);
myConfigPathDialog = make_unique<ConfigPathDialog>(osystem, parent, font, boss);
myRomAuditDialog = make_unique<RomAuditDialog>(osystem, parent, font, max_w, max_h);
myGameInfoDialog = make_unique<GameInfoDialog>(osystem, parent, font, this);
#ifdef CHEATCODE_SUPPORT
myCheatCodeDialog = make_ptr<CheatCodeDialog>(osystem, parent, font);
myCheatCodeDialog = make_unique<CheatCodeDialog>(osystem, parent, font);
#endif
myLoggerDialog = make_ptr<LoggerDialog>(osystem, parent, font, max_w, max_h);
myHelpDialog = make_ptr<HelpDialog>(osystem, parent, font);
myAboutDialog = make_ptr<AboutDialog>(osystem, parent, font);
myLoggerDialog = make_unique<LoggerDialog>(osystem, parent, font, max_w, max_h);
myHelpDialog = make_unique<HelpDialog>(osystem, parent, font);
myAboutDialog = make_unique<AboutDialog>(osystem, parent, font);
addToFocusList(wid);
@ -218,7 +218,7 @@ void OptionsDialog::handleCommand(CommandSender* sender, int cmd,
uInt32 w = 0, h = 0;
bool uselargefont = getResizableBounds(w, h);
myLoggerDialog = make_ptr<LoggerDialog>(instance(), parent(),
myLoggerDialog = make_unique<LoggerDialog>(instance(), parent(),
instance().frameBuffer().font(), w, h, uselargefont);
}
myLoggerDialog->open();

2
src/gui/PopUpWidget.cxx
View File

@ -59,7 +59,7 @@ PopUpWidget::PopUpWidget(GuiObject* boss, const GUI::Font& font,
myTextY = (_h - _font.getFontHeight()) / 2;
myArrowsY = (_h - 8) / 2;
myMenu = make_ptr<ContextMenu>(this, font, list, cmd);
myMenu = make_unique<ContextMenu>(this, font, list, cmd);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

4
src/gui/RomAuditDialog.cxx
View File

@ -88,7 +88,7 @@ RomAuditDialog::RomAuditDialog(OSystem& osystem, DialogContainer& parent,
addBGroupToFocusList(wid);
// Create file browser dialog
myBrowser = make_ptr<BrowserDialog>(this, font, myMaxWidth, myMaxHeight);
myBrowser = make_unique<BrowserDialog>(this, font, myMaxWidth, myMaxHeight);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -179,7 +179,7 @@ void RomAuditDialog::handleCommand(CommandSender* sender, int cmd,
msg.push_back("");
msg.push_back("If you're sure you want to proceed with the");
msg.push_back("audit, click 'OK', otherwise click 'Cancel'.");
myConfirmMsg = make_ptr<GUI::MessageBox>
myConfirmMsg = make_unique<GUI::MessageBox>
(this, instance().frameBuffer().font(), msg,
myMaxWidth, myMaxHeight, kConfirmAuditCmd);
}

2
src/gui/SnapshotDialog.cxx
View File

@ -218,5 +218,5 @@ void SnapshotDialog::createBrowser()
// Create file browser dialog
if(!myBrowser || uInt32(myBrowser->getWidth()) != w ||
uInt32(myBrowser->getHeight()) != h)
myBrowser = make_ptr<BrowserDialog>(this, myFont, w, h);
myBrowser = make_unique<BrowserDialog>(this, myFont, w, h);
}

5
src/tools/check-sig.cxx
View File

@ -6,7 +6,6 @@
#include <cstdlib>
#include <list>
#include "../common/UniquePtr.hxx"
using namespace std;
using uInt8 = unsigned char;
@ -56,12 +55,12 @@ int main(int ac, char* av[])
int i_size = (int) in.tellg();
in.seekg(0, ios::beg);
unique_ptr<uInt8[]> image = make_ptr<uInt8[]>(i_size);
unique_ptr<uInt8[]> image = make_unique<uInt8[]>(i_size);
in.read((char*)(image.get()), i_size);
in.close();
int s_size = 0;
unique_ptr<uInt8[]> sig = make_ptr<uInt8[]>(strlen(av[2])/2);
unique_ptr<uInt8[]> sig = make_unique<uInt8[]>(strlen(av[2])/2);
istringstream buf(av[2]);
uInt32 c;

4
src/tools/romtohex.cxx
View File

@ -8,8 +8,6 @@
#include <fstream>
#include <iostream>
#include <cstdlib>
#include "../common/UniquePtr.hxx"
using namespace std;
using uInt8 = unsigned char;
@ -37,7 +35,7 @@ int main(int ac, char* av[])
int len = (int)in.tellg();
in.seekg(0, ios::beg);
unique_ptr<uInt8[]> data = make_ptr<uInt8[]>(len);
unique_ptr<uInt8[]> data = make_unique<uInt8[]>(len);
in.read((char*)data.get(), len);
in.close();