Add better multiprocess capabilities to uxn11.

The changes are summarized in doc/console.txt.

doc/console.txt

@@ -0,0 +1,150 @@
+CONSOLE DEVICE
+
+ 0x10 vector*      0x18 @stdout
+ 0x11 (vector)     0x19 @stderr
+ 0x12 stdin        0x1a @proc-put
+ 0x13              0x1b
+ 0x14              0x1c param*
+ 0x15              0x1d (param)
+ 0x16              0x1e opts
+ 0x17 type         0x1f @host-put
+
+(* denotes a short register, i.e. two bytes wide)
+(@ denotes a register that causes an immediate effect)
+
+vector ports (0x10-0x11) contain an address to jump to when input is
+available. when the vector fires one byte can be read from the read
+port (0x12), and its meaning is defined by the type (0x17).
+
+the stdin port (0x12) contains one byte of data to be read. the byte
+represents input read from one of the following: arguments, stdin,
+child processes, or host messages. the type port (0x17) says which.
+
+the type (0x17) field explains how to interpret calls to the console
+vector (0x10) and where data can be read from:
+
+ - 0x00 - 00000000 - no input (-)
+ - 0x01 - 00000001 - stdin (stdin)
+ - 0x02 - 00000010 - argument (stdin)
+ - 0x03 - 00000011 - argument spacer (-)
+ - 0x04 - 00000100 - argument end (-)
+ - 0x05 - 00000101 - host response
+ - 0x06 - 00000110 - host response end (-)
+ - 0x07 - 00000111 - stdin end (-)
+ - 0x20 - 00100000 - child 0 sent data
+ - 0x21 - 00100001 - child 1 sent data
+ - 0x22 - 00100010 - child 2 sent data
+ - 0x23 - 00100011 - child 3 sent data
+ - 0x40 - 01000000 - child 0 data end
+ - 0x41 - 01000001 - child 1 data end
+ - 0x42 - 01000010 - child 2 data end
+ - 0x43 - 01000011 - child 3 data end
+ - 0x80 - 10000000 - child 0 exited (stdin contains exit code)
+ - 0x81 - 10000001 - child 1 exited (stdin contains exit code)
+ - 0x82 - 10000010 - child 2 exited (stdin contains exit code)
+ - 0x83 - 10000011 - child 3 exited (stdin contains exit code)
+
+writing a byte to the stdout port (0x18) will send one byte of data to
+the emulator's stdout.
+
+writing a byte to the stderr port (0x19) will send one byte of data to
+the emulator's stderr.
+
+writing a byte to the proc-put port (0x1a) will send one byte of data
+to one of the emulator's child processes. the lower 2 bits of the opts
+port (0x1e) determine which one:
+
+ - 0x00: child 0
+ - 0x01: child 1
+ - 0x02: child 2
+ - 0x03: child 3
+
+the param ports (0x1c-0x1d) specify the a value to use as a parameter
+for a host-put (0x1f). the meaning values by host-put value:
+
+ - 0x00 - (nop) unused
+ - 0x01 - (execute) command string (e.g. 'gcc -o "demo" demo.c')
+ - 0x02 - (getpid) unused
+ - 0x03 - (kill) unused
+ - 0x04 - (raw-tty) unused
+ - 0x04 - (restore-tty) unused
+ - 0x10 - (getenv) name string (e.g. "TERM")
+ - 0x11 - (setenv) assignment string (e.g. "TERM=vt100")
+
+(strings must be null-terminated. commands are parsed by /bin/sh -c.)
+
+the opts port (0x1e) specifies options that affect host actions run
+using the host-put port (0x1f):
+
+ - lower 2 bits control which child process to use (when applicable)
+   + 0x00 - child 0
+   + 0x01 - child 1
+   + 0x02 - child 2
+   + 0x03 - child 3
+ - next 2 bits (0x0c) are unused
+ - upper 4 bits control which pipes to use with execute:
+   + 0x80 - use child's pty (implies 0x70)
+   + 0x40 - read from child's stderr
+   + 0x20 - read from child's stdout
+   + 0x10 - write to child's stdin
+
+the host-put port (0x1f) specifies which host action to take:
+
+ - 0x00 - nop: does nothing
+ - 0x01 - execute: reads command string, starts a subprocess
+ - 0x02 - getpid: responds with child process pid (if any)
+ - 0x03 - kill: shuts down child process
+ - 0x04 - put stdin tty into raw mode
+ - 0x05 - restore stdin tty to canonical mode
+ - 0x10 - getenv: looks up a name (e.g. TERM) in env, responds with value
+ - 0x11 - setenv: reads an assignment (e.g. TERM=vt100), updates env
+
+SYSTEM EXPANSION SUPPORT
+
+the system expansion port can be used to determine whether or not the
+console supports these additional capabilities. the convention is to
+use UUID-based extensions as defined by uxn38. the unix console device
+uses `01231250-d878-4462-bc41-d0927645a2fa` as its UUID, and uses the
+following expansion layout:
+
+  - operation (1 byte): 03 (uuid extension)
+  - device (1 byte): 10 (console)
+  - uuid (16 bytes): 0123 1250 d878 4462 bc41 d092 7645 a2fa
+  - version (1 byte): 00 (set to non-zero by supporting emulators)
+  - flags (2 byte): 0000 (updated by supporting emulators)
+
+after being loaded, version will be non-zero if console expansion is
+supported, and zero otherwise. flags will contain bits describing the
+available capabilities (0x0000 if console expansion is unsupported).
+the flags are as follows:
+
+ - 0x0001: supports `execute`
+ - 0x0002: supports `kill`
+ - 0x0004: supports `raw-tty`, `restore-tty`
+ - 0x0008: supports `getenv` and `setenv`
+ - 0x0010: supports writing to child stdin
+ - 0x0020: supports reading from child stdout
+ - 0x0040: supports reading from child stderr
+ - 0x0080: supports allocating child pty
+ - 0x0100 to 0x8000: (currently unused)
+
+currently uxn11 will write 0x00ff to the flags field, so programs
+wishing to detect unx11 can check for that value. here's a snippet
+that determines whether the console expansion can be used:
+
+  |00 @System [ &unused $2 &expansion $2 ( ... ) ]
+
+  |0010
+    ;query .System/expansion DEO2
+    ;query/flags LDA2 #00ff EQU2 ?enable-uxn11-console
+    BRK
+
+  @enable-uxn-console ...
+
+  @query 03 10 ( uuid ) 0123 1250 d878 4462 bc41 d092 7645 a2fa &flags 00 0000
+
+note that uxn11 unconditionally enables the expanded console. so in
+this case the uuid-based extension mechanism is only used to detect
+the presence (or absence) of emulator support. if device 0x10 is not
+provided then flags will be 0x0000 (moving or adding additional
+console devices is not supported).

src/devices/console.c

@@ -1,11 +1,17 @@
 #undef _POSIX_C_SOURCE
 #define _POSIX_C_SOURCE 200112L
 
+#ifdef __NetBSD__
+#define _NETBSD_SOURCE
+#endif
+
+#include <poll.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/select.h>
 #include <sys/wait.h>
+#include <termios.h>
 #include <unistd.h>
 
 #ifdef __linux
@@ -14,6 +20,7 @@
 
 #ifdef __NetBSD__
 #include <sys/ioctl.h>
+#include <sys/termios.h>
 #include <util.h>
 #endif
 
@@ -31,54 +38,293 @@ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 WITH REGARD TO THIS SOFTWARE.
 */
 
-/* process */
+#define child_ptys(mode) (mode & CONSOLE_MODE_PTY)
-static char *fork_args[32];
+#define child_reads(mode) (mode & CONSOLE_CHILD_READS)
-static int child_mode;
+#define child_writes(mode) (mode & CONSOLE_CHILD_WRITES)
-static int pty_fd;
+#define child_writes_out(mode) (mode & CONSOLE_MODE_OUT)
-static int to_child_fd[2];
+#define child_writes_err(mode) (mode & CONSOLE_MODE_ERR)
-static int from_child_fd[2];
+
-static int saved_in;
+UxnSubprocess children[CONSOLE_MAX_CHILDREN];
-static int saved_out;
+static char *fork_args[4] = {"/bin/sh", "-c", "", NULL};
-static pid_t child_pid;
+static int to_child_fd[2], from_child_fd[2];
-struct winsize ws = {24, 80, 8, 12};
+static char buf[16];
+static int raw_tty = 0;
+struct termios old_termios;
+
+static UxnSubprocess*
+find_child_by_pid(pid_t pid)
+{
+	for(int n = 0; n < CONSOLE_MAX_CHILDREN; n++)
+		if(children[n].pid == pid)
+			return &children[n];
+	return NULL;
+}
 
 static void
-parse_args(Uxn *u, Uint8 *d)
+handle_sigchld(int sig)
 {
-	Uint8 *port_addr = d + 0x3;
+	pid_t pid;
-	int addr = PEEK2(port_addr);
+	int n, wstatus;
-	char *pos = (char *)&u->ram[addr];
+	while((pid = waitpid(-1, &wstatus, WNOHANG)) > 0) {
-	int i = 0;
+		UxnSubprocess *child = find_child_by_pid(pid);
+		if (child != NULL) {
+			/* set running to negative when exiting for clean up */
+			child->running = WEXITSTATUS(wstatus) - 256;
+			/* close relevant file descriptors */
+			if(child_ptys(child->mode))
+				close(child->pty);
+			else {
+				if(child_reads(child->mode)) close(child->fd_in);
+				if(child_writes(child->mode)) close(child->fd_out);
+			}
+			/* reset fields to starting values */
+			child->pid = child->mode = 0;
+			child->fd_out = child->fd_in = child->pty = -1;
+			return;
+		}
+	}
+}
+
+static void
+start_fork_pty(UxnSubprocess *child, int mode)
+{
+	int fd = -1;
+	struct winsize ws = {23, 80, 8, 12};
+	pid_t pid = forkpty(&fd, NULL, NULL, &ws);
+	if(pid < 0) { /* failure */
+		fprintf(stderr, "parent fork failure\n");
+	} else if(pid == 0) { /* child */
+		execvp(fork_args[0], fork_args);
+		fprintf(stderr, "child exec failure\n");
+	} else { /*parent*/
 		do {
-		fork_args[i++] = pos;
+			child->pid = pid;
-		while(*pos != 0) pos++;
+			child->mode = mode;
-		pos++;
+			child->running = 1;
-	} while(*pos != '\0');
+			child->pty = fd;
-	fork_args[i] = NULL;
+			child->fd_in = fd;
+			child->fd_out = fd;
+		} while (child->pid != pid);
+		/* loop to avoid possible race with clean up */
+	}
 }
 
-/* call after we're sure the process has exited */
 static void
-clean_after_child(void)
+start_fork_pipe(UxnSubprocess *child, int mode)
 {
-	child_pid = 0;
+	if(child_reads(mode)) {
-	if(child_mode >= 0x80) {
+		/* parent writes to child's stdin */
-		close(pty_fd);
+		if(pipe(to_child_fd) == -1) {
-		dup2(saved_in, 0);
+			fprintf(stderr, "pipe error: to child\n");
-		dup2(saved_out, 1);
+			return;
-	} else {
+		}
-		if(child_mode & 0x01) {
+	}
+
+	if(child_writes(mode)) {
+		/* parent reads from child's stdout and/or stderr */
+		if(pipe(from_child_fd) == -1) {
+			fprintf(stderr, "pipe error: from child\n");
+			return;
+		}
+	}
+
+	pid_t pid = fork();
+	if(pid < 0) { /* failure */
+		fprintf(stderr, "fork failure\n");
+		return;
+	} else if(pid == 0) { /* child */
+		if(child_reads(mode)) {
+			dup2(to_child_fd[0], 0);
 			close(to_child_fd[1]);
-			dup2(saved_out, 1);
 		}
-		if(child_mode & 0x06) {
+		if(child_writes(mode)) {
+			if(child_writes_out(mode)) dup2(from_child_fd[1], 1);
+			if(child_writes_err(mode)) dup2(from_child_fd[1], 2);
 			close(from_child_fd[0]);
-			dup2(saved_in, 0);
+		}
+		execvp(fork_args[0], fork_args);
+		fprintf(stderr, "child exec failure\n");
+		exit(1);
+	} else { /*parent*/
+		do {
+			child->pid = pid;
+			child->mode = mode;
+			child->running = 1;
+			child->pty = -1;
+			child->fd_in  = child_reads(mode)  ? to_child_fd[1]   : -1;
+			child->fd_out = child_writes(mode) ? from_child_fd[0] : -1;
+		} while (child->pid != pid);
+		/* loop to avoid possible race with clean up */
+
+		/* close the unused end of pipes we opened */
+		if(child_reads(mode)) close(to_child_fd[0]);
+		if(child_writes(mode)) close(from_child_fd[1]);
+	}
+}
+
+static void
+std_put(Uint8 c, FILE *fd)
+{
+	fputc(c, fd);
+	fflush(fd);
+}
+
+static void
+proc_put(Uxn *u, Uint8 *d)
+{
+	Uint8 c = d[0xa];
+	int n = d[0xe] & 0x3;
+	write(children[n].fd_in, &c, 1);
+	fdatasync(children[n].fd_in);
+}
+
+static void
+host_execute(Uxn *u, Uint8 *d)
+{
+	int addr = PEEK2(d + 0xc);
+	int opts = d[0xe];
+	int mode = opts & 0xf0;
+	char *cmd = (char *)&u->ram[addr];
+	UxnSubprocess *child = &children[opts & 0x3];
+
+	fork_args[2] = cmd;
+	if(child->pid > 0)
+		kill(child->pid, 9);
+
+	if(opts >= 0x80)
+		start_fork_pty(child, mode);
+	else
+		start_fork_pipe(child, mode);
+}
+
+static void
+host_response(Uxn *u, char *s)
+{
+	for(int i = 0;; i++)
+		console_input(u, s[i], CONSOLE_HOST);
+	console_input(u, '\0', CONSOLE_HOST_END);
+}
+
+static void
+host_getpid(Uxn *u, Uint8 *d)
+{
+	int n = d[0xe] & 0x3;
+	snprintf(buf, 16, "%d", children[n].pid);
+	host_response(u, buf);
+}
+
+static void
+host_kill(Uxn *u, Uint8 *d)
+{
+	int n = d[0xe] & 0x3;
+	if(children[n].pid > 0)
+		kill(children[n].pid, 15);
+}
+
+static void
+host_raw_tty()
+{
+	if(!raw_tty) {
+		tcgetattr(STDIN_FILENO, &old_termios);
+		struct termios term = old_termios;
+		/* corresponds to `stty raw -echo` */
+		term.c_cflag |= (CS8);
+		term.c_iflag &= ~(IGNBRK | BRKINT | IGNPAR | PARMRK | INPCK | ISTRIP);
+		term.c_iflag &= ~(INLCR  | IGNCR | ICRNL | IXON | IXOFF | IXANY | IMAXBEL);
+		term.c_lflag &= ~(ICANON | ISIG | ECHO);
+		term.c_oflag &= ~(OPOST);
+		term.c_cc[VMIN] = 0;
+		term.c_cc[VTIME] = 1;
+		tcsetattr(0, TCSAFLUSH, &term);
+		raw_tty = 1;
+	}
+}
+
+static void
+host_restore_tty()
+{
+	if(raw_tty) {
+		tcsetattr(0, TCSAFLUSH, &old_termios);
+		raw_tty = 0;
+	}
+}
+
+static void
+host_getenv(Uxn *u, Uint8 *d)
+{
+	int addr = PEEK2(d + 0xc);
+	char *name = (char *)&u->ram[addr];
+	host_response(u, getenv(name));
+}
+
+static void
+host_setenv(Uxn *u, Uint8 *d)
+{
+	int addr = PEEK2(d + 0xc);
+	char *name = (char *)&u->ram[addr];
+	int i = 0;
+	while(name[i] != '=') i++;
+	if(name[i] == '=') {
+		name[i] = '\0';
+		char *value = &name[i+1];
+		setenv(name, value, 1);
+	} else {
+		fprintf(stderr, "mal-formed setenv\n");
+	}
+}
+
+static void
+host_put(Uxn *u, Uint8 *d)
+{
+	switch(d[0xf]) {
+	case 0x00: /* nop */ break;
+	case 0x01: host_execute(u, d); break;
+	case 0x02: host_getpid(u, d); break;
+	case 0x03: host_kill(u, d); break;
+	case 0x04: host_raw_tty(); break;
+	case 0x05: host_restore_tty(); break;
+	case 0x10: host_getenv(u, d); break;
+	case 0x11: host_setenv(u, d); break;
+	}
+}
+
+void
+init_console(void)
+{
+	/* set up signal handler for SIGCHLD */
+	struct sigaction sa;
+	sigemptyset(&sa.sa_mask);
+	sa.sa_flags = 0;
+	sa.sa_handler = handle_sigchld;
+	sigaction(SIGCHLD, &sa, NULL);
+
+	/* initialize (halted) children */
+	for(int i = 0; i < CONSOLE_MAX_CHILDREN; i++) {
+		UxnSubprocess *child = &children[i];
+		child->id = i;
+		child->pid = child->mode = child->running = 0;
+		child->fd_in = child->fd_out = child->pty = -1;
+	}
+}
+
+UxnSubprocess
+*get_child(int n)
+{
+	return &children[n & 0x3];
+}
+
+void
+console_monitor(Uxn *u)
+{
+	/*fflush(stdout);*/ /* TODO: needed? stderr? children? */
+	for(int n = 0; n < CONSOLE_MAX_CHILDREN; n++) {
+		UxnSubprocess *child = &children[n];
+		if(child->running < 0) {
+			Uint8 status = child->running + 256;
+			child->running = 0;
+			console_input(u, status, CONSOLE_CHILD_EXIT | n);
 		}
 	}
-	child_mode = 0;
-	saved_in = -1;
-	saved_out = -1;
 }
 
 int
@@ -96,137 +342,24 @@ console_listen(Uxn *u, int i, int argc, char **argv)
 	for(; i < argc; i++) {
 		char *p = argv[i];
 		while(*p) console_input(u, *p++, CONSOLE_ARG);
-		console_input(u, '\n', i == argc - 1 ? CONSOLE_END : CONSOLE_EOA);
+		console_input(u, '\n', i == argc - 1 ? CONSOLE_ARG_END : CONSOLE_ARG_SPACER);
 	}
 }
 
-static void
-start_fork_pty(Uint8 *d)
-{
-	int fd = -1;
-	pid_t pid = forkpty(&fd, NULL, NULL, NULL);
-	if(pid < 0) { /* failure */
-		d[0x6] = 0xff;
-		fprintf(stderr, "fork failure\n");
-	} else if(pid == 0) { /* child */
-		setenv("TERM", "ansi", 1);
-		execvp(fork_args[0], fork_args);
-		d[0x6] = 0xff;
-		fprintf(stderr, "exec failure\n");
-	} else { /*parent*/
-		child_pid = pid;
-		pty_fd = fd;
-		ioctl(fd, TIOCSWINSZ, &ws);
-		saved_in = dup(0);
-		saved_out = dup(1);
-		dup2(fd, 0);
-		dup2(fd, 1);
-	}
-}
-
-static void
-start_fork_pipe(Uint8 *d)
-{
-	if(child_mode & 0x01) {
-		/* parent writes to child's stdin */
-		if(pipe(to_child_fd) == -1) {
-			d[0x6] = 0xff;
-			fprintf(stderr, "pipe error: to child\n");
-			return;
-		}
-	}
-
-	if(child_mode & 0x06) {
-		/* parent reads from child's stdout and/or stderr */
-		if(pipe(from_child_fd) == -1) {
-			d[0x6] = 0xff;
-			fprintf(stderr, "pipe error: from child\n");
-			return;
-		}
-	}
-
-	pid_t pid = fork();
-	if(pid < 0) { /* failure */
-		d[0x6] = 0xff;
-		fprintf(stderr, "fork failure\n");
-	} else if(pid == 0) { /* child */
-		if(child_mode & 0x01) {
-			dup2(to_child_fd[0], 0);
-			close(to_child_fd[1]);
-		}
-		if(child_mode & 0x06) {
-			if(child_mode & 0x02) dup2(from_child_fd[1], 1);
-			if(child_mode & 0x04) dup2(from_child_fd[1], 2);
-			close(from_child_fd[0]);
-		}
-		execvp(fork_args[0], fork_args);
-		d[0x6] = 0xff;
-		fprintf(stderr, "exec failure\n");
-	} else { /*parent*/
-		child_pid = pid;
-		if(child_mode & 0x01) {
-			saved_out = dup(1);
-			dup2(to_child_fd[1], 1);
-			close(to_child_fd[0]);
-		}
-		if(child_mode & 0x06) {
-			saved_in = dup(0);
-			dup2(from_child_fd[0], 0);
-			close(from_child_fd[1]);
-		}
-	}
-}
-
-static void
-kill_child(Uint8 *d, int options)
-{
-	if(child_pid) {
-		kill(child_pid, 9);
-		int wstatus;
-		if(waitpid(child_pid, &wstatus, options)) {
-			d[0x6] = 1;
-			d[0x7] = WEXITSTATUS(wstatus);
-			clean_after_child();
-		}
-	}
-}
-
-static void
-start_fork(Uxn *u, Uint8 *d)
-{
-	fflush(stderr);
-	kill_child(d, 0);
-	child_mode = d[0x5];
-	parse_args(u, d);
-	if(child_mode >= 0x80)
-		start_fork_pty(d);
-	else
-		start_fork_pipe(d);
-}
-
 Uint8
 console_dei(Uxn *u, Uint8 addr)
 {
 	Uint8 port = addr & 0x0f, *d = &u->dev[addr & 0xf0];
-	switch(port) {
-	case 0x6:
-	case 0x7: kill_child(d, WNOHANG);
-	}
 	return d[port];
 }
 
 void
 console_deo(Uxn *u, Uint8 *d, Uint8 port)
 {
-	FILE *fd = NULL;
 	switch(port) {
-	case 0x5: /* Console/dead */ start_fork(u, d); break;
+	case 0x8: std_put(d[port], stdout); break;
-	case 0x6: /* Console/exit*/ kill_child(d, 0); break;
+	case 0x9: std_put(d[port], stderr); break;
-	case 0x8: fd = stdout; break;
+	case 0xa: proc_put(u, d); break;
-	case 0x9: fd = stderr; break;
+	case 0xf: host_put(u, d); break;
-	}
-	if(fd) {
-		fputc(d[port], fd);
-		fflush(fd);
 	}
 }

src/devices/console.h

@@ -11,12 +11,47 @@ WITH REGARD TO THIS SOFTWARE.
 
 #define CONSOLE_VERSION 1
 
-#define CONSOLE_STD 0x1
+#define CONSOLE_NONE       0x00
-#define CONSOLE_ARG 0x2
+#define CONSOLE_STDIN      0x01
-#define CONSOLE_EOA 0x3
+#define CONSOLE_ARG        0x02
-#define CONSOLE_END 0x4
+#define CONSOLE_ARG_SPACER 0x03
+#define CONSOLE_ARG_END    0x04
+#define CONSOLE_HOST       0x05
+#define CONSOLE_HOST_END   0x06
+#define CONSOLE_STDIN_END  0x07
 
+#define CONSOLE_CHILD_DATA 0x20 /* write from child-n: 0x20 | n */
+#define CONSOLE_CHILD_END  0x40 /* close from child-n: 0x40 | n */
+#define CONSOLE_CHILD_EXIT 0x80 /* exits from child-n: 0x80 | n */
+
+typedef struct UxnSubprocess {
+    int id;      /* identifier: 0-3 */
+    pid_t pid;   /* when running, pid > 0 */
+    int mode;    /* bit flags: CONSOLE_MODE_ */
+    int running; /* 0=stopped, >0 running, <0 exiting */
+    int fd_in;   /* fd to send to child; -1 is unset */
+    int fd_out;  /* fd to read from child; -1 is unset */
+    int pty;     /* pty for child; -1 is unset */
+} UxnSubprocess;
+
+void init_console(void);
+UxnSubprocess *get_child(int n);
+void console_monitor(Uxn *u);
 int console_input(Uxn *u, char c, int type);
 void console_listen(Uxn *u, int i, int argc, char **argv);
 Uint8 console_dei(Uxn *u, Uint8 addr);
 void console_deo(Uxn *u, Uint8 *d, Uint8 port);
+
+#define CONSOLE_MODE_PTY 0x80
+#define CONSOLE_MODE_ERR 0x40
+#define CONSOLE_MODE_OUT 0x20
+#define CONSOLE_MODE_INP 0x10
+
+/* CONSOLE_MODE_PTY | CONSOLE_MODE_INP */
+#define CONSOLE_CHILD_READS  0x90
+
+/* CONSOLE_MODE_PTY | CONSOLE_MODE_OUT | CONSOLE_MODE_ERR */
+#define CONSOLE_CHILD_WRITES 0xe0
+
+#define CONSOLE_MAX_CHILDREN 4
+

src/devices/system.c

@@ -100,6 +100,45 @@ system_boot(Uxn *u, Uint8 *ram, char *rom)
 	return 1;
 }
 
+static void
+system_expansion_copy(Uxn *u, Uint8 *ram, Uint16 addr)
+{
+	Uint16 i, length = PEEK2(ram + addr + 1);
+	Uint16 a_page = PEEK2(ram + addr + 1 + 2), a_addr = PEEK2(ram + addr + 1 + 4);
+	Uint16 b_page = PEEK2(ram + addr + 1 + 6), b_addr = PEEK2(ram + addr + 1 + 8);
+	int src = (a_page % RAM_PAGES) * 0x10000, dst = (b_page % RAM_PAGES) * 0x10000;
+	for(i = 0; i < length; i++)
+		ram[dst + (Uint16)(b_addr + i)] = ram[src + (Uint16)(a_addr + i)];
+}
+
+static int
+uuid_eq(Uint8 *m, Uint8 uuid[16])
+{
+	for(int i = 0; i < 16; i++)
+		if (m[i] != uuid[i])
+			return 0;
+	return 1;
+}
+
+/* console device: 01231250-d878-4462-bc41-d0927645a2fa */
+static Uint8 console_uuid[16] = {
+  0x01, 0x23, 0x12, 0x50, 0xd8, 0x78, 0x44, 0x62,
+  0xbc, 0x41, 0xd0, 0x92, 0x76, 0x45, 0xa2, 0xfa
+};
+
+static void
+system_expansion_uxn38_device(Uxn *u, Uint8 *ram, Uint16 addr)
+{
+	Uint8 dev_id = ram[addr + 1];
+	Uint8 *uuid = &ram[addr + 2];
+	if(uuid_eq(uuid, console_uuid) != 0) {
+		int ok = dev_id == 0x10 ? 0xff : 0x00;
+		ram[addr + 18] = ok;
+		ram[addr + 19] = 0x00;
+		ram[addr + 20] = ok;
+	}
+}
+
 /* IO */
 
 Uint8
@@ -121,14 +160,10 @@ system_deo(Uxn *u, Uint8 *d, Uint8 port)
 	case 0x3:
 		ram = u->ram;
 		addr = PEEK2(d + 2);
-		if(ram[addr] == 0x1) {
+		if(ram[addr] == 0x1)
-			Uint16 i, length = PEEK2(ram + addr + 1);
+			system_expansion_copy(u, ram, addr);
-			Uint16 a_page = PEEK2(ram + addr + 1 + 2), a_addr = PEEK2(ram + addr + 1 + 4);
+		else if(ram[addr] == 0x3)
-			Uint16 b_page = PEEK2(ram + addr + 1 + 6), b_addr = PEEK2(ram + addr + 1 + 8);
+			system_expansion_uxn38_device(u, ram, addr);
-			int src = (a_page % RAM_PAGES) * 0x10000, dst = (b_page % RAM_PAGES) * 0x10000;
-			for(i = 0; i < length; i++)
-				ram[dst + (Uint16)(b_addr + i)] = ram[src + (Uint16)(a_addr + i)];
-		}
 		break;
 	case 0x4:
 		u->wst.ptr = d[4];

src/uxn11.c

@@ -1,8 +1,10 @@
+#include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <X11/keysymdef.h>
+#include <string.h>
 #include <sys/timerfd.h>
 #include <unistd.h>
 #include <poll.h>
@@ -102,6 +104,7 @@ emu_end(Uxn *u)
 	XDestroyImage(ximage);
 	XDestroyWindow(display, window);
 	XCloseDisplay(display);
+	kill(0, 15);
 	exit(0);
 	return u->dev[0x0f] & 0x7f;
 }
@@ -131,6 +134,23 @@ toggle_scale(void)
 	screen_resize(uxn_screen.width, uxn_screen.height, s);
 }
 
+/* returns true if the fd ended (has been closed), false otherwise */
+static int
+handle_input(Uxn *u, struct pollfd pollfd, char *coninp, int argdata, int argend)
+{
+	if((pollfd.revents & POLLIN) != 0) {
+		int n = read(pollfd.fd, coninp, CONINBUFSIZE - 1);
+		coninp[n] = 0;
+		if(n == 0)
+			console_input(u, 0, argend);
+		else
+			for(int i = 0; i < n; i++)
+				console_input(u, coninp[i], argdata);
+		return n == 0;
+	} else
+		return 0;
+}
+
 static void
 emu_event(Uxn *u)
 {
@@ -200,6 +220,7 @@ display_init(void)
 	if(!display)
 		return system_error("init", "Display failed");
 	screen_resize(WIDTH, HEIGHT, 1);
+	init_console();
 	/* start window */
 	visual = DefaultVisual(display, 0);
 	if(visual->class != TrueColor)
@@ -224,9 +245,10 @@ static int
 emu_run(Uxn *u, char *rom)
 {
 	int i = 1, n;
+	int *child_fd_outs;
 	char expirations[8];
 	char coninp[CONINBUFSIZE];
-	struct pollfd fds[3];
+	struct pollfd fds[3 + CONSOLE_MAX_CHILDREN];
 	static const struct itimerspec screen_tspec = {{0, 16666666}, {0, 16666666}};
 	/* timer */
 	fds[0].fd = XConnectionNumber(display);
@@ -236,7 +258,11 @@ emu_run(Uxn *u, char *rom)
 	fds[0].events = fds[1].events = fds[2].events = POLLIN;
 	/* main loop */
 	while(!u->dev[0x0f]) {
-		if(poll(fds, 3, 1000) <= 0)
+		for(i = 0; i < CONSOLE_MAX_CHILDREN; i++) {
+			fds[i + 3].fd = get_child(i)->fd_out;
+			fds[i + 3].events = POLLIN;
+		}
+		if(poll(fds, 3 + CONSOLE_MAX_CHILDREN, 1000) <= 0)
 			continue;
 		while(XPending(display))
 			emu_event(u);
@@ -250,13 +276,18 @@ emu_run(Uxn *u, char *rom)
 				XPutImage(display, window, DefaultGC(display, 0), ximage, x, y, x + PAD, y + PAD, w, h);
 			}
 		}
-		if((fds[2].revents & POLLIN) != 0) {
+
-			n = read(fds[2].fd, coninp, CONINBUFSIZE - 1);
+		/* read input from stdin */
-			coninp[n] = 0;
+		handle_input(u, fds[2], coninp, CONSOLE_STDIN, CONSOLE_STDIN_END);
-			for(i = 0; i < n; i++)
+
-				console_input(u, coninp[i], CONSOLE_STD);
+		/* read input from child processes */
-		}
+		for(i = 0; i < CONSOLE_MAX_CHILDREN; i++)
+			handle_input(u, fds[i + 3], coninp, CONSOLE_CHILD_DATA | i, CONSOLE_CHILD_END | i);
+
+		/* check to see if any children exited */
+		console_monitor(u);
 	}
+	kill(0, 15);
 	return 1;
 }
 

src/uxncli.c

@@ -1,5 +1,8 @@
 #include <stdio.h>
 #include <stdlib.h>
+#include <unistd.h>
+#include <sys/select.h>
+#include <sys/time.h>
 
 #include "uxn.h"
 #include "devices/system.h"
@@ -42,16 +45,59 @@ emu_deo(Uxn *u, Uint8 addr, Uint8 value)
 	}
 }
 
+static void
+handle_input(Uxn *u, int fd, int port, int argdata, int argend)
+{
+	char buf[32];
+	int n = read(fd, &buf, 32);
+	if(n == 0)
+		console_input(u, 0x00, argend);
+	else
+		for(int i = 0; i < n; i++)
+			console_input(u, buf[i], argdata);
+}
+
+static int
+init_rfds(fd_set *rfds)
+{
+	int i, nfds;
+	FD_ZERO(rfds);
+	FD_SET(0, rfds);
+	nfds = 1;
+	for(i = 0; i < 4; i++) {
+		UxnSubprocess *child = get_child(i);
+		int fd = child->fd_out;
+		if (fd >= 0) {
+			FD_SET(fd, rfds);
+			if (fd >= nfds) nfds = fd + 1;
+		}
+	}
+	return nfds;
+}
+
 static void
 emu_run(Uxn *u)
 {
+	int i;
+	struct timeval tv;
+	fd_set rfds;
 	while(!u->dev[0x0f]) {
-		int c = fgetc(stdin);
+		int nfds = init_rfds(&rfds);
-		if(c == EOF) {
+		/* tv.tv_sec = 0; */
-			console_input(u, 0x00, CONSOLE_END);
+		tv.tv_sec = 0;
-			break;
+		tv.tv_usec = 1000;
+		int retval = select(nfds, &rfds, NULL, NULL, &tv);
+		if(retval > 0) {
+			/* printf("got something!\n"); */
+			if (FD_ISSET(0, &rfds))
+				handle_input(u, 0, 0x2, CONSOLE_STDIN, CONSOLE_STDIN_END);
+			for(i = 0; i < 4; i++) {
+				int fd = get_child(i)->fd_out;
+				if (fd > 2 && FD_ISSET(fd, &rfds))
+					handle_input(u, fd, 0x4, CONSOLE_CHILD_DATA | i, CONSOLE_CHILD_END | i);
 			}
-		console_input(u, (Uint8)c, CONSOLE_STD);
+		}
+		console_monitor(u);
 	}
 }
 
@@ -76,6 +122,7 @@ main(int argc, char **argv)
 		return system_error("Init", "Failed to initialize uxn.");
 	/* Game Loop */
 	u.dev[0x17] = argc - i;
+	init_console();
 	if(uxn_eval(&u, PAGE_PROGRAM) && PEEK2(u.dev + 0x10)) {
 		console_listen(&u, i, argc, argv);
 		emu_run(&u);