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