Implemented argument completion

asmsh.c

@@ -86,6 +86,8 @@ int main(int argc, char *argv[], char *envp[])
 		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;

completion.c

@@ -1,7 +1,5 @@
 #include "completion.h"
 
-/// Replace uppper char leading macro if needed
-static int _completion_upper_macro(const char *macro, const char *start, char **ret, size_t *i);
 
 char **asmsh_completion(const char *buf, const char *text, int start, int end)
 {
@@ -22,6 +20,8 @@ char **asmsh_completion(const char *buf, const char *text, int start, int end)
 }
 
 
+/// Replace uppper char leading macro if needed
+static int _completion_upper_macro(const char *macro, const char *start, char **ret, size_t *i);
 char **asmsh_compl_instr(const char *start)
 {
 	const size_t icount = sizeof(x86_64_instr)/sizeof(*x86_64_instr);
@@ -116,23 +116,46 @@ err_strdup:
 
 
 
+/// match against macro
+static int _completion_macro_match(const char *macro, const char *buf, int mlen);
 char **asmsh_compl_arg(const char *buf, const char *text, int start)
 {
-	char **ret;
+	const asmsh_compinstr_t *match = NULL;
+	int argno;
+	int i, tlen;
+	int matchlen = 0;
+	int macro = 0;
+
+	char **ret = malloc(sizeof(char*)*512); /* large enough */
+	if(!ret)
+	{
+		perror("unable to allocate buffer");
+		return NULL;
+	}
+	bzero(ret, sizeof(char*)*512);
 
-	int match = -1;
+	tlen = text?strlen(text):0;
 
 	for(int i=0; i<(sizeof(x86_64_instr)/sizeof(*x86_64_instr))-1; i++)
 	{
+		int cmp;
 		const char *instr = x86_64_instr[i].mnemo;
 		int ilen = strlen(instr);
-		int macro = 0;
+		macro=0;
 		if(instr[ilen-1] >= 'A' && instr[ilen-1] <= 'Z')
 		{
 			ilen--;
 			macro = 1;
+			cmp = _completion_macro_match(instr, buf, ilen);
+			if(cmp < 0)
+			{
+				goto err;
+			}
+		}
+		else
+		{
+			cmp = strncmp(buf, instr, ilen);
 		}
-		int cmp = strncmp(buf, instr, ilen);
 		if(cmp < 0)
 		{
 			break;
@@ -146,17 +169,102 @@ char **asmsh_compl_arg(const char *buf, const char *text, int start)
 			continue; //not a full match
 		}
 		// match or approximate macro match
-		match = i;
+		match = &x86_64_instr[i];
+		matchlen = ilen;
+		while(buf[matchlen] && buf[matchlen] != ' ' && buf[matchlen] != '\t')
+		{
+			matchlen++;
+		}
 		break;
 	}
-	if(match < 0)
+	if(!match)
 	{
 		ret = malloc(sizeof(char*));
 		*ret = NULL;
 		return ret;
 	}
+	argno=0;
+	for(i=matchlen; i<=start; i++)
+	{
+		if(buf[i] == ',')
+		{
+			argno=1;
+		}
+	}
+
+	int args = argno?match->arg2:match->arg1;
+	if(macro && match->mnemo[strlen(match->mnemo)-1] == 'S')
+	{
+		int wreg=ASHCOMP_REGALL;
+		switch(buf[matchlen-1])
+		{
+			case 'b'://M_sizes[0]:
+				wreg = ASHCOMP_REG8;
+				break;
+			case 'w'://M_sizes[1]:
+				wreg = ASHCOMP_REG16;
+				break;
+			case 'd'://M_sizes[2]:
+				wreg = ASHCOMP_REG32;
+				break;
+			case 'q'://M_sizes[3]:
+				wreg = ASHCOMP_REG64;
+				break;
+			default:
+				wreg = ASHCOMP_REGALL;
+				break;
+		}
+		args &= (0xff ^ ASHCOMP_REGALL) | wreg;
+	}
+
+	i=0;// result index
+	for(const asmsh_symtable_elt_t *elt=asmsh_symtable; elt->regs; elt++)
+	{
+		if(!(elt->flag & args))
+		{
+			continue;
+		}
+		if(elt->flag == ASHCOMP_IMM && tlen > 1 && *text=='$')
+		{
+			// immediate value handling
+			continue;
+		}
+		for(const char * const *r=elt->regs; *r; r++)
+		{
+			if(tlen && strncmp(text, *r, tlen))
+			{
+				continue;
+			}
+			if(!(ret[i] = strdup(*r)))
+			{
+				goto err_strdup;
+			}
+			if(argno == 0 && **r == '%')
+			{
+				//full match on arg0 adding ","
+				char *tmp = ret[i];
+				char buf[32];
+				snprintf(buf, 31, "%s,", tmp);
+				ret[i] = strdup(buf);
+			}
+			i++;
+		}
+	}
 	
 	return ret;
+
+err_strdup:
+	perror("Unable to strdup arg match");
+	i--;
+	while(i>=0)
+	{
+		free(ret[i]);
+		i--;
+	}
+err:
+	free(ret);
+	return NULL;
+
 }
 
 
@@ -261,3 +369,38 @@ static int _completion_upper_macro(const char *macro, const char *start, char **
 	return 1;
 }
 
+
+static int _completion_macro_match(const char *macro, const char *text, int mlen)
+{
+	char buf[32];
+	memcpy(buf, macro, mlen);
+	buf[mlen] = '\0';
+	switch(macro[mlen])
+	{
+		case 'C':
+			for(const char * const *cond = M_conds;*cond;cond++)
+			{
+				int ret=snprintf(&buf[mlen], 31-mlen, "%s", *cond);
+				int cmp = strncmp(text, buf, mlen+ret);
+				if(cmp ==  0)
+				{
+					return 0;
+				}
+			}
+			break;
+		case 'S':
+			for(const char * sz=M_sizes; *sz; sz++)
+			{
+				buf[mlen] = *sz;
+				buf[mlen+1] = '\0';
+				int cmp =  strncmp(text, buf, mlen+1);
+				if(cmp == 0)
+				{
+					return 0;
+				}
+			}
+			break;
+	}
+	return 1;
+}
+

completion.h

@@ -73,6 +73,9 @@ static char *asmsh_rl_completion_gen(const char *text, int state)
 	}
 	return res;
 }
+extern int rl_attempted_completion_over;
+extern const char* rl_special_prefixes;
+extern const char* rl_basic_word_break_characters;
 static char **asmsh_rl_completion(const char *text, int start, int end)
 {
 	rl_attempted_completion_over = 1;
@@ -88,7 +91,7 @@ char **asmsh_compl_instr(const char *start);
 char **asmsh_compl_arg(const char *buf, const char *text, int start);
 
 static const char * const M_conds[] = {"o","no","b","c","nae","ae","nb","nc","e","z","ne","nz","be","na","a","nbe","s","ns","p","pe","np","po","l","nge","ge","nl","le","ng","g","nle", NULL};
-static const char *M_sizes = "bwdq";
+static const char M_sizes[] = "bwdq";
 /* Upper case letters are flags pointing to
  * more complex completion (like conditions)
  * C -> CMOVcc cc conditions
@@ -190,7 +193,8 @@ static const asmsh_compinstr_t x86_64_instr[] = {
 	{"outsb", 0, 0},
 	{"outsd", 0, 0},
 	{"outsw", 0, 0},
-	{"pop", 0xff, 0},
+	{"pop", ASHCOMP_REGALL, 0},
+	{"popS", ASHCOMP_IMM, 0},
 	{"popa", 0xff, 0},
 	{"popad", 0xff, 0},
 	{"popcnt", 0xff, 0xff},
@@ -201,6 +205,8 @@ static const asmsh_compinstr_t x86_64_instr[] = {
 	{"prefetch1", ASHCOMP_ADDR, 0},
 	{"prefetch2", ASHCOMP_ADDR, 0},
 	{"prefetchw", ASHCOMP_ADDR, 0},
+	{"push", ASHCOMP_REGALL, 0},
+	{"pushS", ASHCOMP_IMM, 0},
 	{"pusha", 0xff, 0},
 	{"pushad", 0xff, 0},
 	{"pushf", 0, 0},
@@ -244,32 +250,41 @@ static const asmsh_compinstr_t x86_64_instr[] = {
 };
 
 static const char * const asmsh_sym_regs64[] = {
-	"rax", "rbx", "rcx", "rdx", "rbp", "rsi", "rdi", "rsp",
-	"r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
+	"%rax", "%rbx", "%rcx", "%rdx", "%rbp", "%rsi", "%rdi", "%rsp",
+	"%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15",
+	NULL
 };
 static const char * const asmsh_sym_regs32[] = {
-	"eax", "ebx", "ecx", "edx", "esi", "edi", "ebp", "esp",
+	"%eax", "%ebx", "%ecx", "%edx", "%esi", "%edi", "%ebp", "%esp",
+	NULL
 };
 static const char * const asmsh_sym_regs16[] = {
-	"ax", "bx", "cx", "dx", "si", "di", "bp", "sp",
+	"%ax", "%bx", "%cx", "%dx", "%si", "%di", "%bp", "%sp",
+	NULL
 };
 static const char * const asmsh_sym_regs8[] = {
-	"ah", "al", "bh", "bl", "ch", "cl", "dh", "dl"
+	"%ah", "%al", "%bh", "%bl", "%ch", "%cl", "%dh", "%dl",
+	NULL
 };
 static const char * const asmsh_sym_regsseg[] = {
-	"cs", "ds", "es", "fs", "gs", "ss",
+	"%cs", "%ds", "%es", "%fs", "%gs", "%ss",
+	NULL
 };
 static const char * const asmsh_sym_imm[] = {
 	"$", "$0x", "$0o",
+	NULL
 };
 static const char * const asmsh_sym_xmm[] = {
-	"xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
+	"%xmm0", "%xmm1", "%xmm2", "%xmm3", "%xmm4", "%xmm5", "%xmm6", "%xmm7",
+	NULL
 };
 static const char * const asmsh_sym_xmm2[] = {
-	"xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
+	"%xmm8", "%xmm9", "%xmm10", "%xmm11", "%xmm12", "%xmm13", "%xmm14", "%xmm15",
+	NULL
 };
 static const char * const asmsh_sym_ymm[] = {
-	"ymm0", "ymm1", "ymm2", "ymm3", "ymm4", "ymm5", "ymm6", "ymm7",
+	"%ymm0", "%ymm1", "%ymm2", "%ymm3", "%ymm4", "%ymm5", "%ymm6", "%ymm7",
+	NULL
 };
 
 typedef struct {
@@ -287,6 +302,7 @@ static const asmsh_symtable_elt_t asmsh_symtable[] = {
 	{ ASHCOMP_XMM, asmsh_sym_xmm},
 	{ ASHCOMP_XMM2, asmsh_sym_xmm2},
 	{ ASHCOMP_YMM, asmsh_sym_ymm},
+	{ 0, NULL },
 };
 
 #endif