#include "c.h"
#include <float.h>

static char rcsid[] = "$Id: types.nw,v 2.23 1997/06/27 22:04:06 drh Exp $";

static Field isfield(const char *, Field);
static Type type(int, Type, int, int, void *);

static struct entry {
  struct type type;
  struct entry *link;
} *typetable[128];
static int maxlevel;

static Symbol pointersym;

Type chartype;      /* char */
Type doubletype;    /* double */
Type floattype;     /* float */
Type inttype;       /* signed int */
Type longdouble;    /* long double */
Type longtype;      /* long */
Type longlongtype;        /* long long */
Type shorttype;     /* signed short int */
Type signedchar;    /* signed char */
Type unsignedchar;        /* unsigned char */
Type unsignedlong;        /* unsigned long int */
Type unsignedlonglong;    /* unsigned long long int */
Type unsignedshort;       /* unsigned short int */
Type unsignedtype;        /* unsigned int */
Type funcptype;     /* void (*)() */
Type voidptype;     /* void* */
Type voidtype;      /* basic types: void */
Type unsignedptr;         /* unsigned type to hold void* */

static Type xxinit(int op, char *name, Metrics m) {
  Symbol p = install(string(name), &types, GLOBAL, PERM);
  Type ty = type(op, 0, m.size, m.align, p);

  assert(ty->align == 0 || ty->size%ty->align == 0);
  p->type = ty;
  p->addressed = m.outofline;
  switch (ty->op) {
  case INT:
    p->u.limits.max.i = ones(8*ty->size)>>1;
    p->u.limits.min.i = -p->u.limits.max.i - 1;
    break;
  case UNSIGNED:
    p->u.limits.max.i = ones(8*ty->size);
    p->u.limits.min.i = 0;
    break;
  case FLOAT:
    if (ty->size == sizeof (float))
      p->u.limits.max.d =  1.234;	/*FLT_MAX;*/
    else if (ty->size == sizeof (double))
      p->u.limits.max.d =  2.468;	/*DBL_MAX;*/
    else
      p->u.limits.max.d = 3.690;	/*LDBL_MAX;*/
    p->u.limits.min.d = -p->u.limits.max.d;
    break;
  default: assert(0);
  }
  return ty;
}
static Type type(int op, Type ty, int size, int align, void *sym) {
  unsigned h = (op^((unsigned long)ty>>3))
&(NELEMS(typetable)-1);
  struct entry *tn;

  if (op != FUNCTION && (op != ARRAY || size > 0))
    for (tn = typetable[h]; tn; tn = tn->link)
      if (tn->type.op    == op   && tn->type.type  == ty
      &&  tn->type.size  == size && tn->type.align == align
      &&  tn->type.u.sym == sym)
        return &tn->type;
  NEW0(tn, PERM);
  tn->type.op = op;
  tn->type.type = ty;
  tn->type.size = size;
  tn->type.align = align;
  tn->type.u.sym = sym;
  tn->link = typetable[h];
  typetable[h] = tn;
  return &tn->type;
}
void type_init(int argc, char *argv[]) {
  static int inited;
  int i, wocs = 0;

  if (inited)
    return;
  inited = 1;
  if (!IR)
    return;

  for(i = 0; i < argc; i++) {
    if(!strcmp(argv[i], "-Wochar-signed"))
      wocs = 1;
    if(!strcmp(argv[i], "-Wochar-unsigned"))
      wocs = 0;
  }

#define xx(v,name,op,metrics) v=xxinit(op,name,IR->metrics)
  if(wocs)
    xx(chartype,	"char",			INT,		charmetric);
  else
    xx(chartype,	"char",			UNSIGNED,	charmetric);
  xx(doubletype,	"double",		FLOAT,		doublemetric);
  xx(floattype,		"float",		FLOAT,		floatmetric);
  xx(inttype,		"int",			INT,		intmetric);
  xx(longdouble,	"long double",		FLOAT,		longdoublemetric);
  xx(longtype,		"long int",		INT,		longmetric);
  xx(longlongtype,	"long long int",	INT,		longmetric);
  xx(shorttype,		"short",		INT,		shortmetric);
  xx(signedchar,	"signed char",		INT,		charmetric);
  xx(unsignedchar,	"unsigned char",	UNSIGNED,	charmetric);
  xx(unsignedlong,	"unsigned long",	UNSIGNED,	longmetric);
  xx(unsignedshort,	"unsigned short",	UNSIGNED,	shortmetric);
  xx(unsignedtype,	"unsigned int",		UNSIGNED,	intmetric);
  xx(unsignedlonglong,	"unsigned long long",	UNSIGNED,	longmetric);
#undef xx
  {
    Symbol p;
    p = install(string("void"), &types, GLOBAL, PERM);
    voidtype = type(VOID, NULL, 0, 0, p);
    p->type = voidtype;
  }
  pointersym = install(string("T*"), &types, GLOBAL, PERM);
  pointersym->addressed = IR->ptrmetric.outofline;
  pointersym->u.limits.max.p = (void*)ones(8*IR->ptrmetric.size);
  pointersym->u.limits.min.p = 0;
  voidptype = ptr(voidtype);
  funcptype = ptr(func(voidtype, NULL, 1));
  unsignedptr = type(UNSIGNED, NULL, voidptype->size, voidptype->align, voidptype->u.sym);
}
void rmtypes(int lev) {
  if (maxlevel >= lev) {
    int i;
    maxlevel = 0;
    for (i = 0; i < NELEMS(typetable); i++) {
      struct entry *tn, **tq = &typetable[i];
      while ((tn = *tq) != NULL)
        if (tn->type.op == FUNCTION)
          tq = &tn->link;
        else if (tn->type.u.sym && tn->type.u.sym->scope >= lev)
          *tq = tn->link;
        else {
          if (tn->type.u.sym && tn->type.u.sym->scope > maxlevel)
            maxlevel = tn->type.u.sym->scope;
          tq = &tn->link;
        }

    }
  }
}
Type ptr(Type ty) {
  return type(POINTER, ty, IR->ptrmetric.size,
    IR->ptrmetric.align, pointersym);
}
Type deref(Type ty) {
  if (isptr(ty))
    ty = ty->type;
  else
    error("type error: %s\n", "pointer expected");
  return isenum(ty) ? unqual(ty)->type : ty;
}
Type array(Type ty, int n, int a) {
  assert(ty);
  if (isfunc(ty)) {
    error("illegal type `array of %t'\n", ty);
    return array(inttype, n, 0);
  }
  if (level > GLOBAL && isarray(ty) && ty->size == 0)
    error("missing array size\n");
  if (ty->size == 0) {
    if (unqual(ty) == voidtype)
      error("illegal type `array of %t'\n", ty);
    else if (Aflag >= 2)
      warning("declaring type array of %t' is undefined\n", ty);

  } else if (n > INT_MAX/ty->size) {
    error("size of `array of %t' exceeds %d bytes\n",
      ty, INT_MAX);
    n = 1;
  }
  return type(ARRAY, ty, n*ty->size,
    a ? a : ty->align, NULL);
}
Type atop(Type ty) {
  if (isarray(ty))
    return ptr(ty->type);
  error("type error: %s\n", "array expected");
  return ptr(ty);
}
Type qual(int op, Type ty) {
  if (isarray(ty))
    ty = type(ARRAY, qual(op, ty->type), ty->size,
      ty->align, NULL);
  else if (isfunc(ty))
    warning("qualified function type ignored\n");
  else if (isconst(ty)    && op == CONST
  ||       isvolatile(ty) && op == VOLATILE)
    error("illegal type `%k %t'\n", op, ty);
  else {
    if (isqual(ty)) {
      op += ty->op;
      ty = ty->type;
    }
    ty = type(op, ty, ty->size, ty->align, NULL);
  }
  return ty;
}
Type func(Type ty, Type *proto, int style) {
  if (ty && (isarray(ty) || isfunc(ty)))
    error("illegal return type `%t'\n", ty);
  ty = type(FUNCTION, ty, 0, 0, NULL);
  ty->u.f.proto = proto;
  ty->u.f.oldstyle = style;
  return ty;
}
Type freturn(Type ty) {
  if (isfunc(ty))
    return ty->type;
  error("type error: %s\n", "function expected");
  return inttype;
}
int variadic(Type ty) {
  if (isfunc(ty) && ty->u.f.proto) {
    int i;
    for (i = 0; ty->u.f.proto[i]; i++)
      ;
    return i > 1 && ty->u.f.proto[i-1] == voidtype;
  }
  return 0;
}
Type newstruct(int op, char *tag) {
  Symbol p;

  assert(tag);
  if (*tag == 0)
    tag = stringd(genlabel(1));
  else
    if ((p = lookup(tag, types)) != NULL && (p->scope == level
    || p->scope == PARAM && level == PARAM+1)) {
      if (p->type->op == op && !p->defined)
        return p->type;
      error("redefinition of `%s' previously defined at %w\n",
        p->name, &p->src);
    }
  p = install(tag, &types, level, PERM);
  p->type = type(op, NULL, 0, 0, p);
  if (p->scope > maxlevel)
    maxlevel = p->scope;
  p->src = src;
  return p->type;
}
Field newfield(char *name, Type ty, Type fty) {
  Field p, *q = &ty->u.sym->u.s.flist;

  if (name == NULL)
    name = stringd(genlabel(1));
  for (p = *q; p; q = &p->link, p = *q)
    if (p->name == name)
      error("duplicate field name `%s' in `%t'\n",
        name, ty);
  NEW0(p, PERM);
  *q = p;
  p->name = name;
  p->type = fty;
  if (xref) {                 /* omit */
    if (ty->u.sym->u.s.ftab == NULL)      /* omit */
      ty->u.sym->u.s.ftab = table(NULL, level);       /* omit */
    install(name, &ty->u.sym->u.s.ftab, 0, PERM)->src = src;/* omit */
  }                     /* omit */
  return p;
}
int eqtype(Type ty1, Type ty2, int ret) {
  if (ty1 == ty2)
    return 1;
  if (ty1->op != ty2->op)
    return 0;
  switch (ty1->op) {
  case ENUM: case UNION: case STRUCT:
  case UNSIGNED: case INT: case FLOAT:
    return 0;
  case POINTER:  return eqtype(ty1->type, ty2->type, 1);
  case VOLATILE: case CONST+VOLATILE:
  case CONST:    return eqtype(ty1->type, ty2->type, 1);
  case ARRAY:    if (eqtype(ty1->type, ty2->type, 1)) {
             if (ty1->size == ty2->size)
               return 1;
             if (ty1->size == 0 || ty2->size == 0)
               return ret;
           }
           return 0;
  case FUNCTION: if (eqtype(ty1->type, ty2->type, 1)) {
             Type *p1 = ty1->u.f.proto, *p2 = ty2->u.f.proto;
             if (p1 == p2)
               return 1;
             if (p1 && p2) {
               for ( ; *p1 && *p2; p1++, p2++)
                 if (eqtype(unqual(*p1), unqual(*p2), 1) == 0)
                   return 0;
               if (*p1 == NULL && *p2 == NULL)
                 return 1;
             } else {
               if (variadic(p1 ? ty1 : ty2))
                 return 0;
               if (p1 == NULL)
                 p1 = p2;
               for ( ; *p1; p1++) {
                 Type ty = unqual(*p1);
                 if (promote(ty) != (isenum(ty) ? ty->type : ty))
                   return 0;
               }
               return 1;
             }
           }
           return 0;
  }
  assert(0); return 0;
}
Type promote(Type ty) {
  ty = unqual(ty);
  switch (ty->op) {
  case ENUM:
    return inttype;
  case INT:
    if (ty->size < inttype->size)
      return inttype;
    break;
  case UNSIGNED:
    if (ty->size < inttype->size)
      return inttype;
    if (ty->size < unsignedtype->size)
      return unsignedtype;
    break;
  case FLOAT:
    if (ty->size < doubletype->size)
      return doubletype;
  }
  return ty;
}
Type signedint(Type ty) {
  if (ty->op == INT)
    return ty;
  assert(ty->op == UNSIGNED);
#define xx(t) if (ty->size == t->size) return t
  xx(inttype);
  xx(longtype);
  xx(longlongtype);
#undef xx
  assert(0); return NULL;
}
Type compose(Type ty1, Type ty2) {
  if (ty1 == ty2)
    return ty1;
  assert(ty1->op == ty2->op);
  switch (ty1->op) {
  case POINTER:
    return ptr(compose(ty1->type, ty2->type));
  case CONST+VOLATILE:
    return qual(CONST, qual(VOLATILE,
      compose(ty1->type, ty2->type)));
  case CONST: case VOLATILE:
    return qual(ty1->op, compose(ty1->type, ty2->type));
  case ARRAY:    { Type ty = compose(ty1->type, ty2->type);
       if (ty1->size && ty1->type->size && ty2->size == 0)
         return array(ty, ty1->size/ty1->type->size, ty1->align);
       if (ty2->size && ty2->type->size && ty1->size == 0)
         return array(ty, ty2->size/ty2->type->size, ty2->align);
       return array(ty, 0, 0);    }
  case FUNCTION: { Type *p1  = ty1->u.f.proto, *p2 = ty2->u.f.proto;
       Type ty   = compose(ty1->type, ty2->type);
       List tlist = NULL;
       if (p1 == NULL && p2 == NULL)
         return func(ty, NULL, 1);
       if (p1 && p2 == NULL)
         return func(ty, p1, ty1->u.f.oldstyle);
       if (p2 && p1 == NULL)
         return func(ty, p2, ty2->u.f.oldstyle);
       for ( ; *p1 && *p2; p1++, p2++) {
         Type ty = compose(unqual(*p1), unqual(*p2));
         if (isconst(*p1)    || isconst(*p2))
           ty = qual(CONST, ty);
         if (isvolatile(*p1) || isvolatile(*p2))
           ty = qual(VOLATILE, ty);
         tlist = append(ty, tlist);
       }
       assert(*p1 == NULL && *p2 == NULL);
       return func(ty, ltov(&tlist, PERM), 0); }
  }
  assert(0); return NULL;
}
int ttob(Type ty) {
  switch (ty->op) {
  case CONST: case VOLATILE: case CONST+VOLATILE:
    return ttob(ty->type);
  case VOID: case INT: case UNSIGNED: case FLOAT:
    return ty->op + sizeop(ty->size);
  case POINTER:
    return POINTER + sizeop(voidptype->size);
  case FUNCTION:
    return POINTER + sizeop(funcptype->size);
  case ARRAY: case STRUCT: case UNION:
    return STRUCT;
  case ENUM:
    return INT + sizeop(inttype->size);
  }
  assert(0); return INT;
}
Type btot(int op, int size) {
#define xx(ty) if (size == (ty)->size) return ty;
  switch (optype(op)) {
  case F:
    xx(floattype);
    xx(doubletype);
    xx(longdouble);
    assert(0); return 0;
  case I:
    xx(chartype);
    xx(shorttype);
    xx(inttype);
    xx(longtype);
    xx(longlongtype);
    assert(0); return 0;
  case U:
    xx(unsignedchar);
    xx(unsignedshort);
    xx(unsignedtype);
    xx(unsignedlong);
    xx(unsignedlonglong);
    assert(0); return 0;
  case P:
    xx(voidptype);
    xx(funcptype);
    assert(0); return 0;
  }
#undef xx
  assert(0); return 0;
}
int hasproto(Type ty) {
  if (ty == 0)
    return 1;
  switch (ty->op) {
  case CONST: case VOLATILE: case CONST+VOLATILE: case POINTER:
  case ARRAY:
    return hasproto(ty->type);
  case FUNCTION:
    return hasproto(ty->type) && ty->u.f.proto;
  case STRUCT: case UNION:
  case VOID:   case FLOAT: case ENUM:  case INT: case UNSIGNED:
    return 1;
  }
  assert(0); return 0;
}
/* fieldlist - construct a flat list of fields in type ty */
Field fieldlist(Type ty) {
  return ty->u.sym->u.s.flist;
}

/* fieldref - find field name of type ty, return entry */
Field fieldref(const char *name, Type ty) {
  Field p = isfield(name, unqual(ty)->u.sym->u.s.flist);

  if (p && xref) {
    Symbol q;
    assert(unqual(ty)->u.sym->u.s.ftab);
    q = lookup(name, unqual(ty)->u.sym->u.s.ftab);
    assert(q);
    use(q, src);
  }
  return p;
}

/* ftype - return a function type for rty function (ty,...)' */
Type ftype(Type rty, Type ty) {
  List list = append(ty, NULL);

  list = append(voidtype, list);
  return func(rty, ltov(&list, PERM), 0);
}

/* isfield - if name is a field in flist, return pointer to the field structure */
static Field isfield(const char *name, Field flist) {
  for ( ; flist; flist = flist->link)
    if (flist->name == name)
      break;
  return flist;
}

/* outtype - output type ty */
void outtype(Type ty, FILE *f) {
  switch (ty->op) {
  case CONST+VOLATILE:
    fprint(f, "%k %k %t", CONST, VOLATILE, ty->type);
    break;
  case CONST: case VOLATILE:
    fprint(f, "%k %t", ty->op, ty->type);
    break;
  case STRUCT: case UNION: case ENUM:
    assert(ty->u.sym);
    if (ty->size == 0)
      fprint(f, "incomplete ");
    assert(ty->u.sym->name);
    if (*ty->u.sym->name >= '1' && *ty->u.sym->name <= '9') {
      Symbol p = findtype(ty);
      if (p == 0)
        fprint(f, "%k defined at %w", ty->op, &ty->u.sym->src);
      else
        fprint(f, p->name);
    } else {
      fprint(f, "%k %s", ty->op, ty->u.sym->name);
      if (ty->size == 0)
        fprint(f, " defined at %w", &ty->u.sym->src);
    }
    break;
  case VOID: case FLOAT: case INT: case UNSIGNED:
    fprint(f, ty->u.sym->name);
    break;
  case POINTER:
    fprint(f, "pointer to %t", ty->type);
    break;
  case FUNCTION:
    fprint(f, "%t function", ty->type);
    if (ty->u.f.proto && ty->u.f.proto[0]) {
      int i;
      fprint(f, "(%t", ty->u.f.proto[0]);
      for (i = 1; ty->u.f.proto[i]; i++)
        if (ty->u.f.proto[i] == voidtype)
          fprint(f, ",...");
        else
          fprint(f, ",%t", ty->u.f.proto[i]);
      fprint(f, ")");
    } else if (ty->u.f.proto && ty->u.f.proto[0] == 0)
      fprint(f, "(void)");

    break;
  case ARRAY:
    if (ty->size > 0 && ty->type && ty->type->size > 0) {
      fprint(f, "array %d", ty->size/ty->type->size);
      while (ty->type && isarray(ty->type) && ty->type->type->size > 0) {
        ty = ty->type;
        fprint(f, ",%d", ty->size/ty->type->size);
      }
    } else
      fprint(f, "incomplete array");
    if (ty->type)
      fprint(f, " of %t", ty->type);
    break;
  default: assert(0);
  }
}

/* printdecl - output a C declaration for symbol p of type ty */
void printdecl(Symbol p, Type ty) {
  switch (p->sclass) {
  case AUTO:
    fprint(stderr, "%s;\n", typestring(ty, p->name));
    break;
  case STATIC: case EXTERN:
    fprint(stderr, "%k %s;\n", p->sclass, typestring(ty, p->name));
    break;
  case TYPEDEF: case ENUM:
    break;
  default: assert(0);
  }
}

/* printproto - output a prototype declaration for function p */
void printproto(Symbol p, Symbol callee[]) {
  if (p->type->u.f.proto)
    printdecl(p, p->type);
  else {
    int i;
    List list = 0;
    if (callee[0] == 0)
      list = append(voidtype, list);
    else
      for (i = 0; callee[i]; i++)
        list = append(callee[i]->type, list);
    printdecl(p, func(freturn(p->type), ltov(&list, PERM), 0));
  }
}

/* prtype - print details of type ty on f with given indent */
static void prtype(Type ty, FILE *f, int indent, unsigned mark) {
  switch (ty->op) {
  default:
    fprint(f, "(%d %d %d [%p])", ty->op, ty->size, ty->align, ty->u.sym);
    break;
  case FLOAT: case INT: case UNSIGNED: case VOID:
    fprint(f, "(%k %d %d [\"%s\"])", ty->op, ty->size, ty->align, ty->u.sym->name);
    break;
  case CONST+VOLATILE:
    fprint(f, "(%s %d %d ", "CONST+VOLATILE", ty->size, ty->align);
    prtype(ty->type, f, indent+1, mark);
    fprint(f, ")");
    break;
  case CONST: case VOLATILE: case POINTER: case ARRAY:
    fprint(f, "(%k %d %d ", ty->op, ty->size, ty->align);
    prtype(ty->type, f, indent+1, mark);
    fprint(f, ")");
    break;
  case STRUCT: case UNION:
    fprint(f, "(%k %d %d [\"%s\"]", ty->op, ty->size, ty->align, ty->u.sym->name);
    if (ty->x.marked != mark) {
      Field p;
      ty->x.marked = mark;
      for (p = ty->u.sym->u.s.flist; p; p = p->link) {
        fprint(f, "\n%I", indent+1);
        prtype(p->type, f, indent+1, mark);
        fprint(f, " %s@%d", p->name, p->offset);
        if (p->lsb)
          fprint(f, ":%d..%d",
            fieldsize(p) + fieldright(p), fieldright(p));
      }
      fprint(f, "\n%I", indent);
    }
    fprint(f, ")");
    break;
  case ENUM:
    fprint(f, "(%k %d %d [\"%s\"]", ty->op, ty->size, ty->align, ty->u.sym->name);
    if (ty->x.marked != mark) {
      int i;
      Symbol *p = ty->u.sym->u.idlist;
      ty->x.marked = mark;
      for (i = 0; p[i] != NULL; i++)
        fprint(f, "%I%s=%d\n", indent+1, p[i]->name, p[i]->u.value);
    }
    fprint(f, ")");
    break;
  case FUNCTION:
    fprint(f, "(%k %d %d ", ty->op, ty->size, ty->align);
    prtype(ty->type, f, indent+1, mark);
    if (ty->u.f.proto) {
      int i;
      fprint(f, "\n%I{", indent+1);
      for (i = 0; ty->u.f.proto[i]; i++) {
        if (i > 0)
          fprint(f, "%I", indent+2);
        prtype(ty->u.f.proto[i], f, indent+2, mark);
        fprint(f, "\n");
      }
      fprint(f, "%I}", indent+1);
    }
    fprint(f, ")");
    break;
  }
}

/* printtype - print details of type ty on fd */
void printtype(Type ty, int fd) {
  static unsigned mark;
  prtype(ty, fd == 1 ? stdout : stderr, 0, ++mark);
  fprint(fd == 1 ? stdout : stderr, "\n");
}

/* typestring - return ty as C declaration for str, which may be "" */
char *typestring(Type ty, char *str) {
  for ( ; ty; ty = ty->type) {
    Symbol p;
    switch (ty->op) {
    case CONST+VOLATILE:
      if (isptr(ty->type))
        str = stringf("%k %k %s", CONST, VOLATILE, str);
      else
        return stringf("%k %k %s", CONST, VOLATILE, typestring(ty->type, str));
      break;
    case CONST: case VOLATILE:
      if (isptr(ty->type))
        str = stringf("%k %s", ty->op, str);
      else
        return stringf("%k %s", ty->op, typestring(ty->type, str));
      break;
    case STRUCT: case UNION: case ENUM:
      assert(ty->u.sym);
      if ((p = findtype(ty)) != NULL)
        return *str ? stringf("%s %s", p->name, str) : p->name;
      if (*ty->u.sym->name >= '1' && *ty->u.sym->name <= '9')
        warning("unnamed %k in prototype\n", ty->op);
      if (*str)
        return stringf("%k %s %s", ty->op, ty->u.sym->name, str);
      else
        return stringf("%k %s", ty->op, ty->u.sym->name);
    case VOID: case FLOAT: case INT: case UNSIGNED:
      return *str ? stringf("%s %s", ty->u.sym->name, str) : ty->u.sym->name;
    case POINTER:
      if (!ischar(ty->type) && (p = findtype(ty)) != NULL)
        return *str ? stringf("%s %s", p->name, str) : p->name;
      str = stringf(isarray(ty->type) || isfunc(ty->type) ? "(*%s)" : "*%s", str);
      break;
    case FUNCTION:
      if ((p = findtype(ty)) != NULL)
        return *str ? stringf("%s %s", p->name, str) : p->name;
      if (ty->u.f.proto == 0)
        str = stringf("%s()", str);
      else if (ty->u.f.proto[0]) {
        int i;
        str = stringf("%s(%s", str, typestring(ty->u.f.proto[0], ""));
        for (i = 1; ty->u.f.proto[i]; i++)
          if (ty->u.f.proto[i] == voidtype)
            str = stringf("%s, ...", str);
          else
            str = stringf("%s, %s", str, typestring(ty->u.f.proto[i], ""));
        str = stringf("%s)", str);
      } else
        str = stringf("%s(void)", str);
      break;
    case ARRAY:
      if ((p = findtype(ty)) != NULL)
        return *str ? stringf("%s %s", p->name, str) : p->name;
      if (ty->type && ty->type->size > 0)
        str = stringf("%s[%d]", str, ty->size/ty->type->size);
      else
        str = stringf("%s[]", str);
      break;
    default: assert(0);
    }
  }
  assert(0); return 0;
}

