libCOMBINE: allow a COMBINE archive to be initialised using some file contents

.codespellexclude

@@ -1,7 +1,7 @@
   afterAll(() => {
     IssuePtrs mErrors;
     return !mErrors.empty();
-    mErrors.push_back(issue);
+    return mErrors.size();
+    return mErrors;
         mErrors.push_back(issue);
     mErrors.clear();
-    return pimpl()->mErrors;

CMakeLists.txt

@@ -182,7 +182,7 @@ else()
     if(JAVASCRIPT_BINDINGS_AVAILABLE)
         if(JAVASCRIPT_UNIT_TESTING_AVAILABLE)
             set(LIBOPENCOR_JAVASCRIPT_UNIT_TESTING_DOCSTRING "Enable JAVASCRIPT unit testing.")
-            set(LIBOPENCOR_JAVASCRIPT_UNIT_TESTING OFF CACHE BOOL "${LIBOPENCOR_JAVASCRIPT_UNIT_TESTING_DOCSTRING}")
+            set(LIBOPENCOR_JAVASCRIPT_UNIT_TESTING ${LIBOPENCOR_JAVASCRIPT_BINDINGS} CACHE BOOL "${LIBOPENCOR_JAVASCRIPT_UNIT_TESTING_DOCSTRING}")
         endif()
 
         if(NOT "${JAVASCRIPT_UNIT_TESTING}" STREQUAL "" AND JAVASCRIPT_UNIT_TESTING_AVAILABLE)
@@ -372,7 +372,7 @@ else()
     if(PYTHON_BINDINGS_AVAILABLE)
         if(PYTHON_UNIT_TESTING_AVAILABLE)
             set(LIBOPENCOR_PYTHON_UNIT_TESTING_DOCSTRING "Enable Python unit testing.")
-            set(LIBOPENCOR_PYTHON_UNIT_TESTING OFF CACHE BOOL "${LIBOPENCOR_PYTHON_UNIT_TESTING_DOCSTRING}")
+            set(LIBOPENCOR_PYTHON_UNIT_TESTING ${LIBOPENCOR_PYTHON_BINDINGS} CACHE BOOL "${LIBOPENCOR_PYTHON_UNIT_TESTING_DOCSTRING}")
         endif()
 
         if(NOT "${PYTHON_UNIT_TESTING}" STREQUAL "" AND PYTHON_UNIT_TESTING_AVAILABLE)

cmake/base64encoder.cpp

@@ -0,0 +1,57 @@
+/*
+Copyright libOpenCOR contributors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#include "../extern/modp_b64/modp_b64.h"
+
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+
+int main(int pArgC, char *pArgV[])
+{
+    // Convert the given file to a base64-encoded string.
+
+    if (pArgC != 2) {
+        std::cerr << "Usage: " << pArgV[0] << " <file>" << std::endl;
+
+        return 1;
+    }
+
+    std::uintmax_t fileSize = std::filesystem::file_size(pArgV[1]);
+    char *buffer = new char[fileSize];
+    std::ifstream file(pArgV[1], std::ios::binary);
+
+    file.read(buffer, fileSize);
+
+    if (!file) {
+        std::cerr << "Error: the file could not be read." << std::endl;
+
+        return 1;
+    }
+
+    file.close();
+
+    char *base64 = new char[modp_b64_encode_len(fileSize)];
+
+    modp_b64_encode(base64, buffer, fileSize);
+
+    std::cout << base64 << std::endl;
+
+    delete[] base64;
+    delete[] buffer;
+
+    return 0;
+}

cmake/common.cmake

@@ -386,14 +386,25 @@ endfunction()
 
 function(prepare_test TARGET)
     # Prepare the given test.
+    # Note: we don't want modp_b64.cc to be subjected to Clang-Tidy, hence we compile it separately. From Cmake 3.27,
+    #       we could use the SKIP_LINTING property to exclude it from Clang-Tidy, but for some reasons it's not working,
+    #       so we compile it separately (as suggested at https://stackoverflow.com/a/75858167).
 
     add_executable(${TARGET}
                    ${ARGN})
 
     add_dependencies(${TARGET} ${CMAKE_PROJECT_NAME})
 
+    set(MODP_B64_TARGET ${TARGET}_modp_b64)
+
+    add_library(${MODP_B64_TARGET} OBJECT ${CMAKE_SOURCE_DIR}/extern/modp_b64/modp_b64.cc)
+
+    set_target_properties(${MODP_B64_TARGET} PROPERTIES
+                          CXX_CLANG_TIDY "")
+
     target_link_libraries(${TARGET} PRIVATE
                           gtest_main
+                          ${MODP_B64_TARGET}
                           ${CMAKE_PROJECT_NAME})
 
     configure_target(${TARGET})

cmake/environmentchecks.cmake

@@ -324,12 +324,12 @@ if(PYTHON_UNIT_TESTING_AVAILABLE AND PYTHON_EXE)
     endif()
 endif()
 
-if(   (APPLE AND LEAKS_EXE)
-   OR (NOT WIN32 AND PYTHON_EXE AND VALGRIND_EXE))
+if(   (APPLE AND PYTHON_EXE AND LEAKS_EXE)
+   OR (NOT APPLE AND NOT WIN32 AND PYTHON_EXE AND VALGRIND_EXE))
     set(MEMORY_CHECKS_AVAILABLE TRUE)
 else()
     if(APPLE)
-        set(MEMORY_CHECKS_ERROR_MESSAGE "Memory checks are requested but the leaks tool could not be found.")
+        set(MEMORY_CHECKS_ERROR_MESSAGE "Memory checks are requested but Python and/or the leaks tool could not be found.")
     else()
         set(MEMORY_CHECKS_ERROR_MESSAGE "Memory checks are requested but Python and/or Valgrind could not be found.")
     endif()

cmake/packages.cmake

@@ -195,7 +195,7 @@ function(retrieve_package PACKAGE_NAME PACKAGE_VERSION PACKAGE_REPOSITORY RELEAS
         if("${PACKAGE_NAME}" STREQUAL "libCellML")
             #---GRY--- THIS IS TEMPORARY UNTIL libCellML HAS AN OFFICIAL RELEASE WITH THE INTERPRETER.
 
-            set(PACKAGE_URL "https://github.com/agarny/${PACKAGE_REPOSITORY}/releases/download/584ebb5/${PACKAGE_FILE}")
+            set(PACKAGE_URL "https://github.com/agarny/${PACKAGE_REPOSITORY}/releases/download/707e211/${PACKAGE_FILE}")
         endif()
 
         file(DOWNLOAD ${PACKAGE_URL} ${REAL_PACKAGE_FILE} STATUS STATUS)

extern/README.rst

@@ -1,4 +1,5 @@
 `libOpenCOR <https://opencor.ws/libopencor/index.html>`__ relies on the following external projects:
 
-- `GoogleTest <https://github.com/google/googletest>`__ `1.15.2 <https://github.com/google/googletest/releases/tag/v1.15.2>`__; and
+- `GoogleTest <https://github.com/google/googletest>`__ `1.15.2 <https://github.com/google/googletest/releases/tag/v1.15.2>`__;
+- `modp_b64 <https://chromium.googlesource.com/chromium/src/third_party/modp_b64/>`__ at commit `7c1b327 <https://chromium.googlesource.com/chromium/src/third_party/modp_b64/+/7c1b3276e72757e854b5b642284aa367436a4723>`__; and
 - `nanobind <https://github.com/wjakob/nanobind>`__ `2.1.0 <https://github.com/wjakob/nanobind/releases/tag/v2.1.0>`__.

extern/modp_b64/BUILD.gn

@@ -0,0 +1,11 @@
+# Copyright 2013 The Chromium Authors
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+static_library("modp_b64") {
+  sources = [
+    "modp_b64.cc",
+    "modp_b64.h",
+    "modp_b64_data.h",
+  ]
+}

extern/modp_b64/DEPS

@@ -0,0 +1,3 @@
+include_rules = [
+  '+build',
+]

extern/modp_b64/DIR_METADATA

@@ -0,0 +1,6 @@
+monorail: {
+  component: "Internals"
+}
+buganizer_public: {
+  component_id: 1456292
+}

extern/modp_b64/LICENSE

@@ -0,0 +1,33 @@
+ * MODP_B64 - High performance base64 encoder/decoder
+ * Version 1.3 -- 17-Mar-2006
+ * http://modp.com/release/base64
+ *
+ * Copyright (c) 2005, 2006  Nick Galbreath -- nickg [at] modp [dot] com
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *   Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ *   Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ *   Neither the name of the modp.com nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

extern/modp_b64/OWNERS

@@ -0,0 +1 @@
+pkasting@chromium.org

extern/modp_b64/README.chromium

@@ -0,0 +1,24 @@
+Name: modp base64 decoder
+Short Name: stringencoders
+URL: https://github.com/client9/stringencoders
+Version: 2.0.0
+Revision: 26701a1c1fcb98ae43eefcaee23abc58459a6e59
+License: BSD-3-Clause
+License File: LICENSE
+Security Critical: yes
+Shipped: yes
+
+Description:
+The source code was modified from upstream as follows:
+- Removed the inclusion of modp's config.h
+- Fixed compilation errors that occur under VC8
+- Renamed modp_b64.c to modp_b64.cc to force it to be compiled as C++ and so
+  the inclusion of basictypes.h could be possible
+- Made code safe on 64-bit systems
+- Removed misaligned read/writes on little-endian systems
+- Removed unreachable code
+- Extended the API so callers can avoid overload for base64 encode
+- Removed big endian support entirely
+- Removed std::string APIs
+- Added multiple decoding options to support Blink callers
+- Added modp_b64_encode_data which doesn't append a null terminator

extern/modp_b64/modp_b64.cc

@@ -0,0 +1,168 @@
+/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*- */
+/* vi: set expandtab shiftwidth=4 tabstop=4: */
+/**
+ * \file
+ * <PRE>
+ * MODP_B64 - High performance base64 encoder/decoder
+ * Version 1.3 -- 17-Mar-2006
+ * http://modp.com/release/base64
+ *
+ * Copyright &copy; 2005, 2006  Nick Galbreath -- nickg [at] modp [dot] com
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *   Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ *   Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ *   Neither the name of the modp.com nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This is the standard "new" BSD license:
+ * http://www.opensource.org/licenses/bsd-license.php
+ * </PRE>
+ */
+
+/* public header */
+#include "modp_b64.h"
+
+#include "modp_b64_data.h"
+
+#define BADCHAR 0x01FFFFFF
+
+size_t modp_b64_encode_data(char* dest, const char* str, size_t len)
+{
+    size_t i = 0;
+    uint8_t* p = (uint8_t*) dest;
+
+    /* unsigned here is important! */
+    uint8_t t1, t2, t3;
+
+    if (len > 2) {
+        for (; i < len - 2; i += 3) {
+            t1 = str[i]; t2 = str[i+1]; t3 = str[i+2];
+            *p++ = e0[t1];
+            *p++ = e1[((t1 & 0x03) << 4) | ((t2 >> 4) & 0x0F)];
+            *p++ = e1[((t2 & 0x0F) << 2) | ((t3 >> 6) & 0x03)];
+            *p++ = e2[t3];
+        }
+    }
+
+    switch (len - i) {
+    case 0:
+        break;
+    case 1:
+        t1 = str[i];
+        *p++ = e0[t1];
+        *p++ = e1[(t1 & 0x03) << 4];
+        *p++ = CHARPAD;
+        *p++ = CHARPAD;
+        break;
+    default: /* case 2 */
+        t1 = str[i]; t2 = str[i+1];
+        *p++ = e0[t1];
+        *p++ = e1[((t1 & 0x03) << 4) | ((t2 >> 4) & 0x0F)];
+        *p++ = e2[(t2 & 0x0F) << 2];
+        *p++ = CHARPAD;
+    }
+
+    return p - (uint8_t*)dest;
+}
+
+size_t modp_b64_encode(char* dest, const char* str, size_t len) {
+  size_t output_size = modp_b64_encode_data(dest, str, len);
+  dest[output_size] = '\0';
+  return output_size;
+}
+
+size_t do_decode_padding(const char* src, size_t len, ModpDecodePolicy policy) {
+  if (policy == ModpDecodePolicy::kNoPaddingValidation) {
+    while (len > 0 && src[len - 1] == CHARPAD) {
+        len--;
+    }
+  } else {
+    const size_t remainder = len % 4;
+    if (policy == ModpDecodePolicy::kStrict && (remainder != 0 || len < 4))
+      return MODP_B64_ERROR;
+    if (remainder == 0) {
+      if (src[len - 1] == CHARPAD) {
+        len--;
+        if (src[len - 1] == CHARPAD) {
+          len--;
+        }
+      }
+    }
+  }
+  return len % 4 == 1 ? MODP_B64_ERROR : len;
+}
+
+size_t modp_b64_decode(char* dest, const char* src, size_t len, ModpDecodePolicy policy)
+{
+    if (len != 0)
+      len = do_decode_padding(src, len, policy);
+
+    if (len == 0 || len == MODP_B64_ERROR)
+      return len;
+
+    size_t i;
+    int leftover = len % 4;
+    size_t chunks = (leftover == 0) ? len / 4 - 1 : len /4;
+
+    uint8_t* p = (uint8_t*)dest;
+    uint32_t x = 0;
+    const uint8_t* y = (uint8_t*)src;
+    for (i = 0; i < chunks; ++i, y += 4) {
+        x = d0[y[0]] | d1[y[1]] | d2[y[2]] | d3[y[3]];
+        if (x >= BADCHAR) return MODP_B64_ERROR;
+        *p++ =  ((uint8_t*)(&x))[0];
+        *p++ =  ((uint8_t*)(&x))[1];
+        *p++ =  ((uint8_t*)(&x))[2];
+    }
+
+    switch (leftover) {
+    case 0:
+        x = d0[y[0]] | d1[y[1]] | d2[y[2]] | d3[y[3]];
+
+        if (x >= BADCHAR) return MODP_B64_ERROR;
+        *p++ =  ((uint8_t*)(&x))[0];
+        *p++ =  ((uint8_t*)(&x))[1];
+        *p =    ((uint8_t*)(&x))[2];
+        return (chunks+1)*3;
+    case 1:  /* with padding this is an impossible case */
+        x = d0[y[0]];
+        *p = *((uint8_t*)(&x)); // i.e. first char/byte in int
+        break;
+    case 2: // * case 2, 1  output byte */
+        x = d0[y[0]] | d1[y[1]];
+        *p = *((uint8_t*)(&x)); // i.e. first char
+        break;
+    default: /* case 3, 2 output bytes */
+        x = d0[y[0]] | d1[y[1]] | d2[y[2]];  /* 0x3c */
+        *p++ =  ((uint8_t*)(&x))[0];
+        *p =  ((uint8_t*)(&x))[1];
+        break;
+    }
+
+    if (x >= BADCHAR) return MODP_B64_ERROR;
+
+    return 3*chunks + (6*leftover)/8;
+}