| /* ---------------------------------------------------------------------------- |
| * This file was automatically generated by SWIG (http://www.swig.org). |
| * Version 1.3.40 |
| * |
| * This file is not intended to be easily readable and contains a number of |
| * coding conventions designed to improve portability and efficiency. Do not make |
| * changes to this file unless you know what you are doing--modify the SWIG |
| * interface file instead. |
| * ----------------------------------------------------------------------------- */ |
| |
| #define SWIGRUBY |
| |
| |
| #ifdef __cplusplus |
| /* SwigValueWrapper is described in swig.swg */ |
| template<typename T> class SwigValueWrapper { |
| struct SwigMovePointer { |
| T *ptr; |
| SwigMovePointer(T *p) : ptr(p) { } |
| ~SwigMovePointer() { delete ptr; } |
| SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; } |
| } pointer; |
| SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs); |
| SwigValueWrapper(const SwigValueWrapper<T>& rhs); |
| public: |
| SwigValueWrapper() : pointer(0) { } |
| SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; } |
| operator T&() const { return *pointer.ptr; } |
| T *operator&() { return pointer.ptr; } |
| }; |
| |
| template <typename T> T SwigValueInit() { |
| return T(); |
| } |
| #endif |
| |
| /* ----------------------------------------------------------------------------- |
| * This section contains generic SWIG labels for method/variable |
| * declarations/attributes, and other compiler dependent labels. |
| * ----------------------------------------------------------------------------- */ |
| |
| /* template workaround for compilers that cannot correctly implement the C++ standard */ |
| #ifndef SWIGTEMPLATEDISAMBIGUATOR |
| # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) |
| # define SWIGTEMPLATEDISAMBIGUATOR template |
| # elif defined(__HP_aCC) |
| /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ |
| /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ |
| # define SWIGTEMPLATEDISAMBIGUATOR template |
| # else |
| # define SWIGTEMPLATEDISAMBIGUATOR |
| # endif |
| #endif |
| |
| /* inline attribute */ |
| #ifndef SWIGINLINE |
| # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) |
| # define SWIGINLINE inline |
| # else |
| # define SWIGINLINE |
| # endif |
| #endif |
| |
| /* attribute recognised by some compilers to avoid 'unused' warnings */ |
| #ifndef SWIGUNUSED |
| # if defined(__GNUC__) |
| # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) |
| # define SWIGUNUSED __attribute__ ((__unused__)) |
| # else |
| # define SWIGUNUSED |
| # endif |
| # elif defined(__ICC) |
| # define SWIGUNUSED __attribute__ ((__unused__)) |
| # else |
| # define SWIGUNUSED |
| # endif |
| #endif |
| |
| #ifndef SWIG_MSC_UNSUPPRESS_4505 |
| # if defined(_MSC_VER) |
| # pragma warning(disable : 4505) /* unreferenced local function has been removed */ |
| # endif |
| #endif |
| |
| #ifndef SWIGUNUSEDPARM |
| # ifdef __cplusplus |
| # define SWIGUNUSEDPARM(p) |
| # else |
| # define SWIGUNUSEDPARM(p) p SWIGUNUSED |
| # endif |
| #endif |
| |
| /* internal SWIG method */ |
| #ifndef SWIGINTERN |
| # define SWIGINTERN static SWIGUNUSED |
| #endif |
| |
| /* internal inline SWIG method */ |
| #ifndef SWIGINTERNINLINE |
| # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE |
| #endif |
| |
| /* exporting methods */ |
| #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) |
| # ifndef GCC_HASCLASSVISIBILITY |
| # define GCC_HASCLASSVISIBILITY |
| # endif |
| #endif |
| |
| #ifndef SWIGEXPORT |
| # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) |
| # if defined(STATIC_LINKED) |
| # define SWIGEXPORT |
| # else |
| # define SWIGEXPORT __declspec(dllexport) |
| # endif |
| # else |
| # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) |
| # define SWIGEXPORT __attribute__ ((visibility("default"))) |
| # else |
| # define SWIGEXPORT |
| # endif |
| # endif |
| #endif |
| |
| /* calling conventions for Windows */ |
| #ifndef SWIGSTDCALL |
| # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) |
| # define SWIGSTDCALL __stdcall |
| # else |
| # define SWIGSTDCALL |
| # endif |
| #endif |
| |
| /* Deal with Microsoft's attempt at deprecating C standard runtime functions */ |
| #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) |
| # define _CRT_SECURE_NO_DEPRECATE |
| #endif |
| |
| /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ |
| #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) |
| # define _SCL_SECURE_NO_DEPRECATE |
| #endif |
| |
| |
| /* ----------------------------------------------------------------------------- |
| * This section contains generic SWIG labels for method/variable |
| * declarations/attributes, and other compiler dependent labels. |
| * ----------------------------------------------------------------------------- */ |
| |
| /* template workaround for compilers that cannot correctly implement the C++ standard */ |
| #ifndef SWIGTEMPLATEDISAMBIGUATOR |
| # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) |
| # define SWIGTEMPLATEDISAMBIGUATOR template |
| # elif defined(__HP_aCC) |
| /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ |
| /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ |
| # define SWIGTEMPLATEDISAMBIGUATOR template |
| # else |
| # define SWIGTEMPLATEDISAMBIGUATOR |
| # endif |
| #endif |
| |
| /* inline attribute */ |
| #ifndef SWIGINLINE |
| # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) |
| # define SWIGINLINE inline |
| # else |
| # define SWIGINLINE |
| # endif |
| #endif |
| |
| /* attribute recognised by some compilers to avoid 'unused' warnings */ |
| #ifndef SWIGUNUSED |
| # if defined(__GNUC__) |
| # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) |
| # define SWIGUNUSED __attribute__ ((__unused__)) |
| # else |
| # define SWIGUNUSED |
| # endif |
| # elif defined(__ICC) |
| # define SWIGUNUSED __attribute__ ((__unused__)) |
| # else |
| # define SWIGUNUSED |
| # endif |
| #endif |
| |
| #ifndef SWIG_MSC_UNSUPPRESS_4505 |
| # if defined(_MSC_VER) |
| # pragma warning(disable : 4505) /* unreferenced local function has been removed */ |
| # endif |
| #endif |
| |
| #ifndef SWIGUNUSEDPARM |
| # ifdef __cplusplus |
| # define SWIGUNUSEDPARM(p) |
| # else |
| # define SWIGUNUSEDPARM(p) p SWIGUNUSED |
| # endif |
| #endif |
| |
| /* internal SWIG method */ |
| #ifndef SWIGINTERN |
| # define SWIGINTERN static SWIGUNUSED |
| #endif |
| |
| /* internal inline SWIG method */ |
| #ifndef SWIGINTERNINLINE |
| # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE |
| #endif |
| |
| /* exporting methods */ |
| #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) |
| # ifndef GCC_HASCLASSVISIBILITY |
| # define GCC_HASCLASSVISIBILITY |
| # endif |
| #endif |
| |
| #ifndef SWIGEXPORT |
| # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) |
| # if defined(STATIC_LINKED) |
| # define SWIGEXPORT |
| # else |
| # define SWIGEXPORT __declspec(dllexport) |
| # endif |
| # else |
| # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) |
| # define SWIGEXPORT __attribute__ ((visibility("default"))) |
| # else |
| # define SWIGEXPORT |
| # endif |
| # endif |
| #endif |
| |
| /* calling conventions for Windows */ |
| #ifndef SWIGSTDCALL |
| # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) |
| # define SWIGSTDCALL __stdcall |
| # else |
| # define SWIGSTDCALL |
| # endif |
| #endif |
| |
| /* Deal with Microsoft's attempt at deprecating C standard runtime functions */ |
| #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) |
| # define _CRT_SECURE_NO_DEPRECATE |
| #endif |
| |
| /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ |
| #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) |
| # define _SCL_SECURE_NO_DEPRECATE |
| #endif |
| |
| |
| /* ----------------------------------------------------------------------------- |
| * swigrun.swg |
| * |
| * This file contains generic C API SWIG runtime support for pointer |
| * type checking. |
| * ----------------------------------------------------------------------------- */ |
| |
| /* This should only be incremented when either the layout of swig_type_info changes, |
| or for whatever reason, the runtime changes incompatibly */ |
| #define SWIG_RUNTIME_VERSION "4" |
| |
| /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */ |
| #ifdef SWIG_TYPE_TABLE |
| # define SWIG_QUOTE_STRING(x) #x |
| # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) |
| # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) |
| #else |
| # define SWIG_TYPE_TABLE_NAME |
| #endif |
| |
| /* |
| You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for |
| creating a static or dynamic library from the SWIG runtime code. |
| In 99.9% of the cases, SWIG just needs to declare them as 'static'. |
| |
| But only do this if strictly necessary, ie, if you have problems |
| with your compiler or suchlike. |
| */ |
| |
| #ifndef SWIGRUNTIME |
| # define SWIGRUNTIME SWIGINTERN |
| #endif |
| |
| #ifndef SWIGRUNTIMEINLINE |
| # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE |
| #endif |
| |
| /* Generic buffer size */ |
| #ifndef SWIG_BUFFER_SIZE |
| # define SWIG_BUFFER_SIZE 1024 |
| #endif |
| |
| /* Flags for pointer conversions */ |
| #define SWIG_POINTER_DISOWN 0x1 |
| #define SWIG_CAST_NEW_MEMORY 0x2 |
| |
| /* Flags for new pointer objects */ |
| #define SWIG_POINTER_OWN 0x1 |
| |
| |
| /* |
| Flags/methods for returning states. |
| |
| The SWIG conversion methods, as ConvertPtr, return and integer |
| that tells if the conversion was successful or not. And if not, |
| an error code can be returned (see swigerrors.swg for the codes). |
| |
| Use the following macros/flags to set or process the returning |
| states. |
| |
| In old versions of SWIG, code such as the following was usually written: |
| |
| if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) { |
| // success code |
| } else { |
| //fail code |
| } |
| |
| Now you can be more explicit: |
| |
| int res = SWIG_ConvertPtr(obj,vptr,ty.flags); |
| if (SWIG_IsOK(res)) { |
| // success code |
| } else { |
| // fail code |
| } |
| |
| which is the same really, but now you can also do |
| |
| Type *ptr; |
| int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags); |
| if (SWIG_IsOK(res)) { |
| // success code |
| if (SWIG_IsNewObj(res) { |
| ... |
| delete *ptr; |
| } else { |
| ... |
| } |
| } else { |
| // fail code |
| } |
| |
| I.e., now SWIG_ConvertPtr can return new objects and you can |
| identify the case and take care of the deallocation. Of course that |
| also requires SWIG_ConvertPtr to return new result values, such as |
| |
| int SWIG_ConvertPtr(obj, ptr,...) { |
| if (<obj is ok>) { |
| if (<need new object>) { |
| *ptr = <ptr to new allocated object>; |
| return SWIG_NEWOBJ; |
| } else { |
| *ptr = <ptr to old object>; |
| return SWIG_OLDOBJ; |
| } |
| } else { |
| return SWIG_BADOBJ; |
| } |
| } |
| |
| Of course, returning the plain '0(success)/-1(fail)' still works, but you can be |
| more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the |
| SWIG errors code. |
| |
| Finally, if the SWIG_CASTRANK_MODE is enabled, the result code |
| allows to return the 'cast rank', for example, if you have this |
| |
| int food(double) |
| int fooi(int); |
| |
| and you call |
| |
| food(1) // cast rank '1' (1 -> 1.0) |
| fooi(1) // cast rank '0' |
| |
| just use the SWIG_AddCast()/SWIG_CheckState() |
| */ |
| |
| #define SWIG_OK (0) |
| #define SWIG_ERROR (-1) |
| #define SWIG_IsOK(r) (r >= 0) |
| #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError) |
| |
| /* The CastRankLimit says how many bits are used for the cast rank */ |
| #define SWIG_CASTRANKLIMIT (1 << 8) |
| /* The NewMask denotes the object was created (using new/malloc) */ |
| #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1) |
| /* The TmpMask is for in/out typemaps that use temporal objects */ |
| #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1) |
| /* Simple returning values */ |
| #define SWIG_BADOBJ (SWIG_ERROR) |
| #define SWIG_OLDOBJ (SWIG_OK) |
| #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK) |
| #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK) |
| /* Check, add and del mask methods */ |
| #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r) |
| #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r) |
| #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK)) |
| #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r) |
| #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r) |
| #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK)) |
| |
| /* Cast-Rank Mode */ |
| #if defined(SWIG_CASTRANK_MODE) |
| # ifndef SWIG_TypeRank |
| # define SWIG_TypeRank unsigned long |
| # endif |
| # ifndef SWIG_MAXCASTRANK /* Default cast allowed */ |
| # define SWIG_MAXCASTRANK (2) |
| # endif |
| # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1) |
| # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK) |
| SWIGINTERNINLINE int SWIG_AddCast(int r) { |
| return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r; |
| } |
| SWIGINTERNINLINE int SWIG_CheckState(int r) { |
| return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; |
| } |
| #else /* no cast-rank mode */ |
| # define SWIG_AddCast |
| # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0) |
| #endif |
| |
| |
| #include <string.h> |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| typedef void *(*swig_converter_func)(void *, int *); |
| typedef struct swig_type_info *(*swig_dycast_func)(void **); |
| |
| /* Structure to store information on one type */ |
| typedef struct swig_type_info { |
| const char *name; /* mangled name of this type */ |
| const char *str; /* human readable name of this type */ |
| swig_dycast_func dcast; /* dynamic cast function down a hierarchy */ |
| struct swig_cast_info *cast; /* linked list of types that can cast into this type */ |
| void *clientdata; /* language specific type data */ |
| int owndata; /* flag if the structure owns the clientdata */ |
| } swig_type_info; |
| |
| /* Structure to store a type and conversion function used for casting */ |
| typedef struct swig_cast_info { |
| swig_type_info *type; /* pointer to type that is equivalent to this type */ |
| swig_converter_func converter; /* function to cast the void pointers */ |
| struct swig_cast_info *next; /* pointer to next cast in linked list */ |
| struct swig_cast_info *prev; /* pointer to the previous cast */ |
| } swig_cast_info; |
| |
| /* Structure used to store module information |
| * Each module generates one structure like this, and the runtime collects |
| * all of these structures and stores them in a circularly linked list.*/ |
| typedef struct swig_module_info { |
| swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */ |
| size_t size; /* Number of types in this module */ |
| struct swig_module_info *next; /* Pointer to next element in circularly linked list */ |
| swig_type_info **type_initial; /* Array of initially generated type structures */ |
| swig_cast_info **cast_initial; /* Array of initially generated casting structures */ |
| void *clientdata; /* Language specific module data */ |
| } swig_module_info; |
| |
| /* |
| Compare two type names skipping the space characters, therefore |
| "char*" == "char *" and "Class<int>" == "Class<int >", etc. |
| |
| Return 0 when the two name types are equivalent, as in |
| strncmp, but skipping ' '. |
| */ |
| SWIGRUNTIME int |
| SWIG_TypeNameComp(const char *f1, const char *l1, |
| const char *f2, const char *l2) { |
| for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) { |
| while ((*f1 == ' ') && (f1 != l1)) ++f1; |
| while ((*f2 == ' ') && (f2 != l2)) ++f2; |
| if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1; |
| } |
| return (int)((l1 - f1) - (l2 - f2)); |
| } |
| |
| /* |
| Check type equivalence in a name list like <name1>|<name2>|... |
| Return 0 if not equal, 1 if equal |
| */ |
| SWIGRUNTIME int |
| SWIG_TypeEquiv(const char *nb, const char *tb) { |
| int equiv = 0; |
| const char* te = tb + strlen(tb); |
| const char* ne = nb; |
| while (!equiv && *ne) { |
| for (nb = ne; *ne; ++ne) { |
| if (*ne == '|') break; |
| } |
| equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0; |
| if (*ne) ++ne; |
| } |
| return equiv; |
| } |
| |
| /* |
| Check type equivalence in a name list like <name1>|<name2>|... |
| Return 0 if equal, -1 if nb < tb, 1 if nb > tb |
| */ |
| SWIGRUNTIME int |
| SWIG_TypeCompare(const char *nb, const char *tb) { |
| int equiv = 0; |
| const char* te = tb + strlen(tb); |
| const char* ne = nb; |
| while (!equiv && *ne) { |
| for (nb = ne; *ne; ++ne) { |
| if (*ne == '|') break; |
| } |
| equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0; |
| if (*ne) ++ne; |
| } |
| return equiv; |
| } |
| |
| |
| /* |
| Check the typename |
| */ |
| SWIGRUNTIME swig_cast_info * |
| SWIG_TypeCheck(const char *c, swig_type_info *ty) { |
| if (ty) { |
| swig_cast_info *iter = ty->cast; |
| while (iter) { |
| if (strcmp(iter->type->name, c) == 0) { |
| if (iter == ty->cast) |
| return iter; |
| /* Move iter to the top of the linked list */ |
| iter->prev->next = iter->next; |
| if (iter->next) |
| iter->next->prev = iter->prev; |
| iter->next = ty->cast; |
| iter->prev = 0; |
| if (ty->cast) ty->cast->prev = iter; |
| ty->cast = iter; |
| return iter; |
| } |
| iter = iter->next; |
| } |
| } |
| return 0; |
| } |
| |
| /* |
| Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison |
| */ |
| SWIGRUNTIME swig_cast_info * |
| SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) { |
| if (ty) { |
| swig_cast_info *iter = ty->cast; |
| while (iter) { |
| if (iter->type == from) { |
| if (iter == ty->cast) |
| return iter; |
| /* Move iter to the top of the linked list */ |
| iter->prev->next = iter->next; |
| if (iter->next) |
| iter->next->prev = iter->prev; |
| iter->next = ty->cast; |
| iter->prev = 0; |
| if (ty->cast) ty->cast->prev = iter; |
| ty->cast = iter; |
| return iter; |
| } |
| iter = iter->next; |
| } |
| } |
| return 0; |
| } |
| |
| /* |
| Cast a pointer up an inheritance hierarchy |
| */ |
| SWIGRUNTIMEINLINE void * |
| SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) { |
| return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory); |
| } |
| |
| /* |
| Dynamic pointer casting. Down an inheritance hierarchy |
| */ |
| SWIGRUNTIME swig_type_info * |
| SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) { |
| swig_type_info *lastty = ty; |
| if (!ty || !ty->dcast) return ty; |
| while (ty && (ty->dcast)) { |
| ty = (*ty->dcast)(ptr); |
| if (ty) lastty = ty; |
| } |
| return lastty; |
| } |
| |
| /* |
| Return the name associated with this type |
| */ |
| SWIGRUNTIMEINLINE const char * |
| SWIG_TypeName(const swig_type_info *ty) { |
| return ty->name; |
| } |
| |
| /* |
| Return the pretty name associated with this type, |
| that is an unmangled type name in a form presentable to the user. |
| */ |
| SWIGRUNTIME const char * |
| SWIG_TypePrettyName(const swig_type_info *type) { |
| /* The "str" field contains the equivalent pretty names of the |
| type, separated by vertical-bar characters. We choose |
| to print the last name, as it is often (?) the most |
| specific. */ |
| if (!type) return NULL; |
| if (type->str != NULL) { |
| const char *last_name = type->str; |
| const char *s; |
| for (s = type->str; *s; s++) |
| if (*s == '|') last_name = s+1; |
| return last_name; |
| } |
| else |
| return type->name; |
| } |
| |
| /* |
| Set the clientdata field for a type |
| */ |
| SWIGRUNTIME void |
| SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { |
| swig_cast_info *cast = ti->cast; |
| /* if (ti->clientdata == clientdata) return; */ |
| ti->clientdata = clientdata; |
| |
| while (cast) { |
| if (!cast->converter) { |
| swig_type_info *tc = cast->type; |
| if (!tc->clientdata) { |
| SWIG_TypeClientData(tc, clientdata); |
| } |
| } |
| cast = cast->next; |
| } |
| } |
| SWIGRUNTIME void |
| SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) { |
| SWIG_TypeClientData(ti, clientdata); |
| ti->owndata = 1; |
| } |
| |
| /* |
| Search for a swig_type_info structure only by mangled name |
| Search is a O(log #types) |
| |
| We start searching at module start, and finish searching when start == end. |
| Note: if start == end at the beginning of the function, we go all the way around |
| the circular list. |
| */ |
| SWIGRUNTIME swig_type_info * |
| SWIG_MangledTypeQueryModule(swig_module_info *start, |
| swig_module_info *end, |
| const char *name) { |
| swig_module_info *iter = start; |
| do { |
| if (iter->size) { |
| register size_t l = 0; |
| register size_t r = iter->size - 1; |
| do { |
| /* since l+r >= 0, we can (>> 1) instead (/ 2) */ |
| register size_t i = (l + r) >> 1; |
| const char *iname = iter->types[i]->name; |
| if (iname) { |
| register int compare = strcmp(name, iname); |
| if (compare == 0) { |
| return iter->types[i]; |
| } else if (compare < 0) { |
| if (i) { |
| r = i - 1; |
| } else { |
| break; |
| } |
| } else if (compare > 0) { |
| l = i + 1; |
| } |
| } else { |
| break; /* should never happen */ |
| } |
| } while (l <= r); |
| } |
| iter = iter->next; |
| } while (iter != end); |
| return 0; |
| } |
| |
| /* |
| Search for a swig_type_info structure for either a mangled name or a human readable name. |
| It first searches the mangled names of the types, which is a O(log #types) |
| If a type is not found it then searches the human readable names, which is O(#types). |
| |
| We start searching at module start, and finish searching when start == end. |
| Note: if start == end at the beginning of the function, we go all the way around |
| the circular list. |
| */ |
| SWIGRUNTIME swig_type_info * |
| SWIG_TypeQueryModule(swig_module_info *start, |
| swig_module_info *end, |
| const char *name) { |
| /* STEP 1: Search the name field using binary search */ |
| swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name); |
| if (ret) { |
| return ret; |
| } else { |
| /* STEP 2: If the type hasn't been found, do a complete search |
| of the str field (the human readable name) */ |
| swig_module_info *iter = start; |
| do { |
| register size_t i = 0; |
| for (; i < iter->size; ++i) { |
| if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name))) |
| return iter->types[i]; |
| } |
| iter = iter->next; |
| } while (iter != end); |
| } |
| |
| /* neither found a match */ |
| return 0; |
| } |
| |
| /* |
| Pack binary data into a string |
| */ |
| SWIGRUNTIME char * |
| SWIG_PackData(char *c, void *ptr, size_t sz) { |
| static const char hex[17] = "0123456789abcdef"; |
| register const unsigned char *u = (unsigned char *) ptr; |
| register const unsigned char *eu = u + sz; |
| for (; u != eu; ++u) { |
| register unsigned char uu = *u; |
| *(c++) = hex[(uu & 0xf0) >> 4]; |
| *(c++) = hex[uu & 0xf]; |
| } |
| return c; |
| } |
| |
| /* |
| Unpack binary data from a string |
| */ |
| SWIGRUNTIME const char * |
| SWIG_UnpackData(const char *c, void *ptr, size_t sz) { |
| register unsigned char *u = (unsigned char *) ptr; |
| register const unsigned char *eu = u + sz; |
| for (; u != eu; ++u) { |
| register char d = *(c++); |
| register unsigned char uu; |
| if ((d >= '0') && (d <= '9')) |
| uu = ((d - '0') << 4); |
| else if ((d >= 'a') && (d <= 'f')) |
| uu = ((d - ('a'-10)) << 4); |
| else |
| return (char *) 0; |
| d = *(c++); |
| if ((d >= '0') && (d <= '9')) |
| uu |= (d - '0'); |
| else if ((d >= 'a') && (d <= 'f')) |
| uu |= (d - ('a'-10)); |
| else |
| return (char *) 0; |
| *u = uu; |
| } |
| return c; |
| } |
| |
| /* |
| Pack 'void *' into a string buffer. |
| */ |
| SWIGRUNTIME char * |
| SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) { |
| char *r = buff; |
| if ((2*sizeof(void *) + 2) > bsz) return 0; |
| *(r++) = '_'; |
| r = SWIG_PackData(r,&ptr,sizeof(void *)); |
| if (strlen(name) + 1 > (bsz - (r - buff))) return 0; |
| strcpy(r,name); |
| return buff; |
| } |
| |
| SWIGRUNTIME const char * |
| SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) { |
| if (*c != '_') { |
| if (strcmp(c,"NULL") == 0) { |
| *ptr = (void *) 0; |
| return name; |
| } else { |
| return 0; |
| } |
| } |
| return SWIG_UnpackData(++c,ptr,sizeof(void *)); |
| } |
| |
| SWIGRUNTIME char * |
| SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) { |
| char *r = buff; |
| size_t lname = (name ? strlen(name) : 0); |
| if ((2*sz + 2 + lname) > bsz) return 0; |
| *(r++) = '_'; |
| r = SWIG_PackData(r,ptr,sz); |
| if (lname) { |
| strncpy(r,name,lname+1); |
| } else { |
| *r = 0; |
| } |
| return buff; |
| } |
| |
| SWIGRUNTIME const char * |
| SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { |
| if (*c != '_') { |
| if (strcmp(c,"NULL") == 0) { |
| memset(ptr,0,sz); |
| return name; |
| } else { |
| return 0; |
| } |
| } |
| return SWIG_UnpackData(++c,ptr,sz); |
| } |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| /* Errors in SWIG */ |
| #define SWIG_UnknownError -1 |
| #define SWIG_IOError -2 |
| #define SWIG_RuntimeError -3 |
| #define SWIG_IndexError -4 |
| #define SWIG_TypeError -5 |
| #define SWIG_DivisionByZero -6 |
| #define SWIG_OverflowError -7 |
| #define SWIG_SyntaxError -8 |
| #define SWIG_ValueError -9 |
| #define SWIG_SystemError -10 |
| #define SWIG_AttributeError -11 |
| #define SWIG_MemoryError -12 |
| #define SWIG_NullReferenceError -13 |
| |
| |
| |
| #include <ruby.h> |
| |
| /* Remove global macros defined in Ruby's win32.h */ |
| #ifdef write |
| # undef write |
| #endif |
| #ifdef read |
| # undef read |
| #endif |
| #ifdef bind |
| # undef bind |
| #endif |
| #ifdef close |
| # undef close |
| #endif |
| #ifdef connect |
| # undef connect |
| #endif |
| |
| |
| /* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */ |
| #ifndef NUM2LL |
| #define NUM2LL(x) NUM2LONG((x)) |
| #endif |
| #ifndef LL2NUM |
| #define LL2NUM(x) INT2NUM((long) (x)) |
| #endif |
| #ifndef ULL2NUM |
| #define ULL2NUM(x) UINT2NUM((unsigned long) (x)) |
| #endif |
| |
| /* Ruby 1.7 doesn't (yet) define NUM2ULL() */ |
| #ifndef NUM2ULL |
| #ifdef HAVE_LONG_LONG |
| #define NUM2ULL(x) rb_num2ull((x)) |
| #else |
| #define NUM2ULL(x) NUM2ULONG(x) |
| #endif |
| #endif |
| |
| /* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */ |
| /* Define these for older versions so we can just write code the new way */ |
| #ifndef RSTRING_LEN |
| # define RSTRING_LEN(x) RSTRING(x)->len |
| #endif |
| #ifndef RSTRING_PTR |
| # define RSTRING_PTR(x) RSTRING(x)->ptr |
| #endif |
| #ifndef RSTRING_END |
| # define RSTRING_END(x) (RSTRING_PTR(x) + RSTRING_LEN(x)) |
| #endif |
| #ifndef RARRAY_LEN |
| # define RARRAY_LEN(x) RARRAY(x)->len |
| #endif |
| #ifndef RARRAY_PTR |
| # define RARRAY_PTR(x) RARRAY(x)->ptr |
| #endif |
| #ifndef RFLOAT_VALUE |
| # define RFLOAT_VALUE(x) RFLOAT(x)->value |
| #endif |
| #ifndef DOUBLE2NUM |
| # define DOUBLE2NUM(x) rb_float_new(x) |
| #endif |
| #ifndef RHASH_TBL |
| # define RHASH_TBL(x) (RHASH(x)->tbl) |
| #endif |
| #ifndef RHASH_ITER_LEV |
| # define RHASH_ITER_LEV(x) (RHASH(x)->iter_lev) |
| #endif |
| #ifndef RHASH_IFNONE |
| # define RHASH_IFNONE(x) (RHASH(x)->ifnone) |
| #endif |
| #ifndef RHASH_SIZE |
| # define RHASH_SIZE(x) (RHASH(x)->tbl->num_entries) |
| #endif |
| #ifndef RHASH_EMPTY_P |
| # define RHASH_EMPTY_P(x) (RHASH_SIZE(x) == 0) |
| #endif |
| #ifndef RSTRUCT_LEN |
| # define RSTRUCT_LEN(x) RSTRUCT(x)->len |
| #endif |
| #ifndef RSTRUCT_PTR |
| # define RSTRUCT_PTR(x) RSTRUCT(x)->ptr |
| #endif |
| |
| |
| |
| /* |
| * Need to be very careful about how these macros are defined, especially |
| * when compiling C++ code or C code with an ANSI C compiler. |
| * |
| * VALUEFUNC(f) is a macro used to typecast a C function that implements |
| * a Ruby method so that it can be passed as an argument to API functions |
| * like rb_define_method() and rb_define_singleton_method(). |
| * |
| * VOIDFUNC(f) is a macro used to typecast a C function that implements |
| * either the "mark" or "free" stuff for a Ruby Data object, so that it |
| * can be passed as an argument to API functions like Data_Wrap_Struct() |
| * and Data_Make_Struct(). |
| */ |
| |
| #ifdef __cplusplus |
| # ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */ |
| # define PROTECTFUNC(f) ((VALUE (*)()) f) |
| # define VALUEFUNC(f) ((VALUE (*)()) f) |
| # define VOIDFUNC(f) ((void (*)()) f) |
| # else |
| # ifndef ANYARGS /* These definitions should work for Ruby 1.6 */ |
| # define PROTECTFUNC(f) ((VALUE (*)()) f) |
| # define VALUEFUNC(f) ((VALUE (*)()) f) |
| # define VOIDFUNC(f) ((RUBY_DATA_FUNC) f) |
| # else /* These definitions should work for Ruby 1.7+ */ |
| # define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f) |
| # define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f) |
| # define VOIDFUNC(f) ((RUBY_DATA_FUNC) f) |
| # endif |
| # endif |
| #else |
| # define VALUEFUNC(f) (f) |
| # define VOIDFUNC(f) (f) |
| #endif |
| |
| /* Don't use for expressions have side effect */ |
| #ifndef RB_STRING_VALUE |
| #define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s))) |
| #endif |
| #ifndef StringValue |
| #define StringValue(s) RB_STRING_VALUE(s) |
| #endif |
| #ifndef StringValuePtr |
| #define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s)) |
| #endif |
| #ifndef StringValueLen |
| #define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s)) |
| #endif |
| #ifndef SafeStringValue |
| #define SafeStringValue(v) do {\ |
| StringValue(v);\ |
| rb_check_safe_str(v);\ |
| } while (0) |
| #endif |
| |
| #ifndef HAVE_RB_DEFINE_ALLOC_FUNC |
| #define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1) |
| #define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new") |
| #endif |
| |
| static VALUE _mSWIG = Qnil; |
| |
| /* ----------------------------------------------------------------------------- |
| * error manipulation |
| * ----------------------------------------------------------------------------- */ |
| |
| |
| /* Define some additional error types */ |
| #define SWIG_ObjectPreviouslyDeletedError -100 |
| |
| |
| /* Define custom exceptions for errors that do not map to existing Ruby |
| exceptions. Note this only works for C++ since a global cannot be |
| initialized by a funtion in C. For C, fallback to rb_eRuntimeError.*/ |
| |
| SWIGINTERN VALUE |
| getNullReferenceError(void) { |
| static int init = 0; |
| static VALUE rb_eNullReferenceError ; |
| if (!init) { |
| init = 1; |
| rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError); |
| } |
| return rb_eNullReferenceError; |
| } |
| |
| SWIGINTERN VALUE |
| getObjectPreviouslyDeletedError(void) { |
| static int init = 0; |
| static VALUE rb_eObjectPreviouslyDeleted ; |
| if (!init) { |
| init = 1; |
| rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError); |
| } |
| return rb_eObjectPreviouslyDeleted; |
| } |
| |
| |
| SWIGINTERN VALUE |
| SWIG_Ruby_ErrorType(int SWIG_code) { |
| VALUE type; |
| switch (SWIG_code) { |
| case SWIG_MemoryError: |
| type = rb_eNoMemError; |
| break; |
| case SWIG_IOError: |
| type = rb_eIOError; |
| break; |
| case SWIG_RuntimeError: |
| type = rb_eRuntimeError; |
| break; |
| case SWIG_IndexError: |
| type = rb_eIndexError; |
| break; |
| case SWIG_TypeError: |
| type = rb_eTypeError; |
| break; |
| case SWIG_DivisionByZero: |
| type = rb_eZeroDivError; |
| break; |
| case SWIG_OverflowError: |
| type = rb_eRangeError; |
| break; |
| case SWIG_SyntaxError: |
| type = rb_eSyntaxError; |
| break; |
| case SWIG_ValueError: |
| type = rb_eArgError; |
| break; |
| case SWIG_SystemError: |
| type = rb_eFatal; |
| break; |
| case SWIG_AttributeError: |
| type = rb_eRuntimeError; |
| break; |
| case SWIG_NullReferenceError: |
| type = getNullReferenceError(); |
| break; |
| case SWIG_ObjectPreviouslyDeletedError: |
| type = getObjectPreviouslyDeletedError(); |
| break; |
| case SWIG_UnknownError: |
| type = rb_eRuntimeError; |
| break; |
| default: |
| type = rb_eRuntimeError; |
| } |
| return type; |
| } |
| |
| |
| /* This function is called when a user inputs a wrong argument to |
| a method. |
| */ |
| SWIGINTERN |
| const char* Ruby_Format_TypeError( const char* msg, |
| const char* type, |
| const char* name, |
| const int argn, |
| VALUE input ) |
| { |
| char buf[128]; |
| VALUE str; |
| VALUE asStr; |
| if ( msg && *msg ) |
| { |
| str = rb_str_new2(msg); |
| } |
| else |
| { |
| str = rb_str_new(NULL, 0); |
| } |
| |
| str = rb_str_cat2( str, "Expected argument " ); |
| sprintf( buf, "%d of type ", argn-1 ); |
| str = rb_str_cat2( str, buf ); |
| str = rb_str_cat2( str, type ); |
| str = rb_str_cat2( str, ", but got " ); |
| str = rb_str_cat2( str, rb_obj_classname(input) ); |
| str = rb_str_cat2( str, " " ); |
| asStr = rb_inspect(input); |
| if ( RSTRING_LEN(asStr) > 30 ) |
| { |
| str = rb_str_cat( str, StringValuePtr(asStr), 30 ); |
| str = rb_str_cat2( str, "..." ); |
| } |
| else |
| { |
| str = rb_str_append( str, asStr ); |
| } |
| |
| if ( name ) |
| { |
| str = rb_str_cat2( str, "\n\tin SWIG method '" ); |
| str = rb_str_cat2( str, name ); |
| str = rb_str_cat2( str, "'" ); |
| } |
| |
| return StringValuePtr( str ); |
| } |
| |
| /* This function is called when an overloaded method fails */ |
| SWIGINTERN |
| void Ruby_Format_OverloadedError( |
| const int argc, |
| const int maxargs, |
| const char* method, |
| const char* prototypes |
| ) |
| { |
| const char* msg = "Wrong # of arguments"; |
| if ( argc <= maxargs ) msg = "Wrong arguments"; |
| rb_raise(rb_eArgError,"%s for overloaded method '%s'.\n" |
| "Possible C/C++ prototypes are:\n%s", |
| msg, method, prototypes); |
| } |
| |
| /* ----------------------------------------------------------------------------- |
| * See the LICENSE file for information on copyright, usage and redistribution |
| * of SWIG, and the README file for authors - http://www.swig.org/release.html. |
| * |
| * rubytracking.swg |
| * |
| * This file contains support for tracking mappings from |
| * Ruby objects to C++ objects. This functionality is needed |
| * to implement mark functions for Ruby's mark and sweep |
| * garbage collector. |
| * ----------------------------------------------------------------------------- */ |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| /* Ruby 1.8 actually assumes the first case. */ |
| #if SIZEOF_VOIDP == SIZEOF_LONG |
| # define SWIG2NUM(v) LONG2NUM((unsigned long)v) |
| # define NUM2SWIG(x) (unsigned long)NUM2LONG(x) |
| #elif SIZEOF_VOIDP == SIZEOF_LONG_LONG |
| # define SWIG2NUM(v) LL2NUM((unsigned long long)v) |
| # define NUM2SWIG(x) (unsigned long long)NUM2LL(x) |
| #else |
| # error sizeof(void*) is not the same as long or long long |
| #endif |
| |
| |
| /* Global Ruby hash table to store Trackings from C/C++ |
| structs to Ruby Objects. |
| */ |
| static VALUE swig_ruby_trackings = Qnil; |
| |
| /* Global variable that stores a reference to the ruby |
| hash table delete function. */ |
| static ID swig_ruby_hash_delete; |
| |
| /* Setup a Ruby hash table to store Trackings */ |
| SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) { |
| /* Create a ruby hash table to store Trackings from C++ |
| objects to Ruby objects. */ |
| |
| /* Try to see if some other .so has already created a |
| tracking hash table, which we keep hidden in an instance var |
| in the SWIG module. |
| This is done to allow multiple DSOs to share the same |
| tracking table. |
| */ |
| ID trackings_id = rb_intern( "@__trackings__" ); |
| VALUE verbose = rb_gv_get("VERBOSE"); |
| rb_gv_set("VERBOSE", Qfalse); |
| swig_ruby_trackings = rb_ivar_get( _mSWIG, trackings_id ); |
| rb_gv_set("VERBOSE", verbose); |
| |
| /* No, it hasn't. Create one ourselves */ |
| if ( swig_ruby_trackings == Qnil ) |
| { |
| swig_ruby_trackings = rb_hash_new(); |
| rb_ivar_set( _mSWIG, trackings_id, swig_ruby_trackings ); |
| } |
| |
| /* Now store a reference to the hash table delete function |
| so that we only have to look it up once.*/ |
| swig_ruby_hash_delete = rb_intern("delete"); |
| } |
| |
| /* Get a Ruby number to reference a pointer */ |
| SWIGRUNTIME VALUE SWIG_RubyPtrToReference(void* ptr) { |
| /* We cast the pointer to an unsigned long |
| and then store a reference to it using |
| a Ruby number object. */ |
| |
| /* Convert the pointer to a Ruby number */ |
| return SWIG2NUM(ptr); |
| } |
| |
| /* Get a Ruby number to reference an object */ |
| SWIGRUNTIME VALUE SWIG_RubyObjectToReference(VALUE object) { |
| /* We cast the object to an unsigned long |
| and then store a reference to it using |
| a Ruby number object. */ |
| |
| /* Convert the Object to a Ruby number */ |
| return SWIG2NUM(object); |
| } |
| |
| /* Get a Ruby object from a previously stored reference */ |
| SWIGRUNTIME VALUE SWIG_RubyReferenceToObject(VALUE reference) { |
| /* The provided Ruby number object is a reference |
| to the Ruby object we want.*/ |
| |
| /* Convert the Ruby number to a Ruby object */ |
| return NUM2SWIG(reference); |
| } |
| |
| /* Add a Tracking from a C/C++ struct to a Ruby object */ |
| SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) { |
| /* In a Ruby hash table we store the pointer and |
| the associated Ruby object. The trick here is |
| that we cannot store the Ruby object directly - if |
| we do then it cannot be garbage collected. So |
| instead we typecast it as a unsigned long and |
| convert it to a Ruby number object.*/ |
| |
| /* Get a reference to the pointer as a Ruby number */ |
| VALUE key = SWIG_RubyPtrToReference(ptr); |
| |
| /* Get a reference to the Ruby object as a Ruby number */ |
| VALUE value = SWIG_RubyObjectToReference(object); |
| |
| /* Store the mapping to the global hash table. */ |
| rb_hash_aset(swig_ruby_trackings, key, value); |
| } |
| |
| /* Get the Ruby object that owns the specified C/C++ struct */ |
| SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) { |
| /* Get a reference to the pointer as a Ruby number */ |
| VALUE key = SWIG_RubyPtrToReference(ptr); |
| |
| /* Now lookup the value stored in the global hash table */ |
| VALUE value = rb_hash_aref(swig_ruby_trackings, key); |
| |
| if (value == Qnil) { |
| /* No object exists - return nil. */ |
| return Qnil; |
| } |
| else { |
| /* Convert this value to Ruby object */ |
| return SWIG_RubyReferenceToObject(value); |
| } |
| } |
| |
| /* Remove a Tracking from a C/C++ struct to a Ruby object. It |
| is very important to remove objects once they are destroyed |
| since the same memory address may be reused later to create |
| a new object. */ |
| SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) { |
| /* Get a reference to the pointer as a Ruby number */ |
| VALUE key = SWIG_RubyPtrToReference(ptr); |
| |
| /* Delete the object from the hash table by calling Ruby's |
| do this we need to call the Hash.delete method.*/ |
| rb_funcall(swig_ruby_trackings, swig_ruby_hash_delete, 1, key); |
| } |
| |
| /* This is a helper method that unlinks a Ruby object from its |
| underlying C++ object. This is needed if the lifetime of the |
| Ruby object is longer than the C++ object */ |
| SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) { |
| VALUE object = SWIG_RubyInstanceFor(ptr); |
| |
| if (object != Qnil) { |
| DATA_PTR(object) = 0; |
| } |
| } |
| |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| /* ----------------------------------------------------------------------------- |
| * Ruby API portion that goes into the runtime |
| * ----------------------------------------------------------------------------- */ |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| SWIGINTERN VALUE |
| SWIG_Ruby_AppendOutput(VALUE target, VALUE o) { |
| if (NIL_P(target)) { |
| target = o; |
| } else { |
| if (TYPE(target) != T_ARRAY) { |
| VALUE o2 = target; |
| target = rb_ary_new(); |
| rb_ary_push(target, o2); |
| } |
| rb_ary_push(target, o); |
| } |
| return target; |
| } |
| |
| /* For ruby1.8.4 and earlier. */ |
| #ifndef RUBY_INIT_STACK |
| RUBY_EXTERN void Init_stack(VALUE* addr); |
| # define RUBY_INIT_STACK \ |
| VALUE variable_in_this_stack_frame; \ |
| Init_stack(&variable_in_this_stack_frame); |
| #endif |
| |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| |
| /* ----------------------------------------------------------------------------- |
| * See the LICENSE file for information on copyright, usage and redistribution |
| * of SWIG, and the README file for authors - http://www.swig.org/release.html. |
| * |
| * rubyrun.swg |
| * |
| * This file contains the runtime support for Ruby modules |
| * and includes code for managing global variables and pointer |
| * type checking. |
| * ----------------------------------------------------------------------------- */ |
| |
| /* For backward compatibility only */ |
| #define SWIG_POINTER_EXCEPTION 0 |
| |
| /* for raw pointers */ |
| #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0) |
| #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own) |
| #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Ruby_NewPointerObj(ptr, type, flags) |
| #define SWIG_AcquirePtr(ptr, own) SWIG_Ruby_AcquirePtr(ptr, own) |
| #define swig_owntype ruby_owntype |
| |
| /* for raw packed data */ |
| #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags) |
| #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Ruby_NewPackedObj(ptr, sz, type) |
| |
| /* for class or struct pointers */ |
| #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags) |
| #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags) |
| |
| /* for C or C++ function pointers */ |
| #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0) |
| #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0) |
| |
| /* for C++ member pointers, ie, member methods */ |
| #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty) |
| #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Ruby_NewPackedObj(ptr, sz, type) |
| |
| |
| /* Runtime API */ |
| |
| #define SWIG_GetModule(clientdata) SWIG_Ruby_GetModule() |
| #define SWIG_SetModule(clientdata, pointer) SWIG_Ruby_SetModule(pointer) |
| |
| |
| /* Error manipulation */ |
| |
| #define SWIG_ErrorType(code) SWIG_Ruby_ErrorType(code) |
| #define SWIG_Error(code, msg) rb_raise(SWIG_Ruby_ErrorType(code), msg) |
| #define SWIG_fail goto fail |
| |
| |
| /* Ruby-specific SWIG API */ |
| |
| #define SWIG_InitRuntime() SWIG_Ruby_InitRuntime() |
| #define SWIG_define_class(ty) SWIG_Ruby_define_class(ty) |
| #define SWIG_NewClassInstance(value, ty) SWIG_Ruby_NewClassInstance(value, ty) |
| #define SWIG_MangleStr(value) SWIG_Ruby_MangleStr(value) |
| #define SWIG_CheckConvert(value, ty) SWIG_Ruby_CheckConvert(value, ty) |
| |
| #include "assert.h" |
| |
| /* ----------------------------------------------------------------------------- |
| * pointers/data manipulation |
| * ----------------------------------------------------------------------------- */ |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| typedef struct { |
| VALUE klass; |
| VALUE mImpl; |
| void (*mark)(void *); |
| void (*destroy)(void *); |
| int trackObjects; |
| } swig_class; |
| |
| |
| /* Global pointer used to keep some internal SWIG stuff */ |
| static VALUE _cSWIG_Pointer = Qnil; |
| static VALUE swig_runtime_data_type_pointer = Qnil; |
| |
| /* Global IDs used to keep some internal SWIG stuff */ |
| static ID swig_arity_id = 0; |
| static ID swig_call_id = 0; |
| |
| /* |
| If your swig extension is to be run within an embedded ruby and has |
| director callbacks, you should set -DRUBY_EMBEDDED during compilation. |
| This will reset ruby's stack frame on each entry point from the main |
| program the first time a virtual director function is invoked (in a |
| non-recursive way). |
| If this is not done, you run the risk of Ruby trashing the stack. |
| */ |
| |
| #ifdef RUBY_EMBEDDED |
| |
| # define SWIG_INIT_STACK \ |
| if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \ |
| ++swig_virtual_calls; |
| # define SWIG_RELEASE_STACK --swig_virtual_calls; |
| # define Ruby_DirectorTypeMismatchException(x) \ |
| rb_raise( rb_eTypeError, x ); return c_result; |
| |
| static unsigned int swig_virtual_calls = 0; |
| |
| #else /* normal non-embedded extension */ |
| |
| # define SWIG_INIT_STACK |
| # define SWIG_RELEASE_STACK |
| # define Ruby_DirectorTypeMismatchException(x) \ |
| throw Swig::DirectorTypeMismatchException( x ); |
| |
| #endif /* RUBY_EMBEDDED */ |
| |
| |
| SWIGRUNTIME VALUE |
| getExceptionClass(void) { |
| static int init = 0; |
| static VALUE rubyExceptionClass ; |
| if (!init) { |
| init = 1; |
| rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception")); |
| } |
| return rubyExceptionClass; |
| } |
| |
| /* This code checks to see if the Ruby object being raised as part |
| of an exception inherits from the Ruby class Exception. If so, |
| the object is simply returned. If not, then a new Ruby exception |
| object is created and that will be returned to Ruby.*/ |
| SWIGRUNTIME VALUE |
| SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) { |
| VALUE exceptionClass = getExceptionClass(); |
| if (rb_obj_is_kind_of(obj, exceptionClass)) { |
| return obj; |
| } else { |
| return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj)); |
| } |
| } |
| |
| /* Initialize Ruby runtime support */ |
| SWIGRUNTIME void |
| SWIG_Ruby_InitRuntime(void) |
| { |
| if (_mSWIG == Qnil) { |
| _mSWIG = rb_define_module("SWIG"); |
| swig_call_id = rb_intern("call"); |
| swig_arity_id = rb_intern("arity"); |
| } |
| } |
| |
| /* Define Ruby class for C type */ |
| SWIGRUNTIME void |
| SWIG_Ruby_define_class(swig_type_info *type) |
| { |
| VALUE klass; |
| char *klass_name = (char *) malloc(4 + strlen(type->name) + 1); |
| sprintf(klass_name, "TYPE%s", type->name); |
| if (NIL_P(_cSWIG_Pointer)) { |
| _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject); |
| rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new"); |
| } |
| klass = rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer); |
| free((void *) klass_name); |
| } |
| |
| /* Create a new pointer object */ |
| SWIGRUNTIME VALUE |
| SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags) |
| { |
| int own = flags & SWIG_POINTER_OWN; |
| int track; |
| char *klass_name; |
| swig_class *sklass; |
| VALUE klass; |
| VALUE obj; |
| |
| if (!ptr) |
| return Qnil; |
| |
| if (type->clientdata) { |
| sklass = (swig_class *) type->clientdata; |
| |
| /* Are we tracking this class and have we already returned this Ruby object? */ |
| track = sklass->trackObjects; |
| if (track) { |
| obj = SWIG_RubyInstanceFor(ptr); |
| |
| /* Check the object's type and make sure it has the correct type. |
| It might not in cases where methods do things like |
| downcast methods. */ |
| if (obj != Qnil) { |
| VALUE value = rb_iv_get(obj, "@__swigtype__"); |
| char* type_name = RSTRING_PTR(value); |
| |
| if (strcmp(type->name, type_name) == 0) { |
| return obj; |
| } |
| } |
| } |
| |
| /* Create a new Ruby object */ |
| obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), |
| ( own ? VOIDFUNC(sklass->destroy) : |
| (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 ) |
| ), ptr); |
| |
| /* If tracking is on for this class then track this object. */ |
| if (track) { |
| SWIG_RubyAddTracking(ptr, obj); |
| } |
| } else { |
| klass_name = (char *) malloc(4 + strlen(type->name) + 1); |
| sprintf(klass_name, "TYPE%s", type->name); |
| klass = rb_const_get(_mSWIG, rb_intern(klass_name)); |
| free((void *) klass_name); |
| obj = Data_Wrap_Struct(klass, 0, 0, ptr); |
| } |
| rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name)); |
| |
| return obj; |
| } |
| |
| /* Create a new class instance (always owned) */ |
| SWIGRUNTIME VALUE |
| SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type) |
| { |
| VALUE obj; |
| swig_class *sklass = (swig_class *) type->clientdata; |
| obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0); |
| rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name)); |
| return obj; |
| } |
| |
| /* Get type mangle from class name */ |
| SWIGRUNTIMEINLINE char * |
| SWIG_Ruby_MangleStr(VALUE obj) |
| { |
| VALUE stype = rb_iv_get(obj, "@__swigtype__"); |
| return StringValuePtr(stype); |
| } |
| |
| /* Acquire a pointer value */ |
| typedef void (*ruby_owntype)(void*); |
| |
| SWIGRUNTIME ruby_owntype |
| SWIG_Ruby_AcquirePtr(VALUE obj, ruby_owntype own) { |
| if (obj) { |
| ruby_owntype oldown = RDATA(obj)->dfree; |
| RDATA(obj)->dfree = own; |
| return oldown; |
| } else { |
| return 0; |
| } |
| } |
| |
| /* Convert a pointer value */ |
| SWIGRUNTIME int |
| SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, ruby_owntype *own) |
| { |
| char *c; |
| swig_cast_info *tc; |
| void *vptr = 0; |
| |
| /* Grab the pointer */ |
| if (NIL_P(obj)) { |
| *ptr = 0; |
| return SWIG_OK; |
| } else { |
| if (TYPE(obj) != T_DATA) { |
| return SWIG_ERROR; |
| } |
| Data_Get_Struct(obj, void, vptr); |
| } |
| |
| if (own) *own = RDATA(obj)->dfree; |
| |
| /* Check to see if the input object is giving up ownership |
| of the underlying C struct or C++ object. If so then we |
| need to reset the destructor since the Ruby object no |
| longer owns the underlying C++ object.*/ |
| if (flags & SWIG_POINTER_DISOWN) { |
| /* Is tracking on for this class? */ |
| int track = 0; |
| if (ty && ty->clientdata) { |
| swig_class *sklass = (swig_class *) ty->clientdata; |
| track = sklass->trackObjects; |
| } |
| |
| if (track) { |
| /* We are tracking objects for this class. Thus we change the destructor |
| * to SWIG_RubyRemoveTracking. This allows us to |
| * remove the mapping from the C++ to Ruby object |
| * when the Ruby object is garbage collected. If we don't |
| * do this, then it is possible we will return a reference |
| * to a Ruby object that no longer exists thereby crashing Ruby. */ |
| RDATA(obj)->dfree = SWIG_RubyRemoveTracking; |
| } else { |
| RDATA(obj)->dfree = 0; |
| } |
| } |
| |
| /* Do type-checking if type info was provided */ |
| if (ty) { |
| if (ty->clientdata) { |
| if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) { |
| if (vptr == 0) { |
| /* The object has already been deleted */ |
| return SWIG_ObjectPreviouslyDeletedError; |
| } |
| *ptr = vptr; |
| return SWIG_OK; |
| } |
| } |
| if ((c = SWIG_MangleStr(obj)) == NULL) { |
| return SWIG_ERROR; |
| } |
| tc = SWIG_TypeCheck(c, ty); |
| if (!tc) { |
| return SWIG_ERROR; |
| } else { |
| int newmemory = 0; |
| *ptr = SWIG_TypeCast(tc, vptr, &newmemory); |
| assert(!newmemory); /* newmemory handling not yet implemented */ |
| } |
| } else { |
| *ptr = vptr; |
| } |
| |
| return SWIG_OK; |
| } |
| |
| /* Check convert */ |
| SWIGRUNTIMEINLINE int |
| SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty) |
| { |
| char *c = SWIG_MangleStr(obj); |
| if (!c) return 0; |
| return SWIG_TypeCheck(c,ty) != 0; |
| } |
| |
| SWIGRUNTIME VALUE |
| SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) { |
| char result[1024]; |
| char *r = result; |
| if ((2*sz + 1 + strlen(type->name)) > 1000) return 0; |
| *(r++) = '_'; |
| r = SWIG_PackData(r, ptr, sz); |
| strcpy(r, type->name); |
| return rb_str_new2(result); |
| } |
| |
| /* Convert a packed value value */ |
| SWIGRUNTIME int |
| SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) { |
| swig_cast_info *tc; |
| const char *c; |
| |
| if (TYPE(obj) != T_STRING) goto type_error; |
| c = StringValuePtr(obj); |
| /* Pointer values must start with leading underscore */ |
| if (*c != '_') goto type_error; |
| c++; |
| c = SWIG_UnpackData(c, ptr, sz); |
| if (ty) { |
| tc = SWIG_TypeCheck(c, ty); |
| if (!tc) goto type_error; |
| } |
| return SWIG_OK; |
| |
| type_error: |
| return SWIG_ERROR; |
| } |
| |
| SWIGRUNTIME swig_module_info * |
| SWIG_Ruby_GetModule(void) |
| { |
| VALUE pointer; |
| swig_module_info *ret = 0; |
| VALUE verbose = rb_gv_get("VERBOSE"); |
| |
| /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */ |
| rb_gv_set("VERBOSE", Qfalse); |
| |
| /* first check if pointer already created */ |
| pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME); |
| if (pointer != Qnil) { |
| Data_Get_Struct(pointer, swig_module_info, ret); |
| } |
| |
| /* reinstate warnings */ |
| rb_gv_set("VERBOSE", verbose); |
| return ret; |
| } |
| |
| SWIGRUNTIME void |
| SWIG_Ruby_SetModule(swig_module_info *pointer) |
| { |
| /* register a new class */ |
| VALUE cl = rb_define_class("swig_runtime_data", rb_cObject); |
| /* create and store the structure pointer to a global variable */ |
| swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer); |
| rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer); |
| } |
| |
| /* This function can be used to check whether a proc or method or similarly |
| callable function has been passed. Usually used in a %typecheck, like: |
| |
| %typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) { |
| $result = SWIG_Ruby_isCallable( $input ); |
| } |
| */ |
| SWIGINTERN |
| int SWIG_Ruby_isCallable( VALUE proc ) |
| { |
| if ( rb_respond_to( proc, swig_call_id ) == Qtrue ) |
| return 1; |
| return 0; |
| } |
| |
| /* This function can be used to check the arity (number of arguments) |
| a proc or method can take. Usually used in a %typecheck. |
| Valid arities will be that equal to minimal or those < 0 |
| which indicate a variable number of parameters at the end. |
| */ |
| SWIGINTERN |
| int SWIG_Ruby_arity( VALUE proc, int minimal ) |
| { |
| if ( rb_respond_to( proc, swig_arity_id ) == Qtrue ) |
| { |
| VALUE num = rb_funcall( proc, swig_arity_id, 0 ); |
| int arity = NUM2INT(num); |
| if ( arity < 0 && (arity+1) < -minimal ) return 1; |
| if ( arity == minimal ) return 1; |
| return 1; |
| } |
| return 0; |
| } |
| |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| |
| |
| #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) |
| |
| #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else |
| |
| |
| |
| #define SWIG_exception(code, msg) do { SWIG_Error(code, msg);; } while(0) |
| |
| |
| /* -------- TYPES TABLE (BEGIN) -------- */ |
| |
| #define SWIGTYPE_p_char swig_types[0] |
| #define SWIGTYPE_p_marisa__Key swig_types[1] |
| #define SWIGTYPE_p_marisa_swig__Agent swig_types[2] |
| #define SWIGTYPE_p_marisa_swig__Key swig_types[3] |
| #define SWIGTYPE_p_marisa_swig__Keyset swig_types[4] |
| #define SWIGTYPE_p_marisa_swig__Query swig_types[5] |
| #define SWIGTYPE_p_marisa_swig__Trie swig_types[6] |
| #define SWIGTYPE_p_p_char swig_types[7] |
| #define SWIGTYPE_p_std__size_t swig_types[8] |
| static swig_type_info *swig_types[10]; |
| static swig_module_info swig_module = {swig_types, 9, 0, 0, 0, 0}; |
| #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) |
| #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) |
| |
| /* -------- TYPES TABLE (END) -------- */ |
| |
| #define SWIG_init Init_marisa |
| #define SWIG_name "Marisa" |
| |
| static VALUE mMarisa; |
| |
| #define SWIG_RUBY_THREAD_BEGIN_BLOCK |
| #define SWIG_RUBY_THREAD_END_BLOCK |
| |
| |
| #define SWIGVERSION 0x010340 |
| #define SWIG_VERSION SWIGVERSION |
| |
| |
| #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) |
| #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) |
| |
| |
| #include <stdexcept> |
| |
| |
| #include "marisa-swig.h" |
| |
| |
| #include <limits.h> |
| #if !defined(SWIG_NO_LLONG_MAX) |
| # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__) |
| # define LLONG_MAX __LONG_LONG_MAX__ |
| # define LLONG_MIN (-LLONG_MAX - 1LL) |
| # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL) |
| # endif |
| #endif |
| |
| |
| #define SWIG_From_long LONG2NUM |
| |
| |
| SWIGINTERNINLINE VALUE |
| SWIG_From_int (int value) |
| { |
| return SWIG_From_long (value); |
| } |
| |
| |
| SWIGINTERN swig_type_info* |
| SWIG_pchar_descriptor(void) |
| { |
| static int init = 0; |
| static swig_type_info* info = 0; |
| if (!init) { |
| info = SWIG_TypeQuery("_p_char"); |
| init = 1; |
| } |
| return info; |
| } |
| |
| |
| SWIGINTERNINLINE VALUE |
| SWIG_FromCharPtrAndSize(const char* carray, size_t size) |
| { |
| if (carray) { |
| if (size > LONG_MAX) { |
| swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); |
| return pchar_descriptor ? |
| SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : Qnil; |
| } else { |
| return rb_str_new(carray, static_cast< long >(size)); |
| } |
| } else { |
| return Qnil; |
| } |
| } |
| |
| |
| SWIGINTERNINLINE VALUE |
| SWIG_From_unsigned_SS_long (unsigned long value) |
| { |
| return ULONG2NUM(value); |
| } |
| |
| |
| SWIGINTERNINLINE VALUE |
| SWIG_From_size_t (size_t value) |
| { |
| return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value)); |
| } |
| |
| |
| #define SWIG_From_double rb_float_new |
| |
| |
| SWIGINTERNINLINE VALUE |
| SWIG_From_float (float value) |
| { |
| return SWIG_From_double (value); |
| } |
| |
| |
| SWIGINTERN int |
| SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc) |
| { |
| if (TYPE(obj) == T_STRING) { |
| #if defined(StringValuePtr) |
| char *cstr = StringValuePtr(obj); |
| #else |
| char *cstr = STR2CSTR(obj); |
| #endif |
| size_t size = RSTRING_LEN(obj) + 1; |
| if (cptr) { |
| if (alloc) { |
| if (*alloc == SWIG_NEWOBJ) { |
| *cptr = reinterpret_cast< char* >(memcpy((new char[size]), cstr, sizeof(char)*(size))); |
| } else { |
| *cptr = cstr; |
| *alloc = SWIG_OLDOBJ; |
| } |
| } |
| } |
| if (psize) *psize = size; |
| return SWIG_OK; |
| } else { |
| swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); |
| if (pchar_descriptor) { |
| void* vptr = 0; |
| if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) { |
| if (cptr) *cptr = (char *)vptr; |
| if (psize) *psize = vptr ? (strlen((char*)vptr) + 1) : 0; |
| if (alloc) *alloc = SWIG_OLDOBJ; |
| return SWIG_OK; |
| } |
| } |
| } |
| return SWIG_TypeError; |
| } |
| |
| |
| #include <float.h> |
| |
| |
| SWIGINTERN VALUE |
| SWIG_ruby_failed(void) |
| { |
| return Qnil; |
| } |
| |
| |
| /*@SWIG:/usr/share/swig1.3/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/ |
| SWIGINTERN VALUE SWIG_AUX_NUM2DBL(VALUE *args) |
| { |
| VALUE obj = args[0]; |
| VALUE type = TYPE(obj); |
| double *res = (double *)(args[1]); |
| *res = NUM2DBL(obj); |
| return obj; |
| } |
| /*@SWIG@*/ |
| |
| SWIGINTERN int |
| SWIG_AsVal_double (VALUE obj, double *val) |
| { |
| VALUE type = TYPE(obj); |
| if ((type == T_FLOAT) || (type == T_FIXNUM) || (type == T_BIGNUM)) { |
| double v; |
| VALUE a[2]; |
| a[0] = obj; |
| a[1] = (VALUE)(&v); |
| if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2DBL), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) { |
| if (val) *val = v; |
| return SWIG_OK; |
| } |
| } |
| return SWIG_TypeError; |
| } |
| |
| |
| SWIGINTERN int |
| SWIG_AsVal_float (VALUE obj, float *val) |
| { |
| double v; |
| int res = SWIG_AsVal_double (obj, &v); |
| if (SWIG_IsOK(res)) { |
| if ((v < -FLT_MAX || v > FLT_MAX)) { |
| return SWIG_OverflowError; |
| } else { |
| if (val) *val = static_cast< float >(v); |
| } |
| } |
| return res; |
| } |
| |
| |
| |
| |
| |
| /*@SWIG:/usr/share/swig1.3/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/ |
| SWIGINTERN VALUE SWIG_AUX_NUM2ULONG(VALUE *args) |
| { |
| VALUE obj = args[0]; |
| VALUE type = TYPE(obj); |
| unsigned long *res = (unsigned long *)(args[1]); |
| *res = type == T_FIXNUM ? NUM2ULONG(obj) : rb_big2ulong(obj); |
| return obj; |
| } |
| /*@SWIG@*/ |
| |
| SWIGINTERN int |
| SWIG_AsVal_unsigned_SS_long (VALUE obj, unsigned long *val) |
| { |
| VALUE type = TYPE(obj); |
| if ((type == T_FIXNUM) || (type == T_BIGNUM)) { |
| unsigned long v; |
| VALUE a[2]; |
| a[0] = obj; |
| a[1] = (VALUE)(&v); |
| if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2ULONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) { |
| if (val) *val = v; |
| return SWIG_OK; |
| } |
| } |
| return SWIG_TypeError; |
| } |
| |
| |
| SWIGINTERNINLINE int |
| SWIG_AsVal_size_t (VALUE obj, size_t *val) |
| { |
| unsigned long v; |
| int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0); |
| if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v); |
| return res; |
| } |
| |
| |
| SWIGINTERNINLINE VALUE |
| SWIG_From_bool (bool value) |
| { |
| return value ? Qtrue : Qfalse; |
| } |
| |
| |
| /*@SWIG:/usr/share/swig1.3/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/ |
| SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE *args) |
| { |
| VALUE obj = args[0]; |
| VALUE type = TYPE(obj); |
| long *res = (long *)(args[1]); |
| *res = type == T_FIXNUM ? NUM2LONG(obj) : rb_big2long(obj); |
| return obj; |
| } |
| /*@SWIG@*/ |
| |
| SWIGINTERN int |
| SWIG_AsVal_long (VALUE obj, long* val) |
| { |
| VALUE type = TYPE(obj); |
| if ((type == T_FIXNUM) || (type == T_BIGNUM)) { |
| long v; |
| VALUE a[2]; |
| a[0] = obj; |
| a[1] = (VALUE)(&v); |
| if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2LONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) { |
| if (val) *val = v; |
| return SWIG_OK; |
| } |
| } |
| return SWIG_TypeError; |
| } |
| |
| |
| SWIGINTERN int |
| SWIG_AsVal_int (VALUE obj, int *val) |
| { |
| long v; |
| int res = SWIG_AsVal_long (obj, &v); |
| if (SWIG_IsOK(res)) { |
| if ((v < INT_MIN || v > INT_MAX)) { |
| return SWIG_OverflowError; |
| } else { |
| if (val) *val = static_cast< int >(v); |
| } |
| } |
| return res; |
| } |
| |
| swig_class SwigClassKey; |
| |
| SWIGINTERN VALUE |
| _wrap_Key_str(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Key *arg1 = (marisa_swig::Key *) 0 ; |
| char **arg2 = (char **) 0 ; |
| std::size_t *arg3 = (std::size_t *) 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| char *temp2 = 0 ; |
| std::size_t tempn2 ; |
| VALUE vresult = Qnil; |
| |
| arg2 = &temp2; arg3 = &tempn2; |
| if ((argc < 0) || (argc > 0)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Key, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Key const *","str", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Key * >(argp1); |
| { |
| try { |
| ((marisa_swig::Key const *)arg1)->str((char const **)arg2,arg3); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| if (*arg2) { |
| vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_FromCharPtrAndSize(*arg2,*arg3)); |
| ; |
| } |
| return vresult; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Key_id(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Key *arg1 = (marisa_swig::Key *) 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| std::size_t result; |
| VALUE vresult = Qnil; |
| |
| if ((argc < 0) || (argc > 0)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Key, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Key const *","id", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Key * >(argp1); |
| { |
| try { |
| result = ((marisa_swig::Key const *)arg1)->id(); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| vresult = SWIG_From_size_t(static_cast< size_t >(result)); |
| return vresult; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Key_weight(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Key *arg1 = (marisa_swig::Key *) 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| float result; |
| VALUE vresult = Qnil; |
| |
| if ((argc < 0) || (argc > 0)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Key, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Key const *","weight", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Key * >(argp1); |
| { |
| try { |
| result = (float)((marisa_swig::Key const *)arg1)->weight(); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| vresult = SWIG_From_float(static_cast< float >(result)); |
| return vresult; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN void |
| free_marisa_swig_Key(marisa_swig::Key *arg1) { |
| delete arg1; |
| } |
| |
| swig_class SwigClassQuery; |
| |
| SWIGINTERN VALUE |
| _wrap_Query_str(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Query *arg1 = (marisa_swig::Query *) 0 ; |
| char **arg2 = (char **) 0 ; |
| std::size_t *arg3 = (std::size_t *) 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| char *temp2 = 0 ; |
| std::size_t tempn2 ; |
| VALUE vresult = Qnil; |
| |
| arg2 = &temp2; arg3 = &tempn2; |
| if ((argc < 0) || (argc > 0)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Query, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Query const *","str", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Query * >(argp1); |
| { |
| try { |
| ((marisa_swig::Query const *)arg1)->str((char const **)arg2,arg3); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| if (*arg2) { |
| vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_FromCharPtrAndSize(*arg2,*arg3)); |
| ; |
| } |
| return vresult; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Query_id(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Query *arg1 = (marisa_swig::Query *) 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| std::size_t result; |
| VALUE vresult = Qnil; |
| |
| if ((argc < 0) || (argc > 0)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Query, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Query const *","id", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Query * >(argp1); |
| { |
| try { |
| result = ((marisa_swig::Query const *)arg1)->id(); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| vresult = SWIG_From_size_t(static_cast< size_t >(result)); |
| return vresult; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN void |
| free_marisa_swig_Query(marisa_swig::Query *arg1) { |
| delete arg1; |
| } |
| |
| swig_class SwigClassKeyset; |
| |
| #ifdef HAVE_RB_DEFINE_ALLOC_FUNC |
| SWIGINTERN VALUE |
| _wrap_Keyset_allocate(VALUE self) { |
| #else |
| SWIGINTERN VALUE |
| _wrap_Keyset_allocate(int argc, VALUE *argv, VALUE self) { |
| #endif |
| |
| |
| VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_marisa_swig__Keyset); |
| #ifndef HAVE_RB_DEFINE_ALLOC_FUNC |
| rb_obj_call_init(vresult, argc, argv); |
| #endif |
| return vresult; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_new_Keyset(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Keyset *result = 0 ; |
| |
| if ((argc < 0) || (argc > 0)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; |
| } |
| { |
| try { |
| result = (marisa_swig::Keyset *)new marisa_swig::Keyset(); |
| DATA_PTR(self) = result; |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| return self; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN void |
| free_marisa_swig_Keyset(marisa_swig::Keyset *arg1) { |
| delete arg1; |
| } |
| |
| SWIGINTERN VALUE |
| _wrap_Keyset_push_back__SWIG_0(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Keyset *arg1 = (marisa_swig::Keyset *) 0 ; |
| marisa::Key *arg2 = 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| void *argp2 ; |
| int res2 = 0 ; |
| |
| if ((argc < 1) || (argc > 1)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Keyset, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Keyset *","push_back", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Keyset * >(argp1); |
| res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_marisa__Key, 0 ); |
| if (!SWIG_IsOK(res2)) { |
| SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "marisa::Key const &","push_back", 2, argv[0] )); |
| } |
| if (!argp2) { |
| SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "marisa::Key const &","push_back", 2, argv[0])); |
| } |
| arg2 = reinterpret_cast< marisa::Key * >(argp2); |
| { |
| try { |
| (arg1)->push_back((marisa::Key const &)*arg2); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| return Qnil; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Keyset_push_back__SWIG_1(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Keyset *arg1 = (marisa_swig::Keyset *) 0 ; |
| char *arg2 = (char *) 0 ; |
| std::size_t arg3 ; |
| float arg4 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| int res2 ; |
| char *buf2 = 0 ; |
| size_t size2 = 0 ; |
| int alloc2 = 0 ; |
| float val4 ; |
| int ecode4 = 0 ; |
| |
| if ((argc < 2) || (argc > 2)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Keyset, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Keyset *","push_back", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Keyset * >(argp1); |
| res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, &size2, &alloc2); |
| if (!SWIG_IsOK(res2)) { |
| SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","push_back", 2, argv[0] )); |
| } |
| arg2 = reinterpret_cast< char * >(buf2); |
| arg3 = static_cast< std::size_t >(size2 - 1); |
| ecode4 = SWIG_AsVal_float(argv[1], &val4); |
| if (!SWIG_IsOK(ecode4)) { |
| SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "float","push_back", 4, argv[1] )); |
| } |
| arg4 = static_cast< float >(val4); |
| { |
| try { |
| (arg1)->push_back((char const *)arg2,arg3,arg4); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| if (alloc2 == SWIG_NEWOBJ) delete[] buf2; |
| return Qnil; |
| fail: |
| if (alloc2 == SWIG_NEWOBJ) delete[] buf2; |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Keyset_push_back__SWIG_2(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Keyset *arg1 = (marisa_swig::Keyset *) 0 ; |
| char *arg2 = (char *) 0 ; |
| std::size_t arg3 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| int res2 ; |
| char *buf2 = 0 ; |
| size_t size2 = 0 ; |
| int alloc2 = 0 ; |
| |
| if ((argc < 1) || (argc > 1)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Keyset, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Keyset *","push_back", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Keyset * >(argp1); |
| res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, &size2, &alloc2); |
| if (!SWIG_IsOK(res2)) { |
| SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","push_back", 2, argv[0] )); |
| } |
| arg2 = reinterpret_cast< char * >(buf2); |
| arg3 = static_cast< std::size_t >(size2 - 1); |
| { |
| try { |
| (arg1)->push_back((char const *)arg2,arg3); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| if (alloc2 == SWIG_NEWOBJ) delete[] buf2; |
| return Qnil; |
| fail: |
| if (alloc2 == SWIG_NEWOBJ) delete[] buf2; |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE _wrap_Keyset_push_back(int nargs, VALUE *args, VALUE self) { |
| int argc; |
| VALUE argv[4]; |
| int ii; |
| |
| argc = nargs + 1; |
| argv[0] = self; |
| if (argc > 4) SWIG_fail; |
| for (ii = 1; (ii < argc); ++ii) { |
| argv[ii] = args[ii-1]; |
| } |
| if (argc == 2) { |
| int _v; |
| void *vptr = 0; |
| int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_marisa_swig__Keyset, 0); |
| _v = SWIG_CheckState(res); |
| if (_v) { |
| void *vptr = 0; |
| int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_marisa__Key, 0); |
| _v = SWIG_CheckState(res); |
| if (_v) { |
| return _wrap_Keyset_push_back__SWIG_0(nargs, args, self); |
| } |
| } |
| } |
| if (argc == 2) { |
| int _v; |
| void *vptr = 0; |
| int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_marisa_swig__Keyset, 0); |
| _v = SWIG_CheckState(res); |
| if (_v) { |
| int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); |
| _v = SWIG_CheckState(res); |
| if (_v) { |
| if (argc <= 2) { |
| return _wrap_Keyset_push_back__SWIG_2(nargs, args, self); |
| } |
| { |
| int res = SWIG_AsVal_size_t(argv[2], NULL); |
| _v = SWIG_CheckState(res); |
| } |
| if (_v) { |
| return _wrap_Keyset_push_back__SWIG_2(nargs, args, self); |
| } |
| } |
| } |
| } |
| if (argc == 3) { |
| int _v; |
| void *vptr = 0; |
| int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_marisa_swig__Keyset, 0); |
| _v = SWIG_CheckState(res); |
| if (_v) { |
| int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); |
| _v = SWIG_CheckState(res); |
| if (_v) { |
| { |
| int res = SWIG_AsVal_float(argv[2], NULL); |
| _v = SWIG_CheckState(res); |
| } |
| if (_v) { |
| return _wrap_Keyset_push_back__SWIG_1(nargs, args, self); |
| } |
| } |
| } |
| } |
| |
| fail: |
| Ruby_Format_OverloadedError( argc, 4, "Keyset.push_back", |
| " void Keyset.push_back(marisa::Key const &key)\n" |
| " void Keyset.push_back(char const *ptr, std::size_t length, float weight)\n" |
| " void Keyset.push_back(char const *ptr, std::size_t length)\n"); |
| |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Keyset_key(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Keyset *arg1 = (marisa_swig::Keyset *) 0 ; |
| std::size_t arg2 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| size_t val2 ; |
| int ecode2 = 0 ; |
| marisa_swig::Key *result = 0 ; |
| VALUE vresult = Qnil; |
| |
| if ((argc < 1) || (argc > 1)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Keyset, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Keyset const *","key", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Keyset * >(argp1); |
| ecode2 = SWIG_AsVal_size_t(argv[0], &val2); |
| if (!SWIG_IsOK(ecode2)) { |
| SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::size_t","key", 2, argv[0] )); |
| } |
| arg2 = static_cast< std::size_t >(val2); |
| { |
| try { |
| result = (marisa_swig::Key *) &((marisa_swig::Keyset const *)arg1)->key(arg2); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_marisa_swig__Key, 0 | 0 ); |
| return vresult; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Keyset_key_str(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Keyset *arg1 = (marisa_swig::Keyset *) 0 ; |
| std::size_t arg2 ; |
| char **arg3 = (char **) 0 ; |
| std::size_t *arg4 = (std::size_t *) 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| size_t val2 ; |
| int ecode2 = 0 ; |
| char *temp3 = 0 ; |
| std::size_t tempn3 ; |
| VALUE vresult = Qnil; |
| |
| arg3 = &temp3; arg4 = &tempn3; |
| if ((argc < 1) || (argc > 1)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Keyset, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Keyset const *","key_str", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Keyset * >(argp1); |
| ecode2 = SWIG_AsVal_size_t(argv[0], &val2); |
| if (!SWIG_IsOK(ecode2)) { |
| SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::size_t","key_str", 2, argv[0] )); |
| } |
| arg2 = static_cast< std::size_t >(val2); |
| { |
| try { |
| ((marisa_swig::Keyset const *)arg1)->key_str(arg2,(char const **)arg3,arg4); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| if (*arg3) { |
| vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_FromCharPtrAndSize(*arg3,*arg4)); |
| ; |
| } |
| return vresult; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Keyset_key_id(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Keyset *arg1 = (marisa_swig::Keyset *) 0 ; |
| std::size_t arg2 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| size_t val2 ; |
| int ecode2 = 0 ; |
| std::size_t result; |
| VALUE vresult = Qnil; |
| |
| if ((argc < 1) || (argc > 1)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Keyset, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Keyset const *","key_id", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Keyset * >(argp1); |
| ecode2 = SWIG_AsVal_size_t(argv[0], &val2); |
| if (!SWIG_IsOK(ecode2)) { |
| SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::size_t","key_id", 2, argv[0] )); |
| } |
| arg2 = static_cast< std::size_t >(val2); |
| { |
| try { |
| result = ((marisa_swig::Keyset const *)arg1)->key_id(arg2); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| vresult = SWIG_From_size_t(static_cast< size_t >(result)); |
| return vresult; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Keyset_num_keys(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Keyset *arg1 = (marisa_swig::Keyset *) 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| std::size_t result; |
| VALUE vresult = Qnil; |
| |
| if ((argc < 0) || (argc > 0)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Keyset, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Keyset const *","num_keys", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Keyset * >(argp1); |
| { |
| try { |
| result = ((marisa_swig::Keyset const *)arg1)->num_keys(); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| vresult = SWIG_From_size_t(static_cast< size_t >(result)); |
| return vresult; |
| fail: |
| return Qnil; |
| } |
| |
| |
| |
| /* |
| Document-method: Marisa::Keyset.empty |
| |
| call-seq: |
| empty -> bool |
| |
| Check if Keyset is empty. |
| */ |
| SWIGINTERN VALUE |
| _wrap_Keyset_empty(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Keyset *arg1 = (marisa_swig::Keyset *) 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| bool result; |
| VALUE vresult = Qnil; |
| |
| if ((argc < 0) || (argc > 0)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Keyset, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Keyset const *","empty", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Keyset * >(argp1); |
| { |
| try { |
| result = (bool)((marisa_swig::Keyset const *)arg1)->empty(); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| vresult = SWIG_From_bool(static_cast< bool >(result)); |
| return vresult; |
| fail: |
| return Qnil; |
| } |
| |
| |
| |
| /* |
| Document-method: Marisa::Keyset.size |
| |
| call-seq: |
| size -> std::size_t |
| |
| Size or Length of the Keyset. |
| */ |
| SWIGINTERN VALUE |
| _wrap_Keyset_size(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Keyset *arg1 = (marisa_swig::Keyset *) 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| std::size_t result; |
| VALUE vresult = Qnil; |
| |
| if ((argc < 0) || (argc > 0)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Keyset, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Keyset const *","size", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Keyset * >(argp1); |
| { |
| try { |
| result = ((marisa_swig::Keyset const *)arg1)->size(); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| vresult = SWIG_From_size_t(static_cast< size_t >(result)); |
| return vresult; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Keyset_total_length(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Keyset *arg1 = (marisa_swig::Keyset *) 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| std::size_t result; |
| VALUE vresult = Qnil; |
| |
| if ((argc < 0) || (argc > 0)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Keyset, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Keyset const *","total_length", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Keyset * >(argp1); |
| { |
| try { |
| result = ((marisa_swig::Keyset const *)arg1)->total_length(); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| vresult = SWIG_From_size_t(static_cast< size_t >(result)); |
| return vresult; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Keyset_reset(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Keyset *arg1 = (marisa_swig::Keyset *) 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| |
| if ((argc < 0) || (argc > 0)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Keyset, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Keyset *","reset", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Keyset * >(argp1); |
| { |
| try { |
| (arg1)->reset(); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| return Qnil; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Keyset_clear(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Keyset *arg1 = (marisa_swig::Keyset *) 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| |
| if ((argc < 0) || (argc > 0)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Keyset, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Keyset *","clear", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Keyset * >(argp1); |
| { |
| try { |
| (arg1)->clear(); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| return Qnil; |
| fail: |
| return Qnil; |
| } |
| |
| |
| swig_class SwigClassAgent; |
| |
| #ifdef HAVE_RB_DEFINE_ALLOC_FUNC |
| SWIGINTERN VALUE |
| _wrap_Agent_allocate(VALUE self) { |
| #else |
| SWIGINTERN VALUE |
| _wrap_Agent_allocate(int argc, VALUE *argv, VALUE self) { |
| #endif |
| |
| |
| VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_marisa_swig__Agent); |
| #ifndef HAVE_RB_DEFINE_ALLOC_FUNC |
| rb_obj_call_init(vresult, argc, argv); |
| #endif |
| return vresult; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_new_Agent(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Agent *result = 0 ; |
| |
| if ((argc < 0) || (argc > 0)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; |
| } |
| { |
| try { |
| result = (marisa_swig::Agent *)new marisa_swig::Agent(); |
| DATA_PTR(self) = result; |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| return self; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN void |
| free_marisa_swig_Agent(marisa_swig::Agent *arg1) { |
| delete arg1; |
| } |
| |
| SWIGINTERN VALUE |
| _wrap_Agent_set_query__SWIG_0(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Agent *arg1 = (marisa_swig::Agent *) 0 ; |
| char *arg2 = (char *) 0 ; |
| std::size_t arg3 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| int res2 ; |
| char *buf2 = 0 ; |
| size_t size2 = 0 ; |
| int alloc2 = 0 ; |
| |
| if ((argc < 1) || (argc > 1)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Agent, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Agent *","set_query", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Agent * >(argp1); |
| res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, &size2, &alloc2); |
| if (!SWIG_IsOK(res2)) { |
| SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","set_query", 2, argv[0] )); |
| } |
| arg2 = reinterpret_cast< char * >(buf2); |
| arg3 = static_cast< std::size_t >(size2 - 1); |
| { |
| try { |
| (arg1)->set_query((char const *)arg2,arg3); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| if (alloc2 == SWIG_NEWOBJ) delete[] buf2; |
| return Qnil; |
| fail: |
| if (alloc2 == SWIG_NEWOBJ) delete[] buf2; |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Agent_set_query__SWIG_1(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Agent *arg1 = (marisa_swig::Agent *) 0 ; |
| std::size_t arg2 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| size_t val2 ; |
| int ecode2 = 0 ; |
| |
| if ((argc < 1) || (argc > 1)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Agent, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Agent *","set_query", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Agent * >(argp1); |
| ecode2 = SWIG_AsVal_size_t(argv[0], &val2); |
| if (!SWIG_IsOK(ecode2)) { |
| SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::size_t","set_query", 2, argv[0] )); |
| } |
| arg2 = static_cast< std::size_t >(val2); |
| { |
| try { |
| (arg1)->set_query(arg2); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| return Qnil; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE _wrap_Agent_set_query(int nargs, VALUE *args, VALUE self) { |
| int argc; |
| VALUE argv[3]; |
| int ii; |
| |
| argc = nargs + 1; |
| argv[0] = self; |
| if (argc > 3) SWIG_fail; |
| for (ii = 1; (ii < argc); ++ii) { |
| argv[ii] = args[ii-1]; |
| } |
| if (argc == 2) { |
| int _v; |
| void *vptr = 0; |
| int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_marisa_swig__Agent, 0); |
| _v = SWIG_CheckState(res); |
| if (_v) { |
| { |
| int res = SWIG_AsVal_size_t(argv[1], NULL); |
| _v = SWIG_CheckState(res); |
| } |
| if (_v) { |
| return _wrap_Agent_set_query__SWIG_1(nargs, args, self); |
| } |
| } |
| } |
| if (argc == 2) { |
| int _v; |
| void *vptr = 0; |
| int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_marisa_swig__Agent, 0); |
| _v = SWIG_CheckState(res); |
| if (_v) { |
| int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); |
| _v = SWIG_CheckState(res); |
| if (_v) { |
| if (argc <= 2) { |
| return _wrap_Agent_set_query__SWIG_0(nargs, args, self); |
| } |
| { |
| int res = SWIG_AsVal_size_t(argv[2], NULL); |
| _v = SWIG_CheckState(res); |
| } |
| if (_v) { |
| return _wrap_Agent_set_query__SWIG_0(nargs, args, self); |
| } |
| } |
| } |
| } |
| |
| fail: |
| Ruby_Format_OverloadedError( argc, 3, "Agent.set_query", |
| " void Agent.set_query(char const *ptr, std::size_t length)\n" |
| " void Agent.set_query(std::size_t id)\n"); |
| |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Agent_key(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Agent *arg1 = (marisa_swig::Agent *) 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| marisa_swig::Key *result = 0 ; |
| VALUE vresult = Qnil; |
| |
| if ((argc < 0) || (argc > 0)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Agent, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Agent const *","key", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Agent * >(argp1); |
| { |
| try { |
| result = (marisa_swig::Key *) &((marisa_swig::Agent const *)arg1)->key(); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_marisa_swig__Key, 0 | 0 ); |
| return vresult; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Agent_query(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Agent *arg1 = (marisa_swig::Agent *) 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| marisa_swig::Query *result = 0 ; |
| VALUE vresult = Qnil; |
| |
| if ((argc < 0) || (argc > 0)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Agent, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Agent const *","query", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Agent * >(argp1); |
| { |
| try { |
| result = (marisa_swig::Query *) &((marisa_swig::Agent const *)arg1)->query(); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_marisa_swig__Query, 0 | 0 ); |
| return vresult; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Agent_key_str(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Agent *arg1 = (marisa_swig::Agent *) 0 ; |
| char **arg2 = (char **) 0 ; |
| std::size_t *arg3 = (std::size_t *) 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| char *temp2 = 0 ; |
| std::size_t tempn2 ; |
| VALUE vresult = Qnil; |
| |
| arg2 = &temp2; arg3 = &tempn2; |
| if ((argc < 0) || (argc > 0)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Agent, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Agent const *","key_str", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Agent * >(argp1); |
| { |
| try { |
| ((marisa_swig::Agent const *)arg1)->key_str((char const **)arg2,arg3); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| if (*arg2) { |
| vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_FromCharPtrAndSize(*arg2,*arg3)); |
| ; |
| } |
| return vresult; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Agent_key_id(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Agent *arg1 = (marisa_swig::Agent *) 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| std::size_t result; |
| VALUE vresult = Qnil; |
| |
| if ((argc < 0) || (argc > 0)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Agent, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Agent const *","key_id", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Agent * >(argp1); |
| { |
| try { |
| result = ((marisa_swig::Agent const *)arg1)->key_id(); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| vresult = SWIG_From_size_t(static_cast< size_t >(result)); |
| return vresult; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Agent_query_str(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Agent *arg1 = (marisa_swig::Agent *) 0 ; |
| char **arg2 = (char **) 0 ; |
| std::size_t *arg3 = (std::size_t *) 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| char *temp2 = 0 ; |
| std::size_t tempn2 ; |
| VALUE vresult = Qnil; |
| |
| arg2 = &temp2; arg3 = &tempn2; |
| if ((argc < 0) || (argc > 0)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Agent, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Agent const *","query_str", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Agent * >(argp1); |
| { |
| try { |
| ((marisa_swig::Agent const *)arg1)->query_str((char const **)arg2,arg3); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| if (*arg2) { |
| vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_FromCharPtrAndSize(*arg2,*arg3)); |
| ; |
| } |
| return vresult; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Agent_query_id(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Agent *arg1 = (marisa_swig::Agent *) 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| std::size_t result; |
| VALUE vresult = Qnil; |
| |
| if ((argc < 0) || (argc > 0)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Agent, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Agent const *","query_id", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Agent * >(argp1); |
| { |
| try { |
| result = ((marisa_swig::Agent const *)arg1)->query_id(); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| vresult = SWIG_From_size_t(static_cast< size_t >(result)); |
| return vresult; |
| fail: |
| return Qnil; |
| } |
| |
| |
| swig_class SwigClassTrie; |
| |
| #ifdef HAVE_RB_DEFINE_ALLOC_FUNC |
| SWIGINTERN VALUE |
| _wrap_Trie_allocate(VALUE self) { |
| #else |
| SWIGINTERN VALUE |
| _wrap_Trie_allocate(int argc, VALUE *argv, VALUE self) { |
| #endif |
| |
| |
| VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_marisa_swig__Trie); |
| #ifndef HAVE_RB_DEFINE_ALLOC_FUNC |
| rb_obj_call_init(vresult, argc, argv); |
| #endif |
| return vresult; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_new_Trie(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Trie *result = 0 ; |
| |
| if ((argc < 0) || (argc > 0)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; |
| } |
| { |
| try { |
| result = (marisa_swig::Trie *)new marisa_swig::Trie(); |
| DATA_PTR(self) = result; |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| return self; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN void |
| free_marisa_swig_Trie(marisa_swig::Trie *arg1) { |
| delete arg1; |
| } |
| |
| SWIGINTERN VALUE |
| _wrap_Trie_build__SWIG_0(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Trie *arg1 = (marisa_swig::Trie *) 0 ; |
| marisa_swig::Keyset *arg2 = 0 ; |
| int arg3 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| void *argp2 = 0 ; |
| int res2 = 0 ; |
| int val3 ; |
| int ecode3 = 0 ; |
| |
| if ((argc < 2) || (argc > 2)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Trie, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Trie *","build", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Trie * >(argp1); |
| res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_marisa_swig__Keyset, 0 ); |
| if (!SWIG_IsOK(res2)) { |
| SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "marisa_swig::Keyset &","build", 2, argv[0] )); |
| } |
| if (!argp2) { |
| SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "marisa_swig::Keyset &","build", 2, argv[0])); |
| } |
| arg2 = reinterpret_cast< marisa_swig::Keyset * >(argp2); |
| ecode3 = SWIG_AsVal_int(argv[1], &val3); |
| if (!SWIG_IsOK(ecode3)) { |
| SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","build", 3, argv[1] )); |
| } |
| arg3 = static_cast< int >(val3); |
| { |
| try { |
| (arg1)->build(*arg2,arg3); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| return Qnil; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Trie_build__SWIG_1(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Trie *arg1 = (marisa_swig::Trie *) 0 ; |
| marisa_swig::Keyset *arg2 = 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| void *argp2 = 0 ; |
| int res2 = 0 ; |
| |
| if ((argc < 1) || (argc > 1)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Trie, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Trie *","build", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Trie * >(argp1); |
| res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_marisa_swig__Keyset, 0 ); |
| if (!SWIG_IsOK(res2)) { |
| SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "marisa_swig::Keyset &","build", 2, argv[0] )); |
| } |
| if (!argp2) { |
| SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "marisa_swig::Keyset &","build", 2, argv[0])); |
| } |
| arg2 = reinterpret_cast< marisa_swig::Keyset * >(argp2); |
| { |
| try { |
| (arg1)->build(*arg2); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| return Qnil; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE _wrap_Trie_build(int nargs, VALUE *args, VALUE self) { |
| int argc; |
| VALUE argv[4]; |
| int ii; |
| |
| argc = nargs + 1; |
| argv[0] = self; |
| if (argc > 4) SWIG_fail; |
| for (ii = 1; (ii < argc); ++ii) { |
| argv[ii] = args[ii-1]; |
| } |
| if (argc == 2) { |
| int _v; |
| void *vptr = 0; |
| int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_marisa_swig__Trie, 0); |
| _v = SWIG_CheckState(res); |
| if (_v) { |
| void *vptr = 0; |
| int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_marisa_swig__Keyset, 0); |
| _v = SWIG_CheckState(res); |
| if (_v) { |
| return _wrap_Trie_build__SWIG_1(nargs, args, self); |
| } |
| } |
| } |
| if (argc == 3) { |
| int _v; |
| void *vptr = 0; |
| int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_marisa_swig__Trie, 0); |
| _v = SWIG_CheckState(res); |
| if (_v) { |
| void *vptr = 0; |
| int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_marisa_swig__Keyset, 0); |
| _v = SWIG_CheckState(res); |
| if (_v) { |
| { |
| int res = SWIG_AsVal_int(argv[2], NULL); |
| _v = SWIG_CheckState(res); |
| } |
| if (_v) { |
| return _wrap_Trie_build__SWIG_0(nargs, args, self); |
| } |
| } |
| } |
| } |
| |
| fail: |
| Ruby_Format_OverloadedError( argc, 4, "Trie.build", |
| " void Trie.build(marisa_swig::Keyset &keyset, int config_flags)\n" |
| " void Trie.build(marisa_swig::Keyset &keyset)\n"); |
| |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Trie_mmap(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Trie *arg1 = (marisa_swig::Trie *) 0 ; |
| char *arg2 = (char *) 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| int res2 ; |
| char *buf2 = 0 ; |
| int alloc2 = 0 ; |
| |
| if ((argc < 1) || (argc > 1)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Trie, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Trie *","mmap", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Trie * >(argp1); |
| res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2); |
| if (!SWIG_IsOK(res2)) { |
| SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","mmap", 2, argv[0] )); |
| } |
| arg2 = reinterpret_cast< char * >(buf2); |
| { |
| try { |
| (arg1)->mmap((char const *)arg2); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| if (alloc2 == SWIG_NEWOBJ) delete[] buf2; |
| return Qnil; |
| fail: |
| if (alloc2 == SWIG_NEWOBJ) delete[] buf2; |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Trie_load(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Trie *arg1 = (marisa_swig::Trie *) 0 ; |
| char *arg2 = (char *) 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| int res2 ; |
| char *buf2 = 0 ; |
| int alloc2 = 0 ; |
| |
| if ((argc < 1) || (argc > 1)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Trie, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Trie *","load", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Trie * >(argp1); |
| res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2); |
| if (!SWIG_IsOK(res2)) { |
| SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","load", 2, argv[0] )); |
| } |
| arg2 = reinterpret_cast< char * >(buf2); |
| { |
| try { |
| (arg1)->load((char const *)arg2); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| if (alloc2 == SWIG_NEWOBJ) delete[] buf2; |
| return Qnil; |
| fail: |
| if (alloc2 == SWIG_NEWOBJ) delete[] buf2; |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Trie_save(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Trie *arg1 = (marisa_swig::Trie *) 0 ; |
| char *arg2 = (char *) 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| int res2 ; |
| char *buf2 = 0 ; |
| int alloc2 = 0 ; |
| |
| if ((argc < 1) || (argc > 1)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Trie, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Trie const *","save", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Trie * >(argp1); |
| res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2); |
| if (!SWIG_IsOK(res2)) { |
| SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","save", 2, argv[0] )); |
| } |
| arg2 = reinterpret_cast< char * >(buf2); |
| { |
| try { |
| ((marisa_swig::Trie const *)arg1)->save((char const *)arg2); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| if (alloc2 == SWIG_NEWOBJ) delete[] buf2; |
| return Qnil; |
| fail: |
| if (alloc2 == SWIG_NEWOBJ) delete[] buf2; |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Trie_lookup__SWIG_0(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Trie *arg1 = (marisa_swig::Trie *) 0 ; |
| marisa_swig::Agent *arg2 = 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| void *argp2 = 0 ; |
| int res2 = 0 ; |
| bool result; |
| VALUE vresult = Qnil; |
| |
| if ((argc < 1) || (argc > 1)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Trie, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Trie const *","lookup", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Trie * >(argp1); |
| res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_marisa_swig__Agent, 0 ); |
| if (!SWIG_IsOK(res2)) { |
| SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "marisa_swig::Agent &","lookup", 2, argv[0] )); |
| } |
| if (!argp2) { |
| SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "marisa_swig::Agent &","lookup", 2, argv[0])); |
| } |
| arg2 = reinterpret_cast< marisa_swig::Agent * >(argp2); |
| { |
| try { |
| result = (bool)((marisa_swig::Trie const *)arg1)->lookup(*arg2); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| vresult = SWIG_From_bool(static_cast< bool >(result)); |
| return vresult; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Trie_reverse_lookup__SWIG_0(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Trie *arg1 = (marisa_swig::Trie *) 0 ; |
| marisa_swig::Agent *arg2 = 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| void *argp2 = 0 ; |
| int res2 = 0 ; |
| |
| if ((argc < 1) || (argc > 1)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Trie, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Trie const *","reverse_lookup", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Trie * >(argp1); |
| res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_marisa_swig__Agent, 0 ); |
| if (!SWIG_IsOK(res2)) { |
| SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "marisa_swig::Agent &","reverse_lookup", 2, argv[0] )); |
| } |
| if (!argp2) { |
| SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "marisa_swig::Agent &","reverse_lookup", 2, argv[0])); |
| } |
| arg2 = reinterpret_cast< marisa_swig::Agent * >(argp2); |
| { |
| try { |
| ((marisa_swig::Trie const *)arg1)->reverse_lookup(*arg2); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| return Qnil; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Trie_common_prefix_search(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Trie *arg1 = (marisa_swig::Trie *) 0 ; |
| marisa_swig::Agent *arg2 = 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| void *argp2 = 0 ; |
| int res2 = 0 ; |
| bool result; |
| VALUE vresult = Qnil; |
| |
| if ((argc < 1) || (argc > 1)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Trie, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Trie const *","common_prefix_search", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Trie * >(argp1); |
| res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_marisa_swig__Agent, 0 ); |
| if (!SWIG_IsOK(res2)) { |
| SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "marisa_swig::Agent &","common_prefix_search", 2, argv[0] )); |
| } |
| if (!argp2) { |
| SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "marisa_swig::Agent &","common_prefix_search", 2, argv[0])); |
| } |
| arg2 = reinterpret_cast< marisa_swig::Agent * >(argp2); |
| { |
| try { |
| result = (bool)((marisa_swig::Trie const *)arg1)->common_prefix_search(*arg2); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| vresult = SWIG_From_bool(static_cast< bool >(result)); |
| return vresult; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Trie_predictive_search(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Trie *arg1 = (marisa_swig::Trie *) 0 ; |
| marisa_swig::Agent *arg2 = 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| void *argp2 = 0 ; |
| int res2 = 0 ; |
| bool result; |
| VALUE vresult = Qnil; |
| |
| if ((argc < 1) || (argc > 1)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Trie, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Trie const *","predictive_search", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Trie * >(argp1); |
| res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_marisa_swig__Agent, 0 ); |
| if (!SWIG_IsOK(res2)) { |
| SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "marisa_swig::Agent &","predictive_search", 2, argv[0] )); |
| } |
| if (!argp2) { |
| SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "marisa_swig::Agent &","predictive_search", 2, argv[0])); |
| } |
| arg2 = reinterpret_cast< marisa_swig::Agent * >(argp2); |
| { |
| try { |
| result = (bool)((marisa_swig::Trie const *)arg1)->predictive_search(*arg2); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| vresult = SWIG_From_bool(static_cast< bool >(result)); |
| return vresult; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Trie_lookup__SWIG_1(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Trie *arg1 = (marisa_swig::Trie *) 0 ; |
| char *arg2 = (char *) 0 ; |
| std::size_t arg3 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| int res2 ; |
| char *buf2 = 0 ; |
| size_t size2 = 0 ; |
| int alloc2 = 0 ; |
| std::size_t result; |
| VALUE vresult = Qnil; |
| |
| if ((argc < 1) || (argc > 1)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Trie, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Trie const *","lookup", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Trie * >(argp1); |
| res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, &size2, &alloc2); |
| if (!SWIG_IsOK(res2)) { |
| SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","lookup", 2, argv[0] )); |
| } |
| arg2 = reinterpret_cast< char * >(buf2); |
| arg3 = static_cast< std::size_t >(size2 - 1); |
| { |
| try { |
| result = ((marisa_swig::Trie const *)arg1)->lookup((char const *)arg2,arg3); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| vresult = SWIG_From_size_t(static_cast< size_t >(result)); |
| if (alloc2 == SWIG_NEWOBJ) delete[] buf2; |
| return vresult; |
| fail: |
| if (alloc2 == SWIG_NEWOBJ) delete[] buf2; |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE _wrap_Trie_lookup(int nargs, VALUE *args, VALUE self) { |
| int argc; |
| VALUE argv[3]; |
| int ii; |
| |
| argc = nargs + 1; |
| argv[0] = self; |
| if (argc > 3) SWIG_fail; |
| for (ii = 1; (ii < argc); ++ii) { |
| argv[ii] = args[ii-1]; |
| } |
| if (argc == 2) { |
| int _v; |
| void *vptr = 0; |
| int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_marisa_swig__Trie, 0); |
| _v = SWIG_CheckState(res); |
| if (_v) { |
| void *vptr = 0; |
| int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_marisa_swig__Agent, 0); |
| _v = SWIG_CheckState(res); |
| if (_v) { |
| return _wrap_Trie_lookup__SWIG_0(nargs, args, self); |
| } |
| } |
| } |
| if (argc == 2) { |
| int _v; |
| void *vptr = 0; |
| int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_marisa_swig__Trie, 0); |
| _v = SWIG_CheckState(res); |
| if (_v) { |
| int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); |
| _v = SWIG_CheckState(res); |
| if (_v) { |
| if (argc <= 2) { |
| return _wrap_Trie_lookup__SWIG_1(nargs, args, self); |
| } |
| { |
| int res = SWIG_AsVal_size_t(argv[2], NULL); |
| _v = SWIG_CheckState(res); |
| } |
| if (_v) { |
| return _wrap_Trie_lookup__SWIG_1(nargs, args, self); |
| } |
| } |
| } |
| } |
| |
| fail: |
| Ruby_Format_OverloadedError( argc, 3, "Trie.lookup", |
| " std::size_t Trie.lookup(marisa_swig::Agent &agent)\n" |
| " std::size_t Trie.lookup(char const *ptr, std::size_t length)\n"); |
| |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Trie_reverse_lookup__SWIG_1(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Trie *arg1 = (marisa_swig::Trie *) 0 ; |
| std::size_t arg2 ; |
| char **arg3 = (char **) 0 ; |
| std::size_t *arg4 = (std::size_t *) 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| size_t val2 ; |
| int ecode2 = 0 ; |
| char *temp3 = 0 ; |
| std::size_t tempn3 ; |
| VALUE vresult = Qnil; |
| |
| arg3 = &temp3; arg4 = &tempn3; |
| if ((argc < 1) || (argc > 1)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Trie, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Trie const *","reverse_lookup", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Trie * >(argp1); |
| ecode2 = SWIG_AsVal_size_t(argv[0], &val2); |
| if (!SWIG_IsOK(ecode2)) { |
| SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::size_t","reverse_lookup", 2, argv[0] )); |
| } |
| arg2 = static_cast< std::size_t >(val2); |
| { |
| try { |
| ((marisa_swig::Trie const *)arg1)->reverse_lookup(arg2,(char const **)arg3,arg4); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| if (*arg3) { |
| vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_FromCharPtrAndSize(*arg3,*arg4)); |
| delete [] (*arg3); |
| } |
| return vresult; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE _wrap_Trie_reverse_lookup(int nargs, VALUE *args, VALUE self) { |
| int argc; |
| VALUE argv[3]; |
| int ii; |
| |
| argc = nargs + 1; |
| argv[0] = self; |
| if (argc > 3) SWIG_fail; |
| for (ii = 1; (ii < argc); ++ii) { |
| argv[ii] = args[ii-1]; |
| } |
| if (argc == 2) { |
| int _v; |
| void *vptr = 0; |
| int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_marisa_swig__Trie, 0); |
| _v = SWIG_CheckState(res); |
| if (_v) { |
| void *vptr = 0; |
| int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_marisa_swig__Agent, 0); |
| _v = SWIG_CheckState(res); |
| if (_v) { |
| return _wrap_Trie_reverse_lookup__SWIG_0(nargs, args, self); |
| } |
| } |
| } |
| if (argc == 2) { |
| int _v; |
| void *vptr = 0; |
| int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_marisa_swig__Trie, 0); |
| _v = SWIG_CheckState(res); |
| if (_v) { |
| { |
| int res = SWIG_AsVal_size_t(argv[1], NULL); |
| _v = SWIG_CheckState(res); |
| } |
| if (_v) { |
| return _wrap_Trie_reverse_lookup__SWIG_1(nargs, args, self); |
| } |
| } |
| } |
| |
| fail: |
| Ruby_Format_OverloadedError( argc, 3, "Trie.reverse_lookup", |
| " void Trie.reverse_lookup(marisa_swig::Agent &agent)\n" |
| " void Trie.reverse_lookup(std::size_t id, char const **ptr_out_to_be_deleted, std::size_t *length_out)\n"); |
| |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Trie_num_tries(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Trie *arg1 = (marisa_swig::Trie *) 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| std::size_t result; |
| VALUE vresult = Qnil; |
| |
| if ((argc < 0) || (argc > 0)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Trie, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Trie const *","num_tries", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Trie * >(argp1); |
| { |
| try { |
| result = ((marisa_swig::Trie const *)arg1)->num_tries(); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| vresult = SWIG_From_size_t(static_cast< size_t >(result)); |
| return vresult; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Trie_num_keys(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Trie *arg1 = (marisa_swig::Trie *) 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| std::size_t result; |
| VALUE vresult = Qnil; |
| |
| if ((argc < 0) || (argc > 0)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Trie, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Trie const *","num_keys", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Trie * >(argp1); |
| { |
| try { |
| result = ((marisa_swig::Trie const *)arg1)->num_keys(); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| vresult = SWIG_From_size_t(static_cast< size_t >(result)); |
| return vresult; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Trie_num_nodes(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Trie *arg1 = (marisa_swig::Trie *) 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| std::size_t result; |
| VALUE vresult = Qnil; |
| |
| if ((argc < 0) || (argc > 0)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Trie, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Trie const *","num_nodes", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Trie * >(argp1); |
| { |
| try { |
| result = ((marisa_swig::Trie const *)arg1)->num_nodes(); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| vresult = SWIG_From_size_t(static_cast< size_t >(result)); |
| return vresult; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Trie_tail_mode(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Trie *arg1 = (marisa_swig::Trie *) 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| marisa_swig::TailMode result; |
| VALUE vresult = Qnil; |
| |
| if ((argc < 0) || (argc > 0)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Trie, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Trie const *","tail_mode", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Trie * >(argp1); |
| { |
| try { |
| result = (marisa_swig::TailMode)((marisa_swig::Trie const *)arg1)->tail_mode(); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| vresult = SWIG_From_int(static_cast< int >(result)); |
| return vresult; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Trie_node_order(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Trie *arg1 = (marisa_swig::Trie *) 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| marisa_swig::NodeOrder result; |
| VALUE vresult = Qnil; |
| |
| if ((argc < 0) || (argc > 0)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Trie, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Trie const *","node_order", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Trie * >(argp1); |
| { |
| try { |
| result = (marisa_swig::NodeOrder)((marisa_swig::Trie const *)arg1)->node_order(); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| vresult = SWIG_From_int(static_cast< int >(result)); |
| return vresult; |
| fail: |
| return Qnil; |
| } |
| |
| |
| |
| /* |
| Document-method: Marisa::Trie.empty |
| |
| call-seq: |
| empty -> bool |
| |
| Check if Trie is empty. |
| */ |
| SWIGINTERN VALUE |
| _wrap_Trie_empty(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Trie *arg1 = (marisa_swig::Trie *) 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| bool result; |
| VALUE vresult = Qnil; |
| |
| if ((argc < 0) || (argc > 0)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Trie, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Trie const *","empty", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Trie * >(argp1); |
| { |
| try { |
| result = (bool)((marisa_swig::Trie const *)arg1)->empty(); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| vresult = SWIG_From_bool(static_cast< bool >(result)); |
| return vresult; |
| fail: |
| return Qnil; |
| } |
| |
| |
| |
| /* |
| Document-method: Marisa::Trie.size |
| |
| call-seq: |
| size -> std::size_t |
| |
| Size or Length of the Trie. |
| */ |
| SWIGINTERN VALUE |
| _wrap_Trie_size(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Trie *arg1 = (marisa_swig::Trie *) 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| std::size_t result; |
| VALUE vresult = Qnil; |
| |
| if ((argc < 0) || (argc > 0)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Trie, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Trie const *","size", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Trie * >(argp1); |
| { |
| try { |
| result = ((marisa_swig::Trie const *)arg1)->size(); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| vresult = SWIG_From_size_t(static_cast< size_t >(result)); |
| return vresult; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Trie_total_size(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Trie *arg1 = (marisa_swig::Trie *) 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| std::size_t result; |
| VALUE vresult = Qnil; |
| |
| if ((argc < 0) || (argc > 0)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Trie, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Trie const *","total_size", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Trie * >(argp1); |
| { |
| try { |
| result = ((marisa_swig::Trie const *)arg1)->total_size(); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| vresult = SWIG_From_size_t(static_cast< size_t >(result)); |
| return vresult; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Trie_io_size(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Trie *arg1 = (marisa_swig::Trie *) 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| std::size_t result; |
| VALUE vresult = Qnil; |
| |
| if ((argc < 0) || (argc > 0)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Trie, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Trie const *","io_size", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Trie * >(argp1); |
| { |
| try { |
| result = ((marisa_swig::Trie const *)arg1)->io_size(); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| vresult = SWIG_From_size_t(static_cast< size_t >(result)); |
| return vresult; |
| fail: |
| return Qnil; |
| } |
| |
| |
| SWIGINTERN VALUE |
| _wrap_Trie_clear(int argc, VALUE *argv, VALUE self) { |
| marisa_swig::Trie *arg1 = (marisa_swig::Trie *) 0 ; |
| void *argp1 = 0 ; |
| int res1 = 0 ; |
| |
| if ((argc < 0) || (argc > 0)) { |
| rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; |
| } |
| res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_marisa_swig__Trie, 0 | 0 ); |
| if (!SWIG_IsOK(res1)) { |
| SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "marisa_swig::Trie *","clear", 1, self )); |
| } |
| arg1 = reinterpret_cast< marisa_swig::Trie * >(argp1); |
| { |
| try { |
| (arg1)->clear(); |
| } catch (const marisa::Exception &ex) { |
| SWIG_exception(SWIG_RuntimeError, ex.what()); |
| } catch (...) { |
| SWIG_exception(SWIG_UnknownError,"Unknown exception"); |
| } |
| } |
| return Qnil; |
| fail: |
| return Qnil; |
| } |
| |
| |
| |
| /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ |
| |
| static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; |
| static swig_type_info _swigt__p_marisa__Key = {"_p_marisa__Key", "marisa::Key *", 0, 0, (void*)0, 0}; |
| static swig_type_info _swigt__p_marisa_swig__Agent = {"_p_marisa_swig__Agent", "marisa_swig::Agent *", 0, 0, (void*)0, 0}; |
| static swig_type_info _swigt__p_marisa_swig__Key = {"_p_marisa_swig__Key", "marisa_swig::Key *", 0, 0, (void*)0, 0}; |
| static swig_type_info _swigt__p_marisa_swig__Keyset = {"_p_marisa_swig__Keyset", "marisa_swig::Keyset *", 0, 0, (void*)0, 0}; |
| static swig_type_info _swigt__p_marisa_swig__Query = {"_p_marisa_swig__Query", "marisa_swig::Query *", 0, 0, (void*)0, 0}; |
| static swig_type_info _swigt__p_marisa_swig__Trie = {"_p_marisa_swig__Trie", "marisa_swig::Trie *", 0, 0, (void*)0, 0}; |
| static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0}; |
| static swig_type_info _swigt__p_std__size_t = {"_p_std__size_t", "std::size_t *", 0, 0, (void*)0, 0}; |
| |
| static swig_type_info *swig_type_initial[] = { |
| &_swigt__p_char, |
| &_swigt__p_marisa__Key, |
| &_swigt__p_marisa_swig__Agent, |
| &_swigt__p_marisa_swig__Key, |
| &_swigt__p_marisa_swig__Keyset, |
| &_swigt__p_marisa_swig__Query, |
| &_swigt__p_marisa_swig__Trie, |
| &_swigt__p_p_char, |
| &_swigt__p_std__size_t, |
| }; |
| |
| static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; |
| static swig_cast_info _swigc__p_marisa__Key[] = { {&_swigt__p_marisa__Key, 0, 0, 0},{0, 0, 0, 0}}; |
| static swig_cast_info _swigc__p_marisa_swig__Agent[] = { {&_swigt__p_marisa_swig__Agent, 0, 0, 0},{0, 0, 0, 0}}; |
| static swig_cast_info _swigc__p_marisa_swig__Key[] = { {&_swigt__p_marisa_swig__Key, 0, 0, 0},{0, 0, 0, 0}}; |
| static swig_cast_info _swigc__p_marisa_swig__Keyset[] = { {&_swigt__p_marisa_swig__Keyset, 0, 0, 0},{0, 0, 0, 0}}; |
| static swig_cast_info _swigc__p_marisa_swig__Query[] = { {&_swigt__p_marisa_swig__Query, 0, 0, 0},{0, 0, 0, 0}}; |
| static swig_cast_info _swigc__p_marisa_swig__Trie[] = { {&_swigt__p_marisa_swig__Trie, 0, 0, 0},{0, 0, 0, 0}}; |
| static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}}; |
| static swig_cast_info _swigc__p_std__size_t[] = { {&_swigt__p_std__size_t, 0, 0, 0},{0, 0, 0, 0}}; |
| |
| static swig_cast_info *swig_cast_initial[] = { |
| _swigc__p_char, |
| _swigc__p_marisa__Key, |
| _swigc__p_marisa_swig__Agent, |
| _swigc__p_marisa_swig__Key, |
| _swigc__p_marisa_swig__Keyset, |
| _swigc__p_marisa_swig__Query, |
| _swigc__p_marisa_swig__Trie, |
| _swigc__p_p_char, |
| _swigc__p_std__size_t, |
| }; |
| |
| |
| /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ |
| |
| /* ----------------------------------------------------------------------------- |
| * Type initialization: |
| * This problem is tough by the requirement that no dynamic |
| * memory is used. Also, since swig_type_info structures store pointers to |
| * swig_cast_info structures and swig_cast_info structures store pointers back |
| * to swig_type_info structures, we need some lookup code at initialization. |
| * The idea is that swig generates all the structures that are needed. |
| * The runtime then collects these partially filled structures. |
| * The SWIG_InitializeModule function takes these initial arrays out of |
| * swig_module, and does all the lookup, filling in the swig_module.types |
| * array with the correct data and linking the correct swig_cast_info |
| * structures together. |
| * |
| * The generated swig_type_info structures are assigned staticly to an initial |
| * array. We just loop through that array, and handle each type individually. |
| * First we lookup if this type has been already loaded, and if so, use the |
| * loaded structure instead of the generated one. Then we have to fill in the |
| * cast linked list. The cast data is initially stored in something like a |
| * two-dimensional array. Each row corresponds to a type (there are the same |
| * number of rows as there are in the swig_type_initial array). Each entry in |
| * a column is one of the swig_cast_info structures for that type. |
| * The cast_initial array is actually an array of arrays, because each row has |
| * a variable number of columns. So to actually build the cast linked list, |
| * we find the array of casts associated with the type, and loop through it |
| * adding the casts to the list. The one last trick we need to do is making |
| * sure the type pointer in the swig_cast_info struct is correct. |
| * |
| * First off, we lookup the cast->type name to see if it is already loaded. |
| * There are three cases to handle: |
| * 1) If the cast->type has already been loaded AND the type we are adding |
| * casting info to has not been loaded (it is in this module), THEN we |
| * replace the cast->type pointer with the type pointer that has already |
| * been loaded. |
| * 2) If BOTH types (the one we are adding casting info to, and the |
| * cast->type) are loaded, THEN the cast info has already been loaded by |
| * the previous module so we just ignore it. |
| * 3) Finally, if cast->type has not already been loaded, then we add that |
| * swig_cast_info to the linked list (because the cast->type) pointer will |
| * be correct. |
| * ----------------------------------------------------------------------------- */ |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #if 0 |
| } /* c-mode */ |
| #endif |
| #endif |
| |
| #if 0 |
| #define SWIGRUNTIME_DEBUG |
| #endif |
| |
| |
| SWIGRUNTIME void |
| SWIG_InitializeModule(void *clientdata) { |
| size_t i; |
| swig_module_info *module_head, *iter; |
| int found, init; |
| |
| clientdata = clientdata; |
| |
| /* check to see if the circular list has been setup, if not, set it up */ |
| if (swig_module.next==0) { |
| /* Initialize the swig_module */ |
| swig_module.type_initial = swig_type_initial; |
| swig_module.cast_initial = swig_cast_initial; |
| swig_module.next = &swig_module; |
| init = 1; |
| } else { |
| init = 0; |
| } |
| |
| /* Try and load any already created modules */ |
| module_head = SWIG_GetModule(clientdata); |
| if (!module_head) { |
| /* This is the first module loaded for this interpreter */ |
| /* so set the swig module into the interpreter */ |
| SWIG_SetModule(clientdata, &swig_module); |
| module_head = &swig_module; |
| } else { |
| /* the interpreter has loaded a SWIG module, but has it loaded this one? */ |
| found=0; |
| iter=module_head; |
| do { |
| if (iter==&swig_module) { |
| found=1; |
| break; |
| } |
| iter=iter->next; |
| } while (iter!= module_head); |
| |
| /* if the is found in the list, then all is done and we may leave */ |
| if (found) return; |
| /* otherwise we must add out module into the list */ |
| swig_module.next = module_head->next; |
| module_head->next = &swig_module; |
| } |
| |
| /* When multiple interpeters are used, a module could have already been initialized in |
| a different interpreter, but not yet have a pointer in this interpreter. |
| In this case, we do not want to continue adding types... everything should be |
| set up already */ |
| if (init == 0) return; |
| |
| /* Now work on filling in swig_module.types */ |
| #ifdef SWIGRUNTIME_DEBUG |
| printf("SWIG_InitializeModule: size %d\n", swig_module.size); |
| #endif |
| for (i = 0; i < swig_module.size; ++i) { |
| swig_type_info *type = 0; |
| swig_type_info *ret; |
| swig_cast_info *cast; |
| |
| #ifdef SWIGRUNTIME_DEBUG |
| printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); |
| #endif |
| |
| /* if there is another module already loaded */ |
| if (swig_module.next != &swig_module) { |
| type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name); |
| } |
| if (type) { |
| /* Overwrite clientdata field */ |
| #ifdef SWIGRUNTIME_DEBUG |
| printf("SWIG_InitializeModule: found type %s\n", type->name); |
| #endif |
| if (swig_module.type_initial[i]->clientdata) { |
| type->clientdata = swig_module.type_initial[i]->clientdata; |
| #ifdef SWIGRUNTIME_DEBUG |
| printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name); |
| #endif |
| } |
| } else { |
| type = swig_module.type_initial[i]; |
| } |
| |
| /* Insert casting types */ |
| cast = swig_module.cast_initial[i]; |
| while (cast->type) { |
| |
| /* Don't need to add information already in the list */ |
| ret = 0; |
| #ifdef SWIGRUNTIME_DEBUG |
| printf("SWIG_InitializeModule: look cast %s\n", cast->type->name); |
| #endif |
| if (swig_module.next != &swig_module) { |
| ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name); |
| #ifdef SWIGRUNTIME_DEBUG |
| if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name); |
| #endif |
| } |
| if (ret) { |
| if (type == swig_module.type_initial[i]) { |
| #ifdef SWIGRUNTIME_DEBUG |
| printf("SWIG_InitializeModule: skip old type %s\n", ret->name); |
| #endif |
| cast->type = ret; |
| ret = 0; |
| } else { |
| /* Check for casting already in the list */ |
| swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type); |
| #ifdef SWIGRUNTIME_DEBUG |
| if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name); |
| #endif |
| if (!ocast) ret = 0; |
| } |
| } |
| |
| if (!ret) { |
| #ifdef SWIGRUNTIME_DEBUG |
| printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name); |
| #endif |
| if (type->cast) { |
| type->cast->prev = cast; |
| cast->next = type->cast; |
| } |
| type->cast = cast; |
| } |
| cast++; |
| } |
| /* Set entry in modules->types array equal to the type */ |
| swig_module.types[i] = type; |
| } |
| swig_module.types[i] = 0; |
| |
| #ifdef SWIGRUNTIME_DEBUG |
| printf("**** SWIG_InitializeModule: Cast List ******\n"); |
| for (i = 0; i < swig_module.size; ++i) { |
| int j = 0; |
| swig_cast_info *cast = swig_module.cast_initial[i]; |
| printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); |
| while (cast->type) { |
| printf("SWIG_InitializeModule: cast type %s\n", cast->type->name); |
| cast++; |
| ++j; |
| } |
| printf("---- Total casts: %d\n",j); |
| } |
| printf("**** SWIG_InitializeModule: Cast List ******\n"); |
| #endif |
| } |
| |
| /* This function will propagate the clientdata field of type to |
| * any new swig_type_info structures that have been added into the list |
| * of equivalent types. It is like calling |
| * SWIG_TypeClientData(type, clientdata) a second time. |
| */ |
| SWIGRUNTIME void |
| SWIG_PropagateClientData(void) { |
| size_t i; |
| swig_cast_info *equiv; |
| static int init_run = 0; |
| |
| if (init_run) return; |
| init_run = 1; |
| |
| for (i = 0; i < swig_module.size; i++) { |
| if (swig_module.types[i]->clientdata) { |
| equiv = swig_module.types[i]->cast; |
| while (equiv) { |
| if (!equiv->converter) { |
| if (equiv->type && !equiv->type->clientdata) |
| SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata); |
| } |
| equiv = equiv->next; |
| } |
| } |
| } |
| } |
| |
| #ifdef __cplusplus |
| #if 0 |
| { /* c-mode */ |
| #endif |
| } |
| #endif |
| |
| /* |
| |
| */ |
| #ifdef __cplusplus |
| extern "C" |
| #endif |
| SWIGEXPORT void Init_marisa(void) { |
| size_t i; |
| |
| SWIG_InitRuntime(); |
| mMarisa = rb_define_module("Marisa"); |
| |
| SWIG_InitializeModule(0); |
| for (i = 0; i < swig_module.size; i++) { |
| SWIG_define_class(swig_module.types[i]); |
| } |
| |
| SWIG_RubyInitializeTrackings(); |
| rb_define_const(mMarisa, "OK", SWIG_From_int(static_cast< int >(marisa_swig::OK))); |
| rb_define_const(mMarisa, "STATE_ERROR", SWIG_From_int(static_cast< int >(marisa_swig::STATE_ERROR))); |
| rb_define_const(mMarisa, "NULL_ERROR", SWIG_From_int(static_cast< int >(marisa_swig::NULL_ERROR))); |
| rb_define_const(mMarisa, "BOUND_ERROR", SWIG_From_int(static_cast< int >(marisa_swig::BOUND_ERROR))); |
| rb_define_const(mMarisa, "RANGE_ERROR", SWIG_From_int(static_cast< int >(marisa_swig::RANGE_ERROR))); |
| rb_define_const(mMarisa, "CODE_ERROR", SWIG_From_int(static_cast< int >(marisa_swig::CODE_ERROR))); |
| rb_define_const(mMarisa, "RESET_ERROR", SWIG_From_int(static_cast< int >(marisa_swig::RESET_ERROR))); |
| rb_define_const(mMarisa, "SIZE_ERROR", SWIG_From_int(static_cast< int >(marisa_swig::SIZE_ERROR))); |
| rb_define_const(mMarisa, "MEMORY_ERROR", SWIG_From_int(static_cast< int >(marisa_swig::MEMORY_ERROR))); |
| rb_define_const(mMarisa, "IO_ERROR", SWIG_From_int(static_cast< int >(marisa_swig::IO_ERROR))); |
| rb_define_const(mMarisa, "FORMAT_ERROR", SWIG_From_int(static_cast< int >(marisa_swig::FORMAT_ERROR))); |
| rb_define_const(mMarisa, "MIN_NUM_TRIES", SWIG_From_int(static_cast< int >(marisa_swig::MIN_NUM_TRIES))); |
| rb_define_const(mMarisa, "MAX_NUM_TRIES", SWIG_From_int(static_cast< int >(marisa_swig::MAX_NUM_TRIES))); |
| rb_define_const(mMarisa, "DEFAULT_NUM_TRIES", SWIG_From_int(static_cast< int >(marisa_swig::DEFAULT_NUM_TRIES))); |
| rb_define_const(mMarisa, "HUGE_CACHE", SWIG_From_int(static_cast< int >(marisa_swig::HUGE_CACHE))); |
| rb_define_const(mMarisa, "LARGE_CACHE", SWIG_From_int(static_cast< int >(marisa_swig::LARGE_CACHE))); |
| rb_define_const(mMarisa, "NORMAL_CACHE", SWIG_From_int(static_cast< int >(marisa_swig::NORMAL_CACHE))); |
| rb_define_const(mMarisa, "SMALL_CACHE", SWIG_From_int(static_cast< int >(marisa_swig::SMALL_CACHE))); |
| rb_define_const(mMarisa, "TINY_CACHE", SWIG_From_int(static_cast< int >(marisa_swig::TINY_CACHE))); |
| rb_define_const(mMarisa, "DEFAULT_CACHE", SWIG_From_int(static_cast< int >(marisa_swig::DEFAULT_CACHE))); |
| rb_define_const(mMarisa, "TEXT_TAIL", SWIG_From_int(static_cast< int >(marisa_swig::TEXT_TAIL))); |
| rb_define_const(mMarisa, "BINARY_TAIL", SWIG_From_int(static_cast< int >(marisa_swig::BINARY_TAIL))); |
| rb_define_const(mMarisa, "DEFAULT_TAIL", SWIG_From_int(static_cast< int >(marisa_swig::DEFAULT_TAIL))); |
| rb_define_const(mMarisa, "LABEL_ORDER", SWIG_From_int(static_cast< int >(marisa_swig::LABEL_ORDER))); |
| rb_define_const(mMarisa, "WEIGHT_ORDER", SWIG_From_int(static_cast< int >(marisa_swig::WEIGHT_ORDER))); |
| rb_define_const(mMarisa, "DEFAULT_ORDER", SWIG_From_int(static_cast< int >(marisa_swig::DEFAULT_ORDER))); |
| |
| SwigClassKey.klass = rb_define_class_under(mMarisa, "Key", rb_cObject); |
| SWIG_TypeClientData(SWIGTYPE_p_marisa_swig__Key, (void *) &SwigClassKey); |
| rb_undef_alloc_func(SwigClassKey.klass); |
| rb_define_method(SwigClassKey.klass, "str", VALUEFUNC(_wrap_Key_str), -1); |
| rb_define_method(SwigClassKey.klass, "id", VALUEFUNC(_wrap_Key_id), -1); |
| rb_define_method(SwigClassKey.klass, "weight", VALUEFUNC(_wrap_Key_weight), -1); |
| SwigClassKey.mark = 0; |
| SwigClassKey.destroy = (void (*)(void *)) free_marisa_swig_Key; |
| SwigClassKey.trackObjects = 0; |
| |
| SwigClassQuery.klass = rb_define_class_under(mMarisa, "Query", rb_cObject); |
| SWIG_TypeClientData(SWIGTYPE_p_marisa_swig__Query, (void *) &SwigClassQuery); |
| rb_undef_alloc_func(SwigClassQuery.klass); |
| rb_define_method(SwigClassQuery.klass, "str", VALUEFUNC(_wrap_Query_str), -1); |
| rb_define_method(SwigClassQuery.klass, "id", VALUEFUNC(_wrap_Query_id), -1); |
| SwigClassQuery.mark = 0; |
| SwigClassQuery.destroy = (void (*)(void *)) free_marisa_swig_Query; |
| SwigClassQuery.trackObjects = 0; |
| |
| SwigClassKeyset.klass = rb_define_class_under(mMarisa, "Keyset", rb_cObject); |
| SWIG_TypeClientData(SWIGTYPE_p_marisa_swig__Keyset, (void *) &SwigClassKeyset); |
| rb_define_alloc_func(SwigClassKeyset.klass, _wrap_Keyset_allocate); |
| rb_define_method(SwigClassKeyset.klass, "initialize", VALUEFUNC(_wrap_new_Keyset), -1); |
| rb_define_method(SwigClassKeyset.klass, "push_back", VALUEFUNC(_wrap_Keyset_push_back), -1); |
| rb_define_method(SwigClassKeyset.klass, "key", VALUEFUNC(_wrap_Keyset_key), -1); |
| rb_define_method(SwigClassKeyset.klass, "key_str", VALUEFUNC(_wrap_Keyset_key_str), -1); |
| rb_define_method(SwigClassKeyset.klass, "key_id", VALUEFUNC(_wrap_Keyset_key_id), -1); |
| rb_define_method(SwigClassKeyset.klass, "num_keys", VALUEFUNC(_wrap_Keyset_num_keys), -1); |
| rb_define_method(SwigClassKeyset.klass, "empty", VALUEFUNC(_wrap_Keyset_empty), -1); |
| rb_define_method(SwigClassKeyset.klass, "size", VALUEFUNC(_wrap_Keyset_size), -1); |
| rb_define_method(SwigClassKeyset.klass, "total_length", VALUEFUNC(_wrap_Keyset_total_length), -1); |
| rb_define_method(SwigClassKeyset.klass, "reset", VALUEFUNC(_wrap_Keyset_reset), -1); |
| rb_define_method(SwigClassKeyset.klass, "clear", VALUEFUNC(_wrap_Keyset_clear), -1); |
| SwigClassKeyset.mark = 0; |
| SwigClassKeyset.destroy = (void (*)(void *)) free_marisa_swig_Keyset; |
| SwigClassKeyset.trackObjects = 0; |
| |
| SwigClassAgent.klass = rb_define_class_under(mMarisa, "Agent", rb_cObject); |
| SWIG_TypeClientData(SWIGTYPE_p_marisa_swig__Agent, (void *) &SwigClassAgent); |
| rb_define_alloc_func(SwigClassAgent.klass, _wrap_Agent_allocate); |
| rb_define_method(SwigClassAgent.klass, "initialize", VALUEFUNC(_wrap_new_Agent), -1); |
| rb_define_method(SwigClassAgent.klass, "set_query", VALUEFUNC(_wrap_Agent_set_query), -1); |
| rb_define_method(SwigClassAgent.klass, "key", VALUEFUNC(_wrap_Agent_key), -1); |
| rb_define_method(SwigClassAgent.klass, "query", VALUEFUNC(_wrap_Agent_query), -1); |
| rb_define_method(SwigClassAgent.klass, "key_str", VALUEFUNC(_wrap_Agent_key_str), -1); |
| rb_define_method(SwigClassAgent.klass, "key_id", VALUEFUNC(_wrap_Agent_key_id), -1); |
| rb_define_method(SwigClassAgent.klass, "query_str", VALUEFUNC(_wrap_Agent_query_str), -1); |
| rb_define_method(SwigClassAgent.klass, "query_id", VALUEFUNC(_wrap_Agent_query_id), -1); |
| SwigClassAgent.mark = 0; |
| SwigClassAgent.destroy = (void (*)(void *)) free_marisa_swig_Agent; |
| SwigClassAgent.trackObjects = 0; |
| |
| SwigClassTrie.klass = rb_define_class_under(mMarisa, "Trie", rb_cObject); |
| SWIG_TypeClientData(SWIGTYPE_p_marisa_swig__Trie, (void *) &SwigClassTrie); |
| rb_define_alloc_func(SwigClassTrie.klass, _wrap_Trie_allocate); |
| rb_define_method(SwigClassTrie.klass, "initialize", VALUEFUNC(_wrap_new_Trie), -1); |
| rb_define_method(SwigClassTrie.klass, "build", VALUEFUNC(_wrap_Trie_build), -1); |
| rb_define_method(SwigClassTrie.klass, "mmap", VALUEFUNC(_wrap_Trie_mmap), -1); |
| rb_define_method(SwigClassTrie.klass, "load", VALUEFUNC(_wrap_Trie_load), -1); |
| rb_define_method(SwigClassTrie.klass, "save", VALUEFUNC(_wrap_Trie_save), -1); |
| rb_define_method(SwigClassTrie.klass, "common_prefix_search", VALUEFUNC(_wrap_Trie_common_prefix_search), -1); |
| rb_define_method(SwigClassTrie.klass, "predictive_search", VALUEFUNC(_wrap_Trie_predictive_search), -1); |
| rb_define_method(SwigClassTrie.klass, "lookup", VALUEFUNC(_wrap_Trie_lookup), -1); |
| rb_define_method(SwigClassTrie.klass, "reverse_lookup", VALUEFUNC(_wrap_Trie_reverse_lookup), -1); |
| rb_define_method(SwigClassTrie.klass, "num_tries", VALUEFUNC(_wrap_Trie_num_tries), -1); |
| rb_define_method(SwigClassTrie.klass, "num_keys", VALUEFUNC(_wrap_Trie_num_keys), -1); |
| rb_define_method(SwigClassTrie.klass, "num_nodes", VALUEFUNC(_wrap_Trie_num_nodes), -1); |
| rb_define_method(SwigClassTrie.klass, "tail_mode", VALUEFUNC(_wrap_Trie_tail_mode), -1); |
| rb_define_method(SwigClassTrie.klass, "node_order", VALUEFUNC(_wrap_Trie_node_order), -1); |
| rb_define_method(SwigClassTrie.klass, "empty", VALUEFUNC(_wrap_Trie_empty), -1); |
| rb_define_method(SwigClassTrie.klass, "size", VALUEFUNC(_wrap_Trie_size), -1); |
| rb_define_method(SwigClassTrie.klass, "total_size", VALUEFUNC(_wrap_Trie_total_size), -1); |
| rb_define_method(SwigClassTrie.klass, "io_size", VALUEFUNC(_wrap_Trie_io_size), -1); |
| rb_define_method(SwigClassTrie.klass, "clear", VALUEFUNC(_wrap_Trie_clear), -1); |
| SwigClassTrie.mark = 0; |
| SwigClassTrie.destroy = (void (*)(void *)) free_marisa_swig_Trie; |
| SwigClassTrie.trackObjects = 0; |
| rb_define_const(mMarisa, "INVALID_KEY_ID", SWIG_From_size_t(static_cast< size_t >(MARISA_INVALID_KEY_ID))); |
| } |
| |