NEURON
nmodl_visitor.cpp
Go to the documentation of this file.
1 /*
2  * Copyright 2023 Blue Brain Project, EPFL.
3  * See the top-level LICENSE file for details.
4  *
5  * SPDX-License-Identifier: Apache-2.0
6  */
7 
8 ///
9 /// THIS FILE IS GENERATED AT BUILD TIME AND SHALL NOT BE EDITED.
10 ///
11 
12 #include "visitors/nmodl_visitor.hpp"
13 
14 #include "ast/all.hpp"
15 #include "visitors/nmodl_visitor_helper.ipp"
16 
17 
18 namespace nmodl {
19 namespace visitor {
20 
21 using namespace ast;
22 
23 void NmodlPrintVisitor::visit_node(const Node& node) {
24  if (is_exclude_type(node.get_node_type())) {
25  return;
26  }
27 
28 
29 }
30 
31 void NmodlPrintVisitor::visit_statement(const Statement& node) {
32  if (is_exclude_type(node.get_node_type())) {
33  return;
34  }
35 
36 
37 }
38 
39 void NmodlPrintVisitor::visit_expression(const Expression& node) {
40  if (is_exclude_type(node.get_node_type())) {
41  return;
42  }
43 
44 
45 }
46 
47 void NmodlPrintVisitor::visit_block(const Block& node) {
48  if (is_exclude_type(node.get_node_type())) {
49  return;
50  }
51 
52 
53 }
54 
55 void NmodlPrintVisitor::visit_identifier(const Identifier& node) {
56  if (is_exclude_type(node.get_node_type())) {
57  return;
58  }
59 
60 
61 }
62 
63 void NmodlPrintVisitor::visit_number(const Number& node) {
64  if (is_exclude_type(node.get_node_type())) {
65  return;
66  }
67 
68 
69 }
70 
71 void NmodlPrintVisitor::visit_string(const String& node) {
72  if (is_exclude_type(node.get_node_type())) {
73  return;
74  }
75 
76  std::stringstream ss;
77  ss << node.eval();
78  printer->add_element(ss.str());
79 
80 
81 
82 }
83 
84 void NmodlPrintVisitor::visit_integer(const Integer& node) {
85  if (is_exclude_type(node.get_node_type())) {
86  return;
87  }
88 
89  if(node.get_macro() == nullptr) {
90  printer->add_element(std::to_string(node.eval()));
91  }
92 
93 
94 
95  if(node.get_macro()) {
96  node.get_macro()->accept(*this);
97  }
98 
99 
100 }
101 
102 void NmodlPrintVisitor::visit_float(const Float& node) {
103  if (is_exclude_type(node.get_node_type())) {
104  return;
105  }
106 
107  std::stringstream ss;
108  ss << std::setprecision(16);
109  ss << node.eval();
110  printer->add_element(ss.str());
111 
112 
113 
114 }
115 
116 void NmodlPrintVisitor::visit_double(const Double& node) {
117  if (is_exclude_type(node.get_node_type())) {
118  return;
119  }
120 
121  std::stringstream ss;
122  ss << std::setprecision(16);
123  ss << node.eval();
124  printer->add_element(ss.str());
125 
126 
127 
128 }
129 
130 void NmodlPrintVisitor::visit_boolean(const Boolean& node) {
131  if (is_exclude_type(node.get_node_type())) {
132  return;
133  }
134 
135  std::stringstream ss;
136  ss << node.eval();
137  printer->add_element(ss.str());
138 
139 
140 
141 }
142 
143 void NmodlPrintVisitor::visit_name(const Name& node) {
144  if (is_exclude_type(node.get_node_type())) {
145  return;
146  }
147 
148 
149  node.get_value()->accept(*this);
150 
151 
152 }
153 
154 void NmodlPrintVisitor::visit_prime_name(const PrimeName& node) {
155  if (is_exclude_type(node.get_node_type())) {
156  return;
157  }
158 
159 
160  node.get_value()->accept(*this);
161 
162 
163  auto order = node.get_order()->eval();
164  const std::string symbol(order, '\'');
165  printer->add_element(symbol);
166 
167 
168 }
169 
170 void NmodlPrintVisitor::visit_indexed_name(const IndexedName& node) {
171  if (is_exclude_type(node.get_node_type())) {
172  return;
173  }
174 
175 
176  node.get_name()->accept(*this);
177 
178 
179  printer->add_element("[");
180  node.get_length()->accept(*this);
181 printer->add_element("]");
182 
183 
184 }
185 
186 void NmodlPrintVisitor::visit_var_name(const VarName& node) {
187  if (is_exclude_type(node.get_node_type())) {
188  return;
189  }
190 
191 
192  node.get_name()->accept(*this);
193 
194 
195  if(node.get_at()) {
196  printer->add_element("@");
197  node.get_at()->accept(*this);
198  }
199 
200 
201  if(node.get_index()) {
202  printer->add_element("[");
203  node.get_index()->accept(*this);
204 printer->add_element("]");
205  }
206 
207 
208 }
209 
210 void NmodlPrintVisitor::visit_argument(const Argument& node) {
211  if (is_exclude_type(node.get_node_type())) {
212  return;
213  }
214 
215 
216  node.get_name()->accept(*this);
217 
218 
219  if(node.get_unit()) {
220  node.get_unit()->accept(*this);
221  }
222 
223 
224 }
225 
226 void NmodlPrintVisitor::visit_react_var_name(const ReactVarName& node) {
227  if (is_exclude_type(node.get_node_type())) {
228  return;
229  }
230 
231 
232  if(node.get_value()) {
233  printer->add_element(" ");
234  node.get_value()->accept(*this);
235  }
236 
237 
238  node.get_name()->accept(*this);
239 
240 
241 }
242 
243 void NmodlPrintVisitor::visit_read_ion_var(const ReadIonVar& node) {
244  if (is_exclude_type(node.get_node_type())) {
245  return;
246  }
247 
248 
249  node.get_name()->accept(*this);
250 
251 
252 }
253 
254 void NmodlPrintVisitor::visit_write_ion_var(const WriteIonVar& node) {
255  if (is_exclude_type(node.get_node_type())) {
256  return;
257  }
258 
259 
260  node.get_name()->accept(*this);
261 
262 
263 }
264 
265 void NmodlPrintVisitor::visit_nonspecific_cur_var(const NonspecificCurVar& node) {
266  if (is_exclude_type(node.get_node_type())) {
267  return;
268  }
269 
270 
271  node.get_name()->accept(*this);
272 
273 
274 }
275 
276 void NmodlPrintVisitor::visit_electrode_cur_var(const ElectrodeCurVar& node) {
277  if (is_exclude_type(node.get_node_type())) {
278  return;
279  }
280 
281 
282  node.get_name()->accept(*this);
283 
284 
285 }
286 
287 void NmodlPrintVisitor::visit_range_var(const RangeVar& node) {
288  if (is_exclude_type(node.get_node_type())) {
289  return;
290  }
291 
292 
293  node.get_name()->accept(*this);
294 
295 
296 }
297 
298 void NmodlPrintVisitor::visit_global_var(const GlobalVar& node) {
299  if (is_exclude_type(node.get_node_type())) {
300  return;
301  }
302 
303 
304  node.get_name()->accept(*this);
305 
306 
307 }
308 
309 void NmodlPrintVisitor::visit_pointer_var(const PointerVar& node) {
310  if (is_exclude_type(node.get_node_type())) {
311  return;
312  }
313 
314 
315  node.get_name()->accept(*this);
316 
317 
318 }
319 
320 void NmodlPrintVisitor::visit_random_var(const RandomVar& node) {
321  if (is_exclude_type(node.get_node_type())) {
322  return;
323  }
324 
325 
326  node.get_name()->accept(*this);
327 
328 
329 }
330 
331 void NmodlPrintVisitor::visit_bbcore_pointer_var(const BbcorePointerVar& node) {
332  if (is_exclude_type(node.get_node_type())) {
333  return;
334  }
335 
336 
337  node.get_name()->accept(*this);
338 
339 
340 }
341 
342 void NmodlPrintVisitor::visit_extern_var(const ExternVar& node) {
343  if (is_exclude_type(node.get_node_type())) {
344  return;
345  }
346 
347 
348  node.get_name()->accept(*this);
349 
350 
351 }
352 
353 void NmodlPrintVisitor::visit_param_block(const ParamBlock& node) {
354  if (is_exclude_type(node.get_node_type())) {
355  return;
356  }
357  printer->add_element("PARAMETER ");
358 
359  printer->push_level();
360 
361  visit_element(node.get_statements(),"",false,true);
362 
363 
364 printer->pop_level();
365 }
366 
367 void NmodlPrintVisitor::visit_independent_block(const IndependentBlock& node) {
368  printer->add_element(": INDEPENDENT block is deprecated and has no effect in the NEURON model. Skipped!");
369  return; if (is_exclude_type(node.get_node_type())) {
370  return;
371  }
372  printer->add_element("INDEPENDENT ");
373 
374  printer->push_level();
375 
376  visit_element(node.get_variables()," ",false,false);
377 
378 
379 printer->pop_level();
380 }
381 
382 void NmodlPrintVisitor::visit_assigned_block(const AssignedBlock& node) {
383  if (is_exclude_type(node.get_node_type())) {
384  return;
385  }
386  printer->add_element("ASSIGNED ");
387 
388  printer->push_level();
389 
390  visit_element(node.get_definitions(),"",false,true);
391 
392 
393 printer->pop_level();
394 }
395 
396 void NmodlPrintVisitor::visit_state_block(const StateBlock& node) {
397  if (is_exclude_type(node.get_node_type())) {
398  return;
399  }
400  printer->add_element("STATE ");
401 
402  printer->push_level();
403 
404  visit_element(node.get_definitions(),"",false,true);
405 
406 
407 printer->pop_level();
408 }
409 
410 void NmodlPrintVisitor::visit_initial_block(const InitialBlock& node) {
411  if (is_exclude_type(node.get_node_type())) {
412  return;
413  }
414  printer->add_element("INITIAL ");
415 
416 
417  if(node.get_statement_block()) {
418  node.get_statement_block()->accept(*this);
419  }
420 
421 
422 }
423 
424 void NmodlPrintVisitor::visit_constructor_block(const ConstructorBlock& node) {
425  if (is_exclude_type(node.get_node_type())) {
426  return;
427  }
428  printer->add_element("CONSTRUCTOR ");
429 
430 
431  if(node.get_statement_block()) {
432  node.get_statement_block()->accept(*this);
433  }
434 
435 
436 }
437 
438 void NmodlPrintVisitor::visit_destructor_block(const DestructorBlock& node) {
439  if (is_exclude_type(node.get_node_type())) {
440  return;
441  }
442  printer->add_element("DESTRUCTOR ");
443 
444 
445  if(node.get_statement_block()) {
446  node.get_statement_block()->accept(*this);
447  }
448 
449 
450 }
451 
452 void NmodlPrintVisitor::visit_statement_block(const StatementBlock& node) {
453  if (is_exclude_type(node.get_node_type())) {
454  return;
455  }
456 
457  printer->push_level();
458 
459  visit_element(node.get_statements(),"",false,true);
460 
461 
462 printer->pop_level();
463 }
464 
465 void NmodlPrintVisitor::visit_derivative_block(const DerivativeBlock& node) {
466  if (is_exclude_type(node.get_node_type())) {
467  return;
468  }
469  printer->add_element("DERIVATIVE ");
470 
471 
472  node.get_name()->accept(*this);
473 printer->add_element(" ");
474 
475 
476  if(node.get_statement_block()) {
477  node.get_statement_block()->accept(*this);
478  }
479 
480 
481 }
482 
483 void NmodlPrintVisitor::visit_linear_block(const LinearBlock& node) {
484  if (is_exclude_type(node.get_node_type())) {
485  return;
486  }
487  printer->add_element("LINEAR ");
488 
489 
490  node.get_name()->accept(*this);
491 printer->add_element(" ");
492 
493 
494  if (!node.get_solvefor().empty()) {
495  printer->add_element(" SOLVEFOR ");
496  visit_element(node.get_solvefor(),",",false,false);
497  }
498 
499 
500  if(node.get_statement_block()) {
501  node.get_statement_block()->accept(*this);
502  }
503 
504 
505 }
506 
507 void NmodlPrintVisitor::visit_non_linear_block(const NonLinearBlock& node) {
508  if (is_exclude_type(node.get_node_type())) {
509  return;
510  }
511  printer->add_element("NONLINEAR ");
512 
513 
514  node.get_name()->accept(*this);
515 
516 
517  if (!node.get_solvefor().empty()) {
518  printer->add_element(" SOLVEFOR ");
519  visit_element(node.get_solvefor(),",",false,false);
520  }
521 printer->add_element(" ");
522 
523  if(node.get_statement_block()) {
524  node.get_statement_block()->accept(*this);
525  }
526 
527 
528 }
529 
530 void NmodlPrintVisitor::visit_discrete_block(const DiscreteBlock& node) {
531  if (is_exclude_type(node.get_node_type())) {
532  return;
533  }
534  printer->add_element("DISCRETE ");
535 
536 
537  node.get_name()->accept(*this);
538 printer->add_element(" ");
539 
540 
541  if(node.get_statement_block()) {
542  node.get_statement_block()->accept(*this);
543  }
544 
545 
546 }
547 
548 void NmodlPrintVisitor::visit_function_table_block(const FunctionTableBlock& node) {
549  if (is_exclude_type(node.get_node_type())) {
550  return;
551  }
552  printer->add_element("FUNCTION_TABLE ");
553 
554 
555  node.get_name()->accept(*this);
556 
557 printer->add_element("(");
558  visit_element(node.get_parameters(),", ",false,false);
559 printer->add_element(")");
560 
561  if(node.get_unit()) {
562  printer->add_element(" ");
563  node.get_unit()->accept(*this);
564  }
565 
566 
567 }
568 
569 void NmodlPrintVisitor::visit_function_block(const FunctionBlock& node) {
570  if (is_exclude_type(node.get_node_type())) {
571  return;
572  }
573  printer->add_element("FUNCTION ");
574 
575 
576  node.get_name()->accept(*this);
577 
578 printer->add_element("(");
579  visit_element(node.get_parameters(),", ",false,false);
580 printer->add_element(")");
581 
582  if(node.get_unit()) {
583  printer->add_element(" ");
584  node.get_unit()->accept(*this);
585  }
586 printer->add_element(" ");
587 
588  if(node.get_statement_block()) {
589  node.get_statement_block()->accept(*this);
590  }
591 
592 
593 }
594 
595 void NmodlPrintVisitor::visit_procedure_block(const ProcedureBlock& node) {
596  if (is_exclude_type(node.get_node_type())) {
597  return;
598  }
599  printer->add_element("PROCEDURE ");
600 
601 
602  node.get_name()->accept(*this);
603 
604 printer->add_element("(");
605  visit_element(node.get_parameters(),", ",false,false);
606 printer->add_element(") ");
607 
608  if(node.get_unit()) {
609  node.get_unit()->accept(*this);
610  }
611 
612 
613  if(node.get_statement_block()) {
614  node.get_statement_block()->accept(*this);
615  }
616 
617 
618 }
619 
620 void NmodlPrintVisitor::visit_net_receive_block(const NetReceiveBlock& node) {
621  if (is_exclude_type(node.get_node_type())) {
622  return;
623  }
624  printer->add_element("NET_RECEIVE ");
625 
626 printer->add_element("(");
627  visit_element(node.get_parameters(),", ",false,false);
628 printer->add_element(") ");
629 
630  if(node.get_statement_block()) {
631  node.get_statement_block()->accept(*this);
632  }
633 
634 
635 }
636 
637 void NmodlPrintVisitor::visit_solve_block(const SolveBlock& node) {
638  if (is_exclude_type(node.get_node_type())) {
639  return;
640  }
641  printer->add_element("SOLVE");
642 
643 
644  printer->add_element(" ");
645  node.get_block_name()->accept(*this);
646 
647 
648  if(node.get_method()) {
649  printer->add_element(" METHOD ");
650  node.get_method()->accept(*this);
651  }
652 
653 
654  if(node.get_steadystate()) {
655  printer->add_element(" STEADYSTATE ");
656  node.get_steadystate()->accept(*this);
657  }
658 
659 
660 }
661 
662 void NmodlPrintVisitor::visit_breakpoint_block(const BreakpointBlock& node) {
663  if (is_exclude_type(node.get_node_type())) {
664  return;
665  }
666  printer->add_element("BREAKPOINT ");
667 
668 
669  if(node.get_statement_block()) {
670  node.get_statement_block()->accept(*this);
671  }
672 
673 
674 }
675 
676 void NmodlPrintVisitor::visit_before_block(const BeforeBlock& node) {
677  if (is_exclude_type(node.get_node_type())) {
678  return;
679  }
680  printer->add_element("BEFORE ");
681 
682 
683  node.get_bablock()->accept(*this);
684 
685 
686 }
687 
688 void NmodlPrintVisitor::visit_after_block(const AfterBlock& node) {
689  if (is_exclude_type(node.get_node_type())) {
690  return;
691  }
692  printer->add_element("AFTER ");
693 
694 
695  node.get_bablock()->accept(*this);
696 
697 
698 }
699 
700 void NmodlPrintVisitor::visit_ba_block(const BABlock& node) {
701  if (is_exclude_type(node.get_node_type())) {
702  return;
703  }
704 
705 
706  node.get_type()->accept(*this);
707 printer->add_element(" ");
708 
709 
710  if(node.get_statement_block()) {
711  node.get_statement_block()->accept(*this);
712  }
713 
714 
715 }
716 
717 void NmodlPrintVisitor::visit_for_netcon(const ForNetcon& node) {
718  if (is_exclude_type(node.get_node_type())) {
719  return;
720  }
721  printer->add_element("FOR_NETCONS ");
722 
723 printer->add_element("(");
724  visit_element(node.get_parameters(),", ",false,false);
725 printer->add_element(") ");
726 
727  if(node.get_statement_block()) {
728  node.get_statement_block()->accept(*this);
729  }
730 
731 
732 }
733 
734 void NmodlPrintVisitor::visit_kinetic_block(const KineticBlock& node) {
735  if (is_exclude_type(node.get_node_type())) {
736  return;
737  }
738  printer->add_element("KINETIC ");
739 
740 
741  node.get_name()->accept(*this);
742 printer->add_element(" ");
743 
744 
745  visit_element(node.get_solvefor(),",",false,false);
746 
747 
748  if(node.get_statement_block()) {
749  node.get_statement_block()->accept(*this);
750  }
751 
752 
753 }
754 
755 void NmodlPrintVisitor::visit_unit_block(const UnitBlock& node) {
756  if (is_exclude_type(node.get_node_type())) {
757  return;
758  }
759  printer->add_element("UNITS ");
760 
761  printer->push_level();
762 
763  visit_element(node.get_definitions(),"",false,true);
764 
765 
766 printer->pop_level();
767 }
768 
769 void NmodlPrintVisitor::visit_constant_block(const ConstantBlock& node) {
770  if (is_exclude_type(node.get_node_type())) {
771  return;
772  }
773  printer->add_element("CONSTANT ");
774 
775  printer->push_level();
776 
777  visit_element(node.get_statements(),"",false,true);
778 
779 
780 printer->pop_level();
781 }
782 
783 void NmodlPrintVisitor::visit_neuron_block(const NeuronBlock& node) {
784  if (is_exclude_type(node.get_node_type())) {
785  return;
786  }
787  printer->add_element("NEURON ");
788 
789 
790  if(node.get_statement_block()) {
791  node.get_statement_block()->accept(*this);
792  }
793 
794 
795 }
796 
797 void NmodlPrintVisitor::visit_unit(const Unit& node) {
798  if (is_exclude_type(node.get_node_type())) {
799  return;
800  }
801 
802 
803  printer->add_element("(");
804  node.get_name()->accept(*this);
805 printer->add_element(")");
806 
807 
808 }
809 
810 void NmodlPrintVisitor::visit_double_unit(const DoubleUnit& node) {
811  if (is_exclude_type(node.get_node_type())) {
812  return;
813  }
814 
815 
816  node.get_value()->accept(*this);
817 
818 
819  if(node.get_unit()) {
820  node.get_unit()->accept(*this);
821  }
822 
823 
824 }
825 
826 void NmodlPrintVisitor::visit_local_var(const LocalVar& node) {
827  if (is_exclude_type(node.get_node_type())) {
828  return;
829  }
830 
831 
832  node.get_name()->accept(*this);
833 
834 
835 }
836 
837 void NmodlPrintVisitor::visit_limits(const Limits& node) {
838  if (is_exclude_type(node.get_node_type())) {
839  return;
840  }
841 
842 
843  printer->add_element("<");
844  node.get_min()->accept(*this);
845 printer->add_element(",");
846 
847 
848  node.get_max()->accept(*this);
849 printer->add_element(">");
850 
851 
852 }
853 
854 void NmodlPrintVisitor::visit_number_range(const NumberRange& node) {
855  if (is_exclude_type(node.get_node_type())) {
856  return;
857  }
858 
859 
860  printer->add_element("<");
861  node.get_min()->accept(*this);
862 printer->add_element(",");
863 
864 
865  node.get_max()->accept(*this);
866 printer->add_element(">");
867 
868 
869 }
870 
871 void NmodlPrintVisitor::visit_constant_var(const ConstantVar& node) {
872  if (is_exclude_type(node.get_node_type())) {
873  return;
874  }
875 
876 
877  node.get_name()->accept(*this);
878 
879 
880  printer->add_element(" = ");
881  node.get_value()->accept(*this);
882 
883 
884  if(node.get_unit()) {
885  printer->add_element(" ");
886  node.get_unit()->accept(*this);
887  }
888 
889 
890 }
891 
892 void NmodlPrintVisitor::visit_binary_operator(const BinaryOperator& node) {
893  if (is_exclude_type(node.get_node_type())) {
894  return;
895  }
896 
897  std::stringstream ss;
898  ss << node.eval();
899  printer->add_element(ss.str());
900 
901 
902 
903 }
904 
905 void NmodlPrintVisitor::visit_unary_operator(const UnaryOperator& node) {
906  if (is_exclude_type(node.get_node_type())) {
907  return;
908  }
909 
910  std::stringstream ss;
911  ss << node.eval();
912  printer->add_element(ss.str());
913 
914 
915 
916 }
917 
918 void NmodlPrintVisitor::visit_reaction_operator(const ReactionOperator& node) {
919  if (is_exclude_type(node.get_node_type())) {
920  return;
921  }
922 
923  std::stringstream ss;
924  ss << node.eval();
925  printer->add_element(ss.str());
926 
927 
928 
929 }
930 
931 void NmodlPrintVisitor::visit_paren_expression(const ParenExpression& node) {
932  if (is_exclude_type(node.get_node_type())) {
933  return;
934  }
935 
936 
937  printer->add_element("(");
938  node.get_expression()->accept(*this);
939 printer->add_element(")");
940 
941 
942 }
943 
944 void NmodlPrintVisitor::visit_binary_expression(const BinaryExpression& node) {
945  if (is_exclude_type(node.get_node_type())) {
946  return;
947  }
948 
949 
950  node.get_lhs()->accept(*this);
951 
952 
953  std::string op = node.get_op().eval();
954  if(op == "=" || op == "&&" || op == "||" || op == "==")
955  op = " " + op + " ";
956  printer->add_element(op);
957 
958 
959  node.get_rhs()->accept(*this);
960 
961 
962 }
963 
964 void NmodlPrintVisitor::visit_diff_eq_expression(const DiffEqExpression& node) {
965  if (is_exclude_type(node.get_node_type())) {
966  return;
967  }
968 
969 
970  node.get_expression()->accept(*this);
971 
972 
973 }
974 
975 void NmodlPrintVisitor::visit_unary_expression(const UnaryExpression& node) {
976  if (is_exclude_type(node.get_node_type())) {
977  return;
978  }
979 
980 
981  UnaryOperator(node.get_op()).accept(*this);
982 
983 
984  node.get_expression()->accept(*this);
985 
986 
987 }
988 
989 void NmodlPrintVisitor::visit_non_lin_equation(const NonLinEquation& node) {
990  if (is_exclude_type(node.get_node_type())) {
991  return;
992  }
993  printer->add_element("~ ");
994 
995 
996  node.get_lhs()->accept(*this);
997 printer->add_element(" = ");
998 
999 
1000  node.get_rhs()->accept(*this);
1001 
1002 
1003 }
1004 
1005 void NmodlPrintVisitor::visit_lin_equation(const LinEquation& node) {
1006  if (is_exclude_type(node.get_node_type())) {
1007  return;
1008  }
1009  printer->add_element("~ ");
1010 
1011 
1012  node.get_lhs()->accept(*this);
1013 printer->add_element(" = ");
1014 
1015 
1016  node.get_rhs()->accept(*this);
1017 
1018 
1019 }
1020 
1021 void NmodlPrintVisitor::visit_function_call(const FunctionCall& node) {
1022  if (is_exclude_type(node.get_node_type())) {
1023  return;
1024  }
1025 
1026 
1027  node.get_name()->accept(*this);
1028 
1029 printer->add_element("(");
1030  visit_element(node.get_arguments(),", ",false,false);
1031 printer->add_element(")");
1032 
1033 }
1034 
1035 void NmodlPrintVisitor::visit_watch(const Watch& node) {
1036  if (is_exclude_type(node.get_node_type())) {
1037  return;
1038  }
1039 
1040 
1041  printer->add_element("(");
1042  node.get_expression()->accept(*this);
1043 printer->add_element(")");
1044 
1045 
1046  printer->add_element(" ");
1047  node.get_value()->accept(*this);
1048 
1049 
1050 }
1051 
1052 void NmodlPrintVisitor::visit_ba_block_type(const BABlockType& node) {
1053  if (is_exclude_type(node.get_node_type())) {
1054  return;
1055  }
1056 
1057  std::stringstream ss;
1058  ss << node.eval();
1059  printer->add_element(ss.str());
1060 
1061 
1062 
1063 }
1064 
1065 void NmodlPrintVisitor::visit_unit_def(const UnitDef& node) {
1066  if (is_exclude_type(node.get_node_type())) {
1067  return;
1068  }
1069 
1070 
1071  node.get_unit1()->accept(*this);
1072 
1073 
1074  printer->add_element(" = ");
1075  node.get_unit2()->accept(*this);
1076 
1077 
1078 }
1079 
1080 void NmodlPrintVisitor::visit_factor_def(const FactorDef& node) {
1081  if (is_exclude_type(node.get_node_type())) {
1082  return;
1083  }
1084 
1085 
1086  node.get_name()->accept(*this);
1087 printer->add_element(" =");
1088 
1089 
1090  if(node.get_value()) {
1091  printer->add_element(" ");
1092  node.get_value()->accept(*this);
1093  }
1094 
1095 
1096  printer->add_element(" ");
1097  node.get_unit1()->accept(*this);
1098 
1099 
1100  if(node.get_gt()) {
1101  if(node.get_gt()->eval()) {
1102  printer->add_element(" ->");
1103  }
1104  }
1105 
1106 
1107  if(node.get_unit2()) {
1108  printer->add_element(" ");
1109  node.get_unit2()->accept(*this);
1110  }
1111 
1112 
1113 }
1114 
1115 void NmodlPrintVisitor::visit_valence(const Valence& node) {
1116  if (is_exclude_type(node.get_node_type())) {
1117  return;
1118  }
1119 
1120 
1121  printer->add_element(" ");
1122  node.get_type()->accept(*this);
1123 printer->add_element(" ");
1124 
1125 
1126  node.get_value()->accept(*this);
1127 
1128 
1129 }
1130 
1131 void NmodlPrintVisitor::visit_unit_state(const UnitState& node) {
1132  if (is_exclude_type(node.get_node_type())) {
1133  return;
1134  }
1135 
1136  std::stringstream ss;
1137  ss << node.eval();
1138  printer->add_element(ss.str());
1139 
1140 
1141 
1142 }
1143 
1144 void NmodlPrintVisitor::visit_local_list_statement(const LocalListStatement& node) {
1145  if (is_exclude_type(node.get_node_type())) {
1146  return;
1147  }
1148  printer->add_element("LOCAL ");
1149 
1150 
1151  visit_element(node.get_variables(),", ",false,false);
1152 
1153 
1154 }
1155 
1156 void NmodlPrintVisitor::visit_model(const Model& node) {
1157  if (is_exclude_type(node.get_node_type())) {
1158  return;
1159  }
1160  printer->add_element("TITLE");
1161 
1162 
1163  node.get_title()->accept(*this);
1164 
1165 
1166 }
1167 
1168 void NmodlPrintVisitor::visit_define(const Define& node) {
1169  if (is_exclude_type(node.get_node_type())) {
1170  return;
1171  }
1172  printer->add_element("DEFINE ");
1173 
1174 
1175  node.get_name()->accept(*this);
1176 
1177 
1178  printer->add_element(" ");
1179  node.get_value()->accept(*this);
1180 
1181 
1182 }
1183 
1184 void NmodlPrintVisitor::visit_include(const Include& node) {
1185  if (is_exclude_type(node.get_node_type())) {
1186  return;
1187  }
1188  printer->add_element("INCLUDE ");
1189 
1190 
1191  node.get_filename()->accept(*this);
1192 
1193 
1194 
1195 
1196 
1197 }
1198 
1199 void NmodlPrintVisitor::visit_param_assign(const ParamAssign& node) {
1200  if (is_exclude_type(node.get_node_type())) {
1201  return;
1202  }
1203 
1204 
1205  node.get_name()->accept(*this);
1206 
1207 
1208  if(node.get_value()) {
1209  printer->add_element(" = ");
1210  node.get_value()->accept(*this);
1211  }
1212 
1213 
1214  if(node.get_unit()) {
1215  printer->add_element(" ");
1216  node.get_unit()->accept(*this);
1217  }
1218 
1219 
1220  if(node.get_limit()) {
1221  printer->add_element(" ");
1222  node.get_limit()->accept(*this);
1223  }
1224 
1225 
1226 }
1227 
1228 void NmodlPrintVisitor::visit_assigned_definition(const AssignedDefinition& node) {
1229  if (is_exclude_type(node.get_node_type())) {
1230  return;
1231  }
1232 
1233 
1234  node.get_name()->accept(*this);
1235 
1236 
1237  if(node.get_length()) {
1238  printer->add_element("[");
1239  node.get_length()->accept(*this);
1240 printer->add_element("]");
1241  }
1242 
1243 
1244  if(node.get_from()) {
1245  printer->add_element(" FROM ");
1246  node.get_from()->accept(*this);
1247  }
1248 
1249 
1250  if(node.get_to()) {
1251  printer->add_element(" TO ");
1252  node.get_to()->accept(*this);
1253  }
1254 
1255 
1256  if(node.get_start()) {
1257  printer->add_element(" START ");
1258  node.get_start()->accept(*this);
1259  }
1260 
1261 
1262  if(node.get_unit()) {
1263  printer->add_element(" ");
1264  node.get_unit()->accept(*this);
1265  }
1266 
1267 
1268  if(node.get_abstol()) {
1269  printer->add_element(" <");
1270  node.get_abstol()->accept(*this);
1271 printer->add_element(">");
1272  }
1273 
1274 
1275 }
1276 
1277 void NmodlPrintVisitor::visit_conductance_hint(const ConductanceHint& node) {
1278  if (is_exclude_type(node.get_node_type())) {
1279  return;
1280  }
1281  printer->add_element("CONDUCTANCE ");
1282 
1283 
1284  node.get_conductance()->accept(*this);
1285 
1286 
1287  if(node.get_ion()) {
1288  printer->add_element(" USEION ");
1289  node.get_ion()->accept(*this);
1290  }
1291 
1292 
1293 }
1294 
1295 void NmodlPrintVisitor::visit_expression_statement(const ExpressionStatement& node) {
1296  if (is_exclude_type(node.get_node_type())) {
1297  return;
1298  }
1299 
1300 
1301  node.get_expression()->accept(*this);
1302 
1303 
1304 }
1305 
1306 void NmodlPrintVisitor::visit_protect_statement(const ProtectStatement& node) {
1307  if (is_exclude_type(node.get_node_type())) {
1308  return;
1309  }
1310  printer->add_element("PROTECT ");
1311 
1312 
1313  node.get_expression()->accept(*this);
1314 
1315 
1316 }
1317 
1318 void NmodlPrintVisitor::visit_from_statement(const FromStatement& node) {
1319  if (is_exclude_type(node.get_node_type())) {
1320  return;
1321  }
1322  printer->add_element("FROM ");
1323 
1324 
1325  node.get_name()->accept(*this);
1326 
1327 
1328  printer->add_element(" = ");
1329  node.get_from()->accept(*this);
1330 
1331 
1332  printer->add_element(" TO ");
1333  node.get_to()->accept(*this);
1334 
1335 
1336  if(node.get_increment()) {
1337  printer->add_element(" BY ");
1338  node.get_increment()->accept(*this);
1339  }
1340 printer->add_element(" ");
1341 
1342  if(node.get_statement_block()) {
1343  node.get_statement_block()->accept(*this);
1344  }
1345 
1346 
1347 }
1348 
1349 void NmodlPrintVisitor::visit_while_statement(const WhileStatement& node) {
1350  if (is_exclude_type(node.get_node_type())) {
1351  return;
1352  }
1353  printer->add_element("WHILE ");
1354 
1355 
1356  printer->add_element("(");
1357  node.get_condition()->accept(*this);
1358 printer->add_element(") ");
1359 
1360 
1361  if(node.get_statement_block()) {
1362  node.get_statement_block()->accept(*this);
1363  }
1364 
1365 
1366 }
1367 
1368 void NmodlPrintVisitor::visit_if_statement(const IfStatement& node) {
1369  if (is_exclude_type(node.get_node_type())) {
1370  return;
1371  }
1372  printer->add_element("IF ");
1373 
1374 
1375  printer->add_element("(");
1376  node.get_condition()->accept(*this);
1377 printer->add_element(") ");
1378 
1379 
1380  if(node.get_statement_block()) {
1381  node.get_statement_block()->accept(*this);
1382  }
1383 
1384 
1385  visit_element(node.get_elseifs(),"",false,false);
1386 
1387 
1388  if(node.get_elses()) {
1389  node.get_elses()->accept(*this);
1390  }
1391 
1392 
1393 }
1394 
1395 void NmodlPrintVisitor::visit_else_if_statement(const ElseIfStatement& node) {
1396  if (is_exclude_type(node.get_node_type())) {
1397  return;
1398  }
1399  printer->add_element(" ELSE IF ");
1400 
1401 
1402  printer->add_element("(");
1403  node.get_condition()->accept(*this);
1404 printer->add_element(") ");
1405 
1406 
1407  if(node.get_statement_block()) {
1408  node.get_statement_block()->accept(*this);
1409  }
1410 
1411 
1412 }
1413 
1414 void NmodlPrintVisitor::visit_else_statement(const ElseStatement& node) {
1415  if (is_exclude_type(node.get_node_type())) {
1416  return;
1417  }
1418  printer->add_element(" ELSE ");
1419 
1420 
1421  if(node.get_statement_block()) {
1422  node.get_statement_block()->accept(*this);
1423  }
1424 
1425 
1426 }
1427 
1428 void NmodlPrintVisitor::visit_watch_statement(const WatchStatement& node) {
1429  if (is_exclude_type(node.get_node_type())) {
1430  return;
1431  }
1432  printer->add_element("WATCH ");
1433 
1434 
1435  visit_element(node.get_statements(),",",false,false);
1436 
1437 
1438 }
1439 
1440 void NmodlPrintVisitor::visit_mutex_lock(const MutexLock& node) {
1441  if (is_exclude_type(node.get_node_type())) {
1442  return;
1443  }
1444  printer->add_element("MUTEXLOCK");
1445 
1446 
1447 }
1448 
1449 void NmodlPrintVisitor::visit_mutex_unlock(const MutexUnlock& node) {
1450  if (is_exclude_type(node.get_node_type())) {
1451  return;
1452  }
1453  printer->add_element("MUTEXUNLOCK");
1454 
1455 
1456 }
1457 
1458 void NmodlPrintVisitor::visit_conserve(const Conserve& node) {
1459  if (is_exclude_type(node.get_node_type())) {
1460  return;
1461  }
1462  printer->add_element("CONSERVE");
1463 
1464 
1465  printer->add_element(" ");
1466  node.get_react()->accept(*this);
1467 
1468 
1469  printer->add_element(" = ");
1470  node.get_expr()->accept(*this);
1471 
1472 
1473 }
1474 
1475 void NmodlPrintVisitor::visit_compartment(const Compartment& node) {
1476  if (is_exclude_type(node.get_node_type())) {
1477  return;
1478  }
1479  printer->add_element("COMPARTMENT");
1480 
1481 
1482  if(node.get_index_name()) {
1483  printer->add_element(" ");
1484  node.get_index_name()->accept(*this);
1485 printer->add_element(",");
1486  }
1487 
1488 
1489  printer->add_element(" ");
1490  node.get_volume()->accept(*this);
1491 
1492 
1493  if (!node.get_species().empty()) {
1494  printer->add_element(" {");
1495  visit_element(node.get_species()," ",false,false);
1496 printer->add_element("}");
1497  }
1498 
1499 
1500 }
1501 
1502 void NmodlPrintVisitor::visit_lon_diffuse(const LonDiffuse& node) {
1503  if (is_exclude_type(node.get_node_type())) {
1504  return;
1505  }
1506  printer->add_element("LONGITUDINAL_DIFFUSION");
1507 
1508 
1509  if(node.get_index_name()) {
1510  printer->add_element(" ");
1511  node.get_index_name()->accept(*this);
1512 printer->add_element(",");
1513  }
1514 
1515 
1516  printer->add_element(" ");
1517  node.get_rate()->accept(*this);
1518 
1519 
1520  if (!node.get_species().empty()) {
1521  printer->add_element(" {");
1522  visit_element(node.get_species()," ",false,false);
1523 printer->add_element("}");
1524  }
1525 
1526 
1527 }
1528 
1529 void NmodlPrintVisitor::visit_reaction_statement(const ReactionStatement& node) {
1530  if (is_exclude_type(node.get_node_type())) {
1531  return;
1532  }
1533  printer->add_element("~ ");
1534 
1535 
1536  node.get_reaction1()->accept(*this);
1537 
1538 
1539  printer->add_element(" ");
1540  ReactionOperator(node.get_op()).accept(*this);
1541 
1542 
1543  if(node.get_reaction2()) {
1544  printer->add_element(" ");
1545  node.get_reaction2()->accept(*this);
1546  }
1547 
1548 
1549  printer->add_element(" (");
1550  node.get_expression1()->accept(*this);
1551 
1552 
1553  if(node.get_expression2()) {
1554  printer->add_element(", ");
1555  node.get_expression2()->accept(*this);
1556  }
1557 printer->add_element(")");
1558 
1559 }
1560 
1561 void NmodlPrintVisitor::visit_lag_statement(const LagStatement& node) {
1562  if (is_exclude_type(node.get_node_type())) {
1563  return;
1564  }
1565  printer->add_element("LAG ");
1566 
1567 
1568  node.get_name()->accept(*this);
1569 
1570 
1571  printer->add_element(" BY ");
1572  node.get_byname()->accept(*this);
1573 
1574 
1575 }
1576 
1577 void NmodlPrintVisitor::visit_constant_statement(const ConstantStatement& node) {
1578  if (is_exclude_type(node.get_node_type())) {
1579  return;
1580  }
1581 
1582 
1583  node.get_constant()->accept(*this);
1584 
1585 
1586 }
1587 
1588 void NmodlPrintVisitor::visit_table_statement(const TableStatement& node) {
1589  if (is_exclude_type(node.get_node_type())) {
1590  return;
1591  }
1592  printer->add_element("TABLE ");
1593 
1594 
1595  visit_element(node.get_table_vars(),",",false,false);
1596 
1597 
1598  if (!node.get_depend_vars().empty()) {
1599  printer->add_element(" DEPEND ");
1600  visit_element(node.get_depend_vars(),",",false,false);
1601  }
1602 
1603 
1604  printer->add_element(" FROM ");
1605  node.get_from()->accept(*this);
1606 
1607 
1608  printer->add_element(" TO ");
1609  node.get_to()->accept(*this);
1610 
1611 
1612  printer->add_element(" WITH ");
1613  node.get_with()->accept(*this);
1614 
1615 
1616 }
1617 
1618 void NmodlPrintVisitor::visit_suffix(const Suffix& node) {
1619  if (is_exclude_type(node.get_node_type())) {
1620  return;
1621  }
1622 
1623 
1624  node.get_type()->accept(*this);
1625 printer->add_element(" ");
1626 
1627 
1628  node.get_name()->accept(*this);
1629 
1630 
1631 }
1632 
1633 void NmodlPrintVisitor::visit_useion(const Useion& node) {
1634  if (is_exclude_type(node.get_node_type())) {
1635  return;
1636  }
1637  printer->add_element("USEION ");
1638 
1639 
1640  node.get_name()->accept(*this);
1641 
1642 
1643  if (!node.get_readlist().empty()) {
1644  printer->add_element(" READ ");
1645  visit_element(node.get_readlist(),", ",false,false);
1646  }
1647 
1648 
1649  if (!node.get_writelist().empty()) {
1650  printer->add_element(" WRITE ");
1651  visit_element(node.get_writelist(),", ",false,false);
1652  }
1653 
1654 
1655  if(node.get_valence()) {
1656  node.get_valence()->accept(*this);
1657  }
1658 
1659 
1660  if(node.get_ontology_id()) {
1661  printer->add_element(" REPRESENTS ");
1662  node.get_ontology_id()->accept(*this);
1663  }
1664 
1665 
1666 }
1667 
1668 void NmodlPrintVisitor::visit_nonspecific(const Nonspecific& node) {
1669  if (is_exclude_type(node.get_node_type())) {
1670  return;
1671  }
1672  printer->add_element("NONSPECIFIC_CURRENT ");
1673 
1674 
1675  visit_element(node.get_currents(),", ",false,false);
1676 
1677 
1678 }
1679 
1680 void NmodlPrintVisitor::visit_electrode_current(const ElectrodeCurrent& node) {
1681  if (is_exclude_type(node.get_node_type())) {
1682  return;
1683  }
1684  printer->add_element("ELECTRODE_CURRENT ");
1685 
1686 
1687  visit_element(node.get_currents(),", ",false,false);
1688 
1689 
1690 }
1691 
1692 void NmodlPrintVisitor::visit_range(const Range& node) {
1693  if (is_exclude_type(node.get_node_type())) {
1694  return;
1695  }
1696  printer->add_element("RANGE ");
1697 
1698 
1699  visit_element(node.get_variables(),", ",false,false);
1700 
1701 
1702 }
1703 
1704 void NmodlPrintVisitor::visit_global(const Global& node) {
1705  if (is_exclude_type(node.get_node_type())) {
1706  return;
1707  }
1708  printer->add_element("GLOBAL ");
1709 
1710 
1711  visit_element(node.get_variables(),", ",false,false);
1712 
1713 
1714 }
1715 
1716 void NmodlPrintVisitor::visit_random_var_list(const RandomVarList& node) {
1717  if (is_exclude_type(node.get_node_type())) {
1718  return;
1719  }
1720  printer->add_element("RANDOM ");
1721 
1722 
1723  visit_element(node.get_variables(),", ",false,false);
1724 
1725 
1726 }
1727 
1728 void NmodlPrintVisitor::visit_pointer(const Pointer& node) {
1729  if (is_exclude_type(node.get_node_type())) {
1730  return;
1731  }
1732  printer->add_element("POINTER ");
1733 
1734 
1735  visit_element(node.get_variables(),", ",false,false);
1736 
1737 
1738 }
1739 
1740 void NmodlPrintVisitor::visit_bbcore_pointer(const BbcorePointer& node) {
1741  if (is_exclude_type(node.get_node_type())) {
1742  return;
1743  }
1744  printer->add_element("BBCOREPOINTER ");
1745 
1746 
1747  visit_element(node.get_variables(),", ",false,false);
1748 
1749 
1750 }
1751 
1752 void NmodlPrintVisitor::visit_external(const External& node) {
1753  if (is_exclude_type(node.get_node_type())) {
1754  return;
1755  }
1756  printer->add_element("EXTERNAL ");
1757 
1758 
1759  visit_element(node.get_variables(),", ",false,false);
1760 
1761 
1762 }
1763 
1764 void NmodlPrintVisitor::visit_thread_safe(const ThreadSafe& node) {
1765  if (is_exclude_type(node.get_node_type())) {
1766  return;
1767  }
1768  printer->add_element("THREADSAFE");
1769 
1770 
1771 }
1772 
1773 void NmodlPrintVisitor::visit_verbatim(const Verbatim& node) {
1774  if (is_exclude_type(node.get_node_type())) {
1775  return;
1776  }
1777  printer->add_element("VERBATIM");
1778 
1779 
1780  node.get_statement()->accept(*this);
1781 printer->add_element("ENDVERBATIM");
1782 
1783 
1784 }
1785 
1786 void NmodlPrintVisitor::visit_line_comment(const LineComment& node) {
1787  if (is_exclude_type(node.get_node_type())) {
1788  return;
1789  }
1790 
1791 
1792  node.get_statement()->accept(*this);
1793 
1794 
1795 }
1796 
1797 void NmodlPrintVisitor::visit_block_comment(const BlockComment& node) {
1798  if (is_exclude_type(node.get_node_type())) {
1799  return;
1800  }
1801  printer->add_element("COMMENT");
1802 
1803 
1804  node.get_statement()->accept(*this);
1805 printer->add_element("ENDCOMMENT");
1806 
1807 
1808 }
1809 
1810 void NmodlPrintVisitor::visit_ontology_statement(const OntologyStatement& node) {
1811  if (is_exclude_type(node.get_node_type())) {
1812  return;
1813  }
1814  printer->add_element("REPRESENTS ");
1815 
1816 
1817  node.get_ontology_id()->accept(*this);
1818 
1819 
1820 }
1821 
1822 void NmodlPrintVisitor::visit_program(const Program& node) {
1823  if (is_exclude_type(node.get_node_type())) {
1824  return;
1825  }
1826 
1827 
1828  visit_element(node.get_blocks(),"",true,false);
1829 
1830 
1831 }
1832 
1833 void NmodlPrintVisitor::visit_nrn_state_block(const NrnStateBlock& node) {
1834  if (is_exclude_type(node.get_node_type())) {
1835  return;
1836  }
1837  printer->add_element("NRN_STATE ");
1838 
1839 
1840  visit_element(node.get_solve_statements(),"",false,true);
1841 
1842 
1843 }
1844 
1845 void NmodlPrintVisitor::visit_eigen_newton_solver_block(const EigenNewtonSolverBlock& node) {
1846  if (is_exclude_type(node.get_node_type())) {
1847  return;
1848  }
1849  printer->add_element("EIGEN_NEWTON_SOLVE");
1850 
1851 
1852  printer->add_element("[");
1853  node.get_n_state_vars()->accept(*this);
1854 printer->add_element("]");
1855 
1856 
1857  if(node.get_variable_block()) {
1858  node.get_variable_block()->accept(*this);
1859  }
1860 
1861 
1862  if(node.get_initialize_block()) {
1863  node.get_initialize_block()->accept(*this);
1864  }
1865 
1866 
1867  if(node.get_setup_x_block()) {
1868  node.get_setup_x_block()->accept(*this);
1869  }
1870 
1871 
1872  if(node.get_functor_block()) {
1873  node.get_functor_block()->accept(*this);
1874  }
1875 
1876 
1877  if(node.get_update_states_block()) {
1878  node.get_update_states_block()->accept(*this);
1879  }
1880 
1881 
1882  if(node.get_finalize_block()) {
1883  node.get_finalize_block()->accept(*this);
1884  }
1885 
1886 
1887 }
1888 
1889 void NmodlPrintVisitor::visit_eigen_linear_solver_block(const EigenLinearSolverBlock& node) {
1890  if (is_exclude_type(node.get_node_type())) {
1891  return;
1892  }
1893  printer->add_element("EIGEN_LINEAR_SOLVE");
1894 
1895 
1896  printer->add_element("[");
1897  node.get_n_state_vars()->accept(*this);
1898 printer->add_element("]");
1899 
1900 
1901  if(node.get_variable_block()) {
1902  node.get_variable_block()->accept(*this);
1903  }
1904 
1905 
1906  if(node.get_initialize_block()) {
1907  node.get_initialize_block()->accept(*this);
1908  }
1909 
1910 
1911  if(node.get_setup_x_block()) {
1912  node.get_setup_x_block()->accept(*this);
1913  }
1914 
1915 
1916  if(node.get_update_states_block()) {
1917  node.get_update_states_block()->accept(*this);
1918  }
1919 
1920 
1921  if(node.get_finalize_block()) {
1922  node.get_finalize_block()->accept(*this);
1923  }
1924 
1925 
1926 }
1927 
1928 void NmodlPrintVisitor::visit_cvode_block(const CvodeBlock& node) {
1929  if (is_exclude_type(node.get_node_type())) {
1930  return;
1931  }
1932  printer->add_element("CVODE_BLOCK ");
1933 
1934 
1935  node.get_name()->accept(*this);
1936 printer->add_element(" ");
1937 
1938 
1939  printer->add_element("[");
1940  node.get_n_odes()->accept(*this);
1941 printer->add_element("]");
1942 
1943 
1944  if(node.get_non_stiff_block()) {
1945  node.get_non_stiff_block()->accept(*this);
1946  }
1947 
1948 
1949  if(node.get_stiff_block()) {
1950  node.get_stiff_block()->accept(*this);
1951  }
1952 
1953 
1954 }
1955 
1956 void NmodlPrintVisitor::visit_longitudinal_diffusion_block(const LongitudinalDiffusionBlock& node) {
1957  if (is_exclude_type(node.get_node_type())) {
1958  return;
1959  }
1960  printer->add_element("LONGITUDINAL_DIFFUSION_BLOCK");
1961 
1962 
1963  printer->add_element(" ");
1964  node.get_name()->accept(*this);
1965 printer->add_element(" ");
1966 
1967 
1968  if(node.get_longitudinal_diffusion_statements()) {
1969  node.get_longitudinal_diffusion_statements()->accept(*this);
1970  }
1971 
1972 
1973  if(node.get_compartment_statements()) {
1974  node.get_compartment_statements()->accept(*this);
1975  }
1976 
1977 
1978 }
1979 
1980 void NmodlPrintVisitor::visit_wrapped_expression(const WrappedExpression& node) {
1981  if (is_exclude_type(node.get_node_type())) {
1982  return;
1983  }
1984 
1985 
1986  node.get_expression()->accept(*this);
1987 
1988 
1989 }
1990 
1991 void NmodlPrintVisitor::visit_derivimplicit_callback(const DerivimplicitCallback& node) {
1992  if (is_exclude_type(node.get_node_type())) {
1993  return;
1994  }
1995 
1996 
1997  node.get_node_to_solve()->accept(*this);
1998 
1999 
2000 }
2001 
2002 void NmodlPrintVisitor::visit_solution_expression(const SolutionExpression& node) {
2003  if (is_exclude_type(node.get_node_type())) {
2004  return;
2005  }
2006 
2007 
2008  node.get_solve_block()->accept(*this);
2009 
2010 
2011  node.get_node_to_solve()->accept(*this);
2012 
2013 
2014 }
2015 
2016 void NmodlPrintVisitor::visit_update_dt(const UpdateDt& node) {
2017  if (is_exclude_type(node.get_node_type())) {
2018  return;
2019  }
2020  printer->add_element("dt");
2021 
2022 
2023  printer->add_element(" = ");
2024  node.get_value()->accept(*this);
2025 
2026 
2027 }
2028 
2029 
2030 } // namespace visitor
2031 } // namespace nmodl
2032 
all.hpp
Auto generated AST classes declaration.
nmodl::ast::AfterBlock
Represents a AFTER block in NMODL.
Definition: after_block.hpp:51
nmodl::ast::Argument
Represents an argument to functions and procedures.
Definition: argument.hpp:48
nmodl::ast::AssignedBlock
Represents a ASSIGNED block in the NMODL.
Definition: assigned_block.hpp:54
nmodl::ast::AssignedDefinition
Represents a statement in ASSIGNED or STATE block.
Definition: assigned_definition.hpp:38
nmodl::ast::BABlock
Represents a block to be executed before or after another block.
Definition: ba_block.hpp:40
nmodl::ast::BABlockType
Type to represent different block types for before/after block.
Definition: ba_block_type.hpp:42
nmodl::ast::BbcorePointer
Represents BBCOREPOINTER statement in NMODL.
Definition: bbcore_pointer.hpp:47
nmodl::ast::BbcorePointerVar
Represent a single variable of type BBCOREPOINTER.
Definition: bbcore_pointer_var.hpp:39
nmodl::ast::BeforeBlock
Represents a BEFORE block in NMODL.
Definition: before_block.hpp:38
nmodl::ast::BinaryExpression
Represents binary expression in the NMODL.
Definition: binary_expression.hpp:52
nmodl::ast::BinaryOperator
Operator used in ast::BinaryExpression.
Definition: binary_operator.hpp:38
nmodl::ast::BlockComment
Represents a multi-line comment in NMODL.
Definition: block_comment.hpp:38
nmodl::ast::Block
Base class for all block scoped nodes.
Definition: block.hpp:41
nmodl::ast::Boolean
Represents a boolean variable.
Definition: boolean.hpp:42
nmodl::ast::BreakpointBlock
Represents a BREAKPOINT block in NMODL.
Definition: breakpoint_block.hpp:53
nmodl::ast::Compartment
Represent COMPARTMENT statement in NMODL.
Definition: compartment.hpp:39
nmodl::ast::ConductanceHint
Represents CONDUCTANCE statement in NMODL.
Definition: conductance_hint.hpp:46
nmodl::ast::Conserve
Represent CONSERVE statement in NMODL.
Definition: conserve.hpp:38
nmodl::ast::ConstantBlock
Represent CONSTANT block in the mod file.
Definition: constant_block.hpp:50
nmodl::ast::ConstantStatement
Represent statement in CONSTANT block of NMODL.
Definition: constant_statement.hpp:40
nmodl::ast::ConstantVar
Represents a variable in the ast::ConstantBlock.
Definition: constant_var.hpp:38
nmodl::ast::ConstructorBlock
Represents a CONSTRUCTOR block in the NMODL.
Definition: constructor_block.hpp:51
nmodl::ast::CvodeBlock
Represents a block used for variable timestep integration (CVODE) of DERIVATIVE blocks.
Definition: cvode_block.hpp:38
nmodl::ast::Define
Represents a DEFINE statement in NMODL.
Definition: define.hpp:38
nmodl::ast::DerivativeBlock
Represents DERIVATIVE block in the NMODL.
Definition: derivative_block.hpp:49
nmodl::ast::DerivimplicitCallback
Represent a callback to NEURON's derivimplicit solver.
Definition: derivimplicit_callback.hpp:38
nmodl::ast::DestructorBlock
Represents a DESTRUCTOR block in the NMODL.
Definition: destructor_block.hpp:53
nmodl::ast::DiffEqExpression
Represents differential equation in DERIVATIVE block.
Definition: diff_eq_expression.hpp:38
nmodl::ast::Double
Represents a double variable.
Definition: double.hpp:53
nmodl::ast::EigenLinearSolverBlock
Represent linear solver solution block based on Eigen.
Definition: eigen_linear_solver_block.hpp:38
nmodl::ast::EigenNewtonSolverBlock
Represent newton solver solution block based on Eigen.
Definition: eigen_newton_solver_block.hpp:38
nmodl::ast::ElectrodeCurrent
Represents ELECTRODE_CURRENT variables statement in NMODL.
Definition: electrode_current.hpp:39
nmodl::ast::Expression
Base class for all expressions in the NMODL.
Definition: expression.hpp:43
nmodl::ast::External
This construct is deprecated and no longer supported in the NMODL.
Definition: external.hpp:39
nmodl::ast::Float
Represents a float variable.
Definition: float.hpp:44
nmodl::ast::Global
Represents GLOBAL statement in NMODL.
Definition: global.hpp:39
nmodl::ast::Identifier
Base class for all identifiers.
Definition: identifier.hpp:41
nmodl::ast::Include
Represents an INCLUDE statement in NMODL.
Definition: include.hpp:39
nmodl::ast::IndependentBlock
Represents a INDEPENDENT block in the NMODL.
Definition: independent_block.hpp:46
nmodl::ast::IndexedName
Represents specific element of an array variable.
Definition: indexed_name.hpp:48
nmodl::ast::InitialBlock
Represents a INITIAL block in the NMODL.
Definition: initial_block.hpp:49
nmodl::ast::Integer
Represents an integer variable.
Definition: integer.hpp:49
nmodl::ast::LagStatement
Represents a LAG statement in the mod file.
Definition: lag_statement.hpp:47
nmodl::ast::LinEquation
One equation in a system of equations tha collectively form a LINEAR block.
Definition: lin_equation.hpp:38
nmodl::ast::LineComment
Represents a one line comment in NMODL.
Definition: line_comment.hpp:38
nmodl::ast::LinearBlock
Represents LINEAR block in the NMODL.
Definition: linear_block.hpp:53
nmodl::ast::LonDiffuse
Represent LONGITUDINAL_DIFFUSION statement in NMODL.
Definition: lon_diffuse.hpp:39
nmodl::ast::LongitudinalDiffusionBlock
Extracts information required for LONGITUDINAL_DIFFUSION for each KINETIC block.
Definition: longitudinal_diffusion_block.hpp:38
nmodl::ast::MutexLock
Represent MUTEXLOCK statement in NMODL.
Definition: mutex_lock.hpp:38
nmodl::ast::MutexUnlock
Represent MUTEXUNLOCK statement in NMODL.
Definition: mutex_unlock.hpp:38
nmodl::ast::Name
Represents a name.
Definition: name.hpp:44
nmodl::ast::NeuronBlock
Represent NEURON block in the mod file.
Definition: neuron_block.hpp:53
nmodl::ast::Node
Base class for all AST node.
Definition: node.hpp:40
nmodl::ast::NonLinEquation
One equation in a system of equations that collectively make a NONLINEAR block.
Definition: non_lin_equation.hpp:38
nmodl::ast::NonLinearBlock
Represents NONLINEAR block in the NMODL.
Definition: non_linear_block.hpp:50
nmodl::ast::Nonspecific
Represents NONSPECIFIC_CURRENT variables statement in NMODL.
Definition: nonspecific.hpp:39
nmodl::ast::NrnStateBlock
Represents the coreneuron nrn_state callback function.
Definition: nrn_state_block.hpp:39
nmodl::ast::Number
Base class for all numbers.
Definition: number.hpp:39
nmodl::ast::OntologyStatement
Represents CURIE information in NMODL.
Definition: ontology_statement.hpp:38
nmodl::ast::ParamBlock
Represents a PARAMETER block in the NMODL.
Definition: param_block.hpp:53
nmodl::ast::Pointer
Represents POINTER statement in NMODL.
Definition: pointer.hpp:39
nmodl::ast::PrimeName
Represents a prime variable (for ODE)
Definition: prime_name.hpp:48
nmodl::ast::Program
Represents top level AST node for whole NMODL input.
Definition: program.hpp:39
nmodl::ast::RandomVar
Single variable of type RANDOM.
Definition: random_var.hpp:38
nmodl::ast::RandomVarList
Represents RANDOM statement in NMODL.
Definition: random_var_list.hpp:47
nmodl::ast::Range
Represents RANGE variables statement in NMODL.
Definition: range.hpp:39
nmodl::ast::ReactionOperator::accept
void accept(visitor::Visitor &v) override
accept (or visit) the current AST node using provided visitor
Definition: ast.cpp:6366
nmodl::ast::SolutionExpression
Represent solution of a block in the AST.
Definition: solution_expression.hpp:38
nmodl::ast::StateBlock
Represents a STATE block in the NMODL.
Definition: state_block.hpp:52
nmodl::ast::StatementBlock
Represents block encapsulating list of statements.
Definition: statement_block.hpp:53
nmodl::ast::String
Represents a string.
Definition: string.hpp:52
nmodl::ast::Suffix
Represents SUFFIX statement in NMODL.
Definition: suffix.hpp:38
nmodl::ast::TableStatement
Represents TABLE statement in NMODL.
Definition: table_statement.hpp:39
nmodl::ast::ThreadSafe
Represents THREADSAFE statement in NMODL.
Definition: thread_safe.hpp:38
nmodl::ast::UnaryOperator::accept
void accept(visitor::Visitor &v) override
accept (or visit) the current AST node using provided visitor
Definition: ast.cpp:6307
nmodl::ast::UpdateDt
Statement to indicate a change in timestep in a given block.
Definition: update_dt.hpp:38
nmodl::ast::Useion
Represents USEION statement in NMODL.
Definition: useion.hpp:40
nmodl::ast::VarName
Represents a variable.
Definition: var_name.hpp:43
nmodl::ast::Verbatim
Represents a C code block.
Definition: verbatim.hpp:38
nmodl::ast::WatchStatement
Represent WATCH statement in NMODL.
Definition: watch_statement.hpp:39
nmodl::ast::WrappedExpression
Wrap any other expression type.
Definition: wrapped_expression.hpp:38
nmodl::visitor::NmodlPrintVisitor::visit_bbcore_pointer_var
void visit_bbcore_pointer_var(const ast::BbcorePointerVar &node) override
visit node of type ast::BbcorePointerVar
Definition: nmodl_visitor.cpp:331
nmodl::visitor::NmodlPrintVisitor::visit_define
void visit_define(const ast::Define &node) override
visit node of type ast::Define
Definition: nmodl_visitor.cpp:1168
nmodl::visitor::NmodlPrintVisitor::visit_expression
void visit_expression(const ast::Expression &node) override
visit node of type ast::Expression
Definition: nmodl_visitor.cpp:39
nmodl::visitor::NmodlPrintVisitor::visit_electrode_current
void visit_electrode_current(const ast::ElectrodeCurrent &node) override
visit node of type ast::ElectrodeCurrent
Definition: nmodl_visitor.cpp:1680
nmodl::visitor::NmodlPrintVisitor::visit_double
void visit_double(const ast::Double &node) override
visit node of type ast::Double
Definition: nmodl_visitor.cpp:116
nmodl::visitor::NmodlPrintVisitor::visit_string
void visit_string(const ast::String &node) override
visit node of type ast::String
Definition: nmodl_visitor.cpp:71
nmodl::visitor::NmodlPrintVisitor::visit_nonspecific
void visit_nonspecific(const ast::Nonspecific &node) override
visit node of type ast::Nonspecific
Definition: nmodl_visitor.cpp:1668
nmodl::visitor::NmodlPrintVisitor::visit_initial_block
void visit_initial_block(const ast::InitialBlock &node) override
visit node of type ast::InitialBlock
Definition: nmodl_visitor.cpp:410
nmodl::visitor::NmodlPrintVisitor::visit_protect_statement
void visit_protect_statement(const ast::ProtectStatement &node) override
visit node of type ast::ProtectStatement
Definition: nmodl_visitor.cpp:1306
nmodl::visitor::NmodlPrintVisitor::visit_random_var_list
void visit_random_var_list(const ast::RandomVarList &node) override
visit node of type ast::RandomVarList
Definition: nmodl_visitor.cpp:1716
nmodl::visitor::NmodlPrintVisitor::visit_read_ion_var
void visit_read_ion_var(const ast::ReadIonVar &node) override
visit node of type ast::ReadIonVar
Definition: nmodl_visitor.cpp:243
nmodl::visitor::NmodlPrintVisitor::visit_function_block
void visit_function_block(const ast::FunctionBlock &node) override
visit node of type ast::FunctionBlock
Definition: nmodl_visitor.cpp:569
nmodl::visitor::NmodlPrintVisitor::visit_conserve
void visit_conserve(const ast::Conserve &node) override
visit node of type ast::Conserve
Definition: nmodl_visitor.cpp:1458
nmodl::visitor::NmodlPrintVisitor::visit_constant_statement
void visit_constant_statement(const ast::ConstantStatement &node) override
visit node of type ast::ConstantStatement
Definition: nmodl_visitor.cpp:1577
nmodl::visitor::NmodlPrintVisitor::visit_ba_block_type
void visit_ba_block_type(const ast::BABlockType &node) override
visit node of type ast::BABlockType
Definition: nmodl_visitor.cpp:1052
nmodl::visitor::NmodlPrintVisitor::visit_while_statement
void visit_while_statement(const ast::WhileStatement &node) override
visit node of type ast::WhileStatement
Definition: nmodl_visitor.cpp:1349
nmodl::visitor::NmodlPrintVisitor::visit_thread_safe
void visit_thread_safe(const ast::ThreadSafe &node) override
visit node of type ast::ThreadSafe
Definition: nmodl_visitor.cpp:1764
nmodl::visitor::NmodlPrintVisitor::visit_binary_operator
void visit_binary_operator(const ast::BinaryOperator &node) override
visit node of type ast::BinaryOperator
Definition: nmodl_visitor.cpp:892
nmodl::visitor::NmodlPrintVisitor::visit_derivative_block
void visit_derivative_block(const ast::DerivativeBlock &node) override
visit node of type ast::DerivativeBlock
Definition: nmodl_visitor.cpp:465
nmodl::visitor::NmodlPrintVisitor::visit_verbatim
void visit_verbatim(const ast::Verbatim &node) override
visit node of type ast::Verbatim
Definition: nmodl_visitor.cpp:1773
nmodl::visitor::NmodlPrintVisitor::visit_eigen_newton_solver_block
void visit_eigen_newton_solver_block(const ast::EigenNewtonSolverBlock &node) override
visit node of type ast::EigenNewtonSolverBlock
Definition: nmodl_visitor.cpp:1845
nmodl::visitor::NmodlPrintVisitor::visit_random_var
void visit_random_var(const ast::RandomVar &node) override
visit node of type ast::RandomVar
Definition: nmodl_visitor.cpp:320
nmodl::visitor::NmodlPrintVisitor::visit_mutex_unlock
void visit_mutex_unlock(const ast::MutexUnlock &node) override
visit node of type ast::MutexUnlock
Definition: nmodl_visitor.cpp:1449
nmodl::visitor::NmodlPrintVisitor::visit_unit_block
void visit_unit_block(const ast::UnitBlock &node) override
visit node of type ast::UnitBlock
Definition: nmodl_visitor.cpp:755
nmodl::visitor::NmodlPrintVisitor::visit_nonspecific_cur_var
void visit_nonspecific_cur_var(const ast::NonspecificCurVar &node) override
visit node of type ast::NonspecificCurVar
Definition: nmodl_visitor.cpp:265
nmodl::visitor::NmodlPrintVisitor::visit_conductance_hint
void visit_conductance_hint(const ast::ConductanceHint &node) override
visit node of type ast::ConductanceHint
Definition: nmodl_visitor.cpp:1277
nmodl::visitor::NmodlPrintVisitor::visit_breakpoint_block
void visit_breakpoint_block(const ast::BreakpointBlock &node) override
visit node of type ast::BreakpointBlock
Definition: nmodl_visitor.cpp:662
nmodl::visitor::NmodlPrintVisitor::visit_integer
void visit_integer(const ast::Integer &node) override
visit node of type ast::Integer
Definition: nmodl_visitor.cpp:84
nmodl::visitor::NmodlPrintVisitor::visit_ontology_statement
void visit_ontology_statement(const ast::OntologyStatement &node) override
visit node of type ast::OntologyStatement
Definition: nmodl_visitor.cpp:1810
nmodl::visitor::NmodlPrintVisitor::visit_react_var_name
void visit_react_var_name(const ast::ReactVarName &node) override
visit node of type ast::ReactVarName
Definition: nmodl_visitor.cpp:226
nmodl::visitor::NmodlPrintVisitor::visit_number
void visit_number(const ast::Number &node) override
visit node of type ast::Number
Definition: nmodl_visitor.cpp:63
nmodl::visitor::NmodlPrintVisitor::visit_suffix
void visit_suffix(const ast::Suffix &node) override
visit node of type ast::Suffix
Definition: nmodl_visitor.cpp:1618
nmodl::visitor::NmodlPrintVisitor::visit_compartment
void visit_compartment(const ast::Compartment &node) override
visit node of type ast::Compartment
Definition: nmodl_visitor.cpp:1475
nmodl::visitor::NmodlPrintVisitor::visit_kinetic_block
void visit_kinetic_block(const ast::KineticBlock &node) override
visit node of type ast::KineticBlock
Definition: nmodl_visitor.cpp:734
nmodl::visitor::NmodlPrintVisitor::visit_indexed_name
void visit_indexed_name(const ast::IndexedName &node) override
visit node of type ast::IndexedName
Definition: nmodl_visitor.cpp:170
nmodl::visitor::NmodlPrintVisitor::visit_identifier
void visit_identifier(const ast::Identifier &node) override
visit node of type ast::Identifier
Definition: nmodl_visitor.cpp:55
nmodl::visitor::NmodlPrintVisitor::visit_paren_expression
void visit_paren_expression(const ast::ParenExpression &node) override
visit node of type ast::ParenExpression
Definition: nmodl_visitor.cpp:931
nmodl::visitor::NmodlPrintVisitor::visit_before_block
void visit_before_block(const ast::BeforeBlock &node) override
visit node of type ast::BeforeBlock
Definition: nmodl_visitor.cpp:676
nmodl::visitor::NmodlPrintVisitor::visit_watch_statement
void visit_watch_statement(const ast::WatchStatement &node) override
visit node of type ast::WatchStatement
Definition: nmodl_visitor.cpp:1428
nmodl::visitor::NmodlPrintVisitor::visit_bbcore_pointer
void visit_bbcore_pointer(const ast::BbcorePointer &node) override
visit node of type ast::BbcorePointer
Definition: nmodl_visitor.cpp:1740
nmodl::visitor::NmodlPrintVisitor::visit_unit_state
void visit_unit_state(const ast::UnitState &node) override
visit node of type ast::UnitState
Definition: nmodl_visitor.cpp:1131
nmodl::visitor::NmodlPrintVisitor::visit_after_block
void visit_after_block(const ast::AfterBlock &node) override
visit node of type ast::AfterBlock
Definition: nmodl_visitor.cpp:688
nmodl::visitor::NmodlPrintVisitor::visit_write_ion_var
void visit_write_ion_var(const ast::WriteIonVar &node) override
visit node of type ast::WriteIonVar
Definition: nmodl_visitor.cpp:254
nmodl::visitor::NmodlPrintVisitor::visit_update_dt
void visit_update_dt(const ast::UpdateDt &node) override
visit node of type ast::UpdateDt
Definition: nmodl_visitor.cpp:2016
nmodl::visitor::NmodlPrintVisitor::visit_lin_equation
void visit_lin_equation(const ast::LinEquation &node) override
visit node of type ast::LinEquation
Definition: nmodl_visitor.cpp:1005
nmodl::visitor::NmodlPrintVisitor::visit_argument
void visit_argument(const ast::Argument &node) override
visit node of type ast::Argument
Definition: nmodl_visitor.cpp:210
nmodl::visitor::NmodlPrintVisitor::visit_statement_block
void visit_statement_block(const ast::StatementBlock &node) override
visit node of type ast::StatementBlock
Definition: nmodl_visitor.cpp:452
nmodl::visitor::NmodlPrintVisitor::visit_factor_def
void visit_factor_def(const ast::FactorDef &node) override
visit node of type ast::FactorDef
Definition: nmodl_visitor.cpp:1080
nmodl::visitor::NmodlPrintVisitor::visit_include
void visit_include(const ast::Include &node) override
visit node of type ast::Include
Definition: nmodl_visitor.cpp:1184
nmodl::visitor::NmodlPrintVisitor::visit_float
void visit_float(const ast::Float &node) override
visit node of type ast::Float
Definition: nmodl_visitor.cpp:102
nmodl::visitor::NmodlPrintVisitor::visit_function_call
void visit_function_call(const ast::FunctionCall &node) override
visit node of type ast::FunctionCall
Definition: nmodl_visitor.cpp:1021
nmodl::visitor::NmodlPrintVisitor::visit_block
void visit_block(const ast::Block &node) override
visit node of type ast::Block
Definition: nmodl_visitor.cpp:47
nmodl::visitor::NmodlPrintVisitor::visit_node
void visit_node(const ast::Node &node) override
visit node of type ast::Node
Definition: nmodl_visitor.cpp:23
nmodl::visitor::NmodlPrintVisitor::visit_else_statement
void visit_else_statement(const ast::ElseStatement &node) override
visit node of type ast::ElseStatement
Definition: nmodl_visitor.cpp:1414
nmodl::visitor::NmodlPrintVisitor::visit_program
void visit_program(const ast::Program &node) override
visit node of type ast::Program
Definition: nmodl_visitor.cpp:1822
nmodl::visitor::NmodlPrintVisitor::visit_external
void visit_external(const ast::External &node) override
visit node of type ast::External
Definition: nmodl_visitor.cpp:1752
nmodl::visitor::NmodlPrintVisitor::visit_unary_operator
void visit_unary_operator(const ast::UnaryOperator &node) override
visit node of type ast::UnaryOperator
Definition: nmodl_visitor.cpp:905
nmodl::visitor::NmodlPrintVisitor::visit_var_name
void visit_var_name(const ast::VarName &node) override
visit node of type ast::VarName
Definition: nmodl_visitor.cpp:186
nmodl::visitor::NmodlPrintVisitor::visit_for_netcon
void visit_for_netcon(const ast::ForNetcon &node) override
visit node of type ast::ForNetcon
Definition: nmodl_visitor.cpp:717
nmodl::visitor::NmodlPrintVisitor::visit_constant_var
void visit_constant_var(const ast::ConstantVar &node) override
visit node of type ast::ConstantVar
Definition: nmodl_visitor.cpp:871
nmodl::visitor::NmodlPrintVisitor::visit_nrn_state_block
void visit_nrn_state_block(const ast::NrnStateBlock &node) override
visit node of type ast::NrnStateBlock
Definition: nmodl_visitor.cpp:1833
nmodl::visitor::NmodlPrintVisitor::visit_binary_expression
void visit_binary_expression(const ast::BinaryExpression &node) override
visit node of type ast::BinaryExpression
Definition: nmodl_visitor.cpp:944
nmodl::visitor::NmodlPrintVisitor::visit_global_var
void visit_global_var(const ast::GlobalVar &node) override
visit node of type ast::GlobalVar
Definition: nmodl_visitor.cpp:298
nmodl::visitor::NmodlPrintVisitor::visit_solve_block
void visit_solve_block(const ast::SolveBlock &node) override
visit node of type ast::SolveBlock
Definition: nmodl_visitor.cpp:637
nmodl::visitor::NmodlPrintVisitor::visit_eigen_linear_solver_block
void visit_eigen_linear_solver_block(const ast::EigenLinearSolverBlock &node) override
visit node of type ast::EigenLinearSolverBlock
Definition: nmodl_visitor.cpp:1889
nmodl::visitor::NmodlPrintVisitor::visit_lon_diffuse
void visit_lon_diffuse(const ast::LonDiffuse &node) override
visit node of type ast::LonDiffuse
Definition: nmodl_visitor.cpp:1502
nmodl::visitor::NmodlPrintVisitor::visit_pointer_var
void visit_pointer_var(const ast::PointerVar &node) override
visit node of type ast::PointerVar
Definition: nmodl_visitor.cpp:309
nmodl::visitor::NmodlPrintVisitor::visit_solution_expression
void visit_solution_expression(const ast::SolutionExpression &node) override
visit node of type ast::SolutionExpression
Definition: nmodl_visitor.cpp:2002
nmodl::visitor::NmodlPrintVisitor::visit_global
void visit_global(const ast::Global &node) override
visit node of type ast::Global
Definition: nmodl_visitor.cpp:1704
nmodl::visitor::NmodlPrintVisitor::visit_unit_def
void visit_unit_def(const ast::UnitDef &node) override
visit node of type ast::UnitDef
Definition: nmodl_visitor.cpp:1065
nmodl::visitor::NmodlPrintVisitor::visit_local_var
void visit_local_var(const ast::LocalVar &node) override
visit node of type ast::LocalVar
Definition: nmodl_visitor.cpp:826
nmodl::visitor::NmodlPrintVisitor::visit_unit
void visit_unit(const ast::Unit &node) override
visit node of type ast::Unit
Definition: nmodl_visitor.cpp:797
nmodl::visitor::NmodlPrintVisitor::visit_if_statement
void visit_if_statement(const ast::IfStatement &node) override
visit node of type ast::IfStatement
Definition: nmodl_visitor.cpp:1368
nmodl::visitor::NmodlPrintVisitor::visit_derivimplicit_callback
void visit_derivimplicit_callback(const ast::DerivimplicitCallback &node) override
visit node of type ast::DerivimplicitCallback
Definition: nmodl_visitor.cpp:1991
nmodl::visitor::NmodlPrintVisitor::visit_assigned_definition
void visit_assigned_definition(const ast::AssignedDefinition &node) override
visit node of type ast::AssignedDefinition
Definition: nmodl_visitor.cpp:1228
nmodl::visitor::NmodlPrintVisitor::visit_name
void visit_name(const ast::Name &node) override
visit node of type ast::Name
Definition: nmodl_visitor.cpp:143
nmodl::visitor::NmodlPrintVisitor::visit_block_comment
void visit_block_comment(const ast::BlockComment &node) override
visit node of type ast::BlockComment
Definition: nmodl_visitor.cpp:1797
nmodl::visitor::NmodlPrintVisitor::visit_from_statement
void visit_from_statement(const ast::FromStatement &node) override
visit node of type ast::FromStatement
Definition: nmodl_visitor.cpp:1318
nmodl::visitor::NmodlPrintVisitor::visit_range
void visit_range(const ast::Range &node) override
visit node of type ast::Range
Definition: nmodl_visitor.cpp:1692
nmodl::visitor::NmodlPrintVisitor::visit_ba_block
void visit_ba_block(const ast::BABlock &node) override
visit node of type ast::BABlock
Definition: nmodl_visitor.cpp:700
nmodl::visitor::NmodlPrintVisitor::visit_reaction_statement
void visit_reaction_statement(const ast::ReactionStatement &node) override
visit node of type ast::ReactionStatement
Definition: nmodl_visitor.cpp:1529
nmodl::visitor::NmodlPrintVisitor::visit_neuron_block
void visit_neuron_block(const ast::NeuronBlock &node) override
visit node of type ast::NeuronBlock
Definition: nmodl_visitor.cpp:783
nmodl::visitor::NmodlPrintVisitor::visit_local_list_statement
void visit_local_list_statement(const ast::LocalListStatement &node) override
visit node of type ast::LocalListStatement
Definition: nmodl_visitor.cpp:1144
nmodl::visitor::NmodlPrintVisitor::visit_extern_var
void visit_extern_var(const ast::ExternVar &node) override
visit node of type ast::ExternVar
Definition: nmodl_visitor.cpp:342
nmodl::visitor::NmodlPrintVisitor::visit_range_var
void visit_range_var(const ast::RangeVar &node) override
visit node of type ast::RangeVar
Definition: nmodl_visitor.cpp:287
nmodl::visitor::NmodlPrintVisitor::visit_prime_name
void visit_prime_name(const ast::PrimeName &node) override
visit node of type ast::PrimeName
Definition: nmodl_visitor.cpp:154
nmodl::visitor::NmodlPrintVisitor::visit_double_unit
void visit_double_unit(const ast::DoubleUnit &node) override
visit node of type ast::DoubleUnit
Definition: nmodl_visitor.cpp:810
nmodl::visitor::NmodlPrintVisitor::visit_useion
void visit_useion(const ast::Useion &node) override
visit node of type ast::Useion
Definition: nmodl_visitor.cpp:1633
nmodl::visitor::NmodlPrintVisitor::visit_procedure_block
void visit_procedure_block(const ast::ProcedureBlock &node) override
visit node of type ast::ProcedureBlock
Definition: nmodl_visitor.cpp:595
nmodl::visitor::NmodlPrintVisitor::visit_unary_expression
void visit_unary_expression(const ast::UnaryExpression &node) override
visit node of type ast::UnaryExpression
Definition: nmodl_visitor.cpp:975
nmodl::visitor::NmodlPrintVisitor::visit_line_comment
void visit_line_comment(const ast::LineComment &node) override
visit node of type ast::LineComment
Definition: nmodl_visitor.cpp:1786
nmodl::visitor::NmodlPrintVisitor::visit_non_linear_block
void visit_non_linear_block(const ast::NonLinearBlock &node) override
visit node of type ast::NonLinearBlock
Definition: nmodl_visitor.cpp:507
nmodl::visitor::NmodlPrintVisitor::visit_constant_block
void visit_constant_block(const ast::ConstantBlock &node) override
visit node of type ast::ConstantBlock
Definition: nmodl_visitor.cpp:769
nmodl::visitor::NmodlPrintVisitor::visit_linear_block
void visit_linear_block(const ast::LinearBlock &node) override
visit node of type ast::LinearBlock
Definition: nmodl_visitor.cpp:483
nmodl::visitor::NmodlPrintVisitor::visit_non_lin_equation
void visit_non_lin_equation(const ast::NonLinEquation &node) override
visit node of type ast::NonLinEquation
Definition: nmodl_visitor.cpp:989
nmodl::visitor::NmodlPrintVisitor::visit_destructor_block
void visit_destructor_block(const ast::DestructorBlock &node) override
visit node of type ast::DestructorBlock
Definition: nmodl_visitor.cpp:438
nmodl::visitor::NmodlPrintVisitor::visit_wrapped_expression
void visit_wrapped_expression(const ast::WrappedExpression &node) override
visit node of type ast::WrappedExpression
Definition: nmodl_visitor.cpp:1980
nmodl::visitor::NmodlPrintVisitor::visit_valence
void visit_valence(const ast::Valence &node) override
visit node of type ast::Valence
Definition: nmodl_visitor.cpp:1115
nmodl::visitor::NmodlPrintVisitor::visit_watch
void visit_watch(const ast::Watch &node) override
visit node of type ast::Watch
Definition: nmodl_visitor.cpp:1035
nmodl::visitor::NmodlPrintVisitor::visit_longitudinal_diffusion_block
void visit_longitudinal_diffusion_block(const ast::LongitudinalDiffusionBlock &node) override
visit node of type ast::LongitudinalDiffusionBlock
Definition: nmodl_visitor.cpp:1956
nmodl::visitor::NmodlPrintVisitor::visit_param_block
void visit_param_block(const ast::ParamBlock &node) override
visit node of type ast::ParamBlock
Definition: nmodl_visitor.cpp:353
nmodl::visitor::NmodlPrintVisitor::visit_cvode_block
void visit_cvode_block(const ast::CvodeBlock &node) override
visit node of type ast::CvodeBlock
Definition: nmodl_visitor.cpp:1928
nmodl::visitor::NmodlPrintVisitor::visit_number_range
void visit_number_range(const ast::NumberRange &node) override
visit node of type ast::NumberRange
Definition: nmodl_visitor.cpp:854
nmodl::visitor::NmodlPrintVisitor::visit_function_table_block
void visit_function_table_block(const ast::FunctionTableBlock &node) override
visit node of type ast::FunctionTableBlock
Definition: nmodl_visitor.cpp:548
nmodl::visitor::NmodlPrintVisitor::visit_net_receive_block
void visit_net_receive_block(const ast::NetReceiveBlock &node) override
visit node of type ast::NetReceiveBlock
Definition: nmodl_visitor.cpp:620
nmodl::visitor::NmodlPrintVisitor::visit_electrode_cur_var
void visit_electrode_cur_var(const ast::ElectrodeCurVar &node) override
visit node of type ast::ElectrodeCurVar
Definition: nmodl_visitor.cpp:276
nmodl::visitor::NmodlPrintVisitor::visit_diff_eq_expression
void visit_diff_eq_expression(const ast::DiffEqExpression &node) override
visit node of type ast::DiffEqExpression
Definition: nmodl_visitor.cpp:964
nmodl::visitor::NmodlPrintVisitor::visit_limits
void visit_limits(const ast::Limits &node) override
visit node of type ast::Limits
Definition: nmodl_visitor.cpp:837
nmodl::visitor::NmodlPrintVisitor::visit_else_if_statement
void visit_else_if_statement(const ast::ElseIfStatement &node) override
visit node of type ast::ElseIfStatement
Definition: nmodl_visitor.cpp:1395
nmodl::visitor::NmodlPrintVisitor::visit_reaction_operator
void visit_reaction_operator(const ast::ReactionOperator &node) override
visit node of type ast::ReactionOperator
Definition: nmodl_visitor.cpp:918
nmodl::visitor::NmodlPrintVisitor::visit_statement
void visit_statement(const ast::Statement &node) override
visit node of type ast::Statement
Definition: nmodl_visitor.cpp:31
nmodl::visitor::NmodlPrintVisitor::visit_mutex_lock
void visit_mutex_lock(const ast::MutexLock &node) override
visit node of type ast::MutexLock
Definition: nmodl_visitor.cpp:1440
nmodl::visitor::NmodlPrintVisitor::visit_assigned_block
void visit_assigned_block(const ast::AssignedBlock &node) override
visit node of type ast::AssignedBlock
Definition: nmodl_visitor.cpp:382
nmodl::visitor::NmodlPrintVisitor::visit_model
void visit_model(const ast::Model &node) override
visit node of type ast::Model
Definition: nmodl_visitor.cpp:1156
nmodl::visitor::NmodlPrintVisitor::visit_independent_block
void visit_independent_block(const ast::IndependentBlock &node) override
visit node of type ast::IndependentBlock
Definition: nmodl_visitor.cpp:367
nmodl::visitor::NmodlPrintVisitor::visit_state_block
void visit_state_block(const ast::StateBlock &node) override
visit node of type ast::StateBlock
Definition: nmodl_visitor.cpp:396
nmodl::visitor::NmodlPrintVisitor::visit_lag_statement
void visit_lag_statement(const ast::LagStatement &node) override
visit node of type ast::LagStatement
Definition: nmodl_visitor.cpp:1561
nmodl::visitor::NmodlPrintVisitor::visit_expression_statement
void visit_expression_statement(const ast::ExpressionStatement &node) override
visit node of type ast::ExpressionStatement
Definition: nmodl_visitor.cpp:1295
nmodl::visitor::NmodlPrintVisitor::visit_constructor_block
void visit_constructor_block(const ast::ConstructorBlock &node) override
visit node of type ast::ConstructorBlock
Definition: nmodl_visitor.cpp:424
nmodl::visitor::NmodlPrintVisitor::visit_boolean
void visit_boolean(const ast::Boolean &node) override
visit node of type ast::Boolean
Definition: nmodl_visitor.cpp:130
nmodl::visitor::NmodlPrintVisitor::visit_table_statement
void visit_table_statement(const ast::TableStatement &node) override
visit node of type ast::TableStatement
Definition: nmodl_visitor.cpp:1588
nmodl::visitor::NmodlPrintVisitor::visit_pointer
void visit_pointer(const ast::Pointer &node) override
visit node of type ast::Pointer
Definition: nmodl_visitor.cpp:1728
nmodl::visitor::NmodlPrintVisitor::visit_discrete_block
void visit_discrete_block(const ast::DiscreteBlock &node) override
visit node of type ast::DiscreteBlock
Definition: nmodl_visitor.cpp:530
nmodl::visitor::NmodlPrintVisitor::visit_param_assign
void visit_param_assign(const ast::ParamAssign &node) override
visit node of type ast::ParamAssign
Definition: nmodl_visitor.cpp:1199
order
static double order(void *v)
Definition: cvodeobj.cpp:218
nmodl::symtab::syminfo::to_string
std::string to_string(const T &obj)
Definition: symbol_properties.hpp:282
nmodl
encapsulates code generation backend implementations
Definition: ast_common.hpp:26
nmodl_visitor.hpp
THIS FILE IS GENERATED AT BUILD TIME AND SHALL NOT BE EDITED.
nmodl_visitor_helper.ipp
node
static Node * node(Object *)
Definition: netcvode.cpp:291