1 : //==============================================================================
2 : // File <$/src/cpp/dev/idlc/back/lang_java/javainfo.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 : #include <stdlib.h>
28 :
29 : #include "src/cpp/dev/idlc/back/lang_java/javainfo.h"
30 : #include "src/cpp/dev/idlc/symbol.h"
31 : #include "src/cpp/prod/tool/Assert.h"
32 : #include "src/cpp/prod/tool/StringTokenizer.h"
33 :
34 : #include "src/cpp/prod/tool/DEVELOPMENT.h"
35 :
36 : struct JavaKeyWords
37 0 : {
38 : const char* keyword ;
39 : String escape ;
40 : } ;
41 :
42 33 : static const JavaKeyWords KeyWordTab[] =
43 : {
44 : { "abstract" , "_abstract" },
45 : { "boolean" , "_boolean" },
46 : { "break" , "_break" },
47 : { "byte" , "_byte" },
48 : { "case" , "_case" },
49 : { "catch" , "_catch" },
50 : { "char" , "_char" },
51 : { "class" , "_class" },
52 : { "clone" , "_clone" },
53 : { "const" , "_const" },
54 : { "continue" , "_continue" },
55 : { "default" , "_default" },
56 : { "do" , "_do" },
57 : { "double" , "_double" },
58 : { "else" , "_else" },
59 : { "equals" , "_equals" },
60 : { "extends" , "_extends" },
61 : { "false" , "_false" },
62 : { "final" , "_final" },
63 : { "finalize" , "_finalize" },
64 : { "finally" , "_finally" },
65 : { "float" , "_float" },
66 : { "for" , "_for" },
67 : { "getClass" , "_getClass" },
68 : { "goto" , "_goto" },
69 : { "hashCode" , "_hashCode" },
70 : { "if" , "_if" },
71 : { "implements" , "_implements" },
72 : { "import" , "_import" },
73 : { "instanceof" , "_instanceof" },
74 : { "int" , "_int" },
75 : { "interface" , "_interface" },
76 : { "long" , "_long" },
77 : { "native" , "_native" },
78 : { "new" , "_new" },
79 : { "notify" , "_notify" },
80 : { "notifyAll" , "_notifyAll" },
81 : { "null" , "_null" },
82 : { "package" , "_package" },
83 : { "private" , "_private" },
84 : { "protected" , "_protected" },
85 : { "public" , "_public" },
86 : { "return" , "_return" },
87 : { "short" , "_short" },
88 : { "static" , "_static" },
89 : { "super" , "_super" },
90 : { "switch" , "_switch" },
91 : { "synchronized" , "_synchronized" },
92 : { "this" , "_this" },
93 : { "throw" , "_throw" },
94 : { "throws" , "_throws" },
95 : { "toString" , "_toString" },
96 : { "transient" , "_transient" },
97 : { "true" , "_true" },
98 : { "try" , "_try" },
99 : { "void" , "_void" },
100 : { "volatile" , "_volatile" },
101 : { "wait" , "_wait" },
102 : { "while" , "_while" },
103 : { NULL , "" }
104 33 : } ;
105 :
106 : static const char * const SuffixTab[] =
107 : {
108 : "Helper",
109 : "Holder",
110 : NULL
111 : } ;
112 :
113 : static const char* const PseudoTab[] =
114 : {
115 : "PortableServer::POAManager",
116 : "PortableServer::AdapterActivator",
117 : "PortableServer::ServantManager",
118 : "PortableServer::ServantActivator",
119 : "PortableServer::ServantLocator",
120 : "PortableServer::POA",
121 : "PortableServer::Current",
122 : "CORBA::TypeCode",
123 : "CORBA::Environment",
124 : "CORBA::ORB",
125 : NULL
126 : } ;
127 :
128 197 : static String JavaName(const String& idlName)
129 : {
130 : const JavaKeyWords *entry ;
131 :
132 : entry = & KeyWordTab[0] ;
133 :
134 11820 : while (entry->keyword != NULL)
135 : {
136 11623 : if (idlName == entry->keyword)
137 : {
138 0 : return entry->escape ;
139 : }
140 :
141 11623 : entry ++ ;
142 : }
143 :
144 : const char * const * suffixEntry = & SuffixTab[0] ;
145 : const char * suffix = NULL ;
146 197 : int idlLen = idlName.length() ;
147 : const char * hackPtr = NULL ;
148 : int suffixLen = 0 ;
149 :
150 591 : while (* suffixEntry != NULL)
151 : {
152 : suffix = * suffixEntry ;
153 394 : suffixLen = strlen(suffix) ;
154 :
155 : // Does idl name **ends** with suffix ?
156 :
157 394 : if (suffixLen <= idlLen)
158 : {
159 374 : hackPtr = idlName ;
160 : hackPtr = hackPtr + idlLen - suffixLen ;
161 374 : if (strcmp(hackPtr, suffix) == 0)
162 : {
163 : // Yes, escape the idl name
164 0 : String escape = "_" ;
165 0 : escape += idlName ;
166 0 : return escape ;
167 : }
168 : }
169 :
170 : suffixEntry ++ ;
171 : }
172 :
173 197 : return idlName ;
174 : }
175 :
176 65 : static bool IsPseudo(const String& name)
177 : {
178 : const char * const *entry ;
179 :
180 : entry = & PseudoTab[0] ;
181 :
182 666 : while (*entry != NULL)
183 : {
184 608 : if (name == *entry)
185 : {
186 : return true ;
187 : }
188 :
189 : entry ++ ;
190 : }
191 :
192 : return false ;
193 : }
194 :
195 65 : static String PackageName(const String& javaFullName)
196 : {
197 : // Extract a.b.c from a.b.c.z ;
198 :
199 65 : char *tmp = strdup(javaFullName) ;
200 65 : char *dot = strrchr(tmp, '.') ;
201 :
202 65 : if (dot != NULL)
203 : {
204 64 : *dot = '\0' ;
205 : }
206 :
207 65 : String package = tmp ;
208 65 : free(tmp) ;
209 :
210 : return package ;
211 : }
212 :
213 130 : static String HelperName(const String& javaFullName)
214 : {
215 : // Convert a.b.c to a.b.cHelper ;
216 :
217 130 : String helper = javaFullName ;
218 130 : helper += "Helper" ;
219 0 : return helper ;
220 : }
221 :
222 130 : static String HolderName(const String& javaFullName)
223 : {
224 : // Convert a.b.c to a.b.cHolder ;
225 :
226 130 : String holder = javaFullName ;
227 130 : holder += "Holder" ;
228 0 : return holder ;
229 : }
230 :
231 65 : static String JavaFullName(const String& idlFullName)
232 : {
233 : // Convert try::this::stuff into _try._this.stuff
234 :
235 65 : String result ;
236 65 : String token ;
237 65 : StringTokenizer parser(idlFullName, "::") ;
238 : bool first = true ;
239 :
240 197 : while (parser.hasMoreTokens() == true)
241 : {
242 132 : if (first == false)
243 : {
244 67 : result += "." ;
245 : }
246 :
247 132 : token = parser.nextToken() ;
248 132 : result += JavaName(token) ;
249 : first = false ;
250 : }
251 :
252 0 : return result ;
253 : }
254 :
255 325 : static String FileFullName(const String& javaFullName)
256 : {
257 : // Convert _try._this.stuff into _try/_this/stuff
258 :
259 325 : String result ;
260 325 : String token ;
261 325 : StringTokenizer parser(javaFullName, ".") ;
262 : bool first = true ;
263 :
264 1493 : while (parser.hasMoreTokens() == true)
265 : {
266 1168 : if (first == false)
267 : {
268 844 : result += "/" ;
269 : }
270 :
271 1168 : token = parser.nextToken() ;
272 1168 : result += token ;
273 : first = false ;
274 : }
275 :
276 0 : return result ;
277 : }
278 :
279 65 : String ReversePrefix(const String & prefix)
280 : {
281 65 : String result ;
282 65 : String token ;
283 65 : String tmp ;
284 65 : StringTokenizer parser(prefix, ".") ;
285 : bool first = true ;
286 :
287 193 : while (parser.hasMoreTokens() == true)
288 : {
289 128 : token = parser.nextToken() ;
290 :
291 128 : if (first == true)
292 : {
293 64 : result = token ;
294 : first = false ;
295 : }
296 : else
297 : {
298 64 : tmp = token ;
299 64 : tmp += "." ;
300 64 : tmp += result ;
301 64 : result = tmp ;
302 : }
303 : }
304 :
305 0 : return result ;
306 : }
307 :
308 : void PrePend(
309 : const String & pre,
310 : const String & sep,
311 65 : String & str)
312 : {
313 65 : String result ;
314 :
315 65 : if (pre != "")
316 : {
317 64 : result += pre ;
318 64 : result += sep ;
319 : }
320 :
321 65 : result += str ;
322 65 : str = result ;
323 : }
324 :
325 2 : JavaInfo::JavaInfo()
326 : {
327 2 : _isPseudo = false ;
328 2 : }
329 :
330 65 : JavaInfo::JavaInfo(Symbol *sym)
331 : {
332 65 : const String& name = sym->GetName() ;
333 :
334 65 : _javaName = JavaName(name) ;
335 65 : _javaHelperName = HelperName(_javaName) ;
336 65 : _javaHolderName = HolderName(_javaName) ;
337 :
338 65 : const String& fullName = sym->GetFullyQualifiedName() ;
339 65 : const String& prefix = sym->GetPrefix() ;
340 65 : String rPrefix = ReversePrefix(prefix) ;
341 65 : String fPrefix = FileFullName(rPrefix) ;
342 :
343 65 : if (IsPseudo(fullName))
344 : {
345 7 : _isPseudo = true ;
346 : }
347 :
348 65 : _javaFullName = JavaFullName(fullName) ;
349 65 : PrePend(rPrefix, ".", _javaFullName) ;
350 65 : _javaFullHelperName = HelperName(_javaFullName) ;
351 65 : _javaFullHolderName = HolderName(_javaFullName) ;
352 :
353 65 : _javaPackageName = PackageName(_javaFullName) ;
354 :
355 65 : _dirName = FileFullName(_javaFullName) ;
356 65 : _dirName += "/" ;
357 :
358 65 : _fileFullName = FileFullName(_javaFullName) ;
359 65 : _fileFullName += ".java" ;
360 :
361 65 : _fileFullHelperName = FileFullName(_javaFullHelperName) ;
362 65 : _fileFullHelperName += ".java" ;
363 :
364 65 : _fileFullHolderName = FileFullName(_javaFullHolderName) ;
365 65 : _fileFullHolderName += ".java" ;
366 0 : }
367 :
368 2 : JavaInfo::~JavaInfo()
369 35 : {}
370 33 :
|
