Changeset 101e0bd


Ignore:
Timestamp:
Sep 15, 2016, 2:57:03 PM (5 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
ba7aa2d, fc4a0fa
Parents:
5b639ee (diff), 50c5cf3 (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:

more refactoring of parser code

Location:
src
Files:
1 added
1 deleted
18 edited

Legend:

Unmodified
Added
Removed
  • src/Parser/DeclarationNode.cc

    r5b639ee r101e0bd  
    1010// Created On       : Sat May 16 12:34:05 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Sep 12 21:03:18 2016
    13 // Update Count     : 491
     12// Last Modified On : Wed Sep 14 23:13:28 2016
     13// Update Count     : 502
    1414//
    1515
     
    383383}
    384384
    385 static void addQualifiersToType( TypeData *&src, TypeData *dst ) {
    386         if ( src && dst ) {
    387                 if ( src->forall && dst->kind == TypeData::Function ) {
    388                         if ( dst->forall ) {
    389                                 dst->forall->appendList( src->forall );
    390                         } else {
    391                                 dst->forall = src->forall;
    392                         } // if
    393                         src->forall = 0;
    394                 } // if
    395                 if ( dst->base ) {
    396                         addQualifiersToType( src, dst->base );
    397                 } else if ( dst->kind == TypeData::Function ) {
    398                         dst->base = src;
    399                         src = 0;
    400                 } else {
    401                         dst->qualifiers |= src->qualifiers;
    402                 } // if
    403         } // if
    404 }
    405 
    406385void appendError( string & dst, const string & src ) {
    407386        if ( src.empty() ) return;
     
    445424} // DeclarationNode::copyStorageClasses
    446425
     426static void addQualifiersToType( TypeData *&src, TypeData *dst ) {
     427        if ( src->forall && dst->kind == TypeData::Function ) {
     428                if ( dst->forall ) {
     429                        dst->forall->appendList( src->forall );
     430                } else {
     431                        dst->forall = src->forall;
     432                } // if
     433                src->forall = 0;
     434        } // if
     435        if ( dst->base ) {
     436                addQualifiersToType( src, dst->base );
     437        } else if ( dst->kind == TypeData::Function ) {
     438                dst->base = src;
     439                src = 0;
     440        } else {
     441                dst->qualifiers |= src->qualifiers;
     442        } // if
     443} // addQualifiersToType
     444
    447445DeclarationNode *DeclarationNode::addQualifiers( DeclarationNode *q ) {
    448         if ( q ) {
    449                 checkStorageClasses( q );
    450                 copyStorageClasses( q );
    451                 if ( q->type ) {
    452                         if ( ! type ) {
    453                                 type = new TypeData;
     446        if ( ! q ) return this;
     447
     448        checkStorageClasses( q );
     449        copyStorageClasses( q );
     450
     451        if ( ! q->type ) { delete q; return this; }
     452
     453        if ( ! type ) {
     454//              type = new TypeData;
     455                type = q->type;
     456                return this;
     457        } // if
     458
     459        checkQualifiers( q->type, type );
     460        addQualifiersToType( q->type, type );
     461
     462        if ( q->type->forall ) {
     463                if ( type->forall ) {
     464                        type->forall->appendList( q->type->forall );
     465                } else {
     466                        if ( type->kind == TypeData::Aggregate ) {
     467                                type->aggregate.params = q->type->forall;
     468                                // change implicit typedef from TYPEDEFname to TYPEGENname
     469                                typedefTable.changeKind( type->aggregate.name, TypedefTable::TG );
    454470                        } else {
    455                                 checkQualifiers( q->type, type );
     471                                type->forall = q->type->forall;
    456472                        } // if
    457                         addQualifiersToType( q->type, type );
    458                         if ( q->type && q->type->forall ) {
    459                                 if ( type->forall ) {
    460                                         type->forall->appendList( q->type->forall );
    461                                 } else {
    462                                         if ( type->kind == TypeData::Aggregate ) {
    463                                                 type->aggregate.params = q->type->forall;
    464                                                 // change implicit typedef from TYPEDEFname to TYPEGENname
    465                                                 typedefTable.changeKind( type->aggregate.name, TypedefTable::TG );
    466                                         } else {
    467                                                 type->forall = q->type->forall;
    468                                         } // if
     473                } // if
     474                q->type->forall = 0;
     475        } // if
     476        delete q;
     477        return this;
     478} // addQualifiers
     479
     480static void addTypeToType( TypeData *&src, TypeData *&dst ) {
     481        if ( src->forall && dst->kind == TypeData::Function ) {
     482                if ( dst->forall ) {
     483                        dst->forall->appendList( src->forall );
     484                } else {
     485                        dst->forall = src->forall;
     486                } // if
     487                src->forall = 0;
     488        } // if
     489        if ( dst->base ) {
     490                addTypeToType( src, dst->base );
     491        } else {
     492                switch ( dst->kind ) {
     493                  case TypeData::Unknown:
     494                        src->qualifiers |= dst->qualifiers;
     495                        dst = src;
     496                        src = 0;
     497                        break;
     498                  case TypeData::Basic:
     499                        dst->qualifiers |= src->qualifiers;
     500                        if ( src->kind != TypeData::Unknown ) {
     501                                assert( src->kind == TypeData::Basic );
     502
     503                                if ( dst->basictype == DeclarationNode::NoBasicType ) {
     504                                        dst->basictype = src->basictype;
     505                                } else if ( src->basictype != DeclarationNode::NoBasicType )
     506                                        throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::basicTypeName[ src->basictype ] + " in type: ", src );
     507
     508                                if ( dst->complextype == DeclarationNode::NoComplexType ) {
     509                                        dst->complextype = src->complextype;
     510                                } else if ( src->complextype != DeclarationNode::NoComplexType )
     511                                        throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::complexTypeName[ src->complextype ] + " in type: ", src );
     512
     513                                if ( dst->signedness == DeclarationNode::NoSignedness ) {
     514                                        dst->signedness = src->signedness;
     515                                } else if ( src->signedness != DeclarationNode::NoSignedness )
     516                                        throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::signednessName[ src->signedness ] + " in type: ", src );
     517
     518                                if ( dst->length == DeclarationNode::NoLength ) {
     519                                        dst->length = src->length;
     520                                } else if ( dst->length == DeclarationNode::Long && src->length == DeclarationNode::Long ) {
     521                                        dst->length = DeclarationNode::LongLong;
     522                                } else if ( src->length != DeclarationNode::NoLength )
     523                                        throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::lengthName[ src->length ] + " in type: ", src );
     524                        } // if
     525                        break;
     526                  default:
     527                        switch ( src->kind ) {
     528                          case TypeData::Aggregate:
     529                          case TypeData::Enum:
     530                                dst->base = new TypeData( TypeData::AggregateInst );
     531                                dst->base->aggInst.aggregate = src;
     532                                if ( src->kind == TypeData::Aggregate ) {
     533                                        dst->base->aggInst.params = maybeClone( src->aggregate.actuals );
    469534                                } // if
    470                                 q->type->forall = 0;
    471                         } // if
    472                 } // if
    473         } // if
    474         delete q;
    475         return this;
    476 }
    477 
    478 static void addTypeToType( TypeData *&src, TypeData *&dst ) {
    479         if ( src && dst ) {
    480                 if ( src->forall && dst->kind == TypeData::Function ) {
    481                         if ( dst->forall ) {
    482                                 dst->forall->appendList( src->forall );
    483                         } else {
    484                                 dst->forall = src->forall;
    485                         } // if
    486                         src->forall = 0;
    487                 } // if
    488                 if ( dst->base ) {
    489                         addTypeToType( src, dst->base );
    490                 } else {
    491                         switch ( dst->kind ) {
    492                           case TypeData::Unknown:
    493                                 src->qualifiers |= dst->qualifiers;
    494                                 dst = src;
     535                                dst->base->qualifiers |= src->qualifiers;
    495536                                src = 0;
    496537                                break;
    497                           case TypeData::Basic:
    498                                 dst->qualifiers |= src->qualifiers;
    499                                 if ( src->kind != TypeData::Unknown ) {
    500                                         assert( src->kind == TypeData::Basic );
    501 
    502                                         if ( dst->basictype == DeclarationNode::NoBasicType ) {
    503                                                 dst->basictype = src->basictype;
    504                                         } else if ( src->basictype != DeclarationNode::NoBasicType )
    505                                                 throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::basicTypeName[ src->basictype ] + " in type: ", src );
    506 
    507                                         if ( dst->complextype == DeclarationNode::NoComplexType ) {
    508                                                 dst->complextype = src->complextype;
    509                                         } else if ( src->complextype != DeclarationNode::NoComplexType )
    510                                                 throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::complexTypeName[ src->complextype ] + " in type: ", src );
    511 
    512                                         if ( dst->signedness == DeclarationNode::NoSignedness ) {
    513                                                 dst->signedness = src->signedness;
    514                                         } else if ( src->signedness != DeclarationNode::NoSignedness )
    515                                                 throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::signednessName[ src->signedness ] + " in type: ", src );
    516 
    517                                         if ( dst->length == DeclarationNode::NoLength ) {
    518                                                 dst->length = src->length;
    519                                         } else if ( dst->length == DeclarationNode::Long && src->length == DeclarationNode::Long ) {
    520                                                 dst->length = DeclarationNode::LongLong;
    521                                         } else if ( src->length != DeclarationNode::NoLength )
    522                                                 throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::lengthName[ src->length ] + " in type: ", src );
     538                          default:
     539                                if ( dst->forall ) {
     540                                        dst->forall->appendList( src->forall );
     541                                } else {
     542                                        dst->forall = src->forall;
    523543                                } // if
    524                                 break;
    525                           default:
    526                                 switch ( src->kind ) {
    527                                   case TypeData::Aggregate:
    528                                   case TypeData::Enum:
    529                                         dst->base = new TypeData( TypeData::AggregateInst );
    530                                         dst->base->aggInst.aggregate = src;
    531                                         if ( src->kind == TypeData::Aggregate ) {
    532                                                 dst->base->aggInst.params = maybeClone( src->aggregate.actuals );
    533                                         } // if
    534                                         dst->base->qualifiers |= src->qualifiers;
    535                                         src = 0;
    536                                         break;
    537                                   default:
    538                                         if ( dst->forall ) {
    539                                                 dst->forall->appendList( src->forall );
    540                                         } else {
    541                                                 dst->forall = src->forall;
    542                                         } // if
    543                                         src->forall = 0;
    544                                         dst->base = src;
    545                                         src = 0;
    546                                 } // switch
     544                                src->forall = 0;
     545                                dst->base = src;
     546                                src = 0;
    547547                        } // switch
    548                 } // if
     548                } // switch
    549549        } // if
    550550}
  • src/examples/gc_no_raii/bug-repro/field.c

    r5b639ee r101e0bd  
    6262{
    6363        struct gc_object_header* object;
    64         #if _DEBUG
     64        #ifndef NDEBUG
    6565                intptr_t lower_limit;
    6666                intptr_t upper_limit;
     
    7171                gc_pool_object_iterator* const this,
    7272                void* start_object
    73                 #if _DEBUG
     73                #ifndef NDEBUG
    7474                        , intptr_t pool_start
    7575                        , intptr_t pool_end
  • src/examples/gc_no_raii/src/gcpointers.c

    r5b639ee r101e0bd  
    1414                gc_object_header* obj = gc_get_object_for_ref(gc_get_state(), (void*)this);
    1515                check(obj);
    16                 check(gc_obj_is_valide(obj));
    17                 check(gc_is_managed(this) == gc_is_managed(obj->type_chain) || obj->type_chain == NULL);
     16                check(is_valid(obj));
     17                check(gc_is_managed(this) == gc_is_managed(obj->type_chain) || !obj->type_chain);
    1818                this->next = obj->type_chain;
    1919                obj->type_chain = this;
    20                 check(obj->is_valide());
     20                check(is_valid(obj));
    2121        }
    2222        else
     
    2424                gc_object_header* obj = gc_get_object_ptr((void*)this->ptr);
    2525                check(obj);
    26                 check(gc_obj_is_valide(obj));
    27                 check(gc_is_managed(this) == gc_is_managed(obj->root_chain) || obj->root_chain == NULL);
     26                check(is_valid(obj));
     27                check(!obj->root_chain || this->ptr == obj->root_chain->ptr);
     28                check(!obj->root_chain || gc_is_managed(this) == gc_is_managed(obj->root_chain));
    2829                this->next = obj->root_chain;
    2930                obj->root_chain = this;
    30                 check(gc_obj_is_valide(obj));
     31                check(is_valid(obj));
    3132        }
    3233}
     
    6970}
    7071
    71 gcpointer_t* gcpointer_assign(gcpointer_t* this, gcpointer_t* rhs)
     72gcpointer_t ?=?(gcpointer_t* this, gcpointer_t rhs)
    7273{
    73         if(this != rhs)
    74         {
    75                 unregister_ptr(this);
     74        unregister_ptr(this);
     75        this->ptr = rhs.ptr;
     76        register_ptr(this);
    7677
    77                 this->ptr = rhs->ptr;
    78 
    79                 register_ptr(this);
    80         }
    81 
    82         return this;
     78        return *this;
    8379}
    8480
    8581//Logical operators
    86 bool gcpointer_equal(gcpointer_t* this, gcpointer_t* rhs)
     82bool gcpointer_equal(const gcpointer_t* this, const gcpointer_t* rhs)
    8783{
    8884        return this->ptr == rhs->ptr;
    8985}
    9086
    91 bool gcpointer_not_equal(gcpointer_t* this, gcpointer_t* rhs)
     87bool gcpointer_not_equal(const gcpointer_t* this, const gcpointer_t* rhs)
    9288{
    9389        return this->ptr != rhs->ptr;
    9490}
    9591
    96 bool gcpointer_null(gcpointer_t* this)
     92bool gcpointer_null(const gcpointer_t* this)
    9793{
    9894        return this->ptr == (intptr_t)NULL;
    9995}
     96
     97#ifndef NDEBUG
     98        bool is_valid(const gcpointer_t* this) {
     99                if(gcpointer_null(this)) return true;
     100
     101                gc_object_header* obj = gc_get_object_ptr((void*)this->ptr);
     102                check(obj);
     103                check(is_valid(obj));
     104                check(!obj->root_chain || this->ptr == obj->root_chain->ptr);
     105
     106                if( !gc_is_managed(this))
     107                {
     108                        check( !(this->next) || this->ptr == this->next->ptr );
     109                }
     110
     111                return true;
     112        }
     113#endif
    100114
    101115forall(otype T) void ?{}(gcpointer(T)* this) {
     
    107121}
    108122
    109 forall(otype T) void ?{}(gcpointer(T)* this, gcpointer(T)* other) {
    110         (&this->internal) { other->internal };
     123forall(otype T) void ?{}(gcpointer(T)* this, gcpointer(T) other) {
     124        (&this->internal) { other.internal };
    111125}
    112126
     
    115129}
    116130
    117 // forall(otype T) gcpointer(T) ?=?(gcpointer(T) this, gcpointer(T) rhs);
     131forall(otype T) gcpointer(T) ?=?(gcpointer(T)* this, gcpointer(T) rhs) {
     132        this->internal = rhs.internal;
     133        return *this;
     134}
    118135//
    119136// forall(otype T) T *?(gcpointer(T) this);
     
    124141//
    125142// //Logical operators
     143forall(otype T) int ?!=?(gcpointer(T) this, int zero) {
     144        return this.internal.ptr != 0;
     145}
    126146// forall(otype T) int ?!=?(gcpointer(T) this, gcpointer(T) rhs);
    127147// forall(otype T) int ?==?(gcpointer(T) this, gcpointer(T) rhs);
  • src/examples/gc_no_raii/src/gcpointers.h

    r5b639ee r101e0bd  
    33#include <stdbool.h>
    44#include <stdint.h>
     5
     6forall(dtype T)
     7struct gcpointer;
    58
    69struct gcpointer_t
     
    1417void ?{}(gcpointer_t* this, gcpointer_t other);
    1518void ^?{}(gcpointer_t* this);
    16 gcpointer_t* ?=?(gcpointer_t this, gcpointer_t rhs);
     19gcpointer_t ?=?(gcpointer_t* this, gcpointer_t rhs);
    1720
    1821//Logical operators
    1922bool gcpointer_equal(gcpointer_t* this, gcpointer_t* rhs);
    2023bool gcpointer_not_equal(gcpointer_t* this, gcpointer_t* rhs);
    21 bool gcpointer_null(gcpointer_t* this);
     24bool gcpointer_null(const gcpointer_t* this);
    2225
    23 forall(otype T)
     26
     27#ifndef NDEBUG
     28        bool is_valid(const gcpointer_t* this);
     29#endif
     30
     31forall(dtype T)
    2432struct gcpointer
    2533{
     
    3038forall(otype T) void ?{}(gcpointer(T)* this);
    3139forall(otype T) void ?{}(gcpointer(T)* this, void* address);
    32 forall(otype T) void ?{}(gcpointer(T)* this, gcpointer(T)* other);
     40forall(otype T) void ?{}(gcpointer(T)* this, gcpointer(T) other);
    3341forall(otype T) void ^?{}(gcpointer(T)* this);
    34 forall(otype T) gcpointer(T) ?=?(gcpointer(T) this, gcpointer(T) rhs);
     42forall(otype T) gcpointer(T) ?=?(gcpointer(T)* this, gcpointer(T) rhs);
    3543
    3644
    37 forall(otype T) T *?(gcpointer(T) this);
     45// forall(otype T) T *?(gcpointer(T) this);
    3846forall(otype T) T* get(gcpointer(T)* this);
    3947
    4048//Logical operators
     49forall(otype T) int ?!=?(gcpointer(T) this, int zero);
    4150forall(otype T) int ?!=?(gcpointer(T) this, gcpointer(T) rhs);
    4251forall(otype T) int ?==?(gcpointer(T) this, gcpointer(T) rhs);
  • src/examples/gc_no_raii/src/internal/card_table.h

    r5b639ee r101e0bd  
    11#pragma once
    2 
    3 #include <stdlib>
    42
    53#include "globals.h"
     
    97{
    108        size_t card = ( ((intptr_t)address) & CARDS_OFFSET_MASK ) >> CARDS_SIZE_EXP;
     9        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);
    1110        check(card < CARDS_COUNT);
    1211        return card;
     
    1918};
    2019
    21 static inline void ctor(card_table_t* const this)
     20static inline void ctor_card(card_table_t* const this)
    2221{
    2322        this->count = 0;
    2423}
    2524
    26 static inline void dtor(card_table_t* const this)
     25static inline void dtor_card(card_table_t* const this)
    2726{
    2827
     
    4847        else
    4948        {
    50                 check(card == count);
     49                check(card == this->count);
    5150                this->count++;
    5251                this->cards_start[card] = object;
  • src/examples/gc_no_raii/src/internal/collector.c

    r5b639ee r101e0bd  
    2525        gc_object_header* obj = gc_get_object_ptr((void*)target->ptr);
    2626
    27         check(gc_is_valide(obj));
     27        check(is_valid(obj));
    2828
    2929        gcpointer_t** prev_next_ptr = managed ? &obj->type_chain : &obj->root_chain;
     
    3838void* gc_allocate(size_t target_size)
    3939{
    40         sout | "Allocating " | target_size | " bytes" | endl;
     40        // sout | "Allocating " | target_size | " bytes" | endl;
    4141
    4242        size_t size = gc_compute_size(target_size + sizeof(gc_object_header));
    4343
    44         sout | "Object header size: " | sizeof(gc_object_header) | " bytes" | endl;
    45         sout | "Actual allocation size: " | size | " bytes" | endl;
     44        // sout | "Object header size: " | sizeof(gc_object_header) | " bytes" | endl;
     45        // sout | "Actual allocation size: " | size | " bytes" | endl;
    4646
    4747        check(size < POOL_SIZE_BYTES);
     
    6060        if((intptr_t)(block = gc_try_allocate(gc, size))) return gc_finish_alloc_block(block, size, target_size);
    6161
    62         checkf(false, "ERROR: allocation in new pool failed");
     62        checkf( (int) 0, "ERROR: allocation in new pool failed");
    6363
    6464        return NULL;
     
    6767void* gc_finish_alloc_block(void* block, size_t actual_size, size_t target_size)
    6868{
    69         void* data = (void*)(((intptr_t)block) + sizeof(gc_object_header));
     69        intptr_t data = ((intptr_t)block) + sizeof(gc_object_header);
    7070        void* header = block;
    7171
    72         check(((intptr_t)data) > ((intptr_t)block));
    73         check(((intptr_t)data) >= ((intptr_t)header));
    74         check(is_aligned(data));
    75         check(((intptr_t)data) + target_size <= ((intptr_t)block) + actual_size);
     72        check( data > ((intptr_t)block));
     73        check( data >= ((intptr_t)header));
     74        check( gc_is_aligned( (void*)data ) );
     75        check( data + target_size <= ((intptr_t)block) + actual_size );
    7676
    7777        gc_object_header* obj = placement_ctor(header, actual_size);
    7878
    7979        (void)obj; //remove unsused warning since this is for debug
    80         check(obj == get_object_ptr(data));
     80        check(obj == gc_get_object_ptr( (void*)data ));
    8181
    8282        gc_register_allocation(gc_get_state(), actual_size);
    8383
    84         return data;
     84        return (void*)data;
    8585}
    8686
     
    119119        check(!ptr->forward);
    120120        check(!ptr->is_forwarded);
    121         check(gc_is_from_space(gc_pool_of(ptr)));
     121        check(gc_pool_is_from_space(gc_pool_of(ptr)));
    122122
    123123        gc_memory_pool* pool = gc_pool_of(ptr)->mirror;
     
    143143                check(((intptr_t)field) < ((intptr_t)((intptr_t)object) + object->size));
    144144
    145                 check(gc_is_in_to_space(gc_get_state(), &type->ptr));
     145                check(gc_is_in_to_space(gc_get_state(), &field->ptr));
    146146
    147147                intptr_t* ref = &field->ptr;
  • src/examples/gc_no_raii/src/internal/collector.h

    r5b639ee r101e0bd  
    11#pragma once
    22
    3 #include <stdlib>
     3#include <stdlib.h>
    44
    55#include "tools.h"
  • src/examples/gc_no_raii/src/internal/memory_pool.c

    r5b639ee r101e0bd  
    11#include "memory_pool.h"
    22
    3 #include <stdlib>
     3extern "C" {
     4        #include <stdlib.h>
     5        #include <string.h>
     6}
    47
     8#include "collector.h"
    59#include "object_header.h"
    610
     
    1519        card_table_t* new = (card_table_t*)malloc(sizeof(card_table_t));
    1620        this->cards = new;
    17         ctor(this->cards);
     21        ctor_card(this->cards);
    1822
    1923        this->end_p = ((uint8_t*)this) + size;
    2024        this->free_p = this->start_p;
    2125
    22         check(gc_pool_of(this) == this);
     26        check( gc_pool_of( (void*)this ) == this);
    2327        check(this->cards);
    2428        gc_reset_pool(this);
     
    2731void dtor(gc_memory_pool *const this)
    2832{
    29         dtor(this->cards);
     33        dtor_card(this->cards);
    3034        free(this->cards);
    3135}
     
    3438{
    3539        this->free_p = this->start_p;
    36         #if _DEBUG
    37                 memset(this->start_p, 0xCD, gc_pool_total_size(this));
     40        #ifndef NDEBUG
     41                memset(this->start_p, 0xCD, gc_pool_size_total(this));
    3842        #endif
    3943
     
    4145        reset(this->cards);
    4246
    43         check(gc_pool_size_left(this) == gc_pool_total_size(this));
     47        check(gc_pool_size_left(this) == gc_pool_size_total(this));
    4448}
    4549
     
    5862}
    5963
    60 void ctor(
    61                 gc_pool_object_iterator* const this,
     64void ?{}(       gc_pool_object_iterator* this,
    6265                struct gc_object_header* start_object
    63                 #if _DEBUG
     66                #ifndef NDEBUG
    6467                        , intptr_t pool_start
    6568                        , intptr_t pool_end
     
    6871{
    6972        this->object = start_object;
    70         #if _DEBUG
     73        #ifndef NDEBUG
    7174                this->lower_limit = pool_start;
    7275                this->upper_limit = pool_end;
    7376        #endif
    7477
    75         check( ((intptr_t)start_object) >= lower_limit );
    76         check( ((intptr_t)start_object) <= upper_limit );
     78        check( ((intptr_t)start_object) >= this->lower_limit );
     79        check( ((intptr_t)start_object) <= this->upper_limit );
    7780}
     81
     82void ^?{}( gc_pool_object_iterator* this ) {}
    7883
    7984gc_pool_object_iterator gc_pool_iterator_for(gc_memory_pool* const this, void* member)
     
    8186        size_t card = card_of(member);
    8287        intptr_t member_add = (intptr_t)member;
    83         void* start_obj;
    84         intptr_t start_obj_add;
     88        intptr_t start_obj;
    8589
    8690        do
    8791        {
    8892                check(card < CARDS_COUNT);
    89                 start_obj = object_at(this->cards, card);
     93                start_obj = (intptr_t)object_at(this->cards, card);
    9094                check(card != 0 || start_obj);
    9195                card--;
    92                 start_obj_add = (intptr_t)start_obj;
    9396        }
    94         while(start_obj_add > member_add || start_obj_add != 0);
     97        while(start_obj > member_add || !(start_obj));
    9598
    96         check(start_obj);
    97        
     99        check( start_obj );
     100
    98101        struct gc_object_header* start_obj_typed = (struct gc_object_header*)start_obj;
    99102
    100         gc_pool_object_iterator it;
    101         ctor( &it,
    102                 start_obj_typed,
    103                 #if _DEBUG
     103        return (gc_pool_object_iterator) {
     104                start_obj_typed
     105                #ifndef NDEBUG
    104106                        , (intptr_t)this->start_p
    105107                        , (intptr_t)this->free_p
    106108                #endif
    107         );
    108         return it;
     109        };
    109110}
    110111
     
    117118{
    118119        struct gc_object_header* start_obj = (struct gc_object_header*)this->start_p;
    119         gc_pool_object_iterator it;
    120         ctor( &it,
    121                 start_obj,
    122                 #if _DEBUG
     120        return (gc_pool_object_iterator) {
     121                start_obj
     122                #ifndef NDEBUG
    123123                        , (intptr_t)this->start_p
    124124                        , (intptr_t)this->free_p
    125125                #endif
    126         );
    127         return it;
     126        };
    128127}
    129128
    130129gc_pool_object_iterator end(gc_memory_pool* const this)
    131130{
    132         gc_pool_object_iterator it;
    133         ctor( &it,
    134                 (struct gc_object_header*)this->free_p,
    135                 #if _DEBUG
     131        return (gc_pool_object_iterator) {
     132                (struct gc_object_header*)this->free_p
     133                #ifndef NDEBUG
    136134                        , (intptr_t)this->start_p
    137135                        , (intptr_t)this->free_p
    138136                #endif
    139         );
    140         return it;
     137        };
    141138}
    142139
     
    145142        struct gc_object_header* object = it->object;
    146143        intptr_t next_ptr = ((intptr_t)object) + object->size;
    147         check(next_ptr > lower_limit);
    148         check(next_ptr <= upper_limit);
     144        check(next_ptr > it->lower_limit);
     145        check(next_ptr <= it->upper_limit);
    149146
    150147        struct gc_object_header* next_obj = ((struct gc_object_header*)next_ptr);
    151         check(next_ptr == upper_limit || is_valide(next_obj));
     148        check(next_ptr == it->upper_limit || is_valid(next_obj));
    152149
    153150        it->object = next_obj;
  • src/examples/gc_no_raii/src/internal/memory_pool.h

    r5b639ee r101e0bd  
    3939{
    4040        struct gc_object_header* object;
    41         #if _DEBUG
     41        #ifndef NDEBUG
    4242                intptr_t lower_limit;
    4343                intptr_t upper_limit;
     
    4646
    4747
    48 void ctor(
    49                 gc_pool_object_iterator* const this,
     48void ?{}(       gc_pool_object_iterator* this,
    5049                struct gc_object_header* start_object
    51                 #if _DEBUG
     50                #ifndef NDEBUG
    5251                        , intptr_t pool_start
    5352                        , intptr_t pool_end
    5453                #endif
    5554        );
     55
     56void ^?{}( gc_pool_object_iterator* this );
    5657
    5758bool ?!=?(const gc_pool_object_iterator lhs, const gc_pool_object_iterator rhs);
  • src/examples/gc_no_raii/src/internal/object_header.c

    r5b639ee r101e0bd  
    33#include <stdint.h>
    44
     5#include "collector.h"
    56#include "globals.h"
    67#include "gcpointers.h"
     
    89void ctor(gc_object_header* const this, size_t inSize)
    910{
    10         #if _DEBUG
     11        #ifndef NDEBUG
    1112                this->canary_start = CANARY_VALUE;
    1213        #endif
     
    1819        this->is_forwarded = false;
    1920
    20         #if _DEBUG
     21        #ifndef NDEBUG
    2122                this->canary_end = CANARY_VALUE;
    2223        #endif
     
    2526void copy_ctor(gc_object_header* const this, const gc_object_header* const other)
    2627{
    27         #if _DEBUG
     28        #ifndef NDEBUG
    2829                this->canary_start = CANARY_VALUE;
    2930        #endif
     
    3536        this->is_forwarded = false;
    3637
    37         #if _DEBUG
     38        #ifndef NDEBUG
    3839                this->canary_end = CANARY_VALUE;
    3940        #endif
     
    4243        while(root)
    4344        {
    44                 check(get_object_ptr(root->ptr) == other);
     45                check(gc_get_object_ptr( (void*)root->ptr ) == other);
    4546                root->ptr = ((intptr_t)this) + sizeof(gc_object_header);
    4647
    47                 check(get_object_ptr(root->ptr) == this);
     48                check(gc_get_object_ptr( (void*)root->ptr ) == this);
    4849                root = root->next;
    4950        }
     
    5657
    5758                size_t offset = (intptr_t)type - (intptr_t)other;
    58                 check(offset < size);
     59                check(offset < this->size);
    5960
    6061                gcpointer_t* member_ptr = (gcpointer_t*)( (intptr_t)this + offset );
     
    6364
    6465                size_t next_offset = type->next ? (intptr_t)type->next - (intptr_t)other : 0;
    65                 check(next_offset < size);
     66                check(next_offset < this->size);
    6667
    6768                gcpointer_t* next_ptr = type->next ? (gcpointer_t*)((intptr_t)this + next_offset) : NULL;
     
    7374        }
    7475
    75         check(is_valide(this));
     76        check(is_valid(this));
    7677}
    7778
    78 #if _DEBUG
    79         bool is_valide(const gc_object_header* const this)
     79#ifndef NDEBUG
     80        bool is_valid(const gc_object_header* const this)
    8081        {
    81                 check(this->canary_start == CANARY_VALUE);
    82                 check(this->canary_end == CANARY_VALUE);
     82                check((intptr_t)this->canary_start == (intptr_t)CANARY_VALUE);
     83                check((intptr_t)this->canary_end == (intptr_t)CANARY_VALUE);
    8384
    84                 check(this->is_forwarded == (this->forward != nullptr));
     85                check(this->is_forwarded == ( (intptr_t)this->forward != (intptr_t)NULL));
    8586
    8687                check(this->size < POOL_SIZE_BYTES);
     
    8990                while(root)
    9091                {
    91                         check(get_object_ptr(root->ptr) == this);
     92                        checkf(gc_get_object_ptr( (void*)root->ptr ) == this, (const char*)"Expected %lX got %lX\n", gc_get_object_ptr( (void*)root->ptr ), this);
    9293
    9394                        root = root->next;
    9495                }
    9596
    96                 gcpointer_t* type = type_chain;
     97                gcpointer_t* type = this->type_chain;
    9798                while(type)
    9899                {
    99100                        check((intptr_t)type > (intptr_t)this);
    100                         check((intptr_t)type < (intptr_t)((intptr_t)this + size));
     101                        check((intptr_t)type < (intptr_t)(((intptr_t)this) + this->size));
    101102
    102103                        type = type->next;
     
    105106                return true;
    106107        }
     108        #else
     109        #error blarg
    107110#endif
  • src/examples/gc_no_raii/src/internal/object_header.h

    r5b639ee r101e0bd  
    77#include "tools.h"
    88
    9 #if DEBUG
    10         static const long unsigned int CANARY_VALUE = 0xCAFEBABACAFEBABA;
     9#ifndef NDEBUG
     10        static void* const CANARY_VALUE = (void*)0xCAFEBABACAFEBABA;
    1111#endif
    1212
     
    1616struct gc_object_header
    1717{
    18         #if DEBUG
     18        #ifndef NDEBUG
    1919                void* canary_start;
    2020        #endif
     
    2626        bool                    is_forwarded;
    2727
    28         #if DEBUG
     28        #ifndef NDEBUG
    2929                void* canary_end;
    3030        #endif
     
    4747        return this;
    4848}
     49
     50#ifndef NDEBUG
     51        bool is_valid(const gc_object_header* const this);
     52#endif
  • src/examples/gc_no_raii/src/internal/state.c

    r5b639ee r101e0bd  
    2121void gc_state_calc_usage(gc_state *const this);
    2222
    23 #if DEBUG
     23#ifndef NDEBUG
    2424        bool gc_state_roots_match(gc_state *const this);
    2525        bool gc_state_no_from_space_ref(gc_state *const this);
     
    7676gc_object_header* gc_get_object_for_ref(gc_state* state, void* member)
    7777{
     78        volatile int stage = 0;
    7879        intptr_t target = ((intptr_t)member);
    7980        if(!gc_is_in_heap(state, member)) return NULL;
     81        stage++;
    8082
    8183        gc_memory_pool* pool = gc_pool_of(member);
     84        stage++;
    8285        gc_pool_object_iterator it = gc_pool_iterator_for(pool, member);
     86        stage++;
    8387        gc_pool_object_iterator end = end(pool);
     88        stage++;
    8489
    8590        while(it != end)
    8691        {
    8792                gc_object_header* object = *it;
     93                check(object);
     94                check( is_valid(object) );
    8895                {
    8996                        intptr_t start = ((intptr_t)object);
     
    94101                        }
    95102                }
     103                stage++;
    96104                ++it;
    97105        }
    98106
    99         checkf(false, "is_in_heap() and iterator_for() return inconsistent data");
     107        checkf( (int) 0, "is_in_heap() and iterator_for() return inconsistent data");
    100108        abort();
    101109        return NULL;
     
    176184        this->from_code = (~this->from_code) & 0x01;
    177185
    178         #if _DEBUG
     186        #ifndef NDEBUG
    179187                {
    180188                        gc_memory_pool* pool = this->from_space;
     
    251259}
    252260
    253 #if _DEBUG
     261#ifndef NDEBUG
    254262        bool gc_state_roots_match(gc_state* const this)
    255263        {
     
    265273                                size += object->size;
    266274
    267                                 gcpointer_base* ptr = object->root_chain;
     275                                gcpointer_t* ptr = object->root_chain;
    268276                                while(ptr)
    269277                                {
    270                                         check(get_object_ptr(ptr->m_ptr) == object);
    271                                         ptr = ptr->m_next;
     278                                        check(gc_get_object_ptr( (void*)ptr->ptr ) == object);
     279                                        ptr = ptr->next;
    272280                                }
    273281                        }
    274282
    275                         check(size + gc_pool_size_used(pool) == gc_pool_size_total(pool));
     283                        checkf(size + gc_pool_size_left(pool) == gc_pool_size_total(pool),
     284                                (const char*)"expected %lu + %lu == %lu\n",
     285                                (size_t)size,
     286                                (size_t)gc_pool_size_left(pool),
     287                                (size_t)gc_pool_size_total(pool));
    276288
    277289                        pool = pool->next;
     
    286298                while(pool)
    287299                {
    288                         void** potential_ref = (void**)pool->m_start;
    289                         while(potential_ref < (void**)pool->m_free)
     300                        void** potential_ref = (void**)pool->start_p;
     301                        while(potential_ref < (void**)pool->free_p)
    290302                        {
    291303                                check(!gc_is_in_heap(this, *potential_ref));
  • src/examples/gc_no_raii/src/internal/state.h

    r5b639ee r101e0bd  
    3838static inline bool gc_needs_collect(gc_state* state)
    3939{
    40         sout | "Used Space: " | state->used_space | " bytes" | endl;
     40        // sout | "Used Space: " | state->used_space | " bytes" | endl;
    4141        return state->used_space * 2 > state->total_space;
    4242}
  • src/examples/gc_no_raii/src/tools/checks.h

    r5b639ee r101e0bd  
    11#pragma once
    22
    3 #if _DEBUG
     3#ifdef NDEBUG
     4
     5#define check(x)
     6
     7#define checkf(x, format, ...)
     8
     9#warning no debug checks
     10
     11#else
    412
    513#include <stdlib.h>
     
    1018                printf("CHECK failed : %s at %s:%i\n", #x, __FILE__, __LINE__);\
    1119                abort();\
    12         }}while(0)\
     20        }}while( (int)0 )\
    1321
    1422#define checkf(x, ...) do {\
     
    1725                printf(__VA_ARGS__);\
    1826                abort();\
    19         }}while(0)\
    20 
    21 #else
    22 
    23 #define check(x)
    24 
    25 #define checkf(x, format, ...)
     27        }}while( (int)0 )\
    2628
    2729#endif //NO_CHECKS
  • src/examples/gc_no_raii/src/tools/print.c

    r5b639ee r101e0bd  
    11#include "tools.h"
    22
    3 #if _DEBUG
    4         ofstream *sout = ofstream_stdout();
     3#ifndef NDEBUG
     4        // ofstream *sout = ofstream_stdout();
    55#endif
  • src/examples/gc_no_raii/src/tools/print.h

    r5b639ee r101e0bd  
    11#pragma once
    22
    3 #if _DEBUG
    4 
    5 #include <fstream>
    6 
    7 #define DEBUG_OUT(x) sout | x | endl;
    8 
    9 #else
     3// #ifndef NDEBUG
     4//
     5// #include <fstream>
     6//
     7// #define DEBUG_OUT(x) sout | x | endl;
     8//
     9// #else
    1010
    1111#define DEBUG_OUT(x)
    1212
    13 #endif //NO_CHECKS
     13// #endif //NO_CHECKS
  • src/examples/gc_no_raii/test/badlll.c

    r5b639ee r101e0bd  
    11#include "gc.h"
     2
     3#include <stdio.h>
    24
    35struct List_t
     
    79};
    810
    9 void ?{}(List_t* this);
    10 List_t* ?=?(List_t* this, List_t* rhs);
    11 
    1211typedef gcpointer(List_t) LLL;
    1312
    14 #define MAX (1024 * 1024)
     13#define MAX (1024 * 1)
    1514
    16 // LLL buildLLL(int sz)
    17 void bla()
     15LLL buildLLL(int sz)
    1816{
    19         int i;
    20         // LLL ll0;//, lll, llc;
    21 //
    22 //      ll0 = gcmalloc();
    23 //      ll0->val = 0;
    24 //      lll = ll0;
    25 //
    26 //      for (i = 1; i < sz; i++)
    27 //      {
    28 //              llc = gcmalloc();
    29 //              llc->val = i;
    30 //              lll->next = llc;
    31 //              lll = llc;
    32 //      }
    33 //
    34         // return ll0;
     17        int i = 0;
     18        LLL ll0;
     19
     20        gcmalloc( &ll0 );
     21        List_t* ll0_ptr = get( &ll0 );
     22        ll0_ptr->val = i;
     23        LLL lll = ll0;
     24
     25        for (i = 1; i < sz; i++)
     26        {
     27                LLL llc;
     28                gcmalloc( &llc );
     29                List_t* llc_ptr = get( &llc );
     30                llc_ptr->val = i;
     31                List_t* lll_ptr = get( &lll );
     32                lll_ptr->next = llc;
     33
     34                lll = llc;
     35        }
     36
     37        check(is_valid( &ll0.internal ));
     38
     39        return ll0;
    3540}
    36 //
    37 // void testLLL(LLL lll)
    38 // {
    39 //      unsigned char *counted;
    40 //
    41 //      counted = (unsigned char *) calloc(MAX, sizeof(unsigned char));
    42 //      while (lll)
    43 //      {
    44 //              counted[lll->val]++;
    45 //              if (counted[lll->val] > 1)
    46 //              {
    47 //                      fprintf(stderr, "ERROR! Encountered %d twice!\n", lll->val);
    48 //                      exit(1);
    49 //              }
    50 //              lll = lll->next;
    51 //      }
    52 //
    53 //      return;
    54 // }
     41
     42void testLLL(LLL lll)
     43{
     44        unsigned char *counted;
     45
     46        counted = (unsigned char *) calloc(MAX, sizeof(unsigned char));
     47        while (lll)
     48        {
     49                List_t* lll_ptr = get( &lll );
     50                counted[lll_ptr->val]++;
     51                if (counted[lll_ptr->val] > 1)
     52                {
     53                        fprintf(stderr, "ERROR! Encountered %d twice!\n", lll_ptr->val);
     54                        exit(1);
     55                }
     56                lll = lll_ptr->next;
     57        }
     58
     59        return;
     60}
    5561
    5662int main(void)
     
    5864        LLL mylll;
    5965
    60         // mylll = buildLLL(MAX);
    61         //
    62         // testLLL(mylll);
     66        mylll = buildLLL(MAX);
     67
     68        testLLL(mylll);
    6369
    6470        return 0;
  • src/tests/avltree/avl_test.c

    r5b639ee r101e0bd  
    1414
    1515  // int -> int
    16   tree(int, int) * imap = create(-1, 0);
     16  tree(int, int) * imap = create(-1, (int)0);
    1717  insert(&imap, 12, 13);
    1818  insert(&imap, 2, 3);
Note: See TracChangeset for help on using the changeset viewer.