Changeset 23b6643f

Timestamp:

Sep 20, 2016, 4:47:34 PM (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:

1132b62

Parents:

aefcc3b (diff), db46512 (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/Makefile.in
src/ResolvExpr/Unify.cc
src/SynTree/Type.h

Location:

src

Files:

• CodeGen/GenType.cc (modified) (2 diffs)
• Makefile.in (modified) (6 diffs)
• ResolvExpr/AdjustExprType.cc (modified) (2 diffs)
• ResolvExpr/CommonType.cc (modified) (5 diffs)
• ResolvExpr/ConversionCost.cc (modified) (3 diffs)
• ResolvExpr/ConversionCost.h (modified) (1 diff)
• ResolvExpr/PtrsAssignable.cc (modified) (2 diffs)
• ResolvExpr/PtrsCastable.cc (modified) (2 diffs)
• ResolvExpr/RenameVars.cc (modified) (1 diff)
• ResolvExpr/RenameVars.h (modified) (1 diff)
• ResolvExpr/Resolver.cc (modified) (2 diffs)
• ResolvExpr/Unify.cc (modified) (3 diffs)
• SymTab/FixFunction.cc (modified) (1 diff)
• SymTab/FixFunction.h (modified) (1 diff)
• SymTab/ImplementationType.cc (modified) (2 diffs)
• SymTab/Mangler.cc (modified) (1 diff)
• SymTab/Mangler.h (modified) (1 diff)
• SymTab/TypeEquality.cc (modified) (2 diffs)
• SynTree/Mutator.cc (modified) (1 diff)
• SynTree/Mutator.h (modified) (1 diff)
• SynTree/SynTree.h (modified) (1 diff)
• SynTree/Type.h (modified) (1 diff)
• SynTree/TypeSubstitution.cc (modified) (2 diffs)
• SynTree/TypeSubstitution.h (modified) (1 diff)
• SynTree/Visitor.cc (modified) (1 diff)
• SynTree/Visitor.h (modified) (1 diff)
• SynTree/ZeroOneType.cc (added)
• SynTree/module.mk (modified) (1 diff)
• examples/gc_no_raii/src/internal/card_table.h (modified) (1 diff)
• examples/gc_no_raii/src/internal/memory_pool.c (modified) (3 diffs)
• examples/gc_no_raii/src/internal/memory_pool.h (modified) (2 diffs)
• examples/gc_no_raii/src/internal/state.c (modified) (1 diff)
• libcfa/containers/vector (modified) (13 diffs)
• libcfa/containers/vector.c (modified) (6 diffs)
• tests/.expect/libcfa_vector.txt (added)
• tests/libcfa_vector.c (modified) (3 diffs)

src/CodeGen/GenType.cc

@@ -42 +42 @@
                 virtual void visit( TypeInstType *typeInst );
                 virtual void visit( VarArgsType *varArgsType );
+                virtual void visit( ZeroType *zeroType );
+                virtual void visit( OneType *oneType );
 
           private:
@@ -200 +202 @@
         }
 
+        void GenType::visit( ZeroType *zeroType ) {
+                // ideally these wouldn't hit codegen at all, but should be safe to make them ints
+                typeString = "int " + typeString;
+                handleQualifiers( zeroType );
+        }
+
+        void GenType::visit( OneType *oneType ) {
+                // ideally these wouldn't hit codegen at all, but should be safe to make them ints
+                typeString = "int " + typeString;
+                handleQualifiers( oneType );
+        }
+
         void GenType::handleQualifiers( Type *type ) {
                 if ( type->get_isConst() ) {

src/Makefile.in

@@ -164 +164 @@
         SynTree/driver_cfa_cpp-AttrType.$(OBJEXT) \
         SynTree/driver_cfa_cpp-VarArgsType.$(OBJEXT) \
+        SynTree/driver_cfa_cpp-ZeroOneType.$(OBJEXT) \
         SynTree/driver_cfa_cpp-Constant.$(OBJEXT) \
         SynTree/driver_cfa_cpp-Expression.$(OBJEXT) \
@@ -388 +389 @@
         SynTree/ReferenceToType.cc SynTree/TupleType.cc \
         SynTree/TypeofType.cc SynTree/AttrType.cc \
-        SynTree/VarArgsType.cc SynTree/Constant.cc \
-        SynTree/Expression.cc SynTree/TupleExpr.cc \
+        SynTree/VarArgsType.cc SynTree/ZeroOneType.cc \
+        SynTree/Constant.cc SynTree/Expression.cc SynTree/TupleExpr.cc \
         SynTree/CommaExpr.cc SynTree/TypeExpr.cc \
         SynTree/ApplicationExpr.cc SynTree/AddressExpr.cc \
@@ -710 +711 @@
 SynTree/driver_cfa_cpp-VarArgsType.$(OBJEXT): SynTree/$(am__dirstamp) \
         SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/driver_cfa_cpp-ZeroOneType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
 SynTree/driver_cfa_cpp-Constant.$(OBJEXT): SynTree/$(am__dirstamp) \
         SynTree/$(DEPDIR)/$(am__dirstamp)
@@ -871 +874 @@
         -rm -f SynTree/driver_cfa_cpp-Visitor.$(OBJEXT)
         -rm -f SynTree/driver_cfa_cpp-VoidType.$(OBJEXT)
+        -rm -f SynTree/driver_cfa_cpp-ZeroOneType.$(OBJEXT)
         -rm -f Tuples/driver_cfa_cpp-TupleAssignment.$(OBJEXT)
         -rm -f Tuples/driver_cfa_cpp-TupleExpansion.$(OBJEXT)
@@ -975 +979 @@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-Visitor.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-VoidType.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-ZeroOneType.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Tuples/$(DEPDIR)/driver_cfa_cpp-TupleAssignment.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Tuples/$(DEPDIR)/driver_cfa_cpp-TupleExpansion.Po@am__quote@
@@ -2043 +2048 @@
 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @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`
+
+SynTree/driver_cfa_cpp-ZeroOneType.o: SynTree/ZeroOneType.cc
+@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
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-ZeroOneType.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-ZeroOneType.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/ZeroOneType.cc' object='SynTree/driver_cfa_cpp-ZeroOneType.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@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
+
+SynTree/driver_cfa_cpp-ZeroOneType.obj: SynTree/ZeroOneType.cc
+@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`
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-ZeroOneType.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-ZeroOneType.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/ZeroOneType.cc' object='SynTree/driver_cfa_cpp-ZeroOneType.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@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`
 
 SynTree/driver_cfa_cpp-Constant.o: SynTree/Constant.cc

src/ResolvExpr/AdjustExprType.cc

@@ -37 +37 @@
                 virtual Type* mutate( TupleType *tupleType );
                 virtual Type* mutate( VarArgsType *varArgsType );
+                virtual Type* mutate( ZeroType *zeroType );
+                virtual Type* mutate( OneType *oneType );
 
                 const TypeEnvironment &env;
@@ -117 +119 @@
                 return varArgsType;
         }
+
+        Type *AdjustExprType::mutate( ZeroType *zeroType ) {
+                return zeroType;
+        }
+
+        Type *AdjustExprType::mutate( OneType *oneType ) {
+                return oneType;
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/CommonType.cc

@@ -39 +39 @@
                 virtual void visit( TupleType *tupleType );
                 virtual void visit( VarArgsType *varArgsType );
+                virtual void visit( ZeroType *zeroType );
+                virtual void visit( OneType *oneType );
 
                 template< typename RefType > void handleRefType( RefType *inst, Type *other );
@@ -134 +136 @@
                                 result = new BasicType( basicType->get_qualifiers() + otherBasic->get_qualifiers(), newType );
                         } // if
-                } else if ( EnumInstType *enumInstType = dynamic_cast< EnumInstType * > ( type2 ) ) {
-                        // use signed int in lieu of the enum type
+                } else if ( dynamic_cast< EnumInstType * > ( type2 ) || dynamic_cast< ZeroType* >( type2 ) || dynamic_cast< OneType* >( type2 ) ) {
+                        // use signed int in lieu of the enum/zero/one type
                         BasicType::Kind newType = combinedType[ basicType->get_kind() ][ BasicType::SignedInt ];
-                        if ( ( ( newType == basicType->get_kind() && basicType->get_qualifiers() >= enumInstType->get_qualifiers() ) || widenFirst ) && ( ( newType != basicType->get_kind() && basicType->get_qualifiers() <= enumInstType->get_qualifiers() ) || widenSecond ) ) {
-                                result = new BasicType( basicType->get_qualifiers() + enumInstType->get_qualifiers(), newType );
+                        if ( ( ( newType == basicType->get_kind() && basicType->get_qualifiers() >= type2->get_qualifiers() ) || widenFirst ) && ( ( newType != basicType->get_kind() && basicType->get_qualifiers() <= type2->get_qualifiers() ) || widenSecond ) ) {
+                                result = new BasicType( basicType->get_qualifiers() + type2->get_qualifiers(), newType );
                         } // if
                 } // if
@@ -171 +173 @@
                                 otherPointer->get_base()->get_qualifiers() = tq2;
                         } // if
+                } else if ( widenSecond && dynamic_cast< ZeroType* >( type2 ) ) {
+                        result = pointerType->clone();
+                        result->get_qualifiers() += type2->get_qualifiers();
                 } // if
         }
@@ -190 +195 @@
 
         void CommonType::visit( EnumInstType *enumInstType ) {
-                if ( dynamic_cast< BasicType * >( type2 ) ) {
+                if ( dynamic_cast< BasicType * >( type2 ) || dynamic_cast< ZeroType* >( type2 ) || dynamic_cast< OneType* >( type2 ) ) {
                         // reuse BasicType, EnumInstType code by swapping type2 with enumInstType
                         Type * temp = type2;
@@ -230 +235 @@
         void CommonType::visit( VarArgsType *varArgsType ) {
         }
+
+        void CommonType::visit( ZeroType *zeroType ) {
+                if ( widenFirst ) {
+                        if ( dynamic_cast< BasicType* >( type2 ) || dynamic_cast< PointerType* >( type2 ) || dynamic_cast< EnumInstType* >( type2 ) ) {
+                                if ( widenSecond || zeroType->get_qualifiers() <= type2->get_qualifiers() ) {
+                                        result = type2->clone();
+                                        result->get_qualifiers() += zeroType->get_qualifiers();
+                                }
+                        }
+                }
+        }
+
+        void CommonType::visit( OneType *oneType ) {
+                if ( widenFirst ) {
+                        if ( dynamic_cast< BasicType* >( type2 ) || dynamic_cast< EnumInstType* >( type2 ) ) {
+                                if ( widenSecond || oneType->get_qualifiers() <= type2->get_qualifiers() ) {
+                                        result = type2->clone();
+                                        result->get_qualifiers() += oneType->get_qualifiers();
+                                }
+                        }
+                }
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/ConversionCost.cc

@@ -160 +160 @@
                         // xxx - not positive this is correct, but appears to allow casting int => enum
                         cost = Cost( 1, 0, 0 );
-    } // if
+                } else if ( dynamic_cast< ZeroType* >( dest ) != nullptr || dynamic_cast< OneType* >( dest ) != nullptr ) {
+                        cost = Cost( 1, 0, 0 );
+                } // if
         }
 
@@ -175 +177 @@
                                 } // if
                         } // if
+                } else if ( dynamic_cast< ZeroType* >( dest ) != nullptr || dynamic_cast< OneType* >( dest ) != nullptr ) {
+                        cost = Cost( 1, 0, 0 );
                 } // if
         }
@@ -256 +260 @@
                 }
         }
+
+        void ConversionCost::visit(ZeroType *zeroType) {
+                if ( dynamic_cast< ZeroType* >( dest ) ) {
+                        cost = Cost::zero;
+                } else if ( BasicType *destAsBasic = dynamic_cast< BasicType* >( dest ) ) {
+                        // copied from visit(BasicType*) for signed int, but +1 for safe conversions
+                        int tableResult = costMatrix[ BasicType::SignedInt ][ destAsBasic->get_kind() ];
+                        if ( tableResult == -1 ) {
+                                cost = Cost( 1, 0, 0 );
+                        } else {
+                                cost = Cost( 0, 0, tableResult + 1 );
+                        }
+                } else if ( dynamic_cast< PointerType* >( dest ) ) {
+                        cost = Cost( 0, 0, 1 );
+                }
+        }
+
+        void ConversionCost::visit(OneType *oneType) {
+                if ( dynamic_cast< OneType* >( dest ) ) {
+                        cost = Cost::zero;
+                } else if ( BasicType *destAsBasic = dynamic_cast< BasicType* >( dest ) ) {
+                        // copied from visit(BasicType*) for signed int, but +1 for safe conversions
+                        int tableResult = costMatrix[ BasicType::SignedInt ][ destAsBasic->get_kind() ];
+                        if ( tableResult == -1 ) {
+                                cost = Cost( 1, 0, 0 );
+                        } else {
+                                cost = Cost( 0, 0, tableResult + 1 );
+                        }
+                }
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/ConversionCost.h

@@ -41 +41 @@
                 virtual void visit(TupleType *tupleType);
                 virtual void visit(VarArgsType *varArgsType);
+                virtual void visit(ZeroType *zeroType);
+                virtual void visit(OneType *oneType);
           protected:
                 Type *dest;

src/ResolvExpr/PtrsAssignable.cc

@@ -39 +39 @@
                 virtual void visit( TupleType *tupleType );
                 virtual void visit( VarArgsType *varArgsType );
+                virtual void visit( ZeroType *zeroType );
+                virtual void visit( OneType *oneType );
           private:
                 Type *dest;
@@ -141 +143 @@
         void PtrsAssignable::visit( VarArgsType *varArgsType ) {
         }
+
+        void PtrsAssignable::visit( ZeroType *zeroType ) {
+        }
+        
+        void PtrsAssignable::visit( OneType *oneType ) {
+        }
+        
 } // namespace ResolvExpr
 

src/ResolvExpr/PtrsCastable.cc

@@ -40 +40 @@
                 virtual void visit(TupleType *tupleType);
                 virtual void visit(VarArgsType *varArgsType);
+                virtual void visit(ZeroType *zeroType);
+                virtual void visit(OneType *oneType);
           private:
                 Type *dest;
@@ -144 +146 @@
                 result = objectCast( dest, env, indexer );
         }
+
+        void PtrsCastable::visit(ZeroType *zeroType) {
+                result = objectCast( dest, env, indexer );
+        }
+
+        void PtrsCastable::visit(OneType *oneType) {
+                result = objectCast( dest, env, indexer );
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/RenameVars.cc

@@ -110 +110 @@
         }
 
+        void RenameVars::visit( ZeroType *zeroType ) {
+                typeBefore( zeroType );
+                typeAfter( zeroType );
+        }
+
+        void RenameVars::visit( OneType *oneType ) {
+                typeBefore( oneType );
+                typeAfter( oneType );
+        }
+
         void RenameVars::typeBefore( Type *type ) {
                 if ( ! type->get_forall().empty() ) {

src/ResolvExpr/RenameVars.h

@@ -44 +44 @@
                 virtual void visit( TupleType *tupleType );
                 virtual void visit( VarArgsType *varArgsType );
+                virtual void visit( ZeroType *zeroType );
+                virtual void visit( OneType *oneType );
 
                 void typeBefore( Type *type );

src/ResolvExpr/Resolver.cc

@@ -134 +134 @@
                         } else if ( BasicType *bt = dynamic_cast< BasicType * >( type ) ) {
                                 return bt->isInteger();
+                        } else if ( dynamic_cast< ZeroType* >( type ) != nullptr || dynamic_cast< OneType* >( type ) != nullptr ) {
+                                return true;
                         } else {
                                 return false;
@@ -455 +457 @@
                         }
                 } else {
-                        assert( dynamic_cast< BasicType * >( initContext ) || dynamic_cast< PointerType * >( initContext ) );
+                        assert( dynamic_cast< BasicType * >( initContext ) || dynamic_cast< PointerType * >( initContext )
+                                || dynamic_cast< ZeroType * >( initContext ) || dynamic_cast< OneType * >( initContext ) );
                         // basic types are handled here
                         Visitor::visit( listInit );

src/ResolvExpr/Unify.cc

@@ -60 +60 @@
                 virtual void visit(TupleType *tupleType);
                 virtual void visit(VarArgsType *varArgsType);
+                virtual void visit(ZeroType *zeroType);
+                virtual void visit(OneType *oneType);
 
                 template< typename RefType > void handleRefType( RefType *inst, Type *other );
@@ -588 +590 @@
         }
 
+        void Unify::visit(ZeroType *zeroType) {
+                result = dynamic_cast< ZeroType* >( type2 );
+        }
+
+        void Unify::visit(OneType *oneType) {
+                result = dynamic_cast< OneType* >( type2 );
+        }
+
         // xxx - compute once and store in the FunctionType?
         Type * extractResultType( FunctionType * function ) {
@@ -602 +612 @@
                 }
         }
-
 } // namespace ResolvExpr
 

src/SymTab/FixFunction.cc

@@ -77 +77 @@
                 return varArgsType;
         }
+
+        Type * FixFunction::mutate(ZeroType *zeroType) {
+                return zeroType;
+        }
+
+        Type * FixFunction::mutate(OneType *oneType) {
+                return oneType;
+        }
 } // namespace SymTab
 

src/SymTab/FixFunction.h

@@ -42 +42 @@
                 virtual Type* mutate(TupleType *tupleType);
                 virtual Type* mutate(VarArgsType *varArgsType);
+                virtual Type* mutate(ZeroType *zeroType);
+                virtual Type* mutate(OneType *oneType);
   
                 bool isVoid;

src/SymTab/ImplementationType.cc

@@ -41 +41 @@
                 virtual void visit(TupleType *tupleType);
                 virtual void visit(VarArgsType *varArgsType);
+                virtual void visit(ZeroType *zeroType);
+                virtual void visit(OneType *oneType);
 
                 Type *result;                   // synthesized
@@ -120 +122 @@
         void ImplementationType::visit(VarArgsType *varArgsType) {
         }
+
+        void ImplementationType::visit(ZeroType *zeroType) {
+        }
+
+        void ImplementationType::visit(OneType *oneType) {
+        }
 } // namespace SymTab
 

src/SymTab/Mangler.cc

@@ -229 +229 @@
                 printQualifiers( varArgsType );
                 mangleName << "VARGS";
+        }
+
+        void Mangler::visit( ZeroType *zeroType ) {
+                mangleName << "Z";
+        }
+
+        void Mangler::visit( OneType *oneType ) {
+                mangleName << "O";
         }
 

src/SymTab/Mangler.h

@@ -46 +46 @@
                 virtual void visit( TupleType *tupleType );
                 virtual void visit( VarArgsType *varArgsType );
+                virtual void visit( ZeroType *zeroType );
+                virtual void visit( OneType *oneType );
   
                 std::string get_mangleName() { return mangleName.str(); }

src/SymTab/TypeEquality.cc

@@ -42 +42 @@
                 virtual void visit( TypeInstType *typeInst );
                 virtual void visit( VarArgsType *varArgsType );
+                virtual void visit( ZeroType *zeroType );
+                virtual void visit( OneType *oneType );
 
                 void handleQualifiers( Type * t );
@@ -199 +201 @@
                 }
         }
+
+        void TypeEquality::visit( ZeroType *zeroType ) {
+                handleQualifiers( zeroType );
+                if ( ! dynamic_cast< ZeroType * >( other ) ) {
+                        result = false;
+                }
+        }
+
+        void TypeEquality::visit( OneType *oneType ) {
+                handleQualifiers( oneType );
+                if ( ! dynamic_cast< OneType * >( other ) ) {
+                        result = false;
+                }
+        }
 } // namespace SymTab

src/SynTree/Mutator.cc

@@ -480 +480 @@
 }
 
+Type *Mutator::mutate( ZeroType *zeroType ) {
+        mutateAll( zeroType->get_forall(), *this );
+        return zeroType;
+}
+
+Type *Mutator::mutate( OneType *oneType ) {
+        mutateAll( oneType->get_forall(), *this );
+        return oneType;
+}
+
 Initializer *Mutator::mutate( SingleInit *singleInit ) {
         singleInit->set_value( singleInit->get_value()->acceptMutator( *this ) );

src/SynTree/Mutator.h

@@ -99 +99 @@
         virtual Type* mutate( AttrType *attrType );
         virtual Type* mutate( VarArgsType *varArgsType );
+        virtual Type* mutate( ZeroType *zeroType );
+        virtual Type* mutate( OneType *oneType );
 
         virtual Initializer* mutate( SingleInit *singleInit );

src/SynTree/SynTree.h

@@ -106 +106 @@
 class AttrType;
 class VarArgsType;
+class ZeroType;
+class OneType;
 
 class Initializer;

src/SynTree/Type.h

@@ -436 +436 @@
 };
 
+/// Represents a zero constant
+class ZeroType : public Type {
+  public:
+        ZeroType();
+        ZeroType( Type::Qualifiers tq );
+
+        virtual ZeroType *clone() const { return new ZeroType( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+};
+
+/// Represents a one constant
+class OneType : public Type {
+  public:
+        OneType();
+        OneType( Type::Qualifiers tq );
+
+        virtual OneType *clone() const { return new OneType( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+};
+
 inline Type::Qualifiers &Type::Qualifiers::operator&=( const Type::Qualifiers &other ) {
         isConst &= other.isConst;

src/SynTree/TypeSubstitution.cc

@@ -179 +179 @@
 }
 
-Type * TypeSubstitution::mutate( VoidType *basicType ) {
-        return handleType( basicType );
+Type * TypeSubstitution::mutate( VoidType *voidType ) {
+        return handleType( voidType );
 }
 
@@ -221 +221 @@
 Type * TypeSubstitution::mutate( VarArgsType *varArgsType ) {
         return handleType( varArgsType );
+}
+
+Type * TypeSubstitution::mutate( ZeroType *zeroType ) {
+        return handleType( zeroType );
+}
+
+Type * TypeSubstitution::mutate( OneType *oneType ) {
+        return handleType( oneType );
 }
 

src/SynTree/TypeSubstitution.h

@@ -76 +76 @@
         virtual Type* mutate(TupleType *tupleType);
         virtual Type* mutate(VarArgsType *varArgsType);
+        virtual Type* mutate(ZeroType *zeroType);
+        virtual Type* mutate(OneType *oneType);
 
         // TODO: worry about traversing into a forall-qualified function type or type decl with assertions

src/SynTree/Visitor.cc

@@ -406 +406 @@
 }
 
+void Visitor::visit( ZeroType *zeroType ) {
+        acceptAll( zeroType->get_forall(), *this );
+}
+
+void Visitor::visit( OneType *oneType ) {
+        acceptAll( oneType->get_forall(), *this );
+}
+
 void Visitor::visit( SingleInit *singleInit ) {
         singleInit->get_value()->accept( *this );

src/SynTree/Visitor.h

@@ -99 +99 @@
         virtual void visit( AttrType *attrType );
         virtual void visit( VarArgsType *varArgsType );
+        virtual void visit( ZeroType *zeroType );
+        virtual void visit( OneType *oneType );
 
         virtual void visit( SingleInit *singleInit );

src/SynTree/module.mk

@@ -26 +26 @@
        SynTree/AttrType.cc \
        SynTree/VarArgsType.cc \
+       SynTree/ZeroOneType.cc \
        SynTree/Constant.cc \
        SynTree/Expression.cc \

src/examples/gc_no_raii/src/internal/card_table.h

@@ -18 +18 @@
 };
 
-static inline void ctor_card(card_table_t* const this)
+static inline void ?{}(card_table_t* this)
 {
         this->count = 0;
 }
 
-static inline void dtor_card(card_table_t* const this)
+static inline void ^?{}(card_table_t* this)
 {
 

src/examples/gc_no_raii/src/internal/memory_pool.c

@@ -11 +11 @@
 const size_t gc_pool_header_size = (size_t)(  &(((gc_memory_pool*)NULL)->start_p) );
 
-void ctor(gc_memory_pool *const this, size_t size, gc_memory_pool* next, gc_memory_pool* mirror, uint8_t type)
+void ?{}(gc_memory_pool* this, size_t size, gc_memory_pool* next, gc_memory_pool* mirror, uint8_t type)
 {
         this->mirror = mirror;
@@ -17 +17 @@
         this->type_code = type;
 
-        card_table_t* new = (card_table_t*)malloc(sizeof(card_table_t));
-        this->cards = new;
-        ctor_card(this->cards);
+        this->cards = ( (card_table_t*)malloc(sizeof(card_table_t)) ){};
 
         this->end_p = ((uint8_t*)this) + size;
@@ -29 +27 @@
 }
 
-void dtor(gc_memory_pool *const this)
+void ^?{}(gc_memory_pool* this)
 {
-        dtor_card(this->cards);
+        ^(&this->cards){};
         free(this->cards);
 }

src/examples/gc_no_raii/src/internal/memory_pool.h

@@ -27 +27 @@
 };
 
-void ctor(      gc_memory_pool *const this,
+void ?{}(       gc_memory_pool* this,
                 size_t size,
                 gc_memory_pool* next,
@@ -34 +34 @@
         );
 
-void dtor(gc_memory_pool *const this);
+void ^?{}(gc_memory_pool* this);
 
 struct gc_pool_object_iterator

src/examples/gc_no_raii/src/internal/state.c

@@ -131 +131 @@
 
       this->from_space = (gc_memory_pool*)(pal_allocPool(POOL_SIZE_BYTES, 1));
-      this->to_space = (gc_memory_pool*)(pal_allocPool(POOL_SIZE_BYTES, 1));
-
-      ctor(this->from_space, POOL_SIZE_BYTES, old_from_space, this->to_space,   this->from_code);
-      ctor(this->to_space,   POOL_SIZE_BYTES, old_to_space,   this->from_space, (~this->from_code) & 0x01);
+      this->to_space   = (gc_memory_pool*)(pal_allocPool(POOL_SIZE_BYTES, 1));
+
+      this->from_space{ POOL_SIZE_BYTES, old_from_space, this->to_space,   this->from_code };
+      this->to_space  { POOL_SIZE_BYTES, old_to_space,   this->from_space, (~this->from_code) & 0x01 };
 
         this->total_space += gc_pool_size_used(this->from_space);

src/libcfa/containers/vector

@@ -20 +20 @@
 }
 
-#define DESTROY(x)
-
 //------------------------------------------------------------------------------
 //Declaration
 trait allocator_c(otype T, otype allocator_t)
 {
-        void ctor(allocator_t* const);
-        void dtor(allocator_t* const);
-        void realloc_storage(allocator_t* const, size_t);
-        T* data(allocator_t* const);
+        void realloc_storage(allocator_t*, size_t);
+        T* data(allocator_t*);
 };
+
+forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+struct vector;
+
+//------------------------------------------------------------------------------
+//Initialization
+forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+void ?{}(vector(T, allocator_t)* this);
+
+forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+void ?{}(vector(T, allocator_t)* this, vector(T, allocator_t) rhs);
+
+forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+vector(T, allocator_t) ?=?(vector(T, allocator_t)* this, vector(T, allocator_t) rhs);
+
+forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+void ^?{}(vector(T, allocator_t)* this);
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
@@ -40 +53 @@
 
 //------------------------------------------------------------------------------
-//Initialization
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-void ctor(vector(T, allocator_t) *const this);
-
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-void dtor(vector(T, allocator_t) *const this);
-
-//------------------------------------------------------------------------------
 //Capacity
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-static inline bool empty(vector(T, allocator_t) *const this)
+static inline bool empty(vector(T, allocator_t)* this)
 {
         return this->size == 0;
@@ -56 +61 @@
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-static inline size_t size(vector(T, allocator_t) *const this)
+static inline size_t size(vector(T, allocator_t)* this)
 {
         return this->size;
@@ -62 +67 @@
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-static inline void reserve(vector(T, allocator_t) *const this, size_t size)
+static inline void reserve(vector(T, allocator_t)* this, size_t size)
 {
         realloc_storage(&this->storage, this->size+1);
@@ -70 +75 @@
 //Element access
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-static inline T at(vector(T, allocator_t) *const this, size_t index)
+static inline T at(vector(T, allocator_t)* this, size_t index)
 {
         return data(&this->storage)[index];
@@ -76 +81 @@
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-static inline T ?[?](vector(T, allocator_t) *const this, size_t index)
+static inline T ?[?](vector(T, allocator_t)* this, size_t index)
 {
         return data(&this->storage)[index];
@@ -82 +87 @@
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-static inline T front(vector(T, allocator_t) *const this)
+static inline T front(vector(T, allocator_t)* this)
 {
         return data(&this->storage)[0];
@@ -88 +93 @@
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-static inline T back(vector(T, allocator_t) *const this)
+static inline T back(vector(T, allocator_t)* this)
 {
         return data(&this->storage)[this->size - 1];
@@ -96 +101 @@
 //Modifiers
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-void push_back(vector(T, allocator_t) *const this, T value);
+void push_back(vector(T, allocator_t)* this, T value);
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-void pop_back(vector(T, allocator_t) *const this);
+void pop_back(vector(T, allocator_t)* this);
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-void clear(vector(T, allocator_t) *const this);
+void clear(vector(T, allocator_t)* this);
 
 //------------------------------------------------------------------------------
 //Iterators
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-static inline T* begin(vector(T, allocator_t) *const this)
+static inline T* begin(vector(T, allocator_t)* this)
 {
         return data(&this->storage);
@@ -113 +118 @@
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-static inline const T* cbegin(const vector(T, allocator_t) *const this)
+static inline const T* cbegin(const vector(T, allocator_t)* this)
 {
         return data(&this->storage);
@@ -119 +124 @@
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-static inline T* end(vector(T, allocator_t) *const this)
+static inline T* end(vector(T, allocator_t)* this)
 {
         return data(&this->storage) + this->size;
@@ -125 +130 @@
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-static inline const T* cend(const vector(T, allocator_t) *const this)
+static inline const T* cend(const vector(T, allocator_t)* this)
 {
         return data(&this->storage) + this->size;
@@ -140 +145 @@
 
 forall(otype T)
-void ctor(heap_allocator(T) *const this);
+void ?{}(heap_allocator(T)* this);
 
 forall(otype T)
-void dtor(heap_allocator(T) *const this);
+void ?{}(heap_allocator(T)* this, heap_allocator(T) rhs);
 
 forall(otype T)
-void realloc_storage(heap_allocator(T) *const this, size_t size);
+heap_allocator(T) ?=?(heap_allocator(T)* this, heap_allocator(T) rhs);
 
 forall(otype T)
-static inline T* data(heap_allocator(T) *const this)
+void ^?{}(heap_allocator(T)* this);
+
+forall(otype T)
+void realloc_storage(heap_allocator(T)* this, size_t size);
+
+forall(otype T)
+static inline T* data(heap_allocator(T)* this)
 {
         return this->storage;

src/libcfa/containers/vector.c

@@ -18 +18 @@
 #include <stdlib>
 
+forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+void copy_internal(vector(T, allocator_t)* this, vector(T, allocator_t)* other);
+
 //------------------------------------------------------------------------------
 //Initialization
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-void ctor(vector(T, allocator_t) *const this)
+void ?{}(vector(T, allocator_t)* this)
 {
-        ctor(&this->storage);
+        (&this->storage){};
         this->size = 0;
 }
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-void dtor(vector(T, allocator_t) *const this)
+void ?{}(vector(T, allocator_t)* this, vector(T, allocator_t) rhs)
+{
+        (&this->storage){ rhs.storage };
+        copy_internal(this, &rhs);
+}
+
+// forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+// vector(T, allocator_t) ?=?(vector(T, allocator_t)* this, vector(T, allocator_t) rhs)
+// {
+//      (&this->storage){};
+//      copy_internal(this, &rhs);
+//      return *this;
+// }
+
+forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+void ^?{}(vector(T, allocator_t)* this)
 {
         clear(this);
-        dtor(&this->storage);
+        ^(&this->storage){};
 }
 
@@ -37 +55 @@
 //Modifiers
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-void push_back(vector(T, allocator_t) *const this, T value)
+void push_back(vector(T, allocator_t)* this, T value)
 {
         realloc_storage(&this->storage, this->size+1);
@@ -45 +63 @@
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-void pop_back(vector(T, allocator_t) *const this)
+void pop_back(vector(T, allocator_t)* this)
 {
         this->size--;
-        DESTROY(data(&this->storage)[this->size]);
+        ^(&data(&this->storage)[this->size]){};
 }
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-void clear(vector(T, allocator_t) *const this)
+void clear(vector(T, allocator_t)* this)
 {
         for(size_t i = 0; i < this->size; i++)
         {
-                DESTROY(data(&this->storage)[this->size]);
+                ^(&data(&this->storage)[this->size]){};
         }
         this->size = 0;
@@ -62 +80 @@
 
 //------------------------------------------------------------------------------
+//Internal Helpers
+
+forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+void copy_internal(vector(T, allocator_t)* this, vector(T, allocator_t)* other)
+{
+        this->size = other->size;
+        for(size_t i = 0; i < this->size; i++) {
+                (&data(&this->storage)[this->size]){ data(&other->storage)[other->size] };
+        }
+}
+
+//------------------------------------------------------------------------------
 //Allocator
 forall(otype T)
-void ctor(heap_allocator(T) *const this)
+void ?{}(heap_allocator(T)* this)
 {
         this->storage = 0;
@@ -71 +101 @@
 
 forall(otype T)
-void dtor(heap_allocator(T) *const this)
+void ?{}(heap_allocator(T)* this, heap_allocator(T) rhs)
+{
+        this->capacity = rhs.capacity;
+        this->storage = (T*)realloc((void*)this->storage, this->capacity * sizeof(T));
+}
+
+forall(otype T)
+heap_allocator(T) ?=?(heap_allocator(T)* this, heap_allocator(T) rhs)
+{
+        this->capacity = rhs.capacity;
+        this->storage = (T*)realloc((void*)this->storage, this->capacity * sizeof(T));
+        return *this;
+}
+
+forall(otype T)
+void ^?{}(heap_allocator(T)* this)
 {
         free(this->storage);
@@ -77 +122 @@
 
 forall(otype T)
-inline void realloc_storage(heap_allocator(T) *const this, size_t size)
+inline void realloc_storage(heap_allocator(T)* this, size_t size)
 {
         enum { GROWTH_RATE = 2 };

src/tests/libcfa_vector.c

@@ -1 @@
-// 
+//
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 //
 // The contents of this file are covered under the licence agreement in the
 // file "LICENCE" distributed with Cforall.
-// 
-// libcfa_vector.c -- 
-// 
+//
+// libcfa_vector.c --
+//
 // Author           : Thierry Delisle
 // Created On       : Mon Jul  4 23:36:19 2016
@@ -12 +12 @@
 // Last Modified On : Tue Jul  5 15:08:05 2016
 // Update Count     : 26
-// 
+//
 
 #include <fstream>
@@ -28 +28 @@
 int main() {
         vector( int, heap_allocator(int) ) iv;
-        ctor( &iv );
 
         assert( empty( &iv ) );