#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[0])) //if there is 0 args then here could be non-0 and we get troubles
&& (strlen(tbl[i].cmd) != 0)) //combo if
if ( strncmp( tbl[i].cmd, arg->argv[0], strlen(arg->argv[0]) ) == 0 )
{
//never will exec becouse of statment in while
if ( tbl[i].clb == NULL )
{
printf("Empty callback %s\n", tbl[i].cmd);
ret = -1;
break;
}
sub_arg = cmd_arg_sub( arg );
//execute callback preconditions
if (tbl[i].pre != NULL)
{
pret = tbl[i].pre( sub_arg );
} else {
pret = 0; //no precond just pass
}
if (pret == 0)
{
//execute callback
fret = tbl[i].clb( sub_arg );
}
//if command whent wrong or not still clean mem
if ( sub_arg != NULL )
{
cmd_arg_destroy( sub_arg );
}
//command execution precondtions met but wrong execution
if ( pret == 0 )
{
//command execution whent wrong lets go out
if ( fret != 0 )
{
printf("Command broken execution\n");
ret = -1;
break;
}
}
ret = 0; //succesfull execution
break;
}
i++;
}
return ret;
}
int cmd_exec_ev( cmd_table_t *tbl, cmd_arg_t *arg, int event )
{
int ret = -1;
int fret = 0;
int i;
cmd_arg_t *sub_arg = NULL;
if ( arg->argc < 1 )
{
printf("Hm ... no arguments\n");
return -1;
}
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[0])) //if there is 0 args then here could be non-0 and we get troubles
&& (strlen(tbl[i].cmd) != 0)) //combo if
if ( strncmp( tbl[i].cmd, arg->argv[0], strlen(arg->argv[0]) ) == 0 )
{
//never will exec becouse of statment in while
if ( tbl[i].clb == NULL )
{
printf("Empty callback %s\n", tbl[i].cmd);
ret = -1;
break;
}