Changeset 1eba452


Ignore:
Timestamp:
Sep 15, 2016, 10:29:43 AM (9 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:
fc4a0fa, fd782b2
Parents:
96a10cdd (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:

Merge branch 'master' of plg.uwaterloo.ca:/u/cforall/software/cfa/cfa-cc

Conflicts:

src/Parser/parser.cc

Location:
src
Files:
1 added
19 edited

Legend:

Unmodified
Added
Removed

  • src/Parser/parser.h

    r96a10cdd r1eba452  
    1 /* A Bison parser, made by GNU Bison 2.5.  */
     1/* A Bison parser, made by GNU Bison 3.0.2.  */
    22
    33/* Bison interface for Yacc-like parsers in C
    4    
    5       Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
    6    
     4
     5   Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc.
     6
    77   This program is free software: you can redistribute it and/or modify
    88   it under the terms of the GNU General Public License as published by
    99   the Free Software Foundation, either version 3 of the License, or
    1010   (at your option) any later version.
    11    
     11
    1212   This program is distributed in the hope that it will be useful,
    1313   but WITHOUT ANY WARRANTY; without even the implied warranty of
    1414   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    1515   GNU General Public License for more details.
    16    
     16
    1717   You should have received a copy of the GNU General Public License
    1818   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
    … …  
    2727   Bison output files to be licensed under the GNU General Public
    2828   License without this special exception.
    29    
     29
    3030   This special exception was added by the Free Software Foundation in
    3131   version 2.2 of Bison.  */
    3232
    33 
    34 /* Tokens.  */
     33#ifndef YY_YY_PARSER_PARSER_H_INCLUDED
     34# define YY_YY_PARSER_PARSER_H_INCLUDED
     35/* Debug traces.  */
     36#ifndef YYDEBUG
     37# define YYDEBUG 1
     38#endif
     39#if YYDEBUG
     40extern int yydebug;
     41#endif
     42
     43/* Token type.  */
    3544#ifndef YYTOKENTYPE
    3645# define YYTOKENTYPE
    37    /* Put the tokens into the symbol table, so that GDB and other debuggers
    38       know about them.  */
    39    enum yytokentype {
    40      TYPEDEF = 258,
    41      AUTO = 259,
    42      EXTERN = 260,
    43      REGISTER = 261,
    44      STATIC = 262,
    45      INLINE = 263,
    46      FORTRAN = 264,
    47      CONST = 265,
    48      VOLATILE = 266,
    49      RESTRICT = 267,
    50      FORALL = 268,
    51      LVALUE = 269,
    52      VOID = 270,
    53      CHAR = 271,
    54      SHORT = 272,
    55      INT = 273,
    56      LONG = 274,
    57      FLOAT = 275,
    58      DOUBLE = 276,
    59      SIGNED = 277,
    60      UNSIGNED = 278,
    61      VALIST = 279,
    62      BOOL = 280,
    63      COMPLEX = 281,
    64      IMAGINARY = 282,
    65      TYPEOF = 283,
    66      LABEL = 284,
    67      ENUM = 285,
    68      STRUCT = 286,
    69      UNION = 287,
    70      OTYPE = 288,
    71      FTYPE = 289,
    72      DTYPE = 290,
    73      TRAIT = 291,
    74      SIZEOF = 292,
    75      OFFSETOF = 293,
    76      ATTRIBUTE = 294,
    77      EXTENSION = 295,
    78      IF = 296,
    79      ELSE = 297,
    80      SWITCH = 298,
    81      CASE = 299,
    82      DEFAULT = 300,
    83      DO = 301,
    84      WHILE = 302,
    85      FOR = 303,
    86      BREAK = 304,
    87      CONTINUE = 305,
    88      GOTO = 306,
    89      RETURN = 307,
    90      CHOOSE = 308,
    91      DISABLE = 309,
    92      ENABLE = 310,
    93      FALLTHRU = 311,
    94      TRY = 312,
    95      CATCH = 313,
    96      CATCHRESUME = 314,
    97      FINALLY = 315,
    98      THROW = 316,
    99      THROWRESUME = 317,
    100      AT = 318,
    101      ASM = 319,
    102      ALIGNAS = 320,
    103      ALIGNOF = 321,
    104      ATOMIC = 322,
    105      GENERIC = 323,
    106      NORETURN = 324,
    107      STATICASSERT = 325,
    108      THREADLOCAL = 326,
    109      IDENTIFIER = 327,
    110      QUOTED_IDENTIFIER = 328,
    111      TYPEDEFname = 329,
    112      TYPEGENname = 330,
    113      ATTR_IDENTIFIER = 331,
    114      ATTR_TYPEDEFname = 332,
    115      ATTR_TYPEGENname = 333,
    116      INTEGERconstant = 334,
    117      FLOATINGconstant = 335,
    118      CHARACTERconstant = 336,
    119      STRINGliteral = 337,
    120      ZERO = 338,
    121      ONE = 339,
    122      ARROW = 340,
    123      ICR = 341,
    124      DECR = 342,
    125      LS = 343,
    126      RS = 344,
    127      LE = 345,
    128      GE = 346,
    129      EQ = 347,
    130      NE = 348,
    131      ANDAND = 349,
    132      OROR = 350,
    133      ELLIPSIS = 351,
    134      MULTassign = 352,
    135      DIVassign = 353,
    136      MODassign = 354,
    137      PLUSassign = 355,
    138      MINUSassign = 356,
    139      LSassign = 357,
    140      RSassign = 358,
    141      ANDassign = 359,
    142      ERassign = 360,
    143      ORassign = 361,
    144      ATassign = 362,
    145      THEN = 363
    146    };
     46  enum yytokentype
     47  {
     48    TYPEDEF = 258,
     49    AUTO = 259,
     50    EXTERN = 260,
     51    REGISTER = 261,
     52    STATIC = 262,
     53    INLINE = 263,
     54    FORTRAN = 264,
     55    CONST = 265,
     56    VOLATILE = 266,
     57    RESTRICT = 267,
     58    FORALL = 268,
     59    LVALUE = 269,
     60    VOID = 270,
     61    CHAR = 271,
     62    SHORT = 272,
     63    INT = 273,
     64    LONG = 274,
     65    FLOAT = 275,
     66    DOUBLE = 276,
     67    SIGNED = 277,
     68    UNSIGNED = 278,
     69    VALIST = 279,
     70    BOOL = 280,
     71    COMPLEX = 281,
     72    IMAGINARY = 282,
     73    TYPEOF = 283,
     74    LABEL = 284,
     75    ENUM = 285,
     76    STRUCT = 286,
     77    UNION = 287,
     78    OTYPE = 288,
     79    FTYPE = 289,
     80    DTYPE = 290,
     81    TRAIT = 291,
     82    SIZEOF = 292,
     83    OFFSETOF = 293,
     84    ATTRIBUTE = 294,
     85    EXTENSION = 295,
     86    IF = 296,
     87    ELSE = 297,
     88    SWITCH = 298,
     89    CASE = 299,
     90    DEFAULT = 300,
     91    DO = 301,
     92    WHILE = 302,
     93    FOR = 303,
     94    BREAK = 304,
     95    CONTINUE = 305,
     96    GOTO = 306,
     97    RETURN = 307,
     98    CHOOSE = 308,
     99    DISABLE = 309,
     100    ENABLE = 310,
     101    FALLTHRU = 311,
     102    TRY = 312,
     103    CATCH = 313,
     104    CATCHRESUME = 314,
     105    FINALLY = 315,
     106    THROW = 316,
     107    THROWRESUME = 317,
     108    AT = 318,
     109    ASM = 319,
     110    ALIGNAS = 320,
     111    ALIGNOF = 321,
     112    ATOMIC = 322,
     113    GENERIC = 323,
     114    NORETURN = 324,
     115    STATICASSERT = 325,
     116    THREADLOCAL = 326,
     117    IDENTIFIER = 327,
     118    QUOTED_IDENTIFIER = 328,
     119    TYPEDEFname = 329,
     120    TYPEGENname = 330,
     121    ATTR_IDENTIFIER = 331,
     122    ATTR_TYPEDEFname = 332,
     123    ATTR_TYPEGENname = 333,
     124    INTEGERconstant = 334,
     125    FLOATINGconstant = 335,
     126    CHARACTERconstant = 336,
     127    STRINGliteral = 337,
     128    ZERO = 338,
     129    ONE = 339,
     130    ARROW = 340,
     131    ICR = 341,
     132    DECR = 342,
     133    LS = 343,
     134    RS = 344,
     135    LE = 345,
     136    GE = 346,
     137    EQ = 347,
     138    NE = 348,
     139    ANDAND = 349,
     140    OROR = 350,
     141    ELLIPSIS = 351,
     142    MULTassign = 352,
     143    DIVassign = 353,
     144    MODassign = 354,
     145    PLUSassign = 355,
     146    MINUSassign = 356,
     147    LSassign = 357,
     148    RSassign = 358,
     149    ANDassign = 359,
     150    ERassign = 360,
     151    ORassign = 361,
     152    ATassign = 362,
     153    THEN = 363
     154  };
    147155#endif
    148156/* Tokens.  */
    … …  
    254262#define THEN 363
    255263
    256 
    257 
    258 
     264/* Value type.  */
    259265#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
    260 typedef union YYSTYPE
     266typedef union YYSTYPE YYSTYPE;
     267union YYSTYPE
    261268{
    262 
    263 /* Line 2068 of yacc.c  */
    264 #line 115 "parser.yy"
     269#line 115 "parser.yy" /* yacc.c:1909  */
    265270
    266271        Token tok;
    … …  
    279284        bool flag;
    280285
    281 
    282 
    283 /* Line 2068 of yacc.c  */
    284 #line 285 "Parser/parser.h"
    285 } YYSTYPE;
     286#line 287 "Parser/parser.h" /* yacc.c:1909  */
     287};
    286288# define YYSTYPE_IS_TRIVIAL 1
    287 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
    288289# define YYSTYPE_IS_DECLARED 1
    289290#endif
    290291
     292
    291293extern YYSTYPE yylval;
    292294
    293 
     295int yyparse (void);
     296
     297#endif /* !YY_YY_PARSER_PARSER_H_INCLUDED  */

  • src/Parser/parser.yy

    r96a10cdd r1eba452  
    827827                { $$ = new StatementNode( build_while( $3, $5 ) ); }
    828828        | DO statement WHILE '(' comma_expression ')' ';'
    829                 { $$ = new StatementNode( build_while( $5, $2 ) ); }
     829                { $$ = new StatementNode( build_while( $5, $2, true ) ); }
    830830        | FOR '(' push for_control_expression ')' statement
    831831                { $$ = new StatementNode( build_for( $4, $6 ) ); }

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

    r96a10cdd r1eba452  
    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

    r96a10cdd r1eba452  
    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

    r96a10cdd r1eba452  
    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

    r96a10cdd r1eba452  
    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

    r96a10cdd r1eba452  
    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

    r96a10cdd r1eba452  
    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

    r96a10cdd r1eba452  
    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

    r96a10cdd r1eba452  
    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

    r96a10cdd r1eba452  
    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

    r96a10cdd r1eba452  
    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

    r96a10cdd r1eba452  
    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

    r96a10cdd r1eba452  
    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

    r96a10cdd r1eba452  
    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

    r96a10cdd r1eba452  
    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

    r96a10cdd r1eba452  
    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

    r96a10cdd r1eba452  
    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

    r96a10cdd r1eba452  
    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.