1 : //==============================================================================
2 : // File <$/src/cpp/dev/idlc/back/lang_cpp/info.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 <stdio.h>
27 :
28 : #include "src/cpp/dev/idlc/back/lang_cpp/info.h"
29 : #include "src/cpp/dev/idlc/symbol.h"
30 : #include "src/cpp/prod/tool/Assert.h"
31 : #include "src/cpp/prod/tool/StringTokenizer.h"
32 :
33 : struct CppKeyWords
34 0 : {
35 : const char* keyword ;
36 : String escape ;
37 : } ;
38 :
39 33 : static String _stubPattern = "%s_Stub" ;
40 33 : static String _skelPattern = "POA_%s" ;
41 33 : static String _implPattern = "%s_Impl" ;
42 :
43 33 : static const CppKeyWords KeyWordTab[] =
44 : {
45 : // Reference : OMG 99-07-45, section 1.43, page 1-166.
46 :
47 : { "and" , "_cxx_and" },
48 : { "and_eq" , "_cxx_and_eq" },
49 : { "asm" , "_cxx_asm" },
50 : { "auto" , "_cxx_auto" },
51 : { "bitand" , "_cxx_bitand" },
52 : { "bitor" , "_cxx_bitor" },
53 : { "bool" , "_cxx_bool" },
54 : { "break" , "_cxx_break" },
55 : { "case" , "_cxx_case" },
56 : { "catch" , "_cxx_catch" },
57 : { "char" , "_cxx_char" },
58 : { "class" , "_cxx_class" },
59 : { "compl" , "_cxx_compl" },
60 : { "const" , "_cxx_const" },
61 : { "const_cast" , "_cxx_const_cast" },
62 : { "continue" , "_cxx_continue" },
63 : { "default" , "_cxx_default" },
64 : { "delete" , "_cxx_delete" },
65 : { "do" , "_cxx_do" },
66 : { "double" , "_cxx_double" },
67 : { "dynamic_cast" , "_cxx_dynamic_cast" },
68 : { "else" , "_cxx_else" },
69 : { "enum" , "_cxx_enum" },
70 : { "explicit" , "_cxx_explicit" },
71 : { "export" , "_cxx_export" },
72 : { "extern" , "_cxx_extern" },
73 : { "false" , "_cxx_false" },
74 : { "float" , "_cxx_float" },
75 : { "for" , "_cxx_for" },
76 : { "friend" , "_cxx_friend" },
77 : { "goto" , "_cxx_goto" },
78 : { "if" , "_cxx_if" },
79 : { "inline" , "_cxx_inline" },
80 : { "int" , "_cxx_int" },
81 : { "long" , "_cxx_long" },
82 : { "mutable" , "_cxx_mutable" },
83 : { "namespace" , "_cxx_namespace" },
84 : { "new" , "_cxx_new" },
85 : { "not" , "_cxx_not" },
86 : { "not_eq" , "_cxx_not_eq" },
87 : { "operator" , "_cxx_operator" },
88 : { "or" , "_cxx_or" },
89 : { "or_eq" , "_cxx_or_eq" },
90 : { "private" , "_cxx_private" },
91 : { "protected" , "_cxx_protected" },
92 : { "public" , "_cxx_public" },
93 : { "register" , "_cxx_register" },
94 : { "reinterpret_cast", "_cxx_reinterpret_cast"},
95 : { "return" , "_cxx_return" },
96 : { "short" , "_cxx_short" },
97 : { "signed" , "_cxx_signed" },
98 : { "sizeof" , "_cxx_sizeof" },
99 : { "static" , "_cxx_static" },
100 : { "static_cast" , "_cxx_static_cast" },
101 : { "struct" , "_cxx_struct" },
102 : { "switch" , "_cxx_switch" },
103 : { "template" , "_cxx_template" },
104 : { "this" , "_cxx_this" },
105 : { "throw" , "_cxx_throw" },
106 : { "true" , "_cxx_true" },
107 : { "try" , "_cxx_try" },
108 : { "typedef" , "_cxx_typedef" },
109 : { "typeid" , "_cxx_typeid" },
110 : { "typename" , "_cxx_typename" },
111 : { "union" , "_cxx_union" },
112 : { "unsigned" , "_cxx_unsigned" },
113 : { "using" , "_cxx_using" },
114 : { "virtual" , "_cxx_virtual" },
115 : { "void" , "_cxx_void" },
116 : { "volatile" , "_cxx_volatile" },
117 : { "wchar_t" , "_cxx_wchar_t" },
118 : { "while" , "_cxx_while" },
119 : { "xor" , "_cxx_xor" },
120 : { "xor_eq" , "_cxx_xor_eq" },
121 : { NULL , "" }
122 33 : } ;
123 :
124 : static const char* const PseudoTab[] =
125 : {
126 : "PortableServer::POAManager",
127 : "PortableServer::AdapterActivator",
128 : "PortableServer::ServantManager",
129 : "PortableServer::ServantActivator",
130 : "PortableServer::ServantLocator",
131 : "PortableServer::POA",
132 : "PortableServer::Current",
133 : "CORBA::TypeCode",
134 : "CORBA::Environment",
135 : "CORBA::ORB",
136 : NULL
137 : } ;
138 :
139 : // Temporary sprintf operations.
140 : // FIXME : Overflow will crash.
141 : static const int SPRINTF_TMP_SIZE = 132 ;
142 :
143 5444 : static String CppName(const String& idlName)
144 : {
145 : const CppKeyWords *entry ;
146 :
147 : entry = & KeyWordTab[0] ;
148 :
149 408101 : while (entry->keyword != NULL)
150 : {
151 402661 : if (idlName == entry->keyword)
152 : {
153 4 : return entry->escape ;
154 : }
155 :
156 402657 : entry ++ ;
157 : }
158 :
159 5440 : return idlName ;
160 : }
161 :
162 2736 : static bool IsPseudo(const String& name)
163 : {
164 : const char * const *entry ;
165 :
166 : entry = & PseudoTab[0] ;
167 :
168 30033 : while (*entry != NULL)
169 : {
170 27310 : if (name == *entry)
171 : {
172 : return true ;
173 : }
174 :
175 : entry ++ ;
176 : }
177 :
178 : return false ;
179 : }
180 :
181 10428 : static String StubName(const String& cppName)
182 : {
183 : char buf[SPRINTF_TMP_SIZE] ;
184 10428 : const char* format = _stubPattern ;
185 10428 : const char* data = cppName ;
186 :
187 10428 : sprintf(buf, format, data) ;
188 :
189 10428 : return buf ;
190 : }
191 :
192 2708 : static String StubFullName(const String& fullName)
193 : {
194 : // Convert foo:bar::op into foo_Stub::bar_Stub::op_Stub
195 :
196 2708 : String result ;
197 2708 : String token ;
198 2708 : StringTokenizer parser(fullName, "::") ;
199 : bool first = true ;
200 :
201 10400 : while (parser.hasMoreTokens() == true)
202 : {
203 7692 : if (first == false)
204 : {
205 4984 : result += "::" ;
206 : }
207 :
208 7692 : token = parser.nextToken() ;
209 7692 : result += StubName(token) ;
210 : first = false ;
211 : }
212 :
213 0 : return result ;
214 : }
215 :
216 10428 : static String SkelName(const String& cppName)
217 : {
218 : char buf[SPRINTF_TMP_SIZE] ;
219 10428 : const char* format = _skelPattern ;
220 10428 : const char* data = cppName ;
221 :
222 10428 : sprintf(buf, format, data) ;
223 :
224 10428 : return buf ;
225 : }
226 :
227 2708 : static String SkelFullName(const String& fullName)
228 : {
229 : // Convert foo:bar::op into POA_foo::POA_bar::POA_op
230 :
231 2708 : String result ;
232 2708 : String token ;
233 2708 : StringTokenizer parser(fullName, "::") ;
234 : bool first = true ;
235 :
236 10400 : while (parser.hasMoreTokens() == true)
237 : {
238 7692 : if (first == false)
239 : {
240 4984 : result += "::" ;
241 : }
242 :
243 7692 : token = parser.nextToken() ;
244 7692 : result += SkelName(token) ;
245 : first = false ;
246 : }
247 :
248 0 : return result ;
249 : }
250 :
251 10428 : static String ImplName(const String& cppName)
252 : {
253 : char buf[SPRINTF_TMP_SIZE] ;
254 10428 : const char* format = _implPattern ;
255 10428 : const char* data = cppName ;
256 :
257 10428 : sprintf(buf, format, data) ;
258 :
259 10428 : return buf ;
260 : }
261 :
262 2708 : static String ImplFullName(const String& fullName)
263 : {
264 : // Convert foo:bar::op into foo_impl::bar_impl::op_impl
265 :
266 2708 : String result ;
267 2708 : String token ;
268 2708 : StringTokenizer parser(fullName, "::") ;
269 : bool first = true ;
270 :
271 10400 : while (parser.hasMoreTokens() == true)
272 : {
273 7692 : if (first == false)
274 : {
275 4984 : result += "::" ;
276 : }
277 :
278 7692 : token = parser.nextToken() ;
279 7692 : result += ImplName(token) ;
280 : first = false ;
281 : }
282 :
283 0 : return result ;
284 : }
285 :
286 28 : CppInfo::CppInfo(const String& name)
287 : :
288 : _isPseudo(false),
289 : _hasFixedLengthStorage(true),
290 : _hasPtrType(false),
291 : _hasVarType(false),
292 : _isConst(false),
293 : _isPointer(false),
294 : _isVar(false),
295 : _cppName(),
296 : _cppStubName(),
297 : _cppSkelName(),
298 : _cppImplName(),
299 : _cppFullName(),
300 : _cppStubFullName(),
301 : _cppSkelFullName(),
302 28 : _cppImplFullName()
303 : {
304 28 : if (IsPseudo(name))
305 : {
306 0 : _isPseudo = true ;
307 : }
308 :
309 28 : _cppName = CppName(name) ;
310 28 : _cppStubName = StubName(_cppName) ;
311 28 : _cppSkelName = SkelName(_cppName) ;
312 28 : _cppImplName = ImplName(_cppName) ;
313 28 : _cppFullName = _cppName ;
314 28 : _cppStubFullName = _cppStubName ;
315 28 : _cppSkelFullName = _cppSkelName ;
316 28 : _cppImplFullName = _cppImplName ;
317 0 : }
318 :
319 2708 : CppInfo::CppInfo(Symbol *sym)
320 : :
321 : _isPseudo(false),
322 : _hasFixedLengthStorage(true),
323 : _hasPtrType(false),
324 : _hasVarType(false),
325 : _isConst(false),
326 : _isPointer(false),
327 : _isVar(false),
328 : _cppName(),
329 : _cppStubName(),
330 : _cppSkelName(),
331 : _cppImplName(),
332 : _cppFullName(),
333 : _cppStubFullName(),
334 : _cppSkelFullName(),
335 2708 : _cppImplFullName()
336 : {
337 2708 : const String& name = sym->GetName() ;
338 2708 : _cppName = CppName(name) ;
339 2708 : _cppStubName = StubName(_cppName) ;
340 2708 : _cppSkelName = SkelName(_cppName) ;
341 2708 : _cppImplName = ImplName(_cppName) ;
342 :
343 2708 : const String& fullName = sym->GetFullyQualifiedName() ;
344 :
345 2708 : if (IsPseudo(fullName))
346 : {
347 13 : _isPseudo = true ;
348 : }
349 :
350 2708 : _cppFullName = CppName(fullName) ;
351 2708 : _cppStubFullName = StubFullName(_cppFullName) ;
352 2708 : _cppSkelFullName = SkelFullName(_cppFullName) ;
353 2708 : _cppImplFullName = ImplFullName(_cppFullName) ;
354 0 : }
355 :
356 28 : CppInfo::~CppInfo()
357 28 : {}
358 :
359 0 : void CppInfo::SetStubPattern(const String& pattern)
360 : {
361 0 : _stubPattern = pattern ;
362 : }
363 :
364 0 : void CppInfo::SetSkelPattern(const String& pattern)
365 : {
366 0 : _skelPattern = pattern ;
367 : }
368 :
369 0 : void CppInfo::SetImplPattern(const String& pattern)
370 : {
371 0 : _implPattern = pattern ;
372 33 : }
373 33 :
|
