json_visitor.cpp

Go to the documentation of this file.

/*
 * Copyright 2023 Blue Brain Project, EPFL.
 * See the top-level LICENSE file for details.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
///
/// THIS FILE IS GENERATED AT BUILD TIME AND SHALL NOT BE EDITED.
///
 
#include "visitors/json_visitor.hpp"
 
#include "ast/all.hpp"
#include "visitors/visitor_utils.hpp"
 
namespace nmodl {
namespace visitor {
 
using namespace ast;
 
void JSONVisitor::visit_node(const Node& node) {
    (void)node;
    printer->add_node("Node");
}
 
void JSONVisitor::visit_statement(const Statement& node) {
    (void)node;
    printer->add_node("Statement");
}
 
void JSONVisitor::visit_expression(const Expression& node) {
    (void)node;
    printer->add_node("Expression");
}
 
void JSONVisitor::visit_block(const Block& node) {
    (void)node;
    printer->add_node("Block");
}
 
void JSONVisitor::visit_identifier(const Identifier& node) {
    (void)node;
    printer->add_node("Identifier");
}
 
void JSONVisitor::visit_number(const Number& node) {
    (void)node;
    printer->add_node("Number");
}
 
void JSONVisitor::visit_string(const String& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    std::stringstream ss;
    ss << node.eval();
    printer->add_node(ss.str());
    printer->pop_block();
}
 
void JSONVisitor::visit_integer(const Integer& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    if(!node.get_macro()) {
        std::stringstream ss;
        ss << node.eval();
        printer->add_node(ss.str());
    }
    printer->pop_block();
}
 
void JSONVisitor::visit_float(const Float& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    std::stringstream ss;
    ss << node.eval();
    printer->add_node(ss.str());
    printer->pop_block();
}
 
void JSONVisitor::visit_double(const Double& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    std::stringstream ss;
    ss << node.eval();
    printer->add_node(ss.str());
    printer->pop_block();
}
 
void JSONVisitor::visit_boolean(const Boolean& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    std::stringstream ss;
    ss << node.eval();
    printer->add_node(ss.str());
    printer->pop_block();
}
 
void JSONVisitor::visit_name(const Name& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_prime_name(const PrimeName& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_indexed_name(const IndexedName& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_var_name(const VarName& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_argument(const Argument& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_react_var_name(const ReactVarName& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_read_ion_var(const ReadIonVar& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_write_ion_var(const WriteIonVar& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_nonspecific_cur_var(const NonspecificCurVar& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_electrode_cur_var(const ElectrodeCurVar& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_range_var(const RangeVar& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_global_var(const GlobalVar& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_pointer_var(const PointerVar& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_random_var(const RandomVar& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_bbcore_pointer_var(const BbcorePointerVar& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_extern_var(const ExternVar& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_param_block(const ParamBlock& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_independent_block(const IndependentBlock& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_assigned_block(const AssignedBlock& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_state_block(const StateBlock& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_initial_block(const InitialBlock& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_constructor_block(const ConstructorBlock& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_destructor_block(const DestructorBlock& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_statement_block(const StatementBlock& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_derivative_block(const DerivativeBlock& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_linear_block(const LinearBlock& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_non_linear_block(const NonLinearBlock& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_discrete_block(const DiscreteBlock& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_function_table_block(const FunctionTableBlock& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_function_block(const FunctionBlock& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_procedure_block(const ProcedureBlock& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_net_receive_block(const NetReceiveBlock& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_solve_block(const SolveBlock& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_breakpoint_block(const BreakpointBlock& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_before_block(const BeforeBlock& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_after_block(const AfterBlock& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_ba_block(const BABlock& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_for_netcon(const ForNetcon& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_kinetic_block(const KineticBlock& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_unit_block(const UnitBlock& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_constant_block(const ConstantBlock& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_neuron_block(const NeuronBlock& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_unit(const Unit& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_double_unit(const DoubleUnit& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_local_var(const LocalVar& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_limits(const Limits& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_number_range(const NumberRange& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_constant_var(const ConstantVar& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_binary_operator(const BinaryOperator& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    std::stringstream ss;
    ss << node.eval();
    printer->add_node(ss.str());
    printer->pop_block();
}
 
void JSONVisitor::visit_unary_operator(const UnaryOperator& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    std::stringstream ss;
    ss << node.eval();
    printer->add_node(ss.str());
    printer->pop_block();
}
 
void JSONVisitor::visit_reaction_operator(const ReactionOperator& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    std::stringstream ss;
    ss << node.eval();
    printer->add_node(ss.str());
    printer->pop_block();
}
 
void JSONVisitor::visit_paren_expression(const ParenExpression& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_binary_expression(const BinaryExpression& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_diff_eq_expression(const DiffEqExpression& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_unary_expression(const UnaryExpression& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_non_lin_equation(const NonLinEquation& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_lin_equation(const LinEquation& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_function_call(const FunctionCall& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_watch(const Watch& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_ba_block_type(const BABlockType& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    std::stringstream ss;
    ss << node.eval();
    printer->add_node(ss.str());
    printer->pop_block();
}
 
void JSONVisitor::visit_unit_def(const UnitDef& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_factor_def(const FactorDef& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_valence(const Valence& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_unit_state(const UnitState& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    std::stringstream ss;
    ss << node.eval();
    printer->add_node(ss.str());
    printer->pop_block();
}
 
void JSONVisitor::visit_local_list_statement(const LocalListStatement& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_model(const Model& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_define(const Define& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_include(const Include& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_param_assign(const ParamAssign& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_assigned_definition(const AssignedDefinition& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_conductance_hint(const ConductanceHint& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_expression_statement(const ExpressionStatement& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_protect_statement(const ProtectStatement& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_from_statement(const FromStatement& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_while_statement(const WhileStatement& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_if_statement(const IfStatement& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_else_if_statement(const ElseIfStatement& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_else_statement(const ElseStatement& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_watch_statement(const WatchStatement& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_mutex_lock(const MutexLock& node) {
    (void)node;
    printer->add_node("MutexLock");
}
 
void JSONVisitor::visit_mutex_unlock(const MutexUnlock& node) {
    (void)node;
    printer->add_node("MutexUnlock");
}
 
void JSONVisitor::visit_conserve(const Conserve& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_compartment(const Compartment& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_lon_difuse(const LonDifuse& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_reaction_statement(const ReactionStatement& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_lag_statement(const LagStatement& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_constant_statement(const ConstantStatement& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_table_statement(const TableStatement& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_suffix(const Suffix& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_useion(const Useion& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_nonspecific(const Nonspecific& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_electrode_current(const ElectrodeCurrent& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_range(const Range& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_global(const Global& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_random_var_list(const RandomVarList& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_pointer(const Pointer& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_bbcore_pointer(const BbcorePointer& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_external(const External& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_thread_safe(const ThreadSafe& node) {
    (void)node;
    printer->add_node("ThreadSafe");
}
 
void JSONVisitor::visit_verbatim(const Verbatim& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_line_comment(const LineComment& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_block_comment(const BlockComment& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_ontology_statement(const OntologyStatement& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_program(const Program& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
    if (node.get_parent() == nullptr) {
        flush();
    }
}
 
void JSONVisitor::visit_nrn_state_block(const NrnStateBlock& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_eigen_newton_solver_block(const EigenNewtonSolverBlock& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_eigen_linear_solver_block(const EigenLinearSolverBlock& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_wrapped_expression(const WrappedExpression& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_derivimplicit_callback(const DerivimplicitCallback& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_solution_expression(const SolutionExpression& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
void JSONVisitor::visit_update_dt(const UpdateDt& node) {
    printer->push_block(node.get_node_type_name());
    if (embed_nmodl) {
        printer->add_block_property("nmodl", to_nmodl(node));
    }
    node.visit_children(*this);
    printer->pop_block();
}
 
 
}  // namespace visitor
}  // namespace nmodl