source: src/InitTweak/InitTweak.cc @ 64071c2

ADTaaron-thesisarm-ehast-experimentalcleanup-dtorsctordeferred_resndemanglerenumforall-pointer-decaygc_noraiijacob/cs343-translationjenkins-sandboxmemorynew-astnew-ast-unique-exprnew-envno_listpersistent-indexerpthread-emulationqualifiedEnumresolv-newwith_gc
Last change on this file since 64071c2 was 64071c2, checked in by Rob Schluntz <rschlunt@…>, 8 years ago

greatly simplify construction of qualified objects using cast expressions, which also reduces gcc warnings

  • Property mode set to 100644
File size: 5.4 KB
Line 
1#include "InitTweak.h"
2#include "SynTree/Visitor.h"
3#include "SynTree/Statement.h"
4#include "SynTree/Initializer.h"
5#include "SynTree/Expression.h"
6#include "GenPoly/GenPoly.h"
7
8namespace InitTweak {
9        namespace {
10                class HasDesignations : public Visitor {
11                public:
12                        bool hasDesignations = false;
13                        template<typename Init>
14                        void handleInit( Init * init ) {
15                                if ( ! init->get_designators().empty() ) hasDesignations = true;
16                                else Visitor::visit( init );
17                        }
18                        virtual void visit( SingleInit * singleInit ) { handleInit( singleInit); }
19                        virtual void visit( ListInit * listInit ) { handleInit( listInit); }
20                };
21
22                class InitExpander : public Visitor {
23                        public:
24                        InitExpander() {}
25                        virtual void visit( SingleInit * singleInit );
26                        virtual void visit( ListInit * listInit );
27                        std::list< Expression * > argList;
28                };
29
30                void InitExpander::visit( SingleInit * singleInit ) {
31                        argList.push_back( singleInit->get_value()->clone() );
32                }
33
34                void InitExpander::visit( ListInit * listInit ) {
35                        // xxx - for now, assume no nested list inits
36                        std::list<Initializer*>::iterator it = listInit->begin_initializers();
37                        for ( ; it != listInit->end_initializers(); ++it ) {
38                                (*it)->accept( *this );
39                        }
40                }
41        }
42
43        std::list< Expression * > makeInitList( Initializer * init ) {
44                InitExpander expander;
45                maybeAccept( init, expander );
46                return expander.argList;
47        }
48
49        bool isDesignated( Initializer * init ) {
50                HasDesignations finder;
51                maybeAccept( init, finder );
52                return finder.hasDesignations;
53        }
54
55        bool tryConstruct( ObjectDecl * objDecl ) {
56                return ! LinkageSpec::isBuiltin( objDecl->get_linkage() ) &&
57                        (objDecl->get_init() == NULL ||
58                                ( objDecl->get_init() != NULL && objDecl->get_init()->get_maybeConstructed() )) &&
59                        ! isDesignated( objDecl->get_init() );
60        }
61
62        Expression * getCtorDtorCall( Statement * stmt ) {
63                if ( stmt == NULL ) return NULL;
64                if ( ExprStmt * exprStmt = dynamic_cast< ExprStmt * >( stmt ) ) {
65                        return exprStmt->get_expr();
66                } else if ( CompoundStmt * compoundStmt = dynamic_cast< CompoundStmt * >( stmt ) ) {
67                        // could also be a compound statement with a loop, in the case of an array
68                        assert( compoundStmt->get_kids().size() == 2 ); // loop variable and loop
69                        ForStmt * forStmt = dynamic_cast< ForStmt * >( compoundStmt->get_kids().back() );
70                        assert( forStmt && forStmt->get_body() );
71                        return getCtorDtorCall( forStmt->get_body() );
72                } if ( ImplicitCtorDtorStmt * impCtorDtorStmt = dynamic_cast< ImplicitCtorDtorStmt * > ( stmt ) ) {
73                        return getCtorDtorCall( impCtorDtorStmt->get_callStmt() );
74                } else {
75                        // should never get here
76                        assert( false && "encountered unknown call statement" );
77                }
78        }
79
80        bool isInstrinsicSingleArgCallStmt( Statement * stmt ) {
81                Expression * callExpr = getCtorDtorCall( stmt );
82                if ( ! callExpr ) return false;
83                ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( callExpr );
84                assert( appExpr );
85                VariableExpr * function = dynamic_cast< VariableExpr * >( appExpr->get_function() );
86                assert( function );
87                // check for Intrinsic only - don't want to remove all overridable ctor/dtors because autogenerated ctor/dtor
88                // will call all member dtors, and some members may have a user defined dtor.
89                FunctionType * funcType = GenPoly::getFunctionType( function->get_var()->get_type() );
90                assert( funcType );
91                return function->get_var()->get_linkage() == LinkageSpec::Intrinsic && funcType->get_parameters().size() == 1;
92        }
93
94        namespace {
95                template<typename CallExpr>
96                Expression *& callArg( CallExpr * callExpr, unsigned int pos ) {
97                        if ( pos >= callExpr->get_args().size() ) assert( false && "asking for argument that doesn't exist. Return NULL/throw exception?" );
98                        for ( Expression *& arg : callExpr->get_args() ) {
99                                if ( pos == 0 ) return arg;
100                                pos--;
101                        }
102                        assert( false );
103                }
104        }
105
106        Expression *& getCallArg( Expression * callExpr, unsigned int pos ) {
107                if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( callExpr ) ) {
108                        return callArg( appExpr, pos );
109                } else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * >( callExpr ) ) {
110                        return callArg( untypedExpr, pos );
111                } else {
112                        assert( false && "Unexpected expression type passed to getCallArg" );
113                }
114        }
115
116        namespace {
117                template<typename CallExpr>
118                std::string funcName( CallExpr * expr ) {
119                        Expression * func = expr->get_function();
120                        if ( NameExpr * nameExpr = dynamic_cast< NameExpr * >( func ) ) {
121                                return nameExpr->get_name();
122                        } else if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( func ) ) {
123                                return varExpr->get_var()->get_name();
124                        } else {
125                                assert( false && "Unexpected expression type being called as a function in call expression" );
126                        }
127                }
128        }
129
130        std::string getFunctionName( Expression * expr ) {
131                if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr ) ) {
132                        return funcName( appExpr );
133                } else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * > ( expr ) ) {
134                        return funcName( untypedExpr );
135                } else {
136                        assert( false && "Unexpected expression type passed to getFunctionName" );
137                }
138        }
139
140        Type * getPointerBase( Type * type ) {
141                if ( PointerType * ptrType = dynamic_cast< PointerType * >( type ) ) {
142                        return ptrType->get_base();
143                } else if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) {
144                        return arrayType->get_base();
145                } else {
146                        return NULL;
147                }
148        }
149
150        Type * isPointerType( Type * type ) {
151                if ( getPointerBase( type ) ) return type;
152                else return NULL;
153        }
154}
Note: See TracBrowser for help on using the repository browser.