code review 4047047: runtime: automaticaly generated Go declarations for C v...

src/pkg/runtime/hashmap.h

 // 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.
 
 /* A hash table.
    Example, hashing nul-terminated char*s:
         hash_hash_t str_hash (void *v) {
                 char *s;
                 hash_hash_t hash = 0;
                 for (s = *(char **)v; *s != 0; s++) {
@@ skipping 52 matching lines @@
         }
  */
 
 #define malloc          runtime·mal
 #define memset(a,b,c)   runtime·memclr((byte*)(a), (uint32)(c))
 #define memcpy(a,b,c)   runtime·mcpy((byte*)(a),(byte*)(b),(uint32)(c))
 #define assert(a)       if(!(a)) runtime·throw("assert")
 #define free(x) runtime·free(x)
 #define memmove(a,b,c)  runtime·memmove(a, b, c)
 
-struct hash;            /* opaque */
+struct Hmap;            /* opaque */
 struct hash_subtable;   /* opaque */
 struct hash_entry;      /* opaque */
 
 typedef uintptr uintptr_t;
 typedef uintptr_t hash_hash_t;
 
 struct hash_iter {
         uint8*  data;           /* returned from next */
         int32   elemsize;       /* size of elements in table */
         int32   changes;        /* number of changes observed last time */
         int32   i;              /* stack pointer in subtable_state */
         hash_hash_t last_hash;  /* last hash value returned */
-        struct hash *h;         /* the hash table */
+        struct Hmap *h;         /* the hash table */
         struct hash_iter_sub {
                 struct hash_entry *e;           /* pointer into subtable */
                 struct hash_entry *start;       /* start of subtable */
                 struct hash_entry *end;         /* end of subtable */
         } subtable_state[4];    /* Should be large enough unless the hashing is
                                    so bad that many distinct data values hash
                                    to the same hash value.  */
 };
 
 /* Return a hashtable h 2**init_power empty entries, each with
@@ skipping 53 matching lines @@
 // void hash_iter_init (struct hash *h, struct hash_iter *it);
 
 /* Return the next used entry in the table which which *it was initialized. */
 // void *hash_next (struct hash_iter *it);
 
 /*---- test interface ----*/
 /* Call (*data_visit) (arg, level, data) for every data entry in the table,
    whether used or not.   "level" is the subtable level, 0 means first level. */
 /* TESTING ONLY: DO NOT USE THIS ROUTINE IN NORMAL CODE */
 // void hash_visit (struct hash *h, void (*data_visit) (void *arg, int32 level, void *data), void *arg);