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