path: root/extlibs/arg.c

#include "arg.h"

#include "debug.h"

//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