Use Printf/Fprintf instead of std::cout, std::cerr

src/ivoc/ivoc.cpp

@@ -373,12 +373,12 @@ int Oc::run(const char* buf, bool show_err_mes) {
         err = hoc_oc(buf);
     } catch (std::exception const& e) {
         if (show_err_mes) {
-            std::cerr << "Oc::run: caught exception";
+            Fprintf(stderr, "Oc::run: caught exception");
             std::string_view what{e.what()};
             if (!what.empty()) {
-                std::cerr << ": " << what;
+                Fprintf(stderr, fmt::format(": {}", what).c_str());
             }
-            std::cerr << std::endl;
+            Fprintf(stderr, "\n");
         }
         err = 1;
     }

src/ivoc/ivocmain.cpp

@@ -42,6 +42,8 @@ void iv_display_scale(float);
 #include <IV-X11/ivx11_dynam.h>
 #endif
 
+#include <fmt/format.h>
+
 #if 1
 void pr_profile();
 #define PR_PROFILE pr_profile();
@@ -312,7 +314,7 @@ void hoc_nrnmpi_init() {
         nrnmpi_stubs();
         auto const pmes = nrnmpi_load();
         if (!pmes.empty()) {
-            std::cout << pmes << std::endl;
+            Printf(fmt::format("{}\n", pmes).c_str());
         }
 #endif
 

src/ivoc/strfun.cpp

@@ -14,6 +14,9 @@
 #if HAVE_IV
 #include <ocbox.h>
 #endif
+
+#include <fmt/format.h>
+
 extern Objectdata* hoc_top_level_data;
 extern Symlist* hoc_built_in_symlist;
 extern int nrn_is_artificial(int);
@@ -55,7 +58,7 @@
             result = sm.prefix().str();
         }
     } catch (const std::regex_error& e) {
-        std::cerr << e.what() << std::endl;
+        Fprintf(stderr, fmt::format("{}\n", e.what()).c_str());
     }
     char** head = hoc_pgargstr(3);
     hoc_assign_str(head, result.c_str());
@@ -81,7 +84,7 @@
             result = sm.suffix().str();
         }
     } catch (const std::regex_error& e) {
-        std::cerr << e.what() << std::endl;
+        Fprintf(stderr, fmt::format("{}\n", e.what()).c_str());
     }
     char** tail = hoc_pgargstr(3);
     hoc_assign_str(tail, result.c_str());

src/neuron/container/soa_identifier.hpp

@@ -11,6 +11,10 @@
 #include <ostream>
 #include <vector>
 
+#include <fmt/format.h>
+
+#include "hocdec.h"
+
 namespace neuron::container {
 /**
  * @brief A non-owning permutation-stable identifier for a entry in a container.
@@ -164,11 +168,14 @@ struct owning_identifier {
             //   auto const read_only_token = node_data.issue_frozen_token();
             //   list_of_nodes.pop_back();
             // which tries to delete a row from a container in read-only mode.
-            std::cerr << "neuron::container::owning_identifier<"
-                      << cxx_demangle(typeid(Storage).name())
-                      << "> destructor could not delete from the underlying storage: " << e.what()
-                      << " [" << cxx_demangle(typeid(e).name())
-                      << "]. This is not recoverable, aborting." << std::endl;
+            Fprintf(stderr,
+                    fmt::format(
+                        "neuron::container::owning_identifier<{}> destructor could not delete from "
+                        "the underlying storage: {} [{}]. This is not recoverable, aborting.\n",
+                        cxx_demangle(typeid(Storage).name()),
+                        e.what(),
+                        cxx_demangle(typeid(e).name()))
+                        .c_str());
             terminate = true;
         }
         if (terminate) {

src/nrniv/memory_usage.cpp

@@ -2,6 +2,9 @@
 #include <neuron/cache/model_data.hpp>
 #include <stdexcept>
 #include "oc_ansi.h"
+#include "hocdec.h"
+
+#include <fmt/format.h>
 
 namespace neuron::container {
 ModelMemoryUsage memory_usage(const Model& model) {
@@ -134,7 +137,7 @@ std::string format_memory_usage(const MemoryUsage& usage) {
 
 
 void print_memory_usage(MemoryUsage const& memory_usage) {
-    std::cout << format_memory_usage(memory_usage) << "\n";
+    Printf(fmt::format("{}\n", format_memory_usage(memory_usage)).c_str());
 }
 
 }  // namespace neuron::container

src/nrniv/nrncore_write/utils/nrncore_utils.cpp

@@ -105,7 +105,7 @@
     int nlfp = vector_capacity(lfp);
 
     if (nsec != nseg) {
-        std::cout << "Error: Section and Segment mapping vectors should have same size!\n";
+        Printf("Error: Section and Segment mapping vectors should have same size!\n");
         abort();
     }
 

src/nrniv/nrnpy.cpp

@@ -163,8 +163,9 @@
                 line.remove_prefix(prefix.size());
                 line.remove_suffix(suffix.size());
                 if (!glob_var.empty() && glob_var != line) {
-                    std::cout << "WARNING: overriding " << env_var << '=' << glob_var << " with "
-                              << line << std::endl;
+                    Printf(fmt::format(
+                               "WARNING: overriding {} = {} with {}\n", env_var, glob_var, line)
+                               .c_str());
                 }
                 glob_var = line;
             }
@@ -216,13 +217,15 @@
             try {
                 set_nrnpylib();
             } catch (std::exception const& e) {
-                std::cerr << "Could not determine Python library details: " << e.what()
-                          << std::endl;
+                Fprintf(stderr,
+                        fmt::format("Could not determine Python library details: {}\n", e.what())
+                            .c_str());
                 exit(1);
             }
             handle = dlopen(nrnpy_pylib.c_str(), RTLD_NOW | RTLD_GLOBAL);
             if (!handle) {
-                std::cerr << "Could not dlopen NRN_PYLIB: " << nrnpy_pylib << std::endl;
+                Fprintf(stderr,
+                        fmt::format("Could not dlopen NRN_PYLIB: {}\n", nrnpy_pylib).c_str());
 #if DARWIN
                 nrn_possible_mismatched_arch(nrnpy_pylib.c_str());
 #endif
@@ -260,8 +263,12 @@
         pyversion = std::to_string(pv10 / factor) + "." + std::to_string(pv10 % factor);
     } else {
         if (nrnpy_pylib.empty() || nrnpy_pyversion.empty()) {
-            std::cerr << "Do not know what Python to load [nrnpy_pylib=" << nrnpy_pylib
-                      << " nrnpy_pyversion=" << nrnpy_pyversion << ']' << std::endl;
+            Fprintf(
+                stderr,
+                fmt::format("Do not know what Python to load [nrnpy_pylib={} nrnpy_pyversion={}]\n",
+                            nrnpy_pylib,
+                            nrnpy_pyversion)
+                    .c_str());
             return nullptr;
         }
         pyversion = nrnpy_pyversion;
@@ -272,15 +279,18 @@
         auto const iter =
             std::find(supported_versions.begin(), supported_versions.end(), pyversion);
         if (iter == supported_versions.end()) {
-            std::cerr << "Python " << pyversion
-                      << " is not supported by this NEURON installation (supported:";
+            Fprintf(
+                stderr,
+                fmt::format("Python {} is not supported by this NEURON installation (supported:",
+                            pyversion)
+                    .c_str());
             for (auto const& good_ver: supported_versions) {
-                std::cerr << ' ' << good_ver;
+                Fprintf(stderr, fmt::format(" {}", good_ver).c_str());
             }
-            std::cerr << "). If you are seeing this message, your environment probably contains "
-                         "NRN_PYLIB, NRN_PYTHONEXE and NRN_PYTHONVERSION settings that are "
-                         "incompatible with this NEURON. Try unsetting them."
-                      << std::endl;
+            Fprintf(stderr,
+                    "). If you are seeing this message, your environment probably contains "
+                    "NRN_PYLIB, NRN_PYTHONEXE and NRN_PYTHONVERSION settings that are "
+                    "incompatible with this NEURON. Try unsetting them.\n");
             return nullptr;
         }
     }
@@ -296,13 +306,15 @@
 #endif
     auto* const handle = dlopen(name.c_str(), RTLD_NOW);
     if (!handle) {
-        std::cerr << "Could not load " << name << std::endl;
-        std::cerr << "nrn_is_python_extension=" << nrn_is_python_extension << std::endl;
+        Fprintf(stderr, fmt::format("Could not load {}\n", name).c_str());
+        Fprintf(stderr,
+                fmt::format("nrn_is_python_extension={}\n", nrn_is_python_extension).c_str());
         return nullptr;
     }
     auto* const reg = reinterpret_cast<nrnpython_reg_real_t>(dlsym(handle, "nrnpython_reg_real"));
     if (!reg) {
-        std::cerr << "Could not load registration function from " << name << std::endl;
+        Fprintf(stderr,
+                fmt::format("Could not load registration function from {}\n", name).c_str());
     }
     return reg;
 }

src/nrnmpi/memory_usage.cpp

@@ -14,6 +14,9 @@
 
 #include <iostream>
 
+#include "hocdec.h"
+#include <fmt/format.h>
+
 #include "neuron/container/memory_usage.hpp"
 
 static void sum_reduce_memory_usage(void* invec, void* inoutvec, int* len_, MPI_Datatype*) {
@@ -44,7 +47,7 @@
 
 void nrnmpi_print_memory_stats(neuron::container::MemoryStats const& memory_stats) {
     if (nrnmpi_myid_world == 0) {
-        std::cout << format_memory_usage(memory_stats.total) << "\n";
+        Printf(fmt::format("{}\n", format_memory_usage(memory_stats.total)).c_str());
     }
 }
 #endif

src/nrnmpi/nrnmpi_dynam.cpp

@@ -17,6 +17,9 @@
 
 #include "nrnmpi.h"
 
+#include "hocdec.h"
+#include <fmt/format.h>
+
 extern char* cxx_char_alloc(size_t);
 extern std::string corenrn_mpi_library;
 
@@ -173,7 +176,7 @@ std::string nrnmpi_load() {
             return true;
         };
         if (!promote_to_global("libnrniv.so") && !promote_to_global("libnrniv-without-nvidia.so")) {
-            std::cerr << error << " to RTLD_GLOBAL" << std::endl;
+            Fprintf(stderr, fmt::format("{} to RTLD_GLOBAL\n", error).c_str());
         }
     }
 #endif
@@ -258,7 +261,7 @@ std::string nrnmpi_load() {
 void nrnmpi_load_or_exit() {
     auto const err = nrnmpi_load();
     if (!err.empty()) {
-        std::cout << err << std::endl;
+        Printf(fmt::format("{}\n", err).c_str());
         std::exit(1);
     }
 }

src/nrnoc/init.cpp

@@ -239,8 +239,12 @@
     } catch (const std::filesystem::filesystem_error& e) {
         handle = dlopen(relpath, flags);
         if (!handle) {
-            std::cerr << "std::filesystem::absolute failed (" << e.what()
-                      << ") and dlopen failed with '" << relpath << "'" << std::endl;
+            Fprintf(
+                stderr,
+                fmt::format("std::filesystem::absolute failed ({}) and dlopen failed with '{}'\n",
+                            e.what(),
+                            relpath)
+                    .c_str());
 #if DARWIN
             nrn_possible_mismatched_arch(relpath);
 #endif

src/nrnoc/treeset.cpp

@@ -30,6 +30,8 @@
 #include <algorithm>
 #include <string>
 
+#include <fmt/format.h>
+
 extern spREAL* spGetElement(char*, int, int);
 
 int nrn_shape_changed_; /* for notifying Shape class in nrniv */
@@ -2168,7 +2170,7 @@
         // objects. In this case we can figure out which the missing entries are and permute them to
         // the end of the global vectors.
         auto missing_elements = node_data_size - global_i;
-        std::cout << "permuting " << missing_elements << " 'lost' Nodes to the end\n";
+        Printf(fmt::format("permuting {} 'lost' Nodes to the end\n", missing_elements).c_str());
         // There are `missing_elements` integers from the range [0 .. node_data_size-1] whose values
         // in `node_data_permutation` are still std::numeric_limits<std::size_t>::max().
         for (auto global_row = 0ul; global_row < node_data_size; ++global_row) {

src/nrnpython/nrnpy_p2h.cpp

@@ -732,7 +732,7 @@
     if (!result) {
         char* mes = nrnpyerr_str();
         if (mes) {
-            std::cerr << mes << std::endl;
+            Fprintf(stderr, fmt::format("{}\n", mes).c_str());
             free(mes);
             hoc_execerror("PyObject method call failed:", NULL);
         }

src/nrnpython/nrnpython.cpp

@@ -124,7 +124,7 @@
     if (fp) {
         nrnpython_set_path(fname);
     } else {
-        std::cerr << "Could not open " << fname << std::endl;
+        Fprintf(stderr, fmt::format("Could not open {}\n", fname).c_str());
         return 0;
     }
     fclose(fp);
@@ -193,7 +193,7 @@
     if (b == 1 && !started) {
         p_nrnpy_pyrun = nrnpy_pyrun;
         if (nrnpy_nositeflag) {
             Py_NoSiteFlag = 1;
         }
         // Create a Python configuration, see
         // https://docs.python.org/3.8/c-api/init_config.html#python-configuration, so that

src/oc/hoc.cpp

@@ -32,6 +32,8 @@
 #include <thread>
 #include <utility>
 
+#include <fmt/format.h>
+
 /* for eliminating "ignoreing return value" warnings. */
 int nrnignore;
 
@@ -928,7 +930,7 @@
         }
         return exit_status;
     } catch (std::exception const& e) {
-        std::cerr << "hoc_main1 caught exception: " << e.what() << std::endl;
+        Fprintf(stderr, fmt::format("hoc_main1 caught exception: {}\n", e.what()).c_str());
         nrn_exit(1);
     }
 }
@@ -1250,12 +1252,12 @@
                 }
             } catch (std::exception const& e) {
                 hoc_fin = sav_fin;
-                std::cerr << "hoc_run1: caught exception";
+                Fprintf(stderr, "hoc_run1: caught exception");
                 std::string_view what{e.what()};
                 if (!what.empty()) {
-                    std::cerr << ": " << what;
+                    Fprintf(stderr, fmt::format(": {}", what).c_str());
                 }
-                std::cerr << std::endl;
+                Fprintf(stderr, "\n");
                 // Exit if we're not in interactive mode
                 if (!nrn_fw_eq(hoc_fin, stdin)) {
                     return EXIT_FAILURE;

src/oc/hoc_oop.cpp

@@ -20,7 +20,6 @@
 #include "nrnfilewrap.h"
 #include "ocfunc.h"
 
-
 #define PDEBUG 0
 
 Symbol* nrnpy_pyobj_sym_{};
@@ -1060,7 +1059,7 @@
                     auto err = fmt::format("'{}' not a public member of '{}'",
                                            sym0->name,
                                            obp->ctemplate->sym->name);
-                    std::cerr << err << std::endl;
+                    Fprintf(stderr, fmt::format("{}\n", err).c_str());
                     hoc_execerror(err.c_str(), nullptr);
                 }
                 *ptid = obp->ctemplate->id;