void OBSBasic::on_actionRemoveProfile_triggered() { std::string newName; std::string newPath; ConfigFile config; std::string oldDir = config_get_string(App()->GlobalConfig(), "Basic", "ProfileDir"); std::string oldName = config_get_string(App()->GlobalConfig(), "Basic", "Profile"); auto cb = [&](const char *name, const char *filePath) { if (strcmp(oldName.c_str(), name) != 0) { newName = name; newPath = filePath; return false; } return true; }; EnumProfiles(cb); /* this should never be true due to menu item being grayed out */ if (newPath.empty()) return; QString text = QTStr("ConfirmRemove.Text"); text.replace("$1", QT_UTF8(oldName.c_str())); QMessageBox::StandardButton button = QMessageBox::question(this, QTStr("ConfirmRemove.Title"), text); if (button == QMessageBox::No) return; size_t newPath_len = newPath.size(); newPath += "/basic.ini"; if (config.Open(newPath.c_str(), CONFIG_OPEN_ALWAYS) != 0) { blog(LOG_ERROR, "ChangeProfile: Failed to load file '%s'", newPath.c_str()); return; } newPath.resize(newPath_len); const char *newDir = strrchr(newPath.c_str(), '/') + 1; config_set_string(App()->GlobalConfig(), "Basic", "Profile", newName.c_str()); config_set_string(App()->GlobalConfig(), "Basic", "ProfileDir", newDir); config.Swap(basicConfig); InitBasicConfigDefaults(); ResetProfileData(); DeleteProfile(oldName.c_str(), oldDir.c_str()); RefreshProfiles(); config_save_safe(App()->GlobalConfig(), "tmp", nullptr); blog(LOG_INFO, "Switched to profile '%s' (%s)", newName.c_str(), newDir); blog(LOG_INFO, "------------------------------------------------"); UpdateTitleBar(); if (api) { api->on_event(OBS_FRONTEND_EVENT_PROFILE_LIST_CHANGED); api->on_event(OBS_FRONTEND_EVENT_PROFILE_CHANGED); } }
/** * video_shader_write_conf_cgp: * @conf : Preset file to read from. * @shader : Shader passes handle. * * Saves preset and all associated state (passes, * textures, imports, etc) to disk. **/ void video_shader_write_conf_cgp(config_file_t *conf, struct video_shader *shader) { unsigned i; config_set_int(conf, "shaders", shader->passes); if (shader->feedback_pass >= 0) config_set_int(conf, "feedback_pass", shader->feedback_pass); for (i = 0; i < shader->passes; i++) { char key[64] = {0}; const struct video_shader_pass *pass = &shader->pass[i]; snprintf(key, sizeof(key), "shader%u", i); config_set_string(conf, key, pass->source.path); if (pass->filter != RARCH_FILTER_UNSPEC) { snprintf(key, sizeof(key), "filter_linear%u", i); config_set_bool(conf, key, pass->filter == RARCH_FILTER_LINEAR); } snprintf(key, sizeof(key), "wrap_mode%u", i); config_set_string(conf, key, wrap_mode_to_str(pass->wrap)); if (pass->frame_count_mod) { snprintf(key, sizeof(key), "frame_count_mod%u", i); config_set_int(conf, key, pass->frame_count_mod); } snprintf(key, sizeof(key), "mipmap_input%u", i); config_set_bool(conf, key, pass->mipmap); snprintf(key, sizeof(key), "alias%u", i); config_set_string(conf, key, pass->alias); shader_write_fbo(conf, &pass->fbo, i); } if (shader->num_parameters) { char parameters[4096] = {0}; strlcpy(parameters, shader->parameters[0].id, sizeof(parameters)); for (i = 1; i < shader->num_parameters; i++) { /* O(n^2), but number of parameters is very limited. */ strlcat(parameters, ";", sizeof(parameters)); strlcat(parameters, shader->parameters[i].id, sizeof(parameters)); } config_set_string(conf, "parameters", parameters); for (i = 0; i < shader->num_parameters; i++) config_set_float(conf, shader->parameters[i].id, shader->parameters[i].current); } if (shader->luts) { char textures[4096] = {0}; strlcpy(textures, shader->lut[0].id, sizeof(textures)); for (i = 1; i < shader->luts; i++) { /* O(n^2), but number of textures is very limited. */ strlcat(textures, ";", sizeof(textures)); strlcat(textures, shader->lut[i].id, sizeof(textures)); } config_set_string(conf, "textures", textures); for (i = 0; i < shader->luts; i++) { char key[64] = {0}; config_set_string(conf, shader->lut[i].id, shader->lut[i].path); if (shader->lut[i].filter != RARCH_FILTER_UNSPEC) { snprintf(key, sizeof(key), "%s_linear", shader->lut[i].id); config_set_bool(conf, key, shader->lut[i].filter == RARCH_FILTER_LINEAR); } snprintf(key, sizeof(key), "%s_wrap_mode", shader->lut[i].id); config_set_string(conf, key, wrap_mode_to_str(shader->lut[i].wrap)); snprintf(key, sizeof(key), "%s_mipmap", shader->lut[i].id); config_set_bool(conf, key, shader->lut[i].mipmap); } } if (*shader->script_path) config_set_string(conf, "import_script", shader->script_path); if (*shader->script_class) config_set_string(conf, "import_script_class", shader->script_class); if (shader->variables) { char variables[4096] = {0}; strlcpy(variables, shader->variable[0].id, sizeof(variables)); for (i = 1; i < shader->variables; i++) { strlcat(variables, ";", sizeof(variables)); strlcat(variables, shader->variable[i].id, sizeof(variables)); } config_set_string(conf, "imports", variables); for (i = 0; i < shader->variables; i++) shader_write_variable(conf, &shader->variable[i]); } }
static void get_binds(config_file_t *conf, config_file_t *auto_conf, int player, int joypad) { int i, timeout_cnt; const rarch_joypad_driver_t *driver = input_joypad_init_driver(g_driver); if (!driver) { fprintf(stderr, "Cannot find any valid input driver.\n"); exit(1); } if (!driver->query_pad(joypad)) { fprintf(stderr, "Couldn't open joystick #%u.\n", joypad); exit(1); } fprintf(stderr, "Found joypad driver: %s\n", driver->ident); const char *joypad_name = input_joypad_name(driver, joypad); fprintf(stderr, "Using joypad: %s\n", joypad_name ? joypad_name : "Unknown"); if (joypad_name && auto_conf) { config_set_string(auto_conf, "input_device", joypad_name); config_set_string(auto_conf, "input_driver", driver->ident); } int16_t initial_axes[MAX_AXES] = {0}; struct poll_data old_poll = {{0}}; struct poll_data new_poll = {{0}}; int last_axis = -1; bool block_axis = false; int timeout_ticks = g_timeout * 100; poll_joypad(driver, joypad, &old_poll); fprintf(stderr, "\nJoypads tend to have stale state after opened.\nPress some buttons and move some axes around to make sure joypad state is completely neutral before proceeding.\nWhen done, press Enter ... "); getchar(); poll_joypad(driver, joypad, &old_poll); for (i = 0; i < MAX_AXES; i++) { int16_t initial = input_joypad_axis_raw(driver, joypad, i); if (abs(initial) < 20000) initial = 0; // Certain joypads (such as XBox360 controller on Linux) has a default negative axis for shoulder triggers, // which makes configuration very awkward. // If default negative, we can't trigger on the negative axis, and similar with defaulted positive axes. if (initial) fprintf(stderr, "Axis %d is defaulted to %s axis value of %d.\n", i, initial > 0 ? "positive" : "negative", initial); initial_axes[i] = initial; } for (i = 0; i < MAX_BUTTONS; i++) { if (old_poll.buttons[i]) fprintf(stderr, "Button %d was initially pressed. This indicates broken initial state.\n", i); } fprintf(stderr, "Configuring binds for player #%d on joypad #%d.\n\n", player + 1, joypad); for (i = 0, timeout_cnt = 0; input_config_bind_map[i].valid; i++, timeout_cnt = 0) { int j; if (i == RARCH_TURBO_ENABLE) continue; unsigned meta_level = input_config_bind_map[i].meta; if (meta_level > g_meta_level) continue; fprintf(stderr, "%s\n", input_config_bind_map[i].desc); unsigned player_index = input_config_bind_map[i].meta ? 0 : player; for (;;) { old_poll = new_poll; // To avoid pegging CPU. // Ideally use an event-based joypad scheme, // but it adds far more complexity, so, meh. rarch_sleep(10); if (timeout_ticks) { timeout_cnt++; if (timeout_cnt >= timeout_ticks) { fprintf(stderr, "\tTimed out ...\n"); break; } } poll_joypad(driver, joypad, &new_poll); for (j = 0; j < MAX_BUTTONS; j++) { if (new_poll.buttons[j] && !old_poll.buttons[j]) { fprintf(stderr, "\tJoybutton pressed: %u\n", j); char key[64]; snprintf(key, sizeof(key), "%s_%s_btn", input_config_get_prefix(player_index, input_config_bind_map[i].meta), input_config_bind_map[i].base); config_set_int(conf, key, j); if (auto_conf) { snprintf(key, sizeof(key), "input_%s_btn", input_config_bind_map[i].base); config_set_int(auto_conf, key, j); } goto out; } } for (j = 0; j < MAX_AXES; j++) { if (new_poll.axes[j] == old_poll.axes[j]) continue; int16_t value = new_poll.axes[j]; bool same_axis = last_axis == j; bool require_negative = initial_axes[j] > 0; bool require_positive = initial_axes[j] < 0; // Block the axis config until we're sure axes have returned to their neutral state. if (same_axis) { if (abs(value) < 10000 || (require_positive && value < 0) || (require_negative && value > 0)) block_axis = false; } // If axes are in their neutral state, we can't allow it. if (require_negative && value >= 0) continue; if (require_positive && value <= 0) continue; if (block_axis) continue; if (abs(value) > 20000) { last_axis = j; fprintf(stderr, "\tJoyaxis moved: Axis %d, Value %d\n", j, value); char buf[8]; snprintf(buf, sizeof(buf), value > 0 ? "+%d" : "-%d", j); char key[64]; snprintf(key, sizeof(key), "%s_%s_axis", input_config_get_prefix(player_index, input_config_bind_map[i].meta), input_config_bind_map[i].base); config_set_string(conf, key, buf); if (auto_conf) { snprintf(key, sizeof(key), "input_%s_axis", input_config_bind_map[i].base); config_set_string(auto_conf, key, buf); } block_axis = true; goto out; } } for (j = 0; j < MAX_HATS; j++) { const char *quark = NULL; uint16_t value = new_poll.hats[j]; uint16_t old_value = old_poll.hats[j]; if ((value & HAT_UP_MASK) && !(old_value & HAT_UP_MASK)) quark = "up"; else if ((value & HAT_LEFT_MASK) && !(old_value & HAT_LEFT_MASK)) quark = "left"; else if ((value & HAT_RIGHT_MASK) && !(old_value & HAT_RIGHT_MASK)) quark = "right"; else if ((value & HAT_DOWN_MASK) && !(old_value & HAT_DOWN_MASK)) quark = "down"; if (quark) { fprintf(stderr, "\tJoyhat moved: Hat %d, direction %s\n", j, quark); char buf[16]; snprintf(buf, sizeof(buf), "h%d%s", j, quark); char key[64]; snprintf(key, sizeof(key), "%s_%s_btn", input_config_get_prefix(player_index, input_config_bind_map[i].meta), input_config_bind_map[i].base); config_set_string(conf, key, buf); if (auto_conf) { snprintf(key, sizeof(key), "input_%s_btn", input_config_bind_map[i].base); config_set_string(auto_conf, key, buf); } goto out; } } } out: old_poll = new_poll; } }
void config_set_stdstring(config_t* config, const char* section, const char* key, std::string val) { config_set_string(config, section, key, val.c_str()); }
void config_set_char(config_file_t *conf, const char *key, char val) { char buf[2] = {0}; snprintf(buf, sizeof(buf), "%c", val); config_set_string(conf, key, buf); }
void save_script_prefs() { GList* s; char path[PATH_MAX]; for (s = scripts; s; s = g_list_next(s)) { Script* script; GSList* optlist; script = g_datalist_get_data(&scriptdata, s->data); if (!script) { xqf_error("no data for script %s", s->data); continue; } snprintf(path, sizeof(path), "/" CONFIG_FILE "/scripts/%s", (char*)s->data); config_push_prefix(path); for (optlist = script->options; optlist; optlist = g_slist_next(optlist)) { ScriptOption* opt = optlist->data; const char* val = NULL; int enable = 0; switch(opt->type) { case SCRIPT_OPTION_TYPE_STRING: case SCRIPT_OPTION_TYPE_INT: case SCRIPT_OPTION_TYPE_LIST: val = gtk_entry_get_text(GTK_ENTRY(opt->widget)); if (!strlen(val)) { val = NULL; } if ((!val && opt->defval) || (val && !opt->defval) || (val && opt->defval && strcmp(opt->defval, val))) { g_free(opt->defval); debug(4, "set %s/%s=%s (before: %s)", s->data, opt->section, val, opt->defval); if (opt->type == SCRIPT_OPTION_TYPE_INT) { int tmp = val?atoi(val):0; config_set_int(opt->section, tmp); opt->defval = g_strdup_printf("%d", tmp); } else { config_set_string(opt->section, val?val:""); opt->defval = val?strdup(val):NULL; } } break; case SCRIPT_OPTION_TYPE_BOOL: enable = GTK_TOGGLE_BUTTON(opt->widget)->active; if (enable != opt->enable) { config_set_bool(opt->section, enable); debug(4, "set %s/%s=%d", s->data, opt->section, enable); opt->enable = enable; } break; case SCRIPT_OPTION_TYPE_INVALID: break; } } config_pop_prefix(); } }
static int ping_config (const char *key, const char *value) /* {{{ */ { if (strcasecmp (key, "Host") == 0) { hostlist_t *hl; char *host; hl = (hostlist_t *) malloc (sizeof (hostlist_t)); if (hl == NULL) { char errbuf[1024]; ERROR ("ping plugin: malloc failed: %s", sstrerror (errno, errbuf, sizeof (errbuf))); return (1); } host = strdup (value); if (host == NULL) { char errbuf[1024]; sfree (hl); ERROR ("ping plugin: strdup failed: %s", sstrerror (errno, errbuf, sizeof (errbuf))); return (1); } hl->host = host; hl->pkg_sent = 0; hl->pkg_recv = 0; hl->pkg_missed = 0; hl->latency_total = 0.0; hl->latency_squared = 0.0; hl->next = hostlist_head; hostlist_head = hl; } else if (strcasecmp (key, "SourceAddress") == 0) { int status = config_set_string (key, &ping_source, value); if (status != 0) return (status); } #ifdef HAVE_OPING_1_3 else if (strcasecmp (key, "Device") == 0) { int status = config_set_string (key, &ping_device, value); if (status != 0) return (status); } #endif else if (strcasecmp (key, "TTL") == 0) { int ttl = atoi (value); if ((ttl > 0) && (ttl <= 255)) ping_ttl = ttl; else WARNING ("ping plugin: Ignoring invalid TTL %i.", ttl); } else if (strcasecmp (key, "Interval") == 0) { double tmp; tmp = atof (value); if (tmp > 0.0) ping_interval = tmp; else WARNING ("ping plugin: Ignoring invalid interval %g (%s)", tmp, value); } else if (strcasecmp (key, "Size") == 0) { int size; if (ping_data != NULL) { free (ping_data); ping_data = NULL; } size = atoi (value); if ((size >= 0) && (size <= 65536)) { int i; ping_data = (char *) malloc(size + 1); if (ping_data == NULL) { char errbuf[1024]; ERROR ("ping plugin: malloc failed: %s", sstrerror (errno, errbuf, sizeof (errbuf))); return (1); } /* Note: By default oping is using constant string * "liboping -- ICMP ping library <http://octo.it/liboping/>" * which is exactly 56 bytes. * * Optimally we would follow the ping(1) behaviour, but we * cannot use byte 00 or start data payload at exactly same * location, due to oping library limitations. */ for (i = 0; i < size; i++) /* {{{ */ { /* This restricts data pattern to be only composed of easily * printable characters, and not NUL character. */ ping_data[i] = ('0' + i % 64); } /* }}} for (i = 0; i < size; i++) */ ping_data[size] = '\0'; } else WARNING ("ping plugin: Ignoring invalid Size %i.", size); } else if (strcasecmp (key, "Timeout") == 0) { double tmp; tmp = atof (value); if (tmp > 0.0) ping_timeout = tmp; else WARNING ("ping plugin: Ignoring invalid timeout %g (%s)", tmp, value); } else if (strcasecmp (key, "MaxMissed") == 0) { ping_max_missed = atoi (value); if (ping_max_missed < 0) INFO ("ping plugin: MaxMissed < 0, disabled re-resolving of hosts"); } else { return (-1); } return (0); } /* }}} int ping_config */
void config_set_int(config_file_t *conf, const char *key, int val) { char buf[128] = {0}; snprintf(buf, sizeof(buf), "%d", val); config_set_string(conf, key, buf); }
void config_parse( stream_t* stream, hash_t filter_section, bool overwrite ) { char* buffer; hash_t section = 0; hash_t key = 0; unsigned int line = 0; #if BUILD_ENABLE_DEBUG_CONFIG log_debugf( HASH_CONFIG, "Parsing config stream: %s", stream_path( stream ) ); #endif buffer = memory_allocate_zero( 1024ULL, 0, MEMORY_TEMPORARY ); while( !stream_eos( stream ) ) { ++line; stream_read_line_buffer( stream, buffer, 1024, '\n' ); string_strip( buffer, " \t\n\r" ); if( !string_length( buffer ) || ( buffer[0] == ';' ) || ( buffer[0] == '#' ) ) continue; if( buffer[0] == '[' ) { //Section declaration unsigned int endpos = string_rfind( buffer, ']', string_length( buffer ) - 1 ); if( ( endpos == STRING_NPOS ) || ( endpos < 1 ) ) { log_warnf( HASH_CONFIG, WARNING_BAD_DATA, "Invalid section declaration on line %d in config stream '%s'", line, stream_path( stream ) ); continue; } buffer[endpos] = 0; section = hash( buffer + 1, endpos - 1 ); #if BUILD_ENABLE_DEBUG_CONFIG log_debugf( HASH_CONFIG, " config: section set to '%s' (0x%llx)", buffer + 1, section ); #endif } else if( !filter_section || ( filter_section == section ) ) { //name=value declaration char* name; char* value; unsigned int separator = string_find( buffer, '=', 0 ); if( separator == STRING_NPOS ) { log_warnf( HASH_CONFIG, WARNING_BAD_DATA, "Invalid value declaration on line %d in config stream '%s', missing assignment operator '=': %s", line, stream_path( stream ), buffer ); continue; } name = string_strip_substr( buffer, " \t", separator ); value = string_strip( buffer + separator + 1, " \t" ); if( !string_length( name ) ) { log_warnf( HASH_CONFIG, WARNING_BAD_DATA, "Invalid value declaration on line %d in config stream '%s', empty name string", line, stream_path( stream ) ); continue; } key = hash( name, string_length( name ) ); if( overwrite || !config_key( section, key, false ) ) { #if BUILD_ENABLE_DEBUG_CONFIG log_debugf( HASH_CONFIG, " config: %s (0x%llx) = %s", name, key, value ); #endif if( !string_length( value ) ) config_set_string( section, key, "" ); else if( string_equal( value, "false" ) ) config_set_bool( section, key, false ); else if( string_equal( value, "true" ) ) config_set_bool( section, key, true ); else if( ( string_find( value, '.', 0 ) != STRING_NPOS ) && ( string_find_first_not_of( value, "0123456789.", 0 ) == STRING_NPOS ) && ( string_find( value, '.', string_find( value, '.', 0 ) + 1 ) == STRING_NPOS ) ) //Exactly one "." config_set_real( section, key, string_to_real( value ) ); else if( string_find_first_not_of( value, "0123456789", 0 ) == STRING_NPOS ) config_set_int( section, key, string_to_int64( value ) ); else config_set_string( section, key, value ); } } } memory_deallocate( buffer ); }
int main(int argc, char *argv[]) { const char *iface_name = NULL; char *config = NULL, *progname; int c, cnt, index, length, tmo = -1, batch_mode = 0, zero_datalen = 0; int ret = 0; char line[1024], *command = NULL, uds_local[MAX_IFNAME_SIZE + 1]; enum transport_type transport_type = TRANS_UDP_IPV4; UInteger8 boundary_hops = 1, domain_number = 0, transport_specific = 0; struct ptp_message *msg; struct option *opts; struct config *cfg; #define N_FD 2 struct pollfd pollfd[N_FD]; handle_term_signals(); cfg = config_create(); if (!cfg) { return -1; } opts = config_long_options(cfg); /* Process the command line arguments. */ progname = strrchr(argv[0], '/'); progname = progname ? 1+progname : argv[0]; while (EOF != (c = getopt_long(argc, argv, "246u""b:d:f:hi:s:t:vz", opts, &index))) { switch (c) { case 0: if (config_parse_option(cfg, opts[index].name, optarg)) { ret = -1; goto out; } break; case '2': if (config_set_int(cfg, "network_transport", TRANS_IEEE_802_3)) { ret = -1; goto out; } break; case '4': if (config_set_int(cfg, "network_transport", TRANS_UDP_IPV4)) { ret = -1; goto out; } break; case '6': if (config_set_int(cfg, "network_transport", TRANS_UDP_IPV6)) { ret = -1; goto out; } break; case 'u': if (config_set_int(cfg, "network_transport", TRANS_UDS)) { ret = -1; goto out; } break; case 'b': boundary_hops = atoi(optarg); break; case 'd': if (config_set_int(cfg, "domainNumber", atoi(optarg))) { ret = -1; goto out; } break; case 'f': config = optarg; break; case 'i': iface_name = optarg; break; case 's': if (strlen(optarg) > MAX_IFNAME_SIZE) { fprintf(stderr, "path %s too long, max is %d\n", optarg, MAX_IFNAME_SIZE); config_destroy(cfg); return -1; } if (config_set_string(cfg, "uds_address", optarg)) { config_destroy(cfg); return -1; } break; case 't': if (1 == sscanf(optarg, "%x", &c)) { if (config_set_int(cfg, "transportSpecific", c)) { ret = -1; goto out; } } break; case 'v': version_show(stdout); config_destroy(cfg); return 0; case 'z': zero_datalen = 1; break; case 'h': usage(progname); config_destroy(cfg); return 0; case '?': default: usage(progname); config_destroy(cfg); return -1; } } if (config && (c = config_read(config, cfg))) { config_destroy(cfg); return -1; } transport_type = config_get_int(cfg, NULL, "network_transport"); transport_specific = config_get_int(cfg, NULL, "transportSpecific") << 4; domain_number = config_get_int(cfg, NULL, "domainNumber"); if (!iface_name) { if (transport_type == TRANS_UDS) { snprintf(uds_local, sizeof(uds_local), "/var/run/pmc.%d", getpid()); iface_name = uds_local; } else { iface_name = "eth0"; } } if (optind < argc) { batch_mode = 1; } print_set_progname(progname); print_set_syslog(1); print_set_verbose(1); pmc = pmc_create(cfg, transport_type, iface_name, boundary_hops, domain_number, transport_specific, zero_datalen); if (!pmc) { fprintf(stderr, "failed to create pmc\n"); config_destroy(cfg); return -1; } pollfd[0].fd = batch_mode ? -1 : STDIN_FILENO; pollfd[1].fd = pmc_get_transport_fd(pmc); while (is_running()) { if (batch_mode && !command) { if (optind < argc) { command = argv[optind++]; } else { /* No more commands, wait a bit for any outstanding replies and exit. */ tmo = 100; } } pollfd[0].events = 0; pollfd[1].events = POLLIN | POLLPRI; if (!batch_mode && !command) pollfd[0].events |= POLLIN | POLLPRI; if (command) pollfd[1].events |= POLLOUT; cnt = poll(pollfd, N_FD, tmo); if (cnt < 0) { if (EINTR == errno) { continue; } else { pr_emerg("poll failed"); ret = -1; break; } } else if (!cnt) { break; } if (pollfd[0].revents & POLLHUP) { if (tmo == -1) { /* Wait a bit longer for outstanding replies. */ tmo = 100; pollfd[0].fd = -1; pollfd[0].events = 0; } else { break; } } if (pollfd[0].revents & (POLLIN|POLLPRI)) { if (!fgets(line, sizeof(line), stdin)) { break; } length = strlen(line); if (length < 2) { continue; } line[length - 1] = 0; command = line; } if (pollfd[1].revents & POLLOUT) { if (pmc_do_command(pmc, command)) { fprintf(stderr, "bad command: %s\n", command); } command = NULL; } if (pollfd[1].revents & (POLLIN|POLLPRI)) { msg = pmc_recv(pmc); if (msg) { pmc_show(msg, stdout); msg_put(msg); } } } pmc_destroy(pmc); msg_cleanup(); out: config_destroy(cfg); return ret; }
int rc_parse (void) { char *fn; struct keyword *kw; fn = file_in_dir (user_rcdir, RC_FILE); rc_open (fn); g_free (fn); if(!rc) return -1; while ((token = rc_next_token ()) != TOKEN_EOF) { switch (token) { case TOKEN_KEYWORD: for (kw = keywords; kw->name; kw++) { if (strcmp (token_str, kw->name) == 0) { switch (kw->required) { case KEYWORD_INT: if (rc_expect_token (TOKEN_INT)) config_set_int (kw->config, token_int); break; case KEYWORD_BOOL: if (rc_expect_token (TOKEN_INT)) config_set_bool (kw->config, token_int); break; case KEYWORD_STRING: if (rc_expect_token (TOKEN_STRING)) config_set_string (kw->config, token_str); break; } break; } } break; case TOKEN_EOL: case TOKEN_EOF: break; default: syntax_error (); rc_skip_to_eol (); break; } /* switch */ } /* while */ rc_close (); /* Compatibility with old versions */ if (!games[Q1_SERVER].dir && games[QW_SERVER].dir) { games[Q1_SERVER].dir = g_strdup (games[QW_SERVER].dir); config_set_string ("/" CONFIG_FILE "/Game: QS/dir", games[Q1_SERVER].dir); } if (default_w_switch < 0) default_w_switch = 0; if (default_b_switch < 0) default_b_switch = 0; return 0; }
void menu_cb(GtkWidget *w, gint info) { char command[PATH_MAX+32]; /* we should malloc this */ GtkWidget *filew; GtkWidget *dialog; switch(info) { case 1: cardtree_delete(CARDTREE,NULL); RUN_LUA_COMMAND("card.CLA=0"); log_printf(LOG_INFO,"Cleared card data tree"); break; case 2: filew = gtk_file_chooser_dialog_new ("Open File", NULL, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filew), config_get_string(CONFIG_PATH_OPEN_SAVE)); if (gtk_dialog_run (GTK_DIALOG (filew)) == GTK_RESPONSE_ACCEPT) { char *filename; filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (filew)); sprintf(command,"ui.tree_load('%s')",filename); RUN_LUA_COMMAND(command); g_free (filename); filename = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER (filew)); config_set_string(CONFIG_PATH_OPEN_SAVE,filename); g_free(filename); } gtk_widget_destroy (filew); break; case 3: filew = gtk_file_chooser_dialog_new ("Save File", NULL, GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (filew), TRUE); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filew), config_get_string(CONFIG_PATH_OPEN_SAVE)); gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filew), "card.xml"); if (gtk_dialog_run (GTK_DIALOG (filew)) == GTK_RESPONSE_ACCEPT) { char *filename; filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (filew)); sprintf(command,"ui.tree_save('%s')",filename); RUN_LUA_COMMAND(command); g_free (filename); filename = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER (filew)); config_set_string(CONFIG_PATH_OPEN_SAVE,filename); g_free(filename); } gtk_widget_destroy (filew); break; case 4: filew = gtk_file_chooser_dialog_new ("Load script", NULL, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filew), config_get_string(CONFIG_PATH_LOAD_SCRIPT)); if (gtk_dialog_run (GTK_DIALOG (filew)) == GTK_RESPONSE_ACCEPT) { char *filename; filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (filew)); RUN_LUA_SCRIPT(filename); g_free (filename); filename = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER (filew)); config_set_string(CONFIG_PATH_LOAD_SCRIPT,filename); g_free(filename); } gtk_widget_destroy (filew); break; case 11: RUN_LUA_COMMAND("card.connect()"); break; case 12: RUN_LUA_COMMAND("card.warm_reset()"); break; case 13: RUN_LUA_COMMAND("card.disconnect()"); break; case 99: dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, "%s", "cardpeek, version 0.1\nCopyright 2009, by 'L1L1'\nLicenced under the GPL 3"); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); default: log_printf(LOG_INFO,"menu option : %i",info); } }
void config_set_float(config_file_t *conf, const char *key, float val) { char buf[128]; snprintf(buf, sizeof(buf), "%f", val); config_set_string(conf, key, buf); }
/** * Parse command line options * @param argc Number of arguments * @param argv Argument values */ static void parse_options(int argc, char **argv) { int ch; /* reset getopt */ optind = 0; while ((ch = getopt_long(argc, argv, OPTSTRING, longopts, NULL)) != -1) { switch (ch) { case 'n': save = FALSE; break; case 'r': reset = TRUE; break; case 'v': case 'm': /* Empty. See load_config() */ break; case 'o': output_file = optarg; break; case 'V': malheur_version(stdout); exit(EXIT_SUCCESS); break; case 'h': case '?': print_usage(); exit(EXIT_SUCCESS); break; /* long options */ case 1001: config_set_string(&cfg, "input.format", optarg); break; case 1002: config_set_int(&cfg, "input.mist_level", atoi(optarg)); break; case 1003: config_set_int(&cfg, "input.mist_rlen", atoi(optarg)); break; case 1004: config_set_int(&cfg, "input.mist_tlen", atoi(optarg)); break; case 1005: config_set_string(&cfg, "features.ngram_delim", optarg); break; case 1006: config_set_int(&cfg, "features.ngram_len", atoi(optarg)); break; case 1007: config_set_string(&cfg, "features.vect_embed", optarg); break; case 1008: config_set_int(&cfg, "features.lookup_table", atoi(optarg)); break; case 1009: config_set_float(&cfg, "prototypes.max_dist", atof(optarg)); break; case 1010: config_set_int(&cfg, "prototypes.max_num", atoi(optarg)); break; case 1011: config_set_float(&cfg, "classify.max_dist", atof(optarg)); break; case 1012: config_set_string(&cfg, "cluster.link_mode", optarg); break; case 1013: config_set_float(&cfg, "cluster.min_dist", atof(optarg)); break; case 1014: config_set_int(&cfg, "cluster.reject_num", atoi(optarg)); break; case 1015: config_set_int(&cfg, "cluster.shared_ngrams", atoi(optarg)); break; } } /* Check configuration */ config_check(&cfg); argc -= optind; argv += optind; if (argc < 1) fatal("the <action> argument is required"); /* Argument: action */ if (!strcasecmp(argv[0], "prototype")) { action = PROTOTYPE; } else if (!strcasecmp(argv[0], "distance")) { action = DISTANCE; } else if (!strcasecmp(argv[0], "cluster")) { action = CLUSTER; } else if (!strcasecmp(argv[0], "classify")) { action = CLASSIFY; } else if (!strcasecmp(argv[0], "increment")) { action = INCREMENT; } else if (!strcasecmp(argv[0], "protodist")) { action = PROTODIST; } else if (!strcasecmp(argv[0], "info")) { action = INFO; } else { fatal("Unknown analysis action '%s'", argv[0]); } if (argc < 2 && action != PROTODIST && action != INFO) fatal("the <dataset> argument is required"); /* Assign input files */ input_files = argv + 1; input_len = argc - 1; }
static void frontend_xdk_salamander_init(void) { XINPUT_STATE state; (void)state; //WIP - no Xbox 1 controller input yet #ifdef _XBOX360 XInputGetState(0, &state); if(state.Gamepad.wButtons & XINPUT_GAMEPAD_Y) { //override path, boot first executable in cores directory RARCH_LOG("Fallback - Will boot first executable in RetroArch cores directory.\n"); find_and_set_first_file(); } else #endif { //normal executable loading path char tmp_str[PATH_MAX]; bool config_file_exists = false; if(path_file_exists(config_path)) config_file_exists = true; //try to find CORE executable char core_executable[1024]; #if defined(_XBOX360) strlcpy(core_executable, "game:\\CORE.xex", sizeof(core_executable)); #elif defined(_XBOX1) fill_pathname_join(core_executable, "D:", "CORE.xbe", sizeof(core_executable)); #endif if(path_file_exists(core_executable)) { //Start CORE executable strlcpy(libretro_path, core_executable, sizeof(libretro_path)); RARCH_LOG("Start [%s].\n", libretro_path); } else { if(config_file_exists) { config_file_t * conf = config_file_new(config_path); config_get_array(conf, "libretro_path", tmp_str, sizeof(tmp_str)); strlcpy(libretro_path, tmp_str, sizeof(libretro_path)); } if(!config_file_exists || !strcmp(libretro_path, "")) { find_and_set_first_file(); } else { RARCH_LOG("Start [%s] found in retroarch.cfg.\n", libretro_path); } if (!config_file_exists) { config_file_t *new_conf = config_file_new(NULL); config_set_string(new_conf, "libretro_path", libretro_path); config_file_write(new_conf, config_path); config_file_free(new_conf); } } } }
static int config_add (oconfig_item_t *ci) { apache_t *st; int i; int status; if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) { WARNING ("apache plugin: The `%s' config option " "needs exactly one string argument.", ci->key); return (-1); } st = (apache_t *) malloc (sizeof (*st)); if (st == NULL) { ERROR ("apache plugin: malloc failed."); return (-1); } memset (st, 0, sizeof (*st)); status = config_set_string (&st->name, ci); if (status != 0) { sfree (st); return (status); } assert (st->name != NULL); for (i = 0; i < ci->children_num; i++) { oconfig_item_t *child = ci->children + i; if (strcasecmp ("URL", child->key) == 0) status = config_set_string (&st->url, child); else if (strcasecmp ("Host", child->key) == 0) status = config_set_string (&st->host, child); else if (strcasecmp ("User", child->key) == 0) status = config_set_string (&st->user, child); else if (strcasecmp ("Password", child->key) == 0) status = config_set_string (&st->pass, child); else if (strcasecmp ("VerifyPeer", child->key) == 0) status = config_set_boolean (&st->verify_peer, child); else if (strcasecmp ("VerifyHost", child->key) == 0) status = config_set_boolean (&st->verify_host, child); else if (strcasecmp ("CACert", child->key) == 0) status = config_set_string (&st->cacert, child); else if (strcasecmp ("Server", child->key) == 0) status = config_set_string (&st->server, child); else { WARNING ("apache plugin: Option `%s' not allowed here.", child->key); status = -1; } if (status != 0) break; } /* Check if struct is complete.. */ if ((status == 0) && (st->url == NULL)) { ERROR ("apache plugin: Instance `%s': " "No URL has been configured.", st->name); status = -1; } if (status == 0) { user_data_t ud; char callback_name[3*DATA_MAX_NAME_LEN]; memset (&ud, 0, sizeof (ud)); ud.data = st; ud.free_func = (void *) apache_free; memset (callback_name, 0, sizeof (callback_name)); ssnprintf (callback_name, sizeof (callback_name), "apache/%s/%s", (st->host != NULL) ? st->host : hostname_g, (st->name != NULL) ? st->name : "default"), status = plugin_register_complex_read (/* group = */ NULL, /* name = */ callback_name, /* callback = */ apache_read_host, /* interval = */ NULL, /* user_data = */ &ud); } if (status != 0) { apache_free(st); return (-1); } return (0); } /* int config_add */
static void config_parse(nvs_handle fp, config_t *config) { assert(fp != 0); assert(config != NULL); esp_err_t err; int line_num = 0; int err_code = 0; uint16_t i = 0; size_t length = CONFIG_FILE_DEFAULE_LENGTH; size_t total_length = 0; char *line = osi_calloc(1024); char *section = osi_calloc(1024); char *keyname = osi_calloc(sizeof(CONFIG_KEY) + 1); int buf_size = get_config_size_from_flash(fp); char *buf = osi_calloc(buf_size + 100); if (!line || !section || !buf || !keyname) { err_code |= 0x01; goto error; } snprintf(keyname, sizeof(CONFIG_KEY)+1, "%s%d", CONFIG_KEY, 0); err = nvs_get_blob(fp, keyname, buf, &length); if (err == ESP_ERR_NVS_NOT_FOUND) { goto error; } if (err != ESP_OK) { err_code |= 0x02; goto error; } total_length += length; while (length == CONFIG_FILE_MAX_SIZE) { length = CONFIG_FILE_DEFAULE_LENGTH; snprintf(keyname, sizeof(CONFIG_KEY) + 1, "%s%d", CONFIG_KEY, ++i); err = nvs_get_blob(fp, keyname, buf + CONFIG_FILE_MAX_SIZE * i, &length); if (err == ESP_ERR_NVS_NOT_FOUND) { break; } if (err != ESP_OK) { err_code |= 0x02; goto error; } total_length += length; } char *p_line_end; char *p_line_bgn = buf; strcpy(section, CONFIG_DEFAULT_SECTION); while ( (p_line_bgn < buf + total_length - 1) && (p_line_end = strchr(p_line_bgn, '\n'))) { // get one line int line_len = p_line_end - p_line_bgn; if (line_len > 1023) { LOG_WARN("%s exceed max line length on line %d.\n", __func__, line_num); break; } memcpy(line, p_line_bgn, line_len); line[line_len] = '\0'; p_line_bgn = p_line_end + 1; char *line_ptr = trim(line); ++line_num; // Skip blank and comment lines. if (*line_ptr == '\0' || *line_ptr == '#') { continue; } if (*line_ptr == '[') { size_t len = strlen(line_ptr); if (line_ptr[len - 1] != ']') { LOG_WARN("%s unterminated section name on line %d.\n", __func__, line_num); continue; } strncpy(section, line_ptr + 1, len - 2); section[len - 2] = '\0'; } else { char *split = strchr(line_ptr, '='); if (!split) { LOG_DEBUG("%s no key/value separator found on line %d.\n", __func__, line_num); continue; } *split = '\0'; config_set_string(config, section, trim(line_ptr), trim(split + 1), true); } } error: if (buf) { osi_free(buf); } if (line) { osi_free(line); } if (section) { osi_free(section); } if (keyname) { osi_free(keyname); } if (err_code) { LOG_ERROR("%s returned with err code: %d\n", __func__, err_code); } }
void config_set_hex(config_file_t *conf, const char *key, unsigned val) { char buf[128] = {0}; snprintf(buf, sizeof(buf), "%x", val); config_set_string(conf, key, buf); }
static void get_binds(config_file_t *conf, int player, int joypad) { const rarch_joypad_driver_t *driver = input_joypad_init_first(); if (!driver) { fprintf(stderr, "Cannot find any valid input driver.\n"); exit(1); } if (!driver->query_pad(joypad)) { fprintf(stderr, "Couldn't open joystick #%u.\n", joypad); exit(1); } fprintf(stderr, "Found joypad driver: %s\n", driver->ident); int16_t initial_axes[MAX_AXES] = {0}; struct poll_data old_poll = {{0}}; struct poll_data new_poll = {{0}}; int last_axis = -1; bool block_axis = false; poll_joypad(driver, joypad, &old_poll); for (int i = 0; i < MAX_AXES; i++) { int16_t initial = input_joypad_axis_raw(driver, joypad, i); if (abs(initial) < 20000) initial = 0; // Certain joypads (such as XBox360 controller on Linux) has a default negative axis for shoulder triggers, // which makes configuration very awkward. // If default negative, we can't trigger on the negative axis, and similar with defaulted positive axes. if (initial) fprintf(stderr, "Axis %d is defaulted to %s axis value of %d\n", i, initial > 0 ? "positive" : "negative", initial); initial_axes[i] = initial; } fprintf(stderr, "Configuring binds for player #%d on joypad #%d.\n\n", player + 1, joypad); for (unsigned i = 0; i < sizeof(binds) / sizeof(binds[0]) && (g_use_misc || !binds[i].is_misc) ; i++) { fprintf(stderr, "%s\n", binds[i].keystr); unsigned player_index = binds[i].is_misc ? 0 : player; for (;;) { old_poll = new_poll; // To avoid pegging CPU. // Ideally use an event-based joypad scheme, // but it adds far more complexity, so, meh. rarch_sleep(10); poll_joypad(driver, joypad, &new_poll); for (int j = 0; j < MAX_BUTTONS; j++) { if (new_poll.buttons[j] && !old_poll.buttons[j]) { fprintf(stderr, "\tJoybutton pressed: %u\n", j); config_set_int(conf, binds[i].confbtn[player_index], j); goto out; } } for (int j = 0; j < MAX_AXES; j++) { if (new_poll.axes[j] != old_poll.axes[j]) { int16_t value = new_poll.axes[j]; bool same_axis = last_axis == j; bool require_negative = initial_axes[j] > 0; bool require_positive = initial_axes[j] < 0; // Block the axis config until we're sure axes have returned to their neutral state. if (same_axis) { if (abs(value) < 10000 || (require_positive && value < 0) || (require_negative && value > 0)) block_axis = false; } // If axes are in their neutral state, we can't allow it. if (require_negative && value >= 0) continue; if (require_positive && value <= 0) continue; if (block_axis) continue; if (abs(value) > 20000) { last_axis = j; fprintf(stderr, "\tJoyaxis moved: Axis %d, Value %d\n", j, value); char buf[8]; snprintf(buf, sizeof(buf), value > 0 ? "+%d" : "-%d", j); config_set_string(conf, binds[i].confaxis[player_index], buf); block_axis = true; goto out; } } } for (int j = 0; j < MAX_HATS; j++) { const char *quark = NULL; uint16_t value = new_poll.hats[j]; uint16_t old_value = old_poll.hats[j]; if ((value & HAT_UP_MASK) && !(old_value & HAT_UP_MASK)) quark = "up"; else if ((value & HAT_LEFT_MASK) && !(old_value & HAT_LEFT_MASK)) quark = "left"; else if ((value & HAT_RIGHT_MASK) && !(old_value & HAT_RIGHT_MASK)) quark = "right"; else if ((value & HAT_DOWN_MASK) && !(old_value & HAT_DOWN_MASK)) quark = "down"; if (quark) { fprintf(stderr, "\tJoyhat moved: Hat %d, direction %s\n", j, quark); char buf[16]; snprintf(buf, sizeof(buf), "h%d%s", j, quark); config_set_string(conf, binds[i].confbtn[player_index], buf); goto out; } } } out: old_poll = new_poll; } }
void config_set_bool(config_file_t *conf, const char *key, bool val) { config_set_string(conf, key, val ? "true" : "false"); }
void rarch_config_save(const char * conf_name) { config_file_t * conf = config_file_new(conf_name); if(!conf) { RARCH_ERR("Failed to write config file to \"%s\". Check permissions.\n", conf_name); return; } // g_settings config_set_string(conf, "libretro_path", g_settings.libretro); #ifdef HAVE_XML config_set_string(conf, "cheat_database_path", g_settings.cheat_database); #endif config_set_bool(conf, "rewind_enable", g_settings.rewind_enable); config_set_string(conf, "video_cg_shader", g_settings.video.cg_shader_path); config_set_float(conf, "video_aspect_ratio", g_settings.video.aspect_ratio); #ifdef HAVE_FBO config_set_float(conf, "video_fbo_scale_x", g_settings.video.fbo.scale_x); config_set_float(conf, "video_fbo_scale_y", g_settings.video.fbo.scale_y); config_set_string(conf, "video_second_pass_shader", g_settings.video.second_pass_shader); config_set_bool(conf, "video_render_to_texture", g_settings.video.render_to_texture); config_set_bool(conf, "video_second_pass_smooth", g_settings.video.second_pass_smooth); config_set_bool(conf, "fbo_enabled", g_settings.video.fbo.enable); #endif config_set_bool(conf, "video_smooth", g_settings.video.smooth); config_set_bool(conf, "video_vsync", g_settings.video.vsync); config_set_int(conf, "aspect_ratio_index", g_settings.video.aspect_ratio_idx); config_set_int(conf, "color_format", g_settings.video.color_format); config_set_string(conf, "audio_device", g_settings.audio.device); config_set_bool(conf, "audio_rate_control", g_settings.audio.rate_control); config_set_float(conf, "audio_rate_control_delta", g_settings.audio.rate_control_delta); for (unsigned i = 0; i < 7; i++) { char cfg[64]; snprintf(cfg, sizeof(cfg), "input_dpad_emulation_p%u", i + 1); config_set_int(conf, cfg, g_settings.input.dpad_emulation[i]); snprintf(cfg, sizeof(cfg), "input_device_p%u", i + 1); config_set_int(conf, cfg, g_settings.input.device[i]); } config_set_bool(conf, "overscan_enable", g_extern.console.screen.state.overscan.enable); config_set_bool(conf, "screenshots_enable", g_extern.console.screen.state.screenshots.enable); config_set_bool(conf, "gamma_correction", g_extern.console.screen.gamma_correction); #ifdef _XBOX1 config_set_int(conf, "flicker_filter", g_extern.console.screen.state.flicker_filter.value); config_set_int(conf, "sound_volume_level", g_extern.console.sound.volume_level); #endif config_set_bool(conf, "throttle_enable", g_extern.console.screen.state.throttle.enable); config_set_bool(conf, "triple_buffering_enable", g_extern.console.screen.state.triple_buffering.enable); config_set_bool(conf, "info_msg_enable", g_extern.console.rmenu.state.msg_info.enable); config_set_int(conf, "current_resolution_id", g_extern.console.screen.resolutions.current.id); config_set_int(conf, "custom_viewport_width", g_extern.console.screen.viewports.custom_vp.width); config_set_int(conf, "custom_viewport_height", g_extern.console.screen.viewports.custom_vp.height); config_set_int(conf, "custom_viewport_x", g_extern.console.screen.viewports.custom_vp.x); config_set_int(conf, "custom_viewport_y", g_extern.console.screen.viewports.custom_vp.y); config_set_string(conf, "default_rom_startup_dir", g_extern.console.main_wrap.paths.default_rom_startup_dir); config_set_float(conf, "menu_font_size", g_extern.console.rmenu.font_size); config_set_float(conf, "overscan_amount", g_extern.console.screen.overscan_amount); #ifdef HAVE_ZLIB config_set_int(conf, "zip_extract_mode", g_extern.file_state.zip_extract_mode); #endif // g_extern config_set_int(conf, "sound_mode", g_extern.console.sound.mode); config_set_int(conf, "state_slot", g_extern.state_slot); config_set_int(conf, "audio_mute", g_extern.audio_data.mute); config_set_bool(conf, "soft_display_filter_enable", g_extern.console.screen.state.soft_filter.enable); config_set_int(conf, "screen_orientation", g_extern.console.screen.orientation); config_set_bool(conf, "custom_bgm_enable", g_extern.console.sound.custom_bgm.enable); if (!config_file_write(conf, conf_name)) RARCH_ERR("Failed to write config file to \"%s\". Check permissions.\n", conf_name); free(conf); }
int config_load(char *filename){ FILE *f=fopen(filename,"r"); char key[80]; int bank,A,B,C,width,rev; int errflag=0; fprintf(stderr,"Loading state configuration file %s... ",filename); sprintf(key,"[file beginning]"); if(!f){ fprintf(stderr,"No config file %s; will be created on save/exit.\n",filename); return 0; } /* search for magic */ if(fscanf(f,"Postfish rev %d",&rev)!=1 || rev!=2){ fprintf(stderr,"File %s is not a postfish state configuration file.\n",filename); fclose(f); return -1; } /* load file */ while(!feof(f)){ int c=fgetc(f); switch(c){ case '(': /* string type input */ if (fscanf(f,"%79s bank%d A%d B%d C%d l%d \"", key,&bank,&A,&B,&C,&width)==6){ char *buffer=calloc(width+1,sizeof(*buffer)); for(c=0;c<width;c++)buffer[c]=fgetc(f); config_set_string(key,bank,A,B,C,buffer); free(buffer); fscanf(f,"\" )"); errflag=0; }else{ if(!errflag){ fprintf(stderr,"Configuration file parse error after %s\n",key); errflag=1; } } break; case '[': /* vector type input */ if (fscanf(f,"%79s bank%d A%d B%d C%d v%d \"", key,&bank,&A,&B,&C,&width)==6){ int *vec=calloc(width,sizeof(*vec)); for(c=0;c<width;c++){ if(fscanf(f,"%d",vec+c)!=1){ if(!errflag){ fprintf(stderr,"Configuration file parse error after %s\n",key); errflag=1; break; } } } fscanf(f," ]"); config_set_vector(key,bank,A,B,C,width,vec); free(vec); errflag=0; }else{ if(!errflag){ fprintf(stderr,"Configuration file parse error after %s\n",key); errflag=1; } } break; default: /* whitespace OK, other characters indicate a parse error */ if(!isspace(c) && !errflag && c!=EOF){ fprintf(stderr,"Configuration file parse error after %s\n",key); errflag=1; } break; } } fclose(f); fprintf(stderr,"done.\n"); return 0; }
bool OBSBasic::AddProfile(bool create_new, const char *title, const char *text, const char *init_text) { std::string newName; std::string newDir; ConfigFile config; if (!GetProfileName(this, newName, newDir, title, text, init_text)) return false; std::string curDir = config_get_string(App()->GlobalConfig(), "Basic", "ProfileDir"); char newPath[512]; int ret = GetConfigPath(newPath, 512, "obs-studio/basic/profiles/"); if (ret <= 0) { blog(LOG_WARNING, "Failed to get profiles config path"); return false; } strcat(newPath, newDir.c_str()); if (os_mkdir(newPath) < 0) { blog(LOG_WARNING, "Failed to create profile directory '%s'", newDir.c_str()); return false; } if (!create_new) CopyProfile(curDir.c_str(), newPath); strcat(newPath, "/basic.ini"); if (config.Open(newPath, CONFIG_OPEN_ALWAYS) != 0) { blog(LOG_ERROR, "Failed to open new config file '%s'", newDir.c_str()); return false; } config_set_string(App()->GlobalConfig(), "Basic", "Profile", newName.c_str()); config_set_string(App()->GlobalConfig(), "Basic", "ProfileDir", newDir.c_str()); config_set_string(config, "General", "Name", newName.c_str()); config.SaveSafe("tmp"); config.Swap(basicConfig); InitBasicConfigDefaults(); RefreshProfiles(); if (create_new) ResetProfileData(); blog(LOG_INFO, "Created profile '%s' (%s, %s)", newName.c_str(), create_new ? "clean" : "duplicate", newDir.c_str()); blog(LOG_INFO, "------------------------------------------------"); config_save_safe(App()->GlobalConfig(), "tmp", nullptr); UpdateTitleBar(); if (api) { api->on_event(OBS_FRONTEND_EVENT_PROFILE_LIST_CHANGED); api->on_event(OBS_FRONTEND_EVENT_PROFILE_CHANGED); } return true; }
void config_set_double(config_file_t *conf, const char *key, double val) { char buf[128]; snprintf(buf, sizeof(buf), "%lf", val); config_set_string(conf, key, buf); }
/** * video_shader_write_conf_cgp: * @conf : Preset file to read from. * @shader : Shader passes handle. * * Saves preset and all associated state (passes, * textures, imports, etc) to disk. **/ void video_shader_write_conf_cgp(config_file_t *conf, struct video_shader *shader) { unsigned i; config_set_int(conf, "shaders", shader->passes); if (shader->feedback_pass >= 0) config_set_int(conf, "feedback_pass", shader->feedback_pass); for (i = 0; i < shader->passes; i++) { char key[64]; size_t tmp_size = PATH_MAX_LENGTH * sizeof(char); char *tmp = (char*)malloc(PATH_MAX_LENGTH * sizeof(char)); const struct video_shader_pass *pass = &shader->pass[i]; key[0] = '\0'; snprintf(key, sizeof(key), "shader%u", i); strlcpy(tmp, pass->source.path, tmp_size); if (!path_is_absolute(tmp)) path_resolve_realpath(tmp, tmp_size); config_set_string(conf, key, tmp); free(tmp); if (pass->filter != RARCH_FILTER_UNSPEC) { snprintf(key, sizeof(key), "filter_linear%u", i); config_set_bool(conf, key, pass->filter == RARCH_FILTER_LINEAR); } snprintf(key, sizeof(key), "wrap_mode%u", i); config_set_string(conf, key, wrap_mode_to_str(pass->wrap)); if (pass->frame_count_mod) { snprintf(key, sizeof(key), "frame_count_mod%u", i); config_set_int(conf, key, pass->frame_count_mod); } snprintf(key, sizeof(key), "mipmap_input%u", i); config_set_bool(conf, key, pass->mipmap); snprintf(key, sizeof(key), "alias%u", i); config_set_string(conf, key, pass->alias); shader_write_fbo(conf, &pass->fbo, i); } if (shader->num_parameters) { size_t param_size = 4096 * sizeof(char); char *parameters = (char*)malloc(4096 * sizeof(char)); parameters[0] = '\0'; strlcpy(parameters, shader->parameters[0].id, param_size); for (i = 1; i < shader->num_parameters; i++) { /* O(n^2), but number of parameters is very limited. */ strlcat(parameters, ";", param_size); strlcat(parameters, shader->parameters[i].id, param_size); } config_set_string(conf, "parameters", parameters); for (i = 0; i < shader->num_parameters; i++) config_set_float(conf, shader->parameters[i].id, shader->parameters[i].current); free(parameters); } if (shader->luts) { size_t tex_size = 4096 * sizeof(char); char *textures = (char*)malloc(4096 * sizeof(char)); textures[0] = '\0'; strlcpy(textures, shader->lut[0].id, tex_size); for (i = 1; i < shader->luts; i++) { /* O(n^2), but number of textures is very limited. */ strlcat(textures, ";", tex_size); strlcat(textures, shader->lut[i].id, tex_size); } config_set_string(conf, "textures", textures); free(textures); for (i = 0; i < shader->luts; i++) { char key[64]; key[0] = '\0'; config_set_string(conf, shader->lut[i].id, shader->lut[i].path); if (shader->lut[i].filter != RARCH_FILTER_UNSPEC) { snprintf(key, sizeof(key), "%s_linear", shader->lut[i].id); config_set_bool(conf, key, shader->lut[i].filter == RARCH_FILTER_LINEAR); } snprintf(key, sizeof(key), "%s_wrap_mode", shader->lut[i].id); config_set_string(conf, key, wrap_mode_to_str(shader->lut[i].wrap)); snprintf(key, sizeof(key), "%s_mipmap", shader->lut[i].id); config_set_bool(conf, key, shader->lut[i].mipmap); } } if (*shader->script_path) config_set_string(conf, "import_script", shader->script_path); if (*shader->script_class) config_set_string(conf, "import_script_class", shader->script_class); if (shader->variables) { size_t var_tmp = 4096 * sizeof(char); char *variables = (char*)malloc(4096 * sizeof(char)); variables[0] = '\0'; strlcpy(variables, shader->variable[0].id, var_tmp); for (i = 1; i < shader->variables; i++) { strlcat(variables, ";", var_tmp); strlcat(variables, shader->variable[i].id, var_tmp); } config_set_string(conf, "imports", variables); for (i = 0; i < shader->variables; i++) shader_write_variable(conf, &shader->variable[i]); free(variables); } }