예제 #1
0
파일: mconfig.c 프로젝트: MLDroid/malheur
/**
 * Checks if the configuration is valid. The function checks if all 
 * required parameters are set and adds default values if necessary.
 * @param cfg configuration
 */
void config_check(config_t *cfg)
{
    int i, j;
    const char *s;
    double f;
    config_setting_t *cs, *vs;

    for (i = 0; defaults[i].name; i++) {
        /* Lookup setting group */
        cs = config_lookup(cfg, defaults[i].group);
        if (!cs)
            cs = config_setting_add(config_root_setting(cfg),
                                    defaults[i].group, CONFIG_TYPE_GROUP);

        /* (1) Check for string */
        if (defaults[i].type == CONFIG_TYPE_STRING) {
            if (config_setting_lookup_string(cs, defaults[i].name, &s))
                continue;

            /* Add default value */
            vs = config_setting_add(cs, defaults[i].name, CONFIG_TYPE_STRING);
            config_setting_set_string(vs, defaults[i].val.sval);
        /* (2) Check for float */            
        } else if (defaults[i].type == CONFIG_TYPE_FLOAT) {
            if (config_setting_lookup_float(cs, defaults[i].name, &f))
                continue;

            /* Check for mis-interpreted integer */
            if (config_setting_lookup_int(cs, defaults[i].name, &j)) {
                config_setting_remove(cs, defaults[i].name);
                vs = config_setting_add(cs, defaults[i].name, CONFIG_TYPE_FLOAT);
                config_setting_set_float(vs, (double) j);
                continue;
            }

            /* Add default value */
            vs = config_setting_add(cs, defaults[i].name, CONFIG_TYPE_FLOAT);
            config_setting_set_float(vs, defaults[i].val.fval);
        /* (3) Check for integer */            
        } else if (defaults[i].type == CONFIG_TYPE_INT) {
            if (config_setting_lookup_int(cs, defaults[i].name, &j))
                continue;

            /* Check for mis-interpreted float */
            if (config_setting_lookup_float(cs, defaults[i].name, &f)) {
                config_setting_remove(cs, defaults[i].name);
                vs = config_setting_add(cs, defaults[i].name, CONFIG_TYPE_INT);
                config_setting_set_int(vs, (long) round(f));
                continue;
            }

            /* Add default value */
            vs = config_setting_add(cs, defaults[i].name, CONFIG_TYPE_INT);
            config_setting_set_int(vs, defaults[i].val.ival);
        } else {
            error("Unknown configuration type");
        }
    }
}
예제 #2
0
int main(int argc, char **argv)
{
  static const char *output_file = "updated.cfg";
  config_t cfg;
  config_setting_t *root, *setting, *movie;

  config_init(&cfg);

  /* Read the file. If there is an error, report it and exit. */
  if(! config_read_file(&cfg, "example.cfg"))
  {
    fprintf(stderr, "%s:%d - %s\n", config_error_file(&cfg),
            config_error_line(&cfg), config_error_text(&cfg));
    config_destroy(&cfg);
    return(EXIT_FAILURE);
  }

  /* Find the 'movies' setting. Add intermediate settings if they don't yet
  * exist.
  */
  root = config_root_setting(&cfg);

  setting = config_setting_get_member(root, "inventory");
  if(!setting)
    setting = config_setting_add(root, "inventory", CONFIG_TYPE_GROUP);

  setting = config_setting_get_member(setting, "movies");
  if(!setting)
    setting = config_setting_add(setting, "movies", CONFIG_TYPE_LIST);

  /* Create the new movie entry. */
  movie = config_setting_add(setting, NULL, CONFIG_TYPE_GROUP);

  setting = config_setting_add(movie, "title", CONFIG_TYPE_STRING);
  config_setting_set_string(setting, "Buckaroo Banzai");

  setting = config_setting_add(movie, "media", CONFIG_TYPE_STRING);
  config_setting_set_string(setting, "DVD");

  setting = config_setting_add(movie, "price", CONFIG_TYPE_FLOAT);
  config_setting_set_float(setting, 12.99);

  setting = config_setting_add(movie, "qty", CONFIG_TYPE_INT);
  config_setting_set_float(setting, 20);

  /* Write out the updated configuration. */
  if(! config_write_file(&cfg, output_file))
  {
    fprintf(stderr, "Error while writing file.\n");
    config_destroy(&cfg);
    return(EXIT_FAILURE);
  }

  fprintf(stderr, "Updated configuration successfully written to: %s\n",
          output_file);

  config_destroy(&cfg);
  return(EXIT_SUCCESS);
}
예제 #3
0
파일: libconfig.c 프로젝트: mlafeldt/ps2rd
config_setting_t *config_setting_set_float_elem(config_setting_t *vector,
                                                int idx, double value)
{
  config_setting_t *element = NULL;

  if((vector->type != CONFIG_TYPE_ARRAY) && (vector->type != CONFIG_TYPE_LIST))
    return(NULL);

  if(idx < 0)
  {
    if(! __config_vector_checktype(vector, CONFIG_TYPE_FLOAT))
      return(NULL);

    element = config_setting_create(vector, NULL, CONFIG_TYPE_FLOAT);
  }
  else
    element = config_setting_get_elem(vector, idx);

  if(! element)
    return(NULL);

  if(! config_setting_set_float(element, value))
    return(NULL);

  return(element);
}
예제 #4
0
void config_setting_copy_simple(config_setting_t *parent, const config_setting_t *src)
{
	if (config_setting_is_aggregate(src)) {
		config_setting_copy_aggregate(parent, src);
	}
	else {
		config_setting_t *set;
		
		if( config_setting_get_member(parent, config_setting_name(src)) != NULL )
			return;
		
		if ((set = config_setting_add(parent, config_setting_name(src), config_setting_type(src))) == NULL)
			return;

		if (CONFIG_TYPE_INT == config_setting_type(src)) {
			config_setting_set_int(set, config_setting_get_int(src));
			config_setting_set_format(set, src->format);
		} else if (CONFIG_TYPE_INT64 == config_setting_type(src)) {
			config_setting_set_int64(set, config_setting_get_int64(src));
			config_setting_set_format(set, src->format);
		} else if (CONFIG_TYPE_FLOAT == config_setting_type(src)) {
			config_setting_set_float(set, config_setting_get_float(src));
		} else if (CONFIG_TYPE_STRING == config_setting_type(src)) {
			config_setting_set_string(set, config_setting_get_string(src));
		} else if (CONFIG_TYPE_BOOL == config_setting_type(src)) {
			config_setting_set_bool(set, config_setting_get_bool(src));
		}
	}
}
예제 #5
0
void MainDialog::configSetFloat(const char* key, double val) {
  config_setting_t* setting = config_lookup(&config_, key);
  if(!setting) { // setting not found
    // add a new setting for it
    config_setting_t* root = config_root_setting(&config_);
    setting = config_setting_add(root, key, CONFIG_TYPE_FLOAT);
  }
  config_setting_set_float(setting, val);
}
예제 #6
0
/*********************
return RET_NOK on error
*********************/
ret_code_t entry_copy_config(config_setting_t * source, config_setting_t * dest)
{
	config_setting_t * new_source;
	config_setting_t * new_dest;
	int index = -1;
	int int_value;
	long long long_value;
	double double_value;
	const char * string;

	while((new_source=config_setting_get_elem(source,index+1))!= NULL ) {
		index++;
		if(config_setting_is_group(new_source)) {
			if(!entry_copy_aggregate(new_source,dest,CONFIG_TYPE_GROUP)) {
				return RET_NOK;
			}
		}

		else if(config_setting_is_array(new_source)) {
			if(!entry_copy_aggregate(new_source,dest,CONFIG_TYPE_ARRAY)) {
				return RET_NOK;
			}
		}

		else if(config_setting_is_list(new_source)) {
			if(!entry_copy_aggregate(new_source,dest,CONFIG_TYPE_LIST)) {
				return RET_NOK;
			}
		}

		else {
			switch(config_setting_type(new_source)) {
			case CONFIG_TYPE_INT:
				int_value = config_setting_get_int(new_source);
				new_dest = config_setting_add (dest, config_setting_name(new_source),CONFIG_TYPE_INT);
				config_setting_set_int(new_dest,int_value);
				continue;
			case CONFIG_TYPE_INT64:
				long_value = config_setting_get_int64(new_source);
				new_dest = config_setting_add (dest, config_setting_name(new_source),CONFIG_TYPE_INT64);
				config_setting_set_int64(new_dest,long_value);
				continue;
			case CONFIG_TYPE_FLOAT:
				double_value = config_setting_get_float(new_source);
				new_dest = config_setting_add (dest, config_setting_name(new_source),CONFIG_TYPE_FLOAT);
				config_setting_set_float(new_dest,double_value);
				continue;
			case CONFIG_TYPE_BOOL:
				int_value = config_setting_get_bool(new_source);
				new_dest = config_setting_add (dest, config_setting_name(new_source),CONFIG_TYPE_BOOL);
				config_setting_set_bool(new_dest,int_value);
				continue;
			case CONFIG_TYPE_STRING:
				string = config_setting_get_string(new_source);
				new_dest = config_setting_add (dest, config_setting_name(new_source),CONFIG_TYPE_STRING);
				config_setting_set_string(new_dest,string);
				continue;
			default:
				return RET_NOK;
			}
		}
	}

	return RET_OK;
}
예제 #7
0
int writeCfgState(void) {
	config_t cfg;
	config_setting_t *ttempState = 0;
	config_setting_t *thumState = 0;
	config_setting_t *tRHeatTS = 0;
	config_setting_t *tRHumTS = 0;
	config_setting_t *tRHepaTS = 0;
	config_setting_t *tRFanTS = 0;
	config_setting_t *twfactor = 0;
	config_setting_t *trelay1o = 0;
	config_setting_t *trelay2o = 0;
	config_setting_t *trelay3o = 0;
	config_setting_t *trelay4o = 0;
	config_setting_t *trelay5o = 0;
	config_setting_t *trelay6o = 0;
	config_setting_t *trelay7o = 0;
	config_setting_t *trelay8o = 0;

	config_init(&cfg);

	if (!config_read_file(&cfg, config_state_path))
	{
		printf("\n%s:%d - %s", config_error_file(&cfg), config_error_line(&cfg), config_error_text(&cfg));
		config_destroy(&cfg);
		return -1;
	}

	/* lookup variables in config file */
	ttempState = config_lookup(&cfg, "tempState");
	thumState = config_lookup(&cfg, "humState");
	trelay1o = config_lookup(&cfg, "relay1o");
	trelay2o = config_lookup(&cfg, "relay2o");
	trelay3o = config_lookup(&cfg, "relay3o");
	trelay4o = config_lookup(&cfg, "relay4o");
	trelay5o = config_lookup(&cfg, "relay5o");
	trelay6o = config_lookup(&cfg, "relay6o");
	trelay7o = config_lookup(&cfg, "relay7o");
	trelay8o = config_lookup(&cfg, "relay8o");
	tRHeatTS = config_lookup(&cfg, "RHeatTS");
	tRHumTS = config_lookup(&cfg, "RHumTS");
	tRHepaTS = config_lookup(&cfg, "RHepaTS");
	tRFanTS = config_lookup(&cfg, "RFanTS");
	twfactor = config_lookup(&cfg, "wfactor");

	/* get variables from config file then print the variables that changed */
	if (config_setting_get_int(ttempState) != tempState) {
		printf("\ntempState: %i -> ", config_setting_get_int(ttempState));
		config_setting_set_int(ttempState, tempState);
		printf("%i", config_setting_get_int(ttempState));
	}
	if (config_setting_get_int(thumState) != humState) {
		printf("\nhumState: %i -> ", config_setting_get_int(thumState));
		config_setting_set_int(thumState, humState);
		printf("%i", config_setting_get_int(thumState));
	}
	if (config_setting_get_int(trelay1o) != relay1o) {
		printf("\nrelay1o: %i -> ", config_setting_get_int(trelay1o));
		config_setting_set_int(trelay1o, relay1o);
		printf("%i", config_setting_get_int(trelay1o));
	}
	if (config_setting_get_int(trelay2o) != relay2o) {
		printf("\nrelay2o: %i -> ", config_setting_get_int(trelay2o));
		config_setting_set_int(trelay2o, relay2o);
		printf("%i", config_setting_get_int(trelay2o));
	}
	if (config_setting_get_int(trelay3o) != relay3o) {
		printf("\nrelay3o: %i -> ", config_setting_get_int(trelay3o));
		config_setting_set_int(trelay3o, relay3o);
		printf("%i", config_setting_get_int(trelay3o));
	}
	if (config_setting_get_int(trelay4o) != relay4o) {
		printf("\nrelay4o: %i -> ", config_setting_get_int(trelay4o));
		config_setting_set_int(trelay4o, relay4o);
		printf("%i", config_setting_get_int(trelay4o));
	}
	if (config_setting_get_int(trelay5o) != relay5o) {
		printf("\nrelay5o: %i -> ", config_setting_get_int(trelay5o));
		config_setting_set_int(trelay5o, relay5o);
		printf("%i", config_setting_get_int(trelay5o));
	}
	if (config_setting_get_int(trelay6o) != relay6o) {
		printf("\nrelay6o: %i -> ", config_setting_get_int(trelay6o));
		config_setting_set_int(trelay6o, relay6o);
		printf("%i", config_setting_get_int(trelay6o));
	}
	if (config_setting_get_int(trelay7o) != relay7o) {
		printf("\nrelay7o: %i -> ", config_setting_get_int(trelay7o));
		config_setting_set_int(trelay7o, relay7o);
		printf("%i", config_setting_get_int(trelay7o));
	}
	if (config_setting_get_int(trelay8o) != relay8o) {
		printf("\nrelay8o: %i -> ", config_setting_get_int(trelay8o));
		config_setting_set_int(trelay8o, relay8o);
		printf("%i", config_setting_get_int(trelay8o));
	}
	if (config_setting_get_int(tRHeatTS) != RHeatTS) {
		printf("\nRHeatTS: %i -> ", config_setting_get_int(tRHeatTS));
		config_setting_set_int(tRHeatTS, RHeatTS);
		printf("%i", config_setting_get_int(tRHeatTS));
	}
	if (config_setting_get_int(tRHumTS) != RHumTS) {
		printf("\nRHumTS: %i -> ", config_setting_get_int(tRHumTS));
		config_setting_set_int(tRHumTS, RHumTS);
		printf("%i", config_setting_get_int(tRHumTS));
	}
	if (config_setting_get_int(tRHepaTS) != RHepaTS) {
		printf("\nRHepaTS: %i -> ", config_setting_get_int(tRHepaTS));
		config_setting_set_int(tRHepaTS, RHepaTS);
		printf("%i", config_setting_get_int(tRHepaTS));
	}
	if (config_setting_get_int(tRFanTS) != RFanTS) {
		printf("\nRFanTS: %i -> ", config_setting_get_int(tRFanTS));
		config_setting_set_int(tRFanTS, RFanTS);
		printf("%i", config_setting_get_int(tRFanTS));
	}
	if (config_setting_get_float(twfactor) != wfactor) {
		printf("\nwfactor: %i -> ", config_setting_get_float(twfactor));
		config_setting_set_float(twfactor, wfactor);
		printf("%i", config_setting_get_float(twfactor));
	}

	/* write the modified config file */
	config_write_file(&cfg, config_state_path);
	config_destroy(&cfg);
	return 0;
}
예제 #8
0
파일: options.cpp 프로젝트: rdewaele/adhd
// load the default configuration in cfg
static void set_default_config(config_t * cfg) {
	static const unsigned AACCESSES = 4 * 1024 * 1024;
	static const unsigned BEGIN = BEGIN_INIT;
	static const char SPAWN[] = "linear";
	static const long long END = END_INIT;
	static const float FREQUENCY = 1;
	static const bool LOGGING = false;
	static const char LOGFILE[] = "adhd_log";
	static const char PATTERN[] = "random";
	static const unsigned PROCESSES = 1;
	static const unsigned REPETITIONS = 50;
	static const long long STEP = STEP_INIT;
	static const char SCALING[] = "linear";
	static const bool SILENT = false;
	static const unsigned THREADS = 1;

	static const long long STREAM_STEP = 10 * (1 << 20);
	static const long long STREAM_END = 100 * (1 << 20);

	static const long long FLOPS_STEP = 10 * (1 << 10);
	static const long long FLOPS_END = 1 * (1 << 20);
	static const long long FLOPS_CALCULATIONS = 1000 * 1000 * 1000;

	config_setting_t *setting;
	config_setting_t *root;
	root = config_root_setting(cfg);

	// generic group
	{
		config_setting_t *generic =
			config_setting_add(root, FLD_GENERIC_GROUP, CONFIG_TYPE_GROUP);

		// array of names of enabled programs (uses corresponding group names for
		// the sake of simplicity)
		{
			config_setting_t *programs =
				config_setting_add(generic, FLD_PROGRAMS_GROUP, CONFIG_TYPE_ARRAY);

			static const char *names[] = {
				FLD_WALKARRAY_GROUP,
				FLD_STREAMARRAY_GROUP,
				FLD_FLOPSARRAY_GROUP,
				NULL // mark end of list
			};

			for (size_t i = 0; names[i]; ++i) {
				setting = config_setting_add(programs, NULL, CONFIG_TYPE_STRING);
				config_setting_set_string(setting, names[i]);
			}
		}

		// CPU frequency to calculate cycle estimate
		// TODO: use actual cycle counter in the CPU
		// (this is a feature with a design impact, as SMP complicates matters ... :))
		setting = config_setting_add(generic, FLD_GENERIC_GPU_FREQUENCY, CONFIG_TYPE_FLOAT);
		config_setting_set_float(setting, FREQUENCY);

		// logging enabled?
		setting = config_setting_add(generic, FLD_GENERIC_LOGGING, CONFIG_TYPE_BOOL);
		config_setting_set_bool(setting, LOGGING);

		// base filename to log process timings to
		setting = config_setting_add(generic, FLD_GENERIC_LOGFILE, CONFIG_TYPE_STRING);
		config_setting_set_string(setting, LOGFILE);

		// process spawn method
		setting = config_setting_add(generic, FLD_GENERIC_SPAWN, CONFIG_TYPE_STRING);
		config_setting_set_string(setting, SPAWN);

		// number of processes to run: begin
		// TODO: just like arrays we could have a linear or exponential increment
		setting = config_setting_add(generic, FLD_GENERIC_PROCESSES_BEGIN, CONFIG_TYPE_INT64);
		config_setting_set_int64(setting, PROCESSES);

		// number of processes to run: end
		setting = config_setting_add(generic, FLD_GENERIC_PROCESSES_END, CONFIG_TYPE_INT64);
		config_setting_set_int64(setting, PROCESSES);

		// number of threads per process to run: begin
		// TODO: just like arrays we could have a linear or exponential increment
		setting = config_setting_add(generic, FLD_GENERIC_THREADS_BEGIN, CONFIG_TYPE_INT64);
		config_setting_set_int64(setting, THREADS);

		// number of threads per process to run: end
		setting = config_setting_add(generic, FLD_GENERIC_THREADS_END, CONFIG_TYPE_INT64);
		config_setting_set_int64(setting, THREADS);

		// silent mode
		setting = config_setting_add(generic, FLD_GENERIC_SILENT, CONFIG_TYPE_BOOL);
		config_setting_set_bool(setting, SILENT);
	}

	// walking array group
	{
		config_setting_t *array =
			config_setting_add(root, FLD_WALKARRAY_GROUP, CONFIG_TYPE_GROUP);

		// array accesses
		setting = config_setting_add(array, FLD_WALKARRAY_ACCESSES, CONFIG_TYPE_INT64);
		config_setting_set_int64(setting, AACCESSES);

		// repetitions of a single test, to be able to calculate an average
		// and a standard deviation, indicating run precision
		setting = config_setting_add(array, FLD_WALKARRAY_REPEAT, CONFIG_TYPE_INT64);
		config_setting_set_int64(setting, REPETITIONS);

		// initial array size
		setting = config_setting_add(array, FLD_WALKARRAY_BEGINLENGTH, CONFIG_TYPE_INT64);
		config_setting_set_int64(setting, BEGIN);

		// maximal array size
		setting = config_setting_add(array, FLD_WALKARRAY_ENDLENGTH, CONFIG_TYPE_INT64);
		config_setting_set_int64(setting, END);

		// increment factor
		setting = config_setting_add(array, FLD_WALKARRAY_INCREMENT, CONFIG_TYPE_INT64);
		config_setting_set_int64(setting, STEP);

		// increment type
		// (linear adds the increment, exponential multiplies the previous length)
		setting = config_setting_add(array, FLD_WALKARRAY_SCALING, CONFIG_TYPE_STRING);
		config_setting_set_string(setting, SCALING);

		// walking pattern
		// (sequentially increasing/decreasing or random)
		setting = config_setting_add(array, FLD_WALKARRAY_PATTERN, CONFIG_TYPE_STRING);
		config_setting_set_string(setting, PATTERN);
	}

	// streaming array group
	{
		config_setting_t *array =
			config_setting_add(root, FLD_STREAMARRAY_GROUP, CONFIG_TYPE_GROUP);

		// initial array size
		setting = config_setting_add(array, FLD_STREAMARRAY_BEGINLENGTH, CONFIG_TYPE_INT64);
		config_setting_set_int64(setting, BEGIN);

		// maximal array size
		setting = config_setting_add(array, FLD_STREAMARRAY_ENDLENGTH, CONFIG_TYPE_INT64);
		config_setting_set_int64(setting, STREAM_END);

		// increment factor
		setting = config_setting_add(array, FLD_STREAMARRAY_INCREMENT, CONFIG_TYPE_INT64);
		config_setting_set_int64(setting, STREAM_STEP);

		// increment type
		// (linear adds the increment, exponential multiplies the previous length)
		setting = config_setting_add(array, FLD_STREAMARRAY_SCALING, CONFIG_TYPE_STRING);
		config_setting_set_string(setting, SCALING);
	}

	// flops array group
	{
		config_setting_t *array =
			config_setting_add(root, FLD_FLOPSARRAY_GROUP, CONFIG_TYPE_GROUP);

		// initial array size
		setting = config_setting_add(array, FLD_FLOPSARRAY_BEGINLENGTH, CONFIG_TYPE_INT64);
		config_setting_set_int64(setting, BEGIN);

		// maximal array size
		setting = config_setting_add(array, FLD_FLOPSARRAY_ENDLENGTH, CONFIG_TYPE_INT64);
		config_setting_set_int64(setting, FLOPS_END);

		// increment factor
		setting = config_setting_add(array, FLD_FLOPSARRAY_INCREMENT, CONFIG_TYPE_INT64);
		config_setting_set_int64(setting, FLOPS_STEP);

		// increment type
		// (linear adds the increment, exponential multiplies the previous length)
		setting = config_setting_add(array, FLD_FLOPSARRAY_SCALING, CONFIG_TYPE_STRING);
		config_setting_set_string(setting, SCALING);

		// number of calculations to perform
		setting = config_setting_add(array, FLD_FLOPSARRAY_CALCULATIONS, CONFIG_TYPE_INT64);
		config_setting_set_int64(setting, FLOPS_CALCULATIONS);
	}
}