6502/EightBit
1
0
Fork 0
mirror of https://github.com/MoleskiCoder/EightBit.git synced 2024-12-22 09:30:32 +00:00
Code Issues Projects Releases Wiki Activity

Sort a bunch of missing argument const specifications.

Browse Source 
Signed-off-by: Adrian Conlon <Adrian.conlon@gmail.com>
This commit is contained in:
Adrian Conlon 2018-09-21 00:16:00 +01:00
parent 9e91d2adad
commit 7adefd380a
11 changed files with 73 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

84
MC6809/src/mc6809.cpp
View File

@ -89,20 +89,24 @@ void EightBit::mc6809::handleFIRQ() {
// //
int EightBit::mc6809::execute(uint8_t opcode) { int EightBit::mc6809::execute(const uint8_t opcode) {
lower(BA()); lower(BA());
lower(BS()); lower(BS());
if (UNLIKELY(m_prefix10)) const bool prefixed = m_prefix10 || m_prefix11;
execute10(opcode); const bool unprefixed = !prefixed;
else if (UNLIKELY(m_prefix11)) if (unprefixed) {
execute11(opcode);
else
executeUnprefixed(opcode); executeUnprefixed(opcode);
} else {
if (m_prefix10)
execute10(opcode);
else
execute11(opcode);
}
assert(cycles() > 0); assert(cycles() > 0);
return cycles(); return cycles();
} }
void EightBit::mc6809::executeUnprefixed(uint8_t opcode) { void EightBit::mc6809::executeUnprefixed(const uint8_t opcode) {
assert(!(m_prefix10 || m_prefix11)); assert(!(m_prefix10 || m_prefix11));
assert(cycles() == 0); assert(cycles() == 0);
@ -472,7 +476,7 @@ void EightBit::mc6809::executeUnprefixed(uint8_t opcode) {
} }
} }
void EightBit::mc6809::execute10(uint8_t opcode) { void EightBit::mc6809::execute10(const uint8_t opcode) {
assert(m_prefix10 && !m_prefix11); assert(m_prefix10 && !m_prefix11);
assert(cycles() == 0); assert(cycles() == 0);
@ -543,7 +547,7 @@ void EightBit::mc6809::execute10(uint8_t opcode) {
} }
} }
void EightBit::mc6809::execute11(uint8_t opcode) { void EightBit::mc6809::execute11(const uint8_t opcode) {
assert(!m_prefix10 && m_prefix11); assert(!m_prefix10 && m_prefix11);
assert(cycles() == 0); assert(cycles() == 0);
@ -574,7 +578,7 @@ void EightBit::mc6809::execute11(uint8_t opcode) {
// //
void EightBit::mc6809::push(register16_t& stack, uint8_t value) { void EightBit::mc6809::push(register16_t& stack, const uint8_t value) {
BUS().write(stack--, value); BUS().write(stack--, value);
} }
@ -584,7 +588,7 @@ uint8_t EightBit::mc6809::pop(register16_t& stack) {
// //
EightBit::register16_t& EightBit::mc6809::RR(int which) { EightBit::register16_t& EightBit::mc6809::RR(const int which) {
ASSUME(which >= 0); ASSUME(which >= 0);
ASSUME(which <= 3); ASSUME(which <= 3);
switch (which) { switch (which) {
@ -748,23 +752,23 @@ void EightBit::mc6809::saveEntireRegisterState() {
// //
uint8_t EightBit::mc6809::adc(uint8_t operand, uint8_t data) { uint8_t EightBit::mc6809::adc(const uint8_t operand, const uint8_t data) {
return add(operand, data, carry()); return add(operand, data, carry());
} }
uint8_t EightBit::mc6809::add(uint8_t operand, uint8_t data, int carry) { uint8_t EightBit::mc6809::add(const uint8_t operand, const uint8_t data, const int carry) {
const register16_t addition = operand + data + carry; const register16_t addition = operand + data + carry;
adjustAddition(operand, data, addition); adjustAddition(operand, data, addition);
return addition.low; return addition.low;
} }
EightBit::register16_t EightBit::mc6809::add(register16_t operand, register16_t data) { EightBit::register16_t EightBit::mc6809::add(const register16_t operand, const register16_t data) {
const uint32_t addition = operand.word + data.word; const uint32_t addition = operand.word + data.word;
adjustAddition(operand, data, addition); adjustAddition(operand, data, addition);
return addition & Mask16; return addition & Mask16;
} }
uint8_t EightBit::mc6809::andr(uint8_t operand, uint8_t data) { uint8_t EightBit::mc6809::andr(uint8_t operand, const uint8_t data) {
clearFlag(CC(), VF); clearFlag(CC(), VF);
adjustNZ(operand &= data); adjustNZ(operand &= data);
return operand; return operand;
@ -794,11 +798,11 @@ void EightBit::mc6809::cmp(const uint8_t operand, const uint8_t data) {
sub(operand, data); sub(operand, data);
} }
void EightBit::mc6809::cmp(register16_t operand, register16_t data) { void EightBit::mc6809::cmp(const register16_t operand, const register16_t data) {
sub(operand, data); sub(operand, data);
} }
uint8_t EightBit::mc6809::com(uint8_t operand) { uint8_t EightBit::mc6809::com(const uint8_t operand) {
const uint8_t result = ~operand; const uint8_t result = ~operand;
adjustNZ(result); adjustNZ(result);
clearFlag(CC(), VF); clearFlag(CC(), VF);
@ -806,7 +810,7 @@ uint8_t EightBit::mc6809::com(uint8_t operand) {
return result; return result;
} }
void EightBit::mc6809::cwai(uint8_t data) { void EightBit::mc6809::cwai(const uint8_t data) {
CC() &= data; CC() &= data;
saveEntireRegisterState(); saveEntireRegisterState();
halt(); halt();
@ -830,20 +834,20 @@ uint8_t EightBit::mc6809::da(uint8_t operand) {
return operand; return operand;
} }
uint8_t EightBit::mc6809::dec(uint8_t operand) { uint8_t EightBit::mc6809::dec(const uint8_t operand) {
const uint8_t result = operand - 1; const uint8_t result = operand - 1;
adjustNZ(result); adjustNZ(result);
adjustOverflow(operand, 1, result); adjustOverflow(operand, 1, result);
return result; return result;
} }
uint8_t EightBit::mc6809::eor(uint8_t operand, uint8_t data) { uint8_t EightBit::mc6809::eor(uint8_t operand, const uint8_t data) {
clearFlag(CC(), VF); clearFlag(CC(), VF);
adjustNZ(operand ^= data); adjustNZ(operand ^= data);
return operand; return operand;
} }
uint8_t& EightBit::mc6809::referenceTransfer8(int specifier) { uint8_t& EightBit::mc6809::referenceTransfer8(const int specifier) {
switch (specifier) { switch (specifier) {
case 0b1000: case 0b1000:
return A(); return A();
@ -858,7 +862,7 @@ uint8_t& EightBit::mc6809::referenceTransfer8(int specifier) {
} }
} }
EightBit::register16_t& EightBit::mc6809::referenceTransfer16(int specifier) { EightBit::register16_t& EightBit::mc6809::referenceTransfer16(const int specifier) {
switch (specifier) { switch (specifier) {
case 0b0000: case 0b0000:
return D(); return D();
@ -877,7 +881,7 @@ EightBit::register16_t& EightBit::mc6809::referenceTransfer16(int specifier) {
} }
} }
void EightBit::mc6809::exg(uint8_t data) { void EightBit::mc6809::exg(const uint8_t data) {
const auto reg1 = highNibble(data); const auto reg1 = highNibble(data);
const auto reg2 = lowNibble(data); const auto reg2 = lowNibble(data);
@ -898,17 +902,17 @@ uint8_t EightBit::mc6809::inc(uint8_t operand) {
return result; return result;
} }
void EightBit::mc6809::jsr(register16_t address) { void EightBit::mc6809::jsr(const register16_t address) {
call(address); call(address);
} }
uint8_t EightBit::mc6809::ld(uint8_t data) { uint8_t EightBit::mc6809::ld(const uint8_t data) {
clearFlag(CC(), VF); clearFlag(CC(), VF);
adjustNZ(data); adjustNZ(data);
return data; return data;
} }
EightBit::register16_t EightBit::mc6809::ld(register16_t data) { EightBit::register16_t EightBit::mc6809::ld(const register16_t data) {
clearFlag(CC(), VF); clearFlag(CC(), VF);
adjustNZ(data); adjustNZ(data);
return data; return data;
@ -920,7 +924,7 @@ uint8_t EightBit::mc6809::lsr(uint8_t operand) {
return operand; return operand;
} }
EightBit::register16_t EightBit::mc6809::mul(uint8_t first, uint8_t second) { EightBit::register16_t EightBit::mc6809::mul(const uint8_t first, const uint8_t second) {
const register16_t result = first * second; const register16_t result = first * second;
adjustZero(result); adjustZero(result);
setFlag(CC(), CF, result.low & Bit7); setFlag(CC(), CF, result.low & Bit7);
@ -936,13 +940,13 @@ uint8_t EightBit::mc6809::neg(uint8_t operand) {
return operand; return operand;
} }
uint8_t EightBit::mc6809::orr(uint8_t operand, uint8_t data) { uint8_t EightBit::mc6809::orr(uint8_t operand, const uint8_t data) {
clearFlag(CC(), VF); clearFlag(CC(), VF);
adjustNZ(operand |= data); adjustNZ(operand |= data);
return operand; return operand;
} }
void EightBit::mc6809::pshs(uint8_t data) { void EightBit::mc6809::pshs(const uint8_t data) {
if (data & Bit7) { if (data & Bit7) {
addCycles(2); addCycles(2);
pushWordS(PC()); pushWordS(PC());
@ -977,7 +981,7 @@ void EightBit::mc6809::pshs(uint8_t data) {
} }
} }
void EightBit::mc6809::pshu(uint8_t data) { void EightBit::mc6809::pshu(const uint8_t data) {
if (data & Bit7) { if (data & Bit7) {
addCycles(2); addCycles(2);
pushWordU(PC()); pushWordU(PC());
@ -1012,7 +1016,7 @@ void EightBit::mc6809::pshu(uint8_t data) {
} }
} }
void EightBit::mc6809::puls(uint8_t data) { void EightBit::mc6809::puls(const uint8_t data) {
if (data & Bit0) { if (data & Bit0) {
addCycle(); addCycle();
CC() = popS(); CC() = popS();
@ -1047,7 +1051,7 @@ void EightBit::mc6809::puls(uint8_t data) {
} }
} }
void EightBit::mc6809::pulu(uint8_t data) { void EightBit::mc6809::pulu(const uint8_t data) {
if (data & Bit0) { if (data & Bit0) {
addCycle(); addCycle();
CC() = popU(); CC() = popU();
@ -1135,12 +1139,12 @@ void EightBit::mc6809::swi3() {
jump(getWordPaged(0xff, SWI3vector)); jump(getWordPaged(0xff, SWI3vector));
} }
uint8_t EightBit::mc6809::sex(uint8_t from) { uint8_t EightBit::mc6809::sex(const uint8_t from) {
adjustNZ(from); adjustNZ(from);
return from & Bit7 ? Mask8 : 0; return from & Bit7 ? Mask8 : 0;
} }
void EightBit::mc6809::tfr(uint8_t data) { void EightBit::mc6809::tfr(const uint8_t data) {
const auto reg1 = highNibble(data); const auto reg1 = highNibble(data);
const auto reg2 = lowNibble(data); const auto reg2 = lowNibble(data);
@ -1154,34 +1158,34 @@ void EightBit::mc6809::tfr(uint8_t data) {
referenceTransfer16(reg2) = referenceTransfer16(reg1); referenceTransfer16(reg2) = referenceTransfer16(reg1);
} }
uint8_t EightBit::mc6809::st(uint8_t data) { uint8_t EightBit::mc6809::st(const uint8_t data) {
clearFlag(CC(), VF); clearFlag(CC(), VF);
adjustNZ(data); adjustNZ(data);
return data; return data;
} }
EightBit::register16_t EightBit::mc6809::st(register16_t data) { EightBit::register16_t EightBit::mc6809::st(const register16_t data) {
clearFlag(CC(), VF); clearFlag(CC(), VF);
adjustNZ(data); adjustNZ(data);
return data; return data;
} }
uint8_t EightBit::mc6809::sbc(uint8_t operand, uint8_t data) { uint8_t EightBit::mc6809::sbc(const uint8_t operand, const uint8_t data) {
return sub(operand, data, carry()); return sub(operand, data, carry());
} }
uint8_t EightBit::mc6809::sub(uint8_t operand, uint8_t data, int carry) { uint8_t EightBit::mc6809::sub(const uint8_t operand, const uint8_t data, const int carry) {
const register16_t subtraction = operand - data - carry; const register16_t subtraction = operand - data - carry;
adjustSubtraction(operand, data, subtraction); adjustSubtraction(operand, data, subtraction);
return subtraction.low; return subtraction.low;
} }
EightBit::register16_t EightBit::mc6809::sub(register16_t operand, register16_t data) { EightBit::register16_t EightBit::mc6809::sub(const register16_t operand, const register16_t data) {
const uint32_t subtraction = operand.word - data.word; const uint32_t subtraction = operand.word - data.word;
adjustSubtraction(operand, data, subtraction); adjustSubtraction(operand, data, subtraction);
return subtraction & Mask16; return subtraction & Mask16;
} }
void EightBit::mc6809::tst(uint8_t data) { void EightBit::mc6809::tst(const uint8_t data) {
cmp(data, 0); cmp(data, 0);
} }

4
Z80/src/Z80.cpp
View File

@ -474,7 +474,7 @@ void EightBit::Z80::xhtl() {
HL2().high = MEMPTR().high; HL2().high = MEMPTR().high;
} }
void EightBit::Z80::blockCompare(register16_t source, register16_t& counter) { void EightBit::Z80::blockCompare(const register16_t source, register16_t& counter) {
const auto value = BUS().read(source); const auto value = BUS().read(source);
uint8_t result = A() - value; uint8_t result = A() - value;
@ -539,7 +539,7 @@ bool EightBit::Z80::lddr() {
return !!(F() & PF); // See LDD return !!(F() & PF); // See LDD
} }
void EightBit::Z80::blockIn(register16_t& source, register16_t destination) { void EightBit::Z80::blockIn(register16_t& source, const register16_t destination) {
MEMPTR() = BUS().ADDRESS() = source; MEMPTR() = BUS().ADDRESS() = source;
const auto value = readPort(); const auto value = readPort();
BUS().write(destination, value); BUS().write(destination, value);

12
inc/Bus.h
View File

@ -28,11 +28,11 @@ namespace EightBit {
uint8_t& DATA() { return m_data; } uint8_t& DATA() { return m_data; }
uint8_t peek() { return reference(); } uint8_t peek() { return reference(); }
uint8_t peek(uint16_t address) { return reference(address); } uint8_t peek(const uint16_t address) { return reference(address); }
uint8_t peek(register16_t address) { return reference(address.word); } uint8_t peek(const register16_t address) { return reference(address.word); }
void poke(uint8_t value) { reference() = value; } void poke(const uint8_t value) { reference() = value; }
void poke(uint16_t address, uint8_t value) { reference(address) = value; } void poke(const uint16_t address, const uint8_t value) { reference(address) = value; }
void poke(register16_t address, uint8_t value) { reference(address.word) = value; } void poke(const register16_t address, const uint8_t value) { reference(address.word) = value; }
uint8_t read(); uint8_t read();
template<class T> uint8_t read(const T address) { template<class T> uint8_t read(const T address) {
@ -50,7 +50,7 @@ namespace EightBit {
protected: protected:
virtual MemoryMapping mapping(uint16_t address) = 0; virtual MemoryMapping mapping(uint16_t address) = 0;
uint8_t& reference(uint16_t address); uint8_t& reference(uint16_t address);
uint8_t& reference(register16_t address) { return reference(address.word); } uint8_t& reference(const register16_t address) { return reference(address.word); }
uint8_t& reference() { return reference(ADDRESS()); } uint8_t& reference() { return reference(ADDRESS()); }
static std::map<uint16_t, std::vector<uint8_t>> parseHexFile(std::string path); static std::map<uint16_t, std::vector<uint8_t>> parseHexFile(std::string path);

8
inc/EightBitCompilerDefinitions.h
View File

@ -15,7 +15,7 @@ namespace EightBit {
void assume(int expression); void assume(int expression);
} }
inline int EightBit::countBits(uint8_t value) { inline int EightBit::countBits(const uint8_t value) {
#ifdef _MSC_VER #ifdef _MSC_VER
return __popcnt(value); return __popcnt(value);
#else #else
@ -35,11 +35,11 @@ inline int EightBit::countBits(uint8_t value) {
#endif #endif
} }
inline bool EightBit::oddParity(uint8_t value) { inline bool EightBit::oddParity(const uint8_t value) {
return countBits(value) % 2; return countBits(value) % 2;
} }
inline int EightBit::findFirstSet(int value) { inline int EightBit::findFirstSet(const int value) {
#ifdef _MSC_VER #ifdef _MSC_VER
unsigned long index; unsigned long index;
if (_BitScanForward(&index, value)) if (_BitScanForward(&index, value))
@ -52,7 +52,7 @@ inline int EightBit::findFirstSet(int value) {
#endif #endif
} }
inline void EightBit::assume(int expression) { inline void EightBit::assume(const int expression) {
#ifdef _MSC_VER #ifdef _MSC_VER
__assume(expression); __assume(expression);
#elif defined(__GNUG__) #elif defined(__GNUG__)

8
inc/Processor.h
View File

@ -117,11 +117,11 @@ namespace EightBit {
virtual void handleINT(); virtual void handleINT();
virtual void handleIRQ(); virtual void handleIRQ();
uint8_t getBytePaged(uint8_t page, uint8_t offset) { uint8_t getBytePaged(const uint8_t page, const uint8_t offset) {
return BUS().read(register16_t(offset, page)); return BUS().read(register16_t(offset, page));
} }
void setBytePaged(uint8_t page, uint8_t offset, uint8_t value) { void setBytePaged(const uint8_t page, const uint8_t offset, const uint8_t value) {
BUS().write(register16_t(offset, page), value); BUS().write(register16_t(offset, page), value);
} }
@ -143,12 +143,12 @@ namespace EightBit {
virtual void pushWord(const register16_t value) = 0; virtual void pushWord(const register16_t value) = 0;
virtual register16_t popWord() = 0; virtual register16_t popWord() = 0;
register16_t getWord(register16_t address) { register16_t getWord(const register16_t address) {
BUS().ADDRESS() = address; BUS().ADDRESS() = address;
return getWord(); return getWord();
} }
void setWord(register16_t address, register16_t value) { void setWord(const register16_t address, const register16_t value) {
BUS().ADDRESS() = address; BUS().ADDRESS() = address;
return setWord(value); return setWord(value);
} }

2
inc/Ram.h
View File

@ -14,7 +14,7 @@ namespace EightBit {
return BYTES()[address]; return BYTES()[address];
} }
void poke(uint16_t address, uint8_t value) { void poke(const uint16_t address, const uint8_t value) {
Memory::poke(address, value); Memory::poke(address, value);
} }
}; };

10
inc/Register.h
View File

@ -33,8 +33,8 @@ namespace EightBit {
}; };
uint16_t word; uint16_t word;
register16_t() noexcept : word(0) {} register16_t() noexcept : word(0) {}
register16_t(uint16_t w) noexcept : word(w) {} register16_t(const uint16_t w) noexcept : word(w) {}
register16_t(uint8_t l, uint8_t h) noexcept : low(l), high(h) {} register16_t(const uint8_t l, const uint8_t h) noexcept : low(l), high(h) {}
register16_t& operator++() noexcept { register16_t& operator++() noexcept {
++word; ++word;
@ -69,11 +69,11 @@ namespace EightBit {
} }
}; };
inline bool operator==(register16_t lhs, const register16_t rhs) noexcept { inline bool operator==(const register16_t lhs, const register16_t rhs) noexcept {
return lhs.word == rhs.word; return lhs.word == rhs.word;
} }
inline bool operator!=(register16_t lhs, const register16_t rhs) noexcept { inline bool operator!=(const register16_t lhs, const register16_t rhs) noexcept {
return !(lhs == rhs); return !(lhs == rhs);
} }
@ -87,7 +87,7 @@ namespace EightBit {
return lhs; return lhs;
} }
inline std::ostream& operator<<(std::ostream& output, register16_t value) { inline std::ostream& operator<<(std::ostream& output, const register16_t value) {
return output << std::hex << std::setw(4) << std::setfill('0') << value.word; return output << std::hex << std::setw(4) << std::setfill('0') << value.word;
} }
} }

4
src/BigEndianProcessor.cpp
View File

@ -17,14 +17,14 @@ void EightBit::BigEndianProcessor::setWord(const register16_t value) {
BUS().write(value.low); BUS().write(value.low);
} }
EightBit::register16_t EightBit::BigEndianProcessor::getWordPaged(uint8_t page, uint8_t offset) { EightBit::register16_t EightBit::BigEndianProcessor::getWordPaged(const uint8_t page, const uint8_t offset) {
const auto high = getBytePaged(page, offset); const auto high = getBytePaged(page, offset);
++BUS().ADDRESS().low; ++BUS().ADDRESS().low;
const auto low = BUS().read(); const auto low = BUS().read();
return register16_t(low, high); return register16_t(low, high);
} }
void EightBit::BigEndianProcessor::setWordPaged(uint8_t page, uint8_t offset, register16_t value) { void EightBit::BigEndianProcessor::setWordPaged(const uint8_t page, const uint8_t offset, const register16_t value) {
setBytePaged(page, offset, value.high); setBytePaged(page, offset, value.high);
++BUS().ADDRESS().low; ++BUS().ADDRESS().low;
BUS().read(value.low); BUS().read(value.low);

2
src/Bus.cpp
View File

@ -88,7 +88,7 @@ std::map<uint16_t, std::vector<uint8_t>> EightBit::Bus::parseHexFile(const std::
return returned; return returned;
} }
uint8_t& EightBit::Bus::reference(uint16_t address) { uint8_t& EightBit::Bus::reference(const uint16_t address) {
const auto mapped = mapping(address); const auto mapped = mapping(address);
const uint16_t offset = address - mapped.begin; const uint16_t offset = address - mapped.begin;
if (mapped.access == MemoryMapping::ReadOnly) if (mapped.access == MemoryMapping::ReadOnly)

4
src/LittleEndianProcessor.cpp
View File

@ -17,14 +17,14 @@ void EightBit::LittleEndianProcessor::setWord(const register16_t value) {
BUS().write(value.high); BUS().write(value.high);
} }
EightBit::register16_t EightBit::LittleEndianProcessor::getWordPaged(uint8_t page, uint8_t offset) { EightBit::register16_t EightBit::LittleEndianProcessor::getWordPaged(const uint8_t page, const uint8_t offset) {
const auto low = getBytePaged(page, offset); const auto low = getBytePaged(page, offset);
++BUS().ADDRESS().low; ++BUS().ADDRESS().low;
const auto high = BUS().read(); const auto high = BUS().read();
return register16_t(low, high); return register16_t(low, high);
} }
void EightBit::LittleEndianProcessor::setWordPaged(uint8_t page, uint8_t offset, register16_t value) { void EightBit::LittleEndianProcessor::setWordPaged(const uint8_t page, const uint8_t offset, const register16_t value) {
setBytePaged(page, offset, value.low); setBytePaged(page, offset, value.low);
++BUS().ADDRESS().low; ++BUS().ADDRESS().low;
BUS().read(value.high); BUS().read(value.high);

4
src/Processor.cpp
View File

@ -27,13 +27,13 @@ void EightBit::Processor::handleIRQ() {
int EightBit::Processor::run(const int limit) { int EightBit::Processor::run(const int limit) {
int current = 0; int current = 0;
while (LIKELY(powered()) && current < limit) while (LIKELY(powered() && (current < limit)))
current += step(); current += step();
return current; return current;
} }
// http://graphics.stanford.edu/~seander/bithacks.html#FixedSignExtend // http://graphics.stanford.edu/~seander/bithacks.html#FixedSignExtend
int8_t EightBit::Processor::signExtend(int b, uint8_t x) { int8_t EightBit::Processor::signExtend(const int b, uint8_t x) {
const uint8_t m = 1 << (b - 1); // mask can be pre-computed if b is fixed const uint8_t m = 1 << (b - 1); // mask can be pre-computed if b is fixed
x = x & ((1 << b) - 1); // (Skip this if bits in x above position b are already zero.) x = x & ((1 << b) - 1); // (Skip this if bits in x above position b are already zero.)
const auto result = (x ^ m) - m; const auto result = (x ^ m) - m;