platform/common/config.c

   1 /*
   2  * Human-readable config file management for PicoDrive
   3  * (c) notaz, 2008
   4  */
   5
   6 #include <stdio.h>
   7 #include <string.h>
   8 #include <stdlib.h>
   9 #ifdef __EPOC32__
  10 #include <unistd.h>
  11 #endif
  12 #include "config.h"
  13 #include "plat.h"
  14 #include "input.h"
  15 #include "lprintf.h"
  16
  17 static char *mystrip(char *str);
  18
  19 #ifndef _MSC_VER
  20
  21 #include "menu.h"
  22 #include "emu.h"
  23 #include <pico/pico.h>
  24
  25 // always output DOS endlines
  26 #ifdef _WIN32
  27 #define NL "\n"
  28 #else
  29 #define NL "\r\n"
  30 #endif
  31
  32 static int seek_sect(FILE *f, const char *section)
  33 {
  34         char line[128], *tmp;
  35         int len;
  36
  37         len = strlen(section);
  38         // seek to the section needed
  39         while (!feof(f))
  40         {
  41                 tmp = fgets(line, sizeof(line), f);
  42                 if (tmp == NULL) break;
  43
  44                 if (line[0] != '[') continue; // not section start
  45                 if (strncmp(line + 1, section, len) == 0 && line[len+1] == ']')
  46                         return 1; // found it
  47         }
  48
  49         return 0;
  50 }
  51
  52
  53 static void keys_write(FILE *fn, const char *bind_str, int dev_id, const int *binds, int no_defaults)
  54 {
  55         char act[48];
  56         int key_count = 0, k, i;
  57         const int *def_binds;
  58
  59         in_get_config(dev_id, IN_CFG_BIND_COUNT, &key_count);
  60         def_binds = in_get_dev_def_binds(dev_id);
  61
  62         for (k = 0; k < key_count; k++)
  63         {
  64                 const char *name;
  65                 int t, mask;
  66                 act[0] = act[31] = 0;
  67
  68                 for (t = 0; t < IN_BINDTYPE_COUNT; t++)
  69                         if (binds[IN_BIND_OFFS(k, t)] != def_binds[IN_BIND_OFFS(k, t)])
  70                                 break;
  71
  72                 if (no_defaults && t == IN_BINDTYPE_COUNT)
  73                         continue;       /* no change from defaults */
  74
  75                 name = in_get_key_name(dev_id, k);
  76
  77                 for (t = 0; t < IN_BINDTYPE_COUNT; t++)
  78                         if (binds[IN_BIND_OFFS(k, t)] != 0 || def_binds[IN_BIND_OFFS(k, t)] == 0)
  79                                 break;
  80
  81                 if (t == IN_BINDTYPE_COUNT) {
  82                         /* key has default bind removed */
  83                         fprintf(fn, "%s %s =" NL, bind_str, name);
  84                         continue;
  85                 }
  86
  87                 for (i = 0; i < sizeof(me_ctrl_actions) / sizeof(me_ctrl_actions[0]); i++) {
  88                         mask = me_ctrl_actions[i].mask;
  89                         if (mask & binds[IN_BIND_OFFS(k, IN_BINDTYPE_PLAYER12)]) {
  90                                 strncpy(act, me_ctrl_actions[i].name, 31);
  91                                 fprintf(fn, "%s %s = player1 %s" NL, bind_str, name, mystrip(act));
  92                         }
  93                         mask = me_ctrl_actions[i].mask << 16;
  94                         if (mask & binds[IN_BIND_OFFS(k, IN_BINDTYPE_PLAYER12)]) {
  95                                 strncpy(act, me_ctrl_actions[i].name, 31);
  96                                 fprintf(fn, "%s %s = player2 %s" NL, bind_str, name, mystrip(act));
  97                         }
  98                 }
  99
 100                 for (i = 0; emuctrl_actions[i].name != NULL; i++) {
 101                         mask = emuctrl_actions[i].mask;
 102                         if (mask & binds[IN_BIND_OFFS(k, IN_BINDTYPE_EMU)]) {
 103                                 strncpy(act, emuctrl_actions[i].name, 31);
 104                                 fprintf(fn, "%s %s = %s" NL, bind_str, name, mystrip(act));
 105                         }
 106                 }
 107         }
 108 }
 109
 110 /* XXX: this should go to menu structures instead */
 111 static int default_var(const menu_entry *me)
 112 {
 113         switch (me->id)
 114         {
 115                 case MA_OPT2_ENABLE_YM2612:
 116                 case MA_OPT2_ENABLE_SN76496:
 117                 case MA_OPT2_ENABLE_Z80:
 118                 case MA_OPT_6BUTTON_PAD:
 119                 case MA_OPT_ACC_SPRITES:
 120                 case MA_OPT_ARM940_SOUND:
 121                 case MA_CDOPT_PCM:
 122                 case MA_CDOPT_CDDA:
 123                 case MA_CDOPT_SCALEROT_CHIP:
 124                 case MA_CDOPT_BETTER_SYNC:
 125                 case MA_CDOPT_SAVERAM:
 126                 case MA_32XOPT_ENABLE_32X:
 127                 case MA_32XOPT_PWM:
 128                 case MA_OPT2_SVP_DYNAREC:
 129                 case MA_OPT2_NO_SPRITE_LIM:
 130                 case MA_OPT2_NO_IDLE_LOOPS:
 131                         return defaultConfig.s_PicoOpt;
 132
 133                 case MA_OPT_SRAM_STATES:
 134                 case MA_OPT_SHOW_FPS:
 135                 case MA_OPT_ENABLE_SOUND:
 136                 case MA_OPT2_GZIP_STATES:
 137                 case MA_OPT2_SQUIDGEHACK:
 138                 case MA_OPT2_NO_LAST_ROM:
 139                 case MA_OPT2_RAMTIMINGS:
 140                 case MA_CDOPT_LEDS:
 141                 case MA_OPT2_A_SN_GAMMA:
 142                 case MA_OPT2_VSYNC:
 143                 case MA_OPT_INTERLACED:
 144                 case MA_OPT2_DBLBUFF:
 145                 case MA_OPT2_STATUS_LINE:
 146                 case MA_OPT2_NO_FRAME_LIMIT:
 147                 case MA_OPT_TEARING_FIX:
 148                         return defaultConfig.EmuOpt;
 149
 150                 case MA_CTRL_TURBO_RATE: return defaultConfig.turbo_rate;
 151                 case MA_OPT_SCALING:     return defaultConfig.scaling;
 152                 case MA_OPT_ROTATION:    return defaultConfig.rotation;
 153                 case MA_OPT2_GAMMA:      return defaultConfig.gamma;
 154                 case MA_OPT_FRAMESKIP:   return defaultConfig.Frameskip;
 155                 case MA_OPT_CONFIRM_STATES: return defaultConfig.confirm_save;
 156                 case MA_OPT_CPU_CLOCKS:  return defaultConfig.CPUclock;
 157                 case MA_OPT_RENDERER:    return defaultConfig.renderer;
 158                 case MA_32XOPT_RENDERER: return defaultConfig.renderer32x;
 159
 160                 case MA_OPT_SAVE_SLOT:
 161                         return 0;
 162
 163                 default:
 164                         lprintf("missing default for %d\n", me->id);
 165                         return 0;
 166         }
 167 }
 168
 169 static int is_cust_val_default(const menu_entry *me)
 170 {
 171         switch (me->id)
 172         {
 173                 case MA_OPT_REGION:
 174                         return defaultConfig.s_PicoRegion == PicoRegionOverride &&
 175                                 defaultConfig.s_PicoAutoRgnOrder == PicoAutoRgnOrder;
 176                 case MA_OPT_SOUND_QUALITY:
 177                         return defaultConfig.s_PsndRate == PsndRate &&
 178                                 ((defaultConfig.s_PicoOpt ^ PicoOpt) & POPT_EN_STEREO) == 0;
 179                 case MA_CDOPT_READAHEAD:
 180                         return defaultConfig.s_PicoCDBuffers == PicoCDBuffers;
 181                 case MA_32XOPT_MSH2_CYCLES:
 182                         return p32x_msh2_multiplier == MSH2_MULTI_DEFAULT;
 183                 case MA_32XOPT_SSH2_CYCLES:
 184                         return p32x_ssh2_multiplier == SSH2_MULTI_DEFAULT;
 185                 default:break;
 186         }
 187
 188         lprintf("is_cust_val_default: unhandled id %i\n", me->id);
 189         return 0;
 190 }
 191
 192 int config_writesect(const char *fname, const char *section)
 193 {
 194         FILE *fo = NULL, *fn = NULL; // old and new
 195         int no_defaults = 0; // avoid saving defaults
 196         menu_entry *me;
 197         int t, tlen, ret;
 198         char line[128], *tmp;
 199
 200         if (section != NULL)
 201         {
 202                 no_defaults = 1;
 203
 204                 fo = fopen(fname, "r");
 205                 if (fo == NULL) {
 206                         fn = fopen(fname, "w");
 207                         goto write;
 208                 }
 209
 210                 ret = seek_sect(fo, section);
 211                 if (!ret) {
 212                         // sect not found, we can simply append
 213                         fclose(fo); fo = NULL;
 214                         fn = fopen(fname, "a");
 215                         goto write;
 216                 }
 217
 218                 // use 2 files..
 219                 fclose(fo);
 220                 rename(fname, "tmp.cfg");
 221                 fo = fopen("tmp.cfg", "r");
 222                 fn = fopen(fname, "w");
 223                 if (fo == NULL || fn == NULL) goto write;
 224
 225                 // copy everything until sect
 226                 tlen = strlen(section);
 227                 while (!feof(fo))
 228                 {
 229                         tmp = fgets(line, sizeof(line), fo);
 230                         if (tmp == NULL) break;
 231
 232                         if (line[0] == '[' && strncmp(line + 1, section, tlen) == 0 && line[tlen+1] == ']')
 233                                 break;
 234                         fputs(line, fn);
 235                 }
 236
 237                 // now skip to next sect
 238                 while (!feof(fo))
 239                 {
 240                         tmp = fgets(line, sizeof(line), fo);
 241                         if (tmp == NULL) break;
 242                         if (line[0] == '[') {
 243                                 fseek(fo, -strlen(line), SEEK_CUR);
 244                                 break;
 245                         }
 246                 }
 247                 if (feof(fo))
 248                 {
 249                         fclose(fo); fo = NULL;
 250                         remove("tmp.cfg");
 251                 }
 252         }
 253         else
 254         {
 255                 fn = fopen(fname, "w");
 256         }
 257
 258 write:
 259         if (fn == NULL) {
 260                 if (fo) fclose(fo);
 261                 return -1;
 262         }
 263         if (section != NULL)
 264                 fprintf(fn, "[%s]" NL, section);
 265
 266         for (me = me_list_get_first(); me != NULL; me = me_list_get_next())
 267         {
 268                 int dummy;
 269                 if (!me->need_to_save)
 270                         continue;
 271                 if (me->name == NULL || me->name[0] == 0)
 272                         continue;
 273
 274                 if (me->beh == MB_OPT_ONOFF || me->beh == MB_OPT_CUSTONOFF) {
 275                         if (!no_defaults || ((*(int *)me->var ^ default_var(me)) & me->mask))
 276                                 fprintf(fn, "%s = %i" NL, me->name, (*(int *)me->var & me->mask) ? 1 : 0);
 277                 }
 278                 else if (me->beh == MB_OPT_RANGE || me->beh == MB_OPT_CUSTRANGE) {
 279                         if (!no_defaults || (*(int *)me->var ^ default_var(me)))
 280                                 fprintf(fn, "%s = %i" NL, me->name, *(int *)me->var);
 281                 }
 282                 else if (me->beh == MB_OPT_ENUM && me->data != NULL) {
 283                         const char **names = (const char **)me->data;
 284                         for (t = 0; names[t] != NULL; t++)
 285                                 if (*(int *)me->var == t && (!no_defaults || (*(int *)me->var ^ default_var(me)))) {
 286                                         strncpy(line, names[t], sizeof(line));
 287                                         goto write_line;
 288                                 }
 289                 }
 290                 else if (me->generate_name != NULL) {
 291                         if (!no_defaults || !is_cust_val_default(me)) {
 292                                 strncpy(line, me->generate_name(0, &dummy), sizeof(line));
 293                                 goto write_line;
 294                         }
 295                 }
 296                 else
 297                         lprintf("config: unhandled write: %i\n", me->id);
 298                 continue;
 299
 300 write_line:
 301                 line[sizeof(line) - 1] = 0;
 302                 mystrip(line);
 303                 fprintf(fn, "%s = %s" NL, me->name, line);
 304         }
 305
 306         /* input: save device names */
 307         for (t = 0; t < IN_MAX_DEVS; t++)
 308         {
 309                 const int  *binds = in_get_dev_binds(t);
 310                 const char *name =  in_get_dev_name(t, 0, 0);
 311                 if (binds == NULL || name == NULL)
 312                         continue;
 313
 314                 fprintf(fn, "input%d = %s" NL, t, name);
 315         }
 316
 317         /* input: save binds */
 318         for (t = 0; t < IN_MAX_DEVS; t++)
 319         {
 320                 const int *binds = in_get_dev_binds(t);
 321                 const char *name = in_get_dev_name(t, 0, 0);
 322                 char strbind[16];
 323                 int count = 0;
 324
 325                 if (binds == NULL || name == NULL)
 326                         continue;
 327
 328                 sprintf(strbind, "bind%d", t);
 329                 if (t == 0) strbind[4] = 0;
 330
 331                 in_get_config(t, IN_CFG_BIND_COUNT, &count);
 332                 keys_write(fn, strbind, t, binds, no_defaults);
 333         }
 334
 335 #ifndef PSP
 336         if (section == NULL)
 337                 fprintf(fn, "Sound Volume = %i" NL, currentConfig.volume);
 338 #endif
 339
 340         fprintf(fn, NL);
 341
 342         if (fo != NULL)
 343         {
 344                 // copy whatever is left
 345                 while (!feof(fo))
 346                 {
 347                         tmp = fgets(line, sizeof(line), fo);
 348                         if (tmp == NULL) break;
 349
 350                         fputs(line, fn);
 351                 }
 352                 fclose(fo);
 353                 remove("tmp.cfg");
 354         }
 355
 356         fclose(fn);
 357         return 0;
 358 }
 359
 360
 361 int config_writelrom(const char *fname)
 362 {
 363         char line[128], *tmp, *optr = NULL;
 364         char *old_data = NULL;
 365         int size;
 366         FILE *f;
 367
 368         if (strlen(rom_fname_loaded) == 0) return -1;
 369
 370         f = fopen(fname, "r");
 371         if (f != NULL)
 372         {
 373                 fseek(f, 0, SEEK_END);
 374                 size = ftell(f);
 375                 fseek(f, 0, SEEK_SET);
 376                 old_data = malloc(size + size/8);
 377                 if (old_data != NULL)
 378                 {
 379                         optr = old_data;
 380                         while (!feof(f))
 381                         {
 382                                 tmp = fgets(line, sizeof(line), f);
 383                                 if (tmp == NULL) break;
 384                                 mystrip(line);
 385                                 if (strncasecmp(line, "LastUsedROM", 11) == 0)
 386                                         continue;
 387                                 sprintf(optr, "%s", line);
 388                                 optr += strlen(optr);
 389                         }
 390                 }
 391                 fclose(f);
 392         }
 393
 394         f = fopen(fname, "w");
 395         if (f == NULL) return -1;
 396
 397         if (old_data != NULL) {
 398                 fwrite(old_data, 1, optr - old_data, f);
 399                 free(old_data);
 400         }
 401         fprintf(f, "LastUsedROM = %s" NL, rom_fname_loaded);
 402         fclose(f);
 403         return 0;
 404 }
 405
 406 /* --------------------------------------------------------------------------*/
 407
 408 int config_readlrom(const char *fname)
 409 {
 410         char line[128], *tmp;
 411         int i, len, ret = -1;
 412         FILE *f;
 413
 414         f = fopen(fname, "r");
 415         if (f == NULL) return -1;
 416
 417         // seek to the section needed
 418         while (!feof(f))
 419         {
 420                 tmp = fgets(line, sizeof(line), f);
 421                 if (tmp == NULL) break;
 422
 423                 if (strncasecmp(line, "LastUsedROM", 11) != 0) continue;
 424                 len = strlen(line);
 425                 for (i = 0; i < len; i++)
 426                         if (line[i] == '#' || line[i] == '\r' || line[i] == '\n') { line[i] = 0; break; }
 427                 tmp = strchr(line, '=');
 428                 if (tmp == NULL) break;
 429                 tmp++;
 430                 mystrip(tmp);
 431
 432                 len = sizeof(rom_fname_loaded);
 433                 strncpy(rom_fname_loaded, tmp, len);
 434                 rom_fname_loaded[len-1] = 0;
 435                 ret = 0;
 436                 break;
 437         }
 438         fclose(f);
 439         return ret;
 440 }
 441
 442
 443 static int custom_read(menu_entry *me, const char *var, const char *val)
 444 {
 445         char *tmp;
 446
 447         switch (me->id)
 448         {
 449                 case MA_OPT_FRAMESKIP:
 450                         if (strcasecmp(var, "Frameskip") != 0) return 0;
 451                         if (strcasecmp(val, "Auto") == 0)
 452                              currentConfig.Frameskip = -1;
 453                         else currentConfig.Frameskip = atoi(val);
 454                         return 1;
 455
 456                 case MA_OPT_SOUND_QUALITY:
 457                         if (strcasecmp(var, "Sound Quality") != 0) return 0;
 458                         PsndRate = strtoul(val, &tmp, 10);
 459                         if (PsndRate < 8000 || PsndRate > 44100)
 460                                 PsndRate = 22050;
 461                         if (*tmp == 'H' || *tmp == 'h') tmp++;
 462                         if (*tmp == 'Z' || *tmp == 'z') tmp++;
 463                         while (*tmp == ' ') tmp++;
 464                         if        (strcasecmp(tmp, "stereo") == 0) {
 465                                 PicoOpt |=  POPT_EN_STEREO;
 466                         } else if (strcasecmp(tmp, "mono") == 0) {
 467                                 PicoOpt &= ~POPT_EN_STEREO;
 468                         } else
 469                                 return 0;
 470                         return 1;
 471
 472                 case MA_OPT_REGION:
 473                         if (strcasecmp(var, "Region") != 0) return 0;
 474                         if       (strncasecmp(val, "Auto: ", 6) == 0)
 475                         {
 476                                 const char *p = val + 5, *end = val + strlen(val);
 477                                 int i;
 478                                 PicoRegionOverride = PicoAutoRgnOrder = 0;
 479                                 for (i = 0; p < end && i < 3; i++)
 480                                 {
 481                                         while (*p == ' ') p++;
 482                                         if        (p[0] == 'J' && p[1] == 'P') {
 483                                                 PicoAutoRgnOrder |= 1 << (i*4);
 484                                         } else if (p[0] == 'U' && p[1] == 'S') {
 485                                                 PicoAutoRgnOrder |= 4 << (i*4);
 486                                         } else if (p[0] == 'E' && p[1] == 'U') {
 487                                                 PicoAutoRgnOrder |= 8 << (i*4);
 488                                         }
 489                                         while (*p != ' ' && *p != 0) p++;
 490                                         if (*p == 0) break;
 491                                 }
 492                         }
 493                         else   if (strcasecmp(val, "Auto") == 0) {
 494                                 PicoRegionOverride = 0;
 495                         } else if (strcasecmp(val, "Japan NTSC") == 0) {
 496                                 PicoRegionOverride = 1;
 497                         } else if (strcasecmp(val, "Japan PAL") == 0) {
 498                                 PicoRegionOverride = 2;
 499                         } else if (strcasecmp(val, "USA") == 0) {
 500                                 PicoRegionOverride = 4;
 501                         } else if (strcasecmp(val, "Europe") == 0) {
 502                                 PicoRegionOverride = 8;
 503                         } else
 504                                 return 0;
 505                         return 1;
 506
 507                 case MA_OPT2_GAMMA:
 508                         if (strcasecmp(var, "Gamma correction") != 0) return 0;
 509                         currentConfig.gamma = (int) (atof(val) * 100.0);
 510                         return 1;
 511
 512                 case MA_CDOPT_READAHEAD:
 513                         if (strcasecmp(var, "ReadAhead buffer") != 0) return 0;
 514                         PicoCDBuffers = atoi(val) / 2;
 515                         return 1;
 516
 517                 case MA_32XOPT_MSH2_CYCLES:
 518                 case MA_32XOPT_SSH2_CYCLES: {
 519                         int *mul = (me->id == MA_32XOPT_MSH2_CYCLES) ? &p32x_msh2_multiplier : &p32x_ssh2_multiplier;
 520                         *mul = ((unsigned int)atoi(val) << SH2_MULTI_SHIFT) / 7670;
 521                         return 1;
 522                 }
 523
 524                 /* PSP */
 525                 case MA_OPT3_SCALE:
 526                         if (strcasecmp(var, "Scale factor") != 0) return 0;
 527                         currentConfig.scale = atof(val);
 528                         return 1;
 529                 case MA_OPT3_HSCALE32:
 530                         if (strcasecmp(var, "Hor. scale (for low res. games)") != 0) return 0;
 531                         currentConfig.hscale32 = atof(val);
 532                         return 1;
 533                 case MA_OPT3_HSCALE40:
 534                         if (strcasecmp(var, "Hor. scale (for hi res. games)") != 0) return 0;
 535                         currentConfig.hscale40 = atof(val);
 536                         return 1;
 537                 case MA_OPT3_VSYNC:
 538                         // XXX: use enum
 539                         if (strcasecmp(var, "Wait for vsync") != 0) return 0;
 540                         if        (strcasecmp(val, "never") == 0) {
 541                                 currentConfig.EmuOpt &= ~0x12000;
 542                         } else if (strcasecmp(val, "sometimes") == 0) {
 543                                 currentConfig.EmuOpt |=  0x12000;
 544                         } else if (strcasecmp(val, "always") == 0) {
 545                                 currentConfig.EmuOpt &= ~0x12000;
 546                                 currentConfig.EmuOpt |=  0x02000;
 547                         } else
 548                                 return 0;
 549                         return 1;
 550
 551                 default:
 552                         lprintf("unhandled custom_read %i: %s\n", me->id, var);
 553                         return 0;
 554         }
 555 }
 556
 557
 558 static unsigned int keys_encountered = 0;
 559
 560 static int parse_bind_val(const char *val, int *type)
 561 {
 562         int i;
 563
 564         *type = IN_BINDTYPE_NONE;
 565         if (val[0] == 0)
 566                 return 0;
 567
 568         if (strncasecmp(val, "player", 6) == 0)
 569         {
 570                 int player, shift = 0;
 571                 player = atoi(val + 6) - 1;
 572
 573                 if (player > 1)
 574                         return -1;
 575                 if (player == 1)
 576                         shift = 16;
 577
 578                 *type = IN_BINDTYPE_PLAYER12;
 579                 for (i = 0; i < sizeof(me_ctrl_actions) / sizeof(me_ctrl_actions[0]); i++) {
 580                         if (strncasecmp(me_ctrl_actions[i].name, val + 8, strlen(val + 8)) == 0)
 581                                 return me_ctrl_actions[i].mask << shift;
 582                 }
 583         }
 584         for (i = 0; emuctrl_actions[i].name != NULL; i++) {
 585                 if (strncasecmp(emuctrl_actions[i].name, val, strlen(val)) == 0) {
 586                         *type = IN_BINDTYPE_EMU;
 587                         return emuctrl_actions[i].mask;
 588                 }
 589         }
 590
 591         return -1;
 592 }
 593
 594 static void keys_parse(const char *key, const char *val, int dev_id)
 595 {
 596         int acts, type;
 597
 598         acts = parse_bind_val(val, &type);
 599         if (acts == -1) {
 600                 lprintf("config: unhandled action \"%s\"\n", val);
 601                 return;
 602         }
 603
 604         in_config_bind_key(dev_id, key, acts, type);
 605 }
 606
 607 static int get_numvar_num(const char *var)
 608 {
 609         char *p = NULL;
 610         int num;
 611
 612         if (var[0] == ' ')
 613                 return 0;
 614
 615         num = strtoul(var, &p, 10);
 616         if (*p == 0 || *p == ' ')
 617                 return num;
 618
 619         return -1;
 620 }
 621
 622 /* map dev number in confing to input dev number */
 623 static unsigned char input_dev_map[IN_MAX_DEVS];
 624
 625 static void parse(const char *var, const char *val)
 626 {
 627         menu_entry *me;
 628         int tmp;
 629
 630         if (strcasecmp(var, "LastUsedROM") == 0)
 631                 return; /* handled elsewhere */
 632
 633         if (strcasecmp(var, "Sound Volume") == 0) {
 634                 currentConfig.volume = atoi(val);
 635                 return;
 636         }
 637
 638         /* input: device name */
 639         if (strncasecmp(var, "input", 5) == 0) {
 640                 int num = get_numvar_num(var + 5);
 641                 if (num >= 0 && num < IN_MAX_DEVS)
 642                         input_dev_map[num] = in_config_parse_dev(val);
 643                 else
 644                         lprintf("config: failed to parse: %s\n", var);
 645                 return;
 646         }
 647
 648         // key binds
 649         if (strncasecmp(var, "bind", 4) == 0) {
 650                 const char *p = var + 4;
 651                 int num = get_numvar_num(p);
 652                 if (num < 0 || num >= IN_MAX_DEVS) {
 653                         lprintf("config: failed to parse: %s\n", var);
 654                         return;
 655                 }
 656
 657                 num = input_dev_map[num];
 658                 if (num < 0 || num >= IN_MAX_DEVS) {
 659                         lprintf("config: invalid device id: %s\n", var);
 660                         return;
 661                 }
 662
 663                 while (*p && *p != ' ') p++;
 664                 while (*p && *p == ' ') p++;
 665                 keys_parse(p, val, num);
 666                 return;
 667         }
 668
 669         for (me = me_list_get_first(); me != NULL; me = me_list_get_next())
 670         {
 671                 char *p;
 672
 673                 if (!me->need_to_save)
 674                         continue;
 675                 if (me->name == NULL || strcasecmp(var, me->name) != 0)
 676                         continue;
 677
 678                 if (me->beh == MB_OPT_ONOFF) {
 679                         tmp = strtol(val, &p, 0);
 680                         if (*p != 0)
 681                                 goto bad_val;
 682                         if (tmp) *(int *)me->var |=  me->mask;
 683                         else     *(int *)me->var &= ~me->mask;
 684                         return;
 685                 }
 686                 else if (me->beh == MB_OPT_RANGE) {
 687                         tmp = strtol(val, &p, 0);
 688                         if (*p != 0)
 689                                 goto bad_val;
 690                         if (tmp < me->min) tmp = me->min;
 691                         if (tmp > me->max) tmp = me->max;
 692                         *(int *)me->var = tmp;
 693                         return;
 694                 }
 695                 else if (me->beh == MB_OPT_ENUM) {
 696                         const char **names, *p1;
 697                         int i;
 698
 699                         names = (const char **)me->data;
 700                         if (names == NULL)
 701                                 goto bad_val;
 702                         for (i = 0; names[i] != NULL; i++) {
 703                                 for (p1 = names[i]; *p1 == ' '; p1++)
 704                                         ;
 705                                 if (strcasecmp(p1, val) == 0) {
 706                                         *(int *)me->var = i;
 707                                         return;
 708                                 }
 709                         }
 710                         goto bad_val;
 711                 }
 712                 else if (custom_read(me, var, val))
 713                         return;
 714         }
 715
 716         lprintf("config_readsect: unhandled var: \"%s\"\n", var);
 717         return;
 718
 719 bad_val:
 720         lprintf("config_readsect: unhandled val for \"%s\": %s\n", var, val);
 721 }
 722
 723
 724 int config_havesect(const char *fname, const char *section)
 725 {
 726         FILE *f;
 727         int ret;
 728
 729         f = fopen(fname, "r");
 730         if (f == NULL) return 0;
 731
 732         ret = seek_sect(f, section);
 733         fclose(f);
 734         return ret;
 735 }
 736
 737 int config_readsect(const char *fname, const char *section)
 738 {
 739         char line[128], *var, *val;
 740         FILE *f;
 741         int ret;
 742
 743         f = fopen(fname, "r");
 744         if (f == NULL) return -1;
 745
 746         if (section != NULL)
 747         {
 748                 ret = seek_sect(f, section);
 749                 if (!ret) {
 750                         lprintf("config_readsect: %s: missing section [%s]\n", fname, section);
 751                         fclose(f);
 752                         return -1;
 753                 }
 754         }
 755
 756         keys_encountered = 0;
 757         memset(input_dev_map, 0xff, sizeof(input_dev_map));
 758
 759         in_config_start();
 760         while (!feof(f))
 761         {
 762                 ret = config_get_var_val(f, line, sizeof(line), &var, &val);
 763                 if (ret ==  0) break;
 764                 if (ret == -1) continue;
 765
 766                 parse(var, val);
 767         }
 768         in_config_end();
 769
 770         fclose(f);
 771         return 0;
 772 }
 773
 774 #endif // _MSC_VER
 775
 776 static char *mystrip(char *str)
 777 {
 778         int i, len;
 779
 780         len = strlen(str);
 781         for (i = 0; i < len; i++)
 782                 if (str[i] != ' ') break;
 783         if (i > 0) memmove(str, str + i, len - i + 1);
 784
 785         len = strlen(str);
 786         for (i = len - 1; i >= 0; i--)
 787                 if (str[i] != ' ') break;
 788         str[i+1] = 0;
 789
 790         return str;
 791 }
 792
 793 /* returns:
 794  *  0 - EOF, end
 795  *  1 - parsed ok
 796  * -1 - failed to parse line
 797  */
 798 int config_get_var_val(void *file, char *line, int lsize, char **rvar, char **rval)
 799 {
 800         char *var, *val, *tmp;
 801         FILE *f = file;
 802         int len, i;
 803
 804         tmp = fgets(line, lsize, f);
 805         if (tmp == NULL) return 0;
 806
 807         if (line[0] == '[') return 0; // other section
 808
 809         // strip comments, linefeed, spaces..
 810         len = strlen(line);
 811         for (i = 0; i < len; i++)
 812                 if (line[i] == '#' || line[i] == '\r' || line[i] == '\n') { line[i] = 0; break; }
 813         mystrip(line);
 814         len = strlen(line);
 815         if (len <= 0) return -1;;
 816
 817         // get var and val
 818         for (i = 0; i < len; i++)
 819                 if (line[i] == '=') break;
 820         if (i >= len || strchr(&line[i+1], '=') != NULL) {
 821                 lprintf("config_readsect: can't parse: %s\n", line);
 822                 return -1;
 823         }
 824         line[i] = 0;
 825         var = line;
 826         val = &line[i+1];
 827         mystrip(var);
 828         mystrip(val);
 829
 830 #ifndef _MSC_VER
 831         if (strlen(var) == 0 || (strlen(val) == 0 && strncasecmp(var, "bind", 4) != 0)) {
 832                 lprintf("config_readsect: something's empty: \"%s\" = \"%s\"\n", var, val);
 833                 return -1;;
 834         }
 835 #endif
 836
 837         *rvar = var;
 838         *rval = val;
 839         return 1;
 840 }
 841