Enable trivial cases of global state variables.

src/codegen/codegen_neuron_cpp_visitor.cpp

@@ -225,10 +225,13 @@
 }
 
 
-/// TODO: Edit for NEURON
 std::string CodegenNeuronCppVisitor::global_variable_name(const SymbolType& symbol,
                                                           bool use_instance) const {
-    return symbol->get_name();
+    if (use_instance) {
+        return fmt::format("inst.{}->{}", naming::INST_GLOBAL_MEMBER, symbol->get_name());
+    } else {
+        return fmt::format("{}.{}", global_struct_instance(), symbol->get_name());
+    }
 }
 
 
@@ -391,6 +394,8 @@
 
 
 void CodegenNeuronCppVisitor::print_mechanism_global_var_structure(bool print_initializers) {
+    const auto value_initialize = print_initializers ? "{}" : "";
+
     /// TODO: Print only global variables printed in NEURON
     printer->add_newline(2);
     printer->add_line("/* NEURON global variables */");
@@ -405,6 +410,73 @@
                       info.pointer_variables.size() > 0
                           ? static_cast<int>(info.pointer_variables.size())
                           : -1);
+
+    // Start printing the CNRN-style global variables.
+    auto float_type = default_float_data_type();
+    printer->add_newline(2);
+    printer->add_line("/** all global variables */");
+    printer->fmt_push_block("struct {}", global_struct());
+
+    if (!info.ions.empty()) {
+        // TODO implement these when needed.
+    }
+
+    if (info.point_process) {
+        throw std::runtime_error("Not implemented, global point process.");
+    }
+
+    if (!info.vectorize && !info.top_local_variables.empty()) {
+        throw std::runtime_error("Not implemented, global vectorize something.");
+    }
+
+    if (!info.thread_variables.empty()) {
+        throw std::runtime_error("Not implemented, global thread variables.");
+    }
+
+    if (info.table_count > 0) {
+        throw std::runtime_error("Not implemented, global table count.");
+    }
+
+    for (const auto& var: info.state_vars) {
+        auto name = var->get_name() + "0";
+        auto symbol = program_symtab->lookup(name);
+        if (symbol == nullptr) {
+            printer->fmt_line("{} {}{};", float_type, name, value_initialize);
+            codegen_global_variables.push_back(make_symbol(name));
+        }
+    }
+
+    for (const auto& var: info.global_variables) {
+        auto name = var->get_name();
+        auto length = var->get_length();
+        if (var->is_array()) {
+            printer->fmt_line("{} {}[{}] /* TODO init const-array */;", float_type, name, length);
+        } else {
+            double value{};
+            if (auto const& value_ptr = var->get_value()) {
+                value = *value_ptr;
+            }
+            printer->fmt_line("{} {}{};",
+                              float_type,
+                              name,
+                              print_initializers ? fmt::format("{{{:g}}}", value) : std::string{});
+        }
+        codegen_global_variables.push_back(var);
+    }
+
+
+    for (const auto& f: info.function_tables) {
+        throw std::runtime_error("Not implemented, global function tables.");
+    }
+
+    if (info.vectorize && info.thread_data_index) {
+        throw std::runtime_error("Not implemented, global vectorize something else.");
+    }
+
+    printer->pop_block(";");
+
+    print_global_var_struct_assertions();
+    print_global_var_struct_decl();
 }
 
 
@@ -572,11 +644,11 @@
         }
     }
 
-    // printer->fmt_line("{}* {}{};",
-    //                   global_struct(),
-    //                   naming::INST_GLOBAL_MEMBER,
-    //                   print_initializers ? fmt::format("{{&{}}}", global_struct_instance())
-    //                                      : std::string{});
+    printer->fmt_line("{}* {}{};",
+                      global_struct(),
+                      naming::INST_GLOBAL_MEMBER,
+                      print_initializers ? fmt::format("{{&{}}}", global_struct_instance())
+                                         : std::string{});
     printer->pop_block(";");
 }
 

test/unit/codegen/codegen_neuron_cpp_visitor.cpp

@@ -197,6 +197,7 @@ void _nrn_mechanism_register_data_fields(Args&&... args) {
         const double* ion_ena{};
         double* ion_ina{};
         double* ion_dinadv{};
+        pas_test_Store* global{&pas_test_global};
     };)";
 
             REQUIRE_THAT(generated, ContainsSubstring(reindent_and_trim_text(expected)));

test/usecases/CMakeLists.txt

@@ -1,4 +1,4 @@
-set(NMODL_USECASE_DIRS cnexp_scalar cnexp_array)
+set(NMODL_USECASE_DIRS cnexp_scalar cnexp_array global_breakpoint)
 
 foreach(usecase ${NMODL_USECASE_DIRS})
   add_test(NAME usecase_${usecase}

test/usecases/global_breakpoint/leonhard.mod

@@ -0,0 +1,20 @@
+NEURON {
+    SUFFIX leonhard
+    GLOBAL c
+}
+
+PARAMETER {
+  c = 2.0
+}
+
+STATE {
+  x
+}
+
+INITIAL {
+  x = 42
+}
+
+BREAKPOINT {
+  x = c
+}

test/usecases/global_breakpoint/simulate.py

@@ -0,0 +1,27 @@
+import numpy as np
+
+from neuron import h, gui
+from neuron.units import ms
+
+nseg = 1
+
+s = h.Section()
+s.insert("leonhard")
+s.nseg = nseg
+
+x_hoc = h.Vector().record(s(0.5)._ref_x_leonhard)
+t_hoc = h.Vector().record(h._ref_t)
+
+h.stdinit()
+h.tstop = 1.0 * ms
+h.run()
+
+x = np.array(x_hoc.as_numpy())
+t = np.array(t_hoc.as_numpy())
+
+x_exact = 2.0 * np.ones_like(t)
+x_exact[0] = 42;
+abs_err = np.abs(x - x_exact)
+
+assert np.all(abs_err < 1e-12), f"{abs_err=}"
+print("leonhard: success")