Changeset fd782b2

Timestamp:

Sep 15, 2016, 10:55:52 AM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

aa8f9df

Parents:

f006f01 (diff), 1eba452 (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/Parser/ParseNode.h

Location:

src

Files:

• InitTweak/InitTweak.cc (modified) (1 diff)
• Parser/DeclarationNode.cc (modified) (8 diffs)
• Parser/ParseNode.h (modified) (16 diffs)
• Parser/TypeData.h (modified) (2 diffs)
• Parser/parser.cc (modified) (1 diff)
• Parser/parser.yy (modified) (1 diff)
• examples/gc_no_raii/bug-repro/field.c (modified) (2 diffs)
• examples/gc_no_raii/bug-repro/oddtype.c (added)
• examples/gc_no_raii/src/gcpointers.c (modified) (6 diffs)
• examples/gc_no_raii/src/gcpointers.h (modified) (3 diffs)
• examples/gc_no_raii/src/internal/card_table.h (modified) (4 diffs)
• examples/gc_no_raii/src/internal/collector.c (modified) (6 diffs)
• examples/gc_no_raii/src/internal/collector.h (modified) (1 diff)
• examples/gc_no_raii/src/internal/memory_pool.c (modified) (10 diffs)
• examples/gc_no_raii/src/internal/memory_pool.h (modified) (2 diffs)
• examples/gc_no_raii/src/internal/object_header.c (modified) (11 diffs)
• examples/gc_no_raii/src/internal/object_header.h (modified) (4 diffs)
• examples/gc_no_raii/src/internal/state.c (modified) (7 diffs)
• examples/gc_no_raii/src/internal/state.h (modified) (1 diff)
• examples/gc_no_raii/src/tools/checks.h (modified) (3 diffs)
• examples/gc_no_raii/src/tools/print.c (modified) (1 diff)
• examples/gc_no_raii/src/tools/print.h (modified) (1 diff)
• examples/gc_no_raii/test/badlll.c (modified) (3 diffs)
• tests/.expect/declarationErrors.txt (modified) (1 diff)
• tests/avltree/avl_test.c (modified) (1 diff)

src/InitTweak/InitTweak.cc

@@ -387 +387 @@
                         } else if ( MemberExpr * memberExpr = dynamic_cast< MemberExpr * >( func ) ) {
                                 return memberExpr->get_member()->get_name();
+                        } else if ( UntypedMemberExpr * memberExpr = dynamic_cast< UntypedMemberExpr * > ( func ) ) {
+                                return funcName( memberExpr->get_member() );
                         } else {
                                 assertf( false, "Unexpected expression type being called as a function in call expression" );

src/Parser/DeclarationNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Sep  9 23:21:47 2016
-// Update Count     : 402
+// Last Modified On : Sun Sep 11 09:24:11 2016
+// Update Count     : 438
 //
 
@@ -31 +31 @@
 
 // These must remain in the same order as the corresponding DeclarationNode enumerations.
-const char *DeclarationNode::storageName[] = { "extern", "static", "auto", "register", "inline", "fortran", "_Noreturn", "_Thread_local", "" };
+const char *DeclarationNode::storageName[] = { "extern", "static", "auto", "register", "inline", "fortran", "_Noreturn", "_Thread_local", "NoStorageClass" };
 const char *DeclarationNode::qualifierName[] = { "const", "restrict", "volatile", "lvalue", "_Atomic" };
 const char *DeclarationNode::basicTypeName[] = { "char", "int", "float", "double", "void", "_Bool", "_Complex", "_Imaginary",  };
@@ -389 +389 @@
 
 void DeclarationNode::checkQualifiers( const TypeData *src, const TypeData *dst ) {
-        TypeData::Qualifiers qsrc = src->qualifiers, qdst = dst->qualifiers;
-
-        if ( (qsrc & qdst).any() ) {                                            // common bits between qualifier masks ?
+        TypeData::Qualifiers qsrc = src->qualifiers, qdst = dst->qualifiers; // optimization
+
+        if ( (qsrc & qdst).any() ) {                                            // common qualifier ?
                 for ( int i = 0; i < NoOfQualifier; i += 1 ) {  // find common qualifiers
                         if ( qsrc[i] & qdst[i] ) {
-                                error += string(error.empty() ? "" : ", ") + "duplicate " + DeclarationNode::qualifierName[i];
+                                if ( ! error.empty() ) error += ", ";   // separator
+                                error += string( "duplicate " ) + DeclarationNode::qualifierName[i];
                         } // if
                 } // for
         } // if
 } // DeclarationNode::checkQualifiers
+
+void DeclarationNode::checkStorageClasses( DeclarationNode *q ) {
+        if ( storageClass != NoStorageClass && q->storageClass != NoStorageClass ) {
+                if ( ! error.empty() ) error += ", ";                   // separator
+                if ( storageClass == q->storageClass ) {                // duplicate qualifier
+                        error += string( "duplicate " ) + storageName[ storageClass ];
+                } else {                                                                                // only one storage class
+                        error += string( "conflicting " ) + storageName[ storageClass ] + " & " + storageName[ q->storageClass ];
+                        q->storageClass = storageClass;                         // FIX ERROR
+                } // if
+                if ( ! q->error.empty() ) error += ", " + q->error;     // separator
+        } else {
+                if ( ! error.empty() ) {
+                        if ( ! q->error.empty() ) error += ", " + q->error; // separator
+                } else if ( ! q->error.empty() ) error += q->error;
+        } // if
+} // DeclarationNode::copyStorageClasses
+
+DeclarationNode *DeclarationNode::copyStorageClasses( DeclarationNode *q ) {
+        isInline = isInline | q->isInline;
+        isNoreturn = isNoreturn | q->isNoreturn;
+        // do not overwrite an existing value with NoStorageClass
+        if ( q->storageClass != NoStorageClass ) {
+                assert( storageClass == NoStorageClass || storageClass == q->storageClass );
+                storageClass = q->storageClass;
+        } // if
+        return this;
+} // DeclarationNode::copyStorageClasses
 
 DeclarationNode *DeclarationNode::addQualifiers( DeclarationNode *q ) {
         if ( q ) {
-                copyStorageClasses(q);
+                checkStorageClasses( q );
+                copyStorageClasses( q );
                 if ( q->type ) {
                         if ( ! type ) {
@@ -429 +459 @@
         return this;
 }
-
-DeclarationNode *DeclarationNode::copyStorageClasses( DeclarationNode *q ) {
-        isInline = isInline || q->isInline;
-        isNoreturn = isNoreturn || q->isNoreturn;
-        if ( storageClass == NoStorageClass ) {
-                storageClass = q->storageClass;
-        } else if ( q->storageClass != NoStorageClass ) {
-                if ( storageClass == q->storageClass ) {
-                        q->error += string( "duplicate " ) + storageName[ storageClass ];
-                } else {                                                                                // can only have one storage class
-                        q->error += string( "multiple " ) + storageName[ storageClass ] + " & " + storageName[ q->storageClass ];
-                } // if
-        } // if
-        if ( ! q->error.empty() ) {
-                error += (! error.empty() ? ", " : "") + q->error;
-        } // if
-        return this;
-} // DeclarationNode::copyStorageClasses
 
 static void addTypeToType( TypeData *&src, TypeData *&dst ) {
@@ -504 +516 @@
 DeclarationNode *DeclarationNode::addType( DeclarationNode *o ) {
         if ( o ) {
+                checkStorageClasses( o );
                 copyStorageClasses( o );
                 if ( o->type ) {
@@ -751 +764 @@
         } // if
         newnode->type->forall = maybeClone( type->forall );
+        assert( storageClass == NoStorageClass );
         newnode->copyStorageClasses( this );
         newnode->name = assign_strptr( newName );
@@ -791 +805 @@
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = maybeClone( type );
+        assert( storageClass == NoStorageClass );
         newnode->copyStorageClasses( this );
         newnode->name = assign_strptr( newName );
@@ -798 +813 @@
 DeclarationNode *DeclarationNode::cloneType( DeclarationNode *o ) {
         if ( o ) {
+                assert( storageClass == NoStorageClass );
                 o->copyStorageClasses( this );
                 if ( type ) {

src/Parser/ParseNode.h

@@ -10 +10 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Sep  8 21:58:06 2016
-// Update Count     : 587
+// Last Modified On : Sat Sep 10 17:14:37 2016
+// Update Count     : 589
 //
 
@@ -41 +41 @@
   public:
         ParseNode() {};
-        ParseNode( const std::string *name ) : name( *name ) { assert( false ); delete name; }
+        ParseNode( const std::string * name ) : name( * name ) { assert( false ); delete name; }
         ParseNode( const std::string &name ) : name( name ) { assert( false ); }
         virtual ~ParseNode() { delete next; };
-        virtual ParseNode *clone() const = 0;
-
-        ParseNode *get_next() const { return next; }
-        ParseNode *set_next( ParseNode *newlink ) { next = newlink; return this; }
-        ParseNode *get_last() {
-                ParseNode *current;
+        virtual ParseNode * clone() const = 0;
+
+        ParseNode * get_next() const { return next; }
+        ParseNode * set_next( ParseNode * newlink ) { next = newlink; return this; }
+        ParseNode * get_last() {
+                ParseNode * current;
                 for ( current = this; current->get_next() != 0; current = current->get_next() );
                 return current;
         }
-        ParseNode *set_last( ParseNode *newlast ) {
+        ParseNode * set_last( ParseNode * newlast ) {
                 if ( newlast != 0 ) get_last()->set_next( newlast );
                 return this;
@@ -66 +66 @@
         static int indent_by;
 
-        ParseNode *next = nullptr;
+        ParseNode * next = nullptr;
         std::string name;
 }; // ParseNode
@@ -74 +74 @@
 class InitializerNode : public ParseNode {
   public:
-        InitializerNode( ExpressionNode *, bool aggrp = false,  ExpressionNode *des = 0 );
-        InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode *des = 0 );
+        InitializerNode( ExpressionNode *, bool aggrp = false,  ExpressionNode * des = 0 );
+        InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = 0 );
         ~InitializerNode();
-        virtual InitializerNode *clone() const { assert( false ); return nullptr; }
-
-        ExpressionNode *get_expression() const { return expr; }
-
-        InitializerNode *set_designators( ExpressionNode *des ) { designator = des; return this; }
-        ExpressionNode *get_designators() const { return designator; }
-
-        InitializerNode *set_maybeConstructed( bool value ) { maybeConstructed = value; return this; }
+        virtual InitializerNode * clone() const { assert( false ); return nullptr; }
+
+        ExpressionNode * get_expression() const { return expr; }
+
+        InitializerNode * set_designators( ExpressionNode * des ) { designator = des; return this; }
+        ExpressionNode * get_designators() const { return designator; }
+
+        InitializerNode * set_maybeConstructed( bool value ) { maybeConstructed = value; return this; }
         bool get_maybeConstructed() const { return maybeConstructed; }
 
-        InitializerNode *next_init() const { return kids; }
+        InitializerNode * next_init() const { return kids; }
 
         void print( std::ostream &os, int indent = 0 ) const;
         void printOneLine( std::ostream & ) const;
 
-        virtual Initializer *build() const;
+        virtual Initializer * build() const;
   private:
-        ExpressionNode *expr;
+        ExpressionNode * expr;
         bool aggregate;
-        ExpressionNode *designator;                                                     // may be list
-        InitializerNode *kids;
+        ExpressionNode * designator;                                            // may be list
+        InitializerNode * kids;
         bool maybeConstructed;
 }; // InitializerNode
@@ -106 +106 @@
   public:
         ExpressionNode( Expression * expr = nullptr ) : expr( expr ) {}
-        ExpressionNode( Expression * expr, const std::string *name ) : ParseNode( name ), expr( expr ) {}
+        ExpressionNode( Expression * expr, const std::string * name ) : ParseNode( name ), expr( expr ) {}
         ExpressionNode( const ExpressionNode &other );
         virtual ~ExpressionNode() {}
-        virtual ExpressionNode *clone() const { return expr ? new ExpressionNode( expr->clone() ) : nullptr; }
+        virtual ExpressionNode * clone() const { return expr ? new ExpressionNode( expr->clone() ) : nullptr; }
 
         bool get_extension() const { return extension; }
-        ExpressionNode *set_extension( bool exten ) { extension = exten; return this; }
+        ExpressionNode * set_extension( bool exten ) { extension = exten; return this; }
 
         void print( std::ostream &os, int indent = 0 ) const {}
@@ -122 +122 @@
         }
 
-        Expression *build() const { return const_cast<ExpressionNode*>(this)->expr.release(); }
+        Expression * build() const { return const_cast<ExpressionNode*>(this)->expr.release(); }
   private:
         bool extension = false;
@@ -130 +130 @@
 template< typename T >
 struct maybeBuild_t< Expression, T > {
-        static inline Expression * doit( const T *orig ) {
+        static inline Expression * doit( const T * orig ) {
                 if ( orig ) {
-                        Expression *p = orig->build();
+                        Expression * p = orig->build();
                         p->set_extension( orig->get_extension() );
                         return p;
@@ -156 +156 @@
 };
 
-Expression *build_constantInteger( const std::string &str );
-Expression *build_constantFloat( const std::string &str );
-Expression *build_constantChar( const std::string &str );
-ConstantExpr *build_constantStr( const std::string &str );
-
-NameExpr *build_varref( const std::string *name, bool labelp = false );
-Expression *build_typevalue( DeclarationNode *decl );
-
-Expression *build_cast( DeclarationNode * decl_node, ExpressionNode *expr_node );
-Expression *build_fieldSel( ExpressionNode *expr_node, Expression *member );
-Expression *build_pfieldSel( ExpressionNode *expr_node, Expression *member );
-Expression *build_addressOf( ExpressionNode *expr_node );
-Expression *build_sizeOfexpr( ExpressionNode *expr_node );
-Expression *build_sizeOftype( DeclarationNode *decl_node );
-Expression *build_alignOfexpr( ExpressionNode *expr_node );
-Expression *build_alignOftype( DeclarationNode *decl_node );
-Expression *build_offsetOf( DeclarationNode *decl_node, NameExpr *member );
-Expression *build_and( ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
-Expression *build_and_or( ExpressionNode *expr_node1, ExpressionNode *expr_node2, bool kind );
-Expression *build_unary_val( OperKinds op, ExpressionNode *expr_node );
-Expression *build_unary_ptr( OperKinds op, ExpressionNode *expr_node );
-Expression *build_binary_val( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
-Expression *build_binary_ptr( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
-Expression *build_cond( ExpressionNode *expr_node1, ExpressionNode *expr_node2, ExpressionNode *expr_node3 );
-Expression *build_comma( ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
-Expression *build_attrexpr( NameExpr *var, ExpressionNode * expr_node );
-Expression *build_attrtype( NameExpr *var, DeclarationNode * decl_node );
-Expression *build_tuple( ExpressionNode * expr_node = 0 );
-Expression *build_func( ExpressionNode * function, ExpressionNode * expr_node );
-Expression *build_range( ExpressionNode * low, ExpressionNode *high );
-Expression *build_asmexpr( ExpressionNode *inout, ConstantExpr *constraint, ExpressionNode *operand );
-Expression *build_valexpr( StatementNode *s );
-Expression *build_compoundLiteral( DeclarationNode *decl_node, InitializerNode *kids );
+Expression * build_constantInteger( const std::string &str );
+Expression * build_constantFloat( const std::string &str );
+Expression * build_constantChar( const std::string &str );
+ConstantExpr * build_constantStr( const std::string &str );
+
+NameExpr * build_varref( const std::string * name, bool labelp = false );
+Expression * build_typevalue( DeclarationNode * decl );
+
+Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
+Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member );
+Expression * build_pfieldSel( ExpressionNode * expr_node, Expression * member );
+Expression * build_addressOf( ExpressionNode * expr_node );
+Expression * build_sizeOfexpr( ExpressionNode * expr_node );
+Expression * build_sizeOftype( DeclarationNode * decl_node );
+Expression * build_alignOfexpr( ExpressionNode * expr_node );
+Expression * build_alignOftype( DeclarationNode * decl_node );
+Expression * build_offsetOf( DeclarationNode * decl_node, NameExpr * member );
+Expression * build_and( ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
+Expression * build_and_or( ExpressionNode * expr_node1, ExpressionNode * expr_node2, bool kind );
+Expression * build_unary_val( OperKinds op, ExpressionNode * expr_node );
+Expression * build_unary_ptr( OperKinds op, ExpressionNode * expr_node );
+Expression * build_binary_val( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
+Expression * build_binary_ptr( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
+Expression * build_cond( ExpressionNode * expr_node1, ExpressionNode * expr_node2, ExpressionNode * expr_node3 );
+Expression * build_comma( ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
+Expression * build_attrexpr( NameExpr * var, ExpressionNode * expr_node );
+Expression * build_attrtype( NameExpr * var, DeclarationNode * decl_node );
+Expression * build_tuple( ExpressionNode * expr_node = 0 );
+Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node );
+Expression * build_range( ExpressionNode * low, ExpressionNode * high );
+Expression * build_asmexpr( ExpressionNode * inout, ConstantExpr * constraint, ExpressionNode * operand );
+Expression * build_valexpr( StatementNode * s );
+Expression * build_compoundLiteral( DeclarationNode * decl_node, InitializerNode * kids );
 
 //##############################################################################
@@ -204 +204 @@
         enum BuiltinType { Valist };
 
-        static const char *qualifierName[];
-        static const char *storageName[];
-        static const char *basicTypeName[];
-        static const char *modifierName[];
-        static const char *aggregateName[];
-        static const char *typeClassName[];
-        static const char *builtinTypeName[];
-
-        static DeclarationNode *newFunction( std::string *name, DeclarationNode *ret, DeclarationNode *param, StatementNode *body, bool newStyle = false );
-        static DeclarationNode *newQualifier( Qualifier );
-        static DeclarationNode *newForall( DeclarationNode *);
-        static DeclarationNode *newStorageClass( StorageClass );
-        static DeclarationNode *newBasicType( BasicType );
-        static DeclarationNode *newModifier( Modifier );
-        static DeclarationNode *newBuiltinType( BuiltinType );
-        static DeclarationNode *newFromTypedef( std::string *);
-        static DeclarationNode *newAggregate( Aggregate kind, const std::string *name, ExpressionNode *actuals, DeclarationNode *fields, bool body );
-        static DeclarationNode *newEnum( std::string *name, DeclarationNode *constants );
-        static DeclarationNode *newEnumConstant( std::string *name, ExpressionNode *constant );
-        static DeclarationNode *newName( std::string *);
-        static DeclarationNode *newFromTypeGen( std::string *, ExpressionNode *params );
-        static DeclarationNode *newTypeParam( TypeClass, std::string *);
-        static DeclarationNode *newTrait( std::string *name, DeclarationNode *params, DeclarationNode *asserts );
-        static DeclarationNode *newTraitUse( std::string *name, ExpressionNode *params );
-        static DeclarationNode *newTypeDecl( std::string *name, DeclarationNode *typeParams );
-        static DeclarationNode *newPointer( DeclarationNode *qualifiers );
-        static DeclarationNode *newArray( ExpressionNode *size, DeclarationNode *qualifiers, bool isStatic );
-        static DeclarationNode *newVarArray( DeclarationNode *qualifiers );
-        static DeclarationNode *newBitfield( ExpressionNode *size );
-        static DeclarationNode *newTuple( DeclarationNode *members );
-        static DeclarationNode *newTypeof( ExpressionNode *expr );
-        static DeclarationNode *newAttr( std::string *, ExpressionNode *expr );
-        static DeclarationNode *newAttr( std::string *, DeclarationNode *type );
+        static const char * qualifierName[];
+        static const char * storageName[];
+        static const char * basicTypeName[];
+        static const char * modifierName[];
+        static const char * aggregateName[];
+        static const char * typeClassName[];
+        static const char * builtinTypeName[];
+
+        static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false );
+        static DeclarationNode * newQualifier( Qualifier );
+        static DeclarationNode * newForall( DeclarationNode *);
+        static DeclarationNode * newStorageClass( StorageClass );
+        static DeclarationNode * newBasicType( BasicType );
+        static DeclarationNode * newModifier( Modifier );
+        static DeclarationNode * newBuiltinType( BuiltinType );
+        static DeclarationNode * newFromTypedef( std::string *);
+        static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
+        static DeclarationNode * newEnum( std::string * name, DeclarationNode * constants );
+        static DeclarationNode * newEnumConstant( std::string * name, ExpressionNode * constant );
+        static DeclarationNode * newName( std::string *);
+        static DeclarationNode * newFromTypeGen( std::string *, ExpressionNode * params );
+        static DeclarationNode * newTypeParam( TypeClass, std::string *);
+        static DeclarationNode * newTrait( std::string * name, DeclarationNode * params, DeclarationNode * asserts );
+        static DeclarationNode * newTraitUse( std::string * name, ExpressionNode * params );
+        static DeclarationNode * newTypeDecl( std::string * name, DeclarationNode * typeParams );
+        static DeclarationNode * newPointer( DeclarationNode * qualifiers );
+        static DeclarationNode * newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic );
+        static DeclarationNode * newVarArray( DeclarationNode * qualifiers );
+        static DeclarationNode * newBitfield( ExpressionNode * size );
+        static DeclarationNode * newTuple( DeclarationNode * members );
+        static DeclarationNode * newTypeof( ExpressionNode * expr );
+        static DeclarationNode * newAttr( std::string *, ExpressionNode * expr );
+        static DeclarationNode * newAttr( std::string *, DeclarationNode * type );
 
         DeclarationNode();
         ~DeclarationNode();
-        DeclarationNode *clone() const;
-
-        DeclarationNode *addQualifiers( DeclarationNode *);
+        DeclarationNode * clone() const;
+
+        DeclarationNode * addQualifiers( DeclarationNode *);
         void checkQualifiers( const TypeData *, const TypeData * );
-        DeclarationNode *copyStorageClasses( DeclarationNode *);
-        DeclarationNode *addType( DeclarationNode *);
-        DeclarationNode *addTypedef();
-        DeclarationNode *addAssertions( DeclarationNode *);
-        DeclarationNode *addName( std::string *);
-        DeclarationNode *addBitfield( ExpressionNode *size );
-        DeclarationNode *addVarArgs();
-        DeclarationNode *addFunctionBody( StatementNode *body );
-        DeclarationNode *addOldDeclList( DeclarationNode *list );
-        DeclarationNode *addPointer( DeclarationNode *qualifiers );
-        DeclarationNode *addArray( DeclarationNode *array );
-        DeclarationNode *addNewPointer( DeclarationNode *pointer );
-        DeclarationNode *addNewArray( DeclarationNode *array );
-        DeclarationNode *addParamList( DeclarationNode *list );
-        DeclarationNode *addIdList( DeclarationNode *list ); // old-style functions
-        DeclarationNode *addInitializer( InitializerNode *init );
-
-        DeclarationNode *cloneType( std::string *newName );
-        DeclarationNode *cloneType( DeclarationNode *existing );
-        DeclarationNode *cloneType( int ) { return cloneType( ( std::string *)0 ); }
-        DeclarationNode *cloneBaseType( std::string *newName );
-        DeclarationNode *cloneBaseType( DeclarationNode *newdecl );
-
-        DeclarationNode *appendList( DeclarationNode *node ) {
+        void checkStorageClasses( DeclarationNode *q );
+        DeclarationNode * copyStorageClasses( DeclarationNode *);
+        DeclarationNode * addType( DeclarationNode *);
+        DeclarationNode * addTypedef();
+        DeclarationNode * addAssertions( DeclarationNode *);
+        DeclarationNode * addName( std::string *);
+        DeclarationNode * addBitfield( ExpressionNode * size );
+        DeclarationNode * addVarArgs();
+        DeclarationNode * addFunctionBody( StatementNode * body );
+        DeclarationNode * addOldDeclList( DeclarationNode * list );
+        DeclarationNode * addPointer( DeclarationNode * qualifiers );
+        DeclarationNode * addArray( DeclarationNode * array );
+        DeclarationNode * addNewPointer( DeclarationNode * pointer );
+        DeclarationNode * addNewArray( DeclarationNode * array );
+        DeclarationNode * addParamList( DeclarationNode * list );
+        DeclarationNode * addIdList( DeclarationNode * list ); // old-style functions
+        DeclarationNode * addInitializer( InitializerNode * init );
+
+        DeclarationNode * cloneType( std::string * newName );
+        DeclarationNode * cloneType( DeclarationNode * existing );
+        DeclarationNode * cloneType( int ) { return cloneType( ( std::string *)0 ); }
+        DeclarationNode * cloneBaseType( std::string * newName );
+        DeclarationNode * cloneBaseType( DeclarationNode * newdecl );
+
+        DeclarationNode * appendList( DeclarationNode * node ) {
                 return (DeclarationNode *)set_last( node );
         }
@@ -274 +275 @@
         void printList( std::ostream &os, int indent = 0 ) const;
 
-        Declaration *build() const;
-        ::Type *buildType() const;
+        Declaration * build() const;
+        ::Type * buildType() const;
 
         bool get_hasEllipsis() const;
         const std::string &get_name() const { return name; }
         LinkageSpec::Spec get_linkage() const { return linkage; }
-        DeclarationNode *extractAggregate() const;
+        DeclarationNode * extractAggregate() const;
         bool has_enumeratorValue() const { return (bool)enumeratorValue; }
-        ExpressionNode *consume_enumeratorValue() const { return const_cast<DeclarationNode*>(this)->enumeratorValue.release(); }
+        ExpressionNode * consume_enumeratorValue() const { return const_cast<DeclarationNode*>(this)->enumeratorValue.release(); }
 
         bool get_extension() const { return extension; }
-        DeclarationNode *set_extension( bool exten ) { extension = exten; return this; }
+        DeclarationNode * set_extension( bool exten ) { extension = exten; return this; }
   public:
         // StorageClass buildStorageClass() const;
@@ -306 +307 @@
         BuiltinType builtin;
 
-        TypeData *type;
+        TypeData * type;
         std::string name;
         // std::list< StorageClass > storageClasses;
@@ -312 +313 @@
         bool isInline, isNoreturn;
         std::list< std::string > attributes;
-        ExpressionNode *bitfieldWidth;
+        ExpressionNode * bitfieldWidth;
         std::unique_ptr<ExpressionNode> enumeratorValue;
-        InitializerNode *initializer;
+        InitializerNode * initializer;
         bool hasEllipsis;
         LinkageSpec::Spec linkage;
@@ -323 +324 @@
 }; // DeclarationNode
 
-Type *buildType( TypeData *type );
+Type * buildType( TypeData * type );
 //Type::Qualifiers buildQualifiers( const TypeData::Qualifiers & qualifiers );
 
-static inline Type * maybeMoveBuildType( const DeclarationNode *orig ) {
+static inline Type * maybeMoveBuildType( const DeclarationNode * orig ) {
         Type* ret = orig ? orig->buildType() : nullptr;
         delete orig;
@@ -337 +338 @@
   public:
         StatementNode() { stmt = nullptr; }
-        StatementNode( Statement *stmt ) : stmt( stmt ) {}
-        StatementNode( DeclarationNode *decl );
+        StatementNode( Statement * stmt ) : stmt( stmt ) {}
+        StatementNode( DeclarationNode * decl );
         virtual ~StatementNode() {}
 
-        virtual StatementNode *clone() const final { assert( false ); return nullptr; }
-        Statement *build() const { return const_cast<StatementNode*>(this)->stmt.release(); }
-
-        virtual StatementNode *add_label( const std::string * name ) {
-                stmt->get_labels().emplace_back( *name );
+        virtual StatementNode * clone() const final { assert( false ); return nullptr; }
+        Statement * build() const { return const_cast<StatementNode*>(this)->stmt.release(); }
+
+        virtual StatementNode * add_label( const std::string * name ) {
+                stmt->get_labels().emplace_back( * name );
                 delete name;
                 return this;
         }
 
-        virtual StatementNode *append_last_case( StatementNode * );
+        virtual StatementNode * append_last_case( StatementNode * );
 
         virtual void print( std::ostream &os, int indent = 0 ) {}
@@ -358 +359 @@
 }; // StatementNode
 
-Statement *build_expr( ExpressionNode *ctl );
+Statement * build_expr( ExpressionNode * ctl );
 
 struct ForCtl {
-        ForCtl( ExpressionNode *expr, ExpressionNode *condition, ExpressionNode *change ) :
+        ForCtl( ExpressionNode * expr, ExpressionNode * condition, ExpressionNode * change ) :
                 init( new StatementNode( build_expr( expr ) ) ), condition( condition ), change( change ) {}
-        ForCtl( DeclarationNode *decl, ExpressionNode *condition, ExpressionNode *change ) :
+        ForCtl( DeclarationNode * decl, ExpressionNode * condition, ExpressionNode * change ) :
                 init( new StatementNode( decl ) ), condition( condition ), change( change ) {}
 
-        StatementNode *init;
-        ExpressionNode *condition;
-        ExpressionNode *change;
+        StatementNode * init;
+        ExpressionNode * condition;
+        ExpressionNode * change;
 };
 
-Statement *build_if( ExpressionNode *ctl, StatementNode *then_stmt, StatementNode *else_stmt );
-Statement *build_switch( ExpressionNode *ctl, StatementNode *stmt );
-Statement *build_case( ExpressionNode *ctl );
-Statement *build_default();
-Statement *build_while( ExpressionNode *ctl, StatementNode *stmt, bool kind = false );
-Statement *build_for( ForCtl *forctl, StatementNode *stmt );
-Statement *build_branch( BranchStmt::Type kind );
-Statement *build_branch( std::string *identifier, BranchStmt::Type kind );
-Statement *build_computedgoto( ExpressionNode *ctl );
-Statement *build_return( ExpressionNode *ctl );
-Statement *build_throw( ExpressionNode *ctl );
-Statement *build_try( StatementNode *try_stmt, StatementNode *catch_stmt, StatementNode *finally_stmt );
-Statement *build_catch( DeclarationNode *decl, StatementNode *stmt, bool catchAny = false );
-Statement *build_finally( StatementNode *stmt );
-Statement *build_compound( StatementNode *first );
-Statement *build_asmstmt( bool voltile, ConstantExpr *instruction, ExpressionNode *output = 0, ExpressionNode *input = 0, ExpressionNode *clobber = 0, LabelNode *gotolabels = 0 );
+Statement * build_if( ExpressionNode * ctl, StatementNode * then_stmt, StatementNode * else_stmt );
+Statement * build_switch( ExpressionNode * ctl, StatementNode * stmt );
+Statement * build_case( ExpressionNode * ctl );
+Statement * build_default();
+Statement * build_while( ExpressionNode * ctl, StatementNode * stmt, bool kind = false );
+Statement * build_for( ForCtl * forctl, StatementNode * stmt );
+Statement * build_branch( BranchStmt::Type kind );
+Statement * build_branch( std::string * identifier, BranchStmt::Type kind );
+Statement * build_computedgoto( ExpressionNode * ctl );
+Statement * build_return( ExpressionNode * ctl );
+Statement * build_throw( ExpressionNode * ctl );
+Statement * build_try( StatementNode * try_stmt, StatementNode * catch_stmt, StatementNode * finally_stmt );
+Statement * build_catch( DeclarationNode * decl, StatementNode * stmt, bool catchAny = false );
+Statement * build_finally( StatementNode * stmt );
+Statement * build_compound( StatementNode * first );
+Statement * build_asmstmt( bool voltile, ConstantExpr * instruction, ExpressionNode * output = 0, ExpressionNode * input = 0, ExpressionNode * clobber = 0, LabelNode * gotolabels = 0 );
 
 //##############################################################################
 
 template< typename SynTreeType, typename NodeType >
-void buildList( const NodeType *firstNode, std::list< SynTreeType * > &outputList ) {
+void buildList( const NodeType * firstNode, std::list< SynTreeType * > &outputList ) {
         SemanticError errors;
         std::back_insert_iterator< std::list< SynTreeType * > > out( outputList );
-        const NodeType *cur = firstNode;
+        const NodeType * cur = firstNode;
 
         while ( cur ) {
                 try {
-//                      SynTreeType *result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::result_of< decltype(&NodeType::build)(NodeType)>::type >( cur ) );
-                        SynTreeType *result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::pointer_traits< decltype(cur->build())>::element_type >( cur ) );
+//                      SynTreeType * result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::result_of< decltype(&NodeType::build)(NodeType)>::type >( cur ) );
+                        SynTreeType * result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::pointer_traits< decltype(cur->build())>::element_type >( cur ) );
                         if ( result ) {
-                                *out++ = result;
+                                * out++ = result;
                         } // if
                 } catch( SemanticError &e ) {
@@ -414 +415 @@
 
 // in DeclarationNode.cc
-void buildList( const DeclarationNode *firstNode, std::list< Declaration * > &outputList );
-void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType * > &outputList );
-void buildTypeList( const DeclarationNode *firstNode, std::list< Type * > &outputList );
+void buildList( const DeclarationNode * firstNode, std::list< Declaration * > &outputList );
+void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > &outputList );
+void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > &outputList );
 
 template< typename SynTreeType, typename NodeType >
-void buildMoveList( const NodeType *firstNode, std::list< SynTreeType * > &outputList ) {
+void buildMoveList( const NodeType * firstNode, std::list< SynTreeType * > &outputList ) {
         buildList(firstNode, outputList);
         delete firstNode;

src/Parser/TypeData.h

@@ -10 +10 @@
 // Created On       : Sat May 16 15:18:36 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Sep  9 23:20:55 2016
-// Update Count     : 117
+// Last Modified On : Sat Sep 10 09:42:54 2016
+// Update Count     : 118
 //
 
@@ -89 +89 @@
         typedef std::bitset< DeclarationNode::NoOfQualifier > Qualifiers;
         Qualifiers qualifiers;
+        typedef std::bitset< DeclarationNode::NoStorageClass > StorageClasses;
+        StorageClasses storageclasses;
         DeclarationNode * forall;
 

src/Parser/parser.cc

@@ -5943 +5943 @@
 /* Line 1806 of yacc.c  */
 #line 831 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_while( (yyvsp[(5) - (7)].en), (yyvsp[(2) - (7)].sn) ) ); }
+    { (yyval.sn) = new StatementNode( build_while( (yyvsp[(5) - (7)].en), (yyvsp[(2) - (7)].sn), true ) ); }
     break;
 

src/Parser/parser.yy

@@ -829 +829 @@
                 { $$ = new StatementNode( build_while( $3, $5 ) ); }
         | DO statement WHILE '(' comma_expression ')' ';'
-                { $$ = new StatementNode( build_while( $5, $2 ) ); }
+                { $$ = new StatementNode( build_while( $5, $2, true ) ); }
         | FOR '(' push for_control_expression ')' statement
                 { $$ = new StatementNode( build_for( $4, $6 ) ); }

src/examples/gc_no_raii/bug-repro/field.c

@@ -62 +62 @@
 {
         struct gc_object_header* object;
-        #if _DEBUG
+        #ifndef NDEBUG
                 intptr_t lower_limit;
                 intptr_t upper_limit;
@@ -71 +71 @@
                 gc_pool_object_iterator* const this,
                 void* start_object
-                #if _DEBUG
+                #ifndef NDEBUG
                         , intptr_t pool_start
                         , intptr_t pool_end

src/examples/gc_no_raii/src/gcpointers.c

@@ -14 +14 @@
                 gc_object_header* obj = gc_get_object_for_ref(gc_get_state(), (void*)this);
                 check(obj);
-                check(gc_obj_is_valide(obj));
-                check(gc_is_managed(this) == gc_is_managed(obj->type_chain) || obj->type_chain == NULL);
+                check(is_valid(obj));
+                check(gc_is_managed(this) == gc_is_managed(obj->type_chain) || !obj->type_chain);
                 this->next = obj->type_chain;
                 obj->type_chain = this;
-                check(obj->is_valide());
+                check(is_valid(obj));
         }
         else
@@ -24 +24 @@
                 gc_object_header* obj = gc_get_object_ptr((void*)this->ptr);
                 check(obj);
-                check(gc_obj_is_valide(obj));
-                check(gc_is_managed(this) == gc_is_managed(obj->root_chain) || obj->root_chain == NULL);
+                check(is_valid(obj));
+                check(!obj->root_chain || this->ptr == obj->root_chain->ptr);
+                check(!obj->root_chain || gc_is_managed(this) == gc_is_managed(obj->root_chain));
                 this->next = obj->root_chain;
                 obj->root_chain = this;
-                check(gc_obj_is_valide(obj));
+                check(is_valid(obj));
         }
 }
@@ -69 +70 @@
 }
 
-gcpointer_t* gcpointer_assign(gcpointer_t* this, gcpointer_t* rhs)
+gcpointer_t ?=?(gcpointer_t* this, gcpointer_t rhs)
 {
-        if(this != rhs)
-        {
-                unregister_ptr(this);
+        unregister_ptr(this);
+        this->ptr = rhs.ptr;
+        register_ptr(this);
 
-                this->ptr = rhs->ptr;
-
-                register_ptr(this);
-        }
-
-        return this;
+        return *this;
 }
 
 //Logical operators
-bool gcpointer_equal(gcpointer_t* this, gcpointer_t* rhs)
+bool gcpointer_equal(const gcpointer_t* this, const gcpointer_t* rhs)
 {
         return this->ptr == rhs->ptr;
 }
 
-bool gcpointer_not_equal(gcpointer_t* this, gcpointer_t* rhs)
+bool gcpointer_not_equal(const gcpointer_t* this, const gcpointer_t* rhs)
 {
         return this->ptr != rhs->ptr;
 }
 
-bool gcpointer_null(gcpointer_t* this)
+bool gcpointer_null(const gcpointer_t* this)
 {
         return this->ptr == (intptr_t)NULL;
 }
+
+#ifndef NDEBUG
+        bool is_valid(const gcpointer_t* this) {
+                if(gcpointer_null(this)) return true;
+
+                gc_object_header* obj = gc_get_object_ptr((void*)this->ptr);
+                check(obj);
+                check(is_valid(obj));
+                check(!obj->root_chain || this->ptr == obj->root_chain->ptr);
+
+                if( !gc_is_managed(this))
+                {
+                        check( !(this->next) || this->ptr == this->next->ptr );
+                }
+
+                return true;
+        }
+#endif
 
 forall(otype T) void ?{}(gcpointer(T)* this) {
@@ -107 +121 @@
 }
 
-forall(otype T) void ?{}(gcpointer(T)* this, gcpointer(T)* other) {
-        (&this->internal) { other->internal };
+forall(otype T) void ?{}(gcpointer(T)* this, gcpointer(T) other) {
+        (&this->internal) { other.internal };
 }
 
@@ -115 +129 @@
 }
 
-// forall(otype T) gcpointer(T) ?=?(gcpointer(T) this, gcpointer(T) rhs);
+forall(otype T) gcpointer(T) ?=?(gcpointer(T)* this, gcpointer(T) rhs) {
+        this->internal = rhs.internal;
+        return *this;
+}
 //
 // forall(otype T) T *?(gcpointer(T) this);
@@ -124 +141 @@
 //
 // //Logical operators
+forall(otype T) int ?!=?(gcpointer(T) this, int zero) {
+        return this.internal.ptr != 0;
+}
 // forall(otype T) int ?!=?(gcpointer(T) this, gcpointer(T) rhs);
 // forall(otype T) int ?==?(gcpointer(T) this, gcpointer(T) rhs);

src/examples/gc_no_raii/src/gcpointers.h

@@ -3 +3 @@
 #include <stdbool.h>
 #include <stdint.h>
+
+forall(dtype T)
+struct gcpointer;
 
 struct gcpointer_t
@@ -14 +17 @@
 void ?{}(gcpointer_t* this, gcpointer_t other);
 void ^?{}(gcpointer_t* this);
-gcpointer_t* ?=?(gcpointer_t this, gcpointer_t rhs);
+gcpointer_t ?=?(gcpointer_t* this, gcpointer_t rhs);
 
 //Logical operators
 bool gcpointer_equal(gcpointer_t* this, gcpointer_t* rhs);
 bool gcpointer_not_equal(gcpointer_t* this, gcpointer_t* rhs);
-bool gcpointer_null(gcpointer_t* this);
+bool gcpointer_null(const gcpointer_t* this);
 
-forall(otype T)
+
+#ifndef NDEBUG
+        bool is_valid(const gcpointer_t* this);
+#endif
+
+forall(dtype T)
 struct gcpointer
 {
@@ -30 +38 @@
 forall(otype T) void ?{}(gcpointer(T)* this);
 forall(otype T) void ?{}(gcpointer(T)* this, void* address);
-forall(otype T) void ?{}(gcpointer(T)* this, gcpointer(T)* other);
+forall(otype T) void ?{}(gcpointer(T)* this, gcpointer(T) other);
 forall(otype T) void ^?{}(gcpointer(T)* this);
-forall(otype T) gcpointer(T) ?=?(gcpointer(T) this, gcpointer(T) rhs);
+forall(otype T) gcpointer(T) ?=?(gcpointer(T)* this, gcpointer(T) rhs);
 
 
-forall(otype T) T *?(gcpointer(T) this);
+// forall(otype T) T *?(gcpointer(T) this);
 forall(otype T) T* get(gcpointer(T)* this);
 
 //Logical operators
+forall(otype T) int ?!=?(gcpointer(T) this, int zero);
 forall(otype T) int ?!=?(gcpointer(T) this, gcpointer(T) rhs);
 forall(otype T) int ?==?(gcpointer(T) this, gcpointer(T) rhs);

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

@@ -1 +1 @@
 #pragma once
-
-#include <stdlib>
 
 #include "globals.h"
@@ -9 +7 @@
 {
         size_t card = ( ((intptr_t)address) & CARDS_OFFSET_MASK ) >> CARDS_SIZE_EXP;
+        checkf(card < CARDS_COUNT, (const char*)"%lu %lu = (%lx & %lx) >> %lu\n", (size_t)CARDS_COUNT, (size_t)card, (size_t)address, (size_t)CARDS_OFFSET_MASK, (size_t)CARDS_SIZE_EXP);
         check(card < CARDS_COUNT);
         return card;
@@ -19 +18 @@
 };
 
-static inline void ctor(card_table_t* const this)
+static inline void ctor_card(card_table_t* const this)
 {
         this->count = 0;
 }
 
-static inline void dtor(card_table_t* const this)
+static inline void dtor_card(card_table_t* const this)
 {
 
@@ -48 +47 @@
         else
         {
-                check(card == count);
+                check(card == this->count);
                 this->count++;
                 this->cards_start[card] = object;

src/examples/gc_no_raii/src/internal/collector.c

@@ -25 +25 @@
         gc_object_header* obj = gc_get_object_ptr((void*)target->ptr);
 
-        check(gc_is_valide(obj));
+        check(is_valid(obj));
 
         gcpointer_t** prev_next_ptr = managed ? &obj->type_chain : &obj->root_chain;
@@ -38 +38 @@
 void* gc_allocate(size_t target_size)
 {
-        sout | "Allocating " | target_size | " bytes" | endl;
+        // sout | "Allocating " | target_size | " bytes" | endl;
 
         size_t size = gc_compute_size(target_size + sizeof(gc_object_header));
 
-        sout | "Object header size: " | sizeof(gc_object_header) | " bytes" | endl;
-        sout | "Actual allocation size: " | size | " bytes" | endl;
+        // sout | "Object header size: " | sizeof(gc_object_header) | " bytes" | endl;
+        // sout | "Actual allocation size: " | size | " bytes" | endl;
 
         check(size < POOL_SIZE_BYTES);
@@ -60 +60 @@
         if((intptr_t)(block = gc_try_allocate(gc, size))) return gc_finish_alloc_block(block, size, target_size);
 
-        checkf(false, "ERROR: allocation in new pool failed");
+        checkf( (int) 0, "ERROR: allocation in new pool failed");
 
         return NULL;
@@ -67 +67 @@
 void* gc_finish_alloc_block(void* block, size_t actual_size, size_t target_size)
 {
-        void* data = (void*)(((intptr_t)block) + sizeof(gc_object_header));
+        intptr_t data = ((intptr_t)block) + sizeof(gc_object_header);
         void* header = block;
 
-        check(((intptr_t)data) > ((intptr_t)block));
-        check(((intptr_t)data) >= ((intptr_t)header));
-        check(is_aligned(data));
-        check(((intptr_t)data) + target_size <= ((intptr_t)block) + actual_size);
+        check( data > ((intptr_t)block));
+        check( data >= ((intptr_t)header));
+        check( gc_is_aligned( (void*)data ) );
+        check( data + target_size <= ((intptr_t)block) + actual_size );
 
         gc_object_header* obj = placement_ctor(header, actual_size);
 
         (void)obj; //remove unsused warning since this is for debug
-        check(obj == get_object_ptr(data));
+        check(obj == gc_get_object_ptr( (void*)data ));
 
         gc_register_allocation(gc_get_state(), actual_size);
 
-        return data;
+        return (void*)data;
 }
 
@@ -119 +119 @@
         check(!ptr->forward);
         check(!ptr->is_forwarded);
-        check(gc_is_from_space(gc_pool_of(ptr)));
+        check(gc_pool_is_from_space(gc_pool_of(ptr)));
 
         gc_memory_pool* pool = gc_pool_of(ptr)->mirror;
@@ -143 +143 @@
                 check(((intptr_t)field) < ((intptr_t)((intptr_t)object) + object->size));
 
-                check(gc_is_in_to_space(gc_get_state(), &type->ptr));
+                check(gc_is_in_to_space(gc_get_state(), &field->ptr));
 
                 intptr_t* ref = &field->ptr;

src/examples/gc_no_raii/src/internal/collector.h

@@ -1 +1 @@
 #pragma once
 
-#include <stdlib>
+#include <stdlib.h>
 
 #include "tools.h"

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

@@ -1 +1 @@
 #include "memory_pool.h"
 
-#include <stdlib>
+extern "C" {
+        #include <stdlib.h>
+        #include <string.h>
+}
 
+#include "collector.h"
 #include "object_header.h"
 
@@ -15 +19 @@
         card_table_t* new = (card_table_t*)malloc(sizeof(card_table_t));
         this->cards = new;
-        ctor(this->cards);
+        ctor_card(this->cards);
 
         this->end_p = ((uint8_t*)this) + size;
         this->free_p = this->start_p;
 
-        check(gc_pool_of(this) == this);
+        check( gc_pool_of( (void*)this ) == this);
         check(this->cards);
         gc_reset_pool(this);
@@ -27 +31 @@
 void dtor(gc_memory_pool *const this)
 {
-        dtor(this->cards);
+        dtor_card(this->cards);
         free(this->cards);
 }
@@ -34 +38 @@
 {
         this->free_p = this->start_p;
-        #if _DEBUG
-                memset(this->start_p, 0xCD, gc_pool_total_size(this));
+        #ifndef NDEBUG
+                memset(this->start_p, 0xCD, gc_pool_size_total(this));
         #endif
 
@@ -41 +45 @@
         reset(this->cards);
 
-        check(gc_pool_size_left(this) == gc_pool_total_size(this));
+        check(gc_pool_size_left(this) == gc_pool_size_total(this));
 }
 
@@ -58 +62 @@
 }
 
-void ctor(
-                gc_pool_object_iterator* const this,
+void ?{}(       gc_pool_object_iterator* this,
                 struct gc_object_header* start_object
-                #if _DEBUG
+                #ifndef NDEBUG
                         , intptr_t pool_start
                         , intptr_t pool_end
@@ -68 +71 @@
 {
         this->object = start_object;
-        #if _DEBUG
+        #ifndef NDEBUG
                 this->lower_limit = pool_start;
                 this->upper_limit = pool_end;
         #endif
 
-        check( ((intptr_t)start_object) >= lower_limit );
-        check( ((intptr_t)start_object) <= upper_limit );
+        check( ((intptr_t)start_object) >= this->lower_limit );
+        check( ((intptr_t)start_object) <= this->upper_limit );
 }
+
+void ^?{}( gc_pool_object_iterator* this ) {}
 
 gc_pool_object_iterator gc_pool_iterator_for(gc_memory_pool* const this, void* member)
@@ -81 +86 @@
         size_t card = card_of(member);
         intptr_t member_add = (intptr_t)member;
-        void* start_obj;
-        intptr_t start_obj_add;
+        intptr_t start_obj;
 
         do
         {
                 check(card < CARDS_COUNT);
-                start_obj = object_at(this->cards, card);
+                start_obj = (intptr_t)object_at(this->cards, card);
                 check(card != 0 || start_obj);
                 card--;
-                start_obj_add = (intptr_t)start_obj;
         }
-        while(start_obj_add > member_add || start_obj_add != 0);
+        while(start_obj > member_add || !(start_obj));
 
-        check(start_obj);
-        
+        check( start_obj );
+
         struct gc_object_header* start_obj_typed = (struct gc_object_header*)start_obj;
 
-        gc_pool_object_iterator it;
-        ctor( &it,
-                start_obj_typed,
-                #if _DEBUG
+        return (gc_pool_object_iterator) {
+                start_obj_typed
+                #ifndef NDEBUG
                         , (intptr_t)this->start_p
                         , (intptr_t)this->free_p
                 #endif
-        );
-        return it;
+        };
 }
 
@@ -117 +118 @@
 {
         struct gc_object_header* start_obj = (struct gc_object_header*)this->start_p;
-        gc_pool_object_iterator it;
-        ctor( &it,
-                start_obj,
-                #if _DEBUG
+        return (gc_pool_object_iterator) {
+                start_obj
+                #ifndef NDEBUG
                         , (intptr_t)this->start_p
                         , (intptr_t)this->free_p
                 #endif
-        );
-        return it;
+        };
 }
 
 gc_pool_object_iterator end(gc_memory_pool* const this)
 {
-        gc_pool_object_iterator it;
-        ctor( &it,
-                (struct gc_object_header*)this->free_p,
-                #if _DEBUG
+        return (gc_pool_object_iterator) {
+                (struct gc_object_header*)this->free_p
+                #ifndef NDEBUG
                         , (intptr_t)this->start_p
                         , (intptr_t)this->free_p
                 #endif
-        );
-        return it;
+        };
 }
 
@@ -145 +142 @@
         struct gc_object_header* object = it->object;
         intptr_t next_ptr = ((intptr_t)object) + object->size;
-        check(next_ptr > lower_limit);
-        check(next_ptr <= upper_limit);
+        check(next_ptr > it->lower_limit);
+        check(next_ptr <= it->upper_limit);
 
         struct gc_object_header* next_obj = ((struct gc_object_header*)next_ptr);
-        check(next_ptr == upper_limit || is_valide(next_obj));
+        check(next_ptr == it->upper_limit || is_valid(next_obj));
 
         it->object = next_obj;

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

@@ -39 +39 @@
 {
         struct gc_object_header* object;
-        #if _DEBUG
+        #ifndef NDEBUG
                 intptr_t lower_limit;
                 intptr_t upper_limit;
@@ -46 +46 @@
 
 
-void ctor(
-                gc_pool_object_iterator* const this,
+void ?{}(       gc_pool_object_iterator* this,
                 struct gc_object_header* start_object
-                #if _DEBUG
+                #ifndef NDEBUG
                         , intptr_t pool_start
                         , intptr_t pool_end
                 #endif
         );
+
+void ^?{}( gc_pool_object_iterator* this );
 
 bool ?!=?(const gc_pool_object_iterator lhs, const gc_pool_object_iterator rhs);

src/examples/gc_no_raii/src/internal/object_header.c

@@ -3 +3 @@
 #include <stdint.h>
 
+#include "collector.h"
 #include "globals.h"
 #include "gcpointers.h"
@@ -8 +9 @@
 void ctor(gc_object_header* const this, size_t inSize)
 {
-        #if _DEBUG
+        #ifndef NDEBUG
                 this->canary_start = CANARY_VALUE;
         #endif
@@ -18 +19 @@
         this->is_forwarded = false;
 
-        #if _DEBUG
+        #ifndef NDEBUG
                 this->canary_end = CANARY_VALUE;
         #endif
@@ -25 +26 @@
 void copy_ctor(gc_object_header* const this, const gc_object_header* const other)
 {
-        #if _DEBUG
+        #ifndef NDEBUG
                 this->canary_start = CANARY_VALUE;
         #endif
@@ -35 +36 @@
         this->is_forwarded = false;
 
-        #if _DEBUG
+        #ifndef NDEBUG
                 this->canary_end = CANARY_VALUE;
         #endif
@@ -42 +43 @@
         while(root)
         {
-                check(get_object_ptr(root->ptr) == other);
+                check(gc_get_object_ptr( (void*)root->ptr ) == other);
                 root->ptr = ((intptr_t)this) + sizeof(gc_object_header);
 
-                check(get_object_ptr(root->ptr) == this);
+                check(gc_get_object_ptr( (void*)root->ptr ) == this);
                 root = root->next;
         }
@@ -56 +57 @@
 
                 size_t offset = (intptr_t)type - (intptr_t)other;
-                check(offset < size);
+                check(offset < this->size);
 
                 gcpointer_t* member_ptr = (gcpointer_t*)( (intptr_t)this + offset );
@@ -63 +64 @@
 
                 size_t next_offset = type->next ? (intptr_t)type->next - (intptr_t)other : 0;
-                check(next_offset < size);
+                check(next_offset < this->size);
 
                 gcpointer_t* next_ptr = type->next ? (gcpointer_t*)((intptr_t)this + next_offset) : NULL;
@@ -73 +74 @@
         }
 
-        check(is_valide(this));
+        check(is_valid(this));
 }
 
-#if _DEBUG
-        bool is_valide(const gc_object_header* const this)
+#ifndef NDEBUG
+        bool is_valid(const gc_object_header* const this)
         {
-                check(this->canary_start == CANARY_VALUE);
-                check(this->canary_end == CANARY_VALUE);
+                check((intptr_t)this->canary_start == (intptr_t)CANARY_VALUE);
+                check((intptr_t)this->canary_end == (intptr_t)CANARY_VALUE);
 
-                check(this->is_forwarded == (this->forward != nullptr));
+                check(this->is_forwarded == ( (intptr_t)this->forward != (intptr_t)NULL));
 
                 check(this->size < POOL_SIZE_BYTES);
@@ -89 +90 @@
                 while(root)
                 {
-                        check(get_object_ptr(root->ptr) == this);
+                        checkf(gc_get_object_ptr( (void*)root->ptr ) == this, (const char*)"Expected %lX got %lX\n", gc_get_object_ptr( (void*)root->ptr ), this);
 
                         root = root->next;
                 }
 
-                gcpointer_t* type = type_chain;
+                gcpointer_t* type = this->type_chain;
                 while(type)
                 {
                         check((intptr_t)type > (intptr_t)this);
-                        check((intptr_t)type < (intptr_t)((intptr_t)this + size));
+                        check((intptr_t)type < (intptr_t)(((intptr_t)this) + this->size));
 
                         type = type->next;
@@ -105 +106 @@
                 return true;
         }
+        #else
+        #error blarg
 #endif

src/examples/gc_no_raii/src/internal/object_header.h

@@ -7 +7 @@
 #include "tools.h"
 
-#if DEBUG
-        static const long unsigned int CANARY_VALUE = 0xCAFEBABACAFEBABA;
+#ifndef NDEBUG
+        static void* const CANARY_VALUE = (void*)0xCAFEBABACAFEBABA;
 #endif
 
@@ -16 +16 @@
 struct gc_object_header
 {
-        #if DEBUG
+        #ifndef NDEBUG
                 void* canary_start;
         #endif
@@ -26 +26 @@
         bool                    is_forwarded;
 
-        #if DEBUG
+        #ifndef NDEBUG
                 void* canary_end;
         #endif
@@ -47 +47 @@
         return this;
 }
+
+#ifndef NDEBUG
+        bool is_valid(const gc_object_header* const this);
+#endif

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

@@ -21 +21 @@
 void gc_state_calc_usage(gc_state *const this);
 
-#if DEBUG
+#ifndef NDEBUG
         bool gc_state_roots_match(gc_state *const this);
         bool gc_state_no_from_space_ref(gc_state *const this);
@@ -76 +76 @@
 gc_object_header* gc_get_object_for_ref(gc_state* state, void* member)
 {
+        volatile int stage = 0;
         intptr_t target = ((intptr_t)member);
         if(!gc_is_in_heap(state, member)) return NULL;
+        stage++;
 
         gc_memory_pool* pool = gc_pool_of(member);
+        stage++;
         gc_pool_object_iterator it = gc_pool_iterator_for(pool, member);
+        stage++;
         gc_pool_object_iterator end = end(pool);
+        stage++;
 
         while(it != end)
         {
                 gc_object_header* object = *it;
+                check(object);
+                check( is_valid(object) );
                 {
                         intptr_t start = ((intptr_t)object);
@@ -94 +101 @@
                         }
                 }
+                stage++;
                 ++it;
         }
 
-        checkf(false, "is_in_heap() and iterator_for() return inconsistent data");
+        checkf( (int) 0, "is_in_heap() and iterator_for() return inconsistent data");
         abort();
         return NULL;
@@ -176 +184 @@
         this->from_code = (~this->from_code) & 0x01;
 
-        #if _DEBUG
+        #ifndef NDEBUG
                 {
                         gc_memory_pool* pool = this->from_space;
@@ -251 +259 @@
 }
 
-#if _DEBUG
+#ifndef NDEBUG
         bool gc_state_roots_match(gc_state* const this)
         {
@@ -265 +273 @@
                                 size += object->size;
 
-                                gcpointer_base* ptr = object->root_chain;
+                                gcpointer_t* ptr = object->root_chain;
                                 while(ptr)
                                 {
-                                        check(get_object_ptr(ptr->m_ptr) == object);
-                                        ptr = ptr->m_next;
+                                        check(gc_get_object_ptr( (void*)ptr->ptr ) == object);
+                                        ptr = ptr->next;
                                 }
                         }
 
-                        check(size + gc_pool_size_used(pool) == gc_pool_size_total(pool));
+                        checkf(size + gc_pool_size_left(pool) == gc_pool_size_total(pool),
+                                (const char*)"expected %lu + %lu == %lu\n",
+                                (size_t)size,
+                                (size_t)gc_pool_size_left(pool),
+                                (size_t)gc_pool_size_total(pool));
 
                         pool = pool->next;
@@ -286 +298 @@
                 while(pool)
                 {
-                        void** potential_ref = (void**)pool->m_start;
-                        while(potential_ref < (void**)pool->m_free)
+                        void** potential_ref = (void**)pool->start_p;
+                        while(potential_ref < (void**)pool->free_p)
                         {
                                 check(!gc_is_in_heap(this, *potential_ref));

src/examples/gc_no_raii/src/internal/state.h

@@ -38 +38 @@
 static inline bool gc_needs_collect(gc_state* state)
 {
-        sout | "Used Space: " | state->used_space | " bytes" | endl;
+        // sout | "Used Space: " | state->used_space | " bytes" | endl;
         return state->used_space * 2 > state->total_space;
 }

src/examples/gc_no_raii/src/tools/checks.h

@@ -1 +1 @@
 #pragma once
 
-#if _DEBUG
+#ifdef NDEBUG
+
+#define check(x)
+
+#define checkf(x, format, ...)
+
+#warning no debug checks
+
+#else
 
 #include <stdlib.h>
@@ -10 +18 @@
                 printf("CHECK failed : %s at %s:%i\n", #x, __FILE__, __LINE__);\
                 abort();\
-        }}while(0)\
+        }}while( (int)0 )\
 
 #define checkf(x, ...) do {\
@@ -17 +25 @@
                 printf(__VA_ARGS__);\
                 abort();\
-        }}while(0)\
-
-#else
-
-#define check(x)
-
-#define checkf(x, format, ...)
+        }}while( (int)0 )\
 
 #endif //NO_CHECKS

src/examples/gc_no_raii/src/tools/print.c

@@ -1 +1 @@
 #include "tools.h"
 
-#if _DEBUG
-        ofstream *sout = ofstream_stdout();
+#ifndef NDEBUG
+        // ofstream *sout = ofstream_stdout();
 #endif

src/examples/gc_no_raii/src/tools/print.h

@@ -1 +1 @@
 #pragma once
 
-#if _DEBUG
-
-#include <fstream>
-
-#define DEBUG_OUT(x) sout | x | endl;
-
-#else
+// #ifndef NDEBUG
+//
+// #include <fstream>
+//
+// #define DEBUG_OUT(x) sout | x | endl;
+//
+// #else
 
 #define DEBUG_OUT(x)
 
-#endif //NO_CHECKS
+// #endif //NO_CHECKS

src/examples/gc_no_raii/test/badlll.c

@@ -1 +1 @@
 #include "gc.h"
+
+#include <stdio.h>
 
 struct List_t
@@ -7 +9 @@
 };
 
-void ?{}(List_t* this);
-List_t* ?=?(List_t* this, List_t* rhs);
-
 typedef gcpointer(List_t) LLL;
 
-#define MAX (1024 * 1024)
+#define MAX (1024 * 1)
 
-// LLL buildLLL(int sz)
-void bla()
+LLL buildLLL(int sz)
 {
-        int i;
-        // LLL ll0;//, lll, llc;
-//
-//      ll0 = gcmalloc();
-//      ll0->val = 0;
-//      lll = ll0;
-//
-//      for (i = 1; i < sz; i++)
-//      {
-//              llc = gcmalloc();
-//              llc->val = i;
-//              lll->next = llc;
-//              lll = llc;
-//      }
-//
-        // return ll0;
+        int i = 0;
+        LLL ll0;
+
+        gcmalloc( &ll0 );
+        List_t* ll0_ptr = get( &ll0 );
+        ll0_ptr->val = i;
+        LLL lll = ll0;
+
+        for (i = 1; i < sz; i++)
+        {
+                LLL llc;
+                gcmalloc( &llc );
+                List_t* llc_ptr = get( &llc );
+                llc_ptr->val = i;
+                List_t* lll_ptr = get( &lll );
+                lll_ptr->next = llc;
+
+                lll = llc;
+        }
+
+        check(is_valid( &ll0.internal ));
+
+        return ll0;
 }
-//
-// void testLLL(LLL lll)
-// {
-//      unsigned char *counted;
-//
-//      counted = (unsigned char *) calloc(MAX, sizeof(unsigned char));
-//      while (lll)
-//      {
-//              counted[lll->val]++;
-//              if (counted[lll->val] > 1)
-//              {
-//                      fprintf(stderr, "ERROR! Encountered %d twice!\n", lll->val);
-//                      exit(1);
-//              }
-//              lll = lll->next;
-//      }
-//
-//      return;
-// }
+
+void testLLL(LLL lll)
+{
+        unsigned char *counted;
+
+        counted = (unsigned char *) calloc(MAX, sizeof(unsigned char));
+        while (lll)
+        {
+                List_t* lll_ptr = get( &lll );
+                counted[lll_ptr->val]++;
+                if (counted[lll_ptr->val] > 1)
+                {
+                        fprintf(stderr, "ERROR! Encountered %d twice!\n", lll_ptr->val);
+                        exit(1);
+                }
+                lll = lll_ptr->next;
+        }
+
+        return;
+}
 
 int main(void)
@@ -58 +64 @@
         LLL mylll;
 
-        // mylll = buildLLL(MAX);
-        //
-        // testLLL(mylll);
+        mylll = buildLLL(MAX);
+
+        testLLL(mylll);
 
         return 0;

src/tests/.expect/declarationErrors.txt

@@ -2 +2 @@
 Error: duplicate static in declaration of x1: static const volatile short int 
 
-Error: multiple extern & static in declaration of x2: extern const volatile short int 
+Error: conflicting extern & static in declaration of x2: extern const volatile short int 
 
-Error: multiple extern & auto, multiple extern & static, multiple extern & static, duplicate extern in declaration of x3: extern const volatile short int 
+Error: conflicting extern & auto, conflicting extern & static, conflicting extern & static, duplicate extern in declaration of x3: extern const volatile short int 
 
 Error: duplicate static in declaration of x4: static const volatile instance of const volatile struct __anonymous0

src/tests/avltree/avl_test.c

@@ -14 +14 @@
 
   // int -> int
-  tree(int, int) * imap = create(-1, 0);
+  tree(int, int) * imap = create(-1, (int)0);
   insert(&imap, 12, 13);
   insert(&imap, 2, 3);