|
1
|
1 /****************************************************************************
|
|
|
2 **
|
|
|
3 ** Copyright (C) 1992-2008 Nokia. All rights reserved.
|
|
|
4 **
|
|
|
5 ** This file is part of Qt Jambi.
|
|
|
6 **
|
|
|
7 ** * Commercial Usage
|
|
|
8 * Licensees holding valid Qt Commercial licenses may use this file in
|
|
|
9 * accordance with the Qt Commercial License Agreement provided with the
|
|
|
10 * Software or, alternatively, in accordance with the terms contained in
|
|
|
11 * a written agreement between you and Nokia.
|
|
|
12 *
|
|
|
13 *
|
|
|
14 * GNU General Public License Usage
|
|
|
15 * Alternatively, this file may be used under the terms of the GNU
|
|
|
16 * General Public License versions 2.0 or 3.0 as published by the Free
|
|
|
17 * Software Foundation and appearing in the file LICENSE.GPL included in
|
|
|
18 * the packaging of this file. Please review the following information
|
|
|
19 * to ensure GNU General Public Licensing requirements will be met:
|
|
|
20 * http://www.fsf.org/licensing/licenses/info/GPLv2.html and
|
|
|
21 * http://www.gnu.org/copyleft/gpl.html. In addition, as a special
|
|
|
22 * exception, Nokia gives you certain additional rights. These rights
|
|
|
23 * are described in the Nokia Qt GPL Exception version 1.2, included in
|
|
|
24 * the file GPL_EXCEPTION.txt in this package.
|
|
|
25 *
|
|
|
26 * Qt for Windows(R) Licensees
|
|
|
27 * As a special exception, Nokia, as the sole copyright holder for Qt
|
|
|
28 * Designer, grants users of the Qt/Eclipse Integration plug-in the
|
|
|
29 * right for the Qt/Eclipse Integration to link to functionality
|
|
|
30 * provided by Qt Designer and its related libraries.
|
|
|
31 *
|
|
|
32 *
|
|
|
33 * If you are unsure which license is appropriate for your use, please
|
|
|
34 * contact the sales department at qt-sales@nokia.com.
|
|
|
35
|
|
|
36 **
|
|
|
37 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
|
|
|
38 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
39 **
|
|
|
40 ****************************************************************************/
|
|
|
41
|
|
|
42 #ifndef TYPESYSTEM_H
|
|
|
43 #define TYPESYSTEM_H
|
|
|
44
|
|
|
45 #include <QtCore/QHash>
|
|
|
46 #include <QtCore/QString>
|
|
|
47 #include <QtCore/QStringList>
|
|
|
48 #include <QtCore/QMap>
|
|
|
49 #include <QDebug>
|
|
|
50
|
|
|
51 class Indentor;
|
|
|
52
|
|
|
53 class AbstractMetaType;
|
|
|
54 class QTextStream;
|
|
|
55
|
|
|
56 class EnumTypeEntry;
|
|
|
57 class FlagsTypeEntry;
|
|
|
58
|
|
|
59 extern QString strings_Object;
|
|
|
60 extern QString strings_String;
|
|
|
61 extern QString strings_Thread;
|
|
|
62 extern QString strings_char;
|
|
|
63 extern QString strings_java_lang;
|
|
|
64 extern QString strings_jchar;
|
|
|
65 extern QString strings_jobject;
|
|
|
66
|
|
|
67 struct Include
|
|
|
68 {
|
|
|
69 enum IncludeType {
|
|
|
70 IncludePath,
|
|
|
71 LocalPath,
|
|
|
72 TargetLangImport
|
|
|
73 };
|
|
|
74
|
|
|
75 Include() : type(IncludePath) { }
|
|
|
76 Include(IncludeType t, const QString &nam) : type(t), name(nam) { };
|
|
|
77
|
|
|
78 bool isValid() { return !name.isEmpty(); }
|
|
|
79
|
|
|
80 IncludeType type;
|
|
|
81 QString name;
|
|
|
82
|
|
|
83 QString toString() const;
|
|
|
84
|
|
|
85 bool operator<(const Include &other) const { return name < other.name; }
|
|
|
86 };
|
|
|
87 typedef QList<Include> IncludeList;
|
|
|
88
|
|
|
89 typedef QMap<int, QString> ArgumentMap;
|
|
|
90
|
|
|
91 class TemplateInstance;
|
|
|
92
|
|
|
93 namespace TypeSystem {
|
|
|
94 enum Language {
|
|
|
95 NoLanguage = 0x0000,
|
|
|
96 TargetLangCode = 0x0001,
|
|
|
97 NativeCode = 0x0002,
|
|
|
98 ShellCode = 0x0004,
|
|
|
99 ShellDeclaration = 0x0008,
|
|
|
100 PackageInitializer = 0x0010,
|
|
|
101 DestructorFunction = 0x0020,
|
|
|
102 Constructors = 0x0040,
|
|
|
103 Interface = 0x0080,
|
|
|
104
|
|
|
105 // masks
|
|
|
106 All = TargetLangCode
|
|
|
107 | NativeCode
|
|
|
108 | ShellCode
|
|
|
109 | ShellDeclaration
|
|
|
110 | PackageInitializer
|
|
|
111 | Constructors
|
|
|
112 | Interface
|
|
|
113 | DestructorFunction,
|
|
|
114
|
|
|
115 JavaAndNativeCode = TargetLangCode | NativeCode,
|
|
|
116 TargetLangAndNativeCode = TargetLangCode | NativeCode
|
|
|
117 };
|
|
|
118
|
|
|
119 enum Ownership {
|
|
|
120 InvalidOwnership,
|
|
|
121 DefaultOwnership,
|
|
|
122 TargetLangOwnership,
|
|
|
123 CppOwnership
|
|
|
124 };
|
|
|
125 };
|
|
|
126
|
|
|
127 struct ReferenceCount
|
|
|
128 {
|
|
|
129 ReferenceCount() : threadSafe(false), access(Public) { }
|
|
|
130 enum Action { // 0x01 - 0xff
|
|
|
131 Invalid = 0x00,
|
|
|
132 Add = 0x01,
|
|
|
133 AddAll = 0x02,
|
|
|
134 Remove = 0x04,
|
|
|
135 Set = 0x08,
|
|
|
136 Ignore = 0x10,
|
|
|
137
|
|
|
138 ActionsMask = 0xff,
|
|
|
139
|
|
|
140 Padding = 0xffffffff
|
|
|
141 };
|
|
|
142
|
|
|
143 enum Flag { // 0x100 - 0xf00
|
|
|
144 ThreadSafe = 0x100,
|
|
|
145 Static = 0x200,
|
|
|
146 DeclareVariable = 0x400,
|
|
|
147
|
|
|
148 FlagsMask = 0xf00
|
|
|
149 };
|
|
|
150
|
|
|
151 enum Access { // 0x1000 - 0xf000
|
|
|
152 Private = 0x1000,
|
|
|
153 Protected = 0x2000,
|
|
|
154 Friendly = 0x3000,
|
|
|
155 Public = 0x4000,
|
|
|
156
|
|
|
157 AccessMask = 0xf000
|
|
|
158 };
|
|
|
159
|
|
|
160 Action action;
|
|
|
161 QString variableName;
|
|
|
162 QString conditional;
|
|
|
163 QString declareVariable;
|
|
|
164
|
|
|
165 uint threadSafe : 1;
|
|
|
166
|
|
|
167 uint access;
|
|
|
168 };
|
|
|
169
|
|
|
170 class CodeSnipFragment{
|
|
|
171 private:
|
|
|
172 const QString m_code;
|
|
|
173 TemplateInstance *m_instance;
|
|
|
174
|
|
|
175 public:
|
|
|
176 CodeSnipFragment(const QString &code)
|
|
|
177 : m_code(code),
|
|
|
178 m_instance(0)
|
|
|
179 {}
|
|
|
180
|
|
|
181 CodeSnipFragment(TemplateInstance *instance)
|
|
|
182 : m_instance(instance)
|
|
|
183 {}
|
|
|
184
|
|
|
185 QString code() const;
|
|
|
186 };
|
|
|
187
|
|
|
188 class CodeSnipAbstract{
|
|
|
189 public:
|
|
|
190 QString code() const;
|
|
|
191
|
|
|
192 void addCode(const QString &code){
|
|
|
193 codeList.append(new CodeSnipFragment(code));
|
|
|
194 }
|
|
|
195
|
|
|
196 void addTemplateInstance(TemplateInstance *ti){
|
|
|
197 codeList.append(new CodeSnipFragment(ti));
|
|
|
198 }
|
|
|
199
|
|
|
200 QList<CodeSnipFragment*> codeList;
|
|
|
201 };
|
|
|
202
|
|
|
203 class CustomFunction : public CodeSnipAbstract
|
|
|
204 {
|
|
|
205 public:
|
|
|
206 CustomFunction(const QString &n = QString()) : name(n) { }
|
|
|
207
|
|
|
208 QString name;
|
|
|
209 QString param_name;
|
|
|
210 };
|
|
|
211
|
|
|
212 class TemplateEntry : public CodeSnipAbstract
|
|
|
213 {
|
|
|
214 public:
|
|
|
215 TemplateEntry(const QString &name)
|
|
|
216 : m_name(name)
|
|
|
217 {
|
|
|
218 };
|
|
|
219
|
|
|
220 QString name() const {
|
|
|
221 return m_name;
|
|
|
222 };
|
|
|
223
|
|
|
224 private:
|
|
|
225 QString m_name;
|
|
|
226 };
|
|
|
227
|
|
|
228 typedef QHash<QString, TemplateEntry *> TemplateEntryHash;
|
|
|
229
|
|
|
230 class TemplateInstance
|
|
|
231 {
|
|
|
232 public:
|
|
|
233 TemplateInstance(const QString &name)
|
|
|
234 : m_name(name)
|
|
|
235 {}
|
|
|
236
|
|
|
237 void addReplaceRule(const QString &name, const QString &value){
|
|
|
238 replaceRules[name]=value;
|
|
|
239 }
|
|
|
240
|
|
|
241 QString expandCode() const;
|
|
|
242
|
|
|
243 QString name() const {
|
|
|
244 return m_name;
|
|
|
245 }
|
|
|
246
|
|
|
247 private:
|
|
|
248 const QString m_name;
|
|
|
249 QHash<QString, QString> replaceRules;
|
|
|
250 };
|
|
|
251
|
|
|
252
|
|
|
253 class CodeSnip : public CodeSnipAbstract
|
|
|
254 {
|
|
|
255 public:
|
|
|
256 enum Position {
|
|
|
257 Beginning,
|
|
|
258 End,
|
|
|
259 AfterThis
|
|
|
260 };
|
|
|
261
|
|
|
262 CodeSnip() : language(TypeSystem::TargetLangCode) { }
|
|
|
263 CodeSnip(TypeSystem::Language lang) : language(lang) { }
|
|
|
264
|
|
|
265 // Very simple, easy to make code ugly if you try
|
|
|
266 QTextStream &formattedCode(QTextStream &s, Indentor &indentor) const;
|
|
|
267
|
|
|
268 TypeSystem::Language language;
|
|
|
269 Position position;
|
|
|
270 ArgumentMap argumentMap;
|
|
|
271 };
|
|
|
272 typedef QList<CodeSnip> CodeSnipList;
|
|
|
273
|
|
|
274 struct ArgumentModification
|
|
|
275 {
|
|
|
276 ArgumentModification(int idx) : removed_default_expression(false), removed(false), no_null_pointers(false), index(idx)
|
|
|
277 {}
|
|
|
278
|
|
|
279 // Should the default expression be removed?
|
|
|
280 uint removed_default_expression : 1;
|
|
|
281 uint removed : 1;
|
|
|
282 uint no_null_pointers : 1;
|
|
|
283 uint reset_after_use : 1;
|
|
|
284
|
|
|
285 // The index of this argument
|
|
|
286 int index;
|
|
|
287
|
|
|
288 // Reference count flags for this argument
|
|
|
289 QList<ReferenceCount> referenceCounts;
|
|
|
290
|
|
|
291 // The text given for the new type of the argument
|
|
|
292 QString modified_type;
|
|
|
293
|
|
|
294 QString replace_value;
|
|
|
295
|
|
|
296 // The code to be used to construct a return value when no_null_pointers is true and
|
|
|
297 // the returned value is null. If no_null_pointers is true and this string is
|
|
|
298 // empty, then the base class implementation will be used (or a default construction
|
|
|
299 // if there is no implementation)
|
|
|
300 QString null_pointer_default_value;
|
|
|
301
|
|
|
302 // The text of the new default expression of the argument
|
|
|
303 QString replaced_default_expression;
|
|
|
304
|
|
|
305 // The new definition of ownership for a specific argument
|
|
|
306 QHash<TypeSystem::Language, TypeSystem::Ownership> ownerships;
|
|
|
307
|
|
|
308 // Different conversion rules
|
|
|
309 CodeSnipList conversion_rules;
|
|
|
310 };
|
|
|
311
|
|
|
312 struct Modification {
|
|
|
313 enum Modifiers {
|
|
|
314 Private = 0x0001,
|
|
|
315 Protected = 0x0002,
|
|
|
316 Public = 0x0003,
|
|
|
317 Friendly = 0x0004,
|
|
|
318 AccessModifierMask = 0x000f,
|
|
|
319
|
|
|
320 Final = 0x0010,
|
|
|
321 NonFinal = 0x0020,
|
|
|
322 FinalMask = Final | NonFinal,
|
|
|
323
|
|
|
324 Readable = 0x0100,
|
|
|
325 Writable = 0x0200,
|
|
|
326
|
|
|
327 CodeInjection = 0x1000,
|
|
|
328 Rename = 0x2000,
|
|
|
329 Deprecated = 0x4000,
|
|
|
330 ReplaceExpression = 0x8000,
|
|
|
331 VirtualSlot = 0x10000 | NonFinal
|
|
|
332 };
|
|
|
333
|
|
|
334 Modification() : modifiers(0) { }
|
|
|
335
|
|
|
336 bool isAccessModifier() const { return modifiers & AccessModifierMask; }
|
|
|
337 Modifiers accessModifier() const { return Modifiers(modifiers & AccessModifierMask); }
|
|
|
338 bool isPrivate() const { return accessModifier() == Private; }
|
|
|
339 bool isProtected() const { return accessModifier() == Protected; }
|
|
|
340 bool isPublic() const { return accessModifier() == Public; }
|
|
|
341 bool isFriendly() const { return accessModifier() == Friendly; }
|
|
|
342 bool isFinal() const { return modifiers & Final; }
|
|
|
343 bool isNonFinal() const { return modifiers & NonFinal; }
|
|
|
344 bool isVirtualSlot() const { return (modifiers & VirtualSlot) == VirtualSlot; }
|
|
|
345 QString accessModifierString() const;
|
|
|
346
|
|
|
347 bool isDeprecated() const { return modifiers & Deprecated; }
|
|
|
348
|
|
|
349 void setRenamedTo(const QString &name) { renamedToName = name; }
|
|
|
350 QString renamedTo() const { return renamedToName; }
|
|
|
351 bool isRenameModifier() const { return modifiers & Rename; }
|
|
|
352
|
|
|
353 uint modifiers;
|
|
|
354 QString renamedToName;
|
|
|
355 };
|
|
|
356
|
|
|
357 struct FunctionModification: public Modification
|
|
|
358 {
|
|
|
359 FunctionModification() : removal(TypeSystem::NoLanguage), store_result(false) { }
|
|
|
360
|
|
|
361 bool isCodeInjection() const { return modifiers & CodeInjection; }
|
|
|
362 bool isRemoveModifier() const { return removal != TypeSystem::NoLanguage; }
|
|
|
363
|
|
|
364 QString toString() const;
|
|
|
365
|
|
|
366 QString signature;
|
|
|
367 QString association;
|
|
|
368 CodeSnipList snips;
|
|
|
369 TypeSystem::Language removal;
|
|
|
370 bool store_result;
|
|
|
371
|
|
|
372 QList<ArgumentModification> argument_mods;
|
|
|
373 };
|
|
|
374 typedef QList<FunctionModification> FunctionModificationList;
|
|
|
375
|
|
|
376 struct FieldModification: public Modification
|
|
|
377 {
|
|
|
378 bool isReadable() const { return modifiers & Readable; }
|
|
|
379 bool isWritable() const { return modifiers & Writable; }
|
|
|
380
|
|
|
381 QString name;
|
|
|
382 };
|
|
|
383 typedef QList<FieldModification> FieldModificationList;
|
|
|
384
|
|
|
385 struct ExpensePolicy {
|
|
|
386 ExpensePolicy() : limit(-1) { }
|
|
|
387 int limit;
|
|
|
388 QString cost;
|
|
|
389 bool isValid() const { return limit >= 0; }
|
|
|
390 };
|
|
|
391
|
|
|
392 class InterfaceTypeEntry;
|
|
|
393 class ObjectTypeEntry;
|
|
|
394
|
|
|
395 class TypeEntry
|
|
|
396 {
|
|
|
397 public:
|
|
|
398 enum Type {
|
|
|
399 PrimitiveType,
|
|
|
400 VoidType,
|
|
|
401 FlagsType,
|
|
|
402 EnumType,
|
|
|
403 TemplateArgumentType,
|
|
|
404 ThreadType,
|
|
|
405 BasicValueType,
|
|
|
406 StringType,
|
|
|
407 ContainerType,
|
|
|
408 InterfaceType,
|
|
|
409 ObjectType,
|
|
|
410 NamespaceType,
|
|
|
411 VariantType,
|
|
|
412 JObjectWrapperType,
|
|
|
413 CharType,
|
|
|
414 ArrayType,
|
|
|
415 TypeSystemType,
|
|
|
416 CustomType,
|
|
|
417 };
|
|
|
418
|
|
|
419 enum CodeGeneration {
|
|
|
420 GenerateTargetLang = 0x0001,
|
|
|
421 GenerateCpp = 0x0002,
|
|
|
422 GenerateForSubclass = 0x0004,
|
|
|
423
|
|
|
424 GenerateNothing = 0,
|
|
|
425 GenerateAll = 0xffff,
|
|
|
426 GenerateCode = GenerateTargetLang | GenerateCpp
|
|
|
427 };
|
|
|
428
|
|
|
429 TypeEntry(const QString &name, Type t)
|
|
|
430 : m_name(name),
|
|
|
431 m_type(t),
|
|
|
432 m_code_generation(GenerateAll),
|
|
|
433 m_preferred_conversion(true)
|
|
|
434 {
|
|
|
435 };
|
|
|
436
|
|
|
437 virtual ~TypeEntry() { }
|
|
|
438
|
|
|
439 Type type() const { return m_type; }
|
|
|
440 bool isPrimitive() const { return m_type == PrimitiveType; }
|
|
|
441 bool isEnum() const { return m_type == EnumType; }
|
|
|
442 bool isFlags() const { return m_type == FlagsType; }
|
|
|
443 bool isInterface() const { return m_type == InterfaceType; }
|
|
|
444 bool isObject() const { return m_type == ObjectType; }
|
|
|
445 bool isString() const { return m_type == StringType; }
|
|
|
446 bool isChar() const { return m_type == CharType; }
|
|
|
447 bool isNamespace() const { return m_type == NamespaceType; }
|
|
|
448 bool isContainer() const { return m_type == ContainerType; }
|
|
|
449 bool isVariant() const { return m_type == VariantType; }
|
|
|
450 bool isJObjectWrapper() const { return m_type == JObjectWrapperType; }
|
|
|
451 bool isArray() const { return m_type == ArrayType; }
|
|
|
452 bool isTemplateArgument() const { return m_type == TemplateArgumentType; }
|
|
|
453 bool isVoid() const { return m_type == VoidType; }
|
|
|
454 bool isThread() const { return m_type == ThreadType; }
|
|
|
455 bool isCustom() const { return m_type == CustomType; }
|
|
|
456 bool isBasicValue() const { return m_type == BasicValueType; }
|
|
|
457 bool isTypeSystem() const { return m_type == TypeSystemType; }
|
|
|
458
|
|
|
459 virtual bool preferredConversion() const { return m_preferred_conversion; }
|
|
|
460 virtual void setPreferredConversion(bool b) { m_preferred_conversion = b; }
|
|
|
461
|
|
|
462 virtual QString javaQualifier() const { return QString(); }
|
|
|
463
|
|
|
464 // The type's name in C++, fully qualified
|
|
|
465 QString name() const { return m_name; }
|
|
|
466
|
|
|
467 uint codeGeneration() const { return m_code_generation; }
|
|
|
468 void setCodeGeneration(uint cg) { m_code_generation = cg; }
|
|
|
469
|
|
|
470 virtual QString qualifiedCppName() const { return m_name; }
|
|
|
471
|
|
|
472 // Its type's name in JNI
|
|
|
473 virtual QString jniName() const { return m_name; }
|
|
|
474
|
|
|
475 // The type's name in TargetLang
|
|
|
476 virtual QString targetLangName() const { return m_name; }
|
|
|
477
|
|
|
478 // The type to lookup when converting to TargetLang
|
|
|
479 virtual QString lookupName() const { return targetLangName(); }
|
|
|
480
|
|
|
481 // The package
|
|
|
482 virtual QString javaPackage() const { return QString(); }
|
|
|
483
|
|
|
484 virtual QString qualifiedTargetLangName() const {
|
|
|
485 // QString pkg = javaPackage();
|
|
|
486 /* if (pkg.isEmpty())*/ return targetLangName();
|
|
|
487 // return pkg + '.' + targetLangName();
|
|
|
488 }
|
|
|
489
|
|
|
490 virtual InterfaceTypeEntry *designatedInterface() const { return 0; }
|
|
|
491
|
|
|
492 void setCustomConstructor(const CustomFunction &func) { m_customConstructor = func; }
|
|
|
493 CustomFunction customConstructor() const { return m_customConstructor; }
|
|
|
494
|
|
|
495 void setCustomDestructor(const CustomFunction &func) { m_customDestructor = func; }
|
|
|
496 CustomFunction customDestructor() const { return m_customDestructor; }
|
|
|
497
|
|
|
498 virtual bool isValue() const { return false; }
|
|
|
499 virtual bool isComplex() const { return false; }
|
|
|
500
|
|
|
501 virtual bool isNativeIdBased() const { return false; }
|
|
|
502
|
|
|
503 // qtd
|
|
|
504 virtual bool isStructInD() const { return false; }
|
|
|
505
|
|
|
506 private:
|
|
|
507 QString m_name;
|
|
|
508 Type m_type;
|
|
|
509 uint m_code_generation;
|
|
|
510 CustomFunction m_customConstructor;
|
|
|
511 CustomFunction m_customDestructor;
|
|
|
512 bool m_preferred_conversion;
|
|
|
513 };
|
|
|
514 typedef QHash<QString, QList<TypeEntry *> > TypeEntryHash;
|
|
|
515 typedef QHash<QString, TypeEntry *> SingleTypeEntryHash;
|
|
|
516
|
|
|
517
|
|
|
518 class TypeSystemTypeEntry : public TypeEntry
|
|
|
519 {
|
|
|
520 public:
|
|
|
521 TypeSystemTypeEntry(const QString &name)
|
|
|
522 : TypeEntry(name, TypeSystemType)
|
|
|
523 {
|
|
|
524 };
|
|
|
525
|
|
|
526 QList<CodeSnip> snips;
|
|
|
527 };
|
|
|
528
|
|
|
529
|
|
|
530 class ThreadTypeEntry : public TypeEntry
|
|
|
531 {
|
|
|
532 public:
|
|
|
533 ThreadTypeEntry() : TypeEntry("QThread", ThreadType) { setCodeGeneration(GenerateNothing); }
|
|
|
534
|
|
|
535 QString jniName() const { return strings_jobject; }
|
|
|
536 QString targetLangName() const { return strings_Thread; }
|
|
|
537 QString javaPackage() const { return strings_java_lang; }
|
|
|
538 };
|
|
|
539
|
|
|
540 class VoidTypeEntry : public TypeEntry
|
|
|
541 {
|
|
|
542 public:
|
|
|
543 VoidTypeEntry() : TypeEntry("void", VoidType) { }
|
|
|
544 };
|
|
|
545
|
|
|
546 class TemplateArgumentEntry : public TypeEntry
|
|
|
547 {
|
|
|
548 public:
|
|
|
549 TemplateArgumentEntry(const QString &name)
|
|
|
550 : TypeEntry(name, TemplateArgumentType), m_ordinal(0)
|
|
|
551 {
|
|
|
552 }
|
|
|
553
|
|
|
554 int ordinal() const { return m_ordinal; }
|
|
|
555 void setOrdinal(int o) { m_ordinal = o; }
|
|
|
556
|
|
|
557 private:
|
|
|
558 int m_ordinal;
|
|
|
559 };
|
|
|
560
|
|
|
561 class ArrayTypeEntry : public TypeEntry
|
|
|
562 {
|
|
|
563 public:
|
|
|
564 ArrayTypeEntry(const TypeEntry *nested_type) : TypeEntry("Array", ArrayType), m_nested_type(nested_type)
|
|
|
565 {
|
|
|
566 Q_ASSERT(m_nested_type);
|
|
|
567 }
|
|
|
568
|
|
|
569 void setNestedTypeEntry(TypeEntry *nested) { m_nested_type = nested; }
|
|
|
570 const TypeEntry *nestedTypeEntry() const { return m_nested_type; }
|
|
|
571
|
|
|
572 QString targetLangName() const { return m_nested_type->targetLangName() + "[]"; }
|
|
|
573 QString jniName() const
|
|
|
574 {
|
|
|
575 if (m_nested_type->isPrimitive())
|
|
|
576 return m_nested_type->jniName() + "Array";
|
|
|
577 else
|
|
|
578 return "jobjectArray";
|
|
|
579 }
|
|
|
580
|
|
|
581 private:
|
|
|
582 const TypeEntry *m_nested_type;
|
|
|
583 };
|
|
|
584
|
|
|
585
|
|
|
586 class PrimitiveTypeEntry : public TypeEntry
|
|
|
587 {
|
|
|
588 public:
|
|
|
589 PrimitiveTypeEntry(const QString &name)
|
|
|
590 : TypeEntry(name, PrimitiveType), m_preferred_conversion(true), m_preferred_java_type(true)
|
|
|
591 {
|
|
|
592 }
|
|
|
593
|
|
|
594 QString targetLangName() const { return m_java_name; }
|
|
|
595 void setTargetLangName(const QString &targetLangName) { m_java_name = targetLangName; }
|
|
|
596
|
|
|
597 QString jniName() const { return m_jni_name; }
|
|
|
598 void setJniName(const QString &jniName) { m_jni_name = jniName; }
|
|
|
599
|
|
|
600 QString javaObjectFullName() const { return javaObjectPackage() + "." + javaObjectName(); }
|
|
|
601 QString javaObjectName() const;
|
|
|
602 QString javaObjectPackage() const { return strings_java_lang; }
|
|
|
603
|
|
|
604 virtual bool preferredConversion() const { return m_preferred_conversion; }
|
|
|
605 virtual void setPreferredConversion(bool b) { m_preferred_conversion = b; }
|
|
|
606
|
|
|
607 virtual bool preferredTargetLangType() const { return m_preferred_java_type; }
|
|
|
608 virtual void setPreferredTargetLangType(bool b) { m_preferred_java_type = b; }
|
|
|
609
|
|
|
610 private:
|
|
|
611 QString m_java_name;
|
|
|
612 QString m_jni_name;
|
|
|
613 uint m_preferred_conversion : 1;
|
|
|
614 uint m_preferred_java_type : 1;
|
|
|
615 };
|
|
|
616
|
|
|
617
|
|
|
618
|
|
|
619
|
|
|
620 struct EnumValueRedirection
|
|
|
621 {
|
|
|
622 EnumValueRedirection(const QString &rej, const QString &us)
|
|
|
623 : rejected(rej),
|
|
|
624 used(us)
|
|
|
625 {
|
|
|
626 }
|
|
|
627 QString rejected;
|
|
|
628 QString used;
|
|
|
629 };
|
|
|
630
|
|
|
631 class EnumTypeEntry : public TypeEntry
|
|
|
632 {
|
|
|
633 public:
|
|
|
634 EnumTypeEntry(const QString &nspace, const QString &enumName)
|
|
|
635 : TypeEntry(nspace.isEmpty() ? enumName : nspace + QLatin1String("::") + enumName,
|
|
|
636 EnumType),
|
|
|
637 m_flags(0),
|
|
|
638 m_extensible(false)
|
|
|
639 {
|
|
|
640 m_qualifier = nspace;
|
|
|
641 m_java_name = enumName;
|
|
|
642 }
|
|
|
643
|
|
|
644 QString javaPackage() const { return m_package_name; }
|
|
|
645 void setTargetLangPackage(const QString &package) { m_package_name = package; }
|
|
|
646
|
|
|
647 QString targetLangName() const { return m_java_name; }
|
|
|
648 QString javaQualifier() const;
|
|
|
649 QString qualifiedTargetLangName() const {
|
|
|
650 return javaQualifier() + '_' + targetLangName();
|
|
|
651 // return targetLangName();
|
|
|
652 }
|
|
|
653
|
|
|
654 QString jniName() const;
|
|
|
655
|
|
|
656 QString qualifier() const { return m_qualifier; }
|
|
|
657 void setQualifier(const QString &q) { m_qualifier = q; }
|
|
|
658
|
|
|
659 virtual bool preferredConversion() const { return false; }
|
|
|
660
|
|
|
661 bool isBoundsChecked() const { return m_lower_bound.isEmpty() && m_upper_bound.isEmpty(); }
|
|
|
662
|
|
|
663 QString upperBound() const { return m_upper_bound; }
|
|
|
664 void setUpperBound(const QString &bound) { m_upper_bound = bound; }
|
|
|
665
|
|
|
666 QString lowerBound() const { return m_lower_bound; }
|
|
|
667 void setLowerBound(const QString &bound) { m_lower_bound = bound; }
|
|
|
668
|
|
|
669 void setFlags(FlagsTypeEntry *flags) { m_flags = flags; }
|
|
|
670 FlagsTypeEntry *flags() const { return m_flags; }
|
|
|
671
|
|
|
672 bool isExtensible() const { return m_extensible; }
|
|
|
673 void setExtensible(bool is) { m_extensible = is; }
|
|
|
674
|
|
|
675 bool isEnumValueRejected(const QString &name) { return m_rejected_enums.contains(name); }
|
|
|
676 void addEnumValueRejection(const QString &name) { m_rejected_enums << name; }
|
|
|
677 QStringList enumValueRejections() const { return m_rejected_enums; }
|
|
|
678
|
|
|
679 void addEnumValueRedirection(const QString &rejected, const QString &usedValue);
|
|
|
680 QString enumValueRedirection(const QString &value) const;
|
|
|
681
|
|
|
682 bool forceInteger() const { return m_force_integer; }
|
|
|
683 void setForceInteger(bool force) { m_force_integer = force; }
|
|
|
684
|
|
|
685 private:
|
|
|
686 QString m_package_name;
|
|
|
687 QString m_qualifier;
|
|
|
688 QString m_java_name;
|
|
|
689
|
|
|
690 QString m_lower_bound;
|
|
|
691 QString m_upper_bound;
|
|
|
692
|
|
|
693 QStringList m_rejected_enums;
|
|
|
694 QList<EnumValueRedirection> m_enum_redirections;
|
|
|
695
|
|
|
696 FlagsTypeEntry *m_flags;
|
|
|
697
|
|
|
698 bool m_extensible;
|
|
|
699 bool m_force_integer;
|
|
|
700 };
|
|
|
701
|
|
|
702 class FlagsTypeEntry : public TypeEntry
|
|
|
703 {
|
|
|
704 public:
|
|
|
705 FlagsTypeEntry(const QString &name) : TypeEntry(name, FlagsType), m_enum(0)
|
|
|
706 {
|
|
|
707 }
|
|
|
708
|
|
|
709 QString qualifiedTargetLangName() const;
|
|
|
710 QString targetLangName() const { return m_java_name; }
|
|
|
711 QString jniName() const;
|
|
|
712 virtual bool preferredConversion() const { return false; }
|
|
|
713
|
|
|
714 QString originalName() const { return m_original_name; }
|
|
|
715 void setOriginalName(const QString &s) { m_original_name = s; }
|
|
|
716
|
|
|
717 QString flagsName() const { return m_java_name; }
|
|
|
718 void setFlagsName(const QString &name) { m_java_name = name; }
|
|
|
719
|
|
|
720 bool forceInteger() const { return m_enum->forceInteger(); }
|
|
|
721
|
|
|
722 EnumTypeEntry *originator() const { return m_enum; }
|
|
|
723 void setOriginator(EnumTypeEntry *e) { m_enum = e; }
|
|
|
724
|
|
|
725 QString javaPackage() const { return m_enum->javaPackage(); }
|
|
|
726 QString javaQualifier() const { return m_enum->javaQualifier(); }
|
|
|
727 QString qualifier() const { return m_enum->qualifier(); }
|
|
|
728
|
|
|
729 private:
|
|
|
730 QString m_original_name;
|
|
|
731 QString m_java_name;
|
|
|
732 EnumTypeEntry *m_enum;
|
|
|
733 };
|
|
|
734
|
|
|
735
|
|
|
736 class ComplexTypeEntry : public TypeEntry
|
|
|
737 {
|
|
|
738 public:
|
|
|
739 enum TypeFlag {
|
|
|
740 ForceAbstract = 0x1,
|
|
|
741 DeleteInMainThread = 0x2,
|
|
|
742 Deprecated = 0x4
|
|
|
743 };
|
|
|
744 typedef QFlags<TypeFlag> TypeFlags;
|
|
|
745
|
|
|
746 ComplexTypeEntry(const QString &name, Type t)
|
|
|
747 : TypeEntry(QString(name).replace("::", "_"), t),
|
|
|
748 m_qualified_cpp_name(name),
|
|
|
749 m_qobject(false),
|
|
|
750 m_polymorphic_base(false),
|
|
|
751 m_generic_class(false),
|
|
|
752 m_type_flags(0),
|
|
|
753 m_isStructInD(false),
|
|
|
754 m_isAbstract(false)
|
|
|
755 {
|
|
|
756 Include inc;
|
|
|
757 inc.name = "QVariant";
|
|
|
758 inc.type = Include::IncludePath;
|
|
|
759
|
|
|
760 addExtraInclude(inc);
|
|
|
761 }
|
|
|
762
|
|
|
763 bool isComplex() const { return true; }
|
|
|
764
|
|
|
765 IncludeList extraIncludes() const { return m_extra_includes; }
|
|
|
766 void setExtraIncludes(const IncludeList &includes) { m_extra_includes = includes; }
|
|
|
767 void addExtraInclude(const Include &include)
|
|
|
768 {
|
|
|
769 if (!m_includes_used.value(include.name, false)) {
|
|
|
770 m_extra_includes << include;
|
|
|
771 m_includes_used[include.name] = true;
|
|
|
772 }
|
|
|
773 }
|
|
|
774
|
|
|
775 ComplexTypeEntry *copy() const
|
|
|
776 {
|
|
|
777 ComplexTypeEntry *centry = new ComplexTypeEntry(name(), type());
|
|
|
778 centry->setInclude(include());
|
|
|
779 centry->setExtraIncludes(extraIncludes());
|
|
|
780 centry->setFunctionModifications(functionModifications());
|
|
|
781 centry->setFieldModifications(fieldModifications());
|
|
|
782 centry->setQObject(isQObject());
|
|
|
783 centry->setDefaultSuperclass(defaultSuperclass());
|
|
|
784 centry->setCodeSnips(codeSnips());
|
|
|
785 centry->setTargetLangPackage(javaPackage());
|
|
|
786
|
|
|
787 return centry;
|
|
|
788 }
|
|
|
789
|
|
|
790 void setLookupName(const QString &name)
|
|
|
791 {
|
|
|
792 m_lookup_name = name;
|
|
|
793 }
|
|
|
794
|
|
|
795 virtual QString lookupName() const
|
|
|
796 {
|
|
|
797 return m_lookup_name.isEmpty() ? targetLangName() : m_lookup_name;
|
|
|
798 }
|
|
|
799
|
|
|
800 QString jniName() const { return strings_jobject; }
|
|
|
801
|
|
|
802
|
|
|
803 Include include() const { return m_include; }
|
|
|
804 void setInclude(const Include &inc) { m_include = inc; }
|
|
|
805
|
|
|
806 void setTypeFlags(TypeFlags flags)
|
|
|
807 {
|
|
|
808 m_type_flags = flags;
|
|
|
809 }
|
|
|
810
|
|
|
811 TypeFlags typeFlags() const
|
|
|
812 {
|
|
|
813 return m_type_flags;
|
|
|
814 }
|
|
|
815
|
|
|
816 CodeSnipList codeSnips() const { return m_code_snips; }
|
|
|
817 void setCodeSnips(const CodeSnipList &codeSnips) { m_code_snips = codeSnips; }
|
|
|
818 void addCodeSnip(const CodeSnip &codeSnip) { m_code_snips << codeSnip; }
|
|
|
819
|
|
|
820 FunctionModificationList functionModifications() const { return m_function_mods; }
|
|
|
821 void setFunctionModifications(const FunctionModificationList &functionModifications) {
|
|
|
822 m_function_mods = functionModifications;
|
|
|
823 }
|
|
|
824 void addFunctionModification(const FunctionModification &functionModification) {
|
|
|
825 m_function_mods << functionModification;
|
|
|
826 }
|
|
|
827 FunctionModificationList functionModifications(const QString &signature) const;
|
|
|
828
|
|
|
829 FieldModification fieldModification(const QString &name) const;
|
|
|
830 void setFieldModifications(const FieldModificationList &mods) { m_field_mods = mods; }
|
|
|
831 FieldModificationList fieldModifications() const { return m_field_mods; }
|
|
|
832
|
|
|
833 QString javaPackage() const { return m_package; }
|
|
|
834 void setTargetLangPackage(const QString &package) { m_package = package; }
|
|
|
835
|
|
|
836 bool isQObject() const { return m_qobject; }
|
|
|
837 void setQObject(bool qobject) { m_qobject = qobject; }
|
|
|
838
|
|
|
839 QString defaultSuperclass() const { return m_default_superclass; }
|
|
|
840 void setDefaultSuperclass(const QString &sc) { m_default_superclass = sc; }
|
|
|
841
|
|
|
842 virtual QString qualifiedCppName() const { return m_qualified_cpp_name; }
|
|
|
843
|
|
|
844
|
|
|
845 void setIsPolymorphicBase(bool on)
|
|
|
846 {
|
|
|
847 m_polymorphic_base = on;
|
|
|
848 }
|
|
|
849 bool isPolymorphicBase() const { return m_polymorphic_base; }
|
|
|
850
|
|
|
851 void setPolymorphicIdValue(const QString &value)
|
|
|
852 {
|
|
|
853 m_polymorphic_id_value = value;
|
|
|
854 }
|
|
|
855 QString polymorphicIdValue() const { return m_polymorphic_id_value; }
|
|
|
856
|
|
|
857 void setExpensePolicy(const ExpensePolicy &policy) { m_expense_policy = policy; }
|
|
|
858 const ExpensePolicy &expensePolicy() const { return m_expense_policy; }
|
|
|
859
|
|
|
860 QString targetType() const { return m_target_type; }
|
|
|
861 void setTargetType(const QString &code) { m_target_type = code; }
|
|
|
862
|
|
|
863 QString targetLangName() const { return m_java_name.isEmpty()
|
|
|
864 ? TypeEntry::targetLangName()
|
|
|
865 : m_java_name;
|
|
|
866 }
|
|
|
867 void setTargetLangName(const QString &name) { m_java_name = name; }
|
|
|
868
|
|
|
869 bool isGenericClass() const { return m_generic_class; }
|
|
|
870 void setGenericClass(bool isGeneric) { m_generic_class = isGeneric; }
|
|
|
871
|
|
|
872 QString injectedImports;
|
|
|
873
|
|
|
874 // qtd
|
|
|
875 bool isStructInD() const { return m_isStructInD; }
|
|
|
876 void setStructInD(bool isStruct) { m_isStructInD = isStruct; }
|
|
|
877
|
|
|
878 bool isAbstract() const { return m_isAbstract; }
|
|
|
879 void setAbstract(bool isAbstract) { m_isAbstract = isAbstract; }
|
|
|
880
|
|
|
881 QString addedTo;
|
|
|
882 QStringList includedClasses;
|
|
|
883
|
|
|
884
|
|
|
885 private:
|
|
|
886 IncludeList m_extra_includes;
|
|
|
887 Include m_include;
|
|
|
888 QHash<QString, bool> m_includes_used;
|
|
|
889 FunctionModificationList m_function_mods;
|
|
|
890 FieldModificationList m_field_mods;
|
|
|
891 CodeSnipList m_code_snips;
|
|
|
892 QString m_package;
|
|
|
893 QString m_default_superclass;
|
|
|
894 QString m_qualified_cpp_name;
|
|
|
895 QString m_java_name;
|
|
|
896
|
|
|
897 uint m_qobject : 1;
|
|
|
898 uint m_polymorphic_base : 1;
|
|
|
899 uint m_generic_class : 1;
|
|
|
900
|
|
|
901 QString m_polymorphic_id_value;
|
|
|
902 QString m_lookup_name;
|
|
|
903 QString m_target_type;
|
|
|
904 ExpensePolicy m_expense_policy;
|
|
|
905 TypeFlags m_type_flags;
|
|
|
906
|
|
|
907 // qtd
|
|
|
908 bool m_isStructInD;
|
|
|
909 bool m_isAbstract;
|
|
|
910 };
|
|
|
911
|
|
|
912 class ContainerTypeEntry : public ComplexTypeEntry
|
|
|
913 {
|
|
|
914 public:
|
|
|
915 enum Type {
|
|
|
916 NoContainer,
|
|
|
917 ListContainer,
|
|
|
918 StringListContainer,
|
|
|
919 LinkedListContainer,
|
|
|
920 VectorContainer,
|
|
|
921 StackContainer,
|
|
|
922 QueueContainer,
|
|
|
923 SetContainer,
|
|
|
924 MapContainer,
|
|
|
925 MultiMapContainer,
|
|
|
926 HashContainer,
|
|
|
927 MultiHashContainer,
|
|
|
928 PairContainer,
|
|
|
929 };
|
|
|
930
|
|
|
931 ContainerTypeEntry(const QString &name, Type type)
|
|
|
932 : ComplexTypeEntry(name, ContainerType)
|
|
|
933 {
|
|
|
934 m_type = type;
|
|
|
935 setCodeGeneration(GenerateForSubclass);
|
|
|
936 }
|
|
|
937
|
|
|
938 Type type() const { return m_type; }
|
|
|
939 QString targetLangName() const;
|
|
|
940 QString javaPackage() const;
|
|
|
941 QString qualifiedCppName() const;
|
|
|
942
|
|
|
943 private:
|
|
|
944 Type m_type;
|
|
|
945 };
|
|
|
946
|
|
|
947
|
|
|
948 class NamespaceTypeEntry : public ComplexTypeEntry
|
|
|
949 {
|
|
|
950 public:
|
|
|
951 NamespaceTypeEntry(const QString &name) : ComplexTypeEntry(name, NamespaceType) { }
|
|
|
952 };
|
|
|
953
|
|
|
954
|
|
|
955 class ValueTypeEntry : public ComplexTypeEntry
|
|
|
956 {
|
|
|
957 public:
|
|
|
958 ValueTypeEntry(const QString &name) : ComplexTypeEntry(name, BasicValueType) { }
|
|
|
959
|
|
|
960 bool isValue() const { return true; }
|
|
|
961
|
|
|
962 virtual bool isNativeIdBased() const { return true; }
|
|
|
963
|
|
|
964 protected:
|
|
|
965 ValueTypeEntry(const QString &name, Type t) : ComplexTypeEntry(name, t) { }
|
|
|
966 };
|
|
|
967
|
|
|
968
|
|
|
969 class StringTypeEntry : public ValueTypeEntry
|
|
|
970 {
|
|
|
971 public:
|
|
|
972 StringTypeEntry(const QString &name)
|
|
|
973 : ValueTypeEntry(name, StringType)
|
|
|
974 {
|
|
|
975 setCodeGeneration(GenerateNothing);
|
|
|
976 }
|
|
|
977
|
|
|
978 QString jniName() const { return strings_jobject; }
|
|
|
979 QString targetLangName() const { return strings_String; }
|
|
|
980 QString javaPackage() const { return strings_java_lang; }
|
|
|
981
|
|
|
982 virtual bool isNativeIdBased() const { return false; }
|
|
|
983 };
|
|
|
984
|
|
|
985 class CharTypeEntry : public ValueTypeEntry
|
|
|
986 {
|
|
|
987 public:
|
|
|
988 CharTypeEntry(const QString &name) : ValueTypeEntry(name, CharType)
|
|
|
989 {
|
|
|
990 setCodeGeneration(GenerateNothing);
|
|
|
991 }
|
|
|
992
|
|
|
993 QString jniName() const { return strings_jchar; }
|
|
|
994 QString targetLangName() const { return strings_char; }
|
|
|
995 QString javaPackage() const { return QString(); }
|
|
|
996
|
|
|
997 virtual bool isNativeIdBased() const { return false; }
|
|
|
998 };
|
|
|
999
|
|
|
1000 class JObjectWrapperTypeEntry: public ValueTypeEntry
|
|
|
1001 {
|
|
|
1002 public:
|
|
|
1003 JObjectWrapperTypeEntry(const QString &name) : ValueTypeEntry(name, JObjectWrapperType) { }
|
|
|
1004
|
|
|
1005 QString jniName() const { return strings_jobject; }
|
|
|
1006 QString targetLangName() const { return strings_Object; }
|
|
|
1007 QString javaPackage() const { return strings_java_lang; }
|
|
|
1008
|
|
|
1009 bool isNativeIdBased() const { return false; }
|
|
|
1010 };
|
|
|
1011
|
|
|
1012 class VariantTypeEntry: public ValueTypeEntry
|
|
|
1013 {
|
|
|
1014 public:
|
|
|
1015 VariantTypeEntry(const QString &name) : ValueTypeEntry(name, VariantType) { }
|
|
|
1016
|
|
|
1017 QString jniName() const { return strings_jobject; }
|
|
|
1018 QString targetLangName() const { return "QVariant"; }
|
|
|
1019 QString javaPackage() const { return "qt.core"; }
|
|
|
1020 virtual bool isNativeIdBased() const { return false; }
|
|
|
1021 };
|
|
|
1022
|
|
|
1023
|
|
|
1024 class InterfaceTypeEntry : public ComplexTypeEntry
|
|
|
1025 {
|
|
|
1026 public:
|
|
|
1027 InterfaceTypeEntry(const QString &name)
|
|
|
1028 : ComplexTypeEntry(name, InterfaceType)
|
|
|
1029 {
|
|
|
1030 }
|
|
|
1031
|
|
|
1032 static QString interfaceName(const QString &name) {
|
|
|
1033 return "I" + name;
|
|
|
1034 }
|
|
|
1035
|
|
|
1036 ObjectTypeEntry *origin() const { return m_origin; }
|
|
|
1037 void setOrigin(ObjectTypeEntry *origin) { m_origin = origin; }
|
|
|
1038
|
|
|
1039 virtual bool isNativeIdBased() const { return true; }
|
|
|
1040 virtual QString qualifiedCppName() const {
|
|
|
1041 return ComplexTypeEntry::qualifiedCppName().right(ComplexTypeEntry::qualifiedCppName().length() - interfaceName("").length());
|
|
|
1042 }
|
|
|
1043
|
|
|
1044 private:
|
|
|
1045 ObjectTypeEntry *m_origin;
|
|
|
1046 };
|
|
|
1047
|
|
|
1048
|
|
|
1049 class ObjectTypeEntry : public ComplexTypeEntry
|
|
|
1050 {
|
|
|
1051 public:
|
|
|
1052 ObjectTypeEntry(const QString &name)
|
|
|
1053 : ComplexTypeEntry(name, ObjectType), m_interface(0)
|
|
|
1054 {
|
|
|
1055 }
|
|
|
1056
|
|
|
1057 InterfaceTypeEntry *designatedInterface() const { return m_interface; }
|
|
|
1058 void setDesignatedInterface(InterfaceTypeEntry *entry) { m_interface = entry; }
|
|
|
1059
|
|
|
1060 virtual bool isNativeIdBased() const { return true; }
|
|
|
1061
|
|
|
1062 private:
|
|
|
1063 InterfaceTypeEntry *m_interface;
|
|
|
1064 };
|
|
|
1065
|
|
|
1066 class CustomTypeEntry : public ComplexTypeEntry
|
|
|
1067 {
|
|
|
1068 public:
|
|
|
1069 CustomTypeEntry(const QString &name) : ComplexTypeEntry(name, CustomType) { }
|
|
|
1070
|
|
|
1071 virtual void generateCppJavaToQt(QTextStream &s,
|
|
|
1072 const AbstractMetaType *java_type,
|
|
|
1073 const QString &env_name,
|
|
|
1074 const QString &qt_name,
|
|
|
1075 const QString &java_name) const = 0;
|
|
|
1076
|
|
|
1077 virtual void generateCppQtToJava(QTextStream &s,
|
|
|
1078 const AbstractMetaType *java_type,
|
|
|
1079 const QString &env_name,
|
|
|
1080 const QString &qt_name,
|
|
|
1081 const QString &java_name) const = 0;
|
|
|
1082 };
|
|
|
1083
|
|
|
1084 struct TypeRejection
|
|
|
1085 {
|
|
|
1086 QString class_name;
|
|
|
1087 QString function_name;
|
|
|
1088 QString field_name;
|
|
|
1089 QString enum_name;
|
|
|
1090 };
|
|
|
1091
|
|
|
1092 class TypeDatabase
|
|
|
1093 {
|
|
|
1094 public:
|
|
|
1095 TypeDatabase();
|
|
|
1096
|
|
|
1097 static TypeDatabase *instance();
|
|
|
1098
|
|
|
1099 QList<Include> extraIncludes(const QString &className);
|
|
|
1100
|
|
|
1101 inline PrimitiveTypeEntry *findPrimitiveType(const QString &name);
|
|
|
1102 inline ComplexTypeEntry *findComplexType(const QString &name);
|
|
|
1103 inline ObjectTypeEntry *findObjectType(const QString &name);
|
|
|
1104 inline NamespaceTypeEntry *findNamespaceType(const QString &name);
|
|
|
1105 ContainerTypeEntry *findContainerType(const QString &name);
|
|
|
1106
|
|
|
1107 TypeEntry *findType(const QString &name) const {
|
|
|
1108 QList<TypeEntry *> entries = findTypes(name);
|
|
|
1109 foreach (TypeEntry *entry, entries) {
|
|
|
1110 if (entry != 0 &&
|
|
|
1111 (!entry->isPrimitive() || static_cast<PrimitiveTypeEntry *>(entry)->preferredTargetLangType())) {
|
|
|
1112 return entry;
|
|
|
1113 }
|
|
|
1114 }
|
|
|
1115 return 0;
|
|
|
1116 }
|
|
|
1117 QList<TypeEntry *> findTypes(const QString &name) const { return m_entries.value(name); }
|
|
|
1118 TypeEntryHash allEntries() { return m_entries; }
|
|
|
1119 SingleTypeEntryHash entries() {
|
|
|
1120 TypeEntryHash entries = allEntries();
|
|
|
1121
|
|
|
1122 SingleTypeEntryHash returned;
|
|
|
1123 QList<QString> keys = entries.keys();
|
|
|
1124
|
|
|
1125 foreach(QString key, keys) {
|
|
|
1126 returned[key] = findType(key);
|
|
|
1127 }
|
|
|
1128
|
|
|
1129 return returned;
|
|
|
1130 }
|
|
|
1131
|
|
|
1132 PrimitiveTypeEntry *findTargetLangPrimitiveType(const QString &java_name);
|
|
|
1133
|
|
|
1134 void addRejection(const QString &class_name, const QString &function_name,
|
|
|
1135 const QString &field_name, const QString &enum_name);
|
|
|
1136 bool isClassRejected(const QString &class_name);
|
|
|
1137 bool isFunctionRejected(const QString &class_name, const QString &function_name);
|
|
|
1138 bool isFieldRejected(const QString &class_name, const QString &field_name);
|
|
|
1139 bool isEnumRejected(const QString &class_name, const QString &enum_name);
|
|
|
1140
|
|
|
1141 void addType(TypeEntry *e) { m_entries[e->qualifiedCppName()].append(e); }
|
|
|
1142
|
|
|
1143 SingleTypeEntryHash flagsEntries() const { return m_flags_entries; }
|
|
|
1144 FlagsTypeEntry *findFlagsType(const QString &name) const;
|
|
|
1145 void addFlagsType(FlagsTypeEntry *fte) { m_flags_entries[fte->originalName()] = fte; }
|
|
|
1146
|
|
|
1147 TemplateEntry *findTemplate(const QString &name) { return m_templates[name]; }
|
|
|
1148 void addTemplate(TemplateEntry *t) { m_templates[t->name()] = t; }
|
|
|
1149
|
|
|
1150 void setIncludeEclipseWarnings(bool on) { m_includeEclipseWarnings = on; }
|
|
|
1151 bool includeEclipseWarnings() const { return m_includeEclipseWarnings; }
|
|
|
1152
|
|
|
1153 void setSuppressWarnings(bool on) { m_suppressWarnings = on; }
|
|
|
1154 void addSuppressedWarning(const QString &s)
|
|
|
1155 {
|
|
|
1156 m_suppressedWarnings.append(s);
|
|
|
1157 }
|
|
|
1158
|
|
|
1159 bool isSuppressedWarning(const QString &s)
|
|
|
1160 {
|
|
|
1161 if (!m_suppressWarnings)
|
|
|
1162 return false;
|
|
|
1163
|
|
|
1164 foreach (const QString &_warning, m_suppressedWarnings) {
|
|
|
1165 QString warning(QString(_warning).replace("\\*", "&place_holder_for_asterisk;"));
|
|
|
1166
|
|
|
1167 QStringList segs = warning.split("*", QString::SkipEmptyParts);
|
|
|
1168 if (segs.size() == 0)
|
|
|
1169 continue ;
|
|
|
1170
|
|
|
1171 int i = 0;
|
|
|
1172 int pos = s.indexOf(QString(segs.at(i++)).replace("&place_holder_for_asterisk;", "*"));
|
|
|
1173 //qDebug() << "s == " << s << ", warning == " << segs;
|
|
|
1174 while (pos != -1) {
|
|
|
1175 if (i == segs.size())
|
|
|
1176 return true;
|
|
|
1177 pos = s.indexOf(QString(segs.at(i++)).replace("&place_holder_for_asterisk;", "*"), pos);
|
|
|
1178 }
|
|
|
1179 }
|
|
|
1180
|
|
|
1181 return false;
|
|
|
1182 }
|
|
|
1183
|
|
|
1184 void setRebuildClasses(const QStringList &cls) { m_rebuild_classes = cls; }
|
|
|
1185
|
|
|
1186 static QString globalNamespaceClassName(const TypeEntry *te);
|
|
|
1187 QString filename() const { return "typesystem.txt"; }
|
|
|
1188
|
|
4
|
1189 bool parseFile(const QString &filename, const QString &work_dir, bool generate = true);
|
|
1
|
1190
|
|
|
1191 private:
|
|
|
1192 uint m_suppressWarnings : 1;
|
|
|
1193 uint m_includeEclipseWarnings : 1;
|
|
|
1194 uint m_reserved : 30;
|
|
|
1195
|
|
|
1196 TypeEntryHash m_entries;
|
|
|
1197 SingleTypeEntryHash m_flags_entries;
|
|
|
1198 TemplateEntryHash m_templates;
|
|
|
1199 QStringList m_suppressedWarnings;
|
|
|
1200
|
|
|
1201 QList<TypeRejection> m_rejections;
|
|
|
1202 QStringList m_rebuild_classes;
|
|
|
1203 };
|
|
|
1204
|
|
|
1205 inline PrimitiveTypeEntry *TypeDatabase::findPrimitiveType(const QString &name)
|
|
|
1206 {
|
|
|
1207 QList<TypeEntry *> entries = findTypes(name);
|
|
|
1208
|
|
|
1209 foreach (TypeEntry *entry, entries) {
|
|
|
1210 if (entry != 0 && entry->isPrimitive() && static_cast<PrimitiveTypeEntry *>(entry)->preferredTargetLangType())
|
|
|
1211 return static_cast<PrimitiveTypeEntry *>(entry);
|
|
|
1212 }
|
|
|
1213
|
|
|
1214 return 0;
|
|
|
1215 }
|
|
|
1216
|
|
|
1217 inline ComplexTypeEntry *TypeDatabase::findComplexType(const QString &name)
|
|
|
1218 {
|
|
|
1219 TypeEntry *entry = findType(name);
|
|
|
1220 if (entry != 0 && entry->isComplex())
|
|
|
1221 return static_cast<ComplexTypeEntry *>(entry);
|
|
|
1222 else
|
|
|
1223 return 0;
|
|
|
1224 }
|
|
|
1225
|
|
|
1226 inline ObjectTypeEntry *TypeDatabase::findObjectType(const QString &name)
|
|
|
1227 {
|
|
|
1228 TypeEntry *entry = findType(name);
|
|
|
1229 if (entry != 0 && entry->isObject())
|
|
|
1230 return static_cast<ObjectTypeEntry *>(entry);
|
|
|
1231 else
|
|
|
1232 return 0;
|
|
|
1233 }
|
|
|
1234
|
|
|
1235 inline NamespaceTypeEntry *TypeDatabase::findNamespaceType(const QString &name)
|
|
|
1236 {
|
|
|
1237 TypeEntry *entry = findType(name);
|
|
|
1238 if (entry != 0 && entry->isNamespace())
|
|
|
1239 return static_cast<NamespaceTypeEntry *>(entry);
|
|
|
1240 else
|
|
|
1241 return 0;
|
|
|
1242 }
|
|
|
1243
|
|
|
1244 QString fixCppTypeName(const QString &name);
|
|
|
1245
|
|
|
1246 #endif // TYPESYSTEM_H
|
