cfg.c

speech signal process tools

/*  Return the CFG_C2 value based on the id string              */
/****************************************************************/
char ** CONFIG_elem_C2(CONFIG *cfg, char *str)
{
    int cfg_ind;

    if ((cfg_ind = is_CONFIG_id(cfg,str)) != NOT_CONFIG_ID)
        return ((char **)cfg->rec_list[cfg_ind].value);
    fprintf(stderr,"Error: Unknown Config Paramater Requested %s\n",str);
    exit(-1);
}

/****************************************************************/
/*  Set the value for the CFG_TGL value based on the id string  */
/****************************************************************/
void set_CONFIG_elem_TGL(CONFIG *cfg, char *str, int value)
{
    int cfg_ind;

    if ((cfg_ind = is_CONFIG_id(cfg,str)) == NOT_CONFIG_ID){
        fprintf(stderr,"Error: Unknown Config Paramater Set Requested %s\n",
                       str);
        exit(-1);
    }
    cfg->rec_list[cfg_ind].value = (value == TOGGLE_ON) ? TOGGLE_ON_CHR : TOGGLE_OFF_CHR;
}

/****************************************************************/
/*  Set the value for the CFG_C value based on the id string    */
/****************************************************************/
void set_CONFIG_elem_C(CONFIG *cfg, char *str, char *value)
{
    set_CONFIG_elem_STR(cfg,str,value);
}

/****************************************************************/
/*  Set the value for the CFG_STR value based on the id string  */
/****************************************************************/
void set_CONFIG_elem_STR(CONFIG *cfg, char *str, char *value)
{
    int cfg_ind;

    if ((cfg_ind = is_CONFIG_id(cfg,str)) == NOT_CONFIG_ID){
        fprintf(stderr,"Error: Unknown Config Paramater Set Requested %s\n",
                       str);
        exit(-1);
    }
    strcpy(cfg->rec_list[cfg_ind].value,value);
}

/****************************************************************/
/*  Return the element count for the id string                  */
/****************************************************************/
int CONFIG_elem_count(CONFIG *cfg, char *str)
{
    int ind;

    if ((ind = is_CONFIG_id(cfg,str)) == NOT_CONFIG_ID){
        fprintf(stderr,"Error: Invalid id string to find CONFIG ");
        fprintf(stderr,"element count\n");
        exit(-1);
    }
    return(cfg->rec_list[ind].num_elem);
}

/****************************************************************/
/*  Return the element count for the id string                  */
/****************************************************************/
int CONFIG_elem_present_C2(CONFIG *cfg, char *str)
{
    int ind, i;
    char **t_arr;

    if ((ind = is_CONFIG_id(cfg,str)) == NOT_CONFIG_ID){
        fprintf(stderr,"Error: Invalid id string to find CONFIG ");
        fprintf(stderr,"element present count\n");
        exit(-1);
    }
    t_arr = (char **)cfg->rec_list[ind].value;

    for (i=0; i<cfg->rec_list[ind].num_elem; i++)
        if (t_arr[i][0] == NULL_CHAR)
           return(i);
    return(cfg->rec_list[ind].num_elem);
}

/****************************************************************/
/*  Return the element index for the id string                  */
/****************************************************************/
int is_CONFIG_id(CONFIG *cfg, char *id)
{
    int i=0;

    while (*(cfg->rec_list[i].intern_id) != NULL_CHAR){
        if (strcasecmp(id,cfg->rec_list[i].intern_id) == 0)
            return(i);
        i++;
    }
    return(NOT_CONFIG_ID);
}

/****************************************************************/
/*  Dump the config structure to stdout                         */
/****************************************************************/
void dump_CONFIG(CONFIG *cfg)
{
    int i=0;

    printf("Dump of the Configuration arguments and their values\n\n");
    printf("      Name       # elem  type    value\n");
    while (*(cfg->rec_list[i].intern_id) != NULL_CHAR){
       printf(" %15s  %3d    ",cfg->rec_list[i].intern_id,
             cfg->rec_list[i].num_elem);
       switch (cfg->rec_list[i].value_type){
           case CFG_TGL:
              printf("TGL    ");
              if (strcmp(cfg->rec_list[i].value,TOGGLE_ON_CHR) != 0)
                  printf(" OFF\n");
              else
                  printf(" ON\n");
              break;
           case CFG_STR:
              printf("STR    ");
              printf(" %s\n",(char *)cfg->rec_list[i].value);
              break;
           case CFG_C:
              printf("FILE   ");
              printf(" %s\n",(char *)cfg->rec_list[i].value);
              break;
           case CFG_C2:{
              char **chr;
              int ind = 0;
              printf("N_STR  ");
              chr = (char **)cfg->rec_list[i].value;
              if (chr == NULL){
                  printf("\n");
                  break;
	      }
              printf(" %s\n",chr[ind]);
              for (ind = 1;ind < cfg->rec_list[i].num_elem; ind++)
                  if (*(chr[ind]) != NULL_CHAR)
                      printf("%30s   %s\n","",chr[ind]);
              break;
	   }
           default:
              fprintf(stderr,"Error: Unknown CONFIG type %d\n",
                             cfg->rec_list[i].value_type);
              exit(-1);
              break;
       }
       i++;
    }

}

/****************************************************************/
/*  Dump the config structure to stdout (this is as a usage     */
/*  statement)                                                  */
/****************************************************************/
void print_usage_CONFIG(CONFIG *cfg, char *prog_name)
{
    int i=0, j, grp_ids[10], first;

    for (i=0; i<10; i++) grp_ids[i]=FALSE;

    printf("Usage: %s\n",prog_name);
    for (i=0; *(cfg->rec_list[i].intern_id) != NULL_CHAR; i++){
	if (cfg->rec_list[i].flag_group != NO_GRP){
	    if (grp_ids[cfg->rec_list[i].flag_group] == FALSE){
		/* dump the group */
		printf("      [ ");
		first = 0;
		for (j=0; *(cfg->rec_list[j].intern_id) != NULL_CHAR; j++){
		    if (cfg->rec_list[j].flag_group == 
			cfg->rec_list[i].flag_group){
			if (first++ != 0)
			    printf("| ");
			switch (cfg->rec_list[j].value_type){
			  case CFG_TGL:
			    printf("-%s ", cfg->rec_list[j].intern_id);
			    break;
			  case CFG_STR:
			    printf("-%s string ",cfg->rec_list[j].intern_id);
			    break;
			  case CFG_C:
			    printf("-%s file_name ",cfg->rec_list[j].intern_id);
			    break;
			  case CFG_C2:{
			      printf("-%s ",cfg->rec_list[j].intern_id);
			      printf("(MAX %d) file_name ",
				     cfg->rec_list[j].num_elem);
			      break;
			  }
			  default:
			    fprintf(stderr,"Error: Unknown CONFIG type %d\n",
				    cfg->rec_list[i].value_type);
			    exit(-1);
			    break;
			}
		    }
		}
		printf("]\n");
		grp_ids[cfg->rec_list[i].flag_group] = TRUE;
	    }
	} else {
	    switch (cfg->rec_list[i].value_type){
	      case CFG_TGL:
		printf("      [ -%s ]\n",cfg->rec_list[i].intern_id);
		break;
	      case CFG_STR:
		printf("      [ -%s string ]\n",cfg->rec_list[i].intern_id);
		break;
	      case CFG_C:
		printf("      [ -%s file_name ]\n",cfg->rec_list[i].intern_id);
		break;
	      case CFG_C2:{
		  printf("      [ -%s ",cfg->rec_list[i].intern_id);
		  printf("(MAX %d) file_name ]\n",cfg->rec_list[i].num_elem);
		  break;
	      }
	      default:
		fprintf(stderr,"Error: Unknown CONFIG type %d\n",
			cfg->rec_list[i].value_type);
		exit(-1);
		break;
	    }
	}
    }
}

/****************************************************************/
/*  Check the configuration id 'ind' to see if it has been set  */
/****************************************************************/
int is_CONFIG_ind_set(CONFIG *cfg, int ind, int verbose)
{
    char **t_arr;
    int i;

    switch (cfg->rec_list[ind].value_type){
      case CFG_TGL:
	if (strcmp(cfg->rec_list[ind].value,TOGGLE_ON_CHR) == 0)
	    return(TRUE);
	break;
      case CFG_C:
	if (*(cfg->rec_list[ind].value) != NULL_CHAR){
	    if (file_readable(cfg->rec_list[ind].value))
		return(TRUE);
	    fprintf(stderr,
		    "Error: File '%s' for argument '%s' is un-readable\n",
		    cfg->rec_list[ind].value,cfg->rec_list[ind].intern_id);
	    return(FALSE);
	}
	break;
      case CFG_STR:
	if (*(cfg->rec_list[ind].value) != NULL_CHAR)
	    return(TRUE);
	break;
      case CFG_C2:
	t_arr = (char **)cfg->rec_list[ind].value;
	for (i=0; i < cfg->rec_list[ind].num_elem; i++)
	    if (*(t_arr[i]) != NULL_CHAR)
		return(TRUE);
	break;
      default:
	fprintf(stderr,"Error: Unknown CONFIG type %d\n",
		cfg->rec_list[ind].value_type);
	exit(-1);
	break;
    }
    if (verbose)
	fprintf(stderr,"Error: Argument '%s' was not used\n",
		cfg->rec_list[ind].intern_id);
    return(FALSE);
}

/****************************************************************/
/*  verify that at least one of a group set has been set        */
/****************************************************************/
int is_CONFIG_group_set(CONFIG *cfg, int grp_ind, int verbose)
{
    int i=0;

    if (cfg_dbg) printf("CFG: cfg_group_is_active: %d\n",grp_ind);

    /* otherwise, erase all the other values for it's grouping */
    for (i=0; *(cfg->rec_list[i].intern_id) != NULL_CHAR; i++){
        if (cfg->rec_list[i].flag_group == grp_ind){
	    if (is_CONFIG_ind_set(cfg, i, FALSE))
		return(TRUE);
	}
    }
    if (verbose) {
	fprintf(stderr,"Error: One of these arguments should be used: ");
	for (i=0; *(cfg->rec_list[i].intern_id) != NULL_CHAR; i++)
	    if (cfg->rec_list[i].flag_group == grp_ind)
		fprintf(stderr,"%s ",cfg->rec_list[i].intern_id);
	fprintf(stderr,"\n");
    }
    return(FALSE);
}

/****************************************************************/
/*  verify that a cfg string has been set.                      */
/****************************************************************/
int is_CONFIG_set(CONFIG *cfg, char *str, int verbose)
{
    return(is_CONFIG_ind_set(cfg,is_CONFIG_id(cfg,str),verbose));
}