Add a Logger class

src/ivoc/ivoc.cpp

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

src/ivoc/strfun.cpp

@@ -58,7 +58,7 @@ static double l_head(void*) {
             result = sm.prefix().str();
         }
     } catch (const std::regex_error& e) {
-        Fprintf(stderr, fmt::format("{}\n", e.what()).c_str());
+        logger.error("{}\n", e.what());
     }
     char** head = hoc_pgargstr(3);
     hoc_assign_str(head, result.c_str());
@@ -84,7 +84,7 @@ static double l_tail(void*) {
             result = sm.suffix().str();
         }
     } catch (const std::regex_error& e) {
-        Fprintf(stderr, fmt::format("{}\n", e.what()).c_str());
+        logger.error("{}\n", e.what());
     }
     char** tail = hoc_pgargstr(3);
     hoc_assign_str(tail, result.c_str());

src/neuron/container/soa_identifier.hpp

@@ -168,14 +168,12 @@ 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.
-            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());
+            logger.error(
+                "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()));
             terminate = true;
         }
         if (terminate) {

src/neuronmusic/nrnmusic_dynam.cpp

@@ -27,12 +27,12 @@ static void load_music() {
     // every rank if nhost is large. So demand ...
     const_char_ptr music_path = const_char_ptr{std::getenv("NRN_LIBMUSIC_PATH")};
     if (!music_path) {
-        Fprintf(stderr, "No NRN_LIBMUSIC_PATH environment variable for full path to libmusic\n");
+        logger.error("No NRN_LIBMUSIC_PATH environment variable for full path to libmusic\n");
         exit(1);
     }
     handle = dlopen(music_path, RTLD_NOW | RTLD_GLOBAL);
     if (!handle) {
-        Fprintf(stderr, "%s", dlerror());
+        logger.error(dlerror());
         exit(1);
     }
 }
@@ -67,7 +67,7 @@ void nrnmusic_load() {
 
     void* handle = dlopen(nrnmusic_library.c_str(), RTLD_NOW | RTLD_GLOBAL);
     if (!handle) {
-        Fprintf(stderr, "%s\n", dlerror());
+        logger.error("{}\n", dlerror());
         exit(1);
     }
     assert(handle);

src/nrncvode/netcvode.cpp

@@ -5578,10 +5578,9 @@ static int trajec_buffered(NrnThread& nt,
     } else {
         err = nrn_dblpntr2nrncore(pd, nt, types[i_trajec], indices[i_trajec]);
         if (err) {
-            Fprintf(stderr,
-                    "Pointer %p of PlayRecord type %d ignored because not a Range Variable",
-                    fmt::ptr(static_cast<double*>(pd)),
-                    pr->type());
+            logger.error("Pointer {} of PlayRecord type {} ignored because not a Range Variable",
+                         fmt::ptr(static_cast<double*>(pd)),
+                         pr->type());
         }
     }
     return err;

src/nrniv/nrncore_write/callbacks/nrncore_callbacks.cpp

@@ -1015,12 +1015,12 @@ static void set_info(TQItem* tqi,
         core_te->type.pop_back();
         // Delivery time was often reduced by a quarter step to avoid
         // fixed step roundoff problems.
-        Fprintf(stderr,
-                "WARNING: CVode.event(...) for delivery at time step nearest %g discarded. "
-                "CoreNEURON cannot presently handle interpreter events (rank %d, thread %d).\n",
-                tdeliver,
-                nrnmpi_myid,
-                tid);
+        logger.error(
+            "WARNING: CVode.event(...) for delivery at time step nearest {} discarded. "
+            "CoreNEURON cannot presently handle interpreter events (rank {}, thread {}).\n",
+            tdeliver,
+            nrnmpi_myid,
+            tid);
     } break;
     case PlayRecordEventType: {  // 6
     } break;

src/nrniv/nrnpy.cpp

@@ -16,6 +16,8 @@
 #include <cctype>
 #include <sstream>
 
+#include <fmt/ranges.h>  // for the formatter of std::array
+
 namespace neuron::python {
 // Declared extern in nrnpy.h, defined here.
 impl_ptrs methods;
@@ -217,15 +219,12 @@ void nrnpython_reg() {
             try {
                 set_nrnpylib();
             } catch (std::exception const& e) {
-                Fprintf(stderr,
-                        fmt::format("Could not determine Python library details: {}\n", e.what())
-                            .c_str());
+                logger.error("Could not determine Python library details: {}\n", e.what());
                 exit(1);
             }
             handle = dlopen(nrnpy_pylib.c_str(), RTLD_NOW | RTLD_GLOBAL);
             if (!handle) {
-                Fprintf(stderr,
-                        fmt::format("Could not dlopen NRN_PYLIB: {}\n", nrnpy_pylib).c_str());
+                logger.error("Could not dlopen NRN_PYLIB: {}\n", nrnpy_pylib);
 #if DARWIN
                 nrn_possible_mismatched_arch(nrnpy_pylib.c_str());
 #endif
@@ -263,12 +262,9 @@ static nrnpython_reg_real_t load_nrnpython() {
         pyversion = std::to_string(pv10 / factor) + "." + std::to_string(pv10 % factor);
     } else {
         if (nrnpy_pylib.empty() || nrnpy_pyversion.empty()) {
-            Fprintf(
-                stderr,
-                fmt::format("Do not know what Python to load [nrnpy_pylib={} nrnpy_pyversion={}]\n",
-                            nrnpy_pylib,
-                            nrnpy_pyversion)
-                    .c_str());
+            logger.error("Do not know what Python to load [nrnpy_pylib={} nrnpy_pyversion={}]\n",
+                         nrnpy_pylib,
+                         nrnpy_pyversion);
             return nullptr;
         }
         pyversion = nrnpy_pyversion;
@@ -279,18 +275,13 @@ static nrnpython_reg_real_t load_nrnpython() {
         auto const iter =
             std::find(supported_versions.begin(), supported_versions.end(), pyversion);
         if (iter == supported_versions.end()) {
-            Fprintf(
-                stderr,
-                fmt::format("Python {} is not supported by this NEURON installation (supported:",
-                            pyversion)
-                    .c_str());
-            for (auto const& good_ver: supported_versions) {
-                Fprintf(stderr, fmt::format(" {}", good_ver).c_str());
-            }
-            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");
+            logger.error(
+                "Python {} is not supported by this NEURON installation (supported: {}). 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",
+                pyversion,
+                supported_versions);
             return nullptr;
         }
     }
@@ -306,15 +297,13 @@ static nrnpython_reg_real_t load_nrnpython() {
 #endif
     auto* const handle = dlopen(name.c_str(), RTLD_NOW);
     if (!handle) {
-        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());
+        logger.error("Could not load {}\n", name);
+        logger.error("nrn_is_python_extension={}\n", nrn_is_python_extension);
         return nullptr;
     }
     auto* const reg = reinterpret_cast<nrnpython_reg_real_t>(dlsym(handle, "nrnpython_reg_real"));
     if (!reg) {
-        Fprintf(stderr,
-                fmt::format("Could not load registration function from {}\n", name).c_str());
+        logger.error("Could not load registration function from {}\n", name);
     }
     return reg;
 }

src/nrnmpi/nrnmpi_dynam.cpp

@@ -175,7 +175,7 @@ std::string nrnmpi_load() {
             return true;
         };
         if (!promote_to_global("libnrniv.so") && !promote_to_global("libnrniv-without-nvidia.so")) {
-            Fprintf(stderr, fmt::format("{} to RTLD_GLOBAL\n", error).c_str());
+            logger.error("{} to RTLD_GLOBAL\n", error);
         }
     }
 #endif

src/nrnoc/cabcode.cpp

@@ -1058,10 +1058,9 @@ Prop* nrn_mechanism_check(int type, Section* sec, int inode) {
     m = nrn_mechanism(type, sec->pnode[inode]);
     if (!m) {
         if (hoc_execerror_messages) {
-            Fprintf(stderr,
-                    "%s mechanism not inserted in section %s\n",
-                    memb_func[type].sym->name,
-                    secname(sec));
+            logger.error("{} mechanism not inserted in section {}\n",
+                         memb_func[type].sym->name,
+                         secname(sec));
         }
         hoc_execerror("", (char*) 0);
     }

src/nrnoc/eion.cpp

@@ -263,10 +263,10 @@ void nrn_verify_ion_charge_defined() {
         if (nrn_is_ion(i)) {
             if (global_charge(i) == VAL_SENTINAL) {
                 Symbol* s = memb_func[i].sym;
-                Fprintf(stderr,
-                        "%s USEION CHARGE (or VALENCE) must be defined in\n\
+                logger.error(
+                    "{} USEION CHARGE (or VALENCE) must be defined in\n\
 at least one model using this ion\n",
-                        s->name);
+                    s->name);
                 nrn_exit(1);
             }
         }

src/nrnoc/init.cpp

@@ -239,12 +239,9 @@ void* nrn_realpath_dlopen(const char* relpath, int flags) {
     } catch (const std::filesystem::filesystem_error& e) {
         handle = dlopen(relpath, flags);
         if (!handle) {
-            Fprintf(
-                stderr,
-                fmt::format("std::filesystem::absolute failed ({}) and dlopen failed with '{}'\n",
-                            e.what(),
-                            relpath)
-                    .c_str());
+            logger.error("std::filesystem::absolute failed ({}) and dlopen failed with '{}'\n",
+                         e.what(),
+                         relpath);
 #if DARWIN
             nrn_possible_mismatched_arch(relpath);
 #endif
@@ -312,12 +309,13 @@ void hoc_last_init(void) {
     hoc_register_var(scdoub, (DoubVec*) 0, (VoidFunc*) 0);
     nrn_threads_create(1, false);  // single thread
 
-    if (nrnmpi_myid < 1)
+    if (nrnmpi_myid < 1) {
         if (nrn_nobanner_ == 0) {
-            Fprintf(stderr, "%s\n", nrn_version(1));
-            Fprintf(stderr, "%s\n", banner);
+            logger.error("{}\n", nrn_version(1));
+            logger.error("{}\n", banner);
             IGNORE(fflush(stderr));
         }
+    }
     memb_func_size_ = 30;  // initial allocation size
     memb_list.reserve(memb_func_size_);
     memb_func.resize(memb_func_size_);  // we directly resize because it is used below
@@ -700,21 +698,21 @@ void check_mech_version(const char** m) {
     /*printf("%s %s\n", m[0], m[1]);*/
     if (strcmp(m[0], "0") == 0) { /* valid by nature */
     } else if (m[0][0] > '9') {   /* must be 5.1 or before */
-        Fprintf(stderr,
-                "Mechanism %s needs to be re-translated.\n\
-It's pre version 6.0 \"c\" code is incompatible with this neuron version.\n",
-                m[0]);
+        logger.error(
+            "Mechanism {} needs to be re-translated.\n"
+            "It's pre version 6.0 \"c\" code is incompatible with this neuron version.\n",
+            m[0]);
         if (nrn_load_dll_recover_error()) {
             hoc_execerror("Mechanism needs to be retranslated:", m[0]);
         } else {
             nrn_exit(1);
         }
     } else if (strcmp(m[0], nmodl_version_) != 0) {
-        Fprintf(stderr,
-                "Mechanism %s needs to be re-translated.\n\
-It's version %s \"c\" code is incompatible with this neuron version.\n",
-                m[1],
-                m[0]);
+        logger.error(
+            "Mechanism {} needs to be re-translated.\n"
+            "It's version {} \"c\" code is incompatible with this neuron version.\n",
+            m[1],
+            m[0]);
         if (nrn_load_dll_recover_error()) {
             hoc_execerror("Mechanism needs to be retranslated:", m[1]);
         } else {

src/nrnoc/solve.cpp

@@ -359,7 +359,7 @@ void nrn_solve(NrnThread* _nt) {
         nrn_thread_error("debugsolve");
         err = debugsolve();
         if (err > 1.e-10) {
-            Fprintf(stderr, "solve error = %g\n", err);
+            logger.error("solve error = {}\n", err);
         }
     }
 #else