code review 4564043: godefs: do not assume forward type references are enums

src/cmd/godefs/main.c

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // Godefs takes as input a host-compilable C file that includes
 // standard system headers.  From that input file, it generates
 // a standalone (no #includes) C or Go file containing equivalent
 // definitions.
 //
 // The input C file is expected to define new types and enumerated
@@ skipping 163 matching lines @@
         waitpid();
 }
 
 void
 main(int argc, char **argv)
 {
         int p[2], pid, i, j, n, off, npad, prefix;
         char **av, *q, *r, *tofree, *name;
         char nambuf[100];
         Biobuf *bin, *bout;
-        Type *t;
+        Type *t, *tt;
         Field *f;
         int orig_output_fd;
 
         quotefmtinstall();
 
         oargc = argc;
         oargv = argv;
         av = emalloc((30+argc)*sizeof av[0]);
         atexit(waitforgcc);
 
@@ skipping 171 matching lines @@
                         Bprint(bout, lang->unionbegin, name, name, name);
                         goto StructBody;
                 case Struct:
                         Bprint(bout, lang->structbegin, name, name, name);
                 StructBody:
                         prefix = 0;
                         if(lang == &go)
                                 prefix = prefixlen(t);
                         for(j=0; j<t->nf; j++) {
                                 f = &t->f[j];
-                                if(f->type->kind == 0)
-                                        continue;
+                                if(f->type->kind == 0 && f->size <= 64 && (f->size&(f->size-1)) == 0) {
+                                        // unknown type but <= 64 bits and bit size is a power of two.
+                                        // could be enum - make Uint64 and then let it reduce
+                                        tt = emalloc(sizeof *tt);
+                                        *tt = *f->type;
+                                        f->type = tt;
+                                        tt->kind = Uint64;
+                                        while(tt->kind > Uint8 && kindsize[tt->kind] > f->size)

[rh, 2011/06/03 02:38:25]

Is this closer?

+                                                tt->kind -= 2;
+                                }
                                 // padding
                                 if(t->kind == Struct || lang == &go) {
                                         if(f->offset%8 != 0 || f->size%8 != 0) {
                                                 fprint(2, "ignoring bitfield %s.%s\n", t->name, f->name);
                                                 continue;
                                         }
                                         if(f->offset < off)
                                                 sysfatal("%s: struct fields went backward", t->name);
                                         if(off < f->offset) {
                                                 Bprint(bout, lang->structpadfmt, npad++, (f->offset - off) / 8);
@@ skipping 201 matching lines @@
                         return 0;
                 if(name == nil) {
                         name = f->name;
                         len = p+1 - name;
                 }
                 else if(strncmp(f->name, name, len) != 0)
                         return 0;
         }
         return len;
 }