static void imgtool_library_add_class(imgtool_library *library, const imgtool_class *imgclass)
{
imgtool_module *module;
char *s1, *s2;
size_t len;
/* allocate the module and place it in the chain */
module = auto_malloc(sizeof(*module));
memset(module, 0, sizeof(*module));
module->previous = library->last;
if (library->last)
library->last->next = module;
else
library->first = module;
library->last = module;
/* extensions have a weird format */
s1 = imgtool_get_info_string(imgclass, IMGTOOLINFO_STR_FILE_EXTENSIONS);
len = strlen(s1);;
s2 = auto_malloc(len + 2);
strcpy(s2, s1);
s2[len + 1] = '\0';
while((s1 = strchr(s2, ',')) != NULL)
*s1 = '\0';
module->extensions = s2;
module->imgclass = *imgclass;
module->name = auto_strdup(imgtool_get_info_string(imgclass, IMGTOOLINFO_STR_NAME));
module->description = auto_strdup(imgtool_get_info_string(imgclass, IMGTOOLINFO_STR_DESCRIPTION));
module->eoln = auto_strdup_allow_null(imgtool_get_info_string(imgclass, IMGTOOLINFO_STR_EOLN));
module->initial_path_separator = imgtool_get_info_int(imgclass, IMGTOOLINFO_INT_INITIAL_PATH_SEPARATOR) ? 1 : 0;
module->open_is_strict = imgtool_get_info_int(imgclass, IMGTOOLINFO_INT_OPEN_IS_STRICT) ? 1 : 0;
module->tracks_are_called_cylinders = imgtool_get_info_int(imgclass, IMGTOOLINFO_INT_TRACKS_ARE_CALLED_CYLINDERS) ? 1 : 0;
module->writing_untested = imgtool_get_info_int(imgclass, IMGTOOLINFO_INT_WRITING_UNTESTED) ? 1 : 0;
module->creation_untested = imgtool_get_info_int(imgclass, IMGTOOLINFO_INT_CREATION_UNTESTED) ? 1 : 0;
module->open = (imgtoolerr_t (*)(imgtool_image *, imgtool_stream *)) imgtool_get_info_fct(imgclass, IMGTOOLINFO_PTR_OPEN);
module->create = (imgtoolerr_t (*)(imgtool_image *, imgtool_stream *, option_resolution *)) imgtool_get_info_fct(imgclass, IMGTOOLINFO_PTR_CREATE);
module->close = (void (*)(imgtool_image *)) imgtool_get_info_fct(imgclass, IMGTOOLINFO_PTR_CLOSE);
module->info = (void (*)(imgtool_image *, char *, size_t)) imgtool_get_info_fct(imgclass, IMGTOOLINFO_PTR_INFO);
module->read_sector = (imgtoolerr_t (*)(imgtool_image *, UINT32, UINT32, UINT32, void *, size_t)) imgtool_get_info_fct(imgclass, IMGTOOLINFO_PTR_READ_SECTOR);
module->write_sector = (imgtoolerr_t (*)(imgtool_image *, UINT32, UINT32, UINT32, const void *, size_t)) imgtool_get_info_fct(imgclass, IMGTOOLINFO_PTR_WRITE_SECTOR);
module->get_geometry = (imgtoolerr_t (*)(imgtool_image *, UINT32 *, UINT32 *, UINT32 *))imgtool_get_info_fct(imgclass, IMGTOOLINFO_PTR_GET_GEOMETRY);
module->get_sector_size = (imgtoolerr_t (*)(imgtool_image *, UINT32, UINT32, UINT32, UINT32 *))imgtool_get_info_fct(imgclass, IMGTOOLINFO_PTR_GET_SECTOR_SIZE);
module->read_block = (imgtoolerr_t (*)(imgtool_image *, void *, UINT64)) imgtool_get_info_fct(imgclass, IMGTOOLINFO_PTR_READ_BLOCK);
module->write_block = (imgtoolerr_t (*)(imgtool_image *, const void *, UINT64)) imgtool_get_info_fct(imgclass, IMGTOOLINFO_PTR_WRITE_BLOCK);
module->list_partitions = (imgtoolerr_t (*)(imgtool_image *, imgtool_partition_info *, size_t)) imgtool_get_info_fct(imgclass, IMGTOOLINFO_PTR_LIST_PARTITIONS);
module->block_size = imgtool_get_info_int(imgclass, IMGTOOLINFO_INT_BLOCK_SIZE);
module->createimage_optguide = (const struct OptionGuide *) imgtool_get_info_ptr(imgclass, IMGTOOLINFO_PTR_CREATEIMAGE_OPTGUIDE);
module->createimage_optspec = auto_strdup_allow_null(imgtool_get_info_ptr(imgclass, IMGTOOLINFO_STR_CREATEIMAGE_OPTSPEC));
module->image_extra_bytes += imgtool_get_info_int(imgclass, IMGTOOLINFO_INT_IMAGE_EXTRA_BYTES);
}
void inputx_handle_mess_extensions(input_port_entry *ipt)
{
char buf[256];
int i, pos;
unicode_char_t ch;
/* process MESS specific extensions to all ports */
while(ipt->type != IPT_END)
{
/* is this a keyboard port with the default name? */
if (ipt->type == IPT_KEYBOARD && (ipt->name == IP_NAME_DEFAULT))
{
buf[0] = '\0';
pos = 0;
for (i = 0; ipt->keyboard.chars[i] && (i < sizeof(ipt->keyboard.chars)
/ sizeof(ipt->keyboard.chars[0])); i++)
{
ch = ipt->keyboard.chars[i];
pos += sprintf(&buf[pos], "%s ", inputx_key_name(ch));
}
rtrim(buf);
if (buf[0])
ipt->name = auto_strdup(buf);
else
ipt->name = "Unnamed Key";
}
ipt++;
}
}
int uistring_init (mame_file *langfile)
{
/*
TODO: This routine needs to do several things:
- load an external font if needed
- determine the number of characters in the font
- deal with multibyte languages
*/
int i, j, str;
char curline[255];
char section[255] = "\0";
char *ptr;
int string_count;
/* count the total amount of strings */
string_count = 0;
for (i = 0; default_text[i]; i++)
{
for (j = 0; default_text[i][j]; j++)
string_count++;
}
/* allocate the translated text array, and set defaults */
trans_text = auto_malloc(sizeof(const char *) * string_count);
/* copy in references to all of the strings */
str = 0;
for (i = 0; default_text[i]; i++)
{
for (j = 0; default_text[i][j]; j++)
trans_text[str++] = default_text[i][j];
}
memset(&lang, 0, sizeof(lang));
/* if no language file, exit */
if (!langfile)
return 0;
while (mame_fgets (curline, sizeof(curline) / sizeof(curline[0]), langfile) != NULL)
{
/* Ignore commented and blank lines */
if (curline[0] == ';') continue;
if (curline[0] == '\n') continue;
if (curline[0] == '\r') continue;
if (curline[0] == '[')
{
ptr = strtok (&curline[1], "]");
/* Found a section, indicate as such */
strcpy (section, ptr);
/* Skip to the next line */
continue;
}
/* Parse the LangInfo section */
if (strcmp (section, "LangInfo") == 0)
{
ptr = strtok (curline, "=");
if (strcmp (ptr, "Version") == 0)
{
ptr = strtok (NULL, "\n\r");
sscanf (ptr, "%d", &lang.version);
}
else if (strcmp (ptr, "Language") == 0)
{
ptr = strtok (NULL, "\n\r");
strcpy (lang.langname, ptr);
}
else if (strcmp (ptr, "Author") == 0)
{
ptr = strtok (NULL, "\n\r");
strcpy (lang.author, ptr);
}
else if (strcmp (ptr, "Font") == 0)
{
ptr = strtok (NULL, "\n\r");
strcpy (lang.fontname, ptr);
}
}
/* Parse the Strings section */
if (strcmp (section, "Strings") == 0)
{
/* Get all text up to the first line ending */
ptr = strtok (curline, "\n\r");
/* Find a matching default string */
str = 0;
for (i = 0; default_text[i]; i++)
{
for (j = 0; default_text[i][j]; j++)
{
if (strcmp (curline, default_text[i][j]) == 0)
{
char transline[255];
/* Found a match, read next line as the translation */
mame_fgets (transline, 255, langfile);
/* Get all text up to the first line ending */
ptr = strtok (transline, "\n\r");
/* Allocate storage and copy the string */
trans_text[str] = auto_strdup(transline);
if (!trans_text[str])
return 1;
}
str++;
}
}
}
}
/* indicate success */
return 0;
}
static void route_sound(void)
{
int sndnum, spknum, routenum, outputnum;
/* iterate over all the sound chips */
for (sndnum = 0; sndnum < totalsnd; sndnum++)
{
sound_info *info = &sound[sndnum];
/* iterate over all routes */
for (routenum = 0; routenum < info->sound->routes; routenum++)
{
const sound_route *mroute = &info->sound->route[routenum];
speaker_info *speaker;
sound_info *sound;
/* find the target */
speaker = find_speaker_by_tag(mroute->target);
sound = find_sound_by_tag(mroute->target);
/* if neither found, it's fatal */
if (speaker == NULL && sound == NULL)
fatalerror("Sound route \"%s\" not found!\n", mroute->target);
/* if we got a speaker, bump its input count */
if (speaker != NULL)
{
if (mroute->output >= 0 && mroute->output < info->outputs)
speaker->inputs++;
else if (mroute->output == ALL_OUTPUTS)
speaker->inputs += info->outputs;
}
}
}
/* now allocate the mixers and input data */
streams_set_tag(Machine, NULL);
for (spknum = 0; spknum < totalspeakers; spknum++)
{
speaker_info *info = &speaker[spknum];
if (info->inputs != 0)
{
info->mixer_stream = stream_create(info->inputs, 1, Machine->sample_rate, info, mixer_update);
info->input = auto_malloc(info->inputs * sizeof(*info->input));
info->inputs = 0;
}
else
logerror("Warning: speaker \"%s\" has no inputs\n", info->speaker->tag);
}
/* iterate again over all the sound chips */
for (sndnum = 0; sndnum < totalsnd; sndnum++)
{
sound_info *info = &sound[sndnum];
/* iterate over all routes */
for (routenum = 0; routenum < info->sound->routes; routenum++)
{
const sound_route *mroute = &info->sound->route[routenum];
speaker_info *speaker;
sound_info *sound;
/* find the target */
speaker = find_speaker_by_tag(mroute->target);
sound = find_sound_by_tag(mroute->target);
/* if it's a speaker, set the input */
if (speaker != NULL)
{
for (outputnum = 0; outputnum < info->outputs; outputnum++)
if (mroute->output == outputnum || mroute->output == ALL_OUTPUTS)
{
char namebuf[256];
int index;
sndnum_to_sndti(sndnum, &index);
/* fill in the input data on this speaker */
speaker->input[speaker->inputs].gain = mroute->gain;
speaker->input[speaker->inputs].default_gain = mroute->gain;
sprintf(namebuf, "%s:%s #%d.%d", speaker->speaker->tag, sndnum_name(sndnum), index, outputnum);
speaker->input[speaker->inputs].name = auto_strdup(namebuf);
/* connect the output to the input */
stream_set_input(speaker->mixer_stream, speaker->inputs++, info->output[outputnum].stream, info->output[outputnum].output, mroute->gain);
}
}
/* if it's a sound chip, set the input */
else
{
for (outputnum = 0; outputnum < info->outputs; outputnum++)
if (mroute->output == outputnum || mroute->output == ALL_OUTPUTS)
stream_set_input(sound->output[0].stream, 0, info->output[outputnum].stream, info->output[outputnum].output, mroute->gain);
}
}
}
}
static void route_sound(void)
{
int sndnum, routenum, outputnum;
const device_config *curspeak;
/* iterate over all the sound chips */
for (sndnum = 0; sndnum < totalsnd; sndnum++)
{
sound_info *info = &sound[sndnum];
/* iterate over all routes */
for (routenum = 0; routenum < info->sound->routes; routenum++)
{
const sound_route *mroute = &info->sound->route[routenum];
speaker_info *speaker;
sound_info *sound;
/* find the target */
speaker = find_speaker_by_tag(mroute->target);
sound = find_sound_by_tag(mroute->target);
/* if neither found, it's fatal */
if (speaker == NULL && sound == NULL)
fatalerror("Sound route \"%s\" not found!\n", mroute->target);
/* if we got a speaker, bump its input count */
if (speaker != NULL)
{
if (mroute->output >= 0 && mroute->output < info->outputs)
speaker->inputs++;
else if (mroute->output == ALL_OUTPUTS)
speaker->inputs += info->outputs;
}
}
}
/* now allocate the mixers and input data */
streams_set_tag(Machine, NULL);
for (curspeak = speaker_output_first(Machine->config); curspeak != NULL; curspeak = speaker_output_next(curspeak))
{
speaker_info *info = curspeak->token;
if (info->inputs != 0)
{
info->mixer_stream = stream_create(info->inputs, 1, Machine->sample_rate, info, mixer_update);
info->input = auto_malloc(info->inputs * sizeof(*info->input));
info->inputs = 0;
}
else
logerror("Warning: speaker \"%s\" has no inputs\n", info->tag);
}
/* iterate again over all the sound chips */
for (sndnum = 0; sndnum < totalsnd; sndnum++)
{
sound_info *info = &sound[sndnum];
/* iterate over all routes */
for (routenum = 0; routenum < info->sound->routes; routenum++)
{
const sound_route *mroute = &info->sound->route[routenum];
speaker_info *speaker;
sound_info *sound;
/* find the target */
speaker = find_speaker_by_tag(mroute->target);
sound = find_sound_by_tag(mroute->target);
/* if it's a speaker, set the input */
if (speaker != NULL)
{
for (outputnum = 0; outputnum < info->outputs; outputnum++)
if (mroute->output == outputnum || mroute->output == ALL_OUTPUTS)
{
char namebuf[256];
int index;
sound_type sndtype = sndnum_to_sndti(sndnum, &index);
/* built the display name */
namebuf[0] = '\0';
/* speaker name, if more than one speaker */
if (speaker_output_count(Machine->config) > 1)
sprintf(namebuf, "%sSpeaker '%s': ", namebuf, speaker->tag);
/* device name */
sprintf(namebuf, "%s%s ", namebuf, sndnum_name(sndnum));
/* device index, if more than one of this type */
if (sndtype_count(sndtype) > 1)
sprintf(namebuf, "%s#%d ", namebuf, index);
/* channel number, if more than channel for this device */
if (info->outputs > 1)
sprintf(namebuf, "%sCh.%d", namebuf, outputnum);
/* remove final space */
if (namebuf[strlen(namebuf) - 1] == ' ')
namebuf[strlen(namebuf) - 1] = '\0';
/* fill in the input data on this speaker */
speaker->input[speaker->inputs].gain = mroute->gain;
speaker->input[speaker->inputs].default_gain = mroute->gain;
speaker->input[speaker->inputs].name = auto_strdup(namebuf);
/* connect the output to the input */
stream_set_input(speaker->mixer_stream, speaker->inputs++, info->output[outputnum].stream, info->output[outputnum].output, mroute->gain);
}
}
/* if it's a sound chip, set the input */
else
{
if (mroute->input < 0)
{
for (outputnum = 0; outputnum < info->outputs; outputnum++)
if (mroute->output == outputnum || mroute->output == ALL_OUTPUTS)
stream_set_input(sound->output[0].stream, 0, info->output[outputnum].stream, info->output[outputnum].output, mroute->gain);
}
else
{
assert(mroute->output != ALL_OUTPUTS);
for (outputnum = 0; outputnum < info->outputs; outputnum++)
if (mroute->output == outputnum)
stream_set_input(sound->output[0].stream, mroute->input, info->output[outputnum].stream, info->output[outputnum].output, mroute->gain);
}
}
}
}
}
struct IODevice *devices_allocate(const game_driver *gamedrv)
{
struct SystemConfigurationParamBlock params;
device_getinfo_handler handlers[64];
int count_overrides[sizeof(handlers) / sizeof(handlers[0])];
int createimage_optcount, count, i, j, position;
const char *file_extensions, *info_string;
char *converted_file_extensions;
struct IODevice *devices = NULL;
memset(handlers, 0, sizeof(handlers));
memset(count_overrides, 0, sizeof(count_overrides));
if (gamedrv->sysconfig_ctor)
{
memset(¶ms, 0, sizeof(params));
params.device_slotcount = sizeof(handlers) / sizeof(handlers[0]);
params.device_handlers = handlers;
params.device_countoverrides = count_overrides;
gamedrv->sysconfig_ctor(¶ms);
}
/* count the amount of handlers that we have available */
for (count = 0; handlers[count]; count++)
;
count++; /* for our purposes, include the tailing empty device */
devices = (struct IODevice *) auto_malloc(count * sizeof(struct IODevice));
memset(devices, 0, count * sizeof(struct IODevice));
position = 0;
for (i = 0; i < count; i++)
{
devices[i].type = IO_COUNT;
if (handlers[i])
{
devices[i].devclass.get_info = handlers[i];
devices[i].devclass.gamedrv = gamedrv;
/* convert file extensions from comma delimited to null delimited */
converted_file_extensions = NULL;
file_extensions = device_get_info_string(&devices[i].devclass, DEVINFO_STR_FILE_EXTENSIONS);
if (file_extensions)
{
converted_file_extensions = auto_malloc(strlen(file_extensions) + 2);
for (j = 0; file_extensions[j]; j++)
converted_file_extensions[j] = (file_extensions[j] != ',') ? file_extensions[j] : '\0';
converted_file_extensions[j + 0] = '\0';
converted_file_extensions[j + 1] = '\0';
}
info_string = device_get_info_string(&devices[i].devclass, DEVINFO_STR_DEV_TAG);
devices[i].tag = info_string ? auto_strdup(info_string) : NULL;
devices[i].type = device_get_info_int(&devices[i].devclass, DEVINFO_INT_TYPE);
devices[i].count = device_get_info_int(&devices[i].devclass, DEVINFO_INT_COUNT);
devices[i].position = position;
devices[i].file_extensions = converted_file_extensions;
devices[i].readable = device_get_info_int(&devices[i].devclass, DEVINFO_INT_READABLE) ? 1 : 0;
devices[i].writeable = device_get_info_int(&devices[i].devclass, DEVINFO_INT_WRITEABLE) ? 1 : 0;
devices[i].creatable = device_get_info_int(&devices[i].devclass, DEVINFO_INT_CREATABLE) ? 1 : 0;
devices[i].reset_on_load = device_get_info_int(&devices[i].devclass, DEVINFO_INT_RESET_ON_LOAD) ? 1 : 0;
devices[i].must_be_loaded = device_get_info_int(&devices[i].devclass, DEVINFO_INT_MUST_BE_LOADED) ? 1 : 0;
devices[i].load_at_init = device_get_info_int(&devices[i].devclass, DEVINFO_INT_LOAD_AT_INIT) ? 1 : 0;
devices[i].not_working = device_get_info_int(&devices[i].devclass, DEVINFO_INT_NOT_WORKING) ? 1 : 0;
devices[i].init = (device_init_handler) device_get_info_fct(&devices[i].devclass, DEVINFO_PTR_INIT);
devices[i].exit = (device_exit_handler) device_get_info_fct(&devices[i].devclass, DEVINFO_PTR_EXIT);
devices[i].load = (device_load_handler) device_get_info_fct(&devices[i].devclass, DEVINFO_PTR_LOAD);
devices[i].create = (device_create_handler) device_get_info_fct(&devices[i].devclass, DEVINFO_PTR_CREATE);
devices[i].unload = (device_unload_handler) device_get_info_fct(&devices[i].devclass, DEVINFO_PTR_UNLOAD);
devices[i].imgverify = (device_verify_handler) device_get_info_fct(&devices[i].devclass, DEVINFO_PTR_VERIFY);
devices[i].partialhash = (device_partialhash_handler) device_get_info_fct(&devices[i].devclass, DEVINFO_PTR_PARTIAL_HASH);
devices[i].getdispositions = (device_getdispositions_handler) device_get_info_fct(&devices[i].devclass, DEVINFO_PTR_GET_DISPOSITIONS);
devices[i].display = (device_display_handler) device_get_info_fct(&devices[i].devclass, DEVINFO_PTR_DISPLAY);
devices[i].name = default_device_name;
devices[i].createimage_optguide = (const struct OptionGuide *) device_get_info_ptr(&devices[i].devclass, DEVINFO_PTR_CREATE_OPTGUIDE);
createimage_optcount = (int) device_get_info_int(&devices[i].devclass, DEVINFO_INT_CREATE_OPTCOUNT);
if (createimage_optcount > 0)
{
if (createimage_optcount > DEVINFO_CREATE_OPTMAX)
fatalerror("DEVINFO_INT_CREATE_OPTCOUNT: Too many options");
devices[i].createimage_options = auto_malloc((createimage_optcount + 1) *
sizeof(*devices[i].createimage_options));
for (j = 0; j < createimage_optcount; j++)
{
info_string = device_get_info_string(&devices[i].devclass, DEVINFO_STR_CREATE_OPTNAME + j);
devices[i].createimage_options[j].name = info_string ? auto_strdup(info_string) : NULL;
info_string = device_get_info_string(&devices[i].devclass, DEVINFO_STR_CREATE_OPTDESC + j);
devices[i].createimage_options[j].description = info_string ? auto_strdup(info_string) : NULL;
info_string = device_get_info_string(&devices[i].devclass, DEVINFO_STR_CREATE_OPTEXTS + j);
devices[i].createimage_options[j].extensions = info_string ? auto_strdup(info_string) : NULL;
devices[i].createimage_options[j].optspec = device_get_info_ptr(&devices[i].devclass, DEVINFO_PTR_CREATE_OPTSPEC + j);
}
/* terminate the list */
memset(&devices[i].createimage_options[createimage_optcount], 0,
sizeof(devices[i].createimage_options[createimage_optcount]));
}
position += devices[i].count;
/* overriding the count? */
if (count_overrides[i])
devices[i].count = count_overrides[i];
/* any problems? */
if ((devices[i].type < 0) || (devices[i].type >= IO_COUNT))
goto error;
if ((devices[i].count < 0) || (devices[i].count > MAX_DEV_INSTANCES))
goto error;
/* fill in defaults */
if (!devices[i].getdispositions)
devices[i].getdispositions = default_device_getdispositions;
}
}
return devices;
error:
return NULL;
}
