Project: Updated choc

Author: drowaudio

modules/3rd_party/choc/choc/containers/choc_ZipFile.h

@@ -335,11 +335,12 @@ struct ZipFile::Item::ZipStream  : public  std::istream,
                                    private std::streambuf
 {
     ZipStream (const Item& i)
-        : std::istream (this),
+        : std::istream (nullptr),
           fileStream (i.owner->source),
           compressedSize (static_cast<int64_t> (i.compressedSize)),
           fileStartOffset (static_cast<int64_t> (i.fileStartOffset))
     {
+        rdbuf (this);
         char entry[30];
         i.owner->readChunk (entry, fileStartOffset, 30);
 

modules/3rd_party/choc/choc/containers/choc_zlib.h

@@ -96,6 +96,7 @@ class DeflaterStream  : public std::ostream,
     std::unique_ptr<Pimpl> pimpl;
 
     int overflow (int) override;
+    std::streamsize xsputn (const char_type* s, std::streamsize n) override;
 };
 
 
@@ -120,7 +121,7 @@ struct zlib
 // I even started trying to improve some of the appalling variable names,
 // but honestly, life's too short..
 
-CHOC_REGISTER_OPEN_SOURCE_LICENCE (QuickJS, R"(
+CHOC_REGISTER_OPEN_SOURCE_LICENCE (ZLIB, R"(
 ==============================================================================
 ZLIB License:
 
@@ -910,13 +911,15 @@ struct DeflateStream
                 /* strstart == 0 is possible when wraparound on 16-bit machine */
                 s->lookahead = (uint32_t) (s->strstart - max_start);
                 s->strstart = (uint32_t) max_start;
-                s->flushBlock (0);
+                if (! s->flushBlock (false))
+                    return BlockStatus::need_more;  // Output buffer full, need to flush
             }
             /* Flush if we may have to slide, otherwise block_start may become
             * negative and the data will be gone:
             */
             if (s->strstart - (uint32_t) s->block_start >= s->MAX_DIST())
-                s->flushBlock (0);
+                if (! s->flushBlock (false))
+                    return BlockStatus::need_more;  // Output buffer full, need to flush
         }
         s->flushBlock (flush == FlushState::Z_FINISH);
         return flush == FlushState::Z_FINISH ? BlockStatus::finish_done
@@ -1498,14 +1501,15 @@ struct DeflateStream
         last_lit = 0;
     }
 
-    void flushBlock (bool eof)
+    bool flushBlock (bool eof)
     {
         flushCurrentBlock (block_start >= 0 ? (uint8_t*) &window[(uint32_t) block_start]
                                             : (uint8_t*) nullptr,
                            (unsigned long) ((long) strstart - block_start),
                            eof);
         block_start = (long) strstart;
         flushPending();
+        return pending == 0;  // Return true if all data was flushed
     }
 
     void initialiseTrees()
@@ -3808,9 +3812,10 @@ struct InflaterStream::Pimpl
 };
 
 inline InflaterStream::InflaterStream (std::shared_ptr<std::istream> source, FormatType format)
-   : std::istream (this),
+   : std::istream (nullptr),
      pimpl (std::make_unique<Pimpl> (std::move (source), format))
 {
+    rdbuf (this);
 }
 
 inline InflaterStream::~InflaterStream() = default;
@@ -3981,14 +3986,21 @@ struct DeflaterStream::Pimpl
 };
 
 inline DeflaterStream::DeflaterStream (std::shared_ptr<std::ostream> d, CompressionLevel c, int w)
-    : std::ostream (this),
+    : std::ostream (nullptr),
       pimpl (std::make_unique<Pimpl> (std::move (d), c, w))
-{}
+{
+    rdbuf (this);
+}
 
 inline DeflaterStream::~DeflaterStream() = default;
 
 inline int DeflaterStream::overflow (int c) { return pimpl->overflow (c); }
 
+inline std::streamsize DeflaterStream::xsputn (const char_type* s, std::streamsize n)
+{
+    return pimpl->write (reinterpret_cast<const uint8_t*> (s),
+                         static_cast<size_t> (n)) ? n : 0;
+}
 
 } // namespace choc::gzip
 

modules/3rd_party/choc/choc/javascript/choc_javascript.h

@@ -162,6 +162,16 @@ namespace choc::javascript
         /// Pumps the message loop in an engine-specific way - may have no effect on some platforms.
         void pumpMessageLoop();
 
+        /// If supported by the engine, attempts to cancel the execution of the JS code.
+        /// If the JS code is stuck in a blocking call itself, this won't work, but will
+        /// work if the JS code is running a loop, for example.
+        /// This obviously has to be called from another thread, so for example if your JS engine
+        /// is running in a worker thread, the GUI thread can call this.
+        /// If the cancellation worked, an exception will be thrown.
+        /// Returns true if cancellation is supported by this engine, or false if not.
+        /// Currently only implemented in the QuickJS engine.
+        bool cancel();
+
         //==============================================================================
         /// @internal
         struct Pimpl;
@@ -235,6 +245,7 @@ struct Context::Pimpl
     virtual void pushArg (double) = 0;
     virtual void pushArg (bool) = 0;
     virtual void pumpMessageLoop() = 0;
+    virtual bool cancel() { return false; }
 
     void pushArg (const std::string& v)   { pushArg (std::string_view (v)); }
     void pushArg (const char* v)          { pushArg (std::string_view (v)); }
@@ -318,6 +329,12 @@ inline void Context::pumpMessageLoop()
     pimpl->pumpMessageLoop();
 }
 
+inline bool Context::cancel()
+{
+    CHOC_ASSERT (pimpl != nullptr); // cannot call this on a moved-from context!
+    return pimpl->cancel();
+}
+
 inline std::string makeSafeIdentifier (std::string s)
 {
     constexpr static std::string_view reservedWords[] =

modules/3rd_party/choc/choc/javascript/choc_javascript_Duktape.h

@@ -19,6 +19,7 @@
 #ifndef CHOC_JAVASCRIPT_DUKTAPE_HEADER_INCLUDED
 #define CHOC_JAVASCRIPT_DUKTAPE_HEADER_INCLUDED
 
+#include <atomic>
 #include "choc_javascript.h"
 
 /**
@@ -3220,7 +3221,7 @@ typedef struct duk_hthread duk_context;
 #undef DUK_USE_EXEC_INDIRECT_BOUND_CHECK
 #undef DUK_USE_EXEC_PREFER_SIZE
 #define DUK_USE_EXEC_REGCONST_OPTIMIZE
-#undef DUK_USE_EXEC_TIMEOUT_CHECK
+#define DUK_USE_EXEC_TIMEOUT_CHECK(udata) (static_cast<std::atomic<bool>*> (udata)->load())
 #undef DUK_USE_EXPLICIT_NULL_INIT
 #undef DUK_USE_EXTSTR_FREE
 #undef DUK_USE_EXTSTR_INTERN_CHECK
@@ -3262,7 +3263,7 @@ typedef struct duk_hthread duk_context;
 #define DUK_USE_HTML_COMMENTS
 #define DUK_USE_IDCHAR_FASTPATH
 #undef DUK_USE_INJECT_HEAP_ALLOC_ERROR
-#undef DUK_USE_INTERRUPT_COUNTER
+#define DUK_USE_INTERRUPT_COUNTER
 #undef DUK_USE_INTERRUPT_DEBUG_FIXUP
 #define DUK_USE_JC
 #define DUK_USE_JSON_BUILTIN
@@ -104989,7 +104990,7 @@ DUK_INTERNAL duk_double_t duk_util_tinyrandom_get_double(duk_hthread *thr) {
 //==============================================================================
 struct DuktapeContext  : public Context::Pimpl
 {
-    DuktapeContext() : context (duktape::duk_create_heap (nullptr, nullptr, nullptr, nullptr, fatalError))
+    DuktapeContext() : context (duktape::duk_create_heap (nullptr, nullptr, nullptr, &shouldCancel, fatalError))
     {
         CHOC_ASSERT (context != nullptr);
     }
@@ -105001,6 +105002,12 @@ struct DuktapeContext  : public Context::Pimpl
 
     void pumpMessageLoop() override {}
 
+    bool cancel() override
+    {
+        shouldCancel.store (true);
+        return true;
+    }
+
     void resetStack()
     {
         while (duk_get_top (context))
@@ -105018,6 +105025,8 @@ struct DuktapeContext  : public Context::Pimpl
 
     void evalString (std::string_view code)
     {
+        shouldCancel.store (false);
+
         if (duk_peval_lstring (context, code.data(), code.length()) != DUK_EXEC_SUCCESS)
             throwError();
     }
@@ -105310,6 +105319,7 @@ struct DuktapeContext  : public Context::Pimpl
     duktape::duk_context* context = nullptr;
     std::vector<std::unique_ptr<RegisteredFunction>> registeredFunctions;
     duktape::duk_idx_t numFunctionArgs = 0;
+    std::atomic<bool> shouldCancel { false };
 
     static constexpr const char* objectNameAttribute = "_objectName";
 };

modules/3rd_party/choc/choc/javascript/choc_javascript_QuickJS.h

@@ -51,6 +51,7 @@
 #include <time.h>
 #include <fenv.h>
 #include <math.h>
+#include <atomic>
 #if defined(__APPLE__)
 #include <malloc/malloc.h>
 #elif defined(__linux__)
@@ -64052,10 +64053,30 @@ struct QuickJSContext  : public Context::Pimpl
         context = JS_NewContext (runtime);
         CHOC_ASSERT (context != nullptr);
         JS_SetContextOpaque (context, this);
+
+        JS_SetInterruptHandler (runtime, [] (JSRuntime*, void* opaque)
+        {
+            if (auto qjctx = static_cast<QuickJSContext*> (opaque))
+            {
+                if (qjctx->shouldCancel.load())
+                {
+                    qjctx->shouldCancel.store (false);
+                    return 1;
+                }
+            }
+
+            return 0;
+        }, this);
     }
 
     void pumpMessageLoop() override {}
 
+    bool cancel() override
+    {
+        shouldCancel.store (true);
+        return true;
+    }
+
     void pushObjectOrArray (const choc::value::ValueView& v) override { functionArgs.push_back (valueToJS (v).release()); }
     void pushArg (std::string_view v) override                        { functionArgs.push_back (stringToJS (v).release()); }
     void pushArg (int32_t v) override                                 { functionArgs.push_back (JS_NewInt32   (context, v)); }
@@ -64350,6 +64371,7 @@ struct QuickJSContext  : public Context::Pimpl
     std::vector<Context::NativeFunction> registeredFunctions;
     std::vector<JSValue> functionArgs;
     JSAtom functionToCall = {};
+    std::atomic<bool> shouldCancel { false };
 
     static constexpr const char* objectNameAttribute = "_objectName";
 };

modules/3rd_party/choc/choc/platform/choc_DetectDebugger.h

@@ -71,7 +71,7 @@ inline bool choc::isDebuggerActive()
 }
 
 //==============================================================================
-#elif CHOC_LINUX
+#elif CHOC_LINUX || CHOC_ANDROID
 
 #include "../text/choc_Files.h"
 #include "../text/choc_StringUtilities.h"
@@ -80,15 +80,22 @@ inline bool choc::isDebuggerActive()
 {
     auto readStatusFileItem = [] (std::string_view filename, std::string_view item) -> std::string
     {
-        auto lines = choc::text::splitIntoLines (choc::file::loadFileAsString (std::string (filename)), false);
+        // Need to read /proc files without either seeking or throwing exceptions (which would
+        // break the debugger we're trying to detect), so avoid using loadFileAsString() here
+        std::ifstream stream (std::string (filename), std::ios::binary);
+
+        auto content = std::string { std::istreambuf_iterator<char> (stream),
+                                     std::istreambuf_iterator<char>() };
+
+        auto lines = choc::text::splitIntoLines (content, false);
 
         for (auto i = lines.rbegin(); i != lines.rend(); ++i)
         {
             auto line = choc::text::trimStart (std::string_view (*i));
 
             if (choc::text::startsWith (line, item))
             {
-                auto remainder = choc::text::trimStart (item.substr (item.length()));
+                auto remainder = choc::text::trimStart (line.substr (item.length()));
 
                 if (! remainder.empty() && remainder[0] == ':')
                     return std::string (choc::text::trim (remainder.substr (1)));

modules/3rd_party/choc/choc/platform/choc_DisableAllWarnings.h

@@ -85,6 +85,7 @@
  #pragma warning (disable: 2440)
  #pragma warning (disable: 2664)
  #pragma warning (disable: 4244)
+ #pragma warning (disable: 4245)
  #pragma warning (disable: 4701)
  #pragma warning (disable: 4702)
  #pragma warning (disable: 4706)
@@ -99,5 +100,7 @@
  #pragma warning (disable: 6340)
  #pragma warning (disable: 6385)
  #pragma warning (disable: 6386)
+ #pragma warning (disable: 26437)
+ #pragma warning (disable: 26816)
  #pragma warning (disable: 28182)
 #endif

modules/3rd_party/choc/choc/text/choc_Files.h

@@ -21,10 +21,12 @@
 
 #include <fstream>
 #include <functional>
+#include <cstring>
 #include <cwctype>
 #include <stdexcept>
 #include <random>
 #include <filesystem>
+#include "../platform/choc_Platform.h"
 #include "../text/choc_UTF8.h"
 
 namespace choc::file
@@ -145,28 +147,26 @@ size_t readFileContent (const std::filesystem::path& filename, GetDestBufferFn&&
 
         auto fileSize = stream.tellg();
 
-        if (fileSize < 0)
-            throw Error ("Failed to read from file: " + filename.string());
-
         if (fileSize == 0)
-            return {};
+            return 0;
 
-        if (auto destBuffer = getBuffer (static_cast<uint64_t> (fileSize)))
+        if (fileSize > 0)
         {
-            stream.seekg (0);
-
-            if (stream.read (static_cast<std::ifstream::char_type*> (destBuffer), static_cast<std::streamsize> (fileSize)))
-                return static_cast<size_t> (fileSize);
+            if (auto destBuffer = getBuffer (static_cast<uint64_t> (fileSize)))
+            {
+                stream.seekg (0);
 
-            throw Error ("Failed to read from file: " + filename.string());
+                if (stream.read (static_cast<std::ifstream::char_type*> (destBuffer), static_cast<std::streamsize> (fileSize)))
+                    return static_cast<size_t> (fileSize);
+            }
         }
+
+        throw Error ("Failed to read from file: " + filename.string());
     }
     catch (const std::ios_base::failure& e)
     {
         throw Error ("Failed to read from file: " + filename.string() + ": " + e.what());
     }
-
-    return 0;
 }
 
 inline std::string loadFileAsString (const std::filesystem::path& filename)

modules/3rd_party/choc/tests/CMakeLists.txt

@@ -71,7 +71,7 @@ elseif (CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
 
     set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
 
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHsc /W4 /WX -DWIN32 /bigobj ")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHsc /W4 /WX /w14355 -DWIN32 /bigobj ")
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
 endif()
 

modules/3rd_party/choc/tests/choc_tests.h

@@ -724,6 +724,18 @@ inline void testFileUtilities (choc::test::TestProgress& progress)
         CHOC_EXPECT_TRUE (p4.matches ("abcd.x"));
         CHOC_EXPECT_FALSE (p4.matches ("abcd.X") || p4.matches ("abcdd.x") || p4.matches ("abc.x"));
     }
+
+   #if CHOC_LINUX || CHOC_ANDROID
+    {
+        CHOC_TEST (ProcFileReading)
+
+        // /proc files report 0 size but contain data - test that loadFileAsString handles this
+        auto content = choc::file::loadFileAsString ("/proc/self/status");
+        CHOC_EXPECT_FALSE (content.empty());
+        CHOC_EXPECT_TRUE (content.find ("Name:") != std::string::npos);
+        CHOC_EXPECT_TRUE (content.find ("TracerPid:") != std::string::npos);
+    }
+   #endif
 }
 
 //==============================================================================
@@ -2631,7 +2643,14 @@ inline void testWebview (choc::test::TestProgress& progress)
 
         CHOC_EXPECT_EQ (result, "[1234, 5678]");
         CHOC_EXPECT_TRUE (error1.empty());
-        CHOC_EXPECT_EQ (choc::json::toString (value1), R"({"x": [1, 2, 3], "y": 987, "z": true})");
+        // Check individual properties since JSON object order is not guaranteed
+        CHOC_EXPECT_TRUE (value1.isObject());
+        CHOC_EXPECT_TRUE (value1.hasObjectMember ("x"));
+        CHOC_EXPECT_TRUE (value1.hasObjectMember ("y"));
+        CHOC_EXPECT_TRUE (value1.hasObjectMember ("z"));
+        CHOC_EXPECT_EQ (choc::json::toString (value1["x"]), "[1, 2, 3]");
+        CHOC_EXPECT_EQ (value1["y"].get<int>(), 987);
+        CHOC_EXPECT_EQ (value1["z"].get<bool>(), true);
        #if ! CHOC_WINDOWS
         CHOC_EXPECT_TRUE (! error2.empty()); // Windows browser seems to not do this one correctly
        #endif