Changes in / [23b6643f:aefcc3b]

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 (deleted)
• 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 (deleted)
• 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:
@@ -202 +200 @@
         }
 
-        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) \
@@ -389 +388 @@
         SynTree/ReferenceToType.cc SynTree/TupleType.cc \
         SynTree/TypeofType.cc SynTree/AttrType.cc \
-        SynTree/VarArgsType.cc SynTree/ZeroOneType.cc \
-        SynTree/Constant.cc SynTree/Expression.cc SynTree/TupleExpr.cc \
+        SynTree/VarArgsType.cc SynTree/Constant.cc \
+        SynTree/Expression.cc SynTree/TupleExpr.cc \
         SynTree/CommaExpr.cc SynTree/TypeExpr.cc \
         SynTree/ApplicationExpr.cc SynTree/AddressExpr.cc \
@@ -711 +710 @@
 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)
@@ -874 +871 @@
         -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)
@@ -979 +975 @@
 @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@
@@ -2048 +2043 @@
 @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;
@@ -119 +117 @@
                 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 );
@@ -136 +134 @@
                                 result = new BasicType( basicType->get_qualifiers() + otherBasic->get_qualifiers(), newType );
                         } // if
-                } 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
+                } else if ( EnumInstType *enumInstType = dynamic_cast< EnumInstType * > ( type2 ) ) {
+                        // use signed int in lieu of the enum type
                         BasicType::Kind newType = combinedType[ basicType->get_kind() ][ BasicType::SignedInt ];
-                        if ( ( ( newType == basicType->get_kind() && basicType->get_qualifiers() >= 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 ( ( ( newType == basicType->get_kind() && basicType->get_qualifiers() >= enumInstType->get_qualifiers() ) || widenFirst ) && ( ( newType != basicType->get_kind() && basicType->get_qualifiers() <= enumInstType->get_qualifiers() ) || widenSecond ) ) {
+                                result = new BasicType( basicType->get_qualifiers() + enumInstType->get_qualifiers(), newType );
                         } // if
                 } // if
@@ -173 +171 @@
                                 otherPointer->get_base()->get_qualifiers() = tq2;
                         } // if
-                } else if ( widenSecond && dynamic_cast< ZeroType* >( type2 ) ) {
-                        result = pointerType->clone();
-                        result->get_qualifiers() += type2->get_qualifiers();
                 } // if
         }
@@ -195 +190 @@
 
         void CommonType::visit( EnumInstType *enumInstType ) {
-                if ( dynamic_cast< BasicType * >( type2 ) || dynamic_cast< ZeroType* >( type2 ) || dynamic_cast< OneType* >( type2 ) ) {
+                if ( dynamic_cast< BasicType * >( type2 ) ) {
                         // reuse BasicType, EnumInstType code by swapping type2 with enumInstType
                         Type * temp = type2;
@@ -235 +230 @@
         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 );
-                } else if ( dynamic_cast< ZeroType* >( dest ) != nullptr || dynamic_cast< OneType* >( dest ) != nullptr ) {
-                        cost = Cost( 1, 0, 0 );
-                } // if
+    } // if
         }
 
@@ -177 +175 @@
                                 } // if
                         } // if
-                } else if ( dynamic_cast< ZeroType* >( dest ) != nullptr || dynamic_cast< OneType* >( dest ) != nullptr ) {
-                        cost = Cost( 1, 0, 0 );
                 } // if
         }
@@ -260 +256 @@
                 }
         }
-
-        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;
@@ -143 +141 @@
         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;
@@ -146 +144 @@
                 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;
@@ -457 +455 @@
                         }
                 } else {
-                        assert( dynamic_cast< BasicType * >( initContext ) || dynamic_cast< PointerType * >( initContext )
-                                || dynamic_cast< ZeroType * >( initContext ) || dynamic_cast< OneType * >( initContext ) );
+                        assert( dynamic_cast< BasicType * >( initContext ) || dynamic_cast< PointerType * >( 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 );
@@ -590 +588 @@
         }
 
-        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 ) {
@@ -612 +602 @@
                 }
         }
+
 } // 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
@@ -122 +120 @@
         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 );
@@ -201 +199 @@
                 }
         }
-
-        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 *voidType ) {
-        return handleType( voidType );
+Type * TypeSubstitution::mutate( VoidType *basicType ) {
+        return handleType( basicType );
 }
 
@@ -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 ?{}(card_table_t* this)
+static inline void ctor_card(card_table_t* const this)
 {
         this->count = 0;
 }
 
-static inline void ^?{}(card_table_t* this)
+static inline void dtor_card(card_table_t* const 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 ?{}(gc_memory_pool* this, size_t size, gc_memory_pool* next, gc_memory_pool* mirror, uint8_t type)
+void ctor(gc_memory_pool *const this, size_t size, gc_memory_pool* next, gc_memory_pool* mirror, uint8_t type)
 {
         this->mirror = mirror;
@@ -17 +17 @@
         this->type_code = type;
 
-        this->cards = ( (card_table_t*)malloc(sizeof(card_table_t)) ){};
+        card_table_t* new = (card_table_t*)malloc(sizeof(card_table_t));
+        this->cards = new;
+        ctor_card(this->cards);
 
         this->end_p = ((uint8_t*)this) + size;
@@ -27 +29 @@
 }
 
-void ^?{}(gc_memory_pool* this)
+void dtor(gc_memory_pool *const this)
 {
-        ^(&this->cards){};
+        dtor_card(this->cards);
         free(this->cards);
 }

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

@@ -27 +27 @@
 };
 
-void ?{}(       gc_memory_pool* this,
+void ctor(      gc_memory_pool *const this,
                 size_t size,
                 gc_memory_pool* next,
@@ -34 +34 @@
         );
 
-void ^?{}(gc_memory_pool* this);
+void dtor(gc_memory_pool *const 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));
-
-      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->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->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 realloc_storage(allocator_t*, size_t);
-        T* data(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);
 };
-
-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))
@@ -53 +40 @@
 
 //------------------------------------------------------------------------------
+//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)* this)
+static inline bool empty(vector(T, allocator_t) *const this)
 {
         return this->size == 0;
@@ -61 +56 @@
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-static inline size_t size(vector(T, allocator_t)* this)
+static inline size_t size(vector(T, allocator_t) *const this)
 {
         return this->size;
@@ -67 +62 @@
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-static inline void reserve(vector(T, allocator_t)* this, size_t size)
+static inline void reserve(vector(T, allocator_t) *const this, size_t size)
 {
         realloc_storage(&this->storage, this->size+1);
@@ -75 +70 @@
 //Element access
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-static inline T at(vector(T, allocator_t)* this, size_t index)
+static inline T at(vector(T, allocator_t) *const this, size_t index)
 {
         return data(&this->storage)[index];
@@ -81 +76 @@
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-static inline T ?[?](vector(T, allocator_t)* this, size_t index)
+static inline T ?[?](vector(T, allocator_t) *const this, size_t index)
 {
         return data(&this->storage)[index];
@@ -87 +82 @@
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-static inline T front(vector(T, allocator_t)* this)
+static inline T front(vector(T, allocator_t) *const this)
 {
         return data(&this->storage)[0];
@@ -93 +88 @@
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-static inline T back(vector(T, allocator_t)* this)
+static inline T back(vector(T, allocator_t) *const this)
 {
         return data(&this->storage)[this->size - 1];
@@ -101 +96 @@
 //Modifiers
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-void push_back(vector(T, allocator_t)* this, T value);
+void push_back(vector(T, allocator_t) *const this, T value);
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-void pop_back(vector(T, allocator_t)* this);
+void pop_back(vector(T, allocator_t) *const this);
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-void clear(vector(T, allocator_t)* this);
+void clear(vector(T, allocator_t) *const this);
 
 //------------------------------------------------------------------------------
 //Iterators
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-static inline T* begin(vector(T, allocator_t)* this)
+static inline T* begin(vector(T, allocator_t) *const this)
 {
         return data(&this->storage);
@@ -118 +113 @@
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-static inline const T* cbegin(const vector(T, allocator_t)* this)
+static inline const T* cbegin(const vector(T, allocator_t) *const this)
 {
         return data(&this->storage);
@@ -124 +119 @@
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-static inline T* end(vector(T, allocator_t)* this)
+static inline T* end(vector(T, allocator_t) *const this)
 {
         return data(&this->storage) + this->size;
@@ -130 +125 @@
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-static inline const T* cend(const vector(T, allocator_t)* this)
+static inline const T* cend(const vector(T, allocator_t) *const this)
 {
         return data(&this->storage) + this->size;
@@ -145 +140 @@
 
 forall(otype T)
-void ?{}(heap_allocator(T)* this);
+void ctor(heap_allocator(T) *const this);
 
 forall(otype T)
-void ?{}(heap_allocator(T)* this, heap_allocator(T) rhs);
+void dtor(heap_allocator(T) *const this);
 
 forall(otype T)
-heap_allocator(T) ?=?(heap_allocator(T)* this, heap_allocator(T) rhs);
+void realloc_storage(heap_allocator(T) *const this, size_t size);
 
 forall(otype T)
-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)
+static inline T* data(heap_allocator(T) *const 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 ?{}(vector(T, allocator_t)* this)
+void ctor(vector(T, allocator_t) *const this)
 {
-        (&this->storage){};
+        ctor(&this->storage);
         this->size = 0;
 }
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-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)
+void dtor(vector(T, allocator_t) *const this)
 {
         clear(this);
-        ^(&this->storage){};
+        dtor(&this->storage);
 }
 
@@ -55 +37 @@
 //Modifiers
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-void push_back(vector(T, allocator_t)* this, T value)
+void push_back(vector(T, allocator_t) *const this, T value)
 {
         realloc_storage(&this->storage, this->size+1);
@@ -63 +45 @@
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-void pop_back(vector(T, allocator_t)* this)
+void pop_back(vector(T, allocator_t) *const this)
 {
         this->size--;
-        ^(&data(&this->storage)[this->size]){};
+        DESTROY(data(&this->storage)[this->size]);
 }
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-void clear(vector(T, allocator_t)* this)
+void clear(vector(T, allocator_t) *const this)
 {
         for(size_t i = 0; i < this->size; i++)
         {
-                ^(&data(&this->storage)[this->size]){};
+                DESTROY(data(&this->storage)[this->size]);
         }
         this->size = 0;
@@ -80 +62 @@
 
 //------------------------------------------------------------------------------
-//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 ?{}(heap_allocator(T)* this)
+void ctor(heap_allocator(T) *const this)
 {
         this->storage = 0;
@@ -101 +71 @@
 
 forall(otype T)
-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)
+void dtor(heap_allocator(T) *const this)
 {
         free(this->storage);
@@ -122 +77 @@
 
 forall(otype T)
-inline void realloc_storage(heap_allocator(T)* this, size_t size)
+inline void realloc_storage(heap_allocator(T) *const 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 ) );