80486DX2-66/86Box-fork
1
0
Fork 0
Code Issues Pull Requests Activity
Files
c6f469884f43ea79637f965052a32d6639a029af
86Box-fork/src/config.c

2662 lines
66 KiB
C
Raw Blame History

/*
* 86Box A hypervisor and IBM PC system emulator that specializes in
* running old operating systems and software designed for IBM
* PC systems and compatibles from 1981 through fairly recent
* system designs based on the PCI bus.
*
* This file is part of the 86Box distribution.
*
* Configuration file handler.
*
*
*
* Authors: Sarah Walker,
* Miran Grca, <mgrca8@gmail.com>
* Fred N. van Kempen, <decwiz@yahoo.com>
* Overdoze,
* David Hrdlička, <hrdlickadavid@outlook.com>
*
* Copyright 2008-2019 Sarah Walker.
* Copyright 2016-2019 Miran Grca.
* Copyright 2017-2019 Fred N. van Kempen.
* Copyright 2018,2019 David Hrdlička.
*
* NOTE: Forcing config files to be in Unicode encoding breaks
* it on Windows XP, and possibly also Vista. Use the
* -DANSI_CFG for use on these systems.
*/
#include <inttypes.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include <wchar.h>
#define HAVE_STDARG_H
#include <86box/86box.h>
#include "cpu.h"
#include <86box/device.h>
#include <86box/timer.h>
#include <86box/nvr.h>
#include <86box/config.h>
#include <86box/isamem.h>
#include <86box/isartc.h>
#include <86box/lpt.h>
#include <86box/hdd.h>
#include <86box/hdc.h>
#include <86box/hdc_ide.h>
#include <86box/fdd.h>
#include <86box/fdc.h>
#include <86box/fdc_ext.h>
#include <86box/gameport.h>
#include <86box/machine.h>
#include <86box/mouse.h>
#include <86box/network.h>
#include <86box/scsi.h>
#include <86box/scsi_device.h>
#include <86box/cdrom.h>
#include <86box/zip.h>
#include <86box/mo.h>
#include <86box/sound.h>
#include <86box/midi.h>
#include <86box/snd_mpu401.h>
#include <86box/video.h>
#include <86box/plat.h>
#include <86box/plat_midi.h>
#include <86box/ui.h>
typedef struct _list_ {
struct _list_ *next;
} list_t;
typedef struct {
list_t list;
char name[128];
list_t entry_head;
} section_t;
typedef struct {
list_t list;
char name[128];
char data[512];
wchar_t wdata[512];
} entry_t;
#define list_add(new, head) { \
list_t *next = head; \
\
while (next->next != NULL) \
next = next->next; \
\
(next)->next = new; \
(new)->next = NULL; \
}
#define list_delete(old, head) { \
list_t *next = head; \
\
while ((next)->next != old) { \
next = (next)->next; \
} \
\
(next)->next = (old)->next; \
if ((next) == (head)) \
(head)->next = (old)->next; \
}
static list_t config_head;
/* TODO: Backwards compatibility, get rid of this when enough time has passed. */
static int backwards_compat = 0;
#ifdef ENABLE_CONFIG_LOG
int config_do_log = ENABLE_CONFIG_LOG;
static void
config_log(const char *fmt, ...)
{
va_list ap;
if (config_do_log) {
va_start(ap, fmt);
pclog_ex(fmt, ap);
va_end(ap);
}
}
#else
#define config_log(fmt, ...)
#endif
static section_t *
find_section(char *name)
{
section_t *sec;
char blank[] = "";
sec = (section_t *)config_head.next;
if (name == NULL)
name = blank;
while (sec != NULL) {
if (! strncmp(sec->name, name, sizeof(sec->name)))
return(sec);
sec = (section_t *)sec->list.next;
}
return(NULL);
}
static entry_t *
find_entry(section_t *section, char *name)
{
entry_t *ent;
ent = (entry_t *)section->entry_head.next;
while (ent != NULL) {
if (! strncmp(ent->name, name, sizeof(ent->name)))
return(ent);
ent = (entry_t *)ent->list.next;
}
return(NULL);
}
static int
entries_num(section_t *section)
{
entry_t *ent;
int i = 0;
ent = (entry_t *)section->entry_head.next;
while (ent != NULL) {
if (strlen(ent->name) > 0) i++;
ent = (entry_t *)ent->list.next;
}
return(i);
}
static void
delete_section_if_empty(char *head)
{
section_t *section;
section = find_section(head);
if (section == NULL) return;
if (entries_num(section) == 0) {
list_delete(&section->list, &config_head);
free(section);
}
}
static section_t *
create_section(char *name)
{
section_t *ns = malloc(sizeof(section_t));
memset(ns, 0x00, sizeof(section_t));
memcpy(ns->name, name, strlen(name) + 1);
list_add(&ns->list, &config_head);
return(ns);
}
static entry_t *
create_entry(section_t *section, char *name)
{
entry_t *ne = malloc(sizeof(entry_t));
memset(ne, 0x00, sizeof(entry_t));
memcpy(ne->name, name, strlen(name) + 1);
list_add(&ne->list, &section->entry_head);
return(ne);
}
#if 0
static void
config_free(void)
{
section_t *sec, *ns;
entry_t *ent;
sec = (section_t *)config_head.next;
while (sec != NULL) {
ns = (section_t *)sec->list.next;
ent = (entry_t *)sec->entry_head.next;
while (ent != NULL) {
entry_t *nent = (entry_t *)ent->list.next;
free(ent);
ent = nent;
}
free(sec);
sec = ns;
}
}
#endif
/* Read and parse the configuration file into memory. */
static int
config_read(wchar_t *fn)
{
char sname[128], ename[128];
wchar_t buff[1024];
section_t *sec, *ns;
entry_t *ne;
int c, d;
FILE *f;
#if defined(ANSI_CFG) || !defined(_WIN32)
f = plat_fopen(fn, L"rt");
#else
f = plat_fopen(fn, L"rt, ccs=UNICODE");
#endif
if (f == NULL) return(0);
sec = malloc(sizeof(section_t));
memset(sec, 0x00, sizeof(section_t));
memset(&config_head, 0x00, sizeof(list_t));
list_add(&sec->list, &config_head);
while (1) {
memset(buff, 0x00, sizeof(buff));
fgetws(buff, sizeof_w(buff), f);
if (feof(f)) break;
/* Make sure there are no stray newlines or hard-returns in there. */
if (wcslen(buff) > 0)
if (buff[wcslen(buff)-1] == L'\n') buff[wcslen(buff)-1] = L'\0';
if (wcslen(buff) > 0)
if (buff[wcslen(buff)-1] == L'\r') buff[wcslen(buff)-1] = L'\0';
/* Skip any leading whitespace. */
c = 0;
while ((buff[c] == L' ') || (buff[c] == L'\t'))
c++;
/* Skip empty lines. */
if (buff[c] == L'\0') continue;
/* Skip lines that (only) have a comment. */
if ((buff[c] == L'#') || (buff[c] == L';')) continue;
if (buff[c] == L'[') { /*Section*/
c++;
d = 0;
while (buff[c] != L']' && buff[c])
wctomb(&(sname[d++]), buff[c++]);
sname[d] = L'\0';
/* Is the section name properly terminated? */
if (buff[c] != L']') continue;
/* Create a new section and insert it. */
ns = malloc(sizeof(section_t));
memset(ns, 0x00, sizeof(section_t));
memcpy(ns->name, sname, 128);
list_add(&ns->list, &config_head);
/* New section is now the current one. */
sec = ns;
continue;
}
/* Get the variable name. */
d = 0;
while ((buff[c] != L'=') && (buff[c] != L' ') && buff[c])
wctomb(&(ename[d++]), buff[c++]);
ename[d] = L'\0';
/* Skip incomplete lines. */
if (buff[c] == L'\0') continue;
/* Look for =, skip whitespace. */
while ((buff[c] == L'=' || buff[c] == L' ') && buff[c])
c++;
/* Skip incomplete lines. */
if (buff[c] == L'\0') continue;
/* This is where the value part starts. */
d = c;
/* Allocate a new variable entry.. */
ne = malloc(sizeof(entry_t));
memset(ne, 0x00, sizeof(entry_t));
memcpy(ne->name, ename, 128);
wcsncpy(ne->wdata, &buff[d], sizeof_w(ne->wdata)-1);
ne->wdata[sizeof_w(ne->wdata)-1] = L'\0';
wcstombs(ne->data, ne->wdata, sizeof(ne->data));
ne->data[sizeof(ne->data)-1] = '\0';
/* .. and insert it. */
list_add(&ne->list, &sec->entry_head);
}
(void)fclose(f);
if (do_dump_config)
config_dump();
return(1);
}
/*
* Write the in-memory configuration to disk.
* This is a public function, because the Settings UI
* want to directly write the configuration after it
* has changed it.
*/
void
config_write(wchar_t *fn)
{
wchar_t wtemp[512];
section_t *sec;
FILE *f;
int fl = 0;
#if defined(ANSI_CFG) || !defined(_WIN32)
f = plat_fopen(fn, L"wt");
#else
f = plat_fopen(fn, L"wt, ccs=UNICODE");
#endif
if (f == NULL) return;
sec = (section_t *)config_head.next;
while (sec != NULL) {
entry_t *ent;
if (sec->name[0]) {
mbstowcs(wtemp, sec->name, strlen(sec->name)+1);
if (fl)
fwprintf(f, L"\n[%ls]\n", wtemp);
else
fwprintf(f, L"[%ls]\n", wtemp);
fl++;
}
ent = (entry_t *)sec->entry_head.next;
while (ent != NULL) {
if (ent->name[0] != '\0') {
mbstowcs(wtemp, ent->name, 128);
if (ent->wdata[0] == L'\0')
fwprintf(f, L"%ls = \n", wtemp);
else
fwprintf(f, L"%ls = %ls\n", wtemp, ent->wdata);
fl++;
}
ent = (entry_t *)ent->list.next;
}
sec = (section_t *)sec->list.next;
}
(void)fclose(f);
}
#if NOT_USED
static void
config_new(void)
{
#if defined(ANSI_CFG) || !defined(_WIN32)
FILE *f = _wfopen(config_file, L"wt");
#else
FILE *f = _wfopen(config_file, L"wt, ccs=UNICODE");
#endif
if (file != NULL)
(void)fclose(f);
}
#endif
/* Load "General" section. */
static void
load_general(void)
{
char *cat = "General";
char temp[512];
char *p;
vid_resize = !!config_get_int(cat, "vid_resize", 0);
memset(temp, '\0', sizeof(temp));
p = config_get_string(cat, "vid_renderer", "default");
vid_api = plat_vidapi(p);
config_delete_var(cat, "vid_api");
video_fullscreen_scale = config_get_int(cat, "video_fullscreen_scale", 0);
video_fullscreen_first = config_get_int(cat, "video_fullscreen_first", 1);
force_43 = !!config_get_int(cat, "force_43", 0);
scale = config_get_int(cat, "scale", 1);
if (scale > 3)
scale = 3;
dpi_scale = config_get_int(cat, "dpi_scale", 1);
enable_overscan = !!config_get_int(cat, "enable_overscan", 0);
vid_cga_contrast = !!config_get_int(cat, "vid_cga_contrast", 0);
video_grayscale = config_get_int(cat, "video_grayscale", 0);
video_graytype = config_get_int(cat, "video_graytype", 0);
rctrl_is_lalt = config_get_int(cat, "rctrl_is_lalt", 0);
update_icons = config_get_int(cat, "update_icons", 1);
window_remember = config_get_int(cat, "window_remember", 0);
if (window_remember) {
p = config_get_string(cat, "window_coordinates", NULL);
if (p == NULL)
p = "0, 0, 0, 0";
sscanf(p, "%i, %i, %i, %i", &window_w, &window_h, &window_x, &window_y);
} else {
config_delete_var(cat, "window_remember");
config_delete_var(cat, "window_coordinates");
window_w = window_h = window_x = window_y = 0;
}
sound_gain = config_get_int(cat, "sound_gain", 0);
confirm_reset = config_get_int(cat, "confirm_reset", 1);
confirm_exit = config_get_int(cat, "confirm_exit", 1);
#ifdef USE_LANGUAGE
/*
* Currently, 86Box is English (US) only, but in the future
* (version 3.0 at the earliest) other languages will be
* added, therefore it is better to future-proof the code.
*/
plat_langid = config_get_hex16(cat, "language", 0x0409);
#endif
#if USE_DISCORD
enable_discord = !!config_get_int(cat, "enable_discord", 0);
#endif
}
/* Load "Machine" section. */
static void
load_machine(void)
{
char *cat = "Machine";
char *p;
int c, i, speed, legacy_mfg, legacy_cpu;
double multi;
cpu_family_t *legacy_family;
p = config_get_string(cat, "machine", NULL);
if (p != NULL) {
if (! strcmp(p, "8500ttc")) /* correct typo */
machine = machine_get_machine_from_internal_name("8600ttc");
else if (! strcmp(p, "president")) /* migrate from removed machine */
machine = machine_get_machine_from_internal_name("mb500n");
else
machine = machine_get_machine_from_internal_name(p);
} else
machine = 0;
if (machine >= machine_count())
machine = machine_count() - 1;
/* This is for backwards compatibility. */
p = config_get_string(cat, "model", NULL);
if (p != NULL) {
if (! strcmp(p, "p55r2p4")) /* correct typo */
machine = machine_get_machine_from_internal_name("p55t2p4");
else
machine = machine_get_machine_from_internal_name(p);
config_delete_var(cat, "model");
}
if (machine >= machine_count())
machine = machine_count() - 1;
/* Backwards compatibility for the previous CPU model system. */
legacy_mfg = config_get_int(cat, "cpu_manufacturer", 0);
legacy_cpu = config_get_int(cat, "cpu", 0);
if (legacy_mfg || legacy_cpu) {
/* Look for a machine entry on the legacy table. */
p = machine_get_internal_name();
c = 0;
while (cpu_legacy_table[c].machine) {
if (!strcmp(p, cpu_legacy_table[c].machine))
break;
c++;
}
if (cpu_legacy_table[c].machine) {
/* Look for a corresponding CPU entry. */
i = -1;
cpu_legacy_table_t *legacy_table_entry;
do {
i++;
legacy_table_entry = (cpu_legacy_table_t *) &cpu_legacy_table[c].tables[legacy_mfg][i];
if (legacy_cpu >= legacy_table_entry->old_offset) {
/* Found CPU entry. */
if (!(legacy_family = cpu_get_family((char *) legacy_table_entry->family))) /* check if the family exists */
break;
config_set_string(cat, "cpu_family", (char *) legacy_family->internal_name);
legacy_cpu -= legacy_table_entry->old_offset;
legacy_cpu += legacy_table_entry->new_offset;
while (!cpu_is_eligible(legacy_family, legacy_cpu, machine) && (legacy_family->cpus[legacy_cpu].cpu_type != 0)) /* if the legacy CPU is no longer eligible, bump it up until one is eligible or we're out of CPUs */
legacy_cpu++;
if (legacy_family->cpus[legacy_cpu].cpu_type != 0) { /* store only if an eligible CPU was found; if none are, reset to the first one */
config_set_int(cat, "cpu_speed", legacy_family->cpus[legacy_cpu].rspeed);
config_set_double(cat, "cpu_multi", legacy_family->cpus[legacy_cpu].multi);
}
break;
}
} while (cpu_legacy_table[c].tables[legacy_mfg][i].old_offset);
}
}
/* Current CPU model system. */
cpu_f = NULL;
p = config_get_string(cat, "cpu_family", NULL);
if (p)
cpu_f = cpu_get_family(p);
if (cpu_f) {
speed = config_get_int(cat, "cpu_speed", 0);
multi = config_get_double(cat, "cpu_multi", 0);
/* Find the configured CPU. */
c = 0;
i = -1;
while (cpu_f->cpus[c].cpu_type != -1) {
if (cpu_is_eligible(cpu_f, c, machine)) { /* skip ineligible CPUs */
if (i == -1) /* store the first eligible CPU */
i = c;
if ((cpu_f->cpus[c].rspeed == speed) && (cpu_f->cpus[c].multi == multi)) /* check if clock speed and multiplier match */
break;
}
c++;
}
if (cpu_f->cpus[c].cpu_type == -1) /* use first eligible CPU if no match was found */
c = MAX(i, 0);
cpu = c;
cpu_s = (CPU *) &cpu_f->cpus[cpu];
} else { /* default */
/* Find first eligible family. */
c = 0;
while (!cpu_family_is_eligible(&cpu_families[c], machine)) {
if (cpu_families[c++].package == 0) {
fatal("No eligible CPU families for the selected machine\n");
return;
}
}
cpu_f = &cpu_families[c];
/* Find first eligible CPU in that family. */
c = 0;
while (!cpu_is_eligible(cpu_f, c, machine)) {
if (cpu_f->cpus[c++].cpu_type == 0) {
fatal("No eligible CPUs for the default CPU family for the selected machine\n");
return;
}
}
cpu = c;
cpu_s = (CPU *) &cpu_f->cpus[cpu];
}
cpu_waitstates = config_get_int(cat, "cpu_waitstates", 0);
p = (char *)config_get_string(cat, "fpu_type", "none");
fpu_type = fpu_get_type(cpu_f, cpu, p);
mem_size = config_get_int(cat, "mem_size", 4096);
#if 0
if (mem_size < (((machines[machine].flags & MACHINE_AT) &&
(machines[machine].ram_granularity < 128)) ? machines[machine].min_ram*1024 : machines[machine].min_ram))
mem_size = (((machines[machine].flags & MACHINE_AT) && (machines[machine].ram_granularity < 128)) ? machines[machine].min_ram*1024 : machines[machine].min_ram);
#endif
if (mem_size > 2097152)
mem_size = 2097152;
cpu_use_dynarec = !!config_get_int(cat, "cpu_use_dynarec", 0);
p = config_get_string(cat, "time_sync", NULL);
if (p != NULL) {
if (!strcmp(p, "disabled"))
time_sync = TIME_SYNC_DISABLED;
else
if (!strcmp(p, "local"))
time_sync = TIME_SYNC_ENABLED;
else
if (!strcmp(p, "utc") || !strcmp(p, "gmt"))
time_sync = TIME_SYNC_ENABLED | TIME_SYNC_UTC;
else
time_sync = TIME_SYNC_ENABLED;
} else
time_sync = !!config_get_int(cat, "enable_sync", 1);
/* Remove this after a while.. */
config_delete_var(cat, "nvr_path");
config_delete_var(cat, "enable_sync");
}
/* Load "Video" section. */
static void
load_video(void)
{
char *cat = "Video";
char *p;
int free_p = 0;
if (machines[machine].flags & MACHINE_VIDEO_ONLY) {
config_delete_var(cat, "gfxcard");
gfxcard = VID_INTERNAL;
} else {
p = config_get_string(cat, "gfxcard", NULL);
if (p == NULL) {
if (machines[machine].flags & MACHINE_VIDEO) {
p = (char *)malloc((strlen("internal")+1)*sizeof(char));
strcpy(p, "internal");
} else {
p = (char *)malloc((strlen("none")+1)*sizeof(char));
strcpy(p, "none");
}
free_p = 1;
}
gfxcard = video_get_video_from_internal_name(p);
if (free_p)
free(p);
}
voodoo_enabled = !!config_get_int(cat, "voodoo", 0);
}
/* Load "Input Devices" section. */
static void
load_input_devices(void)
{
char *cat = "Input devices";
char temp[512];
int c, d;
char *p;
p = config_get_string(cat, "mouse_type", NULL);
if (p != NULL)
mouse_type = mouse_get_from_internal_name(p);
else
mouse_type = 0;
joystick_type = config_get_int(cat, "joystick_type", JOYSTICK_TYPE_NONE);
for (c=0; c<joystick_get_max_joysticks(joystick_type); c++) {
sprintf(temp, "joystick_%i_nr", c);
joystick_state[c].plat_joystick_nr = config_get_int(cat, temp, 0);
if (joystick_state[c].plat_joystick_nr) {
for (d=0; d<joystick_get_axis_count(joystick_type); d++) {
sprintf(temp, "joystick_%i_axis_%i", c, d);
joystick_state[c].axis_mapping[d] = config_get_int(cat, temp, d);
}
for (d=0; d<joystick_get_button_count(joystick_type); d++) {
sprintf(temp, "joystick_%i_button_%i", c, d);
joystick_state[c].button_mapping[d] = config_get_int(cat, temp, d);
}
for (d=0; d<joystick_get_pov_count(joystick_type); d++) {
sprintf(temp, "joystick_%i_pov_%i", c, d);
p = config_get_string(cat, temp, "0, 0");
joystick_state[c].pov_mapping[d][0] = joystick_state[c].pov_mapping[d][1] = 0;
sscanf(p, "%i, %i", &joystick_state[c].pov_mapping[d][0], &joystick_state[c].pov_mapping[d][1]);
}
}
}
}
/* Load "Sound" section. */
static void
load_sound(void)
{
char *cat = "Sound";
char temp[512];
char *p;
p = config_get_string(cat, "sndcard", NULL);
/* FIXME: Hack to not break configs with the Sound Blaster 128 PCI set. */
if ((p != NULL) && (!strcmp(p, "sbpci128") || !strcmp(p, "sb128pci")))
p = "es1371";
if (p != NULL)
sound_card_current = sound_card_get_from_internal_name(p);
else
sound_card_current = 0;
p = config_get_string(cat, "midi_device", NULL);
if (p != NULL)
midi_device_current = midi_device_get_from_internal_name(p);
else
midi_device_current = 0;
p = config_get_string(cat, "midi_in_device", NULL);
if (p != NULL)
midi_input_device_current = midi_in_device_get_from_internal_name(p);
else
midi_input_device_current = 0;
mpu401_standalone_enable = !!config_get_int(cat, "mpu401_standalone", 0);
SSI2001 = !!config_get_int(cat, "ssi2001", 0);
GAMEBLASTER = !!config_get_int(cat, "gameblaster", 0);
GUS = !!config_get_int(cat, "gus", 0);
memset(temp, '\0', sizeof(temp));
p = config_get_string(cat, "sound_type", "float");
if (strlen(p) <= 511)
strcpy(temp, p);
else
strncpy(temp, p, 511);
if (!strcmp(temp, "float") || !strcmp(temp, "1"))
sound_is_float = 1;
else
sound_is_float = 0;
}
/* Load "Network" section. */
static void
load_network(void)
{
char *cat = "Network";
char *p;
p = config_get_string(cat, "net_type", NULL);
if (p != NULL) {
if (!strcmp(p, "pcap") || !strcmp(p, "1"))
network_type = NET_TYPE_PCAP;
else
if (!strcmp(p, "slirp") || !strcmp(p, "2"))
network_type = NET_TYPE_SLIRP;
else
network_type = NET_TYPE_NONE;
} else
network_type = NET_TYPE_NONE;
memset(network_host, '\0', sizeof(network_host));
p = config_get_string(cat, "net_host_device", NULL);
if (p == NULL) {
p = config_get_string(cat, "net_host_device", NULL);
if (p != NULL)
config_delete_var(cat, "net_host_device");
}
if (p != NULL) {
if ((network_dev_to_id(p) == -1) || (network_ndev == 1)) {
if ((network_ndev == 1) && strcmp(network_host, "none")) {
ui_msgbox_header(MBX_ERROR, (wchar_t *) IDS_2094, (wchar_t *) IDS_2129);
} else if (network_dev_to_id(p) == -1) {
ui_msgbox_header(MBX_ERROR, (wchar_t *) IDS_2095, (wchar_t *) IDS_2129);
}
strcpy(network_host, "none");
} else {
if (strlen(p) <= 522)
strcpy(network_host, p);
else
strncpy(network_host, p, 522);
}
} else
strcpy(network_host, "none");
p = config_get_string(cat, "net_card", NULL);
if (p != NULL)
network_card = network_card_get_from_internal_name(p);
else
network_card = 0;
}
/* Load "Ports" section. */
static void
load_ports(void)
{
char *cat = "Ports (COM & LPT)";
char *p;
char temp[512];
int c, d;
for (c = 0; c < 4; c++) {
sprintf(temp, "serial%d_enabled", c + 1);
serial_enabled[c] = !!config_get_int(cat, temp, (c >= 2) ? 0 : 1);
}
for (c = 0; c < 3; c++) {
sprintf(temp, "lpt%d_enabled", c + 1);
lpt_ports[c].enabled = !!config_get_int(cat, temp, (c == 0) ? 1 : 0);
sprintf(temp, "lpt%d_device", c + 1);
p = (char *) config_get_string(cat, temp, "none");
lpt_ports[c].device = lpt_device_get_from_internal_name(p);
}
/* Legacy config compatibility. */
d = config_get_int(cat, "lpt_enabled", 2);
if (d < 2) {
for (c = 0; c < 3; c++)
lpt_ports[c].enabled = d;
}
config_delete_var(cat, "lpt_enabled");
}
/* Load "Other Peripherals" section. */
static void
load_other_peripherals(void)
{
char *cat = "Other peripherals";
char *p;
char temp[512];
int c, free_p = 0;
p = config_get_string(cat, "scsicard", NULL);
if (p != NULL)
scsi_card_current = scsi_card_get_from_internal_name(p);
else
scsi_card_current = 0;
p = config_get_string(cat, "fdc", NULL);
if (p != NULL)
fdc_type = fdc_card_get_from_internal_name(p);
else
fdc_type = FDC_INTERNAL;
p = config_get_string(cat, "hdc", NULL);
if (p == NULL) {
if (machines[machine].flags & MACHINE_HDC) {
p = (char *)malloc((strlen("internal")+1)*sizeof(char));
strcpy(p, "internal");
} else {
p = (char *)malloc((strlen("none")+1)*sizeof(char));
strcpy(p, "none");
}
free_p = 1;
}
if (!strcmp(p, "mfm_xt"))
hdc_current = hdc_get_from_internal_name("st506_xt");
else if (!strcmp(p, "mfm_xt_dtc5150x"))
hdc_current = hdc_get_from_internal_name("st506_xt_dtc5150x");
else if (!strcmp(p, "mfm_at"))
hdc_current = hdc_get_from_internal_name("st506_at");
else
hdc_current = hdc_get_from_internal_name(p);
if (free_p) {
free(p);
p = NULL;
}
ide_ter_enabled = !!config_get_int(cat, "ide_ter", 0);
ide_qua_enabled = !!config_get_int(cat, "ide_qua", 0);
bugger_enabled = !!config_get_int(cat, "bugger_enabled", 0);
postcard_enabled = !!config_get_int(cat, "postcard_enabled", 0);
for (c = 0; c < ISAMEM_MAX; c++) {
sprintf(temp, "isamem%d_type", c);
p = config_get_string(cat, temp, "none");
isamem_type[c] = isamem_get_from_internal_name(p);
}
p = config_get_string(cat, "isartc_type", "none");
isartc_type = isartc_get_from_internal_name(p);
}
/* Load "Hard Disks" section. */
static void
load_hard_disks(void)
{
char *cat = "Hard disks";
char temp[512], tmp2[512];
char s[512];
int c;
char *p;
wchar_t *wp;
uint32_t max_spt, max_hpc, max_tracks;
uint32_t board = 0, dev = 0;
memset(temp, '\0', sizeof(temp));
for (c=0; c<HDD_NUM; c++) {
sprintf(temp, "hdd_%02i_parameters", c+1);
p = config_get_string(cat, temp, "0, 0, 0, 0, none");
sscanf(p, "%u, %u, %u, %i, %s",
&hdd[c].spt, &hdd[c].hpc, &hdd[c].tracks, (int *)&hdd[c].wp, s);
hdd[c].bus = hdd_string_to_bus(s, 0);
switch(hdd[c].bus) {
case HDD_BUS_DISABLED:
default:
max_spt = max_hpc = max_tracks = 0;
break;
case HDD_BUS_MFM:
max_spt = 26; /* 26 for RLL */
max_hpc = 15;
max_tracks = 2047;
break;
case HDD_BUS_XTA:
max_spt = 63;
max_hpc = 16;
max_tracks = 1023;
break;
case HDD_BUS_ESDI:
max_spt = 99;
max_hpc = 16;
max_tracks = 266305;
break;
case HDD_BUS_IDE:
max_spt = 63;
max_hpc = 16;
max_tracks = 266305;
break;
case HDD_BUS_SCSI:
max_spt = 99;
max_hpc = 255;
max_tracks = 266305;
break;
}
if (hdd[c].spt > max_spt)
hdd[c].spt = max_spt;
if (hdd[c].hpc > max_hpc)
hdd[c].hpc = max_hpc;
if (hdd[c].tracks > max_tracks)
hdd[c].tracks = max_tracks;
/* MFM/RLL */
sprintf(temp, "hdd_%02i_mfm_channel", c+1);
if (hdd[c].bus == HDD_BUS_MFM)
hdd[c].mfm_channel = !!config_get_int(cat, temp, c & 1);
else
config_delete_var(cat, temp);
/* XTA */
sprintf(temp, "hdd_%02i_xta_channel", c+1);
if (hdd[c].bus == HDD_BUS_XTA)
hdd[c].xta_channel = !!config_get_int(cat, temp, c & 1);
else
config_delete_var(cat, temp);
/* ESDI */
sprintf(temp, "hdd_%02i_esdi_channel", c+1);
if (hdd[c].bus == HDD_BUS_ESDI)
hdd[c].esdi_channel = !!config_get_int(cat, temp, c & 1);
else
config_delete_var(cat, temp);
/* IDE */
sprintf(temp, "hdd_%02i_ide_channel", c+1);
if (hdd[c].bus == HDD_BUS_IDE) {
sprintf(tmp2, "%01u:%01u", c>>1, c&1);
p = config_get_string(cat, temp, tmp2);
sscanf(p, "%01u:%01u", &board, &dev);
board &= 3;
dev &= 1;
hdd[c].ide_channel = (board<<1) + dev;
if (hdd[c].ide_channel > 7)
hdd[c].ide_channel = 7;
} else {
config_delete_var(cat, temp);
}
/* SCSI */
sprintf(temp, "hdd_%02i_scsi_id", c+1);
if (hdd[c].bus == HDD_BUS_SCSI) {
hdd[c].scsi_id = config_get_int(cat, temp, c);
if (hdd[c].scsi_id > 15)
hdd[c].scsi_id = 15;
} else
config_delete_var(cat, temp);
memset(hdd[c].fn, 0x00, sizeof(hdd[c].fn));
memset(hdd[c].prev_fn, 0x00, sizeof(hdd[c].prev_fn));
sprintf(temp, "hdd_%02i_fn", c+1);
wp = config_get_wstring(cat, temp, L"");
#if 0
/*
* NOTE:
* Temporary hack to remove the absolute
* path currently saved in most config
* files. We should remove this before
* finalizing this release! --FvK
*/
if (! wcsnicmp(wp, usr_path, wcslen(usr_path))) {
/*
* Yep, its absolute and prefixed
* with the CFG path. Just strip
* that off for now...
*/
wcsncpy(hdd[c].fn, &wp[wcslen(usr_path)], sizeof_w(hdd[c].fn));
} else
#endif
if (plat_path_abs(wp)) {
wcsncpy(hdd[c].fn, wp, sizeof_w(hdd[c].fn));
} else {
wcsncpy(hdd[c].fn, usr_path, sizeof_w(hdd[c].fn));
wcsncat(hdd[c].fn, wp, sizeof_w(hdd[c].fn)-wcslen(usr_path));
}
/* If disk is empty or invalid, mark it for deletion. */
if (! hdd_is_valid(c)) {
sprintf(temp, "hdd_%02i_parameters", c+1);
config_delete_var(cat, temp);
sprintf(temp, "hdd_%02i_preide_channels", c+1);
config_delete_var(cat, temp);
sprintf(temp, "hdd_%02i_ide_channels", c+1);
config_delete_var(cat, temp);
sprintf(temp, "hdd_%02i_scsi_id", c+1);
config_delete_var(cat, temp);
sprintf(temp, "hdd_%02i_fn", c+1);
config_delete_var(cat, temp);
}
sprintf(temp, "hdd_%02i_mfm_channel", c+1);
config_delete_var(cat, temp);
sprintf(temp, "hdd_%02i_ide_channel", c+1);
config_delete_var(cat, temp);
}
}
/* TODO: Backwards compatibility, get rid of this when enough time has passed. */
/* Load "Floppy Drives" section. */
static void
load_floppy_drives(void)
{
char *cat = "Floppy drives";
char temp[512], *p;
wchar_t *wp;
int c;
if (!backwards_compat)
return;
for (c=0; c<FDD_NUM; c++) {
sprintf(temp, "fdd_%02i_type", c+1);
p = config_get_string(cat, temp, (c < 2) ? "525_2dd" : "none");
fdd_set_type(c, fdd_get_from_internal_name(p));
if (fdd_get_type(c) > 13)
fdd_set_type(c, 13);
config_delete_var(cat, temp);
sprintf(temp, "fdd_%02i_fn", c + 1);
wp = config_get_wstring(cat, temp, L"");
config_delete_var(cat, temp);
#if 0
/*
* NOTE:
* Temporary hack to remove the absolute
* path currently saved in most config
* files. We should remove this before
* finalizing this release! --FvK
*/
if (! wcsnicmp(wp, usr_path, wcslen(usr_path))) {
/*
* Yep, its absolute and prefixed
* with the EXE path. Just strip
* that off for now...
*/
wcsncpy(floppyfns[c], &wp[wcslen(usr_path)], sizeof_w(floppyfns[c]));
} else
#endif
wcsncpy(floppyfns[c], wp, sizeof_w(floppyfns[c]));
/* if (*wp != L'\0')
config_log("Floppy%d: %ls\n", c, floppyfns[c]); */
sprintf(temp, "fdd_%02i_writeprot", c+1);
ui_writeprot[c] = !!config_get_int(cat, temp, 0);
config_delete_var(cat, temp);
sprintf(temp, "fdd_%02i_turbo", c + 1);
fdd_set_turbo(c, !!config_get_int(cat, temp, 0));
config_delete_var(cat, temp);
sprintf(temp, "fdd_%02i_check_bpb", c+1);
fdd_set_check_bpb(c, !!config_get_int(cat, temp, 1));
config_delete_var(cat, temp);
}
delete_section_if_empty(cat);
}
/* Load "Floppy and CD-ROM Drives" section. */
static void
load_floppy_and_cdrom_drives(void)
{
char *cat = "Floppy and CD-ROM drives";
char temp[512], tmp2[512], *p;
char s[512];
unsigned int board = 0, dev = 0;
wchar_t *wp;
int c, d = 0;
/* TODO: Backwards compatibility, get rid of this when enough time has passed. */
backwards_compat = (find_section(cat) == NULL);
memset(temp, 0x00, sizeof(temp));
for (c=0; c<FDD_NUM; c++) {
sprintf(temp, "fdd_%02i_type", c+1);
p = config_get_string(cat, temp, (c < 2) ? "525_2dd" : "none");
fdd_set_type(c, fdd_get_from_internal_name(p));
if (fdd_get_type(c) > 13)
fdd_set_type(c, 13);
sprintf(temp, "fdd_%02i_fn", c + 1);
wp = config_get_wstring(cat, temp, L"");
#if 0
/*
* NOTE:
* Temporary hack to remove the absolute
* path currently saved in most config
* files. We should remove this before
* finalizing this release! --FvK
*/
if (! wcsnicmp(wp, usr_path, wcslen(usr_path))) {
/*
* Yep, its absolute and prefixed
* with the EXE path. Just strip
* that off for now...
*/
wcsncpy(floppyfns[c], &wp[wcslen(usr_path)], sizeof_w(floppyfns[c]));
} else
#endif
wcsncpy(floppyfns[c], wp, sizeof_w(floppyfns[c]));
/* if (*wp != L'\0')
config_log("Floppy%d: %ls\n", c, floppyfns[c]); */
sprintf(temp, "fdd_%02i_writeprot", c+1);
ui_writeprot[c] = !!config_get_int(cat, temp, 0);
sprintf(temp, "fdd_%02i_turbo", c + 1);
fdd_set_turbo(c, !!config_get_int(cat, temp, 0));
sprintf(temp, "fdd_%02i_check_bpb", c+1);
fdd_set_check_bpb(c, !!config_get_int(cat, temp, 1));
/* Check whether each value is default, if yes, delete it so that only non-default values will later be saved. */
if (fdd_get_type(c) == ((c < 2) ? 2 : 0)) {
sprintf(temp, "fdd_%02i_type", c+1);
config_delete_var(cat, temp);
}
if (wcslen(floppyfns[c]) == 0) {
sprintf(temp, "fdd_%02i_fn", c+1);
config_delete_var(cat, temp);
}
if (ui_writeprot[c] == 0) {
sprintf(temp, "fdd_%02i_writeprot", c+1);
config_delete_var(cat, temp);
}
if (fdd_get_turbo(c) == 0) {
sprintf(temp, "fdd_%02i_turbo", c+1);
config_delete_var(cat, temp);
}
if (fdd_get_check_bpb(c) == 1) {
sprintf(temp, "fdd_%02i_check_bpb", c+1);
config_delete_var(cat, temp);
}
}
memset(temp, 0x00, sizeof(temp));
for (c=0; c<CDROM_NUM; c++) {
sprintf(temp, "cdrom_%02i_host_drive", c+1);
cdrom[c].host_drive = config_get_int(cat, temp, 0);
cdrom[c].prev_host_drive = cdrom[c].host_drive;
sprintf(temp, "cdrom_%02i_parameters", c+1);
p = config_get_string(cat, temp, NULL);
if (p != NULL)
sscanf(p, "%01u, %s", &d, s);
else if (c == 0)
/* If this is the first drive, unmute the audio. */
sscanf("1, none", "%01u, %s", &d, s);
else
sscanf("0, none", "%01u, %s", &d, s);
cdrom[c].sound_on = d;
cdrom[c].bus_type = hdd_string_to_bus(s, 1);
sprintf(temp, "cdrom_%02i_speed", c+1);
cdrom[c].speed = config_get_int(cat, temp, 8);
/* Default values, needed for proper operation of the Settings dialog. */
cdrom[c].ide_channel = cdrom[c].scsi_device_id = c + 2;
sprintf(temp, "cdrom_%02i_ide_channel", c+1);
if (cdrom[c].bus_type == CDROM_BUS_ATAPI) {
sprintf(tmp2, "%01u:%01u", (c+2)>>1, (c+2)&1);
p = config_get_string(cat, temp, tmp2);
sscanf(p, "%01u:%01u", &board, &dev);
board &= 3;
dev &= 1;
cdrom[c].ide_channel = (board<<1)+dev;
if (cdrom[c].ide_channel > 7)
cdrom[c].ide_channel = 7;
} else {
sprintf(temp, "cdrom_%02i_scsi_id", c+1);
if (cdrom[c].bus_type == CDROM_BUS_SCSI) {
cdrom[c].scsi_device_id = config_get_int(cat, temp, c+2);
if (cdrom[c].scsi_device_id > 15)
cdrom[c].scsi_device_id = 15;
} else
config_delete_var(cat, temp);
}
sprintf(temp, "cdrom_%02i_image_path", c+1);
wp = config_get_wstring(cat, temp, L"");
#if 0
/*
* NOTE:
* Temporary hack to remove the absolute
* path currently saved in most config
* files. We should remove this before
* finalizing this release! --FvK
*/
if (! wcsnicmp(wp, usr_path, wcslen(usr_path))) {
/*
* Yep, its absolute and prefixed
* with the EXE path. Just strip
* that off for now...
*/
wcsncpy(cdrom[c].image_path, &wp[wcslen(usr_path)], sizeof_w(cdrom[c].image_path));
} else
#endif
wcsncpy(cdrom[c].image_path, wp, sizeof_w(cdrom[c].image_path));
if (cdrom[c].host_drive && (cdrom[c].host_drive != 200))
cdrom[c].host_drive = 0;
if ((cdrom[c].host_drive == 0x200) &&
(wcslen(cdrom[c].image_path) == 0))
cdrom[c].host_drive = 0;
/* If the CD-ROM is disabled, delete all its variables. */
if (cdrom[c].bus_type == CDROM_BUS_DISABLED) {
sprintf(temp, "cdrom_%02i_host_drive", c+1);
config_delete_var(cat, temp);
sprintf(temp, "cdrom_%02i_parameters", c+1);
config_delete_var(cat, temp);
sprintf(temp, "cdrom_%02i_ide_channel", c+1);
config_delete_var(cat, temp);
sprintf(temp, "cdrom_%02i_scsi_id", c+1);
config_delete_var(cat, temp);
sprintf(temp, "cdrom_%02i_image_path", c+1);
config_delete_var(cat, temp);
}
sprintf(temp, "cdrom_%02i_iso_path", c+1);
config_delete_var(cat, temp);
}
}
/* Load "Other Removable Devices" section. */
static void
load_other_removable_devices(void)
{
char *cat = "Other removable devices";
char temp[512], tmp2[512], *p;
char s[512];
unsigned int board = 0, dev = 0;
wchar_t *wp;
int c, d = 0;
/* TODO: Backwards compatibility, get rid of this when enough time has passed. */
if (backwards_compat) {
memset(temp, 0x00, sizeof(temp));
for (c=0; c<CDROM_NUM; c++) {
sprintf(temp, "cdrom_%02i_host_drive", c+1);
cdrom[c].host_drive = config_get_int(cat, temp, 0);
cdrom[c].prev_host_drive = cdrom[c].host_drive;
config_delete_var(cat, temp);
sprintf(temp, "cdrom_%02i_parameters", c+1);
p = config_get_string(cat, temp, NULL);
if (p != NULL)
sscanf(p, "%01u, %s", &d, s);
else
sscanf("0, none", "%01u, %s", &d, s);
cdrom[c].sound_on = d;
cdrom[c].bus_type = hdd_string_to_bus(s, 1);
config_delete_var(cat, temp);
sprintf(temp, "cdrom_%02i_speed", c+1);
cdrom[c].speed = config_get_int(cat, temp, 8);
config_delete_var(cat, temp);
/* Default values, needed for proper operation of the Settings dialog. */
cdrom[c].ide_channel = cdrom[c].scsi_device_id = c + 2;
config_delete_var(cat, temp);
sprintf(temp, "cdrom_%02i_ide_channel", c+1);
if (cdrom[c].bus_type == CDROM_BUS_ATAPI) {
sprintf(tmp2, "%01u:%01u", (c+2)>>1, (c+2)&1);
p = config_get_string(cat, temp, tmp2);
sscanf(p, "%01u:%01u", &board, &dev);
board &= 3;
dev &= 1;
cdrom[c].ide_channel = (board<<1)+dev;
if (cdrom[c].ide_channel > 7)
cdrom[c].ide_channel = 7;
} else {
sprintf(temp, "cdrom_%02i_scsi_id", c+1);
if (cdrom[c].bus_type == CDROM_BUS_SCSI) {
cdrom[c].scsi_device_id = config_get_int(cat, temp, c+2);
if (cdrom[c].scsi_device_id > 15)
cdrom[c].scsi_device_id = 15;
} else
config_delete_var(cat, temp);
}
config_delete_var(cat, temp);
sprintf(temp, "cdrom_%02i_image_path", c+1);
wp = config_get_wstring(cat, temp, L"");
config_delete_var(cat, temp);
#if 0
/*
* NOTE:
* Temporary hack to remove the absolute
* path currently saved in most config
* files. We should remove this before
* finalizing this release! --FvK
*/
if (! wcsnicmp(wp, usr_path, wcslen(usr_path))) {
/*
* Yep, its absolute and prefixed
* with the EXE path. Just strip
* that off for now...
*/
wcsncpy(cdrom[c].image_path, &wp[wcslen(usr_path)], sizeof_w(cdrom[c].image_path));
} else
#endif
wcsncpy(cdrom[c].image_path, wp, sizeof_w(cdrom[c].image_path));
if (cdrom[c].host_drive && (cdrom[c].host_drive != 200))
cdrom[c].host_drive = 0;
if ((cdrom[c].host_drive == 0x200) &&
(wcslen(cdrom[c].image_path) == 0))
cdrom[c].host_drive = 0;
}
}
backwards_compat = 0;
memset(temp, 0x00, sizeof(temp));
for (c=0; c<ZIP_NUM; c++) {
sprintf(temp, "zip_%02i_parameters", c+1);
p = config_get_string(cat, temp, NULL);
if (p != NULL)
sscanf(p, "%01u, %s", &zip_drives[c].is_250, s);
else
sscanf("0, none", "%01u, %s", &zip_drives[c].is_250, s);
zip_drives[c].bus_type = hdd_string_to_bus(s, 1);
/* Default values, needed for proper operation of the Settings dialog. */
zip_drives[c].ide_channel = zip_drives[c].scsi_device_id = c + 2;
sprintf(temp, "zip_%02i_ide_channel", c+1);
if (zip_drives[c].bus_type == ZIP_BUS_ATAPI) {
sprintf(tmp2, "%01u:%01u", (c+2)>>1, (c+2)&1);
p = config_get_string(cat, temp, tmp2);
sscanf(p, "%01u:%01u", &board, &dev);
board &= 3;
dev &= 1;
zip_drives[c].ide_channel = (board<<1)+dev;
if (zip_drives[c].ide_channel > 7)
zip_drives[c].ide_channel = 7;
} else {
sprintf(temp, "zip_%02i_scsi_id", c+1);
if (zip_drives[c].bus_type == ZIP_BUS_SCSI) {
zip_drives[c].scsi_device_id = config_get_int(cat, temp, c+2);
if (zip_drives[c].scsi_device_id > 15)
zip_drives[c].scsi_device_id = 15;
} else
config_delete_var(cat, temp);
}
sprintf(temp, "zip_%02i_image_path", c+1);
wp = config_get_wstring(cat, temp, L"");
#if 0
/*
* NOTE:
* Temporary hack to remove the absolute
* path currently saved in most config
* files. We should remove this before
* finalizing this release! --FvK
*/
if (! wcsnicmp(wp, usr_path, wcslen(usr_path))) {
/*
* Yep, its absolute and prefixed
* with the EXE path. Just strip
* that off for now...
*/
wcsncpy(zip_drives[c].image_path, &wp[wcslen(usr_path)], sizeof_w(zip_drives[c].image_path));
} else
#endif
wcsncpy(zip_drives[c].image_path, wp, sizeof_w(zip_drives[c].image_path));
/* If the CD-ROM is disabled, delete all its variables. */
if (zip_drives[c].bus_type == ZIP_BUS_DISABLED) {
sprintf(temp, "zip_%02i_host_drive", c+1);
config_delete_var(cat, temp);
sprintf(temp, "zip_%02i_parameters", c+1);
config_delete_var(cat, temp);
sprintf(temp, "zip_%02i_ide_channel", c+1);
config_delete_var(cat, temp);
sprintf(temp, "zip_%02i_scsi_id", c+1);
config_delete_var(cat, temp);
sprintf(temp, "zip_%02i_image_path", c+1);
config_delete_var(cat, temp);
}
sprintf(temp, "zip_%02i_iso_path", c+1);
config_delete_var(cat, temp);
}
memset(temp, 0x00, sizeof(temp));
for (c=0; c<MO_NUM; c++) {
sprintf(temp, "mo_%02i_parameters", c+1);
p = config_get_string(cat, temp, NULL);
if (p != NULL)
sscanf(p, "%u, %s", &mo_drives[c].type, s);
else
sscanf("00, none", "%u, %s", &mo_drives[c].type, s);
mo_drives[c].bus_type = hdd_string_to_bus(s, 1);
/* Default values, needed for proper operation of the Settings dialog. */
mo_drives[c].ide_channel = mo_drives[c].scsi_device_id = c + 2;
sprintf(temp, "mo_%02i_ide_channel", c+1);
if (mo_drives[c].bus_type == MO_BUS_ATAPI) {
sprintf(tmp2, "%01u:%01u", (c+2)>>1, (c+2)&1);
p = config_get_string(cat, temp, tmp2);
sscanf(p, "%01u:%01u", &board, &dev);
board &= 3;
dev &= 1;
mo_drives[c].ide_channel = (board<<1)+dev;
if (mo_drives[c].ide_channel > 7)
mo_drives[c].ide_channel = 7;
} else {
sprintf(temp, "mo_%02i_scsi_id", c+1);
if (mo_drives[c].bus_type == MO_BUS_SCSI) {
mo_drives[c].scsi_device_id = config_get_int(cat, temp, c+2);
if (mo_drives[c].scsi_device_id > 15)
mo_drives[c].scsi_device_id = 15;
} else
config_delete_var(cat, temp);
}
sprintf(temp, "mo_%02i_image_path", c+1);
wp = config_get_wstring(cat, temp, L"");
wcsncpy(mo_drives[c].image_path, wp, sizeof_w(mo_drives[c].image_path));
/* If the CD-ROM is disabled, delete all its variables. */
if (mo_drives[c].bus_type == MO_BUS_DISABLED) {
sprintf(temp, "mo_%02i_host_drive", c+1);
config_delete_var(cat, temp);
sprintf(temp, "mo_%02i_parameters", c+1);
config_delete_var(cat, temp);
sprintf(temp, "mo_%02i_ide_channel", c+1);
config_delete_var(cat, temp);
sprintf(temp, "mo_%02i_scsi_id", c+1);
config_delete_var(cat, temp);
sprintf(temp, "mo_%02i_image_path", c+1);
config_delete_var(cat, temp);
}
sprintf(temp, "mo_%02i_iso_path", c+1);
config_delete_var(cat, temp);
}
}
/* Load the specified or a default configuration file. */
void
config_load(void)
{
int i;
config_log("Loading config file '%ls'..\n", cfg_path);
memset(hdd, 0, sizeof(hard_disk_t));
memset(cdrom, 0, sizeof(cdrom_t) * CDROM_NUM);
#ifdef USE_IOCTL
memset(cdrom_ioctl, 0, sizeof(cdrom_ioctl_t) * CDROM_NUM);
#endif
memset(zip_drives, 0, sizeof(zip_drive_t));
if (! config_read(cfg_path)) {
cpu_f = &cpu_families[0];
cpu = 0;
#ifdef USE_LANGUAGE
plat_langid = 0x0409;
#endif
scale = 1;
machine = machine_get_machine_from_internal_name("ibmpc");
fpu_type = fpu_get_type(cpu_f, cpu, "none");
gfxcard = video_get_video_from_internal_name("cga");
vid_api = plat_vidapi("default");
time_sync = TIME_SYNC_ENABLED;
joystick_type = JOYSTICK_TYPE_NONE;
hdc_current = hdc_get_from_internal_name("none");
serial_enabled[0] = 1;
serial_enabled[1] = 1;
serial_enabled[2] = 0;
serial_enabled[3] = 0;
lpt_ports[0].enabled = 1;
lpt_ports[1].enabled = 0;
lpt_ports[2].enabled = 0;
for (i = 0; i < FDD_NUM; i++) {
if (i < 2)
fdd_set_type(i, 2);
else
fdd_set_type(i, 0);
fdd_set_turbo(i, 0);
fdd_set_check_bpb(i, 1);
}
/* Unmute the CD audio on the first CD-ROM drive. */
cdrom[0].sound_on = 1;
mem_size = 640;
isartc_type = 0;
for (i = 0; i < ISAMEM_MAX; i++)
isamem_type[i] = 0;
config_log("Config file not present or invalid!\n");
return;
}
load_general(); /* General */
load_machine(); /* Machine */
load_video(); /* Video */
load_input_devices(); /* Input devices */
load_sound(); /* Sound */
load_network(); /* Network */
load_ports(); /* Ports (COM & LPT) */
load_other_peripherals(); /* Other peripherals */
load_hard_disks(); /* Hard disks */
load_floppy_and_cdrom_drives(); /* Floppy and CD-ROM drives */
/* TODO: Backwards compatibility, get rid of this when enough time has passed. */
load_floppy_drives(); /* Floppy drives */
load_other_removable_devices(); /* Other removable devices */
/* Mark the configuration as changed. */
config_changed = 1;
config_log("Config loaded.\n\n");
}
/* Save "General" section. */
static void
save_general(void)
{
char *cat = "General";
char temp[512];
char *va_name;
config_set_int(cat, "vid_resize", vid_resize);
if (vid_resize == 0)
config_delete_var(cat, "vid_resize");
va_name = plat_vidapi_name(vid_api);
if (!strcmp(va_name, "default")) {
config_delete_var(cat, "vid_renderer");
} else {
config_set_string(cat, "vid_renderer", va_name);
}
if (video_fullscreen_scale == 0)
config_delete_var(cat, "video_fullscreen_scale");
else
config_set_int(cat, "video_fullscreen_scale", video_fullscreen_scale);
if (video_fullscreen_first == 1)
config_delete_var(cat, "video_fullscreen_first");
else
config_set_int(cat, "video_fullscreen_first", video_fullscreen_first);
if (force_43 == 0)
config_delete_var(cat, "force_43");
else
config_set_int(cat, "force_43", force_43);
if (scale == 1)
config_delete_var(cat, "scale");
else
config_set_int(cat, "scale", scale);
if (dpi_scale == 1)
config_delete_var(cat, "dpi_scale");
else
config_set_int(cat, "dpi_scale", dpi_scale);
if (enable_overscan == 0)
config_delete_var(cat, "enable_overscan");
else
config_set_int(cat, "enable_overscan", enable_overscan);
if (vid_cga_contrast == 0)
config_delete_var(cat, "vid_cga_contrast");
else
config_set_int(cat, "vid_cga_contrast", vid_cga_contrast);
if (video_grayscale == 0)
config_delete_var(cat, "video_grayscale");
else
config_set_int(cat, "video_grayscale", video_grayscale);
if (video_graytype == 0)
config_delete_var(cat, "video_graytype");
else
config_set_int(cat, "video_graytype", video_graytype);
if (rctrl_is_lalt == 0)
config_delete_var(cat, "rctrl_is_lalt");
else
config_set_int(cat, "rctrl_is_lalt", rctrl_is_lalt);
if (update_icons == 1)
config_delete_var(cat, "update_icons");
else
config_set_int(cat, "update_icons", update_icons);
if (window_remember) {
config_set_int(cat, "window_remember", window_remember);
sprintf(temp, "%i, %i, %i, %i", window_w, window_h, window_x, window_y);
config_set_string(cat, "window_coordinates", temp);
} else {
config_delete_var(cat, "window_remember");
config_delete_var(cat, "window_coordinates");
}
if (sound_gain != 0)
config_set_int(cat, "sound_gain", sound_gain);
else
config_delete_var(cat, "sound_gain");
if (confirm_reset != 1)
config_set_int(cat, "confirm_reset", confirm_reset);
else
config_delete_var(cat, "confirm_reset");
if (confirm_exit != 1)
config_set_int(cat, "confirm_exit", confirm_exit);
else
config_delete_var(cat, "confirm_exit");
#ifdef USE_LANGUAGE
if (plat_langid == 0x0409)
config_delete_var(cat, "language");
else
config_set_hex16(cat, "language", plat_langid);
#endif
#if USE_DISCORD
if (enable_discord)
config_set_int(cat, "enable_discord", enable_discord);
else
config_delete_var(cat, "enable_discord");
#endif
delete_section_if_empty(cat);
}
/* Save "Machine" section. */
static void
save_machine(void)
{
char *cat = "Machine";
config_set_string(cat, "machine", machine_get_internal_name());
config_set_string(cat, "cpu_family", (char *) cpu_f->internal_name);
config_set_int(cat, "cpu_speed", cpu_f->cpus[cpu].rspeed);
config_set_double(cat, "cpu_multi", cpu_f->cpus[cpu].multi);
config_delete_var(cat, "cpu_manufacturer");
config_delete_var(cat, "cpu");
if (cpu_waitstates == 0)
config_delete_var(cat, "cpu_waitstates");
else
config_set_int(cat, "cpu_waitstates", cpu_waitstates);
if (fpu_type == 0)
config_delete_var(cat, "fpu_type");
else
config_set_string(cat, "fpu_type", (char *) fpu_get_internal_name(cpu_f, cpu, fpu_type));
if (mem_size == 4096)
config_delete_var(cat, "mem_size");
else
config_set_int(cat, "mem_size", mem_size);
config_set_int(cat, "cpu_use_dynarec", cpu_use_dynarec);
if (time_sync & TIME_SYNC_ENABLED)
if (time_sync & TIME_SYNC_UTC)
config_set_string(cat, "time_sync", "utc");
else
config_set_string(cat, "time_sync", "local");
else
config_set_string(cat, "time_sync", "disabled");
delete_section_if_empty(cat);
}
/* Save "Video" section. */
static void
save_video(void)
{
char *cat = "Video";
config_set_string(cat, "gfxcard",
video_get_internal_name(gfxcard));
if (voodoo_enabled == 0)
config_delete_var(cat, "voodoo");
else
config_set_int(cat, "voodoo", voodoo_enabled);
delete_section_if_empty(cat);
}
/* Save "Input Devices" section. */
static void
save_input_devices(void)
{
char *cat = "Input devices";
char temp[512], tmp2[512];
int c, d;
config_set_string(cat, "mouse_type", mouse_get_internal_name(mouse_type));
if (joystick_type == JOYSTICK_TYPE_NONE) {
config_delete_var(cat, "joystick_type");
for (c = 0; c < 16; c++) {
sprintf(tmp2, "joystick_%i_nr", c);
config_delete_var(cat, tmp2);
for (d=0; d<16; d++) {
sprintf(tmp2, "joystick_%i_axis_%i", c, d);
config_delete_var(cat, tmp2);
}
for (d=0; d<16; d++) {
sprintf(tmp2, "joystick_%i_button_%i", c, d);
config_delete_var(cat, tmp2);
}
for (d=0; d<16; d++) {
sprintf(tmp2, "joystick_%i_pov_%i", c, d);
config_delete_var(cat, tmp2);
}
}
} else {
config_set_int(cat, "joystick_type", joystick_type);
for (c = 0; c < joystick_get_max_joysticks(joystick_type); c++) {
sprintf(tmp2, "joystick_%i_nr", c);
config_set_int(cat, tmp2, joystick_state[c].plat_joystick_nr);
if (joystick_state[c].plat_joystick_nr) {
for (d=0; d<joystick_get_axis_count(joystick_type); d++) {
sprintf(tmp2, "joystick_%i_axis_%i", c, d);
config_set_int(cat, tmp2, joystick_state[c].axis_mapping[d]);
}
for (d=0; d<joystick_get_button_count(joystick_type); d++) {
sprintf(tmp2, "joystick_%i_button_%i", c, d);
config_set_int(cat, tmp2, joystick_state[c].button_mapping[d]);
}
for (d=0; d<joystick_get_pov_count(joystick_type); d++) {
sprintf(tmp2, "joystick_%i_pov_%i", c, d);
sprintf(temp, "%i, %i", joystick_state[c].pov_mapping[d][0], joystick_state[c].pov_mapping[d][1]);
config_set_string(cat, tmp2, temp);
}
}
}
}
delete_section_if_empty(cat);
}
/* Save "Sound" section. */
static void
save_sound(void)
{
char *cat = "Sound";
if (sound_card_current == 0)
config_delete_var(cat, "sndcard");
else
config_set_string(cat, "sndcard", sound_card_get_internal_name(sound_card_current));
if (!strcmp(midi_device_get_internal_name(midi_device_current), "none"))
config_delete_var(cat, "midi_device");
else
config_set_string(cat, "midi_device", midi_device_get_internal_name(midi_device_current));
if (!strcmp(midi_in_device_get_internal_name(midi_input_device_current), "none"))
config_delete_var(cat, "midi_in_device");
else
config_set_string(cat, "midi_in_device", midi_in_device_get_internal_name(midi_input_device_current));
if (mpu401_standalone_enable == 0)
config_delete_var(cat, "mpu401_standalone");
else
config_set_int(cat, "mpu401_standalone", mpu401_standalone_enable);
if (SSI2001 == 0)
config_delete_var(cat, "ssi2001");
else
config_set_int(cat, "ssi2001", SSI2001);
if (GAMEBLASTER == 0)
config_delete_var(cat, "gameblaster");
else
config_set_int(cat, "gameblaster", GAMEBLASTER);
if (GUS == 0)
config_delete_var(cat, "gus");
else
config_set_int(cat, "gus", GUS);
if (sound_is_float == 1)
config_delete_var(cat, "sound_type");
else
config_set_string(cat, "sound_type", (sound_is_float == 1) ? "float" : "int16");
delete_section_if_empty(cat);
}
/* Save "Network" section. */
static void
save_network(void)
{
char *cat = "Network";
if (network_type == NET_TYPE_NONE)
config_delete_var(cat, "net_type");
else
config_set_string(cat, "net_type",
(network_type == NET_TYPE_SLIRP) ? "slirp" : "pcap");
if (network_host[0] != '\0') {
if (! strcmp(network_host, "none"))
config_delete_var(cat, "net_host_device");
else
config_set_string(cat, "net_host_device", network_host);
} else {
/* config_set_string(cat, "net_host_device", "none"); */
config_delete_var(cat, "net_host_device");
}
if (network_card == 0)
config_delete_var(cat, "net_card");
else
config_set_string(cat, "net_card",
network_card_get_internal_name(network_card));
delete_section_if_empty(cat);
}
/* Save "Ports" section. */
static void
save_ports(void)
{
char *cat = "Ports (COM & LPT)";
char temp[512];
int c, d;
for (c = 0; c < 4; c++) {
sprintf(temp, "serial%d_enabled", c + 1);
if (((c < 2) && serial_enabled[c]) || ((c >= 2) && !serial_enabled[c]))
config_delete_var(cat, temp);
else
config_set_int(cat, temp, serial_enabled[c]);
}
for (c = 0; c < 3; c++) {
sprintf(temp, "lpt%d_enabled", c + 1);
d = (c == 0) ? 1 : 0;
if (lpt_ports[c].enabled == d)
config_delete_var(cat, temp);
else
config_set_int(cat, temp, lpt_ports[c].enabled);
sprintf(temp, "lpt%d_device", c + 1);
if (lpt_ports[c].device == 0)
config_delete_var(cat, temp);
else
config_set_string(cat, temp,
(char *) lpt_device_get_internal_name(lpt_ports[c].device));
}
delete_section_if_empty(cat);
}
/* Save "Other Peripherals" section. */
static void
save_other_peripherals(void)
{
char *cat = "Other peripherals";
char temp[512];
int c;
if (scsi_card_current == 0)
config_delete_var(cat, "scsicard");
else
config_set_string(cat, "scsicard",
scsi_card_get_internal_name(scsi_card_current));
if (fdc_type == FDC_INTERNAL)
config_delete_var(cat, "fdc");
else
config_set_string(cat, "fdc",
fdc_card_get_internal_name(fdc_type));
config_set_string(cat, "hdc",
hdc_get_internal_name(hdc_current));
if (ide_ter_enabled == 0)
config_delete_var(cat, "ide_ter");
else
config_set_int(cat, "ide_ter", ide_ter_enabled);
if (ide_qua_enabled == 0)
config_delete_var(cat, "ide_qua");
else
config_set_int(cat, "ide_qua", ide_qua_enabled);
if (bugger_enabled == 0)
config_delete_var(cat, "bugger_enabled");
else
config_set_int(cat, "bugger_enabled", bugger_enabled);
if (postcard_enabled == 0)
config_delete_var(cat, "postcard_enabled");
else
config_set_int(cat, "postcard_enabled", postcard_enabled);
for (c = 0; c < ISAMEM_MAX; c++) {
sprintf(temp, "isamem%d_type", c);
if (isamem_type[c] == 0)
config_delete_var(cat, temp);
else
config_set_string(cat, temp,
(char *) isamem_get_internal_name(isamem_type[c]));
}
if (isartc_type == 0)
config_delete_var(cat, "isartc_type");
else
config_set_string(cat, "isartc_type",
isartc_get_internal_name(isartc_type));
delete_section_if_empty(cat);
}
/* Save "Hard Disks" section. */
static void
save_hard_disks(void)
{
char *cat = "Hard disks";
char temp[32], tmp2[512];
char *p;
int c;
memset(temp, 0x00, sizeof(temp));
for (c=0; c<HDD_NUM; c++) {
sprintf(temp, "hdd_%02i_parameters", c+1);
if (hdd_is_valid(c)) {
p = hdd_bus_to_string(hdd[c].bus, 0);
sprintf(tmp2, "%u, %u, %u, %i, %s",
hdd[c].spt, hdd[c].hpc, hdd[c].tracks, hdd[c].wp, p);
config_set_string(cat, temp, tmp2);
} else {
config_delete_var(cat, temp);
}
sprintf(temp, "hdd_%02i_mfm_channel", c+1);
if (hdd_is_valid(c) && (hdd[c].bus == HDD_BUS_MFM))
config_set_int(cat, temp, hdd[c].mfm_channel);
else
config_delete_var(cat, temp);
sprintf(temp, "hdd_%02i_xta_channel", c+1);
if (hdd_is_valid(c) && (hdd[c].bus == HDD_BUS_XTA))
config_set_int(cat, temp, hdd[c].xta_channel);
else
config_delete_var(cat, temp);
sprintf(temp, "hdd_%02i_esdi_channel", c+1);
if (hdd_is_valid(c) && (hdd[c].bus == HDD_BUS_ESDI))
config_set_int(cat, temp, hdd[c].esdi_channel);
else
config_delete_var(cat, temp);
sprintf(temp, "hdd_%02i_ide_channel", c+1);
if (! hdd_is_valid(c) || (hdd[c].bus != HDD_BUS_IDE)) {
config_delete_var(cat, temp);
} else {
sprintf(tmp2, "%01u:%01u", hdd[c].ide_channel >> 1, hdd[c].ide_channel & 1);
config_set_string(cat, temp, tmp2);
}
sprintf(temp, "hdd_%02i_scsi_id", c+1);
if (hdd_is_valid(c) && (hdd[c].bus == HDD_BUS_SCSI))
config_set_int(cat, temp, hdd[c].scsi_id);
else
config_delete_var(cat, temp);
sprintf(temp, "hdd_%02i_fn", c+1);
if (hdd_is_valid(c) && (wcslen(hdd[c].fn) != 0))
if (!wcsnicmp(hdd[c].fn, usr_path, wcslen(usr_path)))
config_set_wstring(cat, temp, &hdd[c].fn[wcslen(usr_path)]);
else
config_set_wstring(cat, temp, hdd[c].fn);
else
config_delete_var(cat, temp);
}
delete_section_if_empty(cat);
}
/* Save "Floppy Drives" section. */
static void
save_floppy_and_cdrom_drives(void)
{
char *cat = "Floppy and CD-ROM drives";
char temp[512], tmp2[512];
int c;
for (c=0; c<FDD_NUM; c++) {
sprintf(temp, "fdd_%02i_type", c+1);
if (fdd_get_type(c) == ((c < 2) ? 2 : 0))
config_delete_var(cat, temp);
else
config_set_string(cat, temp,
fdd_get_internal_name(fdd_get_type(c)));
sprintf(temp, "fdd_%02i_fn", c+1);
if (wcslen(floppyfns[c]) == 0) {
config_delete_var(cat, temp);
ui_writeprot[c] = 0;
sprintf(temp, "fdd_%02i_writeprot", c+1);
config_delete_var(cat, temp);
} else {
config_set_wstring(cat, temp, floppyfns[c]);
}
sprintf(temp, "fdd_%02i_writeprot", c+1);
if (ui_writeprot[c] == 0)
config_delete_var(cat, temp);
else
config_set_int(cat, temp, ui_writeprot[c]);
sprintf(temp, "fdd_%02i_turbo", c+1);
if (fdd_get_turbo(c) == 0)
config_delete_var(cat, temp);
else
config_set_int(cat, temp, fdd_get_turbo(c));
sprintf(temp, "fdd_%02i_check_bpb", c+1);
if (fdd_get_check_bpb(c) == 1)
config_delete_var(cat, temp);
else
config_set_int(cat, temp, fdd_get_check_bpb(c));
}
for (c=0; c<CDROM_NUM; c++) {
sprintf(temp, "cdrom_%02i_host_drive", c+1);
if ((cdrom[c].bus_type == 0) || (cdrom[c].host_drive != 200)) {
config_delete_var(cat, temp);
} else {
config_set_int(cat, temp, cdrom[c].host_drive);
}
sprintf(temp, "cdrom_%02i_speed", c+1);
if ((cdrom[c].bus_type == 0) || (cdrom[c].speed == 8)) {
config_delete_var(cat, temp);
} else {
config_set_int(cat, temp, cdrom[c].speed);
}
sprintf(temp, "cdrom_%02i_parameters", c+1);
if (cdrom[c].bus_type == 0) {
config_delete_var(cat, temp);
} else {
sprintf(tmp2, "%u, %s", cdrom[c].sound_on,
hdd_bus_to_string(cdrom[c].bus_type, 1));
config_set_string(cat, temp, tmp2);
}
sprintf(temp, "cdrom_%02i_ide_channel", c+1);
if (cdrom[c].bus_type != CDROM_BUS_ATAPI)
config_delete_var(cat, temp);
else {
sprintf(tmp2, "%01u:%01u", cdrom[c].ide_channel>>1,
cdrom[c].ide_channel & 1);
config_set_string(cat, temp, tmp2);
}
sprintf(temp, "cdrom_%02i_scsi_id", c + 1);
if (cdrom[c].bus_type != CDROM_BUS_SCSI) {
config_delete_var(cat, temp);
} else {
config_set_int(cat, temp, cdrom[c].scsi_device_id);
}
sprintf(temp, "cdrom_%02i_image_path", c + 1);
if ((cdrom[c].bus_type == 0) ||
(wcslen(cdrom[c].image_path) == 0)) {
config_delete_var(cat, temp);
} else {
config_set_wstring(cat, temp, cdrom[c].image_path);
}
}
delete_section_if_empty(cat);
}
/* Save "Other Removable Devices" section. */
static void
save_other_removable_devices(void)
{
char *cat = "Other removable devices";
char temp[512], tmp2[512];
int c;
for (c=0; c<ZIP_NUM; c++) {
sprintf(temp, "zip_%02i_parameters", c+1);
if (zip_drives[c].bus_type == 0) {
config_delete_var(cat, temp);
} else {
sprintf(tmp2, "%u, %s", zip_drives[c].is_250,
hdd_bus_to_string(zip_drives[c].bus_type, 1));
config_set_string(cat, temp, tmp2);
}
sprintf(temp, "zip_%02i_ide_channel", c+1);
if (zip_drives[c].bus_type != ZIP_BUS_ATAPI)
config_delete_var(cat, temp);
else {
sprintf(tmp2, "%01u:%01u", zip_drives[c].ide_channel>>1,
zip_drives[c].ide_channel & 1);
config_set_string(cat, temp, tmp2);
}
sprintf(temp, "zip_%02i_scsi_id", c + 1);
if (zip_drives[c].bus_type != ZIP_BUS_SCSI) {
config_delete_var(cat, temp);
} else {
config_set_int(cat, temp, zip_drives[c].scsi_device_id);
}
sprintf(temp, "zip_%02i_image_path", c + 1);
if ((zip_drives[c].bus_type == 0) ||
(wcslen(zip_drives[c].image_path) == 0)) {
config_delete_var(cat, temp);
} else {
config_set_wstring(cat, temp, zip_drives[c].image_path);
}
}
for (c=0; c<MO_NUM; c++) {
sprintf(temp, "mo_%02i_parameters", c+1);
if (mo_drives[c].bus_type == 0) {
config_delete_var(cat, temp);
} else {
sprintf(tmp2, "%u, %s", mo_drives[c].type,
hdd_bus_to_string(mo_drives[c].bus_type, 1));
config_set_string(cat, temp, tmp2);
}
sprintf(temp, "mo_%02i_ide_channel", c+1);
if (mo_drives[c].bus_type != MO_BUS_ATAPI)
config_delete_var(cat, temp);
else {
sprintf(tmp2, "%01u:%01u", mo_drives[c].ide_channel>>1,
mo_drives[c].ide_channel & 1);
config_set_string(cat, temp, tmp2);
}
sprintf(temp, "mo_%02i_scsi_id", c + 1);
if (mo_drives[c].bus_type != MO_BUS_SCSI) {
config_delete_var(cat, temp);
} else {
config_set_int(cat, temp, mo_drives[c].scsi_device_id);
}
sprintf(temp, "mo_%02i_image_path", c + 1);
if ((mo_drives[c].bus_type == 0) ||
(wcslen(mo_drives[c].image_path) == 0)) {
config_delete_var(cat, temp);
} else {
config_set_wstring(cat, temp, mo_drives[c].image_path);
}
}
delete_section_if_empty(cat);
}
void
config_save(void)
{
save_general(); /* General */
save_machine(); /* Machine */
save_video(); /* Video */
save_input_devices(); /* Input devices */
save_sound(); /* Sound */
save_network(); /* Network */
save_ports(); /* Ports (COM & LPT) */
save_other_peripherals(); /* Other peripherals */
save_hard_disks(); /* Hard disks */
save_floppy_and_cdrom_drives(); /* Floppy and CD-ROM drives */
save_other_removable_devices(); /* Other removable devices */
config_write(cfg_path);
}
void
config_dump(void)
{
section_t *sec;
sec = (section_t *)config_head.next;
while (sec != NULL) {
entry_t *ent;
if (sec->name[0])
config_log("[%s]\n", sec->name);
ent = (entry_t *)sec->entry_head.next;
while (ent != NULL) {
config_log("%s = %ls\n", ent->name, ent->wdata);
ent = (entry_t *)ent->list.next;
}
sec = (section_t *)sec->list.next;
}
}
void
config_delete_var(char *head, char *name)
{
section_t *section;
entry_t *entry;
section = find_section(head);
if (section == NULL) return;
entry = find_entry(section, name);
if (entry != NULL) {
list_delete(&entry->list, &section->entry_head);
free(entry);
}
}
int
config_get_int(char *head, char *name, int def)
{
section_t *section;
entry_t *entry;
int value;
section = find_section(head);
if (section == NULL)
return(def);
entry = find_entry(section, name);
if (entry == NULL)
return(def);
sscanf(entry->data, "%i", &value);
return(value);
}
double
config_get_double(char *head, char *name, double def)
{
section_t *section;
entry_t *entry;
double value;
section = find_section(head);
if (section == NULL)
return(def);
entry = find_entry(section, name);
if (entry == NULL)
return(def);
sscanf(entry->data, "%lg", &value);
return(value);
}
int
config_get_hex16(char *head, char *name, int def)
{
section_t *section;
entry_t *entry;
unsigned int value;
section = find_section(head);
if (section == NULL)
return(def);
entry = find_entry(section, name);
if (entry == NULL)
return(def);
sscanf(entry->data, "%04X", &value);
return(value);
}
int
config_get_hex20(char *head, char *name, int def)
{
section_t *section;
entry_t *entry;
unsigned int value;
section = find_section(head);
if (section == NULL)
return(def);
entry = find_entry(section, name);
if (entry == NULL)
return(def);
sscanf(entry->data, "%05X", &value);
return(value);
}
int
config_get_mac(char *head, char *name, int def)
{
section_t *section;
entry_t *entry;
unsigned int val0 = 0, val1 = 0, val2 = 0;
section = find_section(head);
if (section == NULL)
return(def);
entry = find_entry(section, name);
if (entry == NULL)
return(def);
sscanf(entry->data, "%02x:%02x:%02x", &val0, &val1, &val2);
return((val0 << 16) + (val1 << 8) + val2);
}
char *
config_get_string(char *head, char *name, char *def)
{
section_t *section;
entry_t *entry;
section = find_section(head);
if (section == NULL)
return(def);
entry = find_entry(section, name);
if (entry == NULL)
return(def);
return(entry->data);
}
wchar_t *
config_get_wstring(char *head, char *name, wchar_t *def)
{
section_t *section;
entry_t *entry;
section = find_section(head);
if (section == NULL)
return(def);
entry = find_entry(section, name);
if (entry == NULL)
return(def);
return(entry->wdata);
}
void
config_set_int(char *head, char *name, int val)
{
section_t *section;
entry_t *ent;
section = find_section(head);
if (section == NULL)
section = create_section(head);
ent = find_entry(section, name);
if (ent == NULL)
ent = create_entry(section, name);
sprintf(ent->data, "%i", val);
mbstowcs(ent->wdata, ent->data, 512);
}
void
config_set_double(char *head, char *name, double val)
{
section_t *section;
entry_t *ent;
section = find_section(head);
if (section == NULL)
section = create_section(head);
ent = find_entry(section, name);
if (ent == NULL)
ent = create_entry(section, name);
sprintf(ent->data, "%lg", val);
mbstowcs(ent->wdata, ent->data, 512);
}
void
config_set_hex16(char *head, char *name, int val)
{
section_t *section;
entry_t *ent;
section = find_section(head);
if (section == NULL)
section = create_section(head);
ent = find_entry(section, name);
if (ent == NULL)
ent = create_entry(section, name);
sprintf(ent->data, "%04X", val);
mbstowcs(ent->wdata, ent->data, sizeof_w(ent->wdata));
}
void
config_set_hex20(char *head, char *name, int val)
{
section_t *section;
entry_t *ent;
section = find_section(head);
if (section == NULL)
section = create_section(head);
ent = find_entry(section, name);
if (ent == NULL)
ent = create_entry(section, name);
sprintf(ent->data, "%05X", val);
mbstowcs(ent->wdata, ent->data, sizeof_w(ent->wdata));
}
void
config_set_mac(char *head, char *name, int val)
{
section_t *section;
entry_t *ent;
section = find_section(head);
if (section == NULL)
section = create_section(head);
ent = find_entry(section, name);
if (ent == NULL)
ent = create_entry(section, name);
sprintf(ent->data, "%02x:%02x:%02x",
(val>>16)&0xff, (val>>8)&0xff, val&0xff);
mbstowcs(ent->wdata, ent->data, 512);
}
void
config_set_string(char *head, char *name, char *val)
{
section_t *section;
entry_t *ent;
section = find_section(head);
if (section == NULL)
section = create_section(head);
ent = find_entry(section, name);
if (ent == NULL)
ent = create_entry(section, name);
if ((strlen(val) + 1) <= sizeof(ent->data))
memcpy(ent->data, val, strlen(val) + 1);
else
memcpy(ent->data, val, sizeof(ent->data));
mbstowcs(ent->wdata, ent->data, sizeof_w(ent->wdata));
}
void
config_set_wstring(char *head, char *name, wchar_t *val)
{
section_t *section;
entry_t *ent;
section = find_section(head);
if (section == NULL)
section = create_section(head);
ent = find_entry(section, name);
if (ent == NULL)
ent = create_entry(section, name);
memcpy(ent->wdata, val, sizeof_w(ent->wdata));
wcstombs(ent->data, ent->wdata, sizeof(ent->data));
}
View Git Blame Copy Permalink