cprover
cpp_scope.cpp
Go to the documentation of this file.
1 /*******************************************************************\
2 
3 Module: C++ Language Type Checking
4 
5 Author: Daniel Kroening, kroening@cs.cmu.edu
6 
7 \*******************************************************************/
8 
11 
12 #include "cpp_scope.h"
13 
14 #include "cpp_typecheck.h"
15 
16 std::ostream &operator << (std::ostream &out, cpp_scopet::lookup_kindt kind)
17 {
18  switch(kind)
19  {
20  case cpp_scopet::QUALIFIED: return out << "QUALIFIED";
21  case cpp_scopet::SCOPE_ONLY: return out << "SCOPE_ONLY";
22  case cpp_scopet::RECURSIVE: return out << "RECURSIVE";
23  default: UNREACHABLE;
24  }
25 
26  return out;
27 }
28 
30  const irep_idt &base_name,
31  lookup_kindt kind,
32  id_sett &id_set)
33 {
34  cpp_id_mapt::iterator
35  lower_it=sub.lower_bound(base_name);
36 
37  if(lower_it!=sub.end())
38  {
39  cpp_id_mapt::iterator
40  upper_it=sub.upper_bound(base_name);
41 
42  for(cpp_id_mapt::iterator n_it=lower_it;
43  n_it!=upper_it; n_it++)
44  id_set.insert(&n_it->second);
45  }
46 
47  if(this->base_name==base_name)
48  id_set.insert(this);
49 
50  if(kind==SCOPE_ONLY)
51  return; // done
52 
53  // using scopes
54  for(scope_listt::iterator
55  it=using_scopes.begin();
56  it!=using_scopes.end();
57  it++)
58  {
59  cpp_scopet &other_scope=static_cast<cpp_scopet &>(**it);
60 
61  // Recursive call.
62  // Note the different kind!
63  other_scope.lookup(base_name, QUALIFIED, id_set);
64  }
65 
66  if(!id_set.empty())
67  return; // done, upwards scopes are hidden
68 
69  // secondary scopes
70  for(scope_listt::iterator
71  it=secondary_scopes.begin();
72  it!=secondary_scopes.end();
73  it++)
74  {
75  cpp_scopet &other_scope=static_cast<cpp_scopet &>(**it);
76 
77  // Recursive call.
78  // Note the different kind!
79  other_scope.lookup(base_name, QUALIFIED, id_set);
80  }
81 
82  if(kind==QUALIFIED)
83  return; // done
84  if(!id_set.empty())
85  return; // done
86 
87  // ask parent, recursive call
88  if(!is_root_scope())
90 }
91 
93  const irep_idt &base_name,
94  lookup_kindt kind,
95  cpp_idt::id_classt id_class,
96  id_sett &id_set)
97 {
98  // we have a hack to do full search in case we
99  // are looking for templates!
100 
101  #if 0
102  std::cout << "B: " << base_name << '\n';
103  std::cout << "K: " << kind << '\n';
104  std::cout << "I: " << id_class << '\n';
105  std::cout << "THIS: " << this->base_name << " " << this->id_class
106  << " " << this->identifier << '\n';
107  #endif
108 
109  cpp_id_mapt::iterator
110  lower_it=sub.lower_bound(base_name);
111 
112  if(lower_it!=sub.end())
113  {
114  cpp_id_mapt::iterator
115  upper_it=sub.upper_bound(base_name);
116 
117  for(cpp_id_mapt::iterator n_it=lower_it;
118  n_it!=upper_it; n_it++)
119  {
120  if(n_it->second.id_class == id_class)
121  id_set.insert(&n_it->second);
122  }
123  }
124 
125  if(this->base_name == base_name &&
126  this->id_class == id_class)
127  id_set.insert(this);
128 
129  if(kind==SCOPE_ONLY)
130  return; // done
131 
132  // using scopes
133  for(scope_listt::iterator
134  it=using_scopes.begin();
135  it!=using_scopes.end();
136  it++)
137  {
138  cpp_scopet &other_scope=static_cast<cpp_scopet &>(**it);
139 
140  // Recursive call.
141  // Note the different kind!
142  other_scope.lookup(base_name, QUALIFIED, id_class, id_set);
143  }
144 
145  if(!id_set.empty() && id_class != id_classt::TEMPLATE)
146  return; // done, upwards scopes are hidden
147 
148  // secondary scopes
149  for(scope_listt::iterator
150  it=secondary_scopes.begin();
151  it!=secondary_scopes.end();
152  it++)
153  {
154  cpp_scopet &other_scope=static_cast<cpp_scopet &>(**it);
155 
156  // Recursive call.
157  // Note the different kind!
158  other_scope.lookup(base_name, QUALIFIED, id_class, id_set);
159  }
160 
161  if(kind==QUALIFIED)
162  return; // done
163 
164  if(!id_set.empty() &&
165  id_class!=id_classt::TEMPLATE) return; // done, upwards scopes are hidden
166 
167  // ask parent, recursive call
168  if(!is_root_scope())
170 }
171 
173  const irep_idt &identifier,
174  cpp_idt::id_classt id_class,
175  id_sett &id_set)
176 {
177  for(cpp_id_mapt::iterator n_it=sub.begin();
178  n_it!=sub.end(); n_it++)
179  {
180  if(n_it->second.identifier == identifier
181  && n_it->second.id_class == id_class)
182  id_set.insert(&n_it->second);
183  }
184 
185  if(this->identifier == identifier
186  && this->id_class == id_class)
187  id_set.insert(this);
188 
189  #if 0
190  for(std::size_t i=0; i<parents_size(); i++)
191  {
194  && parent.id_class == id_class)
195  id_set.insert(&parent);
196  }
197  #endif
198 }
199 
201 {
202  cpp_idt &id=insert(new_scope_name);
203  id.identifier=prefix+id2string(new_scope_name);
204  id.prefix=prefix+id2string(new_scope_name)+"::";
205  id.this_expr=this_expr;
206  id.class_identifier=class_identifier;
207  id.is_scope=true;
208  return (cpp_scopet &)id;
209 }
210 
211 
212 bool cpp_scopet::contains(const irep_idt &base_name)
213 {
214  id_sett id_set;
216  return !id_set.empty();
217 }
cpp_id_mapt sub
Definition: cpp_id.h:105
cpp_idt * parent
Definition: cpp_id.h:110
const std::string & id2string(const irep_idt &d)
Definition: irep.h:43
void lookup(const irep_idt &base_name, lookup_kindt kind, id_sett &id_set)
Definition: cpp_scope.cpp:29
class cpp_scopet & new_scope(const irep_idt &new_scope_name)
Definition: cpp_scope.cpp:200
cpp_scopet & get_parent() const
Definition: cpp_scope.h:89
std::ostream & operator<<(std::ostream &out, cpp_scopet::lookup_kindt kind)
Definition: cpp_scope.cpp:16
std::string prefix
Definition: cpp_id.h:80
irep_idt base_name
Definition: cpp_id.h:73
irep_idt identifier
Definition: cpp_id.h:73
id_classt id_class
Definition: cpp_id.h:51
scope_listt using_scopes
Definition: cpp_id.h:109
irep_idt class_identifier
Definition: cpp_id.h:76
C++ Language Type Checking.
C++ Language Type Checking.
exprt this_expr
Definition: cpp_id.h:77
bool contains(const irep_idt &base_name)
Definition: cpp_scope.cpp:212
#define UNREACHABLE
Definition: invariant.h:250
id_classt
Definition: cpp_id.h:33
scope_listt secondary_scopes
Definition: cpp_id.h:109
Definition: cpp_id.h:28
bool is_root_scope() const
Definition: cpp_scope.h:73
cpp_idt & insert(const irep_idt &_base_name)
Definition: cpp_scope.h:48
std::set< cpp_idt * > id_sett
Definition: cpp_scope.h:28
void lookup_identifier(const irep_idt &identifier, cpp_idt::id_classt id_class, id_sett &id_set)
Definition: cpp_scope.cpp:172