Ignore:
Timestamp:
Aug 23, 2017, 6:22:07 PM (9 years ago)
Author:
Peter A. Buhr <pabuhr@…>
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, stuck-waitfor-destruct, with_gc
Children:
87e08e24, cb811ac
Parents:
9f07232 (diff), bd37119 (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 plg2:software/cfa/cfa-cc

Location:
src/libcfa/containers
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • src/libcfa/containers/maybe

    r9f07232 rd3e4d6c  
    2727
    2828forall(otype T)
    29 void ?{}(maybe(T) * this);
     29void ?{}(maybe(T) & this);
    3030
    3131forall(otype T)
    32 void ?{}(maybe(T) * this, T value);
     32void ?{}(maybe(T) & this, T value);
    3333
    3434forall(otype T)
    35 void ?{}(maybe(T) * this, maybe(T) other);
     35void ?{}(maybe(T) & this, maybe(T) other);
    3636
    3737forall(otype T)
    38 void ^?{}(maybe(T) * this);
     38void ^?{}(maybe(T) & this);
    3939
    4040forall(otype T)
    41 maybe(T) ?=?(maybe(T) * this, maybe(T) other);
     41maybe(T) ?=?(maybe(T) & this, maybe(T) other);
    4242
    4343forall(otype T)

  • src/libcfa/containers/maybe.c

    r9f07232 rd3e4d6c  
    1919
    2020forall(otype T)
    21 void ?{}(maybe(T) * this) {
    22         this->has_value = false;
     21void ?{}(maybe(T) & this) {
     22        this.has_value = false;
    2323}
    2424
    2525forall(otype T)
    26 void ?{}(maybe(T) * this, T value) {
    27         this->has_value = true;
    28         (&this->value){value};
     26void ?{}(maybe(T) & this, T value) {
     27        this.has_value = true;
     28        (this.value){value};
    2929}
    3030
    3131forall(otype T)
    32 void ?{}(maybe(T) * this, maybe(T) other) {
    33         this->has_value = other.has_value;
     32void ?{}(maybe(T) & this, maybe(T) other) {
     33        this.has_value = other.has_value;
    3434        if (other.has_value) {
    35                 (&this->value){other.value};
     35                (this.value){other.value};
    3636        }
    3737}
    3838
    3939forall(otype T)
    40 maybe(T) ?=?(maybe(T) * this, maybe(T) that) {
    41         if (this->has_value & that.has_value) {
    42                 this->value = that.value;
    43         } else if (this->has_value) {
    44                 ^(&this->value){};
    45                 this->has_value = false;
     40maybe(T) ?=?(maybe(T) & this, maybe(T) that) {
     41        if (this.has_value & that.has_value) {
     42                this.value = that.value;
     43        } else if (this.has_value) {
     44                ^(this.value){};
     45                this.has_value = false;
    4646        } else if (that.has_value) {
    47                 this->has_value = true;
    48                 (&this->value){that.value};
     47                this.has_value = true;
     48                (this.value){that.value};
    4949        }
     50        return this;
    5051}
    5152
    5253forall(otype T)
    53 void ^?{}(maybe(T) * this) {
    54         if (this->has_value) {
    55                 ^(&this->value){};
     54void ^?{}(maybe(T) & this) {
     55        if (this.has_value) {
     56                ^(this.value){};
    5657        }
    5758}
    … …  
    8990        } else {
    9091                this->has_value = true;
    91                 (&this->value){value};
     92                (this->value){value};
    9293        }
    9394}
    … …  
    9798        if (this->has_value) {
    9899                this->has_value = false;
    99                 ^(&this->value){};
     100                ^(this->value){};
    100101        }
    101102}

  • src/libcfa/containers/result

    r9f07232 rd3e4d6c  
    3333
    3434forall(otype T, otype E)
    35 void ?{}(result(T, E) * this);
     35void ?{}(result(T, E) & this);
    3636
    3737forall(otype T, otype E)
    38 void ?{}(result(T, E) * this, one_t, T value);
     38void ?{}(result(T, E) & this, one_t, T value);
    3939
    4040forall(otype T, otype E)
    41 void ?{}(result(T, E) * this, zero_t, E error);
     41void ?{}(result(T, E) & this, zero_t, E error);
    4242
    4343forall(otype T, otype E)
    44 void ?{}(result(T, E) * this, result(T, E) other);
     44void ?{}(result(T, E) & this, result(T, E) other);
    4545
    4646forall(otype T, otype E)
    47 void ^?{}(result(T, E) * this);
     47void ^?{}(result(T, E) & this);
    4848
    4949forall(otype T, otype E)
    50 result(T, E) ?=?(result(T, E) * this, result(T, E) other);
     50result(T, E) ?=?(result(T, E) & this, result(T, E) other);
    5151
    5252forall(otype T, otype E)

  • src/libcfa/containers/result.c

    r9f07232 rd3e4d6c  
    1919
    2020forall(otype T, otype E)
    21 void ?{}(result(T, E) * this) {
    22         this->has_value = false;
    23         (&this->error){};
     21void ?{}(result(T, E) & this) {
     22        this.has_value = false;
     23        (this.error){};
    2424}
    2525
    2626forall(otype T, otype E)
    27 void ?{}(result(T, E) * this, one_t, T value) {
    28         this->has_value = true;
    29         (&this->value){value};
     27void ?{}(result(T, E) & this, one_t, T value) {
     28        this.has_value = true;
     29        (this.value){value};
    3030}
    3131
    3232forall(otype T, otype E)
    33 void ?{}(result(T, E) * this, zero_t, E error) {
    34         this->has_value = false;
    35         (&this->error){error};
     33void ?{}(result(T, E) & this, zero_t, E error) {
     34        this.has_value = false;
     35        (this.error){error};
    3636}
    3737
    3838forall(otype T, otype E)
    39 void ?{}(result(T, E) * this, result(T, E) other) {
    40         this->has_value = other.has_value;
     39void ?{}(result(T, E) & this, result(T, E) other) {
     40        this.has_value = other.has_value;
    4141        if (other.has_value) {
    42                 (&this->value){other.value};
     42                (this.value){other.value};
    4343        } else {
    44                 (&this->error){other.error};
     44                (this.error){other.error};
    4545        }
    4646}
    4747
    4848forall(otype T, otype E)
    49 result(T, E) ?=?(result(T, E) * this, result(T, E) that) {
    50         if (this->has_value & that.has_value) {
    51                 this->value = that.value;
    52         } else if (this->has_value) {
    53                 ^(&this->value){};
    54                 this->has_value = false;
    55                 (&this->error){that.error};
     49result(T, E) ?=?(result(T, E) & this, result(T, E) that) {
     50        if (this.has_value & that.has_value) {
     51                this.value = that.value;
     52        } else if (this.has_value) {
     53                ^(this.value){};
     54                this.has_value = false;
     55                (this.error){that.error};
    5656        } else if (that.has_value) {
    57                 ^(&this->error){};
    58                 this->has_value = true;
    59                 (&this->value){that.value};
     57                ^(this.error){};
     58                this.has_value = true;
     59                (this.value){that.value};
    6060        } else {
    61                 this->error = that.error;
     61                this.error = that.error;
    6262        }
    6363}
    6464
    6565forall(otype T, otype E)
    66 void ^?{}(result(T, E) * this) {
    67         if (this->has_value) {
    68                 ^(&this->value){};
     66void ^?{}(result(T, E) & this) {
     67        if (this.has_value) {
     68                ^(this.value){};
    6969        } else {
    70                 ^(&this->error){};
     70                ^(this.error){};
    7171        }
    7272}
    … …  
    109109                this->value = value;
    110110        } else {
    111                 ^(&this->error){};
     111                ^(this->error){};
    112112                this->has_value = true;
    113                 (&this->value){value};
     113                (this->value){value};
    114114        }
    115115}
    … …  
    118118void set_error(result(T, E) * this, E error) {
    119119        if (this->has_value) {
    120                 ^(&this->value){};
     120                ^(this->value){};
    121121                this->has_value = false;
    122                 (&this->error){error};
     122                (this->error){error};
    123123        } else {
    124124                this->error = error;

  • src/libcfa/containers/vector

    r9f07232 rd3e4d6c  
    3030
    3131forall(otype T)
    32 void ?{}(heap_allocator(T)* this);
     32void ?{}(heap_allocator(T)& this);
    3333
    3434forall(otype T)
    35 void ?{}(heap_allocator(T)* this, heap_allocator(T) rhs);
     35void ?{}(heap_allocator(T)& this, heap_allocator(T) rhs);
    3636
    3737forall(otype T)
    38 heap_allocator(T) ?=?(heap_allocator(T)* this, heap_allocator(T) rhs);
     38heap_allocator(T) ?=?(heap_allocator(T)& this, heap_allocator(T) rhs);
    3939
    4040forall(otype T)
    41 void ^?{}(heap_allocator(T)* this);
     41void ^?{}(heap_allocator(T)& this);
    4242
    4343forall(otype T)
    … …  
    6464//Initialization
    6565forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
    66 void ?{}(vector(T, allocator_t)* this);
     66void ?{}(vector(T, allocator_t)& this);
    6767
    6868forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
    69 void ?{}(vector(T, allocator_t)* this, vector(T, allocator_t) rhs);
     69void ?{}(vector(T, allocator_t)& this, vector(T, allocator_t) rhs);
    7070
    7171forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
    72 vector(T, allocator_t) ?=?(vector(T, allocator_t)* this, vector(T, allocator_t) rhs);
     72vector(T, allocator_t) ?=?(vector(T, allocator_t)& this, vector(T, allocator_t) rhs);
    7373
    7474forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
    75 void ^?{}(vector(T, allocator_t)* this);
     75void ^?{}(vector(T, allocator_t)& this);
    7676
    7777forall(otype T, otype allocator_t = heap_allocator(T) | allocator_c(T, allocator_t))

  • src/libcfa/containers/vector.c

    r9f07232 rd3e4d6c  
    2424//Initialization
    2525forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
    26 void ?{}(vector(T, allocator_t)* this)
     26void ?{}(vector(T, allocator_t)& this)
    2727{
    28         (&this->storage){};
    29         this->size = 0;
     28        (this.storage){};
     29        this.size = 0;
    3030}
    3131
    3232forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
    33 void ?{}(vector(T, allocator_t)* this, vector(T, allocator_t) rhs)
     33void ?{}(vector(T, allocator_t)& this, vector(T, allocator_t) rhs)
    3434{
    35         (&this->storage){ rhs.storage };
    36         copy_internal(this, &rhs);
     35        (this.storage){ rhs.storage };
     36        copy_internal(&this, &rhs);
    3737}
    3838
    … …  
    4646
    4747forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
    48 void ^?{}(vector(T, allocator_t)* this)
     48void ^?{}(vector(T, allocator_t)& this)
    4949{
    50         clear(this);
    51         ^(&this->storage){};
     50        clear(&this);
     51        ^(this.storage){};
    5252}
    5353
    … …  
    6666{
    6767        this->size--;
    68         ^(&data(&this->storage)[this->size]){};
     68        ^(data(&this->storage)[this->size]){};
    6969}
    7070
    … …  
    7474        for(size_t i = 0; i < this->size; i++)
    7575        {
    76                 ^(&data(&this->storage)[this->size]){};
     76                ^(data(&this->storage)[this->size]){};
    7777        }
    7878        this->size = 0;
    … …  
    8787        this->size = other->size;
    8888        for(size_t i = 0; i < this->size; i++) {
    89                 (&data(&this->storage)[this->size]){ data(&other->storage)[other->size] };
     89                (data(&this->storage)[this->size]){ data(&other->storage)[other->size] };
    9090        }
    9191}
    … …  
    9494//Allocator
    9595forall(otype T)
    96 void ?{}(heap_allocator(T)* this)
     96void ?{}(heap_allocator(T)& this)
    9797{
    98         this->storage = 0;
    99         this->capacity = 0;
     98        this.storage = 0;
     99        this.capacity = 0;
    100100}
    101101
    102102forall(otype T)
    103 void ?{}(heap_allocator(T)* this, heap_allocator(T) rhs)
     103void ?{}(heap_allocator(T)& this, heap_allocator(T) rhs)
    104104{
    105         this->capacity = rhs.capacity;
    106         this->storage = (T*)realloc((void*)this->storage, this->capacity * sizeof(T));
     105        this.capacity = rhs.capacity;
     106        this.storage = (T*)realloc((void*)this.storage, this.capacity * sizeof(T));
    107107}
    108108
    109109forall(otype T)
    110 heap_allocator(T) ?=?(heap_allocator(T)* this, heap_allocator(T) rhs)
     110heap_allocator(T) ?=?(heap_allocator(T)& this, heap_allocator(T) rhs)
    111111{
    112         this->capacity = rhs.capacity;
    113         this->storage = (T*)realloc((void*)this->storage, this->capacity * sizeof(T));
    114         return *this;
     112        this.capacity = rhs.capacity;
     113        this.storage = (T*)realloc((void*)this.storage, this.capacity * sizeof(T));
     114        return this;
    115115}
    116116
    117117forall(otype T)
    118 void ^?{}(heap_allocator(T)* this)
     118void ^?{}(heap_allocator(T)& this)
    119119{
    120         free(this->storage);
     120        free(this.storage);
    121121}
    122122
Note: See TracChangeset for help on using the changeset viewer.