Extracted shell functionnality from main

Makefile.am

@@ -1,6 +1,6 @@
 bin_PROGRAMS = asmsh child
 
-libcheck_asmsh_a_SOURCES = mmap_parse.c asm_env.c compile.c logger.c completion.c
+libcheck_asmsh_a_SOURCES = mmap_parse.c asm_env.c compile.c logger.c completion.c shell.c
 
 asmsh_SOURCES = asmsh.c $(libcheck_asmsh_a_SOURCES)
 child_SOURCES = child.s

asmsh.c

@@ -5,9 +5,8 @@
 
 #define CHILD_EXEC_PATH "./child"
 
-#include "asm_env.h"
 #include "logger.h"
-#include "compile.h"
+#include "shell.h"
 #include "completion.h"
 
 static void print_regs(asmsh_env_t *env)
@@ -39,12 +38,10 @@ flags: %c%c%c%c|%c%c%c\n\
 
 int main(int argc, char *argv[], char *envp[])
 {
-	asmsh_asmc_ctx_t *cctx;
-	asmsh_env_t *env;
-	asmsh_bytecode_t bcode;
 	asmsh_logger_t *logger;
+	asmsh_t sh;
 	
-	int ret, status;
+	int ret;
 	char *cmd;
 	char prompt[64];
 	bzero(prompt, sizeof(prompt));
@@ -52,71 +49,48 @@ int main(int argc, char *argv[], char *envp[])
 	logger = asmsh_logger_new(ASMSH_INFO);
 	asmsh_logger_setup(logger);
 
-	if(!(env = asmsh_env(CHILD_EXEC_PATH)))
+	if(asmsh_init(&sh, CHILD_EXEC_PATH))
 	{
-		perror("Unable to init asm_env");
+		perror("Unable to init shell");
+		asmsh_logger_dprint(2, logger);
 		return 1;
 	}
-	if(!(cctx = asmsh_asmc_ctx_default()))
-	{
-		perror("Unable to init compilation ctx");
-	}
 
 	rl_special_prefixes="";
 	rl_basic_word_break_characters=" \t\n";
 	rl_attempted_completion_function =  asmsh_rl_completion;
 
-	status = 0;
-
 	while(1)
 	{
-		print_regs(env);
+		print_regs(sh.env);
 		snprintf(prompt, sizeof(prompt)-1,
 				"asmsh@%p > ",
-				env->regs.rip, status >> 8);
+				sh.env->regs.rip);
 		cmd = readline(prompt);
 		if(!cmd)
 		{
 			break;
 		}
-		if(strcmp(cmd, "quit") == 0)
-		{
-			break;
-		}
-		bcode.size = 0;
-		ret = asmsh_asmc_compile(cctx, cmd, &bcode);
-		asmsh_logger_dprint_fmt(2, logger, asmsh_log_lvl_fmt);
-		if(ret < 0)
-		{
-			continue;
-		}
-		if(!bcode.size)
-		{
-			asmsh_log_error("No bytecode returned...");
-			asmsh_logger_dprint_fmt(2, logger, asmsh_log_lvl_fmt);
-			continue;
-		}
-		if(asmsh_env_write_code(env, &bcode))
-		{
-			perror("Unable to write instruction");
-			goto err;
-		}
-		ret = asmsh_env_step(env, &status);
+		ret = asmsh_exec(&sh, cmd);
 		asmsh_logger_dprint_fmt(2, logger, asmsh_log_lvl_fmt);
-		if(ret)
+		if(ret > 0)
 		{
-			dprintf(2, "Child is dead...\n");
+			//unrecoverable error or exit (if ret == 1)
+			ret--; // exit status
+			if(ret)
+			{
+				dprintf(2, "Exit with status %d\n", ret);
+			}
 			break;
 		}
+		//else if (ret < 0) {} //recoverable errors
 		add_history(cmd);
 	}
 
-	asmsh_asmc_ctx_free(cctx);
-	asmsh_env_free(env);
-	return 0;
+	asmsh_cleanup(&sh);
+	return ret;
 
 err:
-	asmsh_asmc_ctx_free(cctx);
-	asmsh_env_free(env);
+	asmsh_cleanup(&sh);
 	return 1;
 }

compile.c

@@ -234,8 +234,6 @@ int asmsh_asmc_compile_unsafe(asmsh_asmc_ctx_t *ctx, const char *_instr,
 	}
 	if(!WIFEXITED(wstatus))
 	{
-		kill(ctx->child.pid, SIGKILL);
-		ctx->child.pid = -1;
 		if(WIFSTOPPED(wstatus))
 		{
 			asmsh_log_error("as stopped...");

logger.c

@@ -88,10 +88,11 @@ int asmsh_logger_dprint_fmt(int fd, asmsh_logger_t *logger, asmsh_log_fmt_f *cus
 				buf[BUF_ALLOC-(2+i)] = '.';
 			}
 		}
-		res += dprintf(fd, buf); /// TODO check result
+		res += dprintf(fd, buf); /// TODO use write & check result
 		cur = cur->nxt;
 	}
 	free(buf);
+	logger->nxt = logger->msgs;
 	return res;
 }
 

shell.c

@@ -0,0 +1,130 @@
+#include "shell.h"
+
+int asmsh_init(asmsh_t *sh, const char *child_path)
+{
+	bzero(sh, sizeof(asmsh_t));
+	if(!(sh->env = asmsh_env(child_path)))
+	{
+		asmsh_log_fatal("Unable to start child env");
+		goto err;
+	}
+	if(!(sh->cctx = asmsh_asmc_ctx_default()))
+	{
+		asmsh_log_fatal("Unable to start compilation context");
+		asmsh_env_free(sh->env);
+		goto err;
+	}
+	return 0;
+err:
+	bzero(sh, sizeof(asmsh_t));
+	return -1;
+}
+
+
+void asmsh_cleanup(asmsh_t *sh)
+{
+	if(!sh){ return; }
+	if(sh->cctx)
+	{
+		asmsh_asmc_ctx_free(sh->cctx);
+	}
+	if(sh->env)
+	{
+		asmsh_env_free(sh->env);
+	}
+	bzero(sh, sizeof(asmsh_t));
+}
+
+/** Attempt to compile and step if sucess */
+static int _compile_step(asmsh_t *sh, const char *cmd);
+/** Attempt to handle given shell internal command (starting with  '.') */
+static int _handle_command(asmsh_t *sh, const char *cmd);
+int asmsh_exec(asmsh_t *sh, const char *cmd)
+{
+	if(!cmd)
+	{
+		errno=EINVAL;
+		return -1;
+	}
+
+	int clen, ret;
+	//lstrip whitespace
+	for(cmd; *cmd && (*cmd == ' ' || *cmd == '\t'); cmd++);
+	if(!*cmd) { return 0; }
+
+	switch(*cmd)
+	{
+		case '.':
+			ret = _handle_command(sh, cmd);
+			break;
+		default:
+			ret = _compile_step(sh, cmd);
+			break;
+	}
+	return ret;
+}
+
+static int _compile_step(asmsh_t *sh, const char *cmd)
+{
+	int ret, status;
+	asmsh_bytecode_t bcode;
+
+	if(asmsh_asmc_compile(sh->cctx, cmd, &bcode) < 0)
+	{
+		return -1;
+	}
+	if(!bcode.size)
+	{
+		asmsh_log_error("No bytecode returned...");
+		return -1;
+	}
+	sh->last_bcode = bcode;
+	if(sh->last_instr) { free(sh->last_instr); }
+	sh->last_instr = strdup(cmd);
+char buf[256];
+int _ret;
+_ret = snprintf(buf, 255, "'%s' = 0x", cmd);
+for(int _i=0; _i<bcode.size; _i++)
+{
+	_ret += snprintf(buf+_ret, 255-_ret, "%02x", bcode.bytes[_i]);
+}
+_ret += snprintf(buf+_ret, 255-_ret, "(%d)", bcode.size);
+buf[_ret] = '\0';
+asmsh_log_info(buf);
+
+	if(asmsh_env_write_code(sh->env, &bcode))
+	{
+		return -1;
+	}
+
+	status=0;
+	ret = asmsh_env_step(sh->env, &status);
+	if(ret < 0)
+	{
+		perror("Unable to step");
+		asmsh_log_fatal("Error will child step");
+		return -1;
+	}
+	else if(ret > 0)
+	{
+		asmsh_log_fatal("Child exited with non-zero status");
+		return 1+WEXITSTATUS(status);
+	}
+	return 0;
+}
+
+static int _handle_command(asmsh_t *sh, const char *cmd)
+{
+	const int clen = strlen(cmd);
+
+	if(clen <= 1)
+	{
+		asmsh_log_error("No command given");
+		return 0;
+	}
+	if(strncmp(cmd, ".quit", clen) == 0)
+	{
+		asmsh_cleanup(sh);
+		return 1;
+	}
+}

shell.h

@@ -0,0 +1,30 @@
+#ifndef ASMSH_SHELL_H
+#define ASMSH_SHELL_H
+#include "config.h"
+
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "asm_env.h"
+#include "logger.h"
+#include "compile.h"
+
+typedef struct asmsh_s asmsh_t;
+
+struct asmsh_s
+{
+	asmsh_asmc_ctx_t *cctx;
+	asmsh_env_t *env;
+
+	char *last_instr;
+	asmsh_bytecode_t last_bcode;
+
+};
+
+int asmsh_init(asmsh_t *sh, const char *child_path);
+void asmsh_cleanup(asmsh_t *sh);
+
+/** @return <0 on error 0 on ok 1 on exit */
+int asmsh_exec(asmsh_t *sh, const char *cmd);
+
+#endif