Index: doc/bibliography/pl.bib =================================================================== --- doc/bibliography/pl.bib (revision 54e41b38e2be1b9c4d667e9c0fe4eb202e951fc7) +++ doc/bibliography/pl.bib (revision 24afc5313ce84b9962eaf6529d35b0fc0d0df58f) @@ -1919,4 +1919,14 @@ year = 1965, note = {Reprinted in \cite{Genuys68} pp. 43--112.} +} + +@manual{C++20Coroutine19, + keywords = {coroutine}, + contributer = {pabuhr@plg}, + title = {Coroutines (C++20)}, + organization= {cppreference.com}, + month = apr, + year = 2019, + note = {\href{https://en.cppreference.com/w/cpp/language/coroutines}{https://\-en.cppreference.com/\-w/\-cpp/\-language/\-coroutines}}, } Index: libcfa/src/concurrency/coroutine.hfa =================================================================== --- libcfa/src/concurrency/coroutine.hfa (revision 54e41b38e2be1b9c4d667e9c0fe4eb202e951fc7) +++ libcfa/src/concurrency/coroutine.hfa (revision 24afc5313ce84b9962eaf6529d35b0fc0d0df58f) @@ -117,5 +117,5 @@ // Resume implementation inlined for performance forall(dtype T | is_coroutine(T)) -static inline void resume(T & cor) { +static inline T & resume(T & cor) { // optimization : read TLS once and reuse it // Safety note: this is preemption safe since if @@ -145,4 +145,6 @@ // always done for performance testing CoroutineCtxSwitch( src, dst ); + + return cor; } Index: libcfa/src/fstream.cfa =================================================================== --- libcfa/src/fstream.cfa (revision 54e41b38e2be1b9c4d667e9c0fe4eb202e951fc7) +++ libcfa/src/fstream.cfa (revision 24afc5313ce84b9962eaf6529d35b0fc0d0df58f) @@ -10,6 +10,6 @@ // Created On : Wed May 27 17:56:53 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat Apr 20 12:03:43 2019 -// Update Count : 311 +// Last Modified On : Thu May 16 08:33:28 2019 +// Update Count : 328 // @@ -27,14 +27,14 @@ #define IO_MSG "I/O error: " -void ?{}( ofstream & os, void * file, bool sepDefault, bool sepOnOff, bool nlOnOff, bool prt, const char * separator, const char * tupleSeparator ) { +void ?{}( ofstream & os, void * file ) { os.file = file; - os.sepDefault = sepDefault; - os.sepOnOff = sepOnOff; - os.nlOnOff = nlOnOff; - os.prt = prt; + os.sepDefault = true; + os.sepOnOff = false; + os.nlOnOff = true; + os.prt = false; os.sawNL = false; - sepSet( os, separator ); + sepSet( os, " " ); sepSetCur( os, sepGet( os ) ); - sepSetTuple( os, tupleSeparator ); + sepSetTuple( os, ", " ); } @@ -104,5 +104,5 @@ void open( ofstream & os, const char * name, const char * mode ) { - FILE *file = fopen( name, mode ); + FILE * file = fopen( name, mode ); #ifdef __CFA_DEBUG__ if ( file == 0 ) { @@ -110,5 +110,5 @@ } // if #endif // __CFA_DEBUG__ - (os){ file, true, false, true, false, " ", ", " }; + (os){ file }; } // open @@ -152,9 +152,18 @@ } // fmt -static ofstream soutFile = { (FILE *)(&_IO_2_1_stdout_), true, false, true, false, " ", ", " }; +static ofstream soutFile = { (FILE *)(&_IO_2_1_stdout_) }; ofstream & sout = soutFile; -static ofstream serrFile = { (FILE *)(&_IO_2_1_stderr_), true, false, true, false, " ", ", " }; +static ofstream serrFile = { (FILE *)(&_IO_2_1_stderr_) }; ofstream & serr = serrFile; +// static ofstream sexitFile = { (FILE *)(&_IO_2_1_stdout_) }; +// ofstream & sexit = sexitFile; +// static ofstream sabortFile = { (FILE *)(&_IO_2_1_stderr_) }; +// ofstream & sabort = sabortFile; + +void nl( ofstream & os ) { + if ( getANL( os ) ) (ofstream &)(nl( os )); // implementation only + else setPrt( os, false ); // turn off +} //--------------------------------------- Index: libcfa/src/fstream.hfa =================================================================== --- libcfa/src/fstream.hfa (revision 54e41b38e2be1b9c4d667e9c0fe4eb202e951fc7) +++ libcfa/src/fstream.hfa (revision 24afc5313ce84b9962eaf6529d35b0fc0d0df58f) @@ -10,6 +10,6 @@ // Created On : Wed May 27 17:56:53 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat Apr 20 12:03:58 2019 -// Update Count : 151 +// Last Modified On : Thu May 16 08:34:10 2019 +// Update Count : 157 // @@ -70,4 +70,7 @@ extern ofstream & sout, & serr; +// extern ofstream & sout, & serr, & sexit, & sabort; +// void nl( ofstream & os ); + struct ifstream { Index: libcfa/src/iostream.cfa =================================================================== --- libcfa/src/iostream.cfa (revision 54e41b38e2be1b9c4d667e9c0fe4eb202e951fc7) +++ libcfa/src/iostream.cfa (revision 24afc5313ce84b9962eaf6529d35b0fc0d0df58f) @@ -10,6 +10,6 @@ // Created On : Wed May 27 17:56:53 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat Apr 20 14:02:43 2019 -// Update Count : 617 +// Last Modified On : Mon May 13 12:46:45 2019 +// Update Count : 650 // @@ -23,4 +23,5 @@ extern size_t strlen (const char *__s) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); #include // DBL_DIG, LDBL_DIG +#include // modff, modf, modlf #include // creal, cimag } @@ -156,4 +157,6 @@ if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); fmt( os, "%g", f ); + float tempi; + if ( isfinite( f ) && modff( f, &tempi ) == 0.0F ) fmt( os, "." ); // always print decimal point return os; } // ?|? @@ -165,4 +168,7 @@ if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); fmt( os, "%.*lg", DBL_DIG, d ); + // fmt( os, "%lg", d ); + double tempi; + if ( isfinite( d ) && modf( d, &tempi ) == 0.0D ) fmt( os, "." ); // always print decimal point return os; } // ?|? @@ -174,4 +180,7 @@ if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); fmt( os, "%.*Lg", LDBL_DIG, ld ); + // fmt( os, "%Lg", ld ); + long double tempi; + if ( isfinite( ld ) && modfl( ld, &tempi ) == 0.0L ) fmt( os, "." ); // always print decimal point return os; } // ?|? @@ -182,5 +191,11 @@ ostype & ?|?( ostype & os, float _Complex fc ) { if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); - fmt( os, "%g%+gi", crealf( fc ), cimagf( fc ) ); + float temp = crealf( fc ), tempi; + fmt( os, "%g", temp ); + if ( isfinite( temp ) && modff( temp, &tempi ) == 0.0F ) fmt( os, "." ); // always print decimal point + temp = cimagf( fc ); + fmt( os, "%+g", temp ); + if ( isfinite( temp ) && modff( temp, &tempi ) == 0.0F ) fmt( os, "." ); // always print decimal point + fmt( os, "i" ); return os; } // ?|? @@ -191,5 +206,12 @@ ostype & ?|?( ostype & os, double _Complex dc ) { if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); - fmt( os, "%.*lg%+.*lgi", DBL_DIG, creal( dc ), DBL_DIG, cimag( dc ) ); + double temp = creal( dc ), tempi; + fmt( os, "%.*lg", DBL_DIG, temp ); + if ( isfinite( temp ) && modf( temp, &tempi ) == 0.0D ) fmt( os, "." ); // always print decimal point + temp = cimag( dc ); + fmt( os, "%+.*lg", DBL_DIG, temp ); + if ( isfinite( temp ) && modf( temp, &tempi ) == 0.0D ) fmt( os, "." ); // always print decimal point + fmt( os, "i" ); + // fmt( os, "%lg%+lgi", creal( dc ), cimag( dc ) ); return os; } // ?|? @@ -200,5 +222,12 @@ ostype & ?|?( ostype & os, long double _Complex ldc ) { if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); - fmt( os, "%.*Lg%+.*Lgi", LDBL_DIG, creall( ldc ), LDBL_DIG, cimagl( ldc ) ); + long double temp = creall( ldc ), tempi; + fmt( os, "%.*Lg", LDBL_DIG, temp ); + if ( isfinite( temp ) && modfl( temp, &tempi ) == 0.0L ) fmt( os, "." ); // always print decimal point + temp = cimagl( ldc ); + fmt( os, "%+.*Lg", LDBL_DIG, cimagl( ldc ) ); + if ( isfinite( temp ) && modfl( temp, &tempi ) == 0.0L ) fmt( os, "." ); // always print decimal point + fmt( os, "i" ); + // fmt( os, "%Lg%+Lgi", creall( ldc ), cimagl( ldc ) ); return os; } // ?|? @@ -494,5 +523,4 @@ } // ?|? - // manipulators istype & ?|?( istype & is, istype & (* manip)( istype & ) ) { @@ -501,5 +529,5 @@ istype & nl( istype & is ) { - fmt( is, "%*[ \t\f\n\r\v]" ); // ignore whitespace + fmt( is, "%*[^\n]" ); // ignore characters to newline return is; } // nl Index: libcfa/src/iostream.hfa =================================================================== --- libcfa/src/iostream.hfa (revision 54e41b38e2be1b9c4d667e9c0fe4eb202e951fc7) +++ libcfa/src/iostream.hfa (revision 24afc5313ce84b9962eaf6529d35b0fc0d0df58f) @@ -10,6 +10,6 @@ // Created On : Wed May 27 17:56:53 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri May 3 22:55:04 2019 -// Update Count : 230 +// Last Modified On : Sat May 11 10:31:27 2019 +// Update Count : 232 // @@ -190,8 +190,8 @@ // manipulators + istype & ?|?( istype &, istype & (*)( istype & ) ); + istype & nl( istype & is ); istype & nlOn( istype & ); istype & nlOff( istype & ); - istype & ?|?( istype &, istype & (*)( istype & ) ); - istype & nl( istype & is ); } // distribution @@ -215,5 +215,4 @@ // Local Variables: // -// mode: c // // tab-width: 4 // // End: // Index: src/AST/CVQualifiers.hpp =================================================================== --- src/AST/CVQualifiers.hpp (revision 54e41b38e2be1b9c4d667e9c0fe4eb202e951fc7) +++ src/AST/CVQualifiers.hpp (revision 24afc5313ce84b9962eaf6529d35b0fc0d0df58f) @@ -59,11 +59,11 @@ // ordering is a subtype relationship over qualifiers, e.g. `int` => `const int` is free - bool operator== ( Qualifiers a, Qualifiers b ) { - return (a & EquivQualifiers) == (b & EquivQualifiers); + inline bool operator== ( Qualifiers a, Qualifiers b ) { + return (a.val & EquivQualifiers) == (b.val & EquivQualifiers); } - bool operator!= ( Qualifiers a, Qualifiers b ) { - return (a & EquivQualifiers) != (b & EquivQualifiers); + inline bool operator!= ( Qualifiers a, Qualifiers b ) { + return !(a == b); } - bool operator<= ( Qualifiers a, Qualifiers b ) { + inline bool operator<= ( Qualifiers a, Qualifiers b ) { return a.is_const <= b.is_const // non-const converts to const for free && a.is_volatile <= b.is_volatile // non-volatile converts to volatile for free @@ -71,7 +71,7 @@ && a.is_atomic == b.is_atomic; // atomicity must be preserved in free conversion } - bool operator< ( Qualifiers a, Qualifiers b ) { return a != b && a <= b; } - bool operator>= ( Qualifiers a, Qualifiers b ) { return b <= a; } - bool operator> ( Qualifiers a, Qualifiers b ) { return b < a; } + inline bool operator< ( Qualifiers a, Qualifiers b ) { return a != b && a <= b; } + inline bool operator>= ( Qualifiers a, Qualifiers b ) { return b <= a; } + inline bool operator> ( Qualifiers a, Qualifiers b ) { return b < a; } } Index: src/AST/Decl.cpp =================================================================== --- src/AST/Decl.cpp (revision 54e41b38e2be1b9c4d667e9c0fe4eb202e951fc7) +++ src/AST/Decl.cpp (revision 24afc5313ce84b9962eaf6529d35b0fc0d0df58f) @@ -45,9 +45,14 @@ } +// --- FunctionDecl + +const Type * FunctionDecl::get_type() const override { return type.get(); } +void FunctionDecl::set_type(Type * t) override { type = strict_dynamic_cast< FunctionType* >( t ); } + // --- TypeDecl std::string TypeDecl::typeString() const { static const std::string kindNames[] = { "object type", "function type", "tuple type" }; - assertf( sizeof(kindNames)/sizeof(kindNames[0]) == DeclarationNode::NoTypeClass-1, + assertf( sizeof(kindNames)/sizeof(kindNames[0]) == DeclarationNode::NoTypeClass-1, "typeString: kindNames is out of sync." ); assertf( kind < sizeof(kindNames)/sizeof(kindNames[0]), "TypeDecl's kind is out of bounds." ); Index: src/AST/Decl.hpp =================================================================== --- src/AST/Decl.hpp (revision 54e41b38e2be1b9c4d667e9c0fe4eb202e951fc7) +++ src/AST/Decl.hpp (revision 24afc5313ce84b9962eaf6529d35b0fc0d0df58f) @@ -114,4 +114,5 @@ }; +/// Object declaration `int foo()` class FunctionDecl : public DeclWithType { public: @@ -126,6 +127,6 @@ stmts( stmts ) {} - const Type * get_type() const override { return type.get(); } - void set_type(Type * t) override { type = strict_dynamic_cast< FunctionType* >( t ); } + const Type * get_type() const override; + void set_type(Type * t) override; bool has_body() const { return stmts; } @@ -184,5 +185,5 @@ TypeDecl( const CodeLocation& loc, const std::string& name, Storage::Classes storage, Type* b, TypeVar::Kind k, bool s, Type* i = nullptr ) - : NamedTypeDecl( loc, name, storage, b ), kind( k ), sized( k == TypeVar::Ttype || s ), + : NamedTypeDecl( loc, name, storage, b ), kind( k ), sized( k == TypeVar::Ttype || s ), init( i ) {} Index: src/AST/Pass.hpp =================================================================== --- src/AST/Pass.hpp (revision 54e41b38e2be1b9c4d667e9c0fe4eb202e951fc7) +++ src/AST/Pass.hpp (revision 24afc5313ce84b9962eaf6529d35b0fc0d0df58f) @@ -29,4 +29,5 @@ #include "AST/Init.hpp" #include "AST/Stmt.hpp" +#include "AST/Type.hpp" #include "AST/Visitor.hpp" @@ -189,5 +190,9 @@ template< typename node_t > - auto call_accept( const node_t * node ) -> decltype( node->accept(*this) ); + auto call_accept( const node_t * node ) -> typename std::enable_if< + !std::is_base_of::value && + !std::is_base_of::value + , decltype( node->accept(*this) ) + >::type; template< template class container_t > Index: src/AST/Pass.impl.hpp =================================================================== --- src/AST/Pass.impl.hpp (revision 54e41b38e2be1b9c4d667e9c0fe4eb202e951fc7) +++ src/AST/Pass.impl.hpp (revision 24afc5313ce84b9962eaf6529d35b0fc0d0df58f) @@ -64,5 +64,5 @@ std::transform(decls->begin(), decls->end(), it, [](const ast::Decl * decl) -> auto { - return new DeclStmt( decl ); + return new DeclStmt( decl->location, decl ); }); decls->clear(); @@ -119,5 +119,12 @@ template< typename pass_t > template< typename node_t > - auto Pass< pass_t >::call_accept( const node_t * node ) -> decltype( node->accept(*this) ) { + auto Pass< pass_t >::call_accept( const node_t * node ) + -> typename std::enable_if< + !std::is_base_of::value && + !std::is_base_of::value + , decltype( node->accept(*this) ) + >::type + + { __pedantic_pass_assert( __visit_children() ); __pedantic_pass_assert( expr ); @@ -296,5 +303,5 @@ child_t parent_t::*child ) { - static_assert( std::is_base_of::value, "Error deductiing member object" ); + static_assert( std::is_base_of::value, "Error deducing member object" ); if(__pass::skip(parent->*child)) return; @@ -424,5 +431,5 @@ new ast::ArrayType( new ast::BasicType( ast::BasicType::Char, ast::CV::Qualifiers( ast::CV::Const ) ), - nullptr, true, false + nullptr, VariableLen, DynamicDim ) ); @@ -434,5 +441,5 @@ ValueGuard< bool > oldInFunction( inFunction ); inFunction = true; - maybe_accept( node, &FunctionDecl::statements ); + maybe_accept( node, &FunctionDecl::stmts ); maybe_accept( node, &FunctionDecl::attributes ); ) @@ -537,5 +544,5 @@ VISIT( - maybe_accept( node, &TypeDecl::assertions, *this ); + maybe_accept( node, &TypeDecl::assertions ); { @@ -614,4 +621,74 @@ } +//-------------------------------------------------------------------------- +// ExprStmt +template< typename pass_t > +const ast::Stmt * ast::Pass< pass_t >::visit( const ExprStmt * node ) { + VISIT_START( node ); + + VISIT( + maybe_accept( node, &ExprStmt::expr ); + ) + + VISIT_END( Stmt, node ); +} + +//-------------------------------------------------------------------------- +// AsmStmt +template< typename pass_t > +const ast::Stmt * ast::Pass< pass_t >::visit( const ast::AsmStmt * node ) { + VISIT_START( node ) + + VISIT( + maybe_accept( node, &AsmStmt::instruction ); + maybe_accept( node, &AsmStmt::output ); + maybe_accept( node, &AsmStmt::input ); + maybe_accept( node, &AsmStmt::clobber ); + ) + + VISIT_END( Stmt, node ); +} + +//-------------------------------------------------------------------------- +// DirectiveStmt +template< typename pass_t > +const ast::Stmt * ast::Pass< pass_t >::visit( const ast::DirectiveStmt * node ) { + VISIT_START( node ) + + VISIT_END( Stmt, node ); +} + +//-------------------------------------------------------------------------- +// IfStmt +template< typename pass_t > +const ast::Stmt * ast::Pass< pass_t >::visit( const ast::IfStmt * node ) { + VISIT_START( node ); + VISIT({ + // if statements introduce a level of scope (for the initialization) + guard_indexer guard { *this }; + maybe_accept( node, &IfStmt::inits ); + maybe_accept( node, &IfStmt::cond ); + maybe_accept( node, &IfStmt::thenPart ); + maybe_accept( node, &IfStmt::elsePart ); + }) + VISIT_END( Stmt, node ); +} + +//-------------------------------------------------------------------------- +// WhileStmt +template< typename pass_t > +const ast::Stmt * ast::Pass< pass_t >::visit( const WhileStmt * node ) { + VISIT_START( node ); + + VISIT({ + // while statements introduce a level of scope (for the initialization) + guard_indexer guard { *this }; + maybe_accept( node, &WhileStmt::inits ); + maybe_accept( node, &WhileStmt::cond ); + maybe_accept( node, &WhileStmt::body ); + }) + + VISIT_END( Stmt, node ); +} //-------------------------------------------------------------------------- @@ -667,5 +744,5 @@ ) - VISIT_END( Attribute *, node ); + VISIT_END( Attribute, node ); } Index: src/AST/Pass.proto.hpp =================================================================== --- src/AST/Pass.proto.hpp (revision 54e41b38e2be1b9c4d667e9c0fe4eb202e951fc7) +++ src/AST/Pass.proto.hpp (revision 24afc5313ce84b9962eaf6529d35b0fc0d0df58f) @@ -241,5 +241,5 @@ INDEXER_FUNC1( addUnion , const UnionDecl * ); INDEXER_FUNC1( addTrait , const TraitDecl * ); - INDEXER_FUNC2( addWith , const std::list< Expression * > &, const Node * ); + INDEXER_FUNC2( addWith , const std::list< ptr > &, const Node * ); // A few extra functions have more complicated behaviour, they are hand written Index: src/AST/Stmt.hpp =================================================================== --- src/AST/Stmt.hpp (revision 54e41b38e2be1b9c4d667e9c0fe4eb202e951fc7) +++ src/AST/Stmt.hpp (revision 24afc5313ce84b9962eaf6529d35b0fc0d0df58f) @@ -62,4 +62,8 @@ private: CompoundStmt* clone() const override { return new CompoundStmt{ *this }; } + + /// Must be copied in ALL derived classes + template + friend auto mutate(const node_t * node); }; @@ -73,4 +77,8 @@ private: NullStmt* clone() const override { return new NullStmt{ *this }; } + + /// Must be copied in ALL derived classes + template + friend auto mutate(const node_t * node); }; @@ -80,9 +88,13 @@ ptr expr; - ExprStmt( const CodeLocation& loc, const Expr* e ) : Stmt(loc), expr(e) {} + ExprStmt( const CodeLocation & loc, const Expr * e ) : Stmt(loc), expr(e) {} const Stmt * accept( Visitor& v ) const override { return v.visit( this ); } private: ExprStmt * clone() const override { return new ExprStmt{ *this }; } + + /// Must be copied in ALL derived classes + template + friend auto mutate(const node_t * node); }; @@ -106,4 +118,8 @@ private: AsmStmt* clone() const override { return new AsmStmt{ *this }; } + + /// Must be copied in ALL derived classes + template + friend auto mutate(const node_t * node); }; @@ -119,4 +135,8 @@ private: DirectiveStmt* clone() const override { return new DirectiveStmt{ *this }; } + + /// Must be copied in ALL derived classes + template + friend auto mutate(const node_t * node); }; @@ -137,4 +157,8 @@ private: IfStmt* clone() const override { return new IfStmt{ *this }; } + + /// Must be copied in ALL derived classes + template + friend auto mutate(const node_t * node); }; @@ -151,4 +175,8 @@ private: SwitchStmt* clone() const override { return new SwitchStmt{ *this }; } + + /// Must be copied in ALL derived classes + template + friend auto mutate(const node_t * node); }; @@ -167,4 +195,8 @@ private: CaseStmt* clone() const override { return new CaseStmt{ *this }; } + + /// Must be copied in ALL derived classes + template + friend auto mutate(const node_t * node); }; @@ -184,4 +216,8 @@ private: WhileStmt* clone() const override { return new WhileStmt{ *this }; } + + /// Must be copied in ALL derived classes + template + friend auto mutate(const node_t * node); }; @@ -190,10 +226,10 @@ std::vector> inits; ptr cond; - ptr increment; + ptr inc; ptr body; ForStmt( const CodeLocation& loc, std::vector>&& inits, const Expr* cond, - const Expr* increment, const Stmt* body, std::vector