Index: libcfa/prelude/builtins.c =================================================================== --- libcfa/prelude/builtins.c (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/prelude/builtins.c (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -18,5 +18,5 @@ // type that wraps a pointer and a destructor-like function - used in generating implicit destructor calls for struct members in user-defined functions // Note: needs to occur early, because it is used to generate destructor calls during code generation -forall(dtype T) +forall(T &) struct __Destructor { T * object; @@ -25,5 +25,5 @@ // defined destructor in the case that non-generated code wants to use __Destructor -forall(dtype T) +forall(T &) static inline void ^?{}(__Destructor(T) & x) { if (x.object && x.dtor) { @@ -34,5 +34,5 @@ // easy interface into __Destructor's destructor for easy codegen purposes extern "C" { - forall(dtype T) + forall(T &) static inline void __destroy_Destructor(__Destructor(T) * dtor) { ^(*dtor){}; @@ -51,5 +51,5 @@ void abort( const char fmt[], ... ) __attribute__ (( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ )); -forall(dtype T) +forall(T &) static inline T & identity(T & i) { return i; @@ -64,10 +64,10 @@ static inline void ^?{}($generator &) {} -trait is_generator(dtype T) { +trait is_generator(T &) { void main(T & this); $generator * get_generator(T & this); }; -forall(dtype T | is_generator(T)) +forall(T & | is_generator(T)) static inline T & resume(T & gen) { main(gen); @@ -78,22 +78,22 @@ static inline { - forall( dtype DT | { DT & ?+=?( DT &, one_t ); } ) + forall( DT & | { DT & ?+=?( DT &, one_t ); } ) DT & ++?( DT & x ) { return x += 1; } - forall( dtype DT | sized(DT) | { void ?{}( DT &, DT ); void ^?{}( DT & ); DT & ?+=?( DT &, one_t ); } ) + forall( DT & | sized(DT) | { void ?{}( DT &, DT ); void ^?{}( DT & ); DT & ?+=?( DT &, one_t ); } ) DT & ?++( DT & x ) { DT tmp = x; x += 1; return tmp; } - forall( dtype DT | { DT & ?-=?( DT &, one_t ); } ) + forall( DT & | { DT & ?-=?( DT &, one_t ); } ) DT & --?( DT & x ) { return x -= 1; } - forall( dtype DT | sized(DT) | { void ?{}( DT &, DT ); void ^?{}( DT & ); DT & ?-=?( DT &, one_t ); } ) + forall( DT & | sized(DT) | { void ?{}( DT &, DT ); void ^?{}( DT & ); DT & ?-=?( DT &, one_t ); } ) DT & ?--( DT & x ) { DT tmp = x; x -= 1; return tmp; } - forall( dtype DT | { int ?!=?( const DT &, zero_t ); } ) + forall( DT & | { int ?!=?( const DT &, zero_t ); } ) int !?( const DT & x ) { return !( x != 0 ); } } // distribution // universal typed pointer constant -static inline forall( dtype DT ) DT * intptr( uintptr_t addr ) { return (DT *)addr; } +static inline forall( DT & ) DT * intptr( uintptr_t addr ) { return (DT *)addr; } static inline forall( ftype FT ) FT * intptr( uintptr_t addr ) { return (FT *)addr; } @@ -156,5 +156,5 @@ #define __CFA_EXP_OVERFLOW__() -static inline forall( otype OT | { void ?{}( OT & this, one_t ); OT ?*?( OT, OT ); } ) { +static inline forall( OT | { void ?{}( OT & this, one_t ); OT ?*?( OT, OT ); } ) { OT ?\?( OT ep, unsigned int y ) { __CFA_EXP__(); } OT ?\?( OT ep, unsigned long int y ) { __CFA_EXP__(); } Index: libcfa/prelude/prelude-gen.cc =================================================================== --- libcfa/prelude/prelude-gen.cc (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/prelude/prelude-gen.cc (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -159,5 +159,5 @@ int main() { cout << "# 2 \"prelude.cfa\" // needed for error messages from this file" << endl; - cout << "trait sized(dtype T) {};" << endl; + cout << "trait sized(T &) {};" << endl; cout << "//////////////////////////" << endl; @@ -264,5 +264,5 @@ for (auto cvq : qualifiersPair) { for (auto is_vol : { " ", "volatile" }) { - cout << "forall(dtype DT) void ?{}(" << cvq.first << type << " * " << is_vol << " &, " << cvq.second << "DT *);" << endl; + cout << "forall(DT &) void ?{}(" << cvq.first << type << " * " << is_vol << " &, " << cvq.second << "DT *);" << endl; } } @@ -279,8 +279,8 @@ for (auto cvq : qualifiersSingle) { for (auto is_vol : { " ", "volatile" }) { - cout << "forall(dtype DT) void ?{}(" << cvq << " DT" << " * " << is_vol << " &);" << endl; + cout << "forall(DT &) void ?{}(" << cvq << " DT" << " * " << is_vol << " &);" << endl; } for (auto is_vol : { " ", "volatile" }) { - cout << "forall(dtype DT) void ^?{}(" << cvq << " DT" << " * " << is_vol << " &);" << endl; + cout << "forall(DT &) void ^?{}(" << cvq << " DT" << " * " << is_vol << " &);" << endl; } } @@ -290,5 +290,5 @@ for (auto is_vol : { " ", "volatile" }) { for (auto cvq : qualifiersSingle) { - cout << "forall(dtype DT) void ?{}( " << cvq << type << " * " << is_vol << " &, zero_t);" << endl; + cout << "forall(DT &) void ?{}( " << cvq << type << " * " << is_vol << " &, zero_t);" << endl; } } @@ -317,5 +317,5 @@ for (auto op : pointerOperators) { auto forall = [&op]() { - cout << "forall(dtype DT" << op.sized << ") "; + cout << "forall(DT &" << op.sized << ") "; }; for (auto type : { "DT"/*, "void"*/ } ) { @@ -408,8 +408,8 @@ for (auto is_vol : { " ", "volatile" }) { for (auto cvq : qualifiersPair) { - cout << "forall(dtype DT) " << cvq.first << "void * ?=?( " << cvq.first << "void * " << is_vol << " &, " << cvq.second << "DT *);" << endl; + cout << "forall(DT &) " << cvq.first << "void * ?=?( " << cvq.first << "void * " << is_vol << " &, " << cvq.second << "DT *);" << endl; } for (auto cvq : qualifiersSingle) { - cout << "forall(dtype DT) " << cvq << " DT * ?=?( " << cvq << " DT * " << is_vol << " &, zero_t);" << endl; + cout << "forall(DT &) " << cvq << " DT * ?=?( " << cvq << " DT * " << is_vol << " &, zero_t);" << endl; } } Index: libcfa/prelude/prelude.old.cf =================================================================== --- libcfa/prelude/prelude.old.cf (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/prelude/prelude.old.cf (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -23,5 +23,5 @@ // ------------------------------------------------------------ -trait sized(dtype T) {}; +trait sized(T &) {}; // ------------------------------------------------------------ @@ -68,21 +68,21 @@ long double _Complex ?--( long double _Complex & ), ?--( volatile long double _Complex & ); -forall( dtype T | sized(T) ) T * ?++( T *& ); -forall( dtype T | sized(T) ) const T * ?++( const T *& ); -forall( dtype T | sized(T) ) volatile T * ?++( volatile T *& ); -forall( dtype T | sized(T) ) const volatile T * ?++( const volatile T *& ); -forall( dtype T | sized(T) ) T * ?--( T *& ); -forall( dtype T | sized(T) ) const T * ?--( const T *& ); -forall( dtype T | sized(T) ) volatile T * ?--( volatile T *& ); -forall( dtype T | sized(T) ) const volatile T * ?--( const volatile T *& ); - -forall( dtype T | sized(T) ) T & ?[?]( T *, ptrdiff_t ); -forall( dtype T | sized(T) ) const T & ?[?]( const T *, ptrdiff_t ); -forall( dtype T | sized(T) ) volatile T & ?[?]( volatile T *, ptrdiff_t ); -forall( dtype T | sized(T) ) const volatile T & ?[?]( const volatile T *, ptrdiff_t ); -forall( dtype T | sized(T) ) T & ?[?]( ptrdiff_t, T * ); -forall( dtype T | sized(T) ) const T & ?[?]( ptrdiff_t, const T * ); -forall( dtype T | sized(T) ) volatile T & ?[?]( ptrdiff_t, volatile T * ); -forall( dtype T | sized(T) ) const volatile T & ?[?]( ptrdiff_t, const volatile T * ); +forall( T & | sized(T) ) T * ?++( T *& ); +forall( T & | sized(T) ) const T * ?++( const T *& ); +forall( T & | sized(T) ) volatile T * ?++( volatile T *& ); +forall( T & | sized(T) ) const volatile T * ?++( const volatile T *& ); +forall( T & | sized(T) ) T * ?--( T *& ); +forall( T & | sized(T) ) const T * ?--( const T *& ); +forall( T & | sized(T) ) volatile T * ?--( volatile T *& ); +forall( T & | sized(T) ) const volatile T * ?--( const volatile T *& ); + +forall( T & | sized(T) ) T & ?[?]( T *, ptrdiff_t ); +forall( T & | sized(T) ) const T & ?[?]( const T *, ptrdiff_t ); +forall( T & | sized(T) ) volatile T & ?[?]( volatile T *, ptrdiff_t ); +forall( T & | sized(T) ) const volatile T & ?[?]( const volatile T *, ptrdiff_t ); +forall( T & | sized(T) ) T & ?[?]( ptrdiff_t, T * ); +forall( T & | sized(T) ) const T & ?[?]( ptrdiff_t, const T * ); +forall( T & | sized(T) ) volatile T & ?[?]( ptrdiff_t, volatile T * ); +forall( T & | sized(T) ) const volatile T & ?[?]( ptrdiff_t, const volatile T * ); // ------------------------------------------------------------ @@ -107,17 +107,17 @@ long double _Complex ++?( long double _Complex & ), --?( long double _Complex & ); -forall( dtype T | sized(T) ) T * ++?( T *& ); -forall( dtype T | sized(T) ) const T * ++?( const T *& ); -forall( dtype T | sized(T) ) volatile T * ++?( volatile T *& ); -forall( dtype T | sized(T) ) const volatile T * ++?( const volatile T *& ); -forall( dtype T | sized(T) ) T * --?( T *& ); -forall( dtype T | sized(T) ) const T * --?( const T *& ); -forall( dtype T | sized(T) ) volatile T * --?( volatile T *& ); -forall( dtype T | sized(T) ) const volatile T * --?( const volatile T *& ); - -forall( dtype T | sized(T) ) T & *?( T * ); -forall( dtype T | sized(T) ) const T & *?( const T * ); -forall( dtype T | sized(T) ) volatile T & *?( volatile T * ); -forall( dtype T | sized(T) ) const volatile T & *?( const volatile T * ); +forall( T & | sized(T) ) T * ++?( T *& ); +forall( T & | sized(T) ) const T * ++?( const T *& ); +forall( T & | sized(T) ) volatile T * ++?( volatile T *& ); +forall( T & | sized(T) ) const volatile T * ++?( const volatile T *& ); +forall( T & | sized(T) ) T * --?( T *& ); +forall( T & | sized(T) ) const T * --?( const T *& ); +forall( T & | sized(T) ) volatile T * --?( volatile T *& ); +forall( T & | sized(T) ) const volatile T * --?( const volatile T *& ); + +forall( T & | sized(T) ) T & *?( T * ); +forall( T & | sized(T) ) const T & *?( const T * ); +forall( T & | sized(T) ) volatile T & *?( volatile T * ); +forall( T & | sized(T) ) const volatile T & *?( const volatile T * ); forall( ftype FT ) FT & *?( FT * ); @@ -142,8 +142,8 @@ !?( float _Complex ), !?( double _Complex ), !?( long double _Complex ); -forall( dtype DT ) int !?( DT * ); -forall( dtype DT ) int !?( const DT * ); -forall( dtype DT ) int !?( volatile DT * ); -forall( dtype DT ) int !?( const volatile DT * ); +forall( DT & ) int !?( DT * ); +forall( DT & ) int !?( const DT * ); +forall( DT & ) int !?( volatile DT * ); +forall( DT & ) int !?( const volatile DT * ); forall( ftype FT ) int !?( FT * ); @@ -191,17 +191,17 @@ long double _Complex ?+?( long double _Complex, long double _Complex ), ?-?( long double _Complex, long double _Complex ); -forall( dtype T | sized(T) ) T * ?+?( T *, ptrdiff_t ); -forall( dtype T | sized(T) ) T * ?+?( ptrdiff_t, T * ); -forall( dtype T | sized(T) ) const T * ?+?( const T *, ptrdiff_t ); -forall( dtype T | sized(T) ) const T * ?+?( ptrdiff_t, const T * ); -forall( dtype T | sized(T) ) volatile T * ?+?( volatile T *, ptrdiff_t ); -forall( dtype T | sized(T) ) volatile T * ?+?( ptrdiff_t, volatile T * ); -forall( dtype T | sized(T) ) const volatile T * ?+?( const volatile T *, ptrdiff_t ); -forall( dtype T | sized(T) ) const volatile T * ?+?( ptrdiff_t, const volatile T * ); -forall( dtype T | sized(T) ) T * ?-?( T *, ptrdiff_t ); -forall( dtype T | sized(T) ) const T * ?-?( const T *, ptrdiff_t ); -forall( dtype T | sized(T) ) volatile T * ?-?( volatile T *, ptrdiff_t ); -forall( dtype T | sized(T) ) const volatile T * ?-?( const volatile T *, ptrdiff_t ); -forall( dtype T | sized(T) ) ptrdiff_t ?-?( const volatile T *, const volatile T * ); +forall( T & | sized(T) ) T * ?+?( T *, ptrdiff_t ); +forall( T & | sized(T) ) T * ?+?( ptrdiff_t, T * ); +forall( T & | sized(T) ) const T * ?+?( const T *, ptrdiff_t ); +forall( T & | sized(T) ) const T * ?+?( ptrdiff_t, const T * ); +forall( T & | sized(T) ) volatile T * ?+?( volatile T *, ptrdiff_t ); +forall( T & | sized(T) ) volatile T * ?+?( ptrdiff_t, volatile T * ); +forall( T & | sized(T) ) const volatile T * ?+?( const volatile T *, ptrdiff_t ); +forall( T & | sized(T) ) const volatile T * ?+?( ptrdiff_t, const volatile T * ); +forall( T & | sized(T) ) T * ?-?( T *, ptrdiff_t ); +forall( T & | sized(T) ) const T * ?-?( const T *, ptrdiff_t ); +forall( T & | sized(T) ) volatile T * ?-?( volatile T *, ptrdiff_t ); +forall( T & | sized(T) ) const volatile T * ?-?( const volatile T *, ptrdiff_t ); +forall( T & | sized(T) ) ptrdiff_t ?-?( const volatile T *, const volatile T * ); // ------------------------------------------------------------ @@ -255,23 +255,23 @@ ?>?( long double, long double ), ?>=?( long double, long double ); -forall( dtype DT ) signed int ??( DT *, DT * ); -forall( dtype DT ) signed int ?>?( const DT *, const DT * ); -forall( dtype DT ) signed int ?>?( volatile DT *, volatile DT * ); -forall( dtype DT ) signed int ?>?( const volatile DT *, const volatile DT * ); - -forall( dtype DT ) signed int ?<=?( DT *, DT * ); -forall( dtype DT ) signed int ?<=?( const DT *, const DT * ); -forall( dtype DT ) signed int ?<=?( volatile DT *, volatile DT * ); -forall( dtype DT ) signed int ?<=?( const volatile DT *, const volatile DT * ); - -forall( dtype DT ) signed int ?>=?( DT *, DT * ); -forall( dtype DT ) signed int ?>=?( const DT *, const DT * ); -forall( dtype DT ) signed int ?>=?( volatile DT *, volatile DT * ); -forall( dtype DT ) signed int ?>=?( const volatile DT *, const volatile DT * ); +forall( DT & ) signed int ??( DT *, DT * ); +forall( DT & ) signed int ?>?( const DT *, const DT * ); +forall( DT & ) signed int ?>?( volatile DT *, volatile DT * ); +forall( DT & ) signed int ?>?( const volatile DT *, const volatile DT * ); + +forall( DT & ) signed int ?<=?( DT *, DT * ); +forall( DT & ) signed int ?<=?( const DT *, const DT * ); +forall( DT & ) signed int ?<=?( volatile DT *, volatile DT * ); +forall( DT & ) signed int ?<=?( const volatile DT *, const volatile DT * ); + +forall( DT & ) signed int ?>=?( DT *, DT * ); +forall( DT & ) signed int ?>=?( const DT *, const DT * ); +forall( DT & ) signed int ?>=?( volatile DT *, volatile DT * ); +forall( DT & ) signed int ?>=?( const volatile DT *, const volatile DT * ); // ------------------------------------------------------------ @@ -302,13 +302,13 @@ signed int ?==?( one_t, one_t ), ?!=?( one_t, one_t ); -forall( dtype DT ) signed int ?==?( DT *, DT * ); -forall( dtype DT ) signed int ?==?( const DT *, const DT * ); -forall( dtype DT ) signed int ?==?( volatile DT *, volatile DT * ); -forall( dtype DT ) signed int ?==?( const volatile DT *, const volatile DT * ); +forall( DT & ) signed int ?==?( DT *, DT * ); +forall( DT & ) signed int ?==?( const DT *, const DT * ); +forall( DT & ) signed int ?==?( volatile DT *, volatile DT * ); +forall( DT & ) signed int ?==?( const volatile DT *, const volatile DT * ); forall( ftype FT ) signed int ?==?( FT *, FT * ); -forall( dtype DT ) signed int ?!=?( DT *, DT * ); -forall( dtype DT ) signed int ?!=?( const DT *, const DT * ); -forall( dtype DT ) signed int ?!=?( volatile DT *, volatile DT * ); -forall( dtype DT ) signed int ?!=?( const volatile DT *, const volatile DT * ); +forall( DT & ) signed int ?!=?( DT *, DT * ); +forall( DT & ) signed int ?!=?( const DT *, const DT * ); +forall( DT & ) signed int ?!=?( volatile DT *, volatile DT * ); +forall( DT & ) signed int ?!=?( const volatile DT *, const volatile DT * ); forall( ftype FT ) signed int ?!=?( FT *, FT * ); @@ -376,73 +376,73 @@ forall( ftype FT ) FT * ?=?( FT *&, FT * ); -forall( ftype FT ) FT * ?=?( FT * volatile &, FT * ); - -forall( dtype DT ) DT * ?=?( DT * &, DT * ); -forall( dtype DT ) DT * ?=?( DT * volatile &, DT * ); -forall( dtype DT ) const DT * ?=?( const DT * &, DT * ); -forall( dtype DT ) const DT * ?=?( const DT * volatile &, DT * ); -forall( dtype DT ) const DT * ?=?( const DT * &, const DT * ); -forall( dtype DT ) const DT * ?=?( const DT * volatile &, const DT * ); -forall( dtype DT ) volatile DT * ?=?( volatile DT * &, DT * ); -forall( dtype DT ) volatile DT * ?=?( volatile DT * volatile &, DT * ); -forall( dtype DT ) volatile DT * ?=?( volatile DT * &, volatile DT * ); -forall( dtype DT ) volatile DT * ?=?( volatile DT * volatile &, volatile DT * ); - -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * &, DT * ); -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * volatile &, DT * ); -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * &, const DT * ); -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * volatile &, const DT * ); -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * &, volatile DT * ); -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * volatile &, volatile DT * ); -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * &, const volatile DT * ); -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * volatile &, const volatile DT * ); - -forall( dtype DT ) void * ?=?( void * &, DT * ); -forall( dtype DT ) void * ?=?( void * volatile &, DT * ); -forall( dtype DT ) const void * ?=?( const void * &, DT * ); -forall( dtype DT ) const void * ?=?( const void * volatile &, DT * ); -forall( dtype DT ) const void * ?=?( const void * &, const DT * ); -forall( dtype DT ) const void * ?=?( const void * volatile &, const DT * ); -forall( dtype DT ) volatile void * ?=?( volatile void * &, DT * ); -forall( dtype DT ) volatile void * ?=?( volatile void * volatile &, DT * ); -forall( dtype DT ) volatile void * ?=?( volatile void * &, volatile DT * ); -forall( dtype DT ) volatile void * ?=?( volatile void * volatile &, volatile DT * ); -forall( dtype DT ) const volatile void * ?=?( const volatile void * &, DT * ); -forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile &, DT * ); -forall( dtype DT ) const volatile void * ?=?( const volatile void * &, const DT * ); -forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile &, const DT * ); -forall( dtype DT ) const volatile void * ?=?( const volatile void * &, volatile DT * ); -forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile &, volatile DT * ); -forall( dtype DT ) const volatile void * ?=?( const volatile void * &, const volatile DT * ); -forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile &, const volatile DT * ); +forall( ftyep FT ) FT * ?=?( FT * volatile &, FT * ); + +forall( DT & ) DT * ?=?( DT * &, DT * ); +forall( DT & ) DT * ?=?( DT * volatile &, DT * ); +forall( DT & ) const DT * ?=?( const DT * &, DT * ); +forall( DT & ) const DT * ?=?( const DT * volatile &, DT * ); +forall( DT & ) const DT * ?=?( const DT * &, const DT * ); +forall( DT & ) const DT * ?=?( const DT * volatile &, const DT * ); +forall( DT & ) volatile DT * ?=?( volatile DT * &, DT * ); +forall( DT & ) volatile DT * ?=?( volatile DT * volatile &, DT * ); +forall( DT & ) volatile DT * ?=?( volatile DT * &, volatile DT * ); +forall( DT & ) volatile DT * ?=?( volatile DT * volatile &, volatile DT * ); + +forall( DT & ) const volatile DT * ?=?( const volatile DT * &, DT * ); +forall( DT & ) const volatile DT * ?=?( const volatile DT * volatile &, DT * ); +forall( DT & ) const volatile DT * ?=?( const volatile DT * &, const DT * ); +forall( DT & ) const volatile DT * ?=?( const volatile DT * volatile &, const DT * ); +forall( DT & ) const volatile DT * ?=?( const volatile DT * &, volatile DT * ); +forall( DT & ) const volatile DT * ?=?( const volatile DT * volatile &, volatile DT * ); +forall( DT & ) const volatile DT * ?=?( const volatile DT * &, const volatile DT * ); +forall( DT & ) const volatile DT * ?=?( const volatile DT * volatile &, const volatile DT * ); + +forall( DT & ) void * ?=?( void * &, DT * ); +forall( DT & ) void * ?=?( void * volatile &, DT * ); +forall( DT & ) const void * ?=?( const void * &, DT * ); +forall( DT & ) const void * ?=?( const void * volatile &, DT * ); +forall( DT & ) const void * ?=?( const void * &, const DT * ); +forall( DT & ) const void * ?=?( const void * volatile &, const DT * ); +forall( DT & ) volatile void * ?=?( volatile void * &, DT * ); +forall( DT & ) volatile void * ?=?( volatile void * volatile &, DT * ); +forall( DT & ) volatile void * ?=?( volatile void * &, volatile DT * ); +forall( DT & ) volatile void * ?=?( volatile void * volatile &, volatile DT * ); +forall( DT & ) const volatile void * ?=?( const volatile void * &, DT * ); +forall( DT & ) const volatile void * ?=?( const volatile void * volatile &, DT * ); +forall( DT & ) const volatile void * ?=?( const volatile void * &, const DT * ); +forall( DT & ) const volatile void * ?=?( const volatile void * volatile &, const DT * ); +forall( DT & ) const volatile void * ?=?( const volatile void * &, volatile DT * ); +forall( DT & ) const volatile void * ?=?( const volatile void * volatile &, volatile DT * ); +forall( DT & ) const volatile void * ?=?( const volatile void * &, const volatile DT * ); +forall( DT & ) const volatile void * ?=?( const volatile void * volatile &, const volatile DT * ); //forall( dtype DT ) DT * ?=?( DT * &, zero_t ); //forall( dtype DT ) DT * ?=?( DT * volatile &, zero_t ); -forall( dtype DT ) const DT * ?=?( const DT * &, zero_t ); -forall( dtype DT ) const DT * ?=?( const DT * volatile &, zero_t ); +forall( DT & ) const DT * ?=?( const DT * &, zero_t ); +forall( DT & ) const DT * ?=?( const DT * volatile &, zero_t ); //forall( dtype DT ) volatile DT * ?=?( volatile DT * &, zero_t ); //forall( dtype DT ) volatile DT * ?=?( volatile DT * volatile &, zero_t ); -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * &, zero_t ); -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * volatile &, zero_t ); +forall( DT & ) const volatile DT * ?=?( const volatile DT * &, zero_t ); +forall( DT & ) const volatile DT * ?=?( const volatile DT * volatile &, zero_t ); forall( ftype FT ) FT * ?=?( FT * &, zero_t ); forall( ftype FT ) FT * ?=?( FT * volatile &, zero_t ); -forall( dtype T | sized(T) ) T * ?+=?( T * &, ptrdiff_t ); -forall( dtype T | sized(T) ) T * ?+=?( T * volatile &, ptrdiff_t ); -forall( dtype T | sized(T) ) const T * ?+=?( const T * &, ptrdiff_t ); -forall( dtype T | sized(T) ) const T * ?+=?( const T * volatile &, ptrdiff_t ); -forall( dtype T | sized(T) ) volatile T * ?+=?( volatile T * &, ptrdiff_t ); -forall( dtype T | sized(T) ) volatile T * ?+=?( volatile T * volatile &, ptrdiff_t ); -forall( dtype T | sized(T) ) const volatile T * ?+=?( const volatile T * &, ptrdiff_t ); -forall( dtype T | sized(T) ) const volatile T * ?+=?( const volatile T * volatile &, ptrdiff_t ); -forall( dtype T | sized(T) ) T * ?-=?( T * &, ptrdiff_t ); -forall( dtype T | sized(T) ) T * ?-=?( T * volatile &, ptrdiff_t ); -forall( dtype T | sized(T) ) const T * ?-=?( const T * &, ptrdiff_t ); -forall( dtype T | sized(T) ) const T * ?-=?( const T * volatile &, ptrdiff_t ); -forall( dtype T | sized(T) ) volatile T * ?-=?( volatile T * &, ptrdiff_t ); -forall( dtype T | sized(T) ) volatile T * ?-=?( volatile T * volatile &, ptrdiff_t ); -forall( dtype T | sized(T) ) const volatile T * ?-=?( const volatile T * &, ptrdiff_t ); -forall( dtype T | sized(T) ) const volatile T * ?-=?( const volatile T * volatile &, ptrdiff_t ); +forall( T & | sized(T) ) T * ?+=?( T * &, ptrdiff_t ); +forall( T & | sized(T) ) T * ?+=?( T * volatile &, ptrdiff_t ); +forall( T & | sized(T) ) const T * ?+=?( const T * &, ptrdiff_t ); +forall( T & | sized(T) ) const T * ?+=?( const T * volatile &, ptrdiff_t ); +forall( T & | sized(T) ) volatile T * ?+=?( volatile T * &, ptrdiff_t ); +forall( T & | sized(T) ) volatile T * ?+=?( volatile T * volatile &, ptrdiff_t ); +forall( T & | sized(T) ) const volatile T * ?+=?( const volatile T * &, ptrdiff_t ); +forall( T & | sized(T) ) const volatile T * ?+=?( const volatile T * volatile &, ptrdiff_t ); +forall( T & | sized(T) ) T * ?-=?( T * &, ptrdiff_t ); +forall( T & | sized(T) ) T * ?-=?( T * volatile &, ptrdiff_t ); +forall( T & | sized(T) ) const T * ?-=?( const T * &, ptrdiff_t ); +forall( T & | sized(T) ) const T * ?-=?( const T * volatile &, ptrdiff_t ); +forall( T & | sized(T) ) volatile T * ?-=?( volatile T * &, ptrdiff_t ); +forall( T & | sized(T) ) volatile T * ?-=?( volatile T * volatile &, ptrdiff_t ); +forall( T & | sized(T) ) const volatile T * ?-=?( const volatile T * &, ptrdiff_t ); +forall( T & | sized(T) ) const volatile T * ?-=?( const volatile T * volatile &, ptrdiff_t ); _Bool ?=?( _Bool &, _Bool ), ?=?( volatile _Bool &, _Bool ); @@ -723,30 +723,30 @@ forall( ftype FT ) void ?{}( FT * volatile &, FT * ); -forall( dtype DT ) void ?{}( DT * &, DT * ); -forall( dtype DT ) void ?{}( const DT * &, DT * ); -forall( dtype DT ) void ?{}( const DT * &, const DT * ); -forall( dtype DT ) void ?{}( volatile DT * &, DT * ); -forall( dtype DT ) void ?{}( volatile DT * &, volatile DT * ); -forall( dtype DT ) void ?{}( const volatile DT * &, DT * ); -forall( dtype DT ) void ?{}( const volatile DT * &, const DT * ); -forall( dtype DT ) void ?{}( const volatile DT * &, volatile DT * ); -forall( dtype DT ) void ?{}( const volatile DT * &, const volatile DT * ); - -forall( dtype DT ) void ?{}( void * &, DT * ); -forall( dtype DT ) void ?{}( const void * &, DT * ); -forall( dtype DT ) void ?{}( const void * &, const DT * ); -forall( dtype DT ) void ?{}( volatile void * &, DT * ); -forall( dtype DT ) void ?{}( volatile void * &, volatile DT * ); -forall( dtype DT ) void ?{}( const volatile void * &, DT * ); -forall( dtype DT ) void ?{}( const volatile void * &, const DT * ); -forall( dtype DT ) void ?{}( const volatile void * &, volatile DT * ); -forall( dtype DT ) void ?{}( const volatile void * &, const volatile DT * ); +forall( DT & ) void ?{}( DT * &, DT * ); +forall( DT & ) void ?{}( const DT * &, DT * ); +forall( DT & ) void ?{}( const DT * &, const DT * ); +forall( DT & ) void ?{}( volatile DT * &, DT * ); +forall( DT & ) void ?{}( volatile DT * &, volatile DT * ); +forall( DT & ) void ?{}( const volatile DT * &, DT * ); +forall( DT & ) void ?{}( const volatile DT * &, const DT * ); +forall( DT & ) void ?{}( const volatile DT * &, volatile DT * ); +forall( DT & ) void ?{}( const volatile DT * &, const volatile DT * ); + +forall( DT & ) void ?{}( void * &, DT * ); +forall( DT & ) void ?{}( const void * &, DT * ); +forall( DT & ) void ?{}( const void * &, const DT * ); +forall( DT & ) void ?{}( volatile void * &, DT * ); +forall( DT & ) void ?{}( volatile void * &, volatile DT * ); +forall( DT & ) void ?{}( const volatile void * &, DT * ); +forall( DT & ) void ?{}( const volatile void * &, const DT * ); +forall( DT & ) void ?{}( const volatile void * &, volatile DT * ); +forall( DT & ) void ?{}( const volatile void * &, const volatile DT * ); //forall( dtype DT ) void ?{}( DT * &, zero_t ); //forall( dtype DT ) void ?{}( DT * volatile &, zero_t ); -forall( dtype DT ) void ?{}( const DT * &, zero_t ); +forall( DT & ) void ?{}( const DT * &, zero_t ); //forall( dtype DT ) void ?{}( volatile DT * &, zero_t ); //forall( dtype DT ) void ?{}( volatile DT * volatile &, zero_t ); -forall( dtype DT ) void ?{}( const volatile DT * &, zero_t ); +forall( DT & ) void ?{}( const volatile DT * &, zero_t ); forall( ftype FT ) void ?{}( FT * &, zero_t ); @@ -755,8 +755,8 @@ forall( ftype FT ) void ?{}( FT * & ); -forall( dtype DT ) void ?{}( DT * &); -forall( dtype DT ) void ?{}( const DT * &); -forall( dtype DT ) void ?{}( volatile DT * &); -forall( dtype DT ) void ?{}( const volatile DT * &); +forall( DT & ) void ?{}( DT * &); +forall( DT & ) void ?{}( const DT * &); +forall( DT & ) void ?{}( volatile DT * &); +forall( DT & ) void ?{}( const volatile DT * &); void ?{}( void * &); @@ -768,8 +768,8 @@ forall( ftype FT ) void ^?{}( FT * & ); -forall( dtype DT ) void ^?{}( DT * &); -forall( dtype DT ) void ^?{}( const DT * &); -forall( dtype DT ) void ^?{}( volatile DT * &); -forall( dtype DT ) void ^?{}( const volatile DT * &); +forall( DT & ) void ^?{}( DT * &); +forall( DT & ) void ^?{}( const DT * &); +forall( DT & ) void ^?{}( volatile DT * &); +forall( DT & ) void ^?{}( const volatile DT * &); void ^?{}( void * &); Index: libcfa/prelude/sync-builtins.cf =================================================================== --- libcfa/prelude/sync-builtins.cf (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/prelude/sync-builtins.cf (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -206,5 +206,5 @@ _Bool __sync_bool_compare_and_swap(volatile unsigned __int128 *, unsigned __int128, unsigned __int128,...); #endif -forall(dtype T) _Bool __sync_bool_compare_and_swap(T * volatile *, T *, T*, ...); +forall(T &) _Bool __sync_bool_compare_and_swap(T * volatile *, T *, T*, ...); char __sync_val_compare_and_swap(volatile char *, char, char,...); @@ -223,5 +223,5 @@ unsigned __int128 __sync_val_compare_and_swap(volatile unsigned __int128 *, unsigned __int128, unsigned __int128,...); #endif -forall(dtype T) T * __sync_val_compare_and_swap(T * volatile *, T *, T*,...); +forall(T &) T * __sync_val_compare_and_swap(T * volatile *, T *, T*,...); char __sync_lock_test_and_set(volatile char *, char,...); @@ -326,6 +326,6 @@ void __atomic_exchange(volatile unsigned __int128 *, volatile unsigned __int128 *, volatile unsigned __int128 *, int); #endif -forall(dtype T) T * __atomic_exchange_n(T * volatile *, T *, int); -forall(dtype T) void __atomic_exchange(T * volatile *, T * volatile *, T * volatile *, int); +forall(T &) T * __atomic_exchange_n(T * volatile *, T *, int); +forall(T &) void __atomic_exchange(T * volatile *, T * volatile *, T * volatile *, int); _Bool __atomic_load_n(const volatile _Bool *, int); @@ -359,6 +359,6 @@ void __atomic_load(const volatile unsigned __int128 *, volatile unsigned __int128 *, int); #endif -forall(dtype T) T * __atomic_load_n(T * const volatile *, int); -forall(dtype T) void __atomic_load(T * const volatile *, T **, int); +forall(T &) T * __atomic_load_n(T * const volatile *, int); +forall(T &) void __atomic_load(T * const volatile *, T **, int); _Bool __atomic_compare_exchange_n(volatile char *, char *, char, _Bool, int, int); @@ -390,6 +390,6 @@ _Bool __atomic_compare_exchange (volatile unsigned __int128 *, unsigned __int128 *, unsigned __int128 *, _Bool, int, int); #endif -forall(dtype T) _Bool __atomic_compare_exchange_n (T * volatile *, T **, T*, _Bool, int, int); -forall(dtype T) _Bool __atomic_compare_exchange (T * volatile *, T **, T**, _Bool, int, int); +forall(T &) _Bool __atomic_compare_exchange_n (T * volatile *, T **, T*, _Bool, int, int); +forall(T &) _Bool __atomic_compare_exchange (T * volatile *, T **, T**, _Bool, int, int); void __atomic_store_n(volatile _Bool *, _Bool, int); @@ -423,6 +423,6 @@ void __atomic_store(volatile unsigned __int128 *, unsigned __int128 *, int); #endif -forall(dtype T) void __atomic_store_n(T * volatile *, T *, int); -forall(dtype T) void __atomic_store(T * volatile *, T **, int); +forall(T &) void __atomic_store_n(T * volatile *, T *, int); +forall(T &) void __atomic_store(T * volatile *, T **, int); char __atomic_add_fetch (volatile char *, char, int); Index: libcfa/src/bitmanip.hfa =================================================================== --- libcfa/src/bitmanip.hfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/bitmanip.hfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -100,5 +100,5 @@ unsigned long long int floor2( unsigned long long int n, unsigned long long int align ) { verify( is_pow2( align ) ); return n & -align; } - // forall( otype T | { T ?&?( T, T ); T -?( T ); } ) + // forall( T | { T ?&?( T, T ); T -?( T ); } ) // T floor2( T n, T align ) { verify( is_pow2( align ) ); return n & -align; } @@ -115,5 +115,5 @@ unsigned long long int ceiling2( unsigned long long int n, unsigned long long int align ) { verify( is_pow2( align ) ); return -floor2( -n, align ); } - // forall( otype T | { T floor2( T, T ); T -?( T ); } ) + // forall( T | { T floor2( T, T ); T -?( T ); } ) // T ceiling2( T n, T align ) { verify( is_pow2( align ) ); return -floor2( -n, align ); } } // distribution Index: libcfa/src/bits/algorithm.hfa =================================================================== --- libcfa/src/bits/algorithm.hfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/bits/algorithm.hfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -17,12 +17,12 @@ #ifdef SAFE_SORT -forall( otype T | { int ??( T, T ); } ) static inline void __libcfa_small_sort2( T * arr ); -forall( otype T | { int ??( T, T ); } ) static inline void __libcfa_small_sort3( T * arr ); -forall( otype T | { int ??( T, T ); } ) static inline void __libcfa_small_sort4( T * arr ); -forall( otype T | { int ??( T, T ); } ) static inline void __libcfa_small_sort5( T * arr ); -forall( otype T | { int ??( T, T ); } ) static inline void __libcfa_small_sort6( T * arr ); -forall( otype T | { int ??( T, T ); } ) static inline void __libcfa_small_sortN( T * arr, size_t dim ); +forall( T | { int ??( T, T ); } ) static inline void __libcfa_small_sort2( T * arr ); +forall( T | { int ??( T, T ); } ) static inline void __libcfa_small_sort3( T * arr ); +forall( T | { int ??( T, T ); } ) static inline void __libcfa_small_sort4( T * arr ); +forall( T | { int ??( T, T ); } ) static inline void __libcfa_small_sort5( T * arr ); +forall( T | { int ??( T, T ); } ) static inline void __libcfa_small_sort6( T * arr ); +forall( T | { int ??( T, T ); } ) static inline void __libcfa_small_sortN( T * arr, size_t dim ); -forall( otype T | { int ??( T, T ); } ) +forall( T | { int ??( T, T ); } ) static inline void __libcfa_small_sort( T * arr, size_t dim ) { switch( dim ) { @@ -41,10 +41,10 @@ #define SWAP(x,y) { T a = min(arr[x], arr[y]); T b = max(arr[x], arr[y]); arr[x] = a; arr[y] = b;} -forall( otype T | { int ??( T, T ); } ) +forall( T | { int ??( T, T ); } ) static inline void __libcfa_small_sort2( T * arr ) { SWAP(0, 1); } -forall( otype T | { int ??( T, T ); } ) +forall( T | { int ??( T, T ); } ) static inline void __libcfa_small_sort3( T * arr ) { SWAP(1, 2); @@ -53,5 +53,5 @@ } -forall( otype T | { int ??( T, T ); } ) +forall( T | { int ??( T, T ); } ) static inline void __libcfa_small_sort4( T * arr ) { SWAP(0, 1); @@ -62,5 +62,5 @@ } -forall( otype T | { int ??( T, T ); } ) +forall( T | { int ??( T, T ); } ) static inline void __libcfa_small_sort5( T * arr ) { SWAP(0, 1); @@ -75,5 +75,5 @@ } -forall( otype T | { int ??( T, T ); } ) +forall( T | { int ??( T, T ); } ) static inline void __libcfa_small_sort6( T * arr ) { SWAP(1, 2); @@ -91,5 +91,5 @@ } -forall( otype T | { int ??( T, T ); } ) +forall( T | { int ??( T, T ); } ) static inline void __libcfa_small_sortN( T * arr, size_t dim ) { int i, j; @@ -112,5 +112,5 @@ static inline void __libcfa_small_sortN( void* * arr, size_t dim ); -forall( dtype T ) +forall( T & ) static inline void __libcfa_small_sort( T* * arr, size_t dim ) { switch( dim ) { Index: libcfa/src/bits/collection.hfa =================================================================== --- libcfa/src/bits/collection.hfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/bits/collection.hfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -31,5 +31,5 @@ // // wrappers to make Collection have T - // forall( dtype T ) { + // forall( T & ) { // T *& Next( T * n ) { // return (T *)Next( (Colable *)n ); @@ -38,5 +38,5 @@ } // distribution -forall( dtype T | { T *& Next ( T * ); } ) { +forall( T & | { T *& Next ( T * ); } ) { bool listed( T * n ) { return Next( n ) != 0p; @@ -76,5 +76,5 @@ } // post: elts = null - forall( dtype T ) { + forall( T & ) { T * Curr( ColIter & ci ) with( ci ) { return (T *)curr; Index: libcfa/src/bits/containers.hfa =================================================================== --- libcfa/src/bits/containers.hfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/bits/containers.hfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -23,5 +23,5 @@ #ifdef __cforall - forall(dtype T) + forall(T &) #else #define T void @@ -40,23 +40,23 @@ #ifdef __cforall - // forall(otype T | sized(T)) + // forall(T | sized(T)) // static inline void ?{}(__small_array(T) & this) {} - forall(dtype T | sized(T)) + forall(T & | sized(T)) static inline T & ?[?]( __small_array(T) & this, __lock_size_t idx ) { return ((typeof(this.data))this.data)[idx]; } - forall(dtype T | sized(T)) + forall(T & | sized(T)) static inline T & ?[?]( const __small_array(T) & this, __lock_size_t idx ) { return ((typeof(this.data))this.data)[idx]; } - forall(dtype T) + forall(T &) static inline T * begin( const __small_array(T) & this ) { return ((typeof(this.data))this.data); } - forall(dtype T | sized(T)) + forall(T & | sized(T)) static inline T * end( const __small_array(T) & this ) { return ((typeof(this.data))this.data) + this.size; @@ -69,5 +69,5 @@ #ifdef __cforall - trait is_node(dtype T) { + trait is_node(T &) { T *& get_next( T & ); }; @@ -78,5 +78,5 @@ //----------------------------------------------------------------------------- #ifdef __cforall - forall(dtype TYPE) + forall(TYPE &) #define T TYPE #else @@ -95,10 +95,10 @@ #ifdef __cforall - forall(dtype T) + forall(T &) static inline void ?{}( __stack(T) & this ) { (this.top){ 0p }; } - static inline forall( dtype T | is_node(T) ) { + static inline forall( T & | is_node(T) ) { void push( __stack(T) & this, T * val ) { verify( !get_next( *val ) ); @@ -126,5 +126,5 @@ //----------------------------------------------------------------------------- #ifdef __cforall - forall(dtype TYPE) + forall(TYPE &) #define T TYPE #else @@ -144,5 +144,5 @@ #ifdef __cforall - static inline forall( dtype T | is_node(T) ) { + static inline forall( T & | is_node(T) ) { void ?{}( __queue(T) & this ) with( this ) { (this.head){ 1p }; @@ -215,5 +215,5 @@ //----------------------------------------------------------------------------- #ifdef __cforall - forall(dtype TYPE) + forall(TYPE &) #define T TYPE #define __getter_t * [T * & next, T * & prev] ( T & ) @@ -237,5 +237,5 @@ #ifdef __cforall - forall(dtype T ) + forall(T & ) static inline [void] ?{}( __dllist(T) & this, * [T * & next, T * & prev] ( T & ) __get ) { (this.head){ 0p }; @@ -245,5 +245,5 @@ #define next 0 #define prev 1 - static inline forall(dtype T) { + static inline forall(T &) { void push_front( __dllist(T) & this, T & node ) with( this ) { verify(__get); Index: libcfa/src/bits/queue.hfa =================================================================== --- libcfa/src/bits/queue.hfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/bits/queue.hfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -9,5 +9,5 @@ // instead of being null. -forall( dtype T | { T *& Next ( T * ); } ) { +forall( T & | { T *& Next ( T * ); } ) { struct Queue { inline Collection; // Plan 9 inheritance @@ -151,5 +151,5 @@ } // distribution -forall( dtype T | { T *& Next ( T * ); } ) { +forall( T & | { T *& Next ( T * ); } ) { struct QueueIter { inline ColIter; // Plan 9 inheritance Index: libcfa/src/bits/sequence.hfa =================================================================== --- libcfa/src/bits/sequence.hfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/bits/sequence.hfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -29,5 +29,5 @@ // // wrappers to make Collection have T - // forall( dtype T ) { + // forall( T & ) { // T *& Back( T * n ) { // return (T *)Back( (Seqable *)n ); @@ -43,5 +43,5 @@ // and the back field of the last node points at the first node (circular). -forall( dtype T | { T *& Back ( T * ); T *& Next ( T * ); } ) { +forall( T & | { T *& Back ( T * ); T *& Next ( T * ); } ) { struct Sequence { inline Collection; // Plan 9 inheritance @@ -231,5 +231,5 @@ } // distribution -forall( dtype T | { T *& Back ( T * ); T *& Next ( T * ); } ) { +forall( T & | { T *& Back ( T * ); T *& Next ( T * ); } ) { // SeqIter(T) is used to iterate over a Sequence(T) in head-to-tail order. struct SeqIter { Index: libcfa/src/bits/stack.hfa =================================================================== --- libcfa/src/bits/stack.hfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/bits/stack.hfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -9,5 +9,5 @@ // instead of being null. -forall( dtype T | { T *& Next ( T * ); } ) { +forall( T & | { T *& Next ( T * ); } ) { struct Stack { inline Collection; // Plan 9 inheritance @@ -67,5 +67,5 @@ // order returned by drop(). -forall( dtype T | { T *& Next ( T * ); } ) { +forall( T & | { T *& Next ( T * ); } ) { struct StackIter { inline ColIter; // Plan 9 inheritance Index: libcfa/src/common.cfa =================================================================== --- libcfa/src/common.cfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/common.cfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -23,5 +23,5 @@ [ long int, long int ] div( long int num, long int denom ) { ldiv_t qr = ldiv( num, denom ); return [ qr.quot, qr.rem ]; } [ long long int, long long int ] div( long long int num, long long int denom ) { lldiv_t qr = lldiv( num, denom ); return [ qr.quot, qr.rem ]; } -forall( otype T | { T ?/?( T, T ); T ?%?( T, T ); } ) +forall( T | { T ?/?( T, T ); T ?%?( T, T ); } ) [ T, T ] div( T num, T denom ) { return [ num / denom, num % denom ]; } Index: libcfa/src/common.hfa =================================================================== --- libcfa/src/common.hfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/common.hfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -21,5 +21,5 @@ [ long int, long int ] div( long int num, long int denom ); [ long long int, long long int ] div( long long int num, long long int denom ); -forall( otype T | { T ?/?( T, T ); T ?%?( T, T ); } ) +forall( T | { T ?/?( T, T ); T ?%?( T, T ); } ) [ T, T ] div( T num, T demon ); @@ -61,5 +61,5 @@ } // distribution -forall( otype T | { void ?{}( T &, zero_t ); int ? t2 ? t1 : t2; } // optimization uintptr_t max( uintptr_t t1, uintptr_t t2 ) { return t1 > t2 ? t1 : t2; } // optimization - forall( otype T | { int ?>?( T, T ); } ) + forall( T | { int ?>?( T, T ); } ) T max( T t1, T t2 ) { return t1 > t2 ? t1 : t2; } - forall( otype T | { T min( T, T ); T max( T, T ); } ) + forall( T | { T min( T, T ); T max( T, T ); } ) T clamp( T value, T min_val, T max_val ) { return max( min_val, min( value, max_val ) ); } - forall( otype T ) + forall( T ) void swap( T & v1, T & v2 ) { T temp = v1; v1 = v2; v2 = temp; } } // distribution Index: libcfa/src/concurrency/coroutine.cfa =================================================================== --- libcfa/src/concurrency/coroutine.cfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/concurrency/coroutine.cfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -46,10 +46,10 @@ //----------------------------------------------------------------------------- -FORALL_DATA_INSTANCE(CoroutineCancelled, (dtype coroutine_t), (coroutine_t)) - -forall(dtype T) +FORALL_DATA_INSTANCE(CoroutineCancelled, (coroutine_t &), (coroutine_t)) + +forall(T &) void mark_exception(CoroutineCancelled(T) *) {} -forall(dtype T) +forall(T &) void copy(CoroutineCancelled(T) * dst, CoroutineCancelled(T) * src) { dst->virtual_table = src->virtual_table; @@ -58,5 +58,5 @@ } -forall(dtype T) +forall(T &) const char * msg(CoroutineCancelled(T) *) { return "CoroutineCancelled(...)"; @@ -64,5 +64,5 @@ // This code should not be inlined. It is the error path on resume. -forall(dtype T | is_coroutine(T)) +forall(T & | is_coroutine(T)) void __cfaehm_cancelled_coroutine( T & cor, $coroutine * desc ) { verify( desc->cancellation ); @@ -148,5 +148,5 @@ // Part of the Public API // Not inline since only ever called once per coroutine -forall(dtype T | is_coroutine(T)) +forall(T & | is_coroutine(T)) void prime(T& cor) { $coroutine* this = get_coroutine(cor); Index: libcfa/src/concurrency/coroutine.hfa =================================================================== --- libcfa/src/concurrency/coroutine.hfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/concurrency/coroutine.hfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -22,13 +22,13 @@ //----------------------------------------------------------------------------- // Exception thrown from resume when a coroutine stack is cancelled. -FORALL_DATA_EXCEPTION(CoroutineCancelled, (dtype coroutine_t), (coroutine_t)) ( +FORALL_DATA_EXCEPTION(CoroutineCancelled, (coroutine_t &), (coroutine_t)) ( coroutine_t * the_coroutine; exception_t * the_exception; ); -forall(dtype T) +forall(T &) void copy(CoroutineCancelled(T) * dst, CoroutineCancelled(T) * src); -forall(dtype T) +forall(T &) const char * msg(CoroutineCancelled(T) *); @@ -37,5 +37,5 @@ // Anything that implements this trait can be resumed. // Anything that is resumed is a coroutine. -trait is_coroutine(dtype T | IS_RESUMPTION_EXCEPTION(CoroutineCancelled, (T))) { +trait is_coroutine(T & | IS_RESUMPTION_EXCEPTION(CoroutineCancelled, (T))) { void main(T & this); $coroutine * get_coroutine(T & this); @@ -60,5 +60,5 @@ //----------------------------------------------------------------------------- // Public coroutine API -forall(dtype T | is_coroutine(T)) +forall(T & | is_coroutine(T)) void prime(T & cor); @@ -72,5 +72,5 @@ void __cfactx_invoke_coroutine(void (*main)(void *), void * this); - forall(dtype T) + forall(T &) void __cfactx_start(void (*main)(T &), struct $coroutine * cor, T & this, void (*invoke)(void (*main)(void *), void *)); @@ -129,9 +129,9 @@ } -forall(dtype T | is_coroutine(T)) +forall(T & | is_coroutine(T)) void __cfaehm_cancelled_coroutine( T & cor, $coroutine * desc ); // Resume implementation inlined for performance -forall(dtype T | is_coroutine(T)) +forall(T & | is_coroutine(T)) static inline T & resume(T & cor) { // optimization : read TLS once and reuse it Index: libcfa/src/concurrency/future.hfa =================================================================== --- libcfa/src/concurrency/future.hfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/concurrency/future.hfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -19,5 +19,5 @@ #include "monitor.hfa" -forall( otype T ) { +forall( T ) { struct future { inline future_t; @@ -58,5 +58,5 @@ } -forall( otype T ) { +forall( T ) { monitor multi_future { inline future_t; Index: libcfa/src/concurrency/io/setup.cfa =================================================================== --- libcfa/src/concurrency/io/setup.cfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/concurrency/io/setup.cfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -113,9 +113,10 @@ static struct { - pthread_t thrd; // pthread handle to io poller thread - void * stack; // pthread stack for io poller thread - int epollfd; // file descriptor to the epoll instance - volatile bool run; // Whether or not to continue - volatile size_t epoch; // Epoch used for memory reclamation + pthread_t thrd; // pthread handle to io poller thread + void * stack; // pthread stack for io poller thread + int epollfd; // file descriptor to the epoll instance + volatile bool run; // Whether or not to continue + volatile bool stopped; // Whether the poller has finished running + volatile uint64_t epoch; // Epoch used for memory reclamation } iopoll; @@ -130,7 +131,8 @@ __cfadbg_print_safe(io_core, "Kernel : Starting io poller thread\n" ); - iopoll.run = true; - iopoll.stack = __create_pthread( &iopoll.thrd, iopoll_loop, 0p ); - iopoll.epoch = 0; + iopoll.stack = __create_pthread( &iopoll.thrd, iopoll_loop, 0p ); + iopoll.run = true; + iopoll.stopped = false; + iopoll.epoch = 0; } @@ -205,4 +207,6 @@ } } + + __atomic_store_n(&iopoll.stopped, true, __ATOMIC_SEQ_CST); __cfadbg_print_safe(io_core, "Kernel : IO poller thread stopping\n" ); @@ -536,5 +540,5 @@ // Wait for the next epoch - while(curr == __atomic_load_n(&iopoll.epoch, __ATOMIC_RELAXED)) yield(); + while(curr == iopoll.epoch && !iopoll.stopped) Pause(); } Index: libcfa/src/concurrency/locks.cfa =================================================================== --- libcfa/src/concurrency/locks.cfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/concurrency/locks.cfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -7,5 +7,5 @@ //----------------------------------------------------------------------------- // info_thread -forall(dtype L | is_blocking_lock(L)) { +forall(L & | is_blocking_lock(L)) { struct info_thread { // used to put info_thread on a dl queue (aka sequence) @@ -195,5 +195,5 @@ //----------------------------------------------------------------------------- // alarm node wrapper -forall(dtype L | is_blocking_lock(L)) { +forall(L & | is_blocking_lock(L)) { struct alarm_node_wrap { alarm_node_t alarm_node; @@ -239,5 +239,5 @@ //----------------------------------------------------------------------------- // condition variable -forall(dtype L | is_blocking_lock(L)) { +forall(L & | is_blocking_lock(L)) { void ?{}( condition_variable(L) & this ){ Index: libcfa/src/concurrency/locks.hfa =================================================================== --- libcfa/src/concurrency/locks.hfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/concurrency/locks.hfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -13,5 +13,5 @@ //----------------------------------------------------------------------------- // is_blocking_lock -trait is_blocking_lock(dtype L | sized(L)) { +trait is_blocking_lock(L & | sized(L)) { // For synchronization locks to use when acquiring void on_notify( L &, struct $thread * ); @@ -31,5 +31,5 @@ // the info thread is a wrapper around a thread used // to store extra data for use in the condition variable -forall(dtype L | is_blocking_lock(L)) { +forall(L & | is_blocking_lock(L)) { struct info_thread; @@ -120,5 +120,5 @@ //----------------------------------------------------------------------------- // Synchronization Locks -forall(dtype L | is_blocking_lock(L)) { +forall(L & | is_blocking_lock(L)) { struct condition_variable { // Spin lock used for mutual exclusion Index: libcfa/src/concurrency/monitor.cfa =================================================================== --- libcfa/src/concurrency/monitor.cfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/concurrency/monitor.cfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -50,5 +50,5 @@ static inline [$thread *, int] search_entry_queue( const __waitfor_mask_t &, $monitor * monitors [], __lock_size_t count ); -forall(dtype T | sized( T )) +forall(T & | sized( T )) static inline __lock_size_t insert_unique( T * array [], __lock_size_t & size, T * val ); static inline __lock_size_t count_max ( const __waitfor_mask_t & mask ); @@ -949,5 +949,5 @@ } -forall(dtype T | sized( T )) +forall(T & | sized( T )) static inline __lock_size_t insert_unique( T * array [], __lock_size_t & size, T * val ) { if( !val ) return size; Index: libcfa/src/concurrency/monitor.hfa =================================================================== --- libcfa/src/concurrency/monitor.hfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/concurrency/monitor.hfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -22,5 +22,5 @@ #include "stdlib.hfa" -trait is_monitor(dtype T) { +trait is_monitor(T &) { $monitor * get_monitor( T & ); void ^?{}( T & mutex ); @@ -59,5 +59,5 @@ void ^?{}( monitor_dtor_guard_t & this ); -static inline forall( dtype T | sized(T) | { void ^?{}( T & mutex ); } ) +static inline forall( T & | sized(T) | { void ^?{}( T & mutex ); } ) void delete( T * th ) { ^(*th){}; Index: libcfa/src/concurrency/mutex.cfa =================================================================== --- libcfa/src/concurrency/mutex.cfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/concurrency/mutex.cfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -164,5 +164,5 @@ } -forall(dtype L | is_lock(L)) +forall(L & | is_lock(L)) void wait(condition_variable & this, L & l) { lock( this.lock __cfaabi_dbg_ctx2 ); @@ -176,5 +176,5 @@ //----------------------------------------------------------------------------- // Scopes -forall(dtype L | is_lock(L)) +forall(L & | is_lock(L)) void lock_all ( L * locks[], size_t count) { // Sort locks based on addresses @@ -188,5 +188,5 @@ } -forall(dtype L | is_lock(L)) +forall(L & | is_lock(L)) void unlock_all( L * locks[], size_t count) { // Lock all Index: libcfa/src/concurrency/mutex.hfa =================================================================== --- libcfa/src/concurrency/mutex.hfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/concurrency/mutex.hfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -70,5 +70,5 @@ void unlock(recursive_mutex_lock & this) __attribute__((deprecated("use concurrency/locks.hfa instead"))); -trait is_lock(dtype L | sized(L)) { +trait is_lock(L & | sized(L)) { void lock (L &); void unlock(L &); @@ -94,10 +94,10 @@ void wait(condition_variable & this) __attribute__((deprecated("use concurrency/locks.hfa instead"))); -forall(dtype L | is_lock(L)) +forall(L & | is_lock(L)) void wait(condition_variable & this, L & l) __attribute__((deprecated("use concurrency/locks.hfa instead"))); //----------------------------------------------------------------------------- // Scopes -forall(dtype L | is_lock(L)) { +forall(L & | is_lock(L)) { #if !defined( __TUPLE_ARRAYS_EXIST__ ) void lock ( L * locks [], size_t count); Index: libcfa/src/concurrency/thread.cfa =================================================================== --- libcfa/src/concurrency/thread.cfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/concurrency/thread.cfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -62,7 +62,7 @@ } -FORALL_DATA_INSTANCE(ThreadCancelled, (dtype thread_t), (thread_t)) +FORALL_DATA_INSTANCE(ThreadCancelled, (thread_t &), (thread_t)) -forall(dtype T) +forall(T &) void copy(ThreadCancelled(T) * dst, ThreadCancelled(T) * src) { dst->virtual_table = src->virtual_table; @@ -71,23 +71,23 @@ } -forall(dtype T) +forall(T &) const char * msg(ThreadCancelled(T) *) { return "ThreadCancelled"; } -forall(dtype T) +forall(T &) static void default_thread_cancel_handler(ThreadCancelled(T) & ) { abort( "Unhandled thread cancellation.\n" ); } -forall(dtype T | is_thread(T) | IS_EXCEPTION(ThreadCancelled, (T))) +forall(T & | is_thread(T) | IS_EXCEPTION(ThreadCancelled, (T))) void ?{}( thread_dtor_guard_t & this, - T & thrd, void(*defaultResumptionHandler)(ThreadCancelled(T) &)) { - $monitor * m = get_monitor(thrd); + T & thrd, void(*cancelHandler)(ThreadCancelled(T) &)) { + $monitor * m = get_monitor(thrd); $thread * desc = get_thread(thrd); // Setup the monitor guard void (*dtor)(T& mutex this) = ^?{}; - bool join = defaultResumptionHandler != (void(*)(ThreadCancelled(T)&))0; + bool join = cancelHandler != (void(*)(ThreadCancelled(T)&))0; (this.mg){&m, (void(*)())dtor, join}; @@ -103,7 +103,6 @@ } desc->state = Cancelled; - if (!join) { - defaultResumptionHandler = default_thread_cancel_handler; - } + void(*defaultResumptionHandler)(ThreadCancelled(T) &) = + join ? cancelHandler : default_thread_cancel_handler; ThreadCancelled(T) except; @@ -125,5 +124,5 @@ //----------------------------------------------------------------------------- // Starting and stopping threads -forall( dtype T | is_thread(T) ) +forall( T & | is_thread(T) ) void __thrd_start( T & this, void (*main_p)(T &) ) { $thread * this_thrd = get_thread(this); @@ -141,5 +140,5 @@ //----------------------------------------------------------------------------- // Support for threads that don't ues the thread keyword -forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T&); } ) +forall( T & | sized(T) | is_thread(T) | { void ?{}(T&); } ) void ?{}( scoped(T)& this ) with( this ) { handle{}; @@ -147,5 +146,5 @@ } -forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T&, P); } ) +forall( T &, P... | sized(T) | is_thread(T) | { void ?{}(T&, P); } ) void ?{}( scoped(T)& this, P params ) with( this ) { handle{ params }; @@ -153,5 +152,5 @@ } -forall( dtype T | sized(T) | is_thread(T) ) +forall( T & | sized(T) | is_thread(T) ) void ^?{}( scoped(T)& this ) with( this ) { ^handle{}; @@ -159,5 +158,5 @@ //----------------------------------------------------------------------------- -forall(dtype T | is_thread(T) | IS_RESUMPTION_EXCEPTION(ThreadCancelled, (T))) +forall(T & | is_thread(T) | IS_RESUMPTION_EXCEPTION(ThreadCancelled, (T))) T & join( T & this ) { thread_dtor_guard_t guard = { this, defaultResumptionHandler }; Index: libcfa/src/concurrency/thread.hfa =================================================================== --- libcfa/src/concurrency/thread.hfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/concurrency/thread.hfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -26,5 +26,5 @@ //----------------------------------------------------------------------------- // thread trait -trait is_thread(dtype T) { +trait is_thread(T &) { void ^?{}(T& mutex this); void main(T& this); @@ -32,13 +32,13 @@ }; -FORALL_DATA_EXCEPTION(ThreadCancelled, (dtype thread_t), (thread_t)) ( +FORALL_DATA_EXCEPTION(ThreadCancelled, (thread_t &), (thread_t)) ( thread_t * the_thread; exception_t * the_exception; ); -forall(dtype T) +forall(T &) void copy(ThreadCancelled(T) * dst, ThreadCancelled(T) * src); -forall(dtype T) +forall(T &) const char * msg(ThreadCancelled(T) *); @@ -47,8 +47,8 @@ // Inline getters for threads/coroutines/monitors -forall( dtype T | is_thread(T) ) +forall( T & | is_thread(T) ) static inline $coroutine* get_coroutine(T & this) __attribute__((const)) { return &get_thread(this)->self_cor; } -forall( dtype T | is_thread(T) ) +forall( T & | is_thread(T) ) static inline $monitor * get_monitor (T & this) __attribute__((const)) { return &get_thread(this)->self_mon; } @@ -60,5 +60,5 @@ extern struct cluster * mainCluster; -forall( dtype T | is_thread(T) ) +forall( T & | is_thread(T) ) void __thrd_start( T & this, void (*)(T &) ); @@ -82,5 +82,5 @@ }; -forall( dtype T | is_thread(T) | IS_EXCEPTION(ThreadCancelled, (T)) ) +forall( T & | is_thread(T) | IS_EXCEPTION(ThreadCancelled, (T)) ) void ?{}( thread_dtor_guard_t & this, T & thrd, void(*)(ThreadCancelled(T) &) ); void ^?{}( thread_dtor_guard_t & this ); @@ -89,16 +89,16 @@ // thread runner // Structure that actually start and stop threads -forall( dtype T | sized(T) | is_thread(T) ) +forall( T & | sized(T) | is_thread(T) ) struct scoped { T handle; }; -forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T&); } ) +forall( T & | sized(T) | is_thread(T) | { void ?{}(T&); } ) void ?{}( scoped(T)& this ); -forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T&, P); } ) +forall( T &, P... | sized(T) | is_thread(T) | { void ?{}(T&, P); } ) void ?{}( scoped(T)& this, P params ); -forall( dtype T | sized(T) | is_thread(T) ) +forall( T & | sized(T) | is_thread(T) ) void ^?{}( scoped(T)& this ); @@ -115,5 +115,5 @@ void unpark( $thread * this ); -forall( dtype T | is_thread(T) ) +forall( T & | is_thread(T) ) static inline void unpark( T & this ) { if(!&this) return; unpark( get_thread( this ) );} @@ -128,5 +128,5 @@ //---------- // join -forall( dtype T | is_thread(T) | IS_RESUMPTION_EXCEPTION(ThreadCancelled, (T)) ) +forall( T & | is_thread(T) | IS_RESUMPTION_EXCEPTION(ThreadCancelled, (T)) ) T & join( T & this ); Index: libcfa/src/containers/list.hfa =================================================================== --- libcfa/src/containers/list.hfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/containers/list.hfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -66,5 +66,5 @@ #define __DLISTED_MGD_JUSTIMPL(STRUCT) -forall( dtype tE ) { +forall( tE & ) { struct $mgd_link { tE *elem; @@ -83,5 +83,5 @@ (this.is_terminator){ 1 }; } - forall ( otype tInit | { void ?{}( $mgd_link(tE) &, tInit); } ) + forall ( tInit | { void ?{}( $mgd_link(tE) &, tInit); } ) static inline void ?=?( $mgd_link(tE) &this, tInit i ) { ^?{}( this ); @@ -115,5 +115,5 @@ __DLISTED_MGD_COMMON(STRUCT, STRUCT, $links) -trait $dlistable(dtype Tnode, dtype Telem) { +trait $dlistable(Tnode &, Telem &) { $mgd_link(Telem) & $prev_link(Tnode &); $mgd_link(Telem) & $next_link(Tnode &); @@ -125,5 +125,5 @@ }; -forall (dtype Tnode, dtype Telem | $dlistable(Tnode, Telem)) { +forall (Tnode &, Telem & | $dlistable(Tnode, Telem)) { // implemented as a sentinel item in an underlying cicrular list Index: libcfa/src/containers/maybe.cfa =================================================================== --- libcfa/src/containers/maybe.cfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/containers/maybe.cfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -18,10 +18,10 @@ -forall(otype T) +forall(T) void ?{}(maybe(T) & this) { this.has_value = false; } -forall(otype T) +forall(T) void ?{}(maybe(T) & this, T value) { this.has_value = true; @@ -29,5 +29,5 @@ } -forall(otype T) +forall(T) void ?{}(maybe(T) & this, maybe(T) other) { this.has_value = other.has_value; @@ -37,5 +37,5 @@ } -forall(otype T) +forall(T) maybe(T) ?=?(maybe(T) & this, maybe(T) that) { if (this.has_value && that.has_value) { @@ -51,5 +51,5 @@ } -forall(otype T) +forall(T) void ^?{}(maybe(T) & this) { if (this.has_value) { @@ -58,25 +58,25 @@ } -forall(otype T) +forall(T) bool ?!=?(maybe(T) this, zero_t) { return this.has_value; } -forall(otype T) +forall(T) maybe(T) maybe_value(T value) { return (maybe(T)){value}; } -forall(otype T) +forall(T) maybe(T) maybe_none() { return (maybe(T)){}; } -forall(otype T) +forall(T) bool has_value(maybe(T) * this) { return this->has_value; } -forall(otype T) +forall(T) T get(maybe(T) * this) { assertf(this->has_value, "attempt to get from maybe without value"); @@ -84,5 +84,5 @@ } -forall(otype T) +forall(T) void set(maybe(T) * this, T value) { if (this->has_value) { @@ -94,5 +94,5 @@ } -forall(otype T) +forall(T) void set_none(maybe(T) * this) { if (this->has_value) { Index: libcfa/src/containers/maybe.hfa =================================================================== --- libcfa/src/containers/maybe.hfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/containers/maybe.hfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -19,5 +19,5 @@ // DO NOT USE DIRECTLY! -forall(otype T) +forall(T) struct maybe { bool has_value; @@ -26,40 +26,40 @@ -forall(otype T) +forall(T) void ?{}(maybe(T) & this); -forall(otype T) +forall(T) void ?{}(maybe(T) & this, T value); -forall(otype T) +forall(T) void ?{}(maybe(T) & this, maybe(T) other); -forall(otype T) +forall(T) void ^?{}(maybe(T) & this); -forall(otype T) +forall(T) maybe(T) ?=?(maybe(T) & this, maybe(T) other); -forall(otype T) +forall(T) bool ?!=?(maybe(T) this, zero_t); /* Waiting for bug#11 to be fixed. -forall(otype T) +forall(T) maybe(T) maybe_value(T value); -forall(otype T) +forall(T) maybe(T) maybe_none(); */ -forall(otype T) +forall(T) bool has_value(maybe(T) * this); -forall(otype T) +forall(T) T get(maybe(T) * this); -forall(otype T) +forall(T) void set(maybe(T) * this, T value); -forall(otype T) +forall(T) void set_none(maybe(T) * this); Index: libcfa/src/containers/pair.cfa =================================================================== --- libcfa/src/containers/pair.cfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/containers/pair.cfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -13,5 +13,5 @@ #include -forall(otype R, otype S +forall(R, S | { int ?==?(R, R); int ??(R, R); int ?>?(S, S); }) int ?>?(pair(R, S) p, pair(R, S) q) { @@ -41,5 +41,5 @@ } -forall(otype R, otype S +forall(R, S | { int ?==?(R, R); int ?>?(R, R); int ?>=?(S, S); }) int ?>=?(pair(R, S) p, pair(R, S) q) { Index: libcfa/src/containers/pair.hfa =================================================================== --- libcfa/src/containers/pair.hfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/containers/pair.hfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -16,28 +16,28 @@ #pragma once -forall(otype R, otype S) struct pair { +forall(R, S) struct pair { R first; S second; }; -forall(otype R, otype S +forall(R, S | { int ?==?(R, R); int ??(R, R); int ?>?(S, S); }) int ?>?(pair(R, S) p, pair(R, S) q); -forall(otype R, otype S +forall(R, S | { int ?==?(R, R); int ?>?(R, R); int ?>=?(S, S); }) int ?>=?(pair(R, S) p, pair(R, S) q); Index: libcfa/src/containers/result.cfa =================================================================== --- libcfa/src/containers/result.cfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/containers/result.cfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -18,5 +18,5 @@ -forall(otype T, otype E) +forall(T, E) void ?{}(result(T, E) & this) { this.has_value = false; @@ -24,5 +24,5 @@ } -forall(otype T, otype E) +forall(T, E) void ?{}(result(T, E) & this, one_t, T value) { this.has_value = true; @@ -30,5 +30,5 @@ } -forall(otype T, otype E) +forall(T, E) void ?{}(result(T, E) & this, zero_t, E error) { this.has_value = false; @@ -36,5 +36,5 @@ } -forall(otype T, otype E) +forall(T, E) void ?{}(result(T, E) & this, result(T, E) other) { this.has_value = other.has_value; @@ -46,5 +46,5 @@ } -forall(otype T, otype E) +forall(T, E) result(T, E) ?=?(result(T, E) & this, result(T, E) that) { if (this.has_value && that.has_value) { @@ -63,5 +63,5 @@ } -forall(otype T, otype E) +forall(T, E) void ^?{}(result(T, E) & this) { if (this.has_value) { @@ -72,25 +72,25 @@ } -forall(otype T, otype E) +forall(T, E) bool ?!=?(result(T, E) this, zero_t) { return this.has_value; } -forall(otype T, otype E) +forall(T, E) result(T, E) result_value(T value) { return (result(T, E)){1, value}; } -forall(otype T, otype E) +forall(T, E) result(T, E) result_error(E error) { return (result(T, E)){0, error}; } -forall(otype T, otype E) +forall(T, E) bool has_value(result(T, E) * this) { return this->has_value; } -forall(otype T, otype E) +forall(T, E) T get(result(T, E) * this) { assertf(this->has_value, "attempt to get from result without value"); @@ -98,5 +98,5 @@ } -forall(otype T, otype E) +forall(T, E) E get_error(result(T, E) * this) { assertf(!this->has_value, "attempt to get from result without error"); @@ -104,5 +104,5 @@ } -forall(otype T, otype E) +forall(T, E) void set(result(T, E) * this, T value) { if (this->has_value) { @@ -115,5 +115,5 @@ } -forall(otype T, otype E) +forall(T, E) void set_error(result(T, E) * this, E error) { if (this->has_value) { Index: libcfa/src/containers/result.hfa =================================================================== --- libcfa/src/containers/result.hfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/containers/result.hfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -19,5 +19,5 @@ // DO NOT USE DIRECTLY! -forall(otype T, otype E) +forall(T, E) union inner_result{ T value; @@ -25,5 +25,5 @@ }; -forall(otype T, otype E) +forall(T, E) struct result { bool has_value; @@ -32,46 +32,46 @@ -forall(otype T, otype E) +forall(T, E) void ?{}(result(T, E) & this); -forall(otype T, otype E) +forall(T, E) void ?{}(result(T, E) & this, one_t, T value); -forall(otype T, otype E) +forall(T, E) void ?{}(result(T, E) & this, zero_t, E error); -forall(otype T, otype E) +forall(T, E) void ?{}(result(T, E) & this, result(T, E) other); -forall(otype T, otype E) +forall(T, E) void ^?{}(result(T, E) & this); -forall(otype T, otype E) +forall(T, E) result(T, E) ?=?(result(T, E) & this, result(T, E) other); -forall(otype T, otype E) +forall(T, E) bool ?!=?(result(T, E) this, zero_t); /* Wating for bug#11 to be fixed. -forall(otype T, otype E) +forall(T, E) result(T, E) result_value(T value); -forall(otype T, otype E) +forall(T, E) result(T, E) result_error(E error); */ -forall(otype T, otype E) +forall(T, E) bool has_value(result(T, E) * this); -forall(otype T, otype E) +forall(T, E) T get(result(T, E) * this); -forall(otype T, otype E) +forall(T, E) E get_error(result(T, E) * this); -forall(otype T, otype E) +forall(T, E) void set(result(T, E) * this, T value); -forall(otype T, otype E) +forall(T, E) void set_error(result(T, E) * this, E error); Index: libcfa/src/containers/stackLockFree.hfa =================================================================== --- libcfa/src/containers/stackLockFree.hfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/containers/stackLockFree.hfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -17,5 +17,5 @@ #include -forall( dtype T ) +forall( T & ) union Link { struct { // 32/64-bit x 2 @@ -31,5 +31,5 @@ }; // Link -forall( otype T | sized(T) | { Link(T) * ?`next( T * ); } ) { +forall( T | sized(T) | { Link(T) * ?`next( T * ); } ) { struct StackLF { Link(T) stack; Index: libcfa/src/containers/vector.cfa =================================================================== --- libcfa/src/containers/vector.cfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/containers/vector.cfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -18,10 +18,10 @@ #include -forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +forall(T, 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)) +forall(T, allocator_t | allocator_c(T, allocator_t)) void ?{}(vector(T, allocator_t)& this) { @@ -30,5 +30,5 @@ } -forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +forall(T, allocator_t | allocator_c(T, allocator_t)) void ?{}(vector(T, allocator_t)& this, vector(T, allocator_t) rhs) { @@ -37,5 +37,5 @@ } -// forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +// forall(T, allocator_t | allocator_c(T, allocator_t)) // vector(T, allocator_t) ?=?(vector(T, allocator_t)* this, vector(T, allocator_t) rhs) // { @@ -45,5 +45,5 @@ // } -forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +forall(T, allocator_t | allocator_c(T, allocator_t)) void ^?{}(vector(T, allocator_t)& this) { @@ -54,5 +54,5 @@ //------------------------------------------------------------------------------ //Modifiers -forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +forall(T, allocator_t | allocator_c(T, allocator_t)) void push_back(vector(T, allocator_t)* this, T value) { @@ -62,5 +62,5 @@ } -forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +forall(T, allocator_t | allocator_c(T, allocator_t)) void pop_back(vector(T, allocator_t)* this) { @@ -69,5 +69,5 @@ } -forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +forall(T, allocator_t | allocator_c(T, allocator_t)) void clear(vector(T, allocator_t)* this) { @@ -82,5 +82,5 @@ //Internal Helpers -forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +forall(T, allocator_t | allocator_c(T, allocator_t)) void copy_internal(vector(T, allocator_t)* this, vector(T, allocator_t)* other) { @@ -93,5 +93,5 @@ //------------------------------------------------------------------------------ //Allocator -forall(otype T) +forall(T) void ?{}(heap_allocator(T)& this) { @@ -100,5 +100,5 @@ } -forall(otype T) +forall(T) void ?{}(heap_allocator(T)& this, heap_allocator(T) rhs) { @@ -107,5 +107,5 @@ } -forall(otype T) +forall(T) heap_allocator(T) ?=?(heap_allocator(T)& this, heap_allocator(T) rhs) { @@ -115,5 +115,5 @@ } -forall(otype T) +forall(T) void ^?{}(heap_allocator(T)& this) { @@ -121,5 +121,5 @@ } -forall(otype T) +forall(T) inline void realloc_storage(heap_allocator(T)* this, size_t size) { Index: libcfa/src/containers/vector.hfa =================================================================== --- libcfa/src/containers/vector.hfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/containers/vector.hfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -20,5 +20,5 @@ //------------------------------------------------------------------------------ //Allocator -forall(otype T) +forall(T) struct heap_allocator { @@ -27,20 +27,20 @@ }; -forall(otype T) +forall(T) void ?{}(heap_allocator(T)& this); -forall(otype T) +forall(T) void ?{}(heap_allocator(T)& this, heap_allocator(T) rhs); -forall(otype T) +forall(T) heap_allocator(T) ?=?(heap_allocator(T)& this, heap_allocator(T) rhs); -forall(otype T) +forall(T) void ^?{}(heap_allocator(T)& this); -forall(otype T) +forall(T) void realloc_storage(heap_allocator(T)* this, size_t size); -forall(otype T) +forall(T) static inline T* data(heap_allocator(T)* this) { @@ -50,5 +50,5 @@ //------------------------------------------------------------------------------ //Declaration -trait allocator_c(otype T, otype allocator_t) +trait allocator_c(T, allocator_t) { void realloc_storage(allocator_t*, size_t); @@ -56,22 +56,22 @@ }; -forall(otype T, otype allocator_t = heap_allocator(T) | allocator_c(T, allocator_t)) +forall(T, allocator_t = heap_allocator(T) | allocator_c(T, allocator_t)) struct vector; //------------------------------------------------------------------------------ //Initialization -forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +forall(T, allocator_t | allocator_c(T, allocator_t)) void ?{}(vector(T, allocator_t)& this); -forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +forall(T, 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)) +forall(T, 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)) +forall(T, 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)) +forall(T, allocator_t = heap_allocator(T) | allocator_c(T, allocator_t)) struct vector { @@ -82,5 +82,5 @@ //------------------------------------------------------------------------------ //Capacity -forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +forall(T, allocator_t | allocator_c(T, allocator_t)) static inline bool empty(vector(T, allocator_t)* this) { @@ -88,5 +88,5 @@ } -forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +forall(T, allocator_t | allocator_c(T, allocator_t)) static inline size_t size(vector(T, allocator_t)* this) { @@ -94,5 +94,5 @@ } -forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +forall(T, allocator_t | allocator_c(T, allocator_t)) static inline void reserve(vector(T, allocator_t)* this, size_t size) { @@ -102,5 +102,5 @@ //------------------------------------------------------------------------------ //Element access -forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +forall(T, allocator_t | allocator_c(T, allocator_t)) static inline T at(vector(T, allocator_t)* this, size_t index) { @@ -108,5 +108,5 @@ } -forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +forall(T, allocator_t | allocator_c(T, allocator_t)) static inline T ?[?](vector(T, allocator_t)* this, size_t index) { @@ -114,5 +114,5 @@ } -forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +forall(T, allocator_t | allocator_c(T, allocator_t)) static inline T front(vector(T, allocator_t)* this) { @@ -120,5 +120,5 @@ } -forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +forall(T, allocator_t | allocator_c(T, allocator_t)) static inline T back(vector(T, allocator_t)* this) { @@ -128,16 +128,16 @@ //------------------------------------------------------------------------------ //Modifiers -forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +forall(T, 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)) +forall(T, 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)) +forall(T, 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)) +forall(T, allocator_t | allocator_c(T, allocator_t)) static inline T* begin(vector(T, allocator_t)* this) { @@ -145,5 +145,5 @@ } -// forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +// forall(T, allocator_t | allocator_c(T, allocator_t)) // static inline const T* cbegin(const vector(T, allocator_t)* this) // { @@ -151,5 +151,5 @@ // } -forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +forall(T, allocator_t | allocator_c(T, allocator_t)) static inline T* end(vector(T, allocator_t)* this) { @@ -157,5 +157,5 @@ } -// forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +// forall(T, allocator_t | allocator_c(T, allocator_t)) // static inline const T* cend(const vector(T, allocator_t)* this) // { Index: libcfa/src/exception.h =================================================================== --- libcfa/src/exception.h (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/exception.h (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -101,5 +101,5 @@ // implemented in the .c file either so they all have to be inline. -trait is_exception(dtype exceptT, dtype virtualT) { +trait is_exception(exceptT &, virtualT &) { /* The first field must be a pointer to a virtual table. * That virtual table must be a decendent of the base exception virtual table. @@ -109,13 +109,13 @@ }; -trait is_termination_exception(dtype exceptT, dtype virtualT | is_exception(exceptT, virtualT)) { +trait is_termination_exception(exceptT &, virtualT & | is_exception(exceptT, virtualT)) { void defaultTerminationHandler(exceptT &); }; -trait is_resumption_exception(dtype exceptT, dtype virtualT | is_exception(exceptT, virtualT)) { +trait is_resumption_exception(exceptT &, virtualT & | is_exception(exceptT, virtualT)) { void defaultResumptionHandler(exceptT &); }; -forall(dtype exceptT, dtype virtualT | is_termination_exception(exceptT, virtualT)) +forall(exceptT &, virtualT & | is_termination_exception(exceptT, virtualT)) static inline void $throw(exceptT & except) { __cfaehm_throw_terminate( @@ -125,5 +125,5 @@ } -forall(dtype exceptT, dtype virtualT | is_resumption_exception(exceptT, virtualT)) +forall(exceptT &, virtualT & | is_resumption_exception(exceptT, virtualT)) static inline void $throwResume(exceptT & except) { __cfaehm_throw_resume( @@ -133,15 +133,15 @@ } -forall(dtype exceptT, dtype virtualT | is_exception(exceptT, virtualT)) +forall(exceptT &, virtualT & | is_exception(exceptT, virtualT)) static inline void cancel_stack(exceptT & except) __attribute__((noreturn)) { __cfaehm_cancel_stack( (exception_t *)&except ); } -forall(dtype exceptT, dtype virtualT | is_exception(exceptT, virtualT)) +forall(exceptT &, virtualT & | is_exception(exceptT, virtualT)) static inline void defaultTerminationHandler(exceptT & except) { return cancel_stack( except ); } -forall(dtype exceptT, dtype virtualT | is_exception(exceptT, virtualT)) +forall(exceptT &, virtualT & | is_exception(exceptT, virtualT)) static inline void defaultResumptionHandler(exceptT & except) { throw except; Index: libcfa/src/executor.cfa =================================================================== --- libcfa/src/executor.cfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/executor.cfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -7,5 +7,5 @@ #include -forall( dtype T | $dlistable(T, T) ) { +forall( T & | $dlistable(T, T) ) { monitor Buffer { // unbounded buffer dlist( T, T ) queue; // unbounded list of work requests Index: libcfa/src/gmp.hfa =================================================================== --- libcfa/src/gmp.hfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/gmp.hfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -255,5 +255,5 @@ // I/O - forall( dtype istype | istream( istype ) ) + forall( istype & | istream( istype ) ) istype & ?|?( istype & is, Int & mp ) { gmp_scanf( "%Zd", &mp ); @@ -261,5 +261,5 @@ } // ?|? - forall( dtype ostype | ostream( ostype ) ) { + forall( ostype & | ostream( ostype ) ) { ostype & ?|?( ostype & os, Int mp ) { if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); Index: libcfa/src/iostream.cfa =================================================================== --- libcfa/src/iostream.cfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/iostream.cfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -36,5 +36,5 @@ -forall( dtype ostype | ostream( ostype ) ) { +forall( ostype & | ostream( ostype ) ) { ostype & ?|?( ostype & os, bool b ) { if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); @@ -402,5 +402,5 @@ // tuples -forall( dtype ostype, otype T, ttype Params | writeable( T, ostype ) | { ostype & ?|?( ostype &, Params ); } ) { +forall( ostype &, T, Params... | writeable( T, ostype ) | { ostype & ?|?( ostype &, Params ); } ) { ostype & ?|?( ostype & os, T arg, Params rest ) { (ostype &)(os | arg); // print first argument @@ -421,5 +421,5 @@ // writes the range [begin, end) to the given stream -forall( dtype ostype, otype elt_type | writeable( elt_type, ostype ), otype iterator_type | iterator( iterator_type, elt_type ) ) { +forall( ostype &, elt_type | writeable( elt_type, ostype ), iterator_type | iterator( iterator_type, elt_type ) ) { void write( iterator_type begin, iterator_type end, ostype & os ) { void print( elt_type i ) { os | i; } @@ -442,5 +442,5 @@ // Default prefix for non-decimal prints is 0b, 0, 0x. #define IntegralFMTImpl( T, IFMTNP, IFMTP ) \ -forall( dtype ostype | ostream( ostype ) ) { \ +forall( ostype & | ostream( ostype ) ) { \ ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \ if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); \ @@ -535,5 +535,5 @@ // Default prefix for non-decimal prints is 0b, 0, 0x. #define IntegralFMTImpl128( T, SIGNED, CODE, IFMTNP, IFMTP ) \ -forall( dtype ostype | ostream( ostype ) ) \ +forall( ostype & | ostream( ostype ) ) \ static void base10_128( ostype & os, _Ostream_Manip(T) f ) { \ if ( f.val > UINT64_MAX ) { \ @@ -552,5 +552,5 @@ } /* if */ \ } /* base10_128 */ \ -forall( dtype ostype | ostream( ostype ) ) { \ +forall( ostype & | ostream( ostype ) ) { \ ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \ if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); \ @@ -654,5 +654,5 @@ #if defined( __SIZEOF_INT128__ ) // Default prefix for non-decimal prints is 0b, 0, 0x. -forall( dtype ostype | ostream( ostype ) ) +forall( ostype & | ostream( ostype ) ) static inline void base_128( ostype & os, unsigned int128 val, unsigned int128 power, _Ostream_Manip(uint64_t) & f, unsigned int maxdig, unsigned int bits, unsigned int cnt = 0 ) { int wd = 1; // f.wd is never 0 because 0 implies left-pad @@ -719,5 +719,5 @@ #define IntegralFMTImpl128( T ) \ -forall( dtype ostype | ostream( ostype ) ) { \ +forall( ostype & | ostream( ostype ) ) { \ ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \ _Ostream_Manip(uint64_t) fmt; \ @@ -767,5 +767,5 @@ #define FloatingPointFMTImpl( T, DFMTNP, DFMTP ) \ -forall( dtype ostype | ostream( ostype ) ) { \ +forall( ostype & | ostream( ostype ) ) { \ ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \ if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); \ @@ -801,5 +801,5 @@ // *********************************** character *********************************** -forall( dtype ostype | ostream( ostype ) ) { +forall( ostype & | ostream( ostype ) ) { ostype & ?|?( ostype & os, _Ostream_Manip(char) f ) { if ( f.base != 'c' ) { // bespoke binary/octal/hex format @@ -834,5 +834,5 @@ // *********************************** C string *********************************** -forall( dtype ostype | ostream( ostype ) ) { +forall( ostype & | ostream( ostype ) ) { ostype & ?|?( ostype & os, _Ostream_Manip(const char *) f ) { if ( ! f.val ) return os; // null pointer ? @@ -882,5 +882,5 @@ -forall( dtype istype | istream( istype ) ) { +forall( istype & | istream( istype ) ) { istype & ?|?( istype & is, bool & b ) { char val[6]; @@ -1048,5 +1048,5 @@ // *********************************** manipulators *********************************** -forall( dtype istype | istream( istype ) ) +forall( istype & | istream( istype ) ) istype & ?|?( istype & is, _Istream_Cstr f ) { // skip xxx @@ -1083,5 +1083,5 @@ } // ?|? -forall( dtype istype | istream( istype ) ) +forall( istype & | istream( istype ) ) istype & ?|?( istype & is, _Istream_Char f ) { fmt( is, "%*c" ); // argument variable unused @@ -1090,5 +1090,5 @@ #define InputFMTImpl( T, CODE ) \ -forall( dtype istype | istream( istype ) ) \ +forall( istype & | istream( istype ) ) \ istype & ?|?( istype & is, _Istream_Manip(T) f ) { \ enum { size = 16 }; \ @@ -1119,5 +1119,5 @@ InputFMTImpl( long double, "Lf" ) -forall( dtype istype | istream( istype ) ) +forall( istype & | istream( istype ) ) istype & ?|?( istype & is, _Istream_Manip(float _Complex) fc ) { float re, im; @@ -1130,5 +1130,5 @@ } // ?|? -forall( dtype istype | istream( istype ) ) +forall( istype & | istream( istype ) ) istype & ?|?( istype & is, _Istream_Manip(double _Complex) dc ) { double re, im; @@ -1141,5 +1141,5 @@ } // ?|? -forall( dtype istype | istream( istype ) ) +forall( istype & | istream( istype ) ) istype & ?|?( istype & is, _Istream_Manip(long double _Complex) ldc ) { long double re, im; Index: libcfa/src/iostream.hfa =================================================================== --- libcfa/src/iostream.hfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/iostream.hfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -22,5 +22,5 @@ -trait ostream( dtype ostype ) { +trait ostream( ostype & ) { // private bool $sepPrt( ostype & ); // get separator state (on/off) @@ -56,9 +56,9 @@ }; // ostream -// trait writeable( otype T ) { -// forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, T ); +// trait writeable( T ) { +// forall( ostype & | ostream( ostype ) ) ostype & ?|?( ostype &, T ); // }; // writeable -trait writeable( otype T, dtype ostype | ostream( ostype ) ) { +trait writeable( T, ostype & | ostream( ostype ) ) { ostype & ?|?( ostype &, T ); }; // writeable @@ -66,5 +66,5 @@ // implement writable for intrinsic types -forall( dtype ostype | ostream( ostype ) ) { +forall( ostype & | ostream( ostype ) ) { ostype & ?|?( ostype &, bool ); void ?|?( ostype &, bool ); @@ -140,5 +140,5 @@ // tuples -forall( dtype ostype, otype T, ttype Params | writeable( T, ostype ) | { ostype & ?|?( ostype &, Params ); } ) { +forall( ostype &, T, Params... | writeable( T, ostype ) | { ostype & ?|?( ostype &, Params ); } ) { ostype & ?|?( ostype & os, T arg, Params rest ); void ?|?( ostype & os, T arg, Params rest ); @@ -146,5 +146,5 @@ // writes the range [begin, end) to the given stream -forall( dtype ostype, otype elt_type | writeable( elt_type, ostype ), otype iterator_type | iterator( iterator_type, elt_type ) ) { +forall( ostype &, elt_type | writeable( elt_type, ostype ), iterator_type | iterator( iterator_type, elt_type ) ) { void write( iterator_type begin, iterator_type end, ostype & os ); void write_reverse( iterator_type begin, iterator_type end, ostype & os ); @@ -153,5 +153,5 @@ // *********************************** manipulators *********************************** -forall( otype T ) +forall( T ) struct _Ostream_Manip { T val; // polymorphic base-type @@ -193,5 +193,5 @@ _Ostream_Manip(T) & sign( _Ostream_Manip(T) & fmt ) { fmt.flags.sign = true; return fmt; } \ } /* distribution */ \ -forall( dtype ostype | ostream( ostype ) ) { \ +forall( ostype & | ostream( ostype ) ) { \ ostype & ?|?( ostype & os, _Ostream_Manip(T) f ); \ void ?|?( ostype & os, _Ostream_Manip(T) f ); \ @@ -234,5 +234,5 @@ _Ostream_Manip(T) & nodp( _Ostream_Manip(T) & fmt ) { fmt.flags.nobsdp = true; return fmt; } \ } /* distribution */ \ -forall( dtype ostype | ostream( ostype ) ) { \ +forall( ostype & | ostream( ostype ) ) { \ ostype & ?|?( ostype & os, _Ostream_Manip(T) f ); \ void ?|?( ostype & os, _Ostream_Manip(T) f ); \ @@ -254,5 +254,5 @@ _Ostream_Manip(char) & nobase( _Ostream_Manip(char) & fmt ) { fmt.flags.nobsdp = true; return fmt; } } // distribution -forall( dtype ostype | ostream( ostype ) ) { +forall( ostype & | ostream( ostype ) ) { ostype & ?|?( ostype & os, _Ostream_Manip(char) f ); void ?|?( ostype & os, _Ostream_Manip(char) f ); @@ -272,5 +272,5 @@ _Ostream_Manip(const char *) & nobase( _Ostream_Manip(const char *) & fmt ) { fmt.flags.nobsdp = true; return fmt; } } // distribution -forall( dtype ostype | ostream( ostype ) ) { +forall( ostype & | ostream( ostype ) ) { ostype & ?|?( ostype & os, _Ostream_Manip(const char *) f ); void ?|?( ostype & os, _Ostream_Manip(const char *) f ); @@ -281,5 +281,5 @@ -trait istream( dtype istype ) { +trait istream( istype & ) { void nlOn( istype & ); // read newline void nlOff( istype & ); // scan newline @@ -294,9 +294,9 @@ }; // istream -trait readable( otype T ) { - forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, T ); +trait readable( T ) { + forall( istype & | istream( istype ) ) istype & ?|?( istype &, T ); }; // readable -forall( dtype istype | istream( istype ) ) { +forall( istype & | istream( istype ) ) { istype & ?|?( istype &, bool & ); @@ -363,5 +363,5 @@ _Istream_Cstr & wdi( unsigned int w, _Istream_Cstr & fmt ) { fmt.wd = w; return fmt; } } // distribution -forall( dtype istype | istream( istype ) ) istype & ?|?( istype & is, _Istream_Cstr f ); +forall( istype & | istream( istype ) ) istype & ?|?( istype & is, _Istream_Cstr f ); struct _Istream_Char { @@ -373,7 +373,7 @@ _Istream_Char & ignore( _Istream_Char & fmt ) { fmt.ignore = true; return fmt; } } // distribution -forall( dtype istype | istream( istype ) ) istype & ?|?( istype & is, _Istream_Char f ); - -forall( dtype T | sized( T ) ) +forall( istype & | istream( istype ) ) istype & ?|?( istype & is, _Istream_Char f ); + +forall( T & | sized( T ) ) struct _Istream_Manip { T & val; // polymorphic base-type @@ -389,5 +389,5 @@ _Istream_Manip(T) & wdi( unsigned int w, _Istream_Manip(T) & fmt ) { fmt.wd = w; return fmt; } \ } /* distribution */ \ -forall( dtype istype | istream( istype ) ) { \ +forall( istype & | istream( istype ) ) { \ istype & ?|?( istype & is, _Istream_Manip(T) f ); \ } // ?|? @@ -418,5 +418,5 @@ #include // Duration (constructors) / Time (constructors) -forall( dtype ostype | ostream( ostype ) ) { +forall( ostype & | ostream( ostype ) ) { ostype & ?|?( ostype & os, Duration dur ); void ?|?( ostype & os, Duration dur ); Index: libcfa/src/iterator.cfa =================================================================== --- libcfa/src/iterator.cfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/iterator.cfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -16,5 +16,5 @@ #include "iterator.hfa" -forall( otype iterator_type, otype elt_type | iterator( iterator_type, elt_type ) ) +forall( iterator_type, elt_type | iterator( iterator_type, elt_type ) ) void for_each( iterator_type begin, iterator_type end, void (* func)( elt_type ) ) { for ( iterator_type i = begin; i != end; ++i ) { @@ -23,5 +23,5 @@ } // for_each -forall( otype iterator_type, otype elt_type | iterator( iterator_type, elt_type ) ) +forall( iterator_type, elt_type | iterator( iterator_type, elt_type ) ) void for_each_reverse( iterator_type begin, iterator_type end, void (* func)( elt_type ) ) { for ( iterator_type i = end; i != begin; ) { Index: libcfa/src/iterator.hfa =================================================================== --- libcfa/src/iterator.hfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/iterator.hfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -17,5 +17,5 @@ // An iterator can be used to traverse a data structure. -trait iterator( otype iterator_type, otype elt_type ) { +trait iterator( iterator_type, elt_type ) { // point to the next element // iterator_type ?++( iterator_type & ); @@ -31,5 +31,5 @@ }; -trait iterator_for( otype iterator_type, otype collection_type, otype elt_type | iterator( iterator_type, elt_type ) ) { +trait iterator_for( iterator_type, collection_type, elt_type | iterator( iterator_type, elt_type ) ) { // [ iterator_type begin, iterator_type end ] get_iterators( collection_type ); iterator_type begin( collection_type ); @@ -37,8 +37,8 @@ }; -forall( otype iterator_type, otype elt_type | iterator( iterator_type, elt_type ) ) +forall( iterator_type, elt_type | iterator( iterator_type, elt_type ) ) void for_each( iterator_type begin, iterator_type end, void (* func)( elt_type ) ); -forall( otype iterator_type, otype elt_type | iterator( iterator_type, elt_type ) ) +forall( iterator_type, elt_type | iterator( iterator_type, elt_type ) ) void for_each_reverse( iterator_type begin, iterator_type end, void (* func)( elt_type ) ); Index: libcfa/src/math.hfa =================================================================== --- libcfa/src/math.hfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/math.hfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -286,5 +286,5 @@ unsigned long long int floor( unsigned long long int n, unsigned long long int align ) { return n / align * align; } - // forall( otype T | { T ?/?( T, T ); T ?*?( T, T ); } ) + // forall( T | { T ?/?( T, T ); T ?*?( T, T ); } ) // T floor( T n, T align ) { return n / align * align; } @@ -300,5 +300,5 @@ unsigned long long int ceiling_div( unsigned long long int n, unsigned long long int align ) { return (n + (align - 1)) / align; } - // forall( otype T | { T ?+?( T, T ); T ?-?( T, T ); T ?%?( T, T ); } ) + // forall( T | { T ?+?( T, T ); T ?-?( T, T ); T ?%?( T, T ); } ) // T ceiling_div( T n, T align ) { verify( is_pow2( align ) );return (n + (align - 1)) / align; } @@ -315,5 +315,5 @@ unsigned long long int ceiling( unsigned long long int n, unsigned long long int align ) { return floor( n + (n % align != 0 ? align - 1 : 0), align ); } - // forall( otype T | { void ?{}( T &, one_t ); T ?+?( T, T ); T ?-?( T, T ); T ?/?( T, T ); } ) + // forall( T | { void ?{}( T &, one_t ); T ?+?( T, T ); T ?-?( T, T ); T ?/?( T, T ); } ) // T ceiling( T n, T align ) { return return floor( n + (n % align != 0 ? align - 1 : 0), align ); *} @@ -414,11 +414,11 @@ static inline { - forall( otype T | { void ?{}( T &, one_t ); T ?+?( T, T ); T ?-?( T, T );T ?*?( T, T ); } ) + forall( T | { void ?{}( T &, one_t ); T ?+?( T, T ); T ?-?( T, T );T ?*?( T, T ); } ) T lerp( T x, T y, T a ) { return x * ((T){1} - a) + y * a; } - forall( otype T | { void ?{}( T &, zero_t ); void ?{}( T &, one_t ); int ?counter) { @@ -48,5 +48,5 @@ } -forall(dtype T | sized(T)) +forall(T & | sized(T)) static void internal_copy(counter_ptr(T) & this, counter_ptr(T) & that) { this.data = that.data; @@ -56,5 +56,5 @@ } -forall(dtype T | sized(T) | { void ^?{}(T &); }) +forall(T & | sized(T) | { void ^?{}(T &); }) void ?{}(counter_ptr(T) & this, counter_ptr(T) that) { // `that` is a copy but it should have neither a constructor @@ -64,20 +64,20 @@ } -forall(dtype T | sized(T), ttype Args | { void ?{}(T&, Args); }) +forall(T & | sized(T), Args... | { void ?{}(T&, Args); }) void ?{}(counter_ptr(T) & this, Args args) { this.data = (counter_data(T)*)new(args); } -forall(dtype T | sized(T) | { void ^?{}(T &); }) +forall(T & | sized(T) | { void ^?{}(T &); }) void ^?{}(counter_ptr(T) & this) { internal_decrement(this); } -forall(dtype T | sized(T)) +forall(T & | sized(T)) T & *?(counter_ptr(T) & this) { return *((this.data) ? &this.data->object : 0p); } -forall(dtype T | sized(T) | { void ^?{}(T &); }) +forall(T & | sized(T) | { void ^?{}(T &); }) void ?=?(counter_ptr(T) & this, counter_ptr(T) that) { if (this.data != that.data) { @@ -87,5 +87,5 @@ } -forall(dtype T | sized(T) | { void ^?{}(T &); }) +forall(T & | sized(T) | { void ^?{}(T &); }) void ?=?(counter_ptr(T) & this, zero_t) { internal_decrement(this); @@ -93,20 +93,20 @@ } -forall(dtype T | sized(T)) +forall(T & | sized(T)) int ?==?(counter_ptr(T) const & this, counter_ptr(T) const & that) { return this.data == that.data; } -forall(dtype T | sized(T)) +forall(T & | sized(T)) int ?!=?(counter_ptr(T) const & this, counter_ptr(T) const & that) { return !?==?(this, that); } -forall(dtype T | sized(T)) +forall(T & | sized(T)) int ?==?(counter_ptr(T) const & this, zero_t) { return this.data == 0; } -forall(dtype T | sized(T)) +forall(T & | sized(T)) int ?!=?(counter_ptr(T) const & this, zero_t) { return !?==?(this, (zero_t)0); @@ -114,30 +114,30 @@ // This is the only pointer that keeps this alive. -forall(dtype T) +forall(T &) void ?{}(unique_ptr(T) & this) { this.data = 0p; } -forall(dtype T) +forall(T &) void ?{}(unique_ptr(T) & this, zero_t) { this.data = 0p; } -forall(dtype T | sized(T), ttype Args | { void ?{}(T &, Args); }) +forall(T & | sized(T), Args... | { void ?{}(T &, Args); }) void ?{}(unique_ptr(T) & this, Args args) { this.data = (T *)new(args); } -forall(dtype T | { void ^?{}(T &); }) +forall(T & | { void ^?{}(T &); }) void ^?{}(unique_ptr(T) & this) { delete(this.data); } -forall(dtype T) +forall(T &) T & *?(unique_ptr(T) & this) { return *this.data; } -forall(dtype T | { void ^?{}(T &); }) +forall(T & | { void ^?{}(T &); }) void ?=?(unique_ptr(T) & this, zero_t) { delete(this.data); @@ -145,5 +145,5 @@ } -forall(dtype T | { void ^?{}(T &); }) +forall(T & | { void ^?{}(T &); }) void move(unique_ptr(T) & this, unique_ptr(T) & that) { delete(this.data); @@ -152,20 +152,20 @@ } -forall(dtype T) +forall(T &) int ?==?(unique_ptr(T) const & this, unique_ptr(T) const & that) { return this.data == that.data; } -forall(dtype T) +forall(T &) int ?!=?(unique_ptr(T) const & this, unique_ptr(T) const & that) { return !?==?(this, that); } -forall(dtype T) +forall(T &) int ?==?(unique_ptr(T) const & this, zero_t) { return this.data == 0; } -forall(dtype T) +forall(T &) int ?!=?(unique_ptr(T) const & this, zero_t) { return !?==?(this, (zero_t)0); Index: libcfa/src/memory.hfa =================================================================== --- libcfa/src/memory.hfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/memory.hfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -17,5 +17,5 @@ // Internal data object. -forall(dtype T | sized(T)) { +forall(T & | sized(T)) { struct counter_data { unsigned int counter; @@ -23,5 +23,5 @@ }; - forall(ttype Args | { void ?{}(T &, Args); }) + forall(Args... | { void ?{}(T &, Args); }) void ?{}(counter_data(T) & this, Args args); @@ -31,5 +31,5 @@ // This is one of many pointers keeping this alive. -forall(dtype T | sized(T)) { +forall(T & | sized(T)) { struct counter_ptr { counter_data(T) * data; @@ -40,5 +40,5 @@ forall( | { void ^?{}(T &); }) void ?{}(counter_ptr(T) & this, counter_ptr(T) that); - forall(ttype Args | { void ?{}(T&, Args); }) + forall(Args... | { void ?{}(T&, Args); }) void ?{}(counter_ptr(T) & this, Args args); @@ -60,5 +60,5 @@ // This is the only pointer that keeps this alive. -forall(dtype T) { +forall(T &) { struct unique_ptr { T * data; @@ -68,5 +68,5 @@ void ?{}(unique_ptr(T) & this, zero_t); void ?{}(unique_ptr(T) & this, unique_ptr(T) that) = void; - forall( | sized(T), ttype Args | { void ?{}(T &, Args); }) + forall( | sized(T), Args... | { void ?{}(T &, Args); }) void ?{}(unique_ptr(T) & this, Args args); Index: libcfa/src/parseargs.hfa =================================================================== --- libcfa/src/parseargs.hfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/parseargs.hfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -14,5 +14,5 @@ static inline void ?{}( cfa_option & this ) {} -forall(dtype T | { bool parse(const char *, T & ); }) +forall(T & | { bool parse(const char *, T & ); }) static inline void ?{}( cfa_option & this, char short_name, const char * long_name, const char * help, T & variable ) { this.val = 0; @@ -24,5 +24,5 @@ } -forall(dtype T) +forall(T &) static inline void ?{}( cfa_option & this, char short_name, const char * long_name, const char * help, T & variable, bool (*parse)(const char *, T & )) { this.val = 0; Index: libcfa/src/rational.cfa =================================================================== --- libcfa/src/rational.cfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/rational.cfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -18,5 +18,5 @@ #include "stdlib.hfa" -forall( otype RationalImpl | arithmetic( RationalImpl ) ) { +forall( RationalImpl | arithmetic( RationalImpl ) ) { // helper routines @@ -159,5 +159,5 @@ // I/O - forall( dtype istype | istream( istype ) | { istype & ?|?( istype &, RationalImpl & ); } ) + forall( istype & | istream( istype ) | { istype & ?|?( istype &, RationalImpl & ); } ) istype & ?|?( istype & is, Rational(RationalImpl) & r ) { is | r.numerator | r.denominator; @@ -168,5 +168,5 @@ } // ?|? - forall( dtype ostype | ostream( ostype ) | { ostype & ?|?( ostype &, RationalImpl ); } ) { + forall( ostype & | ostream( ostype ) | { ostype & ?|?( ostype &, RationalImpl ); } ) { ostype & ?|?( ostype & os, Rational(RationalImpl) r ) { return os | r.numerator | '/' | r.denominator; @@ -179,5 +179,5 @@ } // distribution -forall( otype RationalImpl | arithmetic( RationalImpl ) | { RationalImpl ?\?( RationalImpl, unsigned long ); } ) +forall( RationalImpl | arithmetic( RationalImpl ) | { RationalImpl ?\?( RationalImpl, unsigned long ); } ) Rational(RationalImpl) ?\?( Rational(RationalImpl) x, long int y ) { if ( y < 0 ) { @@ -190,10 +190,10 @@ // conversion -forall( otype RationalImpl | arithmetic( RationalImpl ) | { double convert( RationalImpl ); } ) +forall( RationalImpl | arithmetic( RationalImpl ) | { double convert( RationalImpl ); } ) double widen( Rational(RationalImpl) r ) { return convert( r.numerator ) / convert( r.denominator ); } // widen -forall( otype RationalImpl | arithmetic( RationalImpl ) | { double convert( RationalImpl ); RationalImpl convert( double ); } ) +forall( RationalImpl | arithmetic( RationalImpl ) | { double convert( RationalImpl ); RationalImpl convert( double ); } ) Rational(RationalImpl) narrow( double f, RationalImpl md ) { // http://www.ics.uci.edu/~eppstein/numth/frap.c Index: libcfa/src/rational.hfa =================================================================== --- libcfa/src/rational.hfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/rational.hfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -20,8 +20,8 @@ #include "iostream.hfa" -trait scalar( otype T ) { +trait scalar( T ) { }; -trait arithmetic( otype T | scalar( T ) ) { +trait arithmetic( T | scalar( T ) ) { int !?( T ); int ?==?( T, T ); @@ -46,5 +46,5 @@ // implementation -forall( otype RationalImpl | arithmetic( RationalImpl ) ) { +forall( RationalImpl | arithmetic( RationalImpl ) ) { struct Rational { RationalImpl numerator, denominator; // invariant: denominator > 0 @@ -89,8 +89,8 @@ // I/O - forall( dtype istype | istream( istype ) | { istype & ?|?( istype &, RationalImpl & ); } ) + forall( istype & | istream( istype ) | { istype & ?|?( istype &, RationalImpl & ); } ) istype & ?|?( istype &, Rational(RationalImpl) & ); - forall( dtype ostype | ostream( ostype ) | { ostype & ?|?( ostype &, RationalImpl ); } ) { + forall( ostype & | ostream( ostype ) | { ostype & ?|?( ostype &, RationalImpl ); } ) { ostype & ?|?( ostype &, Rational(RationalImpl) ); void ?|?( ostype &, Rational(RationalImpl) ); @@ -98,11 +98,11 @@ } // distribution -forall( otype RationalImpl | arithmetic( RationalImpl ) |{RationalImpl ?\?( RationalImpl, unsigned long );} ) +forall( RationalImpl | arithmetic( RationalImpl ) |{RationalImpl ?\?( RationalImpl, unsigned long );} ) Rational(RationalImpl) ?\?( Rational(RationalImpl) x, long int y ); // conversion -forall( otype RationalImpl | arithmetic( RationalImpl ) | { double convert( RationalImpl ); } ) +forall( RationalImpl | arithmetic( RationalImpl ) | { double convert( RationalImpl ); } ) double widen( Rational(RationalImpl) r ); -forall( otype RationalImpl | arithmetic( RationalImpl ) | { double convert( RationalImpl ); RationalImpl convert( double );} ) +forall( RationalImpl | arithmetic( RationalImpl ) | { double convert( RationalImpl ); RationalImpl convert( double );} ) Rational(RationalImpl) narrow( double f, RationalImpl md ); Index: libcfa/src/stdlib.cfa =================================================================== --- libcfa/src/stdlib.cfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/stdlib.cfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -28,5 +28,5 @@ // Cforall allocation/deallocation and constructor/destructor, array types -forall( dtype T | sized(T), ttype TT | { void ?{}( T &, TT ); } ) +forall( T & | sized(T), TT... | { void ?{}( T &, TT ); } ) T * anew( size_t dim, TT p ) { T * arr = alloc( dim ); @@ -37,5 +37,5 @@ } // anew -forall( dtype T | sized(T) | { void ^?{}( T & ); } ) +forall( T & | sized(T) | { void ^?{}( T & ); } ) void adelete( T arr[] ) { if ( arr ) { // ignore null @@ -48,5 +48,5 @@ } // adelete -forall( dtype T | sized(T) | { void ^?{}( T & ); }, ttype TT | { void adelete( TT ); } ) +forall( T & | sized(T) | { void ^?{}( T & ); }, TT... | { void adelete( TT ); } ) void adelete( T arr[], TT rest ) { if ( arr ) { // ignore null @@ -97,5 +97,5 @@ //--------------------------------------- -forall( otype E | { int ? sizeof(ret.t)) { printf("ERROR: const object of size greater than 50 bytes given for dynamic memory fill\n"); exit(1); } + if ( size > sizeof(ret.t) ) { + abort( "ERROR: const object of size greater than 50 bytes given for dynamic memory fill\n" ); + } // if memcpy( &ret.t, &t, size ); return ret; @@ -173,5 +175,5 @@ S_realloc(T) ?`realloc ( T * a ) { return (S_realloc(T)){a}; } - T * $alloc_internal( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill) { + T * $alloc_internal( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill ) { T * ptr = NULL; size_t size = sizeof(T); @@ -181,28 +183,23 @@ ptr = (T*) (void *) resize( (void *)Resize, Align, Dim * size ); } else if ( Realloc ) { - if (Fill.tag != '0') copy_end = min(malloc_size( Realloc ), Dim * size); - ptr = (T*) (void *) realloc( (void *)Realloc, Align, Dim * size ); + if ( Fill.tag != '0' ) copy_end = min(malloc_size( Realloc ), Dim * size ); + ptr = (T *) (void *) realloc( (void *)Realloc, Align, Dim * size ); } else { - ptr = (T*) (void *) memalign( Align, Dim * size ); - } - - if(Fill.tag == 'c') { + ptr = (T *) (void *) memalign( Align, Dim * size ); + } + + if ( Fill.tag == 'c' ) { memset( (char *)ptr + copy_end, (int)Fill.c, Dim * size - copy_end ); - } else if(Fill.tag == 't') { + } else if ( Fill.tag == 't' ) { for ( int i = copy_end; i < Dim * size; i += size ) { -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Warray-bounds" -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wstringop-overflow=" - memcpy( (char *)ptr + i, &Fill.t, size ); -#pragma GCC diagnostic pop -#pragma GCC diagnostic pop + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wmaybe-uninitialized" + memcpy( (char *)ptr + i, &Fill.t, sizeof(Fill.t) ); + #pragma GCC diagnostic pop } - } else if(Fill.tag == 'a') { + } else if ( Fill.tag == 'a' ) { memcpy( (char *)ptr + copy_end, Fill.at, min(Dim * size - copy_end, Fill.size) ); - } else if(Fill.tag == 'T') { - for ( int i = copy_end; i < Dim * size; i += size ) { - memcpy( (char *)ptr + i, Fill.at, size ); - } + } else if ( Fill.tag == 'T' ) { + memcpy( (char *)ptr + copy_end, Fill.at, Dim * size ); } @@ -210,5 +207,5 @@ } // $alloc_internal - forall( ttype TT | { T * $alloc_internal( void *, T *, size_t, size_t, S_fill(T), TT ); } ) { + forall( TT... | { T * $alloc_internal( void *, T *, size_t, size_t, S_fill(T), TT ); } ) { T * $alloc_internal( void * , T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill, T_resize Resize, TT rest) { @@ -239,5 +236,5 @@ } // distribution T -static inline forall( dtype T | sized(T) ) { +static inline forall( T & | sized(T) ) { // CFA safe initialization/copy, i.e., implicit size specification, non-array types T * memset( T * dest, char fill ) { @@ -260,9 +257,9 @@ // CFA deallocation for multiple objects -static inline forall( dtype T ) // FIX ME, problems with 0p in list +static inline forall( T & ) // FIX ME, problems with 0p in list void free( T * ptr ) { free( (void *)ptr ); // C free } // free -static inline forall( dtype T, ttype TT | { void free( TT ); } ) +static inline forall( T &, TT... | { void free( TT ); } ) void free( T * ptr, TT rest ) { free( ptr ); @@ -271,10 +268,10 @@ // CFA allocation/deallocation and constructor/destructor, non-array types -static inline forall( dtype T | sized(T), ttype TT | { void ?{}( T &, TT ); } ) +static inline forall( T & | sized(T), TT... | { void ?{}( T &, TT ); } ) T * new( TT p ) { return &(*(T *)malloc()){ p }; // run constructor } // new -static inline forall( dtype T | { void ^?{}( T & ); } ) +static inline forall( T & | { void ^?{}( T & ); } ) void delete( T * ptr ) { // special case for 0-sized object => always call destructor @@ -284,5 +281,5 @@ free( ptr ); // always call free } // delete -static inline forall( dtype T, ttype TT | { void ^?{}( T & ); void delete( TT ); } ) +static inline forall( T &, TT... | { void ^?{}( T & ); void delete( TT ); } ) void delete( T * ptr, TT rest ) { delete( ptr ); @@ -291,7 +288,7 @@ // CFA allocation/deallocation and constructor/destructor, array types -forall( dtype T | sized(T), ttype TT | { void ?{}( T &, TT ); } ) T * anew( size_t dim, TT p ); -forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void adelete( T arr[] ); -forall( dtype T | sized(T) | { void ^?{}( T & ); }, ttype TT | { void adelete( TT ); } ) void adelete( T arr[], TT rest ); +forall( T & | sized(T), TT... | { void ?{}( T &, TT ); } ) T * anew( size_t dim, TT p ); +forall( T & | sized(T) | { void ^?{}( T & ); } ) void adelete( T arr[] ); +forall( T & | sized(T) | { void ^?{}( T & ); }, TT... | { void adelete( TT ); } ) void adelete( T arr[], TT rest ); //--------------------------------------- @@ -333,5 +330,5 @@ //--------------------------------------- -forall( otype E | { int ? -trait fromint(otype T) { +trait fromint(T) { void ?{}(T&, int); }; -trait zeroinit(otype T) { +trait zeroinit(T) { void ?{}(T&, zero_t); }; -trait zero_assign(otype T) { +trait zero_assign(T) { T ?=?(T&, zero_t); }; -trait subtract(otype T) { +trait subtract(T) { T ?-?(T, T); }; -trait negate(otype T) { +trait negate(T) { T -?(T); }; -trait add(otype T) { +trait add(T) { T ?+?(T, T); }; -trait multiply(otype T) { +trait multiply(T) { T ?*?(T, T); }; -trait divide(otype T) { +trait divide(T) { T ?/?(T, T); }; -trait lessthan(otype T) { +trait lessthan(T) { int ?'; Index: libcfa/src/vec/vec3.hfa =================================================================== --- libcfa/src/vec/vec3.hfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/vec/vec3.hfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -19,5 +19,5 @@ #include "vec.hfa" -forall (otype T) { +forall (T) { struct vec3 { T x, y, z; @@ -25,5 +25,5 @@ } -forall (otype T) { +forall (T) { static inline { @@ -288,5 +288,5 @@ } -forall(dtype ostype, otype T | writeable(T, ostype)) { +forall(ostype &, T | writeable(T, ostype)) { ostype & ?|?(ostype & os, vec3(T) v) with (v) { return os | '<' | x | ',' | y | ',' | z | '>'; Index: libcfa/src/vec/vec4.hfa =================================================================== --- libcfa/src/vec/vec4.hfa (revision 92bfda038b786d60ca776b71dd68b3dc8f69b94d) +++ libcfa/src/vec/vec4.hfa (revision dafbde8dedf38315f3298b109629f5e705f00ebe) @@ -19,5 +19,5 @@ #include "vec.hfa" -forall (otype T) { +forall (T) { struct vec4 { T x, y, z, w; @@ -25,5 +25,5 @@ } -forall (otype T) { +forall (T) { static inline { @@ -283,5 +283,5 @@ } -forall(dtype ostype, otype T | writeable(T, ostype)) { +forall(ostype &, T | writeable(T, ostype)) { ostype & ?|?(ostype & os, vec4(T) v) with (v) { return os | '<' | x | ',' | y | ',' | z | ',' | w | '>';