path: root/libcmd/cmd.c

#include "cmd.h"
#include "cmd_parse.h"

cmd_tok_t* cmd_tok_create(  char *s, char *e, int sz, int type )
{
	cmd_tok_t *ret = NULL;

	ret = malloc( sizeof(cmd_tok_t) );
	if ( ret == NULL )
		return ret;

	memset( ret, 0, sizeof(cmd_tok_t) );

	ret->s = s;
	ret->e = e;
	ret->sz = sz;
	ret->type = type;
	ret->next = NULL; //no need, but sec programming says we need it

	return ret;
}


int cmd_tok_add( cmd_tok_t *tok, cmd_tok_t *next )
{
	int ret = 0;

	if ( tok == NULL )
	{
		return -1;
	}
	
	if ( next == NULL )
	{
		return -1;
	}

	if ( tok->next != NULL )
	{
		printf("next token allready set\n");
		return -1;
	}

	tok->next = next;

	return ret;
}


int cmd_tok_print( cmd_tok_t *tok )
{
	int ret = 0;

	printf("TOK %p\n",tok);
	if (tok)
	{
		printf("S:%p E:%p SZ:%d \n", tok->s, tok->e, tok->sz);
		printf("TYPE: ");
		switch (tok->type)
		{
		case CMDT_NONE:
			printf("NONE");
			break;
		case CMDT_INT:
			printf("INT");
			break;
		case CMDT_HEX:
			printf("HEX");
			break;
		case CMDT_BIN:
			printf("BIN");
			break;
		case CMDT_STR:
			printf("STR");
			break;
		case CMDT_WORD:
			printf("WORD");
			break;
		case CMDT_SP:
			printf("SP");
			break;
		case CMDT_FLOAT:
			printf("FLOAT");
			break;
		default:
			printf("UNKNOWN");
		}
		printf("\n");
		printf("NEXT: %p\n", tok->next );
	}

	return ret;
}


void cmd_tok_destroy( cmd_tok_t *tok )
{
	cmd_tok_t *t=NULL, *n=NULL;

	if (tok == NULL)
	{
		return;
	}

	if ( tok->next == NULL )
	{
		free( tok );
		return;
	}

	t = tok;
	n = t;
	while ( n != NULL)
	{
		n = t->next;
		t->next = NULL;
		free(t);
		t = n;
	}
}


int cmd_tok_count( cmd_tok_t *tok )
{
	int ret = 0;
	cmd_tok_t *iter = NULL;

	if (tok == NULL)
		return 0;

	iter = tok;
	while( iter != NULL )
	{
		ret += 1;
		iter = iter->next;
	}

	return ret;
}



cmd_arg_t* cmd_arg_create(  cmd_tok_t *tok )
{
	cmd_arg_t *ret = NULL;
	int argc = -1;
	cmd_tok_t *iter = NULL;
	int i = 0;

	ret = malloc( sizeof(cmd_arg_t) );
	if ( ret == NULL )
	{
		return NULL;
	}
	memset( ret, 0, sizeof( cmd_arg_t ));

	//get number of arguments in command line
	argc = cmd_tok_count( tok );
	ret->argc = argc;


	//alloc mem for argument string values
	ret->argv = malloc( sizeof(int*)*argc );
	if ( ret->argv == NULL )
	{
		//printf("ERR:err_malloc_argv\n");
		goto err_malloc_argv;
	}
	memset( ret->argv, 0, sizeof(int*)*argc );

	//alloc mem for argument type values
	ret->type = malloc( sizeof(int)*argc );
	if ( ret->type == NULL )
	{
		//printf("ERR:err_malloc_type\n");
		goto err_malloc_type;
	}
	memset( ret->type, 0, sizeof(int)*argc );

	//create for each cmd token string and set type
	iter = tok;
	for (i=0; i<argc; i++,iter=iter->next)
	{
		ret->argv[i] = malloc( iter->sz+1 );
		memcpy(ret->argv[i], iter->s, iter->sz );
		ret->argv[i][iter->sz] = 0x0;
		ret->type[i] = iter->type;
	}

	return ret;

err_malloc_type:
	free( ret->argv );
err_malloc_argv:
	free( ret );
	return NULL;
}


cmd_arg_t* cmd_arg_sub( cmd_arg_t *arg )
{
	cmd_arg_t *ret = NULL;

	int i=0;

	if ( arg == NULL )
		return NULL;

	if ( arg->argc == 1 )
	{
		ret = cmd_arg_sub_empty();
		return ret;
	}

	ret = malloc( sizeof(cmd_arg_t) );
	
	ret->argc = arg->argc-1;

	ret->type = malloc(sizeof(int)*(arg->argc-1));
	memset(ret->type, 0, sizeof(int)*(arg->argc-1) );
	
	ret->argv = malloc( sizeof(char*)*(arg->argc-1) );
	memset(ret->argv, 0, sizeof(char*)*(arg->argc-1) );

	ret->__sub_cmd = 1;

	for (i=0; i<ret->argc; i++)
	{
		ret->argv[i] = arg->argv[i+1];
		ret->type[i] = arg->type[i+1];
	}

	return ret;
}


cmd_arg_t* cmd_arg_sub_empty()
{
	cmd_arg_t *ret = NULL;

	ret = malloc( sizeof(cmd_arg_t) );
	ret->argc = 0;
	ret->argv = NULL;
	ret->type = NULL;
	ret->__sub_cmd = 1;

	return ret;
}

void cmd_arg_destroy( cmd_arg_t *arg )
{
	int i;

	if ( arg == NULL )
		return;

	for ( i=0; i<arg->argc; i++)
	{
		if ( arg->__sub_cmd == 0 )
			free( arg->argv[i] );
	}

	free( arg->argv );

	free( arg->type );

	free( arg );
}

int  cmd_exec( cmd_table_t *tbl, cmd_arg_t *arg )
{
	int ret = -1;
	int fret = 0;
	int pret = 0; //pre condition return
	int i;

	cmd_arg_t *sub_arg = NULL;

	//there could be 0 arguments
	if ( arg->argc < 0 )
	{
		printf("Hm ... no arguments\n");
		return -1;
	}

	if ( arg->argc == 0 )
		return 0;

	i = 0;
	while ( (tbl[i].cmd != NULL) && (tbl[i].clb != NULL) )
	{
		//printf("tbl.cmd %s\n", tbl[i].cmd );
		if ((strlen(tbl[i].cmd) == strlen(arg->argv[