Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/AST/Pass.hpp

    r23f99e1 r9e1d485  
    2323#include "AST/Fwd.hpp"
    2424#include "AST/Node.hpp"
    25 
    26 #include "AST/Attribute.hpp"
    2725#include "AST/Decl.hpp"
    28 #include "AST/Expr.hpp"
    29 #include "AST/Init.hpp"
    30 #include "AST/Stmt.hpp"
    31 
    3226#include "AST/Visitor.hpp"
    3327
     
    8579
    8680        /// Visit function declarations
    87         const ast::DeclWithType *     visit( const ast::ObjectDecl           * ) override final;
    88         const ast::DeclWithType *     visit( const ast::FunctionDecl         * ) override final;
    89         const ast::Decl *             visit( const ast::StructDecl           * ) override final;
    90         const ast::Decl *             visit( const ast::UnionDecl            * ) override final;
    91         const ast::Decl *             visit( const ast::EnumDecl             * ) override final;
    92         const ast::Decl *             visit( const ast::TraitDecl            * ) override final;
    93         const ast::Decl *             visit( const ast::TypeDecl             * ) override final;
    94         const ast::Decl *             visit( const ast::TypedefDecl          * ) override final;
    95         const ast::AsmDecl *          visit( const ast::AsmDecl              * ) override final;
    96         const ast::StaticAssertDecl * visit( const ast::StaticAssertDecl     * ) override final;
    97         const ast::CompoundStmt *     visit( const ast::CompoundStmt         * ) override final;
    98         const ast::Stmt *             visit( const ast::ExprStmt             * ) override final;
    99         const ast::Stmt *             visit( const ast::AsmStmt              * ) override final;
    100         const ast::Stmt *             visit( const ast::DirectiveStmt        * ) override final;
    101         const ast::Stmt *             visit( const ast::IfStmt               * ) override final;
    102         const ast::Stmt *             visit( const ast::WhileStmt            * ) override final;
    103         const ast::Stmt *             visit( const ast::ForStmt              * ) override final;
    104         const ast::Stmt *             visit( const ast::SwitchStmt           * ) override final;
    105         const ast::Stmt *             visit( const ast::CaseStmt             * ) override final;
    106         const ast::Stmt *             visit( const ast::BranchStmt           * ) override final;
    107         const ast::Stmt *             visit( const ast::ReturnStmt           * ) override final;
    108         const ast::Stmt *             visit( const ast::ThrowStmt            * ) override final;
    109         const ast::Stmt *             visit( const ast::TryStmt              * ) override final;
    110         const ast::Stmt *             visit( const ast::CatchStmt            * ) override final;
    111         const ast::Stmt *             visit( const ast::FinallyStmt          * ) override final;
    112         const ast::Stmt *             visit( const ast::WaitForStmt          * ) override final;
    113         const ast::Stmt *             visit( const ast::WithStmt             * ) override final;
    114         const ast::NullStmt *         visit( const ast::NullStmt             * ) override final;
    115         const ast::Stmt *             visit( const ast::DeclStmt             * ) override final;
    116         const ast::Stmt *             visit( const ast::ImplicitCtorDtorStmt * ) override final;
    117         const ast::Expr *             visit( const ast::ApplicationExpr      * ) override final;
    118         const ast::Expr *             visit( const ast::UntypedExpr          * ) override final;
    119         const ast::Expr *             visit( const ast::NameExpr             * ) override final;
    120         const ast::Expr *             visit( const ast::AddressExpr          * ) override final;
    121         const ast::Expr *             visit( const ast::LabelAddressExpr     * ) override final;
    122         const ast::Expr *             visit( const ast::CastExpr             * ) override final;
    123         const ast::Expr *             visit( const ast::KeywordCastExpr      * ) override final;
    124         const ast::Expr *             visit( const ast::VirtualCastExpr      * ) override final;
    125         const ast::Expr *             visit( const ast::UntypedMemberExpr    * ) override final;
    126         const ast::Expr *             visit( const ast::MemberExpr           * ) override final;
    127         const ast::Expr *             visit( const ast::VariableExpr         * ) override final;
    128         const ast::Expr *             visit( const ast::ConstantExpr         * ) override final;
    129         const ast::Expr *             visit( const ast::SizeofExpr           * ) override final;
    130         const ast::Expr *             visit( const ast::AlignofExpr          * ) override final;
    131         const ast::Expr *             visit( const ast::UntypedOffsetofExpr  * ) override final;
    132         const ast::Expr *             visit( const ast::OffsetofExpr         * ) override final;
    133         const ast::Expr *             visit( const ast::OffsetPackExpr       * ) override final;
    134         const ast::Expr *             visit( const ast::AttrExpr             * ) override final;
    135         const ast::Expr *             visit( const ast::LogicalExpr          * ) override final;
    136         const ast::Expr *             visit( const ast::ConditionalExpr      * ) override final;
    137         const ast::Expr *             visit( const ast::CommaExpr            * ) override final;
    138         const ast::Expr *             visit( const ast::TypeExpr             * ) override final;
    139         const ast::Expr *             visit( const ast::AsmExpr              * ) override final;
    140         const ast::Expr *             visit( const ast::ImplicitCopyCtorExpr * ) override final;
    141         const ast::Expr *             visit( const ast::ConstructorExpr      * ) override final;
    142         const ast::Expr *             visit( const ast::CompoundLiteralExpr  * ) override final;
    143         const ast::Expr *             visit( const ast::RangeExpr            * ) override final;
    144         const ast::Expr *             visit( const ast::UntypedTupleExpr     * ) override final;
    145         const ast::Expr *             visit( const ast::TupleExpr            * ) override final;
    146         const ast::Expr *             visit( const ast::TupleIndexExpr       * ) override final;
    147         const ast::Expr *             visit( const ast::TupleAssignExpr      * ) override final;
    148         const ast::Expr *             visit( const ast::StmtExpr             * ) override final;
    149         const ast::Expr *             visit( const ast::UniqueExpr           * ) override final;
    150         const ast::Expr *             visit( const ast::UntypedInitExpr      * ) override final;
    151         const ast::Expr *             visit( const ast::InitExpr             * ) override final;
    152         const ast::Expr *             visit( const ast::DeletedExpr          * ) override final;
    153         const ast::Expr *             visit( const ast::DefaultArgExpr       * ) override final;
    154         const ast::Expr *             visit( const ast::GenericExpr          * ) override final;
    155         const ast::Type *             visit( const ast::VoidType             * ) override final;
    156         const ast::Type *             visit( const ast::BasicType            * ) override final;
    157         const ast::Type *             visit( const ast::PointerType          * ) override final;
    158         const ast::Type *             visit( const ast::ArrayType            * ) override final;
    159         const ast::Type *             visit( const ast::ReferenceType        * ) override final;
    160         const ast::Type *             visit( const ast::QualifiedType        * ) override final;
    161         const ast::Type *             visit( const ast::FunctionType         * ) override final;
    162         const ast::Type *             visit( const ast::StructInstType       * ) override final;
    163         const ast::Type *             visit( const ast::UnionInstType        * ) override final;
    164         const ast::Type *             visit( const ast::EnumInstType         * ) override final;
    165         const ast::Type *             visit( const ast::TraitInstType        * ) override final;
    166         const ast::Type *             visit( const ast::TypeInstType         * ) override final;
    167         const ast::Type *             visit( const ast::TupleType            * ) override final;
    168         const ast::Type *             visit( const ast::TypeofType           * ) override final;
    169         const ast::Type *             visit( const ast::AttrType             * ) override final;
    170         const ast::Type *             visit( const ast::VarArgsType          * ) override final;
    171         const ast::Type *             visit( const ast::ZeroType             * ) override final;
    172         const ast::Type *             visit( const ast::OneType              * ) override final;
    173         const ast::Type *             visit( const ast::GlobalScopeType      * ) override final;
    174         const ast::Designation *      visit( const ast::Designation          * ) override final;
    175         const ast::Init *             visit( const ast::SingleInit           * ) override final;
    176         const ast::Init *             visit( const ast::ListInit             * ) override final;
    177         const ast::Init *             visit( const ast::ConstructorInit      * ) override final;
    178         const ast::Constant *         visit( const ast::Constant             * ) override final;
    179         const ast::Attribute *        visit( const ast::Attribute            * ) override final;
    180         const ast::TypeSubstitution * visit( const ast::TypeSubstitution     * ) override final;
     81        virtual DeclWithType *     visit( const ObjectDecl           * ) override final;
     82        virtual DeclWithType *     visit( const FunctionDecl         * ) override final;
     83        virtual Decl *             visit( const StructDecl           * ) override final;
     84        virtual Decl *             visit( const UnionDecl            * ) override final;
     85        virtual Decl *             visit( const EnumDecl             * ) override final;
     86        virtual Decl *             visit( const TraitDecl            * ) override final;
     87        virtual Decl *             visit( const TypeDecl             * ) override final;
     88        virtual Decl *             visit( const TypedefDecl          * ) override final;
     89        virtual AsmDecl *          visit( const AsmDecl              * ) override final;
     90        virtual StaticAssertDecl * visit( const StaticAssertDecl     * ) override final;
     91        virtual CompoundStmt *     visit( const CompoundStmt         * ) override final;
     92        virtual Stmt *             visit( const ExprStmt             * ) override final;
     93        virtual Stmt *             visit( const AsmStmt              * ) override final;
     94        virtual Stmt *             visit( const DirectiveStmt        * ) override final;
     95        virtual Stmt *             visit( const IfStmt               * ) override final;
     96        virtual Stmt *             visit( const WhileStmt            * ) override final;
     97        virtual Stmt *             visit( const ForStmt              * ) override final;
     98        virtual Stmt *             visit( const SwitchStmt           * ) override final;
     99        virtual Stmt *             visit( const CaseStmt             * ) override final;
     100        virtual Stmt *             visit( const BranchStmt           * ) override final;
     101        virtual Stmt *             visit( const ReturnStmt           * ) override final;
     102        virtual Stmt *             visit( const ThrowStmt            * ) override final;
     103        virtual Stmt *             visit( const TryStmt              * ) override final;
     104        virtual Stmt *             visit( const CatchStmt            * ) override final;
     105        virtual Stmt *             visit( const FinallyStmt          * ) override final;
     106        virtual Stmt *             visit( const WaitForStmt          * ) override final;
     107        virtual Stmt *             visit( const WithStmt             * ) override final;
     108        virtual NullStmt *         visit( const NullStmt             * ) override final;
     109        virtual Stmt *             visit( const DeclStmt             * ) override final;
     110        virtual Stmt *             visit( const ImplicitCtorDtorStmt * ) override final;
     111        virtual Expr *             visit( const ApplicationExpr      * ) override final;
     112        virtual Expr *             visit( const UntypedExpr          * ) override final;
     113        virtual Expr *             visit( const NameExpr             * ) override final;
     114        virtual Expr *             visit( const AddressExpr          * ) override final;
     115        virtual Expr *             visit( const LabelAddressExpr     * ) override final;
     116        virtual Expr *             visit( const CastExpr             * ) override final;
     117        virtual Expr *             visit( const KeywordCastExpr      * ) override final;
     118        virtual Expr *             visit( const VirtualCastExpr      * ) override final;
     119        virtual Expr *             visit( const UntypedMemberExpr    * ) override final;
     120        virtual Expr *             visit( const MemberExpr           * ) override final;
     121        virtual Expr *             visit( const VariableExpr         * ) override final;
     122        virtual Expr *             visit( const ConstantExpr         * ) override final;
     123        virtual Expr *             visit( const SizeofExpr           * ) override final;
     124        virtual Expr *             visit( const AlignofExpr          * ) override final;
     125        virtual Expr *             visit( const UntypedOffsetofExpr  * ) override final;
     126        virtual Expr *             visit( const OffsetofExpr         * ) override final;
     127        virtual Expr *             visit( const OffsetPackExpr       * ) override final;
     128        virtual Expr *             visit( const AttrExpr             * ) override final;
     129        virtual Expr *             visit( const LogicalExpr          * ) override final;
     130        virtual Expr *             visit( const ConditionalExpr      * ) override final;
     131        virtual Expr *             visit( const CommaExpr            * ) override final;
     132        virtual Expr *             visit( const TypeExpr             * ) override final;
     133        virtual Expr *             visit( const AsmExpr              * ) override final;
     134        virtual Expr *             visit( const ImplicitCopyCtorExpr * ) override final;
     135        virtual Expr *             visit( const ConstructorExpr      * ) override final;
     136        virtual Expr *             visit( const CompoundLiteralExpr  * ) override final;
     137        virtual Expr *             visit( const RangeExpr            * ) override final;
     138        virtual Expr *             visit( const UntypedTupleExpr     * ) override final;
     139        virtual Expr *             visit( const TupleExpr            * ) override final;
     140        virtual Expr *             visit( const TupleIndexExpr       * ) override final;
     141        virtual Expr *             visit( const TupleAssignExpr      * ) override final;
     142        virtual Expr *             visit( const StmtExpr             * ) override final;
     143        virtual Expr *             visit( const UniqueExpr           * ) override final;
     144        virtual Expr *             visit( const UntypedInitExpr      * ) override final;
     145        virtual Expr *             visit( const InitExpr             * ) override final;
     146        virtual Expr *             visit( const DeletedExpr          * ) override final;
     147        virtual Expr *             visit( const DefaultArgExpr       * ) override final;
     148        virtual Expr *             visit( const GenericExpr          * ) override final;
     149        virtual Type *             visit( const VoidType             * ) override final;
     150        virtual Type *             visit( const BasicType            * ) override final;
     151        virtual Type *             visit( const PointerType          * ) override final;
     152        virtual Type *             visit( const ArrayType            * ) override final;
     153        virtual Type *             visit( const ReferenceType        * ) override final;
     154        virtual Type *             visit( const QualifiedType        * ) override final;
     155        virtual Type *             visit( const FunctionType         * ) override final;
     156        virtual Type *             visit( const StructInstType       * ) override final;
     157        virtual Type *             visit( const UnionInstType        * ) override final;
     158        virtual Type *             visit( const EnumInstType         * ) override final;
     159        virtual Type *             visit( const TraitInstType        * ) override final;
     160        virtual Type *             visit( const TypeInstType         * ) override final;
     161        virtual Type *             visit( const TupleType            * ) override final;
     162        virtual Type *             visit( const TypeofType           * ) override final;
     163        virtual Type *             visit( const VarArgsType          * ) override final;
     164        virtual Type *             visit( const ZeroType             * ) override final;
     165        virtual Type *             visit( const OneType              * ) override final;
     166        virtual Type *             visit( const GlobalScopeType      * ) override final;
     167        virtual Designation *      visit( const Designation          * ) override final;
     168        virtual Init *             visit( const SingleInit           * ) override final;
     169        virtual Init *             visit( const ListInit             * ) override final;
     170        virtual Init *             visit( const ConstructorInit      * ) override final;
     171        virtual Constant *         visit( const Constant             * ) override final;
     172        virtual Attribute *        visit( const Attribute            * ) override final;
     173        virtual TypeSubstitution * visit( const TypeSubstitution     * ) override final;
    181174
    182175        friend void acceptAll( std::list< ptr<Decl> > & decls, Pass<pass_t>& visitor );
     
    186179
    187180private:
    188         const ast::Stmt * call_accept( const ast::Stmt * );
    189         const ast::Expr * call_accept( const ast::Expr * );
    190 
    191         template< typename node_t >
    192         auto call_accept( const node_t * node ) -> decltype( node->accept(*this) );
    193 
    194         template< template <class...> class container_t >
     181        /// Logic to call the accept and mutate the parent if needed, delegates call to accept
     182        template<typename parent_t, typename child_t>
     183        void maybe_accept(parent_t * & , typename parent_t::child_t *);
     184
     185        Stmt * call_accept( const Stmt * );
     186        Expr * call_accept( const Expr * );
     187
     188        template< template <class> class container_t >
    195189        container_t< ptr<Stmt> > call_accept( const container_t< ptr<Stmt> > & );
    196190
    197         template< template <class...> class container_t, typename node_t >
     191        template< template <class> class container_t, typename node_t >
    198192        container_t< ptr<node_t> > call_accept( const container_t< ptr<node_t> > & container );
    199 
    200         /// Logic to call the accept and mutate the parent if needed, delegates call to accept
    201         template<typename node_t, typename parent_t, typename child_t>
    202         void maybe_accept(const node_t * &, child_t parent_t::* child);
    203193
    204194private:
     
    216206                Pass<pass_t> & pass;
    217207        };
    218 
    219 private:
    220         bool inFunction = false;
    221208};
    222209
    223210template<typename pass_t>
    224 void accept_all( std::list< ast::ptr<ast::Decl> > &, ast::Pass<pass_t> & visitor );
     211void acceptAll( std::list< ptr<Decl> >, Pass<pass_t>& visitor );
    225212
    226213//-------------------------------------------------------------------------------------------------
    227214// PASS ACCESSORIES
    228215//-------------------------------------------------------------------------------------------------
     216
     217template<typename T>
     218using std_list = std::list<T>;
    229219
    230220/// Keep track of the polymorphic const TypeSubstitution * env for the current expression
     
    235225/// Used if visitor requires added statements before or after the current node.
    236226/// The Pass template handles what *before* and *after* means automatically
    237 template< template<class...> class container_t = std::list >
     227template< template<class> class container_t = std_list >
    238228struct WithStmtsToAdd {
    239229        container_t< ptr<Stmt> > stmtsToAddBefore;
     
    243233/// Used if visitor requires added declarations before or after the current node.
    244234/// The Pass template handles what *before* and *after* means automatically
    245 template< template<class...> class container_t = std::list >
     235template< template<class> class container_t = std_list >
    246236struct WithDeclsToAdd {
    247237        container_t< ptr<Decl> > declsToAddBefore;
     
    295285};
    296286}
    297 
    298 #include "Common/Stats.h"
    299 
    300 extern struct PassVisitorStats {
    301         size_t depth = 0;
    302         Stats::Counters::MaxCounter<double> * max = nullptr;
    303         Stats::Counters::AverageCounter<double> * avg = nullptr;
    304 } pass_visitor_stats;
    305 
    306 #include "AST/Pass.impl.hpp"
Note: See TracChangeset for help on using the changeset viewer.