static void print_modifiers(decl_modifiers_t const modifiers)
{
if (modifiers == 0)
return;
static const struct {
unsigned bit;
const char *name;
} modifiernames[] = {
{ DM_NAKED, "naked" },
{ DM_NOTHROW, "nothrow" },
{ DM_NORETURN, "noreturn" },
{ DM_NOINLINE, "noinline" },
{ DM_NOALIAS, "noalias" },
{ DM_TRANSPARENT_UNION, "transparent_union" },
{ DM_CONST, "const" },
{ DM_PURE, "pure" },
{ DM_CONSTRUCTOR, "constructor" },
{ DM_DESTRUCTOR, "destructor" },
{ DM_UNUSED, "unused" },
{ DM_USED, "used" },
{ DM_RETURNS_TWICE, "returns_twice" },
{ DM_MALLOC, "malloc" },
{ DM_WEAK, "weak" },
{ DM_LEAF, "leaf" },
{ DM_PACKED, "packed" },
};
separator_t sep = { " __attribute__((", ", " };
for (size_t i = 0; i < ARRAY_SIZE(modifiernames); ++i) {
if (modifiers & modifiernames[i].bit)
print_format("%s__%s__", sep_next(&sep), modifiernames[i].name);
}
if (!sep_at_first(&sep))
print_string("))");
}
void print_function_signature(const type_t *const type, const scope_t *parameters)
{
separator_t sep = { "", ", " };
print_char('(');
for (entity_t const *parameter = parameters->first_entity;
parameter != NULL; parameter = parameter->base.next) {
if (parameter->kind != ENTITY_PARAMETER)
continue;
print_string(sep_next(&sep));
const type_t *const param_type = parameter->declaration.type;
if (param_type == NULL) {
//print_string(parameter->base.symbol->string);
print_string("TODO: NULL param_type");
} else {
print_string("mut ");
print_type_ext(param_type, parameter->base.symbol, NULL);
}
}
print_char(')');
if (type->function.return_type) {
print_string(" -> ");
print_type(type->function.return_type);
}
}
/**
* Print the second part (the postfix) of a type.
*
* @param type The type to print.
*/
static void print_function_type_post(const function_type_t *type,
const scope_t *parameters)
{
print_char('(');
separator_t sep = { "", ", " };
if (parameters == NULL) {
function_parameter_t *parameter = type->parameters;
for ( ; parameter != NULL; parameter = parameter->next) {
print_string(sep_next(&sep));
print_type(parameter->type);
}
} else {
for (entity_t const *parameter = parameters->first_entity;
parameter != NULL; parameter = parameter->base.next) {
if (parameter->kind != ENTITY_PARAMETER)
continue;
print_string(sep_next(&sep));
const type_t *const param_type = parameter->declaration.type;
if (param_type == NULL) {
print_string(parameter->base.symbol->string);
} else {
print_type_ext(param_type, parameter->base.symbol, NULL);
}
}
}
if (type->variadic) {
print_string(sep_next(&sep));
print_string("...");
}
if (sep_at_first(&sep) && !type->unspecified_parameters) {
print_string("void");
}
print_char(')');
print_modifiers(type->modifiers);
intern_print_type_post(type->return_type);
}
static void write_function(const entity_t *entity)
{
if (entity->function.body != NULL) {
fprintf(stderr, "Warning: can't convert function bodies (at %s)\n",
entity->base.symbol->string);
return;
}
const function_type_t *function_type
= (const function_type_t*) entity->declaration.type;
fputc('\n', out);
fprintf(out, "\tpublic static native ");
type_t *return_type = skip_typeref(function_type->return_type);
write_type(return_type);
fprintf(out, " %s(", entity->base.symbol->string);
entity_t *parameter = entity->function.parameters.entities;
separator_t sep = { "", ", " };
int n = 0;
for ( ; parameter != NULL; parameter = parameter->base.next) {
assert(parameter->kind == ENTITY_PARAMETER);
fputs(sep_next(&sep), out);
write_type(parameter->declaration.type);
if (parameter->base.symbol != NULL) {
fprintf(out, " %s", fix_builtin_names(parameter->base.symbol->string));
} else {
fprintf(out, " _%d", n++);
}
}
if (function_type->variadic) {
fputs(sep_next(&sep), out);
fputs("Object ... args", out);
}
fprintf(out, ");\n");
}
