1 : //==============================================================================
2 : // File <$/src/cpp/dev/idlc/idl_type.cpp>
3 : // This file is part of YaOrb : Yet Another Object Request Broker,
4 : // Copyright (c) 2000-2003, 2006, Marc Alff.
5 : //
6 : // This program is free software; you can redistribute it and/or
7 : // modify it under the terms of the GNU General Public License
8 : // as published by the Free Software Foundation; either version 2
9 : // of the License, or (at your option) any later version.
10 : //
11 : // This program is distributed in the hope that it will be useful,
12 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : // GNU General Public License for more details.
15 : //
16 : // You should have received a copy of the GNU General Public License
17 : // along with this program; if not, write to the Free Software
18 : // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19 : //
20 : //==============================================================================
21 :
22 : #include <iostream>
23 :
24 : #include "src/cpp/prod/tool/DEVELOPMENT.h"
25 : #include "src/cpp/prod/tool/Assert.h"
26 :
27 : #include "src/cpp/dev/idlc/idl_type.h"
28 : #include "src/cpp/dev/idlc/symbol.h"
29 : #include "src/cpp/dev/idlc/enum.h"
30 : #include "src/cpp/dev/idlc/struct.h"
31 : #include "src/cpp/dev/idlc/typedef.h"
32 : #include "src/cpp/dev/idlc/interface.h"
33 : #include "src/cpp/dev/idlc/native.h"
34 : #include "src/cpp/dev/idlc/all_symbols.h"
35 :
36 : // IDLType
37 :
38 11118 : IDLType::IDLType(IDLType_e type)
39 11118 : : _type(type), _hook(NULL)
40 : {}
41 :
42 9719 : IDLType::~IDLType()
43 0 : {}
44 :
45 15126 : IDLType_e IDLType::isA() const
46 : {
47 : return _type ;
48 : }
49 :
50 0 : void* IDLType::GetHook(void) const
51 : {
52 : return _hook ;
53 : }
54 :
55 0 : void IDLType::SetHook(void* hook)
56 : {
57 0 : _hook = hook ;
58 : }
59 :
60 747 : IDLType* IDLType::ResolveAlias(IDLType *type)
61 : {
62 : ASSERT(type != NULL) ;
63 : IDLTypedefType *td = NULL ;
64 : Typedef *symbol = NULL ;
65 :
66 1598 : while (type->isA() == idl_typedef)
67 : {
68 : td = (IDLTypedefType*) type ;
69 104 : symbol = td->GetSymbol() ;
70 : ASSERT(symbol != NULL) ;
71 104 : type = symbol->GetType() ;
72 : ASSERT(type != NULL) ;
73 : }
74 :
75 : return type ;
76 : }
77 :
78 :
79 : // IDLErrorType
80 :
81 9 : IDLErrorType::IDLErrorType()
82 9 : : IDLType(idl_errorType)
83 : {}
84 :
85 9 : IDLErrorType::~IDLErrorType()
86 9 : {}
87 :
88 0 : void IDLErrorType::print(std::ostream& str)
89 : {
90 0 : str << "idl type error" ;
91 : }
92 :
93 : // IDLIntType
94 :
95 1615 : IDLIntType::IDLIntType(IDLIntType_e type)
96 1615 : : IDLType(idl_intType), _type(type)
97 : {}
98 :
99 1237 : IDLIntType::~IDLIntType()
100 1237 : {}
101 :
102 1605 : IDLIntType_e IDLIntType::GetType(void) const
103 : {
104 : return _type ;
105 : }
106 :
107 54 : void IDLIntType::print(std::ostream& str)
108 : {
109 54 : switch (_type)
110 : {
111 : case idl_signed_short :
112 27 : { str << "idl signed short" ; break ; }
113 : case idl_signed_long :
114 9 : { str << "idl signed long" ; break ; }
115 : case idl_signed_long_long :
116 2 : { str << "idl signed long long" ; break ; }
117 : case idl_unsigned_short :
118 12 : { str << "idl unsigned short" ; break ; }
119 : case idl_unsigned_long :
120 4 : { str << "idl unsigned long" ; break ; }
121 : case idl_unsigned_long_long :
122 0 : { str << "idl unsigned long long" ; break ; }
123 : }
124 : }
125 :
126 : // IDLFloatType
127 :
128 15 : IDLFloatType::IDLFloatType(IDLFloatType_e type)
129 15 : : IDLType(idl_floatType), _type(type)
130 : {}
131 :
132 15 : IDLFloatType::~IDLFloatType()
133 15 : {}
134 :
135 27 : IDLFloatType_e IDLFloatType::GetType(void) const
136 : {
137 : return _type ;
138 : }
139 :
140 0 : void IDLFloatType::print(std::ostream& str)
141 : {
142 0 : switch(_type)
143 : {
144 : case idl_float :
145 : {
146 0 : str << "idl float" ;
147 : break ;
148 : }
149 : case idl_double :
150 : {
151 0 : str << "idl double" ;
152 : break ;
153 : }
154 : case idl_long_double :
155 : {
156 0 : str << "idl long double" ;
157 : break ;
158 : }
159 : }
160 : }
161 :
162 : // IDLCharType
163 :
164 148 : IDLCharType::IDLCharType()
165 148 : : IDLType(idl_charType)
166 : {}
167 :
168 83 : IDLCharType::~IDLCharType()
169 83 : {}
170 :
171 2 : void IDLCharType::print(std::ostream& str)
172 : {
173 2 : str << "idl char" ;
174 : }
175 :
176 : // IDLWCharType
177 :
178 131 : IDLWCharType::IDLWCharType()
179 131 : : IDLType(idl_wcharType)
180 : {}
181 :
182 68 : IDLWCharType::~IDLWCharType()
183 68 : {}
184 :
185 2 : void IDLWCharType::print(std::ostream& str)
186 : {
187 2 : str << "idl wchar" ;
188 : }
189 :
190 : // IDLBoolType
191 :
192 669 : IDLBoolType::IDLBoolType()
193 669 : : IDLType(idl_boolType)
194 : {}
195 :
196 621 : IDLBoolType::~IDLBoolType()
197 621 : {}
198 :
199 0 : void IDLBoolType::print(std::ostream& str)
200 : {
201 0 : NON_DEV("print") ;
202 : }
203 :
204 : // IDLTemplateType
205 :
206 627 : IDLTemplateType::IDLTemplateType(IDLType_e type)
207 627 : : IDLType(type), _bounded(false), _maxSize(0)
208 : {
209 : }
210 :
211 0 : IDLTemplateType::IDLTemplateType(IDLType_e type, int maxSize)
212 0 : : IDLType(type), _bounded(true), _maxSize(maxSize)
213 : {
214 : }
215 :
216 531 : IDLTemplateType::~IDLTemplateType()
217 531 : {}
218 :
219 48 : bool IDLTemplateType::IsBounded(void) const
220 : {
221 : return _bounded ;
222 : }
223 :
224 0 : int IDLTemplateType::GetMaxSize(void) const
225 : {
226 : return _maxSize ;
227 : }
228 :
229 : // IDLSequenceType
230 :
231 389 : IDLSequenceType::IDLSequenceType(IDLType *baseType)
232 389 : : IDLTemplateType(idl_sequence), _baseType(baseType)
233 : {
234 : }
235 :
236 0 : IDLSequenceType::IDLSequenceType(IDLType *baseType, int maxSize)
237 0 : : IDLTemplateType(idl_sequence, maxSize), _baseType(baseType)
238 : {
239 : }
240 :
241 389 : IDLSequenceType::~IDLSequenceType()
242 389 : {}
243 :
244 48 : IDLType* IDLSequenceType::GetType(void) const
245 : {
246 : return _baseType ;
247 : }
248 :
249 0 : void IDLSequenceType::print(std::ostream &str)
250 : {
251 0 : str << "sequence <" ;
252 0 : _baseType->print(str) ;
253 :
254 0 : if (_bounded)
255 : {
256 0 : str << ", " << _maxSize ;
257 : }
258 :
259 0 : str << ">" ;
260 : }
261 :
262 : // IDLStringType
263 :
264 189 : IDLStringType::IDLStringType()
265 189 : : IDLTemplateType(idl_string)
266 : {}
267 :
268 0 : IDLStringType::IDLStringType(int maxSize)
269 0 : : IDLTemplateType(idl_string, maxSize)
270 : {}
271 :
272 141 : IDLStringType::~IDLStringType()
273 141 : {}
274 :
275 1 : void IDLStringType::print(std::ostream &str)
276 : {
277 1 : str << "string" ;
278 :
279 1 : if (_bounded)
280 : {
281 0 : str << "<" << _maxSize << ">" ;
282 : }
283 : }
284 :
285 : // IDLWStringType
286 :
287 49 : IDLWStringType::IDLWStringType()
288 49 : : IDLTemplateType(idl_wstring)
289 : {}
290 :
291 0 : IDLWStringType::IDLWStringType(int maxSize)
292 0 : : IDLTemplateType(idl_wstring, maxSize)
293 : {}
294 :
295 1 : IDLWStringType::~IDLWStringType()
296 1 : {}
297 :
298 1 : void IDLWStringType::print(std::ostream &str)
299 : {
300 1 : str << "wstring" ;
301 :
302 1 : if (_bounded)
303 : {
304 0 : str << "<" << _maxSize << ">" ;
305 : }
306 : }
307 :
308 : // IDLVoidType
309 :
310 464 : IDLVoidType::IDLVoidType()
311 464 : : IDLType(idl_void)
312 : {}
313 :
314 464 : IDLVoidType::~IDLVoidType()
315 464 : {}
316 :
317 0 : void IDLVoidType::print(std::ostream &str)
318 : {
319 0 : str << "void" ;
320 : }
321 :
322 : // IDLArrayType
323 :
324 0 : IDLArrayType::IDLArrayType(int size, IDLType *type)
325 0 : : IDLType(idl_array), _size(size), _type(type)
326 : {
327 : }
328 :
329 0 : IDLArrayType::~IDLArrayType()
330 : {
331 0 : delete _type ;
332 0 : }
333 :
334 0 : void IDLArrayType::print(std::ostream &str)
335 : {
336 0 : str << "Array[" << _size <<"] of " ;
337 0 : _type->print(str) ;
338 : }
339 :
340 : // IDLEnumType
341 :
342 389 : IDLEnumType::IDLEnumType(Enum *symbol)
343 389 : : IDLType(idl_enum), _symbol(symbol)
344 : {
345 : }
346 :
347 389 : IDLEnumType::~IDLEnumType()
348 : {
349 : // Do NOT delete _symbol ;
350 389 : }
351 :
352 0 : void IDLEnumType::print(std::ostream& str)
353 : {
354 0 : str << "Enum: " << _symbol->GetName() ;
355 : }
356 :
357 244 : Enum* IDLEnumType::GetSymbol(void) const
358 : {
359 : return _symbol ;
360 : }
361 :
362 : // IDLStructType
363 :
364 786 : IDLStructType::IDLStructType(Struct *symbol)
365 786 : : IDLType(idl_struct), _symbol(symbol)
366 : {
367 : }
368 :
369 202 : IDLStructType::~IDLStructType()
370 : {
371 : // Do NOT delete _symbol ;
372 202 : }
373 :
374 0 : void IDLStructType::print(std::ostream& str)
375 : {
376 0 : str << "Struct: " << _symbol->GetName() ;
377 : }
378 :
379 233 : Struct* IDLStructType::GetSymbol(void) const
380 : {
381 : return _symbol ;
382 : }
383 :
384 : // IDLTypedefType
385 :
386 3568 : IDLTypedefType::IDLTypedefType(Typedef *symbol)
387 3568 : : IDLType(idl_typedef), _symbol(symbol)
388 : {
389 : }
390 :
391 3507 : IDLTypedefType::~IDLTypedefType()
392 : {
393 : // Do NOT delete _symbol ;
394 3507 : }
395 :
396 0 : void IDLTypedefType::print(std::ostream& str)
397 : {
398 0 : str << "Typedef: " << _symbol->GetName() ;
399 : }
400 :
401 1836 : Typedef* IDLTypedefType::GetSymbol(void) const
402 : {
403 : return _symbol ;
404 : }
405 :
406 :
407 256 : IDLAnyType::IDLAnyType()
408 256 : : IDLType(idl_any)
409 : {}
410 :
411 255 : IDLAnyType::~IDLAnyType()
412 255 : {}
413 :
414 0 : void IDLAnyType::print(std::ostream& str)
415 : {
416 0 : str << "any" ;
417 : }
418 :
419 82 : IDLObjectType::IDLObjectType()
420 82 : : IDLType(idl_object)
421 : {}
422 :
423 82 : IDLObjectType::~IDLObjectType()
424 82 : {}
425 :
426 0 : void IDLObjectType::print(std::ostream& str)
427 : {
428 0 : str << "object" ;
429 : }
430 :
431 : // IDLOctetType
432 :
433 9 : IDLOctetType::IDLOctetType()
434 9 : : IDLType(idl_octet)
435 : {}
436 :
437 4 : IDLOctetType::~IDLOctetType()
438 4 : {}
439 :
440 4 : void IDLOctetType::print(std::ostream& str)
441 : {
442 4 : str << "octet" ;
443 : }
444 :
445 : // IDLNativeType
446 :
447 28 : IDLNativeType::IDLNativeType(SymNative *symbol)
448 28 : : IDLType(idl_native), _symbol(symbol)
449 : {
450 : }
451 :
452 28 : IDLNativeType::~IDLNativeType()
453 : {
454 : // Do NOT delete _symbol
455 28 : }
456 :
457 14 : SymNative* IDLNativeType::GetSymbol(void) const
458 : {
459 : return _symbol ;
460 : }
461 :
462 0 : void IDLNativeType::print(std::ostream& str)
463 : {
464 0 : str << "Native: " << _symbol->GetName() ;
465 : }
466 :
467 : // IDLInterfaceType
468 :
469 2322 : IDLInterfaceType::IDLInterfaceType(Interface *symbol)
470 2322 : : IDLType(idl_interface), _symbol(symbol)
471 : {
472 : }
473 :
474 2224 : IDLInterfaceType::~IDLInterfaceType()
475 : {
476 : // Do NOT delete _symbol ;
477 2224 : }
478 :
479 0 : void IDLInterfaceType::print(std::ostream& str)
480 : {
481 0 : str << "Interface: " << _symbol->GetName() ;
482 : }
483 :
484 2152 : Interface* IDLInterfaceType::GetSymbol(void) const
485 : {
486 : return _symbol ;
487 63 : }
488 63 :
|
