forked from KolibriOS/kolibrios
1236 lines
35 KiB
C++
1236 lines
35 KiB
C++
// This parses the RC file.
|
|
|
|
#ifdef __MINGW32__
|
|
#undef __STRICT_ANSI__
|
|
#endif
|
|
|
|
#include <stddef.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <SDL.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <errno.h>
|
|
#include <assert.h>
|
|
#include <strings.h>
|
|
#include <ctype.h>
|
|
|
|
#include "rc.h"
|
|
#include "ckvp.h"
|
|
#include "pd-defs.h"
|
|
#include "romload.h"
|
|
#include "system.h"
|
|
#include "md.h"
|
|
|
|
// CTV names
|
|
const char *ctv_names[] = {
|
|
"off", "blur", "scanline", "interlace", "swab",
|
|
NULL
|
|
};
|
|
|
|
// Scaling algorithms names
|
|
const char *scaling_names[] = {
|
|
"stretch",
|
|
"scale",
|
|
"hqx",
|
|
"hqx stretch",
|
|
"scale2x",
|
|
"scale2x stretch",
|
|
"none",
|
|
NULL
|
|
};
|
|
|
|
// CPU names, keep index in sync with rc-vars.h and enums in md.h
|
|
const char *emu_z80_names[] = { "none", "mz80", "cz80", "drz80", NULL };
|
|
const char *emu_m68k_names[] = { "none", "star", "musa", "cyclone", NULL };
|
|
|
|
// The table of strings and the keysyms they map to.
|
|
// The order is a bit weird, since this was originally a mapping for the SVGALib
|
|
// scancodes, and I just added the SDL stuff on top of it.
|
|
struct rc_keysym rc_keysyms[] = {
|
|
{ "ESCAPE", PDK_ESCAPE },
|
|
{ "BACKSPACE", PDK_BACKSPACE },
|
|
{ "TAB", PDK_TAB },
|
|
{ "RETURN", PDK_RETURN },
|
|
{ "ENTER", PDK_RETURN },
|
|
{ "KP_MULTIPLY", PDK_KP_MULTIPLY },
|
|
{ "SPACE", PDK_SPACE },
|
|
{ "F1", PDK_F1 },
|
|
{ "F2", PDK_F2 },
|
|
{ "F3", PDK_F3 },
|
|
{ "F4", PDK_F4 },
|
|
{ "F5", PDK_F5 },
|
|
{ "F6", PDK_F6 },
|
|
{ "F7", PDK_F7 },
|
|
{ "F8", PDK_F8 },
|
|
{ "F9", PDK_F9 },
|
|
{ "F10", PDK_F10 },
|
|
{ "KP_7", PDK_KP7 },
|
|
{ "KP_HOME", PDK_KP7 },
|
|
{ "KP_8", PDK_KP8 },
|
|
{ "KP_UP", PDK_KP8 },
|
|
{ "KP_9", PDK_KP9 },
|
|
{ "KP_PAGE_UP", PDK_KP9 },
|
|
{ "KP_PAGEUP", PDK_KP9 },
|
|
{ "KP_MINUS", PDK_KP_MINUS },
|
|
{ "KP_4", PDK_KP4 },
|
|
{ "KP_LEFT", PDK_KP4 },
|
|
{ "KP_5", PDK_KP5 },
|
|
{ "KP_6", PDK_KP6 },
|
|
{ "KP_RIGHT", PDK_KP6 },
|
|
{ "KP_PLUS", PDK_KP_PLUS },
|
|
{ "KP_1", PDK_KP1 },
|
|
{ "KP_END", PDK_KP1 },
|
|
{ "KP_2", PDK_KP2 },
|
|
{ "KP_DOWN", PDK_KP2 },
|
|
{ "KP_3", PDK_KP3 },
|
|
{ "KP_PAGE_DOWN", PDK_KP3 },
|
|
{ "KP_PAGEDOWN", PDK_KP3 },
|
|
{ "KP_0", PDK_KP0 },
|
|
{ "KP_INSERT", PDK_KP0 },
|
|
{ "KP_PERIOD", PDK_KP_PERIOD },
|
|
{ "KP_DELETE", PDK_KP_PERIOD },
|
|
{ "F11", PDK_F11 },
|
|
{ "F12", PDK_F12 },
|
|
{ "KP_ENTER", PDK_KP_ENTER },
|
|
{ "KP_DIVIDE", PDK_KP_DIVIDE },
|
|
{ "HOME", PDK_HOME },
|
|
{ "UP", PDK_UP },
|
|
{ "PAGE_UP", PDK_PAGEUP },
|
|
{ "PAGEUP", PDK_PAGEUP },
|
|
{ "LEFT", PDK_LEFT },
|
|
{ "RIGHT", PDK_RIGHT },
|
|
{ "END", PDK_END },
|
|
{ "DOWN", PDK_DOWN },
|
|
{ "PAGE_DOWN", PDK_PAGEDOWN },
|
|
{ "PAGEDOWN", PDK_PAGEDOWN },
|
|
{ "INSERT", PDK_INSERT },
|
|
{ "DELETE", PDK_DELETE },
|
|
{ "NUMLOCK", PDK_NUMLOCK },
|
|
{ "NUM_LOCK", PDK_NUMLOCK },
|
|
{ "CAPSLOCK", PDK_CAPSLOCK },
|
|
{ "CAPS_LOCK", PDK_CAPSLOCK },
|
|
{ "SCROLLOCK", PDK_SCROLLOCK },
|
|
{ "SCROLL_LOCK", PDK_SCROLLOCK },
|
|
{ "LSHIFT", PDK_LSHIFT },
|
|
{ "SHIFT_L", PDK_LSHIFT },
|
|
{ "RSHIFT", PDK_RSHIFT },
|
|
{ "SHIFT_R", PDK_RSHIFT },
|
|
{ "LCTRL", PDK_LCTRL },
|
|
{ "CTRL_L", PDK_LCTRL },
|
|
{ "RCTRL", PDK_RCTRL },
|
|
{ "CTRL_R", PDK_RCTRL },
|
|
{ "LALT", PDK_LALT },
|
|
{ "ALT_L", PDK_LALT },
|
|
{ "RALT", PDK_RALT },
|
|
{ "ALT_R", PDK_RALT },
|
|
{ "LMETA", PDK_LMETA },
|
|
{ "META_L", PDK_LMETA },
|
|
{ "RMETA", PDK_RMETA },
|
|
{ "META_R", PDK_RMETA },
|
|
{ "", 0 },
|
|
{ NULL, 0 } // Terminator
|
|
}; // Phew! ;)
|
|
|
|
/* Define all the external RC variables */
|
|
#include "rc-vars.h"
|
|
|
|
static const struct {
|
|
const char *name;
|
|
uint32_t flag;
|
|
} keymod[] = {
|
|
{ "shift-", KEYSYM_MOD_SHIFT },
|
|
{ "ctrl-", KEYSYM_MOD_CTRL },
|
|
{ "alt-", KEYSYM_MOD_ALT },
|
|
{ "meta-", KEYSYM_MOD_META },
|
|
{ "", 0 }
|
|
};
|
|
|
|
/* Parse a keysym.
|
|
* If the string matches one of the strings in the keysym table above
|
|
* or if it's another valid character, return the keysym, otherwise -1. */
|
|
intptr_t rc_keysym(const char *code, intptr_t *)
|
|
{
|
|
struct rc_keysym *ks = rc_keysyms;
|
|
uint32_t m = 0;
|
|
uint32_t c;
|
|
|
|
while (*code != '\0') {
|
|
size_t i;
|
|
|
|
for (i = 0; (keymod[i].name[0] != '\0'); ++i) {
|
|
size_t l = strlen(keymod[i].name);
|
|
|
|
if (strncasecmp(keymod[i].name, code, l))
|
|
continue;
|
|
m |= keymod[i].flag;
|
|
code += l;
|
|
break;
|
|
}
|
|
if (keymod[i].name[0] == '\0')
|
|
break;
|
|
}
|
|
while (ks->name != NULL) {
|
|
if (!strcasecmp(ks->name, code))
|
|
return (m | ks->keysym);
|
|
++ks;
|
|
}
|
|
/* Not in the list, so expect a single UTF-8 character instead. */
|
|
code += utf8u32(&c, (const uint8_t *)code);
|
|
if ((c == (uint32_t)-1) || (*code != '\0'))
|
|
return -1;
|
|
/* Must fit in 16 bits. */
|
|
if (c > 0xffff)
|
|
return -1;
|
|
return (m | (c & 0xffff));
|
|
}
|
|
|
|
/* Convert a keysym to text. */
|
|
char *dump_keysym(intptr_t k)
|
|
{
|
|
char buf[64];
|
|
size_t i;
|
|
size_t n;
|
|
size_t l = 0;
|
|
struct rc_keysym *ks = rc_keysyms;
|
|
|
|
buf[0] = '\0';
|
|
for (i = 0; ((keymod[i].name[0] != '\0') && (l < sizeof(buf))); ++i)
|
|
if (k & keymod[i].flag) {
|
|
n = strlen(keymod[i].name);
|
|
if (n > (sizeof(buf) - l))
|
|
n = (sizeof(buf) - l);
|
|
memcpy(&buf[l], keymod[i].name, n);
|
|
l += n;
|
|
}
|
|
k &= ~KEYSYM_MOD_MASK;
|
|
while (ks->name != NULL) {
|
|
if (ks->keysym == k) {
|
|
n = strlen(ks->name);
|
|
if (n > (sizeof(buf) - l))
|
|
n = (sizeof(buf) - l);
|
|
memcpy(&buf[l], ks->name, n);
|
|
l += n;
|
|
goto found;
|
|
}
|
|
++ks;
|
|
}
|
|
n = utf32u8(NULL, k);
|
|
if ((n == 0) || (n > (sizeof(buf) - l)))
|
|
return NULL;
|
|
utf32u8((uint8_t *)&buf[l], k);
|
|
l += n;
|
|
found:
|
|
return backslashify((uint8_t *)buf, l, 0, NULL);
|
|
}
|
|
|
|
/* Parse a boolean value.
|
|
* If the string is "yes" or "true", return 1.
|
|
* If the string is "no" or "false", return 0.
|
|
* Otherwise, just return atoi(value). */
|
|
intptr_t rc_boolean(const char *value, intptr_t *)
|
|
{
|
|
if(!strcasecmp(value, "yes") || !strcasecmp(value, "true"))
|
|
return 1;
|
|
if(!strcasecmp(value, "no") || !strcasecmp(value, "false"))
|
|
return 0;
|
|
return atoi(value);
|
|
}
|
|
|
|
static const char *joypad_axis_type[] = {
|
|
"max", "p", "positive",
|
|
"min", "n", "negative",
|
|
"between", "b", NULL
|
|
};
|
|
|
|
static const unsigned int joypad_axis_value[] = {
|
|
JS_AXIS_POSITIVE, JS_AXIS_POSITIVE, JS_AXIS_POSITIVE,
|
|
JS_AXIS_NEGATIVE, JS_AXIS_NEGATIVE, JS_AXIS_NEGATIVE,
|
|
JS_AXIS_BETWEEN, JS_AXIS_BETWEEN
|
|
};
|
|
|
|
static const char *joypad_hat_type[] = {
|
|
"centered", "up", "right", "down", "left"
|
|
};
|
|
|
|
static const unsigned int joypad_hat_value[] = {
|
|
JS_HAT_CENTERED, JS_HAT_UP, JS_HAT_RIGHT, JS_HAT_DOWN, JS_HAT_LEFT
|
|
};
|
|
|
|
/* Convert a joypad entry to text. */
|
|
char *dump_joypad(intptr_t js)
|
|
{
|
|
char *str = NULL;
|
|
unsigned int id = JS_GET_IDENTIFIER(js);
|
|
const char *arg0 = NULL;
|
|
unsigned int val0 = 0;
|
|
const char *arg1 = NULL;
|
|
unsigned int i;
|
|
|
|
if (JS_IS_BUTTON(js)) {
|
|
arg0 = "button";
|
|
val0 = JS_GET_BUTTON(js);
|
|
}
|
|
else if (JS_IS_AXIS(js)) {
|
|
arg0 = "axis";
|
|
val0 = JS_GET_AXIS(js);
|
|
for (i = 0; (i != elemof(joypad_axis_value)); ++i)
|
|
if (joypad_axis_value[i] == JS_GET_AXIS_DIR(js)) {
|
|
arg1 = joypad_axis_type[i];
|
|
break;
|
|
}
|
|
if (arg1 == NULL)
|
|
return NULL;
|
|
}
|
|
else if (JS_IS_HAT(js)) {
|
|
arg0 = "hat";
|
|
val0 = JS_GET_HAT(js);
|
|
for (i = 0; (i != elemof(joypad_hat_value)); ++i)
|
|
if (joypad_hat_value[i] == JS_GET_HAT_DIR(js)) {
|
|
arg1 = joypad_hat_type[i];
|
|
break;
|
|
}
|
|
if (arg1 == NULL)
|
|
return NULL;
|
|
}
|
|
else
|
|
return NULL;
|
|
i = 0;
|
|
while (1) {
|
|
i = snprintf(str, i, "joystick%u-%s%u%s%s",
|
|
id, arg0, val0,
|
|
(arg1 ? "-" : ""), (arg1 ? arg1 : ""));
|
|
if ((str != NULL) ||
|
|
((str = (char *)malloc(++i)) == NULL))
|
|
break;
|
|
}
|
|
return str;
|
|
}
|
|
|
|
/*
|
|
* Parse a joystick/joypad command (joy_*). The following syntaxes are
|
|
* supported:
|
|
*
|
|
* Normal buttons:
|
|
* (j|js|joystick|joypad)X-(b|button)Y
|
|
* Axes:
|
|
* (j|js|joystick|joypad)X-(a|axis)Y-(max|p|positive|min|n|negative)
|
|
* Hats:
|
|
* (j|js|joystick|joypad)X-(h|hat)Y-(up|right|down|left)
|
|
*/
|
|
intptr_t rc_joypad(const char *value, intptr_t *)
|
|
{
|
|
static const char *r_js[] = { "j", "js", "joystick", "joypad", NULL };
|
|
static const char *r_button[] = { "b", "button", NULL };
|
|
static const char *r_axis[] = { "a", "axis", NULL };
|
|
static const char **r_axis_type = joypad_axis_type;
|
|
static const unsigned int *r_axis_value = joypad_axis_value;
|
|
static const char *r_hat[] = { "h", "hat", NULL };
|
|
static const char **r_hat_type = joypad_hat_type;
|
|
static const unsigned int *r_hat_value = joypad_hat_value;
|
|
int i;
|
|
unsigned int id;
|
|
unsigned int arg;
|
|
|
|
if (*value == '\0')
|
|
return 0;
|
|
if ((i = prefix_casematch(value, r_js)) == -1)
|
|
return -1;
|
|
value += strlen(r_js[i]);
|
|
if ((i = prefix_getuint(value, &id)) == 0)
|
|
return -1;
|
|
value += i;
|
|
if (*value != '-')
|
|
return -1;
|
|
++value;
|
|
if ((i = prefix_casematch(value, r_button)) != -1) {
|
|
value += strlen(r_button[i]);
|
|
if ((i = prefix_getuint(value, &arg)) == 0)
|
|
return -1;
|
|
value += i;
|
|
if (*value != '\0')
|
|
return -1;
|
|
return JS_BUTTON(id, arg);
|
|
}
|
|
if ((i = prefix_casematch(value, r_axis)) != -1) {
|
|
value += strlen(r_axis[i]);
|
|
if ((i = prefix_getuint(value, &arg)) == 0)
|
|
return -1;
|
|
value += i;
|
|
if (*value != '-')
|
|
return -1;
|
|
++value;
|
|
if ((i = prefix_casematch(value, r_axis_type)) == -1)
|
|
return -1;
|
|
value += strlen(r_axis_type[i]);
|
|
if (*value != '\0')
|
|
return -1;
|
|
return JS_AXIS(id, arg, r_axis_value[i]);
|
|
}
|
|
if ((i = prefix_casematch(value, r_hat)) != -1) {
|
|
value += strlen(r_hat[i]);
|
|
if ((i = prefix_getuint(value, &arg)) == 0)
|
|
return -1;
|
|
value += i;
|
|
if (*value != '-')
|
|
return -1;
|
|
++value;
|
|
if ((i = prefix_casematch(value, r_hat_type)) == -1)
|
|
return -1;
|
|
value += strlen(r_hat_type[i]);
|
|
if (*value != '\0')
|
|
return -1;
|
|
return JS_HAT(id, arg, r_hat_value[i]);
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static const char *mouse_motion_type[] = {
|
|
"up", "u",
|
|
"down", "d",
|
|
"left", "l",
|
|
"right", "r",
|
|
NULL
|
|
};
|
|
|
|
/* Convert a mouse entry to text. */
|
|
char *dump_mouse(intptr_t mo)
|
|
{
|
|
char *str = NULL;
|
|
unsigned int id = MO_GET_IDENTIFIER(mo);
|
|
const char *arg0 = NULL;
|
|
unsigned int val0 = 0;
|
|
unsigned int i;
|
|
|
|
if (MO_IS_BUTTON(mo)) {
|
|
arg0 = "button";
|
|
val0 = MO_GET_BUTTON(mo);
|
|
}
|
|
else if (MO_IS_MOTION(mo)) {
|
|
val0 = MO_GET_MOTION(mo);
|
|
for (i = 0; (i != elemof(mouse_motion_type)); ++i)
|
|
if (mouse_motion_type[i][0] == (char)val0) {
|
|
arg0 = mouse_motion_type[i];
|
|
break;
|
|
}
|
|
if (arg0 == NULL)
|
|
return NULL;
|
|
}
|
|
else
|
|
return NULL;
|
|
i = 0;
|
|
while (1) {
|
|
if (MO_IS_BUTTON(mo))
|
|
i = snprintf(str, i, "mouse%u-%s%u", id, arg0, val0);
|
|
else
|
|
i = snprintf(str, i, "mouse%u-%s", id, arg0);
|
|
if ((str != NULL) ||
|
|
((str = (char *)malloc(++i)) == NULL))
|
|
break;
|
|
}
|
|
return str;
|
|
}
|
|
|
|
/*
|
|
* Parse a mouse command (mou_*). The following syntaxes are
|
|
* supported:
|
|
*
|
|
* Buttons:
|
|
* (m|mo|mouse)X-(b|button)Y
|
|
* Motions:
|
|
* (m|mo|mouse)X-(u|up|d|down|l|left|r|right)
|
|
*/
|
|
intptr_t rc_mouse(const char *value, intptr_t *)
|
|
{
|
|
static const char *r_mo[] = { "m", "mo", "mouse", NULL };
|
|
static const char *r_button[] = { "b", "button", NULL };
|
|
static const char **r_motion_type = mouse_motion_type;
|
|
int i;
|
|
unsigned int id;
|
|
unsigned int arg;
|
|
|
|
if (*value == '\0')
|
|
return 0;
|
|
if ((i = prefix_casematch(value, r_mo)) == -1)
|
|
return -1;
|
|
value += strlen(r_mo[i]);
|
|
if ((i = prefix_getuint(value, &id)) == 0)
|
|
return -1;
|
|
value += i;
|
|
if (*value != '-')
|
|
return -1;
|
|
++value;
|
|
if ((i = prefix_casematch(value, r_button)) != -1) {
|
|
value += strlen(r_button[i]);
|
|
if ((i = prefix_getuint(value, &arg)) == 0)
|
|
return -1;
|
|
value += i;
|
|
if (*value != '\0')
|
|
return -1;
|
|
return MO_BUTTON(id, arg);
|
|
}
|
|
if ((i = prefix_casematch(value, r_motion_type)) != -1) {
|
|
arg = r_motion_type[i][0];
|
|
value += strlen(r_motion_type[i]);
|
|
if (*value != '\0')
|
|
return -1;
|
|
return MO_MOTION(id, arg);
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/* Parse the CTV type. As new CTV filters get submitted expect this to grow ;)
|
|
* Current values are:
|
|
* off - No CTV
|
|
* blur - blur bitmap (from DirectX DGen), by Dave <dave@dtmnt.com>
|
|
* scanline - attenuates every other line, looks cool! by Phillip K. Hornung <redx@pknet.com>
|
|
*/
|
|
intptr_t rc_ctv(const char *value, intptr_t *)
|
|
{
|
|
for(int i = 0; i < NUM_CTV; ++i)
|
|
if(!strcasecmp(value, ctv_names[i])) return i;
|
|
return -1;
|
|
}
|
|
|
|
intptr_t rc_scaling(const char *value, intptr_t *)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; (i < NUM_SCALING); ++i)
|
|
if (!strcasecmp(value, scaling_names[i]))
|
|
return i;
|
|
return -1;
|
|
}
|
|
|
|
/* Parse CPU types */
|
|
intptr_t rc_emu_z80(const char *value, intptr_t *)
|
|
{
|
|
unsigned int i;
|
|
|
|
for (i = 0; (emu_z80_names[i] != NULL); ++i)
|
|
if (!strcasecmp(value, emu_z80_names[i]))
|
|
return i;
|
|
return -1;
|
|
}
|
|
|
|
intptr_t rc_emu_m68k(const char *value, intptr_t *)
|
|
{
|
|
unsigned int i;
|
|
|
|
for (i = 0; (emu_m68k_names[i] != NULL); ++i)
|
|
if (!strcasecmp(value, emu_m68k_names[i]))
|
|
return i;
|
|
return -1;
|
|
}
|
|
|
|
intptr_t rc_region(const char *value, intptr_t *)
|
|
{
|
|
if (strlen(value) != 1)
|
|
return -1;
|
|
switch (value[0] | 0x20) {
|
|
case 'j':
|
|
case 'x':
|
|
case 'u':
|
|
case 'e':
|
|
case ' ':
|
|
return (value[0] & ~0x20);
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
intptr_t rc_string(const char *value, intptr_t *)
|
|
{
|
|
char *val;
|
|
|
|
if ((val = strdup(value)) == NULL)
|
|
return -1;
|
|
// -1 is reserved, thus invalid. Should not happen anyway.
|
|
if ((intptr_t)val == -1)
|
|
abort();
|
|
return (intptr_t)val;
|
|
}
|
|
|
|
intptr_t rc_rom_path(const char *value, intptr_t *)
|
|
{
|
|
intptr_t r = rc_string(value, NULL);
|
|
|
|
if (r == -1)
|
|
return -1;
|
|
set_rom_path((char *)r);
|
|
return r;
|
|
}
|
|
|
|
intptr_t rc_number(const char *value, intptr_t *)
|
|
{
|
|
return strtol(value, NULL, 0);
|
|
}
|
|
|
|
intptr_t rc_soundrate(const char *value, intptr_t *)
|
|
{
|
|
long r = strtol(value, NULL, 0);
|
|
|
|
if (r < 8000)
|
|
r = 8000;
|
|
return r;
|
|
}
|
|
|
|
/* This is a table of all the RC options, the variables they affect, and the
|
|
* functions to parse their values. */
|
|
struct rc_field rc_fields[RC_FIELDS_SIZE] = {
|
|
{ "key_pad1_up", rc_keysym, &pad1_up[RCBK] },
|
|
{ "joy_pad1_up", rc_joypad, &pad1_up[RCBJ] },
|
|
{ "mou_pad1_up", rc_mouse, &pad1_up[RCBM] },
|
|
{ "key_pad1_down", rc_keysym, &pad1_down[RCBK] },
|
|
{ "joy_pad1_down", rc_joypad, &pad1_down[RCBJ] },
|
|
{ "mou_pad1_down", rc_mouse, &pad1_down[RCBM] },
|
|
{ "key_pad1_left", rc_keysym, &pad1_left[RCBK] },
|
|
{ "joy_pad1_left", rc_joypad, &pad1_left[RCBJ] },
|
|
{ "mou_pad1_left", rc_mouse, &pad1_left[RCBM] },
|
|
{ "key_pad1_right", rc_keysym, &pad1_right[RCBK] },
|
|
{ "joy_pad1_right", rc_joypad, &pad1_right[RCBJ] },
|
|
{ "mou_pad1_right", rc_mouse, &pad1_right[RCBM] },
|
|
{ "key_pad1_a", rc_keysym, &pad1_a[RCBK] },
|
|
{ "joy_pad1_a", rc_joypad, &pad1_a[RCBJ] },
|
|
{ "mou_pad1_a", rc_mouse, &pad1_a[RCBM] },
|
|
{ "key_pad1_b", rc_keysym, &pad1_b[RCBK] },
|
|
{ "joy_pad1_b", rc_joypad, &pad1_b[RCBJ] },
|
|
{ "mou_pad1_b", rc_mouse, &pad1_b[RCBM] },
|
|
{ "key_pad1_c", rc_keysym, &pad1_c[RCBK] },
|
|
{ "joy_pad1_c", rc_joypad, &pad1_c[RCBJ] },
|
|
{ "mou_pad1_c", rc_mouse, &pad1_c[RCBM] },
|
|
{ "key_pad1_x", rc_keysym, &pad1_x[RCBK] },
|
|
{ "joy_pad1_x", rc_joypad, &pad1_x[RCBJ] },
|
|
{ "mou_pad1_x", rc_mouse, &pad1_x[RCBM] },
|
|
{ "key_pad1_y", rc_keysym, &pad1_y[RCBK] },
|
|
{ "joy_pad1_y", rc_joypad, &pad1_y[RCBJ] },
|
|
{ "mou_pad1_y", rc_mouse, &pad1_y[RCBM] },
|
|
{ "key_pad1_z", rc_keysym, &pad1_z[RCBK] },
|
|
{ "joy_pad1_z", rc_joypad, &pad1_z[RCBJ] },
|
|
{ "mou_pad1_z", rc_mouse, &pad1_z[RCBM] },
|
|
{ "key_pad1_mode", rc_keysym, &pad1_mode[RCBK] },
|
|
{ "joy_pad1_mode", rc_joypad, &pad1_mode[RCBJ] },
|
|
{ "mou_pad1_mode", rc_mouse, &pad1_mode[RCBM] },
|
|
{ "key_pad1_start", rc_keysym, &pad1_start[RCBK] },
|
|
{ "joy_pad1_start", rc_joypad, &pad1_start[RCBJ] },
|
|
{ "mou_pad1_start", rc_mouse, &pad1_start[RCBM] },
|
|
{ "key_pad2_up", rc_keysym, &pad2_up[RCBK] },
|
|
{ "joy_pad2_up", rc_joypad, &pad2_up[RCBJ] },
|
|
{ "mou_pad2_up", rc_mouse, &pad2_up[RCBM] },
|
|
{ "key_pad2_down", rc_keysym, &pad2_down[RCBK] },
|
|
{ "joy_pad2_down", rc_joypad, &pad2_down[RCBJ] },
|
|
{ "mou_pad2_down", rc_mouse, &pad2_down[RCBM] },
|
|
{ "key_pad2_left", rc_keysym, &pad2_left[RCBK] },
|
|
{ "joy_pad2_left", rc_joypad, &pad2_left[RCBJ] },
|
|
{ "mou_pad2_left", rc_mouse, &pad2_left[RCBM] },
|
|
{ "key_pad2_right", rc_keysym, &pad2_right[RCBK] },
|
|
{ "joy_pad2_right", rc_joypad, &pad2_right[RCBJ] },
|
|
{ "mou_pad2_right", rc_mouse, &pad2_right[RCBM] },
|
|
{ "key_pad2_a", rc_keysym, &pad2_a[RCBK] },
|
|
{ "joy_pad2_a", rc_joypad, &pad2_a[RCBJ] },
|
|
{ "mou_pad2_a", rc_mouse, &pad2_a[RCBM] },
|
|
{ "key_pad2_b", rc_keysym, &pad2_b[RCBK] },
|
|
{ "joy_pad2_b", rc_joypad, &pad2_b[RCBJ] },
|
|
{ "mou_pad2_b", rc_mouse, &pad2_b[RCBM] },
|
|
{ "key_pad2_c", rc_keysym, &pad2_c[RCBK] },
|
|
{ "joy_pad2_c", rc_joypad, &pad2_c[RCBJ] },
|
|
{ "mou_pad2_c", rc_mouse, &pad2_c[RCBM] },
|
|
{ "key_pad2_x", rc_keysym, &pad2_x[RCBK] },
|
|
{ "joy_pad2_x", rc_joypad, &pad2_x[RCBJ] },
|
|
{ "mou_pad2_x", rc_mouse, &pad2_x[RCBM] },
|
|
{ "key_pad2_y", rc_keysym, &pad2_y[RCBK] },
|
|
{ "joy_pad2_y", rc_joypad, &pad2_y[RCBJ] },
|
|
{ "mou_pad2_y", rc_mouse, &pad2_y[RCBM] },
|
|
{ "key_pad2_z", rc_keysym, &pad2_z[RCBK] },
|
|
{ "joy_pad2_z", rc_joypad, &pad2_z[RCBJ] },
|
|
{ "mou_pad2_z", rc_mouse, &pad2_z[RCBM] },
|
|
{ "key_pad2_mode", rc_keysym, &pad2_mode[RCBK] },
|
|
{ "joy_pad2_mode", rc_joypad, &pad2_mode[RCBJ] },
|
|
{ "mou_pad2_mode", rc_mouse, &pad2_mode[RCBM] },
|
|
{ "key_pad2_start", rc_keysym, &pad2_start[RCBK] },
|
|
{ "joy_pad2_start", rc_joypad, &pad2_start[RCBJ] },
|
|
{ "mou_pad2_start", rc_mouse, &pad2_start[RCBM] },
|
|
{ "key_pico_pen_up", rc_keysym, &pico_pen_up[RCBK] },
|
|
{ "joy_pico_pen_up", rc_joypad, &pico_pen_up[RCBJ] },
|
|
{ "mou_pico_pen_up", rc_mouse, &pico_pen_up[RCBM] },
|
|
{ "key_pico_pen_down", rc_keysym, &pico_pen_down[RCBK] },
|
|
{ "joy_pico_pen_down", rc_joypad, &pico_pen_down[RCBJ] },
|
|
{ "mou_pico_pen_down", rc_mouse, &pico_pen_down[RCBM] },
|
|
{ "key_pico_pen_left", rc_keysym, &pico_pen_left[RCBK] },
|
|
{ "joy_pico_pen_left", rc_joypad, &pico_pen_left[RCBJ] },
|
|
{ "mou_pico_pen_left", rc_mouse, &pico_pen_left[RCBM] },
|
|
{ "key_pico_pen_right", rc_keysym, &pico_pen_right[RCBK] },
|
|
{ "joy_pico_pen_right", rc_joypad, &pico_pen_right[RCBJ] },
|
|
{ "mou_pico_pen_right", rc_mouse, &pico_pen_right[RCBM] },
|
|
{ "key_pico_pen_button", rc_keysym, &pico_pen_button[RCBK] },
|
|
{ "joy_pico_pen_button", rc_joypad, &pico_pen_button[RCBJ] },
|
|
{ "mou_pico_pen_button", rc_mouse, &pico_pen_button[RCBM] },
|
|
{ "int_pico_pen_stride", rc_number, &pico_pen_stride },
|
|
{ "int_pico_pen_delay", rc_number, &pico_pen_delay },
|
|
{ "key_fix_checksum", rc_keysym, &dgen_fix_checksum[RCBK] },
|
|
{ "joy_fix_checksum", rc_joypad, &dgen_fix_checksum[RCBJ] },
|
|
{ "mou_fix_checksum", rc_mouse, &dgen_fix_checksum[RCBM] },
|
|
{ "key_quit", rc_keysym, &dgen_quit[RCBK] },
|
|
{ "joy_quit", rc_joypad, &dgen_quit[RCBJ] },
|
|
{ "mou_quit", rc_mouse, &dgen_quit[RCBM] },
|
|
{ "key_craptv_toggle", rc_keysym, &dgen_craptv_toggle[RCBK] },
|
|
{ "joy_craptv_toggle", rc_joypad, &dgen_craptv_toggle[RCBJ] },
|
|
{ "mou_craptv_toggle", rc_mouse, &dgen_craptv_toggle[RCBM] },
|
|
{ "key_scaling_toggle", rc_keysym, &dgen_scaling_toggle[RCBK] },
|
|
{ "joy_scaling_toggle", rc_joypad, &dgen_scaling_toggle[RCBJ] },
|
|
{ "mou_scaling_toggle", rc_mouse, &dgen_scaling_toggle[RCBM] },
|
|
{ "key_screenshot", rc_keysym, &dgen_screenshot[RCBK] },
|
|
{ "joy_screenshot", rc_joypad, &dgen_screenshot[RCBJ] },
|
|
{ "mou_screenshot", rc_mouse, &dgen_screenshot[RCBM] },
|
|
{ "key_reset", rc_keysym, &dgen_reset[RCBK] },
|
|
{ "joy_reset", rc_joypad, &dgen_reset[RCBJ] },
|
|
{ "mou_reset", rc_mouse, &dgen_reset[RCBM] },
|
|
{ "key_slot_0", rc_keysym, &dgen_slot_0[RCBK] },
|
|
{ "joy_slot_0", rc_joypad, &dgen_slot_0[RCBJ] },
|
|
{ "mou_slot_0", rc_mouse, &dgen_slot_0[RCBM] },
|
|
{ "key_slot_1", rc_keysym, &dgen_slot_1[RCBK] },
|
|
{ "joy_slot_1", rc_joypad, &dgen_slot_1[RCBJ] },
|
|
{ "mou_slot_1", rc_mouse, &dgen_slot_1[RCBM] },
|
|
{ "key_slot_2", rc_keysym, &dgen_slot_2[RCBK] },
|
|
{ "joy_slot_2", rc_joypad, &dgen_slot_2[RCBJ] },
|
|
{ "mou_slot_2", rc_mouse, &dgen_slot_2[RCBM] },
|
|
{ "key_slot_3", rc_keysym, &dgen_slot_3[RCBK] },
|
|
{ "joy_slot_3", rc_joypad, &dgen_slot_3[RCBJ] },
|
|
{ "mou_slot_3", rc_mouse, &dgen_slot_3[RCBM] },
|
|
{ "key_slot_4", rc_keysym, &dgen_slot_4[RCBK] },
|
|
{ "joy_slot_4", rc_joypad, &dgen_slot_4[RCBJ] },
|
|
{ "mou_slot_4", rc_mouse, &dgen_slot_4[RCBM] },
|
|
{ "key_slot_5", rc_keysym, &dgen_slot_5[RCBK] },
|
|
{ "joy_slot_5", rc_joypad, &dgen_slot_5[RCBJ] },
|
|
{ "mou_slot_5", rc_mouse, &dgen_slot_5[RCBM] },
|
|
{ "key_slot_6", rc_keysym, &dgen_slot_6[RCBK] },
|
|
{ "joy_slot_6", rc_joypad, &dgen_slot_6[RCBJ] },
|
|
{ "mou_slot_6", rc_mouse, &dgen_slot_6[RCBM] },
|
|
{ "key_slot_7", rc_keysym, &dgen_slot_7[RCBK] },
|
|
{ "joy_slot_7", rc_joypad, &dgen_slot_7[RCBJ] },
|
|
{ "mou_slot_7", rc_mouse, &dgen_slot_7[RCBM] },
|
|
{ "key_slot_8", rc_keysym, &dgen_slot_8[RCBK] },
|
|
{ "joy_slot_8", rc_joypad, &dgen_slot_8[RCBJ] },
|
|
{ "mou_slot_8", rc_mouse, &dgen_slot_8[RCBM] },
|
|
{ "key_slot_9", rc_keysym, &dgen_slot_9[RCBK] },
|
|
{ "joy_slot_9", rc_joypad, &dgen_slot_9[RCBJ] },
|
|
{ "mou_slot_9", rc_mouse, &dgen_slot_9[RCBM] },
|
|
{ "key_slot_next", rc_keysym, &dgen_slot_next[RCBK] },
|
|
{ "joy_slot_next", rc_joypad, &dgen_slot_next[RCBJ] },
|
|
{ "mou_slot_next", rc_mouse, &dgen_slot_next[RCBM] },
|
|
{ "key_slot_prev", rc_keysym, &dgen_slot_prev[RCBK] },
|
|
{ "joy_slot_prev", rc_joypad, &dgen_slot_prev[RCBJ] },
|
|
{ "mou_slot_prev", rc_mouse, &dgen_slot_prev[RCBM] },
|
|
{ "key_save", rc_keysym, &dgen_save[RCBK] },
|
|
{ "joy_save", rc_joypad, &dgen_save[RCBJ] },
|
|
{ "mou_save", rc_mouse, &dgen_save[RCBM] },
|
|
{ "key_load", rc_keysym, &dgen_load[RCBK] },
|
|
{ "joy_load", rc_joypad, &dgen_load[RCBJ] },
|
|
{ "mou_load", rc_mouse, &dgen_load[RCBM] },
|
|
{ "key_z80_toggle", rc_keysym, &dgen_z80_toggle[RCBK] },
|
|
{ "joy_z80_toggle", rc_joypad, &dgen_z80_toggle[RCBJ] },
|
|
{ "mou_z80_toggle", rc_mouse, &dgen_z80_toggle[RCBM] },
|
|
{ "key_cpu_toggle", rc_keysym, &dgen_cpu_toggle[RCBK] },
|
|
{ "joy_cpu_toggle", rc_joypad, &dgen_cpu_toggle[RCBJ] },
|
|
{ "mou_cpu_toggle", rc_mouse, &dgen_cpu_toggle[RCBM] },
|
|
{ "key_stop", rc_keysym, &dgen_stop[RCBK] },
|
|
{ "joy_stop", rc_joypad, &dgen_stop[RCBJ] },
|
|
{ "mou_stop", rc_mouse, &dgen_stop[RCBM] },
|
|
{ "key_game_genie", rc_keysym, &dgen_game_genie[RCBK] },
|
|
{ "joy_game_genie", rc_joypad, &dgen_game_genie[RCBJ] },
|
|
{ "mou_game_genie", rc_mouse, &dgen_game_genie[RCBM] },
|
|
{ "key_fullscreen_toggle", rc_keysym, &dgen_fullscreen_toggle[RCBK] },
|
|
{ "joy_fullscreen_toggle", rc_joypad, &dgen_fullscreen_toggle[RCBJ] },
|
|
{ "mou_fullscreen_toggle", rc_mouse, &dgen_fullscreen_toggle[RCBM] },
|
|
{ "key_debug_enter", rc_keysym, &dgen_debug_enter[RCBK] },
|
|
{ "joy_debug_enter", rc_joypad, &dgen_debug_enter[RCBJ] },
|
|
{ "mou_debug_enter", rc_mouse, &dgen_debug_enter[RCBM] },
|
|
{ "key_prompt", rc_keysym, &dgen_prompt[RCBK] },
|
|
{ "joy_prompt", rc_joypad, &dgen_prompt[RCBJ] },
|
|
{ "mou_prompt", rc_mouse, &dgen_prompt[RCBM] },
|
|
{ "bool_vdp_hide_plane_a", rc_boolean, &dgen_vdp_hide_plane_a },
|
|
{ "bool_vdp_hide_plane_b", rc_boolean, &dgen_vdp_hide_plane_b },
|
|
{ "bool_vdp_hide_plane_w", rc_boolean, &dgen_vdp_hide_plane_w },
|
|
{ "bool_vdp_hide_sprites", rc_boolean, &dgen_vdp_hide_sprites },
|
|
{ "bool_vdp_sprites_boxing", rc_boolean, &dgen_vdp_sprites_boxing },
|
|
{ "int_vdp_sprites_boxing_fg", rc_number, &dgen_vdp_sprites_boxing_fg },
|
|
{ "int_vdp_sprites_boxing_bg", rc_number, &dgen_vdp_sprites_boxing_bg },
|
|
{ "bool_autoload", rc_boolean, &dgen_autoload },
|
|
{ "bool_autosave", rc_boolean, &dgen_autosave },
|
|
{ "bool_autoconf", rc_boolean, &dgen_autoconf },
|
|
{ "bool_frameskip", rc_boolean, &dgen_frameskip },
|
|
{ "bool_show_carthead", rc_boolean, &dgen_show_carthead },
|
|
{ "str_rom_path", rc_rom_path,
|
|
(intptr_t *)((void *)&dgen_rom_path) }, // SH
|
|
{ "bool_raw_screenshots", rc_boolean, &dgen_raw_screenshots },
|
|
{ "ctv_craptv_startup", rc_ctv, &dgen_craptv }, // SH
|
|
{ "scaling_startup", rc_scaling, &dgen_scaling }, // SH
|
|
{ "emu_z80_startup", rc_emu_z80, &dgen_emu_z80 }, // SH
|
|
{ "emu_m68k_startup", rc_emu_m68k, &dgen_emu_m68k }, // SH
|
|
{ "bool_sound", rc_boolean, &dgen_sound }, // SH
|
|
{ "int_soundrate", rc_soundrate, &dgen_soundrate }, // SH
|
|
{ "int_soundsegs", rc_number, &dgen_soundsegs }, // SH
|
|
{ "int_soundsamples", rc_number, &dgen_soundsamples }, // SH
|
|
{ "int_volume", rc_number, &dgen_volume },
|
|
{ "key_volume_inc", rc_keysym, &dgen_volume_inc[RCBK] },
|
|
{ "joy_volume_inc", rc_joypad, &dgen_volume_inc[RCBJ] },
|
|
{ "mou_volume_inc", rc_mouse, &dgen_volume_inc[RCBM] },
|
|
{ "key_volume_dec", rc_keysym, &dgen_volume_dec[RCBK] },
|
|
{ "joy_volume_dec", rc_joypad, &dgen_volume_dec[RCBJ] },
|
|
{ "mou_volume_dec", rc_mouse, &dgen_volume_dec[RCBM] },
|
|
{ "bool_mjazz", rc_boolean, &dgen_mjazz }, // SH
|
|
{ "int_nice", rc_number, &dgen_nice },
|
|
{ "int_hz", rc_number, &dgen_hz }, // SH
|
|
{ "bool_pal", rc_boolean, &dgen_pal }, // SH
|
|
{ "region", rc_region, &dgen_region }, // SH
|
|
{ "str_region_order", rc_string,
|
|
(intptr_t *)((void *)&dgen_region_order) },
|
|
{ "bool_fps", rc_boolean, &dgen_fps },
|
|
{ "bool_buttons", rc_boolean, &dgen_buttons },
|
|
{ "bool_fullscreen", rc_boolean, &dgen_fullscreen }, // SH
|
|
{ "int_info_height", rc_number, &dgen_info_height }, // SH
|
|
{ "int_width", rc_number, &dgen_width }, // SH
|
|
{ "int_height", rc_number, &dgen_height }, // SH
|
|
{ "int_scale", rc_number, &dgen_scale }, // SH
|
|
{ "int_scale_x", rc_number, &dgen_x_scale }, // SH
|
|
{ "int_scale_y", rc_number, &dgen_y_scale }, // SH
|
|
{ "int_depth", rc_number, &dgen_depth }, // SH
|
|
{ "bool_aspect", rc_boolean, &dgen_aspect }, // SH
|
|
{ "bool_swab", rc_boolean, &dgen_swab }, // SH
|
|
{ "bool_opengl", rc_boolean, &dgen_opengl }, // SH
|
|
{ "bool_opengl_stretch", rc_boolean, &dgen_opengl_stretch }, // SH
|
|
// deprecated, use bool_aspect
|
|
{ "bool_opengl_aspect", rc_boolean, &dgen_aspect },
|
|
// deprecated, use int_width
|
|
{ "int_opengl_width", rc_number, &dgen_width },
|
|
// deprecated, use int_height
|
|
{ "int_opengl_height", rc_number, &dgen_height },
|
|
{ "bool_opengl_linear", rc_boolean, &dgen_opengl_linear }, // SH
|
|
{ "bool_opengl_32bit", rc_boolean, &dgen_opengl_32bit }, // SH
|
|
// deprecated, use bool_swab
|
|
{ "bool_opengl_swap", rc_boolean, &dgen_swab }, // SH
|
|
{ "bool_opengl_square", rc_boolean, &dgen_opengl_square }, // SH
|
|
{ "bool_doublebuffer", rc_boolean, &dgen_doublebuffer }, // SH
|
|
{ "bool_screen_thread", rc_boolean, &dgen_screen_thread }, // SH
|
|
{ "bool_joystick", rc_boolean, &dgen_joystick }, // SH
|
|
{ "int_mouse_delay", rc_number, &dgen_mouse_delay },
|
|
{ NULL, NULL, NULL }
|
|
};
|
|
|
|
struct rc_binding rc_binding_head = {
|
|
&rc_binding_head,
|
|
&rc_binding_head,
|
|
{ { false, RCBK, 0, } },
|
|
NULL,
|
|
NULL
|
|
};
|
|
|
|
static void rc_binding_cleanup(void)
|
|
{
|
|
struct rc_binding *rcb = rc_binding_head.next;
|
|
struct rc_binding *next;
|
|
|
|
while (rcb != &rc_binding_head) {
|
|
next = rcb->next;
|
|
assert(rcb->to != NULL);
|
|
assert((intptr_t)rcb->to != -1);
|
|
free(rcb->to);
|
|
#ifndef NDEBUG
|
|
memset(rcb, 0x66, sizeof(*rcb));
|
|
#endif
|
|
free(rcb);
|
|
rcb = next;
|
|
}
|
|
}
|
|
|
|
struct rc_field *rc_binding_add(const char *rc, const char *to)
|
|
{
|
|
static bool registered = false;
|
|
size_t rc_sz = (strlen(rc) + 1);
|
|
struct rc_field *rcf = rc_fields;
|
|
struct rc_binding *rcb;
|
|
struct rc_binding_item item[elemof(rcb->item)];
|
|
unsigned int i;
|
|
const char *s;
|
|
size_t off;
|
|
char *new_to;
|
|
|
|
if ((registered == false) && (atexit(rc_binding_cleanup) == 0))
|
|
registered = true;
|
|
// Check if the RC name looks like a valid binding.
|
|
for (off = 0; (rc[off] != '\0'); ++off) {
|
|
if (RC_BIND_PREFIX[off] == '\0')
|
|
break;
|
|
if (rc[off] != RC_BIND_PREFIX[off])
|
|
return NULL;
|
|
}
|
|
if (rc[off] == '\0')
|
|
return NULL;
|
|
// Extract multiple keysyms or joypad codes from RC name.
|
|
memset(item, 0, sizeof(item));
|
|
s = &rc[off];
|
|
i = 0;
|
|
while (s += strspn(s, " \t\n"), off = strcspn(s, " \t\n")) {
|
|
char tmp[64];
|
|
intptr_t code;
|
|
enum rc_binding_type type;
|
|
|
|
if (i == elemof(item))
|
|
return NULL;
|
|
snprintf(tmp, sizeof(tmp), "%.*s", (int)off, s);
|
|
if ((type = RCBJ, ((code = rc_joypad(tmp, NULL)) == -1)) &&
|
|
(type = RCBK, ((code = rc_keysym(tmp, NULL)) == -1)) &&
|
|
(type = RCBM, ((code = rc_mouse(tmp, NULL)) == -1)))
|
|
return NULL;
|
|
item[i].assigned = true;
|
|
item[i].type = type;
|
|
item[i].code = code;
|
|
++i;
|
|
s += off;
|
|
}
|
|
// Find a free entry in rc_fields[].
|
|
while (rcf->fieldname != NULL)
|
|
++rcf;
|
|
if ((rcf - rc_fields) == (elemof(rc_fields) - 1))
|
|
return NULL;
|
|
assert(rcf->parser == NULL);
|
|
assert(rcf->variable == NULL);
|
|
// Allocate binding.
|
|
if ((rcb = (struct rc_binding *)malloc(sizeof(*rcb) + rc_sz)) == NULL)
|
|
return NULL;
|
|
if ((new_to = strdup(to)) == NULL) {
|
|
free(new_to);
|
|
free(rcb);
|
|
return NULL;
|
|
}
|
|
// -1 is reserved, thus invalid. Should not happen anyway.
|
|
if ((intptr_t)new_to == -1)
|
|
abort();
|
|
// Configure binding.
|
|
rcb->prev = rc_binding_head.prev;
|
|
rcb->next = &rc_binding_head;
|
|
rcb->prev->next = rcb;
|
|
rcb->next->prev = rcb;
|
|
memcpy(rcb->item, item, sizeof(rcb->item));
|
|
rcb->rc = ((char *)rcb + sizeof(*rcb));
|
|
rcb->to = new_to;
|
|
memcpy(rcb->rc, rc, rc_sz);
|
|
// Configure RC field.
|
|
rcf->fieldname = rcb->rc;
|
|
rcf->parser = rc_bind;
|
|
rcf->variable = (intptr_t *)((void *)&rcb->to);
|
|
return rcf;
|
|
}
|
|
|
|
void rc_binding_del(rc_field *rcf)
|
|
{
|
|
struct rc_binding *rcb =
|
|
containerof(rcf->variable, struct rc_binding, to);
|
|
|
|
assert(rcf >= &rc_fields[0]);
|
|
assert(rcf < &rc_fields[elemof(rc_fields)]);
|
|
assert(rcf->fieldname != NULL);
|
|
assert(rcf->parser != NULL);
|
|
assert(rcf->variable != NULL);
|
|
if (rcf->parser != rc_bind)
|
|
return;
|
|
assert(rcb != &rc_binding_head);
|
|
// Clean-up.
|
|
rcb->prev->next = rcb->next;
|
|
rcb->next->prev = rcb->prev;
|
|
assert(rcb->to != NULL);
|
|
assert((intptr_t)rcb->to != -1);
|
|
free(rcb->to);
|
|
#ifndef NDEBUG
|
|
memset(rcb, 0x88, (sizeof(*rcb) + strlen(rcb->rc) + 1));
|
|
#endif
|
|
free(rcb);
|
|
// Shift the next entries.
|
|
do {
|
|
memcpy(rcf, (rcf + 1), sizeof(*rcf));
|
|
++rcf;
|
|
}
|
|
while (rcf->fieldname != NULL);
|
|
assert(rcf < &rc_fields[elemof(rc_fields)]);
|
|
}
|
|
|
|
intptr_t rc_bind(const char *value, intptr_t *variable)
|
|
{
|
|
struct rc_binding *rcb = containerof(variable, struct rc_binding, to);
|
|
char *to;
|
|
|
|
assert(*variable != -1);
|
|
assert(rcb != NULL);
|
|
assert(rcb->prev != NULL);
|
|
assert(rcb->next != NULL);
|
|
assert(rcb->rc != NULL);
|
|
assert(rcb->to != NULL);
|
|
assert((intptr_t)rcb->to != -1);
|
|
if ((to = strdup(value)) == NULL) {
|
|
free(to);
|
|
// Get the previous value.
|
|
to = rcb->to;
|
|
}
|
|
// -1 is reserved, thus invalid. Should not happen anyway.
|
|
else if ((intptr_t)to == -1)
|
|
abort();
|
|
else
|
|
free(rcb->to);
|
|
rcb->to = NULL; // Will be updated by the return value.
|
|
// This function must always return a valid pointer.
|
|
return (intptr_t)to;
|
|
}
|
|
|
|
/* Replace unprintable characters */
|
|
static char *strclean(char *s)
|
|
{
|
|
size_t i;
|
|
|
|
for (i = 0; (s[i] != '\0'); ++i)
|
|
if (!isprint(s[i]))
|
|
s[i] = '?';
|
|
return s;
|
|
}
|
|
|
|
/* This is for cleaning up rc_str fields at exit */
|
|
struct rc_str *rc_str_list = NULL;
|
|
|
|
void rc_str_cleanup(void)
|
|
{
|
|
struct rc_str *rs = rc_str_list;
|
|
|
|
while (rs != NULL) {
|
|
if (rs->val == rs->alloc)
|
|
rs->val = NULL;
|
|
free(rs->alloc);
|
|
rs->alloc = NULL;
|
|
rs = rs->next;
|
|
}
|
|
}
|
|
|
|
/* Parse the rc file */
|
|
void parse_rc(FILE *file, const char *name)
|
|
{
|
|
struct rc_field *rc_field = NULL;
|
|
intptr_t potential;
|
|
int overflow = 0;
|
|
size_t len;
|
|
size_t parse;
|
|
ckvp_t ckvp = CKVP_INIT;
|
|
char buf[1024];
|
|
|
|
if ((file == NULL) || (name == NULL))
|
|
return;
|
|
read:
|
|
len = fread(buf, 1, sizeof(buf), file);
|
|
/* Check for read errors first */
|
|
if ((len == 0) && (ferror(file))) {
|
|
fprintf(stderr, "rc: %s: %s\n", name, strerror(errno));
|
|
return;
|
|
}
|
|
/* The goal is to make an extra pass with len == 0 when feof(file) */
|
|
parse = 0;
|
|
parse:
|
|
parse += ckvp_parse(&ckvp, (len - parse), &(buf[parse]));
|
|
switch (ckvp.state) {
|
|
case CKVP_NONE:
|
|
/* Nothing to do */
|
|
break;
|
|
case CKVP_OUT_FULL:
|
|
/*
|
|
Buffer is full, field is probably too large. We don't want
|
|
to report it more than once, so just store a flag for now.
|
|
*/
|
|
overflow = 1;
|
|
break;
|
|
case CKVP_OUT_KEY:
|
|
/* Got a key */
|
|
if (overflow) {
|
|
fprintf(stderr, "rc: %s:%u:%u: key field too large\n",
|
|
name, ckvp.line, ckvp.column);
|
|
rc_field = NULL;
|
|
overflow = 0;
|
|
break;
|
|
}
|
|
/* Find the related rc_field in rc_fields */
|
|
assert(ckvp.out_size < sizeof(ckvp.out));
|
|
ckvp.out[(ckvp.out_size)] = '\0';
|
|
for (rc_field = rc_fields; (rc_field->fieldname != NULL);
|
|
++rc_field)
|
|
if (!strcasecmp(rc_field->fieldname, ckvp.out))
|
|
goto key_over;
|
|
/* Try to add it as a new binding. */
|
|
if ((rc_field = rc_binding_add(ckvp.out, "")) != NULL)
|
|
goto key_over;
|
|
fprintf(stderr, "rc: %s:%u:%u: unknown key `%s'\n",
|
|
name, ckvp.line, ckvp.column, strclean(ckvp.out));
|
|
key_over:
|
|
break;
|
|
case CKVP_OUT_VALUE:
|
|
/* Got a value */
|
|
if (overflow) {
|
|
fprintf(stderr, "rc: %s:%u:%u: value field too large\n",
|
|
name, ckvp.line, ckvp.column);
|
|
overflow = 0;
|
|
break;
|
|
}
|
|
assert(ckvp.out_size < sizeof(ckvp.out));
|
|
ckvp.out[(ckvp.out_size)] = '\0';
|
|
if ((rc_field == NULL) || (rc_field->fieldname == NULL))
|
|
break;
|
|
potential = rc_field->parser(ckvp.out, rc_field->variable);
|
|
/* If we got a bad value, discard and warn user */
|
|
if ((rc_field->parser != rc_number) && (potential == -1))
|
|
fprintf(stderr,
|
|
"rc: %s:%u:%u: invalid value for key"
|
|
" `%s': `%s'\n",
|
|
name, ckvp.line, ckvp.column,
|
|
rc_field->fieldname, strclean(ckvp.out));
|
|
else if ((rc_field->parser == rc_string) ||
|
|
(rc_field->parser == rc_rom_path)) {
|
|
struct rc_str *rs =
|
|
(struct rc_str *)rc_field->variable;
|
|
|
|
if (rc_str_list == NULL) {
|
|
atexit(rc_str_cleanup);
|
|
rc_str_list = rs;
|
|
}
|
|
else if (rs->alloc == NULL) {
|
|
rs->next = rc_str_list;
|
|
rc_str_list = rs;
|
|
}
|
|
else
|
|
free(rs->alloc);
|
|
rs->alloc = (char *)potential;
|
|
rs->val = rs->alloc;
|
|
}
|
|
else if ((rc_field->parser == rc_region) &&
|
|
(rc_field->variable == &dgen_region)) {
|
|
/*
|
|
Another special case: updating region also updates
|
|
PAL and Hz settings.
|
|
*/
|
|
*(rc_field->variable) = potential;
|
|
if (*(rc_field->variable)) {
|
|
int hz;
|
|
int pal;
|
|
|
|
md::region_info(dgen_region, &pal, &hz,
|
|
0, 0, 0);
|
|
dgen_hz = hz;
|
|
dgen_pal = pal;
|
|
}
|
|
}
|
|
else
|
|
*(rc_field->variable) = potential;
|
|
break;
|
|
case CKVP_ERROR:
|
|
default:
|
|
fprintf(stderr, "rc: %s:%u:%u: syntax error, aborting\n",
|
|
name, ckvp.line, ckvp.column);
|
|
return;
|
|
}
|
|
/* Not done with the current buffer? */
|
|
if (parse != len)
|
|
goto parse;
|
|
/* If len != 0, try to read once again */
|
|
if (len != 0)
|
|
goto read;
|
|
}
|
|
|
|
/* Dump the rc file */
|
|
void dump_rc(FILE *file)
|
|
{
|
|
const struct rc_field *rc = rc_fields;
|
|
|
|
while (rc->fieldname != NULL) {
|
|
intptr_t val = *rc->variable;
|
|
char *s = backslashify((const uint8_t *)rc->fieldname,
|
|
strlen(rc->fieldname), 0, NULL);
|
|
|
|
if (s == NULL) {
|
|
++rc;
|
|
continue;
|
|
}
|
|
fprintf(file, "%s = ", s);
|
|
free(s);
|
|
if ((rc->parser == rc_number) ||
|
|
(rc->parser == rc_soundrate))
|
|
fprintf(file, "%ld", (long)val);
|
|
else if (rc->parser == rc_keysym) {
|
|
char *ks = dump_keysym(val);
|
|
|
|
if (ks != NULL) {
|
|
fprintf(file, "\"%s\"", ks);
|
|
free(ks);
|
|
}
|
|
else
|
|
fputs("''", file);
|
|
}
|
|
else if (rc->parser == rc_boolean)
|
|
fprintf(file, "%s", ((val) ? "true" : "false"));
|
|
else if (rc->parser == rc_joypad) {
|
|
char *js = dump_joypad(val);
|
|
|
|
if (js != NULL) {
|
|
fprintf(file, "\"%s\"", js);
|
|
free(js);
|
|
}
|
|
else
|
|
fputs("''", file);
|
|
}
|
|
else if (rc->parser == rc_mouse) {
|
|
char *mo = dump_mouse(val);
|
|
|
|
if (mo != NULL) {
|
|
fprintf(file, "\"%s\"", mo);
|
|
free(mo);
|
|
}
|
|
else
|
|
fputs("''", file);
|
|
}
|
|
else if (rc->parser == rc_ctv)
|
|
fprintf(file, "%s", ctv_names[val]);
|
|
else if (rc->parser == rc_scaling)
|
|
fprintf(file, "\"%s\"", scaling_names[val]);
|
|
else if (rc->parser == rc_emu_z80)
|
|
fprintf(file, "%s", emu_z80_names[val]);
|
|
else if (rc->parser == rc_emu_m68k)
|
|
fprintf(file, "%s", emu_m68k_names[val]);
|
|
else if (rc->parser == rc_region) {
|
|
if (isgraph((char)val))
|
|
fputc((char)val, file);
|
|
else
|
|
fputs("' '", file);
|
|
}
|
|
else if ((rc->parser == rc_string) ||
|
|
(rc->parser == rc_rom_path)) {
|
|
struct rc_str *rs = (struct rc_str *)rc->variable;
|
|
|
|
if ((rs->val == NULL) ||
|
|
((s = backslashify
|
|
((const uint8_t *)rs->val,
|
|
strlen(rs->val), 0, NULL)) == NULL))
|
|
fprintf(file, "\"\"");
|
|
else {
|
|
fprintf(file, "\"%s\"", s);
|
|
free(s);
|
|
}
|
|
}
|
|
else if (rc->parser == rc_bind) {
|
|
s = *(char **)rc->variable;
|
|
assert(s != NULL);
|
|
assert((intptr_t)s != -1);
|
|
s = backslashify((uint8_t *)s, strlen(s), 0, NULL);
|
|
fputc('"', file);
|
|
if (s != NULL) {
|
|
fputs(s, file);
|
|
free(s);
|
|
}
|
|
fputc('"', file);
|
|
}
|
|
fputs("\n", file);
|
|
++rc;
|
|
}
|
|
}
|