Changeset 46f1d20


Ignore:
Timestamp:
Sep 9, 2016, 11:50:04 AM (6 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
aaron-thesis, arm-eh, 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:
ddcfb88
Parents:
850fda6
Message:

some changes to checks in gc which are very intrusive

Location:
src/examples/gc_no_raii
Files:
1 added
15 edited

Legend:

Unmodified
Added
Removed
  • src/examples/gc_no_raii/bug-repro/field.c

    r850fda6 r46f1d20  
    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

    r850fda6 r46f1d20  
    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(gc_is_managed(this) == gc_is_managed(obj->root_chain) || !obj->root_chain);
    2828                this->next = obj->root_chain;
    2929                obj->root_chain = this;
    30                 check(gc_obj_is_valide(obj));
     30                check(is_valid(obj));
    3131        }
    3232}
     
    124124//
    125125// //Logical operators
     126forall(otype T) int ?!=?(gcpointer(T) this, int zero) {
     127        return this.internal.ptr != 0;
     128}
    126129// forall(otype T) int ?!=?(gcpointer(T) this, gcpointer(T) rhs);
    127130// forall(otype T) int ?==?(gcpointer(T) this, gcpointer(T) rhs);
  • src/examples/gc_no_raii/src/gcpointers.h

    r850fda6 r46f1d20  
    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
     
    2124bool gcpointer_null(gcpointer_t* this);
    2225
    23 forall(otype T)
     26forall(dtype T)
    2427struct gcpointer
    2528{
     
    3235forall(otype T) void ?{}(gcpointer(T)* this, gcpointer(T)* other);
    3336forall(otype T) void ^?{}(gcpointer(T)* this);
    34 forall(otype T) gcpointer(T) ?=?(gcpointer(T) this, gcpointer(T) rhs);
     37forall(otype T) gcpointer(T) ?=?(gcpointer(T)* this, gcpointer(T) rhs);
    3538
    3639
    37 forall(otype T) T *?(gcpointer(T) this);
     40// forall(otype T) T *?(gcpointer(T) this);
    3841forall(otype T) T* get(gcpointer(T)* this);
    3942
    4043//Logical operators
     44forall(otype T) int ?!=?(gcpointer(T) this, int zero);
    4145forall(otype T) int ?!=?(gcpointer(T) this, gcpointer(T) rhs);
    4246forall(otype T) int ?==?(gcpointer(T) this, gcpointer(T) rhs);
  • src/examples/gc_no_raii/src/internal/card_table.h

    r850fda6 r46f1d20  
    11#pragma once
    2 
    3 #include <stdlib>
    42
    53#include "globals.h"
     
    1917};
    2018
    21 static inline void ctor(card_table_t* const this)
     19static inline void ctor_card(card_table_t* const this)
    2220{
    2321        this->count = 0;
    2422}
    2523
    26 static inline void dtor(card_table_t* const this)
     24static inline void dtor_card(card_table_t* const this)
    2725{
    2826
     
    4846        else
    4947        {
    50                 check(card == count);
     48                check(card == this->count);
    5149                this->count++;
    5250                this->cards_start[card] = object;
  • src/examples/gc_no_raii/src/internal/collector.c

    r850fda6 r46f1d20  
    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/memory_pool.c

    r850fda6 r46f1d20  
    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;
     88        intptr_t start_obj;
    8489        intptr_t start_obj_add;
    8590
     
    8792        {
    8893                check(card < CARDS_COUNT);
    89                 start_obj = object_at(this->cards, card);
     94                start_obj = (intptr_t)object_at(this->cards, card);
    9095                check(card != 0 || start_obj);
    9196                card--;
     
    9499        while(start_obj_add > member_add || start_obj_add != 0);
    95100
    96         check(start_obj);
    97        
     101        check( start_obj );
     102
    98103        struct gc_object_header* start_obj_typed = (struct gc_object_header*)start_obj;
    99104
    100         gc_pool_object_iterator it;
    101         ctor( &it,
    102                 start_obj_typed,
    103                 #if _DEBUG
     105        return (gc_pool_object_iterator) {
     106                start_obj_typed
     107                #ifndef NDEBUG
    104108                        , (intptr_t)this->start_p
    105109                        , (intptr_t)this->free_p
    106110                #endif
    107         );
    108         return it;
     111        };
    109112}
    110113
     
    117120{
    118121        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
     122        return (gc_pool_object_iterator) {
     123                start_obj
     124                #ifndef NDEBUG
    123125                        , (intptr_t)this->start_p
    124126                        , (intptr_t)this->free_p
    125127                #endif
    126         );
    127         return it;
     128        };
    128129}
    129130
    130131gc_pool_object_iterator end(gc_memory_pool* const this)
    131132{
    132         gc_pool_object_iterator it;
    133         ctor( &it,
    134                 (struct gc_object_header*)this->free_p,
    135                 #if _DEBUG
     133        return (gc_pool_object_iterator) {
     134                (struct gc_object_header*)this->free_p
     135                #ifndef NDEBUG
    136136                        , (intptr_t)this->start_p
    137137                        , (intptr_t)this->free_p
    138138                #endif
    139         );
    140         return it;
     139        };
    141140}
    142141
     
    145144        struct gc_object_header* object = it->object;
    146145        intptr_t next_ptr = ((intptr_t)object) + object->size;
    147         check(next_ptr > lower_limit);
    148         check(next_ptr <= upper_limit);
     146        check(next_ptr > it->lower_limit);
     147        check(next_ptr <= it->upper_limit);
    149148
    150149        struct gc_object_header* next_obj = ((struct gc_object_header*)next_ptr);
    151         check(next_ptr == upper_limit || is_valide(next_obj));
     150        check(next_ptr == it->upper_limit || is_valid(next_obj));
    152151
    153152        it->object = next_obj;
  • src/examples/gc_no_raii/src/internal/memory_pool.h

    r850fda6 r46f1d20  
    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

    r850fda6 r46f1d20  
    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                        check(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;
  • src/examples/gc_no_raii/src/internal/object_header.h

    r850fda6 r46f1d20  
    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( struct gc_object_header* obj );
     52#endif
  • src/examples/gc_no_raii/src/internal/state.c

    r850fda6 r46f1d20  
    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);
     
    9797        }
    9898
    99         checkf(false, "is_in_heap() and iterator_for() return inconsistent data");
     99        checkf( (int) 0, "is_in_heap() and iterator_for() return inconsistent data");
    100100        abort();
    101101        return NULL;
     
    176176        this->from_code = (~this->from_code) & 0x01;
    177177
    178         #if _DEBUG
     178        #ifndef NDEBUG
    179179                {
    180180                        gc_memory_pool* pool = this->from_space;
     
    251251}
    252252
    253 #if _DEBUG
     253#ifndef NDEBUG
    254254        bool gc_state_roots_match(gc_state* const this)
    255255        {
     
    265265                                size += object->size;
    266266
    267                                 gcpointer_base* ptr = object->root_chain;
     267                                gcpointer_t* ptr = object->root_chain;
    268268                                while(ptr)
    269269                                {
    270                                         check(get_object_ptr(ptr->m_ptr) == object);
    271                                         ptr = ptr->m_next;
     270                                        check(gc_get_object_ptr( (void*)ptr->ptr ) == object);
     271                                        ptr = ptr->next;
    272272                                }
    273273                        }
     
    286286                while(pool)
    287287                {
    288                         void** potential_ref = (void**)pool->m_start;
    289                         while(potential_ref < (void**)pool->m_free)
     288                        void** potential_ref = (void**)pool->start_p;
     289                        while(potential_ref < (void**)pool->free_p)
    290290                        {
    291291                                check(!gc_is_in_heap(this, *potential_ref));
  • src/examples/gc_no_raii/src/internal/state.h

    r850fda6 r46f1d20  
    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

    r850fda6 r46f1d20  
    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

    r850fda6 r46f1d20  
    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

    r850fda6 r46f1d20  
    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

    r850fda6 r46f1d20  
    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
    1413#define MAX (1024 * 1024)
    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, lll, llc;
     19
     20        gcmalloc( &ll0 );
     21        List_t* ll0_ptr = get( &ll0 );
     22        ll0_ptr->val = i;
     23        lll = ll0;
     24
     25        for (i = 1; i < sz; i++)
     26        {
     27                gcmalloc( &llc );
     28                List_t* llc_ptr = get( &llc );
     29                llc_ptr->val = i;
     30                List_t* lll_ptr = get( &lll );
     31                lll_ptr->next = llc;
     32
     33                lll = llc;
     34        }
     35
     36        return ll0;
    3537}
    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 // }
     38
     39void testLLL(LLL lll)
     40{
     41        unsigned char *counted;
     42
     43        counted = (unsigned char *) calloc(MAX, sizeof(unsigned char));
     44        while (lll)
     45        {
     46                List_t* lll_ptr = get( &lll );
     47                counted[lll_ptr->val]++;
     48                if (counted[lll_ptr->val] > 1)
     49                {
     50                        fprintf(stderr, "ERROR! Encountered %d twice!\n", lll_ptr->val);
     51                        exit(1);
     52                }
     53                lll = lll_ptr->next;
     54        }
     55
     56        return;
     57}
    5558
    5659int main(void)
     
    5861        LLL mylll;
    5962
    60         // mylll = buildLLL(MAX);
    61         //
    62         // testLLL(mylll);
     63        mylll = buildLLL(MAX);
     64
     65        testLLL(mylll);
    6366
    6467        return 0;
Note: See TracChangeset for help on using the changeset viewer.