source: src/ControlStruct/ExceptTranslate.cc @ 2f42718

no_list
Last change on this file since 2f42718 was 2f42718, checked in by tdelisle <tdelisle@…>, 3 years ago

Parameters and return value of functions are now vectors (and some related clean-up)

  • Property mode set to 100644
File size: 21.5 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// ExceptVisitor.cc --
8//
9// Author           : Andrew Beach
10// Created On       : Wed Jun 14 16:49:00 2017
11// Last Modified By : Andrew Beach
12// Last Modified On : Thr Aug 17 17:19:00 2017
13// Update Count     : 9
14//
15
16#include "ExceptTranslate.h"
17
18#include <stddef.h>                   // for NULL
19#include <cassert>                    // for assert, assertf
20#include <iterator>                   // for back_inserter, inserter
21#include <string>                     // for string, operator==
22
23#include "Common/PassVisitor.h"       // for PassVisitor, WithGuards
24#include "Common/SemanticError.h"     // for SemanticError
25#include "Common/utility.h"           // for CodeLocation
26#include "Parser/LinkageSpec.h"       // for Cforall
27#include "SynTree/Attribute.h"        // for Attribute
28#include "SynTree/Constant.h"         // for Constant
29#include "SynTree/Declaration.h"      // for ObjectDecl, FunctionDecl, Struc...
30#include "SynTree/Expression.h"       // for UntypedExpr, ConstantExpr, Name...
31#include "SynTree/Initializer.h"      // for SingleInit, ListInit
32#include "SynTree/Label.h"            // for Label
33#include "SynTree/Mutator.h"          // for mutateAll
34#include "SynTree/Statement.h"        // for CompoundStmt, CatchStmt, ThrowStmt
35#include "SynTree/Type.h"             // for FunctionType, Type, noQualifiers
36#include "SynTree/DeclReplacer.h"     // for DeclReplacer
37#include "SynTree/Visitor.h"          // for acceptAll
38
39namespace ControlStruct {
40
41        // Buricratic Helpers (Not having to do with the paritular operation.)
42
43        typedef std::list<CatchStmt*> CatchList;
44
45        void split( CatchList& allHandlers, CatchList& terHandlers,
46                                CatchList& resHandlers ) {
47                while ( !allHandlers.empty() ) {
48                        CatchStmt * stmt = allHandlers.front();
49                        allHandlers.pop_front();
50                        if (CatchStmt::Terminate == stmt->get_kind()) {
51                                terHandlers.push_back(stmt);
52                        } else {
53                                resHandlers.push_back(stmt);
54                        }
55                }
56        }
57
58        void appendDeclStmt( CompoundStmt * block, Declaration * item ) {
59                block->push_back(new DeclStmt(item));
60        }
61
62        Expression * nameOf( DeclarationWithType * decl ) {
63                return new VariableExpr( decl );
64        }
65
66        class ExceptionMutatorCore : public WithGuards {
67                enum Context { NoHandler, TerHandler, ResHandler };
68
69                // Also need to handle goto, break & continue.
70                // They need to be cut off in a ResHandler, until we enter another
71                // loop, switch or the goto stays within the function.
72
73                Context cur_context;
74
75                // The current (innermost) termination handler exception declaration.
76                ObjectDecl * handler_except_decl;
77
78                // The built in types used in translation.
79                StructDecl * except_decl;
80                StructDecl * node_decl;
81                StructDecl * hook_decl;
82
83                // The many helper functions for code/syntree generation.
84                Statement * create_given_throw(
85                        const char * throwFunc, ThrowStmt * throwStmt );
86                Statement * create_terminate_throw( ThrowStmt * throwStmt );
87                Statement * create_terminate_rethrow( ThrowStmt * throwStmt );
88                Statement * create_resume_throw( ThrowStmt * throwStmt );
89                Statement * create_resume_rethrow( ThrowStmt * throwStmt );
90                CompoundStmt * take_try_block( TryStmt * tryStmt );
91                FunctionDecl * create_try_wrapper( CompoundStmt * body );
92                FunctionDecl * create_terminate_catch( CatchList &handlers );
93                CompoundStmt * create_single_matcher(
94                        DeclarationWithType * except_obj, CatchStmt * modded_handler );
95                FunctionDecl * create_terminate_match( CatchList &handlers );
96                CompoundStmt * create_terminate_caller( FunctionDecl * try_wrapper,
97                        FunctionDecl * terminate_catch, FunctionDecl * terminate_match );
98                FunctionDecl * create_resume_handler( CatchList &handlers );
99                CompoundStmt * create_resume_wrapper(
100                        Statement * wraps, FunctionDecl * resume_handler );
101                FunctionDecl * create_finally_wrapper( TryStmt * tryStmt );
102                ObjectDecl * create_finally_hook( FunctionDecl * finally_wrapper );
103
104                // Types used in translation, make sure to use clone.
105                // void (*function)();
106                FunctionType try_func_t;
107                // void (*function)(int, exception);
108                FunctionType catch_func_t;
109                // int (*function)(exception);
110                FunctionType match_func_t;
111                // bool (*function)(exception);
112                FunctionType handle_func_t;
113                // void (*function)(__attribute__((unused)) void *);
114                FunctionType finally_func_t;
115
116                StructInstType * create_except_type() {
117                        assert( except_decl );
118                        return new StructInstType( noQualifiers, except_decl );
119                }
120                void init_func_types();
121
122        public:
123                ExceptionMutatorCore() :
124                        cur_context( NoHandler ),
125                        handler_except_decl( nullptr ),
126                        except_decl( nullptr ), node_decl( nullptr ), hook_decl( nullptr ),
127                        try_func_t( noQualifiers, false ),
128                        catch_func_t( noQualifiers, false ),
129                        match_func_t( noQualifiers, false ),
130                        handle_func_t( noQualifiers, false ),
131                        finally_func_t( noQualifiers, false )
132                {}
133
134                void premutate( CatchStmt *catchStmt );
135                void premutate( StructDecl *structDecl );
136                Statement * postmutate( ThrowStmt *throwStmt );
137                Statement * postmutate( TryStmt *tryStmt );
138        };
139
140        void ExceptionMutatorCore::init_func_types() {
141                assert( except_decl );
142
143                ObjectDecl index_obj(
144                        "__handler_index",
145                        Type::StorageClasses(),
146                        LinkageSpec::Cforall,
147                        /*bitfieldWidth*/ NULL,
148                        new BasicType( noQualifiers, BasicType::SignedInt ),
149                        /*init*/ NULL
150                        );
151                ObjectDecl exception_obj(
152                        "__exception_inst",
153                        Type::StorageClasses(),
154                        LinkageSpec::Cforall,
155                        /*bitfieldWidth*/ NULL,
156                        new PointerType(
157                                noQualifiers,
158                                new StructInstType( noQualifiers, except_decl )
159                                ),
160                        /*init*/ NULL
161                        );
162                ObjectDecl bool_obj(
163                        "__ret_bool",
164                        Type::StorageClasses(),
165                        LinkageSpec::Cforall,
166                        /*bitfieldWidth*/ NULL,
167                        new BasicType( noQualifiers, BasicType::Bool ),
168                        /*init*/ NULL,
169                        std::vector< Attribute * >{ new Attribute( "unused" ) }
170                        );
171                ObjectDecl voidptr_obj(
172                        "__hook",
173                        Type::StorageClasses(),
174                        LinkageSpec::Cforall,
175                        NULL,
176                        new PointerType(
177                                noQualifiers,
178                                new VoidType(
179                                        noQualifiers
180                                        ),
181                                std::vector< Attribute * >{ new Attribute( "unused" ) }
182                                ),
183                        NULL
184                        );
185
186                ObjectDecl * unused_index_obj = index_obj.clone();
187                unused_index_obj->attributes.push_back( new Attribute( "unused" ) );
188
189                catch_func_t.parameters.push_back( index_obj.clone() );
190                catch_func_t.parameters.push_back( exception_obj.clone() );
191                match_func_t.returnVals.push_back( unused_index_obj );
192                match_func_t.parameters.push_back( exception_obj.clone() );
193                handle_func_t.returnVals.push_back( bool_obj.clone() );
194                handle_func_t.parameters.push_back( exception_obj.clone() );
195                finally_func_t.parameters.push_back( voidptr_obj.clone() );
196        }
197
198        // ThrowStmt Mutation Helpers
199
200        Statement * ExceptionMutatorCore::create_given_throw(
201                        const char * throwFunc, ThrowStmt * throwStmt ) {
202                // `throwFunc`( `throwStmt->get_name` );
203                UntypedExpr * call = new UntypedExpr( new NameExpr( throwFunc ) );
204                call->get_args().push_back( throwStmt->get_expr() );
205                throwStmt->set_expr( nullptr );
206                delete throwStmt;
207                return new ExprStmt( call );
208        }
209
210        Statement * ExceptionMutatorCore::create_terminate_throw(
211                        ThrowStmt *throwStmt ) {
212                // __throw_terminate( `throwStmt->get_name()` ); }
213                return create_given_throw( "__cfaabi_ehm__throw_terminate", throwStmt );
214        }
215
216        Statement * ExceptionMutatorCore::create_terminate_rethrow(
217                        ThrowStmt *throwStmt ) {
218                // { `handler_except_decl` = NULL; __rethrow_terminate(); }
219                assert( nullptr == throwStmt->get_expr() );
220                assert( handler_except_decl );
221
222                CompoundStmt * result = new CompoundStmt();
223                result->labels =  throwStmt->labels;
224                result->push_back( new ExprStmt( UntypedExpr::createAssign(
225                        nameOf( handler_except_decl ),
226                        new ConstantExpr( Constant::null(
227                                new PointerType(
228                                        noQualifiers,
229                                        handler_except_decl->get_type()->clone()
230                                        )
231                                ) )
232                        ) ) );
233                result->push_back( new ExprStmt(
234                        new UntypedExpr( new NameExpr( "__cfaabi_ehm__rethrow_terminate" ) )
235                        ) );
236                delete throwStmt;
237                return result;
238        }
239
240        Statement * ExceptionMutatorCore::create_resume_throw(
241                        ThrowStmt *throwStmt ) {
242                // __throw_resume( `throwStmt->get_name` );
243                return create_given_throw( "__cfaabi_ehm__throw_resume", throwStmt );
244        }
245
246        Statement * ExceptionMutatorCore::create_resume_rethrow(
247                        ThrowStmt *throwStmt ) {
248                // return false;
249                Statement * result = new ReturnStmt(
250                        new ConstantExpr( Constant::from_bool( false ) )
251                        );
252                result->labels = throwStmt->labels;
253                delete throwStmt;
254                return result;
255        }
256
257        // TryStmt Mutation Helpers
258
259        CompoundStmt * ExceptionMutatorCore::take_try_block( TryStmt *tryStmt ) {
260                CompoundStmt * block = tryStmt->get_block();
261                tryStmt->set_block( nullptr );
262                return block;
263        }
264
265        FunctionDecl * ExceptionMutatorCore::create_try_wrapper(
266                        CompoundStmt *body ) {
267
268                return new FunctionDecl( "try", Type::StorageClasses(),
269                        LinkageSpec::Cforall, try_func_t.clone(), body );
270        }
271
272        FunctionDecl * ExceptionMutatorCore::create_terminate_catch(
273                        CatchList &handlers ) {
274                std::list<CaseStmt *> handler_wrappers;
275
276                FunctionType *func_type = catch_func_t.clone();
277                DeclarationWithType * index_obj  = func_type->parameters.front();
278                DeclarationWithType * except_obj = func_type->parameters.back();
279
280                // Index 1..{number of handlers}
281                int index = 0;
282                CatchList::iterator it = handlers.begin();
283                for ( ; it != handlers.end() ; ++it ) {
284                        ++index;
285                        CatchStmt * handler = *it;
286
287                        // case `index`:
288                        // {
289                        //     `handler.decl` = { (virtual `decl.type`)`except` };
290                        //     `handler.body`;
291                        // }
292                        // return;
293                        CompoundStmt * block = new CompoundStmt();
294
295                        // Just copy the exception value. (Post Validation)
296                        ObjectDecl * handler_decl =
297                                static_cast<ObjectDecl *>( handler->get_decl() );
298                        ObjectDecl * local_except = handler_decl->clone();
299                        local_except->set_init(
300                                new ListInit({ new SingleInit(
301                                        new VirtualCastExpr( nameOf( except_obj ),
302                                                local_except->get_type()
303                                                )
304                                        ) })
305                                );
306                        block->push_back( new DeclStmt( local_except ) );
307
308                        // Add the cleanup attribute.
309                        local_except->get_attributes().push_back( new Attribute(
310                                "cleanup",
311                                { new NameExpr( "__cfaabi_ehm__cleanup_terminate" ) }
312                                ) );
313
314                        // Update variables in the body to point to this local copy.
315                        {
316                                DeclReplacer::DeclMap mapping;
317                                mapping[ handler_decl ] = local_except;
318                                DeclReplacer::replace( handler->body, mapping );
319                        }
320
321                        block->push_back( handler->get_body() );
322                        handler->set_body( nullptr );
323
324                        std::list<Statement *> caseBody
325                                        { block, new ReturnStmt( nullptr ) };
326                        handler_wrappers.push_back( new CaseStmt(
327                                new ConstantExpr( Constant::from_int( index ) ),
328                                caseBody
329                                ) );
330                }
331                // TODO: Some sort of meaningful error on default perhaps?
332
333                std::list<Statement*> stmt_handlers;
334                while ( !handler_wrappers.empty() ) {
335                        stmt_handlers.push_back( handler_wrappers.front() );
336                        handler_wrappers.pop_front();
337                }
338
339                SwitchStmt * handler_lookup = new SwitchStmt(
340                        nameOf( index_obj ),
341                        stmt_handlers
342                        );
343                CompoundStmt * body = new CompoundStmt();
344                body->push_back( handler_lookup );
345
346                return new FunctionDecl("catch", Type::StorageClasses(),
347                        LinkageSpec::Cforall, func_type, body);
348        }
349
350        // Create a single check from a moddified handler.
351        // except_obj is referenced, modded_handler will be freed.
352        CompoundStmt * ExceptionMutatorCore::create_single_matcher(
353                        DeclarationWithType * except_obj, CatchStmt * modded_handler ) {
354                // {
355                //     `modded_handler.decl`
356                //     if ( `decl.name = (virtual `decl.type`)`except`
357                //             [&& `modded_handler.cond`] ) {
358                //         `modded_handler.body`
359                //     }
360                // }
361
362                CompoundStmt * block = new CompoundStmt();
363
364                // Local Declaration
365                ObjectDecl * local_except =
366                        dynamic_cast<ObjectDecl *>( modded_handler->get_decl() );
367                assert( local_except );
368                block->push_back( new DeclStmt( local_except ) );
369
370                // Check for type match.
371                Expression * cond = UntypedExpr::createAssign( nameOf( local_except ),
372                        new VirtualCastExpr( nameOf( except_obj ),
373                                local_except->get_type()->clone() ) );
374
375                // Add the check on the conditional if it is provided.
376                if ( modded_handler->get_cond() ) {
377                        cond = new LogicalExpr( cond, modded_handler->get_cond() );
378                }
379                // Construct the match condition.
380                block->push_back( new IfStmt(
381                        cond, modded_handler->get_body(), nullptr ) );
382
383                modded_handler->set_decl( nullptr );
384                modded_handler->set_cond( nullptr );
385                modded_handler->set_body( nullptr );
386                delete modded_handler;
387                return block;
388        }
389
390        FunctionDecl * ExceptionMutatorCore::create_terminate_match(
391                        CatchList &handlers ) {
392                // int match(exception * except) {
393                //     HANDLER WRAPPERS { return `index`; }
394                // }
395
396                CompoundStmt * body = new CompoundStmt();
397
398                FunctionType * func_type = match_func_t.clone();
399                DeclarationWithType * except_obj = func_type->parameters.back();
400
401                // Index 1..{number of handlers}
402                int index = 0;
403                CatchList::iterator it;
404                for ( it = handlers.begin() ; it != handlers.end() ; ++it ) {
405                        ++index;
406                        CatchStmt * handler = *it;
407
408                        // Body should have been taken by create_terminate_catch.
409                        assert( nullptr == handler->get_body() );
410
411                        // Create new body.
412                        handler->set_body( new ReturnStmt(
413                                new ConstantExpr( Constant::from_int( index ) ) ) );
414
415                        // Create the handler.
416                        body->push_back( create_single_matcher( except_obj, handler ) );
417                        *it = nullptr;
418                }
419
420                body->push_back( new ReturnStmt(
421                        new ConstantExpr( Constant::from_int( 0 ) ) ) );
422
423                return new FunctionDecl("match", Type::StorageClasses(),
424                        LinkageSpec::Cforall, func_type, body);
425        }
426
427        CompoundStmt * ExceptionMutatorCore::create_terminate_caller(
428                        FunctionDecl * try_wrapper,
429                        FunctionDecl * terminate_catch,
430                        FunctionDecl * terminate_match ) {
431                // { __cfaabi_ehm__try_terminate(`try`, `catch`, `match`); }
432
433                UntypedExpr * caller = new UntypedExpr( new NameExpr(
434                        "__cfaabi_ehm__try_terminate" ) );
435                std::list<Expression *>& args = caller->get_args();
436                args.push_back( nameOf( try_wrapper ) );
437                args.push_back( nameOf( terminate_catch ) );
438                args.push_back( nameOf( terminate_match ) );
439
440                CompoundStmt * callStmt = new CompoundStmt();
441                callStmt->push_back( new ExprStmt( caller ) );
442                return callStmt;
443        }
444
445        FunctionDecl * ExceptionMutatorCore::create_resume_handler(
446                        CatchList &handlers ) {
447                // bool handle(exception * except) {
448                //     HANDLER WRAPPERS { `hander->body`; return true; }
449                // }
450                CompoundStmt * body = new CompoundStmt();
451
452                FunctionType * func_type = handle_func_t.clone();
453                DeclarationWithType * except_obj = func_type->parameters.back();
454
455                CatchList::iterator it;
456                for ( it = handlers.begin() ; it != handlers.end() ; ++it ) {
457                        CatchStmt * handler = *it;
458
459                        // Modifiy body.
460                        CompoundStmt * handling_code =
461                                dynamic_cast<CompoundStmt*>( handler->get_body() );
462                        if ( ! handling_code ) {
463                                handling_code = new CompoundStmt();
464                                handling_code->push_back( handler->get_body() );
465                        }
466                        handling_code->push_back( new ReturnStmt(
467                                new ConstantExpr( Constant::from_bool( true ) ) ) );
468                        handler->set_body( handling_code );
469
470                        // Create the handler.
471                        body->push_back( create_single_matcher( except_obj, handler ) );
472                        *it = nullptr;
473                }
474
475                body->push_back( new ReturnStmt(
476                        new ConstantExpr( Constant::from_bool( false ) ) ) );
477
478                return new FunctionDecl("handle", Type::StorageClasses(),
479                        LinkageSpec::Cforall, func_type, body);
480        }
481
482        CompoundStmt * ExceptionMutatorCore::create_resume_wrapper(
483                        Statement * wraps,
484                        FunctionDecl * resume_handler ) {
485                CompoundStmt * body = new CompoundStmt();
486
487                // struct __try_resume_node __resume_node
488                //      __attribute__((cleanup( __cfaabi_ehm__try_resume_cleanup )));
489                // ** unwinding of the stack here could cause problems **
490                // ** however I don't think that can happen currently **
491                // __cfaabi_ehm__try_resume_setup( &__resume_node, resume_handler );
492
493                std::vector< Attribute * > attributes;
494                {
495                        std::list< Expression * > attr_params;
496                        attr_params.push_back( new NameExpr(
497                                "__cfaabi_ehm__try_resume_cleanup" ) );
498                        attributes.push_back( new Attribute( "cleanup", attr_params ) );
499                }
500
501                ObjectDecl * obj = new ObjectDecl(
502                        "__resume_node",
503                        Type::StorageClasses(),
504                        LinkageSpec::Cforall,
505                        nullptr,
506                        new StructInstType(
507                                Type::Qualifiers(),
508                                node_decl
509                                ),
510                        nullptr,
511                        attributes
512                        );
513                appendDeclStmt( body, obj );
514
515                UntypedExpr *setup = new UntypedExpr( new NameExpr(
516                        "__cfaabi_ehm__try_resume_setup" ) );
517                setup->get_args().push_back( new AddressExpr( nameOf( obj ) ) );
518                setup->get_args().push_back( nameOf( resume_handler ) );
519
520                body->push_back( new ExprStmt( setup ) );
521
522                body->push_back( wraps );
523                return body;
524        }
525
526        FunctionDecl * ExceptionMutatorCore::create_finally_wrapper(
527                        TryStmt * tryStmt ) {
528                // void finally() { <finally code> }
529                FinallyStmt * finally = tryStmt->get_finally();
530                CompoundStmt * body = finally->get_block();
531                finally->set_block( nullptr );
532                delete finally;
533                tryStmt->set_finally( nullptr );
534
535                return new FunctionDecl("finally", Type::StorageClasses(),
536                        LinkageSpec::Cforall, finally_func_t.clone(), body);
537        }
538
539        ObjectDecl * ExceptionMutatorCore::create_finally_hook(
540                        FunctionDecl * finally_wrapper ) {
541                // struct __cfaabi_ehm__cleanup_hook __finally_hook
542                //      __attribute__((cleanup( finally_wrapper )));
543
544                // Make Cleanup Attribute.
545                std::vector< Attribute * > attributes;
546                {
547                        std::list< Expression * > attr_params;
548                        attr_params.push_back( nameOf( finally_wrapper ) );
549                        attributes.push_back( new Attribute( "cleanup", attr_params ) );
550                }
551
552                return new ObjectDecl(
553                        "__finally_hook",
554                        Type::StorageClasses(),
555                        LinkageSpec::Cforall,
556                        nullptr,
557                        new StructInstType(
558                                noQualifiers,
559                                hook_decl
560                                ),
561                        nullptr,
562                        attributes
563                        );
564        }
565
566        // Visiting/Mutating Functions
567        void ExceptionMutatorCore::premutate( CatchStmt *catchStmt ) {
568                // Validate the Statement's form.
569                ObjectDecl * decl =
570                        dynamic_cast<ObjectDecl *>( catchStmt->get_decl() );
571                if ( decl && true /* check decl->get_type() */ ) {
572                        // Pass.
573                } else if ( CatchStmt::Terminate == catchStmt->get_kind() ) {
574                        SemanticError(catchStmt->location, "catch must have exception type");
575                } else {
576                        SemanticError(catchStmt->location, "catchResume must have exception type");
577                }
578
579                // Track the handler context.
580                GuardValue( cur_context );
581                if ( CatchStmt::Terminate == catchStmt->get_kind() ) {
582                        cur_context = TerHandler;
583
584                        GuardValue( handler_except_decl );
585                        handler_except_decl = decl;
586                } else {
587                        cur_context = ResHandler;
588                }
589        }
590
591        void ExceptionMutatorCore::premutate( StructDecl *structDecl ) {
592                if ( !structDecl->has_body() ) {
593                        // Skip children?
594                        return;
595                } else if ( structDecl->get_name() == "__cfaabi_ehm__base_exception_t" ) {
596                        assert( nullptr == except_decl );
597                        except_decl = structDecl;
598                        init_func_types();
599                } else if ( structDecl->get_name() == "__cfaabi_ehm__try_resume_node" ) {
600                        assert( nullptr == node_decl );
601                        node_decl = structDecl;
602                } else if ( structDecl->get_name() == "__cfaabi_ehm__cleanup_hook" ) {
603                        assert( nullptr == hook_decl );
604                        hook_decl = structDecl;
605                }
606                // Later we might get the exception type as well.
607        }
608
609        Statement * ExceptionMutatorCore::postmutate( ThrowStmt *throwStmt ) {
610                assert( except_decl );
611
612                // Ignoring throwStmt->get_target() for now.
613                if ( ThrowStmt::Terminate == throwStmt->get_kind() ) {
614                        if ( throwStmt->get_expr() ) {
615                                return create_terminate_throw( throwStmt );
616                        } else if ( TerHandler == cur_context ) {
617                                return create_terminate_rethrow( throwStmt );
618                        } else {
619                                assertf(false, "Invalid throw in %s at %i\n",
620                                        throwStmt->location.filename.c_str(),
621                                        throwStmt->location.first_line);
622                                return nullptr;
623                        }
624                } else {
625                        if ( throwStmt->get_expr() ) {
626                                return create_resume_throw( throwStmt );
627                        } else if ( ResHandler == cur_context ) {
628                                return create_resume_rethrow( throwStmt );
629                        } else {
630                                assertf(false, "Invalid throwResume in %s at %i\n",
631                                        throwStmt->location.filename.c_str(),
632                                        throwStmt->location.first_line);
633                                return nullptr;
634                        }
635                }
636        }
637
638        Statement * ExceptionMutatorCore::postmutate( TryStmt *tryStmt ) {
639                assert( except_decl );
640                assert( node_decl );
641                assert( hook_decl );
642
643                // Generate a prefix for the function names?
644
645                CompoundStmt * block = new CompoundStmt();
646                CompoundStmt * inner = take_try_block( tryStmt );
647
648                if ( tryStmt->get_finally() ) {
649                        // Define the helper function.
650                        FunctionDecl * finally_block =
651                                create_finally_wrapper( tryStmt );
652                        appendDeclStmt( block, finally_block );
653                        // Create and add the finally cleanup hook.
654                        appendDeclStmt( block, create_finally_hook( finally_block ) );
655                }
656
657                CatchList termination_handlers;
658                CatchList resumption_handlers;
659                split( tryStmt->get_catchers(),
660                           termination_handlers, resumption_handlers );
661
662                if ( resumption_handlers.size() ) {
663                        // Define the helper function.
664                        FunctionDecl * resume_handler =
665                                create_resume_handler( resumption_handlers );
666                        appendDeclStmt( block, resume_handler );
667                        // Prepare hooks
668                        inner = create_resume_wrapper( inner, resume_handler );
669                }
670
671                if ( termination_handlers.size() ) {
672                        // Define the three helper functions.
673                        FunctionDecl * try_wrapper = create_try_wrapper( inner );
674                        appendDeclStmt( block, try_wrapper );
675                        FunctionDecl * terminate_catch =
676                                create_terminate_catch( termination_handlers );
677                        appendDeclStmt( block, terminate_catch );
678                        FunctionDecl * terminate_match =
679                                create_terminate_match( termination_handlers );
680                        appendDeclStmt( block, terminate_match );
681                        // Build the call to the try wrapper.
682                        inner = create_terminate_caller(
683                                try_wrapper, terminate_catch, terminate_match );
684                }
685
686                // Embed the try block.
687                block->push_back( inner );
688
689                return block;
690        }
691
692        void translateEHM( std::list< Declaration *> & translationUnit ) {
693                PassVisitor<ExceptionMutatorCore> translator;
694                mutateAll( translationUnit, translator );
695        }
696}
Note: See TracBrowser for help on using the repository browser.