mirror of
https://github.com/TomHarte/CLK.git
synced 2024-06-09 01:29:44 +00:00
Converts all uint8_t and uint16_t casts to the functional style.
This commit is contained in:
Thomas Harte
parent
ec999446e8
commit
e983854e71
|
|
@ -73,7 +73,7 @@ class Pitfall2: public BusExtender {
|
|||
mask_[address & 7] = 0x00;
|
||||
break;
|
||||
case 0x1058: case 0x1059: case 0x105a: case 0x105b: case 0x105c: case 0x105d: case 0x105e: case 0x105f:
|
||||
featcher_address_[address & 7] = (featcher_address_[address & 7] & 0x00ff) | (uint16_t)(*value << 8);
|
||||
featcher_address_[address & 7] = (featcher_address_[address & 7] & 0x00ff) | static_cast<uint16_t>(*value << 8);
|
||||
break;
|
||||
case 0x1070: case 0x1071: case 0x1072: case 0x1073: case 0x1074: case 0x1075: case 0x1076: case 0x1077:
|
||||
random_number_generator_ = 0;
|
||||
|
|
|
|||
|
|
@ -117,7 +117,7 @@ void MachineBase::process_input_bit(int value) {
|
|||
}
|
||||
bit_window_offset_++;
|
||||
if(bit_window_offset_ == 8) {
|
||||
drive_VIA_port_handler_.set_data_input((uint8_t)shift_register_);
|
||||
drive_VIA_port_handler_.set_data_input(static_cast<uint8_t>(shift_register_));
|
||||
bit_window_offset_ = 0;
|
||||
if(drive_VIA_port_handler_.get_should_set_overflow()) {
|
||||
m6502_.set_overflow_line(true);
|
||||
|
|
|
|||
|
|
@ -357,7 +357,7 @@ class ConcreteMachine:
|
|||
if(!media.cartridges.empty()) {
|
||||
rom_address_ = 0xa000;
|
||||
std::vector<uint8_t> rom_image = media.cartridges.front()->get_segments().front().data;
|
||||
rom_length_ = (uint16_t)(rom_image.size());
|
||||
rom_length_ = static_cast<uint16_t>(rom_image.size());
|
||||
|
||||
rom_ = new uint8_t[0x2000];
|
||||
memcpy(rom_, rom_image.data(), rom_image.size());
|
||||
|
|
@ -467,7 +467,7 @@ class ConcreteMachine:
|
|||
std::unique_ptr<Storage::Tape::Commodore::Header> header = parser.get_next_header(tape_->get_tape());
|
||||
|
||||
// serialise to wherever b2:b3 points
|
||||
uint16_t tape_buffer_pointer = (uint16_t)user_basic_memory_[0xb2] | (uint16_t)(user_basic_memory_[0xb3] << 8);
|
||||
uint16_t tape_buffer_pointer = static_cast<uint16_t>(user_basic_memory_[0xb2]) | static_cast<uint16_t>(user_basic_memory_[0xb3] << 8);
|
||||
if(header) {
|
||||
header->serialise(&user_basic_memory_[tape_buffer_pointer], 0x8000 - tape_buffer_pointer);
|
||||
} else {
|
||||
|
|
@ -481,13 +481,13 @@ class ConcreteMachine:
|
|||
|
||||
*value = 0x0c; // i.e. NOP abs
|
||||
} else if(address == 0xf90b) {
|
||||
uint8_t x = (uint8_t)m6502_.get_value_of_register(CPU::MOS6502::Register::X);
|
||||
uint8_t x = static_cast<uint8_t>(m6502_.get_value_of_register(CPU::MOS6502::Register::X));
|
||||
if(x == 0xe) {
|
||||
Storage::Tape::Commodore::Parser parser;
|
||||
std::unique_ptr<Storage::Tape::Commodore::Data> data = parser.get_next_data(tape_->get_tape());
|
||||
uint16_t start_address, end_address;
|
||||
start_address = (uint16_t)(user_basic_memory_[0xc1] | (user_basic_memory_[0xc2] << 8));
|
||||
end_address = (uint16_t)(user_basic_memory_[0xae] | (user_basic_memory_[0xaf] << 8));
|
||||
start_address = static_cast<uint16_t>(user_basic_memory_[0xc1] | (user_basic_memory_[0xc2] << 8));
|
||||
end_address = static_cast<uint16_t>(user_basic_memory_[0xae] | (user_basic_memory_[0xaf] << 8));
|
||||
|
||||
// perform a via-processor_write_memory_map_ memcpy
|
||||
uint8_t *data_ptr = data->data.data();
|
||||
|
|
@ -502,8 +502,8 @@ class ConcreteMachine:
|
|||
|
||||
// set tape status, carry and flag
|
||||
user_basic_memory_[0x90] |= 0x40;
|
||||
uint8_t flags = (uint8_t)m6502_.get_value_of_register(CPU::MOS6502::Register::Flags);
|
||||
flags &= ~(uint8_t)(CPU::MOS6502::Flag::Carry | CPU::MOS6502::Flag::Interrupt);
|
||||
uint8_t flags = static_cast<uint8_t>(m6502_.get_value_of_register(CPU::MOS6502::Register::Flags));
|
||||
flags &= ~static_cast<uint8_t>((CPU::MOS6502::Flag::Carry | CPU::MOS6502::Flag::Interrupt));
|
||||
m6502_.set_value_of_register(CPU::MOS6502::Register::Flags, flags);
|
||||
|
||||
// to ensure that execution proceeds to 0xfccf, pretend a NOP was here and
|
||||
|
|
|
|||
|
|
@ -257,7 +257,7 @@ class ConcreteMachine:
|
|||
// allow the PC read to return an RTS.
|
||||
)
|
||||
) {
|
||||
uint8_t service_call = (uint8_t)m6502_.get_value_of_register(CPU::MOS6502::Register::X);
|
||||
uint8_t service_call = static_cast<uint8_t>(m6502_.get_value_of_register(CPU::MOS6502::Register::X));
|
||||
if(address == 0xf0a8) {
|
||||
if(!ram_[0x247] && service_call == 14) {
|
||||
tape_.set_delegate(nullptr);
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ using namespace Electron;
|
|||
void Speaker::get_samples(unsigned int number_of_samples, int16_t *target) {
|
||||
if(is_enabled_) {
|
||||
while(number_of_samples--) {
|
||||
*target = (int16_t)((counter_ / (divider_+1)) * 8192);
|
||||
*target = static_cast<int16_t>((counter_ / (divider_+1)) * 8192);
|
||||
target++;
|
||||
counter_ = (counter_ + 1) % ((divider_+1) * 2);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@ Tape::Tape() : TapePlayer(2000000) {
|
|||
}
|
||||
|
||||
void Tape::push_tape_bit(uint16_t bit) {
|
||||
data_register_ = (uint16_t)((data_register_ >> 1) | (bit << 10));
|
||||
data_register_ = static_cast<uint16_t>((data_register_ >> 1) | (bit << 10));
|
||||
|
||||
if(input_.minimum_bits_until_full) input_.minimum_bits_until_full--;
|
||||
if(input_.minimum_bits_until_full == 8) interrupt_status_ &= ~Interrupt::ReceiveDataFull;
|
||||
|
|
@ -57,12 +57,12 @@ void Tape::set_counter(uint8_t value) {
|
|||
}
|
||||
|
||||
void Tape::set_data_register(uint8_t value) {
|
||||
data_register_ = (uint16_t)((value << 2) | 1);
|
||||
data_register_ = static_cast<uint16_t>((value << 2) | 1);
|
||||
output_.bits_remaining_until_empty = 9;
|
||||
}
|
||||
|
||||
uint8_t Tape::get_data_register() {
|
||||
return (uint8_t)(data_register_ >> 2);
|
||||
return static_cast<uint8_t>(data_register_ >> 2);
|
||||
}
|
||||
|
||||
void Tape::process_input_pulse(const Storage::Tape::Tape::Pulse &pulse) {
|
||||
|
|
@ -70,7 +70,7 @@ void Tape::process_input_pulse(const Storage::Tape::Tape::Pulse &pulse) {
|
|||
}
|
||||
|
||||
void Tape::acorn_shifter_output_bit(int value) {
|
||||
push_tape_bit((uint16_t)value);
|
||||
push_tape_bit(static_cast<uint16_t>(value));
|
||||
}
|
||||
|
||||
void Tape::run_for(const Cycles cycles) {
|
||||
|
|
|
|||
|
|
@ -246,11 +246,11 @@ void VideoOutput::run_for(const Cycles cycles) {
|
|||
void VideoOutput::set_register(int address, uint8_t value) {
|
||||
switch(address & 0xf) {
|
||||
case 0x02:
|
||||
start_screen_address_ = (start_screen_address_ & 0xfe00) | (uint16_t)((value & 0xe0) << 1);
|
||||
start_screen_address_ = (start_screen_address_ & 0xfe00) | static_cast<uint16_t>((value & 0xe0) << 1);
|
||||
if(!start_screen_address_) start_screen_address_ |= 0x8000;
|
||||
break;
|
||||
case 0x03:
|
||||
start_screen_address_ = (start_screen_address_ & 0x01ff) | (uint16_t)((value & 0x3f) << 9);
|
||||
start_screen_address_ = (start_screen_address_ & 0x01ff) | static_cast<uint16_t>((value & 0x3f) << 9);
|
||||
if(!start_screen_address_) start_screen_address_ |= 0x8000;
|
||||
break;
|
||||
case 0x07: {
|
||||
|
|
@ -292,7 +292,7 @@ void VideoOutput::set_register(int address, uint8_t value) {
|
|||
}
|
||||
|
||||
// regenerate all palette tables for now
|
||||
#define pack(a, b) (uint8_t)((a << 4) | (b))
|
||||
#define pack(a, b) static_cast<uint8_t>((a << 4) | (b))
|
||||
for(int byte = 0; byte < 256; byte++) {
|
||||
uint8_t *target = (uint8_t *)&palette_tables_.forty1bpp[byte];
|
||||
target[0] = pack(palette_[(byte&0x80) >> 4], palette_[(byte&0x40) >> 3]);
|
||||
|
|
|
|||
|
|
@ -87,7 +87,7 @@ class TapePlayer: public Storage::Tape::BinaryTapePlayer {
|
|||
@returns The next byte from the tape.
|
||||
*/
|
||||
uint8_t get_next_byte(bool use_fast_encoding) {
|
||||
return (uint8_t)parser_.get_next_byte(get_tape(), use_fast_encoding);
|
||||
return static_cast<uint8_t>(parser_.get_next_byte(get_tape(), use_fast_encoding));
|
||||
}
|
||||
|
||||
private:
|
||||
|
|
|
|||
|
|
@ -56,7 +56,7 @@ void VideoOutput::set_output_device(Outputs::CRT::OutputDevice output_device) {
|
|||
void VideoOutput::set_colour_rom(const std::vector<uint8_t> &rom) {
|
||||
for(size_t c = 0; c < 8; c++) {
|
||||
size_t index = (c << 2);
|
||||
uint16_t rom_value = (uint16_t)(((uint16_t)rom[index] << 8) | (uint16_t)rom[index+1]);
|
||||
uint16_t rom_value = static_cast<uint16_t>((static_cast<uint16_t>(rom[index]) << 8) | static_cast<uint16_t>(rom[index+1]));
|
||||
rom_value = (rom_value & 0xff00) | ((rom_value >> 4)&0x000f) | ((rom_value << 4)&0x00f0);
|
||||
colour_forms_[c] = rom_value;
|
||||
}
|
||||
|
|
@ -65,7 +65,7 @@ void VideoOutput::set_colour_rom(const std::vector<uint8_t> &rom) {
|
|||
uint16_t test_value = 0x0001;
|
||||
if(*(uint8_t *)&test_value != 0x01) {
|
||||
for(size_t c = 0; c < 8; c++) {
|
||||
colour_forms_[c] = (uint16_t)((colour_forms_[c] >> 8) | (colour_forms_[c] << 8));
|
||||
colour_forms_[c] = static_cast<uint16_t>((colour_forms_[c] >> 8) | (colour_forms_[c] << 8));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -133,8 +133,8 @@ void VideoOutput::run_for(const Cycles cycles) {
|
|||
if(pixel_target_) {
|
||||
uint16_t colours[2];
|
||||
if(output_device_ == Outputs::CRT::Monitor) {
|
||||
colours[0] = (uint8_t)(paper_ ^ inverse_mask);
|
||||
colours[1] = (uint8_t)(ink_ ^ inverse_mask);
|
||||
colours[0] = static_cast<uint8_t>(paper_ ^ inverse_mask);
|
||||
colours[1] = static_cast<uint8_t>(ink_ ^ inverse_mask);
|
||||
} else {
|
||||
colours[0] = colour_forms_[paper_ ^ inverse_mask];
|
||||
colours[1] = colour_forms_[ink_ ^ inverse_mask];
|
||||
|
|
|
|||
|
|
@ -155,7 +155,7 @@ template<bool is_zx81> class ConcreteMachine:
|
|||
int next_byte = parser_.get_next_byte(tape_player_.get_tape());
|
||||
if(next_byte != -1) {
|
||||
uint16_t hl = z80_.get_value_of_register(CPU::Z80::Register::HL);
|
||||
ram_[hl & ram_mask_] = (uint8_t)next_byte;
|
||||
ram_[hl & ram_mask_] = static_cast<uint8_t>(next_byte);
|
||||
*cycle.value = 0x00;
|
||||
z80_.set_value_of_register(CPU::Z80::Register::ProgramCounter, tape_return_address_ - 1);
|
||||
|
||||
|
|
@ -249,7 +249,7 @@ template<bool is_zx81> class ConcreteMachine:
|
|||
automatic_tape_motor_start_address_ = 0x0206;
|
||||
automatic_tape_motor_end_address_ = 0x024d;
|
||||
}
|
||||
rom_mask_ = (uint16_t)(rom_.size() - 1);
|
||||
rom_mask_ = static_cast<uint16_t>(rom_.size() - 1);
|
||||
|
||||
switch(target.zx8081.memory_model) {
|
||||
case StaticAnalyser::ZX8081MemoryModel::Unexpanded:
|
||||
|
|
@ -301,9 +301,9 @@ template<bool is_zx81> class ConcreteMachine:
|
|||
|
||||
void set_key_state(uint16_t key, bool isPressed) override final {
|
||||
if(isPressed)
|
||||
key_states_[key >> 8] &= (uint8_t)(~key);
|
||||
key_states_[key >> 8] &= static_cast<uint8_t>(~key);
|
||||
else
|
||||
key_states_[key >> 8] |= (uint8_t)key;
|
||||
key_states_[key >> 8] |= static_cast<uint8_t>(key);
|
||||
}
|
||||
|
||||
void clear_all_keys() override final {
|
||||
|
|
|
|||
|
|
@ -23,12 +23,12 @@ class CRC16 {
|
|||
CRC16(uint16_t polynomial, uint16_t reset_value) :
|
||||
reset_value_(reset_value), value_(reset_value) {
|
||||
for(int c = 0; c < 256; c++) {
|
||||
uint16_t shift_value = (uint16_t)(c << 8);
|
||||
uint16_t shift_value = static_cast<uint16_t>(c << 8);
|
||||
for(int b = 0; b < 8; b++) {
|
||||
uint16_t exclusive_or = (shift_value&0x8000) ? polynomial : 0x0000;
|
||||
shift_value = (uint16_t)(shift_value << 1) ^ exclusive_or;
|
||||
shift_value = static_cast<uint16_t>(shift_value << 1) ^ exclusive_or;
|
||||
}
|
||||
xor_table[c] = (uint16_t)shift_value;
|
||||
xor_table[c] = static_cast<uint16_t>(shift_value);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -37,7 +37,7 @@ class CRC16 {
|
|||
|
||||
/// Updates the CRC to include @c byte.
|
||||
inline void add(uint8_t byte) {
|
||||
value_ = (uint16_t)((value_ << 8) ^ xor_table[(value_ >> 8) ^ byte]);
|
||||
value_ = static_cast<uint16_t>((value_ << 8) ^ xor_table[(value_ >> 8) ^ byte]);
|
||||
}
|
||||
|
||||
/// @returns The current value of the CRC.
|
||||
|
|
|
|||
|
|
@ -72,11 +72,13 @@
|
|||
buildConfiguration = "Debug"
|
||||
selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
|
||||
selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
|
||||
enableUBSanitizer = "YES"
|
||||
language = ""
|
||||
launchStyle = "0"
|
||||
useCustomWorkingDirectory = "NO"
|
||||
ignoresPersistentStateOnLaunch = "NO"
|
||||
debugDocumentVersioning = "YES"
|
||||
stopOnEveryUBSanitizerIssue = "YES"
|
||||
debugServiceExtension = "internal"
|
||||
allowLocationSimulation = "NO">
|
||||
<BuildableProductRunnable
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ void CRT::set_new_timing(unsigned int cycles_per_line, unsigned int height_of_di
|
|||
|
||||
// figure out the divisor necessary to get the horizontal flywheel into a 16-bit range
|
||||
unsigned int real_clock_scan_period = (multiplied_cycles_per_line * height_of_display) / (time_multiplier_ * common_output_divisor_);
|
||||
vertical_flywheel_output_divider_ = (uint16_t)(ceilf(real_clock_scan_period / 65536.0f) * (time_multiplier_ * common_output_divisor_));
|
||||
vertical_flywheel_output_divider_ = static_cast<uint16_t>(ceilf(real_clock_scan_period / 65536.0f) * (time_multiplier_ * common_output_divisor_));
|
||||
|
||||
openGL_output_builder_.set_timing(cycles_per_line, multiplied_cycles_per_line, height_of_display, horizontal_flywheel_->get_scan_period(), vertical_flywheel_->get_scan_period(), vertical_flywheel_output_divider_);
|
||||
}
|
||||
|
|
@ -68,7 +68,7 @@ void CRT::set_new_display_type(unsigned int cycles_per_line, DisplayType display
|
|||
|
||||
void CRT::set_composite_function_type(CompositeSourceType type, float offset_of_first_sample) {
|
||||
if(type == DiscreteFourSamplesPerCycle) {
|
||||
colour_burst_phase_adjustment_ = (uint8_t)(offset_of_first_sample * 256.0f) & 63;
|
||||
colour_burst_phase_adjustment_ = static_cast<uint8_t>(offset_of_first_sample * 256.0f) & 63;
|
||||
} else {
|
||||
colour_burst_phase_adjustment_ = 0xff;
|
||||
}
|
||||
|
|
@ -170,7 +170,7 @@ void CRT::advance_cycles(unsigned int number_of_cycles, bool hsync_requested, bo
|
|||
if(next_run) {
|
||||
// output_y and texture locations will be written later; we won't necessarily know what they are
|
||||
// outside of the locked region
|
||||
source_output_position_x1() = (uint16_t)horizontal_flywheel_->get_current_output_position();
|
||||
source_output_position_x1() = static_cast<uint16_t>(horizontal_flywheel_->get_current_output_position());
|
||||
source_phase() = colour_burst_phase_;
|
||||
source_amplitude() = colour_burst_amplitude_;
|
||||
}
|
||||
|
|
@ -184,7 +184,7 @@ void CRT::advance_cycles(unsigned int number_of_cycles, bool hsync_requested, bo
|
|||
vertical_flywheel_->apply_event(next_run_length, (next_run_length == time_until_vertical_sync_event) ? next_vertical_sync_event : Flywheel::SyncEvent::None);
|
||||
|
||||
if(next_run) {
|
||||
source_output_position_x2() = (uint16_t)horizontal_flywheel_->get_current_output_position();
|
||||
source_output_position_x2() = static_cast<uint16_t>(horizontal_flywheel_->get_current_output_position());
|
||||
}
|
||||
|
||||
// if this is horizontal retrace then advance the output line counter and bookend an output run
|
||||
|
|
@ -203,8 +203,8 @@ void CRT::advance_cycles(unsigned int number_of_cycles, bool hsync_requested, bo
|
|||
!openGL_output_builder_.composite_output_buffer_is_full()) {
|
||||
|
||||
if(!is_writing_composite_run_) {
|
||||
output_run_.x1 = (uint16_t)horizontal_flywheel_->get_current_output_position();
|
||||
output_run_.y = (uint16_t)(vertical_flywheel_->get_current_output_position() / vertical_flywheel_output_divider_);
|
||||
output_run_.x1 = static_cast<uint16_t>(horizontal_flywheel_->get_current_output_position());
|
||||
output_run_.y = static_cast<uint16_t>(vertical_flywheel_->get_current_output_position() / vertical_flywheel_output_divider_);
|
||||
} else {
|
||||
// Get and write all those previously unwritten output ys
|
||||
const uint16_t output_y = openGL_output_builder_.get_composite_output_y();
|
||||
|
|
@ -215,7 +215,7 @@ void CRT::advance_cycles(unsigned int number_of_cycles, bool hsync_requested, bo
|
|||
output_x1() = output_run_.x1;
|
||||
output_position_y() = output_run_.y;
|
||||
output_tex_y() = output_y;
|
||||
output_x2() = (uint16_t)horizontal_flywheel_->get_current_output_position();
|
||||
output_x2() = static_cast<uint16_t>(horizontal_flywheel_->get_current_output_position());
|
||||
}
|
||||
openGL_output_builder_.array_builder.flush(
|
||||
[=] (uint8_t *input_buffer, size_t input_size, uint8_t *output_buffer, size_t output_size) {
|
||||
|
|
@ -378,7 +378,7 @@ void CRT::output_colour_burst(unsigned int number_of_cycles, uint8_t phase, uint
|
|||
}
|
||||
|
||||
void CRT::output_default_colour_burst(unsigned int number_of_cycles) {
|
||||
output_colour_burst(number_of_cycles, (uint8_t)((phase_numerator_ * 256) / phase_denominator_ + (is_alernate_line_ ? 128 : 0)));
|
||||
output_colour_burst(number_of_cycles, static_cast<uint8_t>((phase_numerator_ * 256) / phase_denominator_ + (is_alernate_line_ ? 128 : 0)));
|
||||
}
|
||||
|
||||
void CRT::output_data(unsigned int number_of_cycles, unsigned int source_divider) {
|
||||
|
|
|
|||
|
|
@ -134,7 +134,7 @@ class OpenGLOutputBuilder {
|
|||
}
|
||||
|
||||
inline uint16_t get_composite_output_y() {
|
||||
return (uint16_t)composite_src_output_y_;
|
||||
return static_cast<uint16_t>(composite_src_output_y_);
|
||||
}
|
||||
|
||||
inline bool composite_output_buffer_is_full() {
|
||||
|
|
|
|||
|
|
@ -82,9 +82,10 @@ uint8_t *TextureBuilder::allocate_write_area(size_t required_length, size_t requ
|
|||
}
|
||||
|
||||
// Queue up the latest write area.
|
||||
write_area_.x = write_areas_start_x_ + 1 + static_cast<uint16_t>(alignment_offset);
|
||||
write_areas_start_x_ += static_cast<uint16_t>(alignment_offset);
|
||||
write_area_.x = write_areas_start_x_ + 1;
|
||||
write_area_.y = write_areas_start_y_;
|
||||
write_area_.length = (uint16_t)required_length;
|
||||
write_area_.length = static_cast<uint16_t>(required_length);
|
||||
|
||||
// Return a video pointer.
|
||||
return pointer_to_location(write_area_.x, write_area_.y);
|
||||
|
|
@ -95,7 +96,7 @@ void TextureBuilder::reduce_previous_allocation_to(size_t actual_length) {
|
|||
if(was_full_) return;
|
||||
|
||||
// Update the length of the current write area.
|
||||
write_area_.length = (uint16_t)actual_length;
|
||||
write_area_.length = static_cast<uint16_t>(actual_length);
|
||||
|
||||
// Bookend the allocation with duplicates of the first and last pixel, to protect
|
||||
// against rounding errors when this run is drawn.
|
||||
|
|
|
|||
|
|
@ -28,13 +28,13 @@ uint16_t ProcessorBase::get_value_of_register(Register r) {
|
|||
|
||||
void ProcessorBase::set_value_of_register(Register r, uint16_t value) {
|
||||
switch (r) {
|
||||
case Register::ProgramCounter: pc_.full = value; break;
|
||||
case Register::StackPointer: s_ = (uint8_t)value; break;
|
||||
case Register::Flags: set_flags((uint8_t)value); break;
|
||||
case Register::A: a_ = (uint8_t)value; break;
|
||||
case Register::X: x_ = (uint8_t)value; break;
|
||||
case Register::Y: y_ = (uint8_t)value; break;
|
||||
case Register::S: s_ = (uint8_t)value; break;
|
||||
case Register::ProgramCounter: pc_.full = value; break;
|
||||
case Register::StackPointer: s_ = static_cast<uint8_t>(value); break;
|
||||
case Register::Flags: set_flags(static_cast<uint8_t>(value)); break;
|
||||
case Register::A: a_ = static_cast<uint8_t>(value); break;
|
||||
case Register::X: x_ = static_cast<uint8_t>(value); break;
|
||||
case Register::Y: y_ = static_cast<uint8_t>(value); break;
|
||||
case Register::S: s_ = static_cast<uint8_t>(value); break;
|
||||
default: break;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -194,17 +194,17 @@ if(number_of_cycles <= Cycles(0)) break;
|
|||
|
||||
case OperationCMP: {
|
||||
const uint16_t temp16 = a_ - operand_;
|
||||
negative_result_ = zero_result_ = (uint8_t)temp16;
|
||||
negative_result_ = zero_result_ = static_cast<uint8_t>(temp16);
|
||||
carry_flag_ = ((~temp16) >> 8)&1;
|
||||
} continue;
|
||||
case OperationCPX: {
|
||||
const uint16_t temp16 = x_ - operand_;
|
||||
negative_result_ = zero_result_ = (uint8_t)temp16;
|
||||
negative_result_ = zero_result_ = static_cast<uint8_t>(temp16);
|
||||
carry_flag_ = ((~temp16) >> 8)&1;
|
||||
} continue;
|
||||
case OperationCPY: {
|
||||
const uint16_t temp16 = y_ - operand_;
|
||||
negative_result_ = zero_result_ = (uint8_t)temp16;
|
||||
negative_result_ = zero_result_ = static_cast<uint8_t>(temp16);
|
||||
carry_flag_ = ((~temp16) >> 8)&1;
|
||||
} continue;
|
||||
|
||||
|
|
@ -223,7 +223,7 @@ if(number_of_cycles <= Cycles(0)) break;
|
|||
case OperationSBC:
|
||||
if(decimal_flag_) {
|
||||
const uint16_t notCarry = carry_flag_ ^ 0x1;
|
||||
const uint16_t decimalResult = (uint16_t)a_ - (uint16_t)operand_ - notCarry;
|
||||
const uint16_t decimalResult = static_cast<uint16_t>(a_) - static_cast<uint16_t>(operand_) - notCarry;
|
||||
uint16_t temp16;
|
||||
|
||||
temp16 = (a_&0xf) - (operand_&0xf) - notCarry;
|
||||
|
|
@ -232,13 +232,13 @@ if(number_of_cycles <= Cycles(0)) break;
|
|||
temp16 += (a_&0xf0) - (operand_&0xf0);
|
||||
|
||||
overflow_flag_ = ( ( (decimalResult^a_)&(~decimalResult^operand_) )&0x80) >> 1;
|
||||
negative_result_ = (uint8_t)temp16;
|
||||
zero_result_ = (uint8_t)decimalResult;
|
||||
negative_result_ = static_cast<uint8_t>(temp16);
|
||||
zero_result_ = static_cast<uint8_t>(decimalResult);
|
||||
|
||||
if(temp16 > 0xff) temp16 -= 0x60;
|
||||
|
||||
carry_flag_ = (temp16 > 0xff) ? 0 : Flag::Carry;
|
||||
a_ = (uint8_t)temp16;
|
||||
a_ = static_cast<uint8_t>(temp16);
|
||||
continue;
|
||||
} else {
|
||||
operand_ = ~operand_;
|
||||
|
|
@ -247,22 +247,22 @@ if(number_of_cycles <= Cycles(0)) break;
|
|||
// deliberate fallthrough
|
||||
case OperationADC:
|
||||
if(decimal_flag_) {
|
||||
const uint16_t decimalResult = (uint16_t)a_ + (uint16_t)operand_ + (uint16_t)carry_flag_;
|
||||
const uint16_t decimalResult = static_cast<uint16_t>(a_) + static_cast<uint16_t>(operand_) + static_cast<uint16_t>(carry_flag_);
|
||||
|
||||
uint8_t low_nibble = (a_ & 0xf) + (operand_ & 0xf) + carry_flag_;
|
||||
if(low_nibble >= 0xa) low_nibble = ((low_nibble + 0x6) & 0xf) + 0x10;
|
||||
uint16_t result = (uint16_t)(a_ & 0xf0) + (uint16_t)(operand_ & 0xf0) + (uint16_t)low_nibble;
|
||||
negative_result_ = (uint8_t)result;
|
||||
uint16_t result = static_cast<uint16_t>(a_ & 0xf0) + static_cast<uint16_t>(operand_ & 0xf0) + static_cast<uint16_t>(low_nibble);
|
||||
negative_result_ = static_cast<uint8_t>(result);
|
||||
overflow_flag_ = (( (result^a_)&(result^operand_) )&0x80) >> 1;
|
||||
if(result >= 0xa0) result += 0x60;
|
||||
|
||||
carry_flag_ = (result >> 8) ? 1 : 0;
|
||||
a_ = (uint8_t)result;
|
||||
zero_result_ = (uint8_t)decimalResult;
|
||||
a_ = static_cast<uint8_t>(result);
|
||||
zero_result_ = static_cast<uint8_t>(decimalResult);
|
||||
} else {
|
||||
const uint16_t result = (uint16_t)a_ + (uint16_t)operand_ + (uint16_t)carry_flag_;
|
||||
const uint16_t result = static_cast<uint16_t>(a_) + static_cast<uint16_t>(operand_) + static_cast<uint16_t>(carry_flag_);
|
||||
overflow_flag_ = (( (result^a_)&(result^operand_) )&0x80) >> 1;
|
||||
negative_result_ = zero_result_ = a_ = (uint8_t)result;
|
||||
negative_result_ = zero_result_ = a_ = static_cast<uint8_t>(result);
|
||||
carry_flag_ = (result >> 8)&1;
|
||||
}
|
||||
|
||||
|
|
@ -286,13 +286,13 @@ if(number_of_cycles <= Cycles(0)) break;
|
|||
continue;
|
||||
|
||||
case OperationROL: {
|
||||
const uint8_t temp8 = (uint8_t)((operand_ << 1) | carry_flag_);
|
||||
const uint8_t temp8 = static_cast<uint8_t>((operand_ << 1) | carry_flag_);
|
||||
carry_flag_ = operand_ >> 7;
|
||||
operand_ = negative_result_ = zero_result_ = temp8;
|
||||
} continue;
|
||||
|
||||
case OperationRLA: {
|
||||
const uint8_t temp8 = (uint8_t)((operand_ << 1) | carry_flag_);
|
||||
const uint8_t temp8 = static_cast<uint8_t>((operand_ << 1) | carry_flag_);
|
||||
carry_flag_ = operand_ >> 7;
|
||||
operand_ = temp8;
|
||||
a_ &= operand_;
|
||||
|
|
@ -320,13 +320,13 @@ if(number_of_cycles <= Cycles(0)) break;
|
|||
continue;
|
||||
|
||||
case OperationROR: {
|
||||
const uint8_t temp8 = (uint8_t)((operand_ >> 1) | (carry_flag_ << 7));
|
||||
const uint8_t temp8 = static_cast<uint8_t>((operand_ >> 1) | (carry_flag_ << 7));
|
||||
carry_flag_ = operand_ & 1;
|
||||
operand_ = negative_result_ = zero_result_ = temp8;
|
||||
} continue;
|
||||
|
||||
case OperationRRA: {
|
||||
const uint8_t temp8 = (uint8_t)((operand_ >> 1) | (carry_flag_ << 7));
|
||||
const uint8_t temp8 = static_cast<uint8_t>((operand_ >> 1) | (carry_flag_ << 7));
|
||||
carry_flag_ = operand_ & 1;
|
||||
operand_ = temp8;
|
||||
} continue;
|
||||
|
|
@ -466,7 +466,7 @@ if(number_of_cycles <= Cycles(0)) break;
|
|||
case OperationBEQ: BRA(!zero_result_); continue;
|
||||
|
||||
case CycleAddSignedOperandToPC:
|
||||
nextAddress.full = (uint16_t)(pc_.full + (int8_t)operand_);
|
||||
nextAddress.full = static_cast<uint16_t>(pc_.full + (int8_t)operand_);
|
||||
pc_.bytes.low = nextAddress.bytes.low;
|
||||
if(nextAddress.bytes.high != pc_.bytes.high) {
|
||||
uint16_t halfUpdatedPc = pc_.full;
|
||||
|
|
@ -491,7 +491,7 @@ if(number_of_cycles <= Cycles(0)) break;
|
|||
if(decimal_flag_) {
|
||||
a_ &= operand_;
|
||||
uint8_t unshiftedA = a_;
|
||||
a_ = (uint8_t)((a_ >> 1) | (carry_flag_ << 7));
|
||||
a_ = static_cast<uint8_t>((a_ >> 1) | (carry_flag_ << 7));
|
||||
zero_result_ = negative_result_ = a_;
|
||||
overflow_flag_ = (a_^(a_ << 1))&Flag::Overflow;
|
||||
|
||||
|
|
@ -501,7 +501,7 @@ if(number_of_cycles <= Cycles(0)) break;
|
|||
if(carry_flag_) a_ += 0x60;
|
||||
} else {
|
||||
a_ &= operand_;
|
||||
a_ = (uint8_t)((a_ >> 1) | (carry_flag_ << 7));
|
||||
a_ = static_cast<uint8_t>((a_ >> 1) | (carry_flag_ << 7));
|
||||
negative_result_ = zero_result_ = a_;
|
||||
carry_flag_ = (a_ >> 6)&1;
|
||||
overflow_flag_ = (a_^(a_ << 1))&Flag::Overflow;
|
||||
|
|
@ -511,7 +511,7 @@ if(number_of_cycles <= Cycles(0)) break;
|
|||
case OperationSBX:
|
||||
x_ &= a_;
|
||||
uint16_t difference = x_ - operand_;
|
||||
x_ = (uint8_t)difference;
|
||||
x_ = static_cast<uint8_t>(difference);
|
||||
negative_result_ = zero_result_ = x_;
|
||||
carry_flag_ = ((difference >> 8)&1)^1;
|
||||
continue;
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@ uint16_t ProcessorBase::get_value_of_register(Register r) {
|
|||
|
||||
case Register::A: return a_;
|
||||
case Register::Flags: return get_flags();
|
||||
case Register::AF: return (uint16_t)((a_ << 8) | get_flags());
|
||||
case Register::AF: return static_cast<uint16_t>((a_ << 8) | get_flags());
|
||||
case Register::B: return bc_.bytes.high;
|
||||
case Register::C: return bc_.bytes.low;
|
||||
case Register::BC: return bc_.full;
|
||||
|
|
@ -59,7 +59,7 @@ uint16_t ProcessorBase::get_value_of_register(Register r) {
|
|||
|
||||
case Register::IFF1: return iff1_ ? 1 : 0;
|
||||
case Register::IFF2: return iff2_ ? 1 : 0;
|
||||
case Register::IM: return (uint16_t)interrupt_mode_;
|
||||
case Register::IM: return static_cast<uint16_t>(interrupt_mode_);
|
||||
|
||||
case Register::MemPtr: return memptr_.full;
|
||||
|
||||
|
|
@ -72,49 +72,49 @@ void ProcessorBase::set_value_of_register(Register r, uint16_t value) {
|
|||
case Register::ProgramCounter: pc_.full = value; break;
|
||||
case Register::StackPointer: sp_.full = value; break;
|
||||
|
||||
case Register::A: a_ = (uint8_t)value; break;
|
||||
case Register::AF: a_ = (uint8_t)(value >> 8); // deliberate fallthrough...
|
||||
case Register::Flags: set_flags((uint8_t)value); break;
|
||||
case Register::A: a_ = static_cast<uint8_t>(value); break;
|
||||
case Register::AF: a_ = static_cast<uint8_t>(value >> 8); // deliberate fallthrough...
|
||||
case Register::Flags: set_flags(static_cast<uint8_t>(value)); break;
|
||||
|
||||
case Register::B: bc_.bytes.high = (uint8_t)value; break;
|
||||
case Register::C: bc_.bytes.low = (uint8_t)value; break;
|
||||
case Register::BC: bc_.full = value; break;
|
||||
case Register::D: de_.bytes.high = (uint8_t)value; break;
|
||||
case Register::E: de_.bytes.low = (uint8_t)value; break;
|
||||
case Register::DE: de_.full = value; break;
|
||||
case Register::H: hl_.bytes.high = (uint8_t)value; break;
|
||||
case Register::L: hl_.bytes.low = (uint8_t)value; break;
|
||||
case Register::HL: hl_.full = value; break;
|
||||
case Register::B: bc_.bytes.high = static_cast<uint8_t>(value); break;
|
||||
case Register::C: bc_.bytes.low = static_cast<uint8_t>(value); break;
|
||||
case Register::BC: bc_.full = value; break;
|
||||
case Register::D: de_.bytes.high = static_cast<uint8_t>(value); break;
|
||||
case Register::E: de_.bytes.low = static_cast<uint8_t>(value); break;
|
||||
case Register::DE: de_.full = value; break;
|
||||
case Register::H: hl_.bytes.high = static_cast<uint8_t>(value); break;
|
||||
case Register::L: hl_.bytes.low = static_cast<uint8_t>(value); break;
|
||||
case Register::HL: hl_.full = value; break;
|
||||
|
||||
case Register::ADash: afDash_.bytes.high = (uint8_t)value; break;
|
||||
case Register::FlagsDash: afDash_.bytes.low = (uint8_t)value; break;
|
||||
case Register::AFDash: afDash_.full = value; break;
|
||||
case Register::BDash: bcDash_.bytes.high = (uint8_t)value; break;
|
||||
case Register::CDash: bcDash_.bytes.low = (uint8_t)value; break;
|
||||
case Register::BCDash: bcDash_.full = value; break;
|
||||
case Register::DDash: deDash_.bytes.high = (uint8_t)value; break;
|
||||
case Register::EDash: deDash_.bytes.low = (uint8_t)value; break;
|
||||
case Register::DEDash: deDash_.full = value; break;
|
||||
case Register::HDash: hlDash_.bytes.high = (uint8_t)value; break;
|
||||
case Register::LDash: hlDash_.bytes.low = (uint8_t)value; break;
|
||||
case Register::HLDash: hlDash_.full = value; break;
|
||||
case Register::ADash: afDash_.bytes.high = static_cast<uint8_t>(value); break;
|
||||
case Register::FlagsDash: afDash_.bytes.low = static_cast<uint8_t>(value); break;
|
||||
case Register::AFDash: afDash_.full = value; break;
|
||||
case Register::BDash: bcDash_.bytes.high = static_cast<uint8_t>(value); break;
|
||||
case Register::CDash: bcDash_.bytes.low = static_cast<uint8_t>(value); break;
|
||||
case Register::BCDash: bcDash_.full = value; break;
|
||||
case Register::DDash: deDash_.bytes.high = static_cast<uint8_t>(value); break;
|
||||
case Register::EDash: deDash_.bytes.low = static_cast<uint8_t>(value); break;
|
||||
case Register::DEDash: deDash_.full = value; break;
|
||||
case Register::HDash: hlDash_.bytes.high = static_cast<uint8_t>(value); break;
|
||||
case Register::LDash: hlDash_.bytes.low = static_cast<uint8_t>(value); break;
|
||||
case Register::HLDash: hlDash_.full = value; break;
|
||||
|
||||
case Register::IXh: ix_.bytes.high = (uint8_t)value; break;
|
||||
case Register::IXl: ix_.bytes.low = (uint8_t)value; break;
|
||||
case Register::IX: ix_.full = value; break;
|
||||
case Register::IYh: iy_.bytes.high = (uint8_t)value; break;
|
||||
case Register::IYl: iy_.bytes.low = (uint8_t)value; break;
|
||||
case Register::IY: iy_.full = value; break;
|
||||
case Register::IXh: ix_.bytes.high = static_cast<uint8_t>(value); break;
|
||||
case Register::IXl: ix_.bytes.low = static_cast<uint8_t>(value); break;
|
||||
case Register::IX: ix_.full = value; break;
|
||||
case Register::IYh: iy_.bytes.high = static_cast<uint8_t>(value); break;
|
||||
case Register::IYl: iy_.bytes.low = static_cast<uint8_t>(value); break;
|
||||
case Register::IY: iy_.full = value; break;
|
||||
|
||||
case Register::R: ir_.bytes.low = (uint8_t)value; break;
|
||||
case Register::I: ir_.bytes.high = (uint8_t)value; break;
|
||||
case Register::Refresh: ir_.full = (uint16_t)value; break;
|
||||
case Register::R: ir_.bytes.low = static_cast<uint8_t>(value); break;
|
||||
case Register::I: ir_.bytes.high = static_cast<uint8_t>(value); break;
|
||||
case Register::Refresh: ir_.full = value; break;
|
||||
|
||||
case Register::IFF1: iff1_ = !!value; break;
|
||||
case Register::IFF2: iff2_ = !!value; break;
|
||||
case Register::IM: interrupt_mode_ = value % 3; break;
|
||||
case Register::IFF1: iff1_ = !!value; break;
|
||||
case Register::IFF2: iff2_ = !!value; break;
|
||||
case Register::IM: interrupt_mode_ = value % 3; break;
|
||||
|
||||
case Register::MemPtr: memptr_.full = value; break;
|
||||
case Register::MemPtr: memptr_.full = value; break;
|
||||
|
||||
default: break;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -58,7 +58,7 @@ template < class T,
|
|||
scheduled_program_counter_++;
|
||||
|
||||
#define set_parity(v) \
|
||||
parity_overflow_result_ = (uint8_t)(v^1);\
|
||||
parity_overflow_result_ = static_cast<uint8_t>(v^1);\
|
||||
parity_overflow_result_ ^= parity_overflow_result_ >> 4;\
|
||||
parity_overflow_result_ ^= parity_overflow_result_ << 2;\
|
||||
parity_overflow_result_ ^= parity_overflow_result_ >> 1;
|
||||
|
|
@ -88,12 +88,12 @@ template < class T,
|
|||
case MicroOp::DecodeOperation:
|
||||
refresh_addr_ = ir_;
|
||||
ir_.bytes.low = (ir_.bytes.low & 0x80) | ((ir_.bytes.low + current_instruction_page_->r_step) & 0x7f);
|
||||
pc_.full += pc_increment_ & (uint16_t)halt_mask_;
|
||||
pc_.full += pc_increment_ & static_cast<uint16_t>(halt_mask_);
|
||||
scheduled_program_counter_ = current_instruction_page_->instructions[operation_ & halt_mask_];
|
||||
break;
|
||||
case MicroOp::DecodeOperationNoRChange:
|
||||
refresh_addr_ = ir_;
|
||||
pc_.full += pc_increment_ & (uint16_t)halt_mask_;
|
||||
pc_.full += pc_increment_ & static_cast<uint16_t>(halt_mask_);
|
||||
scheduled_program_counter_ = current_instruction_page_->instructions[operation_ & halt_mask_];
|
||||
break;
|
||||
|
||||
|
|
@ -146,7 +146,7 @@ template < class T,
|
|||
break;
|
||||
|
||||
case MicroOp::CCF:
|
||||
half_carry_result_ = (uint8_t)(carry_result_ << 4);
|
||||
half_carry_result_ = static_cast<uint8_t>(carry_result_ << 4);
|
||||
carry_result_ ^= Flag::Carry;
|
||||
subtract_flag_ = 0;
|
||||
bit53_result_ = a_;
|
||||
|
|
@ -175,12 +175,12 @@ template < class T,
|
|||
#pragma mark - 8-bit arithmetic
|
||||
|
||||
#define set_arithmetic_flags(sub, b53) \
|
||||
sign_result_ = zero_result_ = (uint8_t)result; \
|
||||
carry_result_ = (uint8_t)(result >> 8); \
|
||||
half_carry_result_ = (uint8_t)half_result; \
|
||||
parity_overflow_result_ = (uint8_t)(overflow >> 5); \
|
||||
sign_result_ = zero_result_ = static_cast<uint8_t>(result); \
|
||||
carry_result_ = static_cast<uint8_t>(result >> 8); \
|
||||
half_carry_result_ = static_cast<uint8_t>(half_result); \
|
||||
parity_overflow_result_ = static_cast<uint8_t>(overflow >> 5); \
|
||||
subtract_flag_ = sub; \
|
||||
bit53_result_ = (uint8_t)b53;
|
||||
bit53_result_ = static_cast<uint8_t>(b53);
|
||||
|
||||
case MicroOp::CP8: {
|
||||
uint8_t value = *(uint8_t *)operation->source;
|
||||
|
|
@ -204,7 +204,7 @@ template < class T,
|
|||
// different and the result is different again
|
||||
int overflow = (value^a_) & (result^a_);
|
||||
|
||||
a_ = (uint8_t)result;
|
||||
a_ = static_cast<uint8_t>(result);
|
||||
set_arithmetic_flags(Flag::Subtract, result);
|
||||
} break;
|
||||
|
||||
|
|
@ -217,7 +217,7 @@ template < class T,
|
|||
// different and the result is different again
|
||||
int overflow = (value^a_) & (result^a_);
|
||||
|
||||
a_ = (uint8_t)result;
|
||||
a_ = static_cast<uint8_t>(result);
|
||||
set_arithmetic_flags(Flag::Subtract, result);
|
||||
} break;
|
||||
|
||||
|
|
@ -230,7 +230,7 @@ template < class T,
|
|||
// the same and the result is different
|
||||
int overflow = ~(value^a_) & (result^a_);
|
||||
|
||||
a_ = (uint8_t)result;
|
||||
a_ = static_cast<uint8_t>(result);
|
||||
set_arithmetic_flags(0, result);
|
||||
} break;
|
||||
|
||||
|
|
@ -243,7 +243,7 @@ template < class T,
|
|||
// the same and the result is different
|
||||
int overflow = ~(value^a_) & (result^a_);
|
||||
|
||||
a_ = (uint8_t)result;
|
||||
a_ = static_cast<uint8_t>(result);
|
||||
set_arithmetic_flags(0, result);
|
||||
} break;
|
||||
|
||||
|
|
@ -254,12 +254,12 @@ template < class T,
|
|||
int result = -a_;
|
||||
int halfResult = -(a_&0xf);
|
||||
|
||||
a_ = (uint8_t)result;
|
||||
a_ = static_cast<uint8_t>(result);
|
||||
bit53_result_ = sign_result_ = zero_result_ = a_;
|
||||
parity_overflow_result_ = overflow ? Flag::Overflow : 0;
|
||||
subtract_flag_ = Flag::Subtract;
|
||||
carry_result_ = (uint8_t)(result >> 8);
|
||||
half_carry_result_ = (uint8_t)halfResult;
|
||||
carry_result_ = static_cast<uint8_t>(result >> 8);
|
||||
half_carry_result_ = static_cast<uint8_t>(halfResult);
|
||||
} break;
|
||||
|
||||
case MicroOp::Increment8: {
|
||||
|
|
@ -271,12 +271,12 @@ template < class T,
|
|||
int overflow = (value ^ result) & ~value;
|
||||
int half_result = (value&0xf) + 1;
|
||||
|
||||
*(uint8_t *)operation->source = (uint8_t)result;
|
||||
*(uint8_t *)operation->source = static_cast<uint8_t>(result);
|
||||
|
||||
// sign, zero and 5 & 3 are set directly from the result
|
||||
bit53_result_ = sign_result_ = zero_result_ = (uint8_t)result;
|
||||
half_carry_result_ = (uint8_t)half_result;
|
||||
parity_overflow_result_ = (uint8_t)(overflow >> 5);
|
||||
bit53_result_ = sign_result_ = zero_result_ = static_cast<uint8_t>(result);
|
||||
half_carry_result_ = static_cast<uint8_t>(half_result);
|
||||
parity_overflow_result_ = static_cast<uint8_t>(overflow >> 5);
|
||||
subtract_flag_ = 0;
|
||||
} break;
|
||||
|
||||
|
|
@ -289,12 +289,12 @@ template < class T,
|
|||
int overflow = (value ^ result) & value;
|
||||
int half_result = (value&0xf) - 1;
|
||||
|
||||
*(uint8_t *)operation->source = (uint8_t)result;
|
||||
*(uint8_t *)operation->source = static_cast<uint8_t>(result);
|
||||
|
||||
// sign, zero and 5 & 3 are set directly from the result
|
||||
bit53_result_ = sign_result_ = zero_result_ = (uint8_t)result;
|
||||
half_carry_result_ = (uint8_t)half_result;
|
||||
parity_overflow_result_ = (uint8_t)(overflow >> 5);
|
||||
bit53_result_ = sign_result_ = zero_result_ = static_cast<uint8_t>(result);
|
||||
half_carry_result_ = static_cast<uint8_t>(half_result);
|
||||
parity_overflow_result_ = static_cast<uint8_t>(overflow >> 5);
|
||||
subtract_flag_ = Flag::Subtract;
|
||||
} break;
|
||||
|
||||
|
|
@ -362,12 +362,12 @@ template < class T,
|
|||
int result = sourceValue + destinationValue;
|
||||
int halfResult = (sourceValue&0xfff) + (destinationValue&0xfff);
|
||||
|
||||
bit53_result_ = (uint8_t)(result >> 8);
|
||||
carry_result_ = (uint8_t)(result >> 16);
|
||||
half_carry_result_ = (uint8_t)(halfResult >> 8);
|
||||
bit53_result_ = static_cast<uint8_t>(result >> 8);
|
||||
carry_result_ = static_cast<uint8_t>(result >> 16);
|
||||
half_carry_result_ = static_cast<uint8_t>(halfResult >> 8);
|
||||
subtract_flag_ = 0;
|
||||
|
||||
*(uint16_t *)operation->destination = (uint16_t)result;
|
||||
*(uint16_t *)operation->destination = static_cast<uint16_t>(result);
|
||||
memptr_.full++;
|
||||
} break;
|
||||
|
||||
|
|
@ -381,14 +381,14 @@ template < class T,
|
|||
int overflow = (result ^ destinationValue) & ~(destinationValue ^ sourceValue);
|
||||
|
||||
bit53_result_ =
|
||||
sign_result_ = (uint8_t)(result >> 8);
|
||||
zero_result_ = (uint8_t)(result | sign_result_);
|
||||
sign_result_ = static_cast<uint8_t>(result >> 8);
|
||||
zero_result_ = static_cast<uint8_t>(result | sign_result_);
|
||||
subtract_flag_ = 0;
|
||||
carry_result_ = (uint8_t)(result >> 16);
|
||||
half_carry_result_ = (uint8_t)(halfResult >> 8);
|
||||
parity_overflow_result_ = (uint8_t)(overflow >> 13);
|
||||
carry_result_ = static_cast<uint8_t>(result >> 16);
|
||||
half_carry_result_ = static_cast<uint8_t>(halfResult >> 8);
|
||||
parity_overflow_result_ = static_cast<uint8_t>(overflow >> 13);
|
||||
|
||||
*(uint16_t *)operation->destination = (uint16_t)result;
|
||||
*(uint16_t *)operation->destination = static_cast<uint16_t>(result);
|
||||
memptr_.full++;
|
||||
} break;
|
||||
|
||||
|
|
@ -405,14 +405,14 @@ template < class T,
|
|||
int overflow = (result ^ destinationValue) & (sourceValue ^ destinationValue);
|
||||
|
||||
bit53_result_ =
|
||||
sign_result_ = (uint8_t)(result >> 8);
|
||||
zero_result_ = (uint8_t)(result | sign_result_);
|
||||
sign_result_ = static_cast<uint8_t>(result >> 8);
|
||||
zero_result_ = static_cast<uint8_t>(result | sign_result_);
|
||||
subtract_flag_ = Flag::Subtract;
|
||||
carry_result_ = (uint8_t)(result >> 16);
|
||||
half_carry_result_ = (uint8_t)(halfResult >> 8);
|
||||
parity_overflow_result_ = (uint8_t)(overflow >> 13);
|
||||
carry_result_ = static_cast<uint8_t>(result >> 16);
|
||||
half_carry_result_ = static_cast<uint8_t>(halfResult >> 8);
|
||||
parity_overflow_result_ = static_cast<uint8_t>(overflow >> 13);
|
||||
|
||||
*(uint16_t *)operation->destination = (uint16_t)result;
|
||||
*(uint16_t *)operation->destination = static_cast<uint16_t>(result);
|
||||
memptr_.full++;
|
||||
} break;
|
||||
|
||||
|
|
@ -477,7 +477,7 @@ template < class T,
|
|||
de_.full += dir; \
|
||||
hl_.full += dir; \
|
||||
uint8_t sum = a_ + temp8_; \
|
||||
bit53_result_ = (uint8_t)((sum&0x8) | ((sum & 0x02) << 4)); \
|
||||
bit53_result_ = static_cast<uint8_t>((sum&0x8) | ((sum & 0x02) << 4)); \
|
||||
subtract_flag_ = 0; \
|
||||
half_carry_result_ = 0; \
|
||||
parity_overflow_result_ = bc_.full ? Flag::Parity : 0;
|
||||
|
|
@ -515,7 +515,7 @@ template < class T,
|
|||
sign_result_ = zero_result_ = result; \
|
||||
\
|
||||
result -= (halfResult >> 4)&1; \
|
||||
bit53_result_ = (uint8_t)((result&0x8) | ((result&0x2) << 4)); \
|
||||
bit53_result_ = static_cast<uint8_t>((result&0x8) | ((result&0x2) << 4)); \
|
||||
|
||||
case MicroOp::CPDR: {
|
||||
CPxR_STEP(-1);
|
||||
|
|
@ -650,25 +650,25 @@ template < class T,
|
|||
|
||||
case MicroOp::RLA: {
|
||||
uint8_t new_carry = a_ >> 7;
|
||||
a_ = (uint8_t)((a_ << 1) | (carry_result_ & Flag::Carry));
|
||||
a_ = static_cast<uint8_t>((a_ << 1) | (carry_result_ & Flag::Carry));
|
||||
set_rotate_flags();
|
||||
} break;
|
||||
|
||||
case MicroOp::RRA: {
|
||||
uint8_t new_carry = a_ & 1;
|
||||
a_ = (uint8_t)((a_ >> 1) | (carry_result_ << 7));
|
||||
a_ = static_cast<uint8_t>((a_ >> 1) | (carry_result_ << 7));
|
||||
set_rotate_flags();
|
||||
} break;
|
||||
|
||||
case MicroOp::RLCA: {
|
||||
uint8_t new_carry = a_ >> 7;
|
||||
a_ = (uint8_t)((a_ << 1) | new_carry);
|
||||
a_ = static_cast<uint8_t>((a_ << 1) | new_carry);
|
||||
set_rotate_flags();
|
||||
} break;
|
||||
|
||||
case MicroOp::RRCA: {
|
||||
uint8_t new_carry = a_ & 1;
|
||||
a_ = (uint8_t)((a_ >> 1) | (new_carry << 7));
|
||||
a_ = static_cast<uint8_t>((a_ >> 1) | (new_carry << 7));
|
||||
set_rotate_flags();
|
||||
} break;
|
||||
|
||||
|
|
@ -682,51 +682,51 @@ template < class T,
|
|||
|
||||
case MicroOp::RLC:
|
||||
carry_result_ = *(uint8_t *)operation->source >> 7;
|
||||
*(uint8_t *)operation->source = (uint8_t)((*(uint8_t *)operation->source << 1) | carry_result_);
|
||||
*(uint8_t *)operation->source = static_cast<uint8_t>((*(uint8_t *)operation->source << 1) | carry_result_);
|
||||
set_shift_flags();
|
||||
break;
|
||||
|
||||
case MicroOp::RRC:
|
||||
carry_result_ = *(uint8_t *)operation->source;
|
||||
*(uint8_t *)operation->source = (uint8_t)((*(uint8_t *)operation->source >> 1) | (carry_result_ << 7));
|
||||
*(uint8_t *)operation->source = static_cast<uint8_t>((*(uint8_t *)operation->source >> 1) | (carry_result_ << 7));
|
||||
set_shift_flags();
|
||||
break;
|
||||
|
||||
case MicroOp::RL: {
|
||||
uint8_t next_carry = *(uint8_t *)operation->source >> 7;
|
||||
*(uint8_t *)operation->source = (uint8_t)((*(uint8_t *)operation->source << 1) | (carry_result_ & Flag::Carry));
|
||||
*(uint8_t *)operation->source = static_cast<uint8_t>((*(uint8_t *)operation->source << 1) | (carry_result_ & Flag::Carry));
|
||||
carry_result_ = next_carry;
|
||||
set_shift_flags();
|
||||
} break;
|
||||
|
||||
case MicroOp::RR: {
|
||||
uint8_t next_carry = *(uint8_t *)operation->source;
|
||||
*(uint8_t *)operation->source = (uint8_t)((*(uint8_t *)operation->source >> 1) | (carry_result_ << 7));
|
||||
*(uint8_t *)operation->source = static_cast<uint8_t>((*(uint8_t *)operation->source >> 1) | (carry_result_ << 7));
|
||||
carry_result_ = next_carry;
|
||||
set_shift_flags();
|
||||
} break;
|
||||
|
||||
case MicroOp::SLA:
|
||||
carry_result_ = *(uint8_t *)operation->source >> 7;
|
||||
*(uint8_t *)operation->source = (uint8_t)(*(uint8_t *)operation->source << 1);
|
||||
*(uint8_t *)operation->source = static_cast<uint8_t>(*(uint8_t *)operation->source << 1);
|
||||
set_shift_flags();
|
||||
break;
|
||||
|
||||
case MicroOp::SRA:
|
||||
carry_result_ = *(uint8_t *)operation->source;
|
||||
*(uint8_t *)operation->source = (uint8_t)((*(uint8_t *)operation->source >> 1) | (*(uint8_t *)operation->source & 0x80));
|
||||
*(uint8_t *)operation->source = static_cast<uint8_t>((*(uint8_t *)operation->source >> 1) | (*(uint8_t *)operation->source & 0x80));
|
||||
set_shift_flags();
|
||||
break;
|
||||
|
||||
case MicroOp::SLL:
|
||||
carry_result_ = *(uint8_t *)operation->source >> 7;
|
||||
*(uint8_t *)operation->source = (uint8_t)(*(uint8_t *)operation->source << 1) | 1;
|
||||
*(uint8_t *)operation->source = static_cast<uint8_t>(*(uint8_t *)operation->source << 1) | 1;
|
||||
set_shift_flags();
|
||||
break;
|
||||
|
||||
case MicroOp::SRL:
|
||||
carry_result_ = *(uint8_t *)operation->source;
|
||||
*(uint8_t *)operation->source = (uint8_t)((*(uint8_t *)operation->source >> 1));
|
||||
*(uint8_t *)operation->source = static_cast<uint8_t>((*(uint8_t *)operation->source >> 1));
|
||||
set_shift_flags();
|
||||
break;
|
||||
|
||||
|
|
@ -742,7 +742,7 @@ template < class T,
|
|||
memptr_.full = hl_.full + 1;
|
||||
uint8_t low_nibble = a_ & 0xf;
|
||||
a_ = (a_ & 0xf0) | (temp8_ & 0xf);
|
||||
temp8_ = (uint8_t)((temp8_ >> 4) | (low_nibble << 4));
|
||||
temp8_ = static_cast<uint8_t>((temp8_ >> 4) | (low_nibble << 4));
|
||||
set_decimal_rotate_flags();
|
||||
} break;
|
||||
|
||||
|
|
@ -750,7 +750,7 @@ template < class T,
|
|||
memptr_.full = hl_.full + 1;
|
||||
uint8_t low_nibble = a_ & 0xf;
|
||||
a_ = (a_ & 0xf0) | (temp8_ >> 4);
|
||||
temp8_ = (uint8_t)((temp8_ << 4) | low_nibble);
|
||||
temp8_ = static_cast<uint8_t>((temp8_ << 4) | low_nibble);
|
||||
set_decimal_rotate_flags();
|
||||
} break;
|
||||
|
||||
|
|
@ -845,7 +845,7 @@ template < class T,
|
|||
break;
|
||||
|
||||
case MicroOp::CalculateIndexAddress:
|
||||
memptr_.full = (uint16_t)(*(uint16_t *)operation->source + (int8_t)temp8_);
|
||||
memptr_.full = static_cast<uint16_t>(*(uint16_t *)operation->source + (int8_t)temp8_);
|
||||
break;
|
||||
|
||||
case MicroOp::IndexedPlaceHolder:
|
||||
|
|
|
|||
|
|
@ -57,8 +57,8 @@ std::unique_ptr<Catalogue> StaticAnalyser::Acorn::GetDFSCatalogue(const std::sha
|
|||
|
||||
if(start_sector < 2) continue;
|
||||
while(data_length > 0) {
|
||||
uint8_t sector = (uint8_t)(start_sector % 10);
|
||||
uint8_t track = (uint8_t)(start_sector / 10);
|
||||
uint8_t sector = static_cast<uint8_t>(start_sector % 10);
|
||||
uint8_t track = static_cast<uint8_t>(start_sector / 10);
|
||||
start_sector++;
|
||||
|
||||
Storage::Encodings::MFM::Sector *next_sector = parser.get_sector(0, track, sector);
|
||||
|
|
|
|||
|
|
@ -50,14 +50,14 @@ static std::unique_ptr<File::Chunk> GetNextChunk(const std::shared_ptr<Storage::
|
|||
// addresses
|
||||
new_chunk->load_address = (uint32_t)parser.get_next_word(tape);
|
||||
new_chunk->execution_address = (uint32_t)parser.get_next_word(tape);
|
||||
new_chunk->block_number = (uint16_t)parser.get_next_short(tape);
|
||||
new_chunk->block_length = (uint16_t)parser.get_next_short(tape);
|
||||
new_chunk->block_flag = (uint8_t)parser.get_next_byte(tape);
|
||||
new_chunk->block_number = static_cast<uint16_t>(parser.get_next_short(tape));
|
||||
new_chunk->block_length = static_cast<uint16_t>(parser.get_next_short(tape));
|
||||
new_chunk->block_flag = static_cast<uint8_t>(parser.get_next_byte(tape));
|
||||
new_chunk->next_address = (uint32_t)parser.get_next_word(tape);
|
||||
|
||||
uint16_t calculated_header_crc = parser.get_crc();
|
||||
uint16_t stored_header_crc = (uint16_t)parser.get_next_short(tape);
|
||||
stored_header_crc = (uint16_t)((stored_header_crc >> 8) | (stored_header_crc << 8));
|
||||
uint16_t stored_header_crc = static_cast<uint16_t>(parser.get_next_short(tape));
|
||||
stored_header_crc = static_cast<uint16_t>((stored_header_crc >> 8) | (stored_header_crc << 8));
|
||||
new_chunk->header_crc_matched = stored_header_crc == calculated_header_crc;
|
||||
|
||||
if(!new_chunk->header_crc_matched) return nullptr;
|
||||
|
|
@ -65,13 +65,13 @@ static std::unique_ptr<File::Chunk> GetNextChunk(const std::shared_ptr<Storage::
|
|||
parser.reset_crc();
|
||||
new_chunk->data.reserve(new_chunk->block_length);
|
||||
for(int c = 0; c < new_chunk->block_length; c++) {
|
||||
new_chunk->data.push_back((uint8_t)parser.get_next_byte(tape));
|
||||
new_chunk->data.push_back(static_cast<uint8_t>(parser.get_next_byte(tape)));
|
||||
}
|
||||
|
||||
if(new_chunk->block_length && !(new_chunk->block_flag&0x40)) {
|
||||
uint16_t calculated_data_crc = parser.get_crc();
|
||||
uint16_t stored_data_crc = (uint16_t)parser.get_next_short(tape);
|
||||
stored_data_crc = (uint16_t)((stored_data_crc >> 8) | (stored_data_crc << 8));
|
||||
uint16_t stored_data_crc = static_cast<uint16_t>(parser.get_next_short(tape));
|
||||
stored_data_crc = static_cast<uint16_t>((stored_data_crc >> 8) | (stored_data_crc << 8));
|
||||
new_chunk->data_crc_matched = stored_data_crc == calculated_data_crc;
|
||||
} else {
|
||||
new_chunk->data_crc_matched = true;
|
||||
|
|
|
|||
|
|
@ -16,8 +16,8 @@ static void DeterminePagingFor2kCartridge(StaticAnalyser::Target &target, const
|
|||
// if this is a 2kb cartridge then it's definitely either unpaged or a CommaVid
|
||||
uint16_t entry_address, break_address;
|
||||
|
||||
entry_address = ((uint16_t)(segment.data[0x7fc] | (segment.data[0x7fd] << 8))) & 0x1fff;
|
||||
break_address = ((uint16_t)(segment.data[0x7fe] | (segment.data[0x7ff] << 8))) & 0x1fff;
|
||||
entry_address = (static_cast<uint16_t>(segment.data[0x7fc] | (segment.data[0x7fd] << 8))) & 0x1fff;
|
||||
break_address = (static_cast<uint16_t>(segment.data[0x7fe] | (segment.data[0x7ff] << 8))) & 0x1fff;
|
||||
|
||||
// a CommaVid start address needs to be outside of its RAM
|
||||
if(entry_address < 0x1800 || break_address < 0x1800) return;
|
||||
|
|
@ -122,8 +122,8 @@ static void DeterminePagingForCartridge(StaticAnalyser::Target &target, const St
|
|||
|
||||
uint16_t entry_address, break_address;
|
||||
|
||||
entry_address = (uint16_t)(segment.data[segment.data.size() - 4] | (segment.data[segment.data.size() - 3] << 8));
|
||||
break_address = (uint16_t)(segment.data[segment.data.size() - 2] | (segment.data[segment.data.size() - 1] << 8));
|
||||
entry_address = static_cast<uint16_t>(segment.data[segment.data.size() - 4] | (segment.data[segment.data.size() - 3] << 8));
|
||||
break_address = static_cast<uint16_t>(segment.data[segment.data.size() - 2] | (segment.data[segment.data.size() - 1] << 8));
|
||||
|
||||
std::function<size_t(uint16_t address)> address_mapper = [](uint16_t address) {
|
||||
if(!(address & 0x1000)) return (size_t)-1;
|
||||
|
|
|
|||
|
|
@ -108,7 +108,7 @@ class CommodoreGCRParser: public Storage::Disk::Controller {
|
|||
}
|
||||
|
||||
std::shared_ptr<Sector> get_sector(uint8_t sector) {
|
||||
uint16_t sector_address = (uint16_t)((track_ << 8) | sector);
|
||||
uint16_t sector_address = static_cast<uint16_t>((track_ << 8) | sector);
|
||||
if(sector_cache_[sector_address]) return sector_cache_[sector_address];
|
||||
|
||||
std::shared_ptr<Sector> first_sector = get_next_sector();
|
||||
|
|
@ -134,12 +134,12 @@ class CommodoreGCRParser: public Storage::Disk::Controller {
|
|||
}
|
||||
|
||||
// get sector details, skip if this looks malformed
|
||||
uint8_t checksum = (uint8_t)get_next_byte();
|
||||
sector->sector = (uint8_t)get_next_byte();
|
||||
sector->track = (uint8_t)get_next_byte();
|
||||
uint8_t checksum = static_cast<uint8_t>(get_next_byte());
|
||||
sector->sector = static_cast<uint8_t>(get_next_byte());
|
||||
sector->track = static_cast<uint8_t>(get_next_byte());
|
||||
uint8_t disk_id[2];
|
||||
disk_id[0] = (uint8_t)get_next_byte();
|
||||
disk_id[1] = (uint8_t)get_next_byte();
|
||||
disk_id[0] = static_cast<uint8_t>(get_next_byte());
|
||||
disk_id[1] = static_cast<uint8_t>(get_next_byte());
|
||||
if(checksum != (sector->sector ^ sector->track ^ disk_id[0] ^ disk_id[1])) continue;
|
||||
|
||||
// look for the following data
|
||||
|
|
@ -150,12 +150,12 @@ class CommodoreGCRParser: public Storage::Disk::Controller {
|
|||
|
||||
checksum = 0;
|
||||
for(size_t c = 0; c < 256; c++) {
|
||||
sector->data[c] = (uint8_t)get_next_byte();
|
||||
sector->data[c] = static_cast<uint8_t>(get_next_byte());
|
||||
checksum ^= sector->data[c];
|
||||
}
|
||||
|
||||
if(checksum == get_next_byte()) {
|
||||
uint16_t sector_address = (uint16_t)((sector->track << 8) | sector->sector);
|
||||
uint16_t sector_address = static_cast<uint16_t>((sector->track << 8) | sector->sector);
|
||||
sector_cache_[sector_address] = sector;
|
||||
return sector;
|
||||
}
|
||||
|
|
@ -223,7 +223,7 @@ std::list<File> StaticAnalyser::Commodore::GetFiles(const std::shared_ptr<Storag
|
|||
next_track = sector->data[0];
|
||||
next_sector = sector->data[1];
|
||||
|
||||
if(is_first_sector) new_file.starting_address = (uint16_t)sector->data[2] | (uint16_t)(sector->data[3] << 8);
|
||||
if(is_first_sector) new_file.starting_address = static_cast<uint16_t>(sector->data[2]) | static_cast<uint16_t>(sector->data[3] << 8);
|
||||
if(next_track)
|
||||
new_file.data.insert(new_file.data.end(), sector->data.begin() + (is_first_sector ? 4 : 2), sector->data.end());
|
||||
else
|
||||
|
|
|
|||
|
|
@ -39,7 +39,7 @@ bool StaticAnalyser::Commodore::File::is_basic() {
|
|||
|
||||
if(next_line_number <= line_number) break;
|
||||
|
||||
line_number = (uint16_t)next_line_number;
|
||||
line_number = static_cast<uint16_t>(next_line_number);
|
||||
line_address = next_line_address;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -249,7 +249,7 @@ static void AddToDisassembly(PartialDisassembly &disassembly, const std::vector<
|
|||
if(low_operand_address >= memory.size() || high_operand_address >= memory.size()) return;
|
||||
address += 2;
|
||||
|
||||
instruction.operand = memory[low_operand_address] | (uint16_t)(memory[high_operand_address] << 8);
|
||||
instruction.operand = memory[low_operand_address] | static_cast<uint16_t>(memory[high_operand_address] << 8);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
|
@ -301,7 +301,7 @@ static void AddToDisassembly(PartialDisassembly &disassembly, const std::vector<
|
|||
return;
|
||||
}
|
||||
if(instruction.addressing_mode == Instruction::Relative) {
|
||||
uint16_t destination = (uint16_t)(address + (int8_t)instruction.operand);
|
||||
uint16_t destination = static_cast<uint16_t>(address + (int8_t)instruction.operand);
|
||||
disassembly.remaining_entry_points.push_back(destination);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -49,10 +49,10 @@ std::list<File> StaticAnalyser::Oric::GetFiles(const std::shared_ptr<Storage::Ta
|
|||
}
|
||||
|
||||
// read end and start addresses
|
||||
new_file.ending_address = (uint16_t)(parser.get_next_byte(tape, is_fast) << 8);
|
||||
new_file.ending_address |= (uint16_t)parser.get_next_byte(tape, is_fast);
|
||||
new_file.starting_address = (uint16_t)(parser.get_next_byte(tape, is_fast) << 8);
|
||||
new_file.starting_address |= (uint16_t)parser.get_next_byte(tape, is_fast);
|
||||
new_file.ending_address = static_cast<uint16_t>(parser.get_next_byte(tape, is_fast) << 8);
|
||||
new_file.ending_address |= static_cast<uint16_t>(parser.get_next_byte(tape, is_fast));
|
||||
new_file.starting_address = static_cast<uint16_t>(parser.get_next_byte(tape, is_fast) << 8);
|
||||
new_file.starting_address |= static_cast<uint16_t>(parser.get_next_byte(tape, is_fast));
|
||||
|
||||
// skip an empty byte
|
||||
parser.get_next_byte(tape, is_fast);
|
||||
|
|
@ -72,7 +72,7 @@ std::list<File> StaticAnalyser::Oric::GetFiles(const std::shared_ptr<Storage::Ta
|
|||
size_t body_length = new_file.ending_address - new_file.starting_address + 1;
|
||||
new_file.data.reserve(body_length);
|
||||
for(size_t c = 0; c < body_length; c++) {
|
||||
new_file.data.push_back((uint8_t)parser.get_next_byte(tape, is_fast));
|
||||
new_file.data.push_back(static_cast<uint8_t>(parser.get_next_byte(tape, is_fast)));
|
||||
}
|
||||
|
||||
// only one validation check: was there enough tape?
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@
|
|||
using namespace Storage::Data::ZX8081;
|
||||
|
||||
static uint16_t short_at(size_t address, const std::vector<uint8_t> &data) {
|
||||
return (uint16_t)(data[address] | (data[address + 1] << 8));
|
||||
return static_cast<uint16_t>(data[address] | (data[address + 1] << 8));
|
||||
}
|
||||
|
||||
static std::shared_ptr<File> ZX80FileFromData(const std::vector<uint8_t> &data) {
|
||||
|
|
|
|||
|
|
@ -76,8 +76,8 @@ std::shared_ptr<Track> CPCDSK::get_track_at_position(Track::Address address) {
|
|||
// Grab the track information.
|
||||
fseek(file_, 5, SEEK_CUR); // skip track number, side number, sector size — each is given per sector
|
||||
int number_of_sectors = fgetc(file_);
|
||||
uint8_t gap3_length = (uint8_t)fgetc(file_);
|
||||
uint8_t filler_byte = (uint8_t)fgetc(file_);
|
||||
uint8_t gap3_length = static_cast<uint8_t>(fgetc(file_));
|
||||
uint8_t filler_byte = static_cast<uint8_t>(fgetc(file_));
|
||||
|
||||
// Grab the sector information
|
||||
struct SectorInfo {
|
||||
|
|
@ -93,12 +93,12 @@ std::shared_ptr<Track> CPCDSK::get_track_at_position(Track::Address address) {
|
|||
while(number_of_sectors--) {
|
||||
SectorInfo sector_info;
|
||||
|
||||
sector_info.track = (uint8_t)fgetc(file_);
|
||||
sector_info.side = (uint8_t)fgetc(file_);
|
||||
sector_info.sector = (uint8_t)fgetc(file_);
|
||||
sector_info.length = (uint8_t)fgetc(file_);
|
||||
sector_info.status1 = (uint8_t)fgetc(file_);
|
||||
sector_info.status2 = (uint8_t)fgetc(file_);
|
||||
sector_info.track = static_cast<uint8_t>(fgetc(file_));
|
||||
sector_info.side = static_cast<uint8_t>(fgetc(file_));
|
||||
sector_info.sector = static_cast<uint8_t>(fgetc(file_));
|
||||
sector_info.length = static_cast<uint8_t>(fgetc(file_));
|
||||
sector_info.status1 = static_cast<uint8_t>(fgetc(file_));
|
||||
sector_info.status2 = static_cast<uint8_t>(fgetc(file_));
|
||||
sector_info.actual_length = fgetc16le();
|
||||
|
||||
sector_infos.push_back(sector_info);
|
||||
|
|
|
|||
|
|
@ -30,7 +30,7 @@ D64::D64(const char *file_name) :
|
|||
disk_id_ = 0;
|
||||
while(*file_name) {
|
||||
disk_id_ ^= file_name[0];
|
||||
disk_id_ = (uint16_t)((disk_id_ << 2) ^ (disk_id_ >> 13));
|
||||
disk_id_ = static_cast<uint16_t>((disk_id_ << 2) ^ (disk_id_ >> 13));
|
||||
file_name++;
|
||||
}
|
||||
}
|
||||
|
|
@ -95,16 +95,16 @@ std::shared_ptr<Track> D64::get_track_at_position(Track::Address address) {
|
|||
uint8_t *sector_data = &data[sector * 349];
|
||||
sector_data[0] = sector_data[1] = sector_data[2] = 0xff;
|
||||
|
||||
uint8_t sector_number = (uint8_t)(sector); // sectors count from 0
|
||||
uint8_t track_number = (uint8_t)((address.position >> 1) + 1); // tracks count from 1
|
||||
uint8_t checksum = (uint8_t)(sector_number ^ track_number ^ disk_id_ ^ (disk_id_ >> 8));
|
||||
uint8_t sector_number = static_cast<uint8_t>(sector); // sectors count from 0
|
||||
uint8_t track_number = static_cast<uint8_t>((address.position >> 1) + 1); // tracks count from 1
|
||||
uint8_t checksum = static_cast<uint8_t>(sector_number ^ track_number ^ disk_id_ ^ (disk_id_ >> 8));
|
||||
uint8_t header_start[4] = {
|
||||
0x08, checksum, sector_number, track_number
|
||||
};
|
||||
Encodings::CommodoreGCR::encode_block(§or_data[3], header_start);
|
||||
|
||||
uint8_t header_end[4] = {
|
||||
(uint8_t)(disk_id_ & 0xff), (uint8_t)(disk_id_ >> 8), 0, 0
|
||||
static_cast<uint8_t>(disk_id_ & 0xff), static_cast<uint8_t>(disk_id_ >> 8), 0, 0
|
||||
};
|
||||
Encodings::CommodoreGCR::encode_block(§or_data[8], header_end);
|
||||
|
||||
|
|
|
|||
|
|
@ -69,7 +69,7 @@ std::shared_ptr<Track> HFE::get_track_at_position(Track::Address address) {
|
|||
|
||||
uint16_t c = 0;
|
||||
while(c < track_length) {
|
||||
uint16_t length = (uint16_t)std::min(256, track_length - c);
|
||||
uint16_t length = static_cast<uint16_t>(std::min(256, track_length - c));
|
||||
fread(&segment.data[c], 1, length, file_);
|
||||
c += length;
|
||||
fseek(file_, 256, SEEK_CUR);
|
||||
|
|
@ -99,7 +99,7 @@ void HFE::set_tracks(const std::map<Track::Address, std::shared_ptr<Track>> &tra
|
|||
|
||||
uint16_t c = 0;
|
||||
while(c < data_length) {
|
||||
uint16_t length = (uint16_t)std::min(256, data_length - c);
|
||||
uint16_t length = static_cast<uint16_t>(std::min(256, data_length - c));
|
||||
fwrite(&segment.data[c], 1, length, file_);
|
||||
c += length;
|
||||
fseek(file_, 256, SEEK_CUR);
|
||||
|
|
|
|||
|
|
@ -23,7 +23,7 @@ class MFMEncoder: public Encoder {
|
|||
void add_byte(uint8_t input) {
|
||||
crc_generator_.add(input);
|
||||
uint16_t spread_value =
|
||||
(uint16_t)(
|
||||
static_cast<uint16_t>(
|
||||
((input & 0x01) << 0) |
|
||||
((input & 0x02) << 1) |
|
||||
((input & 0x04) << 2) |
|
||||
|
|
@ -33,7 +33,7 @@ class MFMEncoder: public Encoder {
|
|||
((input & 0x40) << 6) |
|
||||
((input & 0x80) << 7)
|
||||
);
|
||||
uint16_t or_bits = (uint16_t)((spread_value << 1) | (spread_value >> 1) | (last_output_ << 15));
|
||||
uint16_t or_bits = static_cast<uint16_t>((spread_value << 1) | (spread_value >> 1) | (last_output_ << 15));
|
||||
uint16_t output = spread_value | ((~or_bits) & 0xaaaa);
|
||||
output_short(output);
|
||||
}
|
||||
|
|
@ -79,7 +79,7 @@ class FMEncoder: public Encoder {
|
|||
void add_byte(uint8_t input) {
|
||||
crc_generator_.add(input);
|
||||
output_short(
|
||||
(uint16_t)(
|
||||
static_cast<uint16_t>(
|
||||
((input & 0x01) << 0) |
|
||||
((input & 0x02) << 1) |
|
||||
((input & 0x04) << 2) |
|
||||
|
|
|
|||
|
|
@ -55,8 +55,8 @@ uint32_t FileHolder::fgetc24le() {
|
|||
}
|
||||
|
||||
uint16_t FileHolder::fgetc16le() {
|
||||
uint16_t result = (uint16_t)fgetc(file_);
|
||||
result |= (uint16_t)(fgetc(file_) << 8);
|
||||
uint16_t result = static_cast<uint16_t>(fgetc(file_));
|
||||
result |= static_cast<uint16_t>(fgetc(file_) << 8);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
|
@ -71,8 +71,8 @@ uint32_t FileHolder::fgetc32be() {
|
|||
}
|
||||
|
||||
uint16_t FileHolder::fgetc16be() {
|
||||
uint16_t result = (uint16_t)(fgetc(file_) << 8);
|
||||
result |= (uint16_t)fgetc(file_);
|
||||
uint16_t result = static_cast<uint16_t>(fgetc(file_) << 8);
|
||||
result |= static_cast<uint16_t>(fgetc(file_));
|
||||
|
||||
return result;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -95,7 +95,7 @@ class FileHolder {
|
|||
uint8_t get_bits(int q) {
|
||||
uint8_t result = 0;
|
||||
while(q--) {
|
||||
result = (uint8_t)((result << 1) | get_bit());
|
||||
result = static_cast<uint8_t>((result << 1) | get_bit());
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
|
@ -109,7 +109,7 @@ class FileHolder {
|
|||
uint8_t get_bit() {
|
||||
if(!bits_remaining_) {
|
||||
bits_remaining_ = 8;
|
||||
next_value_ = (uint8_t)fgetc(file_);
|
||||
next_value_ = static_cast<uint8_t>(fgetc(file_));
|
||||
}
|
||||
|
||||
uint8_t bit;
|
||||
|
|
|
|||
|
|
@ -72,7 +72,7 @@ CSW::CSW(const char *file_name) :
|
|||
// uncompress will tell how many compressed bytes there actually were, so use its
|
||||
// modification of output_length to throw away all the memory that isn't actually
|
||||
// needed.
|
||||
uLongf output_length = (uLongf)(number_of_waves * 5);
|
||||
uLongf output_length = static_cast<uLongf>(number_of_waves * 5);
|
||||
uncompress(source_data_.data(), &output_length, file_data.data(), file_data.size());
|
||||
source_data_.resize((size_t)output_length);
|
||||
} else {
|
||||
|
|
|
|||
|
|
@ -71,9 +71,9 @@ Tape::Pulse OricTAP::virtual_get_next_pulse()
|
|||
// [9...]: filename, up to NULL byte
|
||||
next_byte = static_cast<uint8_t>(fgetc(file_));
|
||||
|
||||
if(phase_counter_ == 4) data_end_address_ = (uint16_t)(next_byte << 8);
|
||||
if(phase_counter_ == 4) data_end_address_ = static_cast<uint16_t>(next_byte << 8);
|
||||
if(phase_counter_ == 5) data_end_address_ |= next_byte;
|
||||
if(phase_counter_ == 6) data_start_address_ = (uint16_t)(next_byte << 8);
|
||||
if(phase_counter_ == 6) data_start_address_ = static_cast<uint16_t>(next_byte << 8);
|
||||
if(phase_counter_ == 7) data_start_address_ |= next_byte;
|
||||
|
||||
if(phase_counter_ >= 9 && !next_byte) // advance after the filename-ending NULL byte
|
||||
|
|
@ -119,7 +119,7 @@ Tape::Pulse OricTAP::virtual_get_next_pulse()
|
|||
parity ^= (parity >> 4);
|
||||
parity ^= (parity >> 2);
|
||||
parity ^= (parity >> 1);
|
||||
current_value_ = (uint16_t)(((uint16_t)next_byte << 1) | ((parity&1) << 9) | (7 << 10));
|
||||
current_value_ = static_cast<uint16_t>((static_cast<uint16_t>(next_byte) << 1) | ((parity&1) << 9) | (7 << 10));
|
||||
}
|
||||
|
||||
// In slow mode, a 0 is 4 periods of 1200 Hz, a 1 is 8 periods at 2400 Hz.
|
||||
|
|
|
|||
|
|
@ -61,7 +61,7 @@ PRG::PRG(const char *file_name) :
|
|||
throw ErrorBadFormat;
|
||||
|
||||
load_address_ = fgetc16le();
|
||||
length_ = (uint16_t)(file_stats_.st_size - 2);
|
||||
length_ = static_cast<uint16_t>(file_stats_.st_size - 2);
|
||||
|
||||
if (load_address_ + length_ >= 65536)
|
||||
throw ErrorBadFormat;
|
||||
|
|
|
|||
|
|
@ -105,7 +105,7 @@ void UEF::virtual_reset() {
|
|||
#pragma mark - Chunk navigator
|
||||
|
||||
bool UEF::get_next_chunk(UEF::Chunk &result) {
|
||||
uint16_t chunk_id = (uint16_t)gzget16(file_);
|
||||
uint16_t chunk_id = static_cast<uint16_t>(gzget16(file_));
|
||||
uint32_t chunk_length = (uint32_t)gzget32(file_);
|
||||
z_off_t start_of_next_chunk = gztell(file_) + chunk_length;
|
||||
|
||||
|
|
|
|||
|
|
@ -105,8 +105,8 @@ std::unique_ptr<Header> Parser::get_next_header_body(const std::shared_ptr<Stora
|
|||
// parse if this is not pure data
|
||||
if(header->type != Header::DataBlock)
|
||||
{
|
||||
header->starting_address = (uint16_t)(header->data[0] | (header->data[1] << 8));
|
||||
header->ending_address = (uint16_t)(header->data[2] | (header->data[3] << 8));
|
||||
header->starting_address = static_cast<uint16_t>(header->data[0] | (header->data[1] << 8));
|
||||
header->ending_address = static_cast<uint16_t>(header->data[2] | (header->data[3] << 8));
|
||||
|
||||
for(size_t c = 0; c < 16; c++)
|
||||
{
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user