summaryrefslogtreecommitdiff
path: root/sux.c
diff options
context:
space:
mode:
Diffstat (limited to 'sux.c')
-rw-r--r--sux.c351
1 files changed, 199 insertions, 152 deletions
diff --git a/sux.c b/sux.c
index 8cfecdb..c4c83ee 100644
--- a/sux.c
+++ b/sux.c
@@ -18,6 +18,7 @@
#define CTRL_ADDR 0xC000
#define TX_ADDR 0xC001
#define RX_ADDR 0xC002
+#define STEP_ADDR 0xC010
#define CURSES_BACKSPACE 0x7F
#define setflag(flag, bit) (flag) ? (cpu->ps |= (bit << (thread << 3))) : (cpu->ps &= ~(bit << (thread << 3)))
@@ -30,6 +31,7 @@ uint8_t threads_done = 0;
uint8_t kbd_rdy = 0;
uint8_t kbd_ln = 0;
uint8_t wai = 0;
+uint8_t step = 0;
uint8_t irq = 0;
#if !bench
WINDOW *scr;
@@ -115,10 +117,14 @@ void *run(void *args) {
#if keypoll
pthread_mutex_lock(&mutex);
#endif
- mvwprintw(scr, lines, 0, "pc: $%08llx, a: $%016llx, b: $%016llx, x: $%016llx, y: $%016llx"
+ /*mvwprintw(scr, lines, 0, "pc: $%08llx, a: $%016llx, b: $%016llx, x: $%016llx, y: $%016llx"
", sp: $%04lx, ps: $%016llx, prefix: $%02x, opcode: $%02x, thread: %u, inst: "
, cpu->pc[thread], cpu->a[thread], cpu->b[thread], cpu->x[thread], cpu->y[thread]
- , cpu->sp[thread], cpu->ps, prefix, opcode, thread);
+ , cpu->sp[thread], cpu->ps, prefix, opcode, thread);*/
+ mvwprintw(scr, lines, 0, "pc: $%08llx, a: $%016llx, b: $%016llx, x: $%016llx, y: $%016llx"
+ ", sp: $%04lx, ps: $%016llx, prefix: $%02x, opcode: $%02x, inst: "
+ , cpu->pc[thread], cpu->a[thread], cpu->b[thread], cpu->x[thread], cpu->y[thread]
+ , cpu->sp[thread], cpu->ps, prefix, opcode);
#if keypoll
pthread_mutex_unlock(&mutex);
#endif
@@ -137,6 +143,8 @@ void *run(void *args) {
case IMM:
switch (opcode) {
case TXS:
+ break;
+
case PHB:
case PHP:
case PHA:
@@ -147,7 +155,6 @@ void *run(void *args) {
case PLA:
case PLY:
case PLX:
- break;
case STT:
case LSL:
case LSR:
@@ -317,15 +324,44 @@ void *run(void *args) {
break;
}
- mvwprintw(scr, 29, 0, "address: $%016llx, scr_row: %02u, scr_col: %02u, scr_lnst: $%04x, scr_lncnt: $%04x\r", address, addr[0], addr[1], addr[2] | (addr[3] << 8), addr[4] | (addr[5] << 8));
- mvwprintw(scr, 32, 0, "%02x %02x %02x %02x %02x %02x %02x %02x "
- "%02x %02x %02x %02x %02x %02x %02x %02x\r"
- , addr[0x4000], addr[0x4001], addr[0x4002], addr[0x4003], addr[0x4004], addr[0x4005], addr[0x4006], addr[0x4007]
- , addr[0x4008], addr[0x4009], addr[0x400A], addr[0x400B], addr[0x400C], addr[0x400D], addr[0x400E], addr[0x400F]);
- mvwprintw(scr, 33, 0, "%02x %02x %02x %02x %02x %02x %02x %02x "
+ mvwprintw(scr, 29, 0, "address: $%016llx, scr_row: %02u, scr_col: %02u, scr_str: %02u, scr_end: %02u\r", address, addr[0], addr[1], addr[0x4B], addr[0x4C]);
+ mvwprintw(scr, 32, 0, "bitabl: %02x %02x %02x %02x %02x %02x %02x %02x "
"%02x %02x %02x %02x %02x %02x %02x %02x\r"
- , addr[0x4010], addr[0x4011], addr[0x4012], addr[0x4013], addr[0x4014], addr[0x4015], addr[0x4016], addr[0x4017]
- , addr[0x4018], addr[0x4019], addr[0x401A], addr[0x401B], addr[0x401C], addr[0x401D], addr[0x401E], addr[0x401F]);
+ , addr[0x3B], addr[0x3C], addr[0x3D], addr[0x3E], addr[0x3F], addr[0x40], addr[0x41], addr[0x42]
+ , addr[0x43], addr[0x44], addr[0x45], addr[0x46], addr[0x47], addr[0x48], addr[0x49], addr[0x4A]);
+ mvwprintw(scr, 33, 0, "buffer:\r");
+ uint8_t ln = 34;
+ uint16_t tmpad = 0x2000;
+ for (uint16_t i = 0; i < 20; i+=2) {
+ mvwprintw(scr, ln++, 0, "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x "
+ "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x, i: %02x\r"
+ , addr[tmpad+(0x00)+(i*0x10)], addr[tmpad+(0x01)+(i*0x10)], addr[tmpad+(0x02)+(i*0x10)], addr[tmpad+(0x03)+(i*0x10)]
+ , addr[tmpad+(0x04)+(i*0x10)], addr[tmpad+(0x05)+(i*0x10)], addr[tmpad+(0x06)+(i*0x10)], addr[tmpad+(0x07)+(i*0x10)]
+ , addr[tmpad+(0x08)+(i*0x10)], addr[tmpad+(0x09)+(i*0x10)], addr[tmpad+(0x0A)+(i*0x10)], addr[tmpad+(0x0B)+(i*0x10)]
+ , addr[tmpad+(0x0C)+(i*0x10)], addr[tmpad+(0x0D)+(i*0x10)], addr[tmpad+(0x0E)+(i*0x10)], addr[tmpad+(0x0F)+(i*0x10)]
+ , addr[tmpad+(0x10)+(i*0x10)], addr[tmpad+(0x11)+(i*0x10)], addr[tmpad+(0x12)+(i*0x10)], addr[tmpad+(0x13)+(i*0x10)]
+ , addr[tmpad+(0x14)+(i*0x10)], addr[tmpad+(0x15)+(i*0x10)], addr[tmpad+(0x16)+(i*0x10)], addr[tmpad+(0x17)+(i*0x10)]
+ , addr[tmpad+(0x18)+(i*0x10)], addr[tmpad+(0x19)+(i*0x10)], addr[tmpad+(0x1A)+(i*0x10)], addr[tmpad+(0x1B)+(i*0x10)]
+ , addr[tmpad+(0x1C)+(i*0x10)], addr[tmpad+(0x1D)+(i*0x10)], addr[tmpad+(0x1E)+(i*0x10)], addr[tmpad+(0x1F)+(i*0x10)]
+ , i);
+
+ }
+ /*tmpad = 0x4000;
+ mvwprintw(scr, ln++, 0, "cmd_buf:\r");
+ for (uint16_t i = 0; i < 20; i+=2) {
+ mvwprintw(scr, ln++, 0, "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x "
+ "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x, i: %02x\r"
+ , addr[tmpad+(0x00)+(i*0x10)], addr[tmpad+(0x01)+(i*0x10)], addr[tmpad+(0x02)+(i*0x10)], addr[tmpad+(0x03)+(i*0x10)]
+ , addr[tmpad+(0x04)+(i*0x10)], addr[tmpad+(0x05)+(i*0x10)], addr[tmpad+(0x06)+(i*0x10)], addr[tmpad+(0x07)+(i*0x10)]
+ , addr[tmpad+(0x08)+(i*0x10)], addr[tmpad+(0x09)+(i*0x10)], addr[tmpad+(0x0A)+(i*0x10)], addr[tmpad+(0x0B)+(i*0x10)]
+ , addr[tmpad+(0x0C)+(i*0x10)], addr[tmpad+(0x0D)+(i*0x10)], addr[tmpad+(0x0E)+(i*0x10)], addr[tmpad+(0x0F)+(i*0x10)]
+ , addr[tmpad+(0x10)+(i*0x10)], addr[tmpad+(0x11)+(i*0x10)], addr[tmpad+(0x12)+(i*0x10)], addr[tmpad+(0x13)+(i*0x10)]
+ , addr[tmpad+(0x14)+(i*0x10)], addr[tmpad+(0x15)+(i*0x10)], addr[tmpad+(0x16)+(i*0x10)], addr[tmpad+(0x17)+(i*0x10)]
+ , addr[tmpad+(0x18)+(i*0x10)], addr[tmpad+(0x19)+(i*0x10)], addr[tmpad+(0x1A)+(i*0x10)], addr[tmpad+(0x1B)+(i*0x10)]
+ , addr[tmpad+(0x1C)+(i*0x10)], addr[tmpad+(0x1D)+(i*0x10)], addr[tmpad+(0x1E)+(i*0x10)], addr[tmpad+(0x1F)+(i*0x10)]
+ , i);
+
+ }*/
wrefresh(scr);
#if keypoll
pthread_mutex_unlock(&mutex);
@@ -363,50 +399,30 @@ void *run(void *args) {
setflag(cpu->i[thread], I);
break;
case PHB: /* PusH B register to stack. */
- tmp = addr[cpu->pc[thread]++];
- if (tmp > 7)
- tmp = 7;
- for (int8_t i = tmp<<3; i >= 0; i-=8) {
- if (i)
- addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] = (uint64_t)cpu->b[thread] >> i;
- else
- addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] = (uint64_t)cpu->b[thread] & 0xFF;
- cpu->sp[thread]--;
- }
- break;
case PHP: /* PusH Processor status to stack. */
- tmp = addr[cpu->pc[thread]++];
- if (tmp > 7)
- tmp = 7;
- for (int8_t i = tmp<<3; i >= 0; i-=8) {
- if (i)
- addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] = (uint64_t)cpu->ps >> i;
- else
- addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] = (uint64_t)cpu->ps & 0xFF;
- cpu->sp[thread]--;
- }
- break;
case PHA: /* PusH Accumulator to stack. */
- tmp = addr[cpu->pc[thread]++];
- if (tmp > 7)
- tmp = 7;
- for (int8_t i = tmp<<3; i >= 0; i-=8) {
- if (i)
- addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] = (uint64_t)cpu->a[thread] >> i;
- else
- addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] = (uint64_t)cpu->a[thread] & 0xFF;
- cpu->sp[thread]--;
- }
- break;
case PHY: /* PusH Y register to stack. */
- tmp = addr[cpu->pc[thread]++];
+ case PHX: /* PusH X register to stack. */
+ tmp = value;
+ if (opcode == PHB) {
+ reg = cpu->b[thread];
+ } else if (opcode == PHP) {
+ reg = cpu->ps;
+ } else if (opcode == PHA) {
+ reg = cpu->a[thread];
+ } else if (opcode == PHY) {
+ reg = cpu->y[thread];
+ } else if (opcode == PHX) {
+ reg = cpu->x[thread];
+ }
+
if (tmp > 7)
tmp = 7;
for (int8_t i = tmp<<3; i >= 0; i-=8) {
if (i)
- addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] = (uint64_t)cpu->y[thread] >> i;
+ addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] = reg >> i;
else
- addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] = (uint64_t)cpu->y[thread] & 0xFF;
+ addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] = reg & 0xFF;
cpu->sp[thread]--;
}
break;
@@ -422,28 +438,28 @@ void *run(void *args) {
case TXS: /* Transfer X to Stack pointer. */
if (opcode == TAY)
cpu->y[thread] = cpu->a[thread];
- if (opcode == TAX)
+ else if (opcode == TAX)
cpu->x[thread] = cpu->a[thread];
- if (opcode == TYX)
+ else if (opcode == TYX)
cpu->x[thread] = cpu->y[thread];
- if (opcode == TYA)
+ else if (opcode == TYA)
cpu->a[thread] = cpu->y[thread];
- if (opcode == TXA)
+ else if (opcode == TXA)
cpu->a[thread] = cpu->x[thread];
- if (opcode == TXY)
+ else if (opcode == TXY)
cpu->y[thread] = cpu->x[thread];
- if (opcode == TAB) {
+ else if (opcode == TAB) {
cpu->b[thread] = cpu->a[thread];
cpu->z[thread] = (cpu->b[thread] == 0);
cpu->n[thread] = (cpu->b[thread] >> 63);
}
- if (opcode == TSX) {
+ else if (opcode == TSX) {
cpu->x[thread] = cpu->sp[thread] & 0xFFFF;
cpu->x[thread] = cpu->stk_st[thread] << 16;
}
- if (opcode == TBA)
+ else if (opcode == TBA)
cpu->a[thread] = cpu->b[thread];
- if (opcode == TXS) {
+ else if (opcode == TXS) {
cpu->sp[thread] = cpu->x[thread];
if (prefix == 0x17 && (value == thread+1 || value > 8)) {
cpu->stk_st[thread] = value & 0xFF;
@@ -455,29 +471,17 @@ void *run(void *args) {
cpu->z[thread] = (cpu->a[thread] == 0);
cpu->n[thread] = (cpu->a[thread] >> 63);
}
- if (opcode == TAY || opcode == TXY) {
+ else if (opcode == TAY || opcode == TXY) {
cpu->z[thread] = (cpu->y[thread] == 0);
cpu->n[thread] = (cpu->y[thread] >> 63);
}
- if (opcode == TAX || opcode == TYX) {
+ else if (opcode == TAX || opcode == TYX) {
cpu->z[thread] = (cpu->x[thread] == 0);
cpu->n[thread] = (cpu->x[thread] >> 63);
}
setflag(cpu->z[thread], Z);
setflag(cpu->n[thread], N);
break;
- case PHX: /* PusH X register to stack. */
- tmp = addr[cpu->pc[thread]++];
- if (tmp > 7)
- tmp = 7;
- for (int8_t i = tmp<<3; i >= 0; i-=8) {
- if (i)
- addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] = (uint64_t)cpu->x[thread] >> i;
- else
- addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] = (uint64_t)cpu->x[thread] & 0xFF;
- cpu->sp[thread]--;
- }
- break;
case JMP: /* JMP Absolute. */
cpu->pc[thread] = address;
break;
@@ -500,63 +504,41 @@ void *run(void *args) {
cpu->a[thread] = sum;
break;
case PLB: /* PuLl B register from stack. */
- tmp = addr[cpu->pc[thread]++];
- if (tmp > 7)
- tmp = 7;
- for (uint8_t i = 0; i < (tmp+1)<<3; i+=8) {
- cpu->sp[thread]++;
- if (i)
- cpu->b[thread] += (uint64_t)addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] << i;
- else
- cpu->b[thread] = (uint64_t)addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] & 0xFF;
- }
- break;
case PLP: /* PuLl Processor status from stack. */
- tmp = addr[cpu->pc[thread]++];
- if (tmp > 7)
- tmp = 7;
- for (uint8_t i = 0; i < (tmp+1)<<3; i+=8) {
- cpu->sp[thread]++;
- if (i)
- cpu->ps += (uint64_t)addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] << i;
- else
- cpu->ps = (uint64_t)addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] & 0xFF;
- }
- break;
case PLA: /* PuLl Accumulator from stack. */
- tmp = addr[cpu->pc[thread]++];
- if (tmp > 7)
- tmp = 7;
- for (uint8_t i = 0; i < (tmp+1)<<3; i+=8) {
- cpu->sp[thread]++;
- if (i)
- cpu->a[thread] += (uint64_t)addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] << i;
- else
- cpu->a[thread] = (uint64_t)addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] & 0xFF;
- }
- break;
case PLY: /* PuLl Y register from stack. */
- tmp = addr[cpu->pc[thread]++];
- if (tmp > 7)
- tmp = 7;
- for (uint8_t i = 0; i < (tmp+1)<<3; i+=8) {
- cpu->sp[thread]++;
- if (i)
- cpu->y[thread] += (uint64_t)addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] << i;
- else
- cpu->y[thread] = (uint64_t)addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] & 0xFF;
- }
- break;
case PLX: /* PuLl X register from stack. */
- tmp = addr[cpu->pc[thread]++];
+ tmp = value;
+ if (opcode == PLB)
+ reg = cpu->b[thread];
+ else if (opcode == PLP)
+ reg = cpu->ps;
+ else if (opcode == PLA)
+ reg = cpu->a[thread];
+ else if (opcode == PLY)
+ reg = cpu->y[thread];
+ else if (opcode == PLX)
+ reg = cpu->x[thread];
+
if (tmp > 7)
tmp = 7;
for (uint8_t i = 0; i < (tmp+1)<<3; i+=8) {
cpu->sp[thread]++;
if (i)
- cpu->x[thread] += (uint64_t)addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] << i;
+ reg += addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] << i;
else
- cpu->x[thread] = (uint64_t)addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] & 0xFF;
+ reg = addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] & 0xFF;
+ }
+ if (opcode == PLB) {
+ cpu->b[thread] = reg;
+ } else if (opcode == PLP) {
+ cpu->ps = reg;
+ } else if (opcode == PLA) {
+ cpu->a[thread] = reg;
+ } else if (opcode == PLY) {
+ cpu->y[thread] = reg;
+ } else if (opcode == PLX) {
+ cpu->x[thread] = reg;
}
break;
case 0x34: /* JSR Indirect. */
@@ -607,7 +589,7 @@ void *run(void *args) {
break;
case BPO: /* BPO Absolute. */
case 0x64: /* BPO Zero Matrix. */
- if (cpu->n[thread])
+ if (!cpu->n[thread])
cpu->pc[thread] = address;
break;
case ORA: /* ORA Immediate. */
@@ -629,7 +611,7 @@ void *run(void *args) {
break;
case BNG: /* BNG Absolute. */
case 0x74: /* BNG Zero Matrix. */
- if (!cpu->n[thread])
+ if (cpu->n[thread])
cpu->pc[thread] = address;
break;
case XOR: /* XOR Immediate. */
@@ -707,6 +689,9 @@ void *run(void *args) {
if (opcode == STB || opcode == 0x4E || opcode == 0x6E || opcode == 0x8E || opcode == 0xAE || opcode == 0xCE || opcode == 0xEE)
value = cpu->b[thread];
addr[address] = value & 0xFF;
+ if (address == STEP_ADDR) {
+ step = addr[address];
+ }
#if IO
if (address == TX_ADDR) {
#if keypoll
@@ -755,6 +740,14 @@ void *run(void *args) {
bcd[3] = 0;
esc = 0;
break;
+ case 'S':
+ wscrl(scr, -1);
+ esc = 0;
+ break;
+ case 'T':
+ wscrl(scr, 1);
+ esc = 0;
+ break;
case '0':
case '1':
case '2':
@@ -845,6 +838,10 @@ void *run(void *args) {
bcd[3] = 0;
esc = 0;
break;
+ case 'S':
+ case 'T':
+ esc = 0;
+ break;
case '0':
case '1':
case '2':
@@ -963,6 +960,7 @@ void *run(void *args) {
case 0xDE: /* LDB Indirect Indexed. */
case 0xD9: /* LDA Indirect Indexed. */
if (address == CTRL_ADDR) {
+ kbd_rdy = 1;
pthread_mutex_lock(&main_mutex);
pthread_cond_signal(&main_cond);
pthread_mutex_unlock(&main_mutex);
@@ -971,13 +969,14 @@ void *run(void *args) {
pthread_cond_wait(&cond, &mutex);
pthread_mutex_unlock(&mutex);
#endif
+ kbd_rdy = 0;
}
- value = (uint64_t)addr[address];
+ value = addr[address];
if (regsize >= 2)
- value += (uint64_t)addr[address+1] << 8;
+ value += addr[address+1] << 8;
if (regsize >= 4) {
- value += (uint64_t)addr[address+2] << 16;
- value += (uint64_t)addr[address+3] << 24;
+ value += addr[address+2] << 16;
+ value += addr[address+3] << 24;
}
if (regsize >= 8) {
value += (uint64_t)addr[address+4] << 32;
@@ -1151,10 +1150,10 @@ void *run(void *args) {
if (opcode == CPX || opcode == 0xCB || opcode == 0xDB || opcode == 0xEB || opcode == 0xFB)
reg = cpu->x[thread];
sum = reg-value;
- cpu->n[thread] = (sum & 0x8000000000000000) ? 1 : 0;
+ cpu->n[thread] = (sum & 0x8000000000000000);
cpu->v[thread] = ((reg^value) & 0x8000000000000000) && ((reg^sum) & 0x8000000000000000);
- cpu->z[thread] = (sum == 0) ? 1 : 0;
- cpu->c[thread] = (sum > value) ? 1 : 0;
+ cpu->z[thread] = (sum == 0);
+ cpu->c[thread] = (reg >= value);
setflag(cpu->n[thread], N);
setflag(cpu->v[thread], V);
setflag(cpu->z[thread], Z);
@@ -1249,6 +1248,10 @@ void *run(void *args) {
case 0xC3: /* INC Absolute. */
case 0xC5: /* INC Zero Matrix. */
addr[address]++;
+ cpu->z[thread] = (addr[address] == 0);
+ cpu->n[thread] = (addr[address] >> 7);
+ setflag(cpu->z[thread], Z);
+ setflag(cpu->n[thread], N);
break;
case NOP: /* No OPeration. */
break;
@@ -1268,6 +1271,10 @@ void *run(void *args) {
case 0xD3: /* DEC Absolute. */
case 0xD5: /* DEC Zero Matrix. */
addr[address]--;
+ cpu->z[thread] = (addr[address] == 0);
+ cpu->n[thread] = (addr[address] >> 7);
+ setflag(cpu->z[thread], Z);
+ setflag(cpu->n[thread], N);
break;
case BRK: /* BReaK. */
for (int8_t i = stksize; i >= 0; i-=8) {
@@ -1303,13 +1310,21 @@ void *run(void *args) {
break;
}
ins++;
- /*if (!addr[CTRL_ADDR])
+ if (step) {
+ pthread_mutex_lock(&main_mutex);
+ pthread_cond_signal(&main_cond);
+ pthread_mutex_unlock(&main_mutex);
+ pthread_mutex_lock(&mutex);
+ pthread_cond_wait(&cond, &mutex);
+ pthread_mutex_unlock(&mutex);
+ }
+ if (!addr[CTRL_ADDR])
kbd_ln = 0;
else
kbd_ln = 1;
- if (kbd_ln)
+ /*if (kbd_ln)
usleep(16666);
- /*usleep(500000);*/
+ usleep(500000);*/
#if debug && !bench
#if keypoll
pthread_mutex_lock(&mutex);
@@ -1419,47 +1434,79 @@ int main(int argc, char **argv) {
assert(!result);
}
int c = 0;
+ uint8_t step_key = 0;
#if !bench
werase(scr);
#endif
while (threads_done < THREADS) {
#if !bench
int x, y, i = 0;
- if ((c != EOF && c !=-1)) {
- pthread_mutex_lock(&main_mutex);
- curs_set(0);
- pthread_cond_wait(&main_cond, &main_mutex);
- pthread_mutex_unlock(&main_mutex);
- curs_set(1);
- c = 0;
- addr[CTRL_ADDR] = 0;
- kbd_ln = 0;
+ if ((step_key && step && !kbd_rdy) || !step || kbd_rdy) {
+ if ((c != EOF && c !=-1)) {
+ pthread_mutex_lock(&main_mutex);
+ curs_set(0);
+ pthread_cond_wait(&main_cond, &main_mutex);
+ pthread_mutex_unlock(&main_mutex);
+ curs_set(1);
+ c = 0;
+ step_key = 0;
+ addr[CTRL_ADDR] = 0;
+ kbd_ln = 0;
+ }
}
#if keypoll
pthread_mutex_lock(&mutex);
#endif
getyx(scr, y, x);
c = wgetch(scr);
- switch (c) {
- case ERR:
- addr[CTRL_ADDR] = 0;
- wmove(scr, getmaxy(scr)-1, 0);
- wprintw(scr, "c: %i, x: %i, y: %i, i: %i.", c, x, y, i++);
- wmove(scr, y, x);
- wrefresh(scr);
- break;
- default:
- addr[RX_ADDR] = (uint8_t)c;
- addr[CTRL_ADDR] = 1;
- if (c == '\n')
- kbd_ln = 1;
+ if (c == 19) {
+ step = 1;
+ if (kbd_rdy)
+ c = wgetch(scr);
+ }
+ if (kbd_rdy) {
+ switch (c) {
+ case ERR:
+ addr[CTRL_ADDR] = 0;
+ wmove(scr, getmaxy(scr)-1, 0);
+ wprintw(scr, "c: %i, x: %i, y: %i, i: %i.", c, x, y, i++);
+ wmove(scr, y, x);
+ wrefresh(scr);
+ break;
+ default:
+ if (kbd_rdy && c < 0x100) {
+ addr[RX_ADDR] = (uint8_t)c;
+ addr[CTRL_ADDR] = 1;
+ #if debug && !bench
+ wmove(scr, getmaxy(scr)-1, 0);
+ wprintw(scr, "c: %i, x: %i, y: %i, i: %i.", c, x, y, i++);
+ wmove(scr, y, x);
+ wrefresh(scr);
+ #endif
+ }
+ if (c == '\n')
+ kbd_ln = 1;
+ #if !keypoll
+ pthread_mutex_lock(&mutex);
+ pthread_cond_signal(&cond);
+ pthread_mutex_unlock(&mutex);
+ #endif
+ break;
+ }
+ } else {
+ if ((c == 19 || c == 18) && step) {
+ if (c == 18)
+ step = 0;
+ else if (c == 19)
+ step_key = 1;
#if !keypoll
pthread_mutex_lock(&mutex);
pthread_cond_signal(&cond);
pthread_mutex_unlock(&mutex);
#endif
- break;
+ }
}
+ addr[STEP_ADDR] = step;
#if keypoll
pthread_mutex_unlock(&mutex);
#endif
generated by cgit v1.2.3-13-gbd6f (git 2.30.0) at 2024-12-26 18:39:39 +0000