summaryrefslogtreecommitdiffstatshomepage
path: root/src/lib/util/zippath.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/lib/util/zippath.cpp')
-rw-r--r--src/lib/util/zippath.cpp436
1 files changed, 191 insertions, 245 deletions
diff --git a/src/lib/util/zippath.cpp b/src/lib/util/zippath.cpp
index efe7c710481..edeecf80c47 100644
--- a/src/lib/util/zippath.cpp
+++ b/src/lib/util/zippath.cpp
@@ -8,15 +8,19 @@
***************************************************************************/
-#include <ctype.h>
-#include <stdlib.h>
-#include <new>
-#include <assert.h>
#include "zippath.h"
#include "unzip.h"
#include "corestr.h"
#include "osdcore.h"
+#include <stdlib.h>
+
+#include <cassert>
+#include <cctype>
+#include <new>
+
+
+namespace util {
/***************************************************************************
TYPE DEFINITIONS
@@ -66,7 +70,7 @@ public:
/** @brief true to called zip first. */
bool called_zip_first;
/** @brief The zipfile. */
- zip_file *zipfile;
+ archive_file::ptr zipfile;
/** @brief The zipprefix. */
std::string zipprefix;
/** @brief The returned dirlist. */
@@ -78,10 +82,10 @@ public:
FUNCTION PROTOTYPES
***************************************************************************/
-static const zip_file_header *zippath_find_sub_path(zip_file *zipfile, const char *subpath, osd_dir_entry_type *type);
-static int is_zip_file(const char *path);
-static int is_zip_file_separator(char c);
-static int is_7z_file(const char *path);
+static int zippath_find_sub_path(archive_file &zipfile, std::string const &subpath, osd_dir_entry_type &type);
+static bool is_zip_file(std::string const &path);
+static bool is_zip_file_separator(char c);
+static bool is_7z_file(std::string const &path);
/***************************************************************************
@@ -148,29 +152,15 @@ static void parse_parent_path(const char *path, int *beginpos, int *endpos)
zippath_parent - retrieves the parent directory
-------------------------------------------------*/
-/**
- * @fn std::string &zippath_parent(std::string &dst, const char *path)
- *
- * @brief Zippath parent.
- *
- * @param [in,out] dst Destination for the.
- * @param path Full pathname of the file.
- *
- * @return A std::string&amp;
- */
-
std::string &zippath_parent(std::string &dst, const char *path)
{
int pos;
parse_parent_path(path, &pos, nullptr);
- /* return the result */
- if (pos >= 0) {
+ if (pos >= 0)
dst.assign(path, pos + 1);
- }
- else {
+ else
dst.clear();
- }
return dst;
}
@@ -251,42 +241,42 @@ std::string &zippath_combine(std::string &dst, const char *path1, const char *pa
/*-------------------------------------------------
file_error_from_zip_error - translates a
- file_error to a zip_error
+ osd_file::error to a zip_error
-------------------------------------------------*/
/**
- * @fn static file_error file_error_from_zip_error(zip_error ziperr)
+ * @fn static osd_file::error file_error_from_zip_error(archive_file::error ziperr)
*
* @brief File error from zip error.
*
* @param ziperr The ziperr.
*
- * @return A file_error.
+ * @return A osd_file::error.
*/
-static file_error file_error_from_zip_error(zip_error ziperr)
+static osd_file::error file_error_from_zip_error(archive_file::error ziperr)
{
- file_error filerr;
+ osd_file::error filerr;
switch(ziperr)
{
- case ZIPERR_NONE:
- filerr = FILERR_NONE;
- break;
- case ZIPERR_OUT_OF_MEMORY:
- filerr = FILERR_OUT_OF_MEMORY;
- break;
- case ZIPERR_BAD_SIGNATURE:
- case ZIPERR_DECOMPRESS_ERROR:
- case ZIPERR_FILE_TRUNCATED:
- case ZIPERR_FILE_CORRUPT:
- case ZIPERR_UNSUPPORTED:
- case ZIPERR_FILE_ERROR:
- filerr = FILERR_INVALID_DATA;
- break;
- case ZIPERR_BUFFER_TOO_SMALL:
- default:
- filerr = FILERR_FAILURE;
- break;
+ case archive_file::error::NONE:
+ filerr = osd_file::error::NONE;
+ break;
+ case archive_file::error::OUT_OF_MEMORY:
+ filerr = osd_file::error::OUT_OF_MEMORY;
+ break;
+ case archive_file::error::BAD_SIGNATURE:
+ case archive_file::error::DECOMPRESS_ERROR:
+ case archive_file::error::FILE_TRUNCATED:
+ case archive_file::error::FILE_CORRUPT:
+ case archive_file::error::UNSUPPORTED:
+ case archive_file::error::FILE_ERROR:
+ filerr = osd_file::error::INVALID_DATA;
+ break;
+ case archive_file::error::BUFFER_TOO_SMALL:
+ default:
+ filerr = osd_file::error::FAILURE;
+ break;
}
return filerr;
}
@@ -298,7 +288,7 @@ static file_error file_error_from_zip_error(zip_error ziperr)
-------------------------------------------------*/
/**
- * @fn static file_error create_core_file_from_zip(zip_file *zip, const zip_file_header *header, util::core_file::ptr &file)
+ * @fn static osd_file::error create_core_file_from_zip(archive_file *zip, util::core_file::ptr &file)
*
* @brief Creates core file from zip.
*
@@ -309,28 +299,28 @@ static file_error file_error_from_zip_error(zip_error ziperr)
* @return The new core file from zip.
*/
-static file_error create_core_file_from_zip(zip_file *zip, const zip_file_header *header, util::core_file::ptr &file)
+static osd_file::error create_core_file_from_zip(archive_file &zip, util::core_file::ptr &file)
{
- file_error filerr;
- zip_error ziperr;
+ osd_file::error filerr;
+ archive_file::error ziperr;
void *ptr;
- ptr = malloc(header->uncompressed_length);
+ ptr = malloc(zip.current_uncompressed_length());
if (ptr == nullptr)
{
- filerr = FILERR_OUT_OF_MEMORY;
+ filerr = osd_file::error::OUT_OF_MEMORY;
goto done;
}
- ziperr = zip_file_decompress(zip, ptr, header->uncompressed_length);
- if (ziperr != ZIPERR_NONE)
+ ziperr = zip.decompress(ptr, zip.current_uncompressed_length());
+ if (ziperr != archive_file::error::NONE)
{
filerr = file_error_from_zip_error(ziperr);
goto done;
}
- filerr = util::core_file::open_ram_copy(ptr, header->uncompressed_length, OPEN_FLAG_READ, file);
- if (filerr != FILERR_NONE)
+ filerr = util::core_file::open_ram_copy(ptr, zip.current_uncompressed_length(), OPEN_FLAG_READ, file);
+ if (filerr != osd_file::error::NONE)
goto done;
done:
@@ -345,7 +335,7 @@ done:
-------------------------------------------------*/
/**
- * @fn file_error zippath_fopen(const char *filename, UINT32 openflags, util::core_file::ptr &file, std::string &revised_path)
+ * @fn osd_file::error zippath_fopen(const char *filename, UINT32 openflags, util::core_file::ptr &file, std::string &revised_path)
*
* @brief Zippath fopen.
*
@@ -354,17 +344,16 @@ done:
* @param [in,out] file [in,out] If non-null, the file.
* @param [in,out] revised_path Full pathname of the revised file.
*
- * @return A file_error.
+ * @return A osd_file::error.
*/
-file_error zippath_fopen(const char *filename, UINT32 openflags, util::core_file::ptr &file, std::string &revised_path)
+osd_file::error zippath_fopen(const char *filename, UINT32 openflags, util::core_file::ptr &file, std::string &revised_path)
{
- file_error filerr = FILERR_NOT_FOUND;
- zip_error ziperr;
- zip_file *zip = nullptr;
- const zip_file_header *header;
+ osd_file::error filerr = osd_file::error::NOT_FOUND;
+ archive_file::error ziperr;
+ archive_file::ptr zip;
+ int header;
osd_dir_entry_type entry_type;
- char *alloc_fullpath = nullptr;
int len;
/* first, set up the two types of paths */
@@ -377,56 +366,51 @@ file_error zippath_fopen(const char *filename, UINT32 openflags, util::core_file
&& ((openflags == OPEN_FLAG_READ) || (subpath.length() == 0)))
{
/* is the mainpath a ZIP path? */
- if (is_zip_file(mainpath.c_str()))
+ if (is_zip_file(mainpath) || is_7z_file(mainpath))
{
/* this file might be a zip file - lets take a look */
- ziperr = zip_file_open(mainpath.c_str(), &zip);
- if (ziperr == ZIPERR_NONE)
+ ziperr = is_zip_file(mainpath) ? archive_file::open_zip(mainpath, zip) : archive_file::open_7z(mainpath, zip);
+ if (ziperr == archive_file::error::NONE)
{
/* it is a zip file - error if we're not opening for reading */
if (openflags != OPEN_FLAG_READ)
{
- filerr = FILERR_ACCESS_DENIED;
+ filerr = osd_file::error::ACCESS_DENIED;
goto done;
}
if (subpath.length() > 0)
- header = zippath_find_sub_path(zip, subpath.c_str(), &entry_type);
+ header = zippath_find_sub_path(*zip, subpath, entry_type);
else
- header = zip_file_first_file(zip);
+ header = zip->first_file();
- if (header == nullptr)
+ if (header < 0)
{
- filerr = FILERR_NOT_FOUND;
+ filerr = osd_file::error::NOT_FOUND;
goto done;
}
/* attempt to read the file */
- filerr = create_core_file_from_zip(zip, header, file);
- if (filerr != FILERR_NONE)
+ filerr = create_core_file_from_zip(*zip, file);
+ if (filerr != osd_file::error::NONE)
goto done;
/* update subpath, if appropriate */
if (subpath.length() == 0)
- subpath.assign(header->filename);
+ subpath.assign(zip->current_name());
/* we're done */
goto done;
}
}
- else if (is_7z_file(mainpath.c_str()))
- {
- filerr = FILERR_INVALID_DATA;
- goto done;
- }
if (subpath.length() == 0)
filerr = util::core_file::open(filename, openflags, file);
else
- filerr = FILERR_NOT_FOUND;
+ filerr = osd_file::error::NOT_FOUND;
/* if we errored, then go up a directory */
- if (filerr != FILERR_NONE)
+ if (filerr != osd_file::error::NONE)
{
/* go up a directory */
std::string temp;
@@ -457,23 +441,19 @@ file_error zippath_fopen(const char *filename, UINT32 openflags, util::core_file
done:
/* store the revised path */
revised_path.clear();
- if (filerr == FILERR_NONE)
+ if (filerr == osd_file::error::NONE)
{
/* cannonicalize mainpath */
- filerr = osd_get_full_path(&alloc_fullpath, mainpath.c_str());
- if (filerr == FILERR_NONE)
+ std::string alloc_fullpath;
+ filerr = osd_get_full_path(alloc_fullpath, mainpath);
+ if (filerr == osd_file::error::NONE)
{
+ revised_path = alloc_fullpath;
if (subpath.length() > 0)
- revised_path.assign(alloc_fullpath).append(PATH_SEPARATOR).append(subpath);
- else
- revised_path.assign(alloc_fullpath);
+ revised_path.append(PATH_SEPARATOR).append(subpath);
}
}
- if (zip != nullptr)
- zip_file_close(zip);
- if (alloc_fullpath != nullptr)
- osd_free(alloc_fullpath);
return filerr;
}
@@ -528,10 +508,10 @@ static int is_root(const char *path)
* @return An int.
*/
-static int is_7z_file(const char *path)
+static bool is_7z_file(std::string const &path)
{
- const char *s = strrchr(path, '.');
- return (s != nullptr) && !core_stricmp(s, ".7z");
+ auto const s = path.rfind('.');
+ return (std::string::npos != s) && !core_stricmp(path.c_str() + s, ".7z");
}
@@ -540,20 +520,10 @@ static int is_7z_file(const char *path)
ZIP file
-------------------------------------------------*/
-/**
- * @fn static int is_zip_file(const char *path)
- *
- * @brief Is zip file.
- *
- * @param path Full pathname of the file.
- *
- * @return An int.
- */
-
-static int is_zip_file(const char *path)
+static bool is_zip_file(std::string const &path)
{
- const char *s = strrchr(path, '.');
- return (s != nullptr) && !core_stricmp(s, ".zip");
+ auto const s = path.rfind('.');
+ return (std::string::npos != s) && !core_stricmp(path.c_str() + s, ".zip");
}
@@ -573,7 +543,7 @@ static int is_zip_file(const char *path)
* @return An int.
*/
-static int is_zip_file_separator(char c)
+static bool is_zip_file_separator(char c)
{
return (c == '/') || (c == '\\');
}
@@ -595,7 +565,7 @@ static int is_zip_file_separator(char c)
* @return An int.
*/
-static int is_zip_path_separator(char c)
+static bool is_zip_path_separator(char c)
{
return is_zip_file_separator(c) || is_path_separator(c);
}
@@ -618,38 +588,35 @@ static int is_zip_path_separator(char c)
* @return A char.
*/
-static char next_path_char(const char *s, int *pos)
+static char next_path_char(std::string const &s, std::string::size_type &pos)
{
- char result;
-
- /* skip over any initial separators */
- if (*pos == 0)
+ // skip over any initial separators
+ if (pos == 0)
{
- while(is_zip_file_separator(s[*pos]))
- (*pos)++;
+ while ((pos < s.length()) && is_zip_file_separator(s[pos]))
+ pos++;
}
- /* are we at a path separator? */
- if (is_zip_file_separator(s[*pos]))
+ // are we at a path separator?
+ if (pos == s.length())
{
- /* skip over path separators */
- while(is_zip_file_separator(s[*pos]))
- (*pos)++;
-
- /* normalize as '/' */
- result = '/';
+ // return NUL
+ return '\0';
}
- else if (s[*pos] != '\0')
+ else if (is_zip_file_separator(s[pos]))
{
- /* return character */
- result = tolower(s[(*pos)++]);
+ // skip over path separators
+ while((pos < s.length()) && is_zip_file_separator(s[pos]))
+ pos++;
+
+ // normalize as '/'
+ return '/';
}
else
{
- /* return NUL */
- result = '\0';
+ // return character
+ return std::tolower(s[pos++]);
}
- return result;
}
@@ -661,7 +628,7 @@ static char next_path_char(const char *s, int *pos)
-------------------------------------------------*/
/**
- * @fn static const zip_file_header *zippath_find_sub_path(zip_file *zipfile, const char *subpath, osd_dir_entry_type *type)
+ * @fn static const zip_file_header *zippath_find_sub_path(archive_file *zipfile, const char *subpath, osd_dir_entry_type *type)
*
* @brief Zippath find sub path.
*
@@ -672,50 +639,36 @@ static char next_path_char(const char *s, int *pos)
* @return null if it fails, else a zip_file_header*.
*/
-static const zip_file_header *zippath_find_sub_path(zip_file *zipfile, const char *subpath, osd_dir_entry_type *type)
+static int zippath_find_sub_path(archive_file &zipfile, std::string const &subpath, osd_dir_entry_type &type)
{
- int i, j;
- char c1, c2, last_char;
- const zip_file_header *header;
-
- for (header = zip_file_first_file(zipfile); header != nullptr; header = zip_file_next_file(zipfile))
+ for (int header = zipfile.first_file(); header >= 0; header = zipfile.next_file())
{
- /* special case */
- if (subpath == nullptr)
+ std::string::size_type i = 0, j = 0;
+ char c1, c2;
+ do
{
- if (type != nullptr)
- *type = ENTTYPE_FILE;
- return header;
+ c1 = next_path_char(zipfile.current_name(), i);
+ c2 = next_path_char(subpath, j);
}
+ while ((c1 == c2) && c1 && c2);
- i = 0;
- j = 0;
- last_char = '/';
- while(((c1 = next_path_char(header->filename, &i)) == (c2 = next_path_char(subpath, &j))) &&
- ( c1 != '\0' && c2 != '\0' ))
- last_char = c2;
-
-
- if (c2 == '\0')
+ if (!c2 || ((c2 == '/') && !(c2 = next_path_char(subpath, j))))
{
- if (c1 == '\0')
+ if (!c1)
{
- if (type != nullptr)
- *type = ENTTYPE_FILE;
+ type = zipfile.current_is_directory() ? ENTTYPE_DIR : ENTTYPE_FILE;
return header;
}
- else if ((last_char == '/') || (c1 == '/'))
+ else if ((c1 == '/') || (i <= 1U))
{
- if (type != nullptr)
- *type = ENTTYPE_DIR;
+ type = ENTTYPE_DIR;
return header;
}
}
}
- if (type != nullptr)
- *type = ENTTYPE_NONE;
- return nullptr;
+ type = ENTTYPE_NONE;
+ return -1;
}
@@ -726,7 +679,7 @@ static const zip_file_header *zippath_find_sub_path(zip_file *zipfile, const cha
-------------------------------------------------*/
/**
- * @fn static file_error zippath_resolve(const char *path, osd_dir_entry_type &entry_type, zip_file *&zipfile, std::string &newpath)
+ * @fn static osd_file::error zippath_resolve(const char *path, osd_dir_entry_type &entry_type, archive_file *&zipfile, std::string &newpath)
*
* @brief Zippath resolve.
*
@@ -735,97 +688,81 @@ static const zip_file_header *zippath_find_sub_path(zip_file *zipfile, const cha
* @param [in,out] zipfile [in,out] If non-null, the zipfile.
* @param [in,out] newpath The newpath.
*
- * @return A file_error.
+ * @return A osd_file::error.
*/
-static file_error zippath_resolve(const char *path, osd_dir_entry_type &entry_type, zip_file *&zipfile, std::string &newpath)
+static osd_file::error zippath_resolve(const char *path, osd_dir_entry_type &entry_type, archive_file::ptr &zipfile, std::string &newpath)
{
- file_error err;
- osd_directory_entry *current_entry = nullptr;
- osd_dir_entry_type current_entry_type;
- int went_up = FALSE;
- int i;
-
newpath.clear();
- /* be conservative */
+ // be conservative
entry_type = ENTTYPE_NONE;
- zipfile = nullptr;
+ zipfile.reset();
std::string apath(path);
std::string apath_trimmed;
+ osd_dir_entry_type current_entry_type;
+ bool went_up = false;
do
{
- /* trim the path of trailing path separators */
- i = apath.length();
- while (i > 1 && is_path_separator(apath[i - 1]))
+ // trim the path of trailing path separators
+ auto i = apath.length();
+ while ((i > 1) && is_path_separator(apath[i - 1]))
i--;
- apath = apath.substr(0, i);
- apath_trimmed.assign(apath);
+ apath.resize(i);
+ apath_trimmed = apath;
- /* stat the path */
- current_entry = osd_stat(apath_trimmed.c_str());
+ // stat the path
+ std::unique_ptr<osd_directory_entry, void (*)(void *)> current_entry(osd_stat(apath_trimmed), &osd_free);
- /* did we find anything? */
- if (current_entry != nullptr)
+ // did we find anything?
+ if (current_entry)
{
- /* get the entry type and free the stat entry */
+ // get the entry type and free the stat entry
current_entry_type = current_entry->type;
- osd_free(current_entry);
- current_entry = nullptr;
}
else
{
- /* 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;
- went_up = TRUE;
+ went_up = true;
std::string parent;
- apath.assign(zippath_parent(parent, apath.c_str()));
+ apath = zippath_parent(parent, apath.c_str());
}
}
- while (current_entry_type == ENTTYPE_NONE && !is_root(apath.c_str()));
+ while ((current_entry_type == ENTTYPE_NONE) && !is_root(apath.c_str()));
- /* if we did not find anything, then error out */
+ // if we did not find anything, then error out
if (current_entry_type == ENTTYPE_NONE)
- {
- err = FILERR_NOT_FOUND;
- goto done;
- }
+ return osd_file::error::NOT_FOUND;
- /* is this file a ZIP file? */
- if ((current_entry_type == ENTTYPE_FILE) && is_zip_file(apath_trimmed.c_str())
- && (zip_file_open(apath_trimmed.c_str(), &zipfile) == ZIPERR_NONE))
+ // is this file a ZIP file?
+ if ((current_entry_type == ENTTYPE_FILE) &&
+ ((is_zip_file(apath_trimmed) && (archive_file::open_zip(apath_trimmed, zipfile) == archive_file::error::NONE)) ||
+ (is_7z_file(apath_trimmed) && (archive_file::open_7z(apath_trimmed, zipfile) == archive_file::error::NONE))))
{
- i = strlen(path + apath.length());
- while (i > 0 && is_zip_path_separator(path[apath.length() + i - 1]))
+ auto i = strlen(path + apath.length());
+ while ((i > 0) && is_zip_path_separator(path[apath.length() + i - 1]))
i--;
newpath.assign(path + apath.length(), i);
- /* this was a true ZIP path - attempt to identify the type of path */
- zippath_find_sub_path(zipfile, newpath.c_str(), &current_entry_type);
+ // this was a true ZIP path - attempt to identify the type of path
+ zippath_find_sub_path(*zipfile, newpath, current_entry_type);
if (current_entry_type == ENTTYPE_NONE)
- {
- err = FILERR_NOT_FOUND;
- goto done;
- }
+ return osd_file::error::NOT_FOUND;
}
else
{
- /* this was a normal path */
+ // this was a normal path
if (went_up)
- {
- err = FILERR_NOT_FOUND;
- goto done;
- }
- newpath.assign(path);
+ return osd_file::error::NOT_FOUND;
+
+ newpath = path;
}
- /* success! */
+ // success!
entry_type = current_entry_type;
- err = FILERR_NONE;
-
-done:
- return err;
+ return osd_file::error::NONE;
}
@@ -834,19 +771,19 @@ done:
-------------------------------------------------*/
/**
- * @fn file_error zippath_opendir(const char *path, zippath_directory **directory)
+ * @fn osd_file::error zippath_opendir(const char *path, zippath_directory **directory)
*
* @brief Zippath opendir.
*
* @param path Full pathname of the file.
* @param [in,out] directory If non-null, pathname of the directory.
*
- * @return A file_error.
+ * @return A osd_file::error.
*/
-file_error zippath_opendir(const char *path, zippath_directory **directory)
+osd_file::error zippath_opendir(const char *path, zippath_directory **directory)
{
- file_error err;
+ osd_file::error err;
/* allocate a directory */
zippath_directory *result = nullptr;
@@ -856,30 +793,30 @@ file_error zippath_opendir(const char *path, zippath_directory **directory)
}
catch (std::bad_alloc &)
{
- err = FILERR_OUT_OF_MEMORY;
+ err = osd_file::error::OUT_OF_MEMORY;
goto done;
}
/* resolve the path */
osd_dir_entry_type entry_type;
err = zippath_resolve(path, entry_type, result->zipfile, result->zipprefix);
- if (err != FILERR_NONE)
+ if (err != osd_file::error::NONE)
goto done;
/* we have to be a directory */
if (entry_type != ENTTYPE_DIR)
{
- err = FILERR_NOT_FOUND;
+ err = osd_file::error::NOT_FOUND;
goto done;
}
/* was the result a ZIP? */
- if (result->zipfile == nullptr)
+ if (!result->zipfile)
{
/* a conventional directory */
result->directory = osd_opendir(path);
- if (result->directory == nullptr)
+ if (!result->directory)
{
- err = FILERR_FAILURE;
+ err = osd_file::error::FAILURE;
goto done;
}
@@ -889,7 +826,7 @@ file_error zippath_opendir(const char *path, zippath_directory **directory)
}
done:
- if ((directory == nullptr || err != FILERR_NONE) && result != nullptr)
+ if ((directory == nullptr || err != osd_file::error::NONE) && result != nullptr)
{
zippath_closedir(result);
result = nullptr;
@@ -918,7 +855,7 @@ void zippath_closedir(zippath_directory *directory)
osd_closedir(directory->directory);
if (directory->zipfile != nullptr)
- zip_file_close(directory->zipfile);
+ directory->zipfile.reset();
while (directory->returned_dirlist != nullptr)
{
@@ -948,20 +885,27 @@ void zippath_closedir(zippath_directory *directory)
* @return null if it fails, else the relative path.
*/
-static const char *get_relative_path(zippath_directory *directory, const zip_file_header *header)
+static const char *get_relative_path(zippath_directory const &directory)
{
- const char *result = nullptr;
- int len = directory->zipprefix.length();
+ auto len = directory.zipprefix.length();
+ const char *prefix = directory.zipprefix.c_str();
+ while (is_zip_file_separator(*prefix))
+ {
+ len--;
+ prefix++;
+ }
- if ((len <= strlen(header->filename))
- && !strncmp(directory->zipprefix.c_str(), header->filename, len))
+ if ((len <= directory.zipfile->current_name().length()) &&
+ !strncmp(prefix, directory.zipfile->current_name().c_str(), len))
{
- result = &header->filename[len];
- while(is_zip_file_separator(*result))
+ const char *result = &directory.zipfile->current_name().c_str()[len];
+ while (is_zip_file_separator(*result))
result++;
+
+ return *result ? result : nullptr;
}
- return result;
+ return nullptr;
}
@@ -982,7 +926,7 @@ static const char *get_relative_path(zippath_directory *directory, const zip_fil
const osd_directory_entry *zippath_readdir(zippath_directory *directory)
{
const osd_directory_entry *result = nullptr;
- const zip_file_header *header;
+ int header;
const char *relpath;
const char *separator;
const char *s;
@@ -997,7 +941,7 @@ const osd_directory_entry *zippath_readdir(zippath_directory *directory)
directory->returned_entry.type = ENTTYPE_DIR;
result = &directory->returned_entry;
}
- else if (directory->directory != nullptr)
+ else if (directory->directory)
{
/* a normal directory read */
do
@@ -1007,7 +951,7 @@ const osd_directory_entry *zippath_readdir(zippath_directory *directory)
while((result != nullptr) && (!strcmp(result->name, ".") || !strcmp(result->name, "..")));
/* special case - is this entry a ZIP file? if so we need to return it as a "directory" */
- if ((result != nullptr) && is_zip_file(result->name))
+ if ((result != nullptr) && (is_zip_file(result->name) || is_7z_file(result->name)))
{
/* copy; but change the entry type */
directory->returned_entry = *result;
@@ -1015,7 +959,7 @@ const osd_directory_entry *zippath_readdir(zippath_directory *directory)
result = &directory->returned_entry;
}
}
- else if (directory->zipfile != nullptr)
+ else if (directory->zipfile)
{
do
{
@@ -1023,13 +967,13 @@ const osd_directory_entry *zippath_readdir(zippath_directory *directory)
do
{
if (!directory->called_zip_first)
- header = zip_file_first_file(directory->zipfile);
+ header = directory->zipfile->first_file();
else
- header = zip_file_next_file(directory->zipfile);
+ header = directory->zipfile->next_file();
directory->called_zip_first = true;
relpath = nullptr;
}
- while((header != nullptr) && ((relpath = get_relative_path(directory, header)) == nullptr));
+ while((header >= 0) && ((relpath = get_relative_path(*directory)) == nullptr));
if (relpath != nullptr)
{
@@ -1068,7 +1012,7 @@ const osd_directory_entry *zippath_readdir(zippath_directory *directory)
memset(&directory->returned_entry, 0, sizeof(directory->returned_entry));
directory->returned_entry.name = relpath;
directory->returned_entry.type = ENTTYPE_FILE;
- directory->returned_entry.size = header->uncompressed_length;
+ directory->returned_entry.size = directory->zipfile->current_uncompressed_length();
result = &directory->returned_entry;
}
}
@@ -1099,3 +1043,5 @@ int zippath_is_zip(zippath_directory *directory)
{
return directory->zipfile != nullptr;
}
+
+} // namespace util