0a021a938e
longer as of Go 1.5. In Go 1.5 or later user calls to _swig_makegostring will fail at link time. Instead, use goout and godirectorin typemaps to allocate strings in Go code. Change the Go typemaps support to ignore empty strings, so that we can define empty strings for regular types so that %apply will override the definitions for string types. Fix the gccgo code to wrap SwigCgoCallback around all godirectorin typemaps. Add a few newlines after typemap code so that the typemaps don't have to include them.
688 lines
16 KiB
Text
688 lines
16 KiB
Text
/* ------------------------------------------------------------
|
|
* go.swg
|
|
*
|
|
* Go configuration module.
|
|
* ------------------------------------------------------------ */
|
|
|
|
%include <gostring.swg>
|
|
|
|
/* Code insertion directives */
|
|
#define %go_import(...) %insert(go_imports) %{__VA_ARGS__%}
|
|
|
|
/* Basic types */
|
|
|
|
%typemap(gotype) bool, const bool & "bool"
|
|
%typemap(gotype) char, const char & "byte"
|
|
%typemap(gotype) signed char, const signed char & "int8"
|
|
%typemap(gotype) unsigned char, const unsigned char & "byte"
|
|
%typemap(gotype) short, const short & "int16"
|
|
%typemap(gotype) unsigned short, const unsigned short & "uint16"
|
|
%typemap(gotype) int, const int & "int"
|
|
%typemap(gotype) unsigned int, const unsigned int & "uint"
|
|
%typemap(gotype) long, const long & "int64"
|
|
%typemap(gotype) unsigned long, const unsigned long & "uint64"
|
|
%typemap(gotype) long long, const long long & "int64"
|
|
%typemap(gotype) unsigned long long, const unsigned long long & "uint64"
|
|
%typemap(gotype) float, const float & "float32"
|
|
%typemap(gotype) double, const double & "float64"
|
|
|
|
%typemap(in) bool,
|
|
char,
|
|
signed char,
|
|
unsigned char,
|
|
short,
|
|
unsigned short,
|
|
int,
|
|
unsigned int,
|
|
long,
|
|
unsigned long,
|
|
long long,
|
|
unsigned long long,
|
|
float,
|
|
double
|
|
%{ $1 = ($1_ltype)$input; %}
|
|
|
|
%typemap(in) const bool &,
|
|
const char &,
|
|
const signed char &,
|
|
const unsigned char &,
|
|
const short &,
|
|
const unsigned short &,
|
|
const int &,
|
|
const unsigned int &,
|
|
const long long &,
|
|
const unsigned long long &,
|
|
const float &,
|
|
const double &
|
|
%{ $1 = ($1_ltype)&$input; %}
|
|
|
|
%typemap(in) const long & ($*1_ltype temp),
|
|
const unsigned long & ($*1_ltype temp)
|
|
%{ temp = ($*1_ltype)$input;
|
|
$1 = ($1_ltype)&temp; %}
|
|
|
|
%typemap(out) bool,
|
|
char,
|
|
signed char,
|
|
unsigned char,
|
|
short,
|
|
unsigned short,
|
|
int,
|
|
unsigned int,
|
|
long,
|
|
unsigned long,
|
|
long long,
|
|
unsigned long long,
|
|
float,
|
|
double
|
|
%{ $result = $1; %}
|
|
|
|
%typemap(goout) bool,
|
|
char,
|
|
signed char,
|
|
unsigned char,
|
|
short,
|
|
unsigned short,
|
|
int,
|
|
unsigned int,
|
|
long,
|
|
unsigned long,
|
|
long long,
|
|
unsigned long long,
|
|
float,
|
|
double
|
|
""
|
|
|
|
%typemap(out) const bool &,
|
|
const char &,
|
|
const signed char &,
|
|
const unsigned char &,
|
|
const short &,
|
|
const unsigned short &,
|
|
const int &,
|
|
const unsigned int &,
|
|
const long &,
|
|
const unsigned long &,
|
|
const long long &,
|
|
const unsigned long long &,
|
|
const float &,
|
|
const double &
|
|
%{ $result = ($*1_ltype)*$1; %}
|
|
|
|
%typemap(goout) const bool &,
|
|
const char &,
|
|
const signed char &,
|
|
const unsigned char &,
|
|
const short &,
|
|
const unsigned short &,
|
|
const int &,
|
|
const unsigned int &,
|
|
const long &,
|
|
const unsigned long &,
|
|
const long long &,
|
|
const unsigned long long &,
|
|
const float &,
|
|
const double &
|
|
""
|
|
|
|
%typemap(out) void ""
|
|
|
|
%typemap(goout) void ""
|
|
|
|
%typemap(directorin) bool,
|
|
char,
|
|
signed char,
|
|
unsigned char,
|
|
short,
|
|
unsigned short,
|
|
int,
|
|
unsigned int,
|
|
long,
|
|
unsigned long,
|
|
long long,
|
|
unsigned long long,
|
|
float,
|
|
double
|
|
%{ $input = ($1_ltype)$1; %}
|
|
|
|
%typemap(godirectorin) bool,
|
|
char,
|
|
signed char,
|
|
unsigned char,
|
|
short,
|
|
unsigned short,
|
|
int,
|
|
unsigned int,
|
|
long,
|
|
unsigned long,
|
|
long long,
|
|
unsigned long long,
|
|
float,
|
|
double
|
|
""
|
|
|
|
%typemap(directorin) const bool &,
|
|
const char &,
|
|
const signed char &,
|
|
const unsigned char &,
|
|
const short &,
|
|
const unsigned short &,
|
|
const int &,
|
|
const unsigned int &,
|
|
const long &,
|
|
const unsigned long &,
|
|
const long long &,
|
|
const unsigned long long &,
|
|
const float &,
|
|
const double &
|
|
%{ $input = ($*1_ltype)$1; %}
|
|
|
|
%typemap(godirectorin) const bool &,
|
|
const char &,
|
|
const signed char &,
|
|
const unsigned char &,
|
|
const short &,
|
|
const unsigned short &,
|
|
const int &,
|
|
const unsigned int &,
|
|
const long &,
|
|
const unsigned long &,
|
|
const long long &,
|
|
const unsigned long long &,
|
|
const float &,
|
|
const double &
|
|
""
|
|
|
|
%typemap(directorout) bool,
|
|
char,
|
|
signed char,
|
|
unsigned char,
|
|
short,
|
|
unsigned short,
|
|
int,
|
|
unsigned int,
|
|
long,
|
|
unsigned long,
|
|
long long,
|
|
unsigned long long,
|
|
float,
|
|
double
|
|
%{ $result = ($1_ltype)$input; %}
|
|
|
|
%typemap(directorout,warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) const bool &,
|
|
const char &,
|
|
const signed char &,
|
|
const unsigned char &,
|
|
const short &,
|
|
const unsigned short &,
|
|
const int &,
|
|
const unsigned int &,
|
|
const long &,
|
|
const unsigned long &,
|
|
const long long &,
|
|
const unsigned long long &,
|
|
const float &,
|
|
const double &
|
|
%{
|
|
$result = new $*1_ltype($input);
|
|
swig_acquire_pointer(&swig_mem, $result);
|
|
%}
|
|
|
|
/* The size_t type. */
|
|
|
|
%typemap(gotype) size_t, const size_t & %{int64%}
|
|
|
|
%typemap(in) size_t
|
|
%{ $1 = (size_t)$input; %}
|
|
|
|
%typemap(in) const size_t &
|
|
%{ $1 = ($1_ltype)&$input; %}
|
|
|
|
%typemap(out) size_t
|
|
%{ $result = $1; %}
|
|
|
|
%typemap(goout) size_t ""
|
|
|
|
%typemap(out) const size_t &
|
|
%{ $result = ($*1_ltype)*$1; %}
|
|
|
|
%typemap(goout) const size_t & ""
|
|
|
|
%typemap(directorin) size_t
|
|
%{ $input = (size_t)$1; %}
|
|
|
|
%typemap(godirectorin) size_t ""
|
|
|
|
%typemap(directorin) const size_t &
|
|
%{ $input = ($*1_ltype)$1; %}
|
|
|
|
%typemap(godirectorin) const size_t & ""
|
|
|
|
%typemap(directorout) size_t
|
|
%{ $result = ($1_ltype)$input; %}
|
|
|
|
%typemap(directorout,warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) const size_t &
|
|
%{
|
|
$result = new $*1_ltype($input);
|
|
swig_acquire_pointer(&swig_mem, $result);
|
|
%}
|
|
|
|
/* Member pointers. */
|
|
|
|
%typemap(gotype) SWIGTYPE (CLASS::*)
|
|
%{$gotypename%}
|
|
|
|
%typemap(in) SWIGTYPE (CLASS::*)
|
|
%{ $1 = *($&1_ltype)$input; %}
|
|
|
|
%typemap(out) SWIGTYPE (CLASS::*)
|
|
%{
|
|
struct swig_out_type { intgo size; void* val; } *swig_out;
|
|
swig_out = (struct swig_out_type*)malloc(sizeof(*swig_out));
|
|
if (swig_out) {
|
|
swig_out->size = sizeof($1_ltype);
|
|
swig_out->val = malloc(swig_out->size);
|
|
if (swig_out->val) {
|
|
*($&1_ltype)(swig_out->val) = $1;
|
|
}
|
|
}
|
|
$result = swig_out;
|
|
%}
|
|
|
|
%typemap(goout) SWIGTYPE (CLASS::*)
|
|
%{
|
|
{
|
|
type swig_out_type struct { size int; val uintptr }
|
|
p := (*swig_out_type)(unsafe.Pointer($1))
|
|
if p == nil || p.val == 0 {
|
|
$result = nil
|
|
} else {
|
|
m := make([]byte, p.size)
|
|
a := (*[1024]byte)(unsafe.Pointer(p.val))[:p.size]
|
|
copy(m, a)
|
|
Swig_free(p.val)
|
|
Swig_free(uintptr(unsafe.Pointer(p)))
|
|
$result = &m[0]
|
|
}
|
|
}
|
|
%}
|
|
|
|
%typemap(directorin) SWIGTYPE (CLASS::*)
|
|
%{ $input = *($&1_ltype)$1; %}
|
|
|
|
%typemap(godirectorin) SWIGTYPE (CLASS::*) ""
|
|
|
|
%typemap(directorout) SWIGTYPE (CLASS::*)
|
|
%{
|
|
$result = new $1_ltype($input);
|
|
swig_acquire_pointer(&swig_mem, $result);
|
|
%}
|
|
|
|
/* Pointers. */
|
|
|
|
/* We can't translate pointers using a typemap, so that is handled in
|
|
the C++ code. */
|
|
%typemap(gotype) SWIGTYPE *
|
|
%{$gotypename%}
|
|
|
|
%typemap(in) SWIGTYPE *
|
|
%{ $1 = *($&1_ltype)&$input; %}
|
|
|
|
%typemap(out) SWIGTYPE *
|
|
%{ *($&1_ltype)&$result = ($1_ltype)$1; %}
|
|
|
|
%typemap(goout) SWIGTYPE * ""
|
|
|
|
%typemap(directorin) SWIGTYPE *
|
|
%{ *($&1_ltype)&$input = ($1_ltype)$1; %}
|
|
|
|
%typemap(godirectorin) SWIGTYPE * ""
|
|
|
|
%typemap(directorout) SWIGTYPE *
|
|
%{ $result = *($&1_ltype)&$input; %}
|
|
|
|
%apply SWIGTYPE * { SWIGTYPE *const }
|
|
|
|
/* Pointer references. */
|
|
|
|
%typemap(gotype) SWIGTYPE *const&
|
|
%{$gotypename%}
|
|
|
|
%typemap(in) SWIGTYPE *const& ($*1_ltype temp = 0)
|
|
%{
|
|
temp = *($1_ltype)&$input;
|
|
$1 = ($1_ltype)&temp;
|
|
%}
|
|
|
|
%typemap(out) SWIGTYPE *const&
|
|
%{ *($1_ltype)&$result = *$1; %}
|
|
|
|
%typemap(goout) SWIGTYPE *const& ""
|
|
|
|
/* References. */
|
|
|
|
/* Converting a C++ reference to Go has to be handled in the C++
|
|
code. */
|
|
%typemap(gotype) SWIGTYPE &
|
|
%{$gotypename%}
|
|
|
|
%typemap(in) SWIGTYPE &
|
|
%{ $1 = *($&1_ltype)&$input; %}
|
|
|
|
%typemap(out) SWIGTYPE &
|
|
%{ *($&1_ltype)&$result = $1; %}
|
|
|
|
%typemap(goout) SWIGTYPE & ""
|
|
|
|
%typemap(directorin) SWIGTYPE &
|
|
%{ $input = ($1_ltype)&$1; %}
|
|
|
|
%typemap(godirectorin) SWIGTYPE & ""
|
|
|
|
%typemap(directorout) SWIGTYPE &
|
|
%{ *($&1_ltype)&$result = $input; %}
|
|
|
|
%typemap(gotype) SWIGTYPE &&
|
|
%{$gotypename%}
|
|
|
|
%typemap(in) SWIGTYPE &&
|
|
%{ $1 = *($&1_ltype)&$input; %}
|
|
|
|
%typemap(out) SWIGTYPE &&
|
|
%{ *($&1_ltype)&$result = $1; %}
|
|
|
|
%typemap(goout) SWIGTYPE && ""
|
|
|
|
%typemap(directorin) SWIGTYPE &&
|
|
%{ $input = ($1_ltype)&$1_name; %}
|
|
|
|
%typemap(godirectorin) SWIGTYPE && ""
|
|
|
|
%typemap(directorout) SWIGTYPE &&
|
|
%{ *($&1_ltype)&$result = $input; %}
|
|
|
|
/* C arrays turn into Go pointers. If we know the length we can use a
|
|
slice. */
|
|
|
|
%typemap(gotype) SWIGTYPE []
|
|
%{$gotypename%}
|
|
|
|
%typemap(in) SWIGTYPE []
|
|
%{ $1 = *($&1_ltype)&$input; %}
|
|
|
|
%typemap(out) SWIGTYPE []
|
|
%{ *($&1_ltype)&$result = $1; %}
|
|
|
|
%typemap(goout) SWIGTYPE [] ""
|
|
|
|
%typemap(directorin) SWIGTYPE []
|
|
%{ $input = *($1_ltype)&$1; %}
|
|
|
|
%typemap(godirectorin) SWIGTYPE [] ""
|
|
|
|
%typemap(directorout) SWIGTYPE []
|
|
%{ *($&1_ltype)&$result = $input; %}
|
|
|
|
/* Strings. */
|
|
|
|
%typemap(gotype)
|
|
char *, char *&, char[ANY], char[],
|
|
signed char *, signed char *&, signed char[ANY], signed char[],
|
|
unsigned char *, unsigned char *&, unsigned char[ANY], unsigned char[]
|
|
"string"
|
|
|
|
/* Needed to avoid confusion with the way the go module handles
|
|
references. */
|
|
%typemap(gotype) char&, unsigned char& "*byte"
|
|
%typemap(gotype) signed char& "*int8"
|
|
|
|
%typemap(in)
|
|
char *, char[ANY], char[],
|
|
signed char *, signed char[ANY], signed char[],
|
|
unsigned char *, unsigned char[ANY], unsigned char[]
|
|
%{ $1 = ($1_ltype)$input.p; %}
|
|
|
|
%typemap(in) char *&, signed char *&, unsigned char *&
|
|
%{ $1 = ($1_ltype)$input.p; %}
|
|
|
|
%typemap(out,fragment="AllocateString")
|
|
char *, char *&, char[ANY], char[],
|
|
signed char *, signed char *&, signed char[ANY], signed char[],
|
|
unsigned char *, unsigned char *&, unsigned char[ANY], unsigned char[]
|
|
%{ $result = Swig_AllocateString((char*)$1, $1 ? strlen((char*)$1) : 0); %}
|
|
|
|
%typemap(goout,fragment="CopyString")
|
|
char *, char *&, char[ANY], char[],
|
|
signed char *, signed char *&, signed char[ANY], signed char[],
|
|
unsigned char *, unsigned char *&, unsigned char[ANY], unsigned char[]
|
|
%{ $result = swigCopyString($1) %}
|
|
|
|
%typemap(directorin,fragment="AllocateString")
|
|
char *, char *&, char[ANY], char[],
|
|
signed char *, signed char *&, signed char[ANY], signed char[],
|
|
unsigned char *, unsigned char *&, unsigned char[ANY], unsigned char[]
|
|
%{
|
|
$input = Swig_AllocateString((char*)$1, $1 ? strlen((char*)$1) : 0);
|
|
%}
|
|
|
|
%typemap(godirectorin,fragment="CopyString")
|
|
char *, char *&, char[ANY], char[],
|
|
signed char *, signed char *&, signed char[ANY], signed char[],
|
|
unsigned char *, unsigned char *&, unsigned char[ANY], unsigned char[]
|
|
%{
|
|
$result = swigCopyString($input)
|
|
%}
|
|
|
|
%typemap(directorout)
|
|
char *, char *&, char[ANY], char[],
|
|
signed char *, signed char *&, signed char[ANY], signed char[],
|
|
unsigned char *, unsigned char *&, unsigned char[ANY], unsigned char[]
|
|
%{ $result = ($1_ltype)$input.p; %}
|
|
|
|
/* String & length */
|
|
|
|
%typemap(gotype) (char *STRING, size_t LENGTH) "string"
|
|
|
|
%typemap(in) (char *STRING, size_t LENGTH)
|
|
%{
|
|
$1 = ($1_ltype)$input.p;
|
|
$2 = ($2_ltype)$input.n;
|
|
%}
|
|
|
|
%typemap(out,fragment="AllocateString") (char *STRING, size_t LENGTH)
|
|
%{ $result = Swig_AllocateString((char*)$1, (size_t)$2); %}
|
|
|
|
%typemap(goout,fragment="CopyString") (char *STRING, size_t LENGTH)
|
|
%{ $result = swigCopyString($1) %}
|
|
|
|
%typemap(directorin,fragment="AllocateString") (char *STRING, size_t LENGTH)
|
|
%{ $input = Swig_AllocateString((char*)$1, $2); %}
|
|
|
|
%typemap(godirectorin,fragment="CopyString") (char *STRING, size_t LENGTH)
|
|
%{ $result = swigCopyString($input) %}
|
|
|
|
%typemap(directorout) (char *STRING, size_t LENGTH)
|
|
%{
|
|
$1 = ($1_ltype)$input.p;
|
|
$2 = ($2_ltype)$input.n;
|
|
%}
|
|
|
|
/* Enums. We can't do the right thing for enums in typemap(gotype) so
|
|
we deliberately don't define them. The right thing would be to
|
|
capitalize the name. This is instead done in go.cxx. */
|
|
|
|
%typemap(gotype) enum SWIGTYPE
|
|
%{$gotypename%}
|
|
|
|
%typemap(in) enum SWIGTYPE
|
|
%{ $1 = ($1_ltype)$input; %}
|
|
|
|
%typemap(out) enum SWIGTYPE
|
|
%{ $result = (intgo)$1; %}
|
|
|
|
%typemap(goout) enum SWIGTYPE ""
|
|
|
|
%typemap(directorin) enum SWIGTYPE
|
|
%{ $input = (intgo)$1; %}
|
|
|
|
%typemap(godirectorin) enum SWIGTYPE ""
|
|
|
|
%typemap(directorout) enum SWIGTYPE
|
|
%{ $result = ($1_ltype)$input; %}
|
|
|
|
%typemap(directorin) enum SWIGTYPE & (intgo e)
|
|
%{
|
|
e = (intgo)$1;
|
|
$input = &e;
|
|
%}
|
|
|
|
%typemap(godirectorin) enum SWIGTYPE & ""
|
|
|
|
%typemap(directorout) enum SWIGTYPE &
|
|
%{
|
|
$*1_ltype f = ($*1_ltype)*$input;
|
|
$result = ($1_ltype)&f;
|
|
%}
|
|
|
|
/* Arbitrary type. This is a type passed by value in the C/C++ code.
|
|
We convert it to a pointer for the Go code. Note that all basic
|
|
types are explicitly handled above. */
|
|
|
|
%typemap(gotype) SWIGTYPE
|
|
%{$gotypename%}
|
|
|
|
%typemap(in) SWIGTYPE ($&1_type argp)
|
|
%{
|
|
argp = ($&1_ltype)$input;
|
|
if (argp == NULL) {
|
|
_swig_gopanic("Attempt to dereference null $1_type");
|
|
}
|
|
$1 = ($1_ltype)*argp;
|
|
%}
|
|
|
|
%typemap(out) SWIGTYPE
|
|
#ifdef __cplusplus
|
|
%{ *($&1_ltype*)&$result = new $1_ltype($1); %}
|
|
#else
|
|
{
|
|
$&1_ltype $1ptr = ($&1_ltype)malloc(sizeof($1_ltype));
|
|
memmove($1ptr, &$1, sizeof($1_type));
|
|
*($&1_ltype*)&$result = $1ptr;
|
|
}
|
|
#endif
|
|
|
|
%typemap(goout) SWIGTYPE ""
|
|
|
|
%typemap(directorin) SWIGTYPE
|
|
%{ $input = ($&1_ltype)&$1; %}
|
|
|
|
%typemap(godirectorin) SWIGTYPE ""
|
|
|
|
%typemap(directorout) SWIGTYPE
|
|
%{ $result = *($&1_ltype)$input; %}
|
|
|
|
/* Exception handling */
|
|
|
|
%typemap(throws) char *
|
|
%{ _swig_gopanic($1); %}
|
|
|
|
%typemap(throws) SWIGTYPE, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE *, SWIGTYPE [], SWIGTYPE [ANY]
|
|
%{
|
|
(void)$1;
|
|
_swig_gopanic("C++ $1_type exception thrown");
|
|
%}
|
|
|
|
/* Typecheck typemaps. The purpose of these is merely to issue a
|
|
warning for overloaded C++ functions that cannot be overloaded in
|
|
Go as more than one C++ type maps to a single Go type. */
|
|
|
|
%typecheck(SWIG_TYPECHECK_BOOL) /* Go bool */
|
|
bool,
|
|
const bool &
|
|
""
|
|
|
|
%typecheck(SWIG_TYPECHECK_CHAR) /* Go byte */
|
|
char,
|
|
const char &,
|
|
unsigned char,
|
|
const unsigned char &
|
|
""
|
|
|
|
%typecheck(SWIG_TYPECHECK_INT8) /* Go int8 */
|
|
signed char,
|
|
const signed char &
|
|
""
|
|
|
|
%typecheck(SWIG_TYPECHECK_INT16) /* Go int16 */
|
|
short,
|
|
const short &
|
|
""
|
|
|
|
%typecheck(SWIG_TYPECHECK_INT16) /* Go uint16 */
|
|
unsigned short,
|
|
const unsigned short &
|
|
""
|
|
|
|
%typecheck(SWIG_TYPECHECK_INT32) /* Go int */
|
|
int,
|
|
const int &
|
|
""
|
|
|
|
%typecheck(SWIG_TYPECHECK_INT32) /* Go uint */
|
|
unsigned int,
|
|
const unsigned int &
|
|
""
|
|
|
|
%typecheck(SWIG_TYPECHECK_INT64) /* Go int64 */
|
|
long,
|
|
const long &,
|
|
long long,
|
|
const long long &
|
|
""
|
|
|
|
%typecheck(SWIG_TYPECHECK_INT64) /* Go uint64 */
|
|
unsigned long,
|
|
const unsigned long &,
|
|
unsigned long long,
|
|
const unsigned long long &
|
|
""
|
|
|
|
%typecheck(SWIG_TYPECHECK_FLOAT) /* Go float32 */
|
|
float,
|
|
const float &
|
|
""
|
|
|
|
%typecheck(SWIG_TYPECHECK_DOUBLE) /* Go float64 */
|
|
double,
|
|
const double &
|
|
""
|
|
|
|
%typecheck(SWIG_TYPECHECK_STRING) /* Go string */
|
|
char *,
|
|
char *&,
|
|
char[ANY],
|
|
char [],
|
|
signed char *,
|
|
signed char *&,
|
|
signed char[ANY],
|
|
signed char [],
|
|
unsigned char *,
|
|
unsigned char *&,
|
|
unsigned char[ANY],
|
|
unsigned char []
|
|
""
|
|
|
|
%typecheck(SWIG_TYPECHECK_POINTER)
|
|
SWIGTYPE,
|
|
SWIGTYPE *,
|
|
SWIGTYPE &,
|
|
SWIGTYPE &&,
|
|
SWIGTYPE *const&,
|
|
SWIGTYPE [],
|
|
SWIGTYPE (CLASS::*)
|
|
""
|
|
|
|
/* Go keywords. */
|
|
%include <gokw.swg>
|
|
|
|
%include <goruntime.swg>
|