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

Fixes for suggestions from clang-tidy; mostly missing initializations.

This commit is contained in:
Stephen Anthony 2024-08-23 20:00:44 -02:30
parent ee7190851e
commit 0849a647e3
85 changed files with 270 additions and 322 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/cheat/BankRomCheat.hxx
View File

@ -31,7 +31,7 @@ class BankRomCheat : public Cheat
void evaluate() override; void evaluate() override;
private: private:
std::array<uInt8, 16> savedRom; std::array<uInt8, 16> savedRom{};
uInt16 address{0}; uInt16 address{0};
uInt8 value{0}; uInt8 value{0};
uInt8 count{0}; uInt8 count{0};

2
src/cheat/CheatManager.cxx
View File

@ -135,7 +135,7 @@ shared_ptr<Cheat> CheatManager::createCheat(string_view name, string_view code)
{ {
case 4: return make_shared<RamCheat>(myOSystem, name, code); case 4: return make_shared<RamCheat>(myOSystem, name, code);
case 6: return make_shared<CheetahCheat>(myOSystem, name, code); case 6: return make_shared<CheetahCheat>(myOSystem, name, code);
case 7: return make_shared<BankRomCheat>(myOSystem, name, code); case 7: [[fallthrough]];
case 8: return make_shared<BankRomCheat>(myOSystem, name, code); case 8: return make_shared<BankRomCheat>(myOSystem, name, code);
default: return nullptr; default: return nullptr;
} }

2
src/cheat/CheetahCheat.hxx
View File

@ -31,7 +31,7 @@ class CheetahCheat : public Cheat
void evaluate() override; void evaluate() override;
private: private:
std::array<uInt8, 16> savedRom; std::array<uInt8, 16> savedRom{};
uInt16 address{0}; uInt16 address{0};
uInt8 value{0}; uInt8 value{0};
uInt8 count{0}; uInt8 count{0};

68
src/common/DevSettingsHandler.hxx
View File

@ -47,44 +47,44 @@ class DevSettingsHandler
protected: protected:
OSystem& myOSystem; OSystem& myOSystem;
// Emulator sets // Emulator sets
std::array<bool, numSets> myFrameStats; std::array<bool, numSets> myFrameStats{};
std::array<bool, numSets> myDetectedInfo; std::array<bool, numSets> myDetectedInfo{};
std::array<bool, numSets> myExternAccess; std::array<bool, numSets> myExternAccess{};
std::array<int, numSets> myConsole; std::array<int, numSets> myConsole{};
std::array<bool, numSets> myRandomBank; std::array<bool, numSets> myRandomBank{};
std::array<bool, numSets> myRandomizeTIA; std::array<bool, numSets> myRandomizeTIA{};
std::array<bool, numSets> myRandomizeRAM; std::array<bool, numSets> myRandomizeRAM{};
std::array<string, numSets> myRandomizeCPU; std::array<string, numSets> myRandomizeCPU{};
std::array<bool, numSets> myColorLoss; std::array<bool, numSets> myColorLoss{};
std::array<bool, numSets> myTVJitter; std::array<bool, numSets> myTVJitter{};
std::array<int, numSets> myTVJitterSense; std::array<int, numSets> myTVJitterSense{};
std::array<int, numSets> myTVJitterRec; std::array<int, numSets> myTVJitterRec{};
std::array<bool, numSets> myDebugColors; std::array<bool, numSets> myDebugColors{};
std::array<bool, numSets> myRandomHotspots; std::array<bool, numSets> myRandomHotspots{};
std::array<bool, numSets> myUndrivenPins; std::array<bool, numSets> myUndrivenPins{};
#ifdef DEBUGGER_SUPPORT #ifdef DEBUGGER_SUPPORT
std::array<bool, numSets> myRWPortBreak; std::array<bool, numSets> myRWPortBreak{};
std::array<bool, numSets> myWRPortBreak; std::array<bool, numSets> myWRPortBreak{};
#endif #endif
std::array<bool, numSets> myThumbException; std::array<bool, numSets> myThumbException{};
std::array<int, numSets> myArmSpeed; std::array<int, numSets> myArmSpeed{};
// TIA sets // TIA sets
std::array<string, numSets> myTIAType; std::array<string, numSets> myTIAType{};
std::array<bool, numSets> myPlInvPhase; std::array<bool, numSets> myPlInvPhase{};
std::array<bool, numSets> myMsInvPhase; std::array<bool, numSets> myMsInvPhase{};
std::array<bool, numSets> myBlInvPhase; std::array<bool, numSets> myBlInvPhase{};
std::array<bool, numSets> myPFBits; std::array<bool, numSets> myPFBits{};
std::array<bool, numSets> myPFColor; std::array<bool, numSets> myPFColor{};
std::array<bool, numSets> myPFScore; std::array<bool, numSets> myPFScore{};
std::array<bool, numSets> myBKColor; std::array<bool, numSets> myBKColor{};
std::array<bool, numSets> myPlSwap; std::array<bool, numSets> myPlSwap{};
std::array<bool, numSets> myBlSwap; std::array<bool, numSets> myBlSwap{};
// States sets // States sets
std::array<bool, numSets> myTimeMachine; std::array<bool, numSets> myTimeMachine{};
std::array<int, numSets> myStateSize; std::array<int, numSets> myStateSize{};
std::array<int, numSets> myUncompressed; std::array<int, numSets> myUncompressed{};
std::array<string, numSets> myStateInterval; std::array<string, numSets> myStateInterval{};
std::array<string, numSets> myStateHorizon; std::array<string, numSets> myStateHorizon{};
private: private:
void handleEnableDebugColors(bool enable); void handleEnableDebugColors(bool enable);

1
src/common/EventHandlerSDL2.cxx
View File

@ -265,6 +265,7 @@ EventHandlerSDL2::JoystickSDL2::JoystickSDL2(int idx)
{ {
ASSERT_MAIN_THREAD; ASSERT_MAIN_THREAD;
// NOLINTNEXTLINE: we want to initialize here, not in the member list
myStick = SDL_JoystickOpen(idx); myStick = SDL_JoystickOpen(idx);
if(myStick) if(myStick)
{ {

3
src/common/FSNodeFactory.hxx
View File

@ -63,8 +63,9 @@ class FSNodeFactory
#endif #endif
break; break;
default: default:
return nullptr; break;
} }
return nullptr; // satisfy compiler
} }
private: private:

2
src/common/HighScoresManager.hxx
View File

@ -65,7 +65,7 @@ namespace HSM {
bool specialZeroBased{false}; bool specialZeroBased{false};
string notes; string notes;
// Addresses // Addresses
ScoreAddresses scoreAddr; ScoreAddresses scoreAddr{};
uInt16 varsAddr{0}; uInt16 varsAddr{0};
uInt16 specialAddr{0}; uInt16 specialAddr{0};
}; };

8
src/common/SoundSDL2.hxx
View File

@ -156,7 +156,7 @@ class SoundSDL2 : public Sound
bool myIsInitializedFlag{false}; bool myIsInitializedFlag{false};
// Audio specification structure // Audio specification structure
SDL_AudioSpec myHardwareSpec; SDL_AudioSpec myHardwareSpec{};
SDL_AudioDeviceID myDevice{0}; SDL_AudioDeviceID myDevice{0};
uInt32 myDeviceId{0}; uInt32 myDeviceId{0};
@ -196,9 +196,9 @@ class SoundSDL2 : public Sound
double mySpeed{1.0}; double mySpeed{1.0};
unique_ptr<uInt8[]> myCvtBuffer; unique_ptr<uInt8[]> myCvtBuffer;
uInt32 myCvtBufferSize{0}; uInt32 myCvtBufferSize{0};
SDL_AudioSpec mySpec; // audio output format SDL_AudioSpec mySpec{}; // audio output format
uInt8* myPos{nullptr}; // pointer to the audio buffer to be played uInt8* myPos{nullptr}; // pointer to the audio buffer to be played
uInt32 myRemaining{0}; // remaining length of the sample we have to play uInt32 myRemaining{0}; // remaining length of the sample we have to play
private: private:
// Callback function invoked by the SDL Audio library when it needs data // Callback function invoked by the SDL Audio library when it needs data

2
src/common/Stack.hxx
View File

@ -31,7 +31,7 @@ template <typename T, size_t CAPACITY = 50>
class FixedStack class FixedStack
{ {
private: private:
std::array<T, CAPACITY> _stack; std::array<T, CAPACITY> _stack{};
size_t _size{0}; size_t _size{0};
public: public:

3
src/common/StaggeredLogger.cxx
View File

@ -27,8 +27,7 @@ namespace {
{ {
const std::tm now = BSPF::localTime(); const std::tm now = BSPF::localTime();
std::array<char, 100> formattedTime; std::array<char, 100> formattedTime{};
formattedTime.fill(0);
std::ignore = std::strftime(formattedTime.data(), 99, "%H:%M:%S", &now); std::ignore = std::strftime(formattedTime.data(), 99, "%H:%M:%S", &now);
return formattedTime.data(); return formattedTime.data();

2
src/common/StateManager.hxx
View File

@ -18,7 +18,7 @@
#ifndef STATE_MANAGER_HXX #ifndef STATE_MANAGER_HXX
#define STATE_MANAGER_HXX #define STATE_MANAGER_HXX
#define STATE_HEADER "06070020state" #define STATE_HEADER "06070030state"
class OSystem; class OSystem;
class RewindManager; class RewindManager;

2
src/common/bspf.hxx
View File

@ -424,7 +424,7 @@ namespace BSPF
inline std::tm localTime() inline std::tm localTime()
{ {
const auto currtime = std::time(nullptr); const auto currtime = std::time(nullptr);
std::tm tm_snapshot; std::tm tm_snapshot{};
#if (defined BSPF_WINDOWS || defined __WIN32__) && (!defined __GNUG__ || defined __MINGW32__) #if (defined BSPF_WINDOWS || defined __WIN32__) && (!defined __GNUG__ || defined __MINGW32__)
localtime_s(&tm_snapshot, &currtime); localtime_s(&tm_snapshot, &currtime);
#else #else

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

@ -31,9 +31,7 @@ namespace {
string s; string s;
while(in.get(c)) while(in.get(c))
{ {
if((c == '\\') && (in.peek() == '"')) if(c == '\\' && (in.peek() == '"' || in.peek() == '\\'))
in.get(c);
else if((c == '\\') && (in.peek() == '\\'))
in.get(c); in.get(c);
else if(c == '"') else if(c == '"')
break; break;

3
src/common/tv_filters/AtariNTSC.cxx
View File

@ -106,7 +106,8 @@ void AtariNTSC::render(const uInt8* atari_in, uInt32 in_width, uInt32 in_height,
// Spawn the threads... // Spawn the threads...
for(uInt32 i = 0; i < myWorkerThreads; ++i) for(uInt32 i = 0; i < myWorkerThreads; ++i)
{ {
myThreads[i] = std::thread([=, this] myThreads[i] = std::thread([rgb_in, atari_in, in_width, in_height,
i, rgb_out, out_pitch, this]
{ {
rgb_in == nullptr ? rgb_in == nullptr ?
renderThread(atari_in, in_width, in_height, myTotalThreads, renderThread(atari_in, in_width, in_height, myTotalThreads,

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

@ -154,8 +154,8 @@ class AtariNTSC
luma_cutoff = 0.20F luma_cutoff = 0.20F
; ;
std::array<uInt8, palette_size * 3L> myRGBPalette; std::array<uInt8, palette_size * 3L> myRGBPalette{};
BSPF::array2D<uInt32, palette_size, entry_size> myColorTable; BSPF::array2D<uInt32, palette_size, entry_size> myColorTable{};
// Rendering threads // Rendering threads
unique_ptr<std::thread[]> myThreads; unique_ptr<std::thread[]> myThreads;

9
src/debugger/CartDebug.cxx
View File

@ -779,9 +779,8 @@ int CartDebug::getAddress(const string& label) const
{ {
LabelToAddr::const_iterator iter; LabelToAddr::const_iterator iter;
if((iter = mySystemAddresses.find(label)) != mySystemAddresses.end()) if((iter = mySystemAddresses.find(label)) != mySystemAddresses.end() ||
return iter->second; ((iter = myUserAddresses.find(label)) != myUserAddresses.end()))
else if((iter = myUserAddresses.find(label)) != myUserAddresses.end())
return iter->second; return iter->second;
else else
return -1; return -1;
@ -1626,10 +1625,8 @@ void CartDebug::accessTypeAsString(ostream& buf, uInt16 addr) const
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Device::AccessType CartDebug::accessTypeAbsolute(Device::AccessFlags flags) Device::AccessType CartDebug::accessTypeAbsolute(Device::AccessFlags flags)
{ {
if(flags & Device::CODE) if(flags & Device::CODE || flags & Device::TCODE) // TODO: TCODE separate?
return Device::CODE; return Device::CODE;
else if(flags & Device::TCODE)
return Device::CODE; // TODO - should this be separate??
else if(flags & Device::GFX) else if(flags & Device::GFX)
return Device::GFX; return Device::GFX;
else if(flags & Device::PGFX) else if(flags & Device::PGFX)

10
src/debugger/CartDebug.hxx
View File

@ -294,14 +294,14 @@ class CartDebug : public DebuggerSystem
}; };
// Address type information determined by Distella // Address type information determined by Distella
AddrTypeArray myDisLabels, myDisDirectives; AddrTypeArray myDisLabels{}, myDisDirectives{};
// Information on equates used in the disassembly // Information on equates used in the disassembly
struct ReservedEquates { struct ReservedEquates {
std::array<bool, 16> TIARead{false}; std::array<bool, 16> TIARead{};
std::array<bool, 64> TIAWrite{false}; std::array<bool, 64> TIAWrite{};
std::array<bool, 32> IOReadWrite{false}; std::array<bool, 32> IOReadWrite{};
std::array<bool, 128> ZPRAM{false}; std::array<bool, 128> ZPRAM{};
AddrToLabel Label; AddrToLabel Label;
bool breakFound{false}; bool breakFound{false};
}; };

6
src/debugger/DebuggerParser.cxx
View File

@ -499,14 +499,14 @@ bool DebuggerParser::validateArgs(int cmd)
case Parameters::ARG_LABEL: case Parameters::ARG_LABEL:
case Parameters::ARG_FILE: case Parameters::ARG_FILE:
break; // TODO: validate these (for now any string's allowed) [[fallthrough]]; // FIXME: validate these (for now any string's allowed)
case Parameters::ARG_MULTI_BYTE: case Parameters::ARG_MULTI_BYTE:
case Parameters::ARG_MULTI_WORD: case Parameters::ARG_MULTI_WORD:
break; // FIXME: validate these (for now, any number's allowed) [[fallthrough]]; // FIXME: validate these (for now, any number's allowed)
case Parameters::ARG_END_ARGS: case Parameters::ARG_END_ARGS:
break; [[fallthrough]];
default: default:
break; // Not supposed to get here break; // Not supposed to get here

36
src/debugger/DiStella.cxx
View File

@ -31,6 +31,7 @@ DiStella::DiStella(const CartDebug& dbg, CartDebug::DisassemblyList& list,
myList{list}, myList{list},
mySettings{s}, mySettings{s},
myReserved{reserved}, myReserved{reserved},
myOffset{info.offset},
myLabels{labels}, myLabels{labels},
myDirectives{directives} myDirectives{directives}
{ {
@ -38,7 +39,6 @@ DiStella::DiStella(const CartDebug& dbg, CartDebug::DisassemblyList& list,
const CartDebug::AddressList& debuggerAddresses = info.addressList; const CartDebug::AddressList& debuggerAddresses = info.addressList;
const uInt16 start = *debuggerAddresses.cbegin(); const uInt16 start = *debuggerAddresses.cbegin();
myOffset = info.offset;
if (start & 0x1000) { if (start & 0x1000) {
info.start = myAppData.start = 0x0000; info.start = myAppData.start = 0x0000;
info.end = myAppData.end = static_cast<uInt16>(info.size - 1); info.end = myAppData.end = static_cast<uInt16>(info.size - 1);
@ -818,38 +818,21 @@ void DiStella::disasmFromAddress(uInt32 distart)
mark(ad, Device::DATA); mark(ad, Device::DATA);
break; break;
case AddressingMode::ZERO_PAGE: case AddressingMode::ABSOLUTE_X:
d1 = Debugger::debugger().peek(myPC + myOffset); ++myPC; case AddressingMode::ABSOLUTE_Y:
mark(d1, Device::REFERENCED); case AddressingMode::ABS_INDIRECT:
ad = Debugger::debugger().dpeek(myPC + myOffset); myPC += 2;
mark(ad, Device::REFERENCED);
break; break;
case AddressingMode::IMMEDIATE: case AddressingMode::IMMEDIATE:
++myPC;
break;
case AddressingMode::ABSOLUTE_X:
ad = Debugger::debugger().dpeek(myPC + myOffset); myPC += 2;
mark(ad, Device::REFERENCED);
break;
case AddressingMode::ABSOLUTE_Y:
ad = Debugger::debugger().dpeek(myPC + myOffset); myPC += 2;
mark(ad, Device::REFERENCED);
break;
case AddressingMode::INDIRECT_X: case AddressingMode::INDIRECT_X:
++myPC;
break;
case AddressingMode::INDIRECT_Y: case AddressingMode::INDIRECT_Y:
++myPC; ++myPC;
break; break;
case AddressingMode::ZERO_PAGE:
case AddressingMode::ZERO_PAGE_X: case AddressingMode::ZERO_PAGE_X:
d1 = Debugger::debugger().peek(myPC + myOffset); ++myPC;
mark(d1, Device::REFERENCED);
break;
case AddressingMode::ZERO_PAGE_Y: case AddressingMode::ZERO_PAGE_Y:
d1 = Debugger::debugger().peek(myPC + myOffset); ++myPC; d1 = Debugger::debugger().peek(myPC + myOffset); ++myPC;
mark(d1, Device::REFERENCED); mark(d1, Device::REFERENCED);
@ -869,11 +852,6 @@ void DiStella::disasmFromAddress(uInt32 distart)
} }
break; break;
case AddressingMode::ABS_INDIRECT:
ad = Debugger::debugger().dpeek(myPC + myOffset); myPC += 2;
mark(ad, Device::REFERENCED);
break;
default: default:
break; break;
} // end switch } // end switch

2
src/debugger/TrapArray.hxx
View File

@ -44,7 +44,7 @@ class TrapArray
private: private:
// The actual counts // The actual counts
std::array<uInt8, 0x10000> myCount; std::array<uInt8, 0x10000> myCount{};
// Indicates whether we should treat this array as initialized // Indicates whether we should treat this array as initialized
bool myInitialized{false}; bool myInitialized{false};

9
src/debugger/gui/CartELFWidget.cxx
View File

@ -29,7 +29,7 @@
namespace { namespace {
constexpr int SAVE_ARM_IMAGE_CMD = 'sarm'; constexpr int SAVE_ARM_IMAGE_CMD = 'sarm';
} } // namespace
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
CartridgeELFWidget::CartridgeELFWidget(GuiObject* boss, const GUI::Font& lfont, CartridgeELFWidget::CartridgeELFWidget(GuiObject* boss, const GUI::Font& lfont,
@ -41,6 +41,7 @@ CartridgeELFWidget::CartridgeELFWidget(GuiObject* boss, const GUI::Font& lfont,
initialize(); initialize();
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CartridgeELFWidget::initialize() void CartridgeELFWidget::initialize()
{ {
addBaseInformation(myCart.myImageSize, "AtariAge", "see log below", 1); addBaseInformation(myCart.myImageSize, "AtariAge", "see log below", 1);
@ -60,7 +61,7 @@ void CartridgeELFWidget::initialize()
const auto& logLines = parser.stringList(); const auto& logLines = parser.stringList();
const bool useScrollbar = logLines.size() > visibleLogLines; const bool useScrollbar = logLines.size() > visibleLogLines;
auto logWidget = new StringListWidget( auto* logWidget = new StringListWidget(
_boss, _font, x, y, width, visibleLogLines * lineHeight, false, useScrollbar _boss, _font, x, y, width, visibleLogLines * lineHeight, false, useScrollbar
); );
@ -72,7 +73,7 @@ void CartridgeELFWidget::initialize()
WidgetArray wid; WidgetArray wid;
const auto saveImageButton = new ButtonWidget(_boss, _font, x, y, "Save ARM image", SAVE_ARM_IMAGE_CMD); auto* saveImageButton = new ButtonWidget(_boss, _font, x, y, "Save ARM image", SAVE_ARM_IMAGE_CMD);
saveImageButton->setTarget(this); saveImageButton->setTarget(this);
wid.push_back(saveImageButton); wid.push_back(saveImageButton);
@ -80,6 +81,7 @@ void CartridgeELFWidget::initialize()
addToFocusList(wid); addToFocusList(wid);
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CartridgeELFWidget::saveArmImage(const FSNode& node) void CartridgeELFWidget::saveArmImage(const FSNode& node)
{ {
try { try {
@ -95,6 +97,7 @@ void CartridgeELFWidget::saveArmImage(const FSNode& node)
} }
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CartridgeELFWidget::handleCommand(CommandSender* sender, int cmd, int data, int id) void CartridgeELFWidget::handleCommand(CommandSender* sender, int cmd, int data, int id)
{ {
if (cmd == SAVE_ARM_IMAGE_CMD) if (cmd == SAVE_ARM_IMAGE_CMD)

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

@ -40,7 +40,10 @@
PromptWidget::PromptWidget(GuiObject* boss, const GUI::Font& font, PromptWidget::PromptWidget(GuiObject* boss, const GUI::Font& font,
int x, int y, int w, int h) int x, int y, int w, int h)
: Widget(boss, font, x, y, w - ScrollBarWidget::scrollBarWidth(font), h), : Widget(boss, font, x, y, w - ScrollBarWidget::scrollBarWidth(font), h),
CommandSender(boss) CommandSender(boss),
_kConsoleCharWidth{font.getMaxCharWidth()},
_kConsoleCharHeight{font.getFontHeight()},
_kConsoleLineHeight{_kConsoleCharHeight + 2}
{ {
_flags = Widget::FLAG_ENABLED | Widget::FLAG_CLEARBG | Widget::FLAG_RETAIN_FOCUS | _flags = Widget::FLAG_ENABLED | Widget::FLAG_CLEARBG | Widget::FLAG_RETAIN_FOCUS |
Widget::FLAG_WANTS_TAB | Widget::FLAG_WANTS_RAWDATA; Widget::FLAG_WANTS_TAB | Widget::FLAG_WANTS_RAWDATA;
@ -48,20 +51,16 @@ PromptWidget::PromptWidget(GuiObject* boss, const GUI::Font& font,
_bgcolor = kWidColor; _bgcolor = kWidColor;
_bgcolorlo = kDlgColor; _bgcolorlo = kDlgColor;
_kConsoleCharWidth = font.getMaxCharWidth();
_kConsoleCharHeight = font.getFontHeight();
_kConsoleLineHeight = _kConsoleCharHeight + 2;
// Calculate depending values // Calculate depending values
_lineWidth = (_w - ScrollBarWidget::scrollBarWidth(_font) - 2) / _kConsoleCharWidth; _lineWidth = (_w - ScrollBarWidget::scrollBarWidth(_font) - 2) / _kConsoleCharWidth;
_linesPerPage = (_h - 2) / _kConsoleLineHeight; _linesPerPage = (_h - 2) / _kConsoleLineHeight;
_linesInBuffer = kBufferSize / _lineWidth; _linesInBuffer = kBufferSize / _lineWidth;
// Add scrollbar // Add scrollbar
// NOLINTNEXTLINE: we want to initialize here, not in the member list
_scrollBar = new ScrollBarWidget(boss, font, _x + _w, _y, _scrollBar = new ScrollBarWidget(boss, font, _x + _w, _y,
ScrollBarWidget::scrollBarWidth(_font), _h); ScrollBarWidget::scrollBarWidth(_font), _h);
_scrollBar->setTarget(this); _scrollBar->setTarget(this);
_scrollStopLine = INT_MAX;
clearScreen(); clearScreen();

26
src/debugger/gui/PromptWidget.hxx
View File

@ -106,29 +106,29 @@ class PromptWidget : public Widget, public CommandSender
kHistorySize = 1000 kHistorySize = 1000
}; };
int _buffer[kBufferSize]; // NOLINT (will be rewritten soon) int _buffer[kBufferSize]{}; // NOLINT (will be rewritten soon)
int _linesInBuffer; int _linesInBuffer{0};
int _lineWidth; int _lineWidth{0};
int _linesPerPage; int _linesPerPage{0};
int _currentPos; int _currentPos{0};
int _scrollLine; int _scrollLine{0};
int _firstLineInBuffer; int _firstLineInBuffer{0};
int _scrollStopLine; int _scrollStopLine{INT_MAX};
int _promptStartPos; int _promptStartPos{0};
int _promptEndPos; int _promptEndPos{0};
ScrollBarWidget* _scrollBar; ScrollBarWidget* _scrollBar{nullptr};
std::vector<string> _history; std::vector<string> _history;
int _historyIndex{0}; int _historyIndex{0};
int _historyLine{0}; int _historyLine{0};
int _tabCount{-1}; int _tabCount{-1};
char _inputStr[kLineBufferSize]; char _inputStr[kLineBufferSize]{};
int _kConsoleCharWidth, _kConsoleCharHeight, _kConsoleLineHeight; int _kConsoleCharWidth{0}, _kConsoleCharHeight{0}, _kConsoleLineHeight{0};
bool _inverse{false}; bool _inverse{false};
bool _firstTime{true}; bool _firstTime{true};

8
src/debugger/gui/RomListSettings.cxx
View File

@ -157,15 +157,7 @@ void RomListSettings::handleCommand(CommandSender* sender, int cmd, int data, in
{ {
case RomListWidget::kSetPCCmd: case RomListWidget::kSetPCCmd:
case RomListWidget::kRuntoPCCmd: case RomListWidget::kRuntoPCCmd:
{
sendCommand(cmd, _item, -1);
break;
}
case RomListWidget::kSetTimerCmd: case RomListWidget::kSetTimerCmd:
{
sendCommand(cmd, _item, -1);
break;
}
case RomListWidget::kDisassembleCmd: case RomListWidget::kDisassembleCmd:
{ {
sendCommand(cmd, _item, -1); sendCommand(cmd, _item, -1);

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

@ -33,7 +33,8 @@
RomListWidget::RomListWidget(GuiObject* boss, const GUI::Font& lfont, RomListWidget::RomListWidget(GuiObject* boss, const GUI::Font& lfont,
const GUI::Font& nfont, const GUI::Font& nfont,
int x, int y, int w, int h) int x, int y, int w, int h)
: EditableWidget(boss, nfont, x, y, 16, 16) : EditableWidget(boss, nfont, x, y, 16, 16),
_rows{h / _lineHeight}
{ {
_flags = Widget::FLAG_ENABLED | Widget::FLAG_CLEARBG | Widget::FLAG_RETAIN_FOCUS; _flags = Widget::FLAG_ENABLED | Widget::FLAG_CLEARBG | Widget::FLAG_RETAIN_FOCUS;
_bgcolor = kWidColor; _bgcolor = kWidColor;
@ -44,14 +45,12 @@ RomListWidget::RomListWidget(GuiObject* boss, const GUI::Font& lfont,
_editMode = false; _editMode = false;
_dyText = -1; // fixes the vertical position of selected text _dyText = -1; // fixes the vertical position of selected text
_cols = w / _fontWidth;
_rows = h / _lineHeight;
// Set real dimensions // Set real dimensions
_w = w - ScrollBarWidget::scrollBarWidth(_font); _w = w - ScrollBarWidget::scrollBarWidth(_font);
_h = h + 2; _h = h + 2;
// Create scrollbar and attach to the list // Create scrollbar and attach to the list
// NOLINTNEXTLINE: we want to initialize here, not in the member list
myScrollBar = new ScrollBarWidget(boss, lfont, _x + _w, _y, myScrollBar = new ScrollBarWidget(boss, lfont, _x + _w, _y,
ScrollBarWidget::scrollBarWidth(_font), _h); ScrollBarWidget::scrollBarWidth(_font), _h);
myScrollBar->setTarget(this); myScrollBar->setTarget(this);
@ -73,7 +72,7 @@ RomListWidget::RomListWidget(GuiObject* boss, const GUI::Font& lfont,
// rowheight is determined by largest item on a line, // rowheight is determined by largest item on a line,
// possibly meaning that number of rows will change // possibly meaning that number of rows will change
_lineHeight = std::max(_lineHeight, CheckboxWidget::boxSize(_font)); _lineHeight = std::max(_lineHeight, CheckboxWidget::boxSize(_font));
_rows = h / _lineHeight; _rows = h / _lineHeight; // NOLINT: must be initialized after _lineHeight
// Create a CheckboxWidget for each row in the list // Create a CheckboxWidget for each row in the list
for(int i = 0; i < _rows; ++i) for(int i = 0; i < _rows; ++i)

1
src/debugger/gui/RomListWidget.hxx
View File

@ -98,7 +98,6 @@ class RomListWidget : public EditableWidget
int _labelWidth{0}; int _labelWidth{0};
int _bytesWidth{0}; int _bytesWidth{0};
int _rows{0}; int _rows{0};
int _cols{0};
int _currentPos{0}; // position of first line in visible window int _currentPos{0}; // position of first line in visible window
int _selectedItem{-1}; int _selectedItem{-1};
int _highlightedItem{-1}; int _highlightedItem{-1};

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

@ -63,7 +63,7 @@ class TiaOutputWidget : public Widget, public CommandSender
// Create this buffer once, instead of allocating it each time the // Create this buffer once, instead of allocating it each time the
// TIA image is redrawn // TIA image is redrawn
std::array<uInt32, 320> myLineBuffer; std::array<uInt32, 320> myLineBuffer{};
private: private:
void handleMouseDown(int x, int y, MouseButton b, int clickCount) override; void handleMouseDown(int x, int y, MouseButton b, int clickCount) override;

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

@ -49,8 +49,8 @@ TiaZoomWidget::TiaZoomWidget(GuiObject* boss, const GUI::Font& font,
addFocusWidget(this); addFocusWidget(this);
// Initialize positions // Initialize positions
myNumCols = (_w - 4) / myZoomLevel; myNumCols = (_w - 4) / myZoomLevel; // NOLINT: must initialize after _w
myNumRows = (_h - 4) / myZoomLevel; myNumRows = (_h - 4) / myZoomLevel; // NOLINT: must initialize after _h
// Create context menu for zoom levels // Create context menu for zoom levels
VariantList l; VariantList l;

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

@ -20,6 +20,8 @@
#include "YaccParser.hxx" #include "YaccParser.hxx"
// NOLINTBEGIN: this entire class is due to be rewritten
namespace YaccParser { namespace YaccParser {
#include <cctype> #include <cctype>
@ -409,3 +411,5 @@ int yylex() {
} }
} // namespace YaccParser } // namespace YaccParser
// NOLINTEND

3
src/emucore/Cart.cxx
View File

@ -191,13 +191,12 @@ uInt16 Cartridge::bankOrigin(uInt16 bank, uInt16 PC) const
const uInt32 offset = bank * bankSize(); const uInt32 offset = bank * bankSize();
//uInt16 addrMask = (4_KB - 1) & ~(bankSize(bank) - 1); //uInt16 addrMask = (4_KB - 1) & ~(bankSize(bank) - 1);
//int addrShift = 0; //int addrShift = 0;
std::array<uInt16, intervals> count; // up to 128 256 byte interval origins std::array<uInt16, intervals> count{}; // up to 128 256 byte interval origins
//if(addrMask) //if(addrMask)
// addrShift = log(addrMask) / log(2); // addrShift = log(addrMask) / log(2);
//addrMask; //addrMask;
count.fill(0);
if(PC) if(PC)
count[PC >> 13]++; count[PC >> 13]++;
for(uInt16 addr = 0x0000; addr < bankSize(bank); ++addr) for(uInt16 addr = 0x0000; addr < bankSize(bank); ++addr)

2
src/emucore/Cart.hxx
View File

@ -452,7 +452,7 @@ class Cartridge : public Device
messageCallback myMsgCallback{nullptr}; messageCallback myMsgCallback{nullptr};
// Semi-random values to use when a read from write port occurs // Semi-random values to use when a read from write port occurs
std::array<uInt8, 256> myRWPRandomValues; std::array<uInt8, 256> myRWPRandomValues{};
// If myRandomHotspots is true, peeks to hotspots return semi-random values. // If myRandomHotspots is true, peeks to hotspots return semi-random values.
bool myRandomHotspots{false}; bool myRandomHotspots{false};

2
src/emucore/Cart4A50.hxx
View File

@ -217,7 +217,7 @@ class Cartridge4A50 : public Cartridge
ByteBuffer myImage; ByteBuffer myImage;
// The 32K of RAM on the cartridge // The 32K of RAM on the cartridge
std::array<uInt8, 32_KB> myRAM; std::array<uInt8, 32_KB> myRAM{};
// (Actual) Size of the ROM image // (Actual) Size of the ROM image
size_t mySize{0}; size_t mySize{0};

4
src/emucore/CartAR.cxx
View File

@ -33,11 +33,11 @@ namespace {
CartridgeAR::CartridgeAR(const ByteBuffer& image, size_t size, CartridgeAR::CartridgeAR(const ByteBuffer& image, size_t size,
string_view md5, const Settings& settings) string_view md5, const Settings& settings)
: Cartridge(settings, md5), : Cartridge(settings, md5),
mySize{std::max(size, LOAD_SIZE)} mySize{std::max(size, LOAD_SIZE)},
myNumberOfLoadImages{static_cast<uInt8>(mySize / LOAD_SIZE)}
{ {
// Create a load image buffer and copy the given image // Create a load image buffer and copy the given image
myLoadImages = make_unique<uInt8[]>(mySize); myLoadImages = make_unique<uInt8[]>(mySize);
myNumberOfLoadImages = static_cast<uInt8>(mySize / LOAD_SIZE);
std::copy_n(image.get(), size, myLoadImages.get()); std::copy_n(image.get(), size, myLoadImages.get());
// Add header if image doesn't include it // Add header if image doesn't include it

6
src/emucore/CartAR.hxx
View File

@ -194,13 +194,13 @@ class CartridgeAR : public Cartridge
private: private:
// Indicates the offset within the image for the corresponding bank // Indicates the offset within the image for the corresponding bank
std::array<uInt32, 2> myImageOffset; std::array<uInt32, 2> myImageOffset{};
// The 6K of RAM and 2K of ROM contained in the Supercharger // The 6K of RAM and 2K of ROM contained in the Supercharger
std::array<uInt8, 8_KB> myImage; std::array<uInt8, 8_KB> myImage{};
// The 256 byte header for the current 8448 byte load // The 256 byte header for the current 8448 byte load
std::array<uInt8, 256> myHeader; std::array<uInt8, 256> myHeader{};
// Size of the ROM image // Size of the ROM image
size_t mySize{0}; size_t mySize{0};

20
src/emucore/CartBUS.hxx
View File

@ -45,11 +45,11 @@ class CartridgeBUS : public CartridgeARM
enum class BUSSubtype: uInt8 { enum class BUSSubtype: uInt8 {
BUS0, // very old demos when BUS was in flux, not supported in Stella BUS0, // very old demos when BUS was in flux, not supported in Stella
BUS1, // draconian_20161102.bin BUS1, // draconian_20161102.bin
BUS2, // 128bus_20170120.bin, 128chronocolour_20170101.bin, parrot_20161231_NTSC.bin BUS2, // 128bus_20170120.bin, 128chronocolour_20170101.bin,
// parrot_20161231_NTSC.bin
BUS3 // rpg_20170616_NTSC.bin BUS3 // rpg_20170616_NTSC.bin
}; };
public: public:
/** /**
Create a new cartridge using the specified image Create a new cartridge using the specified image
@ -160,18 +160,18 @@ class CartridgeBUS : public CartridgeARM
*/ */
uInt8 internalRamGetValue(uInt16 addr) const override; uInt8 internalRamGetValue(uInt16 addr) const override;
#ifdef DEBUGGER_SUPPORT #ifdef DEBUGGER_SUPPORT
/** /**
Get debugger widget responsible for accessing the inner workings Get debugger widget responsible for accessing the inner workings
of the cart. of the cart.
*/ */
CartDebugWidget* debugWidget(GuiObject* boss, const GUI::Font& lfont, CartDebugWidget* debugWidget(GuiObject* boss, const GUI::Font& lfont,
const GUI::Font& nfont, int x, int y, int w, int h) override; const GUI::Font& nfont, int x, int y,
int w, int h) override;
CartDebugWidget* infoWidget(GuiObject* boss, const GUI::Font& lfont, CartDebugWidget* infoWidget(GuiObject* boss, const GUI::Font& lfont,
const GUI::Font& nfont, int x, int y, int w, int h) override; const GUI::Font& nfont, int x, int y,
int w, int h) override;
#endif #endif
public: public:
@ -249,7 +249,7 @@ class CartridgeBUS : public CartridgeARM
// $0000 - 2K BUS driver // $0000 - 2K BUS driver
// $0800 - 4K Display Data // $0800 - 4K Display Data
// $1800 - 2K C Variable & Stack // $1800 - 2K C Variable & Stack
std::array<uInt8, 8_KB> myRAM; std::array<uInt8, 8_KB> myRAM{};
// Indicates the offset into the ROM image (aligns to current bank) // Indicates the offset into the ROM image (aligns to current bank)
uInt16 myBankOffset{0}; uInt16 myBankOffset{0};
@ -283,13 +283,13 @@ class CartridgeBUS : public CartridgeARM
uInt16 myWaveformBase{0}; // was WAVEFORM uInt16 myWaveformBase{0}; // was WAVEFORM
// The music mode counters // The music mode counters
std::array<uInt32, 3> myMusicCounters{0}; std::array<uInt32, 3> myMusicCounters{};
// The music frequency // The music frequency
std::array<uInt32, 3> myMusicFrequencies{0}; std::array<uInt32, 3> myMusicFrequencies{};
// The music waveform sizes // The music waveform sizes
std::array<uInt8, 3> myMusicWaveformSize{0}; std::array<uInt8, 3> myMusicWaveformSize{};
// Fractional DPC music OSC clocks unused during the last update // Fractional DPC music OSC clocks unused during the last update
double myFractionalClocks{0.0}; double myFractionalClocks{0.0};

1
src/emucore/CartCDF.cxx
View File

@ -70,6 +70,7 @@ CartridgeCDF::CartridgeCDF(const ByteBuffer& image, size_t size,
// Pointer to the program ROM // Pointer to the program ROM
// which starts after the 2K driver (and 2K C Code for CDF) // which starts after the 2K driver (and 2K C Code for CDF)
// NOLINTNEXTLINE: we want to initialize here, not in the member list
myProgramImage = myImage.get() + (isCDFJplus() ? 2_KB : 4_KB); myProgramImage = myImage.get() + (isCDFJplus() ? 2_KB : 4_KB);
// Pointer to CDF driver in RAM // Pointer to CDF driver in RAM

8
src/emucore/CartCDF.hxx
View File

@ -202,9 +202,11 @@ class CartridgeCDF : public CartridgeARM
of the cart. of the cart.
*/ */
CartDebugWidget* debugWidget(GuiObject* boss, const GUI::Font& lfont, CartDebugWidget* debugWidget(GuiObject* boss, const GUI::Font& lfont,
const GUI::Font& nfont, int x, int y, int w, int h) override; const GUI::Font& nfont, int x, int y,
int w, int h) override;
CartDebugWidget* infoWidget(GuiObject* boss, const GUI::Font& lfont, CartDebugWidget* infoWidget(GuiObject* boss, const GUI::Font& lfont,
const GUI::Font& nfont, int x, int y, int w, int h) override; const GUI::Font& nfont, int x, int y,
int w, int h) override;
#endif #endif
public: public:
@ -296,7 +298,7 @@ class CartridgeCDF : public CartridgeARM
// For CDFJ+, used as: // For CDFJ+, used as:
// $0000 - 2K Driver // $0000 - 2K Driver
// $0800 - Display Data, C Variables & Stack // $0800 - Display Data, C Variables & Stack
std::array<uInt8, 32_KB> myRAM; std::array<uInt8, 32_KB> myRAM{};
// Indicates the offset into the ROM image (aligns to current bank) // Indicates the offset into the ROM image (aligns to current bank)
uInt16 myBankOffset{0}; uInt16 myBankOffset{0};

6
src/emucore/CartCTY.cxx
View File

@ -515,7 +515,7 @@ void CartridgeCTY::loadScore(uInt8 index)
const Serializer serializer(myEEPROMFile, Serializer::Mode::ReadOnly); const Serializer serializer(myEEPROMFile, Serializer::Mode::ReadOnly);
if(serializer) if(serializer)
{ {
std::array<uInt8, 256> scoreRAM; std::array<uInt8, 256> scoreRAM{};
try try
{ {
serializer.getByteArray(scoreRAM.data(), scoreRAM.size()); serializer.getByteArray(scoreRAM.data(), scoreRAM.size());
@ -537,7 +537,7 @@ void CartridgeCTY::saveScore(uInt8 index)
if(serializer) if(serializer)
{ {
// Load score RAM // Load score RAM
std::array<uInt8, 256> scoreRAM; std::array<uInt8, 256> scoreRAM{};
try try
{ {
serializer.getByteArray(scoreRAM.data(), scoreRAM.size()); serializer.getByteArray(scoreRAM.data(), scoreRAM.size());
@ -571,7 +571,7 @@ void CartridgeCTY::wipeAllScores()
if(serializer) if(serializer)
{ {
// Erase score RAM // Erase score RAM
std::array<uInt8, 256> scoreRAM = {}; std::array<uInt8, 256> scoreRAM{};
try try
{ {
serializer.putByteArray(scoreRAM.data(), scoreRAM.size()); serializer.putByteArray(scoreRAM.data(), scoreRAM.size());

8
src/emucore/CartCTY.hxx
View File

@ -274,10 +274,10 @@ class CartridgeCTY : public Cartridge
ByteBuffer myImage; ByteBuffer myImage;
// The 28K ROM image of the music // The 28K ROM image of the music
std::array<uInt8, 28_KB> myTuneData; std::array<uInt8, 28_KB> myTuneData{};
// The 64 bytes of RAM accessible at $1000 - $1080 // The 64 bytes of RAM accessible at $1000 - $1080
std::array<uInt8, 64> myRAM; std::array<uInt8, 64> myRAM{};
// Console clock rate // Console clock rate
double myClockRate{1193191.66666667}; double myClockRate{1193191.66666667};
@ -293,10 +293,10 @@ class CartridgeCTY : public Cartridge
uInt16 myTunePosition{0}; uInt16 myTunePosition{0};
// The music mode counters // The music mode counters
std::array<uInt32, 3> myMusicCounters{0}; std::array<uInt32, 3> myMusicCounters{};
// The music frequency // The music frequency
std::array<uInt32, 3> myMusicFrequencies{0}; std::array<uInt32, 3> myMusicFrequencies{};
// Flags that last byte peeked was A9 (LDA #) // Flags that last byte peeked was A9 (LDA #)
bool myLDAimmediate{false}; bool myLDAimmediate{false};

20
src/emucore/CartDPCPlus.hxx
View File

@ -235,25 +235,25 @@ class CartridgeDPCPlus : public CartridgeARM
// 3K DPC+ driver // 3K DPC+ driver
// 4K Display Data // 4K Display Data
// 1K Frequency Data // 1K Frequency Data
std::array<uInt8, 8_KB> myDPCRAM; std::array<uInt8, 8_KB> myDPCRAM{};
// Pointer to the 1K frequency table // Pointer to the 1K frequency table
uInt8* myFrequencyImage{nullptr}; uInt8* myFrequencyImage{nullptr};
// The top registers for the data fetchers // The top registers for the data fetchers
std::array<uInt8, 8> myTops; std::array<uInt8, 8> myTops{};
// The bottom registers for the data fetchers // The bottom registers for the data fetchers
std::array<uInt8, 8> myBottoms; std::array<uInt8, 8> myBottoms{};
// The counter registers for the data fetchers // The counter registers for the data fetchers
std::array<uInt16, 8> myCounters; std::array<uInt16, 8> myCounters{};
// The counter registers for the fractional data fetchers // The counter registers for the fractional data fetchers
std::array<uInt32, 8> myFractionalCounters; std::array<uInt32, 8> myFractionalCounters{};
// The fractional increments for the data fetchers // The fractional increments for the data fetchers
std::array<uInt8, 8> myFractionalIncrements; std::array<uInt8, 8> myFractionalIncrements{};
// The Fast Fetcher Enabled flag // The Fast Fetcher Enabled flag
bool myFastFetch{false}; bool myFastFetch{false};
@ -262,19 +262,19 @@ class CartridgeDPCPlus : public CartridgeARM
bool myLDAimmediate{false}; bool myLDAimmediate{false};
// Parameter for special functions // Parameter for special functions
std::array<uInt8, 8> myParameter; std::array<uInt8, 8> myParameter{};
// Parameter pointer for special functions // Parameter pointer for special functions
uInt8 myParameterPointer{0}; uInt8 myParameterPointer{0};
// The music mode counters // The music mode counters
std::array<uInt32, 3> myMusicCounters; std::array<uInt32, 3> myMusicCounters{};
// The music frequency // The music frequency
std::array<uInt32, 3> myMusicFrequencies; std::array<uInt32, 3> myMusicFrequencies{};
// The music waveforms // The music waveforms
std::array<uInt16, 3> myMusicWaveforms; std::array<uInt16, 3> myMusicWaveforms{};
// The random number generator register // The random number generator register
uInt32 myRandomNumber{1}; uInt32 myRandomNumber{1};

4
src/emucore/CartE7.hxx
View File

@ -259,10 +259,10 @@ class CartridgeE7 : public Cartridge
size_t mySize{0}; size_t mySize{0};
// The 2K of RAM // The 2K of RAM
std::array<uInt8, RAM_SIZE> myRAM; std::array<uInt8, RAM_SIZE> myRAM{};
// Indicates which bank is in the segment // Indicates which bank is in the segment
std::array<uInt16, NUM_SEGMENTS> myCurrentBank; std::array<uInt16, NUM_SEGMENTS> myCurrentBank{};
// Indicates which 256 byte bank of RAM is being used // Indicates which 256 byte bank of RAM is being used
uInt16 myCurrentRAM{0}; uInt16 myCurrentRAM{0};

3
src/emucore/CartELF.cxx
View File

@ -411,7 +411,7 @@ std::pair<unique_ptr<uInt8[]>, size_t> CartridgeELF::getArmImage() const
memcpy(image.get() + ADDR_RODATA_BASE, mySectionRodata.get(), RODATA_SIZE); memcpy(image.get() + ADDR_RODATA_BASE, mySectionRodata.get(), RODATA_SIZE);
memcpy(image.get() + ADDR_TABLES_BASE, mySectionTables.get(), TABLES_SIZE); memcpy(image.get() + ADDR_TABLES_BASE, mySectionTables.get(), TABLES_SIZE);
return std::pair(std::move(image), imageSize); return {std::move(image), imageSize};
} }
#endif #endif
@ -718,6 +718,7 @@ void CartridgeELF::setupConfig()
myConfigSystemType = determineSystemType(myProperties); myConfigSystemType = determineSystemType(myProperties);
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CartridgeELF::resetWithConfig() void CartridgeELF::resetWithConfig()
{ {
std::fill_n(myLastPeekResult.get(), 0x1000, 0); std::fill_n(myLastPeekResult.get(), 0x1000, 0);

10
src/emucore/CartMVC.cxx
View File

@ -54,7 +54,7 @@ namespace {
class StreamReader : public Serializable class StreamReader : public Serializable
{ {
public: public:
StreamReader() { myBuffer1.fill(0); myBuffer2.fill(0); } StreamReader() = default;
bool open(string_view path) { bool open(string_view path) {
myFile = Serializer(path, Serializer::Mode::ReadOnly); myFile = Serializer(path, Serializer::Mode::ReadOnly);
@ -250,8 +250,8 @@ class StreamReader : public Serializable
uInt8* myColor{nullptr}; uInt8* myColor{nullptr};
uInt8* myColorBK{nullptr}; uInt8* myColorBK{nullptr};
std::array<uInt8, CartridgeMVC::MVC_FIELD_SIZE> myBuffer1; std::array<uInt8, CartridgeMVC::MVC_FIELD_SIZE> myBuffer1{};
std::array<uInt8, CartridgeMVC::MVC_FIELD_SIZE> myBuffer2; std::array<uInt8, CartridgeMVC::MVC_FIELD_SIZE> myBuffer2{};
uInt8 myVisibleLines{192}; uInt8 myVisibleLines{192};
uInt8 myVSyncLines{3}; uInt8 myVSyncLines{3};
@ -785,7 +785,7 @@ static constexpr uInt8 levelBarsOddData[] = {
class MovieCart : public Serializable class MovieCart : public Serializable
{ {
public: public:
MovieCart() { myROM.fill(0); } MovieCart() = default;
bool init(string_view path); bool init(string_view path);
bool process(uInt16 address); bool process(uInt16 address);
@ -845,7 +845,7 @@ class MovieCart : public Serializable
void updateTransport(); void updateTransport();
// data // data
std::array<uInt8, 1_KB> myROM; std::array<uInt8, 1_KB> myROM{};
// title screen state // title screen state
int myTitleCycles{0}; int myTitleCycles{0};

2
src/emucore/CartMVC.hxx
View File

@ -135,7 +135,7 @@ class CartridgeMVC : public Cartridge
private: private:
// Currently not used: // Currently not used:
// Pointer to a dynamically allocated ROM image of the cartridge // Pointer to a dynamically allocated ROM image of the cartridge
ByteBuffer myImage{nullptr}; ByteBuffer myImage;
size_t mySize{0}; size_t mySize{0};
unique_ptr<MovieCart> myMovie; unique_ptr<MovieCart> myMovie;

7
src/emucore/Console.cxx
View File

@ -116,9 +116,10 @@ Console::Console(OSystem& osystem, unique_ptr<Cartridge>& cart,
const Properties& props, AudioSettings& audioSettings) const Properties& props, AudioSettings& audioSettings)
: myOSystem{osystem}, : myOSystem{osystem},
myEvent{osystem.eventHandler().event()}, myEvent{osystem.eventHandler().event()},
myAudioSettings{audioSettings},
myProperties{props}, myProperties{props},
myCart{std::move(cart)}, myCart{std::move(cart)},
myAudioSettings{audioSettings} myDisplayFormat{myProperties.get(PropType::Display_Format)}
{ {
myEmulationTiming = make_shared<EmulationTiming>(); myEmulationTiming = make_shared<EmulationTiming>();
myCart->setProperties(&myProperties); myCart->setProperties(&myProperties);
@ -170,9 +171,6 @@ Console::Console(OSystem& osystem, unique_ptr<Cartridge>& cart,
myDevSettingsHandler = make_unique<DevSettingsHandler>(myOSystem); myDevSettingsHandler = make_unique<DevSettingsHandler>(myOSystem);
// Auto-detect NTSC/PAL mode if it's requested // Auto-detect NTSC/PAL mode if it's requested
string autodetected;
myDisplayFormat = myProperties.get(PropType::Display_Format);
if (myDisplayFormat == "AUTO") if (myDisplayFormat == "AUTO")
myDisplayFormat = formatFromFilename(); myDisplayFormat = formatFromFilename();
@ -184,6 +182,7 @@ Console::Console(OSystem& osystem, unique_ptr<Cartridge>& cart,
myOSystem.sound().pause(true); myOSystem.sound().pause(true);
myOSystem.frameBuffer().clear(); myOSystem.frameBuffer().clear();
string autodetected;
if(myDisplayFormat == "AUTO" || myOSystem.settings().getBool("rominfo")) if(myDisplayFormat == "AUTO" || myOSystem.settings().getBool("rominfo"))
{ {
autodetectFrameLayout(); autodetectFrameLayout();

6
src/emucore/Console.hxx
View File

@ -444,6 +444,9 @@ class Console : public Serializable, public ConsoleIO
// Reference to the event object to use // Reference to the event object to use
const Event& myEvent; const Event& myEvent;
// The audio settings
AudioSettings& myAudioSettings;
// Properties for the game // Properties for the game
Properties myProperties; Properties myProperties;
@ -501,9 +504,6 @@ class Console : public Serializable, public ConsoleIO
// so we make it a shared pointer. // so we make it a shared pointer.
shared_ptr<EmulationTiming> myEmulationTiming; shared_ptr<EmulationTiming> myEmulationTiming;
// The audio settings
AudioSettings& myAudioSettings;
private: private:
// Following constructors and assignment operators not supported // Following constructors and assignment operators not supported
Console() = delete; Console() = delete;

4
src/emucore/ControllerDetector.cxx
View File

@ -90,7 +90,7 @@ Controller::Type ControllerDetector::autodetectPort(
type = Controller::Type::Paddles; type = Controller::Type::Paddles;
else if(isProbablyKidVid(image, size, port)) else if(isProbablyKidVid(image, size, port))
type = Controller::Type::KidVid; type = Controller::Type::KidVid;
else if (isQuadTari) // currently most likely assumption else if(isQuadTari) // currently most likely assumption
type = Controller::Type::Paddles; type = Controller::Type::Paddles;
} }
// TODO: BOOSTERGRIP, DRIVING, COMPUMATE, MINDLINK, ATARIVOX // TODO: BOOSTERGRIP, DRIVING, COMPUMATE, MINDLINK, ATARIVOX
@ -102,7 +102,7 @@ Controller::Type ControllerDetector::autodetectPort(
bool ControllerDetector::searchForBytes(const ByteBuffer& image, size_t imagesize, bool ControllerDetector::searchForBytes(const ByteBuffer& image, size_t imagesize,
const uInt8* signature, uInt32 sigsize) const uInt8* signature, uInt32 sigsize)
{ {
if (imagesize >= sigsize) if(imagesize >= sigsize)
for(uInt32 i = 0; i < imagesize - sigsize; ++i) for(uInt32 i = 0; i < imagesize - sigsize; ++i)
{ {
uInt32 matches = 0; uInt32 matches = 0;

9
src/emucore/CortexM0.cxx
View File

@ -551,9 +551,8 @@ string CortexM0::describeError(err_t err) {
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
CortexM0::CortexM0() CortexM0::CortexM0()
: myPageMap{make_unique<uInt8[]>(PAGEMAP_SIZE)}
{ {
myPageMap = make_unique<uInt8[]>(PAGEMAP_SIZE);
resetMappings(); resetMappings();
reset(); reset();
} }
@ -628,8 +627,7 @@ void CortexM0::MemoryRegion::loadDirtyBits(Serializer& in)
bool CortexM0::save(Serializer& out) const bool CortexM0::save(Serializer& out) const
{ {
try { try {
for (size_t i = 0; i < 16; i++) out.putIntArray(reg_norm.data(), reg_norm.size());
out.putInt(reg_norm[i]);
out.putInt(znFlags); out.putInt(znFlags);
out.putInt(cFlag); out.putInt(cFlag);
@ -650,8 +648,7 @@ bool CortexM0::load(Serializer& in)
try { try {
reset(); reset();
for (size_t i = 0; i < 16; i++) in.getIntArray(reg_norm.data(), reg_norm.size());
reg_norm[i] = in.getInt();
znFlags = in.getInt(); znFlags = in.getInt();
cFlag = in.getInt(); cFlag = in.getInt();

6
src/emucore/CortexM0.hxx
View File

@ -147,7 +147,7 @@ class CortexM0: public Serializable
private: private:
enum class MemoryRegionType : uInt8 { enum class MemoryRegionType: uInt8 {
directData, directData,
directCode, directCode,
delegate, delegate,
@ -208,12 +208,12 @@ class CortexM0: public Serializable
err_t execute(uInt16 inst, uInt8 op); err_t execute(uInt16 inst, uInt8 op);
private: private:
std::array<uInt32, 16> reg_norm; // normal execution mode, do not have a thread mode std::array<uInt32, 16> reg_norm{}; // normal execution mode, do not have a thread mode
uInt32 znFlags{0}; uInt32 znFlags{0};
uInt32 cFlag{0}; uInt32 cFlag{0};
uInt32 vFlag{0}; uInt32 vFlag{0};
std::array<MemoryRegion, 0x100> myRegions; std::array<MemoryRegion, 0x100> myRegions{};
unique_ptr<uInt8[]> myPageMap; unique_ptr<uInt8[]> myPageMap;
uInt8 myNextRegionIndex{0}; uInt8 myNextRegionIndex{0};
BusTransactionDelegate* myDefaultDelegate{nullptr}; BusTransactionDelegate* myDefaultDelegate{nullptr};

2
src/emucore/Event.hxx
View File

@ -200,7 +200,7 @@ class Event
/** /**
Create a new event object. Create a new event object.
*/ */
Event() { clear(); } Event() { clear(); } // NOLINT: myValues is initialized in clear()
~Event() = default; ~Event() = default;
public: public:

2
src/emucore/EventHandler.cxx
View File

@ -2418,7 +2418,7 @@ int EventHandler::getActionListIndex(int idx, Event::Group group)
switch(group) switch(group)
{ {
using enum Event::Group; using enum Event::Group;
case Menu: return idx; case Menu:
case Emulation: return idx; case Emulation: return idx;
case Misc: return getEmulActionListIndex(idx, MiscEvents); case Misc: return getEmulActionListIndex(idx, MiscEvents);
case AudioVideo: return getEmulActionListIndex(idx, AudioVideoEvents); case AudioVideo: return getEmulActionListIndex(idx, AudioVideoEvents);

2
src/emucore/EventHandler.hxx
View File

@ -549,7 +549,7 @@ class EventHandler
; ;
// The event(s) assigned to each combination event // The event(s) assigned to each combination event
BSPF::array2D<Event::Type, COMBO_SIZE, EVENTS_PER_COMBO> myComboTable; BSPF::array2D<Event::Type, COMBO_SIZE, EVENTS_PER_COMBO> myComboTable{};
// Holds static strings for the remap menu (emulation and menu events) // Holds static strings for the remap menu (emulation and menu events)
using EmulActionList = std::array<ActionList, EMUL_ACTIONLIST_SIZE>; using EmulActionList = std::array<ActionList, EMUL_ACTIONLIST_SIZE>;

18
src/emucore/M6532.hxx
View File

@ -190,7 +190,7 @@ class M6532 : public Device
const Settings& mySettings; const Settings& mySettings;
// An amazing 128 bytes of RAM // An amazing 128 bytes of RAM
std::array<uInt8, 128> myRAM; std::array<uInt8, 128> myRAM{};
// Current value of the timer // Current value of the timer
uInt8 myTimer{0}; uInt8 myTimer{0};
@ -230,7 +230,7 @@ class M6532 : public Device
bool myEdgeDetectPositive{false}; bool myEdgeDetectPositive{false};
// Last value written to the timer registers // Last value written to the timer registers
std::array<uInt8, 4> myOutTimer{0}; std::array<uInt8, 4> myOutTimer{};
// Accessible bits in the interrupt flag register // Accessible bits in the interrupt flag register
// All other bits are always zeroed // All other bits are always zeroed
@ -245,19 +245,19 @@ class M6532 : public Device
// The arrays containing information about every byte of RIOT // The arrays containing information about every byte of RIOT
// indicating whether and how (RW) it is used. // indicating whether and how (RW) it is used.
std::array<Device::AccessFlags, RAM_SIZE> myRAMAccessBase; std::array<Device::AccessFlags, RAM_SIZE> myRAMAccessBase{};
std::array<Device::AccessFlags, STACK_SIZE> myStackAccessBase; std::array<Device::AccessFlags, STACK_SIZE> myStackAccessBase{};
std::array<Device::AccessFlags, IO_SIZE> myIOAccessBase; std::array<Device::AccessFlags, IO_SIZE> myIOAccessBase{};
// The arrays containing information about every byte of RIOT // The arrays containing information about every byte of RIOT
// indicating how often it is accessed. // indicating how often it is accessed.
std::array<Device::AccessCounter, std::array<Device::AccessCounter,
static_cast<size_t>(RAM_SIZE * 2)> myRAMAccessCounter; static_cast<size_t>(RAM_SIZE * 2)> myRAMAccessCounter{};
std::array<Device::AccessCounter, std::array<Device::AccessCounter,
static_cast<size_t>(STACK_SIZE * 2)> myStackAccessCounter; static_cast<size_t>(STACK_SIZE * 2)> myStackAccessCounter{};
std::array<Device::AccessCounter, std::array<Device::AccessCounter,
static_cast<size_t>(IO_SIZE * 2)> myIOAccessCounter; static_cast<size_t>(IO_SIZE * 2)> myIOAccessCounter{};
// The array used to skip the first ZP access tracking // The array used to skip the first ZP access tracking
std::array<uInt8, RAM_SIZE> myZPAccessDelay; std::array<uInt8, RAM_SIZE> myZPAccessDelay{};
// Detect timer being accessed on wraparound // Detect timer being accessed on wraparound
bool myTimWrappedOnRead{false}; bool myTimWrappedOnRead{false};

10
src/emucore/MD5.cxx
View File

@ -86,7 +86,7 @@ void MD5::encode(uInt8* output, const uInt32* input, uInt32 len)
// Apply MD5 algo on a block. // Apply MD5 algo on a block.
void MD5::transform(const uInt8* block) void MD5::transform(const uInt8* block)
{ {
std::array<uInt32, 16> x; std::array<uInt32, 16> x{};
decode(x.data(), block, BLOCKSIZE); decode(x.data(), block, BLOCKSIZE);
uInt32 a = state[0], b = state[1], c = state[2], d = state[3]; uInt32 a = state[0], b = state[1], c = state[2], d = state[3];
@ -214,16 +214,12 @@ void MD5::update(const uInt8* input, uInt32 length)
// the message digest and zeroizing the context. // the message digest and zeroizing the context.
void MD5::finalize() void MD5::finalize()
{ {
static constexpr std::array<uInt8, BLOCKSIZE> padding = { static constexpr std::array<uInt8, BLOCKSIZE> padding = { 0x80 };
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
if (!finalized) if (!finalized)
{ {
// Save number of bits // Save number of bits
std::array<uInt8, 8> bits; std::array<uInt8, 8> bits{};
encode(bits.data(), count.data(), 8); encode(bits.data(), count.data(), 8);
// Pad out to 56 mod 64 // Pad out to 56 mod 64

8
src/emucore/MD5.hxx
View File

@ -122,10 +122,10 @@ class MD5
private: private:
static constexpr uInt32 BLOCKSIZE = 64; static constexpr uInt32 BLOCKSIZE = 64;
bool finalized{false}; bool finalized{false};
std::array<uInt8, BLOCKSIZE> buffer; // bytes that didn't fit in last chunk std::array<uInt8, BLOCKSIZE> buffer{}; // bytes that didn't fit in last chunk
std::array<uInt32, 2> count; // 64bit counter for number of bits (lo, hi) std::array<uInt32, 2> count{}; // 64bit counter for number of bits (lo, hi)
std::array<uInt32, 4> state; // digest so far std::array<uInt32, 4> state{}; // digest so far
std::array<uInt8, 16> digest; // the result std::array<uInt8, 16> digest{}; // the result
private: private:
MD5(const MD5&) = delete; MD5(const MD5&) = delete;

4
src/emucore/MT24LC256.hxx
View File

@ -96,7 +96,7 @@ class MT24LC256
ByteBuffer myData; ByteBuffer myData;
// Track which pages are used // Track which pages are used
std::array<bool, PAGE_NUM> myPageHit; std::array<bool, PAGE_NUM> myPageHit{};
// Cached state of the SDA and SCL pins on the last write // Cached state of the SDA and SCL pins on the last write
bool mySDA{false}, mySCL{false}; bool mySDA{false}, mySCL{false};
@ -121,7 +121,7 @@ class MT24LC256
Int32 jpee_sizemask{0}, jpee_pagemask{0}, jpee_smallmode{0}, jpee_logmode{0}; Int32 jpee_sizemask{0}, jpee_pagemask{0}, jpee_smallmode{0}, jpee_logmode{0};
Int32 jpee_pptr{0}, jpee_state{0}, jpee_nb{0}; Int32 jpee_pptr{0}, jpee_state{0}, jpee_nb{0};
uInt32 jpee_address{0}, jpee_ad_known{0}; uInt32 jpee_address{0}, jpee_ad_known{0};
std::array<uInt8, 70> jpee_packet; std::array<uInt8, 70> jpee_packet{};
private: private:
// Following constructors and assignment operators not supported // Following constructors and assignment operators not supported

12
src/emucore/PlusROM.cxx
View File

@ -72,8 +72,10 @@ class PlusROMRequest {
public: public:
PlusROMRequest(const Destination& destination, const PlusStoreId& id, PlusROMRequest(const Destination& destination, const PlusStoreId& id,
const uInt8* request, uInt8 requestSize) const uInt8* request, uInt8 requestSize)
: myState{State::created}, myDestination{destination}, : myState{State::created},
myId{id}, myRequestSize{requestSize} myDestination{destination},
myId{id},
myRequestSize{requestSize}
{ {
memcpy(myRequest.data(), request, myRequestSize); memcpy(myRequest.data(), request, myRequestSize);
} }
@ -184,7 +186,7 @@ class PlusROMRequest {
Destination myDestination; Destination myDestination;
PlusStoreId myId; PlusStoreId myId;
std::array<uInt8, 256> myRequest; std::array<uInt8, 256> myRequest{};
uInt8 myRequestSize{0}; uInt8 myRequestSize{0};
string myResponse; string myResponse;
@ -201,8 +203,6 @@ PlusROM::PlusROM(const Settings& settings, const Cartridge& cart)
: mySettings{settings}, : mySettings{settings},
myCart{cart} myCart{cart}
{ {
myRxBuffer.fill(0);
myTxBuffer.fill(0);
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -433,7 +433,7 @@ void PlusROM::send()
// as the thread is running. Thus, the request can only be destructed once // as the thread is running. Thus, the request can only be destructed once
// the thread has finished, and we can safely evict it from the deque at // the thread has finished, and we can safely evict it from the deque at
// any time. // any time.
std::thread thread([=, this]() std::thread thread([request, this]()
{ {
request->execute(); request->execute();
switch(request->getState()) switch(request->getState())

2
src/emucore/PlusROM.hxx
View File

@ -178,7 +178,7 @@ class PlusROM : public Serializable
string myHost; string myHost;
string myPath; string myPath;
std::array<uInt8, 256> myRxBuffer, myTxBuffer; std::array<uInt8, 256> myRxBuffer{}, myTxBuffer{};
uInt8 myRxReadPos{0}, myRxWritePos{0}, myTxPos{0}; uInt8 myRxReadPos{0}, myRxWritePos{0}, myTxPos{0};
std::deque<shared_ptr<PlusROMRequest>> myPendingRequests; std::deque<shared_ptr<PlusROMRequest>> myPendingRequests;

6
src/emucore/Settings.cxx
View File

@ -835,7 +835,7 @@ void Settings::usage()
#if defined(BSPF_UNIX) || defined(BSPF_MACOS) #if defined(BSPF_UNIX) || defined(BSPF_MACOS)
int height = 25; int height = 25;
struct winsize ws; struct winsize ws{};
ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws); ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws);
@ -906,7 +906,8 @@ void Settings::migrateOne()
const int version = getInt(SETTINGS_VERSION_KEY); const int version = getInt(SETTINGS_VERSION_KEY);
if (version >= SETTINGS_VERSION) return; if (version >= SETTINGS_VERSION) return;
switch (version) { // NOLINT (could be written as IF/ELSE) // NOLINTBEGIN: could be written as IF/ELSE, bugprone-branch-clone
switch (version) {
case 0: case 0:
#if defined BSPF_MACOS || defined DARWIN #if defined BSPF_MACOS || defined DARWIN
setPermanent("video", ""); setPermanent("video", "");
@ -915,6 +916,7 @@ void Settings::migrateOne()
default: default:
break; break;
} }
// NOLINTEND
setPermanent(SETTINGS_VERSION_KEY, version + 1); setPermanent(SETTINGS_VERSION_KEY, version + 1);
} }

9
src/emucore/System.cxx
View File

@ -31,17 +31,12 @@ System::System(Random& random, M6502& m6502, M6532& m6532,
myM6502{m6502}, myM6502{m6502},
myM6532{m6532}, myM6532{m6532},
myTIA{mTIA}, myTIA{mTIA},
myCart{mCart} myCart{mCart},
myCartridgeDoesBusStuffing{myCart.doesBusStuffing()}
{ {
// Initialize page access table // Initialize page access table
const PageAccess access(&myNullDevice, System::PageAccessType::READ); const PageAccess access(&myNullDevice, System::PageAccessType::READ);
myPageAccessTable.fill(access); myPageAccessTable.fill(access);
myPageIsDirtyTable.fill(false);
// Bus starts out unlocked (in other words, peek() changes myDataBusState)
myDataBusLocked = false;
myCartridgeDoesBusStuffing = myCart.doesBusStuffing();
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

2
src/emucore/System.hxx
View File

@ -430,7 +430,7 @@ class System : public Serializable
std::array<PageAccess, NUM_PAGES> myPageAccessTable; std::array<PageAccess, NUM_PAGES> myPageAccessTable;
// The list of dirty pages // The list of dirty pages
std::array<bool, NUM_PAGES> myPageIsDirtyTable; std::array<bool, NUM_PAGES> myPageIsDirtyTable{};
// The current state of the Data Bus // The current state of the Data Bus
uInt8 myDataBusState{0}; uInt8 myDataBusState{0};

6
src/emucore/TIASurface.hxx
View File

@ -248,17 +248,17 @@ class TIASurface
std::array<uInt32, static_cast<std::size_t> std::array<uInt32, static_cast<std::size_t>
(AtariNTSC::outWidth(TIAConstants::frameBufferWidth) * (AtariNTSC::outWidth(TIAConstants::frameBufferWidth) *
TIAConstants::frameBufferHeight)> myRGBFramebuffer; TIAConstants::frameBufferHeight)> myRGBFramebuffer{};
std::array<uInt32, static_cast<std::size_t> std::array<uInt32, static_cast<std::size_t>
(AtariNTSC::outWidth(TIAConstants::frameBufferWidth) * (AtariNTSC::outWidth(TIAConstants::frameBufferWidth) *
TIAConstants::frameBufferHeight)> myPrevRGBFramebuffer; TIAConstants::frameBufferHeight)> myPrevRGBFramebuffer{};
///////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////
// Use scanlines in TIA rendering mode // Use scanlines in TIA rendering mode
bool myScanlinesEnabled{false}; bool myScanlinesEnabled{false};
// Palette for normal TIA rendering mode // Palette for normal TIA rendering mode
PaletteArray myPalette; PaletteArray myPalette{};
// Flag for saving a snapshot // Flag for saving a snapshot
bool mySaveSnapFlag{false}; bool mySaveSnapFlag{false};

8
src/emucore/Thumbulator.cxx
View File

@ -2952,7 +2952,7 @@ int Thumbulator::reset()
#endif #endif
#ifdef THUMB_STATS #ifdef THUMB_STATS
_stats.reads = _stats.writes _stats.reads = _stats.writes
= _stats.nCylces = _stats.sCylces = _stats.iCylces = _stats.nCycles = _stats.nCycles = _stats.iCycles
= _stats.branches = _stats.taken = _stats.branches = _stats.taken
= _stats.mamPrefetchHits = _stats.mamPrefetchMisses = _stats.mamPrefetchHits = _stats.mamPrefetchMisses
= _stats.mamBranchHits = _stats.mamBranchMisses = _stats.mamBranchHits = _stats.mamBranchMisses
@ -3191,7 +3191,7 @@ void Thumbulator::incCycles(AccessType accessType, uInt32 cycles)
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Thumbulator::incSCycles(uInt32 addr, AccessType accessType) void Thumbulator::incSCycles(uInt32 addr, AccessType accessType)
{ {
THUMB_STAT(_stats.sCylces) THUMB_STAT(_stats.nCycles)
uInt32 cycles = 0; uInt32 cycles = 0;
if(addr & 0xC0000000) // RAM, peripherals if(addr & 0xC0000000) // RAM, peripherals
@ -3251,7 +3251,7 @@ void Thumbulator::incSCycles(uInt32 addr, AccessType accessType)
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Thumbulator::incNCycles(uInt32 addr, AccessType accessType) void Thumbulator::incNCycles(uInt32 addr, AccessType accessType)
{ {
THUMB_STAT(_stats.nCylces) THUMB_STAT(_stats.nCycles)
uInt32 cycles = 0; uInt32 cycles = 0;
if(addr & 0xC0000000) // RAM, peripherals if(addr & 0xC0000000) // RAM, peripherals
@ -3278,7 +3278,7 @@ void Thumbulator::incNCycles(uInt32 addr, AccessType accessType)
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Thumbulator::incICycles(uInt32 m) void Thumbulator::incICycles(uInt32 m)
{ {
THUMB_STAT(_stats.iCylces) THUMB_STAT(_stats.iCycles)
#ifdef EMULATE_PIPELINE #ifdef EMULATE_PIPELINE
_fetchPipeline += m; _fetchPipeline += m;

4
src/emucore/Thumbulator.hxx
View File

@ -79,7 +79,7 @@ class Thumbulator
uInt32 instructions{0}; uInt32 instructions{0};
#ifdef THUMB_STATS #ifdef THUMB_STATS
uInt32 reads{0}, writes{0}; uInt32 reads{0}, writes{0};
uInt32 nCylces{0}, sCylces{0}, iCylces{0}; uInt32 nCycles{0}, sCycles{0}, iCycles{0};
uInt32 branches{0}, taken{0}; uInt32 branches{0}, taken{0};
uInt32 mamPrefetchHits{0}, mamPrefetchMisses{0}; uInt32 mamPrefetchHits{0}, mamPrefetchMisses{0};
uInt32 mamBranchHits{0}, mamBranchMisses{0}; uInt32 mamBranchHits{0}, mamBranchMisses{0};
@ -268,7 +268,7 @@ class Thumbulator
const unique_ptr<Op[]> decodedRom; // NOLINT const unique_ptr<Op[]> decodedRom; // NOLINT
const unique_ptr<uInt32[]> decodedParam; // NOLINT const unique_ptr<uInt32[]> decodedParam; // NOLINT
uInt16* ram{nullptr}; uInt16* ram{nullptr};
std::array<uInt32, 16> reg_norm; // normal execution mode, do not have a thread mode std::array<uInt32, 16> reg_norm{}; // normal execution mode, do not have a thread mode
uInt32 znFlags{0}; uInt32 znFlags{0};
uInt32 cFlag{0}; uInt32 cFlag{0};
uInt32 vFlag{0}; uInt32 vFlag{0};

2
src/emucore/elf/ElfLinker.hxx
View File

@ -60,7 +60,7 @@ class ElfLinker {
enum class SegmentType: uInt8 { text, data, rodata }; enum class SegmentType: uInt8 { text, data, rodata };
struct RelocatedSection { struct RelocatedSection {
SegmentType segment; SegmentType segment{};
uInt32 offset{0}; uInt32 offset{0};
}; };

2
src/emucore/tia/AnalogReadout.hxx
View File

@ -88,7 +88,7 @@ class AnalogReadout : public Serializable
Connection myConnection{ConnectionType::disconnected, 0}; Connection myConnection{ConnectionType::disconnected, 0};
uInt64 myTimestamp{0}; uInt64 myTimestamp{0};
ConsoleTiming myConsoleTiming; ConsoleTiming myConsoleTiming{ConsoleTiming::ntsc};
double myClockFreq{0.0}; double myClockFreq{0.0};
bool myIsDumped{false}; bool myIsDumped{false};

4
src/emucore/tia/Audio.hxx
View File

@ -73,8 +73,8 @@ class Audio : public Serializable
uInt32 mySumChannel1{0}; uInt32 mySumChannel1{0};
uInt32 mySumCt{0}; uInt32 mySumCt{0};
std::array<Int16, 0x1e + 1> myMixingTableSum; std::array<Int16, 0x1e + 1> myMixingTableSum{};
std::array<Int16, 0x0f + 1> myMixingTableIndividual; std::array<Int16, 0x0f + 1> myMixingTableIndividual{};
Int16* myCurrentFragment{nullptr}; Int16* myCurrentFragment{nullptr};
uInt32 mySampleIndex{0}; uInt32 mySampleIndex{0};

2
src/emucore/tia/DelayQueue.hxx
View File

@ -53,7 +53,7 @@ class DelayQueue : public Serializable
private: private:
std::array<DelayQueueMember<capacity>, length> myMembers; std::array<DelayQueueMember<capacity>, length> myMembers;
uInt8 myIndex{0}; uInt8 myIndex{0};
std::array<uInt8, 0xFF> myIndices; std::array<uInt8, 0xFF> myIndices{};
private: private:
DelayQueue(const DelayQueue&) = delete; DelayQueue(const DelayQueue&) = delete;

9
src/emucore/tia/DrawCounterDecodes.hxx
View File

@ -37,13 +37,12 @@ class DrawCounterDecodes
private: private:
uInt8* myPlayerDecodes[8]{nullptr}; // TJ: one per NUSIZ number and size uInt8* myPlayerDecodes[8]{}; // TJ: one per NUSIZ number and size
uInt8* myMissileDecodes[8]{}; // TJ: one per NUSIZ number and size
uInt8* myMissileDecodes[8]{nullptr}; // TJ: one per NUSIZ number and size
// TJ: 6 scanline pixel arrays, one for each copy pattern // TJ: 6 scanline pixel arrays, one for each copy pattern
uInt8 myDecodes0[160], myDecodes1[160], myDecodes2[160], myDecodes3[160], uInt8 myDecodes0[160]{}, myDecodes1[160]{}, myDecodes2[160]{},
myDecodes4[160], myDecodes6[160]; myDecodes3[160]{}, myDecodes4[160]{}, myDecodes6[160]{};
static DrawCounterDecodes myInstance; static DrawCounterDecodes myInstance;

22
src/emucore/tia/TIA.hxx
View File

@ -610,8 +610,8 @@ class TIA : public Device
* Palette and indices for fixed debug colors. * Palette and indices for fixed debug colors.
*/ */
enum FixedObject: uInt8 { P0, M0, P1, M1, PF, BL, BK }; enum FixedObject: uInt8 { P0, M0, P1, M1, PF, BL, BK };
BSPF::array2D<FixedColor, 3, 7> myFixedColorPalette; BSPF::array2D<FixedColor, 3, 7> myFixedColorPalette{};
std::array<string, 7> myFixedColorNames; std::array<string, 7> myFixedColorNames{};
private: private:
/** /**
@ -840,12 +840,12 @@ class TIA : public Device
LatchedInput myInput1; LatchedInput myInput1;
// Pointer to the internal color-index-based frame buffer // Pointer to the internal color-index-based frame buffer
std::array<uInt8, static_cast<size_t>(TIAConstants::H_PIXEL * TIAConstants::frameBufferHeight)> myFramebuffer; std::array<uInt8, static_cast<size_t>(TIAConstants::H_PIXEL * TIAConstants::frameBufferHeight)> myFramebuffer{};
// The frame is rendered to the backbuffer and only copied to the framebuffer // The frame is rendered to the backbuffer and only copied to the framebuffer
// upon completion // upon completion
std::array<uInt8, static_cast<size_t>(TIAConstants::H_PIXEL * TIAConstants::frameBufferHeight)> myBackBuffer; std::array<uInt8, static_cast<size_t>(TIAConstants::H_PIXEL * TIAConstants::frameBufferHeight)> myBackBuffer{};
std::array<uInt8, static_cast<size_t>(TIAConstants::H_PIXEL * TIAConstants::frameBufferHeight)> myFrontBuffer; std::array<uInt8, static_cast<size_t>(TIAConstants::H_PIXEL * TIAConstants::frameBufferHeight)> myFrontBuffer{};
// We snapshot frame statistics when the back buffer is copied to the front buffer // We snapshot frame statistics when the back buffer is copied to the front buffer
// and when the front buffer is copied to the frame buffer // and when the front buffer is copied to the frame buffer
@ -971,7 +971,7 @@ class TIA : public Device
* The "shadow registers" track the last written register value for the * The "shadow registers" track the last written register value for the
* debugger. * debugger.
*/ */
std::array<uInt8, 64> myShadowRegisters; std::array<uInt8, 64> myShadowRegisters{};
/** /**
* Indicates if color loss should be enabled or disabled. Color loss * Indicates if color loss should be enabled or disabled. Color loss
@ -991,8 +991,8 @@ class TIA : public Device
bool myAutoPhosphorEnabled{false}; bool myAutoPhosphorEnabled{false};
bool myAutoPhosphorAutoOn{false}; bool myAutoPhosphorAutoOn{false};
bool myAutoPhosphorActive{false}; bool myAutoPhosphorActive{false};
ObjectPos myPosP0, myPosP1, myPosM0, myPosM1, myPosBL; ObjectPos myPosP0{}, myPosP1{}, myPosM0{}, myPosM1{}, myPosBL{};
ObjectGfx myPatPF; ObjectGfx myPatPF{};
int myFlickerFrame{0}, myFlickerCount{0}; int myFlickerFrame{0}, myFlickerCount{0};
uInt32 myFrameEnd{0}; uInt32 myFrameEnd{0};
onPhosphorCallback myPhosphorCallback; onPhosphorCallback myPhosphorCallback;
@ -1024,13 +1024,13 @@ class TIA : public Device
#ifdef DEBUGGER_SUPPORT #ifdef DEBUGGER_SUPPORT
// The arrays containing information about every byte of TIA // The arrays containing information about every byte of TIA
// indicating whether and how (RW) it is used. // indicating whether and how (RW) it is used.
std::array<Device::AccessFlags, TIA_SIZE> myAccessBase; std::array<Device::AccessFlags, TIA_SIZE> myAccessBase{};
// The arrays containing information about every byte of TIA // The arrays containing information about every byte of TIA
// indicating how often it is accessed (read and write). // indicating how often it is accessed (read and write).
std::array<Device::AccessCounter, TIA_SIZE + TIA_READ_SIZE> myAccessCounter; std::array<Device::AccessCounter, TIA_SIZE + TIA_READ_SIZE> myAccessCounter{};
// The array used to skip the first two TIA access trackings // The array used to skip the first two TIA access trackings
std::array<uInt8, TIA_SIZE> myAccessDelay; std::array<uInt8, TIA_SIZE> myAccessDelay{};
#endif // DEBUGGER_SUPPORT #endif // DEBUGGER_SUPPORT
private: private:

2
src/emucore/tia/frame-manager/FrameManager.hxx
View File

@ -26,7 +26,7 @@
class FrameManager: public AbstractFrameManager { class FrameManager: public AbstractFrameManager {
public: public:
enum Metrics : uInt32 { // NOLINT: use 32-bit, even though 16-bit is sufficient enum Metrics: uInt32 { // NOLINT: use 32-bit, even though 16-bit is sufficient
vblankNTSC = 37, vblankNTSC = 37,
vblankPAL = 45, vblankPAL = 45,
vsync = 3, vsync = 3,

4
src/gui/BrowserDialog.cxx
View File

@ -117,9 +117,9 @@ void BrowserDialog::show(GuiObject* parent, const GUI::Font& font,
const Command& command, const Command& command,
const FSNode::NameFilter& namefilter) const FSNode::NameFilter& namefilter)
{ {
uInt32 w, h; uInt32 w = 0, h = 0;
const auto parentDialog = dynamic_cast<Dialog*>(parent); const auto* parentDialog = static_cast<Dialog*>(parent);
if (parentDialog) { if (parentDialog) {
parentDialog->getDynamicBounds(w, h); parentDialog->getDynamicBounds(w, h);
} else { } else {

4
src/gui/EmulationDialog.cxx
View File

@ -65,7 +65,8 @@ namespace {
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
EmulationDialog::EmulationDialog(OSystem& osystem, DialogContainer& parent, EmulationDialog::EmulationDialog(OSystem& osystem, DialogContainer& parent,
const GUI::Font& font, int max_w, int max_h) const GUI::Font& font, int max_w, int max_h)
: Dialog(osystem, parent, font, "Emulation settings") : Dialog(osystem, parent, font, "Emulation settings"),
mySaveOnExitGroup{new RadioButtonGroup()}
{ {
const int lineHeight = Dialog::lineHeight(), const int lineHeight = Dialog::lineHeight(),
fontWidth = Dialog::fontWidth(), fontWidth = Dialog::fontWidth(),
@ -139,7 +140,6 @@ EmulationDialog::EmulationDialog(OSystem& osystem, DialogContainer& parent,
new StaticTextWidget(this, font, HBORDER, ypos + 1, new StaticTextWidget(this, font, HBORDER, ypos + 1,
"When entering/exiting emulation:"); "When entering/exiting emulation:");
ypos += lineHeight + VGAP; ypos += lineHeight + VGAP;
mySaveOnExitGroup = new RadioButtonGroup();
auto* r = new RadioButtonWidget(this, font, xpos, ypos + 1, auto* r = new RadioButtonWidget(this, font, xpos, ypos + 1,
"Do nothing", mySaveOnExitGroup); "Do nothing", mySaveOnExitGroup);
wid.push_back(r); wid.push_back(r);

7
src/gui/LauncherDialog.cxx
View File

@ -68,14 +68,13 @@ LauncherDialog::LauncherDialog(OSystem& osystem, DialogContainer& parent,
int x, int y, int w, int h) int x, int y, int w, int h)
: Dialog(osystem, parent, osystem.frameBuffer().launcherFont(), "", : Dialog(osystem, parent, osystem.frameBuffer().launcherFont(), "",
x, y, w, h), x, y, w, h),
CommandSender(this) CommandSender(this),
myUseMinimalUI{instance().settings().getBool("minimal_ui")}
{ {
const bool bottomButtons = instance().settings().getBool("launcherbuttons"); const bool bottomButtons = instance().settings().getBool("launcherbuttons");
int ypos = Dialog::vBorder(); int ypos = Dialog::vBorder();
myUseMinimalUI = instance().settings().getBool("minimal_ui"); // If minimalUI, show title within dialog surface instead of showing the filtering control
// if minimalUI, show title within dialog surface instead of showing the filtering control
if(myUseMinimalUI) { if(myUseMinimalUI) {
addTitleWidget(ypos); addTitleWidget(ypos);
addPathWidgets(ypos); //-- path widget line will have file count addPathWidgets(ypos); //-- path widget line will have file count

5
src/gui/ListWidget.cxx
View File

@ -28,6 +28,8 @@
ListWidget::ListWidget(GuiObject* boss, const GUI::Font& font, ListWidget::ListWidget(GuiObject* boss, const GUI::Font& font,
int x, int y, int w, int h, bool useScrollbar) int x, int y, int w, int h, bool useScrollbar)
: EditableWidget(boss, font, x, y, 16, 16), : EditableWidget(boss, font, x, y, 16, 16),
_rows{h / _lineHeight},
_cols{w / _fontWidth},
_useScrollbar{useScrollbar} _useScrollbar{useScrollbar}
{ {
_flags = Widget::FLAG_ENABLED | Widget::FLAG_CLEARBG | Widget::FLAG_RETAIN_FOCUS; _flags = Widget::FLAG_ENABLED | Widget::FLAG_CLEARBG | Widget::FLAG_RETAIN_FOCUS;
@ -38,9 +40,6 @@ ListWidget::ListWidget(GuiObject* boss, const GUI::Font& font,
_editMode = false; _editMode = false;
_cols = w / _fontWidth;
_rows = h / _lineHeight;
// Set real dimensions // Set real dimensions
_h = h + 2; _h = h + 2;

4
src/gui/NavigationWidget.cxx
View File

@ -28,11 +28,11 @@
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NavigationWidget::NavigationWidget(GuiObject* boss, const GUI::Font& font, NavigationWidget::NavigationWidget(GuiObject* boss, const GUI::Font& font,
int xpos, int ypos, int w, int h) int xpos, int ypos, int w, int h)
: Widget(boss, font, xpos, ypos, w, h) : Widget(boss, font, xpos, ypos, w, h),
myUseMinimalUI{instance().settings().getBool("minimal_ui")}
{ {
// Add some buttons and textfield to show current directory // Add some buttons and textfield to show current directory
const int lineHeight = _font.getLineHeight(); const int lineHeight = _font.getLineHeight();
myUseMinimalUI = instance().settings().getBool("minimal_ui");
if(!myUseMinimalUI) if(!myUseMinimalUI)
{ {

4
src/gui/RomImageWidget.cxx
View File

@ -32,12 +32,12 @@
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
RomImageWidget::RomImageWidget(GuiObject* boss, const GUI::Font& font, RomImageWidget::RomImageWidget(GuiObject* boss, const GUI::Font& font,
int x, int y, int w, int h) int x, int y, int w, int h)
: Widget(boss, font, x, y, w, h) : Widget(boss, font, x, y, w, h),
myImageHeight{_h - labelHeight(font) - font.getFontHeight() / 4 - 1}
{ {
_flags = Widget::FLAG_ENABLED | Widget::FLAG_TRACK_MOUSE; // | FLAG_WANTS_RAWDATA; _flags = Widget::FLAG_ENABLED | Widget::FLAG_TRACK_MOUSE; // | FLAG_WANTS_RAWDATA;
_bgcolor = kDlgColor; _bgcolor = kDlgColor;
_bgcolorlo = kBGColorLo; _bgcolorlo = kBGColorLo;
myImageHeight = _h - labelHeight(font) - font.getFontHeight() / 4 - 1;
myZoomRect = Common::Rect(_w * 7 / 16, myImageHeight * 7 / 16, myZoomRect = Common::Rect(_w * 7 / 16, myImageHeight * 7 / 16,
_w * 9 / 16, myImageHeight * 9 / 16); _w * 9 / 16, myImageHeight * 9 / 16);

6
src/gui/ScrollBarWidget.cxx
View File

@ -30,14 +30,14 @@
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
ScrollBarWidget::ScrollBarWidget(GuiObject* boss, const GUI::Font& font, ScrollBarWidget::ScrollBarWidget(GuiObject* boss, const GUI::Font& font,
int x, int y, int w, int h) int x, int y, int w, int h)
: Widget(boss, font, x, y, w, h), CommandSender(boss) : Widget(boss, font, x, y, w, h),
CommandSender(boss),
_scrollBarWidth{scrollBarWidth(font)}
{ {
_flags = Widget::FLAG_ENABLED | Widget::FLAG_TRACK_MOUSE | Widget::FLAG_CLEARBG; _flags = Widget::FLAG_ENABLED | Widget::FLAG_TRACK_MOUSE | Widget::FLAG_CLEARBG;
_bgcolor = kWidColor; _bgcolor = kWidColor;
_bgcolorhi = kWidColor; _bgcolorhi = kWidColor;
_scrollBarWidth = scrollBarWidth(font);
setArrows(); setArrows();
} }

3
src/gui/ScrollBarWidget.hxx
View File

@ -36,8 +36,7 @@ class ScrollBarWidget : public Widget, public CommandSender
static void setWheelLines(int lines) { _WHEEL_LINES = lines; } static void setWheelLines(int lines) { _WHEEL_LINES = lines; }
static int getWheelLines() { return _WHEEL_LINES; } static int getWheelLines() { return _WHEEL_LINES; }
static int scrollBarWidth(const GUI::Font& font) static int scrollBarWidth(const GUI::Font& font) {
{
return font.getFontHeight() < 24 ? 15 : 23; return font.getFontHeight() < 24 ? 15 : 23;
} }

5
src/gui/TabWidget.cxx
View File

@ -27,7 +27,8 @@
TabWidget::TabWidget(GuiObject* boss, const GUI::Font& font, TabWidget::TabWidget(GuiObject* boss, const GUI::Font& font,
int x, int y, int w, int h) int x, int y, int w, int h)
: Widget(boss, font, x, y, w, h), : Widget(boss, font, x, y, w, h),
CommandSender(boss) CommandSender(boss),
_tabHeight{font.getLineHeight() + 4}
{ {
_id = 0; // For dialogs with multiple tab widgets, they should specifically _id = 0; // For dialogs with multiple tab widgets, they should specifically
// call ::setID to differentiate among them // call ::setID to differentiate among them
@ -36,8 +37,6 @@ TabWidget::TabWidget(GuiObject* boss, const GUI::Font& font,
_bgcolorhi = kDlgColor; _bgcolorhi = kDlgColor;
_textcolor = kTextColor; _textcolor = kTextColor;
_textcolorhi = kTextColor; _textcolorhi = kTextColor;
_tabHeight = font.getLineHeight() + 4;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

5
src/gui/ToolTip.cxx
View File

@ -27,10 +27,9 @@
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
ToolTip::ToolTip(Dialog& dialog, const GUI::Font& font) ToolTip::ToolTip(Dialog& dialog, const GUI::Font& font)
: myDialog{dialog} : myDialog{dialog},
myScale{myDialog.instance().frameBuffer().hidpiScaleFactor()}
{ {
myScale = myDialog.instance().frameBuffer().hidpiScaleFactor();
setFont(font); setFont(font);
} }

14
src/gui/Widget.cxx
View File

@ -34,14 +34,13 @@ Widget::Widget(GuiObject* boss, const GUI::Font& font,
int x, int y, int w, int h) int x, int y, int w, int h)
: GuiObject(boss->instance(), boss->parent(), boss->dialog(), x, y, w, h), : GuiObject(boss->instance(), boss->parent(), boss->dialog(), x, y, w, h),
_boss{boss}, _boss{boss},
_font{font} _font{font},
_next{_boss->_firstWidget},
_fontWidth{_font.getMaxCharWidth()},
_lineHeight{_font.getLineHeight()}
{ {
// Insert into the widget list of the boss // Insert into the widget list of the boss
_next = _boss->_firstWidget;
_boss->_firstWidget = this; _boss->_firstWidget = this;
_fontWidth = _font.getMaxCharWidth();
_lineHeight = _font.getLineHeight();
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -544,7 +543,6 @@ StaticTextWidget::StaticTextWidget(GuiObject* boss, const GUI::Font& font,
_textcolor = kTextColor; _textcolor = kTextColor;
_textcolorhi = kTextColor; _textcolorhi = kTextColor;
_shadowcolor = shadowColor; _shadowcolor = shadowColor;
_cmd = 0;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -862,14 +860,14 @@ CheckboxWidget::CheckboxWidget(GuiObject* boss, const GUI::Font& font,
int x, int y, string_view label, int x, int y, string_view label,
int cmd) int cmd)
: ButtonWidget(boss, font, x, y, font.getFontHeight() < 24 ? 16 : 24, : ButtonWidget(boss, font, x, y, font.getFontHeight() < 24 ? 16 : 24,
font.getFontHeight() < 24 ? 16 : 24, label, cmd) font.getFontHeight() < 24 ? 16 : 24, label, cmd),
_boxSize{boxSize(font)}
{ {
_flags = Widget::FLAG_ENABLED; _flags = Widget::FLAG_ENABLED;
_bgcolor = _bgcolorhi = kWidColor; _bgcolor = _bgcolorhi = kWidColor;
_bgcolorlo = kDlgColor; _bgcolorlo = kDlgColor;
_editable = true; _editable = true;
_boxSize = boxSize(font);
if(label.empty()) if(label.empty())
_w = _boxSize; _w = _boxSize;

4
src/os/unix/FSNodePOSIX.cxx
View File

@ -56,7 +56,7 @@ FSNodePOSIX::FSNodePOSIX(string_view path, bool verify)
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool FSNodePOSIX::setFlags() bool FSNodePOSIX::setFlags()
{ {
struct stat st; struct stat st{};
if (stat(_path.c_str(), &st) == 0) if (stat(_path.c_str(), &st) == 0)
{ {
_isDirectory = S_ISDIR(st.st_mode); _isDirectory = S_ISDIR(st.st_mode);
@ -102,7 +102,7 @@ size_t FSNodePOSIX::getSize() const
{ {
if (_size == 0 && _isFile) if (_size == 0 && _isFile)
{ {
struct stat st; struct stat st{};
_size = (stat(_path.c_str(), &st) == 0) ? st.st_size : 0; _size = (stat(_path.c_str(), &st) == 0) ? st.st_size : 0;
} }
return _size; return _size;

2
src/os/unix/SerialPortUNIX.cxx
View File

@ -46,7 +46,7 @@ bool SerialPortUNIX::openPort(const string& device)
tcflush(myHandle, TCIFLUSH); tcflush(myHandle, TCIFLUSH);
fcntl(myHandle, F_SETFL, FNDELAY); fcntl(myHandle, F_SETFL, FNDELAY);
struct termios termios; struct termios termios{};
memset(&termios, 0, sizeof(struct termios)); memset(&termios, 0, sizeof(struct termios));
termios.c_cflag = CREAD | CLOCAL; termios.c_cflag = CREAD | CLOCAL;

7
src/tools/TIDY
View File

@ -15,25 +15,19 @@ run-clang-tidy-18 -header-filter=\(.*\.hxx\) \
-cert-dcl37-c,\ -cert-dcl37-c,\
-cert-dcl51-cpp,\ -cert-dcl51-cpp,\
-cert-err58-cpp,\ -cert-err58-cpp,\
-clang-analyzer-core.DivideZero,\
-clang-analyzer-cplusplus.NewDeleteLeaks,\ -clang-analyzer-cplusplus.NewDeleteLeaks,\
-clang-analyzer-optin.performance.Padding,\ -clang-analyzer-optin.performance.Padding,\
-clang-diagnostic-unsafe-buffer-usage,\
-cppcoreguidelines-avoid-c-arrays,\ -cppcoreguidelines-avoid-c-arrays,\
-cppcoreguidelines-avoid-do-while,\ -cppcoreguidelines-avoid-do-while,\
-cppcoreguidelines-avoid-magic-numbers,\ -cppcoreguidelines-avoid-magic-numbers,\
-cppcoreguidelines-avoid-non-const-global-variables,\
-cppcoreguidelines-macro-usage,\ -cppcoreguidelines-macro-usage,\
-cppcoreguidelines-misleading-capture-default-by-value,\
-cppcoreguidelines-narrowing-conversions,\ -cppcoreguidelines-narrowing-conversions,\
-cppcoreguidelines-non-private-member-variables-in-classes,\ -cppcoreguidelines-non-private-member-variables-in-classes,\
-cppcoreguidelines-owning-memory,\ -cppcoreguidelines-owning-memory,\
-cppcoreguidelines-prefer-member-initializer,\
-cppcoreguidelines-pro-bounds-array-to-pointer-decay,\ -cppcoreguidelines-pro-bounds-array-to-pointer-decay,\
-cppcoreguidelines-pro-bounds-constant-array-index,\ -cppcoreguidelines-pro-bounds-constant-array-index,\
-cppcoreguidelines-pro-bounds-pointer-arithmetic,\ -cppcoreguidelines-pro-bounds-pointer-arithmetic,\
-cppcoreguidelines-pro-type-const-cast,\ -cppcoreguidelines-pro-type-const-cast,\
-cppcoreguidelines-pro-type-member-init,\
-cppcoreguidelines-pro-type-reinterpret-cast,\ -cppcoreguidelines-pro-type-reinterpret-cast,\
-cppcoreguidelines-pro-type-static-cast-downcast,\ -cppcoreguidelines-pro-type-static-cast-downcast,\
-cppcoreguidelines-pro-type-vararg,\ -cppcoreguidelines-pro-type-vararg,\
@ -45,7 +39,6 @@ run-clang-tidy-18 -header-filter=\(.*\.hxx\) \
-hicpp-avoid-c-arrays,\ -hicpp-avoid-c-arrays,\
-hicpp-braces-around-statements,\ -hicpp-braces-around-statements,\
-hicpp-explicit-conversions,\ -hicpp-explicit-conversions,\
-hicpp-member-init,\
-hicpp-named-parameter,\ -hicpp-named-parameter,\
-hicpp-no-array-decay,\ -hicpp-no-array-decay,\
-hicpp-signed-bitwise,\ -hicpp-signed-bitwise,\