forked from panda3d/panda3d
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathcppConstType.cxx
More file actions
232 lines (203 loc) · 5.72 KB
/
cppConstType.cxx
File metadata and controls
232 lines (203 loc) · 5.72 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
/**
* PANDA 3D SOFTWARE
* Copyright (c) Carnegie Mellon University. All rights reserved.
*
* All use of this software is subject to the terms of the revised BSD
* license. You should have received a copy of this license along
* with this source code in a file named "LICENSE."
*
* @file cppConstType.cxx
* @author drose
* @date 1999-10-28
*/
#include "cppConstType.h"
/**
*
*/
CPPConstType::
CPPConstType(CPPType *wrapped_around) :
CPPType(CPPFile()),
_wrapped_around(wrapped_around)
{
}
/**
* Returns true if this declaration is an actual, factual declaration, or
* false if some part of the declaration depends on a template parameter which
* has not yet been instantiated.
*/
bool CPPConstType::
is_fully_specified() const {
return CPPType::is_fully_specified() &&
_wrapped_around->is_fully_specified();
}
/**
*
*/
CPPDeclaration *CPPConstType::
substitute_decl(CPPDeclaration::SubstDecl &subst,
CPPScope *current_scope, CPPScope *global_scope) {
SubstDecl::const_iterator si = subst.find(this);
if (si != subst.end()) {
return (*si).second;
}
CPPConstType *rep = new CPPConstType(*this);
rep->_wrapped_around =
_wrapped_around->substitute_decl(subst, current_scope, global_scope)
->as_type();
if (rep->_wrapped_around == _wrapped_around) {
delete rep;
rep = this;
}
rep = CPPType::new_type(rep)->as_const_type();
subst.insert(SubstDecl::value_type(this, rep));
return rep;
}
/**
* If this CPPType object is a forward reference or other nonspecified
* reference to a type that might now be known a real type, returns the real
* type. Otherwise returns the type itself.
*/
CPPType *CPPConstType::
resolve_type(CPPScope *current_scope, CPPScope *global_scope) {
CPPType *ptype = _wrapped_around->resolve_type(current_scope, global_scope);
if (ptype != _wrapped_around) {
CPPConstType *rep = new CPPConstType(*this);
rep->_wrapped_around = ptype;
return CPPType::new_type(rep);
}
return this;
}
/**
* Returns true if the type, or any nested type within the type, is a
* CPPTBDType and thus isn't fully determined right now. In this case,
* calling resolve_type() may or may not resolve the type.
*/
bool CPPConstType::
is_tbd() const {
return _wrapped_around->is_tbd();
}
/**
* Returns true if the type is considered a fundamental type.
*/
bool CPPConstType::
is_fundamental() const {
return _wrapped_around->is_fundamental();
}
/**
* Returns true if the type is considered a standard layout type.
*/
bool CPPConstType::
is_standard_layout() const {
return _wrapped_around->is_standard_layout();
}
/**
* Returns true if the type is considered a Plain Old Data (POD) type.
*/
bool CPPConstType::
is_trivial() const {
return _wrapped_around->is_trivial();
}
/**
* Returns true if the type can be constructed using the given argument.
*/
bool CPPConstType::
is_constructible(const CPPType *given_type) const {
return _wrapped_around->is_constructible(given_type);
}
/**
* Returns true if the type is default-constructible.
*/
bool CPPConstType::
is_default_constructible() const {
return _wrapped_around->is_default_constructible();
}
/**
* Returns true if the type is copy-constructible.
*/
bool CPPConstType::
is_copy_constructible() const {
return _wrapped_around->is_copy_constructible();
}
/**
* Returns true if the type is destructible.
*/
bool CPPConstType::
is_destructible() const {
return _wrapped_around->is_destructible();
}
/**
* Returns true if variables of this type may be implicitly converted to
* the other type.
*/
bool CPPConstType::
is_convertible_to(const CPPType *other) const {
return _wrapped_around->is_convertible_to(other);
}
/**
* This is a little more forgiving than is_equal(): it returns true if the
* types appear to be referring to the same thing, even if they may have
* different pointers or somewhat different definitions. It's useful for
* parameter matching, etc.
*/
bool CPPConstType::
is_equivalent(const CPPType &other) const {
const CPPConstType *ot = ((CPPType *)&other)->as_const_type();
if (ot == nullptr) {
return CPPType::is_equivalent(other);
}
return _wrapped_around->is_equivalent(*ot->_wrapped_around);
}
/**
*
*/
void CPPConstType::
output(std::ostream &out, int indent_level, CPPScope *scope, bool complete) const {
_wrapped_around->output(out, indent_level, scope, complete);
out << " const";
}
/**
* Formats a C++-looking line that defines an instance of the given type, with
* the indicated name. In most cases this will be "type name", but some types
* have special exceptions.
*/
void CPPConstType::
output_instance(std::ostream &out, int indent_level, CPPScope *scope,
bool complete, const std::string &prename,
const std::string &name) const {
_wrapped_around->output_instance(out, indent_level, scope, complete,
"const " + prename, name);
}
/**
*
*/
CPPDeclaration::SubType CPPConstType::
get_subtype() const {
return ST_const;
}
/**
*
*/
CPPConstType *CPPConstType::
as_const_type() {
return this;
}
/**
* Called by CPPDeclaration() to determine whether this type is equivalent to
* another type of the same type.
*/
bool CPPConstType::
is_equal(const CPPDeclaration *other) const {
const CPPConstType *ot = ((CPPDeclaration *)other)->as_const_type();
assert(ot != nullptr);
return _wrapped_around == ot->_wrapped_around;
}
/**
* Called by CPPDeclaration() to determine whether this type should be ordered
* before another type of the same type, in an arbitrary but fixed ordering.
*/
bool CPPConstType::
is_less(const CPPDeclaration *other) const {
const CPPConstType *ot = ((CPPDeclaration *)other)->as_const_type();
assert(ot != nullptr);
return _wrapped_around < ot->_wrapped_around;
}