1. added BufferDesciptor to 'fs' to allow reading from a buffer

2. updated zip-reader to allow reading from a buffer instead of file

microscript/ILibDuktape_fs.c

@@ -78,6 +78,7 @@ limitations under the License.
 #define FS_WINDOWS_WriteCallback	"\xFF_FSWindowsHandles_WriteCallback"
 #define FS_WINDOWS_UserBuffer		"\xFF_FSWindowsHandles_UserBuffer"
 #define FS_WINDOWS_WriteUserBuffer	"\xFF_FSWindowsHandles_WriteUserBuffer"
+#define FS_BUFFER_DESCRIPTOR_PENDING "\xFF_FS_BUFFER_DESCRIPTOR_PENDING"
 
 #if defined(_POSIX) && !defined(__APPLE__)
 typedef struct ILibDuktape_fs_linuxWatcher
@@ -230,6 +231,10 @@ FILE* ILibDuktape_fs_getFilePtr(duk_context *ctx, int fd)
 
 duk_ret_t ILibDuktape_fs_closeSync(duk_context *ctx)
 {
+	if (duk_is_object(ctx, 0) && strcmp(Duktape_GetStringPropertyValue(ctx, 0, "_ObjectID", ""), "fs.bufferDescriptor") == 0)
+	{
+		return(0);
+	}
 	if (duk_is_number(ctx, 0))
 	{
 		void *tmp = (void*)(uintptr_t)duk_require_uint(ctx, 0);
@@ -734,6 +739,30 @@ BOOL ILibDuktape_fs_read_WindowsSink(void *chain, HANDLE h, ILibWaitHandle_Error
 	return(FALSE);
 }
 #endif
+void ILibDuktape_fs_buffer_fd_read(duk_context *ctx, void ** args, int argsLen)
+{
+	duk_idx_t top = duk_get_top(ctx);
+
+	duk_eval_string(ctx, "require('fs');");							// [fs]
+	duk_get_prop_string(ctx, -1, FS_BUFFER_DESCRIPTOR_PENDING);		// [fs][array]
+	while (duk_get_length(ctx, -1) > 0)
+	{
+		duk_array_shift(ctx, -1);									// [fs][array][obj]
+
+		duk_get_prop_string(ctx, -1, "func");						// [fs][array][obj][func]
+		duk_eval_string(ctx, "require('fs');");						// [fs][array][obj][func][this]
+		duk_push_int(ctx, 0);										// [fs][array][obj][func][this][err]
+		duk_get_prop_string(ctx, -4, "bytesRead");					// [fs][array][obj][func][this][err][bytesRead]
+		duk_get_prop_string(ctx, -5, "buffer");						// [fs][array][obj][func][this][err][bytesRead][buffer]
+		duk_remove(ctx, -6);										// [fs][array][func][this][err][bytesRead][buffer]
+		if (duk_pcall_method(ctx, 3) != 0)
+		{
+			ILibDuktape_Process_UncaughtExceptionEx(ctx, "fs.read.bufferFD.callback() ");
+		}
+		duk_pop(ctx);												// [fs][array][obj]
+	}
+	duk_set_top(ctx, top);
+}
 duk_ret_t ILibDuktape_fs_read(duk_context *ctx)
 {
 	int top = duk_get_top(ctx);
@@ -772,6 +801,36 @@ duk_ret_t ILibDuktape_fs_read(duk_context *ctx)
 		duk_call_method(ctx, 3);
 		return(1);
 	}
+	if (duk_is_object(ctx, 0) && duk_is_object(ctx, 1) && duk_is_function(ctx, 2))
+	{
+		if (strcmp(Duktape_GetStringPropertyValue(ctx, 0, "_ObjectID", ""), "fs.bufferDescriptor") != 0) { return(ILibDuktape_Error(ctx, "Invalid Parameter")); }
+		duk_size_t wrbufLen;
+		char *wrbuf = (char*)Duktape_GetBufferPropertyEx(ctx, 1, "buffer", &wrbufLen);
+		duk_dup(ctx, 0);												// [bufferDescriptor]
+		int dpos = Duktape_GetIntPropertyValue(ctx, -1, "position", 0);
+		dpos = Duktape_GetIntPropertyValue(ctx, 1, "position", dpos);
+		duk_get_prop_string(ctx, -1, "buffer");							// [bufferDescriptor][buffer]
+		int bufferLength = (int)duk_get_length(ctx, -1);
+		int length = Duktape_GetIntPropertyValue(ctx, 1, "length", bufferLength);
+		int offset = Duktape_GetIntPropertyValue(ctx, 1, "offset", 0);
+		int bytesRead = length < (bufferLength - dpos) ? length : (bufferLength - dpos);
+		if (bytesRead > ((int)wrbufLen - offset)) { bytesRead = (int)wrbufLen - offset; }
+		duk_size_t srbufLen;
+		char *srbuf = (char*)Duktape_GetBufferPropertyEx(ctx, 0, "buffer", &srbufLen);
+		memcpy_s(wrbuf + offset, bytesRead, srbuf + dpos, bytesRead);
+
+		duk_push_int(ctx, bytesRead);									// [bufferDescriptor][buffer][position]
+		duk_put_prop_string(ctx, -3, "position");						// [bufferDescriptor][buffer]
+		duk_push_this(ctx);												// [bufferDescriptor][buffer][fs]
+		duk_get_prop_string(ctx, -1, FS_BUFFER_DESCRIPTOR_PENDING);		// [bufferDescriptor][buffer][fs][array]
+		duk_push_object(ctx);											// [bufferDescriptor][buffer][fs][array][object]
+		duk_dup(ctx, 2); duk_put_prop_string(ctx, -2, "func");
+		duk_push_int(ctx, bytesRead); duk_put_prop_string(ctx, -2, "bytesRead");
+		duk_get_prop_string(ctx, 1, "buffer"); duk_put_prop_string(ctx, -2, "buffer");
+		duk_array_push(ctx, -2);										// [bufferDescriptor][buffer][fs][array]
+		ILibDuktape_Immediate(ctx, NULL, 0, ILibDuktape_fs_buffer_fd_read);
+		return(0);
+	}
 	if (!(duk_is_number(ctx, 0) && duk_is_object(ctx, 1) && duk_is_function(ctx, 2))) { return(ILibDuktape_Error(ctx, "Invalid Parameters")); }
 #ifdef WIN32
 	HANDLE H = (HANDLE)(uintptr_t)duk_require_uint(ctx, 0);
@@ -2220,6 +2279,9 @@ void ILibDuktape_fs_PUSH(duk_context *ctx, void *chain)
 	duk_push_object(ctx);						// [fs][descriptors]
 	duk_put_prop_string(ctx, -2, FS_FDS);		// [fs]
 
+	duk_push_array(ctx);
+	duk_put_prop_string(ctx, -2, FS_BUFFER_DESCRIPTOR_PENDING);
+
 	duk_push_object(ctx);
 	duk_put_prop_string(ctx, -2, FS_WINDOWS_HANDLES);
 

modules/zip-reader.js

@@ -219,6 +219,7 @@ function zippedObject(table)
             this._bytesLeft = this._info.compressedSize;
             this._buffer = Buffer.alloc(4096);
             console.info1('Local Header @ ' + this._info.offset);
+            console.info1(' -> Compressed Size = ' + this._bytesLeft);
             require('fs').read(this._info.fd, { buffer: Buffer.alloc(30), position: this._info.offset }, this._localHeaderSink);
         });
         return (ret);
@@ -253,6 +254,7 @@ function zippedObject(table)
         prom.results.peek().stream.ret = prom;
         prom.results.peek().stream.on('data', function (c)
         {
+            console.info2('DATA: ' + c.length);
             if (this._buf == null)
             {
                 this._buf = Buffer.concat([c]);
@@ -264,6 +266,7 @@ function zippedObject(table)
         });
         prom.results.peek().stream.on('end', function ()
         {
+            console.info2('End of current stream');
             this.ret.results.peek().buffer = this._buf;
             this.ret.z._extractAllStreams2(this.ret);
         });
@@ -323,15 +326,23 @@ function zippedObject(table)
 
 function read(path)
 {
-    var ret = new promise(function(res,rej){this._res = res; this._rej = rej;});
+    var ret = new promise(function (res, rej) { this._res = res; this._rej = rej; });
-    if (!require('fs').existsSync(path))
+    if (typeof (path) == 'string')
     {
-        ret._rej('File not found');
+        if (!require('fs').existsSync(path))
-        return (ret);
+        {
-    }
+            ret._rej('File not found');
+            return (ret);
+        }
 
-    ret._len = require('fs').statSync(path).size;
+        ret._len = require('fs').statSync(path).size;
-    ret._fd = require('fs').openSync(path, require('fs').constants.O_RDONLY);
+        ret._fd = require('fs').openSync(path, require('fs').constants.O_RDONLY);
+    }
+    else
+    {
+        ret._len = path.length;
+        ret._fd = { _ObjectID: 'fs.bufferDescriptor', buffer: path, position: 0 };
+    }
     ret._cdr = function _cdr(err, bytesRead, buffer)
     {
         var table = {};