| uint8_t rom[0x2000]; | |
| uint8_t regs[0x80]; | |
| void *capture_func = &capture_mux0; | |
| uint16_t debug_coils[2];// 12/13, 14/15 | |
| uint8_t mux0_count_l; // 20 | |
| uint8_t mux0_count_h; // 21 | |
| uint8_t mux1_count_l; // 22 | |
| uint8_t mux1_count_h; // 23 | |
| uint8_t mux2_count_l; // 24 | |
| uint8_t mux2_count_h; // 25 | |
| uint8_t mux3_count_l; // 26 | |
| uint8_t mux3_count_h; // 27 | |
| uint8_t *mux_buf_ptr; // 2F | |
| uint16_t sio_func; // 34/35 | |
| uint8_t recv_buf[8]; // 40..47 | |
| uint8_t *recv_buf_start;// 48 | |
| uint8_t *recv_buf_cur; // 49 | |
| uint8_t recv_val; // 4B | |
| uint8_t mux_buf[8]; // 58 | |
| // "20/08/87" | |
| static const uint8_t data_090A[8] = { 0x32, 0x30, 0x2F, 0x30, 0x38, 0x2F, 0x38, 0xB7 }; | |
| // "A3>" | |
| static const uint8_t data_103F[3] = { 0x41, 0x33, 0xBE }; | |
| // "Syntax Error" | |
| static const uint8_t data_105D[12] = { 0x53, 0x79, 0x6E, 0x74, 0x61, 0x78, 0x20, 0x45, 0x72, 0x72, 0x6F, 0xF2 }; | |
| // "Argument Error" | |
| static const uint8_t data_106E[14] = { 0x41, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x45, 0x72, 0x72, 0x6F, 0xF2 }; | |
| // "Command Error" | |
| static const uint8_t data_10ED[13] = { 0x43, 0x6F, 0x6D, 0x6D, 0x61, 0x6E, 0x64, 0x20, 0x45, 0x72, 0x72, 0x6F, 0xF2 }; | |
| // "Connect Phase Box " | |
| static const uint8_t data_12C9[18] = { 0x43, 0x6F, 0x6E, 0x6E, 0x65, 0x63, 0x74, 0x20, 0x50, 0x68, 0x61, 0x73, 0x65, 0x20, 0x42, 0x6F, 0x78, 0xA0 }; | |
| // "Adjust VR1" | |
| static const uint8_t data_131E[10] = { 0x41, 0x64, 0x6A, 0x75, 0x73, 0x74, 0x20, 0x56, 0x52, 0xB1 }; | |
| // "21" | |
| static const uint8_t data_132F[2] = { 0x32, 0xB1 }; | |
| // "03" | |
| static const uint8_t data_1336[2] = { 0x30, 0xB3 }; | |
| // "Adjust VR1" | |
| static const uint8_t data_13BF[10] = { 0x41, 0x64, 0x6A, 0x75, 0x73, 0x74, 0x20, 0x56, 0x52, 0xB1 }; | |
| // "27" | |
| static const uint8_t data_13D0[2] = { 0x32, 0xB7 }; | |
| // "09" | |
| static const uint8_t data_13D7[2] = { 0x30, 0xB9 }; | |
| // "Adjust VR1" | |
| static const uint8_t data_13E4[10] = { 0x41, 0x64, 0x6A, 0x75, 0x73, 0x74, 0x20, 0x56, 0x52, 0xB1 }; | |
| // "29" | |
| static const uint8_t data_13F5[2] = { 0x32, 0xB9 }; | |
| // "11" | |
| static const uint8_t data_13FC[2] = { 0x31, 0xB1 }; | |
| // "\x0DFailed\x0D" | |
| static const uint8_t data_1411[8] = { 0x0D, 0x46, 0x61, 0x69, 0x6C, 0x65, 0x64, 0x8D }; | |
| // " - Hit Any Key When Correct\x0D" | |
| static const uint8_t data_142C[28] = { 0x20, 0x2D, 0x20, 0x48, 0x69, 0x74, 0x20, 0x41, 0x6E, 0x79, 0x20, 0x4B, 0x65, 0x79, 0x20, 0x57, 0x68, 0x65, 0x6E, 0x20, 0x43, 0x6F, 0x72, 0x72, 0x65, 0x63, 0x74, 0x8D }; | |
| // "F BGYR PROX C/S\x0D" | |
| static const uint8_t data_14FB[16] = { 0x46, 0x20, 0x42, 0x47, 0x59, 0x52, 0x20, 0x50, 0x52, 0x4F, 0x58, 0x20, 0x43, 0x2F, 0x53, 0x8D }; | |
| // "*\x0D" | |
| static const uint8_t data_164A[2] = { 0x2A, 0x8D }; | |
| #define METRIC (regs[0x1F] & 0x04) | |
| #define DIPS_HI regs[0x7E] | |
| #define DIPS_LO regs[0x7F] | |
| // 0030 | |
| static const uint16_t s_unk_tbl[4] = { | |
| 0x03F9, 0x03F6, 0x040B, 0x040F | |
| }; | |
| // 0048 | |
| static const uint8_t s_baud_rates[8] = { | |
| 0xAF, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 | |
| }; | |
| void boot() | |
| { | |
| // ... | |
| test_regs(); | |
| checksum_rom(); | |
| read_dips(); | |
| T0 = s_baud_rates[DIPS_LO & 0x07]; | |
| if (DIPS_LO & 0x80) | |
| { | |
| // 078 | |
| regs[0x1F] |= 0x02; | |
| if (DIPS_LO & 0x08) | |
| { | |
| // 080 | |
| P2 |= 0x01; | |
| } | |
| // 083 | |
| while (true) | |
| { | |
| call_048E(); | |
| if (regs[0x62] == 0xFF) | |
| { | |
| regs[0x1B] = DIPS_HI & 0xF8; | |
| if (regs[0x1B] == 0x78) | |
| { | |
| // 097 | |
| if (regs[0x66] == 0) | |
| { | |
| call_01AE(); | |
| } | |
| } | |
| else if (regs[0x1B] == 0xB8) | |
| { | |
| if (regs[0x66] == 0) | |
| { | |
| call_01D2(); | |
| } | |
| } | |
| else if (regs[0x1B] != 0xF8) | |
| { | |
| break; | |
| } | |
| } | |
| // 0AE | |
| read_dips(); | |
| } | |
| } | |
| // 0B8 | |
| if (!(DIPS_LO & 0x20)) | |
| { | |
| // 0BD | |
| regs[0x1F] |= 0xA0; | |
| if (!(DIPS_LO & 0x40)) | |
| { | |
| // 0C5 | |
| regs[0x1F] |= 0x10; | |
| } | |
| } | |
| // 0C8 | |
| if (regs[0x1F] & 0x02) | |
| { | |
| sio_func = s_unk_tbl[2]; | |
| } | |
| else | |
| { | |
| sio_func = s_unk_tbl[(DIPS_LO >> 3) & 0x03]; | |
| } | |
| if (DIPS_HI & 0x01) | |
| { | |
| set_imperial(); | |
| } | |
| else | |
| { | |
| set_metric(); | |
| } | |
| // 0F5 | |
| if (DIPS_HI & 0x02) | |
| { | |
| regs[0x1F] |= 0x08; | |
| } | |
| // 0FD | |
| regs[0x38] = (DIPS_HI >> 3) & 0x03; | |
| regs[0x1B] = DIPS_HI >> 5; | |
| init_polling(); | |
| // 110 | |
| if ((regs[0x1B] & 0x07) == 0 && (regs[0x38] == 3 || regs[0x38] == 0)) | |
| { | |
| // 11A | |
| regs[0x4F] |= 0x10; | |
| TMR = 0x07; | |
| } | |
| else | |
| { | |
| // 127 | |
| TMR = 0x0F; | |
| } | |
| // 12A | |
| regs[0x4F] |= 0x01; | |
| recv_buf_start = recv_buf; | |
| recv_buf_cur = recv_buf; | |
| regs[0x33] = 0x05; | |
| regs[0x2E] = 0x04; | |
| regs[0x28] = 0x02; | |
| regs[0x29] = 0x1D; | |
| regs[0x60] = 0x2C; | |
| call_0BA6(); | |
| call_01E8(); | |
| enable_interrupts(); | |
| main_loop(); | |
| } | |
| // 14C | |
| void read_dips() | |
| { | |
| // TODO; reads dips into DIPS_HI and DIPS_LO | |
| } | |
| // 0038 | |
| static s_timing_table1[8] = { | |
| 0x48, 0x60, 0xC0, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4 | |
| }; | |
| // 0040 | |
| static s_timing_table2[8] = { | |
| 0x01, 0x01, 0x01, 0x02, 0x04, 0x08, 0x10, 0x50 | |
| }; | |
| // 173 | |
| void init_polling() | |
| { | |
| T1 = s_timing_table1[regs[0x1B] & 7]; | |
| regs[0x39] = s_timing_table2[regs[0x1B] & 7]; | |
| regs[0x3A] = s_timing_table2[regs[0x1B] & 7]; | |
| } | |
| // 18C | |
| void set_imperial() | |
| { | |
| P2 &= ~0x08; | |
| regs[0x1f] &= ~0x04; | |
| regs[0x53] = 0x06; | |
| regs[0x52] = 0x40; | |
| } | |
| // 19D | |
| void set_metric() | |
| { | |
| P2 |= 0x08; | |
| regs[0x1f] |= 0x04; | |
| regs[0x53] = 0x07; | |
| regs[0x52] = 0xF0; | |
| } | |
| // 1C5 | |
| void delay_50000_insns() | |
| { | |
| for (int i = 0x50000; i > 0; i--); | |
| } | |
| // 0209 | |
| static const uint8_t s_login_msg[9] = { | |
| 'L', 'O', 'G', 'I', 'N', ' ', 'A', 0x0D, 0xFF | |
| }; | |
| // 1E8 | |
| void call_01E8() | |
| { | |
| if (rom[0x1FFF] & 0x01) | |
| { | |
| return; | |
| } | |
| uint16_t addr = 0x0209; | |
| uint8_t reg = 0x04; | |
| uint8_t val; | |
| do | |
| { | |
| val = rom[addr++]; | |
| regs[reg++] = val; | |
| } while (val != 0xFF); | |
| transmit_byte(); | |
| } | |
| // 212 | |
| void capture_irq() | |
| { | |
| if (regs[0x2d]) | |
| { | |
| // 21B | |
| (*capture_func)(); | |
| } | |
| } | |
| // 021D | |
| void capture_mux0() | |
| { | |
| capture_rdl(); | |
| mux0_count_l = regs[0x2a]; | |
| capture_rdh(); | |
| mux0_count_h = regs[0x2b]; | |
| P2 |= 0x04; | |
| capture_func = &capture_mux2; | |
| P2 &= ~0x10; | |
| P2 |= 0x10; | |
| regs[0x2e] = 3; | |
| } | |
| // 0230 | |
| void capture_mux2() | |
| { | |
| if (regs[0x2e]) | |
| { | |
| P2 &= ~0x10; | |
| P2 |= 0x10; | |
| return; | |
| } | |
| capture_rdl(); | |
| mux2_count_l = regs[0x2a]; | |
| capture_rdh(); | |
| mux2_count_h = regs[0x2b]; | |
| P2 &= 0xf9; | |
| P2 |= 0x02; | |
| capture_func = &capture_mux1_prep; | |
| P2 &= ~0x10; | |
| P2 |= 0x10; | |
| regs[0x2e] = 3; | |
| } | |
| // 0248 | |
| void capture_mux1_prep() | |
| { | |
| if (--regs[0x2e]) | |
| { | |
| P2 &= ~0x10; | |
| P2 |= 0x10; | |
| return; | |
| } | |
| regs[0x2e] = 2; | |
| if (!(P2 & 0x40)) | |
| { | |
| regs[0x2e] = 4; | |
| } | |
| mux_buf_ptr = &mux_buf[0]; | |
| capture_func = &capture_mux1; | |
| capture_mux1(); | |
| } | |
| // 0264 | |
| void capture_mux1() | |
| { | |
| capture_rdl(); | |
| *mux_buf_ptr++ = regs[0x2a]; | |
| capture_rdh(); | |
| *mux_buf_ptr++ = regs[0x2b]; | |
| regs[0x2e]--; | |
| if (regs[0x2e]) | |
| { | |
| P2 &= ~0x10; | |
| P2 |= 0x10; | |
| return; | |
| } | |
| average_counts(); | |
| mux1_count_l = mux3_count_l; | |
| mux1_count_h = mux3_count_h; | |
| P2 &= 0xF9; | |
| P2 |= 0x06; | |
| capure_func = &capture_mux3_prep; | |
| P2 &= ~0x10; | |
| P2 |= 0x10; | |
| regs[0x2E] = 3; | |
| } | |
| // 0290 | |
| void capture_mux3_prep() | |
| { | |
| if (--regs[0x2e]) | |
| { | |
| P2 &= ~0x10; | |
| P2 |= 0x10; | |
| return; | |
| } | |
| regs[0x2e] = 2; | |
| if (!(P2 & 0x40)) | |
| { | |
| regs[0x2e] = 4; | |
| } | |
| mux_buf_ptr = &mux_buf[0]; | |
| capture_func = &capture_mux3; | |
| capture_mux3(); | |
| } | |
| // 2A1 | |
| void capture_mux3() | |
| { | |
| capture_rdl(); | |
| *mux_buf_ptr++ = regs[0x2a]; | |
| capture_rdh(); | |
| *mux_buf_ptr++ = regs[0x2b]; | |
| regs[0x2e]--; | |
| if (regs[0x2e]) | |
| { | |
| P2 &= ~0x10; | |
| P2 |= 0x10; | |
| return; | |
| } | |
| average_counts(); | |
| regs[0x2D] = 1; | |
| P2 &= 0xF9; | |
| capture_func = &capture_mux0; | |
| call_02C3(); | |
| P2 &= ~0x10; | |
| regs[0x2E] = 3; | |
| } | |
| // 2C3 | |
| void call_02C3() | |
| { | |
| if (METRIC) | |
| { | |
| // 2C8 | |
| mux1_count_l -= 0x44; | |
| mux1_count_h -C= 0x04; | |
| if (mux1_count_h < 0) | |
| { | |
| mux1_count_l += 0xF0; | |
| mux1_count_h +C= 0x07; | |
| } | |
| mux3_count_l -= 0x7F; | |
| mux3_count_h -C= 0x05; | |
| if (mux3_count_h < 0) | |
| { | |
| mux3_count_l += 0xF0; | |
| mux3_count_h +C= 0x07; | |
| } | |
| } | |
| else | |
| { | |
| // 2E5 | |
| mux1_count_l -= 0x5C; | |
| mux1_count_h -= 0x03; | |
| if (mux1_count_h < 0) | |
| { | |
| mux1_count_l += 0x40; | |
| mux1_count_h +C= 0x06; | |
| } | |
| mux3_count_l -= 0x54; | |
| mux3_count_h -C= 0x04; | |
| if (mux3_count_h < 0) | |
| { | |
| mux3_count_l += 0x40; | |
| mux3_count_h +C= 0x06; | |
| } | |
| } | |
| } | |
| // 302 | |
| void capture_rdl() | |
| { | |
| regs[0x2a] = RDL; | |
| } | |
| // 307 | |
| void capture_rdh() | |
| { | |
| regs[0x2b] = RDH & 0x0f; | |
| } | |
| // 030F | |
| void average_counts() | |
| { | |
| mux_buf_ptr = &mux_buf[0]; | |
| regs[0x2e] = 1; | |
| if (!(P2 & 0x40)) | |
| { | |
| regs[0x2e] = 3; | |
| } | |
| mux3_count_l = *mux_buf_ptr++; | |
| mux3_count_h = *mux_buf_ptr; | |
| regs[0x2c] = *mux_buf_ptr++; | |
| do | |
| { | |
| mux3_count_l += *mux_buf_ptr++; | |
| mux3_count_h +C= *mux_buf_ptr; | |
| regs[0x2b] = *mux_buf_ptr++; | |
| regs[0x2b] -= regs[0x2c]; | |
| if (!(regs[0x2b] & 0x80)) | |
| { | |
| // 332 | |
| if (METRIC) | |
| { | |
| // 337 | |
| if (regs[0x2B] < 0x04) | |
| { | |
| continue; | |
| } | |
| mux3_count_l -= 0xF0; | |
| mux3_count_h -C= 0x07; | |
| continue; | |
| } | |
| else | |
| { | |
| // 344 | |
| if (regs[0x2B] < 0x03) | |
| { | |
| continue; | |
| } | |
| mux3_count_l -= 0x40; | |
| mux3_count_h -C= 0x06; | |
| continue; | |
| } | |
| } | |
| else | |
| { | |
| // 351 | |
| if (METRIC) | |
| { | |
| // 356 | |
| if (regs[0x2B] >= 0xFC) | |
| { | |
| continue; | |
| } | |
| mux3_count_l += 0xF0; | |
| mux3_count_h +C= 0x07; | |
| continue; | |
| } | |
| else | |
| { | |
| // 363 | |
| if (rgs[0x2B] >= 0xFD) | |
| { | |
| continue; | |
| } | |
| mux3_count_l += 0x40; | |
| mux3_count_h +C= 0x06; | |
| } | |
| } | |
| } while (--regs[0x2e] > 0); | |
| mux3_count_h >>= 1; | |
| mux3_count_l >>C= 1; | |
| if (!(P2 & 0x40)) | |
| { | |
| mux3_count_h >>= 1; | |
| mux3_count_l >>C= 1; | |
| } | |
| // 37D | |
| if (METRIC) | |
| { | |
| // 382 | |
| mux3_count_l += 0xF0; | |
| mux3_count_h +C= 0x07; | |
| do | |
| { | |
| mux3_count_l -= 0xF0; | |
| mux3_count_h -C= 0x07; | |
| } while (mux3_count_h >= 0); | |
| mux3_count_l += 0xF0; | |
| mux3_count_h +C= 0x07; | |
| } | |
| else | |
| { | |
| // 397 | |
| mux3_count_l += 0x40; | |
| mux3_count_h +C= 0x06; | |
| do | |
| { | |
| mux3_count_l -= 0x40; | |
| mux3_count_h -C= 0x06; | |
| } while (mux3_count_h >= 0); | |
| mux3_count_l += 0x40; | |
| mux3_count_h +C= 0x06; | |
| } | |
| } | |
| // 3AC | |
| void transmit_complete_irq() | |
| { | |
| regs[0x61] &= ~0x04; | |
| // RP = 0x30 | |
| if (!(regs[0x4F] & 0x08)) | |
| { | |
| // 3B8 | |
| regs[0x4F] |= 0x01; | |
| regs[0x33] = 0x05; | |
| return; | |
| } | |
| // 3C0 | |
| if (regs[0x4F] & 0x80) | |
| { | |
| // 3F3 | |
| return; | |
| } | |
| // 3C5 | |
| uint8_t buf_val = regs[regs[0x33]]; // 0x39 | |
| // 3C9 | |
| if (buf_val >= 0xFE) | |
| { | |
| // 3CE | |
| if (buf_val == 0xFE) | |
| { | |
| // 3D0 | |
| regs[0x2D] = 0x01; | |
| regs[0x3A] = 0; | |
| } | |
| // 3D7 | |
| regs[0x4F] &= ~0x08; | |
| regs[0x4F] |= 0x01; | |
| regs[0x33] = 0x05; | |
| return; | |
| } | |
| // 3DC | |
| handle_parity(&buf_val); | |
| disable_interrupts(); | |
| while (P3 & 0x02) | |
| { | |
| // 3E4 | |
| regs[0x2D] = 0; | |
| regs[0x3F] = 0; | |
| } | |
| // 3EA | |
| regs[0x61] |= 0x04; | |
| SIO = buf_val; | |
| regs[0x33]++; | |
| } | |
| // 3F6 | |
| void handle_parity(uint8_t *buf_val) | |
| { | |
| switch (sio_func) | |
| { | |
| case 0: // 3F9 - Odd Parity | |
| case 1: // 3F6 - Even Parity | |
| { | |
| uint8_t parity_bit = sio_func ? 0x00 : 0x80; | |
| for (int i = 0x07; i > 0; i--) | |
| { | |
| if (*buf_val & (1 << i)) | |
| { | |
| parity_bit ^= 0x80; | |
| } | |
| } | |
| *buf_val |= parity_bit; | |
| break; | |
| } | |
| case 2: // 40B - 0 Parity | |
| *buf_val &= 0x7F; | |
| break; | |
| case 3: // 40F - 1 Parity | |
| *buf_val |= 0x80; | |
| break; | |
| } | |
| } | |
| // 48E | |
| void call_048E() | |
| { | |
| regs[0x30] = 0x10; | |
| regs[0x62] = DO07; | |
| } | |
| // 4E1 | |
| void main_loop() | |
| { | |
| while (true) | |
| { | |
| enable_interrupts(); | |
| regs[0x1F] &= ~0x01; | |
| // 4E5 | |
| if (!(P2 & 0x40)) | |
| { | |
| // 4EA | |
| regs[0x1F] |= 0x01; | |
| } | |
| // 4ED | |
| if (!(P2 & 0x20)) | |
| { | |
| // 4F2 | |
| if (regs[0x4F] & 0x01) | |
| { | |
| // 4F7 | |
| P3 &= ~0x20; | |
| } | |
| else | |
| { | |
| // 4FC | |
| P3 |= 0x20; | |
| } | |
| // 52D | |
| // RP = 0x30 | |
| regs[0x3E] = regs[0x3D]; | |
| regs[0x67]--; | |
| if (regs[0x67] == 0) | |
| { | |
| // 537 | |
| regs[0x67] = 0x40; | |
| regs[0x32] = 0x60; | |
| disable_interrupts(); | |
| regs[0x30] = ~(RDH >> 4); | |
| if (DIPS_HI & 0x04) | |
| { | |
| regs[0x31] = regs[0x30]; | |
| regs[0x30] &= 0x05; | |
| if (regs[0x31] & 0x02) | |
| { | |
| regs[0x30] |= 0x80; | |
| } | |
| if (regs[0x31] & 0x08) | |
| { | |
| regs[0x30] |= 0x02; | |
| } | |
| } | |
| // 55D | |
| regs[0x30] &= 0x0F; | |
| if (regs[0x30] == regs[0x3B] && | |
| regs[0x30] == regs[0x3C]) | |
| { | |
| // 568 | |
| regs[0x3D] = regs[0x30]; | |
| regs[0x3C] = regs[0x3B]; | |
| regs[0x3B] = regs[0x30]; | |
| enable_interrupts(); | |
| } | |
| } | |
| // 56F | |
| if (regs[0x3D] != 0) | |
| { | |
| // 573 | |
| regs[0x3F] = regs[0x3D]; | |
| if (regs[0x3A] != 0) | |
| { | |
| // 579 | |
| if (regs[0x38] & 0x02) | |
| { | |
| continue; | |
| } | |
| // 57F | |
| if (regs[0x3E] != 0) | |
| { | |
| continue; | |
| } | |
| // 584 | |
| if (!(regs[0x38] & 0x01)) | |
| { | |
| TMR |= 0x04; | |
| } | |
| regs[0x3A] = 0; | |
| } | |
| } | |
| else | |
| { | |
| // 590 | |
| if (regs[0x3E] != 0 && !(regs[0x38] & 0x04)) | |
| { | |
| // 599 | |
| regs[0x3F] = 0; | |
| continue; | |
| } | |
| // 5A1 | |
| if (regs[0x3A] != 0) | |
| { | |
| continue; | |
| } | |
| } | |
| // 5A6 | |
| if (regs[0x2D] & 0x80) | |
| { | |
| continue; | |
| } | |
| // Fall through to 5AC | |
| } | |
| else | |
| { | |
| // 501 | |
| P3 |= 0x20; | |
| regs[0x2D] = 0; | |
| if (regs[0x38] != 0x03) | |
| { | |
| regs[0x3B] = 0; | |
| regs[0x3C] = 0; | |
| regs[0x3D] = 0; | |
| regs[0x3E] = 0; | |
| regs[0x3F] = 0; | |
| continue; | |
| } | |
| // 518 | |
| if (regs[0x3A] != 0) | |
| { | |
| continue; | |
| } | |
| // 51E | |
| if (!(regs[0x4F] & 0x01)) | |
| { | |
| continue; | |
| } | |
| // 524 | |
| if (regs[0x4F] & 0x80) | |
| { | |
| continue; | |
| } | |
| // 5D5 | |
| goto 5D5; | |
| } | |
| // 5AC | |
| if (regs[0x2D]) | |
| { | |
| // 5B8 | |
| if (!(regs[0x4F] & 0x01)) | |
| continue; | |
| if (regs[0x4F] & 0x80) | |
| continue; | |
| regs[0x2D] = 0; | |
| // 5C4 | |
| if (regs[0x61] & 0x01) | |
| { | |
| // 604 | |
| regs[0x3A] = regs[0x39]; | |
| if (regs[0x38] == 0x02 && regs[0x7E] < 0x40) | |
| { | |
| // 611 | |
| regs[0x3A] = 0; | |
| } | |
| // 613 | |
| regs[0x3F] = 0; | |
| // 617 | |
| // RP = 0x40 | |
| if (regs[0x61] & 0x80) | |
| { | |
| // 64B | |
| call_1013(); | |
| goto 690; | |
| } | |
| else | |
| { | |
| // 61C | |
| while (fetch_from_recv_buf()) | |
| { | |
| // 621 | |
| if (recv_val == 0x12) | |
| { | |
| // 626 | |
| regs[0x61] &= ~0x20; | |
| regs[0x4F] |= 0x10; | |
| regs[0x4E] = 0; | |
| } | |
| else if (regs[0x61] & 0x20) | |
| { | |
| // Fall through to 690 | |
| } | |
| else if (recv_val == 0x14) | |
| { | |
| // 63A | |
| regs[0x61] |= 0x20; | |
| } | |
| else if (recv_val == 0x1B) | |
| { | |
| // 644 | |
| regs[0x4E] = 0x01; | |
| regs[0x4D] = 0; | |
| } | |
| else if (regs[0x4E] != 0) | |
| { | |
| // 655 | |
| call_0784(); | |
| } | |
| else if (recv_val == 0x54) | |
| { | |
| // 65F | |
| call_1C0A(); | |
| } | |
| else if (recv_val == 052) | |
| { | |
| // 669 | |
| call_1C8C(); | |
| break; | |
| } | |
| else if (regs[0x4F] & 0x10) | |
| { | |
| // 675 | |
| if (recv_val == 0x53) | |
| { | |
| // 67A | |
| while (!fetch_from_recv_buf()); | |
| continue; | |
| } | |
| else if (recv_val == 0x50) | |
| { | |
| TMR &= ~0x08; | |
| regs[0x3A]++; | |
| regs[0x38] = 0; | |
| wait_for_switch_release(); | |
| } | |
| else if (recv_val >= 0x40 && recv_val <= 0x4F) | |
| { | |
| // 6A2 | |
| const uint8_t temp_4B = recv_val; | |
| recv_val ^= 0xFF; | |
| const uint8_t temp_i4B = recv_val; | |
| recv_val &= 0x0F; | |
| if (recv_val < 0x08) | |
| { | |
| // 6B0 | |
| recv_val = (recv_val << 5) & 0xE0; | |
| regs[0x7E] = recv_val | (regs[0x7E] & 0x1F); | |
| } | |
| // 6BD | |
| recv_val = temp_i4B; | |
| call_0173(); | |
| TMR |= 0x0C; | |
| regs[0x3F] = 0; | |
| regs[0x38] = 1; | |
| recv_val = temp_4B; | |
| if (recv_val & 0x08) | |
| { | |
| regs[0x38]++; | |
| } | |
| wait_for_switch_release(); | |
| } | |
| } | |
| // 690 | |
| if (!(regs[0x1F] & 0x20)) | |
| { | |
| // Return to beginning of function, 4E1 | |
| } | |
| else | |
| { | |
| } | |
| } | |
| } | |
| } | |
| else | |
| { | |
| call_0B4D(); | |
| if (regs[0x4F] & 0x04) | |
| { | |
| regs[0x3F] = 0; | |
| continue; | |
| } | |
| } | |
| // 5D5 | |
| P3 |= 0x20; | |
| regs[0x4F] |= 0x08; | |
| regs[0x4F] &= ~0x01; | |
| if (regs[0x1F] & 0x02) | |
| { | |
| goto 601; | |
| } | |
| else | |
| { | |
| // 5E3 | |
| // RP = 0x30 | |
| uint8_t buf_val = regs[0x04]; | |
| handle_parity(&buf_val); | |
| disable_interrupts(); | |
| // 5EC | |
| while (P3 & 0x02) | |
| { | |
| regs[0x2D] = 0; | |
| regs[0x3F] = 0; | |
| } | |
| // 5F7 | |
| regs[0x61] |= 0x04; | |
| SIO = buf_val; | |
| enable_interrupts(); | |
| goto 604; | |
| } | |
| } | |
| else | |
| { | |
| // 5AE | |
| regs[0x2D]--; | |
| P2 &= 0xE9; | |
| P2 |= 0x10; | |
| continue; | |
| } | |
| } | |
| } | |
| // 0756 | |
| void wait_for_switch_release() | |
| { | |
| do | |
| { | |
| regs[0x30] = (~RDH) & 0xF0; | |
| } while (regs[0x30]); | |
| regs[0x3B] = 0; | |
| regs[0x3C] = 0; | |
| regs[0x3D] = 0; | |
| regs[0x3E] = 0; | |
| regs[0x3F] = 0; | |
| } | |
| // 0772 | |
| bool fetch_from_recv_buf() | |
| { | |
| if (recv_buf_start == recv_buf_cur) | |
| return false; | |
| recv_val = *recv_buf_cur++; | |
| recv_buf_cur &= 0xF7; | |
| return true; | |
| } | |
| // 0784 | |
| void call_0784() | |
| { | |
| regs[0x4E]++; | |
| if (regs[0x4D] == 0) | |
| { | |
| regs[0x4D] = recv_val; | |
| } | |
| recv_val = regs[0x4D]; | |
| if (recv_val == 'M') | |
| { | |
| // 7D2 | |
| if (regs[0x4E] < 0x03) | |
| return; | |
| advance_receive_buf(); | |
| if (regs[0x4F] & 0x10) | |
| { | |
| // 7DF | |
| if (recv_val == '0') | |
| { | |
| // 7E4 | |
| regs[0x38] = 0x02; | |
| TMR |= 0x0C; | |
| regs[0x3F] = 0; | |
| } | |
| else if (recv_val == '1') | |
| { | |
| // 7F3 | |
| regs[0x38] = 0; | |
| TMR &= ~0x08; | |
| regs[0x3A]++; | |
| } | |
| else if (recv_val == '2') | |
| { | |
| // 801 | |
| regs[0x38] = 0x01; | |
| TMR |= 0x0C; | |
| regs[0x3F] = 0; | |
| } | |
| else if (recv_val == '3') | |
| { | |
| // 80B | |
| regs[0x38] = 0x03; | |
| TMR &= ~0x08; | |
| regs[0x3A]++; | |
| } | |
| else if (recv_val == '4') | |
| { | |
| // 815 | |
| regs[0x38] = 0x04; | |
| TMR |= 0x0C; | |
| regs[0x3F] = 0; | |
| } | |
| } | |
| if (recv_val == '8') | |
| { | |
| // 81F | |
| regs[0x4F] |= 0x10; | |
| } | |
| else if (recv_val == '9') | |
| { | |
| // 829 | |
| regs[0x4F] &= ~0x10; | |
| } | |
| else if (recv_val == 'D') | |
| { | |
| // 833 | |
| regs[0x61] |= 0x81; | |
| call_1020(); | |
| } | |
| } | |
| else if (recv_val == 'G') | |
| { | |
| // 8C0 | |
| if (regs[0x38] == 0x03) | |
| { | |
| // 8C5 | |
| regs[0x3F] = regs[0x3D]; | |
| regs[0x3A] = 0; | |
| } | |
| // 8BD | |
| regs[0x4E] = 0; | |
| return; | |
| } | |
| else if (regs[0x4F] & 0x10) | |
| { | |
| if (recv_val == 'C') | |
| { | |
| // 83F | |
| if (regs[0x4E] < 0x03) | |
| return; | |
| // 844 | |
| advance_receive_buf(); | |
| if (recv_val >= 0x30 && recv_val <= 0x33) | |
| { | |
| // 851 | |
| if (recv_val & 0x01) | |
| set_metric(); | |
| else | |
| set_imperial(); | |
| // 85E | |
| if (recv_val & 0x02) | |
| regs[0x1F] &= ~0x08; | |
| else | |
| regs[0x1F] |= 0x08; | |
| } | |
| } | |
| else if (recv_val == 'D') | |
| { | |
| // 86D | |
| if (regs[0x4E] < 0x03) | |
| return; | |
| // 872 | |
| advance_receive_buf(); | |
| regs[0x60] = recv_val; | |
| } | |
| else if (recv_val == 'E') | |
| { | |
| // 879 | |
| if (regs[0x4E] < 0x05) | |
| return; | |
| // 87E | |
| advance_receive_buf(); | |
| if (recv_val == '2') | |
| { | |
| // 886 | |
| fetch_from_recv_buf(); | |
| if (recv_val >= '0' && recv_val <= '2') | |
| { | |
| if (recv_val == '0') | |
| { | |
| // 88E | |
| regs[0x1F] &= ~0xA0; | |
| } | |
| else if (recv_val == '1') | |
| { | |
| // 898 | |
| regs[0x1F] &= ~0x40; | |
| regs[0x1F] |= 0xA0; | |
| } | |
| else if (recv_val == '2') | |
| { | |
| // 8A5 | |
| regs[0x1F] |= 0xC0; | |
| } | |
| // 8A8 | |
| fetch_from_recv_buf(); | |
| if (recv_val == '0') | |
| { | |
| // 8B0 | |
| regs[0x1F] &= ~0x10; | |
| } | |
| else if (recv_val == '1') | |
| { | |
| // 8BA | |
| regs[0x1F] |= 0x10; | |
| regs[0x4E] = 0; | |
| return; | |
| } | |
| else | |
| { | |
| // 8BD | |
| regs[0x4E] = 0; | |
| return; | |
| } | |
| } | |
| } | |
| } | |
| else if (recv_val == 'Q') | |
| { | |
| // 8CC | |
| if (regs[0x4E] < 0x03) | |
| return; | |
| // 8D1 | |
| advance_receive_buf(); | |
| if (recv_val == '2') | |
| { | |
| // 907 | |
| print_string(data_090A); | |
| goto 8F6; | |
| } | |
| else if (recv_val == '1') | |
| { | |
| // 8ED | |
| } | |
| else if (recv_val == '0') | |
| { | |
| // 8E3 | |
| } | |
| else | |
| { | |
| regs[0x4E] = 0; | |
| return; | |
| } | |
| } | |
| else if (recv_val == 'R') | |
| { | |
| // 914 | |
| } | |
| else if (recv_val == 'T') | |
| { | |
| // 966 | |
| } | |
| else if (recv_val == 'V') | |
| { | |
| // 96B | |
| } | |
| else if (recv_val == 'Z') | |
| { | |
| reset(); | |
| return; | |
| } | |
| } | |
| // 839 | |
| regs[0x4E] = 0; | |
| call_0756(); | |
| } | |
| // 0977 | |
| void advance_receive_buf() | |
| { | |
| recv_buf_cur -= regs[0x4E]; | |
| recv_buf_cur = recv_buf_start + ((recv_buf_cur + 2) & 7); | |
| fetch_from_recv_buf(); | |
| } | |
| // 0B4D | |
| void call_0B4D() | |
| { | |
| regs[0x4F] &= ~0x04; | |
| if (regs[0x4F] & 0x42) | |
| { | |
| // C47 | |
| if (regs[0x4F] & 0x02) | |
| { | |
| // C4C | |
| regs[0x4F] ^= 0x40; | |
| if (regs[0x4f] & 0x40) | |
| { | |
| goto B58; | |
| } | |
| } | |
| // C55 | |
| regs[0x59] = 0x04; | |
| regs[0x1F] |= 0x80; | |
| regs[0x58] = 0x20; | |
| call_0FE5(); | |
| regs[0x58] = 0x22; | |
| call_0FE5(); | |
| regs[0x58] = 0x24; | |
| call_0FE5(); | |
| regs[0x58] = 0x26; | |
| call_0FE5(); | |
| regs[0x59]--; | |
| if (!(regs[0x4F] & 0x02)) | |
| { | |
| goto BC4; | |
| } | |
| // C76 | |
| regs[0x59]++; | |
| regs[regs[0x59]] = regs[0x60]; | |
| regs[0x59]++; | |
| regs[regs[0x59]] = 0xFE; | |
| } | |
| else | |
| { | |
| // B58 | |
| regs[0x5A] = mux2_count_l; | |
| regs[0x5B] = mux2_count_h; | |
| regs[0x5C] = mux3_count_l; | |
| regs[0x5D] = mux3_count_h; | |
| regs[0x4F] |= 0x20; | |
| call_0D94(); | |
| // B66 | |
| if (!(regs[0x61] & 0x40)) | |
| { | |
| call_0CDF(); | |
| } | |
| // B6E | |
| regs[0x5E] = regs[0x5C]; | |
| regs[0x5F] = regs[0x5D]; | |
| // B72 | |
| regs[0x5A] = mux0_count_l; | |
| regs[0x5B] = mux0_count_h; | |
| regs[0x5C] = mux1_count_l; | |
| regs[0x5D] = mux1_count_h; | |
| regs[0x4F] &= ~0x20; | |
| call_0D94(); | |
| // B80 | |
| if (!(regs[0x61] & 0x40)) | |
| { | |
| call_0CDF(); | |
| } | |
| // B88 | |
| call_0C7F(); | |
| if (regs[0x1F] & 0x08) | |
| { | |
| // B90 | |
| regs[5D:5C] >>= 1; | |
| regs[5F:5E] >>= 1; | |
| } | |
| else | |
| { | |
| // B9A | |
| if (METRIC) | |
| { | |
| // B9F | |
| if (!(regs[0x1F] & 0x80)) | |
| { | |
| regs[5D:5C] >>= 1; | |
| regs[5F:5E] >>= 1; | |
| } | |
| } | |
| } | |
| call_0BA6(); | |
| } | |
| } | |
| // 0BA6 | |
| void call_0BA6() | |
| { | |
| // BA6 | |
| if (regs[0x38] == 3) | |
| { | |
| // BAB | |
| if (regs[0x4F] & 0x04) | |
| { | |
| regs[0x4F] &= ~0x04; | |
| return; | |
| } | |
| } | |
| // BB0 | |
| if (regs[0x1F] & 0x80) | |
| { | |
| // BB5 | |
| regs[0x58] = 0x5C; | |
| regs[0x59] = 0x04; | |
| call_0FE5(); | |
| call_0FE5(); | |
| regs[0x5A] = 0x3F; | |
| call_0D70(); | |
| // BC4 | |
| if (regs[0x1F] & 0x20) | |
| { | |
| // BC9 | |
| regs[regs[0x59]] = 0x0D; | |
| regs[0x59]++; | |
| } | |
| // BCD | |
| if (regs[0x1F] & 0x10) | |
| { | |
| regs[regs[0x59]] = 0x0A; | |
| regs[0x59]++; | |
| } | |
| // BD6 | |
| regs[regs[0x59]] = 0xFF; | |
| // BD9 | |
| if (regs[0x4F] & 0x42) | |
| { | |
| regs[0x4F] &= ~0x04; | |
| } | |
| return; | |
| } | |
| else | |
| { | |
| // BE2 | |
| regs[0x50] = 0x3F; | |
| uint8_t carry = 0; | |
| if (regs[0x5F] & 0x10) | |
| { | |
| // BEA | |
| carry = 1; | |
| } | |
| regs[0x50] = (regs[0x50] << 1) | carry; | |
| // BED | |
| carry = 0; | |
| if (regs[0x5D] & 0x10) | |
| { | |
| // BF3 | |
| carry = 1; | |
| } | |
| regs[0x50] = (regs[0x50] << 1) | carry; | |
| // BF6 | |
| if (regs[0x1F] & 0x02) | |
| { | |
| regs[0x50] |= 0x80; | |
| } | |
| else | |
| { | |
| regs[0x50] |= 0x40; | |
| } | |
| // C03 | |
| regs[0x04] = regs[0x50]; | |
| regs[0x50] = regs[0x5C] & 0x3F; | |
| regs[0x05] = regs[0x50]; | |
| // C17 | |
| regs[0x50] = (regs[0x5C] >> 6) & 3; | |
| regs[0x51] = (regs[0x5D] & 0x0F) << 2; | |
| regs[0x51] |= regs[0x50]; | |
| regs[0x06] = regs[0x51]; | |
| // C24 | |
| regs[0x50] = regs[0x5E] & 0x3F; | |
| regs[0x07] = regs[0x50]; | |
| // C2B | |
| regs[0x50] = (regs[0x5E] >> 6) & 3; | |
| regs[0x51] = (regs[0x5F] & 0x0F) << 2; | |
| regs[0x51] |= regs[0x50]; | |
| regs[0x08] = regs[0x51]; | |
| // C43 | |
| regs[0x09] = 0xFF; | |
| } | |
| } | |
| // 0C7F | |
| void call_0C7F() | |
| { | |
| if ((regs[0x4F] & 0x04) || (regs[0x1F] & 0x02)) | |
| { | |
| return; | |
| } | |
| regs[0x51] = regs[0x62]; | |
| regs[0x50] = regs[0x63]; | |
| regs[0x51] -= regs[0x5C]; | |
| regs[0x50] -C= regs[0x5D]; | |
| if (regs[0x50] < 0) | |
| { | |
| regs[0x50] ^= 0xFF; | |
| regs[0x51] ^= 0xFF; | |
| regs[50:51]++; | |
| } | |
| // C9B | |
| if (regs[0x50] != 0) | |
| { | |
| // CD6 | |
| regs[0x62] = regs[0x5C]; | |
| regs[0x63] = regs[0x5D]; | |
| regs[0x64] = regs[0x5E]; | |
| regs[0x65] = regs[0x5F]; | |
| return; | |
| } | |
| // C9F | |
| regs[0x50] = 0x03; | |
| if (P2 & 0x40) | |
| { | |
| regs[0x50] = 0x02; | |
| } | |
| // CA8 | |
| if (regs[0x51] >= regs[0x50]) | |
| { | |
| // CD6 | |
| regs[0x62] = regs[0x5C]; | |
| regs[0x63] = regs[0x5D]; | |
| regs[0x64] = regs[0x5E]; | |
| regs[0x65] = regs[0x5F]; | |
| return; | |
| } | |
| // CAC | |
| regs[0x51] = regs[0x64]; | |
| regs[0x50] = regs[0x65]; | |
| regs[0x51] -= regs[0x5E]; | |
| regs[0x50] -C= regs[0x5F]; | |
| if (regs[0x50] < 0) | |
| { | |
| regs[0x50] ^= 0xFF; | |
| regs[0x51] ^= 0xFF; | |
| regs[50:51]++; | |
| } | |
| // CBC | |
| if (regs[0x50] != 0) | |
| { | |
| // CD6 | |
| regs[0x62] = regs[0x5C]; | |
| regs[0x63] = regs[0x5D]; | |
| regs[0x64] = regs[0x5E]; | |
| regs[0x65] = regs[0x5F]; | |
| return; | |
| } | |
| // CC0 | |
| regs[0x50] = 0x03; | |
| if (P2 & 0x40) | |
| { | |
| regs[0x50] = 0x02; | |
| } | |
| // CC9 | |
| if (regs[0x51] >= regs[0x50]) | |
| { | |
| // CD6 | |
| regs[0x62] = regs[0x5C]; | |
| regs[0x63] = regs[0x5D]; | |
| regs[0x64] = regs[0x5E]; | |
| regs[0x65] = regs[0x5F]; | |
| return; | |
| } | |
| // CCD | |
| regs[0x5C] = regs[0x62]; | |
| regs[0x5D] = regs[0x63]; | |
| regs[0x5E] = regs[0x64]; | |
| regs[0x5F] = regs[0x65]; | |
| } | |
| // 0CDF | |
| void call_0CDF() | |
| { | |
| uint8_t tmp_5C = regs[0x5C]; | |
| uint8_t tmp_5D = regs[0x5D]; | |
| if (regs[0x1F] & 0x08) | |
| { | |
| if (METRIC) | |
| { | |
| // CED | |
| if (regs[0x4F] & 0x20) | |
| { | |
| // CFA | |
| regs[0x5C] -= 0xD1; | |
| regs[0x5D] -C= 0x17; | |
| } | |
| else | |
| { | |
| // CF2 | |
| regs[0x5C] -= 0xBD; | |
| regs[0x5D] -C= 0x21; | |
| } | |
| } | |
| else | |
| { | |
| // D08 | |
| if (regs[0x4F] & 0x20) | |
| { | |
| // D15 | |
| regs[0x5C] -= 0xC1; | |
| regs[0x5D] -C= 0x12; | |
| } | |
| else | |
| { | |
| // D0D | |
| regs[0x5C] -= 0x91; | |
| regs[0x5D] -C= 0x1A; | |
| } | |
| } | |
| } | |
| else | |
| { | |
| // D23 | |
| if (METRIC) | |
| { | |
| // D28 | |
| if (regs[0x4F] & 0x20) | |
| { | |
| // D35 | |
| regs[0x5C] -= 0xD1; | |
| regs[0x5D] -C= 0x17; | |
| } | |
| else | |
| { | |
| // D2D | |
| regs[0x5C] -= 0xBD; | |
| regs[0x5D] -C= 0x21; | |
| } | |
| } | |
| else | |
| { | |
| // D3F | |
| if (regs[0x4F] & 0x20) | |
| { | |
| // D4C | |
| regs[0x5C] -= 0xC1; | |
| regs[0x5D] -C= 0x12; | |
| } | |
| else | |
| { | |
| // D44 | |
| regs[0x5C] -= 0x91; | |
| regs[0x5D] -C= 0x1A; | |
| } | |
| } | |
| } | |
| if (regs[0x5D] >= 0) | |
| { | |
| regs[0x4F] |= 0x04; | |
| } | |
| } | |
| // 0D94 | |
| void call_0D94() | |
| { | |
| // 5A/5B contain the value to process | |
| uint8_t *rom_ptr1 = 0; // 58/59 | |
| uint8_t *rom_ptr2 = 0; // 56/57 | |
| if (regs[0x4F] & 0x20) | |
| { | |
| // D99 | |
| rom_ptr1 = (regs[0x1F] & 0x01) ? 0x0B48 : 0x0B09; | |
| if (METRIC) | |
| { | |
| // DAB | |
| rom_ptr2 = (regs[0x1F] & 0x01) ? 0x0B36 : 0x0AF7; | |
| regs[0x50] = 0xED; | |
| regs[0x51] = 0x02; | |
| regs[0x54] = 0xB3; | |
| regs[0x55] = 0x06; | |
| } | |
| else | |
| { | |
| // DC2 | |
| rom_ptr2 = (regs[0x1F] & 0x01) ? 0x0B1C : 0x0ADD; | |
| regs[0x50] = 0x4E; | |
| regs[0x51] = 0x02; | |
| regs[0x54] = 0x46; | |
| regs[0x55] = 0x05; | |
| } | |
| } | |
| else | |
| { | |
| // DD9 | |
| rom_ptr1 = (regs[0x1F] & 0x01) ? 0x0B42 : 0x0B03; | |
| if (METRIC) | |
| { | |
| // DEB | |
| rom_ptr2 = (regs[0x1F] & 0x01) ? 0x0B28 : 0x0AE9; | |
| regs[0x50] = 0x96; | |
| regs[0x51] = 0x01; | |
| regs[0x54] = 0x27; | |
| regs[0x55] = 0x06; | |
| } | |
| else | |
| { | |
| // E02 | |
| rom_ptr2 = (regs[0x1F] & 0x01) ? 0x0B0E : 0x0ACF; | |
| regs[0x50] = 0x40; | |
| regs[0x51] = 0x01; | |
| regs[0x54] = 0xD8; | |
| regs[0x55] = 0x04; | |
| } | |
| } | |
| // E17 | |
| regs[0x50] -= regs[0x5A]; | |
| regs[0x51] -C= regs[0x5B]; | |
| if (regs[0x51] < 0) | |
| { | |
| // E1D | |
| regs[0x54] -= regs[0x5A]; | |
| regs[0x55] -C= regs[0x5B]; | |
| if (regs[0x55] < 0 && !(regs[0x61] & 0x40)) | |
| { | |
| // E28 | |
| regs[0x4F] |= 0x04; | |
| } | |
| } | |
| else if (!(regs[0x61] & 0x40)) | |
| { | |
| regs[0x4F] |= 0x04; | |
| } | |
| // 0E2B | |
| regs[0x50] = 0; | |
| regs[0x51] = 0; | |
| regs[0x50] -= regs[0x52]; | |
| regs[0x51] -C= regs[0x53]; | |
| while (true) | |
| { | |
| regs[0x55] = *rom_ptr2++; | |
| regs[0x54] = *rom_ptr2; | |
| regs[0x54] -= regs[0x5a]; | |
| regs[0x55] -C= regs[0x5b]; | |
| if (regs[0x55] < 0) | |
| { | |
| rom_ptr2++; | |
| rom_ptr1++; | |
| regs[0x50] += regs[0x52]; | |
| regs[0x51] += regs[0x53]; | |
| } | |
| else | |
| { | |
| break; | |
| } | |
| } | |
| // E49 | |
| rom_ptr2--; | |
| rom_ptr2--; | |
| rom_ptr1--; | |
| regs[0x54] = *rom_ptr2--; | |
| regs[0x55] = *rom_ptr2; | |
| regs[0x5a] -= regs[0x54]; | |
| regs[0x5b] -C= regs[0x55]; | |
| regs[0x54] = *rom_ptr1; | |
| regs[0x56] = 0; | |
| regs[0x57] = 0; | |
| for (uint8_t i = *rom_ptr1; i > 0; i--) | |
| { | |
| regs[0x56] += regs[0x5a]; | |
| regs[0x57] +C= regs[0x5b]; | |
| } | |
| // E65 | |
| regs[0x50] += regs[0x56]; | |
| regs[0x51] +C= regs[0x57]; | |
| regs[0x54] = regs[0x52]; | |
| regs[0x55] = regs[0x53]; | |
| regs[55:54] >>= 1; | |
| regs[0x50] -= regs[0x54]; | |
| regs[0x51] -C= regs[0x55]; | |
| if (regs[0x51] < 0) | |
| { | |
| regs[0x50] = 0; | |
| regs[0x51] = 0; | |
| } | |
| // E7B | |
| while (true) | |
| { | |
| if (regs[0x51] < regs[0x5D] || | |
| (regs[0x51] == regs[0x5D] && regs[0x50] > regs[0x5C])) | |
| { | |
| break; | |
| } | |
| regs[0x5C] += regs[0x52]; | |
| regs[0x5D] += regs[0x53]; | |
| } | |
| // E8B | |
| if (regs[0x61] & 0x40) | |
| { | |
| return; | |
| } | |
| // E90 | |
| call_0EA1(); | |
| regs[0x5C] -= regs[0x52]; | |
| regs[0x5D] -C= regs[0x53]; | |
| if (regs[0x5D] >= 0) | |
| { | |
| return; | |
| } | |
| // E99 | |
| regs[0x5C] = 0; | |
| regs[0x5D] = 0; | |
| regs[0x4F] |= 0x04; | |
| } | |
| 987 | |
| 997 | |
| 9A7 | |
| 9BB | |
| 9CF | |
| 9DF | |
| 9EF | |
| A03 | |
| A17 | |
| A2D | |
| A43 | |
| A5B | |
| A73 | |
| A89 | |
| A9F | |
| AB7 | |
| // 0EA1 | |
| void call_0EA1() | |
| { | |
| uint8_t *rom_ptr1 = 0; // 58/59 | |
| uint8_t *rom_ptr2 = 0; // 56/57 | |
| regs[0x5A] = regs[0x52]; | |
| regs[0x5B] = regs[0x53]; | |
| if (regs[0x4F] & 0x20) | |
| { | |
| // EE1 | |
| if (METRIC) | |
| { | |
| // EFF | |
| if (regs[0x1F] & 0x01) | |
| { | |
| // F0E | |
| rom_ptr2 = 0x0A9F; | |
| rom_ptr1 = 0x0AB7; | |
| } | |
| else | |
| { | |
| // F04 | |
| rom_ptr2 = 0x09EF; | |
| rom_ptr1 = 0x0A03; | |
| } | |
| } | |
| else | |
| { | |
| // EE6 | |
| if (regs[0x1F] & 0x01) | |
| { | |
| // EF5 | |
| rom_ptr2 = 0x0A43; | |
| rom_ptr1 = 0x0A5B; | |
| } | |
| else | |
| { | |
| // EEB | |
| rom_ptr2 = 0x09A7; | |
| rom_ptr1 = 0x09BB; | |
| } | |
| } | |
| } | |
| else | |
| { | |
| // EAA | |
| if (METRIC) | |
| { | |
| // EC8 | |
| if (regs[0x1F] & 0x01) | |
| { | |
| // ED7 | |
| rom_ptr2 = 0x0A73; | |
| rom_ptr1 = 0x0A89; | |
| } | |
| else | |
| { | |
| // ECD | |
| rom_ptr2 = 0x09CF; | |
| rom_ptr1 = 0x09DF; | |
| } | |
| } | |
| else | |
| { | |
| // EAF | |
| if (regs[0x1F] & 0x01) | |
| { | |
| // EBE | |
| rom_ptr2 = 0x0A17; | |
| rom_ptr1 = 0x0A2D; | |
| } | |
| else | |
| { | |
| // EB4 | |
| rom_ptr2 = 0x0987; | |
| rom_ptr1 = 0x0997; | |
| } | |
| } | |
| } | |
| // F16 | |
| while (true) | |
| { | |
| regs[0x51] = *rom_ptr2++; | |
| regs[0x50] = *rom_ptr; | |
| regs[0x50] -= regs[0x5C]; | |
| regs[0x51] -C= regs[0x5D]; | |
| if (regs[0x51] >= 0) | |
| { | |
| break; | |
| } | |
| rom_ptr2++; | |
| rom_ptr++; | |
| rom_ptr++; | |
| } | |
| // F2A | |
| rom_ptr2--; | |
| rom_ptr2--; | |
| regs[0x50] = *rom_ptr2--; | |
| regs[0x51] = *rom_ptr2; | |
| regs[0x52] = regs[0x5C]; | |
| regs[0x53] = regs[0x5D]; | |
| regs[0x52] -= regs[0x50]; | |
| regs[0x53] -C= regs[0x51]; | |
| // F3C | |
| regs[0x51] = *rom_ptr1++; | |
| regs[0x50] = *rom_ptr1; | |
| rom_ptr1 -= 2; | |
| regs[0x54] = *rom_ptr1--; | |
| regs[0x55] = *rom_ptr1; | |
| regs[0x50] -= regs[0x54]; | |
| regs[0x51] -C= regs[0x55]; | |
| if (regs[0x51] >= 0) | |
| { | |
| call_0F75(&rom_ptr1, &rom_ptr2); | |
| regs[0x54] += regs[0x52]; | |
| regs[0x55] +C= regs[0x53]; | |
| } | |
| else | |
| { | |
| // 0F62 | |
| regs[0x50] ^= 0xFF; | |
| regs[0x51] ^= 0xFF | |
| regs[0x50] += 0x01; | |
| regs[0x51] +C= 0x00; | |
| call_0F75(&rom_ptr1, &rom_ptr2); | |
| regs[0x54] -= regs[0x52]; | |
| regs[0x55] -C= regs[0x53]; | |
| } | |
| regs[0x5C] -= regs[0x54]; | |
| regs[0x5D] -C= regs[0x55]; | |
| regs[0x52] = regs[0x5A]; | |
| regs[0x53] = regs[0x5B]; | |
| } | |
| // 0F75 | |
| void call_0F75(uint8_t **rom_ptr1, uint8_t **rom_ptr2); | |
| { | |
| call_0F94(); | |
| regs[0x55] = *(*rom_ptr2); | |
| (*rom_ptr2)++; | |
| regs[0x54] = *(*rom_ptr2); | |
| (*rom_ptr2)++; | |
| regs[0x51] = *(*rom_ptr2); | |
| (*rom_ptr2)++; | |
| regs[0x50] = *(*rom_ptr2); | |
| regs[0x50] -= regs[0x54]; | |
| regs[0x51] -C= regs[0x55]; | |
| call_0FBB(); | |
| regs[0x55] = *(*rom_ptr1); | |
| (*rom_ptr1)++; | |
| regs[0x54] = *(*rom_ptr1); | |
| } | |
| // 0F94 | |
| void call_0F94() | |
| { | |
| const uint8_t tmp_54 = regs[0x54]; | |
| const uint8_t tmp_55 = regs[0x55]; | |
| const uint8_t tmp_56 = regs[0x56]; | |
| regs[0x54] = 0; | |
| regs[0x55] = 0; | |
| regs[0x56] = 0x10; | |
| for (uint8_t r6 = 0x10; r6 > 0; r6--) | |
| { | |
| uint8_t lsb = regs[0x50] & 1; | |
| regs[51:50] >>= 1; | |
| if (lsb) | |
| { | |
| regs[0x54] += regs[0x52]; | |
| regs[0x55] +C= regs[0x53]; | |
| } | |
| regs[0x52] += regs[0x52]; | |
| regs[0x53] +C= regs[0x53]; | |
| } | |
| regs[0x52] = regs[0x54]; | |
| regs[0x53] = regs[0x55]; | |
| regs[0x54] = tmp_54; | |
| regs[0x55] = tmp_55; | |
| regs[0x56] = tmp_56; | |
| } | |
| // 0FBB | |
| void call_0FBB() | |
| { | |
| const uint8_t tmp_54 = regs[0x54]; | |
| const uint8_t tmp_55 = regs[0x55]; | |
| const uint8_t tmp_56 = regs[0x56]; | |
| regs[0x54] = 0; | |
| regs[0x55] = 0; | |
| uint8_t carry = 0; | |
| for (uint8_t r6 = 0x11; r6 > 0; r6--) | |
| { | |
| regs[0x54] +C= regs[0x54]; | |
| regs[0x55] +C= regs[0x55]; | |
| regs[0x54] -= regs[0x50]; | |
| regs[0x55] -C= regs[0x51]; | |
| if (regs[0x55] >= 0) | |
| { | |
| regs[0x54] += regs[0x50]; | |
| regs[0x55] +C= regs[0x51]; | |
| } | |
| carry = (regs[0x53] & 0x80) ? 1 : 0; | |
| regs[53:52] <<= 1; | |
| } | |
| regs[0x54] = tmp_54; | |
| regs[0x55] = tmp_55; | |
| regs[0x56] = tmp_56; | |
| } | |
| // 1013 | |
| void call_1013() | |
| { | |
| if (!fetch_from_recv_buf()) | |
| return; | |
| if (regs[0x61] & 0x01) | |
| { | |
| // 1043 | |
| if (!call_1AC4()) | |
| return; | |
| regs[0x4A] = 0x06; | |
| if (call_1B4A() == 0) | |
| { | |
| goto 1033; | |
| } | |
| if (recv_val == 0x48) | |
| { | |
| // 10FD | |
| } | |
| else | |
| { | |
| // 1055 | |
| if (!call_1B51()) | |
| { | |
| regs[0x1B] = recv_val; | |
| switch (regs[0x1B]) | |
| { | |
| case 'A': // 12C0 | |
| if (regs[0x0C] != 0) | |
| { | |
| print_string(data_106E); | |
| break; | |
| } | |
| print_string(data_12C9); | |
| while (true) | |
| { | |
| regs[0x10] = 0; | |
| call_14C8(); | |
| debug_out_and_delay(0x00); | |
| call_14EC(); | |
| P2 &= ~0x06; | |
| if (!regs[0x10]) | |
| P2 |= 0x02; | |
| else | |
| P2 |= 0x06; | |
| debug_out_and_delay(0x01); | |
| debug_read_coils(); | |
| debug_coils[1] += 0x0190; | |
| if (debug_coils[1] >= 0x0640) | |
| debug_coils[1] -= 0x0640; | |
| debug_coils[0] = debug_coils[1]; | |
| debug_out_and_delay(0x04); | |
| // 131B | |
| print_string(data_131E); | |
| // 1328 | |
| print_string(regs[0x10] ? data_1336 : data_132F); | |
| // 1338 | |
| call_1429(); | |
| debug_out_and_delay(0x03); | |
| debug_read_coils(); | |
| debug_coils[0] = debug_coils[1]; | |
| debug_out_and_delay(0x0C); | |
| debug_read_coils(); | |
| debug_coils[1] -= debug_coils[0]; | |
| debug_coils[0] = 0x018D; | |
| if (debug_coils[1] < 0x018D) | |
| break; | |
| // 135D | |
| debug_coils[0] = 0x0194; | |
| if (debug_coils[1] >= 0x0194) | |
| break; | |
| // 1367 | |
| debug_out_and_delay(0x05); | |
| debug_read_coils(); | |
| debug_coils[0] = debug_coils[1]; | |
| // 1375 | |
| debug_out_and_delay(0x0A); | |
| debug_read_coils(); | |
| debug_coils[1] -= debug_coils[0]; | |
| debug_coils[0] = 0x00C5; | |
| if (debug_coils[1] < 0x00C5) | |
| break; | |
| // 1389 | |
| debug_coils[0] = 0x00CC; | |
| if (debug_coils[1] >= 0x00CC) | |
| break; | |
| // 1393 | |
| debug_out_and_delay(0x00); | |
| call_14EC(); | |
| P2 &= ~0x06; | |
| // 139E | |
| if (regs[0x10] != 0) | |
| P2 |= 0x04; | |
| // 13A5 | |
| debug_out_and_delay(0x11); | |
| debug_read_coils(); | |
| // 13AD | |
| debug_coils[1] -= 0x010B; | |
| debug_coils[0] = debug_coils[1]; | |
| debug_out_and_delay(0x21); | |
| print_string(data_13BF); | |
| // 13C9 | |
| print_string(regs[0x10] ? data_13D7 : data_13D0); | |
| // 13D9 | |
| call_1429(); | |
| debug_out_and_delay(09x1); | |
| print_string(data_13E4); | |
| // 13EE | |
| print_string(regs[0x10] ? data_13FC : data_13F5); | |
| // 13FE | |
| call_1429(); | |
| debug_out_and_delay(0x00); | |
| if (regs[0x10] == 0) | |
| { | |
| regs[0x10]++; | |
| } | |
| } | |
| // 140E | |
| print_string(data_1411); | |
| print_character(0x07); | |
| debug_out_and_delay(0); | |
| P2 &= ~0x06; | |
| break; | |
| case 'B': // 14F2 | |
| { | |
| if (regs[0x0C] != 0) | |
| { | |
| print_string(data_106E); | |
| break; | |
| } | |
| // 14F8 | |
| print_string(data_14FB); | |
| do | |
| { | |
| // 150B | |
| const uint8_t switches = get_switches(); | |
| print_hex_nybble(switches); | |
| print_spaces(0); | |
| // 151A | |
| print_switch_bits(switches); | |
| print_spaces(0); | |
| // 1520 | |
| print_character((P2 & 0x20) ? '1' : '0'); | |
| print_spaces(4); | |
| // 1530 | |
| print_character((P2 & 0x40) ? 'C' : 'S'); | |
| print_character(0x0D); | |
| // 1541 | |
| } while (!fetch_from_recv_buf()); | |
| break; | |
| } | |
| case 'C': // 1549 | |
| if (regs[0x0C] != 1 || regs[0x0B] != 0 || regs[0x0A] > 1) | |
| { | |
| print_string(data_106E); | |
| break; | |
| } | |
| // 155B | |
| regs[0x1C] = 0x0A; | |
| while (regs[0x2D] & 0x80); | |
| if (regs[0x1C] != 0x01) | |
| { | |
| // 1569 | |
| print_character(0x1B); | |
| print_character('E'); | |
| } | |
| else | |
| { | |
| print_character(0x0C); | |
| } | |
| do | |
| { | |
| do | |
| { | |
| // 1573 | |
| regs[0x2D] = 0xFF; | |
| P2 &= ~0x16; | |
| P2 |= 0x10; | |
| while (regs[0x2D] & 0x80); | |
| // 1581 | |
| call_0B4D(); | |
| } while (regs[0x4F] & 0x04); | |
| // 158B | |
| regs[0x1B] = 0x0B; | |
| if (regs[0x1C] != 1) | |
| { | |
| // 1592 | |
| print_character(0x1B); | |
| print_character('Y'); | |
| } | |
| else | |
| { | |
| print_character(0x0B); | |
| } | |
| // 159C | |
| regs[0x1A] = ((int8_t)regs[0x5F]) >> 1; | |
| print_character('7' - regs[0x1A]); | |
| // 15A7 | |
| regs[0x1A] = mux_buf[4]; | |
| regs[0x1B] = mux_buf[5]; | |
| regs[0x1A] += mux_buf[4]; | |
| regs[0x1B] +C= mux_buf[5]; | |
| regs[0x1A] += mux_buf[4]; | |
| regs[0x1B] +C= mux_buf[5]; | |
| print_character((((int8_t)regs[0x1B]) >> 1) + 0x20); | |
| } while (!fetch_from_recv_buf()); | |
| break; | |
| case 'D': // 15CA | |
| case 'E': // 15C7 | |
| { | |
| regs[0x13] = (regs[0x1B] == 'D') ? 0 : 1; | |
| uint16_t dump_start = (regs[0x0B] << 8) | regs[0x0A]; // 14/15 | |
| regs[0x10] = 0; | |
| if (regs[0x0C] < 1) | |
| { | |
| print_string(data_106E); | |
| break; | |
| } | |
| else if (regs[0x0C] > 1) | |
| { | |
| // 15DA | |
| if (regs[0x0C] != 2 || regs[0x07] != 0) | |
| { | |
| print_string(data_106E); | |
| break; | |
| } | |
| // 15E6 | |
| regs[0x1B] = 0x06; | |
| if (regs[0x13] != 0) | |
| { | |
| // 15EC | |
| *(uint8_t *)dump_start = regs[0x1B]; | |
| } | |
| else | |
| { | |
| // 15EF | |
| rom[dump_start] = regs[0x1B]; | |
| } | |
| // 1033 | |
| regs[0x4A] = 0x06; | |
| regs[0x4E] = 0; | |
| regs[0x61] |= 0x01; | |
| print_string(data_103F); | |
| return; | |
| } | |
| else | |
| { | |
| // 15F4 | |
| do | |
| { | |
| print_byte(regs[0x14]); | |
| print_byte(regs[0x15]); | |
| print_spaces(0); | |
| uint16_t dump_addr = dump_start; | |
| for (uint8_t r2 = 0x10; r2 > 0; r2--) | |
| { | |
| print_spaces(0); | |
| if (regs[0x13] != 0) | |
| { | |
| // 160E | |
| regs[0x1B] = *(uint8_t *)dump_addr; | |
| // Broken: 0D | |
| } | |
| else | |
| { | |
| // 1611 | |
| regs[0x1B] = rom[dump_addr]; | |
| } | |
| print_byte(regs[0x1B]); | |
| // 1616 | |
| dump_addr++; | |
| } | |
| // 161E | |
| print_spaces(0); | |
| print_spaces(0); | |
| print_character(0x2A); | |
| for (uint8_t r2 = 0x10; r2 > 0; r2--) | |
| { | |
| if (regs[0x13] != 0) | |
| { | |
| regs[0x1B] = *(uint8_t *)dump_start; | |
| } | |
| else | |
| { | |
| regs[0x1B] = rom[dump_start]; | |
| } | |
| if (regs[0x1B] == ' ' || regs[0x1B] > 0x7F) | |
| print_character('.'); | |
| else | |
| print_character(regs[0x1B]); | |
| dump_start++; | |
| } | |
| // 1647 | |
| print_string(data_164A); | |
| } while (!fetch_from_recv_buf()); | |
| } | |
| break; | |
| } | |
| case 'Q': // 1B39 | |
| break; | |
| case 'F': // 1654 | |
| break; | |
| case 'G': // 16C2 | |
| break; | |
| case 'I': // 16E6 | |
| break; | |
| case 'M': // 172B | |
| break; | |
| case 'P': // 1745 | |
| break; | |
| case 'R': // 17D6 | |
| break; | |
| case 'S': // 1884 | |
| break; | |
| case 'T': // 18D4 | |
| break; | |
| case 'V': // 1924 | |
| break; | |
| case 'X': | |
| case 'Y': // 192E | |
| break; | |
| default: | |
| print_string(data_10ED); | |
| break; | |
| } | |
| } | |
| else | |
| { | |
| // 105A | |
| print_string(data_105D); | |
| } | |
| } | |
| } | |
| // 1030 | |
| print_newline(); | |
| regs[0x4A] = 0x06; | |
| regs[0x4E] = 0; | |
| regs[0x61] |= 0x01; | |
| print_string(data_103F); | |
| } | |
| // 1429 | |
| void call_1429() | |
| { | |
| print_string(data_142C); | |
| regs[0x11] = 0; | |
| while (true) | |
| { | |
| debug_read_coils(); | |
| if (debug_coils[1] != debug_coils[0]) | |
| { | |
| // 1452 | |
| regs[0x11] = 0; | |
| print_character((debug_coils[1] < debug_coils[0]) ? 0x3E : 0x3C); | |
| print_character(0x0D); | |
| if (fetch_from_recv_buf()) | |
| { | |
| print_newline(); | |
| return; | |
| } | |
| } | |
| else | |
| { | |
| // 146A | |
| regs[0x11]++; | |
| if (regs[0x11] < 5) | |
| { | |
| if (fetch_from_recv_buf()) | |
| { | |
| print_newline(); | |
| return; | |
| } | |
| } | |
| else | |
| { | |
| print_character(0x07); | |
| print_character(0x3D); | |
| print_character(0x0D); | |
| if (fetch_from_recv_buf()) | |
| { | |
| print_newline(); | |
| return; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| // 1479 | |
| void debug_read_coils() | |
| { | |
| disable_interrupts(); | |
| IMR &= ~0x02; | |
| enable_interrupts(); | |
| for (int r1 = 10; r1 > 0; r1--) | |
| { | |
| while (!(regs[0x4F] & 0x01)); | |
| // 1489 | |
| IRQ &= ~0x02; | |
| P2 &= ~0x10; | |
| P2 |= 0x10; | |
| while (!(IRQ & 0x02)); | |
| // 1497 | |
| debug_coils[1] = ((RDH << 8) | RDL) & 0x0FFF; | |
| } | |
| IRQ &= ~0x02; | |
| disable_interrupts(); | |
| IMR |= 0x02; | |
| enable_interrupts(); | |
| } | |
| // 14B1 | |
| bool call_14B1() | |
| { | |
| return regs[15:14] < regs[13:12]; | |
| } | |
| // 14B8 | |
| void debug_out_and_delay(uint8_t val) | |
| { | |
| DI07 = val; | |
| delay_50000_insns(); | |
| } | |
| // 19C5 | |
| void print_newline() | |
| { | |
| print_character(0x0D); | |
| print_character(0x0A); | |
| } | |
| // 19DA | |
| void print_byte(uint8_t value) | |
| { | |
| print_hex_nybble(value >> 4); | |
| print_hex_nybble(value); | |
| } | |
| // 19E3 | |
| void print_hex_nybble(uint8_t nybble) | |
| { | |
| print_character((nybble & 0x0F) | 0x40); | |
| } | |
| // 19FC | |
| void print_switch_bits(uint8_t switches) | |
| { | |
| for (int bit = 4; bit > 0; bit--) | |
| print_character((switches & (1 << (bit - 1))) ? '1' : '0'); | |
| } | |
| // 1A17 | |
| uint8_t get_switches() | |
| { | |
| return (~RDH) >> 4; | |
| } | |
| // 1A27 | |
| void print_spaces(uint8_t count) | |
| { | |
| count++; | |
| for (; r0 > 0; r0--) | |
| { | |
| print_character(0x20); | |
| } | |
| } | |
| // 1A37 | |
| void print_character(const uint8_t ascii_val) | |
| { | |
| call_1A5F(); | |
| regs[0x04] = ascii_val; | |
| regs[0x05] = 0xFF; | |
| transmit_byte(); | |
| } | |
| // 1A3F | |
| void transmit_byte() | |
| { | |
| // RP = 0x30 | |
| regs[0x4F] &= ~0x01; | |
| regs[0x4F] |= 0x08; | |
| uint8_t buf_val = regs[0x04]; | |
| handle_parity(&buf_val); | |
| regs[0x61] |= 0x04; | |
| SIO = buf_val; | |
| } | |
| // 1A5F | |
| void call_1A5F() | |
| { | |
| while (true) | |
| { | |
| do | |
| { | |
| enable_interrupts(); | |
| // NOP | |
| disable_interrupts(); | |
| while (P3 & 0x02); | |
| } while (regs[0x61] & 0x02); | |
| // 1A6E | |
| if (regs[0x4F] & 0x80) | |
| { | |
| regs[0x4F] &= ~0x80; | |
| if (!(regs[0x61] & 0x04)) | |
| { | |
| transmit_complete_irq(); | |
| } | |
| continue; | |
| } | |
| if (regs[0x4F] & 0x01) | |
| break; | |
| } | |
| } | |
| // 1A91 | |
| void print_string(uint8_t *data_ptr) | |
| { | |
| uint8_t data = 0; | |
| do | |
| { | |
| data = *data_ptr; | |
| const uint8_t ascii_val = data & 0x7F; | |
| if (ascii_val < 0x20) | |
| { | |
| // 1AA1 | |
| if (ascii_val == 0x0D) | |
| { | |
| call_19C5(); | |
| } | |
| else if (ascii_val != 0x0C) | |
| { | |
| // 1AB0 | |
| regs[0x40] = recv_val; | |
| print_spaces(recv_val); | |
| } | |
| else | |
| { | |
| print_character(ascii_val); | |
| } | |
| } | |
| else | |
| { | |
| print_character(ascii_val); | |
| } | |
| // 1ABA | |
| data_ptr++; | |
| } while (data < 0x80); | |
| } | |
| // 1C11 | |
| void test_regs() | |
| { | |
| while ((regs[0x4F] & 0x81) == 0x01); | |
| while (regs[0x2D] & 0x80); | |
| regs[0x2D] = 0; | |
| regs[0x66] = 0; | |
| disable_interrupts(); | |
| uint8_t reg = 0x7F; | |
| uint8_t carry = 1; | |
| for (uint8_t i = 0x7F, reg = 0x78; i > 0; i--, reg--) | |
| { | |
| const uint8_t orig = regs[reg]; | |
| regs[0x07] = 0x55; | |
| regs[reg] = regs[0x07]; | |
| regs[0x07] = regs[reg]; | |
| regs[reg] ^= 0xFF; | |
| regs[0x07] +C= regs[reg]; | |
| if (regs[0x07] != 0) | |
| { | |
| regs[0x66] |= 0x01; | |
| regs[reg] = orig; | |
| return; | |
| } | |
| regs[reg] = orig; | |
| } | |
| } | |
| // 1C4C | |
| void checksum_rom() | |
| { | |
| // Sets bit 1 in regs[0x66] if ROM checksum is wrong | |
| } |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment