Changeset 62e5546


Ignore:
Timestamp:
Oct 27, 2016, 4:22:27 PM (5 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
0ebac75
Parents:
d93d980
Message:

Removed warnings when compiling with clang

Location:
src
Files:
16 edited

Legend:

Unmodified
Added
Removed
  • src/ControlStruct/LabelFixer.h

    rd93d980 r62e5546  
    2626namespace ControlStruct {
    2727        /// normalizes label definitions and generates multi-level exit labels
    28         class LabelFixer : public Visitor {
     28        class LabelFixer final : public Visitor {
    2929                typedef Visitor Parent;
    3030          public:
     
    3333                std::map < Label, Statement * > *resolveJumps() throw ( SemanticError );
    3434
     35                using Visitor::visit;
     36
    3537                // Declarations
    36                 virtual void visit( FunctionDecl *functionDecl );
     38                virtual void visit( FunctionDecl *functionDecl ) override;
    3739
    3840                // Statements
    3941                void visit( Statement *stmt );
    4042
    41                 virtual void visit( CompoundStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
    42                 virtual void visit( NullStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
    43                 virtual void visit( ExprStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
    44                 virtual void visit( IfStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
    45                 virtual void visit( WhileStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
    46                 virtual void visit( ForStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
    47                 virtual void visit( SwitchStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
    48                 virtual void visit( CaseStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
    49                 virtual void visit( ReturnStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
    50                 virtual void visit( TryStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
    51                 virtual void visit( CatchStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
    52                 virtual void visit( DeclStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
    53                 virtual void visit( BranchStmt *branchStmt );
    54                 virtual void visit( UntypedExpr *untyped );
     43                virtual void visit( CompoundStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
     44                virtual void visit( NullStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
     45                virtual void visit( ExprStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
     46                virtual void visit( IfStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
     47                virtual void visit( WhileStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
     48                virtual void visit( ForStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
     49                virtual void visit( SwitchStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
     50                virtual void visit( CaseStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
     51                virtual void visit( ReturnStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
     52                virtual void visit( TryStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
     53                virtual void visit( CatchStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
     54                virtual void visit( DeclStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
     55                virtual void visit( BranchStmt *branchStmt ) override;
     56                virtual void visit( UntypedExpr *untyped ) override;
    5557
    5658                Label setLabelsDef( std::list< Label > &, Statement *definition );
  • src/ControlStruct/LabelTypeChecker.cc

    rd93d980 r62e5546  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // LabelTypeChecker.cc -- 
     7// LabelTypeChecker.cc --
    88//
    99// Author           : Rodolfo G. Esteves
     
    2828                assert( untypedExpr != 0 );
    2929                NameExpr *fname;
    30                 if ( ((fname = dynamic_cast<NameExpr *>(untypedExpr->get_function())) != 0) 
     30                if ( ((fname = dynamic_cast<NameExpr *>(untypedExpr->get_function())) != 0)
    3131                         && fname->get_name() == std::string("&&") )
    3232                        std::cerr << "Taking the label of an address." << std::endl;
     
    5858
    5959                NameExpr *name;
    60                 if ( ((name = dynamic_cast<NameExpr *>(target)) == 0) )
     60                if ( (name = dynamic_cast<NameExpr *>(target)) == 0 )
    6161                        return; // Not a name expression
    62        
     62
    6363                std::list< DeclarationWithType * > interps;
    6464                index.lookupId(name->get_name(), interps);
  • src/GenPoly/Box.cc

    rd93d980 r62e5546  
    6464
    6565                /// Adds layout-generation functions to polymorphic types
    66                 class LayoutFunctionBuilder : public DeclMutator {
     66                class LayoutFunctionBuilder final : public DeclMutator {
    6767                        unsigned int functionNesting;  // current level of nested functions
    6868                public:
    6969                        LayoutFunctionBuilder() : functionNesting( 0 ) {}
    7070
    71                         virtual DeclarationWithType *mutate( FunctionDecl *functionDecl );
    72                         virtual Declaration *mutate( StructDecl *structDecl );
    73                         virtual Declaration *mutate( UnionDecl *unionDecl );
     71                        using DeclMutator::mutate;
     72                        virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
     73                        virtual Declaration *mutate( StructDecl *structDecl ) override;
     74                        virtual Declaration *mutate( UnionDecl *unionDecl ) override;
    7475                };
    7576
    7677                /// Replaces polymorphic return types with out-parameters, replaces calls to polymorphic functions with adapter calls as needed, and adds appropriate type variables to the function call
    77                 class Pass1 : public PolyMutator {
     78                class Pass1 final : public PolyMutator {
    7879                  public:
    7980                        Pass1();
    80                         virtual Expression *mutate( ApplicationExpr *appExpr );
    81                         virtual Expression *mutate( AddressExpr *addrExpr );
    82                         virtual Expression *mutate( UntypedExpr *expr );
    83                         virtual DeclarationWithType* mutate( FunctionDecl *functionDecl );
    84                         virtual TypeDecl *mutate( TypeDecl *typeDecl );
    85                         virtual Expression *mutate( CommaExpr *commaExpr );
    86                         virtual Expression *mutate( ConditionalExpr *condExpr );
    87                         virtual Statement * mutate( ReturnStmt *returnStmt );
    88                         virtual Type *mutate( PointerType *pointerType );
    89                         virtual Type * mutate( FunctionType *functionType );
    90 
    91                         virtual void doBeginScope();
    92                         virtual void doEndScope();
     81
     82                        using PolyMutator::mutate;
     83                        virtual Expression *mutate( ApplicationExpr *appExpr ) override;
     84                        virtual Expression *mutate( AddressExpr *addrExpr ) override;
     85                        virtual Expression *mutate( UntypedExpr *expr ) override;
     86                        virtual DeclarationWithType* mutate( FunctionDecl *functionDecl ) override;
     87                        virtual TypeDecl *mutate( TypeDecl *typeDecl ) override;
     88                        virtual Expression *mutate( CommaExpr *commaExpr ) override;
     89                        virtual Expression *mutate( ConditionalExpr *condExpr ) override;
     90                        virtual Statement * mutate( ReturnStmt *returnStmt ) override;
     91                        virtual Type *mutate( PointerType *pointerType ) override;
     92                        virtual Type * mutate( FunctionType *functionType ) override;
     93
     94                        virtual void doBeginScope() override;
     95                        virtual void doEndScope() override;
    9396                  private:
    9497                        /// Pass the extra type parameters from polymorphic generic arguments or return types into a function application
     
    135138                /// * Moves polymorphic returns in function types to pointer-type parameters
    136139                /// * adds type size and assertion parameters to parameter lists
    137                 class Pass2 : public PolyMutator {
     140                class Pass2 final : public PolyMutator {
    138141                  public:
    139142                        template< typename DeclClass >
    140143                        DeclClass *handleDecl( DeclClass *decl, Type *type );
    141                         virtual DeclarationWithType *mutate( FunctionDecl *functionDecl );
    142                         virtual ObjectDecl *mutate( ObjectDecl *objectDecl );
    143                         virtual TypeDecl *mutate( TypeDecl *typeDecl );
    144                         virtual TypedefDecl *mutate( TypedefDecl *typedefDecl );
    145                         virtual Type *mutate( PointerType *pointerType );
    146                         virtual Type *mutate( FunctionType *funcType );
     144
     145                        using PolyMutator::mutate;
     146                        virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
     147                        virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override;
     148                        virtual TypeDecl *mutate( TypeDecl *typeDecl ) override;
     149                        virtual TypedefDecl *mutate( TypedefDecl *typedefDecl ) override;
     150                        virtual Type *mutate( PointerType *pointerType ) override;
     151                        virtual Type *mutate( FunctionType *funcType ) override;
    147152
    148153                  private:
     
    156161                /// * Calculates polymorphic offsetof expressions from offset array
    157162                /// * Inserts dynamic calculation of polymorphic type layouts where needed
    158                 class PolyGenericCalculator : public PolyMutator {
     163                class PolyGenericCalculator final : public PolyMutator {
    159164                public:
    160165                        typedef PolyMutator Parent;
     
    163168                        template< typename DeclClass >
    164169                        DeclClass *handleDecl( DeclClass *decl, Type *type );
    165                         virtual DeclarationWithType *mutate( FunctionDecl *functionDecl );
    166                         virtual ObjectDecl *mutate( ObjectDecl *objectDecl );
    167                         virtual TypedefDecl *mutate( TypedefDecl *objectDecl );
    168                         virtual TypeDecl *mutate( TypeDecl *objectDecl );
    169                         virtual Statement *mutate( DeclStmt *declStmt );
    170                         virtual Type *mutate( PointerType *pointerType );
    171                         virtual Type *mutate( FunctionType *funcType );
    172                         virtual Expression *mutate( MemberExpr *memberExpr );
    173                         virtual Expression *mutate( SizeofExpr *sizeofExpr );
    174                         virtual Expression *mutate( AlignofExpr *alignofExpr );
    175                         virtual Expression *mutate( OffsetofExpr *offsetofExpr );
    176                         virtual Expression *mutate( OffsetPackExpr *offsetPackExpr );
    177 
    178                         virtual void doBeginScope();
    179                         virtual void doEndScope();
     170                        virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
     171                        virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override;
     172                        virtual TypedefDecl *mutate( TypedefDecl *objectDecl ) override;
     173                        virtual TypeDecl *mutate( TypeDecl *objectDecl ) override;
     174                        virtual Statement *mutate( DeclStmt *declStmt ) override;
     175                        virtual Type *mutate( PointerType *pointerType ) override;
     176                        virtual Type *mutate( FunctionType *funcType ) override;
     177                        virtual Expression *mutate( MemberExpr *memberExpr ) override;
     178                        virtual Expression *mutate( SizeofExpr *sizeofExpr ) override;
     179                        virtual Expression *mutate( AlignofExpr *alignofExpr ) override;
     180                        virtual Expression *mutate( OffsetofExpr *offsetofExpr ) override;
     181                        virtual Expression *mutate( OffsetPackExpr *offsetPackExpr ) override;
     182
     183                        virtual void doBeginScope() override;
     184                        virtual void doEndScope() override;
    180185
    181186                private:
     
    197202
    198203                /// Replaces initialization of polymorphic values with alloca, declaration of dtype/ftype with appropriate void expression, and sizeof expressions of polymorphic types with the proper variable
    199                 class Pass3 : public PolyMutator {
     204                class Pass3 final : public PolyMutator {
    200205                  public:
    201206                        template< typename DeclClass >
    202207                        DeclClass *handleDecl( DeclClass *decl, Type *type );
    203                         virtual DeclarationWithType *mutate( FunctionDecl *functionDecl );
    204                         virtual ObjectDecl *mutate( ObjectDecl *objectDecl );
    205                         virtual TypedefDecl *mutate( TypedefDecl *objectDecl );
    206                         virtual TypeDecl *mutate( TypeDecl *objectDecl );
    207                         virtual Type *mutate( PointerType *pointerType );
    208                         virtual Type *mutate( FunctionType *funcType );
     208
     209                        using PolyMutator::mutate;
     210                        virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
     211                        virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override;
     212                        virtual TypedefDecl *mutate( TypedefDecl *objectDecl ) override;
     213                        virtual TypeDecl *mutate( TypeDecl *objectDecl ) override;
     214                        virtual Type *mutate( PointerType *pointerType ) override;
     215                        virtual Type *mutate( FunctionType *funcType ) override;
    209216                  private:
    210217                };
  • src/GenPoly/InstantiateGeneric.cc

    rd93d980 r62e5546  
    147147
    148148        /// Mutator pass that replaces concrete instantiations of generic types with actual struct declarations, scoped appropriately
    149         class GenericInstantiator : public DeclMutator {
     149        class GenericInstantiator final : public DeclMutator {
    150150                /// Map of (generic type, parameter list) pairs to concrete type instantiations
    151151                InstantiationMap< AggregateDecl, AggregateDecl > instantiations;
     
    158158                GenericInstantiator() : DeclMutator(), instantiations(), dtypeStatics(), typeNamer("_conc_") {}
    159159
    160                 virtual Type* mutate( StructInstType *inst );
    161                 virtual Type* mutate( UnionInstType *inst );
    162 
    163                 virtual void doBeginScope();
    164                 virtual void doEndScope();
     160                using DeclMutator::mutate;
     161                virtual Type* mutate( StructInstType *inst ) override;
     162                virtual Type* mutate( UnionInstType *inst ) override;
     163
     164                virtual void doBeginScope() override;
     165                virtual void doEndScope() override;
    165166        private:
    166167                /// Wrap instantiation lookup for structs
  • src/GenPoly/Specialize.cc

    rd93d980 r62e5546  
    3636        const std::list<Label> noLabels;
    3737
    38         class Specialize : public PolyMutator {
     38        class Specialize final : public PolyMutator {
    3939          public:
    4040                Specialize( std::string paramPrefix = "_p" );
    4141
    42                 virtual Expression * mutate( ApplicationExpr *applicationExpr );
    43                 virtual Expression * mutate( AddressExpr *castExpr );
    44                 virtual Expression * mutate( CastExpr *castExpr );
     42                using PolyMutator::mutate;
     43                virtual Expression * mutate( ApplicationExpr *applicationExpr ) override;
     44                virtual Expression * mutate( AddressExpr *castExpr ) override;
     45                virtual Expression * mutate( CastExpr *castExpr ) override;
    4546                // virtual Expression * mutate( LogicalExpr *logicalExpr );
    4647                // virtual Expression * mutate( ConditionalExpr *conditionalExpr );
  • src/InitTweak/FixInit.cc

    rd93d980 r62e5546  
    5050                const std::list<Expression*> noDesignators;
    5151
    52                 class InsertImplicitCalls : public GenPoly::PolyMutator {
     52                class InsertImplicitCalls final : public GenPoly::PolyMutator {
    5353                public:
    5454                        /// wrap function application expressions as ImplicitCopyCtorExpr nodes so that it is easy to identify which
     
    5656                        static void insert( std::list< Declaration * > & translationUnit );
    5757
    58                         virtual Expression * mutate( ApplicationExpr * appExpr );
    59                 };
    60 
    61                 class ResolveCopyCtors : public SymTab::Indexer {
     58                        using GenPoly::PolyMutator::mutate;
     59                        virtual Expression * mutate( ApplicationExpr * appExpr ) override;
     60                };
     61
     62                class ResolveCopyCtors final : public SymTab::Indexer {
    6263                public:
    6364                        /// generate temporary ObjectDecls for each argument and return value of each ImplicitCopyCtorExpr,
     
    6667                        static void resolveImplicitCalls( std::list< Declaration * > & translationUnit );
    6768
    68                         virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr );
     69                        using SymTab::Indexer::visit;
     70                        virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr ) override;
    6971
    7072                        /// create and resolve ctor/dtor expression: fname(var, [cpArg])
     
    8284                        using Parent::visit;
    8385                        typedef std::set< ObjectDecl * > ObjectSet;
    84                         virtual void visit( CompoundStmt *compoundStmt );
    85                         virtual void visit( DeclStmt *stmt );
     86                        virtual void visit( CompoundStmt *compoundStmt ) override;
     87                        virtual void visit( DeclStmt *stmt ) override;
    8688                  protected:
    8789                        ObjectSet curVars;
     
    103105                }
    104106
    105                 class LabelFinder : public ObjDeclCollector {
     107                class LabelFinder final : public ObjDeclCollector {
    106108                  public:
    107109                        typedef ObjDeclCollector Parent;
     
    117119                        // subclasses are added, there is only one place that the code has to be updated, rather than ensure that
    118120                        // every specialized class knows about every new kind of statement that might be added.
    119                         virtual void visit( CompoundStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
    120                         virtual void visit( ExprStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
    121                         virtual void visit( AsmStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
    122                         virtual void visit( IfStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
    123                         virtual void visit( WhileStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
    124                         virtual void visit( ForStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
    125                         virtual void visit( SwitchStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
    126                         virtual void visit( CaseStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
    127                         virtual void visit( BranchStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
    128                         virtual void visit( ReturnStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
    129                         virtual void visit( TryStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
    130                         virtual void visit( CatchStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
    131                         virtual void visit( FinallyStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
    132                         virtual void visit( NullStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
    133                         virtual void visit( DeclStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
    134                         virtual void visit( ImplicitCtorDtorStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
    135                 };
    136 
    137                 class InsertDtors : public ObjDeclCollector {
     121                        using Parent::visit;
     122                        virtual void visit( CompoundStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
     123                        virtual void visit( ExprStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
     124                        virtual void visit( AsmStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
     125                        virtual void visit( IfStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
     126                        virtual void visit( WhileStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
     127                        virtual void visit( ForStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
     128                        virtual void visit( SwitchStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
     129                        virtual void visit( CaseStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
     130                        virtual void visit( BranchStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
     131                        virtual void visit( ReturnStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
     132                        virtual void visit( TryStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
     133                        virtual void visit( CatchStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
     134                        virtual void visit( FinallyStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
     135                        virtual void visit( NullStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
     136                        virtual void visit( DeclStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
     137                        virtual void visit( ImplicitCtorDtorStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
     138                };
     139
     140                class InsertDtors final : public ObjDeclCollector {
    138141                public:
    139142                        /// insert destructor calls at the appropriate places.  must happen before CtorInit nodes are removed
     
    147150                        InsertDtors( LabelFinder & finder ) : labelVars( finder.vars ) {}
    148151
    149                         virtual void visit( ObjectDecl * objDecl );
    150 
    151                         virtual void visit( CompoundStmt * compoundStmt );
    152                         virtual void visit( ReturnStmt * returnStmt );
    153                         virtual void visit( BranchStmt * stmt );
     152                        using Parent::visit;
     153
     154                        virtual void visit( ObjectDecl * objDecl ) override;
     155
     156                        virtual void visit( CompoundStmt * compoundStmt ) override;
     157                        virtual void visit( ReturnStmt * returnStmt ) override;
     158                        virtual void visit( BranchStmt * stmt ) override;
    154159                private:
    155160                        void handleGoto( BranchStmt * stmt );
     
    159164                };
    160165
    161                 class FixInit : public GenPoly::PolyMutator {
     166                class FixInit final : public GenPoly::PolyMutator {
    162167                  public:
    163168                        /// expand each object declaration to use its constructor after it is declared.
    164169                        static void fixInitializers( std::list< Declaration * > &translationUnit );
    165170
    166                         virtual DeclarationWithType * mutate( ObjectDecl *objDecl );
     171                        using GenPoly::PolyMutator::mutate;
     172                        virtual DeclarationWithType * mutate( ObjectDecl *objDecl ) override;
    167173
    168174                        std::list< Declaration * > staticDtorDecls;
    169175                };
    170176
    171                 class FixCopyCtors : public GenPoly::PolyMutator {
     177                class FixCopyCtors final : public GenPoly::PolyMutator {
    172178                  public:
    173179                        /// expand ImplicitCopyCtorExpr nodes into the temporary declarations, copy constructors, call expression,
     
    175181                        static void fixCopyCtors( std::list< Declaration * > &translationUnit );
    176182
    177                         virtual Expression * mutate( ImplicitCopyCtorExpr * impCpCtorExpr );
    178                 };
    179 
    180                 class GenStructMemberCalls : public SymTab::Indexer {
     183                        using GenPoly::PolyMutator::mutate;
     184                        virtual Expression * mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) override;
     185                };
     186
     187                class GenStructMemberCalls final : public SymTab::Indexer {
    181188                  public:
    182189                        typedef Indexer Parent;
     
    186193                        static void generate( std::list< Declaration * > & translationUnit );
    187194
    188                         virtual void visit( FunctionDecl * funcDecl );
    189 
    190                         virtual void visit( MemberExpr * memberExpr );
    191                         virtual void visit( ApplicationExpr * appExpr );
     195                        using Parent::visit;
     196
     197                        virtual void visit( FunctionDecl * funcDecl ) override;
     198
     199                        virtual void visit( MemberExpr * memberExpr ) override;
     200                        virtual void visit( ApplicationExpr * appExpr ) override;
    192201
    193202                        SemanticError errors;
     
    207216                // resolve UntypedExprs that are found within newly
    208217                // generated constructor/destructor calls
    209                 class MutatingResolver : public Mutator {
     218                class MutatingResolver final : public Mutator {
    210219                  public:
    211220                        MutatingResolver( SymTab::Indexer & indexer ) : indexer( indexer ) {}
    212221
    213                         virtual DeclarationWithType* mutate( ObjectDecl *objectDecl );
    214 
    215                         virtual Expression* mutate( UntypedExpr *untypedExpr );
    216                         private:
     222                        using Mutator::mutate;
     223                        virtual DeclarationWithType* mutate( ObjectDecl *objectDecl ) override;
     224                        virtual Expression* mutate( UntypedExpr *untypedExpr ) override;
     225
     226                  private:
    217227                        SymTab::Indexer & indexer;
    218228                };
    219229
    220                 class FixCtorExprs : public GenPoly::DeclMutator {
     230                class FixCtorExprs final : public GenPoly::DeclMutator {
    221231                  public:
    222232                        /// expands ConstructorExpr nodes into comma expressions, using a temporary for the first argument
    223233                        static void fix( std::list< Declaration * > & translationUnit );
    224234
    225                         virtual Expression * mutate( ConstructorExpr * ctorExpr );
     235                        using GenPoly::DeclMutator::mutate;
     236                        virtual Expression * mutate( ConstructorExpr * ctorExpr ) override;
    226237                };
    227238        } // namespace
  • src/InitTweak/GenInit.cc

    rd93d980 r62e5546  
    3636        }
    3737
    38         class ReturnFixer : public GenPoly::PolyMutator {
     38        class ReturnFixer final : public GenPoly::PolyMutator {
    3939          public:
    4040                /// consistently allocates a temporary variable for the return value
     
    4545                ReturnFixer();
    4646
    47                 virtual DeclarationWithType * mutate( FunctionDecl *functionDecl );
    48 
    49                 virtual Statement * mutate( ReturnStmt * returnStmt );
     47                using GenPoly::PolyMutator::mutate;
     48                virtual DeclarationWithType * mutate( FunctionDecl *functionDecl ) override;
     49                virtual Statement * mutate( ReturnStmt * returnStmt ) override;
    5050
    5151          protected:
     
    5555        };
    5656
    57         class CtorDtor : public GenPoly::PolyMutator {
     57        class CtorDtor final : public GenPoly::PolyMutator {
    5858          public:
    5959                typedef GenPoly::PolyMutator Parent;
     
    6565                static void generateCtorDtor( std::list< Declaration * > &translationUnit );
    6666
    67                 virtual DeclarationWithType * mutate( ObjectDecl * );
    68                 virtual DeclarationWithType * mutate( FunctionDecl *functionDecl );
     67                virtual DeclarationWithType * mutate( ObjectDecl * ) override;
     68                virtual DeclarationWithType * mutate( FunctionDecl *functionDecl ) override;
    6969                // should not traverse into any of these declarations to find objects
    7070                // that need to be constructed or destructed
    71                 virtual Declaration* mutate( StructDecl *aggregateDecl );
    72                 virtual Declaration* mutate( UnionDecl *aggregateDecl ) { return aggregateDecl; }
    73                 virtual Declaration* mutate( EnumDecl *aggregateDecl ) { return aggregateDecl; }
    74                 virtual Declaration* mutate( TraitDecl *aggregateDecl ) { return aggregateDecl; }
    75                 virtual TypeDecl* mutate( TypeDecl *typeDecl ) { return typeDecl; }
    76                 virtual Declaration* mutate( TypedefDecl *typeDecl ) { return typeDecl; }
    77 
    78                 virtual Type * mutate( FunctionType *funcType ) { return funcType; }
    79 
    80                 virtual CompoundStmt * mutate( CompoundStmt * compoundStmt );
     71                virtual Declaration* mutate( StructDecl *aggregateDecl ) override;
     72                virtual Declaration* mutate( UnionDecl *aggregateDecl ) override { return aggregateDecl; }
     73                virtual Declaration* mutate( EnumDecl *aggregateDecl ) override { return aggregateDecl; }
     74                virtual Declaration* mutate( TraitDecl *aggregateDecl ) override { return aggregateDecl; }
     75                virtual TypeDecl* mutate( TypeDecl *typeDecl ) override { return typeDecl; }
     76                virtual Declaration* mutate( TypedefDecl *typeDecl ) override { return typeDecl; }
     77
     78                virtual Type * mutate( FunctionType *funcType ) override { return funcType; }
     79
     80                virtual CompoundStmt * mutate( CompoundStmt * compoundStmt ) override;
    8181
    8282          private:
     
    9191        };
    9292
    93         class HoistArrayDimension : public GenPoly::DeclMutator {
     93        class HoistArrayDimension final : public GenPoly::DeclMutator {
    9494          public:
    9595                typedef GenPoly::DeclMutator Parent;
     
    101101
    102102          private:
    103                 virtual DeclarationWithType * mutate( ObjectDecl * objectDecl );
    104                 virtual DeclarationWithType * mutate( FunctionDecl *functionDecl );
     103                using Parent::mutate;
     104
     105                virtual DeclarationWithType * mutate( ObjectDecl * objectDecl ) override;
     106                virtual DeclarationWithType * mutate( FunctionDecl *functionDecl ) override;
    105107                // should not traverse into any of these declarations to find objects
    106108                // that need to be constructed or destructed
    107                 virtual Declaration* mutate( StructDecl *aggregateDecl ) { return aggregateDecl; }
    108                 virtual Declaration* mutate( UnionDecl *aggregateDecl ) { return aggregateDecl; }
    109                 virtual Declaration* mutate( EnumDecl *aggregateDecl ) { return aggregateDecl; }
    110                 virtual Declaration* mutate( TraitDecl *aggregateDecl ) { return aggregateDecl; }
    111                 virtual TypeDecl* mutate( TypeDecl *typeDecl ) { return typeDecl; }
    112                 virtual Declaration* mutate( TypedefDecl *typeDecl ) { return typeDecl; }
    113 
    114                 virtual Type* mutate( FunctionType *funcType ) { return funcType; }
     109                virtual Declaration* mutate( StructDecl *aggregateDecl ) override { return aggregateDecl; }
     110                virtual Declaration* mutate( UnionDecl *aggregateDecl ) override { return aggregateDecl; }
     111                virtual Declaration* mutate( EnumDecl *aggregateDecl ) override { return aggregateDecl; }
     112                virtual Declaration* mutate( TraitDecl *aggregateDecl ) override { return aggregateDecl; }
     113                virtual TypeDecl* mutate( TypeDecl *typeDecl ) override { return typeDecl; }
     114                virtual Declaration* mutate( TypedefDecl *typeDecl ) override { return typeDecl; }
     115
     116                virtual Type* mutate( FunctionType *funcType ) override { return funcType; }
    115117
    116118                void hoist( Type * type );
  • src/InitTweak/InitTweak.h

    rd93d980 r62e5546  
    100100
    101101                class ExpanderImpl;
     102                typedef std::list< Expression * > IndexList;
    102103        private:
    103104                std::shared_ptr< ExpanderImpl > expander;
     
    105106
    106107                // invariant: list of size 2N (elements come in pairs [index, dimension])
    107                 typedef std::list< Expression * > IndexList;
    108108                IndexList indices;
    109109        };
  • src/Parser/ParseNode.h

    rd93d980 r62e5546  
    109109        ExpressionNode * set_extension( bool exten ) { extension = exten; return this; }
    110110
    111         void print( std::ostream &os, int indent = 0 ) const {}
     111        virtual void print( std::ostream &os, int indent = 0 ) const override {}
    112112        void printOneLine( std::ostream &os, int indent = 0 ) const {}
    113113
     
    187187//##############################################################################
    188188
    189 class TypeData;
     189struct TypeData;
    190190
    191191class DeclarationNode : public ParseNode {
     
    271271        }
    272272
    273         void print( std::ostream &os, int indent = 0 ) const;
    274         void printList( std::ostream &os, int indent = 0 ) const;
     273        virtual void print( std::ostream &os, int indent = 0 ) const override;
     274        virtual void printList( std::ostream &os, int indent = 0 ) const override;
    275275
    276276        Declaration * build() const;
     
    345345        virtual StatementNode * append_last_case( StatementNode * );
    346346
    347         virtual void print( std::ostream &os, int indent = 0 ) {}
    348         virtual void printList( std::ostream &os, int indent = 0 ) {}
     347        virtual void print( std::ostream &os, int indent = 0 ) const override {}
     348        virtual void printList( std::ostream &os, int indent = 0 ) const override {}
    349349  private:
    350350        std::unique_ptr<Statement> stmt;
  • src/ResolvExpr/AlternativePrinter.h

    rd93d980 r62e5546  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // AlternativePrinter.h -- 
     7// AlternativePrinter.h --
    88//
    99// Author           : Richard C. Bilson
     
    2323
    2424namespace ResolvExpr {
    25         class AlternativePrinter : public SymTab::Indexer {
     25        class AlternativePrinter final : public SymTab::Indexer {
    2626          public:
    2727                AlternativePrinter( std::ostream &os );
    28                 virtual void visit( ExprStmt *exprStmt );
     28
     29                using SymTab::Indexer::visit;
     30                virtual void visit( ExprStmt *exprStmt ) override;
    2931          private:
    3032                std::ostream &os;
  • src/ResolvExpr/Resolver.cc

    rd93d980 r62e5546  
    3232
    3333namespace ResolvExpr {
    34         class Resolver : public SymTab::Indexer {
     34        class Resolver final : public SymTab::Indexer {
    3535          public:
    36                 Resolver() : SymTab::Indexer( false ), switchType( 0 ) {}
    37 
    38                 virtual void visit( FunctionDecl *functionDecl );
    39                 virtual void visit( ObjectDecl *functionDecl );
    40                 virtual void visit( TypeDecl *typeDecl );
    41                 virtual void visit( EnumDecl * enumDecl );
    42 
    43                 virtual void visit( ArrayType * at );
    44                 virtual void visit( PointerType * at );
    45 
    46                 virtual void visit( ExprStmt *exprStmt );
    47                 virtual void visit( AsmExpr *asmExpr );
    48                 virtual void visit( AsmStmt *asmStmt );
    49                 virtual void visit( IfStmt *ifStmt );
    50                 virtual void visit( WhileStmt *whileStmt );
    51                 virtual void visit( ForStmt *forStmt );
    52                 virtual void visit( SwitchStmt *switchStmt );
    53                 virtual void visit( CaseStmt *caseStmt );
    54                 virtual void visit( BranchStmt *branchStmt );
    55                 virtual void visit( ReturnStmt *returnStmt );
    56 
    57                 virtual void visit( SingleInit *singleInit );
    58                 virtual void visit( ListInit *listInit );
    59                 virtual void visit( ConstructorInit *ctorInit );
     36                Resolver() : SymTab::Indexer( false ) {}
     37
     38                using SymTab::Indexer::visit;
     39                virtual void visit( FunctionDecl *functionDecl ) override;
     40                virtual void visit( ObjectDecl *functionDecl ) override;
     41                virtual void visit( TypeDecl *typeDecl ) override;
     42                virtual void visit( EnumDecl * enumDecl ) override;
     43
     44                virtual void visit( ArrayType * at ) override;
     45                virtual void visit( PointerType * at ) override;
     46
     47                virtual void visit( ExprStmt *exprStmt ) override;
     48                virtual void visit( AsmExpr *asmExpr ) override;
     49                virtual void visit( AsmStmt *asmStmt ) override;
     50                virtual void visit( IfStmt *ifStmt ) override;
     51                virtual void visit( WhileStmt *whileStmt ) override;
     52                virtual void visit( ForStmt *forStmt ) override;
     53                virtual void visit( SwitchStmt *switchStmt ) override;
     54                virtual void visit( CaseStmt *caseStmt ) override;
     55                virtual void visit( BranchStmt *branchStmt ) override;
     56                virtual void visit( ReturnStmt *returnStmt ) override;
     57
     58                virtual void visit( SingleInit *singleInit ) override;
     59                virtual void visit( ListInit *listInit ) override;
     60                virtual void visit( ConstructorInit *ctorInit ) override;
    6061          private:
    6162        typedef std::list< Initializer * >::iterator InitIterator;
     
    6970                std::list< Type * > functionReturn;
    7071                Type *initContext;
    71                 Type *switchType;
    7272                bool inEnumDecl = false;
    7373        };
  • src/ResolvExpr/TypeMap.h

    rd93d980 r62e5546  
    3838                typedef typename std::map< std::string, Value* > ValueMap;
    3939                typedef typename ValueMap::iterator ValueMapIterator;
    40                
     40
    4141                Value *voidValue;                                     ///< Value for void type
    4242                Value *basicValue[BasicType::NUMBER_OF_BASIC_TYPES];  ///< Values for basic types
     
    5454                        /// One scope of map rollbacks
    5555                        typedef std::vector< std::pair< ValueMapIterator, Value* > > MapScope;
    56                        
     56
    5757                        PointerScope pointers;  ///< Value pointers to roll back to their previous state
    5858                        MapScope mapNodes;      ///< Value map iterators to roll back to their previous state
     
    6868
    6969                std::vector< Rollback > scopes;  ///< Scope rollback information
    70                
     70
    7171                struct Lookup : public Visitor {
    7272                        Lookup( TypeMap<Value> &typeMap ) : typeMap( typeMap ), found( 0 ), toInsert( 0 ) {}
     
    8787                                return found;
    8888                        }
    89                        
     89
    9090                        void findAndReplace( Value *&loc ) {
    9191                                found = loc;
     
    109109                                }
    110110                        }
    111                        
     111
    112112                        virtual void visit( VoidType *voidType ) {
    113113                                findAndReplace( typeMap.voidValue );
    114114                        }
    115                        
     115
    116116                        virtual void visit( BasicType *basicType ) {
    117117                                findAndReplace( typeMap.basicValue[basicType->get_kind()] );
    118118                        }
    119                        
     119
    120120                        virtual void visit( PointerType *pointerType ) {
    121121                                // NOTE This is one of the places where the apporoximation of the resolver is (deliberately) poor;
     
    129129                                }
    130130                        }
    131                        
     131
    132132                        virtual void visit( ArrayType *arrayType ) {
    133133                                if ( dynamic_cast< FunctionType* >( arrayType->get_base() ) ) {
     
    137137                                }
    138138                        }
    139                        
     139
    140140                        virtual void visit( FunctionType *functionType ) {
    141141                                findAndReplace( typeMap.functionPointerValue );
    142142                        }
    143                        
     143
    144144                        virtual void visit( StructInstType *structType ) {
    145145                                findAndReplace( typeMap.structValue, structType->get_name() );
    146146                        }
    147                        
     147
    148148                        virtual void visit( UnionInstType *unionType ) {
    149149                                findAndReplace( typeMap.unionValue, unionType->get_name() );
    150150                        }
    151                        
     151
    152152                        virtual void visit( EnumInstType *enumType ) {
    153153                                findAndReplace( typeMap.enumValue, enumType->get_name() );
     
    157157                        Value *found;             ///< Value found (NULL if none yet)
    158158                        Value *toInsert;          ///< Value to insert (NULL if a lookup)
    159                 };  // class Lookup
    160                 friend class Lookup;
    161                
     159                };  // struct Lookup
     160                friend struct Lookup;
     161
    162162        public:
    163163                /// Starts a new scope
     
    180180                        scopes.pop_back();
    181181                }
    182                
     182
    183183                TypeMap() : voidValue( 0 ), pointerValue( 0 ), voidPointerValue( 0 ), functionPointerValue( 0 ), structValue(), unionValue(), enumValue(), scopes() {
    184184                        beginScope();
     
    199199                        return searcher.find( key );
    200200                }
    201                
     201
    202202        }; // class TypeMap
    203203
  • src/ResolvExpr/Unify.cc

    rd93d980 r62e5546  
    7373                const OpenVarSet &openVars;
    7474                WidenMode widenMode;
    75                 Type *commonType;
    7675                const SymTab::Indexer &indexer;
    7776        };
  • src/SymTab/Validate.cc

    rd93d980 r62e5546  
    9494
    9595        /// Associates forward declarations of aggregates with their definitions
    96         class Pass2 : public Indexer {
     96        class Pass2 final : public Indexer {
    9797                typedef Indexer Parent;
    9898          public:
    9999                Pass2( bool doDebug, const Indexer *indexer );
    100100          private:
    101                 virtual void visit( StructInstType *structInst );
    102                 virtual void visit( UnionInstType *unionInst );
    103                 virtual void visit( TraitInstType *contextInst );
    104                 virtual void visit( StructDecl *structDecl );
    105                 virtual void visit( UnionDecl *unionDecl );
    106                 virtual void visit( TypeInstType *typeInst );
     101                using Indexer::visit;
     102                void visit( StructInstType *structInst ) final;
     103                void visit( UnionInstType *unionInst ) final;
     104                void visit( TraitInstType *contextInst ) final;
     105                void visit( StructDecl *structDecl ) final;
     106                void visit( UnionDecl *unionDecl ) final;
     107                void visit( TypeInstType *typeInst ) final;
    107108
    108109                const Indexer *indexer;
     
    182183        };
    183184
    184         class CompoundLiteral : public GenPoly::DeclMutator {
     185        class CompoundLiteral final : public GenPoly::DeclMutator {
    185186                DeclarationNode::StorageClass storageclass = DeclarationNode::NoStorageClass;
    186187
    187                 virtual DeclarationWithType * mutate( ObjectDecl *objectDecl );
    188                 virtual Expression *mutate( CompoundLiteralExpr *compLitExpr );
     188                using GenPoly::DeclMutator::mutate;
     189                DeclarationWithType * mutate( ObjectDecl *objectDecl ) final;
     190                Expression *mutate( CompoundLiteralExpr *compLitExpr ) final;
    189191        };
    190192
     
    652654        void EliminateTypedef::addImplicitTypedef( AggDecl * aggDecl ) {
    653655                if ( typedefNames.count( aggDecl->get_name() ) == 0 ) {
    654                         Type *type;
     656                        Type *type = nullptr;
    655657                        if ( StructDecl * newDeclStructDecl = dynamic_cast< StructDecl * >( aggDecl ) ) {
    656658                                type = new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() );
  • src/Tuples/TupleAssignment.cc

    rd93d980 r62e5546  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // TupleAssignment.cc -- 
     7// TupleAssignment.cc --
    88//
    99// Author           : Rodolfo G. Esteves
     
    2929
    3030namespace Tuples {
    31         TupleAssignSpotter::TupleAssignSpotter( ResolvExpr::AlternativeFinder *f = 0 )
     31        TupleAssignSpotter::TupleAssignSpotter( ResolvExpr::AlternativeFinder *f )
    3232                : currentFinder(f), matcher(0), hasMatched( false ) {}
    3333
  • src/Tuples/TupleAssignment.h

    rd93d980 r62e5546  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // TupleAssignment.h -- 
     7// TupleAssignment.h --
    88//
    99// Author           : Rodolfo G. Esteves
     
    2929          public:
    3030                // dispatcher for Tuple (multiple and mass) assignment operations
    31                 TupleAssignSpotter( ResolvExpr::AlternativeFinder * );
     31                TupleAssignSpotter( ResolvExpr::AlternativeFinder * = 0 );
    3232                ~TupleAssignSpotter() { delete matcher; matcher = 0; }
    3333
     
    9797                ResolvExpr::AlternativeFinder *currentFinder;
    9898                //std::list<Expression *> rhs, lhs;
    99                 Expression *rhs, *lhs;
     99                // Expression *rhs, *lhs;
    100100                Matcher *matcher;
    101101                bool hasMatched;
Note: See TracChangeset for help on using the changeset viewer.