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