Index: src/tests/.expect/castError.txt =================================================================== --- src/tests/.expect/castError.txt (revision 8a6cf7efc5b53b47e66ba1a8f429bb5b7c181aa2) +++ src/tests/.expect/castError.txt (revision 2afec66345a55139c8738d36411816676b2fe4d3) @@ -4,5 +4,5 @@ to: char -Alternatives are: Cost ( 1, 0, 0 ): Cast of: +Alternatives are: Cost ( 1, 0, 0, 0 ): Cast of: Variable Expression: f: function accepting unspecified arguments @@ -18,5 +18,5 @@ Environment: - Cost ( 1, 0, 0 ): Cast of: + Cost ( 1, 0, 0, 0 ): Cast of: Variable Expression: f: signed int @@ -28,5 +28,5 @@ Environment: - Cost ( 1, 0, 0 ): Cast of: + Cost ( 1, 0, 0, 0 ): Cast of: Variable Expression: f: double Index: src/tests/alloc.c =================================================================== --- src/tests/alloc.c (revision 8a6cf7efc5b53b47e66ba1a8f429bb5b7c181aa2) +++ src/tests/alloc.c (revision 2afec66345a55139c8738d36411816676b2fe4d3) @@ -1,3 +1,3 @@ -// +// // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo // @@ -5,6 +5,6 @@ // file "LICENCE" distributed with Cforall. // -// alloc.c -- -// +// alloc.c -- +// // Author : Peter A. Buhr // Created On : Wed Feb 3 07:56:22 2016 @@ -12,14 +12,14 @@ // Last Modified On : Fri Jun 2 15:13:03 2017 // Update Count : 316 -// +// #include extern "C" { -#include // malloc_usable_size -#include // uintptr_t -#include // posix_memalign +#include // malloc_usable_size +#include // uintptr_t +#include // posix_memalign } // extern #include -#include // access C malloc, realloc +#include // access C malloc, realloc int * foo( int * p, int c ) { return p; } @@ -28,26 +28,26 @@ int main( void ) { - size_t dim = 10; - int * p; + size_t dim = 10; + int * p; char fill = '\1'; // allocation, non-array types - p = (void *)malloc( sizeof(*p) ); // C malloc, type unsafe + p = (void *)malloc( sizeof(*p) ); // C malloc, type unsafe *p = 0xdeadbeef; printf( "C malloc %#x\n", *p ); - free( p ); - - p = malloc(); // CFA malloc, type safe + free( p ); + + p = malloc(); // CFA malloc, type safe *p = 0xdeadbeef; printf( "CFA malloc %#x\n", *p ); - free( p ); - - p = alloc(); // CFA alloc, type safe + free( p ); + + p = alloc(); // CFA alloc, type safe *p = 0xdeadbeef; printf( "CFA alloc %#x\n", *p ); - free( p ); - - p = alloc( fill ); // CFA alloc, fill + free( p ); + + p = alloc( fill ); // CFA alloc, fill printf( "CFA alloc, fill %08x\n", *p ); @@ -56,24 +56,24 @@ printf( "\n" ); - p = calloc( dim, sizeof( *p ) ); // C array calloc, type unsafe + p = calloc( dim, sizeof( *p ) ); // C array calloc, type unsafe printf( "C array calloc, fill 0\n" ); for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } printf( "\n" ); - free( p ); - - p = calloc( dim ); // CFA array calloc, type safe + free( p ); + + p = calloc( dim ); // CFA array calloc, type safe printf( "CFA array calloc, fill 0\n" ); for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } printf( "\n" ); - free( p ); - - p = alloc( dim ); // CFA array alloc, type safe + free( p ); + + p = alloc( dim ); // CFA array alloc, type safe for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; } printf( "CFA array alloc, no fill\n" ); for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } printf( "\n" ); - free( p ); - - p = alloc( 2 * dim, fill ); // CFA array alloc, fill + free( p ); + + p = alloc( 2 * dim, fill ); // CFA array alloc, fill printf( "CFA array alloc, fill %#x\n", fill ); for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); } @@ -85,5 +85,5 @@ printf( "\n" ); - p = (void *)realloc( p, dim * sizeof(*p) ); // C realloc + p = (void *)realloc( p, dim * sizeof(*p) ); // C realloc for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; } printf( "C realloc\n" ); @@ -91,5 +91,5 @@ printf( "\n" ); - p = realloc( p, 2 * dim * sizeof(*p) ); // CFA realloc + p = realloc( p, 2 * dim * sizeof(*p) ); // CFA realloc for ( int i = dim; i < 2 * dim; i += 1 ) { p[i] = 0x1010101; } printf( "CFA realloc\n" ); @@ -102,5 +102,5 @@ printf( "\n" ); - p = alloc( p, dim ); // CFA resize array alloc + p = alloc( p, dim ); // CFA resize array alloc for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; } printf( "CFA resize alloc\n" ); @@ -108,5 +108,5 @@ printf( "\n" ); - p = alloc( p, 2 * dim ); // CFA resize array alloc + p = alloc( p, 2 * dim ); // CFA resize array alloc for ( int i = dim; i < 2 * dim; i += 1 ) { p[i] = 0x1010101; } printf( "CFA resize array alloc\n" ); @@ -114,5 +114,5 @@ printf( "\n" ); - p = alloc( p, dim ); // CFA array alloc + p = alloc( p, dim ); // CFA array alloc printf( "CFA resize array alloc\n" ); for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } @@ -122,15 +122,15 @@ p = 0; - p = alloc( p, dim, fill ); // CFA array alloc, fill + p = alloc( p, dim, fill ); // CFA array alloc, fill printf( "CFA resize array alloc, fill\n" ); for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } printf( "\n" ); - p = alloc( p, 2 * dim, fill ); // CFA array alloc, fill + p = alloc( p, 2 * dim, fill ); // CFA array alloc, fill printf( "CFA resize array alloc, fill\n" ); for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); } printf( "\n" ); - p = alloc( p, dim, fill ); // CFA array alloc, fill + p = alloc( p, dim, fill ); // CFA array alloc, fill printf( "CFA resize array alloc, fill\n" ); for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] );; } @@ -139,6 +139,6 @@ - struct Struct { int x; double y; }; - Struct st, st1, sta[dim], sta1[dim], * stp, * stp1; + struct Struct { int x; double y; }; + Struct st, st1, sta[dim], sta1[dim], * stp, * stp1; // alignment, non-array types @@ -146,40 +146,40 @@ enum { Alignment = 128 }; - stp = (memalign( Alignment, sizeof( *stp ) ) ){ 42, 42.5 }; // C memalign + stp = (memalign( Alignment, sizeof( *stp ) ) ){ 42, 42.5 }; // C memalign assert( (uintptr_t)stp % Alignment == 0 ); printf( "C memalign %d %g\n", stp->x, stp->y ); - free( stp ); - - stp = (memalign( Alignment )){ 42, 42.5 }; // CFA memalign + free( stp ); + + stp = (memalign( Alignment )){ 42, 42.5 }; // CFA memalign assert( (uintptr_t)stp % Alignment == 0 ); printf( "CFA memalign %d %g\n", stp->x, stp->y ); - free( stp ); - - posix_memalign( (void **)&stp, Alignment, sizeof( *stp ) ); // C posix_memalign + free( stp ); + + posix_memalign( (void **)&stp, Alignment, sizeof( *stp ) ); // C posix_memalign *stp = (Struct){ 42, 42.5 }; assert( (uintptr_t)stp % Alignment == 0 ); printf( "CFA posix_memalign %d %g\n", stp->x, stp->y ); - free( stp ); - - posix_memalign( &stp, Alignment ); // CFA posix_memalign + free( stp ); + + posix_memalign( &stp, Alignment ); // CFA posix_memalign *stp = (Struct){ 42, 42.5 }; assert( (uintptr_t)stp % Alignment == 0 ); printf( "CFA posix_memalign %d %g\n", stp->x, stp->y ); - free( stp ); - - stp = (aligned_alloc( Alignment )){ 42, 42.5 }; // CFA aligned_alloc + free( stp ); + + stp = (aligned_alloc( Alignment )){ 42, 42.5 }; // CFA aligned_alloc assert( (uintptr_t)stp % Alignment == 0 ); printf( "CFA aligned_alloc %d %g\n", stp->x, stp->y ); - free( stp ); - - stp = (align_alloc( Alignment )){ 42, 42.5 }; // CFA align_alloc + free( stp ); + + stp = (align_alloc( Alignment )){ 42, 42.5 }; // CFA align_alloc assert( (uintptr_t)stp % Alignment == 0 ); printf( "CFA align_alloc %d %g\n", stp->x, stp->y ); - free( stp ); - - stp = align_alloc( Alignment, fill ); // CFA memalign, fill + free( stp ); + + stp = align_alloc( Alignment, fill ); // CFA memalign, fill assert( (uintptr_t)stp % Alignment == 0 ); printf( "CFA align_alloc fill %#x %a\n", stp->x, stp->y ); - free( stp ); + free( stp ); @@ -187,5 +187,5 @@ printf( "\n" ); - stp = align_alloc( Alignment, dim ); // CFA array memalign + stp = align_alloc( Alignment, dim ); // CFA array memalign assert( (uintptr_t)stp % Alignment == 0 ); for ( int i = 0; i < dim; i += 1 ) { stp[i] = (Struct){ 42, 42.5 }; } @@ -193,12 +193,12 @@ for ( int i = 0; i < dim; i += 1 ) { printf( "%d %g, ", stp[i].x, stp[i].y ); } printf( "\n" ); - free( stp ); - - stp = align_alloc( Alignment, dim, fill ); // CFA array memalign, fill + free( stp ); + + stp = align_alloc( Alignment, dim, fill ); // CFA array memalign, fill assert( (uintptr_t)stp % Alignment == 0 ); printf( "CFA array align_alloc, fill\n" ); for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", stp[i].x, stp[i].y ); } printf( "\n" ); - free( stp ); + free( stp ); @@ -206,7 +206,7 @@ printf( "\n" ); - memset( &st, fill ); // CFA memset, type safe + memset( &st, fill ); // CFA memset, type safe printf( "CFA memset %#x %a\n", st.x, st.y ); - memcpy( &st1, &st ); // CFA memcpy, type safe + memcpy( &st1, &st ); // CFA memcpy, type safe printf( "CFA memcpy %#x %a\n", st1.x, st1.y ); @@ -215,10 +215,10 @@ printf( "\n" ); - memset( sta, dim, fill ); // CFA array memset, type safe + memset( sta, dim, fill ); // CFA array memset, type safe printf( "CFA array memset\n" ); for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", sta[i].x, sta[i].y ); } printf( "\n" ); - memcpy( sta1, sta, dim ); // CFA array memcpy, type safe + memcpy( sta1, sta, dim ); // CFA array memcpy, type safe printf( "CFA memcpy\n" ); for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", sta1[i].x, sta1[i].y ); } @@ -247,18 +247,18 @@ printf( "\n" ); - float * fp = malloc() + 1; - printf( "pointer arithmetic %d\n", fp == fp - 1 ); - free( fp - 1 ); - - p = foo( bar( baz( malloc(), 0 ), 0 ), 0 ); + float * fp = malloc() + 1; + printf( "pointer arithmetic %d\n", fp == fp - 1 ); + free( fp - 1 ); + + p = foo( bar( baz( malloc(), 0 ), 0 ), 0 ); *p = 0xdeadbeef; printf( "CFA deep malloc %#x\n", *p ); - free( p ); + free( p ); stp = malloc(); printf( "\nSHOULD FAIL\n" ); - p = alloc( stp, dim * sizeof(*stp) ); - p = memset( stp, 10 ); - p = memcpy( &st1, &st ); + p = alloc( stp, dim * sizeof(*stp) ); + p = memset( stp, 10 ); + p = memcpy( &st1, &st ); } // main Index: src/tests/avltree/avl.h =================================================================== --- src/tests/avltree/avl.h (revision 8a6cf7efc5b53b47e66ba1a8f429bb5b7c181aa2) +++ src/tests/avltree/avl.h (revision 2afec66345a55139c8738d36411816676b2fe4d3) @@ -23,5 +23,5 @@ // forall( otype T, ttype Params | { void ?{}(T *, Params); } ) T * new( Params p ); -forall(dtype T | { void ^?{}(T *); }) +forall(dtype T | { void ^?{}(T &); }) void delete(T * x); @@ -59,8 +59,8 @@ forall(otype K | Comparable(K), otype V) -void ?{}(tree(K, V) *t, K key, V value); +void ?{}(tree(K, V) &t, K key, V value); forall(otype K, otype V) -void ^?{}(tree(K, V) * t); +void ^?{}(tree(K, V) & t); forall(otype K | Comparable(K), otype V) Index: src/tests/avltree/avl1.c =================================================================== --- src/tests/avltree/avl1.c (revision 8a6cf7efc5b53b47e66ba1a8f429bb5b7c181aa2) +++ src/tests/avltree/avl1.c (revision 2afec66345a55139c8738d36411816676b2fe4d3) @@ -3,19 +3,19 @@ forall(otype K | Comparable(K), otype V) -void ?{}(tree(K, V) *t, K key, V value){ - (&t->key) { key }; - (&t->value) { value }; - t->parent = NULL; - t->left = NULL; - t->right = NULL; - t->balance = 0; +void ?{}(tree(K, V) &t, K key, V value){ + (t.key) { key }; + (t.value) { value }; + t.parent = NULL; + t.left = NULL; + t.right = NULL; + t.balance = 0; } forall(otype K, otype V) -void ^?{}(tree(K, V) * t){ - delete(t->left); - delete(t->right); - ^(&t->key){}; - ^(&t->value){}; +void ^?{}(tree(K, V) & t){ + delete(t.left); + delete(t.right); + ^(t.key){}; + ^(t.value){}; } @@ -24,5 +24,5 @@ // infinite loop trying to resolve ... t = malloc(); tree(K, V) * t = malloc(sizeof(tree(K,V))); - t { key, value }; + (*t){ key, value }; return t; } Index: src/tests/dtor-early-exit.c =================================================================== --- src/tests/dtor-early-exit.c (revision 8a6cf7efc5b53b47e66ba1a8f429bb5b7c181aa2) +++ src/tests/dtor-early-exit.c (revision 2afec66345a55139c8738d36411816676b2fe4d3) @@ -27,11 +27,11 @@ // don't want these called -void ?{}(A * a) { assert( false ); } -void ?{}(A * a, const char * name) { a->name = name; sout | "construct " | name | endl; a->x = (int*)malloc(); } -void ?{}(A * a, const char * name, int * ptr) { assert( false ); } - -A ?=?(A * a, A a) { sout | "assign " | a->name | " " | a.name; return a; } -void ?{}(A * a, A a) { sout | "copy construct " | a.name | endl; a->x = (int*)malloc(); } -void ^?{}(A * a) { sout | "destruct " | a->name | endl; free(a->x); } +void ?{}(A & a) { assert( false ); } +void ?{}(A & a, const char * name) { a.name = name; sout | "construct " | name | endl; a.x = (int*)malloc(); } +void ?{}(A & a, const char * name, int * ptr) { assert( false ); } + +A ?=?(A & a, A b) { sout | "assign " | a.name | " " | b.name; return a; } +void ?{}(A & a, A b) { sout | "copy construct " | b.name | endl; a.x = (int*)malloc(); } +void ^?{}(A & a) { sout | "destruct " | a.name | endl; free(a.x); } // test returns Index: src/tests/globals.c =================================================================== --- src/tests/globals.c (revision 8a6cf7efc5b53b47e66ba1a8f429bb5b7c181aa2) +++ src/tests/globals.c (revision 2afec66345a55139c8738d36411816676b2fe4d3) @@ -5,5 +5,5 @@ }; -void ?{}( value_t * this ) { this->value = 22; } +void ?{}( value_t & this ) { this.value = 22; } //Standard case @@ -12,5 +12,5 @@ }; -void ?{}( g_t * this ) { (&this->val){}; } +void ?{}( g_t & this ) { (this.val){}; } g_t g; @@ -25,5 +25,5 @@ //Inline case struct gi_t; -void ?{}( gi_t * this ); +void ?{}( gi_t & this ); struct gi_t { @@ -31,5 +31,5 @@ } gi; -void ?{}( gi_t * this ) { (&this->val){}; } +void ?{}( gi_t & this ) { (this.val){}; } //Inline autogen case @@ -43,5 +43,5 @@ }; -void ?{}( gs_t * this ) { (&this->val){}; } +void ?{}( gs_t & this ) { (this.val){}; } static gs_t gs; @@ -56,5 +56,5 @@ //Static inline case struct gsi_t; -void ?{}( gsi_t * this ); +void ?{}( gsi_t & this ); static struct gsi_t { @@ -62,5 +62,5 @@ } gsi; -void ?{}( gsi_t * this ) { (&this->val){}; } +void ?{}( gsi_t & this ) { (this.val){}; } //Static inline autogen case Index: src/tests/init_once.c =================================================================== --- src/tests/init_once.c (revision 8a6cf7efc5b53b47e66ba1a8f429bb5b7c181aa2) +++ src/tests/init_once.c (revision 2afec66345a55139c8738d36411816676b2fe4d3) @@ -60,29 +60,29 @@ return -1; } -void ?{}(array * arr) { - memset(arr->elems, 0, sizeof(arr->elems)); - arr->length = 0; +void ?{}(array & arr) { + memset(arr.elems, 0, sizeof(arr.elems)); + arr.length = 0; } array constructed; array destructed; -void ?{}(init_once * x) { - assert( find( &constructed, x ) == -1 ); - remove( &destructed, x ); - insert( &constructed, x ); +void ?{}(init_once & x) { + assert( find( &constructed, &x ) == -1 ); + remove( &destructed, &x ); + insert( &constructed, &x ); - x->x = malloc(sizeof(int)); + x.x = malloc(sizeof(int)); } -void ?{}(init_once * x, init_once other) { +void ?{}(init_once & x, init_once other) { x{}; // reuse default ctor } -void ^?{}(init_once * x) { - assert( find( &destructed, x ) == -1 ); - remove( &constructed, x ); - insert( &destructed, x ); +void ^?{}(init_once & x) { + assert( find( &destructed, &x ) == -1 ); + remove( &constructed, &x ); + insert( &destructed, &x ); - free(x->x); + free(x.x); } //*** end setup @@ -125,5 +125,5 @@ init_once x; init_once y = x; - (&x) {}; // ensure this doesn't execute + x{}; // ensure this doesn't execute break; } Index: src/tests/memberCtors.c =================================================================== --- src/tests/memberCtors.c (revision 8a6cf7efc5b53b47e66ba1a8f429bb5b7c181aa2) +++ src/tests/memberCtors.c (revision 2afec66345a55139c8738d36411816676b2fe4d3) @@ -3,26 +3,26 @@ }; -void ?{}(WrappedInt * this) { +void ?{}(WrappedInt & this) { printf("constructing int\n"); - this->x = 0; + this.x = 0; } -void ?{}(WrappedInt * this, WrappedInt other) { +void ?{}(WrappedInt & this, WrappedInt other) { printf("copy constructing int: %d\n", other.x); - this->x = other.x; + this.x = other.x; } -void ?{}(WrappedInt * this, int x) { +void ?{}(WrappedInt & this, int x) { printf("constructing int: %d\n", x); - this->x = x; + this.x = x; } -void ^?{}(WrappedInt * this) { - printf("destructing int: %d\n", this->x); +void ^?{}(WrappedInt & this) { + printf("destructing int: %d\n", this.x); } -void ?=?(WrappedInt * this, int x) { - printf("assigning int: %d %d\n", this->x, x); - this->x = x; +void ?=?(WrappedInt & this, int x) { + printf("assigning int: %d %d\n", this.x, x); + this.x = x; } @@ -31,33 +31,33 @@ }; -void ?{}(A * a) { +void ?{}(A & a) { // currently must define default ctor, since there's no "= default" syntax } -void ?{}(A * a, int x) { +void ?{}(A & a, int x) { printf("begin construct A\n"); - printf("construct a->x\n"); - (&a->x){ x+999 }; - printf("assign a->y\n"); - a->y = 0; // not a constructor - default constructor will be inserted + printf("construct a.x\n"); + (a.x){ x+999 }; + printf("assign a.y\n"); + a.y = 0; // not a constructor - default constructor will be inserted printf("end construct A\n"); } // z never constructed - will be automatically default constructed -void ?{}(A * this, A other) { +void ?{}(A & this, A other) { printf("begin copy construct A\n"); - printf("copy construct this->x\n"); - (&this->x){ other.x }; - printf("assign this->y\n"); - this->y = other.y; // not a constructor - copy constructor will be inserted + printf("copy construct this.x\n"); + (this.x){ other.x }; + printf("assign this.y\n"); + this.y = other.y; // not a constructor - copy constructor will be inserted printf("end copy construct A\n"); } // z never constructed - will be automatically copy constructed -A ?=?(A * this, A other) { +A ?=?(A & this, A other) { printf("begin ?=? A\n"); - this->x = other.x; - this->y = other.y; - this->z = other.z; + this.x = other.x; + this.y = other.y; + this.z = other.z; printf("end ?=? A\n"); - return *this; + return this; } @@ -66,19 +66,19 @@ }; -void ?{}(B * b) { +void ?{}(B & b) { printf("begin construct B\n"); - printf("assign b->a2\n"); - b->a2 = (A) { 2 }; - printf("construct b->a1\n"); - (&b->a1){ 1 }; + printf("assign b.a2\n"); + b.a2 = (A) { 2 }; + printf("construct b.a1\n"); + (b.a1){ 1 }; #ifdef ERR1 - (&b->a2){ b->a3 }; // error, b->a2 was used previously but is explicitly constructed + (b.a2){ b.a3 }; // error, b->a2 was used previously but is explicitly constructed #endif printf("end construct B\n"); } // a2, a3 never constructed - will be automatically default constructed -void ^?{}(B * b) { - b->a2 = (A) { 0 }; - ^(&b->a1){}; +void ^?{}(B & b) { + b.a2 = (A) { 0 }; + ^(b.a1){}; } // a2, a3 never destructed - will be automatically destructed Index: src/tests/multiDimension.c =================================================================== --- src/tests/multiDimension.c (revision 8a6cf7efc5b53b47e66ba1a8f429bb5b7c181aa2) +++ src/tests/multiDimension.c (revision 2afec66345a55139c8738d36411816676b2fe4d3) @@ -4,30 +4,30 @@ }; -void ?{}(X * this) { +void ?{}(X & this) { printf("default constructing\n"); - (&this->a){ 123 }; - this->ptr = malloc(sizeof(int)); + (this.a){ 123 }; + this.ptr = malloc(sizeof(int)); } -void ?{}(X * this, X other) { +void ?{}(X & this, X other) { printf("copy constructing\n"); - (&this->a){ other.a }; - this->ptr = malloc(sizeof(int)); + (this.a){ other.a }; + this.ptr = malloc(sizeof(int)); } -void ?{}(X * this, int a) { +void ?{}(X & this, int a) { printf("constructing with %d\n", a); - (&this->a){ a }; - this->ptr = malloc(sizeof(int)); + (this.a){ a }; + this.ptr = malloc(sizeof(int)); } -void ^?{}(X * this) { +void ^?{}(X & this) { printf("destructing\n"); - free(this->ptr); + free(this.ptr); } -X ?=?(X * this, X other) { - this->a = other.a; - return *this; +X ?=?(X & this, X other) { + this.a = other.a; + return this; } Index: src/tests/operators.c =================================================================== --- src/tests/operators.c (revision 8a6cf7efc5b53b47e66ba1a8f429bb5b7c181aa2) +++ src/tests/operators.c (revision 2afec66345a55139c8738d36411816676b2fe4d3) @@ -11,5 +11,5 @@ } -int ?=?( int *a, int b ) { +int ?=?( int &a, int b ) { return 0; } Index: src/tests/preempt.c =================================================================== --- src/tests/preempt.c (revision 8a6cf7efc5b53b47e66ba1a8f429bb5b7c181aa2) +++ src/tests/preempt.c (revision 2afec66345a55139c8738d36411816676b2fe4d3) @@ -16,6 +16,6 @@ }; -void ?{}( worker_t * this, int value ) { - this->value = value; +void ?{}( worker_t & this, int value ) { + this.value = value; } Index: src/tests/rational.c =================================================================== --- src/tests/rational.c (revision 8a6cf7efc5b53b47e66ba1a8f429bb5b7c181aa2) +++ src/tests/rational.c (revision 2afec66345a55139c8738d36411816676b2fe4d3) @@ -1,10 +1,10 @@ -// +// // 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. -// +// // rational.c -- test rational number package -// +// // Author : Peter A. Buhr // Created On : Mon Mar 28 08:43:12 2016 @@ -12,5 +12,5 @@ // Last Modified On : Wed May 17 15:46:35 2017 // Update Count : 65 -// +// #include @@ -20,7 +20,7 @@ // UNNECESSARY, FIX ME -void ?{}( int * this ) { *this = 0; } -void ?{}( int * this, zero_t ) { *this = 0; } -void ?{}( int * this, one_t ) { *this = 1; } +void ?{}( int & this ) { this = 0; } +void ?{}( int & this, zero_t ) { this = 0; } +void ?{}( int & this, one_t ) { this = 1; } double convert( int i ) { return (double)i; } int convert( double d ) { return (int)d; } Index: src/tests/sched-int-barge.c =================================================================== --- src/tests/sched-int-barge.c (revision 8a6cf7efc5b53b47e66ba1a8f429bb5b7c181aa2) +++ src/tests/sched-int-barge.c (revision 2afec66345a55139c8738d36411816676b2fe4d3) @@ -19,15 +19,15 @@ }; -void ?{} ( global_data_t * this ) { - this->done = false; - this->counter = 0; - this->state = BARGE; +void ?{} ( global_data_t & this ) { + this.done = false; + this.counter = 0; + this.state = BARGE; - this->do_signal = 6; - this->do_wait1 = 1; - this->do_wait2 = 3; + this.do_signal = 6; + this.do_wait1 = 1; + this.do_wait2 = 3; } -void ^?{} ( global_data_t * this ) {} +void ^?{} ( global_data_t & this ) {} global_t globalA; Index: src/tests/sched-int-disjoint.c =================================================================== --- src/tests/sched-int-disjoint.c (revision 8a6cf7efc5b53b47e66ba1a8f429bb5b7c181aa2) +++ src/tests/sched-int-disjoint.c (revision 2afec66345a55139c8738d36411816676b2fe4d3) @@ -14,6 +14,6 @@ monitor global_data_t; -void ?{}( global_data_t * this ); -void ^?{} ( global_data_t * this ); +void ?{}( global_data_t & this ); +void ^?{} ( global_data_t & this ); monitor global_data_t { @@ -26,10 +26,10 @@ volatile bool all_done; -void ?{}( global_data_t * this ) { - this->counter == 0; - this->state = BARGE; +void ?{}( global_data_t & this ) { + this.counter == 0; + this.state = BARGE; } -void ^?{} ( global_data_t * this ) {} +void ^?{} ( global_data_t & this ) {} //------------------------------------------------------------------------------ Index: src/tests/test.py =================================================================== --- src/tests/test.py (revision 8a6cf7efc5b53b47e66ba1a8f429bb5b7c181aa2) +++ src/tests/test.py (revision 2afec66345a55139c8738d36411816676b2fe4d3) @@ -31,5 +31,5 @@ # parses the Makefile to find the machine type (32-bit / 64-bit) def getMachineType(): - sh('echo "void ?{}(int*a,int b){}int main(){return 0;}" > .dummy.c') + sh('echo "void ?{}(int&a,int b){}int main(){return 0;}" > .dummy.c') ret, out = sh("make .dummy -s", print2stdout=True) Index: src/tests/tupleAssign.c =================================================================== --- src/tests/tupleAssign.c (revision 8a6cf7efc5b53b47e66ba1a8f429bb5b7c181aa2) +++ src/tests/tupleAssign.c (revision 2afec66345a55139c8738d36411816676b2fe4d3) @@ -48,5 +48,5 @@ int z; } x; - X ?=?(X * x, double d) {} + X ?=?(X & x, double d) {} [int, double, int] t; Index: src/tests/tupleVariadic.c =================================================================== --- src/tests/tupleVariadic.c (revision 8a6cf7efc5b53b47e66ba1a8f429bb5b7c181aa2) +++ src/tests/tupleVariadic.c (revision 2afec66345a55139c8738d36411816676b2fe4d3) @@ -29,5 +29,5 @@ } -forall( dtype T, ttype Params | sized(T) | { void ?{}(T *, Params); } ) +forall( dtype T, ttype Params | sized(T) | { void ?{}(T &, Params); } ) T * new(Params p); @@ -38,44 +38,44 @@ // xxx - eventually this will be collapsed...x -void ?{}(array * a) { - a->size = 0; - a->data = 0; +void ?{}(array & a) { + a.size = 0; + a.data = 0; printf("called ?{} with no a\n"); } -void ?{}(array * a, int a0) { - a->size = 1; - a->data = (int*)malloc(sizeof(int)*a->size); - a->data[0] = a0; +void ?{}(array & a, int a0) { + a.size = 1; + a.data = (int*)malloc(sizeof(int)*a.size); + a.data[0] = a0; printf("called ?{} with a: %d\n", a0); } -void ?{}(array * a, int a0, int a1) { - a->size = 2; - a->data = (int*)malloc(sizeof(int)*a->size); - a->data[0] = a0; - a->data[1] = a1; +void ?{}(array & a, int a0, int a1) { + a.size = 2; + a.data = (int*)malloc(sizeof(int)*a.size); + a.data[0] = a0; + a.data[1] = a1; printf("called ?{} with a: %d %d\n", a0, a1); } -void ?{}(array * a, int a0, int a1, int a2) { - a->size = 3; - a->data = (int*)malloc(sizeof(int)*a->size); - a->data[0] = a0; - a->data[1] = a1; - a->data[2] = a2; +void ?{}(array & a, int a0, int a1, int a2) { + a.size = 3; + a.data = (int*)malloc(sizeof(int)*a.size); + a.data[0] = a0; + a.data[1] = a1; + a.data[2] = a2; printf("called ?{} with a: %d %d %d\n", a0, a1, a2); } // test use of a tuple argument -[void] ?{}(array * a, [int, int, int, int] args) { +[void] ?{}(array & a, [int, int, int, int] args) { int a0, a1, a2, a3; [a0, a1, a2, a3] = args; - a->size = 4; - a->data = malloc(sizeof(int)*a->size); - a->data[0] = a0; - a->data[1] = a1; - a->data[2] = a2; - a->data[3] = a3; + a.size = 4; + a.data = malloc(sizeof(int)*a.size); + a.data[0] = a0; + a.data[1] = a1; + a.data[2] = a2; + a.data[3] = a3; printf("called ?{} with a: %d %d %d %d\n", a0, a1, a2, a3); } Index: src/tests/vector/vector_int.c =================================================================== --- src/tests/vector/vector_int.c (revision 8a6cf7efc5b53b47e66ba1a8f429bb5b7c181aa2) +++ src/tests/vector/vector_int.c (revision 2afec66345a55139c8738d36411816676b2fe4d3) @@ -20,24 +20,24 @@ #define DEFAULT_CAPACITY 20 -void ?{}( vector_int * vec ) { +void ?{}( vector_int & vec ) { vec { DEFAULT_CAPACITY }; } -void ?{}( vector_int * vec, int reserve ) { - vec->last = -1; - vec->capacity = reserve; - vec->data = malloc( sizeof( int ) * reserve ); +void ?{}( vector_int & vec, int reserve ) { + vec.last = -1; + vec.capacity = reserve; + vec.data = malloc( sizeof( int ) * reserve ); } -void ?{}( vector_int * vec, vector_int other ) { - vec->last = other.last; - vec->capacity = other.capacity; - vec->data = malloc( sizeof( int ) * other.capacity ); - for (int i = 0; i < vec->last; i++) { - vec->data[i] = other.data[i]; +void ?{}( vector_int & vec, vector_int other ) { + vec.last = other.last; + vec.capacity = other.capacity; + vec.data = malloc( sizeof( int ) * other.capacity ); + for (int i = 0; i < vec.last; i++) { + vec.data[i] = other.data[i]; } } -void ^?{}( vector_int * vec ) { +void ^?{}( vector_int & vec ) { free( vec->data ); } Index: src/tests/vector/vector_int.h =================================================================== --- src/tests/vector/vector_int.h (revision 8a6cf7efc5b53b47e66ba1a8f429bb5b7c181aa2) +++ src/tests/vector/vector_int.h (revision 2afec66345a55139c8738d36411816676b2fe4d3) @@ -25,8 +25,8 @@ } vector_int; -void ?{}( vector_int * ); // allocate vector with default capacity -void ?{}( vector_int *, int reserve ); // allocate vector with specified capacity -void ?{}( vector_int * vec, vector_int other ); // copy constructor -void ^?{}( vector_int * ); // deallocate vector's storage +void ?{}( vector_int & ); // allocate vector with default capacity +void ?{}( vector_int &, int reserve ); // allocate vector with specified capacity +void ?{}( vector_int & vec, vector_int other ); // copy constructor +void ^?{}( vector_int & ); // deallocate vector's storage void reserve( vector_int *vec, int reserve ); // reserve more capacity