From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- libgo/runtime/map.h | 86 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 86 insertions(+) create mode 100644 libgo/runtime/map.h (limited to 'libgo/runtime/map.h') diff --git a/libgo/runtime/map.h b/libgo/runtime/map.h new file mode 100644 index 000000000..a0c834a54 --- /dev/null +++ b/libgo/runtime/map.h @@ -0,0 +1,86 @@ +/* map.h -- the map type for Go. + + Copyright 2009, 2010 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. */ + +#include + +#include "go-type.h" + +/* A map descriptor is what we need to manipulate the map. This is + constant for a given map type. */ + +struct __go_map_descriptor +{ + /* A pointer to the type descriptor for the type of the map itself. */ + const struct __go_map_type *__map_descriptor; + + /* A map entry is a struct with three fields: + map_entry_type *next_entry; + key_type key; + value_type value; + This is the size of that struct. */ + size_t __entry_size; + + /* The offset of the key field in a map entry struct. */ + size_t __key_offset; + + /* The offset of the value field in a map entry struct (the value + field immediately follows the key field, but there may be some + bytes inserted for alignment). */ + size_t __val_offset; +}; + +struct __go_map +{ + /* The constant descriptor for this map. */ + const struct __go_map_descriptor *__descriptor; + + /* The number of elements in the hash table. */ + size_t __element_count; + + /* The number of entries in the __buckets array. */ + size_t __bucket_count; + + /* Each bucket is a pointer to a linked list of map entries. */ + void **__buckets; +}; + +/* For a map iteration the compiled code will use a pointer to an + iteration structure. The iteration structure will be allocated on + the stack. The Go code must allocate at least enough space. */ + +struct __go_hash_iter +{ + /* A pointer to the current entry. This will be set to NULL when + the range has completed. The Go will test this field, so it must + be the first one in the structure. */ + const void *entry; + /* The map we are iterating over. */ + const struct __go_map *map; + /* A pointer to the next entry in the current bucket. This permits + deleting the current entry. This will be NULL when we have seen + all the entries in the current bucket. */ + const void *next_entry; + /* The bucket index of the current and next entry. */ + size_t bucket; +}; + +extern struct __go_map *__go_new_map (const struct __go_map_descriptor *, + size_t); + +extern unsigned long __go_map_next_prime (unsigned long); + +extern void *__go_map_index (struct __go_map *, const void *, _Bool); + +extern void __go_map_delete (struct __go_map *, const void *); + +extern void __go_mapiterinit (const struct __go_map *, struct __go_hash_iter *); + +extern void __go_mapiternext (struct __go_hash_iter *); + +extern void __go_mapiter1 (struct __go_hash_iter *it, unsigned char *key); + +extern void __go_mapiter2 (struct __go_hash_iter *it, unsigned char *key, + unsigned char *val); -- cgit v1.2.3