Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-07-06 02:18:09 +03:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

Removed old C-based interface to astrings. astring exists only as

Browse Source 
a class now. Updated all stragglers (mostly tools) to use the class
form. [Aaron Giles]
This commit is contained in:
Aaron Giles 2012-01-03 00:21:13 +00:00
parent 8b492b8d80
commit 64f1231c63
27 changed files with 1069 additions and 1831 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

391
src/build/makedep.c
View File

@ -57,45 +57,41 @@
TYPE DEFINITIONS TYPE DEFINITIONS
***************************************************************************/ ***************************************************************************/
typedef struct _include_path include_path; struct include_path
struct _include_path
{ {
include_path * next; include_path * next;
const astring * path; astring path;
}; };
typedef struct _exclude_path exclude_path; struct exclude_path
struct _exclude_path
{ {
exclude_path * next; exclude_path * next;
const astring * path; astring path;
int pathlen; int pathlen;
UINT8 recursive; UINT8 recursive;
}; };
typedef struct _list_entry list_entry; struct list_entry
struct _list_entry
{ {
list_entry * next; list_entry * next;
const astring * name; astring name;
}; };
typedef struct _file_entry file_entry; struct file_entry;
typedef struct _dependency dependency; struct dependency
struct _dependency
{ {
dependency * next; dependency * next;
file_entry * file; file_entry * file;
}; };
struct _file_entry struct file_entry
{ {
astring * name; astring name;
dependency * deplist; dependency * deplist;
}; };
@ -107,7 +103,7 @@ struct _file_entry
static include_path *incpaths; static include_path *incpaths;
static exclude_path *excpaths; static exclude_path *excpaths;
static tagmap *file_map; static tagmap_t<file_entry *> file_map;
@ -115,25 +111,12 @@ static tagmap *file_map;
PROTOTYPES PROTOTYPES
***************************************************************************/ ***************************************************************************/
/* core output functions */ // core output functions
static int recurse_dir(int srcrootlen, const astring *srcdir); static int recurse_dir(int srcrootlen, astring &srcdir);
static file_entry *compute_dependencies(int srcrootlen, const astring *srcfile); static file_entry &compute_dependencies(int srcrootlen, astring &srcfile);
/* path helpers */ // path helpers
static astring *find_include_file(int srcrootlen, const astring *srcfile, const astring *filename); static bool find_include_file(astring &srcincpath, int srcrootlen, const astring &srcfile, const astring &filename);
/***************************************************************************
INLINE FUNCTIONS
***************************************************************************/
/* core output functions */
static int recurse_dir(int srcrootlen, const astring *srcdir);
static file_entry *compute_dependencies(int srcrootlen, const astring *srcfile);
/* path helpers */
static astring *find_include_file(int srcrootlen, const astring *srcfile, const astring *filename);
@ -145,82 +128,66 @@ static astring *find_include_file(int srcrootlen, const astring *srcfile, const
main - main entry point main - main entry point
-------------------------------------------------*/ -------------------------------------------------*/
void usage(const char *argv0)
{
fprintf(stderr, "Usage:\n%s <srcroot> [-Iincpath [-Iincpath [...]]]\n", argv0);
exit(1);
}
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
include_path **incpathhead = &incpaths; include_path **incpathhead = &incpaths;
exclude_path **excpathhead = &excpaths; exclude_path **excpathhead = &excpaths;
astring *srcdir = NULL; astring srcdir;
int unadorned = 0; int unadorned = 0;
int result;
int argnum;
/* loop over arguments */ // loop over arguments
for (argnum = 1; argnum < argc; argnum++) for (int argnum = 1; argnum < argc; argnum++)
{ {
char *arg = argv[argnum]; char *arg = argv[argnum];
/* include path? */ // include path?
if (arg[0] == '-' && arg[1] == 'I') if (arg[0] == '-' && arg[1] == 'I')
{ {
*incpathhead = (include_path *)malloc(sizeof(**incpathhead)); *incpathhead = new include_path;
if (*incpathhead != NULL)
{
(*incpathhead)->next = NULL; (*incpathhead)->next = NULL;
(*incpathhead)->path = astring_replacechr(astring_dupc(&arg[2]), '/', PATH_SEPARATOR[0]); (*incpathhead)->path.cpy(&arg[2]).replacechr('/', PATH_SEPARATOR[0]);
incpathhead = &(*incpathhead)->next; incpathhead = &(*incpathhead)->next;
} }
}
/* exclude path? */ // exclude path?
else if (arg[0] == '-' && arg[1] == 'X') else if (arg[0] == '-' && arg[1] == 'X')
{ {
*excpathhead = (exclude_path *)malloc(sizeof(**excpathhead)); *excpathhead = new exclude_path;
if (*excpathhead != NULL)
{
astring *path;
(*excpathhead)->next = NULL; (*excpathhead)->next = NULL;
path = astring_replacechr(astring_dupc(&arg[2]), PATH_SEPARATOR[0], '/'); (*excpathhead)->path.cpy(&arg[2]).replacechr(PATH_SEPARATOR[0], '/');
(*excpathhead)->recursive = (astring_replacec(path, astring_len(path) - 4, "/...", "") != 0); (*excpathhead)->recursive = ((*excpathhead)->path.replace((*excpathhead)->path.len() - 4, "/...", "") != 0);
(*excpathhead)->path = path; (*excpathhead)->pathlen = (*excpathhead)->path.len();
(*excpathhead)->pathlen = astring_len(path);
excpathhead = &(*excpathhead)->next; excpathhead = &(*excpathhead)->next;
} }
}
/* ignore -include which is used by sdlmame to include sdlprefix.h before all other includes */ // ignore -include which is used by sdlmame to include sdlprefix.h before all other includes
else if (strcmp(arg,"-include") == 0) else if (strcmp(arg,"-include") == 0)
{ {
argnum++; argnum++;
} }
/* other parameter */ // other parameter
else if (arg[0] != '-' && unadorned == 0) else if (arg[0] != '-' && unadorned == 0)
{ {
srcdir = astring_replacechr(astring_dupc(arg), '/', PATH_SEPARATOR[0]); srcdir.cpy(arg).replacechr('/', PATH_SEPARATOR[0]);
unadorned++; unadorned++;
} }
else else
goto usage; usage(argv[0]);
} }
/* make sure we got 1 parameter */ // make sure we got 1 parameter
if (srcdir == NULL) if (srcdir.len() == 0)
goto usage; usage(argv[0]);
/* create a tagmap for tracking files we've visited */ // recurse over subdirectories
file_map = tagmap_alloc(); return recurse_dir(srcdir.len(), srcdir);
/* recurse over subdirectories */
result = recurse_dir(astring_len(srcdir), srcdir);
/* free source and destination directories */
tagmap_free(file_map);
astring_free(srcdir);
return result;
usage:
fprintf(stderr, "Usage:\n%s <srcroot> [-Iincpath [-Iincpath [...]]]\n", argv[0]);
return 1;
} }
@ -233,7 +200,7 @@ static int compare_list_entries(const void *p1, const void *p2)
{ {
const list_entry *entry1 = *(const list_entry **)p1; const list_entry *entry1 = *(const list_entry **)p1;
const list_entry *entry2 = *(const list_entry **)p2; const list_entry *entry2 = *(const list_entry **)p2;
return strcmp(astring_c(entry1->name), astring_c(entry2->name)); return entry1->name.cmp(entry2->name);
} }
@ -243,25 +210,22 @@ static int compare_list_entries(const void *p1, const void *p2)
unless we already exist in the map unless we already exist in the map
-------------------------------------------------*/ -------------------------------------------------*/
static void recurse_dependencies(file_entry *file, tagmap *map) static void recurse_dependencies(file_entry &file, tagmap_t<astring *> &map)
{ {
int filelen = astring_len(file->name); // skip if we're in an exclude path
exclude_path *exclude; int filelen = file.name.len();
dependency *dep; for (exclude_path *exclude = excpaths; exclude != NULL; exclude = exclude->next)
if (exclude->pathlen < filelen && strncmp(file.name, exclude->path, exclude->pathlen) == 0)
/* skip if we're in an exclude path */ if (exclude->recursive || file.name.chr(exclude->pathlen + 1, '/') == -1)
for (exclude = excpaths; exclude != NULL; exclude = exclude->next)
if (exclude->pathlen < filelen && strncmp(astring_c(file->name), astring_c(exclude->path), exclude->pathlen) == 0)
if (exclude->recursive || astring_chr(file->name, exclude->pathlen + 1, '/') == -1)
return; return;
/* attempt to add; if we get an error, we're already present */ // attempt to add; if we get an error, we're already present
if (tagmap_add(map, astring_c(file->name), file->name, FALSE) != TMERR_NONE) if (map.add(file.name, &file.name) != TMERR_NONE)
return; return;
/* recurse the list from there */ // recurse the list from there
for (dep = file->deplist; dep != NULL; dep = dep->next) for (dependency *dep = file.deplist; dep != NULL; dep = dep->next)
recurse_dependencies(dep->file, map); recurse_dependencies(*dep->file, map);
} }
@ -269,122 +233,106 @@ static void recurse_dependencies(file_entry *file, tagmap *map)
recurse_dir - recurse through a directory recurse_dir - recurse through a directory
-------------------------------------------------*/ -------------------------------------------------*/
static int recurse_dir(int srcrootlen, const astring *srcdir) static int recurse_dir(int srcrootlen, astring &srcdir)
{ {
static const osd_dir_entry_type typelist[] = { ENTTYPE_DIR, ENTTYPE_FILE }; static const osd_dir_entry_type typelist[] = { ENTTYPE_DIR, ENTTYPE_FILE };
int result = 0; int result = 0;
int entindex;
/* iterate first over directories, then over files */ // iterate first over directories, then over files
for (entindex = 0; entindex < ARRAY_LENGTH(typelist) && result == 0; entindex++) for (int entindex = 0; entindex < ARRAY_LENGTH(typelist) && result == 0; entindex++)
{ {
osd_dir_entry_type entry_type = typelist[entindex]; osd_dir_entry_type entry_type = typelist[entindex];
const osd_directory_entry *entry;
list_entry **listarray = NULL;
list_entry *list = NULL;
list_entry *curlist;
osd_directory *dir;
int found = 0;
/* open the directory and iterate through it */ // open the directory and iterate through it
dir = osd_opendir(astring_c(srcdir)); osd_directory *dir = osd_opendir(srcdir);
if (dir == NULL) if (dir == NULL)
{ {
result = 1; result = 1;
goto error; goto error;
} }
/* build up the list of files */ // build up the list of files
const osd_directory_entry *entry;
list_entry *list = NULL;
int found = 0;
while ((entry = osd_readdir(dir)) != NULL) while ((entry = osd_readdir(dir)) != NULL)
if (entry->type == entry_type && entry->name[0] != '.') if (entry->type == entry_type && entry->name[0] != '.')
{ {
list_entry *lentry = (list_entry *)malloc(sizeof(*lentry)); list_entry *lentry = new list_entry;
lentry->name = astring_dupc(entry->name); lentry->name.cpy(entry->name);
lentry->next = list; lentry->next = list;
list = lentry; list = lentry;
found++; found++;
} }
/* close the directory */ // close the directory
osd_closedir(dir); osd_closedir(dir);
/* skip if nothing found */ // skip if nothing found
if (found == 0) if (found == 0)
continue; continue;
/* allocate memory for sorting */ // allocate memory for sorting
listarray = (list_entry **)malloc(sizeof(list_entry *) * found); list_entry **listarray = new list_entry *[found];
found = 0; found = 0;
for (curlist = list; curlist != NULL; curlist = curlist->next) for (list_entry *curlist = list; curlist != NULL; curlist = curlist->next)
listarray[found++] = curlist; listarray[found++] = curlist;
/* sort the list */ // sort the list
qsort(listarray, found, sizeof(listarray[0]), compare_list_entries); qsort(listarray, found, sizeof(listarray[0]), compare_list_entries);
/* rebuild the list */ // rebuild the list
list = NULL; list = NULL;
while (--found >= 0) while (--found >= 0)
{ {
listarray[found]->next = list; listarray[found]->next = list;
list = listarray[found]; list = listarray[found];
} }
free(listarray); delete[] listarray;
/* iterate through each file */ // iterate through each file
for (curlist = list; curlist != NULL && result == 0; curlist = curlist->next) for (list_entry *curlist = list; curlist != NULL && result == 0; curlist = curlist->next)
{ {
astring *srcfile; astring srcfile;
/* build the source filename */ // build the source filename
srcfile = astring_alloc(); srcfile.printf("%s%c%s", srcdir.cstr(), PATH_SEPARATOR[0], curlist->name.cstr());
astring_printf(srcfile, "%s%c%s", astring_c(srcdir), PATH_SEPARATOR[0], astring_c(curlist->name));
/* if we have a file, output it */ // if we have a file, output it
if (entry_type == ENTTYPE_FILE) if (entry_type == ENTTYPE_FILE)
{ {
/* make sure we care, first */ // make sure we care, first
if (core_filename_ends_with(astring_c(curlist->name), ".c")) if (core_filename_ends_with(curlist->name, ".c"))
{ {
tagmap *depend_map = tagmap_alloc(); tagmap_t<astring *> depend_map;
tagmap_entry *map_entry;
file_entry *file;
astring *target;
int taghash;
/* find dependencies */ // find dependencies
file = compute_dependencies(srcrootlen, srcfile); file_entry &file = compute_dependencies(srcrootlen, srcfile);
recurse_dependencies(file, depend_map); recurse_dependencies(file, depend_map);
/* convert the target from source to object (makes assumptions about rules) */ // convert the target from source to object (makes assumptions about rules)
target = astring_dup(file->name); astring target(file.name);
astring_replacec(target, 0, "src/", "$(OBJ)/"); target.replace(0, "src/", "$(OBJ)/");
astring_replacec(target, 0, ".c", ".o"); target.replace(0, ".c", ".o");
printf("\n%s : \\\n", astring_c(target)); printf("\n%s : \\\n", target.cstr());
/* iterate over the hashed dependencies and output them as well */ // iterate over the hashed dependencies and output them as well
for (taghash = 0; taghash < TAGMAP_HASH_SIZE; taghash++) for (int taghash = 0; taghash < TAGMAP_HASH_SIZE; taghash++)
for (map_entry = depend_map->table[taghash]; map_entry != NULL; map_entry = map_entry->next) for (tagmap_entry *map_entry = depend_map.table[taghash]; map_entry != NULL; map_entry = map_entry->next)
printf("\t%s \\\n", astring_c((astring *)map_entry->object)); printf("\t%s \\\n", ((astring *)map_entry->object)->cstr());
astring_free(target);
tagmap_free(depend_map);
} }
} }
/* if we have a directory, recurse */ // if we have a directory, recurse
else else
result = recurse_dir(srcrootlen, srcfile); result = recurse_dir(srcrootlen, srcfile);
/* free memory for the names */
astring_free(srcfile);
} }
/* free all the allocated entries */ // free all the allocated entries
while (list != NULL) while (list != NULL)
{ {
list_entry *next = list->next; list_entry *next = list->next;
astring_free((astring *)list->name); delete list;
free(list);
list = next; list = next;
} }
} }
@ -399,84 +347,73 @@ error:
HTML HTML
-------------------------------------------------*/ -------------------------------------------------*/
static file_entry *compute_dependencies(int srcrootlen, const astring *srcfile) static file_entry &compute_dependencies(int srcrootlen, astring &srcfile)
{ {
astring *normalfile; // see if we already have an entry
astring normalfile(srcfile);
normalfile.replacechr(PATH_SEPARATOR[0], '/');
file_entry *foundfile = file_map.find(normalfile);
if (foundfile != NULL)
return *foundfile;
// create a new header entry
file_entry &file = *new file_entry;
file.deplist = NULL;
file.name = normalfile;
file_map.add(file.name, &file);
// read the source file
UINT32 filelength; UINT32 filelength;
file_entry *file;
char *filedata; char *filedata;
int index; if (core_fload(srcfile, (void **)&filedata, &filelength) != FILERR_NONE)
/* see if we already have an entry */
normalfile = astring_dup(srcfile);
astring_replacechr(normalfile, PATH_SEPARATOR[0], '/');
file = (file_entry *)tagmap_find(file_map, astring_c(normalfile));
if (file != NULL)
return file;
/* create a new header entry */
file = (file_entry *)malloc(sizeof(*file));
file->deplist = NULL;
file->name = normalfile;
tagmap_add(file_map, astring_c(file->name), file, FALSE);
/* read the source file */
if (core_fload(astring_c(srcfile), (void **)&filedata, &filelength) != FILERR_NONE)
{ {
fprintf(stderr, "Unable to read file '%s'\n", astring_c(srcfile)); fprintf(stderr, "Unable to read file '%s'\n", srcfile.cstr());
return file; return file;
} }
/* find the #include directives in this file */ // find the #include directives in this file
for (index = 0; index < filelength; index++) for (int index = 0; index < filelength; index++)
if (filedata[index] == '#' && strncmp(&filedata[index + 1], "include", 7) == 0) if (filedata[index] == '#' && strncmp(&filedata[index + 1], "include", 7) == 0)
{ {
astring *filename, *target; // first make sure we're not commented or quoted
int scan = index; bool just_continue = false;
dependency *dep; for (int scan = index; scan > 2 && filedata[scan] != 13 && filedata[scan] != 10; scan--)
int start;
int just_continue = 0;
/* first make sure we're not commented or quoted */
for (scan = index; scan > 2 && filedata[scan] != 13 && filedata[scan] != 10; scan--)
if ((filedata[scan] == '/' && filedata[scan - 1] == '/') || filedata[scan] == '"') if ((filedata[scan] == '/' && filedata[scan - 1] == '/') || filedata[scan] == '"')
{ {
just_continue = 1; just_continue = true;
break; break;
} }
if (just_continue) if (just_continue)
continue; continue;
/* scan forward to find the quotes or bracket */ // scan forward to find the quotes or bracket
index += 7; index += 7;
int scan;
for (scan = index; scan < filelength && filedata[scan] != '<' && filedata[scan] != '"' && filedata[scan] != 13 && filedata[scan] != 10; scan++) ; for (scan = index; scan < filelength && filedata[scan] != '<' && filedata[scan] != '"' && filedata[scan] != 13 && filedata[scan] != 10; scan++) ;
/* ignore if not found or if it's bracketed */ // ignore if not found or if it's bracketed
if (scan >= filelength || filedata[scan] != '"') if (scan >= filelength || filedata[scan] != '"')
continue; continue;
start = ++scan; int start = ++scan;
/* find the closing quote */ // find the closing quote
while (scan < filelength && filedata[scan] != '"') while (scan < filelength && filedata[scan] != '"')
scan++; scan++;
if (scan >= filelength) if (scan >= filelength)
continue; continue;
/* find the include file */ // find the include file
filename = astring_dupch(&filedata[start], scan - start); astring filename(&filedata[start], scan - start);
target = find_include_file(srcrootlen, srcfile, filename); astring target;
/* create a new dependency */ // create a new dependency
if (target != NULL) if (find_include_file(target, srcrootlen, srcfile, filename))
{ {
dep = (dependency *)malloc(sizeof(*dep)); dependency *dep = new dependency;
dep->next = file->deplist; dep->next = file.deplist;
file->deplist = dep; file.deplist = dep;
dep->file = compute_dependencies(srcrootlen, target); dep->file = &compute_dependencies(srcrootlen, target);
astring_free(target);
} }
astring_free(filename);
} }
osd_free(filedata); osd_free(filedata);
@ -493,59 +430,51 @@ static file_entry *compute_dependencies(int srcrootlen, const astring *srcfile)
find_include_file - find an include file find_include_file - find an include file
-------------------------------------------------*/ -------------------------------------------------*/
static astring *find_include_file(int srcrootlen, const astring *srcfile, const astring *filename) static bool find_include_file(astring &srcincpath, int srcrootlen, const astring &srcfile, const astring &filename)
{ {
include_path *curpath; // iterate over include paths and find the file
for (include_path *curpath = incpaths; curpath != NULL; curpath = curpath->next)
{
// a '.' include path is specially treated
if (curpath->path == ".")
srcincpath.cpysubstr(srcfile, 0, srcfile.rchr(0, PATH_SEPARATOR[0]));
else
srcincpath.cpy(curpath->path);
/* iterate over include paths and find the file */ // append the filename piecemeal to account for directories
for (curpath = incpaths; curpath != NULL; curpath = curpath->next)
{
astring *srcincpath = astring_dup(curpath->path);
core_file *testfile;
int lastsepindex = 0; int lastsepindex = 0;
int sepindex; int sepindex;
while ((sepindex = filename.chr(lastsepindex, '/')) != -1)
/* a '.' include path is specially treated */
if (astring_cmpc(curpath->path, ".") == 0)
astring_cpysubstr(srcincpath, srcfile, 0, astring_rchr(srcfile, 0, PATH_SEPARATOR[0]));
/* append the filename piecemeal to account for directories */
while ((sepindex = astring_chr(filename, lastsepindex, '/')) != -1)
{ {
astring *pathpart = astring_dupsubstr(filename, lastsepindex, sepindex - lastsepindex); astring pathpart(filename, lastsepindex, sepindex - lastsepindex);
/* handle .. by removing a chunk from the incpath */ // handle .. by removing a chunk from the incpath
if (astring_cmpc(pathpart, "..") == 0) if (pathpart == "..")
{ {
int sepindex_part = astring_rchr(srcincpath, 0, PATH_SEPARATOR[0]); int sepindex_part = srcincpath.rchr(0, PATH_SEPARATOR[0]);
if (sepindex_part != -1) if (sepindex_part != -1)
astring_substr(srcincpath, 0, sepindex_part); srcincpath.substr(0, sepindex_part);
} }
/* otherwise, append a path separator and the pathpart */ // otherwise, append a path separator and the pathpart
else else
astring_cat(astring_catc(srcincpath, PATH_SEPARATOR), pathpart); srcincpath.cat(PATH_SEPARATOR).cat(pathpart);
/* advance past the previous index */ // advance past the previous index
lastsepindex = sepindex + 1; lastsepindex = sepindex + 1;
/* free the path part we extracted */
astring_free(pathpart);
} }
/* now append the filename */ // now append the filename
astring_catsubstr(astring_catc(srcincpath, PATH_SEPARATOR), filename, lastsepindex, -1); srcincpath.cat(PATH_SEPARATOR).catsubstr(filename, lastsepindex, -1);
/* see if we can open it */ // see if we can open it
if (core_fopen(astring_c(srcincpath), OPEN_FLAG_READ, &testfile) == FILERR_NONE) core_file *testfile;
if (core_fopen(srcincpath, OPEN_FLAG_READ, &testfile) == FILERR_NONE)
{ {
/* close the file */ // close the file
core_fclose(testfile); core_fclose(testfile);
return srcincpath; return true;
} }
/* free our include path */
astring_free(srcincpath);
} }
return NULL; return false;
} }

10
src/emu/clifront.c
View File

@ -166,7 +166,7 @@ int cli_frontend::execute(int argc, char **argv)
// determine the base name of the EXE // determine the base name of the EXE
astring exename; astring exename;
core_filename_extract_base(&exename, argv[0], TRUE); core_filename_extract_base(exename, argv[0], true);
// if we have a command, execute that // if we have a command, execute that
if (strlen(m_options.command()) != 0) if (strlen(m_options.command()) != 0)
@ -345,7 +345,7 @@ void cli_frontend::listsource(const char *gamename)
// iterate through drivers and output the info // iterate through drivers and output the info
astring filename; astring filename;
while (drivlist.next()) while (drivlist.next())
mame_printf_info("%-16s %s\n", drivlist.driver().name, core_filename_extract_base(&filename, drivlist.driver().source_file, FALSE)->cstr()); mame_printf_info("%-16s %s\n", drivlist.driver().name, core_filename_extract_base(filename, drivlist.driver().source_file).cstr());
} }
@ -435,7 +435,7 @@ void cli_frontend::listbrothers(const char *gamename)
while (drivlist.next()) while (drivlist.next())
{ {
int clone_of = drivlist.clone(); int clone_of = drivlist.clone();
mame_printf_info("%-16s %-16s %-16s\n", core_filename_extract_base(&filename, drivlist.driver().source_file, FALSE)->cstr(), drivlist.driver().name, (clone_of == -1 ? "" : drivlist.driver(clone_of).name)); mame_printf_info("%-16s %-16s %-16s\n", core_filename_extract_base(filename, drivlist.driver().source_file).cstr(), drivlist.driver().name, (clone_of == -1 ? "" : drivlist.driver(clone_of).name));
} }
} }
@ -1488,7 +1488,7 @@ void media_identifier::identify_file(const char *name)
{ {
// output the name // output the name
astring basename; astring basename;
mame_printf_info("%-20s", core_filename_extract_base(&basename, name, FALSE)->cstr()); mame_printf_info("%-20s", core_filename_extract_base(basename, name).cstr());
m_total++; m_total++;
// attempt to open as a CHD; fail if not // attempt to open as a CHD; fail if not
@ -1570,7 +1570,7 @@ void media_identifier::identify_data(const char *name, const UINT8 *data, int le
// output the name // output the name
m_total++; m_total++;
astring basename; astring basename;
mame_printf_info("%-20s", core_filename_extract_base(&basename, name, FALSE)->cstr()); mame_printf_info("%-20s", core_filename_extract_base(basename, name).cstr());
// see if we can find a match in the ROMs // see if we can find a match in the ROMs
int found = find_by_hash(hashes, length); int found = find_by_hash(hashes, length);

8
src/emu/debug/debugcpu.c
View File

@ -51,9 +51,6 @@
#include "xmlfile.h" #include "xmlfile.h"
#include <ctype.h> #include <ctype.h>
#include <zlib.h> #include <zlib.h>
#if defined(SDLMAME_FREEBSD) || defined(SDLMAME_NETBSD) || defined(SDLMAME_OS2)
# undef tolower
#endif
/*************************************************************************** /***************************************************************************
@ -1712,7 +1709,7 @@ device_debug::device_debug(device_t &device)
// add all registers into it // add all registers into it
astring tempstr; astring tempstr;
for (const device_state_entry *entry = m_state->state_first(); entry != NULL; entry = entry->next()) for (const device_state_entry *entry = m_state->state_first(); entry != NULL; entry = entry->next())
m_symtable.add(tempstr.cpy(entry->symbol()).tolower(), (void *)(FPTR)entry->index(), get_state, set_state); m_symtable.add(tempstr.cpy(entry->symbol()).makelower(), (void *)(FPTR)entry->index(), get_state, set_state);
} }
// set up execution-related stuff // set up execution-related stuff
@ -3056,8 +3053,7 @@ UINT32 device_debug::dasm_wrapped(astring &buffer, offs_t pc)
} }
// disassemble to our buffer // disassemble to our buffer
buffer.expand(200); return disassemble(buffer.stringbuffer(200), pc, opbuf, argbuf);
return disassemble(buffer.text, pc, opbuf, argbuf);
} }

6
src/emu/debug/express.c
View File

@ -955,15 +955,15 @@ void parsed_expression::parse_symbol_or_number(parse_token &token, const char *&
// if we have an 0x prefix, we must be a hex value // if we have an 0x prefix, we must be a hex value
if (buffer[0] == '0' && buffer[1] == 'x') if (buffer[0] == '0' && buffer[1] == 'x')
return parse_number(token, &buffer[2], 16, expression_error::INVALID_NUMBER); return parse_number(token, buffer.cstr() + 2, 16, expression_error::INVALID_NUMBER);
// if we have a # prefix, we must be a decimal value // if we have a # prefix, we must be a decimal value
if (buffer[0] == '#') if (buffer[0] == '#')
return parse_number(token, &buffer[1], 10, expression_error::INVALID_NUMBER); return parse_number(token, buffer.cstr() + 1, 10, expression_error::INVALID_NUMBER);
// if we have a $ prefix, we are a hex value // if we have a $ prefix, we are a hex value
if (buffer[0] == '$') if (buffer[0] == '$')
return parse_number(token, &buffer[1], 16, expression_error::INVALID_NUMBER); return parse_number(token, buffer.cstr() + 1, 16, expression_error::INVALID_NUMBER);
// check for a symbol match // check for a symbol match
symbol_entry *symbol = m_symtable->find_deep(buffer); symbol_entry *symbol = m_symtable->find_deep(buffer);

1
src/emu/debugint/debugint.c
View File

@ -285,7 +285,6 @@ static DView *dview_alloc(render_target *target, running_machine &machine, debug
static void dview_free(DView *dv) static void dview_free(DView *dv)
{ {
//astring_free(dv->title);
LIST_REMOVE(list, dv, DView); LIST_REMOVE(list, dv, DView);
auto_free(dv->machine(), dv); auto_free(dv->machine(), dv);
} }

16
src/emu/diimage.c
View File

@ -182,7 +182,7 @@ void device_image_interface::device_compute_hash(hash_collection &hashes, const
image_error_t device_image_interface::set_image_filename(const char *filename) image_error_t device_image_interface::set_image_filename(const char *filename)
{ {
m_image_name = filename; m_image_name = filename;
zippath_parent(&m_working_directory, filename); zippath_parent(m_working_directory, filename);
m_basename.cpy(m_image_name); m_basename.cpy(m_image_name);
int loc1 = m_image_name.rchr(0,'\\'); int loc1 = m_image_name.rchr(0,'\\');
@ -352,7 +352,7 @@ bool device_image_interface::try_change_working_directory(const char *subdir)
/* did we successfully identify the directory? */ /* did we successfully identify the directory? */
if (success) if (success)
zippath_combine(&m_working_directory, m_working_directory, subdir); zippath_combine(m_working_directory, m_working_directory, subdir);
return success; return success;
} }
@ -532,10 +532,9 @@ UINT32 device_image_interface::crc()
-------------------------------------------------*/ -------------------------------------------------*/
void device_image_interface::battery_load(void *buffer, int length, int fill) void device_image_interface::battery_load(void *buffer, int length, int fill)
{ {
astring *fname = astring_assemble_4(astring_alloc(), device().machine().system().name, PATH_SEPARATOR, m_basename_noext, ".nv"); astring fname(device().machine().system().name, PATH_SEPARATOR, m_basename_noext, ".nv");
image_battery_load_by_name(device().machine().options(), astring_c(fname), buffer, length, fill); image_battery_load_by_name(device().machine().options(), fname, buffer, length, fill);
astring_free(fname);
} }
/*------------------------------------------------- /*-------------------------------------------------
@ -546,10 +545,9 @@ void device_image_interface::battery_load(void *buffer, int length, int fill)
-------------------------------------------------*/ -------------------------------------------------*/
void device_image_interface::battery_save(const void *buffer, int length) void device_image_interface::battery_save(const void *buffer, int length)
{ {
astring *fname = astring_assemble_4(astring_alloc(), device().machine().system().name, PATH_SEPARATOR, m_basename_noext, ".nv"); astring fname(device().machine().system().name, PATH_SEPARATOR, m_basename_noext, ".nv");
image_battery_save_by_name(device().machine().options(), astring_c(fname), buffer, length); image_battery_save_by_name(device().machine().options(), fname, buffer, length);
astring_free(fname);
} }
//------------------------------------------------- //-------------------------------------------------
@ -605,7 +603,7 @@ image_error_t device_image_interface::load_image_by_path(UINT32 open_flags, cons
astring revised_path; astring revised_path;
/* attempt to read the file */ /* attempt to read the file */
filerr = zippath_fopen(path, open_flags, &m_file, &revised_path); filerr = zippath_fopen(path, open_flags, m_file, revised_path);
/* did the open succeed? */ /* did the open succeed? */
switch(filerr) switch(filerr)

2
src/emu/emucore.h
View File

@ -33,9 +33,9 @@
// core system includes // core system includes
#include "osdcomm.h" #include "osdcomm.h"
#include "astring.h"
#include "emualloc.h" #include "emualloc.h"
#include "corestr.h" #include "corestr.h"
#include "astring.h"
#include "bitmap.h" #include "bitmap.h"
#include "tagmap.h" #include "tagmap.h"

6
src/emu/emuopts.c
View File

@ -448,10 +448,10 @@ void emu_options::parse_standard_inis(astring &error_string)
// next parse "source/<sourcefile>.ini"; if that doesn't exist, try <sourcefile>.ini // next parse "source/<sourcefile>.ini"; if that doesn't exist, try <sourcefile>.ini
astring sourcename; astring sourcename;
core_filename_extract_base(&sourcename, cursystem->source_file, TRUE)->ins(0, "source" PATH_SEPARATOR); core_filename_extract_base(sourcename, cursystem->source_file, true).ins(0, "source" PATH_SEPARATOR);
if (!parse_one_ini(sourcename, OPTION_PRIORITY_SOURCE_INI, &error_string)) if (!parse_one_ini(sourcename, OPTION_PRIORITY_SOURCE_INI, &error_string))
{ {
core_filename_extract_base(&sourcename, cursystem->source_file, TRUE); core_filename_extract_base(sourcename, cursystem->source_file, true);
parse_one_ini(sourcename, OPTION_PRIORITY_SOURCE_INI, &error_string); parse_one_ini(sourcename, OPTION_PRIORITY_SOURCE_INI, &error_string);
} }
@ -474,7 +474,7 @@ void emu_options::parse_standard_inis(astring &error_string)
const game_driver *emu_options::system() const const game_driver *emu_options::system() const
{ {
astring tempstr; astring tempstr;
int index = driver_list::find(*core_filename_extract_base(&tempstr, system_name(), TRUE)); int index = driver_list::find(core_filename_extract_base(tempstr, system_name(), true));
return (index != -1) ? &driver_list::driver(index) : NULL; return (index != -1) ? &driver_list::driver(index) : NULL;
} }

2
src/emu/hash.c
View File

@ -590,7 +590,7 @@ const char *hash_collection::macro_string(astring &buffer) const
buffer.reset(); buffer.reset();
for (hash_base *hash = m_hashlist.first(); hash != NULL; hash = hash->next()) for (hash_base *hash = m_hashlist.first(); hash != NULL; hash = hash->next())
{ {
buffer.cat(temp.cpy(hash->name()).toupper()); buffer.cat(temp.cpy(hash->name()).makeupper());
buffer.cat("(").cat(hash->string(temp)).cat(") "); buffer.cat("(").cat(hash->string(temp)).cat(") ");
} }

22
src/emu/image.c
View File

@ -371,17 +371,17 @@ static char *strip_extension(const char *filename)
string with the image info text string with the image info text
-------------------------------------------------*/ -------------------------------------------------*/
astring *image_info_astring(running_machine &machine, astring *string) astring &image_info_astring(running_machine &machine, astring &string)
{ {
device_image_interface *image = NULL; device_image_interface *image = NULL;
astring_printf(string, "%s\n\n", machine.system().description); string.printf("%s\n\n", machine.system().description);
#if 0 #if 0
if (mess_ram_size > 0) if (mess_ram_size > 0)
{ {
char buf2[RAM_STRING_BUFLEN]; char buf2[RAM_STRING_BUFLEN];
astring_catprintf(string, "RAM: %s\n\n", ram_string(buf2, mess_ram_size)); string.catprintf("RAM: %s\n\n", ram_string(buf2, mess_ram_size));
} }
#endif #endif
@ -398,28 +398,28 @@ astring *image_info_astring(running_machine &machine, astring *string)
base_filename_noextension = strip_extension(base_filename); base_filename_noextension = strip_extension(base_filename);
/* display device type and filename */ /* display device type and filename */
astring_catprintf(string, "%s: %s\n", image->device().name(), base_filename); string.catprintf("%s: %s\n", image->device().name(), base_filename);
/* display long filename, if present and doesn't correspond to name */ /* display long filename, if present and doesn't correspond to name */
info = image->longname(); info = image->longname();
if (info && (!base_filename_noextension || mame_stricmp(info, base_filename_noextension))) if (info && (!base_filename_noextension || mame_stricmp(info, base_filename_noextension)))
astring_catprintf(string, "%s\n", info); string.catprintf("%s\n", info);
/* display manufacturer, if available */ /* display manufacturer, if available */
info = image->manufacturer(); info = image->manufacturer();
if (info != NULL) if (info != NULL)
{ {
astring_catprintf(string, "%s", info); string.catprintf("%s", info);
info = stripspace(image->year()); info = stripspace(image->year());
if (info && *info) if (info && *info)
astring_catprintf(string, ", %s", info); string.catprintf(", %s", info);
astring_catprintf(string,"\n"); string.catprintf("\n");
} }
/* display supported information, if available */ /* display supported information, if available */
switch(image->supported()) { switch(image->supported()) {
case SOFTWARE_SUPPORTED_NO : astring_catprintf(string, "Not supported\n"); break; case SOFTWARE_SUPPORTED_NO : string.catprintf("Not supported\n"); break;
case SOFTWARE_SUPPORTED_PARTIAL : astring_catprintf(string, "Partialy supported\n"); break; case SOFTWARE_SUPPORTED_PARTIAL : string.catprintf("Partialy supported\n"); break;
default : break; default : break;
} }
@ -428,7 +428,7 @@ astring *image_info_astring(running_machine &machine, astring *string)
} }
else else
{ {
astring_catprintf(string, "%s: ---\n", image->device().name()); string.catprintf("%s: ---\n", image->device().name());
} }
} }
return string; return string;

2
src/emu/image.h
View File

@ -26,7 +26,7 @@ extern struct io_procs image_ioprocs;
void image_battery_load_by_name(emu_options &options, const char *filename, void *buffer, int length, int fill); void image_battery_load_by_name(emu_options &options, const char *filename, void *buffer, int length, int fill);
void image_battery_save_by_name(emu_options &options, const char *filename, const void *buffer, int length); void image_battery_save_by_name(emu_options &options, const char *filename, const void *buffer, int length);
astring *image_info_astring(running_machine &machine, astring *string); astring &image_info_astring(running_machine &machine, astring &string);
device_image_interface *image_from_absolute_index(running_machine &machine, int absolute_index); device_image_interface *image_from_absolute_index(running_machine &machine, int absolute_index);

2
src/emu/input.c
View File

@ -2179,7 +2179,7 @@ input_device_item::input_device_item(input_device &device, const char *name, voi
// otherwise, create a tokenized name // otherwise, create a tokenized name
else else
m_token.cpy(name).toupper().delchr(' ').delchr('_'); m_token.cpy(name).makeupper().delchr(' ').delchr('_');
} }

21
src/emu/ioport.c
View File

@ -1911,9 +1911,8 @@ static const char *inputx_key_name(unicode_char ch)
a key based on natural keyboard characters a key based on natural keyboard characters
-------------------------------------------------*/ -------------------------------------------------*/
static astring *get_keyboard_key_name(const input_field_config *field) static astring &get_keyboard_key_name(astring &name, const input_field_config *field)
{ {
astring *result = astring_alloc();
int i; int i;
unicode_char ch; unicode_char ch;
@ -1922,17 +1921,17 @@ static astring *get_keyboard_key_name(const input_field_config *field)
for (i = 0; i < ARRAY_LENGTH(field->chars) && (field->chars[i] != '\0'); i++) for (i = 0; i < ARRAY_LENGTH(field->chars) && (field->chars[i] != '\0'); i++)
{ {
ch = get_keyboard_code(field, i); ch = get_keyboard_code(field, i);
astring_printf(result, "%s%-*s ", astring_c(result), MAX(SPACE_COUNT - 1, 0), inputx_key_name(ch)); name.catprintf("%-*s ", MAX(SPACE_COUNT - 1, 0), inputx_key_name(ch));
} }
/* trim extra spaces */ /* trim extra spaces */
astring_trimspace(result); name.trimspace();
/* special case */ /* special case */
if (astring_len(result) == 0) if (name.len() == 0)
astring_cpyc(result, "Unnamed Key"); name.cpy("Unnamed Key");
return result; return name;
} }
/*------------------------------------------------- /*-------------------------------------------------
@ -2036,12 +2035,8 @@ static void init_port_state(running_machine &machine)
/* Name keyboard key names */ /* Name keyboard key names */
if ((field->type == IPT_KEYBOARD || field->type == IPT_KEYPAD) && (field->name == NULL)) if ((field->type == IPT_KEYBOARD || field->type == IPT_KEYPAD) && (field->name == NULL))
{ {
astring *name = get_keyboard_key_name(field); astring name;
if (name != NULL) field->state->name = auto_strdup(machine, get_keyboard_key_name(name, field));
{
field->state->name = auto_strdup(machine, astring_c(name));
astring_free(name);
}
} }
} }
} }

2
src/emu/softlist.c
View File

@ -1911,7 +1911,7 @@ void validate_softlists(emu_options &options)
} }
/* check for duplicate descriptions */ /* check for duplicate descriptions */
if (descriptions.add(astring(swinfo->longname).tolower().cstr(), swinfo, FALSE) == TMERR_DUPLICATE) if (descriptions.add(astring(swinfo->longname).makelower().cstr(), swinfo, FALSE) == TMERR_DUPLICATE)
{ {
mame_printf_error("%s: %s is a duplicate description (%s)\n", list->file->filename(), swinfo->longname, swinfo->shortname); mame_printf_error("%s: %s is a duplicate description (%s)\n", list->file->filename(), swinfo->longname, swinfo->shortname);
error = TRUE; error = TRUE;

66
src/emu/uiimage.c
View File

@ -224,7 +224,7 @@ static int is_valid_filename_char(unicode_char unichar)
void ui_menu_file_create::custom_render(void *selectedref, float top, float bottom, float origx1, float origy1, float origx2, float origy2) void ui_menu_file_create::custom_render(void *selectedref, float top, float bottom, float origx1, float origy1, float origx2, float origy2)
{ {
extra_text_render(container, top, bottom, origx1, origy1, origx2, origy2, extra_text_render(container, top, bottom, origx1, origy1, origx2, origy2,
astring_c(manager->current_directory), manager->current_directory,
NULL); NULL);
} }
@ -254,8 +254,8 @@ void ui_menu_file_create::populate()
/* append the "New Image Name" item */ /* append the "New Image Name" item */
if (get_selection() == ITEMREF_NEW_IMAGE_NAME) if (get_selection() == ITEMREF_NEW_IMAGE_NAME)
{ {
astring_assemble_2(&buffer, filename_buffer, "_"); buffer.cat(filename_buffer).cat("_");
new_image_name = astring_c(&buffer); new_image_name = buffer;
} }
else else
{ {
@ -286,17 +286,17 @@ void ui_menu_file_create::populate()
int ui_menu_file_create::create_new_image(device_image_interface *image, const char *directory, const char *filename, int *yes) int ui_menu_file_create::create_new_image(device_image_interface *image, const char *directory, const char *filename, int *yes)
{ {
astring *path; astring path;
osd_directory_entry *entry; osd_directory_entry *entry;
osd_dir_entry_type file_type; osd_dir_entry_type file_type;
int do_create, err; int do_create, err;
int result = FALSE; int result = FALSE;
/* assemble the full path */ /* assemble the full path */
path = zippath_combine(astring_alloc(), directory, filename); zippath_combine(path, directory, filename);
/* does a file or a directory exist at the path */ /* does a file or a directory exist at the path */
entry = osd_stat(astring_c(path)); entry = osd_stat(path);
file_type = (entry != NULL) ? entry->type : ENTTYPE_NONE; file_type = (entry != NULL) ? entry->type : ENTTYPE_NONE;
if (entry != NULL) if (entry != NULL)
free(entry); free(entry);
@ -333,16 +333,13 @@ int ui_menu_file_create::create_new_image(device_image_interface *image, const c
/* create the image, if appropriate */ /* create the image, if appropriate */
if (do_create) if (do_create)
{ {
err = image->create(astring_c(path), 0, NULL); err = image->create(path, 0, NULL);
if (err != 0) if (err != 0)
popmessage("Error: %s", image->error()); popmessage("Error: %s", image->error());
else else
result = TRUE; result = TRUE;
} }
/* free the path */
astring_free(path);
return result; return result;
} }
@ -382,7 +379,7 @@ void ui_menu_file_create::handle()
{ {
if (create_new_image( if (create_new_image(
manager->selected_device, manager->selected_device,
astring_c(manager->current_directory), manager->current_directory,
filename_buffer, filename_buffer,
&confirm_save_as_yes)) &confirm_save_as_yes))
{ {
@ -422,7 +419,7 @@ void ui_menu_file_selector::custom_render(void *selectedref, float top, float bo
{ {
extra_text_render(container, top, bottom, extra_text_render(container, top, bottom,
origx1, origy1, origx2, origy2, origx1, origy1, origx2, origy2,
astring_c(manager->current_directory), manager->current_directory,
NULL); NULL);
} }
@ -506,7 +503,7 @@ ui_menu_file_selector::file_selector_entry *ui_menu_file_selector::append_entry(
ui_menu_file_selector::file_selector_entry *ui_menu_file_selector::append_dirent_entry(const osd_directory_entry *dirent) ui_menu_file_selector::file_selector_entry *ui_menu_file_selector::append_dirent_entry(const osd_directory_entry *dirent)
{ {
astring *buffer; astring buffer;
file_selector_entry_type entry_type; file_selector_entry_type entry_type;
file_selector_entry *entry; file_selector_entry *entry;
@ -526,18 +523,17 @@ ui_menu_file_selector::file_selector_entry *ui_menu_file_selector::append_dirent
} }
/* determine the full path */ /* determine the full path */
buffer = zippath_combine( zippath_combine(
astring_alloc(), buffer,
astring_c(manager->current_directory), manager->current_directory,
dirent->name); dirent->name);
/* create the file selector entry */ /* create the file selector entry */
entry = append_entry( entry = append_entry(
entry_type, entry_type,
dirent->name, dirent->name,
astring_c(buffer)); buffer);
astring_free(buffer);
return entry; return entry;
} }
@ -610,7 +606,7 @@ void ui_menu_file_selector::populate()
int i; int i;
const char *volume_name; const char *volume_name;
device_image_interface *device = manager->selected_device; device_image_interface *device = manager->selected_device;
const char *path = astring_c(manager->current_directory); const char *path = manager->current_directory;
/* open the directory */ /* open the directory */
err = zippath_opendir(path, &directory); err = zippath_opendir(path, &directory);
@ -654,7 +650,7 @@ void ui_menu_file_selector::populate()
selected_entry = entry; selected_entry = entry;
/* do we have to select this file? */ /* do we have to select this file? */
if (!mame_stricmp(astring_c(manager->current_file), dirent->name)) if (!mame_stricmp(manager->current_file, dirent->name))
selected_entry = entry; selected_entry = entry;
} }
} }
@ -731,7 +727,7 @@ void ui_menu_file_selector::handle()
ui_popup_time(1, "Error accessing %s", entry->fullpath); ui_popup_time(1, "Error accessing %s", entry->fullpath);
break; break;
} }
astring_cpyc(manager->current_directory, entry->fullpath); manager->current_directory.cpy(entry->fullpath);
reset((ui_menu_reset_options)0); reset((ui_menu_reset_options)0);
break; break;
@ -845,10 +841,9 @@ void ui_menu_file_manager::fix_working_directory(device_image_interface *image)
/* if the image exists, set the working directory to the parent directory */ /* if the image exists, set the working directory to the parent directory */
if (image->exists()) if (image->exists())
{ {
astring *astr = astring_alloc(); astring astr;
zippath_parent(astr, image->filename()); zippath_parent(astr, image->filename());
image->set_working_directory(astring_c(astr)); image->set_working_directory(astr);
astring_free(astr);
} }
/* check to see if the path exists; if not clear it */ /* check to see if the path exists; if not clear it */
@ -882,8 +877,6 @@ void ui_menu_file_manager::custom_render(void *selectedref, float top, float bot
ui_menu_file_manager::ui_menu_file_manager(running_machine &machine, render_container *container) : ui_menu(machine, container) ui_menu_file_manager::ui_menu_file_manager(running_machine &machine, render_container *container) : ui_menu(machine, container)
{ {
current_directory = astring_alloc();
current_file = astring_alloc();
} }
void ui_menu_file_manager::populate() void ui_menu_file_manager::populate()
@ -941,8 +934,6 @@ void ui_menu_file_manager::populate()
ui_menu_file_manager::~ui_menu_file_manager() ui_menu_file_manager::~ui_menu_file_manager()
{ {
astring_free(current_directory);
astring_free(current_file);
} }
@ -967,8 +958,8 @@ void ui_menu_file_manager::handle()
fix_working_directory(selected_device); fix_working_directory(selected_device);
/* set up current_directory and current_file - depends on whether we have an image */ /* set up current_directory and current_file - depends on whether we have an image */
astring_cpyc(current_directory, selected_device->working_directory()); current_directory.cpy(selected_device->working_directory());
astring_cpyc(current_file, selected_device->exists() ? selected_device->basename() : ""); current_file.cpy(selected_device->exists() ? selected_device->basename() : "");
/* reset the existing menu */ /* reset the existing menu */
reset(UI_MENU_RESET_REMEMBER_POSITION); reset(UI_MENU_RESET_REMEMBER_POSITION);
@ -990,9 +981,8 @@ ui_menu_image_info::ui_menu_image_info(running_machine &machine, render_containe
void ui_menu_image_info::populate() void ui_menu_image_info::populate()
{ {
astring *tempstring = image_info_astring(machine(), astring_alloc()); astring tempstring;
item_append(astring_c(tempstring), NULL, MENU_FLAG_MULTILINE, NULL); item_append(image_info_astring(machine(), tempstring), NULL, MENU_FLAG_MULTILINE, NULL);
astring_free(tempstring);
} }
ui_menu_image_info::~ui_menu_image_info() ui_menu_image_info::~ui_menu_image_info()
@ -1084,7 +1074,7 @@ int ui_menu_mess_bitbanger_control::bitbanger_count()
representation of the time representation of the time
-------------------------------------------------*/ -------------------------------------------------*/
astring *tapecontrol_gettime(astring *dest, cassette_image_device *cassette, int *curpos, int *endpos) astring &tapecontrol_gettime(astring &dest, cassette_image_device *cassette, int *curpos, int *endpos)
{ {
double t0, t1; double t0, t1;
@ -1092,9 +1082,9 @@ astring *tapecontrol_gettime(astring *dest, cassette_image_device *cassette, int
t1 = cassette->get_length(); t1 = cassette->get_length();
if (t1) if (t1)
astring_printf(dest, "%04d/%04d", (int) t0, (int) t1); dest.printf("%04d/%04d", (int) t0, (int) t1);
else else
astring_printf(dest, "%04d/%04d", 0, (int) t1); dest.printf("%04d/%04d", 0, (int) t1);
if (curpos != NULL) if (curpos != NULL)
*curpos = t0; *curpos = t0;
@ -1147,7 +1137,7 @@ void ui_menu_mess_tape_control::populate()
item_append(device->device().name(), device->filename(), flags, TAPECMD_SELECT); item_append(device->device().name(), device->filename(), flags, TAPECMD_SELECT);
/* state */ /* state */
tapecontrol_gettime(&timepos, cassette, NULL, NULL); tapecontrol_gettime(timepos, cassette, NULL, NULL);
state = cassette->get_state(); state = cassette->get_state();
item_append( item_append(
(state & CASSETTE_MASK_UISTATE) == CASSETTE_STOPPED (state & CASSETTE_MASK_UISTATE) == CASSETTE_STOPPED
@ -1156,7 +1146,7 @@ void ui_menu_mess_tape_control::populate()
? ((state & CASSETTE_MASK_MOTOR) == CASSETTE_MOTOR_ENABLED ? "playing" : "(playing)") ? ((state & CASSETTE_MASK_MOTOR) == CASSETTE_MOTOR_ENABLED ? "playing" : "(playing)")
: ((state & CASSETTE_MASK_MOTOR) == CASSETTE_MOTOR_ENABLED ? "recording" : "(recording)") : ((state & CASSETTE_MASK_MOTOR) == CASSETTE_MOTOR_ENABLED ? "recording" : "(recording)")
), ),
astring_c(&timepos), timepos,
tapeflags, tapeflags,
TAPECMD_SLIDER); TAPECMD_SLIDER);

4
src/emu/uiimage.h
View File

@ -24,8 +24,8 @@ public:
class ui_menu_file_manager : public ui_menu { class ui_menu_file_manager : public ui_menu {
public: public:
astring *current_directory; astring current_directory;
astring *current_file; astring current_file;
device_image_interface *selected_device; device_image_interface *selected_device;
ui_menu_file_manager(running_machine &machine, render_container *container); ui_menu_file_manager(running_machine &machine, render_container *container);

826
src/lib/util/astring.c
View File

File diff suppressed because it is too large Load Diff

399
src/lib/util/astring.h
View File

@ -46,278 +46,21 @@
#include <ctype.h> #include <ctype.h>
#include "osdcomm.h" #include "osdcomm.h"
#ifdef toupper
#undef toupper
#endif
#ifdef tolower
#undef tolower
#endif
/***************************************************************************
TYPE DEFINITIONS
***************************************************************************/
/* base astring structure */ //**************************************************************************
typedef struct _astring_base astring_base; // TYPE DEFINITIONS
struct _astring_base //**************************************************************************
// derived class for C++
class astring
{ {
char * text;
int alloclen;
char smallbuf[64 - sizeof(int) - sizeof(char *)];
};
/* class for C++, direct map for C */
#ifdef __cplusplus
class astring;
#else
typedef astring_base astring;
#endif
/***************************************************************************
FUNCTION PROTOTYPES
***************************************************************************/
/* ----- astring allocation ----- */
/* allocate a new astring */
astring *astring_alloc(void);
/* free an astring */
void astring_free(astring *str);
/* free an astring */
void astring_expand(astring *str, int length);
/* ----- inline astring changes ----- */
/* copy one astring into another */
astring *astring_cpy(astring *dst, const astring *src);
/* copy a C string into an astring */
astring *astring_cpyc(astring *dst, const char *src);
/* copy a character array into an astring */
astring *astring_cpych(astring *dst, const char *src, int count);
/* copy a substring of one string into another */
astring *astring_cpysubstr(astring *dst, const astring *src, int start, int count);
/* insert one astring into another */
astring *astring_ins(astring *dst, int insbefore, const astring *src);
/* insert a C string into an astring */
astring *astring_insc(astring *dst, int insbefore, const char *src);
/* insert a character array into an astring */
astring *astring_insch(astring *dst, int insbefore, const char *src, int count);
/* insert a substring of one string into another */
astring *astring_inssubstr(astring *dst, int insbefore, const astring *src, int start, int count);
/* extract a substring of ourself, removing everything else */
astring *astring_substr(astring *str, int start, int count);
/* delete a substring from ourself, keeping everything else */
astring *astring_del(astring *str, int start, int count);
/* formatted printf to an astring */
int astring_printf(astring *dst, const char *format, ...) ATTR_PRINTF(2,3);
/* formatted vprintf to an astring */
int astring_vprintf(astring *dst, const char *format, va_list args);
/* formatted printf to the end of an astring */
int astring_catprintf(astring *dst, const char *format, ...) ATTR_PRINTF(2,3);
/* formatted vprintf to the end of an astring */
int astring_catvprintf(astring *dst, const char *format, va_list args);
/* ----- astring queries ----- */
/* return a pointer to a C string from an astring */
const char *astring_c(const astring *str);
/* return the length of an astring */
int astring_len(const astring *str);
/* compare two astrings */
int astring_cmp(const astring *str1, const astring *str2);
/* compare an astring to a C string */
int astring_cmpc(const astring *str1, const char *str2);
/* compare an astring to a character buffer */
int astring_cmpch(const astring *str1, const char *str2, int count);
/* compare an astring to a character buffer */
int astring_cmpsubstr(const astring *str1, const astring *str2, int start, int count);
/* case-insenstive compare two astrings */
int astring_icmp(const astring *str1, const astring *str2);
/* case-insenstive compare an astring to a C string */
int astring_icmpc(const astring *str1, const char *str2);
/* case-insenstive compare an astring to a character buffer */
int astring_icmpch(const astring *str1, const char *str2, int count);
/* case-insenstive compare an astring to a character buffer */
int astring_icmpsubstr(const astring *str1, const astring *str2, int start, int count);
/* search an astring for a character, returning offset or -1 if not found */
int astring_chr(const astring *str, int start, int ch);
/* reverse search an astring for a character, returning offset or -1 if not found */
int astring_rchr(const astring *str, int start, int ch);
/* search in an astring for another astring, returning offset or -1 if not found */
int astring_find(const astring *str, int start, const astring *search);
/* search in an astring for a C string, returning offset or -1 if not found */
int astring_findc(const astring *str, int start, const char *search);
/* search in an astring for another astring, replacing all instances with a third and returning the number of matches */
int astring_replace(astring *str, int start, const astring *search, const astring *replace);
/* search in an astring for a C string, replacing all instances with another C string and returning the number of matches */
int astring_replacec(astring *str, int start, const char *search, const char *replace);
/* ----- astring utilties ----- */
/* delete all instances of 'ch' */
astring *astring_delchr(astring *str, int ch);
/* replace all instances of 'ch' with 'newch' */
astring *astring_replacechr(astring *str, int ch, int newch);
/* convert string to all upper-case */
astring *astring_toupper(astring *str);
/* convert string to all lower-case */
astring *astring_tolower(astring *str);
/* remove all space characters from beginning/end */
astring *astring_trimspace(astring *str);
/***************************************************************************
INLINE FUNCTIONS
***************************************************************************/
/* allocate a new duplicate of an astring */
INLINE astring *astring_dup(const astring *str)
{
return astring_cpy(astring_alloc(), str);
}
/* allocate a new duplicate of an astring */
INLINE astring *astring_dupc(const char *str)
{
return astring_cpyc(astring_alloc(), str);
}
/* allocate a new duplicate of an astring */
INLINE astring *astring_dupch(const char *str, int count)
{
return astring_cpych(astring_alloc(), str, count);
}
/* allocate a duplicate of a substring */
INLINE astring *astring_dupsubstr(const astring *str, int start, int count)
{
return astring_cpysubstr(astring_alloc(), str, start, count);
}
/* reset an astring to an empty string */
INLINE astring *astring_reset(astring *dst)
{
return astring_cpyc(dst, "");
}
/* concatenate one astring to the end of another */
INLINE astring *astring_cat(astring *dst, const astring *src)
{
return astring_ins(dst, -1, src);
}
/* concatenate a C string to the end of an astring */
INLINE astring *astring_catc(astring *dst, const char *src)
{
return astring_insc(dst, -1, src);
}
/* concatenate a character array to the end of an astring */
INLINE astring *astring_catch(astring *dst, const char *src, int count)
{
return astring_insch(dst, -1, src, count);
}
/* concatenate a substring of one string into another */
INLINE astring *astring_catsubstr(astring *dst, const astring *src, int start, int count)
{
return astring_inssubstr(dst, -1, src, start, count);
}
/* assemble an astring from 2 C strings */
INLINE astring *astring_assemble_2(astring *dst, const char *src1, const char *src2)
{
return astring_catc(astring_cpyc(dst, src1), src2);
}
/* assemble an astring from 3 C strings */
INLINE astring *astring_assemble_3(astring *dst, const char *src1, const char *src2, const char *src3)
{
return astring_catc(astring_assemble_2(dst, src1, src2), src3);
}
/* assemble an astring from 4 C strings */
INLINE astring *astring_assemble_4(astring *dst, const char *src1, const char *src2, const char *src3, const char *src4)
{
return astring_catc(astring_assemble_3(dst, src1, src2, src3), src4);
}
/* assemble an astring from 5 C strings */
INLINE astring *astring_assemble_5(astring *dst, const char *src1, const char *src2, const char *src3, const char *src4, const char *src5)
{
return astring_catc(astring_assemble_4(dst, src1, src2, src3, src4), src5);
}
/***************************************************************************
C++ WRAPPERS
***************************************************************************/
#ifdef __cplusplus
#ifdef SDLMAME_NETBSD
#undef toupper
#undef tolower
#endif
/* derived class for C++ */
class astring : public astring_base
{
private:
astring &init();
public: public:
// simple construction/destruction
astring() { init(); } astring() { init(); }
~astring(); ~astring();
// construction with copy
astring(const char *string) { init().cpy(string); } astring(const char *string) { init().cpy(string); }
astring(const char *string, int length) { init().cpy(string, length); } astring(const char *string, int length) { init().cpy(string, length); }
astring(const char *str1, const char *str2) { init().cpy(str1).cat(str2); } astring(const char *str1, const char *str2) { init().cpy(str1).cat(str2); }
@ -327,14 +70,17 @@ public:
astring(const astring &string) { init().cpy(string); } astring(const astring &string) { init().cpy(string); }
astring(const astring &string, int start, int count = -1) { init().cpysubstr(string, start, count); } astring(const astring &string, int start, int count = -1) { init().cpysubstr(string, start, count); }
// assignment operators
astring &operator=(const char *string) { return cpy(string); } astring &operator=(const char *string) { return cpy(string); }
astring &operator=(const astring &string) { return cpy(string); } astring &operator=(const astring &string) { return cpy(string); }
// concatenation operators
astring& operator+=(const astring &string) { return cat(string); } astring& operator+=(const astring &string) { return cat(string); }
friend astring operator+(const astring &lhs, const astring &rhs) { return astring(lhs) += rhs; } friend astring operator+(const astring &lhs, const astring &rhs) { return astring(lhs) += rhs; }
friend astring operator+(const astring &lhs, const char *rhs) { return astring(lhs) += rhs; } friend astring operator+(const astring &lhs, const char *rhs) { return astring(lhs) += rhs; }
friend astring operator+(const char *lhs, const astring &rhs) { return astring(lhs) += rhs; } friend astring operator+(const char *lhs, const astring &rhs) { return astring(lhs) += rhs; }
// comparison operators
bool operator==(const char *string) const { return (cmp(string) == 0); } bool operator==(const char *string) const { return (cmp(string) == 0); }
bool operator==(const astring &string) const { return (cmp(string) == 0); } bool operator==(const astring &string) const { return (cmp(string) == 0); }
bool operator!=(const char *string) const { return (cmp(string) != 0); } bool operator!=(const char *string) const { return (cmp(string) != 0); }
@ -348,68 +94,97 @@ public:
bool operator>=(const char *string) const { return (cmp(string) >= 0); } bool operator>=(const char *string) const { return (cmp(string) >= 0); }
bool operator>=(const astring &string) const { return (cmp(string) >= 0); } bool operator>=(const astring &string) const { return (cmp(string) >= 0); }
// character access operators
char operator[](int index) const { return (index < len()) ? m_text[index] : 0; }
// implicit boolean conversion operators
operator bool() { return m_text[0] != 0; }
operator bool() const { return m_text[0] != 0; }
// C string conversion operators and helpers
operator const char *() const { return m_text; }
const char *cstr() const { return m_text; }
char *stringbuffer(int size) { ensure_room(size); return m_text; }
// buffer management
astring &reset() { return cpy(""); } astring &reset() { return cpy(""); }
astring &expand(int length) { astring_expand(this, length); return *this; } astring &expand(int length) { ensure_room(length); return *this; }
operator bool() { return this->text[0] != 0; } // length query
operator bool() const { return this->text[0] != 0; } int len() const { return strlen(m_text); }
operator const char *() const { return astring_c(this); }
const char *cstr() const { return astring_c(this); }
int len() const { return astring_len(this); }
astring &cpy(const astring &src) { return *astring_cpy(this, &src); } // copy helpers
astring &cpy(const char *src) { return *astring_cpyc(this, src); } astring &cpy(const char *src, int count);
astring &cpy(const char *src, int count) { return *astring_cpych(this, src, count); } astring &cpysubstr(const astring &src, int start, int count = -1);
astring &cpysubstr(const astring &src, int start, int count) { return *astring_cpysubstr(this, &src, start, count); } astring &cpy(const astring &src) { return cpy(src.cstr(), src.len()); }
astring &cpy(const char *src) { return cpy(src, strlen(src)); }
astring &cat(char ch) { return *astring_insch(this, -1, &ch, 1); } // insertion helpers
astring &cat(const astring &src) { return ins(-1, src); } astring &ins(int insbefore, const char *src, int count);
astring &cat(const char *src) { return ins(-1, src); } astring &inssubstr(int insbefore, const astring &src, int start, int count = -1);
astring &ins(int insbefore, const astring &src) { return ins(insbefore, src.cstr(), src.len()); }
astring &ins(int insbefore, const char *src) { return ins(insbefore, src, strlen(src)); }
// concatenation helpers (== insert at end)
astring &cat(const char *src, int count) { return ins(-1, src, count); } astring &cat(const char *src, int count) { return ins(-1, src, count); }
astring &catsubstr(const astring &src, int start, int count) { return inssubstr(-1, src, start, count); } astring &catsubstr(const astring &src, int start, int count = -1) { return inssubstr(-1, src, start, count); }
astring &cat(const astring &src) { return ins(-1, src.cstr(), src.len()); }
astring &cat(const char *src) { return ins(-1, src, strlen(src)); }
astring &cat(char ch) { return ins(-1, &ch, 1); }
astring &ins(int insbefore, const astring &src) { return *astring_ins(this, insbefore, &src); } // substring helpers
astring &ins(int insbefore, const char *src) { return *astring_insc(this, insbefore, src); } astring &substr(int start, int count = -1);
astring &ins(int insbefore, const char *src, int count) { return *astring_insch(this, insbefore, src, count); } astring &del(int start, int count = -1);
astring &inssubstr(int insbefore, const astring &src, int start, int count) { return *astring_inssubstr(this, insbefore, &src, start, count); }
astring &substr(int start, int count) { return *astring_substr(this, start, count); } // formatted string helpers
astring &del(int start, int count) { return *astring_del(this, start, count); } int vprintf(const char *format, va_list args);
int catvprintf(const char *format, va_list args);
int printf(const char *format, ...) { va_list ap; va_start(ap, format); int result = this->vprintf(format, ap); va_end(ap); return result; }
int catprintf(const char *format, ...) { va_list ap; va_start(ap, format); int result = catvprintf(format, ap); va_end(ap); return result; }
astring &format(const char *format, ...) { va_list ap; va_start(ap, format); this->vprintf(format, ap); va_end(ap); return *this; }
astring &catformat(const char *format, ...) { va_list ap; va_start(ap, format); catvprintf(format, ap); va_end(ap); return *this; }
int printf(const char *format, ...) { va_list ap; va_start(ap, format); int result = astring_vprintf(this, format, ap); va_end(ap); return result; } // comparison helpers
int vprintf(const char *format, va_list args) { return astring_vprintf(this, format, args); } int cmp(const char *str2, int count) const;
int catprintf(const char *format, ...) { va_list ap; va_start(ap, format); int result = astring_catvprintf(this, format, ap); va_end(ap); return result; } int cmpsubstr(const astring &str2, int start, int count = -1) const;
int catvprintf(const char *format, va_list args) { return astring_catvprintf(this, format, args); } int cmp(const astring &str2) const { return cmp(str2.cstr(), str2.len()); }
int cmp(const char *str2) const { return cmp(str2, strlen(str2)); }
astring &format(const char *format, ...) { va_list ap; va_start(ap, format); astring_vprintf(this, format, ap); va_end(ap); return *this; } // case-insensitive comparison helpers
int icmp(const char *str2, int count) const;
int icmpsubstr(const astring &str2, int start, int count = -1) const;
int icmp(const astring &str2) const { return icmp(str2.cstr(), str2.len()); }
int icmp(const char *str2) const { return icmp(str2, strlen(str2)); }
int cmp(const astring &str2) const { return astring_cmp(this, &str2); } // character searching helpers
int cmp(const char *str2) const { return astring_cmpc(this, str2); } int chr(int start, int ch) const;
int cmp(const char *str2, int count) const { return astring_cmpch(this, str2, count); } int rchr(int start, int ch) const;
int cmpsubstr(const astring &str2, int start, int count) const { return astring_cmpsubstr(this, &str2, start, count); }
int icmp(const astring &str2) const { return astring_icmp(this, &str2); } // string searching/replacing helpers
int icmp(const char *str2) const { return astring_icmpc(this, str2); } int find(int start, const char *search) const;
int icmp(const char *str2, int count) const { return astring_icmpch(this, str2, count); } int find(const char *search) const { return find(0, search); }
int icmpsubstr(const astring &str2, int start, int count) const { return astring_icmpsubstr(this, &str2, start, count); } int replace(int start, const char *search, const char *replace);
int replace(const char *search, const char *_replace) { return replace(0, search, _replace); }
int chr(int start, int ch) const { return astring_chr(this, start, ch); } // misc utilities
int rchr(int start, int ch) const { return astring_rchr(this, start, ch); } astring &delchr(int ch);
astring &replacechr(int ch, int newch);
astring &makeupper();
astring &makelower();
astring &trimspace();
int find(int start, const astring &search) const { return astring_find(this, start, &search); } private:
int find(int start, const char *search) const { return astring_findc(this, start, search); } // internal helpers
astring &init();
char *safe_string_base(int start) const;
bool ensure_room(int length);
void normalize_substr(int &start, int &count, int length) const;
int replace(int start, const astring &search, const astring &replace) { return astring_replace(this, start, &search, &replace); } // internal state
int replace(int start, const char *search, const char *replace) { return astring_replacec(this, start, search, replace); } char * m_text;
int m_alloclen;
astring &delchr(int ch) { return *astring_delchr(this, ch); } char m_smallbuf[64];
astring &replacechr(int ch, int newch) { return *astring_replacechr(this, ch, newch); }
astring &toupper() { return *astring_toupper(this); }
astring &tolower() { return *astring_tolower(this); }
astring &trimspace() { return *astring_trimspace(this); }
}; };
#endif
#endif /* __ASTRING_H__ */ #endif /* __ASTRING_H__ */

6
src/lib/util/corefile.c
View File

@ -883,7 +883,7 @@ int CLIB_DECL core_fprintf(core_file *f, const char *fmt, ...)
assumptions about path separators assumptions about path separators
-------------------------------------------------*/ -------------------------------------------------*/
astring *core_filename_extract_base(astring *result, const char *name, int strip_extension) astring &core_filename_extract_base(astring &result, const char *name, bool strip_extension)
{ {
/* find the start of the name */ /* find the start of the name */
const char *start = name + strlen(name); const char *start = name + strlen(name);
@ -891,11 +891,11 @@ astring *core_filename_extract_base(astring *result, const char *name, int strip
start--; start--;
/* copy the rest into an astring */ /* copy the rest into an astring */
astring_cpyc(result, start); result.cpy(start);
/* chop the extension if present */ /* chop the extension if present */
if (strip_extension) if (strip_extension)
astring_substr(result, 0, astring_rchr(result, 0, '.')); result.substr(0, result.rchr(0, '.'));
return result; return result;
} }

2
src/lib/util/corefile.h
View File

@ -149,7 +149,7 @@ int CLIB_DECL core_fprintf(core_file *f, const char *fmt, ...) ATTR_PRINTF(2,3);
/* ----- filename utilities ----- */ /* ----- filename utilities ----- */
/* extract the base part of a filename (remove extensions and paths) */ /* extract the base part of a filename (remove extensions and paths) */
astring *core_filename_extract_base(astring *result, const char *name, int strip_extension); astring &core_filename_extract_base(astring &result, const char *name, bool strip_extension = false);
/* true if the given filename ends with a particular extension */ /* true if the given filename ends with a particular extension */
int core_filename_ends_with(const char *filename, const char *extension); int core_filename_ends_with(const char *filename, const char *extension);

227
src/lib/util/zippath.c
View File

@ -8,6 +8,7 @@
#include <ctype.h> #include <ctype.h>
#include <stdlib.h> #include <stdlib.h>
#include <new>
#include "zippath.h" #include "zippath.h"
#include "unzip.h" #include "unzip.h"
#include "corestr.h" #include "corestr.h"
@ -18,28 +19,35 @@
TYPE DEFINITIONS TYPE DEFINITIONS
***************************************************************************/ ***************************************************************************/
typedef struct _zippath_returned_directory zippath_returned_directory; struct zippath_returned_directory
struct _zippath_returned_directory
{ {
zippath_returned_directory *next; zippath_returned_directory *next;
char name[1]; astring name;
}; };
struct _zippath_directory class zippath_directory
{ {
public:
zippath_directory()
: returned_parent(false),
directory(NULL),
called_zip_first(false),
zipfile(NULL),
returned_dirlist(NULL) { }
/* common */ /* common */
unsigned int returned_parent : 1; bool returned_parent;
osd_directory_entry returned_entry; osd_directory_entry returned_entry;
/* specific to normal directories */ /* specific to normal directories */
osd_directory *directory; osd_directory *directory;
/* specific to ZIP directories */ /* specific to ZIP directories */
unsigned int called_zip_first : 1; bool called_zip_first;
zip_file *zipfile; zip_file *zipfile;
astring *zipprefix; astring zipprefix;
zippath_returned_directory *returned_dirlist; zippath_returned_directory *returned_dirlist;
}; };
@ -99,13 +107,13 @@ static void parse_parent_path(const char *path, int *beginpos, int *endpos)
zippath_parent - retrieves the parent directory zippath_parent - retrieves the parent directory
-------------------------------------------------*/ -------------------------------------------------*/
astring *zippath_parent(astring *dst, const char *path) astring &zippath_parent(astring &dst, const char *path)
{ {
int pos; int pos;
parse_parent_path(path, &pos, NULL); parse_parent_path(path, &pos, NULL);
/* return the result */ /* return the result */
return (pos >= 0) ? astring_cpych(dst, path, pos + 1) : astring_cpyc(dst, ""); return (pos >= 0) ? dst.cpy(path, pos + 1) : dst.reset();
} }
@ -115,12 +123,12 @@ astring *zippath_parent(astring *dst, const char *path)
directory basename directory basename
-------------------------------------------------*/ -------------------------------------------------*/
astring *zippath_parent_basename(astring *dst, const char *path) astring &zippath_parent_basename(astring &dst, const char *path)
{ {
int beginpos, endpos; int beginpos, endpos;
parse_parent_path(path, &beginpos, &endpos); parse_parent_path(path, &beginpos, &endpos);
return astring_cpych(dst, path + beginpos + 1, endpos - beginpos); return dst.cpy(path + beginpos + 1, endpos - beginpos);
} }
@ -129,31 +137,29 @@ astring *zippath_parent_basename(astring *dst, const char *path)
zippath_combine - combines two paths zippath_combine - combines two paths
-------------------------------------------------*/ -------------------------------------------------*/
astring *zippath_combine(astring *dst, const char *path1, const char *path2) astring &zippath_combine(astring &dst, const char *path1, const char *path2)
{ {
astring *result;
if (!strcmp(path2, ".")) if (!strcmp(path2, "."))
{ {
result = astring_cpyc(dst, path1); dst.cpy(path1);
} }
else if (!strcmp(path2, "..")) else if (!strcmp(path2, ".."))
{ {
result = zippath_parent(dst, path1); zippath_parent(dst, path1);
} }
else if (osd_is_absolute_path(path2)) else if (osd_is_absolute_path(path2))
{ {
result = astring_cpyc(dst, path2); dst.cpy(path2);
} }
else if ((path1[0] != '\0') && !is_path_separator(path1[strlen(path1) - 1])) else if ((path1[0] != '\0') && !is_path_separator(path1[strlen(path1) - 1]))
{ {
result = astring_assemble_3(dst, path1, PATH_SEPARATOR, path2); dst.cpy(path1).cat(PATH_SEPARATOR).cat(path2);
} }
else else
{ {
result = astring_assemble_2(dst, path1, path2); dst.cpy(path1).cat(path2);
} }
return result; return dst;
} }
@ -200,7 +206,7 @@ static file_error file_error_from_zip_error(zip_error ziperr)
from a zip file entry from a zip file entry
-------------------------------------------------*/ -------------------------------------------------*/
static file_error create_core_file_from_zip(zip_file *zip, const zip_file_header *header, core_file **file) static file_error create_core_file_from_zip(zip_file *zip, const zip_file_header *header, core_file *&file)
{ {
file_error filerr; file_error filerr;
zip_error ziperr; zip_error ziperr;
@ -220,7 +226,7 @@ static file_error create_core_file_from_zip(zip_file *zip, const zip_file_header
goto done; goto done;
} }
filerr = core_fopen_ram_copy(ptr, header->uncompressed_length, OPEN_FLAG_READ, file); filerr = core_fopen_ram_copy(ptr, header->uncompressed_length, OPEN_FLAG_READ, &file);
if (filerr != FILERR_NONE) if (filerr != FILERR_NONE)
goto done; goto done;
@ -235,36 +241,30 @@ done:
zippath_fopen - opens a zip path file zippath_fopen - opens a zip path file
-------------------------------------------------*/ -------------------------------------------------*/
file_error zippath_fopen(const char *filename, UINT32 openflags, core_file **file, astring *revised_path) file_error zippath_fopen(const char *filename, UINT32 openflags, core_file *&file, astring &revised_path)
{ {
file_error filerr = FILERR_NOT_FOUND; file_error filerr = FILERR_NOT_FOUND;
zip_error ziperr; zip_error ziperr;
zip_file *zip = NULL; zip_file *zip = NULL;
const zip_file_header *header; const zip_file_header *header;
osd_dir_entry_type entry_type; osd_dir_entry_type entry_type;
astring *mainpath;
astring *subpath;
astring *temp;
astring *temp2;
char *alloc_fullpath = NULL; char *alloc_fullpath = NULL;
int len; int len;
/* first, set up the two types of paths */ /* first, set up the two types of paths */
mainpath = astring_cpyc(astring_alloc(), filename); astring mainpath(filename);
subpath = astring_alloc(); astring subpath;
temp = astring_alloc(); file = NULL;
temp2 = astring_alloc();
*file = NULL;
/* loop through */ /* loop through */
while((*file == NULL) && (astring_len(mainpath) > 0) while((file == NULL) && (mainpath.len() > 0)
&& ((openflags == OPEN_FLAG_READ) || (astring_len(subpath) == 0))) && ((openflags == OPEN_FLAG_READ) || (subpath.len() == 0)))
{ {
/* is the mainpath a ZIP path? */ /* is the mainpath a ZIP path? */
if (is_zip_file(astring_c(mainpath))) if (is_zip_file(mainpath))
{ {
/* this file might be a zip file - lets take a look */ /* this file might be a zip file - lets take a look */
ziperr = zip_file_open(astring_c(mainpath), &zip); ziperr = zip_file_open(mainpath, &zip);
if (ziperr == ZIPERR_NONE) if (ziperr == ZIPERR_NONE)
{ {
/* it is a zip file - error if we're not opening for reading */ /* it is a zip file - error if we're not opening for reading */
@ -274,8 +274,8 @@ file_error zippath_fopen(const char *filename, UINT32 openflags, core_file **fil
goto done; goto done;
} }
if (astring_len(subpath) > 0) if (subpath.len() > 0)
header = zippath_find_sub_path(zip, astring_c(subpath), &entry_type); header = zippath_find_sub_path(zip, subpath, &entry_type);
else else
header = zip_file_first_file(zip); header = zip_file_first_file(zip);
@ -291,16 +291,16 @@ file_error zippath_fopen(const char *filename, UINT32 openflags, core_file **fil
goto done; goto done;
/* update subpath, if appropriate */ /* update subpath, if appropriate */
if (astring_len(subpath) == 0) if (subpath.len() == 0)
astring_cpyc(subpath, header->filename); subpath.cpy(header->filename);
/* we're done */ /* we're done */
goto done; goto done;
} }
} }
if (astring_len(subpath) == 0) if (subpath.len() == 0)
filerr = core_fopen(filename, openflags, file); filerr = core_fopen(filename, openflags, &file);
else else
filerr = FILERR_NOT_FOUND; filerr = FILERR_NOT_FOUND;
@ -308,56 +308,45 @@ file_error zippath_fopen(const char *filename, UINT32 openflags, core_file **fil
if (filerr != FILERR_NONE) if (filerr != FILERR_NONE)
{ {
/* go up a directory */ /* go up a directory */
zippath_parent(temp, astring_c(mainpath)); astring temp;
zippath_parent(temp, mainpath);
/* append to the sub path */ /* append to the sub path */
if (astring_len(subpath) > 0) if (subpath.len() > 0)
{ {
astring_assemble_3(temp2, astring_c(mainpath) + astring_len(temp), PATH_SEPARATOR, astring_c(subpath)); astring temp2;
astring_cpy(subpath, temp2); temp2.cpysubstr(mainpath, temp.len()).cat(PATH_SEPARATOR).cat(subpath);
subpath.cpy(temp2);
} }
else else
{ subpath.cpysubstr(mainpath, temp.len());
astring_cpyc(subpath, astring_c(mainpath) + astring_len(temp));
}
/* get the new main path, truncating path separators */ /* get the new main path, truncating path separators */
len = astring_len(temp); len = temp.len();
while((len > 0) && is_zip_file_separator(astring_c(temp)[len - 1])) while (len > 0 && is_zip_file_separator(temp[len - 1]))
len--; len--;
astring_cpych(mainpath, astring_c(temp), len); mainpath.cpysubstr(temp, 0, len);
} }
} }
done: done:
/* store the revised path if appropriate */ /* store the revised path */
if (revised_path != NULL) revised_path.reset();
{
astring_cpyc(revised_path, "");
if (filerr == FILERR_NONE) if (filerr == FILERR_NONE)
{ {
/* cannonicalize mainpath */ /* cannonicalize mainpath */
filerr = osd_get_full_path(&alloc_fullpath, astring_c(mainpath)); filerr = osd_get_full_path(&alloc_fullpath, mainpath);
if (filerr == FILERR_NONE) if (filerr == FILERR_NONE)
{ {
if (astring_len(subpath) > 0) if (subpath.len() > 0)
astring_assemble_3(revised_path, alloc_fullpath, PATH_SEPARATOR, astring_c(subpath)); revised_path.cpy(alloc_fullpath).cat(PATH_SEPARATOR).cat(subpath);
else else
astring_cpyc(revised_path, alloc_fullpath); revised_path.cpy(alloc_fullpath);
}
} }
} }
if (zip != NULL) if (zip != NULL)
zip_file_close(zip); zip_file_close(zip);
if (mainpath != NULL)
astring_free(mainpath);
if (subpath != NULL)
astring_free(subpath);
if (temp != NULL)
astring_free(temp);
if (temp2 != NULL)
astring_free(temp2);
if (alloc_fullpath != NULL) if (alloc_fullpath != NULL)
osd_free(alloc_fullpath); osd_free(alloc_fullpath);
return filerr; return filerr;
@ -526,32 +515,32 @@ static const zip_file_header *zippath_find_sub_path(zip_file *zipfile, const cha
true path and ZIP entry components true path and ZIP entry components
-------------------------------------------------*/ -------------------------------------------------*/
static file_error zippath_resolve(const char *path, osd_dir_entry_type *entry_type, static file_error zippath_resolve(const char *path, osd_dir_entry_type &entry_type, zip_file *&zipfile, astring &newpath)
zip_file **zipfile, astring *newpath)
{ {
file_error err; file_error err;
osd_directory_entry *current_entry = NULL; osd_directory_entry *current_entry = NULL;
osd_dir_entry_type current_entry_type; osd_dir_entry_type current_entry_type;
astring *apath = astring_cpyc(astring_alloc(), path);
astring *apath_trimmed = astring_alloc();
astring *parent = NULL;
int went_up = FALSE; int went_up = FALSE;
int i; int i;
/* be conservative */ newpath.reset();
*entry_type = ENTTYPE_NONE;
*zipfile = NULL;
/* be conservative */
entry_type = ENTTYPE_NONE;
zipfile = NULL;
astring apath(path);
astring apath_trimmed;
do do
{ {
/* trim the path of trailing path separators */ /* trim the path of trailing path separators */
i = astring_len(apath); i = apath.len();
while((i > 1) && is_path_separator(astring_c(apath)[i - 1])) while (i > 1 && is_path_separator(apath[i - 1]))
i--; i--;
apath_trimmed = astring_cpysubstr(apath_trimmed, apath, 0, i); apath_trimmed.cpysubstr(apath, 0, i);
/* stat the path */ /* stat the path */
current_entry = osd_stat(astring_c(apath_trimmed)); current_entry = osd_stat(apath_trimmed);
/* did we find anything? */ /* did we find anything? */
if (current_entry != NULL) if (current_entry != NULL)
@ -566,12 +555,11 @@ static file_error zippath_resolve(const char *path, osd_dir_entry_type *entry_ty
/* if we have not found the file or directory, go up */ /* if we have not found the file or directory, go up */
current_entry_type = ENTTYPE_NONE; current_entry_type = ENTTYPE_NONE;
went_up = TRUE; went_up = TRUE;
parent = zippath_parent(astring_alloc(), astring_c(apath)); astring parent;
astring_free(apath); apath.cpy(zippath_parent(parent, apath));
apath = parent;
} }
} }
while((current_entry_type == ENTTYPE_NONE) && (apath != NULL) && !is_root(astring_c(apath))); while (current_entry_type == ENTTYPE_NONE && !is_root(apath));
/* if we did not find anything, then error out */ /* if we did not find anything, then error out */
if (current_entry_type == ENTTYPE_NONE) if (current_entry_type == ENTTYPE_NONE)
@ -581,16 +569,16 @@ static file_error zippath_resolve(const char *path, osd_dir_entry_type *entry_ty
} }
/* is this file a ZIP file? */ /* is this file a ZIP file? */
if ((current_entry_type == ENTTYPE_FILE) && is_zip_file(astring_c(apath_trimmed)) if ((current_entry_type == ENTTYPE_FILE) && is_zip_file(apath_trimmed)
&& (zip_file_open(astring_c(apath_trimmed), zipfile) == ZIPERR_NONE)) && (zip_file_open(apath_trimmed, &zipfile) == ZIPERR_NONE))
{ {
i = strlen(path + astring_len(apath)); i = strlen(path + apath.len());
while((i > 0) && is_zip_path_separator(path[astring_len(apath) + i - 1])) while (i > 0 && is_zip_path_separator(path[apath.len() + i - 1]))
i--; i--;
astring_cpych(newpath, path + astring_len(apath), i); newpath.cpy(path + apath.len(), i);
/* this was a true ZIP path - attempt to identify the type of path */ /* this was a true ZIP path - attempt to identify the type of path */
zippath_find_sub_path(*zipfile, astring_c(newpath), &current_entry_type); zippath_find_sub_path(zipfile, newpath, &current_entry_type);
if (current_entry_type == ENTTYPE_NONE) if (current_entry_type == ENTTYPE_NONE)
{ {
err = FILERR_NOT_FOUND; err = FILERR_NOT_FOUND;
@ -605,18 +593,14 @@ static file_error zippath_resolve(const char *path, osd_dir_entry_type *entry_ty
err = FILERR_NOT_FOUND; err = FILERR_NOT_FOUND;
goto done; goto done;
} }
astring_cpyc(newpath, path); newpath.cpy(path);
} }
/* success! */ /* success! */
*entry_type = current_entry_type; entry_type = current_entry_type;
err = FILERR_NONE; err = FILERR_NONE;
done: done:
if (apath != NULL)
astring_free(apath);
if (apath_trimmed != NULL)
astring_free(apath_trimmed);
return err; return err;
} }
@ -628,21 +612,18 @@ done:
file_error zippath_opendir(const char *path, zippath_directory **directory) file_error zippath_opendir(const char *path, zippath_directory **directory)
{ {
file_error err; file_error err;
osd_dir_entry_type entry_type;
astring *newpath = astring_alloc();
zippath_directory *result;
/* allocate a directory */ /* allocate a directory */
result = (zippath_directory *) malloc(sizeof(*result)); zippath_directory *result = new(std::nothrow) zippath_directory;
if (result == NULL) if (result == NULL)
{ {
err = FILERR_OUT_OF_MEMORY; err = FILERR_OUT_OF_MEMORY;
goto done; goto done;
} }
memset(result, 0, sizeof(*result));
/* resolve the path */ /* resolve the path */
err = zippath_resolve(path, &entry_type, &result->zipfile, newpath); osd_dir_entry_type entry_type;
err = zippath_resolve(path, entry_type, result->zipfile, result->zipprefix);
if (err != FILERR_NONE) if (err != FILERR_NONE)
goto done; goto done;
@ -654,12 +635,7 @@ file_error zippath_opendir(const char *path, zippath_directory **directory)
} }
/* was the result a ZIP? */ /* was the result a ZIP? */
if (result->zipfile != NULL) if (result->zipfile == NULL)
{
result->zipprefix = newpath;
newpath = NULL;
}
else
{ {
/* a conventional directory */ /* a conventional directory */
result->directory = osd_opendir(path); result->directory = osd_opendir(path);
@ -671,20 +647,15 @@ file_error zippath_opendir(const char *path, zippath_directory **directory)
/* is this path the root? if so, pretend we've already returned the parent */ /* is this path the root? if so, pretend we've already returned the parent */
if (is_root(path)) if (is_root(path))
result->returned_parent = TRUE; result->returned_parent = true;
} }
done: done:
if (((directory == NULL) || (err != FILERR_NONE)) && (result != NULL)) if ((directory == NULL || err != FILERR_NONE) && result != NULL)
{ {
zippath_closedir(result); zippath_closedir(result);
result = NULL; result = NULL;
} }
if (newpath != NULL)
{
astring_free(newpath);
newpath = NULL;
}
if (directory != NULL) if (directory != NULL)
*directory = result; *directory = result;
return err; return err;
@ -697,25 +668,20 @@ done:
void zippath_closedir(zippath_directory *directory) void zippath_closedir(zippath_directory *directory)
{ {
zippath_returned_directory *dirlist;
if (directory->directory != NULL) if (directory->directory != NULL)
osd_closedir(directory->directory); osd_closedir(directory->directory);
if (directory->zipfile != NULL) if (directory->zipfile != NULL)
zip_file_close(directory->zipfile); zip_file_close(directory->zipfile);
if (directory->zipprefix != NULL)
astring_free(directory->zipprefix);
while (directory->returned_dirlist != NULL) while (directory->returned_dirlist != NULL)
{ {
dirlist = directory->returned_dirlist; zippath_returned_directory *dirlist = directory->returned_dirlist;
directory->returned_dirlist = directory->returned_dirlist->next; directory->returned_dirlist = directory->returned_dirlist->next;
free(dirlist); delete dirlist;
} }
free(directory); delete directory;
} }
@ -728,10 +694,10 @@ void zippath_closedir(zippath_directory *directory)
static const char *get_relative_path(zippath_directory *directory, const zip_file_header *header) static const char *get_relative_path(zippath_directory *directory, const zip_file_header *header)
{ {
const char *result = NULL; const char *result = NULL;
int len = astring_len(directory->zipprefix); int len = directory->zipprefix.len();
if ((len <= strlen(header->filename)) if ((len <= strlen(header->filename))
&& !strncmp(astring_c(directory->zipprefix), header->filename, len)) && !strncmp(directory->zipprefix, header->filename, len))
{ {
result = &header->filename[len]; result = &header->filename[len];
while(is_zip_file_separator(*result)) while(is_zip_file_separator(*result))
@ -758,7 +724,7 @@ const osd_directory_entry *zippath_readdir(zippath_directory *directory)
if (!directory->returned_parent) if (!directory->returned_parent)
{ {
/* first thing's first - return parent directory */ /* first thing's first - return parent directory */
directory->returned_parent = TRUE; directory->returned_parent = true;
memset(&directory->returned_entry, 0, sizeof(directory->returned_entry)); memset(&directory->returned_entry, 0, sizeof(directory->returned_entry));
directory->returned_entry.name = ".."; directory->returned_entry.name = "..";
directory->returned_entry.type = ENTTYPE_DIR; directory->returned_entry.type = ENTTYPE_DIR;
@ -793,7 +759,7 @@ const osd_directory_entry *zippath_readdir(zippath_directory *directory)
header = zip_file_first_file(directory->zipfile); header = zip_file_first_file(directory->zipfile);
else else
header = zip_file_next_file(directory->zipfile); header = zip_file_next_file(directory->zipfile);
directory->called_zip_first = TRUE; directory->called_zip_first = true;
relpath = NULL; relpath = NULL;
} }
while((header != NULL) && ((relpath = get_relative_path(directory, header)) == NULL)); while((header != NULL) && ((relpath = get_relative_path(directory, header)) == NULL));
@ -817,10 +783,9 @@ const osd_directory_entry *zippath_readdir(zippath_directory *directory)
if (rdent == NULL) if (rdent == NULL)
{ {
/* we've found a new directory; add this to returned_dirlist */ /* we've found a new directory; add this to returned_dirlist */
rdent = (zippath_returned_directory *)malloc(sizeof(*rdent) + (separator - relpath)); rdent = new zippath_returned_directory;
rdent->next = directory->returned_dirlist; rdent->next = directory->returned_dirlist;
memcpy(rdent->name, relpath, (separator - relpath) * sizeof(rdent->name[0])); rdent->name.cpy(relpath, separator - relpath);
rdent->name[separator - relpath] = '\0';
directory->returned_dirlist = rdent; directory->returned_dirlist = rdent;
/* ...and return it */ /* ...and return it */

11
src/lib/util/zippath.h
View File

@ -14,14 +14,13 @@
#include "corefile.h" #include "corefile.h"
#include "astring.h" #include "astring.h"
#include "unzip.h" #include "unzip.h"
#include "astring.h"
/*************************************************************************** /***************************************************************************
TYPE DEFINITIONS TYPE DEFINITIONS
***************************************************************************/ ***************************************************************************/
typedef struct _zippath_directory zippath_directory; class zippath_directory;
@ -32,19 +31,19 @@ typedef struct _zippath_directory zippath_directory;
/* ----- path operations ----- */ /* ----- path operations ----- */
/* retrieves the parent directory */ /* retrieves the parent directory */
astring *zippath_parent(astring *dst, const char *path); astring &zippath_parent(astring &dst, const char *path);
/* retrieves the parent directory basename */ /* retrieves the parent directory basename */
astring *zippath_parent_basename(astring *dst, const char *path); astring &zippath_parent_basename(astring &dst, const char *path);
/* combines two paths */ /* combines two paths */
astring *zippath_combine(astring *dst, const char *path1, const char *path2); astring &zippath_combine(astring &dst, const char *path1, const char *path2);
/* ----- file operations ----- */ /* ----- file operations ----- */
/* opens a zip path file */ /* opens a zip path file */
file_error zippath_fopen(const char *filename, UINT32 openflags, core_file **file, astring *revised_path); file_error zippath_fopen(const char *filename, UINT32 openflags, core_file *&file, astring &revised_path);
/* ----- directory operations ----- */ /* ----- directory operations ----- */

6
src/mame/drivers/jaguar.c
View File

@ -515,14 +515,12 @@ static MACHINE_RESET( jaguar )
static emu_file *jaguar_nvram_fopen( running_machine &machine, UINT32 openflags) static emu_file *jaguar_nvram_fopen( running_machine &machine, UINT32 openflags)
{ {
device_image_interface *image = dynamic_cast<device_image_interface *>(machine.device("cart")); device_image_interface *image = dynamic_cast<device_image_interface *>(machine.device("cart"));
astring *fname;
file_error filerr; file_error filerr;
emu_file *file; emu_file *file;
if (image->exists()) if (image->exists())
{ {
fname = astring_assemble_4( astring_alloc(), machine.system().name, PATH_SEPARATOR, image->basename_noext(), ".nv"); astring fname(machine.system().name, PATH_SEPARATOR, image->basename_noext(), ".nv");
filerr = mame_fopen( SEARCHPATH_NVRAM, astring_c( fname), openflags, &file); filerr = mame_fopen( SEARCHPATH_NVRAM, fname, openflags, &file);
astring_free( fname);
return (filerr == FILERR_NONE) ? file : NULL; return (filerr == FILERR_NONE) ? file : NULL;
} }
else else

2
src/osd/sdl/sdlmain.c
View File

@ -706,7 +706,7 @@ osd_font sdl_osd_interface::font_open(const char *_name, int &height)
/* handle bdf fonts in the core */ /* handle bdf fonts in the core */
if (name.len() > 4) if (name.len() > 4)
if (name.toupper().substr(name.len()-4,4) == ".BDF" ) if (name.makeupper().substr(name.len()-4,4) == ".BDF" )
return NULL; return NULL;
font_name = CFStringCreateWithCString( NULL, _name, kCFStringEncodingUTF8 ); font_name = CFStringCreateWithCString( NULL, _name, kCFStringEncodingUTF8 );

131
src/tools/regrep.c
View File

@ -180,15 +180,15 @@ static int CLIB_DECL compare_file(const void *file0ptr, const void *file1ptr);
static summary_file *sort_file_list(void); static summary_file *sort_file_list(void);
/* HTML helpers */ /* HTML helpers */
static core_file *create_file_and_output_header(const astring *filename, const astring *templatefile, const astring *title); static core_file *create_file_and_output_header(astring &filename, astring &templatefile, astring &title);
static void output_footer_and_close_file(core_file *file, const astring *templatefile, const astring *title); static void output_footer_and_close_file(core_file *file, astring &templatefile, astring &title);
/* report generators */ /* report generators */
static void output_report(const astring *dirname, const astring *tempheader, const astring *tempfooter, summary_file *filelist); static void output_report(astring &dirname, astring &tempheader, astring &tempfooter, summary_file *filelist);
static int compare_screenshots(summary_file *curfile); static int compare_screenshots(summary_file *curfile);
static int generate_png_diff(const summary_file *curfile, const astring *destdir, const char *destname); static int generate_png_diff(const summary_file *curfile, astring &destdir, const char *destname);
static void create_linked_file(const astring *dirname, const summary_file *curfile, const summary_file *prevfile, const summary_file *nextfile, const char *pngfile, const astring *tempheader, const astring *tempfooter); static void create_linked_file(astring &dirname, const summary_file *curfile, const summary_file *prevfile, const summary_file *nextfile, const char *pngfile, astring &tempheader, astring &tempfooter);
static void append_driver_list_table(const char *header, const astring *dirname, core_file *indexfile, const summary_file *listhead, const astring *tempheader, const astring *tempfooter); static void append_driver_list_table(const char *header, astring &dirname, core_file *indexfile, const summary_file *listhead, astring &tempheader, astring &tempfooter);
@ -250,7 +250,6 @@ INLINE int get_unique_index(const summary_file *curfile, int index)
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
astring *dirname = NULL, *tempfilename = NULL, *tempheader = NULL, *tempfooter = NULL;
UINT32 bufsize; UINT32 bufsize;
void *buffer; void *buffer;
int listnum; int listnum;
@ -262,31 +261,33 @@ int main(int argc, char *argv[])
fprintf(stderr, "Usage:\nregrep <template> <outputdir> <summary1> [<summary2> [<summary3> ...]]\n"); fprintf(stderr, "Usage:\nregrep <template> <outputdir> <summary1> [<summary2> [<summary3> ...]]\n");
return 1; return 1;
} }
tempfilename = astring_dupc(argv[1]); astring tempfilename(argv[1]);
dirname = astring_dupc(argv[2]); astring dirname(argv[2]);
list_count = argc - 3; list_count = argc - 3;
/* read the template file into an astring */ /* read the template file into an astring */
if (core_fload(astring_c(tempfilename), &buffer, &bufsize) == FILERR_NONE) astring tempheader;
if (core_fload(tempfilename, &buffer, &bufsize) == FILERR_NONE)
{ {
tempheader = astring_dupch((const char *)buffer, bufsize); tempheader.cpy((const char *)buffer, bufsize);
osd_free(buffer); osd_free(buffer);
} }
/* verify the template */ /* verify the template */
if (tempheader == NULL) if (tempheader.len() == 0)
{ {
fprintf(stderr, "Unable to read template file\n"); fprintf(stderr, "Unable to read template file\n");
return 1; return 1;
} }
result = astring_findc(tempheader, 0, "<!--CONTENT-->"); result = tempheader.find(0, "<!--CONTENT-->");
if (result == -1) if (result == -1)
{ {
fprintf(stderr, "Template is missing a <!--CONTENT--> marker\n"); fprintf(stderr, "Template is missing a <!--CONTENT--> marker\n");
return 1; return 1;
} }
tempfooter = astring_substr(astring_dup(tempheader), result + 14, -1); astring tempfooter(tempheader);
tempheader = astring_substr(tempheader, 0, result); tempfooter.substr(result + 14);
tempheader.substr(0, result);
/* loop over arguments and read the files */ /* loop over arguments and read the files */
for (listnum = 0; listnum < list_count; listnum++) for (listnum = 0; listnum < list_count; listnum++)
@ -298,11 +299,6 @@ int main(int argc, char *argv[])
/* output the summary */ /* output the summary */
output_report(dirname, tempheader, tempfooter, sort_file_list()); output_report(dirname, tempheader, tempfooter, sort_file_list());
astring_free(dirname);
astring_free(tempfilename);
astring_free(tempheader);
astring_free(tempfooter);
return 0; return 0;
} }
@ -613,22 +609,20 @@ static summary_file *sort_file_list(void)
HTML file with a standard header HTML file with a standard header
-------------------------------------------------*/ -------------------------------------------------*/
static core_file *create_file_and_output_header(const astring *filename, const astring *templatefile, const astring *title) static core_file *create_file_and_output_header(astring &filename, astring &templatefile, astring &title)
{ {
astring *modified;
core_file *file; core_file *file;
/* create the indexfile */ /* create the indexfile */
if (core_fopen(astring_c(filename), OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS | OPEN_FLAG_NO_BOM, &file) != FILERR_NONE) if (core_fopen(filename, OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS | OPEN_FLAG_NO_BOM, &file) != FILERR_NONE)
return NULL; return NULL;
/* print a header */ /* print a header */
modified = astring_dup(templatefile); astring modified(templatefile);
astring_replacec(modified, 0, "<!--TITLE-->", astring_c(title)); modified.replace("<!--TITLE-->", title);
core_fwrite(file, astring_c(modified), astring_len(modified)); core_fwrite(file, modified.cstr(), modified.len());
/* return the file */ /* return the file */
astring_free(modified);
return file; return file;
} }
@ -638,14 +632,11 @@ static core_file *create_file_and_output_header(const astring *filename, const a
standard footer to an HTML file and close it standard footer to an HTML file and close it
-------------------------------------------------*/ -------------------------------------------------*/
static void output_footer_and_close_file(core_file *file, const astring *templatefile, const astring *title) static void output_footer_and_close_file(core_file *file, astring &templatefile, astring &title)
{ {
astring *modified; astring modified(templatefile);
modified.replace(0, "<!--TITLE-->", title);
modified = astring_dup(templatefile); core_fwrite(file, modified.cstr(), modified.len());
astring_replacec(modified, 0, "<!--TITLE-->", astring_c(title));
core_fwrite(file, astring_c(modified), astring_len(modified));
astring_free(modified);
core_fclose(file); core_fclose(file);
} }
@ -660,12 +651,12 @@ static void output_footer_and_close_file(core_file *file, const astring *templat
report HTML files report HTML files
-------------------------------------------------*/ -------------------------------------------------*/
static void output_report(const astring *dirname, const astring *tempheader, const astring *tempfooter, summary_file *filelist) static void output_report(astring &dirname, astring &tempheader, astring &tempfooter, summary_file *filelist)
{ {
summary_file *buckethead[BUCKET_COUNT], **buckettailptr[BUCKET_COUNT]; summary_file *buckethead[BUCKET_COUNT], **buckettailptr[BUCKET_COUNT];
summary_file *curfile; summary_file *curfile;
astring *title = astring_dupc("MAME Regressions"); astring title("MAME Regressions");
astring *tempname = astring_alloc(); astring tempname;
int listnum, bucknum; int listnum, bucknum;
core_file *indexfile; core_file *indexfile;
int count = 0, total; int count = 0, total;
@ -744,13 +735,11 @@ static void output_report(const astring *dirname, const astring *tempheader, con
*buckettailptr[bucknum] = NULL; *buckettailptr[bucknum] = NULL;
/* output header */ /* output header */
astring_printf(tempname, "%s" PATH_SEPARATOR "%s", astring_c(dirname), "index.html"); tempname.printf("%s" PATH_SEPARATOR "%s", dirname.cstr(), "index.html");
indexfile = create_file_and_output_header(tempname, tempheader, title); indexfile = create_file_and_output_header(tempname, tempheader, title);
if (indexfile == NULL) if (indexfile == NULL)
{ {
fprintf(stderr, "Error creating file '%s'\n", astring_c(tempname)); fprintf(stderr, "Error creating file '%s'\n", tempname.cstr());
astring_free(tempname);
astring_free(title);
return; return;
} }
@ -768,8 +757,6 @@ static void output_report(const astring *dirname, const astring *tempheader, con
/* output footer */ /* output footer */
output_footer_and_close_file(indexfile, tempfooter, title); output_footer_and_close_file(indexfile, tempfooter, title);
astring_free(tempname);
astring_free(title);
} }
@ -791,24 +778,24 @@ static int compare_screenshots(summary_file *curfile)
bitmaps[listnum] = NULL; bitmaps[listnum] = NULL;
if (curfile->status[listnum] == STATUS_SUCCESS) if (curfile->status[listnum] == STATUS_SUCCESS)
{ {
astring *fullname = astring_alloc(); astring fullname;
file_error filerr; file_error filerr;
core_file *file; core_file *file;
/* get the filename for the image */ /* get the filename for the image */
astring_printf(fullname, "%s" PATH_SEPARATOR "snap" PATH_SEPARATOR "%s" PATH_SEPARATOR "final.png", lists[listnum].dir, curfile->name); fullname.printf("%s" PATH_SEPARATOR "snap" PATH_SEPARATOR "%s" PATH_SEPARATOR "final.png", lists[listnum].dir, curfile->name);
/* open the file */ /* open the file */
filerr = core_fopen(astring_c(fullname), OPEN_FLAG_READ, &file); filerr = core_fopen(fullname, OPEN_FLAG_READ, &file);
/* if that failed, look in the old location */ /* if that failed, look in the old location */
if (filerr != FILERR_NONE) if (filerr != FILERR_NONE)
{ {
/* get the filename for the image */ /* get the filename for the image */
astring_printf(fullname, "%s" PATH_SEPARATOR "snap" PATH_SEPARATOR "_%s.png", lists[listnum].dir, curfile->name); fullname.printf("%s" PATH_SEPARATOR "snap" PATH_SEPARATOR "_%s.png", lists[listnum].dir, curfile->name);
/* open the file */ /* open the file */
filerr = core_fopen(astring_c(fullname), OPEN_FLAG_READ, &file); filerr = core_fopen(fullname, OPEN_FLAG_READ, &file);
} }
/* if that worked, load the file */ /* if that worked, load the file */
@ -817,7 +804,6 @@ static int compare_screenshots(summary_file *curfile)
png_read_bitmap(file, &bitmaps[listnum]); png_read_bitmap(file, &bitmaps[listnum]);
core_fclose(file); core_fclose(file);
} }
astring_free(fullname);
} }
} }
@ -898,12 +884,12 @@ static int compare_screenshots(summary_file *curfile)
side with a third set of differences side with a third set of differences
-------------------------------------------------*/ -------------------------------------------------*/
static int generate_png_diff(const summary_file *curfile, const astring *destdir, const char *destname) static int generate_png_diff(const summary_file *curfile, astring &destdir, const char *destname)
{ {
bitmap_t *bitmaps[MAX_COMPARES] = { NULL }; bitmap_t *bitmaps[MAX_COMPARES] = { NULL };
astring *srcimgname = astring_alloc(); astring srcimgname;
astring *dstfilename = astring_alloc(); astring dstfilename;
astring *tempname = astring_alloc(); astring tempname;
bitmap_t *finalbitmap = NULL; bitmap_t *finalbitmap = NULL;
int width, height, maxwidth; int width, height, maxwidth;
int bitmapcount = 0; int bitmapcount = 0;
@ -915,17 +901,17 @@ static int generate_png_diff(const summary_file *curfile, const astring *destdir
int starty; int starty;
/* generate the common source filename */ /* generate the common source filename */
astring_printf(dstfilename, "%s" PATH_SEPARATOR "%s", astring_c(destdir), destname); dstfilename.printf("%s" PATH_SEPARATOR "%s", destdir.cstr(), destname);
astring_printf(srcimgname, "snap" PATH_SEPARATOR "%s" PATH_SEPARATOR "final.png", curfile->name); srcimgname.printf("snap" PATH_SEPARATOR "%s" PATH_SEPARATOR "final.png", curfile->name);
/* open and load all unique bitmaps */ /* open and load all unique bitmaps */
for (listnum = 0; listnum < list_count; listnum++) for (listnum = 0; listnum < list_count; listnum++)
if (curfile->matchbitmap[listnum] == listnum) if (curfile->matchbitmap[listnum] == listnum)
{ {
astring_printf(tempname, "%s" PATH_SEPARATOR "%s", lists[listnum].dir, astring_c(srcimgname)); tempname.printf("%s" PATH_SEPARATOR "%s", lists[listnum].dir, srcimgname.cstr());
/* open the source image */ /* open the source image */
filerr = core_fopen(astring_c(tempname), OPEN_FLAG_READ, &file); filerr = core_fopen(tempname, OPEN_FLAG_READ, &file);
if (filerr != FILERR_NONE) if (filerr != FILERR_NONE)
goto error; goto error;
@ -999,7 +985,7 @@ static int generate_png_diff(const summary_file *curfile, const astring *destdir
} }
/* write the final PNG */ /* write the final PNG */
filerr = core_fopen(astring_c(dstfilename), OPEN_FLAG_WRITE | OPEN_FLAG_CREATE, &file); filerr = core_fopen(dstfilename, OPEN_FLAG_WRITE | OPEN_FLAG_CREATE, &file);
if (filerr != FILERR_NONE) if (filerr != FILERR_NONE)
goto error; goto error;
pngerr = png_write_bitmap(file, NULL, *finalbitmap, 0, NULL); pngerr = png_write_bitmap(file, NULL, *finalbitmap, 0, NULL);
@ -1015,10 +1001,7 @@ error:
for (bmnum = 0; bmnum < bitmapcount; bmnum++) for (bmnum = 0; bmnum < bitmapcount; bmnum++)
delete bitmaps[bmnum]; delete bitmaps[bmnum];
if (error) if (error)
osd_rmfile(astring_c(dstfilename)); osd_rmfile(dstfilename);
astring_free(dstfilename);
astring_free(srcimgname);
astring_free(tempname);
return error; return error;
} }
@ -1028,27 +1011,24 @@ error:
file between differing versions file between differing versions
-------------------------------------------------*/ -------------------------------------------------*/
static void create_linked_file(const astring *dirname, const summary_file *curfile, const summary_file *prevfile, const summary_file *nextfile, const char *pngfile, const astring *tempheader, const astring *tempfooter) static void create_linked_file(astring &dirname, const summary_file *curfile, const summary_file *prevfile, const summary_file *nextfile, const char *pngfile, astring &tempheader, astring &tempfooter)
{ {
astring *linkname = astring_alloc(); astring linkname;
astring *filename = astring_alloc(); astring filename;
astring *title = astring_alloc(); astring title;
core_file *linkfile; core_file *linkfile;
int listnum; int listnum;
/* create the filename */ /* create the filename */
astring_printf(filename, "%s.html", curfile->name); filename.printf("%s.html", curfile->name);
/* output header */ /* output header */
astring_printf(title, "%s Regressions (%s)", curfile->name, curfile->source); title.printf("%s Regressions (%s)", curfile->name, curfile->source);
astring_printf(linkname, "%s" PATH_SEPARATOR "%s", astring_c(dirname), astring_c(filename)); linkname.printf("%s" PATH_SEPARATOR "%s", dirname.cstr(), filename.cstr());
linkfile = create_file_and_output_header(linkname, tempheader, title); linkfile = create_file_and_output_header(linkname, tempheader, title);
if (linkfile == NULL) if (linkfile == NULL)
{ {
fprintf(stderr, "Error creating file '%s'\n", astring_c(filename)); fprintf(stderr, "Error creating file '%s'\n", filename.cstr());
astring_free(title);
astring_free(filename);
astring_free(linkname);
return; return;
} }
@ -1101,9 +1081,6 @@ static void create_linked_file(const astring *dirname, const summary_file *curfi
/* output footer */ /* output footer */
output_footer_and_close_file(linkfile, tempfooter, title); output_footer_and_close_file(linkfile, tempfooter, title);
astring_free(title);
astring_free(filename);
astring_free(linkname);
} }
@ -1112,7 +1089,7 @@ static void create_linked_file(const astring *dirname, const summary_file *curfi
of drivers from a list to an HTML file of drivers from a list to an HTML file
-------------------------------------------------*/ -------------------------------------------------*/
static void append_driver_list_table(const char *header, const astring *dirname, core_file *indexfile, const summary_file *listhead, const astring *tempheader, const astring *tempfooter) static void append_driver_list_table(const char *header, astring &dirname, core_file *indexfile, const summary_file *listhead, astring &tempheader, astring &tempfooter)
{ {
const summary_file *curfile, *prevfile; const summary_file *curfile, *prevfile;
int width = 100 / (2 + list_count); int width = 100 / (2 + list_count);

98
src/tools/split.c
View File

@ -61,7 +61,7 @@
hash over a buffer and return a string hash over a buffer and return a string
-------------------------------------------------*/ -------------------------------------------------*/
static void compute_hash_as_string(astring *buffer, void *data, UINT32 length) static void compute_hash_as_string(astring &buffer, void *data, UINT32 length)
{ {
char expanded[SHA1_DIGEST_SIZE * 2]; char expanded[SHA1_DIGEST_SIZE * 2];
UINT8 sha1digest[SHA1_DIGEST_SIZE]; UINT8 sha1digest[SHA1_DIGEST_SIZE];
@ -82,7 +82,7 @@ static void compute_hash_as_string(astring *buffer, void *data, UINT32 length)
} }
// copy it to the buffer // copy it to the buffer
astring_cpych(buffer, expanded, sizeof(expanded)); buffer.cpy(expanded, sizeof(expanded));
} }
@ -92,9 +92,9 @@ static void compute_hash_as_string(astring *buffer, void *data, UINT32 length)
static int split_file(const char *filename, const char *basename, UINT32 splitsize) static int split_file(const char *filename, const char *basename, UINT32 splitsize)
{ {
astring *outfilename = astring_alloc(), *basefilename = astring_alloc(), *splitfilename = astring_alloc(); astring outfilename, basefilename, splitfilename;
core_file *outfile = NULL, *infile = NULL, *splitfile = NULL; core_file *outfile = NULL, *infile = NULL, *splitfile = NULL;
astring *computedhash = astring_alloc(); astring computedhash;
void *splitbuffer = NULL; void *splitbuffer = NULL;
int index, partnum; int index, partnum;
UINT64 totallength; UINT64 totallength;
@ -139,29 +139,28 @@ static int split_file(const char *filename, const char *basename, UINT32 splitsi
} }
// find the base name of the file // find the base name of the file
astring_cpyc(basefilename, basename); basefilename.cpy(basename);
index = astring_rchr(basefilename, 0, PATH_SEPARATOR[0]); index = basefilename.rchr(0, PATH_SEPARATOR[0]);
if (index != -1) if (index != -1)
astring_del(basefilename, 0, index + 1); basefilename.del(0, index + 1);
// compute the split filename // compute the split filename
astring_cpyc(splitfilename, basename); splitfilename.cpy(basename).cat(".split");
astring_catc(splitfilename, ".split");
// create the split file // create the split file
filerr = core_fopen(astring_c(splitfilename), OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_NO_BOM, &splitfile); filerr = core_fopen(splitfilename, OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_NO_BOM, &splitfile);
if (filerr != FILERR_NONE) if (filerr != FILERR_NONE)
{ {
fprintf(stderr, "Fatal error: unable to create split file '%s'\n", astring_c(splitfilename)); fprintf(stderr, "Fatal error: unable to create split file '%s'\n", splitfilename.cstr());
goto cleanup; goto cleanup;
} }
// write the basics out // write the basics out
core_fprintf(splitfile, "splitfile=%s\n", astring_c(basefilename)); core_fprintf(splitfile, "splitfile=%s\n", basefilename.cstr());
core_fprintf(splitfile, "splitsize=%d\n", splitsize); core_fprintf(splitfile, "splitsize=%d\n", splitsize);
printf("Split file is '%s'\n", astring_c(splitfilename)); printf("Split file is '%s'\n", splitfilename.cstr());
printf("Splitting file %s into chunks of %dMB...\n", astring_c(basefilename), splitsize / (1024 * 1024)); printf("Splitting file %s into chunks of %dMB...\n", basefilename.cstr(), splitsize / (1024 * 1024));
// now iterate until done // now iterate until done
for (partnum = 0; partnum < 1000; partnum++) for (partnum = 0; partnum < 1000; partnum++)
@ -179,21 +178,21 @@ static int split_file(const char *filename, const char *basename, UINT32 splitsi
compute_hash_as_string(computedhash, splitbuffer, length); compute_hash_as_string(computedhash, splitbuffer, length);
// write that info to the split file // write that info to the split file
core_fprintf(splitfile, "hash=%s file=%s.%03d\n", astring_c(computedhash), astring_c(basefilename), partnum); core_fprintf(splitfile, "hash=%s file=%s.%03d\n", computedhash.cstr(), basefilename.cstr(), partnum);
// compute the full filename for this guy // compute the full filename for this guy
astring_printf(outfilename, "%s.%03d", basename, partnum); outfilename.printf("%s.%03d", basename, partnum);
// create it // create it
filerr = core_fopen(astring_c(outfilename), OPEN_FLAG_WRITE | OPEN_FLAG_CREATE, &outfile); filerr = core_fopen(outfilename, OPEN_FLAG_WRITE | OPEN_FLAG_CREATE, &outfile);
if (filerr != FILERR_NONE) if (filerr != FILERR_NONE)
{ {
printf("\n"); printf("\n");
fprintf(stderr, "Fatal error: unable to create output file '%s'\n", astring_c(outfilename)); fprintf(stderr, "Fatal error: unable to create output file '%s'\n", outfilename.cstr());
goto cleanup; goto cleanup;
} }
printf(" writing %s.%03d...", astring_c(basefilename), partnum); printf(" writing %s.%03d...", basefilename.cstr(), partnum);
// write the data // write the data
actual = core_fwrite(outfile, splitbuffer, length); actual = core_fwrite(outfile, splitbuffer, length);
@ -222,7 +221,7 @@ cleanup:
{ {
core_fclose(splitfile); core_fclose(splitfile);
if (error != 0) if (error != 0)
remove(astring_c(splitfilename)); remove(splitfilename);
} }
if (infile != NULL) if (infile != NULL)
core_fclose(infile); core_fclose(infile);
@ -230,14 +229,10 @@ cleanup:
{ {
core_fclose(outfile); core_fclose(outfile);
if (error != 0) if (error != 0)
remove(astring_c(outfilename)); remove(outfilename);
} }
if (splitbuffer != NULL) if (splitbuffer != NULL)
free(splitbuffer); free(splitbuffer);
astring_free(splitfilename);
astring_free(basefilename);
astring_free(outfilename);
astring_free(computedhash);
return error; return error;
} }
@ -249,9 +244,9 @@ cleanup:
static int join_file(const char *filename, const char *outname, int write_output) static int join_file(const char *filename, const char *outname, int write_output)
{ {
astring *expectedhash = astring_alloc(), *computedhash = astring_alloc(); astring expectedhash, computedhash;
astring *outfilename = astring_alloc(), *infilename = astring_alloc(); astring outfilename, infilename;
astring *basepath = astring_alloc(); astring basepath;
core_file *outfile = NULL, *infile = NULL, *splitfile = NULL; core_file *outfile = NULL, *infile = NULL, *splitfile = NULL;
void *splitbuffer = NULL; void *splitbuffer = NULL;
file_error filerr; file_error filerr;
@ -274,21 +269,21 @@ static int join_file(const char *filename, const char *outname, int write_output
fprintf(stderr, "Fatal error: corrupt or incomplete split file at line:\n%s\n", buffer); fprintf(stderr, "Fatal error: corrupt or incomplete split file at line:\n%s\n", buffer);
goto cleanup; goto cleanup;
} }
astring_trimspace(astring_cpyc(outfilename, buffer + 10)); outfilename.cpy(buffer + 10).trimspace();
// compute the base path // compute the base path
astring_cpyc(basepath, filename); basepath.cpy(filename);
index = astring_rchr(basepath, 0, PATH_SEPARATOR[0]); index = basepath.rchr(0, PATH_SEPARATOR[0]);
if (index != -1) if (index != -1)
astring_del(basepath, index + 1, -1); basepath.del(index + 1);
else else
astring_reset(basepath); basepath.reset();
// override the output filename if specified, otherwise prepend the path // override the output filename if specified, otherwise prepend the path
if (outname != NULL) if (outname != NULL)
astring_cpyc(outfilename, outname); outfilename.cpy(outname);
else else
astring_ins(outfilename, 0, basepath); outfilename.ins(0, basepath);
// read the split size // read the split size
if (!core_fgets(buffer, sizeof(buffer), splitfile) || sscanf(buffer, "splitsize=%d", &splitsize) != 1) if (!core_fgets(buffer, sizeof(buffer), splitfile) || sscanf(buffer, "splitsize=%d", &splitsize) != 1)
@ -301,25 +296,25 @@ static int join_file(const char *filename, const char *outname, int write_output
if (write_output) if (write_output)
{ {
// don't overwrite the original! // don't overwrite the original!
filerr = core_fopen(astring_c(outfilename), OPEN_FLAG_READ, &outfile); filerr = core_fopen(outfilename, OPEN_FLAG_READ, &outfile);
if (filerr == FILERR_NONE) if (filerr == FILERR_NONE)
{ {
core_fclose(outfile); core_fclose(outfile);
outfile = NULL; outfile = NULL;
fprintf(stderr, "Fatal error: output file '%s' already exists\n", astring_c(outfilename)); fprintf(stderr, "Fatal error: output file '%s' already exists\n", outfilename.cstr());
goto cleanup; goto cleanup;
} }
// open the output for write // open the output for write
filerr = core_fopen(astring_c(outfilename), OPEN_FLAG_WRITE | OPEN_FLAG_CREATE, &outfile); filerr = core_fopen(outfilename, OPEN_FLAG_WRITE | OPEN_FLAG_CREATE, &outfile);
if (filerr != FILERR_NONE) if (filerr != FILERR_NONE)
{ {
fprintf(stderr, "Fatal error: unable to create file '%s'\n", astring_c(outfilename)); fprintf(stderr, "Fatal error: unable to create file '%s'\n", outfilename.cstr());
goto cleanup; goto cleanup;
} }
} }
printf("%s file '%s'...\n", write_output ? "Joining" : "Verifying", astring_c(outfilename)); printf("%s file '%s'...\n", write_output ? "Joining" : "Verifying", outfilename.cstr());
// now iterate through each file // now iterate through each file
while (core_fgets(buffer, sizeof(buffer), splitfile)) while (core_fgets(buffer, sizeof(buffer), splitfile))
@ -332,18 +327,18 @@ static int join_file(const char *filename, const char *outname, int write_output
fprintf(stderr, "Fatal error: corrupt or incomplete split file at line:\n%s\n", buffer); fprintf(stderr, "Fatal error: corrupt or incomplete split file at line:\n%s\n", buffer);
goto cleanup; goto cleanup;
} }
astring_cpych(expectedhash, buffer + 5, SHA1_DIGEST_SIZE * 2); expectedhash.cpy(buffer + 5, SHA1_DIGEST_SIZE * 2);
astring_trimspace(astring_cpyc(infilename, buffer + 5 + SHA1_DIGEST_SIZE * 2 + 6)); infilename.cpy(buffer + 5 + SHA1_DIGEST_SIZE * 2 + 6).trimspace();
printf(" Reading file '%s'...", astring_c(infilename)); printf(" Reading file '%s'...", infilename.cstr());
// read the file's contents // read the file's contents
astring_ins(infilename, 0, basepath); infilename.ins(0, basepath);
filerr = core_fload(astring_c(infilename), &splitbuffer, &length); filerr = core_fload(infilename, &splitbuffer, &length);
if (filerr != FILERR_NONE) if (filerr != FILERR_NONE)
{ {
printf("\n"); printf("\n");
fprintf(stderr, "Fatal error: unable to load file '%s'\n", astring_c(infilename)); fprintf(stderr, "Fatal error: unable to load file '%s'\n", infilename.cstr());
goto cleanup; goto cleanup;
} }
@ -351,10 +346,10 @@ static int join_file(const char *filename, const char *outname, int write_output
compute_hash_as_string(computedhash, splitbuffer, length); compute_hash_as_string(computedhash, splitbuffer, length);
// compare // compare
if (astring_cmp(computedhash, expectedhash) != 0) if (computedhash != expectedhash)
{ {
printf("\n"); printf("\n");
fprintf(stderr, "Fatal error: file '%s' has incorrect hash\n Expected: %s\n Computed: %s\n", astring_c(infilename), astring_c(expectedhash), astring_c(computedhash)); fprintf(stderr, "Fatal error: file '%s' has incorrect hash\n Expected: %s\n Computed: %s\n", infilename.cstr(), expectedhash.cstr(), computedhash.cstr());
goto cleanup; goto cleanup;
} }
@ -397,15 +392,10 @@ cleanup:
{ {
core_fclose(outfile); core_fclose(outfile);
if (error != 0) if (error != 0)
remove(astring_c(outfilename)); remove(outfilename);
} }
if (splitbuffer != NULL) if (splitbuffer != NULL)
osd_free(splitbuffer); osd_free(splitbuffer);
astring_free(outfilename);
astring_free(infilename);
astring_free(basepath);
astring_free(expectedhash);
astring_free(computedhash);
return error; return error;
} }

617
src/tools/src2html.c
View File

File diff suppressed because it is too large Load Diff