void CppGenerator::writeFunctionArguments(QTextStream &s,
const AbstractMetaArgumentList &arguments,
Option option,
int numArguments)
{
if (numArguments < 0) numArguments = arguments.size();
for (int i=0; i<numArguments; ++i) {
if (i != 0)
s << ", ";
AbstractMetaArgument *arg = arguments.at(i);
writeTypeInfo(s, arg->type(), option);
if (!(option & SkipName))
s << " " << arg->indexedName();
if ((option & IncludeDefaultExpression) && !arg->originalDefaultValueExpression().isEmpty()) {
s << " = ";
QString expr = arg->originalDefaultValueExpression();
if (arg->type()->typeEntry()->isEnum() && expr.indexOf("::") < 0)
s << ((EnumTypeEntry *)arg->type()->typeEntry())->qualifier() << "::";
s << expr;
}
}
}
void QDocGenerator::write(QTextStream &s, const AbstractMetaFunction *java_function) {
AbstractMetaArgumentList arguments = java_function->arguments();
int argument_count = arguments.size();
int overload_count = 0;
for (int i = 0; i < argument_count; ++i) {
if (!arguments.at(i)->defaultValueExpression().isEmpty())
++overload_count;
}
for (int i = 0; i <= overload_count; ++i) {
writeOverload(s, java_function, argument_count - i);
}
}
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 ShellGenerator::writeFunctionArguments(QTextStream &s, const AbstractMetaClass* owner,
const AbstractMetaArgumentList &arguments,
Option option,
int numArguments)
{
if (numArguments < 0) numArguments = arguments.size();
for (int i=0; i<numArguments; ++i) {
if (i != 0)
s << ", ";
AbstractMetaArgument *arg = arguments.at(i);
writeTypeInfo(s, arg->type(), option);
if (!(option & SkipName)) {
if (option & UseIndexedName) {
s << " " << arg->indexedName();
}
else {
s << " " << arg->argumentName();
}
}
if ((option & IncludeDefaultExpression) && !arg->defaultValueExpression().isEmpty()) {
s << " = ";
QString expr = arg->defaultValueExpression();
if (expr != "0") {
QString qualifier;
if (arg->type()->typeEntry()->isEnum() && expr.indexOf("::") < 0) {
qualifier = ((EnumTypeEntry *)arg->type()->typeEntry())->qualifier();
} else if (arg->type()->typeEntry()->isFlags() && expr.indexOf("::") < 0) {
qualifier = ((FlagsTypeEntry *)arg->type()->typeEntry())->originator()->qualifier();
}
if (!qualifier.isEmpty()) {
s << qualifier << "::";
}
}
s << expr;
}
}
}
\
void func(C c);\
";
const char* xmlCode = "<typesystem package=\"Foo\">\
<container-type name='A' type='list'/>\
<value-type name='B' />\
<function signature='func(A<B>)' />\
</typesystem>";
TestUtil t(cppCode, xmlCode);
AbstractMetaClassList classes = t.builder()->classes();
QCOMPARE(classes.size(), 1);
AbstractMetaFunctionList functions = t.builder()->globalFunctions();
QCOMPARE(functions.count(), 1);
AbstractMetaFunction* function = functions.first();
AbstractMetaArgumentList args = function->arguments();
QCOMPARE(args.count(), 1);
AbstractMetaArgument* arg = args.first();
AbstractMetaType* metaType = arg->type();
QCOMPARE(metaType->cppSignature(), QString("A<B >"));
}
void TestAbstractMetaType::testObjectTypeUsedAsValue()
{
const char* cppCode ="\
class A {\
void method(A);\
};\
";
const char* xmlCode = "<typesystem package='Foo'>\
void CppGenerator::writeFunctionSignature(QTextStream &s,
const AbstractMetaFunction *java_function,
const AbstractMetaClass *implementor,
const QString &name_prefix,
Option option,
const QString &classname_prefix,
const QStringList &extra_arguments,
int numArguments)
{
// ### remove the implementor
AbstractMetaType *function_type = java_function->type();
if (java_function->isStatic() && (option & ShowStatic))
s << "static ";
if ((option & SkipReturnType) == 0) {
if (function_type) {
writeTypeInfo(s, function_type, option);
s << " ";
} else if (!java_function->isConstructor()) {
s << "void ";
}
}
if (implementor) {
if (classname_prefix.isEmpty())
s << shellClassName(implementor) << "::";
else
s << classname_prefix << implementor->name() << "::";
}
QString function_name;
if (option & OriginalName)
function_name = java_function->originalName();
else
function_name = java_function->name();
if (option & UnderscoreSpaces)
function_name = function_name.replace(' ', '_');
if (java_function->isConstructor())
function_name = shellClassName(java_function->ownerClass());
s << name_prefix << function_name;
if (java_function->attributes() & AbstractMetaAttributes::SetterFunction)
s << "_setter";
else if (java_function->attributes() & AbstractMetaAttributes::GetterFunction)
s << "_getter";
s << "(";
const AbstractMetaClass *owner = java_function->ownerClass();
bool has_d_ptr = java_function->isConstructor() && owner && (owner->isPolymorphic()/* || owner->typeEntry()->isObject()*/ );
const AbstractMetaArgumentList arg_list = java_function->arguments();
if (has_d_ptr) {
s << "void *d_ptr";
if (arg_list.size() > 0)
s << ", ";
}
writeFunctionArguments(s, arg_list, option, numArguments);
// The extra arguments...
for (int i=0; i<extra_arguments.size(); ++i) {
if (i > 0 || java_function->arguments().size() != 0)
s << ", ";
s << extra_arguments.at(i);
}
s << ")";
if (java_function->isConstant())
s << " const";
}
