Finished SuBAsm's screen editor.

Which I am now calling, SuBEditor.

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