Having many addons may be faster now

git-svn-id: http://svn.net-core.org/repos/t-engine4@6452 51575b47-30f0-44d4-a5cc-537603b46e54

game/engines/default/engine/Module.lua

@@ -360,14 +360,31 @@ function _M:loadAddons(mod, saveuse)
 			vbase = "/loaded-addons/"..add.short_name
 		end
 
-		if add.data then fs.mount(base.."/data", "/data-"..add.short_name, true) print(" * with data") end
+		if add.data then
+			print(" * with data")
+			if add.teaa then fs.mount("subdir:/data/@"..fs.getRealPath(add.teaa), "/data-"..add.short_name, true)
+			else fs.mount(base.."/data", "/data-"..add.short_name, true)
+			end
+		end
 		if add.superload then 
-			fs.mount(base.."/superload", "/mod/addons/"..add.short_name.."/superload", true) print(" * with superload") 
+			print(" * with superload")
+			if add.teaa then fs.mount("subdir:/superload/@"..fs.getRealPath(add.teaa), "/mod/addons/"..add.short_name.."/superload", true)
+			else fs.mount(base.."/superload", "/mod/addons/"..add.short_name.."/superload", true)
+			end
+			
 			table.insert(_G.__addons_superload_order, add.short_name)
 		end
-		if add.overload then fs.mount(base.."/overload", "/", false) print(" * with overload") end
+		if add.overload then
+			print(" * with overload")
+			if add.teaa then fs.mount("subdir:/overload/@"..fs.getRealPath(add.teaa), "/", false)
+			else fs.mount(base.."/overload", "/", false)
+			end
+		end
 		if add.hooks then
-			fs.mount(base.."/hooks", "/hooks/"..add.short_name, true)
+			if add.teaa then fs.mount("subdir:/hooks/@"..fs.getRealPath(add.teaa), "/hooks/"..add.short_name, true)
+			else fs.mount(base.."/hooks", "/hooks/"..add.short_name, true)
+			end
+
 			self:setCurrentHookDir("/hooks/"..add.short_name.."/")
 			dofile("/hooks/"..add.short_name.."/load.lua")
 			self:setCurrentHookDir(nil)

src/physfs/archivers/subzip.c

+/*
+ * APK support routines for PhysicsFS.
+ * Based von zip.c.
+ *
+ * A apk (android) file is just a zip file. But for LÖVE
+ * only the assets/ content is necessary and therefore
+ * this hides everything outside the assets/ directory
+ * (like a chroot into assets/).
+ *
+ * Please see the file LICENSE.txt in the source's root directory.
+ *
+ *  This file is heavily based on zip.c by Ryan C. Gordon
+ */
+
+#if (defined PHYSFS_SUPPORTS_ZIP)
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifndef _WIN32_WCE
+#include <errno.h>
+#include <time.h>
+#endif
+#include "physfs.h"
+#include "zlib.h"
+
+#define __PHYSICSFS_INTERNAL__
+#include "physfs_internal.h"
+
+extern const PHYSFS_ArchiveInfo    __PHYSFS_ArchiveInfo_ZIP;
+extern const PHYSFS_Archiver       __PHYSFS_Archiver_ZIP;
+
+typedef struct
+{
+	dvoid *subopaque;
+	char *subdir;
+} SUBZIPinfo;
+
+static PHYSFS_sint64 SUBZIP_read(fvoid *opaque, void *buf,
+                              PHYSFS_uint32 objSize, PHYSFS_uint32 objCount)
+{
+	return __PHYSFS_Archiver_ZIP.read(opaque, buf, objSize, objCount);
+} /* SUBZIP_read */
+
+
+static PHYSFS_sint64 SUBZIP_write(fvoid *opaque, const void *buf,
+                               PHYSFS_uint32 objSize, PHYSFS_uint32 objCount)
+{
+	return __PHYSFS_Archiver_ZIP.write(opaque, buf, objSize, objCount);
+} /* SUBZIP_write */
+
+
+static int SUBZIP_eof(fvoid *opaque)
+{
+	return __PHYSFS_Archiver_ZIP.eof(opaque);
+} /* SUBZIP_eof */
+
+
+static PHYSFS_sint64 SUBZIP_tell(fvoid *opaque)
+{
+	return __PHYSFS_Archiver_ZIP.tell(opaque);
+} /* SUBZIP_tell */
+
+
+static int SUBZIP_seek(fvoid *opaque, PHYSFS_uint64 offset)
+{
+	return __PHYSFS_Archiver_ZIP.seek(opaque, offset);
+} /* SUBZIP_seek */
+
+
+static PHYSFS_sint64 SUBZIP_fileLength(fvoid *opaque)
+{
+    return __PHYSFS_Archiver_ZIP.fileLength(opaque);
+} /* SUBZIP_fileLength */
+
+
+static int SUBZIP_fileClose(fvoid *opaque)
+{
+	return __PHYSFS_Archiver_ZIP.fileClose(opaque);
+} /* SUBZIP_fileClose */
+
+
+
+static int SUBZIP_isArchive(const char *name, int forWriting)
+{
+	int len = strlen(name);
+	if (len < 11) return 0;
+	if (name[0] != 's' || name[1] != 'u' || name[2] != 'b' || name[3] != 'd' || name[4] != 'i' || name[5] != 'r' || name[6] != ':' || name[7] != '/') return 0;
+	char *realfile = strrchr(name, '@');
+	if (!realfile) return 0;
+
+	return __PHYSFS_Archiver_ZIP.isArchive(realfile+1, forWriting);
+} /* SUBZIP_isArchive */
+
+
+// subdir invocation: subdir:/foobar@path/to/zip/file.zip
+
+static void *SUBZIP_openArchive(const char *name, int forWriting)
+{
+	int len = strlen(name);
+	if (len < 11) return NULL;
+	if (name[0] != 's' || name[1] != 'u' || name[2] != 'b' || name[3] != 'd' || name[4] != 'i' || name[5] != 'r' || name[6] != ':' || name[7] != '/') return NULL;
+	char *realfile = strrchr(name, '@');
+	if (!realfile) return NULL;
+
+	dvoid *opaque = __PHYSFS_Archiver_ZIP.openArchive(realfile+1, forWriting);
+	if (!opaque) return NULL;
+
+	SUBZIPinfo *info = (SUBZIPinfo *) allocator.Malloc(sizeof (SUBZIPinfo));
+	info->subopaque = opaque;
+	info->subdir = allocator.Malloc(sizeof(char) * strlen(name));
+	name += 8;
+	int i = 0;
+	while (name != realfile) info->subdir[i++] = *(name++);
+	info->subdir[i] = '\0';
+	return info;
+} /* SUBZIP_openArchive */
+
+
+/**
+ * Allocates a new string and appends assets/ name.
+ * Result must be freed manually with allocator.Free
+ * if not necessary anymore
+ */
+char *append_assets(const char *subdir, const char *name)
+{
+	char *patched_name;
+	int sub_len = strlen(subdir);
+	int name_len = strlen(name);
+
+	patched_name = allocator.Malloc(sub_len + name_len + 1);
+
+	memcpy(patched_name, subdir, sub_len);
+	memcpy(patched_name + sub_len, name, name_len);
+	patched_name[sub_len + name_len + 1 - 1] = 0;
+
+	return patched_name;
+}
+
+
+/**
+ * just stores the parameter to an SUBZIP_enumerateFiles call to use them
+ * in the delegated call to cb
+ */
+typedef struct SUBZIP_originalEnumerateFileCallParameter
+{
+	dvoid *opaque;
+	const char *dname;
+	int omitSymLinks;
+	PHYSFS_EnumFilesCallback cb;
+	const char *origdir;
+	void *callbackdata;
+} SUBZIP_originalEnumerateFileCallParameter;
+
+static void SUBZIP_enumerateFilesCallback(void *data, const char *origdir,
+                                         const char *fname)
+{
+	SUBZIP_originalEnumerateFileCallParameter *callParameterPtr;
+
+	callParameterPtr = (SUBZIP_originalEnumerateFileCallParameter *)data;
+
+	(callParameterPtr->cb)(callParameterPtr->callbackdata, callParameterPtr->origdir, fname);
+}
+
+static void SUBZIP_enumerateFiles(dvoid *opaque, const char *dname,
+                               int omitSymLinks, PHYSFS_EnumFilesCallback cb,
+                               const char *origdir, void *callbackdata)
+{
+	char *patched_dname;
+	SUBZIP_originalEnumerateFileCallParameter callParameter;
+
+	callParameter.opaque = opaque;
+	callParameter.dname = dname;
+	callParameter.omitSymLinks = omitSymLinks;
+	callParameter.cb = cb;
+	callParameter.origdir = origdir;
+	callParameter.callbackdata = callbackdata;
+
+	patched_dname = append_assets(((SUBZIPinfo*)opaque)->subdir, dname);
+
+	__PHYSFS_Archiver_ZIP.enumerateFiles(((SUBZIPinfo*)opaque)->subopaque, patched_dname, omitSymLinks, SUBZIP_enumerateFilesCallback, origdir, &callParameter);
+
+	allocator.Free(patched_dname);
+} /* SUBZIP_enumerateFiles */
+
+
+static int SUBZIP_exists(dvoid *opaque, const char *name)
+{
+	int retval = 0;
+	char *patched_name = append_assets(((SUBZIPinfo*)opaque)->subdir, name);
+
+	retval = __PHYSFS_Archiver_ZIP.exists(((SUBZIPinfo*)opaque)->subopaque, patched_name);
+
+	allocator.Free(patched_name);
+
+	return retval;
+} /* SUBZIP_exists */
+
+
+static PHYSFS_sint64 SUBZIP_getLastModTime(dvoid *opaque,
+                                        const char *name,
+                                        int *fileExists)
+{
+	int retval = 0;
+	char *patched_name = append_assets(((SUBZIPinfo*)opaque)->subdir, name);
+
+	retval = __PHYSFS_Archiver_ZIP.getLastModTime(((SUBZIPinfo*)opaque)->subopaque, patched_name, fileExists);
+
+	allocator.Free(patched_name);
+
+	return retval;
+} /* SUBZIP_getLastModTime */
+
+
+static int SUBZIP_isDirectory(dvoid *opaque, const char *name, int *fileExists)
+{
+	int retval = 0;
+	char *patched_name = append_assets(((SUBZIPinfo*)opaque)->subdir, name);
+
+	retval = __PHYSFS_Archiver_ZIP.isDirectory(((SUBZIPinfo*)opaque)->subopaque, patched_name, fileExists);
+
+	allocator.Free(patched_name);
+
+	return retval;
+} /* SUBZIP_isDirectory */
+
+
+static int SUBZIP_isSymLink(dvoid *opaque, const char *name, int *fileExists)
+{
+	int retval = 0;
+	char *patched_name = append_assets(((SUBZIPinfo*)opaque)->subdir, name);
+
+	retval = __PHYSFS_Archiver_ZIP.isSymLink(((SUBZIPinfo*)opaque)->subopaque, patched_name, fileExists);
+
+	allocator.Free(patched_name);
+
+	return retval;
+} /* SUBZIP_isSymLink */
+
+
+static fvoid *SUBZIP_openRead(dvoid *opaque, const char *fnm, int *fileExists)
+{
+	fvoid * retval;
+	char *patched_name = append_assets(((SUBZIPinfo*)opaque)->subdir, fnm);
+
+	retval = __PHYSFS_Archiver_ZIP.openRead(((SUBZIPinfo*)opaque)->subopaque, patched_name, fileExists);
+
+	allocator.Free(patched_name);
+
+	return retval;
+} /* SUBZIP_openRead */
+
+
+static fvoid *SUBZIP_openWrite(dvoid *opaque, const char *filename)
+{
+    BAIL_MACRO(ERR_NOT_SUPPORTED, NULL);
+} /* SUBZIP_openWrite */
+
+
+static fvoid *SUBZIP_openAppend(dvoid *opaque, const char *filename)
+{
+    BAIL_MACRO(ERR_NOT_SUPPORTED, NULL);
+} /* SUBZIP_openAppend */
+
+
+static void SUBZIP_dirClose(dvoid *opaque)
+{
+	SUBZIPinfo *info = (SUBZIPinfo *)opaque;
+	allocator.Free(info->subdir);
+	__PHYSFS_Archiver_ZIP.dirClose(info->subopaque);
+	allocator.Free(info);
+} /* SUBZIP_dirClose */
+
+
+static int SUBZIP_remove(dvoid *opaque, const char *name)
+{
+    BAIL_MACRO(ERR_NOT_SUPPORTED, 0);
+} /* SUBZIP_remove */
+
+
+static int SUBZIP_mkdir(dvoid *opaque, const char *name)
+{
+    BAIL_MACRO(ERR_NOT_SUPPORTED, 0);
+} /* SUBZIP_mkdir */
+
+static int SUBZIP_rename(dvoid *opaque, const char *src, const char *dst)
+{
+    BAIL_MACRO(ERR_NOT_SUPPORTED, 0);
+} /* SUBZIP_mkdir */
+
+
+const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_SUBZIP =
+{
+    "SUBZIP",
+    "SUBZIP reader",
+    "based on __PHYSFS_Archiver_ZIP.ARCHIVE by Ryan C. Gordon <icculus@icculus.org>",
+    "http://icculus.org/physfs/",
+};
+
+
+const PHYSFS_Archiver __PHYSFS_Archiver_SUBZIP =
+{
+    &__PHYSFS_ArchiveInfo_SUBZIP,
+    SUBZIP_isArchive,          /* isArchive() method      */
+    SUBZIP_openArchive,        /* openArchive() method    */
+    SUBZIP_enumerateFiles,     /* enumerateFiles() method */
+    SUBZIP_exists,             /* exists() method         */
+    SUBZIP_isDirectory,        /* isDirectory() method    */
+    SUBZIP_isSymLink,          /* isSymLink() method      */
+    SUBZIP_getLastModTime,     /* getLastModTime() method */
+    SUBZIP_openRead,           /* openRead() method       */
+    SUBZIP_openWrite,          /* openWrite() method      */
+    SUBZIP_openAppend,         /* openAppend() method     */
+    SUBZIP_remove,             /* remove() method         */
+    SUBZIP_rename,              /* mkdir() method          */
+    SUBZIP_mkdir,              /* mkdir() method          */
+    SUBZIP_dirClose,           /* dirClose() method       */
+    SUBZIP_read,               /* read() method           */
+    SUBZIP_write,              /* write() method          */
+    SUBZIP_eof,                /* eof() method            */
+    SUBZIP_tell,               /* tell() method           */
+    SUBZIP_seek,               /* seek() method           */
+    SUBZIP_fileLength,         /* fileLength() method     */
+    SUBZIP_fileClose           /* fileClose() method      */
+};
+
+#endif  /* defined PHYSFS_SUPPORTS_ZIP */
+
+/* end of apk.c ... */

src/physfs/physfs.c

@@ -51,6 +51,8 @@ typedef struct __PHYSFS_ERRMSGTYPE__
 
 
 /* The various i/o drivers...some of these may not be compiled in. */
+extern const PHYSFS_ArchiveInfo    __PHYSFS_ArchiveInfo_SUBZIP;
+extern const PHYSFS_Archiver       __PHYSFS_Archiver_SUBZIP;
 extern const PHYSFS_ArchiveInfo    __PHYSFS_ArchiveInfo_ZIP;
 extern const PHYSFS_Archiver       __PHYSFS_Archiver_ZIP;
 extern const PHYSFS_ArchiveInfo    __PHYSFS_ArchiveInfo_LZMA;
@@ -73,6 +75,7 @@ static const PHYSFS_ArchiveInfo *supported_types[] =
 {
     &__PHYSFS_Archiver_BIND_PHYSFS,
 #if (defined PHYSFS_SUPPORTS_ZIP)
+    &__PHYSFS_ArchiveInfo_SUBZIP,
     &__PHYSFS_ArchiveInfo_ZIP,
 #endif
 #if (defined PHYSFS_SUPPORTS_7Z)
@@ -101,6 +104,7 @@ static const PHYSFS_Archiver *archivers[] =
     &__PHYSFS_Archiver_BIND_PHYSFS,
     &__PHYSFS_Archiver_DIR,
 #if (defined PHYSFS_SUPPORTS_ZIP)
+    &__PHYSFS_Archiver_SUBZIP,
     &__PHYSFS_Archiver_ZIP,
 #endif
 #if (defined PHYSFS_SUPPORTS_7Z)