Changes in / [8abfdb4:ac78e25]

Location:

src

Files:

• ArgTweak/FunctionFixer.cc (modified) (2 diffs)
• CodeGen/CodeGenerator.cc (modified) (9 diffs)
• CodeGen/CodeGenerator.h (modified) (5 diffs)
• GenPoly/Box.cc (modified) (1 diff)
• GenPoly/Specialize.cc (modified) (2 diffs)
• InitTweak/FixGlobalInit.cc (modified) (4 diffs)
• InitTweak/FixInit.cc (modified) (1 diff)
• InitTweak/GenInit.cc (modified) (2 diffs)
• InitTweak/InitTweak.cc (modified) (1 diff)
• InitTweak/InitTweak.h (modified) (1 diff)
• Makefile.in (modified) (6 diffs)
• ResolvExpr/AlternativeFinder.cc (modified) (2 diffs)
• ResolvExpr/CommonType.cc (modified) (3 diffs)
• ResolvExpr/ConversionCost.cc (modified) (2 diffs)
• ResolvExpr/Resolver.cc (modified) (7 diffs)
• SymTab/Autogen.cc (modified) (2 diffs)
• SymTab/Validate.cc (modified) (1 diff)
• SynTree/Attribute.cc (deleted)
• SynTree/Attribute.h (deleted)
• SynTree/Declaration.h (modified) (3 diffs)
• SynTree/FunctionDecl.cc (modified) (5 diffs)
• SynTree/Initializer.cc (modified) (4 diffs)
• SynTree/Initializer.h (modified) (6 diffs)
• SynTree/Mutator.cc (modified) (1 diff)
• SynTree/Mutator.h (modified) (1 diff)
• SynTree/Statement.cc (modified) (3 diffs)
• SynTree/Statement.h (modified) (3 diffs)
• SynTree/SynTree.h (modified) (2 diffs)
• SynTree/Type.cc (modified) (3 diffs)
• SynTree/Type.h (modified) (1 diff)
• SynTree/Visitor.cc (modified) (1 diff)
• SynTree/Visitor.h (modified) (1 diff)
• SynTree/module.mk (modified) (2 diffs)
• examples/avltree/avl-private.h (modified) (2 diffs)

src/ArgTweak/FunctionFixer.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// FunctionFixer.cc --
+// FunctionFixer.cc -- 
 //
 // Author           : Rodolfo G. Esteves
@@ -42 +42 @@
         Expression *FunctionFixer::mutate( UntypedExpr *untypedExpr ) throw ( SemanticError ) {
                 assert( untypedExpr != 0 );
+                NameExpr *function;
 
-                if ( NameExpr * function = dynamic_cast< NameExpr *>(untypedExpr->get_function() ) ) {
+                if ( ( function = dynamic_cast< NameExpr *>(untypedExpr->get_function()) ) != 0 ) {
                         std::list < DeclarationWithType * > options;
                         index->lookupId ( function->get_name(), options );
                         for ( std::list < DeclarationWithType * >::iterator i = options.begin(); i != options.end(); i++ ) {
-                                if ( FunctionType * f = dynamic_cast< FunctionType * > ( (*i)->get_type() ) )   {
+                                FunctionType *f;
+                                if ( ( f = dynamic_cast< FunctionType * > ( (*i)->get_type() ) ) != 0 ) {
                                         std::list < DeclarationWithType * > &pars = f->get_parameters();
+
                                         bool candidateExists ;
-                                        for ( std::list < DeclarationWithType * >::iterator p = pars.begin(); p != pars.end(); p++ ) {
+                                        for ( std::list < DeclarationWithType * >::iterator p = pars.begin(); p != pars.end(); p++ )
                                                 if ( ( candidateExists = align( f->get_parameters(), untypedExpr->get_args(), Matcher() ) ) ) break;
-                                        }
+
                                         if ( ! candidateExists ) throw SemanticError("Error in function call");
                                 } // if

src/CodeGen/CodeGenerator.cc

@@ -26 +26 @@
 #include "SynTree/Statement.h"
 #include "SynTree/Type.h"
-#include "SynTree/Attribute.h"
 
 #include "Common/utility.h"
@@ -34 +33 @@
 #include "OperatorTable.h"
 #include "GenType.h"
-
-#include "InitTweak/InitTweak.h"
 
 using namespace std;
@@ -77 +74 @@
         }
 
-        void CodeGenerator::genAttributes( std::list< Attribute * > & attributes ) {
-                if ( ! attributes.empty() ) {
-                        output << "__attribute__ ((";
-                        for ( Attribute *& attr : attributes ) {
-                                if ( ! attr->empty() ) {
-                                        output << attr->get_name() << "(";
-                                        genCommaList( attr->get_parameters().begin(), attr->get_parameters().end() );
-                                        output << ")";
-                                }
-                                output << ",";
-                        }
-                        output << ")) ";
-                }
-        }
-
-
         //*** Declarations
         void CodeGenerator::visit( FunctionDecl *functionDecl ) {
-                genAttributes( functionDecl->get_attributes() );
-
+                // generalize this
+                FunctionDecl::Attribute attr = functionDecl->get_attribute();
+                switch ( attr.type ) {
+                        case FunctionDecl::Attribute::Constructor:
+                                output << "__attribute__ ((constructor";
+                                if ( attr.priority != FunctionDecl::Attribute::Default ) {
+                                        output << "(" << attr.priority << ")";
+                                }
+                                output << ")) ";
+                                break;
+                        case FunctionDecl::Attribute::Destructor:
+                                output << "__attribute__ ((destructor";
+                                if ( attr.priority != FunctionDecl::Attribute::Default ) {
+                                        output << "(" << attr.priority << ")";
+                                }
+                                output << ")) ";
+                                break;
+                        default:
+                                break;
+                }
                 handleStorageClass( functionDecl );
                 if ( functionDecl->get_isInline() ) {
@@ -270 +269 @@
                                                         UntypedExpr *newExpr = new UntypedExpr( new NameExpr( "*?" ) );
                                                         newExpr->get_args().push_back( *arg );
-                                                        assert( (*arg)->get_results().size() == 1 );
-                                                        Type * type = InitTweak::getPointerBase( (*arg)->get_results().front() );
-                                                        assert( type );
-                                                        newExpr->get_results().push_back( type );
                                                         *arg = newExpr;
                                                 } // if
@@ -302 +297 @@
                                         if ( applicationExpr->get_args().size() == 1 ) {
                                                 // the expression fed into a single parameter constructor or destructor
-                                                // may contain side effects, so must still output this expression
-                                                output << "(";
+                                                // may contain side effects - output as a void expression
+                                                output << "((void)(";
                                                 (*arg++)->accept( *this );
-                                                output << ") /* " << opInfo.inputName << " */";
+                                                output << ")) /* " << opInfo.inputName << " */";
                                         } else if ( applicationExpr->get_args().size() == 2 ) {
                                                 // intrinsic two parameter constructors are essentially bitwise assignment
@@ -387 +382 @@
                                         if ( untypedExpr->get_args().size() == 1 ) {
                                                 // the expression fed into a single parameter constructor or destructor
-                                                // may contain side effects, so must still output this expression
-                                                output << "(";
+                                                // may contain side effects - output as a void expression
+                                                output << "((void)(";
                                                 (*arg++)->accept( *this );
-                                                output << ") /* " << opInfo.inputName << " */";
+                                                output << ")) /* " << opInfo.inputName << " */";
                                         } else if ( untypedExpr->get_args().size() == 2 ) {
                                                 // intrinsic two parameter constructors are essentially bitwise assignment
@@ -616 +611 @@
 
         void CodeGenerator::visit( ExprStmt *exprStmt ) {
+                // I don't see why this check is necessary.
+                // If this starts to cause problems then put it back in,
+                // with an explanation
                 assert( exprStmt );
-                // cast the top-level expression to void to reduce gcc warnings.
-                Expression * expr = new CastExpr( exprStmt->get_expr() );
-                expr->accept( *this );
-                output << ";";
+
+                // if ( exprStmt != 0 ) {
+                exprStmt->get_expr()->accept( *this );
+                output << ";" ;
+                // } // if
         }
 
@@ -729 +728 @@
 
         void CodeGenerator::visit( WhileStmt *whileStmt ) {
-                if ( whileStmt->get_isDoWhile() ) {
+                if ( whileStmt->get_isDoWhile() )
                         output << "do" ;
-                } else {
+                else {
                         output << "while (" ;
                         whileStmt->get_condition()->accept( *this );
@@ -755 +754 @@
                 output << "for (;";
 
-                if ( forStmt->get_condition() != 0 ) {
+                if ( forStmt->get_condition() != 0 )
                         forStmt->get_condition()->accept( *this );
-                }
                 output << ";";
 
-                if ( forStmt->get_increment() != 0 ) {
-                        // cast the top-level expression to void to reduce gcc warnings.
-                        Expression * expr = new CastExpr( forStmt->get_increment() );
-                        expr->accept( *this );
-                }
+                if ( forStmt->get_increment() != 0 )
+                        forStmt->get_increment()->accept( *this );
                 output << ") ";
 

src/CodeGen/CodeGenerator.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// CodeGenerator.h --
+// CodeGenerator.h -- 
 //
 // Author           : Richard C. Bilson
@@ -60 +60 @@
                 virtual void visit( MemberExpr *memberExpr );
                 virtual void visit( VariableExpr *variableExpr );
-                virtual void visit( ConstantExpr *constantExpr );
+                virtual void visit( ConstantExpr *constantExpr ); 
                 virtual void visit( SizeofExpr *sizeofExpr );
                 virtual void visit( AlignofExpr *alignofExpr );
@@ -85 +85 @@
                 virtual void visit( ForStmt * );
                 virtual void visit( NullStmt * );
-                virtual void visit( DeclStmt * );
-
-                void genAttributes( std::list< Attribute * > & attributes );
+                virtual void visit( DeclStmt * ); 
 
                 template< class Iterator > void genCommaList( Iterator begin, Iterator end );
@@ -110 +108 @@
 
         };
-
+        
         template< class Iterator >
         void CodeGenerator::genCommaList( Iterator begin, Iterator end ) {
@@ -121 +119 @@
                 } // for
         }
-
+  
         inline bool doSemicolon( Declaration* decl ) {
                 if ( FunctionDecl* func = dynamic_cast< FunctionDecl* >( decl ) ) {

src/GenPoly/Box.cc

@@ -1947 +1947 @@
                                 UntypedExpr *derefExpr = new UntypedExpr( new NameExpr( "*?" ) );
                                 derefExpr->get_args().push_back( derefdVar );
-                                // xxx - should set results on derefExpr
                                 derefdVar = derefExpr;
                         }

src/GenPoly/Specialize.cc

@@ -25 +25 @@
 #include "SynTree/Statement.h"
 #include "SynTree/Type.h"
-#include "SynTree/Attribute.h"
 #include "SynTree/TypeSubstitution.h"
 #include "SynTree/Mutator.h"
@@ -102 +101 @@
                 thunkFunc->fixUniqueId();
 
-                // thunks may be generated and not used - silence warning with attribute
-                thunkFunc->get_attributes().push_back( new Attribute( "unused" ) );
-
                 // thread thunk parameters into call to actual function, naming thunk parameters as we go
                 UniqueName paramNamer( paramPrefix );

src/InitTweak/FixGlobalInit.cc

@@ -22 +22 @@
 #include "SynTree/Initializer.h"
 #include "SynTree/Visitor.h"
-#include "SynTree/Attribute.h"
 #include <algorithm>
 
@@ -117 +116 @@
         GlobalFixer::GlobalFixer( const std::string & name, bool inLibrary ) : tempNamer( "_global_init" ) {
                 std::string fixedName = globalFunctionName( name );
-                std::list< Expression * > ctorParameters;
-                std::list< Expression * > dtorParameters;
-                if ( inLibrary ) {
-                        // Constructor/destructor attributes take a single parameter which
-                        // is the priority, with lower numbers meaning higher priority.
-                        // Functions specified with priority are guaranteed to run before
-                        // functions without a priority. To ensure that constructors and destructors
-                        // for library code are run before constructors and destructors for user code,
-                        // specify a priority when building the library. Priorities 0-100 are reserved by gcc.
-                        ctorParameters.push_back( new ConstantExpr( Constant::from_int( 101 ) ) );
-                        dtorParameters.push_back( new ConstantExpr( Constant::from_int( 101 ) ) );
-                }
-                initFunction = new FunctionDecl( "_init_" + fixedName, DeclarationNode::Static, LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ), false, false );
-                initFunction->get_attributes().push_back( new Attribute( "constructor", ctorParameters ) );
-                destroyFunction = new FunctionDecl( "_destroy_" + fixedName, DeclarationNode::Static, LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ), false, false );
-                destroyFunction->get_attributes().push_back( new Attribute( "destructor", dtorParameters ) );
+                initFunction = new FunctionDecl( "_init_" + fixedName, DeclarationNode::Static, LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ), false, false, FunctionDecl::Attribute( FunctionDecl::Attribute::Constructor, inLibrary ? FunctionDecl::Attribute::High : FunctionDecl::Attribute::Default ) );
+
+                destroyFunction = new FunctionDecl( "_destroy_" + fixedName, DeclarationNode::Static, LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ), false, false, FunctionDecl::Attribute( FunctionDecl::Attribute::Destructor, inLibrary ? FunctionDecl::Attribute::High : FunctionDecl::Attribute::Default ) );
         }
 
@@ -139 +125 @@
                 std::list< Statement * > & destroyStatements = destroyFunction->get_statements()->get_kids();
 
+                // if ( objDecl->get_init() == NULL ) return;
                 if ( ! tryConstruct( objDecl ) ) return; // don't construct @= or designated objects
+                if ( objDecl->get_type()->get_isConst() ) return; // temporary: can't assign to a const variable
                 if ( objDecl->get_storageClass() == DeclarationNode::Extern ) return;
                 // C allows you to initialize objects with constant expressions
@@ -158 +146 @@
                         init->get_args().push_back( new AddressExpr( new VariableExpr( objDecl ) ) );
                         init->get_args().push_back( new VariableExpr( newObj ) );
-                        initStatements.push_back( new ImplicitCtorDtorStmt( new ExprStmt( noLabels, init ) ) );
+                        initStatements.push_back( new ExprStmt( noLabels, init ) );
 
                         // add destructor calls to global destroy function
                         UntypedExpr * destroy = new UntypedExpr( new NameExpr( "^?{}" ) );
                         destroy->get_args().push_back( new AddressExpr( new VariableExpr( objDecl ) ) );
-                        destroyStatements.push_front( new ImplicitCtorDtorStmt( new ExprStmt( noLabels, destroy ) ) );
+                        destroyStatements.push_front( new ExprStmt( noLabels, destroy ) );
                 }
         }

src/InitTweak/FixInit.cc

@@ -132 +132 @@
                                 return appExpr;
                         } else if ( DeclarationWithType * funcDecl = dynamic_cast< DeclarationWithType * > ( function->get_var() ) ) {
+                                // FunctionType * ftype = funcDecl->get_functionType();
                                 FunctionType * ftype = dynamic_cast< FunctionType * >( GenPoly::getFunctionType( funcDecl->get_type() ) );
                                 assert( ftype );

src/InitTweak/GenInit.cc

@@ -164 +164 @@
                                                 assert( ctor.size() == 1 );
                                                 assert( dtor.size() == 1 );
-                                                objDecl->set_init( new ConstructorInit( new ImplicitCtorDtorStmt( ctor.front() ), new ImplicitCtorDtorStmt( dtor.front() ), objDecl->get_init() ) );
+
+                                                objDecl->set_init( new ConstructorInit( ctor.front(), dtor.front(), objDecl->get_init() ) );
                                         } else {
                                                 // array came with an initializer list: initialize each element
@@ -184 +185 @@
                                         ExprStmt * ctorStmt = new ExprStmt( noLabels, ctor );
                                         ExprStmt * dtorStmt = new ExprStmt( noLabels, dtor );
-                                        objDecl->set_init( new ConstructorInit( new ImplicitCtorDtorStmt( ctorStmt ), new ImplicitCtorDtorStmt( dtorStmt ), objDecl->get_init() ) );
+                                        objDecl->set_init( new ConstructorInit( ctorStmt, dtorStmt, objDecl->get_init() ) );
                                 }
                         }

src/InitTweak/InitTweak.cc

@@ -7 +7 @@
 
 namespace InitTweak {
-        namespace {
-                class HasDesignations : public Visitor {
-                public:
-                        bool hasDesignations = false;
-                        template<typename Init>
-                        void handleInit( Init * init ) {
-                                if ( ! init->get_designators().empty() ) hasDesignations = true;
-                                else Visitor::visit( init );
-                        }
-                        virtual void visit( SingleInit * singleInit ) { handleInit( singleInit); }
-                        virtual void visit( ListInit * listInit ) { handleInit( listInit); }
-                };
+  namespace {
+    class HasDesignations : public Visitor {
+    public:
+      bool hasDesignations = false;
+      template<typename Init>
+      void handleInit( Init * init ) {
+        if ( ! init->get_designators().empty() ) hasDesignations = true;
+        else Visitor::visit( init );
+      }
+      virtual void visit( SingleInit * singleInit ) { handleInit( singleInit); }
+      virtual void visit( ListInit * listInit ) { handleInit( listInit); }
+    };
 
-                class InitExpander : public Visitor {
-                        public:
-                        InitExpander() {}
-                        virtual void visit( SingleInit * singleInit );
-                        virtual void visit( ListInit * listInit );
-                        std::list< Expression * > argList;
-                };
+    class InitExpander : public Visitor {
+      public:
+      InitExpander() {}
+      virtual void visit( SingleInit * singleInit );
+      virtual void visit( ListInit * listInit );
+      std::list< Expression * > argList;
+    };
 
-                void InitExpander::visit( SingleInit * singleInit ) {
-                        argList.push_back( singleInit->get_value()->clone() );
-                }
+    void InitExpander::visit( SingleInit * singleInit ) {
+      argList.push_back( singleInit->get_value()->clone() );
+    }
 
-                void InitExpander::visit( ListInit * listInit ) {
-                        // xxx - for now, assume no nested list inits
-                        std::list<Initializer*>::iterator it = listInit->begin_initializers();
-                        for ( ; it != listInit->end_initializers(); ++it ) {
-                                (*it)->accept( *this );
-                        }
-                }
-        }
+    void InitExpander::visit( ListInit * listInit ) {
+      // xxx - for now, assume no nested list inits
+      std::list<Initializer*>::iterator it = listInit->begin_initializers();
+      for ( ; it != listInit->end_initializers(); ++it ) {
+        (*it)->accept( *this );
+      }
+    }
+  }
 
-        std::list< Expression * > makeInitList( Initializer * init ) {
-                InitExpander expander;
-                maybeAccept( init, expander );
-                return expander.argList;
-        }
+  std::list< Expression * > makeInitList( Initializer * init ) {
+    InitExpander expander;
+    maybeAccept( init, expander );
+    return expander.argList;
+  }
 
-        bool isDesignated( Initializer * init ) {
-                HasDesignations finder;
-                maybeAccept( init, finder );
-                return finder.hasDesignations;
-        }
+  bool isDesignated( Initializer * init ) {
+    HasDesignations finder;
+    maybeAccept( init, finder );
+    return finder.hasDesignations;
+  }
 
-        bool tryConstruct( ObjectDecl * objDecl ) {
-                return ! LinkageSpec::isBuiltin( objDecl->get_linkage() ) &&
-                        (objDecl->get_init() == NULL ||
-                                ( objDecl->get_init() != NULL && objDecl->get_init()->get_maybeConstructed() )) &&
-                        ! isDesignated( objDecl->get_init() );
-        }
+  bool tryConstruct( ObjectDecl * objDecl ) {
+    return ! LinkageSpec::isBuiltin( objDecl->get_linkage() ) &&
+      (objDecl->get_init() == NULL ||
+        ( objDecl->get_init() != NULL && objDecl->get_init()->get_maybeConstructed() )) &&
+      ! isDesignated( objDecl->get_init() );
+  }
 
-        Expression * getCtorDtorCall( Statement * stmt ) {
-                if ( stmt == NULL ) return NULL;
-                if ( ExprStmt * exprStmt = dynamic_cast< ExprStmt * >( stmt ) ) {
-                        return exprStmt->get_expr();
-                } else if ( CompoundStmt * compoundStmt = dynamic_cast< CompoundStmt * >( stmt ) ) {
-                        // could also be a compound statement with a loop, in the case of an array
-                        assert( compoundStmt->get_kids().size() == 2 ); // loop variable and loop
-                        ForStmt * forStmt = dynamic_cast< ForStmt * >( compoundStmt->get_kids().back() );
-                        assert( forStmt && forStmt->get_body() );
-                        return getCtorDtorCall( forStmt->get_body() );
-                } if ( ImplicitCtorDtorStmt * impCtorDtorStmt = dynamic_cast< ImplicitCtorDtorStmt * > ( stmt ) ) {
-                        return getCtorDtorCall( impCtorDtorStmt->get_callStmt() );
-                } else {
-                        // should never get here
-                        assert( false && "encountered unknown call statement" );
-                }
-        }
-
-        bool isInstrinsicSingleArgCallStmt( Statement * stmt ) {
-                Expression * callExpr = getCtorDtorCall( stmt );
-                if ( ! callExpr ) return false;
-                ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( callExpr );
-                assert( appExpr );
-                VariableExpr * function = dynamic_cast< VariableExpr * >( appExpr->get_function() );
-                assert( function );
-                // check for Intrinsic only - don't want to remove all overridable ctor/dtors because autogenerated ctor/dtor
-                // will call all member dtors, and some members may have a user defined dtor.
-                FunctionType * funcType = GenPoly::getFunctionType( function->get_var()->get_type() );
-                assert( funcType );
-                return function->get_var()->get_linkage() == LinkageSpec::Intrinsic && funcType->get_parameters().size() == 1;
-        }
-
-        namespace {
-                template<typename CallExpr>
-                Expression *& callArg( CallExpr * callExpr, unsigned int pos ) {
-                        if ( pos >= callExpr->get_args().size() ) assert( false && "asking for argument that doesn't exist. Return NULL/throw exception?" );
-                        for ( Expression *& arg : callExpr->get_args() ) {
-                                if ( pos == 0 ) return arg;
-                                pos--;
-                        }
-                        assert( false );
-                }
-        }
-
-        Expression *& getCallArg( Expression * callExpr, unsigned int pos ) {
-                if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( callExpr ) ) {
-                        return callArg( appExpr, pos );
-                } else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * >( callExpr ) ) {
-                        return callArg( untypedExpr, pos );
-                } else {
-                        assert( false && "Unexpected expression type passed to getCallArg" );
-                }
-        }
-
-        namespace {
-                template<typename CallExpr>
-                std::string funcName( CallExpr * expr ) {
-                        Expression * func = expr->get_function();
-                        if ( NameExpr * nameExpr = dynamic_cast< NameExpr * >( func ) ) {
-                                return nameExpr->get_name();
-                        } else if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( func ) ) {
-                                return varExpr->get_var()->get_name();
-                        } else {
-                                assert( false && "Unexpected expression type being called as a function in call expression" );
-                        }
-                }
-        }
-
-        std::string getFunctionName( Expression * expr ) {
-                if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr ) ) {
-                        return funcName( appExpr );
-                } else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * > ( expr ) ) {
-                        return funcName( untypedExpr );
-                } else {
-                        assert( false && "Unexpected expression type passed to getFunctionName" );
-                }
-        }
-
-        Type * getPointerBase( Type * type ) {
-                if ( PointerType * ptrType = dynamic_cast< PointerType * >( type ) ) {
-                        return ptrType->get_base();
-                } else if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) {
-                        return arrayType->get_base();
-                } else {
-                        return NULL;
-                }
-        }
-
-        Type * isPointerType( Type * type ) {
-                if ( getPointerBase( type ) ) return type;
-                else return NULL;
-        }
+  bool isInstrinsicSingleArgCallStmt( Statement * stmt ) {
+    if ( stmt == NULL ) return false;
+    if ( ExprStmt * exprStmt = dynamic_cast< ExprStmt * >( stmt ) ) {
+      ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( exprStmt->get_expr() );
+      assert( appExpr );
+      VariableExpr * function = dynamic_cast< VariableExpr * >( appExpr->get_function() );
+      assert( function );
+      // check for Intrinsic only - don't want to remove all overridable ctor/dtors because autogenerated ctor/dtor
+      // will call all member dtors, and some members may have a user defined dtor.
+      FunctionType * funcType = GenPoly::getFunctionType( function->get_var()->get_type() );
+      assert( funcType );
+      return function->get_var()->get_linkage() == LinkageSpec::Intrinsic && funcType->get_parameters().size() == 1;
+    } else if ( CompoundStmt * compoundStmt = dynamic_cast< CompoundStmt * >( stmt ) ) {
+      // could also be a compound statement with a loop, in the case of an array
+      assert( compoundStmt->get_kids().size() == 2 ); // loop variable and loop
+      ForStmt * forStmt = dynamic_cast< ForStmt * >( compoundStmt->get_kids().back() );
+      assert( forStmt && forStmt->get_body() );
+      return isInstrinsicSingleArgCallStmt( forStmt->get_body() );
+    } else {
+      // should never get here
+      assert( false && "encountered unknown call statement" );
+    }
+  }
 }

src/InitTweak/InitTweak.h

@@ -39 +39 @@
   /// Currently has assertions that make it less than fully general.
   bool isInstrinsicSingleArgCallStmt( Statement * expr );
-
-  /// get the Ctor/Dtor call expression from a Statement that looks like a generated ctor/dtor call
-  Expression * getCtorDtorCall( Statement * stmt );
-
-  /// returns the name of the function being called
-  std::string getFunctionName( Expression * expr );
-
-  /// returns the argument to a call expression in position N indexed from 0
-  Expression *& getCallArg( Expression * callExpr, unsigned int pos );
-
-  /// returns the base type of a PointerType or ArrayType, else returns NULL
-  Type * getPointerBase( Type * );
-
-  /// returns the argument if it is a PointerType or ArrayType, else returns NULL
-  Type * isPointerType( Type * );
 } // namespace
 

src/Makefile.in

@@ -195 +195 @@
         SynTree/driver_cfa_cpp-Mutator.$(OBJEXT) \
         SynTree/driver_cfa_cpp-TypeSubstitution.$(OBJEXT) \
-        SynTree/driver_cfa_cpp-Attribute.$(OBJEXT) \
         Tuples/driver_cfa_cpp-Mutate.$(OBJEXT) \
         Tuples/driver_cfa_cpp-AssignExpand.$(OBJEXT) \
@@ -384 +383 @@
         SynTree/NamedTypeDecl.cc SynTree/TypeDecl.cc \
         SynTree/Initializer.cc SynTree/Visitor.cc SynTree/Mutator.cc \
-        SynTree/TypeSubstitution.cc SynTree/Attribute.cc \
-        Tuples/Mutate.cc Tuples/AssignExpand.cc \
-        Tuples/FunctionFixer.cc Tuples/TupleAssignment.cc \
-        Tuples/FunctionChecker.cc Tuples/NameMatcher.cc
+        SynTree/TypeSubstitution.cc Tuples/Mutate.cc \
+        Tuples/AssignExpand.cc Tuples/FunctionFixer.cc \
+        Tuples/TupleAssignment.cc Tuples/FunctionChecker.cc \
+        Tuples/NameMatcher.cc
 MAINTAINERCLEANFILES = Parser/parser.output ${libdir}/${notdir \
         ${cfa_cpplib_PROGRAMS}}
@@ -756 +755 @@
 SynTree/driver_cfa_cpp-TypeSubstitution.$(OBJEXT):  \
         SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/driver_cfa_cpp-Attribute.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
 Tuples/$(am__dirstamp):
         @$(MKDIR_P) Tuples
@@ -855 +852 @@
         -rm -f SynTree/driver_cfa_cpp-ArrayType.$(OBJEXT)
         -rm -f SynTree/driver_cfa_cpp-AttrType.$(OBJEXT)
-        -rm -f SynTree/driver_cfa_cpp-Attribute.$(OBJEXT)
         -rm -f SynTree/driver_cfa_cpp-BasicType.$(OBJEXT)
         -rm -f SynTree/driver_cfa_cpp-CommaExpr.$(OBJEXT)
@@ -965 +961 @@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-ArrayType.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-AttrType.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-Attribute.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-BasicType.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-CommaExpr.Po@am__quote@
@@ -2401 +2396 @@
 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCXX_FALSE@  $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-TypeSubstitution.obj `if test -f 'SynTree/TypeSubstitution.cc'; then $(CYGPATH_W) 'SynTree/TypeSubstitution.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/TypeSubstitution.cc'; fi`
-
-SynTree/driver_cfa_cpp-Attribute.o: SynTree/Attribute.cc
-@am__fastdepCXX_TRUE@   $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-Attribute.o -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-Attribute.Tpo -c -o SynTree/driver_cfa_cpp-Attribute.o `test -f 'SynTree/Attribute.cc' || echo '$(srcdir)/'`SynTree/Attribute.cc
-@am__fastdepCXX_TRUE@   $(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-Attribute.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-Attribute.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      source='SynTree/Attribute.cc' object='SynTree/driver_cfa_cpp-Attribute.o' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-Attribute.o `test -f 'SynTree/Attribute.cc' || echo '$(srcdir)/'`SynTree/Attribute.cc
-
-SynTree/driver_cfa_cpp-Attribute.obj: SynTree/Attribute.cc
-@am__fastdepCXX_TRUE@   $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-Attribute.obj -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-Attribute.Tpo -c -o SynTree/driver_cfa_cpp-Attribute.obj `if test -f 'SynTree/Attribute.cc'; then $(CYGPATH_W) 'SynTree/Attribute.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/Attribute.cc'; fi`
-@am__fastdepCXX_TRUE@   $(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-Attribute.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-Attribute.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      source='SynTree/Attribute.cc' object='SynTree/driver_cfa_cpp-Attribute.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-Attribute.obj `if test -f 'SynTree/Attribute.cc'; then $(CYGPATH_W) 'SynTree/Attribute.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/Attribute.cc'; fi`
 
 Tuples/driver_cfa_cpp-Mutate.o: Tuples/Mutate.cc

src/ResolvExpr/AlternativeFinder.cc

@@ -39 +39 @@
 #include "Tuples/NameMatcher.h"
 #include "Common/utility.h"
-#include "InitTweak/InitTweak.h"
 
 extern bool resolvep;
@@ -547 +546 @@
 
                 {
-                        std::string fname = InitTweak::getFunctionName( untypedExpr );
-                        if ( fname == "&&" ) {
+                        NameExpr *fname = 0;;
+                        if ( ( fname = dynamic_cast<NameExpr *>( untypedExpr->get_function()))
+                                 && ( fname->get_name() == std::string("&&")) ) {
                                 VoidType v = Type::Qualifiers();                // resolve to type void *
                                 PointerType pt( Type::Qualifiers(), v.clone() );

src/ResolvExpr/CommonType.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// CommonType.cc --
+// CommonType.cc -- 
 //
 // Author           : Richard C. Bilson
@@ -134 +134 @@
                                 result = new BasicType( basicType->get_qualifiers() + otherBasic->get_qualifiers(), newType );
                         } // if
-                } else if ( EnumInstType *enumInstType = dynamic_cast< EnumInstType * > ( type2 ) ) {
-                        // use signed int in lieu of the enum type
-                        BasicType::Kind newType = combinedType[ basicType->get_kind() ][ BasicType::SignedInt ];
-                        if ( ( ( newType == basicType->get_kind() && basicType->get_qualifiers() >= enumInstType->get_qualifiers() ) || widenFirst ) && ( ( newType != basicType->get_kind() && basicType->get_qualifiers() <= enumInstType->get_qualifiers() ) || widenSecond ) ) {
-                                result = new BasicType( basicType->get_qualifiers() + enumInstType->get_qualifiers(), newType );
-                        } // if
                 } // if
         }
@@ -189 +183 @@
         }
 
-        void CommonType::visit( EnumInstType *enumInstType ) {
-                if ( dynamic_cast< BasicType * >( type2 ) ) {
-                        // reuse BasicType, EnumInstType code by swapping type2 with enumInstType
-                        Type * temp = type2;
-                        type2 = enumInstType;
-                        temp->accept( *this );
-                        type2 = temp;
-                } // if
+        void CommonType::visit( EnumInstType *aggregateUseType ) {
         }
 

src/ResolvExpr/ConversionCost.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// ConversionCost.cc --
+// ConversionCost.cc -- 
 //
 // Author           : Richard C. Bilson
@@ -157 +157 @@
                                 cost = Cost( 0, 0, tableResult );
                         } // if
-                } else if ( dynamic_cast< EnumInstType *>( dest ) ) {
-                        // xxx - not positive this is correct, but appears to allow casting int => enum
-                        cost = Cost( 1, 0, 0 );
-    } // if
+                } // if
         }
 

src/ResolvExpr/Resolver.cc

@@ -38 +38 @@
                 virtual void visit( ObjectDecl *functionDecl );
                 virtual void visit( TypeDecl *typeDecl );
-                virtual void visit( EnumDecl * enumDecl );
 
                 virtual void visit( ArrayType * at );
@@ -53 +52 @@
                 virtual void visit( BranchStmt *branchStmt );
                 virtual void visit( ReturnStmt *returnStmt );
-                virtual void visit( ImplicitCtorDtorStmt * impCtorDtorStmt );
 
                 virtual void visit( SingleInit *singleInit );
@@ -67 +65 @@
                 Type *initContext;
                 Type *switchType;
-                bool inEnumDecl = false;
         };
 
@@ -180 +177 @@
                 Type *temp = initContext;
                 initContext = new_type;
-                if ( inEnumDecl && dynamic_cast< EnumInstType * >( initContext ) ) {
-                        // enumerator initializers should not use the enum type to initialize, since
-                        // the enum type is still incomplete at this point. Use signed int instead.
-                        initContext = new BasicType( Type::Qualifiers(), BasicType::SignedInt );
-                }
                 SymTab::Indexer::visit( objectDecl );
-                if ( inEnumDecl && dynamic_cast< EnumInstType * >( initContext ) ) {
-                        // delete newly created signed int type
-                        delete initContext;
-                }
                 initContext = temp;
         }
@@ -227 +215 @@
                 SymTab::Indexer::visit( functionDecl );
                 functionReturn = oldFunctionReturn;
-        }
-
-        void Resolver::visit( EnumDecl * enumDecl ) {
-                // in case we decide to allow nested enums
-                bool oldInEnumDecl = inEnumDecl;
-                inEnumDecl = true;
-                SymTab::Indexer::visit( enumDecl );
-                inEnumDecl = oldInEnumDecl;
         }
 
@@ -512 +492 @@
                 } catch ( SemanticError ) {
                         // no alternatives for the constructor initializer - fallback on C-style initializer
-                        // xxx - not sure if this makes a ton of sense - should maybe never be able to have this situation?
+                        // xxx- not sure if this makes a ton of sense - should maybe never be able to have this situation?
                         fallbackInit( ctorInit );
                         return;
@@ -533 +513 @@
                 }
         }
-
-        void Resolver::visit( ImplicitCtorDtorStmt * impCtorDtorStmt ) {
-                // before resolving ctor/dtor, need to remove type qualifiers from the first argument (the object being constructed).
-                // Do this through a cast expression to greatly simplify the code.
-                Expression * callExpr = InitTweak::getCtorDtorCall( impCtorDtorStmt );
-                assert( callExpr );
-                Expression *& constructee = InitTweak::getCallArg( callExpr, 0 );
-                Type * type = 0;
-
-                // need to find the type of the first argument, which is unfortunately not uniform since array construction
-                // includes an untyped '+' expression.
-                if ( UntypedExpr * plusExpr = dynamic_cast< UntypedExpr * >( constructee ) ) {
-                        // constructee is <array>+<index>
-                        // get Variable <array>, then get the base type of the VariableExpr - this is the type that needs to be fixed
-                        Expression * arr = InitTweak::getCallArg( plusExpr, 0 );
-                        assert( dynamic_cast< VariableExpr * >( arr ) );
-                        assert( arr && arr->get_results().size() == 1 );
-                        type = arr->get_results().front()->clone();
-                } else {
-                        // otherwise, constructing a plain object, which means the object's address is being taken.
-                        // Need to get the type of the VariableExpr object, because the AddressExpr is rebuilt and uses the
-                        // type of the VariableExpr to do so.
-                        assert( constructee->get_results().size() == 1 );
-                        AddressExpr * addrExpr = dynamic_cast< AddressExpr * > ( constructee );
-                        assert( addrExpr && addrExpr->get_results().size() == 1);
-                        type = addrExpr->get_results().front()->clone();
-                }
-                // cast to T* with qualifiers removed.
-                // unfortunately, lvalue is considered a qualifier. For AddressExpr to resolve, its argument
-                // must have an lvalue qualified type, so remove all qualifiers except lvalue. If we ever
-                // remove lvalue as a qualifier, this can change to
-                //   type->get_qualifiers() = Type::Qualifiers();
-                Type * base = InitTweak::getPointerBase( type );
-                assert( base );
-                base->get_qualifiers() -= Type::Qualifiers(true, true, true, false, true, true);
-                // if pointer has lvalue qualifier, cast won't appear in output
-                type->set_isLvalue( false );
-                constructee = new CastExpr( constructee, type );
-
-                // finally, resolve the ctor/dtor
-                impCtorDtorStmt->get_callStmt()->accept( *this );
-        }
 } // namespace ResolvExpr
 

src/SymTab/Autogen.cc

@@ -102 +102 @@
                 FunctionType *assignType = new FunctionType( Type::Qualifiers(), false );
 
-                ObjectDecl *dstParam = new ObjectDecl( "_dst", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), refType ), 0 );
-                assignType->get_parameters().push_back( dstParam );
-
-                // void ?{}(E *); void ^?{}(E *);
-                FunctionType * ctorType = assignType->clone();
-                FunctionType * dtorType = assignType->clone();
-
-                ObjectDecl *srcParam = new ObjectDecl( "_src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, refType->clone(), 0 );
-                assignType->get_parameters().push_back( srcParam );
-                // void ?{}(E *, E);
-                FunctionType *copyCtorType = assignType->clone();
-
-                // T ?=?(E *, E);
                 ObjectDecl *returnVal = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, refType->clone(), 0 );
                 assignType->get_returnVals().push_back( returnVal );
 
-                // xxx - should we also generate void ?{}(E *, int) and E ?{}(E *, E)?
-                // right now these cases work, but that might change.
+                // need two assignment operators with different types
+                FunctionType * assignType2 = assignType->clone();
+
+                // E ?=?(E volatile *, E)
+                Type *etype = refType->clone();
+                // etype->get_qualifiers() += Type::Qualifiers(false, true, false, false, false, false);
+
+                ObjectDecl *dstParam = new ObjectDecl( "_dst", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), etype ), 0 );
+                assignType->get_parameters().push_back( dstParam );
+
+                ObjectDecl *srcParam = new ObjectDecl( "_src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, etype->clone(), 0 );
+                assignType->get_parameters().push_back( srcParam );
+
+                // E ?=?(E volatile *, int)
+                assignType2->get_parameters().push_back( dstParam->clone() );
+                BasicType * paramType = new BasicType(Type::Qualifiers(), BasicType::SignedInt);
+                ObjectDecl *srcParam2 = new ObjectDecl( "_src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, paramType, 0 );
+                assignType2->get_parameters().push_back( srcParam2 );
 
                 // Routines at global scope marked "static" to prevent multiple definitions is separate translation units
                 // because each unit generates copies of the default routines for each aggregate.
-                // xxx - Temporary: make these functions intrinsic so they codegen as C assignment.
-                // Really they're something of a cross between instrinsic and autogen, so should
-                // probably make a new linkage type
-                FunctionDecl *assignDecl = new FunctionDecl( "?=?", functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::Intrinsic, assignType, new CompoundStmt( noLabels ), true, false );
-                FunctionDecl *ctorDecl = new FunctionDecl( "?{}", functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::Intrinsic, ctorType, new CompoundStmt( noLabels ), true, false );
-                FunctionDecl *copyCtorDecl = new FunctionDecl( "?{}", functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::Intrinsic, copyCtorType, new CompoundStmt( noLabels ), true, false );
-                FunctionDecl *dtorDecl = new FunctionDecl( "^?{}", functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::Intrinsic, dtorType, new CompoundStmt( noLabels ), true, false );
+
+                // since there is no definition, these should not be inline
+                // make these intrinsic so that the code generator does not make use of them
+                FunctionDecl *assignDecl = new FunctionDecl( "?=?", functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::Intrinsic, assignType, 0, false, false );
                 assignDecl->fixUniqueId();
-                ctorDecl->fixUniqueId();
-                copyCtorDecl->fixUniqueId();
-                dtorDecl->fixUniqueId();
-
-                // enum copy construct and assignment is just C-style assignment.
-                // this looks like a bad recursive call, but code gen will turn it into
-                // a C-style assignment.
-                // This happens before function pointer type conversion, so need to do it manually here
-                VariableExpr * assignVarExpr = new VariableExpr( assignDecl );
-                Type *& assignVarExprType = assignVarExpr->get_results().front();
-                assignVarExprType = new PointerType( Type::Qualifiers(), assignVarExprType );
-                ApplicationExpr * assignExpr = new ApplicationExpr( assignVarExpr );
-                assignExpr->get_args().push_back( new VariableExpr( dstParam ) );
-                assignExpr->get_args().push_back( new VariableExpr( srcParam ) );
-
-                // body is either return stmt or expr stmt
-                assignDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, assignExpr ) );
-                copyCtorDecl->get_statements()->get_kids().push_back( new ExprStmt( noLabels, assignExpr->clone() ) );
-
-                declsToAdd.push_back( assignDecl );
-                declsToAdd.push_back( ctorDecl );
-                declsToAdd.push_back( copyCtorDecl );
-                declsToAdd.push_back( dtorDecl );
+                FunctionDecl *assignDecl2 = new FunctionDecl( "?=?", functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::Intrinsic, assignType2, 0, false, false );
+                assignDecl2->fixUniqueId();
+
+                // these should be built in the same way that the prelude
+                // functions are, so build a list containing the prototypes
+                // and allow MakeLibCfa to autogenerate the bodies.
+                std::list< Declaration * > assigns;
+                assigns.push_back( assignDecl );
+                assigns.push_back( assignDecl2 );
+
+                LibCfa::makeLibCfa( assigns );
+
+                // need to remove the prototypes, since this may be nested in a routine
+                for (int start = 0, end = assigns.size()/2; start < end; start++) {
+                        delete assigns.front();
+                        assigns.pop_front();
+                } // for
+
+                declsToAdd.insert( declsToAdd.begin(), assigns.begin(), assigns.end() );
         }
 
@@ -492 +488 @@
                 type->get_parameters().push_back( dst );
                 type->get_parameters().push_back( src );
-                FunctionDecl *func = new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::AutoGen, type, stmts, true, false );
+                FunctionDecl *func = new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::AutoGen, type, stmts, false, false );
                 declsToAdd.push_back( func );
         }

src/SymTab/Validate.cc

@@ -279 +279 @@
         void Pass1::visit( EnumDecl *enumDecl ) {
                 // Set the type of each member of the enumeration to be EnumConstant
+
                 for ( std::list< Declaration * >::iterator i = enumDecl->get_members().begin(); i != enumDecl->get_members().end(); ++i ) {
                         ObjectDecl * obj = dynamic_cast< ObjectDecl * >( *i );
                         assert( obj );
-                        obj->set_type( new EnumInstType( Type::Qualifiers( true, false, false, false, false, false ), enumDecl->get_name() ) );
+                        // obj->set_type( new EnumInstType( Type::Qualifiers( true, false, false, false, false, false ), enumDecl->get_name() ) );
+                        BasicType * enumType = new BasicType( Type::Qualifiers(), BasicType::SignedInt );
+                        obj->set_type( enumType ) ;
                 } // for
                 Parent::visit( enumDecl );

src/SynTree/Declaration.h

@@ -115 +115 @@
         typedef DeclarationWithType Parent;
   public:
-        FunctionDecl( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Type linkage, FunctionType *type, CompoundStmt *statements, bool isInline, bool isNoreturn, const std::list< Attribute * > attributes = std::list< Attribute * >() );
+        // temporary - merge this into general GCC attributes
+        struct Attribute {
+                enum Type {
+                        NoAttribute, Constructor, Destructor,
+                } type;
+                enum Priority {
+                        // priorities 0-100 are reserved by gcc, so it's okay to use 100 an exceptional case
+                        Default = 100, High,
+                } priority;
+                Attribute(Type t = NoAttribute, Priority p = Default) : type(t), priority(p) {};
+        };
+
+        FunctionDecl( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Type linkage, FunctionType *type, CompoundStmt *statements, bool isInline, bool isNoreturn, Attribute attribute = Attribute() );
         FunctionDecl( const FunctionDecl &other );
         virtual ~FunctionDecl();
@@ -128 +140 @@
         std::list< std::string >& get_oldIdents() { return oldIdents; }
         std::list< Declaration* >& get_oldDecls() { return oldDecls; }
-        std::list< Attribute * >& get_attributes() { return attributes; }
+        Attribute get_attribute() const { return attribute; }
+        void set_attribute( Attribute newValue ) { attribute = newValue; }
 
         virtual FunctionDecl *clone() const { return new FunctionDecl( *this ); }
@@ -140 +153 @@
         std::list< std::string > oldIdents;
         std::list< Declaration* > oldDecls;
-        std::list< Attribute * > attributes;
+        Attribute attribute;
 };
 

src/SynTree/FunctionDecl.cc

@@ -19 +19 @@
 #include "Statement.h"
 #include "Type.h"
-#include "Attribute.h"
 #include "Common/utility.h"
 
-FunctionDecl::FunctionDecl( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Type linkage, FunctionType *type, CompoundStmt *statements, bool isInline, bool isNoreturn, std::list< Attribute * > attributes )
-                : Parent( name, sc, linkage ), type( type ), statements( statements ), attributes( attributes ) {
+FunctionDecl::FunctionDecl( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Type linkage, FunctionType *type, CompoundStmt *statements, bool isInline, bool isNoreturn, Attribute attribute )
+                : Parent( name, sc, linkage ), type( type ), statements( statements ), attribute( attribute ) {
         set_isInline( isInline );
         set_isNoreturn( isNoreturn );
@@ -33 +32 @@
 
 FunctionDecl::FunctionDecl( const FunctionDecl &other )
-        : Parent( other ), type( maybeClone( other.type ) ), statements( maybeClone( other.statements ) ) {
-                cloneAll( other.attributes, attributes );
+        : Parent( other ), type( maybeClone( other.type ) ), statements( maybeClone( other.statements ) ), attribute( other.attribute ) {
 }
 
@@ -40 +38 @@
         delete type;
         delete statements;
-        deleteAll( attributes );
 }
 
@@ -68 +65 @@
                 os << "_Noreturn ";
         } // if
-
-        printAll( attributes, os, indent );
-
+        switch ( attribute.type ) {
+                case Attribute::Constructor:
+                        os << "Global Constructor ";
+                        break;
+                case Attribute::Destructor:
+                        os << "Global Destructor ";
+                        break;
+                default:
+                        break;
+        }
+        if ( attribute.priority != Attribute::Default ) {
+                os << "with priority " << attribute.priority << " ";
+        }
         if ( get_storageClass() != DeclarationNode::NoStorageClass ) {
                 os << DeclarationNode::storageName[ get_storageClass() ] << ' ';
@@ -111 +118 @@
                 os << "_Noreturn ";
         } // if
-
-        // xxx - should printShort print attributes?
-
+        switch ( attribute.type ) {
+                case Attribute::Constructor:
+                        os << " Global Constructor ";
+                        break;
+                case Attribute::Destructor:
+                        os << " Global Destructor ";
+                        break;
+                default:
+                        break;
+        }
+        if ( attribute.priority != Attribute::Default ) {
+                os << "with priority " << attribute.priority << " ";
+        }
         if ( get_storageClass() != DeclarationNode::NoStorageClass ) {
                 os << DeclarationNode::storageName[ get_storageClass() ] << ' ';

src/SynTree/Initializer.cc

@@ -20 +20 @@
 
 Initializer::Initializer( bool maybeConstructed ) : maybeConstructed( maybeConstructed ) {}
-Initializer::Initializer( const Initializer & other ) : maybeConstructed( other.maybeConstructed ) {
-}
-
 
 Initializer::~Initializer() {}
@@ -42 +39 @@
 }
 
-SingleInit::~SingleInit() {
-        deleteAll(designators);
-}
+SingleInit::~SingleInit() {}
+
+SingleInit *SingleInit::clone() const { return new SingleInit( *this); }
 
 void SingleInit::print( std::ostream &os, int indent ) {
@@ -61 +58 @@
 
 ListInit::ListInit( const std::list<Initializer*> &_initializers, const std::list<Expression *> &_designators, bool maybeConstructed )
-        : Initializer( maybeConstructed ), initializers( _initializers ), designators( _designators ) {
+        : Initializer( maybeConstructed), initializers( _initializers ), designators( _designators ) {
 }
 
-ListInit::~ListInit() {
-        deleteAll( initializers );
-        deleteAll( designators );
+ListInit::~ListInit() {}
+
+ListInit *ListInit::clone() const {
+        return new ListInit( *this );
 }
 
@@ -87 +85 @@
 
 ConstructorInit::ConstructorInit( Statement * ctor, Statement * dtor, Initializer * init ) : Initializer( true ), ctor( ctor ), dtor( dtor ), init( init ) {}
-ConstructorInit::ConstructorInit( const ConstructorInit &other ) : Initializer( other ), ctor( maybeClone( other.ctor ) ), dtor( maybeClone( other.dtor ) ), init( maybeClone( other.init ) ) {
+ConstructorInit::~ConstructorInit() {
+        delete ctor;
+        delete init;
 }
 
-ConstructorInit::~ConstructorInit() {
-        delete ctor;
-        delete dtor;
-        delete init;
+ConstructorInit *ConstructorInit::clone() const {
+        return new ConstructorInit( *this );
 }
 

src/SynTree/Initializer.h

@@ -20 +20 @@
 #include "Visitor.h"
 #include "Mutator.h"
-#include "Type.h"
 
 #include <cassert>
@@ -29 +28 @@
         //      Initializer( std::string _name = std::string(""), int _pos = 0 );
         Initializer( bool maybeConstructed );
-        Initializer( const Initializer & other );
         virtual ~Initializer();
 
@@ -70 +68 @@
         std::list<Expression *> &get_designators() { return designators; }
 
-        virtual SingleInit *clone() const { return new SingleInit( *this); }
+        virtual SingleInit *clone() const;
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
@@ -96 +94 @@
         std::list<Initializer*>::iterator end_initializers() { return initializers.end(); }
 
-        virtual ListInit *clone() const { return new ListInit( *this ); }
+        virtual ListInit *clone() const;
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
@@ -110 +108 @@
   public:
         ConstructorInit( Statement * ctor, Statement * dtor, Initializer * init );
-        ConstructorInit( const ConstructorInit &other );
         virtual ~ConstructorInit();
 
@@ -120 +117 @@
         Initializer * get_init() const { return init; }
 
-        ConstructorInit *clone() const { return new ConstructorInit( *this ); }
+        virtual ConstructorInit *clone() const;
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }

src/SynTree/Mutator.cc

@@ -182 +182 @@
 }
 
-Statement *Mutator::mutate( ImplicitCtorDtorStmt *impCtorDtorStmt ) {
-        impCtorDtorStmt->set_callStmt( maybeMutate( impCtorDtorStmt->get_callStmt(), *this ) );
-        return impCtorDtorStmt;
-}
-
 Expression *Mutator::mutate( ApplicationExpr *applicationExpr ) {
         mutateAll( applicationExpr->get_results(), *this );

src/SynTree/Mutator.h

@@ -52 +52 @@
         virtual NullStmt* mutate( NullStmt *nullStmt );
         virtual Statement* mutate( DeclStmt *declStmt );
-        virtual Statement* mutate( ImplicitCtorDtorStmt *impCtorDtorStmt );
 
         virtual Expression* mutate( ApplicationExpr *applicationExpr );

src/SynTree/Statement.cc

@@ -358 +358 @@
 
 void CatchStmt::print( std::ostream &os, int indent ) const {
-        os << "Catch Statement" << endl;
+        os << string( indent, ' ' ) << "Catch Statement" << endl;
 
         os << string( indent, ' ' ) << "... catching" << endl;
@@ -383 +383 @@
 
 void FinallyStmt::print( std::ostream &os, int indent ) const {
-        os << "Finally Statement" << endl;
+        os << string( indent, ' ' ) << "Finally Statement" << endl;
         os << string( indent + 2, ' ' ) << "with block: " << endl;
         block->print( os, indent + 4 );
@@ -393 +393 @@
 void NullStmt::print( std::ostream &os, int indent ) const {
         os << "Null Statement" << endl ;
-}
-
-ImplicitCtorDtorStmt::ImplicitCtorDtorStmt( Statement * callStmt ) : Statement( std::list<Label>() ), callStmt( callStmt ) {
-        assert( callStmt );
-}
-
-ImplicitCtorDtorStmt::ImplicitCtorDtorStmt( const ImplicitCtorDtorStmt & other ) : Statement( other ), callStmt( other.callStmt ) {
-}
-
-ImplicitCtorDtorStmt::~ImplicitCtorDtorStmt() {
-}
-
-void ImplicitCtorDtorStmt::print( std::ostream &os, int indent ) const {
-        os << "Implicit Ctor Dtor Statement" << endl;
-        os << string( indent + 2, ' ' ) << "with Ctor/Dtor: ";
-        callStmt->print( os, indent + 2);
-        os << endl;
 }
 

src/SynTree/Statement.h

@@ -21 +21 @@
 #include "Mutator.h"
 #include "Common/SemanticError.h"
-#include "Type.h"
 
 class Statement {
@@ -395 +394 @@
         virtual ~DeclStmt();
 
-        Declaration *get_decl() const { return decl; }
+        Declaration *get_decl() { return decl; }
         void set_decl( Declaration *newValue ) { decl = newValue; }
 
@@ -405 +404 @@
         Declaration *decl;
 };
-
-
-/// represents an implicit application of a constructor or destructor. Qualifiers are replaced
-/// immediately before and after the call so that qualified objects can be constructed
-/// with the same functions as unqualified objects.
-class ImplicitCtorDtorStmt : public Statement {
-  public:
-        ImplicitCtorDtorStmt( Statement * callStmt );
-        ImplicitCtorDtorStmt( const ImplicitCtorDtorStmt & other );
-        virtual ~ImplicitCtorDtorStmt();
-
-        Statement *get_callStmt() const { return callStmt; }
-        void set_callStmt( Statement * newValue ) { callStmt = newValue; }
-
-        virtual ImplicitCtorDtorStmt *clone() const { return new ImplicitCtorDtorStmt( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
-
-  private:
-        // Non-owned pointer to the constructor/destructor statement
-        Statement * callStmt;
-};
-
 
 std::ostream & operator<<( std::ostream & out, Statement * statement );

src/SynTree/SynTree.h

@@ -56 +56 @@
 class DeclStmt;
 class NullStmt;
-class ImplicitCtorDtorStmt;
 
 class Expression;
@@ -118 +117 @@
 class TypeSubstitution;
 
-// gcc attribute
-class Attribute;
-
 #endif // SYNTREE_H
 

src/SynTree/Type.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Type.cc --
+// Type.cc -- 
 //
 // Author           : Richard C. Bilson
@@ -54 +54 @@
 }
 
-void Type::Qualifiers::print( std::ostream &os, int indent ) const {
-        if ( isConst ) {
-                os << "const ";
-        } // if
-        if ( isVolatile ) {
-                os << "volatile ";
-        } // if
-        if ( isRestrict ) {
-                os << "restrict ";
-        } // if
-        if ( isLvalue ) {
-                os << "lvalue ";
-        } // if
-        if ( isAtomic ) {
-                os << "_Atomic ";
-        } // if
-        if ( isAttribute ) {
-                os << "__attribute(( )) ";
-        } // if
-}
-
 void Type::print( std::ostream &os, int indent ) const {
         if ( ! forall.empty() ) {
@@ -81 +60 @@
                 os << std::string( indent+2, ' ' );
         } // if
-        tq.print( os, indent );
+        if ( tq.isConst ) {
+                os << "const ";
+        } // if
+        if ( tq.isVolatile ) {
+                os << "volatile ";
+        } // if
+        if ( tq.isRestrict ) {
+                os << "restrict ";
+        } // if
+        if ( tq.isLvalue ) {
+                os << "lvalue ";
+        } // if
+        if ( tq.isAtomic ) {
+                os << "_Atomic ";
+        } // if
+        if ( tq.isAttribute ) {
+                os << "__attribute(( )) ";
+        } // if
 }
 

src/SynTree/Type.h

@@ -36 +36 @@
                 bool operator<( const Qualifiers &other );
                 bool operator>( const Qualifiers &other );
-                void print( std::ostream &os, int indent = 0 ) const;
 
                 bool isConst;

src/SynTree/Visitor.cc

@@ -152 +152 @@
 }
 
-void Visitor::visit( ImplicitCtorDtorStmt *impCtorDtorStmt ) {
-        maybeAccept( impCtorDtorStmt->get_callStmt(), *this );
-}
-
 void Visitor::visit( ApplicationExpr *applicationExpr ) {
         acceptAll( applicationExpr->get_results(), *this );

src/SynTree/Visitor.h

@@ -52 +52 @@
         virtual void visit( NullStmt *nullStmt );
         virtual void visit( DeclStmt *declStmt );
-        virtual void visit( ImplicitCtorDtorStmt *impCtorDtorStmt );
 
         virtual void visit( ApplicationExpr *applicationExpr );

src/SynTree/module.mk

@@ -6 +6 @@
 ## file "LICENCE" distributed with Cforall.
 ##
-## module.mk --
+## module.mk -- 
 ##
 ## Author           : Richard C. Bilson
@@ -46 +46 @@
        SynTree/Visitor.cc \
        SynTree/Mutator.cc \
-       SynTree/TypeSubstitution.cc \
-       SynTree/Attribute.cc
+       SynTree/TypeSubstitution.cc
 

src/examples/avltree/avl-private.h

@@ -1 @@
-#ifndef AVL_PRIVATE_H
 #include "avl.h"
 
@@ -14 +13 @@
 forall(otype K | Comparable(K), otype V)
 int height(tree(K, V) * t);
-
-#endif