Changes in / [fba44f8:90e2334]

Location:

src

Files:

• Common/utility.h (modified) (1 diff)
• InitTweak/FixInit.cc (modified) (13 diffs)
• Parser/ParseNode.cc (modified) (3 diffs)
• Parser/ParseNode.h (modified) (1 diff)
• SymTab/Autogen.h (modified) (1 diff)
• SynTree/Declaration.cc (modified) (1 diff)
• SynTree/Declaration.h (modified) (1 diff)
• SynTree/Expression.cc (modified) (2 diffs)
• SynTree/Expression.h (modified) (1 diff)
• SynTree/Statement.cc (modified) (1 diff)
• SynTree/Statement.h (modified) (2 diffs)
• SynTree/Type.cc (modified) (1 diff)
• SynTree/Type.h (modified) (1 diff)

src/Common/utility.h

@@ -246 +246 @@
 }
 
-// RAII object to regulate "save and restore" behaviour, e.g.
-// void Foo::bar() {
-//   ValueGuard<int> guard(var); // var is a member of type Foo
-//   var = ...;
-// } // var's original value is restored
-template< typename T >
-struct ValueGuard {
-        T old;
-        T& ref;
-
-        ValueGuard(T& inRef) : old(inRef), ref(inRef) {}
-        ~ValueGuard() { ref = old; }
-};
-
 #endif // _UTILITY_H
 

src/InitTweak/FixInit.cc

@@ -31 +31 @@
 #include "SynTree/Mutator.h"
 #include "SymTab/Indexer.h"
-#include "SymTab/Autogen.h"
 #include "GenPoly/PolyMutator.h"
 #include "SynTree/AddStmtVisitor.h"
@@ -177 +176 @@
                 };
 
-                class GenStructMemberCalls : public SymTab::Indexer {
+                class WarnStructMembers : public Visitor {
                   public:
-                        typedef Indexer Parent;
-                        /// generate default/copy ctor and dtor calls for user-defined struct ctor/dtors
-                        /// for any member that is missing a corresponding ctor/dtor call.
-                        /// error if a member is used before constructed
-                        static void generate( std::list< Declaration * > & translationUnit );
+                        typedef Visitor Parent;
+                        /// warn if a user-defined constructor or destructor is missing calls for
+                        /// a struct member or if a member is used before constructed
+                        static void warnings( std::list< Declaration * > & translationUnit );
 
                         virtual void visit( FunctionDecl * funcDecl );
@@ -197 +195 @@
 
                         FunctionDecl * function = 0;
-                        std::set< DeclarationWithType * > unhandled, usedUninit;
+                        std::set< DeclarationWithType * > unhandled;
                         ObjectDecl * thisParam = 0;
-                        bool isCtor = false; // true if current function is a constructor
-                };
-
-                // very simple resolver-like mutator class - used to
-                // resolve UntypedExprs that are found within newly
-                // generated constructor/destructor calls
-                class MutatingResolver : public Mutator {
-                  public:
-                        MutatingResolver( SymTab::Indexer & indexer ) : indexer( indexer ) {}
-
-                        virtual DeclarationWithType* mutate( ObjectDecl *objectDecl );
-
-                        virtual Expression* mutate( UntypedExpr *untypedExpr );
-                        private:
-                        SymTab::Indexer & indexer;
                 };
         } // namespace
@@ -229 +212 @@
                 FixCopyCtors::fixCopyCtors( translationUnit );
 
-                GenStructMemberCalls::generate( translationUnit );
+                WarnStructMembers::warnings( translationUnit );
         }
 
@@ -274 +257 @@
                 }
 
-                void GenStructMemberCalls::generate( std::list< Declaration * > & translationUnit ) {
-                        GenStructMemberCalls warner;
-                        acceptAll( translationUnit, warner );
-
-                        // visitor doesn't throw so that it can collect all errors
-                        if ( ! warner.errors.isEmpty() ) {
-                                throw warner.errors;
+                void WarnStructMembers::warnings( std::list< Declaration * > & translationUnit ) {
+                        if ( true ) { // fix this condition to skip this pass if warnings aren't enabled
+                                WarnStructMembers warner;
+                                acceptAll( translationUnit, warner );
+
+                                // visitor doesn't throw so that it can collect all errors
+                                if ( ! warner.errors.isEmpty() ) {
+                                        throw warner.errors;
+                                }
                         }
                 }
@@ -551 +536 @@
                                                         FunctionDecl * dtorCaller = new FunctionDecl( objDecl->get_mangleName() + dtorCallerNamer.newName(), DeclarationNode::Static, LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ), false, false );
                                                         dtorCaller->fixUniqueId();
-                                                        dtorCaller->get_statements()->push_back( dtorStmt );
+                                                        dtorCaller->get_statements()->get_kids().push_back( dtorStmt );
 
                                                         // atexit(dtor_atexit);
@@ -566 +551 @@
                                                         // at global scope and there could be multiple function-scoped
                                                         // static variables with the same name in different functions.
-                                                        // Note: it isn't sufficient to modify only the mangleName, because
-                                                        // then subsequent Indexer passes can choke on seeing the object's name
-                                                        // if another object has the same name and type. An unfortunate side-effect
-                                                        // of renaming the object is that subsequent NameExprs may fail to resolve,
-                                                        // but there shouldn't be any remaining past this point.
                                                         static UniqueName staticNamer( "_static_var" );
-                                                        objDecl->set_name( objDecl->get_name() + staticNamer.newName() );
-                                                        objDecl->set_mangleName( SymTab::Mangler::mangle( objDecl ) );
+                                                        objDecl->set_mangleName( objDecl->get_mangleName() + staticNamer.newName() );
 
                                                         objDecl->set_init( NULL );
@@ -738 +717 @@
                 }
 
-                void GenStructMemberCalls::visit( FunctionDecl * funcDecl ) {
-                        ValueGuard< FunctionDecl * > oldFunction( funcDecl );
-                        ValueGuard< std::set< DeclarationWithType * > > oldUnhandled( unhandled );
-                        ValueGuard< std::set< DeclarationWithType * > > oldUsedUninit( usedUninit );
-                        ValueGuard< ObjectDecl * > oldThisParam( thisParam );
-                        ValueGuard< bool > oldIsCtor( isCtor );
-
-                        // need to start with fresh sets
-                        unhandled.clear();
-                        usedUninit.clear();
+                void WarnStructMembers::visit( FunctionDecl * funcDecl ) {
+                        WarnStructMembers old = *this;
+                        *this = WarnStructMembers();
 
                         function = funcDecl;
-                        isCtor = isConstructor( function->get_name() );
-                        if ( checkWarnings( function ) ) {
-                                FunctionType * type = function->get_functionType();
+                        if ( checkWarnings( funcDecl ) ) {
+                                FunctionType * type = funcDecl->get_functionType();
                                 assert( ! type->get_parameters().empty() );
                                 thisParam = safe_dynamic_cast< ObjectDecl * >( type->get_parameters().front() );
@@ -768 +739 @@
                                 }
                         }
-                        Parent::visit( function );
-
-                        // remove the unhandled objects from usedUninit, because a call is inserted
-                        // to handle them - only objects that are later constructed are used uninitialized.
-                        std::set< DeclarationWithType * > diff;
-                        std::set_difference( usedUninit.begin(), usedUninit.end(), unhandled.begin(), unhandled.end(), std::inserter( diff, diff.begin() ) );
-                        for ( DeclarationWithType * member : diff ) {
-                                emit( "in ", CodeGen::genType( function->get_functionType(), function->get_name(), false ), ", member ", member->get_name(), " used before being constructed" );
+                        Parent::visit( funcDecl );
+
+                        for ( DeclarationWithType * member : unhandled ) {
+                                // emit a warning for each unhandled member
+                                emit( "in ", CodeGen::genType( function->get_functionType(), function->get_name(), false ), ", member ", member->get_name(), " may not have been ", isConstructor( funcDecl->get_name() ) ? "constructed" : "destructed" );
                         }
 
-                        if ( ! unhandled.empty() ) {
-                                // need to explicitly re-add function parameters in order to resolve copy constructors
-                                enterScope();
-                                // maybeAccept( function->get_functionType(), *this );
-                                for ( DeclarationWithType * member : unhandled ) {
-                                        // insert and resolve default/copy constructor call for each member that's unhandled
-                                        std::list< Statement * > stmt;
-                                        UntypedExpr * deref = new UntypedExpr( new NameExpr( "*?" ) );
-                                        deref->get_args().push_back( new VariableExpr( thisParam ) );
-                                        InitExpander srcParam( (Initializer *)NULL ); // xxx - if copy ctor, need to pass appropriate argument - second param of this function dot member
-                                        SymTab::genImplicitCall( srcParam, new MemberExpr( member, deref ), function->get_name(), back_inserter( stmt ), member, isCtor );
-
-                                        assert( stmt.size() <= 1 );
-                                        if ( stmt.size() == 1 ) {
-                                                Statement * callStmt = stmt.front();
-
-                                                MutatingResolver resolver( *this );
-                                                try {
-                                                        // xxx - these should be in field declaration order
-                                                        callStmt->acceptMutator( resolver );
-                                                        if ( isCtor ) {
-                                                                function->get_statements()->push_front( callStmt );
-                                                        } else {
-                                                                // destructor statements should be added at the end
-                                                                function->get_statements()->push_back( callStmt );
-                                                        }
-                                                } catch ( SemanticError & error ) {
-                                                        emit( "in ", CodeGen::genType( function->get_functionType(), function->get_name(), false ), ", member ", member->get_name(), " not explicitly ", isCtor ? "constructed" : "destructed",  " and no ", isCtor ? "default constructor" : "destructor", " found" );
-                                                }
-                                        }
-                                }
-                                leaveScope();
-                        }
-                }
-
-                void GenStructMemberCalls::visit( ApplicationExpr * appExpr ) {
+                        // need to steal the errors before they're lost
+                        old.errors.append( errors );
+                        *this = old;
+                }
+
+                void WarnStructMembers::visit( ApplicationExpr * appExpr ) {
                         if ( ! checkWarnings( function ) ) return;
 
@@ -842 +780 @@
                 }
 
-                void GenStructMemberCalls::handleFirstParam( Expression * firstParam ) {
+                void WarnStructMembers::handleFirstParam( Expression * firstParam ) {
                         using namespace std;
                         if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( firstParam ) ) {
@@ -859 +797 @@
                 }
 
-                void GenStructMemberCalls::visit( MemberExpr * memberExpr ) {
+                void WarnStructMembers::visit( MemberExpr * memberExpr ) {
                         if ( ! checkWarnings( function ) ) return;
-                        if ( ! isCtor ) return;
+                        if ( ! isConstructor( function->get_name() ) ) return;
 
                         if ( ApplicationExpr * deref = dynamic_cast< ApplicationExpr * >( memberExpr->get_aggregate() ) ) {
@@ -869 +807 @@
                                                         if ( unhandled.count( memberExpr->get_member() ) ) {
                                                                 // emit a warning because a member was used before it was constructed
-                                                                usedUninit.insert( memberExpr->get_member() );
+                                                                emit( "in ", CodeGen::genType( function->get_functionType(), function->get_name(), false ), ", member ", memberExpr->get_member()->get_name(), " used before being constructed" );
                                                         }
                                                 }
@@ -884 +822 @@
 
                 template< typename... Params >
-                void GenStructMemberCalls::emit( const Params &... params ) {
+                void WarnStructMembers::emit( const Params &... params ) {
                         // toggle warnings vs. errors here.
                         // warn( params... );
                         error( *this, params... );
-                }
-
-                DeclarationWithType * MutatingResolver::mutate( ObjectDecl *objectDecl ) {
-                        // add object to the indexer assumes that there will be no name collisions
-                        // in generated code. If this changes, add mutate methods for entities with
-                        // scope and call {enter,leave}Scope explicitly.
-                        objectDecl->accept( indexer );
-                        return objectDecl;
-                }
-
-                Expression* MutatingResolver::mutate( UntypedExpr *untypedExpr ) {
-                        return safe_dynamic_cast< ApplicationExpr * >( ResolvExpr::findVoidExpression( untypedExpr, indexer ) );
                 }
         } // namespace

src/Parser/ParseNode.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// ParseNode.cc --
+// ParseNode.cc -- 
 //
 // Author           : Rodolfo G. Esteves
@@ -12 +12 @@
 // Last Modified On : Wed Aug 17 23:14:16 2016
 // Update Count     : 126
-//
+// 
 
 #include "ParseNode.h"
@@ -19 +19 @@
 int ParseNode::indent_by = 4;
 
-std::ostream & operator<<( std::ostream & out, const ParseNode * node ) {
-  node->print( out );
-  return out;
-}
-
 // Local Variables: //
 // tab-width: 4 //

src/Parser/ParseNode.h

@@ -409 +409 @@
 }
 
-// in ParseNode.cc
-std::ostream & operator<<( std::ostream & out, const ParseNode * node );
 
 #endif // PARSENODE_H

src/SymTab/Autogen.h

@@ -102 +102 @@
                 }
 
-                ObjectDecl *index = new ObjectDecl( indexName.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin, std::list<Expression*>() ) );
+                ObjectDecl *index = new ObjectDecl( indexName.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), NULL );
+
+                UntypedExpr *init = new UntypedExpr( new NameExpr( "?=?" ) );
+                init->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) );
+                init->get_args().push_back( begin );
+                index->set_init( new SingleInit( init, std::list<Expression*>() ) );
 
                 UntypedExpr *cond = new UntypedExpr( cmp );

src/SynTree/Declaration.cc

@@ -56 +56 @@
 }
 
-std::ostream & operator<<( std::ostream & out, const Declaration * decl ) {
+std::ostream & operator<<( std::ostream & out, Declaration * decl ) {
         decl->print( out );
         return out;

src/SynTree/Declaration.h

@@ -279 +279 @@
 };
 
-std::ostream & operator<<( std::ostream & out, const Declaration * decl );
+std::ostream & operator<<( std::ostream & out, Declaration * decl );
 
 #endif // DECLARATION_H

src/SynTree/Expression.cc

@@ -358 +358 @@
         assert( member );
         os << std::string( indent + 2, ' ' );
+        os << (void*)member << " ";
         member->print( os, indent + 2 );
         os << std::endl;
@@ -540 +541 @@
 }
 
-std::ostream & operator<<( std::ostream & out, const Expression * expr ) {
+std::ostream & operator<<( std::ostream & out, Expression * expr ) {
         expr->print( out );
         return out;

src/SynTree/Expression.h

@@ -653 +653 @@
 };
 
-std::ostream & operator<<( std::ostream & out, const Expression * expr );
+std::ostream & operator<<( std::ostream & out, Expression * expr );
 
 #endif // EXPRESSION_H

src/SynTree/Statement.cc

@@ -387 +387 @@
 }
 
-std::ostream & operator<<( std::ostream & out, const Statement * statement ) {
+std::ostream & operator<<( std::ostream & out, Statement * statement ) {
         statement->print( out );
         return out;

src/SynTree/Statement.h

@@ -47 +47 @@
 
         std::list<Statement*>& get_kids() { return kids; }
-        void push_back( Statement * stmt ) { kids.push_back( stmt ); }
-        void push_front( Statement * stmt ) { kids.push_front( stmt ); }
 
         virtual CompoundStmt *clone() const { return new CompoundStmt( *this ); }
@@ -397 +395 @@
 
 
-std::ostream & operator<<( std::ostream & out, const Statement * statement );
+std::ostream & operator<<( std::ostream & out, Statement * statement );
 
 #endif // STATEMENT_H

src/SynTree/Type.cc

@@ -84 +84 @@
 }
 
-std::ostream & operator<<( std::ostream & out, const Type * type ) {
+std::ostream & operator<<( std::ostream & out, Type * type ) {
         type->print( out );
         return out;

src/SynTree/Type.h

@@ -481 +481 @@
 }
 
-std::ostream & operator<<( std::ostream & out, const Type * type );
+std::ostream & operator<<( std::ostream & out, Type * type );
 
 #endif // TYPE_H