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

Second pass at fixes for suggestions from clang-tidy.

This commit is contained in:
Stephen Anthony 2022-08-21 13:53:52 -02:30
parent faf7e8b775
commit fc0a8c91a8
174 changed files with 825 additions and 829 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/cheat/BankRomCheat.cxx
View File

@ -51,7 +51,7 @@ bool BankRomCheat::disable()
myOSystem.console().cartridge().bank(bank);
for(int i = 0; i < count; ++i)
myOSystem.console().cartridge().patch(address + i, savedRom[i]);
myOSystem.console().cartridge().patch(address + i, savedRom[i]);
myOSystem.console().cartridge().bank(oldBank);

10
src/cheat/CheatCodeDialog.cxx
View File

@ -133,9 +133,9 @@ void CheatCodeDialog::loadConfig()
myCheatList->setList(l, b);
// Redraw the list, auto-selecting the first item if possible
myCheatList->setSelected(l.size() > 0 ? 0 : -1);
myCheatList->setSelected(!l.empty() ? 0 : -1);
const bool enabled = (list.size() > 0);
const bool enabled = !list.empty();
myEditButton->setEnabled(enabled);
myRemoveButton->setEnabled(enabled);
}
@ -233,7 +233,7 @@ void CheatCodeDialog::handleCommand(CommandSender* sender, int cmd,
{
const string& name = myCheatInput->getResult(0);
const string& code = myCheatInput->getResult(1);
if(instance().cheat().isValidCode(code))
if(CheatManager::isValidCode(code))
{
myCheatInput->close();
instance().cheat().add(name, code);
@ -250,7 +250,7 @@ void CheatCodeDialog::handleCommand(CommandSender* sender, int cmd,
const string& code = myCheatInput->getResult(1);
const bool enable = myCheatList->getSelectedState();
const int idx = myCheatList->getSelected();
if(instance().cheat().isValidCode(code))
if(CheatManager::isValidCode(code))
{
myCheatInput->close();
instance().cheat().add(name, code, enable, idx);
@ -273,7 +273,7 @@ void CheatCodeDialog::handleCommand(CommandSender* sender, int cmd,
{
const string& name = myCheatInput->getResult(0);
const string& code = myCheatInput->getResult(1);
if(instance().cheat().isValidCode(code))
if(CheatManager::isValidCode(code))
{
myCheatInput->close();
instance().cheat().addOneShot(name, code);

8
src/cheat/CheatManager.cxx
View File

@ -272,11 +272,11 @@ void CheatManager::loadCheats(const string& md5sum)
// Set up any cheatcodes that was on the command line
// (and remove the key from the settings, so they won't get set again)
const string& cheats = myOSystem.settings().getString("cheat");
if(cheats != "")
if(!cheats.empty())
myOSystem.settings().setValue("cheat", "");
const auto& iter = myCheatMap.find(md5sum);
if(iter == myCheatMap.end() && cheats == "")
if(iter == myCheatMap.end() && cheats.empty())
return;
// Remember the cheats for this ROM
@ -311,7 +311,7 @@ void CheatManager::saveCheats(const string& md5sum)
myCheatMap.erase(iter);
// Add new entry only if there are any cheats defined
if(cheats.str() != "")
if(!cheats.str().empty())
myCheatMap.emplace(md5sum, cheats.str());
}
@ -322,7 +322,7 @@ void CheatManager::saveCheats(const string& md5sum)
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool CheatManager::isValidCode(const string& code) const
bool CheatManager::isValidCode(const string& code)
{
for(const auto c: code)
if(!isxdigit(c))

2
src/cheat/CheatManager.hxx
View File

@ -121,7 +121,7 @@ class CheatManager
/**
Checks if a code is valid.
*/
bool isValidCode(const string& code) const;
static bool isValidCode(const string& code);
private:
/**

9
src/common/FBBackendSDL2.cxx
View File

@ -97,8 +97,7 @@ void FBBackendSDL2::queryHardware(vector<Common::Size>& fullscreenRes,
s << "Supported video modes (" << numModes << ") for display " << i
<< " (" << SDL_GetDisplayName(i) << "):";
string lastRes = "";
string lastRes;
for(int m = 0; m < numModes; ++m)
{
SDL_DisplayMode mode;
@ -428,7 +427,7 @@ bool FBBackendSDL2::createRenderer()
if(myRenderer)
SDL_DestroyRenderer(myRenderer);
if(video != "")
if(!video.empty())
SDL_SetHint(SDL_HINT_RENDER_DRIVER, video.c_str());
myRenderer = SDL_CreateRenderer(myWindow, -1, renderFlags);
@ -567,7 +566,7 @@ unique_ptr<FBSurface> FBBackendSDL2::createSurface(
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void FBBackendSDL2::readPixels(uInt8* pixels, size_t pitch,
void FBBackendSDL2::readPixels(uInt8* buffer, size_t pitch,
const Common::Rect& rect) const
{
ASSERT_MAIN_THREAD;
@ -576,7 +575,7 @@ void FBBackendSDL2::readPixels(uInt8* pixels, size_t pitch,
r.x = rect.x(); r.y = rect.y();
r.w = rect.w(); r.h = rect.h();
SDL_RenderReadPixels(myRenderer, &r, 0, pixels, static_cast<int>(pitch));
SDL_RenderReadPixels(myRenderer, &r, 0, buffer, static_cast<int>(pitch));
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

22
src/common/FSNodeZIP.cxx
View File

@ -131,7 +131,7 @@ void FSNodeZIP::setFlags(const string& zipfile, const string& virtualpath,
_shortPath = _realNode->getShortPath();
// Is a file component present?
if(_virtualPath.size() != 0)
if(!_virtualPath.empty())
{
_path += ("/" + _virtualPath);
_shortPath += ("/" + _virtualPath);
@ -190,7 +190,7 @@ bool FSNodeZIP::getChildren(AbstractFSList& myList, ListMode mode) const
{
// First strip off the leading directory
const string& curr = name.substr(
_virtualPath == "" ? 0 : _virtualPath.size()+1);
_virtualPath.empty() ? 0 : _virtualPath.size()+1);
// cerr << " curr: " << curr << endl;
// Only add sub-directory entries once
const auto pos = curr.find_first_of("/\\");
@ -203,7 +203,7 @@ bool FSNodeZIP::getChildren(AbstractFSList& myList, ListMode mode) const
for(const auto& dir: dirs)
{
// Prepend previous path
const string& vpath = _virtualPath != "" ? _virtualPath + "/" + dir : dir;
const string& vpath = !_virtualPath.empty() ? _virtualPath + "/" + dir : dir;
myList.emplace_back(new FSNodeZIP(_zipFile, vpath, _realNode, 0, true));
}
@ -215,7 +215,7 @@ bool FSNodeZIP::getChildren(AbstractFSList& myList, ListMode mode) const
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
size_t FSNodeZIP::read(ByteBuffer& image, size_t) const
size_t FSNodeZIP::read(ByteBuffer& buffer, size_t) const
{
switch(_error)
{
@ -234,24 +234,24 @@ size_t FSNodeZIP::read(ByteBuffer& image, size_t) const
found = name == _virtualPath;
}
return found ? myZipHandler->decompress(image) : 0;
return found ? myZipHandler->decompress(buffer) : 0;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
size_t FSNodeZIP::read(stringstream& image) const
size_t FSNodeZIP::read(stringstream& buffer) const
{
// For now, we just read into a buffer and store in the stream
// TODO: maybe there's a more efficient way to do this?
ByteBuffer buffer;
const size_t size = read(buffer, 0);
ByteBuffer read_buf;
const size_t size = read(read_buf, 0);
if(size > 0)
image.write(reinterpret_cast<char*>(buffer.get()), size);
buffer.write(reinterpret_cast<char*>(read_buf.get()), size);
return size;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
size_t FSNodeZIP::write(const ByteBuffer& buffer, size_t size) const
size_t FSNodeZIP::write(const ByteBuffer& buffer, size_t) const
{
// TODO: Not yet implemented
throw runtime_error("ZIP file not writable");
@ -267,7 +267,7 @@ size_t FSNodeZIP::write(const stringstream& buffer) const
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
AbstractFSNodePtr FSNodeZIP::getParent() const
{
if(_virtualPath == "")
if(_virtualPath.empty())
return _realNode ? _realNode->getParent() : nullptr;
const char* start = _path.c_str();

4
src/common/FSNodeZIP.hxx
View File

@ -63,9 +63,9 @@ class FSNodeZIP : public AbstractFSNode
bool getChildren(AbstractFSList& list, ListMode mode) const override;
AbstractFSNodePtr getParent() const override;
size_t read(ByteBuffer& buffer, size_t size) const override;
size_t read(ByteBuffer& buffer, size_t) const override;
size_t read(stringstream& buffer) const override;
size_t write(const ByteBuffer& buffer, size_t size) const override;
size_t write(const ByteBuffer& buffer, size_t) const override;
size_t write(const stringstream& buffer) const override;
private:

69
src/common/HighScoresManager.cxx
View File

@ -85,7 +85,7 @@ Int16 HighScoresManager::peek(uInt16 addr) const
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
const json HighScoresManager::properties(const Properties& props) const
json HighScoresManager::properties(const Properties& props)
{
const string& property = props.get(PropType::Cart_Highscore);
@ -95,7 +95,6 @@ const json HighScoresManager::properties(const Properties& props) const
return json::parse(property);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
json HighScoresManager::properties(json& jprops) const
{
@ -114,7 +113,6 @@ json HighScoresManager::properties(json& jprops) const
return jprops = properties(props);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool HighScoresManager::enabled() const
{
@ -124,12 +122,11 @@ bool HighScoresManager::enabled() const
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt32 HighScoresManager::numVariations(const json& jprops) const
uInt32 HighScoresManager::numVariations(const json& jprops)
{
return min(getPropInt(jprops, VARIATIONS_COUNT, DEFAULT_VARIATION), MAX_VARIATIONS);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool HighScoresManager::get(const Properties& props, uInt32& numVariationsR,
ScoresProps& info) const
@ -159,7 +156,7 @@ bool HighScoresManager::get(const Properties& props, uInt32& numVariationsR,
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void HighScoresManager::set(Properties& props, uInt32 numVariations,
const ScoresProps& info) const
const ScoresProps& info)
{
json jprops = json::object();
@ -207,85 +204,79 @@ void HighScoresManager::set(Properties& props, uInt32 numVariations,
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt32 HighScoresManager::numDigits(const json& jprops) const
uInt32 HighScoresManager::numDigits(const json& jprops)
{
return min(getPropInt(jprops, SCORE_DIGITS, DEFAULT_DIGITS), MAX_SCORE_DIGITS);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt32 HighScoresManager::trailingZeroes(const json& jprops) const
uInt32 HighScoresManager::trailingZeroes(const json& jprops)
{
return min(getPropInt(jprops, SCORE_TRAILING_ZEROES, DEFAULT_TRAILING), MAX_TRAILING);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool HighScoresManager::scoreBCD(const json& jprops) const
bool HighScoresManager::scoreBCD(const json& jprops)
{
return getPropBool(jprops, SCORE_BCD, DEFAULT_SCORE_BCD);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool HighScoresManager::scoreInvert(const json& jprops) const
bool HighScoresManager::scoreInvert(const json& jprops)
{
return getPropBool(jprops, SCORE_INVERTED, DEFAULT_SCORE_REVERSED);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool HighScoresManager::varBCD(const json& jprops) const
bool HighScoresManager::varBCD(const json& jprops)
{
return getPropBool(jprops, VARIATIONS_BCD, DEFAULT_VARS_BCD);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool HighScoresManager::varZeroBased(const json& jprops) const
bool HighScoresManager::varZeroBased(const json& jprops)
{
return getPropBool(jprops, VARIATIONS_ZERO_BASED, DEFAULT_VARS_ZERO_BASED);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
const string HighScoresManager::specialLabel(const json& jprops) const
string HighScoresManager::specialLabel(const json& jprops)
{
return getPropStr(jprops, SPECIAL_LABEL);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool HighScoresManager::specialBCD(const json& jprops) const
bool HighScoresManager::specialBCD(const json& jprops)
{
return getPropBool(jprops, SPECIAL_BCD, DEFAULT_SPECIAL_BCD);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool HighScoresManager::specialZeroBased(const json& jprops) const
bool HighScoresManager::specialZeroBased(const json& jprops)
{
return getPropBool(jprops, SPECIAL_ZERO_BASED, DEFAULT_SPECIAL_ZERO_BASED);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
const string HighScoresManager::notes(const json& jprops) const
string HighScoresManager::notes(const json& jprops)
{
return getPropStr(jprops, NOTES);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt16 HighScoresManager::varAddress(const json& jprops) const
uInt16 HighScoresManager::varAddress(const json& jprops)
{
return getPropAddr(jprops, VARIATIONS_ADDRESS, DEFAULT_ADDRESS);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt16 HighScoresManager::specialAddress(const json& jprops) const
uInt16 HighScoresManager::specialAddress(const json& jprops)
{
return getPropAddr(jprops, SPECIAL_ADDRESS, DEFAULT_ADDRESS);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt32 HighScoresManager::numAddrBytes(Int32 digits, Int32 trailing) const
{
return (digits - trailing + 1) / 2;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt32 HighScoresManager::numAddrBytes(const json& jprops) const
uInt32 HighScoresManager::numAddrBytes(const json& jprops)
{
return numAddrBytes(numDigits(jprops), trailingZeroes(jprops));
}
@ -299,7 +290,7 @@ Int32 HighScoresManager::numVariations() const
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
const string HighScoresManager::specialLabel() const
string HighScoresManager::specialLabel() const
{
json jprops;
@ -379,7 +370,7 @@ Int32 HighScoresManager::score() const
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
const string HighScoresManager::formattedScore(Int32 score, Int32 width) const
string HighScoresManager::formattedScore(Int32 score, Int32 width) const
{
if(score <= 0)
return "";
@ -403,6 +394,7 @@ const string HighScoresManager::formattedScore(Int32 score, Int32 width) const
return buf.str();
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
string HighScoresManager::md5Props() const
{
json jprops;
@ -425,6 +417,7 @@ string HighScoresManager::md5Props() const
return MD5::hash(buf.str());
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool HighScoresManager::scoreInvert() const
{
json jprops;
@ -455,7 +448,7 @@ Int32 HighScoresManager::special() const
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
const string HighScoresManager::notes() const
string HighScoresManager::notes() const
{
json jprops;
@ -463,7 +456,8 @@ const string HighScoresManager::notes() const
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Int32 HighScoresManager::convert(Int32 val, uInt32 maxVal, bool isBCD, bool zeroBased) const
Int32 HighScoresManager::convert(Int32 val, uInt32 maxVal, bool isBCD,
bool zeroBased)
{
//maxVal += zeroBased ? 0 : 1;
maxVal -= zeroBased ? 1 : 0;
@ -487,29 +481,28 @@ Int32 HighScoresManager::convert(Int32 val, uInt32 maxVal, bool isBCD, bool zero
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool HighScoresManager::getPropBool(const json& jprops, const string& key,
bool defVal) const
bool defVal)
{
return jprops.contains(key) ? jprops.at(key).get<bool>() : defVal;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt32 HighScoresManager::getPropInt(const json& jprops, const string& key,
uInt32 defVal) const
uInt32 defVal)
{
return jprops.contains(key) ? jprops.at(key).get<uInt32>() : defVal;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
const string HighScoresManager::getPropStr(const json& jprops, const string& key,
const string& defVal) const
string HighScoresManager::getPropStr(const json& jprops, const string& key,
const string& defVal)
{
return jprops.contains(key) ? jprops.at(key).get<string>() : defVal;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt16 HighScoresManager::getPropAddr(const json& jprops, const string& key,
uInt16 defVal) const
uInt16 defVal)
{
const string str = getPropStr(jprops, key);
@ -517,7 +510,7 @@ uInt16 HighScoresManager::getPropAddr(const json& jprops, const string& key,
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
const HSM::ScoreAddresses HighScoresManager::getPropScoreAddr(const json& jprops) const
HSM::ScoreAddresses HighScoresManager::getPropScoreAddr(const json& jprops)
{
ScoreAddresses scoreAddr{};
@ -544,7 +537,7 @@ const HSM::ScoreAddresses HighScoresManager::getPropScoreAddr(const json& jprops
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt16 HighScoresManager::fromHexStr(const string& addr) const
uInt16 HighScoresManager::fromHexStr(const string& addr)
{
string naked = addr;
@ -555,7 +548,7 @@ uInt16 HighScoresManager::fromHexStr(const string& addr) const
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Int32 HighScoresManager::fromBCD(uInt8 bcd) const
Int32 HighScoresManager::fromBCD(uInt8 bcd)
{
// verify if score is legit
if ((bcd & 0xF0) >= 0xA0 || (bcd & 0xF) >= 0xA)

78
src/common/HighScoresManager.hxx
View File

@ -112,8 +112,8 @@ class HighScoresManager
/**
Set the highscore data of game's properties
*/
void set(Properties& props, uInt32 numVariations,
const HSM::ScoresProps& info) const;
static void set(Properties& props, uInt32 numVariations,
const HSM::ScoresProps& info);
/**
Calculate the score from given parameters
@ -125,24 +125,26 @@ class HighScoresManager
// Convert the given value, using only the maximum bits required by maxVal
// and adjusted for BCD and zero based data
Int32 convert(Int32 val, uInt32 maxVal, bool isBCD, bool zeroBased) const;
static Int32 convert(Int32 val, uInt32 maxVal, bool isBCD, bool zeroBased);
/**
Calculate the number of bytes for one player's score from given parameters
@return The number of score address bytes
*/
uInt32 numAddrBytes(Int32 digits, Int32 trailing) const;
static uInt32 numAddrBytes(Int32 digits, Int32 trailing) {
return (digits - trailing + 1) / 2;
}
// Retrieve current values (using game's properties)
Int32 numVariations() const;
const string specialLabel() const;
string specialLabel() const;
Int32 variation() const;
Int32 score() const;
const string formattedScore(Int32 score, Int32 width = -1) const;
string formattedScore(Int32 score, Int32 width = -1) const;
bool scoreInvert() const;
Int32 special() const;
const string notes() const;
string notes() const;
// Get md5 property definition checksum
string md5Props() const;
@ -150,8 +152,8 @@ class HighScoresManager
// Peek into memory
Int16 peek(uInt16 addr) const;
void loadHighScores(HSM::ScoresData& scores);
void saveHighScores(HSM::ScoresData& scores) const;
void loadHighScores(HSM::ScoresData& data);
void saveHighScores(HSM::ScoresData& data) const;
private:
static const string VARIATIONS_COUNT;
@ -198,53 +200,53 @@ class HighScoresManager
Int32 variation(uInt16 addr, bool varBCD, bool zeroBased, uInt32 numVariations) const;
// Get individual highscore info from properties
uInt32 numVariations(const json& jprops) const;
uInt16 varAddress(const json& jprops) const;
uInt16 specialAddress(const json& jprops) const;
uInt32 numDigits(const json& jprops) const;
uInt32 trailingZeroes(const json& jprops) const;
bool scoreBCD(const json& jprops) const;
bool scoreInvert(const json& jprops) const;
bool varBCD(const json& jprops) const;
bool varZeroBased(const json& jprops) const;
const string specialLabel(const json& jprops) const;
bool specialBCD(const json& jprops) const;
bool specialZeroBased(const json& jprops) const;
const string notes(const json& jprops) const;
static uInt32 numVariations(const json& jprops);
static uInt16 varAddress(const json& jprops);
static uInt16 specialAddress(const json& jprops);
static uInt32 numDigits(const json& jprops);
static uInt32 trailingZeroes(const json& jprops);
static bool scoreBCD(const json& jprops);
static bool scoreInvert(const json& jprops);
static bool varBCD(const json& jprops);
static bool varZeroBased(const json& jprops);
static string specialLabel(const json& jprops);
static bool specialBCD(const json& jprops);
static bool specialZeroBased(const json& jprops);
static string notes(const json& jprops);
// Calculate the number of bytes for one player's score from property parameters
uInt32 numAddrBytes(const json& jprops) const;
static uInt32 numAddrBytes(const json& jprops);
// Get properties
const json properties(const Properties& props) const;
static json properties(const Properties& props);
json properties(json& jprops) const;
// Get value from highscore properties for given key
bool getPropBool(const json& jprops, const string& key,
bool defVal = false) const;
uInt32 getPropInt(const json& jprops, const string& key,
uInt32 defVal = 0) const;
const string getPropStr(const json& jprops, const string& key,
const string& defVal = "") const;
uInt16 getPropAddr(const json& jprops, const string& key,
uInt16 defVal = 0) const;
const HSM::ScoreAddresses getPropScoreAddr(const json& jprops) const;
static bool getPropBool(const json& jprops, const string& key,
bool defVal = false);
static uInt32 getPropInt(const json& jprops, const string& key,
uInt32 defVal = 0);
static string getPropStr(const json& jprops, const string& key,
const string& defVal = "");
static uInt16 getPropAddr(const json& jprops, const string& key,
uInt16 defVal = 0);
static HSM::ScoreAddresses getPropScoreAddr(const json& jprops);
uInt16 fromHexStr(const string& addr) const;
Int32 fromBCD(uInt8 bcd) const;
static uInt16 fromHexStr(const string& addr);
static Int32 fromBCD(uInt8 bcd);
string hash(const HSM::ScoresData& data) const;
/**
Loads the current high scores for this game and variation from the given JSON object.
@param hsData The JSON to parse
@param scores The loaded high score data
@param data The loaded high score data
@return The result of the load. True on success, false on failure.
*/
bool load(const json& hsData, HSM::ScoresData& scores);
static bool load(const json& hsData, HSM::ScoresData& data);
void clearHighScores(HSM::ScoresData& data);
static void clearHighScores(HSM::ScoresData& data);
private:
// Reference to the osystem object

2
src/common/JPGLibrary.hxx
View File

@ -77,7 +77,7 @@ class JPGLibrary
@param filename The filename to load the JPG image
@param metaData The meta data of the JPG image
*/
void readMetaData(const string& filename, VariantList& metaData);
static void readMetaData(const string& filename, VariantList& metaData);
private:
// Following constructors and assignment operators not supported

34
src/common/JoyMap.cxx
View File

@ -112,7 +112,7 @@ bool JoyMap::check(const EventMode mode, const int button,
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
string JoyMap::getDesc(const Event::Type event, const JoyMapping& mapping) const
string JoyMap::getDesc(const Event::Type event, const JoyMapping& mapping)
{
ostringstream buf;
@ -166,7 +166,7 @@ string JoyMap::getEventMappingDesc(int stick, const Event::Type event, const Eve
{
if (_event == event && _mapping.mode == mode)
{
if(buf.str() != "")
if(!buf.str().empty())
buf << ", ";
buf << "C" << stick << getDesc(event, _mapping);
}
@ -193,26 +193,26 @@ json JoyMap::saveMapping(const EventMode mode) const
std::vector<MapType> sortedMap(myMap.begin(), myMap.end());
std::sort(sortedMap.begin(), sortedMap.end(),
[](const MapType& a, const MapType& b)
{
// Event::Type first
if(a.first.button != b.first.button)
return a.first.button < b.first.button;
[](const MapType& a, const MapType& b)
{
// Event::Type first
if(a.first.button != b.first.button)
return a.first.button < b.first.button;
if(a.first.axis != b.first.axis)
return a.first.axis < b.first.axis;
if(a.first.axis != b.first.axis)
return a.first.axis < b.first.axis;
if(a.first.adir != b.first.adir)
return a.first.adir < b.first.adir;
if(a.first.adir != b.first.adir)
return a.first.adir < b.first.adir;
if(a.first.hat != b.first.hat)
return a.first.hat < b.first.hat;
if(a.first.hat != b.first.hat)
return a.first.hat < b.first.hat;
if(a.first.hdir != b.first.hdir)
return a.first.hdir < b.first.hdir;
if(a.first.hdir != b.first.hdir)
return a.first.hdir < b.first.hdir;
return a.second < b.second;
}
return a.second < b.second;
}
);
json eventMappings = json::array();

4
src/common/JoyMap.hxx
View File

@ -122,10 +122,10 @@ class JoyMap
void eraseEvent(const Event::Type event, const EventMode mode);
/** clear all mappings for a modes */
// void clear() { myMap.clear(); }
size_t size() { return myMap.size(); }
size_t size() const { return myMap.size(); }
private:
string getDesc(const Event::Type event, const JoyMapping& mapping) const;
static string getDesc(const Event::Type event, const JoyMapping& mapping);
struct JoyHash {
size_t operator()(const JoyMapping& m)const {

8
src/common/KeyMap.cxx
View File

@ -135,7 +135,7 @@ bool KeyMap::check(const EventMode mode, const int key, const int mod) const
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
string KeyMap::getDesc(const Mapping& mapping) const
string KeyMap::getDesc(const Mapping& mapping)
{
ostringstream buf;
#if defined(BSPF_MACOS) || defined(MACOS_KEYS)
@ -184,7 +184,7 @@ string KeyMap::getDesc(const Mapping& mapping) const
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
string KeyMap::getDesc(const EventMode mode, const int key, const int mod) const
string KeyMap::getDesc(const EventMode mode, const int key, const int mod)
{
return getDesc(Mapping(mode, key, mod));
}
@ -198,7 +198,7 @@ string KeyMap::getEventMappingDesc(const Event::Type event, const EventMode mode
{
if (_event == event && _mapping.mode == mode)
{
if(buf.str() != "")
if(!buf.str().empty())
buf << ", ";
buf << getDesc(_mapping);
}
@ -336,7 +336,7 @@ void KeyMap::eraseEvent(const Event::Type event, const EventMode mode)
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
KeyMap::Mapping KeyMap::convertMod(const Mapping& mapping) const
KeyMap::Mapping KeyMap::convertMod(const Mapping& mapping)
{
Mapping m = mapping;

6
src/common/KeyMap.hxx
View File

@ -79,8 +79,8 @@ class KeyMap
bool check(const EventMode mode, const int key, const int mod) const;
/** Get mapping description */
string getDesc(const Mapping& mapping) const;
string getDesc(const EventMode mode, const int key, const int mod) const;
static string getDesc(const Mapping& mapping);
static string getDesc(const EventMode mode, const int key, const int mod);
/** Get the mapping description(s) for given event and mode */
string getEventMappingDesc(const Event::Type event, const EventMode mode) const;
@ -104,7 +104,7 @@ class KeyMap
private:
//** Convert modifiers */
Mapping convertMod(const Mapping& mapping) const;
static Mapping convertMod(const Mapping& mapping);
struct KeyHash {
size_t operator()(const Mapping& m) const {

2
src/common/MouseControl.cxx
View File

@ -129,7 +129,7 @@ MouseControl::MouseControl(Console& console, const string& mode)
Paddles::setDigitalPaddleRange(m_range);
// If the mouse isn't used at all, we still need one item in the list
if(myModeList.size() == 0)
if(myModeList.empty())
myModeList.emplace_back("Mouse not used for current controllers");
#if 0

2
src/common/MouseControl.hxx
View File

@ -73,7 +73,7 @@ class MouseControl
void addLeftControllerModes(bool noswap);
void addRightControllerModes(bool noswap);
void addPaddleModes(int lport, int rport, int lname, int rname);
bool controllerSupportsMouse(Controller& controller);
static bool controllerSupportsMouse(Controller& controller);
private:
const Properties& myProps;

26
src/common/PJoystickHandler.cxx
View File

@ -15,7 +15,6 @@
// this file, and for a DISCLAIMER OF ALL WARRANTIES.
//============================================================================
#include "Logger.hxx"
#include "OSystem.hxx"
#include "Console.hxx"
#include "Joystick.hxx"
@ -298,7 +297,7 @@ bool PhysicalJoystickHandler::mapStelladaptors(const string& saport, int ID)
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool PhysicalJoystickHandler::hasStelladaptors() const
{
for(auto& [_id, _joyptr] : mySticks)
for(const auto& [_id, _joyptr] : mySticks)
{
// remove previously added emulated ports
const size_t pos = _joyptr->name.find(" (emulates ");
@ -332,7 +331,7 @@ void PhysicalJoystickHandler::setDefaultAction(int stick,
{
// if there is no existing mapping for the event and
// the default mapping for the event is unused, set default key for event
if(j->joyMap.getEventMapping(map.event, mode).size() == 0 &&
if(j->joyMap.getEventMapping(map.event, mode).empty() &&
!j->joyMap.check(mode, map.button, map.axis, map.adir, map.hat, map.hdir))
{
if (map.hat == JOY_CTRL_NONE)
@ -353,8 +352,8 @@ void PhysicalJoystickHandler::setDefaultAction(int stick,
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void PhysicalJoystickHandler::setStickDefaultMapping(int stick, Event::Type event,
EventMode mode, bool updateDefaults)
void PhysicalJoystickHandler::setStickDefaultMapping(
int stick, Event::Type event, EventMode mode, bool updateDefaults)
{
const PhysicalJoystickPtr j = joy(stick);
@ -617,7 +616,8 @@ void PhysicalJoystickHandler::enableMapping(const Event::Type event, EventMode m
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
EventMode PhysicalJoystickHandler::getEventMode(const Event::Type event, const EventMode mode) const
EventMode PhysicalJoystickHandler::getEventMode(const Event::Type event,
const EventMode mode)
{
if(mode == EventMode::kEmulationMode)
{
@ -641,35 +641,35 @@ EventMode PhysicalJoystickHandler::getEventMode(const Event::Type event, const E
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool PhysicalJoystickHandler::isJoystickEvent(const Event::Type event) const
bool PhysicalJoystickHandler::isJoystickEvent(const Event::Type event)
{
return LeftJoystickEvents.find(event) != LeftJoystickEvents.end()
|| RightJoystickEvents.find(event) != RightJoystickEvents.end();
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool PhysicalJoystickHandler::isPaddleEvent(const Event::Type event) const
bool PhysicalJoystickHandler::isPaddleEvent(const Event::Type event)
{
return LeftPaddlesEvents.find(event) != LeftPaddlesEvents.end()
|| RightPaddlesEvents.find(event) != RightPaddlesEvents.end();
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool PhysicalJoystickHandler::isKeyboardEvent(const Event::Type event) const
bool PhysicalJoystickHandler::isKeyboardEvent(const Event::Type event)
{
return LeftKeyboardEvents.find(event) != LeftKeyboardEvents.end()
|| RightKeyboardEvents.find(event) != RightKeyboardEvents.end();
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool PhysicalJoystickHandler::isDrivingEvent(const Event::Type event) const
bool PhysicalJoystickHandler::isDrivingEvent(const Event::Type event)
{
return LeftDrivingEvents.find(event) != LeftDrivingEvents.end()
|| RightDrivingEvents.find(event) != RightDrivingEvents.end();
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool PhysicalJoystickHandler::isCommonEvent(const Event::Type event) const
bool PhysicalJoystickHandler::isCommonEvent(const Event::Type event)
{
return !(isJoystickEvent(event) || isPaddleEvent(event) || isKeyboardEvent(event) || isDrivingEvent(event));
}
@ -732,9 +732,9 @@ string PhysicalJoystickHandler::getMappingDesc(Event::Type event, EventMode mode
if(_joyptr)
{
//Joystick mapping / labeling
if(_joyptr->joyMap.getEventMapping(event, evMode).size())
if(!_joyptr->joyMap.getEventMapping(event, evMode).empty())
{
if(buf.str() != "")
if(!buf.str().empty())
buf << ", ";
buf << _joyptr->joyMap.getEventMappingDesc(_id, event, evMode);
}

16
src/common/PJoystickHandler.hxx
View File

@ -76,7 +76,7 @@ class PhysicalJoystickHandler
bool remove(const string& name);
bool mapStelladaptors(const string& saport, int ID = -1);
bool hasStelladaptors() const;
void setDefaultMapping(Event::Type type, EventMode mode);
void setDefaultMapping(Event::Type event, EventMode mode);
/** define mappings for current controllers */
void defineControllerMappings(const Controller::Type type, Controller::Jack port);
@ -150,7 +150,7 @@ class PhysicalJoystickHandler
void addToDatabase(const PhysicalJoystickPtr& stick);
// Set default mapping for given joystick when no mappings already exist
void setStickDefaultMapping(int stick, Event::Type type, EventMode mode,
void setStickDefaultMapping(int stick, Event::Type event, EventMode mode,
bool updateDefaults = false);
friend ostream& operator<<(ostream& os, const PhysicalJoystickHandler& jh);
@ -180,13 +180,13 @@ class PhysicalJoystickHandler
bool updateDefaults = false);
/** returns the event's controller mode */
EventMode getEventMode(const Event::Type event, const EventMode mode) const;
static EventMode getEventMode(const Event::Type event, const EventMode mode);
/** Checks event type. */
bool isJoystickEvent(const Event::Type event) const;
bool isPaddleEvent(const Event::Type event) const;
bool isKeyboardEvent(const Event::Type event) const;
bool isDrivingEvent(const Event::Type event) const;
bool isCommonEvent(const Event::Type event) const;
static bool isJoystickEvent(const Event::Type event);
static bool isPaddleEvent(const Event::Type event);
static bool isKeyboardEvent(const Event::Type event);
static bool isDrivingEvent(const Event::Type event);
static bool isCommonEvent(const Event::Type event);
void enableCommonMappings();

17
src/common/PKeyboardHandler.cxx
View File

@ -145,7 +145,7 @@ void PhysicalKeyboardHandler::setDefaultKey(EventMapping map, Event::Type event,
{
// if there is no existing mapping for the event and
// the default mapping for the event is unused, set default key for event
if (myKeyMap.getEventMapping(map.event, mode).size() == 0 &&
if (myKeyMap.getEventMapping(map.event, mode).empty() &&
!isMappingUsed(mode, map))
{
addMapping(map.event, mode, map.key, static_cast<StellaMod>(map.mod));
@ -249,7 +249,8 @@ void PhysicalKeyboardHandler::defineControllerMappings(
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
EventMode PhysicalKeyboardHandler::getMode(const Properties& properties, const PropType propType)
EventMode PhysicalKeyboardHandler::getMode(const Properties& properties,
const PropType propType)
{
const string& propName = properties.get(propType);
@ -403,7 +404,7 @@ void PhysicalKeyboardHandler::enableMapping(const Event::Type event,
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
EventMode PhysicalKeyboardHandler::getEventMode(const Event::Type event,
const EventMode mode) const
const EventMode mode)
{
if (mode == EventMode::kEmulationMode)
{
@ -427,7 +428,7 @@ EventMode PhysicalKeyboardHandler::getEventMode(const Event::Type event,
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool PhysicalKeyboardHandler::isJoystickEvent(const Event::Type event) const
bool PhysicalKeyboardHandler::isJoystickEvent(const Event::Type event)
{
return LeftJoystickEvents.find(event) != LeftJoystickEvents.end()
|| QTJoystick3Events.find(event) != QTJoystick3Events.end()
@ -436,7 +437,7 @@ bool PhysicalKeyboardHandler::isJoystickEvent(const Event::Type event) const
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool PhysicalKeyboardHandler::isPaddleEvent(const Event::Type event) const
bool PhysicalKeyboardHandler::isPaddleEvent(const Event::Type event)
{
return LeftPaddlesEvents.find(event) != LeftPaddlesEvents.end()
|| QTPaddles3Events.find(event) != QTPaddles3Events.end()
@ -445,21 +446,21 @@ bool PhysicalKeyboardHandler::isPaddleEvent(const Event::Type event) const
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool PhysicalKeyboardHandler::isDrivingEvent(const Event::Type event) const
bool PhysicalKeyboardHandler::isDrivingEvent(const Event::Type event)
{
return LeftDrivingEvents.find(event) != LeftDrivingEvents.end()
|| RightDrivingEvents.find(event) != RightDrivingEvents.end();
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool PhysicalKeyboardHandler::isKeyboardEvent(const Event::Type event) const
bool PhysicalKeyboardHandler::isKeyboardEvent(const Event::Type event)
{
return LeftKeyboardEvents.find(event) != LeftKeyboardEvents.end()
|| RightKeyboardEvents.find(event) != RightKeyboardEvents.end();
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool PhysicalKeyboardHandler::isCommonEvent(const Event::Type event) const
bool PhysicalKeyboardHandler::isCommonEvent(const Event::Type event)
{
return !(isJoystickEvent(event) || isPaddleEvent(event) || isKeyboardEvent(event));
}

22
src/common/PKeyboardHandler.hxx
View File

@ -48,10 +48,12 @@ class PhysicalKeyboardHandler
void loadSerializedMappings(const string& serializedMappings, EventMode mode);
void setDefaultMapping(Event::Type type, EventMode mode, bool updateDefaults = false);
void setDefaultMapping(Event::Type event, EventMode mode,
bool updateDefaults = false);
/** define mappings for current controllers */
void defineControllerMappings(const Controller::Type type, Controller::Jack port,
void defineControllerMappings(const Controller::Type type,
Controller::Jack port,
const Properties& properties);
/** enable mappings for emulation mode */
void enableEmulationMappings();
@ -100,13 +102,13 @@ class PhysicalKeyboardHandler
EventMode mode = EventMode::kEmulationMode, bool updateDefaults = false);
/** returns the event's controller mode */
EventMode getEventMode(const Event::Type event, const EventMode mode) const;
static EventMode getEventMode(const Event::Type event, const EventMode mode);
/** Checks event type. */
bool isJoystickEvent(const Event::Type event) const;
bool isPaddleEvent(const Event::Type event) const;
bool isKeyboardEvent(const Event::Type event) const;
bool isDrivingEvent(const Event::Type event) const;
bool isCommonEvent(const Event::Type event) const;
static bool isJoystickEvent(const Event::Type event);
static bool isPaddleEvent(const Event::Type event);
static bool isKeyboardEvent(const Event::Type event);
static bool isDrivingEvent(const Event::Type event);
static bool isCommonEvent(const Event::Type event);
void enableCommonMappings();
@ -114,9 +116,9 @@ class PhysicalKeyboardHandler
void enableMapping(const Event::Type event, EventMode mode);
/** return event mode for given property */
EventMode getMode(const Properties& properties, const PropType propType);
static EventMode getMode(const Properties& properties, const PropType propType);
/** return event mode for given controller type */
EventMode getMode(const Controller::Type type);
static EventMode getMode(const Controller::Type type);
private:
OSystem& myOSystem;

12
src/common/PNGLibrary.cxx
View File

@ -382,20 +382,20 @@ void PNGLibrary::takeSnapshot(uInt32 number)
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool PNGLibrary::allocateStorage(size_t w, size_t h)
bool PNGLibrary::allocateStorage(size_t width, size_t height)
{
// Create space for the entire image (3 bytes per pixel in RGB format)
const size_t req_buffer_size = w * h * 3;
const size_t req_buffer_size = width * height * 3;
if(req_buffer_size > ReadInfo.buffer.capacity())
ReadInfo.buffer.reserve(req_buffer_size * 1.5);
const size_t req_row_size = h;
const size_t req_row_size = height;
if(req_row_size > ReadInfo.row_pointers.capacity())
ReadInfo.row_pointers.reserve(req_row_size * 1.5);
ReadInfo.width = static_cast<png_uint_32>(w);
ReadInfo.height = static_cast<png_uint_32>(h);
ReadInfo.pitch = static_cast<png_uint_32>(w * 3);
ReadInfo.width = static_cast<png_uint_32>(width);
ReadInfo.height = static_cast<png_uint_32>(height);
ReadInfo.pitch = static_cast<png_uint_32>(width * 3);
return true;
}

41
src/common/PNGLibrary.hxx
View File

@ -49,7 +49,8 @@ class PNGLibrary
runtime_error is thrown containing a more detailed
error message.
*/
void loadImage(const string& filename, FBSurface& surface, VariantList& metaData);
void loadImage(const string& filename, FBSurface& surface,
VariantList& metaData);
/**
Save the current FrameBuffer image to a PNG file. Note that in most
@ -78,9 +79,9 @@ class PNGLibrary
otherwise a runtime_error is thrown containing a
more detailed error message.
*/
void saveImage(const string& filename, const FBSurface& surface,
const Common::Rect& rect = Common::Rect{},
const VariantList& metaData = VariantList{});
static void saveImage(const string& filename, const FBSurface& surface,
const Common::Rect& rect = Common::Rect{},
const VariantList& metaData = VariantList{});
/**
Called at regular intervals, and used to determine whether a
@ -149,10 +150,10 @@ class PNGLibrary
dependent on the given dimensions. If memory has been previously
allocated and it can accommodate the given dimensions, it is used directly.
@param iwidth The width of the PNG image
@param iheight The height of the PNG image
@param width The width of the PNG image
@param height The height of the PNG image
*/
bool allocateStorage(size_t iwidth, size_t iheight);
static bool allocateStorage(size_t width, size_t height);
/** The actual method which saves a PNG image.
@ -162,9 +163,9 @@ class PNGLibrary
@param height The height of the PNG image
@param metaData The meta data to add to the PNG image
*/
void saveImageToDisk(std::ofstream& out, const vector<png_bytep>& rows,
size_t width, size_t height,
const VariantList& metaData);
static void saveImageToDisk(std::ofstream& out, const vector<png_bytep>& rows,
size_t width, size_t height,
const VariantList& metaData);
/**
Load the PNG data from 'ReadInfo' into the FBSurface. The surface
@ -177,21 +178,25 @@ class PNGLibrary
/**
Write PNG tEXt chunks to the image.
*/
void writeMetaData(const png_structp png_ptr, png_infop info_ptr,
const VariantList& metaData);
static void writeMetaData(const png_structp png_ptr, png_infop info_ptr,
const VariantList& metaData);
/**
Read PNG tEXt chunks from the image.
*/
void readMetaData(const png_structp png_ptr, png_infop info_ptr,
VariantList& metaData);
static void readMetaData(const png_structp png_ptr, png_infop info_ptr,
VariantList& metaData);
/** PNG library callback functions */
static void png_read_data(const png_structp ctx, png_bytep area, png_size_t size);
static void png_write_data(const png_structp ctx, png_bytep area, png_size_t size);
static void png_read_data(const png_structp ctx, png_bytep area,
png_size_t size);
static void png_write_data(const png_structp ctx, png_bytep area,
png_size_t size);
static void png_io_flush(const png_structp ctx);
[[noreturn]] static void png_user_warn(const png_structp ctx, png_const_charp str);
[[noreturn]] static void png_user_error(const png_structp ctx, png_const_charp str);
[[noreturn]] static void png_user_warn(const png_structp ctx,
png_const_charp str);
[[noreturn]] static void png_user_error(const png_structp ctx,
png_const_charp str);
private:
// Following constructors and assignment operators not supported

14
src/common/PaletteHandler.cxx
View File

@ -44,7 +44,7 @@ PaletteHandler::PaletteType PaletteHandler::toPaletteType(const string& name) co
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
string PaletteHandler::toPaletteName(PaletteType type) const
string PaletteHandler::toPaletteName(PaletteType type)
{
const string SETTING_NAMES[int(PaletteType::NumTypes)] = {
SETTING_STANDARD, SETTING_Z26, SETTING_USER, SETTING_CUSTOM
@ -341,7 +341,7 @@ void PaletteHandler::setPalette()
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
PaletteArray PaletteHandler::adjustedPalette(const PaletteArray& palette)
PaletteArray PaletteHandler::adjustedPalette(const PaletteArray& palette) const
{
PaletteArray destPalette{0};
// Constants for saturation and gray scale calculation
@ -443,7 +443,7 @@ void PaletteHandler::loadUserPalette()
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void PaletteHandler::generateCustomPalette(ConsoleTiming timing)
void PaletteHandler::generateCustomPalette(ConsoleTiming timing) const
{
constexpr int NUM_CHROMA = 16;
constexpr int NUM_LUMA = 8;
@ -572,7 +572,8 @@ void PaletteHandler::adjustHueSaturation(int& R, int& G, int& B, float H, float
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
PaletteHandler::vector2d PaletteHandler::rotate(const PaletteHandler::vector2d& vec, float angle) const
PaletteHandler::vector2d
PaletteHandler::rotate(const PaletteHandler::vector2d& vec, float angle)
{
const float r = angle * BSPF::PI_f / 180;
@ -581,14 +582,15 @@ PaletteHandler::vector2d PaletteHandler::rotate(const PaletteHandler::vector2d&
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
PaletteHandler::vector2d PaletteHandler::scale(const PaletteHandler::vector2d& vec, float factor) const
PaletteHandler::vector2d
PaletteHandler::scale(const PaletteHandler::vector2d& vec, float factor)
{
return PaletteHandler::vector2d(vec.x * factor, vec.y * factor);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
float PaletteHandler::dotProduct(const PaletteHandler::vector2d& vec1,
const PaletteHandler::vector2d& vec2) const
const PaletteHandler::vector2d& vec2)
{
return vec1.x * vec2.x + vec1.y * vec2.y;
}

16
src/common/PaletteHandler.hxx
View File

@ -187,7 +187,7 @@ class PaletteHandler
@return The palette's settings name
*/
string toPaletteName(PaletteType type) const;
static string toPaletteName(PaletteType type);
/**
Display current adjustable with gauge bar message
@ -208,16 +208,16 @@ class PaletteHandler
@param timing Use NTSC or PAL phase shift and generate according palette
*/
void generateCustomPalette(ConsoleTiming timing);
void generateCustomPalette(ConsoleTiming timing) const;
/**
Create new palette by applying palette adjustments on given palette.
@param source The palette which should be adjusted
@param palette The palette which should be adjusted
@return An adjusted palette
*/
PaletteArray adjustedPalette(const PaletteArray& source);
PaletteArray adjustedPalette(const PaletteArray& palette) const;
/**
Adjust hue and saturation for given RGB values.
@ -228,22 +228,22 @@ class PaletteHandler
@param H The hue adjustment value
@param S The saturation
*/
void adjustHueSaturation(int& R, int& G, int& B, float H, float S);
static void adjustHueSaturation(int& R, int& G, int& B, float H, float S);
/**
Rotate a 2D vector.
*/
vector2d rotate(const vector2d& vec, float angle) const;
static vector2d rotate(const vector2d& vec, float angle);
/**
Scale a 2D vector.
*/
vector2d scale(const vector2d& vec, float factor) const;
static vector2d scale(const vector2d& vec, float factor);
/**
Get the dot product of two 2D vectors.
*/
float dotProduct(const vector2d& vec1, const vector2d& vec2) const;
static float dotProduct(const vector2d& vec1, const vector2d& vec2);
/**
Loads a user-defined palette file (from OSystem::paletteFile), filling the

7
src/common/PhysicalJoystick.cxx
View File

@ -70,9 +70,8 @@ json PhysicalJoystick::getMap() const
mapping["name"] = name;
for (auto& mode: {
EventMode::kMenuMode, EventMode::kJoystickMode, EventMode::kPaddlesMode, EventMode::kKeyboardMode,
EventMode::kDrivingMode, EventMode::kCommonMode
for (const auto& mode: {
EventMode::kMenuMode, EventMode::kJoystickMode, EventMode::kPaddlesMode, EventMode::kKeyboardMode, EventMode::kDrivingMode, EventMode::kCommonMode
})
mapping[jsonName(mode)] = joyMap.saveMapping(mode);
@ -153,7 +152,7 @@ void PhysicalJoystick::eraseEvent(Event::Type event, EventMode mode)
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void PhysicalJoystick::getValues(const string& list, IntArray& map) const
void PhysicalJoystick::getValues(const string& list, IntArray& map)
{
map.clear();
istringstream buf(list);

2
src/common/PhysicalJoystick.hxx
View File

@ -76,7 +76,7 @@ class PhysicalJoystick
JoyMap joyMap;
private:
void getValues(const string& list, IntArray& map) const;
static void getValues(const string& list, IntArray& map);
friend ostream& operator<<(ostream& os, const PhysicalJoystick& s) {
os << " ID: " << s.ID << ", name: " << s.name << ", numaxis: " << s.numAxes

8
src/common/SoundSDL2.cxx
View File

@ -137,12 +137,12 @@ bool SoundSDL2::openDevice()
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void SoundSDL2::setEnabled(bool state)
void SoundSDL2::setEnabled(bool enable)
{
myAudioSettings.setEnabled(state);
if (myAudioQueue) myAudioQueue->ignoreOverflows(!state);
myAudioSettings.setEnabled(enable);
if (myAudioQueue) myAudioQueue->ignoreOverflows(!enable);
Logger::debug(state ? "SoundSDL2::setEnabled(true)" :
Logger::debug(enable ? "SoundSDL2::setEnabled(true)" :
"SoundSDL2::setEnabled(false)");
}

9
src/common/StaggeredLogger.hxx
View File

@ -28,9 +28,10 @@
#include "Logger.hxx"
/**
* This class buffers log events and logs them after a certain time window has expired.
* The timout increases after every log line by a factor of two until a maximum is reached.
* If no events are reported, the window size decreases again.
* This class buffers log events and logs them after a certain time window has
* expired. The timout increases after every log line by a factor of two until
* a maximum is reached. If no events are reported, the window size decreases
* again.
*/
class StaggeredLogger
@ -46,7 +47,7 @@ class StaggeredLogger
void _log();
void onTimerExpired(uInt32 timerId);
void onTimerExpired(uInt32 timerCallbackId);
void startInterval();

2
src/common/ThreadDebugging.hxx
View File

@ -46,7 +46,7 @@ class ThreadDebuggingHelper {
private:
[[noreturn]] void fail(const string& message);
[[noreturn]] static void fail(const string& message);
ThreadDebuggingHelper() = default;

3
src/common/TimerManager.cxx
View File

@ -20,8 +20,7 @@
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
TimerManager::TimerManager()
: nextId{no_timer + 1},
queue()
: nextId{no_timer + 1}
{
}

10
src/common/main.cxx
View File

@ -281,7 +281,7 @@ int main(int ac, char* av[])
{
attachConsole();
Logger::debug("Displaying usage");
theOSystem->settings().usage();
Settings::usage();
freeConsole();
return Cleanup();
}
@ -294,15 +294,15 @@ int main(int ac, char* av[])
// If not, use the built-in ROM launcher. In this case, we enter 'launcher'
// mode and let the main event loop take care of opening a new console/ROM.
FSNode romnode(romfile);
if(romfile == "" || romnode.isDirectory())
if(romfile.empty() || romnode.isDirectory())
{
Logger::debug("Attempting to use ROM launcher ...");
bool launcherOpened = romfile != "" ?
bool launcherOpened = !romfile.empty() ?
theOSystem->createLauncher(romnode.getPath()) : theOSystem->createLauncher();
if(!launcherOpened)
{
Logger::debug("Launcher could not be started, showing usage");
theOSystem->settings().usage();
Settings::usage();
return Cleanup();
}
}
@ -333,7 +333,7 @@ int main(int ac, char* av[])
#ifdef DEBUGGER_SUPPORT
// Set up any breakpoint that was on the command line
if(localOpts["break"].toString() != "")
if(!localOpts["break"].toString().empty())
{
Debugger& dbg = theOSystem->debugger();
uInt16 bp = uInt16(dbg.stringToValue(localOpts["break"].toString()));

2
src/common/repository/KeyValueRepositoryConfigfile.hxx
View File

@ -27,7 +27,7 @@ class KeyValueRepositoryConfigfile : public KeyValueRepositoryFile<KeyValueRepos
using KeyValueRepositoryFile<KeyValueRepositoryConfigfile>::load;
using KeyValueRepositoryFile<KeyValueRepositoryConfigfile>::save;
explicit KeyValueRepositoryConfigfile(const FSNode& node);
explicit KeyValueRepositoryConfigfile(const FSNode& file);
static std::map<string, Variant> load(istream& in);

4
src/common/repository/KeyValueRepositoryPropertyFile.cxx
View File

@ -91,7 +91,7 @@ std::map<string, Variant> KeyValueRepositoryPropertyFile::load(istream& in)
if(!in) return map;
// A null key signifies the end of the property list
if(key == "")
if(key.empty())
break;
// Get the value associated with this property
@ -111,7 +111,7 @@ std::map<string, Variant> KeyValueRepositoryPropertyFile::load(istream& in)
bool KeyValueRepositoryPropertyFile::save(ostream& out,
const std::map<string, Variant>& values)
{
for (auto& [key, value]: values) {
for (const auto& [key, value]: values) {
writeQuotedString(out, key);
out.put(' ');
writeQuotedString(out, value.toString());

24
src/common/repository/sqlite/CompositeKeyValueRepositorySqlite.cxx
View File

@ -45,7 +45,7 @@ bool CompositeKeyValueRepositorySqlite::has(const string& key)
try {
(*myStmtCountSet)
.reset()
.bind(1, key.c_str());
.bind(1, key);
if (!myStmtCountSet->step())
throw SqliteError("count failed");
@ -68,7 +68,7 @@ void CompositeKeyValueRepositorySqlite::remove(const string& key)
try {
(*myStmtDeleteSet)
.reset()
.bind(1, key.c_str())
.bind(1, key)
.step();
myStmtDelete->reset();
@ -153,9 +153,9 @@ SqliteStatement& CompositeKeyValueRepositorySqlite::ProxyRepository::stmtInsert(
) {
return (*myRepo.myStmtInsert)
.reset()
.bind(1, myKey.c_str())
.bind(2, key.c_str())
.bind(3, value.c_str());
.bind(1, myKey)
.bind(2, key)
.bind(3, value);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -163,7 +163,7 @@ SqliteStatement& CompositeKeyValueRepositorySqlite::ProxyRepository::stmtSelect(
{
return (*myRepo.myStmtSelect)
.reset()
.bind(1, myKey.c_str());
.bind(1, myKey);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -172,8 +172,8 @@ SqliteStatement& CompositeKeyValueRepositorySqlite::ProxyRepository::stmtDelete(
myRepo.myStmtDelete->reset();
return (*myRepo.myStmtDelete)
.bind(1, myKey.c_str())
.bind(2, key.c_str());
.bind(1, myKey)
.bind(2, key);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -181,8 +181,8 @@ SqliteStatement& CompositeKeyValueRepositorySqlite::ProxyRepository::stmtSelectO
{
return (*myRepo.myStmtSelectOne)
.reset()
.bind(1, myKey.c_str())
.bind(2, key.c_str());
.bind(1, myKey)
.bind(2, key);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -190,8 +190,8 @@ SqliteStatement& CompositeKeyValueRepositorySqlite::ProxyRepository::stmtCount(c
{
return (*myRepo.myStmtCount)
.reset()
.bind(1, myKey.c_str())
.bind(2, key.c_str());
.bind(1, myKey)
.bind(2, key);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

10
src/common/repository/sqlite/KeyValueRepositorySqlite.cxx
View File

@ -34,8 +34,8 @@ SqliteStatement& KeyValueRepositorySqlite::stmtInsert(const string& key, const s
{
return (*myStmtInsert)
.reset()
.bind(1, key.c_str())
.bind(2, value.c_str());
.bind(1, key)
.bind(2, value);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -50,7 +50,7 @@ SqliteStatement& KeyValueRepositorySqlite::stmtDelete(const string& key)
{
return (*myStmtDelete)
.reset()
.bind(1, key.c_str());
.bind(1, key);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -58,7 +58,7 @@ SqliteStatement& KeyValueRepositorySqlite::stmtCount(const string& key)
{
return (*myStmtCount)
.reset()
.bind(1, key.c_str());
.bind(1, key);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -66,7 +66,7 @@ SqliteStatement& KeyValueRepositorySqlite::stmtSelectOne(const string& key)
{
return (*myStmtSelectOne)
.reset()
.bind(1, key.c_str());
.bind(1, key);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

2
src/common/repository/sqlite/SqliteDatabase.cxx
View File

@ -105,7 +105,7 @@ Int32 SqliteDatabase::getUserVersion() const
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void SqliteDatabase::setUserVersion(Int32 version)
void SqliteDatabase::setUserVersion(Int32 version) const
{
SqliteStatement(*this, "PRAGMA user_version = %i", static_cast<int>(version))
.step();

2
src/common/repository/sqlite/SqliteDatabase.hxx
View File

@ -42,7 +42,7 @@ class SqliteDatabase
void exec(const string& sql, T arg1, Ts... args);
Int32 getUserVersion() const;
void setUserVersion(Int32 version);
void setUserVersion(Int32 version) const;
private:

9
src/common/repository/sqlite/StellaDb.cxx
View File

@ -85,7 +85,7 @@ void StellaDb::initialize()
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
const string StellaDb::databaseFileName() const
string StellaDb::databaseFileName() const
{
return myDb ? FSNode(myDb->fileName()).getShortPath() : "[failed]";
}
@ -190,8 +190,11 @@ void StellaDb::importOldPropset(const FSNode& node)
while (true) {
auto props = KeyValueRepositoryPropertyFile::load(in);
if (props.size() == 0) break;
if ((props.find("Cart.MD5") == props.end()) || props["Cart.MD5"].toString() == "") continue;
if (props.empty())
break;
if ((props.find("Cart.MD5") == props.end()) ||
props["Cart.MD5"].toString().empty())
continue;
myPropertyRepository->get(props["Cart.MD5"].toString())->save(props);
}

17
src/common/repository/sqlite/StellaDb.hxx
View File

@ -27,21 +27,25 @@
class StellaDb
{
public:
StellaDb(const string& databaseDirectory, const string& databaseName);
void initialize();
KeyValueRepositoryAtomic& settingsRepository() const { return *mySettingsRepository; }
CompositeKeyValueRepository& propertyRepository() const { return *myPropertyRepository; }
CompositeKeyValueRepositoryAtomic& highscoreRepository() const { return *myHighscoreRepository; }
KeyValueRepositoryAtomic& settingsRepository() const {
return *mySettingsRepository;
}
CompositeKeyValueRepository& propertyRepository() const {
return *myPropertyRepository;
}
CompositeKeyValueRepositoryAtomic& highscoreRepository() const {
return *myHighscoreRepository;
}
const string databaseFileName() const;
string databaseFileName() const;
bool isValid() const;
private:
void initializeDb();
void importOldSettings();
void importStellarc(const FSNode& node);
@ -51,7 +55,6 @@ class StellaDb
void migrate();
private:
string myDatabaseDirectory;
string myDatabaseName;

6
src/common/tv_filters/AtariNTSC.hxx
View File

@ -187,10 +187,10 @@ class AtariNTSC
0.9563F, 0.6210F, -0.2721F, -0.6474F, -1.1070F, 1.7046F
};
void init(init_t& impl, const Setup& setup);
void initFilters(init_t& impl, const Setup& setup);
static void init(init_t& impl, const Setup& setup);
static void initFilters(init_t& impl, const Setup& setup);
// Generate pixel at all burst phases and column alignments
void genKernel(init_t& impl, float y, float i, float q, uInt32* out);
static void genKernel(init_t& impl, float y, float i, float q, uInt32* out);
// Begins outputting row and starts two pixels. First pixel will be cut
// off a bit. Use atari_ntsc_black for unused pixels.

6
src/common/tv_filters/NTSCFilter.cxx
View File

@ -139,7 +139,7 @@ void NTSCFilter::loadConfig(const Settings& settings)
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void NTSCFilter::saveConfig(Settings& settings) const
void NTSCFilter::saveConfig(Settings& settings)
{
// Save adjustables for custom mode
settings.setValue("tv.sharpness", myCustomSetup.sharpness);
@ -150,7 +150,7 @@ void NTSCFilter::saveConfig(Settings& settings) const
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void NTSCFilter::getAdjustables(Adjustable& adjustable, Preset preset) const
void NTSCFilter::getAdjustables(Adjustable& adjustable, Preset preset)
{
switch(preset)
{
@ -181,7 +181,7 @@ void NTSCFilter::setCustomAdjustables(const Adjustable& adjustable)
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void NTSCFilter::convertToAdjustable(Adjustable& adjustable,
const AtariNTSC::Setup& setup) const
const AtariNTSC::Setup& setup)
{
adjustable.sharpness = scaleTo100(setup.sharpness);
adjustable.resolution = scaleTo100(setup.resolution);

12
src/common/tv_filters/NTSCFilter.hxx
View File

@ -80,12 +80,12 @@ class NTSCFilter
// Get adjustables for the given preset
// Values will be scaled to 0 - 100 range, independent of how
// they're actually stored internally
void getAdjustables(Adjustable& adjustable, Preset preset) const;
static void getAdjustables(Adjustable& adjustable, Preset preset);
// Set custom adjustables to given values
// Values will be scaled to 0 - 100 range, independent of how
// they're actually stored internally
void setCustomAdjustables(const Adjustable& adjustable);
static void setCustomAdjustables(const Adjustable& adjustable);
// The following methods cycle through each custom adjustable
// They are used in conjunction with the increase/decrease
@ -101,8 +101,8 @@ class NTSCFilter
string& text, string& valueText, Int32& newValue);
// Load and save NTSC-related settings
void loadConfig(const Settings& settings);
void saveConfig(Settings& settings) const;
static void loadConfig(const Settings& settings);
static void saveConfig(Settings& settings);
// Perform Blargg filtering on input buffer, place results in
// output buffer
@ -125,8 +125,8 @@ class NTSCFilter
private:
// Convert from atari_ntsc_setup_t values to equivalent adjustables
void convertToAdjustable(Adjustable& adjustable,
const AtariNTSC::Setup& setup) const;
static void convertToAdjustable(Adjustable& adjustable,
const AtariNTSC::Setup& setup);
private:
// The NTSC object

3
src/debugger/BreakpointMap.cxx
View File

@ -110,7 +110,8 @@ BreakpointMap::BreakpointList BreakpointMap::getBreakpoints() const
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
BreakpointMap::Breakpoint BreakpointMap::convertBreakpoint(const Breakpoint& breakpoint)
BreakpointMap::Breakpoint BreakpointMap::convertBreakpoint(
const Breakpoint& breakpoint)
{
if(breakpoint.bank == ANY_BANK)
return Breakpoint(breakpoint.addr, ANY_BANK);

2
src/debugger/BreakpointMap.hxx
View File

@ -90,7 +90,7 @@ class BreakpointMap
size_t size() const { return myMap.size(); }
private:
Breakpoint convertBreakpoint(const Breakpoint& breakpoint);
static Breakpoint convertBreakpoint(const Breakpoint& breakpoint);
struct BreakpointHash {
size_t operator()(const Breakpoint& bp) const {

22
src/debugger/CartDebug.cxx
View File

@ -232,7 +232,7 @@ string CartDebug::toString()
for(uInt32 j = 0; j < bytesPerLine; ++j)
{
buf << myDebugger.invIfChanged(state.ram[i+j], oldstate.ram[i+j]) << " ";
buf << Debugger::invIfChanged(state.ram[i+j], oldstate.ram[i+j]) << " ";
if(j == 0x07) buf << " ";
}
@ -379,7 +379,7 @@ bool CartDebug::fillDisassemblyList(BankInfo& info, Disassembly& disassembly,
disassembly.list.clear();
addrToLineList.clear();
// An empty address list means that DiStella can't do a disassembly
if(info.addressList.size() == 0)
if(info.addressList.empty())
return false;
disassembly.fieldwidth = 24 + myLabelLength;
@ -832,7 +832,7 @@ string CartDebug::loadListFile()
getline(in, line);
if(!in.good() || line == "" || line[0] == '-')
if(!in.good() || line.empty() || line[0] == '-')
continue;
else // Search for constants
{
@ -1133,7 +1133,7 @@ string CartDebug::saveDisassembly(string path)
disassembleBank(bank);
// An empty address list means that DiStella can't do a disassembly
if(info.addressList.size() == 0)
if(info.addressList.empty())
continue;
buf << "\n\n;***********************************************************\n"
@ -1165,7 +1165,7 @@ string CartDebug::saveDisassembly(string path)
const DisassemblyTag& tag = dt;
// Add label (if any)
if(tag.label != "")
if(!tag.label.empty())
buf << ALIGN(4) << (tag.label) << "\n";
buf << " ";
@ -1377,7 +1377,7 @@ string CartDebug::saveDisassembly(string path)
}
}
if(myReserved.Label.size() > 0)
if(!myReserved.Label.empty())
{
out << "\n\n;-----------------------------------------------------------\n"
<< "; Non Locatable Labels\n"
@ -1386,7 +1386,7 @@ string CartDebug::saveDisassembly(string path)
out << ALIGN(16) << iter.second << "= $" << iter.first << "\n";
}
if(myUserLabels.size() > 0)
if(!myUserLabels.empty())
{
out << "\n\n;-----------------------------------------------------------\n"
<< "; User Defined Labels\n"
@ -1561,7 +1561,7 @@ void CartDebug::getCompletions(const char* in, StringList& completions) const
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
CartDebug::AddrType CartDebug::addressType(uInt16 addr) const
CartDebug::AddrType CartDebug::addressType(uInt16 addr)
{
// Determine the type of address to access the correct list
// These addresses were based on (and checked against) Kroko's 2600 memory
@ -1643,7 +1643,7 @@ void CartDebug::accessTypeAsString(ostream& buf, uInt16 addr) const
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Device::AccessType CartDebug::accessTypeAbsolute(Device::AccessFlags flags) const
Device::AccessType CartDebug::accessTypeAbsolute(Device::AccessFlags flags)
{
if(flags & Device::CODE)
return Device::CODE;
@ -1670,7 +1670,7 @@ Device::AccessType CartDebug::accessTypeAbsolute(Device::AccessFlags flags) cons
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CartDebug::AccessTypeAsString(ostream& buf, Device::AccessType type) const
void CartDebug::AccessTypeAsString(ostream& buf, Device::AccessType type)
{
switch(type)
{
@ -1689,7 +1689,7 @@ void CartDebug::AccessTypeAsString(ostream& buf, Device::AccessType type) const
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CartDebug::AccessTypeAsString(ostream& buf, Device::AccessFlags flags) const
void CartDebug::AccessTypeAsString(ostream& buf, Device::AccessFlags flags)
{
if(flags)
{

10
src/debugger/CartDebug.hxx
View File

@ -66,7 +66,7 @@ class CartDebug : public DebuggerSystem
// Determine 'type' of address (ie, what part of the system accessed)
enum class AddrType { TIA, IO, ZPRAM, ROM };
AddrType addressType(uInt16 addr) const;
static AddrType addressType(uInt16 addr);
public:
CartDebug(Debugger& dbg, Console& console, const OSystem& osystem);
@ -260,13 +260,13 @@ class CartDebug : public DebuggerSystem
Methods used by the command parser for tab-completion
In this case, return completions from the equate list(s)
*/
void getCompletions(const char* in, StringList& list) const;
void getCompletions(const char* in, StringList& completions) const;
// Convert given address to corresponding access type and append to buf
void accessTypeAsString(ostream& buf, uInt16 addr) const;
// Convert access enum type to corresponding string and append to buf
void AccessTypeAsString(ostream& buf, Device::AccessType type) const;
static void AccessTypeAsString(ostream& buf, Device::AccessType type);
private:
using AddrToLineList = std::map<uInt16, int>;
@ -330,11 +330,11 @@ class CartDebug : public DebuggerSystem
void getBankDirectives(ostream& buf, const BankInfo& info) const;
// Get access enum type from 'flags', taking precendence into account
Device::AccessType accessTypeAbsolute(Device::AccessFlags flags) const;
static Device::AccessType accessTypeAbsolute(Device::AccessFlags flags);
// Convert all access types in 'flags' to corresponding string and
// append to buf
void AccessTypeAsString(ostream& buf, Device::AccessFlags flags) const;
static void AccessTypeAsString(ostream& buf, Device::AccessFlags flags);
private:
const OSystem& myOSystem;

38
src/debugger/Debugger.cxx
View File

@ -218,13 +218,13 @@ TrapArray& Debugger::writeTraps() const
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
const string Debugger::run(const string& command)
string Debugger::run(const string& command)
{
return myParser->run(command);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
const string Debugger::invIfChanged(int reg, int oldReg)
string Debugger::invIfChanged(int reg, int oldReg)
{
string ret;
@ -361,7 +361,7 @@ int Debugger::trace()
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool Debugger::setBreakPoint(uInt16 addr, uInt8 bank, uInt32 flags)
bool Debugger::setBreakPoint(uInt16 addr, uInt8 bank, uInt32 flags) const
{
if(checkBreakPoint(addr, bank))
return false;
@ -371,7 +371,7 @@ bool Debugger::setBreakPoint(uInt16 addr, uInt8 bank, uInt32 flags)
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool Debugger::clearBreakPoint(uInt16 addr, uInt8 bank)
bool Debugger::clearBreakPoint(uInt16 addr, uInt8 bank) const
{
if(!checkBreakPoint(addr, bank))
return false;
@ -381,13 +381,13 @@ bool Debugger::clearBreakPoint(uInt16 addr, uInt8 bank)
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool Debugger::checkBreakPoint(uInt16 addr, uInt8 bank)
bool Debugger::checkBreakPoint(uInt16 addr, uInt8 bank) const
{
return breakPoints().check(addr, bank);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool Debugger::toggleBreakPoint(uInt16 addr, uInt8 bank)
bool Debugger::toggleBreakPoint(uInt16 addr, uInt8 bank) const
{
if(checkBreakPoint(addr, bank))
clearBreakPoint(addr, bank);
@ -398,53 +398,53 @@ bool Debugger::toggleBreakPoint(uInt16 addr, uInt8 bank)
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Debugger::addReadTrap(uInt16 t)
void Debugger::addReadTrap(uInt16 t) const
{
readTraps().initialize();
readTraps().add(t);
}
void Debugger::addWriteTrap(uInt16 t)
void Debugger::addWriteTrap(uInt16 t) const
{
writeTraps().initialize();
writeTraps().add(t);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Debugger::addTrap(uInt16 t)
void Debugger::addTrap(uInt16 t) const
{
addReadTrap(t);
addWriteTrap(t);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Debugger::removeReadTrap(uInt16 t)
void Debugger::removeReadTrap(uInt16 t) const
{
readTraps().initialize();
readTraps().remove(t);
}
void Debugger::removeWriteTrap(uInt16 t)
void Debugger::removeWriteTrap(uInt16 t) const
{
writeTraps().initialize();
writeTraps().remove(t);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Debugger::removeTrap(uInt16 t)
void Debugger::removeTrap(uInt16 t) const
{
removeReadTrap(t);
removeWriteTrap(t);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool Debugger::readTrap(uInt16 t)
bool Debugger::readTrap(uInt16 t) const
{
return readTraps().isInitialized() && readTraps().isSet(t);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool Debugger::writeTrap(uInt16 t)
bool Debugger::writeTrap(uInt16 t) const
{
return writeTraps().isInitialized() && writeTraps().isSet(t);
}
@ -700,13 +700,13 @@ uInt16 Debugger::unwindStates(const uInt16 numStates, string& message)
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Debugger::clearAllBreakPoints()
void Debugger::clearAllBreakPoints() const
{
breakPoints().clear();
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Debugger::clearAllTraps()
void Debugger::clearAllTraps() const
{
readTraps().clearAll();
writeTraps().clearAll();
@ -829,7 +829,7 @@ bool Debugger::delFunction(const string& name)
const Expression& Debugger::getFunction(const string& name) const
{
const auto& iter = myFunctions.find(name);
return iter != myFunctions.end() ? *(iter->second.get()) : EmptyExpression;
return iter != myFunctions.end() ? *(iter->second) : EmptyExpression;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -840,13 +840,13 @@ const string& Debugger::getFunctionDef(const string& name) const
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
const Debugger::FunctionDefMap Debugger::getFunctionDefMap() const
Debugger::FunctionDefMap Debugger::getFunctionDefMap() const
{
return myFunctionDefs;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
string Debugger::builtinHelp() const
string Debugger::builtinHelp()
{
ostringstream buf;
size_t c_maxlen = 0, i_maxlen = 0;

40
src/debugger/Debugger.hxx
View File

@ -111,13 +111,13 @@ class Debugger : public DialogContainer
bool addFunction(const string& name, const string& def,
Expression* exp, bool builtin = false);
bool isBuiltinFunction(const string& name);
static bool isBuiltinFunction(const string& name);
bool delFunction(const string& name);
const Expression& getFunction(const string& name) const;
const string& getFunctionDef(const string& name) const;
const FunctionDefMap getFunctionDefMap() const;
string builtinHelp() const;
FunctionDefMap getFunctionDefMap() const;
static string builtinHelp();
/**
Methods used by the command parser for tab-completion
@ -168,33 +168,33 @@ class Debugger : public DialogContainer
Returns true if successfully set
*/
bool setBreakPoint(uInt16 addr, uInt8 bank = ANY_BANK,
uInt32 flags = 0);
uInt32 flags = 0) const;
/**
Clears a breakpoint.
Returns true if successfully cleared
*/
bool clearBreakPoint(uInt16 addr, uInt8 bank);
bool clearBreakPoint(uInt16 addr, uInt8 bank) const;
/**
Toggles a breakpoint
Returns new state of breakpoint
*/
bool toggleBreakPoint(uInt16 addr, uInt8 bank);
bool toggleBreakPoint(uInt16 addr, uInt8 bank) const;
/**
Checks for a breakpoint.
Returns true if existing, else false
*/
bool checkBreakPoint(uInt16 addr, uInt8 bank);
bool checkBreakPoint(uInt16 addr, uInt8 bank) const;
/**
Run the debugger command and return the result.
*/
const string run(const string& command);
string run(const string& command);
string autoExec(StringList* history);
@ -235,7 +235,7 @@ class Debugger : public DialogContainer
}
/** Invert given input if it differs from its previous value */
const string invIfChanged(int reg, int oldReg);
static string invIfChanged(int reg, int oldReg);
/**
This is used when we want the debugger from a class that can't
@ -261,7 +261,7 @@ class Debugger : public DialogContainer
Device::AccessFlags getAccessFlags(uInt16 addr) const;
void setAccessFlags(uInt16 addr, Device::AccessFlags flags);
uInt32 getBaseAddress(uInt32 addr, bool read);
static uInt32 getBaseAddress(uInt32 addr, bool read);
bool patchROM(uInt16 addr, uInt8 value);
@ -315,17 +315,17 @@ class Debugger : public DialogContainer
uInt16 rewindStates(const uInt16 numStates, string& message);
uInt16 unwindStates(const uInt16 numStates, string& message);
void clearAllBreakPoints();
void clearAllBreakPoints() const;
void addReadTrap(uInt16 t);
void addWriteTrap(uInt16 t);
void addTrap(uInt16 t);
void removeReadTrap(uInt16 t);
void removeWriteTrap(uInt16 t);
void removeTrap(uInt16 t);
bool readTrap(uInt16 t);
bool writeTrap(uInt16 t);
void clearAllTraps();
void addReadTrap(uInt16 t) const;
void addWriteTrap(uInt16 t) const;
void addTrap(uInt16 t) const;
void removeReadTrap(uInt16 t) const;
void removeWriteTrap(uInt16 t) const;
void removeTrap(uInt16 t) const;
bool readTrap(uInt16 t) const;
bool writeTrap(uInt16 t) const;
void clearAllTraps() const;
void log(const string& triggerMsg);
// Set a bunch of RAM locations at once

72
src/debugger/DebuggerParser.cxx
View File

@ -25,9 +25,7 @@
#include "ControlLowLevel.hxx"
#include "TIADebug.hxx"
#include "TiaOutputWidget.hxx"
#include "DebuggerParser.hxx"
#include "YaccParser.hxx"
#include "M6502.hxx"
#include "Expression.hxx"
#include "FSNode.hxx"
#include "OSystem.hxx"
@ -177,7 +175,7 @@ void DebuggerParser::outputCommandError(const string& errorMsg, int command)
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Completion-related stuff:
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void DebuggerParser::getCompletions(const char* in, StringList& completions) const
void DebuggerParser::getCompletions(const char* in, StringList& completions)
{
// cerr << "Attempting to complete \"" << in << "\"" << endl;
for(const auto& c: commands)
@ -309,7 +307,7 @@ string DebuggerParser::showWatches()
ostringstream buf;
for(uInt32 i = 0; i < myWatches.size(); ++i)
{
if(myWatches[i] != "")
if(!myWatches[i].empty())
{
// Clear the args, since we're going to pass them to eval()
argStrings.clear();
@ -337,7 +335,7 @@ bool DebuggerParser::getArgs(const string& command, string& verb)
ParseState state = ParseState::IN_COMMAND;
size_t i = 0;
const size_t length = command.length();
string curArg = "";
string curArg;
verb = "";
argStrings.clear();
@ -390,14 +388,14 @@ bool DebuggerParser::getArgs(const string& command, string& verb)
while(i < length);
// Take care of the last argument, if there is one
if(curArg != "")
if(!curArg.empty())
argStrings.push_back(curArg);
argCount = static_cast<uInt32>(argStrings.size());
for(uInt32 arg = 0; arg < argCount; ++arg)
{
if(!YaccParser::parse(argStrings[arg].c_str()))
if(!YaccParser::parse(argStrings[arg]))
{
unique_ptr<Expression> expr(YaccParser::getResult());
args.push_back(expr->evaluate());
@ -545,8 +543,8 @@ string DebuggerParser::eval()
{
string rlabel = debugger.cartDebug().getLabel(args[i], true);
string wlabel = debugger.cartDebug().getLabel(args[i], false);
const bool validR = rlabel != "" && rlabel[0] != '$',
validW = wlabel != "" && wlabel[0] != '$';
const bool validR = !rlabel.empty() && rlabel[0] != '$',
validW = !wlabel.empty() && wlabel[0] != '$';
if(validR && validW)
{
if(rlabel == wlabel)
@ -587,7 +585,7 @@ void DebuggerParser::listTraps(bool listCond)
commandResult << (listCond ? "trapifs:" : "traps:") << endl;
for(uInt32 i = 0; i < names.size(); ++i)
{
const bool hasCond = names[i] != "";
const bool hasCond = !names[i].empty();
if(hasCond == listCond)
{
commandResult << Base::toString(i) << ": ";
@ -619,23 +617,23 @@ string DebuggerParser::trapStatus(const Trap& trap)
string lblb = debugger.cartDebug().getLabel(trap.begin, !trap.write);
string lble = debugger.cartDebug().getLabel(trap.end, !trap.write);
if(lblb != "") {
if(!lblb.empty()) {
result << " (";
result << lblb;
}
if(trap.begin != trap.end)
{
if(lble != "")
if(!lble.empty())
{
if (lblb != "")
if(!lblb.empty())
result << " ";
else
result << " (";
result << lble;
}
}
if (lblb != "" || lble != "")
if(!lblb.empty() || !lble.empty())
result << ")";
return result.str();
@ -647,7 +645,7 @@ string DebuggerParser::saveScriptFile(string file)
stringstream out;
Debugger::FunctionDefMap funcs = debugger.getFunctionDefMap();
for(const auto& [name, cmd]: funcs)
if (!debugger.isBuiltinFunction(name))
if (!Debugger::isBuiltinFunction(name))
out << "function " << name << " {" << cmd << "}" << endl;
for(const auto& w: myWatches)
@ -669,7 +667,7 @@ string DebuggerParser::saveScriptFile(string file)
{
const bool read = myTraps[i]->read,
write = myTraps[i]->write,
hasCond = names[i] != "";
hasCond = !names[i].empty();
if(read && write)
out << "trap";
@ -744,7 +742,7 @@ void DebuggerParser::executeDirective(Device::AccessType type)
const bool result = debugger.cartDebug().addDirective(type, args[0], args[1]);
commandResult << (result ? "added " : "removed ");
debugger.cartDebug().AccessTypeAsString(commandResult, type);
CartDebug::AccessTypeAsString(commandResult, type);
commandResult << " directive on range $"
<< hex << args[0] << " $" << hex << args[1];
debugger.rom().invalidate();
@ -873,7 +871,7 @@ void DebuggerParser::executeBreak()
// "breakIf"
void DebuggerParser::executeBreakIf()
{
int res = YaccParser::parse(argStrings[0].c_str());
int res = YaccParser::parse(argStrings[0]);
if(res == 0)
{
string condition = argStrings[0];
@ -1273,7 +1271,7 @@ void DebuggerParser::executeDump()
DebuggerDialog* dlg = debugger.myDialog;
BrowserDialog::show(dlg, "Save Dump as", path.str(),
BrowserDialog::Mode::FileSave,
[this, dlg, outStr, resultStr]
[dlg, outStr, resultStr]
(bool OK, const FSNode& node)
{
if(OK)
@ -1352,7 +1350,7 @@ void DebuggerParser::executeFunction()
return;
}
int res = YaccParser::parse(argStrings[1].c_str());
int res = YaccParser::parse(argStrings[1]);
if(res == 0)
{
debugger.addFunction(argStrings[0], argStrings[1], YaccParser::getResult());
@ -1388,7 +1386,7 @@ void DebuggerParser::executeHelp()
commandResult << setw(static_cast<int>(clen)) << right << c.cmdString
<< " - " << c.description << endl;
commandResult << debugger.builtinHelp();
commandResult << Debugger::builtinHelp();
}
else // get help for specific command
{
@ -1567,7 +1565,7 @@ void DebuggerParser::executeListBreaks()
StringList conds = debugger.m6502().getCondBreakNames();
if(conds.size() > 0)
if(!conds.empty())
{
if(count)
commandResult << endl;
@ -1579,7 +1577,7 @@ void DebuggerParser::executeListBreaks()
}
}
if(commandResult.str() == "")
if(commandResult.str().empty())
commandResult << "no breakpoints set";
}
@ -1599,7 +1597,7 @@ void DebuggerParser::executeListFunctions()
{
const Debugger::FunctionDefMap& functions = debugger.getFunctionDefMap();
if(functions.size() > 0)
if(!functions.empty())
for(const auto& [name, cmd]: functions)
commandResult << name << " -> " << cmd << endl;
else
@ -1613,7 +1611,7 @@ void DebuggerParser::executeListSaveStateIfs()
ostringstream buf;
StringList conds = debugger.m6502().getCondSaveStateNames();
if(conds.size() > 0)
if(!conds.empty())
{
commandResult << "saveStateIf:" << endl;
for(uInt32 i = 0; i < conds.size(); ++i)
@ -1623,7 +1621,7 @@ void DebuggerParser::executeListSaveStateIfs()
}
}
if(commandResult.str() == "")
if(commandResult.str().empty())
commandResult << "no savestateifs defined";
}
@ -1639,11 +1637,11 @@ void DebuggerParser::executeListTraps()
return;
}
if (names.size() > 0)
if(!names.empty())
{
bool trapFound = false, trapifFound = false;
for(const auto& name: names)
if(name == "")
if(name.empty())
trapFound = true;
else
trapifFound = true;
@ -1705,7 +1703,7 @@ void DebuggerParser::executeN()
// "palette"
void DebuggerParser::executePalette()
{
commandResult << debugger.tiaDebug().palette();
commandResult << TIADebug::palette();
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -2087,7 +2085,7 @@ void DebuggerParser::executeSaveState()
// "saveStateIf"
void DebuggerParser::executeSaveStateIf()
{
int res = YaccParser::parse(argStrings[0].c_str());
int res = YaccParser::parse(argStrings[0]);
if(res == 0)
{
string condition = argStrings[0];
@ -2130,7 +2128,7 @@ void DebuggerParser::executeStep()
// "stepWhile"
void DebuggerParser::executeStepWhile()
{
int res = YaccParser::parse(argStrings[0].c_str());
int res = YaccParser::parse(argStrings[0]);
if(res != 0) {
commandResult << red("invalid expression");
return;
@ -2256,10 +2254,10 @@ void DebuggerParser::executeTraps(bool read, bool write, const string& command,
}
// base addresses of mirrors
const uInt32 beginRead = debugger.getBaseAddress(begin, true);
const uInt32 endRead = debugger.getBaseAddress(end, true);
const uInt32 beginWrite = debugger.getBaseAddress(begin, false);
const uInt32 endWrite = debugger.getBaseAddress(end, false);
const uInt32 beginRead = Debugger::getBaseAddress(begin, true);
const uInt32 endRead = Debugger::getBaseAddress(end, true);
const uInt32 beginWrite = Debugger::getBaseAddress(begin, false);
const uInt32 endWrite = Debugger::getBaseAddress(end, false);
stringstream conditionBuf;
// parenthesize provided and address range condition(s) (begin)
@ -2289,7 +2287,7 @@ void DebuggerParser::executeTraps(bool read, bool write, const string& command,
const string condition = conditionBuf.str();
int res = YaccParser::parse(condition.c_str());
int res = YaccParser::parse(condition);
if(res == 0)
{
// duplicates will remove each other
@ -2334,7 +2332,7 @@ void DebuggerParser::executeTraps(bool read, bool write, const string& command,
// wrapper function for trap(if)/trapRead(if)/trapWrite(if) commands
void DebuggerParser::executeTrapRW(uInt32 addr, bool read, bool write, bool add)
{
switch(debugger.cartDebug().addressType(addr))
switch(CartDebug::addressType(addr))
{
case CartDebug::AddrType::TIA:
{

6
src/debugger/DebuggerParser.hxx
View File

@ -42,7 +42,7 @@ class DebuggerParser
/** Given a substring, determine matching substrings from the list
of available commands. Used in the debugger prompt for tab-completion */
void getCompletions(const char* in, StringList& list) const;
static void getCompletions(const char* in, StringList& completions);
/** Evaluate the given expression using operators, current base, etc */
int decipher_arg(const string& str);
@ -65,8 +65,8 @@ class DebuggerParser
bool validateArgs(int cmd);
string eval();
string saveScriptFile(string file);
void saveDump(const FSNode& node, const stringstream& out,
ostringstream& result);
static void saveDump(const FSNode& node, const stringstream& out,
ostringstream& result);
const string& cartName() const;
private:

18
src/debugger/DiStella.cxx
View File

@ -80,7 +80,7 @@ DiStella::DiStella(const CartDebug& dbg, CartDebug::DisassemblyList& list,
// multi-byte instruction, then we make note of that address for reference
//
// However, we only do this for labels pointing to ROM (above $1000)
if (myDbg.addressType(k + myOffset) == CartDebug::AddrType::ROM) {
if (CartDebug::addressType(k + myOffset) == CartDebug::AddrType::ROM) {
reservedLabel.str("");
reservedLabel << "L" << Base::HEX4 << (k + myOffset);
myReserved.Label.emplace(k + myOffset, reservedLabel.str());
@ -944,7 +944,7 @@ DiStella::AddressType DiStella::mark(uInt32 address, uInt16 mask, bool directive
// Check for equates before ROM/ZP-RAM accesses, because the original logic
// of Distella assumed either equates or ROM; it didn't take ZP-RAM into account
const CartDebug::AddrType type = myDbg.addressType(address);
const CartDebug::AddrType type = CartDebug::addressType(address);
if(type == CartDebug::AddrType::TIA) {
return AddressType::TIA;
}
@ -1003,18 +1003,18 @@ bool DiStella::checkBits(uInt16 address, uInt16 mask, uInt16 notMask, bool useDe
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool DiStella::check_range(uInt16 beg, uInt16 end) const
bool DiStella::check_range(uInt16 start, uInt16 end) const
{
if (beg > end) {
cerr << "Beginning of range greater than end: start = " << std::hex << beg
if (start > end) {
cerr << "Beginning of range greater than end: start = " << std::hex << start
<< ", end = " << std::hex << end << endl;
return false;
} else if (beg > myAppData.end + myOffset) {
cerr << "Beginning of range out of range: start = " << std::hex << beg
} else if (start > myAppData.end + myOffset) {
cerr << "Beginning of range out of range: start = " << std::hex << start
<< ", range = " << std::hex << (myAppData.end + myOffset) << endl;
return false;
} else if (beg < myOffset) {
cerr << "Beginning of range out of range: start = " << std::hex << beg
} else if (start < myOffset) {
cerr << "Beginning of range out of range: start = " << std::hex << start
<< ", offset = " << std::hex << myOffset << endl;
return false;
}

30
src/debugger/RiotDebug.cxx
View File

@ -377,29 +377,29 @@ string RiotDebug::toString()
const auto& oldstate = static_cast<const RiotState&>(getOldState());
ostringstream buf;
buf << "280/SWCHA(R)=" << myDebugger.invIfChanged(state.SWCHA_R, oldstate.SWCHA_R)
<< " 280/SWCHA(W)=" << myDebugger.invIfChanged(state.SWCHA_W, oldstate.SWCHA_W)
<< " 281/SWACNT=" << myDebugger.invIfChanged(state.SWACNT, oldstate.SWACNT)
buf << "280/SWCHA(R)=" << Debugger::invIfChanged(state.SWCHA_R, oldstate.SWCHA_R)
<< " 280/SWCHA(W)=" << Debugger::invIfChanged(state.SWCHA_W, oldstate.SWCHA_W)
<< " 281/SWACNT=" << Debugger::invIfChanged(state.SWACNT, oldstate.SWACNT)
<< endl
<< "282/SWCHB(R)=" << myDebugger.invIfChanged(state.SWCHB_R, oldstate.SWCHB_R)
<< " 282/SWCHB(W)=" << myDebugger.invIfChanged(state.SWCHB_W, oldstate.SWCHB_W)
<< " 283/SWBCNT=" << myDebugger.invIfChanged(state.SWBCNT, oldstate.SWBCNT)
<< "282/SWCHB(R)=" << Debugger::invIfChanged(state.SWCHB_R, oldstate.SWCHB_R)
<< " 282/SWCHB(W)=" << Debugger::invIfChanged(state.SWCHB_W, oldstate.SWCHB_W)
<< " 283/SWBCNT=" << Debugger::invIfChanged(state.SWBCNT, oldstate.SWBCNT)
<< endl
// These are squirrely: some symbol files will define these as
// 0x284-0x287. Doesn't actually matter, these registers repeat
// every 16 bytes.
<< "294/TIM1T=" << myDebugger.invIfChanged(state.TIM1T, oldstate.TIM1T)
<< " 295/TIM8T=" << myDebugger.invIfChanged(state.TIM8T, oldstate.TIM8T)
<< " 296/TIM64T=" << myDebugger.invIfChanged(state.TIM64T, oldstate.TIM64T)
<< " 297/T1024T=" << myDebugger.invIfChanged(state.T1024T, oldstate.T1024T)
<< "294/TIM1T=" << Debugger::invIfChanged(state.TIM1T, oldstate.TIM1T)
<< " 295/TIM8T=" << Debugger::invIfChanged(state.TIM8T, oldstate.TIM8T)
<< " 296/TIM64T=" << Debugger::invIfChanged(state.TIM64T, oldstate.TIM64T)
<< " 297/T1024T=" << Debugger::invIfChanged(state.T1024T, oldstate.T1024T)
<< endl
<< "0x284/INTIM=" << myDebugger.invIfChanged(state.INTIM, oldstate.INTIM)
<< " 285/TIMINT=" << myDebugger.invIfChanged(state.TIMINT, oldstate.TIMINT)
<< " Timer_Clocks=" << myDebugger.invIfChanged(state.TIMCLKS, oldstate.TIMCLKS)
<< " INTIM_Clocks=" << myDebugger.invIfChanged(state.INTIMCLKS, oldstate.INTIMCLKS)
<< " Divider=" << myDebugger.invIfChanged(state.TIMDIV, oldstate.TIMDIV)
<< "0x284/INTIM=" << Debugger::invIfChanged(state.INTIM, oldstate.INTIM)
<< " 285/TIMINT=" << Debugger::invIfChanged(state.TIMINT, oldstate.TIMINT)
<< " Timer_Clocks=" << Debugger::invIfChanged(state.TIMCLKS, oldstate.TIMCLKS)
<< " INTIM_Clocks=" << Debugger::invIfChanged(state.INTIMCLKS, oldstate.INTIMCLKS)
<< " Divider=" << Debugger::invIfChanged(state.TIMDIV, oldstate.TIMDIV)
<< endl
<< "Left/P0diff: " << diffP0String() << " Right/P1diff: " << diffP1String()

6
src/debugger/TIADebug.cxx
View File

@ -995,7 +995,7 @@ shared_ptr<DelayQueueIterator> TIADebug::delayQueueIterator() const
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
string TIADebug::colorSwatch(uInt8 c) const
string TIADebug::colorSwatch(uInt8 c)
{
string ret;
@ -1019,7 +1019,7 @@ string TIADebug::audFreq1()
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
string TIADebug::audFreq(uInt8 dist, uInt8 div)
string TIADebug::audFreq(uInt8 dist, uInt8 div) const
{
static constexpr uInt16 dist_div[16] = {
1, 15, 465, 465, 2, 2, 31, 31,
@ -1154,7 +1154,7 @@ string TIADebug::debugColors() const
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
string TIADebug::palette() const
string TIADebug::palette()
{
ostringstream buf;

20
src/debugger/TIADebug.hxx
View File

@ -63,7 +63,7 @@ class TIADebug : public DebuggerSystem
void saveOldState() override;
string toString() override;
string debugColors() const;
string palette() const;
static string palette();
// TIA byte (or part of a byte) registers
uInt8 nusiz0(int newVal = -1);
@ -185,14 +185,18 @@ class TIADebug : public DebuggerSystem
private:
/** Display a color patch for color at given index in the palette */
string colorSwatch(uInt8 c) const;
static string colorSwatch(uInt8 c);
string audFreq(uInt8 dist, uInt8 div);
string stringOnly(const string& value, bool changed = false);
string decWithLabel(const string& label, uInt16 value, bool changed = false, uInt16 width = 3);
string hexWithLabel(const string& label, uInt16 value, bool changed = false, uInt16 width = 2);
string binWithLabel(const string& label, uInt16 value, bool changed = false);
string boolWithLabel(const string& label, bool value, bool changed = false);
string audFreq(uInt8 dist, uInt8 div) const;
static string stringOnly(const string& value, bool changed = false);
static string decWithLabel(const string& label, uInt16 value,
bool changed = false, uInt16 width = 3);
static string hexWithLabel(const string& label, uInt16 value,
bool changed = false, uInt16 width = 2);
static string binWithLabel(const string& label, uInt16 value,
bool changed = false);
static string boolWithLabel(const string& label, bool value,
bool changed = false);
private:
TiaState myState;

3
src/debugger/gui/BoosterWidget.cxx
View File

@ -126,6 +126,3 @@ void BoosterWidget::handleCommand(
}
}
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
constexpr std::array<Controller::DigitalPin, 5> BoosterWidget::ourPinNo;

4
src/debugger/gui/CartE7Widget.cxx
View File

@ -63,7 +63,7 @@ CartridgeE7Widget::CartridgeE7Widget(
void CartridgeE7Widget::initialize(GuiObject* boss,
const CartridgeE7& cart, const ostringstream& info)
{
const uInt32 size = cart.romBankCount() * cart.BANK_SIZE;
const uInt32 size = cart.romBankCount() * CartridgeE7::BANK_SIZE;
constexpr int xpos = 2;
int ypos = addBaseInformation(size, "M Network", info.str(), 15) + myLineHeight;
@ -148,7 +148,7 @@ string CartridgeE7Widget::bankState()
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt32 CartridgeE7Widget::internalRamSize()
{
return myCart.RAM_SIZE;
return CartridgeE7::RAM_SIZE;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

5
src/debugger/gui/CartE7Widget.hxx
View File

@ -52,9 +52,10 @@ class CartridgeE7Widget : public CartDebugWidget
};
protected:
void initialize(GuiObject* boss, const CartridgeE7& cart, const ostringstream& info);
void initialize(GuiObject* boss, const CartridgeE7& cart,
const ostringstream& info);
const char* getSpotLower(int idx);
const char* getSpotUpper(int idx);
static const char* getSpotUpper(int idx);
private:
void saveOldState() override;

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

@ -384,7 +384,7 @@ uInt32 CartridgeEnhancedWidget::internalRamRPort(int start)
string CartridgeEnhancedWidget::internalRamDescription()
{
ostringstream desc;
string indent = "";
string indent;
if(myCart.ramBankCount())
{

2
src/debugger/gui/CartRamWidget.hxx
View File

@ -65,7 +65,7 @@ class CartRamWidget : public Widget, public CommandSender
InternalRamWidget(GuiObject* boss, const GUI::Font& lfont,
const GUI::Font& nfont,
int x, int y, int w, int h,
CartDebugWidget& cartDebug);
CartDebugWidget& dbg);
~InternalRamWidget() override = default;
string getLabel(int addr) const override;

5
src/debugger/gui/CartWDWidget.cxx
View File

@ -22,8 +22,7 @@
CartridgeWDWidget::CartridgeWDWidget(
GuiObject* boss, const GUI::Font& lfont, const GUI::Font& nfont,
int x, int y, int w, int h, CartridgeWD& cart)
: CartridgeEnhancedWidget(boss, lfont, nfont, x, y, w, h, cart),
myCartWD{cart}
: CartridgeEnhancedWidget(boss, lfont, nfont, x, y, w, h, cart)
{
initialize();
}
@ -46,7 +45,7 @@ string CartridgeWDWidget::description()
string CartridgeWDWidget::hotspotStr(int bank, int segment, bool prefix)
{
ostringstream info;
const CartridgeWD::BankOrg banks = myCartWD.ourBankOrg[bank];
const CartridgeWD::BankOrg banks = CartridgeWD::ourBankOrg[bank];
info << "(" << (prefix ? "hotspot " : "")
<< "$" << Common::Base::HEX1 << (myCart.hotspot() + bank) << ") ["

3
src/debugger/gui/CartWDWidget.hxx
View File

@ -31,9 +31,6 @@ class CartridgeWDWidget : public CartridgeEnhancedWidget
CartridgeWD& cart);
~CartridgeWDWidget() override = default;
private:
CartridgeWD& myCartWD;
private:
string manufacturer() override { return "Wickstead Design"; }

2
src/debugger/gui/DataGridRamWidget.hxx
View File

@ -30,7 +30,7 @@ class DataGridRamWidget : public DataGridWidget
const GUI::Font& font,
int x, int y, int cols, int rows,
int colchars, int bits,
Common::Base::Fmt format = Common::Base::Fmt::_DEFAULT,
Common::Base::Fmt base = Common::Base::Fmt::_DEFAULT,
bool useScrollbar = false);
~DataGridRamWidget() override = default;

6
src/debugger/gui/DataGridWidget.cxx
View File

@ -308,7 +308,7 @@ void DataGridWidget::handleMouseWheel(int x, int y, int direction)
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
int DataGridWidget::findItem(int x, int y)
int DataGridWidget::findItem(int x, int y) const
{
int row = (y - 1) / _rowHeight;
if(row >= _rows) row = _rows - 1;
@ -759,8 +759,8 @@ void DataGridWidget::endEditMode()
enableEditMode(false);
// Update the both the string representation and the real data
if(editString().size() > 0 && !(editString()[0] == '$' ||
editString()[0] == '#' || editString()[0] == '\\'))
if(!editString().empty() && !(editString()[0] == '$' ||
editString()[0] == '#' || editString()[0] == '\\'))
{
switch(_base)
{

4
src/debugger/gui/DataGridWidget.hxx
View File

@ -43,7 +43,7 @@ class DataGridWidget : public EditableWidget
DataGridWidget(GuiObject* boss, const GUI::Font& font,
int x, int y, int cols, int rows,
int colchars, int bits,
Common::Base::Fmt format = Common::Base::Fmt::_DEFAULT,
Common::Base::Fmt base = Common::Base::Fmt::_DEFAULT,
bool useScrollbar = false);
~DataGridWidget() override = default;
@ -92,7 +92,7 @@ class DataGridWidget : public EditableWidget
protected:
void drawWidget(bool hilite) override;
int findItem(int x, int y);
int findItem(int x, int y) const;
void startEditMode() override;
void endEditMode() override;

5
src/debugger/gui/DelayQueueWidget.cxx
View File

@ -39,7 +39,8 @@ DelayQueueWidget::DelayQueueWidget(
_w = 20 * font.getMaxCharWidth() + 6;
_h = static_cast<int>(myLines.size() * font.getLineHeight() + 6);
for (auto&& line : myLines) line = "";
for (auto&& line : myLines)
line = "";
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -50,7 +51,7 @@ void DelayQueueWidget::loadConfig() {
using Common::Base;
for (auto&& line : myLines) {
if (!delayQueueIterator->isValid()) {
if(line != "")
if(!line.empty())
{
setDirty();
line = "";

3
src/debugger/gui/Joy2BPlusWidget.cxx
View File

@ -126,6 +126,3 @@ void Joy2BPlusWidget::handleCommand(
}
}
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
constexpr std::array<Controller::DigitalPin, 5> Joy2BPlusWidget::ourPinNo;

3
src/debugger/gui/PointingDeviceWidget.cxx
View File

@ -140,7 +140,8 @@ void PointingDeviceWidget::setGrayCodeV()
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void PointingDeviceWidget::setValue(DataGridWidget* grayValue, const int index, const int direction)
void PointingDeviceWidget::setValue(DataGridWidget* grayValue,
const int index, const int direction)
{
const uInt8 grayCode = getGrayCodeTable(index, direction);

2
src/debugger/gui/PointingDeviceWidget.hxx
View File

@ -52,7 +52,7 @@ class PointingDeviceWidget : public ControllerWidget
void setGrayCodeH();
void setGrayCodeV();
void setValue(DataGridWidget* greyValue, const int index, const int direction);
void setValue(DataGridWidget* grayValue, const int index, const int direction);
// Following constructors and assignment operators not supported
PointingDeviceWidget() = delete;

12
src/debugger/gui/PromptWidget.cxx
View File

@ -583,7 +583,7 @@ void PromptWidget::historyAdd(const string& entry)
void PromptWidget::addToHistory(const char* str)
{
// Do not add duplicates, remove old duplicate
if(_history.size())
if(!_history.empty())
{
int i = _historyIndex;
const int historyEnd = _historyIndex % _history.size();
@ -618,7 +618,7 @@ void PromptWidget::addToHistory(const char* str)
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool PromptWidget::historyScroll(int direction)
{
if(_history.size() == 0)
if(_history.empty())
return false;
// add current input temporarily to history
@ -695,7 +695,7 @@ bool PromptWidget::execute()
}
else if(result == "_NO_PROMPT")
return true;
else if(result != "")
else if(!result.empty())
print(result + "\n");
}
return false;
@ -741,7 +741,7 @@ bool PromptWidget::autoComplete(int direction)
if(lastDelimPos == -1)
// no delimiters, do only command completion:
instance().debugger().parser().getCompletions(_inputStr, list);
DebuggerParser::getCompletions(_inputStr, list);
else
{
const size_t strLen = len - lastDelimPos - 1;
@ -750,7 +750,7 @@ bool PromptWidget::autoComplete(int direction)
{
// Special case for 'help' command
if(BSPF::startsWithIgnoreCase(_inputStr, "help"))
instance().debugger().parser().getCompletions(_inputStr + lastDelimPos + 1, list);
DebuggerParser::getCompletions(_inputStr + lastDelimPos + 1, list);
else
{
// we got a delimiter, so this must be a label or a function
@ -762,7 +762,7 @@ bool PromptWidget::autoComplete(int direction)
}
}
if(list.size() < 1)
if(list.empty())
return false;
sort(list.begin(), list.end());

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

@ -288,7 +288,7 @@ void RamWidget::handleCommand(CommandSender* sender, int cmd, int data, int id)
case kSValEntered:
{
const string& result = doSearch(myInputBox->getResult());
if(result != "")
if(!result.empty())
myInputBox->setMessage(result);
else
myInputBox->close();
@ -298,7 +298,7 @@ void RamWidget::handleCommand(CommandSender* sender, int cmd, int data, int id)
case kCValEntered:
{
const string& result = doCompare(myInputBox->getResult());
if(result != "")
if(!result.empty())
myInputBox->setMessage(result);
else
myInputBox->close();
@ -543,7 +543,7 @@ void RamWidget::showSearchResults()
// Only update the search results for the bank currently being shown
BoolArray temp;
const uInt32 start = myCurrentRamBank * myPageSize;
if(mySearchState.size() == 0 || start > mySearchState.size())
if(mySearchState.empty() || start > mySearchState.size())
{
for(uInt32 i = 0; i < myPageSize; ++i)
temp.push_back(false);

5
src/debugger/gui/RiotWidget.cxx
View File

@ -521,8 +521,9 @@ void RiotWidget::handleCommand(CommandSender* sender, int cmd, int data, int id)
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
ControllerWidget* RiotWidget::addControlWidget(GuiObject* boss, const GUI::Font& font,
int x, int y, Controller& controller)
ControllerWidget*
RiotWidget::addControlWidget(GuiObject* boss, const GUI::Font& font,
int x, int y, Controller& controller)
{
switch(controller.type())
{

3
src/debugger/gui/RiotWidget.hxx
View File

@ -37,7 +37,8 @@ class RiotWidget : public Widget, public CommandSender
~RiotWidget() override = default;
private:
ControllerWidget* addControlWidget(GuiObject* boss, const GUI::Font& font,
static ControllerWidget* addControlWidget(
GuiObject* boss, const GUI::Font& font,
int x, int y, Controller& controller);
void handleConsole();

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

@ -658,7 +658,7 @@ void RomListWidget::startEditMode()
if (isEditable() && !_editMode && _selectedItem >= 0)
{
// Does this line represent an editable area?
if(myDisasm->list[_selectedItem].bytes == "")
if(myDisasm->list[_selectedItem].bytes.empty())
return;
_editMode = true;

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

@ -117,7 +117,7 @@ void TiaOutputWidget::saveSnapshot(int execDepth, const string& execPrefix,
string message = "Snapshot saved";
try
{
instance().png().saveImage(sspath.str(), s, rect);
PNGLibrary::saveImage(sspath.str(), s, rect);
}
catch(const runtime_error& e)
{

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

@ -75,7 +75,7 @@ void ToggleWidget::handleMouseUp(int x, int y, MouseButton b, int clickCount)
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
int ToggleWidget::findItem(int x, int y)
int ToggleWidget::findItem(int x, int y) const
{
int row = (y - 1) / _rowHeight;
if(row >= _rows) row = _rows - 1;

2
src/debugger/gui/ToggleWidget.hxx
View File

@ -70,7 +70,7 @@ class ToggleWidget : public Widget, public CommandSender
private:
void drawWidget(bool hilite) override = 0;
int findItem(int x, int y);
int findItem(int x, int y) const;
void handleMouseDown(int x, int y, MouseButton b, int clickCount) override;
void handleMouseUp(int x, int y, MouseButton b, int clickCount) override;

8
src/debugger/yacc/YaccParser.cxx
View File

@ -177,7 +177,7 @@ int const_to_int(char* ch)
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// special methods that get Cart RAM/ROM internal state
CartMethod getCartSpecial(char* ch)
CartMethod getCartSpecial(const char* ch)
{
if(BSPF::equalsIgnoreCase(ch, "_bank"))
return &CartDebug::getPCBank;
@ -196,7 +196,7 @@ CartMethod getCartSpecial(char* ch)
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// special methods that get e.g. CPU registers
CpuMethod getCpuSpecial(char* ch)
CpuMethod getCpuSpecial(const char* ch)
{
if(BSPF::equalsIgnoreCase(ch, "a"))
return &CpuDebug::a;
@ -230,7 +230,7 @@ CpuMethod getCpuSpecial(char* ch)
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// special methods that get RIOT internal state
RiotMethod getRiotSpecial(char* ch)
RiotMethod getRiotSpecial(const char* ch)
{
if(BSPF::equalsIgnoreCase(ch, "_timWrapRead"))
return &RiotDebug::timWrappedOnRead;
@ -248,7 +248,7 @@ RiotMethod getRiotSpecial(char* ch)
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// special methods that get TIA internal state
TiaMethod getTiaSpecial(char* ch)
TiaMethod getTiaSpecial(const char* ch)
{
if(BSPF::equalsIgnoreCase(ch, "_scan"))
return &TIADebug::scanlines;

8
src/debugger/yacc/YaccParser.hxx
View File

@ -36,10 +36,10 @@ namespace YaccParser
int parse(const string& in);
int const_to_int(char* ch);
CartMethod getCartSpecial(char* ch);
CpuMethod getCpuSpecial(char* ch);
RiotMethod getRiotSpecial(char* ch);
TiaMethod getTiaSpecial(char* ch);
CartMethod getCartSpecial(const char* ch);
CpuMethod getCpuSpecial(const char* ch);
RiotMethod getRiotSpecial(const char* ch);
TiaMethod getTiaSpecial(const char* ch);
}
#endif

11
src/emucore/CartAR.cxx
View File

@ -276,17 +276,6 @@ void CartridgeAR::initializeROM()
myImage[(RAM_SIZE) + BANK_SIZE - 1] = 0xF8;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
uInt8 CartridgeAR::checksum(const uInt8* s, uInt16 length)
{
uInt8 sum = 0;
for(uInt32 i = 0; i < length; ++i)
sum += s[i];
return sum;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CartridgeAR::loadIntoRAM(uInt8 load)
{

8
src/emucore/CartAR.hxx
View File

@ -187,7 +187,13 @@ class CartridgeAR : public Cartridge
bool bankConfiguration(uInt8 configuration);
// Compute the sum of the array of bytes
uInt8 checksum(const uInt8* s, uInt16 length);
static uInt8 checksum(const uInt8* s, uInt16 length) {
uInt8 sum = 0;
for(uInt32 i = 0; i < length; ++i)
sum += s[i];
return sum;
}
// Load the specified load into SC RAM
void loadIntoRAM(uInt8 load);

4
src/emucore/CartCreator.cxx
View File

@ -72,10 +72,10 @@
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
unique_ptr<Cartridge> CartCreator::create(const FSNode& file,
const ByteBuffer& image, size_t size, string& md5,
const string& propertiesType, Settings& settings)
const string& dtype, Settings& settings)
{
unique_ptr<Cartridge> cartridge;
Bankswitch::Type type = Bankswitch::nameToType(propertiesType),
Bankswitch::Type type = Bankswitch::nameToType(dtype),
detectedType = type;
string id;

10
src/emucore/CartDetector.cxx
View File

@ -430,16 +430,12 @@ bool CartDetector::isProbably4KSC(const ByteBuffer& image, size_t size)
{
// We check if the first 256 bytes are identical *and* if there's
// an "SC" signature for one of our larger SC types at 1FFA.
const uInt8 first = image[0];
for(uInt32 i = 1; i < 256; ++i)
if(image[i] != first)
return false;
if(image[i] != first)
return false;
if((image[size-6]=='S') && (image[size-5]=='C'))
return true;
return false;
return (image[size-6] == 'S') && (image[size-5] == 'C');
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

14
src/emucore/CartMVC.cxx
View File

@ -31,20 +31,20 @@
*/
namespace {
static constexpr uInt8 LO_JUMP_BYTE(uInt16 b) {
constexpr uInt8 LO_JUMP_BYTE(uInt16 b) {
return b & 0xff;
}
static constexpr uInt8 HI_JUMP_BYTE(uInt16 b) {
constexpr uInt8 HI_JUMP_BYTE(uInt16 b) {
return ((b & 0xff00) >> 8) | 0x10;
}
static constexpr uInt8 COLOR_BLUE = 0x9A;
// static constexpr uInt8 COLOR_WHITE = 0x0E;
constexpr uInt8 COLOR_BLUE = 0x9A;
// constexpr uInt8 COLOR_WHITE = 0x0E;
static constexpr uInt8 OSD_FRAMES = 180;
static constexpr int BACK_SECONDS = 10;
constexpr uInt8 OSD_FRAMES = 180;
constexpr int BACK_SECONDS = 10;
static constexpr int TITLE_CYCLES = 1000000;
constexpr int TITLE_CYCLES = 1000000;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

10
src/emucore/Console.cxx
View File

@ -23,7 +23,6 @@
#include "Booster.hxx"
#include "Cart.hxx"
#include "Control.hxx"
#include "Cart.hxx"
#include "CartCM.hxx"
#include "Driving.hxx"
#include "Event.hxx"
@ -161,7 +160,7 @@ Console::Console(OSystem& osystem, unique_ptr<Cartridge>& cart,
myDevSettingsHandler = make_unique<DevSettingsHandler>(myOSystem);
// Auto-detect NTSC/PAL mode if it's requested
string autodetected = "";
string autodetected;
myDisplayFormat = myProperties.get(PropType::Display_Format);
if (myDisplayFormat == "AUTO")
@ -296,9 +295,9 @@ void Console::autodetectFrameLayout(bool reset)
for(int i = 0; i < 20; ++i)
myTIA->update();
frameLayoutDetector.simulateInput(*myRiot, myOSystem.eventHandler(), true);
FrameLayoutDetector::simulateInput(*myRiot, myOSystem.eventHandler(), true);
myTIA->update();
frameLayoutDetector.simulateInput(*myRiot, myOSystem.eventHandler(), false);
FrameLayoutDetector::simulateInput(*myRiot, myOSystem.eventHandler(), false);
for(int i = 0; i < 40; ++i)
myTIA->update();
@ -441,8 +440,7 @@ void Console::setFormat(uInt32 format, bool force)
if(!force && myCurrentFormat == format)
return;
string saveformat, message;
string autodetected = "";
string saveformat, message, autodetected;
myCurrentFormat = format;
switch(myCurrentFormat)

4
src/emucore/ControllerDetector.cxx
View File

@ -45,10 +45,10 @@ Controller::Type ControllerDetector::detectType(
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
string ControllerDetector::detectName(const ByteBuffer& image, size_t size,
const Controller::Type controller, const Controller::Jack port,
const Controller::Type type, const Controller::Jack port,
const Settings& settings)
{
return Controller::getName(detectType(image, size, controller, port, settings));
return Controller::getName(detectType(image, size, type, port, settings));
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

12
src/emucore/ControllerDetector.hxx
View File

@ -34,15 +34,15 @@ class ControllerDetector
/**
Detects the controller type at the given port if no controller is provided.
@param image A reference to the ROM image
@param size The size of the ROM image
@param controller The provided controller type of the ROM image
@param port The port to be checked
@param settings A reference to the various settings (read-only)
@param image A reference to the ROM image
@param size The size of the ROM image
@param type The provided controller type of the ROM image
@param port The port to be checked
@param settings A reference to the various settings (read-only)
@return The detected controller type
*/
static Controller::Type detectType(const ByteBuffer& image, size_t size,
const Controller::Type controller, const Controller::Jack port,
const Controller::Type type, const Controller::Jack port,
const Settings& settings);
/**

2
src/emucore/EmulationWorker.hxx
View File

@ -128,7 +128,7 @@ class EmulationWorker
/**
Log a fatal error to cerr and throw a runtime exception.
*/
[[noreturn]] void fatal(const string& message);
[[noreturn]] static void fatal(const string& message);
private:
/**

46
src/emucore/EventHandler.cxx
View File

@ -270,7 +270,7 @@ void EventHandler::poll(uInt64 time)
myOSystem.state().update();
#ifdef CHEATCODE_SUPPORT
for(auto& cheat: myOSystem.cheat().perFrame())
for(const auto& cheat: myOSystem.cheat().perFrame())
cheat->evaluate();
#endif
@ -392,6 +392,7 @@ void EventHandler::handleSystemEvent(SystemEvent e, int, int)
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// NOLINTNEXTLINE (readability-function-size)
void EventHandler::handleEvent(Event::Type event, Int32 value, bool repeated)
{
// Take care of special events that aren't part of the emulation core
@ -1548,7 +1549,7 @@ void EventHandler::handleEvent(Event::Type event, Int32 value, bool repeated)
msg.push_back("");
msg.push_back("You will lose all your progress.");
}
myOSystem.messageMenu().setMessage("Exit Emulation", msg, true);
MessageMenu::setMessage("Exit Emulation", msg, true);
enterMenuMode(EventHandlerState::MESSAGEMENU);
}
else
@ -1913,15 +1914,15 @@ void EventHandler::setActionMappings(EventMode mode)
#ifdef JOYSTICK_SUPPORT
const string joydesc = myPJoyHandler->getMappingDesc(event, mode);
if(joydesc != "")
if(!joydesc.empty())
{
if(key != "")
if(!key.empty())
key += ", ";
key += joydesc;
}
#endif
if(key != "")
if(!key.empty())
item.key = key;
}
break;
@ -1935,15 +1936,15 @@ void EventHandler::setActionMappings(EventMode mode)
#ifdef JOYSTICK_SUPPORT
const string joydesc = myPJoyHandler->getMappingDesc(event, mode);
if(joydesc != "")
if(!joydesc.empty())
{
if(key != "")
if(!key.empty())
key += ", ";
key += joydesc;
}
#endif
if(key != "")
if(!key.empty())
item.key = key;
}
break;
@ -2035,7 +2036,7 @@ json EventHandler::convertLegacyComboMapping(string list)
events.push_back(Event::Type(event));
}
// only store if there are any NoType events
if(events.size())
if(!events.empty())
{
json combo;
@ -2173,7 +2174,7 @@ void EventHandler::saveComboMapping()
events.push_back(Event::Type(event));
}
// only store if there are any NoType events
if(events.size())
if(!events.empty())
{
json combo;
@ -2186,7 +2187,7 @@ void EventHandler::saveComboMapping()
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
StringList EventHandler::getActionList(EventMode mode) const
StringList EventHandler::getActionList(EventMode mode)
{
StringList l;
switch(mode)
@ -2206,10 +2207,8 @@ StringList EventHandler::getActionList(EventMode mode) const
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
StringList EventHandler::getActionList(Event::Group group) const
StringList EventHandler::getActionList(Event::Group group)
{
StringList l;
switch(group)
{
case Event::Group::Menu:
@ -2252,12 +2251,13 @@ StringList EventHandler::getActionList(Event::Group group) const
return getActionList(ComboEvents);
default:
return l; // ToDo
return {}; // ToDo
}
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
StringList EventHandler::getActionList(const Event::EventSet& events, EventMode mode) const
StringList EventHandler::getActionList(const Event::EventSet& events,
EventMode mode)
{
StringList l;
@ -2286,7 +2286,7 @@ StringList EventHandler::getActionList(const Event::EventSet& events, EventMode
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
VariantList EventHandler::getComboList() const
VariantList EventHandler::getComboList()
{
// For now, this only works in emulation mode
VariantList l;
@ -2355,7 +2355,7 @@ void EventHandler::setComboListForEvent(Event::Type event, const StringList& eve
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
int EventHandler::getEmulActionListIndex(int idx, const Event::EventSet& events) const
int EventHandler::getEmulActionListIndex(int idx, const Event::EventSet& events)
{
// idx = index into intersection set of 'events' and 'ourEmulActionList'
// ordered by 'ourEmulActionList'!
@ -2383,7 +2383,7 @@ int EventHandler::getEmulActionListIndex(int idx, const Event::EventSet& events)
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
int EventHandler::getActionListIndex(int idx, Event::Group group) const
int EventHandler::getActionListIndex(int idx, Event::Group group)
{
switch(group)
{
@ -2432,7 +2432,7 @@ int EventHandler::getActionListIndex(int idx, Event::Group group) const
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Event::Type EventHandler::eventAtIndex(int idx, Event::Group group) const
Event::Type EventHandler::eventAtIndex(int idx, Event::Group group)
{
const int index = getActionListIndex(idx, group);
@ -2453,7 +2453,7 @@ Event::Type EventHandler::eventAtIndex(int idx, Event::Group group) const
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
string EventHandler::actionAtIndex(int idx, Event::Group group) const
string EventHandler::actionAtIndex(int idx, Event::Group group)
{
const int index = getActionListIndex(idx, group);
@ -2474,7 +2474,7 @@ string EventHandler::actionAtIndex(int idx, Event::Group group) const
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
string EventHandler::keyAtIndex(int idx, Event::Group group) const
string EventHandler::keyAtIndex(int idx, Event::Group group)
{
const int index = getActionListIndex(idx, group);
@ -2527,7 +2527,7 @@ void EventHandler::changeMouseControllerMode(int direction)
string usemouse = myOSystem.settings().getString("usemouse");
int i = 0;
for(auto& mode : MODES)
for(const auto& mode : MODES)
{
if(mode == usemouse)
{

32
src/emucore/EventHandler.hxx
View File

@ -160,11 +160,11 @@ class EventHandler
Send an event directly to the event handler.
These events cannot be remapped.
@param type The event
@param event The event
@param value The value to use for the event
@param repeated Repeated key (true) or first press/release (false)
*/
void handleEvent(Event::Type type, Int32 value = 1, bool repeated = false);
void handleEvent(Event::Type event, Int32 value = 1, bool repeated = false);
/**
Handle events that must be processed each time a new console is
@ -174,8 +174,8 @@ class EventHandler
bool frying() const { return myFryingFlag; }
StringList getActionList(Event::Group group) const;
VariantList getComboList() const;
static StringList getActionList(Event::Group group);
static VariantList getComboList();
/** Used to access the list of events assigned to a specific combo event. */
StringList getComboListForEvent(Event::Type event) const;
@ -205,9 +205,9 @@ class EventHandler
return myPKeyHandler->getMappingDesc(event, mode);
}
Event::Type eventAtIndex(int idx, Event::Group group) const;
string actionAtIndex(int idx, Event::Group group) const;
string keyAtIndex(int idx, Event::Group group) const;
static Event::Type eventAtIndex(int idx, Event::Group group);
static string actionAtIndex(int idx, Event::Group group);
static string keyAtIndex(int idx, Event::Group group);
/**
Bind a key to an event/action and regenerate the mapping array(s).
@ -427,14 +427,15 @@ class EventHandler
void handleSystemEvent(SystemEvent e, int data1 = 0, int data2 = 0);
/**
Add the given joystick to the list of physical joysticks available to the handler.
Add the given joystick to the list of physical joysticks available to
the handler.
*/
void addPhysicalJoystick(const PhysicalJoystickPtr& stick);
void addPhysicalJoystick(const PhysicalJoystickPtr& joy);
/**
Remove physical joystick at the current index.
Remove physical joystick with the givem id.
*/
void removePhysicalJoystick(int index);
void removePhysicalJoystick(int id);
private:
// Define event groups
@ -459,11 +460,12 @@ class EventHandler
static nlohmann::json convertLegacyComboMapping(string list);
void saveComboMapping();
StringList getActionList(EventMode mode) const;
StringList getActionList(const Event::EventSet& events, EventMode mode = EventMode::kEmulationMode) const;
static StringList getActionList(EventMode mode);
static StringList getActionList(const Event::EventSet& events,
EventMode mode = EventMode::kEmulationMode);
// returns the action array index of the index in the provided group
int getEmulActionListIndex(int idx, const Event::EventSet& events) const;
int getActionListIndex(int idx, Event::Group group) const;
static int getEmulActionListIndex(int idx, const Event::EventSet& events);
static int getActionListIndex(int idx, Event::Group group);
private:
// Structure used for action menu items

8
src/emucore/FBSurface.cxx
View File

@ -298,7 +298,7 @@ void FBSurface::frameRect(uInt32 x, uInt32 y, uInt32 w, uInt32 h,
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void FBSurface::splitString(const GUI::Font& font, const string& s, int w,
string& left, string& right) const
string& left, string& right)
{
#ifdef GUI_SUPPORT
uInt32 pos = 0;
@ -334,12 +334,6 @@ void FBSurface::splitString(const GUI::Font& font, const string& s, int w,
#endif
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool FBSurface::isWhiteSpace(const char c) const
{
return string(" ,.;:+-*/\\'([\n").find(c) != string::npos;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
int FBSurface::drawString(const GUI::Font& font, const string& s,
int x, int y, int w, int h,

8
src/emucore/FBSurface.hxx
View File

@ -267,8 +267,8 @@ class FBSurface
@param left The left part of the split string
@param right The right part of the split string
*/
void splitString(const GUI::Font& font, const string& s, int w,
string& left, string& right) const;
static void splitString(const GUI::Font& font, const string& s, int w,
string& left, string& right);
/**
The rendering attributes that can be modified for this texture.
@ -403,7 +403,9 @@ class FBSurface
@param c Character to check
@return True if whitespace character
*/
bool isWhiteSpace(const char c) const;
static bool isWhiteSpace(const char c) {
return string(" ,.;:+-*/\\'([\n").find(c) != string::npos;
}
protected:
uInt32* myPixels{nullptr}; // NOTE: MUST be set in child classes

2
src/emucore/FrameBuffer.cxx
View File

@ -206,7 +206,7 @@ void FrameBuffer::setupFonts()
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
FontDesc FrameBuffer::getFontDesc(const string& name) const
FontDesc FrameBuffer::getFontDesc(const string& name)
{
if(name == "small")
return GUI::consoleDesc; // 8x13

2
src/emucore/FrameBuffer.hxx
View File

@ -324,7 +324,7 @@ class FrameBuffer
@return The description of the font
*/
FontDesc getFontDesc(const string& name) const;
static FontDesc getFontDesc(const string& name);
#endif
/**

8
src/emucore/GlobalKeyHandler.cxx
View File

@ -164,7 +164,7 @@ GlobalKeyHandler::Group GlobalKeyHandler::getGroup() const
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool GlobalKeyHandler::isJoystick(const Controller& controller) const
bool GlobalKeyHandler::isJoystick(const Controller& controller)
{
return controller.type() == Controller::Type::Joystick
|| controller.type() == Controller::Type::BoosterGrip
@ -175,7 +175,7 @@ bool GlobalKeyHandler::isJoystick(const Controller& controller) const
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool GlobalKeyHandler::isPaddle(const Controller& controller) const
bool GlobalKeyHandler::isPaddle(const Controller& controller)
{
return controller.type() == Controller::Type::Paddles
|| controller.type() == Controller::Type::PaddlesIAxDr
@ -186,7 +186,7 @@ bool GlobalKeyHandler::isPaddle(const Controller& controller) const
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool GlobalKeyHandler::isTrackball(const Controller& controller) const
bool GlobalKeyHandler::isTrackball(const Controller& controller)
{
return controller.type() == Controller::Type::AmigaMouse
|| controller.type() == Controller::Type::AtariMouse
@ -283,7 +283,7 @@ bool GlobalKeyHandler::skipDebugSetting() const
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
const GlobalKeyHandler::Function GlobalKeyHandler::cycleSetting(int direction)
GlobalKeyHandler::Function GlobalKeyHandler::cycleSetting(int direction)
{
bool skip = false;

16
src/emucore/GlobalKeyHandler.hxx
View File

@ -167,17 +167,21 @@ class GlobalKeyHandler
// Get group based on given setting
Group getGroup() const;
// Cycle settings using given direction (can be 0)
const Function cycleSetting(int direction);
Function cycleSetting(int direction);
// Get adjustment function and if it is repeated
SettingData getSettingData(const Setting setting) const;
PhysicalJoystickHandler& joyHandler() const { return myOSystem.eventHandler().joyHandler(); }
PhysicalKeyboardHandler& keyHandler() const { return myOSystem.eventHandler().keyHandler(); }
PhysicalJoystickHandler& joyHandler() const {
return myOSystem.eventHandler().joyHandler();
}
PhysicalKeyboardHandler& keyHandler() const {
return myOSystem.eventHandler().keyHandler();
}
// Check if controller type is used (skips related input settings if not)
bool isJoystick(const Controller& controller) const;
bool isPaddle(const Controller& controller) const;
bool isTrackball(const Controller& controller) const;
static bool isJoystick(const Controller& controller);
static bool isPaddle(const Controller& controller);
static bool isTrackball(const Controller& controller);
// Check if a currently non-relevant adjustment can be skipped
bool skipAVSetting() const;

10
src/emucore/Keyboard.cxx
View File

@ -55,7 +55,8 @@ Keyboard::Keyboard(Jack jack, const Event& event, const System& system)
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Keyboard::ColumnState Keyboard::processColumn(const Event::Type buttons[]) {
Keyboard::ColumnState Keyboard::processColumn(const Event::Type buttons[])
{
static constexpr DigitalPin signals[] =
{DigitalPin::One, DigitalPin::Two, DigitalPin::Three, DigitalPin::Four};
@ -69,8 +70,11 @@ Keyboard::ColumnState Keyboard::processColumn(const Event::Type buttons[]) {
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
AnalogReadout::Connection Keyboard::columnStateToAnalogSignal(ColumnState state) const {
switch (state) {
AnalogReadout::Connection
Keyboard::columnStateToAnalogSignal(ColumnState state)
{
switch (state)
{
case ColumnState::gnd:
return AnalogReadout::connectToGround();

2
src/emucore/Keyboard.hxx
View File

@ -70,7 +70,7 @@ class Keyboard : public Controller
private:
ColumnState processColumn(const Event::Type buttons[]);
AnalogReadout::Connection columnStateToAnalogSignal(ColumnState state) const;
static AnalogReadout::Connection columnStateToAnalogSignal(ColumnState state);
private:
// Pre-compute the events we care about based on given port

2
src/emucore/KidVid.cxx
View File

@ -210,7 +210,7 @@ void KidVid::setNextSong()
{
if(myFileOpened)
{
myBeep = (ourSongPositions[myFilePointer] & 0x80) ? false : true;
myBeep = (ourSongPositions[myFilePointer] & 0x80) == 0;
const uInt8 temp = ourSongPositions[myFilePointer] & 0x7f;
mySharedData = (temp < 10);

17
src/emucore/M6502.cxx
View File

@ -121,7 +121,7 @@ inline uInt8 M6502::peek(uInt16 address, Device::AccessFlags flags)
if(myReadTraps.isInitialized() && myReadTraps.isSet(address)
&& (myGhostReadsTrap || flags != DISASM_NONE))
{
myLastPeekBaseAddress = myDebugger->getBaseAddress(myLastPeekAddress, true); // mirror handling
myLastPeekBaseAddress = Debugger::getBaseAddress(myLastPeekAddress, true); // mirror handling
const int cond = evalCondTraps();
if(cond > -1)
{
@ -157,7 +157,7 @@ inline void M6502::poke(uInt16 address, uInt8 value, Device::AccessFlags flags)
#ifdef DEBUGGER_SUPPORT
if(myWriteTraps.isInitialized() && myWriteTraps.isSet(address))
{
myLastPokeBaseAddress = myDebugger->getBaseAddress(myLastPokeAddress, false); // mirror handling
myLastPokeBaseAddress = Debugger::getBaseAddress(myLastPokeAddress, false); // mirror handling
const int cond = evalCondTraps();
if(cond > -1)
{
@ -188,9 +188,9 @@ inline void M6502::handleHalt()
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void M6502::execute(uInt64 number, DispatchResult& result)
void M6502::execute(uInt64 cycles, DispatchResult& result)
{
_execute(number, result);
_execute(cycles, result);
#ifdef DEBUGGER_SUPPORT
// Debugger hack: this ensures that stepping a "STA WSYNC" will actually end at the
@ -208,16 +208,17 @@ void M6502::execute(uInt64 number, DispatchResult& result)
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool M6502::execute(uInt64 number)
bool M6502::execute(uInt64 cycles)
{
DispatchResult result;
execute(number, result);
execute(cycles, result);
return result.isSuccess();
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// NOLINTNEXTLINE (readability-function-size)
inline void M6502::_execute(uInt64 cycles, DispatchResult& result)
{
myExecutionStatus = 0;
@ -682,7 +683,7 @@ const StringList& M6502::getCondTrapNames() const
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void M6502::updateStepStateByInstruction()
{
myStepStateByInstruction = myCondBreaks.size() || myCondSaveStates.size() ||
myTrapConds.size();
myStepStateByInstruction =
!myCondBreaks.empty() || !myCondSaveStates.empty() || !myTrapConds.empty();
}
#endif // DEBUGGER_SUPPORT

8
src/emucore/M6502.hxx
View File

@ -114,10 +114,10 @@ class M6502 : public Serializable
is executed, someone stops execution, or an error occurs. Answers
true iff execution stops normally.
@param cycles Indicates the number of cycles to execute. Not that the actual
granularity of the CPU is instructions, so this is only accurate up to
a couple of cycles
@param result A DispatchResult object that will transport the result
@param cycles Indicates the number of cycles to execute. Not that the
actual granularity of the CPU is instructions, so this
is only accurate up to a couple of cycles
@param result A DispatchResult object that will transport the result
*/
void execute(uInt64 cycles, DispatchResult& result);

Some files were not shown because too many files have changed in this diff Show More