diff options
| -rw-r--r-- | .gitignore | 2 | ||||
| -rw-r--r-- | Makefile | 28 | ||||
| -rw-r--r-- | __cpp.h | 20 | ||||
| -rw-r--r-- | extlib/arg.c | 1132 | ||||
| -rw-r--r-- | extlib/arg.h | 451 | ||||
| -rw-r--r-- | extlib/debug.h | 69 | ||||
| -rw-r--r-- | notifylist.c | 18 |
7 files changed, 1720 insertions, 0 deletions
diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..7ba1cbe --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +*.o +notifylist diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..c7dc48b --- /dev/null +++ b/Makefile @@ -0,0 +1,28 @@ +PROJECT=notifylist +CC=gcc +CXX=g++ +CFLAGS= +LDFLAGS= +SOURCES=$(wildcard *.c) +OBJECTS=$(SOURCES:.c=.o) +INCLUDE=-I./extlib/ + +all: createextlib $(OBJECTS) $(PROJECT) + +$(PROJECT): $(SOURCES) notifylist.c + $(CXX) -c notifylist.c + $(CC) $(OBJECTS) $(CFLAGS) $(LDFLAGS) -o $(PROJECT) + +%.o: %.c + @echo $@ + @$(CXX) $(CFLAGS) $(INCLUDE) -c $< -o $(subst .c,.o,$<) + + +EXTLIB_SOURCES=$(wildcard extlib/*.c) +EXTLIB_OBJECTS=$(EXTLIB_SOURCES:.c=.o) +OBJECTS+=$(EXTLIB_OBJECTS) +createextlib: $(EXTLIB_OBJECTS) + #asd + +clean: + rm -f $(PROJECT) *.o extlib/*.o
\ No newline at end of file @@ -0,0 +1,20 @@ +extern "C" void* emulate_cc_new(unsigned long 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 long) __attribute__((alias("emulate_cc_new"))); +void* operator new[](unsigned long) __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;
\ No newline at end of file diff --git a/extlib/arg.c b/extlib/arg.c new file mode 100644 index 0000000..90c8fc8 --- /dev/null +++ b/extlib/arg.c @@ -0,0 +1,1132 @@ +#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) ); + memset( ret, 0, sizeof(arg_list) ); + + ptr_c = malloc(sizeof(char*)*num); + for (i=0;i<num;i++) + { + ptr_c[i] = vals[i]; + } + + ret->num = num; + ret->vals = ptr_c; + + return ret; +} + + +arg_file* arg_c_file( char *name ) +{ + arg_file *ret = NULL; + + ret = malloc( sizeof(arg_file) ); + memset( ret, 0, sizeof(arg_file) ); + + ret->name = name; + + return ret; +} + + +arg_val* arg_c_val( char *ptr ) +{ + arg_val *ret = NULL; + + ret = malloc( sizeof(arg_val) ); + memset( ret, 0, sizeof(arg_val) ); + + ret->ptr = ptr; + + return ret; +} + + +arg_flag* arg_c_flag() +{ + arg_flag *ret = NULL; + + ret = malloc( sizeof(arg_flag) ); + memset( ret, 0, sizeof(arg_flag) ); + + ret->flag = 0; + + return ret; +} +*/ + +/* +void arg_print( arg_t *arg ) +{ + int i = 0; + argv_t *v = NULL; + + if ( arg == NULL ) + { + printf("Nothing to print\n"); + return; + } + + printf("| NUM |\n"); + for ( i=0; i<arg->size;i++ ) + { + printf("| %02d |\n", i); + v = arg->arg[i]; + if (v == NULL) + continue; + printf(" ->| %02d | ", v->type); + switch( v->type ) + { + case ARGT_NONE: + { + printf("None\n"); + break; + } + case ARGT_IP: + { + printf("IP\n"); + break; + } + case ARGT_LIST: + { + int k; + arg_list *lst = (arg_list *)v->val; + printf("Lst | "); + for (k=0;k<lst->num;k++) + { + printf("%s ", lst->vals[k]); + } + printf("\n"); + break; + } + case ARGT_VAL: + { + arg_val *val = (void *)v->val; + printf("Val | "); + + printf("%s\n",val->ptr); + + break; + } + case ARGT_FLAG: + { + arg_flag *flag = (void *)v->val; + printf("FLg | "); + + printf("%d\n",flag->flag); + + break; + } + default: + printf("Unknown\n"); + } + + } + +} +*/ + +/* +int __search_arg( char *in, def_arg *arg) +{ + int ret = -1; + int i = 0; + + i = 0; + while ( arg[i].param != NULL ) + { + if (strncmp(arg[i].param,in,strlen(in)) == 0) + return i; + i++; + } + + + return ret; +} +*/ + +/* +void* __create_arg( int type, void *val ) +{ + void *ret = NULL; + + switch ( type ) + { + case ARGT_NONE: + { + break; + } + + case ARGT_IP: + { + arg_ip *ip = NULL; + s_arg_ip *s_ip= val; + + ip = arg_c_ip( s_ip->ip, s_ip->port ); + + ret = ip; + break; + } + + case ARGT_RANGE: + { + arg_range *range = NULL; + s_arg_range *s_range = val; + + range = arg_c_range( s_range->start, s_range->end, s_range->end ); + + ret = range; + break; + } + + case ARGT_FLOAT: + { + arg_float *fl = NULL; + s_arg_float *s_fl = val; + + fl = arg_c_float( s_fl->val ); + + ret = fl; + break; + } + + case ARGT_LIST: + { + arg_list *list = NULL; + s_arg_list *s_list = val; + + //so NULL where given as we use *->* then be carefull + if (s_list != NULL) + { + list = arg_c_list( s_list->num, s_list->vals ); + } + + ret = list; + break; + } + + case ARGT_FILE: + { + arg_file *f = NULL; + s_arg_file *s_f = val; + + f = arg_c_file( s_f->name ); + + ret = f; + break; + } + + case ARGT_VAL: + { + arg_val *v = NULL; + s_arg_val *s_v = val; + + v = arg_c_val( s_v->ptr ); + + ret = v; + break; + } + case ARGT_FLAG: + { + arg_flag *flag = NULL; + + flag = arg_c_flag(); + + ret = flag; + break; + } + + default: + printf("Unknown type\n"); + } + + return ret; +} +*/ + +/* +int __add_arg( arg_t *arg, int type, void *val ) +{ + argv_t *argv = NULL; + + void *new_ptr = NULL; + + new_ptr = realloc( arg->arg, sizeof(void*)*(arg->size+1) ); + if (new_ptr == NULL) + { + ENL(); + return -1; + } + arg->arg = new_ptr; + arg->size += 1; + + argv = malloc(sizeof(argv_t)); + if (argv == NULL) + { + //do resize back reallocated arg->arg + ENL(); + return -1; + } + memset(argv, 0, sizeof(argv_t)); + argv->type = type; + argv->val = val; + + arg->arg[arg->size-1] = argv; + + return 0; +} +*/ + + + + + +CmdArgVal::CmdArgVal() +{ + this->used = 0; + this->ptr = NULL; +} + +int CmdArgVal::isUsed() +{ + return this->used; +} + +void CmdArgVal::setUsed() +{ + this->used = 1; +} + +void CmdArgVal::setValue(char *val) +{ + this->ptr = val; +} + +char* CmdArgVal::getValue() +{ + return this->ptr; +} + +CmdArgValConf::CmdArgValConf() +{ + this->used = 0; + this->def = 0; + this->ptr = NULL; + this->default_ptr = NULL; + this->result = NULL; +} + +int CmdArgValConf::isUsed() +{ + return this->used; +} + +void CmdArgValConf::setUsed() +{ + this->used = 1; +} + +void CmdArgValConf::link(CmdArgVal *valArg) +{ + this->result = valArg; +} + +/* +CmdArg::CmdArg() +{ + this->used = 0; + this->_size = 0; + this->arg = NULL; +} + +int CmdArg::isUsed() +{ + return this->used; +} + +int CmdArg::size() +{ + return this->_size; +} +*/ + +CmdArgFloat::CmdArgFloat() +{ + this->used = 0; + this->val = 0.0f; +} + +int CmdArgFloat::isUsed() +{ + return this->used; +} + +float CmdArgFloat::get() +{ + return this->val; +} + +CmdArgFloatConf::CmdArgFloatConf() +{ + this->used = 0; + this->def = 0; + this->val = 0.0f; + this->default_val = 0.0f; + this->result = NULL; +} + +void CmdArgFloatConf::link(CmdArgFloat *floatArg) +{ + this->result = floatArg; +} + +int CmdArgFloatConf::isUsed() +{ + return this->used; +} + +CmdArgFlag::CmdArgFlag() +{ + this->used = 0; + this->flag = 0; +} + +int CmdArgFlag::isUsed() +{ + return this->used; +} + +int CmdArgFlag::get() +{ + return this->flag; +} + +void CmdArgFlag::setUsed() { + this->used = 1; +} + +int CmdArgFlag::getValue() { + return this->flag; +} + +void CmdArgFlag::setFlag() { + this->flag = 1; +} + +CmdArgFlagConf::CmdArgFlagConf() +{ + this->used = 0; + this->flag = 0; + this->result = NULL; +} + +CmdArgFlagConf::CmdArgFlagConf(int flag) +{ + this->used = 0; + this->flag = flag; + this->result = NULL; +} + +int CmdArgFlagConf::isUsed() +{ + return this->used; +} + +void CmdArgFlagConf::setUsed() { + this->used=1; +} + +void CmdArgFlagConf::link(CmdArgFlag *flagArg) +{ + this->result = flagArg; +} + + +CmdArgDefault::CmdArgDefault() +{ + this->param = NULL; + this->type = 0; + this->def = NULL; + this->used = 0; + this->help = NULL; + this->result = NULL; +} + +/* +CmdArgDefault::CmdArgDefault(char *param, uint32_t type, void *def, char *help, void *result) +{ + this->param = param; + this->type = type; + this->def = def; + this->used = 0; + this->help = help; + this->result = result; +} +*/ + +CmdArgDefault::CmdArgDefault(char *param, CmdArgFlagConf *def, char *help, CmdArgFlag *result) +{ + //printf("Construct CmdArgDefault::CmdArgDefault(char *param, CmdArgFlagConf *def, char *help, CmdArgFlag *result)\n"); + this->param = param; + this->type = ARGT_FLAG; + this->def = (void *)def; + this->used = 0; + this->help = help; + this->result = (void *)result; +} + +CmdArgDefault::CmdArgDefault(char *param, CmdArgValConf *def, char *help, CmdArgVal *result) +{ + this->param = param; + this->type = ARGT_VAL; + this->def = (void *)def; + this->used = 0; + this->help = help; + this->result = (void *)result; +} + + +void CmdArgDefault::setParam(char *param) +{ + this->param = param; +} + +char* CmdArgDefault::getParam() { + return this->param; +} + +void CmdArgDefault::setType(uint32_t type) +{ + this->type = type; +} + +uint32_t CmdArgDefault::getType() +{ + return this->type; +} + +void CmdArgDefault::setDefValue(void *def) +{ + this->def = def; +} + +int CmdArgDefault::isUsed() +{ + return this->used; +} + +void CmdArgDefault::setUsed() { + this->used = 1; +} + +void CmdArgDefault::setHelp(char *help) +{ + this->help = help; +} + + +void CmdArgDefault::link(void *result) +{ + this->result = result; +} + +void *CmdArgDefault::getResult() { + return this->result; +} + +void *CmdArgDefault::getDefault() { + return this->def; +} + + +CmdArg::CmdArg() +{ + this->num = 0; + this->defaultArgs = NULL; + this->usedArgs = NULL; + this->usedArgsNum = -1; +} + +void CmdArg::load(int argc, char **argv) +{ + int i; + int pos; + + this->usedArgs = (int *)calloc(argc,sizeof(int)); //DNCHK + this->usedArgsNum = argc; + + i = 1; + while (i < this->usedArgsNum) { + + pos = this->searchArg(argv[i]); + + if (pos==-1) { + printf("Couldnt find any arguments\n"); + break; + } + CmdArgDefault *param = (CmdArgDefault *)this->defaultArgs[pos]; + switch (param->getType()) { + case ARGT_IP: { + break; + } + + case ARGT_RANGE: { + break; + } + + case ARGT_FLOAT: { + break; + } + + case ARGT_LIST: { + break; + } + + case ARGT_FILE: { + break; + } + + case ARGT_VAL: { + CmdArgVal *val=(CmdArgVal *)param->getResult(); + CmdArgValConf *conf=(CmdArgValConf *)param->getDefault(); + + if (i+1<argc) + { + if ((this->usedArgs[i] == 0) + && (this->usedArgs[i+1] == 0)) + { + + param->setUsed(); + val->setUsed(); + val->setValue(argv[i+1]); + conf->setUsed(); + this->usedArgs[i] = 1; + this->usedArgs[i+1] = 1; + } + } + break; + } + + case ARGT_FLAG: { + + CmdArgFlag *flag=(CmdArgFlag *)param->getResult(); + CmdArgFlagConf *conf=(CmdArgFlagConf *)param->getDefault(); + + PRINT("ARGT_FLAG\n"); + + if (this->usedArgs[pos] == 0) + { + param->setUsed(); + flag->setUsed(); + flag->setFlag(); + conf->setUsed(); + this->usedArgs[i] = 1; + } + //warn? + + + break; + } + default: { + printf("Unknown type\n"); + } + } + + i++; + } +} + +void CmdArg::add(CmdArgDefault *param) +{ + if (param == NULL) { + return; + } + + this->num += 1; + void *new_ptr=NULL; + new_ptr = realloc(this->defaultArgs, sizeof(void *)*this->num); + if (new_ptr != NULL) + { + this->defaultArgs = (void **)new_ptr; + new_ptr = NULL; + } else { + this->num-=1; + printf("Couldnt allocate memory\n"); + return; + } + CmdArgDefault *p = (CmdArgDefault *)param; + printf("Added type %d\n", p->getType()); + + this->defaultArgs[this->num-1] = param; +} + +int CmdArg::searchArg(char *in) { + int i; + for (i=0;i<this->num;i++) { + CmdArgDefault *param = (CmdArgDefault *)this->defaultArgs[i]; + if (strncmp(param->getParam(), in, strlen(in)) == 0) { + return i; + } + } + return -1; +}
\ No newline at end of file diff --git a/extlib/arg.h b/extlib/arg.h new file mode 100644 index 0000000..fde5afc --- /dev/null +++ b/extlib/arg.h @@ -0,0 +1,451 @@ +#ifndef __ARG_H +#define __ARG_H + +#include <stdio.h> +#include <stdint.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#define ARGT_NONE 0 //nothing +#define ARGT_IP 1 //ip addr +#define ARGT_RANGE 2 //range of values +#define ARGT_FLOAT 3 //could be float +#define ARGT_LIST 4 //list of values +#define ARGT_FILE 5 //path to file +#define ARGT_VAL 6 //command line direct val +#define ARGT_FLAG 7 //flag value on/off + +#define ARG_ENTRY(P,T,V,H) {.param=P,.type=ARGT_##T,.def=V,.used=0,.help=H} + + + +/* +typedef struct argv_t +{ + int type; + uint8_t *val; // points to arg_{ip|range|..} +} argv_t; +*/ +/* +class CmdArgVar +{ + int _type; + uint8_t *val; // points to arg_{ip|range|..} +public: + CmdArgVar(); + uint8_t *get(); + int type(); +}; +*/ + +/* +typedef struct arg_t +{ + int used; + int size; //number of arguments + argv_t **arg; //list of pointers to arguments +} arg_t; +*/ +/* +class CmdArg +{ + int used; + int _size; //number of arguments + CmdArgVar **arg; //list of pointers to arguments +public: + CmdArg(); + int isUsed(); + int size(); +}; +*/ + +//ip argument default behaviour structure + +//resulting structure with ip/port values +/* +typedef struct arg_ip +{ + int used; + uint32_t ip; //IP4 ip addrers + uint16_t port;//port number +} arg_ip; +*/ + +class CmdArgIp { + int used; + uint32_t ip; //IP4 ip addrers + uint16_t port;//port number +}; +/* +Supported ip addresses: +...1 = 127.0.0.1:[default port] +:80 = [default ip]:80 +*/ +/* +typedef struct s_arg_ip +{ + int used; //value is in cmd + int def; //says if default should be used if no value in cmd + uint32_t ip; + uint32_t default_ip; + uint16_t port; + uint32_t default_port; + arg_ip *result; +} s_arg_ip; +*/ + +class CmdArgIpConf { + int used; //value is in cmd + int def; //says if default should be used if no value in cmd + uint32_t ip; + uint32_t default_ip; + uint16_t port; + uint32_t default_port; + CmdArgIp *result; +}; + + +//configure range argument behaviour +//configuration structure for range argument +/* +typedef struct arg_range +{ + int used; + uint32_t start; + uint32_t end; + uint32_t step; +} arg_range; +*/ +class CmdArgRange { + int used; + uint32_t start; + uint32_t end; + uint32_t step; +}; +/* +number format decimal ones +1k = 1000 +1m = 1000k = 1000000 +1g = 1000m = 1000000k = 1000000000 +10:100 - from 10 till 100 step [default step] +100: - from 100 till [default end] [default step] +:200 - from [default start] till +100:200:1 - from 100 till 200 with step 1 +*/ +/* +typedef struct s_arg_range +{ + int used; + int def; //says if default should be used if no value in cmd + uint32_t start; + uint32_t default_start; //default start value + uint32_t end; // + uint32_t default_end; //default end value + uint32_t step; // + uint32_t default_step; //default step value + arg_range *result; +} s_arg_range; +*/ +class CmdArgRangeConf { + int used; + int def; //says if default should be used if no value in cmd + uint32_t start; + uint32_t default_start; //default start value + uint32_t end; // + uint32_t default_end; //default end value + uint32_t step; // + uint32_t default_step; //default step value + CmdArgRange *result; +}; + + + +//configuration structure for float argument +/* +typedef struct arg_float +{ + int used; + float val; +} arg_float; +*/ + +class CmdArgFloat +{ + int used; + float val; + +public: + CmdArgFloat(); + int isUsed(); + float get(); +}; + +/* +typedef struct s_arg_float +{ + int used; + int def; //says if default should be used if no value in cmd + float val; + float default_val; + arg_float *result; +} s_arg_float; +*/ +class CmdArgFloatConf { + int used; + int def; //says if default should be used if no value in cmd + float val; + float default_val; + CmdArgFloat *result; + +public: + CmdArgFloatConf(); + void link(CmdArgFloat *floatArg); + int isUsed(); +}; + + +//configuration structure for list argument +/* +typedef struct arg_list +{ + int used; + uint32_t num; + char **vals; +} arg_list; +*/ + +class CmdArgList { + int used; + uint32_t num; + char **vals; +}; + +/* +list arguments by name + +supports +PARAM1|PARAM2|PARAM3 +*/ +/* +typedef struct s_arg_list +{ + int used; + int def; //says if default should be used if no value in cmd + uint32_t num; + char **vals; //list of supported arguments + char *default_val; //points to default arguments in da list + arg_list *result; +} s_arg_list; +*/ + +class CmdArgListConf { + int used; + int def; //says if default should be used if no value in cmd + uint32_t num; + char **vals; //list of supported arguments + char *default_val; //points to default arguments in da list + CmdArgList *result; +}; + + +/* +configuration structure to default file argument +*/ +/* +resulting structure for file argument +*/ +/* +typedef struct arg_file +{ + int used; + char *name; + char *abspath; +} arg_file; +*/ + +class CmdArgFile { + int used; + char *name; + char *abspath; +}; + +/* +typedef struct s_arg_file +{ + int used; + int def; //says if default should be used if no value in cmd + char *name; //current filename + char *default_name; //default filename + char *abspath; //dire where to search stuff? + char *default_abspath; //default absoulute file path + arg_file *result; +} s_arg_file; +*/ + +class CmdArgFileConf { + int used; + int def; //says if default should be used if no value in cmd + char *name; //current filename + char *default_name; //default filename + char *abspath; //dire where to search stuff? + char *default_abspath; //default absoulute file path + CmdArgFile *result; +}; + +/* +typedef struct arg_val +{ + int used; + char *ptr; +} arg_val; + +typedef struct s_arg_val +{ + int used; + int def; //says if default should be used if no value in cmd + char *ptr; + char *default_ptr; + arg_val *result; +} s_arg_val; +*/ + +class CmdArgVal { + int used; + char *ptr; +public: + CmdArgVal(); + int isUsed(); + //char* get(); //do not free + void setUsed(); + void setValue(char *val); + void setFlag(); + char *getValue(); +}; + +class CmdArgValConf { + int used; + int def; //says if default should be used if no value in cmd + char *ptr; + char *default_ptr; + CmdArgVal *result; +public: + CmdArgValConf(); + int isUsed(); + void setUsed(); + void link(CmdArgVal *valArg); +}; + +/* +//no need as there is no default values +typedef struct arg_flag +{ + int used; + int flag; +} arg_flag; + +typedef struct s_arg_flag +{ + int used; + int flag; //do we need it? + arg_flag *result; +} s_arg_flag; +*/ + +class CmdArgFlag { + int used; + int flag; +public: + CmdArgFlag(); + int isUsed(); + int get(); + void setUsed(); + void setFlag(); + int getValue(); +}; + +class CmdArgFlagConf { + int used; + int flag; //do we need it? + CmdArgFlag *result; +public: + CmdArgFlagConf(); + CmdArgFlagConf(int flag); + int isUsed(); + void setUsed(); + void link(CmdArgFlag *flagArg); +}; + +/* +used to define table with predefine arguments +*/ +/* +typedef struct def_arg +{ + char *param; //parametr that comes from shell + uint32_t type; //type of argument + void *def; //define default values, NULL if no default values + uint8_t used; + char *help; //command description + void *result; //result +} def_arg; +*/ + +class CmdArgDefault +{ + char *param; //parametr that comes from shell + uint32_t type; //type of argument + void *def; //define default values, NULL if no default values + int32_t used; + char *help; //command description + void *result; //result where to save resulting value +public: + CmdArgDefault(); + //CmdArgDefault(char *param, uint32_t type, void *def, char *help, void *result); + CmdArgDefault(char *param, CmdArgFlagConf *def, char *help, CmdArgFlag *result); + //CmdArgDefault(char *param, CmdArgFlagConf *def, char *help, CmdArgFlag *result); + CmdArgDefault(char *param, CmdArgValConf *def, char *help, CmdArgVal *result); + + void setParam(char *param); + char *getParam(); + void setType(uint32_t type); + uint32_t getType(); + void setDefValue(void *def); + int isUsed(); + void setUsed(); + void setHelp(char *help); + void link(void *result); + void *getResult(); + void *getDefault(); +}; + +class CmdArg { + int num; + void **defaultArgs; + int searchArg(char *in); + int *usedArgs; + int usedArgsNum; +public: + CmdArg(); + void load(int argc, char **argv); + void add(CmdArgDefault *param); + +}; + +/* +arg_t* arg_load( int argc, char **argv, def_arg *argl ); +void arg_free( arg_t *arg ); +int arg_type( arg_t *arg, int num ); +argv_t* arg_get( arg_t *arg, int num ); +arg_ip* arg_c_ip( uint32_t ip, uint16_t port ); +arg_range* arg_c_range( uint32_t start, uint32_t end, uint32_t step ); +arg_float* arg_c_float( float val ); +arg_list* arg_c_list( uint32_t num, char **vals); +arg_file* arg_c_file( char *name ); +arg_val* arg_c_val( char *ptr ); +arg_flag* arg_c_flag(); +void arg_print( arg_t *arg ); +*/ + + +#endif
\ No newline at end of file diff --git a/extlib/debug.h b/extlib/debug.h new file mode 100644 index 0000000..a8bf211 --- /dev/null +++ b/extlib/debug.h @@ -0,0 +1,69 @@ +#ifndef __RB_DEBUG_UTILS_H +#define __RB_DEBUG_UTILS_H + +//what about kprintf? + +//config options +#define PRINTF printf +#define COLORIZE +#define PRINT_LINENUM +#define PRINT_FILENAME +#define PRINT_DEBUG + + +//use color +#ifdef COLORIZE + #define D_COLOR "1;32m" + #define D_COLOR_S "\033[" D_COLOR + #define D_COLOR_E "\033[0m" + #define E_COLOR "1;31m" + #define E_COLOR_S "\033[" E_COLOR + #define E_COLOR_E "\033[0m" +#else + #define D_COLOR + #define D_COLOR_S + #define D_COLOR_E + #define E_COLOR + #define E_COLOR_S + #define E_COLOR_E +#endif + +//print debug line +#ifdef PRINT_LINENUM + #define PRINT_LINE_F "LINE:%d " + #define PRINT_LINE_D __LINE__ +#else + #define PRINT_LINE_F "" + #define PRINT_LINE_D "" +#endif + +//print +#ifdef PRINT_FILENAME + #define PRINT_FILE_F "FILE:%s " + #define PRINT_FILE_D __FILE__ +#else + #define PRINT_FILE_F "" + #define PRINT_FILE_D "" +#endif + +//print debug string +#ifdef PRINT_DEBUG + #define PRINT_DEBUG_F "Debug: " +#else + #define PRINT_DEBUG_F "" +#endif + +#define PRINT( format, args ... ) PRINTF( D_COLOR_S PRINT_DEBUG_F \ + PRINT_FILE_F PRINT_LINE_F format D_COLOR_E, PRINT_FILE_D, \ + PRINT_LINE_D, ##args); + +#define ERROR( format, args ... ) PRINTF( E_COLOR_S PRINT_DEBUG_F \ + PRINT_FILE_F PRINT_LINE_F format E_COLOR_E, PRINT_FILE_D, \ + PRINT_LINE_D, ##args); + +#define PNL() PRINT("\n"); + +#define ENL() ERROR("\n"); + + +#endif diff --git a/notifylist.c b/notifylist.c new file mode 100644 index 0000000..ab98cb2 --- /dev/null +++ b/notifylist.c @@ -0,0 +1,18 @@ +#include <stdio.h> +#include <stdlib.h> +#include <stdint.h> +#include <unistd.h> + +#include "__cpp.h" + +class INotify { +private: +public: +}; + + +int main() +{ + + return 0; +}
\ No newline at end of file |