void Assembler::assemblyFunction(Core::FunType::PtrType fun, Core::Environment* env) { if (fun->body == NULL) return; std::ostringstream ss; Core::AbstractScope::PtrType global_scope(new Core::GlobalScope(env)); Core::BlockScope::PtrType function_scope(new Core::BlockScope(global_scope)); for (int i = 0; i < fun->args.size(); i++) { function_scope->define(fun->idents[i], fun->args[i]->toLValue()); } Core::BlockScope::PtrType body_scope(new Core::BlockScope(function_scope)); std::cout << "; " << fun->name << std::endl; std::cout << ".method public static " << functionSignature(fun) << std::endl; StmtAssembler ass(body_scope, env, ss); fun->body->sblock_->accept(&ass); std::cout << ".limit stack " << ass.stackLimit << std::endl; std::cout << ".limit locals " << global_scope->maxIx() << std::endl; std::cout << ss.str(); if (fun->ret_type->getType() == Core::VOID) std::cout << " return" << std::endl; std::cout << ".end method" << std::endl << std::endl; };
void MetaInfoGenerator::writeSignalsAndSlots(QTextStream &s, const QString &package) { AbstractMetaClassList classes = this->classes(); QList<QString> strs; foreach (AbstractMetaClass *cls, classes) { if (cls->package() == package) { AbstractMetaFunctionList functions = cls->functions(); foreach (AbstractMetaFunction *f, functions) { if (f->implementingClass() == cls && (f->isSignal() || f->isSlot())) { AbstractMetaArgumentList arguments = f->arguments(); int numOverloads = arguments.size(); for (int i=arguments.size()-1; i>=0; --i) { if (arguments.at(i)->defaultValueExpression().isEmpty()) { numOverloads = arguments.size() - i - 1; break; } } for (int i=0; i<=numOverloads; ++i) { Option option = Option(SkipAttributes | SkipReturnType | SkipName); QString qtName; { QTextStream qtNameStream(&qtName); CppGenerator::writeFunctionSignature(qtNameStream, f, 0, QString(), Option(option | OriginalName | NormalizeAndFixTypeSignature | OriginalTypeDescription), QString(), QStringList(), arguments.size() - i); } qtName = f->implementingClass()->qualifiedCppName() + "::" + qtName; qtName = QMetaObject::normalizedSignature(qtName.toLatin1().constData()); QString javaFunctionName = functionSignature(f, 0, 0, option, arguments.size() - (f->isSignal() ? 0 : i)); QString javaObjectName = f->isSignal() ? f->name() : javaFunctionName; javaFunctionName = f->implementingClass()->fullName() + "." + javaFunctionName; javaObjectName = f->implementingClass()->fullName() + "." + javaObjectName; QString javaSignature = "("; for (int j=0; j < (arguments.size() - (f->isSignal() ? 0 : i)); ++j) { AbstractMetaArgument *arg = arguments.at(j); javaSignature += jni_signature(arg->type(), SlashesAndStuff); } javaSignature += ")" + jni_signature(f->type(), SlashesAndStuff); strs.append(qtName); strs.append(javaFunctionName); strs.append(javaObjectName); strs.append(javaSignature); } } } } }
void QDocGenerator::writeOverload(QTextStream &s, const AbstractMetaFunction *java_function, int arg_count) { if (java_function->isModifiedRemoved(TypeSystem::TargetLangCode)) return; uint included_attributes = NoBlockedSlot; uint excluded_attributes = 0; setupForFunction(java_function, &included_attributes, &excluded_attributes); if (arg_count < java_function->arguments().size()) { // see JavaGenerator::writeFunctionOverloads() if (!java_function->isConstructor()) included_attributes |= AbstractMetaAttributes::Final; excluded_attributes |= AbstractMetaAttributes::Abstract | AbstractMetaAttributes::Native; } QString signature = functionSignature(java_function, included_attributes, excluded_attributes, NoOption, arg_count); s << "<method java=\"" << protect(signature.toUtf8()) << "\"" << endl << " cpp=\"" << protect(java_function->signature().toUtf8()) << "\"" << endl; FunctionModificationList mods = java_function->modifications(java_function->implementingClass()); QList<ArgumentModification> argumentMods; foreach(const FunctionModification &m, mods) { if (!m.association.isEmpty()) s << " association=\"" << m.association << "\"" << endl; if (m.modifiers & Modification::AccessModifierMask) s << " access-change=\"" << m.accessModifierString() << "\"" << endl; if (m.modifiers & Modification::Rename) s << " renamed=\"" << m.renamedToName << "\"" << endl; if (m.modifiers & (Modification::FinalMask)) { s << " final=\"" << ((m.modifiers & Modification::Final) ? "final" : "non-final") << "\"" << endl; } if (m.modifiers & Modification::Deprecated) s << " deprecated=\"yes\"" << endl; if (m.removal) s << " removal=\"" << m.removal << "\"" << endl; argumentMods << m.argument_mods; } AbstractMetaArgumentList arguments = java_function->arguments(); bool wroteOwnershipStolen = false; foreach(AbstractMetaArgument *argument, arguments) { if (java_function->disabledGarbageCollection(java_function->implementingClass(), argument->argumentIndex() + 1)) { if (!wroteOwnershipStolen) { s << endl << " steals-ownership-of=\""; wroteOwnershipStolen = true; } else { s << ","; } s << protect(argument->argumentName().toUtf8()); } } if (wroteOwnershipStolen) s << "\""; s << ">" << endl; if (argumentMods.size()) { foreach(const ArgumentModification &m, argumentMods) { s << " <argument index=\"" << m.index << "\"" << endl; if (m.removed_default_expression) s << " remove-default-expression=\"yes\"" << endl; if (m.removed) s << " removed=\"yes\"" << endl; if (m.no_null_pointers) s << " no-null=\"yes\"" << endl; if (!m.modified_type.isEmpty()) s << " modified-type=\"" << protect(m.modified_type.toLatin1()) << "\"" << endl; if (!m.replaced_default_expression.isEmpty()) { s << " default-expression=\"" << protect(m.replaced_default_expression.toUtf8()) << "\"" << endl; } if (!m.referenceCounts.isEmpty()) s << " reference-counted=\"...\"" << endl; s << "/>" << endl; }