Changeset add7117


Ignore:
Timestamp:
Sep 10, 2016, 11:08:47 AM (8 years ago)
Author:
Rob Schluntz <rschlunt@…>
Branches:
ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
Children:
5af62f1
Parents:
f5e81d1 (diff), 03e3117 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' into tuples

Conflicts:

src/ResolvExpr/AlternativeFinder.cc
src/ResolvExpr/AlternativeFinder.h

Location:
src
Files:
22 edited

Legend:

Unmodified
Added
Removed
  • src/InitTweak/FixInit.cc

    rf5e81d1 radd7117  
    3333#include "SymTab/Autogen.h"
    3434#include "GenPoly/PolyMutator.h"
     35#include "GenPoly/DeclMutator.h"
    3536#include "SynTree/AddStmtVisitor.h"
    3637#include "CodeGen/GenType.h"  // for warnings
     
    216217                        SymTab::Indexer & indexer;
    217218                };
     219
     220                class FixCtorExprs : public GenPoly::DeclMutator {
     221                  public:
     222                        /// expands ConstructorExpr nodes into comma expressions, using a temporary for the first argument
     223                        static void fix( std::list< Declaration * > & translationUnit );
     224
     225                        virtual Expression * mutate( ConstructorExpr * ctorExpr );
     226                };
    218227        } // namespace
    219228
     
    221230                // fixes ConstructorInit for global variables. should happen before fixInitializers.
    222231                InitTweak::fixGlobalInit( translationUnit, filename, inLibrary );
     232
    223233
    224234                InsertImplicitCalls::insert( translationUnit );
     
    231241
    232242                GenStructMemberCalls::generate( translationUnit );
     243                // xxx - ctor expansion currently has to be after FixCopyCtors, because there is currently a
     244                // hack in the way untyped assignments are generated, where the first argument cannot have
     245                // its address taken because of the way codegeneration handles UntypedExpr vs. ApplicationExpr.
     246                // Thus such assignment exprs must never pushed through expression resolution (and thus should
     247                // not go through the FixCopyCtors pass), otherwise they will fail -- guaranteed.
     248                // Also needs to happen after GenStructMemberCalls, since otherwise member constructors exprs
     249                // don't look right, and a member can be constructed more than once.
     250                FixCtorExprs::fix( translationUnit );
    233251        }
    234252
     
    283301                                throw warner.errors;
    284302                        }
     303                }
     304
     305                void FixCtorExprs::fix( std::list< Declaration * > & translationUnit ) {
     306                        FixCtorExprs fixer;
     307                        fixer.mutateDeclarationList( translationUnit );
    285308                }
    286309
     
    480503                                        retExpr = deref;
    481504                                } // if
    482                                 // xxx - might need to set env on retExpr...
    483                                 // retExpr->set_env( env->clone() );
     505                                retExpr->set_env( env->clone() );
    484506                                return retExpr;
    485507                        } else {
     
    914936                        return safe_dynamic_cast< ApplicationExpr * >( ResolvExpr::findVoidExpression( untypedExpr, indexer ) );
    915937                }
     938
     939                Expression * FixCtorExprs::mutate( ConstructorExpr * ctorExpr ) {
     940                        static UniqueName tempNamer( "_tmp_ctor_expr" );
     941                        assert( ctorExpr->get_results().size() == 1 );
     942                        ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, ctorExpr->get_results().front()->clone(), nullptr );
     943                        addDeclaration( tmp );
     944
     945                        ApplicationExpr * callExpr = safe_dynamic_cast< ApplicationExpr * > ( ctorExpr->get_callExpr() );
     946                        TypeSubstitution * env = ctorExpr->get_env();
     947                        ctorExpr->set_callExpr( nullptr );
     948                        ctorExpr->set_env( nullptr );
     949
     950                        Expression *& firstArg = callExpr->get_args().front();
     951                        UntypedExpr * assign = new UntypedExpr( new NameExpr( "?=?" ) );
     952                        assign->get_args().push_back( new VariableExpr( tmp ) );
     953                        assign->get_args().push_back( firstArg );
     954                        cloneAll( ctorExpr->get_results(), assign->get_results() );
     955                        firstArg = assign;
     956
     957                        CommaExpr * commaExpr = new CommaExpr( callExpr, new VariableExpr( tmp ) );
     958                        commaExpr->set_env( env );
     959                        delete ctorExpr;
     960                        return commaExpr;
     961                }
    916962        } // namespace
    917963} // namespace InitTweak
  • src/InitTweak/InitTweak.cc

    rf5e81d1 radd7117  
    358358                template<typename CallExpr>
    359359                Expression *& callArg( CallExpr * callExpr, unsigned int pos ) {
    360                         if ( pos >= callExpr->get_args().size() ) assert( false && "asking for argument that doesn't exist. Return NULL/throw exception?" );
     360                        if ( pos >= callExpr->get_args().size() ) assertf( false, "asking for argument that doesn't exist. Return NULL/throw exception?" );
    361361                        for ( Expression *& arg : callExpr->get_args() ) {
    362362                                if ( pos == 0 ) return arg;
     
    373373                        return callArg( untypedExpr, pos );
    374374                } else {
    375                         assert( false && "Unexpected expression type passed to getCallArg" );
     375                        assertf( false, "Unexpected expression type passed to getCallArg" );
    376376                }
    377377        }
     
    388388                                return memberExpr->get_member()->get_name();
    389389                        } else {
    390                                 assert( false && "Unexpected expression type being called as a function in call expression" );
     390                                assertf( false, "Unexpected expression type being called as a function in call expression" );
    391391                        }
    392392                }
     
    400400                } else {
    401401                        std::cerr << expr << std::endl;
    402                         assert( false && "Unexpected expression type passed to getFunctionName" );
     402                        assertf( false, "Unexpected expression type passed to getFunctionName" );
    403403                }
    404404        }
  • src/Parser/DeclarationNode.cc

    rf5e81d1 radd7117  
    1010// Created On       : Sat May 16 12:34:05 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Aug 29 22:30:56 2016
    13 // Update Count     : 327
     12// Last Modified On : Fri Sep  9 23:21:47 2016
     13// Update Count     : 402
    1414//
    1515
     
    4343extern LinkageSpec::Spec linkage;                                               // defined in parser.yy
    4444
    45 DeclarationNode::DeclarationNode()
    46                 : type( 0 )
    47                 , storageClass( NoStorageClass )
    48                 , isInline( false )
    49                 , isNoreturn( false )
    50                 , bitfieldWidth( 0 )
    51                 , initializer( 0 )
    52                 , hasEllipsis( false )
    53                 , linkage( ::linkage )
    54                 , extension( false )
    55                 , error() {
     45DeclarationNode::DeclarationNode() :
     46                type( 0 ),
     47                storageClass( NoStorageClass ),
     48                isInline( false ),
     49                isNoreturn( false ),
     50                bitfieldWidth( 0 ),
     51                initializer( 0 ),
     52                hasEllipsis( false ),
     53                linkage( ::linkage ),
     54                extension( false ) {
     55        variable.tyClass = DeclarationNode::Type;
     56        variable.assertions = nullptr;
     57
    5658        attr.expr = nullptr;
    5759        attr.type = nullptr;
    58 
    59         variable.tyClass = DeclarationNode::Type;
    60         variable.assertions = nullptr;
    6160}
    6261
     
    393392
    394393        if ( (qsrc & qdst).any() ) {                                            // common bits between qualifier masks ?
    395                 error = "duplicate qualifier ";
    396                 int j = 0;                                                                              // separator detector
    397                 for ( int i = 0; i < DeclarationNode::NoOfQualifier; i += 1 ) {
    398                         if ( qsrc[i] & qdst[i] ) {                                      // find specific qualifiers in common
    399                                 if ( j > 0 ) error += ", ";
    400                                 error += DeclarationNode::qualifierName[i];
    401                                 j += 1;
     394                for ( int i = 0; i < NoOfQualifier; i += 1 ) {  // find common qualifiers
     395                        if ( qsrc[i] & qdst[i] ) {
     396                                error += string(error.empty() ? "" : ", ") + "duplicate " + DeclarationNode::qualifierName[i];
    402397                        } // if
    403398                } // for
    404                 error += " in declaration of ";
    405399        } // if
    406400} // DeclarationNode::checkQualifiers
     
    442436                storageClass = q->storageClass;
    443437        } else if ( q->storageClass != NoStorageClass ) {
    444                 q->error = "invalid combination of storage classes in declaration of ";
    445         } // if
    446         if ( error.empty() ) error = q->error;
    447         return this;
    448 }
     438                if ( storageClass == q->storageClass ) {
     439                        q->error += string( "duplicate " ) + storageName[ storageClass ];
     440                } else {                                                                                // can only have one storage class
     441                        q->error += string( "multiple " ) + storageName[ storageClass ] + " & " + storageName[ q->storageClass ];
     442                } // if
     443        } // if
     444        if ( ! q->error.empty() ) {
     445                error += (! error.empty() ? ", " : "") + q->error;
     446        } // if
     447        return this;
     448} // DeclarationNode::copyStorageClasses
    449449
    450450static void addTypeToType( TypeData *&src, TypeData *&dst ) {
     
    908908
    909909Declaration *DeclarationNode::build() const {
    910         if ( ! error.empty() ) throw SemanticError( error, this );
     910        if ( ! error.empty() ) throw SemanticError( error + " in declaration of ", this );
    911911        if ( type ) {
    912912                if ( type->kind == TypeData::Variable ) {
     
    922922                return (new ObjectDecl( name, storageClass, linkage, maybeBuild< Expression >( bitfieldWidth ), 0, maybeBuild< Initializer >( initializer ) ))->set_extension( extension );
    923923        } // if
    924         throw SemanticError( "invalid function specifier in declaration of ", this );
     924        throw SemanticError( "invalid function specifier ", this );
    925925}
    926926
     
    971971}
    972972
    973 // DeclarationNode::StorageClass DeclarationNode::buildStorageClass() const {
    974 //      DeclarationNode::StorageClass ret = DeclarationNode::NoStorageClass;
    975 //      for ( std::list< DeclarationNode::StorageClass >::const_iterator i = storageClasses.begin(); i != storageClasses.end(); ++i ) {
    976 //        if ( *i == DeclarationNode::Inline || *i == DeclarationNode::Noreturn ) continue; // ignore function specifiers
    977 //        if ( ret != DeclarationNode::NoStorageClass ) {       // already have a valid storage class ?
    978 //                      throw SemanticError( "invalid combination of storage classes in declaration of ", this );
    979 //              } // if
    980 //              ret = *i;
    981 //      } // for
    982 //      return ret;
    983 // }
    984 
    985 // bool DeclarationNode::buildFuncSpecifier( DeclarationNode::StorageClass key ) const {
    986 //      std::list< DeclarationNode::StorageClass >::const_iterator first = std::find( storageClasses.begin(), storageClasses.end(), key );
    987 //   if ( first == storageClasses.end() ) return false; // not found
    988 //      first = std::find( ++first, storageClasses.end(), key ); // found
    989 //   if ( first == storageClasses.end() ) return true;          // not found again
    990 //      throw SemanticError( "duplicate function specifier in declaration of ", this );
    991 // }
    992 
    993973// Local Variables: //
    994974// tab-width: 4 //
  • src/Parser/ParseNode.h

    rf5e81d1 radd7117  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Aug 29 21:45:43 2016
    13 // Update Count     : 583
     12// Last Modified On : Thu Sep  8 21:58:06 2016
     13// Update Count     : 587
    1414//
    1515
     
    290290        // bool buildFuncSpecifier( StorageClass key ) const;
    291291
    292         struct Enumeration_t {
    293                 std::string name;
    294                 DeclarationNode * constants;
    295         };
    296         Enumeration_t enumeration;
    297 
    298292        struct Variable_t {
    299293                DeclarationNode::TypeClass tyClass;
     
    408402                        if ( result ) {
    409403                                *out++ = result;
    410                         } else {
    411404                        } // if
    412405                } catch( SemanticError &e ) {
  • src/Parser/TypeData.h

    rf5e81d1 radd7117  
    1010// Created On       : Sat May 16 15:18:36 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Aug 29 22:31:52 2016
    13 // Update Count     : 110
     12// Last Modified On : Fri Sep  9 23:20:55 2016
     13// Update Count     : 117
    1414//
    1515
     
    9696                Array_t array;
    9797                Enumeration_t enumeration;
     98                // Variable_t variable;
    9899                Function_t function;
    99100                Symbolic_t symbolic;
    100101                DeclarationNode * tuple;
    101102                ExpressionNode * typeexpr;
    102                 //Attr_t attr;
     103                // Attr_t attr;
    103104                // DeclarationNode::BuiltinType builtin;
    104105
  • src/Parser/parser.cc

    rf5e81d1 radd7117  
    51255125    {
    51265126                        Token fn;
    5127                         fn.str = new std::string( "?{}" ); // location undefined
    5128                         (yyval.en) = new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( (yyvsp[(1) - (4)].en) )->set_last( (yyvsp[(3) - (4)].en) ) ) );
     5127                        fn.str = new std::string( "?{}" ); // location undefined - use location of '{'?
     5128                        (yyval.en) = new ExpressionNode( new ConstructorExpr( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( (yyvsp[(1) - (4)].en) )->set_last( (yyvsp[(3) - (4)].en) ) ) ) );
    51295129                }
    51305130    break;
  • src/Parser/parser.yy

    rf5e81d1 radd7117  
    391391                {
    392392                        Token fn;
    393                         fn.str = new std::string( "?{}" ); // location undefined
    394                         $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $1 )->set_last( $3 ) ) );
     393                        fn.str = new std::string( "?{}" ); // location undefined - use location of '{'?
     394                        $$ = new ExpressionNode( new ConstructorExpr( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $1 )->set_last( $3 ) ) ) );
    395395                }
    396396        ;
  • src/ResolvExpr/AlternativeFinder.cc

    rf5e81d1 radd7117  
    209209        }
    210210
    211         void AlternativeFinder::find( Expression *expr, bool adjust ) {
     211        void AlternativeFinder::find( Expression *expr, bool adjust, bool prune ) {
    212212                expr->accept( *this );
    213213                if ( alternatives.empty() ) {
     
    219219                        }
    220220                }
    221                 PRINT(
    222                         std::cerr << "alternatives before prune:" << std::endl;
    223                         printAlts( alternatives, std::cerr );
    224                 )
    225                 AltList::iterator oldBegin = alternatives.begin();
    226                 pruneAlternatives( alternatives.begin(), alternatives.end(), front_inserter( alternatives ), indexer );
    227                 if ( alternatives.begin() == oldBegin ) {
    228                         std::ostringstream stream;
    229                         stream << "Can't choose between alternatives for expression ";
    230                         expr->print( stream );
    231                         stream << "Alternatives are:";
    232                         AltList winners;
    233                         findMinCost( alternatives.begin(), alternatives.end(), back_inserter( winners ) );
    234                         printAlts( winners, stream, 8 );
    235                         throw SemanticError( stream.str() );
    236                 }
    237                 alternatives.erase( oldBegin, alternatives.end() );
    238                 PRINT(
    239                         std::cerr << "there are " << alternatives.size() << " alternatives after elimination" << std::endl;
    240                 )
     221                if ( prune ) {
     222                        PRINT(
     223                                std::cerr << "alternatives before prune:" << std::endl;
     224                                printAlts( alternatives, std::cerr );
     225                        )
     226                        AltList::iterator oldBegin = alternatives.begin();
     227                        pruneAlternatives( alternatives.begin(), alternatives.end(), front_inserter( alternatives ), indexer );
     228                        if ( alternatives.begin() == oldBegin ) {
     229                                std::ostringstream stream;
     230                                stream << "Can't choose between alternatives for expression ";
     231                                expr->print( stream );
     232                                stream << "Alternatives are:";
     233                                AltList winners;
     234                                findMinCost( alternatives.begin(), alternatives.end(), back_inserter( winners ) );
     235                                printAlts( winners, stream, 8 );
     236                                throw SemanticError( stream.str() );
     237                        }
     238                        alternatives.erase( oldBegin, alternatives.end() );
     239                        PRINT(
     240                                std::cerr << "there are " << alternatives.size() << " alternatives after elimination" << std::endl;
     241                        )
     242                }
    241243
    242244                // Central location to handle gcc extension keyword for all expression types.
     
    246248        }
    247249
    248         void AlternativeFinder::findWithAdjustment( Expression *expr ) {
    249                 find( expr, true );
     250        void AlternativeFinder::findWithAdjustment( Expression *expr, bool prune ) {
     251                find( expr, true, prune );
    250252        }
    251253
    252254        template< typename StructOrUnionType >
    253         void AlternativeFinder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, Expression * member ) {
     255        void AlternativeFinder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) {
    254256                NameExpr * nameExpr = safe_dynamic_cast< NameExpr * >( member );
    255257                const std::string & name = nameExpr->get_name();
    256 
    257258                std::list< Declaration* > members;
    258259                aggInst->lookup( name, members );
     
    813814                        if ( agg->expr->get_results().size() == 1 ) {
    814815                                if ( StructInstType *structInst = dynamic_cast< StructInstType* >( agg->expr->get_results().front() ) ) {
    815                                         addAggMembers( structInst, agg->expr, agg->cost, memberExpr->get_member() );
     816                                        addAggMembers( structInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
    816817                                } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( agg->expr->get_results().front() ) ) {
    817                                         addAggMembers( unionInst, agg->expr, agg->cost, memberExpr->get_member() );
     818                                        addAggMembers( unionInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
    818819                                } // if
    819820                        } // if
     
    843844                        if ( StructInstType *structInst = dynamic_cast< StructInstType* >( (*i)->get_type() ) ) {
    844845                                NameExpr nameExpr( "" );
    845                                 addAggMembers( structInst, &newExpr, Cost( 0, 0, 1 ), &nameExpr );
     846                                addAggMembers( structInst, &newExpr, Cost( 0, 0, 1 ), env, &nameExpr );
    846847                        } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( (*i)->get_type() ) ) {
    847848                                NameExpr nameExpr( "" );
    848                                 addAggMembers( unionInst, &newExpr, Cost( 0, 0, 1 ), &nameExpr );
     849                                addAggMembers( unionInst, &newExpr, Cost( 0, 0, 1 ), env, &nameExpr );
    849850                        } // if
    850851                } // for
     
    10671068                alternatives.push_back( Alternative( impCpCtorExpr->clone(), env, Cost::zero ) );
    10681069        }
     1070
     1071        void AlternativeFinder::visit( ConstructorExpr * ctorExpr ) {
     1072                AlternativeFinder finder( indexer, env );
     1073                // don't prune here, since it's guaranteed all alternatives will have the same type
     1074                // (giving the alternatives different types is half of the point of ConstructorExpr nodes)
     1075                finder.findWithAdjustment( ctorExpr->get_callExpr(), false );
     1076                for ( Alternative & alt : finder.alternatives ) {
     1077                        alternatives.push_back( Alternative( new ConstructorExpr( alt.expr->clone() ), alt.env, alt.cost ) );
     1078                }
     1079        }
    10691080} // namespace ResolvExpr
    10701081
  • src/ResolvExpr/AlternativeFinder.h

    rf5e81d1 radd7117  
    2929          public:
    3030                AlternativeFinder( const SymTab::Indexer &indexer, const TypeEnvironment &env );
    31                 void find( Expression *expr, bool adjust = false );
     31                void find( Expression *expr, bool adjust = false, bool prune = true );
    3232                /// Calls find with the adjust flag set; adjustment turns array and function types into equivalent pointer types
    33                 void findWithAdjustment( Expression *expr );
     33                void findWithAdjustment( Expression *expr, bool prune = true );
    3434                AltList &get_alternatives() { return alternatives; }
    3535
     
    6666                virtual void visit( TupleExpr *tupleExpr );
    6767                virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr );
     68                virtual void visit( ConstructorExpr * ctorExpr );
    6869          public:  // xxx - temporary hack - should make Tuples::TupleAssignment a friend
    6970          /// Runs a new alternative finder on each element in [begin, end)
     
    7475          private:
    7576                /// Adds alternatives for member expressions, given the aggregate, conversion cost for that aggregate, and name of the member
    76                 template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, Expression * member );
     77                template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member );
    7778                /// Adds alternatives for offsetof expressions, given the base type and name of the member
    7879                template< typename StructOrUnionType > void addOffsetof( StructOrUnionType *aggInst, const std::string &name );
  • src/SymTab/Validate.cc

    rf5e81d1 radd7117  
    6060#include "ResolvExpr/typeops.h"
    6161#include <algorithm>
     62#include "InitTweak/InitTweak.h"
    6263
    6364#define debugPrint( x ) if ( doDebug ) { std::cout << x; }
     
    171172        };
    172173
    173         class VerifyCtorDtor : public Visitor {
     174        class VerifyCtorDtorAssign : public Visitor {
    174175        public:
    175                 /// ensure that constructors and destructors have at least one
    176                 /// parameter, the first of which must be a pointer, and no
     176                /// ensure that constructors, destructors, and assignment have at least one
     177                /// parameter, the first of which must be a pointer, and that ctor/dtors have no
    177178                /// return values.
    178179                static void verify( std::list< Declaration * > &translationUnit );
     
    202203                compoundliteral.mutateDeclarationList( translationUnit );
    203204                acceptAll( translationUnit, pass3 );
    204                 VerifyCtorDtor::verify( translationUnit );
     205                VerifyCtorDtorAssign::verify( translationUnit );
    205206        }
    206207
     
    687688        }
    688689
    689         void VerifyCtorDtor::verify( std::list< Declaration * > & translationUnit ) {
    690                 VerifyCtorDtor verifier;
     690        void VerifyCtorDtorAssign::verify( std::list< Declaration * > & translationUnit ) {
     691                VerifyCtorDtorAssign verifier;
    691692                acceptAll( translationUnit, verifier );
    692693        }
    693694
    694         void VerifyCtorDtor::visit( FunctionDecl * funcDecl ) {
     695        void VerifyCtorDtorAssign::visit( FunctionDecl * funcDecl ) {
    695696                FunctionType * funcType = funcDecl->get_functionType();
    696697                std::list< DeclarationWithType * > &returnVals = funcType->get_returnVals();
    697698                std::list< DeclarationWithType * > &params = funcType->get_parameters();
    698699
    699                 if ( funcDecl->get_name() == "?{}" || funcDecl->get_name() == "^?{}" ) {
     700                if ( InitTweak::isCtorDtorAssign( funcDecl->get_name() ) ) {
    700701                        if ( params.size() == 0 ) {
    701                                 throw SemanticError( "Constructors and destructors require at least one parameter ", funcDecl );
     702                                throw SemanticError( "Constructors, destructors, and assignment functions require at least one parameter ", funcDecl );
    702703                        }
    703704                        if ( ! dynamic_cast< PointerType * >( params.front()->get_type() ) ) {
    704                                 throw SemanticError( "First parameter of a constructor or destructor must be a pointer ", funcDecl );
     705                                throw SemanticError( "First parameter of a constructor, destructor, or assignment function must be a pointer ", funcDecl );
    705706                        }
    706                         if ( returnVals.size() != 0 ) {
     707                        if ( InitTweak::isCtorDtor( funcDecl->get_name() ) && returnVals.size() != 0 ) {
    707708                                throw SemanticError( "Constructors and destructors cannot have explicit return values ", funcDecl );
    708709                        }
  • src/SynTree/Expression.cc

    rf5e81d1 radd7117  
    2828#include "TypeSubstitution.h"
    2929#include "Common/utility.h"
     30#include "InitTweak/InitTweak.h"
    3031
    3132
     
    496497
    497498void ImplicitCopyCtorExpr::print( std::ostream &os, int indent ) const {
    498         os << std::string( indent, ' ' ) << "Implicit Copy Constructor Expression: " << std::endl;
     499        os << "Implicit Copy Constructor Expression: " << std::endl;
    499500        assert( callExpr );
    500501        callExpr->print( os, indent + 2 );
     
    506507}
    507508
     509
     510ConstructorExpr::ConstructorExpr( Expression * callExpr ) : callExpr( callExpr ) {
     511        // allow resolver to type a constructor used as an expression as if it has the same type as its first argument
     512        assert( callExpr );
     513        Expression * arg = InitTweak::getCallArg( callExpr, 0 );
     514        assert( arg );
     515        cloneAll( arg->get_results(), results );
     516}
     517
     518ConstructorExpr::ConstructorExpr( const ConstructorExpr & other ) : Expression( other ), callExpr( maybeClone( other.callExpr ) ) {
     519}
     520
     521ConstructorExpr::~ConstructorExpr() {
     522        delete callExpr;
     523}
     524
     525void ConstructorExpr::print( std::ostream &os, int indent ) const {
     526        os <<  "Constructor Expression: " << std::endl;
     527        assert( callExpr );
     528        os << std::string( indent+2, ' ' );
     529        callExpr->print( os, indent + 2 );
     530        Expression::print( os, indent );
     531}
     532
     533
     534CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : type( type ), initializer( initializer ) {
     535        add_result( type->clone() );
     536}
     537
     538CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), type( maybeClone( other.type ) ), initializer( maybeClone( other.initializer ) ) {}
     539
     540CompoundLiteralExpr::~CompoundLiteralExpr() {
     541        delete initializer;
     542        delete type;
     543}
     544
     545void CompoundLiteralExpr::print( std::ostream &os, int indent ) const {
     546        os << "Compound Literal Expression: " << std::endl;
     547        if ( type ) type->print( os, indent + 2 );
     548        if ( initializer ) initializer->print( os, indent + 2 );
     549}
     550
    508551UntypedValofExpr::UntypedValofExpr( const UntypedValofExpr & other ) : Expression( other ), body ( maybeClone( other.body ) ) {}
    509552
     
    514557        if ( get_body() != 0 )
    515558                get_body()->print( os, indent + 2 );
    516 }
    517 
    518 
    519 CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : type( type ), initializer( initializer ) {
    520         add_result( type->clone() );
    521 }
    522 
    523 CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), type( maybeClone( other.type ) ), initializer( maybeClone( other.initializer ) ) {}
    524 
    525 CompoundLiteralExpr::~CompoundLiteralExpr() {
    526         delete initializer;
    527         delete type;
    528 }
    529 
    530 void CompoundLiteralExpr::print( std::ostream &os, int indent ) const {
    531         os << "Compound Literal Expression: " << std::endl;
    532         if ( type ) type->print( os, indent + 2 );
    533         if ( initializer ) initializer->print( os, indent + 2 );
    534559}
    535560
  • src/SynTree/Expression.h

    rf5e81d1 radd7117  
    595595};
    596596
     597/// ConstructorExpr represents the use of a constructor in an expression context, e.g. int * x = malloc() { 5 };
     598class ConstructorExpr : public Expression {
     599public:
     600        ConstructorExpr( Expression * callExpr );
     601        ConstructorExpr( const ConstructorExpr & other );
     602        ~ConstructorExpr();
     603
     604        Expression *get_callExpr() const { return callExpr; }
     605        void set_callExpr( Expression *newValue ) { callExpr = newValue; }
     606
     607        virtual ConstructorExpr *clone() const { return new ConstructorExpr( *this ); }
     608        virtual void accept( Visitor &v ) { v.visit( this ); }
     609        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     610        virtual void print( std::ostream &os, int indent = 0 ) const;
     611private:
     612        Expression * callExpr;
     613};
     614
     615/// CompoundLiteralExpr represents a C99 'compound literal'
     616class CompoundLiteralExpr : public Expression {
     617  public:
     618        CompoundLiteralExpr( Type * type, Initializer * initializer );
     619        CompoundLiteralExpr( const CompoundLiteralExpr &other );
     620        virtual ~CompoundLiteralExpr();
     621
     622        Type * get_type() const { return type; }
     623        void set_type( Type * t ) { type = t; }
     624
     625        Initializer * get_initializer() const { return initializer; }
     626        void set_initializer( Initializer * i ) { initializer = i; }
     627
     628        virtual CompoundLiteralExpr *clone() const { return new CompoundLiteralExpr( *this ); }
     629        virtual void accept( Visitor &v ) { v.visit( this ); }
     630        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     631        virtual void print( std::ostream &os, int indent = 0 ) const;
     632  private:
     633        Type * type;
     634        Initializer * initializer;
     635};
     636
    597637/// ValofExpr represents a GCC 'lambda expression'
    598638class UntypedValofExpr : public Expression {
     
    613653};
    614654
    615 /// CompoundLiteralExpr represents a C99 'compound literal'
    616 class CompoundLiteralExpr : public Expression {
    617   public:
    618         CompoundLiteralExpr( Type * type, Initializer * initializer );
    619         CompoundLiteralExpr( const CompoundLiteralExpr &other );
    620         virtual ~CompoundLiteralExpr();
    621 
    622         Type * get_type() const { return type; }
    623         void set_type( Type * t ) { type = t; }
    624 
    625         Initializer * get_initializer() const { return initializer; }
    626         void set_initializer( Initializer * i ) { initializer = i; }
    627 
    628         virtual CompoundLiteralExpr *clone() const { return new CompoundLiteralExpr( *this ); }
    629         virtual void accept( Visitor &v ) { v.visit( this ); }
    630         virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    631         virtual void print( std::ostream &os, int indent = 0 ) const;
    632   private:
    633         Type * type;
    634         Initializer * initializer;
    635 };
    636 
     655/// RangeExpr represents a range e.g. '3 ... 5' or '1~10'
    637656class RangeExpr : public Expression {
    638657  public:
  • src/SynTree/Mutator.cc

    rf5e81d1 radd7117  
    340340}
    341341
    342 Expression *Mutator::mutate( UntypedValofExpr *valofExpr ) {
    343         mutateAll( valofExpr->get_results(), *this );
    344         return valofExpr;
     342Expression* Mutator::mutate( ConstructorExpr *ctorExpr ) {
     343        mutateAll( ctorExpr->get_results(), *this );
     344        ctorExpr->set_callExpr( maybeMutate( ctorExpr->get_callExpr(), *this ) );
     345        return ctorExpr;
    345346}
    346347
     
    350351        compLitExpr->set_initializer( maybeMutate( compLitExpr->get_initializer(), *this ) );
    351352        return compLitExpr;
     353}
     354
     355Expression *Mutator::mutate( UntypedValofExpr *valofExpr ) {
     356        mutateAll( valofExpr->get_results(), *this );
     357        return valofExpr;
    352358}
    353359
  • src/SynTree/Mutator.h

    rf5e81d1 radd7117  
    7676        virtual Expression* mutate( AsmExpr *asmExpr );
    7777        virtual Expression* mutate( ImplicitCopyCtorExpr *impCpCtorExpr );
     78        virtual Expression* mutate( ConstructorExpr *ctorExpr );
     79        virtual Expression* mutate( CompoundLiteralExpr *compLitExpr );
    7880        virtual Expression* mutate( UntypedValofExpr *valofExpr );
    79         virtual Expression* mutate( CompoundLiteralExpr *compLitExpr );
    8081        virtual Expression* mutate( RangeExpr *rangeExpr );
    8182        virtual Expression* mutate( TupleIndexExpr *tupleExpr );
  • src/SynTree/SynTree.h

    rf5e81d1 radd7117  
    8181class AsmExpr;
    8282class ImplicitCopyCtorExpr;
     83class ConstructorExpr;
     84class CompoundLiteralExpr;
    8385class UntypedValofExpr;
    84 class CompoundLiteralExpr;
    8586class RangeExpr;
    8687class TupleIndexExpr;
  • src/SynTree/Visitor.cc

    rf5e81d1 radd7117  
    288288}
    289289
    290 void Visitor::visit( UntypedValofExpr *valofExpr ) {
    291         acceptAll( valofExpr->get_results(), *this );
    292         maybeAccept( valofExpr->get_body(), *this );
     290void Visitor::visit( ConstructorExpr * ctorExpr ) {
     291        acceptAll( ctorExpr->get_results(), *this );
     292        maybeAccept( ctorExpr->get_callExpr(), *this );
    293293}
    294294
     
    297297        maybeAccept( compLitExpr->get_type(), *this );
    298298        maybeAccept( compLitExpr->get_initializer(), *this );
     299}
     300
     301void Visitor::visit( UntypedValofExpr *valofExpr ) {
     302        acceptAll( valofExpr->get_results(), *this );
     303        maybeAccept( valofExpr->get_body(), *this );
    299304}
    300305
  • src/SynTree/Visitor.h

    rf5e81d1 radd7117  
    7676        virtual void visit( AsmExpr *asmExpr );
    7777        virtual void visit( ImplicitCopyCtorExpr *impCpCtorExpr );
     78        virtual void visit( ConstructorExpr * ctorExpr );
     79        virtual void visit( CompoundLiteralExpr *compLitExpr );
    7880        virtual void visit( UntypedValofExpr *valofExpr );
    79         virtual void visit( CompoundLiteralExpr *compLitExpr );
    8081        virtual void visit( RangeExpr *rangeExpr );
    8182        virtual void visit( TupleIndexExpr *tupleExpr );
  • src/include/assert.h

    rf5e81d1 radd7117  
    2222#define assertf(expr, fmt, ...) ((expr) ? static_cast<void>(0) : __assert_fail_f(__VSTRINGIFY__(expr), __FILE__, __LINE__, __PRETTY_FUNCTION__, fmt, ## __VA_ARGS__ ))
    2323
    24 void __assert_fail_f( const char *assertion, const char *file, unsigned int line, const char *function, const char *fmt, ... );
     24void __assert_fail_f( const char *assertion, const char *file, unsigned int line, const char *function, const char *fmt, ... ) __attribute__((noreturn));
    2525
    2626template<typename T, typename U>
  • src/libcfa/prelude.cf

    rf5e81d1 radd7117  
    636636
    637637// default ctor
    638 void    ?{}( _Bool * ),                         ?{}( volatile _Bool * );
    639 void    ?{}( char * ),  ?{}( volatile char * );
    640 void    ?{}( unsigned char * ), ?{}( volatile unsigned char * );
    641 void    ?{}( char signed * ),                   ?{}( volatile char signed * );
    642 void    ?{}( int short * ),                             ?{}( volatile int short * );
    643 void    ?{}( int short unsigned * ),    ?{}( volatile int short unsigned * );
    644 void    ?{}( signed int * ),                    ?{}( volatile signed int * );
    645 void    ?{}( unsigned int * ),                  ?{}( volatile unsigned int * );
    646 void    ?{}( signed long int * ),               ?{}( volatile signed long int * );
    647 void    ?{}( unsigned long int * ),             ?{}( volatile unsigned long int * );
    648 void    ?{}( signed long long int * ),          ?{}( volatile signed long long int * );
    649 void    ?{}( unsigned long long int * ),        ?{}( volatile unsigned long long int * );
    650 void    ?{}( float * ),                         ?{}( volatile float * );
    651 void    ?{}( double * ),                        ?{}( volatile double * );
    652 void    ?{}( long double * ),                   ?{}( volatile long double * );
    653 void    ?{}( float _Complex * ),                ?{}( volatile float _Complex * );
    654 void    ?{}( double _Complex * ),               ?{}( volatile double _Complex * );
    655 void    ?{}( long double _Complex * ),          ?{}( volatile long double _Complex * );
     638void    ?{}( _Bool * );
     639void    ?{}( char * );
     640void    ?{}( unsigned char * );
     641void    ?{}( char signed * );
     642void    ?{}( int short * );
     643void    ?{}( int short unsigned * );
     644void    ?{}( signed int * );
     645void    ?{}( unsigned int * );
     646void    ?{}( signed long int * );
     647void    ?{}( unsigned long int * );
     648void    ?{}( signed long long int * );
     649void    ?{}( unsigned long long int * );
     650void    ?{}( float * );
     651void    ?{}( double * );
     652void    ?{}( long double * );
     653void    ?{}( float _Complex * );
     654void    ?{}( double _Complex * );
     655void    ?{}( long double _Complex * );
    656656
    657657// copy ctor
    658 void    ?{}( _Bool *, _Bool ),                                  ?{}( volatile _Bool *, _Bool );
    659 void    ?{}( char *, char ),    ?{}( volatile char *, char );
    660 void    ?{}( unsigned char *, unsigned char ),                  ?{}( volatile unsigned char *, unsigned char );
    661 void    ?{}( char signed *, char signed ),                      ?{}( volatile char signed *, char signed );
    662 void    ?{}( int short *, int short ),                          ?{}( volatile int short *, int short );
    663 void    ?{}( int short unsigned *, int short unsigned ),        ?{}( volatile int short unsigned *, int short unsigned );
    664 void    ?{}( signed int *, signed int),                         ?{}( volatile signed int *, signed int );
    665 void    ?{}( unsigned int *, unsigned int),                     ?{}( volatile unsigned int *, unsigned int );
    666 void    ?{}( signed long int *, signed long int),               ?{}( volatile signed long int *, signed long int );
    667 void    ?{}( unsigned long int *, unsigned long int),           ?{}( volatile unsigned long int *, unsigned long int );
    668 void    ?{}( signed long long int *, signed long long int),     ?{}( volatile signed long long int *, signed long long int );
    669 void    ?{}( unsigned long long int *, unsigned long long int), ?{}( volatile unsigned long long int *, unsigned long long int );
    670 void    ?{}( float *, float),                                   ?{}( volatile float *, float );
    671 void    ?{}( double *, double),                                 ?{}( volatile double *, double );
    672 void    ?{}( long double *, long double),                       ?{}( volatile long double *, long double );
    673 void    ?{}( float _Complex *, float _Complex),                 ?{}( volatile float _Complex *, float _Complex );
    674 void    ?{}( double _Complex *, double _Complex),               ?{}( volatile double _Complex *, double _Complex );
    675 void    ?{}( long double _Complex *, long double _Complex),     ?{}( volatile long double _Complex *, long double _Complex );
     658void    ?{}( _Bool *, _Bool );
     659void    ?{}( char *, char );
     660void    ?{}( unsigned char *, unsigned char );
     661void    ?{}( char signed *, char signed );
     662void    ?{}( int short *, int short );
     663void    ?{}( int short unsigned *, int short unsigned );
     664void    ?{}( signed int *, signed int);
     665void    ?{}( unsigned int *, unsigned int);
     666void    ?{}( signed long int *, signed long int);
     667void    ?{}( unsigned long int *, unsigned long int);
     668void    ?{}( signed long long int *, signed long long int);
     669void    ?{}( unsigned long long int *, unsigned long long int);
     670void    ?{}( float *, float);
     671void    ?{}( double *, double);
     672void    ?{}( long double *, long double);
     673void    ?{}( float _Complex *, float _Complex);
     674void    ?{}( double _Complex *, double _Complex);
     675void    ?{}( long double _Complex *, long double _Complex);
    676676
    677677// dtor
    678 void    ^?{}( _Bool * ),                        ^?{}( volatile _Bool * );
    679 void    ^?{}( char * ), ^?{}( volatile char * );
    680 void    ^?{}( char unsigned * ),                        ^?{}( volatile char unsigned * );
    681 void    ^?{}( char signed * ),                  ^?{}( volatile char signed * );
    682 void    ^?{}( int short * ),                            ^?{}( volatile int short * );
    683 void    ^?{}( int short unsigned * ),   ^?{}( volatile int short unsigned * );
    684 void    ^?{}( signed int * ),                   ^?{}( volatile signed int * );
    685 void    ^?{}( unsigned int * ),                 ^?{}( volatile unsigned int * );
    686 void    ^?{}( signed long int * ),              ^?{}( volatile signed long int * );
    687 void    ^?{}( unsigned long int * ),            ^?{}( volatile unsigned long int * );
    688 void    ^?{}( signed long long int * ),         ^?{}( volatile signed long long int * );
    689 void    ^?{}( unsigned long long int * ),       ^?{}( volatile unsigned long long int * );
    690 void    ^?{}( float * ),                        ^?{}( volatile float * );
    691 void    ^?{}( double * ),                       ^?{}( volatile double * );
    692 void    ^?{}( long double * ),                  ^?{}( volatile long double * );
    693 void    ^?{}( float _Complex * ),               ^?{}( volatile float _Complex * );
    694 void    ^?{}( double _Complex * ),              ^?{}( volatile double _Complex * );
    695 void    ^?{}( long double _Complex * ),         ^?{}( volatile long double _Complex * );
     678void    ^?{}( _Bool * );
     679void    ^?{}( char * );
     680void    ^?{}( char unsigned * );
     681void    ^?{}( char signed * );
     682void    ^?{}( int short * );
     683void    ^?{}( int short unsigned * );
     684void    ^?{}( signed int * );
     685void    ^?{}( unsigned int * );
     686void    ^?{}( signed long int * );
     687void    ^?{}( unsigned long int * );
     688void    ^?{}( signed long long int * );
     689void    ^?{}( unsigned long long int * );
     690void    ^?{}( float * );
     691void    ^?{}( double * );
     692void    ^?{}( long double * );
     693void    ^?{}( float _Complex * );
     694void    ^?{}( double _Complex * );
     695void    ^?{}( long double _Complex * );
    696696
    697697// // default ctor
     
    719719
    720720forall( dtype DT ) void ?{}(                 DT *          *,                   DT * );
    721 forall( dtype DT ) void ?{}(                 DT * volatile *,                   DT * );
    722721forall( dtype DT ) void ?{}( const           DT *          *,                   DT * );
    723 forall( dtype DT ) void ?{}( const           DT * volatile *,                   DT * );
    724722forall( dtype DT ) void ?{}( const           DT *          *, const             DT * );
    725 forall( dtype DT ) void ?{}( const           DT * volatile *, const             DT * );
    726723forall( dtype DT ) void ?{}(       volatile  DT *          *,                   DT * );
    727 forall( dtype DT ) void ?{}(       volatile  DT * volatile *,                   DT * );
    728724forall( dtype DT ) void ?{}(       volatile  DT *          *,       volatile    DT * );
    729 forall( dtype DT ) void ?{}(       volatile  DT * volatile *,       volatile    DT * );
    730725
    731726forall( dtype DT ) void ?{}( const volatile  DT *          *,                   DT * );
    732 forall( dtype DT ) void ?{}( const volatile  DT * volatile *,                   DT * );
    733727forall( dtype DT ) void ?{}( const volatile  DT *          *, const             DT * );
    734 forall( dtype DT ) void ?{}( const volatile  DT * volatile *, const             DT * );
    735728forall( dtype DT ) void ?{}( const volatile  DT *          *,       volatile    DT * );
    736 forall( dtype DT ) void ?{}( const volatile  DT * volatile *,       volatile    DT * );
    737729forall( dtype DT ) void ?{}( const volatile  DT *          *, const volatile    DT * );
    738 forall( dtype DT ) void ?{}( const volatile  DT * volatile *, const volatile    DT * );
    739730
    740731forall( dtype DT ) void ?{}(                 DT *          *,                   void * );
    741 forall( dtype DT ) void ?{}(                 DT * volatile *,                   void * );
    742732forall( dtype DT ) void ?{}( const           DT *          *,                   void * );
    743 forall( dtype DT ) void ?{}( const           DT * volatile *,                   void * );
    744733forall( dtype DT ) void ?{}( const           DT *          *, const             void * );
    745 forall( dtype DT ) void ?{}( const           DT * volatile *, const             void * );
    746734forall( dtype DT ) void ?{}(       volatile  DT *          *,                   void * );
    747 forall( dtype DT ) void ?{}(       volatile  DT * volatile *,                   void * );
    748735forall( dtype DT ) void ?{}(       volatile  DT *          *,       volatile    void * );
    749 forall( dtype DT ) void ?{}(       volatile  DT * volatile *,       volatile    void * );
    750736
    751737forall( dtype DT ) void ?{}( const volatile  DT *          *,                   void * );
    752 forall( dtype DT ) void ?{}( const volatile  DT * volatile *,                   void * );
    753738forall( dtype DT ) void ?{}( const volatile  DT *          *, const             void * );
    754 forall( dtype DT ) void ?{}( const volatile  DT * volatile *, const             void * );
    755739forall( dtype DT ) void ?{}( const volatile  DT *          *,       volatile    void * );
    756 forall( dtype DT ) void ?{}( const volatile  DT * volatile *,       volatile    void * );
    757740forall( dtype DT ) void ?{}( const volatile  DT *          *, const volatile    void * );
    758 forall( dtype DT ) void ?{}( const volatile  DT * volatile *, const volatile    void * );
    759741
    760742forall( dtype DT ) void ?{}(                 void *          *,                 DT * );
    761 forall( dtype DT ) void ?{}(                 void * volatile *,                 DT * );
    762743forall( dtype DT ) void ?{}( const           void *          *,                 DT * );
    763 forall( dtype DT ) void ?{}( const           void * volatile *,                 DT * );
    764744forall( dtype DT ) void ?{}( const           void *          *, const           DT * );
    765 forall( dtype DT ) void ?{}( const           void * volatile *, const           DT * );
    766745forall( dtype DT ) void ?{}(        volatile void *          *,                 DT * );
    767 forall( dtype DT ) void ?{}(        volatile void * volatile *,                 DT * );
    768746forall( dtype DT ) void ?{}(        volatile void *          *,       volatile  DT * );
    769 forall( dtype DT ) void ?{}(        volatile void * volatile *,       volatile  DT * );
    770747forall( dtype DT ) void ?{}( const volatile void *           *,                 DT * );
    771 forall( dtype DT ) void ?{}( const volatile void * volatile *,                  DT * );
    772748forall( dtype DT ) void ?{}( const volatile void *           *, const           DT * );
    773 forall( dtype DT ) void ?{}( const volatile void * volatile *, const            DT * );
    774749forall( dtype DT ) void ?{}( const volatile void *           *,       volatile  DT * );
    775 forall( dtype DT ) void ?{}( const volatile void * volatile *,        volatile  DT * );
    776750forall( dtype DT ) void ?{}( const volatile void *           *, const volatile  DT * );
    777 forall( dtype DT ) void ?{}( const volatile void * volatile *, const volatile   DT * );
    778751
    779752void    ?{}(                void *          *,                void * );
    780 void    ?{}(                void * volatile *,                void * );
    781753void    ?{}( const          void *          *,                void * );
    782 void    ?{}( const          void * volatile *,                void * );
    783754void    ?{}( const          void *          *, const          void * );
    784 void    ?{}( const          void * volatile *, const          void * );
    785755void    ?{}(       volatile void *          *,                void * );
    786 void    ?{}(       volatile void * volatile *,                void * );
    787756void    ?{}(       volatile void *          *,       volatile void * );
    788 void    ?{}(       volatile void * volatile *,       volatile void * );
    789757void    ?{}( const volatile void *          *,                void * );
    790 void    ?{}( const volatile void * volatile *,                void * );
    791758void    ?{}( const volatile void *          *, const          void * );
    792 void    ?{}( const volatile void * volatile *, const          void * );
    793759void    ?{}( const volatile void *          *,       volatile void * );
    794 void    ?{}( const volatile void * volatile *,       volatile void * );
    795760void    ?{}( const volatile void *          *, const volatile void * );
    796 void    ?{}( const volatile void * volatile *, const volatile void * );
    797761
    798762//forall( dtype DT ) void ?{}(              DT *          *, forall( dtype DT2 ) const DT2 * );
    799763//forall( dtype DT ) void ?{}(              DT * volatile *, forall( dtype DT2 ) const DT2 * );
    800764forall( dtype DT ) void ?{}( const          DT *          *, forall( dtype DT2 ) const DT2 * );
    801 forall( dtype DT ) void ?{}( const          DT * volatile *, forall( dtype DT2 ) const DT2 * );
    802765//forall( dtype DT ) void ?{}( volatile     DT *          *, forall( dtype DT2 ) const DT2 * );
    803766//forall( dtype DT ) void ?{}( volatile     DT * volatile *, forall( dtype DT2 ) const DT2 * );
    804767forall( dtype DT ) void ?{}( const volatile DT *          *, forall( dtype DT2 ) const DT2 * );
    805 forall( dtype DT ) void ?{}( const volatile DT * volatile *, forall( dtype DT2 ) const DT2 * );
    806768
    807769forall( ftype FT ) void ?{}( FT *          *, forall( ftype FT2 ) FT2 * );
    808 forall( ftype FT ) void ?{}( FT * volatile *, forall( ftype FT2 ) FT2 * );
    809770
    810771// default ctors
    811772forall( ftype FT ) void ?{}( FT *          * );
    812 forall( ftype FT ) void ?{}( FT * volatile * );
    813773
    814774forall( dtype DT ) void ?{}(                 DT *          *);
    815 forall( dtype DT ) void ?{}(                 DT * volatile *);
    816775forall( dtype DT ) void ?{}( const           DT *          *);
    817 forall( dtype DT ) void ?{}( const           DT * volatile *);
    818776forall( dtype DT ) void ?{}(       volatile  DT *          *);
    819 forall( dtype DT ) void ?{}(       volatile  DT * volatile *);
    820777forall( dtype DT ) void ?{}( const volatile  DT *          *);
    821 forall( dtype DT ) void ?{}( const volatile  DT * volatile *);
    822778
    823779void    ?{}(                void *          *);
    824 void    ?{}(                void * volatile *);
    825780void    ?{}( const          void *          *);
    826 void    ?{}( const          void * volatile *);
    827781void    ?{}(       volatile void *          *);
    828 void    ?{}(       volatile void * volatile *);
    829782void    ?{}( const volatile void *          *);
    830 void    ?{}( const volatile void * volatile *);
    831783
    832784// dtors
    833785forall( ftype FT ) void ^?{}( FT *         * );
    834 forall( ftype FT ) void ^?{}( FT * volatile * );
    835786
    836787forall( dtype DT ) void ^?{}(                DT *          *);
    837 forall( dtype DT ) void ^?{}(                DT * volatile *);
    838788forall( dtype DT ) void ^?{}( const          DT *          *);
    839 forall( dtype DT ) void ^?{}( const          DT * volatile *);
    840789forall( dtype DT ) void ^?{}(      volatile  DT *          *);
    841 forall( dtype DT ) void ^?{}(      volatile  DT * volatile *);
    842790forall( dtype DT ) void ^?{}( const volatile  DT *         *);
    843 forall( dtype DT ) void ^?{}( const volatile  DT * volatile *);
    844791
    845792void    ^?{}(               void *          *);
    846 void    ^?{}(               void * volatile *);
    847793void    ^?{}( const         void *          *);
    848 void    ^?{}( const         void * volatile *);
    849794void    ^?{}(      volatile void *          *);
    850 void    ^?{}(      volatile void * volatile *);
    851795void    ^?{}( const volatile void *         *);
    852 void    ^?{}( const volatile void * volatile *);
    853796
    854797// Local Variables: //
  • src/tests/.expect/declarationErrors.txt

    rf5e81d1 radd7117  
    11CFA Version 1.0.0 (debug)
    2 Error: invalid combination of storage classes in declaration of x9: static const volatile short int
     2Error: duplicate static in declaration of x1: static const volatile short int
    33
    4 Error: invalid combination of storage classes in declaration of x18: static const volatile instance of const volatile struct __anonymous0
     4Error: multiple extern & static in declaration of x2: extern const volatile short int
     5
     6Error: multiple extern & auto, multiple extern & static, multiple extern & static, duplicate extern in declaration of x3: extern const volatile short int
     7
     8Error: duplicate static in declaration of x4: static const volatile instance of const volatile struct __anonymous0
    59  with members
    610   with body
    711
    812
    9 Error: duplicate qualifier volatile in declaration of x19: static const volatile instance of const volatile struct __anonymous1
     13Error: duplicate const, duplicate static, duplicate volatile in declaration of x5: static const volatile instance of const volatile struct __anonymous1
    1014  with members
    1115   with body
    1216
    1317
    14 Error: invalid combination of storage classes in declaration of x28: static const volatile instance of type Int
     18Error: duplicate static in declaration of x6: static const volatile instance of type Int
    1519
    16 Error: duplicate qualifier const in declaration of f01: static inline function
     20Error: duplicate const in declaration of f01: static inline function
    1721  with no parameters
    1822  returning const volatile int
    1923
    2024
    21 Error: duplicate qualifier volatile in declaration of f02: static inline function
     25Error: duplicate volatile in declaration of f02: static inline function
    2226  with no parameters
    2327  returning const volatile int
    2428
    2529
    26 Error: duplicate qualifier const in declaration of f03: static inline function
     30Error: duplicate const in declaration of f03: static inline function
    2731  with no parameters
    2832  returning const volatile int
    2933
    3034
    31 Error: duplicate qualifier volatile in declaration of f04: static inline function
     35Error: duplicate volatile in declaration of f04: static inline function
    3236  with no parameters
    3337  returning const volatile int
    3438
    3539
    36 Error: duplicate qualifier const in declaration of f05: static inline function
     40Error: duplicate const in declaration of f05: static inline function
    3741  with no parameters
    3842  returning const volatile int
    3943
    4044
    41 Error: duplicate qualifier volatile in declaration of f06: static inline function
     45Error: duplicate volatile in declaration of f06: static inline function
    4246  with no parameters
    4347  returning const volatile int
    4448
    4549
    46 Error: duplicate qualifier const in declaration of f07: static inline function
     50Error: duplicate const in declaration of f07: static inline function
    4751  with no parameters
    4852  returning const volatile int
    4953
    5054
    51 Error: duplicate qualifier const, volatile in declaration of f08: static inline function
     55Error: duplicate const, duplicate volatile in declaration of f08: static inline function
    5256  with no parameters
    5357  returning const volatile int
    5458
    5559
    56 Error: duplicate qualifier const, volatile in declaration of f09: static inline function
     60Error: duplicate const, duplicate volatile in declaration of f09: static inline function
    5761  with no parameters
    5862  returning const volatile int
    5963
    6064
    61 Error: duplicate qualifier const, volatile in declaration of f09: static inline function
     65Error: duplicate const, duplicate _Atomic, duplicate _Atomic, duplicate const, duplicate restrict, duplicate volatile in declaration of f09: static inline function
    6266  with no parameters
    63   returning const volatile int
     67  returning const restrict volatile _Atomic int
    6468
    6569
  • src/tests/declarationErrors.c

    rf5e81d1 radd7117  
    1010// Created On       : Wed Aug 17 08:23:43 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug 25 18:16:40 2016
    13 // Update Count     : 5
     12// Last Modified On : Fri Sep  9 22:57:52 2016
     13// Update Count     : 31
    1414//
    1515
    16 static short int volatile static const x9;                              // duplicate static
    17 struct { int i; } const static volatile static x18;             // duplicate static
    18 struct { int i; } const static volatile static volatile x19; // duplicate static & volatile
     16static short int volatile static const x1;                              // duplicate static
     17extern short int static volatile const x2;                              // multiple extern & static
     18extern short int auto static volatile static extern const x3; // duplicate and multiple storage classes
     19struct { int i; } const static volatile static x4;              // duplicate static
     20struct { int i; } const static volatile const static volatile x5; // duplicate static & const & volatile
    1921typedef int Int;
    20 static Int volatile static const x28;                                   // duplicate static
     22static Int volatile static const x6;                                    // duplicate static
    2123
    2224const static inline const volatile int f01();                   // duplicate const
     
    2426const inline const volatile int static f03();                   // duplicate const
    2527volatile inline static const volatile int f04();                // duplicate volatile
    26 const static const inline volatile int f05();                   // duplicate const
    27 volatile static const volatile inline int f06();                // duplicate volatile
    28 const static const volatile int inline f07();                   // duplicate const
    29 volatile static const int inline const volatile f08();          // duplicate volatile
     28const static int const inline volatile f05();                   // duplicate const
     29volatile int static const volatile inline f06();                // duplicate volatile
     30const static const int volatile inline f07();                   // duplicate const
     31volatile static const int inline const volatile f08();  // duplicate volatile
    3032
    31 volatile static const int inline const volatile f09();          // duplicate volatile
    32 volatile static const int inline const volatile f09();          // duplicate volatile
     33volatile static const int inline const volatile f09();  // duplicate volatile
     34_Atomic _Atomic _Atomic volatile restrict static const const int inline restrict const volatile f09();  // duplicate volatile
    3335
    3436//Dummy main
  • src/tests/test.py

    rf5e81d1 radd7117  
    285285# check if the user already passed in a number of jobs for multi-threading
    286286make_flags = environ.get('MAKEFLAGS')
    287 make_has_max_jobs = re.search("(-j|--jobs)\s*([0-9]+)", make_flags) if make_flags else None
    288 make_max_jobs = make_has_max_jobs.group(2) if make_has_max_jobs else None
    289 make_cmd = "make" if make_flags and "-j" in make_flags else "make -j8"
     287make_jobs_fds = re.search("--jobserver-fds=\s*([0-9]+),([0-9]+)", make_flags) if make_flags else None
     288if make_jobs_fds :
     289        tokens = os.read(int(make_jobs_fds.group(1)), 1024)
     290        options.jobs = len(tokens)
     291        os.write(int(make_jobs_fds.group(2)), tokens)
    290292
    291293# make sure we have a valid number of jobs that corresponds to user input
    292 options.jobs = int(make_max_jobs) if make_max_jobs else (options.jobs if options.jobs else 1)
    293294if options.jobs <= 0 :
    294295        print('ERROR: Invalid number of jobs', file=sys.stderr)
     
    296297
    297298print('Running on %i cores' % options.jobs)
     299make_cmd = "make" if make_flags else ("make -j%i" % options.jobs)
    298300
    299301# users may want to simply list the tests
Note: See TracChangeset for help on using the changeset viewer.