static void print_type_eng(type *ref)
{
if(!ref)
return;
print_type_eng(ref->ref);
switch(ref->type){
case type_auto:
ICE("__auto_type");
case type_cast:
if(ref->bits.cast.is_signed_cast)
fprintf(cc1_out, "%s ", ref->bits.cast.signed_true ? "signed" : "unsigned");
else
fprintf(cc1_out, "%s", type_qual_to_str(ref->bits.cast.qual, 1));
break;
case type_ptr:
fprintf(cc1_out, "pointer to ");
break;
case type_block:
fprintf(cc1_out, "block returning ");
break;
case type_func:
{
#ifdef ENGLISH_PRINT_ARGLIST
funcargs *fargs = ref->bits.func.args;
decl **iter;
#endif
fputs("function", cc1_out);
#ifdef ENGLISH_PRINT_ARGLIST
fputc('(', cc1_out);
if(fargs->arglist){
for(iter = fargs->arglist; iter && *iter; iter++){
print_decl(*iter, PDECL_NONE);
if(iter[1])
fputs(", ", cc1_out);
}
if(fargs->variadic)
fputs("variadic", cc1_out);
}else{
fprintf(cc1_out, "taking %s arguments", fargs->args_void ? "no" : "unspecified");
}
fputc(')', cc1_out);
#endif
fputs(" returning ", cc1_out);
break;
}
case type_array:
fputs("array[", cc1_out);
if(ref->bits.array.size)
print_expr_val(ref->bits.array.size);
fputs("] of ", cc1_out);
break;
case type_btype:
fprintf(cc1_out, "%s", btype_to_str(ref->bits.type));
break;
case type_tdef:
case type_attr:
ICE("TODO");
case type_where:
break;
}
}
static
type *type_add_type_str(type *r,
char **bufp, int *sz,
enum type_str_opts const opts)
{
/* go down to the first type or typedef, print it and then its descriptions */
type *ty;
**bufp = '\0';
for(ty = r;
ty && ty->type != type_btype;
ty = ty->ref)
{
if((opts & TY_STR_NO_TDEF) == 0 && ty->type == type_tdef)
break;
}
if(!ty)
return NULL;
if(ty->type == type_tdef){
char buf[BTYPE_STATIC_BUFSIZ];
decl *d = ty->bits.tdef.decl;
type *of;
if(d){
BUF_ADD("%s", d->spel);
of = d->ref;
}else{
expr *const e = ty->bits.tdef.type_of;
int const is_type = !e->expr;
BUF_ADD("typeof(%s%s)",
/* e is always expr_sizeof() */
is_type ? "" : "expr: ",
is_type ? type_to_str_r_spel_opts(buf, e->tree_type, NULL, TY_STR_NOOPT)
: e->expr->f_str());
/* don't show aka for typeof types - it's there already */
of = is_type ? NULL : e->tree_type;
}
if((opts & TY_STR_AKA) && of){
/* descend to the type if it's next */
type *t_ref = type_is_primitive(of, type_unknown);
const btype *t = t_ref ? t_ref->bits.type : NULL;
BUF_ADD(" (aka '%s')",
t ? btype_to_str(t)
: type_to_str_r_spel_opts(buf, type_skip_tdefs(of), NULL, TY_STR_NOOPT));
}
return ty;
}else{
BUF_ADD("%s", btype_to_str(ty->bits.type));
}
return NULL;
}
