Remove incorrect export declaration
[dyninst.git] / parseAPI / h / CFGFactory.h
1 /*
2  * See the dyninst/COPYRIGHT file for copyright information.
3  * 
4  * We provide the Paradyn Tools (below described as "Paradyn")
5  * on an AS IS basis, and do not warrant its validity or performance.
6  * We reserve the right to update, modify, or discontinue this
7  * software at any time.  We shall have no obligation to supply such
8  * updates or modifications or any other form of support to you.
9  * 
10  * By your use of Paradyn, you understand and agree that we (or any
11  * other person or entity with proprietary rights in Paradyn) are
12  * under no obligation to provide either maintenance services,
13  * update services, notices of latent defects, or correction of
14  * defects for Paradyn.
15  * 
16  * This library is free software; you can redistribute it and/or
17  * modify it under the terms of the GNU Lesser General Public
18  * License as published by the Free Software Foundation; either
19  * version 2.1 of the License, or (at your option) any later version.
20  * 
21  * This library is distributed in the hope that it will be useful,
22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
24  * Lesser General Public License for more details.
25  * 
26  * You should have received a copy of the GNU Lesser General Public
27  * License along with this library; if not, write to the Free Software
28  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29  */
30 #ifndef _CFG_FACTORY_H_
31 #define _CFG_FACTORY_H_
32
33 #include "dyntypes.h"
34
35 #include "CFG.h"
36 #include "InstructionSource.h"
37
38 namespace Dyninst {
39 namespace ParseAPI {
40
41 template <class T>
42 class flist_iter {
43     typedef T elem;
44  private:
45     mutable allocatable * cur_;
46  public:
47     flist_iter(elem * cur) :
48         cur_(cur) { }
49
50     flist_iter(allocatable * cur) :
51         cur_(cur) { }
52
53     inline elem &operator*() { return *(elem*)cur_; }
54     inline const elem &operator*() const { return *(elem*)cur_; }
55
56     inline flist_iter operator++(int) const {
57         flist_iter result = *this;
58         cur_ = cur_->alloc_next();
59         return result;
60     }
61     inline flist_iter operator++() const {
62         cur_ = cur_->alloc_next();
63         return *this;
64     }
65
66     inline bool operator==(const flist_iter &iter) const {
67         return (cur_ == iter.cur_);
68     }
69     inline bool operator!=(const flist_iter &iter) const {
70         return (cur_ != iter.cur_);
71     }
72 };
73
74 template <class T>
75 class fact_list {
76  public:
77     typedef flist_iter<T> iterator;
78     typedef const flist_iter<T> const_iterator;
79     typedef T elem;
80
81     fact_list() {
82         head.alloc_set_next(&head);
83         head.alloc_set_prev(&head);
84     }
85
86     ~fact_list() { }
87
88     void add(elem & new_elem) {
89         head.append(new_elem);
90     }
91     void add_tail(elem & new_elem) {
92         head.prepend(new_elem);
93     }
94     void clear() {
95         while(head.alloc_next() != &head)
96             head.alloc_next()->remove();
97     }
98     
99     // iterators
100     iterator begin() { return iterator(head.alloc_next()); }
101     iterator end() { return iterator(&head); }
102     const_iterator begin() const { return iterator(head.alloc_next()); }
103     const_iterator end() const { return iterator(&head); }
104  private:
105     allocatable head;
106 };
107 /** An implementation of CFGFactory is responsible for allocation and
108     deallocation of CFG objects like Blocks, Edges, and Functions.
109     Overriding the default methods of this interface allows the parsing
110     routines to generate and work with extensions of the base types **/
111
112 /** Objects created by a CFGFactory must descend from `allocatable' **/
113
114 class PARSER_EXPORT CFGFactory {   
115  public:
116     CFGFactory() {};
117     virtual ~CFGFactory();
118     
119     /*
120      * These methods are called by ParseAPI, and perform bookkeeping
121      * around the user-overridden creation/destruction methods.
122      */
123     Function *_mkfunc(Address addr, FuncSource src,
124                                     std::string name, CodeObject *obj,
125                                     CodeRegion *region, InstructionSource *isrc);
126     Block *_mkblock(Function *f, CodeRegion *r, Address addr);
127     Edge *_mkedge(Block *src, Block *trg, EdgeTypeEnum type);
128     
129     Block *_mksink(CodeObject *obj, CodeRegion *r);
130
131     void destroy_func(Function *f);
132     void destroy_block(Block *b);
133     void destroy_edge(Edge *e);
134
135     void destroy_all();
136
137  protected:
138     virtual Function * mkfunc(Address addr, FuncSource src, 
139             std::string name, CodeObject * obj, CodeRegion * region, 
140             Dyninst::InstructionSource * isrc);
141     virtual Block * mkblock(Function * f, CodeRegion * r, 
142             Address addr);
143     virtual Edge * mkedge(Block * src, Block * trg, 
144             EdgeTypeEnum type);
145     /*
146      * A `sink' block is the target of all unresolvable control
147      * flow in a parsing unit. Implementors may return a unique
148      * sink per CodeObject or a single global sink.
149      */
150     virtual Block * mksink(CodeObject *obj, CodeRegion *r);
151
152     virtual void free_func(Function * f);
153     virtual void free_block(Block * b);
154     virtual void free_edge(Edge * e);
155
156     fact_list<Edge> edges_;
157     fact_list<Block> blocks_;
158     fact_list<Function> funcs_;
159 };
160
161
162 }
163 }
164
165 #endif