int read_scenario_master_file(char scenario_list[30][60],
                              unsigned int scenario_reps[60]) {
  config_t cfg; // Returns all parameters in this structure
  char current_scenario[30];
  const char *tmpS;
  int num_scenarios = 1;
  int tmpI; // Stores the value of Integer Parameters from Config file

  config_init(&cfg);

  // Read the file. If there is an error, report it and exit.
  if (!config_read_file(&cfg, "master_scenario_file.cfg")) {
    printf("Error reading master scenario file on line %i\n",
           config_error_line(&cfg));
    exit(1);
  }

  // Read the parameter group
  if (config_lookup_int(&cfg, "NumberofScenarios", &tmpI))
    num_scenarios = (int)tmpI;

  for (int i = 0; i < num_scenarios; i++) {
    sprintf(current_scenario, "scenario_%d", i + 1);
    if (config_lookup_string(&cfg, current_scenario, &tmpS))
      strcpy(&scenario_list[i][0], tmpS);
  }
  for (int i = 0; i < num_scenarios; i++) {
    sprintf(current_scenario, "reps_scenario_%d", i + 1);
    if (config_lookup_int(&cfg, current_scenario, &tmpI))
      scenario_reps[i] = tmpI;
  }
  config_destroy(&cfg);
  return num_scenarios;
} // End readScMasterFile()

	void Init(HINSTANCE i_thisInstanceOfTheApplication, HINSTANCE i_thisIsNothing, char* i_commandLineArguments, int i_initialWindowDisplayState)
	{
		config_t cfg;
		int Screenwidth;
		int Screenheight;
		config_init(&cfg);

		if(! config_read_file(&cfg, "config.cfg"))
		{
			fprintf(stderr, "%s:%d - %s\n", config_error_file(&cfg),
							config_error_line(&cfg), config_error_text(&cfg));
			config_destroy(&cfg);
		}
		config_lookup_int(&cfg, "ScreenWidth", &Screenwidth);
		config_lookup_int(&cfg, "ScreenHeight", &Screenheight);
		  
		config_destroy(&cfg);
		Renderer::width=Screenwidth;
		Renderer::height=Screenheight;

		Singleton<Time>::getInstance().Init();
		Singleton<Physics>::getInstance().Init();
		Singleton<Renderer>::getInstance().Init( i_thisInstanceOfTheApplication, i_thisIsNothing,  i_commandLineArguments,  i_initialWindowDisplayState);
		Singleton<World>::getInstance().Init();
		Singleton<Collision>::getInstance().Init();
		Singleton<EventHandler>::getInstance().Init();
		SoundManager::Manager().Init();
	}

static int init(int argc, char **argv) {
  const char *str;
  int value;

  config.audio_backend_buffer_desired_length = 44100; // one second.
  config.audio_backend_latency_offset = 0;

  if (config.cfg != NULL) {
    /* Get the desired buffer size setting. */
    if (config_lookup_int(config.cfg, "stdout.audio_backend_buffer_desired_length", &value)) {
      if ((value < 0) || (value > 132300))
        die("Invalid stdout audio backend buffer desired length \"%d\". It should be between 0 and 132300, default is 44100",
            value);
      else
        config.audio_backend_buffer_desired_length = value;
    }

    /* Get the latency offset. */
    if (config_lookup_int(config.cfg, "stdout.audio_backend_latency_offset", &value)) {
      if ((value < -66150) || (value > 66150))
        die("Invalid stdout audio backend buffer latency offset \"%d\". It should be between -66150 and +66150, default is 0",
            value);
      else
        config.audio_backend_latency_offset = value;
    }
  }
  return 0;
}

/**
 * Initializes the similarity measure
 */
void kern_wdegree_config()
{
    const char *str;

    config_lookup_int(&cfg, "measures.kern_wdegree.degree", &degree);
    config_lookup_int(&cfg, "measures.kern_wdegree.shift", &shift);

    /* Normalization */
    config_lookup_string(&cfg, "measures.kern_wdegree.norm", &str);
    n = knorm_get(str);
}

/**
 * Re-reads configuration from the given file
 */
int read_config() {
	config_t cfg;
	config_init(&cfg);

	if (config_read_file(&cfg, conf.config_file) == CONFIG_FALSE) {
		if (config_error_type(&cfg) == CONFIG_ERR_FILE_IO) {
			log_error("Configuration file not found: %s", conf.config_file);
			config_destroy(&cfg);
			return -1;
		}
		log_error("%s:%d - %s", config_error_file(&cfg), config_error_line(&cfg), config_error_text(&cfg));
		config_destroy(&cfg);
		return -1;
	}

	int intVal;
	const char* charVal;
	if (config_lookup_int(&cfg, "num_connections", &intVal) == CONFIG_TRUE) {
		conf.num_connections = intVal;
	}
	if (config_lookup_int(&cfg, "report_freq", &intVal) == CONFIG_TRUE) {
		conf.report_freq = intVal;
	}
	if (config_lookup_int(&cfg, "packet_size", &intVal) == CONFIG_TRUE) {
		if (intVal > MAXPACKET) {
			log_error("packet_size: %d exceeds maximal packet size (%d)", intVal, MAXPACKET);
			config_destroy(&cfg);
			return -1;
		}
		conf.packet_size = intVal;
	}
	if (config_lookup_int(&cfg, "packets_count", &intVal) == CONFIG_TRUE) {
		conf.packets_count = intVal;
	}
	if (config_lookup_string(&cfg, "reports_dir", &charVal) == CONFIG_TRUE) {
		free(conf.reports_dir);
		conf.reports_dir = strdup(charVal);
	}
	if (config_lookup_string(&cfg, "hosts_file", &charVal) == CONFIG_TRUE) {
		free(conf.hosts_file);
		conf.hosts_file = strdup(charVal);
	}
	if (config_lookup_string(&cfg, "log_file", &charVal) == CONFIG_TRUE) {
		free(conf.log_file);
		conf.log_file = strdup(charVal);
	}
	config_destroy(&cfg);

	if (read_hosts() == -1) {
		return -1;
	}

	return 0;
}

int get_server_config(s_config *c, char *config_path)
{
	config_t cfg;
	config_setting_t *modules_setting, *module_setting;
	unsigned int count, i;
	const char *module_name;

	config_init(&cfg);

	if (!config_read_file(&cfg, config_path)) {
		config_destroy(&cfg);
		return CONFIG_FILE_READ_ERROR;
	}

	if (config_lookup_int(&cfg, "port", &(c->port))
		&& config_lookup_string(&cfg, "host", &(c->host))
		&& config_lookup_string(&cfg, "web_root", &(c->web_root))
		&& config_lookup_string(&cfg, "web_prefix", &(c->web_prefix))
		&& config_lookup_string(&cfg, "api_prefix", &(c->api_prefix))
		&& config_lookup_string(&cfg, "index_file", &(c->index_file))
		&& config_lookup_string(&cfg, "api_modules_path", &(c->api_modules_path))
		&& config_lookup_int(&cfg, "buffer_size", &(c->buffer_size))
		&& config_lookup_int(&cfg, "api_modules_number", &(c->api_modules_number))
	) {
		c->buffer = (char*) calloc((size_t) c->buffer_size, sizeof(char));

		/* Output a list of all movies in the inventory. */
		modules_setting = config_lookup(&cfg, "api_modules");
		if (modules_setting != NULL) {
			count = (unsigned int) config_setting_length(modules_setting);
			if (count != (unsigned int) c->api_modules_number)
				return CONFIG_INCONSISTENT_DATA;
			else if (count == 0)
				return CONFIG_FILE_READ_OK;

			c->api_modules_names = malloc(count * sizeof(char*));
			for (i = 0; i < count; ++i) {
				module_setting = config_setting_get_elem(modules_setting, i);
				module_name = config_setting_get_string(module_setting);

				c->api_modules_names[i] = module_name;
			}

			map_init(&c->api_modules, c->api_modules_number);
		}

		return CONFIG_FILE_READ_OK;
	}
	else
		return CONFIG_MISSING_KEY;
}

int readCfg (void)
{
	config_t cfg;
	config_init(&cfg);

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

	if (!config_lookup_int(&cfg, "onTemp", &onTemp))  printf("\nNo 'onTemp' setting in configuration file.");
	if (!config_lookup_int(&cfg, "offTemp", &offTemp)) printf("\nNo 'offTemp' setting in configuration file.");
	if (!config_lookup_int(&cfg, "highTemp", &highTemp)) printf("\nNo 'highTemp' setting in configuration file.");
	if (!config_lookup_int(&cfg, "onHum", &onHum)) printf("\nNo 'onHum' setting in configuration file.");
	if (!config_lookup_int(&cfg, "offHum", &offHum)) printf("\nNo 'offHum' setting in configuration file.");
	if (!config_lookup_int(&cfg, "webOR", &webOR)) printf("\nNo 'webOR' setting in configuration file.");
	if (!config_lookup_int(&cfg, "tempState", &tempState)) printf("\nNo 'tempState' setting in configuration file.");
	if (!config_lookup_int(&cfg, "humState", &humState)) printf("\nNo 'humState' setting in configuration file.");

	config_destroy(&cfg);

	return 0;
}

void get_conf_int (char *key, int *value) {
  config_t *conf = &(config_t) {};
  config_init (conf);
  config_read_file (conf, "TSECDecoder.conf");
  config_lookup_int(conf, key, value);
  config_destroy (conf);
}

int lamb_get_int(const config_t *cfg, const char *key, int *val) {
    if (!config_lookup_int(cfg, key, val)) {
        return -1;
    }

    return 0;
}

struct scenario_parameters read_scenario_parameters(char *scenario_file) {
  // configuration variable
  config_t cfg;
  config_init(&cfg);

  // string pointing to scenario file
  char scenario[100];
  strcpy(scenario, "scenarios/");
  strcat(scenario, scenario_file);

  // Read the file. If there is an error, report it and exit.
  if (!config_read_file(&cfg, scenario)) {
    printf("Error reading %s on line %i\n", scenario, config_error_line(&cfg));
    printf("%s\n", config_error_text(&cfg));
    config_destroy(&cfg);
    exit(1);
  }

  // Read scenario parameters
  struct scenario_parameters sp;
  int tmpI;
  double tmpD;

  config_lookup_int(&cfg, "num_nodes", &tmpI);
  sp.num_nodes = tmpI;
  config_lookup_float(&cfg, "run_time", &tmpD);
  sp.runTime = (time_t)tmpD;
  config_destroy(&cfg);

  return sp;
} // End readScConfigFile()

/**
 * Exit Sally tool. Close open files and free memory.
 */
static void sally_exit()
{
    int ehash;
    const char *cfg_str, *hash_file;

    info_msg(1, "Flushing. Closing input and output.");
    input_close();
    output_close();

    config_lookup_string(&cfg, "features.vect_embed", &cfg_str);
    if (!strcasecmp(cfg_str, "tfidf"))
        idf_destroy(input);

    config_lookup_string(&cfg, "input.stopword_file", &cfg_str);
    if (strlen(cfg_str) > 0)
        stopwords_destroy();

    config_lookup_string(&cfg, "features.hash_file", &hash_file);
    if (strlen(hash_file) > 0) {
        info_msg(1, "Saving explicit hash table to '%s'.", hash_file);    
        gzFile z = gzopen(hash_file, "w9");
        if (!z)
            error("Could not open hash file '%s'", hash_file);
        fhash_write(z);
        gzclose(z);
    }
    
    config_lookup_int(&cfg, "features.explicit_hash", &ehash);
    if (ehash || strlen(hash_file) > 0)
        fhash_destroy();

    /* Destroy configuration */
    config_destroy(&cfg);

}

/**
 * Initialize malheur tool
 * @param argc Number of arguments
 * @param argv Argument values
 */
static void malheur_init(int argc, char **argv)
{
    int lookup;
    double shared;

    /* Load configuration */
    load_config(argc, argv);

    /* Parse options */
    parse_options(argc, argv);

    /* Prepare malheur files */
    snprintf(mcfg.reject_file, MAX_PATH_LEN, "%s/%s", malheur_dir, REJECT_FILE);
    snprintf(mcfg.config_file, MAX_PATH_LEN,"%s/%s", malheur_dir, CONFIG_FILE);
    snprintf(mcfg.proto_file, MAX_PATH_LEN, "%s/%s", malheur_dir, PROTO_FILE);
    snprintf(mcfg.state_file, MAX_PATH_LEN, "%s/%s", malheur_dir, STATE_FILE);

    /* Init feature lookup table */
    config_lookup_int(&cfg, "features.lookup_table", &lookup);
    config_lookup_float(&cfg, "cluster.shared_ngrams", &shared);
    if (lookup || shared > 0.0) {
        ftable_init();
    }
    
    /* Reset current state */
    if (reset) {
        unlink(mcfg.reject_file);
        unlink(mcfg.proto_file);
        unlink(mcfg.state_file);
    }

    memset(&mstate, 0, sizeof(mstate));
}

/**
 * Internal: Allocates and extracts a feature vector from a string without
 * postprocessing and no blended n-grams.
 * @param x String of bytes (with space delimiters)
 * @param l Length of sequence
 * @param n N-gram length
 * @return feature vector
 */
fvec_t *fvec_extract_intern2(char *x, int l, int n)
{
    fvec_t *fv;
    int pos;
    cfg_int shift;
    const char *dlm_str;
    assert(x && l >= 0);

    /* Allocate feature vector */
    fv = calloc(1, sizeof(fvec_t));
    if (!fv) {
        error("Could not extract feature vector");
        return NULL;
    }

    /* Get configuration */
    config_lookup_string(&cfg, "features.ngram_delim", &dlm_str);
    config_lookup_bool(&cfg, "features.ngram_pos", &pos);
    config_lookup_int(&cfg, "features.pos_shift", &shift);

    /* Check for empty sequence */
    if (l == 0)
        return fv;

    /* Sanitize shift value */
    if (!pos)
        shift = 0;

    /* Allocate arrays */
    int space = 2 * shift + 1;
    fv->dim = (feat_t *) malloc(l * sizeof(feat_t) * space);
    fv->val = (float *) malloc(l * sizeof(float) * space);

    if (!fv->dim || !fv->val) {
        error("Could not allocate feature vector contents");
        fvec_destroy(fv);
        return NULL;
    }

    /* Get configuration */
    config_lookup_string(&cfg, "features.ngram_delim", &dlm_str);

    /* Loop over position shifts (0 if pos is disabled) */
    for (int s = -shift; s <= shift; s++) {
        if (!dlm_str || strlen(dlm_str) == 0) {
            extract_ngrams(fv, x, l, n, pos, s);
        } else {
            extract_wgrams(fv, x, l, n, pos, s);
        }
    }

    /* Sort extracted features */
    qsort(fv->dim, fv->len, sizeof(feat_t), cmp_feat);

    /* Count features  */
    count_feat(fv);

    return fv;
}

int init_config() 
{
    config_t cfg;
    config_init(&cfg);
    if (!config_read_file(&cfg, g_data.conf_path))
    {
        return -1;
    }
   
    const char* ip;
    if (!config_lookup_string(&cfg, "server.ip", &ip)) 
    {
        fprintf(stderr, "get server ip fail");
        return -1;
    }
    snprintf(g_data.server.ip, TINY_STR_LEN, "%s", ip);
    if (!config_lookup_int(&cfg, "server.port", &g_data.server.port))
    {
        fprintf(stderr, "get server port fail");
        return -1;
    }
    if (!config_lookup_int(&cfg, "server.port", &g_data.server.port))
    {
        fprintf(stderr, "get server port fail");
        return -1;
    }
    if (!config_lookup_int(&cfg, "thread_num", &g_data.thread_num))
    {
        fprintf(stderr, "get server port fail");
        g_data.thread_num = 0;
    }
    fprintf(stdout, "threadnum:%d\n", g_data.thread_num);

    if (!config_lookup_int(&cfg, "per_thread_loop_num", &g_data.per_thread_loop_num))
    {
        fprintf(stderr, "per_thread_loop_num error");
        g_data.per_thread_loop_num = 0;
    }
    fprintf(stdout, "per_thread_loop_num:%d\n", g_data.per_thread_loop_num);

    config_destroy(&cfg);
    printf("server:%s, %d\n", g_data.server.ip, g_data.server.port);
    return 0;
}

int read_stats_configuration(const char *filename, stats_options_t *options, shared_options_t *shared_options) {
    if (filename == NULL || options == NULL || shared_options == NULL) {
        return -1;
    }
    
    config_t *config = (config_t*) calloc (1, sizeof(config_t));
    int ret_code = config_read_file(config, filename);
    if (ret_code == CONFIG_FALSE) {
        LOG_ERROR_F("config file error: %s\n", config_error_text(config));
        return ret_code;
    }
    
    // Read number of threads that will make request to the web service
    ret_code = config_lookup_int(config, "vcf-tools.stats.num-threads", shared_options->num_threads->ival);
    if (ret_code == CONFIG_FALSE) {
        LOG_WARN("Number of threads not found in config file, must be set via command-line\n");
    } else {
        LOG_DEBUG_F("num-threads = %ld\n", *(shared_options->num_threads->ival));
    }

    // Read maximum number of batches that can be stored at certain moment
    ret_code = config_lookup_int(config, "vcf-tools.stats.max-batches", shared_options->max_batches->ival);
    if (ret_code == CONFIG_FALSE) {
        LOG_WARN("Maximum number of batches not found in configuration file, must be set via command-line\n");
    } else {
        LOG_DEBUG_F("max-batches = %ld\n", *(shared_options->max_batches->ival));
    }
    
    // Read size of every batch read
    ret_code = config_lookup_int(config, "vcf-tools.stats.batch-lines", shared_options->batch_lines->ival);
    ret_code |= config_lookup_int(config, "vcf-tools.stats.batch-bytes", shared_options->batch_bytes->ival);
    if (ret_code == CONFIG_FALSE) {
        LOG_WARN("Neither batch lines nor bytes found in configuration file, must be set via command-line\n");
    } 
    /*else {
        LOG_DEBUG_F("batch-lines = %ld\n", *(shared_options->batch_size->ival));
    }*/
    
    config_destroy(config);
    free(config);

    return 0;
}

/**
 * Main processing routine of Sally. This function processes chunks of
 * strings. It might be suitable for OpenMP support in a later version.
 */
static void sally_process()
{
    long read, i, j;
    int chunk;
    const char *hash_file;

    /* Check if a hash file is set */
    config_lookup_string(&cfg, "features.hash_file", &hash_file);

    /* Get chunk size */
    config_lookup_int(&cfg, "input.chunk_size", &chunk);

    /* Allocate space */
    fvec_t **fvec = malloc(sizeof(fvec_t *) * chunk);
    string_t *strs = malloc(sizeof(string_t) * chunk);

    if (!fvec || !strs)
        fatal("Could not allocate memory for embedding");

    info_msg(1, "Processing %d strings in chunks of %d.", entries, chunk);

    for (i = 0, read = 0; i < entries; i += read) {
        read = input_read(strs, chunk);
        if (read <= 0)
            fatal("Failed to read strings from input '%s'", input);

        /* Generic preprocessing of input */
        input_preproc(strs, read);

#ifdef ENABLE_OPENMP
#pragma omp parallel for
#endif
        for (j = 0; j < read; j++) {
            fvec[j] = fvec_extract(strs[j].str, strs[j].len);
            fvec_set_label(fvec[j], strs[j].label);
            fvec_set_source(fvec[j], strs[j].src);
        }

        if (!output_write(fvec, read))
            fatal("Failed to write vectors to output '%s'", output);

        /* Free memory */
        input_free(strs, read);
        output_free(fvec, read);

        /* Reset hash if enabled but no hash file is set */
        if (fhash_enabled() && !strlen(hash_file) > 0)
            fhash_reset();

        prog_bar(0, entries, i + read);
    }
    
    free(fvec);
    free(strs);
}

int read_tdt_configuration(const char *filename, tdt_options_t *tdt_options, shared_options_t *shared_options) {
    if (filename == NULL || tdt_options == NULL || shared_options == NULL) {
        return -1;
    }

    config_t *config = (config_t*) calloc (1, sizeof(config_t));
    int ret_code = config_read_file(config, filename);
    if (ret_code == CONFIG_FALSE) {
        LOG_ERROR_F("Configuration file error: %s\n", config_error_text(config));
        return CANT_READ_CONFIG_FILE;
    }

    const char *tmp_string;
    
    // Read number of threads that will make request to the web service
    ret_code = config_lookup_int(config, "gwas.tdt.num-threads", shared_options->num_threads->ival);
    if (ret_code == CONFIG_FALSE) {
        LOG_WARN("Number of threads not found in config file, must be set via command-line");
    } else {
        LOG_DEBUG_F("num-threads = %ld\n", *(shared_options->num_threads->ival));
    }

    // Read maximum number of batches that can be stored at certain moment
    ret_code = config_lookup_int(config, "gwas.tdt.max-batches", shared_options->max_batches->ival);
    if (ret_code == CONFIG_FALSE) {
        LOG_WARN("Maximum number of batches not found in configuration file, must be set via command-line");
    } else {
        LOG_DEBUG_F("max-batches = %ld\n", *(shared_options->max_batches->ival));
    }
    
    // Read size of a batch (in lines or bytes)
    ret_code = config_lookup_int(config, "gwas.tdt.batch-lines", shared_options->batch_lines->ival);
    ret_code |= config_lookup_int(config, "gwas.tdt.batch-bytes", shared_options->batch_bytes->ival);
    if (ret_code == CONFIG_FALSE) {
        LOG_WARN("Neither batch lines nor bytes found in configuration file, must be set via command-line");
    }
    
    config_destroy(config);
    free(config);

    return 0;
}

/* create default configuration file */
void
SWS_get_config()
{
	config_t cfg;

	config_init(&cfg);

	if (!config_read_file(&cfg, DEFAULT_FILE)) {
		SWS_log_fatal("%s", config_error_line(&cfg));		
	}		

	if (!config_lookup_int(&cfg, "SWS_port", &SWS_port)) {
		SWS_log_fatal("default configuration file has been changed,"
				"No port!");
	}
	if (!config_lookup_int(&cfg, "SWS_process_num", &SWS_process_num)) {
		SWS_log_fatal("default configuration file has been changed,"
				"No address!");
	}
	if (!config_lookup_int(&cfg, "SWS_request_header", &SWS_request_header)) {
		SWS_log_fatal("default configuration file has been changed,"
				"No url_length!");
	}
	if (!config_lookup_int(&cfg, "SWS_request_body", &SWS_request_body)) {
		SWS_log_fatal("default configuration file has been changed,"
				"No url_length!");
	}
	if (!config_lookup_string(&cfg, "SWS_address", &SWS_addr)) {
		SWS_log_fatal("default configuration file has been changed,"
				"No address!");
	}
	if (!config_lookup_string(&cfg, "SWS_error_log", &SWS_error_log)) {
		SWS_log_fatal("default configuration file has been changed,"
				"No error_log!");
	}
	if (!config_lookup_string(&cfg, "SWS_web_root", &SWS_web_root)) {
		SWS_log_fatal("default configuration file has been changed,"
				"No web_root!");
	}

	config_destroy(&cfg);
}

ModBusReader::ModBusReader(config_t cfg)
{
	if(!config_lookup_bool(&cfg, "main.debug", &this->debug)) {
		this->debug = false;
	}
	
	if(!config_lookup_string(&cfg, "reader.port", &this->_address)) {
		throw "Reader port is not defined";
	}
	if(!config_lookup_int(&cfg, "reader.baud_rate", &this->baud)) {
		baud = 115200;
	}
	if(!config_lookup_int(&cfg, "reader.slave_id", &this->slave_id)) {
		throw "Reader slave_id is not defined";
	}

	if(!config_lookup_int(&cfg, "reader.register_number", &this->register_number)) {
		throw "Reader register_number is not defined";
	}
}

/**
 * Initializes the similarity measure
 */
void kern_spectrum_config()
{
    const char *str;

    /* Length parameter */
    config_lookup_int(&cfg, "measures.kern_spectrum.length", &len);

    /* Normalization */
    config_lookup_string(&cfg, "measures.kern_spectrum.norm", &str);
    n = knorm_get(str);
}