windows build fixes and some more work on symtab serialization
[dyninst.git] / symtabAPI / h / Module.h
1 /*
2  * Copyright (c) 1996-2007 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
30  */
31
32 #ifndef __MODULE__H__
33 #define __MODULE__H__
34  
35 #include "symutil.h"
36 #include "Symbol.h"
37
38 #include "Annotatable.h"
39 #include "Serialization.h"
40 #include "LineInformation.h"
41
42 namespace Dyninst{
43 namespace SymtabAPI{
44
45 class typeCollection;
46 class LineInformation;
47 class localVar;
48 class Symtab;
49
50 class Module : public LookupInterface,
51                public Serializable, 
52                public AnnotatableSparse
53 {
54    friend class Symtab;
55
56    public:
57
58    SYMTAB_EXPORT Module();
59    SYMTAB_EXPORT Module(supportedLanguages lang, Offset adr, std::string fullNm,
60          Symtab *img);
61    SYMTAB_EXPORT Module(const Module &mod);
62    SYMTAB_EXPORT bool operator==(Module &mod);
63
64    SYMTAB_EXPORT void serialize(SerializerBase *sb, const char *tag = "Module") THROW_SPEC (SerializerError);
65
66    SYMTAB_EXPORT const std::string &fileName() const;
67    SYMTAB_EXPORT const std::string &fullName() const;
68    SYMTAB_EXPORT bool setName(std::string newName);
69
70    SYMTAB_EXPORT supportedLanguages language() const;
71    SYMTAB_EXPORT void setLanguage(supportedLanguages lang);
72
73    SYMTAB_EXPORT Offset addr() const;
74    SYMTAB_EXPORT Symtab *exec() const;
75
76    SYMTAB_EXPORT bool isShared() const;
77    SYMTAB_EXPORT ~Module();
78
79    // Symbol output methods
80    SYMTAB_EXPORT virtual bool findSymbolByType(std::vector<Symbol *> &ret, 
81                                                const std::string name,
82                                                Symbol::SymbolType sType, 
83                                                NameType nameType = anyName,
84                                                bool isRegex = false, 
85                                                bool checkCase = false);
86    SYMTAB_EXPORT virtual bool getAllSymbolsByType(std::vector<Symbol *> &ret, 
87                                                   Symbol::SymbolType sType);
88    SYMTAB_EXPORT virtual bool getAllSymbols(std::vector<Symbol *> &ret);
89
90
91    // Function based methods
92    SYMTAB_EXPORT bool getAllFunctions(std::vector<Function *>&ret);
93    SYMTAB_EXPORT bool findFunctionByEntryOffset(Function *&ret, const Offset offset);
94    SYMTAB_EXPORT bool findFunctionsByName(std::vector<Function *> &ret, const std::string name,
95                                       NameType nameType = anyName, 
96                                       bool isRegex = false,
97                                       bool checkCase = true);
98
99    // Variable based methods
100    SYMTAB_EXPORT bool findVariableByOffset(Variable *&ret, const Offset offset);
101    SYMTAB_EXPORT bool findVariablesByName(std::vector<Variable *> &ret, const std::string name,
102                                       NameType nameType = anyName, 
103                                       bool isRegex = false, 
104                                       bool checkCase = true);
105    SYMTAB_EXPORT bool getAllVariables(std::vector<Variable *> &ret);
106
107
108    // Type output methods
109    SYMTAB_EXPORT virtual bool findType(Type *&type, std::string name);
110    SYMTAB_EXPORT virtual bool findVariableType(Type *&type, std::string name);
111
112    SYMTAB_EXPORT std::vector<Type *> *getAllTypes();
113    SYMTAB_EXPORT std::vector<std::pair<std::string, Type *> > *getAllGlobalVars();
114
115    SYMTAB_EXPORT typeCollection *getModuleTypes();
116
117    /***** Local Variable Information *****/
118    SYMTAB_EXPORT bool findLocalVariable(std::vector<localVar *>&vars, std::string name);
119
120    /***** Line Number Information *****/
121    SYMTAB_EXPORT bool getAddressRanges(std::vector<std::pair<Offset, Offset> >&ranges,
122          std::string lineSource, unsigned int LineNo);
123    SYMTAB_EXPORT bool getSourceLines(std::vector<LineNoTuple> &lines,
124          Offset addressInRange);
125    SYMTAB_EXPORT bool setLineInfo(LineInformation *lineInfo);
126    SYMTAB_EXPORT LineInformation *getLineInformation();
127    SYMTAB_EXPORT bool hasLineInformation();
128    SYMTAB_EXPORT bool setDefaultNamespacePrefix(std::string str);
129
130    // Deprecated methods
131    SYMTAB_EXPORT virtual bool findSymbolByType(std::vector<Symbol *> &ret, 
132                                                const std::string name,
133                                                Symbol::SymbolType sType, 
134                                                bool isMangled = false,
135                                                bool isRegex = false, 
136                                                bool checkCase = false);
137
138
139    private:
140
141    std::string fileName_;                   // short file 
142    std::string fullName_;                   // full path to file 
143    supportedLanguages language_;
144    Offset addr_;                      // starting address of module
145    Symtab *exec_;
146 };
147
148
149
150
151
152 }//namespace SymtabAPI
153
154 }//namespace Dyninst
155 #endif