1 : //==============================================================================
2 : // File <$/src/cpp/dev/idlc/back/lang_cpp/lang_cpp.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 : // Portability
23 : #include "yaorb/config.h"
24 : #include "src/cpp/prod/port/port_stdc.h"
25 :
26 : #include <stdlib.h>
27 : #include <fstream>
28 : #include <ctype.h>
29 :
30 : #include "src/cpp/prod/tool/DEVELOPMENT.h"
31 :
32 : #include "src/cpp/prod/tool/Assert.h"
33 :
34 : #include "src/cpp/dev/idlc/sym_tab.h"
35 : #include "src/cpp/dev/idlc/all_symbols.h"
36 : #include "src/cpp/dev/idlc/interface.h"
37 : #include "src/cpp/dev/idlc/native.h"
38 : #include "src/cpp/dev/idlc/attribute.h"
39 : #include "src/cpp/dev/idlc/struct.h"
40 : #include "src/cpp/dev/idlc/exception.h"
41 : #include "src/cpp/dev/idlc/struct_member.h"
42 : #include "src/cpp/dev/idlc/enum.h"
43 : #include "src/cpp/dev/idlc/enum_item.h"
44 : #include "src/cpp/dev/idlc/operation.h"
45 : #include "src/cpp/dev/idlc/typedef.h"
46 : #include "src/cpp/dev/idlc/idl_type.h"
47 : #include "src/cpp/dev/idlc/value.h"
48 : #include "src/cpp/dev/idlc/char_value.h"
49 : #include "src/cpp/dev/idlc/wchar_value.h"
50 : #include "src/cpp/dev/idlc/int_value.h"
51 : #include "src/cpp/dev/idlc/string_value.h"
52 : #include "src/cpp/dev/idlc/wstring_value.h"
53 : #include "src/cpp/dev/idlc/yyutils.h"
54 : #include "src/cpp/dev/idlc/back/lang_cpp/lang_cpp.h"
55 : #include "src/cpp/dev/idlc/back/lang_cpp/info.h"
56 :
57 : // since ostream and endl is used **so much** ...
58 : // This setting is private to this file though
59 : using namespace std ;
60 :
61 33 : const String LangCpp::_tab(" ") ;
62 :
63 0 : static void PrintNiceChar(char c, ostream& str)
64 : {
65 0 : switch(c)
66 : {
67 : case '\n' :
68 : {
69 0 : str << "\\n" ;
70 0 : break ;
71 : }
72 : case '\t' :
73 : {
74 0 : str << "\\t" ;
75 0 : break ;
76 : }
77 : case '\v' :
78 : {
79 0 : str << "\\v" ;
80 0 : break ;
81 : }
82 : case '\b' :
83 : {
84 0 : str << "\\b" ;
85 0 : break ;
86 : }
87 : case '\r' :
88 : {
89 0 : str << "\\r" ;
90 0 : break ;
91 : }
92 : case '\f' :
93 : {
94 0 : str << "\\f" ;
95 0 : break ;
96 : }
97 : case '\a' :
98 : {
99 0 : str << "\\a" ;
100 0 : break ;
101 : }
102 : case '\\' :
103 : {
104 0 : str << "\\\\" ;
105 0 : break ;
106 : }
107 : case '\'' :
108 : {
109 0 : str << "\\\'" ;
110 0 : break ;
111 : }
112 : case '\"' :
113 : {
114 0 : str << "\\\"" ;
115 0 : break ;
116 : }
117 : default :
118 : {
119 0 : if (isprint(c))
120 : {
121 0 : str << c ;
122 : }
123 : else
124 : {
125 : char buf[5] ;
126 0 : sprintf (buf, "\\x%02x", c) ;
127 0 : str << buf ;
128 : }
129 : }
130 : }
131 : }
132 :
133 28 : LangCpp::LangCpp()
134 : :
135 : _H(),
136 : _Cpp(),
137 : _StubH(),
138 : _StubCpp(),
139 : _SkelH(),
140 : _SkelCpp(),
141 : _generateModuleName(),
142 : _generateModuleOption(false),
143 : _outputFileName(),
144 28 : _outputDirName()
145 : {
146 0 : }
147 :
148 28 : LangCpp::~LangCpp()
149 28 : {}
150 :
151 11071 : CppInfo* LangCpp::GetCppInfo(Symbol *s)
152 : {
153 : ASSERT(s != NULL) ;
154 11071 : CppInfo *result = (CppInfo*) s->GetHook() ;
155 11071 : if (result == NULL)
156 : {
157 685 : result = new CppInfo(s) ;
158 685 : s->SetHook(result) ;
159 : }
160 : return result ;
161 : }
162 :
163 2023 : void LangCpp::SetCppInfo(Symbol *s, CppInfo *i)
164 : {
165 : ASSERT(s != NULL) ;
166 : ASSERT(i != NULL) ;
167 2023 : s->SetHook(i) ;
168 : }
169 :
170 232 : ostream& LangCpp::Tabulate(ostream& str, int level)
171 : {
172 536 : while (level > 0)
173 : {
174 304 : str << _tab ;
175 : level-- ;
176 : }
177 :
178 : return str ;
179 : }
180 :
181 27 : void LangCpp::SetGenerateOption(const String& module)
182 : {
183 27 : _generateModuleOption = true ;
184 27 : _generateModuleName = module ;
185 : }
186 :
187 28 : void LangCpp::SetOutputFile(const String& filename)
188 : {
189 28 : _outputFileName = filename ;
190 : }
191 :
192 28 : void LangCpp::SetOutputDir(const String& dirname)
193 : {
194 28 : _outputDirName = dirname ;
195 : }
196 :
197 28 : void LangCpp::Headers(void)
198 : {
199 : static const char* text[] =
200 : {
201 : "",
202 : "// This file was automatically generated by YaOrb IDL->C++ compiler.",
203 : "// DO NOT EDIT !",
204 : "",
205 : NULL
206 : } ;
207 :
208 28 : _H.PrintText(text) ;
209 28 : _Cpp.PrintText(text) ;
210 28 : _StubH.PrintText(text) ;
211 28 : _StubCpp.PrintText(text) ;
212 28 : _SkelH.PrintText(text) ;
213 28 : _SkelCpp.PrintText(text) ;
214 :
215 : return ;
216 : }
217 :
218 2239 : String LangCpp::Prefix(const String& idlFullName)
219 : {
220 : // extract A::B::C from A::B::C::Z
221 :
222 2239 : String result ;
223 :
224 2239 : char *tmp = strdup(idlFullName) ;
225 2239 : char *end = tmp + strlen(tmp) ;
226 :
227 4478 : while ((tmp <= end) && (*end != ':')) end-- ; // Eat Z
228 :
229 : ASSERT(tmp +1 <= end) ;
230 : end -- ; // eat "::"
231 :
232 2239 : *end = '\0' ;
233 :
234 2239 : result = tmp ;
235 2239 : free(tmp) ;
236 :
237 0 : return result ;
238 : }
239 :
240 28 : void LangCpp::GenerateCode(SymbolTable *symTab)
241 : {
242 28 : CppInfo _info (_outputFileName) ;
243 :
244 28 : String name_h = _info._cppName ;
245 28 : String name_cpp = _info._cppName ;
246 28 : name_h += ".h" ;
247 28 : name_cpp += ".cpp" ;
248 :
249 28 : String stub_name_h = _info._cppStubName ;
250 28 : String stub_name_cpp = _info._cppStubName ;
251 28 : stub_name_h += ".h" ;
252 28 : stub_name_cpp += ".cpp" ;
253 :
254 28 : String skel_name_h = _info._cppSkelName ;
255 28 : String skel_name_cpp = _info._cppSkelName ;
256 28 : skel_name_h += ".h" ;
257 28 : skel_name_cpp += ".cpp" ;
258 :
259 28 : _H.open(_outputDirName, name_h) ;
260 28 : _Cpp.open(_outputDirName, name_cpp) ;
261 28 : _StubH.open(_outputDirName, stub_name_h) ;
262 28 : _StubCpp.open(_outputDirName, stub_name_cpp) ;
263 28 : _SkelH.open(_outputDirName, skel_name_h) ;
264 28 : _SkelCpp.open(_outputDirName, skel_name_cpp) ;
265 :
266 28 : Headers() ;
267 :
268 28 : _H.Tab() << "#ifndef __" << _outputFileName << "_H" << endl ;
269 28 : _H.Tab() << "#define __" << _outputFileName << "_H" << endl ;
270 28 : _H.Tab() << endl ;
271 :
272 28 : _Cpp.Tab() << "#include <stdio.h>" << endl ;
273 28 : _Cpp.Tab() << "#include <yaorb/CORBA.h>" << endl ;
274 28 : _Cpp.Tab() << "#include <yaorb/YAORB.h>" << endl ;
275 28 : _Cpp.Tab() << "#include \"" << name_h << "\"" << endl << endl ;
276 :
277 28 : _StubH.Tab() << "#ifndef __" << _outputFileName << "_STUB_H" << endl ;
278 28 : _StubH.Tab() << "#define __" << _outputFileName << "_STUB_H" << endl ;
279 28 : _StubH.Tab() << "#include \"" << name_h << "\"" << endl << endl ;
280 :
281 28 : _StubCpp.Tab() << "#include <yaorb/CORBA.h>" << endl ;
282 28 : _StubCpp.Tab() << "#include <yaorb/YAORB.h>" << endl ;
283 28 : _StubCpp.Tab() << "#include \"" << stub_name_h << "\"" << endl << endl ;
284 :
285 28 : _SkelH.Tab() << "#ifndef __" << _outputFileName << "_SKEL_H" << endl ;
286 28 : _SkelH.Tab() << "#define __" << _outputFileName << "_SKEL_H" << endl ;
287 28 : _SkelH.Tab() << "#include \"" << name_h << "\"" << endl << endl ;
288 :
289 28 : _SkelCpp.Tab() << "#include <yaorb/CORBA.h>" << endl ;
290 28 : _SkelCpp.Tab() << "#include <yaorb/YAORB.h>" << endl ;
291 28 : _SkelCpp.Tab() << "#include \"" << skel_name_h << "\"" << endl << endl ;
292 :
293 28 : GenerateContextForwardDecl(symTab, false) ;
294 28 : GenerateContextDecl(symTab, false) ;
295 28 : GenerateContextImpl(symTab, false) ;
296 :
297 28 : _SkelH.Tab() << "#endif" << endl ;
298 :
299 28 : _StubH.Tab() << "#endif" << endl ;
300 :
301 28 : _H.Tab() << "#endif" << endl ;
302 :
303 28 : _H.close() ;
304 28 : _Cpp.close() ;
305 28 : _StubH.close() ;
306 28 : _StubCpp.close() ;
307 28 : _SkelH.close() ;
308 28 : _SkelCpp.close() ;
309 : }
310 :
311 : void LangCpp::GenerateContextDecl(
312 : SymbolContainer *symTab,
313 251 : bool pseudo)
314 : {
315 251 : const SymbolList& symbols = symTab->GetLocalSymbols() ;
316 : Symbol *symbol = NULL ;
317 : SymbolListIt it(symbols) ;
318 251 : String name ;
319 251 : int len = strlen(_generateModuleName) ;
320 :
321 1831 : while (it.GetNext())
322 : {
323 : symbol = it.GetItem() ;
324 :
325 1329 : if (_generateModuleOption == true)
326 : {
327 1029 : name = symbol->GetFullyQualifiedName() ;
328 :
329 : // If the symbol is in the module to generate ...
330 1029 : if (strncmp(name, _generateModuleName, len) == 0)
331 : {
332 987 : GenerateOneSymbolDecl(symTab, symbol, pseudo) ;
333 : }
334 : }
335 : else
336 : {
337 300 : GenerateOneSymbolDecl(symTab, symbol, pseudo) ;
338 : }
339 0 : }
340 : }
341 :
342 251 : void LangCpp::GenerateContextImpl(SymbolContainer *symTab, bool pseudo)
343 : {
344 251 : const SymbolList& symbols = symTab->GetLocalSymbols() ;
345 : Symbol *symbol = NULL ;
346 : SymbolListIt it(symbols) ;
347 251 : String name ;
348 251 : int len = strlen(_generateModuleName) ;
349 :
350 1831 : while (it.GetNext())
351 : {
352 : symbol = it.GetItem() ;
353 :
354 1329 : if (_generateModuleOption == true)
355 : {
356 1029 : name = symbol->GetFullyQualifiedName() ;
357 :
358 : // If the symbol is in the module to generate ...
359 1029 : if (strncmp(name, _generateModuleName, len) == 0)
360 : {
361 987 : GenerateOneSymbolImpl(symTab, symbol, pseudo) ;
362 : }
363 : }
364 : else
365 : {
366 300 : GenerateOneSymbolImpl(symTab, symbol, pseudo) ;
367 : }
368 0 : }
369 : }
370 :
371 : void LangCpp::GenerateContextForwardDecl(
372 : SymbolContainer *symTab,
373 251 : bool pseudo)
374 : {
375 251 : const SymbolList& symbols = symTab->GetLocalSymbols() ;
376 : Symbol *symbol = NULL ;
377 : Interface *interface = NULL ;
378 : SymbolListIt it(symbols) ;
379 :
380 1831 : while (it.GetNext())
381 : {
382 : symbol = it.GetItem() ;
383 :
384 1329 : if (symbol->GetClass() == interfaceSymbol)
385 : {
386 : interface = (Interface*) symbol ;
387 196 : GenerateInterfaceForwardDecl(symTab, interface, pseudo) ;
388 : }
389 : }
390 : }
391 :
392 : void LangCpp::GenerateOneSymbolDecl(
393 : SymbolContainer *symTab,
394 : Symbol *symbol,
395 1287 : bool pseudo)
396 : {
397 1287 : switch(symbol->GetClass())
398 : {
399 : case moduleSymbol:
400 : {
401 : Module *m = (Module*) symbol ;
402 27 : GenerateModuleDecl(symTab, m) ;
403 : break ;
404 : }
405 : case interfaceSymbol :
406 : {
407 : Interface *i = (Interface*) symbol ;
408 196 : GenerateInterfaceDecl(symTab, i) ;
409 : break ;
410 : }
411 : case attributeSymbol :
412 : {
413 : Attribute *a = (Attribute*) symbol ;
414 94 : GenerateAttributeDecl(symTab, a, pseudo) ;
415 : break ;
416 : }
417 : case operationSymbol :
418 : {
419 : Operation *o = (Operation*) symbol ;
420 565 : GenerateOperationDecl(symTab, o, pseudo) ;
421 : break ;
422 : }
423 : case parameterSymbol :
424 : {
425 0 : NON_DEV("GenerateOneSymbolDecl") ;
426 : break ;
427 : }
428 : case typedefSymbol :
429 : {
430 : Typedef *t = (Typedef*) symbol ;
431 69 : GenerateTypedefDecl(symTab, t) ;
432 : break ;
433 : }
434 : case structSymbol :
435 : {
436 : Struct *s = (Struct*) symbol ;
437 42 : GenerateStructDecl(symTab, s, pseudo) ;
438 : break ;
439 : }
440 : case memberSymbol :
441 : {
442 : // Nothing ! GenerateStructDecl will take care of the member
443 : break ;
444 : }
445 : case unionSymbol :
446 : {
447 0 : NON_DEV("GenerateOneSymbolDecl") ;
448 : break ;
449 : }
450 : case constantSymbol :
451 : {
452 : Constant *c = (Constant*) symbol ;
453 13 : GenerateConstantDecl(symTab, c) ;
454 : break ;
455 : }
456 : case enumSymbol :
457 : {
458 : Enum *e = (Enum*) symbol ;
459 31 : GenerateEnumDecl(symTab, e, pseudo) ;
460 : break ;
461 : }
462 : case enumItemSymbol :
463 : {
464 : // Nothing ! GenerateEnumDecl will take care of the enum
465 : break ;
466 : }
467 : case exceptionSymbol :
468 : {
469 : Exception *e = (Exception*) symbol ;
470 76 : GenerateExceptionDecl(symTab, e) ;
471 : break ;
472 : }
473 : case nativeSymbol :
474 : {
475 : SymNative *native = (SymNative*) symbol ;
476 2 : GenerateNativeDecl(native) ;
477 : break ;
478 : }
479 : }
480 : }
481 :
482 : void LangCpp::GenerateOneSymbolImpl(
483 : SymbolContainer *symTab,
484 : Symbol *symbol,
485 1287 : bool pseudo)
486 : {
487 1287 : switch(symbol->GetClass())
488 : {
489 : case moduleSymbol:
490 : {
491 : Module *m = (Module*) symbol ;
492 27 : GenerateModuleImpl(symTab, m) ;
493 : break ;
494 : }
495 : case interfaceSymbol :
496 : {
497 : Interface *i = (Interface*) symbol ;
498 196 : GenerateInterfaceImpl(symTab, i) ;
499 : break ;
500 : }
501 : case attributeSymbol :
502 : {
503 94 : if ( ! pseudo)
504 : {
505 : Attribute *a = (Attribute*) symbol ;
506 89 : GenerateAttributeImpl(symTab, a) ;
507 : }
508 : break ;
509 : }
510 : case operationSymbol :
511 : {
512 565 : if ( ! pseudo)
513 : {
514 : Operation *o = (Operation*) symbol ;
515 492 : GenerateOperationImpl(symTab, o) ;
516 : }
517 : break ;
518 : }
519 : case parameterSymbol :
520 : {
521 0 : NON_DEV("GenerateParameterImpl") ;
522 : break ;
523 : }
524 : case typedefSymbol :
525 : {
526 : // Nothing !
527 : break ;
528 : }
529 : case structSymbol :
530 : {
531 : Struct *s = (Struct*) symbol ;
532 42 : GenerateStructImpl(symTab, s, pseudo) ;
533 : break ;
534 : }
535 : case memberSymbol :
536 : {
537 : // Nothing ! GenerateStructImpl will take care of the member
538 : break ;
539 : }
540 : case unionSymbol :
541 : {
542 0 : NON_DEV("GenerateUnionImpl") ;
543 : break ;
544 : }
545 : case constantSymbol :
546 : {
547 13 : NON_DEV("GenerateConstantImpl") ;
548 : break ;
549 :
550 : // Constant *c = (Constant*) symbol ;
551 : // GenerateConstantImpl(symTab, c) ;
552 : // break ;
553 : }
554 : case enumSymbol :
555 : {
556 : Enum *e = (Enum*) symbol ;
557 31 : GenerateEnumImpl(symTab, e, pseudo) ;
558 : break ;
559 : }
560 : case enumItemSymbol :
561 : {
562 : // Nothing ! GenerateEnumDecl will take care of the enum
563 : break ;
564 : }
565 : case exceptionSymbol :
566 : {
567 : Exception *e = (Exception*) symbol ;
568 76 : GenerateExceptionImpl(symTab, e) ;
569 : break ;
570 : }
571 : case nativeSymbol :
572 : {
573 : // NOTHING !
574 : break ;
575 : }
576 : }
577 : }
578 :
579 : void LangCpp::GenerateModuleDecl(
580 : SymbolContainer *symTab,
581 27 : Module *module)
582 : {
583 27 : CppInfo *info = new CppInfo(module) ;
584 27 : SetCppInfo(module, info) ;
585 :
586 27 : const String& name = module->GetName() ;
587 :
588 : //=============================== H_STUB, Part 1 ============================
589 : // namespace Module_Stub
590 : // {
591 : // << CONTENT >>
592 :
593 27 : _StubH.Tab() << "namespace " << info->_cppStubName << endl ;
594 27 : _StubH.Tab() << "{" << endl ;
595 27 : _StubH.IncTab() ;
596 :
597 : //=============================== H_SKEL, Part 1 ============================
598 : // namespace POA_Module
599 : // {
600 : // << CONTENT >>
601 :
602 27 : _SkelH.Tab() << "namespace " << info->_cppSkelName << endl ;
603 27 : _SkelH.Tab() << "{" << endl ;
604 27 : _SkelH.IncTab() ;
605 :
606 : //=============================== H, Part 1 =================================
607 : // namespace Module
608 : // {
609 : // << CONTENT >>
610 :
611 27 : _H.Tab() << "namespace " << info->_cppName << endl ;
612 27 : _H.BeginBloc() ;
613 :
614 : //=============================== CONTENT ===================================
615 :
616 27 : Context *c = symTab->findLocalContext(name) ;
617 : ASSERT(c != NULL) ;
618 27 : GenerateContextForwardDecl(c, false) ;
619 27 : GenerateContextDecl(c, false) ;
620 :
621 : //=============================== H, Part 2 =================================
622 : // << CONTENT >>
623 : // }
624 :
625 27 : _H.EndBloc() ;
626 :
627 : //=============================== H_SKEL, Part 2 ============================
628 : // << CONTENT >>
629 : // }
630 :
631 27 : _SkelH.DecTab() ;
632 27 : _SkelH.Tab() << "}" << endl << endl ;
633 :
634 : //=============================== H_STUB, Part 2 ============================
635 : // << CONTENT >>
636 : // }
637 :
638 27 : _StubH.DecTab() ;
639 27 : _StubH.Tab() << "}" << endl << endl ;
640 : }
641 :
642 : void LangCpp::GenerateModuleImpl(
643 : SymbolContainer *symTab,
644 27 : Module *module)
645 : {
646 27 : const String& name = module->GetName() ;
647 :
648 27 : Context *c = symTab->findLocalContext(name) ;
649 : ASSERT(c != NULL) ;
650 27 : GenerateContextImpl(c, false) ;
651 : }
652 :
653 : void LangCpp::GenerateInterfaceForwardDecl(
654 : SymbolContainer *symTab,
655 : Interface *interface,
656 196 : bool pseudo)
657 : {
658 196 : CppInfo *info = new CppInfo(interface) ;
659 196 : SetCppInfo(interface, info) ;
660 :
661 196 : String name_var = info->_cppName ;
662 196 : name_var += "_var" ;
663 196 : String name_ptr = info->_cppName ;
664 196 : name_ptr += "_ptr" ;
665 :
666 : //=============================== H ========================================
667 : // class Foo ;
668 : // typedef Foo* Foo_ptr ;
669 : // typedef CORBAObjectVar<Foo> Foo_var ;
670 : //
671 :
672 196 : _H.Tab() << "class " << info->_cppName << " ;" << endl ;
673 : _H.Tab() << "typedef " << info->_cppName << "* "
674 196 : << name_ptr << " ;" << endl ;
675 :
676 196 : if ( ! info->_isPseudo)
677 : {
678 : _H.Tab() << "typedef CORBAObjectVar<" << info->_cppName << "> "
679 186 : << name_var << " ;" << endl << endl ;
680 : }
681 : else
682 : {
683 : _H.Tab() << "typedef CORBAPseudoVar<" << info->_cppName << "> "
684 10 : << name_var << " ;" << endl << endl ;
685 0 : }
686 :
687 : }
688 :
689 : void LangCpp::GenerateInterfaceDecl(
690 : SymbolContainer *symTab,
691 196 : Interface *interface)
692 : {
693 196 : CppInfo *info = GetCppInfo(interface) ;
694 :
695 196 : const String& name = interface->GetName() ;
696 196 : String name_var = info->_cppName ;
697 196 : name_var += "_var" ;
698 196 : String name_ptr = info->_cppName ;
699 196 : name_ptr += "_ptr" ;
700 :
701 196 : if (interface->IsDefined() == false)
702 : {
703 0 : return ;
704 : }
705 :
706 196 : const InterfaceList& inherit = interface->GetInheritance() ;
707 : Interface *super = NULL ;
708 : CppInfo *sInfo = NULL ;
709 :
710 : //=============================== STUB H, part 1 ===========================
711 : // class Foo_Stub :
712 : // public Module::Bar,
713 : // public YAORB::Stub
714 : // {
715 : // public :
716 : // <<CONTENT>>
717 :
718 196 : if ( ! info->_isPseudo)
719 : {
720 186 : _StubH.Tab() << "class " << info->_cppStubName << endl ;
721 186 : _StubH.IncTab() ;
722 :
723 186 : _StubH.Tab() << ": public " << info->_cppFullName ;
724 :
725 186 : if (inherit.size() == 0)
726 : {
727 71 : _StubH.Str() << "," << endl ;
728 71 : _StubH.Tab() << "public virtual YAORB::Stub" << endl ;
729 : }
730 : else
731 : {
732 : InterfaceListIt it(inherit) ;
733 252 : while (it.GetNext())
734 : {
735 : super = it.GetItem() ;
736 137 : sInfo = GetCppInfo(super) ;
737 :
738 137 : _StubH.Str() << "," << endl ;
739 137 : _StubH.Tab() << sInfo->_cppStubFullName ;
740 : }
741 115 : _StubH.Str() << endl ;
742 : }
743 :
744 186 : _StubH.DecTab() ;
745 :
746 186 : _StubH.Tab() << "{" << endl ;
747 186 : _StubH.IncTab() ;
748 186 : _StubH.Tab() << "public :" << endl ;
749 186 : _StubH.IncTab() ;
750 : }
751 :
752 : //=============================== SQUEL H, part 1 ==========================
753 : // class POA_Foo :
754 : // public Module::Bar,
755 : // public virtual PortableServer::ServantBase
756 : // {
757 : // public :
758 :
759 186 : if ( ! info->_isPseudo)
760 : {
761 : // FIXME
762 186 : _SkelH.Tab() << "class " << info->_cppSkelName << " :" << endl ;
763 186 : _SkelH.IncTab() ;
764 186 : _SkelH.Tab() << "public " << info->_cppFullName << "," << endl ;
765 186 : _SkelH.Tab() << "public PortableServer::ServantBase" << endl ;
766 186 : _SkelH.DecTab() ;
767 :
768 186 : _SkelH.Tab() << "{" << endl ;
769 186 : _SkelH.IncTab() ;
770 186 : _SkelH.Tab() << "public :" << endl ;
771 186 : _SkelH.IncTab() ;
772 : }
773 :
774 :
775 : //=============================== H, part 1 ================================
776 : // class Foo : public <inheritance of Foo>
777 : // {
778 : // public :
779 : // virtual ~Foo() ;
780 : // typedef Foo_ptr _ptr_type ;
781 : // typedef Foo_var _var_type ;
782 : //
783 : // static Foo_ptr _duplicate(Foo_ptr obj) ;
784 : // static Foo_ptr _narrow(CORBA::Object_ptr obj) ;
785 : // static Foo_ptr _nil(void) ;
786 : // static Foo_ptr _bind(YAORB::CDR*) ;
787 : // virtual const YAORB::ClassInfo* _getInfo(void) const ;
788 : // virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
789 : //
790 :
791 196 : _H.Tab() << "class " << info->_cppName ;
792 :
793 196 : if (inherit.size() == 0)
794 : {
795 78 : if ( ! info->_isPseudo)
796 : {
797 71 : _H.Str() << " : public virtual CORBA::Object" << endl ;
798 : }
799 : else
800 : {
801 7 : _H.Str() << endl ;
802 : }
803 : }
804 : else
805 : {
806 118 : _H.Str() << " : public " ;
807 :
808 : InterfaceListIt it(inherit) ;
809 : bool comma = false ;
810 258 : while (it.GetNext())
811 : {
812 : super = it.GetItem() ;
813 140 : sInfo = GetCppInfo(super) ;
814 :
815 140 : if (comma)
816 : {
817 22 : _H.Str() << ", " ;
818 : }
819 :
820 140 : _H.Str() << sInfo->_cppFullName ;
821 : comma = true ;
822 : }
823 118 : _H.Str() << endl ;
824 : }
825 :
826 196 : _H.Tab() << "{" << endl ;
827 :
828 196 : if ( info->_isPseudo)
829 : {
830 10 : _H.IncTab() ;
831 : _H.Tab() << "// GENERATED PART OF PSEUDO CLASS " << info->_cppFullName
832 10 : << endl ;
833 10 : _H.DecTab() ;
834 : }
835 :
836 196 : _H.IncTab() ;
837 196 : _H.Tab() << "public :" << endl ;
838 196 : _H.IncTab() ;
839 :
840 196 : if ( ! info->_isPseudo)
841 : {
842 186 : _H.Tab() << "virtual ~" << info->_cppName << "() ;" << endl ;
843 : }
844 :
845 196 : _H.Tab() << "typedef " << name_ptr << " _ptr_type ;" << endl ;
846 196 : _H.Tab() << "typedef " << name_var << " _var_type ;" << endl ;
847 196 : _H.Str() << endl ;
848 : _H.Tab() << "static " << name_ptr
849 196 : << " _duplicate(" << name_ptr << " obj) ;" << endl ;
850 :
851 196 : if ( ! info->_isPseudo)
852 : {
853 : _H.Tab() << "static " << name_ptr
854 186 : << " _narrow(CORBA::Object_ptr obj) ;" << endl ;
855 : }
856 :
857 : _H.Tab() << "static " << name_ptr
858 196 : << " _nil(void) ;" << endl ;
859 :
860 196 : if ( ! info->_isPseudo)
861 : {
862 : _H.Tab() << "static " << name_ptr
863 186 : << " _bind(YAORB::CDR*) ;" << endl ;
864 :
865 : _H.Tab() << "virtual const YAORB::ClassInfo* _getInfo(void) const ;"
866 186 : << endl ;
867 : _H.Tab() << "virtual bool _isA"
868 186 : << "(const YAORB::ClassInfo*, void*& that) const ;" << endl ;
869 : }
870 196 : _H.Str() << endl ;
871 :
872 :
873 : //=============================== CONTENT ==================================
874 :
875 196 : Context *c = symTab->findLocalContext(name) ;
876 : ASSERT(c != NULL) ;
877 196 : GenerateContextForwardDecl(c, info->_isPseudo) ;
878 196 : GenerateContextDecl(c, info->_isPseudo) ;
879 196 : _H.Str() << endl ;
880 :
881 : //=============================== H, part 2 ================================
882 : //
883 : // protected :
884 : // static const YAORB::ClassInfo _info ;
885 : //
886 : // Foo() ;
887 : //
888 : // private :
889 : // Foo(const Foo&) ;
890 : // Foo& operator = (const Foo&) ;
891 : // } ;
892 :
893 196 : _H.DecTab() ;
894 :
895 196 : if ( ! info->_isPseudo)
896 : {
897 186 : _H.Tab() << "protected :" << endl ;
898 :
899 186 : _H.IncTab() ;
900 :
901 186 : _H.Tab() << "static const YAORB::ClassInfo _info ;" << endl << endl ;
902 :
903 186 : _H.Tab() << info->_cppName << "() ;" << endl << endl ;
904 186 : _H.DecTab() ;
905 : }
906 :
907 196 : _H.Tab() << "private :" << endl ;
908 196 : _H.IncTab() ;
909 :
910 : _H.Tab() << info->_cppName << "(const " << info->_cppName << "&) ;"
911 196 : << endl ;
912 : _H.Tab() << info->_cppName << "& operator = (const "
913 196 : << info->_cppName << "&) ;" << endl ;
914 196 : _H.DecTab() ;
915 :
916 196 : _H.DecTab() ;
917 :
918 196 : if ( info->_isPseudo)
919 : {
920 10 : _H.IncTab() ;
921 10 : _H.Str() << endl ;
922 : _H.Tab() << "// MANUAL PART OF PSEUDO CLASS " << info->_cppFullName
923 10 : << endl ;
924 10 : _H.Str() << endl ;
925 10 : _H.DecTab() ;
926 : }
927 :
928 196 : _H.Tab() << "} ;" << endl << endl ;
929 :
930 : //=============================== SKEL H, part 2 ===========================
931 : // protected :
932 : // POA_Foo() ;
933 : //
934 : // private :
935 : // static const YAORB::SkelInfo::LocalOp _localOps[] ;
936 : // static const YAORB::SkelInfo _skelInfo ;
937 : // static const YAORB::SkelInfo * _parentSkelInfo[] ;
938 : //
939 : // POA_Foo(const POA_Foo&) ;
940 : // POA_Foo& operator=(const POA_Foo&) ;
941 : // } ;
942 :
943 196 : if ( ! info->_isPseudo)
944 : {
945 186 : _SkelH.DecTab() ;
946 186 : _SkelH.Tab() << "protected :" << endl ;
947 186 : _SkelH.IncTab() ;
948 :
949 186 : _SkelH.Tab() << info->_cppSkelName << "() ;" << endl ;
950 186 : _SkelH.Tab() << "~" << info->_cppSkelName << "() ;" << endl ;
951 :
952 186 : _SkelH.DecTab() ;
953 186 : _SkelH.Tab() << "private :" << endl ;
954 186 : _SkelH.IncTab() ;
955 :
956 : _SkelH.Tab() << "static const YAORB::SkelInfo::LocalOp _localOps[] ;"
957 186 : << endl ;
958 186 : _SkelH.Tab() << "static const YAORB::SkelInfo _skelInfo ;" << endl ;
959 : _SkelH.Tab() << "static const YAORB::SkelInfo * _parentSkelInfo[] ;"
960 186 : << endl ;
961 :
962 : _SkelH.Tab() << info->_cppSkelName
963 186 : << "(const " << info->_cppSkelName << "&) ;" << endl ;
964 : _SkelH.Tab() << info->_cppSkelName
965 186 : << "& operator = (const " << info->_cppSkelName << "&) ;" << endl ;
966 186 : _SkelH.DecTab() ;
967 :
968 186 : _SkelH.DecTab() ;
969 186 : _SkelH.Tab() << "} ;" << endl << endl ;
970 : }
971 :
972 : //=============================== STUB H, part 2 ===========================
973 : // public :
974 : // virtual YAORB::StubInfo* getStubInfo(void) const ;
975 : // static YAORB::StubInfo _stubInfo ;
976 : // static CORBA::Object*
977 : // create(const YAORB::Ref&) ;
978 : //
979 : // Foo_Stub(const YAORB::Ref&) ;
980 : //
981 : // private :
982 : // Foo_Stub() ;
983 : // Foo_Stub(const Foo_Stub&) ;
984 : // Foo_Stub& operator=(const Foo_Stub&) ;
985 : // } ;
986 :
987 186 : if ( ! info->_isPseudo)
988 : {
989 186 : _StubH.DecTab() ;
990 186 : _StubH.Tab() << "public :" << endl ;
991 186 : _StubH.IncTab() ;
992 : _StubH.Tab() << "virtual YAORB::StubInfo* getStubInfo(void) const ;"
993 186 : << endl ;
994 186 : _StubH.Tab() << "static YAORB::StubInfo _stubInfo ;" << endl ;
995 :
996 186 : _StubH.Tab() << "static CORBA::Object*" << endl ;
997 186 : _StubH.IncTab() ;
998 : _StubH.Tab() << "create(const YAORB::Ref&) ;"
999 186 : << endl << endl ;
1000 186 : _StubH.DecTab() ;
1001 :
1002 : _StubH.Tab() << info->_cppStubName << "(const YAORB::Ref&) ;"
1003 186 : << endl << endl ;
1004 :
1005 186 : _StubH.DecTab() ;
1006 186 : _StubH.Tab() << "private :" << endl ;
1007 186 : _StubH.IncTab() ;
1008 186 : _StubH.Tab() << info->_cppStubName << "() ;" << endl ;
1009 : _StubH.Tab() << info->_cppStubName
1010 186 : << "(const " << info->_cppStubName << "&) ;" << endl ;
1011 : _StubH.Tab() << info->_cppStubName
1012 186 : << "& operator = (const " << info->_cppStubName << "&) ;" << endl ;
1013 186 : _StubH.DecTab() ;
1014 :
1015 186 : _StubH.DecTab() ;
1016 186 : _StubH.Tab() << "} ;" << endl << endl ;
1017 196 : }
1018 :
1019 : }
1020 :
1021 : void LangCpp::GenerateInterfaceImpl(
1022 : SymbolContainer *symTab,
1023 196 : Interface *interface)
1024 : {
1025 196 : CppInfo *info = GetCppInfo(interface) ;
1026 :
1027 196 : const String& name = interface->GetName() ;
1028 196 : String name_var = info->_cppFullName ;
1029 196 : name_var += "_var" ;
1030 196 : String name_ptr = info->_cppFullName ;
1031 196 : name_ptr += "_ptr" ;
1032 :
1033 196 : if (interface->IsDefined() == false)
1034 : {
1035 0 : return ;
1036 : }
1037 :
1038 196 : const InterfaceList& inherit = interface->GetInheritance() ;
1039 : Interface *super = NULL ;
1040 : CppInfo *sinfo = NULL ;
1041 :
1042 : //=============================== CPP ======================================
1043 : // Foo::Bar::Bar()
1044 : // {}
1045 : //
1046 : // Foo::Bar::~Bar()
1047 : // {}
1048 : //
1049 : // Foo::Bar_ptr Foo::Bar::_duplicate(Foo::Bar_ptr obj)
1050 : // {
1051 : // if (CORBA::is_nil(obj))
1052 : // {
1053 : // return _nil() ;
1054 : // }
1055 : // else
1056 : // {
1057 : // (void) CORBA::Object::_duplicate(obj) ;
1058 : // return obj ;
1059 : // }
1060 : // }
1061 : //
1062 : // Foo::Bar_ptr Foo::Bar::_narrow(CORBA::Object_ptr obj)
1063 : // {
1064 : // if (CORBA::is_nil(obj))
1065 : // {
1066 : // return _nil() ;
1067 : // }
1068 : // else
1069 : // {
1070 : // void * that = NULL ;
1071 : // if (obj->_isA(_info, that))
1072 : // {
1073 : // Foo::Bar_ptr ret ;
1074 : // ret = (Foo::Bar_ptr) that ;
1075 : // CORBA::Object::_duplicate(obj) ;
1076 : // return ret ;
1077 : // }
1078 : // else
1079 : // {
1080 : // return _nil() ;
1081 : // }
1082 : // }
1083 : // }
1084 : //
1085 : // Foo::Bar_ptr Foo::Bar::_nil(void)
1086 : // {
1087 : // return NULL ;
1088 : // }
1089 : //
1090 : // Foo::Bar_ptr Foo::Bar::_bind(YAORB::CDR* cdrs)
1091 : // {
1092 : // return _narrow(CORBA::Object::_bind(cdrs)) ;
1093 : // }
1094 : //
1095 : // const YAORB::ClassInfo* Foo::Bar::_getInfo(void) const
1096 : // {
1097 : // return & _info ;
1098 : // }
1099 : //
1100 : // bool Foo::Bar::_isA(const YAORB::ClassInfo* info, void*& that) const
1101 : // {
1102 : // if (_info->isEquiv(info))
1103 : // { // TO DO : Document this black magic ! (virtual inheritance)
1104 : // that = (void*) (const void*) this ;
1105 : // return true ;
1106 : // }
1107 : // // call ::_isA on parent classes
1108 : // if (Mod::Base::_isA(info, that))
1109 : // {
1110 : // return true ;
1111 : // }
1112 : // return false ;
1113 : // }
1114 : //
1115 : // const YAORB::ClassInfo Foo::Bar::_info("<<repository id>>") ;
1116 : //
1117 : // <<CONTENT>>
1118 :
1119 196 : if (! info->_isPseudo)
1120 : {
1121 : _Cpp.Tab() << info->_cppFullName
1122 186 : << "::" << info->_cppName << "()" << endl ;
1123 :
1124 186 : if (inherit.size() == 0)
1125 : {
1126 71 : _Cpp.Tab() << " : CORBA::Object()" << endl ;
1127 : }
1128 : else
1129 : {
1130 115 : NON_DEV("Base constructors") ;
1131 : }
1132 :
1133 186 : _Cpp.Tab() << "{}" << endl << endl ;
1134 :
1135 : _Cpp.Tab() << info->_cppFullName
1136 186 : << "::~" << info->_cppName << "()" << endl ;
1137 186 : _Cpp.Tab() << "{}" << endl << endl ;
1138 :
1139 186 : _Cpp.Tab() << name_ptr << endl ;
1140 : _Cpp.Tab() << info->_cppFullName
1141 186 : << "::_duplicate(" << name_ptr << " obj)" << endl ;
1142 186 : _Cpp.Tab() << "{" << endl ;
1143 186 : _Cpp.IncTab() ;
1144 186 : _Cpp.Tab() << "if (CORBA::is_nil(obj))" << endl ;
1145 186 : _Cpp.Tab() << "{" << endl ;
1146 186 : _Cpp.IncTab() ;
1147 186 : _Cpp.Tab() << "return _nil() ;" << endl ;
1148 186 : _Cpp.DecTab() ;
1149 186 : _Cpp.Tab() << "}" << endl ;
1150 186 : _Cpp.Tab() << "else" << endl ;
1151 186 : _Cpp.Tab() << "{" << endl ;
1152 186 : _Cpp.IncTab() ;
1153 : _Cpp.Tab() << "(void) CORBA::Object::_duplicate(obj) ;"
1154 186 : << endl ;
1155 186 : _Cpp.Tab() << "return obj ;" << endl ;
1156 186 : _Cpp.DecTab() ;
1157 186 : _Cpp.Tab() << "}" << endl ;
1158 186 : _Cpp.DecTab() ;
1159 186 : _Cpp.Tab() << "}" << endl << endl ;
1160 :
1161 186 : _Cpp.Tab() << name_ptr << endl ;
1162 : _Cpp.Tab() << info->_cppFullName
1163 186 : << "::_narrow(CORBA::Object_ptr obj)" << endl ;
1164 186 : _Cpp.Tab() << "{" << endl ;
1165 186 : _Cpp.IncTab() ;
1166 186 : _Cpp.Tab() << "if (CORBA::is_nil(obj))" << endl ;
1167 186 : _Cpp.Tab() << "{" << endl ;
1168 186 : _Cpp.IncTab() ;
1169 186 : _Cpp.Tab() << "return _nil() ;" << endl ;
1170 186 : _Cpp.DecTab() ;
1171 186 : _Cpp.Tab() << "}" << endl ;
1172 186 : _Cpp.Tab() << "else" << endl ;
1173 186 : _Cpp.Tab() << "{" << endl ;
1174 186 : _Cpp.IncTab() ;
1175 186 : _Cpp.Tab() << "void *that = NULL ;" << endl ;
1176 186 : _Cpp.Tab() << "if (obj->_isA(& _info, that))" << endl ;
1177 186 : _Cpp.Tab() << "{" << endl ;
1178 186 : _Cpp.IncTab() ;
1179 186 : _Cpp.Tab() << name_ptr << " ret ;" << endl ;
1180 186 : _Cpp.Tab() << "ret = (" << name_ptr << ") that ;" << endl ;
1181 186 : _Cpp.Tab() << "CORBA::Object::_duplicate(obj) ;" << endl ;
1182 186 : _Cpp.Tab() << "return ret ;" << endl ;
1183 186 : _Cpp.DecTab() ;
1184 186 : _Cpp.Tab() << "}" << endl ;
1185 186 : _Cpp.Tab() << "else" << endl ;
1186 186 : _Cpp.Tab() << "{" << endl ;
1187 186 : _Cpp.IncTab() ;
1188 186 : _Cpp.Tab() << "return _nil() ;" << endl ;
1189 186 : _Cpp.DecTab() ;
1190 186 : _Cpp.Tab() << "}" << endl ;
1191 186 : _Cpp.DecTab() ;
1192 186 : _Cpp.Tab() << "}" << endl ;
1193 186 : _Cpp.DecTab() ;
1194 186 : _Cpp.Tab() << "}" << endl << endl ;
1195 : }
1196 :
1197 : _Cpp.Tab() << name_ptr << " " << info->_cppFullName
1198 196 : << "::_nil(void)" << endl ;
1199 196 : _Cpp.Tab() << "{" << endl ;
1200 196 : _Cpp.IncTab() ;
1201 196 : _Cpp.Tab() << "return NULL ;" << endl ;
1202 196 : _Cpp.DecTab() ;
1203 196 : _Cpp.Tab() << "}" << endl << endl ;
1204 :
1205 196 : if ( ! info->_isPseudo)
1206 : {
1207 : _Cpp.Tab() << name_ptr << " " << info->_cppFullName
1208 186 : << "::_bind(YAORB::CDR* cdrs)" << endl ;
1209 186 : _Cpp.Tab() << "{" << endl ;
1210 186 : _Cpp.IncTab() ;
1211 : _Cpp.Tab() << "return _narrow(CORBA::Object::_bind(cdrs)) ;"
1212 186 : << endl ;
1213 186 : _Cpp.DecTab() ;
1214 186 : _Cpp.Tab() << "}" << endl << endl ;
1215 :
1216 : _Cpp.Tab() << "const YAORB::ClassInfo* "
1217 186 : << info->_cppFullName << "::_getInfo(void) const" << endl ;
1218 186 : _Cpp.Tab() << "{" << endl ;
1219 186 : _Cpp.IncTab() ;
1220 186 : _Cpp.Tab() << "return & _info ;" << endl ;
1221 186 : _Cpp.DecTab() ;
1222 186 : _Cpp.Tab() << "}" << endl << endl ;
1223 :
1224 : _Cpp.Tab() << "bool " << info->_cppFullName
1225 186 : << "::_isA(const YAORB::ClassInfo* info, void*& that) const" << endl ;
1226 186 : _Cpp.Tab() << "{" << endl ;
1227 186 : _Cpp.IncTab() ;
1228 186 : _Cpp.Tab() << "if (_info.isEquiv(info))" << endl ;
1229 186 : _Cpp.Tab() << "{" << endl ;
1230 186 : _Cpp.IncTab() ;
1231 186 : _Cpp.Tab() << "that = (void*) (const void*) this ;" << endl ;
1232 186 : _Cpp.Tab() << "return true ;" << endl ;
1233 186 : _Cpp.DecTab() ;
1234 186 : _Cpp.Tab() << "}" << endl ;
1235 :
1236 : InterfaceListIt it(inherit) ;
1237 323 : while (it.GetNext())
1238 : {
1239 : super = it.GetItem() ;
1240 137 : sinfo = GetCppInfo(super) ;
1241 :
1242 : _Cpp.Tab() << "if (" << sinfo->_cppFullName
1243 137 : << "::_isA(info, that))" << endl ;
1244 137 : _Cpp.Tab() << "{" << endl ;
1245 137 : _Cpp.IncTab() ;
1246 137 : _Cpp.Tab() << "return true ;" << endl ;
1247 137 : _Cpp.DecTab() ;
1248 137 : _Cpp.Tab() << "}" << endl ;
1249 : }
1250 :
1251 186 : _Cpp.Tab() << "return false ;" << endl ;
1252 186 : _Cpp.DecTab() ;
1253 186 : _Cpp.Tab() << "}" << endl << endl ;
1254 :
1255 186 : const String& ir = interface->GetInterfaceRepositoryID() ;
1256 : _Cpp.Tab() << "const YAORB::ClassInfo "
1257 186 : << info->_cppFullName << "::_info(\"" << ir << "\") ;" << endl ;
1258 : }
1259 196 : _Cpp.Str() << endl ;
1260 :
1261 : //=============================== Content ==================================
1262 :
1263 196 : Context *c = symTab->findLocalContext(name) ;
1264 : ASSERT(c != NULL) ;
1265 :
1266 196 : if ( ! info->_isPseudo)
1267 : {
1268 186 : GenerateInterfaceTablesImpl(c, interface) ;
1269 : }
1270 :
1271 196 : GenerateContextImpl(c, info->_isPseudo) ;
1272 :
1273 : //=============================== STUB CPP =================================
1274 : // YAORB::StubInfo* Bar_Stub::Foo_Stub::getStubInfo(void) const
1275 : // {
1276 : // return & _stubInfo ;
1277 : // }
1278 : //
1279 : // YAORB::StubInfo
1280 : // Bar_Stub::Foo_Stub::_stubInfo(
1281 : // Bar_Stub::Foo_Stub::create,
1282 : // & Bar::Foo::_info) ;
1283 : //
1284 : // CORBA::Object*
1285 : // Bar_Stub::Foo_Stub::create(const YAORB::Ref& ref)
1286 : // {
1287 : // return new Stub_Bar(ref) ;
1288 : // }
1289 : //
1290 : // Bar_Stub::Foo_Stub::Foo_Stub(const YAORB::Ref& ref)
1291 : // : YAORB::Stub(ref)
1292 : // {}
1293 :
1294 196 : _StubCpp.Tab() << "YAORB::StubInfo*" << endl ;
1295 : _StubCpp.Tab() << info->_cppStubFullName
1296 196 : << "::getStubInfo(void) const" << endl ;
1297 196 : _StubCpp.Tab() << "{" << endl ;
1298 196 : _StubCpp.IncTab() ;
1299 196 : _StubCpp.Tab() << "return & _stubInfo ;" << endl ;
1300 196 : _StubCpp.DecTab() ;
1301 196 : _StubCpp.Tab() << "}" << endl << endl ;
1302 :
1303 196 : _StubCpp.Tab() << "YAORB::StubInfo" << endl ;
1304 : _StubCpp.Tab() << info->_cppStubFullName
1305 196 : << "::_stubInfo(" << endl ;
1306 196 : _StubCpp.IncTab() ;
1307 196 : _StubCpp.Tab() << info->_cppStubFullName << "::create," << endl ;
1308 : _StubCpp.Tab() << "& " << info->_cppFullName << "::_info) ;"
1309 196 : << endl << endl ;
1310 196 : _StubCpp.DecTab() ;
1311 :
1312 196 : _StubCpp.Tab() << "CORBA::Object*" << endl ;
1313 : _StubCpp.Tab() << info->_cppStubFullName
1314 196 : << "::create(const YAORB::Ref& ref)" << endl ;
1315 196 : _StubCpp.Tab() << "{" << endl ;
1316 196 : _StubCpp.IncTab() ;
1317 : _StubCpp.Tab() << "return new " << info->_cppStubName
1318 196 : << "(ref) ;" << endl ;
1319 196 : _StubCpp.DecTab() ;
1320 196 : _StubCpp.Tab() << "}" << endl << endl ;
1321 :
1322 : _StubCpp.Tab() << info->_cppStubFullName
1323 196 : << "::" << info->_cppStubName << "(const YAORB::Ref& ref)" << endl ;
1324 196 : _StubCpp.Tab() << " : YAORB::Stub(ref)" << endl ;
1325 196 : _StubCpp.Tab() << "{}" << endl << endl ;
1326 :
1327 : //=============================== SKEL CPP =================================
1328 : // POA_Bar::POA_Foo::POA_Foo()
1329 : // : Foo::Bar, PortableServer::ServantBase()
1330 : // {}
1331 : //
1332 : // POA_Bar::POA_Foo::~POA_Foo()
1333 : // {}
1334 : //
1335 :
1336 196 : if ( ! info->_isPseudo)
1337 : {
1338 : _SkelCpp.Tab() << info->_cppSkelFullName
1339 186 : << "::" << info->_cppSkelName << "()" << endl ;
1340 186 : _SkelCpp.Tab() << ": " << info->_cppFullName << "()," << endl ;
1341 186 : _SkelCpp.Tab() << "PortableServer::ServantBase()" << endl ;
1342 186 : _SkelCpp.Tab() << "{}" << endl << endl ;
1343 :
1344 : _SkelCpp.Tab() << info->_cppSkelFullName
1345 186 : << "::~" << info->_cppSkelName << "()" << endl ;
1346 186 : _SkelCpp.Tab() << "{}" << endl << endl ;
1347 196 : }
1348 : }
1349 :
1350 : void LangCpp::GenerateInterfaceTablesImpl(
1351 : SymbolContainer *symTab,
1352 186 : Interface *interface)
1353 : {
1354 186 : CppInfo *info = GetCppInfo(interface) ;
1355 :
1356 : //=============================== SKEL CPP =================================
1357 : //
1358 : // In this example, Bar::Foo inherit from The::Thing.
1359 : //
1360 : // const YAORB::SkelInfo::LocalOp
1361 : // POA_Bar::POA_Foo::_localOps[] =
1362 : // {
1363 : // { "Operation1", & POA_Bar::POA_Foo::_op_Operation1},
1364 : // { "Operation2", & POA_Bar::POA_Foo::_op_Operation2},
1365 : // { NULL, NULL}
1366 : // } ;
1367 : //
1368 : // const YAORB::SkelInfo*
1369 : // POA_Bar::POA_Foo::_parentSkelInfo[] =
1370 : // {
1371 : // & POA_The::POA_Thing::_stubInfo,
1372 : // NULL
1373 : // } ;
1374 : //
1375 : // const YAORB::SkelInfo
1376 : // POA_Bar::POA_Foo::_stubInfo() ;
1377 : // & Bar::Foo::_info,
1378 : // POA_Bar::POA_Foo::_localOps,
1379 : // POA_Bar::POA_Foo::_parentSkelInfo) ;
1380 :
1381 186 : _SkelCpp.Tab() << "const YAORB::SkelInfo::LocalOp" << endl ;
1382 : _SkelCpp.Tab() << info->_cppSkelFullName
1383 186 : << "::_localOps[] = " << endl ;
1384 186 : _SkelCpp.Tab() << "{" << endl ;
1385 186 : _SkelCpp.IncTab() ;
1386 :
1387 186 : GenerateLocalOpsImpl(symTab, interface) ;
1388 :
1389 186 : _SkelCpp.DecTab() ;
1390 186 : _SkelCpp.Tab() << "} ;" << endl << endl ;
1391 :
1392 186 : _SkelCpp.Tab() << "const YAORB::SkelInfo *" << endl ;
1393 : _SkelCpp.Tab() << info->_cppSkelFullName
1394 186 : << "::_parentSkelInfo[] = " << endl ;
1395 186 : _SkelCpp.Tab() << "{" << endl ;
1396 186 : _SkelCpp.IncTab() ;
1397 :
1398 186 : NON_DEV("Inheritance for static operation tables") ;
1399 :
1400 186 : _SkelCpp.Tab() << "NULL" << endl ;
1401 186 : _SkelCpp.DecTab() ;
1402 186 : _SkelCpp.Tab() << "} ;" << endl << endl ;
1403 :
1404 :
1405 186 : _SkelCpp.Tab() << "const YAORB::SkelInfo" << endl ;
1406 : _SkelCpp.Tab() << info->_cppSkelFullName
1407 186 : << "::_skelInfo(" << endl ;
1408 186 : _SkelCpp.IncTab() ;
1409 :
1410 186 : _SkelCpp.Tab() << "& " << info->_cppFullName << "::_info," << endl ;
1411 :
1412 : _SkelCpp.Tab() << "& " << info->_cppSkelFullName
1413 186 : << "::_localOps[0]," << endl ;
1414 :
1415 : _SkelCpp.Tab() << "& " << info->_cppSkelFullName
1416 186 : << "::_parentSkelInfo[0]) ;" << endl << endl ;
1417 :
1418 186 : _SkelCpp.DecTab() ;
1419 : }
1420 :
1421 : void LangCpp::GenerateLocalOpsImpl(
1422 : SymbolContainer *symTab,
1423 186 : Interface *interface)
1424 : {
1425 186 : const SymbolList& symbols = symTab->GetLocalSymbols() ;
1426 : Symbol *symbol = NULL ;
1427 : SymbolListIt it(symbols) ;
1428 :
1429 994 : while (it.GetNext())
1430 : {
1431 : symbol = it.GetItem() ;
1432 :
1433 622 : switch(symbol->GetClass())
1434 : {
1435 : case attributeSymbol :
1436 : {
1437 89 : Attribute *a = (Attribute*) symbol ;
1438 89 : AttributeAttribute attrib = a->GetAttribute() ;
1439 89 : CppInfo *info = GetCppInfo(a) ;
1440 89 : const String& name = a->GetName() ;
1441 89 : String atName = Prefix(info->_cppSkelFullName) ;
1442 :
1443 : //-----------------------------------------------------------------
1444 : // REFERENCE : OMG 99-07-19.pdf, section 15.4.2.1, page 15.34
1445 : //-----------------------------------------------------------------
1446 :
1447 : _SkelCpp.Tab()
1448 : << "{ \"_get_" << name << "\", "
1449 89 : << atName << "::_get_" << info->_cppName << "}," << endl ;
1450 :
1451 89 : if (attrib == ATTRIBUTE_READWRITE)
1452 : {
1453 : _SkelCpp.Tab()
1454 : << "{ \"_set_" << name << "\", "
1455 45 : << atName << "::_set_" << info->_cppName << "}," << endl ;
1456 : }
1457 0 : break ;
1458 : }
1459 : case operationSymbol :
1460 : {
1461 : Operation *o = (Operation*) symbol ;
1462 492 : CppInfo *info = GetCppInfo(o) ;
1463 492 : const String& name = o->GetName() ;
1464 492 : String opName = Prefix(info->_cppSkelFullName) ;
1465 492 : opName += "::_op_" ;
1466 492 : opName += info->_cppName ;
1467 :
1468 : _SkelCpp.Tab() << "{ \"" << name << "\", & "
1469 492 : << opName << "}," << endl ;
1470 492 : break ;
1471 : }
1472 : default :
1473 : {
1474 : break ;
1475 : }
1476 : }
1477 : }
1478 :
1479 186 : _SkelCpp.Tab() << "{ NULL, NULL }" << endl ;
1480 : }
1481 :
1482 : void LangCpp::GenerateAttributeDecl(
1483 : SymbolContainer *symTab,
1484 : Attribute *attribute,
1485 94 : bool pseudo)
1486 : {
1487 94 : CppInfo *info = new CppInfo(attribute) ;
1488 94 : SetCppInfo(attribute, info) ;
1489 :
1490 94 : IDLType *type = attribute->GetType() ;
1491 94 : AttributeAttribute attrib = attribute->GetAttribute() ;
1492 :
1493 : bool dummy1, dummy2, dummy3 ;
1494 :
1495 : //=============================== H ========================================
1496 : // Read Write attribute :
1497 : // ----------------------
1498 : // virtual void Attr(<in_type>) = 0 ;
1499 : // virtual <return_type> Attr(void) = 0 ;
1500 : //
1501 : // Read only attribute :
1502 : // ---------------------
1503 : // virtual <return_type> Attr(void) = 0 ;
1504 :
1505 : // Get
1506 : // ===
1507 :
1508 94 : if (! pseudo)
1509 : {
1510 89 : _H.Tab() << "virtual " ;
1511 : }
1512 : else
1513 : {
1514 5 : (void) _H.Tab() ;
1515 : }
1516 :
1517 : PrintType(_H.Str(),
1518 : type,
1519 : PRINT_RETURN,
1520 : info->_isConst,
1521 : info->_isPointer,
1522 94 : info->_isVar) ;
1523 :
1524 94 : _H.Str() << " " << info->_cppName << "(void)" ;
1525 :
1526 94 : if (! pseudo)
1527 : {
1528 89 : _H.Str() << " = 0 ;" << endl ;
1529 : }
1530 : else
1531 : {
1532 5 : _H.Str() << " ;" << endl ;
1533 : }
1534 :
1535 : // Set
1536 : // ===
1537 :
1538 94 : if (attrib == ATTRIBUTE_READWRITE)
1539 : {
1540 46 : if ( ! pseudo)
1541 : {
1542 45 : _H.Tab() << "virtual void " << info->_cppName << "(" ;
1543 : PrintType(_H.Str(),
1544 : type,
1545 : PRINT_IN,
1546 : dummy1,
1547 : dummy2,
1548 45 : dummy3) ;
1549 45 : _H.Str() << ") = 0 ;" << endl ;
1550 : }
1551 : else
1552 : {
1553 1 : _H.Tab() << "void " << info->_cppName << "(" ;
1554 : PrintType(_H.Str(),
1555 : type,
1556 : PRINT_IN,
1557 : dummy1,
1558 : dummy2,
1559 1 : dummy3) ;
1560 1 : _H.Str() << ") ;" << endl ;
1561 : }
1562 : }
1563 :
1564 94 : _H.Str() << endl ;
1565 :
1566 : //=============================== Stub H ===================================
1567 : // Read Write attribute :
1568 : // ----------------------
1569 : // void Attr(<in_type>) ;
1570 : // <return_type> Attr(void) ;
1571 : //
1572 : // Read only attribute :
1573 : // ---------------------
1574 : // <return_type> Attr(void) ;
1575 :
1576 : // Get
1577 : // ===
1578 :
1579 94 : if ( ! pseudo)
1580 : {
1581 89 : _StubH.Tab() ;
1582 : PrintType(_StubH.Str(),
1583 : type,
1584 : PRINT_RETURN,
1585 : info->_isConst,
1586 : info->_isPointer,
1587 89 : info->_isVar) ;
1588 :
1589 89 : _StubH.Str() << " " << info->_cppName << "(void) ;" << endl ;
1590 : }
1591 :
1592 : // Set
1593 : // ===
1594 :
1595 94 : if ( (attrib == ATTRIBUTE_READWRITE)
1596 : && ( ! pseudo))
1597 : {
1598 45 : _StubH.Tab() << "virtual void " << info->_cppName << "(" ;
1599 : PrintType(_StubH.Str(),
1600 : type,
1601 : PRINT_IN,
1602 : dummy1,
1603 : dummy2,
1604 45 : dummy3) ;
1605 45 : _StubH.Str() << ") = 0 ;" << endl ;
1606 : }
1607 :
1608 48 : if ( ! pseudo)
1609 : {
1610 89 : _StubH.Str() << endl ;
1611 : }
1612 :
1613 : //=============================== Skel H ===================================
1614 : // Read Write attribute :
1615 : // ----------------------
1616 : // static void _get_Attr(
1617 : // PortableServer::ServantBase*,
1618 : // YAORB::Request&,
1619 : // YAORB::Reply&) ;
1620 : // static void _set_Attr(
1621 : // PortableServer::ServantBase*,
1622 : // YAORB::Request&,
1623 : // YAORB::Reply&) ;
1624 : //
1625 : // Read only attribute :
1626 : // ---------------------
1627 : // static void _get_Attr(
1628 : // PortableServer::ServantBase*,
1629 : // YAORB::Request&,
1630 : // YAORB::Reply&) ;
1631 :
1632 : // Get
1633 : // ===
1634 :
1635 : if ( ! pseudo)
1636 : {
1637 89 : _SkelH.Tab() << "static void _get_" << info->_cppName << "(" << endl ;
1638 89 : _SkelH.IncTab() ;
1639 89 : _SkelH.Tab() << "PortableServer::ServantBase*," << endl ;
1640 89 : _SkelH.Tab() << "YAORB::Request&," << endl ;
1641 89 : _SkelH.Tab() << "YAORB::Reply&) ;" << endl ;
1642 89 : _SkelH.DecTab() ;
1643 : }
1644 :
1645 : // Set
1646 : // ===
1647 :
1648 93 : if ( (attrib == ATTRIBUTE_READWRITE)
1649 : && ( ! pseudo))
1650 : {
1651 45 : _SkelH.Tab() << "static void _set_" << info->_cppName << "(" << endl ;
1652 45 : _SkelH.IncTab() ;
1653 45 : _SkelH.Tab() << "PortableServer::ServantBase*," << endl ;
1654 45 : _SkelH.Tab() << "YAORB::Request&," << endl ;
1655 45 : _SkelH.Tab() << "YAORB::Reply&) ;" << endl ;
1656 45 : _SkelH.DecTab() ;
1657 : }
1658 :
1659 48 : if ( ! pseudo)
1660 : {
1661 89 : _SkelH.Str() << endl ;
1662 : }
1663 : }
1664 :
1665 : void LangCpp::GenerateAttributeImpl(
1666 : SymbolContainer *symTab,
1667 89 : Attribute *attribute)
1668 : {
1669 89 : GenerateAttributeStubImpl(attribute) ;
1670 89 : GenerateAttributeSkelImpl(attribute) ;
1671 : }
1672 :
1673 : void LangCpp::GenerateAttributeStubImpl(
1674 89 : Attribute *attribute)
1675 : {
1676 89 : CppInfo *info = GetCppInfo(attribute) ;
1677 :
1678 89 : IDLType *type = attribute->GetType() ;
1679 89 : AttributeAttribute attrib = attribute->GetAttribute() ;
1680 :
1681 : //=============================== Stub CPP =================================
1682 : // Read Write attribute :
1683 : // ----------------------
1684 : // void Attr(<in_type>)
1685 : // {
1686 : // }
1687 : //
1688 : // <return_type> Attr(void)
1689 : // {
1690 : // }
1691 : //
1692 : // Read only attribute :
1693 : // ---------------------
1694 : // <return_type> Attr(void)
1695 : // {
1696 : // ...
1697 : // }
1698 :
1699 : // Get
1700 : // ===
1701 :
1702 : PrintType(_StubCpp.Str(),
1703 : type,
1704 : PRINT_RETURN,
1705 : info->_isConst,
1706 : info->_isPointer,
1707 89 : info->_isVar) ;
1708 :
1709 89 : _StubCpp.Str() << " " << info->_cppName << "(void)" << endl ;
1710 89 : _StubCpp.Tab() << "{" << endl ;
1711 :
1712 89 : NON_DEV("GenerateAttributeStubImpl") ;
1713 89 : _StubCpp.Str() << "NON_DEV(\"GenerateAttributeStubImpl\") ;" << endl ;
1714 :
1715 89 : _StubCpp.Tab() << "}" << endl ;
1716 :
1717 : // Set
1718 : // ===
1719 :
1720 89 : if (attrib == ATTRIBUTE_READWRITE)
1721 : {
1722 : bool dummy1, dummy2, dummy3 ;
1723 :
1724 45 : _StubCpp.Tab() << "void " << info->_cppName << "(" ;
1725 : PrintType(_StubCpp.Str(),
1726 : type,
1727 : PRINT_RETURN,
1728 : dummy1,
1729 : dummy2,
1730 45 : dummy3) ;
1731 45 : _StubCpp.Str() << " __attr)" << endl ;
1732 45 : _StubCpp.Tab() << "{" << endl ;
1733 :
1734 45 : NON_DEV("GenerateAttributeStubImpl") ;
1735 45 : _StubCpp.Str() << "NON_DEV(\"GenerateAttributeStubImpl\") ;" << endl ;
1736 :
1737 45 : _StubCpp.Tab() << "}" << endl ;
1738 : }
1739 : }
1740 :
1741 : void LangCpp::GenerateAttributeSkelImpl(
1742 89 : Attribute *attribute)
1743 : {
1744 89 : CppInfo *info = GetCppInfo(attribute) ;
1745 :
1746 : // IDLType *type = attribute->GetType() ;
1747 89 : AttributeAttribute attrib = attribute->GetAttribute() ;
1748 :
1749 89 : String className = Prefix(info->_cppSkelFullName) ;
1750 :
1751 : _SkelCpp.Tab() << "void " << className
1752 89 : << "::_get_" << info->_cppName << "(" << endl ;
1753 89 : _SkelCpp.IncTab() ;
1754 89 : _SkelCpp.Tab() << "PortableServer::ServantBase* __this," << endl ;
1755 89 : _SkelCpp.Tab() << "YAORB::Request& __request," << endl ;
1756 89 : _SkelCpp.Tab() << "YAORB::Reply& __reply)" << endl ;
1757 89 : _SkelCpp.DecTab() ;
1758 89 : _SkelCpp.Tab() << "{" << endl ;
1759 :
1760 89 : NON_DEV("GenerateAttributeSkelImpl") ;
1761 89 : _SkelCpp.Str() << "NON_DEV(\"GenerateAttributeSkelImpl\") ;" << endl ;
1762 :
1763 89 : _SkelCpp.Tab() << "}" << endl << endl ;
1764 :
1765 89 : if (attrib == ATTRIBUTE_READWRITE)
1766 : {
1767 : _SkelCpp.Tab() << "void " << className
1768 45 : << "::_get_" << info->_cppName << "(" << endl ;
1769 45 : _SkelCpp.IncTab() ;
1770 45 : _SkelCpp.Tab() << "PortableServer::ServantBase* __this," << endl ;
1771 45 : _SkelCpp.Tab() << "YAORB::Request& __request," << endl ;
1772 45 : _SkelCpp.Tab() << "YAORB::Reply& __reply)" << endl ;
1773 45 : _SkelCpp.DecTab() ;
1774 45 : _SkelCpp.Tab() << "{" << endl ;
1775 :
1776 45 : NON_DEV("GenerateAttributeSkelImpl") ;
1777 45 : _SkelCpp.Str() << "NON_DEV(\"GenerateAttributeSkelImpl\") ;" << endl ;
1778 :
1779 45 : _SkelCpp.Tab() << "}" << endl << endl ;
1780 0 : }
1781 : }
1782 :
1783 : void LangCpp::GenerateOperationDecl(
1784 : SymbolContainer *symTab,
1785 : Operation *operation,
1786 565 : bool pseudo)
1787 : {
1788 565 : CppInfo *info = new CppInfo(operation) ;
1789 565 : SetCppInfo(operation, info) ;
1790 :
1791 565 : IDLType* returnType = operation->GetReturnType() ;
1792 565 : const ParameterList& params = operation->GetParameterList() ;
1793 :
1794 : //=============================== STUB H ===================================
1795 : // <return_type> Operation(
1796 : // <arg1_type> arg1,
1797 : // <arg2_type> arg2,
1798 : // ...,
1799 : // <argN_type> argn) ;
1800 : //
1801 :
1802 565 : if ( ! pseudo)
1803 : {
1804 492 : _StubH.Tab() << "virtual " ;
1805 :
1806 : PrintType(
1807 : _StubH.Str(),
1808 : returnType,
1809 : PRINT_RETURN,
1810 : info->_isConst,
1811 : info->_isPointer,
1812 492 : info->_isVar) ;
1813 :
1814 492 : _StubH.Str() << " " << info->_cppName << "(" ;
1815 :
1816 492 : _StubH.IncTab() ;
1817 492 : PrintParameterList(params, _StubH, false) ;
1818 492 : _StubH.DecTab() ;
1819 :
1820 492 : _StubH.Str() << ") ;" << endl << endl ;
1821 : }
1822 :
1823 :
1824 : //=============================== H ========================================
1825 : // virtual <return_type> Operation(
1826 : // <arg1_type> arg1,
1827 : // <arg2_type> arg2,
1828 : // ...,
1829 : // <argN_type> argn) = 0 ;
1830 : //
1831 :
1832 : if ( ! pseudo)
1833 : {
1834 492 : _H.Tab() << "virtual " ;
1835 : }
1836 : else
1837 : {
1838 73 : (void) _H.Tab() ;
1839 : }
1840 :
1841 : PrintType(
1842 : _H.Str(),
1843 : returnType,
1844 : PRINT_RETURN,
1845 : info->_isConst,
1846 : info->_isPointer,
1847 565 : info->_isVar) ;
1848 :
1849 565 : _H.Str() << " " << info->_cppName << "(" ;
1850 :
1851 565 : _H.IncTab() ;
1852 565 : PrintParameterList(params, _H, true) ;
1853 565 : _H.DecTab() ;
1854 :
1855 565 : if ( ! pseudo)
1856 : {
1857 492 : _H.Str() << ") = 0 ;" << endl << endl ;
1858 : }
1859 : else
1860 : {
1861 73 : _H.Str() << ") ;" << endl << endl ;
1862 : }
1863 :
1864 : //=============================== SKEL H ===================================
1865 : // static void _op_Operation(
1866 : // FIXME : PortableServer::Servant*,
1867 : // YAORB::Request&,
1868 : // YAORB::Reply&) ;
1869 : //
1870 :
1871 : if ( ! pseudo)
1872 : {
1873 492 : _SkelH.Tab() << "static void _op_" << info->_cppName << endl ;
1874 492 : _SkelH.IncTab() ;
1875 : _SkelH.Tab()
1876 : << "(PortableServer::ServantBase*, YAORB::Request&, YAORB::Reply&) ;"
1877 492 : << endl << endl ;
1878 492 : _SkelH.DecTab() ;
1879 : }
1880 : }
1881 :
1882 : void LangCpp::GenerateOperationImpl(
1883 : SymbolContainer *symTab,
1884 492 : Operation *operation)
1885 : {
1886 492 : GenerateOperationStubImpl(symTab, operation) ;
1887 492 : GenerateOperationSkelImpl(symTab, operation) ;
1888 : }
1889 :
1890 : void LangCpp::GenerateOperationStubImpl(
1891 : SymbolContainer *symTab,
1892 492 : Operation *operation)
1893 : {
1894 492 : CppInfo *info = GetCppInfo(operation) ;
1895 :
1896 492 : IDLType* returnType = operation->GetReturnType() ;
1897 492 : const ParameterList& params = operation->GetParameterList() ;
1898 : Parameter *param = NULL ;
1899 : CppInfo *pInfo = NULL ;
1900 :
1901 515 : static String CDRName ("__cdrs") ;
1902 515 : static String resultName ("__result") ;
1903 :
1904 : //=============================== STUB CPP =================================
1905 : // <return_type>
1906 : // Foo_Stub::Operation(
1907 : // <arg1_type> arg1,
1908 : // <arg2_type> arg2,
1909 : // ...,
1910 : // <argN_type> argn)
1911 : // {
1912 : // // FIXME : Prepare a request in a CDR stream.
1913 : // const YAORB::Ref & __ref = this->GetRef() ;
1914 : // const char* __op = "Operation" ;
1915 : // YAORB::Request __request ;
1916 : // YAORB::Reply __reply ;
1917 : // YAORB::CDR *__cdrs = ??? ;
1918 : // // FIXME : Encode IN and INOUT parameters
1919 : // // FIXME : Send the request
1920 : // // FIXME : Wait for the reply
1921 : // // FIXME : Decode INOUT and RETURN parameters
1922 : // // FIXME : return
1923 : // // FIXME : Decode exceptions
1924 : // // FIXME : Throw exceptions
1925 : // }
1926 :
1927 492 : String prefix = Prefix(info->_cppStubFullName) ;
1928 :
1929 : bool retIsConst, retIsPointer, retIsVar ;
1930 :
1931 : PrintType(_StubCpp.Str(),
1932 : returnType,
1933 : PRINT_RETURN,
1934 : retIsConst,
1935 : retIsPointer,
1936 492 : retIsVar) ;
1937 :
1938 492 : _StubCpp.Str() << endl ;
1939 492 : _StubCpp.Tab() << prefix << "::" << info->_cppName << "(" ;
1940 :
1941 492 : _StubCpp.IncTab() ;
1942 492 : PrintParameterList(params, _StubCpp, false) ;
1943 492 : _StubCpp.DecTab() ;
1944 :
1945 492 : _StubCpp.Str() << ")" << endl ;
1946 :
1947 492 : _StubCpp.Tab() << "{" << endl ;
1948 492 : _StubCpp.IncTab() ;
1949 492 : _StubCpp.Tab() << "const YAORB::Ref & __ref = this->GetRef() ;" << endl ;
1950 : _StubCpp.Tab() << "const char * __op = \""
1951 492 : << operation->GetName() << "\" ;" << endl ;
1952 492 : _StubCpp.Tab() << "YAORB::Request __request ;" << endl ;
1953 492 : _StubCpp.Tab() << "YAORB::Reply __reply ;" << endl ;
1954 492 : _StubCpp.Tab() << "YAORB::CDR *" << CDRName << " ;" << endl << endl ;
1955 :
1956 492 : _StubCpp.Tab() << "// 1: Prepare request" << endl ;
1957 492 : _StubCpp.Tab() << CDRName << " = __request.init(__ref, __op) ;" << endl ;
1958 :
1959 : ParameterListIt itRequest(params) ;
1960 :
1961 1119 : while (itRequest.GetNext())
1962 : {
1963 : param = itRequest.GetItem() ;
1964 627 : pInfo = GetCppInfo(param) ;
1965 :
1966 627 : switch(param->GetAttribute())
1967 : {
1968 : case PARAMETER_IN :
1969 : case PARAMETER_INOUT :
1970 : {
1971 555 : IDLType *paramType = param->GetType() ;
1972 :
1973 555 : _StubCpp.Tab() ;
1974 : PrintCDR(pInfo->_cppName,
1975 : paramType,
1976 : CDRName,
1977 : pInfo->_isConst,
1978 : pInfo->_isPointer,
1979 555 : _StubCpp.Str()) ;
1980 : break ;
1981 : }
1982 : case PARAMETER_OUT :
1983 : {
1984 : // Not used in request.
1985 : break ;
1986 : }
1987 : }
1988 : }
1989 :
1990 492 : _StubCpp.Tab() << "__request.complete() ;" << endl ;
1991 492 : _StubCpp.Str() << endl ;
1992 :
1993 492 : _StubCpp.Tab() << "// 2: Send Request." << endl ;
1994 :
1995 : _StubCpp.Tab() << "YAORB::Stub::Send(__request, __reply) ;"
1996 492 : << endl << endl ;
1997 492 : _StubCpp.Tab() << CDRName << " = __reply.GetCDR() ;" << endl ;
1998 :
1999 492 : _StubCpp.Tab() << "if (__reply.IsUserException())" << endl ;
2000 492 : _StubCpp.Tab() << "{" << endl ;
2001 492 : _StubCpp.IncTab() ;
2002 492 : _StubCpp.Tab() << "// 3: Decode Exception" << endl ;
2003 492 : _StubCpp.Tab() << "// 4: Throw Exception" << endl ;
2004 492 : _StubCpp.DecTab() ;
2005 492 : _StubCpp.Tab() << "}" << endl << endl ;
2006 492 : _StubCpp.Tab() << "// 5: Decode Normal reply" << endl ;
2007 :
2008 492 : if (returnType->isA() != idl_void)
2009 : {
2010 : bool isConst, isPointer, isVar ;
2011 :
2012 327 : _StubCpp.Tab() ;
2013 : PrintType(_StubCpp.Str(),
2014 : returnType,
2015 : PRINT_RETURN,
2016 : isConst,
2017 : isPointer,
2018 327 : isVar) ;
2019 327 : _StubCpp.Str() << " " << resultName << " ;" << endl ;
2020 :
2021 327 : _StubCpp.Tab() ;
2022 : PrintCDR(resultName,
2023 : returnType,
2024 : CDRName,
2025 : isConst,
2026 : isPointer,
2027 327 : _StubCpp.Str()) ;
2028 : }
2029 :
2030 : ParameterListIt itReply(params) ;
2031 :
2032 1119 : while (itReply.GetNext())
2033 : {
2034 : param = itReply.GetItem() ;
2035 627 : pInfo = GetCppInfo(param) ;
2036 :
2037 627 : switch(param->GetAttribute())
2038 : {
2039 : case PARAMETER_OUT :
2040 : case PARAMETER_INOUT :
2041 : {
2042 72 : IDLType *paramType = param->GetType() ;
2043 :
2044 72 : Tabulate(_StubCpp.Str(), 2) ;
2045 : PrintCDR(pInfo->_cppName,
2046 : paramType,
2047 : CDRName,
2048 : pInfo->_isConst,
2049 : pInfo->_isPointer,
2050 72 : _StubCpp.Str()) ;
2051 : break ;
2052 : }
2053 : case PARAMETER_IN :
2054 : {
2055 : // Not used in reply.
2056 : break ;
2057 : }
2058 : }
2059 : }
2060 :
2061 492 : if (returnType->isA() != idl_void)
2062 : {
2063 327 : _StubCpp.Tab() << "return " << resultName << " ;" << endl ;
2064 : }
2065 : else
2066 : {
2067 165 : _StubCpp.Tab() << "return ;" << endl ;
2068 : }
2069 :
2070 492 : _StubCpp.DecTab() ;
2071 492 : _StubCpp.Tab() << "}" << endl << endl ;
2072 : }
2073 :
2074 : void LangCpp::GenerateOperationSkelImpl(
2075 : SymbolContainer *symTab,
2076 564 : Operation *operation)
2077 : {
2078 492 : CppInfo *info = GetCppInfo(operation) ;
2079 :
2080 492 : IDLType* returnType = operation->GetReturnType() ;
2081 492 : const ParameterList& params = operation->GetParameterList() ;
2082 : Parameter *param = NULL ;
2083 : CppInfo *pInfo = NULL ;
2084 : printMode mode ;
2085 :
2086 : int nbParam = params.size() ;
2087 : int index = 0 ;
2088 : bool *paramIsConstVector = NULL ;
2089 : bool *paramIsPointerVector = NULL ;
2090 : bool *paramIsVarVector = NULL ;
2091 : bool paramIsFixedType = false ;
2092 :
2093 492 : if (nbParam > 0)
2094 : {
2095 362 : paramIsConstVector = new bool[nbParam] ;
2096 362 : paramIsPointerVector = new bool[nbParam] ;
2097 362 : paramIsVarVector = new bool[nbParam] ;
2098 : }
2099 :
2100 515 : static String CDRName ("__cdrs") ;
2101 515 : static String resultName ("__result") ;
2102 :
2103 : //=============================== SKEL CPP =================================
2104 : // void
2105 : // POA_foo::_op_Operation(
2106 : // PortableServer::ServantBase*,
2107 : // YAORB::Request& __request,
2108 : // YAORB::Reply& __reply)
2109 : // {
2110 : // __reply.completed = NO ;
2111 : //
2112 : // // 1 : Decode input arguments
2113 : //
2114 : // try
2115 : // {
2116 : // __reply.completed = MAYBE ;
2117 : // // 2: Call the method implementation
2118 : // __reply.completed = YES ;
2119 : // }
2120 : // catch (...)
2121 : // {
2122 : // // 3 : Encode a user exception reply
2123 : // }
2124 : //
2125 : // // 4 : Encode a normal reply
2126 : // }
2127 :
2128 492 : String prefix = Prefix(info->_cppSkelFullName) ;
2129 :
2130 492 : _SkelCpp.Tab() << "void" << endl ;
2131 : _SkelCpp.Tab() << prefix << "::_op_" << info->_cppName
2132 492 : << "(" << endl ;
2133 492 : _SkelCpp.IncTab() ;
2134 492 : _SkelCpp.Tab() << "PortableServer::ServantBase* __this," << endl ;
2135 492 : _SkelCpp.Tab() << "YAORB::Request& __request," << endl ;
2136 492 : _SkelCpp.Tab() << "YAORB::Reply& __reply)" << endl ;
2137 492 : _SkelCpp.DecTab() ;
2138 492 : _SkelCpp.Tab() << "{" << endl ;
2139 492 : _SkelCpp.IncTab() ;
2140 :
2141 492 : _SkelCpp.Tab() << "// 1: Decode request" << endl ;
2142 492 : _SkelCpp.Tab() << "YAORB::CDR *" << CDRName << " ;" << endl ;
2143 492 : _SkelCpp.Tab() << CDRName << " = __request.GetCDR() ;" << endl ;
2144 492 : _SkelCpp.Str() << endl ;
2145 :
2146 : //--------------------------------------------------------------------------
2147 : // Emit code to declare locals for parameters.
2148 : // Emit code to decode the in & inout parameters.
2149 : //--------------------------------------------------------------------------
2150 :
2151 : ParameterListIt itRequest(params) ;
2152 :
2153 : index = 0 ;
2154 :
2155 1119 : while (itRequest.GetNext())
2156 : {
2157 : param = itRequest.GetItem() ;
2158 627 : pInfo = GetCppInfo(param) ;
2159 627 : IDLType *paramType = param->GetType() ;
2160 :
2161 627 : paramIsFixedType = IsTypeFixedLength(paramType) ;
2162 :
2163 627 : if (paramIsFixedType)
2164 : {
2165 : mode = PRINT_NORMAL ;
2166 : }
2167 : else
2168 : {
2169 : mode = PRINT_VAR ;
2170 : }
2171 :
2172 627 : _SkelCpp.Tab() ;
2173 : PrintType(_SkelCpp.Str(),
2174 : paramType,
2175 : mode,
2176 : paramIsConstVector[index],
2177 : paramIsPointerVector[index],
2178 627 : paramIsVarVector[index]) ;
2179 :
2180 627 : _SkelCpp.Str() << " " << pInfo->_cppName << " ;" << endl ;
2181 :
2182 627 : switch(param->GetAttribute())
2183 : {
2184 : case PARAMETER_IN :
2185 : case PARAMETER_INOUT :
2186 : {
2187 555 : _SkelCpp.Tab() ;
2188 : PrintCDR(pInfo->_cppName,
2189 : paramType,
2190 : CDRName,
2191 : paramIsConstVector[index],
2192 : paramIsPointerVector[index],
2193 555 : _SkelCpp.Str()) ;
2194 : break ;
2195 : }
2196 : case PARAMETER_OUT :
2197 : {
2198 : break ;
2199 : }
2200 : }
2201 :
2202 : index ++ ;
2203 : }
2204 :
2205 492 : _SkelCpp.Str() << endl ;
2206 :
2207 : //--------------------------------------------------------------------------
2208 : // Emit code to declare a variable for the return value.
2209 : //--------------------------------------------------------------------------
2210 :
2211 492 : bool returnIsConst = false ;
2212 492 : bool returnIsPointer = false ;
2213 492 : bool returnIsVar = false ;
2214 :
2215 492 : if (returnType->isA() != idl_void)
2216 : {
2217 327 : if (info->_isVar)
2218 : {
2219 : mode = PRINT_VAR ;
2220 : }
2221 : else
2222 : {
2223 : mode = PRINT_NORMAL ;
2224 : }
2225 :
2226 327 : _SkelCpp.Tab() ;
2227 : PrintType(_SkelCpp.Str(),
2228 : returnType,
2229 : mode,
2230 : returnIsConst,
2231 : returnIsPointer,
2232 327 : returnIsVar) ;
2233 :
2234 327 : _SkelCpp.Str() << " " << resultName << " ;" << endl ;
2235 : }
2236 :
2237 : //--------------------------------------------------------------------------
2238 : // Emit code to generate the call
2239 : //--------------------------------------------------------------------------
2240 :
2241 492 : String className = Prefix(info->_cppSkelFullName) ;
2242 492 : _SkelCpp.Tab() << className << " *__that ;" << endl ;
2243 : _SkelCpp.Tab() << "__that = (" << className << "*) __this ;"
2244 492 : << endl ;
2245 :
2246 492 : if (returnType->isA() != idl_void)
2247 : {
2248 :
2249 : _SkelCpp.Tab() << resultName << " = __that->"
2250 327 : << info->_cppName << "(" ;
2251 : }
2252 : else
2253 : {
2254 165 : _SkelCpp.Tab() << "__that->" << info->_cppName << "(" ;
2255 : }
2256 :
2257 492 : _SkelCpp.IncTab() ;
2258 492 : PrintCallParameterList(params, _SkelCpp) ;
2259 492 : _SkelCpp.DecTab() ;
2260 :
2261 492 : _SkelCpp.Str() << ") ;" << endl << endl ;
2262 :
2263 : //--------------------------------------------------------------------------
2264 : // Emit code to encode the return value.
2265 : //--------------------------------------------------------------------------
2266 :
2267 492 : if (returnType->isA() != idl_void)
2268 : {
2269 327 : _SkelCpp.Tab() ;
2270 : PrintCDR(resultName,
2271 : returnType,
2272 : CDRName,
2273 : returnIsConst,
2274 : returnIsPointer,
2275 327 : _SkelCpp.Str()) ;
2276 : }
2277 :
2278 : //--------------------------------------------------------------------------
2279 : // Emit code to encode the out & inout parameters.
2280 : //--------------------------------------------------------------------------
2281 :
2282 : ParameterListIt itReply(params) ;
2283 :
2284 : index = 0 ;
2285 :
2286 1119 : while (itReply.GetNext())
2287 : {
2288 : param = itReply.GetItem() ;
2289 627 : pInfo = GetCppInfo(param) ;
2290 :
2291 627 : switch(param->GetAttribute())
2292 : {
2293 : case PARAMETER_OUT :
2294 : case PARAMETER_INOUT :
2295 : {
2296 72 : IDLType *paramType = param->GetType() ;
2297 :
2298 72 : _SkelCpp.Tab() ;
2299 : PrintCDR(pInfo->_cppName,
2300 : paramType,
2301 : CDRName,
2302 : paramIsConstVector[index],
2303 : paramIsPointerVector[index],
2304 144 : _SkelCpp.Str()) ;
2305 : break ;
2306 : }
2307 : case PARAMETER_IN :
2308 : {
2309 : // Not used in reply.
2310 : break ;
2311 : }
2312 : }
2313 :
2314 : index ++ ;
2315 : }
2316 :
2317 492 : _SkelCpp.DecTab() ;
2318 492 : _SkelCpp.Tab() << "}" << endl << endl ;
2319 :
2320 492 : if (nbParam >0)
2321 : {
2322 362 : delete [] paramIsConstVector ;
2323 362 : delete [] paramIsPointerVector ;
2324 362 : delete [] paramIsVarVector ;
2325 0 : }
2326 : }
2327 :
2328 : void LangCpp::PrintParameterList(
2329 : const ParameterList& params,
2330 : CodePrinter & str,
2331 1549 : bool buildInfo)
2332 : {
2333 : Parameter *param = NULL ;
2334 :
2335 1549 : if (params.size() == 0)
2336 : {
2337 : // No parameters at all.
2338 409 : str.Str() << "void" ;
2339 : }
2340 : else
2341 : {
2342 : ParameterListIt it(params) ;
2343 :
2344 1140 : str.Str() << endl ;
2345 :
2346 1140 : if (it.GetNext())
2347 : {
2348 : param = it.GetItem() ;
2349 1140 : PrintParameter(param, str, buildInfo) ;
2350 : }
2351 :
2352 1979 : while (it.GetNext())
2353 : {
2354 839 : str.Str() << "," << endl ;
2355 :
2356 : param = it.GetItem() ;
2357 839 : PrintParameter(param, str, buildInfo) ;
2358 : }
2359 : }
2360 : }
2361 :
2362 : void LangCpp::PrintParameter(
2363 : Parameter *param,
2364 : CodePrinter & str,
2365 1979 : bool buildInfo)
2366 : {
2367 : CppInfo *info ;
2368 1979 : if (buildInfo)
2369 : {
2370 725 : info = new CppInfo(param) ;
2371 725 : SetCppInfo(param, info) ;
2372 : }
2373 : else
2374 : {
2375 1254 : info = GetCppInfo(param) ;
2376 : }
2377 :
2378 1979 : IDLType* type = param->GetType() ;
2379 : printMode mode = PRINT_IN ; // Initialized to avoid warnings
2380 :
2381 1979 : switch(param->GetAttribute())
2382 : {
2383 : case PARAMETER_IN :
2384 : {
2385 : mode = PRINT_IN ;
2386 : break ;
2387 : }
2388 : case PARAMETER_OUT :
2389 : {
2390 : mode = PRINT_OUT ;
2391 : break ;
2392 : }
2393 : case PARAMETER_INOUT :
2394 : {
2395 : mode = PRINT_INOUT ;
2396 : break ;
2397 : }
2398 : }
2399 :
2400 : bool isConst ;
2401 : bool isPointer ;
2402 : bool isVar ;
2403 :
2404 1979 : str.Tab() ;
2405 1979 : PrintType(str.Str(), type, mode, isConst, isPointer, isVar) ;
2406 1979 : str.Str() << " " << info->_cppName ;
2407 :
2408 1979 : if (buildInfo)
2409 : {
2410 725 : info->_isConst = isConst ;
2411 725 : info->_isPointer = isPointer ;
2412 725 : info->_isVar = isVar ;
2413 : }
2414 : }
2415 :
2416 : void LangCpp::PrintCallParameterList(
2417 : const ParameterList& params,
2418 492 : CodePrinter & str)
2419 : {
2420 : Parameter *param = NULL ;
2421 :
2422 492 : if (params.size() == 0)
2423 : {
2424 : // No parameters at all.
2425 : }
2426 : else
2427 : {
2428 : ParameterListIt it(params) ;
2429 :
2430 362 : str.Str() << endl ;
2431 :
2432 362 : if (it.GetNext())
2433 : {
2434 : param = it.GetItem() ;
2435 362 : PrintCallParameter(param, str) ;
2436 : }
2437 :
2438 627 : while (it.GetNext())
2439 : {
2440 265 : str.Str() << "," << endl ;
2441 :
2442 : param = it.GetItem() ;
2443 265 : PrintCallParameter(param, str) ;
2444 : }
2445 : }
2446 : }
2447 :
2448 : void LangCpp::PrintCallParameter(
2449 : Parameter *param,
2450 627 : CodePrinter & str)
2451 : {
2452 627 : CppInfo *info = GetCppInfo(param) ;
2453 :
2454 627 : str.Tab() << info->_cppName ;
2455 :
2456 627 : if (info->_isVar)
2457 : {
2458 356 : switch(param->GetAttribute())
2459 : {
2460 : case PARAMETER_IN :
2461 : {
2462 307 : str.Str() << ".in()" ;
2463 : break ;
2464 : }
2465 : case PARAMETER_OUT :
2466 : {
2467 49 : str.Str() << ".out()" ;
2468 : break ;
2469 : }
2470 : case PARAMETER_INOUT :
2471 : {
2472 0 : str.Str() << ".inout()" ;
2473 : break ;
2474 : }
2475 : }
2476 : }
2477 : }
2478 :
2479 : void LangCpp::GenerateTypedefDecl(
2480 : SymbolContainer *symTab,
2481 69 : Typedef *type_def)
2482 : {
2483 69 : CppInfo *info = new CppInfo(type_def) ;
2484 69 : SetCppInfo(type_def, info) ;
2485 :
2486 69 : IDLType* type = type_def->GetType() ;
2487 :
2488 69 : _H.Tab() << "typedef " ;
2489 : PrintType(_H.Str(),
2490 : type,
2491 : PRINT_NORMAL,
2492 : info->_isConst,
2493 : info->_isPointer,
2494 69 : info->_isVar) ;
2495 :
2496 69 : _H.Str() << " " << info->_cppName << " ;" << endl ;
2497 :
2498 69 : if (type->isA() == idl_sequence)
2499 : {
2500 : _H.Tab() << "typedef CORBAVLengthStructVar<" << info->_cppName
2501 45 : << "> " << info->_cppName << "_var ;" << endl ;
2502 : }
2503 :
2504 69 : _H.Str() << endl ;
2505 : }
2506 :
2507 : void LangCpp::GenerateExceptionDecl(
2508 : SymbolContainer *symbTab,
2509 76 : Exception *exception)
2510 : {
2511 76 : CppInfo *info = new CppInfo(exception) ;
2512 76 : SetCppInfo(exception, info) ;
2513 :
2514 : //=============================== H, Part 1 =================================
2515 : // class Foo : public CORBA::UserException
2516 : // {
2517 : // public:
2518 : // Foo();
2519 : // Foo(const Foo &);
2520 : // FIXME : Foo(<<CONTENT>>) ;
2521 : // ~Foo();
2522 : // Foo &operator=(const Foo &);
2523 : //
2524 : // FIXME : Any &exception();
2525 : // static Foo* _downcast(CORBA::UserException*);
2526 : // static const Foo* _downcast(const CORBA::UserException*);
2527 : // virtual void _raise(void) const ;
2528 : // private:
2529 : // FIXME : <<CONTENT>
2530 : // };
2531 :
2532 : _H.Tab() << "class " << info->_cppName
2533 76 : << " : public CORBA::UserException" << endl ;
2534 76 : _H.Tab() << "{" << endl ;
2535 :
2536 76 : _H.IncTab() ;
2537 76 : _H.Tab() << "public :" << endl ;
2538 76 : _H.IncTab() ;
2539 :
2540 76 : _H.Tab() << info->_cppName << "() ;" << endl ;
2541 :
2542 : _H.Tab() << info->_cppName << "(const " << info->_cppName << "& ) ;"
2543 76 : << endl ;
2544 :
2545 76 : _H.Tab() << "~" << info->_cppName << "() ;" << endl ;
2546 :
2547 : _H.Tab() << info->_cppName << "& operator =(const "
2548 76 : << info->_cppName << "& ) ;" << endl ;
2549 76 : _H.Str() << endl ;
2550 :
2551 : _H.Tab() << "static " << info->_cppName
2552 76 : << "* _downcast(CORBA::UserException*) ;" << endl ;
2553 :
2554 : _H.Tab() << "static const " << info->_cppName
2555 76 : << "* _downcast(const CORBA::UserException*) ;" << endl ;
2556 :
2557 76 : _H.Tab() << "virtual void _raise(void) const ;" << endl ;
2558 :
2559 76 : _H.DecTab() ;
2560 76 : _H.Tab() << "private :" << endl ;
2561 76 : _H.IncTab() ;
2562 :
2563 76 : const MemberList& members = exception->GetMembers() ;
2564 : MemberListIt it(members) ;
2565 : Member *member = 0 ;
2566 76 : bool dummy = true ;
2567 :
2568 177 : while (it.GetNext())
2569 : {
2570 : member = it.GetItem() ;
2571 25 : GenerateMemberDecl(member, dummy) ;
2572 : }
2573 :
2574 76 : info->_hasFixedLengthStorage = false ;
2575 :
2576 : //=============================== H, Part 2 =================================
2577 :
2578 76 : _H.DecTab() ;
2579 76 : _H.DecTab() ;
2580 76 : _H.Tab() << "} ;" << endl << endl ;
2581 :
2582 : }
2583 :
2584 : void LangCpp::GenerateExceptionImpl(
2585 : SymbolContainer *symbTab,
2586 76 : Exception *exception)
2587 : {
2588 76 : NON_DEV("GenerateExceptionImpl") ;
2589 :
2590 76 : CppInfo *info = GetCppInfo(exception) ;
2591 :
2592 : //=============================== CPP ======================================
2593 : // Foo::Foo()
2594 : // {}
2595 : //
2596 : // Foo::Foo(const Foo& except)
2597 : // {}
2598 : //
2599 : // Foo::~Foo()
2600 : // {}
2601 : //
2602 : // void Foo::_raise(void) const
2603 : // {
2604 : // throw *this ;
2605 : // }
2606 :
2607 : _Cpp.Tab() << info->_cppFullName
2608 76 : << "::" << info->_cppName << "()" << endl ;
2609 76 : _Cpp.Tab() << ": CORBA::UserException()" << endl ;
2610 76 : _Cpp.Tab() << "{}" << endl << endl ;
2611 :
2612 : _Cpp.Tab() << info->_cppFullName
2613 : << "::" << info->_cppName << "(const "
2614 76 : << info->_cppFullName << "& except)" << endl ;
2615 76 : _Cpp.Tab() << ": CORBA::UserException(except)" << endl ;
2616 76 : _Cpp.Tab() << "{}" << endl << endl ;
2617 :
2618 : _Cpp.Tab() << info->_cppFullName
2619 76 : << "::~" << info->_cppName << "()" << endl ;
2620 76 : _Cpp.Tab() << "{}" << endl << endl ;
2621 :
2622 : _Cpp.Tab() << "void " << info->_cppFullName
2623 76 : << "::_raise(void) const" << endl ;
2624 76 : _Cpp.Tab() << "{" << endl ;
2625 76 : _Cpp.IncTab() ;
2626 76 : _Cpp.Tab() << "throw *this ;" << endl ;
2627 76 : _Cpp.DecTab() ;
2628 76 : _Cpp.Tab() << "}" << endl << endl ;
2629 : }
2630 :
2631 : void LangCpp::GenerateStructDecl(
2632 : SymbolContainer *symTab,
2633 : Struct *structure,
2634 42 : bool pseudo)
2635 : {
2636 42 : CppInfo *info = new CppInfo(structure) ;
2637 42 : SetCppInfo(structure, info) ;
2638 :
2639 : //=============================== H, Part 1 =================================
2640 : // struct Foo
2641 : // {
2642 : // << CONTENT >>
2643 :
2644 42 : _H.Tab() << "struct " << info->_cppName << endl ;
2645 42 : _H.Tab() << "{" << endl ;
2646 :
2647 42 : _H.IncTab() ;
2648 :
2649 : //=============================== CONTENT ===================================
2650 :
2651 42 : const MemberList& members = structure->GetMembers() ;
2652 : MemberListIt it(members) ;
2653 : Member *member = 0 ;
2654 42 : bool memberFixedLength = true ;
2655 : bool structFixedLength = true ;
2656 :
2657 244 : while (it.GetNext())
2658 : {
2659 : member = it.GetItem() ;
2660 160 : GenerateMemberDecl(member, memberFixedLength) ;
2661 160 : if (memberFixedLength == false)
2662 : {
2663 : structFixedLength = false ;
2664 : }
2665 : }
2666 :
2667 : //=============================== H, Part 2 =================================
2668 : // << CONTENT >>
2669 : //
2670 : // void cdr(YAORB::CDR*) ;
2671 : // } ;
2672 : // typedef CORBAVar<Foo> Foo_var ;
2673 :
2674 42 : _H.Str() << endl ;
2675 :
2676 42 : if ( ! pseudo)
2677 : {
2678 42 : _H.Tab() << "void cdr(YAORB::CDR*) ;" << endl ;
2679 : }
2680 42 : _H.DecTab() ;
2681 :
2682 42 : _H.Tab() << "} ;" << endl ;
2683 :
2684 42 : if (structFixedLength)
2685 : {
2686 : _H.Tab() << "typedef CORBAFixedStructVar<" << info->_cppName << "> "
2687 5 : << info->_cppName << "_var ;" << endl ;
2688 : }
2689 : else
2690 : {
2691 : _H.Tab() << "typedef CORBAVLengthStructVar<" << info->_cppName << "> "
2692 37 : << info->_cppName << "_var ;" << endl ;
2693 : }
2694 :
2695 42 : _H.Str() << endl ;
2696 :
2697 42 : info->_hasFixedLengthStorage = structFixedLength ;
2698 : }
2699 :
2700 : void LangCpp::GenerateStructImpl(
2701 : SymbolContainer *symTab,
2702 : Struct *structure,
2703 42 : bool pseudo)
2704 : {
2705 42 : if (pseudo)
2706 : {
2707 42 : return ;
2708 : }
2709 :
2710 42 : CppInfo *info = GetCppInfo(structure) ;
2711 52 : static String cdrName("__cdrs") ;
2712 :
2713 : //=============================== CPP ======================================
2714 : // void Foo::cdr(YAORB::CDR* __cdrs)
2715 : // {
2716 : // << CONTENT >>
2717 :
2718 : _Cpp.Tab() << "void " << info->_cppFullName
2719 42 : << "::cdr(YAORB::CDR* " << cdrName << ")" << endl ;
2720 42 : _Cpp.Tab() << "{" << endl ;
2721 :
2722 : //=============================== CONTENT ===================================
2723 :
2724 42 : const MemberList& members = structure->GetMembers() ;
2725 : MemberListIt it(members) ;
2726 : Member *member = 0 ;
2727 :
2728 244 : while (it.GetNext())
2729 : {
2730 160 : (void) Tabulate(_Cpp.Str(), 1) ;
2731 : member = it.GetItem() ;
2732 160 : GenerateMemberImpl(member, cdrName) ;
2733 : }
2734 :
2735 : //=============================== CPP ======================================
2736 : // << CONTENT >>
2737 : // }
2738 :
2739 42 : _Cpp.Tab() << "}" << endl << endl ;
2740 : }
2741 :
2742 : void LangCpp::GenerateMemberDecl(
2743 : Member *member,
2744 185 : bool& memberFixedLength)
2745 : {
2746 185 : CppInfo *info = new CppInfo(member) ;
2747 185 : SetCppInfo(member, info) ;
2748 :
2749 185 : IDLType *type = member->GetType() ;
2750 :
2751 185 : _H.Tab() ;
2752 :
2753 185 : memberFixedLength = IsTypeFixedLength(type) ;
2754 :
2755 185 : if (memberFixedLength)
2756 : {
2757 : PrintType(_H.Str(),
2758 : type,
2759 : PRINT_NORMAL,
2760 : info->_isConst,
2761 : info->_isPointer,
2762 52 : info->_isVar) ;
2763 : }
2764 : else
2765 : {
2766 : PrintType(_H.Str(),
2767 : type,
2768 : PRINT_VAR,
2769 : info->_isConst,
2770 : info->_isPointer,
2771 133 : info->_isVar) ;
2772 : }
2773 :
2774 185 : _H.Str() << " " << info->_cppName << " ;" << endl ;
2775 : }
2776 :
2777 : void LangCpp::GenerateMemberImpl(
2778 : Member *member,
2779 160 : const String& cdrName)
2780 : {
2781 160 : CppInfo *info = GetCppInfo(member) ;
2782 160 : IDLType *type = member->GetType() ;
2783 :
2784 : const String& name = info->_cppName ;
2785 : bool isConst = false ;
2786 : bool isPointer = false ;
2787 :
2788 : PrintCDR(name,
2789 : type,
2790 : cdrName,
2791 : isConst,
2792 : isPointer,
2793 160 : _Cpp.Str()) ;
2794 : }
2795 :
2796 : void LangCpp::GenerateUnionDecl(
2797 : SymbolContainer *symTab,
2798 0 : Union *union_symbol)
2799 : {
2800 0 : NON_DEV("GenerateUnionDecl") ;
2801 : }
2802 :
2803 : void LangCpp::GenerateConstantDecl(
2804 : SymbolContainer *symTab,
2805 13 : Constant *constant)
2806 : {
2807 13 : CppInfo *info = new CppInfo(constant) ;
2808 13 : SetCppInfo(constant, info) ;
2809 :
2810 13 : info->_isConst = true ;
2811 :
2812 13 : IDLValue *value = constant->GetValue() ;
2813 13 : IDLType *type = value->GetValueType() ;
2814 :
2815 13 : switch (type->isA())
2816 : {
2817 : case idl_string :
2818 : {
2819 0 : _H.Tab() << "static const char* const" ;
2820 0 : break ;
2821 : }
2822 : case idl_wstring :
2823 : {
2824 0 : _H.Tab() << "static const wchar_t* const" ;
2825 0 : break ;
2826 : }
2827 : default :
2828 : {
2829 : bool dummy ;
2830 13 : _H.Tab() << "static const " ;
2831 : PrintType(_H.Str(),
2832 : type,
2833 : PRINT_NORMAL,
2834 : dummy,
2835 : info->_isPointer,
2836 13 : info->_isVar) ;
2837 : break ;
2838 : }
2839 : }
2840 :
2841 13 : _H.Str() << " " << info->_cppName << " = " ;
2842 13 : PrintValue(_H.Str(), value) ;
2843 13 : _H.Str() << " ;" << endl ;
2844 : }
2845 :
2846 : void LangCpp::GenerateEnumDecl(
2847 : SymbolContainer *symTab,
2848 : Enum *enum_symbol,
2849 31 : bool pseudo)
2850 : {
2851 : /*
2852 : ** What the function does with an example ...
2853 : **
2854 : ** INPUT
2855 : ** =====
2856 : ** IDL : enum Color { red, green, blue } ;
2857 : **
2858 : ** OUTPUT
2859 : ** ======
2860 : ** C++ .h :
2861 : **
2862 : ** enum Color
2863 : ** {
2864 : ** red = 0,
2865 : ** green = 1,
2866 : ** blue = 2
2867 : ** } ;
2868 : ** typedef Color& Color_out ;
2869 : ** void CDR_Color(YAORB::CDR*, Color*) ;
2870 : **
2871 : ** NOTE
2872 : ** ====
2873 : ** An IDL enum IS implemented using 32 bits (ULong).
2874 : ** A C++ enum might NOT be implemented using 32 bits.
2875 : **
2876 : */
2877 :
2878 31 : CppInfo *info = new CppInfo(enum_symbol) ;
2879 31 : SetCppInfo(enum_symbol, info) ;
2880 :
2881 31 : _H.Tab() << "enum " << info->_cppName << endl ;
2882 31 : _H.Tab() << "{" << endl ;
2883 :
2884 31 : _H.IncTab() ;
2885 :
2886 31 : const EnumItemList& ItemList = enum_symbol->GetItems() ;
2887 : EnumItemListIt it(ItemList) ;
2888 : int value = 0 ;
2889 : EnumItem *item ;
2890 :
2891 31 : if (it.GetNext())
2892 : {
2893 : item = it.GetItem() ;
2894 :
2895 31 : _H.Tab() << item->GetName() << " = " << value ;
2896 : value ++ ;
2897 : }
2898 :
2899 172 : while (it.GetNext())
2900 : {
2901 141 : _H.Str() << "," << endl ;
2902 :
2903 : item = it.GetItem() ;
2904 :
2905 141 : _H.Tab() << item->GetName() << " = " << value ;
2906 141 : value ++ ;
2907 : }
2908 :
2909 31 : _H.Str() << endl ;
2910 :
2911 31 : _H.DecTab() ;
2912 :
2913 31 : _H.Tab() << "} ;" << endl ;
2914 : _H.Tab() << "typedef " << info->_cppName << "& "
2915 31 : << info->_cppName << "_out ; " << endl ;
2916 :
2917 31 : if ( ! pseudo)
2918 : {
2919 : _H.Tab() << "void CDR_" << info->_cppName
2920 30 : << "(YAORB::CDR*, " << info->_cppName << "*) ;" << endl ;
2921 : }
2922 :
2923 31 : _H.Str() << endl ;
2924 : }
2925 :
2926 : void LangCpp::GenerateEnumImpl(
2927 : SymbolContainer *symTab,
2928 : Enum *enum_symbol,
2929 31 : bool pseudo)
2930 : {
2931 : /*
2932 : ** What the function does with an example ...
2933 : **
2934 : ** INPUT
2935 : ** =====
2936 : ** IDL : enum Color { red, green, blue } ;
2937 : **
2938 : ** OUTPUT
2939 : ** ======
2940 : ** C++ .cpp :
2941 : **
2942 : ** void <FIXME:fully_qualified_name>::CDR_Color(YAORB::CDR* cdrs, Color* e)
2943 : ** {
2944 : ** CORBA::ULong value ;
2945 : ** switch (cdrs->Op())
2946 : ** {
2947 : ** case YAORB::CDR_READ:
2948 : ** {
2949 : ** cdrs->cdr_ULong(& value) ;
2950 : ** *e = (Color) value ;
2951 : ** break ;
2952 : ** }
2953 : ** case YAORB::CDR_WRITE:
2954 : ** {
2955 : ** value = (CORBA::ULong) (*e) ;
2956 : ** cdrs->cdr_ULong(& value) ;
2957 : ** break ;
2958 : ** }
2959 : ** }
2960 : ** }
2961 : **
2962 : ** NOTE
2963 : ** ====
2964 : ** An IDL enum IS implemented using 32 bits (ULong).
2965 : ** A C++ enum might NOT be implemented using 32 bits.
2966 : **
2967 : */
2968 :
2969 31 : if (pseudo)
2970 : {
2971 30 : return ;
2972 : }
2973 :
2974 30 : CppInfo *info = GetCppInfo(enum_symbol) ;
2975 :
2976 30 : String prefix = Prefix(info->_cppFullName) ;
2977 :
2978 :
2979 : _Cpp.Tab() << "void " << prefix << "::CDR_" << info->_cppName
2980 30 : << "(YAORB::CDR *cdrs, " << info->_cppFullName << " *e)" << endl ;
2981 30 : _Cpp.Tab() << "{" << endl ;
2982 30 : _Cpp.IncTab() ;
2983 30 : _Cpp.Tab() << "CORBA::ULong value ;" << endl ;
2984 30 : _Cpp.Tab() << "switch (cdrs->Op())" << endl ;
2985 30 : _Cpp.Tab() << "{" << endl ;
2986 30 : _Cpp.IncTab() ;
2987 30 : _Cpp.Tab() << "case YAORB::CDR_READ:" << endl ;
2988 30 : _Cpp.Tab() << "{" << endl ;
2989 30 : _Cpp.IncTab() ;
2990 30 : _Cpp.Tab() << "cdrs->cdr_ULong(& value) ;" << endl ;
2991 30 : _Cpp.Tab() << "*e = (" << info->_cppFullName <<") value ;" << endl ;
2992 30 : _Cpp.Tab() << "break ;" << endl ;
2993 30 : _Cpp.DecTab() ;
2994 30 : _Cpp.Tab() << "}" << endl ;
2995 30 : _Cpp.Tab() << "case YAORB::CDR_WRITE:" << endl ;
2996 30 : _Cpp.Tab() << "{" << endl ;
2997 30 : _Cpp.IncTab() ;
2998 30 : _Cpp.Tab() << "value = (CORBA::ULong) (*e) ;" << endl ;
2999 30 : _Cpp.Tab() << "cdrs->cdr_ULong(& value) ;" << endl ;
3000 30 : _Cpp.Tab() << "break ;" << endl ;
3001 30 : _Cpp.DecTab() ;
3002 30 : _Cpp.Tab() << "}" << endl ;
3003 30 : _Cpp.DecTab() ;
3004 30 : _Cpp.Tab() << "}" << endl ;
3005 30 : _Cpp.DecTab() ;
3006 60 : _Cpp.Tab() << "}" << endl << endl ;
3007 : }
3008 :
3009 : void LangCpp::PrintType(
3010 : ostream& str,
3011 : IDLType *type,
3012 : printMode mode,
3013 : bool& isConst,
3014 : bool& isPointer,
3015 6098 : bool& isVar)
3016 : {
3017 6098 : switch (type->isA())
3018 : {
3019 : case idl_errorType :
3020 : {
3021 : str << endl ;
3022 0 : str << "#error IDL->C++ generation failed due to previous errors." ;
3023 : str << endl ;
3024 : break ;
3025 : }
3026 : case idl_intType :
3027 : {
3028 : IDLIntType *t = (IDLIntType*) type ;
3029 612 : PrintIntType(str, t, mode, isConst, isPointer, isVar) ;
3030 : break ;
3031 : }
3032 : case idl_floatType :
3033 : {
3034 : IDLFloatType *t = (IDLFloatType*) type ;
3035 0 : PrintFloatType(str, t, mode, isConst, isPointer, isVar) ;
3036 : break ;
3037 : }
3038 : case idl_charType :
3039 : {
3040 0 : PrintCharType(str, mode, isConst, isPointer, isVar) ;
3041 : break ;
3042 : }
3043 : case idl_wcharType :
3044 : {
3045 0 : PrintWCharType(str, mode, isConst, isPointer, isVar) ;
3046 : break ;
3047 : }
3048 : case idl_boolType :
3049 : {
3050 872 : PrintBoolType(str, mode, isConst, isPointer, isVar) ;
3051 : break ;
3052 : }
3053 : case idl_struct :
3054 : {
3055 : IDLStructType *t = (IDLStructType*) type ;
3056 144 : PrintStructType(str, t, mode, isConst, isPointer, isVar) ;
3057 : break ;
3058 : }
3059 : case idl_enum :
3060 : {
3061 : IDLEnumType *t = (IDLEnumType*) type ;
3062 179 : PrintEnumType(str, t, mode, isConst, isPointer, isVar) ;
3063 : break ;
3064 : }
3065 : case idl_typedef :
3066 : {
3067 : IDLTypedefType *t = (IDLTypedefType*) type ;
3068 1012 : PrintTypedefType(str, t, mode, isConst, isPointer, isVar) ;
3069 : break ;
3070 : }
3071 : case idl_array :
3072 : {
3073 0 : str << "FIXME idl_array" ;
3074 : break ;
3075 : }
3076 : case idl_sequence :
3077 : {
3078 : IDLSequenceType *t = (IDLSequenceType*) type ;
3079 48 : PrintSequenceType(str, t, mode, isConst, isPointer, isVar) ;
3080 : break ;
3081 : }
3082 : case idl_string :
3083 : {
3084 569 : PrintStringType(str, mode, isConst, isPointer, isVar) ;
3085 : break ;
3086 : }
3087 : case idl_wstring :
3088 : {
3089 0 : PrintWStringType(str, mode, isConst, isPointer, isVar) ;
3090 : break ;
3091 : }
3092 : case idl_any :
3093 : {
3094 518 : PrintAnyType(str, mode, isConst, isPointer, isVar) ;
3095 : break ;
3096 : }
3097 : case idl_object :
3098 : {
3099 97 : PrintObjectType(str, mode, isConst, isPointer, isVar) ;
3100 : break ;
3101 : }
3102 : case idl_octet :
3103 : {
3104 0 : PrintOctetType(str, mode, isConst, isPointer, isVar) ;
3105 : break ;
3106 : }
3107 : case idl_interface :
3108 : {
3109 : IDLInterfaceType *i = (IDLInterfaceType*) type ;
3110 1527 : PrintInterfaceType(str, i, mode, isConst, isPointer, isVar) ;
3111 : break ;
3112 : }
3113 : case idl_void :
3114 : {
3115 : ASSERT(mode == PRINT_RETURN) ;
3116 506 : str << "void" ;
3117 : break ;
3118 : }
3119 : case idl_native :
3120 : {
3121 : IDLNativeType *t = (IDLNativeType*) type ;
3122 14 : PrintNativeType(str, t, mode, isConst, isPointer, isVar) ;
3123 : break ;
3124 : }
3125 : }
3126 : }
3127 :
3128 : void LangCpp::PrintCDR(
3129 : const String& dataName,
3130 : IDLType *type,
3131 : const String& cdrName,
3132 : bool isConst,
3133 : bool isPointer,
3134 2509 : ostream& str)
3135 : {
3136 2509 : switch (type->isA())
3137 : {
3138 : case idl_errorType :
3139 : {
3140 : str << endl ;
3141 0 : str << "#error IDL->C++ generation failed due to previous errors." ;
3142 : str << endl ;
3143 : break ;
3144 : }
3145 : case idl_intType :
3146 : {
3147 : IDLIntType *t = (IDLIntType*) type ;
3148 : PrintCDRInt(
3149 : dataName,
3150 : t,
3151 : cdrName,
3152 : isConst,
3153 : isPointer,
3154 243 : str) ;
3155 : break ;
3156 : }
3157 : case idl_floatType :
3158 : {
3159 0 : str << "FIXME idl_floatType" ;
3160 : break ;
3161 : }
3162 : case idl_charType :
3163 : {
3164 : PrintCDRChar(
3165 : dataName,
3166 : cdrName,
3167 : isConst,
3168 : isPointer,
3169 0 : str) ;
3170 : break ;
3171 : }
3172 : case idl_wcharType :
3173 : {
3174 : PrintCDRWChar(
3175 : dataName,
3176 : cdrName,
3177 : isConst,
3178 : isPointer,
3179 0 : str) ;
3180 : break ;
3181 : }
3182 : case idl_boolType :
3183 : {
3184 : PrintCDRBool(
3185 : dataName,
3186 : cdrName,
3187 : isConst,
3188 : isPointer,
3189 346 : str) ;
3190 : break ;
3191 : }
3192 : case idl_struct :
3193 : {
3194 : IDLStructType *t = (IDLStructType*) type ;
3195 : PrintCDRStruct(
3196 : dataName,
3197 : t,
3198 : cdrName,
3199 : isConst,
3200 : isPointer,
3201 58 : str) ;
3202 : break ;
3203 : }
3204 : case idl_enum :
3205 : {
3206 : IDLEnumType *t = (IDLEnumType*) type ;
3207 : PrintCDREnum(
3208 : dataName,
3209 : t,
3210 : cdrName,
3211 : isConst,
3212 : isPointer,
3213 63 : str) ;
3214 : break ;
3215 : }
3216 : case idl_typedef :
3217 : {
3218 : IDLTypedefType *t = (IDLTypedefType*) type ;
3219 : PrintCDRTypedef(
3220 : dataName,
3221 : t,
3222 : cdrName,
3223 : isConst,
3224 : isPointer,
3225 441 : str) ;
3226 : break ;
3227 : }
3228 : case idl_array :
3229 : {
3230 0 : str << "FIXME idl_array" ;
3231 : break ;
3232 : }
3233 : case idl_sequence :
3234 : {
3235 : IDLSequenceType *t = (IDLSequenceType*) type ;
3236 : PrintCDRSequence(
3237 : dataName,
3238 : t,
3239 : cdrName,
3240 : isConst,
3241 : isPointer,
3242 176 : str) ;
3243 : break ;
3244 : }
3245 : case idl_string :
3246 : {
3247 : PrintCDRString(
3248 : dataName,
3249 : cdrName,
3250 : isConst,
3251 : isPointer,
3252 261 : str) ;
3253 : break ;
3254 : }
3255 : case idl_wstring :
3256 : {
3257 : PrintCDRWString(
3258 : dataName,
3259 : cdrName,
3260 : isConst,
3261 : isPointer,
3262 0 : str) ;
3263 : break ;
3264 : }
3265 : case idl_any :
3266 : {
3267 : PrintCDRAny(
3268 : dataName,
3269 : cdrName,
3270 : isConst,
3271 : isPointer,
3272 258 : str) ;
3273 : break ;
3274 : }
3275 : case idl_octet :
3276 : {
3277 : PrintCDROctet(
3278 : dataName,
3279 : cdrName,
3280 : isConst,
3281 : isPointer,
3282 0 : str) ;
3283 : break ;
3284 : }
3285 : case idl_interface :
3286 : {
3287 : IDLInterfaceType *t = (IDLInterfaceType*) type ;
3288 : PrintCDRInterface(
3289 : dataName,
3290 : t,
3291 : cdrName,
3292 : isConst,
3293 : isPointer,
3294 625 : str) ;
3295 : break ;
3296 : }
3297 : case idl_object :
3298 : {
3299 : PrintCDRObject(
3300 : dataName,
3301 : cdrName,
3302 : isConst,
3303 : isPointer,
3304 38 : str) ;
3305 : break ;
3306 : }
3307 : case idl_void :
3308 : {
3309 0 : str << "FIXME idl_void" ;
3310 : break ;
3311 : }
3312 : case idl_native :
3313 : {
3314 0 : str << "FIXME idl_native" ;
3315 : break ;
3316 : }
3317 : }
3318 : }
3319 :
3320 : void LangCpp::PrintCDRInt(
3321 : const String& dataName,
3322 : IDLIntType *type,
3323 : const String& cdrName,
3324 : bool isConst,
3325 : bool isPointer,
3326 243 : ostream& str)
3327 : {
3328 243 : str << cdrName << "->" ;
3329 :
3330 243 : switch(type->GetType())
3331 : {
3332 : case idl_signed_short :
3333 : {
3334 38 : str << "cdr_Short" ;
3335 38 : break ;
3336 : }
3337 : case idl_signed_long :
3338 : {
3339 48 : str << "cdr_Long" ;
3340 48 : break ;
3341 : }
3342 : case idl_signed_long_long :
3343 : {
3344 0 : str << "cdr_LongLong" ;
3345 0 : break ;
3346 : }
3347 : case idl_unsigned_short :
3348 : {
3349 3 : str << "cdr_UShort" ;
3350 3 : break ;
3351 : }
3352 : case idl_unsigned_long :
3353 : {
3354 143 : str << "cdr_ULong" ;
3355 143 : break ;
3356 : }
3357 : case idl_unsigned_long_long :
3358 : {
3359 11 : str << "cdr_ULongLong" ;
3360 : break ;
3361 : }
3362 : }
3363 :
3364 : ASSERT(isConst == false) ;
3365 : ASSERT(isPointer == false) ;
3366 243 : str << "(& " << dataName << ") ;" << endl ;
3367 : }
3368 :
3369 : void LangCpp::PrintCDRBool(
3370 : const String& dataName,
3371 : const String& cdrName,
3372 : bool isConst,
3373 : bool isPointer,
3374 346 : ostream& str)
3375 : {
3376 346 : str << cdrName << "->cdr_Boolean(" ;
3377 :
3378 346 : if (isConst)
3379 : {
3380 0 : str << "(CORBA::Boolean*)" ;
3381 : }
3382 :
3383 346 : if ( ! isPointer)
3384 : {
3385 346 : str << " & " ;
3386 : }
3387 :
3388 346 : str << dataName << ") ;" << endl ;
3389 : }
3390 :
3391 : void LangCpp::PrintCDRChar(
3392 : const String& dataName,
3393 : const String& cdrName,
3394 : bool isConst,
3395 : bool isPointer,
3396 0 : ostream& str)
3397 : {
3398 0 : str << cdrName << "->cdr_Char(" ;
3399 :
3400 0 : if (isConst)
3401 : {
3402 0 : str << "(CORBA::Char*)" ;
3403 : }
3404 :
3405 0 : if ( ! isPointer)
3406 : {
3407 0 : str << " & " ;
3408 : }
3409 :
3410 0 : str << dataName << ") ;" << endl ;
3411 : }
3412 :
3413 : void LangCpp::PrintCDRWChar(
3414 : const String& dataName,
3415 : const String& cdrName,
3416 : bool isConst,
3417 : bool isPointer,
3418 0 : ostream& str)
3419 : {
3420 0 : str << cdrName << "->cdr_WChar(" ;
3421 :
3422 0 : if (isConst)
3423 : {
3424 0 : str << "(CORBA::WChar*)" ;
3425 : }
3426 :
3427 0 : if ( ! isPointer)
3428 : {
3429 0 : str << " & " ;
3430 : }
3431 :
3432 0 : str << dataName << ") ;" << endl ;
3433 : }
3434 :
3435 : void LangCpp::PrintCDRStruct(
3436 : const String& dataName,
3437 : IDLStructType *type,
3438 : const String& cdrName,
3439 : bool isConst,
3440 : bool isPointer,
3441 58 : ostream& str)
3442 : {
3443 58 : Struct *s = type->GetSymbol() ;
3444 58 : CppInfo *info = GetCppInfo(s) ;
3445 :
3446 58 : if (isConst == true)
3447 : {
3448 11 : str << "((" << info->_cppFullName ;
3449 :
3450 11 : if (isPointer == true)
3451 : {
3452 0 : str << "*" ;
3453 : }
3454 :
3455 11 : str << ")" << dataName << ")" ;
3456 : }
3457 : else
3458 : {
3459 47 : str << dataName ;
3460 : }
3461 :
3462 :
3463 58 : if (isPointer == true)
3464 : {
3465 9 : str << "->cdr(" << cdrName << ") ;" << endl ;
3466 : }
3467 : else
3468 : {
3469 49 : str << ".cdr(" << cdrName << ") ;" << endl ;
3470 : }
3471 :
3472 : return ;
3473 : }
3474 :
3475 : void LangCpp::PrintCDREnum(
3476 : const String& dataName,
3477 : IDLEnumType *type,
3478 : const String& cdrName,
3479 : bool isConst,
3480 : bool isPointer,
3481 63 : ostream& str)
3482 : {
3483 63 : Enum *e = type->GetSymbol() ;
3484 63 : CppInfo *info = GetCppInfo(e) ;
3485 63 : const String& prefix = Prefix(info->_cppFullName) ;
3486 :
3487 63 : str << prefix << "::CDR_" << info->_cppName ;
3488 63 : str << "(" << cdrName << ", & " << dataName << ") ;" << endl ;
3489 :
3490 63 : return ;
3491 : }
3492 :
3493 : void LangCpp::PrintCDRTypedef(
3494 : const String& dataName,
3495 : IDLTypedefType *type,
3496 : const String& cdrName,
3497 : bool isConst,
3498 : bool isPointer,
3499 441 : ostream& str)
3500 : {
3501 441 : Typedef *symbol = type->GetSymbol() ;
3502 441 : IDLType* t = symbol->GetType() ;
3503 :
3504 441 : PrintCDR(dataName, t, cdrName, isConst, isPointer, str) ;
3505 : }
3506 :
3507 : void LangCpp::PrintCDRSequence(
3508 : const String& dataName,
3509 : IDLSequenceType *type,
3510 : const String& cdrName,
3511 : bool isConst,
3512 : bool isPointer,
3513 176 : ostream& str)
3514 : {
3515 : char *call ;
3516 :
3517 176 : if (isPointer)
3518 : {
3519 : call = "->" ;
3520 : }
3521 : else
3522 : {
3523 : call = "." ;
3524 : }
3525 :
3526 176 : str << dataName << call << "cdr(" << cdrName << ") ;" << endl ;
3527 : }
3528 :
3529 : void LangCpp::PrintCDRString(
3530 : const String& dataName,
3531 : const String& cdrName,
3532 : bool isConst,
3533 : bool isPointer,
3534 261 : ostream& str)
3535 : {
3536 : char *call ;
3537 :
3538 261 : if (isPointer)
3539 : {
3540 : call = "->" ;
3541 : }
3542 : else
3543 : {
3544 : call = "." ;
3545 : }
3546 :
3547 261 : str << dataName << call << "cdr(" << cdrName << ") ;" << endl ;
3548 : }
3549 :
3550 : void LangCpp::PrintCDRWString(
3551 : const String& dataName,
3552 : const String& cdrName,
3553 : bool isConst,
3554 : bool isPointer,
3555 0 : ostream& str)
3556 : {
3557 : char *call ;
3558 :
3559 0 : if (isPointer)
3560 : {
3561 : call = "->" ;
3562 : }
3563 : else
3564 : {
3565 : call = "." ;
3566 : }
3567 :
3568 0 : str << dataName << call << "cdr(" << cdrName << ") ;" << endl ;
3569 : }
3570 :
3571 : void LangCpp::PrintCDRAny(
3572 : const String& dataName,
3573 : const String& cdrName,
3574 : bool isConst,
3575 : bool isPointer,
3576 258 : ostream& str)
3577 : {
3578 258 : str << "// FIXME CDR" << endl ;
3579 : }
3580 :
3581 : void LangCpp::PrintCDROctet(
3582 : const String& dataName,
3583 : const String& cdrName,
3584 : bool isConst,
3585 : bool isPointer,
3586 0 : ostream& str)
3587 : {
3588 0 : str << cdrName << "->cdr_Octet(" ;
3589 :
3590 0 : if (isConst)
3591 : {
3592 0 : str << "(CORBA::Octet*) " ;
3593 : }
3594 :
3595 0 : if ( ! isPointer)
3596 : {
3597 0 : str << "& " ;
3598 : }
3599 :
3600 0 : str << dataName << ") ;" << endl ;
3601 : }
3602 :
3603 : void LangCpp::PrintCDRInterface(
3604 : const String& dataName,
3605 : IDLInterfaceType *type,
3606 : const String& cdrName,
3607 : bool isConst,
3608 : bool isPointer,
3609 625 : ostream& str)
3610 : {
3611 625 : str << "NON_DEV(\"LangCpp::PrintCDRInterface\") ;" << endl ;
3612 :
3613 625 : Interface *i = type->GetSymbol() ;
3614 625 : CppInfo *info = GetCppInfo(i) ;
3615 :
3616 625 : str << dataName << " = " << info->_cppFullName << "::_nil() ;" << endl ;
3617 :
3618 : #ifdef LATER
3619 : // Brain damaged : get rid of "encode"
3620 : if (encode)
3621 : {
3622 : str << dataName << "->cdr(" << cdrName << ") ;"
3623 : << endl ;
3624 : }
3625 : else
3626 : {
3627 : Interface *i = type->GetSymbol() ;
3628 : CppInfo *info = GetCppInfo(i) ;
3629 :
3630 : str << dataName << " = " << info->_cppFullName ;
3631 : str << "::_bind(" << cdrName << ") ;" << endl ;
3632 : }
3633 : #endif
3634 : }
3635 :
3636 : void LangCpp::PrintCDRObject(
3637 : const String& dataName,
3638 : const String& cdrName,
3639 : bool isConst,
3640 : bool isPointer,
3641 38 : ostream& str)
3642 : {
3643 38 : str << "NON_DEV(\"LangCpp::PrintCDRObject\") ;" << endl ;
3644 :
3645 38 : if (isConst == false)
3646 : {
3647 24 : str << dataName << " = CORBA::Object::_nil() ;" << endl ;
3648 : }
3649 :
3650 : #ifdef LATER
3651 : // Brain damaged :
3652 : if (encode)
3653 : {
3654 : str << dataName << "->cdr(" << cdrName << ") ;" << endl ;
3655 : }
3656 : else
3657 : {
3658 : str << dataName << " = CORBA::Object::_bind(" << cdrName << ") ;" << endl ;
3659 : }
3660 : #endif
3661 : }
3662 :
3663 : void LangCpp::PrintNativeType(
3664 : ostream& str,
3665 : IDLNativeType *type,
3666 : printMode mode,
3667 : bool& isConst,
3668 : bool& isPointer,
3669 14 : bool& isVar)
3670 : {
3671 14 : SymNative *symbol = type->GetSymbol() ;
3672 14 : const String& name = symbol->GetFullyQualifiedName() ;
3673 :
3674 14 : if (name == "PortableServer::ServantLocator::Cookie")
3675 : {
3676 2 : isConst = false ;
3677 2 : isPointer = true ;
3678 2 : isVar = false ;
3679 :
3680 2 : switch(mode)
3681 : {
3682 : case PRINT_NORMAL :
3683 : case PRINT_IN :
3684 : case PRINT_RETURN :
3685 : {
3686 1 : str << "void*" ;
3687 : break ;
3688 : }
3689 : case PRINT_OUT :
3690 : case PRINT_INOUT :
3691 : {
3692 1 : str << "void*&" ;
3693 : break ;
3694 : }
3695 : case PRINT_PTR :
3696 : case PRINT_VAR :
3697 : {
3698 : str << endl ;
3699 0 : str << "#error Unsupported native Cookie usage." << endl ;
3700 : break ;
3701 : }
3702 : }
3703 : return ;
3704 : }
3705 :
3706 : // Default Native mapping, also used for "PortableServer::Servant"
3707 :
3708 12 : isVar = false ; // FIXME
3709 :
3710 12 : switch(mode)
3711 : {
3712 : case PRINT_NORMAL :
3713 : case PRINT_RETURN :
3714 : {
3715 5 : isConst = false ;
3716 5 : isPointer = false ;
3717 5 : str << name;
3718 : break ;
3719 : }
3720 : case PRINT_IN :
3721 : {
3722 7 : isConst = true ;
3723 7 : isPointer = false ;
3724 7 : str << "const " << name << "&" ;
3725 : break ;
3726 : }
3727 : case PRINT_OUT :
3728 : {
3729 0 : isConst = false ;
3730 0 : isPointer = false ;
3731 0 : str << name << "&" ;
3732 : break ;
3733 : }
3734 : case PRINT_INOUT :
3735 : {
3736 0 : isConst = false ;
3737 0 : isPointer = true ;
3738 0 : str << name << "*&" ;
3739 : break ;
3740 : }
3741 : case PRINT_PTR :
3742 : {
3743 0 : isConst = false ;
3744 0 : isPointer = false ;
3745 0 : str << name << "_ptr" ;
3746 : break ;
3747 : }
3748 : case PRINT_VAR :
3749 : {
3750 0 : isConst = false ;
3751 0 : isPointer = false ;
3752 0 : str << name << "_var" ;
3753 : break ;
3754 : }
3755 : }
3756 : }
3757 :
3758 : void LangCpp::PrintIntType(
3759 : ostream& str,
3760 : IDLIntType *type,
3761 : printMode mode,
3762 : bool& isConst,
3763 : bool& isPointer,
3764 612 : bool& isVar)
3765 : {
3766 612 : isConst = false ;
3767 612 : isPointer = false ;
3768 612 : isVar = false ;
3769 :
3770 612 : switch(type->GetType())
3771 : {
3772 : case idl_signed_short :
3773 : {
3774 106 : str << "CORBA::Short" ;
3775 106 : break ;
3776 : }
3777 : case idl_signed_long :
3778 : {
3779 107 : str << "CORBA::Long" ;
3780 107 : break ;
3781 : }
3782 : case idl_signed_long_long :
3783 : {
3784 0 : str << "CORBA::LongLong" ;
3785 0 : break ;
3786 : }
3787 : case idl_unsigned_short :
3788 : {
3789 19 : str << "CORBA::UShort" ;
3790 19 : break ;
3791 : }
3792 : case idl_unsigned_long :
3793 : {
3794 353 : str << "CORBA::ULong" ;
3795 353 : break ;
3796 : }
3797 : case idl_unsigned_long_long :
3798 : {
3799 27 : str << "CORBA::ULongLong" ;
3800 : break ;
3801 : }
3802 : }
3803 :
3804 612 : switch (mode)
3805 : {
3806 : case PRINT_VAR:
3807 : case PRINT_NORMAL:
3808 : case PRINT_IN:
3809 : case PRINT_RETURN:
3810 : {
3811 : // Nothing
3812 : break ;
3813 : }
3814 : case PRINT_OUT:
3815 : case PRINT_INOUT:
3816 : {
3817 15 : str << "&" ;
3818 : break ;
3819 : }
3820 : case PRINT_PTR:
3821 : {
3822 : ASSERT(false) ;
3823 : }
3824 : }
3825 : }
3826 :
3827 : void LangCpp::PrintFloatType(
3828 : ostream& str,
3829 : IDLFloatType *type,
3830 : printMode mode,
3831 : bool& isConst,
3832 : bool& isPointer,
3833 0 : bool& isVar)
3834 : {
3835 0 : isConst = false ;
3836 0 : isPointer = false ;
3837 0 : isVar = false ;
3838 :
3839 0 : switch(type->GetType())
3840 : {
3841 : case idl_float :
3842 : {
3843 0 : str << "CORBA::Float" ;
3844 0 : break ;
3845 : }
3846 : case idl_double :
3847 : {
3848 0 : str << "CORBA::Double" ;
3849 0 : break ;
3850 : }
3851 : case idl_long_double :
3852 : {
3853 0 : str << "CORBA::LongDouble" ;
3854 : break ;
3855 : }
3856 : }
3857 :
3858 0 : switch (mode)
3859 : {
3860 : case PRINT_VAR:
3861 : case PRINT_NORMAL:
3862 : case PRINT_IN:
3863 : case PRINT_RETURN:
3864 : {
3865 : // Nothing
3866 : break ;
3867 : }
3868 : case PRINT_OUT:
3869 : case PRINT_INOUT:
3870 : {
3871 0 : str << "&" ;
3872 : break ;
3873 : }
3874 : case PRINT_PTR:
3875 : {
3876 : ASSERT(false) ;
3877 : }
3878 : }
3879 : }
3880 :
3881 : void LangCpp::PrintStringType(
3882 : ostream& str,
3883 : printMode mode,
3884 : bool& isConst,
3885 : bool& isPointer,
3886 569 : bool& isVar)
3887 : {
3888 569 : isPointer = false ; // CDR prototype accept char*
3889 569 : isVar = true ; // use String_var for .in() .inout() .out() and ._retn()
3890 :
3891 569 : switch (mode)
3892 : {
3893 : case PRINT_NORMAL :
3894 : case PRINT_RETURN :
3895 : {
3896 70 : isConst = false ;
3897 70 : str << "char*" ;
3898 : break ;
3899 : }
3900 : case PRINT_IN :
3901 : {
3902 320 : isConst = true ;
3903 320 : str << "const char*" ;
3904 : break ;
3905 : }
3906 : case PRINT_OUT :
3907 : case PRINT_INOUT :
3908 : {
3909 9 : isConst = false ;
3910 9 : str << "char*&" ;
3911 : break ;
3912 : }
3913 : case PRINT_VAR :
3914 : {
3915 170 : isConst = false ;
3916 170 : str << "CORBA::String_var" ;
3917 : break ;
3918 : }
3919 : case PRINT_PTR :
3920 : {
3921 0 : isConst = false ;
3922 0 : str << "CORBA::String_ptr" ;
3923 : break ;
3924 : }
3925 : }
3926 : }
3927 :
3928 : void LangCpp::PrintWStringType(
3929 : ostream& str,
3930 : printMode mode,
3931 : bool& isConst,
3932 : bool& isPointer,
3933 0 : bool& isVar)
3934 : {
3935 0 : isPointer = false ; // CDR prototype accept WChar*
3936 0 : isVar = true ; // use WString_var for .in() .inout() .out() and ._retn()
3937 :
3938 0 : switch (mode)
3939 : {
3940 : case PRINT_NORMAL :
3941 : case PRINT_RETURN :
3942 : {
3943 0 : isConst = false ;
3944 0 : str << "CORBA::WChar*" ;
3945 : break ;
3946 : }
3947 : case PRINT_IN :
3948 : {
3949 0 : isConst = true ;
3950 0 : str << "const CORBA::WChar*" ;
3951 : break ;
3952 : }
3953 : case PRINT_OUT :
3954 : case PRINT_INOUT :
3955 : {
3956 0 : isConst = false ;
3957 0 : str << "CORBA::WChar*&" ;
3958 : break ;
3959 : }
3960 : case PRINT_VAR :
3961 : {
3962 0 : isConst = false ;
3963 0 : str << "CORBA::WString_var" ;
3964 : break ;
3965 : }
3966 : case PRINT_PTR :
3967 : {
3968 0 : isConst = false ;
3969 0 : str << "CORBA::WString_ptr" ;
3970 : break ;
3971 : }
3972 : }
3973 : }
3974 :
3975 : void LangCpp::PrintEnumType(
3976 : ostream& str,
3977 : IDLEnumType* type,
3978 : printMode mode,
3979 : bool& isConst,
3980 : bool& isPointer,
3981 179 : bool& isVar)
3982 : {
3983 179 : Enum* e = type->GetSymbol() ;
3984 179 : CppInfo *info = GetCppInfo(e) ;
3985 :
3986 179 : isConst = false ;
3987 179 : isPointer = false ;
3988 :
3989 179 : str << info->_cppFullName ;
3990 :
3991 179 : if ( (mode == PRINT_OUT)
3992 : || (mode == PRINT_INOUT))
3993 : {
3994 0 : str << "&" ;
3995 : }
3996 : }
3997 :
3998 : void LangCpp::PrintTypedefType(
3999 : ostream& str,
4000 : IDLTypedefType* type,
4001 : printMode mode,
4002 : bool& isConst,
4003 : bool& isPointer,
4004 1012 : bool& isVar)
4005 : {
4006 1012 : Typedef *symbol = type->GetSymbol() ;
4007 1012 : CppInfo *info = GetCppInfo(symbol) ;
4008 :
4009 1012 : IDLType* t = symbol->GetType() ;
4010 :
4011 1012 : if (t->isA() == idl_sequence)
4012 : {
4013 : // For IDL sequence, the typedef name is the C++ type.
4014 444 : switch (mode)
4015 : {
4016 : case PRINT_NORMAL :
4017 : {
4018 6 : isConst = false ;
4019 6 : isPointer = false ;
4020 6 : str << info->_cppFullName ;
4021 : break ;
4022 : }
4023 : case PRINT_IN :
4024 : {
4025 190 : isConst = true ;
4026 190 : isPointer = false ;
4027 190 : str << "const " << info->_cppFullName << "&" ;
4028 : break ;
4029 : }
4030 : case PRINT_OUT :
4031 : {
4032 63 : isConst = false ;
4033 63 : isPointer = true ;
4034 63 : str << info->_cppFullName << "*&" ;
4035 : break ;
4036 : }
4037 : case PRINT_INOUT :
4038 : {
4039 0 : isConst = false ;
4040 0 : isPointer = false ;
4041 0 : str << info->_cppFullName << "&" ;
4042 : break ;
4043 : }
4044 : case PRINT_RETURN :
4045 : {
4046 81 : isConst = false ;
4047 81 : isPointer = true ;
4048 81 : str << info->_cppFullName << "*" ;
4049 : break ;
4050 : }
4051 : case PRINT_PTR :
4052 : {
4053 0 : isConst = false ;
4054 0 : isPointer = false ;
4055 0 : str << info->_cppFullName << "_ptr" ;
4056 : break ;
4057 : }
4058 : case PRINT_VAR :
4059 : {
4060 104 : isConst = false ;
4061 104 : isPointer = false ;
4062 104 : str << info->_cppFullName << "_var" ;
4063 : break ;
4064 : }
4065 : }
4066 : }
4067 : else
4068 : {
4069 : // For other IDL types, the C++ type resolves to the aliased type.
4070 568 : PrintType(str, t, mode, isConst, isPointer, isVar) ;
4071 : }
4072 : }
4073 :
4074 : void LangCpp::PrintSequenceType(
4075 : ostream& str,
4076 : IDLSequenceType* type,
4077 : printMode mode,
4078 : bool& isConst,
4079 : bool& isPointer,
4080 48 : bool& isVar)
4081 : {
4082 : bool dummy1, dummy2, dummy3 ;
4083 :
4084 48 : IDLType *elem = type->GetType() ;
4085 48 : bool bounded = type->IsBounded() ;
4086 :
4087 48 : isConst = false ;
4088 48 : isPointer = false ;
4089 :
4090 : const char* name = NULL ;
4091 : const char* bname = NULL ;
4092 :
4093 : // Primitive types have dedicated sequences.
4094 :
4095 48 : switch (elem->isA())
4096 : {
4097 : case idl_boolType:
4098 : {
4099 : name = "CORBABooleanSeq" ;
4100 : bname = "CORBABooleanBSeq" ;
4101 0 : break ;
4102 : }
4103 : case idl_charType:
4104 : {
4105 : name = "CORBACharSeq" ;
4106 : bname = "CORBACharBSeq" ;
4107 0 : break ;
4108 : }
4109 : case idl_wcharType:
4110 : {
4111 : name = "CORBAWCharSeq" ;
4112 : bname = "CORBAWCharBSeq" ;
4113 0 : break ;
4114 : }
4115 : case idl_intType:
4116 : {
4117 : IDLIntType *elem2 = (IDLIntType*) elem ;
4118 :
4119 0 : switch(elem2->GetType())
4120 : {
4121 : case idl_signed_short:
4122 : {
4123 : name = "CORBAShortSeq" ;
4124 : bname = "CORBAShortBSeq" ;
4125 0 : break ;
4126 : }
4127 : case idl_signed_long:
4128 : {
4129 : name = "CORBALongSeq" ;
4130 : bname = "CORBALongBSeq" ;
4131 0 : break ;
4132 : }
4133 : case idl_signed_long_long:
4134 : {
4135 : name = "CORBALongLongSeq" ;
4136 : bname = "CORBALongLongBSeq" ;
4137 0 : break ;
4138 : }
4139 : case idl_unsigned_short:
4140 : {
4141 : name = "CORBAUShortSeq" ;
4142 : bname = "CORBAUShortBSeq" ;
4143 0 : break ;
4144 : }
4145 : case idl_unsigned_long:
4146 : {
4147 : name = "CORBAULongSeq" ;
4148 : bname = "CORBAULongBSeq" ;
4149 0 : break ;
4150 : }
4151 : case idl_unsigned_long_long:
4152 : {
4153 : name = "CORBAULongLongSeq" ;
4154 : bname = "CORBAULongLongBSeq" ;
4155 : break ;
4156 : }
4157 : }
4158 : break ;
4159 : }
4160 : case idl_floatType:
4161 : {
4162 : IDLFloatType *elem2 = (IDLFloatType*) elem ;
4163 :
4164 0 : switch(elem2->GetType())
4165 : {
4166 : case idl_float:
4167 : {
4168 : name = "CORBAFloatSeq" ;
4169 : bname = "CORBAFloatBSeq" ;
4170 0 : break ;
4171 : }
4172 : case idl_double:
4173 : {
4174 : name = "CORBADoubleSeq" ;
4175 : bname = "CORBADoubleBSeq" ;
4176 0 : break ;
4177 : }
4178 : case idl_long_double:
4179 : {
4180 : name = "CORBALongDoubleSeq" ;
4181 : bname = "CORBALongDoubleBSeq" ;
4182 : break ;
4183 : }
4184 : }
4185 : break ;
4186 : }
4187 : case idl_octet:
4188 : {
4189 : name = "CORBAOctetSeq" ;
4190 : bname = "CORBAOctetBSeq" ;
4191 : break ;
4192 : }
4193 : default:
4194 : {
4195 : break ;
4196 : }
4197 : }
4198 :
4199 48 : if (bounded)
4200 : {
4201 0 : if (bname)
4202 : {
4203 0 : NON_DEV("bounded sequences for raw types") ;
4204 : }
4205 : else
4206 : {
4207 0 : str << "CORBABSequence<" ;
4208 0 : PrintType(str, elem, PRINT_VAR, dummy1, dummy2, dummy3) ;
4209 0 : str << ", " << type->GetMaxSize() << ">" ;
4210 : }
4211 : }
4212 : else
4213 : {
4214 48 : if (name != NULL)
4215 : {
4216 2 : str << name ;
4217 : }
4218 : else
4219 : {
4220 46 : str << "CORBASequence<" ;
4221 46 : PrintType(str, elem, PRINT_VAR, dummy1, dummy2, dummy3) ;
4222 46 : str << ">" ;
4223 : }
4224 : }
4225 : }
4226 :
4227 : void LangCpp::PrintAnyType(
4228 : ostream& str,
4229 : printMode mode,
4230 : bool& isConst,
4231 : bool& isPointer,
4232 518 : bool& isVar)
4233 : {
4234 518 : isVar = true ;
4235 :
4236 518 : switch(mode)
4237 : {
4238 : case PRINT_NORMAL:
4239 : {
4240 130 : isConst = false ;
4241 130 : isPointer = false ;
4242 130 : str << "CORBA::Any" ;
4243 : break ;
4244 : }
4245 : case PRINT_IN:
4246 : {
4247 296 : isConst = true ;
4248 296 : isPointer = false ;
4249 296 : str << "const CORBA::Any&" ;
4250 : break ;
4251 : }
4252 : case PRINT_OUT:
4253 : {
4254 66 : isConst = false ;
4255 66 : isPointer = true ;
4256 66 : str << "CORBA::Any*&" ;
4257 : break ;
4258 : }
4259 : case PRINT_INOUT:
4260 : {
4261 0 : isConst = false ;
4262 0 : isPointer = false ;
4263 0 : str << "CORBA::Any&";
4264 : break ;
4265 : }
4266 : case PRINT_RETURN:
4267 : {
4268 21 : isConst = false ;
4269 21 : isPointer = true ;
4270 21 : str << "CORBA::Any*" ;
4271 : break ;
4272 : }
4273 : case PRINT_VAR:
4274 : {
4275 5 : isConst = false ;
4276 5 : isPointer = false ;
4277 5 : str << "CORBA::Any_var" ;
4278 : break ;
4279 : }
4280 : case PRINT_PTR:
4281 : {
4282 0 : isConst = false ;
4283 0 : isPointer = false ;
4284 0 : str << "CORBA::Any_ptr" ;
4285 : break ;
4286 : }
4287 : }
4288 : }
4289 :
4290 : void LangCpp::PrintObjectType(
4291 : ostream& str,
4292 : printMode mode,
4293 : bool& isConst,
4294 : bool& isPointer,
4295 97 : bool& isVar)
4296 : {
4297 : // FIXME, certainly wrong
4298 :
4299 97 : isVar = true ;
4300 :
4301 97 : switch(mode)
4302 : {
4303 : case PRINT_NORMAL:
4304 : {
4305 2 : isConst = false ;
4306 2 : isPointer = true ;
4307 2 : str << "CORBA::Object_ptr" ;
4308 : break ;
4309 : }
4310 : case PRINT_IN:
4311 : {
4312 44 : isConst = true ;
4313 44 : isPointer = false ;
4314 44 : str << "const CORBA::Object_ptr" ;
4315 : break ;
4316 : }
4317 : case PRINT_OUT:
4318 : {
4319 0 : isConst = false ;
4320 0 : isPointer = true ;
4321 0 : str << "CORBA::Object_ptr&" ;
4322 : break ;
4323 : }
4324 : case PRINT_INOUT:
4325 : {
4326 0 : isConst = false ;
4327 0 : isPointer = true ;
4328 0 : str << "CORBA::Object_ptr&";
4329 : break ;
4330 : }
4331 : case PRINT_RETURN:
4332 : {
4333 30 : isConst = false ;
4334 30 : isPointer = true ;
4335 30 : str << "CORBA::Object_ptr" ;
4336 : break ;
4337 : }
4338 : case PRINT_VAR:
4339 : {
4340 21 : isConst = false ;
4341 21 : isPointer = false ;
4342 21 : str << "CORBA::Object_var" ;
4343 : break ;
4344 : }
4345 : case PRINT_PTR:
4346 : {
4347 0 : isConst = false ;
4348 0 : isPointer = true ;
4349 0 : str << "CORBA::Object_ptr" ;
4350 : break ;
4351 : }
4352 : }
4353 : }
4354 :
4355 : void LangCpp::PrintOctetType(
4356 : ostream& str,
4357 : printMode mode,
4358 : bool& isConst,
4359 : bool& isPointer,
4360 0 : bool& isVar)
4361 : {
4362 0 : isConst = false ;
4363 0 : isPointer = false ;
4364 0 : isVar = false ;
4365 :
4366 0 : str << "CORBA::Octet" ;
4367 :
4368 0 : if ( (mode == PRINT_OUT)
4369 : || (mode == PRINT_INOUT))
4370 : {
4371 0 : str << "&" ;
4372 : }
4373 : }
4374 :
4375 : void LangCpp::PrintBoolType(
4376 : ostream& str,
4377 : printMode mode,
4378 : bool& isConst,
4379 : bool& isPointer,
4380 872 : bool& isVar)
4381 : {
4382 872 : isConst = false ;
4383 872 : isPointer = false ;
4384 872 : isVar = false ;
4385 :
4386 872 : str << "CORBA::Boolean" ;
4387 :
4388 872 : if ( (mode == PRINT_OUT)
4389 : || (mode == PRINT_INOUT))
4390 : {
4391 15 : str << "&" ;
4392 : }
4393 : }
4394 :
4395 : void LangCpp::PrintCharType(
4396 : ostream& str,
4397 : printMode mode,
4398 : bool& isConst,
4399 : bool& isPointer,
4400 0 : bool& isVar)
4401 : {
4402 0 : isConst = false ;
4403 0 : isPointer = false ;
4404 0 : isVar = false ;
4405 :
4406 0 : str << "CORBA::Char" ;
4407 :
4408 0 : if ( (mode == PRINT_OUT)
4409 : || (mode == PRINT_INOUT))
4410 : {
4411 0 : str << "&" ;
4412 : }
4413 : }
4414 :
4415 : void LangCpp::PrintWCharType(
4416 : ostream& str,
4417 : printMode mode,
4418 : bool& isConst,
4419 : bool& isPointer,
4420 0 : bool& isVar)
4421 : {
4422 0 : isConst = false ;
4423 0 : isPointer = false ;
4424 0 : isVar = false ;
4425 :
4426 0 : str << "CORBA::WChar" ;
4427 :
4428 0 : if ( (mode == PRINT_OUT)
4429 : || (mode == PRINT_INOUT))
4430 : {
4431 0 : str << "&" ;
4432 : }
4433 : }
4434 :
4435 : void LangCpp::PrintInterfaceType(
4436 : ostream& str,
4437 : IDLInterfaceType* type,
4438 : printMode mode,
4439 : bool& isConst,
4440 : bool& isPointer,
4441 1527 : bool& isVar)
4442 : {
4443 1527 : Symbol *symbol = type->GetSymbol() ;
4444 1527 : CppInfo *info = GetCppInfo(symbol) ;
4445 :
4446 1527 : isConst = false ;
4447 1527 : isPointer = false ;
4448 :
4449 1527 : str << info->_cppFullName ;
4450 :
4451 1527 : switch(mode)
4452 : {
4453 : case PRINT_NORMAL:
4454 : case PRINT_IN:
4455 : case PRINT_PTR:
4456 : case PRINT_RETURN:
4457 : {
4458 1282 : str << "_ptr" ;
4459 : break ;
4460 : }
4461 : case PRINT_OUT:
4462 : case PRINT_INOUT:
4463 : {
4464 24 : str << "_ptr&" ;
4465 : break ;
4466 : }
4467 : case PRINT_VAR:
4468 : {
4469 221 : str << "_var" ;
4470 : break ;
4471 : }
4472 : }
4473 : }
4474 :
4475 : void LangCpp::PrintStructType(
4476 : ostream& str,
4477 : IDLStructType *type,
4478 : printMode mode,
4479 : bool& isConst,
4480 : bool& isPointer,
4481 144 : bool& isVar)
4482 : {
4483 144 : Struct *symbol = type->GetSymbol() ;
4484 144 : CppInfo *info = GetCppInfo(symbol) ;
4485 :
4486 : // GenerateStructDecl should have set info
4487 : ASSERT(info != NULL) ;
4488 :
4489 144 : switch(mode)
4490 : {
4491 : case PRINT_NORMAL :
4492 : {
4493 15 : isConst = false ;
4494 15 : isPointer = false ;
4495 15 : isVar = false ;
4496 15 : str << info->_cppFullName ;
4497 : break ;
4498 : }
4499 : case PRINT_IN :
4500 : {
4501 33 : isConst = true ;
4502 33 : isPointer = false ;
4503 33 : isVar = false ;
4504 33 : str << "const " << info->_cppFullName << "&" ;
4505 : break ;
4506 : }
4507 : case PRINT_OUT :
4508 : {
4509 24 : if (info->_hasFixedLengthStorage == true)
4510 : {
4511 6 : isConst = false ;
4512 6 : isPointer = false ;
4513 6 : isVar = false ;
4514 6 : str << info->_cppFullName << "&" ;
4515 : }
4516 : else
4517 : {
4518 18 : isConst = false ;
4519 18 : isPointer = true ;
4520 18 : isVar = false ;
4521 18 : str << info->_cppFullName << "*&" ;
4522 : }
4523 : break ;
4524 : }
4525 : case PRINT_INOUT :
4526 : {
4527 0 : isConst = false ;
4528 0 : isPointer = false ;
4529 0 : isVar = false ;
4530 0 : str << info->_cppFullName << "&" ;
4531 : break ;
4532 : }
4533 : case PRINT_RETURN :
4534 : {
4535 22 : if (info->_hasFixedLengthStorage == true)
4536 : {
4537 10 : isConst = false ;
4538 10 : isPointer = false ;
4539 10 : isVar = false ;
4540 10 : str << info->_cppFullName ;
4541 : }
4542 : else
4543 : {
4544 12 : isConst = false ;
4545 12 : isPointer = true ;
4546 12 : isVar = false ;
4547 12 : str << info->_cppFullName << "*" ;
4548 : }
4549 : break ;
4550 : }
4551 : case PRINT_PTR :
4552 : {
4553 0 : isConst = false ;
4554 0 : isPointer = false ;
4555 0 : isVar = false ;
4556 0 : str << info->_cppFullName << "_ptr" ;
4557 : break ;
4558 : }
4559 : case PRINT_VAR :
4560 : {
4561 50 : isConst = false ;
4562 50 : isPointer = false ;
4563 50 : isVar = true ;
4564 50 : str << info->_cppFullName << "_var" ;
4565 : break ;
4566 : }
4567 : }
4568 : }
4569 :
4570 : void LangCpp::PrintValue(
4571 : ostream& str,
4572 13 : IDLValue *value)
4573 : {
4574 13 : switch(value->isA())
4575 : {
4576 : case idl_errorType:
4577 : {
4578 0 : str << "FIXME idl_errorType" ;
4579 : break ;
4580 : }
4581 : case idl_intType:
4582 : {
4583 : IDLIntValue *v = (IDLIntValue*) value ;
4584 13 : PrintIntValue(str, v) ;
4585 : break ;
4586 : }
4587 : case idl_floatType:
4588 : {
4589 0 : str << "FIXME idl_floatType" ;
4590 : break ;
4591 : }
4592 : case idl_charType:
4593 : {
4594 : IDLCharValue *v = (IDLCharValue*) value ;
4595 0 : PrintCharValue(str, v) ;
4596 : break ;
4597 : }
4598 : case idl_wcharType:
4599 : {
4600 : IDLWCharValue *v = (IDLWCharValue*) value ;
4601 0 : PrintWCharValue(str, v) ;
4602 : break ;
4603 : }
4604 : case idl_boolType:
4605 : {
4606 0 : str << "FIXME idl_boolType" ;
4607 : break ;
4608 : }
4609 : case idl_struct:
4610 : {
4611 0 : str << "FIXME idl_struct" ;
4612 : break ;
4613 : }
4614 : case idl_enum:
4615 : {
4616 0 : str << "FIXME idl_enum" ;
4617 : break ;
4618 : }
4619 : case idl_typedef:
4620 : {
4621 0 : str << "FIXME idl_typedef" ;
4622 : break ;
4623 : }
4624 : case idl_array:
4625 : {
4626 0 : str << "FIXME idl_array" ;
4627 : break ;
4628 : }
4629 : case idl_sequence:
4630 : {
4631 0 : str << "FIXME idl_sequence" ;
4632 : break ;
4633 : }
4634 : case idl_string:
4635 : {
4636 : IDLStringValue *v = (IDLStringValue*) value ;
4637 0 : PrintStringValue(str, v) ;
4638 : break ;
4639 : }
4640 : case idl_wstring:
4641 : {
4642 : IDLWStringValue *v = (IDLWStringValue*) value ;
4643 0 : PrintWStringValue(str, v) ;
4644 : break ;
4645 : }
4646 : case idl_any:
4647 : {
4648 0 : str << "FIXME idl_any" ;
4649 : break ;
4650 : }
4651 : case idl_octet:
4652 : {
4653 0 : str << "FIXME idl_octet" ;
4654 : break ;
4655 : }
4656 : case idl_interface:
4657 : {
4658 0 : str << "FIXME idl_interface" ;
4659 : break ;
4660 : }
4661 : case idl_object:
4662 : {
4663 0 : str << "FIXME idl_object" ;
4664 : break ;
4665 : }
4666 : case idl_void:
4667 : {
4668 0 : str << "FIXME idl_void" ;
4669 : break ;
4670 : }
4671 : case idl_native:
4672 : {
4673 0 : str << "FIXME idl_native" ;
4674 : break ;
4675 : }
4676 : }
4677 : }
4678 :
4679 : void LangCpp::PrintCharValue(
4680 : ostream& str,
4681 0 : IDLCharValue *value)
4682 : {
4683 0 : char c = value->GetChar() ;
4684 :
4685 0 : str << '\'' ;
4686 0 : PrintNiceChar(c, str) ;
4687 0 : str << '\'' ;
4688 : }
4689 :
4690 : void LangCpp::PrintWCharValue(
4691 : ostream& str,
4692 0 : IDLWCharValue *value)
4693 : {
4694 0 : wchar_t wc = value->GetWChar() ;
4695 : char buf[10] ;
4696 0 : sprintf (buf, "L'\\x%x'", wc) ;
4697 0 : str << buf ;
4698 : }
4699 :
4700 : void LangCpp::PrintStringValue(
4701 : ostream& str,
4702 0 : IDLStringValue *value)
4703 : {
4704 0 : const String& str1 = value->GetString() ;
4705 0 : const char* str2 = str1 ;
4706 :
4707 0 : str << '\"' ;
4708 0 : while (*str2 != '\0')
4709 : {
4710 0 : PrintNiceChar(*str2, str) ;
4711 : str2 ++ ;
4712 : }
4713 0 : str << '\"' ;
4714 : }
4715 :
4716 : void LangCpp::PrintWStringValue(
4717 : ostream& str,
4718 0 : IDLWStringValue *value)
4719 : {
4720 0 : str << "L\"" << value->GetWString() << "\"" ;
4721 : }
4722 :
4723 : void LangCpp::PrintIntValue(
4724 : ostream& str,
4725 13 : IDLIntValue *value)
4726 : {
4727 13 : switch(value->GetType())
4728 : {
4729 : case idl_signed_short:
4730 : {
4731 6 : str << value->GetS16() ;
4732 : break ;
4733 : }
4734 : case idl_signed_long:
4735 : {
4736 0 : str << value->GetS32() << "L" ;
4737 : break ;
4738 : }
4739 : case idl_signed_long_long:
4740 : {
4741 0 : str << value->GetS64() << "L" ;
4742 : break ;
4743 : }
4744 : case idl_unsigned_short:
4745 : {
4746 0 : str << value->GetU16() ;
4747 : break ;
4748 : }
4749 : case idl_unsigned_long:
4750 : {
4751 14 : str << value->GetU32() << "L" ;
4752 : break ;
4753 : }
4754 : case idl_unsigned_long_long:
4755 : {
4756 0 : str << value->GetU64() << "L" ;
4757 : break ;
4758 : }
4759 : }
4760 : }
4761 :
4762 1085 : bool LangCpp::IsTypeFixedLength(IDLType* type)
4763 : {
4764 1085 : switch(type->isA())
4765 : {
4766 : case idl_errorType :
4767 : { // not real C++ code, generation will abort
4768 : return true ;
4769 : }
4770 : case idl_intType :
4771 : {
4772 : return true ;
4773 : }
4774 : case idl_floatType :
4775 : {
4776 : return true ;
4777 : }
4778 : case idl_charType :
4779 : {
4780 : return true ;
4781 : }
4782 : case idl_wcharType :
4783 : {
4784 : return true ;
4785 : }
4786 : case idl_boolType :
4787 : {
4788 : return true ;
4789 : }
4790 : case idl_struct :
4791 : {
4792 : IDLStructType *t = (IDLStructType*) type ;
4793 31 : Struct *symbol = t->GetSymbol() ;
4794 31 : CppInfo *info = GetCppInfo(symbol) ;
4795 31 : return info->_hasFixedLengthStorage ;
4796 : }
4797 : case idl_enum :
4798 : {
4799 : return true ;
4800 : }
4801 : case idl_typedef :
4802 : {
4803 : IDLTypedefType *t = (IDLTypedefType*) type ;
4804 273 : Typedef *symbol = t->GetSymbol() ;
4805 273 : IDLType *t2 = symbol->GetType() ;
4806 273 : return IsTypeFixedLength(t2) ;
4807 : }
4808 : case idl_array :
4809 : {
4810 0 : NON_DEV("IsTypeFixedLength") ;
4811 0 : return true ;
4812 : }
4813 : case idl_sequence :
4814 : {
4815 : return false ;
4816 : }
4817 : case idl_string :
4818 : {
4819 : return false ;
4820 : }
4821 : case idl_wstring :
4822 : {
4823 : return false ;
4824 : }
4825 : case idl_any :
4826 : {
4827 : return true ;
4828 : }
4829 : case idl_octet :
4830 : {
4831 : return true ;
4832 : }
4833 : case idl_object :
4834 : {
4835 : return false ;
4836 : }
4837 : case idl_interface :
4838 : {
4839 : return false ;
4840 : }
4841 : case idl_void :
4842 : {
4843 : return true ;
4844 : }
4845 : case idl_native :
4846 : {
4847 0 : NON_DEV("idl_native fixed length ?") ;
4848 : return false ;
4849 : }
4850 : }
4851 :
4852 : return true ;
4853 : }
4854 :
4855 2 : void LangCpp::GenerateNativeDecl(SymNative *native)
4856 : {
4857 2 : const String& name = native->GetFullyQualifiedName() ;
4858 :
4859 2 : if (name == "PortableServer::Servant")
4860 : {
4861 : // PortableServer::Servant
4862 : // REFERENCE : OMG 99-07-15, section 1.36.1, page 1-128
4863 :
4864 1 : _H.Str() << endl ;
4865 1 : _H.Str() << "// ============================== BEGIN of Servant generation" ;
4866 1 : _H.Str() << endl ;
4867 1 : _H.Str() << "// See OMG Document 99-07-15, section 1.36.1, page 1-128." << endl ;
4868 1 : _H.Str() << endl ;
4869 1 : _H.Tab() << "class ServantBase" << endl ;
4870 1 : _H.Tab() << "{" << endl ;
4871 1 : _H.Tab() << " public :" << endl ;
4872 1 : _H.Tab() << " virtual ~ServantBase() ;" << endl ;
4873 1 : _H.Str() << endl ;
4874 1 : _H.Tab() << " virtual POA_ptr _default_POA() ;" << endl ;
4875 1 : _H.Str() << endl ;
4876 1 : _H.Tab() << " virtual CORBA::InterfaceDef_ptr" << endl ;
4877 1 : _H.Tab() << " _get_interface()" << endl ;
4878 1 : _H.Tab() << " throw(CORBA::SystemException) ;" << endl ;
4879 1 : _H.Str() << endl ;
4880 1 : _H.Tab() << " virtual CORBA::Boolean" << endl ;
4881 1 : _H.Tab() << " _is_a(const char* logical_type_id)" << endl ;
4882 1 : _H.Tab() << " throw(CORBA::SystemException) ;" << endl ;
4883 1 : _H.Str() << endl ;
4884 1 : _H.Tab() << " virtual CORBA::Boolean" << endl ;
4885 1 : _H.Tab() << " _non_existent()" << endl ;
4886 1 : _H.Tab() << " throw(CORBA::SystemException) ;" << endl ;
4887 1 : _H.Str() << endl ;
4888 1 : _H.Tab() << " virtual void _add_ref() ;" << endl ;
4889 1 : _H.Tab() << " virtual void _remove_ref() ;" << endl ;
4890 1 : _H.Str() << endl ;
4891 1 : _H.Tab() << " protected :" << endl ;
4892 1 : _H.Tab() << " ServantBase() ;" << endl ;
4893 1 : _H.Tab() << " ServantBase(const ServantBase&) ;" << endl ;
4894 1 : _H.Tab() << " ServantBase& operator=(const ServantBase&) ;" << endl ;
4895 1 : _H.Tab() << "} ;" << endl ;
4896 1 : _H.Tab() << "typedef ServantBase* Servant ;" << endl ;
4897 1 : _H.Str() << "// ============================== END of Servant generation" ;
4898 1 : _H.Str() << endl << endl ;
4899 :
4900 : return ;
4901 : }
4902 :
4903 1 : if (name == "PortableServer::ServantLocator::Cookie")
4904 : {
4905 : // PortableServer::ServantLocator::Cookie map to void* in C++
4906 : // REFERENCE : OMG 99-07-15, section 10.4.1, page 1-146.
4907 0 : return ;
4908 : }
4909 :
4910 0 : String error = "Don't know how to generate native " ;
4911 0 : error += native->GetName() ;
4912 0 : error += "." ;
4913 :
4914 0 : IDLCompileError(error) ;
4915 :
4916 33 : }
4917 33 :
|
