#include "arg.h"
#include "debug.h"
//extern "C" void* emulate_cc_new(unsigned len) { \
// void *p = malloc(len);
// if (p == 0) {
// /* Don't use stdio (e.g. fputs), because that may want to allocate more
// * memory.
// */
// (void)!write(2, "out of memory\n", 14);
// abort();
// }
// return p;
//}
//extern "C" void emulate_cc_delete(void* p) {
// if (p != 0)
// free(p);
//}
//void* operator new (unsigned len) __attribute__((alias("emulate_cc_new")));
//void* operator new[](unsigned len) __attribute__((alias("emulate_cc_new")));
//void operator delete (void* p) __attribute__((alias("emulate_cc_delete")));
//void operator delete[](void* p) __attribute__((alias("emulate_cc_delete")));
//void* __cxa_pure_virtual = 0;
//for local usage only?
//int __search_arg( char *in, def_arg *arg );
/*from s_arg_[TYPE] create type arg_[TYPE]*/
//void* __create_arg( int type, void *val );
/*add to argument list new parsed/recognized argument*/
//int __add_arg( arg_t *arg, int type, void *val );
/*
/*
check if command line argument ARG[NUM<argc]
*/
//#define CHK_ARG(ARG,NUM) if ((ARG+NUM)>=argc) {\
//printf("not enought arguments for %s ",argv[ARG]);break;} //
//arg_t* arg_load( int argc, char **argv, def_arg *argl )
//{
// arg_t *ret = NULL;
// uint8_t *used; //count unused arguments, there should be no unused
// //elements at the end
// int i=0;
// int pos = -1; //position of argv inside def_arg table//
// //prepare return value
// ret = malloc( sizeof(arg_t) );
// memset( ret, 0, sizeof(arg_t) );//
// used = malloc(sizeof(uint8_t)*argc);
// memset( used, 0, sizeof(uint8_t)*argc );//
// /***************************************************************************
// Go troght all define arguments and try to parse and match all found arguments.
// Prepare list of all recognized arguments
// ***************************************************************************/
// i = 1; //we can ignore first as first arg is name of programm
// while ( i < argc )
// {
// //printf("%s ",argv[i]);
// pos = __search_arg(argv[i], argl);
// //printf("TAB:%d\n", pos );//
// switch (argl[pos].type)
// {
// case ARGT_NONE:
// {
// //printf("No arg\n");
// break;
// }
// case ARGT_IP:
// {
// //printf("%d is ip\n",i);
// /*
// arg_ip *ip = __create_arg( argl[i].type, argl[i].def );//
// //if ip is 0.0.0.0 then probably no default value for ip
// if ( ((s_arg_ip*)argl[i].def)->ip == 0 )
// ip->def = 0;
// //ip->ptr = argv[i+1];
// ip->used = 1;
// i+=1;
// */
// break;
// }
// case ARGT_RANGE:
// {
// printf("%d is range\n",i);
// /*
// CHK_ARG(i,1);//
// if (argl[pos].used == 1)
// {
// printf("Allready used %s\n",argv[i]);
// break;
// }//
// arg_range *range = __create_arg(argl[pos].type, argl[pos].def);//
//
//
// i += 1;//
// *///
// break;
// }
// case ARGT_FLOAT:
// {
// //printf("%d is float\n",i);
// break;
// }
// case ARGT_LIST:
// {
// int j=0;
// char **parse_params = NULL;
// int param_num = 0;
// s_arg_list *declared_params = argl[pos].def;
// char *iter=NULL, *st=NULL, *s=NULL;//
// //printf("%d is list\n",i);
// CHK_ARG(i,1);//
//
// if (argl[pos].used == 1)
// {
// printf("Allready used %s\n", argv[i]);
// break;
// }
//
// //super algo for parsing
// iter = argv[i+1];
// st = iter;
// while ((*iter)!='\0')
// {
// if ((*iter)=='|')
// {
// if ((iter)>st)
// {
// s = malloc(iter-st+1);
// memcpy(s, st, iter-st);
// s[iter-st]=0;//
// //TODO double flags will be passed in =P
// for (j=0;j<declared_params->num;j++)
// {
// int n1 = strlen(s);
// int n2 = strlen(declared_params->vals[j]);
// int n = n1 > n2 ? n1 : n2;
// if (strncmp(s,declared_params->vals[j],n)==0)
// {
// //PNL();
// param_num += 1;
// char **realoc_ptr = realloc(parse_params, sizeof(char *)*param_num);
// if (realoc_ptr)
// {
// parse_params = (char **)realoc_ptr;
// parse_params[param_num-1] = s;
// } else
// {
// param_num -= 1;
// }
// }
// }
// st = iter+1;
// } else
// {
// st = iter+1;
// }
// }
// iter++;
// if (*iter=='\0')
// {
// if ((iter)>st)
// {
// s = malloc(iter-st+1);
// memcpy(s, st, iter-st);
// s[iter-st]=0;
//
// //some hash table could be nice to use here =p
// //TODO double flags will be passed in =P
// for (j=0;j<declared_params->num;j++)
// {
// int n1 = strlen(s);
// int n2 = strlen(declared_params->vals[j]);
// int n = n1 > n2 ? n1 : n2;
// if (strncmp(s,declared_params->vals[j],n)==0)
// {
// param_num += 1;
// char **realoc_ptr = realloc(parse_params, sizeof(char *)*param_num);
// if (realoc_ptr)
// {
// parse_params = (char **)realoc_ptr;
// parse_params[param_num-1] = s;
// } else
// {
// param_num -= 1;
// }
// }
// }//
// st = iter+1;
// }
// }
// }//
// arg_list *list=NULL;
// {
// //PNL();
// //hack depends on __create_arg logic
// s_arg_list arg;
// arg.num = param_num;
// arg.vals = parse_params;
// list = __create_arg(argl[pos].type, &arg);
// }//
// //check param values//
// if (-1 == __add_arg(ret, ARGT_LIST, list))
// {
// ENL();
// }
// //
//
// argl[pos].used = 1;
// ((s_arg_list *)argl[pos].def)->result = list;//
// used[i] = 1;
// used[i+1] = 1;//
// i+=1;
// break;//
// }
// case ARGT_FILE:
// {
// //printf("%d is file\n",i);//
// break;
// }
// // we need one argument after flag
// case ARGT_VAL:
// {
// //printf("%d is !val\n",i);
// CHK_ARG(i,1);//
// if (argl[pos].used == 1)
// {
// printf("Allready used %s\n", argv[i]);
// break;
// }//
// arg_val *val = __create_arg( argl[pos].type, argl[pos].def );//
// //if (((s_arg_val*)argl[pos].def)->ptr != NULL)
// // val->def = 0;
// val->ptr = argv[i+1];//
// __add_arg( ret, ARGT_VAL, val );
// //set that requied option allready where at cmd
// argl[pos].used = 1;
// ((s_arg_val *)argl[pos].def)->result = val;//
// //set used cmd arg
// used[i ] = 1;
// used[i+1] = 1;//
// i += 1;//
// break;
// }
// // enought that this is triggered
// case ARGT_FLAG:
// {
// arg_flag *flg = NULL;//
// //printf("%d is flag\n", i);//
// if ( argl[pos].used == 1 )
// {
// printf("Allready used %s\n", argv[i]);
// break;
// }//
// flg = __create_arg( argl[pos].type, argl[pos].def );//
// flg->flag = 1;//
// __add_arg( ret, ARGT_FLAG, flg );//
//
//
// argl[pos].used = 1;
// ((s_arg_flag *)argl[pos].def)->result = flg;
//
// printf("result = ?\n");//
// used[i] = 1;//
// break;
// }
// default:
// printf("Unknown arg %d \"%s\"\n", i, argv[i]);//
// }//
// i++;
// }//
// /*if some arguments wherent used then add default value*/
// i = 0;
// while(argl[i].param != NULL)
// {
// if (argl[i].used == 0)
// {
// switch(argl[i].type)
// {
// case ARGT_IP:
// {
// //printf("Not yet\n");
// break;
// }
// case ARGT_RANGE:
// {
// //printf("Not yet\n");
// break;
// }
// case ARGT_FLOAT:
// {
// //printf("Not yet\n");
// break;
// }
// case ARGT_LIST:
// {
// //printf("Not yet\n");
// break;
// }
// case ARGT_FILE:
// {
// //printf("Not yet\n");
// break;
// }
// case ARGT_VAL:
// {
// printf("VAL default\n");
// arg_val *val= __create_arg( argl[i].type, argl[i].def );
// val->ptr = ((s_arg_val *)argl[i].def)->default_ptr;
// ((s_arg_val *)argl[i].def)->result = val;
// break;
// }
// case ARGT_FLAG:
// {
// printf("FLAG default\n");
// arg_flag *flag= __create_arg( argl[i].type, argl[i].def );
// //flag->flag = ((s_arg_flag *)argl[i].def)->flag;
// flag->flag = 0;
// ((s_arg_flag *)argl[i].def)->result = flag;
// break;
// }
// default:
// {
// printf("Unknown type\n");
// }
// }
// }//
// i++;
// }//
// free(used);//
//
// return ret;
//}
/*
void arg_free( arg_t *arg )
{
int i;
for (i=0;i<arg->size;i++)
{
free( arg->arg[i]->val );
free( arg->arg[i] );
}
free( arg->arg );
free( arg );
}
int arg_type( arg_t *arg, int num )
{
int ret = ARGT_NONE;
return ret;
}
argv_t* arg_get( arg_t *arg, int num )
{
argv_t *ret = NULL;
return ret;
}
arg_ip* arg_c_ip( uint32_t ip, uint16_t port )
{
arg_ip *ret = NULL;
ret = malloc( sizeof(arg_ip) );
memset(ret,0,sizeof(arg_ip));
ret->ip = ip;
ret->port = port;
return ret;
}
arg_range* arg_c_range( uint32_t start, uint32_t end, uint32_t step )
{
arg_range* ret = NULL;
ret = malloc( sizeof(arg_range) );
memset( ret, 0, sizeof(arg_range) );
ret->start = start;
ret->end = end;
ret->step = step;
return ret;
}
arg_float* arg_c_float( float val )
{
arg_float* ret = NULL;
ret = malloc( sizeof(arg_float) );
memset( ret, 0, sizeof(arg_float) );
ret->val = val;
return ret;
}
arg_list* arg_c_list( uint32_t num, char **vals)
{
int i;
arg_list *ret = NULL;
char **ptr_c=NULL;
ret = malloc( sizeof(arg_list) )