Changeset 58fe85a for src/Concurrency/Keywords.cc

Timestamp:

Jan 7, 2021, 3:27:00 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

2b4daf2, 64aeca0

Parents:

3c64c668 (diff), eef8dfb (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.

Message:

Merge branch 'master' into park_unpark

File:

• src/Concurrency/Keywords.cc (modified) (27 diffs)

src/Concurrency/Keywords.cc

@@ -16 +16 @@
 #include "Concurrency/Keywords.h"
 
-#include <cassert>                 // for assert
-#include <string>                  // for string, operator==
-
-#include "Common/PassVisitor.h"    // for PassVisitor
-#include "Common/SemanticError.h"  // for SemanticError
-#include "Common/utility.h"        // for deleteAll, map_range
-#include "CodeGen/OperatorTable.h" // for isConstructor
-#include "InitTweak/InitTweak.h"   // for getPointerBase
-#include "SynTree/LinkageSpec.h"   // for Cforall
-#include "SynTree/Constant.h"      // for Constant
-#include "SynTree/Declaration.h"   // for StructDecl, FunctionDecl, ObjectDecl
-#include "SynTree/Expression.h"    // for VariableExpr, ConstantExpr, Untype...
-#include "SynTree/Initializer.h"   // for SingleInit, ListInit, Initializer ...
-#include "SynTree/Label.h"         // for Label
-#include "SynTree/Statement.h"     // for CompoundStmt, DeclStmt, ExprStmt
-#include "SynTree/Type.h"          // for StructInstType, Type, PointerType
-#include "SynTree/Visitor.h"       // for Visitor, acceptAll
+#include <cassert>                        // for assert
+#include <string>                         // for string, operator==
+
+#include <iostream>
+
+#include "Common/Examine.h"               // for isMainFor
+#include "Common/PassVisitor.h"           // for PassVisitor
+#include "Common/SemanticError.h"         // for SemanticError
+#include "Common/utility.h"               // for deleteAll, map_range
+#include "CodeGen/OperatorTable.h"        // for isConstructor
+#include "ControlStruct/LabelGenerator.h" // for LebelGenerator
+#include "InitTweak/InitTweak.h"          // for getPointerBase
+#include "SynTree/LinkageSpec.h"          // for Cforall
+#include "SynTree/Constant.h"             // for Constant
+#include "SynTree/Declaration.h"          // for StructDecl, FunctionDecl, ObjectDecl
+#include "SynTree/Expression.h"           // for VariableExpr, ConstantExpr, Untype...
+#include "SynTree/Initializer.h"          // for SingleInit, ListInit, Initializer ...
+#include "SynTree/Label.h"                // for Label
+#include "SynTree/Statement.h"            // for CompoundStmt, DeclStmt, ExprStmt
+#include "SynTree/Type.h"                 // for StructInstType, Type, PointerType
+#include "SynTree/Visitor.h"              // for Visitor, acceptAll
+#include "Virtual/Tables.h"
 
 class Attribute;
 
 namespace Concurrency {
+        inline static std::string getVTableName( std::string const & exception_name ) {
+                return exception_name.empty() ? std::string() : Virtual::vtableTypeName(exception_name);
+        }
+
+        // Only detects threads constructed with the keyword thread.
+        inline static bool isThread( DeclarationWithType * decl ) {
+                Type * baseType = decl->get_type()->stripDeclarator();
+                StructInstType * instType = dynamic_cast<StructInstType *>( baseType );
+                if ( nullptr == instType ) { return false; }
+                return instType->baseStruct->is_thread();
+        }
+
         //=============================================================================================
         // Pass declarations
@@ -53 +70 @@
           public:
 
-                ConcurrentSueKeyword( std::string&& type_name, std::string&& field_name, std::string&& getter_name, std::string&& context_error, bool needs_main, AggregateDecl::Aggregate cast_target ) :
-                  type_name( type_name ), field_name( field_name ), getter_name( getter_name ), context_error( context_error ), needs_main( needs_main ), cast_target( cast_target ) {}
+                ConcurrentSueKeyword( std::string&& type_name, std::string&& field_name,
+                        std::string&& getter_name, std::string&& context_error, std::string&& exception_name,
+                        bool needs_main, AggregateDecl::Aggregate cast_target ) :
+                  type_name( type_name ), field_name( field_name ), getter_name( getter_name ),
+                  context_error( context_error ), exception_name( exception_name ),
+                  vtable_name( getVTableName( exception_name ) ),
+                  needs_main( needs_main ), cast_target( cast_target ) {}
 
                 virtual ~ConcurrentSueKeyword() {}
@@ -62 +84 @@
 
                 void handle( StructDecl * );
+                void addVtableForward( StructDecl * );
                 FunctionDecl * forwardDeclare( StructDecl * );
                 ObjectDecl * addField( StructDecl * );
@@ -75 +98 @@
                 const std::string getter_name;
                 const std::string context_error;
+                const std::string exception_name;
+                const std::string vtable_name;
                 bool needs_main;
                 AggregateDecl::Aggregate cast_target;
@@ -80 +105 @@
                 StructDecl   * type_decl = nullptr;
                 FunctionDecl * dtor_decl = nullptr;
+                StructDecl * except_decl = nullptr;
+                StructDecl * vtable_decl = nullptr;
         };
 
@@ -100 +127 @@
                         "get_thread",
                         "thread keyword requires threads to be in scope, add #include <thread.hfa>\n",
+                        "ThreadCancelled",
                         true,
                         AggregateDecl::Thread
@@ -132 +160 @@
                         "get_coroutine",
                         "coroutine keyword requires coroutines to be in scope, add #include <coroutine.hfa>\n",
+                        "CoroutineCancelled",
                         true,
                         AggregateDecl::Coroutine
@@ -146 +175 @@
                 }
         };
+
+
 
         //-----------------------------------------------------------------------------
@@ -164 +195 @@
                         "get_monitor",
                         "monitor keyword requires monitors to be in scope, add #include <monitor.hfa>\n",
+                        "",
                         false,
                         AggregateDecl::Monitor
@@ -177 +209 @@
                         mutateAll( translationUnit, impl );
                 }
+        };
+
+        //-----------------------------------------------------------------------------
+        //Handles generator type declarations :
+        // generator MyGenerator {                   struct MyGenerator {
+        //      int data;                                  int data;
+        //      a_struct_t more_data;                      a_struct_t more_data;
+        //                                =>             int __gen_next;
+        // };                                        };
+        //
+        class GeneratorKeyword final : public ConcurrentSueKeyword {
+          public:
+
+                GeneratorKeyword() : ConcurrentSueKeyword(
+                        "$generator",
+                        "__generator_state",
+                        "get_generator",
+                        "Unable to find builtin type $generator\n",
+                        "",
+                        true,
+                        AggregateDecl::Generator
+                )
+                {}
+
+                virtual ~GeneratorKeyword() {}
+
+                virtual bool is_target( StructDecl * decl ) override final { return decl->is_generator(); }
+
+                static void implement( std::list< Declaration * > & translationUnit ) {
+                        PassVisitor< GeneratorKeyword > impl;
+                        mutateAll( translationUnit, impl );
+                }
+        };
+
+
+        //-----------------------------------------------------------------------------
+        class SuspendKeyword final : public WithStmtsToAdd, public WithGuards {
+        public:
+                SuspendKeyword() = default;
+                virtual ~SuspendKeyword() = default;
+
+                void  premutate( FunctionDecl * );
+                DeclarationWithType * postmutate( FunctionDecl * );
+
+                Statement * postmutate( SuspendStmt * );
+
+                static void implement( std::list< Declaration * > & translationUnit ) {
+                        PassVisitor< SuspendKeyword > impl;
+                        mutateAll( translationUnit, impl );
+                }
+
+        private:
+                bool is_real_suspend( FunctionDecl * );
+
+                Statement * make_generator_suspend( SuspendStmt * );
+                Statement * make_coroutine_suspend( SuspendStmt * );
+
+                struct LabelPair {
+                        Label obj;
+                        int   idx;
+                };
+
+                LabelPair make_label() {
+                        labels.push_back( gen.newLabel("generator") );
+                        return { labels.back(), int(labels.size()) };
+                }
+
+                DeclarationWithType * in_generator = nullptr;
+                FunctionDecl * decl_suspend = nullptr;
+                std::vector<Label> labels;
+                ControlStruct::LabelGenerator & gen = *ControlStruct::LabelGenerator::getGenerator();
         };
 
@@ -195 +298 @@
                 std::list<DeclarationWithType*> findMutexArgs( FunctionDecl*, bool & first );
                 void validate( DeclarationWithType * );
-                void addDtorStatments( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
-                void addStatments( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
+                void addDtorStatements( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
+                void addStatements( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
+                void addThreadDtorStatements( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args );
 
                 static void implement( std::list< Declaration * > & translationUnit ) {
@@ -207 +311 @@
                 StructDecl* guard_decl = nullptr;
                 StructDecl* dtor_guard_decl = nullptr;
+                StructDecl* thread_guard_decl = nullptr;
 
                 static std::unique_ptr< Type > generic_func;
@@ -251 +356 @@
                 CoroutineKeyword        ::implement( translationUnit );
                 MonitorKeyword  ::implement( translationUnit );
+                GeneratorKeyword  ::implement( translationUnit );
+                SuspendKeyword    ::implement( translationUnit );
         }
 
@@ -283 +390 @@
                         handle( decl );
                 }
+                else if ( !except_decl && exception_name == decl->name && decl->body ) {
+                        except_decl = decl;
+                }
+                else if ( !vtable_decl && vtable_name == decl->name && decl->body ) {
+                        vtable_decl = decl;
+                }
+                // Might be able to get ride of is target.
+                assert( is_target(decl) == (cast_target == decl->kind) );
                 return decl;
         }
 
         DeclarationWithType * ConcurrentSueKeyword::postmutate( FunctionDecl * decl ) {
-                if( !type_decl ) return decl;
-                if( !CodeGen::isDestructor( decl->name ) ) return decl;
-
-                auto params = decl->type->parameters;
-                if( params.size() != 1 ) return decl;
-
-                auto type = dynamic_cast<ReferenceType*>( params.front()->get_type() );
-                if( !type ) return decl;
-
-                auto stype = dynamic_cast<StructInstType*>( type->base );
-                if( !stype ) return decl;
-                if( stype->baseStruct != type_decl ) return decl;
-
-                if( !dtor_decl ) dtor_decl = decl;
+                if ( type_decl && isDestructorFor( decl, type_decl ) )
+                        dtor_decl = decl;
+                else if ( vtable_name.empty() )
+                        ;
+                else if( !decl->has_body() )
+                        ;
+                else if ( auto param = isMainFor( decl, cast_target ) ) {
+                        // This should never trigger.
+                        assert( vtable_decl );
+                        // Should be safe because of isMainFor.
+                        StructInstType * struct_type = static_cast<StructInstType *>(
+                                static_cast<ReferenceType *>( param->get_type() )->base );
+                        assert( struct_type );
+
+                        std::list< Expression * > poly_args = { new TypeExpr( struct_type->clone() ) };
+                        ObjectDecl * vtable_object = Virtual::makeVtableInstance(
+                                vtable_decl->makeInst( poly_args ), struct_type, nullptr );
+                        declsToAddAfter.push_back( vtable_object );
+                        declsToAddAfter.push_back( Virtual::makeGetExceptionFunction(
+                                vtable_object, except_decl->makeInst( std::move( poly_args ) )
+                        ) );
+                }
+
                 return decl;
         }
@@ -324 +448 @@
                 if( !dtor_decl ) SemanticError( decl, context_error );
 
+                addVtableForward( decl );
                 FunctionDecl * func = forwardDeclare( decl );
                 ObjectDecl * field = addField( decl );
                 addRoutines( field, func );
+        }
+
+        void ConcurrentSueKeyword::addVtableForward( StructDecl * decl ) {
+                if ( vtable_decl ) {
+                        std::list< Expression * > poly_args = {
+                                new TypeExpr( new StructInstType( noQualifiers, decl ) ),
+                        };
+                        declsToAddBefore.push_back( Virtual::makeGetExceptionForward(
+                                vtable_decl->makeInst( poly_args ),
+                                except_decl->makeInst( poly_args )
+                        ) );
+                        declsToAddBefore.push_back( Virtual::makeVtableForward(
+                                vtable_decl->makeInst( move( poly_args ) ) ) );
+                // Its only an error if we want a vtable and don't have one.
+                } else if ( ! vtable_name.empty() ) {
+                        SemanticError( decl, context_error );
+                }
         }
 
@@ -434 +576 @@
                                                 new CastExpr(
                                                         new VariableExpr( func->get_functionType()->get_parameters().front() ),
-                                                        func->get_functionType()->get_parameters().front()->get_type()->stripReferences()->clone()
+                                                        func->get_functionType()->get_parameters().front()->get_type()->stripReferences()->clone(),
+                                                        false
                                                 )
                                         )
@@ -446 +589 @@
 
                 declsToAddAfter.push_back( get_decl );
-
-                // get_decl->fixUniqueId();
-        }
+        }
+
+        //=============================================================================================
+        // Suspend keyword implementation
+        //=============================================================================================
+        bool SuspendKeyword::is_real_suspend( FunctionDecl * func ) {
+                if(isMangled(func->linkage)) return false; // the real suspend isn't mangled
+                if(func->name != "__cfactx_suspend") return false; // the real suspend has a specific name
+                if(func->type->parameters.size() != 0) return false; // Too many parameters
+                if(func->type->returnVals.size() != 0) return false; // Too many return values
+
+                return true;
+        }
+
+        void SuspendKeyword::premutate( FunctionDecl * func ) {
+                GuardValue(in_generator);
+                in_generator = nullptr;
+
+                // Is this the real suspend?
+                if(is_real_suspend(func)) {
+                        decl_suspend = decl_suspend ? decl_suspend : func;
+                        return;
+                }
+
+                // Is this the main of a generator?
+                auto param = isMainFor( func, AggregateDecl::Aggregate::Generator );
+                if(!param) return;
+
+                if(func->type->returnVals.size() != 0) SemanticError(func->location, "Generator main must return void");
+
+                in_generator = param;
+                GuardValue(labels);
+                labels.clear();
+        }
+
+        DeclarationWithType * SuspendKeyword::postmutate( FunctionDecl * func ) {
+                if( !func->statements ) return func; // Not the actual definition, don't do anything
+                if( !in_generator     ) return func; // Not in a generator, don't do anything
+                if( labels.empty()    ) return func; // Generator has no states, nothing to do, could throw a warning
+
+                // This is a generator main, we need to add the following code to the top
+                // static void * __generator_labels[] = {&&s0, &&s1, ...};
+                // goto * __generator_labels[gen.__generator_state];
+                const auto & loc = func->location;
+
+                const auto first_label = gen.newLabel("generator");
+
+                // for each label add to declaration
+                std::list<Initializer*> inits = { new SingleInit( new LabelAddressExpr( first_label ) ) };
+                for(const auto & label : labels) {
+                        inits.push_back(
+                                new SingleInit(
+                                        new LabelAddressExpr( label )
+                                )
+                        );
+                }
+                auto init = new ListInit(std::move(inits), noDesignators, true);
+                labels.clear();
+
+                // create decl
+                auto decl = new ObjectDecl(
+                        "__generator_labels",
+                        Type::StorageClasses( Type::Static ),
+                        LinkageSpec::AutoGen,
+                        nullptr,
+                        new ArrayType(
+                                Type::Qualifiers(),
+                                new PointerType(
+                                        Type::Qualifiers(),
+                                        new VoidType( Type::Qualifiers() )
+                                ),
+                                nullptr,
+                                false, false
+                        ),
+                        init
+                );
+
+                // create the goto
+                assert(in_generator);
+
+                auto go_decl = new ObjectDecl(
+                        "__generator_label",
+                        noStorageClasses,
+                        LinkageSpec::AutoGen,
+                        nullptr,
+                        new PointerType(
+                                Type::Qualifiers(),
+                                new VoidType( Type::Qualifiers() )
+                        ),
+                        new SingleInit(
+                                new UntypedExpr(
+                                        new NameExpr("?[?]"),
+                                        {
+                                                new NameExpr("__generator_labels"),
+                                                new UntypedMemberExpr(
+                                                        new NameExpr("__generator_state"),
+                                                        new VariableExpr( in_generator )
+                                                )
+                                        }
+                                )
+                        )
+                );
+                go_decl->location = loc;
+
+                auto go = new BranchStmt(
+                        new VariableExpr( go_decl ),
+                        BranchStmt::Goto
+                );
+                go->location = loc;
+                go->computedTarget->location = loc;
+
+                auto noop = new NullStmt({ first_label });
+                noop->location = loc;
+
+                // wrap everything in a nice compound
+                auto body = new CompoundStmt({
+                        new DeclStmt( decl ),
+                        new DeclStmt( go_decl ),
+                        go,
+                        noop,
+                        func->statements
+                });
+                body->location   = loc;
+                func->statements = body;
+
+                return func;
+        }
+
+        Statement * SuspendKeyword::postmutate( SuspendStmt * stmt ) {
+                SuspendStmt::Type type = stmt->type;
+                if(type == SuspendStmt::None) {
+                        // This suspend has a implicit target, find it
+                        type = in_generator ? SuspendStmt::Generator : SuspendStmt::Coroutine;
+                }
+
+                // Check that the target makes sense
+                if(!in_generator && type == SuspendStmt::Generator) SemanticError( stmt->location, "'suspend generator' must be used inside main of generator type.");
+
+                // Act appropriately
+                switch(type) {
+                        case SuspendStmt::Generator: return make_generator_suspend(stmt);
+                        case SuspendStmt::Coroutine: return make_coroutine_suspend(stmt);
+                        default: abort();
+                }
+        }
+
+        Statement * SuspendKeyword::make_generator_suspend( SuspendStmt * stmt ) {
+                assert(in_generator);
+                // Target code is :
+                //   gen.__generator_state = X;
+                //   { THEN }
+                //   return;
+                //   __gen_X:;
+
+                // Save the location and delete the old statement, we only need the location from this point on
+                auto loc = stmt->location;
+
+                // Build the label and get its index
+                auto label = make_label();
+
+                // Create the context saving statement
+                auto save = new ExprStmt( new UntypedExpr(
+                        new NameExpr( "?=?" ),
+                        {
+                                new UntypedMemberExpr(
+                                        new NameExpr("__generator_state"),
+                                        new VariableExpr( in_generator )
+                                ),
+                                new ConstantExpr(
+                                        Constant::from_int( label.idx )
+                                )
+                        }
+                ));
+                assert(save->expr);
+                save->location = loc;
+                stmtsToAddBefore.push_back( save );
+
+                // if we have a then add it here
+                auto then = stmt->then;
+                stmt->then = nullptr;
+                delete stmt;
+                if(then) stmtsToAddBefore.push_back( then );
+
+                // Create the return statement
+                auto ret = new ReturnStmt( nullptr );
+                ret->location = loc;
+                stmtsToAddBefore.push_back( ret );
+
+                // Create the null statement with the created label
+                auto noop = new NullStmt({ label.obj });
+                noop->location = loc;
+
+                // Return the null statement to take the place of the previous statement
+                return noop;
+        }
+
+        Statement * SuspendKeyword::make_coroutine_suspend( SuspendStmt * stmt ) {
+                if(stmt->then) SemanticError( stmt->location, "Compound statement following coroutines is not implemented.");
+
+                // Save the location and delete the old statement, we only need the location from this point on
+                auto loc = stmt->location;
+                delete stmt;
+
+                // Create the call expression
+                if(!decl_suspend) SemanticError( loc, "suspend keyword applied to coroutines requires coroutines to be in scope, add #include <coroutine.hfa>\n");
+                auto expr = new UntypedExpr( VariableExpr::functionPointer( decl_suspend ) );
+                expr->location = loc;
+
+                // Change this statement into a regular expr
+                assert(expr);
+                auto nstmt = new ExprStmt( expr );
+                nstmt->location = loc;
+                return nstmt;
+        }
+
 
         //=============================================================================================
@@ -458 +813 @@
                 bool first = false;
                 std::list<DeclarationWithType*> mutexArgs = findMutexArgs( decl, first );
-                bool isDtor = CodeGen::isDestructor( decl->name );
+                bool const isDtor = CodeGen::isDestructor( decl->name );
 
                 // Is this function relevant to monitors
@@ -506 +861 @@
 
                 // Instrument the body
-                if( isDtor ) {
-                        addDtorStatments( decl, body, mutexArgs );
+                if ( isDtor && isThread( mutexArgs.front() ) ) {
+                        if( !thread_guard_decl ) {
+                                SemanticError( decl, "thread destructor requires threads to be in scope, add #include <thread.hfa>\n" );
+                        }
+                        addThreadDtorStatements( decl, body, mutexArgs );
+                }
+                else if ( isDtor ) {
+                        addDtorStatements( decl, body, mutexArgs );
                 }
                 else {
-                        addStatments( decl, body, mutexArgs );
+                        addStatements( decl, body, mutexArgs );
                 }
         }
@@ -527 +888 @@
                         assert( !dtor_guard_decl );
                         dtor_guard_decl = decl;
+                }
+                else if( decl->name == "thread_dtor_guard_t" && decl->body ) {
+                        assert( !thread_guard_decl );
+                        thread_guard_decl = decl;
                 }
         }
@@ -565 +930 @@
         }
 
-        void MutexKeyword::addDtorStatments( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
+        void MutexKeyword::addDtorStatements( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
                 Type * arg_type = args.front()->get_type()->clone();
                 arg_type->set_mutex( false );
@@ -583 +948 @@
                         new SingleInit( new UntypedExpr(
                                 new NameExpr( "get_monitor" ),
-                                {  new CastExpr( new VariableExpr( args.front() ), arg_type ) }
+                                {  new CastExpr( new VariableExpr( args.front() ), arg_type, false ) }
                         ))
                 );
@@ -604 +969 @@
                                         {
                                                 new SingleInit( new AddressExpr( new VariableExpr( monitors ) ) ),
-                                                new SingleInit( new CastExpr( new VariableExpr( func ), generic_func->clone() ) )
+                                                new SingleInit( new CastExpr( new VariableExpr( func ), generic_func->clone(), false ) ),
+                                                new SingleInit( new ConstantExpr( Constant::from_bool( false ) ) )
                                         },
                                         noDesignators,
@@ -613 +979 @@
 
                 //$monitor * __monitors[] = { get_monitor(a), get_monitor(b) };
-                body->push_front( new DeclStmt( monitors) );
-        }
-
-        void MutexKeyword::addStatments( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
+                body->push_front( new DeclStmt( monitors ) );
+        }
+
+        void MutexKeyword::addThreadDtorStatements(
+                        FunctionDecl*, CompoundStmt * body,
+                        const std::list<DeclarationWithType * > & args ) {
+                assert( args.size() == 1 );
+                DeclarationWithType * arg = args.front();
+                Type * arg_type = arg->get_type()->clone();
+                assert( arg_type->get_mutex() );
+                arg_type->set_mutex( false );
+
+                // thread_dtor_guard_t __guard = { this, intptr( 0 ) };
+                body->push_front(
+                        new DeclStmt( new ObjectDecl(
+                                "__guard",
+                                noStorageClasses,
+                                LinkageSpec::Cforall,
+                                nullptr,
+                                new StructInstType(
+                                        noQualifiers,
+                                        thread_guard_decl
+                                ),
+                                new ListInit(
+                                        {
+                                                new SingleInit( new CastExpr( new VariableExpr( arg ), arg_type ) ),
+                                                new SingleInit( new UntypedExpr(
+                                                        new NameExpr( "intptr" ), {
+                                                                new ConstantExpr( Constant::from_int( 0 ) ),
+                                                        }
+                                                ) ),
+                                        },
+                                        noDesignators,
+                                        true
+                                )
+                        ))
+                );
+        }
+
+        void MutexKeyword::addStatements( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
                 ObjectDecl * monitors = new ObjectDecl(
                         "__monitors",
@@ -641 +1043 @@
                                         return new SingleInit( new UntypedExpr(
                                                 new NameExpr( "get_monitor" ),
-                                                {  new CastExpr( new VariableExpr( var ), type ) }
+                                                {  new CastExpr( new VariableExpr( var ), type, false ) }
                                         ) );
                                 })
@@ -665 +1067 @@
                                                 new SingleInit( new VariableExpr( monitors ) ),
                                                 new SingleInit( new ConstantExpr( Constant::from_ulong( args.size() ) ) ),
-                                                new SingleInit( new CastExpr( new VariableExpr( func ), generic_func->clone() ) )
+                                                new SingleInit( new CastExpr( new VariableExpr( func ), generic_func->clone(), false ) )
                                         },
                                         noDesignators,
@@ -727 +1129 @@
 // tab-width: 4 //
 // End: //
+