Index: libcfa/src/containers/maybe =================================================================== --- libcfa/src/containers/maybe (revision bf71cfdb7285490eee552b461158846f626cc52f) +++ libcfa/src/containers/maybe (revision bf71cfdb7285490eee552b461158846f626cc52f) @@ -0,0 +1,69 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// maybe -- May contain a value. +// +// Author : Andrew Beach +// Created On : Wed May 24 14:43:00 2017 +// Last Modified By : Peter A. Buhr +// Last Modified On : Sat Jul 22 10:00:52 2017 +// Update Count : 4 +// + +#pragma once + +#include + +// DO NOT USE DIRECTLY! +forall(otype T) +struct maybe { + bool has_value; + T value; +}; + + +forall(otype T) +void ?{}(maybe(T) & this); + +forall(otype T) +void ?{}(maybe(T) & this, T value); + +forall(otype T) +void ?{}(maybe(T) & this, maybe(T) other); + +forall(otype T) +void ^?{}(maybe(T) & this); + +forall(otype T) +maybe(T) ?=?(maybe(T) & this, maybe(T) other); + +forall(otype T) +bool ?!=?(maybe(T) this, zero_t); + +/* Waiting for bug#11 to be fixed. +forall(otype T) +maybe(T) maybe_value(T value); + +forall(otype T) +maybe(T) maybe_none(); +*/ + +forall(otype T) +bool has_value(maybe(T) * this); + +forall(otype T) +T get(maybe(T) * this); + +forall(otype T) +void set(maybe(T) * this, T value); + +forall(otype T) +void set_none(maybe(T) * this); + +// Local Variables: // +// mode: c // +// tab-width: 4 // +// End: // Index: libcfa/src/containers/maybe.c =================================================================== --- libcfa/src/containers/maybe.c (revision bf71cfdb7285490eee552b461158846f626cc52f) +++ libcfa/src/containers/maybe.c (revision bf71cfdb7285490eee552b461158846f626cc52f) @@ -0,0 +1,102 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// maybe.c -- May contain a value. +// +// Author : Andrew Beach +// Created On : Wed May 24 15:40:00 2017 +// Last Modified By : Peter A. Buhr +// Last Modified On : Thu Jul 20 15:23:50 2017 +// Update Count : 2 +// + +#include +#include + + +forall(otype T) +void ?{}(maybe(T) & this) { + this.has_value = false; +} + +forall(otype T) +void ?{}(maybe(T) & this, T value) { + this.has_value = true; + (this.value){value}; +} + +forall(otype T) +void ?{}(maybe(T) & this, maybe(T) other) { + this.has_value = other.has_value; + if (other.has_value) { + (this.value){other.value}; + } +} + +forall(otype T) +maybe(T) ?=?(maybe(T) & this, maybe(T) that) { + if (this.has_value & that.has_value) { + this.value = that.value; + } else if (this.has_value) { + ^(this.value){}; + this.has_value = false; + } else if (that.has_value) { + this.has_value = true; + (this.value){that.value}; + } + return this; +} + +forall(otype T) +void ^?{}(maybe(T) & this) { + if (this.has_value) { + ^(this.value){}; + } +} + +forall(otype T) +bool ?!=?(maybe(T) this, zero_t) { + return this.has_value; +} + +forall(otype T) +maybe(T) maybe_value(T value) { + return (maybe(T)){value}; +} + +forall(otype T) +maybe(T) maybe_none() { + return (maybe(T)){}; +} + +forall(otype T) +bool has_value(maybe(T) * this) { + return this->has_value; +} + +forall(otype T) +T get(maybe(T) * this) { + assertf(this->has_value, "attempt to get from maybe without value"); + return this->value; +} + +forall(otype T) +void set(maybe(T) * this, T value) { + if (this->has_value) { + this->value = value; + } else { + this->has_value = true; + (this->value){value}; + } +} + +forall(otype T) +void set_none(maybe(T) * this) { + if (this->has_value) { + this->has_value = false; + ^(this->value){}; + } +} Index: libcfa/src/containers/pair =================================================================== --- libcfa/src/containers/pair (revision bf71cfdb7285490eee552b461158846f626cc52f) +++ libcfa/src/containers/pair (revision bf71cfdb7285490eee552b461158846f626cc52f) @@ -0,0 +1,48 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// pair -- +// +// Author : Aaron Moss +// Created On : Wed Apr 12 15:32:00 2017 +// Last Modified By : Peter A. Buhr +// Last Modified On : Sat Jul 22 09:59:53 2017 +// Update Count : 2 +// + +#pragma once + +forall(otype R, otype S) struct pair { + R first; + S second; +}; + +forall(otype R, otype S + | { int ?==?(R, R); int ??(R, R); int ?>?(S, S); }) +int ?>?(pair(R, S) p, pair(R, S) q); + +forall(otype R, otype S + | { int ?==?(R, R); int ?>?(R, R); int ?>=?(S, S); }) +int ?>=?(pair(R, S) p, pair(R, S) q); + +// Local Variables: // +// mode: c // +// tab-width: 4 // +// End: // Index: libcfa/src/containers/pair.c =================================================================== --- libcfa/src/containers/pair.c (revision bf71cfdb7285490eee552b461158846f626cc52f) +++ libcfa/src/containers/pair.c (revision bf71cfdb7285490eee552b461158846f626cc52f) @@ -0,0 +1,47 @@ +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// pair.c -- +// +// Author : Aaron Moss +// Created On : Wed Apr 12 15:32:00 2017 +// Last Modified By : Aaron Moss +// Last Modified On : Wed Apr 12 15:32:00 2017 +// Update Count : 1 +// + +#include + +forall(otype R, otype S + | { int ?==?(R, R); int ??(R, R); int ?>?(S, S); }) +int ?>?(pair(R, S) p, pair(R, S) q) { + return p.first > q.first || ( p.first == q.first && p.second > q.second ); +} + +forall(otype R, otype S + | { int ?==?(R, R); int ?>?(R, R); int ?>=?(S, S); }) +int ?>=?(pair(R, S) p, pair(R, S) q) { + return p.first > q.first || ( p.first == q.first && p.second >= q.second ); +} Index: libcfa/src/containers/result =================================================================== --- libcfa/src/containers/result (revision bf71cfdb7285490eee552b461158846f626cc52f) +++ libcfa/src/containers/result (revision bf71cfdb7285490eee552b461158846f626cc52f) @@ -0,0 +1,81 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// result -- Contains the expected value or an error value. +// +// Author : Andrew Beach +// Created On : Wed May 24 14:45:00 2017 +// Last Modified By : Peter A. Buhr +// Last Modified On : Sat Jul 22 10:00:44 2017 +// Update Count : 3 +// + +#pragma once + +#include + +// DO NOT USE DIRECTLY! +forall(otype T, otype E) +union inner_result{ + T value; + E error; +}; + +forall(otype T, otype E) +struct result { + bool has_value; + inline union inner_result(T, E); +}; + + +forall(otype T, otype E) +void ?{}(result(T, E) & this); + +forall(otype T, otype E) +void ?{}(result(T, E) & this, one_t, T value); + +forall(otype T, otype E) +void ?{}(result(T, E) & this, zero_t, E error); + +forall(otype T, otype E) +void ?{}(result(T, E) & this, result(T, E) other); + +forall(otype T, otype E) +void ^?{}(result(T, E) & this); + +forall(otype T, otype E) +result(T, E) ?=?(result(T, E) & this, result(T, E) other); + +forall(otype T, otype E) +bool ?!=?(result(T, E) this, zero_t); + +/* Wating for bug#11 to be fixed. +forall(otype T, otype E) +result(T, E) result_value(T value); + +forall(otype T, otype E) +result(T, E) result_error(E error); +*/ + +forall(otype T, otype E) +bool has_value(result(T, E) * this); + +forall(otype T, otype E) +T get(result(T, E) * this); + +forall(otype T, otype E) +E get_error(result(T, E) * this); + +forall(otype T, otype E) +void set(result(T, E) * this, T value); + +forall(otype T, otype E) +void set_error(result(T, E) * this, E error); + +// Local Variables: // +// mode: c // +// tab-width: 4 // +// End: // Index: libcfa/src/containers/result.c =================================================================== --- libcfa/src/containers/result.c (revision bf71cfdb7285490eee552b461158846f626cc52f) +++ libcfa/src/containers/result.c (revision bf71cfdb7285490eee552b461158846f626cc52f) @@ -0,0 +1,126 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// result.c -- Contains the expected value or an error value. +// +// Author : Andrew Beach +// Created On : Wed May 24 15:40:00 2017 +// Last Modified By : Peter A. Buhr +// Last Modified On : Thu Jul 20 15:23:58 2017 +// Update Count : 2 +// + +#include +#include + + +forall(otype T, otype E) +void ?{}(result(T, E) & this) { + this.has_value = false; + (this.error){}; +} + +forall(otype T, otype E) +void ?{}(result(T, E) & this, one_t, T value) { + this.has_value = true; + (this.value){value}; +} + +forall(otype T, otype E) +void ?{}(result(T, E) & this, zero_t, E error) { + this.has_value = false; + (this.error){error}; +} + +forall(otype T, otype E) +void ?{}(result(T, E) & this, result(T, E) other) { + this.has_value = other.has_value; + if (other.has_value) { + (this.value){other.value}; + } else { + (this.error){other.error}; + } +} + +forall(otype T, otype E) +result(T, E) ?=?(result(T, E) & this, result(T, E) that) { + if (this.has_value & that.has_value) { + this.value = that.value; + } else if (this.has_value) { + ^(this.value){}; + this.has_value = false; + (this.error){that.error}; + } else if (that.has_value) { + ^(this.error){}; + this.has_value = true; + (this.value){that.value}; + } else { + this.error = that.error; + } +} + +forall(otype T, otype E) +void ^?{}(result(T, E) & this) { + if (this.has_value) { + ^(this.value){}; + } else { + ^(this.error){}; + } +} + +forall(otype T, otype E) +bool ?!=?(result(T, E) this, zero_t) { + return this.has_value; +} + +forall(otype T, otype E) +result(T, E) result_value(T value) { + return (result(T, E)){1, value}; +} + +forall(otype T, otype E) +result(T, E) result_error(E error) { + return (result(T, E)){0, error}; +} + +forall(otype T, otype E) +bool has_value(result(T, E) * this) { + return this->has_value; +} + +forall(otype T, otype E) +T get(result(T, E) * this) { + assertf(this->has_value, "attempt to get from result without value"); + return this->value; +} + +forall(otype T, otype E) +E get_error(result(T, E) * this) { + assertf(!this->has_value, "attempt to get from result without error"); + return this->error; +} + +forall(otype T, otype E) +void set(result(T, E) * this, T value) { + if (this->has_value) { + this->value = value; + } else { + ^(this->error){}; + this->has_value = true; + (this->value){value}; + } +} + +forall(otype T, otype E) +void set_error(result(T, E) * this, E error) { + if (this->has_value) { + ^(this->value){}; + this->has_value = false; + (this->error){error}; + } else { + this->error = error; + } +} Index: libcfa/src/containers/vector =================================================================== --- libcfa/src/containers/vector (revision bf71cfdb7285490eee552b461158846f626cc52f) +++ libcfa/src/containers/vector (revision bf71cfdb7285490eee552b461158846f626cc52f) @@ -0,0 +1,170 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// vector -- +// +// Author : Thierry Delisle +// Created On : Tue Jul 5 18:00:07 2016 +// Last Modified By : Peter A. Buhr +// Last Modified On : Sat Jul 22 10:01:18 2017 +// Update Count : 3 +// + +#pragma once + +extern "C" { +#include +} + +//------------------------------------------------------------------------------ +//Allocator +forall(otype T) +struct heap_allocator +{ + T* storage; + size_t capacity; +}; + +forall(otype T) +void ?{}(heap_allocator(T)& this); + +forall(otype T) +void ?{}(heap_allocator(T)& this, heap_allocator(T) rhs); + +forall(otype T) +heap_allocator(T) ?=?(heap_allocator(T)& this, heap_allocator(T) rhs); + +forall(otype T) +void ^?{}(heap_allocator(T)& this); + +forall(otype T) +void realloc_storage(heap_allocator(T)* this, size_t size); + +forall(otype T) +static inline T* data(heap_allocator(T)* this) +{ + return this->storage; +} + +//------------------------------------------------------------------------------ +//Declaration +trait allocator_c(otype T, otype allocator_t) +{ + void realloc_storage(allocator_t*, size_t); + T* data(allocator_t*); +}; + +forall(otype T, otype allocator_t = heap_allocator(T) | allocator_c(T, allocator_t)) +struct vector; + +//------------------------------------------------------------------------------ +//Initialization +forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +void ?{}(vector(T, allocator_t)& this); + +forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +void ?{}(vector(T, allocator_t)& this, vector(T, allocator_t) rhs); + +forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +vector(T, allocator_t) ?=?(vector(T, allocator_t)& this, vector(T, allocator_t) rhs); + +forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +void ^?{}(vector(T, allocator_t)& this); + +forall(otype T, otype allocator_t = heap_allocator(T) | allocator_c(T, allocator_t)) +struct vector +{ + allocator_t storage; + size_t size; +}; + +//------------------------------------------------------------------------------ +//Capacity +forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +static inline bool empty(vector(T, allocator_t)* this) +{ + return this->size == 0; +} + +forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +static inline size_t size(vector(T, allocator_t)* this) +{ + return this->size; +} + +forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +static inline void reserve(vector(T, allocator_t)* this, size_t size) +{ + realloc_storage(&this->storage, this->size+1); +} + +//------------------------------------------------------------------------------ +//Element access +forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +static inline T at(vector(T, allocator_t)* this, size_t index) +{ + return data(&this->storage)[index]; +} + +forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +static inline T ?[?](vector(T, allocator_t)* this, size_t index) +{ + return data(&this->storage)[index]; +} + +forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +static inline T front(vector(T, allocator_t)* this) +{ + return data(&this->storage)[0]; +} + +forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +static inline T back(vector(T, allocator_t)* this) +{ + return data(&this->storage)[this->size - 1]; +} + +//------------------------------------------------------------------------------ +//Modifiers +forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +void push_back(vector(T, allocator_t)* this, T value); + +forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +void pop_back(vector(T, allocator_t)* this); + +forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +void clear(vector(T, allocator_t)* this); + +//------------------------------------------------------------------------------ +//Iterators +forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +static inline T* begin(vector(T, allocator_t)* this) +{ + return data(&this->storage); +} + +// forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +// static inline const T* cbegin(const vector(T, allocator_t)* this) +// { +// return data(&this->storage); +// } + +forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +static inline T* end(vector(T, allocator_t)* this) +{ + return data(&this->storage) + this->size; +} + +// forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +// static inline const T* cend(const vector(T, allocator_t)* this) +// { +// return data(&this->storage) + this->size; +// } + +// Local Variables: // +// mode: c // +// tab-width: 4 // +// End: // Index: libcfa/src/containers/vector.c =================================================================== --- libcfa/src/containers/vector.c (revision bf71cfdb7285490eee552b461158846f626cc52f) +++ libcfa/src/containers/vector.c (revision bf71cfdb7285490eee552b461158846f626cc52f) @@ -0,0 +1,137 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// vector.c -- +// +// Author : Thierry Delisle +// Created On : Tue Jul 5 18:07:52 2016 +// Last Modified By : Peter A. Buhr +// Last Modified On : Tue Jul 5 18:08:31 2016 +// Update Count : 2 +// + +#include + +#include + +forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +void copy_internal(vector(T, allocator_t)* this, vector(T, allocator_t)* other); + +//------------------------------------------------------------------------------ +//Initialization +forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +void ?{}(vector(T, allocator_t)& this) +{ + (this.storage){}; + this.size = 0; +} + +forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +void ?{}(vector(T, allocator_t)& this, vector(T, allocator_t) rhs) +{ + (this.storage){ rhs.storage }; + copy_internal(&this, &rhs); +} + +// forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +// vector(T, allocator_t) ?=?(vector(T, allocator_t)* this, vector(T, allocator_t) rhs) +// { +// (&this->storage){}; +// copy_internal(this, &rhs); +// return *this; +// } + +forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +void ^?{}(vector(T, allocator_t)& this) +{ + clear(&this); + ^(this.storage){}; +} + +//------------------------------------------------------------------------------ +//Modifiers +forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +void push_back(vector(T, allocator_t)* this, T value) +{ + realloc_storage(&this->storage, this->size+1); + data(&this->storage)[this->size] = value; + this->size++; +} + +forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +void pop_back(vector(T, allocator_t)* this) +{ + this->size--; + ^(data(&this->storage)[this->size]){}; +} + +forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +void clear(vector(T, allocator_t)* this) +{ + for(size_t i = 0; i < this->size; i++) + { + ^(data(&this->storage)[this->size]){}; + } + this->size = 0; +} + +//------------------------------------------------------------------------------ +//Internal Helpers + +forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +void copy_internal(vector(T, allocator_t)* this, vector(T, allocator_t)* other) +{ + this->size = other->size; + for(size_t i = 0; i < this->size; i++) { + (data(&this->storage)[this->size]){ data(&other->storage)[other->size] }; + } +} + +//------------------------------------------------------------------------------ +//Allocator +forall(otype T) +void ?{}(heap_allocator(T)& this) +{ + this.storage = 0; + this.capacity = 0; +} + +forall(otype T) +void ?{}(heap_allocator(T)& this, heap_allocator(T) rhs) +{ + this.capacity = rhs.capacity; + this.storage = (T*)realloc((void*)this.storage, this.capacity * sizeof(T)); +} + +forall(otype T) +heap_allocator(T) ?=?(heap_allocator(T)& this, heap_allocator(T) rhs) +{ + this.capacity = rhs.capacity; + this.storage = (T*)realloc((void*)this.storage, this.capacity * sizeof(T)); + return this; +} + +forall(otype T) +void ^?{}(heap_allocator(T)& this) +{ + free(this.storage); +} + +forall(otype T) +inline void realloc_storage(heap_allocator(T)* this, size_t size) +{ + enum { GROWTH_RATE = 2 }; + if(size > this->capacity) + { + this->capacity = GROWTH_RATE * size; + this->storage = (T*)realloc((void*)this->storage, this->capacity * sizeof(T)); + } +} + +// Local Variables: // +// mode: c // +// tab-width: 4 // +// End: //