projects/qtd: generator/cppimplgenerator.cpp comparison

comparison generator/cppimplgenerator.cpp @ 310:5bcfe9e7db7f lifetime

Committing local changes

author	maxter <spambox@d-coding.com>
date	Wed, 23 Dec 2009 16:10:46 +0200
parents	90131f64c9c9
children	80b52f5e97b6

comparison

equal deleted inserted replaced

-:a7b313b8b149
+:5bcfe9e7db7f
 writeDefaultConstructedValues(s, java_class);
 if (hasCustomDestructor(java_class)) */
-if (java_class->hasPublicDestructor() && (!java_class->baseClass() || !java_class->hasVirtualFunctions()))
+if (java_class->hasPublicDestructor() && !java_class->hasVirtualDestructor())
 writeDestructor(s, java_class);
 if (java_class->isQObject())
 writeSignalsHandling(s, java_class);
 foreach (AbstractMetaFunction *function, java_class->functions()) {
 if (function->isConstructor())
 writeShellConstructor(s, function);
 }
-if (java_class->hasVirtualFunctions())
+if (java_class->isPolymorphic())
 writeShellDestructor(s, java_class);
 if (java_class->isQObject())
 writeQObjectFunctions(s, java_class);
 else if (java_class->typeEntry()->isObject())
 for (int pos = 0; pos<virtualFunctions.size(); ++pos) {
 const AbstractMetaFunction *function = virtualFunctions.at(pos);
 // qtd            writeShellFunction(s, function, java_class, pos);
 writeShellVirtualFunction(s, function, java_class, pos);
 }
+s << "// end ------------------------" << endl << endl;
 if (cpp_shared)
 writeInitCallbacks(s, java_class);
 // Functions in shell class
 AbstractMetaFunctionList shellFunctions = java_class->nonVirtualShellFunctions();
 for (int i=0; i<shellFunctions.size(); ++i) {
 const AbstractMetaFunction *function = shellFunctions.at(i);
 writeShellFunction(s, function, java_class, -1);
 }
+s << "// end ------------------------" << endl << endl;
 // Write public overrides for functions that are protected in the base class
 // so they can be accessed from the native callback
 s << "// public overrides for functions that are protected in the base class" << endl;
 AbstractMetaFunctionList public_override_functions = java_class->publicOverrideFunctions();
 foreach (AbstractMetaFunction *function, public_override_functions) {
 if(notWrappedYet(function))
 continue;
 writePublicFunctionOverride(s, function, java_class);
 }
+s << "// end ------------------------" << endl << endl;
 // Write virtual function overries used to decide on static/virtual calls
 s << "// Write virtual function overries used to decide on static/virtual calls" << endl;
 AbstractMetaFunctionList virtual_functions = java_class->virtualOverrideFunctions();
 foreach (const AbstractMetaFunction *function, virtual_functions) {
 if(notWrappedYet(function))
 continue;
 writeVirtualFunctionOverride(s, function, java_class);
 }
+s << "// end ------------------------" << endl << endl;;
 }
 writeExtraFunctions(s, java_class);
 /* qtd2
 writeToStringFunction(s, java_class);
 // Signals
 AbstractMetaFunctionList signal_functions = signalFunctions(java_class);
 for (int i=0; i<signal_functions.size(); ++i)
 writeSignalFunction(s, signal_functions.at(i), java_class, i);
 */
-s << "// ---externC---" << endl;
+s << "// extern C" << endl;
 // Native callbacks (all java functions require native callbacks)
 AbstractMetaFunctionList class_funcs = java_class->functionsInTargetLang();
 foreach (AbstractMetaFunction *function, class_funcs) {
 if (!function->isEmptyFunction())
 writeFinalFunction(s, function, java_class);
 }
-s << "// ---externC---end" << endl;
+s << "// end ------------------------" << endl << endl;
 class_funcs = java_class->queryFunctions(AbstractMetaClass::NormalFunctions | AbstractMetaClass::AbstractFunctions | AbstractMetaClass::NotRemovedFromTargetLang);
 foreach (AbstractMetaFunction *function, class_funcs) {
 if (function->implementingClass() != java_class) {
 s << "// Field accessors" << endl;
 foreach (AbstractMetaField *field, java_class->fields()) {
 if (field->wasPublic() || (field->wasProtected() && !java_class->isFinal()))
 writeFieldAccessors(s, field);
 }
+s << "// end ------------------------" << endl << endl;
 /*
 s << "// writeFromNativeFunction" << endl;
 writeFromNativeFunction(s, java_class);
 if (java_class->isQObject())
 // qtd    writeJavaLangObjectOverrideFunctions(s, java_class);
 if (java_class->isQObject())
 {
 s << endl << endl
-<< "extern \"C\" DLL_PUBLIC void* qtd_" << java_class->name() << "_staticMetaObject() {" << endl
+<< "extern \"C\" DLL_PUBLIC void* qtd_" << java_class->name() << "_staticTypeId() {" << endl
 << "    return (void*)&" << java_class->name() << "::staticMetaObject;" << endl
 << "}" << endl;
 }
 s << endl << endl;
 }
 s << ")";
 if (cls->isQObject())
 s << "," << endl << "      QtD_QObjectEntity(this, d_ptr)";
-else if (cls->hasVirtualFunctions())
+else if (cls->isPolymorphic())
 s << "," << endl << "      QtD_Entity(d_ptr)";
 /* qtd        s << "    m_meta_object(0)," << endl;
 s << "      m_vtable(0)," << endl
 << "      m_link(0)" << endl;
 */
 s << "}" << endl << endl;
 }
 void CppImplGenerator::writeObjectFunctions(QTextStream &s, const AbstractMetaClass *java_class)
 {
-if (java_class->isPolymorphic())
+if (java_class == java_class->polymorphicBase())
+{
+if (java_class->isPolymorphic())
+{
+s << "extern \"C\" DLL_PUBLIC void* qtd_" << java_class->name() << "_dId(void *nativeId)" << endl
+<< "{" << endl
+<< "    QtD_Entity *e = dynamic_cast<QtD_Entity*>((" << java_class->qualifiedCppName() << "*)nativeId);" << endl
+<< "    return e ? e->dId : NULL;" << endl
+<< "}" << endl << endl;
+}
+if (!java_class->isQObject())
+{
+s << "extern \"C\" DLL_PUBLIC const void* qtd_" << java_class->name() << "_typeId(void *nativeId)" << endl
+<< "{" << endl
+<< "    return &typeid((" << java_class->qualifiedCppName() << "*)nativeId);" << endl
+<< "}" << endl << endl;
+}
+}
+if (!java_class->isQObject())
 {
 s << "extern \"C\" DLL_PUBLIC const void* qtd_" << java_class->name() << "_staticTypeId()" << endl;
 s << "{" << endl;
 {
 Indentation indent(INDENT);
 s << INDENT << "return &typeid(" << java_class->qualifiedCppName() << ");" << endl;
 }
 s << "}" << endl << endl;
-if (!java_class->baseClass())
-{
-s << "extern \"C\" DLL_PUBLIC void* qtd_" << java_class->name() << "_dId(void *nativeId)" << endl
-<< "{" << endl
-<< "    QtD_Entity *a = dynamic_cast<QtD_Entity*>((" << java_class->qualifiedCppName() << "*)nativeId);" << endl
-<< "    return a ? a->dId : NULL;" << endl
-<< "}" << endl << endl
-<< "extern \"C\" DLL_PUBLIC const void* qtd_" << java_class->name() << "_typeId(void *nativeId)" << endl
-<< "{" << endl
-<< "    return &typeid((" << java_class->qualifiedCppName() << "*)nativeId);" << endl
-<< "}" << endl << endl;
-}
 }
 }
 void CppImplGenerator::writeVirtualFunctionOverride(QTextStream &s,
 const AbstractMetaFunction *java_function,
 */
 uint nativeArgCount = 0;
 const AbstractMetaClass *cls = java_function->ownerClass();
 if (java_function->isConstructor() &&
-cls->hasVirtualFunctions())
+cls->isPolymorphic())
 {
 s << "void *d_ptr";
 nativeArgCount++;
 }
 s << INDENT
 << "bool __do_static_call = __this_nativeId ? ";
 if (java_class->isQObject())
 s << "QtD_QObjectEntity::getQObjectEntity((QObject*)__this_nativeId) : false;" << endl;
 else
-s << "qtd_" << java_class->rootClass()->name() << "_dId(__this_nativeId) : false;" << endl;
+s << "qtd_" << java_class->polymorphicBase()->name() << "_dId(__this_nativeId) : false;" << endl;
 } else {
 option = OriginalName;
 }
 // Call the Qt function on the java object
 void CppImplGenerator::writeDestructor(QTextStream &s, const AbstractMetaClass *cls)
 {
 if (!cls->hasConstructors())
 return;
-s << INDENT << "extern \"C\" DLL_PUBLIC void qtd_" << cls->name() << "_destructor(void *ptr)" << endl
+if (cls->polymorphicBase() == cls)
-<< INDENT << "{" << endl;
 {
-QString className = cls->hasVirtualFunctions() ? cls->typeEntry()->name() : shellClassName(cls);
+s << "extern \"C\" DLL_PUBLIC void qtd_" << cls->name() << "_delete(void *ptr){" << endl;
-s << INDENT << "delete (" << className << " *)ptr;" << endl;
+QString className = cls->generateShellClass() ? shellClassName(cls) : cls->typeEntry()->name();
-}
+s << "    delete (" << className << " *)ptr;" << endl
+<< "}" << endl << endl;
-s << INDENT << "}" << endl << endl;
+}
 }
 void CppImplGenerator::writeFinalConstructor(QTextStream &s,
 const AbstractMetaFunction *java_function,
 const QString &qt_object_name,
 const QString &qt_name,
 const QString &java_name,
 const AbstractMetaFunction *java_function,
 int argument_index)
 {
+s << "//writeJavaToQt" << endl; // TMP
 // Conversion to C++: Shell code for return values, native code for arguments
 TypeSystem::Language lang = argument_index == 0 ? TypeSystem::ShellCode : TypeSystem::NativeCode;
 if (writeConversionRule(s, lang, java_function, argument_index, qt_name, java_name))
 return;
 const QString &java_name,
 const AbstractMetaFunction *java_function,
 int argument_index,
 Option options)
 {
+s << "//writeJavaToQt 2" << endl; // TMP
 // Conversion to C++: Shell code for return values, native code for arguments
 TypeSystem::Language lang = argument_index == 0 ? TypeSystem::ShellCode : TypeSystem::NativeCode;
 if (java_function && writeConversionRule(s, lang, java_function, argument_index, qt_name, java_name))
 return;
 const QString &java_name,
 const AbstractMetaFunction *java_function,
 int argument_index,
 Option option)
 {
+s << "writeQtToJava" << endl;
 // Conversion to Java: Native code for return values, shell code for arguments
 TypeSystem::Language lang = argument_index == 0 ? TypeSystem::NativeCode : TypeSystem::ShellCode;
 /* qtd    if (java_function && writeConversionRule(s, lang, java_function, argument_index, qt_name, java_name))
 return;
 {
 AbstractMetaArgumentList arguments = java_function->arguments();
 int written_arguments = 0;
 const AbstractMetaClass *cls = java_function->ownerClass();
-if (java_function->isConstructor() && cls->hasVirtualFunctions()) {
+if (java_function->isConstructor() && cls->isPolymorphic()) {
 s << "d_ptr";
 written_arguments++;
 }
 for (int i=0; i<arguments.size(); ++i) {
 const AbstractMetaArgument *argument = arguments.at(i);

Mercurial > projects > qtd

comparison generator/cppimplgenerator.cpp @ 310:5bcfe9e7db7f lifetime