Remove incorrect export declaration
[dyninst.git] / symtabAPI / h / Variable.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
31 #if !defined(_Variable_h_)
32 #define _Variable_h_
33
34 #include "Annotatable.h"
35 #include "Serialization.h"
36 #include "Symtab.h"
37 #include "Aggregate.h"
38 #include "dyn_regs.h"
39 #include "VariableLocation.h"
40
41 //class Dyninst::SymtabAPI::Variable;
42 SYMTAB_EXPORT std::ostream &operator<<(std::ostream &os, const Dyninst::SymtabAPI::Variable &);
43
44 namespace Dyninst {
45 namespace SymtabAPI {
46
47
48 class Symbol;
49 class Symtab;
50 class Aggregate;
51 class Function;
52 class FunctionBase;
53
54 class SYMTAB_EXPORT Variable : public Aggregate, public Serializable, public AnnotatableSparse {
55         friend class Symtab;
56         friend std::ostream &::operator<<(std::ostream &os, const Dyninst::SymtabAPI::Variable &);
57
58         private:
59    Variable(Symbol *sym);
60    static Variable *createVariable(Symbol *sym);
61    
62  public:
63    Variable();
64     /* Symbol management */
65     bool removeSymbol(Symbol *sym);      
66
67    void setType(Type *type);
68    Type *getType();
69
70    Serializable *serialize_impl(SerializerBase *sb, 
71                    const char *tag = "Variable") THROW_SPEC (SerializerError);
72    bool operator==(const Variable &v);
73
74  private:
75
76    Type *type_;
77 };
78
79 class SYMTAB_EXPORT localVar : public Serializable, public AnnotatableSparse
80 {
81         friend class typeCommon;
82         friend class localVarCollection;
83
84         std::string name_;
85         Type *type_;
86         std::string fileName_;
87         int lineNum_;
88         FunctionBase *func_;
89         std::vector<VariableLocation> locs_;
90         // We start with an abstract location that may include "the frame
91         // pointer" as a register. Once a user requests the location list
92         // we concretize it and set this flag.
93         bool locsExpanded_;
94         
95         // scope_t scope;
96
97         void expandLocation(const VariableLocation &var,
98                             std::vector<VariableLocation> &ret);
99
100         public:
101         localVar() :
102         type_(NULL), lineNum_(-1), func_(NULL), locsExpanded_(false) {}
103         //  Internal use only
104         localVar(std::string name,  Type *typ, std::string fileName, 
105             int lineNum, FunctionBase *f, 
106             std::vector<VariableLocation> *locs = NULL);
107             
108         // Copy constructor
109         localVar(localVar &lvar);
110         bool addLocation(VariableLocation &location);
111         ~localVar();
112         void fixupUnknown(Module *);
113
114         public:
115         //  end of functions for internal use only
116         std::string &getName();
117         Type *getType();
118         bool setType(Type *newType);
119         int  getLineNum();
120         std::string &getFileName();
121         std::vector<VariableLocation> &getLocationLists();
122         bool operator==(const localVar &l);
123         Serializable *serialize_impl(SerializerBase *, 
124                         const char * = "localVar") THROW_SPEC(SerializerError);
125 };
126
127 }
128 }
129
130
131 #endif