ast_decl.hpp

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.
///
 
#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 LonDiffuse;
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 CvodeBlock;
class LongitudinalDiffusionBlock;
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_DIFFUSE, ///< type of ast::LonDiffuse
    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
    CVODE_BLOCK, ///< type of ast::CvodeBlock
    LONGITUDINAL_DIFFUSION_BLOCK, ///< type of ast::LongitudinalDiffusionBlock
    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 LonDiffuseVector = std::vector<std::shared_ptr<LonDiffuse>>;
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 CvodeBlockVector = std::vector<std::shared_ptr<CvodeBlock>>;
using LongitudinalDiffusionBlockVector = std::vector<std::shared_ptr<LongitudinalDiffusionBlock>>;
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