NEURON
json_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/json_visitor.hpp"
13 
14 #include "ast/all.hpp"
15 #include "visitors/visitor_utils.hpp"
16 
17 namespace nmodl {
18 namespace visitor {
19 
20 using namespace ast;
21 
22 void JSONVisitor::visit_node(const Node& node) {
23  (void)node;
24  printer->add_node("Node");
25 }
26 
27 void JSONVisitor::visit_statement(const Statement& node) {
28  (void)node;
29  printer->add_node("Statement");
30 }
31 
32 void JSONVisitor::visit_expression(const Expression& node) {
33  (void)node;
34  printer->add_node("Expression");
35 }
36 
37 void JSONVisitor::visit_block(const Block& node) {
38  (void)node;
39  printer->add_node("Block");
40 }
41 
42 void JSONVisitor::visit_identifier(const Identifier& node) {
43  (void)node;
44  printer->add_node("Identifier");
45 }
46 
47 void JSONVisitor::visit_number(const Number& node) {
48  (void)node;
49  printer->add_node("Number");
50 }
51 
52 void JSONVisitor::visit_string(const String& node) {
53  printer->push_block(node.get_node_type_name());
54  if (embed_nmodl) {
55  printer->add_block_property("nmodl", to_nmodl(node));
56  }
57  node.visit_children(*this);
58  std::stringstream ss;
59  ss << node.eval();
60  printer->add_node(ss.str());
61  printer->pop_block();
62 }
63 
64 void JSONVisitor::visit_integer(const Integer& node) {
65  printer->push_block(node.get_node_type_name());
66  if (embed_nmodl) {
67  printer->add_block_property("nmodl", to_nmodl(node));
68  }
69  node.visit_children(*this);
70  if(!node.get_macro()) {
71  std::stringstream ss;
72  ss << node.eval();
73  printer->add_node(ss.str());
74  }
75  printer->pop_block();
76 }
77 
78 void JSONVisitor::visit_float(const Float& node) {
79  printer->push_block(node.get_node_type_name());
80  if (embed_nmodl) {
81  printer->add_block_property("nmodl", to_nmodl(node));
82  }
83  node.visit_children(*this);
84  std::stringstream ss;
85  ss << node.eval();
86  printer->add_node(ss.str());
87  printer->pop_block();
88 }
89 
90 void JSONVisitor::visit_double(const Double& node) {
91  printer->push_block(node.get_node_type_name());
92  if (embed_nmodl) {
93  printer->add_block_property("nmodl", to_nmodl(node));
94  }
95  node.visit_children(*this);
96  std::stringstream ss;
97  ss << node.eval();
98  printer->add_node(ss.str());
99  printer->pop_block();
100 }
101 
102 void JSONVisitor::visit_boolean(const Boolean& node) {
103  printer->push_block(node.get_node_type_name());
104  if (embed_nmodl) {
105  printer->add_block_property("nmodl", to_nmodl(node));
106  }
107  node.visit_children(*this);
108  std::stringstream ss;
109  ss << node.eval();
110  printer->add_node(ss.str());
111  printer->pop_block();
112 }
113 
114 void JSONVisitor::visit_name(const Name& node) {
115  printer->push_block(node.get_node_type_name());
116  if (embed_nmodl) {
117  printer->add_block_property("nmodl", to_nmodl(node));
118  }
119  node.visit_children(*this);
120  printer->pop_block();
121 }
122 
123 void JSONVisitor::visit_prime_name(const PrimeName& node) {
124  printer->push_block(node.get_node_type_name());
125  if (embed_nmodl) {
126  printer->add_block_property("nmodl", to_nmodl(node));
127  }
128  node.visit_children(*this);
129  printer->pop_block();
130 }
131 
132 void JSONVisitor::visit_indexed_name(const IndexedName& node) {
133  printer->push_block(node.get_node_type_name());
134  if (embed_nmodl) {
135  printer->add_block_property("nmodl", to_nmodl(node));
136  }
137  node.visit_children(*this);
138  printer->pop_block();
139 }
140 
141 void JSONVisitor::visit_var_name(const VarName& node) {
142  printer->push_block(node.get_node_type_name());
143  if (embed_nmodl) {
144  printer->add_block_property("nmodl", to_nmodl(node));
145  }
146  node.visit_children(*this);
147  printer->pop_block();
148 }
149 
150 void JSONVisitor::visit_argument(const Argument& node) {
151  printer->push_block(node.get_node_type_name());
152  if (embed_nmodl) {
153  printer->add_block_property("nmodl", to_nmodl(node));
154  }
155  node.visit_children(*this);
156  printer->pop_block();
157 }
158 
159 void JSONVisitor::visit_react_var_name(const ReactVarName& node) {
160  printer->push_block(node.get_node_type_name());
161  if (embed_nmodl) {
162  printer->add_block_property("nmodl", to_nmodl(node));
163  }
164  node.visit_children(*this);
165  printer->pop_block();
166 }
167 
168 void JSONVisitor::visit_read_ion_var(const ReadIonVar& node) {
169  printer->push_block(node.get_node_type_name());
170  if (embed_nmodl) {
171  printer->add_block_property("nmodl", to_nmodl(node));
172  }
173  node.visit_children(*this);
174  printer->pop_block();
175 }
176 
177 void JSONVisitor::visit_write_ion_var(const WriteIonVar& node) {
178  printer->push_block(node.get_node_type_name());
179  if (embed_nmodl) {
180  printer->add_block_property("nmodl", to_nmodl(node));
181  }
182  node.visit_children(*this);
183  printer->pop_block();
184 }
185 
186 void JSONVisitor::visit_nonspecific_cur_var(const NonspecificCurVar& node) {
187  printer->push_block(node.get_node_type_name());
188  if (embed_nmodl) {
189  printer->add_block_property("nmodl", to_nmodl(node));
190  }
191  node.visit_children(*this);
192  printer->pop_block();
193 }
194 
195 void JSONVisitor::visit_electrode_cur_var(const ElectrodeCurVar& node) {
196  printer->push_block(node.get_node_type_name());
197  if (embed_nmodl) {
198  printer->add_block_property("nmodl", to_nmodl(node));
199  }
200  node.visit_children(*this);
201  printer->pop_block();
202 }
203 
204 void JSONVisitor::visit_range_var(const RangeVar& node) {
205  printer->push_block(node.get_node_type_name());
206  if (embed_nmodl) {
207  printer->add_block_property("nmodl", to_nmodl(node));
208  }
209  node.visit_children(*this);
210  printer->pop_block();
211 }
212 
213 void JSONVisitor::visit_global_var(const GlobalVar& node) {
214  printer->push_block(node.get_node_type_name());
215  if (embed_nmodl) {
216  printer->add_block_property("nmodl", to_nmodl(node));
217  }
218  node.visit_children(*this);
219  printer->pop_block();
220 }
221 
222 void JSONVisitor::visit_pointer_var(const PointerVar& node) {
223  printer->push_block(node.get_node_type_name());
224  if (embed_nmodl) {
225  printer->add_block_property("nmodl", to_nmodl(node));
226  }
227  node.visit_children(*this);
228  printer->pop_block();
229 }
230 
231 void JSONVisitor::visit_random_var(const RandomVar& node) {
232  printer->push_block(node.get_node_type_name());
233  if (embed_nmodl) {
234  printer->add_block_property("nmodl", to_nmodl(node));
235  }
236  node.visit_children(*this);
237  printer->pop_block();
238 }
239 
240 void JSONVisitor::visit_bbcore_pointer_var(const BbcorePointerVar& node) {
241  printer->push_block(node.get_node_type_name());
242  if (embed_nmodl) {
243  printer->add_block_property("nmodl", to_nmodl(node));
244  }
245  node.visit_children(*this);
246  printer->pop_block();
247 }
248 
249 void JSONVisitor::visit_extern_var(const ExternVar& node) {
250  printer->push_block(node.get_node_type_name());
251  if (embed_nmodl) {
252  printer->add_block_property("nmodl", to_nmodl(node));
253  }
254  node.visit_children(*this);
255  printer->pop_block();
256 }
257 
258 void JSONVisitor::visit_param_block(const ParamBlock& node) {
259  printer->push_block(node.get_node_type_name());
260  if (embed_nmodl) {
261  printer->add_block_property("nmodl", to_nmodl(node));
262  }
263  node.visit_children(*this);
264  printer->pop_block();
265 }
266 
267 void JSONVisitor::visit_independent_block(const IndependentBlock& node) {
268  printer->push_block(node.get_node_type_name());
269  if (embed_nmodl) {
270  printer->add_block_property("nmodl", to_nmodl(node));
271  }
272  node.visit_children(*this);
273  printer->pop_block();
274 }
275 
276 void JSONVisitor::visit_assigned_block(const AssignedBlock& node) {
277  printer->push_block(node.get_node_type_name());
278  if (embed_nmodl) {
279  printer->add_block_property("nmodl", to_nmodl(node));
280  }
281  node.visit_children(*this);
282  printer->pop_block();
283 }
284 
285 void JSONVisitor::visit_state_block(const StateBlock& node) {
286  printer->push_block(node.get_node_type_name());
287  if (embed_nmodl) {
288  printer->add_block_property("nmodl", to_nmodl(node));
289  }
290  node.visit_children(*this);
291  printer->pop_block();
292 }
293 
294 void JSONVisitor::visit_initial_block(const InitialBlock& node) {
295  printer->push_block(node.get_node_type_name());
296  if (embed_nmodl) {
297  printer->add_block_property("nmodl", to_nmodl(node));
298  }
299  node.visit_children(*this);
300  printer->pop_block();
301 }
302 
303 void JSONVisitor::visit_constructor_block(const ConstructorBlock& node) {
304  printer->push_block(node.get_node_type_name());
305  if (embed_nmodl) {
306  printer->add_block_property("nmodl", to_nmodl(node));
307  }
308  node.visit_children(*this);
309  printer->pop_block();
310 }
311 
312 void JSONVisitor::visit_destructor_block(const DestructorBlock& node) {
313  printer->push_block(node.get_node_type_name());
314  if (embed_nmodl) {
315  printer->add_block_property("nmodl", to_nmodl(node));
316  }
317  node.visit_children(*this);
318  printer->pop_block();
319 }
320 
321 void JSONVisitor::visit_statement_block(const StatementBlock& node) {
322  printer->push_block(node.get_node_type_name());
323  if (embed_nmodl) {
324  printer->add_block_property("nmodl", to_nmodl(node));
325  }
326  node.visit_children(*this);
327  printer->pop_block();
328 }
329 
330 void JSONVisitor::visit_derivative_block(const DerivativeBlock& node) {
331  printer->push_block(node.get_node_type_name());
332  if (embed_nmodl) {
333  printer->add_block_property("nmodl", to_nmodl(node));
334  }
335  node.visit_children(*this);
336  printer->pop_block();
337 }
338 
339 void JSONVisitor::visit_linear_block(const LinearBlock& node) {
340  printer->push_block(node.get_node_type_name());
341  if (embed_nmodl) {
342  printer->add_block_property("nmodl", to_nmodl(node));
343  }
344  node.visit_children(*this);
345  printer->pop_block();
346 }
347 
348 void JSONVisitor::visit_non_linear_block(const NonLinearBlock& node) {
349  printer->push_block(node.get_node_type_name());
350  if (embed_nmodl) {
351  printer->add_block_property("nmodl", to_nmodl(node));
352  }
353  node.visit_children(*this);
354  printer->pop_block();
355 }
356 
357 void JSONVisitor::visit_discrete_block(const DiscreteBlock& node) {
358  printer->push_block(node.get_node_type_name());
359  if (embed_nmodl) {
360  printer->add_block_property("nmodl", to_nmodl(node));
361  }
362  node.visit_children(*this);
363  printer->pop_block();
364 }
365 
366 void JSONVisitor::visit_function_table_block(const FunctionTableBlock& node) {
367  printer->push_block(node.get_node_type_name());
368  if (embed_nmodl) {
369  printer->add_block_property("nmodl", to_nmodl(node));
370  }
371  node.visit_children(*this);
372  printer->pop_block();
373 }
374 
375 void JSONVisitor::visit_function_block(const FunctionBlock& node) {
376  printer->push_block(node.get_node_type_name());
377  if (embed_nmodl) {
378  printer->add_block_property("nmodl", to_nmodl(node));
379  }
380  node.visit_children(*this);
381  printer->pop_block();
382 }
383 
384 void JSONVisitor::visit_procedure_block(const ProcedureBlock& node) {
385  printer->push_block(node.get_node_type_name());
386  if (embed_nmodl) {
387  printer->add_block_property("nmodl", to_nmodl(node));
388  }
389  node.visit_children(*this);
390  printer->pop_block();
391 }
392 
393 void JSONVisitor::visit_net_receive_block(const NetReceiveBlock& node) {
394  printer->push_block(node.get_node_type_name());
395  if (embed_nmodl) {
396  printer->add_block_property("nmodl", to_nmodl(node));
397  }
398  node.visit_children(*this);
399  printer->pop_block();
400 }
401 
402 void JSONVisitor::visit_solve_block(const SolveBlock& node) {
403  printer->push_block(node.get_node_type_name());
404  if (embed_nmodl) {
405  printer->add_block_property("nmodl", to_nmodl(node));
406  }
407  node.visit_children(*this);
408  printer->pop_block();
409 }
410 
411 void JSONVisitor::visit_breakpoint_block(const BreakpointBlock& node) {
412  printer->push_block(node.get_node_type_name());
413  if (embed_nmodl) {
414  printer->add_block_property("nmodl", to_nmodl(node));
415  }
416  node.visit_children(*this);
417  printer->pop_block();
418 }
419 
420 void JSONVisitor::visit_before_block(const BeforeBlock& node) {
421  printer->push_block(node.get_node_type_name());
422  if (embed_nmodl) {
423  printer->add_block_property("nmodl", to_nmodl(node));
424  }
425  node.visit_children(*this);
426  printer->pop_block();
427 }
428 
429 void JSONVisitor::visit_after_block(const AfterBlock& node) {
430  printer->push_block(node.get_node_type_name());
431  if (embed_nmodl) {
432  printer->add_block_property("nmodl", to_nmodl(node));
433  }
434  node.visit_children(*this);
435  printer->pop_block();
436 }
437 
438 void JSONVisitor::visit_ba_block(const BABlock& node) {
439  printer->push_block(node.get_node_type_name());
440  if (embed_nmodl) {
441  printer->add_block_property("nmodl", to_nmodl(node));
442  }
443  node.visit_children(*this);
444  printer->pop_block();
445 }
446 
447 void JSONVisitor::visit_for_netcon(const ForNetcon& node) {
448  printer->push_block(node.get_node_type_name());
449  if (embed_nmodl) {
450  printer->add_block_property("nmodl", to_nmodl(node));
451  }
452  node.visit_children(*this);
453  printer->pop_block();
454 }
455 
456 void JSONVisitor::visit_kinetic_block(const KineticBlock& node) {
457  printer->push_block(node.get_node_type_name());
458  if (embed_nmodl) {
459  printer->add_block_property("nmodl", to_nmodl(node));
460  }
461  node.visit_children(*this);
462  printer->pop_block();
463 }
464 
465 void JSONVisitor::visit_unit_block(const UnitBlock& node) {
466  printer->push_block(node.get_node_type_name());
467  if (embed_nmodl) {
468  printer->add_block_property("nmodl", to_nmodl(node));
469  }
470  node.visit_children(*this);
471  printer->pop_block();
472 }
473 
474 void JSONVisitor::visit_constant_block(const ConstantBlock& node) {
475  printer->push_block(node.get_node_type_name());
476  if (embed_nmodl) {
477  printer->add_block_property("nmodl", to_nmodl(node));
478  }
479  node.visit_children(*this);
480  printer->pop_block();
481 }
482 
483 void JSONVisitor::visit_neuron_block(const NeuronBlock& node) {
484  printer->push_block(node.get_node_type_name());
485  if (embed_nmodl) {
486  printer->add_block_property("nmodl", to_nmodl(node));
487  }
488  node.visit_children(*this);
489  printer->pop_block();
490 }
491 
492 void JSONVisitor::visit_unit(const Unit& node) {
493  printer->push_block(node.get_node_type_name());
494  if (embed_nmodl) {
495  printer->add_block_property("nmodl", to_nmodl(node));
496  }
497  node.visit_children(*this);
498  printer->pop_block();
499 }
500 
501 void JSONVisitor::visit_double_unit(const DoubleUnit& node) {
502  printer->push_block(node.get_node_type_name());
503  if (embed_nmodl) {
504  printer->add_block_property("nmodl", to_nmodl(node));
505  }
506  node.visit_children(*this);
507  printer->pop_block();
508 }
509 
510 void JSONVisitor::visit_local_var(const LocalVar& node) {
511  printer->push_block(node.get_node_type_name());
512  if (embed_nmodl) {
513  printer->add_block_property("nmodl", to_nmodl(node));
514  }
515  node.visit_children(*this);
516  printer->pop_block();
517 }
518 
519 void JSONVisitor::visit_limits(const Limits& node) {
520  printer->push_block(node.get_node_type_name());
521  if (embed_nmodl) {
522  printer->add_block_property("nmodl", to_nmodl(node));
523  }
524  node.visit_children(*this);
525  printer->pop_block();
526 }
527 
528 void JSONVisitor::visit_number_range(const NumberRange& node) {
529  printer->push_block(node.get_node_type_name());
530  if (embed_nmodl) {
531  printer->add_block_property("nmodl", to_nmodl(node));
532  }
533  node.visit_children(*this);
534  printer->pop_block();
535 }
536 
537 void JSONVisitor::visit_constant_var(const ConstantVar& node) {
538  printer->push_block(node.get_node_type_name());
539  if (embed_nmodl) {
540  printer->add_block_property("nmodl", to_nmodl(node));
541  }
542  node.visit_children(*this);
543  printer->pop_block();
544 }
545 
546 void JSONVisitor::visit_binary_operator(const BinaryOperator& node) {
547  printer->push_block(node.get_node_type_name());
548  if (embed_nmodl) {
549  printer->add_block_property("nmodl", to_nmodl(node));
550  }
551  node.visit_children(*this);
552  std::stringstream ss;
553  ss << node.eval();
554  printer->add_node(ss.str());
555  printer->pop_block();
556 }
557 
558 void JSONVisitor::visit_unary_operator(const UnaryOperator& node) {
559  printer->push_block(node.get_node_type_name());
560  if (embed_nmodl) {
561  printer->add_block_property("nmodl", to_nmodl(node));
562  }
563  node.visit_children(*this);
564  std::stringstream ss;
565  ss << node.eval();
566  printer->add_node(ss.str());
567  printer->pop_block();
568 }
569 
570 void JSONVisitor::visit_reaction_operator(const ReactionOperator& node) {
571  printer->push_block(node.get_node_type_name());
572  if (embed_nmodl) {
573  printer->add_block_property("nmodl", to_nmodl(node));
574  }
575  node.visit_children(*this);
576  std::stringstream ss;
577  ss << node.eval();
578  printer->add_node(ss.str());
579  printer->pop_block();
580 }
581 
582 void JSONVisitor::visit_paren_expression(const ParenExpression& node) {
583  printer->push_block(node.get_node_type_name());
584  if (embed_nmodl) {
585  printer->add_block_property("nmodl", to_nmodl(node));
586  }
587  node.visit_children(*this);
588  printer->pop_block();
589 }
590 
591 void JSONVisitor::visit_binary_expression(const BinaryExpression& node) {
592  printer->push_block(node.get_node_type_name());
593  if (embed_nmodl) {
594  printer->add_block_property("nmodl", to_nmodl(node));
595  }
596  node.visit_children(*this);
597  printer->pop_block();
598 }
599 
600 void JSONVisitor::visit_diff_eq_expression(const DiffEqExpression& node) {
601  printer->push_block(node.get_node_type_name());
602  if (embed_nmodl) {
603  printer->add_block_property("nmodl", to_nmodl(node));
604  }
605  node.visit_children(*this);
606  printer->pop_block();
607 }
608 
609 void JSONVisitor::visit_unary_expression(const UnaryExpression& node) {
610  printer->push_block(node.get_node_type_name());
611  if (embed_nmodl) {
612  printer->add_block_property("nmodl", to_nmodl(node));
613  }
614  node.visit_children(*this);
615  printer->pop_block();
616 }
617 
618 void JSONVisitor::visit_non_lin_equation(const NonLinEquation& node) {
619  printer->push_block(node.get_node_type_name());
620  if (embed_nmodl) {
621  printer->add_block_property("nmodl", to_nmodl(node));
622  }
623  node.visit_children(*this);
624  printer->pop_block();
625 }
626 
627 void JSONVisitor::visit_lin_equation(const LinEquation& node) {
628  printer->push_block(node.get_node_type_name());
629  if (embed_nmodl) {
630  printer->add_block_property("nmodl", to_nmodl(node));
631  }
632  node.visit_children(*this);
633  printer->pop_block();
634 }
635 
636 void JSONVisitor::visit_function_call(const FunctionCall& node) {
637  printer->push_block(node.get_node_type_name());
638  if (embed_nmodl) {
639  printer->add_block_property("nmodl", to_nmodl(node));
640  }
641  node.visit_children(*this);
642  printer->pop_block();
643 }
644 
645 void JSONVisitor::visit_watch(const Watch& node) {
646  printer->push_block(node.get_node_type_name());
647  if (embed_nmodl) {
648  printer->add_block_property("nmodl", to_nmodl(node));
649  }
650  node.visit_children(*this);
651  printer->pop_block();
652 }
653 
654 void JSONVisitor::visit_ba_block_type(const BABlockType& node) {
655  printer->push_block(node.get_node_type_name());
656  if (embed_nmodl) {
657  printer->add_block_property("nmodl", to_nmodl(node));
658  }
659  node.visit_children(*this);
660  std::stringstream ss;
661  ss << node.eval();
662  printer->add_node(ss.str());
663  printer->pop_block();
664 }
665 
666 void JSONVisitor::visit_unit_def(const UnitDef& node) {
667  printer->push_block(node.get_node_type_name());
668  if (embed_nmodl) {
669  printer->add_block_property("nmodl", to_nmodl(node));
670  }
671  node.visit_children(*this);
672  printer->pop_block();
673 }
674 
675 void JSONVisitor::visit_factor_def(const FactorDef& node) {
676  printer->push_block(node.get_node_type_name());
677  if (embed_nmodl) {
678  printer->add_block_property("nmodl", to_nmodl(node));
679  }
680  node.visit_children(*this);
681  printer->pop_block();
682 }
683 
684 void JSONVisitor::visit_valence(const Valence& node) {
685  printer->push_block(node.get_node_type_name());
686  if (embed_nmodl) {
687  printer->add_block_property("nmodl", to_nmodl(node));
688  }
689  node.visit_children(*this);
690  printer->pop_block();
691 }
692 
693 void JSONVisitor::visit_unit_state(const UnitState& node) {
694  printer->push_block(node.get_node_type_name());
695  if (embed_nmodl) {
696  printer->add_block_property("nmodl", to_nmodl(node));
697  }
698  node.visit_children(*this);
699  std::stringstream ss;
700  ss << node.eval();
701  printer->add_node(ss.str());
702  printer->pop_block();
703 }
704 
705 void JSONVisitor::visit_local_list_statement(const LocalListStatement& node) {
706  printer->push_block(node.get_node_type_name());
707  if (embed_nmodl) {
708  printer->add_block_property("nmodl", to_nmodl(node));
709  }
710  node.visit_children(*this);
711  printer->pop_block();
712 }
713 
714 void JSONVisitor::visit_model(const Model& node) {
715  printer->push_block(node.get_node_type_name());
716  if (embed_nmodl) {
717  printer->add_block_property("nmodl", to_nmodl(node));
718  }
719  node.visit_children(*this);
720  printer->pop_block();
721 }
722 
723 void JSONVisitor::visit_define(const Define& node) {
724  printer->push_block(node.get_node_type_name());
725  if (embed_nmodl) {
726  printer->add_block_property("nmodl", to_nmodl(node));
727  }
728  node.visit_children(*this);
729  printer->pop_block();
730 }
731 
732 void JSONVisitor::visit_include(const Include& node) {
733  printer->push_block(node.get_node_type_name());
734  if (embed_nmodl) {
735  printer->add_block_property("nmodl", to_nmodl(node));
736  }
737  node.visit_children(*this);
738  printer->pop_block();
739 }
740 
741 void JSONVisitor::visit_param_assign(const ParamAssign& node) {
742  printer->push_block(node.get_node_type_name());
743  if (embed_nmodl) {
744  printer->add_block_property("nmodl", to_nmodl(node));
745  }
746  node.visit_children(*this);
747  printer->pop_block();
748 }
749 
750 void JSONVisitor::visit_assigned_definition(const AssignedDefinition& node) {
751  printer->push_block(node.get_node_type_name());
752  if (embed_nmodl) {
753  printer->add_block_property("nmodl", to_nmodl(node));
754  }
755  node.visit_children(*this);
756  printer->pop_block();
757 }
758 
759 void JSONVisitor::visit_conductance_hint(const ConductanceHint& node) {
760  printer->push_block(node.get_node_type_name());
761  if (embed_nmodl) {
762  printer->add_block_property("nmodl", to_nmodl(node));
763  }
764  node.visit_children(*this);
765  printer->pop_block();
766 }
767 
768 void JSONVisitor::visit_expression_statement(const ExpressionStatement& node) {
769  printer->push_block(node.get_node_type_name());
770  if (embed_nmodl) {
771  printer->add_block_property("nmodl", to_nmodl(node));
772  }
773  node.visit_children(*this);
774  printer->pop_block();
775 }
776 
777 void JSONVisitor::visit_protect_statement(const ProtectStatement& node) {
778  printer->push_block(node.get_node_type_name());
779  if (embed_nmodl) {
780  printer->add_block_property("nmodl", to_nmodl(node));
781  }
782  node.visit_children(*this);
783  printer->pop_block();
784 }
785 
786 void JSONVisitor::visit_from_statement(const FromStatement& node) {
787  printer->push_block(node.get_node_type_name());
788  if (embed_nmodl) {
789  printer->add_block_property("nmodl", to_nmodl(node));
790  }
791  node.visit_children(*this);
792  printer->pop_block();
793 }
794 
795 void JSONVisitor::visit_while_statement(const WhileStatement& node) {
796  printer->push_block(node.get_node_type_name());
797  if (embed_nmodl) {
798  printer->add_block_property("nmodl", to_nmodl(node));
799  }
800  node.visit_children(*this);
801  printer->pop_block();
802 }
803 
804 void JSONVisitor::visit_if_statement(const IfStatement& node) {
805  printer->push_block(node.get_node_type_name());
806  if (embed_nmodl) {
807  printer->add_block_property("nmodl", to_nmodl(node));
808  }
809  node.visit_children(*this);
810  printer->pop_block();
811 }
812 
813 void JSONVisitor::visit_else_if_statement(const ElseIfStatement& node) {
814  printer->push_block(node.get_node_type_name());
815  if (embed_nmodl) {
816  printer->add_block_property("nmodl", to_nmodl(node));
817  }
818  node.visit_children(*this);
819  printer->pop_block();
820 }
821 
822 void JSONVisitor::visit_else_statement(const ElseStatement& node) {
823  printer->push_block(node.get_node_type_name());
824  if (embed_nmodl) {
825  printer->add_block_property("nmodl", to_nmodl(node));
826  }
827  node.visit_children(*this);
828  printer->pop_block();
829 }
830 
831 void JSONVisitor::visit_watch_statement(const WatchStatement& node) {
832  printer->push_block(node.get_node_type_name());
833  if (embed_nmodl) {
834  printer->add_block_property("nmodl", to_nmodl(node));
835  }
836  node.visit_children(*this);
837  printer->pop_block();
838 }
839 
840 void JSONVisitor::visit_mutex_lock(const MutexLock& node) {
841  (void)node;
842  printer->add_node("MutexLock");
843 }
844 
845 void JSONVisitor::visit_mutex_unlock(const MutexUnlock& node) {
846  (void)node;
847  printer->add_node("MutexUnlock");
848 }
849 
850 void JSONVisitor::visit_conserve(const Conserve& node) {
851  printer->push_block(node.get_node_type_name());
852  if (embed_nmodl) {
853  printer->add_block_property("nmodl", to_nmodl(node));
854  }
855  node.visit_children(*this);
856  printer->pop_block();
857 }
858 
859 void JSONVisitor::visit_compartment(const Compartment& node) {
860  printer->push_block(node.get_node_type_name());
861  if (embed_nmodl) {
862  printer->add_block_property("nmodl", to_nmodl(node));
863  }
864  node.visit_children(*this);
865  printer->pop_block();
866 }
867 
868 void JSONVisitor::visit_lon_diffuse(const LonDiffuse& node) {
869  printer->push_block(node.get_node_type_name());
870  if (embed_nmodl) {
871  printer->add_block_property("nmodl", to_nmodl(node));
872  }
873  node.visit_children(*this);
874  printer->pop_block();
875 }
876 
877 void JSONVisitor::visit_reaction_statement(const ReactionStatement& node) {
878  printer->push_block(node.get_node_type_name());
879  if (embed_nmodl) {
880  printer->add_block_property("nmodl", to_nmodl(node));
881  }
882  node.visit_children(*this);
883  printer->pop_block();
884 }
885 
886 void JSONVisitor::visit_lag_statement(const LagStatement& node) {
887  printer->push_block(node.get_node_type_name());
888  if (embed_nmodl) {
889  printer->add_block_property("nmodl", to_nmodl(node));
890  }
891  node.visit_children(*this);
892  printer->pop_block();
893 }
894 
895 void JSONVisitor::visit_constant_statement(const ConstantStatement& node) {
896  printer->push_block(node.get_node_type_name());
897  if (embed_nmodl) {
898  printer->add_block_property("nmodl", to_nmodl(node));
899  }
900  node.visit_children(*this);
901  printer->pop_block();
902 }
903 
904 void JSONVisitor::visit_table_statement(const TableStatement& node) {
905  printer->push_block(node.get_node_type_name());
906  if (embed_nmodl) {
907  printer->add_block_property("nmodl", to_nmodl(node));
908  }
909  node.visit_children(*this);
910  printer->pop_block();
911 }
912 
913 void JSONVisitor::visit_suffix(const Suffix& node) {
914  printer->push_block(node.get_node_type_name());
915  if (embed_nmodl) {
916  printer->add_block_property("nmodl", to_nmodl(node));
917  }
918  node.visit_children(*this);
919  printer->pop_block();
920 }
921 
922 void JSONVisitor::visit_useion(const Useion& node) {
923  printer->push_block(node.get_node_type_name());
924  if (embed_nmodl) {
925  printer->add_block_property("nmodl", to_nmodl(node));
926  }
927  node.visit_children(*this);
928  printer->pop_block();
929 }
930 
931 void JSONVisitor::visit_nonspecific(const Nonspecific& node) {
932  printer->push_block(node.get_node_type_name());
933  if (embed_nmodl) {
934  printer->add_block_property("nmodl", to_nmodl(node));
935  }
936  node.visit_children(*this);
937  printer->pop_block();
938 }
939 
940 void JSONVisitor::visit_electrode_current(const ElectrodeCurrent& node) {
941  printer->push_block(node.get_node_type_name());
942  if (embed_nmodl) {
943  printer->add_block_property("nmodl", to_nmodl(node));
944  }
945  node.visit_children(*this);
946  printer->pop_block();
947 }
948 
949 void JSONVisitor::visit_range(const Range& node) {
950  printer->push_block(node.get_node_type_name());
951  if (embed_nmodl) {
952  printer->add_block_property("nmodl", to_nmodl(node));
953  }
954  node.visit_children(*this);
955  printer->pop_block();
956 }
957 
958 void JSONVisitor::visit_global(const Global& node) {
959  printer->push_block(node.get_node_type_name());
960  if (embed_nmodl) {
961  printer->add_block_property("nmodl", to_nmodl(node));
962  }
963  node.visit_children(*this);
964  printer->pop_block();
965 }
966 
967 void JSONVisitor::visit_random_var_list(const RandomVarList& node) {
968  printer->push_block(node.get_node_type_name());
969  if (embed_nmodl) {
970  printer->add_block_property("nmodl", to_nmodl(node));
971  }
972  node.visit_children(*this);
973  printer->pop_block();
974 }
975 
976 void JSONVisitor::visit_pointer(const Pointer& node) {
977  printer->push_block(node.get_node_type_name());
978  if (embed_nmodl) {
979  printer->add_block_property("nmodl", to_nmodl(node));
980  }
981  node.visit_children(*this);
982  printer->pop_block();
983 }
984 
985 void JSONVisitor::visit_bbcore_pointer(const BbcorePointer& node) {
986  printer->push_block(node.get_node_type_name());
987  if (embed_nmodl) {
988  printer->add_block_property("nmodl", to_nmodl(node));
989  }
990  node.visit_children(*this);
991  printer->pop_block();
992 }
993 
994 void JSONVisitor::visit_external(const External& node) {
995  printer->push_block(node.get_node_type_name());
996  if (embed_nmodl) {
997  printer->add_block_property("nmodl", to_nmodl(node));
998  }
999  node.visit_children(*this);
1000  printer->pop_block();
1001 }
1002 
1003 void JSONVisitor::visit_thread_safe(const ThreadSafe& node) {
1004  (void)node;
1005  printer->add_node("ThreadSafe");
1006 }
1007 
1008 void JSONVisitor::visit_verbatim(const Verbatim& node) {
1009  printer->push_block(node.get_node_type_name());
1010  if (embed_nmodl) {
1011  printer->add_block_property("nmodl", to_nmodl(node));
1012  }
1013  node.visit_children(*this);
1014  printer->pop_block();
1015 }
1016 
1017 void JSONVisitor::visit_line_comment(const LineComment& node) {
1018  printer->push_block(node.get_node_type_name());
1019  if (embed_nmodl) {
1020  printer->add_block_property("nmodl", to_nmodl(node));
1021  }
1022  node.visit_children(*this);
1023  printer->pop_block();
1024 }
1025 
1026 void JSONVisitor::visit_block_comment(const BlockComment& node) {
1027  printer->push_block(node.get_node_type_name());
1028  if (embed_nmodl) {
1029  printer->add_block_property("nmodl", to_nmodl(node));
1030  }
1031  node.visit_children(*this);
1032  printer->pop_block();
1033 }
1034 
1035 void JSONVisitor::visit_ontology_statement(const OntologyStatement& node) {
1036  printer->push_block(node.get_node_type_name());
1037  if (embed_nmodl) {
1038  printer->add_block_property("nmodl", to_nmodl(node));
1039  }
1040  node.visit_children(*this);
1041  printer->pop_block();
1042 }
1043 
1044 void JSONVisitor::visit_program(const Program& node) {
1045  printer->push_block(node.get_node_type_name());
1046  if (embed_nmodl) {
1047  printer->add_block_property("nmodl", to_nmodl(node));
1048  }
1049  node.visit_children(*this);
1050  printer->pop_block();
1051  if (node.get_parent() == nullptr) {
1052  flush();
1053  }
1054 }
1055 
1056 void JSONVisitor::visit_nrn_state_block(const NrnStateBlock& node) {
1057  printer->push_block(node.get_node_type_name());
1058  if (embed_nmodl) {
1059  printer->add_block_property("nmodl", to_nmodl(node));
1060  }
1061  node.visit_children(*this);
1062  printer->pop_block();
1063 }
1064 
1065 void JSONVisitor::visit_eigen_newton_solver_block(const EigenNewtonSolverBlock& node) {
1066  printer->push_block(node.get_node_type_name());
1067  if (embed_nmodl) {
1068  printer->add_block_property("nmodl", to_nmodl(node));
1069  }
1070  node.visit_children(*this);
1071  printer->pop_block();
1072 }
1073 
1074 void JSONVisitor::visit_eigen_linear_solver_block(const EigenLinearSolverBlock& node) {
1075  printer->push_block(node.get_node_type_name());
1076  if (embed_nmodl) {
1077  printer->add_block_property("nmodl", to_nmodl(node));
1078  }
1079  node.visit_children(*this);
1080  printer->pop_block();
1081 }
1082 
1083 void JSONVisitor::visit_cvode_block(const CvodeBlock& node) {
1084  printer->push_block(node.get_node_type_name());
1085  if (embed_nmodl) {
1086  printer->add_block_property("nmodl", to_nmodl(node));
1087  }
1088  node.visit_children(*this);
1089  printer->pop_block();
1090 }
1091 
1092 void JSONVisitor::visit_longitudinal_diffusion_block(const LongitudinalDiffusionBlock& node) {
1093  printer->push_block(node.get_node_type_name());
1094  if (embed_nmodl) {
1095  printer->add_block_property("nmodl", to_nmodl(node));
1096  }
1097  node.visit_children(*this);
1098  printer->pop_block();
1099 }
1100 
1101 void JSONVisitor::visit_wrapped_expression(const WrappedExpression& node) {
1102  printer->push_block(node.get_node_type_name());
1103  if (embed_nmodl) {
1104  printer->add_block_property("nmodl", to_nmodl(node));
1105  }
1106  node.visit_children(*this);
1107  printer->pop_block();
1108 }
1109 
1110 void JSONVisitor::visit_derivimplicit_callback(const DerivimplicitCallback& node) {
1111  printer->push_block(node.get_node_type_name());
1112  if (embed_nmodl) {
1113  printer->add_block_property("nmodl", to_nmodl(node));
1114  }
1115  node.visit_children(*this);
1116  printer->pop_block();
1117 }
1118 
1119 void JSONVisitor::visit_solution_expression(const SolutionExpression& node) {
1120  printer->push_block(node.get_node_type_name());
1121  if (embed_nmodl) {
1122  printer->add_block_property("nmodl", to_nmodl(node));
1123  }
1124  node.visit_children(*this);
1125  printer->pop_block();
1126 }
1127 
1128 void JSONVisitor::visit_update_dt(const UpdateDt& node) {
1129  printer->push_block(node.get_node_type_name());
1130  if (embed_nmodl) {
1131  printer->add_block_property("nmodl", to_nmodl(node));
1132  }
1133  node.visit_children(*this);
1134  printer->pop_block();
1135 }
1136 
1137 
1138 } // namespace visitor
1139 } // namespace nmodl
1140 
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::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::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::JSONVisitor::visit_wrapped_expression
void visit_wrapped_expression(const ast::WrappedExpression &node) override
visit node of type ast::WrappedExpression
Definition: json_visitor.cpp:1101
nmodl::visitor::JSONVisitor::visit_program
void visit_program(const ast::Program &node) override
visit node of type ast::Program
Definition: json_visitor.cpp:1044
nmodl::visitor::JSONVisitor::visit_ontology_statement
void visit_ontology_statement(const ast::OntologyStatement &node) override
visit node of type ast::OntologyStatement
Definition: json_visitor.cpp:1035
nmodl::visitor::JSONVisitor::visit_expression_statement
void visit_expression_statement(const ast::ExpressionStatement &node) override
visit node of type ast::ExpressionStatement
Definition: json_visitor.cpp:768
nmodl::visitor::JSONVisitor::visit_var_name
void visit_var_name(const ast::VarName &node) override
visit node of type ast::VarName
Definition: json_visitor.cpp:141
nmodl::visitor::JSONVisitor::visit_eigen_linear_solver_block
void visit_eigen_linear_solver_block(const ast::EigenLinearSolverBlock &node) override
visit node of type ast::EigenLinearSolverBlock
Definition: json_visitor.cpp:1074
nmodl::visitor::JSONVisitor::visit_nonspecific_cur_var
void visit_nonspecific_cur_var(const ast::NonspecificCurVar &node) override
visit node of type ast::NonspecificCurVar
Definition: json_visitor.cpp:186
nmodl::visitor::JSONVisitor::visit_assigned_block
void visit_assigned_block(const ast::AssignedBlock &node) override
visit node of type ast::AssignedBlock
Definition: json_visitor.cpp:276
nmodl::visitor::JSONVisitor::visit_external
void visit_external(const ast::External &node) override
visit node of type ast::External
Definition: json_visitor.cpp:994
nmodl::visitor::JSONVisitor::visit_read_ion_var
void visit_read_ion_var(const ast::ReadIonVar &node) override
visit node of type ast::ReadIonVar
Definition: json_visitor.cpp:168
nmodl::visitor::JSONVisitor::visit_define
void visit_define(const ast::Define &node) override
visit node of type ast::Define
Definition: json_visitor.cpp:723
nmodl::visitor::JSONVisitor::visit_protect_statement
void visit_protect_statement(const ast::ProtectStatement &node) override
visit node of type ast::ProtectStatement
Definition: json_visitor.cpp:777
nmodl::visitor::JSONVisitor::visit_react_var_name
void visit_react_var_name(const ast::ReactVarName &node) override
visit node of type ast::ReactVarName
Definition: json_visitor.cpp:159
nmodl::visitor::JSONVisitor::visit_nrn_state_block
void visit_nrn_state_block(const ast::NrnStateBlock &node) override
visit node of type ast::NrnStateBlock
Definition: json_visitor.cpp:1056
nmodl::visitor::JSONVisitor::visit_linear_block
void visit_linear_block(const ast::LinearBlock &node) override
visit node of type ast::LinearBlock
Definition: json_visitor.cpp:339
nmodl::visitor::JSONVisitor::visit_include
void visit_include(const ast::Include &node) override
visit node of type ast::Include
Definition: json_visitor.cpp:732
nmodl::visitor::JSONVisitor::visit_expression
void visit_expression(const ast::Expression &node) override
visit node of type ast::Expression
Definition: json_visitor.cpp:32
nmodl::visitor::JSONVisitor::visit_compartment
void visit_compartment(const ast::Compartment &node) override
visit node of type ast::Compartment
Definition: json_visitor.cpp:859
nmodl::visitor::JSONVisitor::visit_global_var
void visit_global_var(const ast::GlobalVar &node) override
visit node of type ast::GlobalVar
Definition: json_visitor.cpp:213
nmodl::visitor::JSONVisitor::visit_reaction_operator
void visit_reaction_operator(const ast::ReactionOperator &node) override
visit node of type ast::ReactionOperator
Definition: json_visitor.cpp:570
nmodl::visitor::JSONVisitor::visit_mutex_unlock
void visit_mutex_unlock(const ast::MutexUnlock &node) override
visit node of type ast::MutexUnlock
Definition: json_visitor.cpp:845
nmodl::visitor::JSONVisitor::visit_non_linear_block
void visit_non_linear_block(const ast::NonLinearBlock &node) override
visit node of type ast::NonLinearBlock
Definition: json_visitor.cpp:348
nmodl::visitor::JSONVisitor::visit_cvode_block
void visit_cvode_block(const ast::CvodeBlock &node) override
visit node of type ast::CvodeBlock
Definition: json_visitor.cpp:1083
nmodl::visitor::JSONVisitor::visit_model
void visit_model(const ast::Model &node) override
visit node of type ast::Model
Definition: json_visitor.cpp:714
nmodl::visitor::JSONVisitor::visit_block
void visit_block(const ast::Block &node) override
visit node of type ast::Block
Definition: json_visitor.cpp:37
nmodl::visitor::JSONVisitor::visit_unary_operator
void visit_unary_operator(const ast::UnaryOperator &node) override
visit node of type ast::UnaryOperator
Definition: json_visitor.cpp:558
nmodl::visitor::JSONVisitor::visit_verbatim
void visit_verbatim(const ast::Verbatim &node) override
visit node of type ast::Verbatim
Definition: json_visitor.cpp:1008
nmodl::visitor::JSONVisitor::visit_write_ion_var
void visit_write_ion_var(const ast::WriteIonVar &node) override
visit node of type ast::WriteIonVar
Definition: json_visitor.cpp:177
nmodl::visitor::JSONVisitor::visit_boolean
void visit_boolean(const ast::Boolean &node) override
visit node of type ast::Boolean
Definition: json_visitor.cpp:102
nmodl::visitor::JSONVisitor::visit_reaction_statement
void visit_reaction_statement(const ast::ReactionStatement &node) override
visit node of type ast::ReactionStatement
Definition: json_visitor.cpp:877
nmodl::visitor::JSONVisitor::visit_local_list_statement
void visit_local_list_statement(const ast::LocalListStatement &node) override
visit node of type ast::LocalListStatement
Definition: json_visitor.cpp:705
nmodl::visitor::JSONVisitor::visit_kinetic_block
void visit_kinetic_block(const ast::KineticBlock &node) override
visit node of type ast::KineticBlock
Definition: json_visitor.cpp:456
nmodl::visitor::JSONVisitor::visit_prime_name
void visit_prime_name(const ast::PrimeName &node) override
visit node of type ast::PrimeName
Definition: json_visitor.cpp:123
nmodl::visitor::JSONVisitor::visit_ba_block
void visit_ba_block(const ast::BABlock &node) override
visit node of type ast::BABlock
Definition: json_visitor.cpp:438
nmodl::visitor::JSONVisitor::visit_watch
void visit_watch(const ast::Watch &node) override
visit node of type ast::Watch
Definition: json_visitor.cpp:645
nmodl::visitor::JSONVisitor::visit_procedure_block
void visit_procedure_block(const ast::ProcedureBlock &node) override
visit node of type ast::ProcedureBlock
Definition: json_visitor.cpp:384
nmodl::visitor::JSONVisitor::visit_electrode_current
void visit_electrode_current(const ast::ElectrodeCurrent &node) override
visit node of type ast::ElectrodeCurrent
Definition: json_visitor.cpp:940
nmodl::visitor::JSONVisitor::visit_solve_block
void visit_solve_block(const ast::SolveBlock &node) override
visit node of type ast::SolveBlock
Definition: json_visitor.cpp:402
nmodl::visitor::JSONVisitor::visit_conserve
void visit_conserve(const ast::Conserve &node) override
visit node of type ast::Conserve
Definition: json_visitor.cpp:850
nmodl::visitor::JSONVisitor::visit_for_netcon
void visit_for_netcon(const ast::ForNetcon &node) override
visit node of type ast::ForNetcon
Definition: json_visitor.cpp:447
nmodl::visitor::JSONVisitor::visit_unit_block
void visit_unit_block(const ast::UnitBlock &node) override
visit node of type ast::UnitBlock
Definition: json_visitor.cpp:465
nmodl::visitor::JSONVisitor::visit_suffix
void visit_suffix(const ast::Suffix &node) override
visit node of type ast::Suffix
Definition: json_visitor.cpp:913
nmodl::visitor::JSONVisitor::visit_statement
void visit_statement(const ast::Statement &node) override
visit node of type ast::Statement
Definition: json_visitor.cpp:27
nmodl::visitor::JSONVisitor::visit_identifier
void visit_identifier(const ast::Identifier &node) override
visit node of type ast::Identifier
Definition: json_visitor.cpp:42
nmodl::visitor::JSONVisitor::visit_after_block
void visit_after_block(const ast::AfterBlock &node) override
visit node of type ast::AfterBlock
Definition: json_visitor.cpp:429
nmodl::visitor::JSONVisitor::visit_mutex_lock
void visit_mutex_lock(const ast::MutexLock &node) override
visit node of type ast::MutexLock
Definition: json_visitor.cpp:840
nmodl::visitor::JSONVisitor::visit_longitudinal_diffusion_block
void visit_longitudinal_diffusion_block(const ast::LongitudinalDiffusionBlock &node) override
visit node of type ast::LongitudinalDiffusionBlock
Definition: json_visitor.cpp:1092
nmodl::visitor::JSONVisitor::visit_valence
void visit_valence(const ast::Valence &node) override
visit node of type ast::Valence
Definition: json_visitor.cpp:684
nmodl::visitor::JSONVisitor::visit_bbcore_pointer_var
void visit_bbcore_pointer_var(const ast::BbcorePointerVar &node) override
visit node of type ast::BbcorePointerVar
Definition: json_visitor.cpp:240
nmodl::visitor::JSONVisitor::visit_independent_block
void visit_independent_block(const ast::IndependentBlock &node) override
visit node of type ast::IndependentBlock
Definition: json_visitor.cpp:267
nmodl::visitor::JSONVisitor::visit_table_statement
void visit_table_statement(const ast::TableStatement &node) override
visit node of type ast::TableStatement
Definition: json_visitor.cpp:904
nmodl::visitor::JSONVisitor::visit_non_lin_equation
void visit_non_lin_equation(const ast::NonLinEquation &node) override
visit node of type ast::NonLinEquation
Definition: json_visitor.cpp:618
nmodl::visitor::JSONVisitor::visit_param_assign
void visit_param_assign(const ast::ParamAssign &node) override
visit node of type ast::ParamAssign
Definition: json_visitor.cpp:741
nmodl::visitor::JSONVisitor::visit_ba_block_type
void visit_ba_block_type(const ast::BABlockType &node) override
visit node of type ast::BABlockType
Definition: json_visitor.cpp:654
nmodl::visitor::JSONVisitor::visit_eigen_newton_solver_block
void visit_eigen_newton_solver_block(const ast::EigenNewtonSolverBlock &node) override
visit node of type ast::EigenNewtonSolverBlock
Definition: json_visitor.cpp:1065
nmodl::visitor::JSONVisitor::visit_lag_statement
void visit_lag_statement(const ast::LagStatement &node) override
visit node of type ast::LagStatement
Definition: json_visitor.cpp:886
nmodl::visitor::JSONVisitor::visit_local_var
void visit_local_var(const ast::LocalVar &node) override
visit node of type ast::LocalVar
Definition: json_visitor.cpp:510
nmodl::visitor::JSONVisitor::visit_number
void visit_number(const ast::Number &node) override
visit node of type ast::Number
Definition: json_visitor.cpp:47
nmodl::visitor::JSONVisitor::visit_diff_eq_expression
void visit_diff_eq_expression(const ast::DiffEqExpression &node) override
visit node of type ast::DiffEqExpression
Definition: json_visitor.cpp:600
nmodl::visitor::JSONVisitor::visit_number_range
void visit_number_range(const ast::NumberRange &node) override
visit node of type ast::NumberRange
Definition: json_visitor.cpp:528
nmodl::visitor::JSONVisitor::visit_destructor_block
void visit_destructor_block(const ast::DestructorBlock &node) override
visit node of type ast::DestructorBlock
Definition: json_visitor.cpp:312
nmodl::visitor::JSONVisitor::visit_node
void visit_node(const ast::Node &node) override
visit node of type ast::Node
Definition: json_visitor.cpp:22
nmodl::visitor::JSONVisitor::visit_constant_block
void visit_constant_block(const ast::ConstantBlock &node) override
visit node of type ast::ConstantBlock
Definition: json_visitor.cpp:474
nmodl::visitor::JSONVisitor::visit_lon_diffuse
void visit_lon_diffuse(const ast::LonDiffuse &node) override
visit node of type ast::LonDiffuse
Definition: json_visitor.cpp:868
nmodl::visitor::JSONVisitor::visit_range
void visit_range(const ast::Range &node) override
visit node of type ast::Range
Definition: json_visitor.cpp:949
nmodl::visitor::JSONVisitor::visit_statement_block
void visit_statement_block(const ast::StatementBlock &node) override
visit node of type ast::StatementBlock
Definition: json_visitor.cpp:321
nmodl::visitor::JSONVisitor::visit_from_statement
void visit_from_statement(const ast::FromStatement &node) override
visit node of type ast::FromStatement
Definition: json_visitor.cpp:786
nmodl::visitor::JSONVisitor::visit_derivative_block
void visit_derivative_block(const ast::DerivativeBlock &node) override
visit node of type ast::DerivativeBlock
Definition: json_visitor.cpp:330
nmodl::visitor::JSONVisitor::visit_block_comment
void visit_block_comment(const ast::BlockComment &node) override
visit node of type ast::BlockComment
Definition: json_visitor.cpp:1026
nmodl::visitor::JSONVisitor::visit_line_comment
void visit_line_comment(const ast::LineComment &node) override
visit node of type ast::LineComment
Definition: json_visitor.cpp:1017
nmodl::visitor::JSONVisitor::visit_conductance_hint
void visit_conductance_hint(const ast::ConductanceHint &node) override
visit node of type ast::ConductanceHint
Definition: json_visitor.cpp:759
nmodl::visitor::JSONVisitor::visit_watch_statement
void visit_watch_statement(const ast::WatchStatement &node) override
visit node of type ast::WatchStatement
Definition: json_visitor.cpp:831
nmodl::visitor::JSONVisitor::visit_unit_def
void visit_unit_def(const ast::UnitDef &node) override
visit node of type ast::UnitDef
Definition: json_visitor.cpp:666
nmodl::visitor::JSONVisitor::visit_function_table_block
void visit_function_table_block(const ast::FunctionTableBlock &node) override
visit node of type ast::FunctionTableBlock
Definition: json_visitor.cpp:366
nmodl::visitor::JSONVisitor::visit_unary_expression
void visit_unary_expression(const ast::UnaryExpression &node) override
visit node of type ast::UnaryExpression
Definition: json_visitor.cpp:609
nmodl::visitor::JSONVisitor::visit_solution_expression
void visit_solution_expression(const ast::SolutionExpression &node) override
visit node of type ast::SolutionExpression
Definition: json_visitor.cpp:1119
nmodl::visitor::JSONVisitor::visit_limits
void visit_limits(const ast::Limits &node) override
visit node of type ast::Limits
Definition: json_visitor.cpp:519
nmodl::visitor::JSONVisitor::visit_factor_def
void visit_factor_def(const ast::FactorDef &node) override
visit node of type ast::FactorDef
Definition: json_visitor.cpp:675
nmodl::visitor::JSONVisitor::visit_constant_var
void visit_constant_var(const ast::ConstantVar &node) override
visit node of type ast::ConstantVar
Definition: json_visitor.cpp:537
nmodl::visitor::JSONVisitor::visit_else_statement
void visit_else_statement(const ast::ElseStatement &node) override
visit node of type ast::ElseStatement
Definition: json_visitor.cpp:822
nmodl::visitor::JSONVisitor::visit_binary_operator
void visit_binary_operator(const ast::BinaryOperator &node) override
visit node of type ast::BinaryOperator
Definition: json_visitor.cpp:546
nmodl::visitor::JSONVisitor::visit_double_unit
void visit_double_unit(const ast::DoubleUnit &node) override
visit node of type ast::DoubleUnit
Definition: json_visitor.cpp:501
nmodl::visitor::JSONVisitor::visit_nonspecific
void visit_nonspecific(const ast::Nonspecific &node) override
visit node of type ast::Nonspecific
Definition: json_visitor.cpp:931
nmodl::visitor::JSONVisitor::visit_if_statement
void visit_if_statement(const ast::IfStatement &node) override
visit node of type ast::IfStatement
Definition: json_visitor.cpp:804
nmodl::visitor::JSONVisitor::visit_indexed_name
void visit_indexed_name(const ast::IndexedName &node) override
visit node of type ast::IndexedName
Definition: json_visitor.cpp:132
nmodl::visitor::JSONVisitor::visit_name
void visit_name(const ast::Name &node) override
visit node of type ast::Name
Definition: json_visitor.cpp:114
nmodl::visitor::JSONVisitor::visit_float
void visit_float(const ast::Float &node) override
visit node of type ast::Float
Definition: json_visitor.cpp:78
nmodl::visitor::JSONVisitor::visit_useion
void visit_useion(const ast::Useion &node) override
visit node of type ast::Useion
Definition: json_visitor.cpp:922
nmodl::visitor::JSONVisitor::visit_random_var
void visit_random_var(const ast::RandomVar &node) override
visit node of type ast::RandomVar
Definition: json_visitor.cpp:231
nmodl::visitor::JSONVisitor::visit_constructor_block
void visit_constructor_block(const ast::ConstructorBlock &node) override
visit node of type ast::ConstructorBlock
Definition: json_visitor.cpp:303
nmodl::visitor::JSONVisitor::visit_state_block
void visit_state_block(const ast::StateBlock &node) override
visit node of type ast::StateBlock
Definition: json_visitor.cpp:285
nmodl::visitor::JSONVisitor::visit_net_receive_block
void visit_net_receive_block(const ast::NetReceiveBlock &node) override
visit node of type ast::NetReceiveBlock
Definition: json_visitor.cpp:393
nmodl::visitor::JSONVisitor::visit_lin_equation
void visit_lin_equation(const ast::LinEquation &node) override
visit node of type ast::LinEquation
Definition: json_visitor.cpp:627
nmodl::visitor::JSONVisitor::visit_integer
void visit_integer(const ast::Integer &node) override
visit node of type ast::Integer
Definition: json_visitor.cpp:64
nmodl::visitor::JSONVisitor::visit_initial_block
void visit_initial_block(const ast::InitialBlock &node) override
visit node of type ast::InitialBlock
Definition: json_visitor.cpp:294
nmodl::visitor::JSONVisitor::visit_function_call
void visit_function_call(const ast::FunctionCall &node) override
visit node of type ast::FunctionCall
Definition: json_visitor.cpp:636
nmodl::visitor::JSONVisitor::visit_function_block
void visit_function_block(const ast::FunctionBlock &node) override
visit node of type ast::FunctionBlock
Definition: json_visitor.cpp:375
nmodl::visitor::JSONVisitor::visit_unit_state
void visit_unit_state(const ast::UnitState &node) override
visit node of type ast::UnitState
Definition: json_visitor.cpp:693
nmodl::visitor::JSONVisitor::visit_unit
void visit_unit(const ast::Unit &node) override
visit node of type ast::Unit
Definition: json_visitor.cpp:492
nmodl::visitor::JSONVisitor::visit_before_block
void visit_before_block(const ast::BeforeBlock &node) override
visit node of type ast::BeforeBlock
Definition: json_visitor.cpp:420
nmodl::visitor::JSONVisitor::visit_assigned_definition
void visit_assigned_definition(const ast::AssignedDefinition &node) override
visit node of type ast::AssignedDefinition
Definition: json_visitor.cpp:750
nmodl::visitor::JSONVisitor::visit_pointer_var
void visit_pointer_var(const ast::PointerVar &node) override
visit node of type ast::PointerVar
Definition: json_visitor.cpp:222
nmodl::visitor::JSONVisitor::visit_paren_expression
void visit_paren_expression(const ast::ParenExpression &node) override
visit node of type ast::ParenExpression
Definition: json_visitor.cpp:582
nmodl::visitor::JSONVisitor::visit_bbcore_pointer
void visit_bbcore_pointer(const ast::BbcorePointer &node) override
visit node of type ast::BbcorePointer
Definition: json_visitor.cpp:985
nmodl::visitor::JSONVisitor::visit_random_var_list
void visit_random_var_list(const ast::RandomVarList &node) override
visit node of type ast::RandomVarList
Definition: json_visitor.cpp:967
nmodl::visitor::JSONVisitor::visit_thread_safe
void visit_thread_safe(const ast::ThreadSafe &node) override
visit node of type ast::ThreadSafe
Definition: json_visitor.cpp:1003
nmodl::visitor::JSONVisitor::visit_argument
void visit_argument(const ast::Argument &node) override
visit node of type ast::Argument
Definition: json_visitor.cpp:150
nmodl::visitor::JSONVisitor::visit_electrode_cur_var
void visit_electrode_cur_var(const ast::ElectrodeCurVar &node) override
visit node of type ast::ElectrodeCurVar
Definition: json_visitor.cpp:195
nmodl::visitor::JSONVisitor::visit_breakpoint_block
void visit_breakpoint_block(const ast::BreakpointBlock &node) override
visit node of type ast::BreakpointBlock
Definition: json_visitor.cpp:411
nmodl::visitor::JSONVisitor::visit_double
void visit_double(const ast::Double &node) override
visit node of type ast::Double
Definition: json_visitor.cpp:90
nmodl::visitor::JSONVisitor::visit_neuron_block
void visit_neuron_block(const ast::NeuronBlock &node) override
visit node of type ast::NeuronBlock
Definition: json_visitor.cpp:483
nmodl::visitor::JSONVisitor::visit_extern_var
void visit_extern_var(const ast::ExternVar &node) override
visit node of type ast::ExternVar
Definition: json_visitor.cpp:249
nmodl::visitor::JSONVisitor::visit_binary_expression
void visit_binary_expression(const ast::BinaryExpression &node) override
visit node of type ast::BinaryExpression
Definition: json_visitor.cpp:591
nmodl::visitor::JSONVisitor::visit_update_dt
void visit_update_dt(const ast::UpdateDt &node) override
visit node of type ast::UpdateDt
Definition: json_visitor.cpp:1128
nmodl::visitor::JSONVisitor::visit_else_if_statement
void visit_else_if_statement(const ast::ElseIfStatement &node) override
visit node of type ast::ElseIfStatement
Definition: json_visitor.cpp:813
nmodl::visitor::JSONVisitor::visit_global
void visit_global(const ast::Global &node) override
visit node of type ast::Global
Definition: json_visitor.cpp:958
nmodl::visitor::JSONVisitor::visit_range_var
void visit_range_var(const ast::RangeVar &node) override
visit node of type ast::RangeVar
Definition: json_visitor.cpp:204
nmodl::visitor::JSONVisitor::visit_while_statement
void visit_while_statement(const ast::WhileStatement &node) override
visit node of type ast::WhileStatement
Definition: json_visitor.cpp:795
nmodl::visitor::JSONVisitor::visit_string
void visit_string(const ast::String &node) override
visit node of type ast::String
Definition: json_visitor.cpp:52
nmodl::visitor::JSONVisitor::visit_derivimplicit_callback
void visit_derivimplicit_callback(const ast::DerivimplicitCallback &node) override
visit node of type ast::DerivimplicitCallback
Definition: json_visitor.cpp:1110
nmodl::visitor::JSONVisitor::visit_param_block
void visit_param_block(const ast::ParamBlock &node) override
visit node of type ast::ParamBlock
Definition: json_visitor.cpp:258
nmodl::visitor::JSONVisitor::visit_constant_statement
void visit_constant_statement(const ast::ConstantStatement &node) override
visit node of type ast::ConstantStatement
Definition: json_visitor.cpp:895
nmodl::visitor::JSONVisitor::visit_pointer
void visit_pointer(const ast::Pointer &node) override
visit node of type ast::Pointer
Definition: json_visitor.cpp:976
nmodl::visitor::JSONVisitor::visit_discrete_block
void visit_discrete_block(const ast::DiscreteBlock &node) override
visit node of type ast::DiscreteBlock
Definition: json_visitor.cpp:357
json_visitor.hpp
THIS FILE IS GENERATED AT BUILD TIME AND SHALL NOT BE EDITED.
nmodl
encapsulates code generation backend implementations
Definition: ast_common.hpp:26
nmodl::to_nmodl
std::string to_nmodl(const ast::Ast &node, const std::set< ast::AstNodeType > &exclude_types)
Given AST node, return the NMODL string representation.
Definition: visitor_utils.cpp:234
node
static Node * node(Object *)
Definition: netcvode.cpp:291
visitor_utils.hpp
Utility functions for visitors implementation.