Index: libcfa/prelude/builtins.c =================================================================== --- libcfa/prelude/builtins.c (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/prelude/builtins.c (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/prelude/prelude-gen.cc (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/prelude/prelude.old.cf (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/prelude/sync-builtins.cf (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/bitmanip.hfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/bits/algorithm.hfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/bits/collection.hfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/bits/containers.hfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/bits/queue.hfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/bits/sequence.hfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/bits/stack.hfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/common.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/common.hfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/concurrency/coroutine.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/concurrency/coroutine.hfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/concurrency/future.hfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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/locks.cfa =================================================================== --- libcfa/src/concurrency/locks.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/concurrency/locks.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/concurrency/locks.hfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/concurrency/monitor.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/concurrency/monitor.hfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/concurrency/mutex.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/concurrency/mutex.hfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/concurrency/thread.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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,15 +71,15 @@ } -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(*cancelHandler)(ThreadCancelled(T) &)) { @@ -124,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); @@ -140,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{}; @@ -146,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 }; @@ -152,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{}; @@ -158,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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/concurrency/thread.hfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/containers/list.hfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/containers/maybe.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/containers/maybe.hfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/containers/pair.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/containers/pair.hfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/containers/result.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/containers/result.hfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/containers/stackLockFree.hfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/containers/vector.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/containers/vector.hfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/exception.h (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/executor.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/gmp.hfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/iostream.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/iostream.hfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/iterator.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/iterator.hfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/math.hfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/memory.hfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/parseargs.hfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/rational.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/rational.hfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/stdlib.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 ? always call destructor @@ -281,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 ); @@ -288,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 ); //--------------------------------------- @@ -330,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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/vec/vec3.hfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ libcfa/src/vec/vec4.hfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -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 | '>'; Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ src/Parser/parser.yy (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -2441,5 +2441,9 @@ type_parameter: // CFA type_class identifier_or_type_name - { typedefTable.addToScope( *$2, TYPEDEFname, "9" ); } + { typedefTable.addToScope( *$2, TYPEDEFname, "9" ); + if ( $1 == TypeDecl::Otype ) { SemanticError( yylloc, "otype keyword is deprecated" ); } + if ( $1 == TypeDecl::Dtype ) { SemanticError( yylloc, "dtype keyword is deprecated" ); } + if ( $1 == TypeDecl::Ttype ) { SemanticError( yylloc, "ttype keyword is deprecated" ); } + } type_initializer_opt assertion_list_opt { $$ = DeclarationNode::newTypeParam( $1, $2 )->addTypeInitializer( $4 )->addAssertions( $5 ); } Index: tests/avltree/avl-private.cfa =================================================================== --- tests/avltree/avl-private.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/avltree/avl-private.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -11,5 +11,5 @@ // an AVL tree's height is easy to compute // just follow path with the larger balance -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) int height(tree(K, V) * t){ int helper(tree(K, V) * t, int ht){ @@ -27,5 +27,5 @@ } -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) int calcBalance(tree(K, V) * t){ int l = height(t->left); @@ -36,5 +36,5 @@ // re-establish the link between parent and child -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) void relinkToParent(tree(K, V) * t){ tree(K, V) * parent = t->parent; // FIX ME!! @@ -49,5 +49,5 @@ // rotate left from t -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) tree(K, V) * rotateLeft(tree(K, V) * t){ tree(K, V) * newRoot = t->right; @@ -68,5 +68,5 @@ // rotate right from t -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) tree(K, V) * rotateRight(tree(K, V) * t){ tree(K, V) * newRoot = t->left; @@ -87,5 +87,5 @@ // balances a node that has balance factor -2 or 2 -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) tree(K, V) * fix(tree(K, V) * t){ // ensure that t's balance factor is one of @@ -113,5 +113,5 @@ // attempt to fix the tree, if necessary -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) tree(K, V) * tryFix(tree(K, V) * t){ int b = calcBalance(t); @@ -126,5 +126,5 @@ // sets parent field of c to be p -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) void setParent(tree(K, V) * c, tree(K, V) * p){ if (! empty(c)){ Index: tests/avltree/avl-private.h =================================================================== --- tests/avltree/avl-private.h (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/avltree/avl-private.h (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -5,11 +5,11 @@ // attempt to fix the tree, if necessary -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) tree(K, V) * tryFix(tree(K, V) * t); // sets parent field of c to be p -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) void setParent(tree(K, V) * c, tree(K, V) * p); -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) int height(tree(K, V) * t); Index: tests/avltree/avl.h =================================================================== --- tests/avltree/avl.h (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/avltree/avl.h (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -9,12 +9,12 @@ // #include -trait Comparable(otype T) { +trait Comparable(T) { int ??(T t1, T t2); @@ -41,8 +41,8 @@ // temporary: need forward decl to get around typedef problem -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) struct tree; -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) struct tree { K key; @@ -54,30 +54,30 @@ }; -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) void ?{}(tree(K, V) &t, K key, V value); -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) void ^?{}(tree(K, V) & t); -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) tree(K, V) * create(K key, V value); -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) V * find(tree(K, V) * t, K key); -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) int empty(tree(K, V) * t); // returns the root of the tree -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) int insert(tree(K, V) ** t, K key, V value); -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) int remove(tree(K, V) ** t, K key); -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) void copy(tree(K, V) * src, tree(K, V) ** ret); -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) void for_each(tree(K, V) * t, void (*func)(V)); Index: tests/avltree/avl0.cfa =================================================================== --- tests/avltree/avl0.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/avltree/avl0.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -1,10 +1,10 @@ #include "avl.h" -forall(otype T | Comparable(T)) +forall(T | Comparable(T)) int ?==?(T t1, T t2) { return !(t1 < t2) && !(t2 < t1); } -forall(otype T | Comparable(T)) +forall(T | Comparable(T)) int ?>?(T t1, T t2) { return t2 < t1; Index: tests/avltree/avl1.cfa =================================================================== --- tests/avltree/avl1.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/avltree/avl1.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -3,5 +3,5 @@ #include -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) void ?{}(tree(K, V) &t, K key, V value){ (t.key) { key }; @@ -13,5 +13,5 @@ } -forall(otype K| Comparable(K), otype V) +forall(K| Comparable(K), V) void ^?{}(tree(K, V) & t){ delete(t.left); @@ -21,5 +21,5 @@ } -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) tree(K, V) * create(K key, V value) { // infinite loop trying to resolve ... t = malloc(); Index: tests/avltree/avl2.cfa =================================================================== --- tests/avltree/avl2.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/avltree/avl2.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -2,5 +2,5 @@ #include "avl-private.h" -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) V * find(tree(K, V) * t, K key){ if (empty(t)){ @@ -18,5 +18,5 @@ } -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) int empty(tree(K, V) * t){ return t == NULL; @@ -24,5 +24,5 @@ // returns the root of the tree -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) int insert(tree(K, V) ** t, K key, V value) { // handles a non-empty tree Index: tests/avltree/avl3.cfa =================================================================== --- tests/avltree/avl3.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/avltree/avl3.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -4,5 +4,5 @@ // swaps the data within two tree nodes -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) void node_swap(tree(K, V) * t, tree(K, V) * t2){ swap( t->key, t2->key); @@ -11,5 +11,5 @@ // go left as deep as possible from within the right subtree -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) tree(K, V) * find_successor(tree(K, V) * t){ tree(K, V) * find_successor_helper(tree(K, V) * t){ @@ -25,5 +25,5 @@ // cleanup - don't want to deep delete, so set children to NULL first. -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) void deleteSingleNode(tree(K, V) * t) { t->left = NULL; @@ -33,5 +33,5 @@ // does the actual remove operation once we've found the node in question -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) tree(K, V) * remove_node(tree(K, V) * t){ // is the node a leaf? @@ -85,5 +85,5 @@ // finds the node that needs to be removed -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) tree(K, V) * remove_helper(tree(K, V) * t, K key, int * worked){ if (empty(t)){ @@ -106,5 +106,5 @@ } -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) int remove(tree(K, V) ** t, K key){ int worked = 0; Index: tests/avltree/avl4.cfa =================================================================== --- tests/avltree/avl4.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/avltree/avl4.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -4,5 +4,5 @@ // Perform a shallow copy of src, return the // new tree in ret -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) int copy(tree(K, V) * src, tree(K, V) ** ret){ tree(K, V) * helper(tree(K, V) * t, int * worked){ @@ -35,5 +35,5 @@ // Apply func to every value element in t, using an in order traversal -forall(otype K | Comparable(K), otype V) +forall(K | Comparable(K), V) void for_each(tree(K, V) * t, int (*func)(V)) { if (t == NULL) { Index: tests/bugs/10.cfa =================================================================== --- tests/bugs/10.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/bugs/10.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -2,5 +2,5 @@ // https://cforall.uwaterloo.ca/trac/ticket/10 -forall(otype T) +forall(T) struct result { union { Index: tests/bugs/104.cfa =================================================================== --- tests/bugs/104.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/bugs/104.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -4,5 +4,5 @@ [ float, float ] modf_( float x ); -forall(otype T | { [T, T] modf_(T); }) +forall(T | { [T, T] modf_(T); }) void modf(T); Index: tests/bugs/194.cfa =================================================================== --- tests/bugs/194.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/bugs/194.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -2,9 +2,9 @@ // https://cforall.uwaterloo.ca/trac/ticket/194 -forall( dtype T | sized(T) ) T * foo( void ) { +forall( T & | sized(T) ) T * foo( void ) { printf( "foo1\n" ); return (T *)0; } -forall( dtype T | sized(T) ) T & foo( void ) { +forall( T & | sized(T) ) T & foo( void ) { printf( "foo2\n" ); return (T &)*(T *)0; Index: tests/bugs/196.cfa =================================================================== --- tests/bugs/196.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/bugs/196.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -2,8 +2,8 @@ // https://cforall.uwaterloo.ca/trac/ticket/196 -forall(dtype T) +forall(T &) struct link; -forall(dtype T) +forall(T &) struct link { link(T) * next; @@ -12,13 +12,13 @@ // ----- -forall(dtype T) +forall(T &) struct foo; -forall(dtype U) +forall(U &) struct bar { foo(U) * data; }; -forall(dtype T) +forall(T &) struct foo {}; Index: tests/bugs/203-2.cfa =================================================================== --- tests/bugs/203-2.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/bugs/203-2.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -1,10 +1,10 @@ // Trac ticket: https://cforall.uwaterloo.ca/trac/ticket/203 -forall(dtype A) +forall(A &) struct empty { // Nothing. }; -forall(dtype C) +forall(C &) struct wrap_e { empty(C) field; Index: tests/bugs/203-7.cfa =================================================================== --- tests/bugs/203-7.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/bugs/203-7.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -1,10 +1,10 @@ // Trac ticket: https://cforall.uwaterloo.ca/trac/ticket/203 -forall(dtype A) +forall(A &) struct empty { // Nothing. }; -forall(dtype C) +forall(C &) struct wrap_e { empty(C) field; Index: tests/bugs/203-9.cfa =================================================================== --- tests/bugs/203-9.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/bugs/203-9.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -1,10 +1,10 @@ // Trac ticket: https://cforall.uwaterloo.ca/trac/ticket/203 -forall(dtype A) +forall(A &) struct empty { // Nothing. }; -forall(dtype C) +forall(C &) struct wrap_e { empty(C) field; Index: tests/bugs/7.cfa =================================================================== --- tests/bugs/7.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/bugs/7.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -8,8 +8,8 @@ // (Bug 1 unresolved as of this test.) -forall(otype T) +forall(T) struct stack_node; -forall(otype T) +forall(T) struct stack_node { stack_node(T) * next; @@ -17,14 +17,14 @@ }; -forall(otype T) +forall(T) struct stack { stack_node(T) * head; }; -trait stack_errors(otype T) { +trait stack_errors(T) { T emptyStackHandler (stack(T) * this); }; -forall(otype T | stack_errors(T)) +forall(T | stack_errors(T)) T pop (stack(T) * this) { return (T){}; Index: tests/castError.cfa =================================================================== --- tests/castError.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/castError.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -14,5 +14,5 @@ // -forall(otype T) struct S { T p; }; +forall(T) struct S { T p; }; int f; S(int) sint; Index: tests/concurrent/examples/boundedBufferEXT.cfa =================================================================== --- tests/concurrent/examples/boundedBufferEXT.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/concurrent/examples/boundedBufferEXT.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -24,5 +24,5 @@ enum { BufferSize = 50 }; -forall( otype T ) { +forall( T ) { monitor Buffer { int front, back, count; Index: tests/concurrent/examples/boundedBufferINT.cfa =================================================================== --- tests/concurrent/examples/boundedBufferINT.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/concurrent/examples/boundedBufferINT.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -24,5 +24,5 @@ enum { BufferSize = 50 }; -forall( otype T ) { +forall( T ) { monitor Buffer { condition full, empty; Index: tests/concurrent/examples/quickSort.generic.cfa =================================================================== --- tests/concurrent/examples/quickSort.generic.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/concurrent/examples/quickSort.generic.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -21,5 +21,5 @@ #include // strcmp -forall( otype T | { int ? -FORALL_TRIVIAL_EXCEPTION(proxy, (otype T), (T)); -FORALL_TRIVIAL_INSTANCE(proxy, (otype U), (U)) +FORALL_TRIVIAL_EXCEPTION(proxy, (T), (T)); +FORALL_TRIVIAL_INSTANCE(proxy, (U), (U)) const char * msg(proxy(int) * this) { return "proxy(int)"; } @@ -33,9 +33,9 @@ } -FORALL_DATA_EXCEPTION(cell, (otype T), (T))( +FORALL_DATA_EXCEPTION(cell, (T), (T))( T data; ); -FORALL_DATA_INSTANCE(cell, (otype T), (T)) +FORALL_DATA_INSTANCE(cell, (T), (T)) const char * msg(cell(int) * this) { return "cell(int)"; } Index: tests/exceptions/virtual-poly.cfa =================================================================== --- tests/exceptions/virtual-poly.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/exceptions/virtual-poly.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -16,10 +16,10 @@ }; -forall(otype T) +forall(T) struct mono_child_vtable { mono_base_vtable const * const parent; }; -forall(otype T) +forall(T) struct mono_child { mono_child_vtable(T) const * virtual_table; @@ -37,20 +37,20 @@ } -forall(otype U) +forall(U) struct poly_base_vtable { poly_base_vtable(U) const * const parent; }; -forall(otype U) +forall(U) struct poly_base { poly_base_vtable(U) const * virtual_table; }; -forall(otype V) +forall(V) struct poly_child_vtable { poly_base_vtable(V) const * const parent; }; -forall(otype V) +forall(V) struct poly_child { poly_child_vtable(V) const * virtual_table; Index: tests/forall.cfa =================================================================== --- tests/forall.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/forall.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -15,5 +15,5 @@ void g1() { - forall( otype T ) T f( T ) {}; + forall( T ) T f( T ) {}; void f( int ) {}; void h( void (*p)(void) ) {}; @@ -32,6 +32,6 @@ void g2() { - forall( otype T ) void f( T, T ) {} - forall( otype T, otype U ) void f( T, U ) {} + forall( T ) void f( T, T ) {} + forall( T, U ) void f( T, U ) {} int x; @@ -45,7 +45,7 @@ } -typedef forall ( otype T ) int (* f)( int ); - -forall( otype T ) +typedef forall ( T ) int (* f)( int ); + +forall( T ) void swap( T left, T right ) { T temp = left; @@ -54,5 +54,5 @@ } -trait sumable( otype T ) { +trait sumable( T ) { void ?{}( T &, zero_t ); // 0 literal constructor T ?+?( T, T ); // assortment of additions @@ -62,5 +62,5 @@ }; // sumable -forall( otype T | sumable( T ) ) // use trait +forall( T | sumable( T ) ) // use trait T sum( size_t size, T a[] ) { T total = 0; // initialize by 0 constructor @@ -70,10 +70,10 @@ } // sum -forall( otype T | { T ?+?( T, T ); T ?++( T & ); [T] ?+=?( T &,T ); } ) +forall( T | { T ?+?( T, T ); T ?++( T & ); [T] ?+=?( T &,T ); } ) T twice( T t ) { return t + t; } -forall( otype T | { int ?val * x; @@ -130,5 +130,5 @@ // TODO: generalize to ttype return; doesn't work yet // like std::function -forall(otype Return, ttype Args) +forall(Return, Args...) struct function { Return (*f)(Args); Index: tests/genericUnion.cfa =================================================================== --- tests/genericUnion.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/genericUnion.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -16,5 +16,5 @@ #include -forall(otype T) +forall(T) union ByteView { T val; @@ -22,5 +22,5 @@ }; -forall(otype T) +forall(T) void print(ByteView(T) x) { for (int i = 0; i < sizeof(int); i++) { // want to change to sizeof(T) @@ -29,5 +29,5 @@ } -forall(otype T) +forall(T) void f(ByteView(T) x, T val) { print(x); Index: tests/global-monomorph.cfa =================================================================== --- tests/global-monomorph.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/global-monomorph.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -1,11 +1,11 @@ // Create monomorphic instances of polymorphic types at global scope. -forall(dtype T) +forall(T &) void poly0(T &) {} -forall(dtype T | sized(T)) +forall(T & | sized(T)) void poly1(T &) {} -forall(otype T) +forall(T) void poly2(T &) {} Index: tests/identity.cfa =================================================================== --- tests/identity.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/identity.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -16,5 +16,5 @@ #include -forall( otype T ) +forall( T ) T identity( T t ) { return t; Index: tests/init1.cfa =================================================================== --- tests/init1.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/init1.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -120,10 +120,10 @@ } -forall (dtype T, dtype S) +forall (T &, S &) T & anycvt( S & s ) { return s; // mismatched referenced type } -forall (dtype T, dtype S) +forall (T &, S &) T * anycvt( S * s ) { return s; // mismatched referenced type Index: tests/nested-types.cfa =================================================================== --- tests/nested-types.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/nested-types.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -16,5 +16,5 @@ typedef int N; struct A { - forall(otype T) + forall(T) struct N { T x; Index: tests/poly-d-cycle.cfa =================================================================== --- tests/poly-d-cycle.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/poly-d-cycle.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -1,13 +1,13 @@ // Check that a cycle of polymorphic dtype structures can be instancated. -forall(dtype T) +forall(T &) struct func_table; -forall(dtype U) +forall(U &) struct object { func_table(U) * virtual_table; }; -forall(dtype T) +forall(T &) struct func_table { void (*object_func)(object(T) *); Index: tests/poly-o-cycle.cfa =================================================================== --- tests/poly-o-cycle.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/poly-o-cycle.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -1,13 +1,13 @@ // Check that a cycle of polymorphic otype structures can be instancated. -forall(otype T) +forall(T) struct func_table; -forall(otype U) +forall(U) struct object { func_table(U) * virtual_table; }; -forall(otype T) +forall(T) struct func_table { void (*object_func)(object(T) *); Index: tests/poly-selection.cfa =================================================================== --- tests/poly-selection.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/poly-selection.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -16,15 +16,15 @@ void testSpecializationFromGenericOverBareTyvar() { - forall( dtype T ) + forall( T & ) void friend( T & ) { printf("friending generically\n"); } - forall(dtype T) + forall(T &) struct thing { int x; }; - forall( dtype T ) + forall( T & ) void friend( thing(T) & ) { printf("friending specifically\n"); @@ -37,13 +37,13 @@ void testSpecializationFromGenericAccessibleWithExtraTyvars() { - forall( dtype T, dtype U ) + forall( T &, U & ) struct map {}; - forall( dtype T ) + forall( T & ) void f( T & ) { printf("f-generic\n"); } - forall( dtype T ) + forall( T & ) void f( map(T, T) & ) { printf("f-specific\n"); Index: tests/polymorphism.cfa =================================================================== --- tests/polymorphism.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/polymorphism.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -18,5 +18,5 @@ #include -forall(otype T) +forall(T) T f(T x, T y) { x = y; @@ -24,9 +24,9 @@ } -forall(otype T) T ident(T x) { +forall(T) T ident(T x) { return x; } -forall( otype T, otype U ) +forall( T, U ) size_t struct_size( T i, U j ) { struct S { T i; U j; }; @@ -34,5 +34,5 @@ } -forall( otype T, otype U ) +forall( T, U ) size_t union_size( T i, U j ) { union B { T i; U j; }; @@ -41,5 +41,5 @@ // perform some simple operations on aggregates of T and U -forall( otype T | { void print(T); int ?==?(T, T); }, otype U | { void print(U); U ?=?(U&, zero_t); } ) +forall( T | { void print(T); int ?==?(T, T); }, U | { void print(U); U ?=?(U&, zero_t); } ) U foo(T i, U j) { struct S { T i; U j; }; Index: tests/raii/ctor-autogen.cfa =================================================================== --- tests/raii/ctor-autogen.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/raii/ctor-autogen.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -33,5 +33,5 @@ // dtype-static generic type is otype -forall(dtype T) +forall(T &) struct DtypeStaticStruct { T * data; @@ -39,5 +39,5 @@ }; -forall(dtype T) +forall(T &) union DtypeStaticUnion { T * data; @@ -46,10 +46,10 @@ // dynamic generic type is otype -forall(otype T) +forall(T) struct DynamicStruct { T x; }; -forall(otype T) +forall(T) union DynamicUnion { T x; @@ -80,5 +80,5 @@ -forall(otype T) +forall(T) T identity(T x) { return x; } Index: tests/simpleGenericTriple.cfa =================================================================== --- tests/simpleGenericTriple.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/simpleGenericTriple.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -14,10 +14,10 @@ // -forall(otype T) +forall(T) struct T3 { T f0, f1, f2; }; -forall(otype T | { T ?+?(T, T); }) +forall(T | { T ?+?(T, T); }) T3(T) ?+?(T3(T) x, T3(T) y) { T3(T) z = { x.f0+y.f0, x.f1+y.f1, x.f2+y.f2 }; Index: tests/sum.cfa =================================================================== --- tests/sum.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/sum.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -18,5 +18,5 @@ #include -trait sumable( otype T ) { +trait sumable( T ) { void ?{}( T &, zero_t ); // 0 literal constructor T ?+?( T, T ); // assortment of additions @@ -26,5 +26,5 @@ }; // sumable -forall( otype T | sumable( T ) ) // use trait +forall( T | sumable( T ) ) // use trait T sum( size_t size, T a[] ) { T total = 0; // initialize by 0 constructor @@ -107,5 +107,5 @@ | sum( size, (S *)a ) | ", check" | (S)s; - forall( otype Impl | sumable( Impl ) ) + forall( Impl | sumable( Impl ) ) struct GS { Impl * x, * y; @@ -194,5 +194,5 @@ sum( size, (S *)a ).[i, j], s.[i, j] ); - forall( otype Impl | sumable( Impl ) ) + forall( Impl | sumable( Impl ) ) struct GS { Impl * x, * y; Index: tests/tuple/tuplePolymorphism.cfa =================================================================== --- tests/tuple/tuplePolymorphism.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/tuple/tuplePolymorphism.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -29,9 +29,9 @@ // ensure that f is a viable candidate for g, even though its parameter structure does not exactly match [A] f([A, B] x, B y) { printf("%g %c %g %lld %c %lld %lld %c %lld\n", x.0.[x,y,z], x.1.[x,y,z], y.[x,y,z]); return x.0; } -forall(otype T, otype U | { T f(T, U, U); }) +forall(T, U | { T f(T, U, U); }) void g(T x, U y) { f(x, y, y); } // add two triples -forall(otype T | { T ?+?(T, T); }) +forall(T | { T ?+?(T, T); }) [T, T, T] ?+?([T, T, T] x, [T, T, T] y) { return [x.0+y.0, x.1+y.1, x.2+y.2]; @@ -64,5 +64,5 @@ } -forall(otype T) +forall(T) [T, T] foo([T, T] y) { [T, T] x; Index: tests/tuple/tupleVariadic.cfa =================================================================== --- tests/tuple/tupleVariadic.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/tuple/tupleVariadic.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -19,5 +19,5 @@ printf("called func(void)\n"); } -forall(otype T, ttype Params | { void process(T); void func(Params); }) +forall(T, Params... | { void process(T); void func(Params); }) void func(T arg1, Params p) { process(arg1); @@ -92,5 +92,5 @@ } -forall(otype T) +forall(T) T * copy(T x) { // test calling new inside a polymorphic function @@ -98,5 +98,5 @@ } -forall(ttype T | { void foo(T); }) void bar(T x) {} +forall(T... | { void foo(T); }) void bar(T x) {} void foo(int) {} Index: tests/zombies/ArrayN.c =================================================================== --- tests/zombies/ArrayN.c (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/ArrayN.c (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -6,5 +6,5 @@ // } -forall(otype index_t) +forall(index_t) index_t offset_to_index(unsigned offset, index_t size) { return [offset / size.0, offset % size.1]; Index: tests/zombies/Members.c =================================================================== --- tests/zombies/Members.c (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/Members.c (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -2,6 +2,6 @@ int ?=?( int*, int ); float ?=?( float*, float ); -forall( dtype DT ) DT * ?=?( DT**, DT* ); -forall(otype T) lvalue T *?( T* ); +forall( DT & ) DT * ?=?( DT**, DT* ); +forall(T) lvalue T *?( T* ); char *__builtin_memcpy(); Index: tests/zombies/Rank2.c =================================================================== --- tests/zombies/Rank2.c (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/Rank2.c (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -1,8 +1,8 @@ int ?=?( int &, int ); -forall(dtype DT) DT * ?=?( DT *&, DT * ); +forall(DT &) DT * ?=?( DT *&, DT * ); void a() { - forall( otype T ) void f( T ); - void g( forall( otype U ) void p( U ) ); + forall( T ) void f( T ); + void g( forall( U ) void p( U ) ); g( f ); } @@ -10,5 +10,5 @@ void g() { void h( int *null ); - forall( otype T ) T id( T ); + forall( T ) T id( T ); // forall( dtype T ) T *0; // int 0; Index: tests/zombies/abstype.c =================================================================== --- tests/zombies/abstype.c (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/abstype.c (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -21,8 +21,8 @@ } -forall( otype T ) T *?( T * ); +forall( T ) T *?( T * ); int ?++( int * ); int ?=?( int *, int ); -forall( dtype DT ) DT * ?=?( DT **, DT * ); +forall( DT & ) DT * ?=?( DT **, DT * ); otype U = int *; Index: tests/zombies/context.cfa =================================================================== --- tests/zombies/context.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/context.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -1,10 +1,10 @@ // trait declaration -trait has_q( otype T ) { +trait has_q( T ) { T q( T ); }; -forall( otype z | has_q( z ) ) void f() { - trait has_r( otype T, otype U ) { +forall( z | has_q( z ) ) void f() { + trait has_r( T, U ) { T r( T, T (T,U) ); }; Index: tests/zombies/gc_no_raii/bug-repro/blockers/explicit_cast.c =================================================================== --- tests/zombies/gc_no_raii/bug-repro/blockers/explicit_cast.c (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/gc_no_raii/bug-repro/blockers/explicit_cast.c (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -9,5 +9,5 @@ }; -forall(otype T) +forall(T) struct gcpointer { @@ -15,5 +15,5 @@ }; -forall(otype T) +forall(T) static inline gcpointer(T) gcmalloc() { Index: tests/zombies/gc_no_raii/bug-repro/blockers/recursive_realloc.c =================================================================== --- tests/zombies/gc_no_raii/bug-repro/blockers/recursive_realloc.c (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/gc_no_raii/bug-repro/blockers/recursive_realloc.c (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -3,10 +3,10 @@ #include -trait allocator_c(otype T, otype allocator_t) +trait allocator_c(T, allocator_t) { void realloc(allocator_t* const, size_t); }; -forall(otype T) +forall(T) struct heap_allocator { @@ -15,5 +15,5 @@ }; -forall(otype T) +forall(T) inline void realloc(heap_allocator(T) *const this, size_t size) { Index: tests/zombies/gc_no_raii/bug-repro/deref.c =================================================================== --- tests/zombies/gc_no_raii/bug-repro/deref.c (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/gc_no_raii/bug-repro/deref.c (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -1,3 +1,3 @@ - forall(otype T) + forall(T) struct wrap { @@ -5,5 +5,5 @@ }; - forall(otype T) + forall(T) T *? (wrap(T) rhs) { Index: tests/zombies/gc_no_raii/bug-repro/field.c =================================================================== --- tests/zombies/gc_no_raii/bug-repro/field.c (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/gc_no_raii/bug-repro/field.c (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -8,5 +8,5 @@ //------------------------------------------------------------------------------ //Declaration -trait allocator_c(otype T, otype allocator_t) +trait allocator_c(T, allocator_t) { void ctor(allocator_t* const); @@ -16,5 +16,5 @@ }; -forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +forall(T, allocator_t | allocator_c(T, allocator_t)) struct vector { Index: tests/zombies/gc_no_raii/bug-repro/malloc.c =================================================================== --- tests/zombies/gc_no_raii/bug-repro/malloc.c (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/gc_no_raii/bug-repro/malloc.c (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -1,3 +1,3 @@ -forall(otype T) +forall(T) struct wrapper { @@ -5,5 +5,5 @@ }; -forall(otype T) +forall(T) void ctor(wrapper(T)* this) { @@ -11,5 +11,5 @@ } -forall(otype T) +forall(T) wrapper(T) gcmalloc() { @@ -19,5 +19,5 @@ } -forall(otype T) +forall(T) wrapper(T)* ?=? (wrapper(T)* lhs, wrapper(T)* rhs) { Index: tests/zombies/gc_no_raii/bug-repro/oddtype.c =================================================================== --- tests/zombies/gc_no_raii/bug-repro/oddtype.c (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/gc_no_raii/bug-repro/oddtype.c (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -1,10 +1,10 @@ -forall(dtype T) +forall(T &) struct wrap { int i; }; -forall(otype T) void ?{}(wrap(T)* this) {} -forall(otype T) void ?=?(wrap(T)* this) {} -forall(otype T) void ^?{}(wrap(T)* this) {} +forall(T) void ?{}(wrap(T)* this) {} +forall(T) void ?=?(wrap(T)* this) {} +forall(T) void ^?{}(wrap(T)* this) {} struct List_t { Index: tests/zombies/gc_no_raii/bug-repro/push_back.h =================================================================== --- tests/zombies/gc_no_raii/bug-repro/push_back.h (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/gc_no_raii/bug-repro/push_back.h (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -1,5 +1,5 @@ //------------------------------------------------------------------------------ //Declaration -trait allocator_c(otype T, otype allocator_t) { +trait allocator_c(T, allocator_t) { void ctor(allocator_t* const); void dtor(allocator_t* const); @@ -8,5 +8,5 @@ }; -forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +forall(T, allocator_t | allocator_c(T, allocator_t)) struct vector { @@ -17,13 +17,13 @@ //------------------------------------------------------------------------------ //Initialization -forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +forall(T, allocator_t | allocator_c(T, allocator_t)) void vector_ctor(vector(T, allocator_t) *const this); -forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +forall(T, allocator_t | allocator_c(T, allocator_t)) void dtor(vector(T, allocator_t) *const this); //------------------------------------------------------------------------------ //Allocator -forall(otype T) +forall(T) struct heap_allocator { @@ -32,14 +32,14 @@ }; -forall(otype T) +forall(T) void ctor(heap_allocator(T) *const this); -forall(otype T) +forall(T) void dtor(heap_allocator(T) *const this); -forall(otype T) +forall(T) void realloc(heap_allocator(T) *const this, size_t size); -forall(otype T) +forall(T) inline T* data(heap_allocator(T) *const this) { @@ -49,5 +49,5 @@ //------------------------------------------------------------------------------ //Capacity -forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +forall(T, allocator_t | allocator_c(T, allocator_t)) inline bool empty(vector(T, allocator_t) *const this) { @@ -55,5 +55,5 @@ } -forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +forall(T, allocator_t | allocator_c(T, allocator_t)) inline bool size(vector(T, allocator_t) *const this) { @@ -61,5 +61,5 @@ } -forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +forall(T, allocator_t | allocator_c(T, allocator_t)) inline void reserve(vector(T, allocator_t) *const this, size_t size) { @@ -69,4 +69,4 @@ //------------------------------------------------------------------------------ //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) *const this, T value); Index: tests/zombies/gc_no_raii/bug-repro/realloc.c =================================================================== --- tests/zombies/gc_no_raii/bug-repro/realloc.c (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/gc_no_raii/bug-repro/realloc.c (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -1,5 +1,5 @@ void* realloc(void*, unsigned long int); -forall(otype T) +forall(T) struct wrap { @@ -7,5 +7,5 @@ }; -forall(otype T) +forall(T) static inline void realloc(wrap(T) *const this, unsigned long int size) { Index: tests/zombies/gc_no_raii/bug-repro/return.c =================================================================== --- tests/zombies/gc_no_raii/bug-repro/return.c (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/gc_no_raii/bug-repro/return.c (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -1,3 +1,3 @@ -forall(otype T) +forall(T) struct wrapper { @@ -5,5 +5,5 @@ }; -forall(otype T) +forall(T) wrapper(T) create() { @@ -12,5 +12,5 @@ } -forall(otype T) +forall(T) wrapper(T)* ?=?(wrapper(T)* lhs, wrapper(T)* rhs) { Index: tests/zombies/gc_no_raii/bug-repro/return_template.c =================================================================== --- tests/zombies/gc_no_raii/bug-repro/return_template.c (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/gc_no_raii/bug-repro/return_template.c (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -1,3 +1,3 @@ -forall(otype T) +forall(T) struct wrap { @@ -5,10 +5,10 @@ }; -forall(otype T) void ?{}(wrap(T)* this); -forall(otype T) void ?{}(wrap(T)* this, wrap(T)* rhs); -forall(otype T) void ^?{}(wrap(T)* this); -forall(otype T) void ?=?(wrap(T)* this, wrap(T)* rhs); +forall(T) void ?{}(wrap(T)* this); +forall(T) void ?{}(wrap(T)* this, wrap(T)* rhs); +forall(T) void ^?{}(wrap(T)* this); +forall(T) void ?=?(wrap(T)* this, wrap(T)* rhs); -forall(otype T) +forall(T) wrap(T) test() { Index: tests/zombies/gc_no_raii/bug-repro/slow_malloc.c =================================================================== --- tests/zombies/gc_no_raii/bug-repro/slow_malloc.c (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/gc_no_raii/bug-repro/slow_malloc.c (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -1,5 +1,5 @@ #include -forall(otype T) +forall(T) struct heap_allocator { Index: tests/zombies/gc_no_raii/bug-repro/zero.c =================================================================== --- tests/zombies/gc_no_raii/bug-repro/zero.c (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/gc_no_raii/bug-repro/zero.c (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -1,3 +1,3 @@ -forall(otype T) +forall(T) struct wrap { @@ -5,5 +5,5 @@ }; -forall(otype T) +forall(T) int ?==? (wrap(T) lhs, wrap(T) rhs) { @@ -14,5 +14,5 @@ struct wrap(int) 0; /*/ -forall(otype T) +forall(T) struct wrap(T) 0; //*/ Index: tests/zombies/gc_no_raii/src/gc.h =================================================================== --- tests/zombies/gc_no_raii/src/gc.h (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/gc_no_raii/src/gc.h (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -13,5 +13,5 @@ // } -forall(otype T) +forall(T) static inline void gcmalloc(gcpointer(T)* ptr) { Index: tests/zombies/gc_no_raii/src/gcpointers.c =================================================================== --- tests/zombies/gc_no_raii/src/gcpointers.c (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/gc_no_raii/src/gcpointers.c (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -113,21 +113,21 @@ #endif -forall(otype T) void ?{}(gcpointer(T)* this) { +forall(T) void ?{}(gcpointer(T)* this) { (&this->internal) {}; } -forall(otype T) void ?{}(gcpointer(T)* this, void* address) { +forall(T) void ?{}(gcpointer(T)* this, void* address) { (&this->internal) { address }; } -forall(otype T) void ?{}(gcpointer(T)* this, gcpointer(T) other) { +forall(T) void ?{}(gcpointer(T)* this, gcpointer(T) other) { (&this->internal) { other.internal }; } -forall(otype T) void ^?{}(gcpointer(T)* this) { +forall(T) void ^?{}(gcpointer(T)* this) { ^?{}(&this->internal); } -forall(otype T) gcpointer(T) ?=?(gcpointer(T)* this, gcpointer(T) rhs) { +forall(T) gcpointer(T) ?=?(gcpointer(T)* this, gcpointer(T) rhs) { this->internal = rhs.internal; return *this; @@ -136,10 +136,10 @@ // forall(otype T) T *?(gcpointer(T) this); -forall(otype T) T* get(gcpointer(T)* this) { +forall(T) T* get(gcpointer(T)* this) { return (T*)this->internal.ptr; } // // //Logical operators -forall(otype T) int ?!=?(gcpointer(T) this, int zero) { +forall(T) int ?!=?(gcpointer(T) this, int zero) { return this.internal.ptr != 0; } Index: tests/zombies/gc_no_raii/src/gcpointers.h =================================================================== --- tests/zombies/gc_no_raii/src/gcpointers.h (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/gc_no_raii/src/gcpointers.h (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -4,5 +4,5 @@ #include -forall(dtype T) +forall(T &) struct gcpointer; @@ -29,5 +29,5 @@ #endif -forall(dtype T) +forall(T &) struct gcpointer { @@ -36,16 +36,16 @@ // -forall(otype T) void ?{}(gcpointer(T)* this); -forall(otype T) void ?{}(gcpointer(T)* this, void* address); -forall(otype T) void ?{}(gcpointer(T)* this, gcpointer(T) other); -forall(otype T) void ^?{}(gcpointer(T)* this); -forall(otype T) gcpointer(T) ?=?(gcpointer(T)* this, gcpointer(T) rhs); +forall(T) void ?{}(gcpointer(T)* this); +forall(T) void ?{}(gcpointer(T)* this, void* address); +forall(T) void ?{}(gcpointer(T)* this, gcpointer(T) other); +forall(T) void ^?{}(gcpointer(T)* this); +forall(T) gcpointer(T) ?=?(gcpointer(T)* this, gcpointer(T) rhs); // forall(otype T) T *?(gcpointer(T) this); -forall(otype T) T* get(gcpointer(T)* this); +forall(T) T* get(gcpointer(T)* this); //Logical operators -forall(otype T) int ?!=?(gcpointer(T) this, int zero); -forall(otype T) int ?!=?(gcpointer(T) this, gcpointer(T) rhs); -forall(otype T) int ?==?(gcpointer(T) this, gcpointer(T) rhs); +forall(T) int ?!=?(gcpointer(T) this, int zero); +forall(T) int ?!=?(gcpointer(T) this, gcpointer(T) rhs); +forall(T) int ?==?(gcpointer(T) this, gcpointer(T) rhs); Index: tests/zombies/gc_no_raii/src/tools.h =================================================================== --- tests/zombies/gc_no_raii/src/tools.h (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/gc_no_raii/src/tools.h (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -12,10 +12,10 @@ // } -trait has_equal(otype T) +trait has_equal(T) { signed int ?==?(T a, T b); }; -trait InputIterator_t(otype T, otype InputIterator) +trait InputIterator_t(T, InputIterator) { signed int ?==?(InputIterator a, InputIterator b); @@ -26,5 +26,5 @@ }; -forall(otype T | has_equal(T), otype InputIterator | InputIterator_t(T, InputIterator)) +forall(T | has_equal(T), InputIterator | InputIterator_t(T, InputIterator)) static inline InputIterator find( InputIterator first, const InputIterator* const last, T val) { Index: tests/zombies/hashtable.cfa =================================================================== --- tests/zombies/hashtable.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/hashtable.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -14,14 +14,14 @@ -trait has_hash( otype K ) { +trait has_hash( K ) { size_t hash(K); int ?==?( K, K ); }; -trait hkey( otype K, dtype tN | has_hash(K) ) { +trait hkey( K, tN & | has_hash(K) ) { K key(tN &); }; -forall( otype K, dtype tN, dtype tE | $dlistable(tN, tE) | hkey(K, tN) ) { +forall( K, tN &, tE & | $dlistable(tN, tE) | hkey(K, tN) ) { struct hashtable { @@ -39,5 +39,5 @@ } -forall( otype K, dtype tN, dtype tE | $dlistable(tN, tE) | hkey(K, tN) | { void defaultResumptionHandler(ht_fill_limit_crossed &); } ) { +forall( K, tN &, tE & | $dlistable(tN, tE) | hkey(K, tN) | { void defaultResumptionHandler(ht_fill_limit_crossed &); } ) { void ?{}( hashtable(K, tN, tE) & this, size_t n_buckets, dlist(tN, tE) *buckets ) { @@ -57,5 +57,5 @@ } -forall( otype K, dtype tN, dtype tE | $dlistable(tN, tE) | hkey(K, tN) ) { +forall( K, tN &, tE & | $dlistable(tN, tE) | hkey(K, tN) ) { float fill_frac( hashtable(K, tN, tE) & this ) with(this) { @@ -124,5 +124,5 @@ -trait heaped(dtype T) { +trait heaped(T &) { T * alloc( size_t ); void free( void * ); @@ -133,5 +133,5 @@ } -forall( otype K, dtype tN, dtype tE | $dlistable(tN, tE) | hkey(K, tN) | heaped( dlist(tN, tE) ) ) { +forall( K, tN &, tE & | $dlistable(tN, tE) | hkey(K, tN) | heaped( dlist(tN, tE) ) ) { struct hashtable_dynamic { Index: tests/zombies/hashtable2.cfa =================================================================== --- tests/zombies/hashtable2.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/hashtable2.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -69,9 +69,9 @@ -trait pretendsToMatter( dtype TTT ) { +trait pretendsToMatter( TTT & ) { void actsmart(TTT &); }; -forall( dtype TTTx ) +forall( TTTx & ) void actsmart(TTTx &) {} @@ -86,5 +86,5 @@ // 2. shows up in -CFA output as hashtable_rbs(), which is bad C; expecting hashtable_rbs* -forall( otype Tt_unused | pretendsToMatter(Tt_unused) ) { +forall( Tt_unused | pretendsToMatter(Tt_unused) ) { // hashtable of request by source @@ -104,5 +104,5 @@ } -forall( otype Tt_unused | pretendsToMatter(Tt_unused) | { void defaultResumptionHandler(ht_fill_limit_crossed &); } ) { +forall( Tt_unused | pretendsToMatter(Tt_unused) | { void defaultResumptionHandler(ht_fill_limit_crossed &); } ) { void ?{}( hashtable_rbs(Tt_unused) & this, size_t n_buckets, dlist(request_in_ht_by_src, request) *buckets, @@ -135,5 +135,5 @@ void defaultResumptionHandler( ht_auto_resize_pending & ex ); -forall( otype Tt_unused | pretendsToMatter(Tt_unused) ) { +forall( Tt_unused | pretendsToMatter(Tt_unused) ) { float fill_frac( hashtable_rbs(Tt_unused) & this ) with(this) { @@ -221,5 +221,5 @@ -trait heaped(dtype T) { +trait heaped(T &) { T * alloc( size_t ); void free( void * ); @@ -228,5 +228,5 @@ void __dynamic_defaultResumptionHandler(ht_fill_limit_crossed &); -forall( otype Tt_unused ) { +forall( Tt_unused ) { struct hashtable_rbs_dynamic { @@ -263,5 +263,5 @@ -forall( otype Tt_unused | heaped( dlist(request_in_ht_by_src, request) ) ) { +forall( Tt_unused | heaped( dlist(request_in_ht_by_src, request) ) ) { void ?{}( hashtable_rbs_dynamic(Tt_unused).resize_policy & this, size_t nbuckets_floor ) { @@ -325,5 +325,5 @@ } -forall( otype Tt_unused ) { +forall( Tt_unused ) { void rehashToLarger_STEP( hashtable_rbs_dynamic(Tt_unused) & this, size_t new_n_buckets ) with (this) { rehashToLarger( this, new_n_buckets ); Index: tests/zombies/huge.c =================================================================== --- tests/zombies/huge.c (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/huge.c (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -14,5 +14,5 @@ // -int huge( int n, forall( otype T ) T (*f)( T ) ) { +int huge( int n, forall( T ) T (*f)( T ) ) { if ( n <= 0 ) return f( 0 ); Index: tests/zombies/it_out.c =================================================================== --- tests/zombies/it_out.c (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/it_out.c (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -16,18 +16,18 @@ typedef unsigned long streamsize_type; -trait ostream( dtype os_type ) { +trait ostream( os_type & ) { os_type *write( os_type *, const char *, streamsize_type ); int fail( os_type * ); }; -trait writeable( otype T ) { - forall( dtype os_type | ostream( os_type ) ) os_type * ?<>?( is_type *, char* ); -forall( dtype is_type | istream( is_type ) ) is_type * ?>>?( is_type *, int* ); +forall( is_type & | istream( is_type ) ) is_type * ?>>?( is_type *, char* ); +forall( is_type & | istream( is_type ) ) is_type * ?>>?( is_type *, int* ); -trait iterator( otype iterator_type, otype elt_type ) { +trait iterator( iterator_type, elt_type ) { iterator_type ?++( iterator_type* ); iterator_type ++?( iterator_type* ); @@ -52,12 +52,12 @@ }; -forall( otype elt_type | writeable( elt_type ), - otype iterator_type | iterator( iterator_type, elt_type ), - dtype os_type | ostream( os_type ) ) +forall( elt_type | writeable( elt_type ), + iterator_type | iterator( iterator_type, elt_type ), + os_type & | ostream( os_type ) ) void write_all( iterator_type begin, iterator_type end, os_type *os ); -forall( otype elt_type | writeable( elt_type ), - otype iterator_type | iterator( iterator_type, elt_type ), - dtype os_type | ostream( os_type ) ) +forall( elt_type | writeable( elt_type ), + iterator_type | iterator( iterator_type, elt_type ), + os_type & | ostream( os_type ) ) void write_all( elt_type begin, iterator_type end, os_type *os ) { os << begin; Index: tests/zombies/new.c =================================================================== --- tests/zombies/new.c (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/new.c (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -14,5 +14,5 @@ // -forall( otype T ) +forall( T ) void f( T *t ) { t--; Index: tests/zombies/occursError.cfa =================================================================== --- tests/zombies/occursError.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/occursError.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -1,5 +1,5 @@ -forall( otype T ) void f( void (*)( T, T * ) ); -forall( otype U ) void g( U, U * ); -forall( otype U ) void h( U *, U ); +forall( T ) void f( void (*)( T, T * ) ); +forall( U ) void g( U, U * ); +forall( U ) void h( U *, U ); void test() { Index: tests/zombies/prolog.c =================================================================== --- tests/zombies/prolog.c (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/prolog.c (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -25,13 +25,13 @@ void is_integer( int x ) {} -trait ArithmeticType( otype T ) { +trait ArithmeticType( T ) { void is_arithmetic( T ); }; -trait IntegralType( otype T | ArithmeticType( T ) ) { +trait IntegralType( T | ArithmeticType( T ) ) { void is_integer( T ); }; -forall( otype T | IntegralType( T ) | { void printResult( T ); } ) +forall( T | IntegralType( T ) | { void printResult( T ); } ) void hornclause( T param ) { printResult( param ); Index: tests/zombies/quad.c =================================================================== --- tests/zombies/quad.c (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/quad.c (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -16,10 +16,10 @@ #include -forall( otype T | { T ?*?( T, T ); } ) +forall( T | { T ?*?( T, T ); } ) T square( T t ) { return t * t; } -forall( otype U | { U square( U ); } ) +forall( U | { U square( U ); } ) U quad( U u ) { return square( square( u ) ); Index: tests/zombies/scope.cfa =================================================================== --- tests/zombies/scope.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/scope.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -20,9 +20,9 @@ y p; -trait has_u( otype z ) { +trait has_u( z ) { z u(z); }; -forall( otype t | has_u( t ) ) +forall( t | has_u( t ) ) y q( t the_t ) { t y = u( the_t ); Index: tests/zombies/simplePoly.c =================================================================== --- tests/zombies/simplePoly.c (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/simplePoly.c (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -14,5 +14,5 @@ // -forall( otype T, otype U | { T f( T, U ); } ) +forall( T, U | { T f( T, U ); } ) T q( T t, U u ) { return f( t, u ); Index: tests/zombies/simpler.c =================================================================== --- tests/zombies/simpler.c (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/simpler.c (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -14,5 +14,5 @@ // -forall( otype T ) T id( T, T ); +forall( T ) T id( T, T ); int main() { Index: tests/zombies/specialize.c =================================================================== --- tests/zombies/specialize.c (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/specialize.c (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -39,5 +39,5 @@ } -forall( otype T ) T f( T t ) +forall( T ) T f( T t ) { printf( "in f; sizeof T is %d\n", sizeof( T ) ); Index: tests/zombies/square.c =================================================================== --- tests/zombies/square.c (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/square.c (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -16,5 +16,5 @@ #include -forall( otype T | { T ?*?( T, T ); } ) +forall( T | { T ?*?( T, T ); } ) T square( T t ) { return t * t; Index: tests/zombies/structMember.cfa =================================================================== --- tests/zombies/structMember.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/structMember.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -66,5 +66,5 @@ S.T; .S.T; - forall( otype S, otype T ) struct W { + forall( S, T ) struct W { struct X {}; }; Index: tests/zombies/subrange.cfa =================================================================== --- tests/zombies/subrange.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/subrange.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -1,5 +1,5 @@ // A small context defining the notion of an ordered otype. (The standard // library should probably contain a context for this purpose.) -trait ordered(otype T) { +trait ordered(T) { int ? -forall( otype T | { T ?+?( T, T ); } ) +forall( T | { T ?+?( T, T ); } ) T twice( const T t ) { return t + t; Index: tests/zombies/typeGenerator.cfa =================================================================== --- tests/zombies/typeGenerator.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/typeGenerator.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -1,8 +1,8 @@ -context addable( otype T ) { +context addable( T ) { T ?+?( T,T ); T ?=?( T*, T); }; -otype List1( otype T | addable( T ) ) = struct { T data; List1( T ) *next; } *; +otype List1( T | addable( T ) ) = struct { T data; List1( T ) *next; } *; typedef List1( int ) ListOfIntegers; //List1( int ) li; @@ -11,11 +11,11 @@ [int] h( * List1( int ) p ); // new declaration syntax -struct( otype T ) S2 { T i; }; // actual definition +struct( T ) S2 { T i; }; // actual definition struct( int ) S3 v1, *p; // expansion and instantiation -struct( otype T )( int ) S24 { T i; } v2; // actual definition, expansion and instantiation -struct( otype T )( int ) { T i; } v2; // anonymous actual definition, expansion and instantiation +struct( T )( int ) S24 { T i; } v2; // actual definition, expansion and instantiation +struct( T )( int ) { T i; } v2; // anonymous actual definition, expansion and instantiation -struct( otype T | addable( T ) ) node { T data; struct( T ) node *next; }; -otype List( otype T ) = struct( T ) node *; +struct( T | addable( T ) ) node { T data; struct( T ) node *next; }; +otype List( T ) = struct( T ) node *; List( int ) my_list; Index: tests/zombies/withStatement.cfa =================================================================== --- tests/zombies/withStatement.cfa (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/withStatement.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -54,10 +54,10 @@ } -forall( otype T ) +forall( T ) struct Box { T x; }; -forall( otype T ) +forall( T ) void ?{}( Box(T) & this ) with( this ) { // with clause in polymorphic function x{}; @@ -66,5 +66,5 @@ void print( int i ) { sout | i; } -forall( otype T | { void print( T ); }) +forall( T | { void print( T ); }) void foo( T t ) { Box( T ) b = { t }; Index: tests/zombies/wrapper/src/pointer.h =================================================================== --- tests/zombies/wrapper/src/pointer.h (revision 2f47ea426dc2d246d8866b716dd596ee8ab732c4) +++ tests/zombies/wrapper/src/pointer.h (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) @@ -8,5 +8,5 @@ // type safe malloc / free -forall(otype T) +forall(T) T* new() { @@ -16,5 +16,5 @@ } -forall(otype T) +forall(T) void delete(T* p) {