html/doxygen/ast__decl_8hpp_source.html

/*

 * 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.

///


#pragma once


#include <memory>

#include <vector>


/// \file

/// \brief Auto generated  AST node types and aliases declaration


namespace nmodl {

namespace ast {


/// forward declaration of ast nodes


struct Ast;

class Node;

class Statement;

class Expression;

class Block;

class Identifier;

class Number;

class String;

class Integer;

class Float;

class Double;

class Boolean;

class Name;

class PrimeName;

class IndexedName;

class VarName;

class Argument;

class ReactVarName;

class ReadIonVar;

class WriteIonVar;

class NonspecificCurVar;

class ElectrodeCurVar;

class RangeVar;

class GlobalVar;

class PointerVar;

class RandomVar;

class BbcorePointerVar;

class ExternVar;

class ParamBlock;

class IndependentBlock;

class AssignedBlock;

class StateBlock;

class InitialBlock;

class ConstructorBlock;

class DestructorBlock;

class StatementBlock;

class DerivativeBlock;

class LinearBlock;

class NonLinearBlock;

class DiscreteBlock;

class FunctionTableBlock;

class FunctionBlock;

class ProcedureBlock;

class NetReceiveBlock;

class SolveBlock;

class BreakpointBlock;

class BeforeBlock;

class AfterBlock;

class BABlock;

class ForNetcon;

class KineticBlock;

class UnitBlock;

class ConstantBlock;

class NeuronBlock;

class Unit;

class DoubleUnit;

class LocalVar;

class Limits;

class NumberRange;

class ConstantVar;

class BinaryOperator;

class UnaryOperator;

class ReactionOperator;

class ParenExpression;

class BinaryExpression;

class DiffEqExpression;

class UnaryExpression;

class NonLinEquation;

class LinEquation;

class FunctionCall;

class Watch;

class BABlockType;

class UnitDef;

class FactorDef;

class Valence;

class UnitState;

class LocalListStatement;

class Model;

class Define;

class Include;

class ParamAssign;

class AssignedDefinition;

class ConductanceHint;

class ExpressionStatement;

class ProtectStatement;

class FromStatement;

class WhileStatement;

class IfStatement;

class ElseIfStatement;

class ElseStatement;

class WatchStatement;

class MutexLock;

class MutexUnlock;

class Conserve;

class Compartment;

class LonDifuse;

class ReactionStatement;

class LagStatement;

class ConstantStatement;

class TableStatement;

class Suffix;

class Useion;

class Nonspecific;

class ElectrodeCurrent;

class Range;

class Global;

class RandomVarList;

class Pointer;

class BbcorePointer;

class External;

class ThreadSafe;

class Verbatim;

class LineComment;

class BlockComment;

class OntologyStatement;

class Program;

class NrnStateBlock;

class EigenNewtonSolverBlock;

class EigenLinearSolverBlock;

class WrappedExpression;

class DerivimplicitCallback;

class SolutionExpression;

class UpdateDt;


/**

 * @defgroup ast_type AST Node Types

 * @ingroup ast

 * @brief Enum node types for all ast nodes

 * @{

 */


/**

 * \brief Enum type for every AST node type

 *

 * Every node in the ast has associated type represented by this

 * enum class.

 *

 * \sa ast::Ast::get_node_type ast::Ast::get_node_type_name

 */

enum class AstNodeType {

    NODE, ///< type of ast::Node

    STATEMENT, ///< type of ast::Statement

    EXPRESSION, ///< type of ast::Expression

    BLOCK, ///< type of ast::Block

    IDENTIFIER, ///< type of ast::Identifier

    NUMBER, ///< type of ast::Number

    STRING, ///< type of ast::String

    INTEGER, ///< type of ast::Integer

    FLOAT, ///< type of ast::Float

    DOUBLE, ///< type of ast::Double

    BOOLEAN, ///< type of ast::Boolean

    NAME, ///< type of ast::Name

    PRIME_NAME, ///< type of ast::PrimeName

    INDEXED_NAME, ///< type of ast::IndexedName

    VAR_NAME, ///< type of ast::VarName

    ARGUMENT, ///< type of ast::Argument

    REACT_VAR_NAME, ///< type of ast::ReactVarName

    READ_ION_VAR, ///< type of ast::ReadIonVar

    WRITE_ION_VAR, ///< type of ast::WriteIonVar

    NONSPECIFIC_CUR_VAR, ///< type of ast::NonspecificCurVar

    ELECTRODE_CUR_VAR, ///< type of ast::ElectrodeCurVar

    RANGE_VAR, ///< type of ast::RangeVar

    GLOBAL_VAR, ///< type of ast::GlobalVar

    POINTER_VAR, ///< type of ast::PointerVar

    RANDOM_VAR, ///< type of ast::RandomVar

    BBCORE_POINTER_VAR, ///< type of ast::BbcorePointerVar

    EXTERN_VAR, ///< type of ast::ExternVar

    PARAM_BLOCK, ///< type of ast::ParamBlock

    INDEPENDENT_BLOCK, ///< type of ast::IndependentBlock

    ASSIGNED_BLOCK, ///< type of ast::AssignedBlock

    STATE_BLOCK, ///< type of ast::StateBlock

    INITIAL_BLOCK, ///< type of ast::InitialBlock

    CONSTRUCTOR_BLOCK, ///< type of ast::ConstructorBlock

    DESTRUCTOR_BLOCK, ///< type of ast::DestructorBlock

    STATEMENT_BLOCK, ///< type of ast::StatementBlock

    DERIVATIVE_BLOCK, ///< type of ast::DerivativeBlock

    LINEAR_BLOCK, ///< type of ast::LinearBlock

    NON_LINEAR_BLOCK, ///< type of ast::NonLinearBlock

    DISCRETE_BLOCK, ///< type of ast::DiscreteBlock

    FUNCTION_TABLE_BLOCK, ///< type of ast::FunctionTableBlock

    FUNCTION_BLOCK, ///< type of ast::FunctionBlock

    PROCEDURE_BLOCK, ///< type of ast::ProcedureBlock

    NET_RECEIVE_BLOCK, ///< type of ast::NetReceiveBlock

    SOLVE_BLOCK, ///< type of ast::SolveBlock

    BREAKPOINT_BLOCK, ///< type of ast::BreakpointBlock

    BEFORE_BLOCK, ///< type of ast::BeforeBlock

    AFTER_BLOCK, ///< type of ast::AfterBlock

    BA_BLOCK, ///< type of ast::BABlock

    FOR_NETCON, ///< type of ast::ForNetcon

    KINETIC_BLOCK, ///< type of ast::KineticBlock

    UNIT_BLOCK, ///< type of ast::UnitBlock

    CONSTANT_BLOCK, ///< type of ast::ConstantBlock

    NEURON_BLOCK, ///< type of ast::NeuronBlock

    UNIT, ///< type of ast::Unit

    DOUBLE_UNIT, ///< type of ast::DoubleUnit

    LOCAL_VAR, ///< type of ast::LocalVar

    LIMITS, ///< type of ast::Limits

    NUMBER_RANGE, ///< type of ast::NumberRange

    CONSTANT_VAR, ///< type of ast::ConstantVar

    BINARY_OPERATOR, ///< type of ast::BinaryOperator

    UNARY_OPERATOR, ///< type of ast::UnaryOperator

    REACTION_OPERATOR, ///< type of ast::ReactionOperator

    PAREN_EXPRESSION, ///< type of ast::ParenExpression

    BINARY_EXPRESSION, ///< type of ast::BinaryExpression

    DIFF_EQ_EXPRESSION, ///< type of ast::DiffEqExpression

    UNARY_EXPRESSION, ///< type of ast::UnaryExpression

    NON_LIN_EQUATION, ///< type of ast::NonLinEquation

    LIN_EQUATION, ///< type of ast::LinEquation

    FUNCTION_CALL, ///< type of ast::FunctionCall

    WATCH, ///< type of ast::Watch

    BA_BLOCK_TYPE, ///< type of ast::BABlockType

    UNIT_DEF, ///< type of ast::UnitDef

    FACTOR_DEF, ///< type of ast::FactorDef

    VALENCE, ///< type of ast::Valence

    UNIT_STATE, ///< type of ast::UnitState

    LOCAL_LIST_STATEMENT, ///< type of ast::LocalListStatement

    MODEL, ///< type of ast::Model

    DEFINE, ///< type of ast::Define

    INCLUDE, ///< type of ast::Include

    PARAM_ASSIGN, ///< type of ast::ParamAssign

    ASSIGNED_DEFINITION, ///< type of ast::AssignedDefinition

    CONDUCTANCE_HINT, ///< type of ast::ConductanceHint

    EXPRESSION_STATEMENT, ///< type of ast::ExpressionStatement

    PROTECT_STATEMENT, ///< type of ast::ProtectStatement

    FROM_STATEMENT, ///< type of ast::FromStatement

    WHILE_STATEMENT, ///< type of ast::WhileStatement

    IF_STATEMENT, ///< type of ast::IfStatement

    ELSE_IF_STATEMENT, ///< type of ast::ElseIfStatement

    ELSE_STATEMENT, ///< type of ast::ElseStatement

    WATCH_STATEMENT, ///< type of ast::WatchStatement

    MUTEX_LOCK, ///< type of ast::MutexLock

    MUTEX_UNLOCK, ///< type of ast::MutexUnlock

    CONSERVE, ///< type of ast::Conserve

    COMPARTMENT, ///< type of ast::Compartment

    LON_DIFUSE, ///< type of ast::LonDifuse

    REACTION_STATEMENT, ///< type of ast::ReactionStatement

    LAG_STATEMENT, ///< type of ast::LagStatement

    CONSTANT_STATEMENT, ///< type of ast::ConstantStatement

    TABLE_STATEMENT, ///< type of ast::TableStatement

    SUFFIX, ///< type of ast::Suffix

    USEION, ///< type of ast::Useion

    NONSPECIFIC, ///< type of ast::Nonspecific

    ELECTRODE_CURRENT, ///< type of ast::ElectrodeCurrent

    RANGE, ///< type of ast::Range

    GLOBAL, ///< type of ast::Global

    RANDOM_VAR_LIST, ///< type of ast::RandomVarList

    POINTER, ///< type of ast::Pointer

    BBCORE_POINTER, ///< type of ast::BbcorePointer

    EXTERNAL, ///< type of ast::External

    THREAD_SAFE, ///< type of ast::ThreadSafe

    VERBATIM, ///< type of ast::Verbatim

    LINE_COMMENT, ///< type of ast::LineComment

    BLOCK_COMMENT, ///< type of ast::BlockComment

    ONTOLOGY_STATEMENT, ///< type of ast::OntologyStatement

    PROGRAM, ///< type of ast::Program

    NRN_STATE_BLOCK, ///< type of ast::NrnStateBlock

    EIGEN_NEWTON_SOLVER_BLOCK, ///< type of ast::EigenNewtonSolverBlock

    EIGEN_LINEAR_SOLVER_BLOCK, ///< type of ast::EigenLinearSolverBlock

    WRAPPED_EXPRESSION, ///< type of ast::WrappedExpression

    DERIVIMPLICIT_CALLBACK, ///< type of ast::DerivimplicitCallback

    SOLUTION_EXPRESSION, ///< type of ast::SolutionExpression

    UPDATE_DT, ///< type of ast::UpdateDt

};


/** @} */  // end of ast_type


/**

 * @defgroup ast_vec_type AST Vector Type Aliases

 * @ingroup ast

 * @brief Vector type alias for AST node

 * @{

 */

using NodeVector = std::vector<std::shared_ptr<Node>>;

using StatementVector = std::vector<std::shared_ptr<Statement>>;

using ExpressionVector = std::vector<std::shared_ptr<Expression>>;

using BlockVector = std::vector<std::shared_ptr<Block>>;

using IdentifierVector = std::vector<std::shared_ptr<Identifier>>;

using NumberVector = std::vector<std::shared_ptr<Number>>;

using StringVector = std::vector<std::shared_ptr<String>>;

using IntegerVector = std::vector<std::shared_ptr<Integer>>;

using FloatVector = std::vector<std::shared_ptr<Float>>;

using DoubleVector = std::vector<std::shared_ptr<Double>>;

using BooleanVector = std::vector<std::shared_ptr<Boolean>>;

using NameVector = std::vector<std::shared_ptr<Name>>;

using PrimeNameVector = std::vector<std::shared_ptr<PrimeName>>;

using IndexedNameVector = std::vector<std::shared_ptr<IndexedName>>;

using VarNameVector = std::vector<std::shared_ptr<VarName>>;

using ArgumentVector = std::vector<std::shared_ptr<Argument>>;

using ReactVarNameVector = std::vector<std::shared_ptr<ReactVarName>>;

using ReadIonVarVector = std::vector<std::shared_ptr<ReadIonVar>>;

using WriteIonVarVector = std::vector<std::shared_ptr<WriteIonVar>>;

using NonspecificCurVarVector = std::vector<std::shared_ptr<NonspecificCurVar>>;

using ElectrodeCurVarVector = std::vector<std::shared_ptr<ElectrodeCurVar>>;

using RangeVarVector = std::vector<std::shared_ptr<RangeVar>>;

using GlobalVarVector = std::vector<std::shared_ptr<GlobalVar>>;

using PointerVarVector = std::vector<std::shared_ptr<PointerVar>>;

using RandomVarVector = std::vector<std::shared_ptr<RandomVar>>;

using BbcorePointerVarVector = std::vector<std::shared_ptr<BbcorePointerVar>>;

using ExternVarVector = std::vector<std::shared_ptr<ExternVar>>;

using ParamBlockVector = std::vector<std::shared_ptr<ParamBlock>>;

using IndependentBlockVector = std::vector<std::shared_ptr<IndependentBlock>>;

using AssignedBlockVector = std::vector<std::shared_ptr<AssignedBlock>>;

using StateBlockVector = std::vector<std::shared_ptr<StateBlock>>;

using InitialBlockVector = std::vector<std::shared_ptr<InitialBlock>>;

using ConstructorBlockVector = std::vector<std::shared_ptr<ConstructorBlock>>;

using DestructorBlockVector = std::vector<std::shared_ptr<DestructorBlock>>;

using StatementBlockVector = std::vector<std::shared_ptr<StatementBlock>>;

using DerivativeBlockVector = std::vector<std::shared_ptr<DerivativeBlock>>;

using LinearBlockVector = std::vector<std::shared_ptr<LinearBlock>>;

using NonLinearBlockVector = std::vector<std::shared_ptr<NonLinearBlock>>;

using DiscreteBlockVector = std::vector<std::shared_ptr<DiscreteBlock>>;

using FunctionTableBlockVector = std::vector<std::shared_ptr<FunctionTableBlock>>;

using FunctionBlockVector = std::vector<std::shared_ptr<FunctionBlock>>;

using ProcedureBlockVector = std::vector<std::shared_ptr<ProcedureBlock>>;

using NetReceiveBlockVector = std::vector<std::shared_ptr<NetReceiveBlock>>;

using SolveBlockVector = std::vector<std::shared_ptr<SolveBlock>>;

using BreakpointBlockVector = std::vector<std::shared_ptr<BreakpointBlock>>;

using BeforeBlockVector = std::vector<std::shared_ptr<BeforeBlock>>;

using AfterBlockVector = std::vector<std::shared_ptr<AfterBlock>>;

using BABlockVector = std::vector<std::shared_ptr<BABlock>>;

using ForNetconVector = std::vector<std::shared_ptr<ForNetcon>>;

using KineticBlockVector = std::vector<std::shared_ptr<KineticBlock>>;

using UnitBlockVector = std::vector<std::shared_ptr<UnitBlock>>;

using ConstantBlockVector = std::vector<std::shared_ptr<ConstantBlock>>;

using NeuronBlockVector = std::vector<std::shared_ptr<NeuronBlock>>;

using UnitVector = std::vector<std::shared_ptr<Unit>>;

using DoubleUnitVector = std::vector<std::shared_ptr<DoubleUnit>>;

using LocalVarVector = std::vector<std::shared_ptr<LocalVar>>;

using LimitsVector = std::vector<std::shared_ptr<Limits>>;

using NumberRangeVector = std::vector<std::shared_ptr<NumberRange>>;

using ConstantVarVector = std::vector<std::shared_ptr<ConstantVar>>;

using BinaryOperatorVector = std::vector<std::shared_ptr<BinaryOperator>>;

using UnaryOperatorVector = std::vector<std::shared_ptr<UnaryOperator>>;

using ReactionOperatorVector = std::vector<std::shared_ptr<ReactionOperator>>;

using ParenExpressionVector = std::vector<std::shared_ptr<ParenExpression>>;

using BinaryExpressionVector = std::vector<std::shared_ptr<BinaryExpression>>;

using DiffEqExpressionVector = std::vector<std::shared_ptr<DiffEqExpression>>;

using UnaryExpressionVector = std::vector<std::shared_ptr<UnaryExpression>>;

using NonLinEquationVector = std::vector<std::shared_ptr<NonLinEquation>>;

using LinEquationVector = std::vector<std::shared_ptr<LinEquation>>;

using FunctionCallVector = std::vector<std::shared_ptr<FunctionCall>>;

using WatchVector = std::vector<std::shared_ptr<Watch>>;

using BABlockTypeVector = std::vector<std::shared_ptr<BABlockType>>;

using UnitDefVector = std::vector<std::shared_ptr<UnitDef>>;

using FactorDefVector = std::vector<std::shared_ptr<FactorDef>>;

using ValenceVector = std::vector<std::shared_ptr<Valence>>;

using UnitStateVector = std::vector<std::shared_ptr<UnitState>>;

using LocalListStatementVector = std::vector<std::shared_ptr<LocalListStatement>>;

using ModelVector = std::vector<std::shared_ptr<Model>>;

using DefineVector = std::vector<std::shared_ptr<Define>>;

using IncludeVector = std::vector<std::shared_ptr<Include>>;

using ParamAssignVector = std::vector<std::shared_ptr<ParamAssign>>;

using AssignedDefinitionVector = std::vector<std::shared_ptr<AssignedDefinition>>;

using ConductanceHintVector = std::vector<std::shared_ptr<ConductanceHint>>;

using ExpressionStatementVector = std::vector<std::shared_ptr<ExpressionStatement>>;

using ProtectStatementVector = std::vector<std::shared_ptr<ProtectStatement>>;

using FromStatementVector = std::vector<std::shared_ptr<FromStatement>>;

using WhileStatementVector = std::vector<std::shared_ptr<WhileStatement>>;

using IfStatementVector = std::vector<std::shared_ptr<IfStatement>>;

using ElseIfStatementVector = std::vector<std::shared_ptr<ElseIfStatement>>;

using ElseStatementVector = std::vector<std::shared_ptr<ElseStatement>>;

using WatchStatementVector = std::vector<std::shared_ptr<WatchStatement>>;

using MutexLockVector = std::vector<std::shared_ptr<MutexLock>>;

using MutexUnlockVector = std::vector<std::shared_ptr<MutexUnlock>>;

using ConserveVector = std::vector<std::shared_ptr<Conserve>>;

using CompartmentVector = std::vector<std::shared_ptr<Compartment>>;

using LonDifuseVector = std::vector<std::shared_ptr<LonDifuse>>;

using ReactionStatementVector = std::vector<std::shared_ptr<ReactionStatement>>;

using LagStatementVector = std::vector<std::shared_ptr<LagStatement>>;

using ConstantStatementVector = std::vector<std::shared_ptr<ConstantStatement>>;

using TableStatementVector = std::vector<std::shared_ptr<TableStatement>>;

using SuffixVector = std::vector<std::shared_ptr<Suffix>>;

using UseionVector = std::vector<std::shared_ptr<Useion>>;

using NonspecificVector = std::vector<std::shared_ptr<Nonspecific>>;

using ElectrodeCurrentVector = std::vector<std::shared_ptr<ElectrodeCurrent>>;

using RangeVector = std::vector<std::shared_ptr<Range>>;

using GlobalVector = std::vector<std::shared_ptr<Global>>;

using RandomVarListVector = std::vector<std::shared_ptr<RandomVarList>>;

using PointerVector = std::vector<std::shared_ptr<Pointer>>;

using BbcorePointerVector = std::vector<std::shared_ptr<BbcorePointer>>;

using ExternalVector = std::vector<std::shared_ptr<External>>;

using ThreadSafeVector = std::vector<std::shared_ptr<ThreadSafe>>;

using VerbatimVector = std::vector<std::shared_ptr<Verbatim>>;

using LineCommentVector = std::vector<std::shared_ptr<LineComment>>;

using BlockCommentVector = std::vector<std::shared_ptr<BlockComment>>;

using OntologyStatementVector = std::vector<std::shared_ptr<OntologyStatement>>;

using ProgramVector = std::vector<std::shared_ptr<Program>>;

using NrnStateBlockVector = std::vector<std::shared_ptr<NrnStateBlock>>;

using EigenNewtonSolverBlockVector = std::vector<std::shared_ptr<EigenNewtonSolverBlock>>;

using EigenLinearSolverBlockVector = std::vector<std::shared_ptr<EigenLinearSolverBlock>>;

using WrappedExpressionVector = std::vector<std::shared_ptr<WrappedExpression>>;

using DerivimplicitCallbackVector = std::vector<std::shared_ptr<DerivimplicitCallback>>;

using SolutionExpressionVector = std::vector<std::shared_ptr<SolutionExpression>>;

using UpdateDtVector = std::vector<std::shared_ptr<UpdateDt>>;


/** @} */  // end of ast_vec_type


}  // namespace ast

}  // namespace nmodl