nmodl_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/nmodl_visitor.hpp"
 
#include "ast/all.hpp"
#include "visitors/nmodl_visitor_helper.ipp"
 
 
namespace nmodl {
namespace visitor {
 
using namespace ast;
 
void NmodlPrintVisitor::visit_node(const Node& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
}
 
void NmodlPrintVisitor::visit_statement(const Statement& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
}
 
void NmodlPrintVisitor::visit_expression(const Expression& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
}
 
void NmodlPrintVisitor::visit_block(const Block& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
}
 
void NmodlPrintVisitor::visit_identifier(const Identifier& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
}
 
void NmodlPrintVisitor::visit_number(const Number& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
}
 
void NmodlPrintVisitor::visit_string(const String& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
            std::stringstream ss;
            ss << node.eval();
            printer->add_element(ss.str());
 
 
 
}
 
void NmodlPrintVisitor::visit_integer(const Integer& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
            if(node.get_macro() == nullptr) {
                printer->add_element(std::to_string(node.eval()));
            }
 
 
 
                if(node.get_macro()) {
                    node.get_macro()->accept(*this);
                }
 
 
}
 
void NmodlPrintVisitor::visit_float(const Float& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
            std::stringstream ss;
            ss << std::setprecision(16);
            ss << node.eval();
            printer->add_element(ss.str());
 
 
 
}
 
void NmodlPrintVisitor::visit_double(const Double& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
            std::stringstream ss;
            ss << std::setprecision(16);
            ss << node.eval();
            printer->add_element(ss.str());
 
 
 
}
 
void NmodlPrintVisitor::visit_boolean(const Boolean& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
            std::stringstream ss;
            ss << node.eval();
            printer->add_element(ss.str());
 
 
 
}
 
void NmodlPrintVisitor::visit_name(const Name& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                node.get_value()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_prime_name(const PrimeName& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                node.get_value()->accept(*this);
 
 
                auto order = node.get_order()->eval();
        const std::string symbol(order, '\'');
        printer->add_element(symbol);
 
 
}
 
void NmodlPrintVisitor::visit_indexed_name(const IndexedName& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                node.get_name()->accept(*this);
 
 
                printer->add_element("[");
        node.get_length()->accept(*this);
printer->add_element("]");
 
 
}
 
void NmodlPrintVisitor::visit_var_name(const VarName& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                node.get_name()->accept(*this);
 
 
                if(node.get_at()) {
                    printer->add_element("@");
        node.get_at()->accept(*this);
                }
 
 
                if(node.get_index()) {
                    printer->add_element("[");
        node.get_index()->accept(*this);
printer->add_element("]");
                }
 
 
}
 
void NmodlPrintVisitor::visit_argument(const Argument& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                node.get_name()->accept(*this);
 
 
                if(node.get_unit()) {
                    node.get_unit()->accept(*this);
                }
 
 
}
 
void NmodlPrintVisitor::visit_react_var_name(const ReactVarName& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                if(node.get_value()) {
                    printer->add_element(" ");
        node.get_value()->accept(*this);
                }
 
 
                node.get_name()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_read_ion_var(const ReadIonVar& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                node.get_name()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_write_ion_var(const WriteIonVar& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                node.get_name()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_nonspecific_cur_var(const NonspecificCurVar& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                node.get_name()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_electrode_cur_var(const ElectrodeCurVar& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                node.get_name()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_range_var(const RangeVar& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                node.get_name()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_global_var(const GlobalVar& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                node.get_name()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_pointer_var(const PointerVar& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                node.get_name()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_random_var(const RandomVar& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                node.get_name()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_bbcore_pointer_var(const BbcorePointerVar& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                node.get_name()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_extern_var(const ExternVar& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                node.get_name()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_param_block(const ParamBlock& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("PARAMETER ");
 
        printer->push_level();
 
                visit_element(node.get_statements(),"",false,true);
 
 
printer->pop_level();
}
 
void NmodlPrintVisitor::visit_independent_block(const IndependentBlock& node) {
        printer->add_element(": INDEPENDENT block is deprecated and has no effect in the NEURON model. Skipped!");
        return;    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("INDEPENDENT ");
 
        printer->push_level();
 
                visit_element(node.get_variables()," ",false,false);
 
 
printer->pop_level();
}
 
void NmodlPrintVisitor::visit_assigned_block(const AssignedBlock& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("ASSIGNED ");
 
        printer->push_level();
 
                visit_element(node.get_definitions(),"",false,true);
 
 
printer->pop_level();
}
 
void NmodlPrintVisitor::visit_state_block(const StateBlock& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("STATE ");
 
        printer->push_level();
 
                visit_element(node.get_definitions(),"",false,true);
 
 
printer->pop_level();
}
 
void NmodlPrintVisitor::visit_initial_block(const InitialBlock& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("INITIAL ");
 
 
                if(node.get_statement_block()) {
                    node.get_statement_block()->accept(*this);
                }
 
 
}
 
void NmodlPrintVisitor::visit_constructor_block(const ConstructorBlock& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("CONSTRUCTOR ");
 
 
                if(node.get_statement_block()) {
                    node.get_statement_block()->accept(*this);
                }
 
 
}
 
void NmodlPrintVisitor::visit_destructor_block(const DestructorBlock& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("DESTRUCTOR ");
 
 
                if(node.get_statement_block()) {
                    node.get_statement_block()->accept(*this);
                }
 
 
}
 
void NmodlPrintVisitor::visit_statement_block(const StatementBlock& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
        printer->push_level();
 
                visit_element(node.get_statements(),"",false,true);
 
 
printer->pop_level();
}
 
void NmodlPrintVisitor::visit_derivative_block(const DerivativeBlock& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("DERIVATIVE ");
 
 
                node.get_name()->accept(*this);
printer->add_element(" ");
 
 
                if(node.get_statement_block()) {
                    node.get_statement_block()->accept(*this);
                }
 
 
}
 
void NmodlPrintVisitor::visit_linear_block(const LinearBlock& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("LINEAR ");
 
 
                node.get_name()->accept(*this);
printer->add_element(" ");
 
 
                if (!node.get_solvefor().empty()) {
                printer->add_element(" SOLVEFOR ");
    visit_element(node.get_solvefor(),",",false,false);
            }
 
 
                if(node.get_statement_block()) {
                    node.get_statement_block()->accept(*this);
                }
 
 
}
 
void NmodlPrintVisitor::visit_non_linear_block(const NonLinearBlock& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("NONLINEAR ");
 
 
                node.get_name()->accept(*this);
 
 
                if (!node.get_solvefor().empty()) {
                printer->add_element(" SOLVEFOR ");
    visit_element(node.get_solvefor(),",",false,false);
            }
printer->add_element(" ");
 
                if(node.get_statement_block()) {
                    node.get_statement_block()->accept(*this);
                }
 
 
}
 
void NmodlPrintVisitor::visit_discrete_block(const DiscreteBlock& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("DISCRETE ");
 
 
                node.get_name()->accept(*this);
printer->add_element(" ");
 
 
                if(node.get_statement_block()) {
                    node.get_statement_block()->accept(*this);
                }
 
 
}
 
void NmodlPrintVisitor::visit_function_table_block(const FunctionTableBlock& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("FUNCTION_TABLE ");
 
 
                node.get_name()->accept(*this);
 
printer->add_element("(");
                visit_element(node.get_parameters(),", ",false,false);
printer->add_element(")");
 
                if(node.get_unit()) {
                    printer->add_element(" ");
        node.get_unit()->accept(*this);
                }
 
 
}
 
void NmodlPrintVisitor::visit_function_block(const FunctionBlock& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("FUNCTION ");
 
 
                node.get_name()->accept(*this);
 
printer->add_element("(");
                visit_element(node.get_parameters(),", ",false,false);
printer->add_element(")");
 
                if(node.get_unit()) {
                    printer->add_element(" ");
        node.get_unit()->accept(*this);
                }
printer->add_element(" ");
 
                if(node.get_statement_block()) {
                    node.get_statement_block()->accept(*this);
                }
 
 
}
 
void NmodlPrintVisitor::visit_procedure_block(const ProcedureBlock& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("PROCEDURE ");
 
 
                node.get_name()->accept(*this);
 
printer->add_element("(");
                visit_element(node.get_parameters(),", ",false,false);
printer->add_element(") ");
 
                if(node.get_unit()) {
                    node.get_unit()->accept(*this);
                }
 
 
                if(node.get_statement_block()) {
                    node.get_statement_block()->accept(*this);
                }
 
 
}
 
void NmodlPrintVisitor::visit_net_receive_block(const NetReceiveBlock& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("NET_RECEIVE ");
 
printer->add_element("(");
                visit_element(node.get_parameters(),", ",false,false);
printer->add_element(") ");
 
                if(node.get_statement_block()) {
                    node.get_statement_block()->accept(*this);
                }
 
 
}
 
void NmodlPrintVisitor::visit_solve_block(const SolveBlock& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("SOLVE");
 
 
                printer->add_element(" ");
        node.get_block_name()->accept(*this);
 
 
                if(node.get_method()) {
                    printer->add_element(" METHOD ");
        node.get_method()->accept(*this);
                }
 
 
                if(node.get_steadystate()) {
                    printer->add_element(" STEADYSTATE ");
        node.get_steadystate()->accept(*this);
                }
 
 
}
 
void NmodlPrintVisitor::visit_breakpoint_block(const BreakpointBlock& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("BREAKPOINT ");
 
 
                if(node.get_statement_block()) {
                    node.get_statement_block()->accept(*this);
                }
 
 
}
 
void NmodlPrintVisitor::visit_before_block(const BeforeBlock& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("BEFORE ");
 
 
                node.get_bablock()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_after_block(const AfterBlock& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("AFTER ");
 
 
                node.get_bablock()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_ba_block(const BABlock& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                node.get_type()->accept(*this);
printer->add_element(" ");
 
 
                if(node.get_statement_block()) {
                    node.get_statement_block()->accept(*this);
                }
 
 
}
 
void NmodlPrintVisitor::visit_for_netcon(const ForNetcon& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("FOR_NETCONS ");
 
printer->add_element("(");
                visit_element(node.get_parameters(),", ",false,false);
printer->add_element(") ");
 
                if(node.get_statement_block()) {
                    node.get_statement_block()->accept(*this);
                }
 
 
}
 
void NmodlPrintVisitor::visit_kinetic_block(const KineticBlock& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("KINETIC ");
 
 
                node.get_name()->accept(*this);
printer->add_element(" ");
 
 
                visit_element(node.get_solvefor(),",",false,false);
 
 
                if(node.get_statement_block()) {
                    node.get_statement_block()->accept(*this);
                }
 
 
}
 
void NmodlPrintVisitor::visit_unit_block(const UnitBlock& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("UNITS ");
 
        printer->push_level();
 
                visit_element(node.get_definitions(),"",false,true);
 
 
printer->pop_level();
}
 
void NmodlPrintVisitor::visit_constant_block(const ConstantBlock& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("CONSTANT ");
 
        printer->push_level();
 
                visit_element(node.get_statements(),"",false,true);
 
 
printer->pop_level();
}
 
void NmodlPrintVisitor::visit_neuron_block(const NeuronBlock& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("NEURON ");
 
 
                if(node.get_statement_block()) {
                    node.get_statement_block()->accept(*this);
                }
 
 
}
 
void NmodlPrintVisitor::visit_unit(const Unit& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                printer->add_element("(");
        node.get_name()->accept(*this);
printer->add_element(")");
 
 
}
 
void NmodlPrintVisitor::visit_double_unit(const DoubleUnit& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                node.get_value()->accept(*this);
 
 
                if(node.get_unit()) {
                    node.get_unit()->accept(*this);
                }
 
 
}
 
void NmodlPrintVisitor::visit_local_var(const LocalVar& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                node.get_name()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_limits(const Limits& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                printer->add_element("<");
        node.get_min()->accept(*this);
printer->add_element(",");
 
 
                node.get_max()->accept(*this);
printer->add_element(">");
 
 
}
 
void NmodlPrintVisitor::visit_number_range(const NumberRange& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                printer->add_element("<");
        node.get_min()->accept(*this);
printer->add_element(",");
 
 
                node.get_max()->accept(*this);
printer->add_element(">");
 
 
}
 
void NmodlPrintVisitor::visit_constant_var(const ConstantVar& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                node.get_name()->accept(*this);
 
 
                printer->add_element(" = ");
        node.get_value()->accept(*this);
 
 
                if(node.get_unit()) {
                    printer->add_element(" ");
        node.get_unit()->accept(*this);
                }
 
 
}
 
void NmodlPrintVisitor::visit_binary_operator(const BinaryOperator& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
            std::stringstream ss;
            ss << node.eval();
            printer->add_element(ss.str());
 
 
 
}
 
void NmodlPrintVisitor::visit_unary_operator(const UnaryOperator& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
            std::stringstream ss;
            ss << node.eval();
            printer->add_element(ss.str());
 
 
 
}
 
void NmodlPrintVisitor::visit_reaction_operator(const ReactionOperator& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
            std::stringstream ss;
            ss << node.eval();
            printer->add_element(ss.str());
 
 
 
}
 
void NmodlPrintVisitor::visit_paren_expression(const ParenExpression& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                printer->add_element("(");
        node.get_expression()->accept(*this);
printer->add_element(")");
 
 
}
 
void NmodlPrintVisitor::visit_binary_expression(const BinaryExpression& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                node.get_lhs()->accept(*this);
 
 
                std::string op = node.get_op().eval();
        if(op == "=" || op == "&&" || op == "||" || op == "==")
            op = " " + op + " ";
        printer->add_element(op);
 
 
                node.get_rhs()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_diff_eq_expression(const DiffEqExpression& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                node.get_expression()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_unary_expression(const UnaryExpression& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                UnaryOperator(node.get_op()).accept(*this);
 
 
                node.get_expression()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_non_lin_equation(const NonLinEquation& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("~ ");
 
 
                node.get_lhs()->accept(*this);
printer->add_element(" = ");
 
 
                node.get_rhs()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_lin_equation(const LinEquation& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("~ ");
 
 
                node.get_left_linxpression()->accept(*this);
printer->add_element(" = ");
 
 
                node.get_linxpression()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_function_call(const FunctionCall& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                node.get_name()->accept(*this);
 
printer->add_element("(");
                visit_element(node.get_arguments(),", ",false,false);
printer->add_element(")");
 
}
 
void NmodlPrintVisitor::visit_watch(const Watch& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                printer->add_element("(");
        node.get_expression()->accept(*this);
printer->add_element(")");
 
 
                printer->add_element(" ");
        node.get_value()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_ba_block_type(const BABlockType& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
            std::stringstream ss;
            ss << node.eval();
            printer->add_element(ss.str());
 
 
 
}
 
void NmodlPrintVisitor::visit_unit_def(const UnitDef& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                node.get_unit1()->accept(*this);
 
 
                printer->add_element(" = ");
        node.get_unit2()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_factor_def(const FactorDef& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                node.get_name()->accept(*this);
printer->add_element(" =");
 
 
                if(node.get_value()) {
                    printer->add_element(" ");
        node.get_value()->accept(*this);
                }
 
 
                printer->add_element(" ");
        node.get_unit1()->accept(*this);
 
 
                if(node.get_gt()) {
                    if(node.get_gt()->eval()) {
            printer->add_element(" ->");
        }
                }
 
 
                if(node.get_unit2()) {
                    printer->add_element(" ");
        node.get_unit2()->accept(*this);
                }
 
 
}
 
void NmodlPrintVisitor::visit_valence(const Valence& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                printer->add_element(" ");
        node.get_type()->accept(*this);
printer->add_element(" ");
 
 
                node.get_value()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_unit_state(const UnitState& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
            std::stringstream ss;
            ss << node.eval();
            printer->add_element(ss.str());
 
 
 
}
 
void NmodlPrintVisitor::visit_local_list_statement(const LocalListStatement& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("LOCAL ");
 
 
                visit_element(node.get_variables(),", ",false,false);
 
 
}
 
void NmodlPrintVisitor::visit_model(const Model& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("TITLE");
 
 
                node.get_title()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_define(const Define& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("DEFINE ");
 
 
                node.get_name()->accept(*this);
 
 
                printer->add_element(" ");
        node.get_value()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_include(const Include& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("INCLUDE ");
 
 
                node.get_filename()->accept(*this);
 
 
                
 
 
}
 
void NmodlPrintVisitor::visit_param_assign(const ParamAssign& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                node.get_name()->accept(*this);
 
 
                if(node.get_value()) {
                    printer->add_element(" = ");
        node.get_value()->accept(*this);
                }
 
 
                if(node.get_unit()) {
                    printer->add_element(" ");
        node.get_unit()->accept(*this);
                }
 
 
                if(node.get_limit()) {
                    printer->add_element(" ");
        node.get_limit()->accept(*this);
                }
 
 
}
 
void NmodlPrintVisitor::visit_assigned_definition(const AssignedDefinition& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                node.get_name()->accept(*this);
 
 
                if(node.get_length()) {
                    printer->add_element("[");
        node.get_length()->accept(*this);
printer->add_element("]");
                }
 
 
                if(node.get_from()) {
                    printer->add_element(" FROM ");
        node.get_from()->accept(*this);
                }
 
 
                if(node.get_to()) {
                    printer->add_element(" TO ");
        node.get_to()->accept(*this);
                }
 
 
                if(node.get_start()) {
                    printer->add_element(" START ");
        node.get_start()->accept(*this);
                }
 
 
                if(node.get_unit()) {
                    printer->add_element(" ");
        node.get_unit()->accept(*this);
                }
 
 
                if(node.get_abstol()) {
                    printer->add_element(" <");
        node.get_abstol()->accept(*this);
printer->add_element(">");
                }
 
 
}
 
void NmodlPrintVisitor::visit_conductance_hint(const ConductanceHint& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("CONDUCTANCE ");
 
 
                node.get_conductance()->accept(*this);
 
 
                if(node.get_ion()) {
                    printer->add_element(" USEION ");
        node.get_ion()->accept(*this);
                }
 
 
}
 
void NmodlPrintVisitor::visit_expression_statement(const ExpressionStatement& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                node.get_expression()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_protect_statement(const ProtectStatement& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("PROTECT ");
 
 
                node.get_expression()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_from_statement(const FromStatement& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("FROM ");
 
 
                node.get_name()->accept(*this);
 
 
                printer->add_element(" = ");
        node.get_from()->accept(*this);
 
 
                printer->add_element(" TO ");
        node.get_to()->accept(*this);
 
 
                if(node.get_increment()) {
                    printer->add_element(" BY ");
        node.get_increment()->accept(*this);
                }
printer->add_element(" ");
 
                if(node.get_statement_block()) {
                    node.get_statement_block()->accept(*this);
                }
 
 
}
 
void NmodlPrintVisitor::visit_while_statement(const WhileStatement& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("WHILE ");
 
 
                printer->add_element("(");
        node.get_condition()->accept(*this);
printer->add_element(") ");
 
 
                if(node.get_statement_block()) {
                    node.get_statement_block()->accept(*this);
                }
 
 
}
 
void NmodlPrintVisitor::visit_if_statement(const IfStatement& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("IF ");
 
 
                printer->add_element("(");
        node.get_condition()->accept(*this);
printer->add_element(") ");
 
 
                if(node.get_statement_block()) {
                    node.get_statement_block()->accept(*this);
                }
 
 
                visit_element(node.get_elseifs(),"",false,false);
 
 
                if(node.get_elses()) {
                    node.get_elses()->accept(*this);
                }
 
 
}
 
void NmodlPrintVisitor::visit_else_if_statement(const ElseIfStatement& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element(" ELSE IF ");
 
 
                printer->add_element("(");
        node.get_condition()->accept(*this);
printer->add_element(") ");
 
 
                if(node.get_statement_block()) {
                    node.get_statement_block()->accept(*this);
                }
 
 
}
 
void NmodlPrintVisitor::visit_else_statement(const ElseStatement& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element(" ELSE ");
 
 
                if(node.get_statement_block()) {
                    node.get_statement_block()->accept(*this);
                }
 
 
}
 
void NmodlPrintVisitor::visit_watch_statement(const WatchStatement& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("WATCH ");
 
 
                visit_element(node.get_statements(),",",false,false);
 
 
}
 
void NmodlPrintVisitor::visit_mutex_lock(const MutexLock& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("MUTEXLOCK");
 
 
}
 
void NmodlPrintVisitor::visit_mutex_unlock(const MutexUnlock& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("MUTEXUNLOCK");
 
 
}
 
void NmodlPrintVisitor::visit_conserve(const Conserve& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("CONSERVE");
 
 
                printer->add_element(" ");
        node.get_react()->accept(*this);
 
 
                printer->add_element(" = ");
        node.get_expr()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_compartment(const Compartment& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("COMPARTMENT");
 
 
                if(node.get_name()) {
                    printer->add_element(" ");
        node.get_name()->accept(*this);
printer->add_element(",");
                }
 
 
                printer->add_element(" ");
        node.get_expression()->accept(*this);
 
 
                if (!node.get_names().empty()) {
                printer->add_element(" {");
    visit_element(node.get_names()," ",false,false);
printer->add_element("}");
            }
 
 
}
 
void NmodlPrintVisitor::visit_lon_difuse(const LonDifuse& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("LONGITUDINAL_DIFFUSION");
 
 
                if(node.get_name()) {
                    printer->add_element(" ");
        node.get_name()->accept(*this);
printer->add_element(",");
                }
 
 
                printer->add_element(" ");
        node.get_expression()->accept(*this);
 
 
                if (!node.get_names().empty()) {
                printer->add_element(" {");
    visit_element(node.get_names()," ",false,false);
printer->add_element("}");
            }
 
 
}
 
void NmodlPrintVisitor::visit_reaction_statement(const ReactionStatement& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("~ ");
 
 
                node.get_reaction1()->accept(*this);
 
 
                printer->add_element(" ");
        ReactionOperator(node.get_op()).accept(*this);
 
 
                if(node.get_reaction2()) {
                    printer->add_element(" ");
        node.get_reaction2()->accept(*this);
                }
 
 
                printer->add_element(" (");
        node.get_expression1()->accept(*this);
 
 
                if(node.get_expression2()) {
                    printer->add_element(", ");
        node.get_expression2()->accept(*this);
                }
printer->add_element(")");
 
}
 
void NmodlPrintVisitor::visit_lag_statement(const LagStatement& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("LAG ");
 
 
                node.get_name()->accept(*this);
 
 
                printer->add_element(" BY ");
        node.get_byname()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_constant_statement(const ConstantStatement& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                node.get_constant()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_table_statement(const TableStatement& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("TABLE ");
 
 
                visit_element(node.get_table_vars(),",",false,false);
 
 
                if (!node.get_depend_vars().empty()) {
                printer->add_element(" DEPEND ");
    visit_element(node.get_depend_vars(),",",false,false);
            }
 
 
                printer->add_element(" FROM ");
        node.get_from()->accept(*this);
 
 
                printer->add_element(" TO ");
        node.get_to()->accept(*this);
 
 
                printer->add_element(" WITH ");
        node.get_with()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_suffix(const Suffix& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                node.get_type()->accept(*this);
printer->add_element(" ");
 
 
                node.get_name()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_useion(const Useion& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("USEION ");
 
 
                node.get_name()->accept(*this);
 
 
                if (!node.get_readlist().empty()) {
                printer->add_element(" READ ");
    visit_element(node.get_readlist(),", ",false,false);
            }
 
 
                if (!node.get_writelist().empty()) {
                printer->add_element(" WRITE ");
    visit_element(node.get_writelist(),", ",false,false);
            }
 
 
                if(node.get_valence()) {
                    node.get_valence()->accept(*this);
                }
 
 
                if(node.get_ontology_id()) {
                    printer->add_element(" REPRESENTS ");
        node.get_ontology_id()->accept(*this);
                }
 
 
}
 
void NmodlPrintVisitor::visit_nonspecific(const Nonspecific& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("NONSPECIFIC_CURRENT ");
 
 
                visit_element(node.get_currents(),", ",false,false);
 
 
}
 
void NmodlPrintVisitor::visit_electrode_current(const ElectrodeCurrent& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("ELECTRODE_CURRENT ");
 
 
                visit_element(node.get_currents(),", ",false,false);
 
 
}
 
void NmodlPrintVisitor::visit_range(const Range& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("RANGE ");
 
 
                visit_element(node.get_variables(),", ",false,false);
 
 
}
 
void NmodlPrintVisitor::visit_global(const Global& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("GLOBAL ");
 
 
                visit_element(node.get_variables(),", ",false,false);
 
 
}
 
void NmodlPrintVisitor::visit_random_var_list(const RandomVarList& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("RANDOM ");
 
 
                visit_element(node.get_variables(),", ",false,false);
 
 
}
 
void NmodlPrintVisitor::visit_pointer(const Pointer& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("POINTER ");
 
 
                visit_element(node.get_variables(),", ",false,false);
 
 
}
 
void NmodlPrintVisitor::visit_bbcore_pointer(const BbcorePointer& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("BBCOREPOINTER ");
 
 
                visit_element(node.get_variables(),", ",false,false);
 
 
}
 
void NmodlPrintVisitor::visit_external(const External& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("EXTERNAL ");
 
 
                visit_element(node.get_variables(),", ",false,false);
 
 
}
 
void NmodlPrintVisitor::visit_thread_safe(const ThreadSafe& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("THREADSAFE");
 
 
}
 
void NmodlPrintVisitor::visit_verbatim(const Verbatim& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("VERBATIM");
 
 
                node.get_statement()->accept(*this);
printer->add_element("ENDVERBATIM");
 
 
}
 
void NmodlPrintVisitor::visit_line_comment(const LineComment& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                node.get_statement()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_block_comment(const BlockComment& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("COMMENT");
 
 
                node.get_statement()->accept(*this);
printer->add_element("ENDCOMMENT");
 
 
}
 
void NmodlPrintVisitor::visit_ontology_statement(const OntologyStatement& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("REPRESENTS ");
 
 
                node.get_ontology_id()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_program(const Program& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                visit_element(node.get_blocks(),"",true,false);
 
 
}
 
void NmodlPrintVisitor::visit_nrn_state_block(const NrnStateBlock& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("NRN_STATE ");
 
 
                visit_element(node.get_solve_statements(),"",false,true);
 
 
}
 
void NmodlPrintVisitor::visit_eigen_newton_solver_block(const EigenNewtonSolverBlock& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("EIGEN_NEWTON_SOLVE");
 
 
                printer->add_element("[");
        node.get_n_state_vars()->accept(*this);
printer->add_element("]");
 
 
                if(node.get_variable_block()) {
                    node.get_variable_block()->accept(*this);
                }
 
 
                if(node.get_initialize_block()) {
                    node.get_initialize_block()->accept(*this);
                }
 
 
                if(node.get_setup_x_block()) {
                    node.get_setup_x_block()->accept(*this);
                }
 
 
                if(node.get_functor_block()) {
                    node.get_functor_block()->accept(*this);
                }
 
 
                if(node.get_update_states_block()) {
                    node.get_update_states_block()->accept(*this);
                }
 
 
                if(node.get_finalize_block()) {
                    node.get_finalize_block()->accept(*this);
                }
 
 
}
 
void NmodlPrintVisitor::visit_eigen_linear_solver_block(const EigenLinearSolverBlock& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("EIGEN_LINEAR_SOLVE");
 
 
                printer->add_element("[");
        node.get_n_state_vars()->accept(*this);
printer->add_element("]");
 
 
                if(node.get_variable_block()) {
                    node.get_variable_block()->accept(*this);
                }
 
 
                if(node.get_initialize_block()) {
                    node.get_initialize_block()->accept(*this);
                }
 
 
                if(node.get_setup_x_block()) {
                    node.get_setup_x_block()->accept(*this);
                }
 
 
                if(node.get_update_states_block()) {
                    node.get_update_states_block()->accept(*this);
                }
 
 
                if(node.get_finalize_block()) {
                    node.get_finalize_block()->accept(*this);
                }
 
 
}
 
void NmodlPrintVisitor::visit_wrapped_expression(const WrappedExpression& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                node.get_expression()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_derivimplicit_callback(const DerivimplicitCallback& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                node.get_node_to_solve()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_solution_expression(const SolutionExpression& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
    
 
                node.get_solve_block()->accept(*this);
 
 
                node.get_node_to_solve()->accept(*this);
 
 
}
 
void NmodlPrintVisitor::visit_update_dt(const UpdateDt& node) {
    if (is_exclude_type(node.get_node_type())) {
        return;
    }
        printer->add_element("dt");
 
 
                printer->add_element(" = ");
        node.get_value()->accept(*this);
 
 
}
 
 
}  // namespace visitor
}  // namespace nmodl