Changeset 9c23f31


Ignore:
Timestamp:
Sep 24, 2016, 12:19:33 PM (5 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
3b5e3aa
Parents:
2298f728 (diff), 7ae930a (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:

fix conflicts

Files:
8 added
44 edited

Legend:

Unmodified
Added
Removed
  • src/CodeGen/GenType.cc

    r2298f728 r9c23f31  
    4242                virtual void visit( TypeInstType *typeInst );
    4343                virtual void visit( VarArgsType *varArgsType );
     44                virtual void visit( ZeroType *zeroType );
     45                virtual void visit( OneType *oneType );
    4446
    4547          private:
     
    200202        }
    201203
     204        void GenType::visit( ZeroType *zeroType ) {
     205                // ideally these wouldn't hit codegen at all, but should be safe to make them ints
     206                typeString = "int " + typeString;
     207                handleQualifiers( zeroType );
     208        }
     209
     210        void GenType::visit( OneType *oneType ) {
     211                // ideally these wouldn't hit codegen at all, but should be safe to make them ints
     212                typeString = "int " + typeString;
     213                handleQualifiers( oneType );
     214        }
     215
    202216        void GenType::handleQualifiers( Type *type ) {
    203217                if ( type->get_isConst() ) {
  • src/InitTweak/FixInit.cc

    r2298f728 r9c23f31  
    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

    r2298f728 r9c23f31  
    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        }
     
    387387                        } else if ( MemberExpr * memberExpr = dynamic_cast< MemberExpr * >( func ) ) {
    388388                                return memberExpr->get_member()->get_name();
     389                        } else if ( UntypedMemberExpr * memberExpr = dynamic_cast< UntypedMemberExpr * > ( func ) ) {
     390                                return memberExpr->get_member();
    389391                        } else {
    390                                 assert( false && "Unexpected expression type being called as a function in call expression" );
     392                                assertf( false, "Unexpected expression type being called as a function in call expression" );
    391393                        }
    392394                }
     
    400402                } else {
    401403                        std::cerr << expr << std::endl;
    402                         assert( false && "Unexpected expression type passed to getFunctionName" );
     404                        assertf( false, "Unexpected expression type passed to getFunctionName" );
    403405                }
    404406        }
  • src/Makefile.in

    r2298f728 r9c23f31  
    165165        SynTree/driver_cfa_cpp-AttrType.$(OBJEXT) \
    166166        SynTree/driver_cfa_cpp-VarArgsType.$(OBJEXT) \
     167        SynTree/driver_cfa_cpp-ZeroOneType.$(OBJEXT) \
    167168        SynTree/driver_cfa_cpp-Constant.$(OBJEXT) \
    168169        SynTree/driver_cfa_cpp-Expression.$(OBJEXT) \
     
    390391        SynTree/ReferenceToType.cc SynTree/TupleType.cc \
    391392        SynTree/TypeofType.cc SynTree/AttrType.cc \
    392         SynTree/VarArgsType.cc SynTree/Constant.cc \
    393         SynTree/Expression.cc SynTree/TupleExpr.cc \
     393        SynTree/VarArgsType.cc SynTree/ZeroOneType.cc \
     394        SynTree/Constant.cc SynTree/Expression.cc SynTree/TupleExpr.cc \
    394395        SynTree/CommaExpr.cc SynTree/TypeExpr.cc \
    395396        SynTree/ApplicationExpr.cc SynTree/AddressExpr.cc \
     
    715716SynTree/driver_cfa_cpp-VarArgsType.$(OBJEXT): SynTree/$(am__dirstamp) \
    716717        SynTree/$(DEPDIR)/$(am__dirstamp)
     718SynTree/driver_cfa_cpp-ZeroOneType.$(OBJEXT): SynTree/$(am__dirstamp) \
     719        SynTree/$(DEPDIR)/$(am__dirstamp)
    717720SynTree/driver_cfa_cpp-Constant.$(OBJEXT): SynTree/$(am__dirstamp) \
    718721        SynTree/$(DEPDIR)/$(am__dirstamp)
     
    877880        -rm -f SynTree/driver_cfa_cpp-Visitor.$(OBJEXT)
    878881        -rm -f SynTree/driver_cfa_cpp-VoidType.$(OBJEXT)
     882        -rm -f SynTree/driver_cfa_cpp-ZeroOneType.$(OBJEXT)
    879883        -rm -f Tuples/driver_cfa_cpp-NameMatcher.$(OBJEXT)
    880884        -rm -f Tuples/driver_cfa_cpp-TupleAssignment.$(OBJEXT)
     
    982986@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-Visitor.Po@am__quote@
    983987@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-VoidType.Po@am__quote@
     988@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-ZeroOneType.Po@am__quote@
    984989@AMDEP_TRUE@@am__include@ @am__quote@Tuples/$(DEPDIR)/driver_cfa_cpp-NameMatcher.Po@am__quote@
    985990@AMDEP_TRUE@@am__include@ @am__quote@Tuples/$(DEPDIR)/driver_cfa_cpp-TupleAssignment.Po@am__quote@
     
    20642069@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    20652070@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-VarArgsType.obj `if test -f 'SynTree/VarArgsType.cc'; then $(CYGPATH_W) 'SynTree/VarArgsType.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/VarArgsType.cc'; fi`
     2071
     2072SynTree/driver_cfa_cpp-ZeroOneType.o: SynTree/ZeroOneType.cc
     2073@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-ZeroOneType.o -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-ZeroOneType.Tpo -c -o SynTree/driver_cfa_cpp-ZeroOneType.o `test -f 'SynTree/ZeroOneType.cc' || echo '$(srcdir)/'`SynTree/ZeroOneType.cc
     2074@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-ZeroOneType.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-ZeroOneType.Po
     2075@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/ZeroOneType.cc' object='SynTree/driver_cfa_cpp-ZeroOneType.o' libtool=no @AMDEPBACKSLASH@
     2076@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     2077@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-ZeroOneType.o `test -f 'SynTree/ZeroOneType.cc' || echo '$(srcdir)/'`SynTree/ZeroOneType.cc
     2078
     2079SynTree/driver_cfa_cpp-ZeroOneType.obj: SynTree/ZeroOneType.cc
     2080@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-ZeroOneType.obj -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-ZeroOneType.Tpo -c -o SynTree/driver_cfa_cpp-ZeroOneType.obj `if test -f 'SynTree/ZeroOneType.cc'; then $(CYGPATH_W) 'SynTree/ZeroOneType.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/ZeroOneType.cc'; fi`
     2081@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-ZeroOneType.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-ZeroOneType.Po
     2082@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/ZeroOneType.cc' object='SynTree/driver_cfa_cpp-ZeroOneType.obj' libtool=no @AMDEPBACKSLASH@
     2083@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     2084@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-ZeroOneType.obj `if test -f 'SynTree/ZeroOneType.cc'; then $(CYGPATH_W) 'SynTree/ZeroOneType.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/ZeroOneType.cc'; fi`
    20662085
    20672086SynTree/driver_cfa_cpp-Constant.o: SynTree/Constant.cc
  • src/Parser/parser.yy

    r2298f728 r9c23f31  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Sep 24 11:30:40 2016
    13 // Update Count     : 1991
     12// Last Modified On : Sat Sep 24 12:16:53 2016
     13// Update Count     : 1992
    1414//
    1515
     
    390390                {
    391391                        Token fn;
    392                         fn.str = new string( "?{}" );                           // location undefined
    393                         $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $1 )->set_last( $3 ) ) );
     392                        fn.str = new std::string( "?{}" );                      // location undefined - use location of '{'?
     393                        $$ = new ExpressionNode( new ConstructorExpr( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $1 )->set_last( $3 ) ) ) );
    394394                }
    395395        ;
  • src/ResolvExpr/AdjustExprType.cc

    r2298f728 r9c23f31  
    3737                virtual Type* mutate( TupleType *tupleType );
    3838                virtual Type* mutate( VarArgsType *varArgsType );
     39                virtual Type* mutate( ZeroType *zeroType );
     40                virtual Type* mutate( OneType *oneType );
    3941
    4042                const TypeEnvironment &env;
     
    117119                return varArgsType;
    118120        }
     121
     122        Type *AdjustExprType::mutate( ZeroType *zeroType ) {
     123                return zeroType;
     124        }
     125
     126        Type *AdjustExprType::mutate( OneType *oneType ) {
     127                return oneType;
     128        }
    119129} // namespace ResolvExpr
    120130
  • src/ResolvExpr/AlternativeFinder.cc

    r2298f728 r9c23f31  
    197197        }
    198198
    199         void AlternativeFinder::find( Expression *expr, bool adjust ) {
     199        void AlternativeFinder::find( Expression *expr, bool adjust, bool prune ) {
    200200                expr->accept( *this );
    201201                if ( alternatives.empty() ) {
     
    207207                        }
    208208                }
    209                 PRINT(
    210                         std::cerr << "alternatives before prune:" << std::endl;
    211                         printAlts( alternatives, std::cerr );
    212                 )
    213                 AltList::iterator oldBegin = alternatives.begin();
    214                 pruneAlternatives( alternatives.begin(), alternatives.end(), front_inserter( alternatives ), indexer );
    215                 if ( alternatives.begin() == oldBegin ) {
    216                         std::ostringstream stream;
    217                         stream << "Can't choose between alternatives for expression ";
    218                         expr->print( stream );
    219                         stream << "Alternatives are:";
    220                         AltList winners;
    221                         findMinCost( alternatives.begin(), alternatives.end(), back_inserter( winners ) );
    222                         printAlts( winners, stream, 8 );
    223                         throw SemanticError( stream.str() );
    224                 }
    225                 alternatives.erase( oldBegin, alternatives.end() );
    226                 PRINT(
    227                         std::cerr << "there are " << alternatives.size() << " alternatives after elimination" << std::endl;
    228                 )
     209                if ( prune ) {
     210                        PRINT(
     211                                std::cerr << "alternatives before prune:" << std::endl;
     212                                printAlts( alternatives, std::cerr );
     213                        )
     214                        AltList::iterator oldBegin = alternatives.begin();
     215                        pruneAlternatives( alternatives.begin(), alternatives.end(), front_inserter( alternatives ), indexer );
     216                        if ( alternatives.begin() == oldBegin ) {
     217                                std::ostringstream stream;
     218                                stream << "Can't choose between alternatives for expression ";
     219                                expr->print( stream );
     220                                stream << "Alternatives are:";
     221                                AltList winners;
     222                                findMinCost( alternatives.begin(), alternatives.end(), back_inserter( winners ) );
     223                                printAlts( winners, stream, 8 );
     224                                throw SemanticError( stream.str() );
     225                        }
     226                        alternatives.erase( oldBegin, alternatives.end() );
     227                        PRINT(
     228                                std::cerr << "there are " << alternatives.size() << " alternatives after elimination" << std::endl;
     229                        )
     230                }
    229231
    230232                // Central location to handle gcc extension keyword for all expression types.
     
    234236        }
    235237
    236         void AlternativeFinder::findWithAdjustment( Expression *expr ) {
    237                 find( expr, true );
     238        void AlternativeFinder::findWithAdjustment( Expression *expr, bool prune ) {
     239                find( expr, true, prune );
    238240        }
    239241
    240242        template< typename StructOrUnionType >
    241         void AlternativeFinder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const std::string &name ) {
     243        void AlternativeFinder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, const std::string &name ) {
    242244                std::list< Declaration* > members;
    243245                aggInst->lookup( name, members );
     
    760762                        if ( agg->expr->get_results().size() == 1 ) {
    761763                                if ( StructInstType *structInst = dynamic_cast< StructInstType* >( agg->expr->get_results().front() ) ) {
    762                                         addAggMembers( structInst, agg->expr, agg->cost, memberExpr->get_member() );
     764                                        addAggMembers( structInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
    763765                                } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( agg->expr->get_results().front() ) ) {
    764                                         addAggMembers( unionInst, agg->expr, agg->cost, memberExpr->get_member() );
     766                                        addAggMembers( unionInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
    765767                                } // if
    766768                        } // if
     
    789791                        renameTypes( alternatives.back().expr );
    790792                        if ( StructInstType *structInst = dynamic_cast< StructInstType* >( (*i)->get_type() ) ) {
    791                                 addAggMembers( structInst, &newExpr, Cost( 0, 0, 1 ), "" );
     793                                addAggMembers( structInst, &newExpr, Cost( 0, 0, 1 ), env, "" );
    792794                        } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( (*i)->get_type() ) ) {
    793                                 addAggMembers( unionInst, &newExpr, Cost( 0, 0, 1 ), "" );
     795                                addAggMembers( unionInst, &newExpr, Cost( 0, 0, 1 ), env, "" );
    794796                        } // if
    795797                } // for
     
    10121014                alternatives.push_back( Alternative( impCpCtorExpr->clone(), env, Cost::zero ) );
    10131015        }
     1016
     1017        void AlternativeFinder::visit( ConstructorExpr * ctorExpr ) {
     1018                AlternativeFinder finder( indexer, env );
     1019                // don't prune here, since it's guaranteed all alternatives will have the same type
     1020                // (giving the alternatives different types is half of the point of ConstructorExpr nodes)
     1021                finder.findWithAdjustment( ctorExpr->get_callExpr(), false );
     1022                for ( Alternative & alt : finder.alternatives ) {
     1023                        alternatives.push_back( Alternative( new ConstructorExpr( alt.expr->clone() ), alt.env, alt.cost ) );
     1024                }
     1025        }
    10141026} // namespace ResolvExpr
    10151027
  • src/ResolvExpr/AlternativeFinder.h

    r2298f728 r9c23f31  
    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                template< typename InputIterator, typename OutputIterator >
     
    7273          private:
    7374                /// Adds alternatives for member expressions, given the aggregate, conversion cost for that aggregate, and name of the member
    74                 template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const std::string &name );
     75                template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, const std::string &name );
    7576                /// Adds alternatives for offsetof expressions, given the base type and name of the member
    7677                template< typename StructOrUnionType > void addOffsetof( StructOrUnionType *aggInst, const std::string &name );
  • src/ResolvExpr/CommonType.cc

    r2298f728 r9c23f31  
    3939                virtual void visit( TupleType *tupleType );
    4040                virtual void visit( VarArgsType *varArgsType );
     41                virtual void visit( ZeroType *zeroType );
     42                virtual void visit( OneType *oneType );
    4143
    4244                template< typename RefType > void handleRefType( RefType *inst, Type *other );
     
    134136                                result = new BasicType( basicType->get_qualifiers() + otherBasic->get_qualifiers(), newType );
    135137                        } // if
    136                 } else if ( EnumInstType *enumInstType = dynamic_cast< EnumInstType * > ( type2 ) ) {
    137                         // use signed int in lieu of the enum type
     138                } else if ( dynamic_cast< EnumInstType * > ( type2 ) || dynamic_cast< ZeroType* >( type2 ) || dynamic_cast< OneType* >( type2 ) ) {
     139                        // use signed int in lieu of the enum/zero/one type
    138140                        BasicType::Kind newType = combinedType[ basicType->get_kind() ][ BasicType::SignedInt ];
    139                         if ( ( ( newType == basicType->get_kind() && basicType->get_qualifiers() >= enumInstType->get_qualifiers() ) || widenFirst ) && ( ( newType != basicType->get_kind() && basicType->get_qualifiers() <= enumInstType->get_qualifiers() ) || widenSecond ) ) {
    140                                 result = new BasicType( basicType->get_qualifiers() + enumInstType->get_qualifiers(), newType );
     141                        if ( ( ( newType == basicType->get_kind() && basicType->get_qualifiers() >= type2->get_qualifiers() ) || widenFirst ) && ( ( newType != basicType->get_kind() && basicType->get_qualifiers() <= type2->get_qualifiers() ) || widenSecond ) ) {
     142                                result = new BasicType( basicType->get_qualifiers() + type2->get_qualifiers(), newType );
    141143                        } // if
    142144                } // if
     
    171173                                otherPointer->get_base()->get_qualifiers() = tq2;
    172174                        } // if
     175                } else if ( widenSecond && dynamic_cast< ZeroType* >( type2 ) ) {
     176                        result = pointerType->clone();
     177                        result->get_qualifiers() += type2->get_qualifiers();
    173178                } // if
    174179        }
     
    190195
    191196        void CommonType::visit( EnumInstType *enumInstType ) {
    192                 if ( dynamic_cast< BasicType * >( type2 ) ) {
     197                if ( dynamic_cast< BasicType * >( type2 ) || dynamic_cast< ZeroType* >( type2 ) || dynamic_cast< OneType* >( type2 ) ) {
    193198                        // reuse BasicType, EnumInstType code by swapping type2 with enumInstType
    194199                        Type * temp = type2;
     
    230235        void CommonType::visit( VarArgsType *varArgsType ) {
    231236        }
     237
     238        void CommonType::visit( ZeroType *zeroType ) {
     239                if ( widenFirst ) {
     240                        if ( dynamic_cast< BasicType* >( type2 ) || dynamic_cast< PointerType* >( type2 ) || dynamic_cast< EnumInstType* >( type2 ) ) {
     241                                if ( widenSecond || zeroType->get_qualifiers() <= type2->get_qualifiers() ) {
     242                                        result = type2->clone();
     243                                        result->get_qualifiers() += zeroType->get_qualifiers();
     244                                }
     245                        }
     246                }
     247        }
     248
     249        void CommonType::visit( OneType *oneType ) {
     250                if ( widenFirst ) {
     251                        if ( dynamic_cast< BasicType* >( type2 ) || dynamic_cast< EnumInstType* >( type2 ) ) {
     252                                if ( widenSecond || oneType->get_qualifiers() <= type2->get_qualifiers() ) {
     253                                        result = type2->clone();
     254                                        result->get_qualifiers() += oneType->get_qualifiers();
     255                                }
     256                        }
     257                }
     258        }
    232259} // namespace ResolvExpr
    233260
  • src/ResolvExpr/ConversionCost.cc

    r2298f728 r9c23f31  
    160160                        // xxx - not positive this is correct, but appears to allow casting int => enum
    161161                        cost = Cost( 1, 0, 0 );
    162     } // if
     162                } else if ( dynamic_cast< ZeroType* >( dest ) != nullptr || dynamic_cast< OneType* >( dest ) != nullptr ) {
     163                        cost = Cost( 1, 0, 0 );
     164                } // if
    163165        }
    164166
     
    175177                                } // if
    176178                        } // if
     179                } else if ( dynamic_cast< ZeroType* >( dest ) != nullptr || dynamic_cast< OneType* >( dest ) != nullptr ) {
     180                        cost = Cost( 1, 0, 0 );
    177181                } // if
    178182        }
     
    256260                }
    257261        }
     262
     263        void ConversionCost::visit(ZeroType *zeroType) {
     264                if ( dynamic_cast< ZeroType* >( dest ) ) {
     265                        cost = Cost::zero;
     266                } else if ( BasicType *destAsBasic = dynamic_cast< BasicType* >( dest ) ) {
     267                        // copied from visit(BasicType*) for signed int, but +1 for safe conversions
     268                        int tableResult = costMatrix[ BasicType::SignedInt ][ destAsBasic->get_kind() ];
     269                        if ( tableResult == -1 ) {
     270                                cost = Cost( 1, 0, 0 );
     271                        } else {
     272                                cost = Cost( 0, 0, tableResult + 1 );
     273                        }
     274                } else if ( dynamic_cast< PointerType* >( dest ) ) {
     275                        cost = Cost( 0, 0, 1 );
     276                }
     277        }
     278
     279        void ConversionCost::visit(OneType *oneType) {
     280                if ( dynamic_cast< OneType* >( dest ) ) {
     281                        cost = Cost::zero;
     282                } else if ( BasicType *destAsBasic = dynamic_cast< BasicType* >( dest ) ) {
     283                        // copied from visit(BasicType*) for signed int, but +1 for safe conversions
     284                        int tableResult = costMatrix[ BasicType::SignedInt ][ destAsBasic->get_kind() ];
     285                        if ( tableResult == -1 ) {
     286                                cost = Cost( 1, 0, 0 );
     287                        } else {
     288                                cost = Cost( 0, 0, tableResult + 1 );
     289                        }
     290                }
     291        }
    258292} // namespace ResolvExpr
    259293
  • src/ResolvExpr/ConversionCost.h

    r2298f728 r9c23f31  
    4141                virtual void visit(TupleType *tupleType);
    4242                virtual void visit(VarArgsType *varArgsType);
     43                virtual void visit(ZeroType *zeroType);
     44                virtual void visit(OneType *oneType);
    4345          protected:
    4446                Type *dest;
  • src/ResolvExpr/PtrsAssignable.cc

    r2298f728 r9c23f31  
    3939                virtual void visit( TupleType *tupleType );
    4040                virtual void visit( VarArgsType *varArgsType );
     41                virtual void visit( ZeroType *zeroType );
     42                virtual void visit( OneType *oneType );
    4143          private:
    4244                Type *dest;
     
    141143        void PtrsAssignable::visit( VarArgsType *varArgsType ) {
    142144        }
     145
     146        void PtrsAssignable::visit( ZeroType *zeroType ) {
     147        }
     148       
     149        void PtrsAssignable::visit( OneType *oneType ) {
     150        }
     151       
    143152} // namespace ResolvExpr
    144153
  • src/ResolvExpr/PtrsCastable.cc

    r2298f728 r9c23f31  
    4040                virtual void visit(TupleType *tupleType);
    4141                virtual void visit(VarArgsType *varArgsType);
     42                virtual void visit(ZeroType *zeroType);
     43                virtual void visit(OneType *oneType);
    4244          private:
    4345                Type *dest;
     
    144146                result = objectCast( dest, env, indexer );
    145147        }
     148
     149        void PtrsCastable::visit(ZeroType *zeroType) {
     150                result = objectCast( dest, env, indexer );
     151        }
     152
     153        void PtrsCastable::visit(OneType *oneType) {
     154                result = objectCast( dest, env, indexer );
     155        }
    146156} // namespace ResolvExpr
    147157
  • src/ResolvExpr/RenameVars.cc

    r2298f728 r9c23f31  
    110110        }
    111111
     112        void RenameVars::visit( ZeroType *zeroType ) {
     113                typeBefore( zeroType );
     114                typeAfter( zeroType );
     115        }
     116
     117        void RenameVars::visit( OneType *oneType ) {
     118                typeBefore( oneType );
     119                typeAfter( oneType );
     120        }
     121
    112122        void RenameVars::typeBefore( Type *type ) {
    113123                if ( ! type->get_forall().empty() ) {
  • src/ResolvExpr/RenameVars.h

    r2298f728 r9c23f31  
    4444                virtual void visit( TupleType *tupleType );
    4545                virtual void visit( VarArgsType *varArgsType );
     46                virtual void visit( ZeroType *zeroType );
     47                virtual void visit( OneType *oneType );
    4648
    4749                void typeBefore( Type *type );
  • src/ResolvExpr/Resolver.cc

    r2298f728 r9c23f31  
    133133                        } else if ( BasicType *bt = dynamic_cast< BasicType * >( type ) ) {
    134134                                return bt->isInteger();
     135                        } else if ( dynamic_cast< ZeroType* >( type ) != nullptr || dynamic_cast< OneType* >( type ) != nullptr ) {
     136                                return true;
    135137                        } else {
    136138                                return false;
     
    459461                        }
    460462                } else {
    461                         assert( dynamic_cast< BasicType * >( initContext ) || dynamic_cast< PointerType * >( initContext ) );
     463                        assert( dynamic_cast< BasicType * >( initContext ) || dynamic_cast< PointerType * >( initContext )
     464                                || dynamic_cast< ZeroType * >( initContext ) || dynamic_cast< OneType * >( initContext ) );
    462465                        // basic types are handled here
    463466                        Visitor::visit( listInit );
  • src/ResolvExpr/Unify.cc

    r2298f728 r9c23f31  
    6060                virtual void visit(TupleType *tupleType);
    6161                virtual void visit(VarArgsType *varArgsType);
     62                virtual void visit(ZeroType *zeroType);
     63                virtual void visit(OneType *oneType);
    6264
    6365                template< typename RefType > void handleRefType( RefType *inst, Type *other );
     
    588590        }
    589591
     592        void Unify::visit(ZeroType *zeroType) {
     593                result = dynamic_cast< ZeroType* >( type2 );
     594        }
     595
     596        void Unify::visit(OneType *oneType) {
     597                result = dynamic_cast< OneType* >( type2 );
     598        }
     599
    590600} // namespace ResolvExpr
    591601
  • src/SymTab/FixFunction.cc

    r2298f728 r9c23f31  
    7777                return varArgsType;
    7878        }
     79
     80        Type * FixFunction::mutate(ZeroType *zeroType) {
     81                return zeroType;
     82        }
     83
     84        Type * FixFunction::mutate(OneType *oneType) {
     85                return oneType;
     86        }
    7987} // namespace SymTab
    8088
  • src/SymTab/FixFunction.h

    r2298f728 r9c23f31  
    4242                virtual Type* mutate(TupleType *tupleType);
    4343                virtual Type* mutate(VarArgsType *varArgsType);
     44                virtual Type* mutate(ZeroType *zeroType);
     45                virtual Type* mutate(OneType *oneType);
    4446 
    4547                bool isVoid;
  • src/SymTab/ImplementationType.cc

    r2298f728 r9c23f31  
    4141                virtual void visit(TupleType *tupleType);
    4242                virtual void visit(VarArgsType *varArgsType);
     43                virtual void visit(ZeroType *zeroType);
     44                virtual void visit(OneType *oneType);
    4345
    4446                Type *result;                   // synthesized
     
    120122        void ImplementationType::visit(VarArgsType *varArgsType) {
    121123        }
     124
     125        void ImplementationType::visit(ZeroType *zeroType) {
     126        }
     127
     128        void ImplementationType::visit(OneType *oneType) {
     129        }
    122130} // namespace SymTab
    123131
  • src/SymTab/Mangler.cc

    r2298f728 r9c23f31  
    229229                printQualifiers( varArgsType );
    230230                mangleName << "VARGS";
     231        }
     232
     233        void Mangler::visit( ZeroType *zeroType ) {
     234                mangleName << "Z";
     235        }
     236
     237        void Mangler::visit( OneType *oneType ) {
     238                mangleName << "O";
    231239        }
    232240
  • src/SymTab/Mangler.h

    r2298f728 r9c23f31  
    4646                virtual void visit( TupleType *tupleType );
    4747                virtual void visit( VarArgsType *varArgsType );
     48                virtual void visit( ZeroType *zeroType );
     49                virtual void visit( OneType *oneType );
    4850 
    4951                std::string get_mangleName() { return mangleName.str(); }
  • src/SymTab/TypeEquality.cc

    r2298f728 r9c23f31  
    4242                virtual void visit( TypeInstType *typeInst );
    4343                virtual void visit( VarArgsType *varArgsType );
     44                virtual void visit( ZeroType *zeroType );
     45                virtual void visit( OneType *oneType );
    4446
    4547                void handleQualifiers( Type * t );
     
    199201                }
    200202        }
     203
     204        void TypeEquality::visit( ZeroType *zeroType ) {
     205                handleQualifiers( zeroType );
     206                if ( ! dynamic_cast< ZeroType * >( other ) ) {
     207                        result = false;
     208                }
     209        }
     210
     211        void TypeEquality::visit( OneType *oneType ) {
     212                handleQualifiers( oneType );
     213                if ( ! dynamic_cast< OneType * >( other ) ) {
     214                        result = false;
     215                }
     216        }
    201217} // namespace SymTab
  • src/SymTab/Validate.cc

    r2298f728 r9c23f31  
    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

    r2298f728 r9c23f31  
    2828#include "TypeSubstitution.h"
    2929#include "Common/utility.h"
     30#include "InitTweak/InitTweak.h"
    3031
    3132
     
    493494
    494495void ImplicitCopyCtorExpr::print( std::ostream &os, int indent ) const {
    495         os << std::string( indent, ' ' ) << "Implicit Copy Constructor Expression: " << std::endl;
     496        os << "Implicit Copy Constructor Expression: " << std::endl;
    496497        assert( callExpr );
    497498        callExpr->print( os, indent + 2 );
     
    503504}
    504505
     506
     507ConstructorExpr::ConstructorExpr( Expression * callExpr ) : callExpr( callExpr ) {
     508        // allow resolver to type a constructor used as an expression as if it has the same type as its first argument
     509        assert( callExpr );
     510        Expression * arg = InitTweak::getCallArg( callExpr, 0 );
     511        assert( arg );
     512        cloneAll( arg->get_results(), results );
     513}
     514
     515ConstructorExpr::ConstructorExpr( const ConstructorExpr & other ) : Expression( other ), callExpr( maybeClone( other.callExpr ) ) {
     516}
     517
     518ConstructorExpr::~ConstructorExpr() {
     519        delete callExpr;
     520}
     521
     522void ConstructorExpr::print( std::ostream &os, int indent ) const {
     523        os <<  "Constructor Expression: " << std::endl;
     524        assert( callExpr );
     525        os << std::string( indent+2, ' ' );
     526        callExpr->print( os, indent + 2 );
     527        Expression::print( os, indent );
     528}
     529
     530
     531CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : type( type ), initializer( initializer ) {
     532        add_result( type->clone() );
     533}
     534
     535CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), type( maybeClone( other.type ) ), initializer( maybeClone( other.initializer ) ) {}
     536
     537CompoundLiteralExpr::~CompoundLiteralExpr() {
     538        delete initializer;
     539        delete type;
     540}
     541
     542void CompoundLiteralExpr::print( std::ostream &os, int indent ) const {
     543        os << "Compound Literal Expression: " << std::endl;
     544        if ( type ) type->print( os, indent + 2 );
     545        if ( initializer ) initializer->print( os, indent + 2 );
     546}
     547
    505548UntypedValofExpr::UntypedValofExpr( const UntypedValofExpr & other ) : Expression( other ), body ( maybeClone( other.body ) ) {}
    506549
     
    511554        if ( get_body() != 0 )
    512555                get_body()->print( os, indent + 2 );
    513 }
    514 
    515 
    516 CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : type( type ), initializer( initializer ) {
    517         add_result( type->clone() );
    518 }
    519 
    520 CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), type( maybeClone( other.type ) ), initializer( maybeClone( other.initializer ) ) {}
    521 
    522 CompoundLiteralExpr::~CompoundLiteralExpr() {
    523         delete initializer;
    524         delete type;
    525 }
    526 
    527 void CompoundLiteralExpr::print( std::ostream &os, int indent ) const {
    528         os << "Compound Literal Expression: " << std::endl;
    529         if ( type ) type->print( os, indent + 2 );
    530         if ( initializer ) initializer->print( os, indent + 2 );
    531556}
    532557
  • src/SynTree/Expression.h

    r2298f728 r9c23f31  
    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        ~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         ~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

    r2298f728 r9c23f31  
    339339}
    340340
    341 Expression *Mutator::mutate( UntypedValofExpr *valofExpr ) {
    342         mutateAll( valofExpr->get_results(), *this );
    343         return valofExpr;
     341Expression* Mutator::mutate( ConstructorExpr *ctorExpr ) {
     342        mutateAll( ctorExpr->get_results(), *this );
     343        ctorExpr->set_callExpr( maybeMutate( ctorExpr->get_callExpr(), *this ) );
     344        return ctorExpr;
    344345}
    345346
     
    349350        compLitExpr->set_initializer( maybeMutate( compLitExpr->get_initializer(), *this ) );
    350351        return compLitExpr;
     352}
     353
     354Expression *Mutator::mutate( UntypedValofExpr *valofExpr ) {
     355        mutateAll( valofExpr->get_results(), *this );
     356        return valofExpr;
    351357}
    352358
     
    447453}
    448454
     455Type *Mutator::mutate( ZeroType *zeroType ) {
     456        mutateAll( zeroType->get_forall(), *this );
     457        return zeroType;
     458}
     459
     460Type *Mutator::mutate( OneType *oneType ) {
     461        mutateAll( oneType->get_forall(), *this );
     462        return oneType;
     463}
     464
    449465Initializer *Mutator::mutate( SingleInit *singleInit ) {
    450466        singleInit->set_value( singleInit->get_value()->acceptMutator( *this ) );
  • src/SynTree/Mutator.h

    r2298f728 r9c23f31  
    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
     
    9495        virtual Type* mutate( AttrType *attrType );
    9596        virtual Type* mutate( VarArgsType *varArgsType );
     97        virtual Type* mutate( ZeroType *zeroType );
     98        virtual Type* mutate( OneType *oneType );
    9699
    97100        virtual Initializer* mutate( SingleInit *singleInit );
  • src/SynTree/SynTree.h

    r2298f728 r9c23f31  
    8181class AsmExpr;
    8282class ImplicitCopyCtorExpr;
     83class ConstructorExpr;
     84class CompoundLiteralExpr;
    8385class UntypedValofExpr;
    84 class CompoundLiteralExpr;
    8586class RangeExpr;
    8687
     
    101102class AttrType;
    102103class VarArgsType;
     104class ZeroType;
     105class OneType;
    103106
    104107class Initializer;
  • src/SynTree/Type.h

    r2298f728 r9c23f31  
    418418};
    419419
     420/// Represents a zero constant
     421class ZeroType : public Type {
     422  public:
     423        ZeroType();
     424        ZeroType( Type::Qualifiers tq );
     425
     426        virtual ZeroType *clone() const { return new ZeroType( *this ); }
     427        virtual void accept( Visitor &v ) { v.visit( this ); }
     428        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     429        virtual void print( std::ostream &os, int indent = 0 ) const;
     430};
     431
     432/// Represents a one constant
     433class OneType : public Type {
     434  public:
     435        OneType();
     436        OneType( Type::Qualifiers tq );
     437
     438        virtual OneType *clone() const { return new OneType( *this ); }
     439        virtual void accept( Visitor &v ) { v.visit( this ); }
     440        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     441        virtual void print( std::ostream &os, int indent = 0 ) const;
     442};
     443
    420444inline Type::Qualifiers &Type::Qualifiers::operator+=( const Type::Qualifiers &other ) {
    421445        isConst |= other.isConst;
  • src/SynTree/TypeSubstitution.cc

    r2298f728 r9c23f31  
    179179}
    180180
    181 Type * TypeSubstitution::mutate( VoidType *basicType ) {
    182         return handleType( basicType );
     181Type * TypeSubstitution::mutate( VoidType *voidType ) {
     182        return handleType( voidType );
    183183}
    184184
     
    221221Type * TypeSubstitution::mutate( VarArgsType *varArgsType ) {
    222222        return handleType( varArgsType );
     223}
     224
     225Type * TypeSubstitution::mutate( ZeroType *zeroType ) {
     226        return handleType( zeroType );
     227}
     228
     229Type * TypeSubstitution::mutate( OneType *oneType ) {
     230        return handleType( oneType );
    223231}
    224232
  • src/SynTree/TypeSubstitution.h

    r2298f728 r9c23f31  
    7676        virtual Type* mutate(TupleType *tupleType);
    7777        virtual Type* mutate(VarArgsType *varArgsType);
     78        virtual Type* mutate(ZeroType *zeroType);
     79        virtual Type* mutate(OneType *oneType);
    7880
    7981        // TODO: worry about traversing into a forall-qualified function type or type decl with assertions
  • src/SynTree/Visitor.cc

    r2298f728 r9c23f31  
    287287}
    288288
    289 void Visitor::visit( UntypedValofExpr *valofExpr ) {
    290         acceptAll( valofExpr->get_results(), *this );
    291         maybeAccept( valofExpr->get_body(), *this );
     289void Visitor::visit( ConstructorExpr * ctorExpr ) {
     290        acceptAll( ctorExpr->get_results(), *this );
     291        maybeAccept( ctorExpr->get_callExpr(), *this );
    292292}
    293293
     
    296296        maybeAccept( compLitExpr->get_type(), *this );
    297297        maybeAccept( compLitExpr->get_initializer(), *this );
     298}
     299
     300void Visitor::visit( UntypedValofExpr *valofExpr ) {
     301        acceptAll( valofExpr->get_results(), *this );
     302        maybeAccept( valofExpr->get_body(), *this );
    298303}
    299304
     
    378383}
    379384
     385void Visitor::visit( ZeroType *zeroType ) {
     386        acceptAll( zeroType->get_forall(), *this );
     387}
     388
     389void Visitor::visit( OneType *oneType ) {
     390        acceptAll( oneType->get_forall(), *this );
     391}
     392
    380393void Visitor::visit( SingleInit *singleInit ) {
    381394        singleInit->get_value()->accept( *this );
  • src/SynTree/Visitor.h

    r2298f728 r9c23f31  
    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
     
    9495        virtual void visit( AttrType *attrType );
    9596        virtual void visit( VarArgsType *varArgsType );
     97        virtual void visit( ZeroType *zeroType );
     98        virtual void visit( OneType *oneType );
    9699
    97100        virtual void visit( SingleInit *singleInit );
  • src/SynTree/module.mk

    r2298f728 r9c23f31  
    2626       SynTree/AttrType.cc \
    2727       SynTree/VarArgsType.cc \
     28       SynTree/ZeroOneType.cc \
    2829       SynTree/Constant.cc \
    2930       SynTree/Expression.cc \
  • src/examples/gc_no_raii/src/internal/card_table.h

    r2298f728 r9c23f31  
    1818};
    1919
    20 static inline void ctor_card(card_table_t* const this)
     20static inline void ?{}(card_table_t* this)
    2121{
    2222        this->count = 0;
    2323}
    2424
    25 static inline void dtor_card(card_table_t* const this)
     25static inline void ^?{}(card_table_t* this)
    2626{
    2727
  • src/examples/gc_no_raii/src/internal/memory_pool.c

    r2298f728 r9c23f31  
    1111const size_t gc_pool_header_size = (size_t)(  &(((gc_memory_pool*)NULL)->start_p) );
    1212
    13 void ctor(gc_memory_pool *const this, size_t size, gc_memory_pool* next, gc_memory_pool* mirror, uint8_t type)
     13void ?{}(gc_memory_pool* this, size_t size, gc_memory_pool* next, gc_memory_pool* mirror, uint8_t type)
    1414{
    1515        this->mirror = mirror;
     
    1717        this->type_code = type;
    1818
    19         card_table_t* new = (card_table_t*)malloc(sizeof(card_table_t));
    20         this->cards = new;
    21         ctor_card(this->cards);
     19        this->cards = ( (card_table_t*)malloc(sizeof(card_table_t)) ){};
    2220
    2321        this->end_p = ((uint8_t*)this) + size;
     
    2927}
    3028
    31 void dtor(gc_memory_pool *const this)
     29void ^?{}(gc_memory_pool* this)
    3230{
    33         dtor_card(this->cards);
     31        ^(&this->cards){};
    3432        free(this->cards);
    3533}
  • src/examples/gc_no_raii/src/internal/memory_pool.h

    r2298f728 r9c23f31  
    2727};
    2828
    29 void ctor(      gc_memory_pool *const this,
     29void ?{}(       gc_memory_pool* this,
    3030                size_t size,
    3131                gc_memory_pool* next,
     
    3434        );
    3535
    36 void dtor(gc_memory_pool *const this);
     36void ^?{}(gc_memory_pool* this);
    3737
    3838struct gc_pool_object_iterator
  • src/examples/gc_no_raii/src/internal/state.c

    r2298f728 r9c23f31  
    131131
    132132      this->from_space = (gc_memory_pool*)(pal_allocPool(POOL_SIZE_BYTES, 1));
    133       this->to_space = (gc_memory_pool*)(pal_allocPool(POOL_SIZE_BYTES, 1));
    134 
    135       ctor(this->from_space, POOL_SIZE_BYTES, old_from_space, this->to_space,   this->from_code);
    136       ctor(this->to_space,   POOL_SIZE_BYTES, old_to_space,   this->from_space, (~this->from_code) & 0x01);
     133      this->to_space   = (gc_memory_pool*)(pal_allocPool(POOL_SIZE_BYTES, 1));
     134
     135      this->from_space{ POOL_SIZE_BYTES, old_from_space, this->to_space,   this->from_code };
     136      this->to_space  { POOL_SIZE_BYTES, old_to_space,   this->from_space, (~this->from_code) & 0x01 };
    137137
    138138        this->total_space += gc_pool_size_used(this->from_space);
  • src/include/assert.h

    r2298f728 r9c23f31  
    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/containers/vector

    r2298f728 r9c23f31  
    2020}
    2121
    22 #define DESTROY(x)
    23 
    2422//------------------------------------------------------------------------------
    2523//Declaration
    2624trait allocator_c(otype T, otype allocator_t)
    2725{
    28         void ctor(allocator_t* const);
    29         void dtor(allocator_t* const);
    30         void realloc_storage(allocator_t* const, size_t);
    31         T* data(allocator_t* const);
     26        void realloc_storage(allocator_t*, size_t);
     27        T* data(allocator_t*);
    3228};
     29
     30forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
     31struct vector;
     32
     33//------------------------------------------------------------------------------
     34//Initialization
     35forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
     36void ?{}(vector(T, allocator_t)* this);
     37
     38forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
     39void ?{}(vector(T, allocator_t)* this, vector(T, allocator_t) rhs);
     40
     41forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
     42vector(T, allocator_t) ?=?(vector(T, allocator_t)* this, vector(T, allocator_t) rhs);
     43
     44forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
     45void ^?{}(vector(T, allocator_t)* this);
    3346
    3447forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
     
    4053
    4154//------------------------------------------------------------------------------
    42 //Initialization
    43 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
    44 void ctor(vector(T, allocator_t) *const this);
    45 
    46 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
    47 void dtor(vector(T, allocator_t) *const this);
    48 
    49 //------------------------------------------------------------------------------
    5055//Capacity
    5156forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
    52 static inline bool empty(vector(T, allocator_t) *const this)
     57static inline bool empty(vector(T, allocator_t)* this)
    5358{
    5459        return this->size == 0;
     
    5661
    5762forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
    58 static inline size_t size(vector(T, allocator_t) *const this)
     63static inline size_t size(vector(T, allocator_t)* this)
    5964{
    6065        return this->size;
     
    6267
    6368forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
    64 static inline void reserve(vector(T, allocator_t) *const this, size_t size)
     69static inline void reserve(vector(T, allocator_t)* this, size_t size)
    6570{
    6671        realloc_storage(&this->storage, this->size+1);
     
    7075//Element access
    7176forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
    72 static inline T at(vector(T, allocator_t) *const this, size_t index)
     77static inline T at(vector(T, allocator_t)* this, size_t index)
    7378{
    7479        return data(&this->storage)[index];
     
    7681
    7782forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
    78 static inline T ?[?](vector(T, allocator_t) *const this, size_t index)
     83static inline T ?[?](vector(T, allocator_t)* this, size_t index)
    7984{
    8085        return data(&this->storage)[index];
     
    8287
    8388forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
    84 static inline T front(vector(T, allocator_t) *const this)
     89static inline T front(vector(T, allocator_t)* this)
    8590{
    8691        return data(&this->storage)[0];
     
    8893
    8994forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
    90 static inline T back(vector(T, allocator_t) *const this)
     95static inline T back(vector(T, allocator_t)* this)
    9196{
    9297        return data(&this->storage)[this->size - 1];
     
    96101//Modifiers
    97102forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
    98 void push_back(vector(T, allocator_t) *const this, T value);
     103void push_back(vector(T, allocator_t)* this, T value);
    99104
    100105forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
    101 void pop_back(vector(T, allocator_t) *const this);
     106void pop_back(vector(T, allocator_t)* this);
    102107
    103108forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
    104 void clear(vector(T, allocator_t) *const this);
     109void clear(vector(T, allocator_t)* this);
    105110
    106111//------------------------------------------------------------------------------
    107112//Iterators
    108113forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
    109 static inline T* begin(vector(T, allocator_t) *const this)
     114static inline T* begin(vector(T, allocator_t)* this)
    110115{
    111116        return data(&this->storage);
     
    113118
    114119forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
    115 static inline const T* cbegin(const vector(T, allocator_t) *const this)
     120static inline const T* cbegin(const vector(T, allocator_t)* this)
    116121{
    117122        return data(&this->storage);
     
    119124
    120125forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
    121 static inline T* end(vector(T, allocator_t) *const this)
     126static inline T* end(vector(T, allocator_t)* this)
    122127{
    123128        return data(&this->storage) + this->size;
     
    125130
    126131forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
    127 static inline const T* cend(const vector(T, allocator_t) *const this)
     132static inline const T* cend(const vector(T, allocator_t)* this)
    128133{
    129134        return data(&this->storage) + this->size;
     
    140145
    141146forall(otype T)
    142 void ctor(heap_allocator(T) *const this);
     147void ?{}(heap_allocator(T)* this);
    143148
    144149forall(otype T)
    145 void dtor(heap_allocator(T) *const this);
     150void ?{}(heap_allocator(T)* this, heap_allocator(T) rhs);
    146151
    147152forall(otype T)
    148 void realloc_storage(heap_allocator(T) *const this, size_t size);
     153heap_allocator(T) ?=?(heap_allocator(T)* this, heap_allocator(T) rhs);
    149154
    150155forall(otype T)
    151 static inline T* data(heap_allocator(T) *const this)
     156void ^?{}(heap_allocator(T)* this);
     157
     158forall(otype T)
     159void realloc_storage(heap_allocator(T)* this, size_t size);
     160
     161forall(otype T)
     162static inline T* data(heap_allocator(T)* this)
    152163{
    153164        return this->storage;
  • src/libcfa/containers/vector.c

    r2298f728 r9c23f31  
    1818#include <stdlib>
    1919
     20forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
     21void copy_internal(vector(T, allocator_t)* this, vector(T, allocator_t)* other);
     22
    2023//------------------------------------------------------------------------------
    2124//Initialization
    2225forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
    23 void ctor(vector(T, allocator_t) *const this)
     26void ?{}(vector(T, allocator_t)* this)
    2427{
    25         ctor(&this->storage);
     28        (&this->storage){};
    2629        this->size = 0;
    2730}
    2831
    2932forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
    30 void dtor(vector(T, allocator_t) *const this)
     33void ?{}(vector(T, allocator_t)* this, vector(T, allocator_t) rhs)
     34{
     35        (&this->storage){ rhs.storage };
     36        copy_internal(this, &rhs);
     37}
     38
     39// forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
     40// vector(T, allocator_t) ?=?(vector(T, allocator_t)* this, vector(T, allocator_t) rhs)
     41// {
     42//      (&this->storage){};
     43//      copy_internal(this, &rhs);
     44//      return *this;
     45// }
     46
     47forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
     48void ^?{}(vector(T, allocator_t)* this)
    3149{
    3250        clear(this);
    33         dtor(&this->storage);
     51        ^(&this->storage){};
    3452}
    3553
     
    3755//Modifiers
    3856forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
    39 void push_back(vector(T, allocator_t) *const this, T value)
     57void push_back(vector(T, allocator_t)* this, T value)
    4058{
    4159        realloc_storage(&this->storage, this->size+1);
     
    4563
    4664forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
    47 void pop_back(vector(T, allocator_t) *const this)
     65void pop_back(vector(T, allocator_t)* this)
    4866{
    4967        this->size--;
    50         DESTROY(data(&this->storage)[this->size]);
     68        ^(&data(&this->storage)[this->size]){};
    5169}
    5270
    5371forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
    54 void clear(vector(T, allocator_t) *const this)
     72void clear(vector(T, allocator_t)* this)
    5573{
    5674        for(size_t i = 0; i < this->size; i++)
    5775        {
    58                 DESTROY(data(&this->storage)[this->size]);
     76                ^(&data(&this->storage)[this->size]){};
    5977        }
    6078        this->size = 0;
     
    6280
    6381//------------------------------------------------------------------------------
     82//Internal Helpers
     83
     84forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
     85void copy_internal(vector(T, allocator_t)* this, vector(T, allocator_t)* other)
     86{
     87        this->size = other->size;
     88        for(size_t i = 0; i < this->size; i++) {
     89                (&data(&this->storage)[this->size]){ data(&other->storage)[other->size] };
     90        }
     91}
     92
     93//------------------------------------------------------------------------------
    6494//Allocator
    6595forall(otype T)
    66 void ctor(heap_allocator(T) *const this)
     96void ?{}(heap_allocator(T)* this)
    6797{
    6898        this->storage = 0;
     
    71101
    72102forall(otype T)
    73 void dtor(heap_allocator(T) *const this)
     103void ?{}(heap_allocator(T)* this, heap_allocator(T) rhs)
     104{
     105        this->capacity = rhs.capacity;
     106        this->storage = (T*)realloc((void*)this->storage, this->capacity * sizeof(T));
     107}
     108
     109forall(otype T)
     110heap_allocator(T) ?=?(heap_allocator(T)* this, heap_allocator(T) rhs)
     111{
     112        this->capacity = rhs.capacity;
     113        this->storage = (T*)realloc((void*)this->storage, this->capacity * sizeof(T));
     114        return *this;
     115}
     116
     117forall(otype T)
     118void ^?{}(heap_allocator(T)* this)
    74119{
    75120        free(this->storage);
     
    77122
    78123forall(otype T)
    79 inline void realloc_storage(heap_allocator(T) *const this, size_t size)
     124inline void realloc_storage(heap_allocator(T)* this, size_t size)
    80125{
    81126        enum { GROWTH_RATE = 2 };
  • src/libcfa/prelude.cf

    r2298f728 r9c23f31  
    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/libcfa_vector.c

    r2298f728 r9c23f31  
    1 // 
     1//
    22// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
    33//
    44// The contents of this file are covered under the licence agreement in the
    55// file "LICENCE" distributed with Cforall.
    6 // 
    7 // libcfa_vector.c -- 
    8 // 
     6//
     7// libcfa_vector.c --
     8//
    99// Author           : Thierry Delisle
    1010// Created On       : Mon Jul  4 23:36:19 2016
     
    1212// Last Modified On : Tue Jul  5 15:08:05 2016
    1313// Update Count     : 26
    14 // 
     14//
    1515
    1616#include <fstream>
     
    2828int main() {
    2929        vector( int, heap_allocator(int) ) iv;
    30         ctor( &iv );
    3130
    3231        assert( empty( &iv ) );
Note: See TracChangeset for help on using the changeset viewer.