1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_codemaker.hxx"
26 #include "sal/config.h"
27
28 #include "codemaker/commoncpp.hxx"
29
30 #include "codemaker/options.hxx"
31 #include "codemaker/typemanager.hxx"
32 #include "codemaker/unotype.hxx"
33
34 #include "osl/diagnose.h"
35 #include "registry/reader.hxx"
36 #include "registry/types.h"
37 #include "rtl/strbuf.hxx"
38 #include "rtl/string.hxx"
39 #include "rtl/ustring.hxx"
40 #include "sal/types.h"
41
42 #include <vector>
43
44 namespace codemaker { namespace cpp {
45
typeToPrefix(TypeManager const & manager,rtl::OString const & type)46 rtl::OString typeToPrefix(TypeManager const & manager, rtl::OString const & type)
47 {
48 RTTypeClass typeclass = manager.getTypeClass(type);
49 if (typeclass == RT_TYPE_INVALID ||
50 typeclass == RT_TYPE_PUBLISHED)
51 return rtl::OString("_");
52
53 static char const * const typeclassPrefix[RT_TYPE_UNION + 1] = {
54 "invalid", /* RT_TYPE_INVALID, is here only as placeholder */
55 "interface", /* RT_TYPE_INTERFACE */
56 "module", /* RT_TYPE_MODULE */
57 "struct", /* RT_TYPE_STRUCT */
58 "enum", /* RT_TYPE_ENUM */
59 "exception", /* RT_TYPE_EXCEPTION */
60 "typedef", /* RT_TYPE_TYPEDEF */
61 "service", /* RT_TYPE_SERVICE */
62 "singleton", /* RT_TYPE_SINGLETON */
63 "object", /* RT_TYPE_OBJECT */
64 "constants", /* RT_TYPE_CONSTANTS */
65 "union" /* RT_TYPE_UNION */
66 };
67
68 return rtl::OString(typeclassPrefix[typeclass]);
69 }
70
scopedCppName(rtl::OString const & type,bool bNoNameSpace,bool shortname)71 rtl::OString scopedCppName(rtl::OString const & type, bool bNoNameSpace,
72 bool shortname)
73 {
74 char c('/');
75 sal_Int32 nPos = type.lastIndexOf( c );
76 if (nPos == -1) {
77 nPos = type.lastIndexOf( '.' );
78 if (nPos == -1)
79 return type;
80
81 c = '.';
82 }
83 if (bNoNameSpace)
84 return type.copy(nPos+1);
85
86 rtl::OStringBuffer tmpBuf(type.getLength()*2);
87 nPos = 0;
88 do
89 {
90 tmpBuf.append("::");
91 tmpBuf.append(type.getToken(0, c, nPos));
92 } while( nPos != -1 );
93
94 if (shortname) {
95 rtl::OString s(tmpBuf.makeStringAndClear());
96 if (s.indexOf("::com::sun::star") == 0)
97 return s.replaceAt(0, 16, "css");
98 else
99 return s;
100 }
101
102 return tmpBuf.makeStringAndClear();
103 }
104
105
translateUnoToCppType(codemaker::UnoType::Sort sort,RTTypeClass typeClass,rtl::OString const & nucleus,bool shortname)106 rtl::OString translateUnoToCppType(
107 codemaker::UnoType::Sort sort, RTTypeClass typeClass,
108 rtl::OString const & nucleus, bool shortname)
109 {
110 rtl::OStringBuffer buf;
111 if (sort == codemaker::UnoType::SORT_COMPLEX) {
112 if (typeClass == RT_TYPE_INTERFACE
113 && nucleus == rtl::OString("com/sun/star/uno/XInterface"))
114 {
115 buf.append(RTL_CONSTASCII_STRINGPARAM("::com::sun::star::uno::XInterface"));
116 } else {
117 //TODO: check that nucleus is a valid (UTF-8) identifier
118 buf.append(nucleus);
119 }
120 } else {
121 static char const * const cppTypes[codemaker::UnoType::SORT_ANY + 1] = {
122 "void", "::sal_Bool", "::sal_Int8", "::sal_Int16", "::sal_uInt16",
123 "::sal_Int32", "::sal_uInt32", "::sal_Int64", "::sal_uInt64",
124 "float", "double", "::sal_Unicode", "::rtl::OUString",
125 "::com::sun::star::uno::Type", "::com::sun::star::uno::Any" };
126 buf.append(cppTypes[sort]);
127 }
128
129 if (shortname) {
130 rtl::OString s(buf.makeStringAndClear());
131 if (s.indexOf("::com::sun::star") == 0)
132 return s.replaceAt(0, 16, "css");
133 else
134 return s;
135 }
136
137 return buf.makeStringAndClear();
138 }
139
translateUnoToCppIdentifier(rtl::OString const & unoIdentifier,rtl::OString const & prefix,IdentifierTranslationMode transmode,rtl::OString const * forbidden)140 rtl::OString translateUnoToCppIdentifier(
141 rtl::OString const & unoIdentifier, rtl::OString const & prefix,
142 IdentifierTranslationMode transmode, rtl::OString const * forbidden)
143 {
144 if (// Keywords:
145 unoIdentifier == "asm"
146 || unoIdentifier == "auto"
147 || unoIdentifier == "bool"
148 || unoIdentifier == "break"
149 || unoIdentifier == "case"
150 || unoIdentifier == "catch"
151 || unoIdentifier == "char"
152 || unoIdentifier == "class"
153 || unoIdentifier == "const"
154 /* unoIdentifier == "const_cast" */
155 || unoIdentifier == "continue"
156 || unoIdentifier == "default"
157 || unoIdentifier == "delete"
158 || unoIdentifier == "do"
159 || unoIdentifier == "double"
160 /* unoIdentifier == "dynamic_cast" */
161 || unoIdentifier == "else"
162 || unoIdentifier == "enum"
163 || unoIdentifier == "explicit"
164 || unoIdentifier == "export"
165 || unoIdentifier == "extern"
166 || unoIdentifier == "false"
167 || unoIdentifier == "float"
168 || unoIdentifier == "for"
169 || unoIdentifier == "friend"
170 || unoIdentifier == "goto"
171 || unoIdentifier == "if"
172 || unoIdentifier == "inline"
173 || unoIdentifier == "int"
174 || unoIdentifier == "long"
175 || unoIdentifier == "mutable"
176 || unoIdentifier == "namespace"
177 || unoIdentifier == "new"
178 || unoIdentifier == "operator"
179 || unoIdentifier == "private"
180 || unoIdentifier == "protected"
181 || unoIdentifier == "public"
182 || unoIdentifier == "register"
183 /* unoIdentifier == "reinterpret_cast" */
184 || unoIdentifier == "return"
185 || unoIdentifier == "short"
186 || unoIdentifier == "signed"
187 || unoIdentifier == "sizeof"
188 || unoIdentifier == "static"
189 /* unoIdentifier == "static_cast" */
190 || unoIdentifier == "struct"
191 || unoIdentifier == "switch"
192 || unoIdentifier == "template"
193 || unoIdentifier == "this"
194 || unoIdentifier == "throw"
195 || unoIdentifier == "true"
196 || unoIdentifier == "try"
197 || unoIdentifier == "typedef"
198 || unoIdentifier == "typeid"
199 || unoIdentifier == "typename"
200 || unoIdentifier == "union"
201 || unoIdentifier == "unsigned"
202 || unoIdentifier == "using"
203 || unoIdentifier == "virtual"
204 || unoIdentifier == "void"
205 || unoIdentifier == "volatile"
206 /* unoIdentifier == "wchar_t" */
207 || unoIdentifier == "while"
208 // Alternative representations:
209 || unoIdentifier == "and"
210 /* unoIdentifier == "and_eq" */
211 || unoIdentifier == "bitand"
212 || unoIdentifier == "bitor"
213 || unoIdentifier == "compl"
214 || unoIdentifier == "not"
215 /* unoIdentifier == "not_eq" */
216 || unoIdentifier == "or"
217 /* unoIdentifier == "or_eq" */
218 || unoIdentifier == "xor"
219 /* unoIdentifier == "xor_eq" */
220 // Standard macros:
221 || (transmode != ITM_KEYWORDSONLY
222 && (unoIdentifier == "BUFSIZ"
223 || unoIdentifier == "CLOCKS_PER_SEC"
224 || unoIdentifier == "EDOM"
225 || unoIdentifier == "EOF"
226 || unoIdentifier == "ERANGE"
227 || unoIdentifier == "EXIT_FAILURE"
228 || unoIdentifier == "EXIT_SUCCESS"
229 || unoIdentifier == "FILENAME_MAX"
230 || unoIdentifier == "FOPEN_MAX"
231 || unoIdentifier == "HUGE_VAL"
232 || unoIdentifier == "LC_ALL"
233 || unoIdentifier == "LC_COLLATE"
234 || unoIdentifier == "LC_CTYPE"
235 || unoIdentifier == "LC_MONETARY"
236 || unoIdentifier == "LC_NUMERIC"
237 || unoIdentifier == "LC_TIME"
238 || unoIdentifier == "L_tmpnam"
239 || unoIdentifier == "MB_CUR_MAX"
240 || unoIdentifier == "NULL"
241 || unoIdentifier == "RAND_MAX"
242 || unoIdentifier == "SEEK_CUR"
243 || unoIdentifier == "SEEK_END"
244 || unoIdentifier == "SEEK_SET"
245 || unoIdentifier == "SIGABRT"
246 || unoIdentifier == "SIGFPE"
247 || unoIdentifier == "SIGILL"
248 || unoIdentifier == "SIGINT"
249 || unoIdentifier == "SIGSEGV"
250 || unoIdentifier == "SIGTERM"
251 || unoIdentifier == "SIG_DFL"
252 || unoIdentifier == "SIG_ERR"
253 || unoIdentifier == "SIG_IGN"
254 || unoIdentifier == "TMP_MAX"
255 || unoIdentifier == "WCHAR_MAX"
256 || unoIdentifier == "WCHAR_MIN"
257 || unoIdentifier == "WEOF"
258 /* unoIdentifier == "_IOFBF" */
259 /* unoIdentifier == "_IOLBF" */
260 /* unoIdentifier == "_IONBF" */
261 || unoIdentifier == "assert"
262 || unoIdentifier == "errno"
263 || unoIdentifier == "offsetof"
264 || unoIdentifier == "setjmp"
265 || unoIdentifier == "stderr"
266 || unoIdentifier == "stdin"
267 || unoIdentifier == "stdout"
268 /* unoIdentifier == "va_arg" */
269 /* unoIdentifier == "va_end" */
270 /* unoIdentifier == "va_start" */
271 // Standard values:
272 || unoIdentifier == "CHAR_BIT"
273 || unoIdentifier == "CHAR_MAX"
274 || unoIdentifier == "CHAR_MIN"
275 || unoIdentifier == "DBL_DIG"
276 || unoIdentifier == "DBL_EPSILON"
277 || unoIdentifier == "DBL_MANT_DIG"
278 || unoIdentifier == "DBL_MAX"
279 || unoIdentifier == "DBL_MAX_10_EXP"
280 || unoIdentifier == "DBL_MAX_EXP"
281 || unoIdentifier == "DBL_MIN"
282 || unoIdentifier == "DBL_MIN_10_EXP"
283 || unoIdentifier == "DBL_MIN_EXP"
284 || unoIdentifier == "FLT_DIG"
285 || unoIdentifier == "FLT_EPSILON"
286 || unoIdentifier == "FLT_MANT_DIG"
287 || unoIdentifier == "FLT_MAX"
288 || unoIdentifier == "FLT_MAX_10_EXP"
289 || unoIdentifier == "FLT_MAX_EXP"
290 || unoIdentifier == "FLT_MIN"
291 || unoIdentifier == "FLT_MIN_10_EXP"
292 || unoIdentifier == "FLT_MIN_EXP"
293 || unoIdentifier == "FLT_RADIX"
294 || unoIdentifier == "FLT_ROUNDS"
295 || unoIdentifier == "INT_MAX"
296 || unoIdentifier == "INT_MIN"
297 || unoIdentifier == "LDBL_DIG"
298 || unoIdentifier == "LDBL_EPSILON"
299 || unoIdentifier == "LDBL_MANT_DIG"
300 || unoIdentifier == "LDBL_MAX"
301 || unoIdentifier == "LDBL_MAX_10_EXP"
302 || unoIdentifier == "LDBL_MAX_EXP"
303 || unoIdentifier == "LDBL_MIN"
304 || unoIdentifier == "LDBL_MIN_10_EXP"
305 || unoIdentifier == "LDBL_MIN_EXP"
306 || unoIdentifier == "LONG_MAX"
307 || unoIdentifier == "LONG_MIN"
308 || unoIdentifier == "MB_LEN_MAX"
309 || unoIdentifier == "SCHAR_MAX"
310 || unoIdentifier == "SCHAR_MIN"
311 || unoIdentifier == "SHRT_MAX"
312 || unoIdentifier == "SHRT_MIN"
313 || unoIdentifier == "UCHAR_MAX"
314 || unoIdentifier == "UINT_MAX"
315 || unoIdentifier == "ULONG_MAX"
316 || unoIdentifier == "USHRT_MAX"))
317 || (transmode == ITM_GLOBAL
318 && (// Standard types:
319 /* unoIdentifier == "clock_t" */
320 /* unoIdentifier == "div_t" */
321 unoIdentifier == "FILE"
322 /* unoIdentifier == "fpos_t" */
323 /* unoIdentifier == "jmp_buf" */
324 || unoIdentifier == "lconv"
325 /* unoIdentifier == "ldiv_t" */
326 /* unoIdentifier == "mbstate_t" */
327 /* unoIdentifier == "ptrdiff_t" */
328 /* unoIdentifier == "sig_atomic_t" */
329 /* unoIdentifier == "size_t" */
330 /* unoIdentifier == "time_t" */
331 || unoIdentifier == "tm"
332 /* unoIdentifier == "va_list" */
333 /* unoIdentifier == "wctrans_t" */
334 /* unoIdentifier == "wctype_t" */
335 /* unoIdentifier == "wint_t" */
336 // Standard namespaces:
337 || unoIdentifier == "std"))
338 // Others:
339 || unoIdentifier == "NDEBUG"
340 || (forbidden != 0 && unoIdentifier == *forbidden) )
341 {
342 rtl::OStringBuffer buf(prefix);
343 buf.append('_');
344 buf.append(unoIdentifier);
345 return buf.makeStringAndClear();
346 } else {
347 return unoIdentifier;
348 }
349 }
350
351 } }
352