Astyling the common files

Signed-off-by: Raphael Defosseux <raphael.defosseux@eurecom.fr>

common/config/config_cmdline.c

@@ -39,40 +39,38 @@
 #include "config_userapi.h"
 
 
-int parse_stringlist(paramdef_t *cfgoptions, char *val)
-{
-char *atoken;
-char *tokctx;
-char *tmpval=strdup(val);
-int   numelt=0;
-
+int parse_stringlist(paramdef_t *cfgoptions, char *val) {
+  char *atoken;
+  char *tokctx;
+  char *tmpval=strdup(val);
+  int   numelt=0;
   cfgoptions->numelt=0;
-
   atoken=strtok_r(tmpval, ",",&tokctx);
+
   while(atoken != NULL) {
     numelt++ ;
     atoken=strtok_r(NULL, ",",&tokctx);
   }
+
   free(tmpval);
   config_check_valptr(cfgoptions,(char **)&(cfgoptions->strlistptr), sizeof(char *) * numelt);
   cfgoptions->numelt=numelt;
-
   atoken=strtok_r(val, ",",&tokctx);
+
   for( int i=0; i<cfgoptions->numelt && atoken != NULL ; i++) {
     config_check_valptr(cfgoptions,&(cfgoptions->strlistptr[i]),strlen(atoken)+1);
     sprintf(cfgoptions->strlistptr[i],"%s",atoken);
     printf_params("[LIBCONFIG] %s[%i]: %s\n", cfgoptions->optname,i,cfgoptions->strlistptr[i]);
     atoken=strtok_r(NULL, ",",&tokctx);
   }
+
   return (cfgoptions->numelt > 0);
 }
 
-int processoption(paramdef_t *cfgoptions, char *value)
-{
-char *tmpval = value;
-int optisset=0;
-char defbool[2]="1";
-
+int processoption(paramdef_t *cfgoptions, char *value) {
+  char *tmpval = value;
+  int optisset=0;
+  char defbool[2]="1";
 
   if ( value == NULL) {
     if( (cfgoptions->paramflags &PARAMFLAG_BOOL) == 0 ) { /* not a boolean, argument required */
@@ -82,8 +80,8 @@ char defbool[2]="1";
       tmpval = defbool;
     }
   }
-     switch(cfgoptions->type)
-       {
+
+  switch(cfgoptions->type) {
     case TYPE_STRING:
       if (cfgoptions->numelt == 0 ) {
         config_check_valptr(cfgoptions, cfgoptions->strptr, strlen(tmpval)+1);
@@ -91,6 +89,7 @@ char defbool[2]="1";
       } else {
         sprintf( (char *)(cfgoptions->strptr), "%s",tmpval);
       }
+
       printf_cmdl("[CONFIG] %s set to  %s from command line\n", cfgoptions->optname, tmpval);
       optisset=1;
       break;
@@ -98,6 +97,7 @@ char defbool[2]="1";
     case TYPE_STRINGLIST:
       optisset=parse_stringlist(cfgoptions,tmpval);
       break;
+
     case TYPE_UINT32:
     case TYPE_INT32:
     case TYPE_UINT16:
@@ -108,6 +108,7 @@ char defbool[2]="1";
       config_assign_int(cfgoptions,cfgoptions->optname,(int32_t)strtol(tmpval,NULL,0));
       optisset=1;
       break;
+
     case TYPE_UINT64:
     case TYPE_INT64:
       config_check_valptr(cfgoptions, (char **)&(cfgoptions->i64ptr),sizeof(uint64_t));
@@ -115,10 +116,11 @@ char defbool[2]="1";
       printf_cmdl("[CONFIG] %s set to  %lli from command line\n", cfgoptions->optname, (long long)*(cfgoptions->i64ptr));
       optisset=1;
       break;
+
     case TYPE_UINTARRAY:
     case TYPE_INTARRAY:
-
       break;
+
     case TYPE_DOUBLE:
       config_check_valptr(cfgoptions, (char **)&(cfgoptions->dblptr),sizeof(double));
       *(cfgoptions->dblptr) = strtof(tmpval,NULL);
@@ -127,24 +129,24 @@ char defbool[2]="1";
       break;
 
     case TYPE_IPV4ADDR:
-
       break;
 
     default:
       fprintf(stderr,"[CONFIG] command line, %s type %i  not supported\n",cfgoptions->optname, cfgoptions->type);
       break;
   } /* switch on param type */
+
   if (optisset == 1) {
     cfgoptions->paramflags = cfgoptions->paramflags |  PARAMFLAG_PARAMSET;
   }
+
   return optisset;
 }
 
-int config_check_cmdlineopt(char *prefix)
-{
-int unknowndetected=0;
-char testprefix[CONFIG_MAXOPTLENGTH]="";
-int finalcheck = 0; 
+int config_check_cmdlineopt(char *prefix) {
+  int unknowndetected=0;
+  char testprefix[CONFIG_MAXOPTLENGTH]="";
+  int finalcheck = 0;
 
   if (prefix != NULL) {
     if (strcmp(prefix,CONFIG_CHECKALLSECTIONS) == 0)
@@ -156,8 +158,11 @@ int finalcheck = 0;
 
   for (int i=1; i<config_get_if()->argc ; i++) {
     if ( !finalcheck && strstr(config_get_if()->argv[i],testprefix) == NULL ) continue;
+
     if ( !finalcheck && testprefix[0]==0 && index(config_get_if()->argv[i],'.') != NULL) continue;
+
     if ( !finalcheck && config_get_if()->argv[i][0] == '-' && isdigit(config_get_if()->argv[i][1])) continue;
+
     if ( (config_get_if()->argv_info[i] & CONFIG_CMDLINEOPT_PROCESSED) == 0 ) {
       fprintf(stderr,"[CONFIG] unknown option: %s\n",
               config_get_if()->argv[i] );
@@ -165,39 +170,42 @@ int finalcheck = 0;
     }
   }
 
- 
   printf_cmdl("[CONFIG] %i unknown option(s) in command line starting with %s (section %s)\n",
               unknowndetected,testprefix,((prefix==NULL)?"":prefix));
   return unknowndetected;
 }  /* parse_cmdline*/
 
-int config_process_cmdline(paramdef_t *cfgoptions,int numoptions, char *prefix)
-{
+int config_process_cmdline(paramdef_t *cfgoptions,int numoptions, char *prefix) {
   int c = config_get_if()->argc;
   int i,j;
   char *pp;
   char cfgpath[CONFIG_MAXOPTLENGTH];
- 
   j = 0;
   i = 0;
+
   while (c > 0 ) {
     char *oneargv = strdup(config_get_if()->argv[i]);          /* we use strtok_r which modifies its string paramater, and we don't want argv to be modified */
+
     /* first check help options, either --help, -h or --help_<section> */
     if (strncmp(oneargv, "-h",2) == 0 || strncmp(oneargv, "--help",6) == 0 ) {
       char *tokctx;
       pp=strtok_r(oneargv, "_",&tokctx);
       config_get_if()->argv_info[i] |= CONFIG_CMDLINEOPT_PROCESSED;
+
       if (pp == NULL || strcasecmp(pp,config_get_if()->argv[i] ) == 0 ) {
         if( prefix == NULL) {
           config_printhelp(cfgoptions,numoptions);
+
           if ( ! ( CONFIG_ISFLAGSET(CONFIG_NOEXITONHELP)))
             exit_fun("[CONFIG] Exiting after displaying help\n");
         }
       } else {
         pp=strtok_r(NULL, " ",&tokctx);
+
         if ( prefix != NULL && pp != NULL && strncasecmp(prefix,pp,strlen(pp)) == 0 ) {
           printf ("Help for %s section:\n",prefix);
           config_printhelp(cfgoptions,numoptions);
+
           if ( ! (CONFIG_ISFLAGSET(CONFIG_NOEXITONHELP))) {
             fprintf(stderr,"[CONFIG] %s %i section %s:", __FILE__, __LINE__, prefix);
             exit_fun(" Exiting after displaying help\n");
@@ -208,24 +216,29 @@ int config_process_cmdline(paramdef_t *cfgoptions,int numoptions, char *prefix)
 
     /* now, check for non help options */
     if (oneargv[0] == '-') {
-    	    for(int n=0;n<numoptions;n++) {
+      for(int n=0; n<numoptions; n++) {
         if ( ( cfgoptions[n].paramflags & PARAMFLAG_DISABLECMDLINE) != 0) {
           continue;
         }
+
         if (prefix != NULL) {
           sprintf(cfgpath,"%s.%s",prefix,cfgoptions[n].optname);
         } else {
           sprintf(cfgpath,"%s",cfgoptions[n].optname);
         }
+
         if ( ((strlen(oneargv) == 2) && (strcmp(oneargv + 1,cfgpath) == 0))  || /* short option, one "-" */
              ((strlen(oneargv) > 2) && (strcmp(oneargv + 2,cfgpath ) == 0 )) ) {
           char *valptr=NULL;
           int ret;
           config_get_if()->argv_info[i] |= CONFIG_CMDLINEOPT_PROCESSED;
+
           if (c > 0) {
             pp = config_get_if()->argv[i+1];
+
             if (pp != NULL ) {
               ret = strlen(pp);
+
               if (ret > 0 ) {
                 if (pp[0] != '-')
                   valptr=pp;
@@ -234,28 +247,36 @@ int config_process_cmdline(paramdef_t *cfgoptions,int numoptions, char *prefix)
               }
             }
           }
+
           j += processoption(&(cfgoptions[n]), valptr);
+
           if (  valptr != NULL ) {
             i++;
             config_get_if()->argv_info[i] |= CONFIG_CMDLINEOPT_PROCESSED;
             c--;
           }
+
           break;
         }
       } /* for n... */
     } /* if (oneargv[0] == '-') */
+
     free(oneargv);
     i++;
     c--;
   }   /* fin du while */
+
   printf_cmdl("[CONFIG] %s %i options set from command line\n",((prefix == NULL) ? "(root)":prefix),j);
+
   if ( !(CONFIG_ISFLAGSET( CONFIG_NOCHECKUNKOPT )) ) {
     i=config_check_cmdlineopt(prefix);
+
     if (i > 0) {
       fprintf(stderr,"[CONFIG] %i unknown options for section %s detected in command line\n",
               i,((prefix==NULL)?"\"root section\"":prefix));
       exit_fun(" Exiting after detecting errors in command line \n");
     }
   }
+
   return j;
 }  /* parse_cmdline*/

common/config/config_load_configmodule.c

@@ -42,17 +42,15 @@
 #include "config_userapi.h"
 #define CONFIG_SHAREDLIBFORMAT "libparams_%s.so"
 
-int load_config_sharedlib(configmodule_interface_t *cfgptr)
-{
-void *lib_handle;
-char fname[128];
-char libname[FILENAME_MAX]; 
-int st;
-
+int load_config_sharedlib(configmodule_interface_t *cfgptr) {
+  void *lib_handle;
+  char fname[128];
+  char libname[FILENAME_MAX];
+  int st;
   st=0;
   sprintf(libname,CONFIG_SHAREDLIBFORMAT,cfgptr->cfgmode);
-
   lib_handle = dlopen(libname,RTLD_NOW | RTLD_GLOBAL | RTLD_NODELETE);
+
   if (!lib_handle) {
     fprintf(stderr,"[CONFIG] %s %d Error calling dlopen(%s): %s\n",__FILE__, __LINE__, libname,dlerror());
     st = -1;
@@ -71,6 +69,7 @@ int st;
 
     sprintf (fname,"config_%s_get",cfgptr->cfgmode);
     cfgptr->get = dlsym(lib_handle,fname);
+
     if (cfgptr->get == NULL ) {
       printf("[CONFIG] %s %d no function %s for config mode %s\n",
              __FILE__, __LINE__,fname, cfgptr->cfgmode);
@@ -79,6 +78,7 @@ int st;
 
     sprintf (fname,"config_%s_getlist",cfgptr->cfgmode);
     cfgptr->getlist = dlsym(lib_handle,fname);
+
     if (cfgptr->getlist == NULL ) {
       printf("[CONFIG] %s %d no function %s for config mode %s\n",
              __FILE__, __LINE__,fname, cfgptr->cfgmode);
@@ -87,6 +87,7 @@ int st;
 
     sprintf (fname,"config_%s_end",cfgptr->cfgmode);
     cfgptr->end = dlsym(lib_handle,fname);
+
     if (cfgptr->getlist == NULL ) {
       printf("[CONFIG] %s %d no function %s for config mode %s\n",
              __FILE__, __LINE__,fname, cfgptr->cfgmode);
@@ -102,29 +103,29 @@ int nooptfunc(void) {
 };
 
 int config_cmdlineonly_getlist(paramlist_def_t *ParamList,
-                                   paramdef_t *params, int numparams, char *prefix)
-{
+                               paramdef_t *params, int numparams, char *prefix) {
   ParamList->numelt = 0;
   return 0;
 }
 
 
-int config_cmdlineonly_get(paramdef_t *cfgoptions,int numoptions, char *prefix )
-{
+int config_cmdlineonly_get(paramdef_t *cfgoptions,int numoptions, char *prefix ) {
   int defval;
   int fatalerror=0;
   int numdefvals=0;
 
-
-  for(int i=0;i<numoptions;i++) {
+  for(int i=0; i<numoptions; i++) {
     defval=0;
+
     switch(cfgoptions[i].type) {
       case TYPE_STRING:
         defval=config_setdefault_string(&(cfgoptions[i]), prefix);
         break;
+
       case TYPE_STRINGLIST:
         defval=config_setdefault_stringlist(&(cfgoptions[i]), prefix);
         break;
+
       case TYPE_UINT8:
       case TYPE_INT8:
       case TYPE_UINT16:
@@ -134,94 +135,106 @@ int config_cmdlineonly_get(paramdef_t *cfgoptions,int numoptions, char *prefix )
       case TYPE_MASK:
         defval=config_setdefault_int(&(cfgoptions[i]), prefix);
         break;
+
       case TYPE_UINT64:
       case TYPE_INT64:
         defval=config_setdefault_int64(&(cfgoptions[i]), prefix);
         break;
+
       case TYPE_UINTARRAY:
       case TYPE_INTARRAY:
         defval=config_setdefault_intlist(&(cfgoptions[i]), prefix);
         break;
+
       case TYPE_DOUBLE:
         defval=config_setdefault_double(&(cfgoptions[i]), prefix);
         break;
+
       case TYPE_IPV4ADDR:
         defval=config_setdefault_ipv4addr(&(cfgoptions[i]), prefix);
-              
         break;
+
       default:
         fprintf(stderr,"[CONFIG] %s.%s type %i  not supported\n",prefix, cfgoptions[i].optname,cfgoptions[i].type);
         fatalerror=1;
         break;
     } /* switch on param type */
+
     if (defval == 1) {
       numdefvals++;
       cfgoptions[i].paramflags = cfgoptions[i].paramflags |  PARAMFLAG_PARAMSETDEF;
     }
   } /* for loop on options */
+
   printf("[CONFIG] %s: %i/%i parameters successfully set \n",
          ((prefix == NULL)?"(root)":prefix),
          numdefvals,numoptions );
+
   if (fatalerror == 1) {
     fprintf(stderr,"[CONFIG] fatal errors found when assigning %s parameters \n",
             prefix);
   }
+
   return numdefvals;
 }
 
-configmodule_interface_t *load_configmodule(int argc, char **argv, uint32_t initflags)
-{
-char *cfgparam=NULL;
-char *modeparams=NULL;
-char *cfgmode=NULL;
-char *strtokctx=NULL;
-char *atoken;
-uint32_t tmpflags=0;
-int i;
-int OoptIdx=-1;
- 
-/* first parse the command line to look for the -O option */
-  for (i = 0;i<argc;i++) {
+configmodule_interface_t *load_configmodule(int argc, char **argv, uint32_t initflags) {
+  char *cfgparam=NULL;
+  char *modeparams=NULL;
+  char *cfgmode=NULL;
+  char *strtokctx=NULL;
+  char *atoken;
+  uint32_t tmpflags=0;
+  int i;
+  int OoptIdx=-1;
+
+  /* first parse the command line to look for the -O option */
+  for (i = 0; i<argc; i++) {
     if (strlen(argv[i]) < 2) continue;
+
     if ( argv[i][1] == 'O' && i < (argc -1)) {
       cfgparam = argv[i+1];
       OoptIdx=i;
     }
+
     if ( strstr(argv[i], "help_config") != NULL  ) {
       config_printhelp(Config_Params,CONFIG_PARAMLENGTH(Config_Params));
       exit(0);
     }
+
     if ( (strcmp(argv[i]+1, "h") == 0) || (strstr(argv[i]+1, "help_") != NULL ) ) {
       tmpflags = CONFIG_HELP;
     }
   }
 
-/* look for the OAI_CONFIGMODULE environement variable */
+  /* look for the OAI_CONFIGMODULE environement variable */
   if ( cfgparam == NULL ) {
     cfgparam = getenv("OAI_CONFIGMODULE");
   }
 
-/* default different for UE and softmodem because UE doesn't use config file*/
-/* and -O option is not mandatory for UE                                    */
-/* phy simulators behave as UE                                              */
-/* test of exec name would better be replaced by a parameter to the l       */
-/* oad_configmodule function */
+  /* default different for UE and softmodem because UE doesn't use config file*/
+  /* and -O option is not mandatory for UE                                    */
+  /* phy simulators behave as UE                                              */
+  /* test of exec name would better be replaced by a parameter to the l       */
+  /* oad_configmodule function */
   if (cfgparam == NULL) {
     tmpflags = tmpflags | CONFIG_NOOOPT;
+
     if ( initflags &  CONFIG_ENABLECMDLINEONLY) {
       cfgparam = CONFIG_CMDLINEONLY ":dbgl0" ;
     } else {
-      cfgparam = CONFIG_CMDLINEONLY ":dbgl0" ;cfgparam = CONFIG_LIBCONFIGFILE ":" DEFAULT_CFGFILENAME;         
+      cfgparam = CONFIG_CMDLINEONLY ":dbgl0" ;
+      cfgparam = CONFIG_LIBCONFIGFILE ":" DEFAULT_CFGFILENAME;
     }
   }
 
-/* parse the config parameters to set the config source */
+  /* parse the config parameters to set the config source */
   i = sscanf(cfgparam,"%m[^':']:%ms",&cfgmode,&modeparams);
+
   if (i< 0) {
     fprintf(stderr,"[CONFIG] %s, %d, sscanf error parsing config source  %s: %s\n", __FILE__, __LINE__,cfgparam, strerror(errno));
     exit(-1) ;
-   }
-   else if ( i == 1 ) {
+  } else if ( i == 1 ) {
     /* -O argument doesn't contain ":" separator, assume -O <conf file> option, default cfgmode to libconfig
        with one parameter, the path to the configuration file cfgmode must not be NULL */
     modeparams=cfgmode;
@@ -231,6 +244,7 @@ int OoptIdx=-1;
   cfgptr = calloc(sizeof(configmodule_interface_t),1);
   cfgptr->argv_info = calloc(sizeof(int32_t), argc);
   cfgptr->argv_info[0] |= CONFIG_CMDLINEOPT_PROCESSED;
+
   if (OoptIdx >= 0) {
     cfgptr->argv_info[OoptIdx] |= CONFIG_CMDLINEOPT_PROCESSED;
     cfgptr->argv_info[OoptIdx+1] |= CONFIG_CMDLINEOPT_PROCESSED;
@@ -242,30 +256,34 @@ int OoptIdx=-1;
   cfgptr->cfgmode=strdup(cfgmode);
   cfgptr->num_cfgP=0;
   atoken=strtok_r(modeparams,":",&strtokctx);
+
   while ( cfgptr->num_cfgP< CONFIG_MAX_OOPT_PARAMS && atoken != NULL) {
     /* look for debug level in the config parameters, it is commom to all config mode
        and will be removed frome the parameter array passed to the shared module */
     char *aptr;
     aptr=strcasestr(atoken,"dbgl");
+
     if (aptr != NULL) {
       cfgptr->rtflags = cfgptr->rtflags | strtol(aptr+4,NULL,0);
-
     } else {
       cfgptr->cfgP[cfgptr->num_cfgP] = strdup(atoken);
       cfgptr->num_cfgP++;
     }
+
     atoken = strtok_r(NULL,":",&strtokctx);
   }
 
-   
   printf("[CONFIG] get parameters from %s ",cfgmode);
-   for (i=0;i<cfgptr->num_cfgP; i++) {
+
+  for (i=0; i<cfgptr->num_cfgP; i++) {
     printf("%s ",cfgptr->cfgP[i]);
   }
+
   printf(", debug flags: 0x%08x\n",cfgptr->rtflags);
 
   if (strstr(cfgparam,CONFIG_CMDLINEONLY) == NULL) {
     i=load_config_sharedlib(cfgptr);
+
     if (i ==  0) {
       printf("[CONFIG] config module %s loaded\n",cfgmode);
       Config_Params[CONFIGPARAM_DEBUGFLAGS_IDX].uptr=&(cfgptr->rtflags);
@@ -281,22 +299,22 @@ int OoptIdx=-1;
     cfgptr->end = (configmodule_endfunc_t)nooptfunc;
   }
 
-  
-
   if (modeparams != NULL) free(modeparams);
+
   if (cfgmode != NULL) free(cfgmode);
+
   if (CONFIG_ISFLAGSET(CONFIG_ABORT)) {
     config_printhelp(Config_Params,CONFIG_PARAMLENGTH(Config_Params));
-//       exit(-1);   
+    //       exit(-1);
   }
+
   return cfgptr;
 }
 
 
 /* free memory allocated when reading parameters */
 /* config module could be initialized again after this call */
-void end_configmodule(void)
-{ 
+void end_configmodule(void) {
   if (cfgptr != NULL) {
     if (cfgptr->end != NULL) {
       printf ("[CONFIG] calling config module end function...\n");
@@ -304,29 +322,32 @@ void end_configmodule(void)
     }
 
     printf ("[CONFIG] free %u config value pointers\n",cfgptr->numptrs);
+
     for(int i=0; i<cfgptr->numptrs ; i++) {
       if (cfgptr->ptrs[i] != NULL) {
         free(cfgptr->ptrs[i]);
         cfgptr->ptrs[i]=NULL;
       }
     }
+
     cfgptr->numptrs=0;
   }
 }
 
 /* free all memory used by config module */
 /* should be called only at program exit */
-void free_configmodule(void)
-{ 
+void free_configmodule(void) {
   if (cfgptr != NULL) {
     end_configmodule();
+
     if( cfgptr->cfgmode != NULL) free(cfgptr->cfgmode);
+
     printf ("[CONFIG] free %u config parameter pointers\n",cfgptr->num_cfgP);
+
     for (int i=0; i<cfgptr->num_cfgP; i++) {
       if ( cfgptr->cfgP[i] != NULL) free(cfgptr->cfgP[i]);
     }
 
-
     free(cfgptr);
     cfgptr=NULL;
   }

common/config/config_load_configmodule.h

@@ -61,8 +61,7 @@ typedef int(*configmodule_initfunc_t)(char *cfgP[],int numP);
 typedef int(*configmodule_getfunc_t)(paramdef_t *,int numparams, char *prefix);
 typedef int(*configmodule_getlistfunc_t)(paramlist_def_t *, paramdef_t *,int numparams, char *prefix);
 typedef void(*configmodule_endfunc_t)(void);
-typedef struct configmodule_interface
-{
+typedef struct configmodule_interface {
   int      argc;
   char     **argv;
   uint32_t *argv_info;
@@ -91,11 +90,11 @@ static char config_helpstr [] = "\n lte-softmodem -O [config mode]<:dbgl[debugfl
 
 
 static paramdef_t Config_Params[] = {
-/*-----------------------------------------------------------------------------------------------------------------------*/
-/*                                            config parameters for config module                                        */
-/*   optname              helpstr           paramflags     XXXptr       defXXXval            type       numelt           */
-/*-----------------------------------------------------------------------------------------------------------------------*/
-{"debugflags",            config_helpstr,   0,             uptr:NULL,   defintval:0,        TYPE_MASK,  0}, 
+  /*-----------------------------------------------------------------------------------------------------------------------*/
+  /*                                            config parameters for config module                                        */
+  /*   optname              helpstr           paramflags     XXXptr       defXXXval            type       numelt           */
+  /*-----------------------------------------------------------------------------------------------------------------------*/
+  {"debugflags",            config_helpstr,   0,             uptr:NULL,   defintval:0,        TYPE_MASK,  0},
 };
 
 #else

common/config/config_paramdesc.h

@@ -99,8 +99,7 @@ typedef union checkedparam {
 
 /* paramdef is used to describe a parameter, array of paramdef_t strustures is used as the main parameter in */
 /* config apis used to retrieve parameters values  */
-typedef struct paramdef
-{
+typedef struct paramdef {
   char         optname[MAX_OPTNAME_SIZE]; /* parameter name, can be used as long command line option */
   char         *helpstr;                  /* help string */
   unsigned int paramflags;                /* value is a "ored" combination of above PARAMFLAG_XXXX values */

common/config/config_userapi.c

@@ -44,22 +44,23 @@
 #include "config_userapi.h"
 
 
-configmodule_interface_t *config_get_if(void)
-{
+configmodule_interface_t *config_get_if(void) {
   if (cfgptr == NULL) {
     fprintf(stderr,"[CONFIG] %s %d config module not initialized\n",__FILE__, __LINE__);
     exit(-1);
   }
+
   return cfgptr;
 }
 
-char * config_check_valptr(paramdef_t *cfgoptions, char **ptr, int length) 
-{
+char *config_check_valptr(paramdef_t *cfgoptions, char **ptr, int length) {
   if (ptr == NULL ) {
     ptr = malloc(sizeof(char *));
+
     if (ptr != NULL) {
       *ptr=NULL;
       cfgoptions->strptr=ptr;
+
       if ( (cfgoptions->paramflags & PARAMFLAG_NOFREE) == 0) {
         config_get_if()->ptrs[config_get_if()->numptrs] = (char *)ptr;
         config_get_if()->numptrs++;
@@ -70,7 +71,9 @@ char * config_check_valptr(paramdef_t *cfgoptions, char **ptr, int length)
       exit(-1);
     }
   }
+
   printf_ptrs("[CONFIG] %s ptr: 0x%08lx requested size: %i\n",cfgoptions->optname,(uintptr_t)(ptr),length);
+
   if(cfgoptions->numelt > 0 && PARAM_ISSCALAR(cfgoptions)  ) { /* already allocated */
     if (*ptr != NULL) {
       return *ptr;
@@ -83,8 +86,10 @@ char * config_check_valptr(paramdef_t *cfgoptions, char **ptr, int length)
 
   if (*ptr == NULL) {
     *ptr = malloc(length);
+
     if ( *ptr != NULL) {
       memset(*ptr,0,length);
+
       if ( (cfgoptions->paramflags & PARAMFLAG_NOFREE) == 0) {
         config_get_if()->ptrs[config_get_if()->numptrs] = *ptr;
         config_get_if()->numptrs++;
@@ -94,44 +99,53 @@ char * config_check_valptr(paramdef_t *cfgoptions, char **ptr, int length)
       exit(-1);
     }
   }
+
   return *ptr;
 }
 
-void config_assign_int(paramdef_t *cfgoptions, char *fullname, int val)
-{
-int tmpval=val;
+void config_assign_int(paramdef_t *cfgoptions, char *fullname, int val) {
+  int tmpval=val;
+
   if ( ((cfgoptions->paramflags &PARAMFLAG_BOOL) != 0) && tmpval >0) {
     tmpval =1;
   }
+
   switch (cfgoptions->type) {
     case TYPE_UINT8:
       *(cfgoptions->u8ptr) = (uint8_t)tmpval;
       printf_params("[CONFIG] %s: %u\n", fullname, (uint8_t)tmpval);
       break;
+
     case TYPE_INT8:
       *(cfgoptions->i8ptr) = (int8_t)tmpval;
       printf_params("[CONFIG] %s: %i\n", fullname, (int8_t)tmpval);
       break;
+
     case TYPE_UINT16:
       *(cfgoptions->u16ptr) = (uint16_t)tmpval;
       printf_params("[CONFIG] %s: %hu\n", fullname, (uint16_t)tmpval);
       break;
+
     case TYPE_INT16:
       *(cfgoptions->i16ptr) = (int16_t)tmpval;
       printf_params("[CONFIG] %s: %hi\n", fullname, (int16_t)tmpval);
       break;
+
     case TYPE_UINT32:
       *(cfgoptions->uptr) = (uint32_t)tmpval;
       printf_params("[CONFIG] %s: %u\n", fullname, (uint32_t)tmpval);
       break;
+
     case TYPE_MASK:
       *(cfgoptions->uptr) = *(cfgoptions->uptr) | (uint32_t)tmpval;
       printf_params("[CONFIG] %s: 0x%08x\n", fullname, (uint32_t)tmpval);
       break;
+
     case TYPE_INT32:
       *(cfgoptions->iptr) = (int32_t)tmpval;
       printf_params("[CONFIG] %s: %i\n", fullname, (int32_t)tmpval);
       break;
+
     default:
       fprintf (stderr,"[CONFIG] %s %i type %i non integer parameter %s not assigned\n",__FILE__, __LINE__,cfgoptions->type,fullname);
       break;
@@ -139,6 +153,7 @@ int tmpval=val;
 }
 void config_assign_processedint(paramdef_t *cfgoption, int val) {
   cfgoption->processedvalue = malloc(sizeof(int));
+
   if (  cfgoption->processedvalue != NULL) {
     *(cfgoption->processedvalue) = val;
   } else {
@@ -149,6 +164,7 @@ void config_assign_processedint(paramdef_t *cfgoption, int val) {
 
 int config_get_processedint(paramdef_t *cfgoption) {
   int ret;
+
   if (  cfgoption->processedvalue != NULL) {
     ret=*(cfgoption->processedvalue);
     free( cfgoption->processedvalue);
@@ -158,10 +174,10 @@ int config_get_processedint(paramdef_t *cfgoption) {
     fprintf (stderr,"[CONFIG] %s %d %s has no processed integer availablle\n",__FILE__, __LINE__, cfgoption->optname);
     ret=0;
   }
-return ret;            
+
+  return ret;
 }
-void config_printhelp(paramdef_t *params,int numparams)
-{
+void config_printhelp(paramdef_t *params,int numparams) {
   for (int i=0 ; i<numparams ; i++) {
     if ( params[i].helpstr != NULL) {
       printf("%s%s: %s",
@@ -172,79 +188,92 @@ void config_printhelp(paramdef_t *params,int numparams)
   }
 }
 
-int config_execcheck(paramdef_t *params,int numparams, char *prefix)
-{
-int st=0;
+int config_execcheck(paramdef_t *params,int numparams, char *prefix) {
+  int st=0;
 
   for (int i=0 ; i<numparams ; i++) {
     if ( params[i].chkPptr == NULL) {
       continue;
     }
+
     if (params[i].chkPptr->s4.f4 != NULL) {
       st += params[i].chkPptr->s4.f4(&(params[i]));
     }
   }
+
   if (st != 0) {
     fprintf(stderr,"[CONFIG] config_execcheck: section %s %i parameters with wrong value\n", prefix, -st);
+
     if ( CONFIG_ISFLAGSET(CONFIG_NOABORTONCHKF) == 0) {
       exit_fun("exit because configuration failed\n");
     }
   }
-return st;
+
+  return st;
 }
 
-int config_get(paramdef_t *params,int numparams, char *prefix)
-{
-int ret= -1;
+int config_get(paramdef_t *params,int numparams, char *prefix) {
+  int ret= -1;
 
   if (CONFIG_ISFLAGSET(CONFIG_ABORT)) {
     fprintf(stderr,"[CONFIG] config_get, section %s skipped, config module not properly initialized\n",prefix);
     return ret;
   }
+
   configmodule_interface_t *cfgif = config_get_if();
+
   if (cfgif != NULL) {
     ret = config_get_if()->get(params, numparams,prefix);
+
     if (ret >= 0) {
       config_process_cmdline(params,numparams,prefix);
       config_execcheck(params,numparams,prefix);
     }
+
     return ret;
   }
+
   return ret;
 }
 
-int config_getlist(paramlist_def_t *ParamList, paramdef_t *params, int numparams, char *prefix)
-{
+int config_getlist(paramlist_def_t *ParamList, paramdef_t *params, int numparams, char *prefix) {
   if (CONFIG_ISFLAGSET(CONFIG_ABORT)) {
     fprintf(stderr,"[CONFIG] config_get skipped, config module not properly initialized\n");
     return -1;
   }
+
   if (!config_get_if())
     return -1;
 
   const int ret = config_get_if()->getlist(ParamList, params, numparams, prefix);
+
   if (ret >= 0 && params) {
     char *newprefix;
+
     if (prefix) {
       int rc = asprintf(&newprefix, "%s.%s", prefix, ParamList->listname);
+
       if (rc < 0) newprefix = NULL;
     } else {
       newprefix = ParamList->listname;
     }
+
     char cfgpath[MAX_OPTNAME_SIZE*2 + 6]; /* prefix.listname.[listindex] */
+
     for (int i = 0; i < ParamList->numelt; ++i) {
       // TODO config_process_cmdline?
       sprintf(cfgpath, "%s.[%i]", newprefix, i);
       config_execcheck(ParamList->paramarray[i], numparams, cfgpath);
     }
+
     if (prefix)
       free(newprefix);
   }
+
   return ret;
 }
 
-int config_isparamset(paramdef_t *params,int paramidx)
-{
+int config_isparamset(paramdef_t *params,int paramidx) {
   if ((params[paramidx].paramflags & PARAMFLAG_PARAMSET) != 0) {
     return 1;
   } else {
@@ -255,30 +284,31 @@ int config_isparamset(paramdef_t *params,int paramidx)
 void print_intvalueerror(paramdef_t *param, char *fname, int *okval, int numokval) {
   fprintf(stderr,"[CONFIG] %s: %s: %i invalid value, authorized values:\n       ",
           fname,param->optname, (int)*(param->uptr));
+
   for ( int i=0; i<numokval ; i++) {
     fprintf(stderr, " %i",okval[i]);
   }
+
   fprintf(stderr, " \n");
 }
 
-int config_check_intval(paramdef_t *param)
-{
-    if ( param == NULL ){
+int config_check_intval(paramdef_t *param) {
+  if ( param == NULL ) {
     fprintf(stderr,"[CONFIG] config_check_intval: NULL param argument\n");
     return -1;
   }
+
   for ( int i=0; i<param->chkPptr->s1.num_okintval ; i++) {
     if( *(param->uptr) == param->chkPptr->s1.okintval[i] ) {
       return 0;
     }
   }
+
   print_intvalueerror(param,"config_check_intval", param->chkPptr->s1.okintval,param->chkPptr->s1.num_okintval);
   return -1;
 }
 
-int config_check_modify_integer(paramdef_t *param)
-{
-   
+int config_check_modify_integer(paramdef_t *param) {
   for (int i=0; i < param->chkPptr->s1a.num_okintval ; i++) {
     if (*(param->uptr) == param->chkPptr->s1a.okintval[i] ) {
       printf_params("[CONFIG] %s:  read value %i, set to %i\n",param->optname,*(param->uptr),param->chkPptr->s1a.setintval [i]);
@@ -286,15 +316,16 @@ int config_check_modify_integer(paramdef_t *param)
       return 0;
     }
   }
+
   print_intvalueerror(param,"config_check_modify_integer", param->chkPptr->s1a.okintval,param->chkPptr->s1a.num_okintval);
   return -1;
 }
 
-int config_check_intrange(paramdef_t *param)
-{
+int config_check_intrange(paramdef_t *param) {
   if( *(param->iptr) >= param->chkPptr->s2.okintrange[0]  && *(param->iptr) <= param->chkPptr->s2.okintrange[1]  ) {
     return 0;
   }
+
   fprintf(stderr,"[CONFIG] config_check_intrange: %s: %i invalid value, authorized range: %i %i\n",
           param->optname, (int)*(param->uptr), param->chkPptr->s2.okintrange[0], param->chkPptr->s2.okintrange[1]);
   return -1;
@@ -303,45 +334,45 @@ int config_check_intrange(paramdef_t *param)
 void print_strvalueerror(paramdef_t *param, char *fname, char **okval, int numokval) {
   fprintf(stderr,"[CONFIG] %s: %s: %s invalid value, authorized values:\n       ",
           fname,param->optname, *(param->strptr));
+
   for ( int i=0; i<numokval ; i++) {
     fprintf(stderr, " %s",okval[i]);
   }
+
   fprintf(stderr, " \n");
 }
 
-int config_check_strval(paramdef_t *param)
-{
-    if ( param == NULL ){
+int config_check_strval(paramdef_t *param) {
+  if ( param == NULL ) {
     fprintf(stderr,"[CONFIG] config_check_strval: NULL param argument\n");
     return -1;
   }
+
   for ( int i=0; i<param->chkPptr->s3.num_okstrval ; i++) {
     if( strcasecmp(*(param->strptr),param->chkPptr->s3.okstrval[i] ) == 0) {
       return 0;
     }
   }
+
   print_strvalueerror(param, "config_check_strval", param->chkPptr->s3.okstrval, param->chkPptr->s3.num_okstrval);
   return -1;
 }
 
-int config_checkstr_assign_integer(paramdef_t *param)
-{
-
-
+int config_checkstr_assign_integer(paramdef_t *param) {
   for (int i=0; i < param->chkPptr->s3a.num_okstrval ; i++) {
     if (strcasecmp(*(param->strptr),param->chkPptr->s3a.okstrval[i]  ) == 0) {
       config_assign_processedint(param, param->chkPptr->s3a.setintval[i]);
       return 0;
     }
   }
-   print_strvalueerror(param, "config_check_strval", param->chkPptr->s3a.okstrval, param->chkPptr->s3a.num_okstrval);
 
+  print_strvalueerror(param, "config_check_strval", param->chkPptr->s3a.okstrval, param->chkPptr->s3a.num_okstrval);
   return -1;
 }
 
-int config_setdefault_string(paramdef_t *cfgoptions, char *prefix)
-{
+int config_setdefault_string(paramdef_t *cfgoptions, char *prefix) {
   int status = 0;
+
   if( cfgoptions->defstrval != NULL) {
     status=1;
 
@@ -355,75 +386,83 @@ int config_setdefault_string(paramdef_t *cfgoptions, char *prefix)
       printf_params("[CONFIG] %s.%s set to default value \"%s\"\n", ((prefix == NULL) ? "" : prefix), cfgoptions->optname, (char *)*(cfgoptions->strptr));
     }
   }
+
   return status;
 }
 
-int config_setdefault_stringlist(paramdef_t *cfgoptions, char *prefix)
-{
+int config_setdefault_stringlist(paramdef_t *cfgoptions, char *prefix) {
   int status = 0;
+
   if( cfgoptions->defstrlistval != NULL) {
     cfgoptions->strlistptr=cfgoptions->defstrlistval;
     status=1;
+
     for(int j=0; j<cfgoptions->numelt; j++)
       printf_params("[CONFIG] %s.%s[%i] set to default value %s\n", ((prefix == NULL) ? "" : prefix), cfgoptions->optname,j, cfgoptions->strlistptr[j]);
   }
+
   return status;
 }
 
-int config_setdefault_int(paramdef_t *cfgoptions, char *prefix)
-{
+int config_setdefault_int(paramdef_t *cfgoptions, char *prefix) {
   int status = 0;
   config_check_valptr(cfgoptions, (char **)(&(cfgoptions->iptr)),sizeof(int32_t));
+
   if( ((cfgoptions->paramflags & PARAMFLAG_MANDATORY) == 0)) {
     config_assign_int(cfgoptions,cfgoptions->optname,cfgoptions->defintval);
     status=1;
     printf_params("[CONFIG] %s.%s set to default value\n", ((prefix == NULL) ? "" : prefix), cfgoptions->optname);
   }
+
   return status;
 }
 
-int config_setdefault_int64(paramdef_t *cfgoptions, char *prefix)
-{
+int config_setdefault_int64(paramdef_t *cfgoptions, char *prefix) {
   int status = 0;
   config_check_valptr(cfgoptions, (char **)&(cfgoptions->i64ptr),sizeof(long long));
+
   if( ((cfgoptions->paramflags & PARAMFLAG_MANDATORY) == 0)) {
     *(cfgoptions->u64ptr)=cfgoptions->defuintval;
     status=1;
     printf_params("[CONFIG] %s.%s set to default value %llu\n", ((prefix == NULL) ? "" : prefix), cfgoptions->optname, (long long unsigned)(*(cfgoptions->u64ptr)));
   }
+
   return status;
 }
 
-int config_setdefault_intlist(paramdef_t *cfgoptions, char *prefix)
-{
+int config_setdefault_intlist(paramdef_t *cfgoptions, char *prefix) {
   int status = 0;
+
   if( cfgoptions->defintarrayval != NULL) {
-    config_check_valptr(cfgoptions,(char **)&(cfgoptions->iptr), sizeof(int32_t*));
+    config_check_valptr(cfgoptions,(char **)&(cfgoptions->iptr), sizeof(int32_t *));
     cfgoptions->iptr=cfgoptions->defintarrayval;
     status=1;
+
     for (int j=0; j<cfgoptions->numelt ; j++) {
       printf_params("[CONFIG] %s[%i] set to default value %i\n",cfgoptions->optname ,j,(int)cfgoptions->iptr[j]);
     }
   }
+
   return status;
 }
 
-int config_setdefault_double(paramdef_t *cfgoptions, char *prefix)
-{
+int config_setdefault_double(paramdef_t *cfgoptions, char *prefix) {
   int status = 0;
   config_check_valptr(cfgoptions, (char **)&(cfgoptions->dblptr),sizeof(double));
+
   if( ((cfgoptions->paramflags & PARAMFLAG_MANDATORY) == 0)) {
     *(cfgoptions->u64ptr)=cfgoptions->defdblval;
     status=1;
     printf_params("[CONFIG] %s set to default value %lf\n",cfgoptions->optname , *(cfgoptions->dblptr));
   }
+
   return status;
 }
 
-int config_assign_ipv4addr(paramdef_t *cfgoptions, char *ipv4addr)
-{
+int config_assign_ipv4addr(paramdef_t *cfgoptions, char *ipv4addr) {
   config_check_valptr(cfgoptions,(char **)&(cfgoptions->uptr), sizeof(int));
   int rst=inet_pton(AF_INET, ipv4addr ,cfgoptions->uptr );
+
   if (rst == 1 && *(cfgoptions->uptr) > 0) {
     printf_params("[CONFIG] %s: %s\n",cfgoptions->optname, ipv4addr);
     return 1;
@@ -437,16 +476,17 @@ int config_assign_ipv4addr(paramdef_t *cfgoptions, char *ipv4addr)
       return -1;
     }
   }
+
   return 0;
 }
 
 
-int config_setdefault_ipv4addr(paramdef_t *cfgoptions,  char *prefix)
-{
+int config_setdefault_ipv4addr(paramdef_t *cfgoptions,  char *prefix) {
   int status = 0;
 
   if (cfgoptions->defstrval != NULL) {
     status = config_assign_ipv4addr(cfgoptions, cfgoptions->defstrval);
   }
+
   return status;
 }

common/config/config_userapi.h

@@ -48,7 +48,7 @@ extern "C"
 #define CONFIG_ISPARAMFLAGSET(P,F) ( !!(P.paramflags & F))
 /* utility functions, to be used by configuration module and/or configuration libraries */
 extern configmodule_interface_t *config_get_if(void);
-extern char * config_check_valptr(paramdef_t *cfgoptions, char **ptr, int length) ;
+extern char *config_check_valptr(paramdef_t *cfgoptions, char **ptr, int length) ;
 extern void config_printhelp(paramdef_t *,int numparams);
 extern int config_process_cmdline(paramdef_t *params,int numparams, char *prefix);
 extern void config_assign_processedint(paramdef_t *cfgoption, int val);

common/utils/LOG/log.c

@@ -72,16 +72,14 @@ char *log_level_highlight_start[] = {LOG_RED, LOG_ORANGE, "", LOG_BLUE, LOG_CYBL
 char *log_level_highlight_end[]   = {LOG_RESET,LOG_RESET,LOG_RESET, LOG_RESET,LOG_RESET};   /*!< \brief Optional end-format strings for highlighting */
 
 
-int write_file_matlab(const char *fname,const char *vname,void *data,int length,int dec,char format)
-{
-
+int write_file_matlab(const char *fname,const char *vname,void *data,int length,int dec,char format) {
   FILE *fp=NULL;
   int i;
 
   if (data == NULL)
     return -1;
-  //printf("Writing %d elements of type %d to %s\n",length,format,fname);
 
+  //printf("Writing %d elements of type %d to %s\n",length,format,fname);
 
   if (format == 10 || format ==11 || format == 12 || format == 13 || format == 14) {
     fp = fopen(fname,"a+");
@@ -89,8 +87,6 @@ int write_file_matlab(const char *fname,const char *vname,void *data,int length,
     fp = fopen(fname,"w+");
   }
 
-
-
   if (fp== NULL) {
     printf("[OPENAIR][FILE OUTPUT] Cannot open file %s\n",fname);
     return(-1);
@@ -99,10 +95,8 @@ int write_file_matlab(const char *fname,const char *vname,void *data,int length,
   if (format != 10 && format !=11  && format != 12 && format != 13 && format != 14)
     fprintf(fp,"%s = [",vname);
 
-
   switch (format) {
     case 0:   // real 16-bit
-
       for (i=0; i<length; i+=dec) {
         fprintf(fp,"%d\n",((short *)data)[i]);
       }
@@ -113,13 +107,10 @@ int write_file_matlab(const char *fname,const char *vname,void *data,int length,
     case 13:
     case 14:
     case 15:
-
       for (i=0; i<length<<1; i+=(2*dec)) {
         fprintf(fp,"%d + j*(%d)\n",((short *)data)[i],((short *)data)[i+1]);
-
       }
 
-
       break;
 
     case 2:  // real 32-bit
@@ -152,7 +143,7 @@ int write_file_matlab(const char *fname,const char *vname,void *data,int length,
 
     case 6:  // real 64-bit
       for (i=0; i<length; i+=dec) {
-      fprintf(fp,"%lld\n",((long long*)data)[i]);
+        fprintf(fp,"%lld\n",((long long *)data)[i]);
       }
 
       break;
@@ -178,27 +169,20 @@ int write_file_matlab(const char *fname,const char *vname,void *data,int length,
 
       break;
 
-
     case 10 : // case eren 16 bit complex :
-
       for (i=0; i<length<<1; i+=(2*dec)) {
-
         if((i < 2*(length-1)) && (i > 0))
           fprintf(fp,"%d + j*(%d),",((short *)data)[i],((short *)data)[i+1]);
         else if (i == 2*(length-1))
           fprintf(fp,"%d + j*(%d);",((short *)data)[i],((short *)data)[i+1]);
         else if (i == 0)
           fprintf(fp,"\n%d + j*(%d),",((short *)data)[i],((short *)data)[i+1]);
-
-
-
       }
 
       break;
 
     case 11 : //case eren 16 bit real for channel magnitudes:
       for (i=0; i<length; i+=dec) {
-
         if((i <(length-1))&& (i > 0))
           fprintf(fp,"%d,",((short *)data)[i]);
         else if (i == (length-1))
@@ -213,7 +197,6 @@ int write_file_matlab(const char *fname,const char *vname,void *data,int length,
     case 12 : // case eren for log2_maxh real unsigned 8 bit
       fprintf(fp,"%d \n",((unsigned char *)&data)[0]);
       break;
-
   }
 
   if (format != 10 && format !=11 && format !=12 && format != 13 && format != 15) {
@@ -232,8 +215,6 @@ int write_file_matlab(const char *fname,const char *vname,void *data,int length,
 void  log_getconfig(log_t *g_log) {
   char *gloglevel = NULL;
   int consolelog ;
-  
-  
   paramdef_t logparams_defaults[] = LOG_GLOBALPARAMS_DESC;
   paramdef_t logparams_level[MAX_LOG_PREDEF_COMPONENTS];
   paramdef_t logparams_logfile[MAX_LOG_PREDEF_COMPONENTS];
@@ -241,27 +222,29 @@ void  log_getconfig(log_t *g_log) {
   paramdef_t logparams_dump[sizeof(log_maskmap)/sizeof(mapping)];
   CONFIG_SETRTFLAG(CONFIG_NOCHECKUNKOPT);
   int ret = config_get( logparams_defaults,sizeof(logparams_defaults)/sizeof(paramdef_t),CONFIG_STRING_LOG_PREFIX);
+
   if (ret <0) {
     fprintf(stderr,"[LOG] init aborted, configuration couldn't be performed");
     return;
   }
 
-/* set LOG display options (enable/disable color, thread name, level ) */
+  /* set LOG display options (enable/disable color, thread name, level ) */
   for(int i=0; i<logparams_defaults[LOG_OPTIONS_IDX].numelt ; i++) {
     for(int j=0; log_options[j].name != NULL ; j++) {
       if (strcmp(logparams_defaults[LOG_OPTIONS_IDX].strlistptr[i],log_options[j].name) == 0) {
         g_log->flag = g_log->flag |  log_options[j].value;
         break;
-        } else if (log_options[j+1].name == NULL){
+      } else if (log_options[j+1].name == NULL) {
         fprintf(stderr,"Unknown log option: %s\n",logparams_defaults[LOG_OPTIONS_IDX].strlistptr[i]);
         exit(-1);
       }
     }
   }
 
-/* build the parameter array for setting per component log level and infile options */  
+  /* build the parameter array for setting per component log level and infile options */
   memset(logparams_level,    0, sizeof(paramdef_t)*MAX_LOG_PREDEF_COMPONENTS);
   memset(logparams_logfile,  0, sizeof(paramdef_t)*MAX_LOG_PREDEF_COMPONENTS);
+
   for (int i=MIN_LOG_COMPONENTS; i < MAX_LOG_PREDEF_COMPONENTS; i++) {
     if(g_log->log_component[i].name == NULL) {
       g_log->log_component[i].name = malloc(16);
@@ -269,37 +252,43 @@ void  log_getconfig(log_t *g_log) {
       logparams_logfile[i].paramflags = PARAMFLAG_DONOTREAD;
       logparams_level[i].paramflags = PARAMFLAG_DONOTREAD;
     }
+
     sprintf(logparams_level[i].optname,    LOG_CONFIG_LEVEL_FORMAT,       g_log->log_component[i].name);
     sprintf(logparams_logfile[i].optname,  LOG_CONFIG_LOGFILE_FORMAT,     g_log->log_component[i].name);
-/* workaround: all log options in existing configuration files use lower case component names
+
+    /* workaround: all log options in existing configuration files use lower case component names
        where component names include uppercase char in log.h....                                */
     for (int j=0 ; j<strlen(logparams_level[i].optname); j++)
       logparams_level[i].optname[j] = tolower(logparams_level[i].optname[j]);
+
     for (int j=0 ; j<strlen(logparams_level[i].optname); j++)
       logparams_logfile[i].optname[j] = tolower(logparams_logfile[i].optname[j]);
-/* */
+
+    /* */
     logparams_level[i].defstrval     = gloglevel;
     logparams_logfile[i].defuintval  = 0;
     logparams_logfile[i].numelt      = 0;
     logparams_level[i].numelt        = 0;
     logparams_level[i].type          = TYPE_STRING;
     logparams_logfile[i].type        = TYPE_UINT;
-
     logparams_logfile[i].paramflags  = logparams_logfile[i].paramflags|PARAMFLAG_BOOL;
   }
-/* read the per component parameters */
+
+  /* read the per component parameters */
   config_get( logparams_level,    MAX_LOG_PREDEF_COMPONENTS,CONFIG_STRING_LOG_PREFIX);
   config_get( logparams_logfile,  MAX_LOG_PREDEF_COMPONENTS,CONFIG_STRING_LOG_PREFIX);
-/* now set the log levels and infile option, according to what we read */
+
+  /* now set the log levels and infile option, according to what we read */
   for (int i=MIN_LOG_COMPONENTS; i < MAX_LOG_PREDEF_COMPONENTS; i++) {
     g_log->log_component[i].level = map_str_to_int(log_level_names,    *(logparams_level[i].strptr));
     set_log(i, g_log->log_component[i].level);
+
     if (*(logparams_logfile[i].uptr) == 1)
       set_component_filelog(i);
   }
 
-/* build then read the debug and dump parameter array */
-  for (int i=0;log_maskmap[i].name != NULL ; i++) {
+  /* build then read the debug and dump parameter array */
+  for (int i=0; log_maskmap[i].name != NULL ; i++) {
     sprintf(logparams_debug[i].optname,  LOG_CONFIG_DEBUG_FORMAT, log_maskmap[i].name);
     sprintf(logparams_dump[i].optname,   LOG_CONFIG_DUMP_FORMAT, log_maskmap[i].name);
     logparams_debug[i].defuintval  = 0;
@@ -315,27 +304,31 @@ void  log_getconfig(log_t *g_log) {
     logparams_dump[i].chkPptr     = NULL;
     logparams_dump[i].numelt      = 0;
   }
+
   config_get( logparams_debug,(sizeof(log_maskmap)/sizeof(mapping)) - 1 ,CONFIG_STRING_LOG_PREFIX);
   CONFIG_CLEARRTFLAG(CONFIG_NOCHECKUNKOPT);
   config_get( logparams_dump,(sizeof(log_maskmap)/sizeof(mapping)) - 1 ,CONFIG_STRING_LOG_PREFIX);
-/* set the debug mask according to the debug parameters values */
+
+  /* set the debug mask according to the debug parameters values */
   for (int i=0; log_maskmap[i].name != NULL ; i++) {
     if (*(logparams_debug[i].uptr) )
       g_log->debug_mask = g_log->debug_mask | log_maskmap[i].value;
+
     if (*(logparams_dump[i].uptr) )
       g_log->dump_mask = g_log->dump_mask | log_maskmap[i].value;
   }
-/* log globally enabled/disabled */
+
+  /* log globally enabled/disabled */
   set_glog_onlinelog(consolelog);
 }
 
-int register_log_component(char *name, char *fext, int compidx)
-{
-int computed_compidx=compidx;
+int register_log_component(char *name, char *fext, int compidx) {
+  int computed_compidx=compidx;
 
   if (strlen(fext) > 3) {
     fext[3]=0;  /* limit log file extension to 3 chars */
   }
+
   if (compidx < 0) { /* this is not a pre-defined component */
     for (int i = MAX_LOG_PREDEF_COMPONENTS; i< MAX_LOG_COMPONENTS; i++) {
       if (g_log->log_component[i].name == NULL) {
@@ -344,6 +337,7 @@ int computed_compidx=compidx;
       }
     }
   }
+
   if (computed_compidx >= 0 && computed_compidx <MAX_LOG_COMPONENTS) {
     g_log->log_component[computed_compidx].name = strdup(name);
     g_log->log_component[computed_compidx].stream = stdout;
@@ -353,19 +347,21 @@ int computed_compidx=compidx;
   } else {
     fprintf(stderr,"{LOG} %s %d Couldn't register componemt %s\n",__FILE__,__LINE__,name);
   }
-return computed_compidx;
+
+  return computed_compidx;
 }
 
-int isLogInitDone (void){
+int isLogInitDone (void) {
   if (g_log == NULL)
     return 0;
+
   if (!(g_log->flag & FLAG_INITIALIZED))
     return 0;
+
   return 1;
 }
 
-int logInit (void)
-{
+int logInit (void) {
   int i;
   g_log = calloc(1, sizeof(log_t));
 
@@ -373,10 +369,8 @@ int logInit (void)
     perror ("cannot allocated memory for log generation module \n");
     exit(EXIT_FAILURE);
   }
-  memset(g_log,0,sizeof(log_t));
-
-
 
+  memset(g_log,0,sizeof(log_t));
   register_log_component("PHY","log",PHY);
   register_log_component("MAC","log",MAC);
   register_log_component("OPT","log",OPT);
@@ -405,56 +399,39 @@ int logInit (void)
   register_log_component("TMR","",TMR);
   register_log_component("USIM","txt",USIM);
   register_log_component("SIM","txt",SIM);
-
   /* following log component are used for the localization*/
   register_log_component("LOCALIZE","log",LOCALIZE);
   register_log_component("NAS","log",NAS);
   register_log_component("UDP","",UDP_);
-
-
   register_log_component("GTPV1U","",GTPU);
-
-
   register_log_component("S1AP","",S1AP);
   register_log_component("X2AP","",X2AP);
-
-
   register_log_component("SCTP","",SCTP);
   register_log_component("X2AP","",X2AP);
   register_log_component("LOADER","log",LOADER);
   register_log_component("ASN","log",ASN);
 
-
-
   for (int i=0 ; log_level_names[i].name != NULL ; i++)
     g_log->level2string[i]           = toupper(log_level_names[i].name[0]); // uppercased first letter of level name
 
-
- 
-
-
   g_log->filelog_name = "/tmp/openair.log";
-
   log_getconfig(g_log);
 
-
-
   // set all unused component items to 0, they are for non predefined components
   for (i=MAX_LOG_PREDEF_COMPONENTS; i < MAX_LOG_COMPONENTS; i++) {
     memset(&(g_log->log_component[i]),0,sizeof(log_component_t));
   }
+
   g_log->flag =  g_log->flag | FLAG_INITIALIZED;
   printf("log init done\n");
-
   return 0;
 }
 
 
 char *log_getthreadname(char *threadname, int bufsize) {
+  int rt =   pthread_getname_np(pthread_self(), threadname,bufsize) ;
 
-int rt =   pthread_getname_np(pthread_self(), threadname,bufsize) ;  
-   if (rt == 0)
-   {
+  if (rt == 0) {
     return threadname;
   } else {
     return "thread?";
@@ -463,7 +440,7 @@ int rt =   pthread_getname_np(pthread_self(), threadname,bufsize) ;
 
 static int log_header(char *log_buffer, int buffsize, int comp, int level,const char *format) {
   char threadname[PR_SET_NAME];
-return  snprintf(log_buffer, buffsize , "%s%s[%s]%c %s %s%s",
+  return  snprintf(log_buffer, buffsize , "%s%s[%s]%c %s %s%s",
                    log_level_highlight_end[level],
                    ( (g_log->flag & FLAG_NOCOLOR)?"":log_level_highlight_start[level]),
                    g_log->log_component[comp].name,
@@ -473,37 +450,30 @@ return  snprintf(log_buffer, buffsize , "%s%s[%s]%c %s %s%s",
                    log_level_highlight_end[level]);
 }
 
-void logRecord_mt(const char *file, const char *func, int line, int comp, int level, const char* format, ... )
-  {
+void logRecord_mt(const char *file, const char *func, int line, int comp, int level, const char *format, ... ) {
   char log_buffer[MAX_LOG_TOTAL];
   va_list args;
-
   va_start(args, format);
-
-
-
-
   log_header(log_buffer,MAX_LOG_TOTAL ,comp, level,format);
   g_log->log_component[comp].vprint(g_log->log_component[comp].stream,log_buffer, args);
   va_end(args);
-
-
 }
 
-void log_dump(int component, void *buffer, int buffsize,int datatype, const char* format, ... ) {
-va_list args;
-char *wbuf; 
-
+void log_dump(int component, void *buffer, int buffsize,int datatype, const char *format, ... ) {
+  va_list args;
+  char *wbuf;
 
   switch(datatype) {
     case LOG_DUMP_DOUBLE:
       wbuf=malloc((buffsize * 10)  + 64 + MAX_LOG_TOTAL);
       break;
+
     case LOG_DUMP_CHAR:
     default:
       wbuf=malloc((buffsize * 3 ) + 64 + MAX_LOG_TOTAL);
       break;
   }
+
   if (wbuf != NULL) {
     va_start(args, format);
     int pos=log_header(wbuf,MAX_LOG_TOTAL ,component, OAILOG_INFO,"");
@@ -516,20 +486,21 @@ char *wbuf;
         case LOG_DUMP_DOUBLE:
           pos = pos + sprintf(wbuf+pos,"%04.4lf ", (double)((double *)buffer)[i]);
           break;
+
         case LOG_DUMP_CHAR:
         default:
           pos = pos + sprintf(wbuf+pos,"%02x ", (unsigned char)((unsigned char *)buffer)[i]);
           break;
       }
     }
+
     sprintf(wbuf+pos,"\n");
     g_log->log_component[component].print(g_log->log_component[component].stream,wbuf);
     free(wbuf);
   }
 }
 
-int set_log(int component, int level)
-{
+int set_log(int component, int level) {
   /* Checking parameters */
   DevCheck((component >= MIN_LOG_COMPONENTS) && (component < MAX_LOG_COMPONENTS),
            component, MIN_LOG_COMPONENTS, MAX_LOG_COMPONENTS);
@@ -538,23 +509,20 @@ int set_log(int component, int level)
 
   if ( g_log->log_component[component].level != OAILOG_DISABLE )
     g_log->log_component[component].savedlevel = g_log->log_component[component].level;
-  g_log->log_component[component].level = level;
 
+  g_log->log_component[component].level = level;
   return 0;
 }
 
 
 
-void set_glog(int level)
-{
+void set_glog(int level) {
   for (int c=0; c< MAX_LOG_COMPONENTS; c++ ) {
     set_log(c, level);
   }
-  
 }
 
-void set_glog_onlinelog(int enable)
-{
+void set_glog_onlinelog(int enable) {
   for (int c=0; c< MAX_LOG_COMPONENTS; c++ ) {
     if ( enable ) {
       g_log->log_component[c].level = g_log->log_component[c].savedlevel;
@@ -566,9 +534,8 @@ void set_glog_onlinelog(int enable)
     }
   }
 }
-void set_glog_filelog(int enable)
-{
-static FILE *fptr;
+void set_glog_filelog(int enable) {
+  static FILE *fptr;
 
   if ( enable ) {
     fptr = fopen(g_log->filelog_name,"w");
@@ -581,33 +548,35 @@ static FILE *fptr;
   } else {
     for (int c=0; c< MAX_LOG_COMPONENTS; c++ ) {
       g_log->log_component[c].filelog =  0;
+
       if (fptr != NULL) {
         fclose(fptr);
       }
+
       g_log->log_component[c].stream = stdout;
     }
   }
 }
 
-void set_component_filelog(int comp)
-{
+void set_component_filelog(int comp) {
   if (g_log->log_component[comp].stream == NULL || g_log->log_component[comp].stream == stdout) {
     g_log->log_component[comp].stream = fopen(g_log->log_component[comp].filelog_name,"w");
   }
+
   g_log->log_component[comp].vprint = vfprintf;
   g_log->log_component[comp].print = fprintf;
   g_log->log_component[comp].filelog =  1;
 }
-void close_component_filelog(int comp)
-{
+void close_component_filelog(int comp) {
   g_log->log_component[comp].filelog =  0;
+
   if (g_log->log_component[comp].stream != NULL && g_log->log_component[comp].stream != stdout ) {
     fclose(g_log->log_component[comp].stream);
     g_log->log_component[comp].stream = stdout;
   }
+
   g_log->log_component[comp].vprint = vfprintf;
   g_log->log_component[comp].print = fprintf;
- 
 }
 
 /*
@@ -615,8 +584,7 @@ void close_component_filelog(int comp)
  * with string value NULL
  */
 /* map a string to an int. Takes a mapping array and a string as arg */
-int map_str_to_int(mapping *map, const char *str)
-{
+int map_str_to_int(mapping *map, const char *str) {
   while (1) {
     if (map->name == NULL) {
       return(-1);
@@ -631,8 +599,7 @@ int map_str_to_int(mapping *map, const char *str)
 }
 
 /* map an int to a string. Takes a mapping array and a value */
-char *map_int_to_str(mapping *map, int val)
-{
+char *map_int_to_str(mapping *map, int val) {
   while (1) {
     if (map->name == NULL) {
       return NULL;
@@ -646,8 +613,7 @@ char *map_int_to_str(mapping *map, int val)
   }
 }
 
-int is_newline( char *str, int size)
-{
+int is_newline( char *str, int size) {
   int i;
 
   for (  i = 0; i < size; i++ ) {
@@ -660,12 +626,12 @@ int is_newline( char *str, int size)
   return 0;
 }
 
-void logClean (void)
-{
+void logClean (void) {
   int i;
 
   if(isLogInitDone()) {
     LOG_UI(PHY,"\n");
+
     for (i=MIN_LOG_COMPONENTS; i < MAX_LOG_COMPONENTS; i++) {
       close_component_filelog(i);
     }
@@ -675,69 +641,50 @@ void logClean (void)
 
 #ifdef LOG_TEST
 
-int main(int argc, char *argv[])
-{
-
+int main(int argc, char *argv[]) {
   logInit();
-
-
   test_log();
-
   return 1;
 }
 
-int test_log(void)
-{
+int test_log(void) {
   LOG_ENTER(MAC); // because the default level is DEBUG
   LOG_I(EMU, "1 Starting OAI logs version %s Build date: %s on %s\n",
         BUILD_VERSION, BUILD_DATE, BUILD_HOST);
   LOG_D(MAC, "1 debug  MAC \n");
   LOG_W(MAC, "1 warning MAC \n");
-
   set_log(EMU, OAILOG_INFO);
   set_log(MAC, OAILOG_WARNING);
-
   LOG_I(EMU, "2 Starting OAI logs version %s Build date: %s on %s\n",
         BUILD_VERSION, BUILD_DATE, BUILD_HOST);
   LOG_E(MAC, "2 error MAC\n");
   LOG_D(MAC, "2 debug  MAC \n");
   LOG_W(MAC, "2 warning MAC \n");
   LOG_I(MAC, "2 info MAC \n");
-
-
   set_log(MAC, OAILOG_NOTICE);
-
   LOG_ENTER(MAC);
   LOG_I(EMU, "3 Starting OAI logs version %s Build date: %s on %s\n",
         BUILD_VERSION, BUILD_DATE, BUILD_HOST);
   LOG_D(MAC, "3 debug  MAC \n");
   LOG_W(MAC, "3 warning MAC \n");
   LOG_I(MAC, "3 info MAC \n");
-
   set_log(MAC, LOG_DEBUG);
   set_log(EMU, LOG_DEBUG);
-
   LOG_ENTER(MAC);
   LOG_I(EMU, "4 Starting OAI logs version %s Build date: %s on %s\n",
         BUILD_VERSION, BUILD_DATE, BUILD_HOST);
   LOG_D(MAC, "4 debug  MAC \n");
   LOG_W(MAC, "4 warning MAC \n");
   LOG_I(MAC, "4 info MAC \n");
-
-
   set_log(MAC, LOG_DEBUG);
   set_log(EMU, LOG_DEBUG);
-
   LOG_I(LOG, "5 Starting OAI logs version %s Build date: %s on %s\n",
         BUILD_VERSION, BUILD_DATE, BUILD_HOST);
   LOG_D(MAC, "5 debug  MAC \n");
   LOG_W(MAC, "5 warning MAC \n");
   LOG_I(MAC, "5 info MAC \n");
-
-
   set_log(MAC, LOG_TRACE);
   set_log(EMU, LOG_TRACE);
-
   LOG_ENTER(MAC);
   LOG_I(LOG, "6 Starting OAI logs version %s Build date: %s on %s\n",
         BUILD_VERSION, BUILD_DATE, BUILD_HOST);
@@ -745,7 +692,6 @@ int test_log(void)
   LOG_W(MAC, "6 warning MAC \n");
   LOG_I(MAC, "6 info MAC \n");
   LOG_EXIT(MAC);
-
   return 0;
 }
 #endif

common/utils/LOG/log.h

@@ -45,11 +45,11 @@
 #include <time.h>
 #include <stdint.h>
 #ifndef __STDC_FORMAT_MACROS
-#define __STDC_FORMAT_MACROS
+  #define __STDC_FORMAT_MACROS
 #endif
 #include <inttypes.h>
 #ifndef _GNU_SOURCE
-#define _GNU_SOURCE
+  #define _GNU_SOURCE
 #endif
 #include <pthread.h>
 #include "T.h"
@@ -164,7 +164,7 @@ extern "C" {
     {"NAS",         DEBUG_NAS},\
     {"UE_TIMING",   UE_TIMING},\
     {NULL,-1}\
-}
+  }
 
 
 
@@ -250,7 +250,7 @@ typedef struct {
   log_component_t         log_component[MAX_LOG_COMPONENTS];
   char                    level2string[NUM_LOG_LEVEL];
   int                     flag;
-    char*                   filelog_name;
+  char                   *filelog_name;
   uint64_t                debug_mask;
   uint64_t                dump_mask;
 } log_t;
@@ -271,9 +271,9 @@ void log_set_instance_type (log_instance_type_t instance);
 log_t *g_log;
 #else
 #ifdef __cplusplus
-   extern "C" {
+extern "C" {
 #endif
-extern log_t *g_log;
+  extern log_t *g_log;
 #ifdef __cplusplus
 }
 #endif
@@ -284,7 +284,7 @@ extern log_t *g_log;
 int  logInit (void);
 int isLogInitDone (void);
 void logRecord_mt(const char *file, const char *func, int line,int comp, int level, const char *format, ...) __attribute__ ((format (printf, 6, 7)));
-void log_dump(int component, void *buffer, int buffsize,int datatype, const char* format, ... );
+void log_dump(int component, void *buffer, int buffsize,int datatype, const char *format, ... );
 int  set_log(int component, int level);
 void set_glog(int level);
 
@@ -339,10 +339,10 @@ int32_t write_file_matlab(const char *fname, const char *vname, void *data, int
 /*   optname                            help                                                paramflags       XXXptr                    defXXXval              type   numelt */
 /*------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
 #define LOG_GLOBALPARAMS_DESC { \
-{LOG_CONFIG_STRING_GLOBAL_LOG_LEVEL,    "Default log level for all componemts\n",              0,  	      strptr:(char **)&gloglevel,    defstrval:log_level_names[2].name,    TYPE_STRING,    0}, \
-{LOG_CONFIG_STRING_GLOBAL_LOG_ONLINE,   "Default console output option, for all components\n", 0,  	      iptr:&(consolelog),            defintval:1,                          TYPE_INT,       0}, \
-{LOG_CONFIG_STRING_GLOBAL_LOG_OPTIONS,  LOG_CONFIG_HELP_OPTIONS,                               0,  	      strlistptr:NULL,               defstrlistval:NULL,                   TYPE_STRINGLIST,0} \
-}
+    {LOG_CONFIG_STRING_GLOBAL_LOG_LEVEL,    "Default log level for all componemts\n",              0,         strptr:(char **)&gloglevel,    defstrval:log_level_names[2].name,    TYPE_STRING,    0}, \
+    {LOG_CONFIG_STRING_GLOBAL_LOG_ONLINE,   "Default console output option, for all components\n", 0,         iptr:&(consolelog),            defintval:1,                          TYPE_INT,       0}, \
+    {LOG_CONFIG_STRING_GLOBAL_LOG_OPTIONS,  LOG_CONFIG_HELP_OPTIONS,                               0,         strlistptr:NULL,               defstrlistval:NULL,                   TYPE_STRINGLIST,0} \
+  }
 
 #define LOG_OPTIONS_IDX   2
 /*----------------------------------------------------------------------------------*/
@@ -355,22 +355,22 @@ int32_t write_file_matlab(const char *fname, const char *vname, void *data, int
 // debugging macros
 #define LOG_F  LOG_I           /* because  LOG_F was originaly to dump a message or buffer but is also used as a regular level...., to dump use LOG_DUMPMSG */
 #  if T_TRACER
-     /* per component, level dependant macros */
+/* per component, level dependant macros */
 #    define LOG_E(c, x...) do { if (T_stdout) { if( g_log->log_component[c].level >= OAILOG_ERR    ) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_ERR, x)     ;} else { T(T_LEGACY_ ## c ## _ERROR, T_PRINTF(x))   ;}} while (0)
 #    define LOG_W(c, x...) do { if (T_stdout) { if( g_log->log_component[c].level >= OAILOG_WARNING) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_WARNING, x) ;} else { T(T_LEGACY_ ## c ## _WARNING, T_PRINTF(x)) ;}} while (0)
 #    define LOG_I(c, x...) do { if (T_stdout) { if( g_log->log_component[c].level >= OAILOG_INFO   ) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_INFO, x)    ;} else { T(T_LEGACY_ ## c ## _INFO, T_PRINTF(x))    ;}} while (0)
 #    define LOG_D(c, x...) do { if (T_stdout) { if( g_log->log_component[c].level >= OAILOG_DEBUG  ) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_DEBUG, x)   ;} else { T(T_LEGACY_ ## c ## _DEBUG, T_PRINTF(x))   ;}} while (0)
 #    define LOG_T(c, x...) do { if (T_stdout) { if( g_log->log_component[c].level >= OAILOG_TRACE  ) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_TRACE, x)   ;} else { T(T_LEGACY_ ## c ## _TRACE, T_PRINTF(x))   ;}} while (0)
-    /* macro used to dump a buffer or a message as in openair2/RRC/LTE/RRC_eNB.c, replaces LOG_F macro */
+/* macro used to dump a buffer or a message as in openair2/RRC/LTE/RRC_eNB.c, replaces LOG_F macro */
 #    define LOG_DUMPMSG(c, f, b, s, x...) do {  if(g_log->dump_mask & f) log_dump(c, b, s, LOG_DUMP_CHAR, x)  ;}   while (0)  /* */
 #    define nfapi_log(FILE, FNC, LN, COMP, LVL, F...)  do { if (T_stdout) { logRecord_mt(__FILE__, __FUNCTION__, __LINE__,COMP, LVL, F)  ;}}   while (0)  /* */
-     /* bitmask dependant macros, to isolate debugging code */
+/* bitmask dependant macros, to isolate debugging code */
 #    define LOG_DEBUGFLAG(D) (g_log->debug_mask & D)
 
-     /* bitmask dependant macros, to generate debug file such as matlab file or message dump */
+/* bitmask dependant macros, to generate debug file such as matlab file or message dump */
 #    define LOG_DUMPFLAG(D) (g_log->dump_mask & D)
 #    define LOG_M(file, vector, data, len, dec, format) do { write_file_matlab(file, vector, data, len, dec, format);} while(0)/* */
-     /* define variable only used in LOG macro's */
+/* define variable only used in LOG macro's */
 #    define LOG_VAR(A,B) A B
 #  else /* T_TRACER: remove all debugging and tracing messages, except errors */
 #    define LOG_I(c, x...) /* */
@@ -420,7 +420,7 @@ static __inline__ uint64_t rdtsc(void) {
 
 extern double cpuf;
 
-static inline uint64_t checkTCPU(int timeout, char * file, int line) {
+static inline uint64_t checkTCPU(int timeout, char *file, int line) {
   static uint64_t __thread lastCPUTime=0;
   static uint64_t __thread last=0;
   uint64_t cur=rdtsc();
@@ -429,25 +429,29 @@ static inline uint64_t checkTCPU(int timeout, char * file, int line) {
   uint64_t CPUTime=CPUt.tv_sec*1000*1000+CPUt.tv_nsec/1000;
   double microCycles=(double)(cpuf*1000);
   int duration=(int)((cur-last)/microCycles);
+
   if ( last!=0 && duration > timeout ) {
     //struct timespec ts;
     //clock_gettime(CLOCK_MONOTONIC, &ts);
     printf("%s:%d lte-ue delay %d (exceed %d), CPU for this period: %lld\n", file, line,
            duration, timeout, (long long)CPUTime-lastCPUTime );
   }
+
   last=cur;
   lastCPUTime=CPUTime;
   return cur;
 }
 
-static inline unsigned long long checkT(int timeout, char * file, int line) {
+static inline unsigned long long checkT(int timeout, char *file, int line) {
   static unsigned long long __thread last=0;
   unsigned long long cur=rdtsc();
   int microCycles=(int)(cpuf*1000);
   int duration=(int)((cur-last)/microCycles);
+
   if ( last!=0 && duration > timeout )
     printf("%s:%d lte-ue delay %d (exceed %d)\n", file, line,
            duration, timeout);
+
   last=cur;
   return cur;
 }
@@ -458,7 +462,7 @@ typedef struct m {
   uint64_t maxArray[11];
 } Meas;
 
-static inline void printMeas(char * txt, Meas *M, int period) {
+static inline void printMeas(char *txt, Meas *M, int period) {
   if (M->iterations%period == 0 ) {
     char txt2[512];
     sprintf(txt2,"%s avg=%" PRIu64 " iterations=%" PRIu64 " max=%"
@@ -476,13 +480,13 @@ static inline void printMeas(char * txt, Meas *M, int period) {
   }
 }
 
-static inline int cmpint(const void* a, const void* b) {
-    uint64_t* aa=(uint64_t*)a;
-    uint64_t* bb=(uint64_t*)b;
+static inline int cmpint(const void *a, const void *b) {
+  uint64_t *aa=(uint64_t *)a;
+  uint64_t *bb=(uint64_t *)b;
   return (int)(*aa-*bb);
 }
 
-static inline void updateTimes(uint64_t start, Meas *M, int period, char * txt) {
+static inline void updateTimes(uint64_t start, Meas *M, int period, char *txt) {
   if (start!=0) {
     uint64_t end=rdtsc();
     long long diff=(end-start)/(cpuf*1000);

common/utils/T/genids.c

@@ -8,27 +8,35 @@ char **unique_ids;
 int unique_ids_size;
 int unique_ids_maxsize;
 
-int cmp(const void *p1, const void *p2)
-{
-  return strcmp(*(char * const *)p1, *(char * const *)p2);
+int cmp(const void *p1, const void *p2) {
+  return strcmp(*(char *const *)p1, *(char *const *)p2);
 }
 
 /* return 1 if s was not already known, 0 if it was */
-int new_unique_id(char *s, char *input_file)
-{
+int new_unique_id(char *s, char *input_file) {
   if (unique_ids_size)
     if (bsearch(&s, unique_ids, unique_ids_size, sizeof(char *), cmp) != NULL) {
       printf("error: ID %s is not unique in %s\n", s, input_file);
       return 0;
     }
+
   if (unique_ids_size == unique_ids_maxsize) {
     unique_ids_maxsize += 256;
     unique_ids = realloc(unique_ids, unique_ids_maxsize * sizeof(char *));
-    if (unique_ids == NULL) { printf("error: out of memory\n"); abort(); }
+
+    if (unique_ids == NULL) {
+      printf("error: out of memory\n");
+      abort();
     }
+  }
+
   unique_ids[unique_ids_size] = strdup(s);
-  if (unique_ids[unique_ids_size] == NULL)
-    { printf("error: out of memory\n"); abort(); }
+
+  if (unique_ids[unique_ids_size] == NULL) {
+    printf("error: out of memory\n");
+    abort();
+  }
+
   unique_ids_size++;
   qsort(unique_ids, unique_ids_size, sizeof(char *), cmp);
   return 1;
@@ -38,14 +46,17 @@ char *bufname;
 int bufname_size;
 int bufname_maxsize;
 
-void putname(int c)
-{
+void putname(int c) {
   if (bufname_size == bufname_maxsize) {
     bufname_maxsize += 256;
     bufname = realloc(bufname, bufname_maxsize);
-    if (bufname == NULL)
-      { printf("error: memory allocation error\n"); exit(1); }
+
+    if (bufname == NULL) {
+      printf("error: memory allocation error\n");
+      exit(1);
+    }
   }
+
   bufname[bufname_size] = c;
   bufname_size++;
 }
@@ -54,42 +65,54 @@ char *bufvalue;
 int bufvalue_size;
 int bufvalue_maxsize;
 
-void putvalue(int c)
-{
+void putvalue(int c) {
   if (bufvalue_size == bufvalue_maxsize) {
     bufvalue_maxsize += 256;
     bufvalue = realloc(bufvalue, bufvalue_maxsize);
-    if (bufvalue == NULL)
-      { printf("error: memory allocation error\n"); exit(1); }
+
+    if (bufvalue == NULL) {
+      printf("error: memory allocation error\n");
+      exit(1);
+    }
   }
+
   bufvalue[bufvalue_size] = c;
   bufvalue_size++;
 }
 
-void smash_spaces(FILE *f)
-{
+void smash_spaces(FILE *f) {
   int c;
+
   while (1) {
     c = fgetc(f);
+
     if (isspace(c)) continue;
+
     if (c == ' ') continue;
+
     if (c == '\t') continue;
+
     if (c == '\n') continue;
+
     if (c == 10 || c == 13) continue;
+
     if (c == '#') {
       while (1) {
         c = fgetc(f);
+
         if (c == '\n' || c == EOF) break;
       }
+
       continue;
     }
+
     break;
   }
+
   if (c != EOF) ungetc(c, f);
 }
 
-void get_line(FILE *f, char **name, char **value)
-{
+void get_line(FILE *f, char **name, char **value) {
   int c;
   bufname_size = 0;
   bufvalue_size = 0;
@@ -97,23 +120,39 @@ void get_line(FILE *f, char **name, char **value)
   *value = NULL;
   smash_spaces(f);
   c = fgetc(f);
-  while (!(c == '=' || isspace(c) || c == EOF)) { putname(c); c = fgetc(f); }
+
+  while (!(c == '=' || isspace(c) || c == EOF)) {
+    putname(c);
+    c = fgetc(f);
+  }
+
   if (c == EOF) return;
+
   putname(0);
+
   while (!(c == EOF || c == '=')) c = fgetc(f);
+
   if (c == EOF) return;
+
   smash_spaces(f);
   c = fgetc(f);
-  while (!(c == 10 || c == 13 || c == EOF)) { putvalue(c); c = fgetc(f); }
+
+  while (!(c == 10 || c == 13 || c == EOF)) {
+    putvalue(c);
+    c = fgetc(f);
+  }
+
   putvalue(0);
+
   if (bufname_size <= 1) return;
+
   if (bufvalue_size <= 1) return;
+
   *name = bufname;
   *value = bufvalue;
 }
 
-int main(int n, char **v)
-{
+int main(int n, char **v) {
   FILE *in;
   FILE *out;
   char *name;
@@ -121,36 +160,54 @@ int main(int n, char **v)
   char *in_name;
   char *out_name;
 
-  if (n != 3) { printf("error: gimme <source> <dest>\n"); exit(1); }
+  if (n != 3) {
+    printf("error: gimme <source> <dest>\n");
+    exit(1);
+  }
 
   n = 0;
-
   in_name = v[1];
   out_name = v[2];
+  in = fopen(in_name, "r");
+
+  if (in == NULL) {
+    perror(in_name);
+    exit(1);
+  }
 
-  in = fopen(in_name, "r"); if (in == NULL) { perror(in_name); exit(1); }
-  out = fopen(out_name, "w"); if (out == NULL) { perror(out_name); exit(1); }
+  out = fopen(out_name, "w");
+
+  if (out == NULL) {
+    perror(out_name);
+    exit(1);
+  }
 
   fprintf(out, "/* generated file, do not edit by hand */\n\n");
 
   while (1) {
     get_line(in, &name, &value);
+
     if (name == NULL) break;
+
     if (isspace(value[strlen(value)-1])) {
       printf("error: bad value '%s' (no space at the end please!)\n", value);
       unlink(out_name);
       exit(1);
     }
+
     if (!strcmp(name, "ID")) {
-      if (!new_unique_id(value, in_name)) { unlink(out_name); exit(1); }
+      if (!new_unique_id(value, in_name)) {
+        unlink(out_name);
+        exit(1);
+      }
+
       fprintf(out, "#define T_%s T_ID(%d)\n", value, n);
       n++;
     }
   }
-  fprintf(out, "#define T_NUMBER_OF_IDS %d\n", n);
 
+  fprintf(out, "#define T_NUMBER_OF_IDS %d\n", n);
   fclose(in);
   fclose(out);
-
   return 0;
 }