EXPORT m64p_error CALL ConfigSetParameter(m64p_handle ConfigSectionHandle, const char *ParamName, m64p_type ParamType, const void *ParamValue)
{
config_section *section;
config_var *var;
/* check input conditions */
if (!l_ConfigInit)
return M64ERR_NOT_INIT;
if (ConfigSectionHandle == NULL || ParamName == NULL || ParamValue == NULL || (int) ParamType < 1 || (int) ParamType > 4)
return M64ERR_INPUT_ASSERT;
section = (config_section *) ConfigSectionHandle;
if (section->magic != SECTION_MAGIC)
return M64ERR_INPUT_INVALID;
/* if this parameter doesn't already exist, then create it and add it to the section */
var = find_section_var(section, ParamName);
if (var == NULL)
{
var = (config_var *) malloc(sizeof(config_var));
if (var == NULL)
return M64ERR_NO_MEMORY;
strncpy(var->name, ParamName, 63);
var->name[63] = 0;
var->type = M64TYPE_INT;
var->val_int = 0;
var->val_string = NULL;
var->comment = NULL;
var->next = NULL;
append_var_to_section(section, var);
}
/* set this parameter's value */
var->type = ParamType;
switch(ParamType)
{
case M64TYPE_INT:
var->val_int = *((int *) ParamValue);
break;
case M64TYPE_FLOAT:
var->val_float = *((float *) ParamValue);
break;
case M64TYPE_BOOL:
var->val_int = (*((int *) ParamValue) != 0);
break;
case M64TYPE_STRING:
if (var->val_string != NULL)
free(var->val_string);
var->val_string = (char *) malloc(strlen((char *) ParamValue) + 1);
if (var->val_string == NULL)
return M64ERR_NO_MEMORY;
memcpy(var->val_string, ParamValue, strlen((char *) ParamValue) + 1);
break;
default:
/* this is logically impossible because of the ParamType check at the top of this function */
break;
}
return M64ERR_SUCCESS;
}
EXPORT m64p_error CALL ConfigSetParameter(m64p_handle ConfigSectionHandle, const char *ParamName, m64p_type ParamType, const void *ParamValue)
{
config_section *section;
config_var *var;
/* check input conditions */
if (!l_ConfigInit)
return M64ERR_NOT_INIT;
if (ConfigSectionHandle == NULL || ParamName == NULL || ParamValue == NULL || (int) ParamType < 1 || (int) ParamType > 4)
return M64ERR_INPUT_ASSERT;
section = (config_section *) ConfigSectionHandle;
if (section->magic != SECTION_MAGIC)
return M64ERR_INPUT_INVALID;
/* if this parameter doesn't already exist, then create it and add it to the section */
var = find_section_var(section, ParamName);
if (var == NULL)
{
var = config_var_create(ParamName, NULL);
if (var == NULL)
return M64ERR_NO_MEMORY;
append_var_to_section(section, var);
}
/* cleanup old values */
switch (var->type)
{
case M64TYPE_STRING:
free(var->val.string);
break;
default:
break;
}
/* set this parameter's value */
var->type = ParamType;
switch(ParamType)
{
case M64TYPE_INT:
var->val.integer = *((int *) ParamValue);
break;
case M64TYPE_FLOAT:
var->val.number = *((float *) ParamValue);
break;
case M64TYPE_BOOL:
var->val.integer = (*((int *) ParamValue) != 0);
break;
case M64TYPE_STRING:
var->val.string = strdup((char *)ParamValue);
if (var->val.string == NULL)
return M64ERR_NO_MEMORY;
break;
default:
/* this is logically impossible because of the ParamType check at the top of this function */
break;
}
return M64ERR_SUCCESS;
}
EXPORT m64p_error CALL ConfigSetDefaultString(m64p_handle ConfigSectionHandle, const char *ParamName, const char * ParamValue, const char *ParamHelp)
{
config_section *section;
config_var *var;
/* check input conditions */
if (!l_ConfigInit)
return M64ERR_NOT_INIT;
if (ConfigSectionHandle == NULL || ParamName == NULL || ParamValue == NULL)
return M64ERR_INPUT_ASSERT;
section = (config_section *) ConfigSectionHandle;
if (section->magic != SECTION_MAGIC)
return M64ERR_INPUT_INVALID;
/* if this parameter already exists, then just return successfully */
var = find_section_var(section, ParamName);
if (var != NULL)
return M64ERR_SUCCESS;
/* otherwise create a new config_var object and add it to this section */
var = config_var_create(ParamName, ParamHelp);
if (var == NULL)
return M64ERR_NO_MEMORY;
var->type = M64TYPE_STRING;
var->val.string = strdup(ParamValue);
if (var->val.string == NULL)
{
delete_var(var);
return M64ERR_NO_MEMORY;
}
append_var_to_section(section, var);
return M64ERR_SUCCESS;
}
EXPORT m64p_error CALL ConfigSetParameterHelp(m64p_handle ConfigSectionHandle, const char *ParamName, const char *ParamHelp)
{
config_section *section;
config_var *var;
/* check input conditions */
if (!l_ConfigInit)
return M64ERR_NOT_INIT;
if (ConfigSectionHandle == NULL || ParamName == NULL || ParamHelp == NULL)
return M64ERR_INPUT_ASSERT;
section = (config_section *) ConfigSectionHandle;
if (section->magic != SECTION_MAGIC)
return M64ERR_INPUT_INVALID;
/* if this parameter doesn't already exist, return an error */
var = find_section_var(section, ParamName);
if (var == NULL)
return M64ERR_INPUT_NOT_FOUND;
if (var->comment != NULL)
free(var->comment);
var->comment = strdup(ParamHelp);
return M64ERR_SUCCESS;
}
EXPORT m64p_error CALL ConfigGetParameter(m64p_handle ConfigSectionHandle, const char *ParamName, m64p_type ParamType, void *ParamValue, int MaxSize)
{
config_section *section;
config_var *var;
/* check input conditions */
if (!l_ConfigInit)
return M64ERR_NOT_INIT;
if (ConfigSectionHandle == NULL || ParamName == NULL || ParamValue == NULL || (int) ParamType < 1 || (int) ParamType > 4)
return M64ERR_INPUT_ASSERT;
section = (config_section *) ConfigSectionHandle;
if (section->magic != SECTION_MAGIC)
return M64ERR_INPUT_INVALID;
/* if this parameter doesn't already exist, return an error */
var = find_section_var(section, ParamName);
if (var == NULL)
return M64ERR_INPUT_NOT_FOUND;
/* call the specific Get function to translate the parameter to the desired type */
switch(ParamType)
{
case M64TYPE_INT:
if (MaxSize < sizeof(int)) return M64ERR_INPUT_INVALID;
if (var->type != M64TYPE_INT && var->type != M64TYPE_FLOAT) return M64ERR_WRONG_TYPE;
*((int *) ParamValue) = ConfigGetParamInt(ConfigSectionHandle, ParamName);
break;
case M64TYPE_FLOAT:
if (MaxSize < sizeof(float)) return M64ERR_INPUT_INVALID;
if (var->type != M64TYPE_INT && var->type != M64TYPE_FLOAT) return M64ERR_WRONG_TYPE;
*((float *) ParamValue) = ConfigGetParamFloat(ConfigSectionHandle, ParamName);
break;
case M64TYPE_BOOL:
if (MaxSize < sizeof(int)) return M64ERR_INPUT_INVALID;
if (var->type != M64TYPE_BOOL && var->type != M64TYPE_INT) return M64ERR_WRONG_TYPE;
*((int *) ParamValue) = ConfigGetParamBool(ConfigSectionHandle, ParamName);
break;
case M64TYPE_STRING:
{
const char *string;
if (MaxSize < 1) return M64ERR_INPUT_INVALID;
if (var->type != M64TYPE_STRING && var->type != M64TYPE_BOOL) return M64ERR_WRONG_TYPE;
string = ConfigGetParamString(ConfigSectionHandle, ParamName);
strncpy((char *) ParamValue, string, MaxSize);
*((char *) ParamValue + MaxSize - 1) = 0;
break;
}
default:
/* this is logically impossible because of the ParamType check at the top of this function */
break;
}
return M64ERR_SUCCESS;
}
EXPORT const char * CALL ConfigGetParamString(m64p_handle ConfigSectionHandle, const char *ParamName)
{
static char outstr[64]; /* warning: not thread safe */
config_section *section;
config_var *var;
/* check input conditions */
if (!l_ConfigInit || ConfigSectionHandle == NULL || ParamName == NULL)
{
DebugMessage(M64MSG_ERROR, "ConfigGetParamString(): Input assertion!");
return "";
}
section = (config_section *) ConfigSectionHandle;
if (section->magic != SECTION_MAGIC)
{
DebugMessage(M64MSG_ERROR, "ConfigGetParamString(): ConfigSectionHandle invalid!");
return "";
}
/* if this parameter doesn't already exist, return an error */
var = find_section_var(section, ParamName);
if (var == NULL)
{
DebugMessage(M64MSG_ERROR, "ConfigGetParamString(): Parameter '%s' not found!", ParamName);
return "";
}
/* translate the actual variable type to an int */
switch(var->type)
{
case M64TYPE_INT:
snprintf(outstr, 63, "%i", var->val_int);
outstr[63] = 0;
return outstr;
case M64TYPE_FLOAT:
snprintf(outstr, 63, "%f", var->val_float);
outstr[63] = 0;
return outstr;
case M64TYPE_BOOL:
return (var->val_int ? "True" : "False");
case M64TYPE_STRING:
return var->val_string;
default:
DebugMessage(M64MSG_ERROR, "ConfigGetParamString(): invalid internal parameter type for '%s'", ParamName);
return "";
}
return "";
}
EXPORT int CALL ConfigGetParamBool(m64p_handle ConfigSectionHandle, const char *ParamName)
{
config_section *section;
config_var *var;
/* check input conditions */
if (!l_ConfigInit || ConfigSectionHandle == NULL || ParamName == NULL)
{
DebugMessage(M64MSG_ERROR, "ConfigGetParamBool(): Input assertion!");
return 0;
}
section = (config_section *) ConfigSectionHandle;
if (section->magic != SECTION_MAGIC)
{
DebugMessage(M64MSG_ERROR, "ConfigGetParamBool(): ConfigSectionHandle invalid!");
return 0;
}
/* if this parameter doesn't already exist, return an error */
var = find_section_var(section, ParamName);
if (var == NULL)
{
DebugMessage(M64MSG_ERROR, "ConfigGetParamBool(): Parameter '%s' not found!", ParamName);
return 0;
}
/* translate the actual variable type to an int */
switch(var->type)
{
case M64TYPE_INT:
return (var->val_int != 0);
case M64TYPE_FLOAT:
return (var->val_float != 0.0);
case M64TYPE_BOOL:
return var->val_int;
case M64TYPE_STRING:
return (osal_insensitive_strcmp(var->val_string, "true") == 0);
default:
DebugMessage(M64MSG_ERROR, "ConfigGetParamBool(): invalid internal parameter type for '%s'", ParamName);
return 0;
}
return 0;
}
EXPORT m64p_error CALL ConfigSetDefaultString(m64p_handle ConfigSectionHandle, const char *ParamName, const char * ParamValue, const char *ParamHelp)
{
config_section *section;
config_var *var;
/* check input conditions */
if (!l_ConfigInit)
return M64ERR_NOT_INIT;
if (ConfigSectionHandle == NULL || ParamName == NULL || ParamValue == NULL)
return M64ERR_INPUT_ASSERT;
section = (config_section *) ConfigSectionHandle;
if (section->magic != SECTION_MAGIC)
return M64ERR_INPUT_INVALID;
/* if this parameter already exists, then just return successfully */
var = find_section_var(section, ParamName);
if (var != NULL)
return M64ERR_SUCCESS;
/* otherwise create a new config_var object and add it to this section */
var = (config_var *) malloc(sizeof(config_var));
if (var == NULL)
return M64ERR_NO_MEMORY;
strncpy(var->name, ParamName, 63);
var->name[63] = 0;
var->type = M64TYPE_STRING;
var->val_string = (char *) malloc(strlen(ParamValue) + 1);
if (var->val_string == NULL)
return M64ERR_NO_MEMORY;
strcpy(var->val_string, ParamValue);
if (ParamHelp == NULL)
var->comment = NULL;
else
{
var->comment = (char *) malloc(strlen(ParamHelp) + 1);
if (var->comment == NULL)
return M64ERR_NO_MEMORY;
strcpy(var->comment, ParamHelp);
}
var->next = NULL;
append_var_to_section(section, var);
return M64ERR_SUCCESS;
}
EXPORT float CALL ConfigGetParamFloat(m64p_handle ConfigSectionHandle, const char *ParamName)
{
config_section *section;
config_var *var;
/* check input conditions */
if (!l_ConfigInit || ConfigSectionHandle == NULL || ParamName == NULL)
{
DebugMessage(M64MSG_ERROR, "ConfigGetParamFloat(): Input assertion!");
return 0.0;
}
section = (config_section *) ConfigSectionHandle;
if (section->magic != SECTION_MAGIC)
{
DebugMessage(M64MSG_ERROR, "ConfigGetParamFloat(): ConfigSectionHandle invalid!");
return 0.0;
}
/* if this parameter doesn't already exist, return an error */
var = find_section_var(section, ParamName);
if (var == NULL)
{
DebugMessage(M64MSG_ERROR, "ConfigGetParamFloat(): Parameter '%s' not found!", ParamName);
return 0.0;
}
/* translate the actual variable type to a float */
switch(var->type)
{
case M64TYPE_INT:
return (float) var->val.integer;
case M64TYPE_FLOAT:
return var->val.number;
case M64TYPE_BOOL:
return (var->val.integer != 0) ? 1.0f : 0.0f;
case M64TYPE_STRING:
return (float) atof(var->val.string);
default:
DebugMessage(M64MSG_ERROR, "ConfigGetParamFloat(): invalid internal parameter type for '%s'", ParamName);
return 0.0;
}
}
EXPORT const char * CALL ConfigGetParameterHelp(m64p_handle ConfigSectionHandle, const char *ParamName)
{
config_section *section;
config_var *var;
/* check input conditions */
if (!l_ConfigInit || ConfigSectionHandle == NULL || ParamName == NULL)
return NULL;
section = (config_section *) ConfigSectionHandle;
if (section->magic != SECTION_MAGIC)
return NULL;
/* if this parameter doesn't exist, return an error */
var = find_section_var(section, ParamName);
if (var == NULL)
return NULL;
return var->comment;
}
EXPORT m64p_error CALL ConfigGetParameterType(m64p_handle ConfigSectionHandle, const char *ParamName, m64p_type *ParamType)
{
config_section *section;
config_var *var;
/* check input conditions */
if (!l_ConfigInit)
return M64ERR_NOT_INIT;
if (ConfigSectionHandle == NULL || ParamName == NULL || ParamType == NULL)
return M64ERR_INPUT_ASSERT;
section = (config_section *) ConfigSectionHandle;
if (section->magic != SECTION_MAGIC)
return M64ERR_INPUT_INVALID;
/* if this parameter doesn't already exist, return an error */
var = find_section_var(section, ParamName);
if (var == NULL)
return M64ERR_INPUT_NOT_FOUND;
*ParamType = var->type;
return M64ERR_SUCCESS;
}
EXPORT int CALL ConfigGetParamInt(m64p_handle ConfigSectionHandle, const char *ParamName)
{
config_section *section;
config_var *var;
#ifdef __LIBRETRO__ // Conifg overrides
static const struct
{
const char* ParamName;
const char* RetroName;
const value_pair Values[4];
} libretro_translate[] =
{
{ "R4300Emulator", "mupen64-cpucore", { { 0, "pure_interpreter" }, { 1, "cached_interpreter" }, { 2, "dynamic_recompiler" }, { 0, 0 } } },
{ "DisableExtraMem", "mupen64-disableexpmem", { { 0, "no" }, { 1, "yes" }, { 0, 0 } } },
{ "ScreenWidth", "mupen64-screensize", { { 320, "320x240" }, { 640, "640x480" }, { 1280, "1280x960" }, { 0, 0 } } },
{ "ScreenHeight", "mupen64-screensize", { { 240, "320x240" }, { 480, "640x480" }, { 960, "1280x960" }, { 0, 0 } } },
0
};
for (int i = 0; libretro_translate[i].ParamName; i ++)
{
if (strcmp(ParamName, libretro_translate[i].ParamName) == 0)
{
int result = choose_value(libretro_translate[i].RetroName, libretro_translate[i].Values);
if (result >= 0)
return result;
break;
}
}
#endif
/* check input conditions */
if (!l_ConfigInit || ConfigSectionHandle == NULL || ParamName == NULL)
{
DebugMessage(M64MSG_ERROR, "ConfigGetParamInt(): Input assertion!");
return 0;
}
section = (config_section *) ConfigSectionHandle;
if (section->magic != SECTION_MAGIC)
{
DebugMessage(M64MSG_ERROR, "ConfigGetParamInt(): ConfigSectionHandle invalid!");
return 0;
}
/* if this parameter doesn't already exist, return an error */
var = find_section_var(section, ParamName);
if (var == NULL)
{
DebugMessage(M64MSG_ERROR, "ConfigGetParamInt(): Parameter '%s' not found!", ParamName);
return 0;
}
/* translate the actual variable type to an int */
switch(var->type)
{
case M64TYPE_INT:
return var->val.integer;
case M64TYPE_FLOAT:
return (int) var->val.number;
case M64TYPE_BOOL:
return (var->val.integer != 0);
case M64TYPE_STRING:
return atoi(var->val.string);
default:
DebugMessage(M64MSG_ERROR, "ConfigGetParamInt(): invalid internal parameter type for '%s'", ParamName);
return 0;
}
return 0;
}
