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;
}
