Changeset 24afc53


Ignore:
Timestamp:
May 16, 2019, 1:54:43 PM (6 years ago)
Author:
Aaron Moss <a3moss@…>
Branches:
ADT, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum
Children:
1fb7bfd, f3cc5b6
Parents:
54e41b3 (diff), aa00626 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
git-author:
Aaron Moss <a3moss@…> (05/16/19 13:46:32)
git-committer:
Aaron Moss <a3moss@…> (05/16/19 13:54:43)
Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Files:
25 edited

Legend:

Unmodified
Added
Removed

  • doc/bibliography/pl.bib

    r54e41b3 r24afc53  
    19191919    year        = 1965,
    19201920    note        = {Reprinted in \cite{Genuys68} pp. 43--112.}
     1921}
     1922
     1923@manual{C++20Coroutine19,
     1924    keywords    = {coroutine},
     1925    contributer = {pabuhr@plg},
     1926    title       = {Coroutines (C++20)},
     1927    organization= {cppreference.com},
     1928    month       = apr,
     1929    year        = 2019,
     1930    note        = {\href{https://en.cppreference.com/w/cpp/language/coroutines}{https://\-en.cppreference.com/\-w/\-cpp/\-language/\-coroutines}},
    19211931}
    19221932

  • libcfa/src/concurrency/coroutine.hfa

    r54e41b3 r24afc53  
    117117// Resume implementation inlined for performance
    118118forall(dtype T | is_coroutine(T))
    119 static inline void resume(T & cor) {
     119static inline T & resume(T & cor) {
    120120        // optimization : read TLS once and reuse it
    121121        // Safety note: this is preemption safe since if
    … …  
    145145        // always done for performance testing
    146146        CoroutineCtxSwitch( src, dst );
     147
     148        return cor;
    147149}
    148150

  • libcfa/src/fstream.cfa

    r54e41b3 r24afc53  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Apr 20 12:03:43 2019
    13 // Update Count     : 311
     12// Last Modified On : Thu May 16 08:33:28 2019
     13// Update Count     : 328
    1414//
    1515
    … …  
    2727#define IO_MSG "I/O error: "
    2828
    29 void ?{}( ofstream & os, void * file, bool sepDefault, bool sepOnOff, bool nlOnOff, bool prt, const char * separator, const char * tupleSeparator ) {
     29void ?{}( ofstream & os, void * file ) {
    3030        os.file = file;
    31         os.sepDefault = sepDefault;
    32         os.sepOnOff = sepOnOff;
    33         os.nlOnOff = nlOnOff;
    34         os.prt = prt;
     31        os.sepDefault = true;
     32        os.sepOnOff = false;
     33        os.nlOnOff = true;
     34        os.prt = false;
    3535        os.sawNL = false;
    36         sepSet( os, separator );
     36        sepSet( os, " " );
    3737        sepSetCur( os, sepGet( os ) );
    38         sepSetTuple( os, tupleSeparator );
     38        sepSetTuple( os, ", " );
    3939}
    4040
    … …  
    104104
    105105void open( ofstream & os, const char * name, const char * mode ) {
    106         FILE *file = fopen( name, mode );
     106        FILE * file = fopen( name, mode );
    107107        #ifdef __CFA_DEBUG__
    108108        if ( file == 0 ) {
    … …  
    110110        } // if
    111111        #endif // __CFA_DEBUG__
    112         (os){ file, true, false, true, false, " ", ", " };
     112        (os){ file };
    113113} // open
    114114
    … …  
    152152} // fmt
    153153
    154 static ofstream soutFile = { (FILE *)(&_IO_2_1_stdout_), true, false, true, false, " ", ", " };
     154static ofstream soutFile = { (FILE *)(&_IO_2_1_stdout_) };
    155155ofstream & sout = soutFile;
    156 static ofstream serrFile = { (FILE *)(&_IO_2_1_stderr_), true, false, true, false, " ", ", " };
     156static ofstream serrFile = { (FILE *)(&_IO_2_1_stderr_) };
    157157ofstream & serr = serrFile;
    158158
     159// static ofstream sexitFile = { (FILE *)(&_IO_2_1_stdout_) };
     160// ofstream & sexit = sexitFile;
     161// static ofstream sabortFile = { (FILE *)(&_IO_2_1_stderr_) };
     162// ofstream & sabort = sabortFile;
     163
     164void nl( ofstream & os ) {
     165        if ( getANL( os ) ) (ofstream &)(nl( os ));                     // implementation only
     166        else setPrt( os, false );                                                       // turn off
     167}
    159168
    160169//---------------------------------------

  • libcfa/src/fstream.hfa

    r54e41b3 r24afc53  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Apr 20 12:03:58 2019
    13 // Update Count     : 151
     12// Last Modified On : Thu May 16 08:34:10 2019
     13// Update Count     : 157
    1414//
    1515
    … …  
    7070extern ofstream & sout, & serr;
    7171
     72// extern ofstream & sout, & serr, & sexit, & sabort;
     73// void nl( ofstream & os );
     74
    7275
    7376struct ifstream {

  • libcfa/src/iostream.cfa

    r54e41b3 r24afc53  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Apr 20 14:02:43 2019
    13 // Update Count     : 617
     12// Last Modified On : Mon May 13 12:46:45 2019
     13// Update Count     : 650
    1414//
    1515
    … …  
    2323extern size_t strlen (const char *__s) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
    2424#include <float.h>                                                                              // DBL_DIG, LDBL_DIG
     25#include <math.h>                                                                               // modff, modf, modlf
    2526#include <complex.h>                                                                    // creal, cimag
    2627}
    … …  
    156157                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    157158                fmt( os, "%g", f );
     159                float tempi;
     160                if ( isfinite( f ) && modff( f, &tempi ) == 0.0F ) fmt( os, "." ); // always print decimal point
    158161                return os;
    159162        } // ?|?
    … …  
    165168                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    166169                fmt( os, "%.*lg", DBL_DIG, d );
     170                // fmt( os, "%lg", d );
     171                double tempi;
     172                if ( isfinite( d ) && modf( d, &tempi ) == 0.0D ) fmt( os, "." ); // always print decimal point
    167173                return os;
    168174        } // ?|?
    … …  
    174180                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    175181                fmt( os, "%.*Lg", LDBL_DIG, ld );
     182                // fmt( os, "%Lg", ld );
     183                long double tempi;
     184                if ( isfinite( ld ) && modfl( ld, &tempi ) == 0.0L ) fmt( os, "." ); // always print decimal point
    176185                return os;
    177186        } // ?|?
    … …  
    182191        ostype & ?|?( ostype & os, float _Complex fc ) {
    183192                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    184                 fmt( os, "%g%+gi", crealf( fc ), cimagf( fc ) );
     193                float temp = crealf( fc ), tempi;
     194                fmt( os, "%g", temp );
     195                if ( isfinite( temp ) && modff( temp, &tempi ) == 0.0F ) fmt( os, "." ); // always print decimal point
     196                temp = cimagf( fc );
     197                fmt( os, "%+g", temp );
     198                if ( isfinite( temp ) && modff( temp, &tempi ) == 0.0F ) fmt( os, "." ); // always print decimal point
     199                fmt( os, "i" );
    185200                return os;
    186201        } // ?|?
    … …  
    191206        ostype & ?|?( ostype & os, double _Complex dc ) {
    192207                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    193                 fmt( os, "%.*lg%+.*lgi", DBL_DIG, creal( dc ), DBL_DIG, cimag( dc ) );
     208                double temp = creal( dc ), tempi;
     209                fmt( os, "%.*lg", DBL_DIG, temp );
     210                if ( isfinite( temp ) && modf( temp, &tempi ) == 0.0D ) fmt( os, "." ); // always print decimal point
     211                temp = cimag( dc );
     212                fmt( os, "%+.*lg", DBL_DIG, temp );
     213                if ( isfinite( temp ) && modf( temp, &tempi ) == 0.0D ) fmt( os, "." ); // always print decimal point
     214                fmt( os, "i" );
     215                // fmt( os, "%lg%+lgi", creal( dc ), cimag( dc ) );
    194216                return os;
    195217        } // ?|?
    … …  
    200222        ostype & ?|?( ostype & os, long double _Complex ldc ) {
    201223                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    202                 fmt( os, "%.*Lg%+.*Lgi", LDBL_DIG, creall( ldc ), LDBL_DIG, cimagl( ldc ) );
     224                long double temp = creall( ldc ), tempi;
     225                fmt( os, "%.*Lg", LDBL_DIG, temp );
     226                if ( isfinite( temp ) && modfl( temp, &tempi ) == 0.0L ) fmt( os, "." ); // always print decimal point
     227                temp = cimagl( ldc );
     228                fmt( os, "%+.*Lg", LDBL_DIG, cimagl( ldc ) );
     229                if ( isfinite( temp ) && modfl( temp, &tempi ) == 0.0L ) fmt( os, "." ); // always print decimal point
     230                fmt( os, "i" );
     231                // fmt( os, "%Lg%+Lgi", creall( ldc ), cimagl( ldc ) );
    203232                return os;
    204233        } // ?|?
    … …  
    494523        } // ?|?
    495524
    496 
    497525        // manipulators
    498526        istype & ?|?( istype & is, istype & (* manip)( istype & ) ) {
    … …  
    501529
    502530        istype & nl( istype & is ) {
    503                 fmt( is, "%*[ \t\f\n\r\v]" );                                   // ignore whitespace
     531                fmt( is, "%*[^\n]" );                                                   // ignore characters to newline
    504532                return is;
    505533        } // nl

  • libcfa/src/iostream.hfa

    r54e41b3 r24afc53  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri May  3 22:55:04 2019
    13 // Update Count     : 230
     12// Last Modified On : Sat May 11 10:31:27 2019
     13// Update Count     : 232
    1414//
    1515
    … …  
    190190
    191191        // manipulators
     192        istype & ?|?( istype &, istype & (*)( istype & ) );
     193        istype & nl( istype & is );
    192194        istype & nlOn( istype & );
    193195        istype & nlOff( istype & );
    194         istype & ?|?( istype &, istype & (*)( istype & ) );
    195         istype & nl( istype & is );
    196196} // distribution
    197197
    … …  
    215215
    216216// Local Variables: //
    217 // mode: c //
    218217// tab-width: 4 //
    219218// End: //

  • src/AST/CVQualifiers.hpp

    r54e41b3 r24afc53  
    5959        // ordering is a subtype relationship over qualifiers, e.g. `int` => `const int` is free
    6060
    61         bool operator== ( Qualifiers a, Qualifiers b ) {
    62                 return (a & EquivQualifiers) == (b & EquivQualifiers);
     61        inline bool operator== ( Qualifiers a, Qualifiers b ) {
     62                return (a.val & EquivQualifiers) == (b.val & EquivQualifiers);
    6363        }
    64         bool operator!= ( Qualifiers a, Qualifiers b ) {
    65                 return (a & EquivQualifiers) != (b & EquivQualifiers);
     64        inline bool operator!= ( Qualifiers a, Qualifiers b ) {
     65                return !(a == b);
    6666        }
    67         bool operator<= ( Qualifiers a, Qualifiers b ) {
     67        inline bool operator<= ( Qualifiers a, Qualifiers b ) {
    6868                return a.is_const    <= b.is_const    // non-const converts to const for free
    6969                        && a.is_volatile <= b.is_volatile // non-volatile converts to volatile for free
    … …  
    7171                        && a.is_atomic   == b.is_atomic;  // atomicity must be preserved in free conversion
    7272        }
    73         bool operator<  ( Qualifiers a, Qualifiers b ) { return a != b && a <= b; }
    74         bool operator>= ( Qualifiers a, Qualifiers b ) { return b <= a; }
    75         bool operator>  ( Qualifiers a, Qualifiers b ) { return b < a; }
     73        inline bool operator<  ( Qualifiers a, Qualifiers b ) { return a != b && a <= b; }
     74        inline bool operator>= ( Qualifiers a, Qualifiers b ) { return b <= a; }
     75        inline bool operator>  ( Qualifiers a, Qualifiers b ) { return b < a; }
    7676
    7777}

  • src/AST/Decl.cpp

    r54e41b3 r24afc53  
    4545}
    4646
     47// --- FunctionDecl
     48
     49const Type * FunctionDecl::get_type() const override { return type.get(); }
     50void FunctionDecl::set_type(Type * t) override { type = strict_dynamic_cast< FunctionType* >( t ); }
     51
    4752// --- TypeDecl
    4853
    4954std::string TypeDecl::typeString() const {
    5055        static const std::string kindNames[] = { "object type", "function type", "tuple type" };
    51         assertf( sizeof(kindNames)/sizeof(kindNames[0]) == DeclarationNode::NoTypeClass-1, 
     56        assertf( sizeof(kindNames)/sizeof(kindNames[0]) == DeclarationNode::NoTypeClass-1,
    5257                "typeString: kindNames is out of sync." );
    5358        assertf( kind < sizeof(kindNames)/sizeof(kindNames[0]), "TypeDecl's kind is out of bounds." );

  • src/AST/Decl.hpp

    r54e41b3 r24afc53  
    114114};
    115115
     116/// Object declaration `int foo()`
    116117class FunctionDecl : public DeclWithType {
    117118public:
    … …  
    126127          stmts( stmts ) {}
    127128
    128         const Type * get_type() const override { return type.get(); }
    129         void set_type(Type * t) override { type = strict_dynamic_cast< FunctionType* >( t ); }
     129        const Type * get_type() const override;
     130        void set_type(Type * t) override;
    130131
    131132        bool has_body() const { return stmts; }
    … …  
    184185        TypeDecl( const CodeLocation& loc, const std::string& name, Storage::Classes storage, Type* b,
    185186                TypeVar::Kind k, bool s, Type* i = nullptr )
    186         : NamedTypeDecl( loc, name, storage, b ), kind( k ), sized( k == TypeVar::Ttype || s ), 
     187        : NamedTypeDecl( loc, name, storage, b ), kind( k ), sized( k == TypeVar::Ttype || s ),
    187188          init( i ) {}
    188189

  • src/AST/Pass.hpp

    r54e41b3 r24afc53  
    2929#include "AST/Init.hpp"
    3030#include "AST/Stmt.hpp"
     31#include "AST/Type.hpp"
    3132
    3233#include "AST/Visitor.hpp"
    … …  
    189190
    190191        template< typename node_t >
    191         auto call_accept( const node_t * node ) -> decltype( node->accept(*this) );
     192        auto call_accept( const node_t * node ) -> typename std::enable_if<
     193                                !std::is_base_of<ast::Expr, node_t>::value &&
     194                                !std::is_base_of<ast::Stmt, node_t>::value
     195                        , decltype( node->accept(*this) )
     196                >::type;
    192197
    193198        template< template <class...> class container_t >

  • src/AST/Pass.impl.hpp

    r54e41b3 r24afc53  
    6464
    6565                        std::transform(decls->begin(), decls->end(), it, [](const ast::Decl * decl) -> auto {
    66                                         return new DeclStmt( decl );
     66                                        return new DeclStmt( decl->location, decl );
    6767                                });
    6868                        decls->clear();
    … …  
    119119        template< typename pass_t >
    120120        template< typename node_t >
    121         auto Pass< pass_t >::call_accept( const node_t * node ) -> decltype( node->accept(*this) ) {
     121        auto Pass< pass_t >::call_accept( const node_t * node )
     122                -> typename std::enable_if<
     123                                !std::is_base_of<ast::Expr, node_t>::value &&
     124                                !std::is_base_of<ast::Stmt, node_t>::value
     125                        , decltype( node->accept(*this) )
     126                >::type
     127
     128        {
    122129                __pedantic_pass_assert( __visit_children() );
    123130                __pedantic_pass_assert( expr );
    … …  
    296303                child_t parent_t::*child
    297304        ) {
    298                 static_assert( std::is_base_of<parent_t, node_t>::value, "Error deductiing member object" );
     305                static_assert( std::is_base_of<parent_t, node_t>::value, "Error deducing member object" );
    299306
    300307                if(__pass::skip(parent->*child)) return;
    … …  
    424431                                new ast::ArrayType(
    425432                                        new ast::BasicType( ast::BasicType::Char, ast::CV::Qualifiers( ast::CV::Const ) ),
    426                                         nullptr, true, false
     433                                        nullptr, VariableLen, DynamicDim
    427434                                )
    428435                        );
    … …  
    434441                                ValueGuard< bool > oldInFunction( inFunction );
    435442                                inFunction = true;
    436                                 maybe_accept( node, &FunctionDecl::statements );
     443                                maybe_accept( node, &FunctionDecl::stmts );
    437444                                maybe_accept( node, &FunctionDecl::attributes );
    438445                        )
    … …  
    537544
    538545        VISIT(
    539                 maybe_accept( node, &TypeDecl::assertions, *this );
     546                maybe_accept( node, &TypeDecl::assertions );
    540547
    541548                {
    … …  
    614621}
    615622
     623//--------------------------------------------------------------------------
     624// ExprStmt
     625template< typename pass_t >
     626const ast::Stmt * ast::Pass< pass_t >::visit( const ExprStmt * node ) {
     627        VISIT_START( node );
     628
     629        VISIT(
     630                maybe_accept( node, &ExprStmt::expr );
     631        )
     632
     633        VISIT_END( Stmt, node );
     634}
     635
     636//--------------------------------------------------------------------------
     637// AsmStmt
     638template< typename pass_t >
     639const ast::Stmt * ast::Pass< pass_t >::visit( const ast::AsmStmt * node ) {
     640        VISIT_START( node )
     641
     642        VISIT(
     643                maybe_accept( node, &AsmStmt::instruction );
     644                maybe_accept( node, &AsmStmt::output      );
     645                maybe_accept( node, &AsmStmt::input       );
     646                maybe_accept( node, &AsmStmt::clobber     );
     647        )
     648
     649        VISIT_END( Stmt, node );
     650}
     651
     652//--------------------------------------------------------------------------
     653// DirectiveStmt
     654template< typename pass_t >
     655const ast::Stmt * ast::Pass< pass_t >::visit( const ast::DirectiveStmt * node ) {
     656        VISIT_START( node )
     657
     658        VISIT_END( Stmt, node );
     659}
     660
     661//--------------------------------------------------------------------------
     662// IfStmt
     663template< typename pass_t >
     664const ast::Stmt * ast::Pass< pass_t >::visit( const ast::IfStmt * node ) {
     665        VISIT_START( node );
     666        VISIT({
     667                // if statements introduce a level of scope (for the initialization)
     668                guard_indexer guard { *this };
     669                maybe_accept( node, &IfStmt::inits    );
     670                maybe_accept( node, &IfStmt::cond     );
     671                maybe_accept( node, &IfStmt::thenPart );
     672                maybe_accept( node, &IfStmt::elsePart );
     673        })
     674        VISIT_END( Stmt, node );
     675}
     676
     677//--------------------------------------------------------------------------
     678// WhileStmt
     679template< typename pass_t >
     680const ast::Stmt * ast::Pass< pass_t >::visit( const WhileStmt * node ) {
     681        VISIT_START( node );
     682
     683        VISIT({
     684                // while statements introduce a level of scope (for the initialization)
     685                guard_indexer guard { *this };
     686                maybe_accept( node, &WhileStmt::inits );
     687                maybe_accept( node, &WhileStmt::cond  );
     688                maybe_accept( node, &WhileStmt::body  );
     689        })
     690
     691        VISIT_END( Stmt, node );
     692}
    616693
    617694//--------------------------------------------------------------------------
    … …  
    667744        )
    668745
    669         VISIT_END( Attribute *, node );
     746        VISIT_END( Attribute, node );
    670747}
    671748

  • src/AST/Pass.proto.hpp

    r54e41b3 r24afc53  
    241241                INDEXER_FUNC1( addUnion  , const UnionDecl *     );
    242242                INDEXER_FUNC1( addTrait  , const TraitDecl *     );
    243                 INDEXER_FUNC2( addWith   , const std::list< Expression * > &, const Node * );
     243                INDEXER_FUNC2( addWith   , const std::list< ptr<Expr> > &, const Node * );
    244244
    245245                // A few extra functions have more complicated behaviour, they are hand written

  • src/AST/Stmt.hpp

    r54e41b3 r24afc53  
    6262private:
    6363        CompoundStmt* clone() const override { return new CompoundStmt{ *this }; }
     64
     65        /// Must be copied in ALL derived classes
     66        template<typename node_t>
     67        friend auto mutate(const node_t * node);
    6468};
    6569
    … …  
    7377private:
    7478        NullStmt* clone() const override { return new NullStmt{ *this }; }
     79
     80        /// Must be copied in ALL derived classes
     81        template<typename node_t>
     82        friend auto mutate(const node_t * node);
    7583};
    7684
    … …  
    8088        ptr<Expr> expr;
    8189
    82         ExprStmt( const CodeLocation& loc, const Expr* e ) : Stmt(loc), expr(e) {}
     90        ExprStmt( const CodeLocation & loc, const Expr * e ) : Stmt(loc), expr(e) {}
    8391
    8492        const Stmt * accept( Visitor& v ) const override { return v.visit( this ); }
    8593private:
    8694        ExprStmt * clone() const override { return new ExprStmt{ *this }; }
     95
     96        /// Must be copied in ALL derived classes
     97        template<typename node_t>
     98        friend auto mutate(const node_t * node);
    8799};
    88100
    … …  
    106118private:
    107119        AsmStmt* clone() const override { return new AsmStmt{ *this }; }
     120
     121        /// Must be copied in ALL derived classes
     122        template<typename node_t>
     123        friend auto mutate(const node_t * node);
    108124};
    109125
    … …  
    119135private:
    120136        DirectiveStmt* clone() const override { return new DirectiveStmt{ *this }; }
     137
     138        /// Must be copied in ALL derived classes
     139        template<typename node_t>
     140        friend auto mutate(const node_t * node);
    121141};
    122142
    … …  
    137157private:
    138158        IfStmt* clone() const override { return new IfStmt{ *this }; }
     159
     160        /// Must be copied in ALL derived classes
     161        template<typename node_t>
     162        friend auto mutate(const node_t * node);
    139163};
    140164
    … …  
    151175private:
    152176        SwitchStmt* clone() const override { return new SwitchStmt{ *this }; }
     177
     178        /// Must be copied in ALL derived classes
     179        template<typename node_t>
     180        friend auto mutate(const node_t * node);
    153181};
    154182
    … …  
    167195private:
    168196        CaseStmt* clone() const override { return new CaseStmt{ *this }; }
     197
     198        /// Must be copied in ALL derived classes
     199        template<typename node_t>
     200        friend auto mutate(const node_t * node);
    169201};
    170202
    … …  
    184216private:
    185217        WhileStmt* clone() const override { return new WhileStmt{ *this }; }
     218
     219        /// Must be copied in ALL derived classes
     220        template<typename node_t>
     221        friend auto mutate(const node_t * node);
    186222};
    187223
    … …  
    190226        std::vector<ptr<Stmt>> inits;
    191227        ptr<Expr> cond;
    192         ptr<Expr> increment;
     228        ptr<Expr> inc;
    193229        ptr<Stmt> body;
    194230
    195231        ForStmt( const CodeLocation& loc, std::vector<ptr<Stmt>>&& inits, const Expr* cond,
    196                 const Expr* increment, const Stmt* body, std::vector<Label>&& labels = {} )
    197         : Stmt(loc, std::move(labels)), inits(std::move(inits)), cond(cond), increment(increment),
     232                const Expr* inc, const Stmt* body, std::vector<Label>&& labels = {} )
     233        : Stmt(loc, std::move(labels)), inits(std::move(inits)), cond(cond), inc(inc),
    198234          body(body) {}
    199235
    … …  
    201237private:
    202238        ForStmt* clone() const override { return new ForStmt{ *this }; }
     239
     240        /// Must be copied in ALL derived classes
     241        template<typename node_t>
     242        friend auto mutate(const node_t * node);
    203243};
    204244
    … …  
    225265private:
    226266        BranchStmt* clone() const override { return new BranchStmt{ *this }; }
     267
     268        /// Must be copied in ALL derived classes
     269        template<typename node_t>
     270        friend auto mutate(const node_t * node);
     271
    227272        static const char * kindNames[kindEnd];
    228273};
    … …  
    238283private:
    239284        ReturnStmt* clone() const override { return new ReturnStmt{ *this }; }
     285
     286        /// Must be copied in ALL derived classes
     287        template<typename node_t>
     288        friend auto mutate(const node_t * node);
    240289};
    241290
    … …  
    255304private:
    256305        ThrowStmt* clone() const override { return new ThrowStmt{ *this }; }
     306
     307        /// Must be copied in ALL derived classes
     308        template<typename node_t>
     309        friend auto mutate(const node_t * node);
    257310};
    258311
    … …  
    271324private:
    272325        TryStmt* clone() const override { return new TryStmt{ *this }; }
     326
     327        /// Must be copied in ALL derived classes
     328        template<typename node_t>
     329        friend auto mutate(const node_t * node);
    273330};
    274331
    … …  
    289346private:
    290347        CatchStmt* clone() const override { return new CatchStmt{ *this }; }
     348
     349        /// Must be copied in ALL derived classes
     350        template<typename node_t>
     351        friend auto mutate(const node_t * node);
    291352};
    292353
    … …  
    302363private:
    303364        FinallyStmt* clone() const override { return new FinallyStmt{ *this }; }
     365
     366        /// Must be copied in ALL derived classes
     367        template<typename node_t>
     368        friend auto mutate(const node_t * node);
    304369};
    305370
    … …  
    338403private:
    339404        WaitForStmt* clone() const override { return new WaitForStmt{ *this }; }
     405
     406        /// Must be copied in ALL derived classes
     407        template<typename node_t>
     408        friend auto mutate(const node_t * node);
    340409};
    341410
    … …  
    352421private:
    353422        WithStmt* clone() const override { return new WithStmt{ *this }; }
     423
     424        /// Must be copied in ALL derived classes
     425        template<typename node_t>
     426        friend auto mutate(const node_t * node);
    354427};
    355428
    … …  
    364437private:
    365438        DeclStmt* clone() const override { return new DeclStmt{ *this }; }
     439
     440        /// Must be copied in ALL derived classes
     441        template<typename node_t>
     442        friend auto mutate(const node_t * node);
    366443};
    367444
    … …  
    377454private:
    378455        ImplicitCtorDtorStmt* clone() const override { return new ImplicitCtorDtorStmt{ *this }; }
     456
     457        /// Must be copied in ALL derived classes
     458        template<typename node_t>
     459        friend auto mutate(const node_t * node);
    379460};
    380461
    … …  
    390471inline void increment( const class ExprStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    391472inline void decrement( const class ExprStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    392 // inline void increment( const class AsmStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    393 // inline void decrement( const class AsmStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    394 // inline void increment( const class DirectiveStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    395 // inline void decrement( const class DirectiveStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    396 // inline void increment( const class IfStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    397 // inline void decrement( const class IfStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    398 // inline void increment( const class WhileStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    399 // inline void decrement( const class WhileStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    400 // inline void increment( const class ForStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    401 // inline void decrement( const class ForStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    402 // inline void increment( const class SwitchStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    403 // inline void decrement( const class SwitchStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    404 // inline void increment( const class CaseStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    405 // inline void decrement( const class CaseStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    406 // inline void increment( const class BranchStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    407 // inline void decrement( const class BranchStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    408 // inline void increment( const class ReturnStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    409 // inline void decrement( const class ReturnStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    410 // inline void increment( const class ThrowStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    411 // inline void decrement( const class ThrowStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    412 // inline void increment( const class TryStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    413 // inline void decrement( const class TryStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    414 // inline void increment( const class CatchStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    415 // inline void decrement( const class CatchStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    416 // inline void increment( const class FinallyStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    417 // inline void decrement( const class FinallyStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    418 // inline void increment( const class WaitForStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    419 // inline void decrement( const class WaitForStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    420 // inline void increment( const class WithStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    421 // inline void decrement( const class WithStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    422 // inline void increment( const class DeclStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    423 // inline void decrement( const class DeclStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
     473inline void increment( const class AsmStmt * node, Node::ref_type ref ) { node->increment( ref ); }
     474inline void decrement( const class AsmStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
     475inline void increment( const class DirectiveStmt * node, Node::ref_type ref ) { node->increment( ref ); }
     476inline void decrement( const class DirectiveStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
     477inline void increment( const class IfStmt * node, Node::ref_type ref ) { node->increment( ref ); }
     478inline void decrement( const class IfStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
     479inline void increment( const class WhileStmt * node, Node::ref_type ref ) { node->increment( ref ); }
     480inline void decrement( const class WhileStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
     481inline void increment( const class ForStmt * node, Node::ref_type ref ) { node->increment( ref ); }
     482inline void decrement( const class ForStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
     483inline void increment( const class SwitchStmt * node, Node::ref_type ref ) { node->increment( ref ); }
     484inline void decrement( const class SwitchStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
     485inline void increment( const class CaseStmt * node, Node::ref_type ref ) { node->increment( ref ); }
     486inline void decrement( const class CaseStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
     487inline void increment( const class BranchStmt * node, Node::ref_type ref ) { node->increment( ref ); }
     488inline void decrement( const class BranchStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
     489inline void increment( const class ReturnStmt * node, Node::ref_type ref ) { node->increment( ref ); }
     490inline void decrement( const class ReturnStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
     491inline void increment( const class ThrowStmt * node, Node::ref_type ref ) { node->increment( ref ); }
     492inline void decrement( const class ThrowStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
     493inline void increment( const class TryStmt * node, Node::ref_type ref ) { node->increment( ref ); }
     494inline void decrement( const class TryStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
     495inline void increment( const class CatchStmt * node, Node::ref_type ref ) { node->increment( ref ); }
     496inline void decrement( const class CatchStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
     497inline void increment( const class FinallyStmt * node, Node::ref_type ref ) { node->increment( ref ); }
     498inline void decrement( const class FinallyStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
     499inline void increment( const class WaitForStmt * node, Node::ref_type ref ) { node->increment( ref ); }
     500inline void decrement( const class WaitForStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
     501inline void increment( const class WithStmt * node, Node::ref_type ref ) { node->increment( ref ); }
     502inline void decrement( const class WithStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
     503inline void increment( const class DeclStmt * node, Node::ref_type ref ) { node->increment( ref ); }
     504inline void decrement( const class DeclStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    424505inline void increment( const class NullStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    425506inline void decrement( const class NullStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    426 // inline void increment( const class ImplicitCtorDtorStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    427 // inline void decrement( const class ImplicitCtorDtorStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
     507inline void increment( const class ImplicitCtorDtorStmt * node, Node::ref_type ref ) { node->increment( ref ); }
     508inline void decrement( const class ImplicitCtorDtorStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    428509
    429510}

  • src/Parser/lex.ll

    r54e41b3 r24afc53  
    1010 * Created On       : Sat Sep 22 08:58:10 2001
    1111 * Last Modified By : Peter A. Buhr
    12  * Last Modified On : Wed Mar 13 14:54:30 2019
    13  * Update Count     : 707
     12 * Last Modified On : Wed May 15 21:25:27 2019
     13 * Update Count     : 708
    1414 */
    1515
    … …  
    265265fortran                 { KEYWORD_RETURN(FORTRAN); }
    266266ftype                   { KEYWORD_RETURN(FTYPE); }                              // CFA
     267generator               { KEYWORD_RETURN(GENERATOR); }                  // CFA
    267268_Generic                { KEYWORD_RETURN(GENERIC); }                    // C11
    268269goto                    { KEYWORD_RETURN(GOTO); }

  • src/Parser/parser.yy

    r54e41b3 r24afc53  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Apr 15 15:02:56 2019
    13 // Update Count     : 4290
     12// Last Modified On : Wed May 15 21:25:27 2019
     13// Update Count     : 4296
    1414//
    1515
    … …  
    173173DeclarationNode * fieldDecl( DeclarationNode * typeSpec, DeclarationNode * fieldList ) {
    174174        if ( ! fieldList ) {                                                            // field declarator ?
    175                 if ( ! ( typeSpec->type && typeSpec->type->kind == TypeData::Aggregate ) ) {
     175                if ( ! ( typeSpec->type && (typeSpec->type->kind == TypeData::Aggregate || typeSpec->type->kind == TypeData::Enum) ) ) {
    176176                        stringstream ss;
    177177                        typeSpec->type->print( ss );
    … …  
    275275%token ENUM STRUCT UNION
    276276%token EXCEPTION                                                                                // CFA
    277 %token COROUTINE MONITOR THREAD                                                 // CFA
     277%token GENERATOR COROUTINE MONITOR THREAD                               // CFA
    278278%token OTYPE FTYPE DTYPE TTYPE TRAIT                                    // CFA
    279279%token SIZEOF OFFSETOF
    … …  
    677677        // empty
    678678                { $$ = nullptr; }
    679         | '?'                                                                                           // CFA, default parameter
     679        | '@'                                                                                           // CFA, default parameter
    680680                { SemanticError( yylloc, "Default parameter for argument is currently unimplemented." ); $$ = nullptr; }
    681681                // { $$ = new ExpressionNode( build_constantInteger( *new string( "2" ) ) ); }
    … …  
    796796                { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
    797797                // keyword cast cannot be grouped because of reduction in aggregate_key
     798        | '(' GENERATOR '&' ')' cast_expression                         // CFA
     799                { $$ = new ExpressionNode( build_keyword_cast( KeywordCastExpr::Coroutine, $5 ) ); }
    798800        | '(' COROUTINE '&' ')' cast_expression                         // CFA
    799801                { $$ = new ExpressionNode( build_keyword_cast( KeywordCastExpr::Coroutine, $5 ) ); }
    … …  
    20612063        | EXCEPTION
    20622064                { yyy = true; $$ = DeclarationNode::Exception; }
     2065        | GENERATOR
     2066                { yyy = true; $$ = DeclarationNode::Coroutine; }
    20632067        | COROUTINE
    20642068                { yyy = true; $$ = DeclarationNode::Coroutine; }

  • tests/.expect/abs.txt

    r54e41b3 r24afc53  
    33signed long int         -65     abs 65
    44signed long long int    -65     abs 65
    5 float                   -65     abs 65
    6 double                  -65     abs 65
    7 long double             -65     abs 65
    8 float _Complex          -65-2i  abs 65.0308
    9 double _Complex         -65-2i  abs 65.0307619515564
    10 long double _Complex    -65-2i  abs 65.0307619515564342
     5float                   -65.    abs 65.
     6double                  -65.    abs 65.
     7long double             -65.    abs 65.
     8float _Complex          -65.-2.i        abs 65.0308
     9double _Complex         -65.-2.i        abs 65.0307619515564
     10long double _Complex    -65.-2.i        abs 65.0307619515564342

  • tests/.expect/ato.txt

    r54e41b3 r24afc53  
    2222-123.456789012345679 -123.45678901234567890123456789
    2323-123.456-123.456i -123.456-123.456i
    24 0+0i 2  3
     240.+0.i 2  3
    2525-123.456789012346+123.456789012346i -123.4567890123456+123.4567890123456i
    2626123.456789012345679-123.456789012345679i 123.45678901234567890123456789-123.45678901234567890123456789i

  • tests/.expect/complex.txt

    r54e41b3 r24afc53  
    11x:3+2i y:4+5i z:7+7i
    2 x:3+2i y:4+5i z:7+7i
     2x:3.+2.i y:4.+5.i z:7.+7.i
    33x:2.1+1.3i y:3.2+4.5i z:5.3+5.8i
    44x:2.1+1.3i y:3.2+4.5i z:5.3+5.8i

  • tests/.expect/identity.txt

    r54e41b3 r24afc53  
    99double                  4.1
    1010long double             4.1
    11 float _Complex          -4.1-2i
    12 double _Complex         -4.1-2i
    13 long double _Complex    -4.1-2i
     11float _Complex          -4.1-2.i
     12double _Complex         -4.1-2.i
     13long double _Complex    -4.1-2.i

  • tests/.expect/math1.txt

    r54e41b3 r24afc53  
    1 fmod:1 1 1 1 1 1
    2 remainder:-1 -1 -1
     1fmod:1. 1. 1. 1. 1. 1.
     2remainder:-1. -1. -1.
    33remquo:7 0.0999999 7 0.1 7 0.0999999999999999999
    4 div:7, 0.2 7, 0.2 7, 0.2
    5 fma:-2 -2 -2
    6 fdim:2 2 2
     4div:7., 0.2 7., 0.2 7., 0.2
     5fma:-2. -2. -2.
     6fdim:2. 2. 2.
    77nan:nan nan nan
    88exp:2.71828 2.71828182845905 2.71828182845904524 1.46869+2.28736i 1.46869393991589+2.28735528717884i 1.46869393991588516+2.28735528717884239i
    9 exp2:2 2 2
     9exp2:2. 2. 2.
    1010expm1:1.71828 1.71828182845905 1.71828182845904524
    11 pow:1 1 1 0.273957+0.583701i 0.273957253830121+0.583700758758615i -0.638110484918098871+0.705394566961838155i
     11pow:1. 1. 1. 0.273957+0.583701i 0.273957253830121+0.583700758758615i -0.638110484918098871+0.705394566961838155i
    121216 \ 2 = 256
    1313912673 256 64 -64 0 0

  • tests/.expect/math2.txt

    r54e41b3 r24afc53  
    1 log:0 0 0 0.346574+0.785398i 0.346573590279973+0.785398163397448i 0.346573590279972655+0.78539816339744831i
    2 log2:3 3 3
    3 log10:2 2 2
     1log:0. 0. 0. 0.346574+0.785398i 0.346573590279973+0.785398163397448i 0.346573590279972655+0.78539816339744831i
     2log2:3. 3. 3.
     3log10:2. 2. 2.
    44log1p:0.693147 0.693147180559945 0.693147180559945309
    55ilogb:0 0 0
    6 logb:3 3 3
    7 sqrt:1 1 1 1.09868+0.45509i 1.09868411346781+0.455089860562227i 1.09868411346780997+0.455089860562227341i
    8 cbrt:3 3 3
     6logb:3. 3. 3.
     7sqrt:1. 1. 1. 1.09868+0.45509i 1.09868411346781+0.455089860562227i 1.09868411346780997+0.455089860562227341i
     8cbrt:3. 3. 3.
    99hypot:1.41421 1.4142135623731 1.41421356237309505
    1010sin:0.841471 0.841470984807897 0.841470984807896507 1.29846+0.634964i 1.29845758141598+0.634963914784736i 1.29845758141597729+0.634963914784736108i
    … …  
    1212tan:1.55741 1.5574077246549 1.55740772465490223 0.271753+1.08392i 0.271752585319512+1.08392332733869i 0.271752585319511717+1.08392332733869454i
    1313asin:1.5708 1.5707963267949 1.57079632679489662 0.666239+1.06128i 0.666239432492515+1.06127506190504i 0.666239432492515255+1.06127506190503565i
    14 acos:0 0 0 0.904557-1.06128i 0.904556894302381-1.06127506190504i 0.904556894302381364-1.06127506190503565i
     14acos:0. 0. 0. 0.904557-1.06128i 0.904556894302381-1.06127506190504i 0.904556894302381364-1.06127506190503565i
    1515atan:0.785398 0.785398163397448 0.78539816339744831 1.01722+0.402359i 1.01722196789785+0.402359478108525i 1.01722196789785137+0.402359478108525094i
    1616atan2:0.785398 0.785398163397448 0.78539816339744831 atan:0.785398 0.785398163397448 0.78539816339744831

  • tests/.expect/math3.txt

    r54e41b3 r24afc53  
    22cosh:1.54308 1.54308063481524 1.54308063481524378 0.83373+0.988898i 0.833730025131149+0.988897705762865i 0.833730025131149049+0.988897705762865096i
    33tanh:0.761594 0.761594155955765 0.761594155955764888 1.08392+0.271753i 1.08392332733869+0.271752585319512i 1.08392332733869454+0.271752585319511717i
    4 acosh:0 0 0 1.06128+0.904557i 1.06127506190504+0.904556894302381i 1.06127506190503565+0.904556894302381364i
     4acosh:0. 0. 0. 1.06128+0.904557i 1.06127506190504+0.904556894302381i 1.06127506190503565+0.904556894302381364i
    55asinh:0.881374 0.881373587019543 0.881373587019543025 1.06128+0.666239i 1.06127506190504+0.666239432492515i 1.06127506190503565+0.666239432492515255i
    66atanh:inf inf inf 0.402359+1.01722i 0.402359478108525+1.01722196789785i 0.402359478108525094+1.01722196789785137i
    … …  
    99lgamma:1.79176 1.79175946922805 1.791759469228055
    1010lgamma:1.79176 1 1.79175946922805 1 1.791759469228055 1
    11 tgamma:6 6 6
     11tgamma:6 6. 6.

  • tests/.expect/math4.txt

    r54e41b3 r24afc53  
    1 floor:1 1 1
    2 ceil:2 2 2
    3 trunc:3 3 3
    4 rint:2 2 2
     1floor:1. 1. 1.
     2ceil:2. 2. 2.
     3trunc:3. 3. 3.
     4rint:2. 2. 2.
    55rint:2 2 2
    66rint:2 2 2
    77lrint:2 2 2
    88llrint:2 2 2
    9 nearbyint:4 4 4
    10 round:2 2 2
     9nearbyint:4. 4. 4.
     10round:2. 2. 2.
    1111round:2 2 2
    1212round:2 2 2
    1313lround:2 2 2
    1414llround:2 2 2
    15 copysign:-1 -1 -1
     15copysign:-1. -1. -1.
    1616frexp:0.5 3 0.5 3 0.5 3
    17 ldexp:8 8 8
    18 modf:2 0.3 2 0.3 2 0.3
    19 modf:2, 0.3 2, 0.3 2, 0.3
     17ldexp:8. 8. 8.
     18modf:2. 0.3 2. 0.3 2. 0.3
     19modf:2., 0.3 2., 0.3 2., 0.3
    2020nextafter:2 2 2
    2121nexttoward:2 2 2
    22 scalbn:16 16 16
    23 scalbln:16 16 16
     22scalbn:16. 16. 16.
     23scalbln:16. 16. 16.

  • tests/.expect/minmax.txt

    r54e41b3 r24afc53  
    66signed long long int    4 3     min 3
    77unsigned long long int  4 3     min 3
    8 float                   4 3.1   min 3.1
    9 double                  4 3.1   min 3.1
    10 long double             4 3.1   min 3.1
     8float                   4. 3.1  min 3.1
     9double                  4. 3.1  min 3.1
     10long double             4. 3.1  min 3.1
    1111
    1212char                    z a     max z
    … …  
    1717signed long long int    4 3     max 4
    1818unsigned long long int  4 3     max 4
    19 float                   4 3.1   max 4
    20 double                  4 3.1   max 4
    21 long double             4 3.1   max 4
     19float                   4. 3.1  max 4.
     20double                  4. 3.1  max 4.
     21long double             4. 3.1  max 4.

  • tests/.expect/references.txt

    r54e41b3 r24afc53  
    35353
    36363
    37 3 9 { 1, 7 }, [1, 2, 3]
     373 9 { 1., 7. }, [1, 2, 3]
    3838Destructing a Y
    3939Destructing a Y
Note: See TracChangeset for help on using the changeset viewer.