Index: tests/zombies/abort.cfa =================================================================== --- tests/zombies/abort.cfa (revision 0cc3c47034d68dcb4ba3146c73bec402f40a2236) +++ tests/zombies/abort.cfa (revision 0cc3c47034d68dcb4ba3146c73bec402f40a2236) @@ -0,0 +1,18 @@ +#include + +int level3() { + abort(); + return 0; +} + +int level2() { + return level3(); +} + +int level1() { + return level2(); +} + +int main() { + return level1(); +} Index: tests/zombies/context.cfa =================================================================== --- tests/zombies/context.cfa (revision 0cc3c47034d68dcb4ba3146c73bec402f40a2236) +++ tests/zombies/context.cfa (revision 0cc3c47034d68dcb4ba3146c73bec402f40a2236) @@ -0,0 +1,19 @@ +// trait declaration + +trait has_q( otype T ) { + T q( T ); +}; + +forall( otype z | has_q( z ) ) void f() { + trait has_r( otype T, otype U ) { + T r( T, T (T,U) ); + }; + + extern otype x, y | has_r( x, y ); +} + +//Dummy main +int main(int argc, char const *argv[]) +{ + return 0; +} Index: tests/zombies/namedParmArg.cfa =================================================================== --- tests/zombies/namedParmArg.cfa (revision 0cc3c47034d68dcb4ba3146c73bec402f40a2236) +++ tests/zombies/namedParmArg.cfa (revision 0cc3c47034d68dcb4ba3146c73bec402f40a2236) @@ -0,0 +1,14 @@ +int f1( int i = 3, int *j = 0 ) {} /* ANSI */ +[int, int ] f2( int i = 3, * int j = 0 ) {} /* CFA */ + +int main() { + f1(); /* identical calls */ + f1( 3 ); + f1( 3, ); + f1( 3, 0 ); + f1( 3, j : 0 ); + f1( j : 0, 3 ); + f1( i : 3, j : 0 ); + f1( j : 0, i : 3 ); + f1( [j, i] : f2() ); +} Index: tests/zombies/structMember.cfa =================================================================== --- tests/zombies/structMember.cfa (revision 0cc3c47034d68dcb4ba3146c73bec402f40a2236) +++ tests/zombies/structMember.cfa (revision 0cc3c47034d68dcb4ba3146c73bec402f40a2236) @@ -0,0 +1,100 @@ +typedef int TD; +extern struct TTT {}; + +struct S { + int m1:3, m2:4; + int :2; + int :3, :4; + int m3; + int m4, m5, m6; + int *m7, *m8, *m9; + __extension__ int (*m10)(); + __extension__ int *(*m11)(int); +// TD (TD); + +// Cforall declarations + + * int m12, m13; + * [ * int ] (int) m14; + +// C anonymous declarations (padding) + + int :4; + int :4, :6; + +// Cforall anonymous declarations (padding) + + int @; + TD @; + int @, @, @; + int * @ , @, @; + int * @, * @, * @; + * int @, @, @; + struct TTT @; + TTT @, @; + int @ :4, @ :6; + * int @, @; + int (*@)(); + int (*@)(int), (*@)(int); + * [int](int) @, @; + int (**@)( int ); + * * [int](int) @; + +// C aggregate open declarations + + __extension__ union { int i; }; + struct T { int k; }; + +// Cforall forward declaration + + struct PPP; + __extension__ struct QQQ; + +// C useless declarations + + int; + TD; + unsigned int; + __extension__ long double; + _Complex; + double _Complex; + volatile zero_t; + const one_t; + S; + .S; + S.T; + .S.T; + forall( otype S, otype T ) struct W { + struct X {}; + }; + W(int); + W(int).X; +}; + +struct S s; + +// Cforall Plan 9 declarations + +struct UUU {}; +extern struct SSS { + inline struct WWW {}; + inline UUU; + inline UUU *, **; + inline UUU (*)( int p ); + inline int; + inline int *; + inline * int; + inline int (*)( int p ); + inline * [int](int p); +}; + +union U { + [5] int m1; + int m2[5]; + * int m3; + int *m4; +} u; + +// Local Variables: // +// tab-width: 4 // +// End: // Index: tests/zombies/subrange.cfa =================================================================== --- tests/zombies/subrange.cfa (revision 0cc3c47034d68dcb4ba3146c73bec402f40a2236) +++ tests/zombies/subrange.cfa (revision 0cc3c47034d68dcb4ba3146c73bec402f40a2236) @@ -0,0 +1,63 @@ +// A small context defining the notion of an ordered otype. (The standard +// library should probably contain a context for this purpose.) +trait ordered(otype T) { + int ? +#include +#include + +int ?`s( int s ) { sout | "secs" | s; return s; } +int ?`m( int m ) { sout | "mins" | m; return m * 60; } +int ?`h( int h ) { sout | "hours" | h; return h * 3600; } +int ?`_A_( int x ) { sout | "_A_" | x; return x; } +int ?`__thingy_( int x ) { sout | "_thingy_" | x; return x; } + +int ?`s( const char * s ) { sout | "secs" | s; return 0; } +int ?`m( const char16_t * m ) { sout | "mins" | m; return 0;} +int ?`h( const char32_t * h ) { sout | "hours" | h; return 0; } +int ?`_A_( const wchar_t * str ) { sout | "_A_" | str; return 0; } +int ?`__thingy_( const char * str ) { sout | "_thingy_" | str; return 0; } + + +struct Weight { double stones; }; +void ?{}( Weight & w ) { w.stones = 0; } +void ?{}( Weight & w, double w ) { w.stones = w; } +Weight ?+?( Weight l, Weight r ) { + return (Weight){ l.stones + r.stones }; +} +ofstream & ?|?( ofstream & os, Weight w ) { return os | w.stones; } + +Weight ?`st( double w ) { return (Weight){ w }; } // backquote for user literals +Weight ?`lb( double w ) { return (Weight){ w / 14.0 }; } +Weight ?`kg( double w ) { return (Weight) { w * 0.16 }; } + +int main() { + Weight w, heavy = { 20 }; // 20 stone + w = 155`lb; + sout | w; + w = 0b_1111`st; + sout | w; + w = 0_233`lb; // octal weight (155) + sout | w; + w = 0x_9b_u`kg; + sout | w; + w = 70.3`kg; + sout | w; + w = 11`st + 1`lb; + sout | w; + w = 5`st + 8`kg + 25`lb + heavy; + sout | w; + +// 0`secs; + 1`s; + 23`s; + 23u`m; + 23l`h; + 23_ul`_A_; + 1_234_LL`__thingy_; + + 0xff_ffl; + 0xff_ff`s; + 0xff_ffu`m; + 0xff_ffl`h; + 0xff_fful`_A_; + 0xff_ffLL`__thingy_; + + '\n'`s; + L'\n'`h; + u'\n'`m; + L_'\n'`_A_; + U_'\n'`__thingy_; + + "abc"`s; +// u"abc"`m; +// U_"abc"`h; +// L"abc"`_A_; + u8_"abc"`__thingy_; +} // main + +// Local Variables: // +// tab-width: 4 // +// compile-command: "cfa user_literals.cfa" // +// End: // Index: tests/zombies/virtualCast.cfa =================================================================== --- tests/zombies/virtualCast.cfa (revision 0cc3c47034d68dcb4ba3146c73bec402f40a2236) +++ tests/zombies/virtualCast.cfa (revision 0cc3c47034d68dcb4ba3146c73bec402f40a2236) @@ -0,0 +1,76 @@ +// Testing the virtual cast, as part of strict inheritance. + +/* IMPORTANT: This test does not repersent the final feature set. + * We are missing a number of important aspects such as: + * + vtable type generation. + * + vtable instance generation, that might use different resolution rules. + * + Virtual syntax to force said generation on structures and traits. + * + Trait references/pointers that do the virtual_table lookup. + */ + +#include +#include + +struct alpha_vtable { + alpha_vtable const * const parent; + char (*code)(void); +}; + +struct alpha { + alpha_vtable const * virtual_table; +}; + +char ret_a(void) { + return 'a'; +} + + + +struct beta_vtable { + alpha_vtable const * const parent; + char (*code)(void); +}; + +struct beta { + beta_vtable const * virtual_table; +}; + +char ret_b(void) { + return 'b'; +} + + + +struct gamma_vtable { + beta_vtable const * const parent; + char (*code)(void); +}; + +struct gamma { + gamma_vtable const * virtual_table; +}; + +char ret_g(void) { + return 'g'; +} + + +extern "C" { + alpha_vtable _alpha_vtable_instance = { 0, ret_a }; + beta_vtable _beta_vtable_instance = { &_alpha_vtable_instance, ret_b }; + gamma_vtable _gamma_vtable_instance = { &_beta_vtable_instance, ret_g }; +} + +int main (int argc, char * argv[]) { + + gamma * tri = malloc(); tri->virtual_table = &_gamma_vtable_instance; + beta * mid = (virtual beta *)tri; + assert( 'g' == mid->virtual_table->code() ); + + alpha * top = malloc(); top->virtual_table = &_alpha_vtable_instance; + mid = (virtual beta *)top; + assert( ! mid ); + + free(tri); + free(top); +} Index: tests/zombies/withStatement.cfa =================================================================== --- tests/zombies/withStatement.cfa (revision 0cc3c47034d68dcb4ba3146c73bec402f40a2236) +++ tests/zombies/withStatement.cfa (revision 0cc3c47034d68dcb4ba3146c73bec402f40a2236) @@ -0,0 +1,109 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// tupleFunction.c -- +// +// Author : Rob Schluntz +// Created On : Mon Dec 04 17:41:45 2017 +// Last Modified By : Peter A. Buhr +// Last Modified On : Mon Dec 24 19:08:18 2018 +// Update Count : 5 +// + +#include + +struct S { + int i; + // dynamically allocated member ensures ctor/dtors are called correctly on temporaries + int * ptr; +}; + +// with clause on reference parameter +void ?{}( S & this, int n ) with( this ) { + i = n; + ptr = (int *)malloc( sizeof(int) ); +} + +void ?{}( S & this ) { + this{ 0 }; +} + +void ?{}( S & this, S other ) { + this{ other.i }; +} + +S ?=?( S & this, S other ) with( this ) { + i = other.i; + *ptr = *other.ptr; + return this; +} + +void ^?{}( S & this ) with( this ) { + free( ptr ); +} + +struct S2 { + S s; +}; + +void ?{}( S2 & this, int n ) { + (this.s){ n }; +} + +forall( otype T ) +struct Box { + T x; +}; + +forall( otype T ) +void ?{}( Box(T) & this ) with( this ) { // with clause in polymorphic function + x{}; +} + +void print( int i ) { sout | i; } + +forall( otype T | { void print( T ); }) +void foo( T t ) { + Box( T ) b = { t }; + with( b ) { // with statement in polymorphic function + print( x ); + } +} + +// ensure with-statement temporary generation works correctly +S mk() { + sout | "called mk"; + return (S){ 444 }; +} + +// ensure with-statement temporary generation with reference-returning functions works correctly +S & ref() { + static S var = { 123456789 }; + return var; +} + +int main() { + S2 s2 = { 12345 }; + with ( s2) { + with( s ) { // with s2.s + sout | i | s.i | s2.s.i; + foo( i ); // s.i + with( mk()) { + sout | i | i | i; + with( ref()) { + sout | i | i | i; + } // with ref() + with( ref()) { + sout | i | i | i; + } // with ref() + } // with mk() + } // with s + } // with s2 +} + +// Local Variables: // +// tab-width: 4 // +// End: //