struct mapaccess_ret
mapaccess (struct __go_map_type *mt, uintptr_t m, uintptr_t key_i)
{
struct __go_map *map = (struct __go_map *) m;
void *key;
const struct __go_type_descriptor *key_descriptor;
void *p;
const struct __go_type_descriptor *val_descriptor;
struct mapaccess_ret ret;
void *val;
void *pv;
__go_assert (mt->__common.__code == GO_MAP);
key_descriptor = mt->__key_type;
if (__go_is_pointer_type (key_descriptor))
key = &key_i;
else
key = (void *) key_i;
if (map == NULL)
p = NULL;
else
p = __go_map_index (map, key, 0);
val_descriptor = mt->__val_type;
if (__go_is_pointer_type (val_descriptor))
{
val = NULL;
pv = &val;
}
else
{
val = __go_alloc (val_descriptor->__size);
pv = val;
}
if (p == NULL)
ret.pres = 0;
else
{
__builtin_memcpy (pv, p, val_descriptor->__size);
ret.pres = 1;
}
ret.val = (uintptr_t) val;
return ret;
}
_Bool
__go_type_equal_empty_interface (const void *vv1, const void *vv2,
uintptr_t key_size __attribute__ ((unused)))
{
const struct __go_empty_interface *v1;
const struct __go_empty_interface *v2;
const struct __go_type_descriptor* v1_descriptor;
const struct __go_type_descriptor* v2_descriptor;
v1 = (const struct __go_empty_interface *) vv1;
v2 = (const struct __go_empty_interface *) vv2;
v1_descriptor = v1->__type_descriptor;
v2_descriptor = v2->__type_descriptor;
if (v1_descriptor == NULL || v2_descriptor == NULL)
return v1_descriptor == v2_descriptor;
if (!__go_type_descriptors_equal (v1_descriptor, v2_descriptor))
return 0;
if (v1_descriptor->__equalfn == NULL)
runtime_panicstring ("comparing uncomparable types");
if (__go_is_pointer_type (v1_descriptor))
return v1->__object == v2->__object;
else
return __go_call_equalfn (v1_descriptor->__equalfn, v1->__object,
v2->__object, v1_descriptor->__size);
}
_Bool
__go_type_equal_empty_interface (const void *vv1, const void *vv2,
size_t key_size __attribute__ ((unused)))
{
const struct __go_empty_interface *v1;
const struct __go_empty_interface *v2;
const struct __go_type_descriptor* v1_descriptor;
const struct __go_type_descriptor* v2_descriptor;
v1 = (const struct __go_empty_interface *) vv1;
v2 = (const struct __go_empty_interface *) vv2;
v1_descriptor = v1->__type_descriptor;
v2_descriptor = v2->__type_descriptor;
if (((uintptr_t) v1_descriptor & reflectFlags) != 0
|| ((uintptr_t) v2_descriptor & reflectFlags) != 0)
runtime_panicstring ("invalid interface value");
if (v1_descriptor == NULL || v2_descriptor == NULL)
return v1_descriptor == v2_descriptor;
if (!__go_type_descriptors_equal (v1_descriptor, v2_descriptor))
return 0;
if (__go_is_pointer_type (v1_descriptor))
return v1->__object == v2->__object;
else
return v1_descriptor->__equalfn (v1->__object, v2->__object,
v1_descriptor->__size);
}
int
__go_empty_interface_compare (struct __go_empty_interface left,
struct __go_empty_interface right)
{
const struct __go_type_descriptor *left_descriptor;
left_descriptor = left.__type_descriptor;
if (((uintptr_t) left_descriptor & reflectFlags) != 0
|| ((uintptr_t) right.__type_descriptor & reflectFlags) != 0)
__go_panic_msg ("invalid interface value");
if (left_descriptor == NULL && right.__type_descriptor == NULL)
return 0;
if (left_descriptor == NULL || right.__type_descriptor == NULL)
return 1;
if (!__go_type_descriptors_equal (left_descriptor,
right.__type_descriptor))
return 1;
if (__go_is_pointer_type (left_descriptor))
return left.__object == right.__object ? 0 : 1;
if (!left_descriptor->__equalfn (left.__object, right.__object,
left_descriptor->__size))
return 1;
return 0;
}
struct __go_empty_interface
Unreflect (struct __go_empty_interface type, void *object)
{
struct __go_empty_interface ret;
/* FIXME: We should check __type_descriptor to verify that this is
really a type descriptor. */
ret.__type_descriptor = type.__object;
if (__go_is_pointer_type (ret.__type_descriptor))
ret.__object = *(void **) object;
else
ret.__object = object;
return ret;
}
void
mapassign (struct __go_map_type *mt, uintptr_t m, uintptr_t key_i,
uintptr_t val_i, _Bool pres)
{
struct __go_map *map = (struct __go_map *) m;
const struct __go_type_descriptor *key_descriptor;
void *key;
__go_assert (mt->__common.__code == GO_MAP);
if (map == NULL)
__go_panic_msg ("assignment to entry in nil map");
key_descriptor = mt->__key_type;
if (__go_is_pointer_type (key_descriptor))
key = &key_i;
else
key = (void *) key_i;
if (!pres)
__go_map_delete (map, key);
else
{
void *p;
const struct __go_type_descriptor *val_descriptor;
void *pv;
p = __go_map_index (map, key, 1);
val_descriptor = mt->__val_type;
if (__go_is_pointer_type (val_descriptor))
pv = &val_i;
else
pv = (void *) val_i;
__builtin_memcpy (p, pv, val_descriptor->__size);
}
}
uintptr_t
__go_type_hash_interface (const void *vval,
uintptr_t key_size __attribute__ ((unused)))
{
const struct __go_interface *val;
const struct __go_type_descriptor *descriptor;
uintptr_t size;
val = (const struct __go_interface *) vval;
if (val->__methods == NULL)
return 0;
descriptor = (const struct __go_type_descriptor *) val->__methods[0];
size = descriptor->__size;
if (__go_is_pointer_type (descriptor))
return descriptor->__hashfn (&val->__object, size);
else
return descriptor->__hashfn (val->__object, size);
}
size_t
__go_type_hash_empty_interface (const void *vval,
size_t key_size __attribute__ ((unused)))
{
const struct __go_empty_interface *val;
const struct __go_type_descriptor *descriptor;
size_t size;
val = (const struct __go_empty_interface *) vval;
descriptor = val->__type_descriptor;
if (descriptor == NULL)
return 0;
size = descriptor->__size;
if (__go_is_pointer_type (descriptor))
return descriptor->__hashfn (&val->__object, size);
else
return descriptor->__hashfn (val->__object, size);
}
uintptr_t
__go_type_hash_empty_interface (const void *vval, uintptr_t seed,
uintptr_t key_size __attribute__ ((unused)))
{
const struct __go_empty_interface *val;
const struct __go_type_descriptor *descriptor;
uintptr_t size;
val = (const struct __go_empty_interface *) vval;
descriptor = val->__type_descriptor;
if (descriptor == NULL)
return 0;
if (descriptor->__hashfn == NULL)
runtime_panicstring ("hash of unhashable type");
size = descriptor->__size;
if (__go_is_pointer_type (descriptor))
return __go_call_hashfn (descriptor->__hashfn, &val->__object, seed, size);
else
return __go_call_hashfn (descriptor->__hashfn, val->__object, seed, size);
}
int
__go_interface_compare (struct __go_interface left,
struct __go_interface right)
{
const struct __go_type_descriptor *left_descriptor;
if (left.__methods == NULL && right.__methods == NULL)
return 0;
if (left.__methods == NULL || right.__methods == NULL)
return 1;
left_descriptor = left.__methods[0];
if (!__go_type_descriptors_equal (left_descriptor, right.__methods[0]))
return 1;
if (__go_is_pointer_type (left_descriptor))
return left.__object == right.__object ? 0 : 1;
if (!left_descriptor->__equalfn (left.__object, right.__object,
left_descriptor->__size))
return 1;
return 0;
}
_Bool
reflect_chansend(ChanType *t, Hchan *c, uintptr val, _Bool nb)
{
bool selected;
bool *sp;
byte *vp;
if(nb) {
selected = false;
sp = (bool*)&selected;
} else {
selected = true;
sp = nil;
}
if(__go_is_pointer_type(t->__element_type))
vp = (byte*)&val;
else
vp = (byte*)val;
runtime_chansend(t, c, vp, sp, runtime_getcallerpc(&t));
return selected;
}
_Bool
__go_type_equal_interface (const void *vv1, const void *vv2,
uintptr_t key_size __attribute__ ((unused)))
{
const struct __go_interface *v1;
const struct __go_interface *v2;
const struct __go_type_descriptor* v1_descriptor;
const struct __go_type_descriptor* v2_descriptor;
v1 = (const struct __go_interface *) vv1;
v2 = (const struct __go_interface *) vv2;
if (v1->__methods == NULL || v2->__methods == NULL)
return v1->__methods == v2->__methods;
v1_descriptor = (const struct __go_type_descriptor *) v1->__methods[0];
v2_descriptor = (const struct __go_type_descriptor *) v2->__methods[0];
if (!__go_type_descriptors_equal (v1_descriptor, v2_descriptor))
return 0;
if (__go_is_pointer_type (v1_descriptor))
return v1->__object == v2->__object;
else
return v1_descriptor->__equalfn (v1->__object, v2->__object,
v1_descriptor->__size);
}
struct mapiterkey_ret
mapiterkey (unsigned char *ita)
{
struct __go_hash_iter *it = (struct __go_hash_iter *) ita;
struct mapiterkey_ret ret;
if (it->entry == NULL)
{
ret.key = 0;
ret.ok = 0;
}
else
{
const struct __go_type_descriptor *key_descriptor;
void *key;
void *pk;
key_descriptor = it->map->__descriptor->__map_descriptor->__key_type;
if (__go_is_pointer_type (key_descriptor))
{
key = NULL;
pk = &key;
}
else
{
key = __go_alloc (key_descriptor->__size);
pk = key;
}
__go_mapiter1 (it, pk);
ret.key = (uintptr_t) key;
ret.ok = 1;
}
return ret;
}
