source: src/InitTweak/InitTweak.h @ 9191a8e

ADTaaron-thesisarm-ehast-experimentalcleanup-dtorsdeferred_resndemanglerenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprnew-envno_listpersistent-indexerpthread-emulationqualifiedEnumresolv-newwith_gc
Last change on this file since 9191a8e was bff227f, checked in by Rob Schluntz <rschlunt@…>, 7 years ago

Refactor operator predicates into OperatorTable?.cc

  • Property mode set to 100644
File size: 4.1 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// RemoveInit.h --
8//
9// Author           : Rob Schluntz
10// Created On       : Fri May 13 11:26:36 2016
11// Last Modified By : Rob Schluntz
12// Last Modified On : Fri May 13 11:35:36 2016
13// Update Count     : 3
14//
15
16#ifndef INIT_TWEAK_H
17#define INIT_TWEAK_H
18
19#include <string>
20#include <list>
21
22#include "SynTree/SynTree.h"
23#include "SynTree/Declaration.h"
24#include "SynTree/Mutator.h"
25
26// helper functions for initialization
27namespace InitTweak {
28        FunctionDecl * isAssignment( Declaration * decl );
29        FunctionDecl * isDestructor( Declaration * decl );
30        FunctionDecl * isDefaultConstructor( Declaration * decl );
31        FunctionDecl * isCopyConstructor( Declaration * decl );
32        FunctionDecl * isCopyFunction( Declaration * decl, const std::string & fname );
33
34        /// transform Initializer into an argument list that can be passed to a call expression
35        std::list< Expression * > makeInitList( Initializer * init );
36
37        /// True if the resolver should try to construct objDecl
38        bool tryConstruct( ObjectDecl * objDecl );
39
40        /// True if the Initializer contains designations
41        bool isDesignated( Initializer * init );
42
43        /// True if the ObjectDecl's Initializer nesting level is not deeper than the depth of its
44        /// type, where the depth of its type is the number of nested ArrayTypes + 1
45        bool checkInitDepth( ObjectDecl * objDecl );
46
47        /// returns the declaration of the function called by the expr (must be ApplicationExpr or UntypedExpr)
48        DeclarationWithType * getFunction( Expression * expr );
49
50        /// Non-Null if expr is a call expression whose target function is intrinsic
51        ApplicationExpr * isIntrinsicCallExpr( Expression * expr );
52
53        /// True if stmt is a call statement where the function called is intrinsic and takes one parameter.
54        /// Intended to be used for default ctor/dtor calls, but might have use elsewhere.
55        /// Currently has assertions that make it less than fully general.
56        bool isIntrinsicSingleArgCallStmt( Statement * stmt );
57
58        /// True if stmt is a call statement where the function called is intrinsic.
59        bool isIntrinsicCallStmt( Statement * stmt );
60
61        /// get all Ctor/Dtor call expressions from a Statement
62        void collectCtorDtorCalls( Statement * stmt, std::list< Expression * > & matches );
63
64        /// get the Ctor/Dtor call expression from a Statement that looks like a generated ctor/dtor call
65        Expression * getCtorDtorCall( Statement * stmt );
66
67        /// returns the name of the function being called
68        std::string getFunctionName( Expression * expr );
69
70        /// returns the argument to a call expression in position N indexed from 0
71        Expression *& getCallArg( Expression * callExpr, unsigned int pos );
72
73        /// returns the base type of a PointerType or ArrayType, else returns NULL
74        Type * getPointerBase( Type * );
75
76        /// returns the argument if it is a PointerType or ArrayType, else returns NULL
77        Type * isPointerType( Type * );
78
79        /// returns true if expr is trivially a compile-time constant
80        bool isConstExpr( Expression * expr );
81        bool isConstExpr( Initializer * init );
82
83        class InitExpander {
84        public:
85                // expand by stepping through init to get each list of arguments
86                InitExpander( Initializer * init );
87
88                // always expand to expr
89                InitExpander( Expression * expr );
90
91                // iterator-like interface
92                std::list< Expression * > operator*();
93                InitExpander & operator++();
94
95                // builds statement which has the same semantics as a C-style list initializer
96                // (for array initializers) using callExpr as the base expression to perform initialization
97                Statement * buildListInit( UntypedExpr * callExpr );
98                void addArrayIndex( Expression * index, Expression * dimension );
99                void clearArrayIndices();
100
101                class ExpanderImpl;
102                typedef std::list< Expression * > IndexList;
103        private:
104                std::shared_ptr< ExpanderImpl > expander;
105                std::list< Expression * > cur;
106
107                // invariant: list of size 2N (elements come in pairs [index, dimension])
108                IndexList indices;
109        };
110} // namespace
111
112#endif // INITTWEAK_GENINIT_H
113
114// Local Variables: //
115// tab-width: 4 //
116// mode: c++ //
117// compile-command: "make install" //
118// End: //
Note: See TracBrowser for help on using the repository browser.