swishe 0.2 → 0.4.2
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +7 -0
- data/{README → README.md} +31 -10
- data/ext/extconf.rb +1 -1
- data/ext/swish-e.i +193 -0
- data/ext/swishe_base.c +644 -375
- data/lib/swishe.rb +39 -4
- data/test/tc_swishe.rb +92 -0
- data/test/unittest.rb +3 -0
- metadata +53 -44
- data/ext/MANIFEST +0 -3
checksums.yaml
ADDED
@@ -0,0 +1,7 @@
|
|
1
|
+
---
|
2
|
+
SHA1:
|
3
|
+
metadata.gz: cd705daa29622afb11ac666f6f9549bd987e3d04
|
4
|
+
data.tar.gz: 790b37559650d35ac615fa4a2479468d7dba67e2
|
5
|
+
SHA512:
|
6
|
+
metadata.gz: dec15f3ff2498d42d561c9c1a291921f6f4c79d99e865163114e5cde7217ed6bd71d2370e3eb1d1a94dedf7dc96e73fba6a6448d98fe269a0bbb752cff69c032
|
7
|
+
data.tar.gz: b70ce90724d4892a16589fa2414602da6e711ad41641e94d93ba431412bbac432a21e7189a74a3a478eaaeadc67c156e06d6137fa709e674d6e0a98be2be140d
|
data/{README → README.md}
RENAMED
@@ -1,6 +1,7 @@
|
|
1
|
-
|
1
|
+
# Readme for Swish-e Ruby Bindings
|
2
2
|
|
3
|
-
|
3
|
+
## Example usage
|
4
|
+
```ruby
|
4
5
|
require "swishe"
|
5
6
|
sw=SwishE.new("swishe-index")
|
6
7
|
sw.query("searchstring").each do |result|
|
@@ -9,25 +10,45 @@
|
|
9
10
|
# ....
|
10
11
|
end
|
11
12
|
sw.close
|
13
|
+
```
|
12
14
|
|
13
|
-
|
15
|
+
```ruby
|
16
|
+
require "swishe"
|
17
|
+
sw=SwishE.new("swishe-index")
|
18
|
+
sw.search({"query" => "This is","order" => "swishdocsize asc","limit" => 1}).each do |result|
|
19
|
+
puts result.docpath
|
20
|
+
puts result.rank
|
21
|
+
# ....
|
22
|
+
end
|
23
|
+
sw.close
|
24
|
+
```
|
25
|
+
|
26
|
+
## Installing the bindings
|
14
27
|
|
15
28
|
You have two choices installing the bindings. First, use the gem command, such as
|
16
|
-
|
29
|
+
|
30
|
+
gem install swishe
|
31
|
+
|
17
32
|
in case the gem command doesn't find the Swish-e C-library you might need to supply the path
|
18
33
|
to the library on the gem command line, for example:
|
19
|
-
|
34
|
+
|
35
|
+
gem install swishe -- --with-swishe-dir=/opt/swishe/2.4.3/
|
20
36
|
|
21
37
|
The other way to install the ruby bindings for Swish-e would be to download the source file
|
22
38
|
and run setup.rb manually:
|
23
|
-
|
39
|
+
|
40
|
+
ruby setup.rb all
|
41
|
+
|
24
42
|
and again, if your system doesn't find the Swish-e library, you need to supply those:
|
25
|
-
|
43
|
+
|
44
|
+
ruby setup.rb all -- --with-swishe-dir=/opt/swishe/2.4.3/
|
45
|
+
|
26
46
|
Needles to say that you need to change the path according to your system requirements.
|
27
47
|
|
28
|
-
|
48
|
+
## Other Stuff
|
29
49
|
Author:: Patrick Gundlach <patrick <at> gundla.ch>
|
30
|
-
|
31
|
-
Homepage:: (Documentation) http://swishe.rubyforge.org
|
50
|
+
|
32
51
|
License:: Copyright (c) 2006 Patrick Gundlach.
|
33
52
|
Released under the terms of the MIT license. See the file MIT-LICENSE
|
53
|
+
|
54
|
+
Reluctant maintainer:: Neil Spring
|
data/ext/extconf.rb
CHANGED
data/ext/swish-e.i
ADDED
@@ -0,0 +1,193 @@
|
|
1
|
+
/* File : swish-e.i */
|
2
|
+
%module swishe_base
|
3
|
+
%{
|
4
|
+
#include "stdio.h"
|
5
|
+
#include "swish-e.h"
|
6
|
+
|
7
|
+
%}
|
8
|
+
|
9
|
+
typedef void * SW_HANDLE;
|
10
|
+
typedef void * SW_SEARCH;
|
11
|
+
typedef void * SW_RESULTS;
|
12
|
+
typedef void * SW_RESULT;
|
13
|
+
typedef void * SW_FUZZYWORD; /* access to the swish-e stemmers */
|
14
|
+
|
15
|
+
|
16
|
+
/* These must match headers.h */
|
17
|
+
|
18
|
+
typedef enum {
|
19
|
+
SWISH_NUMBER,
|
20
|
+
SWISH_STRING,
|
21
|
+
SWISH_LIST,
|
22
|
+
SWISH_BOOL,
|
23
|
+
SWISH_WORD_HASH,
|
24
|
+
SWISH_OTHER_DATA,
|
25
|
+
SWISH_HEADER_ERROR /* must check error in this case */
|
26
|
+
} SWISH_HEADER_TYPE;
|
27
|
+
|
28
|
+
typedef union
|
29
|
+
{
|
30
|
+
const char *string;
|
31
|
+
const char **string_list;
|
32
|
+
unsigned long number;
|
33
|
+
int boolean;
|
34
|
+
} SWISH_HEADER_VALUE;
|
35
|
+
|
36
|
+
|
37
|
+
const char **SwishHeaderNames( SW_HANDLE ); /* fetch the list of available header names */
|
38
|
+
const char **SwishIndexNames( SW_HANDLE ); /* fetch list of index files names associated */
|
39
|
+
SWISH_HEADER_VALUE SwishHeaderValue( SW_HANDLE, const char *index_name, const char *cur_header, SWISH_HEADER_TYPE *type );
|
40
|
+
SWISH_HEADER_VALUE SwishResultIndexValue( SW_RESULT, const char *name, SWISH_HEADER_TYPE *type );
|
41
|
+
|
42
|
+
typedef const void * SW_META;
|
43
|
+
typedef SW_META * SWISH_META_LIST;
|
44
|
+
|
45
|
+
/* Meta and Property Values */
|
46
|
+
|
47
|
+
#define SW_META_TYPE_UNDEF 0
|
48
|
+
#define SW_META_TYPE_STRING 4
|
49
|
+
#define SW_META_TYPE_ULONG 8
|
50
|
+
#define SW_META_TYPE_DATE 16
|
51
|
+
|
52
|
+
SWISH_META_LIST SwishMetaList( SW_HANDLE, const char *index_name );
|
53
|
+
SWISH_META_LIST SwishPropertyList( SW_HANDLE, const char *index_name );
|
54
|
+
SWISH_META_LIST SwishResultMetaList( SW_RESULT );
|
55
|
+
SWISH_META_LIST SwishResultPropertyList( SW_RESULT );
|
56
|
+
const char *SwishMetaName( SW_META );
|
57
|
+
int SwishMetaType( SW_META );
|
58
|
+
int SwishMetaID( SW_META );
|
59
|
+
|
60
|
+
/* Limit searches by structure */
|
61
|
+
|
62
|
+
#define IN_FILE_BIT 0
|
63
|
+
#define IN_TITLE_BIT 1
|
64
|
+
#define IN_HEAD_BIT 2
|
65
|
+
#define IN_BODY_BIT 3
|
66
|
+
#define IN_COMMENTS_BIT 4
|
67
|
+
#define IN_HEADER_BIT 5
|
68
|
+
#define IN_EMPHASIZED_BIT 6
|
69
|
+
#define IN_META_BIT 7
|
70
|
+
|
71
|
+
|
72
|
+
#define IN_FILE (1<<IN_FILE_BIT)
|
73
|
+
#define IN_TITLE (1<<IN_TITLE_BIT)
|
74
|
+
#define IN_HEAD (1<<IN_HEAD_BIT)
|
75
|
+
#define IN_BODY (1<<IN_BODY_BIT)
|
76
|
+
#define IN_COMMENTS (1<<IN_COMMENTS_BIT)
|
77
|
+
#define IN_HEADER (1<<IN_HEADER_BIT)
|
78
|
+
#define IN_EMPHASIZED (1<<IN_EMPHASIZED_BIT)
|
79
|
+
#define IN_META (1<<IN_META_BIT)
|
80
|
+
#define IN_ALL (IN_FILE|IN_TITLE|IN_HEAD|IN_BODY|IN_COMMENTS|IN_HEADER|IN_EMPHASIZED|IN_META)
|
81
|
+
|
82
|
+
|
83
|
+
|
84
|
+
SW_HANDLE SwishInit(char *);
|
85
|
+
|
86
|
+
SW_RESULTS SwishQuery(SW_HANDLE, char *words );
|
87
|
+
|
88
|
+
SW_SEARCH New_Search_Object( SW_HANDLE, char *query );
|
89
|
+
|
90
|
+
void SwishRankScheme( SW_HANDLE sw, int scheme );
|
91
|
+
void SwishSetRefPtr( SW_HANDLE sw, void *address );
|
92
|
+
void *SwishGetRefPtr( SW_HANDLE sw );
|
93
|
+
|
94
|
+
void *SwishSearch_parent( SW_SEARCH srch );
|
95
|
+
void *SwishResults_parent( SW_RESULTS results );
|
96
|
+
void *SwishResult_parent( SW_RESULT result );
|
97
|
+
void ResultsSetRefPtr( SW_RESULTS results, void *address );
|
98
|
+
|
99
|
+
void SwishSetStructure( SW_SEARCH srch, int structure );
|
100
|
+
void SwishPhraseDelimiter( SW_SEARCH srch, char delimiter );
|
101
|
+
void SwishSetSort( SW_SEARCH srch, char *sort );
|
102
|
+
void SwishSetQuery( SW_SEARCH srch, char *query );
|
103
|
+
|
104
|
+
int SwishSetSearchLimit( SW_SEARCH srch, char *propertyname, char *low, char *hi);
|
105
|
+
void SwishResetSearchLimit( SW_SEARCH srch );
|
106
|
+
|
107
|
+
SW_RESULTS SwishExecute( SW_SEARCH, char *optional_query );
|
108
|
+
|
109
|
+
/* Headers specific to results */
|
110
|
+
int SwishHits( SW_RESULTS );
|
111
|
+
SWISH_HEADER_VALUE SwishParsedWords( SW_RESULTS, const char *index_name );
|
112
|
+
SWISH_HEADER_VALUE SwishRemovedStopwords( SW_RESULTS, const char *index_name );
|
113
|
+
|
114
|
+
|
115
|
+
|
116
|
+
int SwishSeekResult( SW_RESULTS, int position );
|
117
|
+
SW_RESULT SwishNextResult( SW_RESULTS );
|
118
|
+
|
119
|
+
char *SwishResultPropertyStr(SW_RESULT, char *propertyname);
|
120
|
+
unsigned long SwishResultPropertyULong(SW_RESULT, char *propertyname);
|
121
|
+
SW_HANDLE SW_ResultToSW_HANDLE( SW_RESULT );
|
122
|
+
SW_HANDLE SW_ResultsToSW_HANDLE( SW_RESULTS );
|
123
|
+
|
124
|
+
void Free_Search_Object( SW_SEARCH srch );
|
125
|
+
void Free_Results_Object( SW_RESULTS results );
|
126
|
+
|
127
|
+
|
128
|
+
void SwishClose( SW_HANDLE );
|
129
|
+
|
130
|
+
|
131
|
+
int SwishError( SW_HANDLE ); /* test if error state - returns error number */
|
132
|
+
int SwishCriticalError( SW_HANDLE ); /* true if show stopping error */
|
133
|
+
void SwishAbortLastError( SW_HANDLE ); /* format and abort the error message */
|
134
|
+
|
135
|
+
char *SwishErrorString( SW_HANDLE ); /* string for the error number */
|
136
|
+
char *SwishLastErrorMsg( SW_HANDLE ); /* more specific message about the error */
|
137
|
+
|
138
|
+
void set_error_handle( FILE *where );
|
139
|
+
void SwishErrorsToStderr( void );
|
140
|
+
|
141
|
+
/* Returns all words that begin with the specified char */
|
142
|
+
const char *SwishWordsByLetter(SW_HANDLE, char *filename, char c);
|
143
|
+
|
144
|
+
|
145
|
+
/* Stemming Interface */
|
146
|
+
|
147
|
+
char *SwishStemWord( SW_HANDLE, char *word ); /* Really this is depreciated */
|
148
|
+
|
149
|
+
SW_FUZZYWORD SwishFuzzyWord( SW_RESULT r, char *word );
|
150
|
+
SW_FUZZYWORD SwishFuzzy( SW_HANDLE sw, const char *index_name, char *word );
|
151
|
+
const char **SwishFuzzyWordList( SW_FUZZYWORD fw );
|
152
|
+
int SwishFuzzyWordCount( SW_FUZZYWORD fw );
|
153
|
+
int SwishFuzzyWordError( SW_FUZZYWORD fw );
|
154
|
+
void SwishFuzzyWordFree( SW_FUZZYWORD fw );
|
155
|
+
const char *SwishFuzzyMode( SW_RESULT r );
|
156
|
+
|
157
|
+
/* For low-level access to a property */
|
158
|
+
|
159
|
+
typedef enum
|
160
|
+
{ /* Property Datatypes */
|
161
|
+
PROP_UNDEFINED = -1, /* a result does not have a value for that prop */
|
162
|
+
PROP_UNKNOWN = 0, /* invalid property requested (not really used anyplace) */
|
163
|
+
PROP_STRING,
|
164
|
+
PROP_INTEGER,
|
165
|
+
PROP_FLOAT,
|
166
|
+
PROP_DATE,
|
167
|
+
PROP_ULONG
|
168
|
+
}
|
169
|
+
PropType;
|
170
|
+
|
171
|
+
|
172
|
+
|
173
|
+
typedef union
|
174
|
+
{ /* storage of the PropertyValue */
|
175
|
+
char *v_str; /* strings */
|
176
|
+
int v_int; /* Integer */
|
177
|
+
time_t v_date; /* Date */
|
178
|
+
double v_float; /* Double Float */
|
179
|
+
unsigned long v_ulong; /* Unsigned long */
|
180
|
+
}
|
181
|
+
u_PropValue1;
|
182
|
+
|
183
|
+
typedef struct
|
184
|
+
{ /* Propvalue with type info */
|
185
|
+
PropType datatype;
|
186
|
+
u_PropValue1 value;
|
187
|
+
int destroy; /* flag to destroy (free) any pointer type */
|
188
|
+
}
|
189
|
+
PropValue;
|
190
|
+
|
191
|
+
PropValue *getResultPropValue (SW_RESULT result, char *name, int ID);
|
192
|
+
void freeResultPropValue(PropValue *pv);
|
193
|
+
|
data/ext/swishe_base.c
CHANGED
@@ -1,9 +1,6 @@
|
|
1
|
-
#include "stdio.h"
|
2
|
-
#include "swish-e.h"
|
3
|
-
|
4
1
|
/* ----------------------------------------------------------------------------
|
5
2
|
* This file was automatically generated by SWIG (http://www.swig.org).
|
6
|
-
* Version
|
3
|
+
* Version 2.0.7
|
7
4
|
*
|
8
5
|
* This file is not intended to be easily readable and contains a number of
|
9
6
|
* coding conventions designed to improve portability and efficiency. Do not make
|
@@ -12,6 +9,7 @@
|
|
12
9
|
* ----------------------------------------------------------------------------- */
|
13
10
|
|
14
11
|
#define SWIGRUBY
|
12
|
+
|
15
13
|
/* -----------------------------------------------------------------------------
|
16
14
|
* This section contains generic SWIG labels for method/variable
|
17
15
|
* declarations/attributes, and other compiler dependent labels.
|
@@ -19,14 +17,14 @@
|
|
19
17
|
|
20
18
|
/* template workaround for compilers that cannot correctly implement the C++ standard */
|
21
19
|
#ifndef SWIGTEMPLATEDISAMBIGUATOR
|
22
|
-
# if defined(__SUNPRO_CC)
|
23
|
-
#
|
24
|
-
#
|
25
|
-
|
26
|
-
|
27
|
-
#
|
20
|
+
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
|
21
|
+
# define SWIGTEMPLATEDISAMBIGUATOR template
|
22
|
+
# elif defined(__HP_aCC)
|
23
|
+
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
|
24
|
+
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
|
25
|
+
# define SWIGTEMPLATEDISAMBIGUATOR template
|
28
26
|
# else
|
29
|
-
#
|
27
|
+
# define SWIGTEMPLATEDISAMBIGUATOR
|
30
28
|
# endif
|
31
29
|
#endif
|
32
30
|
|
@@ -54,6 +52,12 @@
|
|
54
52
|
# endif
|
55
53
|
#endif
|
56
54
|
|
55
|
+
#ifndef SWIG_MSC_UNSUPPRESS_4505
|
56
|
+
# if defined(_MSC_VER)
|
57
|
+
# pragma warning(disable : 4505) /* unreferenced local function has been removed */
|
58
|
+
# endif
|
59
|
+
#endif
|
60
|
+
|
57
61
|
#ifndef SWIGUNUSEDPARM
|
58
62
|
# ifdef __cplusplus
|
59
63
|
# define SWIGUNUSEDPARM(p)
|
@@ -109,6 +113,12 @@
|
|
109
113
|
# define _CRT_SECURE_NO_DEPRECATE
|
110
114
|
#endif
|
111
115
|
|
116
|
+
/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
|
117
|
+
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
|
118
|
+
# define _SCL_SECURE_NO_DEPRECATE
|
119
|
+
#endif
|
120
|
+
|
121
|
+
|
112
122
|
/* -----------------------------------------------------------------------------
|
113
123
|
* This section contains generic SWIG labels for method/variable
|
114
124
|
* declarations/attributes, and other compiler dependent labels.
|
@@ -116,14 +126,14 @@
|
|
116
126
|
|
117
127
|
/* template workaround for compilers that cannot correctly implement the C++ standard */
|
118
128
|
#ifndef SWIGTEMPLATEDISAMBIGUATOR
|
119
|
-
# if defined(__SUNPRO_CC)
|
120
|
-
#
|
121
|
-
#
|
122
|
-
|
123
|
-
|
124
|
-
#
|
129
|
+
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
|
130
|
+
# define SWIGTEMPLATEDISAMBIGUATOR template
|
131
|
+
# elif defined(__HP_aCC)
|
132
|
+
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
|
133
|
+
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
|
134
|
+
# define SWIGTEMPLATEDISAMBIGUATOR template
|
125
135
|
# else
|
126
|
-
#
|
136
|
+
# define SWIGTEMPLATEDISAMBIGUATOR
|
127
137
|
# endif
|
128
138
|
#endif
|
129
139
|
|
@@ -151,6 +161,12 @@
|
|
151
161
|
# endif
|
152
162
|
#endif
|
153
163
|
|
164
|
+
#ifndef SWIG_MSC_UNSUPPRESS_4505
|
165
|
+
# if defined(_MSC_VER)
|
166
|
+
# pragma warning(disable : 4505) /* unreferenced local function has been removed */
|
167
|
+
# endif
|
168
|
+
#endif
|
169
|
+
|
154
170
|
#ifndef SWIGUNUSEDPARM
|
155
171
|
# ifdef __cplusplus
|
156
172
|
# define SWIGUNUSEDPARM(p)
|
@@ -206,16 +222,22 @@
|
|
206
222
|
# define _CRT_SECURE_NO_DEPRECATE
|
207
223
|
#endif
|
208
224
|
|
225
|
+
/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
|
226
|
+
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
|
227
|
+
# define _SCL_SECURE_NO_DEPRECATE
|
228
|
+
#endif
|
229
|
+
|
230
|
+
|
209
231
|
/* -----------------------------------------------------------------------------
|
210
232
|
* swigrun.swg
|
211
233
|
*
|
212
|
-
* This file contains generic
|
234
|
+
* This file contains generic C API SWIG runtime support for pointer
|
213
235
|
* type checking.
|
214
236
|
* ----------------------------------------------------------------------------- */
|
215
237
|
|
216
238
|
/* This should only be incremented when either the layout of swig_type_info changes,
|
217
239
|
or for whatever reason, the runtime changes incompatibly */
|
218
|
-
#define SWIG_RUNTIME_VERSION "
|
240
|
+
#define SWIG_RUNTIME_VERSION "4"
|
219
241
|
|
220
242
|
/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
|
221
243
|
#ifdef SWIG_TYPE_TABLE
|
@@ -228,11 +250,11 @@
|
|
228
250
|
|
229
251
|
/*
|
230
252
|
You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
|
231
|
-
creating a static or dynamic library from the
|
232
|
-
In 99.9% of the cases,
|
253
|
+
creating a static or dynamic library from the SWIG runtime code.
|
254
|
+
In 99.9% of the cases, SWIG just needs to declare them as 'static'.
|
233
255
|
|
234
|
-
But only do this if
|
235
|
-
with your compiler or
|
256
|
+
But only do this if strictly necessary, ie, if you have problems
|
257
|
+
with your compiler or suchlike.
|
236
258
|
*/
|
237
259
|
|
238
260
|
#ifndef SWIGRUNTIME
|
@@ -250,6 +272,7 @@
|
|
250
272
|
|
251
273
|
/* Flags for pointer conversions */
|
252
274
|
#define SWIG_POINTER_DISOWN 0x1
|
275
|
+
#define SWIG_CAST_NEW_MEMORY 0x2
|
253
276
|
|
254
277
|
/* Flags for new pointer objects */
|
255
278
|
#define SWIG_POINTER_OWN 0x1
|
@@ -258,14 +281,14 @@
|
|
258
281
|
/*
|
259
282
|
Flags/methods for returning states.
|
260
283
|
|
261
|
-
The
|
284
|
+
The SWIG conversion methods, as ConvertPtr, return an integer
|
262
285
|
that tells if the conversion was successful or not. And if not,
|
263
286
|
an error code can be returned (see swigerrors.swg for the codes).
|
264
287
|
|
265
288
|
Use the following macros/flags to set or process the returning
|
266
289
|
states.
|
267
290
|
|
268
|
-
In old
|
291
|
+
In old versions of SWIG, code such as the following was usually written:
|
269
292
|
|
270
293
|
if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
|
271
294
|
// success code
|
@@ -273,7 +296,7 @@
|
|
273
296
|
//fail code
|
274
297
|
}
|
275
298
|
|
276
|
-
Now you can be more explicit
|
299
|
+
Now you can be more explicit:
|
277
300
|
|
278
301
|
int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
|
279
302
|
if (SWIG_IsOK(res)) {
|
@@ -282,7 +305,7 @@
|
|
282
305
|
// fail code
|
283
306
|
}
|
284
307
|
|
285
|
-
|
308
|
+
which is the same really, but now you can also do
|
286
309
|
|
287
310
|
Type *ptr;
|
288
311
|
int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
|
@@ -300,7 +323,7 @@
|
|
300
323
|
|
301
324
|
I.e., now SWIG_ConvertPtr can return new objects and you can
|
302
325
|
identify the case and take care of the deallocation. Of course that
|
303
|
-
|
326
|
+
also requires SWIG_ConvertPtr to return new result values, such as
|
304
327
|
|
305
328
|
int SWIG_ConvertPtr(obj, ptr,...) {
|
306
329
|
if (<obj is ok>) {
|
@@ -318,7 +341,7 @@
|
|
318
341
|
|
319
342
|
Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
|
320
343
|
more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
|
321
|
-
|
344
|
+
SWIG errors code.
|
322
345
|
|
323
346
|
Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
|
324
347
|
allows to return the 'cast rank', for example, if you have this
|
@@ -332,9 +355,8 @@
|
|
332
355
|
fooi(1) // cast rank '0'
|
333
356
|
|
334
357
|
just use the SWIG_AddCast()/SWIG_CheckState()
|
358
|
+
*/
|
335
359
|
|
336
|
-
|
337
|
-
*/
|
338
360
|
#define SWIG_OK (0)
|
339
361
|
#define SWIG_ERROR (-1)
|
340
362
|
#define SWIG_IsOK(r) (r >= 0)
|
@@ -359,7 +381,6 @@
|
|
359
381
|
#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
|
360
382
|
#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
|
361
383
|
|
362
|
-
|
363
384
|
/* Cast-Rank Mode */
|
364
385
|
#if defined(SWIG_CASTRANK_MODE)
|
365
386
|
# ifndef SWIG_TypeRank
|
@@ -382,18 +403,16 @@ SWIGINTERNINLINE int SWIG_CheckState(int r) {
|
|
382
403
|
#endif
|
383
404
|
|
384
405
|
|
385
|
-
|
386
|
-
|
387
406
|
#include <string.h>
|
388
407
|
|
389
408
|
#ifdef __cplusplus
|
390
409
|
extern "C" {
|
391
410
|
#endif
|
392
411
|
|
393
|
-
typedef void *(*swig_converter_func)(void *);
|
412
|
+
typedef void *(*swig_converter_func)(void *, int *);
|
394
413
|
typedef struct swig_type_info *(*swig_dycast_func)(void **);
|
395
414
|
|
396
|
-
/* Structure to store
|
415
|
+
/* Structure to store information on one type */
|
397
416
|
typedef struct swig_type_info {
|
398
417
|
const char *name; /* mangled name of this type */
|
399
418
|
const char *str; /* human readable name of this type */
|
@@ -438,7 +457,7 @@ SWIG_TypeNameComp(const char *f1, const char *l1,
|
|
438
457
|
while ((*f2 == ' ') && (f2 != l2)) ++f2;
|
439
458
|
if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
|
440
459
|
}
|
441
|
-
return (l1 - f1) - (l2 - f2);
|
460
|
+
return (int)((l1 - f1) - (l2 - f2));
|
442
461
|
}
|
443
462
|
|
444
463
|
/*
|
@@ -480,48 +499,66 @@ SWIG_TypeCompare(const char *nb, const char *tb) {
|
|
480
499
|
}
|
481
500
|
|
482
501
|
|
483
|
-
/* think of this as a c++ template<> or a scheme macro */
|
484
|
-
#define SWIG_TypeCheck_Template(comparison, ty) \
|
485
|
-
if (ty) { \
|
486
|
-
swig_cast_info *iter = ty->cast; \
|
487
|
-
while (iter) { \
|
488
|
-
if (comparison) { \
|
489
|
-
if (iter == ty->cast) return iter; \
|
490
|
-
/* Move iter to the top of the linked list */ \
|
491
|
-
iter->prev->next = iter->next; \
|
492
|
-
if (iter->next) \
|
493
|
-
iter->next->prev = iter->prev; \
|
494
|
-
iter->next = ty->cast; \
|
495
|
-
iter->prev = 0; \
|
496
|
-
if (ty->cast) ty->cast->prev = iter; \
|
497
|
-
ty->cast = iter; \
|
498
|
-
return iter; \
|
499
|
-
} \
|
500
|
-
iter = iter->next; \
|
501
|
-
} \
|
502
|
-
} \
|
503
|
-
return 0
|
504
|
-
|
505
502
|
/*
|
506
503
|
Check the typename
|
507
504
|
*/
|
508
505
|
SWIGRUNTIME swig_cast_info *
|
509
506
|
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
|
510
|
-
|
507
|
+
if (ty) {
|
508
|
+
swig_cast_info *iter = ty->cast;
|
509
|
+
while (iter) {
|
510
|
+
if (strcmp(iter->type->name, c) == 0) {
|
511
|
+
if (iter == ty->cast)
|
512
|
+
return iter;
|
513
|
+
/* Move iter to the top of the linked list */
|
514
|
+
iter->prev->next = iter->next;
|
515
|
+
if (iter->next)
|
516
|
+
iter->next->prev = iter->prev;
|
517
|
+
iter->next = ty->cast;
|
518
|
+
iter->prev = 0;
|
519
|
+
if (ty->cast) ty->cast->prev = iter;
|
520
|
+
ty->cast = iter;
|
521
|
+
return iter;
|
522
|
+
}
|
523
|
+
iter = iter->next;
|
524
|
+
}
|
525
|
+
}
|
526
|
+
return 0;
|
511
527
|
}
|
512
528
|
|
513
|
-
/*
|
529
|
+
/*
|
530
|
+
Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
|
531
|
+
*/
|
514
532
|
SWIGRUNTIME swig_cast_info *
|
515
|
-
SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *
|
516
|
-
|
533
|
+
SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
|
534
|
+
if (ty) {
|
535
|
+
swig_cast_info *iter = ty->cast;
|
536
|
+
while (iter) {
|
537
|
+
if (iter->type == from) {
|
538
|
+
if (iter == ty->cast)
|
539
|
+
return iter;
|
540
|
+
/* Move iter to the top of the linked list */
|
541
|
+
iter->prev->next = iter->next;
|
542
|
+
if (iter->next)
|
543
|
+
iter->next->prev = iter->prev;
|
544
|
+
iter->next = ty->cast;
|
545
|
+
iter->prev = 0;
|
546
|
+
if (ty->cast) ty->cast->prev = iter;
|
547
|
+
ty->cast = iter;
|
548
|
+
return iter;
|
549
|
+
}
|
550
|
+
iter = iter->next;
|
551
|
+
}
|
552
|
+
}
|
553
|
+
return 0;
|
517
554
|
}
|
518
555
|
|
519
556
|
/*
|
520
557
|
Cast a pointer up an inheritance hierarchy
|
521
558
|
*/
|
522
559
|
SWIGRUNTIMEINLINE void *
|
523
|
-
SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
|
524
|
-
return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
|
560
|
+
SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
|
561
|
+
return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
|
525
562
|
}
|
526
563
|
|
527
564
|
/*
|
@@ -794,6 +831,33 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
|
|
794
831
|
|
795
832
|
#include <ruby.h>
|
796
833
|
|
834
|
+
/* Ruby 1.9.1 has a "memoisation optimisation" when compiling with GCC which
|
835
|
+
* breaks using rb_intern as an lvalue, as SWIG does. We work around this
|
836
|
+
* issue for now by disabling this.
|
837
|
+
* https://sourceforge.net/tracker/?func=detail&aid=2859614&group_id=1645&atid=101645
|
838
|
+
*/
|
839
|
+
#ifdef rb_intern
|
840
|
+
# undef rb_intern
|
841
|
+
#endif
|
842
|
+
|
843
|
+
/* Remove global macros defined in Ruby's win32.h */
|
844
|
+
#ifdef write
|
845
|
+
# undef write
|
846
|
+
#endif
|
847
|
+
#ifdef read
|
848
|
+
# undef read
|
849
|
+
#endif
|
850
|
+
#ifdef bind
|
851
|
+
# undef bind
|
852
|
+
#endif
|
853
|
+
#ifdef close
|
854
|
+
# undef close
|
855
|
+
#endif
|
856
|
+
#ifdef connect
|
857
|
+
# undef connect
|
858
|
+
#endif
|
859
|
+
|
860
|
+
|
797
861
|
/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
|
798
862
|
#ifndef NUM2LL
|
799
863
|
#define NUM2LL(x) NUM2LONG((x))
|
@@ -822,12 +886,44 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
|
|
822
886
|
#ifndef RSTRING_PTR
|
823
887
|
# define RSTRING_PTR(x) RSTRING(x)->ptr
|
824
888
|
#endif
|
889
|
+
#ifndef RSTRING_END
|
890
|
+
# define RSTRING_END(x) (RSTRING_PTR(x) + RSTRING_LEN(x))
|
891
|
+
#endif
|
825
892
|
#ifndef RARRAY_LEN
|
826
893
|
# define RARRAY_LEN(x) RARRAY(x)->len
|
827
894
|
#endif
|
828
895
|
#ifndef RARRAY_PTR
|
829
896
|
# define RARRAY_PTR(x) RARRAY(x)->ptr
|
830
897
|
#endif
|
898
|
+
#ifndef RFLOAT_VALUE
|
899
|
+
# define RFLOAT_VALUE(x) RFLOAT(x)->value
|
900
|
+
#endif
|
901
|
+
#ifndef DOUBLE2NUM
|
902
|
+
# define DOUBLE2NUM(x) rb_float_new(x)
|
903
|
+
#endif
|
904
|
+
#ifndef RHASH_TBL
|
905
|
+
# define RHASH_TBL(x) (RHASH(x)->tbl)
|
906
|
+
#endif
|
907
|
+
#ifndef RHASH_ITER_LEV
|
908
|
+
# define RHASH_ITER_LEV(x) (RHASH(x)->iter_lev)
|
909
|
+
#endif
|
910
|
+
#ifndef RHASH_IFNONE
|
911
|
+
# define RHASH_IFNONE(x) (RHASH(x)->ifnone)
|
912
|
+
#endif
|
913
|
+
#ifndef RHASH_SIZE
|
914
|
+
# define RHASH_SIZE(x) (RHASH(x)->tbl->num_entries)
|
915
|
+
#endif
|
916
|
+
#ifndef RHASH_EMPTY_P
|
917
|
+
# define RHASH_EMPTY_P(x) (RHASH_SIZE(x) == 0)
|
918
|
+
#endif
|
919
|
+
#ifndef RSTRUCT_LEN
|
920
|
+
# define RSTRUCT_LEN(x) RSTRUCT(x)->len
|
921
|
+
#endif
|
922
|
+
#ifndef RSTRUCT_PTR
|
923
|
+
# define RSTRUCT_PTR(x) RSTRUCT(x)->ptr
|
924
|
+
#endif
|
925
|
+
|
926
|
+
|
831
927
|
|
832
928
|
/*
|
833
929
|
* Need to be very careful about how these macros are defined, especially
|
@@ -889,6 +985,7 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
|
|
889
985
|
#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
|
890
986
|
#endif
|
891
987
|
|
988
|
+
static VALUE _mSWIG = Qnil;
|
892
989
|
|
893
990
|
/* -----------------------------------------------------------------------------
|
894
991
|
* error manipulation
|
@@ -901,7 +998,7 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
|
|
901
998
|
|
902
999
|
/* Define custom exceptions for errors that do not map to existing Ruby
|
903
1000
|
exceptions. Note this only works for C++ since a global cannot be
|
904
|
-
initialized by a
|
1001
|
+
initialized by a function in C. For C, fallback to rb_eRuntimeError.*/
|
905
1002
|
|
906
1003
|
SWIGINTERN VALUE
|
907
1004
|
getNullReferenceError(void) {
|
@@ -979,12 +1076,73 @@ SWIG_Ruby_ErrorType(int SWIG_code) {
|
|
979
1076
|
}
|
980
1077
|
|
981
1078
|
|
1079
|
+
/* This function is called when a user inputs a wrong argument to
|
1080
|
+
a method.
|
1081
|
+
*/
|
1082
|
+
SWIGINTERN
|
1083
|
+
const char* Ruby_Format_TypeError( const char* msg,
|
1084
|
+
const char* type,
|
1085
|
+
const char* name,
|
1086
|
+
const int argn,
|
1087
|
+
VALUE input )
|
1088
|
+
{
|
1089
|
+
char buf[128];
|
1090
|
+
VALUE str;
|
1091
|
+
VALUE asStr;
|
1092
|
+
if ( msg && *msg )
|
1093
|
+
{
|
1094
|
+
str = rb_str_new2(msg);
|
1095
|
+
}
|
1096
|
+
else
|
1097
|
+
{
|
1098
|
+
str = rb_str_new(NULL, 0);
|
1099
|
+
}
|
1100
|
+
|
1101
|
+
str = rb_str_cat2( str, "Expected argument " );
|
1102
|
+
sprintf( buf, "%d of type ", argn-1 );
|
1103
|
+
str = rb_str_cat2( str, buf );
|
1104
|
+
str = rb_str_cat2( str, type );
|
1105
|
+
str = rb_str_cat2( str, ", but got " );
|
1106
|
+
str = rb_str_cat2( str, rb_obj_classname(input) );
|
1107
|
+
str = rb_str_cat2( str, " " );
|
1108
|
+
asStr = rb_inspect(input);
|
1109
|
+
if ( RSTRING_LEN(asStr) > 30 )
|
1110
|
+
{
|
1111
|
+
str = rb_str_cat( str, StringValuePtr(asStr), 30 );
|
1112
|
+
str = rb_str_cat2( str, "..." );
|
1113
|
+
}
|
1114
|
+
else
|
1115
|
+
{
|
1116
|
+
str = rb_str_append( str, asStr );
|
1117
|
+
}
|
1118
|
+
|
1119
|
+
if ( name )
|
1120
|
+
{
|
1121
|
+
str = rb_str_cat2( str, "\n\tin SWIG method '" );
|
1122
|
+
str = rb_str_cat2( str, name );
|
1123
|
+
str = rb_str_cat2( str, "'" );
|
1124
|
+
}
|
982
1125
|
|
1126
|
+
return StringValuePtr( str );
|
1127
|
+
}
|
1128
|
+
|
1129
|
+
/* This function is called when an overloaded method fails */
|
1130
|
+
SWIGINTERN
|
1131
|
+
void Ruby_Format_OverloadedError(
|
1132
|
+
const int argc,
|
1133
|
+
const int maxargs,
|
1134
|
+
const char* method,
|
1135
|
+
const char* prototypes
|
1136
|
+
)
|
1137
|
+
{
|
1138
|
+
const char* msg = "Wrong # of arguments";
|
1139
|
+
if ( argc <= maxargs ) msg = "Wrong arguments";
|
1140
|
+
rb_raise(rb_eArgError,"%s for overloaded method '%s'.\n"
|
1141
|
+
"Possible C/C++ prototypes are:\n%s",
|
1142
|
+
msg, method, prototypes);
|
1143
|
+
}
|
983
1144
|
|
984
1145
|
/* -----------------------------------------------------------------------------
|
985
|
-
* See the LICENSE file for information on copyright, usage and redistribution
|
986
|
-
* of SWIG, and the README file for authors - http://www.swig.org/release.html.
|
987
|
-
*
|
988
1146
|
* rubytracking.swg
|
989
1147
|
*
|
990
1148
|
* This file contains support for tracking mappings from
|
@@ -997,23 +1155,51 @@ SWIG_Ruby_ErrorType(int SWIG_code) {
|
|
997
1155
|
extern "C" {
|
998
1156
|
#endif
|
999
1157
|
|
1158
|
+
/* Ruby 1.8 actually assumes the first case. */
|
1159
|
+
#if SIZEOF_VOIDP == SIZEOF_LONG
|
1160
|
+
# define SWIG2NUM(v) LONG2NUM((unsigned long)v)
|
1161
|
+
# define NUM2SWIG(x) (unsigned long)NUM2LONG(x)
|
1162
|
+
#elif SIZEOF_VOIDP == SIZEOF_LONG_LONG
|
1163
|
+
# define SWIG2NUM(v) LL2NUM((unsigned long long)v)
|
1164
|
+
# define NUM2SWIG(x) (unsigned long long)NUM2LL(x)
|
1165
|
+
#else
|
1166
|
+
# error sizeof(void*) is not the same as long or long long
|
1167
|
+
#endif
|
1168
|
+
|
1000
1169
|
|
1001
1170
|
/* Global Ruby hash table to store Trackings from C/C++
|
1002
|
-
structs to Ruby Objects.
|
1003
|
-
|
1171
|
+
structs to Ruby Objects.
|
1172
|
+
*/
|
1173
|
+
static VALUE swig_ruby_trackings = Qnil;
|
1004
1174
|
|
1005
1175
|
/* Global variable that stores a reference to the ruby
|
1006
1176
|
hash table delete function. */
|
1007
|
-
static ID swig_ruby_hash_delete
|
1177
|
+
static ID swig_ruby_hash_delete;
|
1008
1178
|
|
1009
1179
|
/* Setup a Ruby hash table to store Trackings */
|
1010
1180
|
SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
|
1011
1181
|
/* Create a ruby hash table to store Trackings from C++
|
1012
|
-
objects to Ruby objects.
|
1013
|
-
|
1014
|
-
|
1015
|
-
|
1016
|
-
|
1182
|
+
objects to Ruby objects. */
|
1183
|
+
|
1184
|
+
/* Try to see if some other .so has already created a
|
1185
|
+
tracking hash table, which we keep hidden in an instance var
|
1186
|
+
in the SWIG module.
|
1187
|
+
This is done to allow multiple DSOs to share the same
|
1188
|
+
tracking table.
|
1189
|
+
*/
|
1190
|
+
ID trackings_id = rb_intern( "@__trackings__" );
|
1191
|
+
VALUE verbose = rb_gv_get("VERBOSE");
|
1192
|
+
rb_gv_set("VERBOSE", Qfalse);
|
1193
|
+
swig_ruby_trackings = rb_ivar_get( _mSWIG, trackings_id );
|
1194
|
+
rb_gv_set("VERBOSE", verbose);
|
1195
|
+
|
1196
|
+
/* No, it hasn't. Create one ourselves */
|
1197
|
+
if ( swig_ruby_trackings == Qnil )
|
1198
|
+
{
|
1199
|
+
swig_ruby_trackings = rb_hash_new();
|
1200
|
+
rb_ivar_set( _mSWIG, trackings_id, swig_ruby_trackings );
|
1201
|
+
}
|
1202
|
+
|
1017
1203
|
/* Now store a reference to the hash table delete function
|
1018
1204
|
so that we only have to look it up once.*/
|
1019
1205
|
swig_ruby_hash_delete = rb_intern("delete");
|
@@ -1026,8 +1212,7 @@ SWIGRUNTIME VALUE SWIG_RubyPtrToReference(void* ptr) {
|
|
1026
1212
|
a Ruby number object. */
|
1027
1213
|
|
1028
1214
|
/* Convert the pointer to a Ruby number */
|
1029
|
-
|
1030
|
-
return LONG2NUM(value);
|
1215
|
+
return SWIG2NUM(ptr);
|
1031
1216
|
}
|
1032
1217
|
|
1033
1218
|
/* Get a Ruby number to reference an object */
|
@@ -1037,8 +1222,7 @@ SWIGRUNTIME VALUE SWIG_RubyObjectToReference(VALUE object) {
|
|
1037
1222
|
a Ruby number object. */
|
1038
1223
|
|
1039
1224
|
/* Convert the Object to a Ruby number */
|
1040
|
-
|
1041
|
-
return LONG2NUM(value);
|
1225
|
+
return SWIG2NUM(object);
|
1042
1226
|
}
|
1043
1227
|
|
1044
1228
|
/* Get a Ruby object from a previously stored reference */
|
@@ -1046,9 +1230,8 @@ SWIGRUNTIME VALUE SWIG_RubyReferenceToObject(VALUE reference) {
|
|
1046
1230
|
/* The provided Ruby number object is a reference
|
1047
1231
|
to the Ruby object we want.*/
|
1048
1232
|
|
1049
|
-
/*
|
1050
|
-
|
1051
|
-
return (VALUE) value;
|
1233
|
+
/* Convert the Ruby number to a Ruby object */
|
1234
|
+
return NUM2SWIG(reference);
|
1052
1235
|
}
|
1053
1236
|
|
1054
1237
|
/* Add a Tracking from a C/C++ struct to a Ruby object */
|
@@ -1140,15 +1323,21 @@ SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
|
|
1140
1323
|
return target;
|
1141
1324
|
}
|
1142
1325
|
|
1326
|
+
/* For ruby1.8.4 and earlier. */
|
1327
|
+
#ifndef RUBY_INIT_STACK
|
1328
|
+
RUBY_EXTERN void Init_stack(VALUE* addr);
|
1329
|
+
# define RUBY_INIT_STACK \
|
1330
|
+
VALUE variable_in_this_stack_frame; \
|
1331
|
+
Init_stack(&variable_in_this_stack_frame);
|
1332
|
+
#endif
|
1333
|
+
|
1334
|
+
|
1143
1335
|
#ifdef __cplusplus
|
1144
1336
|
}
|
1145
1337
|
#endif
|
1146
1338
|
|
1147
1339
|
|
1148
1340
|
/* -----------------------------------------------------------------------------
|
1149
|
-
* See the LICENSE file for information on copyright, usage and redistribution
|
1150
|
-
* of SWIG, and the README file for authors - http://www.swig.org/release.html.
|
1151
|
-
*
|
1152
1341
|
* rubyrun.swg
|
1153
1342
|
*
|
1154
1343
|
* This file contains the runtime support for Ruby modules
|
@@ -1192,7 +1381,7 @@ SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
|
|
1192
1381
|
/* Error manipulation */
|
1193
1382
|
|
1194
1383
|
#define SWIG_ErrorType(code) SWIG_Ruby_ErrorType(code)
|
1195
|
-
#define SWIG_Error(code, msg) rb_raise(SWIG_Ruby_ErrorType(code), msg)
|
1384
|
+
#define SWIG_Error(code, msg) rb_raise(SWIG_Ruby_ErrorType(code), "%s", msg)
|
1196
1385
|
#define SWIG_fail goto fail
|
1197
1386
|
|
1198
1387
|
|
@@ -1204,6 +1393,7 @@ SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
|
|
1204
1393
|
#define SWIG_MangleStr(value) SWIG_Ruby_MangleStr(value)
|
1205
1394
|
#define SWIG_CheckConvert(value, ty) SWIG_Ruby_CheckConvert(value, ty)
|
1206
1395
|
|
1396
|
+
#include "assert.h"
|
1207
1397
|
|
1208
1398
|
/* -----------------------------------------------------------------------------
|
1209
1399
|
* pointers/data manipulation
|
@@ -1211,9 +1401,6 @@ SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
|
|
1211
1401
|
|
1212
1402
|
#ifdef __cplusplus
|
1213
1403
|
extern "C" {
|
1214
|
-
#if 0
|
1215
|
-
} /* cc-mode */
|
1216
|
-
#endif
|
1217
1404
|
#endif
|
1218
1405
|
|
1219
1406
|
typedef struct {
|
@@ -1225,10 +1412,44 @@ typedef struct {
|
|
1225
1412
|
} swig_class;
|
1226
1413
|
|
1227
1414
|
|
1228
|
-
|
1415
|
+
/* Global pointer used to keep some internal SWIG stuff */
|
1229
1416
|
static VALUE _cSWIG_Pointer = Qnil;
|
1230
1417
|
static VALUE swig_runtime_data_type_pointer = Qnil;
|
1231
1418
|
|
1419
|
+
/* Global IDs used to keep some internal SWIG stuff */
|
1420
|
+
static ID swig_arity_id = 0;
|
1421
|
+
static ID swig_call_id = 0;
|
1422
|
+
|
1423
|
+
/*
|
1424
|
+
If your swig extension is to be run within an embedded ruby and has
|
1425
|
+
director callbacks, you should set -DRUBY_EMBEDDED during compilation.
|
1426
|
+
This will reset ruby's stack frame on each entry point from the main
|
1427
|
+
program the first time a virtual director function is invoked (in a
|
1428
|
+
non-recursive way).
|
1429
|
+
If this is not done, you run the risk of Ruby trashing the stack.
|
1430
|
+
*/
|
1431
|
+
|
1432
|
+
#ifdef RUBY_EMBEDDED
|
1433
|
+
|
1434
|
+
# define SWIG_INIT_STACK \
|
1435
|
+
if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \
|
1436
|
+
++swig_virtual_calls;
|
1437
|
+
# define SWIG_RELEASE_STACK --swig_virtual_calls;
|
1438
|
+
# define Ruby_DirectorTypeMismatchException(x) \
|
1439
|
+
rb_raise( rb_eTypeError, "%s", x ); return c_result;
|
1440
|
+
|
1441
|
+
static unsigned int swig_virtual_calls = 0;
|
1442
|
+
|
1443
|
+
#else /* normal non-embedded extension */
|
1444
|
+
|
1445
|
+
# define SWIG_INIT_STACK
|
1446
|
+
# define SWIG_RELEASE_STACK
|
1447
|
+
# define Ruby_DirectorTypeMismatchException(x) \
|
1448
|
+
throw Swig::DirectorTypeMismatchException( x );
|
1449
|
+
|
1450
|
+
#endif /* RUBY_EMBEDDED */
|
1451
|
+
|
1452
|
+
|
1232
1453
|
SWIGRUNTIME VALUE
|
1233
1454
|
getExceptionClass(void) {
|
1234
1455
|
static int init = 0;
|
@@ -1260,6 +1481,8 @@ SWIG_Ruby_InitRuntime(void)
|
|
1260
1481
|
{
|
1261
1482
|
if (_mSWIG == Qnil) {
|
1262
1483
|
_mSWIG = rb_define_module("SWIG");
|
1484
|
+
swig_call_id = rb_intern("call");
|
1485
|
+
swig_arity_id = rb_intern("arity");
|
1263
1486
|
}
|
1264
1487
|
}
|
1265
1488
|
|
@@ -1283,7 +1506,7 @@ SWIGRUNTIME VALUE
|
|
1283
1506
|
SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
|
1284
1507
|
{
|
1285
1508
|
int own = flags & SWIG_POINTER_OWN;
|
1286
|
-
|
1509
|
+
int track;
|
1287
1510
|
char *klass_name;
|
1288
1511
|
swig_class *sklass;
|
1289
1512
|
VALUE klass;
|
@@ -1296,15 +1519,16 @@ SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
|
|
1296
1519
|
sklass = (swig_class *) type->clientdata;
|
1297
1520
|
|
1298
1521
|
/* Are we tracking this class and have we already returned this Ruby object? */
|
1299
|
-
|
1522
|
+
track = sklass->trackObjects;
|
1523
|
+
if (track) {
|
1300
1524
|
obj = SWIG_RubyInstanceFor(ptr);
|
1301
1525
|
|
1302
1526
|
/* Check the object's type and make sure it has the correct type.
|
1303
1527
|
It might not in cases where methods do things like
|
1304
1528
|
downcast methods. */
|
1305
1529
|
if (obj != Qnil) {
|
1306
|
-
VALUE value = rb_iv_get(obj, "__swigtype__");
|
1307
|
-
char* type_name = RSTRING_PTR(value);
|
1530
|
+
VALUE value = rb_iv_get(obj, "@__swigtype__");
|
1531
|
+
const char* type_name = RSTRING_PTR(value);
|
1308
1532
|
|
1309
1533
|
if (strcmp(type->name, type_name) == 0) {
|
1310
1534
|
return obj;
|
@@ -1313,10 +1537,13 @@ SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
|
|
1313
1537
|
}
|
1314
1538
|
|
1315
1539
|
/* Create a new Ruby object */
|
1316
|
-
obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark),
|
1540
|
+
obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark),
|
1541
|
+
( own ? VOIDFUNC(sklass->destroy) :
|
1542
|
+
(track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )
|
1543
|
+
), ptr);
|
1317
1544
|
|
1318
1545
|
/* If tracking is on for this class then track this object. */
|
1319
|
-
if (
|
1546
|
+
if (track) {
|
1320
1547
|
SWIG_RubyAddTracking(ptr, obj);
|
1321
1548
|
}
|
1322
1549
|
} else {
|
@@ -1326,7 +1553,7 @@ SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
|
|
1326
1553
|
free((void *) klass_name);
|
1327
1554
|
obj = Data_Wrap_Struct(klass, 0, 0, ptr);
|
1328
1555
|
}
|
1329
|
-
rb_iv_set(obj, "__swigtype__", rb_str_new2(type->name));
|
1556
|
+
rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
|
1330
1557
|
|
1331
1558
|
return obj;
|
1332
1559
|
}
|
@@ -1338,7 +1565,7 @@ SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
|
|
1338
1565
|
VALUE obj;
|
1339
1566
|
swig_class *sklass = (swig_class *) type->clientdata;
|
1340
1567
|
obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
|
1341
|
-
rb_iv_set(obj, "__swigtype__", rb_str_new2(type->name));
|
1568
|
+
rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
|
1342
1569
|
return obj;
|
1343
1570
|
}
|
1344
1571
|
|
@@ -1346,7 +1573,7 @@ SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
|
|
1346
1573
|
SWIGRUNTIMEINLINE char *
|
1347
1574
|
SWIG_Ruby_MangleStr(VALUE obj)
|
1348
1575
|
{
|
1349
|
-
VALUE stype = rb_iv_get(obj, "__swigtype__");
|
1576
|
+
VALUE stype = rb_iv_get(obj, "@__swigtype__");
|
1350
1577
|
return StringValuePtr(stype);
|
1351
1578
|
}
|
1352
1579
|
|
@@ -1428,8 +1655,11 @@ SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags,
|
|
1428
1655
|
tc = SWIG_TypeCheck(c, ty);
|
1429
1656
|
if (!tc) {
|
1430
1657
|
return SWIG_ERROR;
|
1658
|
+
} else {
|
1659
|
+
int newmemory = 0;
|
1660
|
+
*ptr = SWIG_TypeCast(tc, vptr, &newmemory);
|
1661
|
+
assert(!newmemory); /* newmemory handling not yet implemented */
|
1431
1662
|
}
|
1432
|
-
*ptr = SWIG_TypeCast(tc, vptr);
|
1433
1663
|
} else {
|
1434
1664
|
*ptr = vptr;
|
1435
1665
|
}
|
@@ -1510,10 +1740,42 @@ SWIG_Ruby_SetModule(swig_module_info *pointer)
|
|
1510
1740
|
rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
|
1511
1741
|
}
|
1512
1742
|
|
1743
|
+
/* This function can be used to check whether a proc or method or similarly
|
1744
|
+
callable function has been passed. Usually used in a %typecheck, like:
|
1745
|
+
|
1746
|
+
%typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) {
|
1747
|
+
$result = SWIG_Ruby_isCallable( $input );
|
1748
|
+
}
|
1749
|
+
*/
|
1750
|
+
SWIGINTERN
|
1751
|
+
int SWIG_Ruby_isCallable( VALUE proc )
|
1752
|
+
{
|
1753
|
+
if ( rb_respond_to( proc, swig_call_id ) == Qtrue )
|
1754
|
+
return 1;
|
1755
|
+
return 0;
|
1756
|
+
}
|
1757
|
+
|
1758
|
+
/* This function can be used to check the arity (number of arguments)
|
1759
|
+
a proc or method can take. Usually used in a %typecheck.
|
1760
|
+
Valid arities will be that equal to minimal or those < 0
|
1761
|
+
which indicate a variable number of parameters at the end.
|
1762
|
+
*/
|
1763
|
+
SWIGINTERN
|
1764
|
+
int SWIG_Ruby_arity( VALUE proc, int minimal )
|
1765
|
+
{
|
1766
|
+
if ( rb_respond_to( proc, swig_arity_id ) == Qtrue )
|
1767
|
+
{
|
1768
|
+
VALUE num = rb_funcall( proc, swig_arity_id, 0 );
|
1769
|
+
int arity = NUM2INT(num);
|
1770
|
+
if ( arity < 0 && (arity+1) < -minimal ) return 1;
|
1771
|
+
if ( arity == minimal ) return 1;
|
1772
|
+
return 1;
|
1773
|
+
}
|
1774
|
+
return 0;
|
1775
|
+
}
|
1776
|
+
|
1777
|
+
|
1513
1778
|
#ifdef __cplusplus
|
1514
|
-
#if 0
|
1515
|
-
{ /* cc-mode */
|
1516
|
-
#endif
|
1517
1779
|
}
|
1518
1780
|
#endif
|
1519
1781
|
|
@@ -1550,7 +1812,11 @@ static swig_module_info swig_module = {swig_types, 11, 0, 0, 0, 0};
|
|
1550
1812
|
|
1551
1813
|
static VALUE mSwishe_base;
|
1552
1814
|
|
1553
|
-
#define
|
1815
|
+
#define SWIG_RUBY_THREAD_BEGIN_BLOCK
|
1816
|
+
#define SWIG_RUBY_THREAD_END_BLOCK
|
1817
|
+
|
1818
|
+
|
1819
|
+
#define SWIGVERSION 0x020007
|
1554
1820
|
#define SWIG_VERSION SWIGVERSION
|
1555
1821
|
|
1556
1822
|
|
@@ -1558,15 +1824,18 @@ static VALUE mSwishe_base;
|
|
1558
1824
|
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
|
1559
1825
|
|
1560
1826
|
|
1827
|
+
#include "stdio.h"
|
1828
|
+
#include "swish-e.h"
|
1829
|
+
|
1830
|
+
|
1831
|
+
|
1561
1832
|
#include <limits.h>
|
1562
|
-
#
|
1563
|
-
#
|
1564
|
-
#
|
1565
|
-
#
|
1566
|
-
#
|
1567
|
-
#endif
|
1568
|
-
#ifndef ULLONG_MAX
|
1569
|
-
# define ULLONG_MAX ULONG_LONG_MAX
|
1833
|
+
#if !defined(SWIG_NO_LLONG_MAX)
|
1834
|
+
# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
|
1835
|
+
# define LLONG_MAX __LONG_LONG_MAX__
|
1836
|
+
# define LLONG_MIN (-LLONG_MAX - 1LL)
|
1837
|
+
# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
|
1838
|
+
# endif
|
1570
1839
|
#endif
|
1571
1840
|
|
1572
1841
|
|
@@ -1597,11 +1866,11 @@ SWIGINTERN int
|
|
1597
1866
|
SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
|
1598
1867
|
{
|
1599
1868
|
if (TYPE(obj) == T_STRING) {
|
1600
|
-
|
1601
|
-
|
1602
|
-
|
1869
|
+
#if defined(StringValuePtr)
|
1870
|
+
char *cstr = StringValuePtr(obj);
|
1871
|
+
#else
|
1603
1872
|
char *cstr = STR2CSTR(obj);
|
1604
|
-
|
1873
|
+
#endif
|
1605
1874
|
size_t size = RSTRING_LEN(obj) + 1;
|
1606
1875
|
if (cptr) {
|
1607
1876
|
if (alloc) {
|
@@ -1665,7 +1934,7 @@ SWIG_ruby_failed(void)
|
|
1665
1934
|
}
|
1666
1935
|
|
1667
1936
|
|
1668
|
-
/*@SWIG
|
1937
|
+
/*@SWIG:/usr/local/Cellar/swig/2.0.7/share/swig/2.0.7/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
|
1669
1938
|
SWIGINTERN VALUE SWIG_AUX_NUM2ULONG(VALUE *args)
|
1670
1939
|
{
|
1671
1940
|
VALUE obj = args[0];
|
@@ -1701,7 +1970,7 @@ SWIG_From_unsigned_SS_long (unsigned long value)
|
|
1701
1970
|
}
|
1702
1971
|
|
1703
1972
|
|
1704
|
-
/*@SWIG
|
1973
|
+
/*@SWIG:/usr/local/Cellar/swig/2.0.7/share/swig/2.0.7/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
|
1705
1974
|
SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE *args)
|
1706
1975
|
{
|
1707
1976
|
VALUE obj = args[0];
|
@@ -1789,13 +2058,13 @@ SWIG_AsVal_char (VALUE obj, char *val)
|
|
1789
2058
|
}
|
1790
2059
|
|
1791
2060
|
|
1792
|
-
/*@SWIG
|
2061
|
+
/*@SWIG:/usr/local/Cellar/swig/2.0.7/share/swig/2.0.7/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
|
1793
2062
|
SWIGINTERN VALUE SWIG_AUX_NUM2DBL(VALUE *args)
|
1794
2063
|
{
|
1795
2064
|
VALUE obj = args[0];
|
1796
2065
|
VALUE type = TYPE(obj);
|
1797
2066
|
double *res = (double *)(args[1]);
|
1798
|
-
*res =
|
2067
|
+
*res = NUM2DBL(obj);
|
1799
2068
|
return obj;
|
1800
2069
|
}
|
1801
2070
|
/*@SWIG@*/
|
@@ -1820,7 +2089,7 @@ SWIG_AsVal_double (VALUE obj, double *val)
|
|
1820
2089
|
|
1821
2090
|
#define SWIG_From_double rb_float_new
|
1822
2091
|
|
1823
|
-
swig_class
|
2092
|
+
static swig_class SwigClassSWISH_HEADER_VALUE;
|
1824
2093
|
|
1825
2094
|
SWIGINTERN VALUE
|
1826
2095
|
_wrap_SWISH_HEADER_VALUE_string_set(int argc, VALUE *argv, VALUE self) {
|
@@ -1837,12 +2106,12 @@ _wrap_SWISH_HEADER_VALUE_string_set(int argc, VALUE *argv, VALUE self) {
|
|
1837
2106
|
}
|
1838
2107
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SWISH_HEADER_VALUE, 0 | 0 );
|
1839
2108
|
if (!SWIG_IsOK(res1)) {
|
1840
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
2109
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SWISH_HEADER_VALUE *","string", 1, self ));
|
1841
2110
|
}
|
1842
2111
|
arg1 = (SWISH_HEADER_VALUE *)(argp1);
|
1843
2112
|
res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
|
1844
2113
|
if (!SWIG_IsOK(res2)) {
|
1845
|
-
SWIG_exception_fail(SWIG_ArgError(res2),
|
2114
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","string", 2, argv[0] ));
|
1846
2115
|
}
|
1847
2116
|
arg2 = (char *)(buf2);
|
1848
2117
|
if (arg2) {
|
@@ -1862,9 +2131,9 @@ fail:
|
|
1862
2131
|
SWIGINTERN VALUE
|
1863
2132
|
_wrap_SWISH_HEADER_VALUE_string_get(int argc, VALUE *argv, VALUE self) {
|
1864
2133
|
SWISH_HEADER_VALUE *arg1 = (SWISH_HEADER_VALUE *) 0 ;
|
1865
|
-
char *result = 0 ;
|
1866
2134
|
void *argp1 = 0 ;
|
1867
2135
|
int res1 = 0 ;
|
2136
|
+
char *result = 0 ;
|
1868
2137
|
VALUE vresult = Qnil;
|
1869
2138
|
|
1870
2139
|
if ((argc < 0) || (argc > 0)) {
|
@@ -1872,7 +2141,7 @@ _wrap_SWISH_HEADER_VALUE_string_get(int argc, VALUE *argv, VALUE self) {
|
|
1872
2141
|
}
|
1873
2142
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SWISH_HEADER_VALUE, 0 | 0 );
|
1874
2143
|
if (!SWIG_IsOK(res1)) {
|
1875
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
2144
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SWISH_HEADER_VALUE *","string", 1, self ));
|
1876
2145
|
}
|
1877
2146
|
arg1 = (SWISH_HEADER_VALUE *)(argp1);
|
1878
2147
|
result = (char *) ((arg1)->string);
|
@@ -1897,16 +2166,15 @@ _wrap_SWISH_HEADER_VALUE_string_list_set(int argc, VALUE *argv, VALUE self) {
|
|
1897
2166
|
}
|
1898
2167
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SWISH_HEADER_VALUE, 0 | 0 );
|
1899
2168
|
if (!SWIG_IsOK(res1)) {
|
1900
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
2169
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SWISH_HEADER_VALUE *","string_list", 1, self ));
|
1901
2170
|
}
|
1902
2171
|
arg1 = (SWISH_HEADER_VALUE *)(argp1);
|
1903
2172
|
res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_p_char, 0 | 0 );
|
1904
2173
|
if (!SWIG_IsOK(res2)) {
|
1905
|
-
SWIG_exception_fail(SWIG_ArgError(res2),
|
2174
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const **","string_list", 2, argv[0] ));
|
1906
2175
|
}
|
1907
2176
|
arg2 = (char **)(argp2);
|
1908
2177
|
if (arg1) (arg1)->string_list = (char const **)arg2;
|
1909
|
-
|
1910
2178
|
return Qnil;
|
1911
2179
|
fail:
|
1912
2180
|
return Qnil;
|
@@ -1916,9 +2184,9 @@ fail:
|
|
1916
2184
|
SWIGINTERN VALUE
|
1917
2185
|
_wrap_SWISH_HEADER_VALUE_string_list_get(int argc, VALUE *argv, VALUE self) {
|
1918
2186
|
SWISH_HEADER_VALUE *arg1 = (SWISH_HEADER_VALUE *) 0 ;
|
1919
|
-
char **result = 0 ;
|
1920
2187
|
void *argp1 = 0 ;
|
1921
2188
|
int res1 = 0 ;
|
2189
|
+
char **result = 0 ;
|
1922
2190
|
VALUE vresult = Qnil;
|
1923
2191
|
|
1924
2192
|
if ((argc < 0) || (argc > 0)) {
|
@@ -1926,7 +2194,7 @@ _wrap_SWISH_HEADER_VALUE_string_list_get(int argc, VALUE *argv, VALUE self) {
|
|
1926
2194
|
}
|
1927
2195
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SWISH_HEADER_VALUE, 0 | 0 );
|
1928
2196
|
if (!SWIG_IsOK(res1)) {
|
1929
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
2197
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SWISH_HEADER_VALUE *","string_list", 1, self ));
|
1930
2198
|
}
|
1931
2199
|
arg1 = (SWISH_HEADER_VALUE *)(argp1);
|
1932
2200
|
result = (char **) ((arg1)->string_list);
|
@@ -1951,16 +2219,15 @@ _wrap_SWISH_HEADER_VALUE_number_set(int argc, VALUE *argv, VALUE self) {
|
|
1951
2219
|
}
|
1952
2220
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SWISH_HEADER_VALUE, 0 | 0 );
|
1953
2221
|
if (!SWIG_IsOK(res1)) {
|
1954
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
2222
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SWISH_HEADER_VALUE *","number", 1, self ));
|
1955
2223
|
}
|
1956
2224
|
arg1 = (SWISH_HEADER_VALUE *)(argp1);
|
1957
2225
|
ecode2 = SWIG_AsVal_unsigned_SS_long(argv[0], &val2);
|
1958
2226
|
if (!SWIG_IsOK(ecode2)) {
|
1959
|
-
SWIG_exception_fail(SWIG_ArgError(ecode2),
|
2227
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned long","number", 2, argv[0] ));
|
1960
2228
|
}
|
1961
2229
|
arg2 = (unsigned long)(val2);
|
1962
2230
|
if (arg1) (arg1)->number = arg2;
|
1963
|
-
|
1964
2231
|
return Qnil;
|
1965
2232
|
fail:
|
1966
2233
|
return Qnil;
|
@@ -1970,9 +2237,9 @@ fail:
|
|
1970
2237
|
SWIGINTERN VALUE
|
1971
2238
|
_wrap_SWISH_HEADER_VALUE_number_get(int argc, VALUE *argv, VALUE self) {
|
1972
2239
|
SWISH_HEADER_VALUE *arg1 = (SWISH_HEADER_VALUE *) 0 ;
|
1973
|
-
unsigned long result;
|
1974
2240
|
void *argp1 = 0 ;
|
1975
2241
|
int res1 = 0 ;
|
2242
|
+
unsigned long result;
|
1976
2243
|
VALUE vresult = Qnil;
|
1977
2244
|
|
1978
2245
|
if ((argc < 0) || (argc > 0)) {
|
@@ -1980,7 +2247,7 @@ _wrap_SWISH_HEADER_VALUE_number_get(int argc, VALUE *argv, VALUE self) {
|
|
1980
2247
|
}
|
1981
2248
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SWISH_HEADER_VALUE, 0 | 0 );
|
1982
2249
|
if (!SWIG_IsOK(res1)) {
|
1983
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
2250
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SWISH_HEADER_VALUE *","number", 1, self ));
|
1984
2251
|
}
|
1985
2252
|
arg1 = (SWISH_HEADER_VALUE *)(argp1);
|
1986
2253
|
result = (unsigned long) ((arg1)->number);
|
@@ -2005,16 +2272,15 @@ _wrap_SWISH_HEADER_VALUE_boolean_set(int argc, VALUE *argv, VALUE self) {
|
|
2005
2272
|
}
|
2006
2273
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SWISH_HEADER_VALUE, 0 | 0 );
|
2007
2274
|
if (!SWIG_IsOK(res1)) {
|
2008
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
2275
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SWISH_HEADER_VALUE *","boolean", 1, self ));
|
2009
2276
|
}
|
2010
2277
|
arg1 = (SWISH_HEADER_VALUE *)(argp1);
|
2011
2278
|
ecode2 = SWIG_AsVal_int(argv[0], &val2);
|
2012
2279
|
if (!SWIG_IsOK(ecode2)) {
|
2013
|
-
SWIG_exception_fail(SWIG_ArgError(ecode2),
|
2280
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","boolean", 2, argv[0] ));
|
2014
2281
|
}
|
2015
2282
|
arg2 = (int)(val2);
|
2016
2283
|
if (arg1) (arg1)->boolean = arg2;
|
2017
|
-
|
2018
2284
|
return Qnil;
|
2019
2285
|
fail:
|
2020
2286
|
return Qnil;
|
@@ -2024,9 +2290,9 @@ fail:
|
|
2024
2290
|
SWIGINTERN VALUE
|
2025
2291
|
_wrap_SWISH_HEADER_VALUE_boolean_get(int argc, VALUE *argv, VALUE self) {
|
2026
2292
|
SWISH_HEADER_VALUE *arg1 = (SWISH_HEADER_VALUE *) 0 ;
|
2027
|
-
int result;
|
2028
2293
|
void *argp1 = 0 ;
|
2029
2294
|
int res1 = 0 ;
|
2295
|
+
int result;
|
2030
2296
|
VALUE vresult = Qnil;
|
2031
2297
|
|
2032
2298
|
if ((argc < 0) || (argc > 0)) {
|
@@ -2034,7 +2300,7 @@ _wrap_SWISH_HEADER_VALUE_boolean_get(int argc, VALUE *argv, VALUE self) {
|
|
2034
2300
|
}
|
2035
2301
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SWISH_HEADER_VALUE, 0 | 0 );
|
2036
2302
|
if (!SWIG_IsOK(res1)) {
|
2037
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
2303
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SWISH_HEADER_VALUE *","boolean", 1, self ));
|
2038
2304
|
}
|
2039
2305
|
arg1 = (SWISH_HEADER_VALUE *)(argp1);
|
2040
2306
|
result = (int) ((arg1)->boolean);
|
@@ -2069,8 +2335,8 @@ _wrap_new_SWISH_HEADER_VALUE(int argc, VALUE *argv, VALUE self) {
|
|
2069
2335
|
if ((argc < 0) || (argc > 0)) {
|
2070
2336
|
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
2071
2337
|
}
|
2072
|
-
result = (SWISH_HEADER_VALUE *)
|
2073
|
-
|
2338
|
+
result = (SWISH_HEADER_VALUE *)calloc(1, sizeof(SWISH_HEADER_VALUE));
|
2339
|
+
DATA_PTR(self) = result;
|
2074
2340
|
return self;
|
2075
2341
|
fail:
|
2076
2342
|
return Qnil;
|
@@ -2085,8 +2351,8 @@ free_SWISH_HEADER_VALUE(SWISH_HEADER_VALUE *arg1) {
|
|
2085
2351
|
SWIGINTERN VALUE
|
2086
2352
|
_wrap_SwishHeaderNames(int argc, VALUE *argv, VALUE self) {
|
2087
2353
|
SW_HANDLE arg1 = (SW_HANDLE) 0 ;
|
2088
|
-
char **result = 0 ;
|
2089
2354
|
int res1 ;
|
2355
|
+
char **result = 0 ;
|
2090
2356
|
VALUE vresult = Qnil;
|
2091
2357
|
|
2092
2358
|
if ((argc < 1) || (argc > 1)) {
|
@@ -2094,7 +2360,7 @@ _wrap_SwishHeaderNames(int argc, VALUE *argv, VALUE self) {
|
|
2094
2360
|
}
|
2095
2361
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
2096
2362
|
if (!SWIG_IsOK(res1)) {
|
2097
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
2363
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_HANDLE","SwishHeaderNames", 1, argv[0] ));
|
2098
2364
|
}
|
2099
2365
|
result = (char **)SwishHeaderNames(arg1);
|
2100
2366
|
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 | 0 );
|
@@ -2107,8 +2373,8 @@ fail:
|
|
2107
2373
|
SWIGINTERN VALUE
|
2108
2374
|
_wrap_SwishIndexNames(int argc, VALUE *argv, VALUE self) {
|
2109
2375
|
SW_HANDLE arg1 = (SW_HANDLE) 0 ;
|
2110
|
-
char **result = 0 ;
|
2111
2376
|
int res1 ;
|
2377
|
+
char **result = 0 ;
|
2112
2378
|
VALUE vresult = Qnil;
|
2113
2379
|
|
2114
2380
|
if ((argc < 1) || (argc > 1)) {
|
@@ -2116,7 +2382,7 @@ _wrap_SwishIndexNames(int argc, VALUE *argv, VALUE self) {
|
|
2116
2382
|
}
|
2117
2383
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
2118
2384
|
if (!SWIG_IsOK(res1)) {
|
2119
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
2385
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_HANDLE","SwishIndexNames", 1, argv[0] ));
|
2120
2386
|
}
|
2121
2387
|
result = (char **)SwishIndexNames(arg1);
|
2122
2388
|
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 | 0 );
|
@@ -2132,7 +2398,6 @@ _wrap_SwishHeaderValue(int argc, VALUE *argv, VALUE self) {
|
|
2132
2398
|
char *arg2 = (char *) 0 ;
|
2133
2399
|
char *arg3 = (char *) 0 ;
|
2134
2400
|
SWISH_HEADER_TYPE *arg4 = (SWISH_HEADER_TYPE *) 0 ;
|
2135
|
-
SWISH_HEADER_VALUE result;
|
2136
2401
|
int res1 ;
|
2137
2402
|
int res2 ;
|
2138
2403
|
char *buf2 = 0 ;
|
@@ -2142,6 +2407,7 @@ _wrap_SwishHeaderValue(int argc, VALUE *argv, VALUE self) {
|
|
2142
2407
|
int alloc3 = 0 ;
|
2143
2408
|
void *argp4 = 0 ;
|
2144
2409
|
int res4 = 0 ;
|
2410
|
+
SWISH_HEADER_VALUE result;
|
2145
2411
|
VALUE vresult = Qnil;
|
2146
2412
|
|
2147
2413
|
if ((argc < 4) || (argc > 4)) {
|
@@ -2149,21 +2415,21 @@ _wrap_SwishHeaderValue(int argc, VALUE *argv, VALUE self) {
|
|
2149
2415
|
}
|
2150
2416
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
2151
2417
|
if (!SWIG_IsOK(res1)) {
|
2152
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
2418
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_HANDLE","SwishHeaderValue", 1, argv[0] ));
|
2153
2419
|
}
|
2154
2420
|
res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
|
2155
2421
|
if (!SWIG_IsOK(res2)) {
|
2156
|
-
SWIG_exception_fail(SWIG_ArgError(res2),
|
2422
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","SwishHeaderValue", 2, argv[1] ));
|
2157
2423
|
}
|
2158
2424
|
arg2 = (char *)(buf2);
|
2159
2425
|
res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
|
2160
2426
|
if (!SWIG_IsOK(res3)) {
|
2161
|
-
SWIG_exception_fail(SWIG_ArgError(res3),
|
2427
|
+
SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","SwishHeaderValue", 3, argv[2] ));
|
2162
2428
|
}
|
2163
2429
|
arg3 = (char *)(buf3);
|
2164
2430
|
res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_SWISH_HEADER_TYPE, 0 | 0 );
|
2165
2431
|
if (!SWIG_IsOK(res4)) {
|
2166
|
-
SWIG_exception_fail(SWIG_ArgError(res4),
|
2432
|
+
SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "SWISH_HEADER_TYPE *","SwishHeaderValue", 4, argv[3] ));
|
2167
2433
|
}
|
2168
2434
|
arg4 = (SWISH_HEADER_TYPE *)(argp4);
|
2169
2435
|
result = SwishHeaderValue(arg1,(char const *)arg2,(char const *)arg3,arg4);
|
@@ -2183,13 +2449,13 @@ _wrap_SwishResultIndexValue(int argc, VALUE *argv, VALUE self) {
|
|
2183
2449
|
SW_RESULT arg1 = (SW_RESULT) 0 ;
|
2184
2450
|
char *arg2 = (char *) 0 ;
|
2185
2451
|
SWISH_HEADER_TYPE *arg3 = (SWISH_HEADER_TYPE *) 0 ;
|
2186
|
-
SWISH_HEADER_VALUE result;
|
2187
2452
|
int res1 ;
|
2188
2453
|
int res2 ;
|
2189
2454
|
char *buf2 = 0 ;
|
2190
2455
|
int alloc2 = 0 ;
|
2191
2456
|
void *argp3 = 0 ;
|
2192
2457
|
int res3 = 0 ;
|
2458
|
+
SWISH_HEADER_VALUE result;
|
2193
2459
|
VALUE vresult = Qnil;
|
2194
2460
|
|
2195
2461
|
if ((argc < 3) || (argc > 3)) {
|
@@ -2197,16 +2463,16 @@ _wrap_SwishResultIndexValue(int argc, VALUE *argv, VALUE self) {
|
|
2197
2463
|
}
|
2198
2464
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
2199
2465
|
if (!SWIG_IsOK(res1)) {
|
2200
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
2466
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_RESULT","SwishResultIndexValue", 1, argv[0] ));
|
2201
2467
|
}
|
2202
2468
|
res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
|
2203
2469
|
if (!SWIG_IsOK(res2)) {
|
2204
|
-
SWIG_exception_fail(SWIG_ArgError(res2),
|
2470
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","SwishResultIndexValue", 2, argv[1] ));
|
2205
2471
|
}
|
2206
2472
|
arg2 = (char *)(buf2);
|
2207
2473
|
res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_SWISH_HEADER_TYPE, 0 | 0 );
|
2208
2474
|
if (!SWIG_IsOK(res3)) {
|
2209
|
-
SWIG_exception_fail(SWIG_ArgError(res3),
|
2475
|
+
SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "SWISH_HEADER_TYPE *","SwishResultIndexValue", 3, argv[2] ));
|
2210
2476
|
}
|
2211
2477
|
arg3 = (SWISH_HEADER_TYPE *)(argp3);
|
2212
2478
|
result = SwishResultIndexValue(arg1,(char const *)arg2,arg3);
|
@@ -2223,11 +2489,11 @@ SWIGINTERN VALUE
|
|
2223
2489
|
_wrap_SwishMetaList(int argc, VALUE *argv, VALUE self) {
|
2224
2490
|
SW_HANDLE arg1 = (SW_HANDLE) 0 ;
|
2225
2491
|
char *arg2 = (char *) 0 ;
|
2226
|
-
SWISH_META_LIST result;
|
2227
2492
|
int res1 ;
|
2228
2493
|
int res2 ;
|
2229
2494
|
char *buf2 = 0 ;
|
2230
2495
|
int alloc2 = 0 ;
|
2496
|
+
SWISH_META_LIST result;
|
2231
2497
|
VALUE vresult = Qnil;
|
2232
2498
|
|
2233
2499
|
if ((argc < 2) || (argc > 2)) {
|
@@ -2235,11 +2501,11 @@ _wrap_SwishMetaList(int argc, VALUE *argv, VALUE self) {
|
|
2235
2501
|
}
|
2236
2502
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
2237
2503
|
if (!SWIG_IsOK(res1)) {
|
2238
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
2504
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_HANDLE","SwishMetaList", 1, argv[0] ));
|
2239
2505
|
}
|
2240
2506
|
res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
|
2241
2507
|
if (!SWIG_IsOK(res2)) {
|
2242
|
-
SWIG_exception_fail(SWIG_ArgError(res2),
|
2508
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","SwishMetaList", 2, argv[1] ));
|
2243
2509
|
}
|
2244
2510
|
arg2 = (char *)(buf2);
|
2245
2511
|
result = (SWISH_META_LIST)SwishMetaList(arg1,(char const *)arg2);
|
@@ -2256,11 +2522,11 @@ SWIGINTERN VALUE
|
|
2256
2522
|
_wrap_SwishPropertyList(int argc, VALUE *argv, VALUE self) {
|
2257
2523
|
SW_HANDLE arg1 = (SW_HANDLE) 0 ;
|
2258
2524
|
char *arg2 = (char *) 0 ;
|
2259
|
-
SWISH_META_LIST result;
|
2260
2525
|
int res1 ;
|
2261
2526
|
int res2 ;
|
2262
2527
|
char *buf2 = 0 ;
|
2263
2528
|
int alloc2 = 0 ;
|
2529
|
+
SWISH_META_LIST result;
|
2264
2530
|
VALUE vresult = Qnil;
|
2265
2531
|
|
2266
2532
|
if ((argc < 2) || (argc > 2)) {
|
@@ -2268,11 +2534,11 @@ _wrap_SwishPropertyList(int argc, VALUE *argv, VALUE self) {
|
|
2268
2534
|
}
|
2269
2535
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
2270
2536
|
if (!SWIG_IsOK(res1)) {
|
2271
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
2537
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_HANDLE","SwishPropertyList", 1, argv[0] ));
|
2272
2538
|
}
|
2273
2539
|
res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
|
2274
2540
|
if (!SWIG_IsOK(res2)) {
|
2275
|
-
SWIG_exception_fail(SWIG_ArgError(res2),
|
2541
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","SwishPropertyList", 2, argv[1] ));
|
2276
2542
|
}
|
2277
2543
|
arg2 = (char *)(buf2);
|
2278
2544
|
result = (SWISH_META_LIST)SwishPropertyList(arg1,(char const *)arg2);
|
@@ -2288,8 +2554,8 @@ fail:
|
|
2288
2554
|
SWIGINTERN VALUE
|
2289
2555
|
_wrap_SwishResultMetaList(int argc, VALUE *argv, VALUE self) {
|
2290
2556
|
SW_RESULT arg1 = (SW_RESULT) 0 ;
|
2291
|
-
SWISH_META_LIST result;
|
2292
2557
|
int res1 ;
|
2558
|
+
SWISH_META_LIST result;
|
2293
2559
|
VALUE vresult = Qnil;
|
2294
2560
|
|
2295
2561
|
if ((argc < 1) || (argc > 1)) {
|
@@ -2297,7 +2563,7 @@ _wrap_SwishResultMetaList(int argc, VALUE *argv, VALUE self) {
|
|
2297
2563
|
}
|
2298
2564
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
2299
2565
|
if (!SWIG_IsOK(res1)) {
|
2300
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
2566
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_RESULT","SwishResultMetaList", 1, argv[0] ));
|
2301
2567
|
}
|
2302
2568
|
result = (SWISH_META_LIST)SwishResultMetaList(arg1);
|
2303
2569
|
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_void, 0 | 0 );
|
@@ -2310,8 +2576,8 @@ fail:
|
|
2310
2576
|
SWIGINTERN VALUE
|
2311
2577
|
_wrap_SwishResultPropertyList(int argc, VALUE *argv, VALUE self) {
|
2312
2578
|
SW_RESULT arg1 = (SW_RESULT) 0 ;
|
2313
|
-
SWISH_META_LIST result;
|
2314
2579
|
int res1 ;
|
2580
|
+
SWISH_META_LIST result;
|
2315
2581
|
VALUE vresult = Qnil;
|
2316
2582
|
|
2317
2583
|
if ((argc < 1) || (argc > 1)) {
|
@@ -2319,7 +2585,7 @@ _wrap_SwishResultPropertyList(int argc, VALUE *argv, VALUE self) {
|
|
2319
2585
|
}
|
2320
2586
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
2321
2587
|
if (!SWIG_IsOK(res1)) {
|
2322
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
2588
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_RESULT","SwishResultPropertyList", 1, argv[0] ));
|
2323
2589
|
}
|
2324
2590
|
result = (SWISH_META_LIST)SwishResultPropertyList(arg1);
|
2325
2591
|
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_void, 0 | 0 );
|
@@ -2332,8 +2598,8 @@ fail:
|
|
2332
2598
|
SWIGINTERN VALUE
|
2333
2599
|
_wrap_SwishMetaName(int argc, VALUE *argv, VALUE self) {
|
2334
2600
|
SW_META arg1 = (SW_META) 0 ;
|
2335
|
-
char *result = 0 ;
|
2336
2601
|
int res1 ;
|
2602
|
+
char *result = 0 ;
|
2337
2603
|
VALUE vresult = Qnil;
|
2338
2604
|
|
2339
2605
|
if ((argc < 1) || (argc > 1)) {
|
@@ -2341,7 +2607,7 @@ _wrap_SwishMetaName(int argc, VALUE *argv, VALUE self) {
|
|
2341
2607
|
}
|
2342
2608
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
2343
2609
|
if (!SWIG_IsOK(res1)) {
|
2344
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
2610
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_META","SwishMetaName", 1, argv[0] ));
|
2345
2611
|
}
|
2346
2612
|
result = (char *)SwishMetaName((void const *)arg1);
|
2347
2613
|
vresult = SWIG_FromCharPtr((const char *)result);
|
@@ -2354,8 +2620,8 @@ fail:
|
|
2354
2620
|
SWIGINTERN VALUE
|
2355
2621
|
_wrap_SwishMetaType(int argc, VALUE *argv, VALUE self) {
|
2356
2622
|
SW_META arg1 = (SW_META) 0 ;
|
2357
|
-
int result;
|
2358
2623
|
int res1 ;
|
2624
|
+
int result;
|
2359
2625
|
VALUE vresult = Qnil;
|
2360
2626
|
|
2361
2627
|
if ((argc < 1) || (argc > 1)) {
|
@@ -2363,7 +2629,7 @@ _wrap_SwishMetaType(int argc, VALUE *argv, VALUE self) {
|
|
2363
2629
|
}
|
2364
2630
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
2365
2631
|
if (!SWIG_IsOK(res1)) {
|
2366
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
2632
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_META","SwishMetaType", 1, argv[0] ));
|
2367
2633
|
}
|
2368
2634
|
result = (int)SwishMetaType((void const *)arg1);
|
2369
2635
|
vresult = SWIG_From_int((int)(result));
|
@@ -2376,8 +2642,8 @@ fail:
|
|
2376
2642
|
SWIGINTERN VALUE
|
2377
2643
|
_wrap_SwishMetaID(int argc, VALUE *argv, VALUE self) {
|
2378
2644
|
SW_META arg1 = (SW_META) 0 ;
|
2379
|
-
int result;
|
2380
2645
|
int res1 ;
|
2646
|
+
int result;
|
2381
2647
|
VALUE vresult = Qnil;
|
2382
2648
|
|
2383
2649
|
if ((argc < 1) || (argc > 1)) {
|
@@ -2385,7 +2651,7 @@ _wrap_SwishMetaID(int argc, VALUE *argv, VALUE self) {
|
|
2385
2651
|
}
|
2386
2652
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
2387
2653
|
if (!SWIG_IsOK(res1)) {
|
2388
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
2654
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_META","SwishMetaID", 1, argv[0] ));
|
2389
2655
|
}
|
2390
2656
|
result = (int)SwishMetaID((void const *)arg1);
|
2391
2657
|
vresult = SWIG_From_int((int)(result));
|
@@ -2398,10 +2664,10 @@ fail:
|
|
2398
2664
|
SWIGINTERN VALUE
|
2399
2665
|
_wrap_SwishInit(int argc, VALUE *argv, VALUE self) {
|
2400
2666
|
char *arg1 = (char *) 0 ;
|
2401
|
-
SW_HANDLE result;
|
2402
2667
|
int res1 ;
|
2403
2668
|
char *buf1 = 0 ;
|
2404
2669
|
int alloc1 = 0 ;
|
2670
|
+
SW_HANDLE result;
|
2405
2671
|
VALUE vresult = Qnil;
|
2406
2672
|
|
2407
2673
|
if ((argc < 1) || (argc > 1)) {
|
@@ -2409,7 +2675,7 @@ _wrap_SwishInit(int argc, VALUE *argv, VALUE self) {
|
|
2409
2675
|
}
|
2410
2676
|
res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
|
2411
2677
|
if (!SWIG_IsOK(res1)) {
|
2412
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
2678
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char *","SwishInit", 1, argv[0] ));
|
2413
2679
|
}
|
2414
2680
|
arg1 = (char *)(buf1);
|
2415
2681
|
result = (SW_HANDLE)SwishInit(arg1);
|
@@ -2426,11 +2692,11 @@ SWIGINTERN VALUE
|
|
2426
2692
|
_wrap_SwishQuery(int argc, VALUE *argv, VALUE self) {
|
2427
2693
|
SW_HANDLE arg1 = (SW_HANDLE) 0 ;
|
2428
2694
|
char *arg2 = (char *) 0 ;
|
2429
|
-
SW_RESULTS result;
|
2430
2695
|
int res1 ;
|
2431
2696
|
int res2 ;
|
2432
2697
|
char *buf2 = 0 ;
|
2433
2698
|
int alloc2 = 0 ;
|
2699
|
+
SW_RESULTS result;
|
2434
2700
|
VALUE vresult = Qnil;
|
2435
2701
|
|
2436
2702
|
if ((argc < 2) || (argc > 2)) {
|
@@ -2438,11 +2704,11 @@ _wrap_SwishQuery(int argc, VALUE *argv, VALUE self) {
|
|
2438
2704
|
}
|
2439
2705
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
2440
2706
|
if (!SWIG_IsOK(res1)) {
|
2441
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
2707
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_HANDLE","SwishQuery", 1, argv[0] ));
|
2442
2708
|
}
|
2443
2709
|
res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
|
2444
2710
|
if (!SWIG_IsOK(res2)) {
|
2445
|
-
SWIG_exception_fail(SWIG_ArgError(res2),
|
2711
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","SwishQuery", 2, argv[1] ));
|
2446
2712
|
}
|
2447
2713
|
arg2 = (char *)(buf2);
|
2448
2714
|
result = (SW_RESULTS)SwishQuery(arg1,arg2);
|
@@ -2459,11 +2725,11 @@ SWIGINTERN VALUE
|
|
2459
2725
|
_wrap_New_Search_Object(int argc, VALUE *argv, VALUE self) {
|
2460
2726
|
SW_HANDLE arg1 = (SW_HANDLE) 0 ;
|
2461
2727
|
char *arg2 = (char *) 0 ;
|
2462
|
-
SW_SEARCH result;
|
2463
2728
|
int res1 ;
|
2464
2729
|
int res2 ;
|
2465
2730
|
char *buf2 = 0 ;
|
2466
2731
|
int alloc2 = 0 ;
|
2732
|
+
SW_SEARCH result;
|
2467
2733
|
VALUE vresult = Qnil;
|
2468
2734
|
|
2469
2735
|
if ((argc < 2) || (argc > 2)) {
|
@@ -2471,11 +2737,11 @@ _wrap_New_Search_Object(int argc, VALUE *argv, VALUE self) {
|
|
2471
2737
|
}
|
2472
2738
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
2473
2739
|
if (!SWIG_IsOK(res1)) {
|
2474
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
2740
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_HANDLE","New_Search_Object", 1, argv[0] ));
|
2475
2741
|
}
|
2476
2742
|
res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
|
2477
2743
|
if (!SWIG_IsOK(res2)) {
|
2478
|
-
SWIG_exception_fail(SWIG_ArgError(res2),
|
2744
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","New_Search_Object", 2, argv[1] ));
|
2479
2745
|
}
|
2480
2746
|
arg2 = (char *)(buf2);
|
2481
2747
|
result = (SW_SEARCH)New_Search_Object(arg1,arg2);
|
@@ -2501,11 +2767,11 @@ _wrap_SwishRankScheme(int argc, VALUE *argv, VALUE self) {
|
|
2501
2767
|
}
|
2502
2768
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
2503
2769
|
if (!SWIG_IsOK(res1)) {
|
2504
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
2770
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_HANDLE","SwishRankScheme", 1, argv[0] ));
|
2505
2771
|
}
|
2506
2772
|
ecode2 = SWIG_AsVal_int(argv[1], &val2);
|
2507
2773
|
if (!SWIG_IsOK(ecode2)) {
|
2508
|
-
SWIG_exception_fail(SWIG_ArgError(ecode2),
|
2774
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","SwishRankScheme", 2, argv[1] ));
|
2509
2775
|
}
|
2510
2776
|
arg2 = (int)(val2);
|
2511
2777
|
SwishRankScheme(arg1,arg2);
|
@@ -2527,11 +2793,11 @@ _wrap_SwishSetRefPtr(int argc, VALUE *argv, VALUE self) {
|
|
2527
2793
|
}
|
2528
2794
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
2529
2795
|
if (!SWIG_IsOK(res1)) {
|
2530
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
2796
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_HANDLE","SwishSetRefPtr", 1, argv[0] ));
|
2531
2797
|
}
|
2532
2798
|
res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
|
2533
2799
|
if (!SWIG_IsOK(res2)) {
|
2534
|
-
SWIG_exception_fail(SWIG_ArgError(res2),
|
2800
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","SwishSetRefPtr", 2, argv[1] ));
|
2535
2801
|
}
|
2536
2802
|
SwishSetRefPtr(arg1,arg2);
|
2537
2803
|
return Qnil;
|
@@ -2543,8 +2809,8 @@ fail:
|
|
2543
2809
|
SWIGINTERN VALUE
|
2544
2810
|
_wrap_SwishGetRefPtr(int argc, VALUE *argv, VALUE self) {
|
2545
2811
|
SW_HANDLE arg1 = (SW_HANDLE) 0 ;
|
2546
|
-
void *result = 0 ;
|
2547
2812
|
int res1 ;
|
2813
|
+
void *result = 0 ;
|
2548
2814
|
VALUE vresult = Qnil;
|
2549
2815
|
|
2550
2816
|
if ((argc < 1) || (argc > 1)) {
|
@@ -2552,7 +2818,7 @@ _wrap_SwishGetRefPtr(int argc, VALUE *argv, VALUE self) {
|
|
2552
2818
|
}
|
2553
2819
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
2554
2820
|
if (!SWIG_IsOK(res1)) {
|
2555
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
2821
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_HANDLE","SwishGetRefPtr", 1, argv[0] ));
|
2556
2822
|
}
|
2557
2823
|
result = (void *)SwishGetRefPtr(arg1);
|
2558
2824
|
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
|
@@ -2565,8 +2831,8 @@ fail:
|
|
2565
2831
|
SWIGINTERN VALUE
|
2566
2832
|
_wrap_SwishSearch_parent(int argc, VALUE *argv, VALUE self) {
|
2567
2833
|
SW_SEARCH arg1 = (SW_SEARCH) 0 ;
|
2568
|
-
void *result = 0 ;
|
2569
2834
|
int res1 ;
|
2835
|
+
void *result = 0 ;
|
2570
2836
|
VALUE vresult = Qnil;
|
2571
2837
|
|
2572
2838
|
if ((argc < 1) || (argc > 1)) {
|
@@ -2574,7 +2840,7 @@ _wrap_SwishSearch_parent(int argc, VALUE *argv, VALUE self) {
|
|
2574
2840
|
}
|
2575
2841
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
2576
2842
|
if (!SWIG_IsOK(res1)) {
|
2577
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
2843
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_SEARCH","SwishSearch_parent", 1, argv[0] ));
|
2578
2844
|
}
|
2579
2845
|
result = (void *)SwishSearch_parent(arg1);
|
2580
2846
|
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
|
@@ -2587,8 +2853,8 @@ fail:
|
|
2587
2853
|
SWIGINTERN VALUE
|
2588
2854
|
_wrap_SwishResults_parent(int argc, VALUE *argv, VALUE self) {
|
2589
2855
|
SW_RESULTS arg1 = (SW_RESULTS) 0 ;
|
2590
|
-
void *result = 0 ;
|
2591
2856
|
int res1 ;
|
2857
|
+
void *result = 0 ;
|
2592
2858
|
VALUE vresult = Qnil;
|
2593
2859
|
|
2594
2860
|
if ((argc < 1) || (argc > 1)) {
|
@@ -2596,7 +2862,7 @@ _wrap_SwishResults_parent(int argc, VALUE *argv, VALUE self) {
|
|
2596
2862
|
}
|
2597
2863
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
2598
2864
|
if (!SWIG_IsOK(res1)) {
|
2599
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
2865
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_RESULTS","SwishResults_parent", 1, argv[0] ));
|
2600
2866
|
}
|
2601
2867
|
result = (void *)SwishResults_parent(arg1);
|
2602
2868
|
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
|
@@ -2609,8 +2875,8 @@ fail:
|
|
2609
2875
|
SWIGINTERN VALUE
|
2610
2876
|
_wrap_SwishResult_parent(int argc, VALUE *argv, VALUE self) {
|
2611
2877
|
SW_RESULT arg1 = (SW_RESULT) 0 ;
|
2612
|
-
void *result = 0 ;
|
2613
2878
|
int res1 ;
|
2879
|
+
void *result = 0 ;
|
2614
2880
|
VALUE vresult = Qnil;
|
2615
2881
|
|
2616
2882
|
if ((argc < 1) || (argc > 1)) {
|
@@ -2618,7 +2884,7 @@ _wrap_SwishResult_parent(int argc, VALUE *argv, VALUE self) {
|
|
2618
2884
|
}
|
2619
2885
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
2620
2886
|
if (!SWIG_IsOK(res1)) {
|
2621
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
2887
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_RESULT","SwishResult_parent", 1, argv[0] ));
|
2622
2888
|
}
|
2623
2889
|
result = (void *)SwishResult_parent(arg1);
|
2624
2890
|
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
|
@@ -2640,11 +2906,11 @@ _wrap_ResultsSetRefPtr(int argc, VALUE *argv, VALUE self) {
|
|
2640
2906
|
}
|
2641
2907
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
2642
2908
|
if (!SWIG_IsOK(res1)) {
|
2643
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
2909
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_RESULTS","ResultsSetRefPtr", 1, argv[0] ));
|
2644
2910
|
}
|
2645
2911
|
res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
|
2646
2912
|
if (!SWIG_IsOK(res2)) {
|
2647
|
-
SWIG_exception_fail(SWIG_ArgError(res2),
|
2913
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","ResultsSetRefPtr", 2, argv[1] ));
|
2648
2914
|
}
|
2649
2915
|
ResultsSetRefPtr(arg1,arg2);
|
2650
2916
|
return Qnil;
|
@@ -2666,11 +2932,11 @@ _wrap_SwishSetStructure(int argc, VALUE *argv, VALUE self) {
|
|
2666
2932
|
}
|
2667
2933
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
2668
2934
|
if (!SWIG_IsOK(res1)) {
|
2669
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
2935
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_SEARCH","SwishSetStructure", 1, argv[0] ));
|
2670
2936
|
}
|
2671
2937
|
ecode2 = SWIG_AsVal_int(argv[1], &val2);
|
2672
2938
|
if (!SWIG_IsOK(ecode2)) {
|
2673
|
-
SWIG_exception_fail(SWIG_ArgError(ecode2),
|
2939
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","SwishSetStructure", 2, argv[1] ));
|
2674
2940
|
}
|
2675
2941
|
arg2 = (int)(val2);
|
2676
2942
|
SwishSetStructure(arg1,arg2);
|
@@ -2693,11 +2959,11 @@ _wrap_SwishPhraseDelimiter(int argc, VALUE *argv, VALUE self) {
|
|
2693
2959
|
}
|
2694
2960
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
2695
2961
|
if (!SWIG_IsOK(res1)) {
|
2696
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
2962
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_SEARCH","SwishPhraseDelimiter", 1, argv[0] ));
|
2697
2963
|
}
|
2698
2964
|
ecode2 = SWIG_AsVal_char(argv[1], &val2);
|
2699
2965
|
if (!SWIG_IsOK(ecode2)) {
|
2700
|
-
SWIG_exception_fail(SWIG_ArgError(ecode2),
|
2966
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "char","SwishPhraseDelimiter", 2, argv[1] ));
|
2701
2967
|
}
|
2702
2968
|
arg2 = (char)(val2);
|
2703
2969
|
SwishPhraseDelimiter(arg1,arg2);
|
@@ -2721,11 +2987,11 @@ _wrap_SwishSetSort(int argc, VALUE *argv, VALUE self) {
|
|
2721
2987
|
}
|
2722
2988
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
2723
2989
|
if (!SWIG_IsOK(res1)) {
|
2724
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
2990
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_SEARCH","SwishSetSort", 1, argv[0] ));
|
2725
2991
|
}
|
2726
2992
|
res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
|
2727
2993
|
if (!SWIG_IsOK(res2)) {
|
2728
|
-
SWIG_exception_fail(SWIG_ArgError(res2),
|
2994
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","SwishSetSort", 2, argv[1] ));
|
2729
2995
|
}
|
2730
2996
|
arg2 = (char *)(buf2);
|
2731
2997
|
SwishSetSort(arg1,arg2);
|
@@ -2751,11 +3017,11 @@ _wrap_SwishSetQuery(int argc, VALUE *argv, VALUE self) {
|
|
2751
3017
|
}
|
2752
3018
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
2753
3019
|
if (!SWIG_IsOK(res1)) {
|
2754
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3020
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_SEARCH","SwishSetQuery", 1, argv[0] ));
|
2755
3021
|
}
|
2756
3022
|
res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
|
2757
3023
|
if (!SWIG_IsOK(res2)) {
|
2758
|
-
SWIG_exception_fail(SWIG_ArgError(res2),
|
3024
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","SwishSetQuery", 2, argv[1] ));
|
2759
3025
|
}
|
2760
3026
|
arg2 = (char *)(buf2);
|
2761
3027
|
SwishSetQuery(arg1,arg2);
|
@@ -2773,7 +3039,6 @@ _wrap_SwishSetSearchLimit(int argc, VALUE *argv, VALUE self) {
|
|
2773
3039
|
char *arg2 = (char *) 0 ;
|
2774
3040
|
char *arg3 = (char *) 0 ;
|
2775
3041
|
char *arg4 = (char *) 0 ;
|
2776
|
-
int result;
|
2777
3042
|
int res1 ;
|
2778
3043
|
int res2 ;
|
2779
3044
|
char *buf2 = 0 ;
|
@@ -2784,6 +3049,7 @@ _wrap_SwishSetSearchLimit(int argc, VALUE *argv, VALUE self) {
|
|
2784
3049
|
int res4 ;
|
2785
3050
|
char *buf4 = 0 ;
|
2786
3051
|
int alloc4 = 0 ;
|
3052
|
+
int result;
|
2787
3053
|
VALUE vresult = Qnil;
|
2788
3054
|
|
2789
3055
|
if ((argc < 4) || (argc > 4)) {
|
@@ -2791,21 +3057,21 @@ _wrap_SwishSetSearchLimit(int argc, VALUE *argv, VALUE self) {
|
|
2791
3057
|
}
|
2792
3058
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
2793
3059
|
if (!SWIG_IsOK(res1)) {
|
2794
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3060
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_SEARCH","SwishSetSearchLimit", 1, argv[0] ));
|
2795
3061
|
}
|
2796
3062
|
res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
|
2797
3063
|
if (!SWIG_IsOK(res2)) {
|
2798
|
-
SWIG_exception_fail(SWIG_ArgError(res2),
|
3064
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","SwishSetSearchLimit", 2, argv[1] ));
|
2799
3065
|
}
|
2800
3066
|
arg2 = (char *)(buf2);
|
2801
3067
|
res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
|
2802
3068
|
if (!SWIG_IsOK(res3)) {
|
2803
|
-
SWIG_exception_fail(SWIG_ArgError(res3),
|
3069
|
+
SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char *","SwishSetSearchLimit", 3, argv[2] ));
|
2804
3070
|
}
|
2805
3071
|
arg3 = (char *)(buf3);
|
2806
3072
|
res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
|
2807
3073
|
if (!SWIG_IsOK(res4)) {
|
2808
|
-
SWIG_exception_fail(SWIG_ArgError(res4),
|
3074
|
+
SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char *","SwishSetSearchLimit", 4, argv[3] ));
|
2809
3075
|
}
|
2810
3076
|
arg4 = (char *)(buf4);
|
2811
3077
|
result = (int)SwishSetSearchLimit(arg1,arg2,arg3,arg4);
|
@@ -2832,7 +3098,7 @@ _wrap_SwishResetSearchLimit(int argc, VALUE *argv, VALUE self) {
|
|
2832
3098
|
}
|
2833
3099
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
2834
3100
|
if (!SWIG_IsOK(res1)) {
|
2835
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3101
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_SEARCH","SwishResetSearchLimit", 1, argv[0] ));
|
2836
3102
|
}
|
2837
3103
|
SwishResetSearchLimit(arg1);
|
2838
3104
|
return Qnil;
|
@@ -2845,11 +3111,11 @@ SWIGINTERN VALUE
|
|
2845
3111
|
_wrap_SwishExecute(int argc, VALUE *argv, VALUE self) {
|
2846
3112
|
SW_SEARCH arg1 = (SW_SEARCH) 0 ;
|
2847
3113
|
char *arg2 = (char *) 0 ;
|
2848
|
-
SW_RESULTS result;
|
2849
3114
|
int res1 ;
|
2850
3115
|
int res2 ;
|
2851
3116
|
char *buf2 = 0 ;
|
2852
3117
|
int alloc2 = 0 ;
|
3118
|
+
SW_RESULTS result;
|
2853
3119
|
VALUE vresult = Qnil;
|
2854
3120
|
|
2855
3121
|
if ((argc < 2) || (argc > 2)) {
|
@@ -2857,11 +3123,11 @@ _wrap_SwishExecute(int argc, VALUE *argv, VALUE self) {
|
|
2857
3123
|
}
|
2858
3124
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
2859
3125
|
if (!SWIG_IsOK(res1)) {
|
2860
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3126
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_SEARCH","SwishExecute", 1, argv[0] ));
|
2861
3127
|
}
|
2862
3128
|
res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
|
2863
3129
|
if (!SWIG_IsOK(res2)) {
|
2864
|
-
SWIG_exception_fail(SWIG_ArgError(res2),
|
3130
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","SwishExecute", 2, argv[1] ));
|
2865
3131
|
}
|
2866
3132
|
arg2 = (char *)(buf2);
|
2867
3133
|
result = (SW_RESULTS)SwishExecute(arg1,arg2);
|
@@ -2877,8 +3143,8 @@ fail:
|
|
2877
3143
|
SWIGINTERN VALUE
|
2878
3144
|
_wrap_SwishHits(int argc, VALUE *argv, VALUE self) {
|
2879
3145
|
SW_RESULTS arg1 = (SW_RESULTS) 0 ;
|
2880
|
-
int result;
|
2881
3146
|
int res1 ;
|
3147
|
+
int result;
|
2882
3148
|
VALUE vresult = Qnil;
|
2883
3149
|
|
2884
3150
|
if ((argc < 1) || (argc > 1)) {
|
@@ -2886,7 +3152,7 @@ _wrap_SwishHits(int argc, VALUE *argv, VALUE self) {
|
|
2886
3152
|
}
|
2887
3153
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
2888
3154
|
if (!SWIG_IsOK(res1)) {
|
2889
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3155
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_RESULTS","SwishHits", 1, argv[0] ));
|
2890
3156
|
}
|
2891
3157
|
result = (int)SwishHits(arg1);
|
2892
3158
|
vresult = SWIG_From_int((int)(result));
|
@@ -2900,11 +3166,11 @@ SWIGINTERN VALUE
|
|
2900
3166
|
_wrap_SwishParsedWords(int argc, VALUE *argv, VALUE self) {
|
2901
3167
|
SW_RESULTS arg1 = (SW_RESULTS) 0 ;
|
2902
3168
|
char *arg2 = (char *) 0 ;
|
2903
|
-
SWISH_HEADER_VALUE result;
|
2904
3169
|
int res1 ;
|
2905
3170
|
int res2 ;
|
2906
3171
|
char *buf2 = 0 ;
|
2907
3172
|
int alloc2 = 0 ;
|
3173
|
+
SWISH_HEADER_VALUE result;
|
2908
3174
|
VALUE vresult = Qnil;
|
2909
3175
|
|
2910
3176
|
if ((argc < 2) || (argc > 2)) {
|
@@ -2912,11 +3178,11 @@ _wrap_SwishParsedWords(int argc, VALUE *argv, VALUE self) {
|
|
2912
3178
|
}
|
2913
3179
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
2914
3180
|
if (!SWIG_IsOK(res1)) {
|
2915
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3181
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_RESULTS","SwishParsedWords", 1, argv[0] ));
|
2916
3182
|
}
|
2917
3183
|
res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
|
2918
3184
|
if (!SWIG_IsOK(res2)) {
|
2919
|
-
SWIG_exception_fail(SWIG_ArgError(res2),
|
3185
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","SwishParsedWords", 2, argv[1] ));
|
2920
3186
|
}
|
2921
3187
|
arg2 = (char *)(buf2);
|
2922
3188
|
result = SwishParsedWords(arg1,(char const *)arg2);
|
@@ -2933,11 +3199,11 @@ SWIGINTERN VALUE
|
|
2933
3199
|
_wrap_SwishRemovedStopwords(int argc, VALUE *argv, VALUE self) {
|
2934
3200
|
SW_RESULTS arg1 = (SW_RESULTS) 0 ;
|
2935
3201
|
char *arg2 = (char *) 0 ;
|
2936
|
-
SWISH_HEADER_VALUE result;
|
2937
3202
|
int res1 ;
|
2938
3203
|
int res2 ;
|
2939
3204
|
char *buf2 = 0 ;
|
2940
3205
|
int alloc2 = 0 ;
|
3206
|
+
SWISH_HEADER_VALUE result;
|
2941
3207
|
VALUE vresult = Qnil;
|
2942
3208
|
|
2943
3209
|
if ((argc < 2) || (argc > 2)) {
|
@@ -2945,11 +3211,11 @@ _wrap_SwishRemovedStopwords(int argc, VALUE *argv, VALUE self) {
|
|
2945
3211
|
}
|
2946
3212
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
2947
3213
|
if (!SWIG_IsOK(res1)) {
|
2948
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3214
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_RESULTS","SwishRemovedStopwords", 1, argv[0] ));
|
2949
3215
|
}
|
2950
3216
|
res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
|
2951
3217
|
if (!SWIG_IsOK(res2)) {
|
2952
|
-
SWIG_exception_fail(SWIG_ArgError(res2),
|
3218
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","SwishRemovedStopwords", 2, argv[1] ));
|
2953
3219
|
}
|
2954
3220
|
arg2 = (char *)(buf2);
|
2955
3221
|
result = SwishRemovedStopwords(arg1,(char const *)arg2);
|
@@ -2966,10 +3232,10 @@ SWIGINTERN VALUE
|
|
2966
3232
|
_wrap_SwishSeekResult(int argc, VALUE *argv, VALUE self) {
|
2967
3233
|
SW_RESULTS arg1 = (SW_RESULTS) 0 ;
|
2968
3234
|
int arg2 ;
|
2969
|
-
int result;
|
2970
3235
|
int res1 ;
|
2971
3236
|
int val2 ;
|
2972
3237
|
int ecode2 = 0 ;
|
3238
|
+
int result;
|
2973
3239
|
VALUE vresult = Qnil;
|
2974
3240
|
|
2975
3241
|
if ((argc < 2) || (argc > 2)) {
|
@@ -2977,11 +3243,11 @@ _wrap_SwishSeekResult(int argc, VALUE *argv, VALUE self) {
|
|
2977
3243
|
}
|
2978
3244
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
2979
3245
|
if (!SWIG_IsOK(res1)) {
|
2980
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3246
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_RESULTS","SwishSeekResult", 1, argv[0] ));
|
2981
3247
|
}
|
2982
3248
|
ecode2 = SWIG_AsVal_int(argv[1], &val2);
|
2983
3249
|
if (!SWIG_IsOK(ecode2)) {
|
2984
|
-
SWIG_exception_fail(SWIG_ArgError(ecode2),
|
3250
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","SwishSeekResult", 2, argv[1] ));
|
2985
3251
|
}
|
2986
3252
|
arg2 = (int)(val2);
|
2987
3253
|
result = (int)SwishSeekResult(arg1,arg2);
|
@@ -2995,8 +3261,8 @@ fail:
|
|
2995
3261
|
SWIGINTERN VALUE
|
2996
3262
|
_wrap_SwishNextResult(int argc, VALUE *argv, VALUE self) {
|
2997
3263
|
SW_RESULTS arg1 = (SW_RESULTS) 0 ;
|
2998
|
-
SW_RESULT result;
|
2999
3264
|
int res1 ;
|
3265
|
+
SW_RESULT result;
|
3000
3266
|
VALUE vresult = Qnil;
|
3001
3267
|
|
3002
3268
|
if ((argc < 1) || (argc > 1)) {
|
@@ -3004,7 +3270,7 @@ _wrap_SwishNextResult(int argc, VALUE *argv, VALUE self) {
|
|
3004
3270
|
}
|
3005
3271
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
3006
3272
|
if (!SWIG_IsOK(res1)) {
|
3007
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3273
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_RESULTS","SwishNextResult", 1, argv[0] ));
|
3008
3274
|
}
|
3009
3275
|
result = (SW_RESULT)SwishNextResult(arg1);
|
3010
3276
|
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
|
@@ -3018,11 +3284,11 @@ SWIGINTERN VALUE
|
|
3018
3284
|
_wrap_SwishResultPropertyStr(int argc, VALUE *argv, VALUE self) {
|
3019
3285
|
SW_RESULT arg1 = (SW_RESULT) 0 ;
|
3020
3286
|
char *arg2 = (char *) 0 ;
|
3021
|
-
char *result = 0 ;
|
3022
3287
|
int res1 ;
|
3023
3288
|
int res2 ;
|
3024
3289
|
char *buf2 = 0 ;
|
3025
3290
|
int alloc2 = 0 ;
|
3291
|
+
char *result = 0 ;
|
3026
3292
|
VALUE vresult = Qnil;
|
3027
3293
|
|
3028
3294
|
if ((argc < 2) || (argc > 2)) {
|
@@ -3030,11 +3296,11 @@ _wrap_SwishResultPropertyStr(int argc, VALUE *argv, VALUE self) {
|
|
3030
3296
|
}
|
3031
3297
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
3032
3298
|
if (!SWIG_IsOK(res1)) {
|
3033
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3299
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_RESULT","SwishResultPropertyStr", 1, argv[0] ));
|
3034
3300
|
}
|
3035
3301
|
res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
|
3036
3302
|
if (!SWIG_IsOK(res2)) {
|
3037
|
-
SWIG_exception_fail(SWIG_ArgError(res2),
|
3303
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","SwishResultPropertyStr", 2, argv[1] ));
|
3038
3304
|
}
|
3039
3305
|
arg2 = (char *)(buf2);
|
3040
3306
|
result = (char *)SwishResultPropertyStr(arg1,arg2);
|
@@ -3051,11 +3317,11 @@ SWIGINTERN VALUE
|
|
3051
3317
|
_wrap_SwishResultPropertyULong(int argc, VALUE *argv, VALUE self) {
|
3052
3318
|
SW_RESULT arg1 = (SW_RESULT) 0 ;
|
3053
3319
|
char *arg2 = (char *) 0 ;
|
3054
|
-
unsigned long result;
|
3055
3320
|
int res1 ;
|
3056
3321
|
int res2 ;
|
3057
3322
|
char *buf2 = 0 ;
|
3058
3323
|
int alloc2 = 0 ;
|
3324
|
+
unsigned long result;
|
3059
3325
|
VALUE vresult = Qnil;
|
3060
3326
|
|
3061
3327
|
if ((argc < 2) || (argc > 2)) {
|
@@ -3063,11 +3329,11 @@ _wrap_SwishResultPropertyULong(int argc, VALUE *argv, VALUE self) {
|
|
3063
3329
|
}
|
3064
3330
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
3065
3331
|
if (!SWIG_IsOK(res1)) {
|
3066
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3332
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_RESULT","SwishResultPropertyULong", 1, argv[0] ));
|
3067
3333
|
}
|
3068
3334
|
res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
|
3069
3335
|
if (!SWIG_IsOK(res2)) {
|
3070
|
-
SWIG_exception_fail(SWIG_ArgError(res2),
|
3336
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","SwishResultPropertyULong", 2, argv[1] ));
|
3071
3337
|
}
|
3072
3338
|
arg2 = (char *)(buf2);
|
3073
3339
|
result = (unsigned long)SwishResultPropertyULong(arg1,arg2);
|
@@ -3083,8 +3349,8 @@ fail:
|
|
3083
3349
|
SWIGINTERN VALUE
|
3084
3350
|
_wrap_SW_ResultToSW_HANDLE(int argc, VALUE *argv, VALUE self) {
|
3085
3351
|
SW_RESULT arg1 = (SW_RESULT) 0 ;
|
3086
|
-
SW_HANDLE result;
|
3087
3352
|
int res1 ;
|
3353
|
+
SW_HANDLE result;
|
3088
3354
|
VALUE vresult = Qnil;
|
3089
3355
|
|
3090
3356
|
if ((argc < 1) || (argc > 1)) {
|
@@ -3092,7 +3358,7 @@ _wrap_SW_ResultToSW_HANDLE(int argc, VALUE *argv, VALUE self) {
|
|
3092
3358
|
}
|
3093
3359
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
3094
3360
|
if (!SWIG_IsOK(res1)) {
|
3095
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3361
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_RESULT","SW_ResultToSW_HANDLE", 1, argv[0] ));
|
3096
3362
|
}
|
3097
3363
|
result = (SW_HANDLE)SW_ResultToSW_HANDLE(arg1);
|
3098
3364
|
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
|
@@ -3105,8 +3371,8 @@ fail:
|
|
3105
3371
|
SWIGINTERN VALUE
|
3106
3372
|
_wrap_SW_ResultsToSW_HANDLE(int argc, VALUE *argv, VALUE self) {
|
3107
3373
|
SW_RESULTS arg1 = (SW_RESULTS) 0 ;
|
3108
|
-
SW_HANDLE result;
|
3109
3374
|
int res1 ;
|
3375
|
+
SW_HANDLE result;
|
3110
3376
|
VALUE vresult = Qnil;
|
3111
3377
|
|
3112
3378
|
if ((argc < 1) || (argc > 1)) {
|
@@ -3114,7 +3380,7 @@ _wrap_SW_ResultsToSW_HANDLE(int argc, VALUE *argv, VALUE self) {
|
|
3114
3380
|
}
|
3115
3381
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
3116
3382
|
if (!SWIG_IsOK(res1)) {
|
3117
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3383
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_RESULTS","SW_ResultsToSW_HANDLE", 1, argv[0] ));
|
3118
3384
|
}
|
3119
3385
|
result = (SW_HANDLE)SW_ResultsToSW_HANDLE(arg1);
|
3120
3386
|
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
|
@@ -3134,7 +3400,7 @@ _wrap_Free_Search_Object(int argc, VALUE *argv, VALUE self) {
|
|
3134
3400
|
}
|
3135
3401
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
3136
3402
|
if (!SWIG_IsOK(res1)) {
|
3137
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3403
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_SEARCH","Free_Search_Object", 1, argv[0] ));
|
3138
3404
|
}
|
3139
3405
|
Free_Search_Object(arg1);
|
3140
3406
|
return Qnil;
|
@@ -3153,7 +3419,7 @@ _wrap_Free_Results_Object(int argc, VALUE *argv, VALUE self) {
|
|
3153
3419
|
}
|
3154
3420
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
3155
3421
|
if (!SWIG_IsOK(res1)) {
|
3156
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3422
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_RESULTS","Free_Results_Object", 1, argv[0] ));
|
3157
3423
|
}
|
3158
3424
|
Free_Results_Object(arg1);
|
3159
3425
|
return Qnil;
|
@@ -3172,7 +3438,7 @@ _wrap_SwishClose(int argc, VALUE *argv, VALUE self) {
|
|
3172
3438
|
}
|
3173
3439
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
3174
3440
|
if (!SWIG_IsOK(res1)) {
|
3175
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3441
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_HANDLE","SwishClose", 1, argv[0] ));
|
3176
3442
|
}
|
3177
3443
|
SwishClose(arg1);
|
3178
3444
|
return Qnil;
|
@@ -3184,8 +3450,8 @@ fail:
|
|
3184
3450
|
SWIGINTERN VALUE
|
3185
3451
|
_wrap_SwishError(int argc, VALUE *argv, VALUE self) {
|
3186
3452
|
SW_HANDLE arg1 = (SW_HANDLE) 0 ;
|
3187
|
-
int result;
|
3188
3453
|
int res1 ;
|
3454
|
+
int result;
|
3189
3455
|
VALUE vresult = Qnil;
|
3190
3456
|
|
3191
3457
|
if ((argc < 1) || (argc > 1)) {
|
@@ -3193,7 +3459,7 @@ _wrap_SwishError(int argc, VALUE *argv, VALUE self) {
|
|
3193
3459
|
}
|
3194
3460
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
3195
3461
|
if (!SWIG_IsOK(res1)) {
|
3196
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3462
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_HANDLE","SwishError", 1, argv[0] ));
|
3197
3463
|
}
|
3198
3464
|
result = (int)SwishError(arg1);
|
3199
3465
|
vresult = SWIG_From_int((int)(result));
|
@@ -3206,8 +3472,8 @@ fail:
|
|
3206
3472
|
SWIGINTERN VALUE
|
3207
3473
|
_wrap_SwishCriticalError(int argc, VALUE *argv, VALUE self) {
|
3208
3474
|
SW_HANDLE arg1 = (SW_HANDLE) 0 ;
|
3209
|
-
int result;
|
3210
3475
|
int res1 ;
|
3476
|
+
int result;
|
3211
3477
|
VALUE vresult = Qnil;
|
3212
3478
|
|
3213
3479
|
if ((argc < 1) || (argc > 1)) {
|
@@ -3215,7 +3481,7 @@ _wrap_SwishCriticalError(int argc, VALUE *argv, VALUE self) {
|
|
3215
3481
|
}
|
3216
3482
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
3217
3483
|
if (!SWIG_IsOK(res1)) {
|
3218
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3484
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_HANDLE","SwishCriticalError", 1, argv[0] ));
|
3219
3485
|
}
|
3220
3486
|
result = (int)SwishCriticalError(arg1);
|
3221
3487
|
vresult = SWIG_From_int((int)(result));
|
@@ -3235,7 +3501,7 @@ _wrap_SwishAbortLastError(int argc, VALUE *argv, VALUE self) {
|
|
3235
3501
|
}
|
3236
3502
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
3237
3503
|
if (!SWIG_IsOK(res1)) {
|
3238
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3504
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_HANDLE","SwishAbortLastError", 1, argv[0] ));
|
3239
3505
|
}
|
3240
3506
|
SwishAbortLastError(arg1);
|
3241
3507
|
return Qnil;
|
@@ -3247,8 +3513,8 @@ fail:
|
|
3247
3513
|
SWIGINTERN VALUE
|
3248
3514
|
_wrap_SwishErrorString(int argc, VALUE *argv, VALUE self) {
|
3249
3515
|
SW_HANDLE arg1 = (SW_HANDLE) 0 ;
|
3250
|
-
char *result = 0 ;
|
3251
3516
|
int res1 ;
|
3517
|
+
char *result = 0 ;
|
3252
3518
|
VALUE vresult = Qnil;
|
3253
3519
|
|
3254
3520
|
if ((argc < 1) || (argc > 1)) {
|
@@ -3256,7 +3522,7 @@ _wrap_SwishErrorString(int argc, VALUE *argv, VALUE self) {
|
|
3256
3522
|
}
|
3257
3523
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
3258
3524
|
if (!SWIG_IsOK(res1)) {
|
3259
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3525
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_HANDLE","SwishErrorString", 1, argv[0] ));
|
3260
3526
|
}
|
3261
3527
|
result = (char *)SwishErrorString(arg1);
|
3262
3528
|
vresult = SWIG_FromCharPtr((const char *)result);
|
@@ -3269,8 +3535,8 @@ fail:
|
|
3269
3535
|
SWIGINTERN VALUE
|
3270
3536
|
_wrap_SwishLastErrorMsg(int argc, VALUE *argv, VALUE self) {
|
3271
3537
|
SW_HANDLE arg1 = (SW_HANDLE) 0 ;
|
3272
|
-
char *result = 0 ;
|
3273
3538
|
int res1 ;
|
3539
|
+
char *result = 0 ;
|
3274
3540
|
VALUE vresult = Qnil;
|
3275
3541
|
|
3276
3542
|
if ((argc < 1) || (argc > 1)) {
|
@@ -3278,7 +3544,7 @@ _wrap_SwishLastErrorMsg(int argc, VALUE *argv, VALUE self) {
|
|
3278
3544
|
}
|
3279
3545
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
3280
3546
|
if (!SWIG_IsOK(res1)) {
|
3281
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3547
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_HANDLE","SwishLastErrorMsg", 1, argv[0] ));
|
3282
3548
|
}
|
3283
3549
|
result = (char *)SwishLastErrorMsg(arg1);
|
3284
3550
|
vresult = SWIG_FromCharPtr((const char *)result);
|
@@ -3299,7 +3565,7 @@ _wrap_set_error_handle(int argc, VALUE *argv, VALUE self) {
|
|
3299
3565
|
}
|
3300
3566
|
res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FILE, 0 | 0 );
|
3301
3567
|
if (!SWIG_IsOK(res1)) {
|
3302
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3568
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FILE *","set_error_handle", 1, argv[0] ));
|
3303
3569
|
}
|
3304
3570
|
arg1 = (FILE *)(argp1);
|
3305
3571
|
set_error_handle(arg1);
|
@@ -3326,13 +3592,13 @@ _wrap_SwishWordsByLetter(int argc, VALUE *argv, VALUE self) {
|
|
3326
3592
|
SW_HANDLE arg1 = (SW_HANDLE) 0 ;
|
3327
3593
|
char *arg2 = (char *) 0 ;
|
3328
3594
|
char arg3 ;
|
3329
|
-
char *result = 0 ;
|
3330
3595
|
int res1 ;
|
3331
3596
|
int res2 ;
|
3332
3597
|
char *buf2 = 0 ;
|
3333
3598
|
int alloc2 = 0 ;
|
3334
3599
|
char val3 ;
|
3335
3600
|
int ecode3 = 0 ;
|
3601
|
+
char *result = 0 ;
|
3336
3602
|
VALUE vresult = Qnil;
|
3337
3603
|
|
3338
3604
|
if ((argc < 3) || (argc > 3)) {
|
@@ -3340,16 +3606,16 @@ _wrap_SwishWordsByLetter(int argc, VALUE *argv, VALUE self) {
|
|
3340
3606
|
}
|
3341
3607
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
3342
3608
|
if (!SWIG_IsOK(res1)) {
|
3343
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3609
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_HANDLE","SwishWordsByLetter", 1, argv[0] ));
|
3344
3610
|
}
|
3345
3611
|
res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
|
3346
3612
|
if (!SWIG_IsOK(res2)) {
|
3347
|
-
SWIG_exception_fail(SWIG_ArgError(res2),
|
3613
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","SwishWordsByLetter", 2, argv[1] ));
|
3348
3614
|
}
|
3349
3615
|
arg2 = (char *)(buf2);
|
3350
3616
|
ecode3 = SWIG_AsVal_char(argv[2], &val3);
|
3351
3617
|
if (!SWIG_IsOK(ecode3)) {
|
3352
|
-
SWIG_exception_fail(SWIG_ArgError(ecode3),
|
3618
|
+
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "char","SwishWordsByLetter", 3, argv[2] ));
|
3353
3619
|
}
|
3354
3620
|
arg3 = (char)(val3);
|
3355
3621
|
result = (char *)SwishWordsByLetter(arg1,arg2,arg3);
|
@@ -3366,11 +3632,11 @@ SWIGINTERN VALUE
|
|
3366
3632
|
_wrap_SwishStemWord(int argc, VALUE *argv, VALUE self) {
|
3367
3633
|
SW_HANDLE arg1 = (SW_HANDLE) 0 ;
|
3368
3634
|
char *arg2 = (char *) 0 ;
|
3369
|
-
char *result = 0 ;
|
3370
3635
|
int res1 ;
|
3371
3636
|
int res2 ;
|
3372
3637
|
char *buf2 = 0 ;
|
3373
3638
|
int alloc2 = 0 ;
|
3639
|
+
char *result = 0 ;
|
3374
3640
|
VALUE vresult = Qnil;
|
3375
3641
|
|
3376
3642
|
if ((argc < 2) || (argc > 2)) {
|
@@ -3378,11 +3644,11 @@ _wrap_SwishStemWord(int argc, VALUE *argv, VALUE self) {
|
|
3378
3644
|
}
|
3379
3645
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
3380
3646
|
if (!SWIG_IsOK(res1)) {
|
3381
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3647
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_HANDLE","SwishStemWord", 1, argv[0] ));
|
3382
3648
|
}
|
3383
3649
|
res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
|
3384
3650
|
if (!SWIG_IsOK(res2)) {
|
3385
|
-
SWIG_exception_fail(SWIG_ArgError(res2),
|
3651
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","SwishStemWord", 2, argv[1] ));
|
3386
3652
|
}
|
3387
3653
|
arg2 = (char *)(buf2);
|
3388
3654
|
result = (char *)SwishStemWord(arg1,arg2);
|
@@ -3399,11 +3665,11 @@ SWIGINTERN VALUE
|
|
3399
3665
|
_wrap_SwishFuzzyWord(int argc, VALUE *argv, VALUE self) {
|
3400
3666
|
SW_RESULT arg1 = (SW_RESULT) 0 ;
|
3401
3667
|
char *arg2 = (char *) 0 ;
|
3402
|
-
SW_FUZZYWORD result;
|
3403
3668
|
int res1 ;
|
3404
3669
|
int res2 ;
|
3405
3670
|
char *buf2 = 0 ;
|
3406
3671
|
int alloc2 = 0 ;
|
3672
|
+
SW_FUZZYWORD result;
|
3407
3673
|
VALUE vresult = Qnil;
|
3408
3674
|
|
3409
3675
|
if ((argc < 2) || (argc > 2)) {
|
@@ -3411,11 +3677,11 @@ _wrap_SwishFuzzyWord(int argc, VALUE *argv, VALUE self) {
|
|
3411
3677
|
}
|
3412
3678
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
3413
3679
|
if (!SWIG_IsOK(res1)) {
|
3414
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3680
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_RESULT","SwishFuzzyWord", 1, argv[0] ));
|
3415
3681
|
}
|
3416
3682
|
res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
|
3417
3683
|
if (!SWIG_IsOK(res2)) {
|
3418
|
-
SWIG_exception_fail(SWIG_ArgError(res2),
|
3684
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","SwishFuzzyWord", 2, argv[1] ));
|
3419
3685
|
}
|
3420
3686
|
arg2 = (char *)(buf2);
|
3421
3687
|
result = (SW_FUZZYWORD)SwishFuzzyWord(arg1,arg2);
|
@@ -3429,11 +3695,10 @@ fail:
|
|
3429
3695
|
|
3430
3696
|
|
3431
3697
|
SWIGINTERN VALUE
|
3432
|
-
|
3698
|
+
_wrap_SwishFuzzy(int argc, VALUE *argv, VALUE self) {
|
3433
3699
|
SW_HANDLE arg1 = (SW_HANDLE) 0 ;
|
3434
3700
|
char *arg2 = (char *) 0 ;
|
3435
3701
|
char *arg3 = (char *) 0 ;
|
3436
|
-
SW_FUZZYWORD result;
|
3437
3702
|
int res1 ;
|
3438
3703
|
int res2 ;
|
3439
3704
|
char *buf2 = 0 ;
|
@@ -3441,6 +3706,7 @@ _wrap_SwishFuzzify(int argc, VALUE *argv, VALUE self) {
|
|
3441
3706
|
int res3 ;
|
3442
3707
|
char *buf3 = 0 ;
|
3443
3708
|
int alloc3 = 0 ;
|
3709
|
+
SW_FUZZYWORD result;
|
3444
3710
|
VALUE vresult = Qnil;
|
3445
3711
|
|
3446
3712
|
if ((argc < 3) || (argc > 3)) {
|
@@ -3448,19 +3714,19 @@ _wrap_SwishFuzzify(int argc, VALUE *argv, VALUE self) {
|
|
3448
3714
|
}
|
3449
3715
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
3450
3716
|
if (!SWIG_IsOK(res1)) {
|
3451
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3717
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_HANDLE","SwishFuzzy", 1, argv[0] ));
|
3452
3718
|
}
|
3453
3719
|
res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
|
3454
3720
|
if (!SWIG_IsOK(res2)) {
|
3455
|
-
SWIG_exception_fail(SWIG_ArgError(res2),
|
3721
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","SwishFuzzy", 2, argv[1] ));
|
3456
3722
|
}
|
3457
3723
|
arg2 = (char *)(buf2);
|
3458
3724
|
res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
|
3459
3725
|
if (!SWIG_IsOK(res3)) {
|
3460
|
-
SWIG_exception_fail(SWIG_ArgError(res3),
|
3726
|
+
SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char *","SwishFuzzy", 3, argv[2] ));
|
3461
3727
|
}
|
3462
3728
|
arg3 = (char *)(buf3);
|
3463
|
-
result = (SW_FUZZYWORD)
|
3729
|
+
result = (SW_FUZZYWORD)SwishFuzzy(arg1,(char const *)arg2,arg3);
|
3464
3730
|
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
|
3465
3731
|
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
|
3466
3732
|
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
|
@@ -3475,8 +3741,8 @@ fail:
|
|
3475
3741
|
SWIGINTERN VALUE
|
3476
3742
|
_wrap_SwishFuzzyWordList(int argc, VALUE *argv, VALUE self) {
|
3477
3743
|
SW_FUZZYWORD arg1 = (SW_FUZZYWORD) 0 ;
|
3478
|
-
char **result = 0 ;
|
3479
3744
|
int res1 ;
|
3745
|
+
char **result = 0 ;
|
3480
3746
|
VALUE vresult = Qnil;
|
3481
3747
|
|
3482
3748
|
if ((argc < 1) || (argc > 1)) {
|
@@ -3484,7 +3750,7 @@ _wrap_SwishFuzzyWordList(int argc, VALUE *argv, VALUE self) {
|
|
3484
3750
|
}
|
3485
3751
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
3486
3752
|
if (!SWIG_IsOK(res1)) {
|
3487
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3753
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_FUZZYWORD","SwishFuzzyWordList", 1, argv[0] ));
|
3488
3754
|
}
|
3489
3755
|
result = (char **)SwishFuzzyWordList(arg1);
|
3490
3756
|
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 | 0 );
|
@@ -3497,8 +3763,8 @@ fail:
|
|
3497
3763
|
SWIGINTERN VALUE
|
3498
3764
|
_wrap_SwishFuzzyWordCount(int argc, VALUE *argv, VALUE self) {
|
3499
3765
|
SW_FUZZYWORD arg1 = (SW_FUZZYWORD) 0 ;
|
3500
|
-
int result;
|
3501
3766
|
int res1 ;
|
3767
|
+
int result;
|
3502
3768
|
VALUE vresult = Qnil;
|
3503
3769
|
|
3504
3770
|
if ((argc < 1) || (argc > 1)) {
|
@@ -3506,7 +3772,7 @@ _wrap_SwishFuzzyWordCount(int argc, VALUE *argv, VALUE self) {
|
|
3506
3772
|
}
|
3507
3773
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
3508
3774
|
if (!SWIG_IsOK(res1)) {
|
3509
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3775
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_FUZZYWORD","SwishFuzzyWordCount", 1, argv[0] ));
|
3510
3776
|
}
|
3511
3777
|
result = (int)SwishFuzzyWordCount(arg1);
|
3512
3778
|
vresult = SWIG_From_int((int)(result));
|
@@ -3519,8 +3785,8 @@ fail:
|
|
3519
3785
|
SWIGINTERN VALUE
|
3520
3786
|
_wrap_SwishFuzzyWordError(int argc, VALUE *argv, VALUE self) {
|
3521
3787
|
SW_FUZZYWORD arg1 = (SW_FUZZYWORD) 0 ;
|
3522
|
-
int result;
|
3523
3788
|
int res1 ;
|
3789
|
+
int result;
|
3524
3790
|
VALUE vresult = Qnil;
|
3525
3791
|
|
3526
3792
|
if ((argc < 1) || (argc > 1)) {
|
@@ -3528,7 +3794,7 @@ _wrap_SwishFuzzyWordError(int argc, VALUE *argv, VALUE self) {
|
|
3528
3794
|
}
|
3529
3795
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
3530
3796
|
if (!SWIG_IsOK(res1)) {
|
3531
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3797
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_FUZZYWORD","SwishFuzzyWordError", 1, argv[0] ));
|
3532
3798
|
}
|
3533
3799
|
result = (int)SwishFuzzyWordError(arg1);
|
3534
3800
|
vresult = SWIG_From_int((int)(result));
|
@@ -3548,7 +3814,7 @@ _wrap_SwishFuzzyWordFree(int argc, VALUE *argv, VALUE self) {
|
|
3548
3814
|
}
|
3549
3815
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
3550
3816
|
if (!SWIG_IsOK(res1)) {
|
3551
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3817
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_FUZZYWORD","SwishFuzzyWordFree", 1, argv[0] ));
|
3552
3818
|
}
|
3553
3819
|
SwishFuzzyWordFree(arg1);
|
3554
3820
|
return Qnil;
|
@@ -3560,8 +3826,8 @@ fail:
|
|
3560
3826
|
SWIGINTERN VALUE
|
3561
3827
|
_wrap_SwishFuzzyMode(int argc, VALUE *argv, VALUE self) {
|
3562
3828
|
SW_RESULT arg1 = (SW_RESULT) 0 ;
|
3563
|
-
char *result = 0 ;
|
3564
3829
|
int res1 ;
|
3830
|
+
char *result = 0 ;
|
3565
3831
|
VALUE vresult = Qnil;
|
3566
3832
|
|
3567
3833
|
if ((argc < 1) || (argc > 1)) {
|
@@ -3569,7 +3835,7 @@ _wrap_SwishFuzzyMode(int argc, VALUE *argv, VALUE self) {
|
|
3569
3835
|
}
|
3570
3836
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
3571
3837
|
if (!SWIG_IsOK(res1)) {
|
3572
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3838
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_RESULT","SwishFuzzyMode", 1, argv[0] ));
|
3573
3839
|
}
|
3574
3840
|
result = (char *)SwishFuzzyMode(arg1);
|
3575
3841
|
vresult = SWIG_FromCharPtr((const char *)result);
|
@@ -3579,7 +3845,7 @@ fail:
|
|
3579
3845
|
}
|
3580
3846
|
|
3581
3847
|
|
3582
|
-
swig_class
|
3848
|
+
static swig_class SwigClassU_PropValue1;
|
3583
3849
|
|
3584
3850
|
SWIGINTERN VALUE
|
3585
3851
|
_wrap_u_PropValue1_v_str_set(int argc, VALUE *argv, VALUE self) {
|
@@ -3596,12 +3862,12 @@ _wrap_u_PropValue1_v_str_set(int argc, VALUE *argv, VALUE self) {
|
|
3596
3862
|
}
|
3597
3863
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_u_PropValue1, 0 | 0 );
|
3598
3864
|
if (!SWIG_IsOK(res1)) {
|
3599
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3865
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "u_PropValue1 *","v_str", 1, self ));
|
3600
3866
|
}
|
3601
3867
|
arg1 = (u_PropValue1 *)(argp1);
|
3602
3868
|
res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
|
3603
3869
|
if (!SWIG_IsOK(res2)) {
|
3604
|
-
SWIG_exception_fail(SWIG_ArgError(res2),
|
3870
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","v_str", 2, argv[0] ));
|
3605
3871
|
}
|
3606
3872
|
arg2 = (char *)(buf2);
|
3607
3873
|
if (arg1->v_str) free((char*)arg1->v_str);
|
@@ -3622,9 +3888,9 @@ fail:
|
|
3622
3888
|
SWIGINTERN VALUE
|
3623
3889
|
_wrap_u_PropValue1_v_str_get(int argc, VALUE *argv, VALUE self) {
|
3624
3890
|
u_PropValue1 *arg1 = (u_PropValue1 *) 0 ;
|
3625
|
-
char *result = 0 ;
|
3626
3891
|
void *argp1 = 0 ;
|
3627
3892
|
int res1 = 0 ;
|
3893
|
+
char *result = 0 ;
|
3628
3894
|
VALUE vresult = Qnil;
|
3629
3895
|
|
3630
3896
|
if ((argc < 0) || (argc > 0)) {
|
@@ -3632,7 +3898,7 @@ _wrap_u_PropValue1_v_str_get(int argc, VALUE *argv, VALUE self) {
|
|
3632
3898
|
}
|
3633
3899
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_u_PropValue1, 0 | 0 );
|
3634
3900
|
if (!SWIG_IsOK(res1)) {
|
3635
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3901
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "u_PropValue1 *","v_str", 1, self ));
|
3636
3902
|
}
|
3637
3903
|
arg1 = (u_PropValue1 *)(argp1);
|
3638
3904
|
result = (char *) ((arg1)->v_str);
|
@@ -3657,16 +3923,15 @@ _wrap_u_PropValue1_v_int_set(int argc, VALUE *argv, VALUE self) {
|
|
3657
3923
|
}
|
3658
3924
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_u_PropValue1, 0 | 0 );
|
3659
3925
|
if (!SWIG_IsOK(res1)) {
|
3660
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3926
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "u_PropValue1 *","v_int", 1, self ));
|
3661
3927
|
}
|
3662
3928
|
arg1 = (u_PropValue1 *)(argp1);
|
3663
3929
|
ecode2 = SWIG_AsVal_int(argv[0], &val2);
|
3664
3930
|
if (!SWIG_IsOK(ecode2)) {
|
3665
|
-
SWIG_exception_fail(SWIG_ArgError(ecode2),
|
3931
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","v_int", 2, argv[0] ));
|
3666
3932
|
}
|
3667
3933
|
arg2 = (int)(val2);
|
3668
3934
|
if (arg1) (arg1)->v_int = arg2;
|
3669
|
-
|
3670
3935
|
return Qnil;
|
3671
3936
|
fail:
|
3672
3937
|
return Qnil;
|
@@ -3676,9 +3941,9 @@ fail:
|
|
3676
3941
|
SWIGINTERN VALUE
|
3677
3942
|
_wrap_u_PropValue1_v_int_get(int argc, VALUE *argv, VALUE self) {
|
3678
3943
|
u_PropValue1 *arg1 = (u_PropValue1 *) 0 ;
|
3679
|
-
int result;
|
3680
3944
|
void *argp1 = 0 ;
|
3681
3945
|
int res1 = 0 ;
|
3946
|
+
int result;
|
3682
3947
|
VALUE vresult = Qnil;
|
3683
3948
|
|
3684
3949
|
if ((argc < 0) || (argc > 0)) {
|
@@ -3686,7 +3951,7 @@ _wrap_u_PropValue1_v_int_get(int argc, VALUE *argv, VALUE self) {
|
|
3686
3951
|
}
|
3687
3952
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_u_PropValue1, 0 | 0 );
|
3688
3953
|
if (!SWIG_IsOK(res1)) {
|
3689
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3954
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "u_PropValue1 *","v_int", 1, self ));
|
3690
3955
|
}
|
3691
3956
|
arg1 = (u_PropValue1 *)(argp1);
|
3692
3957
|
result = (int) ((arg1)->v_int);
|
@@ -3711,22 +3976,21 @@ _wrap_u_PropValue1_v_date_set(int argc, VALUE *argv, VALUE self) {
|
|
3711
3976
|
}
|
3712
3977
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_u_PropValue1, 0 | 0 );
|
3713
3978
|
if (!SWIG_IsOK(res1)) {
|
3714
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
3979
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "u_PropValue1 *","v_date", 1, self ));
|
3715
3980
|
}
|
3716
3981
|
arg1 = (u_PropValue1 *)(argp1);
|
3717
3982
|
{
|
3718
3983
|
res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_time_t, 0 );
|
3719
3984
|
if (!SWIG_IsOK(res2)) {
|
3720
|
-
SWIG_exception_fail(SWIG_ArgError(res2),
|
3985
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "time_t","v_date", 2, argv[0] ));
|
3721
3986
|
}
|
3722
3987
|
if (!argp2) {
|
3723
|
-
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "
|
3988
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "time_t","v_date", 2, argv[0]));
|
3724
3989
|
} else {
|
3725
3990
|
arg2 = *((time_t *)(argp2));
|
3726
3991
|
}
|
3727
3992
|
}
|
3728
3993
|
if (arg1) (arg1)->v_date = arg2;
|
3729
|
-
|
3730
3994
|
return Qnil;
|
3731
3995
|
fail:
|
3732
3996
|
return Qnil;
|
@@ -3736,9 +4000,9 @@ fail:
|
|
3736
4000
|
SWIGINTERN VALUE
|
3737
4001
|
_wrap_u_PropValue1_v_date_get(int argc, VALUE *argv, VALUE self) {
|
3738
4002
|
u_PropValue1 *arg1 = (u_PropValue1 *) 0 ;
|
3739
|
-
time_t result;
|
3740
4003
|
void *argp1 = 0 ;
|
3741
4004
|
int res1 = 0 ;
|
4005
|
+
time_t result;
|
3742
4006
|
VALUE vresult = Qnil;
|
3743
4007
|
|
3744
4008
|
if ((argc < 0) || (argc > 0)) {
|
@@ -3746,7 +4010,7 @@ _wrap_u_PropValue1_v_date_get(int argc, VALUE *argv, VALUE self) {
|
|
3746
4010
|
}
|
3747
4011
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_u_PropValue1, 0 | 0 );
|
3748
4012
|
if (!SWIG_IsOK(res1)) {
|
3749
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
4013
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "u_PropValue1 *","v_date", 1, self ));
|
3750
4014
|
}
|
3751
4015
|
arg1 = (u_PropValue1 *)(argp1);
|
3752
4016
|
result = ((arg1)->v_date);
|
@@ -3771,16 +4035,15 @@ _wrap_u_PropValue1_v_float_set(int argc, VALUE *argv, VALUE self) {
|
|
3771
4035
|
}
|
3772
4036
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_u_PropValue1, 0 | 0 );
|
3773
4037
|
if (!SWIG_IsOK(res1)) {
|
3774
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
4038
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "u_PropValue1 *","v_float", 1, self ));
|
3775
4039
|
}
|
3776
4040
|
arg1 = (u_PropValue1 *)(argp1);
|
3777
4041
|
ecode2 = SWIG_AsVal_double(argv[0], &val2);
|
3778
4042
|
if (!SWIG_IsOK(ecode2)) {
|
3779
|
-
SWIG_exception_fail(SWIG_ArgError(ecode2),
|
4043
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","v_float", 2, argv[0] ));
|
3780
4044
|
}
|
3781
4045
|
arg2 = (double)(val2);
|
3782
4046
|
if (arg1) (arg1)->v_float = arg2;
|
3783
|
-
|
3784
4047
|
return Qnil;
|
3785
4048
|
fail:
|
3786
4049
|
return Qnil;
|
@@ -3790,9 +4053,9 @@ fail:
|
|
3790
4053
|
SWIGINTERN VALUE
|
3791
4054
|
_wrap_u_PropValue1_v_float_get(int argc, VALUE *argv, VALUE self) {
|
3792
4055
|
u_PropValue1 *arg1 = (u_PropValue1 *) 0 ;
|
3793
|
-
double result;
|
3794
4056
|
void *argp1 = 0 ;
|
3795
4057
|
int res1 = 0 ;
|
4058
|
+
double result;
|
3796
4059
|
VALUE vresult = Qnil;
|
3797
4060
|
|
3798
4061
|
if ((argc < 0) || (argc > 0)) {
|
@@ -3800,7 +4063,7 @@ _wrap_u_PropValue1_v_float_get(int argc, VALUE *argv, VALUE self) {
|
|
3800
4063
|
}
|
3801
4064
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_u_PropValue1, 0 | 0 );
|
3802
4065
|
if (!SWIG_IsOK(res1)) {
|
3803
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
4066
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "u_PropValue1 *","v_float", 1, self ));
|
3804
4067
|
}
|
3805
4068
|
arg1 = (u_PropValue1 *)(argp1);
|
3806
4069
|
result = (double) ((arg1)->v_float);
|
@@ -3825,16 +4088,15 @@ _wrap_u_PropValue1_v_ulong_set(int argc, VALUE *argv, VALUE self) {
|
|
3825
4088
|
}
|
3826
4089
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_u_PropValue1, 0 | 0 );
|
3827
4090
|
if (!SWIG_IsOK(res1)) {
|
3828
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
4091
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "u_PropValue1 *","v_ulong", 1, self ));
|
3829
4092
|
}
|
3830
4093
|
arg1 = (u_PropValue1 *)(argp1);
|
3831
4094
|
ecode2 = SWIG_AsVal_unsigned_SS_long(argv[0], &val2);
|
3832
4095
|
if (!SWIG_IsOK(ecode2)) {
|
3833
|
-
SWIG_exception_fail(SWIG_ArgError(ecode2),
|
4096
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned long","v_ulong", 2, argv[0] ));
|
3834
4097
|
}
|
3835
4098
|
arg2 = (unsigned long)(val2);
|
3836
4099
|
if (arg1) (arg1)->v_ulong = arg2;
|
3837
|
-
|
3838
4100
|
return Qnil;
|
3839
4101
|
fail:
|
3840
4102
|
return Qnil;
|
@@ -3844,9 +4106,9 @@ fail:
|
|
3844
4106
|
SWIGINTERN VALUE
|
3845
4107
|
_wrap_u_PropValue1_v_ulong_get(int argc, VALUE *argv, VALUE self) {
|
3846
4108
|
u_PropValue1 *arg1 = (u_PropValue1 *) 0 ;
|
3847
|
-
unsigned long result;
|
3848
4109
|
void *argp1 = 0 ;
|
3849
4110
|
int res1 = 0 ;
|
4111
|
+
unsigned long result;
|
3850
4112
|
VALUE vresult = Qnil;
|
3851
4113
|
|
3852
4114
|
if ((argc < 0) || (argc > 0)) {
|
@@ -3854,7 +4116,7 @@ _wrap_u_PropValue1_v_ulong_get(int argc, VALUE *argv, VALUE self) {
|
|
3854
4116
|
}
|
3855
4117
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_u_PropValue1, 0 | 0 );
|
3856
4118
|
if (!SWIG_IsOK(res1)) {
|
3857
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
4119
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "u_PropValue1 *","v_ulong", 1, self ));
|
3858
4120
|
}
|
3859
4121
|
arg1 = (u_PropValue1 *)(argp1);
|
3860
4122
|
result = (unsigned long) ((arg1)->v_ulong);
|
@@ -3889,8 +4151,8 @@ _wrap_new_u_PropValue1(int argc, VALUE *argv, VALUE self) {
|
|
3889
4151
|
if ((argc < 0) || (argc > 0)) {
|
3890
4152
|
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
3891
4153
|
}
|
3892
|
-
result = (u_PropValue1 *)
|
3893
|
-
|
4154
|
+
result = (u_PropValue1 *)calloc(1, sizeof(u_PropValue1));
|
4155
|
+
DATA_PTR(self) = result;
|
3894
4156
|
return self;
|
3895
4157
|
fail:
|
3896
4158
|
return Qnil;
|
@@ -3902,7 +4164,7 @@ free_u_PropValue1(u_PropValue1 *arg1) {
|
|
3902
4164
|
free((char *) arg1);
|
3903
4165
|
}
|
3904
4166
|
|
3905
|
-
swig_class
|
4167
|
+
static swig_class SwigClassPropValue;
|
3906
4168
|
|
3907
4169
|
SWIGINTERN VALUE
|
3908
4170
|
_wrap_PropValue_datatype_set(int argc, VALUE *argv, VALUE self) {
|
@@ -3918,16 +4180,15 @@ _wrap_PropValue_datatype_set(int argc, VALUE *argv, VALUE self) {
|
|
3918
4180
|
}
|
3919
4181
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PropValue, 0 | 0 );
|
3920
4182
|
if (!SWIG_IsOK(res1)) {
|
3921
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
4183
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "PropValue *","datatype", 1, self ));
|
3922
4184
|
}
|
3923
4185
|
arg1 = (PropValue *)(argp1);
|
3924
4186
|
ecode2 = SWIG_AsVal_int(argv[0], &val2);
|
3925
4187
|
if (!SWIG_IsOK(ecode2)) {
|
3926
|
-
SWIG_exception_fail(SWIG_ArgError(ecode2),
|
4188
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "PropType","datatype", 2, argv[0] ));
|
3927
4189
|
}
|
3928
4190
|
arg2 = (PropType)(val2);
|
3929
4191
|
if (arg1) (arg1)->datatype = arg2;
|
3930
|
-
|
3931
4192
|
return Qnil;
|
3932
4193
|
fail:
|
3933
4194
|
return Qnil;
|
@@ -3937,9 +4198,9 @@ fail:
|
|
3937
4198
|
SWIGINTERN VALUE
|
3938
4199
|
_wrap_PropValue_datatype_get(int argc, VALUE *argv, VALUE self) {
|
3939
4200
|
PropValue *arg1 = (PropValue *) 0 ;
|
3940
|
-
PropType result;
|
3941
4201
|
void *argp1 = 0 ;
|
3942
4202
|
int res1 = 0 ;
|
4203
|
+
PropType result;
|
3943
4204
|
VALUE vresult = Qnil;
|
3944
4205
|
|
3945
4206
|
if ((argc < 0) || (argc > 0)) {
|
@@ -3947,7 +4208,7 @@ _wrap_PropValue_datatype_get(int argc, VALUE *argv, VALUE self) {
|
|
3947
4208
|
}
|
3948
4209
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PropValue, 0 | 0 );
|
3949
4210
|
if (!SWIG_IsOK(res1)) {
|
3950
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
4211
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "PropValue *","datatype", 1, self ));
|
3951
4212
|
}
|
3952
4213
|
arg1 = (PropValue *)(argp1);
|
3953
4214
|
result = (PropType) ((arg1)->datatype);
|
@@ -3972,16 +4233,15 @@ _wrap_PropValue_value_set(int argc, VALUE *argv, VALUE self) {
|
|
3972
4233
|
}
|
3973
4234
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PropValue, 0 | 0 );
|
3974
4235
|
if (!SWIG_IsOK(res1)) {
|
3975
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
4236
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "PropValue *","value", 1, self ));
|
3976
4237
|
}
|
3977
4238
|
arg1 = (PropValue *)(argp1);
|
3978
4239
|
res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_u_PropValue1, 0 | 0 );
|
3979
4240
|
if (!SWIG_IsOK(res2)) {
|
3980
|
-
SWIG_exception_fail(SWIG_ArgError(res2),
|
4241
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "u_PropValue1 *","value", 2, argv[0] ));
|
3981
4242
|
}
|
3982
4243
|
arg2 = (u_PropValue1 *)(argp2);
|
3983
4244
|
if (arg1) (arg1)->value = *arg2;
|
3984
|
-
|
3985
4245
|
return Qnil;
|
3986
4246
|
fail:
|
3987
4247
|
return Qnil;
|
@@ -3991,9 +4251,9 @@ fail:
|
|
3991
4251
|
SWIGINTERN VALUE
|
3992
4252
|
_wrap_PropValue_value_get(int argc, VALUE *argv, VALUE self) {
|
3993
4253
|
PropValue *arg1 = (PropValue *) 0 ;
|
3994
|
-
u_PropValue1 *result = 0 ;
|
3995
4254
|
void *argp1 = 0 ;
|
3996
4255
|
int res1 = 0 ;
|
4256
|
+
u_PropValue1 *result = 0 ;
|
3997
4257
|
VALUE vresult = Qnil;
|
3998
4258
|
|
3999
4259
|
if ((argc < 0) || (argc > 0)) {
|
@@ -4001,7 +4261,7 @@ _wrap_PropValue_value_get(int argc, VALUE *argv, VALUE self) {
|
|
4001
4261
|
}
|
4002
4262
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PropValue, 0 | 0 );
|
4003
4263
|
if (!SWIG_IsOK(res1)) {
|
4004
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
4264
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "PropValue *","value", 1, self ));
|
4005
4265
|
}
|
4006
4266
|
arg1 = (PropValue *)(argp1);
|
4007
4267
|
result = (u_PropValue1 *)& ((arg1)->value);
|
@@ -4026,16 +4286,15 @@ _wrap_PropValue_destroy_set(int argc, VALUE *argv, VALUE self) {
|
|
4026
4286
|
}
|
4027
4287
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PropValue, 0 | 0 );
|
4028
4288
|
if (!SWIG_IsOK(res1)) {
|
4029
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
4289
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "PropValue *","destroy", 1, self ));
|
4030
4290
|
}
|
4031
4291
|
arg1 = (PropValue *)(argp1);
|
4032
4292
|
ecode2 = SWIG_AsVal_int(argv[0], &val2);
|
4033
4293
|
if (!SWIG_IsOK(ecode2)) {
|
4034
|
-
SWIG_exception_fail(SWIG_ArgError(ecode2),
|
4294
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","destroy", 2, argv[0] ));
|
4035
4295
|
}
|
4036
4296
|
arg2 = (int)(val2);
|
4037
4297
|
if (arg1) (arg1)->destroy = arg2;
|
4038
|
-
|
4039
4298
|
return Qnil;
|
4040
4299
|
fail:
|
4041
4300
|
return Qnil;
|
@@ -4045,9 +4304,9 @@ fail:
|
|
4045
4304
|
SWIGINTERN VALUE
|
4046
4305
|
_wrap_PropValue_destroy_get(int argc, VALUE *argv, VALUE self) {
|
4047
4306
|
PropValue *arg1 = (PropValue *) 0 ;
|
4048
|
-
int result;
|
4049
4307
|
void *argp1 = 0 ;
|
4050
4308
|
int res1 = 0 ;
|
4309
|
+
int result;
|
4051
4310
|
VALUE vresult = Qnil;
|
4052
4311
|
|
4053
4312
|
if ((argc < 0) || (argc > 0)) {
|
@@ -4055,7 +4314,7 @@ _wrap_PropValue_destroy_get(int argc, VALUE *argv, VALUE self) {
|
|
4055
4314
|
}
|
4056
4315
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PropValue, 0 | 0 );
|
4057
4316
|
if (!SWIG_IsOK(res1)) {
|
4058
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
4317
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "PropValue *","destroy", 1, self ));
|
4059
4318
|
}
|
4060
4319
|
arg1 = (PropValue *)(argp1);
|
4061
4320
|
result = (int) ((arg1)->destroy);
|
@@ -4090,8 +4349,8 @@ _wrap_new_PropValue(int argc, VALUE *argv, VALUE self) {
|
|
4090
4349
|
if ((argc < 0) || (argc > 0)) {
|
4091
4350
|
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
4092
4351
|
}
|
4093
|
-
result = (PropValue *)
|
4094
|
-
|
4352
|
+
result = (PropValue *)calloc(1, sizeof(PropValue));
|
4353
|
+
DATA_PTR(self) = result;
|
4095
4354
|
return self;
|
4096
4355
|
fail:
|
4097
4356
|
return Qnil;
|
@@ -4108,13 +4367,13 @@ _wrap_getResultPropValue(int argc, VALUE *argv, VALUE self) {
|
|
4108
4367
|
SW_RESULT arg1 = (SW_RESULT) 0 ;
|
4109
4368
|
char *arg2 = (char *) 0 ;
|
4110
4369
|
int arg3 ;
|
4111
|
-
PropValue *result = 0 ;
|
4112
4370
|
int res1 ;
|
4113
4371
|
int res2 ;
|
4114
4372
|
char *buf2 = 0 ;
|
4115
4373
|
int alloc2 = 0 ;
|
4116
4374
|
int val3 ;
|
4117
4375
|
int ecode3 = 0 ;
|
4376
|
+
PropValue *result = 0 ;
|
4118
4377
|
VALUE vresult = Qnil;
|
4119
4378
|
|
4120
4379
|
if ((argc < 3) || (argc > 3)) {
|
@@ -4122,16 +4381,16 @@ _wrap_getResultPropValue(int argc, VALUE *argv, VALUE self) {
|
|
4122
4381
|
}
|
4123
4382
|
res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
|
4124
4383
|
if (!SWIG_IsOK(res1)) {
|
4125
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
4384
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SW_RESULT","getResultPropValue", 1, argv[0] ));
|
4126
4385
|
}
|
4127
4386
|
res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
|
4128
4387
|
if (!SWIG_IsOK(res2)) {
|
4129
|
-
SWIG_exception_fail(SWIG_ArgError(res2),
|
4388
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","getResultPropValue", 2, argv[1] ));
|
4130
4389
|
}
|
4131
4390
|
arg2 = (char *)(buf2);
|
4132
4391
|
ecode3 = SWIG_AsVal_int(argv[2], &val3);
|
4133
4392
|
if (!SWIG_IsOK(ecode3)) {
|
4134
|
-
SWIG_exception_fail(SWIG_ArgError(ecode3),
|
4393
|
+
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","getResultPropValue", 3, argv[2] ));
|
4135
4394
|
}
|
4136
4395
|
arg3 = (int)(val3);
|
4137
4396
|
result = (PropValue *)getResultPropValue(arg1,arg2,arg3);
|
@@ -4155,7 +4414,7 @@ _wrap_freeResultPropValue(int argc, VALUE *argv, VALUE self) {
|
|
4155
4414
|
}
|
4156
4415
|
res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_PropValue, 0 | 0 );
|
4157
4416
|
if (!SWIG_IsOK(res1)) {
|
4158
|
-
SWIG_exception_fail(SWIG_ArgError(res1),
|
4417
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "PropValue *","freeResultPropValue", 1, argv[0] ));
|
4159
4418
|
}
|
4160
4419
|
arg1 = (PropValue *)(argp1);
|
4161
4420
|
freeResultPropValue(arg1);
|
@@ -4175,10 +4434,10 @@ static swig_type_info _swigt__p_SWISH_HEADER_TYPE = {"_p_SWISH_HEADER_TYPE", "en
|
|
4175
4434
|
static swig_type_info _swigt__p_SWISH_HEADER_VALUE = {"_p_SWISH_HEADER_VALUE", "SWISH_HEADER_VALUE *", 0, 0, (void*)0, 0};
|
4176
4435
|
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
|
4177
4436
|
static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
|
4178
|
-
static swig_type_info _swigt__p_p_void = {"_p_p_void", "void
|
4437
|
+
static swig_type_info _swigt__p_p_void = {"_p_p_void", "SWISH_META_LIST|void **", 0, 0, (void*)0, 0};
|
4179
4438
|
static swig_type_info _swigt__p_time_t = {"_p_time_t", "time_t *", 0, 0, (void*)0, 0};
|
4180
4439
|
static swig_type_info _swigt__p_u_PropValue1 = {"_p_u_PropValue1", "u_PropValue1 *", 0, 0, (void*)0, 0};
|
4181
|
-
static swig_type_info _swigt__p_void = {"_p_void", "void *|SW_FUZZYWORD", 0, 0, (void*)0, 0};
|
4440
|
+
static swig_type_info _swigt__p_void = {"_p_void", "SW_SEARCH|SW_RESULT|SW_HANDLE|SW_RESULTS|void *|SW_FUZZYWORD", 0, 0, (void*)0, 0};
|
4182
4441
|
|
4183
4442
|
static swig_type_info *swig_type_initial[] = {
|
4184
4443
|
&_swigt__p_FILE,
|
@@ -4280,7 +4539,7 @@ SWIGRUNTIME void
|
|
4280
4539
|
SWIG_InitializeModule(void *clientdata) {
|
4281
4540
|
size_t i;
|
4282
4541
|
swig_module_info *module_head, *iter;
|
4283
|
-
int found;
|
4542
|
+
int found, init;
|
4284
4543
|
|
4285
4544
|
clientdata = clientdata;
|
4286
4545
|
|
@@ -4290,6 +4549,9 @@ SWIG_InitializeModule(void *clientdata) {
|
|
4290
4549
|
swig_module.type_initial = swig_type_initial;
|
4291
4550
|
swig_module.cast_initial = swig_cast_initial;
|
4292
4551
|
swig_module.next = &swig_module;
|
4552
|
+
init = 1;
|
4553
|
+
} else {
|
4554
|
+
init = 0;
|
4293
4555
|
}
|
4294
4556
|
|
4295
4557
|
/* Try and load any already created modules */
|
@@ -4318,6 +4580,12 @@ SWIG_InitializeModule(void *clientdata) {
|
|
4318
4580
|
module_head->next = &swig_module;
|
4319
4581
|
}
|
4320
4582
|
|
4583
|
+
/* When multiple interpeters are used, a module could have already been initialized in
|
4584
|
+
a different interpreter, but not yet have a pointer in this interpreter.
|
4585
|
+
In this case, we do not want to continue adding types... everything should be
|
4586
|
+
set up already */
|
4587
|
+
if (init == 0) return;
|
4588
|
+
|
4321
4589
|
/* Now work on filling in swig_module.types */
|
4322
4590
|
#ifdef SWIGRUNTIME_DEBUG
|
4323
4591
|
printf("SWIG_InitializeModule: size %d\n", swig_module.size);
|
@@ -4451,7 +4719,9 @@ SWIG_PropagateClientData(void) {
|
|
4451
4719
|
}
|
4452
4720
|
#endif
|
4453
4721
|
|
4722
|
+
/*
|
4454
4723
|
|
4724
|
+
*/
|
4455
4725
|
#ifdef __cplusplus
|
4456
4726
|
extern "C"
|
4457
4727
|
#endif
|
@@ -4467,7 +4737,6 @@ SWIGEXPORT void Init_swishe_base(void) {
|
|
4467
4737
|
}
|
4468
4738
|
|
4469
4739
|
SWIG_RubyInitializeTrackings();
|
4470
|
-
rb_define_const(mSwishe_base, "SEARCHSWISH_H", SWIG_From_int((int)(1)));
|
4471
4740
|
rb_define_const(mSwishe_base, "SWISH_NUMBER", SWIG_From_int((int)(SWISH_NUMBER)));
|
4472
4741
|
rb_define_const(mSwishe_base, "SWISH_STRING", SWIG_From_int((int)(SWISH_STRING)));
|
4473
4742
|
rb_define_const(mSwishe_base, "SWISH_LIST", SWIG_From_int((int)(SWISH_LIST)));
|
@@ -4476,21 +4745,21 @@ SWIGEXPORT void Init_swishe_base(void) {
|
|
4476
4745
|
rb_define_const(mSwishe_base, "SWISH_OTHER_DATA", SWIG_From_int((int)(SWISH_OTHER_DATA)));
|
4477
4746
|
rb_define_const(mSwishe_base, "SWISH_HEADER_ERROR", SWIG_From_int((int)(SWISH_HEADER_ERROR)));
|
4478
4747
|
|
4479
|
-
|
4480
|
-
SWIG_TypeClientData(SWIGTYPE_p_SWISH_HEADER_VALUE, (void *) &
|
4481
|
-
rb_define_alloc_func(
|
4482
|
-
rb_define_method(
|
4483
|
-
rb_define_method(
|
4484
|
-
rb_define_method(
|
4485
|
-
rb_define_method(
|
4486
|
-
rb_define_method(
|
4487
|
-
rb_define_method(
|
4488
|
-
rb_define_method(
|
4489
|
-
rb_define_method(
|
4490
|
-
rb_define_method(
|
4491
|
-
|
4492
|
-
|
4493
|
-
|
4748
|
+
SwigClassSWISH_HEADER_VALUE.klass = rb_define_class_under(mSwishe_base, "SWISH_HEADER_VALUE", rb_cObject);
|
4749
|
+
SWIG_TypeClientData(SWIGTYPE_p_SWISH_HEADER_VALUE, (void *) &SwigClassSWISH_HEADER_VALUE);
|
4750
|
+
rb_define_alloc_func(SwigClassSWISH_HEADER_VALUE.klass, _wrap_SWISH_HEADER_VALUE_allocate);
|
4751
|
+
rb_define_method(SwigClassSWISH_HEADER_VALUE.klass, "initialize", _wrap_new_SWISH_HEADER_VALUE, -1);
|
4752
|
+
rb_define_method(SwigClassSWISH_HEADER_VALUE.klass, "string=", _wrap_SWISH_HEADER_VALUE_string_set, -1);
|
4753
|
+
rb_define_method(SwigClassSWISH_HEADER_VALUE.klass, "string", _wrap_SWISH_HEADER_VALUE_string_get, -1);
|
4754
|
+
rb_define_method(SwigClassSWISH_HEADER_VALUE.klass, "string_list=", _wrap_SWISH_HEADER_VALUE_string_list_set, -1);
|
4755
|
+
rb_define_method(SwigClassSWISH_HEADER_VALUE.klass, "string_list", _wrap_SWISH_HEADER_VALUE_string_list_get, -1);
|
4756
|
+
rb_define_method(SwigClassSWISH_HEADER_VALUE.klass, "number=", _wrap_SWISH_HEADER_VALUE_number_set, -1);
|
4757
|
+
rb_define_method(SwigClassSWISH_HEADER_VALUE.klass, "number", _wrap_SWISH_HEADER_VALUE_number_get, -1);
|
4758
|
+
rb_define_method(SwigClassSWISH_HEADER_VALUE.klass, "boolean=", _wrap_SWISH_HEADER_VALUE_boolean_set, -1);
|
4759
|
+
rb_define_method(SwigClassSWISH_HEADER_VALUE.klass, "boolean", _wrap_SWISH_HEADER_VALUE_boolean_get, -1);
|
4760
|
+
SwigClassSWISH_HEADER_VALUE.mark = 0;
|
4761
|
+
SwigClassSWISH_HEADER_VALUE.destroy = (void (*)(void *)) free_SWISH_HEADER_VALUE;
|
4762
|
+
SwigClassSWISH_HEADER_VALUE.trackObjects = 0;
|
4494
4763
|
rb_define_module_function(mSwishe_base, "SwishHeaderNames", _wrap_SwishHeaderNames, -1);
|
4495
4764
|
rb_define_module_function(mSwishe_base, "SwishIndexNames", _wrap_SwishIndexNames, -1);
|
4496
4765
|
rb_define_module_function(mSwishe_base, "SwishHeaderValue", _wrap_SwishHeaderValue, -1);
|
@@ -4562,7 +4831,7 @@ SWIGEXPORT void Init_swishe_base(void) {
|
|
4562
4831
|
rb_define_module_function(mSwishe_base, "SwishWordsByLetter", _wrap_SwishWordsByLetter, -1);
|
4563
4832
|
rb_define_module_function(mSwishe_base, "SwishStemWord", _wrap_SwishStemWord, -1);
|
4564
4833
|
rb_define_module_function(mSwishe_base, "SwishFuzzyWord", _wrap_SwishFuzzyWord, -1);
|
4565
|
-
rb_define_module_function(mSwishe_base, "
|
4834
|
+
rb_define_module_function(mSwishe_base, "SwishFuzzy", _wrap_SwishFuzzy, -1);
|
4566
4835
|
rb_define_module_function(mSwishe_base, "SwishFuzzyWordList", _wrap_SwishFuzzyWordList, -1);
|
4567
4836
|
rb_define_module_function(mSwishe_base, "SwishFuzzyWordCount", _wrap_SwishFuzzyWordCount, -1);
|
4568
4837
|
rb_define_module_function(mSwishe_base, "SwishFuzzyWordError", _wrap_SwishFuzzyWordError, -1);
|
@@ -4576,37 +4845,37 @@ SWIGEXPORT void Init_swishe_base(void) {
|
|
4576
4845
|
rb_define_const(mSwishe_base, "PROP_DATE", SWIG_From_int((int)(PROP_DATE)));
|
4577
4846
|
rb_define_const(mSwishe_base, "PROP_ULONG", SWIG_From_int((int)(PROP_ULONG)));
|
4578
4847
|
|
4579
|
-
|
4580
|
-
SWIG_TypeClientData(SWIGTYPE_p_u_PropValue1, (void *) &
|
4581
|
-
rb_define_alloc_func(
|
4582
|
-
rb_define_method(
|
4583
|
-
rb_define_method(
|
4584
|
-
rb_define_method(
|
4585
|
-
rb_define_method(
|
4586
|
-
rb_define_method(
|
4587
|
-
rb_define_method(
|
4588
|
-
rb_define_method(
|
4589
|
-
rb_define_method(
|
4590
|
-
rb_define_method(
|
4591
|
-
rb_define_method(
|
4592
|
-
rb_define_method(
|
4593
|
-
|
4594
|
-
|
4595
|
-
|
4848
|
+
SwigClassU_PropValue1.klass = rb_define_class_under(mSwishe_base, "U_PropValue1", rb_cObject);
|
4849
|
+
SWIG_TypeClientData(SWIGTYPE_p_u_PropValue1, (void *) &SwigClassU_PropValue1);
|
4850
|
+
rb_define_alloc_func(SwigClassU_PropValue1.klass, _wrap_u_PropValue1_allocate);
|
4851
|
+
rb_define_method(SwigClassU_PropValue1.klass, "initialize", _wrap_new_u_PropValue1, -1);
|
4852
|
+
rb_define_method(SwigClassU_PropValue1.klass, "v_str=", _wrap_u_PropValue1_v_str_set, -1);
|
4853
|
+
rb_define_method(SwigClassU_PropValue1.klass, "v_str", _wrap_u_PropValue1_v_str_get, -1);
|
4854
|
+
rb_define_method(SwigClassU_PropValue1.klass, "v_int=", _wrap_u_PropValue1_v_int_set, -1);
|
4855
|
+
rb_define_method(SwigClassU_PropValue1.klass, "v_int", _wrap_u_PropValue1_v_int_get, -1);
|
4856
|
+
rb_define_method(SwigClassU_PropValue1.klass, "v_date=", _wrap_u_PropValue1_v_date_set, -1);
|
4857
|
+
rb_define_method(SwigClassU_PropValue1.klass, "v_date", _wrap_u_PropValue1_v_date_get, -1);
|
4858
|
+
rb_define_method(SwigClassU_PropValue1.klass, "v_float=", _wrap_u_PropValue1_v_float_set, -1);
|
4859
|
+
rb_define_method(SwigClassU_PropValue1.klass, "v_float", _wrap_u_PropValue1_v_float_get, -1);
|
4860
|
+
rb_define_method(SwigClassU_PropValue1.klass, "v_ulong=", _wrap_u_PropValue1_v_ulong_set, -1);
|
4861
|
+
rb_define_method(SwigClassU_PropValue1.klass, "v_ulong", _wrap_u_PropValue1_v_ulong_get, -1);
|
4862
|
+
SwigClassU_PropValue1.mark = 0;
|
4863
|
+
SwigClassU_PropValue1.destroy = (void (*)(void *)) free_u_PropValue1;
|
4864
|
+
SwigClassU_PropValue1.trackObjects = 0;
|
4596
4865
|
|
4597
|
-
|
4598
|
-
SWIG_TypeClientData(SWIGTYPE_p_PropValue, (void *) &
|
4599
|
-
rb_define_alloc_func(
|
4600
|
-
rb_define_method(
|
4601
|
-
rb_define_method(
|
4602
|
-
rb_define_method(
|
4603
|
-
rb_define_method(
|
4604
|
-
rb_define_method(
|
4605
|
-
rb_define_method(
|
4606
|
-
rb_define_method(
|
4607
|
-
|
4608
|
-
|
4609
|
-
|
4866
|
+
SwigClassPropValue.klass = rb_define_class_under(mSwishe_base, "PropValue", rb_cObject);
|
4867
|
+
SWIG_TypeClientData(SWIGTYPE_p_PropValue, (void *) &SwigClassPropValue);
|
4868
|
+
rb_define_alloc_func(SwigClassPropValue.klass, _wrap_PropValue_allocate);
|
4869
|
+
rb_define_method(SwigClassPropValue.klass, "initialize", _wrap_new_PropValue, -1);
|
4870
|
+
rb_define_method(SwigClassPropValue.klass, "datatype=", _wrap_PropValue_datatype_set, -1);
|
4871
|
+
rb_define_method(SwigClassPropValue.klass, "datatype", _wrap_PropValue_datatype_get, -1);
|
4872
|
+
rb_define_method(SwigClassPropValue.klass, "value=", _wrap_PropValue_value_set, -1);
|
4873
|
+
rb_define_method(SwigClassPropValue.klass, "value", _wrap_PropValue_value_get, -1);
|
4874
|
+
rb_define_method(SwigClassPropValue.klass, "destroy=", _wrap_PropValue_destroy_set, -1);
|
4875
|
+
rb_define_method(SwigClassPropValue.klass, "destroy", _wrap_PropValue_destroy_get, -1);
|
4876
|
+
SwigClassPropValue.mark = 0;
|
4877
|
+
SwigClassPropValue.destroy = (void (*)(void *)) free_PropValue;
|
4878
|
+
SwigClassPropValue.trackObjects = 0;
|
4610
4879
|
rb_define_module_function(mSwishe_base, "getResultPropValue", _wrap_getResultPropValue, -1);
|
4611
4880
|
rb_define_module_function(mSwishe_base, "freeResultPropValue", _wrap_freeResultPropValue, -1);
|
4612
4881
|
}
|