XenOn/kolibrios-fun
1
1
Fork 0
forked from KolibriOS/kolibrios
Code Pull Requests Wiki Activity
5bf9207b4b
kolibrios-fun/programs/emulator/dgen-sdl-1.33/rc.cpp

1236 lines
35 KiB
C++
Raw Normal View History

Upload DGEN port source git-svn-id: svn://kolibrios.org@9837 a494cfbc-eb01-0410-851d-a64ba20cac60
2022-06-15 20:25:17 +02:00
// 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;
}
}
Copy Permalink