projects/qtd: generator/dgenerator.cpp comparison

comparison generator/dgenerator.cpp @ 262:90131f64c9c9 lifetime

looks like enabling/disabling GC is enough

author	maxter
date	Tue, 22 Sep 2009 15:19:04 +0000
parents	b5773ccab07d
children	a7b313b8b149

comparison

equal deleted inserted replaced

-:8f7bb7fc3123
+:90131f64c9c9
 DGenerator::DGenerator()
 : m_doc_parser(0),
 m_docs_enabled(false),
 m_native_jump_table(false),
 m_recursive(0),
 m_isRecursive(false)
 {
 excludedTypes << "long long" << "bool" << "int" << "QString" << "char" << "WId"
 << "unsigned char" << "uint" << "double" << "short" << "float"
 << "signed char" << "unsigned short" << "QBool" << "unsigned int"
 << "Qt::HANDLE" << "QChar" << "java.lang.JObjectWrapper" << "void"
 s << ";" << endl;
 }
 }
 static QString function_call_for_ownership(TypeSystem::Ownership owner)
 {
 if (owner == TypeSystem::CppOwnership) {
-return "__nativeOwnership = true";
+return "__pin";
-} else /* qtd 2 if (owner == TypeSystem::TargetLangOwnership) */ {
+} else if (owner == TypeSystem::TargetLangOwnership || owner == TypeSystem::TargetLangOwnership) {
-return "__nativeOwnership = false";
+return "__unpin";
-}/* else if (owner == TypeSystem::DefaultOwnership) {
-return "__no_real_delete = false";
 } else {
 Q_ASSERT(false);
 return "bogus()";
-}*/
+}
 }
 void DGenerator::writeOwnershipForContainer(QTextStream &s, TypeSystem::Ownership owner,
 AbstractMetaType *type, const QString &arg_name)
 {
 writeReferenceCount(s, refCount, i == 0 ? "this" : arguments.at(i-1)->argumentName());
 }
 referenceCounts = d_function->referenceCounts(d_function->implementingClass(), 0);
 */
 AbstractMetaType *return_type = d_function->type();
 QString new_return_type = QString(d_function->typeReplaced(0)).replace('$', '.');
 bool has_return_type = new_return_type != "void"
 && (!new_return_type.isEmpty() || return_type != 0);
 // qtd    TypeSystem::Ownership owner = d_function->ownership(d_function->implementingClass(), TypeSystem::TargetLangCode, 0);
 s << " __d_return_value = ";
 }
 if(return_type->isQObject())
 s << return_type->name() << ".__wrap(ret);" << endl;
 if ((return_type->isValue() && !return_type->typeEntry()->isStructInD()) || return_type->isVariant())
 s << "new " << return_type->name() << "(ret);" << endl;
 else if (return_type->typeEntry()->isValue() && return_type->isNativePointer())
 s << "new " << return_type->name() << "(ret, QtdObjectFlags.skipNativeDelete);" << endl;
 if (return_type->isObject()) {
 if(d_function->storeResult())
 {
 QString fieldName = QString("__m_%1;").arg(d_function->name());
 s << INDENT << "if (!" << fieldName << " || " << fieldName << ".__nativeId != ret) {" << endl
 {
 if (!d_class->hasConstructors())
 return;
 s << "    override void __deleteNative() {" << endl
 << "        qtd_" << d_class->name() << "_destructor(__nativeId);" << endl
 << "    }" << endl;
 }
 void DGenerator::writeOwnershipSetter(QTextStream &s, const AbstractMetaClass *d_class)
 {
 s << "private extern(C) void " << sigExternName << "_handle(void* d_entity, void** args) {" << endl;
 {
 Indentation indent(INDENT);
 s << INDENT << "auto d_object = cast(" << d_class->name() << ") d_entity;" << endl;
 int sz = arguments.count();
 //TODO: This mostly duplicates virtual function argument generation. Should be merged
 for (int j=0; j<sz; ++j) {
 AbstractMetaArgument *argument = arguments.at(j);
 QString arg_name = argument->indexedName();
 AbstractMetaType *type = argument->type();
 s << INDENT << "auto " << arg_name << " = *(cast(" << type_name << "*)" << arg_ptr << ");";
 } else if (type->isValue() || (type->typeEntry()->isValue() && type->isNativePointer())) {
 s << INDENT << "scope " << arg_name << " = new " <<  argument->type()->typeEntry()->name()
 << "(cast(void*)(" << arg_ptr << "), QtdObjectFlags.skipNativeDelete);" << endl;
 }
-else if (type->isObject() || type->isQObject())
+else if (type->typeEntry()->isObject())
 {
 bool resetAfterUse = !type->isQObject() && signal->resetObjectAfterUse(argument->argumentIndex() + 1);
 if ((static_cast<const ComplexTypeEntry*>(type->typeEntry()))->isPolymorphic())
 {
 QString flags;
 if (resetAfterUse)
 flags = "QtdObjectFlags.stackAllocated | QtdObjectFlags.skipNativeDelete";
-else if (type->isQObject())
+else
 flags = "QtdObjectFlags.none";
-else
-flags = "QtdObjectFlags.skipNativeDelete";
 s << INDENT << "auto " << arg_name << " = " << type->typeEntry()->name() << ".__wrap(" << arg_name
 << ", cast(QtdObjectFlags)(" << flags << "));" << endl;
 if (resetAfterUse)
 {
 s << INDENT << "scope(exit) {" << endl
 << INDENT << "    if (" << arg_name << "_d_ref.__flags & QtdObjectFlags.stackAllocated)" << endl
 << INDENT << "        delete " << arg_name << ";" << endl
 << INDENT << "}" << endl;
 }
 }
 else
 {
 s << INDENT << (resetAfterUse ? "scope " : "auto ")
-<< arg_name << "_d_ref = new " << type->typeEntry()->name() << "(" << arg_name << ", QtdObjectFlags.skipNativeDelete);";
+<< arg_name << "_d_ref = new " << type->typeEntry()->name() << "(" << arg_name << ", QtdObjectFlags."
+<< (resetAtferUse ? "skipNativeDelete" : "none") << ");" << endl;
 }
 }
 s << endl;
 }
 //            s << INDENT << "Stdout(\"" << d_class->name() << "\", \"" << signal->name() << "\").newline;" << endl;
 s << INDENT << "d_object." << signal->name() << ".emit(";
 for (int j = 0; j<sz; ++j) {
 }
 }
 void DGenerator::write(QTextStream &s, const AbstractMetaClass *d_class)
 {
 ReportHandler::debugSparse("Generating class: " + d_class->fullName());
 bool fakeClass = d_class->attributes() & AbstractMetaAttributes::Fake;
 QString auxModName = d_class->package() + "." + d_class->name() + "_aux";
 if (d_class->isQObject()) {
 s << "public import qt.core.QMetaObject;" << endl;
 s << "public import qt.Signal;" << endl;
 if (d_class->name() != "QObject")
 s << "public import qt.core.QObject;" << endl;
 }
 // qtd2 hack!
 if (d_class->name() == "QCoreApplication")
 s << "private import qt.core.ArrayOps;" << endl;
 else if (d_class->name() == "QApplication")
 s << ">";
 }
 if (!d_class->isNamespace() && !d_class->isInterface()) {
 s << " : ";
 if (d_class->baseClass()) {
 s << d_class->baseClass()->name();
 } else {
 if (d_class->typeEntry()->isValue())
 s << "QtdObjectBase";
 else if (d_class->typeEntry()->isObject())
 s << "QtdObject";
 }
 }/* qtd else if (d_class->isInterface()) {
 s << " extends QtJambiInterface";
 }*/
 if (!interfaces.isEmpty()) {
 if (!d_class->isInterface())
 s << ", ";
 else {
 implements = true;
-s << ": ";
+s << " : ";
 }
 for (int i=0; i<interfaces.size(); ++i) {
 AbstractMetaClass *iface = interfaces.at(i);
 if (i) s << ", ";
 s << iface->name();
 }
 }
 foreach (QString variableName, variables.keys()) {
 int actions = variables.value(variableName) & ReferenceCount::ActionsMask;
-//            bool threadSafe = variables.value(variableName) & ReferenceCount::ThreadSafe;
+bool threadSafe = variables.value(variableName) & ReferenceCount::ThreadSafe;
 bool isStatic = variables.value(variableName) & ReferenceCount::Static;
 bool declareVariable = variables.value(variableName) & ReferenceCount::DeclareVariable;
 int access = variables.value(variableName) & ReferenceCount::AccessMask;
 if (actions == ReferenceCount::Ignore || !declareVariable)
 s << "package "; break; // qtd
 case ReferenceCount::Protected:
 s << "protected "; break;
 case ReferenceCount::Public:
 s << "public "; break;
-default:
+default: // friendly
-s << "protected"; // friendly
 }
 } // qtd2
 if (isStatic)
 // Enums aliaases
 foreach (AbstractMetaEnum *d_enum, d_class->enums())
 writeEnumAlias(s, d_enum);
 // Signals
 if (d_class->isQObject())
 {
 AbstractMetaFunctionList signal_funcs = signalFunctions(d_class, false);
 writeSignalSignatures(s, d_class, signal_funcs);
 foreach (AbstractMetaFunction *signal, signal_funcs)
 writeSignal(s, signal);
 }
 // Class has subclasses but also only private constructors
 {
 if (d_class->isQObject())
 writeQObjectFunctions(s, d_class);
 else
 writeObjectFunctions(s, d_class);
 if (d_class->isPolymorphic())
 {
 s << "    static QtdObjectBase __createWrapper(void* nativeId, QtdObjectFlags flags) {" << endl;
 QString className = d_class->name();
 if (d_class->isAbstract())
 className += "_ConcreteWrapper";
 s << "        auto obj = new(flags) " << className << "(nativeId, flags);" << endl;
 if (d_class->isQObject())
 s << "        qtd_" << d_class->name() << "_createEntity(nativeId, cast(void*)obj);" << endl;
 s << "        return obj;" << endl
 << "    }" << endl << endl;
 }
 }
-if (d_class->hasPublicDestructor() && (!d_class->baseClass() || !d_class->isPolymorphic()))
+if (d_class->hasPublicDestructor() && (!d_class->baseClass() || !d_class->hasVirtualFunctions()))
 writeDestructor(s, d_class);
 // Add dummy constructor for use when constructing subclasses
 if (!d_class->isNamespace() && !d_class->isInterface() && !fakeClass) {
 s << endl
 << INDENT << "public "
 << "this";
 Indentation indent(INDENT);
 QString flags = d_class->hasVirtualFunctions() && d_class->typeEntry()->isObject() ? "QtdObjectFlags.hasDId" : "QtdObjectFlags.none";
 s << "(void* nativeId, QtdObjectFlags flags = " << flags << ") {" << endl
 << INDENT << "super(nativeId, flags);" << endl;
 /*
 if (cpp_shared) {
 if (d_class->generateShellClass() && !d_class->isInterface())
 s << INDENT << "if (!static_inited)" << endl
 << INDENT << "    static_init_" << d_class->name() << "();" << endl << endl;
 }
 */
 // customized store-result instances
 d_funcs = d_class->functionsInTargetLang();
 for (int i=0; i<d_funcs.size(); ++i) {
 AbstractMetaFunction *d_function = d_funcs.at(i);
 uint included_attributes = 0;
 QString type_name = d_function->type()->name();
 const ComplexTypeEntry *ctype = static_cast<const ComplexTypeEntry *>(d_function->type()->typeEntry());
 if(ctype->isAbstract())
 type_name = type_name + "_ConcreteWrapper";
 s << INDENT << "    __m_" << d_function->name() << ";" << endl;
 }
 }
 // pointers to native interface objects for classes that implement interfaces
 // initializing
 AbstractMetaClass *iface = interfaces.at(i);
 s << INDENT << "private void* __m_ptr_" << iface->name() << ";" << endl
 << INDENT << "public void* __ptr_" << iface->name() << "() { return __m_ptr_" << iface->name() << "; }" << endl << endl;
 }
 }
 }
 /* qtd
 // Add a function that converts an array of the value type to a QNativePointer
 if (d_class->typeEntry()->isValue() && !fakeClass) {
 writeCloneFunction(s, d_class);
 }
 */
 s << "}" << endl;
 /* ---------------- injected free code ----------------*/
 const ComplexTypeEntry *class_type = d_class->typeEntry();
 Q_ASSERT(class_type);
 CodeSnipList code_snips = class_type->codeSnips();
 foreach (const CodeSnip &snip, code_snips) {
 if (!d_class->isInterface() && snip.language == TypeSystem::TargetLangFreeCode) {
 s << endl;
 snip.formattedCode(s, INDENT);
 }
 }
 /* --------------------------------------------------- */
 interfaces = d_class->interfaces();
 if (!interfaces.isEmpty()) {
 for (int i=0; i<interfaces.size(); ++i) {
 s << endl;
 s << INDENT << "public class " << d_class->name() << "_ConcreteWrapper : " << d_class->name() << " {" << endl;
 {
 Indentation indent(INDENT);
 s << INDENT << "public this(void* native_id, QtdObjectFlags flags) {" << endl
 << INDENT << "    super(native_id, flags);" << endl << endl;
 /******************!!!DUPLICATE!!!*********************/
 d_funcs = d_class->functionsInTargetLang();
 for (int i=0; i<d_funcs.size(); ++i) {
 AbstractMetaFunction *d_function = d_funcs.at(i);
 uint included_attributes = 0;
 QString type_name = d_function->type()->name();
 const ComplexTypeEntry *ctype = static_cast<const ComplexTypeEntry *>(d_function->type()->typeEntry());
 if(ctype->isAbstract())
 type_name = type_name + "_ConcreteWrapper";
 s << INDENT << "    __m_" << d_function->name() << " = new "
 << type_name << "(cast(void*)null);" << endl;
 }
 }
 s << INDENT << "}" << endl << endl;
 }
 }
 s  << INDENT << "}" << endl << endl;
 }
-if (d_class->typeEntry()->isObject() && d_class->isPolymorphic())
+if (d_class->isPolymorphic())
 {
 if (!d_class->typeEntry()->isQObject())
 {
 s << "extern(C) void* qtd_" << d_class->name() << "_dId(void *q_ptr);" << endl << endl;
 s << "extern(C) void* qtd_" << d_class->name() << "_typeId(void* nativeId);" << endl;
 }
 s << "extern(C) void* qtd_" << d_class->name() << "_staticTypeId();" << endl;
 }
 //    if (d_class->needsConversionFunc)
 //        writeConversionFunction(s, d_class);
 << QString("_initCallBacks(%1);").arg(initArgs) << endl << endl;
 }
 s << "extern(C) void static_init_" << d_class->name() << "() {" << endl;
-if (d_class->typeEntry()->isObject() && d_class->isPolymorphic()) {
+if (d_class->isPolymorphic()) {
 s << INDENT << "if (!" << d_class->name() << "._staticMetaObject) " << endl
 << INDENT << "    " << d_class->name() << ".createStaticMetaObject;" << endl << endl;
 }
 if (cpp_shared) {
 s << "}" << endl << endl;
 }
 */
 void DGenerator::writeObjectFunctions(QTextStream &s, const AbstractMetaClass *d_class)
 {
 // polymorphic
 if (d_class->isPolymorphic())
 {
 QString rootClassName = d_class->rootClass()->name();
 QString concreteArg;
 if (d_class->isAbstract())
 concreteArg += ", " + d_class->name() + "_ConcreteWrapper";
 s << "    private static QtdMetaObject _staticMetaObject;" << endl
 //<< "    private static QtdMetaObject[void*] _nativeToTargetMap;" << endl
 << "    protected static void createStaticMetaObject() {" << endl
 << "        assert(!_staticMetaObject);" << endl
 << "        QtdMetaObject base;" << endl;
 if (d_class->baseClass())
 QString baseName = d_class->baseClassName();
 s << "        if (!" << baseName << "._staticMetaObject)" << endl
 << "            " << baseName << ".createStaticMetaObject;" << endl
 << "        base = " << baseName << "._staticMetaObject;" << endl;
 }
 s << "        _staticMetaObject = new QtdMetaObject(qtd_" << d_class->name() << "_staticTypeId, base);"   << endl
 << "        _staticMetaObject.construct!(" << d_class->name() << concreteArg << ");" << endl
 << "    }" << endl << endl
 << "    QtdMetaObject metaObject() {" << endl
 << "        return _staticMetaObject;" << endl
 << "    }" << endl << endl
 << "    static QtdMetaObject staticMetaObject() {" << endl
 << "        return _staticMetaObject;" << endl
 << "    }" << endl << endl
-<< "    static " << d_class->name() << " __wrap(void* nativeId, QtdObjectFlags flags = QtdObjectFlags.skipNativeDelete) {" << endl
+<< "    static " << d_class->name() << " __wrap(void* nativeId, QtdObjectFlags flags = QtdObjectFlags.none) {" << endl
 << "        auto obj = cast("  << d_class->name() << ") qtd_" << rootClassName << "_dId(nativeId);" << endl
 << "        if (!obj)" << endl
 << "            obj = static_cast!(" << d_class->name() << ")(_staticMetaObject.wrap(nativeId, "
 "qtd_" << rootClassName << "_typeId(nativeId), flags));" << endl
 << "        return obj;" << endl
 << "    }" << endl << endl;
 }
 else
 {
-s << "    static " << d_class->name() << " __wrap(void* nativeId, QtdObjectFlags flags = QtdObjectFlags.skipNativeDelete) {" << endl
+s << "    static " << d_class->name() << " __wrap(void* nativeId, QtdObjectFlags flags = QtdObjectFlags.none) {" << endl
 << "        return new " << d_class->name() << "(nativeId, flags);"
 << "    }" << endl << endl;
 }
 }
 << "        return _staticMetaObject;" << endl
 << "    }" << endl << endl
 << "    static " << d_class->name() << " __wrap(void* nativeId, QtdObjectFlags flags = QtdObjectFlags.none) {" << endl
 << "        return static_cast!(" << d_class->name() << ")(_staticMetaObject.wrap(nativeId, flags));" << endl
 << "    }" << endl << endl;
 }
 /*
 void DGenerator::writeMarshallFunction(QTextStream &s, const AbstractMetaClass *d_class)
 {
 */
 void DGenerator::marshalToD(QTextStream &s, const ComplexTypeEntry *ctype)
 {
 if(ctype->isObject()) {
-if (ctype->isPolymorphic())
+s << "return " << ctype->name() << ".__wrap(ret);" << endl;
-s << "return " << ctype->name() << ".__wrap(ret);" << endl;
-else
-s << "return new " << ctype->name() << "(ret, QtdObjectFlags.skipNativeDelete);" << endl;
 } else if (ctype->isValue() && !ctype->isStructInD()) {
 s << INDENT << "return new " << ctype->name() << "(ret);" << endl;
 } else if (ctype->isVariant()) {
 s << INDENT << "return new QVariant(ret);" << endl;
 } else if (ctype->name() == "QModelIndex" || ctype->isStructInD()) {
 {
 s << INDENT << "private const string[" << signal_funcs.size() << "] __signalSignatures = [";
 {
 Indentation indent(INDENT);
 for (int i = 0; i < signal_funcs.size(); ++i)
 {
 if (i)
 s << ", ";
 s << endl << INDENT << "    \"" << signal_funcs.at(i)->minimalSignature() << "\"";
 }
 }
 s << INDENT << "];" << endl << endl;
 s << INDENT << "int signalSignature(int signalId, ref stringz signature) {" << endl;
 {
 Indentation indent(INDENT);
 if (d_class->name() != "QObject")
 {
 s << INDENT << "signalId = super.signalSignature(signalId, signature);" << endl
 << INDENT << "if (signature)" << endl
 << INDENT << "    return signalId;" << endl;
 }
 s << INDENT << "if (signalId < __signalSignatures.length)" << endl
 << INDENT << "    signature = __signalSignatures[signalId].ptr;" << endl
 << INDENT << "else" << endl
 << INDENT << "    signalId -= __signalSignatures.length;" << endl
 << INDENT << "return signalId;" << endl;
 s << INDENT << "auto d_object = cast(" << own_class->name() << ") d_entity;" << endl;
 // the function arguments
 AbstractMetaArgumentList arguments = d_function->arguments();
-foreach (const AbstractMetaArgument *argument, arguments)
+foreach (const AbstractMetaArgument *argument, arguments) {
 if (!d_function->argumentRemoved(argument->argumentIndex() + 1)) {
 QString arg_name = argument->indexedName();
 AbstractMetaType *type = argument->type();
 // if has QString argument we have to pass char* and str.length to QString constructor
 {
 }
 else if (type->typeEntry()->isStructInD())
 continue;
 else if (type->typeEntry()->isValue() || (type->typeEntry()->isValue() && type->isNativePointer())){
 s << INDENT << "scope " << arg_name << "_d_ref = new " << type->typeEntry()->name() << "(" << arg_name << ", QtdObjectFlags.skipNativeDelete);" << endl;
 }
 else if (!type->hasNativeId())
 continue;
-else if (type->isObject() || type->isQObject())
+else if (type->typeEntry()->isObject())
 {
 bool resetAfterUse = !type->isQObject() && d_function->resetObjectAfterUse(argument->argumentIndex() + 1);
 if ((static_cast<const ComplexTypeEntry*>(type->typeEntry()))->isPolymorphic())
 {
 QString flags;
 if (resetAfterUse)
 flags = "QtdObjectFlags.stackAllocated | QtdObjectFlags.skipNativeDelete";
-else if (type->isQObject())
+else
 flags = "QtdObjectFlags.none";
-else
-flags = "QtdObjectFlags.skipNativeDelete";
 s << INDENT << "auto " << arg_name << "_d_ref = " << type->typeEntry()->name() << ".__wrap(" << arg_name
 << ", cast(QtdObjectFlags)(" << flags << "));" << endl;
 if (resetAfterUse)
 {
 s << INDENT << "scope(exit) {" << endl
 << INDENT << "    if (" << arg_name << "_d_ref.__flags & QtdObjectFlags.stackAllocated)" << endl
 << INDENT << "        delete " << arg_name << ";" << endl
 << INDENT << "}" << endl;
 }
 }
 else
 {
 s << INDENT << (resetAfterUse ? "scope " : "auto ")
-<< arg_name << "_d_ref = new " << type->typeEntry()->name() << "(" << arg_name << ", QtdObjectFlags.skipNativeDelete);";
+<< arg_name << "_d_ref = new " << type->typeEntry()->name() << "(" << arg_name << ", QtdObjectFlags."
+<< (resetAtferUse ? "skipNativeDelete" : "none") << ");" << endl;
 }
 }
 else
 qFatal(qPrintable(type->typeEntry()->name()));
 s << endl;
 }
+}
 }
 s << INDENT;
 AbstractMetaType *return_type = d_function->type();
 QString new_return_type = QString(d_function->typeReplaced(0)).replace('$', '.');
 bool has_return_type = new_return_type != "void"
 && (!new_return_type.isEmpty() || return_type != 0);
 if(has_return_type) {
 AbstractMetaType *f_type = d_function->type();
 if(f_type && (f_type->isObject() || f_type->isQObject() || f_type->isVariant() ||
 (f_type->isValue() && !f_type->typeEntry()->isStructInD())))
 {
 QString f_type_name = f_type->name();
 if(f_type->typeEntry()->designatedInterface())
 s << f->implementingClass()->fullName() << " : " << f->minimalSignature() << endl;
 }
 }
 file.close();
 }
 delete logstream;
 delete log;
 }
 void DGenerator::writeFunctionAttributes(QTextStream &s, const AbstractMetaFunction *d_function,

Mercurial > projects > qtd

comparison generator/dgenerator.cpp @ 262:90131f64c9c9 lifetime