Index: doc/papers/concurrency/Paper.tex =================================================================== --- doc/papers/concurrency/Paper.tex (revision 2b10f958db325dea85128cd85f1c1c9c8a596962) +++ doc/papers/concurrency/Paper.tex (revision 86fb8f2eb09b7e86dbe5a9c58b2ef0fae49bfee9) @@ -654,20 +654,43 @@ \centering \newbox\myboxA +% \begin{lrbox}{\myboxA} +% \begin{cfa}[aboveskip=0pt,belowskip=0pt] +% `int fn1, fn2, state = 1;` // single global variables +% int fib() { +% int fn; +% `switch ( state )` { // explicit execution state +% case 1: fn = 0; fn1 = fn; state = 2; break; +% case 2: fn = 1; fn2 = fn1; fn1 = fn; state = 3; break; +% case 3: fn = fn1 + fn2; fn2 = fn1; fn1 = fn; break; +% } +% return fn; +% } +% int main() { +% +% for ( int i = 0; i < 10; i += 1 ) { +% printf( "%d\n", fib() ); +% } +% } +% \end{cfa} +% \end{lrbox} \begin{lrbox}{\myboxA} \begin{cfa}[aboveskip=0pt,belowskip=0pt] -`int fn1, fn2, state = 1;` // single global variables -int fib() { - int fn; - `switch ( state )` { // explicit execution state - case 1: fn = 0; fn1 = fn; state = 2; break; - case 2: fn = 1; fn2 = fn1; fn1 = fn; state = 3; break; - case 3: fn = fn1 + fn2; fn2 = fn1; fn1 = fn; break; - } - return fn; -} +#define FIB_INIT { 0, 1 } +typedef struct { int fn1, fn; } Fib; +int fib( Fib * f ) { + + int ret = f->fn1; + f->fn1 = f->fn; + f->fn = ret + f->fn; + return ret; +} + + + int main() { - + Fib f1 = FIB_INIT, f2 = FIB_INIT; for ( int i = 0; i < 10; i += 1 ) { - printf( "%d\n", fib() ); + printf( "%d %d\n", + fib( &f1 ), fib( &f2 ) ); } } @@ -678,72 +701,106 @@ \begin{lrbox}{\myboxB} \begin{cfa}[aboveskip=0pt,belowskip=0pt] -#define FIB_INIT `{ 0, 1 }` -typedef struct { int fn2, fn1; } Fib; -int fib( Fib * f ) { - - int ret = f->fn2; - int fn = f->fn1 + f->fn2; - f->fn2 = f->fn1; f->fn1 = fn; - - return ret; -} -int main() { - Fib f1 = FIB_INIT, f2 = FIB_INIT; - for ( int i = 0; i < 10; i += 1 ) { - printf( "%d %d\n", fib( &fn1 ), fib( &f2 ) ); +`coroutine` Fib { int fn1; }; +void main( Fib & fib ) with( fib ) { + int fn; + [fn1, fn] = [0, 1]; + for () { + `suspend();` + [fn1, fn] = [fn, fn1 + fn]; } } -\end{cfa} -\end{lrbox} - -\subfloat[3 states: global variables]{\label{f:GlobalVariables}\usebox\myboxA} -\qquad -\subfloat[1 state: encapsulated variables]{\label{f:ExternalState}\usebox\myboxB} -\caption{C fibonacci fsm} -\label{f:C-fibonacci} - -\bigskip - -\newbox\myboxA -\begin{lrbox}{\myboxA} -\begin{cfa}[aboveskip=0pt,belowskip=0pt] -`coroutine` Fib { int fn; }; -void main( Fib & fib ) with( fib ) { - fn = 0; int fn1 = fn; `suspend()`; - fn = 1; int fn2 = fn1; fn1 = fn; `suspend()`; - for () { - fn = fn1 + fn2; fn2 = fn1; fn1 = fn; `suspend()`; } -} -int next( Fib & fib ) with( fib ) { `resume( fib );` return fn; } +int ?()( Fib & fib ) with( fib ) { + `resume( fib );` return fn1; +} int main() { Fib f1, f2; - for ( 10 ) - sout | next( f1 ) | next( f2 ); -} + for ( 10 ) { + sout | f1() | f2(); +} + + \end{cfa} \end{lrbox} -\newbox\myboxB -\begin{lrbox}{\myboxB} + +\newbox\myboxC +\begin{lrbox}{\myboxC} \begin{python}[aboveskip=0pt,belowskip=0pt] -def Fibonacci(): - fn = 0; fn1 = fn; `yield fn` # suspend - fn = 1; fn2 = fn1; fn1 = fn; `yield fn` - while True: - fn = fn1 + fn2; fn2 = fn1; fn1 = fn; `yield fn` - - -f1 = Fibonacci() -f2 = Fibonacci() +def Fib(): + + fn1, fn = 0, 1 + while True: + `yield fn1` + fn1, fn = fn, fn1 + fn + + +// next prewritten + + +f1 = Fib() +f2 = Fib() for i in range( 10 ): - print( `next( f1 )`, `next( f2 )` ) # resume + print( next( f1 ), next( f2 ) ) + + \end{python} \end{lrbox} -\subfloat[\CFA]{\label{f:Coroutine3States}\usebox\myboxA} -\qquad -\subfloat[Python]{\label{f:Coroutine1State}\usebox\myboxB} -\caption{Fibonacci input coroutine, 3 states, internal variables} -\label{f:cfa-fibonacci} + +\subfloat[C]{\label{f:GlobalVariables}\usebox\myboxA} +\hspace{3pt} +\vrule +\hspace{3pt} +\subfloat[\CFA]{\label{f:ExternalState}\usebox\myboxB} +\hspace{3pt} +\vrule +\hspace{3pt} +\subfloat[Python]{\label{f:ExternalState}\usebox\myboxC} +\caption{Fibonacci Generator} +\label{f:C-fibonacci} + +% \bigskip +% +% \newbox\myboxA +% \begin{lrbox}{\myboxA} +% \begin{cfa}[aboveskip=0pt,belowskip=0pt] +% `coroutine` Fib { int fn; }; +% void main( Fib & fib ) with( fib ) { +% fn = 0; int fn1 = fn; `suspend()`; +% fn = 1; int fn2 = fn1; fn1 = fn; `suspend()`; +% for () { +% fn = fn1 + fn2; fn2 = fn1; fn1 = fn; `suspend()`; } +% } +% int next( Fib & fib ) with( fib ) { `resume( fib );` return fn; } +% int main() { +% Fib f1, f2; +% for ( 10 ) +% sout | next( f1 ) | next( f2 ); +% } +% \end{cfa} +% \end{lrbox} +% \newbox\myboxB +% \begin{lrbox}{\myboxB} +% \begin{python}[aboveskip=0pt,belowskip=0pt] +% +% def Fibonacci(): +% fn = 0; fn1 = fn; `yield fn` # suspend +% fn = 1; fn2 = fn1; fn1 = fn; `yield fn` +% while True: +% fn = fn1 + fn2; fn2 = fn1; fn1 = fn; `yield fn` +% +% +% f1 = Fibonacci() +% f2 = Fibonacci() +% for i in range( 10 ): +% print( `next( f1 )`, `next( f2 )` ) # resume +% +% \end{python} +% \end{lrbox} +% \subfloat[\CFA]{\label{f:Coroutine3States}\usebox\myboxA} +% \qquad +% \subfloat[Python]{\label{f:Coroutine1State}\usebox\myboxB} +% \caption{Fibonacci input coroutine, 3 states, internal variables} +% \label{f:cfa-fibonacci} \end{figure} Index: doc/papers/concurrency/examples/Fib2.cfa =================================================================== --- doc/papers/concurrency/examples/Fib2.cfa (revision 86fb8f2eb09b7e86dbe5a9c58b2ef0fae49bfee9) +++ doc/papers/concurrency/examples/Fib2.cfa (revision 86fb8f2eb09b7e86dbe5a9c58b2ef0fae49bfee9) @@ -0,0 +1,45 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2018 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// fibonacci_1.cfa -- 1-state finite-state machine: precomputed first two states returning f(n - 1) +// +// Author : Peter A. Buhr +// Created On : Thu Apr 26 23:20:08 2018 +// Last Modified By : Peter A. Buhr +// Last Modified On : Fri Mar 22 17:26:41 2019 +// Update Count : 28 +// + +#include +#include + +coroutine Fibonacci { int fn1; }; // used for communication + +void main( Fibonacci & fib ) with( fib ) { // called on first resume + int fn; + [fn1, fn] = [0, 1]; // precompute first two states + for () { + suspend(); // restart last resume + [fn1, fn] = [fn, fn1 + fn]; // general case + } // for +} + +int ?()( Fibonacci & fib ) with( fib ) { // function call operator + resume( fib ); // restart last suspend + return fn1; +} + +int main() { + Fibonacci f1, f2; + for ( 10 ) { // print N Fibonacci values + sout | f1() | f2(); + } // for +} + +// Local Variables: // +// tab-width: 4 // +// compile-command: "cfa fibonacci_1.cfa" // +// End: // Index: doc/papers/concurrency/examples/Pingpong.cfa =================================================================== --- doc/papers/concurrency/examples/Pingpong.cfa (revision 2b10f958db325dea85128cd85f1c1c9c8a596962) +++ doc/papers/concurrency/examples/Pingpong.cfa (revision 86fb8f2eb09b7e86dbe5a9c58b2ef0fae49bfee9) @@ -4,16 +4,13 @@ coroutine PingPong { const char * name; - /* const */ unsigned int N; - PingPong * part; + unsigned int N; + PingPong & part; }; void ?{}( PingPong & this, const char * name, unsigned int N, PingPong & part ) { - (this.__cor){name}; - this.name = name; - this.N = N; - this.part = ∂ + this.[name, N] = [name, N]; &this.part = ∂ } void ?{}( PingPong & this, const char * name, unsigned int N ) { - this{ name, N, *(PingPong *)0 }; + this{ name, N, *0p }; // call first constructor } void cycle( PingPong & pingpong ) { @@ -21,15 +18,15 @@ } void partner( PingPong & this, PingPong & part ) { - this.part = ∂ + &this.part = ∂ resume( this ); } -void main( PingPong & pingpong ) { // ping's starter ::main, pong's starter ping - for ( pingpong.N ) { // N ping-pongs - sout | pingpong.name; - cycle( *pingpong.part ); +void main( PingPong & pingpong ) with(pingpong) { // ping's starter ::main, pong's starter ping + for ( N ) { // N ping-pongs + sout | name; + cycle( part ); } // for } int main() { - enum { N = 20 }; + enum { N = 5 }; PingPong ping = { "ping", N }, pong = { "pong", N, ping }; partner( ping, pong ); @@ -38,4 +35,4 @@ // Local Variables: // // tab-width: 4 // -// compile-command: "cfa pingpong.cfa" // +// compile-command: "cfa Pingpong.cfa" // // End: // Index: doc/papers/concurrency/examples/Pingpong.py =================================================================== --- doc/papers/concurrency/examples/Pingpong.py (revision 2b10f958db325dea85128cd85f1c1c9c8a596962) +++ doc/papers/concurrency/examples/Pingpong.py (revision 86fb8f2eb09b7e86dbe5a9c58b2ef0fae49bfee9) @@ -1,33 +1,32 @@ -def Scheduler +def PingPong( name, N ): + partner = (yield) # get partner + yield # resume scheduler + for i in range( N ): + print( name ) + yield partner # execute next + print( "end", name ) + +def Scheduler(): + n = (yield) # starting coroutine + while True: + n = next( n ) # schedule coroutine + +pi = PingPong( "ping", 5 ) +po = PingPong( "pong", 5 ) +next( pi ) # prime +pi.send( po ) # send partner +next( po ) # prime +po.send( pi ) # send partner + +s = Scheduler(); +next( s ) # prime try: - yield from ping(); - yield from pong(); + s.send( pi ) # start cycle except StopIteration: - print( "Scheduler stop" ) - - -def pong(): - print( "pong" ) -for i in range( 10 ): - - yield from ping() - print( "stop pong" ) - -def ping(): - global i - print( "ping" ) - i += 1 - if i < 5: - yield from pong() - print( "stop ping" ) - -p = ping() -try: - next( p ) -except StopIteration: - print( "stop" ) + print( "scheduler stop" ) +print( "stop" ) # Local Variables: # # tab-width: 4 # -# compile-command: "python3.5 pingpong.py" # +# compile-command: "python3.5 Pingpong.py" # # End: # Index: doc/papers/concurrency/examples/ProdCons.cfa =================================================================== --- doc/papers/concurrency/examples/ProdCons.cfa (revision 2b10f958db325dea85128cd85f1c1c9c8a596962) +++ doc/papers/concurrency/examples/ProdCons.cfa (revision 86fb8f2eb09b7e86dbe5a9c58b2ef0fae49bfee9) @@ -23,8 +23,8 @@ sout | "prod stops"; } -int payment( Prod & prod, int money ) { - prod.money = money; +int payment( Prod & prod, int m ) with(prod) { + money = m; resume( prod ); // main 1st time, then - return prod.receipt; // prod in delivery + return receipt; // prod in delivery } void start( Prod & prod, int N, Cons &c ) { Index: doc/papers/concurrency/examples/ProdCons.cpp =================================================================== --- doc/papers/concurrency/examples/ProdCons.cpp (revision 2b10f958db325dea85128cd85f1c1c9c8a596962) +++ doc/papers/concurrency/examples/ProdCons.cpp (revision 86fb8f2eb09b7e86dbe5a9c58b2ef0fae49bfee9) @@ -12,5 +12,9 @@ struct Cons; -struct Prod { +struct resumable { + virtual resumable * resume() = 0; +}; + +struct Prod : public resumable { struct local { Cons * c; @@ -20,4 +24,5 @@ struct promise_type { local _l; + resumable * next; Prod get_return_object() { @@ -69,14 +74,7 @@ static Prod main(); - auto payment(int money) { - _coroutine.promise()._l.money = money; - struct ret { - int _receipt; - bool await_ready() { return false; } - void await_suspend(std::experimental::coroutine_handle<>) {} - int await_resume() { return _receipt; } - }; - return ret{ _coroutine.promise()._l.receipt }; - } + struct payment_return; + + payment_return payment(int money); auto start(int N, Cons & c) { @@ -84,9 +82,13 @@ _coroutine.promise()._l.N = N; _coroutine.promise()._l.receipt = 0; + } + + virtual resumable * resume() override final { _coroutine.resume(); - } -}; - -struct Cons { + return _coroutine.promise().next; + } +}; + +struct Cons : public resumable { struct local { Prod * p; @@ -97,4 +99,5 @@ struct promise_type { local _l; + resumable * next; Cons get_return_object() { @@ -154,9 +157,12 @@ struct ret { int _status; + Cons * c; bool await_ready() { return false; } - void await_suspend(std::experimental::coroutine_handle<>) {} + void await_suspend(std::experimental::coroutine_handle _coroutine) { + _coroutine.promise().next = c; + } int await_resume() { return _status; } }; - return ret{ _coroutine.promise()._l.status }; + return ret{ _coroutine.promise()._l.status, this }; } @@ -164,11 +170,38 @@ _coroutine.promise()._l.done = true; struct ret { + Cons * c; + Prod::promise_type * _promise; bool await_ready() { return false; } - void await_suspend(std::experimental::coroutine_handle<>) {} - void await_resume() {} + void await_suspend(std::experimental::coroutine_handle _coroutine) { + _promise = &_coroutine.promise(); + _promise->next = c; + } + void await_resume() { + _promise->next = nullptr; + } }; - return ret{}; - } -}; + return ret{this, nullptr}; + } + + virtual resumable * resume() override final { + _coroutine.resume(); + return _coroutine.promise().next; + } +}; + +struct Prod::payment_return { + int _receipt; + Prod * p; + bool await_ready() { return false; } + void await_suspend(std::experimental::coroutine_handle _coroutine) { + _coroutine.promise().next = p; + } + int await_resume() { return _receipt; } +}; + +Prod::payment_return Prod::payment(int money) { + _coroutine.promise()._l.money = money; + return payment_return{ _coroutine.promise()._l.receipt, this }; +} Prod Prod::main() { @@ -176,11 +209,11 @@ for(int i = 0; i < p.N; i++) { int p1 = random(100), p2 = random(100); - std::cout << p1 << " " << p2; + std::cout << p1 << " " << p2 << std::endl; int status = co_await p.c->deliver(p1, p2); - std::cout << " $" << p.money << std::endl << status; + std::cout << " $" << p.money << std::endl << status << std::endl; p.receipt += 1; } co_await p.c->stop(); - std::cout << "prod stops"; + std::cout << "prod stops" << std::endl; } @@ -189,11 +222,16 @@ int money = 1, receipt; for(;!c.done ;) { - std::cout << c.p1 << " " << c.p2 << std::endl << " $" << money; + std::cout << c.p1 << " " << c.p2 << std::endl; + std::cout << " $ " << money << std::endl; c.status += 1; receipt = co_await c.p->payment( money ); - std::cout << " #" << receipt; + std::cout << " # " << receipt << std::endl; money += 1; } - std::cout << "const stops"; + std::cout << "cons stops" << std::endl; +} + +void dispatch(resumable * r) { + while((r = r->resume())); } @@ -203,3 +241,4 @@ srandom( getpid() ); prod.start(5, cons); -} + dispatch(&prod); +} Index: doc/papers/concurrency/examples/ProdCons.py =================================================================== --- doc/papers/concurrency/examples/ProdCons.py (revision 86fb8f2eb09b7e86dbe5a9c58b2ef0fae49bfee9) +++ doc/papers/concurrency/examples/ProdCons.py (revision 86fb8f2eb09b7e86dbe5a9c58b2ef0fae49bfee9) @@ -0,0 +1,40 @@ +def Prod( N ): + cons = (yield) # get cons + yield # resume scheduler + for i in range( N ): + print( "prod" ) + yield cons # execute next + print( "end", "prod" ) + +def Cons( N ): + prod = (yield) # get prod + yield # resume scheduler + for i in range( N ): + print( "cons" ) + yield prod # execute next + print( "end", "cons" ) + +def Scheduler(): + n = (yield) # starting coroutine + while True: + n = next( n ) # schedule coroutine + +prod = Prod( 5 ) +cons = Cons( 5 ) +next( prod ) # prime +prod.send( cons ) # send cons +next( cons ) # prime +cons.send( prod ) # send prod + +s = Scheduler(); +next( s ) # prime +try: + s.send( prod ) # start cycle +except StopIteration: + print( "scheduler stop" ) +print( "stop" ) + +# Local Variables: # +# tab-width: 4 # +# compile-command: "python3.5 ProdCons.py" # +# End: # Index: doc/user/user.tex =================================================================== --- doc/user/user.tex (revision 2b10f958db325dea85128cd85f1c1c9c8a596962) +++ doc/user/user.tex (revision 86fb8f2eb09b7e86dbe5a9c58b2ef0fae49bfee9) @@ -11,6 +11,6 @@ %% Created On : Wed Apr 6 14:53:29 2016 %% Last Modified By : Peter A. Buhr -%% Last Modified On : Tue Dec 11 23:19:26 2018 -%% Update Count : 3400 +%% Last Modified On : Tue Mar 26 22:10:49 2019 +%% Update Count : 3411 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @@ -508,16 +508,21 @@ As for \Index{division}, there are exponentiation operators for integral and floating types, including the builtin \Index{complex} types. -Unsigned integral exponentiation\index{exponentiation!unsigned integral} is performed with repeated multiplication\footnote{The multiplication computation is $O(\log y)$.} (or shifting if the base is 2). -Signed integral exponentiation\index{exponentiation!signed integral} is performed with repeated multiplication (or shifting if the base is 2), but yields a floating result because $x^{-y}=1/x^y$. -Hence, it is important to designate exponent integral-constants as unsigned or signed: ©3 \ 3u© return an integral result, while ©3 \ 3© returns a floating result. -Floating exponentiation\index{exponentiation!floating} is performed using \Index{logarithm}s\index{exponentiation!logarithm}, so the base cannot be negative. -\begin{cfa} -sout | 2 ®\® 8u | 4 ®\® 3u | -4 ®\® 3u | 4 ®\® -3 | -4 ®\® -3 | 4.0 ®\® 2.1 | (1.0f+2.0fi) ®\® (3.0f+2.0fi); -256 64 -64 0.015625 -0.015625 18.3791736799526 0.264715-1.1922i +Integral exponentiation\index{exponentiation!unsigned integral} is performed with repeated multiplication\footnote{The multiplication computation is $O(\log y)$.} (or shifting if the exponent is 2). +Overflow from large exponents or negative exponents return zero. +Floating exponentiation\index{exponentiation!floating} is performed using \Index{logarithm}s\index{exponentiation!logarithm}, so the exponent cannot be negative. +\begin{cfa} +sout | 1 ®\® 0 | 1 ®\® 1 | 2 ®\® 8 | -4 ®\® 3 | 5 ®\® 3 | 5 ®\® 32 | 5L ®\® 32 | 5L ®\® 64 | -4 ®\® -3 | -4.0 ®\® -3 | 4.0 ®\® 2.1 + | (1.0f+2.0fi) ®\® (3.0f+2.0fi); +1 1 256 -64 125 0 3273344365508751233 0 0 -0.015625 18.3791736799526 0.264715-1.1922i \end{cfa} Parenthesis are necessary for complex constants or the expression is parsed as ©1.0f+®(®2.0fi \ 3.0f®)®+2.0fi©. -The exponentiation operator is available for all the basic types, but for user-defined types, only the integral-computation versions are available. -For returning an integral value, the user type ©T© must define multiplication, ©*©, and one, ©1©; -for returning a floating value, an additional divide of type ©T© into a ©double© returning a ©double© (©double ?/?( double, T )©) is necessary for negative exponents. +The exponentiation operator is available for all the basic types, but for user-defined types, only the integral-computation version is available. +\begin{cfa} +forall( otype OT | { void ?{}( OT & this, one_t ); OT ?*?( OT, OT ); } ) +OT ?®\®?( OT ep, unsigned int y ); +forall( otype OT | { void ?{}( OT & this, one_t ); OT ?*?( OT, OT ); } ) +OT ?®\®?( OT ep, unsigned long int y ); +\end{cfa} +The user type ©T© must define multiplication one, ©1©, and, ©*©. @@ -1320,5 +1325,8 @@ \end{cfa} Essentially, the return type is wrapped around the routine name in successive layers (like an \Index{onion}). -While attempting to make the two contexts consistent is a laudable goal, it has not worked out in practice. +While attempting to make the two contexts consistent is a laudable goal, it has not worked out in practice, even though Dennis Richie believed otherwise: +\begin{quote} +In spite of its difficulties, I believe that the C's approach to declarations remains plausible, and am comfortable with it; it is a useful unifying principle.~\cite[p.~12]{Ritchie93} +\end{quote} \CFA provides its own type, variable and routine declarations, using a different syntax. Index: libcfa/prelude/builtins.c =================================================================== --- libcfa/prelude/builtins.c (revision 2b10f958db325dea85128cd85f1c1c9c8a596962) +++ libcfa/prelude/builtins.c (revision 86fb8f2eb09b7e86dbe5a9c58b2ef0fae49bfee9) @@ -10,6 +10,6 @@ // Created On : Fri Jul 21 16:21:03 2017 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun Mar 10 10:52:50 2019 -// Update Count : 31 +// Last Modified On : Tue Mar 26 23:10:36 2019 +// Update Count : 95 // @@ -18,4 +18,5 @@ typedef unsigned long long __cfaabi_abi_exception_type_t; +#include // CHAR_BIT #include "../src/virtual.h" #include "../src/exception.h" @@ -26,19 +27,21 @@ // increment/decrement unification -static inline forall( dtype T | { T & ?+=?( T &, one_t ); } ) -T & ++? ( T & x ) { return x += 1; } +static inline { + forall( dtype DT | { DT & ?+=?( DT &, one_t ); } ) + DT & ++?( DT & x ) { return x += 1; } -static inline forall( dtype T | sized(T) | { void ?{}( T &, T ); void ^?{}( T & ); T & ?+=?( T &, one_t ); } ) -T & ?++ ( T & x ) { T tmp = x; x += 1; return tmp; } + forall( dtype DT | sized(DT) | { void ?{}( DT &, DT ); void ^?{}( DT & ); DT & ?+=?( DT &, one_t ); } ) + DT & ?++( DT & x ) { DT tmp = x; x += 1; return tmp; } -static inline forall( dtype T | { T & ?-=?( T &, one_t ); } ) -T & --? ( T & x ) { return x -= 1; } + forall( dtype DT | { DT & ?-=?( DT &, one_t ); } ) + DT & --?( DT & x ) { return x -= 1; } -static inline forall( dtype T | sized(T) | { void ?{}( T &, T ); void ^?{}( T & ); T & ?-=?( T &, one_t ); } ) -T & ?-- ( T & x ) { T tmp = x; x -= 1; return tmp; } + forall( dtype DT | sized(DT) | { void ?{}( DT &, DT ); void ^?{}( DT & ); DT & ?-=?( DT &, one_t ); } ) + DT & ?--( DT & x ) { DT tmp = x; x -= 1; return tmp; } +} // distribution // universal typed pointer constant - -static inline forall( dtype T ) T * intptr( uintptr_t addr ) { return (T *)addr; } +// Compiler issue: there is a problem with anonymous types that do not have a size. +static inline forall( dtype DT | sized(DT) ) DT * intptr( uintptr_t addr ) { return (DT *)addr; } // exponentiation operator implementation @@ -53,65 +56,59 @@ } // extern "C" -static inline float ?\?( float x, float y ) { return powf( x, y ); } -static inline double ?\?( double x, double y ) { return pow( x, y ); } -static inline long double ?\?( long double x, long double y ) { return powl( x, y ); } -static inline float _Complex ?\?( float _Complex x, _Complex float y ) { return cpowf(x, y ); } -static inline double _Complex ?\?( double _Complex x, _Complex double y ) { return cpow( x, y ); } -static inline long double _Complex ?\?( long double _Complex x, _Complex long double y ) { return cpowl( x, y ); } +static inline { + float ?\?( float x, float y ) { return powf( x, y ); } + double ?\?( double x, double y ) { return pow( x, y ); } + long double ?\?( long double x, long double y ) { return powl( x, y ); } + float _Complex ?\?( float _Complex x, _Complex float y ) { return cpowf(x, y ); } + double _Complex ?\?( double _Complex x, _Complex double y ) { return cpow( x, y ); } + long double _Complex ?\?( long double _Complex x, _Complex long double y ) { return cpowl( x, y ); } +} // distribution -static inline long int ?\?( long int ep, unsigned long int y ) { // disallow negative exponent - if ( y == 0 ) return 1; // base case - if ( ep == 2 ) return ep << (y - 1); // special case, positive shifting only - typeof( ep ) op = 1; // accumulate odd product - for ( ; y > 1; y >>= 1 ) { // squaring exponentiation, O(log2 y) - if ( (y & 1) == 1 ) op *= ep; // odd ? - ep *= ep; - } // for - return ep * op; -} // ?\? +#define __CFA_BASE_COMP_1__() if ( ep == 1 ) return 1 +#define __CFA_BASE_COMP_2__() if ( ep == 2 ) return ep << (y - 1) +#define __CFA_EXP_OVERFLOW__() if ( y >= sizeof(y) * CHAR_BIT ) return 0 -static inline forall( otype T | { void ?{}( T & this, one_t ); T ?*?( T, T ); } ) -T ?\?( T ep, unsigned long int y ) { - if ( y == 0 ) return 1; - T op = 1; - for ( ; y > 1; y >>= 1 ) { // squaring exponentiation, O(log2 y) - if ( (y & 1) == 1 ) op = op * ep; // odd ? - ep = ep * ep; - } // for - return ep * op; -} // ?\? +#define __CFA_EXP__() \ + if ( y == 0 ) return 1; /* convention */ \ + __CFA_BASE_COMP_1__(); /* base case */ \ + __CFA_BASE_COMP_2__(); /* special case, positive shifting for integral types */ \ + __CFA_EXP_OVERFLOW__(); /* immediate overflow, negative exponent > 2^size-1 */ \ + typeof(ep) op = 1; /* accumulate odd product */ \ + for ( ; y > 1; y >>= 1 ) { /* squaring exponentiation, O(log2 y) */ \ + if ( (y & 1) == 1 ) op = op * ep; /* odd ? */ \ + ep = ep * ep; \ + } \ + return ep * op -// unsigned computation may be faster and larger -static inline unsigned long int ?\?( unsigned long int ep, unsigned long int y ) { // disallow negative exponent - if ( y == 0 ) return 1; // base case - if ( ep == 2 ) return ep << (y - 1); // special case, positive shifting only - typeof( ep ) op = 1; // accumulate odd product - for ( ; y > 1; y >>= 1 ) { // squaring exponentiation, O(log2 y) - if ( (y & 1) == 1 ) op *= ep; // odd ? - ep *= ep; - } // for - return ep * op; -} // ?\? +static inline { + long int ?\?( int ep, unsigned int y ) { __CFA_EXP__(); } + long int ?\?( long int ep, unsigned long int y ) { __CFA_EXP__(); } + // unsigned computation may be faster and larger + unsigned long int ?\?( unsigned int ep, unsigned int y ) { __CFA_EXP__(); } + unsigned long int ?\?( unsigned long int ep, unsigned long int y ) { __CFA_EXP__(); } +} // distribution -static inline double ?\?( long int x, signed long int y ) { // allow negative exponent - if ( y >= 0 ) return (double)(x \ (unsigned long int)y); - else return 1.0 / x \ (unsigned int)(-y); -} // ?\? +#undef __CFA_BASE_COMP_1__ +#undef __CFA_BASE_COMP_2__ +#undef __CFA_EXP_OVERFLOW__ +#define __CFA_BASE_COMP_1__() +#define __CFA_BASE_COMP_2__() +#define __CFA_EXP_OVERFLOW__() -// FIXME (x \ (unsigned long int)y) relies on X ?\?(T, unsigned long) a function that is neither -// defined, nor passed as an assertion parameter. Without user-defined conversions, cannot specify -// X as a type that casts to double, yet it doesn't make sense to write functions with that type -// signature where X is double. +static inline forall( otype 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__(); } +} // distribution -// static inline forall( otype T | { void ?{}( T & this, one_t ); T ?*?( T, T ); double ?/?( double, T ); } ) -// double ?\?( T x, signed long int y ) { -// if ( y >= 0 ) return (double)(x \ (unsigned long int)y); -// else return 1.0 / x \ (unsigned long int)(-y); -// } // ?\? +#undef __CFA_BASE_COMP_1__ +#undef __CFA_BASE_COMP_2__ +#undef __CFA_EXP_OVERFLOW__ -static inline long int ?\=?( long int & x, unsigned long int y ) { x = x \ y; return x; } -static inline unsigned long int ?\=?( unsigned long int & x, unsigned long int y ) { x = x \ y; return x; } -static inline int ?\=?( int & x, unsigned long int y ) { x = x \ y; return x; } -static inline unsigned int ?\=?( unsigned int & x, unsigned long int y ) { x = x \ y; return x; } +static inline { + long int ?\=?( long int & x, unsigned long int y ) { x = x \ y; return x; } + unsigned long int ?\=?( unsigned long int & x, unsigned long int y ) { x = x \ y; return x; } + int ?\=?( int & x, unsigned long int y ) { x = x \ y; return x; } + unsigned int ?\=?( unsigned int & x, unsigned long int y ) { x = x \ y; return x; } +} // distribution // Local Variables: // Index: libcfa/src/rational.cfa =================================================================== --- libcfa/src/rational.cfa (revision 2b10f958db325dea85128cd85f1c1c9c8a596962) +++ libcfa/src/rational.cfa (revision 86fb8f2eb09b7e86dbe5a9c58b2ef0fae49bfee9) @@ -10,6 +10,6 @@ // Created On : Wed Apr 6 17:54:28 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun Dec 23 22:56:49 2018 -// Update Count : 170 +// Last Modified On : Wed Mar 27 08:45:59 2019 +// Update Count : 180 // @@ -54,6 +54,5 @@ void ?{}( Rational(RationalImpl) & r, RationalImpl n, RationalImpl d ) { RationalImpl t = simplify( n, d ); // simplify - r.numerator = n / t; - r.denominator = d / t; + r.[numerator, denominator] = [n / t, d / t]; } // rational @@ -78,6 +77,5 @@ RationalImpl prev = r.numerator; RationalImpl t = gcd( abs( n ), r.denominator ); // simplify - r.numerator = n / t; - r.denominator = r.denominator / t; + r.[numerator, denominator] = [n / t, r.denominator / t]; return prev; } // numerator @@ -86,6 +84,5 @@ RationalImpl prev = r.denominator; RationalImpl t = simplify( r.numerator, d ); // simplify - r.numerator = r.numerator / t; - r.denominator = d / t; + r.[numerator, denominator] = [r.numerator / t, d / t]; return prev; } // denominator @@ -120,20 +117,16 @@ Rational(RationalImpl) +?( Rational(RationalImpl) r ) { - Rational(RationalImpl) t = { r.numerator, r.denominator }; - return t; + return (Rational(RationalImpl)){ r.numerator, r.denominator }; } // +? Rational(RationalImpl) -?( Rational(RationalImpl) r ) { - Rational(RationalImpl) t = { -r.numerator, r.denominator }; - return t; + return (Rational(RationalImpl)){ -r.numerator, r.denominator }; } // -? Rational(RationalImpl) ?+?( Rational(RationalImpl) l, Rational(RationalImpl) r ) { if ( l.denominator == r.denominator ) { // special case - Rational(RationalImpl) t = { l.numerator + r.numerator, l.denominator }; - return t; + return (Rational(RationalImpl)){ l.numerator + r.numerator, l.denominator }; } else { - Rational(RationalImpl) t = { l.numerator * r.denominator + l.denominator * r.numerator, l.denominator * r.denominator }; - return t; + return (Rational(RationalImpl)){ l.numerator * r.denominator + l.denominator * r.numerator, l.denominator * r.denominator }; } // if } // ?+? @@ -141,24 +134,19 @@ Rational(RationalImpl) ?-?( Rational(RationalImpl) l, Rational(RationalImpl) r ) { if ( l.denominator == r.denominator ) { // special case - Rational(RationalImpl) t = { l.numerator - r.numerator, l.denominator }; - return t; + return (Rational(RationalImpl)){ l.numerator - r.numerator, l.denominator }; } else { - Rational(RationalImpl) t = { l.numerator * r.denominator - l.denominator * r.numerator, l.denominator * r.denominator }; - return t; + return (Rational(RationalImpl)){ l.numerator * r.denominator - l.denominator * r.numerator, l.denominator * r.denominator }; } // if } // ?-? Rational(RationalImpl) ?*?( Rational(RationalImpl) l, Rational(RationalImpl) r ) { - Rational(RationalImpl) t = { l.numerator * r.numerator, l.denominator * r.denominator }; - return t; + return (Rational(RationalImpl)){ l.numerator * r.numerator, l.denominator * r.denominator }; } // ?*? Rational(RationalImpl) ?/?( Rational(RationalImpl) l, Rational(RationalImpl) r ) { if ( r.numerator < (RationalImpl){0} ) { - r.numerator = -r.numerator; - r.denominator = -r.denominator; + r.[numerator, denominator] = [-r.numerator, -r.denominator]; } // if - Rational(RationalImpl) t = { l.numerator * r.denominator, l.denominator * r.numerator }; - return t; + return (Rational(RationalImpl)){ l.numerator * r.denominator, l.denominator * r.numerator }; } // ?/? @@ -167,7 +155,6 @@ forall( dtype istype | istream( istype ) | { istype & ?|?( istype &, RationalImpl & ); } ) istype & ?|?( istype & is, Rational(RationalImpl) & r ) { - RationalImpl t; is | r.numerator | r.denominator; - t = simplify( r.numerator, r.denominator ); + RationalImpl t = simplify( r.numerator, r.denominator ); r.numerator /= t; r.denominator /= t; @@ -185,4 +172,13 @@ } // distribution } // distribution + +forall( otype RationalImpl | arithmetic( RationalImpl ) | { RationalImpl ?\?( RationalImpl, unsigned long ); } ) +Rational(RationalImpl) ?\?( Rational(RationalImpl) x, long int y ) { + if ( y < 0 ) { + return (Rational(RationalImpl)){ x.denominator \ -y, x.numerator \ -y }; + } else { + return (Rational(RationalImpl)){ x.numerator \ y, x.denominator \ y }; + } // if +} // conversion Index: libcfa/src/rational.hfa =================================================================== --- libcfa/src/rational.hfa (revision 2b10f958db325dea85128cd85f1c1c9c8a596962) +++ libcfa/src/rational.hfa (revision 86fb8f2eb09b7e86dbe5a9c58b2ef0fae49bfee9) @@ -12,6 +12,6 @@ // Created On : Wed Apr 6 17:56:25 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Dec 4 23:07:46 2018 -// Update Count : 106 +// Last Modified On : Tue Mar 26 23:16:10 2019 +// Update Count : 109 // @@ -98,4 +98,7 @@ } // distribution +forall( otype RationalImpl | arithmetic( RationalImpl ) |{RationalImpl ?\?( RationalImpl, unsigned long );} ) +Rational(RationalImpl) ?\?( Rational(RationalImpl) x, long int y ); + // conversion forall( otype RationalImpl | arithmetic( RationalImpl ) | { double convert( RationalImpl ); } ) Index: tests/.expect/KRfunctions.x64.txt =================================================================== --- tests/.expect/KRfunctions.x64.txt (revision 2b10f958db325dea85128cd85f1c1c9c8a596962) +++ tests/.expect/KRfunctions.x64.txt (revision 86fb8f2eb09b7e86dbe5a9c58b2ef0fae49bfee9) @@ -82,7 +82,7 @@ signed int _X1ai_2; signed int _X1bi_2; - signed int *(*_tmp_cp_ret2)(signed int _X1xi_1, signed int _X1yi_1); - ((void)(_X1xFPi_ii__2=(((void)(_tmp_cp_ret2=_X3f10FFPi_ii__iPiPid__1(3, (&_X1ai_2), (&_X1bi_2), 3.5))) , _tmp_cp_ret2))); - ((void)(_tmp_cp_ret2) /* ^?{} */); + signed int *(*_tmp_cp_ret4)(signed int _X1xi_1, signed int _X1yi_1); + ((void)(_X1xFPi_ii__2=(((void)(_tmp_cp_ret4=_X3f10FFPi_ii__iPiPid__1(3, (&_X1ai_2), (&_X1bi_2), 3.5))) , _tmp_cp_ret4))); + ((void)(_tmp_cp_ret4) /* ^?{} */); const signed int _X2f1Fi_iPiPi__2(signed int _X1ai_2, signed int *_X1bPi_2, signed int *_X1cPi_2){ __attribute__ ((unused)) const signed int _X10_retval_f1Ki_2; Index: tests/.expect/completeTypeError.txt =================================================================== --- tests/.expect/completeTypeError.txt (revision 2b10f958db325dea85128cd85f1c1c9c8a596962) +++ tests/.expect/completeTypeError.txt (revision 86fb8f2eb09b7e86dbe5a9c58b2ef0fae49bfee9) @@ -87,5 +87,5 @@ void ) - Environment:( _74_0_T ) -> instance of type T (not function type) (no widening) + Environment:( _99_0_T ) -> instance of type T (not function type) (no widening) Index: tests/.expect/declarationSpecifier.x64.txt =================================================================== --- tests/.expect/declarationSpecifier.x64.txt (revision 2b10f958db325dea85128cd85f1c1c9c8a596962) +++ tests/.expect/declarationSpecifier.x64.txt (revision 86fb8f2eb09b7e86dbe5a9c58b2ef0fae49bfee9) @@ -698,7 +698,7 @@ signed int main(signed int _X4argci_1, char **_X4argvPPc_1, char **_X4envpPPc_1){ __attribute__ ((unused)) signed int _X12_retval_maini_1; - signed int _tmp_cp_ret2; - ((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret2=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret2)) /* ?{} */); - ((void)(_tmp_cp_ret2) /* ^?{} */); + signed int _tmp_cp_ret4; + ((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret4=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret4)) /* ?{} */); + ((void)(_tmp_cp_ret4) /* ^?{} */); return _X12_retval_maini_1; } Index: tests/.expect/extension.x64.txt =================================================================== --- tests/.expect/extension.x64.txt (revision 2b10f958db325dea85128cd85f1c1c9c8a596962) +++ tests/.expect/extension.x64.txt (revision 86fb8f2eb09b7e86dbe5a9c58b2ef0fae49bfee9) @@ -186,7 +186,7 @@ __extension__ signed int _X1ci_2; ((void)(__extension__ _X1ai_2=(__extension__ _X1bi_2+__extension__ _X1ci_2))); - signed int _tmp_cp_ret2; - ((void)(((void)(_tmp_cp_ret2=__extension__ _X4fredFi_i__1(3))) , _tmp_cp_ret2)); - ((void)(_tmp_cp_ret2) /* ^?{} */); + signed int _tmp_cp_ret4; + ((void)(((void)(_tmp_cp_ret4=__extension__ _X4fredFi_i__1(3))) , _tmp_cp_ret4)); + ((void)(_tmp_cp_ret4) /* ^?{} */); __extension__ signed int _X4maryFi_i__2(signed int _X1pi_2){ __attribute__ ((unused)) signed int _X12_retval_maryi_2; Index: tests/.expect/gccExtensions.x64.txt =================================================================== --- tests/.expect/gccExtensions.x64.txt (revision 2b10f958db325dea85128cd85f1c1c9c8a596962) +++ tests/.expect/gccExtensions.x64.txt (revision 86fb8f2eb09b7e86dbe5a9c58b2ef0fae49bfee9) @@ -171,7 +171,7 @@ signed int main(signed int _X4argci_1, char **_X4argvPPc_1, char **_X4envpPPc_1){ __attribute__ ((unused)) signed int _X12_retval_maini_1; - signed int _tmp_cp_ret2; - ((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret2=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret2)) /* ?{} */); - ((void)(_tmp_cp_ret2) /* ^?{} */); + signed int _tmp_cp_ret4; + ((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret4=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret4)) /* ?{} */); + ((void)(_tmp_cp_ret4) /* ^?{} */); return _X12_retval_maini_1; } Index: tests/.expect/math1.txt =================================================================== --- tests/.expect/math1.txt (revision 2b10f958db325dea85128cd85f1c1c9c8a596962) +++ tests/.expect/math1.txt (revision 86fb8f2eb09b7e86dbe5a9c58b2ef0fae49bfee9) @@ -10,4 +10,8 @@ expm1:1.71828 1.71828182845905 1.71828182845904524 pow:1 1 1 0.273957+0.583701i 0.273957253830121+0.583700758758615i -0.638110484918098871+0.705394566961838155i -\ 16 256 -\ 912673 256 64 -64 0.015625 -0.015625 18.3791736799526 0.264715-1.1922i +16 \ 2 = 256 +912673 256 64 -64 0 0 +0.015625 -0.015625 18.3791736799526 0.264715-1.1922i +0 0 18.3791736799526 0.264715-1.1922i +16 +4 16 Index: tests/coroutine/pingpong.cfa =================================================================== --- tests/coroutine/pingpong.cfa (revision 2b10f958db325dea85128cd85f1c1c9c8a596962) +++ tests/coroutine/pingpong.cfa (revision 86fb8f2eb09b7e86dbe5a9c58b2ef0fae49bfee9) @@ -10,6 +10,6 @@ // Created On : Wed Sep 20 11:55:23 2017 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Mar 22 13:37:52 2019 -// Update Count : 30 +// Last Modified On : Tue Mar 26 17:54:14 2019 +// Update Count : 35 // @@ -20,15 +20,12 @@ const char * name; /* const */ unsigned int N; - PingPong * part; + PingPong & part; }; void ?{}( PingPong & this, const char * name, unsigned int N, PingPong & part ) { - (this.__cor){name}; - this.name = name; - this.N = N; - this.part = ∂ + this.[name, N] = [name, N]; &this.part = ∂ } void ?{}( PingPong & this, const char * name, unsigned int N ) { - this{ name, N, *(PingPong *)0 }; + this{ name, N, *0p }; // call first constructor } void cycle( PingPong & pingpong ) { @@ -36,11 +33,11 @@ } void partner( PingPong & this, PingPong & part ) { - this.part = ∂ + &this.part = ∂ resume( this ); } -void main( PingPong & pingpong ) { // ping's starter ::main, pong's starter ping - for ( pingpong.N ) { // N ping-pongs - sout | pingpong.name; - cycle( *pingpong.part ); +void main( PingPong & pingpong ) with(pingpong) { // ping's starter ::main, pong's starter ping + for ( N ) { // N ping-pongs + sout | name; + cycle( part ); } // for } Index: tests/math1.cfa =================================================================== --- tests/math1.cfa (revision 2b10f958db325dea85128cd85f1c1c9c8a596962) +++ tests/math1.cfa (revision 86fb8f2eb09b7e86dbe5a9c58b2ef0fae49bfee9) @@ -10,6 +10,6 @@ // Created On : Fri Apr 22 14:59:21 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Dec 12 16:28:49 2018 -// Update Count : 89 +// Last Modified On : Mon Mar 25 22:56:47 2019 +// Update Count : 109 // @@ -49,7 +49,19 @@ unsigned int e = 2; b \= e; - sout | "\\" | b | b \ e; - sout | "\\" | 'a' \ 3u | 2 \ 8u | 4 \ 3u | -4 \ 3u | nonl; + sout | b | "\\" | e | "= " | b \ e; + sout | 'a' \ 3 | 2 \ 8 | 4 \ 3 | -4 \ 3 | 4 \ -3 | -4 \ -3; + sout | 4.0 \ -3 | -4.0 \ -3 | 4.0 \ 2.1 | (1.0f+2.0fi) \ (3.0f+2.0fi); sout | 4 \ -3 | -4 \ -3 | 4.0 \ 2.1 | (1.0f+2.0fi) \ (3.0f+2.0fi); + + struct S { int i; }; + double ?*?( double d, S s ) { return d * s.i; } + double ?/?( double d, S s ) { return d / s.i; } + S ?\?( S s, unsigned long y ) { return (S){ s.i \ y }; } + ofstream & ?|?( ofstream & os, S s ) { return os | s.i; } + void ?|?( ofstream & os, S s ) { (ofstream &)(os | s); nl( os ); } + S s = { 4 }; + S x = s \ 2; + sout | x; + sout | s.i | s \ 2u; } // main Index: tests/rational.cfa =================================================================== --- tests/rational.cfa (revision 2b10f958db325dea85128cd85f1c1c9c8a596962) +++ tests/rational.cfa (revision 86fb8f2eb09b7e86dbe5a9c58b2ef0fae49bfee9) @@ -10,6 +10,6 @@ // Created On : Mon Mar 28 08:43:12 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Mar 19 08:30:28 2019 -// Update Count : 73 +// Last Modified On : Wed Mar 27 07:37:17 2019 +// Update Count : 80 // @@ -54,4 +54,6 @@ sout | a * b; sout | a / b; +// sout | a \ 2 | b \ 2; // FIX ME +// sout | a \ -2 | b \ -2; sout | "conversion";