fmu-manipulation-toolbox 2.0b2__tar.gz → 2.1.dev0__tar.gz

{fmu_manipulation_toolbox-2.0b2 → fmu_manipulation_toolbox-2.1.dev0}/CHANGELOG.md

@@ -3,7 +3,39 @@ This package was formerly known as `fmutool`.
 
 # Upstream
 
-Not released yet. Changes since 1.9.4.2, by theme: 🟢 **ADDED** new feature, 🔵 **CHANGED** change of behaviour or
+Not released yet. Changes since 2.0, with the same legend as 2.0.
+
+## FMU Container
+
+- 🟢 **ADDED** **architecture wires** in SSP files: a connection annotated
+  `fmu_manipulation_toolbox.architecture-wire` describes a dependency between two components (directed,
+  bidirectional or undirected, with a Markdown description) before the exchanged variables are known. It is not a
+  link: it takes no part in the container and is not written in the JSON description; the Container Builder shows it
+  as a hint. See [Architecture wires](docs/user-guide/fmucontainer/container.md#architecture-wires).
+- 🔵 **CHANGED** SSP import: each component is embedded as `<component name>.fmu` (it was named after its FMU file,
+  `<file>-<n>.fmu` for the components sharing a source), and the FMUs are extracted keeping their path inside the
+  archive: two FMUs with the same file name in different directories no longer overwrite each other. A component
+  `source` outside the archive is refused. SSP 2.0 files are read; a component without `source` (SSP 2.0) is
+  ignored with a warning, together with its connections.
+
+## fmutool and the Python API
+
+- 🟢 **ADDED** `-debug` option of `fmutool` and `fmutool-gui` (at launch): the `DEBUG` lines are logged, in the log
+  area for `fmutool-gui`, e.g. the command lines of the compiler and of the linker of `-compile-sources`.
+
+## Graphical User Interfaces
+
+- 🟢 **ADDED** `fmucontainer-gui <file>` opens an FMU container (`.fmu`) or imports an assembly file (`.json`,
+  `.csv`, `.ssp`) given on the command line.
+- 🟢 **ADDED** Container Builder: the nodes imported from an SSP file are placed after the geometry of their
+  components, and the [architecture wires](docs/user-guide/fmucontainer/gui-usage.md#architecture-wires) of the file
+  are shown as dashed wires until their links are defined, with their direction and description in the wire details.
+- 🟠 **FIXED** status bar of the GUIs: a long log record is elided (the whole line in the tooltip) instead
+  of widening the window.
+
+# Version 2.0
+
+Changes since 1.9.4.2, by theme: 🟢 **ADDED** new feature, 🔵 **CHANGED** change of behaviour or
 API, 🟠 **FIXED** bug fix; 🔴 **BREAKING** marks what may require changes in scripts, custom operations or checkers.
 
 ## Installation and platforms
@@ -12,6 +44,8 @@ API, 🟠 **FIXED** bug fix; 🔴 **BREAKING** marks what may require changes in
   October 2025. On Python 3.9, pip installs 1.9.4.2, the last release supporting it.
 - 🟢 **ADDED** Python 3.14 is supported, and tested by the CI on Windows, Linux and macOS. Python 3.13 remains the
   recommended version.
+- 🟠 **FIXED** the Linux binaries (container, remoting) load again on Ubuntu 22.04 and the distributions with
+  glibc 2.35 or newer: those of 1.9.4.2, built on Ubuntu 24.04, required glibc 2.38.
 - 🔵 **CHANGED** `PySide6` (the GUI toolkit) is no longer installed by default. `pip install fmu-manipulation-toolbox`
   only installs the **CLI** (`fmutool`, `fmucontainer`, `fmusplit`, `datalog2pcap`) and the
   **Python API**, neither of which import `PySide6`. Extras: `gui` for the **Graphical User
@@ -31,6 +65,9 @@ API, 🟠 **FIXED** bug fix; 🔴 **BREAKING** marks what may require changes in
   sdist). The remoting code is now compiled in C23 with the same warnings and optimizations as the container
   (IPO/LTO, optional PGO). The build options are renamed `FMUTOOL_WARNINGS_AS_ERRORS`, `FMUTOOL_STRICT_CONVERSION`
   and `FMUTOOL_PGO` (formerly `CONTAINER_*`). See the [Installation Guide](docs/installation.md).
+- 🟢 **ADDED** native tests of the container runtime (`container/tests`, run by CTest and by the CI on every
+  platform) and the build option `FMUTOOL_SANITIZE` (AddressSanitizer and UndefinedBehaviorSanitizer), used by a new
+  CI job. See [Native runtime of the container](docs/developer/native-runtime.md).
 
 ## AI Assistant (MCP server)
 
@@ -79,11 +116,17 @@ API, 🟠 **FIXED** bug fix; 🔴 **BREAKING** marks what may require changes in
 
 ## FMU Container
 
+- 🟢 **ADDED** **several instances of the same FMU** in a container: each instance has its own name
+  (`bb_position-1.fmu`, ...) and its file in the new optional `path` block of the JSON; the Container Builder,
+  the MCP tools, SSP import and `fmusplit` handle them. See
+  [Embedding the same FMU several times](docs/user-guide/fmucontainer/container.md#embedding-the-same-fmu-several-times).
 - 🟠 **FIXED** a container called with a communication step that is not a multiple of its internal step (e.g. a
   sub-container at 0.02 s in a parent at 0.01 s) returned without reaching the end of the step, and made its
   internal step later with the inputs of a later instant. Each internal step now uses the inputs of its beginning
   and holds its outputs until its end; the warning "CommunicationStepSize should be divisible" is removed. See
   [Communication step and internal step](docs/user-guide/fmucontainer/container.md#communication-step-and-internal-step).
+- 🟠 **FIXED** a `TS_MULTIPLIER` below 1 (e.g. 0, received during the initialization) gave a nominal step of 0 and
+  a `doStep` of 0 to the embedded FMUs: it counts as 1, as it already did for the step of the container.
 - 🔵 **CHANGED** the container **propagates the links** between its embedded FMUs **during the initialization**:
   in the order of the links, each FMU gets its linked inputs, leaves its Initialization Mode, then its outputs are
   read for the FMUs after it, so that an FMU is initialized with the values of the FMUs it depends on (as Simulink
@@ -166,6 +209,9 @@ API, 🟠 **FIXED** bug fix; 🔴 **BREAKING** marks what may require changes in
 - 🟠 **FIXED** the runtime reads the lines of `container.txt` of any length: a line longer than 4095 characters
   (the start values of a large array, a string start value of more than 4095 characters) was cut and shifted the
   reading of the rest of the file, so that the container failed to instantiate.
+- 🟠 **FIXED** Windows: an embedded FMU, or an FMU run by the remoting server, whose DLL depends on other DLLs
+  shipped next to it in `binaries/win64` (or `win32`) failed to load. The dependencies of the DLL are now searched
+  first in its own directory.
 - 🔵 **CHANGED** the runtime checks the format version of `container.txt` and refuses, with an explicit error, a
   container whose `container.txt` does not come from the same version of the toolbox. See
   [Troubleshooting](docs/help/troubleshooting.md#fmu-container-fails-to-instantiate-format-version-of-containertxt).
@@ -180,6 +226,35 @@ API, 🟠 **FIXED** bug fix; 🔴 **BREAKING** marks what may require changes in
   simulation loop of Model-Exchange FMUs fed by Co-Simulation FMUs takes about a third less time (1.5 times
   faster), about 5 % less without coupling between them.
 
+- 🟠 **FIXED** several instances of containers in one process: each instance has its own logger. They overwrote
+  each other's logging callback and debug flag, and an instance could log through the name of an instance already
+  freed. `fmi2SetDebugLogging` / `fmi3SetDebugLogging` only change their own instance. A `NULL` logging callback,
+  allowed by FMI 3.0, no longer crashes.
+- 🟠 **FIXED** a multi-thread container whose configuration fails (e.g. an embedded FMU that cannot be
+  instantiated) crashed or hung when it was freed. The worker threads are started once all of them are launched,
+  and stopped only if they were.
+- 🟠 **FIXED** the container no longer changes the host process: the numeric locale of the importer is left
+  unchanged (`container.txt` is read with a decimal dot on the thread of the instantiation only), and on Windows
+  the priority class of the process is no longer raised (the worker threads keep a high priority).
+- 🟠 **FIXED** the runtime checks the values read from `container.txt`: value references, FMU indexes, clocks and
+  local variables out of range, malformed lines and too many start values are configuration errors instead of
+  out-of-bounds accesses. An embedded FMU that cannot be loaded no longer leaks the FMUs loaded before it.
+- 🟠 **FIXED** a container built on Windows could not load its embedded FMUs on Linux or macOS: the runtime kept the
+  `\r` of the CRLF line endings of `container.txt` in the names it reads.
+- 🟠 **FIXED** a start value refused by an embedded FMU went unnoticed: it is logged and makes the initialization
+  (or the reset of the FMU) fail. The start value of an FMI-3 array was given with one value instead of all of them.
+- 🟠 **FIXED** the instantiation returns `NULL` instead of crashing on an allocation failure or invalid arguments
+  (`NULL` callbacks, GUID or resource location).
+- 🟠 **FIXED** the `String` start values: an array of strings leaked all its values but the first one, and a
+  `container.txt` cut in their section crashed the importer when the container was freed. `fmi2FreeInstance` /
+  `fmi3FreeInstance` with a `NULL` instance are ignored, as FMI requires, instead of crashing.
+- 🟠 **FIXED** a path of the directory of an embedded FMU too long for the runtime is a configuration error: it was
+  cut without notice, and the FMU was looked for in a wrong directory.
+- 🔵 **CHANGED** datalog: the time and the reals are written with every significant digit (`%.17g`, `%.9g`
+  for `Float32`) instead of 7 and 6 decimals, always with a decimal dot; strings and column names with a comma, a
+  double quote or a line break are quoted (RFC 4180). See
+  [Container with datalog](docs/user-guide/fmucontainer/datalog.md#csv-format).
+
 ## fmutool and the Python API
 
 - 🟢 **ADDED** compilation of the sources embedded in an FMU when the binary of the current platform is missing:
@@ -262,13 +337,26 @@ API, 🟠 **FIXED** bug fix; 🔴 **BREAKING** marks what may require changes in
   search, **Save Logs…** and **Clear**. In `fmucontainer-gui`, the messages that were lost outside the progress
   dialog are now visible there, among them the `[AI] …` change journal and the token of the AI Assistant. See the
   [Container Builder GUI guide](docs/user-guide/fmucontainer/gui-usage.md#log).
-- 🔵 **CHANGED** `fmucontainer-gui`: **Verbose Mode** sets the level of the whole log (`DEBUG`) and copies it on the
-  standard output; without it, nothing is written on the standard output (the tree view and the AI Assistant used to
-  write their messages there in any case).
+- 🔵 **CHANGED** `fmucontainer-gui`: **Verbose Mode** sets the level of the log of its window (`DEBUG`) and copies
+  its messages on the standard output; without it, nothing is written on the standard output (the tree view and the
+  AI Assistant used to write their messages there in any case).
+- 🟠 **FIXED** `fmutoolbox`: the windows opened from the launcher shared one log. Each window now has its own: an
+  operation of an FMU Tool window, a build or a request of the AI Assistant of a Container Builder are only shown in
+  that window (log area, status bar, log window), **Clear** only forgets the messages of its window, and opening a
+  window no longer turns off the **Verbose Mode** of an open Container Builder. The few messages that do not come
+  from a window are shown in all of them. See the [Launcher guide](docs/user-guide/launcher.md).
 - 🟢 **ADDED** `fmucontainer-gui`: the `reset_ports` checkbox of a container (root included) adds a
   `<fmu>.reset` port per FMU, or sub-container, to the `configuration` node; a wire to it resets the FMU. Selecting
   the node lists its reset ports, to expose them as container inputs. See
   [The configuration Node](docs/user-guide/fmucontainer/gui-usage.md#the-configuration-node).
+- 🟢 **ADDED** `fmucontainer-gui`: a second, read-only, column of the tree view shows the step size of each FMU and
+  container; the step size of a container whose `step_size` is empty is the one deduced at build time, in italics.
+  See [Step Size Column](docs/user-guide/fmucontainer/gui-usage.md#step-size-column).
+- 🟠 **FIXED** `fmucontainer-gui`: the column headers of the **Link Assistant** (e.g. *Direction* of the staged links)
+  were truncated on Windows; a column is never narrower than its header.
+- 🟢 **ADDED** documentation: the criteria of the **Link Assistant** step by step, **Replace prefix / suffix** and
+  **Regular expression** with examples, a syntax reminder and the pitfalls. See
+  [Rules tab](docs/user-guide/fmucontainer/gui-usage.md#rules-tab).
 
 # Version 1.9.4.2
 * ADDED: Container thread synchronization on macOS now uses a semaphore instead of a barrier

{fmu_manipulation_toolbox-2.0b2 → fmu_manipulation_toolbox-2.1.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fmu_manipulation_toolbox
-Version: 2.0b2
+Version: 2.1.dev0
 Summary: FMU Manipulation Toolbox is a python package which helps to analyze, modify, validate, combine or split Functional Mock-up Units (FMUs) without recompilation, through a GUI, a CLI or a Python API.
 Author-email: Nicolas LAURENT <Nicolas.LAURENT@Renault.com>
 License-Expression: BSD-2-Clause
@@ -41,7 +41,7 @@ Requires-Dist: PySide6>=6.8.0; extra == "test"
 Requires-Dist: pytest>=9.0.3; extra == "test"
 Requires-Dist: pytest-qt>=4.4.0; extra == "test"
 Requires-Dist: pytest-cov>=7.0.0; extra == "test"
-Requires-Dist: coverage-badge>=1.1.2; extra == "test"
+Requires-Dist: anybadge>=1.16.0; extra == "test"
 Requires-Dist: fmpy>=0.3.20; extra == "test"
 Requires-Dist: numpy; extra == "test"
 Provides-Extra: all

{fmu_manipulation_toolbox-2.0b2 → fmu_manipulation_toolbox-2.1.dev0}/cmake/fmutool.cmake

@@ -6,6 +6,7 @@ set(FMUTOOL_CMAKE_DIR ${CMAKE_CURRENT_LIST_DIR})
 
 option(FMUTOOL_WARNINGS_AS_ERRORS "Treat compiler warnings as errors"       OFF)
 option(FMUTOOL_STRICT_CONVERSION  "Enable -Wconversion / -Wsign-conversion" OFF)
+option(FMUTOOL_SANITIZE           "Build with AddressSanitizer and UndefinedBehaviorSanitizer (GCC, Clang)" OFF)
 
 set(CMAKE_C_STANDARD 23)
 
@@ -83,6 +84,19 @@ else()
     if(FMUTOOL_STRICT_CONVERSION)
         target_compile_options(fmutool_flags INTERFACE -Wconversion -Wsign-conversion)
     endif()
+    if(FMUTOOL_SANITIZE)
+        # Any undefined behaviour aborts, so that a test fails on it.
+        target_compile_options(fmutool_flags INTERFACE
+            -fsanitize=address,undefined
+            -fno-sanitize-recover=undefined
+            -fno-omit-frame-pointer
+            -g
+        )
+        target_link_options(fmutool_flags INTERFACE -fsanitize=address,undefined)
+    endif()
+endif()
+if(FMUTOOL_SANITIZE AND MSVC)
+    message(FATAL_ERROR "FMUTOOL_SANITIZE is supported with GCC and Clang only.")
 endif()
 
 # -----------------------------------------------------------------------------
@@ -142,5 +156,6 @@ function(fmutool_summary)
     message(STATUS "  Build type  : ${CMAKE_BUILD_TYPE}${CMAKE_CONFIGURATION_TYPES}")
     message(STATUS "  IPO/LTO     : ${FMUTOOL_IPO_SUPPORTED}")
     message(STATUS "  Options     : FMUTOOL_WARNINGS_AS_ERRORS=${FMUTOOL_WARNINGS_AS_ERRORS}"
-                   " FMUTOOL_STRICT_CONVERSION=${FMUTOOL_STRICT_CONVERSION} FMUTOOL_PGO=${FMUTOOL_PGO}")
+                   " FMUTOOL_STRICT_CONVERSION=${FMUTOOL_STRICT_CONVERSION} FMUTOOL_PGO=${FMUTOOL_PGO}"
+                   " FMUTOOL_SANITIZE=${FMUTOOL_SANITIZE}")
 endfunction()

fmu_manipulation_toolbox-2.1.dev0/container/CMakeLists.txt

@@ -0,0 +1,123 @@
+cmake_minimum_required(VERSION 3.21)
+project(container C)
+include(${CMAKE_CURRENT_SOURCE_DIR}/../cmake/fmutool.cmake)
+
+# -----------------------------------------------------------------------------
+# FMI sanity check: FMI 2.0 and 3.0 data types must share the same storage.
+# -----------------------------------------------------------------------------
+try_run(test_fmi test_fmi_compilation
+    ${CMAKE_CURRENT_BINARY_DIR}
+    ${CMAKE_CURRENT_SOURCE_DIR}/test_fmi.c
+    CMAKE_FLAGS "-DINCLUDE_DIRECTORIES=${CMAKE_CURRENT_SOURCE_DIR}/../fmu_manipulation_toolbox/resources/fmi"
+    COMPILE_OUTPUT_VARIABLE test_fmi_compilation_output
+    RUN_OUTPUT_VARIABLE test_fmi_output
+)
+if(NOT test_fmi_compilation OR NOT test_fmi EQUAL 0)
+    message(FATAL_ERROR "FMI sanity check failed:\n${test_fmi_compilation_output}${test_fmi_output}")
+endif()
+
+# -----------------------------------------------------------------------------
+# container: the shared library embedded in the container FMUs.
+# -----------------------------------------------------------------------------
+set(CONTAINER_SOURCES
+    config.c    config.h
+    container.c container.h
+    convert.c   convert.h
+    datalog.c   datalog.h
+    fmi2.c
+    fmi3.c
+    fmu.c       fmu.h
+    hash.c      hash.h
+    library.c   library.h
+    logger.c    logger.h
+    profile.c   profile.h
+    solver.c    solver.h
+    thread.c    thread.h
+)
+
+# container_link_platform(<target>): system libraries of the runtime.
+function(container_link_platform target)
+    if(WIN32)
+        target_link_libraries(${target} PRIVATE Imagehlp.lib)
+    elseif(NOT APPLE)
+        target_link_libraries(${target} PRIVATE Threads::Threads)
+    endif()
+endfunction()
+
+add_library(container SHARED ${CONTAINER_SOURCES})
+container_link_platform(container)
+fmutool_native_target(container)
+
+# -----------------------------------------------------------------------------
+# Native tests: the sources of the runtime compiled again with the tests, so
+# that the internal functions can be called (the shared library exports only
+# the FMI API). Run with: ctest --test-dir <build dir> -C <config>
+# -----------------------------------------------------------------------------
+include(CTest)
+if(BUILD_TESTING)
+    add_executable(container_tests
+        ${CONTAINER_SOURCES}
+        tests/test.h
+        tests/test_main.c
+        tests/test_config.c
+        tests/test_configure.c
+        tests/test_logger.c
+        tests/test_locale.c
+        tests/test_malformed.c
+        tests/test_datalog.c
+        tests/test_thread.c
+        tests/test_threads_lifecycle.c
+    )
+    target_link_libraries(container_tests PRIVATE fmutool_flags)
+    target_include_directories(container_tests PRIVATE
+        ${CMAKE_CURRENT_SOURCE_DIR}
+        ${FMUTOOL_CMAKE_DIR}/../fmu_manipulation_toolbox/resources/fmi
+        ${CMAKE_CURRENT_BINARY_DIR}     # version.h
+    )
+    target_compile_definitions(container_tests PRIVATE
+        TEST_DATA_DIR="${CMAKE_CURRENT_SOURCE_DIR}/tests/data"
+        TEST_BINARY_DIR="${CMAKE_CURRENT_BINARY_DIR}"
+    )
+    container_link_platform(container_tests)
+    add_dependencies(container_tests version_h)
+    add_test(NAME container_tests COMMAND container_tests)
+
+    # FMI 2.0 FMU of the tests, embedded in the fixtures made of tests/data/one_fmu/container.txt.in.
+    add_library(stub_fmu MODULE tests/stub_fmu.c)
+    target_link_libraries(stub_fmu PRIVATE fmutool_flags)
+    target_include_directories(stub_fmu PRIVATE ${FMUTOOL_CMAKE_DIR}/../fmu_manipulation_toolbox/resources/fmi)
+    if(WIN32)
+        set(_stub_suffix ".dll")
+    elseif(APPLE)
+        set(_stub_suffix ".dylib")
+    else()
+        set(_stub_suffix ".so")
+    endif()
+    set_target_properties(stub_fmu PROPERTIES PREFIX "" SUFFIX "${_stub_suffix}" C_VISIBILITY_PRESET hidden)
+    add_dependencies(container_tests stub_fmu)
+
+    set(TEST_FIXTURES_DIR "${CMAKE_CURRENT_BINARY_DIR}/fixtures")
+    target_compile_definitions(container_tests PRIVATE TEST_FIXTURES_DIR="${TEST_FIXTURES_DIR}")
+
+    # container_fixture(<name> <guid> <mt>): container.txt with the stub FMU, given its GUID (which selects its
+    # behaviour, see tests/stub_fmu.c) and the multi-thread flag.
+    function(container_fixture name guid mt)
+        set(GUID "${guid}")
+        set(MT "${mt}")
+        set(_dir "${TEST_FIXTURES_DIR}/${name}")
+        configure_file(tests/data/one_fmu/container.txt.in "${_dir}/container.txt" @ONLY)
+        add_custom_command(TARGET stub_fmu POST_BUILD
+            COMMAND ${CMAKE_COMMAND} -E make_directory "${_dir}/00/binaries/${FMI_PLATFORM}"
+            COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:stub_fmu> "${_dir}/00/binaries/${FMI_PLATFORM}/stub${_stub_suffix}"
+        )
+    endfunction()
+    container_fixture(one_fmu               "{stub}"                    0)
+    container_fixture(one_fmu_datalog       "{stub}"                    0)
+    set(DATALOG_FILE "${TEST_FIXTURES_DIR}/one_fmu_datalog/datalog.csv")
+    configure_file(tests/data/one_fmu/datalog.txt.in "${TEST_FIXTURES_DIR}/one_fmu_datalog/datalog.txt" @ONLY)
+    container_fixture(one_fmu_mt            "{stub}"                    1)
+    container_fixture(mt_instantiate_fails  "{stub-fail-instantiate}"   1)
+    container_fixture(malformed             "{stub}"                    0)  # container.txt rewritten by the tests
+endif()
+
+fmutool_summary()

{fmu_manipulation_toolbox-2.0b2 → fmu_manipulation_toolbox-2.1.dev0}/container/config.c

@@ -15,6 +15,7 @@
  * Return 0, -1 at the end of the file, -2 when the buffer cannot grow.
  */
 static int read_line(config_file_t* config_file) {
+    const logger_t *logger = config_file->logger;
     size_t len = 0;
 
     config_file->line[0] = '\0';
@@ -27,7 +28,7 @@ static int read_line(config_file_t* config_file) {
 
         char *line = realloc(config_file->line, 2 * config_file->line_size);
         if (!line) {
-            logger(LOGGER_ERROR, "Cannot allocate memory to read line #%u.", config_file->line_number + 1);
+            LOGGER_ERROR("Cannot allocate memory to read line #%u.", config_file->line_number + 1);
             return -2;
         }
         config_file->line = line;
@@ -38,8 +39,10 @@ static int read_line(config_file_t* config_file) {
         return -1;
     config_file->line_number += 1;
 
-    /* CHOMP() */
+    /* CHOMP(): "\n" or "\r\n" (a file written on Windows, read on another platform) */
     if (config_file->line[len - 1] == '\n')
+        config_file->line[--len] = '\0';
+    if (len > 0 && config_file->line[len - 1] == '\r')
         config_file->line[len - 1] = '\0';
 
     return 0;
@@ -73,9 +76,10 @@ int config_file_version(config_file_t* config_file, int *version) {
 }
 
 
-int config_file_open(config_file_t* config_file, const char *dirname, const char *filename) {
+int config_file_open(config_file_t* config_file, const logger_t *logger, const char *dirname, const char *filename) {
     char full_path[CONFIG_FILE_SZ];
 
+    config_file->logger = logger;
     STRLCPY(full_path, dirname, sizeof(full_path));
     STRLCAT(full_path, "/", sizeof(full_path));
     STRLCAT(full_path, filename, sizeof(full_path));
@@ -83,20 +87,20 @@ int config_file_open(config_file_t* config_file, const char *dirname, const char
     config_file->line = NULL;
     config_file->fp = fopen(full_path, "rt");
     if (! config_file->fp) {
-        logger(LOGGER_DEBUG, "Cannot open configuration file '%s'.", full_path);
+        LOGGER_DEBUG("Cannot open configuration file '%s'.", full_path);
         return -1;
     }
 
     config_file->line_size = CONFIG_FILE_SZ;
     config_file->line = malloc(config_file->line_size);
     if (! config_file->line) {
-        logger(LOGGER_ERROR, "Cannot allocate memory to read configuration file '%s'.", full_path);
+        LOGGER_ERROR("Cannot allocate memory to read configuration file '%s'.", full_path);
         fclose(config_file->fp);
         config_file->fp = NULL;
         return -1;
     }
 
-    logger(LOGGER_DEBUG, "Reading '%s'...", filename);
+    LOGGER_DEBUG("Reading '%s'...", filename);
 
     config_file->line_number = 0;
 
@@ -114,6 +118,7 @@ void config_file_close(config_file_t* config_file) {
 }
 
 void config_file_error(config_file_t *config_file, unsigned int code_line_number, const char *message, ...) {
+    const logger_t *logger = config_file->logger;
     char message_buffer[256];
     va_list ap;
 
@@ -121,5 +126,70 @@ void config_file_error(config_file_t *config_file, unsigned int code_line_number
     vsnprintf(message_buffer, sizeof(message_buffer), message, ap);
     va_end(ap);
 
-    logger(LOGGER_ERROR, "Configuration error(%u): line #%u: %s", code_line_number, config_file->line_number, message_buffer);
+    LOGGER_ERROR("Configuration error(%u): line #%u: %s", code_line_number, config_file->line_number, message_buffer);
+}
+
+
+/*
+ * C numeric locale of the current thread: the configuration files and the datalog use a decimal dot whatever the
+ * locale of the host. enter / leave switch the current thread only; they may be called several times.
+ */
+int config_c_locale_init(config_c_locale_t *c_locale) {
+#ifdef _WIN32
+    c_locale->per_thread = 0;
+    c_locale->previous = NULL;
+    c_locale->locale = _create_locale(LC_NUMERIC, "C");
+    return c_locale->locale ? 0 : -1;
+#else
+    c_locale->previous = (locale_t)0;
+    locale_t base = duplocale(LC_GLOBAL_LOCALE);
+    if (!base)
+        return -1;
+    c_locale->c_locale = newlocale(LC_NUMERIC_MASK, "C", base);
+    if (!c_locale->c_locale) {
+        freelocale(base);
+        return -1;
+    }
+    return 0;
+#endif
+}
+
+
+void config_c_locale_enter(config_c_locale_t *c_locale) {
+#ifdef _WIN32
+    c_locale->per_thread = _configthreadlocale(_ENABLE_PER_THREAD_LOCALE);
+    const char *previous = setlocale(LC_NUMERIC, NULL);
+    c_locale->previous = previous ? _strdup(previous) : NULL;
+    setlocale(LC_NUMERIC, "C");
+#else
+    c_locale->previous = uselocale(c_locale->c_locale);
+#endif
+}
+
+
+void config_c_locale_leave(config_c_locale_t *c_locale) {
+#ifdef _WIN32
+    if (c_locale->previous) {
+        setlocale(LC_NUMERIC, c_locale->previous);
+        free(c_locale->previous);
+        c_locale->previous = NULL;
+    }
+    if (c_locale->per_thread != -1)
+        _configthreadlocale(c_locale->per_thread);
+#else
+    if (c_locale->previous)
+        uselocale(c_locale->previous);
+    c_locale->previous = (locale_t)0;
+#endif
+}
+
+
+void config_c_locale_free(config_c_locale_t *c_locale) {
+#ifdef _WIN32
+    free(c_locale->previous);
+    c_locale->previous = NULL;
+    _free_locale(c_locale->locale);
+#else
+    freelocale(c_locale->c_locale);
+#endif
 }

{fmu_manipulation_toolbox-2.0b2 → fmu_manipulation_toolbox-2.1.dev0}/container/config.h

@@ -6,6 +6,10 @@ extern "C" {
 #	endif
 
 #include <stdio.h>
+#include <locale.h>
+#ifdef __APPLE__
+#   include <xlocale.h>
+#endif
 
 
 #ifdef _WIN32
@@ -25,7 +29,10 @@ extern "C" {
                         C O N F I G _ F I L E _ T
 ----------------------------------------------------------------------------*/
 #define CONFIG_FILE_SZ			4096	/* size of the path buffers, initial size of the line buffer */
+struct logger_s;
+
 typedef struct {
+	const struct logger_s		*logger;	/* logger of the container that reads the file */
 	FILE						*fp;
 	char						*line;		/* current line, grown to hold a line of any length */
 	size_t						line_size;
@@ -33,14 +40,36 @@ typedef struct {
 } config_file_t;
 
 
+/*----------------------------------------------------------------------------
+                      C O N F I G _ C _ L O C A L E _ T
+----------------------------------------------------------------------------*/
+
+/* C numeric locale (decimal dot) for the current thread only: the locale of the host is never changed. */
+typedef struct {
+#ifdef _WIN32
+    _locale_t                   locale;     /* C numeric locale, for the _l functions (_fprintf_l...) */
+    int                         per_thread; /* setting of _configthreadlocale() before enter */
+    char                        *previous;  /* LC_NUMERIC of the thread before enter */
+#else
+    locale_t                    c_locale;   /* copy of the global locale with the C numeric category */
+    locale_t                    previous;   /* locale of the thread before enter */
+#endif
+} config_c_locale_t;
+
+
 /*----------------------------------------------------------------------------
                             P R O T O T Y P E S
 ----------------------------------------------------------------------------*/
 
 int get_line(config_file_t* config_file);
 extern int config_file_version(config_file_t* config_file, int *version);
-extern int config_file_open(config_file_t* config_file, const char *dirname, const char *filename);
+extern int config_file_open(config_file_t* config_file, const struct logger_s *logger, const char *dirname,
+                            const char *filename);
 extern void config_file_close(config_file_t* config_file);
+extern int config_c_locale_init(config_c_locale_t *c_locale);
+extern void config_c_locale_enter(config_c_locale_t *c_locale);
+extern void config_c_locale_leave(config_c_locale_t *c_locale);
+extern void config_c_locale_free(config_c_locale_t *c_locale);
 extern void config_file_error(config_file_t *config_file, unsigned int code_line_number, const char *message, ...) __attribute__((__format__(__printf__, 3, 4)));
 
 #	ifdef __cplusplus