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 159 matching lines @@
 
 void
 waitforgcc(void)
 {
         waitpid();
 }
 
 void
 main(int argc, char **argv)
 {
-        int p[2], pid, i, j, k, n, off, npad, prefix;
+        int p[2], pid, i, j, n, off, npad, prefix;
         char **av, *q, *r, *tofree, *name;
         char nambuf[100];
         Biobuf *bin, *bout;
         Type *t, *tt;
         Field *f;
         int orig_output_fd;
 
         quotefmtinstall();
 
         oargc = argc;
@@ skipping 178 matching lines @@
                         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 && 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
-                                        for (k = Uint64; k >= Uint8 && kindsize[k] >= f->size; k -= 2) {

[rsc, 2011/06/02 14:17:29]

I'm a bit confused by this loop.  Maybe it is supposed to be

k = Uint64
while (...)
    k -= 2;
tt = emalloc...
...

?

-                                                tt = emalloc(sizeof *tt);
-                                                *tt = *f->type;
-                                                f->type = tt;
-                                                tt->kind = k;
-                                        }
+                                        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) {
@@ skipping 202 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;
 }