Implements labels declaration & references

For the moment labels are only subsituted with relative notation
". +/- OFFSET"

README.md

 asmsh@0x7f3020bec00b > .regs %rbx
 rbx: 0000000000000042
 ```
+
+**Make a loop with a label**
+
+```text
+asmsh@0x7f0fadb73000 > mov $27, %rcx
+asmsh@0x7f0fadb73005 > .label print
+INFO: Label '@print' 00007f0fadb73005 added
+asmsh@0x7f0fadb73005 > push %rcx
+asmsh@0x7f0fadb73006 > mov $27,%rbx
+asmsh@0x7f0fadb7300b > sub %rcx, %rbx
+asmsh@0x7f0fadb7300e > add $0x0a40, %rbx
+asmsh@0x7f0fadb73015 > push %rbx
+asmsh@0x7f0fadb73016 > mov $1, %rax
+asmsh@0x7f0fadb7301b > mov %rax, %rdi
+asmsh@0x7f0fadb7301e > mov %rsp, %rsi
+asmsh@0x7f0fadb73021 > mov $2, %rdx
+asmsh@0x7f0fadb73026 > syscall
+@
+asmsh@0x7f0fadb73028 > pop %rbx
+asmsh@0x7f0fadb73029 > pop %rcx
+asmsh@0x7f0fadb7302a > .breakpoint after loop @print
+INFO: Set breakpoint @ 00007F0FADB7302C
+asmsh@0x7f0fadb73005 > .run
+[...]
+```
+
 ## Tests & docs
 
 **Run tests and coverage**

src/Makefile.am

 
 libcheck_asmsh_a_SOURCES = mmap_parse.c asm_env.c breakpoints.c compile.c logger.c \
 			   completion.c history.c \
-			   shell.c shell_cmds.c shell_sym.c \
+			   shell.c shell_cmds.c shell_sym.c shell_cmds_lib.c \
 			   shell_cmd_breakpoint.c
 
 noinst_HEADERS = asmsh.h mmap_parse.h asm_env.h breakpoints.h compile.h logger.h \
 		completion.h history.h \
-		shell.h shell_cmds.h shell_sym.h syscalls.h
+		shell.h shell_cmds.h shell_sym.h shell_cmds_lib.h syscalls.h
 
 
 asmsh_SOURCES = asmsh.c $(libcheck_asmsh_a_SOURCES)

src/asm_env.c

 		errno = err;
 		return NULL;
 	}
+	/** @todo better error checks & clean */
 	child_mmap_init(&(res->mmap));
 
 	asmsh_brk_init(&res->brks);
 
+	if(asmsh_symtable_init(&res->labels) < 0)
+	{
+		asmsh_log_perror("Unable to initialize labels symtable");
+		return NULL;
+	}
+
 	res->childpath = NULL;
 	if(childpath && (res->childpath = strdup(childpath)) == NULL)
 	{
 	}
 	kill(asmenv->pid, SIGKILL);
 	asmsh_brk_free(&asmenv->brks);
+	asmsh_symtable_clean(&asmenv->labels);
 	free(asmenv->childpath);
 	free(asmenv);
 }

src/asm_env.h

 #define ASMSH_CHILD_TEXT_MAP_SZ 0x1000 // defined in child.s
 
 typedef struct asmsh_env_s asmsh_env_t;
+#include "shell_sym.h"
 
 struct asmsh_env_s
 {
 	/** List of breakpoints addresses in child's memory */
 	asmsh_brk_t brks;
 
+	/** List of labels addresses in child's memory */
+	asmsh_symtable_t labels;
+
 	/** @todo check & delete useless properties */
 	/** Pointer on the next addr where we should write some
 	 *  compiled bytecode */

src/asmsh.h

 loop . - 4
 </pre>
 
+@par Labels
+Labels can be defined to ease relative jumps using the ".label" command.
+Labels are used using "@NAME" notation, they are substituted with
+". SIGN OFFSET" with SIGN and OFFSET calculated from RIP value.
+
+@par Example
+The instruction "loop @lbl" could be transformed in "loop . - 8"
+
 @section shell_cmds COMMANDS
 
+@par .breakpoint [CMD] [OPTS...]
+Handle breakpoint with different subcommands :
+- add (implicit) add a breakpoint at given address (or RIP value if no address given)
+- del remove a breakpoint at given address (or RIP)
+- list list all breakpoints
 @par .bytecode
 Compile an instruction and display it's bytecode
 @par .flags
 Display the CPU flags
 @par .help [COMMAND]
 Display the builtin help or the help of the command gioven as argument
+@par .label [NAME] [ADDR]
+Handle labels :
+- if no name given all labels are displayed.
+- if a name is given without address, a label is set at RIP value
+- if address is 0, the label is deleted
 @par .maps
 Display process memory maps
 @par .quit
 @par .reset
 Reset the shell (spawn a new process)
 
+@section Files
+
+@par ~/.local/share/asmsh/asmsh.history
+The command history file
+
 @section EXAMPLES
 
 @subsection example_exit Exit with a specific status
 rbx: 0000000000000042
 </pre>
 
+@subsection label_loop Make a loop using a label
+
+<pre>
+asmsh@0x7f0fadb73000 > mov $27, \%rcx
+asmsh@0x7f0fadb73005 > .label print
+INFO: Label '@print' 00007f0fadb73005 added
+asmsh@0x7f0fadb73005 > push \%rcx
+asmsh@0x7f0fadb73006 > mov $27,\%rbx
+asmsh@0x7f0fadb7300b > sub \%rcx, \%rbx
+asmsh@0x7f0fadb7300e > add $0x0a40, \%rbx
+asmsh@0x7f0fadb73015 > push \%rbx
+asmsh@0x7f0fadb73016 > mov $1, \%rax
+asmsh@0x7f0fadb7301b > mov \%rax, \%rdi
+asmsh@0x7f0fadb7301e > mov \%rsp, \%rsi
+asmsh@0x7f0fadb73021 > mov $2, \%rdx
+asmsh@0x7f0fadb73026 > syscall
+@
+asmsh@0x7f0fadb73028 > pop \%rbx
+asmsh@0x7f0fadb73029 > pop \%rcx
+asmsh@0x7f0fadb7302a > .breakpoint after loop @print
+INFO: Set breakpoint @ 00007F0FADB7302C
+asmsh@0x7f0fadb73005 > .run
+[...]
+</pre>
+
 @section TODO TODOLIST
 
 @todo Implement command for memory read/dump
-@todo Implement symbols for jumps
-@todo Add support for label declarations & references
 @todo Implement write without exec
 @todo Implement function declaration
 @todo Add switch between intel's & AT&T's syntaxes.
 @todo Implement a command to run until syscall only (and another for run until
 		breakpoint or syscall ?)
 @todo Rationalise commands argument parsing (at the moment .breakpoints allready uses special stuff :/)
+@todo Enhance support for labels & far/abs jump
+@todo Implement a script run mode without the prompt & without readline
 
 @section AUTHOR
 Written by Yann Weber &lt;yann.weber@members.fsf.org&gt;

src/history.c

 
 char * history_filename_init(const char *homedir)
 {
-	const char fmt[] = "%s/.local/share/asmsh";
+	const char fmt[] = ASMSH_HISTORY_PATH_FMT;
 	int sz;
 	const char *home = homedir?homedir:getenv("HOME");
 	if(!home)

src/history.h

 #include <sys/types.h>
 #include <sys/stat.h>
 
+#define ASMSH_HISTORY_PATH_FMT "%s/.local/share/asmsh"
+
 static const char ASMSH_HISTORY_FILE[] = "asmsh.history";
 
 typedef void(add_history_f)(const char*);

src/shell.c

 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)
+int asmsh_exec(asmsh_t *sh, const char *_cmd)
 {
-	if(!cmd)
+	if(!_cmd)
 	{
 		errno=EINVAL;
 		return -1;
 	}
 
+	char *cmd;
+	char prealloc_cmd[4096];
+	char *m_cmd = NULL;
+	cmd = prealloc_cmd;
+
+	size_t need_sz = asmsh_parse_labels(sh,
+			ASMSH_LABEL_SYM, _cmd, prealloc_cmd, 4096);
+	if(need_sz == 0)
+	{
+		return -1;
+	}
+
+	if(need_sz > 4096)
+	{
+		if(!(m_cmd = malloc(need_sz)))
+		{
+			asmsh_log_perror("Unable to allocate memory for parsed commandline");
+			return -1;
+		}
+		asmsh_parse_labels(sh, ASMSH_LABEL_SYM, _cmd, m_cmd, need_sz);
+		cmd = m_cmd;
+	}
+
 	int ret;
 	//lstrip whitespace
 	for(; *cmd && (*cmd == ' ' || *cmd == '\t'); cmd++);
 			ret = _compile_step(sh, cmd);
 			break;
 	}
+	if(m_cmd) { free(m_cmd); }
 	if(!ret)
 	{
 		asmsh_env_update_regs(sh->env);
 	asmsh_cmd_args_free(args);
 	return ret;
 }
+
+
+size_t asmsh_parse_labels(asmsh_t *sh, char preffix, const char *cmd,
+		char *buf, size_t buf_sz)
+{
+	asmsh_symtable_t *table = &sh->env->labels;
+	const char *cmdptr, *prevptr;
+	size_t res, prev_sz;
+	
+	cmdptr = prevptr = cmd;
+
+	res = 0;
+	prev_sz = 0;
+	while(*cmdptr)
+	{
+		if(*cmdptr != preffix)
+		{
+			cmdptr++;
+			prev_sz++;
+			continue;
+		}
+		if(res + prev_sz < buf_sz)
+		{
+			// enough buffer to write
+			memcpy(buf+res, prevptr, prev_sz);
+		}
+		res += prev_sz;
+		cmdptr++;
+		prevptr = cmdptr;
+		prev_sz = 0;
+		// cmdptr is on start of the symbol, looking for end
+		while(*cmdptr && ( (*cmdptr >= 'a' && *cmdptr <= 'z') ||\
+					(*cmdptr >= 'A' && *cmdptr <= 'Z') ||\
+					(*cmdptr >= '0' && *cmdptr <= '9') ||\
+					*cmdptr == '-' || *cmdptr == '_'))
+		{
+			cmdptr++;
+		}
+		size_t symlen=cmdptr-prevptr;
+		char symname[symlen+1];
+		memcpy(symname, prevptr, symlen);
+		symname[symlen] = '\0';
+
+		const asmsh_sym_t *sym = asmsh_symtable_get(table, symname);
+		if(!sym)
+		{
+			asmsh_log_error("Symbol '%c%s' not found",
+					preffix, symname);
+			return 0;
+		}
+
+		const char fmt_addr[] = ". %c 0x%lx";
+		char sign = sym->addr > sh->env->regs.rip ? '+': '-';
+		size_t offset = sym->addr > sh->env->regs.rip ?  \
+				sym->addr - sh->env->regs.rip:\
+				sh->env->regs.rip - sym->addr;
+		int sz_print = snprintf(NULL, 0, fmt_addr, sign, offset);
+		if(res + sz_print + 1 < buf_sz)
+		{
+			res += snprintf(&buf[res], sz_print+1, fmt_addr, sign, offset);
+		}
+		else
+		{
+			res += sz_print;
+		}
+		prevptr=cmdptr;
+		prev_sz=0;
+	}
+	if(res + prev_sz < buf_sz)
+	{
+		// enough buffer to writea
+		memcpy(buf+res, prevptr, prev_sz);
+	}
+	res += prev_sz;
+	if(res < buf_sz)
+	{
+		buf[res] = '\0';
+		res++;
+	}
+	else if(buf_sz)
+	{
+		// ensure \0 is at end of string
+		buf[buf_sz-1] = '\0';
+	}
+	return res;
+}
+

src/shell.h

 /** @return <0 on error 0 on ok 1 on exit */
 int asmsh_exec(asmsh_t *sh, const char *cmd);
 
+/** Parse all symbols found in given command
+ * @param asmsh_t* The shell
+ * @param char The prefix character before a symbol name
+ * @param const char* The string we want to parse
+ * @param char* A pointer on a buffer large enough to store the parsed string
+ * @param size_t The buffer size
+ * @return 0 on error else return the needed buffer size
+ */
+size_t asmsh_parse_labels(asmsh_t *sh, char preffix, const char *cmd,
+		char *buf, size_t buf_sz);
 
 #include "shell_cmds.h" // declares the static commands list
 

src/shell_cmd_breakpoint.c

  */
 static int brk_ls(asmsh_t *sh, asmsh_cmd_args_t *args, int expr_first);
 
-/** Parse a breakpoint address expression
- *
- * An expression must be of the form A [OP B] with A and B
- * an integer or '.' for current RIP value and OP one of + or -
- *
- * @param asmsh_cmd_args_t* The breakpoint command argument list
- * @param int The first argument of the address expression
- * @param const unsigned long RIP value
- * @param unsigned long* A pointer on the result address
- *
- * @returns -1 on error and 0 if ok
- */
-static int parse_addr_expr(asmsh_cmd_args_t *args, int first,
-		const unsigned long rip,  unsigned long *addr);
-
-/** Utility function for @ref parse_addr_expr() that parse an expression value.
- *
- * An expression can be . for rip value or an unsigned long, possibly in hex, etc
- * @param const char* The value
- * @param unsigned long The value of RIP
- * @param unsigned long* A pointer on the result
- * @return -1 on error else 0
- */
-static int addr_expr_val(const char *val, unsigned long rip, unsigned long *res);
-
 /** Add a breakpoint and display a message about it
  * @param asmsh_t The shell
  * @param unsigned long The breakpoint address
 static int brk_add_or_err(asmsh_t *sh, unsigned long addr);
 
 
-void log_expr_usage()
-{
-	asmsh_log_info("Expected an address expression of the form A + B or A - B with A and B an integer or '.' (for current RIP value)");
-}
-
 void log_brk_usage()
 {
 	asmsh_log_info("Available commands are :");
 	asmsh_log_info("\t\tAdd a new breakpoint after an instruction");
 	asmsh_log_info("\tlist|ls|l");
 	asmsh_log_info("\t\tList existing breakpoints");
-	log_expr_usage();
+	asmsh_log_addr_expr_usage();
 }
 
 
 	{
 		if((ret = brk_add(sh, args, 0)) < 0)
 		{
-			log_expr_usage();
+			asmsh_log_addr_expr_usage();
 		}
 		return ret;
 	}
 	{
 		if((ret = brk_add(sh, args, 1)) < 0)
 		{
-			log_expr_usage();
+			asmsh_log_addr_expr_usage();
 		}
 		return ret;
 	}
 
 	unsigned long addr;
 
-	if(parse_addr_expr(args, expr_first, rip, &addr) < 0)
+	if(asmsh_cmd_parse_addr_expr(args, expr_first, rip, &addr) < 0)
 	{
 		return -1;
 	}
 
 	unsigned long addr;
 
-	if(parse_addr_expr(args, expr_first, rip, &addr) < 0)
+	if(asmsh_cmd_parse_addr_expr(args, expr_first, rip, &addr) < 0)
 	{
 		return -1;
 	}
 	return 0;
 }
 
-static int addr_expr_val(const char *val, unsigned long rip, unsigned long *res)
-{
-	if(strcmp(".", val) == 0)
-	{
-		*res = rip;
-		return 0;
-	}
-
-	char *endptr;
-	errno = 0;
-	*res = strtoul(val, &endptr, 0);
-	if(errno != 0)
-	{
-		return -1;
-	}
-	else if(*endptr != '\0')
-	{
-		errno = EINVAL;
-		return -1;
-	}
-	return 0;
-}
-
-static int parse_addr_expr(asmsh_cmd_args_t *args, int first,
-		const unsigned long rip, unsigned long *addr)
-{
-	char * const * argv = args->args + first;
-	const int argc = args->argc - first;
-
-	unsigned long val[2];
-
-	switch(argc)
-	{
-		case 0:
-			*addr = rip;
-			break;
-		case 1:
-			if(addr_expr_val(argv[0], rip, addr) < 0)
-			{
-				int err = errno;
-				asmsh_log_error("Invalid expression value '%s': %s",
-						argv[0], strerror(errno));
-				errno = err;
-				return -1;
-			}
-			break;
-		case 3:
-
-			for(int i=0; i<2; i++)
-			{
-				const char *arg = i ? argv[2]:argv[0];
-				if(addr_expr_val(arg, rip, &val[i]) < 0)
-				{
-
-					asmsh_log_error("Invalid value '%s' in expression '%s %s %s' : %s",
-							arg,
-							argv[0], argv[1], argv[2],
-							strerror(errno));
-					return -1;
-				}
-			}
-
-			const char operator = strlen(argv[1]) == 1 ? argv[1][0]: '\0';
-			switch(operator)
-			{
-				case '+':
-					*addr = val[0] + val[1];
-					break;
-				case '-':
-					*addr = val[0] - val[1];
-					break;
-				default:
-					asmsh_log_error("Invalid operator '%s' in expression '%s %s %s'",
-							argv[1],
-							argv[0], argv[1], argv[2]);
-					return -1;
-			}
-			break;
-		default:
-			//USAGE !
-			asmsh_log_error("Unexexpected argument count for an expression. Expecting one of 0, 1 or 3 but got %d", argc);
-			return -1;
-	}
-	return 0;
-}

src/shell_cmds.c

 	return 0;
 }
 
+
+int asmsh_cmd_label(asmsh_t *sh, asmsh_cmd_args_t *args)
+{
+	const unsigned long rip = sh->env->regs.rip;
+
+	unsigned long addr;
+
+	if(args->argc == 0)
+	{
+		if(sh->env->labels.syms_sz == 0)
+		{
+			printf("No label defined...\n");
+			asmsh_log_info("Use '.label NAME [addr]' to define a label");
+			return 0;
+		}
+		printf("%3ld labels :\n", sh->env->labels.syms_sz);
+		for(size_t i=0; i<sh->env->labels.syms_sz; i++)
+		{
+			printf("\t%c%s\t %016lx\n",
+					ASMSH_LABEL_SYM,
+					sh->env->labels.syms[i].name,
+					sh->env->labels.syms[i].addr);
+		}
+		return 0;
+	}
+	if(args->argc == 1)
+	{
+		addr = rip;
+	}
+	else
+	{
+		if(asmsh_cmd_parse_addr_expr(args, 1, rip, &addr) < 0)
+		{
+			asmsh_log_addr_expr_usage();
+			return -1;
+		}
+	}
+
+	int ret;
+	const char *label = args->args[0];
+	if(addr == 0)
+	{
+		ret = asmsh_symtable_del(&sh->env->labels, label);
+		if(ret < 0)
+		{
+			asmsh_log_perror("Unable to delete label");
+			return -1;
+		}
+		else if(ret > 0)
+		{
+			asmsh_log_warning("No label '%c%s'",
+					ASMSH_LABEL_SYM, label);
+			return -1;
+		}
+		asmsh_log_info("Label '%c%s' deleted", 
+				ASMSH_LABEL_SYM, label);
+		return 0;
+	}
+	ret = asmsh_symtable_add(&sh->env->labels, label, addr);
+	if(ret < 0)
+	{
+		asmsh_log_perror("Unable to add label");
+		return -1;
+	}
+	else if(ret > 0)
+	{
+		asmsh_log_warning("Label '%c%s' updated to %016x",
+				ASMSH_LABEL_SYM, label, addr);
+		return 0;
+	}
+	asmsh_log_info("Label '%c%s' %016lx added",
+			ASMSH_LABEL_SYM, label, addr);
+	return ret;
+}
+
+
 int asmsh_cmd_maps(asmsh_t *sh, asmsh_cmd_args_t *args)
 {
 	if(asmsh_env_update_maps(sh->env) < 0)

src/shell_cmds.h

 typedef struct asmsh_cmd_args_s asmsh_cmd_args_t;
 #include "shell.h"
 #include "asm_env.h"
+#include "shell_cmds_lib.h"
+#include "shell_sym.h"
 
 /** @return <0 on recoverable error 0 on ok, 1+status on exit */
 typedef int (asmsh_cmd_f)(asmsh_t*, asmsh_cmd_args_t*);
 
 const char *asmsh_cmd_help(asmsh_t *sh);
 
-
 /*
  * Commands declaration
  *
 // Quit the shell
 int asmsh_cmd_quit(asmsh_t *sh, asmsh_cmd_args_t *args);
 
-// Defined in @file shell_cmd_breakpoint.c
+// Defined in @ref shell_cmd_breakpoint.c
 int asmsh_cmd_breakpoint(asmsh_t *sh, asmsh_cmd_args_t *args);
 
 // Print an instruction bytecode 
 int asmsh_cmd_bcode_(asmsh_t *sh, char *buf, int bufsz, int argc, char **args);
 int asmsh_cmd_bcode(asmsh_t *sh, asmsh_cmd_args_t *args);
 
+// Defined in @ref shell_cmd_label.c
+int asmsh_cmd_label(asmsh_t* sh, asmsh_cmd_args_t *args);
+
 int asmsh_cmd_maps(asmsh_t *sh, asmsh_cmd_args_t *args);
 
 int asmsh_cmd_print_regs(asmsh_t *sh, asmsh_cmd_args_t *args);
  */
 static const asmsh_cmd_t asmsh_CMDS[] = {
 	{".breakpoint", asmsh_cmd_breakpoint, 3,
-	 ".br(eakpoint)", "[addr]",
+	 ".br(eakpoint)", "[add|del|list] [addr]",
 	 "Set a breakpoint"},
 	{".bytecode", asmsh_cmd_bcode, 2,
 	 ".b(ytecode)", "",
 	{".help", asmsh_cmd_help_, 2,
 	 ".h(elp)","[cmd]",
 	 "display this help or the help of specified command"},
+	{".label", asmsh_cmd_label, 2,
+	 ".l(abel)", "label_name [addr]",
+	 "Set a label at given address (or . if none given)"},
 	{".maps", asmsh_cmd_maps, 2,
 	 ".m(aps)", "",
 	 "display memory maps"},

src/shell_cmds_lib.c

+#include "shell_cmds_lib.h"
+
+/** Utility function for @ref asmsh_cmd_parse_addr_expr() that parse an expression value.
+ *
+ * An expression can be . for rip value or an unsigned long, possibly in hex, etc
+ * @param const char* The value
+ * @param unsigned long The value of RIP
+ * @param unsigned long* A pointer on the result
+ * @return -1 on error else 0
+ */
+static int addr_expr_val(const char *val, unsigned long rip, unsigned long *res);
+
+
+void asmsh_log_addr_expr_usage()
+{
+	asmsh_log_info("Expected an address expression of the form A + B or A - B with A and B an integer or '.' (for current RIP value)");
+}
+
+
+int asmsh_cmd_parse_addr_expr(asmsh_cmd_args_t *args, int first,
+		const unsigned long rip, unsigned long *addr)
+{
+	char * const * argv = args->args + first;
+	const int argc = args->argc - first;
+
+	unsigned long val[2];
+
+	switch(argc)
+	{
+		case 0:
+			*addr = rip;
+			break;
+		case 1:
+			if(addr_expr_val(argv[0], rip, addr) < 0)
+			{
+				int err = errno;
+				asmsh_log_error("Invalid expression value '%s': %s",
+						argv[0], strerror(errno));
+				errno = err;
+				return -1;
+			}
+			break;
+		case 3:
+
+			for(int i=0; i<2; i++)
+			{
+				const char *arg = i ? argv[2]:argv[0];
+				if(addr_expr_val(arg, rip, &val[i]) < 0)
+				{
+
+					asmsh_log_error("Invalid value '%s' in expression '%s %s %s' : %s",
+							arg,
+							argv[0], argv[1], argv[2],
+							strerror(errno));
+					return -1;
+				}
+			}
+
+			const char operator = strlen(argv[1]) == 1 ? argv[1][0]: '\0';
+			switch(operator)
+			{
+				case '+':
+					*addr = val[0] + val[1];
+					break;
+				case '-':
+					*addr = val[0] - val[1];
+					break;
+				default:
+					asmsh_log_error("Invalid operator '%s' in expression '%s %s %s'",
+							argv[1],
+							argv[0], argv[1], argv[2]);
+					return -1;
+			}
+			break;
+		default:
+			//USAGE !
+			asmsh_log_error("Unexexpected argument count for an expression. Expecting one of 0, 1 or 3 but got %d", argc);
+			return -1;
+	}
+	return 0;
+}
+
+
+static int addr_expr_val(const char *val, unsigned long rip, unsigned long *res)
+{
+	if(strcmp(".", val) == 0)
+	{
+		*res = rip;
+		return 0;
+	}
+
+	char *endptr;
+	errno = 0;
+	*res = strtoul(val, &endptr, 0);
+	if(errno != 0)
+	{
+		return -1;
+	}
+	else if(*endptr != '\0')
+	{
+		errno = EINVAL;
+		return -1;
+	}
+	return 0;
+}
+

src/shell_cmds_lib.h

+/* Copyright Yann Weber <asmsh@yannweb.net>
+   This file is part of asmsh.
+
+   asmsh is free software: you can redistribute it and/or modify it under the
+   terms of the GNU General Public License as published by the Free Software
+   Foundation, either version 3 of the License, or any later version.
+   
+   asmsh is distributed in the hope that it will be useful, but WITHOUT ANY
+   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+   FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+   details.
+   
+   You should have received a copy of the GNU General Public License along
+   with asmsh. If not, see <https://www.gnu.org/licenses/>.
+*/
+#ifndef ASMSH_SHELL_CMDS_LIB_H
+#define ASMSH_SHELL_CMDS_LIB_H
+#include "config.h"
+
+#include "logger.h"
+#include "shell_cmds.h"
+
+/** Logs address expression usage */
+void asmsh_log_addr_expr_usage();
+
+
+/** Parse an address expression
+ *
+ * An expression must be of the form A [OP B] with A and B
+ * an integer or '.' for current RIP value and OP one of + or -
+ *
+ * @param asmsh_cmd_args_t* The breakpoint command argument list
+ * @param int The first argument of the address expression
+ * @param const unsigned long RIP value
+ * @param unsigned long* A pointer on the result address
+ *
+ * @returns -1 on error and 0 if ok
+ */
+int asmsh_cmd_parse_addr_expr(asmsh_cmd_args_t *args, int first,
+		const unsigned long rip,  unsigned long *addr);
+
+#endif
+

src/shell_sym.c

 			}
 			*/
 			table->syms[i].addr = val;
-			return 0;
+			return 1;
 		}
 		else if(cmp > 0)
 		{
 {
 	if(strlen(name) > ASMSH_VARNAME_MAX)
 	{
-		return 0;
+		return -1;
 	}
 	int i=0;
 	for(i=0; i<table->syms_sz;  i++)
 	}
 	if(i==table->syms_sz)
 	{
-		return 0; // not found
+		return 1; // not found
 	}
 	//if(table->freeval) { free(table->syms[i].val); }
 	if(table->syms_sz > i+1)
 					sizeof(*table->syms)*table->alloc);
 			if(!tmp)
 			{
-				return 0; // :/
+				return -1; // :/
 			}
 			table->syms = tmp;
 		}
 	}
 	table->syms_sz--;
-	return 1; // 1 deleted
+	return 0;
 }
 
 
 	return NULL;
 }
 
+

src/shell_sym.h

 #define ASMSH_VARNAME_MAX 256
 #define ASMSH_SYMALLOC 64
 
+/** The symbol prefixing a label */
+#define ASMSH_LABEL_SYM '@'
+
 typedef struct asmsh_sym_s asmsh_sym_t;
 typedef struct asmsh_symtable_s asmsh_symtable_t;
 
 int asmsh_symtable_init(asmsh_symtable_t *table);
 void asmsh_symtable_clean(asmsh_symtable_t *table);
 
+/**
+ * @return 1 on update 0 on added -1 on error */
 int asmsh_symtable_add(asmsh_symtable_t *table, const char *name, unsigned long val);
+/**
+ * @return 0 on deleted, 1 on not found, -1 on error */
 int asmsh_symtable_del(asmsh_symtable_t *table, const char *name);
+/**
+ * @return NULL on error or not found else a ref */
 const asmsh_sym_t *asmsh_symtable_get(asmsh_symtable_t *table, const char *name);
 
-
 #include "shell.h"
 
 #endif

tests/tests_shell_sym.c

 	ck_assert_int_eq(st.syms_sz, 1);
 	ck_assert_int_eq(asmsh_symtable_add(&st, "a", 0), 0);
 	ck_assert_int_eq(st.syms_sz, 2);
-	ck_assert_int_eq(asmsh_symtable_add(&st, "a", 0), 0);
+	ck_assert_int_eq(asmsh_symtable_add(&st, "a", 0), 1);
 	ck_assert_int_eq(st.syms_sz, 2);
 	ck_assert_int_eq(asmsh_symtable_add(&st, "ab", 0), 0);
 	ck_assert_int_eq(st.syms_sz, 3);
 
 	asmsh_symtable_t st;
 	ck_assert_int_eq(asmsh_symtable_init(&st), 0);
-	ck_assert_int_eq(asmsh_symtable_del(&st, "a"), 0);
-	ck_assert_int_eq(asmsh_symtable_add(&st, "a", 0), 0);
 	ck_assert_int_eq(asmsh_symtable_del(&st, "a"), 1);
+	ck_assert_int_eq(asmsh_symtable_add(&st, "a", 0), 0);
 	ck_assert_int_eq(asmsh_symtable_del(&st, "a"), 0);
+	ck_assert_int_eq(asmsh_symtable_del(&st, "a"), 1);
 	ck_assert_int_eq(asmsh_symtable_add(&st, "a", 0), 0);
 	ck_assert_int_eq(asmsh_symtable_add(&st, "b", 0), 0);
 	ck_assert_int_eq(asmsh_symtable_add(&st, "c", 0), 0);
-	ck_assert_int_eq(asmsh_symtable_del(&st, "d"), 0);
-	ck_assert_int_eq(asmsh_symtable_del(&st, "b"), 1);
+	ck_assert_int_eq(asmsh_symtable_del(&st, "d"), 1);
 	ck_assert_int_eq(asmsh_symtable_del(&st, "b"), 0);
+	ck_assert_int_eq(asmsh_symtable_del(&st, "b"), 1);
 	ck_assert_int_eq(asmsh_symtable_add(&st, "b", 0), 0);
-	ck_assert_int_eq(asmsh_symtable_del(&st, "a"), 1);
 	ck_assert_int_eq(asmsh_symtable_del(&st, "a"), 0);
+	ck_assert_int_eq(asmsh_symtable_del(&st, "a"), 1);
 	asmsh_symtable_clean(&st);
 }
 END_TEST
 	s = asmsh_symtable_get(&st, "a");
 	ck_assert_ptr_nonnull(s);
 	ck_assert_int_eq(s->addr, 0);
-	ck_assert_int_eq(asmsh_symtable_add(&st, "a", 42), 0);
+	ck_assert_int_eq(asmsh_symtable_add(&st, "a", 42), 1);
 	s = asmsh_symtable_get(&st, "a");
 	ck_assert_ptr_nonnull(s);
 	ck_assert_int_eq(s->addr, 42);