libgo/runtime/iface.goc

   1 // Copyright 2010 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package runtime
   6 #include "go-type.h"
   7 #include "interface.h"
   8 #define nil NULL
   9
  10 typedef _Bool bool;
  11 typedef struct __go_type_descriptor descriptor;
  12 typedef const struct __go_type_descriptor const_descriptor;
  13 typedef struct __go_interface interface;
  14 typedef struct __go_empty_interface empty_interface;
  15
  16 // Compare two type descriptors.
  17 func ifacetypeeq(a *descriptor, b *descriptor) (eq bool) {
  18         eq = __go_type_descriptors_equal(a, b);
  19 }
  20
  21 // Return the descriptor for an empty interface type.n
  22 func efacetype(e empty_interface) (d *const_descriptor) {
  23         return e.__type_descriptor;
  24 }
  25
  26 // Return the descriptor for a non-empty interface type.
  27 func ifacetype(i interface) (d *const_descriptor) {
  28         if (i.__methods == nil) {
  29                 return nil;
  30         }
  31         d = i.__methods[0];
  32 }
  33
  34 // Convert an empty interface to an empty interface.
  35 func ifaceE2E2(e empty_interface) (ret empty_interface, ok bool) {
  36         ret = e;
  37         ok = ret.__type_descriptor != nil;
  38 }
  39
  40 // Convert a non-empty interface to an empty interface.
  41 func ifaceI2E2(i interface) (ret empty_interface, ok bool) {
  42         if (i.__methods == nil) {
  43                 ret.__type_descriptor = nil;
  44                 ret.__object = nil;
  45                 ok = 0;
  46         } else {
  47                 ret.__type_descriptor = i.__methods[0];
  48                 ret.__object = i.__object;
  49                 ok = 1;
  50         }
  51 }
  52
  53 // Convert an empty interface to a non-empty interface.
  54 func ifaceE2I2(inter *descriptor, e empty_interface) (ret interface, ok bool) {
  55         if (e.__type_descriptor == nil) {
  56                 ret.__methods = nil;
  57                 ret.__object = nil;
  58                 ok = 0;
  59         } else {
  60                 ret.__methods = __go_convert_interface_2(inter,
  61                                                          e.__type_descriptor,
  62                                                          1);
  63                 ret.__object = e.__object;
  64                 ok = ret.__methods != nil;
  65         }
  66 }
  67
  68 // Convert a non-empty interface to a non-empty interface.
  69 func ifaceI2I2(inter *descriptor, i interface) (ret interface, ok bool) {
  70         if (i.__methods == nil) {
  71                 ret.__methods = nil;
  72                 ret.__object = nil;
  73                 ok = 0;
  74         } else {
  75                 ret.__methods = __go_convert_interface_2(inter,
  76                                                          i.__methods[0], 1);
  77                 ret.__object = i.__object;
  78                 ok = ret.__methods != nil;
  79         }
  80 }
  81
  82 // Convert an empty interface to a pointer type.
  83 func ifaceE2T2P(inter *descriptor, e empty_interface) (ret *void, ok bool) {
  84         if (!__go_type_descriptors_equal(inter, e.__type_descriptor)) {
  85                 ret = nil;
  86                 ok = 0;
  87         } else {
  88                 ret = e.__object;
  89                 ok = 1;
  90         }
  91 }
  92
  93 // Convert a non-empty interface to a pointer type.
  94 func ifaceI2T2P(inter *descriptor, i interface) (ret *void, ok bool) {
  95         if (i.__methods == nil
  96             || !__go_type_descriptors_equal(inter, i.__methods[0])) {
  97                 ret = nil;
  98                 ok = 0;
  99         } else {
 100                 ret = i.__object;
 101                 ok = 1;
 102         }
 103 }
 104
 105 // Convert an empty interface to a non-pointer type.
 106 func ifaceE2T2(inter *descriptor, e empty_interface, ret *void) (ok bool) {
 107         if (!__go_type_descriptors_equal(inter, e.__type_descriptor)) {
 108                 __builtin_memset(ret, 0, inter->__size);
 109                 ok = 0;
 110         } else {
 111                 __builtin_memcpy(ret, e.__object, inter->__size);
 112                 ok = 1;
 113         }
 114 }
 115
 116 // Convert a non-empty interface to a non-pointer type.
 117 func ifaceI2T2(inter *descriptor, i interface, ret *void) (ok bool) {
 118         if (i.__methods == nil
 119             || !__go_type_descriptors_equal(inter, i.__methods[0])) {
 120                 __builtin_memset(ret, 0, inter->__size);
 121                 ok = 0;
 122         } else {
 123                 __builtin_memcpy(ret, i.__object, inter->__size);
 124                 ok = 1;
 125         }
 126 }
 127
 128 // Return whether we can convert an interface to a type.
 129 func ifaceI2Tp(to *descriptor, from *descriptor) (ok bool) {
 130         ok = __go_can_convert_to_interface(to, from);
 131 }