| /* ----------------------------------------------------------------------------- |
| * This file is part of SWIG, which is licensed as a whole under version 3 |
| * (or any later version) of the GNU General Public License. Some additional |
| * terms also apply to certain portions of SWIG. The full details of the SWIG |
| * license and copyrights can be found in the LICENSE and COPYRIGHT files |
| * included with the SWIG source code as distributed by the SWIG developers |
| * and at https://www.swig.org/legal.html. |
| * |
| * go.cxx |
| * |
| * Go language module for SWIG. |
| * ----------------------------------------------------------------------------- */ |
| |
| #include "swigmod.h" |
| #include "cparse.h" |
| #include <ctype.h> |
| |
| /* ---------------------------------------------------------------------- |
| * siphash() |
| * |
| * 64-bit SipHash-2-4 to generate unique id for each module |
| * ---------------------------------------------------------------------- */ |
| |
| // An unsigned 64-bit integer that works on a 32-bit host. |
| typedef struct { |
| // Assume unsigned long is at least 32 bits. |
| unsigned long hi; |
| unsigned long lo; |
| } swig_uint64; |
| |
| // Rotate v left by bits, which must be <= 32. |
| static inline void _rotl(swig_uint64 *v, int bits) { |
| assert(bits <= 32); |
| unsigned long tmp = v->hi; |
| if (bits == 32) { |
| v->hi = v->lo; |
| v->lo = tmp; |
| } else { |
| v->hi = (tmp << bits) | ((0xfffffffful & v->lo) >> (32 - bits)); |
| v->lo = (v->lo << bits) | ((0xfffffffful & tmp) >> (32 - bits)); |
| } |
| } |
| |
| // dst ^= src |
| static inline void _xor(swig_uint64 *dst, swig_uint64 *src) { |
| dst->lo ^= src->lo; |
| dst->hi ^= src->hi; |
| } |
| |
| // dst += src |
| static inline void _add(swig_uint64 *dst, swig_uint64 *src) { |
| dst->lo += src->lo; |
| dst->hi += src->hi + ((dst->lo & 0xfffffffful) < (src->lo&0xfffffffful) ? 1 : 0); |
| } |
| #define SIPROUND \ |
| do { \ |
| _add(&v0, &v1); _rotl(&v1, 13); _xor(&v1, &v0); _rotl(&v0, 32); \ |
| _add(&v2, &v3); _rotl(&v3, 16); _xor(&v3, &v2); \ |
| _add(&v0, &v3); _rotl(&v3, 21); _xor(&v3, &v0); \ |
| _add(&v2, &v1); _rotl(&v1, 17); _xor(&v1, &v2); _rotl(&v2, 32); \ |
| } while(0) |
| |
| // Set out to the hash of inc/inlen. |
| static void siphash(swig_uint64 *out, const char *inc, unsigned long inlen) { |
| /* "somepseudorandomlygeneratedbytes" */ |
| swig_uint64 v0 = {0x736f6d65UL, 0x70736575UL}; |
| swig_uint64 v1 = {0x646f7261UL, 0x6e646f6dUL}; |
| swig_uint64 v2 = {0x6c796765UL, 0x6e657261UL}; |
| swig_uint64 v3 = {0x74656462UL, 0x79746573UL}; |
| swig_uint64 b; |
| /* hard-coded k. */ |
| swig_uint64 k0 = {0x07060504UL, 0x03020100UL}; |
| swig_uint64 k1 = {0x0F0E0D0CUL, 0x0B0A0908UL}; |
| int i; |
| const int cROUNDS = 2, dROUNDS = 4; |
| const unsigned char *in = (const unsigned char *)inc; |
| const unsigned char *end = in + inlen - (inlen % 8); |
| int left = inlen & 7; |
| _xor(&v3, &k1); _xor(&v2, &k0); _xor(&v1, &k1); _xor(&v0, &k0); |
| for (; in != end; in += 8) { |
| b.hi = 0; b.lo = 0; |
| for (i = 0; i < 4; i++) { |
| b.lo |= ((unsigned long)in[i]) << (8*i); |
| } |
| for (i = 0; i < 4; i++) { |
| b.hi |= ((unsigned long)in[i+4]) << (8*i); |
| } |
| _xor(&v3, &b); |
| for (i = 0; i < cROUNDS; i++) { |
| SIPROUND; |
| } |
| _xor(&v0, &b); |
| } |
| b.hi = (inlen & 0xff)<<24; b.lo = 0; |
| for (; left; left--) { |
| if (left > 4) { |
| b.hi |= ((unsigned long)in[left-1]) << (8*left-8-32); |
| } else { |
| b.lo |= ((unsigned long)in[left-1]) << (8*left-8); |
| } |
| } |
| _xor(&v3, &b); |
| for(i=0; i<cROUNDS; i++) { |
| SIPROUND; |
| } |
| _xor(&v0, &b); v2.lo ^= 0xff; |
| for(i=0; i<dROUNDS; i++) { |
| SIPROUND; |
| } |
| out->lo = 0; out->hi = 0; |
| _xor(out, &v0); _xor(out, &v1); _xor(out, &v2); _xor(out, &v3); |
| } |
| #undef SIPROUND |
| |
| class GO:public Language { |
| static const char *const usage; |
| |
| // Go package name. |
| String *package; |
| // SWIG module name. |
| String *module; |
| // Flag for generating gccgo output. |
| bool gccgo_flag; |
| // Prefix to use with gccgo. |
| String *go_prefix; |
| // -fgo-prefix option. |
| String *prefix_option; |
| // -fgo-pkgpath option. |
| String *pkgpath_option; |
| // Prefix for translating %import directive to import statements. |
| String *import_prefix; |
| // Whether to use a shared library. |
| bool use_shlib; |
| // Name of shared library to import. |
| String *soname; |
| // Size in bits of the Go type "int". 0 if not specified. |
| int intgo_type_size; |
| |
| /* Output files */ |
| File *f_c_begin; |
| File *f_go_begin; |
| |
| /* Output fragments */ |
| File *f_c_runtime; |
| File *f_c_header; |
| File *f_c_wrappers; |
| File *f_c_init; |
| File *f_c_directors; |
| File *f_c_directors_h; |
| File *f_go_imports; |
| File *f_go_runtime; |
| File *f_go_header; |
| File *f_go_wrappers; |
| File *f_go_directors; |
| File *f_cgo_comment; |
| File *f_cgo_comment_typedefs; |
| |
| // True if we imported a module. |
| bool saw_import; |
| // If not NULL, name of import package being processed. |
| String *imported_package; |
| // Build interface methods while handling a class. This is only |
| // non-NULL when we are handling methods. |
| String *interfaces; |
| // The class node while handling a class. This is only non-NULL |
| // when we are handling methods. |
| Node *class_node; |
| // The class name while handling a class. This is only non-NULL |
| // when we are handling methods. This is the name of the class as |
| // SWIG sees it. |
| String *class_name; |
| // The receiver name while handling a class. This is only non-NULL |
| // when we are handling methods. This is the name of the class |
| // as run through goCPointerType. |
| String *class_receiver; |
| // A hash table of method names that we have seen when processing a |
| // class. This lets us detect base class methods that we don't want |
| // to use. |
| Hash *class_methods; |
| // True when we are generating the wrapper functions for a variable. |
| bool making_variable_wrappers; |
| // True when working with a static member function. |
| bool is_static_member_function; |
| // A hash table of enum types that we have seen but which may not have |
| // been defined. The index is a SwigType. |
| Hash *undefined_enum_types; |
| // A hash table of types that we have seen but which may not have |
| // been defined. The index is a SwigType. |
| Hash *undefined_types; |
| // A hash table of classes which were defined. The index is a Go |
| // type name. |
| Hash *defined_types; |
| // A hash table of all the go_imports already imported. The index is a full |
| // import name e.g. '"runtime"' or '_ "runtime/cgo"' or 'sc "syscall"'. |
| Hash *go_imports; |
| // A unique ID used to make public symbols unique. |
| String *unique_id; |
| |
| public: |
| GO():package(NULL), |
| module(NULL), |
| gccgo_flag(false), |
| go_prefix(NULL), |
| prefix_option(NULL), |
| pkgpath_option(NULL), |
| import_prefix(NULL), |
| use_shlib(false), |
| soname(NULL), |
| intgo_type_size(0), |
| f_c_begin(NULL), |
| f_go_begin(NULL), |
| f_c_runtime(NULL), |
| f_c_header(NULL), |
| f_c_wrappers(NULL), |
| f_c_init(NULL), |
| f_c_directors(NULL), |
| f_c_directors_h(NULL), |
| f_go_imports(NULL), |
| f_go_runtime(NULL), |
| f_go_header(NULL), |
| f_go_wrappers(NULL), |
| f_go_directors(NULL), |
| f_cgo_comment(NULL), |
| f_cgo_comment_typedefs(NULL), |
| saw_import(false), |
| imported_package(NULL), |
| interfaces(NULL), |
| class_node(NULL), |
| class_name(NULL), |
| class_receiver(NULL), |
| class_methods(NULL), |
| making_variable_wrappers(false), |
| is_static_member_function(false), |
| undefined_enum_types(NULL), |
| undefined_types(NULL), |
| defined_types(NULL), |
| go_imports(NULL), |
| unique_id(NULL) { |
| director_multiple_inheritance = 1; |
| director_language = 1; |
| director_prot_ctor_code = NewString("_swig_gopanic(\"accessing abstract class or protected constructor\");"); |
| } |
| |
| private: |
| /* ------------------------------------------------------------ |
| * main() |
| * ------------------------------------------------------------ */ |
| virtual void main(int argc, char *argv[]) { |
| |
| SWIG_library_directory("go"); |
| bool saw_nocgo_flag = false; |
| |
| // Process command line options. |
| for (int i = 1; i < argc; i++) { |
| if (argv[i]) { |
| if (strcmp(argv[i], "-package") == 0) { |
| if (argv[i + 1]) { |
| package = NewString(argv[i + 1]); |
| Swig_mark_arg(i); |
| Swig_mark_arg(i + 1); |
| i++; |
| } else { |
| Swig_arg_error(); |
| } |
| } else if (strcmp(argv[i], "-cgo") == 0) { |
| Swig_mark_arg(i); |
| } else if (strcmp(argv[i], "-no-cgo") == 0) { |
| Swig_mark_arg(i); |
| saw_nocgo_flag = true; |
| } else if (strcmp(argv[i], "-gccgo") == 0) { |
| Swig_mark_arg(i); |
| gccgo_flag = true; |
| } else if (strcmp(argv[i], "-go-prefix") == 0) { |
| if (argv[i + 1]) { |
| prefix_option = NewString(argv[i + 1]); |
| Swig_mark_arg(i); |
| Swig_mark_arg(i + 1); |
| i++; |
| } else { |
| Swig_arg_error(); |
| } |
| } else if (strcmp(argv[i], "-go-pkgpath") == 0) { |
| if (argv[i + 1]) { |
| pkgpath_option = NewString(argv[i + 1]); |
| Swig_mark_arg(i); |
| Swig_mark_arg(i + 1); |
| i++; |
| } else { |
| Swig_arg_error(); |
| } |
| } else if (strcmp(argv[i], "-import-prefix") == 0) { |
| if (argv[i + 1]) { |
| import_prefix = NewString(argv[i + 1]); |
| Swig_mark_arg(i); |
| Swig_mark_arg(i + 1); |
| i++; |
| } else { |
| Swig_arg_error(); |
| } |
| } else if (strcmp(argv[i], "-use-shlib") == 0) { |
| Swig_mark_arg(i); |
| use_shlib = true; |
| } else if (strcmp(argv[i], "-soname") == 0) { |
| if (argv[i + 1]) { |
| soname = NewString(argv[i + 1]); |
| Swig_mark_arg(i); |
| Swig_mark_arg(i + 1); |
| i++; |
| } else { |
| Swig_arg_error(); |
| } |
| } else if (strcmp(argv[i], "-longsize") == 0) { |
| // Ignore for backward compatibility. |
| if (argv[i + 1]) { |
| Swig_mark_arg(i); |
| Swig_mark_arg(i + 1); |
| ++i; |
| } else { |
| Swig_arg_error(); |
| } |
| } else if (strcmp(argv[i], "-intgosize") == 0) { |
| if (argv[i + 1]) { |
| intgo_type_size = atoi(argv[i + 1]); |
| if (intgo_type_size != 32 && intgo_type_size != 64) { |
| Printf(stderr, "-intgosize not 32 or 64\n"); |
| Swig_arg_error(); |
| } |
| Swig_mark_arg(i); |
| Swig_mark_arg(i + 1); |
| ++i; |
| } else { |
| Swig_arg_error(); |
| } |
| } else if (strcmp(argv[i], "-help") == 0) { |
| Printf(stdout, "%s\n", usage); |
| } |
| } |
| } |
| |
| if (saw_nocgo_flag) { |
| Printf(stderr, "SWIG -go: -no-cgo option is no longer supported\n"); |
| Exit(EXIT_FAILURE); |
| } |
| |
| if (gccgo_flag && !pkgpath_option && !prefix_option) { |
| prefix_option = NewString("go"); |
| } |
| |
| // Add preprocessor symbol to parser. |
| Preprocessor_define("SWIGGO 1", 0); |
| |
| if (gccgo_flag) { |
| Preprocessor_define("SWIGGO_GCCGO 1", 0); |
| } |
| |
| if (intgo_type_size == 32) { |
| Preprocessor_define("SWIGGO_INTGO_SIZE 32", 0); |
| } else if (intgo_type_size == 64) { |
| Preprocessor_define("SWIGGO_INTGO_SIZE 64", 0); |
| } else { |
| Preprocessor_define("SWIGGO_INTGO_SIZE 0", 0); |
| } |
| |
| // Add typemap definitions. |
| SWIG_typemap_lang("go"); |
| SWIG_config_file("go.swg"); |
| |
| allow_overloading(); |
| } |
| |
| /* --------------------------------------------------------------------- |
| * top() |
| * |
| * For gc, we are going to create the following files: |
| * |
| * 1) A .c or .cxx file compiled with gcc. This file will contain |
| * function wrappers. Each wrapper will take a pointer to a |
| * struct holding the arguments, unpack them, and call the real |
| * function. |
| * |
| * 2) A .go file which defines the Go form of all types, and which |
| * defines Go function wrappers. Each wrapper will call the C |
| * function wrapper in the second file. |
| * |
| * 3) A .c file compiled with 6c/8c. This file will define |
| * Go-callable C function wrappers. Each wrapper will use |
| * cgocall to call the function wrappers in the first file. |
| * |
| * When generating code for gccgo, we don't need the third file, and |
| * the function wrappers in the first file have a different form. |
| * |
| * --------------------------------------------------------------------- */ |
| |
| virtual int top(Node *n) { |
| Node *optionsnode = Getattr(Getattr(n, "module"), "options"); |
| if (optionsnode) { |
| if (Getattr(optionsnode, "directors")) { |
| allow_directors(); |
| } |
| if (Getattr(optionsnode, "dirprot")) { |
| allow_dirprot(); |
| } |
| allow_allprotected(GetFlag(optionsnode, "allprotected")); |
| } |
| |
| module = Getattr(n, "name"); |
| if (!package) { |
| package = Copy(module); |
| } |
| if (!soname && use_shlib) { |
| soname = Copy(package); |
| Append(soname, ".so"); |
| } |
| |
| if (gccgo_flag) { |
| String *pref; |
| if (pkgpath_option) { |
| pref = pkgpath_option; |
| } else { |
| pref = prefix_option; |
| } |
| go_prefix = NewString(""); |
| for (char *p = Char(pref); *p != '\0'; p++) { |
| if ((*p >= 'A' && *p <= 'Z') || (*p >= 'a' && *p <= 'z') || (*p >= '0' && *p <= '9') || *p == '.' || *p == '$') { |
| Putc(*p, go_prefix); |
| } else { |
| Putc('_', go_prefix); |
| } |
| } |
| if (!pkgpath_option) { |
| Append(go_prefix, "."); |
| Append(go_prefix, getModuleName(package)); |
| } |
| } |
| |
| // Get filenames. |
| |
| String *swig_filename = Getattr(n, "infile"); |
| String *c_filename = Getattr(n, "outfile"); |
| String *c_filename_h = Getattr(n, "outfile_h"); |
| |
| String *go_filename = NewString(""); |
| Printf(go_filename, "%s%s.go", SWIG_output_directory(), module); |
| |
| // Generate a unique ID based on a hash of the SWIG input. |
| swig_uint64 hash = {0, 0}; |
| FILE *swig_input = Swig_open(swig_filename); |
| if (swig_input == NULL) { |
| FileErrorDisplay(swig_filename); |
| Exit(EXIT_FAILURE); |
| } |
| String *swig_input_content = Swig_read_file(swig_input); |
| siphash(&hash, Char(swig_input_content), Len(swig_input_content)); |
| Delete(swig_input_content); |
| fclose(swig_input); |
| unique_id = NewString(""); |
| Printf(unique_id, "_%s_%08x%08x", getModuleName(package), hash.hi, hash.lo); |
| |
| // Open files. |
| |
| f_c_begin = NewFile(c_filename, "w", SWIG_output_files()); |
| if (!f_c_begin) { |
| FileErrorDisplay(c_filename); |
| Exit(EXIT_FAILURE); |
| } |
| |
| if (directorsEnabled()) { |
| if (!c_filename_h) { |
| Printf(stderr, "Unable to determine outfile_h\n"); |
| Exit(EXIT_FAILURE); |
| } |
| f_c_directors_h = NewFile(c_filename_h, "w", SWIG_output_files()); |
| if (!f_c_directors_h) { |
| FileErrorDisplay(c_filename_h); |
| Exit(EXIT_FAILURE); |
| } |
| } |
| |
| f_go_begin = NewFile(go_filename, "w", SWIG_output_files()); |
| if (!f_go_begin) { |
| FileErrorDisplay(go_filename); |
| Exit(EXIT_FAILURE); |
| } |
| |
| f_c_runtime = NewString(""); |
| f_c_header = NewString(""); |
| f_c_wrappers = NewString(""); |
| f_c_init = NewString(""); |
| f_c_directors = NewString(""); |
| f_go_imports = NewString(""); |
| f_go_runtime = NewString(""); |
| f_go_header = NewString(""); |
| f_go_wrappers = NewString(""); |
| f_go_directors = NewString(""); |
| f_cgo_comment = NewString(""); |
| f_cgo_comment_typedefs = NewString(""); |
| |
| Swig_register_filebyname("begin", f_c_begin); |
| Swig_register_filebyname("runtime", f_c_runtime); |
| Swig_register_filebyname("header", f_c_header); |
| Swig_register_filebyname("wrapper", f_c_wrappers); |
| Swig_register_filebyname("init", f_c_init); |
| Swig_register_filebyname("director", f_c_directors); |
| Swig_register_filebyname("director_h", f_c_directors_h); |
| Swig_register_filebyname("go_begin", f_go_begin); |
| Swig_register_filebyname("go_imports", f_go_imports); |
| Swig_register_filebyname("go_runtime", f_go_runtime); |
| Swig_register_filebyname("go_header", f_go_header); |
| Swig_register_filebyname("go_wrapper", f_go_wrappers); |
| Swig_register_filebyname("go_director", f_go_directors); |
| Swig_register_filebyname("cgo_comment", f_cgo_comment); |
| Swig_register_filebyname("cgo_comment_typedefs", f_cgo_comment_typedefs); |
| |
| Swig_banner(f_c_begin); |
| |
| Swig_obligatory_macros(f_c_runtime, "GO"); |
| |
| if (CPlusPlus) { |
| Printf(f_c_begin, "\n// source: %s\n\n", swig_filename); |
| } else { |
| Printf(f_c_begin, "\n/* source: %s */\n\n", swig_filename); |
| } |
| |
| Printf(f_c_runtime, "#define SWIGMODULE %s\n", module); |
| |
| if (gccgo_flag) { |
| Printf(f_c_runtime, "#define SWIGGO_PREFIX %s\n", go_prefix); |
| } |
| |
| if (directorsEnabled()) { |
| Printf(f_c_runtime, "#define SWIG_DIRECTORS\n"); |
| |
| Swig_banner(f_c_directors_h); |
| Printf(f_c_directors_h, "\n// source: %s\n\n", swig_filename); |
| |
| Printf(f_c_directors_h, "#ifndef SWIG_%s_WRAP_H_\n", module); |
| Printf(f_c_directors_h, "#define SWIG_%s_WRAP_H_\n\n", module); |
| Printf(f_c_directors_h, "class Swig_memory;\n\n"); |
| |
| Printf(f_c_directors, "\n// C++ director class methods.\n"); |
| String *filename = Swig_file_filename(c_filename_h); |
| Printf(f_c_directors, "#include \"%s\"\n\n", filename); |
| Delete(filename); |
| } |
| |
| Swig_banner(f_go_begin); |
| Printf(f_go_begin, "\n// source: %s\n", swig_filename); |
| |
| Printv(f_cgo_comment_typedefs, "/*\n", NULL); |
| |
| // The cgo program defines the intgo type after our function |
| // definitions, but we want those definitions to be able to use |
| // intgo also. |
| Printv(f_cgo_comment_typedefs, "#define intgo swig_intgo\n", NULL); |
| Printv(f_cgo_comment_typedefs, "typedef void *swig_voidp;\n", NULL); |
| |
| // Output module initialization code. |
| |
| Printf(f_go_begin, "\npackage %s\n\n", getModuleName(package)); |
| |
| // All the C++ wrappers should be extern "C". |
| |
| Printv(f_c_wrappers, "#ifdef __cplusplus\n", "extern \"C\" {\n", "#endif\n\n", NULL); |
| |
| // Set up the hash table for types not defined by SWIG. |
| |
| undefined_enum_types = NewHash(); |
| undefined_types = NewHash(); |
| defined_types = NewHash(); |
| go_imports = NewHash(); |
| |
| // Emit code. |
| |
| Language::top(n); |
| |
| if (directorsEnabled()) { |
| // Insert director runtime into the f_runtime file (make it occur before %header section) |
| Swig_insert_file("director_common.swg", f_c_runtime); |
| Swig_insert_file("director.swg", f_c_runtime); |
| } |
| |
| Delete(go_imports); |
| |
| // Write out definitions for the types not defined by SWIG. |
| |
| if (Len(undefined_enum_types) > 0) |
| Printv(f_go_wrappers, "\n", NULL); |
| for (Iterator p = First(undefined_enum_types); p.key; p = Next(p)) { |
| String *name = p.item; |
| Printv(f_go_wrappers, "type ", name, " int\n", NULL); |
| } |
| |
| Printv(f_go_wrappers, "\n", NULL); |
| for (Iterator p = First(undefined_types); p.key; p = Next(p)) { |
| String *ty = goType(NULL, p.key); |
| if (!Getattr(defined_types, ty)) { |
| String *cp = goCPointerType(p.key, false); |
| if (!Getattr(defined_types, cp)) { |
| Printv(f_go_wrappers, "type ", cp, " uintptr\n", NULL); |
| Printv(f_go_wrappers, "type ", ty, " interface {\n", NULL); |
| Printv(f_go_wrappers, "\tSwigcptr() uintptr;\n", NULL); |
| Printv(f_go_wrappers, "}\n", NULL); |
| Printv(f_go_wrappers, "func (p ", cp, ") Swigcptr() uintptr {\n", NULL); |
| Printv(f_go_wrappers, "\treturn uintptr(p)\n", NULL); |
| Printv(f_go_wrappers, "}\n\n", NULL); |
| } |
| Delete(cp); |
| } |
| Delete(ty); |
| } |
| Delete(undefined_enum_types); |
| Delete(undefined_types); |
| Delete(defined_types); |
| |
| /* Write and cleanup */ |
| |
| Dump(f_c_header, f_c_runtime); |
| |
| if (directorsEnabled()) { |
| Printf(f_c_directors_h, "#endif\n"); |
| Delete(f_c_directors_h); |
| f_c_directors_h = NULL; |
| |
| Dump(f_c_directors, f_c_runtime); |
| Delete(f_c_directors); |
| f_c_directors = NULL; |
| } |
| |
| // End the extern "C". |
| Printv(f_c_wrappers, "#ifdef __cplusplus\n", "}\n", "#endif\n\n", NULL); |
| |
| // End the cgo comment. |
| Printv(f_cgo_comment, "#undef intgo\n", NULL); |
| Printv(f_cgo_comment, "*/\n", NULL); |
| Printv(f_cgo_comment, "import \"C\"\n", NULL); |
| Printv(f_cgo_comment, "\n", NULL); |
| |
| bool need_panic = false; |
| if (Strstr(f_c_runtime, "SWIG_contract_assert(") != 0 || Strstr(f_c_wrappers, "SWIG_contract_assert(") != 0) { |
| Printv(f_c_begin, "\n#define SWIG_contract_assert(expr, msg) if (!(expr)) { _swig_gopanic(msg); } else\n\n", NULL); |
| need_panic = true; |
| } |
| |
| if (!gccgo_flag && (need_panic || Strstr(f_c_runtime, "_swig_gopanic") != 0 || Strstr(f_c_wrappers, "_swig_gopanic") != 0)) { |
| Printv(f_go_header, "//export cgo_panic_", unique_id, "\n", NULL); |
| Printv(f_go_header, "func cgo_panic_", unique_id, "(p *byte) {\n", NULL); |
| Printv(f_go_header, "\ts := (*[1024]byte)(unsafe.Pointer(p))[:]\n", NULL); |
| Printv(f_go_header, "\tfor i, b := range s {\n", NULL); |
| Printv(f_go_header, "\t\tif b == 0 {\n", NULL); |
| Printv(f_go_header, "\t\t\tpanic(string(s[:i]))\n", NULL); |
| Printv(f_go_header, "\t\t}\n", NULL); |
| Printv(f_go_header, "\t}\n", NULL); |
| Printv(f_go_header, "\tpanic(string(s))\n", NULL); |
| Printv(f_go_header, "}\n\n", NULL); |
| |
| Printv(f_c_begin, "\nextern\n", NULL); |
| Printv(f_c_begin, "#ifdef __cplusplus\n", NULL); |
| Printv(f_c_begin, " \"C\"\n", NULL); |
| Printv(f_c_begin, "#endif\n", NULL); |
| Printv(f_c_begin, " void cgo_panic_", unique_id, "(const char*);\n", NULL); |
| Printv(f_c_begin, "static void _swig_gopanic(const char *p) {\n", NULL); |
| Printv(f_c_begin, " cgo_panic_", unique_id, "(p);\n", NULL); |
| Printv(f_c_begin, "}\n\n", NULL); |
| } |
| |
| Dump(f_c_runtime, f_c_begin); |
| Dump(f_c_wrappers, f_c_begin); |
| Dump(f_c_init, f_c_begin); |
| Dump(f_cgo_comment_typedefs, f_go_begin); |
| Dump(f_cgo_comment, f_go_begin); |
| Dump(f_go_imports, f_go_begin); |
| Dump(f_go_header, f_go_begin); |
| Dump(f_go_runtime, f_go_begin); |
| Dump(f_go_wrappers, f_go_begin); |
| if (directorsEnabled()) { |
| Dump(f_go_directors, f_go_begin); |
| } |
| Delete(f_c_runtime); |
| Delete(f_c_header); |
| Delete(f_c_wrappers); |
| Delete(f_c_init); |
| Delete(f_go_imports); |
| Delete(f_go_runtime); |
| Delete(f_go_header); |
| Delete(f_go_wrappers); |
| Delete(f_go_directors); |
| Delete(f_cgo_comment); |
| Delete(f_cgo_comment_typedefs); |
| Delete(f_c_begin); |
| Delete(f_go_begin); |
| |
| return SWIG_OK; |
| } |
| |
| /* ------------------------------------------------------------ |
| * importDirective() |
| * |
| * Handle a SWIG import statement by generating a Go import |
| * statement. |
| * ------------------------------------------------------------ */ |
| |
| virtual int importDirective(Node *n) { |
| String *hold_import = imported_package; |
| String *modname = Getattr(n, "module"); |
| if (modname) { |
| if (!Getattr(go_imports, modname)) { |
| Setattr(go_imports, modname, modname); |
| Printv(f_go_imports, "import \"", NULL); |
| if (import_prefix) { |
| Printv(f_go_imports, import_prefix, "/", NULL); |
| } |
| Printv(f_go_imports, modname, "\"\n", NULL); |
| } |
| imported_package = modname; |
| saw_import = true; |
| } |
| int r = Language::importDirective(n); |
| imported_package = hold_import; |
| return r; |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * Language::insertDirective() |
| * |
| * If the section is go_imports, store them for later. |
| * ---------------------------------------------------------------------- */ |
| virtual int insertDirective(Node *n) { |
| char *section = Char(Getattr(n, "section")); |
| if ((ImportMode && !Getattr(n, "generated")) || |
| !section || (strcmp(section, "go_imports") != 0)) { |
| return Language::insertDirective(n); |
| } |
| |
| char *code = Char(Getattr(n, "code")); |
| char *pch = strtok(code, ","); |
| while (pch != NULL) { |
| // Do not import same thing more than once. |
| if (!Getattr(go_imports, pch)) { |
| Setattr(go_imports, pch, pch); |
| Printv(f_go_imports, "import ", pch, "\n", NULL); |
| } |
| pch = strtok(NULL, ","); |
| } |
| return SWIG_OK; |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * functionWrapper() |
| * |
| * Implement a function. |
| * ---------------------------------------------------------------------- */ |
| |
| virtual int functionWrapper(Node *n) { |
| if (GetFlag(n, "feature:ignore")) { |
| return SWIG_OK; |
| } |
| |
| // We don't need explicit calls. |
| if (GetFlag(n, "explicitcall")) { |
| return SWIG_OK; |
| } |
| |
| // Don't emit constructors for abstract director classes. They |
| // will never succeed anyhow. |
| if (Swig_methodclass(n) && Swig_directorclass(n) |
| && Strcmp(Char(Getattr(n, "wrap:action")), director_prot_ctor_code) == 0) { |
| return SWIG_OK; |
| } |
| |
| String *name = Getattr(n, "sym:name"); |
| String *nodetype = Getattr(n, "nodeType"); |
| bool is_static = is_static_member_function || isStatic(n); |
| bool is_friend = isFriend(n); |
| bool is_ctor_dtor = false; |
| |
| SwigType *result = Getattr(n, "type"); |
| |
| // For some reason SWIG changs the "type" value during the call to |
| // functionWrapper. We need to remember the type for possible |
| // overload processing. |
| Setattr(n, "go:type", Copy(result)); |
| |
| String *go_name; |
| |
| String *r1 = NULL; |
| if (making_variable_wrappers) { |
| // Change the name of the variable setter and getter functions |
| // to be more Go like. |
| |
| bool is_set = Strcmp(Char(name) + Len(name) - 4, "_set") == 0; |
| assert(is_set || Strcmp(Char(name) + Len(name) - 4, "_get") == 0); |
| |
| // Start with Set or Get. |
| go_name = NewString(is_set ? "Set" : "Get"); |
| |
| // If this is a static variable, put in the class name, |
| // capitalized. |
| if (is_static && class_name) { |
| String *ccn = exportedName(class_name); |
| Append(go_name, ccn); |
| Delete(ccn); |
| } |
| |
| // Add the rest of the name, capitalized, dropping the _set or |
| // _get. |
| String *c1 = removeClassname(name); |
| String *c2 = exportedName(c1); |
| char *p = Char(c2); |
| int len = Len(p); |
| for (int i = 0; i < len - 4; ++i) { |
| Putc(p[i], go_name); |
| } |
| Delete(c2); |
| Delete(c1); |
| |
| if (!checkIgnoredParameters(n, go_name)) { |
| Delete(go_name); |
| return SWIG_NOWRAP; |
| } |
| } else if (Cmp(nodetype, "constructor") == 0) { |
| is_ctor_dtor = true; |
| |
| // Change the name of a constructor to be more Go like. Change |
| // new_ to New, and capitalize the class name. |
| assert(Strncmp(name, "new_", 4) == 0); |
| String *c1 = NewString(Char(name) + 4); |
| String *c2 = exportedName(c1); |
| go_name = NewString("New"); |
| Append(go_name, c2); |
| Delete(c2); |
| Delete(c1); |
| |
| if (Swig_methodclass(n) && Swig_directorclass(n)) { |
| // The core SWIG code skips the first parameter when |
| // generating the $nondirector_new string. Recreate the |
| // action in this case. But don't it if we are using the |
| // special code for an abstract class. |
| String *call = Swig_cppconstructor_call(getClassType(), |
| Getattr(n, "parms")); |
| SwigType *type = Copy(getClassType()); |
| SwigType_add_pointer(type); |
| String *cres = Swig_cresult(type, Swig_cresult_name(), call); |
| Setattr(n, "wrap:action", cres); |
| } |
| } else if (Cmp(nodetype, "destructor") == 0) { |
| // No need to emit protected destructors. |
| if (!is_public(n)) { |
| return SWIG_OK; |
| } |
| |
| is_ctor_dtor = true; |
| |
| // Change the name of a destructor to be more Go like. Change |
| // delete_ to Delete and capitalize the class name. |
| assert(Strncmp(name, "delete_", 7) == 0); |
| String *c1 = NewString(Char(name) + 7); |
| String *c2 = exportedName(c1); |
| go_name = NewString("Delete"); |
| Append(go_name, c2); |
| Delete(c2); |
| Delete(c1); |
| |
| result = NewString("void"); |
| r1 = result; |
| } else { |
| if (!checkFunctionVisibility(n, NULL)) { |
| return SWIG_OK; |
| } |
| |
| go_name = buildGoName(name, is_static, is_friend); |
| |
| if (!checkIgnoredParameters(n, go_name)) { |
| Delete(go_name); |
| return SWIG_NOWRAP; |
| } |
| } |
| |
| String *overname = NULL; |
| if (Getattr(n, "sym:overloaded")) { |
| overname = Getattr(n, "sym:overname"); |
| } else { |
| String *scope; |
| if (!class_name || is_static || is_ctor_dtor) { |
| scope = NULL; |
| } else { |
| scope = NewString("swiggoscope."); |
| Append(scope, class_name); |
| } |
| if (!checkNameConflict(go_name, n, scope)) { |
| Delete(go_name); |
| return SWIG_NOWRAP; |
| } |
| } |
| |
| String *wname = Swig_name_wrapper(name); |
| if (overname) { |
| Append(wname, overname); |
| } |
| Append(wname, unique_id); |
| Setattr(n, "wrap:name", wname); |
| |
| ParmList *parms = Getattr(n, "parms"); |
| Setattr(n, "wrap:parms", parms); |
| |
| int r = makeWrappers(n, go_name, overname, wname, NULL, parms, result, is_static); |
| if (r != SWIG_OK) { |
| return r; |
| } |
| |
| if (Getattr(n, "sym:overloaded") && !Getattr(n, "sym:nextSibling")) { |
| String *scope ; |
| if (!class_name || is_static || is_ctor_dtor) { |
| scope = NULL; |
| } else { |
| scope = NewString("swiggoscope."); |
| Append(scope, class_name); |
| } |
| if (!checkNameConflict(go_name, n, scope)) { |
| Delete(go_name); |
| return SWIG_NOWRAP; |
| } |
| |
| String *receiver = class_receiver; |
| if (is_static || is_ctor_dtor) { |
| receiver = NULL; |
| } |
| r = makeDispatchFunction(n, go_name, receiver, is_static, NULL, false); |
| if (r != SWIG_OK) { |
| return r; |
| } |
| } |
| |
| Delete(wname); |
| Delete(go_name); |
| Delete(r1); |
| |
| return SWIG_OK; |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * staticmemberfunctionHandler() |
| * |
| * For some reason the language code removes the "storage" attribute |
| * for a static function before calling functionWrapper, which means |
| * that we have no way of knowing whether a function is static or |
| * not. That makes no sense in the Go context. Here we note that a |
| * function is static. |
| * ---------------------------------------------------------------------- */ |
| |
| int staticmemberfunctionHandler(Node *n) { |
| assert(!is_static_member_function); |
| is_static_member_function = true; |
| int r = Language::staticmemberfunctionHandler(n); |
| is_static_member_function = false; |
| return r; |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * makeWrappers() |
| * |
| * Write out the various function wrappers. |
| * n: The function we are emitting. |
| * go_name: The name of the function in Go. |
| * overname: The overload string for overloaded function. |
| * wname: The SWIG wrapped name--the name of the C function. |
| * base: A list of the names of base classes, in the case where this |
| * is a virtual method not defined in the current class. |
| * parms: The parameters. |
| * result: The result type. |
| * is_static: Whether this is a static method or member. |
| * ---------------------------------------------------------------------- */ |
| |
| int makeWrappers(Node *n, String *go_name, String *overname, String *wname, List *base, ParmList *parms, SwigType *result, bool is_static) { |
| |
| assert(result); |
| |
| int ret = SWIG_OK; |
| |
| int r = makeCgoWrappers(n, go_name, overname, wname, base, parms, result, is_static); |
| if (r != SWIG_OK) { |
| ret = r; |
| } |
| |
| if (class_methods) { |
| Setattr(class_methods, Getattr(n, "name"), NewString("")); |
| } |
| |
| return ret; |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * struct cgoWrapperInfo |
| * |
| * Information needed by the CGO wrapper functions. |
| * ---------------------------------------------------------------------- */ |
| |
| struct cgoWrapperInfo { |
| // The function we are generating code for. |
| Node *n; |
| // The name of the Go function. |
| String *go_name; |
| // The overload string for an overloaded function. |
| String *overname; |
| // The name of the C wrapper function. |
| String *wname; |
| // The base classes. |
| List *base; |
| // The parameters. |
| ParmList *parms; |
| // The result type. |
| SwigType *result; |
| // Whether this is a static function, not a class method. |
| bool is_static; |
| // The Go receiver type. |
| String *receiver; |
| // Whether this is a class constructor. |
| bool is_constructor; |
| // Whether this is a class destructor. |
| bool is_destructor; |
| }; |
| |
| /* ---------------------------------------------------------------------- |
| * makeCgoWrappers() |
| * |
| * Write out the wrappers for a function when producing cgo input |
| * files. |
| * ---------------------------------------------------------------------- */ |
| |
| int makeCgoWrappers(Node *n, String *go_name, String *overname, String *wname, List *base, ParmList *parms, SwigType *result, bool is_static) { |
| Swig_save("makeCgoWrappers", n, "emit:cgotype", "emit:cgotypestruct", NULL); |
| |
| cgoWrapperInfo info; |
| |
| info.n = n; |
| info.go_name = go_name; |
| info.overname = overname; |
| info.wname = wname; |
| info.base = base; |
| info.parms = parms; |
| info.result = result; |
| info.is_static = is_static; |
| |
| info.receiver = class_receiver; |
| if (is_static) { |
| info.receiver = NULL; |
| } |
| |
| String *nodetype = Getattr(n, "nodeType"); |
| info.is_constructor = Cmp(nodetype, "constructor") == 0; |
| info.is_destructor = Cmp(nodetype, "destructor") == 0; |
| if (info.is_constructor || info.is_destructor) { |
| assert(class_receiver); |
| assert(!base); |
| info.receiver = NULL; |
| } |
| |
| int ret = SWIG_OK; |
| |
| int r = cgoGoWrapper(&info); |
| if (r != SWIG_OK) { |
| ret = r; |
| } |
| |
| r = cgoCommentWrapper(&info); |
| if (r != SWIG_OK) { |
| ret = r; |
| } |
| |
| r = cgoGccWrapper(&info); |
| if (r != SWIG_OK) { |
| ret = r; |
| } |
| |
| Swig_restore(n); |
| |
| return ret; |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * cgoGoWrapper() |
| * |
| * Write out Go code to call a cgo function. This code will go into |
| * the generated Go output file. |
| * ---------------------------------------------------------------------- */ |
| int cgoGoWrapper(const cgoWrapperInfo *info) { |
| |
| Wrapper *dummy = initGoTypemaps(info->parms); |
| |
| bool add_to_interface = interfaces && !info->is_constructor && !info->is_destructor && !info->is_static && !info->overname && checkFunctionVisibility(info->n, NULL); |
| |
| Printv(f_go_wrappers, "func ", NULL); |
| |
| Parm *p = info->parms; |
| int pi = 0; |
| |
| // Add the receiver first if this is a method. |
| if (info->receiver) { |
| Printv(f_go_wrappers, "(", NULL); |
| if (info->base && info->receiver) { |
| Printv(f_go_wrappers, "_swig_base", NULL); |
| } else { |
| Printv(f_go_wrappers, Getattr(p, "lname"), NULL); |
| p = nextParm(p); |
| ++pi; |
| } |
| Printv(f_go_wrappers, " ", info->receiver, ") ", NULL); |
| } |
| |
| Printv(f_go_wrappers, info->go_name, NULL); |
| if (info->overname) { |
| Printv(f_go_wrappers, info->overname, NULL); |
| } |
| Printv(f_go_wrappers, "(", NULL); |
| |
| // If we are doing methods, add this method to the interface. |
| if (add_to_interface) { |
| Printv(interfaces, "\t", info->go_name, "(", NULL); |
| } |
| |
| // Write out the parameters to both the function definition and |
| // the interface. |
| |
| String *parm_print = NewString(""); |
| |
| int parm_count = emit_num_arguments(info->parms); |
| int required_count = emit_num_required(info->parms); |
| int args = 0; |
| |
| for (; pi < parm_count; ++pi) { |
| p = getParm(p); |
| if (pi == 0 && info->is_destructor) { |
| String *cl = exportedName(class_name); |
| Printv(parm_print, Getattr(p, "lname"), " ", cl, NULL); |
| Delete(cl); |
| ++args; |
| } else { |
| if (args > 0) { |
| Printv(parm_print, ", ", NULL); |
| } |
| ++args; |
| if (pi >= required_count) { |
| Printv(parm_print, "_swig_args ...interface{}", NULL); |
| break; |
| } |
| Printv(parm_print, Getattr(p, "lname"), " ", NULL); |
| String *tm = goType(p, Getattr(p, "type")); |
| Printv(parm_print, tm, NULL); |
| Delete(tm); |
| } |
| p = nextParm(p); |
| } |
| |
| Printv(parm_print, ")", NULL); |
| |
| // Write out the result type. |
| if (info->is_constructor) { |
| String *cl = exportedName(class_name); |
| Printv(parm_print, " (_swig_ret ", cl, ")", NULL); |
| Delete(cl); |
| } else { |
| if (SwigType_type(info->result) != T_VOID) { |
| String *tm = goType(info->n, info->result); |
| Printv(parm_print, " (_swig_ret ", tm, ")", NULL); |
| Delete(tm); |
| } |
| } |
| |
| Printv(f_go_wrappers, parm_print, NULL); |
| if (add_to_interface) { |
| Printv(interfaces, parm_print, "\n", NULL); |
| } |
| |
| // Write out the function body. |
| |
| Printv(f_go_wrappers, " {\n", NULL); |
| |
| if (parm_count > required_count) { |
| Parm *p = info->parms; |
| int i; |
| for (i = 0; i < required_count; ++i) { |
| p = getParm(p); |
| p = nextParm(p); |
| } |
| for (; i < parm_count; ++i) { |
| p = getParm(p); |
| String *tm = goType(p, Getattr(p, "type")); |
| Printv(f_go_wrappers, "\tvar ", Getattr(p, "lname"), " ", tm, "\n", NULL); |
| Printf(f_go_wrappers, "\tif len(_swig_args) > %d {\n", i - required_count); |
| Printf(f_go_wrappers, "\t\t%s = _swig_args[%d].(%s)\n", Getattr(p, "lname"), i - required_count, tm); |
| Printv(f_go_wrappers, "\t}\n", NULL); |
| Delete(tm); |
| p = nextParm(p); |
| } |
| } |
| |
| String *call = NewString("\t"); |
| |
| String *ret_type = NULL; |
| bool memcpy_ret = false; |
| String *wt = NULL; |
| if (SwigType_type(info->result) != T_VOID) { |
| if (info->is_constructor) { |
| ret_type = exportedName(class_name); |
| } else { |
| ret_type = goImType(info->n, info->result); |
| } |
| Printv(f_go_wrappers, "\tvar swig_r ", ret_type, "\n", NULL); |
| |
| bool c_struct_type; |
| Delete(cgoTypeForGoValue(info->n, info->result, &c_struct_type)); |
| if (c_struct_type) { |
| memcpy_ret = true; |
| } |
| |
| if (memcpy_ret) { |
| Printv(call, "swig_r_p := ", NULL); |
| } else { |
| Printv(call, "swig_r = (", ret_type, ")(", NULL); |
| } |
| |
| if (info->is_constructor || goTypeIsInterface(info->n, info->result)) { |
| if (info->is_constructor) { |
| wt = Copy(class_receiver); |
| } else { |
| wt = goWrapperType(info->n, info->result, true); |
| } |
| Printv(call, wt, "(", NULL); |
| } |
| } |
| |
| Printv(call, "C.", info->wname, "(", NULL); |
| |
| args = 0; |
| |
| if (parm_count > required_count) { |
| Printv(call, "C.swig_intgo(len(_swig_args))", NULL); |
| ++args; |
| } |
| |
| if (info->base && info->receiver) { |
| if (args > 0) { |
| Printv(call, ", ", NULL); |
| } |
| ++args; |
| Printv(call, "C.uintptr_t(_swig_base)", NULL); |
| } |
| |
| p = info->parms; |
| for (int i = 0; i < parm_count; ++i) { |
| p = getParm(p); |
| if (args > 0) { |
| Printv(call, ", ", NULL); |
| } |
| ++args; |
| |
| SwigType *pt = Getattr(p, "type"); |
| String *ln = Getattr(p, "lname"); |
| |
| String *ivar = NewStringf("_swig_i_%d", i); |
| |
| String *goin = goGetattr(p, "tmap:goin"); |
| if (goin == NULL) { |
| Printv(f_go_wrappers, "\t", ivar, " := ", NULL); |
| bool need_close = false; |
| if ((i == 0 && info->is_destructor) || ((i > 0 || !info->receiver || info->base || info->is_constructor) && goTypeIsInterface(p, pt))) { |
| Printv(f_go_wrappers, "getSwigcptr(", NULL); |
| need_close = true; |
| } |
| Printv(f_go_wrappers, ln, NULL); |
| if (need_close) { |
| Printv(f_go_wrappers, ")", NULL); |
| } |
| Printv(f_go_wrappers, "\n", NULL); |
| Setattr(p, "emit:goinput", ln); |
| } else { |
| String *itm = goImType(p, pt); |
| Printv(f_go_wrappers, "\tvar ", ivar, " ", itm, "\n", NULL); |
| goin = Copy(goin); |
| Replaceall(goin, "$input", ln); |
| Replaceall(goin, "$result", ivar); |
| Printv(f_go_wrappers, goin, "\n", NULL); |
| Delete(goin); |
| Setattr(p, "emit:goinput", ivar); |
| } |
| |
| bool c_struct_type; |
| String *ct = cgoTypeForGoValue(p, pt, &c_struct_type); |
| if (c_struct_type) { |
| Printv(call, "*(*C.", ct, ")(unsafe.Pointer(&", ivar, "))", NULL); |
| } else { |
| Printv(call, "C.", ct, "(", ivar, ")", NULL); |
| } |
| Delete(ct); |
| |
| p = nextParm(p); |
| } |
| |
| Printv(f_go_wrappers, call, ")", NULL); |
| Delete(call); |
| |
| if (wt) { |
| // Close the type conversion to the wrapper type. |
| Printv(f_go_wrappers, ")", NULL); |
| } |
| if (SwigType_type(info->result) != T_VOID && !memcpy_ret) { |
| // Close the type conversion of the return value. |
| Printv(f_go_wrappers, ")", NULL); |
| } |
| |
| Printv(f_go_wrappers, "\n", NULL); |
| |
| if (memcpy_ret) { |
| Printv(f_go_wrappers, "\tswig_r = *(*", ret_type, ")(unsafe.Pointer(&swig_r_p))\n", NULL); |
| } |
| if (ret_type) { |
| Delete(ret_type); |
| } |
| |
| goargout(info->parms); |
| |
| if (SwigType_type(info->result) != T_VOID) { |
| |
| Swig_save("cgoGoWrapper", info->n, "type", "tmap:goout", NULL); |
| Setattr(info->n, "type", info->result); |
| |
| String *goout = goTypemapLookup("goout", info->n, "swig_r"); |
| if (goout == NULL) { |
| Printv(f_go_wrappers, "\treturn swig_r\n", NULL); |
| } else { |
| String *tm = goType(info->n, info->result); |
| Printv(f_go_wrappers, "\tvar swig_r_1 ", tm, "\n", NULL); |
| goout = Copy(goout); |
| Replaceall(goout, "$input", "swig_r"); |
| Replaceall(goout, "$result", "swig_r_1"); |
| Printv(f_go_wrappers, goout, "\n", NULL); |
| Printv(f_go_wrappers, "\treturn swig_r_1\n", NULL); |
| } |
| |
| Swig_restore(info->n); |
| } |
| |
| Printv(f_go_wrappers, "}\n\n", NULL); |
| |
| DelWrapper(dummy); |
| |
| return SWIG_OK; |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * cgoCommentWrapper() |
| * |
| * Write out a cgo function to call a C/C++ function. This code |
| * will go into the cgo comment in the generated Go output file. |
| * ---------------------------------------------------------------------- */ |
| int cgoCommentWrapper(const cgoWrapperInfo *info) { |
| String *ret_type; |
| if (SwigType_type(info->result) == T_VOID) { |
| ret_type = NewString("void"); |
| } else { |
| bool c_struct_type; |
| ret_type = cgoTypeForGoValue(info->n, info->result, &c_struct_type); |
| } |
| |
| Printv(f_cgo_comment, "extern ", ret_type, " ", info->wname, "(", NULL); |
| |
| Delete(ret_type); |
| |
| int parm_count = emit_num_arguments(info->parms); |
| int required_count = emit_num_required(info->parms); |
| int args = 0; |
| |
| if (parm_count > required_count) { |
| Printv(f_cgo_comment, "intgo _swig_args", NULL); |
| ++args; |
| } |
| |
| if (info->base && info->receiver) { |
| if (args > 0) { |
| Printv(f_cgo_comment, ", ", NULL); |
| } |
| ++args; |
| Printv(f_cgo_comment, "uintptr_t _swig_base", NULL); |
| } |
| |
| Parm *p = info->parms; |
| for (int i = 0; i < parm_count; ++i) { |
| p = getParm(p); |
| if (args > 0) { |
| Printv(f_cgo_comment, ", ", NULL); |
| } |
| ++args; |
| |
| SwigType *pt = Getattr(p, "type"); |
| String *ln = Getattr(p, "lname"); |
| |
| bool c_struct_type; |
| String *ct = cgoTypeForGoValue(p, pt, &c_struct_type); |
| Printv(f_cgo_comment, ct, " ", ln, NULL); |
| Delete(ct); |
| |
| p = nextParm(p); |
| } |
| |
| if (args == 0) { |
| Printv(f_cgo_comment, "void", NULL); |
| } |
| |
| Printv(f_cgo_comment, ");\n", NULL); |
| |
| return SWIG_OK; |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * cgoGccWrapper() |
| * |
| * Write out code to the C/C++ wrapper file. This code will be |
| * called by the code generated by cgoCommentWrapper. |
| * ---------------------------------------------------------------------- */ |
| int cgoGccWrapper(const cgoWrapperInfo *info) { |
| Wrapper *f = NewWrapper(); |
| |
| Swig_save("cgoGccWrapper", info->n, "parms", NULL); |
| |
| ParmList *parms = info->parms; |
| |
| Parm *base_parm = NULL; |
| if (info->base && !isStatic(info->n)) { |
| SwigType *base_type = Copy(getClassType()); |
| SwigType_add_pointer(base_type); |
| base_parm = NewParm(base_type, NewString("arg1"), info->n); |
| set_nextSibling(base_parm, parms); |
| parms = base_parm; |
| } |
| |
| emit_parameter_variables(parms, f); |
| emit_attach_parmmaps(parms, f); |
| int parm_count = emit_num_arguments(parms); |
| int required_count = emit_num_required(parms); |
| |
| emit_return_variable(info->n, info->result, f); |
| |
| // Start the function definition. |
| |
| String *fnname = NewString(""); |
| Printv(fnname, info->wname, "(", NULL); |
| |
| int args = 0; |
| |
| if (parm_count > required_count) { |
| Printv(fnname, "intgo _swig_optargc", NULL); |
| ++args; |
| } |
| |
| Parm *p = parms; |
| for (int i = 0; i < parm_count; ++i) { |
| if (args > 0) { |
| Printv(fnname, ", ", NULL); |
| } |
| ++args; |
| |
| p = getParm(p); |
| |
| SwigType *pt = Copy(Getattr(p, "type")); |
| if (SwigType_isarray(pt) && Getattr(p, "tmap:gotype") == NULL) { |
| SwigType_del_array(pt); |
| SwigType_add_pointer(pt); |
| } |
| String *pn = NewStringf("_swig_go_%d", i); |
| String *ct = gcCTypeForGoValue(p, pt, pn); |
| Printv(fnname, ct, NULL); |
| Delete(ct); |
| Delete(pn); |
| Delete(pt); |
| |
| p = nextParm(p); |
| } |
| |
| Printv(fnname, ")", NULL); |
| |
| if (SwigType_type(info->result) == T_VOID) { |
| Printv(f->def, "void ", fnname, NULL); |
| } else { |
| String *ct = gcCTypeForGoValue(info->n, info->result, fnname); |
| Printv(f->def, ct, NULL); |
| Delete(ct); |
| |
| String *ln = NewString("_swig_go_result"); |
| ct = gcCTypeForGoValue(info->n, info->result, ln); |
| Wrapper_add_local(f, "_swig_go_result", ct); |
| Delete(ct); |
| Delete(ln); |
| } |
| |
| Delete(fnname); |
| |
| Printv(f->def, " {\n", NULL); |
| |
| // Apply the in typemaps. |
| |
| p = parms; |
| for (int i = 0; i < parm_count; ++i) { |
| p = getParm(p); |
| String *tm = Getattr(p, "tmap:in"); |
| if (!tm) { |
| Swig_warning(WARN_TYPEMAP_IN_UNDEF, input_file, line_number, "unable to use type %s as a function argument\n", SwigType_str(Getattr(p, "type"), 0)); |
| } else { |
| tm = Copy(tm); |
| String *pn = NewStringf("_swig_go_%d", i); |
| Replaceall(tm, "$input", pn); |
| if (i < required_count) { |
| Printv(f->code, "\t", tm, "\n", NULL); |
| } else { |
| Printf(f->code, "\tif (_swig_optargc > %d) {\n", i - required_count); |
| Printv(f->code, "\t\t", tm, "\n", NULL); |
| Printv(f->code, "\t}\n", NULL); |
| } |
| Delete(tm); |
| Setattr(p, "emit:input", pn); |
| } |
| p = nextParm(p); |
| } |
| |
| Printv(f->code, "\n", NULL); |
| |
| // Do the real work of the function. |
| |
| checkConstraints(parms, f); |
| |
| emitGoAction(info->n, info->base, parms, info->result, f); |
| |
| argout(parms, f); |
| |
| cleanupFunction(info->n, f, parms); |
| |
| if (SwigType_type(info->result) != T_VOID) { |
| Printv(f->code, "\treturn _swig_go_result;\n", NULL); |
| } |
| |
| Printv(f->code, "}\n", NULL); |
| |
| Wrapper_print(f, f_c_wrappers); |
| |
| Swig_restore(info->n); |
| |
| DelWrapper(f); |
| if (base_parm) { |
| Delete(base_parm); |
| } |
| |
| return SWIG_OK; |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * initGoTypemaps() |
| * |
| * Initialize the typenames for a Go wrapper, returning a dummy |
| * Wrapper*. Also set consistent names for the parameters. |
| * ---------------------------------------------------------------------- */ |
| |
| Wrapper* initGoTypemaps(ParmList *parms) { |
| Wrapper *dummy = NewWrapper(); |
| emit_attach_parmmaps(parms, dummy); |
| |
| Parm *p = parms; |
| int parm_count = emit_num_arguments(parms); |
| for (int i = 0; i < parm_count; ++i) { |
| p = getParm(p); |
| Swig_cparm_name(p, i); |
| p = nextParm(p); |
| } |
| |
| Swig_typemap_attach_parms("default", parms, dummy); |
| Swig_typemap_attach_parms("gotype", parms, dummy); |
| Swig_typemap_attach_parms("goin", parms, dummy); |
| Swig_typemap_attach_parms("goargout", parms, dummy); |
| Swig_typemap_attach_parms("imtype", parms, dummy); |
| |
| return dummy; |
| } |
| |
| /* ----------------------------------------------------------------------- |
| * checkConstraints() |
| * |
| * Check parameter constraints if any. This is used for the C/C++ |
| * function. This assumes that each parameter has an "emit:input" |
| * property with the name to use to refer to that parameter. |
| * ----------------------------------------------------------------------- */ |
| |
| void checkConstraints(ParmList *parms, Wrapper *f) { |
| Parm *p = parms; |
| while (p) { |
| String *tm = Getattr(p, "tmap:check"); |
| if (!tm) { |
| p = nextSibling(p); |
| } else { |
| tm = Copy(tm); |
| Replaceall(tm, "$input", Getattr(p, "emit:input")); |
| Printv(f->code, tm, "\n\n", NULL); |
| Delete(tm); |
| p = Getattr(p, "tmap:check:next"); |
| } |
| } |
| } |
| |
| /* ----------------------------------------------------------------------- |
| * emitGoAction() |
| * |
| * Emit the action of the function. This is used for the C/C++ function. |
| * ----------------------------------------------------------------------- */ |
| |
| void emitGoAction(Node *n, List *base, ParmList *parms, SwigType *result, Wrapper *f) { |
| String *actioncode; |
| if (!base || isStatic(n)) { |
| Swig_director_emit_dynamic_cast(n, f); |
| actioncode = emit_action(n); |
| } else { |
| // Call the base class method. |
| actioncode = NewString(""); |
| |
| String *current = NewString(""); |
| Printv(current, Getattr(parms, "lname"), NULL); |
| |
| int vc = 0; |
| for (Iterator bi = First(base); bi.item; bi = Next(bi)) { |
| Printf(actioncode, " %s *swig_b%d = (%s *)%s;\n", bi.item, vc, bi.item, current); |
| Delete(current); |
| current = NewString(""); |
| Printf(current, "swig_b%d", vc); |
| ++vc; |
| } |
| |
| String *code = Copy(Getattr(n, "wrap:action")); |
| Replace(code, Getattr(parms, "lname"), current, DOH_REPLACE_ANY | DOH_REPLACE_ID); |
| Delete(current); |
| Printv(actioncode, code, "\n", NULL); |
| } |
| |
| Swig_save("emitGoAction", n, "type", "tmap:out", NULL); |
| |
| Setattr(n, "type", result); |
| |
| String *tm = Swig_typemap_lookup_out("out", n, Swig_cresult_name(), f, actioncode); |
| if (!tm) { |
| Swig_warning(WARN_TYPEMAP_OUT_UNDEF, input_file, line_number, "Unable to use return type %s\n", SwigType_str(result, 0)); |
| } else { |
| Replaceall(tm, "$result", "_swig_go_result"); |
| if (GetFlag(n, "feature:new")) { |
| Replaceall(tm, "$owner", "1"); |
| } else { |
| Replaceall(tm, "$owner", "0"); |
| } |
| Printv(f->code, tm, "\n", NULL); |
| Delete(tm); |
| } |
| |
| Swig_restore(n); |
| } |
| |
| /* ----------------------------------------------------------------------- |
| * argout() |
| * |
| * Handle argument output code if any. This is used for the C/C++ |
| * function. This assumes that each parameter has an "emit:input" |
| * property with the name to use to refer to that parameter. |
| * ----------------------------------------------------------------------- */ |
| |
| void argout(ParmList *parms, Wrapper *f) { |
| Parm *p = parms; |
| while (p) { |
| String *tm = Getattr(p, "tmap:argout"); |
| if (!tm) { |
| p = nextSibling(p); |
| } else { |
| tm = Copy(tm); |
| Replaceall(tm, "$result", Swig_cresult_name()); |
| Replaceall(tm, "$input", Getattr(p, "emit:input")); |
| Printv(f->code, tm, "\n", NULL); |
| Delete(tm); |
| p = Getattr(p, "tmap:argout:next"); |
| } |
| } |
| } |
| |
| /* ----------------------------------------------------------------------- |
| * goargout() |
| * |
| * Handle Go argument output code if any. This is used for the Go |
| * function. This assumes that each parameter has an "emit:goinput" |
| * property with the name to use to refer to that parameter. |
| * ----------------------------------------------------------------------- */ |
| |
| void goargout(ParmList *parms) { |
| Parm *p = parms; |
| while (p) { |
| String *tm = Getattr(p, "tmap:goargout"); |
| if (!tm) { |
| p = nextSibling(p); |
| } else { |
| tm = Copy(tm); |
| Replaceall(tm, "$result", "swig_r"); |
| Replaceall(tm, "$input", Getattr(p, "emit:goinput")); |
| Printv(f_go_wrappers, tm, "\n", NULL); |
| Delete(tm); |
| p = Getattr(p, "tmap:goargout:next"); |
| } |
| } |
| |
| // If we need to memcpy a parameter to pass it to the C code, the |
| // compiler may think that the parameter is not live during the |
| // function call. If the garbage collector runs while the C/C++ |
| // function is running, the parameter may be freed. Force the |
| // compiler to see the parameter as live across the C/C++ function. |
| int parm_count = emit_num_arguments(parms); |
| p = parms; |
| for (int i = 0; i < parm_count; ++i) { |
| p = getParm(p); |
| bool c_struct_type; |
| Delete(cgoTypeForGoValue(p, Getattr(p, "type"), &c_struct_type)); |
| if (c_struct_type) { |
| Printv(f_go_wrappers, "\tif Swig_escape_always_false {\n", NULL); |
| Printv(f_go_wrappers, "\t\tSwig_escape_val = ", Getattr(p, "emit:goinput"), "\n", NULL); |
| Printv(f_go_wrappers, "\t}\n", NULL); |
| } |
| p = nextParm(p); |
| } |
| } |
| |
| /* ----------------------------------------------------------------------- |
| * freearg() |
| * |
| * Handle argument cleanup code if any. This is used for the C/C++ |
| * function. This assumes that each parameter has an "emit:input" |
| * property with the name to use to refer to that parameter. |
| * ----------------------------------------------------------------------- */ |
| |
| String *freearg(ParmList *parms) { |
| String *ret = NewString(""); |
| Parm *p = parms; |
| while (p) { |
| String *tm = Getattr(p, "tmap:freearg"); |
| if (!tm) { |
| p = nextSibling(p); |
| } else { |
| tm = Copy(tm); |
| Replaceall(tm, "$input", Getattr(p, "emit:input")); |
| Printv(ret, tm, "\n", NULL); |
| Delete(tm); |
| p = Getattr(p, "tmap:freearg:next"); |
| } |
| } |
| return ret; |
| } |
| |
| /* ----------------------------------------------------------------------- |
| * cleanupFunction() |
| * |
| * Final function cleanup code. |
| * ----------------------------------------------------------------------- */ |
| |
| void cleanupFunction(Node *n, Wrapper *f, ParmList *parms) { |
| String *cleanup = freearg(parms); |
| Printv(f->code, cleanup, NULL); |
| |
| if (GetFlag(n, "feature:new")) { |
| String *tm = Swig_typemap_lookup("newfree", n, Swig_cresult_name(), 0); |
| if (tm) { |
| Printv(f->code, tm, "\n", NULL); |
| Delete(tm); |
| } |
| } |
| |
| Replaceall(f->code, "$cleanup", cleanup); |
| Delete(cleanup); |
| |
| /* See if there is any return cleanup code */ |
| String *tm; |
| if ((tm = Swig_typemap_lookup("ret", n, Swig_cresult_name(), 0))) { |
| Printf(f->code, "%s\n", tm); |
| Delete(tm); |
| } |
| |
| Replaceall(f->code, "$symname", Getattr(n, "sym:name")); |
| } |
| |
| /* ----------------------------------------------------------------------- |
| * variableHandler() |
| * |
| * This exists just to set the making_variable_wrappers flag. |
| * ----------------------------------------------------------------------- */ |
| |
| virtual int variableHandler(Node *n) { |
| assert(!making_variable_wrappers); |
| making_variable_wrappers = true; |
| int r = Language::variableHandler(n); |
| making_variable_wrappers = false; |
| return r; |
| } |
| |
| /* ----------------------------------------------------------------------- |
| * constantWrapper() |
| * |
| * Product a const declaration. |
| * ------------------------------------------------------------------------ */ |
| |
| virtual int constantWrapper(Node *n) { |
| SwigType *type = Getattr(n, "type"); |
| |
| if (!SwigType_issimple(type) && SwigType_type(type) != T_STRING) { |
| return goComplexConstant(n, type); |
| } |
| |
| if (Swig_storage_isstatic(n)) { |
| return goComplexConstant(n, type); |
| } |
| |
| String *go_name = buildGoName(Getattr(n, "sym:name"), false, false); |
| |
| String *tm = goType(n, type); |
| String *value = Getattr(n, "value"); |
| |
| String *copy = NULL; |
| if (SwigType_type(type) == T_BOOL) { |
| if (Cmp(value, "true") != 0 && Cmp(value, "false") != 0) { |
| return goComplexConstant(n, type); |
| } |
| } else if (SwigType_type(type) == T_STRING || SwigType_type(type) == T_CHAR) { |
| // Backslash sequences are somewhat different in Go and C/C++. |
| if (Strchr(value, '\\') != 0) { |
| return goComplexConstant(n, type); |
| } |
| } else { |
| // Accept a 0x prefix, and strip combinations of u and l |
| // suffixes. Otherwise accept digits, decimal point, and |
| // exponentiation. Treat anything else as too complicated to |
| // handle as a Go constant. |
| char *p = Char(value); |
| int len = (int)strlen(p); |
| bool need_copy = false; |
| while (len > 0) { |
| char c = p[len - 1]; |
| if (c != 'l' && c != 'L' && c != 'u' && c != 'U') { |
| break; |
| } |
| --len; |
| need_copy = true; |
| } |
| bool is_hex = false; |
| int i = 0; |
| if (p[0] == '0' && (p[1] == 'x' || p[1] == 'X')) { |
| i = 2; |
| is_hex = true; |
| } |
| for (; i < len; ++i) { |
| switch (p[i]) { |
| case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': |
| break; |
| case 'a': case 'b': case 'c': case 'd': case 'f': case 'A': case 'B': case 'C': case 'D': case 'F': |
| if (!is_hex) { |
| return goComplexConstant(n, type); |
| } |
| break; |
| case '.': case 'e': case 'E': case '+': case '-': |
| break; |
| default: |
| return goComplexConstant(n, type); |
| } |
| } |
| if (need_copy) { |
| copy = Copy(value); |
| Replaceall(copy, p + len, ""); |
| value = copy; |
| } |
| } |
| |
| if (!checkNameConflict(go_name, n, NULL)) { |
| Delete(tm); |
| Delete(go_name); |
| Delete(copy); |
| return SWIG_NOWRAP; |
| } |
| |
| Printv(f_go_wrappers, "const ", go_name, " ", tm, " = ", NULL); |
| if (SwigType_type(type) == T_STRING) { |
| Printv(f_go_wrappers, "\"", value, "\"", NULL); |
| } else if (SwigType_type(type) == T_CHAR) { |
| Printv(f_go_wrappers, "'", value, "'", NULL); |
| } else { |
| Printv(f_go_wrappers, value, NULL); |
| } |
| |
| Printv(f_go_wrappers, "\n", NULL); |
| |
| Delete(tm); |
| Delete(go_name); |
| Delete(copy); |
| |
| return SWIG_OK; |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * enumDeclaration() |
| * |
| * A C++ enum type turns into a Named go int type. |
| * ---------------------------------------------------------------------- */ |
| |
| virtual int enumDeclaration(Node *n) { |
| if (getCurrentClass() && (cplus_mode != PUBLIC)) |
| return SWIG_NOWRAP; |
| |
| String *name = goEnumName(n); |
| if (Strcmp(name, "int") != 0) { |
| if (!ImportMode || !imported_package) { |
| if (!checkNameConflict(name, n, NULL)) { |
| Delete(name); |
| return SWIG_NOWRAP; |
| } |
| Printv(f_go_wrappers, "type ", name, " int\n", NULL); |
| } else { |
| String *nw = NewString(""); |
| Printv(nw, getModuleName(imported_package), ".", name, NULL); |
| Setattr(n, "go:enumname", nw); |
| } |
| } |
| Delete(name); |
| |
| return Language::enumDeclaration(n); |
| } |
| |
| /* ----------------------------------------------------------------------- |
| * enumvalueDeclaration() |
| * |
| * Declare a single value of an enum type. We fetch the value by |
| * calling a C/C++ function. |
| * ------------------------------------------------------------------------ */ |
| |
| virtual int enumvalueDeclaration(Node *n) { |
| if (!is_public(n)) { |
| return SWIG_OK; |
| } |
| |
| Swig_require("enumvalueDeclaration", n, "*sym:name", NIL); |
| Node *parent = parentNode(n); |
| |
| if (Getattr(parent, "unnamed")) { |
| Setattr(n, "type", NewString("int")); |
| } else { |
| Setattr(n, "type", Getattr(parent, "enumtype")); |
| } |
| |
| if (GetFlag(parent, "scopedenum")) { |
| String *symname = Getattr(n, "sym:name"); |
| symname = Swig_name_member(0, Getattr(parent, "sym:name"), symname); |
| Setattr(n, "sym:name", symname); |
| Delete(symname); |
| } |
| |
| int ret = goComplexConstant(n, Getattr(n, "type")); |
| Swig_restore(n); |
| return ret; |
| } |
| |
| /* ----------------------------------------------------------------------- |
| * goComplexConstant() |
| * |
| * Handle a const declaration for something which is not a Go constant. |
| * ------------------------------------------------------------------------ */ |
| |
| int goComplexConstant(Node *n, SwigType *type) { |
| String *symname = Getattr(n, "sym:name"); |
| if (!symname) { |
| symname = Getattr(n, "name"); |
| } |
| |
| String *varname = buildGoName(symname, true, false); |
| |
| if (!checkNameConflict(varname, n, NULL)) { |
| Delete(varname); |
| return SWIG_NOWRAP; |
| } |
| |
| String *rawval = Getattr(n, "rawval"); |
| if (rawval && Len(rawval)) { |
| // Based on Swig_VargetToFunction |
| String *nname = NewStringf("(%s)", rawval); |
| String *call; |
| if (SwigType_isclass(type)) { |
| call = NewStringf("%s", nname); |
| } else { |
| call = SwigType_lcaststr(type, nname); |
| } |
| String *cres = Swig_cresult(type, Swig_cresult_name(), call); |
| Setattr(n, "wrap:action", cres); |
| Delete(nname); |
| Delete(call); |
| Delete(cres); |
| } else { |
| String *get = NewString(""); |
| Printv(get, Swig_cresult_name(), " = ", NULL); |
| |
| char quote; |
| if (Getattr(n, "wrappedasconstant")) { |
| quote = '\0'; |
| } else if (SwigType_type(type) == T_CHAR) { |
| quote = '\''; |
| } else if (SwigType_type(type) == T_STRING) { |
| Printv(get, "(char *)", NULL); |
| quote = '"'; |
| } else { |
| quote = '\0'; |
| } |
| |
| if (quote != '\0') { |
| Printf(get, "%c", quote); |
| } |
| |
| Printv(get, Getattr(n, "value"), NULL); |
| |
| if (quote != '\0') { |
| Printf(get, "%c", quote); |
| } |
| |
| Printv(get, ";\n", NULL); |
| |
| Setattr(n, "wrap:action", get); |
| Delete(get); |
| } |
| |
| String *sname = Copy(symname); |
| if (class_name) { |
| Append(sname, "_"); |
| Append(sname, class_name); |
| } |
| |
| String *go_name = NewString("_swig_get"); |
| if (class_name) { |
| Append(go_name, class_name); |
| Append(go_name, "_"); |
| } |
| Append(go_name, sname); |
| |
| String *wname = Swig_name_wrapper(sname); |
| Append(wname, unique_id); |
| Setattr(n, "wrap:name", wname); |
| |
| int r = makeWrappers(n, go_name, NULL, wname, NULL, NULL, type, true); |
| |
| if (r != SWIG_OK) { |
| return r; |
| } |
| |
| String *t = goType(n, type); |
| Printv(f_go_wrappers, "var ", varname, " ", t, " = ", go_name, "()\n", NULL); |
| |
| Delete(varname); |
| Delete(t); |
| Delete(go_name); |
| Delete(sname); |
| |
| return SWIG_OK; |
| } |
| |
| /* ------------------------------------------------------------ |
| * classHandler() |
| * |
| * For a C++ class, in Go we generate both a struct and an |
| * interface. The interface will declare all the class public |
| * methods. We will define all the methods on the struct, so that |
| * the struct meets the interface. We then expect users of the |
| * class to use the interface. |
| * ------------------------------------------------------------ */ |
| |
| virtual int classHandler(Node *n) { |
| class_node = n; |
| |
| List *baselist = Getattr(n, "bases"); |
| bool has_base_classes = baselist && Len(baselist) > 0; |
| |
| String *name = Getattr(n, "sym:name"); |
| |
| String *go_name = exportedName(name); |
| |
| if (!checkNameConflict(go_name, n, NULL)) { |
| Delete(go_name); |
| SetFlag(n, "go:conflict"); |
| return SWIG_NOWRAP; |
| } |
| |
| String *go_type_name = goCPointerType(Getattr(n, "classtypeobj"), true); |
| |
| class_name = name; |
| class_receiver = go_type_name; |
| class_methods = NewHash(); |
| |
| int isdir = GetFlag(n, "feature:director"); |
| int isnodir = GetFlag(n, "feature:nodirector"); |
| bool is_director = isdir && !isnodir; |
| |
| Printv(f_go_wrappers, "type ", go_type_name, " uintptr\n\n", NULL); |
| |
| // A method to return the pointer to the C++ class. This is used |
| // by generated code to convert between the interface and the C++ |
| // value. |
| Printv(f_go_wrappers, "func (p ", go_type_name, ") Swigcptr() uintptr {\n", NULL); |
| Printv(f_go_wrappers, "\treturn (uintptr)(p)\n", NULL); |
| Printv(f_go_wrappers, "}\n\n", NULL); |
| |
| // A method used as a marker for the class, to avoid invalid |
| // interface conversions when using multiple inheritance. |
| Printv(f_go_wrappers, "func (p ", go_type_name, ") SwigIs", go_name, "() {\n", NULL); |
| Printv(f_go_wrappers, "}\n\n", NULL); |
| |
| if (is_director) { |
| // Return the interface passed to the NewDirector function. |
| Printv(f_go_wrappers, "func (p ", go_type_name, ") DirectorInterface() interface{} {\n", NULL); |
| Printv(f_go_wrappers, "\treturn nil\n", NULL); |
| Printv(f_go_wrappers, "}\n\n", NULL); |
| } |
| |
| // We have seen a definition for this type. |
| Setattr(defined_types, go_name, go_name); |
| Setattr(defined_types, go_type_name, go_type_name); |
| |
| interfaces = NewString(""); |
| |
| int r = Language::classHandler(n); |
| if (r != SWIG_OK) { |
| return r; |
| } |
| |
| if (has_base_classes) { |
| // For each method defined in a base class but not defined in |
| // this class, we need to define the method in this class. We |
| // can't use anonymous field inheritance because it works |
| // differently in Go and in C++. |
| |
| Hash *local = NewHash(); |
| for (Node *ni = Getattr(n, "firstChild"); ni; ni = nextSibling(ni)) { |
| |
| if (!is_public(ni)) { |
| continue; |
| } |
| |
| String *type = Getattr(ni, "nodeType"); |
| if (Cmp(type, "constructor") == 0 || Cmp(type, "destructor") == 0) { |
| continue; |
| } |
| |
| String *cname = Getattr(ni, "sym:name"); |
| if (!cname) { |
| cname = Getattr(ni, "name"); |
| } |
| if (cname) { |
| Setattr(local, cname, NewString("")); |
| } |
| } |
| |
| for (Iterator b = First(baselist); b.item; b = Next(b)) { |
| List *bases = NewList(); |
| Append(bases, Getattr(b.item, "classtype")); |
| int r = addBase(n, b.item, bases, local); |
| if (r != SWIG_OK) { |
| return r; |
| } |
| Delete(bases); |
| } |
| |
| Delete(local); |
| |
| Hash *parents = NewHash(); |
| addFirstBaseInterface(n, parents, baselist); |
| int r = addExtraBaseInterfaces(n, parents, baselist); |
| Delete(parents); |
| if (r != SWIG_OK) { |
| return r; |
| } |
| } |
| |
| Printv(f_go_wrappers, "type ", go_name, " interface {\n", NULL); |
| Printv(f_go_wrappers, "\tSwigcptr() uintptr\n", NULL); |
| Printv(f_go_wrappers, "\tSwigIs", go_name, "()\n", NULL); |
| |
| if (is_director) { |
| Printv(f_go_wrappers, "\tDirectorInterface() interface{}\n", NULL); |
| } |
| |
| Append(f_go_wrappers, interfaces); |
| Printv(f_go_wrappers, "}\n\n", NULL); |
| Delete(interfaces); |
| |
| interfaces = NULL; |
| class_name = NULL; |
| class_receiver = NULL; |
| class_node = NULL; |
| Delete(class_methods); |
| class_methods = NULL; |
| |
| Delete(go_type_name); |
| |
| return SWIG_OK; |
| } |
| |
| /* ------------------------------------------------------------ |
| * addBase() |
| * |
| * Implement methods and members defined in a parent class for a |
| * child class. |
| * ------------------------------------------------------------ */ |
| |
| int addBase(Node *n, Node *base, List *bases, Hash *local) { |
| if (GetFlag(base, "feature:ignore")) { |
| return SWIG_OK; |
| } |
| |
| for (Node *ni = Getattr(base, "firstChild"); ni; ni = nextSibling(ni)) { |
| int r = goBaseEntry(n, bases, local, ni); |
| if (r != SWIG_OK) { |
| return r; |
| } |
| } |
| |
| List *baselist = Getattr(base, "bases"); |
| if (baselist && Len(baselist) > 0) { |
| for (Iterator b = First(baselist); b.item; b = Next(b)) { |
| List *nb = Copy(bases); |
| Append(nb, Getattr(b.item, "classtype")); |
| int r = addBase(n, b.item, nb, local); |
| Delete(nb); |
| if (r != SWIG_OK) { |
| return r; |
| } |
| } |
| } |
| |
| return SWIG_OK; |
| } |
| |
| /* ------------------------------------------------------------ |
| * goBaseEntry() |
| * |
| * Implement one entry defined in a parent class for a child class. |
| * n is the child class. |
| * ------------------------------------------------------------ */ |
| |
| int goBaseEntry(Node* n, List* bases, Hash *local, Node* entry) { |
| if (GetFlag(entry, "feature:ignore")) { |
| return SWIG_OK; |
| } |
| |
| if (!is_public(entry)) { |
| return SWIG_OK; |
| } |
| |
| String *type = Getattr(entry, "nodeType"); |
| if (Strcmp(type, "constructor") == 0 || Strcmp(type, "destructor") == 0 || Strcmp(type, "enum") == 0 || Strcmp(type, "using") == 0 || Strcmp(type, "classforward") == 0 || Strcmp(type, "template") == 0) { |
| return SWIG_OK; |
| } |
| |
| if (Strcmp(type, "extend") == 0) { |
| for (Node* extend = firstChild(entry); extend; extend = nextSibling(extend)) { |
| if (isStatic(extend)) { |
| // If we don't do this, the extend_default test case fails. |
| continue; |
| } |
| |
| int r = goBaseEntry(n, bases, local, extend); |
| if (r != SWIG_OK) { |
| return r; |
| } |
| } |
| return SWIG_OK; |
| } |
| |
| String *storage = Getattr(entry, "storage"); |
| if (storage && (Strcmp(storage, "typedef") == 0 || Strstr(storage, "friend"))) { |
| return SWIG_OK; |
| } |
| |
| String *mname = Getattr(entry, "sym:name"); |
| if (!mname) { |
| return SWIG_OK; |
| } |
| |
| String *lname = Getattr(entry, "name"); |
| if (Getattr(class_methods, lname)) { |
| return SWIG_OK; |
| } |
| if (Getattr(local, lname)) { |
| return SWIG_OK; |
| } |
| Setattr(local, lname, NewString("")); |
| |
| String *ty = NewString(Getattr(entry, "type")); |
| SwigType_push(ty, Getattr(entry, "decl")); |
| String *fullty = SwigType_typedef_resolve_all(ty); |
| bool is_function = SwigType_isfunction(fullty) ? true : false; |
| Delete(ty); |
| Delete(fullty); |
| |
| if (is_function) { |
| int r = goBaseMethod(n, bases, entry); |
| if (r != SWIG_OK) { |
| return r; |
| } |
| |
| if (Getattr(entry, "sym:overloaded")) { |
| for (Node *on = Getattr(entry, "sym:nextSibling"); on; on = Getattr(on, "sym:nextSibling")) { |
| r = goBaseMethod(n, bases, on); |
| if (r != SWIG_OK) { |
| return r; |
| } |
| } |
| |
| String *receiver = class_receiver; |
| bool is_static = isStatic(entry); |
| if (is_static) { |
| receiver = NULL; |
| } |
| String *go_name = buildGoName(Getattr(entry, "sym:name"), is_static, false); |
| r = makeDispatchFunction(entry, go_name, receiver, is_static, NULL, false); |
| Delete(go_name); |
| if (r != SWIG_OK) { |
| return r; |
| } |
| } |
| } else { |
| int r = goBaseVariable(n, bases, entry); |
| if (r != SWIG_OK) { |
| return r; |
| } |
| } |
| |
| return SWIG_OK; |
| } |
| |
| |
| /* ------------------------------------------------------------ |
| * goBaseMethod() |
| * |
| * Implement a method defined in a parent class for a child class. |
| * ------------------------------------------------------------ */ |
| |
| int goBaseMethod(Node *method_class, List *bases, Node *method) { |
| String *symname = Getattr(method, "sym:name"); |
| if (!validIdentifier(symname)) { |
| return SWIG_OK; |
| } |
| |
| String *name = NewString(""); |
| Printv(name, Getattr(method_class, "sym:name"), "_", symname, NULL); |
| |
| bool is_static = isStatic(method); |
| |
| String *go_name = buildGoName(name, is_static, false); |
| |
| String *overname = NULL; |
| if (Getattr(method, "sym:overloaded")) { |
| overname = Getattr(method, "sym:overname"); |
| } |
| String *wname = Swig_name_wrapper(name); |
| if (overname) { |
| Append(wname, overname); |
| } |
| Append(wname, unique_id); |
| |
| String *result = NewString(Getattr(method, "type")); |
| SwigType_push(result, Getattr(method, "decl")); |
| if (SwigType_isqualifier(result)) { |
| Delete(SwigType_pop(result)); |
| } |
| Delete(SwigType_pop_function(result)); |
| |
| // If the base method is imported, wrap:action may not be set. |
| Swig_save("goBaseMethod", method, "wrap:name", "wrap:action", "parms", NULL); |
| Setattr(method, "wrap:name", wname); |
| if (!Getattr(method, "wrap:action")) { |
| if (!is_static) { |
| Swig_MethodToFunction(method, getNSpace(), getClassType(), (Getattr(method, "template") ? SmartPointer : Extend | SmartPointer), NULL, false); |
| // Remove any self parameter that was just added. |
| ParmList *parms = Getattr(method, "parms"); |
| if (parms && Getattr(parms, "self")) { |
| parms = CopyParmList(nextSibling(parms)); |
| Setattr(method, "parms", parms); |
| } |
| } else { |
| String *call = Swig_cfunction_call(Getattr(method, "name"), Getattr(method, "parms")); |
| Setattr(method, "wrap:action", Swig_cresult(Getattr(method, "type"), Swig_cresult_name(), call)); |
| } |
| } |
| |
| // A method added by %extend in a base class may have void parms. |
| ParmList* parms = Getattr(method, "parms"); |
| if (parms != NULL && SwigType_type(Getattr(parms, "type")) == T_VOID) { |
| parms = NULL; |
| } |
| |
| int r = makeWrappers(method, go_name, overname, wname, bases, parms, result, is_static); |
| |
| Swig_restore(method); |
| |
| Delete(result); |
| Delete(go_name); |
| Delete(name); |
| |
| return r; |
| } |
| |
| /* ------------------------------------------------------------ |
| * goBaseVariable() |
| * |
| * Add accessors for a member variable defined in a parent class for |
| * a child class. |
| * ------------------------------------------------------------ */ |
| |
| int goBaseVariable(Node *var_class, List *bases, Node *var) { |
| if (isStatic(var)) { |
| return SWIG_OK; |
| } |
| |
| String *var_name = buildGoName(Getattr(var, "sym:name"), false, false); |
| |
| Swig_save("goBaseVariable", var, "type", "wrap:action", NULL); |
| |
| // For a pointer type we apparently have to wrap in the decl. |
| SwigType *var_type = NewString(Getattr(var, "type")); |
| SwigType_push(var_type, Getattr(var, "decl")); |
| Setattr(var, "type", var_type); |
| |
| SwigType *vt = Copy(var_type); |
| |
| int flags = Extend | SmartPointer | use_naturalvar_mode(var); |
| if (isNonVirtualProtectedAccess(var)) { |
| flags |= CWRAP_ALL_PROTECTED_ACCESS; |
| } |
| |
| // Copied from Swig_wrapped_member_var_type. |
| if (SwigType_isclass(vt)) { |
| if (flags & CWRAP_NATURAL_VAR) { |
| if (CPlusPlus) { |
| if (!SwigType_isconst(vt)) { |
| SwigType_add_qualifier(vt, "const"); |
| } |
| SwigType_add_reference(vt); |
| } |
| } else { |
| SwigType_add_pointer(vt); |
| } |
| } |
| |
| String *mname = Swig_name_member(getNSpace(), Getattr(var_class, "sym:name"), var_name); |
| |
| if (is_assignable(var)) { |
| for (Iterator ki = First(var); ki.key; ki = Next(ki)) { |
| if (Strncmp(ki.key, "tmap:", 5) == 0) { |
| Delattr(var, ki.key); |
| } |
| } |
| Swig_save("goBaseVariableSet", var, "name", "sym:name", "type", NULL); |
| |
| String *mname_set = NewString("Set"); |
| Append(mname_set, mname); |
| |
| String *go_name = NewString("Set"); |
| Append(go_name, var_name); |
| |
| Swig_MembersetToFunction(var, class_name, flags); |
| |
| String *wname = Swig_name_wrapper(mname_set); |
| Append(wname, unique_id); |
| ParmList *parms = NewParm(vt, var_name, var); |
| String *result = NewString("void"); |
| int r = makeWrappers(var, go_name, NULL, wname, bases, parms, result, false); |
| if (r != SWIG_OK) { |
| return r; |
| } |
| Delete(wname); |
| Delete(parms); |
| Delete(result); |
| Delete(go_name); |
| Delete(mname_set); |
| |
| Swig_restore(var); |
| for (Iterator ki = First(var); ki.key; ki = Next(ki)) { |
| if (Strncmp(ki.key, "tmap:", 5) == 0) { |
| Delattr(var, ki.key); |
| } |
| } |
| } |
| |
| Swig_MembergetToFunction(var, class_name, flags); |
| |
| String *mname_get = NewString("Get"); |
| Append(mname_get, mname); |
| |
| String *go_name = NewString("Get"); |
| Append(go_name, var_name); |
| |
| String *wname = Swig_name_wrapper(mname_get); |
| Append(wname, unique_id); |
| |
| int r = makeWrappers(var, go_name, NULL, wname, bases, NULL, vt, false); |
| if (r != SWIG_OK) { |
| return r; |
| } |
| |
| Delete(wname); |
| Delete(mname_get); |
| Delete(go_name); |
| Delete(mname); |
| Delete(var_name); |
| Delete(var_type); |
| Delete(vt); |
| |
| Swig_restore(var); |
| |
| return SWIG_OK; |
| } |
| |
| /* ------------------------------------------------------------ |
| * addFirstBaseInterface() |
| * |
| * When a C++ class uses multiple inheritance, we can use the C++ |
| * pointer for the first base class but not for any subsequent base |
| * classes. However, the Go interface will match the interface for |
| * all the base classes. To avoid accidentally treating a class as |
| * a pointer to a base class other than the first one, we use an |
| * isClassname method. This function adds those methods as |
| * required. |
| * |
| * For convenience when using multiple inheritance, we also add |
| * functions to retrieve the base class pointers. |
| * ------------------------------------------------------------ */ |
| |
| void addFirstBaseInterface(Node *n, Hash *parents, List *bases) { |
| if (!bases || Len(bases) == 0) { |
| return; |
| } |
| Iterator b = First(bases); |
| if (!GetFlag(b.item, "feature:ignore")) { |
| String *go_name = buildGoName(Getattr(n, "sym:name"), false, false); |
| String *go_type_name = goCPointerType(Getattr(n, "classtypeobj"), true); |
| String *go_base_name = exportedName(Getattr(b.item, "sym:name")); |
| String *go_base_type = goType(n, Getattr(b.item, "classtypeobj")); |
| String *go_base_type_name = goCPointerType(Getattr(b.item, "classtypeobj"), true); |
| |
| Printv(f_go_wrappers, "func (p ", go_type_name, ") SwigIs", go_base_name, "() {\n", NULL); |
| Printv(f_go_wrappers, "}\n\n", NULL); |
| |
| Printv(interfaces, "\tSwigIs", go_base_name, "()\n", NULL); |
| |
| Printv(f_go_wrappers, "func (p ", go_type_name, ") SwigGet", go_base_name, "() ", go_base_type, " {\n", NULL); |
| Printv(f_go_wrappers, "\treturn ", go_base_type_name, "(getSwigcptr(p))\n", NULL); |
| Printv(f_go_wrappers, "}\n\n", NULL); |
| |
| Printv(interfaces, "\tSwigGet", go_base_name, "() ", go_base_type, "\n", NULL); |
| |
| Setattr(parents, go_base_name, NewString("")); |
| |
| Delete(go_name); |
| Delete(go_type_name); |
| Delete(go_base_type); |
| Delete(go_base_type_name); |
| } |
| |
| addFirstBaseInterface(n, parents, Getattr(b.item, "bases")); |
| } |
| |
| /* ------------------------------------------------------------ |
| * addExtraBaseInterfaces() |
| * |
| * Add functions to retrieve the base class pointers for all base |
| * classes other than the first. |
| * ------------------------------------------------------------ */ |
| |
| int addExtraBaseInterfaces(Node *n, Hash *parents, List *bases) { |
| Iterator b = First(bases); |
| |
| Node *fb = b.item; |
| |
| for (b = Next(b); b.item; b = Next(b)) { |
| if (GetFlag(b.item, "feature:ignore")) { |
| continue; |
| } |
| |
| String *go_base_name = exportedName(Getattr(b.item, "sym:name")); |
| |
| Swig_save("addExtraBaseInterface", n, "wrap:action", "wrap:name", "wrap:parms", NULL); |
| |
| SwigType *type = Copy(Getattr(n, "classtypeobj")); |
| SwigType_add_pointer(type); |
| Parm *parm = NewParm(type, "self", n); |
| Setattr(n, "wrap:parms", parm); |
| |
| String *pn = Swig_cparm_name(parm, 0); |
| String *action = NewString(""); |
| Printv(action, Swig_cresult_name(), " = (", Getattr(b.item, "classtype"), "*)", pn, ";", NULL); |
| Delete(pn); |
| |
| Setattr(n, "wrap:action", action); |
| |
| String *name = Copy(class_name); |
| Append(name, "_SwigGet"); |
| Append(name, go_base_name); |
| |
| String *go_name = NewString("SwigGet"); |
| String *c1 = exportedName(go_base_name); |
| Append(go_name, c1); |
| Delete(c1); |
| |
| String *wname = Swig_name_wrapper(name); |
| Append(wname, unique_id); |
| Setattr(n, "wrap:name", wname); |
| |
| SwigType *result = Copy(Getattr(b.item, "classtypeobj")); |
| SwigType_add_pointer(result); |
| |
| int r = makeWrappers(n, go_name, NULL, wname, NULL, parm, result, false); |
| if (r != SWIG_OK) { |
| return r; |
| } |
| |
| Swig_restore(n); |
| |
| Setattr(parents, go_base_name, NewString("")); |
| |
| Delete(go_name); |
| Delete(type); |
| Delete(parm); |
| Delete(action); |
| Delete(result); |
| |
| String *ns = NewString(""); |
| addParentExtraBaseInterfaces(n, parents, b.item, false, ns); |
| Delete(ns); |
| } |
| |
| if (!GetFlag(fb, "feature:ignore")) { |
| String *ns = NewString(""); |
| addParentExtraBaseInterfaces(n, parents, fb, true, ns); |
| Delete(ns); |
| } |
| |
| return SWIG_OK; |
| } |
| |
| /* ------------------------------------------------------------ |
| * addParentExtraBaseInterfaces() |
| * |
| * Add functions to retrieve the base class pointers for all base |
| * classes of parents other than the first base class at each level. |
| * ------------------------------------------------------------ */ |
| |
| void addParentExtraBaseInterfaces(Node *n, Hash *parents, Node *base, bool is_base_first, String *sofar) { |
| List *baselist = Getattr(base, "bases"); |
| if (!baselist || Len(baselist) == 0) { |
| return; |
| } |
| |
| String *go_this_base_name = exportedName(Getattr(base, "sym:name")); |
| |
| String *sf = NewString(""); |
| Printv(sf, sofar, ".SwigGet", go_this_base_name, "()", NULL); |
| |
| Iterator b = First(baselist); |
| |
| if (is_base_first) { |
| if (!b.item) { |
| return; |
| } |
| if (!GetFlag(b.item, "feature:ignore")) { |
| addParentExtraBaseInterfaces(n, parents, b.item, true, sf); |
| } |
| |
| b = Next(b); |
| } |
| |
| String *go_name = buildGoName(Getattr(n, "sym:name"), false, false); |
| String *go_type_name = goCPointerType(Getattr(n, "classtypeobj"), true); |
| |
| for (; b.item; b = Next(b)) { |
| if (GetFlag(b.item, "feature:ignore")) { |
| continue; |
| } |
| |
| String *go_base_name = exportedName(Getattr(b.item, "sym:name")); |
| |
| if (!Getattr(parents, go_base_name)) { |
| Printv(f_go_wrappers, "func (p ", go_type_name, ") SwigGet", go_base_name, "() ", go_base_name, " {\n", NULL); |
| Printv(f_go_wrappers, "\treturn p", sf, ".SwigGet", go_base_name, "()\n", NULL); |
| Printv(f_go_wrappers, "}\n\n", NULL); |
| |
| Printv(interfaces, "\tSwigGet", go_base_name, "() ", go_base_name, "\n", NULL); |
| |
| addParentExtraBaseInterfaces(n, parents, b.item, false, sf); |
| |
| Setattr(parents, go_base_name, NewString("")); |
| } |
| } |
| |
| Delete(go_name); |
| Delete(go_type_name); |
| Delete(go_this_base_name); |
| Delete(sf); |
| } |
| |
| /* ------------------------------------------------------------ |
| * classDirectorInit |
| * |
| * Add support for a director class. |
| * |
| * Virtual inheritance is different in Go and C++. We implement |
| * director classes by defining a new function in Go, |
| * NewDirectorClassname, which takes a empty interface value and |
| * creates an instance of a new child class. The new child class |
| * refers all methods back to Go. The Go code checks whether the |
| * value passed to NewDirectorClassname implements that method; if |
| * it does, it calls it, otherwise it calls back into C++. |
| * ------------------------------------------------------------ */ |
| |
| int classDirectorInit(Node *n) { |
| // Because we use a different function to handle inheritance in |
| // Go, ordinary creations of the object should not create a |
| // director object. |
| Delete(director_ctor_code); |
| director_ctor_code = NewString("$nondirector_new"); |
| |
| class_node = n; |
| |
| String *name = Getattr(n, "sym:name"); |
| |
| assert(!class_name); |
| class_name = name; |
| |
| String *go_name = exportedName(name); |
| |
| String *go_type_name = goCPointerType(Getattr(n, "classtypeobj"), true); |
| |
| assert(!class_receiver); |
| class_receiver = go_type_name; |
| |
| String *director_struct_name = NewString("_swig_Director"); |
| Append(director_struct_name, go_name); |
| |
| String *cxx_director_name = NewString("SwigDirector_"); |
| Append(cxx_director_name, name); |
| |
| // The Go type of the director class. |
| Printv(f_go_wrappers, "type ", director_struct_name, " struct {\n", NULL); |
| Printv(f_go_wrappers, "\t", go_type_name, "\n", NULL); |
| Printv(f_go_wrappers, "\tv interface{}\n", NULL); |
| Printv(f_go_wrappers, "}\n\n", NULL); |
| |
| Printv(f_go_wrappers, "func (p *", director_struct_name, ") Swigcptr() uintptr {\n", NULL); |
| Printv(f_go_wrappers, "\treturn getSwigcptr(p.", go_type_name, ")\n", NULL); |
| Printv(f_go_wrappers, "}\n\n", NULL); |
| |
| Printv(f_go_wrappers, "func (p *", director_struct_name, ") SwigIs", go_name, "() {\n", NULL); |
| Printv(f_go_wrappers, "}\n\n", NULL); |
| |
| Printv(f_go_wrappers, "func (p *", director_struct_name, ") DirectorInterface() interface{} {\n", NULL); |
| Printv(f_go_wrappers, "\treturn p.v\n", NULL); |
| Printv(f_go_wrappers, "}\n\n", NULL); |
| |
| // Start defining the director class. |
| Printv(f_c_directors_h, "class ", cxx_director_name, " : public ", Getattr(n, "classtype"), "\n", NULL); |
| Printv(f_c_directors_h, "{\n", NULL); |
| Printv(f_c_directors_h, " public:\n", NULL); |
| |
| Delete(director_struct_name); |
| Delete(cxx_director_name); |
| |
| class_methods = NewHash(); |
| |
| return SWIG_OK; |
| } |
| |
| /* ------------------------------------------------------------ |
| * classDirectorConstructor |
| * |
| * Emit a constructor for a director class. |
| * ------------------------------------------------------------ */ |
| |
| int classDirectorConstructor(Node *n) { |
| bool is_ignored = GetFlag(n, "feature:ignore") ? true : false; |
| |
| String *name = Getattr(n, "sym:name"); |
| if (!name) { |
| assert(is_ignored); |
| name = Getattr(n, "name"); |
| } |
| |
| String *overname = NULL; |
| if (Getattr(n, "sym:overloaded")) { |
| overname = Getattr(n, "sym:overname"); |
| } |
| |
| String *go_name = exportedName(name); |
| |
| ParmList *parms = Getattr(n, "parms"); |
| Setattr(n, "wrap:parms", parms); |
| |
| String *cn = exportedName(Getattr(parentNode(n), "sym:name")); |
| |
| String *go_type_name = goCPointerType(Getattr(parentNode(n), "classtypeobj"), true); |
| |
| String *director_struct_name = NewString("_swig_Director"); |
| Append(director_struct_name, cn); |
| |
| String *fn_name = NewString("_swig_NewDirector"); |
| Append(fn_name, cn); |
| Append(fn_name, go_name); |
| |
| if (!overname && !is_ignored) { |
| if (!checkNameConflict(fn_name, n, NULL)) { |
| return SWIG_NOWRAP; |
| } |
| } |
| |
| String *fn_with_over_name = Copy(fn_name); |
| if (overname) { |
| Append(fn_with_over_name, overname); |
| } |
| |
| String *wname = Swig_name_wrapper(fn_name); |
| |
| if (overname) { |
| Append(wname, overname); |
| } |
| Append(wname, unique_id); |
| Setattr(n, "wrap:name", wname); |
| |
| bool is_static = isStatic(n); |
| |
| Wrapper *dummy = NewWrapper(); |
| emit_attach_parmmaps(parms, dummy); |
| DelWrapper(dummy); |
| |
| Swig_typemap_attach_parms("gotype", parms, NULL); |
| Swig_typemap_attach_parms("goin", parms, NULL); |
| Swig_typemap_attach_parms("goargout", parms, NULL); |
| Swig_typemap_attach_parms("imtype", parms, NULL); |
| int parm_count = emit_num_arguments(parms); |
| |
| String *func_name = NewString("NewDirector"); |
| Append(func_name, go_name); |
| |
| String *func_with_over_name = Copy(func_name); |
| if (overname) { |
| Append(func_with_over_name, overname); |
| } |
| |
| SwigType *first_type = NewString("int"); |
| Parm *first_parm = NewParm(first_type, "swig_p", n); |
| set_nextSibling(first_parm, parms); |
| Setattr(first_parm, "lname", "p"); |
| |
| Parm *p = parms; |
| for (int i = 0; i < parm_count; ++i) { |
| p = getParm(p); |
| Swig_cparm_name(p, i); |
| p = nextParm(p); |
| } |
| |
| if (!is_ignored) { |
| Printv(f_cgo_comment, "extern uintptr_t ", wname, "(int", NULL); |
| |
| p = parms; |
| for (int i = 0; i < parm_count; ++i) { |
| p = getParm(p); |
| bool c_struct_type; |
| String *ct = cgoTypeForGoValue(p, Getattr(p, "type"), &c_struct_type); |
| Printv(f_cgo_comment, ", ", ct, " ", Getattr(p, "lname"), NULL); |
| p = nextParm(p); |
| } |
| Printv(f_cgo_comment, ");\n", NULL); |
| |
| // Write out the Go function that calls the wrapper. |
| |
| Printv(f_go_wrappers, "func ", func_with_over_name, "(v interface{}", NULL); |
| |
| p = parms; |
| for (int i = 0; i < parm_count; ++i) { |
| p = getParm(p); |
| Printv(f_go_wrappers, ", ", Getattr(p, "lname"), " ", NULL); |
| String *tm = goType(p, Getattr(p, "type")); |
| Printv(f_go_wrappers, tm, NULL); |
| Delete(tm); |
| p = nextParm(p); |
| } |
| |
| Printv(f_go_wrappers, ") ", cn, " {\n", NULL); |
| |
| Printv(f_go_wrappers, "\tp := &", director_struct_name, "{0, v}\n", NULL); |
| |
| String *call = NewString(""); |
| |
| Printv(call, "\tp.", class_receiver, " = ", NULL); |
| Printv(call, go_type_name, "(C.", wname, "(C.int(swigDirectorAdd(p))", NULL); |
| |
| p = parms; |
| for (int i = 0; i < parm_count; ++i) { |
| Printv(call, ", ", NULL); |
| |
| p = getParm(p); |
| String *pt = Getattr(p, "type"); |
| String *ln = Getattr(p, "lname"); |
| |
| String *ivar = NewStringf("_swig_i_%d", i); |
| |
| String *goin = goGetattr(p, "tmap:goin"); |
| if (goin == NULL) { |
| Printv(f_go_wrappers, "\t", ivar, " := ", NULL); |
| bool need_close = false; |
| if (goTypeIsInterface(p, pt)) { |
| Printv(f_go_wrappers, "getSwigcptr(", NULL); |
| need_close = true; |
| } |
| Printv(f_go_wrappers, ln, NULL); |
| if (need_close) { |
| Printv(f_go_wrappers, ")", NULL); |
| } |
| Printv(f_go_wrappers, "\n", NULL); |
| } else { |
| String *itm = goImType(p, pt); |
| Printv(f_go_wrappers, "\tvar ", ivar, " ", itm, "\n", NULL); |
| goin = Copy(goin); |
| Replaceall(goin, "$input", ln); |
| Replaceall(goin, "$result", ivar); |
| Printv(f_go_wrappers, goin, "\n", NULL); |
| Delete(goin); |
| } |
| |
| Setattr(p, "emit:goinput", ivar); |
| |
| bool c_struct_type; |
| String *ct = cgoTypeForGoValue(p, pt, &c_struct_type); |
| if (c_struct_type) { |
| Printv(call, "*(*C.", ct, ")(unsafe.Pointer(&", ivar, "))", NULL); |
| } else { |
| Printv(call, "C.", ct, "(", ivar, ")", NULL); |
| } |
| Delete(ct); |
| |
| p = nextParm(p); |
| } |
| |
| Printv(call, "))", NULL); |
| |
| Printv(f_go_wrappers, call, "\n", NULL); |
| |
| goargout(parms); |
| |
| Printv(f_go_wrappers, "\treturn p\n", NULL); |
| Printv(f_go_wrappers, "}\n\n", NULL); |
| |
| SwigType *result = Copy(Getattr(parentNode(n), "classtypeobj")); |
| SwigType_add_pointer(result); |
| |
| Swig_save("classDirectorConstructor", n, "wrap:name", "wrap:action", NULL); |
| |
| String *dwname = Swig_name_wrapper(name); |
| Append(dwname, unique_id); |
| Setattr(n, "wrap:name", dwname); |
| |
| String *action = NewString(""); |
| Printv(action, Swig_cresult_name(), " = new SwigDirector_", class_name, "(", NULL); |
| String *pname = Swig_cparm_name(NULL, 0); |
| Printv(action, pname, NULL); |
| Delete(pname); |
| p = parms; |
| for (int i = 0; i < parm_count; ++i) { |
| p = getParm(p); |
| String *pname = Swig_cparm_name(NULL, i + 1); |
| Printv(action, ", ", NULL); |
| if (SwigType_isreference(Getattr(p, "type"))) { |
| Printv(action, "*", NULL); |
| } |
| Printv(action, pname, NULL); |
| Delete(pname); |
| p = nextParm(p); |
| } |
| Printv(action, ");", NULL); |
| Setattr(n, "wrap:action", action); |
| |
| cgoWrapperInfo info; |
| |
| info.n = n; |
| info.go_name = func_name; |
| info.overname = overname; |
| info.wname = wname; |
| info.base = NULL; |
| info.parms = first_parm; |
| info.result = result; |
| info.is_static = false; |
| info.receiver = NULL; |
| info.is_constructor = true; |
| info.is_destructor = false; |
| |
| int r = cgoGccWrapper(&info); |
| if (r != SWIG_OK) { |
| return r; |
| } |
| |
| Swig_restore(n); |
| |
| Delete(result); |
| } |
| |
| String *cxx_director_name = NewString("SwigDirector_"); |
| Append(cxx_director_name, class_name); |
| |
| String *decl = Swig_method_decl(NULL, Getattr(n, "decl"), cxx_director_name, first_parm, 0); |
| Printv(f_c_directors_h, " ", decl, ";\n", NULL); |
| Delete(decl); |
| |
| decl = Swig_method_decl(NULL, Getattr(n, "decl"), cxx_director_name, first_parm, 0); |
| Printv(f_c_directors, cxx_director_name, "::", decl, "\n", NULL); |
| Delete(decl); |
| |
| Printv(f_c_directors, " : ", Getattr(parentNode(n), "classtype"), "(", NULL); |
| |
| p = parms; |
| for (int i = 0; i < parm_count; ++i) { |
| p = getParm(p); |
| if (i > 0) { |
| Printv(f_c_directors, ", ", NULL); |
| } |
| String *pn = Getattr(p, "name"); |
| assert(pn); |
| Printv(f_c_directors, pn, NULL); |
| p = nextParm(p); |
| } |
| Printv(f_c_directors, "),\n", NULL); |
| Printv(f_c_directors, " go_val(swig_p), swig_mem(0)\n", NULL); |
| Printv(f_c_directors, "{ }\n\n", NULL); |
| |
| if (Getattr(n, "sym:overloaded") && !Getattr(n, "sym:nextSibling")) { |
| int r = makeDispatchFunction(n, func_name, cn, is_static, Getattr(parentNode(n), "classtypeobj"), false); |
| if (r != SWIG_OK) { |
| return r; |
| } |
| } |
| |
| Delete(cxx_director_name); |
| Delete(go_name); |
| Delete(cn); |
| Delete(go_type_name); |
| Delete(director_struct_name); |
| Delete(fn_name); |
| Delete(fn_with_over_name); |
| Delete(func_name); |
| Delete(func_with_over_name); |
| Delete(wname); |
| Delete(first_type); |
| Delete(first_parm); |
| |
| return SWIG_OK; |
| } |
| |
| /* ------------------------------------------------------------ |
| * classDirectorDestructor |
| * |
| * Emit a destructor for a director class. |
| * ------------------------------------------------------------ */ |
| |
| int classDirectorDestructor(Node *n) { |
| if (!is_public(n)) { |
| return SWIG_OK; |
| } |
| |
| bool is_ignored = GetFlag(n, "feature:ignore") ? true : false; |
| |
| if (!is_ignored) { |
| String *fnname = NewString("DeleteDirector"); |
| String *c1 = exportedName(class_name); |
| Append(fnname, c1); |
| Delete(c1); |
| |
| String *wname = Swig_name_wrapper(fnname); |
| Append(wname, unique_id); |
| |
| Setattr(n, "wrap:name", fnname); |
| |
| Swig_DestructorToFunction(n, getNSpace(), getClassType(), CPlusPlus, Extend); |
| |
| ParmList *parms = Getattr(n, "parms"); |
| Setattr(n, "wrap:parms", parms); |
| |
| String *result = NewString("void"); |
| int r = makeWrappers(n, fnname, NULL, wname, NULL, parms, result, isStatic(n)); |
| if (r != SWIG_OK) { |
| return r; |
| } |
| |
| Delete(result); |
| Delete(fnname); |
| Delete(wname); |
| } |
| |
| // Generate the destructor for the C++ director class. Since the |
| // Go code is keeping a pointer to the C++ object, we need to call |
| // back to the Go code to let it know that the C++ object is gone. |
| |
| String *go_name = NewString("Swiggo_DeleteDirector_"); |
| Append(go_name, class_name); |
| |
| String *cn = exportedName(class_name); |
| |
| String *director_struct_name = NewString("_swig_Director"); |
| Append(director_struct_name, cn); |
| |
| Printv(f_c_directors_h, " virtual ~SwigDirector_", class_name, "()", NULL); |
| |
| String *throws = buildThrow(n); |
| if (throws) { |
| Printv(f_c_directors_h, " ", throws, NULL); |
| } |
| |
| Printv(f_c_directors_h, ";\n", NULL); |
| |
| String *director_sig = NewString(""); |
| |
| Printv(director_sig, "SwigDirector_", class_name, "::~SwigDirector_", class_name, "()", NULL); |
| |
| if (throws) { |
| Printv(director_sig, " ", throws, NULL); |
| Delete(throws); |
| } |
| |
| Printv(director_sig, "\n", NULL); |
| Printv(director_sig, "{\n", NULL); |
| |
| if (is_ignored) { |
| Printv(f_c_directors, director_sig, NULL); |
| } else { |
| makeDirectorDestructorWrapper(go_name, director_struct_name, director_sig); |
| } |
| |
| Printv(f_c_directors, " delete swig_mem;\n", NULL); |
| |
| Printv(f_c_directors, "}\n\n", NULL); |
| |
| Delete(director_sig); |
| Delete(go_name); |
| Delete(cn); |
| Delete(director_struct_name); |
| |
| return SWIG_OK; |
| } |
| |
| /* ------------------------------------------------------------ |
| * makeDirectorDestructorWrapper |
| * |
| * Emit the function wrapper for the destructor of a director class. |
| * ------------------------------------------------------------ */ |
| |
| void makeDirectorDestructorWrapper(String *go_name, String *director_struct_name, String *director_sig) { |
| String *wname = Copy(go_name); |
| Append(wname, unique_id); |
| |
| Printv(f_go_wrappers, "//export ", wname, "\n", NULL); |
| Printv(f_go_wrappers, "func ", wname, "(c int) {\n", NULL); |
| Printv(f_go_wrappers, "\tswigDirectorLookup(c).(*", director_struct_name, ").", class_receiver, " = 0\n", NULL); |
| Printv(f_go_wrappers, "\tswigDirectorDelete(c)\n", NULL); |
| Printv(f_go_wrappers, "}\n\n", NULL); |
| |
| Printv(f_c_directors, "extern \"C\" void ", wname, "(intgo);\n", NULL); |
| Printv(f_c_directors, director_sig, NULL); |
| Printv(f_c_directors, " ", wname, "(go_val);\n", NULL); |
| } |
| |
| /* ------------------------------------------------------------ |
| * classDirectorMethod |
| * |
| * Emit a method for a director class, plus its overloads. |
| * ------------------------------------------------------------ */ |
| |
| int classDirectorMethod(Node *n, Node *parent, String *super) { |
| bool is_ignored = GetFlag(n, "feature:ignore") ? true : false; |
| |
| // We don't need explicit calls. |
| if (GetFlag(n, "explicitcall")) { |
| return SWIG_OK; |
| } |
| |
| String *name = Getattr(n, "sym:name"); |
| if (!name) { |
| assert(is_ignored); |
| (void)is_ignored; |
| name = Getattr(n, "name"); |
| } |
| |
| bool overloaded = Getattr(n, "sym:overloaded") && !Getattr(n, "explicitcallnode"); |
| if (!overloaded) { |
| int r = oneClassDirectorMethod(n, parent, super); |
| if (r != SWIG_OK) { |
| return r; |
| } |
| } else { |
| // Handle overloaded methods here, because otherwise we will |
| // reject them in the class_methods hash table. We need to use |
| // class_methods so that we correctly handle cases where a |
| // function in one class hides a function of the same name in a |
| // parent class. |
| if (!Getattr(class_methods, name)) { |
| for (Node *on = Getattr(n, "sym:overloaded"); on; on = Getattr(on, "sym:nextSibling")) { |
| // Swig_overload_rank expects wrap:name and wrap:parms to be |
| // set. |
| String *wn = Swig_name_wrapper(Getattr(on, "sym:name")); |
| Append(wn, Getattr(on, "sym:overname")); |
| Append(wn, unique_id); |
| Setattr(on, "wrap:name", wn); |
| Delete(wn); |
| Setattr(on, "wrap:parms", Getattr(on, "parms")); |
| } |
| } |
| |
| int r = oneClassDirectorMethod(n, parent, super); |
| if (r != SWIG_OK) { |
| return r; |
| } |
| |
| if (!Getattr(n, "sym:nextSibling")) |
| { |
| // Last overloaded function |
| Node *on = Getattr(n, "sym:overloaded"); |
| bool is_static = isStatic(on); |
| |
| String *cn = exportedName(Getattr(parent, "sym:name")); |
| String *go_name = buildGoName(name, is_static, false); |
| |
| String *director_struct_name = NewString("_swig_Director"); |
| Append(director_struct_name, cn); |
| |
| int r = makeDispatchFunction(on, go_name, director_struct_name, is_static, director_struct_name, false); |
| if (r != SWIG_OK) { |
| return r; |
| } |
| |
| if (!GetFlag(n, "abstract")) { |
| String *go_upcall = NewString("Director"); |
| Append(go_upcall, cn); |
| Append(go_upcall, go_name); |
| r = makeDispatchFunction(on, go_upcall, director_struct_name, is_static, director_struct_name, true); |
| if (r != SWIG_OK) { |
| return r; |
| } |
| Delete(go_upcall); |
| } |
| |
| Delete(director_struct_name); |
| Delete(go_name); |
| Delete(cn); |
| } |
| } |
| Setattr(class_methods, name, NewString("")); |
| |
| return SWIG_OK; |
| } |
| |
| /* ------------------------------------------------------------ |
| * oneClassDirectorMethod |
| * |
| * Emit a method for a director class. |
| * ------------------------------------------------------------ */ |
| |
| int oneClassDirectorMethod(Node *n, Node *parent, String *super) { |
| String *symname = Getattr(n, "sym:name"); |
| if (!checkFunctionVisibility(n, parent)) { |
| return SWIG_OK; |
| } |
| |
| bool is_ignored = GetFlag(n, "feature:ignore") ? true : false; |
| bool is_pure_virtual = (Cmp(Getattr(n, "storage"), "virtual") == 0 && Cmp(Getattr(n, "value"), "0") == 0); |
| |
| String *name = Getattr(n, "sym:name"); |
| if (!name) { |
| assert(is_ignored); |
| name = Getattr(n, "name"); |
| } |
| |
| String *overname = NULL; |
| if (Getattr(n, "sym:overloaded")) { |
| overname = Getattr(n, "sym:overname"); |
| } |
| |
| String *cn = exportedName(Getattr(parent, "sym:name")); |
| |
| String *go_type_name = goCPointerType(Getattr(parent, "classtypeobj"), true); |
| |
| String *director_struct_name = NewString("_swig_Director"); |
| Append(director_struct_name, cn); |
| |
| bool is_static = isStatic(n); |
| |
| String *go_name = buildGoName(name, is_static, false); |
| |
| ParmList *parms = Getattr(n, "parms"); |
| Setattr(n, "wrap:parms", parms); |
| |
| Wrapper *dummy = NewWrapper(); |
| emit_attach_parmmaps(parms, dummy); |
| |
| Swig_typemap_attach_parms("gotype", parms, NULL); |
| Swig_typemap_attach_parms("imtype", parms, NULL); |
| int parm_count = emit_num_arguments(parms); |
| |
| SwigType *result = Getattr(n, "type"); |
| |
| // Save the type for overload processing. |
| Setattr(n, "go:type", result); |
| |
| String *interface_name = NewString("_swig_DirectorInterface"); |
| Append(interface_name, cn); |
| Append(interface_name, go_name); |
| if (overname) { |
| Append(interface_name, overname); |
| } |
| |
| String *callback_name = Copy(director_struct_name); |
| Append(callback_name, "_callback_"); |
| Append(callback_name, name); |
| Replace(callback_name, "_swig", "Swig", DOH_REPLACE_FIRST); |
| if (overname) { |
| Append(callback_name, overname); |
| } |
| Append(callback_name, unique_id); |
| |
| String *upcall_name = Copy(director_struct_name); |
| Append(upcall_name, "_upcall_"); |
| Append(upcall_name, go_name); |
| |
| String *upcall_wname = Swig_name_wrapper(upcall_name); |
| if (overname) { |
| Append(upcall_wname, overname); |
| } |
| Append(upcall_wname, unique_id); |
| |
| String *upcall_gc_name = buildGoWrapperName(upcall_name, overname); |
| |
| String *go_with_over_name = Copy(go_name); |
| if (overname) { |
| Append(go_with_over_name, overname); |
| } |
| |
| Parm *p = 0; |
| Wrapper *w = NewWrapper(); |
| |
| Swig_director_parms_fixup(parms); |
| |
| Swig_typemap_attach_parms("directorin", parms, w); |
| Swig_typemap_attach_parms("directorargout", parms, w); |
| Swig_typemap_attach_parms("godirectorin", parms, w); |
| Swig_typemap_attach_parms("goin", parms, dummy); |
| Swig_typemap_attach_parms("goargout", parms, dummy); |
| |
| DelWrapper(dummy); |
| |
| if (!is_ignored) { |
| // We use an interface to see if this method is defined in Go. |
| Printv(f_go_wrappers, "type ", interface_name, " interface {\n", NULL); |
| Printv(f_go_wrappers, "\t", go_with_over_name, "(", NULL); |
| |
| p = parms; |
| for (int i = 0; i < parm_count; ++i) { |
| p = getParm(p); |
| if (i > 0) { |
| Printv(f_go_wrappers, ", ", NULL); |
| } |
| String *tm = goType(p, Getattr(p, "type")); |
| Printv(f_go_wrappers, tm, NULL); |
| Delete(tm); |
| p = nextParm(p); |
| } |
| |
| Printv(f_go_wrappers, ")", NULL); |
| |
| if (SwigType_type(result) != T_VOID) { |
| String *tm = goType(n, result); |
| Printv(f_go_wrappers, " ", tm, NULL); |
| Delete(tm); |
| } |
| |
| Printv(f_go_wrappers, "\n", NULL); |
| Printv(f_go_wrappers, "}\n\n", NULL); |
| |
| if (!GetFlag(n, "abstract")) { |
| Printv(f_cgo_comment, "extern ", NULL); |
| |
| if (SwigType_type(result) == T_VOID) { |
| Printv(f_cgo_comment, "void", NULL); |
| } else { |
| bool c_struct_type; |
| String *ret_type = cgoTypeForGoValue(n, result, &c_struct_type); |
| Printv(f_cgo_comment, ret_type, NULL); |
| Delete(ret_type); |
| } |
| |
| Printv(f_cgo_comment, " ", upcall_wname, "(uintptr_t", NULL); |
| |
| p = parms; |
| for (int i = 0; i < parm_count; ++i) { |
| p = getParm(p); |
| bool c_struct_type; |
| String *ct = cgoTypeForGoValue(p, Getattr(p, "type"), &c_struct_type); |
| Printv(f_cgo_comment, ", ", ct, " ", Getattr(p, "lname"), NULL); |
| p = nextParm(p); |
| } |
| Printv(f_cgo_comment, ");\n", NULL); |
| } |
| |
| // Define the method on the director class in Go. |
| |
| Printv(f_go_wrappers, "func (swig_p *", director_struct_name, ") ", go_with_over_name, "(", NULL); |
| |
| p = parms; |
| for (int i = 0; i < parm_count; ++i) { |
| p = getParm(p); |
| if (i > 0) { |
| Printv(f_go_wrappers, ", ", NULL); |
| } |
| Printv(f_go_wrappers, Getattr(p, "lname"), " ", NULL); |
| String *tm = goType(p, Getattr(p, "type")); |
| Printv(f_go_wrappers, tm, NULL); |
| Delete(tm); |
| p = nextParm(p); |
| } |
| |
| Printv(f_go_wrappers, ")", NULL); |
| |
| if (SwigType_type(result) != T_VOID) { |
| String *tm = goType(n, result); |
| Printv(f_go_wrappers, " ", tm, NULL); |
| Delete(tm); |
| } |
| |
| Printv(f_go_wrappers, " {\n", NULL); |
| |
| Printv(f_go_wrappers, "\tif swig_g, swig_ok := swig_p.v.(", interface_name, "); swig_ok {\n", NULL); |
| Printv(f_go_wrappers, "\t\t", NULL); |
| if (SwigType_type(result) != T_VOID) { |
| Printv(f_go_wrappers, "return ", NULL); |
| } |
| Printv(f_go_wrappers, "swig_g.", go_with_over_name, "(", NULL); |
| |
| p = parms; |
| for (int i = 0; i < parm_count; ++i) { |
| p = getParm(p); |
| if (i > 0) { |
| Printv(f_go_wrappers, ", ", NULL); |
| } |
| Printv(f_go_wrappers, Getattr(p, "lname"), NULL); |
| p = nextParm(p); |
| } |
| |
| Printv(f_go_wrappers, ")\n", NULL); |
| if (SwigType_type(result) == T_VOID) { |
| Printv(f_go_wrappers, "\t\treturn\n", NULL); |
| } |
| Printv(f_go_wrappers, "\t}\n", NULL); |
| |
| if (GetFlag(n, "abstract")) { |
| Printv(f_go_wrappers, "\tpanic(\"call to pure virtual method\")\n", NULL); |
| } else { |
| String *ret_type = NULL; |
| bool memcpy_ret = false; |
| String *wt = NULL; |
| String *goout = NULL; |
| if (SwigType_type(result) != T_VOID) { |
| ret_type = goImType(n, result); |
| Printv(f_go_wrappers, "\tvar swig_r ", ret_type, "\n", NULL); |
| goout = goTypemapLookup("goout", n, "swig_r"); |
| |
| bool c_struct_type; |
| Delete(cgoTypeForGoValue(n, result, &c_struct_type)); |
| if (c_struct_type) { |
| memcpy_ret = true; |
| } |
| } |
| |
| String *call = NewString(""); |
| |
| Printv(call, "\t", NULL); |
| if (SwigType_type(result) != T_VOID) { |
| if (memcpy_ret) { |
| Printv(call, "swig_r_p := ", NULL); |
| } else { |
| Printv(call, "swig_r = (", ret_type, ")(", NULL); |
| } |
| if (goTypeIsInterface(n, result)) { |
| wt = goWrapperType(n, result, true); |
| Printv(call, "(", wt, ")(", NULL); |
| } |
| } |
| |
| Printv(call, "C.", upcall_wname, "(C.uintptr_t(swig_p.", |
| go_type_name, ")", NULL); |
| |
| p = parms; |
| for (int i = 0; i < parm_count; ++i) { |
| Printv(call, ", ", NULL); |
| p = getParm(p); |
| SwigType *pt = Getattr(p, "type"); |
| |
| String *ln = Getattr(p, "lname"); |
| |
| String *ivar = NewStringf("_swig_i_%d", i); |
| |
| // This is an ordinary call from Go to C++, so adjust using |
| // the goin typemap. |
| String *goin = goGetattr(p, "tmap:goin"); |
| if (goin == NULL) { |
| Printv(f_go_wrappers, "\t", ivar, " := ", NULL); |
| bool need_close = false; |
| if (goTypeIsInterface(p, pt)) { |
| Printv(f_go_wrappers, "getSwigcptr(", NULL); |
| need_close = true; |
| } |
| Printv(f_go_wrappers, ln, NULL); |
| if (need_close) { |
| Printv(f_go_wrappers, ")", NULL); |
| } |
| Printv(f_go_wrappers, "\n", NULL); |
| } else { |
| String *itm = goImType(p, pt); |
| Printv(f_go_wrappers, "\tvar ", ivar, " ", itm, "\n", NULL); |
| goin = Copy(goin); |
| Replaceall(goin, "$input", ln); |
| Replaceall(goin, "$result", ivar); |
| Printv(f_go_wrappers, goin, "\n", NULL); |
| Delete(goin); |
| } |
| |
| Setattr(p, "emit:goinput", ivar); |
| |
| bool c_struct_type; |
| String *ct = cgoTypeForGoValue(p, pt, &c_struct_type); |
| if (c_struct_type) { |
| Printv(call, "*(*C.", ct, ")(unsafe.Pointer(&", ivar, "))", NULL); |
| } else { |
| Printv(call, "C.", ct, "(", ivar, ")", NULL); |
| } |
| |
| p = nextParm(p); |
| } |
| |
| Printv(call, ")", NULL); |
| |
| if (wt) { |
| // Close the type conversion to the wrapper type. |
| Printv(call, ")", NULL); |
| } |
| if (SwigType_type(result) != T_VOID && !memcpy_ret) { |
| // Close the type conversion of the return value. |
| Printv(call, ")", NULL); |
| } |
| |
| Printv(call, "\n", NULL); |
| |
| Printv(f_go_wrappers, call, NULL); |
| Delete(call); |
| |
| if (memcpy_ret) { |
| Printv(f_go_wrappers, "\tswig_r = *(*", ret_type, ")(unsafe.Pointer(&swig_r_p))\n", NULL); |
| } |
| |
| goargout(parms); |
| |
| if (SwigType_type(result) != T_VOID) { |
| if (goout == NULL) { |
| Printv(f_go_wrappers, "\treturn swig_r\n", NULL); |
| } else { |
| String *tm = goType(n, result); |
| Printv(f_go_wrappers, "\tvar swig_r_1 ", tm, "\n", NULL); |
| Replaceall(goout, "$input", "swig_r"); |
| Replaceall(goout, "$result", "swig_r_1"); |
| Printv(f_go_wrappers, goout, "\n", NULL); |
| Printv(f_go_wrappers, "\treturn swig_r_1\n", NULL); |
| } |
| } |
| |
| if (ret_type) { |
| Delete(ret_type); |
| } |
| if (wt) { |
| Delete(wt); |
| } |
| } |
| |
| Printv(f_go_wrappers, "}\n\n", NULL); |
| |
| if (!GetFlag(n, "abstract")) { |
| // Define a function that uses the Go director type that other |
| // methods in the Go type can call to get parent methods. |
| |
| Printv(f_go_wrappers, "func Director", cn, go_with_over_name, "(swig_p ", cn, NULL); |
| |
| p = parms; |
| for (int i = 0; i < parm_count; ++i) { |
| p = getParm(p); |
| Printv(f_go_wrappers, ", ", Getattr(p, "lname"), " ", NULL); |
| String *tm = goType(p, Getattr(p, "type")); |
| Printv(f_go_wrappers, tm, NULL); |
| Delete(tm); |
| p = nextParm(p); |
| } |
| |
| Printv(f_go_wrappers, ")", NULL); |
| |
| if (SwigType_type(result) != T_VOID) { |
| String *tm = goType(n, result); |
| Printv(f_go_wrappers, " ", tm, NULL); |
| Delete(tm); |
| } |
| |
| Printv(f_go_wrappers, " {\n", NULL); |
| |
| String *ret_type = NULL; |
| bool memcpy_ret = false; |
| String *wt = NULL; |
| String *goout = NULL; |
| if (SwigType_type(result) != T_VOID) { |
| ret_type = goImType(n, result); |
| Printv(f_go_wrappers, "\tvar swig_r ", ret_type, "\n", NULL); |
| goout = goTypemapLookup("goout", n, "swig_r"); |
| |
| bool c_struct_type; |
| Delete(cgoTypeForGoValue(n, result, &c_struct_type)); |
| if (c_struct_type) { |
| memcpy_ret = true; |
| } |
| } |
| |
| String *call = NewString(""); |
| |
| Printv(call, "\t", NULL); |
| if (SwigType_type(result) != T_VOID) { |
| if (memcpy_ret) { |
| Printv(call, "swig_r_p := ", NULL); |
| } else { |
| Printv(call, "swig_r = (", ret_type, ")(", NULL); |
| } |
| if (goTypeIsInterface(n, result)) { |
| wt = goWrapperType(n, result, true); |
| Printv(call, "(", wt, ")(", NULL); |
| } |
| } |
| |
| Printv(call, "C.", upcall_wname, "(C.uintptr_t(swig_p.(*", |
| director_struct_name, ").", go_type_name, ")", NULL); |
| |
| p = parms; |
| for (int i = 0; i < parm_count; ++i) { |
| Printv(call, ", ", NULL); |
| p = getParm(p); |
| SwigType *pt = Getattr(p, "type"); |
| |
| String *ivar = NewStringf("_swig_i_%d", i); |
| |
| String *ln = Copy(Getattr(p, "lname")); |
| |
| String *goin = goGetattr(p, "tmap:goin"); |
| if (goin == NULL) { |
| Printv(f_go_wrappers, "\t", ivar, " := ", NULL); |
| bool need_close = false; |
| if (goTypeIsInterface(p, pt)) { |
| Printv(f_go_wrappers, "getSwigcptr(", NULL); |
| need_close = true; |
| } |
| Printv(f_go_wrappers, ln, NULL); |
| if (need_close) { |
| Printv(f_go_wrappers, ")", NULL); |
| } |
| Printv(f_go_wrappers, "\n", NULL); |
| } else { |
| String *itm = goImType(p, pt); |
| Printv(f_go_wrappers, "\tvar ", ivar, " ", itm, "\n", NULL); |
| goin = Copy(goin); |
| Replaceall(goin, "$input", ln); |
| Replaceall(goin, "$result", ivar); |
| Printv(f_go_wrappers, goin, "\n", NULL); |
| Delete(goin); |
| } |
| |
| Setattr(p, "emit:goinput", ivar); |
| |
| bool c_struct_type; |
| String *ct = cgoTypeForGoValue(p, pt, &c_struct_type); |
| if (c_struct_type) { |
| Printv(call, "*(*C.", ct, ")(unsafe.Pointer(&", ivar, "))", NULL); |
| } else { |
| Printv(call, "C.", ct, "(", ivar, ")", NULL); |
| } |
| |
| Delete(ln); |
| |
| p = nextParm(p); |
| } |
| |
| Printv(call, ")", NULL); |
| |
| if (wt) { |
| // Close the type conversion to the wrapper type. |
| Printv(call, ")", NULL); |
| } |
| if (SwigType_type(result) != T_VOID && !memcpy_ret) { |
| // Close the type conversion of the return value. |
| Printv(call, ")", NULL); |
| } |
| |
| Printv(call, "\n", NULL); |
| |
| Printv(f_go_wrappers, call, NULL); |
| Delete(call); |
| |
| if (memcpy_ret) { |
| Printv(f_go_wrappers, "\tswig_r = *(*", ret_type, ")(unsafe.Pointer(&swig_r_p))\n", NULL); |
| } |
| |
| goargout(parms); |
| |
| if (SwigType_type(result) != T_VOID) { |
| if (goout == NULL) { |
| Printv(f_go_wrappers, "\treturn swig_r\n", NULL); |
| } else { |
| String *tm = goType(n, result); |
| Printv(f_go_wrappers, "\tvar swig_r_1 ", tm, "\n", NULL); |
| Replaceall(goout, "$input", "swig_r"); |
| Replaceall(goout, "$result", "swig_r_1"); |
| Printv(f_go_wrappers, goout, "\n", NULL); |
| Printv(f_go_wrappers, "\treturn swig_r_1\n", NULL); |
| } |
| } |
| |
| Printv(f_go_wrappers, "}\n\n", NULL); |
| |
| if (ret_type) { |
| Delete(ret_type); |
| } |
| if (wt) { |
| Delete(wt); |
| } |
| |
| // Define a method in the C++ director class that the C++ |
| // upcall function can call. This permits an upcall to a |
| // protected method. |
| |
| String *upcall_method_name = NewString("_swig_upcall_"); |
| Append(upcall_method_name, name); |
| if (overname) { |
| Append(upcall_method_name, overname); |
| } |
| SwigType *rtype = Getattr(n, "classDirectorMethods:type"); |
| String *upcall_decl = Swig_method_decl(rtype, Getattr(n, "decl"), upcall_method_name, parms, 0); |
| Printv(f_c_directors_h, " ", upcall_decl, " {\n", NULL); |
| Delete(upcall_decl); |
| |
| Printv(f_c_directors_h, " ", NULL); |
| if (SwigType_type(result) != T_VOID) { |
| Printv(f_c_directors_h, "return ", NULL); |
| } |
| |
| String *super_call = Swig_method_call(super, parms); |
| Printv(f_c_directors_h, super_call, ";\n", NULL); |
| Delete(super_call); |
| |
| Printv(f_c_directors_h, " }\n", NULL); |
| |
| // Define the C++ function that the Go function calls. |
| |
| SwigType *first_type = NULL; |
| Parm *first_parm = parms; |
| if (!is_static) { |
| first_type = NewString("SwigDirector_"); |
| Append(first_type, class_name); |
| SwigType_add_pointer(first_type); |
| first_parm = NewParm(first_type, "p", n); |
| set_nextSibling(first_parm, parms); |
| } |
| |
| Swig_save("classDirectorMethod", n, "wrap:name", "wrap:action", NULL); |
| |
| Setattr(n, "wrap:name", upcall_wname); |
| |
| String *action = NewString(""); |
| if (SwigType_type(result) != T_VOID) { |
| Printv(action, Swig_cresult_name(), " = (", SwigType_lstr(result, 0), ")", NULL); |
| if (SwigType_isreference(result)) { |
| Printv(action, "&", NULL); |
| } |
| } |
| Printv(action, Swig_cparm_name(NULL, 0), "->", upcall_method_name, "(", NULL); |
| |
| p = parms; |
| int i = 0; |
| while (p != NULL) { |
| if (SwigType_type(Getattr(p, "type")) != T_VOID) { |
| String *pname = Swig_cparm_name(NULL, i + 1); |
| if (i > 0) { |
| Printv(action, ", ", NULL); |
| } |
| |
| // A parameter whose type is a reference is converted into a |
| // pointer type by gcCTypeForGoValue. We are calling a |
| // function which expects a reference so we need to convert |
| // back. |
| if (SwigType_isreference(Getattr(p, "type"))) { |
| Printv(action, "*", NULL); |
| } |
| |
| Printv(action, pname, NULL); |
| Delete(pname); |
| i++; |
| } |
| p = nextSibling(p); |
| } |
| Printv(action, ");", NULL); |
| Setattr(n, "wrap:action", action); |
| |
| cgoWrapperInfo info; |
| |
| info.n = n; |
| info.go_name = go_name; |
| info.overname = overname; |
| info.wname = upcall_wname; |
| info.base = NULL; |
| info.parms = first_parm; |
| info.result = result; |
| info.is_static = is_static; |
| info.receiver = NULL; |
| info.is_constructor = false; |
| info.is_destructor = false; |
| |
| int r = cgoGccWrapper(&info); |
| if (r != SWIG_OK) { |
| return r; |
| } |
| |
| Delete(first_type); |
| if (first_parm != parms) { |
| Delete(first_parm); |
| } |
| |
| Swig_restore(n); |
| Delete(upcall_method_name); |
| } |
| |
| // The Go function which invokes the method. This is called by |
| // the C++ method on the director class. |
| |
| Printv(f_go_wrappers, "//export ", callback_name, "\n", |
| "func ", callback_name, "(swig_c int", NULL); |
| |
| p = parms; |
| for (int i = 0; i < parm_count; ++i) { |
| p = getParm(p); |
| String *tm = goWrapperType(p, Getattr(p, "type"), false); |
| Printv(f_go_wrappers, ", ", Getattr(p, "lname"), " ", tm, NULL); |
| Delete(tm); |
| p = nextParm(p); |
| } |
| |
| Printv(f_go_wrappers, ") ", NULL); |
| String *result_wrapper = NULL; |
| if (SwigType_type(result) != T_VOID) { |
| result_wrapper = goWrapperType(n, result, true); |
| Printv(f_go_wrappers, "(swig_result ", result_wrapper, ") ", NULL); |
| } |
| Printv(f_go_wrappers, "{\n", NULL); |
| |
| if (is_ignored) { |
| Printv(f_go_wrappers, "\treturn\n", NULL); |
| } else { |
| bool result_is_interface = false; |
| String *goout = NULL; |
| if (SwigType_type(result) != T_VOID) { |
| result_is_interface = goTypeIsInterface(NULL, result); |
| Printv(f_go_wrappers, "\tvar swig_r ", NULL); |
| if (!result_is_interface) { |
| Printv(f_go_wrappers, goType(n, result), NULL); |
| } else { |
| Printv(f_go_wrappers, result_wrapper, NULL); |
| } |
| Printv(f_go_wrappers, "\n", NULL); |
| goout = goTypemapLookup("godirectorout", n, "swig_r"); |
| } |
| |
| String *call = NewString(""); |
| Printv(call, "\t", NULL); |
| |
| if (SwigType_type(result) != T_VOID) { |
| Printv(call, "swig_r = ", NULL); |
| if (result_is_interface) { |
| Printv(call, result_wrapper, "(getSwigcptr(", NULL); |
| } |
| } |
| Printv(call, "swig_p.", go_with_over_name, "(", NULL); |
| |
| String *goincode = NewString(""); |
| |
| p = parms; |
| for (int i = 0; i < parm_count; ++i) { |
| p = getParm(p); |
| if (i > 0) { |
| Printv(call, ", ", NULL); |
| } |
| SwigType *pt = Getattr(p, "type"); |
| |
| String *ln = NewString(""); |
| |
| // If the Go representation is an interface type class, then |
| // we are receiving a uintptr, and must convert to the |
| // interface. |
| bool is_interface = goTypeIsInterface(p, pt); |
| if (is_interface) { |
| // Passing is_result as true to goWrapperType gives us the |
| // name of the Go type we need to convert to an interface. |
| String *wt = goWrapperType(p, pt, true); |
| Printv(ln, wt, "(", NULL); |
| Delete(wt); |
| } |
| |
| Printv(ln, Getattr(p, "lname"), NULL); |
| |
| if (is_interface) { |
| Printv(ln, ")", NULL); |
| } |
| |
| String *goin = goGetattr(p, "tmap:godirectorin"); |
| if (goin == NULL) { |
| Printv(call, ln, NULL); |
| } else { |
| String *ivar = NewString(""); |
| Printf(ivar, "_swig_i_%d", i); |
| String *itm = goType(p, pt); |
| Printv(f_go_wrappers, "\tvar ", ivar, " ", itm, "\n", NULL); |
| goin = Copy(goin); |
| Replaceall(goin, "$input", ln); |
| Replaceall(goin, "$result", ivar); |
| Printv(goincode, goin, "\n", NULL); |
| Delete(goin); |
| Printv(call, ivar, NULL); |
| Delete(ivar); |
| } |
| |
| Delete(ln); |
| |
| p = nextParm(p); |
| } |
| |
| Printv(call, ")", NULL); |
| |
| if (result_is_interface) { |
| Printv(call, "))", NULL); |
| } |
| Printv(call, "\n", NULL); |
| |
| Printv(f_go_wrappers, "\tswig_p := swigDirectorLookup(swig_c).(*", director_struct_name, ")\n", NULL); |
| Printv(f_go_wrappers, goincode, NULL); |
| Printv(f_go_wrappers, call, NULL); |
| Delete(call); |
| |
| if (SwigType_type(result) != T_VOID) { |
| if (goout == NULL) { |
| Printv(f_go_wrappers, "\treturn swig_r\n", NULL); |
| } else { |
| String *tm = goImType(n, result); |
| Printv(f_go_wrappers, "\tvar swig_r_1 ", tm, "\n", NULL); |
| Replaceall(goout, "$input", "swig_r"); |
| Replaceall(goout, "$result", "swig_r_1"); |
| Printv(f_go_wrappers, goout, "\n", NULL); |
| Printv(f_go_wrappers, "\treturn swig_r_1\n", NULL); |
| } |
| } |
| } |
| |
| Printv(f_go_wrappers, "}\n\n", NULL); |
| |
| Delete(result_wrapper); |
| |
| Delete(upcall_wname); |
| Delete(upcall_gc_name); |
| Delete(go_with_over_name); |
| } |
| |
| if (!is_ignored || is_pure_virtual) { |
| // Declare the method for the director class. |
| |
| SwigType *rtype = Getattr(n, "conversion_operator") ? 0 : Getattr(n, "classDirectorMethods:type"); |
| String *decl = Swig_method_decl(rtype, Getattr(n, "decl"), Getattr(n, "name"), parms, 0); |
| Printv(f_c_directors_h, " virtual ", decl, NULL); |
| Delete(decl); |
| |
| String *qname = NewString(""); |
| Printv(qname, "SwigDirector_", class_name, "::", Getattr(n, "name"), NULL); |
| decl = Swig_method_decl(rtype, Getattr(n, "decl"), qname, parms, 0); |
| Printv(w->def, decl, NULL); |
| Delete(decl); |
| Delete(qname); |
| |
| String *throws = buildThrow(n); |
| if (throws) { |
| Printv(f_c_directors_h, " ", throws, NULL); |
| Printv(w->def, " ", throws, NULL); |
| Delete(throws); |
| } |
| |
| Printv(f_c_directors_h, ";\n", NULL); |
| |
| Printv(w->def, " {\n", NULL); |
| |
| if (SwigType_type(result) != T_VOID) { |
| if (!SwigType_isclass(result)) { |
| if (!(SwigType_ispointer(result) || SwigType_isreference(result))) { |
| String *construct_result = NewStringf("= SwigValueInit< %s >()", SwigType_lstr(result, 0)); |
| Wrapper_add_localv(w, "c_result", SwigType_lstr(result, "c_result"), construct_result, NIL); |
| Delete(construct_result); |
| } else { |
| Wrapper_add_localv(w, "c_result", SwigType_lstr(result, "c_result"), "= 0", NIL); |
| } |
| } else { |
| String *cres = SwigType_lstr(result, "c_result"); |
| Printf(w->code, "%s;\n", cres); |
| Delete(cres); |
| } |
| } |
| |
| if (!is_ignored) { |
| makeDirectorMethodWrapper(n, w, callback_name); |
| } else { |
| assert(is_pure_virtual); |
| Printv(w->code, " _swig_gopanic(\"call to pure virtual function ", Getattr(parent, "sym:name"), name, "\");\n", NULL); |
| if (SwigType_type(result) != T_VOID) { |
| String *retstr = SwigType_rcaststr(result, "c_result"); |
| Printv(w->code, " return ", retstr, ";\n", NULL); |
| Delete(retstr); |
| } |
| } |
| |
| Printv(w->code, "}", NULL); |
| |
| Replaceall(w->code, "$symname", symname); |
| Wrapper_print(w, f_c_directors); |
| } |
| |
| Delete(cn); |
| Delete(go_type_name); |
| Delete(director_struct_name); |
| Delete(interface_name); |
| Delete(callback_name); |
| Delete(upcall_name); |
| Delete(go_name); |
| DelWrapper(w); |
| |
| return SWIG_OK; |
| } |
| |
| /* ------------------------------------------------------------ |
| * makeDirectorMethodWrapper |
| * |
| * Emit the function wrapper for a director method. |
| * ------------------------------------------------------------ */ |
| void makeDirectorMethodWrapper(Node *n, Wrapper *w, String *callback_name) { |
| ParmList *parms = Getattr(n, "wrap:parms"); |
| SwigType *result = Getattr(n, "type"); |
| |
| Printv(f_c_directors, "extern \"C\" ", NULL); |
| |
| String *fnname = Copy(callback_name); |
| Append(fnname, "(int"); |
| |
| Parm *p = parms; |
| while (p) { |
| while (checkAttribute(p, "tmap:directorin:numinputs", "0")) { |
| p = Getattr(p, "tmap:directorin:next"); |
| } |
| String *cg = gcCTypeForGoValue(p, Getattr(p, "type"), Getattr(p, "lname")); |
| Printv(fnname, ", ", cg, NULL); |
| Delete(cg); |
| p = Getattr(p, "tmap:directorin:next"); |
| } |
| |
| Printv(fnname, ")", NULL); |
| |
| if (SwigType_type(result) == T_VOID) { |
| Printv(f_c_directors, "void ", fnname, NULL); |
| } else { |
| String *tm = gcCTypeForGoValue(n, result, fnname); |
| Printv(f_c_directors, tm, NULL); |
| Delete(tm); |
| } |
| |
| Delete(fnname); |
| |
| Printv(f_c_directors, ";\n", NULL); |
| |
| if (SwigType_type(result) != T_VOID) { |
| String *r = NewString(Swig_cresult_name()); |
| String *tm = gcCTypeForGoValue(n, result, r); |
| Wrapper_add_local(w, r, tm); |
| Delete(tm); |
| Delete(r); |
| } |
| |
| String *args = NewString(""); |
| |
| p = parms; |
| while (p) { |
| while (checkAttribute(p, "tmap:directorin:numinputs", "0")) { |
| p = Getattr(p, "tmap:directorin:next"); |
| } |
| |
| String *pn = NewString("swig_"); |
| Append(pn, Getattr(p, "lname")); |
| Setattr(p, "emit:directorinput", pn); |
| |
| String *tm = gcCTypeForGoValue(p, Getattr(p, "type"), pn); |
| Wrapper_add_local(w, pn, tm); |
| Delete(tm); |
| |
| tm = Getattr(p, "tmap:directorin"); |
| if (!tm) { |
| Swig_warning(WARN_TYPEMAP_DIRECTORIN_UNDEF, input_file, |
| line_number, "Unable to use type %s as director method argument\n", SwigType_str(Getattr(p, "type"), 0)); |
| } else { |
| tm = Copy(tm); |
| Replaceall(tm, "$input", pn); |
| Replaceall(tm, "$owner", 0); |
| Printv(w->code, " ", tm, "\n", NULL); |
| Delete(tm); |
| |
| Printv(args, ", ", pn, NULL); |
| } |
| |
| p = Getattr(p, "tmap:directorin:next"); |
| } |
| |
| Printv(w->code, " ", NULL); |
| if (SwigType_type(result) != T_VOID) { |
| Printv(w->code, Swig_cresult_name(), " = ", NULL); |
| } |
| Printv(w->code, callback_name, "(go_val", args, ");\n", NULL); |
| |
| /* Marshal outputs */ |
| for (p = parms; p; ) { |
| String *tm; |
| if ((tm = Getattr(p, "tmap:directorargout"))) { |
| tm = Copy(tm); |
| Replaceall(tm, "$result", "jresult"); |
| Replaceall(tm, "$input", Getattr(p, "emit:directorinput")); |
| Printv(w->code, tm, "\n", NULL); |
| Delete(tm); |
| p = Getattr(p, "tmap:directorargout:next"); |
| } else { |
| p = nextSibling(p); |
| } |
| } |
| |
| if (SwigType_type(result) != T_VOID) { |
| String *result_str = NewString("c_result"); |
| String *tm = Swig_typemap_lookup("directorout", n, result_str, NULL); |
| if (!tm) { |
| Swig_warning(WARN_TYPEMAP_DIRECTOROUT_UNDEF, input_file, line_number, |
| "Unable to use type %s as director method result\n", SwigType_str(result, 0)); |
| } else { |
| tm = Copy(tm); |
| Replaceall(tm, "$input", Swig_cresult_name()); |
| Replaceall(tm, "$result", "c_result"); |
| Printv(w->code, " ", tm, "\n", NULL); |
| String *retstr = SwigType_rcaststr(result, "c_result"); |
| Printv(w->code, " return ", retstr, ";\n", NULL); |
| Delete(retstr); |
| Delete(tm); |
| } |
| Delete(result_str); |
| } |
| } |
| |
| |
| /* ------------------------------------------------------------ |
| * classDirectorEnd |
| * |
| * Complete support for a director class. |
| * ------------------------------------------------------------ */ |
| |
| int classDirectorEnd(Node *n) { |
| (void) n; |
| |
| Printv(f_c_directors_h, " private:\n", NULL); |
| Printv(f_c_directors_h, " intgo go_val;\n", NULL); |
| Printv(f_c_directors_h, " Swig_memory *swig_mem;\n", NULL); |
| Printv(f_c_directors_h, "};\n\n", NULL); |
| |
| class_name = NULL; |
| class_node = NULL; |
| |
| Delete(class_receiver); |
| class_receiver = NULL; |
| |
| Delete(class_methods); |
| class_methods = NULL; |
| |
| return SWIG_OK; |
| } |
| |
| /* ------------------------------------------------------------ |
| * classDirectorDisown |
| * |
| * I think Go does not require a disown method. |
| * ------------------------------------------------------------ */ |
| |
| int classDirectorDisown(Node *n) { |
| (void) n; |
| return SWIG_OK; |
| } |
| |
| /*---------------------------------------------------------------------- |
| * buildThrow() |
| * |
| * Build and return a throw clause if needed. |
| *--------------------------------------------------------------------*/ |
| |
| String *buildThrow(Node *n) { |
| if (Getattr(n, "noexcept")) |
| return NewString("noexcept"); |
| ParmList *throw_parm_list = Getattr(n, "throws"); |
| if (!throw_parm_list && !Getattr(n, "throw")) |
| return NULL; |
| String *ret = NewString("throw("); |
| if (throw_parm_list) { |
| Swig_typemap_attach_parms("throws", throw_parm_list, NULL); |
| } |
| bool first = true; |
| for (Parm *p = throw_parm_list; p; p = nextSibling(p)) { |
| if (Getattr(p, "tmap:throws")) { |
| if (first) { |
| first = false; |
| } else { |
| Printv(ret, ", ", NULL); |
| } |
| String *s = SwigType_str(Getattr(p, "type"), 0); |
| Printv(ret, s, NULL); |
| Delete(s); |
| } |
| } |
| Printv(ret, ")", NULL); |
| return ret; |
| } |
| |
| /*---------------------------------------------------------------------- |
| * extraDirectorProtectedCPPMethodsRequired() |
| * |
| * We don't need to check upcall when calling methods. |
| *--------------------------------------------------------------------*/ |
| |
| bool extraDirectorProtectedCPPMethodsRequired() const { |
| return false; |
| } |
| |
| /*---------------------------------------------------------------------- |
| * makeDispatchFunction |
| * |
| * Make a dispatch function for an overloaded C++ function. The |
| * receiver parameter is the receiver for a method, unless is_upcall |
| * is true. If is_upcall is true, then the receiver parameter is |
| * the type of the first argument to the function. |
| *--------------------------------------------------------------------*/ |
| |
| int makeDispatchFunction(Node *n, String *go_name, String *receiver, bool is_static, SwigType *director_struct, bool is_upcall) { |
| bool is_director = director_struct ? true : false; |
| |
| String *nodetype = Getattr(n, "nodeType"); |
| bool is_constructor = Cmp(nodetype, "constructor") == 0; |
| bool is_destructor = Cmp(nodetype, "destructor") == 0; |
| |
| bool can_use_receiver = (!is_constructor && !is_destructor && !is_upcall); |
| |
| bool use_receiver = (!is_static && can_use_receiver); |
| |
| bool add_to_interface = (interfaces && !is_constructor && !is_destructor && !is_static && !is_upcall); |
| |
| List *dispatch = Swig_overload_rank(n, false); |
| int nfunc = Len(dispatch); |
| |
| SwigType *all_result; |
| bool mismatch; |
| if (is_constructor) { |
| assert(!is_upcall); |
| if (!is_director) { |
| all_result = Copy(Getattr(class_node, "classtypeobj")); |
| } else { |
| all_result = Copy(director_struct); |
| } |
| mismatch = false; |
| } else { |
| all_result = NULL; |
| mismatch = false; |
| bool any_void = false; |
| for (int i = 0; i < nfunc; ++i) { |
| Node *nn = Getitem(dispatch, i); |
| Node *ni = Getattr(nn, "directorNode") ? Getattr(nn, "directorNode") : nn; |
| SwigType *result = Getattr(ni, "go:type"); |
| assert(result); |
| |
| if (SwigType_type(result) == T_VOID) { |
| if (all_result) { |
| mismatch = true; |
| } |
| any_void = true; |
| } else { |
| if (any_void) { |
| mismatch = true; |
| } else if (!all_result) { |
| all_result = Copy(result); |
| } else if (Cmp(result, all_result) != 0) { |
| mismatch = true; |
| } |
| } |
| } |
| if (mismatch) { |
| Delete(all_result); |
| all_result = NULL; |
| } else if (all_result) { |
| ; |
| } else { |
| all_result = NewString("void"); |
| } |
| } |
| |
| Printv(f_go_wrappers, "func ", NULL); |
| |
| if (receiver && use_receiver) { |
| Printv(f_go_wrappers, "(p ", receiver, ") ", NULL); |
| } |
| |
| Printv(f_go_wrappers, go_name, "(", NULL); |
| if (is_director && is_constructor) { |
| Printv(f_go_wrappers, "abi interface{}, ", NULL); |
| assert(!add_to_interface); |
| } |
| if (is_upcall) { |
| Printv(f_go_wrappers, "p *", receiver, ", ", NULL); |
| assert(!add_to_interface); |
| } |
| Printv(f_go_wrappers, "a ...interface{})", NULL); |
| |
| if (add_to_interface) { |
| Printv(interfaces, "\t", go_name, "(a ...interface{})", NULL); |
| } |
| |
| if (mismatch) { |
| Printv(f_go_wrappers, " interface{}", NULL); |
| if (add_to_interface) { |
| Printv(interfaces, " interface{}", NULL); |
| } |
| } else if (all_result && SwigType_type(all_result) != T_VOID) { |
| if (is_director && is_constructor) { |
| Printv(f_go_wrappers, " ", receiver, NULL); |
| if (add_to_interface) { |
| Printv(interfaces, " ", receiver, NULL); |
| } |
| } else { |
| String *tm = goType(n, all_result); |
| Printv(f_go_wrappers, " ", tm, NULL); |
| if (add_to_interface) { |
| Printv(interfaces, " ", tm, NULL); |
| } |
| Delete(tm); |
| } |
| } |
| Printv(f_go_wrappers, " {\n", NULL); |
| if (add_to_interface) { |
| Printv(interfaces, "\n", NULL); |
| } |
| |
| Printv(f_go_wrappers, "\targc := len(a)\n", NULL); |
| |
| for (int i = 0; i < nfunc; ++i) { |
| int fn = 0; |
| Node *nn = Getitem(dispatch, i); |
| Node *ni = Getattr(nn, "directorNode") ? Getattr(nn, "directorNode") : nn; |
| Parm *pi = Getattr(ni, "wrap:parms"); |
| |
| // If we are using a receiver, we want to ignore a leading self |
| // parameter. Because of the way this is called, there may or |
| // may not be a self parameter at this point. |
| if (use_receiver && pi && Getattr(pi, "self")) { |
| pi = getParm(pi); |
| if (pi) { |
| pi = nextParm(pi); |
| } |
| } |
| |
| int num_required = emit_num_required(pi); |
| int num_arguments = emit_num_arguments(pi); |
| bool varargs = emit_isvarargs(pi) ? true : false; |
| |
| if (varargs) { |
| Printf(f_go_wrappers, "\tif argc >= %d {\n", num_required); |
| } else { |
| if (num_required == num_arguments) { |
| Printf(f_go_wrappers, "\tif argc == %d {\n", num_required); |
| } else { |
| Printf(f_go_wrappers, "\tif argc >= %d && argc <= %d {\n", num_required, num_arguments); |
| } |
| } |
| |
| // Build list of collisions with the same number of arguments. |
| List *coll = NewList(); |
| for (int k = i + 1; k < nfunc; ++k) { |
| Node *nnk = Getitem(dispatch, k); |
| Node *nk = Getattr(nnk, "directorNode") ? Getattr(nnk, "directorNode") : nnk; |
| Parm *pk = Getattr(nk, "wrap:parms"); |
| if (use_receiver && pk && Getattr(pk, "self")) { |
| pk = getParm(pk); |
| if (pk) { |
| pk = nextParm(pk); |
| } |
| } |
| int nrk = emit_num_required(pk); |
| int nak = emit_num_arguments(pk); |
| if ((nrk >= num_required && nrk <= num_arguments) |
| || (nak >= num_required && nak <= num_arguments) |
| || (nrk <= num_required && nak >= num_arguments) |
| || (varargs && nrk >= num_required)) { |
| Append(coll, nk); |
| } |
| } |
| |
| int num_braces = 0; |
| if (Len(coll) > 0 && num_arguments > 0) { |
| int j = 0; |
| Parm *pj = pi; |
| while (pj) { |
| pj = getParm(pj); |
| if (!pj) { |
| break; |
| } |
| |
| // If all the overloads have the same type in this position, |
| // we can omit the check. |
| SwigType *tm = goOverloadType(pj, Getattr(pj, "type")); |
| bool emitcheck = false; |
| for (int k = 0; k < Len(coll) && !emitcheck; ++k) { |
| Node *nk = Getitem(coll, k); |
| Parm *pk = Getattr(nk, "wrap:parms"); |
| if (use_receiver && pk && Getattr(pk, "self")) { |
| pk = getParm(pk); |
| if (pk) { |
| pk = nextParm(pk); |
| } |
| } |
| int nak = emit_num_arguments(pk); |
| if (nak <= j) |
| continue; |
| int l = 0; |
| Parm *pl = pk; |
| while (pl && l <= j) { |
| pl = getParm(pl); |
| if (!pl) { |
| break; |
| } |
| if (l == j) { |
| SwigType *tml = goOverloadType(pl, Getattr(pl, "type")); |
| if (Cmp(tm, tml) != 0) { |
| emitcheck = true; |
| } |
| Delete(tml); |
| } |
| pl = nextParm(pl); |
| ++l; |
| } |
| } |
| |
| if (emitcheck) { |
| if (j >= num_required) { |
| Printf(f_go_wrappers, "\t\tif argc > %d {\n", j); |
| ++num_braces; |
| } |
| |
| fn = i + 1; |
| Printf(f_go_wrappers, "\t\tif _, ok := a[%d].(%s); !ok {\n", j, tm); |
| Printf(f_go_wrappers, "\t\t\tgoto check_%d\n", fn); |
| Printv(f_go_wrappers, "\t\t}\n", NULL); |
| } |
| |
| Delete(tm); |
| |
| pj = nextParm(pj); |
| |
| ++j; |
| } |
| } |
| |
| for (; num_braces > 0; --num_braces) { |
| Printv(f_go_wrappers, "\t\t}\n", NULL); |
| } |
| |
| // We may need to generate multiple calls if there are variable |
| // argument lists involved. Build the start of the call. |
| |
| String *start = NewString(""); |
| |
| SwigType *result = Getattr(ni, "go:type"); |
| |
| if (is_constructor) { |
| result = all_result; |
| } else if (is_destructor) { |
| result = NULL; |
| } |
| |
| if (result && SwigType_type(result) != T_VOID && (!all_result || SwigType_type(all_result) != T_VOID)) { |
| Printv(start, "return ", NULL); |
| } |
| |
| bool advance_parm = false; |
| |
| if (receiver && use_receiver) { |
| Printv(start, "p.", go_name, NULL); |
| } else if (can_use_receiver && !isStatic(ni) && pi && Getattr(pi, "self")) { |
| // This is an overload of a static function and a non-static |
| // function. |
| assert(num_required > 0); |
| SwigType *tm = goWrapperType(pi, Getattr(pi, "type"), true); |
| String *nm = buildGoName(Getattr(ni, "sym:name"), false, isFriend(ni)); |
| Printv(start, "a[0].(", tm, ").", nm, NULL); |
| Delete(nm); |
| Delete(tm); |
| advance_parm = true; |
| } else { |
| Printv(start, go_name, NULL); |
| } |
| |
| Printv(start, Getattr(ni, "sym:overname"), "(", NULL); |
| |
| bool need_comma = false; |
| |
| if (is_director && is_constructor) { |
| Printv(start, "abi", NULL); |
| need_comma = true; |
| } |
| if (is_upcall) { |
| Printv(start, "p", NULL); |
| need_comma = true; |
| } |
| Parm *p = pi; |
| int pn = 0; |
| if (advance_parm) { |
| p = getParm(p); |
| if (p) { |
| p = nextParm(p); |
| } |
| ++pn; |
| } |
| while (pn < num_required) { |
| p = getParm(p); |
| |
| if (need_comma) { |
| Printv(start, ", ", NULL); |
| } |
| |
| SwigType *tm = goType(p, Getattr(p, "type")); |
| Printf(start, "a[%d].(%s)", pn, tm); |
| Delete(tm); |
| |
| need_comma = true; |
| ++pn; |
| p = nextParm(p); |
| } |
| |
| String *end = NULL; |
| if (!result || SwigType_type(result) == T_VOID || (all_result && SwigType_type(all_result) == T_VOID)) { |
| end = NewString(""); |
| Printv(end, "return", NULL); |
| if (!all_result || SwigType_type(all_result) != T_VOID) { |
| Printv(end, " 0", NULL); |
| } |
| } |
| |
| if (num_required == num_arguments) { |
| Printv(f_go_wrappers, "\t\t", start, ")\n", NULL); |
| if (end) { |
| Printv(f_go_wrappers, "\t\t", end, "\n", NULL); |
| } |
| } else { |
| Printv(f_go_wrappers, "\t\tswitch argc {\n", NULL); |
| for (int j = num_required; j <= num_arguments; ++j) { |
| Printf(f_go_wrappers, "\t\tcase %d:\n", j); |
| Printv(f_go_wrappers, "\t\t\t", start, NULL); |
| bool nc = need_comma; |
| for (int k = num_required; k < j; ++k) { |
| if (nc) { |
| Printv(f_go_wrappers, ", ", NULL); |
| } |
| Printf(f_go_wrappers, "a[%d]", k); |
| nc = true; |
| } |
| Printv(f_go_wrappers, ")\n", NULL); |
| if (end) { |
| Printv(f_go_wrappers, "\t\t\t", end, "\n", NULL); |
| } |
| } |
| Printv(f_go_wrappers, "\t\t}\n", NULL); |
| } |
| |
| Printv(f_go_wrappers, "\t}\n", NULL); |
| |
| if (fn != 0) { |
| Printf(f_go_wrappers, "check_%d:\n", fn); |
| } |
| |
| Delete(coll); |
| } |
| |
| Printv(f_go_wrappers, "\tpanic(\"No match for overloaded function call\")\n", NULL); |
| Printv(f_go_wrappers, "}\n\n", NULL); |
| |
| Delete(all_result); |
| Delete(dispatch); |
| |
| return SWIG_OK; |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * checkFunctionVisibility() |
| * |
| * Return true if we should write out a function based on its |
| * visibility, false otherwise. |
| * ---------------------------------------------------------------------- */ |
| |
| bool checkFunctionVisibility(Node *n, Node *parent) { |
| // Write out a public function. |
| if (is_public(n)) |
| return true; |
| // Don't write out a private function. |
| if (is_private(n)) |
| return false; |
| // Write a protected function for a director class in |
| // dirprot_mode. |
| if (parent == NULL) { |
| return false; |
| } |
| if (dirprot_mode() && Swig_directorclass(parent)) |
| return true; |
| // Otherwise don't write out a protected function. |
| return false; |
| } |
| |
| |
| /* ---------------------------------------------------------------------- |
| * exportedName() |
| * |
| * Given a C/C++ name, return a name in Go which will be exported. |
| * If the first character is an upper case letter, this returns a |
| * copy of its argument. If the first character is a lower case |
| * letter, this forces it to upper case. Otherwise, this prepends |
| * 'X'. |
| * ---------------------------------------------------------------------- */ |
| |
| String *exportedName(SwigType *name) { |
| SwigType *copy = Copy(name); |
| char c = *Char(copy); |
| if (islower(c)) { |
| char l[2]; |
| char u[2]; |
| l[0] = c; |
| l[1] = '\0'; |
| u[0] = toupper(c); |
| u[1] = '\0'; |
| Replace(copy, l, u, DOH_REPLACE_FIRST); |
| } else if (!isalpha(c)) { |
| char l[2]; |
| char u[3]; |
| l[0] = c; |
| l[1] = '\0'; |
| u[0] = 'X'; |
| u[1] = c; |
| u[2] = '\0'; |
| Replace(copy, l, u, DOH_REPLACE_FIRST); |
| } |
| String *ret = Swig_name_mangle_type(copy); |
| Delete(copy); |
| return ret; |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * removeClassname() |
| * |
| * If the name starts with the current class name, followed by an |
| * underscore, remove it. If there is no current class name, this |
| * simply returns a copy of the name. This undoes Swig's way of |
| * recording the class name in a member name. |
| * ---------------------------------------------------------------------- */ |
| |
| String *removeClassname(String *name) { |
| String *copy = Copy(name); |
| if (class_name) { |
| char *p = Char(name); |
| if (Strncmp(name, class_name, Len(class_name)) == 0 && p[Len(class_name)] == '_') { |
| Replace(copy, class_name, "", DOH_REPLACE_FIRST); |
| Replace(copy, "_", "", DOH_REPLACE_FIRST); |
| } |
| } |
| return copy; |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * buildGoName() |
| * |
| * Build the name to use for an ordinary function, variable, or |
| * whatever in Go. The name argument is something like the sym:name |
| * attribute of the node. If is_static is false, this could be a |
| * method, and the returned name will be the name of the |
| * method--i.e., it will not include the class name. |
| * ---------------------------------------------------------------------- */ |
| |
| String *buildGoName(String *name, bool is_static, bool is_friend) { |
| String *nw = NewString(""); |
| if (is_static && !is_friend && class_name) { |
| String *c1 = exportedName(class_name); |
| Append(nw, c1); |
| Delete(c1); |
| } |
| String *c2 = removeClassname(name); |
| String *c3 = exportedName(c2); |
| Append(nw, c3); |
| Delete(c2); |
| Delete(c3); |
| String *ret = Swig_name_mangle_string(nw); |
| Delete(nw); |
| return ret; |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * buildGoWrapperName() |
| * |
| * Build the name to use for a Go wrapper function. This is a |
| * function called by the real Go function in order to convert C++ |
| * classes from interfaces to pointers, and other such conversions |
| * between the Go type and the C++ type. |
| * ---------------------------------------------------------------------- */ |
| |
| String *buildGoWrapperName(String *name, String *overname) { |
| String *s1 = NewString("_swig_wrap_"); |
| Append(s1, name); |
| String *s2 = Swig_name_mangle_string(s1); |
| Delete(s1); |
| if (overname) { |
| Append(s2, overname); |
| } |
| return s2; |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * checkNameConflict() |
| * |
| * Check for a name conflict on the name we are going to use in Go. |
| * These conflicts are likely because of the enforced |
| * capitalization. When we find one, issue a warning and return |
| * false. If the name is OK, return true. |
| * ---------------------------------------------------------------------- */ |
| |
| bool checkNameConflict(String* name, Node* n, const_String_or_char_ptr scope) { |
| Node *lk = symbolLookup(name, scope); |
| if (lk) { |
| String *n1 = Getattr(n, "sym:name"); |
| if (!n1) { |
| n1 = Getattr(n, "name"); |
| } |
| String *n2 = Getattr(lk, "sym:name"); |
| if (!n2) { |
| n2 = Getattr(lk, "name"); |
| } |
| Swig_warning(WARN_GO_NAME_CONFLICT, input_file, line_number, |
| "Ignoring '%s' due to Go name ('%s') conflict with '%s'\n", |
| n1, name, n2); |
| return false; |
| } |
| bool r = addSymbol(name, n, scope) ? true : false; |
| assert(r); |
| (void)r; |
| return true; |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * checkIgnoredParameters() |
| * |
| * If any of the parameters of this function, or the return type, |
| * are ignored due to a name conflict, give a warning and return |
| * false. |
| * ---------------------------------------------------------------------- */ |
| |
| bool checkIgnoredParameters(Node *n, String *go_name) { |
| ParmList *parms = Getattr(n, "parms"); |
| if (parms) { |
| Wrapper *dummy = NewWrapper(); |
| emit_attach_parmmaps(parms, dummy); |
| int parm_count = emit_num_arguments(parms); |
| Parm *p = parms; |
| |
| for (int i = 0; i < parm_count; ++i) { |
| p = getParm(p); |
| if (!checkIgnoredType(n, go_name, Getattr(p, "type"))) { |
| DelWrapper(dummy); |
| return false; |
| } |
| p = nextParm(p); |
| } |
| |
| DelWrapper(dummy); |
| } |
| |
| if (!checkIgnoredType(n, go_name, Getattr(n, "type"))) { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * checkIgnoredType() |
| * |
| * If this type is being ignored due to a name conflict, give a |
| * warning and return false. |
| * ---------------------------------------------------------------------- */ |
| |
| bool checkIgnoredType(Node *n, String *go_name, SwigType *type) { |
| if (hasGoTypemap(n, type)) { |
| return true; |
| } |
| |
| SwigType *t = SwigType_typedef_resolve_all(type); |
| |
| bool ret = true; |
| bool is_conflict = false; |
| Node *e = Language::enumLookup(t); |
| if (e) { |
| if (GetFlag(e, "go:conflict")) { |
| is_conflict = true; |
| } |
| } else if (SwigType_issimple(t)) { |
| Node *cn = classLookup(t); |
| if (cn) { |
| if (GetFlag(cn, "go:conflict")) { |
| is_conflict = true; |
| } |
| } |
| } else if (SwigType_ispointer(t) || SwigType_isarray(t) || SwigType_isqualifier(t) || SwigType_isreference(t)) { |
| SwigType *r = Copy(t); |
| if (SwigType_ispointer(r)) { |
| SwigType_del_pointer(r); |
| } else if (SwigType_isarray(r)) { |
| SwigType_del_array(r); |
| } else if (SwigType_isqualifier(r)) { |
| SwigType_del_qualifier(r); |
| } else { |
| SwigType_del_reference(r); |
| } |
| |
| if (!checkIgnoredType(n, go_name, r)) { |
| ret = false; |
| } |
| |
| Delete(r); |
| } |
| |
| if (is_conflict) { |
| String *s = SwigType_str(t, NULL); |
| Swig_warning(WARN_GO_NAME_CONFLICT, input_file, line_number, |
| "Ignoring '%s' (Go name '%s') due to Go name conflict for parameter or result type '%s'\n", |
| Getattr(n, "name"), go_name, s); |
| Delete(s); |
| ret = false; |
| } |
| |
| Delete(t); |
| |
| return ret; |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * goType() |
| * |
| * Given a SWIG type, return a string for the type in Go. |
| * ---------------------------------------------------------------------- */ |
| |
| String *goType(Node *n, SwigType *type) { |
| return goTypeWithInfo(n, type, false, NULL); |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * goImType() |
| * |
| * Given a SWIG type, return a string for the intermediate Go type |
| * to pass to C/C++. This is like goType except that it looks for |
| * an imtype typemap entry first. |
| * ---------------------------------------------------------------------- */ |
| |
| String *goImType(Node *n, SwigType *type) { |
| return goTypeWithInfo(n, type, true, NULL); |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * goTypeWithInfo() |
| * |
| * Like goType, but return some more information. |
| * |
| * If use_imtype is true, this look for a imtype typemap entry. |
| * |
| * If the p_is_interface parameter is not NULL, this sets |
| * *p_is_interface to indicate whether this type is going to be |
| * represented by a Go interface type. These are cases where the Go |
| * code needs to make some adjustments when passing values back and |
| * forth with C/C++. |
| * ---------------------------------------------------------------------- */ |
| |
| String *goTypeWithInfo(Node *n, SwigType *type, bool use_imtype, bool *p_is_interface) { |
| if (p_is_interface) { |
| *p_is_interface = false; |
| } |
| |
| String *ret = NULL; |
| if (use_imtype) { |
| if (n && Cmp(type, Getattr(n, "type")) == 0) { |
| if (Strcmp(Getattr(n, "nodeType"), "parm") == 0) { |
| ret = Getattr(n, "tmap:imtype"); |
| } |
| if (!ret) { |
| ret = Swig_typemap_lookup("imtype", n, "", NULL); |
| } |
| } else { |
| Parm *p = NewParm(type, "goImType", n); |
| ret = Swig_typemap_lookup("imtype", p, "", NULL); |
| Delete(p); |
| } |
| } |
| if (!ret) { |
| if (n && Cmp(type, Getattr(n, "type")) == 0) { |
| if (Strcmp(Getattr(n, "nodeType"), "parm") == 0) { |
| ret = Getattr(n, "tmap:gotype"); |
| } |
| if (!ret) { |
| ret = Swig_typemap_lookup("gotype", n, "", NULL); |
| } |
| } else { |
| Parm *p = NewParm(type, "goType", n); |
| ret = Swig_typemap_lookup("gotype", p, "", NULL); |
| Delete(p); |
| } |
| } |
| |
| if (ret && Strstr(ret, "$gotypename") != 0) { |
| ret = NULL; |
| } |
| |
| if (ret) { |
| return Copy(ret); |
| } |
| |
| SwigType *t = SwigType_typedef_resolve_all(type); |
| |
| if (SwigType_isenum(t)) { |
| Node *e = Language::enumLookup(t); |
| if (e) { |
| ret = goEnumName(e); |
| } else if (Strcmp(t, "enum ") == 0) { |
| ret = NewString("int"); |
| } else { |
| // An unknown enum - one that has not been parsed (neither a C enum forward reference nor a definition) or an ignored enum |
| String *tt = Copy(t); |
| Replace(tt, "enum ", "", DOH_REPLACE_ANY); |
| ret = exportedName(tt); |
| Setattr(undefined_enum_types, t, ret); |
| Delete(tt); |
| } |
| } else if (SwigType_isfunctionpointer(t) || SwigType_isfunction(t)) { |
| ret = NewString("_swig_fnptr"); |
| } else if (SwigType_ismemberpointer(t)) { |
| ret = NewString("_swig_memberptr"); |
| } else if (SwigType_issimple(t)) { |
| Node *cn = classLookup(t); |
| if (cn) { |
| ret = Getattr(cn, "sym:name"); |
| if (!ret) { |
| ret = Getattr(cn, "name"); |
| } |
| ret = exportedName(ret); |
| |
| Node *cnmod = Getattr(cn, "module"); |
| if (!cnmod || Strcmp(Getattr(cnmod, "name"), module) == 0) { |
| Setattr(undefined_types, t, t); |
| } else { |
| String *nw = NewString(""); |
| Printv(nw, getModuleName(Getattr(cnmod, "name")), ".", ret, NULL); |
| Delete(ret); |
| ret = nw; |
| } |
| } else { |
| // SWIG does not know about this type. |
| ret = exportedName(t); |
| Setattr(undefined_types, t, t); |
| } |
| if (p_is_interface) { |
| *p_is_interface = true; |
| } |
| } else if (SwigType_ispointer(t) || SwigType_isarray(t)) { |
| SwigType *r = Copy(t); |
| if (SwigType_ispointer(r)) { |
| SwigType_del_pointer(r); |
| } else { |
| SwigType_del_array(r); |
| } |
| |
| if (SwigType_type(r) == T_VOID) { |
| ret = NewString("uintptr"); |
| } else { |
| bool is_interface; |
| String *base = goTypeWithInfo(n, r, false, &is_interface); |
| |
| // At the Go level, an unknown or class type is handled as an |
| // interface wrapping a pointer. This means that if a |
| // function returns the C type X, we will be wrapping the C |
| // type X*. In Go we will call that type X. That means that |
| // if a C function expects X*, we can pass the Go type X. And |
| // that means that when we see the C type X*, we should use |
| // the Go type X. |
| |
| // The is_interface variable tells us this. However, it will |
| // be true both for the case of X and for the case of X*. If |
| // r is a pointer here, then we are looking at X**. There is |
| // really no good way for us to handle that. |
| bool is_pointer_to_pointer = false; |
| if (is_interface) { |
| SwigType *c = Copy(r); |
| if (SwigType_isqualifier(c)) { |
| SwigType_del_qualifier(c); |
| if (SwigType_ispointer(c) || SwigType_isarray(c)) { |
| is_pointer_to_pointer = true; |
| } |
| } |
| Delete(c); |
| } |
| |
| if (is_interface) { |
| if (!is_pointer_to_pointer) { |
| ret = base; |
| if (p_is_interface) { |
| *p_is_interface = true; |
| } |
| } else { |
| ret = NewString("uintptr"); |
| } |
| } else { |
| ret = NewString("*"); |
| Append(ret, base); |
| Delete(base); |
| } |
| } |
| |
| Delete(r); |
| } else if (SwigType_isreference(t)) { |
| SwigType *r = Copy(t); |
| SwigType_del_reference(r); |
| |
| // If this is a const reference, and we are looking at a pointer |
| // to it, then we just use the pointer we already have. |
| bool add_pointer = true; |
| if (SwigType_isqualifier(r)) { |
| String *q = SwigType_parm(r); |
| if (Strcmp(q, "const") == 0) { |
| SwigType *c = Copy(r); |
| SwigType_del_qualifier(c); |
| if (SwigType_ispointer(c)) { |
| add_pointer = false; |
| } |
| Delete(c); |
| } |
| } |
| if (add_pointer) { |
| SwigType_add_pointer(r); |
| } |
| ret = goTypeWithInfo(n, r, false, p_is_interface); |
| Delete(r); |
| } else if (SwigType_isqualifier(t)) { |
| SwigType *r = Copy(t); |
| SwigType_del_qualifier(r); |
| ret = goTypeWithInfo(n, r, false, p_is_interface); |
| Delete(r); |
| } else if (SwigType_isvarargs(t)) { |
| ret = NewString("[]interface{}"); |
| } |
| |
| Delete(t); |
| |
| if (!ret) { |
| Swig_warning(WARN_LANG_NATIVE_UNIMPL, input_file, line_number, "No Go typemap defined for %s\n", SwigType_str(type, 0)); |
| ret = NewString("uintptr"); |
| } |
| |
| return ret; |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * cgoTypeForGoValue() |
| * |
| * Given a SWIG type, return a string for the C type to use for the |
| * cgo wrapper code. This always returns a simple identifier, since |
| * it is used in Go code as C.name. |
| * |
| * This sets *c_struct_type if the C type uses a struct where the Go |
| * type uses a simple type. This is true for strings and slices. |
| * When this is true the Go code has to jump through unsafe hoops to |
| * pass the type checker. |
| * ---------------------------------------------------------------------- */ |
| |
| String *cgoTypeForGoValue(Node *n, SwigType *type, bool *c_struct_type) { |
| *c_struct_type = false; |
| |
| bool is_interface; |
| String *go_type = goTypeWithInfo(n, type, true, &is_interface); |
| if (is_interface) { |
| Delete(go_type); |
| return NewString("uintptr_t"); |
| } |
| if (Strcmp(go_type, "uintptr") == 0) { |
| Delete(go_type); |
| return NewString("uintptr_t"); |
| } |
| if (((char*)Char(go_type))[0] == '*') { |
| // Treat all pointers as void*. There is no meaningful type |
| // checking going on here anyhow, and that lets us avoid |
| // worrying about defining the base type of the pointer. |
| Delete(go_type); |
| return NewString("swig_voidp"); |
| } |
| |
| // Check for some Go types that are really pointers under the covers. |
| bool is_hidden_pointer = Strncmp(go_type, "func(", 5) == 0 || Strncmp(go_type, "map[", 4) == 0 || Strncmp(go_type, "chan ", 5) == 0; |
| |
| Delete(go_type); |
| |
| String *ct = Getattr(n, "emit:cgotype"); |
| if (ct) { |
| *c_struct_type = Getattr(n, "emit:cgotypestruct") ? true : false; |
| return Copy(ct); |
| } |
| |
| String *t = Copy(type); |
| if (SwigType_isarray(t) && Getattr(n, "tmap:gotype") == NULL) { |
| SwigType_del_array(t); |
| SwigType_add_pointer(t); |
| } |
| |
| bool add_typedef = true; |
| |
| static int count; |
| ++count; |
| ct = NewStringf("swig_type_%d", count); |
| |
| String *gct = gcCTypeForGoValue(n, t, ct); |
| Delete(t); |
| |
| if (Strncmp(gct, "_gostring_", 10) == 0 || Strncmp(gct, "_goslice_", 9) == 0) { |
| *c_struct_type = true; |
| Setattr(n, "emit:cgotypestruct", type); |
| } else { |
| char *p = Strstr(gct, ct); |
| if (p != NULL && p > (char*)Char(gct) && p[-1] == '*' && p[Len(ct)] == '\0') { |
| // Treat all pointers as void*. See above. |
| Delete(ct); |
| --count; |
| ct = NewString("swig_voidp"); |
| add_typedef = false; |
| if (is_hidden_pointer) { |
| // A Go type that is really a pointer, like func, map, chan, |
| // is being represented in C by a pointer. This is fine, |
| // but we have to memcpy the type rather than simply |
| // converting it. |
| *c_struct_type = true; |
| Setattr(n, "emit:cgotypestruct", type); |
| } |
| } |
| |
| if (Strncmp(gct, "bool ", 5) == 0) { |
| // Change the C++ type bool to the C type _Bool. |
| Replace(gct, "bool", "_Bool", DOH_REPLACE_FIRST); |
| } |
| if (Strncmp(gct, "intgo ", 6) == 0) { |
| // We #define intgo to swig_intgo for the cgo comment. |
| Replace(gct, "intgo", "swig_intgo", DOH_REPLACE_FIRST); |
| } |
| p = Strstr(gct, ct); |
| if (p != NULL && p > (char*)Char(gct) && p[-1] == ' ' && p[Len(ct)] == '\0') { |
| String *q = NewStringWithSize(gct, Len(gct) - Len(ct) - 1); |
| if (validIdentifier(q)) { |
| // This is a simple type name, and we can use it directly. |
| Delete(ct); |
| --count; |
| ct = q; |
| add_typedef = false; |
| } |
| } |
| } |
| if (add_typedef) { |
| Printv(f_cgo_comment_typedefs, "typedef ", gct, ";\n", NULL); |
| } |
| |
| Setattr(n, "emit:cgotype", ct); |
| |
| Delete(gct); |
| |
| return Copy(ct); |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * goWrapperType() |
| * |
| * Given a type, return a string for the type to use for the wrapped |
| * Go function. This function exists because for a C++ class we |
| * need to convert interface and reference types. |
| * ---------------------------------------------------------------------- */ |
| |
| String *goWrapperType(Node *n, SwigType *type, bool is_result) { |
| bool is_interface; |
| String *ret = goTypeWithInfo(n, type, true, &is_interface); |
| |
| // If this is an interface, we want to pass the real type. |
| if (is_interface) { |
| Delete(ret); |
| if (!is_result) { |
| ret = NewString("uintptr"); |
| } else { |
| SwigType *ty = SwigType_typedef_resolve_all(type); |
| while (true) { |
| if (SwigType_ispointer(ty)) { |
| SwigType_del_pointer(ty); |
| } else if (SwigType_isarray(ty)) { |
| SwigType_del_array(ty); |
| } else if (SwigType_isreference(ty)) { |
| SwigType_del_reference(ty); |
| } else if (SwigType_isqualifier(ty)) { |
| SwigType_del_qualifier(ty); |
| } else { |
| break; |
| } |
| } |
| assert(SwigType_issimple(ty)); |
| String *p = goCPointerType(ty, true); |
| Delete(ty); |
| ret = p; |
| } |
| } |
| |
| return ret; |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * goOverloadType() |
| * |
| * Given a type, return the Go type to use when dispatching of |
| * overloaded functions. This is normally just the usual Go type. |
| * However, for a C++ class, the usual Go type is an interface type. |
| * And if that interface type represents a C++ type that SWIG does |
| * not know about, then the interface type generated for any C++ |
| * class will match that interface. So for that case, we match on |
| * the underlying integer type. |
| * |
| * It has to work this way so that we can handle a derived type of a |
| * %ignore'd type. It's unlikely that anybody will have a value of |
| * an undefined type, but we support it because it worked in the |
| * past. |
| * ---------------------------------------------------------------------- */ |
| |
| String *goOverloadType(Node *n, SwigType *type) { |
| SwigType *ty = SwigType_typedef_resolve_all(type); |
| while (true) { |
| if (SwigType_ispointer(ty)) { |
| SwigType_del_pointer(ty); |
| } else if (SwigType_isarray(ty)) { |
| SwigType_del_array(ty); |
| } else if (SwigType_isreference(ty)) { |
| SwigType_del_reference(ty); |
| } else if (SwigType_isqualifier(ty)) { |
| SwigType_del_qualifier(ty); |
| } else { |
| break; |
| } |
| } |
| |
| String* go_type = goType(n, ty); |
| |
| if (Getattr(undefined_types, ty) && !Getattr(defined_types, go_type)) { |
| Delete(go_type); |
| return goWrapperType(n, type, true); |
| } |
| |
| Delete(go_type); |
| return goType(n, type); |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * goCPointerType() |
| * |
| * Return the name of the Go type to use for the C pointer value. |
| * The regular C type is the name of an interface type which wraps a |
| * pointer whose name is returned by this function. |
| * ---------------------------------------------------------------------- */ |
| |
| String *goCPointerType(SwigType *type, bool add_to_hash) { |
| SwigType *ty = SwigType_typedef_resolve_all(type); |
| Node *cn = classLookup(ty); |
| String *ex; |
| String *ret; |
| if (!cn) { |
| if (add_to_hash) { |
| Setattr(undefined_types, ty, ty); |
| } |
| ret = NewString("Swigcptr"); |
| ex = exportedName(ty); |
| Append(ret, ex); |
| } else { |
| String *cname = Getattr(cn, "sym:name"); |
| if (!cname) { |
| cname = Getattr(cn, "name"); |
| } |
| ex = exportedName(cname); |
| Node *cnmod = Getattr(cn, "module"); |
| if (!cnmod || Strcmp(Getattr(cnmod, "name"), module) == 0) { |
| if (add_to_hash) { |
| Setattr(undefined_types, ty, ty); |
| } |
| ret = NewString("Swigcptr"); |
| Append(ret, ex); |
| } else { |
| ret = NewString(""); |
| Printv(ret, getModuleName(Getattr(cnmod, "name")), ".Swigcptr", ex, NULL); |
| } |
| } |
| Delete(ty); |
| Delete(ex); |
| return ret; |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * gcCTypeForGoValue() |
| * |
| * Given a type, return the C/C++ type which will be used to catch |
| * the value in Go. This is the gc version. |
| * ---------------------------------------------------------------------- */ |
| |
| String *gcCTypeForGoValue(Node *n, SwigType *type, String *name) { |
| bool is_interface; |
| String *gt = goTypeWithInfo(n, type, true, &is_interface); |
| |
| String *tail = NewString(""); |
| SwigType *t = SwigType_typedef_resolve_all(type); |
| bool is_const_ref = false; |
| if (SwigType_isreference(t)) { |
| SwigType* tt = Copy(t); |
| SwigType_del_reference(tt); |
| if (SwigType_isqualifier(tt)) { |
| String* q = SwigType_parm(tt); |
| if (Strcmp(q, "const") == 0) { |
| is_const_ref = true; |
| } |
| } |
| Delete(tt); |
| } |
| if (!is_const_ref) { |
| while (Strncmp(gt, "*", 1) == 0) { |
| Replace(gt, "*", "", DOH_REPLACE_FIRST); |
| Printv(tail, "*", NULL); |
| } |
| } |
| Delete(t); |
| |
| bool is_string = Strcmp(gt, "string") == 0; |
| bool is_slice = Strncmp(gt, "[]", 2) == 0; |
| bool is_function = Strcmp(gt, "_swig_fnptr") == 0; |
| bool is_member = Strcmp(gt, "_swig_memberptr") == 0; |
| bool is_complex64 = Strcmp(gt, "complex64") == 0; |
| bool is_complex128 = Strcmp(gt, "complex128") == 0; |
| bool is_bool = false; |
| bool is_int8 = false; |
| bool is_int16 = false; |
| bool is_int = Strcmp(gt, "int") == 0 || Strcmp(gt, "uint") == 0; |
| bool is_int32 = false; |
| bool is_int64 = false; |
| bool is_float32 = false; |
| bool is_float64 = false; |
| |
| bool has_typemap = (n != NULL && Getattr(n, "tmap:gotype") != NULL) || hasGoTypemap(n, type); |
| if (has_typemap) { |
| is_bool = Strcmp(gt, "bool") == 0; |
| is_int8 = Strcmp(gt, "int8") == 0 || Strcmp(gt, "uint8") == 0 || Strcmp(gt, "byte") == 0; |
| is_int16 = Strcmp(gt, "int16") == 0 || Strcmp(gt, "uint16") == 0; |
| is_int32 = Strcmp(gt, "int32") == 0 || Strcmp(gt, "uint32") == 0; |
| is_int64 = Strcmp(gt, "int64") == 0 || Strcmp(gt, "uint64") == 0; |
| is_float32 = Strcmp(gt, "float32") == 0; |
| is_float64 = Strcmp(gt, "float64") == 0; |
| } |
| Delete(gt); |
| |
| String *ret; |
| if (is_string) { |
| // Note that we don't turn a reference to a string into a |
| // pointer to a string. Strings are immutable anyhow. |
| ret = NewString(""); |
| Printv(ret, "_gostring_", tail, " ", name, NULL); |
| Delete(tail); |
| return ret; |
| } else if (is_slice) { |
| // Slices are always passed as a _goslice_, whether or not references |
| // are involved. |
| ret = NewString(""); |
| Printv(ret, "_goslice_", tail, " ", name, NULL); |
| Delete(tail); |
| return ret; |
| } else if (is_function || is_member) { |
| ret = NewString(""); |
| Printv(ret, "void*", tail, " ", name, NULL); |
| Delete(tail); |
| return ret; |
| } else if (is_complex64) { |
| ret = NewString("_Complex float "); |
| } else if (is_complex128) { |
| ret = NewString("_Complex double "); |
| } else if (is_interface) { |
| SwigType *t = SwigType_typedef_resolve_all(type); |
| if (SwigType_ispointer(t)) { |
| SwigType_del_pointer(t); |
| } |
| if (SwigType_isreference(t)) { |
| SwigType_del_reference(t); |
| } |
| SwigType_add_pointer(t); |
| ret = SwigType_lstr(t, name); |
| Delete(t); |
| Delete(tail); |
| return ret; |
| } else { |
| SwigType *t = SwigType_typedef_resolve_all(type); |
| if (!has_typemap && SwigType_isreference(t)) { |
| // A const reference to a known type, or to a pointer, is not |
| // mapped to a pointer. |
| SwigType_del_reference(t); |
| if (SwigType_isqualifier(t)) { |
| String *q = SwigType_parm(t); |
| if (Strcmp(q, "const") == 0) { |
| SwigType_del_qualifier(t); |
| if (hasGoTypemap(n, t) || SwigType_ispointer(t)) { |
| if (is_int) { |
| ret = NewString("intgo "); |
| Append(ret, name); |
| } else if (is_int64) { |
| ret = NewString("long long "); |
| Append(ret, name); |
| } else { |
| ret = SwigType_lstr(t, name); |
| } |
| Delete(q); |
| Delete(t); |
| Delete(tail); |
| return ret; |
| } |
| } |
| Delete(q); |
| } |
| } |
| |
| if (Language::enumLookup(t) != NULL) { |
| is_int = true; |
| } else { |
| SwigType *tstripped = SwigType_strip_qualifiers(t); |
| if (SwigType_isenum(tstripped)) |
| is_int = true; |
| Delete(tstripped); |
| } |
| |
| Delete(t); |
| if (is_bool) { |
| ret = NewString("bool "); |
| } else if (is_int8) { |
| ret = NewString("char "); |
| } else if (is_int16) { |
| ret = NewString("short "); |
| } else if (is_int) { |
| ret = NewString("intgo "); |
| } else if (is_int32) { |
| ret = NewString("int "); |
| } else if (is_int64) { |
| ret = NewString("long long "); |
| } else if (is_float32) { |
| ret = NewString("float "); |
| } else if (is_float64) { |
| ret = NewString("double "); |
| } else { |
| Delete(tail); |
| return SwigType_lstr(type, name); |
| } |
| } |
| |
| Append(ret, tail); |
| if (!has_typemap && SwigType_isreference(type)) { |
| Append(ret, "* "); |
| } |
| Append(ret, name); |
| Delete(tail); |
| return ret; |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * goTypeIsInterface |
| * |
| * Return whether this C++ type is represented as an interface type |
| * in Go. These types require adjustments in the Go code when |
| * passing them back and forth between Go and C++. |
| * ---------------------------------------------------------------------- */ |
| |
| bool goTypeIsInterface(Node *n, SwigType *type) { |
| bool is_interface; |
| Delete(goTypeWithInfo(n, type, false, &is_interface)); |
| return is_interface; |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * hasGoTypemap |
| * |
| * Return whether a type has a "gotype" typemap entry. |
| * ---------------------------------------------------------------------- */ |
| |
| bool hasGoTypemap(Node *n, SwigType *type) { |
| Parm *p = NewParm(type, "test", n); |
| SwigType *tm = Swig_typemap_lookup("gotype", p, "", NULL); |
| Delete(p); |
| if (tm && Strstr(tm, "$gotypename") == 0) { |
| Delete(tm); |
| return true; |
| } |
| Delete(tm); |
| return false; |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * goEnumName() |
| * |
| * Given an enum node, return a string to use for the enum type in Go. |
| * ---------------------------------------------------------------------- */ |
| |
| String *goEnumName(Node *n) { |
| String *ret = Getattr(n, "go:enumname"); |
| if (ret) { |
| return Copy(ret); |
| } |
| |
| if (Equal(Getattr(n, "type"), "enum ")) { |
| return NewString("int"); |
| } |
| |
| SwigType *type = Getattr(n, "enumtype"); |
| assert(type); |
| char *p = Char(type); |
| int len = Len(type); |
| SwigType *s = NewString(""); |
| bool capitalize = true; |
| for (int i = 0; i < len; ++i, ++p) { |
| if (*p == ':') { |
| ++i; |
| ++p; |
| assert(*p == ':'); |
| capitalize = true; |
| } else if (capitalize) { |
| Putc(toupper(*p), s); |
| capitalize = false; |
| } else { |
| Putc(*p, s); |
| } |
| } |
| |
| ret = Swig_name_mangle_type(s); |
| Delete(s); |
| return ret; |
| } |
| |
| |
| /* ---------------------------------------------------------------------- |
| * getParm() |
| * |
| * Get the real parameter to use. |
| * ---------------------------------------------------------------------- */ |
| |
| Parm *getParm(Parm *p) { |
| while (p && checkAttribute(p, "tmap:in:numinputs", "0")) { |
| p = Getattr(p, "tmap:in:next"); |
| } |
| return p; |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * nextParm() |
| * |
| * Return the next parameter. |
| * ---------------------------------------------------------------------- */ |
| |
| Parm *nextParm(Parm *p) { |
| if (!p) { |
| return NULL; |
| } else if (Getattr(p, "tmap:in")) { |
| return Getattr(p, "tmap:in:next"); |
| } else { |
| return nextSibling(p); |
| } |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * isStatic |
| * |
| * Return whether a node should be considered as static rather than |
| * as a member. |
| * ---------------------------------------------------------------------- */ |
| |
| bool isStatic(Node *n) { |
| String *storage = Getattr(n, "storage"); |
| return (storage && (Swig_storage_isstatic(n) || Strstr(storage, "friend")) && (!SmartPointer || !Getattr(n, "allocate:smartpointeraccess"))); |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * isFriend |
| * |
| * Return whether a node is a friend. |
| * ---------------------------------------------------------------------- */ |
| |
| bool isFriend(Node *n) { |
| String *storage = Getattr(n, "storage"); |
| return storage && Strstr(storage, "friend"); |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * goGetattr |
| * |
| * Fetch an attribute from a node but return NULL if it is the empty string. |
| * ---------------------------------------------------------------------- */ |
| Node *goGetattr(Node *n, const char *name) { |
| Node *ret = Getattr(n, name); |
| if (ret != NULL && Len(ret) == 0) { |
| ret = NULL; |
| } |
| return ret; |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * goTypemapLookup |
| * |
| * Look up a typemap but return NULL if it is the empty string. |
| * ---------------------------------------------------------------------- */ |
| String *goTypemapLookup(const char *name, Node *node, const char *lname) { |
| String *ret = Swig_typemap_lookup(name, node, lname, NULL); |
| if (ret != NULL && Len(ret) == 0) { |
| ret = NULL; |
| } |
| return ret; |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * getModuleName |
| * |
| * Return the name of a module. This is different from module path: |
| * "some/path/to/module" -> "module". |
| * ---------------------------------------------------------------------- */ |
| |
| String *getModuleName(String *module_path) { |
| char *suffix = strrchr(Char(module_path), '/'); |
| if (suffix == NULL) { |
| return module_path; |
| } |
| return Str(suffix + 1); |
| } |
| |
| }; /* class GO */ |
| |
| /* ----------------------------------------------------------------------------- |
| * swig_go() - Instantiate module |
| * ----------------------------------------------------------------------------- */ |
| |
| static Language *new_swig_go() { |
| return new GO(); |
| } |
| extern "C" Language *swig_go(void) { |
| return new_swig_go(); |
| } |
| |
| /* ----------------------------------------------------------------------------- |
| * Static member variables |
| * ----------------------------------------------------------------------------- */ |
| |
| // Usage message. |
| const char * const GO::usage = "\ |
| Go Options (available with -go)\n\ |
| -cgo - Generate cgo input files\n\ |
| -no-cgo - Do not generate cgo input files\n\ |
| -gccgo - Generate code for gccgo rather than gc\n\ |
| -go-pkgpath <p> - Like gccgo -fgo-pkgpath option\n\ |
| -go-prefix <p> - Like gccgo -fgo-prefix option\n\ |
| -import-prefix <p> - Prefix to add to %import directives\n\ |
| -intgosize <s> - Set size of Go int type--32 or 64 bits\n\ |
| -package <name> - Set name of the Go package to <name>\n\ |
| -use-shlib - Force use of a shared library\n\ |
| -soname <name> - Set shared library holding C/C++ code to <name>\n\ |
| \n"; |