X-Git-Url: http://deadsoftware.ru/gitweb?a=blobdiff_plain;f=src%2Fconfig.c;h=dccf37c813c9708cfb759b8b5dcb2ae962668d14;hb=HEAD;hp=af211aeee7ea89b7194fcb8e0ff81e63d6433fbb;hpb=e5a6f7533ac0d87aca1084509533211af42b92e0;p=flatwaifu.git diff --git a/src/config.c b/src/config.c index af211ae..78664aa 100644 --- a/src/config.c +++ b/src/config.c @@ -1,24 +1,17 @@ -/* - Copyright (C) Prikol Software 1996-1997 - Copyright (C) Aleksey Volynskov 1996-1997 - Copyright (C) 2011 - - This file is part of the Doom2D:Rembo project. - - Doom2D:Rembo is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License version 2 as - published by the Free Software Foundation. - - Doom2D:Rembo is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, see or - write to the Free Software Foundation, Inc., - 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA -*/ +/* Copyright (C) 2020 SovietPony + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, version 3 of the License ONLY. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ #include "glob.h" #include @@ -26,73 +19,56 @@ #include #include #include -#include "map.h" -#include "sound.h" -#include "music.h" -#include "view.h" -#include "monster.h" -#include "player.h" -#include "menu.h" +#include "system.h" #include "files.h" -#include "render.h" -#include "error.h" #include "input.h" -#include "my.h" -enum {NONE, BYTE, WORD, DWORD, STRING, SW_ON, SW_OFF, FILES, KEY}; - -typedef struct cfg_t { - char *par, *cfg; - void *p; - byte t; -} cfg_t; - -byte cheat; -byte shot_vga; +#include "common/cp866.h" static FILE *f; static int ch; -static cfg_t cfg[] = { - {"file", NULL, NULL, FILES}, - {"cheat", NULL, &cheat, SW_ON}, - {"vga", "screenshot", &shot_vga, SW_ON}, - {"sndvol", "sound_volume", &snd_vol, WORD}, - {"musvol", "music_volume", &mus_vol, WORD}, -// {"fullscr", "fullscreen", &fullscreen, SW_ON}, -// {"window", NULL, &fullscreen, SW_OFF}, - {NULL, "sky", &w_horiz, SW_ON}, - {"mon", NULL, &nomon, SW_OFF}, -// {"gamma", "gamma", &gammaa, DWORD}, - {"warp", NULL, &_warp, BYTE}, - {"width", "screen_width", &SCRW, DWORD}, - {"height", "screen_height", &SCRH, DWORD}, - {NULL, "music_random", &music_random, SW_ON}, - {NULL, "music_time", &music_time, DWORD}, - {NULL, "music_fade", &music_fade, DWORD}, - {NULL, "pl1_left", &pl1.kl, KEY}, - {NULL, "pl1_right",&pl1.kr, KEY}, - {NULL, "pl1_up", &pl1.ku, KEY}, - {NULL, "pl1_down", &pl1.kd, KEY}, - {NULL, "pl1_jump", &pl1.kj, KEY}, - {NULL, "pl1_fire", &pl1.kf, KEY}, - {NULL, "pl1_next", &pl1.kwr, KEY}, - {NULL, "pl1_prev", &pl1.kwl, KEY}, - {NULL, "pl1_use", &pl1.kp, KEY}, - {NULL, "pl2_left", &pl2.kl, KEY}, - {NULL, "pl2_right",&pl2.kr, KEY}, - {NULL, "pl2_up", &pl2.ku, KEY}, - {NULL, "pl2_down", &pl2.kd, KEY}, - {NULL, "pl2_jump", &pl2.kj, KEY}, - {NULL, "pl2_fire", &pl2.kf, KEY}, - {NULL, "pl2_next", &pl2.kwr, KEY}, - {NULL, "pl2_prev", &pl2.kwl, KEY}, - {NULL, "pl2_use", &pl2.kp, KEY}, -// {"config", NULL, cfg_file, STRING}, - {NULL, NULL, NULL, NONE} // end -}; - -static int CFG_open_iterator (const char *name) { +const cfg_t *CFG_find_entry (const char *key, const cfg_t *cfg) { + assert(key != NULL); + if (cfg != NULL) { + int i = 0; + while (cfg[i].cfg && cp866_strcasecmp(cfg[i].cfg, key) != 0) { + i++; + } + return cfg[i].cfg ? &cfg[i] : NULL; + } else { + return NULL; + } +} + +int CFG_update_key (const char *key, const char *value, const cfg_t *cfg) { + const cfg_t *entry; + assert(key != NULL); + assert(value != NULL); + entry = CFG_find_entry(key, cfg); + if (entry != NULL) { + void *p = entry->p; + switch (entry->t) { + case Y_BYTE: *(byte*)p = atoi(value); break; + case Y_WORD: *(word*)p = atoi(value); break; + case Y_DWORD: *(dword*)p = atoi(value); break; + case Y_STRING: strcpy(p, value); break; // TODO fix this security problem + case Y_SW_ON: *(byte*)p = cp866_strcasecmp(value, "on") == 0 ? 1 : 0; break; + case Y_SW_OFF: *(byte*)p = cp866_strcasecmp(value, "off") == 0 ? 1 : 0; break; + case Y_FILES: F_addwad(value); break; + case Y_KEY: *(int*)p = I_string_to_key(value); break; + default: assert(0); // unknown type -> something broken + } + //logo("CFG_update_key: [%s] = [%s]\n", key, value); + return 1; + } else { + return 0; + } +} + +/* --- parser --- */ + +int CFG_open_iterator (const char *name) { assert(f == NULL); f = fopen(name, "rb"); if (f != NULL) { @@ -116,13 +92,13 @@ static void CFG_skip_line (void) { } } -static int CFG_scan_iterator (char *key, int keylen, char *value, int valuelen) { +int CFG_scan_iterator (char *key, int keylen, char *value, int valuelen) { + int i; + int found = 0; assert(key != NULL); assert(keylen > 0); assert(value != NULL); assert(valuelen > 0); - int i; - int found = 0; while (feof(f) == 0 && found == 0) { CFG_skip_space(); if (ch == ';') { @@ -158,40 +134,28 @@ static int CFG_scan_iterator (char *key, int keylen, char *value, int valuelen) return found; } -static void CFG_close_iterator (void) { +void CFG_close_iterator (void) { assert(f != NULL); fclose(f); f = NULL; } -static int CFG_update_key (const char *key, const char *value, int iscfg) { -// logo("CFG_update_key: [%s] [%s] %i\n", key, value, iscfg); - int i = 0; - while (cfg[i].t != NONE && ((iscfg ? cfg[i].cfg : cfg[i].par) == NULL || strcasecmp(key, iscfg ? cfg[i].cfg : cfg[i].par) != 0)) { - i += 1; - } - switch (cfg[i].t) { - case BYTE: *(byte*)cfg[i].p = atoi(value); break; - case WORD: *(word*)cfg[i].p = atoi(value); break; - case DWORD: *(dword*)cfg[i].p = atoi(value); break; - case STRING: cfg[i].p = strcpy(malloc(strlen(value) + 1), value); break; - case SW_ON: *(byte*)cfg[i].p = strcasecmp(value, "on") == 0 ? 1 : 0; break; - case SW_OFF: *(byte*)cfg[i].p = strcasecmp(value, "off") == 0 ? 0 : 1; break; - case FILES: F_addwad(value); break; - case KEY: *(int*)cfg[i].p = I_string_to_key(value); break; - case NONE: return 0; - default: assert(0); // unknown type -> something broken - } - return 1; -} +/* --- reader --- */ -static int CFG_read_config (const char *name) { +int CFG_read_config (const char *name, int n, const cfg_t **cfg) { + int i; char key[64]; char value[64]; assert(name != NULL); + assert(n >= 0); + assert(cfg != NULL); + assert(name != NULL); if (CFG_open_iterator(name)) { while (CFG_scan_iterator(key, 64, value, 64)) { - CFG_update_key(key, value, 1); + i = 0; + while (i < n && CFG_update_key(key, value, cfg[i]) == 0) { + i++; + } } CFG_close_iterator(); return 1; @@ -200,31 +164,98 @@ static int CFG_read_config (const char *name) { } } -void CFG_args (int argc, const char **argv) { - int i; - for (i = 1; i < argc; i++) { - if (argv[i][0] == '-' && argv[i][1] != 0) { - if (i + 1 >= argc) { - ERR_failinit("CFG_args: not enough arguments for parameter %s\n", argv[i]); - } else { - if (CFG_update_key(&argv[i][1], argv[i + 1], 0) != 0) { - ERR_failinit("CFG_args: unknown parameter %s\n", argv[i]); - } - i += 1; - } - } else { - ERR_failinit("CFG_args: something wrong here: %s\n", argv[i]); - } - } + + +/* --- writer --- */ + +static void CFG_write_key_value (FILE *f, const char *key, const char *value) { + assert(f != NULL); + assert(key != NULL); + assert(value != NULL); + fwrite(key, strlen(key), 1, f); + fwrite("=", 1, 1, f); + fwrite(value, strlen(value), 1, f); + fwrite("\n", 1, 1, f); } -void CFG_load (void) { - if (CFG_read_config("default.cfg") == 0) { - // TODO alt config at $HOME and system directories +static int CFG_write_entry (FILE *f, const cfg_t *entry) { + char buf[16]; + const char *str; + const char *key; + assert(f != NULL); + assert(entry != NULL); + key = entry->cfg; + if (key != NULL) { + switch (entry->t) { + case Y_BYTE: + snprintf(buf, 16, "%i", *(byte*)entry->p); + CFG_write_key_value(f, key, buf); + break; + case Y_WORD: + snprintf(buf, 16, "%i", *(word*)entry->p); + CFG_write_key_value(f, key, buf); + break; + case Y_DWORD: + snprintf(buf, 16, "%i", *(dword*)entry->p); + CFG_write_key_value(f, key, buf); + break; + case Y_STRING: + CFG_write_key_value(f, key, entry->p); + break; + case Y_SW_ON: + case Y_SW_OFF: + str = *(byte*)entry->p ? "on" : "off"; + CFG_write_key_value(f, key, str); + break; + case Y_KEY: + str = I_key_to_string(*(int*)entry->p); + CFG_write_key_value(f, key, str); + break; + case Y_FILES: return 1; // ignore + case 0: return 0; // end + default: assert(0); // unknown type -> something broken + } } - CFG_read_config("user.cfg"); + return entry->t == 0 ? 0 : 1; } -void CFG_save (void) { - // TODO +int CFG_update_config (const char *old, const char *new, int n, const cfg_t **cfg, const char *msg) { + int i, j; + char key[64]; + char value[64]; + FILE *nf; + assert(old != NULL); + assert(new != NULL); + assert(n >= 0); + assert(cfg != NULL); + nf = fopen(new, "wb"); + if (nf != NULL) { + if (msg != NULL) { + fwrite("; ", 2, 1, nf); + fwrite(msg, strlen(msg), 1, nf); + fwrite("\n", 1, 1, nf); + } + if (CFG_open_iterator(old)) { + while (CFG_scan_iterator(key, 64, value, 64)) { + i = 0; + while (i < n && CFG_find_entry(key, cfg[i]) == NULL) { + i++; + } + if (i >= n) { + CFG_write_key_value(nf, key, value); + } + } + CFG_close_iterator(); + } + for (j = 0; j < n; j++) { + if (cfg[j] != NULL) { + i = 0; + while (CFG_write_entry(nf, &cfg[j][i])) { + i++; + } + } + } + fclose(nf); + } + return nf != NULL; }